scene.cpp

Go to the documentation of this file.

#ifndef __SCENE_CPP__
#define __SCENE_CPP__

#include <GL/glu.h>
#include <string>
#include "scene.h"
#include "config.h"
#include "heightfield.h"
#include <stdio.h>
#include <math.h>
#include <iostream>
#include "texture.h"

#include <errno.h>
//#include <string>

#include "airplane.h"



std::string model_name[MODEL_N] =
    { "gallows",
      "gallows_rope",
        "iron_maiden",
        "crypt",
        "diablo",
        "casket_closed",
        "casket_opened",
        "casket_opened2",
        "giljotina1(derevo)",
        "giljotina2(metal)",
        "giljotina3(chelovek)",
        "giljotina4(korzina)",
        "graveyard",
        "mancage_1(derevo)",
        "mancage_2(metal)",
        "prosto-chelovek",
        
    };
        
bool model_in_use[MODEL_N] = 
    {   true,//gallows
        true,//rope
        true,//iron_maiden
        true,//crypt
        false,//diablo
        true,//casket_closed
        false,
        false,
        true,//giljotina_1
        true,//-2
        true,//-3
        true,//-4
        true, //graveyard
        true,//mancage-1
        true, //-2
        false, //player
        
    };

    
unsigned int model_index[MODEL_N];
bool   model_use_list[MODEL_N];
int    model_handle[MODEL_N];

        
void normalize ( double v[3])
{
double d = sqrt(v[0]*v[0] + v[1]*v[1] + v[2]*v[2]);
if (d != 0.0) 
    {
    v[0] /= d;
    v[1] /= d;
    v[2] /= d;
    }
else
    printf(" zero normal?! hmm, strange...\n");

//printf(" len of normal is %f \n", sqrt (v[0]*v[0] + v[1]*v[1] + v[2]*v[2] ) );
}

                
Point3Struct operator+(Point3Struct p1, Point3Struct p2)
{
Point3 pp;
pp.x = p1.x + p2.x;
pp.y = p1.y + p2.y;
pp.z = p1.z + p2.z;
return(pp);
}

struct Model_partStruct
        {
        int nfaces;
        int ind_faces;
        int nvertices;
        int ind_vertices;
        } Model_part;

struct ModelStruct
        {
        int nmodel_parts;
        int ind_model_parts;
        } Model;

static void *Model_parts;
static int model_parts_size = 0;
static void *Models;
static int models_size = 0;

//int ind_gallows;              

static void  *Vertices;
static int vertices_size = 0;
static void *Normals;
static void *Faces;
static int faces_size = 0;


int addModel (std::string );

void deleteModels();


//_________________DELETE_MODELS
void deleteModels(void)
{
free (Model_parts);
free (Models);
free (Vertices);
free (Normals);
free (Faces);
}


//_____________________________________ADD_MODEL
int  addModel (std::string filename)
{


ModelStruct newModel;
Model_partStruct newPart;

FILE *file = fopen (filename.c_str(), "rb");
//int _errno = errno;
if (file == NULL) 
    {
    perror( filename.c_str() );
    return (-1);
    }

newModel.ind_model_parts = model_parts_size;

int n = fread( &newModel.nmodel_parts, sizeof(int), 1, file);
    if (n != 1) {
      printf( "Error reading the number of parts of the model. \n");
      return (-1);
    }

        model_parts_size += newModel.nmodel_parts;
        Model_parts = realloc ( Model_parts, model_parts_size*sizeof(Model_partStruct));

        
for (int i=0; i < newModel.nmodel_parts; i++)
        {
        n = fread( &newPart.nvertices, sizeof(int), 1, file );
        if (n != 1) {   printf( "Error reading the number of vertices. \n"); return (-1); }
    
        n = fread ( &newPart.nfaces, sizeof(int), 1, file );
        if (n != 1) {   printf( "Error reading the number of faces. \n"); return (-1); }

        //now reallocating memory for vertices and appending new vertices
        newPart.ind_vertices = vertices_size;
        vertices_size = (newPart.ind_vertices + newPart.nvertices);
        Vertices = realloc ( Vertices, vertices_size*sizeof(Point3) );

                    
        n = fread ( ((Point3 *) Vertices + newPart.ind_vertices), sizeof(Point3), newPart.nvertices, file );
        if (n != newPart.nvertices) 
            {   printf( "Error reading vertices from the file %s. \n Only %d vertices were read. \n", filename.c_str(), n);
                return (-1);
            }
       
        //now reallocating memory for normals and appending new normals
        newPart.ind_faces = faces_size;
        faces_size = newPart.ind_faces + newPart.nfaces;

        Normals = realloc ( Normals, faces_size*sizeof(Point3) );

        n = fread ( ((Point3 *) Normals + newPart.ind_faces), sizeof(Point3), newPart.nfaces, file );
        if (n != newPart.nfaces) 
            {   printf( "Error reading normals from the file %s. \n Only %d normals were read. \n", filename.c_str(), n);
                return (-1);
            }
   
        //now reallocating memory for faces and appending new faces
        Faces = realloc (Faces, (faces_size)*sizeof(long)*3 );
        
        
        n = fread ( ((long *) Faces + newPart.ind_faces*3), sizeof(long), newPart.nfaces*3, file );
        if (n != newPart.nfaces*3) 
            {   printf( "Error reading faces from the file %s. \n Only %d faces were read. \n", filename.c_str(), n);
                return (-1);
            }

        //adding new model part to global array
        memcpy ( ((Model_partStruct *)Model_parts + newModel.ind_model_parts + i  ), (void *) &newPart, sizeof(Model_partStruct) );
        
        }//end for

    //adding new model to global array
    models_size ++;
    Models = realloc ( Models, models_size*sizeof(ModelStruct));
        
    memcpy ( ((ModelStruct *)Models + models_size - 1 ), (void *) &newModel, sizeof(ModelStruct) );

//cout << "start of faces array " << (int) ((long *)Faces) << endl;
//cout << "end of faces array " << (int) ((long *)Faces + (faces_size - 1)*3) << endl;



return (models_size - 1);

}
        
