source: orxonox.OLD/orxonox/branches/md2_loader/src/lib/graphics/importer/abstract_model.h @ 4234

/* 
   orxonox - the future of 3D-vertical-scrollers

   Copyright (C) 2004 orx

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

   ### File Specific:
   main-programmer: Patrick Boenzli
   co-programmer: 
*/

/*! 
    \file abstract_model.h
    \brief Definition of an abstract model. containing all needed for other model
*/

#ifndef _ABSTRACT_MODEL_H
#define _ABSTRACT_MODEL_H

#include "stdincl.h"
#include "base_object.h"
#include <vector>
#include <math.h>
#include <SDL_image.h>

using namespace std;



//! this is a small and performant 3D vector
typedef float sVec3D[3];

//! small and performant 2D vector
typedef float sVec2D[2];

//! compressed vertex data: char insetead of float, the value will be expanded by the scale value. only for loading
typedef struct
{
  byte v[3];
  unsigned char lightNormalIndex;
} sVertex;

//! compressed texture offset data: coords scaled by the texture size. Only for loading
typedef struct
{
  short s,t;
} sTexCoor;


//! holds tha informations about a md2 frame
typedef struct
{
  sVec3D scale;                        //!< scales values of the model
  sVec3D translate;                    //!< translates the model
  char name[16];                       //!< frame name: something like "run32"
  sVertex pVertices[1];                //!< first vertex of thes frame
} sFrame;


//! holds the information about a triangle
typedef struct
{
  short indexToVertices[3];             //!< index to the verteces of the triangle
  short indexToTexCoor[3];              //!< index to the texture coordinates
} sTriangle;


typedef struct
{
   float s, t;
   int vertexIndex;
} glCommandVertex;


//! a md2 animation definition
typedef struct
{
  int firstFrame;                       //!< first frame of the animation
  int lastFrame;                        //!< last frame of the animation
  int fps;                              //!< speed: number of frames per second
} sAnim;

//! animation state definition
typedef struct
{
  int startFrame;
  int endFrame;
  int fps;

  float localTime;
  float lastTime;
  float interpolationState;            //!< the state of the animation [0..1]
  
  int type;                            //!< animation type

  int currentFrame;
  int nextFrame;
} sAnimState;


//! This is our 3D point class.  CONFLICTING with Vector.cc
class CVector3 
{
 public:
  float x, y, z;
};

//! This is our 2D point class.  CONFLICTING with Vector.cc
class CVector2 
{
 public:
  float x, y;
};

// CONFLICTING with model.h
struct tFace
{
  int vertIndex[3];                     // indicies for the verts that make up this triangle
  int coordIndex[3];                    // indicies for the tex coords to texture this face
};

// CONFLICTING with material.cc, there are some small differences, i will use this struct and switch over later
struct tMaterialInfo
{
  char  strName[255];                   // The texture name
  char  strFile[255];                   // The texture file name (If this is set it's a texture map)
  byte  color[3];       // The color of the object (R, G, B)
  int   texureId;                               // the texture ID
  float uTile;                          // u tiling of texture  
  float vTile;                          // v tiling of texture  
  float uOffset;                                // u offset of texture
  float vOffset;                                // v offset of texture
} ;

//! properties of a 3D object
struct t3DObject 
{
  int  numOfVerts;                      // The number of verts in the model
  int  numOfFaces;                      // The number of faces in the model
  int  numTexVertex;                    // The number of texture coordinates
  int  materialID;                      // The texture ID to use, which is the index into our texture array
  bool bHasTexture;                     // This is TRUE if there is a texture map for this object
  char strName[255];                    // The name of the object
  CVector3  *pVerts;                    // The object's vertices
  CVector3  *pNormals;                  // The object's normals
  CVector2  *pTexVerts;                 // The texture's UV coordinates
  tFace *pFaces;                                // The faces information of the object
};

// CONFLICTING with animation.cc
struct tAnimationInfo
{
  char strName[255];                    // This stores the name of the animation (Jump, Pain, etc..)
  int startFrame;                               // This stores the first frame number for this animation
  int endFrame;                         // This stores the last frame number for this animation
};

// CONFLICTING with animation.cc and vector.cc
struct t3DModel 
{
  int numOfObjects;                                     // The number of objects in the model
  int numOfMaterials;                                   // The number of materials for the model
  int numOfAnimations;                          // The number of animations in this model (NEW)
  int currentAnim;                                      // The current index into pAnimations list (NEW)
  int currentFrame;                                     // The current frame of the current animation (NEW)
  vector<tAnimationInfo> animationList; // The list of animations (NEW)
  vector<tMaterialInfo> materialList;   // The list of material information (Textures and colors)
  vector<t3DObject> objectList;                 // The object list for our model
};



//! This class defines the basic components of a model
class AbstractModel : public BaseObject {

 public:
  AbstractModel() {}
  virtual ~AbstractModel() {}
};


/* TESTING TESTING TESTING */
/* some mathematical functions that are already implemented by vector.cc class */

// magnitude of a normal
#define Mag(Normal) (sqrt(Normal.x*Normal.x + Normal.y*Normal.y + Normal.z*Normal.z))

class MathHelp {

 public:
  // vector between two points
  static CVector3 VectorDiff(CVector3 vPoint1, CVector3 vPoint2)
    {
      CVector3 vVector;                                                 

      vVector.x = vPoint1.x - vPoint2.x;                        
      vVector.y = vPoint1.y - vPoint2.y;                        
      vVector.z = vPoint1.z - vPoint2.z;                        

      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;              

      return 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;

      return vResult;   
    }

  // 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
  static CVector3 NormalizeVector(CVector3 vNormal)
    {
      double Magnitude;
      Magnitude = Mag(vNormal); 
      vNormal.x /= (float)Magnitude;    
      vNormal.y /= (float)Magnitude;    
      vNormal.z /= (float)Magnitude;    

      return vNormal;   
    }
};


#endif /* _ABSTRACT_MODEL_H */