Beispiel #1
0
void Bumper::RenderStatic(RenderDevice* pd3dDevice)
{
   if (m_ptable->m_fReflectionEnabled && !m_d.m_fReflectionEnabled)
      return;

   if (m_d.m_fBaseVisible)
   {

      const Material *mat = m_ptable->GetMaterial(m_d.m_szBaseMaterial);
      if (!mat->m_bOpacityActive)
      {
         pd3dDevice->basicShader->SetTechnique(mat->m_bIsMetal ? "basic_without_texture_isMetal" : "basic_without_texture_isNotMetal");
         RenderBase(pd3dDevice, mat);
      }
   }

   if (m_d.m_fSkirtVisible)
   {
      const Material *mat = m_ptable->GetMaterial(m_d.m_szSkirtMaterial);
      if (!mat->m_bOpacityActive)
      {
         pd3dDevice->basicShader->SetTechnique(mat->m_bIsMetal ? "basic_without_texture_isMetal" : "basic_without_texture_isNotMetal");
         RenderSocket(pd3dDevice, mat);
      }
   }

   if (m_d.m_fCapVisible)
   {
      const Material * const mat = m_ptable->GetMaterial(m_d.m_szCapMaterial);
      if (!mat->m_bOpacityActive)
      {
         pd3dDevice->basicShader->SetTechnique(mat->m_bIsMetal ? "basic_with_texture_isMetal" : "basic_with_texture_isNotMetal");
         RenderCap(pd3dDevice, mat);
      }
   }
}
Beispiel #2
0
void CBuildings::OnRender()
{
	if(Client()->State() < IClient::STATE_ONLINE)
		return;
	
	int Num = Client()->SnapNumItems(IClient::SNAP_CURRENT);
	for(int i = 0; i < Num; i++)
	{
		IClient::CSnapItem Item;
		const void *pData = Client()->SnapGetItem(IClient::SNAP_CURRENT, i, &Item);

		if(Item.m_Type == NETOBJTYPE_TURRET)
		{
			const struct CNetObj_Turret *pTurret = (const CNetObj_Turret *)pData;
			const void *pPrev = Client()->SnapFindItem(IClient::SNAP_PREV, Item.m_Type, Item.m_ID);
			RenderTurret(pTurret, pPrev ? (const CNetObj_Turret *)pPrev : pTurret);
		}
		else if(Item.m_Type == NETOBJTYPE_POWERUPPER)
			RenderPowerupper((const CNetObj_Powerupper *)pData);
		else if(Item.m_Type == NETOBJTYPE_SHOP)
			RenderShop((const CNetObj_Shop *)pData);
		else if (Item.m_Type == NETOBJTYPE_BUILDING)
		{
			const struct CNetObj_Building *pBuilding = (const CNetObj_Building *)pData;
			const void *pPrev = Client()->SnapFindItem(IClient::SNAP_PREV, Item.m_Type, Item.m_ID);
			
			switch (pBuilding->m_Type)
			{
			case BUILDING_SAWBLADE:
				RenderSawblade(pBuilding);
				break;
				
			case BUILDING_MINE1:
				RenderMine(pBuilding);
				break;
				
			case BUILDING_MINE2:
				RenderElectromine(pBuilding);
				break;
				
			case BUILDING_BARREL:
				RenderBarrel(pBuilding, pPrev ? (const CNetObj_Building *)pPrev : pBuilding);
				break;
				
			case BUILDING_POWERBARREL:
				RenderPowerBarrel(pBuilding, pPrev ? (const CNetObj_Building *)pPrev : pBuilding);
				break;
				
			case BUILDING_LAZER:
				RenderLazer(pBuilding);
				break;
				
			case BUILDING_FLAMETRAP:
				RenderFlametrap(pBuilding, pPrev ? (const CNetObj_Building *)pPrev : pBuilding);
				break;
				
			case BUILDING_BASE:
				RenderBase(pBuilding);
				break;
				
			case BUILDING_STAND:
				RenderStand(pBuilding, pPrev ? (const CNetObj_Building *)pPrev : pBuilding);
				break;
				
			case BUILDING_REACTOR:
				RenderReactor(pBuilding);
				break;
				
			case BUILDING_TESLACOIL:
				RenderTeslacoil(pBuilding, pPrev ? (const CNetObj_Building *)pPrev : pBuilding);
				break;
				
			case BUILDING_REACTOR_DESTROYED:
				RenderDestroyedReactor(pBuilding);
				break;
				
			case BUILDING_SWITCH:
				RenderSwitch(pBuilding);
				break;
				
			case BUILDING_DOOR1:
				RenderDoor1(pBuilding);
				break;
				
			case BUILDING_GENERATOR:
				RenderGenerator(pBuilding, pPrev ? (const CNetObj_Building *)pPrev : pBuilding);
				break;
				
			case BUILDING_SCREEN:
				RenderScreen(pBuilding);
				break;
				
			/*
			case BUILDING_SHOP:
				RenderShop(pBuilding);
				break;
				*/
				
			default:;
			};
			
			//m_pClient->m_pEffects->Light(vec2(pBuilding->m_X, pBuilding->m_Y), 512);
		}
	}
}
Beispiel #3
0
void Bumper::PostRenderStatic(RenderDevice* pd3dDevice)
{
   TRACE_FUNCTION();

   if (m_ringVertexBuffer == NULL && (m_d.m_fBaseVisible || m_d.m_fCapVisible))
      return;

   if (m_ptable->m_fReflectionEnabled && !m_d.m_fReflectionEnabled)
      return;

   const U32 old_time_msec = (m_d.m_time_msec < g_pplayer->m_time_msec) ? m_d.m_time_msec : g_pplayer->m_time_msec;
   m_d.m_time_msec = g_pplayer->m_time_msec;
   const float diff_time_msec = (float)(g_pplayer->m_time_msec - old_time_msec);

   pd3dDevice->SetRenderState(RenderDevice::DEPTHBIAS, 0);
   pd3dDevice->SetRenderState(RenderDevice::ZWRITEENABLE, TRUE);
   pd3dDevice->SetRenderState(RenderDevice::CULLMODE, D3DCULL_CCW);

   if (m_d.m_fRingVisible)
   {
      const int state = m_pbumperhitcircle->m_bumperanim.m_fHitEvent ? 1 : 0;    // 0 = not hit, 1 = hit

      if (state == 1)
      {
         m_ringAnimate = true;
         m_ringDown = true;
         m_pbumperhitcircle->m_bumperanim.m_fHitEvent = false;
      }

      if (m_ringAnimate)
      {
         float step = m_d.m_ringSpeed*m_ptable->m_BG_scalez[m_ptable->m_BG_current_set];
         const float limit = 45.f*m_ptable->m_BG_scalez[m_ptable->m_BG_current_set];
         if (m_ringDown)
            step = -step;
         m_pbumperhitcircle->m_bumperanim.m_ringAnimOffset += step*diff_time_msec;
         if (m_ringDown)
         {
            if (m_pbumperhitcircle->m_bumperanim.m_ringAnimOffset <= -limit)
            {
               m_pbumperhitcircle->m_bumperanim.m_ringAnimOffset = -limit;
               m_ringDown = false;
            }
         }
         else
         {
            if (m_pbumperhitcircle->m_bumperanim.m_ringAnimOffset >= 0.0f)
            {
               m_pbumperhitcircle->m_bumperanim.m_ringAnimOffset = 0.0f;
               m_ringAnimate = false;
            }
         }
         UpdateRing(pd3dDevice);
      }

      if (m_ringMaterial.m_bIsMetal)
      {
         pd3dDevice->basicShader->SetTechnique(m_ringMaterial.m_bIsMetal ? "basic_with_texture_isMetal" : "basic_with_texture_isNotMetal");
         pd3dDevice->basicShader->SetTexture("Texture0", &m_ringTexture);
      }
      else
         pd3dDevice->basicShader->SetTechnique(m_ringMaterial.m_bIsMetal ? "basic_without_texture_isMetal" : "basic_without_texture_isNotMetal");
      pd3dDevice->basicShader->SetMaterial(&m_ringMaterial);
      pd3dDevice->basicShader->SetAlphaTestValue(-1.0f);
      // render ring
      pd3dDevice->basicShader->Begin(0);
      pd3dDevice->DrawIndexedPrimitiveVB(D3DPT_TRIANGLELIST, MY_D3DFVF_NOTEX2_VERTEX, m_ringVertexBuffer, 0, bumperRingNumVertices, m_ringIndexBuffer, 0, bumperRingNumFaces);
      pd3dDevice->basicShader->End();
   }
   if (m_d.m_fSkirtVisible)
   {
      const Material *mat = m_ptable->GetMaterial(m_d.m_szSkirtMaterial);
      if (mat->m_bOpacityActive)
      {
         pd3dDevice->basicShader->SetTechnique(mat->m_bIsMetal ? "basic_with_texture_isMetal" : "basic_with_texture_isNotMetal");
         pd3dDevice->SetRenderState(RenderDevice::CULLMODE, D3DCULL_NONE);
         RenderSocket(pd3dDevice, mat);
      }
   }

   if (m_d.m_fBaseVisible)
   {
      const Material *mat = m_ptable->GetMaterial(m_d.m_szBaseMaterial);
      if (mat->m_bOpacityActive)
      {
         pd3dDevice->basicShader->SetTechnique(mat->m_bIsMetal ? "basic_with_texture_isMetal" : "basic_with_texture_isNotMetal");
         pd3dDevice->SetRenderState(RenderDevice::CULLMODE, D3DCULL_NONE);
         RenderBase(pd3dDevice, mat);
      }
   }

   if (m_d.m_fCapVisible)
   {
      const Material * const mat = m_ptable->GetMaterial(m_d.m_szCapMaterial);
      if (mat->m_bOpacityActive)
      {
         pd3dDevice->basicShader->SetTechnique(mat->m_bIsMetal ? "basic_with_texture_isMetal" : "basic_with_texture_isNotMetal");
         pd3dDevice->SetRenderState(RenderDevice::CULLMODE, D3DCULL_NONE);
         RenderCap(pd3dDevice, mat);
      }
   }
}