The SX Engine

Uhyve · Dec 14, 2010

Ah, I knew I read someone talking about having a standard block size. I actually had that working, but it broke at some point while I was making normal scales work. I'd make a small equation so you wouldn't have to do all the scaling by hand, but I'm not actually that great at proper maths equations... it's actually not too difficult once you understand that bit of code, since after that, you just add it onto 1 and that's your scale.

I actually do feel like I'm understanding more and more about how the DEF files work. I can really see myself getting stuck on Paths though. But then again, I can always release the program as open source (if I haven't already done that by that point), I'm sure someone on the internet would be able to figure it out if I can't.

Edit: Added a download link to the newest version, fresh off the compiler.

True Dude · Dec 14, 2010

Weird, I tried testing this out, but when I tried clicking on the .exe it wouldn't load. Do I need to launch it in DosBox or something?

Uhyve · Dec 14, 2010

Nah, it should just work. I should really put in some error messages. But I'd be willing to bet, that's a DirectX error, try installing the DirectX updater (it checks all of the individual DirectX components, for the odd one that is out of date):
DirectX Web Updater

If it's not that, I guess I must've used some DirectX function that you're graphics card can't do, because that's exactly what happens when a program fails to create a renderer.

True Dude · Dec 14, 2010

Uhyve said:

If it's not that, I guess I must've used some DirectX function that you're graphics card can't do, because that's exactly what happens when a program fails to create a renderer.
Click to expand...

That explains it then, my graphics card I have right now is a piece of crap, and can't run anything worth a damn. I'll try it when I get a better graphics card, I guess.

Uhyve · Dec 14, 2010

Yeah, if it's that, I'll try fixing it in the next build, I've got a pretty new computer so I didn't really do much to make sure it'd work on older machines.

Edit: Still not sure whether anyone cares (which is why I'm just editing an old post), but I figure it'll probably be a good idea to document how the DEF files work. Just been figuring out renderflags (I was just specifying specific renderflags originally, which means I was probably missing some stuff). Basically, these are binary flags, I'll give an example of one:

00000010 (2)

So if the 7th number means transparent, the object would be transparent. Say the 6th number is the mirror texture flag, and we wanted a transparent mirrored object, we'd set it like this:

00000110 (5)

The renderflags are basically the same but not binary formatted:

8448

Which means:

00100001 00000000 (8192 + 256)

You can work this out using annoyingly complicated powers of two logic but I won't bore you guys with that. Not totally done with renderflags yet though, as I still need to know what each flag is actually meant to do, I think that in the example above, 256 means mirror texture. I realized this a while back but now I've bothered implementing this, I just realized that the massive scales must be the offset flag, just like the comments hint at in the DEF files (no idea why that never occurred to me).

PS Just got fillcolors working, the DE levels are now starting to look more like levels.

Uhyve · Dec 25, 2010

Figured I'd release the source as a Christmas present. There's no actual progress since last release and it's super messy since I wasn't actually planning on releasing anything, but at least if I get lazy and stop working on it now, people don't have to start again from scratch.

And yes, it's realllly messy.

http://code.google.com/p/sx-engine/source/detail?r=2

Andrew75 · Dec 26, 2010

Hey , don't get to lazy now, hope to see this project bare more fruit !
Anyways merry belated X-mas!.
Would have replied yesterday, had a really fulfilling day with family.

SANiK · Jan 10, 2011

Uhyve said:

Code (Text):

// Set a max scale value

int maxScale = 128;

// Loading in yScale value from DEF file

usedCubes[currentCube].yScale = (float)atoi(num.c_str());

// If the imported value is above the maxScale, it's probably one of those impossible scales

if(abs(usedCubes[currentCube].yScale) > maxScale)

{

    int tempPower = 1;

    while (tempPower <= abs((int)usedCubes[currentCube].yScale))

    {

        // Find the highest power of two that'll fit into the imported scale (well, 1 multiply over)

        tempPower = tempPower * 2;

    }

    // Until we're within the scale range, keep subtracting the smallest power of two that'll fit.

    while(abs(usedCubes[currentCube].yScale) > maxScale)

    {

        // Divide first since we went over last time.

        tempPower = tempPower / 2;

        if (usedCubes[currentCube].yScale > 0) //Depending on whether we're dealing with a +/- scale...

            usedCubes[currentCube].yScale -= tempPower;

        else

            usedCubes[currentCube].yScale += tempPower;

    }

}

Click to expand...

That is alright guess work but it is actually simpler than that.
Try:

Code (Text):

unsigned int combinedScaleOffset=atoi(num.c_str());

//Decompose combined data

usedCubes[currentCube].yScale = 1+(signed short)combinedScaleOffset/128.0f;

usedCubes[currentCube].yOffset = (signed short)(combinedScaleOffset >> 16)/256.0f;

The scale and offset are stored as a combined 32bit number.
The top 16 bits are the relative offset and the bottom 16 bits are the relative scale.

The scale is relative to 1 which you've figured out already and it uses 128.0f accuracy which you've also figured out.
The offset is 256.0f accuracy.

SANiK · Jan 10, 2011

Ofer made up as he went along. There are various functional differences in the DEF format, even though the DEF files show the same file version number.
You might also want to invest time in a nice database to manage the resources.

2) make hexdump actual hex data not strings
3) Palettes lack a Value or HexDump, they use FileName "..."
10) Implement UV orientation (flip/rotate), as well as implement it on the image data level
18) CRYSTAL2.DEF: Trunks of snowball trees aren't transparent

Bugs:
1) Double sided Crystal1 ramp going up... in video it doesn't disappear but it fades out... is this "weak double sided" or "double sided but blocking the camera..."
2) GALAXY1, Playme.def, DE_*, and RAMPS top-plane slope fiasco... they seem to use different settings
3) JG_07 Wood support bridge doesn't uses flat but has auto values... so I use auto... looks good but unsure if actual working of engine
5) Figure out how to use correct value of local shading. Also, is it added to the global shading or overridden?
6) Figure difference between X 90 and X 45 cube types instead of processing them the same...
8) Figure why the shadows seem to be inverted on the X thing... darker side is showing with lighter side behind it... wrong X setup, wrong shadoing, or discard shadows for X type?
9) Why is death egg so light
10) Check Fern_01 for unk2 and ... that fence might be transparent
11) Check out Diamon in Neo_01
12) Screen2 and scrreen1 water animating has blanks - transparent flag/auto alpha on first frame only?
13) TEST_05C.DEF = egypt level
14) Frame size might actually be 1 pixel thick?
15) (Blending) Transparency needs to be implemented for all sides. Not per texture blending but per renderflag blending.
16) Rotatation on renderflag level and texture level needs to be implemented
17) Texture scrolling needs to be implemented
18) Crystal frost, ramps have garbled textures on side
19) Shading algorithm is off
20) Fish eye algorithm is off
21) Some corners missing due to optomization algo I think in X shapes?

Code (Text):

//Layout.c

#include "common.h"

//Defines

//TEXTURE:VALUE001=Flags

//#define LAYOUT_TXTR_GlobalMapping      1

//#define LAYOUT_TXTR_LocalMapping      2

//#define LAYOUT_TXTR_Animation          4

#define LAYOUT_TXTR_Bitmap            8    //Overrides LAYOUT_TXTR_FLAT_FILL & LAYOUT_TXTR_AUTO_FILL

#define LAYOUT_TXTR_FLAT_FILL          16 //Default, if 0

#define LAYOUT_TXTR_AUTO_FILL          32 //Overrides LAYOUT_TXTR_FLAT_FILL

#define LAYOUT_TXTR_FRAME1            64 //Draw X (what's the need for LAYOUT_TXTR_DRAW_X then...?)

#define LAYOUT_TXTR_FRAME2            128 //Draw []

//#define LAYOUT_TXTR_DRAW_X            256 //Undefined? //"Continues animation" is 256 //Might mean Draw_regardless...?

//TEXTURE:VALUE002=Render mode

#define LAYOUT_Opaque                  1

#define LAYOUT_Transparent            2

#define LAYOUT_Blend                  16

#define LAYOUT_Darken                  32    //Undoc

#define LAYOUT_Lighten                64    //Undoc

//#define LAYOUT_Disolve                128

#define LAYOUT_FlipH                  256

#define LAYOUT_FlipV                  512

//#define LAYOUT_Ditr                    1024

#define LAYOUT_AutoTrans              2048

//#define LAYOUT_RemapColors            4096

#define LAYOUT_BestQuality            8192

//#define LAYOUT_Rotate                  16384

//TEXTURE:VALUE003=Palette (Palette Name)

//TEXTURE:VALUE004=Unknown

//TEXTURE:VALUE005=Unknown

//TEXTURE:VALUE006=MaxFrames (New version: Uses stated animation count + Detection; Old version: Used detection to figure out animation count, e.g. if 0.pcx exists try 1.pcx etc.)

//TEXTURE:VALUE007=Unknown

//TEXTURE:VALUE008=Texture File Path

//TEXTURE:VALUE009=Unknown

//TEXTURE:VALUE010=Weight (Variable Name)

//TEXTURE:VALUE011=Elastic (Variable Name)

//TEXTURE:VALUE012=FrictionX (Variable Name)

//TEXTURE:VALUE013=FrictionY (Variable Name)

//TEXTURE:VALUE014=FrictionZ (Variable Name)

//TEXTURE:VALUE015=Physics flags

//#define LAYOUT_AlignPlayer            1

//#define LAYOUT_AlignWorld              2

//#define LAYOUT_RotWorldCW              4

//#define LAYOUT_RotWorldCCW            8

//#define LAYOUT_unknownNameButLetPlayerPass  16

//TEXTURE:VALUE016=Magnet (Variable Name)

//TEXTURE:VALUE017=Fill1 color (Flat fill color, autofill left) (color)

//TEXTURE:VALUE018=Frame1 color (\ color) (|- color) (color)

//TEXTURE:VALUE019=Frame2 color  (/ color) (_| color) (color)

//TEXTURE:VALUE020=Fill2 color (autofill right) (color)

//TEXTURE:VALUE021=Autofill color (color) (enables extra mode?) Color(r,g,b) r=gradient center shift, g=gradient format, b=gradient bar count ...

//TEXTURE:VALUE022=Scroll color (probably direction? X,Y, and speed?)

//CUBE:VALUE001=Flags

//#define  LAYOUT_CDF_EmptyCube          0    //Denotes empty space

#define LAYOUT_CDF_Active              1

//#define LAYOUT_CDF_Sloped              2

//#define LAYOUT_CDF_DSloped            4

#define LAYOUT_CDF_Chkrs              8      //CDF_Chkrs means depending on x,y,z position of tile, the sides of cube interchange

//#define LAYOUT_CDF_Sprite              16

//#define LAYOUT_CDF_Pass                32

//CUBE:VALUE002=Type (0=Cube, 1=Sprite Center, 2=Sprite Front, 3=Cross Y45, 4= Cross Y90, 5=Diamond, 6=Sprite & Shadow, 7=Pyramid)

//CUBE:VALUE003=Back (Texture Name)    //New Version: No texture, means no side

//CUBE:VALUE004=Top (Texture Name)     //New Version: No texture, means no side

//CUBE:VALUE005=Right (Texture Name)    //New Version: No texture, means no side

//CUBE:VALUE006=Bottom (Texture Name)    //New Version: No texture, means no side

//CUBE:VALUE007=Left (Texture Name)    //New Version: No texture, means no side

//CUBE:VALUE008=Front (Texture Name)    //New Version: No texture, means no side

//CUBE:VALUE009=Unknown

//CUBE:VALUE010=Unknown

//CUBE:VALUE011=Attack (0-31?)

//CUBE:VALUE012=Shield (0-31?)

//CUBE:VALUE013=Unknown

//CUBE:VALUE014=Unknown

//CUBE:VALUE015=Slope Direction

////

//CUBE:VALUE016=X Size/Offset

//CUBE:VALUE017=Y Size/Offset

//CUBE:VALUE018=Z Size/Offset

//CUBE:VALUE019=Unknown

//CUBE:VALUE020 (Double Sided),VALUE021 (Partial Face, Old Version Use Only: Faces not to Draw),VALUE022 (Not on grid, Old Version Use Only: For Mesh Optomization),VALUE023 (Auto determination, Old Version Use Only: Engine fills in blanks it seems?)

#define LAYOUT_BACK                    1

#define LAYOUT_TOP                    2

#define LAYOUT_RIGHT                  4

#define LAYOUT_BOTTOM                  8

#define LAYOUT_LEFT                    16

#define LAYOUT_FRONT                  32

//#define LAYOUT_HORIZONTAL              64

//#define LAYOUT_VERTICAL                128

//#define LAYOUT_SIDE                    256

//CUBE:VALUE024=Unknown

//CUBE:VALUE025=Unknown

//CUBE:VALUE026=Swap (Cube #) //Cube ID of new cube to spawn, but when is it triggered?

//CUBE:VALUE027=Unknown

//CUBE:VALUE028=Unknown

//CUBE:VALUE029=RenderFlags Back (Renderflags are the same as texture renderflags but with shading, where shading is upper 16bits); shading seems to be -15 to +15

//CUBE:VALUE030=RenderFlags Top

//CUBE:VALUE031=RenderFlags Right

//CUBE:VALUE032=RenderFlags Bottom

//CUBE:VALUE033=RenderFlags Left

//CUBE:VALUE034=RenderFlags Front

