📄 papfilter.cpp

📁 一个96K的3D游戏源码
💻 CPP
字号:
#include "stdio.h"
#include "stdlib.h"
#include <string.h>
#include <stdarg.h>
#include <math.h>
#include <windows.h>
#include <conio.h>

#include "TexturGenerator.h"
#include "PapFilter.h"
#include "..\vectors.h"

tFontItem FontItem[96];

float	ATanList[256*256];
float	AbList[256*256];

void ConvertToFontItem(long Nr,char *Data,long X)
{
	long I,K,M,C;
	tFontItem *Item=&FontItem[Nr];
	Item->Data=(char*)malloc(30*30*4);
	M=0;
	for(I=0;I<30;I++)
	{
		for(K=0;K<30;K++)
		{
			C=*(Data+(K*X+I)*4);
			*(Item->Data+(K*30+I)*4)=C;
			*(Item->Data+(K*30+I)*4+1)=C;
			*(Item->Data+(K*30+I)*4+2)=C;
			*(Item->Data+(K*30+I)*4+3)=255;
			if(C!=0) M=I;
		}
	}
	Item->X=M+1;
	if(M==0) M=3;
	Item->Y=30;
}

void PapDraw(tImage *Temp,tTC_TEXT *Param)
{
	long TPtr=0;
	long I,K,M,BB,X,Y,W,R,G,B,O,S,OS,E;
	unsigned char *Pic;
	X=Param->X;
	Y=Param->Y;
	R=Param->R;
	G=Param->G;
	B=Param->B;
	S=Param->Trans;
	OS=255-S;
	Pic=(unsigned char*)Temp->Data;
	for(TPtr=0;TPtr<Param->Len;TPtr++)
	{
		M=Param->DaText[TPtr]-32;
		for(K=0;K<FontItem[M].Y;K++)
		{
			for(I=0;I<FontItem[M].X;I++)
			{
				BB=*(FontItem[M].Data+((29-K)*30+I)*4);
				if(BB!=0)
				{
					W=(((Y+K)%256)*256+(X+I)%256)*4;
					O=*(Pic+W);	  E=(O*OS+R*S)/256; *(Pic+W)=E;
					O=*(Pic+W+1); E=(O*OS+G*S)/256;	*(Pic+W+1)=E;
					O=*(Pic+W+2); E=(O*OS+B*S)/256;	*(Pic+W+2)=E;
					O=*(Pic+W+3); E=(O*OS+255*S)/256;	*(Pic+W+3)=E;
				}
			}
		}
		X+=FontItem[M].X+2;
	}
}
/*
void CreateXORMap(tImage *Temp,tTC_XORMAP *Param)
{
	long I,K;
	char *Pic;
	float T;

	Pic=(char*) Temp->Data;
	for(K=0;K<Temp->YSize;K++)
	{
		for(I=0;I<Temp->XSize;I++)
		{
			T=((float)(I^K))/255.0;
			*(Pic+(K*Temp->XSize+I)*4)=((float)Param->R)*T;
			*(Pic+(K*Temp->XSize+I)*4+1)=((float)Param->G)*T;
			*(Pic+(K*Temp->XSize+I)*4+2)=((float)Param->B)*T;
			*(Pic+(K*Temp->XSize+I)*4+3)=((float)Param->A)*T;
		}
	}
};
*/
void Blur(tImage *Temp)
{
	tImage *Old;

	Old=CopyImage(Temp);
	
	__asm
	{
		xor		ecx,ecx
ChannelLoop:
		push	ecx
		
		xor		ebx,ebx
		mov		edi,[ebp+8]
		mov		edi,[edi+8]
		mov		esi,Old
		mov		esi,[esi+8]

		add		esi,ecx
		add		edi,ecx
		mov		ecx,65536

BlurLoop:
			dec		ecx

			xor		eax,eax
			mov		dh,255
YLoop:
			mov		dl,255
XLoop:
			cmp		dx,0
			je		DontUse
			xor		ebx,ebx
			mov		bx,cx
			add		bl,dl
			add		bh,dh
			mov		bl,[esi+ebx*4]
			xor		bh,bh
			add		eax,ebx
DontUse:
			inc		dl
			cmp		dl,2
			jne		XLoop

			inc		dh
			cmp		dh,2
			jne		YLoop

			shr		eax,3
			mov		[edi+ecx*4],al

			or		ecx,ecx
		jnz		BlurLoop

		pop		ecx
		inc		ecx
		cmp		ecx,4
		jne		ChannelLoop
	}
/*
	Pic1=(unsigned char*)Temp->Data;
	Pic2=(unsigned char*)Old->Data;
	
	XS=Temp->XSize;
	YS=Temp->YSize;
	Zeile=XS*4;
	Spalte=4;

	for(K=0;K<YS;K++)
	{
		for(I=0;I<XS;I++)
		{
			for(C=0;C<4;C++)
			{
				F=0;
				for(Y=-1;Y<2;Y++)
				{
					X=0;
					for(X=-1;X<2;X++)
					{
						M=(((K+Y+YS)%YS)*XS+(I+X+XS)%XS)*4+C;
						F=F+(*(Pic2+M));
					}
				}
				F=F/9;
				if(F<0)F=0;
				if(F>255) F=255;
				M=(K*XS+I)*4+C;
				*(Pic1+M)=F;
			}
		}
	}

*/
	DestroyImage(Old);
}

