1349 lines
43 KiB
C++
1349 lines
43 KiB
C++
// artchecker.cpp : Defines the entry point for the console application.
|
|
// options -strict -add -all
|
|
#pragma warning(disable:4786)
|
|
|
|
|
|
#include <iostream>
|
|
#include <cstring>
|
|
#include <iomanip>
|
|
//#include <mysql++>
|
|
#include "artobject.h"
|
|
#include "artlimits.h"
|
|
#include "badlist.hpp"
|
|
#include "outputbuffer.hpp"
|
|
#include <toollib.hpp>
|
|
#include <tlCollisionObjectChunk.hpp>
|
|
#include <tlMeshChunk.hpp>
|
|
#include <tlImageChunk.hpp>
|
|
#include <tlAnimationChunk.hpp>
|
|
#include <tlStatepropChunk.hpp>
|
|
#include "..\..\..\..\game\code\constants\srrchunks.h"
|
|
|
|
using namespace std;
|
|
|
|
void debugstring(char * message);
|
|
|
|
int texturelookup(const texture_data& texturedata, bool add, bool strict,bool showall,badlist& p_badtextures ,bool suppress);
|
|
int shaderlookup(shader_data* lp_shaderdata, bool add, bool strict,bool showall,badlist& badshaders,bool suppress);
|
|
//int artobjectlookup(art_object* lp_artobject, Query& query,bool add, bool strict,bool showall,bool suppress);
|
|
//int bvobjectlookup(bv_data* lp_bvobject,Query& query,bool add,bool strict,bool showall,bool suppress);
|
|
|
|
int main(int argc, char* argv[])
|
|
{
|
|
|
|
char* arguements [4];
|
|
char* filename;
|
|
bool strict =false;
|
|
bool add =false;
|
|
bool badart=false;
|
|
bool showall =false;
|
|
bool suppress =false;
|
|
bool shin=false;
|
|
char screenoutput [1000];
|
|
int i;
|
|
|
|
//lists to track bad textures and shaders.
|
|
badlist bad_textures;
|
|
badlist bad_shaders;
|
|
|
|
//list to track meshes using bad shaders and meshes over 500 polys
|
|
outputbuffer* p_mesh_ref=new outputbuffer;
|
|
outputbuffer* p_polycount=new outputbuffer;
|
|
|
|
|
|
tlDataChunk::RegisterDefaultChunks();
|
|
|
|
//processes arguements
|
|
|
|
//no options
|
|
if (argc ==1)
|
|
{
|
|
printf("usage:artchecker filename <strict> \n");
|
|
exit (1);
|
|
}
|
|
|
|
|
|
filename= argv[1];
|
|
debugstring(filename);
|
|
|
|
|
|
for (i=2;i<argc;i++)
|
|
{
|
|
arguements[i]=argv[i];
|
|
|
|
// user set strict
|
|
if (strcmp(arguements[i],"strict")== 0)
|
|
{
|
|
strict =true;
|
|
debugstring("strict option set");
|
|
break;
|
|
}
|
|
|
|
//user set add
|
|
|
|
else if (strcmp (arguements[i],"add")==0)
|
|
{
|
|
add=true;
|
|
debugstring("add option set");
|
|
break;
|
|
}
|
|
|
|
else if (strcmp (arguements[i],"sum")==0)
|
|
{
|
|
suppress =true;
|
|
break;
|
|
}
|
|
|
|
else if (strcmp (arguements[i],"all")==0)
|
|
{
|
|
showall =true;
|
|
break;
|
|
}
|
|
|
|
else if (strcmp (arguements[i],"shin")==0)
|
|
{
|
|
shin =true;
|
|
break;
|
|
}
|
|
//illegal option
|
|
else
|
|
{
|
|
printf("%s is an illegal option \n",arguements[i]);
|
|
exit (1);
|
|
}
|
|
|
|
|
|
} //end for
|
|
|
|
//have the pure3d file name
|
|
|
|
tlFile input(new tlFileByteStream(filename,omREAD), tlFile::FROMFILE);
|
|
if(!input.IsOpen())
|
|
{
|
|
printf("Could not open %s\n", filename);
|
|
exit(-6);
|
|
}
|
|
|
|
printf("Processing Filename: %s\n",filename);
|
|
|
|
//desend into the file and look at each object until no more objects left
|
|
|
|
// make a tlDataChunk from the file
|
|
// this is the wrapper chunk for the input
|
|
tlDataChunk* inchunk = new tlDataChunk(&input);
|
|
// we don't need the tlFile anymore
|
|
// this cleans up the tlFile object including the
|
|
// tlFileByteStream
|
|
//printf("Fucking CLose! \n");
|
|
input.Close();
|
|
|
|
//printf("Closing File proceeding.\n");
|
|
|
|
//lists to track memory stats for various components.
|
|
badlist texturestats(inchunk->SubChunkCount());
|
|
badlist animationstats(inchunk->SubChunkCount());
|
|
badlist meshstats(inchunk->SubChunkCount());
|
|
|
|
// build an output chunk
|
|
tlDataChunk* outchunk = new tlDataChunk;
|
|
int ch;
|
|
|
|
static int counter =0;
|
|
|
|
//connect to the DB
|
|
|
|
|
|
//setup artrb variables
|
|
bool dbconnect=false;
|
|
// char querybuffer [1000];
|
|
// Row row;
|
|
|
|
|
|
|
|
|
|
//creat connection and query
|
|
//Connection con (use_exceptions);
|
|
//Query query=con.query( );
|
|
//dbconnect=con.connect ("srr2test","radit","root","custom47");
|
|
/*
|
|
if (dbconnect == true)
|
|
{
|
|
printf("Connection to Artdb established proceeding.\n");
|
|
}
|
|
else
|
|
{
|
|
printf("Cant connection to art db \n");
|
|
exit (1);
|
|
}
|
|
*/
|
|
//printf("Counting chunks !\n");
|
|
|
|
// go through all the sub-chunks of the input and
|
|
// process the ones you care about
|
|
for(ch=0; ch < inchunk->SubChunkCount(); ch++)
|
|
{
|
|
//printf("Processing Chunks, #%d \n",ch);
|
|
// create the next sub-chunk
|
|
tlDataChunk* sub = inchunk->GetSubChunk(ch);
|
|
|
|
// look at the id of the subchunk to decide if we
|
|
// want to do something with it or not
|
|
switch(sub->ID())
|
|
{
|
|
|
|
|
|
case Pure3D::Texture::TEXTURE:
|
|
{
|
|
//temp variables
|
|
tlTexture* p_texture = new tlTexture ();
|
|
tlImage* p_image2d ;
|
|
texture_data mytexture;
|
|
unsigned int texturememsize =0;
|
|
|
|
//printf("texuture name: %s \n",p_texture->GetName());
|
|
|
|
int chunkcount1,chunkcount2;
|
|
|
|
for (chunkcount1 =0;chunkcount1<sub->SubChunkCount();chunkcount1++)
|
|
{
|
|
tlDataChunk* sub1=sub->GetSubChunk(chunkcount1);
|
|
|
|
switch(sub1->ID())
|
|
{
|
|
case Pure3D::Texture::IMAGE:
|
|
{
|
|
for (chunkcount2=0;chunkcount2<sub1->SubChunkCount();chunkcount2++)
|
|
{
|
|
tlDataChunk* sub2=sub1->GetSubChunk(chunkcount2);
|
|
switch (sub2->ID())
|
|
{
|
|
case Pure3D::Texture::IMAGE_DATA:
|
|
{
|
|
tlImageDataChunk* p_imagedatachunk = (tlImageDataChunk*) sub2;
|
|
texturememsize += p_imagedatachunk->GetImageDataSize();
|
|
//printf("%u bytes \n", p_imagedatachunk->GetImageDataSize());
|
|
}
|
|
}
|
|
}//end for
|
|
|
|
}//end case
|
|
}//end switch
|
|
|
|
}//end outer for loop.
|
|
|
|
|
|
|
|
|
|
p_texture->LoadFromChunk(sub);
|
|
|
|
//cout<<"Checking for "<<p_texture->GetName()<<" Texture ";
|
|
p_image2d = p_texture->GetImage(0);
|
|
|
|
//fill in texture struct.
|
|
strcpy(mytexture.name,p_texture->GetName());
|
|
mytexture.height=p_texture->GetHeight();
|
|
mytexture.width=p_texture->GetWidth();
|
|
mytexture.bpp=p_image2d->GetBpp();
|
|
mytexture.alpha=p_texture->GetAlphaDepth();
|
|
|
|
texturestats.add(p_texture->GetName(),1,texturememsize);
|
|
|
|
//texture check
|
|
if (texturelookup (mytexture,add,strict,showall,bad_textures,suppress) ) //
|
|
{
|
|
badart= true;
|
|
}
|
|
|
|
/*
|
|
cout<<"Height: "<<p_image2d->GetHeight();
|
|
cout<<"Width: "<<p_image2d->GetWidth();
|
|
cout<<"Bpp: "<<mytexture.bpp;
|
|
cout<<"Alpha: "<<mytexture.alpha;
|
|
cout<<endl;
|
|
*/
|
|
|
|
delete p_texture;
|
|
outchunk->AppendSubChunk(sub,FALSE);
|
|
break;
|
|
}
|
|
|
|
case Pure3D::Shader::SHADER:
|
|
{
|
|
|
|
shader_data myshader;
|
|
tlShader* p_shader =new tlShader ();
|
|
p_shader->LoadFromChunk(sub);
|
|
|
|
//get data for myshader
|
|
|
|
strcpy(myshader.name,p_shader->GetName());
|
|
myshader.lit=p_shader->GetIntParam("LIT");
|
|
myshader.twosid=p_shader->GetIntParam("2SID");
|
|
|
|
//cout<<"Checking for "<<myshader.name<<" Shader ";
|
|
|
|
|
|
if (p_shader->GetFloatParam("SHIN") > 0.0 )
|
|
{
|
|
if (shin)
|
|
{
|
|
printf("Shader: %s has shinyness %f greater than 0.0!!!\n",p_shader->GetName(),p_shader->GetFloatParam("SHIN"));
|
|
//printf("Shader: %s has shinyness %f greater than 0.0!!!, Setting it to 0.0\n",p_shader->GetName(),p_shader->GetFloatParam("SHIN"));
|
|
//p_shader->SetFloatParam("SHIN",0.0);
|
|
}
|
|
}
|
|
|
|
|
|
if( strcmp ("lambert",p_shader->GetShaderType() )==0)
|
|
{
|
|
printf(" =====> ERROR: %s is of type Lambert, SOMEONE is GETTING the BEATS ! \n",myshader.name);
|
|
badart=true;
|
|
}
|
|
|
|
if (p_shader->GetIntParam("2SID") == 0)
|
|
{
|
|
//printf("%-30s Shader: =====>Warning : Double Sided FLAG is 0!\n",p_shader->GetName());
|
|
//p_shader->SetIntParam("2SID",1);
|
|
//error=true;
|
|
}
|
|
|
|
if(shaderlookup(&myshader,add,strict,showall,bad_shaders,suppress))
|
|
{
|
|
badart=true;
|
|
}
|
|
|
|
tlDataChunk* p_chunk=p_shader->Chunk();
|
|
delete p_shader;
|
|
outchunk->AppendSubChunk(p_chunk);
|
|
break;
|
|
}
|
|
case SRR2::ChunkID::ENTITY_DSG:
|
|
{
|
|
tlDataChunk* p_temp = sub->GetSubChunk(0);
|
|
|
|
|
|
tlMeshChunk* p_mesh = (tlMeshChunk* ) p_temp;
|
|
tlPrimGroup* p_primgroup = new tlPrimGroup ();
|
|
unsigned int vertexmemsize =0;
|
|
p_primgroup->LoadFromChunk(p_mesh->GetSubChunk(0));
|
|
|
|
if( p_primgroup->GetTriangleCount() >MAX_POLYCOUNT)
|
|
{
|
|
if(p_primgroup->GetType() == PDDI_PRIM_TRIANGLES)
|
|
{
|
|
sprintf(screenoutput,"%-30s mesh => Polycount : %6d \n",p_mesh->GetName(),p_primgroup->GetTriangleCount());
|
|
}
|
|
|
|
if(p_primgroup->GetType() == PDDI_PRIM_TRISTRIP)
|
|
{
|
|
sprintf(screenoutput,"%-30s mesh => Polycount Tristriped: %6d \n",p_mesh->GetName(),p_primgroup->GetTriangleCount());
|
|
}
|
|
|
|
//cout<< p_primgroup->GetTriangleCount()<<endl;
|
|
//printf("%-30s mesh => Polycount: %6d \n",p_mesh->GetName(),p_primgroup->GetTriangleCount());
|
|
p_polycount->add(screenoutput);
|
|
}
|
|
|
|
if(p_primgroup->GetVertexType()==8209)
|
|
{
|
|
//printf("ERROR: %s mesh HAS NO CVB lighting INFO!\n",p_mesh->GetName());
|
|
sprintf(screenoutput,"%-30s =====>ERROR: Mesh has No CBV (Color by Vertex) Lighting INFO! ", p_mesh->GetName());
|
|
p_mesh_ref->add(screenoutput);
|
|
badart=true;
|
|
}
|
|
|
|
if (bad_shaders.inlist(p_primgroup->GetShader( ) ))
|
|
{
|
|
sprintf(screenoutput,"%-30s =====>ERROR: Referencing bad shader : %-30s", p_mesh->GetName(), p_primgroup->GetShader());
|
|
p_mesh_ref->add(screenoutput);
|
|
badart =true;
|
|
}
|
|
|
|
delete p_primgroup;
|
|
|
|
|
|
|
|
// memory checkfunctionality
|
|
int chunkcount1,chunkcount2;
|
|
|
|
for (chunkcount1 =0;chunkcount1<p_temp->SubChunkCount();chunkcount1++)
|
|
{
|
|
tlDataChunk* sub1=p_temp->GetSubChunk(chunkcount1);
|
|
|
|
switch(sub1->ID())
|
|
{
|
|
case Pure3D::Mesh::PRIMGROUP:
|
|
{
|
|
for (chunkcount2=0;chunkcount2<sub1->SubChunkCount();chunkcount2++)
|
|
{
|
|
tlDataChunk* sub2=sub1->GetSubChunk(chunkcount2);
|
|
switch (sub2->ID())
|
|
{
|
|
case Pure3D::Mesh::MEMORYIMAGEVERTEXLIST:
|
|
{
|
|
tlPrimGroupMemoryImageVertexChunk* p_vertexmemorychunk = (tlPrimGroupMemoryImageVertexChunk*) sub2;
|
|
vertexmemsize = p_vertexmemorychunk->GetMemoryImageVertexSize();
|
|
//printf("%u bytes \n", p_vertexmemorychunk->GetMemoryImageVertexSize());
|
|
}
|
|
}
|
|
}//end for
|
|
|
|
}//end case
|
|
}//end switch
|
|
|
|
}//end outer for loop.
|
|
|
|
|
|
meshstats.add(p_mesh->GetName(),1,vertexmemsize);
|
|
outchunk->AppendSubChunk(sub,FALSE);
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case Pure3D::Mesh::MESH:
|
|
{
|
|
counter++;
|
|
|
|
tlDataChunk* p_sub =NULL;
|
|
|
|
unsigned int i = 0;
|
|
p_sub = sub->GetSubChunk(i);
|
|
|
|
while (p_sub ->ID( ) == Pure3D::Mesh::PRIMGROUP )
|
|
{
|
|
tlMeshChunk* p_mesh = (tlMeshChunk* ) sub;
|
|
tlPrimGroup* p_primgroup = new tlPrimGroup ();
|
|
unsigned int vertexmemsize =0;
|
|
p_primgroup->LoadFromChunk(p_mesh->GetSubChunk(i));
|
|
|
|
if( p_primgroup->GetTriangleCount() >MAX_POLYCOUNT)
|
|
{
|
|
|
|
if(p_primgroup->GetType() == PDDI_PRIM_TRIANGLES)
|
|
{
|
|
sprintf(screenoutput,"%-30s mesh => Polycount : %6d \n",p_mesh->GetName(),p_primgroup->GetTriangleCount());
|
|
p_polycount->add(screenoutput);
|
|
}
|
|
|
|
if(p_primgroup->GetType() == PDDI_PRIM_TRISTRIP)
|
|
{
|
|
sprintf(screenoutput,"%-30s mesh => Polycount Tristriped: %6d \n",p_mesh->GetName(),p_primgroup->GetTriangleCount());
|
|
p_polycount->add(screenoutput);
|
|
}
|
|
}
|
|
|
|
if(p_primgroup->GetVertexType()==8209)
|
|
{
|
|
sprintf(screenoutput,"%-30s =====>ERROR: Mesh has No CBV (Color by Vertex) Lighting INFO! ", p_mesh->GetName());
|
|
p_mesh_ref->add(screenoutput);
|
|
badart=true;
|
|
}
|
|
|
|
//hack to make every 3rd shader be char swatch.
|
|
if (counter == 3)
|
|
{
|
|
counter =0;
|
|
p_primgroup->SetShader("char_swatch_m");
|
|
}
|
|
|
|
if (bad_shaders.inlist(p_primgroup->GetShader( ) ))
|
|
{
|
|
sprintf(screenoutput,"%-30s =====>ERROR: Referencing bad shader : %-30s", p_mesh->GetName(), p_primgroup->GetShader());
|
|
p_mesh_ref->add(screenoutput);
|
|
badart=true;
|
|
}
|
|
|
|
delete p_primgroup;
|
|
i++;
|
|
|
|
|
|
|
|
// memory checkfunctionality
|
|
int chunkcount1,chunkcount2;
|
|
|
|
for (chunkcount1 =0;chunkcount1<sub->SubChunkCount();chunkcount1++)
|
|
{
|
|
tlDataChunk* sub1=sub->GetSubChunk(chunkcount1);
|
|
|
|
switch(sub1->ID())
|
|
{
|
|
case Pure3D::Mesh::PRIMGROUP:
|
|
{
|
|
for (chunkcount2=0;chunkcount2<sub1->SubChunkCount();chunkcount2++)
|
|
{
|
|
tlDataChunk* sub2=sub1->GetSubChunk(chunkcount2);
|
|
switch (sub2->ID())
|
|
{
|
|
case Pure3D::Mesh::MEMORYIMAGEVERTEXLIST:
|
|
{
|
|
tlPrimGroupMemoryImageVertexChunk* p_vertexmemorychunk = (tlPrimGroupMemoryImageVertexChunk*) sub2;
|
|
vertexmemsize = p_vertexmemorychunk->GetMemoryImageVertexSize();
|
|
//printf("%u bytes \n", p_vertexmemorychunk->GetMemoryImageVertexSize());
|
|
}
|
|
}
|
|
}//end for
|
|
|
|
}//end case
|
|
}//end switch
|
|
|
|
}//end outer for loop.
|
|
|
|
|
|
meshstats.add(p_mesh->GetName(),1,vertexmemsize);
|
|
outchunk->AppendSubChunk(sub,FALSE);
|
|
p_sub = sub->GetSubChunk(i);
|
|
}//end while loop
|
|
break;
|
|
}
|
|
case Pure3D::Animation::AnimationData::ANIMATION:
|
|
{
|
|
|
|
unsigned int animationmemsize =0;
|
|
int chunkcount1;
|
|
|
|
for (chunkcount1 =0;chunkcount1<sub->SubChunkCount();chunkcount1++)
|
|
{
|
|
tlDataChunk* sub1=sub->GetSubChunk(chunkcount1);
|
|
|
|
switch(sub1->ID())
|
|
{
|
|
case Pure3D::Animation::AnimationData::SIZE:
|
|
{
|
|
|
|
tlAnimationSizeChunk* p_animationsizechunk = (tlAnimationSizeChunk*) sub1;
|
|
animationmemsize = p_animationsizechunk->GetPS2();
|
|
//printf("%u bytes \n", p_animationsizechunk->GetPS2());
|
|
|
|
}//end case
|
|
}//end switch
|
|
}//end outer for loop.
|
|
|
|
//printf("name: %s , %u bytes \n",sub->GetName(),animationmemsize);
|
|
animationstats.add(sub->GetName(),1,animationmemsize);
|
|
outchunk->AppendSubChunk(sub,FALSE);
|
|
break;
|
|
|
|
}
|
|
|
|
/*
|
|
case Simulation::Collision::OBJECT:
|
|
{
|
|
//temp local variables
|
|
|
|
tlCollisionObjectChunk* p_collisionobject= (tlCollisionObjectChunk*)sub;
|
|
bv_data bv_object;
|
|
char source_name[max_length];
|
|
char object_name1[max_length];
|
|
char object_name2[max_length];
|
|
|
|
|
|
//cout<<"Checking "<<p_collisionobject->GetName()<<" Collision Object "<< endl;
|
|
|
|
//get the name of collision object
|
|
strcpy(source_name,p_collisionobject->GetName());
|
|
//cout<<"Source name: "<<source_name<<endl;
|
|
|
|
//smash up string to remove the number appended by Maya
|
|
strcpy(object_name1,strtok(source_name,"_"));
|
|
strcpy(object_name2,strtok(NULL,"_"));
|
|
|
|
//reform string
|
|
strcat(object_name1,"_");
|
|
strcat(object_name1,object_name2);
|
|
|
|
|
|
//set default vaules
|
|
strcpy(bv_object.name,object_name1);
|
|
bv_object.classtype=0;
|
|
bv_object.physpropid=0;
|
|
|
|
//cout<<"New concated string: " <<object_name1<<endl;
|
|
|
|
|
|
if(bvobjectlookup(&bv_object,query,add,strict,showall))
|
|
{
|
|
badart=true;
|
|
}
|
|
|
|
//creating object attribute chunk
|
|
|
|
tlObjectAttributeChunk* p_otc =new tlObjectAttributeChunk ();
|
|
p_otc->SetClassType(bv_object.classtype);
|
|
p_otc->SetPhyPropID(bv_object.physpropid);
|
|
|
|
tlPhysWrapperChunk* p_physwrapper = new tlPhysWrapperChunk ();
|
|
p_physwrapper->SetName(p_collisionobject->GetName());
|
|
|
|
//append the chunks
|
|
//p_physwrapper->AppendSubChunk(p_otc);
|
|
//p_physwrapper->AppendSubChunk(sub, FALSE);
|
|
outchunk->AppendSubChunk(sub,FALSE);
|
|
break;
|
|
}
|
|
|
|
|
|
*/
|
|
case StateProp::STATEPROP:
|
|
{
|
|
printf("This File:%s contains a stateprop \n",filename);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
// this is not a chunk that we care about
|
|
// so simply copy it to the output wrapper chunk
|
|
// the optional parameter to AppendSubChunk
|
|
// indicates that we have merely copied a pointer
|
|
// so the destructor of outchunk should not
|
|
// destroy this sub-chunk as that duty will be
|
|
// taken care of by the destructor of inchunk
|
|
outchunk->AppendSubChunk(sub,FALSE);
|
|
break;
|
|
|
|
}
|
|
}//end switch
|
|
}//end for
|
|
|
|
//record objects stats faking art object
|
|
art_object target_object;
|
|
strcpy(target_object.name,"devil car");
|
|
|
|
target_object.art_properties.vertex_count= 453;
|
|
target_object.art_properties.poly_count=2345;
|
|
target_object.art_properties.animation_frames=25;
|
|
target_object.art_properties.bone_count=35;
|
|
target_object.art_properties.shader_count=14;
|
|
|
|
/*
|
|
if( artobjectlookup(&target_object,query,add,strict) )
|
|
{
|
|
cout<<"Art object:" <<target_object.name<< " has failed art check\n ";
|
|
//exit (1);
|
|
}
|
|
|
|
*/
|
|
//check for shaders and textures are
|
|
|
|
|
|
//all is good add physic proporties
|
|
|
|
shader_data hmm;
|
|
|
|
strcpy(hmm.name,"trunk");
|
|
hmm.lit=false;
|
|
/*
|
|
if (shaderlookup(&hmm,query,add,strict))
|
|
{
|
|
cout<<hmm.name<<"not in art db \n";
|
|
//exit (1);
|
|
}
|
|
*/
|
|
|
|
|
|
//}
|
|
//end of try
|
|
|
|
// catch (BadQuery er)
|
|
{
|
|
// cout<<"Error: " <<er.error<< endl;
|
|
// return 1;
|
|
}
|
|
|
|
if (badart)
|
|
{
|
|
printf("\n");
|
|
printf("\n");
|
|
|
|
printf("***** SUMMARY ******* \n");
|
|
fprintf(stdout,"ERROR: %-15s contains BAD ART and has FAILED Artchecker! \n",filename);
|
|
|
|
// cleanup the no-longer-needed wrapper chunks
|
|
|
|
printf("Total Memory size of Textures: %20u bytes in %9u textures \n",texturestats.getsize(),texturestats.getindexcount());
|
|
printf("Total Memory size of Animations: %20u bytes in %9u animations \n",animationstats.getsize(),animationstats.getindexcount());
|
|
printf("Total Memory size of Meshes: %20u bytes in %9u meshes \n",meshstats.getsize(),meshstats.getindexcount());
|
|
|
|
printf("***** END OF SUMMARY ******* \n");
|
|
printf("\n");
|
|
|
|
|
|
if(!suppress)
|
|
{
|
|
printf("\n");
|
|
printf("\n");
|
|
printf("***** Bad Meshes *******\n");
|
|
p_mesh_ref->print();
|
|
printf("\n");
|
|
printf("***** HIGH POLY Meshes *******\n");
|
|
p_polycount->print();
|
|
printf("\n");
|
|
}
|
|
if(showall)
|
|
{
|
|
printf("\n");
|
|
printf("***** Texture Breakdown *******\n");
|
|
texturestats.printverbose();
|
|
printf("\n");
|
|
printf("***** Animation Breakdown *******\n");
|
|
animationstats.printverbose();
|
|
printf("\n");
|
|
printf("***** Meshes Breakdown *******\n");
|
|
meshstats.printverbose();
|
|
printf("\n");
|
|
|
|
}
|
|
delete p_mesh_ref ;
|
|
delete p_polycount;
|
|
|
|
/*
|
|
// create the new output file
|
|
tlFile output(new tlFileByteStream(filename, omWRITE), tlFile::CHUNK32);
|
|
|
|
if(!output.IsOpen())
|
|
{
|
|
printf("Could not open %s for writing,unable to Save\n", filename);
|
|
exit(-1);
|
|
}
|
|
|
|
// get the output wrapper chunk to write its data out
|
|
// to the file
|
|
outchunk->Write(&output);
|
|
*/
|
|
|
|
delete inchunk;
|
|
delete outchunk;
|
|
return 1;
|
|
}
|
|
else
|
|
{
|
|
|
|
/*
|
|
// create the new output file
|
|
tlFile output(new tlFileByteStream(filename, omWRITE), tlFile::CHUNK32);
|
|
|
|
if(!output.IsOpen())
|
|
{
|
|
printf("Could not open %s for writing\n", filename);
|
|
exit(-1);
|
|
}
|
|
*/
|
|
// get the output wrapper chunk to write its data out
|
|
// to the file
|
|
// outchunk->Write(&output);
|
|
|
|
|
|
// cleanup the no-longer-needed wrapper chunks
|
|
delete inchunk;
|
|
delete outchunk;
|
|
delete p_mesh_ref;
|
|
delete p_polycount;
|
|
printf("\n");
|
|
printf("\n");
|
|
printf("\n");
|
|
|
|
printf("***** SUMMARY ******* \n");
|
|
printf("\n");
|
|
fprintf(stdout,"Filename:%-15s PASSED Artchecker. \n",filename);
|
|
printf("\n");
|
|
|
|
// cleanup the no-longer-needed wrapper chunks
|
|
|
|
printf("Total Memory size of Textures: %20u bytes in %9u textures \n",texturestats.getsize(),texturestats.getindexcount());
|
|
printf("Total Memory size of Animations: %20u bytes in %9u animations \n",animationstats.getsize(),animationstats.getindexcount());
|
|
printf("Total Memory size of Meshes: %20u bytes in %9u meshes \n",meshstats.getsize(),meshstats.getindexcount());
|
|
|
|
printf("***** END OF SUMMARY ******* \n");
|
|
|
|
if(showall)
|
|
{
|
|
printf("\n");
|
|
printf("***** Texture Breakdown *******\n");
|
|
texturestats.printverbose();
|
|
printf("\n");
|
|
printf("***** Animation Breakdown *******\n");
|
|
animationstats.printverbose();
|
|
printf("\n");
|
|
printf("***** Meshes Breakdown *******\n");
|
|
meshstats.printverbose();
|
|
printf("\n");
|
|
|
|
}
|
|
return 0;
|
|
}
|
|
} //end of main
|
|
|
|
|
|
//********************************************
|
|
// Function Bodies
|
|
//********************************************
|
|
|
|
//helper function to print error messages
|
|
void debugstring (char * message)
|
|
{
|
|
#ifdef DEBUG
|
|
cout<<message<<endl;
|
|
#endif
|
|
}
|
|
|
|
|
|
//helper funtion to check texutre return 0 if texture matches db ,1 if their is a mismatch or error
|
|
int texturelookup(const texture_data& texturedata, bool add, bool strict,bool showall,badlist& badtextures,bool suppress) //badlist* p_badtextures
|
|
{
|
|
bool error=false ;
|
|
//char querybuffer [1000];
|
|
char output [1000];
|
|
// Result::iterator sql_iterator;
|
|
// Row row;
|
|
outputbuffer texture_errors;
|
|
|
|
//sprintf(querybuffer, "SELECT * FROM textures WHERE name = '%s' ",texturedata.name);
|
|
//query<< querybuffer;
|
|
//Result myresult= query.store ( );
|
|
|
|
|
|
|
|
//cant find texture in the database
|
|
//if (myresult.size ( ) ==0 )
|
|
if (1)
|
|
{
|
|
|
|
if ( add == true)
|
|
{
|
|
//add object to the DB
|
|
cout<< "Adding:" << texturedata.name << " texture to the ArtDB \n";
|
|
|
|
//todo add stuff here
|
|
}
|
|
//texture not found in the the DB
|
|
|
|
if (strict)
|
|
{
|
|
//cout<<",Not Found !" <<endl;
|
|
sprintf(output," ERROR :%s texture not found in the ArtDB",texturedata.name);
|
|
texture_errors.add(output);
|
|
//cout<<"ERROR :"<<texturedata.name<< " texture not found in the ArtDB \n";
|
|
error = true;
|
|
}
|
|
|
|
//check texture attributes against the default limits
|
|
|
|
//check against art limits
|
|
if(texturedata.height>MAX_TEXTURE_SIZE)
|
|
{
|
|
error=true;
|
|
sprintf(output," ERROR : %u Height exceeds Max Texture SIZE OF %u",texturedata.height,MAX_TEXTURE_SIZE);
|
|
texture_errors.add(output);
|
|
// cout<<" =====>Warning "<<texturedata.name<<" : "<< texturedata.height << " Height exceeds Max Texture SIZE OF "<<MAX_TEXTURE_SIZE<<endl;
|
|
}
|
|
|
|
if(texturedata.width>MAX_TEXTURE_SIZE)
|
|
{
|
|
error=true;
|
|
sprintf(output," ERROR : %u Width exceeds Max Texture SIZE OF %u",texturedata.width,MAX_TEXTURE_SIZE);
|
|
texture_errors.add(output);
|
|
// cout<<" =====>Warning "<<texturedata.name<<": "<< texturedata.width << " Width exceeds Max Texture SIZE OF "<<MAX_TEXTURE_SIZE<<endl;
|
|
}
|
|
|
|
if(texturedata.bpp>MAX_BPP)
|
|
{
|
|
error=true;
|
|
sprintf(output," ERROR : %u BPP exceeds Max BPP SIZE OF %u",texturedata.bpp,MAX_BPP);
|
|
texture_errors.add(output);
|
|
//cout<<" =====>Warning "<<texturedata.name<<": "<< texturedata.bpp << " BPP exceeds Max BPP SIZE OF "<<MAX_BPP<<endl;
|
|
}
|
|
// cout<<" Warning :"<<texturedata.name<< " texture not found in the ArtDB \n";
|
|
|
|
}//end if in artdb block
|
|
|
|
//if(myresult.size()!=0)
|
|
if(0)
|
|
{
|
|
//cout <<",Found . " << endl;
|
|
|
|
/*
|
|
for (sql_iterator=myresult.begin ( ); sql_iterator!= myresult.end ( ); sql_iterator++)
|
|
{
|
|
|
|
row =*sql_iterator;
|
|
int height= row["height"];
|
|
int width=row["width"];
|
|
int bpp=row["bpp"];
|
|
int alpha=row["alphabits"];
|
|
|
|
|
|
//check texture height
|
|
if( texturedata.height > height)
|
|
{
|
|
if (strict)
|
|
{
|
|
error=true;
|
|
sprintf(output," ERROR :Texture height %u exceeds expected %u",texturedata.height,height);
|
|
texture_errors.add(output);
|
|
}
|
|
else
|
|
{
|
|
sprintf(output," Warning :Texture height %u exceeds expected %u",texturedata.height,height);
|
|
texture_errors.add(output);
|
|
}
|
|
}//end if
|
|
|
|
//check width
|
|
if( texturedata.width > width)
|
|
{
|
|
if (strict)
|
|
{
|
|
error=true;
|
|
sprintf(output," ERROR :Texture width %u exceeds expected %u",texturedata.width,width);
|
|
texture_errors.add(output);
|
|
}
|
|
else
|
|
{
|
|
sprintf(output," Warning :Texture width %u exceeds expected %u",texturedata.width,width);
|
|
texture_errors.add(output);
|
|
}
|
|
}//end if
|
|
|
|
//check bpp
|
|
if( texturedata.bpp > bpp)
|
|
{
|
|
if (strict)
|
|
{
|
|
error=true;
|
|
sprintf(output," ERROR :Texture BPP %u exceeds expected %u",texturedata.bpp,bpp);
|
|
texture_errors.add(output);
|
|
}
|
|
else
|
|
{
|
|
sprintf(output," Warning :Texture BPP %u exceeds expected %u",texturedata.bpp,bpp);
|
|
texture_errors.add(output);
|
|
}
|
|
}//end if
|
|
|
|
|
|
|
|
|
|
//just printing out the rows
|
|
//for (int j=0;j<row.size ( ); j++)
|
|
//{
|
|
// cout<< "[" << row[j] << "]" ;
|
|
//}
|
|
//cout<<endl;
|
|
|
|
}//end for iterator loop
|
|
|
|
*/
|
|
|
|
}//end if found in the Artdb block
|
|
|
|
|
|
|
|
|
|
if (error)
|
|
{
|
|
if(!suppress)
|
|
{
|
|
printf("\n");
|
|
printf("%s Texture:\n",texturedata.name);
|
|
texture_errors.print();
|
|
printf("\n");
|
|
}
|
|
badtextures.add(texturedata.name,1,0);
|
|
return 1;
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
}// end texture lookup
|
|
|
|
|
|
//helper funtion to check shader, returns 0 if shader matches db ,1 if their is a mismatch
|
|
int shaderlookup(shader_data* lp_shaderdata, bool add, bool strict,bool showall,badlist& badshaders,bool suppress)
|
|
{
|
|
|
|
bool error=false;
|
|
char querybuffer [1000];
|
|
char output [1000];
|
|
//Result::iterator sql_iterator;
|
|
//Row row;
|
|
outputbuffer shader_errors;
|
|
sprintf(querybuffer, "SELECT * FROM shaders WHERE name = '%s' ",lp_shaderdata->name);
|
|
//query<< querybuffer;
|
|
//Result myresult= query.store ( );
|
|
|
|
|
|
// if (myresult.size ( ) ==0 )
|
|
if (1)
|
|
{
|
|
|
|
if ( add == true)
|
|
{
|
|
//add object to the DB
|
|
printf("Adding: %s shader to the ArtDB \n",lp_shaderdata->name);
|
|
//todo add stuff here
|
|
}
|
|
|
|
if (strict)
|
|
{
|
|
sprintf(output," ERROR: %s Shader not found in the ArtDB",lp_shaderdata->name);
|
|
shader_errors.add(output);
|
|
}
|
|
|
|
//check for lit
|
|
if ( lp_shaderdata->lit)
|
|
{
|
|
shader_errors.add(" =====>ERROR : LIT shader FOUND!");
|
|
error = true;
|
|
|
|
if(badshaders.inlist(lp_shaderdata->name) ==0)
|
|
{
|
|
badshaders.add(lp_shaderdata->name,1,0);
|
|
}
|
|
}
|
|
/*
|
|
if ((lp_shaderdata->twosid) == 0)
|
|
{
|
|
shader_errors.add(" =====>Warning : Double Sided FLAG is 0!");
|
|
error=true;
|
|
}
|
|
|
|
*/
|
|
|
|
}//end if shader in artdb check
|
|
|
|
//cout << "Records Found: " << myresult.size() << endl ;
|
|
/*
|
|
|
|
for (sql_iterator=myresult.begin ( ); sql_iterator!= myresult.end ( ); sql_iterator++)
|
|
{
|
|
row =*sql_iterator;
|
|
|
|
//just printing out the rows
|
|
for (int j=0;j<row.size ( ); j++)
|
|
{
|
|
cout<< "[" << row[j] << "]" ;
|
|
}
|
|
cout<<endl;
|
|
}//end for iterator loop
|
|
*/
|
|
|
|
if (error)
|
|
{
|
|
if(!suppress)
|
|
{
|
|
|
|
printf("\n");
|
|
printf("%s shader : \n",lp_shaderdata->name);
|
|
shader_errors.print();
|
|
}
|
|
if(strict)
|
|
{
|
|
return 1;
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
}// end shader lookup
|
|
|
|
/*
|
|
|
|
|
|
//helper funtion to check object, returns 0 if shader matches db ,1 if their is a mismatch
|
|
int artobjectlookup(art_object* lp_artobject, Query& query,bool add, bool strict,bool showall,bool suppress)
|
|
{
|
|
|
|
char querybuffer [1000];
|
|
Result::iterator sql_iterator;
|
|
Row row;
|
|
unsigned int artpropid,shaderid;
|
|
bool error= false;
|
|
|
|
//setup a query to artdb ask if object is in Artdb
|
|
|
|
sprintf(querybuffer, "SELECT * FROM objects WHERE name = '%s' ",lp_artobject->name);
|
|
query<< querybuffer;
|
|
Result myresult= query.store ( );
|
|
//cout << "Records Found: " << myresult.size() << endl ;
|
|
|
|
//if result size is zero, object not found
|
|
//if ( myresult.size ( ) ==0 )
|
|
if(1)
|
|
{
|
|
if ( add == true)
|
|
{
|
|
//add object to the DB
|
|
cout<< "Adding:" << lp_artobject->name << " to the ArtDB \n";
|
|
//todo add stuff here
|
|
|
|
return 0;
|
|
}
|
|
//object not found in the the DB halt
|
|
else
|
|
{
|
|
if (strict)
|
|
{
|
|
printf("ERROR: %s object not found in the ArtDB, \n",lp_artobject->name);
|
|
error =true;
|
|
}
|
|
else
|
|
{
|
|
printf("Warning:%s object not found in the ArtDB \n",lp_artobject->name);
|
|
}
|
|
}
|
|
}//end if object in artdb check
|
|
|
|
|
|
for (sql_iterator=myresult.begin ( ); sql_iterator!= myresult.end ( ); sql_iterator++)
|
|
{
|
|
row =*sql_iterator;
|
|
artpropid = row["artpropid"];
|
|
shaderid = row["shaderid"];
|
|
//just printing out the rows
|
|
for (int j=0;j<row.size ( ); j++)
|
|
{
|
|
cout<< "[" << row[j] << "]" ;
|
|
}
|
|
cout<<endl;
|
|
}//end for iterator loop
|
|
|
|
|
|
//check check the art proporties if less than max vertices,etc then we ok
|
|
sprintf(querybuffer, "SELECT * FROM artprops WHERE id = '%i' ",artpropid);
|
|
query<< querybuffer;
|
|
myresult= query.store ( );
|
|
|
|
cout << "Records Found: " << myresult.size() << endl ;
|
|
//check if artprops in the ArtDB
|
|
//if ( myresult.size ( ) ==0 )
|
|
if(1)
|
|
{
|
|
if ( add == true)
|
|
{
|
|
//add object to the DB
|
|
cout<< "Adding:" <<lp_artobject->name << " art props to the ArtDB \n";
|
|
cout<< "Adding: Artprops to artdb \n";
|
|
return 0;
|
|
|
|
//todo add stuff here
|
|
}
|
|
|
|
//object not found in the the DB halt
|
|
else
|
|
{
|
|
if (strict)
|
|
{
|
|
cout<<"ERROR: "<<lp_artobject->name<< " Art properties not found in the ArtDB, Halting \n";
|
|
error=true;
|
|
}
|
|
else
|
|
{
|
|
cout<<"Warning: "<<lp_artobject->name<< " Art properties not found in the ArtDB, using default physic properties\n";
|
|
}//end else
|
|
}//end else
|
|
}//end if
|
|
|
|
for (sql_iterator=myresult.begin ( ); sql_iterator!= myresult.end ( ); sql_iterator++)
|
|
{
|
|
row =*sql_iterator;
|
|
|
|
unsigned int vertexcount,polycount,shadercount,bonecount,animationframes;
|
|
vertexcount=row["VertexCount"];
|
|
polycount=row["PolyCount"];
|
|
shadercount=row["ShaderCount"];
|
|
bonecount=row["BoneCount"];
|
|
animationframes=row["Animframes"];
|
|
|
|
if (strict)
|
|
{
|
|
if( lp_artobject->art_properties.vertex_count > vertexcount)
|
|
{
|
|
cout<<"ERROR:"<< lp_artobject->name<<" has exceeded " << row["VertexCount"]<<" Vertexcount, HALTING \n";
|
|
error =true;
|
|
}
|
|
|
|
if( lp_artobject->art_properties.poly_count > polycount)
|
|
{
|
|
cout<<"ERROR:"<< lp_artobject->name<<" has exceeded " << row["PolyCount"]<<" Polycount, HALTING \n";
|
|
error =true;
|
|
}
|
|
|
|
if( lp_artobject->art_properties.animation_frames > animationframes)
|
|
{
|
|
cout<<"ERROR:"<< lp_artobject->name<<" has exceeded " << row["AnimFrames"]<< " Animation frames, HALTING \n";
|
|
error =true;
|
|
}
|
|
|
|
if( lp_artobject->art_properties.bone_count > bonecount)
|
|
{
|
|
cout<<"ERROR:"<< lp_artobject->name<<" has exceeded " << row["BoneCount"]<<" Bonecount, HALTING \n";
|
|
error =true;
|
|
}
|
|
|
|
if( lp_artobject->art_properties.shader_count > shadercount)
|
|
{
|
|
cout<<"ERROR:"<< lp_artobject->name<<" has exceeded " << row["ShaderCount"]<<" Shadercount, HALTING\n";
|
|
error =true;
|
|
}
|
|
}//end if artprops check
|
|
else
|
|
{
|
|
if( lp_artobject->art_properties.vertex_count > vertexcount)
|
|
{
|
|
cout<<"Warning:"<< lp_artobject->name<<" has exceeded " << row["VertexCount"]<<" Vertexcount \n";
|
|
}
|
|
|
|
if( lp_artobject->art_properties.poly_count > polycount)
|
|
{
|
|
cout<<"Warning:"<< lp_artobject->name<<" has exceeded " << row["PolyCount"]<<" Polycount \n";
|
|
}
|
|
|
|
if( lp_artobject->art_properties.animation_frames > animationframes)
|
|
{
|
|
cout<<"Warning:"<< lp_artobject->name<<" has exceeded " << row["AnimFrames"]<< " Animation frames \n";
|
|
}
|
|
|
|
if( lp_artobject->art_properties.bone_count > bonecount)
|
|
{
|
|
cout<<"Warning:"<< lp_artobject->name<<" has exceeded " << row["BoneCount"]<<" Bonecount \n";
|
|
}
|
|
|
|
if( lp_artobject->art_properties.shader_count > shadercount)
|
|
{
|
|
cout<<"Warning:"<< lp_artobject->name<<" has exceeded " << row["ShaderCount"]<<" Shadercount \n";
|
|
}
|
|
}// end else artprops check
|
|
|
|
|
|
|
|
}//for loop end artobjectlookup
|
|
|
|
|
|
//printing art props
|
|
|
|
for (int j=0;j<row.size ( ); j++)
|
|
{
|
|
cout<< "[" << row[j] << "]" ;
|
|
}
|
|
|
|
|
|
printf("\n");
|
|
|
|
if (error)
|
|
{
|
|
return 1;
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
}//end artobject lookup
|
|
|
|
|
|
//*************************************************************************
|
|
// Check's if root of Bound Volume exists, if not then treats it as a strict object
|
|
|
|
int bvobjectlookup(bv_data* lp_bvobject,Query& query,bool add,bool strict,bool showall,bool suppress)
|
|
{
|
|
bool errors =false;
|
|
char querybuffer [1000];
|
|
char output[1000];
|
|
outputbuffer bv_errors;
|
|
Result::iterator sql_iterator;
|
|
Row row;
|
|
|
|
|
|
sprintf(querybuffer, "SELECT * FROM objects WHERE name = '%s' ",lp_bvobject->name);
|
|
query<< querybuffer;
|
|
Result myresult= query.store ( );
|
|
|
|
|
|
if (myresult.size ( ) ==0 )
|
|
{
|
|
if ( add == true)
|
|
{
|
|
//add object to the DB
|
|
//cout<< "Adding:" << lp_shaderdata->name << " shader to the ArtDB \n";
|
|
|
|
//todo add stuff here
|
|
}
|
|
//object not found in the the DB halt
|
|
else
|
|
{
|
|
if (strict)
|
|
{
|
|
sprintf(output,"ERROR: %s object not found in the ArtDB \n",lp_bvobject->name);
|
|
bv_errors.add(output);
|
|
//cout<<" ERROR:"<<lp_bvobject->name<< " object not found in the ArtDB \n";
|
|
//return 1;
|
|
errors =true;
|
|
}
|
|
else
|
|
{
|
|
errors =true;
|
|
sprintf(output,"Warning: %s object not found in the ArtDB , using defaults vaules for ObjectAttributeChunk \n",lp_bvobject->name);
|
|
bv_errors.add(output);
|
|
//cout<<" Warning:"<<lp_bvobject->name<< " bv object not found in the ArtDB, using defaults vaules for ObjectAttributeChunk \n";
|
|
lp_bvobject->physpropid=0;
|
|
lp_bvobject->classtype=2; // set to dsg_static_phys
|
|
}
|
|
|
|
}
|
|
|
|
}//end if object check in artdb check
|
|
|
|
// cout << "Records Found: " << myresult.size() << endl ;
|
|
|
|
for (sql_iterator=myresult.begin ( ); sql_iterator!= myresult.end ( ); sql_iterator++)
|
|
{
|
|
|
|
row =*sql_iterator;
|
|
lp_bvobject->classtype =2;
|
|
lp_bvobject->physpropid=row["physpropid"];
|
|
|
|
|
|
//just printing out the rows
|
|
for (int j=0;j<row.size ( ); j++)
|
|
{
|
|
cout<< "[" << row[j] << "]" ;
|
|
}
|
|
|
|
cout<<endl;
|
|
|
|
|
|
}//end for iterator loop
|
|
|
|
if (errors)
|
|
{
|
|
if(strict)
|
|
{
|
|
bv_errors.print();
|
|
return 1;
|
|
}
|
|
else
|
|
{
|
|
if(!suppress)
|
|
{
|
|
bv_errors.print ();
|
|
}
|
|
return 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
}// end of Bv object check
|
|
|
|
|
|
*/ |