Changeset 4149 in orxonox.OLD for orxonox

Timestamp:

May 10, 2005, 6:04:16 PM (20 years ago)

Author:

patrick

Message:

orxonox/branches/md2_loader: fixed linker problem, there is no a MathHelp class, which contains the redundant mathematical functions to solve the normalization problems

Location:

orxonox/branches/md2_loader/src/lib/graphics/importer

Files:

• abstract_model.h (modified) (1 diff)
• md2Model.cc (modified) (1 diff)

orxonox/branches/md2_loader/src/lib/graphics/importer/abstract_model.h

@@ -119 +119 @@
 #define Mag(Normal) (sqrt(Normal.x*Normal.x + Normal.y*Normal.y + Normal.z*Normal.z))
 
-// vector between two points
-CVector3 VectorDiff(CVector3 vPoint1, CVector3 vPoint2)
-{
-        CVector3 vVector;                                                       
+class MathHelp {
 
-        vVector.x = vPoint1.x - vPoint2.x;                      
-        vVector.y = vPoint1.y - vPoint2.y;                      
-        vVector.z = vPoint1.z - vPoint2.z;                      
+ public:
+  // vector between two points
+  static CVector3 VectorDiff(CVector3 vPoint1, CVector3 vPoint2)
+    {
+      CVector3 vVector;                                                 
 
-        return vVector;                                                         
-}
+      vVector.x = vPoint1.x - vPoint2.x;                        
+      vVector.y = vPoint1.y - vPoint2.y;                        
+      vVector.z = vPoint1.z - vPoint2.z;                        
 
-// adding vectors, returning result
-CVector3 AddVector(CVector3 vVector1, CVector3 vVector2)
-{
-        CVector3 vResult;                                                       
+      return vVector;                                                           
+    }
+
+  // adding vectors, returning result
+  static CVector3 AddVector(CVector3 vVector1, CVector3 vVector2)
+    {
+      CVector3 vResult;                                                 
         
-        vResult.x = vVector2.x + vVector1.x;            
-        vResult.y = vVector2.y + vVector1.y;            
-        vResult.z = vVector2.z + vVector1.z;            
+      vResult.x = vVector2.x + vVector1.x;              
+      vResult.y = vVector2.y + vVector1.y;              
+      vResult.z = vVector2.z + vVector1.z;              
 
-        return vResult;
-}
+      return vResult;
+    }
 
-// This divides a vector by a single number (scalar) and returns the result
-CVector3 DivideVectorByScaler(CVector3 vVector1, float Scaler)
-{
-        CVector3 vResult;                                                       
+  // This divides a vector by a single number (scalar) and returns the result
+  static CVector3 DivideVectorByScaler(CVector3 vVector1, float Scaler)
+    {
+      CVector3 vResult;                                                 
         
-        vResult.x = vVector1.x / Scaler;                        
-        vResult.y = vVector1.y / Scaler;                
-        vResult.z = vVector1.z / Scaler;
+      vResult.x = vVector1.x / Scaler;                  
+      vResult.y = vVector1.y / Scaler;          
+      vResult.z = vVector1.z / Scaler;
 
-        return vResult; 
-}
+      return vResult;   
+    }
 
-// cross product between 2 vectors
-CVector3 CrossProduct(CVector3 vVector1, CVector3 vVector2)
-{
-        CVector3 vCross;        
-        vCross.x = ((vVector1.y * vVector2.z) - (vVector1.z * vVector2.y));
-        vCross.y = ((vVector1.z * vVector2.x) - (vVector1.x * vVector2.z));
-        vCross.z = ((vVector1.x * vVector2.y) - (vVector1.y * vVector2.x));
-        return vCross;  
-}
+  // cross product between 2 vectors
+  static CVector3 CrossProduct(CVector3 vVector1, CVector3 vVector2)
+    {
+      CVector3 vCross;  
+      vCross.x = ((vVector1.y * vVector2.z) - (vVector1.z * vVector2.y));
+      vCross.y = ((vVector1.z * vVector2.x) - (vVector1.x * vVector2.z));
+      vCross.z = ((vVector1.x * vVector2.y) - (vVector1.y * vVector2.x));
+      return vCross;    
+    }
 
-// calculate the normal of a vector
-CVector3 NormalizeVector(CVector3 vNormal)
-{
-        double Magnitude;
-        Magnitude = Mag(vNormal);       
-        vNormal.x /= (float)Magnitude;  
-        vNormal.y /= (float)Magnitude;  
-        vNormal.z /= (float)Magnitude;  
+  // calculate the normal of a vector
+  static CVector3 NormalizeVector(CVector3 vNormal)
+    {
+      double Magnitude;
+      Magnitude = Mag(vNormal); 
+      vNormal.x /= (float)Magnitude;    
+      vNormal.y /= (float)Magnitude;    
+      vNormal.z /= (float)Magnitude;    
 
-        return vNormal; 
-}
-
+      return vNormal;   
+    }
+};
 
 #endif /* _ABSTRACT_MODEL_H */

orxonox/branches/md2_loader/src/lib/graphics/importer/md2Model.cc