//QUBIX:VALUE001=Layout Texture FileName without FileFormat

//QUBIX:VALUE002=Background Texture FileName without FileFormat

//QUBIX:VALUE003=Unknown

//QUBIX:VALUE004=Unknown

//QUBIX:VALUE005=Specular Color (color)

//QUBIX:VALUE006=Fog Color (color)

//Variables

byte layout_drawPhase=0;

float slopeElevation[16][4]={

//top left, top right, front left, front right

{1.0f, 1.0f,

1.0f, 1.0f}, //0

{1.0f, 0.0f,

1.0f, 0.0f}, //1

{1.0f, 1.0f,

1.0f, 1.0f}, //2

{1.0f, 1.0f,

1.0f, 1.0f}, //3

{0.0f, 1.0f,

0.0f, 1.0f}, //4

{1.0f, 1.0f,

0.0f, 0.0f}, //5

{1.0f, 1.0f,

1.0f, 1.0f}, //6

{1.0f, 1.0f,

1.0f, 1.0f}, //7

{0.0f, 0.0f,

1.0f, 1.0f}, //8

{1.0f, 1.0f,

1.0f, 1.0f}, //9

{1.0f, 1.0f,

1.0f, 1.0f}, //10

{1.0f, 1.0f,

1.0f, 1.0f}, //11

{1.0f, 1.0f,

1.0f, 1.0f}, //12

};

//Functions

sdword layout_getIntValue(byte *a_stringData)

{

  if(a_stringData == NULL) return 0;

  

  //If it's already in numeric form, just return the number

  if((util_isDigit(a_stringData[0])) || (a_stringData[0]=='-')) return atoi(a_stringData);

  //If it's Color(#,#,#) then parse it into 0xRRGGBBFF

  if(strncmp(a_stringData, "Color(", sizeof("Color(")-1) == 0)

  {

    dword red,green,blue;

    sscanf(a_stringData, "Color(%d,%d,%d)", &red, &green, &blue);

    return (((byte)red)<<24) | (((byte)green)<<16) | (((byte)blue)<<8) | 0xFF;

  }

  

  //Else decode the value

  sdword intData=0;

  

  //TEXTURE:VALUE001=Flags

  if(strstr(a_stringData, "TXTR_Bitmap") != NULL) intData|=LAYOUT_TXTR_Bitmap;

  if(strstr(a_stringData, "TXTR_FLAT_FILL") != NULL) intData|=LAYOUT_TXTR_FLAT_FILL;

  if(strstr(a_stringData, "TXTR_AUTO_FILL") != NULL) intData|=LAYOUT_TXTR_AUTO_FILL;

  if(strstr(a_stringData, "TXTR_FRAME1") != NULL) intData|=LAYOUT_TXTR_FRAME1;

  if(strstr(a_stringData, "TXTR_FRAME2") != NULL) intData|=LAYOUT_TXTR_FRAME2;

  

  //CUBE:VALUE029 to inclusive VALUE034

  //TEXTURE:VALUE002=Render mode

  if(strstr(a_stringData, "Opaque") != NULL) intData|=LAYOUT_Opaque;

  if(strstr(a_stringData, "Transparent") != NULL) intData|=LAYOUT_Transparent;

  if(strstr(a_stringData, "FlipH") != NULL) intData|=LAYOUT_FlipH;

  if(strstr(a_stringData, "FlipV") != NULL) intData|=LAYOUT_FlipV;

  if(strstr(a_stringData, "AutoTrans") != NULL) intData|=LAYOUT_AutoTrans;

  if(strstr(a_stringData, "BestQuality") != NULL) intData|=LAYOUT_BestQuality;

  

  //CUBE:VALUE001=Flags

  if(strstr(a_stringData, "CDF_Active") != NULL) intData|=LAYOUT_CDF_Active;

  if(strstr(a_stringData, "CDF_Chkrs") != NULL) intData|=LAYOUT_CDF_Chkrs;

  

  //CUBE:VALUE020 to inclusive VALUE023

  if(strstr(a_stringData, "BACK") != NULL) intData|=LAYOUT_BACK;

  if(strstr(a_stringData, "TOP") != NULL) intData|=LAYOUT_TOP;

  if(strstr(a_stringData, "RIGHT") != NULL) intData|=LAYOUT_RIGHT;

  if(strstr(a_stringData, "BOTTOM") != NULL) intData|=LAYOUT_BOTTOM;

  if(strstr(a_stringData, "LEFT") != NULL) intData|=LAYOUT_LEFT;

  if(strstr(a_stringData, "FRONT") != NULL) intData|=LAYOUT_FRONT;

  

  return intData;

}

void layout_parsePath(byte *a_destString, byte *a_fileDirectory, byte *a_layoutStringData, byte *a_fileFormat)

{

  dword fileDirectoryLen=strlen(a_fileDirectory);

  

  //Prepare the full file path

  memcpy(a_destString, a_fileDirectory, fileDirectoryLen);

  dword stringDataLen=strlen(a_layoutStringData)-2;

  memcpy(&a_destString[fileDirectoryLen], &a_layoutStringData[1], stringDataLen);

  a_destString[fileDirectoryLen+stringDataLen]=0;

  

  //Convert : to backward slash

  byte *charPointer=&a_destString[fileDirectoryLen];

  while(*charPointer)

  {

    if(*charPointer == ':') *charPointer='\\';

    charPointer++;

  }

  

  //Append the file format

  strcat(a_destString, a_fileFormat);  

}

void layout_parseDef(Layout *a_layout, byte *a_fileName)

{

  //Get the size of the file

  dword fileSize=file_getSize(a_fileName);

  

  //Allocate and load the file into a buffer (and convert the buffer into a null terminated string)

  byte *fileBuffer=malloc(fileSize+1);

  file_read(a_fileName, fileBuffer, 0, fileSize);

  fileBuffer[fileSize]=0;

  

  //Remove comments, repetitive whitespace, and shift data down

  byte *fileDestPointer=fileBuffer;

  byte *fileSrcPointer=fileBuffer;

  byte stringMode=0;

  byte commentMode=0;

  byte whitespaceMode=0;

  while(*fileSrcPointer != 0)

  {

    //Is it a comment?

    if((!stringMode) && (!commentMode) && (*fileSrcPointer == '/') && (fileSrcPointer[1] == '/'))

    {

      commentMode=1;

      fileSrcPointer++;

    }

    //Is it a string?

    else if((!commentMode) && (*fileSrcPointer == '"'))

    {

      whitespaceMode=0;

      *fileDestPointer++=*fileSrcPointer++;

      stringMode=!stringMode;

    }

    //Is it inside a comment?

    else if(commentMode)

    {

      if(*fileSrcPointer == '\n')

      {

        *fileDestPointer++=*fileSrcPointer;

        commentMode=!commentMode;

      }

      fileSrcPointer++;

    }

    //Is it duplicate whitespace

    else if((!stringMode) && (whitespaceMode) && ((*fileSrcPointer == '\t') || (*fileSrcPointer == '\r') || (*fileSrcPointer == ' ')))

    {

      //Ignore it

      fileSrcPointer++;

    }

    //Is it all else

    else

    {

      whitespaceMode=((*fileSrcPointer == '\t') || (*fileSrcPointer == '\r') || (*fileSrcPointer == ' ') || (*fileSrcPointer == '\n'));

      *fileDestPointer++=*fileSrcPointer++;

    }

  }

  *fileDestPointer++=0; //Add terminating null

  

  //Calculate new fileSize

  fileSize=(dword)fileDestPointer-(dword)fileBuffer;

  

  //Parse the file

  dword fileOffset=0;

  while(1)

  {

    if(fileOffset >= fileSize) break;

    

    //Is it data?

    if(strncmp(&fileBuffer[fileOffset], "NEW_", sizeof("NEW_")-1) == 0)

    {

      fileOffset+=(sizeof("NEW_")-1);

      

      //Get type

      dword typeOffset=fileOffset;

      dword typeLen=0;

      while((util_isLetter(fileBuffer[fileOffset])) && (fileBuffer[fileOffset] != 0))

      {

        typeLen++;

        fileOffset++;

      }

      if(fileBuffer[fileOffset] == 0) break;

      

      //fwrite(&fileBuffer[typeOffset], typeLen, 1, stdout);printf(":");

      

      //Get name

      while((fileBuffer[fileOffset] != '"') && (fileBuffer[fileOffset] != 0)) fileOffset++;

      if(fileBuffer[fileOffset] == 0) break;

      

      dword nameOffset=fileOffset;

      dword nameLen=2; //Include the first " and the last "

      

      fileOffset++; //Skip the "

      while((fileBuffer[fileOffset] != '"') && (fileBuffer[fileOffset] != 0))

      {

        nameLen++;

        fileOffset++;

      }

      if(fileBuffer[fileOffset] == 0) break;

      

      //fwrite(&fileBuffer[nameOffset], nameLen, 1, stdout);printf("\n");

      

      //Get {

      while((fileBuffer[fileOffset] != '{') && (fileBuffer[fileOffset] != 0)) fileOffset++;

      if(fileBuffer[fileOffset] == 0) break;

      fileOffset++; //Skip the {

      

      //Figure which type it is

      List *typeListPointer=NULL;

      //VARIABLE

      if((typeLen == (sizeof("VARIABLE")-1)) && !strncmp(&fileBuffer[typeOffset], "VARIABLE", typeLen)){typeListPointer=&a_layout->variableList;}

      //PALETTE

      else if((typeLen == (sizeof("PALETTE")-1)) && !strncmp(&fileBuffer[typeOffset], "PALETTE", typeLen)){typeListPointer=&a_layout->paletteList;}

      //CAMERA

      else if((typeLen == (sizeof("CAMERA")-1)) && !strncmp(&fileBuffer[typeOffset], "CAMERA", typeLen)){typeListPointer=&a_layout->cameraList;}

      //TEXTURE

      else if((typeLen == (sizeof("TEXTURE")-1)) && !strncmp(&fileBuffer[typeOffset], "TEXTURE", typeLen)){typeListPointer=&a_layout->textureList;}

      //QUBIX

      else if((typeLen == (sizeof("QUBIX")-1)) && !strncmp(&fileBuffer[typeOffset], "QUBIX", typeLen)){typeListPointer=&a_layout->qubixList;}

      //ACTOR

      else if((typeLen == (sizeof("ACTOR")-1)) && !strncmp(&fileBuffer[typeOffset], "ACTOR", typeLen)){typeListPointer=&a_layout->actorList;}

      //PATH

      else if((typeLen == (sizeof("PATH")-1)) && !strncmp(&fileBuffer[typeOffset], "PATH", typeLen)){typeListPointer=&a_layout->pathList;}

      //CUBE

      else if((typeLen == (sizeof("CUBE")-1)) && !strncmp(&fileBuffer[typeOffset], "CUBE", typeLen)){typeListPointer=&a_layout->cubeList;}

      //UNKNOWN

      else

      {

        printf("Warning: Unknown Data Type: NEW_");

        fwrite(&fileBuffer[typeOffset], typeLen, 1, stdout);

        printf("\n");

      }

      

      //Add the proper list entry

      if(typeListPointer != NULL)

      {

        LayoutElement *layoutElementPointer=malloc(sizeof(LayoutElement));

        //Copy the element name to the element template, add term null to name

        layoutElementPointer->elementName=malloc(nameLen+1);

        memcpy(layoutElementPointer->elementName, &fileBuffer[nameOffset], nameLen);

        layoutElementPointer->elementName[nameLen]=0;

        

        //Initiate the two lists in the element

        list_init(&layoutElementPointer->valueList);

        list_init(&layoutElementPointer->hexDumpList);

        

        //Add the list element to the typeListPointer

        list_addEntry(typeListPointer, layoutElementPointer);

        

        //Scan for values or hexdumps, whilst getting }

        while((fileBuffer[fileOffset] != '}') && (fileBuffer[fileOffset] != 0))

        {

          if(fileOffset >= fileSize) break;

          //Is it a value?

          if(strncmp(&fileBuffer[fileOffset], "Value", sizeof("Value")-1) == 0)

          {

            fileOffset+=(sizeof("Value")-1);

            

            //Get id

            dword id=0;

            while((!util_isDigit(fileBuffer[fileOffset])) && (fileBuffer[fileOffset] != 0)) fileOffset++; //Approach the first digit

            if(fileBuffer[fileOffset] == 0) break;

            while((util_isDigit(fileBuffer[fileOffset])) && (fileBuffer[fileOffset] != 0)) //Process digit

            {

              id*=10;

              id+=fileBuffer[fileOffset]-='0';

              fileOffset++;

            }

            if(fileBuffer[fileOffset] == 0) break;

            

            //Get ,

            while((fileBuffer[fileOffset] != ',') && (fileBuffer[fileOffset] != 0)) fileOffset++;

            if(fileBuffer[fileOffset] == 0) break;

            fileOffset++; //Skip the ,

            

            //Get stringData

            dword dataOffset=fileOffset;

            dword dataLen=0;

            while((fileBuffer[fileOffset] != '\n') && (fileBuffer[fileOffset] != 0))

            {              

              dataLen++;

              fileOffset++;

            }

            if(fileBuffer[fileOffset] == 0) break;

            

            //Trim string data on Left

            while((dataLen > 0) && ((fileBuffer[dataOffset] == ' ') || (fileBuffer[dataOffset] == '\t') || (fileBuffer[dataOffset] == '\r')))

            {

              dataOffset++;

              dataLen--;

            }

            

            //Trim string data on Right

             while((dataLen > 0) && ((fileBuffer[dataOffset+dataLen-1] == ' ') || (fileBuffer[dataOffset+dataLen-1] == '\t') || (fileBuffer[dataOffset+dataLen-1] == '\r')))

            {

              dataLen--;

            }

            

            //Add Value to list

            {

              LayoutValue *layoutValuePointer=malloc(sizeof(LayoutValue));

              

              //Set the id

              layoutValuePointer->id=id;

              

              //Copy the value string data name to the element template, add term null to data

              layoutValuePointer->stringData=malloc(dataLen+1);

              memcpy(layoutValuePointer->stringData, &fileBuffer[dataOffset], dataLen);

              layoutValuePointer->stringData[dataLen]=0;

              

              //Generate int value

              layoutValuePointer->intData=layout_getIntValue(layoutValuePointer->stringData);

              

              //Add to listElement's value list

              list_addEntry(&layoutElementPointer->valueList, layoutValuePointer);

            }

          }

           //Is it a hexdump?

          else if(strncmp(&fileBuffer[fileOffset], "HexDump", sizeof("HexDump")-1) == 0)

          {

            fileOffset+=(sizeof("HexDump")-1);

            

            //Get hexDumpData

            while((fileBuffer[fileOffset] != '"') && (fileBuffer[fileOffset] != 0)) fileOffset++;

            if(fileBuffer[fileOffset] == 0) break;

            

            dword hexOffset=fileOffset;

            dword hexLen=2; //Include the first " and the last "

            

            fileOffset++; //Skip the "

            while((fileBuffer[fileOffset] != '"') && (fileBuffer[fileOffset] != 0))

            {

              hexLen++;

              fileOffset++;

            }

            if(fileBuffer[fileOffset] == 0) break;

            

            //Add hexDump to list

            {

              byte *hexDumpData=malloc(hexLen+1);

              memcpy(hexDumpData, &fileBuffer[hexOffset], hexLen);

              hexDumpData[hexLen]=0;

              

              //Add to listElement's hexdump list

              list_addEntry(&layoutElementPointer->hexDumpList, hexDumpData);

            }

          }

          //All else

          else

          {

            fileOffset++;

          }

        }

        if(fileBuffer[fileOffset] == 0) break;

        fileOffset++; //Skip the {

      }

    }

    //All else

    else

    {

      fileOffset++;

    }

  }

  

  //Free the file from memory

  free(fileBuffer);

}