float MyArcTan(float X,float Y)
{
	float Wink;
	
	if(X!=0)
	{ Wink=atan(Y/X); } else 
	{ if(Y<0) { Wink=3*Pi/2.0; } else { Wink=Pi/2.0;} };

	if((X<0)&&(Y>0)) Wink+=Pi;
	if((X<0)&&(Y<=0)) Wink+=Pi;
	if((X>0)&&(Y<=0)) Wink+=2*Pi;
	return(Wink);
}

void Twist(tImage *Temp,tTC_TWIST *Param)
{
	tImage *Old;
	long XS,YS,I,K,C,M,Zeile,Spalte,X,Y,XM,YM,W;
	char *Pic1,*Pic2;
	float Wink,Ab,XR,YR,ParWink;

	Old=CopyImage(Temp);

	ParWink=((float)Param->Wink)*0.0001;
	Pic1=(char*)Temp->Data;
	Pic2=(char*)Old->Data;
	
	XS=Temp->XSize;
	YS=Temp->YSize;
	Zeile=XS*4;
	Spalte=4;

	XM=XS/2;
	YM=YS/2;

	for(K=0;K<YS;K++)
	{
		for(I=0;I<XS;I++)
		{
			Wink=ATanList[K*256+I];
			Ab=AbList[K*256+I];

			Wink+=Ab*ParWink;

			XR=XM+cos(Wink)*Ab;
			YR=YM+sin(Wink)*Ab;
			X=((long)XR+XS)%XS;
			Y=((long)YR+YS)%YS;
			W=(Y*XS+X)*4;
			M=(K*XS+I)*4;
			for(C=0;C<4;C++)
			{
				*(Pic1+(M+C))=*(Pic2+(W+C));
			}
		}
	}


	DestroyImage(Old);
}

