Esempio n. 1
0
//---------------------------------------------------------------------------
void Clouds::update (void)
{
	renderClouds = false;
	
	scrollU += frameLength * SCROLL_U_FACTOR;
	scrollV += frameLength * SCROLL_V_FACTOR;

	if (scrollU > 1.0f)
		scrollU -= 1.0f;
		
	if (scrollV > 1.0f)
		scrollV -= 1.0f;
		
	if (scrollU < -1.0f)
		scrollU += 1.0f;
		
	if (scrollV < -1.0f)
		scrollV += 1.0f;
		
	//---------------------------------------------------------------------
	// If projectionAngle is less then some magic number, draw the clouds.
	// Otherwise, do not do anything!
	if (eye->active && eye->usePerspective && (eye->getProjectionAngle() < MAX_CLOUDS_ANGLE))
	{
		//renderClouds = true;
		
		//-------------------------------------------------------
		// Create the cloud grid based on camera CENTER position.
		Stuff::Vector3D centerPosition(eye->getPosition());
		
		//-------------------------------------------------------
		// Create a topLeft vertex
		float tLeftX = centerPosition.x + MAX_CLOUDS_SIZE;
		float tLeftY = centerPosition.y + MAX_CLOUDS_SIZE;
		
		//-------------------------------------------------------
		// Create the grid.
		long cloudInc = float2long(MAX_CLOUDS_SIZE * 2.0f / gridSize);
		float uvInc = MAX_UV_REPEAT / float(gridSize);
		
		for (long y=0;y<gridSize;y++)
		{
			for (long x=0;x<gridSize;x++)
			{
				cloudVertices[x + (y*gridSize)].vx = tLeftX - (cloudInc * x);
				cloudVertices[x + (y*gridSize)].vy = tLeftY - (cloudInc * y);
				
				cloudVertices[x + (y*gridSize)].pu = CLOUD_START_U + (uvInc * x);
				cloudVertices[x + (y*gridSize)].pv = CLOUD_START_V + (uvInc * y);
 			}
		}
		
		//-------------------------------------------------------
		// Transform Grid
		long gridTotal = gridSize * gridSize;
		for (long i=0;i<gridTotal;i++)
		{
			//----------------------------------------------------------------------------------------
			// Figure out if we are in front of camera or not.  Should be faster then actual project!
			// Should weed out VAST overwhelming majority of vertices!
			bool onScreen = true;
		
			//-----------------------------------------------------------------
			// Find angle between lookVector of Camera and vector from camPos
			// to Target.  If angle is less then halfFOV, object is visible.
			
			//-------------------------------------------------------------------
			// Then figure out if FarClipped.  Should weed out a boatload more!
			float hazeFactor = 0.0f;
			Stuff::Point3D Distance;
			Stuff::Point3D vPosition;
			Stuff::Point3D eyePosition(eye->getPosition());
			vPosition.x = cloudVertices[i].vx;;
			vPosition.y = cloudVertices[i].vy;
			vPosition.z = centerPosition.z;
				
			Distance.Subtract(eyePosition,vPosition);
			float eyeDistance = Distance.GetApproximateLength();
			if (eyeDistance > Camera::MaxClipDistance)
			{
				hazeFactor = 1.0f;
				//onScreen = false;
			}
			else if (eyeDistance > Camera::MinHazeDistance)
			{
				hazeFactor = (eyeDistance - Camera::MinHazeDistance) * Camera::DistanceFactor;
			}
			else
			{
				hazeFactor = 0.0f;
			}
					
			//------------------------------------------------------------
			// Calculate the HazeDWORD here
			if (hazeFactor != 0.0f)
			{
				float fogFactor = 1.0 - hazeFactor;
				DWORD distFog = float2long(fogFactor * 255.0f);
				
				cloudVertices[i].fogRGB = (distFog<<24) + (0xffffff);
			}
			else
			{
				cloudVertices[i].fogRGB = 0xffffffff;
			}
			
			if (onScreen)
			{
				Stuff::Vector3D Distance;
				Stuff::Point3D objPosition;
				Stuff::Point3D eyePosition(eye->getCameraOrigin());
				objPosition.x = -cloudVertices[i].vx;
				objPosition.y = CLOUD_ALTITUDE;
				objPosition.z = cloudVertices[i].vy;
			
				Distance.Subtract(objPosition,eyePosition);
				Distance.Normalize(Distance);
					
				float cosine = Distance * eye->getLookVector();
				if (cosine > eye->cosHalfFOV)
					onScreen = true;
				else
					onScreen = false;
			}
			else
			{
				hazeFactor = 1.0f;
			}
			
			Stuff::Vector3D vertex3D(cloudVertices[i].vx,cloudVertices[i].vy,(CLOUD_ALTITUDE+eye->getCameraOrigin().y));
			Stuff::Vector4D screenPos;
			bool inView = eye->projectZ(vertex3D,screenPos);
			
			cloudVertices[i].px = screenPos.x;
			cloudVertices[i].py = screenPos.y;
			cloudVertices[i].pz = screenPos.z;
			cloudVertices[i].pw = screenPos.w;
			
			//------------------------------------------------------------
			// Fix clip.  Vertices can all be off screen and triangle
			// still needs to be drawn!
			cloudVertices[i].clipInfo = onScreen && inView;
			
			//------------------------------------------------------------
			// Still need to scrollUVs here!
			cloudVertices[i].pu += scrollU;
			cloudVertices[i].pv += scrollV;
		}
		
		for (y=0;y<(gridSize-1);y++)
		{
			for (long x=0;x<(gridSize-1);x++)
			{
				CloudVertexPtr cloudVertex0 = &(cloudVertices[x     + (y    *gridSize)]);
				CloudVertexPtr cloudVertex1 = &(cloudVertices[(x+1) + (y    *gridSize)]); 
				CloudVertexPtr cloudVertex2 = &(cloudVertices[(x+1) + ((y+1)*gridSize)]); 
				CloudVertexPtr cloudVertex3 = &(cloudVertices[x     + ((y+1)*gridSize)]); 
				
				bool clipCheck = (cloudVertex0->clipInfo || cloudVertex1->clipInfo || cloudVertex2->clipInfo);
				if (clipCheck && ((cloudVertex0->pz < 1.0f) && (cloudVertex0->pz > 0.0f) &&
									(cloudVertex1->pz < 1.0f) && (cloudVertex1->pz > 0.0f) && 
									(cloudVertex2->pz < 1.0f) && (cloudVertex2->pz > 0.0f)))
				{
					mcTextureManager->addTriangle(mcTextureNodeIndex,MC2_DRAWALPHA);
				}
				
				clipCheck = (cloudVertex0->clipInfo || cloudVertex2->clipInfo || cloudVertex3->clipInfo);
				if (clipCheck && ((cloudVertex0->pz < 1.0f) && (cloudVertex0->pz > 0.0f) &&
									(cloudVertex2->pz < 1.0f) && (cloudVertex2->pz > 0.0f) && 
									(cloudVertex3->pz < 1.0f) && (cloudVertex3->pz > 0.0f)))
				{
					mcTextureManager->addTriangle(mcTextureNodeIndex,MC2_DRAWALPHA);
				}
			}
		}			 
	}
}
Esempio n. 2
0
//---------------------------------------------------------------------
void CraterManager::render (void)
{
	if (!useNonWeaponEffects)
		return;

	//-----------------------------------------------------
	// Run through all craters in list and render anything
	// which not clipped or an invalid_crater
	CraterDataPtr currCrater = craterList;

	for (long i=0;i<(long)maxCraters;i++,currCrater++)
	{
		if (currCrater->craterShapeId != -1)
		{
			long handleOffset = 1;
			float uvAdd = 0.125;
			if (currCrater->craterShapeId >= MAX_FOOTPRINTS)
			{
				handleOffset = 0;
				uvAdd = 0.50;
			}
				
			bool onScreen1 = eye->projectZ(currCrater->position[0],currCrater->screenPos[0]);
			bool onScreen2 = eye->projectZ(currCrater->position[1],currCrater->screenPos[1]);
			bool onScreen3 = eye->projectZ(currCrater->position[2],currCrater->screenPos[2]);
			bool onScreen4 = eye->projectZ(currCrater->position[3],currCrater->screenPos[3]);

			//--------------------------------------------------
			// First, if we are using perspective, figure out
			// if object too far from camera.  Far Clip Plane.
			float hazeFactor = 0.0f;
			if (eye->usePerspective)
			{
				Stuff::Point3D Distance;
				Stuff::Point3D objPosition;
				Stuff::Point3D eyePosition(eye->getCameraOrigin());
				objPosition.x = -currCrater->position[0].x;
				objPosition.y = currCrater->position[0].z;
				objPosition.z = currCrater->position[0].y;
		
				Distance.Subtract(objPosition,eyePosition);
				float eyeDistance = Distance.GetApproximateLength();
				if (eyeDistance > Camera::MaxClipDistance)
				{
					onScreen1 = false;
					onScreen2 = false;
					onScreen3 = false;
					onScreen4 = false;
				}
				else if (eyeDistance > Camera::MinHazeDistance)
				{
					hazeFactor = (eyeDistance - Camera::MinHazeDistance) * Camera::DistanceFactor;
				}
				else
				{
					hazeFactor = 0.0f;
				}
			}
					
			//----------------
			// Check clipping
			if (onScreen1 || onScreen2 || onScreen3 || onScreen4)
			{
				DWORD lightRGB = 0xffffffff;
				DWORD specR = 0, specB = 0, specG = 0;
				
				unsigned char lightr = 0xff,lightg = 0xff,lightb = 0xff;
				lightr = eye->ambientRed;
				lightg = eye->ambientGreen;
				lightb = eye->ambientBlue;
						
				lightRGB = lightb + (lightr<<16) + (lightg << 8) + (0xff << 24);
				
				if (Terrain::terrainTextures2)
				{
					if (TerrainQuad::rainLightLevel < 1.0f)
					{
						lightr = (float)lightr * TerrainQuad::rainLightLevel;
						lightb = (float)lightb * TerrainQuad::rainLightLevel;
						lightg = (float)lightg * TerrainQuad::rainLightLevel;
					}
					
					if (TerrainQuad::lighteningLevel > 0x0)
					{
						specR = specG = specB = TerrainQuad::lighteningLevel;
					}
					
					lightRGB = lightb + (lightr<<16) + (lightg << 8) + (0xff << 24);
				}

				DWORD fogRGB = (0xff<<24) + (specR<<16) + (specG<<8) + specB;
				
				if (useFog)
				{
					DWORD fogValue = 0xff;
					float fogStart = eye->fogStart;
					float fogFull = eye->fogFull;

					if (currCrater->position[0].z < fogStart)
					{
						float fogFactor = fogStart - currCrater->position[0].z;
						if (fogFactor < 0.0)
							fogRGB = (0xff<<24) + (specR<<16) + (specG<<8) + specB; 
						else
						{
							fogFactor /= (fogStart - fogFull);
							if (fogFactor <= 1.0)
							{
								fogFactor *= fogFactor;
								fogFactor = 1.0 - fogFactor;
								fogFactor *= 256.0;
							}
							else
							{
								fogFactor = 256.0;
							}

							unsigned char fogResult = fogFactor;
							fogValue = fogFactor;
							fogRGB = (fogResult << 24) + (specR<<16) + (specG<<8) + specB;
						}
					}
					else
					{
						fogRGB = (0xff<<24) + (specR<<16) + (specG<<8) + specB;
					}
					
					if (hazeFactor != 0.0f)
					{
						float fogFactor = 1.0 - hazeFactor;
						DWORD distFog = float2long(fogFactor * 255.0f);
						
						if (distFog < fogValue)
							fogValue = distFog;
							
						fogRGB = (fogValue << 24) + (specR << 16) + (specG << 8) + (specB);
					}
				}
   
				if (drawOldWay)
				{
					//------------------------------------
					// Replace with Polygon Quad Elements
					gos_VERTEX gVertex[4];
	
					gVertex[0].x		= currCrater->screenPos[0].x;
					gVertex[0].y		= currCrater->screenPos[0].y;
					gVertex[0].z		= currCrater->screenPos[0].z;
					gVertex[0].rhw		= currCrater->screenPos[0].w;
					gVertex[0].u		= craterUVTable[(currCrater->craterShapeId*2)];
					gVertex[0].v		= craterUVTable[(currCrater->craterShapeId*2)+1];
					gVertex[0].argb		= lightRGB;
					gVertex[0].frgb		= fogRGB;
	
					gVertex[1].x		= currCrater->screenPos[1].x;
					gVertex[1].y		= currCrater->screenPos[1].y;
					gVertex[1].z		= currCrater->screenPos[1].z;
					gVertex[1].rhw		= currCrater->screenPos[1].w;
					gVertex[1].u		= gVertex[0].u + uvAdd;
					gVertex[1].v		= gVertex[0].v;
					gVertex[1].argb		= lightRGB;
					gVertex[1].frgb		= fogRGB;
	
					gVertex[2].x		= currCrater->screenPos[2].x;
					gVertex[2].y		= currCrater->screenPos[2].y;
					gVertex[2].z		= currCrater->screenPos[2].z;
					gVertex[2].rhw		= currCrater->screenPos[2].w;
					gVertex[2].u		= gVertex[1].u;
					gVertex[2].v		= gVertex[0].v + uvAdd;
					gVertex[2].argb		= lightRGB;
					gVertex[2].frgb		= fogRGB;
	
					gVertex[3].x		= currCrater->screenPos[3].x;
					gVertex[3].y		= currCrater->screenPos[3].y;
					gVertex[3].z		= currCrater->screenPos[3].z;
					gVertex[3].rhw		= currCrater->screenPos[3].w;
					gVertex[3].u		= gVertex[0].u;
					gVertex[3].v		= gVertex[2].v;
					gVertex[3].argb		= lightRGB;
					gVertex[3].frgb		= fogRGB;
					
 					TexturedPolygonQuadElement element;
					element.init(gVertex,craterTextureHandles[handleOffset],false,false);
	
					//-----------------------------------------------------
					// FOG time.  Set Render state to FOG on!
					if (useFog)
					{
						DWORD fogColor = eye->fogColor;
						gos_SetRenderState( gos_State_Fog, (int)&fogColor);
					}
					else
					{
						gos_SetRenderState( gos_State_Fog, 0);
					}
	
					element.draw();
					gos_SetRenderState( gos_State_Fog, 0);		//ALWAYS SHUT FOG OFF WHEN DONE!
				}
				else
				{
					//------------------------------------
					gos_VERTEX gVertex[3];
					gos_VERTEX sVertex[3];
	
					gVertex[0].x		= sVertex[0].x        = currCrater->screenPos[0].x;
					gVertex[0].y		= sVertex[0].y        = currCrater->screenPos[0].y;
					gVertex[0].z		= sVertex[0].z        = currCrater->screenPos[0].z;
					gVertex[0].rhw		= sVertex[0].rhw      = currCrater->screenPos[0].w;
					gVertex[0].u		= sVertex[0].u        = craterUVTable[(currCrater->craterShapeId*2)];
					gVertex[0].v		= sVertex[0].v        = craterUVTable[(currCrater->craterShapeId*2)+1];
					gVertex[0].argb		= sVertex[0].argb     = lightRGB;
					gVertex[0].frgb		= sVertex[0].frgb     = fogRGB;
	
					gVertex[1].x		= currCrater->screenPos[1].x;
					gVertex[1].y		= currCrater->screenPos[1].y;
					gVertex[1].z		= currCrater->screenPos[1].z;
					gVertex[1].rhw		= currCrater->screenPos[1].w;
					gVertex[1].u		= gVertex[0].u + uvAdd;
					gVertex[1].v		= gVertex[0].v;
					gVertex[1].argb		= lightRGB;
					gVertex[1].frgb		= fogRGB;
	
					gVertex[2].x		= sVertex[1].x        = currCrater->screenPos[2].x;
					gVertex[2].y		= sVertex[1].y        = currCrater->screenPos[2].y;
					gVertex[2].z		= sVertex[1].z        = currCrater->screenPos[2].z;
					gVertex[2].rhw		= sVertex[1].rhw      = currCrater->screenPos[2].w;
					gVertex[2].u		= sVertex[1].u        = gVertex[1].u;
					gVertex[2].v		= sVertex[1].v        = gVertex[0].v + uvAdd;
					gVertex[2].argb		= sVertex[1].argb     = lightRGB;
					gVertex[2].frgb		= sVertex[1].frgb     = fogRGB;
	
					sVertex[2].x		= currCrater->screenPos[3].x;
					sVertex[2].y		= currCrater->screenPos[3].y;
					sVertex[2].z		= currCrater->screenPos[3].z;
					sVertex[2].rhw		= currCrater->screenPos[3].w;
					sVertex[2].u		= gVertex[0].u;
					sVertex[2].v		= gVertex[2].v;
					sVertex[2].argb		= lightRGB;
					sVertex[2].frgb		= fogRGB;
 				
					if (currCrater->craterShapeId > TURKINA_FOOTPRINT)	//We are standard crater.
					{
						mcTextureManager->addVertices(craterTextureIndices[handleOffset],gVertex,MC2_ISCRATERS | MC2_DRAWALPHA | MC2_ISTERRAIN);
						mcTextureManager->addVertices(craterTextureIndices[handleOffset],sVertex,MC2_ISCRATERS | MC2_DRAWALPHA | MC2_ISTERRAIN);
					}
					else		//We are a footprint
					{
						mcTextureManager->addVertices(craterTextureIndices[handleOffset],gVertex,MC2_ISCRATERS | MC2_DRAWALPHA);
						mcTextureManager->addVertices(craterTextureIndices[handleOffset],sVertex,MC2_ISCRATERS | MC2_DRAWALPHA);
					}
				}
			}
		}
	}
}