OpenGL/bullet.cpp at glew · zhiyb/OpenGL · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
#include <iostream>
#include <sstream>
#include <fstream>
#include <vector>
#include "bullet.h"
#include "helper.h"
#include "world.h"

using namespace std;
using namespace glm;

struct bullet_data_t bullet;

// Bullet physics
static btBroadphaseInterface* broadphase;
static btDefaultCollisionConfiguration* collisionConfiguration;
static btCollisionDispatcher* dispatcher;
static btSequentialImpulseConstraintSolver* solver;
static btDiscreteDynamicsWorld* dynamicsWorld;

static vector<btRigidBody *> rigidBodys;

void bulletInit()
{
	ifstream datafs(DATA_BULLET);
	if (!datafs) {
		cerr << "Cannot open bullet physics description file " DATA_BULLET << endl;
		return;
	}
	string line;
	while (getline(datafs, line)) {
		if (line.empty() || line.at(0) == '#')
			continue;
		istringstream ss(line);
		string item;
		ss >> item;
		if (!ss)
			continue;
		if (item == "Gravity")
			ss >> bullet.gravity;
		else {
			bullet_data_t::rigid_data_t data;
			ss >> data.restitution >> data.friction;
			ss >> data.lin_damping >> data.ang_damping;
			bullet.rigid[item] = data;
		}
	}

	// Set up world
	broadphase = new btDbvtBroadphase();
	collisionConfiguration = new btDefaultCollisionConfiguration();
	dispatcher = new btCollisionDispatcher(collisionConfiguration);
	solver = new btSequentialImpulseConstraintSolver;
	dynamicsWorld = new btDiscreteDynamicsWorld(dispatcher,broadphase,solver,collisionConfiguration);
	dynamicsWorld->setGravity(to_btVector3(bullet.gravity));
}

void bulletCleanup()
{
	for (btRigidBody *rigidBody: rigidBodys) {
		dynamicsWorld->removeRigidBody(rigidBody);
		delete rigidBody;
	}
	delete dynamicsWorld;
	delete solver;
	delete dispatcher;
	delete collisionConfiguration;
	delete broadphase;
}

void bulletUpdate(double diff)
{
	double step = 1.f / 240.f;
	dynamicsWorld->stepSimulation(diff == 0.f ? step : diff, 1.f / step, step);
}

void bulletAddRigidBody(btRigidBody *rigidBody)
{
	dynamicsWorld->addRigidBody(rigidBody);
	rigidBodys.push_back(rigidBody);
}

void bulletAddRigidBody(btRigidBody *rigidBody, const char *name)
{
	bullet_data_t::rigid_data_t &data = bullet.rigid[name];
	rigidBody->setRestitution(data.restitution);
	rigidBody->setFriction(data.friction);
	rigidBody->setDamping(data.lin_damping, data.ang_damping);
	bulletAddRigidBody(rigidBody);
}

void bulletUprightConstraint(btRigidBody *body)
{
	//body->setLinearFactor(btVector3(1, 0, 1));
	body->setAngularFactor(btVector3(0, 1, 0));
}

btVector3 bulletGetOrigin(btRigidBody *rigidBody)
{
	btTransform trans;
	rigidBody->getMotionState()->getWorldTransform(trans);
	return trans.getOrigin();
}

mat4 bulletGetMatrix(btRigidBody *rigidBody) {
	btTransform trans;
	rigidBody->getMotionState()->getWorldTransform(trans);
	mat4 matrix;
	trans.getOpenGLMatrix((btScalar *)&matrix);
	return matrix;
}