void Twirl(tImage *Temp,tTC_TWIRL *Param)
{
	tImage *Old;
	long K,W;
	long *Pic1,*Pic2;
	float Wink,Ab,ParWink,Wert;

	Old=CopyImage(Temp);


	ParWink=((float)Param->Wink)*0.0174*0.3;
	Pic1=(long*)Temp->Data;
	Pic2=(long*)Old->Data;

	for(K=0;K<65536;K++)
	{
		Ab=AbList[K];
		Wert=Ab/128.0;
		Wink=ATanList[K];
		if(Wert<1)
			Wink+=sin(Wert*3.14159)*ParWink;

		W=((long)(sin(Wink)*Ab)*256+(long)(cos(Wink)*Ab))+(128*256+128);

		*(Pic1+K)=*(Pic2+W);
	}
/**/

	DestroyImage(Old);
}
/*

void MixPics(tImage *Temp,tImage *Temp2,tTC_MIXPICS *Param)
{
	long X,Y,M,C,W;
	unsigned char *Pic1;
	unsigned char *Pic2;
	
	Pic1=(unsigned char*)Temp->Data;
	Pic2=(unsigned char*)Temp2->Data;

	for(Y=0;Y<Temp->YSize;Y++)
	{
		for(X=0;X<Temp->XSize;X++)
		{
			M=(Y*Temp->XSize+X)*4;
			for(C=0;C<4;C++)
			{
				if(C==0) W=Param->R;
				if(C==1) W=Param->G;
				if(C==2) W=Param->B;
				if(C==3) W=Param->A;
				*(Pic1+M)=(long)(*(Pic2+M))*W/255+(long)(*(Pic1+M))*(255-W)/255;

				M++;

			}
		}
	}
}
*/
void MakeTileAble(tImage *Temp,tTC_MAKETILEABLE *Params)
{
	long I,K,X,Y,XMid,YMid,XAb,YAb,Channel,PX,PY,PO;
	float MixX,MixY,CX,CY,CO;
	tImage *Img;
	unsigned char *Pic1;
	unsigned char *Pic2;

	Img=CopyImage(Temp);

	Pic1=(unsigned char*)Temp->Data;
	Pic2=(unsigned char*)Img->Data;

	XMid=Temp->XSize/2;
	YMid=Temp->YSize/2;

	for(K=0;K<Temp->YSize;K++)
	{
		for(I=0;I<Temp->XSize;I++)
		{
			X=(I+128)%256;
			Y=(K+128)%256;
			XAb=128-X;
			YAb=128-Y;

			MixX=1.0-fabs(XAb)/(float)Params->Amount;
			fRange(&MixX);
			MixY=1.0-fabs(YAb)/(float)Params->Amount;
			fRange(&MixY);

			MixX=sin(MixX*3.14159/2.0);
			MixY=sin(MixY*3.14159/2.0);
			MixX=MixX/2.0;
			MixY=MixY/2.0;

			PX=(K*256+ (I-1+XAb*2+512)%256)*4;
			PY=(((K-1+YAb*2+512)%256)*256+ I)*4;
			PO=(K*256+I)*4;

		  for(Channel=0;Channel<4;Channel++)
		  {
			CX=*(Pic2+ (PX+Channel));
			CY=*(Pic2+ (PY+Channel));
			CO=*(Pic2 + (PO+Channel));

			*(Pic1 + (PO+Channel))= 
				(CO*(1.0-MixX)+CX*MixX+CO*(1.0-MixY)+CY*MixY)/2.0;
		  }
		}
	}

	DestroyImage(Img);
}
/*
void MakeTileAble(tImage *Temp,tTC_MAKETILEABLE *Params)
{
	long I,K,M,X,Y,XMid,YMid,XAb,YAb,Channel;
	float Ab,MixX,MixY,CX,CY,CO;
	tImage *Img;
	unsigned char *Pic1;
	unsigned char *Pic2;

	Img=CopyImage(Temp);

	Pic1=(unsigned char*)Temp->Data;
	Pic2=(unsigned char*)Img->Data;

	XMid=Temp->XSize/2;
	YMid=Temp->YSize/2;

	for(K=0;K<Temp->YSize;K++)
	{
		for(I=0;I<Temp->XSize;I++)
		{
		  for(Channel=0;Channel<4;Channel++)
		  {
			X=(I+128)%256;
			Y=(K+128)%256;
			XAb=128-X;
			YAb=128-Y;

			MixX=1.0-fabs(XAb)/(float)Params->Amount;
			if(MixX<0) MixX=0;
			if(MixX>1) MixX=1;
			MixY=1.0-fabs(YAb)/(float)Params->Amount;
			if(MixY<0) MixY=0;
			if(MixY>1) MixY=1;

			MixX=sin(MixX*3.14159/2.0);
			MixY=sin(MixY*3.14159/2.0);

			CX=*(Pic2+ ((K*Temp->XSize+ (I-1+XAb*2+2*Temp->XSize)%Temp->XSize)*4+Channel));
			CY=*(Pic2+ ((((K-1+YAb*2+2*Temp->YSize)%(Temp->YSize))*Temp->XSize+ I)*4+Channel));
			CO=*(Pic2 + ((K*Temp->XSize+I)*4+Channel));

			MixX=MixX/2.0;
			MixY=MixY/2.0;

			*(Pic1 + ((K*Temp->XSize+I)*4+Channel))= 
				(CO*(1.0-MixX)+CX*MixX+CO*(1.0-MixY)+CY*MixY)/2.0;
		  }
		}
	}

	DestroyImage(Img);
}
*/