@@ -308 +308 @@
 void MD2Loader::computeNormals(t3DModel *pModel)
 {
-        CVector3 vVector1, vVector2, vNormal, vPoly[3];
-
-        if( unlikely(pModel->numOfObjects <= 0))
-                return;
-        /* now computing face normals: this means just averaging the vertex normals of a face */
-        /* so for every object: */
-        for(int index = 0; index < pModel->numOfObjects; index++)
-        {
-                t3DObject *pObject = &(pModel->objectList[index]);
-
-                /* allocate all the memory we need to calculate the normals */
-                CVector3 *pNormals = new CVector3 [pObject->numOfFaces];
-                CVector3 *pTempNormals = new CVector3 [pObject->numOfFaces];
-                pObject->pNormals = new CVector3 [pObject->numOfVerts];
-
-                for(int i=0; i < pObject->numOfFaces; i++)
+  CVector3 vVector1, vVector2, vNormal, vPoly[3];
+
+  if( unlikely(pModel->numOfObjects <= 0))
+    return;
+  /* now computing face normals: this means just averaging the vertex normals of a face */
+  /* so for every object: */
+  for(int index = 0; index < pModel->numOfObjects; index++)
+    {
+      t3DObject *pObject = &(pModel->objectList[index]);
+
+      /* allocate all the memory we need to calculate the normals */
+      CVector3 *pNormals = new CVector3 [pObject->numOfFaces];
+      CVector3 *pTempNormals = new CVector3 [pObject->numOfFaces];
+      pObject->pNormals = new CVector3 [pObject->numOfVerts];
+
+      for(int i=0; i < pObject->numOfFaces; i++)
+        {
+          /* cache the points to make coding easier :) */
+          vPoly[0] = pObject->pVerts[pObject->pFaces[i].vertIndex[0]];
+          vPoly[1] = pObject->pVerts[pObject->pFaces[i].vertIndex[1]];
+          vPoly[2] = pObject->pVerts[pObject->pFaces[i].vertIndex[2]];
+
+          vVector1 = MathHelp::VectorDiff(vPoly[0], vPoly[2]);          
+          vVector2 = MathHelp::VectorDiff(vPoly[2], vPoly[1]);          
+                        
+          vNormal  = MathHelp::CrossProduct(vVector1, vVector2);                
+          pTempNormals[i] = vNormal;                                    
+          vNormal  = MathHelp::NormalizeVector(vNormal);                                
+
+          pNormals[i] = vNormal;
+        }
+
+      /* now calculating vertex normals */
+      CVector3 vSum = {0.0, 0.0, 0.0};
+      CVector3 vZero = vSum;
+      int shared=0;
+
+      for (int i = 0; i < pObject->numOfVerts; i++)                     
+        {
+          for (int j = 0; j < pObject->numOfFaces; j++) 
+            {                                                                                           
+              if (pObject->pFaces[j].vertIndex[0] == i || 
+                  pObject->pFaces[j].vertIndex[1] == i || 
+                  pObject->pFaces[j].vertIndex[2] == i)
                 {
-                    /* cache the points to make coding easier :) */
-                        vPoly[0] = pObject->pVerts[pObject->pFaces[i].vertIndex[0]];
-                        vPoly[1] = pObject->pVerts[pObject->pFaces[i].vertIndex[1]];
-                        vPoly[2] = pObject->pVerts[pObject->pFaces[i].vertIndex[2]];
-
-                        vVector1 = VectorDiff(vPoly[0], vPoly[2]);              
-                        vVector2 = VectorDiff(vPoly[2], vPoly[1]);              
-                        
-                        vNormal  = CrossProduct(vVector1, vVector2);            
-                        pTempNormals[i] = vNormal;                                      
-                        vNormal  = NormalizeVector(vNormal);                            
-
-                        pNormals[i] = vNormal;
-                }
-
-                /* now calculating vertex normals */
-                CVector3 vSum = {0.0, 0.0, 0.0};
-                CVector3 vZero = vSum;
-                int shared=0;
-
-                for (i = 0; i < pObject->numOfVerts; i++)                       
-                {
-                        for (int j = 0; j < pObject->numOfFaces; j++)   
-                        {                                                                                               
-                                        if (pObject->pFaces[j].vertIndex[0] == i || 
-                                        pObject->pFaces[j].vertIndex[1] == i || 
-                                        pObject->pFaces[j].vertIndex[2] == i)
-                                {
-                                        vSum = AddVector(vSum, pTempNormals[j]);
-                                        shared++;                                                                                               }
-                        }      
-                        pObject->pNormals[i] = DivideVectorByScaler(vSum, float(-shared));
-                        pObject->pNormals[i] = NormalizeVector(pObject->pNormals[i]);   
-
-                        vSum = vZero;                                                                   
-                        shared = 0;                                                                             
-                }
-                delete [] pTempNormals;
-                delete [] pNormals;
-        }
+                  vSum = MathHelp::AddVector(vSum, pTempNormals[j]);
+                  shared++;                                                                                             }
+            }      
+          pObject->pNormals[i] = MathHelp::DivideVectorByScaler(vSum, float(-shared));
+          pObject->pNormals[i] = MathHelp::NormalizeVector(pObject->pNormals[i]);       
+
+          vSum = vZero;                                                                 
+          shared = 0;                                                                           
+        }
+      delete [] pTempNormals;
+      delete [] pNormals;
+    }
 }