Classes/Engine3d/LwoLoader.cpp

#include <stdio.h>
#include "LwoLoader.h"
#include "../ImageFormat/SGI.h"
#include "math.h"
#include "../String/String.h"
#include "../System/System.h"
#include "../System/SystemDefine.h"


LwoLoader::LwoLoader(Object3dList **iobjekt3dlist_, ObjectLinkedList<SGI> *iTextureList)
{
        objekt3dlist_[0]=iobjekt3dlist_[0];
        textureList=iTextureList;
}

LwoLoader::~LwoLoader()
{
}

void LwoLoader::remove()
{
        if (textureNameList!=null)
        {
                delete textureNameList;
        }

        if (binaryInput!=null)
        {
                delete binaryInput;
        }       

        if (xVerticesArray!=null)
        {
                delete xVerticesArray;
        }

        if (yVerticesArray!=null)
        {
                delete yVerticesArray;
        }

        if (zVerticesArray!=null)
        {
                delete zVerticesArray;
        }

        if (polygonPoints!=null)
        {
                delete polygonPoints;
        }

        if (polygonSurfaces!=null)
        {
                delete polygonSurfaces;
        }

        if (surfaceMappingMethod!=null)
        {
                delete surfaceMappingMethod;
        }

        if (surfaceColourArray!=null)
        {
                delete surfaceColourArray;
        }

        if (surfaceTransparentArray!=null)
        {
                delete surfaceTransparentArray;
        }

        if (surfaceTextureWrappingXArray!=null)
        {
                delete surfaceTextureWrappingXArray;
        }

        if (surfaceTextureWrappingYArray!=null)
        {
                delete surfaceTextureWrappingYArray;
        }

        if (surfaceXYZAxleArray!=null)
        {
                delete surfaceXYZAxleArray;
        }

        if (surfaceTextureSizeXArray!=null)
        {
                delete surfaceTextureSizeXArray;
        }

        if (surfaceTextureSizeYArray!=null)
        {
                delete surfaceTextureSizeYArray;
        }

        if (surfaceTextureSizeZArray!=null)
        {
                delete surfaceTextureSizeZArray;
        }

        if (surfaceTextureCenterXArray!=null)
        {
                delete surfaceTextureCenterXArray;
        }

        if (surfaceTextureCenterYArray!=null)
        {
                delete surfaceTextureCenterYArray;
        }

        if (surfaceTextureCenterZArray!=null)
        {
                delete surfaceTextureCenterZArray;
        }

        if (polygonPoint1UArray!=null)
        {
                delete polygonPoint1UArray;
        }

        if (polygonPoint1VArray!=null)
        {
                delete polygonPoint1VArray;
        }

        if (polygonPoint2UArray!=null)
        {
                delete polygonPoint2UArray;
        }

        if (polygonPoint2VArray!=null)
        {
                delete polygonPoint2VArray;
        }

        if (polygonPoint3UArray!=null)
        {
                delete polygonPoint3UArray;
        }

        if (polygonPoint3VArray!=null)
        {
                delete polygonPoint3VArray;
        }
}

//*********************************************************
//compute the data you want from a lwo file
//*********************************************************

void LwoLoader::scanLwoFile(String &fileName)
{
        textureNameList=new StringLinkedList();
        binaryInput=new BinaryInput();
        xVerticesArray=null;
        yVerticesArray=null;
        zVerticesArray=null;
        polygonPoints=null;
        polygonSurfaces=null;
        surfaceMappingMethod=null;
        surfaceColourArray=null;
        surfaceTransparentArray=null;
        surfaceTextureWrappingXArray=null;
        surfaceTextureWrappingYArray=null;
        surfaceXYZAxleArray=null;
        surfaceTextureSizeXArray=null;
        surfaceTextureSizeYArray=null;
        surfaceTextureSizeZArray=null;
        surfaceTextureCenterXArray=null;
        surfaceTextureCenterYArray=null;
        surfaceTextureCenterZArray=null;
        polygonPoint1UArray=null;
        polygonPoint1VArray=null;
        polygonPoint2UArray=null;
        polygonPoint2VArray=null;
        polygonPoint3UArray=null;
        polygonPoint3VArray=null;

        binaryInput->readFile(fileName);

        binaryInput->setBigEndian(true);
        System::println(binaryInput->getWord(4));
        System::println(binaryInput->getInt());
        System::println(binaryInput->getWord(4));
        bool diffJumpValue=false;

        while (binaryInput->getBinaryStatus())
        {
                int jumpValue=0;

                String chunk=binaryInput->getWord(4);
                System::println(chunk);

                if (chunk.equals("SURF"))
                {
                        jumpValue=binaryInput->getInt();
                        System::println(binaryInput->getWord());
                        binaryInput->getChar();
                        diffJumpValue=true;
                }
                else
                {
                        if (diffJumpValue)
                        {
                                jumpValue=(int)binaryInput->getShort();
                        }
                        else
                        {
                                jumpValue=binaryInput->getInt();
                        }

                        bool notJump=false;

                        notJump=computeChunkPNTS(chunk, jumpValue);
                        
                        if (!notJump)
                        {                       
                                notJump=computeChunkSRFS(chunk, jumpValue);
                        }

                        if (!notJump)
                        {
                                notJump=computeChunkPOLS(chunk, jumpValue);
                        }

                        if (!notJump)
                        {
                                notJump=computeChunkCOLR(chunk, jumpValue);
                        }

                        if (!notJump)
                        {
                                notJump=computeChunkVTRN(chunk, jumpValue);
                        }

                        if (!notJump)
                        {
                                notJump=computeChunkCTEX(chunk, jumpValue);
                        }

                        if (!notJump)
                        {
                                notJump=computeChunkTIMG(chunk, jumpValue);
                        }

                        if (!notJump)
                        {
                                notJump=computeChunkTWRP(chunk, jumpValue);
                        }
                        
                        if (!notJump)
                        {
                                notJump=computeChunkTFLG(chunk, jumpValue);
                        }

                        if (!notJump)
                        {
                                notJump=computeChunkTSIZ(chunk, jumpValue);
                        }

                        if (!notJump)
                        {
                                notJump=computeChunkTCTR(chunk, jumpValue);
                        }

                        if (!notJump)
                        {
                                binaryInput->jumpForward(jumpValue);
                        }
                }
        }       

        calcTextureMapping();

        Object3d *objekt3d_ = objekt3dlist_[0]->add(xVerticesArray->size, polygonSurfaces->size,polygonPoints->size,textureNameList->size());

        readttpoints(objekt3d_);

        if (textureNameList->size()!=0)
        {
                for ( int t=0; t<textureNameList->size() ; t++ )
                {
                        String filePath=textureNameList->getElement(t);
//                      System::println(filePath);
                        objekt3d_->settexturep((int)textureList->addLastWithNoDoubleName(new SGI(filePath),filePath.buffer),t); 
                }
        }

        readvertices(objekt3d_);
        readprepareuv2(objekt3d_);
        readvpoints(objekt3d_);
//      readcolour(objekt3d_);
//      readtransparent(objekt3d_);

        objekt3d_->makenormtab();

        remove();
}


