Zero Hour rebuilt from EA's source: x64, Direct3D 11, VS2022/CMake, ~60 original bugs fixed, an AI that builds a base. Bring your own game.
C++ cmakecnccommand-and-conquercppdirectx11game-enginegame-preservationgeneralsrtssage-enginex64zero-hour
/*
** Command & Conquer Generals Zero Hour(tm)
** Copyright 2025 Electronic Arts Inc.
**
** This program is free software: you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation, either version 3 of the License, or
** (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
// Modified 2025-2026 by Olcay Seygan for Zero Hour Reforged; see the git history.
// Modified 2026 by İlyas Akın for the macOS/Linux port; see NOTICE.md and the git history.
////////////////////////////////////////////////////////////////////////////////
// //
// (c) 2001-2003 Electronic Arts Inc. //
// //
////////////////////////////////////////////////////////////////////////////////
// FILE: W3DShadow.cpp ///////////////////////////////////////////////////////////
//
// Real time shadow representations
//
// Author: Mark Wilczynski, February 2002
//
//
// USER INCLUDES //////////////////////////////////////////////////////////////
#include "Platform/SunShadow.h"
#include "always.h"
#include "GameClient/View.h"
#include "WW3D2/camera.h"
#include "WW3D2/light.h"
#include "WW3D2/dx8wrapper.h"
#include "WW3D2/hlod.h"
#include "WW3D2/mesh.h"
#include "WW3D2/meshmdl.h"
#include "Lib/BaseType.h"
#include "W3DDevice/GameClient/W3DGranny.h"
#include "W3DDevice/GameClient/HeightMap.h"
#include "d3dx9math.h"
#include "Common/GlobalData.h"
#include "W3DDevice/GameClient/W3DVolumetricShadow.h"
#include "W3DDevice/GameClient/W3DProjectedShadow.h"
#include "W3DDevice/GameClient/W3DShadow.h"
#include "WW3D2/statistics.h"
#include "Common/Debug.h"
#include "Common/PerfTimer.h"
#define SUN_DISTANCE_FROM_GROUND 10000.0f //distance of sun (our only light source).
// Global Variables and Functions /////////////////////////////////////////////
W3DShadowManager *TheW3DShadowManager=NULL;
const FrustumClass *shadowCameraFrustum;
Vector3 LightPosWorld[ MAX_SHADOW_LIGHTS ] =
{
Vector3( 94.0161f, 50.499f, 200.0f)
};
/** Whether anything a body casts can land in the view. The body is its bounding sphere and its
shadow is that sphere swept down to groundZ, the lowest the shadow can land, moving runX, runY
sideways for every unit it drops: the sun's own slope, or whatever the caller's shadow is held
to. Only the four sides of the view are tested, which is all a shadow lying on the ground
needs, and each on its own, so a capsule past a corner of the view can pass when it misses it:
the test can let in a caster that reaches nothing, never leave out one that does. A caster
just off the edge of the screen whose shadow falls onto it passes, so its shadow does not go
out the moment its body leaves the frame. */
Bool shadowCanReachView( const FrustumClass &view, const SphereClass &body, Real groundZ, Real runX, Real runY )
{
const Real drop = WWMath::Max( body.Center.Z - groundZ + body.Radius, 0.0f );
const Vector3 downwind = body.Center + Vector3( runX, runY, -1.0f ) * drop;
for (Int side = 1; side <= 4; ++side)
{
const PlaneClass &plane = view.Planes[ side ];
if (Vector3::Dot_Product( plane.N, body.Center ) - plane.D > body.Radius
&& Vector3::Dot_Product( plane.N, downwind ) - plane.D > body.Radius)
return FALSE;
}
return TRUE;
}
/** The same for a stencil volume, which is pushed away from the light's position rather than along
one direction for the whole map: from a caster in the far corner the light stands some way off
the direction it has from the map's origin. */
Bool volumeShadowCanReachView( const FrustumClass &view, const SphereClass &body, Real groundZ )
{
const Vector3 toLight = TheW3DShadowManager->getLightPosWorld( 0 ) - body.Center;
if (toLight.Z <= 0.01f * toLight.Length())
return TRUE; // a light at the horizon throws every shadow across the whole map
return shadowCanReachView( view, body, groundZ, -toLight.X / toLight.Z, -toLight.Y / toLight.Z );
}
DECLARE_PERF_TIMER(shadowsRender)
void DoShadows(RenderInfoClass & rinfo, Bool stencilPass)
{
SunShadow::ReceiverExclusion sunReceivers(DX8Wrapper::_Get_D3D_Device());
USE_PERF_TIMER(shadowsRender)
shadowCameraFrustum=&rinfo.Camera.Get_Frustum();
Int projectionCount=0;
//Projected shadows render first because they may fill the stencil buffer
//which will be used by the shadow volumes
if (stencilPass == FALSE && TheW3DProjectedShadowManager)
{
if (TheW3DShadowManager->isShadowScene())
projectionCount=TheW3DProjectedShadowManager->renderShadows(rinfo);
}
if (stencilPass == TRUE && TheW3DVolumetricShadowManager)
{
// TheW3DShadowManager->loadTerrainShadows();
//This function gets called many times by the W3D renderer
//so we use this flag to make sure shadows rendered only once per frame.
if (TheW3DShadowManager->isShadowScene())
TheW3DVolumetricShadowManager->renderShadows(projectionCount);
}
if (TheW3DShadowManager && stencilPass) //reset so no more shadow processing this frame.
TheW3DShadowManager->queueShadows(FALSE);
}
W3DShadowManager::W3DShadowManager( void )
{
DEBUG_ASSERTCRASH(TheW3DVolumetricShadowManager == NULL && TheW3DProjectedShadowManager == NULL,
("Creating new shadow managers without deleting old ones"));
m_shadowColor = 0x7fa0a0a0;
m_isShadowScene = FALSE;
m_stencilShadowMask = 0; //all bits can be used for storing shadows.
Vector3 lightRay(-TheGlobalData->m_terrainLightPos[0].x,
-TheGlobalData->m_terrainLightPos[0].y, -TheGlobalData->m_terrainLightPos[0].z);
lightRay.Normalize();
LightPosWorld[0]=lightRay*SUN_DISTANCE_FROM_GROUND;
TheW3DVolumetricShadowManager = NEW W3DVolumetricShadowManager;
TheProjectedShadowManager = TheW3DProjectedShadowManager = NEW W3DProjectedShadowManager;
}
W3DShadowManager::~W3DShadowManager( void )
{
delete TheW3DVolumetricShadowManager;
TheW3DVolumetricShadowManager = NULL;
delete TheW3DProjectedShadowManager;
TheProjectedShadowManager = TheW3DProjectedShadowManager = NULL;
}
/** Do one-time initilalization of shadow systems that need to be
active for full duration of game*/
Bool W3DShadowManager::init( void )
{
Bool result=TRUE;
/* Both managers are still brought up under -nodevice - the rest of the client assumes they
exist, and W3DTerrainVisual::reset walks the projected one's texture manager on the way out.
What is skipped is ReAcquireResources, which is the half that asks the device for the buffers
and the back buffer to draw a shadow with. */
const Bool haveDevice = !(TheGlobalData && TheGlobalData->m_noRenderDevice);
if (TheW3DVolumetricShadowManager && TheW3DVolumetricShadowManager->init())
{
if (haveDevice && TheW3DVolumetricShadowManager->ReAcquireResources())
result = TRUE;
}
if ( TheW3DProjectedShadowManager && TheW3DProjectedShadowManager->init())
{
if (haveDevice && TheW3DProjectedShadowManager->ReAcquireResources())
result = TRUE;
}
return result;
}
/** Do per-map reset. This frees up shadows from all objects since
they may not exist on the next map*/
void W3DShadowManager::Reset( void )
{
if (TheW3DVolumetricShadowManager)
TheW3DVolumetricShadowManager->reset();
if (TheW3DProjectedShadowManager)
TheW3DProjectedShadowManager->reset();
}
Bool W3DShadowManager::ReAcquireResources()
{
Bool result = TRUE;
if (TheW3DVolumetricShadowManager && !TheW3DVolumetricShadowManager->ReAcquireResources())
result = FALSE;
if (TheW3DProjectedShadowManager && !TheW3DProjectedShadowManager->ReAcquireResources())
result = FALSE;
return result;
}
void W3DShadowManager::ReleaseResources(void)
{
if (TheW3DVolumetricShadowManager)
TheW3DVolumetricShadowManager->ReleaseResources();
if (TheW3DProjectedShadowManager)
TheW3DProjectedShadowManager->ReleaseResources();
}
Shadow *W3DShadowManager::addShadow( RenderObjClass *robj, Shadow::ShadowTypeInfo *shadowInfo, Drawable *draw)
{
ShadowType type = SHADOW_VOLUME;
if (shadowInfo)
type = shadowInfo->m_type;
switch(type)
{
case SHADOW_VOLUME:
if (TheW3DVolumetricShadowManager)
return (Shadow *)TheW3DVolumetricShadowManager->addShadow(robj, shadowInfo, draw);
break;
case SHADOW_PROJECTION:
case SHADOW_DECAL:
if (TheW3DProjectedShadowManager)
return (Shadow *)TheW3DProjectedShadowManager->addShadow(robj, shadowInfo, draw);
break;
default:
return NULL;
}
return NULL;
}
void W3DShadowManager::removeShadow(Shadow *shadow)
{
shadow->release();
}
void W3DShadowManager::removeAllShadows(void)
{
if (TheW3DVolumetricShadowManager)
TheW3DVolumetricShadowManager->removeAllShadows();
if (TheW3DProjectedShadowManager)
TheW3DProjectedShadowManager->removeAllShadows();
}
/**Force update of all shadows even when light source and object have not moved*/
void W3DShadowManager::invalidateCachedLightPositions(void)
{
if (TheW3DVolumetricShadowManager)
TheW3DVolumetricShadowManager->invalidateCachedLightPositions();
if (TheW3DProjectedShadowManager)
TheW3DProjectedShadowManager->invalidateCachedLightPositions();
}
Vector3 &W3DShadowManager::getLightPosWorld(Int lightIndex)
{
return LightPosWorld[lightIndex];
}
void W3DShadowManager::setLightPosition(Int lightIndex, Real x, Real y, Real z)
{
if (lightIndex != 0)
return; ///@todo: Add support for multiple lights
LightPosWorld[lightIndex]=Vector3(x,y,z);
}
void W3DShadowManager::setTimeOfDay(TimeOfDay tod)
{
//Ray to light source
const GlobalData::TerrainLighting *ol=&TheGlobalData->m_terrainObjectsLighting[tod][0];
Vector3 lightRay(-ol->lightPos.x,-ol->lightPos.y,-ol->lightPos.z);
lightRay.Normalize();
lightRay *= SUN_DISTANCE_FROM_GROUND;
setLightPosition(0, lightRay.X, lightRay.Y, lightRay.Z);
}