~yacinechaouche/+junk/BZR

## file model.py

 

from objloader import *

from drawing import *

from OpenGL.GL import *

 

class Model:

 

    def __init__(self,filename="",groupname = None,model = None,textureFileName = None) :

        """

        This holds all informations relative to a 3D (lightwave) model. Developers can use an object of this class to represent immobile 3D models. For mobile models use MobileModel instead. To create a composite model, specify it's filename. For the components, specify the groupname and the model's model (model). model is specified for a construction by copy.

        """

        if groupname :

            if not model :

                raise 'No model model specified for the group',groupname

            else :

                print 'creation of model ',groupname

                self.copy(model)

                self.groups = {groupname : model.groups[groupname]}

                del model.groups[groupname]

                model.buildModelList()                

                #print self.groups

                self.min = self.groups[groupname][MINIMA]

                self.max = self.groups[groupname][MAXIMA]

                self.center = self.groups[groupname][CENTER]

                self.boundingbox = [self.min,self.max]

                self.modelList = glGenLists(1)

                self.buildModelList()

                return 

 

        print 'creation of model', filename

        self.filename          = filename

        self.materialFileName  = ''

        self.textureFileName   = textureFileName

        self.materialFile      = ''

        self.vertices          = []

        self.textures          = []

        self.normals           = []

        self.nb_vertices       = 0

        self.nb_textures       = 0

        self.nb_normals        = 0        

        self.nb_faces          = 0

        self.nb_materials      = 0

        self.nb_groups         = 0

        self.nb_elements       = 0

        self.materials         = {}  # dictionary 

        self.groups            = {}  # dictionary

        self.center            = [0,0,0]

        self.min               = [INFINITY,INFINITY,INFINITY]

        self.max               = [-INFINITY,-INFINITY,-INFINITY]

        self.loader            = ObjLoader(model=self)

        self.boundingBox       = [self.min,self.max]

        self.boundingBoxShowed = False

        self.drawing           = Drawing()

        self.modelList         = glGenLists(1)

 

        

        if self.modelList == 0 :

            print 'Error in MobileModel constructor, self.modelList is', self.modelList, '. returning.'

           # return 

            

        self.buildModelList()

 

    def copy(self,model):

        for i,j in model.__dict__.items() :

            self.__dict__[i] = j

 

    def buildModelList(self):

        glNewList(self.modelList,GL_COMPILE)

        if self.textureFileName :

            glEnable(GL_TEXTURE_2D)

            self.drawing.useTexture(self.textureFileName)

        glPushMatrix()

        for g in self.groups.values():

            if not self.textureFileName :

                try:

                    self.useMaterial(g[MATERIAL])

                    pass

                except:

                    print "Warning : a group has no material in ", self.model.filename,"!"

                    pass

            #FACES is an enumeration. It's value is 1

            for f in g[FACES]:

                if  len(f) == 3 * self.nb_elements :

                    glBegin(GL_TRIANGLES)

                elif len(f) == 4 * self.nb_elements :

                    glBegin(GL_QUADS)

                else :

                    glBegin(GL_POLYGON)

                for i in range(0,len(f),self.nb_elements): 

                    #Keep in mind that first line is line 1, not 0

                    j = i + self.nb_elements - 1

                    k = i + 1

                    glNormal(self.normals[f[j]-1][X],

                             self.normals[f[j]-1][Y],

                             self.normals[f[j]-1][Z])

                    glVertex(self.vertices[f[i]-1][X],

                             self.vertices[f[i]-1][Y],

                             self.vertices[f[i]-1][Z])

                    if self.textureFileName and self.nb_elements == 3 :

##                         print self.nb_elements

##                         print k

##                         print f[k]

##                         print self.textures[f[k] - 1]

                        

                        glTexCoord(self.textures[f[k]-1][X],

                                   self.textures[f[k]-1][Y])

                        ##self.textures[f[k]-1][Z])

 

                glEnd()

        glPopMatrix()

        if self.textureFileName :

            glDisable(GL_TEXTURE_2D)    

        glEndList()

        

    def useMaterial(self,materialName):

        for param in [GL_AMBIENT,GL_SPECULAR,GL_DIFFUSE,GL_SHININESS]:

            try: # sometimes not all values are defined, so put this line in a try block

                glMaterialfv(GL_FRONT,param,self.materials[materialName][param])

            except:

                pass

 

    def draw(self):

        glPushMatrix()

        glCallList(self.modelList)

        if(self.boundingBoxShowed):

            self.drawBoundingBox()

        glPopMatrix()

 

    def buildBoundingBoxList(self):

        self.boundingBoxList = glGenLists(1)

        glNewList(self.boundingBoxList,GL_COMPILE)

        glDisable(GL_LIGHTING)

        glPushMatrix()

        glTranslate(self.center[X],self.center[Y],self.center[Z])

        glScale(self.max[X]-self.min[X],self.max[Y]-self.min[Y],self.max[Z]-self.min[Z])

        glutWireCube(1.0)

        glPopMatrix()

        glEnable(GL_LIGHTING)

        glEndList()

 

    def drawBoundingBox(self):

        glPushMatrix()

        glCallList(self.boundingBoxList)

        glPopMatrix()

 

    def showBoundingBox(self,showing):

        if showing :

            self.boundingBoxShowed = True

            self.buildBoundingBoxList()

        else :

            self.boundingBoxShowed= False

            glDeleteLists(self.boundingBoxList,1)

 

def loader_test(filename='',groupname='') :

    if (filename == '' or groupname == ''):

        print "usage : loader_test (filename,groupname)"

        return 

 

    model = Model(filename)

    for name,g in model.groups.items() :

        #print 'group ', name

        for f in g[FACES] :

            #print 'faces are', f

            for i in range(0,len(f),model.nb_elements):

                #Keep in mind that first line is line 1, not 0

                #print 'i is',i,' and len(f) is', len(f)

                #print 'len(normals) is',len(l.normals),'and f[i+1]-1 is ', f[i+1] - 1,'sans le -1',f[i+1]

                #print 'normals are',l.normals[f[i+2]-1][X],l.normals[f[i+2]-1][Y],l.normals[f[i+2]-1][Z]

                #print 'vertices are',l.vertices[f[i]-1][X],l.vertices[f[i]-1][Y],l.vertices[f[i]-1][Z]

                pass

    if not model.groups.has_key(groupname) :

        print "error, no group named", groupname, "in model. Returning."

        return

    model.computeBoundingBox(groupname)

    print 'min du ',groupname,' est', model.groups[groupname][MINIMA]

    print 'max du ',groupname,' est', model.groups[groupname][MAXIMA]

    print 'centre du ',groupname,' est', model.groups[groupname][CENTER]

    print 'min du ', filename.split(".")[0],model.min

    print 'max du ',filename.split(".")[0] ,model.max

    print 'centre du ',filename.split(".")[0],model.center

#####################            

##loader_test("tank.obj",'Canon')

def testSingleton():

 

    model1 = Model(filename = 'jeep.txt')

    model2 = Model(filename = 'tank.obj')

    print model1.loader

    print ObjLoader.singleton

    print model2.loader

    

##testSingleton()