bool LwoLoader::computeChunkPNTS(String &chunk, int chunkValue)
{
        if (chunk.equals("PNTS"))
        {
                int numberOfVertices=(chunkValue/12);
                System::println(numberOfVertices);

                xVerticesArray = new FloatArray(numberOfVertices);
                yVerticesArray = new FloatArray(numberOfVertices);
                zVerticesArray = new FloatArray(numberOfVertices);

                for ( int v=0 ; v<numberOfVertices ; v++ ) 
                {                       
                        xVerticesArray->setFloat(binaryInput->getFloat(),v);
                        yVerticesArray->setFloat(binaryInput->getFloat(),v);
                        zVerticesArray->setFloat(binaryInput->getFloat(),v);
                }
        
                return true;
        }       

        return false;
}

bool LwoLoader::computeChunkSRFS(String &chunk, int chunkValue)
{
        if (chunk.equals("SRFS"))
        {
                numberOfSurfaces=0;

                binaryInput->resetCharCounter();
                
                while (binaryInput->getCharCounter() < chunkValue)
                {
                        String surfaceName=binaryInput->getWord();
                        System::println(surfaceName);
                        if ((surfaceName.length&1) == 1)
                        {
                                binaryInput->getChar();
                        }
                        numberOfSurfaces++;
                }

                surfaceColourArray = new IntArray(numberOfSurfaces);
                surfaceTransparentArray = new FloatArray(numberOfSurfaces);
                surfaceMappingMethod = new IntArray(numberOfSurfaces);
                surfaceTextureWrappingXArray = new IntArray(numberOfSurfaces);
                surfaceTextureWrappingYArray = new IntArray(numberOfSurfaces);
                surfaceXYZAxleArray = new IntArray(numberOfSurfaces);
                surfaceTextureSizeXArray = new FloatArray(numberOfSurfaces);
                surfaceTextureSizeYArray = new FloatArray(numberOfSurfaces);
                surfaceTextureSizeZArray = new FloatArray(numberOfSurfaces);
                surfaceTextureCenterXArray = new FloatArray(numberOfSurfaces);
                surfaceTextureCenterYArray = new FloatArray(numberOfSurfaces);
                surfaceTextureCenterZArray = new FloatArray(numberOfSurfaces);
                return true;
        }

        return false;
}

bool LwoLoader::computeChunkPOLS(String &chunk, int chunkValue)
{
        if (chunk.equals("POLS"))
        {
                int numberOfPoints=0;
                int numberOfPolygonSurfaces=0;
                int numberOfPolygons=0;

                polygonPoints = new IntArray((int)(binaryInput->getInternBufferSize()/sizeof(int)));
                polygonSurfaces = new IntArray((int)(binaryInput->getInternBufferSize()/sizeof(int)));

                binaryInput->resetCharCounter();

            while (binaryInput->getCharCounter() < chunkValue)
            {
                        int numberOfFaces=(int)binaryInput->getShort();
                        numberOfFaces-=2;
                        numberOfPolygons+=numberOfFaces;
                        //System::println(numberOfPolygons);
                        short firstPoint=binaryInput->getShort();
      
                        for ( int p=0 ; p<numberOfFaces ; p++ ) 
                        {                              
                            polygonPoints->setInt((int)firstPoint,numberOfPoints);
                                numberOfPoints++;
                        
                            polygonPoints->setInt((int)binaryInput->getShort(),numberOfPoints);
                                numberOfPoints++;

                                polygonPoints->setInt((int)binaryInput->getShortButGoNotFoward(),numberOfPoints);
                                numberOfPoints++;
                        }               
                
                        binaryInput->getShort();
                        int surfaceID=(int)(binaryInput->getShort()-1);

                        for ( int p2=0 ; p2<numberOfFaces ; p2++ ) 
                        {      
                                polygonSurfaces->setInt(surfaceID,numberOfPolygonSurfaces);
                                numberOfPolygonSurfaces++;                              
                        }

                }

//              System::println(binaryInput->getCharCounter()-chunkValue);
     
                polygonPoints->size=numberOfPoints;
                polygonSurfaces->size=numberOfPolygons;

                String numberOfPolysName="numberOfPolys: ";
//              System::println(numberOfPolysName + numberOfPolygons);

                return true;
        }

        return false;
}

//*********************************************************
//colour
//*********************************************************

bool LwoLoader::computeChunkCOLR(String &chunk, int chunkValue)
{
        if (chunk.equals("COLR"))
        {
                if (surfaceColourArray->getInternIndex() < numberOfSurfaces)
                {
                        surfaceColourArray->setInt((binaryInput->getInt()));
                        System::println(surfaceColourArray->getInt());
                        surfaceColourArray->internIndexForward();
                        return true;
                }
        }

        return false;
}

//*********************************************************
//transparent??
//*********************************************************

bool LwoLoader::computeChunkVTRN(String &chunk, int chunkValue)
{
        if (chunk.equals("VTRN"))
        {
                if (surfaceTransparentArray->getInternIndex() < numberOfSurfaces)
                {
                        surfaceTransparentArray->setFloat((binaryInput->getFloat()));
                        System::println(surfaceTransparentArray->getFloat());
                        surfaceTransparentArray->internIndexForward();
                        return true;
                }
        }

        return false;
}

//*********************************************************
//planar cylindric or spherilic
//*********************************************************

bool LwoLoader::computeChunkCTEX(String &chunk, int chunkValue)
{
        if (chunk.equals("CTEX"))
        {
                if (surfaceMappingMethod->getInternIndex() < numberOfSurfaces)
                {
                        String mappingMethodName=binaryInput->getWord();
                        if ((mappingMethodName.length&1) == 1)
                        {
                                binaryInput->getChar();
                        }
                        
                        bool statement=true;

                        if (mappingMethodName.equals("Planar Image Map"))
                        {
                                surfaceMappingMethod->setInt(1);
                                statement=false;
                        }
                        
                        if (mappingMethodName.equals("Cylindric Image Map"))
                        {
                                surfaceMappingMethod->setInt(2);
                                statement=false;
                        }
                        
                        if (mappingMethodName.equals("Spherelic Image Map"))
                        {
                                surfaceMappingMethod->setInt(3);
                                statement=false;
                        }

                        if (statement)
                        {
                                surfaceMappingMethod->setInt(0);
                        }

                        System::println(surfaceMappingMethod->getInt());

                        surfaceMappingMethod->internIndexForward();

                        return true;
                }
        }       

        return false;
}


