Hey thanks for sharing my project. I'm learning C as I go but familiar with messing around in Unity. If anyone's trying early build its actually X to start/reset the game. Id say the gameplay is only %30 done, haven't started learning collision yet and its very hacky how I make him Surf + Gravity/Jumping without it. I was thinking a balance bar too but think that just confusing when moving around.
Should get the player textured map soon just having trouble figuring it out with the current tools for Jo engine. Also I added a NiGHTS style grading dice when your given your score and have a sprite animation of it spinning I'm going to add in, but right now its replacing every single TGA and not sure why.
I made a github and will update the iso there with my latest version. Im still new to coding so its extremely confusing because I get things to work after messing around a lot and don't want to touch them. But any help is welcome
https://github.com/VirtuaSkimmer/Virtua-Skimmer-Sega-Saturn-
This is roughly how the player will look. I think this is 64x64 but maybe 128x128 and need to be reduced. And need to get rid of more triangles. Its head is actually Sonic from Sonic R turned facing down and bending his hair
I got the model converter I promised you working at pretty much 70-80%, but I didn't have time to test it nor write a demo.
It seems to be ok, but since I didn't test it, I can't guarantee it.
IT'S ALSO REALLY QUICKLY CODED! I made it in like 2 hours and only did small tests, so it might not work properly.
I'm sharing it with you now, but I guess without a demo it might be a bit hard to use.
The file starts with a header portion of 36 bytes, then writes the texture data, then the polygon data.
I added the header and the code to know how I write to the binary file so that you know what to load.
You can use the image converter I posted elsewhere to know how to load the paletted textures.
The program also outputs a text file including all the PDATA, but no textures, so you can also play with that.
Please note that it only supports textures, so if you want to load a flat shaded polygon, you can use something such as a 8x1 texture with 1 color. I guess it would be a bit slower than using a real flat shaded quad, but I don't think I will have time to modify my code to allow it for now.
Code:
//HEADER
typedef struct
{
unsigned short TOTAL_MESH; //total amount of PDATA
short TOT_TEXT; //total amount of textures
unsigned int TEXT_SIZE; //to quickly load from disk, that's the size of the textures in bytes
unsigned int PDATA_SIZE; //to quickly load from disk, total size of pdata in bytes
vector3 Origin; //Origin point used to "center" the culling/collision data and your model's position. Should be 0,0,0 unless you have an offset
vector3 Length; //Lenght along the x,y z axis. Together with the origin, that gives you the bounding box for quick broad collision testing
} _MOD_DATA;
//TEXTURE DATA
unsigned short convert_to_4bpp(unsigned short a, unsigned short b){ return (((a&0xffff)<<4) | (b));}
void WRITES_TEXTURES(ofstream * binFile)
{
cout << "Writing the textures to binary file...\n\n";
unsigned short buf16;
for (short i=0; i<MODEL_DATA.TOT_TEXT; i++)
{
unsigned short w = swap_endian_ushort(pimg[i].width); //pimg == paletted image
unsigned short h = swap_endian_ushort(pimg[i].height);
binFile->write((char*)&w, sizeof(unsigned short));
binFile->write((char*)&h, sizeof(unsigned short));
binFile->write((char*)&MODEL_DATA.TEXT_SIZE, sizeof(int));
for (short ii=0; ii< (pimg[i].width * pimg[i].height);)
{
unsigned char buf = 0;
buf = (unsigned char) convert_to_4bpp(pimg[i].palette_id[ii], pimg[i].palette_id[ii+1]);
binFile->write((char*)&buf, sizeof(unsigned char));
ii+=2;
}
}
for (short i=0; i<MODEL_DATA.TOT_TEXT; i++)
{
for (unsigned int ii=0; ii<16; ii++)
{
buf16 = swap_endian_ushort(pimg[i].palette[ii]);
binFile->write((char*)(&buf16), sizeof(unsigned short));
}
}
}
//PDATA
/*****
This writes all the PDATA in a sequential order
*****/
void WRITE_PDATA(ofstream * file)
{
unsigned short bUint16;
unsigned int bUint32;
int bSint32;
for (unsigned int i=0; i<MODEL_DATA.TOTAL_MESH; i++)
{
//PDATA, including buffers for the pointers
bUint32 = 0;
file->write((char*)&bUint32, sizeof(unsigned int));
bUint32 = swap_endian_uint(mesh_array[i].nbPoint);
file->write((char*)&bUint32, sizeof(unsigned int));
bUint32 = 0;
file->write((char*)&bUint32, sizeof(unsigned int));
bUint32 = swap_endian_uint(mesh_array[i].nbPolygon);
file->write((char*)&bUint32, sizeof(unsigned int));
bUint32 = 0;
file->write((char*)&bUint32, sizeof(unsigned int));
//POINT (vertices), 12 bytes each
for (unsigned int ii=0; ii<mesh_array[i].nbPoint; ii++)
{
for (unsigned int j=0; j<3; j++)
{
bSint32 = swap_endian_sint(mesh_array[i].pntbl[ii][j]);
file->write((char*)&bSint32, sizeof(int));
}
}
//POLYGON, 12 bytes for normals and 8 bytes for vertices
for (unsigned int ii=0; ii<mesh_array[i].nbPolygon; ii++)
{
//Normals
for (unsigned int j=0; j<3; j++)
{
bSint32 = swap_endian_sint(mesh_array[i].pltbl[ii].norm[j]);
file->write((char*)&bSint32, sizeof(int));
}
//Vertices
for (unsigned int j=0; j<4; j++)
{
bUint16 = swap_endian_ushort(mesh_array[i].pltbl[ii].Vertices[j]);
file->write((char*)&bUint16, sizeof(unsigned short));
}
}
//ATTRIBUTES, 12 bytes each
for (unsigned int ii=0; ii<mesh_array[i].nbPolygon; ii++)
{
file->write((char*)&TextureAttributeArray[mesh_array[i].attbl[ii].texno].flag, sizeof(unsigned char));
file->write((char*)&TextureAttributeArray[mesh_array[i].attbl[ii].texno].sorting, sizeof(unsigned char));
bUint16=swap_endian_ushort(TextureAttributeArray[mesh_array[i].attbl[ii].texno].texno);
file->write((char*)&bUint16, sizeof(unsigned short));
bUint16=swap_endian_ushort(TextureAttributeArray[mesh_array[i].attbl[ii].texno].atrb);
file->write((char*)&bUint16, sizeof(unsigned short));
bUint16=swap_endian_ushort(TextureAttributeArray[mesh_array[i].attbl[ii].texno].colno);
file->write((char*)&bUint16, sizeof(unsigned short));
bUint16=swap_endian_ushort(TextureAttributeArray[mesh_array[i].attbl[ii].texno].gstb);
file->write((char*)&bUint16, sizeof(unsigned short));
bUint16=swap_endian_ushort(TextureAttributeArray[mesh_array[i].attbl[ii].texno].dir);
file->write((char*)&bUint16, sizeof(unsigned short));
}
}
}
So, you can use something such as GFS_LOAD starting with 36 bytes to know what the file contains, then read the textures (just put it in low-work RAM), DMA everything to VRAM where it belongs and then overwrite the data in low-work RAM with the PDATA (since the textures are transfered, you don't need them in work-RAM, so just overwrite them).
For the textures, make sure you do it per face instead of using texture coordinates.
The converter I wrote only supports 16 colors per texture, but save your TGA files as 32 bits files. The alpha channel is treated as transparent.
I'll see what I can do for the demo, but I'm a bit busy with work so I might not have time. Let me know if you encounter bugs!
I added the title map from Quake as a demo, but this tool isn't meant for maps since it doesn't do map partition nor does it hold data for culling!
Edit : Removed the file, use the one on the newer post instead.