LayoutValue *layout_getLayoutValue(LayoutElement *a_layoutElement, dword a_id)

{

  dword entryIndex=0;

  dword entryTotal=list_getEntryCount(&a_layoutElement->valueList);

  while(entryIndex < entryTotal)

  {

    LayoutValue *layoutValuePointer=list_getEntry(&a_layoutElement->valueList, entryIndex);

    

    //Found a matching id

    if(layoutValuePointer->id == a_id)

    {

      return layoutValuePointer;

    }

    

    //Goto the next entry

    entryIndex++;

  }

  

  //No such id found, return NULL

  return NULL;

}

void layout_parsePcx(Layout *a_layout, byte *a_fileName)

{

  if(a_layout == NULL) return;

  

  //Load the .pcx (ignoring the palette)

  FILE *file=fopen(a_fileName, "rb");

  if(!file) return;

  

  //Read the header

  if(fgetc(file)!=0xA) return;

  if(fgetc(file)!=0x5) return;

  if(fgetc(file)!=1) return;

  if(fgetc(file)!=8) return;

  

  //Get the image size

  word tempWidth;

  word tempHeight;

  word imageWidth;

  word imageHeight;

  fread(&tempWidth, 2, 1, file);

  fread(&tempHeight, 2, 1, file);

  fread(&imageWidth, 2, 1, file);

  fread(&imageHeight, 2, 1, file);

  imageWidth-=tempWidth;

  imageHeight-=tempHeight;

  imageWidth++;

  imageHeight++;

  if(!imageWidth || !imageHeight) return;

  

  //Expect 1 color plane

  fseek(file, 53, SEEK_CUR);

  if(fgetc(file)!=1) return;

  

  //Get the number of bytes per line

  word pcxBytesPerLine;

  fread(&pcxBytesPerLine, 2, 1, file);

  

  //Skip to the image data

  fseek(file, 128, SEEK_SET);

  

  //Calculate some constants

  dword dataSize=imageWidth * imageHeight;

  //Allocate the buffer where the image is to be copied

  byte *pcxBitmap=malloc(dataSize);

  //Decode the image

  {

    dword y=0;

    while(y < imageHeight)

    {

      //Setup the address at which the bitmap's written to

      byte *bitmap_rw=&pcxBitmap[y*imageWidth];

      

      //Loop till a break's requested

      dword subPixelCount=0;

      while(1)

      {

        //Get the count and read values

        byte rleData=fgetc(file);  

        byte rleValue=rleData;

        byte rleCount=1;

        if(0xC0 == (rleData & 0xC0))

        {

          rleCount=rleData & 0x3F;

          rleValue=fgetc(file);

        }

      

        //Decompress the RLE

        while(rleCount)

        {

          subPixelCount++;

          

          //8-bit transfer

          *bitmap_rw++=rleValue;

          

          //Check if the scanline's done

          if(subPixelCount == imageWidth)

          {

            subPixelCount=0;

            goto reset;

          }

          

          //Decrement the counter

          rleCount--;

        }

      }

      reset:

      y++;

    }

  }

  //Find the true map dimensions

  dword sectionWidth=0;

  dword sectionHeight=0;

  {

    dword count=0;

    byte *bitmap_rw=NULL;

    //Find the width (5th palette color = separator)

    bitmap_rw=pcxBitmap+1;

     for(count=0; *bitmap_rw == 5; count++)

      bitmap_rw++;

    a_layout->layoutWidth=count;

    

    //Find the height (5th palette color = separator)

    bitmap_rw=pcxBitmap+imageWidth;

    for(count=0; *bitmap_rw == 5; count++)

      bitmap_rw+=imageWidth;

    a_layout->layoutDepth=count; //Depth

    

    //Calculate the Height

    sectionWidth=imageWidth/(a_layout->layoutWidth+2);

    sectionHeight=imageHeight/(a_layout->layoutDepth+2);

    a_layout->layoutHeight=sectionWidth * sectionHeight; //Height

  }

  

  //Get the layout map buffer ready

  a_layout->layoutMap=malloc(a_layout->layoutWidth * a_layout->layoutHeight * a_layout->layoutDepth);

  

  //Copy the tiles in the correct order

  {

    sdword x,y,z,w;

    byte *bitmap_rw=pcxBitmap;

    for(y=0; y<sectionHeight; y++)

    {

      bitmap_rw+=imageWidth;

      for(z=a_layout->layoutDepth-1; z>=0; z--)

      {

        for(x=0; x<sectionWidth; x++)

        {

          bitmap_rw++; //Skip separator

          byte *sync=&a_layout->layoutMap[(y*sectionWidth*a_layout->layoutWidth*a_layout->layoutDepth)+(x*a_layout->layoutWidth*a_layout->layoutDepth)+(z*a_layout->layoutWidth)];

          for(w=0; w<a_layout->layoutWidth; w++)

          {

            *sync++=~(*bitmap_rw++);

          }

          bitmap_rw++; //Skip separator

        }

      }

      bitmap_rw+=imageWidth;

    }

  }

  

  //Close the file

  fclose(file);

}

dword layout_doesNeighborHaveNormalSide(Layout *a_layout, byte a_tileId, word a_x, word a_y, word a_z, word a_side)

{ //True = side is existant and non-scaled

  

  byte *sync;

  

  //Draw the map

  if(a_z >= a_layout->layoutDepth) return 0;

  if(a_x >= a_layout->layoutWidth) return 0;

  if(a_y >= a_layout->layoutHeight) return 0;

  

  //Does cube exist?

  sync=&a_layout->layoutMap[(a_y*a_layout->layoutWidth*a_layout->layoutDepth)+(a_z*a_layout->layoutWidth)+a_x];

  if(*sync)

  {

    //If the cubes are the same return true

    //Since this function will only be called if the original is unmodified

    if(a_tileId == *sync) return -1;

    

    //Read cube type

    LayoutElement *layoutElementPointer=NULL;

    LayoutValue *layoutValuePointer=NULL;

    

    //Get cube element id

    layoutElementPointer=list_getEntry(&a_layout->cubeList, (*sync)-1);

    if(layoutElementPointer == NULL) return 0;

    

    //Read cubeType

    dword cubeType=0;

    layoutValuePointer=layout_getLayoutValue(layoutElementPointer, 2);

    if(layoutValuePointer != NULL) cubeType=layoutValuePointer->intData;

    

    //Type is not cube

    if(cubeType != 0) return 0;

    

    //Check if cube has any scaling or offsetting

    ///Nonexistant value's means values should be 0 by default

    layoutValuePointer=layout_getLayoutValue(layoutElementPointer, 16);

    if(layoutValuePointer != NULL)

    {

      if(layoutValuePointer->intData != 0) return 0;

    }

    

    layoutValuePointer=layout_getLayoutValue(layoutElementPointer, 17);

    if(layoutValuePointer != NULL)

    {

      if(layoutValuePointer->intData != 0) return 0;

    }

    

    layoutValuePointer=layout_getLayoutValue(layoutElementPointer, 18);

    if(layoutValuePointer != NULL)

    {

      if(layoutValuePointer->intData != 0) return 0;

    }

    

    //Check if side is to be drawn by checking if there's a texture

    layoutValuePointer=layout_getLayoutValue(layoutElementPointer, 3+a_side);

    if(layoutValuePointer == NULL) return 0;

    

    //Check that the cube is not a slope

    layoutValuePointer=layout_getLayoutValue(layoutElementPointer, 15);

    if(layoutValuePointer != NULL)

    {

      //Side qube is a slope

      if(layoutValuePointer->intData != 0) return 0;  

    }

    

    //Side exists and is not scaled

    return -1;

  }

  //No qube exists

  return 0;

}

float layout_getDropDistance(Layout *a_layout, byte *a_slopeType, word a_x, word a_y, word a_z)

{

  byte *sync;

  sdword y=0;

  float height=0.0f;

  *a_slopeType=0;

  

  //Skip the current piece

  a_y--;

  

  //Draw the map

  if(a_z >= a_layout->layoutDepth) return -1;

  if(a_x >= a_layout->layoutWidth) return -1;

  if(a_y >= a_layout->layoutHeight) return -1;

  

  for(y=a_y; y >= 0; y--) //Down to up

  {

    sync=&a_layout->layoutMap[(y*a_layout->layoutWidth*a_layout->layoutDepth)+(a_z*a_layout->layoutWidth)+a_x];

    if(*sync)

    {

      //Read cube type

      LayoutElement *layoutElementPointer=NULL;

      LayoutValue *layoutValuePointer=NULL;

      

      //Get cube element id

      layoutElementPointer=list_getEntry(&a_layout->cubeList, (*sync)-1);

      if(layoutElementPointer == NULL) return -1;

      

      //Read cubeType

      dword cubeType=0;

      layoutValuePointer=layout_getLayoutValue(layoutElementPointer, 2);

      if(layoutValuePointer != NULL) cubeType=layoutValuePointer->intData;

      

      if(cubeType == 0)

      {

        //Return slope type

        layoutValuePointer=layout_getLayoutValue(layoutElementPointer, 15);

        if(layoutValuePointer != NULL) //Only apply the slope transformation if the cubeType is "Cube"

        {

          *a_slopeType=layoutValuePointer->intData;

        }

        return height;

      }

    }

    height+=1.0f;

  }

  

  return -1;

}

Code (Text):

void layout_drawCube(Layout *a_layout, float *a_matrix, byte a_tileId, word a_x, word a_y, word a_z)

