X-Git-Url: https://git.jsancho.org/?a=blobdiff_plain;f=Source%2FAnimation%2FSkeleton.cpp;h=31f98860c8528fc05f82caad26144bda85a3e9e3;hb=7d2f9d40d94d14a61ecdaaa2c41f964029815bc2;hp=3f5e65c5a88d6beb58680a17c21bda19f4cffca9;hpb=ed3662c0852c4312a612b4fc35bd03aba8d13db7;p=lugaru.git

diff --git a/Source/Animation/Skeleton.cpp b/Source/Animation/Skeleton.cpp
index 3f5e65c..31f9886 100644
--- a/Source/Animation/Skeleton.cpp
+++ b/Source/Animation/Skeleton.cpp
@@ -28,7 +28,6 @@ along with Lugaru.  If not, see <http://www.gnu.org/licenses/>.
 extern float multiplier;
 extern float gravity;
 extern Terrain terrain;
-extern Objects objects;
 extern int environment;
 extern float camerashake;
 extern bool freeze;
@@ -115,7 +114,8 @@ float Skeleton::DoConstraints(XYZ *coords, float *scale)
     XYZ bounceness;
     const int numrepeats = 3;
     float groundlevel = .15;
-    int i, j, k, m;
+    int k, m;
+    unsigned i;
     XYZ temp;
     XYZ terrainnormal;
     int whichhit;
@@ -133,7 +133,7 @@ float Skeleton::DoConstraints(XYZ *coords, float *scale)
         whichpatchz = coords->z / (terrain.size / subdivision * terrain.scale);
 
         terrainlight = *coords;
