mlrclipper.cpp

机甲指挥官2源代码

		DrawShape(&drawShapeInfo);

		drawShapeInfo.shape->DetachReference();

		gos_SetRenderState(	gos_State_Fog, 0);
	}
#endif

	gos_PopCurrentHeap();

//
// End timing function
//
}

static	AffineMatrix4D scaledShapeToWorld;

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
void
	MLRClipper::DrawShape (DrawShapeInformation *dInfo)
{
	Check_Object(this);
//
// Statistic timing function
//

	gos_PushCurrentHeap(Heap);
	MLRShape *shape = dInfo->shape;
	MLRPrimitiveBase *primitive = NULL;

	if(dInfo->nrOfActiveLights > Limits::Max_Number_Of_Lights_Per_Primitive)
	{
		dInfo->nrOfActiveLights = Limits::Max_Number_Of_Lights_Per_Primitive;
	}

	shape->shapeToClipMatrix.Multiply(*dInfo->shapeToWorld, worldToClipMatrix);

	shape->worldToShape = dInfo->worldToShape;

	shape->InitializePrimitives(true, dInfo->state);

	int i, j;
	Point3D sp;
	int	nrOfLightMaps = 0;
	sp.Multiply(cameraPosition, *shape->worldToShape);

	for(i=0;i<dInfo->nrOfActiveLights;i++)
	{
		dInfo->activeLights[i]->SetLightToShapeMatrix(*shape->worldToShape);
		nrOfLightMaps += (dInfo->activeLights[i]->GetLightMap()) ? 1 : 0;
	}

	if(!gEnableLightMaps)
	{
		nrOfLightMaps = 0;
	}

	gos_GetViewport( &ViewportScalars::MulX, &ViewportScalars::MulY, &ViewportScalars::AddX, &ViewportScalars::AddY );

#ifdef LAB_ONLY
	if(gShowBirdView)
	{
		dInfo->clippingFlags = 0x3f;
#ifdef OLDFOG
		dInfo->state.SetFogMode(MLRState::DisableFogMode);
#else
		dInfo->state.SetFogMode(0);
#endif
		dInfo->state.SetRenderPermissionMask (
			dInfo->state.GetRenderPermissionMask() & ~MLRState::FogMask
		);
	}
#endif

	for(i=0;i<shape->numPrimitives;i++)
	{
		primitive = shape->allPrimitives[i];
		Check_Object(primitive);

		if(primitive->GetCurrentState().GetDrawNowMode()==MLRState::DrawNowOffMode)
		{
			ToBeDrawnPrimitive *tbdp = sorter->GetCurrentTBDP();
			Check_Pointer(tbdp);

			tbdp->primitive = primitive;

			tbdp->state = primitive->GetCurrentState();
			tbdp->cameraPosition = sp;
			tbdp->clippingFlags = dInfo->clippingFlags;

			Check_Object(&tbdp->shapeToClipMatrix);
			tbdp->shapeToClipMatrix = shape->shapeToClipMatrix;
			tbdp->worldToShape = *shape->worldToShape;

			Verify(dInfo->nrOfActiveLights <= Limits::Max_Number_Of_Lights_Per_Primitive);
			tbdp->nrOfActiveLights = dInfo->nrOfActiveLights;

			for(j=0;j<tbdp->nrOfActiveLights;j++)
			{
				Check_Object(dInfo->activeLights[j]);
				tbdp->activeLights[j] = dInfo->activeLights[j];
			}
			sorter->IncreaseTBDPCounter();
		}
		else
		{
			if(nrOfLightMaps)
			{
				MLRLightMap::SetDrawData
					(
						&allVerticesToDraw,
						&shape->shapeToClipMatrix,
						dInfo->clippingFlags,
						dInfo->state
					);
			}

			if(primitive->FindBackFace(sp))
			{
				primitive->Lighting(dInfo->activeLights, dInfo->nrOfActiveLights);

				if(dInfo->clippingFlags.GetClippingState() != 0)
				{
					if(primitive->TransformAndClip(&shape->shapeToClipMatrix, dInfo->clippingFlags, &allVerticesToDraw))
					{
						if(primitive->GetVisible())
						{
							for(j=0;j<primitive->GetNumPasses();j++)
							{
								sorter->DrawPrimitive(primitive, j);
							}
							
						}
					}
				}
				else
				{
					primitive->TransformNoClip(&shape->shapeToClipMatrix, &allVerticesToDraw);

					for(j=0;j<primitive->GetNumPasses();j++)
					{
						sorter->DrawPrimitive(primitive, j);
					}
				}

#ifdef LAB_ONLY
				Set_Statistic(Number_Of_Primitives, Number_Of_Primitives+1);

				if(primitive->IsDerivedFrom(MLRIndexedPrimitiveBase::DefaultData))
				{
					Point3D *coords;
					unsigned short *indices;
					int nr;

					(Cast_Pointer(MLRIndexedPrimitiveBase*, primitive))->GetIndexData(&indices, &nr);
					NumAllIndices += nr;

					primitive->GetCoordData(&coords, &nr);
					NumAllVertices += nr;

					Set_Statistic(Index_Over_Vertex_Ratio, (Scalar)NumAllIndices/(Scalar)NumAllVertices);
				}
#endif
				if(nrOfLightMaps)
				{
					MLRLightMap::DrawLightMaps(sorter);
				}
			}
		}
	}

//
// End timing function
//
	gos_PopCurrentHeap();
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
void
	MLRClipper::DrawScalableShape (DrawScalableShapeInformation *dInfo)
{
	Check_Object(this);
//
// Statistic timing function
//

	MLRShape *shape = dInfo->shape;
	MLRPrimitiveBase *primitive = NULL;

	shape->shapeToClipMatrix.Multiply(*dInfo->shapeToWorld, worldToClipMatrix);

	shape->worldToShape = dInfo->worldToShape;

	shape->InitializePrimitives(true, dInfo->state, 1);

	if(dInfo->scaling != NULL)
	{
		LinearMatrix4D scale = LinearMatrix4D::Identity;

		scale(0,0) = dInfo->scaling->x;
		scale(1,1) = dInfo->scaling->y;
		scale(2,2) = dInfo->scaling->z; 

		scaledShapeToWorld.Multiply(scale, *dInfo->shapeToWorld);

		shape->shapeToClipMatrix.Multiply(scaledShapeToWorld, worldToClipMatrix);
	}
	else
	{
		shape->shapeToClipMatrix.Multiply(*dInfo->shapeToWorld, worldToClipMatrix);
	}

	shape->worldToShape = NULL;

	int i;

	gos_GetViewport( &ViewportScalars::MulX, &ViewportScalars::MulY, &ViewportScalars::AddX, &ViewportScalars::AddY );

#ifdef LAB_ONLY
	if(gShowBirdView)
	{
		dInfo->clippingFlags = 0x3f;
	}
#endif

	for(i=0;i<shape->numPrimitives;i++)
	{
		primitive = shape->allPrimitives[i];
		Check_Object(primitive);

		if(dInfo->paintMe)
		{
			primitive->PaintMe(dInfo->paintMe);
		}

		if(dInfo->clippingFlags.GetClippingState() != 0)
		{
			if(primitive->TransformAndClip(&shape->shapeToClipMatrix, dInfo->clippingFlags, &allVerticesToDraw))
			{
				if(primitive->GetVisible())
				{
					if(primitive->GetCurrentState().GetDrawNowMode()==MLRState::DrawNowOnMode)
					{
						sorter->DrawPrimitive(primitive);
					}
					else
					{
						sorter->AddPrimitive(primitive);
					}
					
					#ifdef LAB_ONLY
						Set_Statistic(Number_Of_Primitives, Number_Of_Primitives+1);
					#endif
				}
			}
		}
		else
		{
			primitive->TransformNoClip(&shape->shapeToClipMatrix, &allVerticesToDraw);

			if(primitive->GetCurrentState().GetDrawNowMode()==MLRState::DrawNowOnMode)
			{
				sorter->DrawPrimitive(primitive);
			}
			else
			{
				sorter->AddPrimitive(primitive);
			}
			
			#ifdef LAB_ONLY
				Set_Statistic(Number_Of_Primitives, Number_Of_Primitives+1);
			#endif
		}
	}
//
// End timing function
//
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
void
	MLRClipper::DrawEffect (DrawEffectInformation *dInfo)
{
//
// Statistic timing function
//

	Check_Object(this);
	Check_Object(dInfo);
	Check_Object(dInfo->effect);

#ifdef LAB_ONLY
	if(gShowBirdView)
	{
		dInfo->clippingFlags = 0x3f;
	}
#endif

	dInfo->effect->SetEffectToClipMatrix(dInfo->effectToWorld, &worldToClipMatrix);
	gos_GetViewport( &ViewportScalars::MulX, &ViewportScalars::MulY, &ViewportScalars::AddX, &ViewportScalars::AddY );
	dInfo->effect->Draw(dInfo, &allVerticesToDraw, sorter);
//
// End timing function
//
}


//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
void
	MLRClipper::DrawScreenQuads (DrawScreenQuadsInformation *dInfo)
{
//
// Statistic timing function
//

	Check_Object(this);
	Check_Object(dInfo);

	gos_GetViewport( &ViewportScalars::MulX, &ViewportScalars::MulY, &ViewportScalars::AddX, &ViewportScalars::AddY );

	GOSVertex *vertices	= allVerticesToDraw.GetActualVertexPool();

	int i, j;

	dInfo->currentNrOfQuads = 0;

	for(i=0,j=0;i<dInfo->nrOfQuads;i++)
	{
		if(dInfo->onOrOff[i] == true)
		{
			dInfo->currentNrOfQuads += 4;
			for(;j<dInfo->currentNrOfQuads;j++)
			{
				int offset = (i<<2) + (j&3);

				Verify(dInfo->coords[offset].x >= 0.0f && dInfo->coords[offset].x <= dInfo->coords[offset].w );
				Verify(dInfo->coords[offset].y >= 0.0f && dInfo->coords[offset].y <= dInfo->coords[offset].w );
				Verify(dInfo->coords[offset].z >= 0.0f && dInfo->coords[offset].z <= dInfo->coords[offset].w );

				vertices[j].x = (1.0f-dInfo->coords[offset].x)*ViewportScalars::MulX + ViewportScalars::AddX;
				vertices[j].y = (1.0f-dInfo->coords[offset].y)*ViewportScalars::MulY + ViewportScalars::AddY;
				vertices[j].z = dInfo->coords[offset].z;
				vertices[j].rhw = dInfo->coords[offset].w;

				vertices[j].argb = GOSCopyColor(dInfo->colors + offset);

				vertices[j].u = dInfo->texCoords[offset][0];
				vertices[j].v = dInfo->texCoords[offset][1];

			}
		}
	}

	if(j>0)
	{
		allVerticesToDraw.Increase(j);

		sorter->AddScreenQuads(vertices, dInfo);
	}
//
// End timing function
//
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
void
	MLRClipper::Clear (unsigned int flags)
{
	Check_Object(this);
}