{

  LayoutElement *layoutElementPointer=NULL;

  LayoutValue *layoutValuePointer=NULL;

  

  //Do not draw if far away

  {

    float tempX=a_x;

    float tempY=a_y;

    float tempZ=a_z*1.54f;

    

    //Apply the matrices to the point

    vector_matrix_mul(tempX, tempY, tempZ, a_matrix);

    

    float distanceFromCamera=tempZ;//sqrt((tempX*tempX)+(tempY*tempY)+(tempZ*tempZ));

    //if(distanceFromCamera > 24.0f) return; //Do not draw far away cubes

    //if(distanceFromCamera >= 30.0f) { printf("%f %f %f\n", tempX, tempY, tempZ); return; } //Do not draw far away cubes

    if(distanceFromCamera < 0.0f) return;

    else if(distanceFromCamera >= 30.0f) return;

  }

  

  //Get cube element id

  layoutElementPointer=list_getEntry(&a_layout->cubeList, a_tileId-1);

  if(layoutElementPointer == NULL) return;

  

  //Read cubeFlags

  dword cubeFlags=0;

  layoutValuePointer=layout_getLayoutValue(layoutElementPointer, 1);

  if(layoutValuePointer != NULL) cubeFlags=layoutValuePointer->intData;

  

  //Is the cube active? If not don't draw it

  if(!(cubeFlags & LAYOUT_CDF_Active))

    return;

  

  //Read cubeType

  dword cubeType=0;

  layoutValuePointer=layout_getLayoutValue(layoutElementPointer, 2);

  if(layoutValuePointer != NULL) cubeType=layoutValuePointer->intData;

  

  //Generate cube texture lookup id based on side (for use with Value 003+[sideId])

  byte textureToSide[6]={0,1,2,3,4,5};

  

  //Is the cube in checkers mode? If so, remix the sides based on position of tile

  if(cubeFlags & LAYOUT_CDF_Chkrs)

  {

    if(((a_x+a_y+a_z)&1))

    {

      textureToSide[0]=5;

      textureToSide[1]=3;

      textureToSide[2]=4;

      textureToSide[3]=1;

      textureToSide[4]=2;

      textureToSide[5]=0;

    }

  }

  

  //Fetch cube scale

  dword unmodifiedShape=-1;

  float xScale=1.0f;

  float yScale=1.0f;

  float zScale=1.0f;

  float xOffset=0.0f;

  float yOffset=0.0f;

  float zOffset=0.0f;

  {

    dword value=0;

  

    //Get xso

    layoutValuePointer=layout_getLayoutValue(layoutElementPointer, 16);

    if(layoutValuePointer != NULL)

    {

      value=layoutValuePointer->intData;

      if(value != 0) unmodifiedShape=0;

      xScale=1+(sword)(value>>0)/128.0f;

      xOffset=(sword)(value>>16)/256.0f;

    }

    

    //Get yso

    layoutValuePointer=layout_getLayoutValue(layoutElementPointer, 17);

    if(layoutValuePointer != NULL)

    {

      value=layoutValuePointer->intData;

      if(value != 0) unmodifiedShape=0;

      yScale=1+(sword)(value>>0)/128.0f;

      yOffset=(sword)(value>>16)/256.0f;

    }

    

    //Get zso

    layoutValuePointer=layout_getLayoutValue(layoutElementPointer, 18);

    if(layoutValuePointer != NULL)

    {

      value=layoutValuePointer->intData;

      if(value != 0) unmodifiedShape=0;

      zScale=1+(sword)(value>>0)/128.0f;

      zOffset=(sword)(value>>16)/256.0f;

    }

  }

  

  //Initiate the cube mesh

  Vertex cubeVertex[9]=

  {

    {xOffset+a_x-0.5f*xScale, yOffset+a_y+0.5f*yScale, (zOffset+a_z)*1.54f-0.5f*1.54f*zScale}, //Front, top-left

    {xOffset+a_x+0.5f*xScale, yOffset+a_y+0.5f*yScale, (zOffset+a_z)*1.54f-0.5f*1.54f*zScale}, //Front, top-right

    {xOffset+a_x-0.5f*xScale, yOffset+a_y-0.5f*yScale, (zOffset+a_z)*1.54f-0.5f*1.54f*zScale}, //Front, bottom-left

    {xOffset+a_x+0.5f*xScale, yOffset+a_y-0.5f*yScale, (zOffset+a_z)*1.54f-0.5f*1.54f*zScale}, //Front, bottom-right

    

    {xOffset+a_x-0.5f*xScale, yOffset+a_y+0.5f*yScale, (zOffset+a_z)*1.54f+0.5f*1.54f*zScale}, //Back, top-left

    {xOffset+a_x+0.5f*xScale, yOffset+a_y+0.5f*yScale, (zOffset+a_z)*1.54f+0.5f*1.54f*zScale}, //Back, top-right

    {xOffset+a_x-0.5f*xScale, yOffset+a_y-0.5f*yScale, (zOffset+a_z)*1.54f+0.5f*1.54f*zScale}, //Back, bottom-left

    {xOffset+a_x+0.5f*xScale, yOffset+a_y-0.5f*yScale, (zOffset+a_z)*1.54f+0.5f*1.54f*zScale}, //Back, bottom-right

    

    {xOffset+a_x, yOffset+a_y, (zOffset+a_z)*1.54f}, //Center

  };

  

  //Deform cube mesh if there's a slope

  layoutValuePointer=layout_getLayoutValue(layoutElementPointer, 15);

  if((layoutValuePointer != NULL) && (cubeType == 0)) //Only apply the slope transformation if the cubeType is "Cube"

  {

    dword value=layoutValuePointer->intData;

    if(value != 0) unmodifiedShape=0;

  

    //Use the appropriate transformation

    switch(value)

    {

      case 0: break; //None

      

      case 5: //Left plane: back down to front

        memcpy(&cubeVertex[0], &cubeVertex[2], sizeof(Vertex));

        memcpy(&cubeVertex[1], &cubeVertex[3], sizeof(Vertex));

        break;

        

      case 8: //Left plane: front down to back

        memcpy(&cubeVertex[5], &cubeVertex[1], sizeof(Vertex));

        memcpy(&cubeVertex[4], &cubeVertex[0], sizeof(Vertex));

        break;

        

      case 6: //Left plane: back up to front

        memcpy(&cubeVertex[2], &cubeVertex[0], sizeof(Vertex));

        memcpy(&cubeVertex[3], &cubeVertex[1], sizeof(Vertex));

        break;

        

      case 7: //Left plane: front up to back

        memcpy(&cubeVertex[6], &cubeVertex[4], sizeof(Vertex));

        memcpy(&cubeVertex[7], &cubeVertex[5], sizeof(Vertex));

        break;

        

      case 1: //Front plane: left down to right

        memcpy(&cubeVertex[1], &cubeVertex[3], sizeof(Vertex));

        memcpy(&cubeVertex[5], &cubeVertex[7], sizeof(Vertex));

        break;

        

      case 4: //Front plane: right down to left

        memcpy(&cubeVertex[0], &cubeVertex[1], sizeof(Vertex));

        memcpy(&cubeVertex[4], &cubeVertex[5], sizeof(Vertex));

        break;

        

      case 2: //Front plane: left up to right

        memcpy(&cubeVertex[3], &cubeVertex[2], sizeof(Vertex));

        memcpy(&cubeVertex[7], &cubeVertex[6], sizeof(Vertex));

        break;

        

      case 3: //Front plane: right up to left

        memcpy(&cubeVertex[2], &cubeVertex[0], sizeof(Vertex));

        memcpy(&cubeVertex[6], &cubeVertex[4], sizeof(Vertex));

        break;

      

      //Questionable setup *fix*

      case 12: //Top plane: back down to front

        memcpy(&cubeVertex[1], &cubeVertex[0], sizeof(Vertex));

        memcpy(&cubeVertex[3], &cubeVertex[2], sizeof(Vertex));

        break;

      

      case 9: //Top plane: back up to front //10-12

        memcpy(&cubeVertex[0], &cubeVertex[4], sizeof(Vertex));

        memcpy(&cubeVertex[2], &cubeVertex[6], sizeof(Vertex));

        break;

      

      case 11: //Top plane: front down to back //12-10

        //memcpy(&cubeVertex[5], &cubeVertex[1], sizeof(Vertex));

        //memcpy(&cubeVertex[7], &cubeVertex[3], sizeof(Vertex));

        memcpy(&cubeVertex[5], &cubeVertex[4], sizeof(Vertex));

        memcpy(&cubeVertex[7], &cubeVertex[6], sizeof(Vertex));

        break;

        

      case 10: //Top plane: front up to back

        memcpy(&cubeVertex[4], &cubeVertex[5], sizeof(Vertex));

        memcpy(&cubeVertex[6], &cubeVertex[7], sizeof(Vertex));

        break;

        

      /*case 9: //Top plane: back down to front

        memcpy(&cubeVertex[1], &cubeVertex[0], sizeof(Vertex));

        memcpy(&cubeVertex[3], &cubeVertex[2], sizeof(Vertex));

        break;

        

      case 12: //Top plane: front down to back

        memcpy(&cubeVertex[5], &cubeVertex[1], sizeof(Vertex));

        memcpy(&cubeVertex[7], &cubeVertex[3], sizeof(Vertex));

        memcpy(&cubeVertex[1], &cubeVertex[0], sizeof(Vertex));

        memcpy(&cubeVertex[3], &cubeVertex[2], sizeof(Vertex));

        memcpy(&cubeVertex[0], &cubeVertex[4], sizeof(Vertex));

        memcpy(&cubeVertex[2], &cubeVertex[6], sizeof(Vertex));

        break;

        

      case 10: //Top plane: back up to front

        memcpy(&cubeVertex[0], &cubeVertex[4], sizeof(Vertex));

        memcpy(&cubeVertex[2], &cubeVertex[6], sizeof(Vertex));

        memcpy(&cubeVertex[4], &cubeVertex[5], sizeof(Vertex));

        memcpy(&cubeVertex[6], &cubeVertex[7], sizeof(Vertex));

        memcpy(&cubeVertex[5], &cubeVertex[1], sizeof(Vertex));

        memcpy(&cubeVertex[7], &cubeVertex[3], sizeof(Vertex));

        break;

        

      case 11: //Top plane: front up to back

        memcpy(&cubeVertex[4], &cubeVertex[5], sizeof(Vertex));

        memcpy(&cubeVertex[6], &cubeVertex[7], sizeof(Vertex));

        break;*/

    }

  }

  

  //Transform the mesh based on the cubeType

  if(cubeType == 0) //Cube

  {

    //return;

  }

  else if(cubeType == 1) //Sprite Center

  {

    //return;

  }

  else if(cubeType == 2) //Sprite Front (unk)

  {

    //printf("unk2 found\n");

    //system("pause");

    //return;

    //Found in Fern_01

  }

  else if(cubeType == 3) //45 deg X

  {

    //return;

  }

  else if(cubeType == 4) //90 deg X

  {

    //return;

  }

  else if(cubeType == 5) //Diamond (unk)

  {

    //printf("unk5 found\n");

    //system("pause");

    //return;

    //Found in Neo_01

  }

  else if(cubeType == 6) //Sprite with Shadow

  {

    //return;

  }

  else if(cubeType == 7) //Pyramid (unk)

  {

    //printf("unk7 found\n");

    //system("pause");

    return;

  }

  

  //Figure which sides are double sided

  dword doubleSidedFlag=0;

  layoutValuePointer=layout_getLayoutValue(layoutElementPointer, 20);

  if(layoutValuePointer != NULL) doubleSidedFlag=layoutValuePointer->intData;

  

  //Setup draw settings

  texture_enable(true);

  texture_color(255, 255, 255);

  texture_smooth(false);

  

  //Front Face

  do

  {

    //Choose texture, if there's no texture do not draw

    layoutValuePointer=layout_getLayoutValue(layoutElementPointer, 3+textureToSide[5]);

    if(layoutValuePointer == NULL) break;

    List *listPointer=&a_layout->layoutTexture[layoutValuePointer->intData].frameList;

    texture_set(list_getEntry(listPointer, (a_layout->clock)%list_getEntryCount(listPointer)));

    

    //Can this face be optimized?

    //Can only be applied to shapes that are not modified via scaling or offsetting

    if(unmodifiedShape)

    {

      //Do not draw if the in the front shape's back face is visible

      if(layout_doesNeighborHaveNormalSide(a_layout, a_tileId, a_x, a_y, a_z-1, 0)) break;

    }

    

    //Is it blended? Don't draw it on the first draw stage

    if(layout_drawPhase == 0)

    {

      LayoutElement *textureElement=a_layout->layoutTexture[layoutValuePointer->intData].textureElement;

      if(textureElement != NULL)

      {

        layoutValuePointer=layout_getLayoutValue(textureElement, 2);

        if(layoutValuePointer != NULL)

        {

          if(layoutValuePointer->intData & LAYOUT_Blend) break;

        }

      }

    }

    

    //Is it double sided?

    texture_noclip(doubleSidedFlag & LAYOUT_FRONT);

    //Apply global shading

    sword shadeDelta=255+a_layout->layoutShading[5];

    shadeDelta=(byte)shadeDelta;

    

    //Apply local shading

    layoutValuePointer=layout_getLayoutValue(layoutElementPointer, 29+5);

    if(layoutValuePointer != NULL)

    {

      sbyte localShadeDelta=layoutValuePointer->intData >> 16;

      shadeDelta+=localShadeDelta*16;

      

      //Is it blended

      if(layoutValuePointer->intData & LAYOUT_Blend) texture_alpha(128);

    }

    if(shadeDelta < 0) shadeDelta=0; else if(shadeDelta > 255) shadeDelta=255;

    if(cubeType == 0) texture_color(shadeDelta, shadeDelta, shadeDelta);

    else texture_color(255, 255, 255);

    

    //Setup uvs

    float uvAx=0.0f, uvAy=0.0f;

    float uvBx=0.0f, uvBy=1.0f;

    float uvCx=1.0f, uvCy=1.0f;

    float uvDx=1.0f, uvDy=0.0f;

    

    //Manage UVs

    layoutValuePointer=layout_getLayoutValue(layoutElementPointer, 29+textureToSide[5]);

    if(layoutValuePointer != NULL)

    {

      if(layoutValuePointer->intData & LAYOUT_FlipH)

      {

        float temp;

        

        temp=uvAx;uvAx=uvDx;uvDx=temp;

        temp=uvAy;uvAy=uvDy;uvDy=temp;

        temp=uvBx;uvBx=uvCx;uvCx=temp;

        temp=uvBy;uvBy=uvCy;uvCy=temp;

      }

      if(layoutValuePointer->intData & LAYOUT_FlipV)

      {

        float temp;

        

        temp=uvAx;uvAx=uvBx;uvBx=temp;

        temp=uvAy;uvAy=uvBy;uvBy=temp;

        temp=uvDx;uvDx=uvCx;uvCx=temp;

        temp=uvDy;uvDy=uvCy;uvCy=temp;

      }

    }

    

    //Draw

    if((cubeType == 4) || (cubeType == 3))

    { //Back-right leg

      glBegin(GL_QUADS);

        glTexCoord2f(uvDx, uvDy); reflex(a_matrix, cubeVertex[8].x, cubeVertex[0].y, cubeVertex[8].z);

        glTexCoord2f(uvCx, uvCy); reflex(a_matrix, cubeVertex[8].x, cubeVertex[2].y, cubeVertex[8].z);

        glTexCoord2f(uvBx, uvBy); reflex(a_matrix, cubeVertex[7].x, cubeVertex[7].y, cubeVertex[7].z);

        glTexCoord2f(uvAx, uvAy); reflex(a_matrix, cubeVertex[5].x, cubeVertex[5].y, cubeVertex[5].z);

      glEnd();

    }

    else

    {

      glBegin(GL_QUADS);

        glTexCoord2f(uvAx, uvAy); reflex(a_matrix, cubeVertex[0].x, cubeVertex[0].y, cubeVertex[0].z);

        glTexCoord2f(uvBx, uvBy); reflex(a_matrix, cubeVertex[2].x, cubeVertex[2].y, cubeVertex[2].z);

        glTexCoord2f(uvCx, uvCy); reflex(a_matrix, cubeVertex[3].x, cubeVertex[3].y, cubeVertex[3].z);

        glTexCoord2f(uvDx, uvDy); reflex(a_matrix, cubeVertex[1].x, cubeVertex[1].y, cubeVertex[1].z);

      glEnd();

    }

  } while(0);

  

  //Top Face

  do

  {

    texture_alpha(255);

    

    //Choose texture, if there's no texture do not draw

    layoutValuePointer=layout_getLayoutValue(layoutElementPointer, 3+textureToSide[1]);

    if(layoutValuePointer == NULL) break;

    List *listPointer=&a_layout->layoutTexture[layoutValuePointer->intData].frameList;

    texture_set(list_getEntry(listPointer, (a_layout->clock)%list_getEntryCount(listPointer)));

    

    //Can this face be optimized?

    //Can only be applied to shapes that are not modified via scaling or offsetting

    if(unmodifiedShape)

    {

      //Do not draw if the above shape's bottom face is visible

      if(layout_doesNeighborHaveNormalSide(a_layout, a_tileId, a_x, a_y+1, a_z, 3)) break;

    }

    

    //Is it blended? Don't draw it on the first draw stage

    if(layout_drawPhase == 0)

    {

      LayoutElement *textureElement=a_layout->layoutTexture[layoutValuePointer->intData].textureElement;

      if(textureElement != NULL)

      {

        layoutValuePointer=layout_getLayoutValue(textureElement, 2);

        if(layoutValuePointer != NULL)

        {

          if(layoutValuePointer->intData & LAYOUT_Blend) break;

        }

      }

    }

    

    //Is it double sided?

    texture_noclip(doubleSidedFlag & LAYOUT_TOP);

    

    //Apply global shading

    sword shadeDelta=255+a_layout->layoutShading[1];

    shadeDelta=(byte)shadeDelta;

    

    //Apply local shading

    layoutValuePointer=layout_getLayoutValue(layoutElementPointer, 29+1);

    if(layoutValuePointer != NULL)

    {

      sbyte localShadeDelta=layoutValuePointer->intData >> 16;

      shadeDelta+=localShadeDelta*16;

    }

    if(shadeDelta < 0) shadeDelta=0; else if(shadeDelta > 255) shadeDelta=255;

    if(cubeType == 0) texture_color(shadeDelta, shadeDelta, shadeDelta);

    else texture_color(255, 255, 255);

    

    //Setup uvs

    float uvAx=1.0f, uvAy=1.0f;

    float uvBx=1.0f, uvBy=0.0f;

    float uvCx=0.0f, uvCy=0.0f;

    float uvDx=0.0f, uvDy=1.0f;

    

    //Manage UVs

    layoutValuePointer=layout_getLayoutValue(layoutElementPointer, 29+textureToSide[1]);

    if(layoutValuePointer != NULL)

    {

      if(layoutValuePointer->intData & LAYOUT_FlipH)

      {

        float temp;

        temp=uvAx;uvAx=uvDx;uvDx=temp;

        temp=uvAy;uvAy=uvDy;uvDy=temp;

        temp=uvBx;uvBx=uvCx;uvCx=temp;

        temp=uvBy;uvBy=uvCy;uvCy=temp;

      }

      if(layoutValuePointer->intData & LAYOUT_FlipV)

      {

        float temp;

        

        temp=uvAx;uvAx=uvBx;uvBx=temp;

        temp=uvAy;uvAy=uvBy;uvBy=temp;

        temp=uvDx;uvDx=uvCx;uvCx=temp;

        temp=uvDy;uvDy=uvCy;uvCy=temp;

      }

    }

    

    //Draw

    glBegin(GL_QUADS);

      glTexCoord2f(uvAx, uvAy); reflex(a_matrix, cubeVertex[1].x, cubeVertex[1].y, cubeVertex[1].z);

      glTexCoord2f(uvBx, uvBy); reflex(a_matrix, cubeVertex[5].x, cubeVertex[5].y, cubeVertex[5].z);

      glTexCoord2f(uvCx, uvCy); reflex(a_matrix, cubeVertex[4].x, cubeVertex[4].y, cubeVertex[4].z);

      glTexCoord2f(uvDx, uvDy); reflex(a_matrix, cubeVertex[0].x, cubeVertex[0].y, cubeVertex[0].z);

    glEnd();

  } while(0);

  

  //Back Face

  do

  {

    texture_alpha(255);

    

    //Choose texture, if there's no texture do not draw

    layoutValuePointer=layout_getLayoutValue(layoutElementPointer, 3+textureToSide[0]);

    if(layoutValuePointer == NULL) break;

    List *listPointer=&a_layout->layoutTexture[layoutValuePointer->intData].frameList;

    texture_set(list_getEntry(listPointer, (a_layout->clock)%list_getEntryCount(listPointer)));

    

    //Can this face be optimized?

    //Can only be applied to shapes that are not modified via scaling or offsetting

    if(unmodifiedShape)

    {

      //Do not draw if the in the back shape's front face is visible

      if(layout_doesNeighborHaveNormalSide(a_layout, a_tileId, a_x, a_y, a_z+1, 5)) break;

    }

    

    //Is it blended? Don't draw it on the first draw stage

    if(layout_drawPhase == 0)

    {

      LayoutElement *textureElement=a_layout->layoutTexture[layoutValuePointer->intData].textureElement;

      if(textureElement != NULL)

      {

        layoutValuePointer=layout_getLayoutValue(textureElement, 2);

        if(layoutValuePointer != NULL)

        {

          if(layoutValuePointer->intData & LAYOUT_Blend) break;

        }

      }

    }

    

    //Is it double sided?

    texture_noclip(doubleSidedFlag & LAYOUT_BACK);

    

    //Apply global shading

    sword shadeDelta=255+a_layout->layoutShading[0];

    shadeDelta=(byte)shadeDelta;

    

    //Apply local shading

    layoutValuePointer=layout_getLayoutValue(layoutElementPointer, 29+0);

    if(layoutValuePointer != NULL)

    {

      sbyte localShadeDelta=layoutValuePointer->intData >> 16;

      shadeDelta+=localShadeDelta*16;

    }

    if(shadeDelta < 0) shadeDelta=0; else if(shadeDelta > 255) shadeDelta=255;

    if(cubeType == 0) texture_color(shadeDelta, shadeDelta, shadeDelta);

    else texture_color(255, 255, 255);

    

    //Setup uvs

    float uvAx=0.0f, uvAy=0.0f;

    float uvBx=0.0f, uvBy=1.0f;

    float uvCx=1.0f, uvCy=1.0f;

    float uvDx=1.0f, uvDy=0.0f;

    

    //Manage UVs

    layoutValuePointer=layout_getLayoutValue(layoutElementPointer, 29+textureToSide[0]);

    if(layoutValuePointer != NULL)

    {

      if(layoutValuePointer->intData & LAYOUT_FlipH)

      {

        float temp;

        temp=uvAx;uvAx=uvDx;uvDx=temp;

        temp=uvAy;uvAy=uvDy;uvDy=temp;

        temp=uvBx;uvBx=uvCx;uvCx=temp;

        temp=uvBy;uvBy=uvCy;uvCy=temp;

      }

      if(layoutValuePointer->intData & LAYOUT_FlipV)

      {

        float temp;

        

        temp=uvAx;uvAx=uvBx;uvBx=temp;

        temp=uvAy;uvAy=uvBy;uvBy=temp;

        temp=uvDx;uvDx=uvCx;uvCx=temp;

        temp=uvDy;uvDy=uvCy;uvCy=temp;

      }

    }

    

    //Draw

    if((cubeType == 4) || (cubeType == 3))

    { //Front-left leg

      glBegin(GL_QUADS);

        glTexCoord2f(uvAx, uvAy); reflex(a_matrix, cubeVertex[0].x, cubeVertex[0].y, cubeVertex[0].z);

        glTexCoord2f(uvBx, uvBy); reflex(a_matrix, cubeVertex[2].x, cubeVertex[2].y, cubeVertex[2].z);

        glTexCoord2f(uvCx, uvCy); reflex(a_matrix, cubeVertex[8].x, cubeVertex[2].y, cubeVertex[8].z);

        glTexCoord2f(uvDx, uvDy); reflex(a_matrix, cubeVertex[8].x, cubeVertex[0].y, cubeVertex[8].z);

      glEnd();

    }

    else

    {

      glBegin(GL_QUADS);

        glTexCoord2f(uvAx, uvAy); reflex(a_matrix, cubeVertex[5].x, cubeVertex[5].y, cubeVertex[5].z);

        glTexCoord2f(uvBx, uvBy); reflex(a_matrix, cubeVertex[7].x, cubeVertex[7].y, cubeVertex[7].z);

        glTexCoord2f(uvCx, uvCy); reflex(a_matrix, cubeVertex[6].x, cubeVertex[6].y, cubeVertex[6].z);

        glTexCoord2f(uvDx, uvDy); reflex(a_matrix, cubeVertex[4].x, cubeVertex[4].y, cubeVertex[4].z);

      glEnd();

    }

  } while(0);

  

  //Bottom Face

  do

  {

    texture_alpha(255);

    

    //Choose texture, if there's no texture do not draw

    layoutValuePointer=layout_getLayoutValue(layoutElementPointer, 3+textureToSide[3]);

    if(layoutValuePointer == NULL) break;

    List *listPointer=&a_layout->layoutTexture[layoutValuePointer->intData].frameList;

    texture_set(list_getEntry(listPointer, (a_layout->clock)%list_getEntryCount(listPointer)));

    

    //Can this face be optimized?

    //Can only be applied to shapes that are not modified via scaling or offsetting

    if(unmodifiedShape)

    {

      //Do not draw if the bottom shape's top face is visible

      if(layout_doesNeighborHaveNormalSide(a_layout, a_tileId, a_x, a_y-1, a_z, 1)) break;

    }

    

    //Is it blended? Don't draw it on the first draw stage

    if(layout_drawPhase == 0)

    {

      LayoutElement *textureElement=a_layout->layoutTexture[layoutValuePointer->intData].textureElement;

      if(textureElement != NULL)

      {

        layoutValuePointer=layout_getLayoutValue(textureElement, 2);

        if(layoutValuePointer != NULL)

        {

          if(layoutValuePointer->intData & LAYOUT_Blend) break;

        }

      }

    }

    

    //Is it double sided?

    texture_noclip(doubleSidedFlag & LAYOUT_BOTTOM);

    

    //Apply global shading

    sword shadeDelta=255+a_layout->layoutShading[3];

    shadeDelta=(byte)shadeDelta;

    

    //Apply local shading

    layoutValuePointer=layout_getLayoutValue(layoutElementPointer, 29+3);

    if(layoutValuePointer != NULL)

    {

      sbyte localShadeDelta=layoutValuePointer->intData >> 16;

      shadeDelta+=localShadeDelta*16;

    }

    if(shadeDelta < 0) shadeDelta=0; else if(shadeDelta > 255) shadeDelta=255;

    if(cubeType == 0) texture_color(shadeDelta, shadeDelta, shadeDelta);

    else texture_color(255, 255, 255);

    

    //Darken?

    layoutValuePointer=layout_getLayoutValue(layoutElementPointer, 29+3);

    if(layoutValuePointer != NULL)

    {

      if(layoutValuePointer->intData & LAYOUT_Darken) texture_color(0, 0, 0);

    }

    

    //Setup uvs

    float uvAx=0.0f, uvAy=0.0f;

    float uvBx=1.0f, uvBy=0.0f;

    float uvCx=1.0f, uvCy=1.0f;

    float uvDx=0.0f, uvDy=1.0f;

    

    //Manage UVs

    layoutValuePointer=layout_getLayoutValue(layoutElementPointer, 29+textureToSide[3]);

    if(layoutValuePointer != NULL)

    {

      if(layoutValuePointer->intData & LAYOUT_FlipH)

      {

        float temp;

        temp=uvAx;uvAx=uvDx;uvDx=temp;

        temp=uvAy;uvAy=uvDy;uvDy=temp;

        temp=uvBx;uvBx=uvCx;uvCx=temp;

        temp=uvBy;uvBy=uvCy;uvCy=temp;

      }

      if(layoutValuePointer->intData & LAYOUT_FlipV)

      {

        float temp;

        

        temp=uvAx;uvAx=uvBx;uvBx=temp;

        temp=uvAy;uvAy=uvBy;uvBy=temp;

        temp=uvDx;uvDx=uvCx;uvCx=temp;

        temp=uvDy;uvDy=uvCy;uvCy=temp;

      }

    }

    

    //Draw

    if((cubeType == 6) || (cubeType == 1) || (cubeType == 2))

    { //Draw a Shadow? (Special case for a sprite)

      

      //Set texture color to black

      texture_color(0, 0, 0);

      texture_alpha(100);

      

      //Find how far to drop the shadow

      byte slopeOfProjectPlane=0;

      float shadowDropDistance=layout_getDropDistance(a_layout, &slopeOfProjectPlane, a_x, a_y, a_z);

      

      //Do not draw if shadowDropDistance is negative

      if(shadowDropDistance < 0) break;

      

      //Draw a bottom face facing up

      glBegin(GL_QUADS);

        glTexCoord2f(uvAx, uvAy); reflex(a_matrix, cubeVertex[6].x, a_y-0.45f-shadowDropDistance-(1.0f-slopeElevation[slopeOfProjectPlane][0])*0.75f, cubeVertex[6].z);

        glTexCoord2f(uvDx, uvDy); reflex(a_matrix, cubeVertex[2].x, a_y-0.45f-shadowDropDistance-(1.0f-slopeElevation[slopeOfProjectPlane][2])*0.75f, cubeVertex[2].z);

        glTexCoord2f(uvCx, uvCy); reflex(a_matrix, cubeVertex[3].x, a_y-0.45f-shadowDropDistance-(1.0f-slopeElevation[slopeOfProjectPlane][3])*0.75f, cubeVertex[3].z);

        glTexCoord2f(uvBx, uvBy); reflex(a_matrix, cubeVertex[7].x, a_y-0.45f-shadowDropDistance-(1.0f-slopeElevation[slopeOfProjectPlane][1])*0.75f, cubeVertex[7].z);

      glEnd();

    }

    else

    {

      glBegin(GL_QUADS);

        glTexCoord2f(uvAx, uvAy); reflex(a_matrix, cubeVertex[6].x, cubeVertex[6].y, cubeVertex[6].z);

        glTexCoord2f(uvBx, uvBy); reflex(a_matrix, cubeVertex[7].x, cubeVertex[7].y, cubeVertex[7].z);

        glTexCoord2f(uvCx, uvCy); reflex(a_matrix, cubeVertex[3].x, cubeVertex[3].y, cubeVertex[3].z);

        glTexCoord2f(uvDx, uvDy); reflex(a_matrix, cubeVertex[2].x, cubeVertex[2].y, cubeVertex[2].z);

      glEnd();

    }

  } while(0);

  

  //Right face

  do

  {

    texture_alpha(255);

    

    //Choose texture, if there's no texture do not draw

    layoutValuePointer=layout_getLayoutValue(layoutElementPointer, 3+textureToSide[2]);

    if(layoutValuePointer == NULL) break;

    List *listPointer=&a_layout->layoutTexture[layoutValuePointer->intData].frameList;

    texture_set(list_getEntry(listPointer, (a_layout->clock)%list_getEntryCount(listPointer)));

    

    //Can this face be optimized?

    //Can only be applied to shapes that are not modified via scaling or offsetting

    if(unmodifiedShape)

    {

      //Do not draw if the right shape's left face is visible

      if(layout_doesNeighborHaveNormalSide(a_layout, a_tileId, a_x+1, a_y, a_z, 4)) break;

    }

    

    //Is it blended? Don't draw it on the first draw stage

    if(layout_drawPhase == 0)

    {

      LayoutElement *textureElement=a_layout->layoutTexture[layoutValuePointer->intData].textureElement;

      if(textureElement != NULL)

      {

        layoutValuePointer=layout_getLayoutValue(textureElement, 2);

        if(layoutValuePointer != NULL)

        {

          if(layoutValuePointer->intData & LAYOUT_Blend) break;

        }

      }

    }

    

    //Is it double sided?

    texture_noclip(doubleSidedFlag & LAYOUT_RIGHT);

    

    //Apply global shading

    sword shadeDelta=255+a_layout->layoutShading[2];

    shadeDelta=(byte)shadeDelta;

    

    //Apply local shading

    layoutValuePointer=layout_getLayoutValue(layoutElementPointer, 29+2);

    if(layoutValuePointer != NULL)

    {

      sbyte localShadeDelta=layoutValuePointer->intData >> 16;

      shadeDelta+=localShadeDelta*16;

    }

    if(shadeDelta < 0) shadeDelta=0; else if(shadeDelta > 255) shadeDelta=255;

    if(cubeType == 0) texture_color(shadeDelta, shadeDelta, shadeDelta);

    else texture_color(255, 255, 255);

    

    //Setup uvs

    float uvAx=1.0f, uvAy=1.0f;

    float uvBx=1.0f, uvBy=0.0f;

    float uvCx=0.0f, uvCy=0.0f;

    float uvDx=0.0f, uvDy=1.0f;

    

    //Manage UVs

    layoutValuePointer=layout_getLayoutValue(layoutElementPointer, 29+textureToSide[2]);

    if(layoutValuePointer != NULL)

    {

      if(layoutValuePointer->intData & LAYOUT_FlipH)

      {

        float temp;

        temp=uvAx;uvAx=uvDx;uvDx=temp;

        temp=uvAy;uvAy=uvDy;uvDy=temp;

        temp=uvBx;uvBx=uvCx;uvCx=temp;

        temp=uvBy;uvBy=uvCy;uvCy=temp;

      }

      if(layoutValuePointer->intData & LAYOUT_FlipV)

      {

        float temp;

        

        temp=uvAx;uvAx=uvBx;uvBx=temp;

        temp=uvAy;uvAy=uvBy;uvBy=temp;

        temp=uvDx;uvDx=uvCx;uvCx=temp;

        temp=uvDy;uvDy=uvCy;uvCy=temp;

      }

    }

    

    //Draw

    if((cubeType == 4) || (cubeType == 3))

    { //Front-right leg

      glBegin(GL_QUADS);

        glTexCoord2f(uvDx, uvDy); reflex(a_matrix, cubeVertex[3].x, cubeVertex[3].y, cubeVertex[3].z);

        glTexCoord2f(uvCx, uvCy); reflex(a_matrix, cubeVertex[1].x, cubeVertex[1].y, cubeVertex[1].z);

        glTexCoord2f(uvBx, uvBy); reflex(a_matrix, cubeVertex[8].x, cubeVertex[0].y, cubeVertex[8].z);

        glTexCoord2f(uvAx, uvAy); reflex(a_matrix, cubeVertex[8].x, cubeVertex[2].y, cubeVertex[8].z);

      glEnd();

    }

    else

    {

      glBegin(GL_QUADS);

        glTexCoord2f(uvAx, uvAy); reflex(a_matrix, cubeVertex[7].x, cubeVertex[7].y, cubeVertex[7].z);

        glTexCoord2f(uvBx, uvBy); reflex(a_matrix, cubeVertex[5].x, cubeVertex[5].y, cubeVertex[5].z);

        glTexCoord2f(uvCx, uvCy); reflex(a_matrix, cubeVertex[1].x, cubeVertex[1].y, cubeVertex[1].z);

        glTexCoord2f(uvDx, uvDy); reflex(a_matrix, cubeVertex[3].x, cubeVertex[3].y, cubeVertex[3].z);

      glEnd();

    }

  } while(0);

  

  //Left Face

  do

  {

    texture_alpha(255);

    

    //Choose texture, if there's no texture do not draw

    layoutValuePointer=layout_getLayoutValue(layoutElementPointer, 3+textureToSide[4]);

    if(layoutValuePointer == NULL) break;

    List *listPointer=&a_layout->layoutTexture[layoutValuePointer->intData].frameList;

    texture_set(list_getEntry(listPointer, (a_layout->clock)%list_getEntryCount(listPointer)));

    

    //Can this face be optimized?

    //Can only be applied to shapes that are not modified via scaling or offsetting

    if(unmodifiedShape)

    {

      //Do not draw if the left shape's right face is visible

      if(layout_doesNeighborHaveNormalSide(a_layout, a_tileId, a_x-1, a_y, a_z, 2)) break;

    }

    

    //Is it blended? Don't draw it on the first draw stage

    if(layout_drawPhase == 0)

    {

      LayoutElement *textureElement=a_layout->layoutTexture[layoutValuePointer->intData].textureElement;

      if(textureElement != NULL)

      {

        layoutValuePointer=layout_getLayoutValue(textureElement, 2);

        if(layoutValuePointer != NULL)

        {

          if(layoutValuePointer->intData & LAYOUT_Blend) break;

        }

      }

    }

    

    //Is it double sided?

    texture_noclip(doubleSidedFlag & LAYOUT_LEFT);

    

    //Apply global shading

    sword shadeDelta=255+a_layout->layoutShading[4];

    shadeDelta=(byte)shadeDelta;

    

    //Apply local shading

    layoutValuePointer=layout_getLayoutValue(layoutElementPointer, 29+4);

    if(layoutValuePointer != NULL)

    {

      sbyte localShadeDelta=layoutValuePointer->intData >> 16;

      shadeDelta+=localShadeDelta*16;

    }

    if(shadeDelta < 0) shadeDelta=0; else if(shadeDelta > 255) shadeDelta=255;

    if(cubeType == 0) texture_color(shadeDelta, shadeDelta, shadeDelta);

    else texture_color(255, 255, 255);

    

    //Setup uvs

    float uvAx=1.0f, uvAy=0.0f;

    float uvBx=0.0f, uvBy=0.0f;

    float uvCx=0.0f, uvCy=1.0f;

    float uvDx=1.0f, uvDy=1.0f;

    

    //Manage UVs

    layoutValuePointer=layout_getLayoutValue(layoutElementPointer, 29+textureToSide[4]);

    if(layoutValuePointer != NULL)

    {

      if(layoutValuePointer->intData & LAYOUT_FlipH)

      {

        float temp;

        

        temp=uvAx;uvAx=uvBx;uvBx=temp;

        temp=uvAy;uvAy=uvBy;uvBy=temp;

        temp=uvDx;uvDx=uvCx;uvCx=temp;

        temp=uvDy;uvDy=uvCy;uvCy=temp;

      }

      if(layoutValuePointer->intData & LAYOUT_FlipV)

      {

        float temp;

        

        temp=uvAx;uvAx=uvDx;uvDx=temp;

        temp=uvAy;uvAy=uvDy;uvDy=temp;

        temp=uvBx;uvBx=uvCx;uvCx=temp;

        temp=uvBy;uvBy=uvCy;uvCy=temp;

      }

    }

    

    //Draw

    if((cubeType == 4) || (cubeType == 3))

    {

      glBegin(GL_QUADS);

        glTexCoord2f(uvAx, uvAy); reflex(a_matrix, cubeVertex[8].x, cubeVertex[0].y, cubeVertex[8].z);

        glTexCoord2f(uvBx, uvBy); reflex(a_matrix, cubeVertex[4].x, cubeVertex[4].y, cubeVertex[4].z);

        glTexCoord2f(uvCx, uvCy); reflex(a_matrix, cubeVertex[6].x, cubeVertex[6].y, cubeVertex[6].z);

        glTexCoord2f(uvDx, uvDy); reflex(a_matrix, cubeVertex[8].x, cubeVertex[2].y, cubeVertex[8].z);

      glEnd();

    }

    else

    {

      glBegin(GL_QUADS);

        glTexCoord2f(uvAx, uvAy); reflex(a_matrix, cubeVertex[0].x, cubeVertex[0].y, cubeVertex[0].z);

        glTexCoord2f(uvBx, uvBy); reflex(a_matrix, cubeVertex[4].x, cubeVertex[4].y, cubeVertex[4].z);

        glTexCoord2f(uvCx, uvCy); reflex(a_matrix, cubeVertex[6].x, cubeVertex[6].y, cubeVertex[6].z);

        glTexCoord2f(uvDx, uvDy); reflex(a_matrix, cubeVertex[2].x, cubeVertex[2].y, cubeVertex[2].z);

      glEnd();

    }

  } while(0);

  

  //Reset draw settings

  texture_noclip(false);

  texture_alpha(255);

  texture_color(255, 255, 255);

}