//___________________________DRAW_FACES         
void drawFaces ( int handle, double scale)
{
ModelStruct *model =  ((ModelStruct *)Models + handle);  
Model_partStruct *model_part;
//printf(" model has %d model_parts \n", model -> nmodel_parts);

Point3 vertex[3];
Point3Struct * vertex_ptr;
Point3 normal;
Point3Struct * normal_ptr;
long face;
long *face_ptr;

double A, B, C, D;
double cosalpha, cosbeta, cosgamma, mu;
Point3 tex[3];

double oldbeta;
double alpha, beta, gamma;

//setDiffuseMaterialColor( colorWhite );



//cout << "start of faces array " << (int) ((long *)Faces) << endl;

//glPushMatrix();



glDisable( GL_TEXTURE_GEN_S);
glDisable( GL_TEXTURE_GEN_T);
glDisable( GL_TEXTURE_GEN_R);
/*
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST );
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL );
*/
for (int i=0; i < model -> nmodel_parts; i++)
    {//drawing every part as a separate object
//cout << "drawing part " << i << endl;
//cout.flush();

    model_part = ((Model_partStruct *)Model_parts + model->ind_model_parts + i);

//cout << "start of the face " << (int) ((long *)Faces + model_part->ind_faces) << endl;
//cout << "end   of the face " << (int) ((long *)Faces + model_part->ind_faces + (model_part->nfaces-1)*3 + 2) << endl;

//glPushMatrix();

    for (int j=0; j < model_part->nfaces; j++ )
        {//drawing every face

//cout << j << ",";
//cout.flush();
            normal_ptr = ((Point3 *)Normals + model_part->ind_faces + j);
            normal = *normal_ptr;

        for (int k=0; k < 3; k++ )
            {
            face_ptr = ((long *)Faces + model_part->ind_faces*3 + j*3 + k);
            face = *face_ptr;
            
            vertex_ptr = ((Point3 *)Vertices + model_part->ind_vertices + face);
            vertex[k] = *vertex_ptr;

            }//end for k

/*
//determining the coefficients in plane's equation
A = ( (vertex[1].y - vertex[0].y)*(vertex[2].z - vertex[0].z) ) - ( (vertex[1].z - vertex[0].z)*(vertex[2].y - vertex[0].y) );
B = ( (vertex[1].z - vertex[0].z)*(vertex[2].x - vertex[0].x) ) - ( (vertex[2].z - vertex[0].z)*(vertex[1].x - vertex[0].x) );
C = ( (vertex[1].x - vertex[0].x)*(vertex[2].y - vertex[0].y) ) - ( (vertex[1].y - vertex[0].y)*(vertex[2].x - vertex[0].x) );
D = - ( vertex[0].x*A + vertex[0].y*B + vertex[0].z*C );

if (D < 0)
    {
    //normalizing
    D = -D;
    A = -A;
    B = -B;
    C = -C;
    }

//computing normalized equation of the plane
    //since (D >= 0) we certainly know which root to take for mu
mu = (-1) / sqrt( A*A + B*B + C*C );

//printf(" mu = %f, A = %f, B = %f, C = %f, D = %f \n", mu, A, B, C, D );

cosalpha = mu * A;
cosbeta  = mu * B;
cosgamma = mu * C;

alpha = acos (cosgamma);// - M_PI/2;
beta  = acos (cosbeta)  ;
gamma = acos (cosgamma) ;

oldbeta = beta;
//alpha += M_PI/2;

beta  *= cos(alpha );
//beta += M_PI/2;
gamma = gamma*(cos(oldbeta  ) ) ;
gamma = gamma*(sin(alpha));
//gamma += M_PI;
//gamma *=sin(alpha );

glDisable(GL_TEXTURE_2D);
    glMatrixMode ( GL_TEXTURE );
    glLoadIdentity ();

    glRotated ( gamma * 180.0f/M_PI , 0, 1, 0);
    glRotated ( beta  * 180.0f/M_PI, 0, 0, 1);
    glRotated ( alpha * 180.0f/M_PI, 1, 0, 0);

    glMatrixMode (GL_MODELVIEW);

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, GL_REPEAT );

glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, texture(TEX_CHECK));

//printf(" cos is  %f, %f, %f \n", cosalpha, cosbeta, cosgamma );
//printf(" acos is %f, %f, %f \n", acos(cosalpha)*180.0f/M_PI, acos(cosbeta)*180/M_PI, acos(cosgamma)*180/M_PI ); 

//glMatrixMode (GL_MODELVIEW);

for (int k=0; k<3; k++) 
    {
    tex[k].x =   vertex[k].x*scale/5;
    tex[k].y =   vertex[k].y*scale/5;
    tex[k].z =   vertex[k].z*scale/5;
    }

  
*/
//printf(" x=%f y=%f \n", texture[0].x, texture[0].y);
        glBegin(GL_TRIANGLES);
                glNormal3d( normal.x, normal.y, normal.z);
                            
                for (int k=0; k<3; k++)
                {
//              glTexCoord3d( tex[k].x, tex[k].y, tex[k].z );
                glVertex3d( vertex[k].x, vertex[k].y, vertex[k].z);
                }//end for k
        glEnd();

//glPopMatrix();
        }//end for j

//glPopMatrix();

    }//end for i
glDisable(GL_TEXTURE_2D);
//glPopMatrix();




//cout << " all parts are drawn";
//cout.flush();
    
/*
glBegin(GL_TRIANGLES);
    
    glNormal3d( normal.x / len, normal.y / len, normal.z / len );
    glVertex3d(vertexa.x, vertexa.y, vertexa.z);


    glNormal3d( normal.x / len, normal.y / len, normal.z / len );
    glVertex3d(vertexb.x, vertexb.y, vertexb.z);


    glNormal3d( normal.x / len, normal.y / len, normal.z / len );
    glVertex3d(vertexc.x, vertexc.y, vertexc.z);
    
    }
glEnd();
*/
}

