tiberium/CnC_Renegade
Archived
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
This repository has been archived on 2025-02-27. You can view files and clone it, but cannot push or open issues or pull requests.
CnC_Renegade/Code/wwphys/pscene_projectors.cpp

1296 lines
37 KiB
C++
Raw Permalink Blame History

/*
** Command & Conquer Renegade(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/>.
*/
/***********************************************************************************************
*** C O N F I D E N T I A L --- W E S T W O O D S T U D I O S ***
***********************************************************************************************
* *
* Project Name : WWPhys *
* *
* $Archive:: /Commando/Code/wwphys/pscene_projectors.cpp $*
* *
* Original Author:: Greg Hjelstrom *
* *
* $Author:: Greg_h $*
* *
* $Modtime:: 1/11/02 3:12p $*
* *
* $Revision:: 50 $*
* *
*---------------------------------------------------------------------------------------------*
* Functions: *
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#include "pscene.h"
#include "colmathaabox.h"
#include "rinfo.h"
#include "staticaabtreecull.h"
#include "dynamicaabtreecull.h"
#include "physgridcull.h"
#include "lightcull.h"
#include "staticanimphys.h"
#include "assetmgr.h"
#include "refcount.h"
#include "camera.h"
#include "quat.h"
#include "win.h"
#include "vertmaterial.h"
#include "wwprofile.h"
#include "texture.h"
#include "dx8wrapper.h"
#include "pot.h"
#include "materialeffect.h"
#include "wwmemlog.h"
#include "targa.h"
#include "bitmaphandler.h"
#include "dx8caps.h"
#include "vertmaterial.h"
#define DEBUG_SHADOW_RENDERING 0
#if (DEBUG_SHADOW_RENDERING)
#define SHADOW_WINDOW_STYLE WS_POPUP | WS_CAPTION | WS_BORDER | WS_VISIBLE
#else
#define SHADOW_WINDOW_STYLE WS_POPUP | WS_CAPTION | WS_BORDER
#endif
const int SHADOW_CLIP_FAR = 500;
const int STATIC_PROJECTOR_RESOLUTION = 256; //128;
const float STATIC_SHADOW_INTENSITY = 0.6f;
const float MIN_STATIC_SHADOW_COS_HALF_THETA = cos(DEG_TO_RADF(10.0f)/2.0f); // angle to allow shadow tex re-use
const int DEFAULT_MAX_DYNAMIC_SHADOWS = 6;
const int DEFAULT_DYNAMIC_SHADOW_RESOLUTION = 256;
/**
** StaticShadowTexMgrClass
** This object simply manages the list of unique shadow textures being used by the
** static shadow projectors. For example, all instances of the same tree model
** re-use the same shadow texture...
*/
class StaticShadowTexMgrClass
{
public:
StaticShadowTexMgrClass(void);
virtual ~StaticShadowTexMgrClass(void);
void Reset(void);
TextureClass * Peek_Shadow_Texture(uint32 obj_type_id,const Quaternion & orientation);
void Add_Shadow_Texture(uint32 obj_type_id,const Quaternion & orientation,TextureClass * tex);
void Remove_Shadow_Texture(TextureClass * tex);
private:
class ShadowTexClass
{
public:
ShadowTexClass(void);
ShadowTexClass(uint32 obj_type_id,const Quaternion & orientation,TextureClass * tex);
ShadowTexClass(const ShadowTexClass & that);
~ShadowTexClass(void);
const ShadowTexClass & operator = (const ShadowTexClass &);
bool operator == (const ShadowTexClass &) { return false; }
bool operator != (const ShadowTexClass & that) { return true; }
uint32 ObjectTypeID; // use the Definition ID to uniquely identify object types
Quaternion ObjectOrientation; // orientation of the object when this shadow was generated
TextureClass * Texture; // texture
};
DynamicVectorClass<ShadowTexClass> ShadowTextures;
};
/**
** DynamicShadowTexMgrClass
** This class manages a pool of render target textures which are shared by the currently
** active shadow projectors.
*/
class DynamicShadowTexMgrClass
{
public:
DynamicShadowTexMgrClass(void);
virtual ~DynamicShadowTexMgrClass(void);
// void Reset(); // Jani: Disabling reset. Re-allocating render targets if the device is out of
// free texture memory causes problems on at least TNT2.
void Set_Max_Simultaneous_Shadows(unsigned int max);
unsigned int Get_Max_Simultaneous_Shadows(void);
void Set_Shadow_Resolution(unsigned int size);
unsigned int Get_Shadow_Resolution(void);
void Per_Frame_Reset(void);
void Assign_Render_Target_Texture(TexProjectClass * tex_proj);
private:
TextureClass * Allocate_Render_Target_Texture(void);
unsigned int CurShadow;
unsigned int TextureResolution;
SimpleVecClass<TextureClass *> ShadowTextures;
};
/*
**
** Instantiate the Shadow Texture Managers.
**
*/
static StaticShadowTexMgrClass _StaticShadowTexMgr;
static DynamicShadowTexMgrClass _DynamicShadowTexMgr;
static TextureClass* Create_Projector_Render_Target(unsigned w,unsigned h)
{
WW3DFormat format=WW3D_FORMAT_UNKNOWN;
// Try if 8 or 16 bit render target formats would be supported
if (DX8Wrapper::Get_Current_Caps()->Support_Render_To_Texture_Format(WW3D_FORMAT_R3G3B2)) format=WW3D_FORMAT_R3G3B2;
else if (DX8Wrapper::Get_Current_Caps()->Support_Render_To_Texture_Format(WW3D_FORMAT_R5G6B5)) format=WW3D_FORMAT_R5G6B5;
else if (DX8Wrapper::Get_Current_Caps()->Support_Render_To_Texture_Format(WW3D_FORMAT_A4R4G4B4)) format=WW3D_FORMAT_A4R4G4B4;
else if (DX8Wrapper::Get_Current_Caps()->Support_Render_To_Texture_Format(WW3D_FORMAT_X1R5G5B5)) format=WW3D_FORMAT_X1R5G5B5;
TextureClass* texture = DX8Wrapper::Create_Render_Target(w,h,format);
if (texture) return texture;
// As a last resort, try creating with unknown format (which means using the current display resolution)
if (format!=WW3D_FORMAT_UNKNOWN) {
format=WW3D_FORMAT_UNKNOWN;
return DX8Wrapper::Create_Render_Target(w,h,format);
}
return NULL;
}
/************************************************************************************
**
** ShadowTexClass Implemenation
**
************************************************************************************/
StaticShadowTexMgrClass::ShadowTexClass::ShadowTexClass(void) :
ObjectTypeID(0),
ObjectOrientation(1),
Texture(NULL)
{
}
StaticShadowTexMgrClass::ShadowTexClass::ShadowTexClass
(
uint32 obj_type_id,
const Quaternion & orientation,
TextureClass * tex
) :
ObjectTypeID(obj_type_id),
ObjectOrientation(orientation),
Texture(NULL)
{
REF_PTR_SET(Texture,tex);
}
StaticShadowTexMgrClass::ShadowTexClass::ShadowTexClass(const ShadowTexClass & that) :
ObjectTypeID(0),
ObjectOrientation(1),
Texture(NULL)
{
*this = that;
}
const StaticShadowTexMgrClass::ShadowTexClass &
StaticShadowTexMgrClass::ShadowTexClass::operator = (const ShadowTexClass & that)
{
ObjectTypeID = that.ObjectTypeID;
ObjectOrientation = that.ObjectOrientation;
REF_PTR_SET(Texture,that.Texture);
return *this;
}
StaticShadowTexMgrClass::ShadowTexClass::~ShadowTexClass(void)
{
REF_PTR_RELEASE(Texture);
}
/************************************************************************************
**
** StaticShadowTexMgrClass Implemenation
**
************************************************************************************/
StaticShadowTexMgrClass::StaticShadowTexMgrClass(void)
{
}
StaticShadowTexMgrClass::~StaticShadowTexMgrClass(void)
{
}
void StaticShadowTexMgrClass::Reset(void)
{
ShadowTextures.Delete_All();
}
TextureClass * StaticShadowTexMgrClass::Peek_Shadow_Texture
(
uint32 obj_type_id,
const Quaternion & orientation
)
{
for (int i=0; i<ShadowTextures.Count(); i++) {
Quaternion deltaq = ShadowTextures[i].ObjectOrientation * Inverse(orientation);
if ( (ShadowTextures[i].ObjectTypeID == obj_type_id) &&
(deltaq.W > MIN_STATIC_SHADOW_COS_HALF_THETA))
{
return ShadowTextures[i].Texture;
}
}
return NULL;
}
void StaticShadowTexMgrClass::Add_Shadow_Texture
(
uint32 obj_type_id,
const Quaternion & orientation,
TextureClass * tex
)
{
WWASSERT(Peek_Shadow_Texture(obj_type_id,orientation) == NULL);
ShadowTexClass record(obj_type_id,orientation,tex);
ShadowTextures.Add(record);
}
void StaticShadowTexMgrClass::Remove_Shadow_Texture
(
TextureClass * tex
)
{
for (int i=0; i<ShadowTextures.Count(); i++) {
if (ShadowTextures[i].Texture == tex) {
ShadowTextures.Delete(i);
return;
}
}
}
/************************************************************************************
**
** DynamicShadowTexMgrClass Implementation
**
************************************************************************************/
DynamicShadowTexMgrClass::DynamicShadowTexMgrClass(void) :
CurShadow(0),
TextureResolution(DEFAULT_DYNAMIC_SHADOW_RESOLUTION)
{
WWMEMLOG(MEM_GAMEDATA);
ShadowTextures.Resize(DEFAULT_MAX_DYNAMIC_SHADOWS);
for (int i=0; i<ShadowTextures.Length(); i++) {
ShadowTextures[i] = NULL;
}
}
DynamicShadowTexMgrClass::~DynamicShadowTexMgrClass(void)
{
// Reset();
for (int i=0; i<ShadowTextures.Length(); i++) {
REF_PTR_RELEASE(ShadowTextures[i]);
}
}
/*
void DynamicShadowTexMgrClass::Reset(void)
{
for (int i=0; i<ShadowTextures.Length(); i++) {
REF_PTR_RELEASE(ShadowTextures[i]);
}
}
*/
// Set the maximum number of dynamic render targets. Allocate all
// textures at this point!
void DynamicShadowTexMgrClass::Set_Max_Simultaneous_Shadows(unsigned int max)
{
int curlen = ShadowTextures.Length();
for (int i=max;i<curlen; i++) {
REF_PTR_RELEASE(ShadowTextures[i]);
}
ShadowTextures.Resize(max);
if (curlen>ShadowTextures.Length()) curlen=ShadowTextures.Length();
for (i=0; i<curlen; i++) {
if (!ShadowTextures[i]) {
ShadowTextures[i] = Allocate_Render_Target_Texture();
}
}
for (; i<ShadowTextures.Length(); i++) {
ShadowTextures[i] = Allocate_Render_Target_Texture();
}
}
unsigned int DynamicShadowTexMgrClass::Get_Max_Simultaneous_Shadows(void)
{
return ShadowTextures.Length();
}
void DynamicShadowTexMgrClass::Set_Shadow_Resolution(unsigned int res)
{
unsigned int oksize = ::Find_POT(res);
if (oksize > 256) {
oksize = 256;
}
if (oksize < 16) {
oksize = 16;
}
if (oksize != TextureResolution) {
int i;
for (i=0; i<ShadowTextures.Length(); i++) {
REF_PTR_RELEASE(ShadowTextures[i]);
}
TextureResolution = oksize;
for (i=0; i<ShadowTextures.Length(); i++) {
ShadowTextures[i] = Allocate_Render_Target_Texture();
}
}
}
unsigned int DynamicShadowTexMgrClass::Get_Shadow_Resolution(void)
{
return TextureResolution;
}
void DynamicShadowTexMgrClass::Per_Frame_Reset(void)
{
CurShadow = 0;
}
void DynamicShadowTexMgrClass::Assign_Render_Target_Texture(TexProjectClass * tex_proj)
{
if (CurShadow < (unsigned int)ShadowTextures.Length()) {
if (ShadowTextures[CurShadow] == NULL) {
ShadowTextures[CurShadow] = Allocate_Render_Target_Texture();
}
tex_proj->Set_Render_Target(ShadowTextures[CurShadow]);
CurShadow++;
}
}
TextureClass * DynamicShadowTexMgrClass::Allocate_Render_Target_Texture(void)
{
TextureClass * texture=Create_Projector_Render_Target(TextureResolution,TextureResolution);
if (texture != NULL) {
SET_REF_OWNER(texture);
texture->Set_U_Addr_Mode(TextureClass::TEXTURE_ADDRESS_CLAMP);
texture->Set_V_Addr_Mode(TextureClass::TEXTURE_ADDRESS_CLAMP);
}
return texture;
}
/************************************************************************************
**
** PhysicsSceneClass Texture Projection Code
**
************************************************************************************/
void PhysicsSceneClass::Release_Projector_Resources(void)
{
if (ShadowRenderContext != NULL) {
delete ShadowRenderContext;
ShadowRenderContext=NULL;
}
REF_PTR_RELEASE(ShadowMaterialPass);
REF_PTR_RELEASE(ShadowCamera);
REF_PTR_RELEASE(ShadowBlobTexture);
_StaticShadowTexMgr.Reset();
// _DynamicShadowTexMgr.Reset();
}
void PhysicsSceneClass::Set_Shadow_Resolution(unsigned int res)
{
_DynamicShadowTexMgr.Set_Shadow_Resolution(res);
}
unsigned int PhysicsSceneClass::Get_Shadow_Resolution(void)
{
return _DynamicShadowTexMgr.Get_Shadow_Resolution();
}
void PhysicsSceneClass::Set_Max_Simultaneous_Shadows(unsigned int count)
{
_DynamicShadowTexMgr.Set_Max_Simultaneous_Shadows(count);
}
unsigned int PhysicsSceneClass::Get_Max_Simultaneous_Shadows(void)
{
return _DynamicShadowTexMgr.Get_Max_Simultaneous_Shadows();
}
SpecialRenderInfoClass *
PhysicsSceneClass::Get_Shadow_Render_Context(int width,int height)
{
if (ShadowRenderContext == NULL) {
/*
** Create a camera for shadow rendering to use
*/
if (ShadowCamera == NULL) {
ShadowCamera = NEW_REF(CameraClass,());
ShadowCamera->Set_Clip_Planes(0.2f,SHADOW_CLIP_FAR);
ShadowCamera->Set_View_Plane(DEG_TO_RAD(90.0f),DEG_TO_RAD(90.0f));
ShadowCamera->Set_Viewport(Vector2(0,0),Vector2(1,1));
}
/*
** Create the render context
*/
ShadowRenderContext = new SpecialRenderInfoClass(*ShadowCamera,SpecialRenderInfoClass::RENDER_SHADOW);
}
return ShadowRenderContext;
}
MaterialPassClass * PhysicsSceneClass::Get_Shadow_Material_Pass(void)
{
if (ShadowMaterialPass == NULL) {
VertexMaterialClass * vmtl = NEW_REF(VertexMaterialClass,());
vmtl->Set_Ambient(0,0,0);
vmtl->Set_Diffuse(0,0,0);
vmtl->Set_Specular(0,0,0);
vmtl->Set_Emissive(0,0,0);
vmtl->Set_Lighting(true);
ShaderClass shader = ShaderClass::_PresetOpaqueShader;
shader.Set_Depth_Compare(ShaderClass::PASS_ALWAYS);
shader.Set_Depth_Mask(ShaderClass::DEPTH_WRITE_DISABLE);
shader.Set_Texturing(ShaderClass::TEXTURING_DISABLE);
ShadowMaterialPass = NEW_REF(MaterialPassClass,());
ShadowMaterialPass->Set_Material(vmtl);
ShadowMaterialPass->Set_Shader(shader);
ShadowMaterialPass->Enable_On_Translucent_Meshes(false);
REF_PTR_RELEASE(vmtl);
}
ShadowMaterialPass->Add_Ref();
return ShadowMaterialPass;
}
void PhysicsSceneClass::Enable_Static_Projectors(bool onoff)
{
StaticProjectorsEnabled = onoff;
}
bool PhysicsSceneClass::Are_Static_Projectors_Enabled(void)
{
return StaticProjectorsEnabled;
}
void PhysicsSceneClass::Enable_Dynamic_Projectors(bool onoff)
{
DynamicProjectorsEnabled = onoff;
}
bool PhysicsSceneClass::Are_Dynamic_Projectors_Enabled(void)
{
return DynamicProjectorsEnabled;
}
void PhysicsSceneClass::Set_Shadow_Mode(ShadowEnum shadow_mode)
{
if (((int)shadow_mode >= 0) && ((int)shadow_mode < SHADOW_MODE_COUNT)) {
if (ShadowMode!=shadow_mode) {
ShadowMode = shadow_mode;
switch (ShadowMode) {
default:
case SHADOW_MODE_NONE: // no shadows at all
case SHADOW_MODE_BLOBS: // projected blob shadows
Set_Max_Simultaneous_Shadows(0);
break;
case SHADOW_MODE_BLOBS_PLUS: // projected blobs with main character having a rendered shadow
Set_Max_Simultaneous_Shadows(1);
break;
case SHADOW_MODE_HARDWARE: // use render-to-texture hardware
Set_Max_Simultaneous_Shadows(4);
break;
}
}
}
}
PhysicsSceneClass::ShadowEnum
PhysicsSceneClass::Get_Shadow_Mode(void)
{
return ShadowMode;
}
void PhysicsSceneClass::Set_Shadow_Attenuation(float atten_start_distance,float atten_end_distance)
{
if (atten_start_distance < 0.0f) {
atten_start_distance = 0.0f;
}
if (atten_end_distance < atten_start_distance) {
atten_end_distance = atten_start_distance;
}
ShadowAttenStart = atten_start_distance;
ShadowAttenEnd = atten_end_distance;
}
void PhysicsSceneClass::Get_Shadow_Attenuation(float * set_atten_start,float * set_atten_end)
{
if (set_atten_start != NULL) {
*set_atten_start = ShadowAttenStart;
}
if (set_atten_end != NULL) {
*set_atten_end = ShadowAttenEnd;
}
}
void PhysicsSceneClass::Set_Shadow_Normal_Intensity(float normal_intensity)
{
if (normal_intensity < 0.0f) {
normal_intensity = 0.0f;
}
if (normal_intensity > 1.0f) {
normal_intensity = 1.0f;
}
ShadowNormalIntensity = normal_intensity;
}
float PhysicsSceneClass::Get_Shadow_Normal_Intensity(void)
{
return ShadowNormalIntensity;
}
void PhysicsSceneClass::Add_Static_Texture_Projector(TexProjectClass * newprojector)
{
WWASSERT(newprojector);
WWASSERT(!StaticProjectorList.Is_In_List(newprojector));
StaticProjectorList.Add(newprojector);
StaticProjectorCullingSystem->Add_Object(newprojector);
}
void PhysicsSceneClass::Remove_Static_Texture_Projector(TexProjectClass * projector)
{
WWASSERT(projector);
if (projector->Get_Culling_System() == StaticProjectorCullingSystem) {
WWASSERT(StaticProjectorList.Is_In_List(projector));
StaticProjectorList.Remove(projector);
StaticProjectorCullingSystem->Remove_Object(projector);
}
}
void PhysicsSceneClass::Add_Dynamic_Texture_Projector(TexProjectClass * newprojector)
{
WWASSERT(newprojector);
WWASSERT(!DynamicProjectorList.Is_In_List(newprojector));
DynamicProjectorList.Add(newprojector);
DynamicProjectorCullingSystem->Add_Object(newprojector);
}
void PhysicsSceneClass::Remove_Dynamic_Texture_Projector(TexProjectClass * projector)
{
WWASSERT(projector);
if (projector->Get_Culling_System() == DynamicProjectorCullingSystem) {
WWASSERT(DynamicProjectorList.Is_In_List(projector));
DynamicProjectorList.Remove(projector);
DynamicProjectorCullingSystem->Remove_Object(projector);
}
}
void PhysicsSceneClass::Remove_Texture_Projector(TexProjectClass * projector)
{
WWASSERT(projector);
if (DynamicProjectorList.Is_In_List(projector)) {
DynamicProjectorCullingSystem->Remove_Object(projector);
DynamicProjectorList.Remove(projector);
} else if (StaticProjectorList.Is_In_List(projector)) {
StaticProjectorCullingSystem->Remove_Object(projector);
StaticProjectorList.Remove(projector);
}
}
bool PhysicsSceneClass::Contains(TexProjectClass * projector)
{
return (DynamicProjectorList.Is_In_List(projector) || StaticProjectorList.Is_In_List(projector));
}
float PhysicsSceneClass::Compute_Projector_Attenuation(TexProjectClass * dynamic_projector,const Vector3 & view_pos,const Vector3 & view_dir)
{
Vector3 r;
Vector3::Subtract(dynamic_projector->Get_Bounding_Volume().Center,view_pos,&r);
float dist = Vector3::Dot_Product(r,view_dir);
if (dist > ShadowAttenEnd) {
return 0.0f;
}
if (dist < ShadowAttenStart) {
return 1.0f;
}
return 1.0f - (dist - ShadowAttenStart) / (ShadowAttenEnd - ShadowAttenStart);
}
void PhysicsSceneClass::Apply_Projectors
(
const CameraClass & camera
)
{
WWPROFILE("pscene::Apply_Projectors");
Vector3 view_pos;
Vector3 view_dir;
camera.Get_Transform().Get_Translation(&view_pos);
camera.Get_Transform().Get_Z_Vector(&view_dir);
view_dir = -view_dir;
if (StaticProjectorsEnabled) {
/*
** collect the visible static projectors
*/
StaticProjectorCullingSystem->Reset_Collection();
StaticProjectorCullingSystem->Collect_Objects(camera.Get_Frustum());
TexProjectClass * static_projector = StaticProjectorCullingSystem->Get_First_Collected_Object();
while (static_projector != NULL) {
/*
** only keep considering this projector if its intensity is above ZERO
*/
if (!static_projector->Is_Intensity_Zero()) {
/*
** attenuate the projector with distance from the camera (if needed)
*/
float attenuation = 1.0f;
if (static_projector->Is_Attenuation_Enabled()) {
attenuation = Compute_Projector_Attenuation(static_projector,view_pos,view_dir);
static_projector->Set_Attenuation(attenuation);
}
/*
** if the projector is completely attenuated, don't process it
*/
if (attenuation > 0.0f) {
if (ProjectorDebugDisplayEnabled) {
DEBUG_RENDER_OBBOX(static_projector->Get_Bounding_Volume(),Vector3(0,1,0),0.25f);
}
Apply_Projector_To_Objects(static_projector,camera);
}
}
static_projector = StaticProjectorCullingSystem->Get_Next_Collected_Object(static_projector);
}
}
/*
** Build a list of the dynamic shadow textures that need to be rendered
*/
TexProjListClass rt_projector_list;
unsigned int count = 0;
if (DynamicProjectorsEnabled) {
/*
** Collect the visible dynamic projectors
*/
DynamicProjectorCullingSystem->Reset_Collection();
DynamicProjectorCullingSystem->Collect_Objects(camera.Get_Frustum());
TexProjectClass * dynamic_projector = DynamicProjectorCullingSystem->Get_First_Collected_Object();
while (dynamic_projector != NULL) {
/*
** only keep considering this projector if its intensity is above ZERO
*/
if (!dynamic_projector->Is_Intensity_Zero()) {
/*
** attenuate the projector with distance from the camera (if needed)
*/
float attenuation = 1.0f;
if (dynamic_projector->Is_Attenuation_Enabled()) {
attenuation = Compute_Projector_Attenuation(dynamic_projector,view_pos,view_dir);
dynamic_projector->Set_Attenuation(attenuation);
}
/*
** if the projector is completely attenuated, don't process it
*/
if (attenuation > 0.0f) {
if (ProjectorDebugDisplayEnabled) {
DEBUG_RENDER_OBBOX(dynamic_projector->Get_Bounding_Volume(),Vector3(1,0,0),0.25f);
}
/*
** If this projector needs to recompute its texture, add it to the list,
** otherwise set it up now.
*/
if (dynamic_projector->Needs_Render_Target()) {
rt_projector_list.Add(dynamic_projector);
count++;
} else {
Apply_Projector_To_Objects(dynamic_projector,camera);
}
}
}
dynamic_projector = DynamicProjectorCullingSystem->Get_Next_Collected_Object(dynamic_projector);
}
}
/*
** Reject texture projectors until we are below the maximum allowed simultaneous shadows
*/
Vector3 cam_pos;
camera.Get_Transform().Get_Translation(&cam_pos);
TexProjListIterator it(&rt_projector_list);
while (count > _DynamicShadowTexMgr.Get_Max_Simultaneous_Shadows()) {
/*
** Find the projector farthest from the camera
*/
it.First();
TexProjectClass * farthest_shadow = it.Peek_Obj();
float farthest_dist = (farthest_shadow->Get_Bounding_Volume().Center - cam_pos).Length2();
it.Next();
while (!it.Is_Done()) {
float dist = (it.Peek_Obj()->Get_Bounding_Volume().Center - cam_pos).Length2();
if (dist > farthest_dist) {
farthest_dist = dist;
farthest_shadow = it.Peek_Obj();
}
it.Next();
}
/*
** Remove it from the list and disable it.
*/
rt_projector_list.Remove(farthest_shadow);
farthest_shadow->Set_Render_Target(NULL);
count--;
}
/*
** Process the most "important" active dynamic shadows
*/
_DynamicShadowTexMgr.Per_Frame_Reset();
it.First();
while (!it.Is_Done()) {
TexProjectClass * projector = it.Peek_Obj();
_DynamicShadowTexMgr.Assign_Render_Target_Texture(projector);
if (projector->Peek_Render_Target() != NULL) {
Apply_Projector_To_Objects(projector,camera);
}
it.Next();
}
DX8Wrapper::Set_Render_Target((IDirect3DSurface8 *)NULL);
}
void PhysicsSceneClass::Apply_Projector_To_Objects
(
TexProjectClass * tex_proj,
const CameraClass & camera
)
{
bool projector_update_needed = false; // Needed if just one mesh uses it
SimpleEffectClass * effect = NEW_REF(SimpleEffectClass,(tex_proj->Peek_Material_Pass()));
effect->Enable_Auto_Remove(true);
/*
** collect the static objects intersecting the projector's volume
*/
if (tex_proj->Is_Affect_Static_Objects_Enabled()) {
StaticCullingSystem->Reset_Collection();
StaticCullingSystem->Collect_Objects(tex_proj->Get_Bounding_Volume());
StaticPhysClass * static_obj = (StaticPhysClass *)StaticCullingSystem->Get_First_Collected_Object();
while (static_obj) {
/*
** for each static object, if it also in our visible list, add this projector to it
** since the visible static objects are split into two lists we check both.
*/
if (VisibleStaticObjectList.Contains(static_obj) || VisibleWSMeshList.Is_In_List(static_obj)) {
// check if our volume actually intersects the mesh!
if (static_obj->Intersects(tex_proj->Get_Bounding_Volume())) {
static_obj->Add_Effect_To_Me(effect);
projector_update_needed = true;
}
}
static_obj = (StaticPhysClass *)StaticCullingSystem->Get_Next_Collected_Object(static_obj);
}
}
/*
** collect the dynamic objects intersecting the projector's volume
*/
if (tex_proj->Is_Affect_Dynamic_Objects_Enabled()) {
DynamicCullingSystem->Reset_Collection();
DynamicCullingSystem->Collect_Objects(tex_proj->Get_Bounding_Volume());
PhysClass * dyn_obj = DynamicCullingSystem->Get_First_Collected_Object();
while (dyn_obj) {
/*
** for each dynamic object, if it also in our visible list and is not the
** object that generated this shadow, add this projector to it
*/
if ((VisibleDynamicObjectList.Contains(dyn_obj)) && (dyn_obj != tex_proj->Get_Projection_Object_ID())) {
dyn_obj->Add_Effect_To_Me(effect);
projector_update_needed = true;
}
dyn_obj = DynamicCullingSystem->Get_Next_Collected_Object(dyn_obj);
}
}
// if this projector is needed, update it
if (projector_update_needed) {
tex_proj->Pre_Render_Update(camera.Get_Transform());
}
REF_PTR_RELEASE(effect);
}
static void Create_Render_Target_Test(TextureClass* render_target)
{
Matrix4 old_view_transform;
Matrix4 old_world_transform;
Matrix4 old_projection_transform;
DX8Wrapper::Get_Transform(D3DTS_VIEW,old_view_transform);
DX8Wrapper::Get_Transform(D3DTS_WORLD,old_world_transform);
DX8Wrapper::Get_Transform(D3DTS_PROJECTION,old_projection_transform);
/*
** Set the render target
*/
DX8Wrapper::Set_Render_Target(render_target);
/*
** Set up the camera
*/
// Configure_Camera(context->Camera);
/*
** Render the object
*/
Vector3 color(0.0f,0.0f,0.0f);
WW3D::Begin_Render(true,false,color); // false to zclear as we don't have z-buffer
DX8Wrapper::Set_World_Identity();
DX8Wrapper::Set_View_Identity();
DX8Wrapper::Set_Transform(D3DTS_PROJECTION,Matrix4(true));
const int vertex_count=9;
const int polygon_count=3;
DynamicVBAccessClass vb_access(BUFFER_TYPE_DYNAMIC_DX8,dynamic_fvf_type,vertex_count);
{
DynamicVBAccessClass::WriteLockClass lock(&vb_access);
VertexFormatXYZNDUV2* verts=lock.Get_Formatted_Vertex_Array();
Vector3 vertices[vertex_count]={
Vector3(-1.0f, 1.0f,0.0f),
Vector3(-1.0f,-1.0f,0.0f),
Vector3( 0.0f,-1.0f,0.0f),
Vector3(-1.0f,-1.0f,0.0f),
Vector3( 1.0f,-1.0f,0.0f),
Vector3( 1.0f, 0.0f,0.0f),
Vector3( 1.0f,-1.0f,0.0f),
Vector3( 1.0f, 1.0f,0.0f),
Vector3( 0.0f, 1.0f,0.0f)
};
unsigned colors[vertex_count]={
0xff0000,
0xff0000,
0xff0000,
0x00ff00,
0x00ff00,
0x00ff00,
0x0000ff,
0x0000ff,
0x0000ff
};
for (int v=0;v<vertex_count;++v) {
verts[v].x=vertices[v][0];
verts[v].y=vertices[v][1];
verts[v].z=vertices[v][2];
verts[v].nx=0.0f;
verts[v].ny=0.0f;
verts[v].nz=0.0f;
verts[v].diffuse=colors[v];
verts[v].u1=0.0f;
verts[v].v1=0.0f;
verts[v].u2=0.0f;
verts[v].v2=0.0f;
}
}
DX8Wrapper::Set_Vertex_Buffer(vb_access);
DynamicIBAccessClass ib_access(BUFFER_TYPE_DYNAMIC_DX8,polygon_count*3);
{
DynamicIBAccessClass::WriteLockClass lock(&ib_access);
unsigned short* inds=lock.Get_Index_Array();
for (int i=0;i<polygon_count*3;++i) {
*inds++=short(i);
}
}
ShaderClass shader;
shader.Set_Cull_Mode( ShaderClass::CULL_MODE_DISABLE );
shader.Set_Depth_Mask( ShaderClass::DEPTH_WRITE_DISABLE );
shader.Set_Depth_Compare( ShaderClass::PASS_ALWAYS );
shader.Set_Dst_Blend_Func( ShaderClass::DSTBLEND_ONE );
shader.Set_Src_Blend_Func( ShaderClass::SRCBLEND_ONE );
shader.Set_Fog_Func( ShaderClass::FOG_DISABLE );
shader.Set_Primary_Gradient( ShaderClass::GRADIENT_MODULATE );
shader.Set_Texturing( ShaderClass::TEXTURING_DISABLE );
DX8Wrapper::Set_Index_Buffer(ib_access,0);
DX8Wrapper::Set_Shader(shader);
DX8Wrapper::Set_Texture(0,NULL);
DX8Wrapper::Draw_Triangles(0,polygon_count,0,vertex_count);
// WW3D::Render(*model,*context);
WW3D::End_Render(false);
DX8Wrapper::Set_Render_Target((IDirect3DSurface8 *)NULL);
DX8Wrapper::Set_Transform(D3DTS_PROJECTION,old_projection_transform);
DX8Wrapper::Set_Transform(D3DTS_VIEW,old_view_transform);
DX8Wrapper::Set_Transform(D3DTS_WORLD,old_world_transform);
}
static bool Test_Render_Target_Surface(TextureClass* render_target)
{
SurfaceClass * surf = render_target->Get_Surface_Level();
SurfaceClass::SurfaceDescription desc;
surf->Get_Description(desc);
SurfaceClass * new_surf = NEW_REF(SurfaceClass,(desc.Width,desc.Height,desc.Format));
DX8Wrapper::_Copy_DX8_Rects(surf->Peek_D3D_Surface(),NULL,0,new_surf->Peek_D3D_Surface(),NULL);
REF_PTR_RELEASE(surf);
int pitch;
unsigned char* tmpbits=(unsigned char*)new_surf->Lock(&pitch);
unsigned color1,color2,color3,color4;
BitmapHandlerClass::Read_B8G8R8A8(
color1, tmpbits, desc.Format,
1*desc.Width/4,
1*desc.Height/4,
desc.Width, desc.Height, NULL, 0);
BitmapHandlerClass::Read_B8G8R8A8(
color2, tmpbits, desc.Format,
3*desc.Width/4,
1*desc.Height/4,
desc.Width, desc.Height, NULL, 0);
BitmapHandlerClass::Read_B8G8R8A8(
color3, tmpbits, desc.Format,
3*desc.Width/4,
3*desc.Height/4,
desc.Width, desc.Height, NULL, 0);
BitmapHandlerClass::Read_B8G8R8A8(
color4, tmpbits, desc.Format,
1*desc.Width/4,
3*desc.Height/4,
desc.Width, desc.Height, NULL, 0);
new_surf->Unlock();
REF_PTR_RELEASE(new_surf);
WWDEBUG_SAY(("Render target test: 0x%8.8x, 0x%8.8x, 0x%8.8x, 0x%8.8x\n",
color1&0x00ffffff,
color2&0x00ffffff,
color3&0x00ffffff,
color4&0x00ffffff));
// color1 is 0x00000000
if (color1&0x00ffffff) return false;
// color2 is 0x000000ff
if (color2&0x00ffff00) return false;
if (!(color2&0x000000ff)) return false;
// color3 is 0x0000ff00
if (color3&0x00ff00ff) return false;
if (!(color3&0x0000ff00)) return false;
// color4 is 0x00ff0000
if (color4&0x0000ffff) return false;
if (!(color4&0x00ff0000)) return false;
return true;
}
void PhysicsSceneClass::Invalidate_Static_Shadow_Projectors()
{
/*
** Collect a list of all static objects who want to generate a shadow
** Tell each to destroy their shadow
*/
RefPhysListClass shadow_gen_list;
RefPhysListIterator static_anim_iterator(&StaticAnimList);
for (static_anim_iterator.First(); !static_anim_iterator.Is_Done(); static_anim_iterator.Next()) {
StaticAnimPhysClass * obj = (StaticAnimPhysClass *)static_anim_iterator.Peek_Obj();
if (obj != NULL) {
StaticAnimPhysDefClass * def = obj->Get_StaticAnimPhysDef();
if (def && def->Shadow_Dynamic_Objs()) {
obj->Set_Shadow(NULL);
shadow_gen_list.Add(obj);
}
}
}
StaticProjectorsDirty=true;
/*
** Release all of the textures we were using for static shadows
*/
_StaticShadowTexMgr.Reset();
}
void PhysicsSceneClass::Generate_Static_Shadow_Projectors(void)
{
if (!StaticProjectorsDirty) return;
// Don't operate if the device is lost!
if (DX8Wrapper::Is_Device_Lost() || !DX8Wrapper::Is_Initted()) return;
/*
** Collect a list of all static objects who want to generate a shadow
** Tell each to destroy their shadow
*/
RefPhysListClass shadow_gen_list;
RefPhysListIterator static_anim_iterator(&StaticAnimList);
for (static_anim_iterator.First(); !static_anim_iterator.Is_Done(); static_anim_iterator.Next()) {
StaticAnimPhysClass * obj = (StaticAnimPhysClass *)static_anim_iterator.Peek_Obj();
if (obj != NULL) {
StaticAnimPhysDefClass * def = obj->Get_StaticAnimPhysDef();
if (def && def->Shadow_Dynamic_Objs()) {
obj->Set_Shadow(NULL);
shadow_gen_list.Add(obj);
}
}
}
/*
** Release all of the textures we were using for static shadows
*/
_StaticShadowTexMgr.Reset();
/*
** Allocate a render target texture for all of the static shadows to share
*/
TextureClass * render_target = Create_Projector_Render_Target(STATIC_PROJECTOR_RESOLUTION,STATIC_PROJECTOR_RESOLUTION);
// TextureClass * render_target = DX8Wrapper::Create_Render_Target(STATIC_PROJECTOR_RESOLUTION,STATIC_PROJECTOR_RESOLUTION);
// Test render target functionality. Some NVidia driver versions have issues with rendering to a texture and
// copying surface to another texture. If this fails, we'll not use static shadow projectors. Dynamic shadow
// projectors may still work however, as they work differently.
if (render_target) {
Create_Render_Target_Test(render_target);
if (!Test_Render_Target_Surface(render_target)) {
WWDEBUG_SAY(("Render target locking doesn't work correctly. Disabling static projectors\n"));
REF_PTR_RELEASE(render_target);
}
/*
char* bits=new char[desc.Width*desc.Height*3];
//memcpy(bits,tmpbits,desc.Width*desc.Height*4);
for (unsigned int y=0;y<desc.Height;++y) {
for (unsigned int x=0;x<desc.Width;++x) {
// index for image
unsigned index=3*(x+y*desc.Width);
// index for fb
unsigned index2=y*pitch+4*x;
bits[index]=*(tmpbits + index2+2);
bits[index+1]=*(tmpbits + index2+1);
bits[index+2]=*(tmpbits + index2+0);
}
}
new_surf->Unlock();
Targa targ;
memset(&targ.Header,0,sizeof(targ.Header));
targ.Header.Width=desc.Width;
targ.Header.Height=desc.Height;
targ.Header.PixelDepth=24;
targ.Header.ImageType=TGA_TRUECOLOR;
targ.SetImage((char*)bits);
targ.YFlip();
const char* filename="shadowtex.tga";
targ.Save(filename,TGAF_IMAGE,false);
delete[] bits;
*/
}
if (render_target != NULL) {
SET_REF_OWNER(render_target);
/*
** Generate a new shadow for each one. Each time we find a new object-lightsource
** combination, generate a new texture.
*/
RefPhysListIterator shadow_gen_iterator(&shadow_gen_list);
for (shadow_gen_iterator.First(); !shadow_gen_iterator.Is_Done(); shadow_gen_iterator.Next()) {
StaticAnimPhysClass * obj = (StaticAnimPhysClass *)shadow_gen_iterator.Peek_Obj();
/*
** Setup the shadow projector for this object
*/
Vector3 sunvector;
Get_Sun_Light_Vector(&sunvector);
Setup_Static_Directional_Shadow(*obj,sunvector,render_target);
}
DX8Wrapper::Set_Render_Target((IDirect3DSurface8 *)NULL);
REF_PTR_RELEASE(render_target);
}
StaticProjectorsDirty=false;
}
void PhysicsSceneClass::Setup_Static_Directional_Shadow
(
StaticAnimPhysClass & obj,
const Vector3 & light_dir,
TextureClass * render_target
)
{
/*
** Get the definition for this object
*/
StaticAnimPhysDefClass * def = obj.Get_StaticAnimPhysDef();
if (def == NULL) {
return;
}
int type_id = def->Get_ID();
Quaternion obj_orientation(1);
if (def->Shadow_Ignores_Z_Rotation() == false) {
obj_orientation = Build_Quaternion(obj.Get_Transform());
}
/*
** Create the projector
*/
PhysTexProjectClass * shadow_projector = NEW_REF(PhysTexProjectClass,());
shadow_projector->Set_Texture_Size(STATIC_PROJECTOR_RESOLUTION);
shadow_projector->Set_Intensity(def->Shadow_Intensity(),true);
if (def->Shadow_Is_Additive()) {
shadow_projector->Init_Additive();
} else {
shadow_projector->Init_Multiplicative();
/*
** (gth) override the static shadow intensity with the global setting.
*/
shadow_projector->Set_Intensity(Get_Shadow_Normal_Intensity(),true);
}
shadow_projector->Compute_Ortho_Projection(&obj,light_dir,def->Shadow_NearZ(),def->Shadow_FarZ());
shadow_projector->Enable_Attenuation(true);
shadow_projector->Enable_Depth_Gradient(false);
shadow_projector->Peek_Material_Pass()->Enable_On_Translucent_Meshes(false);
/*
** See if we already have a suitable texture.
*/
TextureClass * existing_texture = _StaticShadowTexMgr.Peek_Shadow_Texture(type_id,obj_orientation);
if (existing_texture != NULL) {
shadow_projector->Set_Texture(existing_texture);
}
/*
** If no texture was a available, we have to generate it.
** Then add it to the cache so others can use it
*/
if (existing_texture == NULL) {
shadow_projector->Set_Render_Target(render_target);
shadow_projector->Compute_Texture(&obj,def->Shadow_Is_Additive());
SurfaceClass * surf = render_target->Get_Surface_Level();
SurfaceClass::SurfaceDescription desc;
surf->Get_Description(desc);
SurfaceClass * new_surf = NEW_REF(SurfaceClass,(desc.Width,desc.Height,desc.Format));
DX8Wrapper::_Copy_DX8_Rects(surf->Peek_D3D_Surface(),NULL,0,new_surf->Peek_D3D_Surface(),NULL);
TextureClass * new_texture = NEW_REF(TextureClass,(new_surf));
shadow_projector->Set_Render_Target(NULL);
shadow_projector->Set_Texture(new_texture);
REF_PTR_RELEASE(surf);
REF_PTR_RELEASE(new_surf);
REF_PTR_RELEASE(new_texture);
_StaticShadowTexMgr.Add_Shadow_Texture(type_id,obj_orientation,shadow_projector->Peek_Texture());
}
/*
** Give the projector to the object
*/
obj.Set_Shadow(shadow_projector);
/*
** Release resources
*/
REF_PTR_RELEASE(shadow_projector);
}
Reference in a new issue View git blame Copy permalink