void Tile(tImage *Temp)
{
/*
	long I,K,M,Channel;
	unsigned char *Pic1;
	unsigned char *Pic2;
*/
	tImage *Img;

	Img=CopyImage(Temp);
	__asm
	{
		mov		edi,[ebp+8]
		mov		edi,[edi+8]

		mov		esi,Img
		mov		esi,[esi+8]

		mov		ecx,65536
PixelLoop:
		dec		ecx

		mov		ebx,ecx
		shl		bl,1
		shl		bh,1
		mov		eax,[esi+ebx*4]
		mov		[edi+ecx*4],eax

		or		ecx,ecx
		jnz		PixelLoop
	}
/*
	Pic1=(unsigned char*)Temp->Data;
	Pic2=(unsigned char*)Img->Data;

	for(K=0;K<Temp->YSize;K++)
	{
		for(I=0;I<Temp->XSize;I++)
		{
		  for(Channel=0;Channel<4;Channel++)
		  {
			  *(Pic1+((K*Temp->XSize+I)*4+Channel)) =
				  *(Pic2+((((K*2)%Temp->YSize)*Temp->XSize+(I*2)%Temp->XSize)*4+Channel));

		  }
		}
	}
*/
	DestroyImage(Img);
}

void Color(tImage *Temp,tTC_COLOR *Params)
{

	__asm
	{
		mov		esi,[ebp+12]

	
		mov		edi,[ebp+8]
		mov		edx,[edi]
		imul	edx,[edi+4]
		mov		edi,[edi+8]
PixelLoop:
			push	edx
			xor		ebx,ebx
			xor		edx,edx
			xor		eax,eax
			xor		ecx,ecx
ChannelLoop:
				mov		bl,[esi+4]
				cmp		bl,4
				je		DoChannel
				cmp		cl,bl
				jne		NextChannel
DoChannel:						
				mov		bl,[edi+ecx]
				add		eax,ebx
				inc		edx
NextChannel:
				inc		ecx
				cmp		ecx,4
			jne		ChannelLoop

			cmp		edx,4
			jne		NoDiv
			shr		eax,2
NoDiv:
			mov		bl,[esi+5]
			imul	eax,ebx
			shr		eax,7
			cmp		eax,255
			jle		NoAdjust
			mov		eax,255
NoAdjust:

			xor		edx,edx
DrawLoop:
				xor		ebx,ebx
				mov		bl,[esi+edx]
				imul	ebx,eax
				shr		ebx,8
				mov		[edi],bl

				inc		edi
				inc		edx
				cmp		edx,4
			jne		DrawLoop
		

			pop		edx
			dec		edx
		jnz		PixelLoop

	}
/**/
/*
	long I,K,M,Channel,CA,CW,C;
	unsigned char *Pic1;

	Pic1=(unsigned char*)Temp->Data;

	for(K=0;K<Temp->YSize;K++)
	{
		for(I=0;I<Temp->XSize;I++)
		{
			CW=0;
			CA=0;
			M=(K*Temp->XSize+I)*4;
			for(Channel=0;Channel<4;Channel++)
			{
				if((Params->Channel==4)||(Params->Channel==Channel))
				{
					CW+=*(Pic1+(M+Channel));
					CA++;
				}
			}
			CW=CW/CA;
			CW=(CW*Params->Gamma)/128;
			if(CW>255)CW=255;
			*(Pic1+(M))=(long)(CW*Params->R)/255;
			*(Pic1+(M+1))=(long)(CW*Params->G)/255;
			*(Pic1+(M+2))=(long)(CW*Params->B)/255;
			*(Pic1+(M+3))=(long)(CW*Params->A)/255;
		}
	}
/**/
}

void MoveMid(tImage *Temp)
{
	long I,K,Channel;
	tImage *Img;
	unsigned char *Pic1;
	unsigned char *Pic2;

	Img=CopyImage(Temp);

	Pic1=(unsigned char*)Temp->Data;
	Pic2=(unsigned char*)Img->Data;

	for(K=0;K<Temp->YSize;K++)
	{
		for(I=0;I<Temp->XSize;I++)
		{
		  for(Channel=0;Channel<4;Channel++)
		  {
			  *(Pic1+((K*Temp->XSize+I)*4+Channel)) =
				  *(Pic2+((((K+Temp->YSize/2)%Temp->YSize)*Temp->XSize+(I+Temp->XSize/2)%Temp->XSize)*4+Channel));

		  }
		}
	}

	DestroyImage(Img);
}

