Model.h

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 5 -*- */

/*
 * Combination of a first person action and a real time strategy battle game.
 */

/*
 * Model.h
 * MetalWarriors
 * $Revision: 1.23 $
 *
 * Created by Daniel Aarno on Sun Sep 28 2003.
 * Copyright (c) 2003 Daniel Aarno and Erik Ytterberg - All rights reserved.
 *
 *     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 of the License, or
 *     (at your option) any later version.
 *
 *     This program is distributed in the hope that it will be useful,
 *     but WITHOUT ANY WARRANTY; without even the implied warranty of
 *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *     GNU General Public License for more details.
 *
 *     You should have received a copy of the GNU General Public License
 *     along with this program; if not, write to the Free Software
 *     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 */
 
#ifndef _MODEL_
#define _MODEL_


#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <list>
#include "opengl.h"

/*Splits a buffer (file) into convenient strings*/
char *getString(char *buf, char *pos,  int fd);

/*Returns length of a substring in a longer string*/
int atos(char *str);


typedef enum {
  CAP_DUMMY = 0,
  CAP_BODY = 1,
  
  CAP_TURRET = 10,
  CAP_TURRET_ROTATION,
  CAP_TURRET_ROT_LEFT,
  CAP_TURRET_ROT_RIGHT,
  
  CAP_BARREL = 20,
  CAP_BARREL_ELEVATION,
  CAP_BARREL_UP,
  CAP_BARREL_DOWN,

  CAP_WHEEL = 30,
  CAP_WHEEL_ROTATION_R,
  CAP_WHEEL_ROTATION_L,
  CAP_MAX
}model_cap_t;

#define MODEL_CAPS_USED 17

#define MODEL_CAP_MAX_NAME_LEN 30

typedef struct{
  model_cap_t cap;
  char name[MODEL_CAP_MAX_NAME_LEN];
}model_cap_trans_t;

//void initCaps(void);
//model_cap_t findCapTrans(char *str);

typedef struct{
  model_cap_t cap;
  float *value;
  float min;
  float max;
  float step;
  
}model_cap_data_t;

/*Some functions for easy manipulation of cap values*/
void incCap(model_cap_data_t *cap_data);
void decCap(model_cap_data_t *cap_data);
void incCap(model_cap_data_t *cap_data, float steps);
void decCap(model_cap_data_t *cap_data, float steps);

#define MAX_CAPS 10

class Model
{
  friend class ModelResource;
public:
     GLfloat *vertices;  
     GLuint *indices;    

     long indexCount;    
     long vertexCount;   
   

    
#ifdef MEM_STATS
     size_t size;
#endif
 protected:
     char rsrcKey[32];
public:
     Model();
     Model(char *desc_file);
     virtual ~Model();

     int loadModel(const char *path);

     void clear();

     static void DrawVertexArray(const GLfloat* vertices, 
                                 const GLuint* indices, 
                                 GLint count);
 protected:
     int readVertices(FILE* modFile);
     int readFaces(FILE* modFile);
};

class CompModel : public Model
{
protected:
     static std::string filePrefix;

public:
     enum {
          FOG_BIT = 0,
       LIGHTING_BIT,
       DEPTH_TEST_BIT,
       CULL_FACE_BIT,
       ALPHA_TEST_BIT,
       TEXTURE_2D_BIT,
       STENCIL_TEST_BIT, 
       BLEND_BIT
     };

     struct openglstate {
          GLuint tex;
          unsigned long state;
     };

     typedef openglstate openglstate_t;
     //typedef unsigned long openglstate_t;

     struct RGBA_t {
          RGBA_t() {}
          RGBA_t (GLfloat r_, GLfloat g_, GLfloat b_, GLfloat a_) 
               : r(r_), g(g_), b(b_), a(a_) {}
          
          static RGBA_t Black() { return RGBA_t(0.0f, 0.0f, 0.0f, 1.0f); }
          static RGBA_t White() { return RGBA_t(1.0f, 1.0f, 1.0f, 1.0f); }

          operator GLfloat* () { return &r; }
          RGBA_t& operator*=(GLfloat d);

          GLfloat r;
          GLfloat g;
          GLfloat b;
          GLfloat a;
     };

     struct Lighting {
          RGBA_t ambient;
          RGBA_t diffuse;
          RGBA_t specular;
          GLfloat shine;
     };

     float translation[3];
     float rotation[4];
     float scale[3];
  
     std::list<CompModel*> children;
     GLuint tex_id;
     char name[20];
     char texRsrcKey[32];
  
     std::list<model_cap_data_t*> caps;
     Lighting* lighting;
     openglstate_t state;

protected:
     int parseDesc(int fd);
     int readDesc(int fd, char *buffer, char **str_pos, char *parent_name);
     virtual void paintVertexArray(void);

public:
     CompModel(void);
     virtual ~CompModel();
     int initModel(std::string desc_file, std::string prefix);
     CompModel *getByName(char *search_name);
     CompModel *replaceByName(char *search_name, CompModel* replacement);
     float *getTrans(void){return translation;}
     float *getRot(void) {return rotation;}
     float *getScale(void) {return scale;}

     float *getCapValue(model_cap_t cap);
     void setCapValue(model_cap_t cap, float value);
     model_cap_data_t *getCapData(model_cap_t cap);
     int getAllCapData(std::list<model_cap_data_t*> *cap_data_list, 
                       model_cap_t cap);
     void incCap(model_cap_t cap);
     void decCap(model_cap_t cap);
     void incCap(model_cap_t cap, float steps);
     void decCap(model_cap_t cap, float steps);
     void paint();
};

#endif// _MODEL_

---