void layout_draw(Layout *a_layout, float *a_matrix)

{

  byte *sync;

  sdword x=0;

  sdword y=0;

  sdword z=0;

  

  //Draw the bg

  /*if((layout_drawPhase == 0) && (a_layout->layoutBackgroundTexture))

  {

    camera_2D();

    texture_color(255, 255, 255);

    texture_smooth(true);

    glDisable(GL_LIGHTING);

    texture_set(a_layout->layoutBackgroundTexture);

    //else texture_set(&tile_dummy);

    glBegin(GL_QUADS);

      glTexCoord2f(0, 0); glVertex2f(0, 0);

      glTexCoord2f(0, 1); glVertex2f(0, PH);

      glTexCoord2f(1, 1); glVertex2f(PW, PH);

      glTexCoord2f(1, 0); glVertex2f(PW, 0);

    glEnd();

    glEnable(GL_LIGHTING);

    glDisable(GL_LIGHTING);

    camera_3D(45);

  }*/

  //Draw the map

  for(z=a_layout->layoutDepth-1; z >= 0; z--) //Back to front

  {

    for(y=0; y < a_layout->layoutHeight; y++) //Down to up

    {

      sync=&a_layout->layoutMap[(y*a_layout->layoutWidth*a_layout->layoutDepth)+(z*a_layout->layoutWidth)];

      for(x=0; x < a_layout->layoutWidth; x++)

      {

        if(*sync)

        {

          layout_drawCube(a_layout, a_matrix, *sync++, x, y, z);

        } else sync++;

      }

    }

  }

  

  layout_drawPhase=!layout_drawPhase;

}