void RangeColors(tImage *Temp,tTC_RANGECOLORS *Params)
{
	long K,M,Channel,C,LowRange,UpRange,MinValue,MaxValue;
	unsigned char *Pic1;

	Pic1=(unsigned char*)Temp->Data;

	MinValue=(long)Params->MinValue*(long)Params->MidValue/(long)255;
	MaxValue=(long)Params->MaxValue*(long)(255-Params->MidValue)/(long)255+(long)Params->MidValue;
	LowRange=(long)Params->MidValue-(long)MinValue;
	UpRange=(long)MaxValue-(long)Params->MidValue;

	for(K=0;K<Temp->YSize*Temp->XSize;K++)
	{
		M=K*4;
		for(Channel=0;Channel<4;Channel++)
		{
			if((Params->Channel==4)||(Params->Channel==Channel))
			{
				C=*(Pic1+(M+Channel));
				if(C<Params->MidValue)
				{ C=C*LowRange/(long)Params->MidValue +MinValue;}
				else
				{ C=(long)(C-Params->MidValue)*UpRange/(long)(255-Params->MidValue) +Params->MidValue;}

				*(Pic1+(M+Channel))=C;
			}
		}
	}
}

void SolidFill(tImage *Temp,tTC_SOLIDFILL *Params)
{
	__asm
	{
		mov		esi,[ebp+12]
		mov		bl,[esi]

		xor		ecx,ecx
ChannelLoop:
		mov		al,[esi+1]
		cmp		al,4
		je		DoChannel
		cmp		al,cl
		jne		NextChannel
DoChannel:
		
			mov		edi,[ebp+8]
			mov		edx,[edi]
			imul	edx,[edi+4]
			mov		edi,[edi+8]
			add		edi,ecx

  PixelLoop:
			mov		byte ptr [edi],bl

			add		edi,4
			dec		edx
			jnz		PixelLoop

NextChannel:
		inc		ecx
		cmp		ecx,4
		jne		ChannelLoop
	}
/**/
/*
	long I,K,M,Channel;
	unsigned char *Pic1;

	Pic1=(unsigned char*)Temp->Data;

	for(I=0;I<Temp->XSize*Temp->YSize;I++)
	{
		for(Channel=0;Channel<4;Channel++)
		{
			if((Params->Channel==4)||(Params->Channel==Channel))
			{
				*(Pic1+(I*4+Channel))=Params->Value;
			}
		}
	}
/**/
}

void Sphere(tImage *Temp,tTC_SPHERE *Params)
{
	long I,K,C,X,Y,Channel;
	unsigned char *Pic1;
	float Abstand,Size,Pos;

	Size=Temp->XSize/2;
	Pic1=(unsigned char*)Temp->Data;
	for(K=0;K<Temp->YSize;K++)
	{
		for(I=0;I<Temp->XSize;I++)
		{
			X=I-Temp->XSize/2;
			Y=K-Temp->YSize/2;
			Abstand=sqrt(X*X+Y*Y);
			if(Abstand<Size)
			{
				Pos=1.0-Abstand/(float)Size;
				if(Params->Type==0)
					C=Pos*((long)Params->MaxValue-(long)Params->MinValue)+(long)Params->MinValue;
				if(Params->Type==1)
					C=sin(Pos*3.14159/2)*((long)Params->MaxValue-(long)Params->MinValue)+(long)Params->MinValue;
				lRange(&C,0,255);
/*
				if(C<0)C=0;
				if(C>255)C=255;
*/
				for(Channel=0;Channel<4;Channel++)
				{
					if((Params->Channel==4)||(Params->Channel==Channel))
					{
						*(Pic1+((K*Temp->XSize+I)*4+Channel))=C;
					}
				}
			}
		}
	}

}

void	InitATanList()
{
	long I,K;
	float XR,YR;
	for(I=0;I<256;I++)
		for(K=0;K<256;K++)
		{
			XR=I-128;
			YR=K-128;
			ATanList[K*256+I]=MyArcTan(I-128,K-128);
			AbList[K*256+I]=sqrt(XR*XR+YR*YR);
		}
}
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -