Changeset 8565 in orxonox.OLD for branches/bsp_model

Timestamp:

Jun 17, 2006, 2:13:26 PM (19 years ago)

Author:

patrick

Message:

bsp: switched to const drawing function… this was quite messy

Location:

branches/bsp_model/src/lib/graphics/importer/md3

Files:

• md3_model.cc (modified) (14 diffs)
• md3_model.h (modified) (2 diffs)

branches/bsp_model/src/lib/graphics/importer/md3/md3_model.cc

@@ -47 +47 @@
       this->tmpMesh[i] = new sVec3D[this->md3Data->meshes[i]->header->vertexNum];
 
-    this->tmpNormal = new MD3Normal[2048];                    //!< the temporary normals
+    this->tmpNormal = new MD3Normal*[this->md3Data->meshNum];
+    for( int i = 0; i < this->md3Data->meshNum; i++)
+      this->tmpNormal[i] = new MD3Normal[this->md3Data->meshes[i]->header->vertexNum];
 
     this->tmpMatrix = new float*[this->md3Data->tagNum];
@@ -112 +114 @@
 
 
-      // draw vertex normals if needed
-          if( this->bDrawNormals) {
-        // get vertex normals, interpolate if necessary
+
+
+          // draw vertex normals if needed
+          if( this->bDrawNormals)
+          {
+            // get vertex normals, interpolate if necessary
             if( data->animationState.interpolationFraction != 0.0 &&
-                data->animationState.currentFrame != data->animationState.nextFrame) {
-          //interpolate vertex normals
-              this->drawVertexNormals(frame, this->interpolateVertexNormals(&mesh->normals[data->animationState.currentFrame],
-                                      &mesh->normals[data->animationState.nextFrame], data->animationState.interpolationFraction, mesh));
-                }
-                else {
-          //stick with current vertex normals
-                  this->drawVertexNormals(frame, &mesh->normals[data->animationState.currentFrame]);
-                }
+                data->animationState.currentFrame != data->animationState.nextFrame)
+            {
+              //interpolate vertex normals
+              this->interpolateVertexNormals(&mesh->normals[data->animationState.currentFrame],
+                                              &mesh->normals[data->animationState.nextFrame],
+                                              data->animationState.interpolationFraction, mesh, i);
+             }
           }
     }
+
 
 
@@ -184 +188 @@
    * this draws the md3 model
    */
-  void MD3Model::draw()
-  {
+  void MD3Model::draw() const
+  {
+    PRINTF(0)("draw\n");
+
     //draw current bone frame
-//     this->draw(this->md3Data);
-
-    PRINTF(0)("draw\n");
+    this->draw(this->md3Data);
   }
 
@@ -197 +201 @@
    * @param data: the data to be drawn
    */
-  void MD3Model::draw(MD3Data* data)
+  void MD3Model::draw(MD3Data* data) const
   {
 
@@ -207 +211 @@
           data->animationState.currentFrame != data->animationState.nextFrame) {
         //interpolate bone frame
-        this->drawBoneFrame(this->interpolateBoneFrame(data->boneFrames[data->animationState.currentFrame],
-                            data->boneFrames[data->animationState.nextFrame],
-                            data->animationState.interpolationFraction));
+        this->drawBoneFrame(this->tmpBoneFrame);
       }
       else {
@@ -230 +232 @@
 
       // get mesh frame, do interpolation if necessary
-      sVec3D* frame;
-      if( data->animationState.interpolationFraction != 0.0 &&
-          data->animationState.currentFrame != data->animationState.nextFrame) {
-        //interpolate mesh frame between the 2 current mesh frames
-//         frame = this->interpolateMeshFrame(mesh, data->animationState.currentFrame, data->animationState.nextFrame,
-//                                            data->animationState.interpolationFraction);
-        frame = this->interpolateMeshFrame( data->meshes[data->animationState.currentFrame]->meshFrames,
-                                            data->meshes[data->animationState.nextFrame]->meshFrames,
-                                            data->animationState.interpolationFraction, mesh, i);
-      }
+      sVec3D* frame = this->tmpMesh[i];
+
+      this->drawMesh(mesh, frame);
 
 
@@ -248 +243 @@
             data->animationState.currentFrame != data->animationState.nextFrame) {
           //interpolate vertex normals
-          this->interpolateVertexNormals(&mesh->normals[data->animationState.currentFrame],
-                                         &mesh->normals[data->animationState.nextFrame],
-                                         data->animationState.interpolationFraction, mesh);
-        }
+          this->drawVertexNormals(frame, this->tmpNormal[i]);
+            }
+            else {
+          //stick with current vertex normals
+              this->drawVertexNormals(frame, &mesh->normals[data->animationState.currentFrame]);
+            }
       }
     }