void layout_init(Layout *a_layout)

{

  //Initiate the lists

  list_init(&a_layout->variableList);

  list_init(&a_layout->paletteList);

  list_init(&a_layout->cameraList);

  list_init(&a_layout->textureList);

  list_init(&a_layout->qubixList);

  list_init(&a_layout->actorList);

  list_init(&a_layout->pathList);

  list_init(&a_layout->cubeList);

  

  //Set the proper NULLs

  a_layout->clock=0;

  a_layout->layoutTexture=NULL;

  a_layout->layoutWidth=0;

  a_layout->layoutHeight=0;

  a_layout->layoutDepth=0;

  a_layout->layoutMap=NULL;

  a_layout->layoutBackgroundTexture=NULL;

  memset(a_layout->layoutShading, 0, sizeof(a_layout->layoutShading));

}

void layout_loadDef(Layout *a_layout, byte *a_defFileName)

{

  //Parse the DEF file

  layout_parseDef(a_layout, a_defFileName);

}

void layout_build(Layout *a_layout, byte *a_pcxBaseDirPath)

{

  byte stringBuffer[512]={0};

  

  //Texture:Process and load all the textures

  do

  {

    dword textureTotal=list_getEntryCount(&a_layout->textureList);

    if(!textureTotal) break;

    

    //Create the memory for the textures

    a_layout->layoutTexture=malloc(sizeof(LayoutTexture) * textureTotal);

    

    //Process each

    {

      dword textureCounter=0;

      while(textureCounter < textureTotal)

      {

        LayoutElement *layoutElementPointer=list_getEntry(&a_layout->textureList, textureCounter);

        LayoutValue *layoutValuePointer=NULL;

        Image image;

        

        //Initiate the LayoutTexture

        list_init(&a_layout->layoutTexture[textureCounter].frameList);

        a_layout->layoutTexture[textureCounter].textureElement=layoutElementPointer;

        

        //Read texture type

        dword textureType=0;

        layoutValuePointer=layout_getLayoutValue(layoutElementPointer, 1);

        if(layoutValuePointer != NULL) textureType=layoutValuePointer->intData;

        

        //Read texture render mode information

        dword textureRenderMode=0;

        layoutValuePointer=layout_getLayoutValue(layoutElementPointer, 2);

        if(layoutValuePointer != NULL) textureRenderMode=layoutValuePointer->intData;

        

        //Read shade colors

        dword shadeLeftColor=0xFF;

        dword shadeRightColor=0xFF;

        dword frameLeftColor=0xFF;

        dword frameRightColor=0xFF;

        

        //Fetch shade left color

        layoutValuePointer=layout_getLayoutValue(layoutElementPointer, 17);

        if(layoutValuePointer != NULL) shadeLeftColor=layoutValuePointer->intData;

        

        //Fetch shade right color

        layoutValuePointer=layout_getLayoutValue(layoutElementPointer, 20);

        if(layoutValuePointer != NULL) shadeRightColor=layoutValuePointer->intData;

        

        //Fetch frame left color

        layoutValuePointer=layout_getLayoutValue(layoutElementPointer, 18);

        if(layoutValuePointer != NULL) frameLeftColor=layoutValuePointer->intData;

        

        //Fetch frame right color

        layoutValuePointer=layout_getLayoutValue(layoutElementPointer, 19);

        if(layoutValuePointer != NULL) frameRightColor=layoutValuePointer->intData;

        

        //Get ready to load all frames

        dword frameCounter=0;

        bool firstFrameHasAlpha=1;

        while(1)

        {

          bool lastFrameSuccess=0;

          

          //Do we load a bitmap or use a fresh texture?

          if(textureType & LAYOUT_TXTR_Bitmap)

          {

            //Read texture file name

            layoutValuePointer=layout_getLayoutValue(layoutElementPointer, 8);

            //A file path is stated

            if(layoutValuePointer != NULL)

            {

              //Prepare the full file path

              if(frameCounter == 0)

                layout_parsePath(stringBuffer, a_pcxBaseDirPath, layoutValuePointer->stringData, ".pcx");

              else

              {

                //Mutate file path

                dword pathLen=strlen(stringBuffer)-4;

                

                if(util_isDigit(stringBuffer[pathLen-1]))

                {

                  if(stringBuffer[pathLen-1] == '9')

                  {

                    stringBuffer[pathLen-1]='0';

                    if(util_isDigit(stringBuffer[pathLen-2]))

                    {

                      if(stringBuffer[pathLen-2] == '9')

                      {

                        stringBuffer[pathLen-2]='0';

                        if(util_isDigit(stringBuffer[pathLen-3]))

                        {

                          if(stringBuffer[pathLen-3] == '9')

                            break;

                          else stringBuffer[pathLen-3]++;

                        }

                      }

                      else stringBuffer[pathLen-2]++;

                    }

                    else break;

                  }

                  else stringBuffer[pathLen-1]++;

                }

                else break; //Can't mutate

              }

              

              //Attempt to load frame

              if(image_loadPcx(&image, stringBuffer, 1))

              {

                //Do we use transparency? //AutoTrans always

                if(/*(textureRenderMode & LAYOUT_AutoTrans) &&*/ firstFrameHasAlpha)

                {

                  if(frameCounter==0)

                    firstFrameHasAlpha=image_autoAlpha(&image); //Always apply autotrans

                  else

                    image_autoAlpha(&image);

                }

                

                //Increment the frame count

                frameCounter++;

                  

                //Success

                lastFrameSuccess=1;

              }

            }

            

            //Load a dummy frame if frameCounter is 0

            if(frameCounter == 0)

            {

              image_create(&image, 32, 32, 1);

              image_fillFlat(&image, 0x8080A0FF);

            }

            else if(lastFrameSuccess == 0)

              break;  //If last frame was not a success and we already loaded 1 frame, break

          }

          else if(textureType & LAYOUT_TXTR_AUTO_FILL)

          {

            //Auto fill

            image_create(&image, 32, 32, 1);

            image_fillAuto(&image, shadeLeftColor, shadeRightColor);

          }

          else //LAYOUT_TXTR_FLAT_FILL is default

          {

            //Flat fill

            image_create(&image, 32, 32, 1);

            //image_fillFlat(&image, shadeLeftColor);

            image_fillAuto(&image, shadeLeftColor, shadeRightColor); //MAKE JG07 WOOD look pretty since it's flat but not auto...

          }

          

          //Does the image have a box frame?

          if(textureType & LAYOUT_TXTR_FRAME2)

          {

            image_drawFrame(&image, frameLeftColor, frameRightColor);

          }

          

          //Does the image have a X frame?

          if(textureType & LAYOUT_TXTR_FRAME1)

          {

            image_drawCross(&image, frameLeftColor, frameRightColor);

          }

          

          //Do we blend?

          if(textureRenderMode & LAYOUT_Blend)

          {

            image_blendAlpha(&image);

          }

          

          //Process the image and make it a texture

          Texture *texture=malloc(sizeof(Texture));

          texture_fromImage(texture, &image);

          image_destroy(&image);

          

          list_addEntry(&a_layout->layoutTexture[textureCounter].frameList, texture);

        

          //If last frame was not a success, break

          if(lastFrameSuccess == 0) break;

        }

        

        //Goto next texture

        textureCounter++;

      }

    }

  } while(0);

  

  //Qubix:Load the layout & background image

  do

  {

    LayoutElement *layoutElementPointer=NULL;

    LayoutValue *layoutValuePointer=NULL;

    

    //Load the layout

    {

      //Get first qubix element

      layoutElementPointer=list_getEntry(&a_layout->qubixList, 0);

      if(layoutElementPointer == NULL) break;

      

      //Get layout texture file name

      layoutValuePointer=layout_getLayoutValue(layoutElementPointer, 1);

      if(layoutValuePointer == NULL) break;

      

      //Prepare the full file path

      layout_parsePath(stringBuffer, a_pcxBaseDirPath, layoutValuePointer->stringData, ".pcx");

      

      //Parse

      layout_parsePcx(a_layout, stringBuffer);

    }

    

    //Load background image

    {

      layoutValuePointer=layout_getLayoutValue(layoutElementPointer, 2);

      if(layoutValuePointer == NULL) break;

      

      //Prepare the full file path

      layout_parsePath(stringBuffer, a_pcxBaseDirPath, layoutValuePointer->stringData, ".pcx");

      

      //Load image

      Image image;

      if(!image_loadPcx(&image, stringBuffer, 0)) break;

      

      a_layout->layoutBackgroundTexture=malloc(sizeof(Texture));

      texture_fromImage(a_layout->layoutBackgroundTexture, &image);

      

      image_destroy(&image);

    }

  } while(0);

  

  //Cube:Link the textures to the cubes by storing the engine texture's index in the intData of the cube's texture reference

  do

  {

    dword cubeTotal=list_getEntryCount(&a_layout->cubeList);

    dword textureTotal=list_getEntryCount(&a_layout->textureList);

    if(!cubeTotal) break;

    if(!textureTotal) break;

    

    //Loop through each cube

    dword cubeCounter=0;

    while(cubeCounter < cubeTotal)

    {

      LayoutElement *layoutElementPointer=list_getEntry(&a_layout->cubeList, cubeCounter);

      LayoutValue *layoutValuePointer=NULL;

        

      //Loop through each side

      dword sideCounter=0;

      while(sideCounter < 6) //6 sides in a cube

      {

        //See if there's a texture set for the said side

        layoutValuePointer=layout_getLayoutValue(layoutElementPointer, 3+sideCounter);

        

         if(layoutValuePointer != NULL)

        {

          //A texture is set, now we must find the texture by matching names

          dword textureCounter=0;

          while(textureCounter < textureTotal)

          {

            LayoutElement *layoutSubElementPointer=list_getEntry(&a_layout->textureList, textureCounter);

            

            if(strcmp(layoutValuePointer->stringData, layoutSubElementPointer->elementName) == 0)

            {

              //We have found a match, link textures

              layoutValuePointer->intData=textureCounter;

              break;

            }

            

            //Goto next texture

            textureCounter++;

          }

          

          //Has a match failed to be found? A cube with a texture given that's not in the actual texture list at all

          //Just let it be

        }

        

        //Goto next side

        sideCounter++;

      }

      

      //Goto next cube

      cubeCounter++;

    }

  } while(0);

  

  //Variable:Find some important variables and transfer their values over

  do

  {

    dword variableTotal=list_getEntryCount(&a_layout->variableList);

    if(!variableTotal) break;

    

    //Loop through each variable

    dword variableCounter=0;

    while(variableCounter < variableTotal)

    {

      LayoutElement *layoutElementPointer=list_getEntry(&a_layout->variableList, variableCounter);

      LayoutValue *layoutValuePointer=NULL;

      //Scan to see if it's a key variable

      if(strcmp(layoutElementPointer->elementName, "\"SYS_BackShading\"") == 0)

      {

        //Get the value

        layoutValuePointer=layout_getLayoutValue(layoutElementPointer, 2);

        if(layoutValuePointer != NULL) a_layout->layoutShading[0]=layoutValuePointer->intData;

      }

      else if(strcmp(layoutElementPointer->elementName, "\"SYS_TopShading\"") == 0)

      {

        //Get the value

        layoutValuePointer=layout_getLayoutValue(layoutElementPointer, 2);

        if(layoutValuePointer != NULL) a_layout->layoutShading[1]=layoutValuePointer->intData;

      }

      else if(strcmp(layoutElementPointer->elementName, "\"SYS_RightShading\"") == 0)

      {

        //Get the value

        layoutValuePointer=layout_getLayoutValue(layoutElementPointer, 2);

        if(layoutValuePointer != NULL) a_layout->layoutShading[2]=layoutValuePointer->intData;

      }

      else if(strcmp(layoutElementPointer->elementName, "\"SYS_BottomShading\"") == 0)

      {

        //Get the value

        layoutValuePointer=layout_getLayoutValue(layoutElementPointer, 2);

        if(layoutValuePointer != NULL) a_layout->layoutShading[3]=layoutValuePointer->intData;

      }

      else if(strcmp(layoutElementPointer->elementName, "\"SYS_LeftShading\"") == 0)

      {

        //Get the value

        layoutValuePointer=layout_getLayoutValue(layoutElementPointer, 2);

        if(layoutValuePointer != NULL) a_layout->layoutShading[4]=layoutValuePointer->intData;

      }

      else if(strcmp(layoutElementPointer->elementName, "\"SYS_FrontShading\"") == 0)

      {

        //Get the value

        layoutValuePointer=layout_getLayoutValue(layoutElementPointer, 2);

        if(layoutValuePointer != NULL) a_layout->layoutShading[5]=layoutValuePointer->intData;

      }

      

      //Goto next variable

      variableCounter++;

    }

  } while(0);

}

