Compare commits
14 commits
0db091f76e
...
818aaf01a9
Author | SHA1 | Date | |
---|---|---|---|
Rémi Oudin | 818aaf01a9 | ||
Rémi Oudin | d8dafd3823 | ||
Rémi Oudin | d23f05de14 | ||
Rémi Oudin | 2afd89dbf3 | ||
Rémi Oudin | 6823552ee7 | ||
Rémi Oudin | 041a1236c0 | ||
Rémi Oudin | f6f789cc2e | ||
Rémi Oudin | 14f3b8afdf | ||
Rémi Oudin | 75fc077007 | ||
Rémi Oudin | aafbd8ec9c | ||
Rémi Oudin | 083bc3c654 | ||
Rémi Oudin | 538930bd71 | ||
Rémi Oudin | 15ee31c30e | ||
Rémi Oudin | d484a18da5 |
47
Ball.cpp
47
Ball.cpp
|
@ -5,10 +5,11 @@
|
||||||
bool bouncing = true;
|
bool bouncing = true;
|
||||||
double stop_bouncing;
|
double stop_bouncing;
|
||||||
|
|
||||||
Ball::Ball(const Point& _center, double _min_height, double _v_x, double _v_z,
|
Ball::Ball(const Point& _center, const Ground* _ground, double _min_height,
|
||||||
double _p, double _q) :
|
double _v_x, double _v_z, double _p, double _q) :
|
||||||
Center(_center),
|
Center(_center),
|
||||||
surface(_center, _min_height, _p, _q),
|
surface(_center, _min_height, _p, _q),
|
||||||
|
ground(_ground),
|
||||||
radius(_p),
|
radius(_p),
|
||||||
init_h(_center.y),
|
init_h(_center.y),
|
||||||
min_height(_min_height),
|
min_height(_min_height),
|
||||||
|
@ -24,24 +25,26 @@ Ball::Ball(const Point& _center, double _min_height, double _v_x, double _v_z,
|
||||||
}
|
}
|
||||||
|
|
||||||
void Ball::_compute_pos(double dt) {
|
void Ball::_compute_pos(double dt) {
|
||||||
|
double height = (*ground)(Center.x, Center.z);
|
||||||
if (bouncing) {
|
if (bouncing) {
|
||||||
Center.y = fmax(
|
Center.y = fmax(
|
||||||
min_height,
|
min_height + height,
|
||||||
A + B * crt_time - (G_CTE / 2) * crt_time * crt_time + min_height
|
A + B * crt_time - (G_CTE / 2) * crt_time * crt_time + min_height
|
||||||
);
|
);
|
||||||
} else {
|
} else {
|
||||||
double n_time = crt_time - stop_bouncing;
|
double n_time = crt_time - stop_bouncing;
|
||||||
double min_rad = radius - min_height;
|
double min_rad = radius - min_height;
|
||||||
Center.y = min_height + ((min_rad * (1.0 - exp(-n_time)) + min_rad )/2.) +
|
|
||||||
(min_rad - ((min_rad* (1- exp(-n_time)) + min_rad)/2.)) * sin(5. *
|
|
||||||
n_time);
|
|
||||||
v_x *= 0.8;
|
v_x *= 0.8;
|
||||||
v_z *= 0.8;
|
v_z *= 0.8;
|
||||||
|
Center.y = height + min_height + ((min_rad * (1.0 - exp(-n_time)) + min_rad )/2.) +
|
||||||
|
(min_rad - ((min_rad* (1- exp(-n_time)) + min_rad)/2.)) * sin(5. *
|
||||||
|
n_time);
|
||||||
}
|
}
|
||||||
Center.x += dt * v_x;
|
Center.x += dt * v_x;
|
||||||
Center.z += dt * v_z;
|
Center.z += dt * v_z;
|
||||||
|
std::cout << (*this) <<"\n";
|
||||||
surface.update_center_pos(Center);
|
surface.update_center_pos(Center);
|
||||||
surface.check_horizontal_plan_collision(0.0);
|
surface.check_ground_collision(ground);
|
||||||
}
|
}
|
||||||
|
|
||||||
void Ball::_compute_T_n() {
|
void Ball::_compute_T_n() {
|
||||||
|
@ -61,21 +64,23 @@ void Ball::_compute_U_n() {
|
||||||
}
|
}
|
||||||
|
|
||||||
void Ball::_compute_v_x(Point normal) {
|
void Ball::_compute_v_x(Point normal) {
|
||||||
double factor = normal.x / (4*(normal.x + normal.z));
|
double factor = 0;
|
||||||
|
if (normal.x + normal.z != 0) {
|
||||||
|
factor = normal.x / (4*(normal.x + normal.z));
|
||||||
|
}
|
||||||
v_x *= (0.5 + factor);
|
v_x *= (0.5 + factor);
|
||||||
}
|
}
|
||||||
|
|
||||||
void Ball::_compute_v_z(Point normal) {
|
void Ball::_compute_v_z(Point normal) {
|
||||||
double factor = normal.z / (4*(normal.x + normal.z));
|
double factor = 0;
|
||||||
|
if (normal.x + normal.z != 0) {
|
||||||
|
factor = normal.z / (4*(normal.x + normal.z));
|
||||||
|
}
|
||||||
v_z *= (0.5 + factor);
|
v_z *= (0.5 + factor);
|
||||||
}
|
}
|
||||||
|
|
||||||
void Ball::update_pos(double dt) {
|
void Ball::_compute_parameters() {
|
||||||
crt_time += dt;
|
Point normal = (*ground).get_normal(Center.x, Center.z);
|
||||||
if ((bouncing) && (crt_time >= T)) {
|
|
||||||
double old_t = T;
|
|
||||||
double max_t;
|
|
||||||
Point normal = surface.getNormalVector();
|
|
||||||
bounce_number += 1;
|
bounce_number += 1;
|
||||||
_compute_U_n();
|
_compute_U_n();
|
||||||
_compute_A_n();
|
_compute_A_n();
|
||||||
|
@ -85,6 +90,18 @@ void Ball::update_pos(double dt) {
|
||||||
_compute_v_z(normal);
|
_compute_v_z(normal);
|
||||||
min_height = fmin(radius, min_height + 0.2 * (radius - min_height));
|
min_height = fmin(radius, min_height + 0.2 * (radius - min_height));
|
||||||
std::cout << "U:" << U << "\n";
|
std::cout << "U:" << U << "\n";
|
||||||
|
std::cout << "B:" << B << "\n";
|
||||||
|
std::cout << "A:" << A << "\n";
|
||||||
|
std::cout << "T:" << T << "\n";
|
||||||
|
}
|
||||||
|
|
||||||
|
void Ball::update_pos(double dt) {
|
||||||
|
//double height = (*ground)(Center.x, Center.z);
|
||||||
|
crt_time += dt;
|
||||||
|
if ((bouncing) && (crt_time >= T)) {
|
||||||
|
double old_t = T;
|
||||||
|
double max_t;
|
||||||
|
_compute_parameters();
|
||||||
max_t = (T - old_t)/2.0 + old_t;
|
max_t = (T - old_t)/2.0 + old_t;
|
||||||
|
|
||||||
if (((A + B * max_t - (G_CTE / 2) * max_t * max_t + min_height) < radius)) {
|
if (((A + B * max_t - (G_CTE / 2) * max_t * max_t + min_height) < radius)) {
|
||||||
|
|
6
Ball.hpp
6
Ball.hpp
|
@ -12,6 +12,8 @@
|
||||||
#pragma once
|
#pragma once
|
||||||
#include <cstddef>
|
#include <cstddef>
|
||||||
#include "spheroid.hpp"
|
#include "spheroid.hpp"
|
||||||
|
#include "FlatGround.hpp"
|
||||||
|
#include "PerlinGround.hpp"
|
||||||
|
|
||||||
#define G_CTE 9.81
|
#define G_CTE 9.81
|
||||||
|
|
||||||
|
@ -19,6 +21,7 @@ class Ball {
|
||||||
private:
|
private:
|
||||||
Point Center;
|
Point Center;
|
||||||
Spheroid surface;
|
Spheroid surface;
|
||||||
|
const Ground* ground;
|
||||||
double radius;
|
double radius;
|
||||||
double init_h;
|
double init_h;
|
||||||
double min_height;
|
double min_height;
|
||||||
|
@ -27,6 +30,7 @@ class Ball {
|
||||||
double A, B, U, T; // Coefficients for the physical model.
|
double A, B, U, T; // Coefficients for the physical model.
|
||||||
double v_x, v_z;
|
double v_x, v_z;
|
||||||
void _compute_pos(double dt);
|
void _compute_pos(double dt);
|
||||||
|
void _compute_parameters();
|
||||||
void _compute_v_x(Point normal);
|
void _compute_v_x(Point normal);
|
||||||
void _compute_v_z(Point normal);
|
void _compute_v_z(Point normal);
|
||||||
void _compute_A_n();
|
void _compute_A_n();
|
||||||
|
@ -34,7 +38,7 @@ class Ball {
|
||||||
void _compute_U_n();
|
void _compute_U_n();
|
||||||
void _compute_T_n();
|
void _compute_T_n();
|
||||||
public:
|
public:
|
||||||
Ball(const Point& _center, double _min_height, double _v_x,
|
Ball(const Point& _center, const Ground* ground, double _min_height, double _v_x,
|
||||||
double _v_z, double p, double q);
|
double _v_z, double p, double q);
|
||||||
void update_pos(double dt);
|
void update_pos(double dt);
|
||||||
Point getCenter() const {return Center;}
|
Point getCenter() const {return Center;}
|
||||||
|
|
10
FlatGround.cpp
Normal file
10
FlatGround.cpp
Normal file
|
@ -0,0 +1,10 @@
|
||||||
|
#include "FlatGround.hpp"
|
||||||
|
|
||||||
|
|
||||||
|
double FlatGround::operator() (double, double) const {
|
||||||
|
return 0. ;
|
||||||
|
}
|
||||||
|
|
||||||
|
Point FlatGround::get_normal(double, double) const {
|
||||||
|
return Point(0, 1, 0);
|
||||||
|
}
|
8
FlatGround.hpp
Normal file
8
FlatGround.hpp
Normal file
|
@ -0,0 +1,8 @@
|
||||||
|
#pragma once
|
||||||
|
#include "Ground.hpp"
|
||||||
|
|
||||||
|
class FlatGround : public Ground {
|
||||||
|
public:
|
||||||
|
double operator() (double, double) const;
|
||||||
|
Point get_normal(double x, double y) const;
|
||||||
|
};
|
0
Ground.cpp
Normal file
0
Ground.cpp
Normal file
9
Ground.hpp
Normal file
9
Ground.hpp
Normal file
|
@ -0,0 +1,9 @@
|
||||||
|
#pragma once
|
||||||
|
|
||||||
|
#include "common_structures.hpp"
|
||||||
|
|
||||||
|
class Ground {
|
||||||
|
public:
|
||||||
|
virtual double operator() (double, double) const = 0;
|
||||||
|
virtual Point get_normal(double x, double y) const = 0;
|
||||||
|
};
|
3
Makefile
3
Makefile
|
@ -11,6 +11,9 @@ OBJS=Implicit.o \
|
||||||
Mesh.o \
|
Mesh.o \
|
||||||
spheroid.o \
|
spheroid.o \
|
||||||
Ball.o \
|
Ball.o \
|
||||||
|
Ground.o \
|
||||||
|
FlatGround.o \
|
||||||
|
PerlinGround.o \
|
||||||
PerlinNoise.o \
|
PerlinNoise.o \
|
||||||
util/ObjParser.o \
|
util/ObjParser.o \
|
||||||
MarchingCubes.o \
|
MarchingCubes.o \
|
||||||
|
|
|
@ -5,6 +5,8 @@
|
||||||
|
|
||||||
#include "GL/gl.h"
|
#include "GL/gl.h"
|
||||||
|
|
||||||
|
#include "GL/gl.h"
|
||||||
|
|
||||||
MarchingCubes::MarchingCubes(
|
MarchingCubes::MarchingCubes(
|
||||||
const ImplicitSurface& surface,
|
const ImplicitSurface& surface,
|
||||||
const Cuboid& box,
|
const Cuboid& box,
|
||||||
|
|
14
PerlinGround.cpp
Normal file
14
PerlinGround.cpp
Normal file
|
@ -0,0 +1,14 @@
|
||||||
|
#include "PerlinGround.hpp"
|
||||||
|
|
||||||
|
PerlinGround::PerlinGround() : surface(PerlinNoise()) {}
|
||||||
|
PerlinGround::PerlinGround(unsigned int seed) : surface(PerlinNoise(seed)) {}
|
||||||
|
|
||||||
|
double PerlinGround::operator() (double x, double z) const {
|
||||||
|
return surface.noise(x, z);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
Point PerlinGround::get_normal(double x, double z) const {
|
||||||
|
const Point pt(x, surface.noise(x, z), z);
|
||||||
|
return surface.normal_at(pt);
|
||||||
|
}
|
14
PerlinGround.hpp
Normal file
14
PerlinGround.hpp
Normal file
|
@ -0,0 +1,14 @@
|
||||||
|
#pragma once
|
||||||
|
#include "Ground.hpp"
|
||||||
|
#include "PerlinNoise.hpp"
|
||||||
|
|
||||||
|
class PerlinGround : public Ground {
|
||||||
|
public:
|
||||||
|
PerlinGround();
|
||||||
|
PerlinGround(unsigned int seed);
|
||||||
|
double operator() (double, double) const;
|
||||||
|
Point get_normal(double x, double y) const;
|
||||||
|
PerlinNoise* get_surface() { return &surface;}
|
||||||
|
private:
|
||||||
|
PerlinNoise surface;
|
||||||
|
};
|
|
@ -44,7 +44,7 @@ PerlinNoise::PerlinNoise(unsigned int seed) : ImplicitSurface(Point(0,0,0)) {
|
||||||
}
|
}
|
||||||
|
|
||||||
double PerlinNoise::operator() (double x, double y, double z) const {
|
double PerlinNoise::operator() (double x, double y, double z) const {
|
||||||
return z - noise(x, y, 0);
|
return (y - fBm(x, 0, z, 2, 0.3, 0.9));
|
||||||
}
|
}
|
||||||
|
|
||||||
double PerlinNoise::noise(double _x, double _y, double _z) const {
|
double PerlinNoise::noise(double _x, double _y, double _z) const {
|
||||||
|
@ -60,31 +60,31 @@ double PerlinNoise::noise(double _x, double _y, double _z) const {
|
||||||
double v = fade(_y);
|
double v = fade(_y);
|
||||||
double w = fade(_z);
|
double w = fade(_z);
|
||||||
|
|
||||||
int A = p[X] + Y;
|
int A = p[X] + Z;
|
||||||
int AA = p[A] + Z;
|
int AA = p[A] + Y;
|
||||||
int AB = p[A + 1] + Z;
|
int AB = p[A + 1] + Y;
|
||||||
int B = p[X + 1] + Y;
|
int B = p[X + 1] + Z;
|
||||||
int BA = p[B] + Z;
|
int BA = p[B] + Y;
|
||||||
int BB = p[B + 1] + Z;
|
int BB = p[B + 1] + Y;
|
||||||
|
|
||||||
double res = lerp(
|
double res = lerp(
|
||||||
w,
|
w,
|
||||||
lerp(
|
lerp(
|
||||||
v,
|
v,
|
||||||
lerp(u, grad(p[AA], _x, _y, _z), grad(p[BA], _x-1, _y, _z)),
|
lerp(u, grad(p[AA], _x, _z, _y), grad(p[BA], _x-1, _z, _y)),
|
||||||
lerp(u, grad(p[AB], _x, _y-1, _z), grad(p[BB], _x-1, _y-1, _z))
|
lerp(u, grad(p[AB], _x, _z-1, _y), grad(p[BB], _x-1, _z-1, _y))
|
||||||
),
|
),
|
||||||
lerp(
|
lerp(
|
||||||
v,
|
v,
|
||||||
lerp(
|
lerp(
|
||||||
u,
|
u,
|
||||||
grad(p[AA+1], _x, _y, _z-1),
|
grad(p[AA+1], _x, _z, _y-1),
|
||||||
grad(p[BA+1], _x-1, _y, _z-1)
|
grad(p[BA+1], _x-1, _z, _y-1)
|
||||||
),
|
),
|
||||||
lerp(
|
lerp(
|
||||||
u,
|
u,
|
||||||
grad(p[AB+1], _x, _y-1, _z-1),
|
grad(p[AB+1], _x, _z-1, _y-1),
|
||||||
grad(p[BB+1], _x-1, _y-1, _z-1)
|
grad(p[BB+1], _x-1, _z-1, _y-1)
|
||||||
)
|
)
|
||||||
)
|
)
|
||||||
);
|
);
|
||||||
|
@ -92,7 +92,7 @@ double PerlinNoise::noise(double _x, double _y, double _z) const {
|
||||||
}
|
}
|
||||||
|
|
||||||
double PerlinNoise::noise(double _x, double _y) const {
|
double PerlinNoise::noise(double _x, double _y) const {
|
||||||
return noise(_x, _y, 0);
|
return noise(_x, 0, _y);
|
||||||
}
|
}
|
||||||
|
|
||||||
double PerlinNoise::fade(double t) const {
|
double PerlinNoise::fade(double t) const {
|
||||||
|
@ -111,6 +111,21 @@ double PerlinNoise::grad(int hash, double x, double y, double z) const {
|
||||||
return ((h & 1) == 0 ? u : -u) + ((h & 2) == 0 ? v : -v);
|
return ((h & 1) == 0 ? u : -u) + ((h & 2) == 0 ? v : -v);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
double PerlinNoise::fBm(double x, double y, double z, int octaves, double
|
||||||
|
lacunarity, double gain) const {
|
||||||
|
double amplitude = 1.0;
|
||||||
|
double frequency = 1.0;
|
||||||
|
double sum = 0.0;
|
||||||
|
for(int i = 0; i < octaves; ++i)
|
||||||
|
{
|
||||||
|
// sum += amplitude * (1-abs(noise(x * frequency, y * frequency, z * frequency)));
|
||||||
|
sum += amplitude * noise(x * frequency, y * frequency, z * frequency);
|
||||||
|
amplitude *= gain;
|
||||||
|
frequency *= lacunarity;
|
||||||
|
}
|
||||||
|
return sum;
|
||||||
|
}
|
||||||
|
|
||||||
Point PerlinNoise::normal_vector(double x, double y) {
|
Point PerlinNoise::normal_vector(double x, double y) {
|
||||||
double n_x_y = noise(x, y, 0);
|
double n_x_y = noise(x, y, 0);
|
||||||
double n_dx_y = noise(x + 0.01, y, 0);
|
double n_dx_y = noise(x + 0.01, y, 0);
|
||||||
|
|
|
@ -1,6 +1,7 @@
|
||||||
/**
|
/**
|
||||||
* Perlin Noise implementation for the ground (header file)
|
* Perlin Noise implementation for the ground (header file)
|
||||||
**/
|
**/
|
||||||
|
#pragma once
|
||||||
#include "Implicit.hpp"
|
#include "Implicit.hpp"
|
||||||
#include <cmath>
|
#include <cmath>
|
||||||
#include <random>
|
#include <random>
|
||||||
|
@ -15,6 +16,8 @@ class PerlinNoise : public ImplicitSurface {
|
||||||
double operator() (double _x, double _y, double _z) const;
|
double operator() (double _x, double _y, double _z) const;
|
||||||
double noise(double x, double y) const;
|
double noise(double x, double y) const;
|
||||||
Point normal_vector(double x, double y);
|
Point normal_vector(double x, double y);
|
||||||
|
double fBm(double x, double y, double z, int octaves, double
|
||||||
|
lacunarity, double gain) const;
|
||||||
|
|
||||||
virtual Point location_hint() const;
|
virtual Point location_hint() const;
|
||||||
Point location_hint(double x, double z) const;
|
Point location_hint(double x, double z) const;
|
||||||
|
|
|
@ -5,13 +5,16 @@
|
||||||
#include "Ball.hpp"
|
#include "Ball.hpp"
|
||||||
#include <cstdio>
|
#include <cstdio>
|
||||||
#include <iostream>
|
#include <iostream>
|
||||||
|
#include "FlatGround.hpp"
|
||||||
|
|
||||||
using namespace std;
|
using namespace std;
|
||||||
|
|
||||||
int main() {
|
int main() {
|
||||||
int i;
|
int i;
|
||||||
Point center(0,10,0);
|
Point center(0,10,0);
|
||||||
Ball ball(center, 0, 0.25, 0, 1, 1);
|
FlatGround* flat = new FlatGround();
|
||||||
|
|
||||||
|
Ball ball(center,flat, 0, 0.25, 0, 1, 1);
|
||||||
for(i=0; i< 10000; i++) {
|
for(i=0; i< 10000; i++) {
|
||||||
ball.update_pos(0.001);
|
ball.update_pos(0.001);
|
||||||
cout << ball << "\n";
|
cout << ball << "\n";
|
||||||
|
|
|
@ -4,17 +4,21 @@
|
||||||
|
|
||||||
#include "render/GlutRender.hpp"
|
#include "render/GlutRender.hpp"
|
||||||
#include "Ball.hpp"
|
#include "Ball.hpp"
|
||||||
|
#include "FlatGround.hpp"
|
||||||
#include "MarchingCubes.hpp"
|
#include "MarchingCubes.hpp"
|
||||||
|
|
||||||
#include "periodic_updates.hpp"
|
#include "periodic_updates.hpp"
|
||||||
|
|
||||||
int main(int argc, char** argv) {
|
int main(int argc, char** argv) {
|
||||||
|
|
||||||
|
FlatGround* flat = new FlatGround();
|
||||||
GlutRender& render = GlutRender::get_instance();
|
GlutRender& render = GlutRender::get_instance();
|
||||||
render.init(&argc, argv, 640, 480, "Bouncing stuff");
|
render.init(&argc, argv, 640, 480, "Bouncing stuff");
|
||||||
|
|
||||||
Ball ball(Point(0, 5, 0), 0.75, -.5, -.7, 1, 1);
|
Ball ball(Point(0, 5, 0), flat, 0.75, -0.5, -0.7, 1, 1);
|
||||||
|
|
||||||
Cuboid bbox = ball.get_surface()->max_bounding_box();
|
Cuboid bbox = ball.get_surface()->max_bounding_box();
|
||||||
|
Cuboid bbox_2(Point(-2, -1, -2), Point(2,1,2));
|
||||||
printf("%.2lf %.2lf %.2lf | %.2lf %.2lf %.2lf\n",
|
printf("%.2lf %.2lf %.2lf | %.2lf %.2lf %.2lf\n",
|
||||||
bbox.low(0), bbox.low(1), bbox.low(2),
|
bbox.low(0), bbox.low(1), bbox.low(2),
|
||||||
bbox.high(0), bbox.high(1), bbox.high(2));
|
bbox.high(0), bbox.high(1), bbox.high(2));
|
||||||
|
|
35
spheroid.cpp
35
spheroid.cpp
|
@ -6,7 +6,7 @@
|
||||||
#include <iostream>
|
#include <iostream>
|
||||||
|
|
||||||
Spheroid::Spheroid(const Point& _center, double _min_p, double _p, double _q) :
|
Spheroid::Spheroid(const Point& _center, double _min_p, double _p, double _q) :
|
||||||
ImplicitSurface(_center), normal_vector(Point(0,0,1)), min_p(_min_p),
|
ImplicitSurface(_center), min_p(_min_p),
|
||||||
init_p(_p), p(_p), q(_q), stiffness(0)
|
init_p(_p), p(_p), q(_q), stiffness(0)
|
||||||
{
|
{
|
||||||
_compute_volume();
|
_compute_volume();
|
||||||
|
@ -22,35 +22,19 @@ void Spheroid::update_radius() {
|
||||||
q = sqrt((3./4.) * V / PI / p);
|
q = sqrt((3./4.) * V / PI / p);
|
||||||
}
|
}
|
||||||
|
|
||||||
void Spheroid::update_height() {
|
|
||||||
q = (3./4.) * V / PI / (p*p);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
void Spheroid::update_center_pos(Point& _center) {
|
void Spheroid::update_center_pos(Point& _center) {
|
||||||
center = _center;
|
center = _center;
|
||||||
}
|
}
|
||||||
|
|
||||||
void Spheroid::check_horizontal_plan_collision(double height) {
|
void Spheroid::check_ground_collision(const Ground* ground) {
|
||||||
if (((center.y - p) <= height) || (p < init_p)) {
|
double height = (*ground)(center.x, center.z);
|
||||||
p = fmin(init_p, center.y-height);
|
if (((center.y -p) <= height) || (p < init_p)) {
|
||||||
|
p = fmin(init_p, center.y - height);
|
||||||
update_radius();
|
update_radius();
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void Spheroid::check_vertical_plan_collision(double& abscissa) {
|
|
||||||
if (center.x <= abscissa) {
|
|
||||||
if ((center.x + q) >= abscissa) {
|
|
||||||
q = abscissa - center.x;
|
|
||||||
update_height();
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
if ((center.x - q) <= abscissa) {
|
|
||||||
q = center.x - abscissa;
|
|
||||||
update_height();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
Cuboid Spheroid::max_bounding_box() const {
|
Cuboid Spheroid::max_bounding_box() const {
|
||||||
double max_radius = sqrt((3./4.) * V / PI / min_p);
|
double max_radius = sqrt((3./4.) * V / PI / min_p);
|
||||||
|
@ -60,15 +44,6 @@ Cuboid Spheroid::max_bounding_box() const {
|
||||||
return Cuboid(_bd1, _bd2);
|
return Cuboid(_bd1, _bd2);
|
||||||
}
|
}
|
||||||
|
|
||||||
void Spheroid::check_perlin_collision(PerlinNoise perlin) {
|
|
||||||
double height = perlin.noise(center.x, center.z);
|
|
||||||
if ((center.y - p) <= height) {
|
|
||||||
p = fmin(init_p, center.z- height );
|
|
||||||
normal_vector = perlin.normal_vector(center.x, center.z);
|
|
||||||
update_radius();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
double Spheroid::operator() (double _x, double _y, double _z) const {
|
double Spheroid::operator() (double _x, double _y, double _z) const {
|
||||||
return (pow(_x, 2) / pow(q, 2)
|
return (pow(_x, 2) / pow(q, 2)
|
||||||
|
|
|
@ -8,6 +8,8 @@
|
||||||
#include "Implicit.hpp"
|
#include "Implicit.hpp"
|
||||||
#include "common_structures.hpp"
|
#include "common_structures.hpp"
|
||||||
#include "PerlinNoise.hpp"
|
#include "PerlinNoise.hpp"
|
||||||
|
#include "FlatGround.hpp"
|
||||||
|
#include "PerlinGround.hpp"
|
||||||
|
|
||||||
const double PI = 3.141592653589793;
|
const double PI = 3.141592653589793;
|
||||||
|
|
||||||
|
@ -16,12 +18,9 @@ class Spheroid : public ImplicitSurface {
|
||||||
Spheroid(const Point& _center, double _min_p, double _p, double _q);
|
Spheroid(const Point& _center, double _min_p, double _p, double _q);
|
||||||
void update_center_pos(Point& _center);
|
void update_center_pos(Point& _center);
|
||||||
void update_radius();
|
void update_radius();
|
||||||
void update_height();
|
void check_ground_collision(const Ground* ground);
|
||||||
void check_horizontal_plan_collision(double height);
|
|
||||||
void check_vertical_plan_collision(double& abscissa);
|
|
||||||
Cuboid max_bounding_box() const;
|
Cuboid max_bounding_box() const;
|
||||||
void check_perlin_collision(PerlinNoise perlin);
|
void check_perlin_collision(PerlinNoise perlin);
|
||||||
Point getNormalVector() const { return normal_vector;}
|
|
||||||
double operator() (double _x, double _y, double _z) const;
|
double operator() (double _x, double _y, double _z) const;
|
||||||
|
|
||||||
virtual Point location_hint() const;
|
virtual Point location_hint() const;
|
||||||
|
@ -32,7 +31,6 @@ class Spheroid : public ImplicitSurface {
|
||||||
* V is the volume. Extremely useful to have a constant volume in the
|
* V is the volume. Extremely useful to have a constant volume in the
|
||||||
* ball
|
* ball
|
||||||
**/
|
**/
|
||||||
Point normal_vector;
|
|
||||||
double min_p, init_p, p, q;
|
double min_p, init_p, p, q;
|
||||||
size_t stiffness;
|
size_t stiffness;
|
||||||
double V;
|
double V;
|
||||||
|
|
Loading…
Reference in a new issue