@@ -257 +254 @@
 
     // draw all models linked to this model
+    int i = 0;
     std::map<int, MD3Data*>::iterator it = data->sortedMap.begin();
     while( it != data->sortedMap.end())
@@ -270 +268 @@
           data->animationState.currentFrame != data->animationState.nextFrame) {
         //we need to interpolate
-        MD3Tag* nextFrameTag = data->boneFrames[data->animationState.nextFrame]->tags[child->parentTagIndex];
-//         m = this->interpolateTransformation(currFrameTag, nextFrameTag, data->animationState.interpolationFraction);
+        m = this->tmpMatrix[i];
       }
       else {
@@ -302 +299 @@
 
       glPopMatrix();
+      i++;
     }
   }
@@ -309 +307 @@
    * draws the mesh
    */
-  void MD3Model::drawMesh(MD3Mesh* mesh, sVec3D* frame)
+  void MD3Model::drawMesh(MD3Mesh* mesh, sVec3D* frame) const
   {
     glColor3f(1.0f, 1.0f, 1.0f);
     glBegin( GL_TRIANGLES );
+
+    Vector tmpVec1, tmpVec2;
 
     // upload all triangles in the frame to OpenGL
     for( int t = 0; t < mesh->header->triangleNum; t++) {
       // calc normal vector
-      this->tmpVec1.x = frame[mesh->triangles[t].vertexOffset[1]][0] - frame[mesh->triangles[t].vertexOffset[0]][0];
-      this->tmpVec2.x = frame[mesh->triangles[t].vertexOffset[2]][0] - frame[mesh->triangles[t].vertexOffset[0]][0];
-
-      this->tmpVec1.y = frame[mesh->triangles[t].vertexOffset[1]][1] - frame[mesh->triangles[t].vertexOffset[0]][1];
-      this->tmpVec2.y = frame[mesh->triangles[t].vertexOffset[2]][1] - frame[mesh->triangles[t].vertexOffset[0]][1];
-
-      this->tmpVec1.z = frame[mesh->triangles[t].vertexOffset[1]][2] - frame[mesh->triangles[t].vertexOffset[0]][2];
-      this->tmpVec2.z = frame[mesh->triangles[t].vertexOffset[2]][2] - frame[mesh->triangles[t].vertexOffset[0]][2];
-
-      Vector normal = this->tmpVec1.cross(tmpVec2);
+      tmpVec1.x = frame[mesh->triangles[t].vertexOffset[1]][0] - frame[mesh->triangles[t].vertexOffset[0]][0];
+      tmpVec2.x = frame[mesh->triangles[t].vertexOffset[2]][0] - frame[mesh->triangles[t].vertexOffset[0]][0];
+
+      tmpVec1.y = frame[mesh->triangles[t].vertexOffset[1]][1] - frame[mesh->triangles[t].vertexOffset[0]][1];
+      tmpVec2.y = frame[mesh->triangles[t].vertexOffset[2]][1] - frame[mesh->triangles[t].vertexOffset[0]][1];
+
+      tmpVec1.z = frame[mesh->triangles[t].vertexOffset[1]][2] - frame[mesh->triangles[t].vertexOffset[0]][2];
+      tmpVec2.z = frame[mesh->triangles[t].vertexOffset[2]][2] - frame[mesh->triangles[t].vertexOffset[0]][2];
+
+      Vector normal = tmpVec1.cross(tmpVec2);
       normal.normalize();
 
@@ -353 +353 @@
    *  drawo vertex normals
    */
-  void MD3Model::drawVertexNormals(sVec3D* frame, MD3Normal* normals)
+  void MD3Model::drawVertexNormals(sVec3D* frame, MD3Normal* normals) const
   {}
 
@@ -360 +360 @@
    * draw bone frame
    */
-  void MD3Model::drawBoneFrame(MD3BoneFrame* frame)
+  void MD3Model::drawBoneFrame(MD3BoneFrame* frame) const
   {
     float x1 = frame->mins.x;
@@ -459 +459 @@
    * interpolate vertex normal
    */
-  MD3Normal* MD3Model::interpolateVertexNormals(MD3Normal* currNormals, MD3Normal* nextNormals, float frac, MD3Mesh* mesh)
-  {
-    for( int i = 0; i < mesh->header->vertexNum; i++)
-    {
-      this->tmpNormal[i].vertexNormal[0] = (int)((1.0f - frac) * currNormals[i].vertexNormal[0] + frac * nextNormals[i].vertexNormal[0]);
-      this->tmpNormal[i].vertexNormal[1] = (int)((1.0f - frac) * currNormals[i].vertexNormal[1] + frac * nextNormals[i].vertexNormal[1]);
-    }
-
-    return this->tmpNormal;
+  MD3Normal* MD3Model::interpolateVertexNormals(MD3Normal* currNormals, MD3Normal* nextNormals, float frac, MD3Mesh* mesh, int i)
+  {
+    for( int j = 0; j < mesh->header->vertexNum; j++)
+    {
+      this->tmpNormal[i][j].vertexNormal[0] = (int)((1.0f - frac) * currNormals[j].vertexNormal[0] + frac * nextNormals[j].vertexNormal[0]);
+      this->tmpNormal[i][j].vertexNormal[1] = (int)((1.0f - frac) * currNormals[j].vertexNormal[1] + frac * nextNormals[j].vertexNormal[1]);
+    }
+
+    return this->tmpNormal[i];
   }
 

branches/bsp_model/src/lib/graphics/importer/md3/md3_model.h

@@ -35 +35 @@
 
     virtual void tick(float dt);
-    virtual void draw() ;
+    virtual void draw() const;
 
 
   private:
-    void draw(MD3Data* data);
+    void draw(MD3Data* data) const;
     void tick(float dt, MD3Data* data);
 
-    void drawMesh(MD3Mesh* mesh, sVec3D* frame) ;
-    void drawVertexNormals(sVec3D* frame, MD3Normal* normals) ;
-    void drawBoneFrame(MD3BoneFrame* frame) ;
+    void drawMesh(MD3Mesh* mesh, sVec3D* frame) const;
+    void drawVertexNormals(sVec3D* frame, MD3Normal* normals) const;
+    void drawBoneFrame(MD3BoneFrame* frame) const;
 
     MD3BoneFrame* interpolateBoneFrame(MD3BoneFrame* currBoneFrame, MD3BoneFrame* nextBoneFrame, float frac);
     sVec3D* interpolateMeshFrame(sVec3D* currMeshFrame, sVec3D* nextMeshFrame, float frac, MD3Mesh* mesh, int i);
-    MD3Normal* interpolateVertexNormals(MD3Normal* curNormals, MD3Normal* nextNormals, float frac, MD3Mesh* mesh);
+    MD3Normal* interpolateVertexNormals(MD3Normal* curNormals, MD3Normal* nextNormals, float frac, MD3Mesh* mesh, int i);
     float* interpolateTransformation(MD3Tag* currFrameTag, MD3Tag* nextFrameTag, float frac, int i);
 
@@ -59 +59 @@
     MD3BoneFrame*       tmpBoneFrame;      //!< a temporary bone frame
     sVec3D**            tmpMesh;           //!< a temporary mesh frame
-    MD3Normal*          tmpNormal;         //!< a temporary normals frame
+    MD3Normal**         tmpNormal;         //!< a temporary normals frame
     float**             tmpMatrix;         //!< a temporary matrix
-    Vector              tmpVec1;
-    Vector              tmpVec2;
+
 };