//*********************************************************
//read texture name
//*********************************************************

bool LwoLoader::computeChunkTIMG(String &chunk, int chunkValue)
{
        if (chunk.equals("TIMG"))
        {
                String word=binaryInput->getWord();

                if ((word.length&1) == 1)
                {
                        binaryInput->getChar();
                }

                word.cutTheBack(92);
                word.cutTheBegining('.');

                String filePath="data/texturer/";
                String fulFilePath=filePath + word + ".rgb";
                textureNameList->addLast(fulFilePath);
                System::println(fulFilePath);
                
                return true;
        }

        return false;
}

//*********************************************************
//texture wrapping
//*********************************************************

bool LwoLoader::computeChunkTWRP(String &chunk, int chunkValue)
{
        if (chunk.equals("TWRP"))
        {
                if (surfaceTextureWrappingXArray->getInternIndex() < numberOfSurfaces)
                {
                        surfaceTextureWrappingXArray->setInt((int)binaryInput->getShort());
                        surfaceTextureWrappingYArray->setInt((int)binaryInput->getShort());
                        System::println(surfaceTextureWrappingXArray->getInt());
                        System::println(surfaceTextureWrappingYArray->getInt());
                        surfaceTextureWrappingXArray->internIndexForward();
                        surfaceTextureWrappingYArray->internIndexForward();

                        return true;
                }
        }

        return false;
}

//*********************************************************
//x or y or z axles
//*********************************************************

bool LwoLoader::computeChunkTFLG(String &chunk, int chunkValue)
{
        if (chunk.equals("TFLG"))
        {
                if (surfaceXYZAxleArray->getInternIndex() < numberOfSurfaces)
                {
                        int axle=(int)binaryInput->getShort();

                        int outPutAxle=0;

                        if( (axle&1) == 1)
                        {
                                 outPutAxle=1;
                        }
                                
                        if(((axle>>1)&1) == 1)
                        {
                                 outPutAxle=2;
                        }
                                
                        if(((axle>>2)&1) == 1)
                        {
                                 outPutAxle=3;
                        }

                        surfaceXYZAxleArray->setInt(outPutAxle);
                        System::println(surfaceXYZAxleArray->getInt());
                        surfaceXYZAxleArray->internIndexForward();
                        return true;
                }
        }

        return false;
}


//*********************************************************
//texture size x,y,z
//*********************************************************

bool LwoLoader::computeChunkTSIZ(String &chunk, int chunkValue)
{
        if (chunk.equals("TSIZ"))
        {
                if (surfaceTextureSizeXArray->getInternIndex() < numberOfSurfaces)
                {
                        surfaceTextureSizeXArray->setFloat(binaryInput->getFloat());
                        surfaceTextureSizeYArray->setFloat(binaryInput->getFloat());
                        surfaceTextureSizeZArray->setFloat(binaryInput->getFloat());
                        System::println(surfaceTextureSizeXArray->getFloat());
                        System::println(surfaceTextureSizeYArray->getFloat());
                        System::println(surfaceTextureSizeZArray->getFloat());
                        surfaceTextureSizeXArray->internIndexForward();
                        surfaceTextureSizeYArray->internIndexForward();
                        surfaceTextureSizeZArray->internIndexForward();

                        return true;
                }
        }

        return false;
}

//*********************************************************
//texture center x,y,z 
//*********************************************************

bool LwoLoader::computeChunkTCTR(String &chunk, int chunkValue)
{
        if (chunk.equals("TCTR"))
        {
                if (surfaceTextureCenterXArray->getInternIndex() < numberOfSurfaces)
                {
                        surfaceTextureCenterXArray->setFloat(binaryInput->getFloat());
                        surfaceTextureCenterYArray->setFloat(binaryInput->getFloat());
                        surfaceTextureCenterZArray->setFloat(binaryInput->getFloat());
                        System::println(surfaceTextureCenterXArray->getFloat());
                        System::println(surfaceTextureCenterYArray->getFloat());
                        System::println(surfaceTextureCenterZArray->getFloat());
                        surfaceTextureCenterXArray->internIndexForward();
                        surfaceTextureCenterYArray->internIndexForward();
                        surfaceTextureCenterZArray->internIndexForward();

                        return true;
                }
        }

        return false;
}

//*********************************************************
// calculate texturemapping
//*********************************************************

void LwoLoader::calcTextureMapping()
{
        polygonPoint1UArray = new FloatArray(polygonSurfaces->size);
        polygonPoint1VArray = new FloatArray(polygonSurfaces->size);
        polygonPoint2UArray = new FloatArray(polygonSurfaces->size);
        polygonPoint2VArray = new FloatArray(polygonSurfaces->size);
        polygonPoint3UArray = new FloatArray(polygonSurfaces->size);
        polygonPoint3VArray = new FloatArray(polygonSurfaces->size);

        for ( int p=0; p<polygonSurfaces->size ; p++ )
        {
                int whichPolygonPoint=0;
                float u=0;
                float v=0;

                calcUVForAVertices(p, whichPolygonPoint, &u, &v);

                polygonPoint1UArray->setFloat(u,p);     
                polygonPoint1VArray->setFloat(v,p);     

                whichPolygonPoint++;
                u=0;
                v=0;

                calcUVForAVertices(p, whichPolygonPoint, &u, &v);

                polygonPoint2UArray->setFloat(u,p);     
                polygonPoint2VArray->setFloat(v,p);     

                whichPolygonPoint++;
                u=0;
                v=0;

                calcUVForAVertices(p, whichPolygonPoint, &u, &v);

                polygonPoint3UArray->setFloat(u,p);     
                polygonPoint3VArray->setFloat(v,p);     

        }
}


