texcommander.cpp

一个96K的3D游戏源码

#include "stdio.h"
#include "stdlib.h"
#include <string.h>
#include <stdarg.h>
#include <math.h>
#include <windows.h>
#include <conio.h>
#include "PapFilter.h"
#include "FillFilter.h"
#include "TexturGenerator.h"
#include "TexCommander.h"
#include "MainGui.h"
#include "..\GameDefines.h"

long GetTypeSize(long TCID)
{
	switch(TCID)
	{
	case TCID_XORMAP:return(sizeof(tTC_XORMAP));break;
	case TCID_TWIST:return(sizeof(tTC_TWIST));break;
	case TCID_TEXT:return(sizeof(tTC_TEXT));break;
	case TCID_BLUR:return(0);break;
	case TCID_MOVEMID:return(0);break;
	case TCID_FILLGEN:return(sizeof(tTC_FILLFILTER01));break;
	case TCID_FILLFILTER02:return(sizeof(tTC_FILLFILTER02));break;
	case TCID_MIXPICS:return(sizeof(tTC_MIXPICS));break;
	case TCID_MAKETILEABLE:return(sizeof(tTC_MAKETILEABLE));break;
	case TCID_TWIRL:return(sizeof(tTC_TWIRL));break;
	case TCID_TILE:return(0);break;
	case TCID_COLOR:return(sizeof(tTC_COLOR));break;
	case TCID_RANGECOLORS:return(sizeof(tTC_RANGECOLORS));break;
	case TCID_SOLIDFILL:return(sizeof(tTC_SOLIDFILL));break;
	case TCID_SPHERE:return(sizeof(tTC_SPHERE));break;
	}
}

tTexCommand *CreateTexCommand(long Type,void *Params)
{
	tTexCommand *Temp;
	long M;

	Temp=(tTexCommand*)malloc(sizeof(tTexCommand));
	Temp->Params=NULL;
	Temp->Type=Type;
	M=GetTypeSize(Type);
	if(M!=0)
	{
		Temp->Params=malloc(M);
		memcpy(Temp->Params,Params,M);
	}
	return(Temp);
}

void DestroyTexCommand(tTexCommand *Temp)
{
	if(Temp->Params!=NULL) free(Temp->Params);
	free(Temp);
}

void ReCalcLayer(tLayer *Layer)
{
	if(Layer->Command==NULL) return;
	switch(Layer->Command->Type)
	{
//	case TCID_XORMAP:CreateXORMap(Layer->Image,(tTC_XORMAP*)Layer->Command->Params);	break;
	case TCID_BLUR:Blur(Layer->Image);	break;
	case TCID_MOVEMID:MoveMid(Layer->Image);	break;
	case TCID_TWIST:Twist(Layer->Image,(tTC_TWIST*)Layer->Command->Params);	break;
	case TCID_TEXT:PapDraw(Layer->Image,(tTC_TEXT*)Layer->Command->Params);	break;

#ifndef SpeedUpTCMLoading
	case TCID_FILLGEN:FillbertFilter01(Layer->Image,(tTC_FILLFILTER01*)Layer->Command->Params);	break;
#else
	case TCID_FILLGEN:Blur(Layer->Image);	break;
#endif

	case TCID_FILLFILTER02:FillbertFilter02(Layer->Image,(tTC_FILLFILTER02*)Layer->Command->Params);	break;
#ifndef TCMMemoryLoading
/*
	case TCID_MIXPICS:
		LoadToLoadedImage(((tTC_MIXPICS*)(Layer->Command->Params))->FName);
		MixPics(Layer->Image,LoadedImage,(tTC_MIXPICS*)Layer->Command->Params);
		DoneWithLoadedImage();
		break;
*/
#endif
	case TCID_MAKETILEABLE:MakeTileAble(Layer->Image,(tTC_MAKETILEABLE*)Layer->Command->Params);	break;
	case TCID_TWIRL:Twirl(Layer->Image,(tTC_TWIRL*)Layer->Command->Params);	break;
	case TCID_TILE:Tile(Layer->Image);	break;
	case TCID_COLOR:Color(Layer->Image,(tTC_COLOR*)Layer->Command->Params);	break;
	case TCID_RANGECOLORS:RangeColors(Layer->Image,(tTC_RANGECOLORS*)Layer->Command->Params);	break;
	case TCID_SOLIDFILL:SolidFill(Layer->Image,(tTC_SOLIDFILL*)Layer->Command->Params);	break;
	case TCID_SPHERE:Sphere(Layer->Image,(tTC_SPHERE*)Layer->Command->Params);	break;
	}
}

