mlr_terrain2.cpp

机甲指挥官2源代码

//===========================================================================//
// Copyright (C) Microsoft Corporation. All rights reserved.                 //
//===========================================================================//

#include "MLRHeaders.hpp"

#if defined(TRACE_ENABLED) && defined(MLR_TRACE)
	BitTrace *MLR_Terrain2_Clip;
#endif

extern DWORD gEnableLightMaps;

//#############################################################################
//## MLRTerrain with no color no lighting w/ detail texture, uv's from xyz  ###
//#############################################################################

DynamicArrayOf<Vector2DScalar>
	*MLR_Terrain2::detailTexCoords;

MLR_Terrain2::ClassData*
	MLR_Terrain2::DefaultData = NULL;

extern DynamicArrayOf<Vector2DScalar> *lightMapUVs;
extern DynamicArrayOf<Scalar> *lightMapSqFalloffs;

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
void
	MLR_Terrain2::InitializeClass()
{
	Verify(!DefaultData);
	Verify(gos_GetCurrentHeap() == StaticHeap);
	DefaultData =
		new ClassData(
			MLR_Terrain2ClassID,
			"MidLevelRenderer::MLR_Terrain2",
			MLR_I_DeT_TMesh::DefaultData,
			(MLRPrimitiveBase::Factory)&Make
		);
	Register_Object(DefaultData);

	detailTexCoords = new DynamicArrayOf<Vector2DScalar> (Limits::Max_Number_Vertices_Per_Mesh);
	Register_Object(detailTexCoords);

	#if defined(TRACE_ENABLED) && defined(MLR_TRACE)
		MLR_Terrain2_Clip = new BitTrace("MLR_Terrain2_Clip");
		Register_Object(MLR_Terrain2_Clip);
	#endif
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
void
	MLR_Terrain2::TerminateClass()
{
	Unregister_Object(DefaultData);
	delete DefaultData;
	DefaultData = NULL;

	Unregister_Object(detailTexCoords);
	delete detailTexCoords;

	#if defined(TRACE_ENABLED) && defined(MLR_TRACE)
		Unregister_Object(MLR_Terrain2_Clip);
		delete MLR_Terrain2_Clip;
	#endif
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
MLR_Terrain2::MLR_Terrain2(
	ClassData *class_data,
	MemoryStream *stream,
	int version
):
	MLR_I_DeT_TMesh(class_data, stream, version)
{
	Check_Pointer(this);
	Check_Pointer(stream);
	Verify(gos_GetCurrentHeap() == Heap);

	*stream >> tileX >> tileZ;
	*stream >> maxDepth >> maxAllDepth;

	if(version>4)
	{
		Scalar *fptr = &frame[0][0];

		for(int i=0;i<32;i++)
		{
			*stream >> *fptr++;
		}
	}
	else
	{
		Scalar xOffset, zOffset, xGrid, zGrid;

		*stream >> xOffset >> zOffset;
		*stream >> xGrid >> zGrid;

		frame[0][0] = xOffset;
		frame[0][1] = zOffset;
		frame[0][2] = xOffset + 8*xGrid;
		frame[0][3] = zOffset + 8*zGrid;

		frame[1][0] = xOffset + 4*(tileX/4)*xGrid;
		frame[1][1] = zOffset + 4*(tileZ/4)*zGrid;
		frame[1][2] = frame[1][0] + 4*xGrid;
		frame[1][3] = frame[1][1] + 4*zGrid;

		int i;
		for(i=2;i<8;i++)
		{
			frame[i][0] = xOffset + tileX*xGrid;
			frame[i][1] = zOffset + tileZ*zGrid;
			frame[i][2] = frame[i][0] + xGrid;
			frame[i][3] = frame[i][1] + zGrid;
		}
	}

	*stream >> borderPixelFun;

	unsigned char textureFlags, mask = 1;

	*stream >> textureFlags;

	for(int i=0;i<8;i++)
	{
		if(textureFlags | mask)
		{
			textures[i] = 1;
		}
		else
		{
			textures[i] = 0;
		}
		mask <<= 1;
	}

	Check_Object(MLRTexturePool::Instance);
	MLRTexture *orgTexture = (*MLRTexturePool::Instance)[referenceState.GetTextureHandle()];
	Check_Object(orgTexture);
	const char *texName = orgTexture->GetTextureName();
	char texRoot[1024], name[1024];

	int len;
	if((len = strlen(texName)) > 0)
	{
		Verify(len>8);
		int i, d = texName[len-6] - '0';

		strncpy(texRoot, texName, len-7);
		texRoot[len-7] = '\0';

		textures[d] = referenceState.GetTextureHandle();

		MLRTexture *texture;

		unsigned char mask = 1;
		for(i=0;i<8;i++)
		{
			if(textureFlags & mask)
			{
				sprintf(name, "%s_%1d_%02x%02x", texRoot, i, (7-tileX)/(1<<(maxAllDepth-i)), (7-tileZ)/(1<<(maxAllDepth-i)));

				texture = (*MLRTexturePool::Instance)(name, 0);
				if (!texture)
				{
					texture = MLRTexturePool::Instance->Add(name, 0);
				}
				Check_Object(texture);

				texture->SetHint(orgTexture->GetHint());

				textures[i] = texture->GetTextureHandle();
			}
			else
			{
				textures[i] = 0;
			}
			mask <<= 1;
		}
		i++;
		for(;i<8;i++)
		{
			textures[i] = 0;
		}
	}
	else
	{
		for(int i=0;i<8;i++)
		{
			textures[i] = 0;
		}
	}

	Verify(textures[0]!=0);

	currentDepth = -1;

	SetCurrentDepth(1);

	referenceState.SetLightingMode(MLRState::LightMapLightingMode);
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
MLR_Terrain2::MLR_Terrain2(ClassData *class_data):
	MLR_I_DeT_TMesh(class_data)
{
	Check_Pointer(this);
	Verify(gos_GetCurrentHeap() == Heap);

	tileX = 0;
	tileZ = 0;
	maxDepth = 0;
	maxAllDepth = 0;

	borderPixelFun = 0.0f;

	Scalar *fptr = &frame[0][0];

	int i;
	for(i=0;i<32;i++)
	{
		*fptr++ = 0.0f;
	}

	for(i=0;i<8;i++)
	{
		textures[i] = 0;
	}
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
MLR_Terrain2::~MLR_Terrain2()
{
	Check_Object(this);
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
MLR_Terrain2*
	MLR_Terrain2::Make(
		MemoryStream *stream,
		int version
	)
{
	Check_Object(stream);

	gos_PushCurrentHeap(Heap);
	MLR_Terrain2 *terrain = new MLR_Terrain2(DefaultData, stream, version);
	gos_PopCurrentHeap();

	return terrain;
}


//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
void
	MLR_Terrain2::Save(MemoryStream *stream)
{
	Check_Object(this);
	Check_Object(stream);

	texCoords.SetLength(0);
	MLR_I_DeT_TMesh::Save(stream);
	CalculateUVs();

	*stream << tileX << tileZ;
	*stream << maxDepth << maxAllDepth;

	Scalar *fptr = &frame[0][0];

	for(int i=0;i<32;i++)
	{
		*stream << *fptr++;
	}

	*stream << borderPixelFun;

	unsigned char textureFlags = 0;

//	HACK
/*
	Check_Object(MLRTexturePool::Instance);
	MLRTexture *orgTexture = (*MLRTexturePool::Instance)[referenceState.GetTextureHandle()];
	const char *texName = orgTexture->GetTextureName();
	char texRoot[1024], name[1024];

	int len;
	if((len = strlen(texName)) > 0)
	{
		Verify(len>8);
		int i, d = texName[len-6] - '0';
		Verify(d==maxDepth);
		strncpy(texRoot, texName, len-7);
		texRoot[len-7] = '\0';

		textures[d] = referenceState.GetTextureHandle();

		MLRTexture *texture;

		unsigned char mask = 1;
		for(i=0;i<d;i++)
		{
			sprintf(name, "%s_%1d_%02x%02x", texRoot, i, tileX/(1<<(maxAllDepth-i)), tileZ/(1<<(maxAllDepth-i)));

			Verify((1<<i)>(tileX/(1<<(maxAllDepth-i))));
			Verify((1<<i)>(tileZ/(1<<(maxAllDepth-i))));
//				SPEW(("micgaert", "%s", name));

			texture = (*MLRTexturePool::Instance)(name, 0);
			if (texture)
			{
				textureFlags |= mask;
				textures[i] = texture->GetTextureHandle();
			}
			mask <<= 1;
		}
	}
	Verify(textures[0]!=0);
*/
	textureFlags = 3;
//	HACK


	*stream << textureFlags;
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
void
	MLR_Terrain2::TestInstance() const
{
	Verify(IsDerivedFrom(DefaultData));
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
void
	MLR_Terrain2::SetCurrentDepth(unsigned char d)
{
	if(d == currentDepth)
	{
		return;
	}
	else
	{
		Verify(d <= maxAllDepth);

		unsigned char dt;
		dt = d<maxDepth ? d : maxDepth;

		while(dt>0 && textures[dt]==0)
		{
			dt--;
		}
		currentDepth = dt;
	}
	CalculateUVs();
	referenceState.SetTextureHandle(textures[currentDepth]);
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
void
	MLR_Terrain2::SetLevelTexture(int lev, int handle)
{
	Check_Object(this);
	Verify(lev>=0 && lev<8);
	textures[lev] = handle;

	if(lev==currentDepth)
	{
		referenceState.SetTextureHandle(textures[currentDepth]);
	}
 }

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
void
	MLR_Terrain2::CalculateUVs()
{
	if(texCoords.GetLength() != coords.GetLength())
	{
		gos_PushCurrentHeap(Heap);
		texCoords.SetLength(coords.GetLength());
		gos_PopCurrentHeap();
	}

	Scalar maxX = frame[currentDepth][2];
	Scalar maxZ = frame[currentDepth][3];

	Scalar OneOverX = 1.0f/(frame[currentDepth][2] - frame[currentDepth][0]);
	Scalar OneOverZ = 1.0f/(frame[currentDepth][3] - frame[currentDepth][1]);

	for(int i=0;i<texCoords.GetLength();i++)
	{
		texCoords[i][0] = borderPixelFun + (1.0f-2*borderPixelFun)*(maxX - coords[i].x)*OneOverX;
		texCoords[i][1] = borderPixelFun + (1.0f-2*borderPixelFun)*(maxZ - coords[i].z)*OneOverZ;

		Verify(texCoords[i][0]>=0.0 && texCoords[i][0]<=1.0);
		Verify(texCoords[i][1]>=0.0 && texCoords[i][1]<=1.0);
	}
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//

#define I_SAY_YES_TO_DETAIL_TEXTURES
#define I_SAY_YES_TO_TERRAIN2
#undef I_SAY_YES_TO_DUAL_TEXTURES
#undef I_SAY_YES_TO_COLOR
#undef I_SAY_YES_TO_TERRAIN
#undef I_SAY_YES_TO_LIGHTING

#define CLASSNAME MLR_Terrain2

#if defined(TRACE_ENABLED) && defined(MLR_TRACE)
	#define SET_MLR_TMESH_CLIP() MLR_Terrain2_Clip->Set()
	#define CLEAR_MLR_TMESH_CLIP() MLR_Terrain2_Clip->Clear()
#else
	#define SET_MLR_TMESH_CLIP()
	#define CLEAR_MLR_TMESH_CLIP()
#endif