void LwoLoader::calcUVForAVertices(int whichPolygon, int whichPolygonPoint, float *u, float *v)
{
        int whichSurface=polygonSurfaces->getInt(whichPolygon);
                                
        float x=xVerticesArray->getFloat(polygonPoints->getInt(whichPolygon*3+whichPolygonPoint))-surfaceTextureCenterXArray->getFloat(whichSurface);
        float y=yVerticesArray->getFloat(polygonPoints->getInt(whichPolygon*3+whichPolygonPoint))-surfaceTextureCenterYArray->getFloat(whichSurface);
        float z=zVerticesArray->getFloat(polygonPoints->getInt(whichPolygon*3+whichPolygonPoint))-surfaceTextureCenterZArray->getFloat(whichSurface);


        float xTextureSize=surfaceTextureSizeXArray->getFloat(whichSurface);
        float yTextureSize=surfaceTextureSizeYArray->getFloat(whichSurface);
        float zTextureSize=surfaceTextureSizeZArray->getFloat(whichSurface);
        int axle=surfaceXYZAxleArray->getInt(whichSurface);

        if (surfaceMappingMethod->getInt(whichSurface) == 1)
        {
                if (axle==3)
                {
                        u[0]=(x/xTextureSize+0.5f);
                        v[0]=(-y/yTextureSize+0.5f);
                }

                if (axle==1)
                {
                        u[0]=(-z/zTextureSize+0.5f);
                        v[0]=(-y/yTextureSize+0.5f);
                }

                if (axle==2)
                {
                        u[0]=(z/zTextureSize+0.5f);
                        v[0]=(x/xTextureSize+0.5f);
                }
        }                               

/*
                                if ( ctex[whichSurface] == 2)
                                {
                                        float rz;

                                        if ( tflg[whichSurface] == 3 )
                                        {
                                                u=(x/tsiz[whichSurface*3+0]);
                                                v=(-y/tsiz[whichSurface*3+1]);
                                                rz=(-z/tsiz[whichSurface*3+2]);                                         
                                        }


                                        if ( tflg[whichSurface] == 1 )
                                        {
                                                rz=(x/tsiz[whichSurface*3+0]);
                                                v=(y/tsiz[whichSurface*3+1]);
                                                u=(z/tsiz[whichSurface*3+2]);
                                        }

                                        if ( tflg[whichSurface] == 2 )
                                        {
                                                u=(z/tsiz[whichSurface*3+2]);
                                                v=(x/tsiz[whichSurface*3+0]);
                                                rz=(y/tsiz[whichSurface*3+1]);                                  
                                        }

                                        //twrp[tpoints[v2]*2+0]
                                        u=1.0f-((float)(((atan2(v,u)/2)*2)/3.14)+0.25f);
                                        v=0.5f+(float)(rz);
                                }


                                if ( ctex[whichSurface] == 3)
                                {

                                        if ( tflg[whichSurface] == 2 )
                                        {
                                                u=(z/tsiz[whichSurface*3+2]+0.5f);
                                                v=(x/tsiz[whichSurface*3+0]+0.5f);
                                        }
        
                                        if ( tflg[whichSurface] == 1 )
                                        {
                                                u=(-z/tsiz[whichSurface*3+2]+0.5f);
                                                v=(-y/tsiz[whichSurface*3+1]+0.5f);
                                        }

                                        if ( tflg[whichSurface] == 3 )
                                        {
                                                u=(x/tsiz[whichSurface*3+0]+0.5f);
                                                v=(-y/tsiz[whichSurface*3+1]+0.5f);
                                        }
                                                //lon*=twrp[tpoints[v2]*2+0];
                                                //lon*=twrp[tpoints[v2]*2+1];
                                }
*/
        if ( u[0] < 0 )
        {
                u[0]*=-1;                                       
        }               

        if ( v[0] < 0 )
        {
                v[0]*=-1;
        }

                                
        if ( u[0] > 1 )
        {
                u[0]=1;
        }

        if ( v[0] > 1)
        {
                v[0]=1;
        }
}


//vertices

void LwoLoader::readvertices(Object3d *out)
{
        for ( int n=0 ; n<xVerticesArray->size ; n++ )
        {
                out->setvx(xVerticesArray->getFloat(n),n);
                out->setvy(yVerticesArray->getFloat(n),n);
                out->setvz(zVerticesArray->getFloat(n),n);
        }
}

// u,v cordinates

void LwoLoader::readprepareuv2(Object3d *out)
{
        for ( int n=0 ; n<polygonSurfaces->size ; n++ )
        {
                out->setvu(polygonPoint1UArray->getFloat(n),n*3+0);
                out->setvv(polygonPoint1VArray->getFloat(n),n*3+0);
                out->setvu(polygonPoint2UArray->getFloat(n),n*3+1);
                out->setvv(polygonPoint2VArray->getFloat(n),n*3+1);
                out->setvu(polygonPoint3UArray->getFloat(n),n*3+2);
                out->setvv(polygonPoint3VArray->getFloat(n),n*3+2);
        }
}

// transparent

void LwoLoader::readtransparent(Object3d *out)
{
        for ( int p=0; p<polygonSurfaces->size ; p++ )
        {
//              out->settransparent(transparent[p],p);
        }

}

// colour

void LwoLoader::readcolour(Object3d *out)
{
        for ( int p=0; p<polygonSurfaces->size ; p++ )
        {
//              out->setcolour(colour[p],p);
        }
}

// vertices points

void LwoLoader::readvpoints(Object3d *out)
{
        for ( int s=0 ; s<polygonPoints->size ; s++ )
        {
                out->setpoints(polygonPoints->getInt(s),s);
        }
}

// texture address