void layout_debug(Layout *a_layout)

{

  //VARIABLE

  {

    dword entryIndex=0;

    dword entryTotal=list_getEntryCount(&a_layout->variableList);

    while(entryIndex < entryTotal)

    {

      LayoutElement *layoutElementPointer=list_getEntry(&a_layout->variableList, entryIndex);

      

      //Print element name

      printf("[VARIABLE:%s]\n", layoutElementPointer->elementName);

      

      //Loop through element value list

      {

        dword entryIndex=0;

        dword entryTotal=list_getEntryCount(&layoutElementPointer->valueList);

        while(entryIndex < entryTotal)

        {

          LayoutValue *layoutValuePointer=list_getEntry(&layoutElementPointer->valueList, entryIndex);

          

          //Print value id & data

          printf("%d=%s\n", layoutValuePointer->id, layoutValuePointer->stringData);

          

          //Goto the next entry

          entryIndex++;

        }

      }

      

      //Loop through element hexdump list

      {

        dword entryIndex=0;

        dword entryTotal=list_getEntryCount(&layoutElementPointer->hexDumpList);

        while(entryIndex < entryTotal)

        {

          byte *hexDump=list_getEntry(&layoutElementPointer->hexDumpList, entryIndex);

          

          //Print value id & data

          printf("HexDump=%s\n", hexDump);

          

          //Goto the next entry

          entryIndex++;

        }

      }

      

      //Goto the next entry

      entryIndex++;

    }

  }

  //list_init(&a_layout->paletteList);

  //list_init(&a_layout->cameraList);

  //TEXTURE

  {

    dword entryIndex=0;

    dword entryTotal=list_getEntryCount(&a_layout->textureList);

    while(entryIndex < entryTotal)

    {

      LayoutElement *layoutElementPointer=list_getEntry(&a_layout->textureList, entryIndex);

      

      //Print element name

      printf("[TEXTURE:%s]\n", layoutElementPointer->elementName);

      

      //Loop through element value list

      {

        dword entryIndex=0;

        dword entryTotal=list_getEntryCount(&layoutElementPointer->valueList);

        while(entryIndex < entryTotal)

        {

          LayoutValue *layoutValuePointer=list_getEntry(&layoutElementPointer->valueList, entryIndex);

          

          //Print value id & data

          printf("%d=%s\n", layoutValuePointer->id, layoutValuePointer->stringData);

          

          //Goto the next entry

          entryIndex++;

        }

      }

      

      //Loop through element hexdump list

      {

        dword entryIndex=0;

        dword entryTotal=list_getEntryCount(&layoutElementPointer->hexDumpList);

        while(entryIndex < entryTotal)

        {

          byte *hexDump=list_getEntry(&layoutElementPointer->hexDumpList, entryIndex);

          

          //Print value id & data

          printf("HexDump=%s\n", hexDump);

          

          //Goto the next entry

          entryIndex++;

        }

      }

      

      //Goto the next entry

      entryIndex++;

    }

  }

  //list_init(&a_layout->qubixList);

  //list_init(&a_layout->actorList);

  //list_init(&a_layout->pathList);

  //list_init(&a_layout->cubeList);

}

