mlrsorter.cpp

机甲指挥官2源代码

MLRSorter::~MLRSorter()
{
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
void
	MLRSorter::StartDraw(const MLRState &default_state)
{
	theCurrentState = default_state;
	theCurrentState.SetRendererState(texturePool);
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
void
	MLRSorter::Reset ()
{
	lastUsedRaw = 0;

#ifdef CalDraw
	for(int i=0;i<MLRState::PriorityCount;i++)
	{
		lastUsedInBucketNotDrawn[i] = 0;
	}

	lastUsedDraw = 0;
#endif
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
void
	MLRSorter::DrawPrimitive(MLRPrimitiveBase *pt, int pass)
{
	Check_Object(this); 
	Check_Object(pt);

	SortData *sd = NULL;

	switch(pt->GetSortDataMode())
	{
		case SortData::TriList:
		case SortData::TriIndexedList:
		{
			sd = SetRawData(pt, pass);

			if(theCurrentState != sd->state)
			{
				SetDifferences(theCurrentState, sd->state);
				theCurrentState = sd->state;
			}

			if(sd->texture2>0)
			{
				gos_SetRenderState( 
					gos_State_Texture2, 
					(*texturePool)[sd->texture2]->GetImage(NULL)->GetHandle());

				switch(sd->state.GetMultiTextureMode())
				{
					case MLRState::MultiTextureLightmapMode:
						gos_SetRenderState( gos_State_Multitexture, gos_Multitexture_LightMap );
					break;
					case MLRState::MultiTextureSpecularMode:
						gos_SetRenderState( gos_State_Multitexture, gos_Multitexture_SpecularMap );
					break;
				}
			}
			else
			{
			}

			SortData::DrawFunc drawFunc = sd->Draw[sd->type];

			(sd->*drawFunc)();

			if(sd->texture2>0)
			{
				gos_SetRenderState( gos_State_Multitexture, gos_Multitexture_None );
			}
		}
		break;
	}

}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
SortData *
	MLRSorter::SetRawData
		(
			void *vertices, 
			int numVertices, 
			const MLRState& state,
			const int& mode,
			int tex2
		)
{
	Check_Object(this);

	SortData *sd = rawDrawData.GetData();

	Verify (lastUsedRaw < Limits::Max_Number_Primitives_Per_Frame);
	Verify (vertices != NULL);
	Verify (numVertices > 0);

	(sd + lastUsedRaw)->vertices = vertices;
	(sd + lastUsedRaw)->indices = 0;

	(sd + lastUsedRaw)->state = state;

	(sd + lastUsedRaw)->numVertices = numVertices;
	(sd + lastUsedRaw)->numIndices = 0;

	(sd + lastUsedRaw)->type = mode;
	(sd + lastUsedRaw)->texture2 = tex2;

	lastUsedRaw++;

	return (sd + lastUsedRaw - 1);
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
SortData *
	MLRSorter::SetRawIndexedData
		(
			void *vertices, 
			int numVertices, 
			unsigned short *indices, 
			int numIndices, 
			const MLRState& state,
			const int& mode,
			int tex2
		)
{
	Check_Object(this);

	SortData *sd = rawDrawData.GetData();

	Verify (lastUsedRaw < Limits::Max_Number_Primitives_Per_Frame);
	Verify (vertices != NULL);
	Verify (numVertices > 0);

	(sd + lastUsedRaw)->vertices = vertices;
	(sd + lastUsedRaw)->indices = indices;

	(sd + lastUsedRaw)->state = state;

	(sd + lastUsedRaw)->numVertices = numVertices;
	(sd + lastUsedRaw)->numIndices = numIndices;

	(sd + lastUsedRaw)->type = mode;
	(sd + lastUsedRaw)->texture2 = tex2;
		
	lastUsedRaw++;

	return (sd + lastUsedRaw - 1);
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
SortData *
	MLRSorter::SetRawData ( MLRPrimitiveBase *pt, int pass)
{
	Check_Object(this);
	Check_Object(pt);
	
	int drawMode = pt->GetSortDataMode();
	
	switch(drawMode)
	{
		case SortData::TriIndexedList:
		{
			MLRIndexedPrimitiveBase *ipt = static_cast<MLRIndexedPrimitiveBase *>(pt);

			int tex2 = 0;
			void *vertices = ipt->GetGOSVertices(pass);
			int vertexCount = ipt->GetNumGOSVertices();

			if(pt->GetCurrentState(pass).GetMultiTextureMode()!=MLRState::MultiTextureOffMode && MLRState::GetMultitextureLightMap())
			{
				Verify(pass==0);
				tex2 = pt->GetCurrentState(1).GetTextureHandle();
				vertices = pt->GetGOSVertices2UV();
			}

			return SetRawIndexedData (
				vertices,
				vertexCount, 
				ipt->GetGOSIndices(pass),
				ipt->GetNumGOSIndices(), 
				ipt->GetCurrentState(pass),
				drawMode,
				tex2
			);
		}
		case SortData::TriList:
			return SetRawData (
				pt->GetGOSVertices(pass),
				pt->GetNumGOSVertices(), 
				pt->GetCurrentState(pass),
				drawMode
			);
	}

	return NULL;
}

#ifdef CalDraw
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
void
	MLRSorter::IncreaseTBDPCounter()
{
	Check_Object(this);
	int priority = drawData[lastUsedDraw].primitive->GetReferenceState().GetPriority();
	priorityBucketsNotDrawn[priority][lastUsedInBucketNotDrawn[priority]++] = &drawData[lastUsedDraw];
	lastUsedDraw++;
}
#endif

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
bool
	MLRSorter::SetDifferences(const MLRState& original, const MLRState& newer)
{
	Verify(original != newer);

	int changed = (original.renderState ^ newer.renderState);

	if(changed)
	{
		if(changed & MLRState::TextureMask)
		{
			Check_Object(texturePool);

			if( newer.renderState & MLRState::TextureMask )
			{
				Verify((*texturePool)[newer.renderState & MLRState::TextureMask]);
				gos_SetRenderState( 
					gos_State_Texture, 
					(*texturePool)[newer.renderState & MLRState::TextureMask]->GetImage(NULL)->GetHandle()
				);
			}
			else
				gos_SetRenderState(gos_State_Texture, 0);
		}

		if(changed & MLRState::AlphaMask)
		{
			switch( newer.renderState&MLRState::AlphaMask )
			{
			case MLRState::OneZeroMode:
				gos_SetRenderState(gos_State_AlphaTest, 0);
				gos_SetRenderState(gos_State_AlphaMode, gos_Alpha_OneZero);
				break;

			case MLRState::OneOneMode:
				gos_SetRenderState(gos_State_AlphaTest, 0);
				gos_SetRenderState(gos_State_AlphaMode, gos_Alpha_OneOne);
				break;

			case MLRState::AlphaOneMode:
				SPEW(("micgaert", "MLRState::AlphaOneMode not available anymore"));
				break;

			case MLRState::OneAlphaMode:
				SPEW(("micgaert", "MLRState::OneAlphaMode not available anymore"));
				break;

			case MLRState::AlphaInvAlphaMode:
				gos_SetRenderState(gos_State_AlphaTest, 1);
				gos_SetRenderState(gos_State_AlphaMode, gos_Alpha_AlphaInvAlpha);
				break;

			case MLRState::OneInvAlphaMode:
				gos_SetRenderState(gos_State_AlphaTest, 0);
				gos_SetRenderState(gos_State_AlphaMode, gos_Alpha_OneInvAlpha);
				break;

			default:
				STOP(("Unknown alpha renderState"));
			}
		}

		if (changed & MLRState::FilterMask)
		{
			switch( newer.renderState&MLRState::FilterMask )
			{
				case MLRState::NoFilterMode:
					gos_SetRenderState(gos_State_Filter, gos_FilterNone);
					break;

				case MLRState::BiLinearFilterMode:
					gos_SetRenderState(gos_State_Filter, gos_FilterBiLinear);
					break;

				case MLRState::TriLinearFilterMode:
					gos_SetRenderState(gos_State_Filter, gos_FilterTriLinear);
					break;

				default:
					STOP(("Unknown filter state"));
			}
		}

		if(changed & MLRState::FogMask)
		{
			if(newer.renderState & MLRState::FogMask)
			{
				gos_SetRenderState(	gos_State_Fog, (int)&newer.fogColor);
			}
			else
			{
				gos_SetRenderState(	gos_State_Fog, 0);
			}
		}

		if(changed & MLRState::SpecularMask)
		{
			gos_SetRenderState(	gos_State_Specular, newer.renderState & MLRState::SpecularOnMode );
		}

		if(changed & MLRState::TextureWrapMask)
		{
			gos_SetRenderState(	
				gos_State_TextureAddress, 
				(newer.renderState & MLRState::TextureClamp) ? gos_TextureClamp : gos_TextureWrap
			);
		}

		if(changed & MLRState::DitherOnMode)
		{
			gos_SetRenderState(	gos_State_Dither, newer.renderState & MLRState::DitherOnMode );
		}

		if(changed & MLRState::TextureCorrectionOnMode)
		{
			gos_SetRenderState(	gos_State_Perspective, newer.renderState & MLRState::TextureCorrectionOnMode );
		}

		if(changed & MLRState::WireFrameMask)
		{
			if( newer.renderState & MLRState::WireFrameOnlyMode )
			{
				DWORD wfColor=0xffffff;
				gos_SetRenderState(	gos_State_WireframeMode, (DWORD)&wfColor );
			}
			else
			{
				gos_SetRenderState(	gos_State_WireframeMode, 0 );
			}
		}

		if(changed & MLRState::FlatColoringMask)
		{
			gos_SetRenderState(gos_State_ShadeMode, gos_ShadeGouraud);
		}

		if(changed & MLRState::ZBufferWriteMask)
		{
			gos_SetRenderState(gos_State_ZWrite, (newer.renderState & MLRState::ZBufferWriteMask) ? 1 : 0);
		}

		if(changed & MLRState::ZBufferCompareMask)
		{
			gos_SetRenderState( gos_State_ZCompare, (newer.renderState & MLRState::ZBufferCompareMask) ? 1 : 0);
		}
	}

	gos_SetRenderState( gos_State_TextureMapBlend, gos_BlendModulateAlpha);

	return true;
}

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