void LwoLoader::readttpoints(Object3d *out)
{
        for ( int s=0 ; s<polygonSurfaces->size ; s++ )
        {
                out->settpoints(polygonSurfaces->getInt(s),s);
        }
}
1	#include <stdio.h>
2	#include "LwoLoader.h"
3	#include "../ImageFormat/SGI.h"
4	#include "math.h"
5	#include "../String/String.h"
6	#include "../System/System.h"
7	#include "../System/SystemDefine.h"
8
9
10	LwoLoader::LwoLoader(Object3dList *iobjekt3dlist_, ObjectLinkedList<SGI> iTextureList)
11	{
12	objekt3dlist_[0]=iobjekt3dlist_[0];
13	textureList=iTextureList;
14	}
15
16	LwoLoader::~LwoLoader()
17	{
18	}
19
20	void LwoLoader::remove()
21	{
22	if (textureNameList!=null)
23	{
24	delete textureNameList;
25	}
26
27	if (binaryInput!=null)
28	{
29	delete binaryInput;
30	}
31
32	if (xVerticesArray!=null)
33	{
34	delete xVerticesArray;
35	}
36
37	if (yVerticesArray!=null)
38	{
39	delete yVerticesArray;
40	}
41
42	if (zVerticesArray!=null)
43	{
44	delete zVerticesArray;
45	}
46
47	if (polygonPoints!=null)
48	{
49	delete polygonPoints;
50	}
51
52	if (polygonSurfaces!=null)
53	{
54	delete polygonSurfaces;
55	}
56
57	if (surfaceMappingMethod!=null)
58	{
59	delete surfaceMappingMethod;
60	}
61
62	if (surfaceColourArray!=null)
63	{
64	delete surfaceColourArray;
65	}
66
67	if (surfaceTransparentArray!=null)
68	{
69	delete surfaceTransparentArray;
70	}
71
72	if (surfaceTextureWrappingXArray!=null)
73	{
74	delete surfaceTextureWrappingXArray;
75	}
76
77	if (surfaceTextureWrappingYArray!=null)
78	{
79	delete surfaceTextureWrappingYArray;
80	}
81
82	if (surfaceXYZAxleArray!=null)
83	{
84	delete surfaceXYZAxleArray;
85	}
86
87	if (surfaceTextureSizeXArray!=null)
88	{
89	delete surfaceTextureSizeXArray;
90	}
91
92	if (surfaceTextureSizeYArray!=null)
93	{
94	delete surfaceTextureSizeYArray;
95	}
96
97	if (surfaceTextureSizeZArray!=null)
98	{
99	delete surfaceTextureSizeZArray;
100	}
101
102	if (surfaceTextureCenterXArray!=null)
103	{
104	delete surfaceTextureCenterXArray;
105	}
106
107	if (surfaceTextureCenterYArray!=null)
108	{
109	delete surfaceTextureCenterYArray;
110	}
111
112	if (surfaceTextureCenterZArray!=null)
113	{
114	delete surfaceTextureCenterZArray;
115	}
116
117	if (polygonPoint1UArray!=null)
118	{
119	delete polygonPoint1UArray;
120	}
121
122	if (polygonPoint1VArray!=null)
123	{
124	delete polygonPoint1VArray;
125	}
126
127	if (polygonPoint2UArray!=null)
128	{
129	delete polygonPoint2UArray;
130	}
131
132	if (polygonPoint2VArray!=null)
133	{
134	delete polygonPoint2VArray;
135	}
136
137	if (polygonPoint3UArray!=null)
138	{
139	delete polygonPoint3UArray;
140	}
141
142	if (polygonPoint3VArray!=null)
143	{
144	delete polygonPoint3VArray;
145	}
146	}
147
148	//*********************************************************
149	//compute the data you want from a lwo file
150	//*********************************************************
151
152	void LwoLoader::scanLwoFile(String &fileName)
153	{
154	textureNameList=new StringLinkedList();
155	binaryInput=new BinaryInput();
156	xVerticesArray=null;
157	yVerticesArray=null;
158	zVerticesArray=null;
159	polygonPoints=null;
160	polygonSurfaces=null;
161	surfaceMappingMethod=null;
162	surfaceColourArray=null;
163	surfaceTransparentArray=null;
164	surfaceTextureWrappingXArray=null;
165	surfaceTextureWrappingYArray=null;
166	surfaceXYZAxleArray=null;
167	surfaceTextureSizeXArray=null;
168	surfaceTextureSizeYArray=null;
169	surfaceTextureSizeZArray=null;
170	surfaceTextureCenterXArray=null;
171	surfaceTextureCenterYArray=null;
172	surfaceTextureCenterZArray=null;
173	polygonPoint1UArray=null;
174	polygonPoint1VArray=null;
175	polygonPoint2UArray=null;
176	polygonPoint2VArray=null;
177	polygonPoint3UArray=null;
178	polygonPoint3VArray=null;
179
180	binaryInput->readFile(fileName);
181
182	binaryInput->setBigEndian(true);
183	System::println(binaryInput->getWord(4));
184	System::println(binaryInput->getInt());
185	System::println(binaryInput->getWord(4));
186	bool diffJumpValue=false;
187
188	while (binaryInput->getBinaryStatus())
189	{
190	int jumpValue=0;
191
192	String chunk=binaryInput->getWord(4);
193	System::println(chunk);
194
195	if (chunk.equals("SURF"))
196	{
197	jumpValue=binaryInput->getInt();
198	System::println(binaryInput->getWord());
199	binaryInput->getChar();
200	diffJumpValue=true;
201	}
202	else
203	{
204	if (diffJumpValue)
205	{
206	jumpValue=(int)binaryInput->getShort();
207	}
208	else
209	{
210	jumpValue=binaryInput->getInt();
211	}
212
213	bool notJump=false;
214
215	notJump=computeChunkPNTS(chunk, jumpValue);
216
217	if (!notJump)
218	{
219	notJump=computeChunkSRFS(chunk, jumpValue);
220	}
221
222	if (!notJump)
223	{
224	notJump=computeChunkPOLS(chunk, jumpValue);
225	}
226
227	if (!notJump)
228	{
229	notJump=computeChunkCOLR(chunk, jumpValue);
230	}
231
232	if (!notJump)
233	{
234	notJump=computeChunkVTRN(chunk, jumpValue);
235	}
236
237	if (!notJump)
238	{
239	notJump=computeChunkCTEX(chunk, jumpValue);
240	}
241
242	if (!notJump)
243	{
244	notJump=computeChunkTIMG(chunk, jumpValue);
245	}
246
247	if (!notJump)
248	{
249	notJump=computeChunkTWRP(chunk, jumpValue);
250	}
251
252	if (!notJump)
253	{
254	notJump=computeChunkTFLG(chunk, jumpValue);
255	}
256
257	if (!notJump)
258	{
259	notJump=computeChunkTSIZ(chunk, jumpValue);
260	}
261
262	if (!notJump)
263	{
264	notJump=computeChunkTCTR(chunk, jumpValue);
265	}
266
267	if (!notJump)
268	{
269	binaryInput->jumpForward(jumpValue);
270	}
271	}
272	}
273
274	calcTextureMapping();
275
276	Object3d *objekt3d_ = objekt3dlist_[0]->add(xVerticesArray->size, polygonSurfaces->size,polygonPoints->size,textureNameList->size());
277
278	readttpoints(objekt3d_);
279
280	if (textureNameList->size()!=0)
281	{
282	for ( int t=0; t<textureNameList->size() ; t++ )
283	{
284	String filePath=textureNameList->getElement(t);
285	// System::println(filePath);
286	objekt3d_->settexturep((int)textureList->addLastWithNoDoubleName(new SGI(filePath),filePath.buffer),t);
287	}
288	}
289
290	readvertices(objekt3d_);
291	readprepareuv2(objekt3d_);
292	readvpoints(objekt3d_);
293	// readcolour(objekt3d_);
294	// readtransparent(objekt3d_);
295
296	objekt3d_->makenormtab();
297
298	remove();
299	}
300
301
302	bool LwoLoader::computeChunkPNTS(String &chunk, int chunkValue)
303	{
304	if (chunk.equals("PNTS"))
305	{
306	int numberOfVertices=(chunkValue/12);
307	System::println(numberOfVertices);
308
309	xVerticesArray = new FloatArray(numberOfVertices);
310	yVerticesArray = new FloatArray(numberOfVertices);
311	zVerticesArray = new FloatArray(numberOfVertices);
312
313	for ( int v=0 ; v<numberOfVertices ; v++ )
314	{
315	xVerticesArray->setFloat(binaryInput->getFloat(),v);
316	yVerticesArray->setFloat(binaryInput->getFloat(),v);
317	zVerticesArray->setFloat(binaryInput->getFloat(),v);
318	}
319
320	return true;
321	}
322
323	return false;
324	}
325
326	bool LwoLoader::computeChunkSRFS(String &chunk, int chunkValue)
327	{
328	if (chunk.equals("SRFS"))
329	{
330	numberOfSurfaces=0;
331
332	binaryInput->resetCharCounter();
333
334	while (binaryInput->getCharCounter() < chunkValue)
335	{
336	String surfaceName=binaryInput->getWord();
337	System::println(surfaceName);
338	if ((surfaceName.length&1) == 1)
339	{
340	binaryInput->getChar();
341	}
342	numberOfSurfaces++;
343	}
344
345	surfaceColourArray = new IntArray(numberOfSurfaces);
346	surfaceTransparentArray = new FloatArray(numberOfSurfaces);
347	surfaceMappingMethod = new IntArray(numberOfSurfaces);
348	surfaceTextureWrappingXArray = new IntArray(numberOfSurfaces);
349	surfaceTextureWrappingYArray = new IntArray(numberOfSurfaces);
350	surfaceXYZAxleArray = new IntArray(numberOfSurfaces);
351	surfaceTextureSizeXArray = new FloatArray(numberOfSurfaces);
352	surfaceTextureSizeYArray = new FloatArray(numberOfSurfaces);
353	surfaceTextureSizeZArray = new FloatArray(numberOfSurfaces);
354	surfaceTextureCenterXArray = new FloatArray(numberOfSurfaces);
355	surfaceTextureCenterYArray = new FloatArray(numberOfSurfaces);
356	surfaceTextureCenterZArray = new FloatArray(numberOfSurfaces);
357	return true;
358	}
359
360	return false;
361	}
362
363	bool LwoLoader::computeChunkPOLS(String &chunk, int chunkValue)
364	{
365	if (chunk.equals("POLS"))
366	{
367	int numberOfPoints=0;
368	int numberOfPolygonSurfaces=0;
369	int numberOfPolygons=0;
370
371	polygonPoints = new IntArray((int)(binaryInput->getInternBufferSize()/sizeof(int)));
372	polygonSurfaces = new IntArray((int)(binaryInput->getInternBufferSize()/sizeof(int)));
373
374	binaryInput->resetCharCounter();
375
376	while (binaryInput->getCharCounter() < chunkValue)
377	{
378	int numberOfFaces=(int)binaryInput->getShort();
379	numberOfFaces-=2;
380	numberOfPolygons+=numberOfFaces;
381	//System::println(numberOfPolygons);
382	short firstPoint=binaryInput->getShort();
383
384	for ( int p=0 ; p<numberOfFaces ; p++ )
385	{
386	polygonPoints->setInt((int)firstPoint,numberOfPoints);
387	numberOfPoints++;
388
389	polygonPoints->setInt((int)binaryInput->getShort(),numberOfPoints);
390	numberOfPoints++;
391
392	polygonPoints->setInt((int)binaryInput->getShortButGoNotFoward(),numberOfPoints);
393	numberOfPoints++;
394	}
395
396	binaryInput->getShort();
397	int surfaceID=(int)(binaryInput->getShort()-1);
398
399	for ( int p2=0 ; p2<numberOfFaces ; p2++ )
400	{
401	polygonSurfaces->setInt(surfaceID,numberOfPolygonSurfaces);
402	numberOfPolygonSurfaces++;
403	}
404
405	}
406
407	// System::println(binaryInput->getCharCounter()-chunkValue);
408
409	polygonPoints->size=numberOfPoints;
410	polygonSurfaces->size=numberOfPolygons;
411
412	String numberOfPolysName="numberOfPolys: ";
413	// System::println(numberOfPolysName + numberOfPolygons);
414
415	return true;
416	}
417
418	return false;
419	}
420
421	//*********************************************************
422	//colour
423	//*********************************************************
424
425	bool LwoLoader::computeChunkCOLR(String &chunk, int chunkValue)
426	{
427	if (chunk.equals("COLR"))
428	{
429	if (surfaceColourArray->getInternIndex() < numberOfSurfaces)
430	{
431	surfaceColourArray->setInt((binaryInput->getInt()));
432	System::println(surfaceColourArray->getInt());
433	surfaceColourArray->internIndexForward();
434	return true;
435	}
436	}
437
438	return false;
439	}
440
441	//*********************************************************
442	//transparent??
443	//*********************************************************
444
445	bool LwoLoader::computeChunkVTRN(String &chunk, int chunkValue)
446	{
447	if (chunk.equals("VTRN"))
448	{
449	if (surfaceTransparentArray->getInternIndex() < numberOfSurfaces)
450	{
451	surfaceTransparentArray->setFloat((binaryInput->getFloat()));
452	System::println(surfaceTransparentArray->getFloat());
453	surfaceTransparentArray->internIndexForward();
454	return true;
455	}
456	}
457
458	return false;
459	}
460
461	//*********************************************************
462	//planar cylindric or spherilic
463	//*********************************************************
464
465	bool LwoLoader::computeChunkCTEX(String &chunk, int chunkValue)
466	{
467	if (chunk.equals("CTEX"))
468	{
469	if (surfaceMappingMethod->getInternIndex() < numberOfSurfaces)
470	{
471	String mappingMethodName=binaryInput->getWord();
472	if ((mappingMethodName.length&1) == 1)
473	{
474	binaryInput->getChar();
475	}
476
477	bool statement=true;
478
479	if (mappingMethodName.equals("Planar Image Map"))
480	{
481	surfaceMappingMethod->setInt(1);
482	statement=false;
483	}
484
485	if (mappingMethodName.equals("Cylindric Image Map"))
486	{
487	surfaceMappingMethod->setInt(2);
488	statement=false;
489	}
490
491	if (mappingMethodName.equals("Spherelic Image Map"))
492	{
493	surfaceMappingMethod->setInt(3);
494	statement=false;
495	}
496
497	if (statement)
498	{
499	surfaceMappingMethod->setInt(0);
500	}
501
502	System::println(surfaceMappingMethod->getInt());
503
504	surfaceMappingMethod->internIndexForward();
505
506	return true;
507	}
508	}
509
510	return false;
511	}
512
513
514	//*********************************************************
515	//read texture name
516	//*********************************************************
517
518	bool LwoLoader::computeChunkTIMG(String &chunk, int chunkValue)
519	{
520	if (chunk.equals("TIMG"))
521	{
522	String word=binaryInput->getWord();
523
524	if ((word.length&1) == 1)
525	{
526	binaryInput->getChar();
527	}
528
529	word.cutTheBack(92);
530	word.cutTheBegining('.');
531
532	String filePath="data/texturer/";
533	String fulFilePath=filePath + word + ".rgb";
534	textureNameList->addLast(fulFilePath);
535	System::println(fulFilePath);
536
537	return true;
538	}
539
540	return false;
541	}
542
543	//*********************************************************
544	//texture wrapping
545	//*********************************************************
546
547	bool LwoLoader::computeChunkTWRP(String &chunk, int chunkValue)
548	{
549	if (chunk.equals("TWRP"))
550	{
551	if (surfaceTextureWrappingXArray->getInternIndex() < numberOfSurfaces)
552	{
553	surfaceTextureWrappingXArray->setInt((int)binaryInput->getShort());
554	surfaceTextureWrappingYArray->setInt((int)binaryInput->getShort());
555	System::println(surfaceTextureWrappingXArray->getInt());
556	System::println(surfaceTextureWrappingYArray->getInt());
557	surfaceTextureWrappingXArray->internIndexForward();
558	surfaceTextureWrappingYArray->internIndexForward();
559
560	return true;
561	}
562	}
563
564	return false;
565	}
566
567	//*********************************************************
568	//x or y or z axles
569	//*********************************************************
570
571	bool LwoLoader::computeChunkTFLG(String &chunk, int chunkValue)
572	{
573	if (chunk.equals("TFLG"))
574	{
575	if (surfaceXYZAxleArray->getInternIndex() < numberOfSurfaces)
576	{
577	int axle=(int)binaryInput->getShort();
578
579	int outPutAxle=0;
580
581	if( (axle&1) == 1)
582	{
583	outPutAxle=1;
584	}
585
586	if(((axle>>1)&1) == 1)
587	{
588	outPutAxle=2;
589	}
590
591	if(((axle>>2)&1) == 1)
592	{
593	outPutAxle=3;
594	}
595
596	surfaceXYZAxleArray->setInt(outPutAxle);
597	System::println(surfaceXYZAxleArray->getInt());
598	surfaceXYZAxleArray->internIndexForward();
599	return true;
600	}
601	}
602
603	return false;
604	}
605
606
607	//*********************************************************
608	//texture size x,y,z
609	//*********************************************************
610
611	bool LwoLoader::computeChunkTSIZ(String &chunk, int chunkValue)
612	{
613	if (chunk.equals("TSIZ"))
614	{
615	if (surfaceTextureSizeXArray->getInternIndex() < numberOfSurfaces)
616	{
617	surfaceTextureSizeXArray->setFloat(binaryInput->getFloat());
618	surfaceTextureSizeYArray->setFloat(binaryInput->getFloat());
619	surfaceTextureSizeZArray->setFloat(binaryInput->getFloat());
620	System::println(surfaceTextureSizeXArray->getFloat());
621	System::println(surfaceTextureSizeYArray->getFloat());
622	System::println(surfaceTextureSizeZArray->getFloat());
623	surfaceTextureSizeXArray->internIndexForward();
624	surfaceTextureSizeYArray->internIndexForward();
625	surfaceTextureSizeZArray->internIndexForward();
626
627	return true;
628	}
629	}
630
631	return false;
632	}
633
634	//*********************************************************
635	//texture center x,y,z
636	//*********************************************************
637
638	bool LwoLoader::computeChunkTCTR(String &chunk, int chunkValue)
639	{
640	if (chunk.equals("TCTR"))
641	{
642	if (surfaceTextureCenterXArray->getInternIndex() < numberOfSurfaces)
643	{
644	surfaceTextureCenterXArray->setFloat(binaryInput->getFloat());
645	surfaceTextureCenterYArray->setFloat(binaryInput->getFloat());
646	surfaceTextureCenterZArray->setFloat(binaryInput->getFloat());
647	System::println(surfaceTextureCenterXArray->getFloat());
648	System::println(surfaceTextureCenterYArray->getFloat());
649	System::println(surfaceTextureCenterZArray->getFloat());
650	surfaceTextureCenterXArray->internIndexForward();
651	surfaceTextureCenterYArray->internIndexForward();
652	surfaceTextureCenterZArray->internIndexForward();
653
654	return true;
655	}
656	}
657
658	return false;
659	}
660
661	//*********************************************************
662	// calculate texturemapping
663	//*********************************************************
664
665	void LwoLoader::calcTextureMapping()
666	{
667	polygonPoint1UArray = new FloatArray(polygonSurfaces->size);
668	polygonPoint1VArray = new FloatArray(polygonSurfaces->size);
669	polygonPoint2UArray = new FloatArray(polygonSurfaces->size);
670	polygonPoint2VArray = new FloatArray(polygonSurfaces->size);
671	polygonPoint3UArray = new FloatArray(polygonSurfaces->size);
672	polygonPoint3VArray = new FloatArray(polygonSurfaces->size);
673
674	for ( int p=0; p<polygonSurfaces->size ; p++ )
675	{
676	int whichPolygonPoint=0;
677	float u=0;
678	float v=0;
679
680	calcUVForAVertices(p, whichPolygonPoint, &u, &v);
681
682	polygonPoint1UArray->setFloat(u,p);
683	polygonPoint1VArray->setFloat(v,p);
684
685	whichPolygonPoint++;
686	u=0;
687	v=0;
688
689	calcUVForAVertices(p, whichPolygonPoint, &u, &v);
690
691	polygonPoint2UArray->setFloat(u,p);
692	polygonPoint2VArray->setFloat(v,p);
693
694	whichPolygonPoint++;
695	u=0;
696	v=0;
697
698	calcUVForAVertices(p, whichPolygonPoint, &u, &v);
699
700	polygonPoint3UArray->setFloat(u,p);
701	polygonPoint3VArray->setFloat(v,p);
702
703	}
704	}
705
706
707	void LwoLoader::calcUVForAVertices(int whichPolygon, int whichPolygonPoint, float u, float v)
708	{
709	int whichSurface=polygonSurfaces->getInt(whichPolygon);
710
711	float x=xVerticesArray->getFloat(polygonPoints->getInt(whichPolygon*3+whichPolygonPoint))-surfaceTextureCenterXArray->getFloat(whichSurface);
712	float y=yVerticesArray->getFloat(polygonPoints->getInt(whichPolygon*3+whichPolygonPoint))-surfaceTextureCenterYArray->getFloat(whichSurface);
713	float z=zVerticesArray->getFloat(polygonPoints->getInt(whichPolygon*3+whichPolygonPoint))-surfaceTextureCenterZArray->getFloat(whichSurface);
714
715
716	float xTextureSize=surfaceTextureSizeXArray->getFloat(whichSurface);
717	float yTextureSize=surfaceTextureSizeYArray->getFloat(whichSurface);
718	float zTextureSize=surfaceTextureSizeZArray->getFloat(whichSurface);
719	int axle=surfaceXYZAxleArray->getInt(whichSurface);
720
721	if (surfaceMappingMethod->getInt(whichSurface) == 1)
722	{
723	if (axle==3)
724	{
725	u[0]=(x/xTextureSize+0.5f);
726	v[0]=(-y/yTextureSize+0.5f);
727	}
728
729	if (axle==1)
730	{
731	u[0]=(-z/zTextureSize+0.5f);
732	v[0]=(-y/yTextureSize+0.5f);
733	}
734
735	if (axle==2)
736	{
737	u[0]=(z/zTextureSize+0.5f);
738	v[0]=(x/xTextureSize+0.5f);
739	}
740	}
741
742	/*
743	if ( ctex[whichSurface] == 2)
744	{
745	float rz;
746
747	if ( tflg[whichSurface] == 3 )
748	{
749	u=(x/tsiz[whichSurface*3+0]);
750	v=(-y/tsiz[whichSurface*3+1]);
751	rz=(-z/tsiz[whichSurface*3+2]);
752	}
753
754
755	if ( tflg[whichSurface] == 1 )
756	{
757	rz=(x/tsiz[whichSurface*3+0]);
758	v=(y/tsiz[whichSurface*3+1]);
759	u=(z/tsiz[whichSurface*3+2]);
760	}
761
762	if ( tflg[whichSurface] == 2 )
763	{
764	u=(z/tsiz[whichSurface*3+2]);
765	v=(x/tsiz[whichSurface*3+0]);
766	rz=(y/tsiz[whichSurface*3+1]);
767	}
768
769	//twrp[tpoints[v2]*2+0]
770	u=1.0f-((float)(((atan2(v,u)/2)*2)/3.14)+0.25f);
771	v=0.5f+(float)(rz);
772	}
773
774
775	if ( ctex[whichSurface] == 3)
776	{
777
778	if ( tflg[whichSurface] == 2 )
779	{
780	u=(z/tsiz[whichSurface*3+2]+0.5f);
781	v=(x/tsiz[whichSurface*3+0]+0.5f);
782	}
783
784	if ( tflg[whichSurface] == 1 )
785	{
786	u=(-z/tsiz[whichSurface*3+2]+0.5f);
787	v=(-y/tsiz[whichSurface*3+1]+0.5f);
788	}
789
790	if ( tflg[whichSurface] == 3 )
791	{
792	u=(x/tsiz[whichSurface*3+0]+0.5f);
793	v=(-y/tsiz[whichSurface*3+1]+0.5f);
794	}
795	//lon=twrp[tpoints[v2]2+0];
796	//lon=twrp[tpoints[v2]2+1];
797	}
798	*/
799	if ( u[0] < 0 )
800	{
801	u[0]*=-1;
802	}
803
804	if ( v[0] < 0 )
805	{
806	v[0]*=-1;
807	}
808
809
810	if ( u[0] > 1 )
811	{
812	u[0]=1;
813	}
814
815	if ( v[0] > 1)
816	{
817	v[0]=1;
818	}
819	}
820
821
822
823	//vertices
824
825	void LwoLoader::readvertices(Object3d *out)
826	{
827	for ( int n=0 ; n<xVerticesArray->size ; n++ )
828	{
829	out->setvx(xVerticesArray->getFloat(n),n);
830	out->setvy(yVerticesArray->getFloat(n),n);
831	out->setvz(zVerticesArray->getFloat(n),n);
832	}
833	}
834
835	// u,v cordinates
836
837	void LwoLoader::readprepareuv2(Object3d *out)
838	{
839	for ( int n=0 ; n<polygonSurfaces->size ; n++ )
840	{
841	out->setvu(polygonPoint1UArray->getFloat(n),n*3+0);
842	out->setvv(polygonPoint1VArray->getFloat(n),n*3+0);
843	out->setvu(polygonPoint2UArray->getFloat(n),n*3+1);
844	out->setvv(polygonPoint2VArray->getFloat(n),n*3+1);
845	out->setvu(polygonPoint3UArray->getFloat(n),n*3+2);
846	out->setvv(polygonPoint3VArray->getFloat(n),n*3+2);
847	}
848	}
849
850	// transparent
851
852	void LwoLoader::readtransparent(Object3d *out)
853	{
854	for ( int p=0; p<polygonSurfaces->size ; p++ )
855	{
856	// out->settransparent(transparent[p],p);
857	}
858
859	}
860
861	// colour
862
863	void LwoLoader::readcolour(Object3d *out)
864	{
865	for ( int p=0; p<polygonSurfaces->size ; p++ )
866	{
867	// out->setcolour(colour[p],p);
868	}
869	}
870
871	// vertices points
872
873	void LwoLoader::readvpoints(Object3d *out)
874	{
875	for ( int s=0 ; s<polygonPoints->size ; s++ )
876	{
877	out->setpoints(polygonPoints->getInt(s),s);
878	}
879	}
880
881	// texture address
882
883	void LwoLoader::readttpoints(Object3d *out)
884	{
885	for ( int s=0 ; s<polygonSurfaces->size ; s++ )
886	{
887	out->settpoints(polygonSurfaces->getInt(s),s);
888	}
889	}