void C3DS::ReadMeshVertices(stChunk* Chunk)
{
unsigned int iNumberVertices = 0;
Chunk->bytesRead += (unsigned int)fread(&iNumberVertices, 1, 2, m_fp);
// Allocate Memory and dump our vertices to the screen.
stVert *pVerts = new stVert[iNumberVertices];
Chunk->bytesRead += (unsigned int)fread( (void*)pVerts, 1, iNumberVertices*sizeof(stVert), m_fp);
stMesh* pMesh = &(m_pMeshs[m_iNumMeshs - 1]);
pMesh->pVerts = pVerts;
pMesh->iNumVerts = iNumberVertices;
// Crazy but true, the z and y need to be swapped around!
for(int i=0; i< pMesh->iNumVerts; i++)
{
pMesh->pVerts[i].x = pMesh->pVerts[i].x;
float tempz = pMesh->pVerts[i].y;
pMesh->pVerts[i].y = pMesh->pVerts[i].z;
pMesh->pVerts[i].z = tempz;
}
SkipChunk(Chunk);
}
// For reading the master chunk (ideally, whole file)
static bool ReadMaster(OpenedFile& OFile, int32 ParentChunkEnd)
{
int32 Location = 0;
OFile.GetPosition(Location);
while(Location < ParentChunkEnd)
{
ChunkHeaderData ChunkHeader;
if (!ReadChunkHeader(OFile,ChunkHeader)) return false;
switch(ChunkHeader.ID)
{
case EDITOR:
if (!ReadContainer(OFile,ChunkHeader,ReadEditor)) return false;
break;
default:
if (!SkipChunk(OFile,ChunkHeader)) return false;
}
// Where are we now?
OFile.GetPosition(Location);
}
if (Location > ParentChunkEnd)
{
if (DBOut)
fprintf(DBOut,"ERROR: Overran parent chunk: %ld > %ld\n",Location,ParentChunkEnd);
return false;
}
return true;
}
bool L3DS::FindChunk(LChunk &target, const LChunk &parent)
{
if (Pos() >= parent.end)
return false;
LChunk chunk;
chunk = ReadChunk();
while (( chunk.id != target.id) && (chunk.end <= parent.end))
{
SkipChunk(chunk);
if (chunk.end >= parent.end)
break;
unsigned short id = chunk.id;
uint end = chunk.end;
chunk = ReadChunk();
// try to detect a endless loop amz
if(id == chunk.id && end == chunk.end)
break;
}
if (chunk.id == target.id)
{
target.start = chunk.start;
target.end = chunk.end;
return true;
}
return false;
}
// For reading the face-data chunk
static bool ReadFaceData(OpenedFile& OFile, int32 ParentChunkEnd)
{
uint8 NFBuffer[2];
uint16 NumFaces;
if (!OFile.Read(2,NFBuffer))
{
logError1("ERROR reading number of faces in %s",Path);
return false;
}
uint8 *S = NFBuffer;
StreamToValue(S,NumFaces);
int32 DataSize = 4*sizeof(uint16)*int(NumFaces);
SetChunkBufferSize(DataSize);
if (!OFile.Read(DataSize,ChunkBufferBase()))
{
logError1("ERROR reading face-chunk contents in %s",Path);
return false;
}
S = ChunkBufferBase();
ModelPtr->VertIndices.resize(3*NumFaces);
for (int k=0; k<NumFaces; k++)
{
uint16 *CurrPoly = ModelPtr->VIBase() + 3*k;
uint16 Flags;
StreamToList(S,CurrPoly,3);
StreamToValue(S,Flags);
}
int32 Location = 0;
OFile.GetPosition(Location);
while(Location < ParentChunkEnd)
{
ChunkHeaderData ChunkHeader;
if (!ReadChunkHeader(OFile,ChunkHeader)) return false;
switch(ChunkHeader.ID)
{
/*
case OBJECT:
if (!ReadContainer(OFile,ChunkHeader,ReadObject)) return false;
break;
*/
default:
if (!SkipChunk(OFile,ChunkHeader)) return false;
}
// Where are we now?
OFile.GetPosition(Location);
}
if (Location > ParentChunkEnd)
{
logError3("ERROR: Overran parent chunk: %d > %d in %s",Location,ParentChunkEnd,Path);
return false;
}
return true;
}
// For reading the editor-data chunk
static bool ReadEditor(OpenedFile& OFile, int32 ParentChunkEnd)
{
int32 Location = 0;
OFile.GetPosition(Location);
while(Location < ParentChunkEnd)
{
ChunkHeaderData ChunkHeader;
if (!ReadChunkHeader(OFile,ChunkHeader)) return false;
switch(ChunkHeader.ID)
{
case OBJECT:
if (!ReadContainer(OFile,ChunkHeader,ReadObject)) return false;
break;
default:
if (!SkipChunk(OFile,ChunkHeader)) return false;
}
// Where are we now?
OFile.GetPosition(Location);
}
if (Location > ParentChunkEnd)
{
logError3("ERROR: Overran parent chunk: %d > %d in %s",Location,ParentChunkEnd,Path);
return false;
}
return true;
}
void L3DS::ReadCamera(const LChunk &parent)
{
LVector3 v,t;
LCamera camera;
camera.SetName(m_objName);
v.x = ReadFloat();
v.y = ReadFloat();
v.z = ReadFloat();
t.x = ReadFloat();
t.y = ReadFloat();
t.z = ReadFloat();
camera.SetPosition(v);
camera.SetTarget(t);
camera.SetBank(ReadFloat());
camera.SetFOV(2400.0f/ReadFloat());
LChunk chunk = ReadChunk();
while (chunk.end <= parent.end)
{
switch (chunk.id)
{
case CAM_RANGES:
camera.SetNearplane(ReadFloat());
camera.SetFarplane(ReadFloat());
break;
default:
break;
}
SkipChunk(chunk);
if (chunk.end >= parent.end)
break;
chunk = ReadChunk();
}
m_cameras.push_back(camera);
}
void ReadRGB(int Format, unsigned char &Red, unsigned char &Green, unsigned char &Blue){
switch (Format){
case M3D_3DS_RGB3F:
Red = (unsigned char)Stream->ReadFloat()*255;
Green = (unsigned char)Stream->ReadFloat()*255;
Blue = (unsigned char)Stream->ReadFloat()*255;
break;
case M3D_3DS_RGB3B:
Red = Stream->ReadByte();
Green = Stream->ReadByte();
Blue = Stream->ReadByte();
break;
case M3D_3DS_RGBGAMMA3F:
Red = (unsigned char)Stream->ReadFloat()*255;
Green = (unsigned char)Stream->ReadFloat()*255;
Blue = (unsigned char)Stream->ReadFloat()*255;
break;
case M3D_3DS_RGBGAMMA3B:
Red = Stream->ReadByte();
Green = Stream->ReadByte();
Blue = Stream->ReadByte();
break;
default:
SkipChunk();
}
}
__regargs PaletteT *LoadPalette(const char *filename) {
PaletteT *palette = NULL;
IffFileT iff;
if (OpenIff(&iff, filename)) {
if (iff.header.type == ID_ILBM) {
while (ParseChunk(&iff)) {
switch (iff.chunk.type) {
case ID_CMAP:
palette = NewPalette(iff.chunk.length / sizeof(ColorT));
ReadChunk(&iff, palette->colors);
break;
default:
SkipChunk(&iff);
break;
}
}
}
CloseIff(&iff);
}
return palette;
}
void L3DS::ReadFaceList(const LChunk &chunk, LMesh &mesh)
{
// variables
unsigned short count, t;
uint i;
LTri tri;
LChunk ch;
char str[20];
//uint mat;
// consistency checks
if (chunk.id != TRI_FACELIST)
{
ErrorMsg("L3DS::ReadFaceList - internal error: wrong chunk passed as parameter");
return;
}
GotoChunk(chunk);
tri.smoothingGroups = 1;
// read the number of faces
count = ReadShort();
mesh.SetTriangleArraySize(count);
for (i=0; i<count; i++)
{
tri.a = ReadShort();
tri.b = ReadShort();
tri.c = ReadShort();
ReadShort();
mesh.SetTri(tri, i);
}
// now read the optional chunks
ch = ReadChunk();
int mat_id;
while (ch.end <= chunk.end)
{
switch (ch.id)
{
case TRI_MAT_GROUP:
ReadASCIIZ(str, 20);
mat_id=0;
if (FindMaterial(str)!=NULL)
mat_id = FindMaterial(str)->GetID();
mesh.AddMaterial(mat_id);
count = ReadShort();
for (i=0; i<count; i++)
{
t = ReadShort();
mesh.GetTri(t).materialId = mat_id;
}
break;
case TRI_SMOOTH_GROUP:
for (i=0; i<mesh.GetTriangleCount(); i++)
mesh.GetTri(i).smoothingGroups = (ulong) ReadInt();
break;
}
SkipChunk(ch);
ch = ReadChunk();
}
}
// For reading the object-data chunk
static bool ReadObject(OpenedFile& OFile, int32 ParentChunkEnd)
{
// Read the name
if (DBOut) fprintf(DBOut,"Object Name: ");
while(true)
{
char c;
if (!OFile.Read(1,&c))
{
if (DBOut) fprintf(DBOut,"ERROR in reading name");
return false;
}
if (c == 0)
{
if (DBOut) fprintf(DBOut,"\n");
break;
}
else
{
if (DBOut) fprintf(DBOut,"%c",c);
}
}
int32 Location = 0;
OFile.GetPosition(Location);
while(Location < ParentChunkEnd)
{
ChunkHeaderData ChunkHeader;
if (!ReadChunkHeader(OFile,ChunkHeader)) return false;
switch(ChunkHeader.ID)
{
case TRIMESH:
if (!ReadContainer(OFile,ChunkHeader,ReadTrimesh)) return false;
break;
default:
if (!SkipChunk(OFile,ChunkHeader)) return false;
}
// Where are we now?
OFile.GetPosition(Location);
}
if (Location > ParentChunkEnd)
{
if (DBOut)
fprintf(DBOut,"ERROR: Overran parent chunk: %ld > %ld\n",Location,ParentChunkEnd);
return false;
}
return true;
}
void C3DS::ReadNameOfObjectToAnimate(stChunk* Chunk)
{
char str[256];
Chunk->bytesRead += GetString(str);
stAnimation* pAnim = &(m_pAnimation[m_iNumAnimObjects - 1]);
strcpy(pAnim->szObjName, str);
// Skip hierachy
SkipChunk(Chunk);
}
unsigned char ReadPercent(int Format){
switch (Format){
case M3D_3DS_PERCENTI:
return (int)Stream->ReadShort();
case M3D_3DS_PERCENTF:
return (int)Stream->ReadFloat();
default:
SkipChunk();
return 0.0;
}
}
void C3DS::ReadMeshTexCoords(stChunk* Chunk)
{
unsigned short iNumberVertices = 0;
Chunk->bytesRead += (unsigned int)fread(&iNumberVertices, 1, 2, m_fp);
// Allocate Memory and dump our texture for each vertice to the screen.
stTex *pTex = new stTex[iNumberVertices];
Chunk->bytesRead += (unsigned int)fread( (void*)pTex, 1, iNumberVertices*sizeof(stTex), m_fp);
stMesh* pMesh = &(m_pMeshs[m_iNumMeshs - 1]);
pMesh->pTexs = pTex;
SkipChunk(Chunk);
}
void L3DS::ReadLight(const LChunk &parent)
{
float t;
LVector3 v;
LLight light;
light.SetName(m_objName);
v.x = ReadFloat();
v.y = ReadFloat();
v.z = ReadFloat();
light.SetPosition(v);
LChunk chunk = ReadChunk();
while (chunk.end <= parent.end)
{
switch (chunk.id)
{
case COLOR_24:
case COLOR_F:
case LIN_COLOR_F:
case LIN_COLOR_24:
light.SetColor(ReadColor(chunk));
break;
case SPOTLIGHT:
v.x = ReadFloat();
v.y = ReadFloat();
v.z = ReadFloat();
light.SetTarget(v);
t = ReadFloat();
light.SetHotspot(t);
t = ReadFloat();
light.SetFalloff(t);
break;
case LIT_INRANGE:
light.SetAttenuationstart(ReadFloat());
break;
case LIT_OUTRANGE:
light.SetAttenuationend(ReadFloat());
break;
default:
break;
}
SkipChunk(chunk);
if (chunk.end >= parent.end)
break;
chunk = ReadChunk();
}
m_lights.push_back(light);
}
// Ambient (rgb)
void C3DS::GetAmbientColour(stChunk* Chunk)
{
struct stRGB{ unsigned char r, g, b; };
stRGB AmbColour;
char ChunkHeader[6];
Chunk->bytesRead += (unsigned int)fread(ChunkHeader, 1, 6, m_fp);
Chunk->bytesRead += (unsigned int)fread(&AmbColour, 1, 3, m_fp);
stMaterial* pM = &(m_pMaterials[m_iNumMaterials-1]);
pM->Ambient.r = AmbColour.r;
pM->Ambient.g = AmbColour.g;
pM->Ambient.b = AmbColour.b;
SkipChunk(Chunk);
}
// Read in our diffuse colour (rgb)
void C3DS::GetDiffuseColour(stChunk* Chunk)
{
struct stRGB{ unsigned char r, g, b; };
stRGB DiffColour;
char ChunkHeader[6];
Chunk->bytesRead += (unsigned int)fread(ChunkHeader, 1, 6, m_fp);
Chunk->bytesRead += (unsigned int)fread(&DiffColour, 1, 3, m_fp);
stMaterial* pM = &(m_pMaterials[m_iNumMaterials-1]);
pM->Colour.r = DiffColour.r;
pM->Colour.g = DiffColour.g;
pM->Colour.b = DiffColour.b;
SkipChunk(Chunk);
}
void C3DS::ReadMeshVertices(stChunk* Chunk)
{
unsigned int iNumberVertices = 0;
Chunk->bytesRead += (unsigned int)fread(&iNumberVertices, 1, 2, m_fp);
// Allocate Memory and dump our vertices to the screen.
stVert *pVerts = new stVert[iNumberVertices];
stVert *pNormalVerts = new stVert[iNumberVertices];
Chunk->bytesRead += (unsigned int)fread( (void*)pVerts, 1, iNumberVertices*sizeof(stVert), m_fp);
stMesh* pMesh = &(m_pMeshs[m_iNumMeshs - 1]);
pMesh->pVerts = pVerts;
pMesh->pNormalVerts = pNormalVerts;
pMesh->iNumVerts = iNumberVertices;
SkipChunk(Chunk);
}
// For reading the triangle-mesh-data chunk
static bool ReadTrimesh(OpenedFile& OFile, int32 ParentChunkEnd)
{
int32 Location = 0;
OFile.GetPosition(Location);
assert(ModelPtr);
while(Location < ParentChunkEnd)
{
ChunkHeaderData ChunkHeader;
if (!ReadChunkHeader(OFile,ChunkHeader)) return false;
switch(ChunkHeader.ID)
{
case VERTICES:
if (!LoadChunk(OFile,ChunkHeader)) return false;
LoadVertices();
break;
case TXTR_COORDS:
if (!LoadChunk(OFile,ChunkHeader)) return false;
LoadTextureCoordinates();
break;
case FACE_DATA:
if (!ReadContainer(OFile,ChunkHeader,ReadFaceData)) return false;
break;
default:
if (!SkipChunk(OFile,ChunkHeader)) return false;
}
// Where are we now?
OFile.GetPosition(Location);
}
if (Location > ParentChunkEnd)
{
if (DBOut)
fprintf(DBOut,"ERROR: Overran parent chunk: %ld > %ld\n",Location,ParentChunkEnd);
return false;
}
return true;
}
// For reading the object-data chunk
static bool ReadObject(OpenedFile& OFile, int32 ParentChunkEnd)
{
// Read the name
char c;
do
{
if (!OFile.Read(1,&c))
{
logError1("ERROR when reading name in %s",Path);
return false;
}
}
while(c != 0);
int32 Location = 0;
OFile.GetPosition(Location);
while(Location < ParentChunkEnd)
{
ChunkHeaderData ChunkHeader;
if (!ReadChunkHeader(OFile,ChunkHeader)) return false;
switch(ChunkHeader.ID)
{
case TRIMESH:
if (!ReadContainer(OFile,ChunkHeader,ReadTrimesh)) return false;
break;
default:
if (!SkipChunk(OFile,ChunkHeader)) return false;
}
// Where are we now?
OFile.GetPosition(Location);
}
if (Location > ParentChunkEnd)
{
logError3("ERROR: Overran parent chunk: %d > %d in %s",Location,ParentChunkEnd,Path);
return false;
}
return true;
}
bool L3DS::FindChunk(LChunk &target, const LChunk &parent)
{
if (Pos() >= parent.end)
return false;
LChunk chunk;
chunk = ReadChunk();
while (( chunk.id != target.id) && (chunk.end <= parent.end))
{
SkipChunk(chunk);
if (chunk.end >= parent.end)
break;
chunk = ReadChunk();
}
if (chunk.id == target.id)
{
target.start = chunk.start;
target.end = chunk.end;
return true;
}
return false;
}
int main() {
UWORD len = __commandlen;
STRPTR filename = __builtin_alloca(len);
IffFileT iff;
memcpy(filename, __commandline, len--);
filename[len] = '\0';
OpenIff(&iff, filename);
Log("Parsing '%s':\n", filename);
Log("%.4s %ld\n", (STRPTR)&iff.header.type, iff.header.length);
while (ParseChunk(&iff)) {
Log(".%.4s %ld\n", (STRPTR)&iff.chunk.type, iff.chunk.length);
SkipChunk(&iff);
}
CloseIff(&iff);
return 0;
}
void L3DS::ReadMap(const LChunk &chunk, LMap& map)
{
LChunk child;
char str[20];
GotoChunk(chunk);
child = ReadChunk();
while (child.end <= chunk.end)
{
switch (child.id)
{
case INT_PERCENTAGE:
map.strength = ReadPercentage(child);
break;
case MAT_MAPNAME:
ReadASCIIZ(str, 20);
strcpy(map.mapName, str);
break;
case MAT_MAP_TILING:
map.tiling = ReadShort();
break;
case MAT_MAP_USCALE:
map.uScale = ReadFloat();
break;
case MAT_MAP_VSCALE:
map.vScale = ReadFloat();
break;
case MAT_MAP_UOFFSET:
map.uOffset = ReadFloat();
break;
case MAT_MAP_VOFFSET:
map.vOffset = ReadFloat();
break;
case MAT_MAP_ANG:
map.angle = ReadFloat();
break;
}
SkipChunk(child);
child = ReadChunk();
}
}
__regargs BitmapT *LoadILBM(const char *filename, BOOL interleaved) {
BitmapT *bitmap = NULL;
PaletteT *palette = NULL;
IffFileT iff;
if (OpenIff(&iff, filename)) {
if (iff.header.type == ID_ILBM) {
BOOL compression = FALSE;
while (ParseChunk(&iff)) {
BitmapHeaderT bmhd;
switch (iff.chunk.type) {
case ID_BMHD:
ReadChunk(&iff, &bmhd);
bitmap = NewBitmap(bmhd.w, bmhd.h, bmhd.nPlanes, interleaved);
compression = bmhd.compression;
break;
case ID_CMAP:
palette = NewPalette(iff.chunk.length / sizeof(ColorT));
ReadChunk(&iff, palette->colors);
break;
case ID_BODY:
{
BYTE *data = MemAlloc(iff.chunk.length, MEMF_PUBLIC);
LONG size = iff.chunk.length;
ReadChunk(&iff, data);
if (compression) {
LONG newSize = bitmap->bplSize * bitmap->depth;
BYTE *uncompressed = MemAlloc(newSize, MEMF_PUBLIC);
UnRLE(data, size, uncompressed);
MemFree(data, size);
data = uncompressed;
size = newSize;
}
if (!interleaved)
Deinterleave(data, bitmap);
else
memcpy(bitmap->planes[0], data, bitmap->bplSize * bitmap->depth);
MemFree(data, size);
}
break;
default:
SkipChunk(&iff);
break;
}
}
if (bitmap)
bitmap->palette = palette;
}
CloseIff(&iff);
} else {
Log("File '%s' missing.\n", filename);
}
return bitmap;
}
Mesh* Load3ds(string URL, Entity* parent_ent){
int Size;
//Local OldDir:String
unsigned char Red, Green, Blue;
//unsigned char Percent;
//Local Pixmap:TPixmap
Stream = File::ReadResourceFile(URL);
if (Stream == 0) return 0;
//Size = Stream.Size()
fseek(Stream->pFile, 0, SEEK_END); // seek to end of file
Size = ftell(Stream->pFile); // get current file pointer
fseek(Stream->pFile, 0, SEEK_SET);
// Read Main-Chunk
ReadChunk();
if (ChunkID != M3D_3DS_MAIN || ChunkSize != Size) {
Stream->CloseFile();
//Print "No 3DS File"
return 0;
}
// Find 3DEditor-Chunk
while (Stream->Eof()==0){
ReadChunk();
if (ChunkID == M3D_3DS_3DEDITOR){
break;
}else{
SkipChunk();
}
}
//OldDir = CurrentDir()
//If String(URL) <> "" Then ChangeDir(ExtractDir(String(URL)))
mesh = Mesh::CreateMesh();
while (Stream->Eof()==0){
ReadChunk();
switch (ChunkID){
case M3D_3DS_OBJECTBLOCK:
ReadCString(); // ' ObjectName
break;
case M3D_3DS_BrushBLOCK:
ReadBrushBlock();
break;
case M3D_3DS_TRIMESH:
ReadTriMesh();
break;
case M3D_3DS_VERTEXLIST:
ReadVertexList();
break;
case M3D_3DS_FACELIST:
ReadFaceList();
break;
case M3D_3DS_FACEMATLIST:
ReadFaceMatList();
break;
case M3D_3DS_TEXCOORDS:
ReadTexCoords();
break;
case M3D_3DS_BrushNAME:
//Loader.Brush = CreateBrush()
brush->name = ReadCString();
break;
case M3D_3DS_BrushAMBIENT:
//ReadChunk();
//ReadRGB(ChunkID, Red, Green, Blue);
//brush->SetAmbientColor(Red, Green, Blue);
break;
case M3D_3DS_BrushDIFFUSE:
ReadChunk();
ReadRGB(ChunkID, Red, Green, Blue);
brush->BrushColor(Red, Green, Blue);
break;
case M3D_3DS_BrushSPECULAR:
//'Loader.ReadChunk()
//'Loader.ReadRGB(Loader.ChunkID, Red, Green, Blue)
//'Loader.Brush.SetSpecularColor(Red, Green, Blue)
break;
case M3D_3DS_BrushSHININESS:
//'Loader.ReadChunk()
//'Percent = Loader.ReadPercent(Loader.ChunkID)
//'Loader.Brush.BrushShininess(Percent)
break;
case M3D_3DS_MAPFILENAME:
LoadMap();
break;
case M3D_3DS_MAPVSCALE:
texture->v_scale = Stream->ReadFloat();
break;
case M3D_3DS_MAPUSCALE:
texture->u_scale = Stream->ReadFloat();
break;
case M3D_3DS_MAPUOFFSET:
texture->u_pos = Stream->ReadFloat();
break;
case M3D_3DS_MAPVOFFSET:
texture->v_pos = Stream->ReadFloat();
break;
case M3D_3DS_MAPROTATION:
texture->angle = Stream->ReadFloat();
break;
default:
if ((ChunkID == M3D_3DS_TEXTUREMAP1) || (ChunkID == M3D_3DS_TEXTUREMAP2)) {
ReadMap(ChunkID);
}else{
SkipChunk();
}
}
}
Stream->CloseFile();
if (surface!=0){
MovedTris.sort();
int CheckSurface=0;
for(list<int>::const_reverse_iterator it = MovedTris.rbegin(); it != MovedTris.rend(); it++){
surface->RemoveTri(*it);
CheckSurface=1;
}
MovedTris.clear();
if (surface->no_tris==0 && CheckSurface !=0) {
delete surface;
mesh->surf_list.remove(surface);
mesh->no_surfs=mesh->no_surfs-1;
}
}
// ChangeDir(OldDir)
// Loader.Surface.UpdateVertices()
// Loader.Surface.UpdateTriangles()
mesh->UpdateNormals();
/*Loader.Mesh.UpdateBuffer()
Print Loader.Surface.Tris.Length
Print Loader.Surface.no_verts
'Loader.Mesh.FlipMesh()*/
mesh->class_name="Mesh";
mesh->AddParent(*parent_ent);
Entity::entity_list.push_back(mesh);
if(mesh->parent!=0){
mesh->mat.Overwrite(mesh->parent->mat);
mesh->UpdateMat();
}else{
mesh->UpdateMat(true);
}
return mesh;
}
void sXSILoader::ScanMatLib(sInt indent)
{
sChar chunk[XSISIZE];
sChar name[XSISIZE];
sChar texname[256];
sChar buffer[XSISIZE];
sChar pname[XSISIZE];
sChar tname[XSISIZE];
sChar tsup[2][XSISIZE];
sInt texena[2];
sXSIMaterial *mat;
sXSITexture *tex;
sInt i,max;
sInt pcount,ccount;
sInt ival;
sF32 fval;
ScanInt();
while(*Scan!=0 && *Scan!='}' && !Error)
{
ScanChunk(indent,chunk,name);
if(sCmpString(chunk,"SI_Material")==0)
{
mat = new sXSIMaterial;
sCopyString(mat->Name,name,sizeof(mat->Name));
mat->Flags |= 0;
Materials->Add(mat);
ScanFloat(); ScanFloat(); ScanFloat(); ScanFloat();
ScanFloat(); ScanFloat(); ScanFloat(); ScanFloat();
ScanFloat(); ScanFloat(); ScanFloat();
ScanInt();
ScanFloat(); ScanFloat(); ScanFloat();
sScanSpace(Scan);
while(*Scan!=0 && *Scan!='}' && !Error)
{
ScanChunk(indent+1,chunk,name);
if(sCmpString(chunk,"SI_Texture2D")==0)
{
ScanString(texname,sizeof(texname));
ScanInt(); ScanInt(); ScanInt(); ScanInt();
ScanInt(); ScanInt(); ScanInt(); ScanInt();
ScanInt(); ScanInt(); ScanInt(); ScanInt();
ScanFloat(); ScanFloat(); ScanFloat(); ScanFloat();
ScanFloat(); ScanFloat(); ScanFloat(); ScanFloat();
ScanFloat(); ScanFloat(); ScanFloat(); ScanFloat();
ScanFloat(); ScanFloat(); ScanFloat(); ScanFloat();
ScanFloat(); ScanFloat(); ScanFloat(); ScanFloat();
ScanInt();
ScanFloat(); ScanFloat(); ScanFloat(); ScanFloat();
ScanFloat(); ScanFloat(); ScanFloat();
EndChunk();
if(mat->Tex[0] == 0)
{
tex = FindTexture(texname);
if(tex)
mat->Tex[0] = tex;
}
}
else
{
SkipChunk();
}
sScanSpace(Scan);
}
EndChunk();
}
else if(sCmpString(chunk,"XSI_Material")==0)
{
mat = new sXSIMaterial;
sCopyString(mat->Name,name,sizeof(mat->Name));
mat->TFlags[0] = 0;
mat->TFlags[1] = 0;
mat->Flags |= 0;
sDPrintF("%08x:<%s>\n",Scan,name);
Materials->Add(mat);
max = ScanInt();
for(i=0;i<max;i++)
{
ScanString(buffer,sizeof(buffer));
ScanString(buffer,sizeof(buffer));
}
sScanSpace(Scan);
tsup[0][0]=0;
tsup[0][1]=0;
texena[0] = 0;
texena[1] = 0;
while(*Scan!=0 && *Scan!='}' && !Error)
{
ScanChunk(indent+1,chunk,name);
if(sCmpString(chunk,"XSI_Shader")==0)
{
ScanString(buffer,sizeof(buffer));
ScanInt();
pcount = ScanInt();
ccount = ScanInt();
for(i=0;i<pcount;i++)
{
ScanString(pname,sizeof(pname));
ScanString(tname,sizeof(tname));
if(sCmpString(tname,"STRING")==0)
{
ScanString(buffer,sizeof(buffer));
if(sCmpString(pname,"tspace_id1")==0) sCopyString(tsup[0],buffer,sizeof(tsup[0]));
if(sCmpString(pname,"tspace_id" )==0) sCopyString(tsup[0],buffer,sizeof(tsup[0]));
if(sCmpString(pname,"tspace_id2")==0) sCopyString(tsup[1],buffer,sizeof(tsup[1]));
}
else if(sCmpString(tname,"FLOAT")==0)
{
fval = ScanFloat();
ival = sRange<sInt>(255*fval,255,0);
if(sCmpString(pname,"Ambient.red")==0) mat->Ambient.r = ival;
if(sCmpString(pname,"Ambient.green")==0) mat->Ambient.g = ival;
if(sCmpString(pname,"Ambient.blue")==0) mat->Ambient.b = ival;
if(sCmpString(pname,"Diffuse.red")==0) mat->Diffuse.r = ival;
if(sCmpString(pname,"Diffuse.green")==0) mat->Diffuse.g = ival;
if(sCmpString(pname,"Diffuse.blue")==0) mat->Diffuse.b = ival;
if(sCmpString(pname,"Specular.red")==0) mat->Specular.r = ival;
if(sCmpString(pname,"Specular.green")==0) mat->Specular.g = ival;
if(sCmpString(pname,"Specular.blue")==0) mat->Specular.b = ival;
if(sCmpString(pname,"Shininess")==0) mat->Specularity = fval;
}
else if(sCmpString(tname,"INTEGER")==0)
{
ival = ScanInt();
}
else if(sCmpString(tname,"BOOLEAN")==0)
{
ival = ScanInt();
if(ival!=0)
{
// if(sCmpString(pname,"WrapS1")==0) mat->TFlags[0] |= sMTF_TILE;
// if(sCmpString(pname,"WrapT1")==0) mat->TFlags[0] |= sMTF_TILE;
if(sCmpString(pname,"Refmap1")==0) mat->TFlags[0] |= sMTF_UVENVI;
if(sCmpString(pname,"Texture_1_Enable")==0) texena[0]=1;
// if(sCmpString(pname,"WrapS2")==0) mat->TFlags[1] |= sMTF_TILE;
// if(sCmpString(pname,"WrapT2")==0) mat->TFlags[1] |= sMTF_TILE;
if(sCmpString(pname,"Refmap2")==0) mat->TFlags[1] |= sMTF_UVENVI;
if(sCmpString(pname,"Texture_2_Enable")==0) texena[1]=1;
}
else
{
if(sCmpString(pname,"Enable_Ambient")==0) mat->Ambient = 0xffffffff;
if(sCmpString(pname,"Enable_Diffuse")==0) mat->Diffuse = 0xffffffff;
if(sCmpString(pname,"Enable_Specular")==0) mat->Specular = 0xffffffff;
if(sCmpString(pname,"Enable_Shininess")==0) mat->Specularity = 0;
// if(sCmpString(pname,"Enable_Lighting")==0) mat->Flags &= ~sMF_LIGHTMASK;
}
}
else
{
Error = sTRUE;
}
}
for(i=0;i<ccount;i++)
{
ScanString(pname,sizeof(pname));
ScanString(buffer,sizeof(buffer));
ScanString(tname,sizeof(tname));
if(sCmpString(tname,"IMAGE")==0)
{
if((sCmpString(pname,"Texture_1")==0 || sCmpString(pname,"tex")==0) && texena[0])
{
if(mat->Tex[0] == 0
&& (tsup[0][0]!=0 || (mat->TFlags[0]&sMTF_UVMASK)==sMTF_UVENVI)
&& TSCount<sXSI_MAXTS)
{
tex = FindTexture(buffer);
if(tex)
{
mat->Tex[0] = tex;
mat->Mode = sMBM_TEX;
sCopyString(TSName[TSCount],tsup[0],XSISIZE);
mat->TUV[0] = TSCount++;
}
}
}
if(sCmpString(pname,"Texture_2")==0 && texena[1])
{
if(mat->Tex[1] == 0
&& (tsup[1][0]!=0 || (mat->TFlags[1]&sMTF_UVMASK)==sMTF_UVENVI)
&& TSCount<sXSI_MAXTS)
{
tex = FindTexture(buffer);
if(tex)
{
mat->Tex[1] = tex;
mat->Mode = sMBM_MUL;
// mat->TFlags[1] = sMTF_FILTER|sMTF_MIPMAP;//|sMTF_UVENVI;
sCopyString(TSName[TSCount],tsup[1],XSISIZE);
mat->TUV[1] = TSCount++;
}
}
}
}
}
sScanSpace(Scan);
while(*Scan!=0 && *Scan!='}' && !Error)
{
ScanChunk(indent+1,chunk,name);
SkipChunk();
sScanSpace(Scan);
}
EndChunk();
}
else
{
SkipChunk();
}
sScanSpace(Scan);
}
if((mat->TFlags[1] & sMTF_UVMASK)==0)
mat->TFlags[1] |= sMTF_UV1;
if(mat->Specularity>0.0001f || mat->Ambient!=0xffffffff
|| mat->Diffuse != 0xffffffff || mat->Specular != 0xffffffff)
{
// mat->Flags = (mat->Flags & (~sMF_LIGHTMASK)) | sMF_LIGHTMAT;
// sDPrintF("extlight: %08x %08x %08x\n",mat->Diffuse.Color,mat->Ambient.Color,mat->Specular.Color);
}
else
{
// mat->Flags |= sMF_COLBOTH;
}
mat->TFlags[0] |= sMTF_FILTERMIN | sMTF_FILTERMAG | sMTF_MIPMAP;
mat->TFlags[1] |= sMTF_FILTERMIN | sMTF_FILTERMAG | sMTF_MIPMAP;
EndChunk();
}
else
{
SkipChunk();
}
sScanSpace(Scan);
}
EndChunk();
}
void C3DS::ParseChunk(stChunk* Chunk){
while(Chunk->bytesRead < Chunk->length){
stChunk tempChunk = {0, 0, 0};
ReadChunk(&tempChunk);
switch( tempChunk.ID){
// HEADER OUR ENTRY POINT
case EDIT3DS: //0x3D3D
ParseChunk(&tempChunk);
break;
// MATERIALS
case MATERIAL: //0xAFFF
stMaterial newMaterial;
m_pMaterials.push_back(newMaterial);
m_iNumMaterials++;
ParseChunk(&tempChunk);
break;
case MAT_NAME: //0xA000 - sz for hte material name "e.g. default 2"
GetMaterialName(&tempChunk);
break;
case MAT_DIFFUSE: // Diffuse Colour //0xA020
GetDiffuseColour(&tempChunk);
break;
case MAT_TEXMAP: //0xA200 - if there's a texture wrapped to it where here
ParseChunk(&tempChunk);
break;
case MAT_TEXFLNM: // 0xA300 - get filename of the material
GetTexFileName(&tempChunk);
break;
// OBJECT - MESH'S
case NAMED_OBJECT:{
stMesh newMesh;
m_pMeshs.push_back(newMesh);
m_iNumMeshs++;
GetMeshObjectName(&tempChunk);
}
break;
case OBJ_MESH: //0x4100
ParseChunk(&tempChunk);
break;
case MESH_VERTICES: //0x4110
ReadMeshVertices(&tempChunk);
break;
case MESH_FACES: //0x4120
ReadMeshFaces(&tempChunk);
break;
case MESH_TEX_VERT: //0x4140
ReadMeshTexCoords(&tempChunk);
break;
case MESH_MATER: //0x4130
ReadMeshMaterials(&tempChunk);
break;
default:
SkipChunk(&tempChunk);
}
Chunk->bytesRead += tempChunk.length;
}
}
bool L3DS::Read3DS()
{
LChunk mainchunk;
LChunk edit;
edit.id = EDIT3DS;
mainchunk = ReadChunk();
if (mainchunk.id != MAIN3DS)
{
fprintf(stderr, "L3DS::Read3DS - wrong file format");
return false;
}
if (!FindChunk(edit, mainchunk))
return false;
LChunk obj;
LChunk ml;
GotoChunk(edit);
obj.id = MAT_ENTRY;
while (FindChunk(obj, edit))
{
ReadMaterial(obj);
SkipChunk(obj);
}
GotoChunk(edit);
obj.id = EDIT_OBJECT;
{
while (FindChunk(obj, edit))
{
ReadASCIIZ(m_objName, 99);
ml = ReadChunk();
if (ml.id == OBJ_TRIMESH)
ReadMesh(ml);
else
if (ml.id == OBJ_LIGHT)
ReadLight(ml);
else
if (ml.id == OBJ_CAMERA)
ReadCamera(ml);
SkipChunk(obj);
}
}
// read the keyframer data here to find out correct object orientation
LChunk keyframer;
keyframer.id = KFDATA;
LChunk objtrack;
objtrack.id = OBJECT_NODE_TAG;
GotoChunk(mainchunk);
if (FindChunk(keyframer, mainchunk))
{ // keyframer chunk is present
GotoChunk(keyframer);
while (FindChunk(objtrack, keyframer))
{
ReadKeyframeData(objtrack);
SkipChunk(objtrack);
}
}
for (uint i=0; i<m_meshes.size(); i++)
m_meshes[i].Optimize(m_optLevel);
m_pos = 0;
strcpy(m_objName, "");
return true;
}
void L3DS::ReadMesh(const LChunk &parent)
{
unsigned short count, i;
LVector4 p;
LMatrix4 m;
LVector2 t;
p.w = 1.0f;
LMesh mesh;
mesh.SetName(m_objName);
GotoChunk(parent);
LChunk chunk = ReadChunk();
while (chunk.end <= parent.end)
{
switch (chunk.id)
{
case TRI_VERTEXLIST:
count = ReadShort();
mesh.SetVertexArraySize(count);
for (i=0; i < count; i++)
{
p.x = ReadFloat();
p.y = ReadFloat();
p.z = ReadFloat();
mesh.SetVertex(p, i);
}
break;
case TRI_FACEMAPPING:
count = ReadShort();
if (mesh.GetVertexCount() == 0)
mesh.SetVertexArraySize(count);
for (i=0; i < count; i++)
{
t.x = ReadFloat();
t.y = ReadFloat();
mesh.SetUV(t, i);
}
break;
case TRI_FACELIST:
ReadFaceList(chunk, mesh);
break;
case TRI_MATRIX:
m._11 = ReadFloat();
m._12 = ReadFloat();
m._13 = ReadFloat();
m._21 = ReadFloat();
m._22 = ReadFloat();
m._23 = ReadFloat();
m._31 = ReadFloat();
m._32 = ReadFloat();
m._33 = ReadFloat();
m._41 = ReadFloat();
m._42 = ReadFloat();
m._43 = ReadFloat();
m._14 = 0.0f;
m._24 = 0.0f;
m._34 = 0.0f;
m._44 = 1.0f;
mesh.SetMatrix(m);
break;
default:
break;
}
SkipChunk(chunk);
if (chunk.end >= parent.end)
break;
chunk = ReadChunk();
}
m_meshes.push_back(mesh);
}
void L3DS::ReadMaterial(const LChunk &parent)
{
// variables
LChunk chunk;
LChunk child;
char str[30];
LMaterial mat;
short sh;
GotoChunk(parent);
chunk = ReadChunk();
while (chunk.end <= parent.end)
{
switch (chunk.id)
{
case MAT_NAME:
ReadASCIIZ(str, 30);
mat.SetName(str);
break;
case MAT_AMBIENT:
child = ReadChunk();
mat.SetAmbientColor(ReadColor(child));
break;
case MAT_DIFFUSE:
child = ReadChunk();
mat.SetDiffuseColor(ReadColor(child));
break;
case MAT_SPECULAR:
child = ReadChunk();
mat.SetSpecularColor(ReadColor(child));
break;
case MAT_SHININESS:
child = ReadChunk();
mat.SetShininess(ReadPercentage(child));
break;
case MAT_TRANSPARENCY:
child = ReadChunk();
mat.SetTransparency(ReadPercentage(child));
break;
case MAT_SHADING:
sh = ReadShort();
switch (sh)
{
case 0:
mat.SetShadingType(sWireframe);
break;
case 1:
mat.SetShadingType(sFlat);
break;
case 2:
mat.SetShadingType(sGouraud);
break;
case 3:
mat.SetShadingType(sPhong);
break;
case 4:
mat.SetShadingType(sMetal);
break;
}
break;
case MAT_WIRE:
mat.SetShadingType(sWireframe);
break;
case MAT_TEXMAP:
ReadMap(chunk, mat.GetTextureMap1());
break;
case MAT_TEX2MAP:
ReadMap(chunk, mat.GetTextureMap2());
break;
case MAT_OPACMAP:
ReadMap(chunk, mat.GetOpacityMap());
break;
case MAT_BUMPMAP:
ReadMap(chunk, mat.GetBumpMap());
break;
case MAT_SPECMAP:
ReadMap(chunk, mat.GetSpecularMap());
break;
case MAT_REFLMAP:
// AMZ not really a bugfix but it seems to work!
#if 1
ReadMap(chunk, mat.GetReflectionMap());
#else
child = ReadChunk();
mat.GetReflectionMap().strength = ReadPercentage(child);
SkipChunk(child);
child = ReadChunk();
if (child.id != MAT_MAPNAME)
{
fprintf(stderr, "L3DS::ReadMaterial - error, expected chunk not found");
return;
}
ReadASCIIZ(str, 30);
if (strcmp(str, "") == 0)
strcpy(mat.GetReflectionMap().mapName, "auto");
#endif
break;
}
SkipChunk(chunk);
chunk = ReadChunk();
}
m_materials.push_back(mat);
m_materials[m_materials.size()-1].SetID(uint(m_materials.size())-1);
}
void C3DS::ParseChunk(stChunk* Chunk)
{
while(Chunk->bytesRead < Chunk->length)
{
stChunk tempChunk = {0};
ReadChunk(&tempChunk);
// DEBUG CHUNKS
//char buf[2000];
//sprintf(buf, "Chunk ID: %.4x\t Size: %d\n", tempChunk.ID, tempChunk.length);
//debug_op(buf);
switch( tempChunk.ID)
{
// HEADER OUR ENTRY POINT
case EDIT3DS: //0x3D3D
ParseChunk(&tempChunk);
break;
// MATERIALS
case MATERIAL: //0xAFFF
{
stMaterial newMaterial;
m_pMaterials.push_back(newMaterial);
m_iNumMaterials++;
}
ParseChunk(&tempChunk);
break;
case MAT_NAME: //0xA000 - sz for hte material name "e.g. default 2"
GetMaterialName(&tempChunk);
break;
case MAT_AMBIENT:
GetAmbientColour(&tempChunk);
break;
case MAT_SPECULAR:
GetSpecularColour(&tempChunk);
break;
case MAT_DIFFUSE: // Diffuse Colour //0xA020
GetDiffuseColour(&tempChunk);
break;
case MAT_TEXMAP: //0xA200 - if there's a texture wrapped to it where here
ParseChunk(&tempChunk);
break;
case MAT_TEXFLNM: // 0xA300 - get filename of the material
GetTexFileName(&tempChunk);
break;
// OBJECT - MESH'S
case NAMED_OBJECT: //0x4000
{
stMesh newMesh;
m_pMeshs.push_back(newMesh);
m_iNumMeshs++;
GetMeshObjectName(&tempChunk);
}
break;
case OBJ_MESH: //0x4100
ParseChunk(&tempChunk);
break;
case MESH_VERTICES: //0x4110
ReadMeshVertices(&tempChunk);
break;
case MESH_FACES: //0x4120
ReadMeshFaces(&tempChunk);
break;
case MESH_TEX_VERT: //0x4140
ReadMeshTexCoords(&tempChunk);
break;
case MESH_MATER: //0x4130
ReadMeshMaterials(&tempChunk);
break;
// ANIMATION
case KEYF3DS: //0xB000
ParseChunk(&tempChunk);
break;
case ANIM_S_E_TIME: //0xB008
StartEndFrames(&tempChunk);
break;
case ANIM_OBJ: //0xB002
{
stAnimation newAnimation;
m_pAnimation.push_back(newAnimation);
m_iNumAnimObjects++;
}
ParseChunk(&tempChunk);
break;
case ANIM_NAME:
ReadNameOfObjectToAnimate(&tempChunk);
break;
case ANIM_PIVOT: // 0xB013
ReadPivotPoint(&tempChunk);
break;
case ANIM_POS: // 0xB020
ReadAnimPos(&tempChunk);
break;
case ANIM_ROT: // 0xB021
ReadAnimRot(&tempChunk);
break;
case ANIM_SCALE: // 0xB022
ReadAnimScale(&tempChunk);
break;
default:
SkipChunk(&tempChunk);
}
Chunk->bytesRead += tempChunk.length;
}
}