//__________________________DRAW_MODEL
void drawModel(int model, int handle, double X, double Y, double Z, double x, double y, double z, double fi, double theta, double psi, double scale)
{

if (handle == -1)
    {
    printf(" Incorrect model handler. Probably, model was not initialized properly. \n ");
    exit(1);
    }

float hf;

hf = gethf( (int) round(x/g_cellsize), (int) round (y/g_cellsize) );

//hf *= g_fHeightScale;

//hf -= g_fHeight;
//we start to output vertices in order, defined by face array
//int n= sizeof(gallows_1_face)/ (sizeof(long)*3);


glDisable(GL_AUTO_NORMAL);
glEnable(GL_NORMALIZE);
glDisable(GL_CULL_FACE);
glCullFace(GL_NONE);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glTranslated(x, z + hf, y);
glTranslated(-X, -Z, -Y);//, 0);/-Z);//-Y*g_cellsize, -Z);
glRotated(fi,    1, 0, 0);
glRotated(theta, 0, 1, 0);
glRotated(psi,   0, 0, 1);
glScaled(scale, scale, scale);
/*
      if ( model_use_list[model] )
            {
            glCallList ( model_index[model] );
            }
        else
            {
*/
    drawFaces (handle, scale);
//          }
glPopMatrix();

glDisable(GL_AUTO_NORMAL);
glDisable(GL_NORMALIZE);

//setDiffuseMaterialColor( colorWhite );
//coordinate axises for object
if (g_show_axis)
    {
    glPushMatrix();
glMatrixMode(GL_MODELVIEW);
glTranslated(x*g_cellsize, z + hf, y*g_cellsize);
glTranslated(-X*g_cellsize, -Z, -Y*g_cellsize);//, 0);//-Z);//-Y*g_cellsize, -Z);

glLineWidth(2);
    glBegin(GL_LINES);
        glColor3d(1, 0, 0);
        glVertex3d(0, 0, 0);
        glColor3d(1, 0, 0);
        glVertex3d(10, 0, 0);
    glEnd();
    
    glBegin(GL_LINES);
        glColor3d(0, 1, 0);
        glVertex3d(0, 0, 0);
        glColor3d(0, 1, 0);
        glVertex3d(0, 12, 0);
    glEnd();

    glBegin(GL_LINES);
        glColor3d(0, 0, 1);
        glVertex3d(0, 0, 0);
        glColor3d(0, 0, 1);
        glVertex3d(0, 0, 15);
    glEnd();
glLineWidth(1);

        glColor3d(1, 1, 1);

    glPopMatrix();
    }

//setDiffuseMaterialColor( colorWhite );
    

//printf("\n X %f, Y %f , Z %f, ", X, Y, Z); 


}


#endif

---