void DestroyLayer(tLayer *Temp,bool WithSub)
{
	if(Temp==NULL) return;
	if(WithSub) DestroyLayer(Temp->Next,WithSub);

	if(Temp->Command!=NULL) DestroyTexCommand(Temp->Command);
	if(Temp->Image!=NULL) DestroyImage(Temp->Image);
	free(Temp);
}

tLayer *LoadLayer(t_File_Handle *F,tImage *OldImage)
{
	tLayer *Temp;
	tTC_TEXT *TP;
	long M;
	Temp=CreateLayer();
	Temp->Next=NULL;
	Temp->Image=CopyImage(OldImage);
	Temp->Command=(tTexCommand*)malloc(sizeof(tTexCommand));
	Temp->Command->Params=NULL;
	FileRead(F,&Temp->Command->Type,sizeof(char));
	M=GetTypeSize(Temp->Command->Type);
	if(M!=0)
	{
		Temp->Command->Params=malloc(M);
		if(Temp->Command->Type==TCID_TEXT)
		{
			TP=(tTC_TEXT*)Temp->Command->Params;
			FileRead(F,TP,7);
			FileRead(F,&TP->DaText,TP->Len);
			TP->DaText[TP->Len]=0;
		} else {
			FileRead(F,Temp->Command->Params,M);
		}
	}
	ReCalcLayer(Temp);
	return(Temp);
}

#ifdef TCMMemoryLoading

tLayer *LoadLayerFile(unsigned char *Addr)
{
	t_File_Handle *F,FMem;
	tLayer *Temp,*Layer;
	long I,M;

//		F=Load_File(fname);
		FMem.Pointer=Addr;
		FMem.Pos=0;
		F=&FMem;
		FileRead(F,&M,sizeof(long));

		for(I=0;I<M;I++)
		{
			if(I==0)
			{
				Layer=LoadLayer(F,BlankImage);
				Temp=Layer;
			} else {
				Temp->Next=LoadLayer(F,Temp->Image);
				Temp=Temp->Next;
			}
		}
//		Close_File(F);
	return(Layer);
}

void LoadToLoadedImage(unsigned char *P1)
{
/*
		char MyChar[12];
		char *P2;
		long I;

		P1=(char*) P1;
		P2=(char*) &MyChar;
		I=0;
		while((I<9)&&(*(P1+I)!='.'))
		{
			*(P2+I)=*(P1+I);
			I++;
		}
		*(MyChar+I)='.';I++;
		*(MyChar+I)='t';I++;
		*(MyChar+I)='c';I++;
		*(MyChar+I)='m';I++;
		*(MyChar+I)=0;
*/		
		TempLayer=LoadLayerFile(P1);
		LoadedImage=GetLayerAddr(TempLayer,CountLayers(TempLayer)-1)->Image;
}
#else
tLayer *LoadLayerFile(char *fname)
{
	t_File_Handle *F;
	tLayer *Temp,*Layer;
	long I,M;

		F=Load_File(fname);
		FileRead(F,&M,sizeof(long));

		for(I=0;I<M;I++)
		{
			if(I==0)
			{
				Layer=LoadLayer(F,BlankImage);
				Temp=Layer;
			} else {
				Temp->Next=LoadLayer(F,Temp->Image);
				Temp=Temp->Next;
			}
		}
		Close_File(F);
	return(Layer);
}

void LoadToLoadedImage(char *P1)
{

		char MyChar[20];
		char *P2;
		long I;

		P1=(char*) P1;
		P2=(char*) &MyChar;
		I=0;
		while((I<9)&&(*(P1+I)!='.'))
		{
			*(P2+I)=*(P1+I);
			I++;
		}
		*(MyChar+I)='.';I++;
		*(MyChar+I)='t';I++;
		*(MyChar+I)='c';I++;
		*(MyChar+I)='m';I++;
		*(MyChar+I)=0;
		
		TempLayer=LoadLayerFile((char*)&MyChar);
		LoadedImage=GetLayerAddr(TempLayer,CountLayers(TempLayer)-1)->Image;
}
#endif

void DoneWithLoadedImage()
{
	DestroyLayer(TempLayer,true);
}