Uhyve · Jan 10, 2011

SANiK said:

The scale and offset are stored as a combined 32bit number.
The top 16 bits are the relative offset and the bottom 16 bits are the relative scale.

The scale is relative to 1 which you've figured out already and it uses 128.0f accuracy which you've also figured out.
The offset is 256.0f accuracy.
Click to expand...

Ah man, that is alot simpler, feel like I should've thought of that.

SANiK said:

Ofer made up as he went along. There are various functional differences in the DEF format, even though the DEF files show the same file version number.
You might also want to invest time in a nice database to manage the resources.
Click to expand...

Yeah, I noticed some stuff in the JG_0* levels that suggested something like that happening, some sort of database probably would be the best idea. My code feels really hacky at this point...

SANiK said:

Code
Click to expand...

... Especially after seeing that. That is really clean code, I'm kind of embarrassed to have released my source now. Gonna have to spend some time looking through all that, I'm not too proud to admit that I'm alittle giddy right now. My code has so many glitches, I've constantly been wondering how you managed to get some of the stuff working.

SANiK · Jan 11, 2011

Uhyve said:

SANiK said:

The scale and offset are stored as a combined 32bit number.
The top 16 bits are the relative offset and the bottom 16 bits are the relative scale.

The scale is relative to 1 which you've figured out already and it uses 128.0f accuracy which you've also figured out.
The offset is 256.0f accuracy.
Click to expand...

Ah man, that is alot simpler, feel like I should've thought of that.

SANiK said:

Ofer made up as he went along. There are various functional differences in the DEF format, even though the DEF files show the same file version number.
You might also want to invest time in a nice database to manage the resources.
Click to expand...

Yeah, I noticed some stuff in the JG_0* levels that suggested something like that happening, some sort of database probably would be the best idea. My code feels really hacky at this point...

SANiK said:

Code
Click to expand...

... Especially after seeing that. That is really clean code, I'm kind of embarrassed to have released my source now. Gonna have to spend some time looking through all that, I'm not too proud to admit that I'm alittle giddy right now. My code has so many glitches, I've constantly been wondering how you managed to get some of the stuff working.
Click to expand...

Well even my code is hacky, but that is expected when reverse engineering. Furthermore I could have used a loop for certain parts of the above code, but I did not and instead I wrote things out in case there was an unexpected exception to how something might be handled. All part of the learning process.

I would suggest you focus more on coding than on cleansiness.
Do this so you can understand the file format better and write a file format specification.
After that is done, you can finally start coding a neater map viewer since you will have the ability to preplan your code from your specification notes.

Trying to reverse engineer and make a complete product at the same time will only exhaust you.

SegaLoco · Jan 11, 2011

Dude, are you considering porting to OpenGL sometime, or will this stay a Direct3D thing?

Uhyve · Jan 11, 2011

SANiK said:

Well even my code is hacky, but that is expected when reverse engineering. Furthermore I could have used a loop for certain parts of the above code, but I did not and instead I wrote things out in case there was an unexpected exception to how something might be handled. All part of the learning process.

I would suggest you focus more on coding than on cleansiness.
Do this so you can understand the file format better and write a file format specification.
After that is done, you can finally start coding a neater map viewer since you will have the ability to preplan your code from your specification notes.

Trying to reverse engineer and make a complete product at the same time will only exhaust you.
Click to expand...

Yeah, that sounds like a good idea, I've never been very patient when it comes to programming, but in this case, that sounds like the best way of going.

SegaLoco said:

Dude, are you considering porting to OpenGL sometime, or will this stay a Direct3D thing?
Click to expand...

I'll probably be leaving it as DirectX for now. But the project is open source, so if anyone thinks that they're up to the task, they can always get in contact. I assume that it's also pretty dependent on MSVS, so I dunno if it would compile for Linux, since I've barely ever used GCC. Would be nice though.

kazade · Jan 14, 2011

SegaLoco said:

Dude, are you considering porting to OpenGL sometime, or will this stay a Direct3D thing?
Click to expand...

I'll probably be leaving it as DirectX for now. But the project is open source, so if anyone thinks that they're up to the task, they can always get in contact. I assume that it's also pretty dependent on MSVS, so I dunno if it would compile for Linux, since I've barely ever used GCC. Would be nice though.
Click to expand...

Just so you know, I'm taking a look at an SDL/OpenGL port (developing on Ubuntu). I'll let you know how it goes...

P.S. Thank you for open sourcing it. Respect++;

SANiK · Jan 14, 2011

In Level.cpp there is a typo:
usedCubes[currentCube].zScale = (1+(signed short)combinedScaleOffset)/128.0f;

The 1+ should be outside the parenthesis.

Uhyve · Jan 15, 2011

SANiK said:

In Level.cpp there is a typo:
usedCubes[currentCube].zScale = (1+(signed short)combinedScaleOffset)/128.0f;

The 1+ should be outside the parenthesis.
Click to expand...

Right, with the correct scaling, everything looked way too big, so that was me trying to fix it without really understanding the code. Got it figured out now, my problem was that I was already adding 1 to the scale somewhere else in the code, so it looked more right with the +1 inside the parenthesis because it was getting divided by 128. Now I've just gotta figure out where the offsets are going wrong, I'd put money on me overlooking some old bit of code.

kazade said:

Just so you know, I'm taking a look at an SDL/OpenGL port (developing on Ubuntu). I'll let you know how it goes...

P.S. Thank you for open sourcing it. Respect++;
Click to expand...

Nice. I'll try to keep away from using any more DirectX features to make it alittle bit less of a moving target. I can see the pointless shaders (HLSL) being annoying, they're really just there for fun.

Edit: Heh, got it. I was using my old bit of "offset" code, which worked by altering the axis of the scaling (seemed to work surprisingly well, even though it was obviously completely wrong), now I'm actually adding onto the block positions and it's fine.

SANiK · Jan 15, 2011

I would get rid of the shaders totally as well as smoothing and keep it pixel filled.

I would split the engine up into the following classes:

Code (Text):

//Sonic X-treme components

class sxValue //A growing linked list that takes an index an returns the string or value stored there

class sxHexDump //A linked list that contains raw byte data

class sxVariable

class sxPalette

class sxCamera

class sxPath

class sxTexture

class sxQubix

class sxCube

class sxActorType

class sxFilePcx //Loads a pcx file and returns a palette array and an index array

class sxFileDef //Loads a def file and creates the above classes in sxSystem. Remember multiple DEF files can be loaded and they merge variables and other settings.

class sxSystem //Keeps the merged DEF classes.

//Engine based components

class enCamera

class enInput

class enPoly      //Rendering 3D polygons with an enTexture

class enImage   //Software image manipulation code for generating some of the dynamic textures in X-treme.

class enTexture  //Abstraction layer to send texture to renderer

class enSprite    //Rendering on screen enTextures for UIs

class enBillboard  //Rendering 3D billboard sprites

class enMath     //Math function

class enSystem //Encompasses everything

Uhyve · Jan 15, 2011

SANiK said:

I would get rid of the shaders totally as well as smoothing and keep it pixel filled.

I would split the engine up into the following classes:

Code (Text):

//Sonic X-treme components

class sxValue //A growing linked list that takes an index an returns the string or value stored there

class sxHexDump //A linked list that contains raw byte data

class sxVariable

class sxPalette

class sxCamera

class sxPath

class sxTexture

class sxQubix

class sxCube

class sxActorType

class sxFilePcx //Loads a pcx file and returns a palette array and an index array

class sxFileDef //Loads a def file and creates the above classes in sxSystem. Remember multiple DEF files can be loaded and they merge variables and other settings.

class sxSystem //Keeps the merged DEF classes.

//Engine based components

class enCamera

class enInput

class enPoly      //Rendering 3D polygons with an enTexture

class enImage   //Software image manipulation code for generating some of the dynamic textures in X-treme.

class enTexture  //Abstraction layer to send texture to renderer

class enSprite    //Rendering on screen enTextures for UIs

class enBillboard  //Rendering 3D billboard sprites

class enMath     //Math function

class enSystem //Encompasses everything

Click to expand...

That seems like a good way of organizing stuff, I'm already getting to a point where moving around the huge classes is getting annoying. But yeah, I think I can manage that, my code is a bit messy but I don't think it'll be too hard to modularize. Plus, a general rearrangement of code will probably help me get rid of any old useless stuff. In fact, yeah, I don't think that'll be too difficult actually.

Yeah, I'm gonna need to get rid of the shaders, it was becoming a bit of a hassle keeping them in really. The bloom is pretty useless, and shader based lighting seems to be quite slow.

PS Heh, I like open source, it's been up for less than a month and I've already got a ton of useful help. If anyone hadn't guessed, I'm not a professional coder, I've got a degree and everything, but not a job yet, so I'm still super inexperienced in certain areas.

kazade · Jan 15, 2011

Uhyve said:

kazade said:

Just so you know, I'm taking a look at an SDL/OpenGL port (developing on Ubuntu). I'll let you know how it goes...

P.S. Thank you for open sourcing it. Respect++;
Click to expand...

Nice. I'll try to keep away from using any more DirectX features to make it alittle bit less of a moving target. I can see the pointless shaders (HLSL) being annoying, they're really just there for fun.
Click to expand...

The main problem I'm having is the use of D3DXVector, D3DXMatrix and D3DXPlane (and probably others I haven't go to yet) in public interfaces. Those make it difficult to port, but I understand there's not much you can do about that aside from using a different math library which will just make more work for you. Fortunately, I've written a GL math library that's similar to the D3DX stuff: http://blog.kazade.co.uk/p/kazmath.html

So the way I've started implementing stuff is by duplicating files (e.g. Camera.h -> CameraGL.h) and replacing things with my math library. I'm currently writing a library for sprites ( https://launchpad.net/kazsprite ), when I've done that I can move on. So far I've ported the window init code and the camera.

Uhyve · Jan 15, 2011

Oh yeah, it hadn't even occurred to me that the matrix math is using DirectX, that's a pain, it gets used quite a lot in the engine.

Does OpenGL have native support for any specific mesh types? Just wondering because the cubes that are used in the engine is an actual mesh file (.x file). That was more out of laziness though, I can make it create the mesh in memory at run time if need be.

The SX Engine

Useful Searches