-        objects.SphereCheckPossible(&terrainlight, 1);
+        Object::SphereCheckPossible(&terrainlight, 1);
 
         //Add velocity
         for (i = 0; i < joints.size(); i++) {
@@ -163,7 +163,7 @@ float Skeleton::DoConstraints(XYZ *coords, float *scale)
         float tempmult = multiplier;
         //multiplier/=numrepeats;
 
-        for (j = 0; j < numrepeats; j++) {
+        for (int j = 0; j < numrepeats; j++) {
             float r = .05;
             // right leg constraints?
             if (!joint(rightknee).locked && !joint(righthip).locked) {
@@ -218,7 +218,7 @@ float Skeleton::DoConstraints(XYZ *coords, float *scale)
                     joints[i].locked = 0;
                 if (joints[i].delay > 0) {
                     bool freely = true;
-                    for (j = 0; j < joints.size(); j++) {
+                    for (unsigned j = 0; j < joints.size(); j++) {
                         if (joints[j].locked)
                             freely = false;
                     }
@@ -275,7 +275,7 @@ float Skeleton::DoConstraints(XYZ *coords, float *scale)
                             // FIXME: this crashes because k is not initialized!
                             // to reproduce, type 'wolfie' in console and play a while
                             // I'll just comment it out for now
-                            //objects.model[k].MakeDecal(breakdecal, DoRotation(temp - objects.position[k], 0, -objects.yaw[k], 0), .4, .5, Random() % 360);
+                            //Object::objects[k]->model.MakeDecal(breakdecal, DoRotation(temp - Object::objects[k]->position, 0, -Object::objects[k]->yaw, 0), .4, .5, Random() % 360);
                             Sprite::MakeSprite(cloudsprite, joints[i].position * (*scale) + *coords, joints[i].velocity * .06, 1, 1, 1, 4, .2);
                             breaking = false;
                             camerashake += .6;
@@ -326,12 +326,12 @@ float Skeleton::DoConstraints(XYZ *coords, float *scale)
                 if (terrain.patchobjectnum[whichpatchx][whichpatchz])
                     for (m = 0; m < terrain.patchobjectnum[whichpatchx][whichpatchz]; m++) {
                         k = terrain.patchobjects[whichpatchx][whichpatchz][m];
-                        if (k < objects.numobjects && k >= 0)
-                            if (objects.possible[k]) {
-                                friction = objects.friction[k];
+                        if (k < Object::objects.size() && k >= 0)
+                            if (Object::objects[k]->possible) {
+                                friction = Object::objects[k]->friction;
                                 XYZ start = joints[i].realoldposition;
                                 XYZ end = joints[i].position * (*scale) + *coords;
-                                whichhit = objects.model[k].LineCheckPossible(&start, &end, &temp, &objects.position[k], &objects.yaw[k]);
+                                whichhit = Object::objects[k]->model.LineCheckPossible(&start, &end, &temp, &Object::objects[k]->position, &Object::objects[k]->yaw);
                                 if (whichhit != -1) {
                                     if (joints[i].label == groin && !joints[i].locked && joints[i].delay <= 0) {
                                         joints[i].locked = 1;
@@ -350,7 +350,7 @@ float Skeleton::DoConstraints(XYZ *coords, float *scale)
                                         }
                                     }
 
-                                    terrainnormal = DoRotation(objects.model[k].facenormals[whichhit], 0, objects.yaw[k], 0) * -1;
+                                    terrainnormal = DoRotation(Object::objects[k]->model.facenormals[whichhit], 0, Object::objects[k]->yaw, 0) * -1;
                                     if (terrainnormal.y > .8)
                                         freefall = 0;
                                     bounceness = terrainnormal * findLength(&joints[i].velocity) * (abs(normaldotproduct(joints[i].velocity, terrainnormal)));
@@ -360,7 +360,7 @@ float Skeleton::DoConstraints(XYZ *coords, float *scale)
                                     }
                                     if (tutoriallevel != 1 || id == 0)
                                         if (findLengthfast(&bounceness) > 4000 && breaking) {
-                                            objects.model[k].MakeDecal(breakdecal, DoRotation(temp - objects.position[k], 0, -objects.yaw[k], 0), .4, .5, Random() % 360);
+                                            Object::objects[k]->model.MakeDecal(breakdecal, DoRotation(temp - Object::objects[k]->position, 0, -Object::objects[k]->yaw, 0), .4, .5, Random() % 360);
                                             Sprite::MakeSprite(cloudsprite, joints[i].position * (*scale) + *coords, joints[i].velocity * .06, 1, 1, 1, 4, .2);
                                             breaking = false;
                                             camerashake += .6;
@@ -369,11 +369,11 @@ float Skeleton::DoConstraints(XYZ *coords, float *scale)
 
                                             addEnvSound(*coords, 64);
                                         }
-                                    if (objects.type[k] == treetrunktype) {
-                                        objects.rotx[k] += joints[i].velocity.x * multiplier * .4;
-                                        objects.roty[k] += joints[i].velocity.z * multiplier * .4;
-                                        objects.rotx[k + 1] += joints[i].velocity.x * multiplier * .4;
-                                        objects.roty[k + 1] += joints[i].velocity.z * multiplier * .4;
+                                    if (Object::objects[k]->type == treetrunktype) {
+                                        Object::objects[k]->rotx += joints[i].velocity.x * multiplier * .4;
+                                        Object::objects[k]->roty += joints[i].velocity.z * multiplier * .4;
+                                        Object::objects[k + 1]->rotx += joints[i].velocity.x * multiplier * .4;
+                                        Object::objects[k + 1]->roty += joints[i].velocity.z * multiplier * .4;
                                     }
                                     if (!joints[i].locked)
                                         damage += findLengthfast(&bounceness) / 2500;
@@ -412,15 +412,15 @@ float Skeleton::DoConstraints(XYZ *coords, float *scale)
         if (terrain.patchobjectnum[whichpatchx][whichpatchz])
             for (m = 0; m < terrain.patchobjectnum[whichpatchx][whichpatchz]; m++) {
                 k = terrain.patchobjects[whichpatchx][whichpatchz][m];
-                if (objects.possible[k]) {
+                if (Object::objects[k]->possible) {
                     for (i = 0; i < 26; i++) {
                         //Make this less stupid
                         XYZ start = joints[jointlabels[whichjointstartarray[i]]].position * (*scale) + *coords;
                         XYZ end = joints[jointlabels[whichjointendarray[i]]].position * (*scale) + *coords;
-                        whichhit = objects.model[k].LineCheckSlidePossible(&start, &end, &temp, &objects.position[k], &objects.yaw[k]);
+                        whichhit = Object::objects[k]->model.LineCheckSlidePossible(&start, &end, &temp, &Object::objects[k]->position, &Object::objects[k]->yaw);
                         if (whichhit != -1) {
                             joints[jointlabels[whichjointendarray[i]]].position = (end - *coords) / (*scale);
-                            for (j = 0; j < muscles.size(); j++) {
+                            for (unsigned j = 0; j < muscles.size(); j++) {
                                 if ((muscles[j].parent1->label == whichjointstartarray[i] && muscles[j].parent2->label == whichjointendarray[i]) || (muscles[j].parent2->label == whichjointstartarray[i] && muscles[j].parent1->label == whichjointendarray[i]))
                                     muscles[j].DoConstraint(spinny);
                             }
@@ -476,8 +476,7 @@ float Skeleton::DoConstraints(XYZ *coords, float *scale)
  */
 void Skeleton::DoGravity(float *scale)
 {
-    static int i;
-    for (i = 0; i < joints.size(); i++) {
+    for (unsigned i = 0; i < joints.size(); i++) {
         if (
                 (
                     ((joints[i].label != leftknee) && (joints[i].label != rightknee)) ||
@@ -487,8 +486,9 @@ void Skeleton::DoGravity(float *scale)
                     ((joints[i].label != leftelbow) && (joints[i].label != rightelbow)) ||
                     (forward.y < .3)
                 )
-            )
+            ) {
             joints[i].velocity.y += gravity * multiplier / (*scale);
+        }
     }
 }
 
@@ -615,7 +615,7 @@ void Skeleton::Load(const std::string& filename,       const std::string& lowfil
     GLfloat M[16];
     FILE *tfile;
     float lSize;
-    int i, j, num_joints, num_muscles;
+    int j, num_joints, num_muscles;
 
     LOGFUNC;
 
@@ -632,7 +632,7 @@ void Skeleton::Load(const std::string& filename,       const std::string& lowfil
     model[5].loadnotex(model6filename);
     model[6].loadnotex(model7filename);
 
-    for (i = 0; i < num_models; i++) {
+    for (int i = 0; i < num_models; i++) {
         model[i].Rotate(180, 0, 0);
         model[i].Scale(.04, .04, .04);
         model[i].CalculateNormals(0);
@@ -689,7 +689,7 @@ void Skeleton::Load(const std::string& filename,       const std::string& lowfil
     joints.resize(num_joints);
 
     // read info for each joint
-    for (i = 0; i < num_joints; i++) {
+    for (int i = 0; i < num_joints; i++) {
         joints[i].load(tfile, joints);
     }
 
@@ -700,7 +700,7 @@ void Skeleton::Load(const std::string& filename,       const std::string& lowfil
     muscles.resize(num_muscles);
 
     // for each muscle...
-    for (i = 0; i < num_muscles; i++) {
+    for (int i = 0; i < num_muscles; i++) {
         muscles[i].load(tfile, model[0].vertexNum, joints);
     }
 
@@ -715,22 +715,23 @@ void Skeleton::Load(const std::string& filename,       const std::string& lowfil
 
     // ???
     for (j = 0; j < num_muscles; j++) {
-        for (i = 0; i < muscles[j].vertices.size(); i++) {
+        for (unsigned i = 0; i < muscles[j].vertices.size(); i++) {
             for (int k = 0; k < num_models; k++) {
-                if (muscles[j].vertices[i] < model[k].vertexNum)
+                if (muscles[j].vertices[i] < model[k].vertexNum) {
                     model[k].owner[muscles[j].vertices[i]] = j;
+                }
             }
         }
     }
 
     // calculate some stuff
     FindForwards();
-    for (i = 0; i < num_muscles; i++) {
+    for (int i = 0; i < num_muscles; i++) {
         FindRotationMuscle(i, -1);
     }
     // this seems to use opengl purely for matrix calculations
     for (int k = 0; k < num_models; k++) {
-        for (i = 0; i < model[k].vertexNum; i++) {
+        for (int i = 0; i < model[k].vertexNum; i++) {
             model[k].vertex[i] = model[k].vertex[i] - (muscles[model[k].owner[i]].parent1->position + muscles[model[k].owner[i]].parent2->position) / 2;
             glMatrixMode(GL_MODELVIEW);
             glPushMatrix();
@@ -756,7 +757,7 @@ void Skeleton::Load(const std::string& filename,       const std::string& lowfil
     // skip joints section
 
     fseek(tfile, sizeof(num_joints), SEEK_CUR);
-    for (i = 0; i < num_joints; i++) {
+    for (int i = 0; i < num_joints; i++) {
         // skip joint info
         lSize = sizeof(XYZ)
                 + sizeof(float)
@@ -776,7 +777,7 @@ void Skeleton::Load(const std::string& filename,       const std::string& lowfil
     // skip num_muscles
     fseek(tfile, sizeof(num_muscles), SEEK_CUR);
 
-    for (i = 0; i < num_muscles; i++) {
+    for (int i = 0; i < num_muscles; i++) {
         // skip muscle info
         lSize = sizeof(float)
                 + sizeof(float)
@@ -797,14 +798,15 @@ void Skeleton::Load(const std::string& filename,       const std::string& lowfil
     }
 
     for (j = 0; j < num_muscles; j++) {
-        for (i = 0; i < muscles[j].verticeslow.size(); i++) {
-            if (muscles[j].verticeslow[i] < modellow.vertexNum)
+        for (unsigned i = 0; i < muscles[j].verticeslow.size(); i++) {
+            if (muscles[j].verticeslow[i] < modellow.vertexNum) {
                 modellow.owner[muscles[j].verticeslow[i]] = j;
+            }
         }
     }
 
     // use opengl for its matrix math
-    for (i = 0; i < modellow.vertexNum; i++) {
+    for (int i = 0; i < modellow.vertexNum; i++) {
         modellow.vertex[i] = modellow.vertex[i] - (muscles[modellow.owner[i]].parent1->position + muscles[modellow.owner[i]].parent2->position) / 2;
         glMatrixMode(GL_MODELVIEW);
         glPushMatrix();
@@ -830,7 +832,7 @@ void Skeleton::Load(const std::string& filename,       const std::string& lowfil
         // skip num_joints
         fseek(tfile, sizeof(num_joints), SEEK_CUR);
 
-        for (i = 0; i < num_joints; i++) {
+        for (int i = 0; i < num_joints; i++) {
             // skip joint info
             lSize = sizeof(XYZ)
                     + sizeof(float)
@@ -850,7 +852,7 @@ void Skeleton::Load(const std::string& filename,       const std::string& lowfil
         // skip num_muscles
         fseek(tfile, sizeof(num_muscles), SEEK_CUR);
 
-        for (i = 0; i < num_muscles; i++) {
+        for (int i = 0; i < num_muscles; i++) {
             // skip muscle info
             lSize = sizeof(float)
                     + sizeof(float)
@@ -873,14 +875,15 @@ void Skeleton::Load(const std::string& filename,       const std::string& lowfil
         // ???
         lSize = sizeof(int);
         for (j = 0; j < num_muscles; j++) {
-            for (i = 0; i < muscles[j].verticesclothes.size(); i++) {
-                if (muscles[j].verticesclothes.size() && muscles[j].verticesclothes[i] < modelclothes.vertexNum)
+            for (unsigned i = 0; i < muscles[j].verticesclothes.size(); i++) {
+                if (muscles[j].verticesclothes.size() && muscles[j].verticesclothes[i] < modelclothes.vertexNum) {
                     modelclothes.owner[muscles[j].verticesclothes[i]] = j;
+                }
             }
         }
 
         // use opengl for its matrix math
-        for (i = 0; i < modelclothes.vertexNum; i++) {
+        for (int i = 0; i < modelclothes.vertexNum; i++) {
             modelclothes.vertex[i] = modelclothes.vertex[i] - (muscles[modelclothes.owner[i]].parent1->position + muscles[modelclothes.owner[i]].parent2->position) / 2;
             glMatrixMode(GL_MODELVIEW);
             glPushMatrix();
@@ -900,7 +903,7 @@ void Skeleton::Load(const std::string& filename,       const std::string& lowfil
     }
     fclose(tfile);
 
-    for (i = 0; i < num_joints; i++) {
+    for (int i = 0; i < num_joints; i++) {
         for (j = 0; j < num_joints; j++) {
             if (joints[i].label == j)
                 jointlabels[j] = i;