static void ENTITY_ComputeMinMaxNode(scene_node_t * node) {
unsigned int i;
/* Figure out the min/max if it's a mesh */
if (node->type == NODE_TYPE_STATIC_MESH) {
ENTITY_ComputeMinMaxMesh(node->object.mesh);
node->bounding_box.min[0] = node->object.mesh->bounding_box.min[0];
node->bounding_box.min[1] = node->object.mesh->bounding_box.min[1];
node->bounding_box.min[2] = node->object.mesh->bounding_box.min[2];
node->bounding_box.max[0] = node->object.mesh->bounding_box.max[0];
node->bounding_box.max[1] = node->object.mesh->bounding_box.max[1];
node->bounding_box.max[2] = node->object.mesh->bounding_box.max[2];
} else {
/* Reset self */
vectorSet(node->bounding_box.min, 0, 0, 0);
vectorSet(node->bounding_box.max, 0, 0, 0);
}
/* Compute child first */
for (i = 0; i < node->num_children; i++) {
ENTITY_ComputeMinMaxNode(node->child[i]);
node->bounding_box.min[0] = MIN(node->bounding_box.min[0], node->child[i]->bounding_box.min[0]);
node->bounding_box.min[1] = MIN(node->bounding_box.min[1], node->child[i]->bounding_box.min[1]);
node->bounding_box.min[2] = MIN(node->bounding_box.min[2], node->child[i]->bounding_box.min[2]);
node->bounding_box.max[0] = MAX(node->bounding_box.max[0], node->child[i]->bounding_box.max[0]);
node->bounding_box.max[1] = MAX(node->bounding_box.max[1], node->child[i]->bounding_box.max[1]);
node->bounding_box.max[2] = MAX(node->bounding_box.max[2], node->child[i]->bounding_box.max[2]);
}
}
void Camera::reset(void){
cameraSpeed = 0.005f;
cameraTurnSpeed = 0.01f;
vectorSet(position, 0.764331460f, -1.66760659f, 0.642456770);
vectorSet(forwardVec, -0.398769796f, 0.763009906f, -0.508720219f);
vectorSet(rightVec, 0.886262059f, 0.463184059f, 0.000000000f);
vectorSet(upVec, -0.235630989f, 0.450859368f, 0.860931039f);
}
/*--------------------------------------------------------------------*/
static MATRIX uFromAngles(double om, double sgu, double sgl){
MATRIX u;
u = makeVector();
if(u == NULL){
return NULL;
}
vectorSet(u,0,-Cosd(sgl)*Cosd(om));
vectorSet(u,1,Cosd(sgu)*Sind(om) - Sind(sgu)*Sind(sgl)*Cosd(om));
vectorSet(u,2,-Sind(sgu)*Sind(om) - Cosd(sgu)*Sind(sgl)*Cosd(om));
return u;
}
/*-----------------------------------------------------------------------------*/
static MATRIX tasReflectionToQC(tasQEPosition r, MATRIX UB){
MATRIX Q, QC;
Q = makeVector();
if(Q == NULL){
return NULL;
}
vectorSet(Q,0,r.qh);
vectorSet(Q,1,r.qk);
vectorSet(Q,2,r.ql);
QC = mat_mul(UB,Q);
killVector(Q);
return QC;
}
/*==================== reciprocal space ==============================*/
static MATRIX tasReflectionToHC(tasQEPosition r, MATRIX B){
MATRIX h = NULL, hc = NULL;
h = makeVector();
if(h == NULL){
return NULL;
}
vectorSet(h,0,r.qh);
vectorSet(h,1,r.qk);
vectorSet(h,2,r.ql);
hc = mat_mul(B,h);
killVector(h);
return hc;
}
//*************************************************************************************************
// Vector suite
//*************************************************************************************************
void vectorSuite(SUINT& errors, SUINT& tests)
{
errors += vectorInit(tests);
errors += vectorSet(tests);
TestVectorCompareEqual(errors, tests);
TestVectorCompareNotEqual(errors, tests);
}
static void ENTITY_ComputeMinMaxMesh(mesh_t * mesh) {
unsigned int i;
vectorSet(mesh->bounding_box.max, 0, 0, 0);
vectorSet(mesh->bounding_box.min, 0, 0, 0);
for (i = 0; i < mesh->num_verticies; i++) {
mesh->bounding_box.min[0] = MIN(mesh->bounding_box.min[0], mesh->vertices[i].position[0]);
mesh->bounding_box.min[1] = MIN(mesh->bounding_box.min[1], mesh->vertices[i].position[1]);
mesh->bounding_box.min[2] = MIN(mesh->bounding_box.min[2], mesh->vertices[i].position[2]);
mesh->bounding_box.max[0] = MAX(mesh->bounding_box.max[0], mesh->vertices[i].position[0]);
mesh->bounding_box.max[1] = MAX(mesh->bounding_box.max[1], mesh->vertices[i].position[1]);
mesh->bounding_box.max[2] = MAX(mesh->bounding_box.max[2], mesh->vertices[i].position[2]);
}
}
void Mesh::createVertexnormals(void) {
int i, j, ii;
bool connect;
float normal[3];
for (i = 0; i < vertexcount; i++) {
bool found = false;
vectorSet(normal, 0, 0, 0);
for (j = 0; j < polygoncount; j++) {
connect = false;
class Polygon *polygon = &polygons[j];
for (ii = 0; ii < polygon->vertexcount; ii++) {
if (polygons[j].vertices[ii] == &(vertices[i])) {
connect = true;
}
}
if (connect) {
vectorAdd(normal, polygon->planenormal);
found = true;
}
}
if (found) {
vectorNormalize(vertices[i].normal, normal);
}
}
for (j = 0; j < polygoncount; j++) {
class Polygon *polygon = &polygons[j];
if (!polygon->realsmooth)
polygon->smooth = true;
}
}
void* vectorRemoveReorder (vector* v, int n) {
if (v->length <= n)
return 0;
void* last = vectorPop(v);
vectorSet(v, n, last);
return last;
}
void vectorRemove(Vector *pVector, int index){
#ifdef DEBUG_ON
// Check if out of bounds
if (index < 0 || index >= pVector->size){
printf("'vectorRemove' - Index %d is out of bounds for vector of size %d\n", index, pVector->size);
}
#endif
// Check usage and halves vector if usage is <= 50%
vectorHalfCapacityIfNotUsed(pVector);
// Remove value att index position
vectorFreeValue(pVector->data[index]);
// Move all values whos index is larger than 'index' one lower (element 4 becomes 5, 5 becomes 6, and so on)
for (int i = index; i < (pVector->size - 1); i++){
vectorSet(pVector, i, pVector->data[i + 1]);
}
// Decrement vector->size and set last value to NULL
vectorSet(pVector, (pVector->size--), NULL);
}
//
// Moves all values one step higer from index position and inserts the new value at index
//
void vectorInsert(Vector *pVector, int index, void* *value, int sizeOfElem){
#ifdef DEBUG_ON
// Check if out of bounds
if (index < 0 || index >= pVector->size){
printf("'vectorInsert' - Index %d is out of bounds for vector of size %d\n", index, pVector->size);
}
#endif
// Make the vector one element larger to make room for the new value
pVector->size++;
vectorDoubleCapacityIfFull(pVector);
// Move all values whos index is larger than 'index' one higher (element 5 becomes 4, 4 becomes 3, and so on)
for (int i = (pVector->size - 1); i > index; i--){
vectorSet(pVector, i, pVector->data[i - 1]);
}
// Save the value at a new adress
void* ptr = vectorCopyValue(value, sizeOfElem);
// Save the new adress in the vector
vectorSet(pVector, index, ptr);
}
Vertex::Vertex(void) {
vectorSet(position, 0, 0, 0);
vectorSet(normal, 0, 0, 0);
}
Vertex::Vertex(float x, float y, float z, float nx, float ny, float nz) {
vectorSet(position, x, y, z);
vectorSet(normal, nx, ny, nz);
}
bool MeshShape::checkCollisionPeer(MeshShape *target) {
float normal[3];
float contactpoint[3];
bool collided = false;
int i;
Mesh *sourcemesh, *targetmesh;
sourcemesh = this->mesh;
targetmesh = target->mesh;
for (i = 0; i < sourcemesh->vertexcount; i++) {
Vertex *vertex = &sourcemesh->vertices[i];
float vertexposition[3];
object->transformPoint(vertexposition, vertex->position);
target->object->unTransformPoint(vertexposition, vertexposition);
if (checkPointMeshCollision(vertexposition, targetmesh, normal,
contactpoint)) {
target->object->transformVector(normal, normal);
target->object->transformPoint(contactpoint, contactpoint);
if (vectorIsZero(contactpoint)) {
vectorSet(contactpoint, 0, 0, 0);
}
addCollision(object, target->object, normal, contactpoint);
collided = true;
}
}
sourcemesh = target->mesh;
targetmesh = this->mesh;
for (i = 0; i < sourcemesh->vertexcount; i++) {
Vertex *vertex = &sourcemesh->vertices[i];
float vertexposition[3];
target->object->transformPoint(vertexposition, vertex->position);
object->unTransformPoint(vertexposition, vertexposition);
if (checkPointMeshCollision(vertexposition, targetmesh, normal,
contactpoint)) {
object->transformVector(normal, normal);
object->transformPoint(contactpoint, contactpoint);
addCollision(target->object, object, normal, contactpoint);
collided = true;
}
}
sourcemesh = this->mesh;
targetmesh = target->mesh;
for (i = 0; i < sourcemesh->edgecount; i++) {
Edge *edge = &sourcemesh->edges[i];
float v1[3], v2[3];
object->transformPoint(v1, edge->v1->position);
target->object->unTransformPoint(v1, v1);
object->transformPoint(v2, edge->v2->position);
target->object->unTransformPoint(v2, v2);
if (checkEdgeMeshCollision(v1, v2, targetmesh, normal, contactpoint)) {
target->object->transformVector(normal, normal);
target->object->transformPoint(contactpoint, contactpoint);
addCollision(object, target->object, normal, contactpoint);
collided = true;
}
}
return collided;
}
void vectorDeletePos(vector_t *vec, size_t pos)
{
vectorSet(vec, pos, NONE_VALUE, P_NONE);
}
Vertex::Vertex(float x, float y, float z) {
vectorSet(position, x, y, z);
vectorSet(normal, x, y, z);
vectorNormalize(normal);
}
bool handleCollision(Contact *contact) {
Object *source = contact->object1;
Object *target = contact->object2;
float *normal = contact->normal;
float *contactpoint = contact->position;
float sourcevelocity[3], targetvelocity[3];
float sourcecontactpoint[3], targetcontactpoint[3];
vectorSub(sourcecontactpoint, contactpoint, source->position);
source->getVelocity(sourcevelocity, sourcecontactpoint);
if (target == NULL) {
vectorSet(targetcontactpoint, 0, 0, 0);
vectorSet(targetvelocity, 0, 0, 0);
} else {
vectorSub(targetcontactpoint, contactpoint, target->position);
target->getVelocity(targetvelocity, targetcontactpoint);
}
float deltavelocity[3];
vectorSub(deltavelocity, sourcevelocity, targetvelocity);
float dot = vectorDot(deltavelocity, normal);
// if (fabs(dot) < EPSILON) return false;
// if (dot > -1.0e-5 && dot < 1.0e-5) return false;
// if (dot >= 0) return false;
if (dot > -1.0e-5)
return false;
float invmass1;
invmass1 = source->invmass;
float invmass2;
if (target == NULL)
invmass2 = 0;
else
invmass2 = target->invmass;
float t1;
if (source->invmomentofinertia == 0) {
t1 = 0;
} else {
float v1[3];
vectorCross(v1, sourcecontactpoint, normal);
vectorScale(v1, source->invmomentofinertia);
float w1[3];
vectorCross(w1, v1, sourcecontactpoint);
t1 = vectorDot(normal, w1);
}
float t2;
if (target == NULL || target->invmomentofinertia == 0) {
t2 = 0;
} else {
float v1[3];
vectorCross(v1, targetcontactpoint, normal);
vectorScale(v1, target->invmomentofinertia);
float w1[3];
vectorCross(w1, v1, targetcontactpoint);
t2 = vectorDot(normal, w1);
}
float denominator = invmass1 + invmass2 + t1 + t2;
float e = 1.0 - COLLISIONFRICTION;
float impulsesize = (1 + e) * dot / denominator;
// printf("%f\n", impulsesize);
float impulse[3];
vectorScale(impulse, normal, impulsesize);
float friction[3];
vectorScale(friction, normal, vectorDot(deltavelocity, normal));
vectorAdd(friction, deltavelocity);
vectorNormalize(friction);
float frictionsize = 10 * KINETICFRICTION * dot / denominator;
float maxfrictionsize = 0.1 * vectorLength(deltavelocity);
if (frictionsize < -maxfrictionsize)
frictionsize = -maxfrictionsize;
vectorScale(friction, -frictionsize);
vectorAdd(impulse, friction);
if (target != NULL) {
target->addImpulse(impulse, targetcontactpoint);
target->calculateStateVariables();
}
float speed;
float speed2[3];
if (target != NULL && source != NULL) {
// float kvel[3];
// source->getVelocity(kvel);
float k = vectorLength(sourcevelocity) * 0.1;
// if (k > 1) k = 1;
speed = -impulsesize * target->invmass * k;
vectorScale(speed2, impulse, target->invmass * k);
/*float kvel[3];
source->getVelocity(kvel);
float k = 0;//vectorDot(speed2, kvel);
if (k < EPSILON) k = 0;
speed *= k;
vectorScale(speed2, k);
if (k > 0) */ target->hitForce(speed, speed2, source);
}
vectorScale(impulse, -1);
source->addImpulse(impulse, sourcecontactpoint);
source->calculateStateVariables();
// vectorScale(speed, source->invmass);
if (target != NULL && source != NULL) {
// float kvel[3];
// target->getVelocity(kvel);
float k = vectorLength(targetvelocity) * 0.1;
// if (k > 1) k = 1;
speed = -impulsesize * source->invmass * k;
vectorScale(speed2, impulse, source->invmass * k);
/*float kvel[3];
target->getVelocity(kvel);
float k = 0;//vectorDot(speed2, kvel);
if (k < EPSILON) k = 0;
speed *= k;
vectorScale(speed2, k);
if (k > 0) */ source->hitForce(speed, speed2, target);
}
return true;
}
