TSH&R-PC

1 files changed, 494 insertions, 0 deletions

diff --git a/tools/CreateSetChunk/main.cpp b/tools/CreateSetChunk/main.cpp
new file mode 100644
index 0000000..62228a4
--- /dev/null
+++ b/tools/CreateSetChunk/main.cpp
@@ -0,0 +1,494 @@
+/*===========================================================================
+   File: main.cpp 
+
+   This tool turns a greyscale image into a raw look up table.
+
+   Copyright (c)  Radical Entertainment, Inc.  All rights reserved.
+
+===========================================================================*/
+
+#include <stdio.h>
+#include <assert.h>
+#include <toollib.hpp>
+#include <dospath.hpp>
+#include <tlFrameControllerChunk16.hpp>
+#include <tlAnimationChunk.hpp>
+#include <atenum.hpp>
+#include <chunkids.hpp>
+
+#include "Param.hpp"
+#include <tlSetChunk.hpp>
+
+Parameters* Param;
+char outFile[P3DMAXNAME];
+
+struct TextureData
+{
+    TextureData() :
+		m_TextureID( 0 ),
+		m_NumIDs( 0 ),
+		m_ShaderID( 0 ),
+		m_AnimationChunk( 0 ),
+		m_ControllerChunk( 0 ),
+//		m_MultiControllerChunk( 0 ),
+		m_pSetChunk( 0 ),
+		m_WritenOut( false ) {};
+    ~TextureData() { delete m_TextureID; } // Set chunk is deleted by the output chunk.
+    TLUID* m_TextureID;           // List of texture chunks to put into set chunk.
+    int m_NumIDs;                 // Number in list. If number is negative then just the animation/controller chunk are removed and multicontroller modified.
+    TLUID m_ShaderID;             // The shader this data is for.
+    TLUID m_AnimationChunk;       // Texture animation chunk to remove.
+    TLUID m_ControllerChunk;      // Texture frame controller chunk to remove.
+//	TLUID m_MultiControllerChunk; // MultiController to remove texture frame controller from.
+    tlSetChunk* m_pSetChunk;      // Set chunk which will be written to file.
+    bool m_WritenOut;             // Has the set chunk been written out?
+};
+
+static const int TEXTURE_COLLECTION_SIZE = 256;
+static TextureData* g_TextureCollection[ TEXTURE_COLLECTION_SIZE ];
+static int g_TextureCollectionCount = 0;
+
+int main(int argc, char* argv[])
+{
+	Param = new Parameters(argc,argv);
+    bool sameFile = false; // Have we switched to a new output file.
+
+	tlDataChunk::RegisterDefaultChunks();
+
+	tlFile* output = 0;
+
+    for( int i = 0; i < TEXTURE_COLLECTION_SIZE; ++i )
+    {
+        g_TextureCollection[ i ] = 0;
+    }
+
+	if( Param->Files.Count() < 1 )
+	{
+		printf( "Must specify at least one input file.\n" );
+		exit( -1 );
+	}
+    if( Param->ShaderName == 0 )
+    {
+        printf( "Must specify the name of the shader with texture animation.\n" );
+        exit( -1 );
+    }
+
+    bool wildCardShader = false;
+    int shaderNameLen = strlen( Param->ShaderName );
+    if( Param->ShaderName[ shaderNameLen - 1 ] == '*' )
+    {
+        wildCardShader = true;
+        --shaderNameLen;
+        Param->ShaderName[ shaderNameLen ] = '\0';
+    }
+
+	// for each file on the command-line, do the following:
+	for(int curFile = 0; curFile < Param->Files.Count(); curFile++) 
+	{
+		tlFile input(new tlFileByteStream(Param->Files[ curFile ], omREAD), tlFile::FROMFILE);
+		if(!input.IsOpen()) 
+		{
+			printf("Could not open %s\n", Param->Files[ curFile ]);
+			exit( -1 );
+		}
+        tlDataChunk* inChunk = new tlDataChunk( &input );
+
+		char outFileName[256];
+		if( output == 0 )
+		{
+			if( Param->OutputFile )
+			{
+				strcpy(outFileName, Param->OutputFile);
+			}
+			else
+			{
+				strcpy(outFileName, Param->Files[curFile]);
+				RemoveExtension(outFileName);
+				strcat(outFileName, ".p3d");
+			}
+			output = new tlFile(new tlFileByteStream(outFileName, omWRITE), tlFile::CHUNK32);
+			if( ( output == 0 ) || ( !output->IsOpen() ) )
+			{
+				printf("Could not open %s for writing\n", outFileName);
+				exit(-1);
+			}
+            sameFile = false;
+		}
+        for( int i = 0; i < g_TextureCollectionCount; ++i )
+        {
+            delete g_TextureCollection[ i ];
+            g_TextureCollection[ i ] = 0;
+        }
+
+        /*************************************************/
+        // First pass for input file, nose through the frame controllers.
+        // Go through all the sub-chunks of the input and look for shader name
+        //in heirarchy of texture frame controller.
+        int inChunkIndex;
+        for( inChunkIndex = 0; inChunkIndex < inChunk->SubChunkCount(); inChunkIndex++ )
+        {
+            tlDataChunk* sub = inChunk->GetSubChunk( inChunkIndex );
+            if( sub->ID() == Pure3D::Animation::FrameControllerData::FRAME_CONTROLLER )
+            {
+                // We have a frame controller...
+                tlFrameControllerChunk* controller = static_cast<tlFrameControllerChunk*>( sub );
+                if( controller->GetType() == Pure3DAnimationTypes::TEXTURE_TEX )
+                {
+                    // and it's a texture controller. So check the hierarchy name.
+                    bool foundShader = false;
+                    const char* heirName = controller->HierarchyName();
+                    if( wildCardShader )
+                    {
+                        foundShader = strncmp( heirName, Param->ShaderName, shaderNameLen ) == 0;
+                    }
+                    else
+                    {
+                        foundShader = strcmp( heirName, Param->ShaderName ) == 0;
+                    }
+                    if( foundShader )
+                    {
+                        // We found the shader so remember the texture animation data.
+                        TextureData* texData = new TextureData();
+                        if( texData == 0 )
+                        {
+                            printf( "Unable to allocate texture data.\n" );
+                            exit( -1 );
+                        }
+                        texData->m_ShaderID = tlEntity::MakeUID( heirName );
+                        texData->m_ControllerChunk = tlEntity::MakeUID( controller->GetName() );
+                        texData->m_AnimationChunk = tlEntity::MakeUID( controller->AnimationName() );
+                        // Look to see if we already have this shader.
+                        //If we do, we'll just erase the controller and animation and modify the multicontroller.
+                        //The first texData will be used to create the chunk set.
+                        for( int i = 0; i < g_TextureCollectionCount; ++i )
+                        {
+                            if( g_TextureCollection[ i ]->m_ShaderID == texData->m_ShaderID )
+                            {
+                                texData->m_NumIDs = -1;
+                                break;
+                            }
+                        }
+                        g_TextureCollection[ g_TextureCollectionCount ] = texData;
+                        ++g_TextureCollectionCount;
+                    }
+                }
+            }
+        }
+        /*************************************************/
+        // Second pass. Now we look for the animation to go with all those texture frame controllers
+        //we found.
+        for( inChunkIndex = 0; inChunkIndex < inChunk->SubChunkCount(); inChunkIndex++ )
+        {
+            tlDataChunk* sub = inChunk->GetSubChunk( inChunkIndex );
+			// Is this an animation?
+            if( sub->ID() != Pure3D::Animation::AnimationData::ANIMATION )
+            {
+				// No, not interested.
+                continue;
+            }
+            tlAnimationChunk* anim = static_cast<tlAnimationChunk*>( sub );
+			// Is it a texture animation?
+            if( anim->GetAnimationType() != Pure3DAnimationTypes::TEXTURE_TEX )
+            {
+				// No, not interested.
+                continue;
+            }
+            // We've found a texture animation. Check if it's one we are looking for.
+            TLUID animID = tlEntity::MakeUID( anim->GetName() );
+            for( int i = 0; i < g_TextureCollectionCount; ++i )
+            {
+                if( ( g_TextureCollection[ i ]->m_NumIDs == 0 ) && ( g_TextureCollection[ i ]->m_AnimationChunk == animID ) )
+                {
+                    // We've found the animation to match a frame controller. Let the mess begin.
+                    TextureData* texData = g_TextureCollection[ i ]; // just for convience.
+                    // Examine the sub chunks...there should be a goup list in there...
+                    for( int subChunkIndex = 0; subChunkIndex < anim->SubChunkCount(); ++subChunkIndex )
+                    {
+                        tlDataChunk* animSub = anim->GetSubChunk( subChunkIndex );
+                        if( animSub->ID() == Pure3D::Animation::AnimationData::GROUP_LIST )
+                        {
+                            // Found the group list. Now we'll nose around the groups...
+                            tlAnimationGroupListChunk* groupList = static_cast<tlAnimationGroupListChunk*>( animSub );
+                            for( int listChunkIndex = 0; listChunkIndex < groupList->SubChunkCount(); ++listChunkIndex )
+                            {
+                                // Look at all the channels in the groups in the group list.
+                                tlDataChunk* listSub = groupList->GetSubChunk( listChunkIndex );
+                                if( listSub->ID() == Pure3D::Animation::AnimationData::GROUP )
+                                {
+                                    tlAnimationGroupChunk* group = static_cast<tlAnimationGroupChunk*>( listSub );
+                                    for( int channelIndex = 0; channelIndex < (int)group->GetNumChannels(); ++channelIndex )
+                                    {
+                                        int i;
+                                        // In the group (whew), look at all the channels.
+										// Is it an entity channel?
+                                        tlDataChunk* channelSub = group->GetSubChunk( channelIndex );
+                                        if( channelSub->ID() != Pure3D::Animation::ChannelData::ENTITY )
+                                        {
+											// No, not interested.
+                                            continue;
+                                        }
+										// Is the entity channel a texture?
+                                        tlEntityChannelChunk* entityChannel = static_cast<tlEntityChannelChunk*>( channelSub );
+                                        if( entityChannel->Param() != Pure3DAnimationTypes::TEXTURE_TEX )
+                                        {
+											// No, not interested.
+                                            continue;
+                                        }
+                                        // Okay we have the entity channel for a texture animation, now we
+                                        //record the texture names.
+                                        // We might end up allocating extra space for textures, but we'll
+                                        //leave the UIDs at zero at the end of the array.
+                                        texData->m_TextureID = new TLUID[ entityChannel->GetNumFrames() ];
+                                        if( texData->m_TextureID == 0 )
+                                        {
+                                            printf( "Unable to allocate texture array.\n" );
+                                            exit( -1 );
+                                        }
+                                        for( i = 0; i < (int)entityChannel->GetNumFrames(); ++i )
+                                        {
+                                            texData->m_TextureID[ i ] = 0;
+                                        }
+                                        // Get all the frame values.
+                                        char** values = entityChannel->GetValues();
+                                        for( i = 0; i < (int)entityChannel->GetNumFrames(); ++i )
+                                        {
+                                            TLUID textureID = tlEntity::MakeUID( values[ i ] );
+                                            // We have the texture tUID, look if it's a duplicate.
+                                            bool textureDup = false;
+                                            for( int j = 0; j < texData->m_NumIDs; ++j )
+                                            {
+                                                if( texData->m_TextureID[ j ] == textureID )
+                                                {
+													// this one is a duplicate, skip it.
+                                                    textureDup = true;
+                                                    break;
+                                                }
+                                            }
+                                            if( !textureDup )
+                                            {
+                                                // It's not a duplicate so remember it.
+                                                texData->m_TextureID[ texData->m_NumIDs ] = textureID;
+                                                ++texData->m_NumIDs;
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        /*************************************************/
+        // Third pass, create the set chunks from the textures we got from those texture animations.
+        for( inChunkIndex = 0; inChunkIndex < inChunk->SubChunkCount(); inChunkIndex++ )
+        {
+            tlDataChunk* sub = inChunk->GetSubChunk( inChunkIndex );
+            if( sub->ID() == Pure3D::Texture::TEXTURE )
+            {
+                // We've found a texture, check to see if it's one of the textures we are looking for.
+                TextureData* texData = 0;
+                int textureIDIndex = 0;
+                TLUID textureID = tlEntity::MakeUID( sub->GetName() );
+                for( int i = 0; i < g_TextureCollectionCount; ++i )
+                {
+                    texData = g_TextureCollection[ i ];
+                    for( textureIDIndex = 0; textureIDIndex < texData->m_NumIDs; ++textureIDIndex )
+                    {
+                        if( textureID == texData->m_TextureID[ textureIDIndex ] )
+                        {
+                            if( texData->m_pSetChunk == 0 )
+                            {
+                                texData->m_pSetChunk = new tlSetChunk();
+                                if( texData->m_pSetChunk == 0 )
+                                {
+                                    printf( "Unable to create tlSetChunk.\n" );
+                                    exit( -1 );
+                                }
+                            }
+                            if( textureIDIndex == 0 )
+                            {
+                                // This is the first texture in the set so we'll use the name for
+                                //the set.
+                                texData->m_pSetChunk->SetName( sub->GetName() );
+                            }
+                            texData->m_pSetChunk->AppendSubChunk( sub, 0 );
+                            break;
+                        }
+                    }
+                }
+            }
+        }       
+
+        /*************************************************/
+        // Forth pass, process the file. Copy all the chunks over,
+        //except the texture frame controllers, texture animations,
+        //and textures we've used. Also, modify the multicontrollers
+		//to exclude the texture frame controllers.
+		tlDataChunk* outChunk = new tlDataChunk;
+
+        if( Param->WriteHistory && !sameFile )
+        {
+            // put a history chunk in the output
+            // a history chunk shows what version of the tool
+            // was run on the file with what command-line 
+            // parameters
+            outChunk->AppendSubChunk(Param->HistoryChunk());
+            sameFile = true;
+        }
+        
+        if( outChunk == 0 )
+        {
+            printf( "Unable to create output chunk.\n" );
+            exit( -1 );
+        }
+        for( inChunkIndex = 0; inChunkIndex < inChunk->SubChunkCount(); inChunkIndex++ )
+        {
+            tlDataChunk* sub = inChunk->GetSubChunk( inChunkIndex );
+            if( sub->ID() == Pure3D::Texture::TEXTURE )
+            {
+                bool inAnySet = false;
+                for( int i = 0; i < g_TextureCollectionCount; ++i )
+                {
+                    // Theorically a texture can go into multiple sets so go through them all.
+                    bool found = false;
+                    TextureData* texData = g_TextureCollection[ i ];
+                    for( int j = 0; j < texData->m_NumIDs; ++j )
+                    {
+                        // Look to see if this texture is in this set.
+                        if( tlEntity::MakeUID( sub->GetName() ) == texData->m_TextureID[ j ] )
+                        {
+                            found = true;
+                            inAnySet = true;
+                            break;
+                        }
+                    }
+                    if( found && ( texData->m_NumIDs > 0 ) )
+                    {
+                        // This texture has gone into this set chunk. We'll write the
+                        //set chunk out at this point so it's roughly in the same place in
+                        //file to protect against load order dependency problems.
+                        if( texData->m_WritenOut == false )
+                        {
+                            texData->m_pSetChunk->SetChildCount( texData->m_NumIDs );
+                            outChunk->AppendSubChunk( texData->m_pSetChunk );
+                            texData->m_WritenOut = true; // Only write it once.
+                        }
+                    }
+                }
+                if( !inAnySet )
+                {
+                    // This isn't a texture we're interested in so write it out.
+                    outChunk->AppendSubChunk( sub );
+                }
+            }
+            else if( sub->ID() == Pure3D::Animation::FrameControllerData::FRAME_CONTROLLER )
+            {
+				// This is a frame controller. If it's one we've used then don't include it.
+                bool found = false;
+                TLUID controllerID = tlEntity::MakeUID( sub->GetName() );
+                for( int i = 0; i < g_TextureCollectionCount; ++i )
+                {
+                    if( controllerID == g_TextureCollection[ i ]->m_ControllerChunk )
+                    {
+                        found = true;
+                        break;
+                    }
+                }
+                if( !found )
+                {
+                    outChunk->AppendSubChunk( sub );
+                }
+            }
+            else if( sub->ID() == Pure3D::Animation::AnimationData::ANIMATION )
+            {
+				// This is an animation. If it's one we've used then don't include it.
+                bool found = false;
+                TLUID animID = tlEntity::MakeUID( sub->GetName() );
+                for( int i = 0; i < g_TextureCollectionCount; ++i )
+                {
+                    if( animID == g_TextureCollection[ i ]->m_AnimationChunk )
+                    {
+                        found = true;
+                        break;
+                    }
+                }
+                if( !found )
+                {
+                    outChunk->AppendSubChunk( sub );
+                }
+            }
+			else if( sub->ID() == P3D_MULTI_CONTROLLER )
+			{
+				// This is a multicontroller. If a track references an framecontroller we
+				//used then exclude that track.
+				tlMultiControllerChunk16* multiCont = static_cast<tlMultiControllerChunk16*>( sub );
+				for( int subIndex = 0; subIndex < multiCont->SubChunkCount(); ++subIndex )
+				{
+					tlDataChunk* subChunk = multiCont->GetSubChunk( subIndex );
+					if( subChunk->ID() == P3D_MULTI_CONTROLLER_TRACKS )
+					{
+						tlMultiControllerTracksChunk16* tracks = static_cast<tlMultiControllerTracksChunk16*>( subChunk );
+						unsigned long numTracks = tracks->GetNumTracks();
+						tlMultiControllerTrackData* trackArray = tracks->GetTracks();
+						for( int i = 0; i < numTracks; ++i )
+						{
+							TLUID trackID = tlEntity::MakeUID( trackArray[ i ].name );
+							for( int j = 0; j < g_TextureCollectionCount; ++j )
+							{
+								if( trackID == g_TextureCollection[ j ]->m_ControllerChunk )
+								{
+									// Remove this track.
+									--numTracks;
+									tracks->SetNumTracks( numTracks );
+									multiCont->SetNumTracks( multiCont->GetNumTracks() - 1 );
+									if( i < numTracks )
+									{
+										trackArray[ i ] = trackArray[ numTracks ];
+										--i;
+									}
+								}
+							}
+						}
+					}
+					else if( subChunk->ID() == P3D_MULTI_CONTROLLER_TRACK )
+					{
+						tlMultiControllerTrackChunk16* track = static_cast<tlMultiControllerTrackChunk16*>( subChunk );
+						TLUID trackID = tlEntity::MakeUID( track->GetName() );
+						for( int i = 0; i < g_TextureCollectionCount; ++i )
+						{
+							if( trackID == g_TextureCollection[ i ]->m_ControllerChunk )
+							{
+								multiCont->RemoveSubChunk( subIndex );
+								multiCont->SetNumTracks( multiCont->GetNumTracks() - 1 );
+							}
+						}
+					}
+				}
+				outChunk->AppendSubChunk( sub );
+			}
+            else
+            {
+                outChunk->AppendSubChunk( sub );
+            }
+        }
+		outChunk->Write( output );
+		delete outChunk;
+		outChunk = 0;
+		if( Param->OutputFile == 0 )
+		{
+			// We have multiple output files so get rid of the
+			//the output file now.
+			delete output;
+			output = 0;
+		}
+        for( i = 0; i < g_TextureCollectionCount; ++i )
+        {
+            delete g_TextureCollection[ i ];
+            g_TextureCollection[ i ] = 0;
+        }
+	} // end of main for loop
+
+   delete Param;
+   return 0;
+}