void calculateCullingFrustum(mat4 camMatrix) {
float cLeft = -0.05f;
float cRight = 0.05f;
float cBottom = -0.05f;
float cTop = 0.05f;
float cNear = 0.2f;
//float cFar = 50.f;
vec3 topLeft = {cLeft, cTop, -cNear};
vec3 bottomLeft = {cLeft, cBottom, -cNear};
vec3 topRight = {cRight, cTop, -cNear};
vec3 bottomRight = {cRight, cBottom, -cNear};
vec3 farNormal = {0.f, 0.f, -1.f};
mat4 invCam = InvertMat4(camMatrix);
topLeft = MultVec3(invCam, topLeft);
bottomLeft = MultVec3(invCam, topLeft);
topRight = MultVec3(invCam, topLeft);
bottomRight = MultVec3(invCam, topLeft);
farNormal = MultVec3(invCam, farNormal);
cullingFrustumNormals[0] = Normalize(CrossProduct(topLeft, bottomLeft)); // Left normal
cullingFrustumNormals[1] = Normalize(CrossProduct(bottomRight, topRight)); // Right normal
cullingFrustumNormals[2] = Normalize(CrossProduct(bottomLeft, bottomRight)); // Bottom normal
cullingFrustumNormals[3] = Normalize(CrossProduct(topRight, topLeft)); // Top normal
cullingFrustumNormals[4] = Normalize(farNormal); // Far normal
}
void calc_bone_transform(joint_s * j, int acc)
{
joint_s * jc;
joint_s * rootj = j;
mat4 tmp, tmptrans, invtrans;
//tmp = IdentityMatrix();
if(acc)
tmp = j->parent->tmp;
//tmp = j->parent->Mtot;
else
//tmp = IdentityMatrix();
tmp = Mult(T(cow.pos.x, cow.pos.y, cow.pos.z), Ry(cow.angle));
GLfloat Ms[8][16];
int i=0,ii=0, k=0;
float currpos[8*3] = {0};
float bonepos[8*3] = {0};
while(j->child[0] != NULL)
{
//calc_bone_transform(j->child[0], 1);
for(k=1; k < MAX_CHILDREN; k++)
{
if(j->child[k] != NULL)
calc_bone_transform(j->child[k], 1);
}
jc = j->child[0];
vec3 tmp_bonepos;
tmptrans = j->T;
tmp = Mult(tmp, tmptrans);
invtrans = InvertMat4(tmptrans);
tmp = Mult(tmp, Mult(j->R, invtrans));
j->tmp = tmp;
j->isnull = 0;
//middle of bone
tmp_bonepos = ScalarMult(
VectorAdd(j->pos, jc->pos), .5);
for(ii=0;ii<16;ii++)
Ms[i][ii] = (tmp).m[ii];
currpos[i*3] = 10*j->pos.x;
currpos[i*3+1] = 10*j->pos.y;
currpos[i*3+2] = 10*j->pos.z;
bonepos[i*3] = 10*tmp_bonepos.x;
bonepos[i*3+1] = 10*tmp_bonepos.y;
bonepos[i*3+2] = 10*tmp_bonepos.z;
j = j->child[0];
i++;
}
if(rootj->posvar != NULL)
{
//printf(rootj->posvar);
//printf("\n");
}
//printf("%f %f %f\n", currpos[0], currpos[1], currpos[2]);
glUniformMatrix4fv(glGetUniformLocation(g_shader, rootj->Mvar), 8, GL_TRUE, Ms[0]);
glUniform3fv(glGetUniformLocation(g_shader, rootj->posvar), 8, currpos);
glUniform3fv(glGetUniformLocation(g_shader, rootj->boneposvar), 8, bonepos);
}
///////////////////////////////////////////////////////
// D E F O R M C Y L I N D E R
//
// Desc: deformera cylinder meshen enligt skelettet
void DeformCylinder()
{
//vec3 v[kMaxBones];
//float w[kMaxBones];
int row, corner, bonesnum, bonesnum2;
//bonesnum = 0;
// för samtliga vertexar
for (row = 0; row < kMaxRow; row++)
{
for (corner = 0; corner < kMaxCorners; corner++)
{
// ---------========= UPG 4 ===========---------
// TODO: skinna meshen mot alla benen.
//
// data som du kan använda:
// g_bonesRes[].rot //Rotation på benen
// g_bones[].pos //Benens position
// g_boneWeights //g_boneWeights[kMaxRow][kMaxCorners][kMaxBones]
// g_vertsOrg //Originalet
// g_vertsRes //Det som ska skickas
//g_vertsRes[row][corner] = g_vertsOrg[row][corner];
vec3 sum = SetVector(0.0, 0.0, 0.0);
for(bonesnum = 0; bonesnum < kMaxBones; bonesnum++)
{
//Beräknar T för Org och Res
mat4 currOrgT = T(g_bones[bonesnum].pos.x, g_bones[bonesnum].pos.y, g_bones[bonesnum].pos.z);
mat4 currResT = T(g_bonesRes[bonesnum].pos.x, g_bonesRes[bonesnum].pos.y, g_bonesRes[bonesnum].pos.z);
//Beräknar M för Org och Res, och även inverterad M
mat4 currOrgM = Mult(currOrgT, g_bones[bonesnum].rot);
mat4 currResM = Mult(currResT, g_bonesRes[bonesnum].rot);
mat4 currInvM = InvertMat4(currOrgM);
mat4 sumOrgM = currOrgM;
mat4 sumResM = currResM;
mat4 sumInvM = currInvM;
for(bonesnum2 = bonesnum - 1; bonesnum2 >= 0; bonesnum2--)
{
//Beräknar T för Org och Res för ben innan bonesnum
mat4 preOrgT = T(g_bones[bonesnum2].pos.x, g_bones[bonesnum2].pos.y, g_bones[bonesnum2].pos.z);
mat4 preResT = T(g_bonesRes[bonesnum2].pos.x, g_bonesRes[bonesnum2].pos.y, g_bonesRes[bonesnum2].pos.z);
//Beräknar M för Org och Res, och även inverterad M för ben innan bonesnum
mat4 preOrgM = Mult(preOrgT, g_bones[bonesnum2].rot);
mat4 preResM = Mult(preResT, g_bonesRes[bonesnum2].rot);
mat4 preInvM = InvertMat4(preOrgM);
//Summerar
sumOrgM = Mult(sumOrgM, preOrgM);
sumResM = Mult(sumResM, preResM);
sumInvM = Mult(preInvM, sumInvM);
}
vec3 resV = MultVec3(sumOrgM, g_vertsOrg[row][corner]);
mat4 temp1 = Mult(sumResM, sumInvM);
vec3 temp2 = MultVec3(temp1, resV);
temp2 = ScalarMult(temp2, g_boneWeights[row][corner][bonesnum]);
sum = VectorAdd(sum, temp2);
}
g_vertsRes[row][corner] = sum;
}
}
}
