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/ww3d2/ww3d.h

430 lines
No EOL
17 KiB
C++

/*
** 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 : WW3D *
* *
* $Archive:: /Commando/Code/ww3d2/ww3d.h $*
* *
* $Author:: Steve_t $*
* *
* $Modtime:: 1/02/02 4:17p $*
* *
* $Revision:: 42 $*
* *
*---------------------------------------------------------------------------------------------*
* Functions: *
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#if defined(_MSC_VER)
#pragma once
#endif
#ifndef WW3D_H
#define WW3D_H
#include "always.h"
#include "vector3.h"
#include "layer.h"
#include "w3derr.h"
#include "robjlist.h"
class SceneClass;
class CameraClass;
class ShaderClass;
class DX8Wrapper;
struct RenderStatistics;
class FrameGrabClass;
class VertexMaterialClass;
class ExtraMaterialPassClass;
class RenderInfoClass;
class RenderDeviceDescClass;
class StringClass;
class LightEnvironmentClass;
class MaterialPassClass;
#define MESH_RENDER_SNAPSHOT_ENABLED
#define SNAPSHOT_SAY(x) if (WW3D::Is_Snapshot_Activated()) { WWDEBUG_SAY(x); }
//#define SNAPSHOT_SAY(x)
/**
** WW3D
**
** This is the collection of static functions and data which initialize and
** control the behavior of the WW3D library.
*/
class WW3D
{
public:
enum PrelitModeEnum {
PRELIT_MODE_VERTEX,
PRELIT_MODE_LIGHTMAP_MULTI_PASS,
PRELIT_MODE_LIGHTMAP_MULTI_TEXTURE
};
enum MeshDrawModeEnum {
MESH_DRAW_MODE_OLD,
MESH_DRAW_MODE_NEW,
MESH_DRAW_MODE_DEBUG_DRAW,
MESH_DRAW_MODE_DEBUG_CLIP,
MESH_DRAW_MODE_DEBUG_BOX,
MESH_DRAW_MODE_NONE,
MESH_DRAW_MODE_DX8_ONLY
};
enum NPatchesGapFillingModeEnum {
NPATCHES_GAP_FILLING_DISABLED,
NPATCHES_GAP_FILLING_ENABLED,
NPATCHES_GAP_FILLING_FORCE
};
static WW3DErrorType Init(void * hwnd, char *defaultpal = NULL, bool lite = false);
static WW3DErrorType Shutdown(void);
static bool Is_Initted(void) { return IsInitted; }
static const int Get_Render_Device_Count(void);
static const char * Get_Render_Device_Name(int device_index);
static const RenderDeviceDescClass & Get_Render_Device_Desc(int device = -1);
static int Get_Render_Device(void);
static WW3DErrorType Set_Render_Device( int dev=-1, int resx=-1, int resy=-1, int bits=-1, int windowed=-1, bool resize_window = false );
static WW3DErrorType Set_Render_Device( const char *dev_name, int resx=-1, int resy=-1, int bits=-1, int windowed=-1, bool resize_window = false );
static WW3DErrorType Set_Next_Render_Device(void);
static WW3DErrorType Set_Any_Render_Device( void );
static void Get_Pixel_Center(float &x, float &y);
static void Get_Render_Target_Resolution(int & set_w,int & set_h,int & get_bits,bool & get_windowed);
static void Get_Device_Resolution(int & set_w,int & set_h,int & get_bits,bool & get_windowed);
static WW3DErrorType Set_Device_Resolution(int w=-1,int h=-1,int bits=-1,int windowed=-1, bool resize_window=false );
static bool Is_Windowed( void );
static WW3DErrorType Toggle_Windowed ( void );
static void Set_Window( void *hwnd );
static void * Get_Window( void );
static WW3DErrorType On_Activate_App( void );
static WW3DErrorType On_Deactivate_App( void );
static WW3DErrorType Registry_Save_Render_Device( const char * sub_key );
static WW3DErrorType Registry_Save_Render_Device( const char * sub_key, int device, int width, int height, int depth, bool windowed, int texture_depth );
static WW3DErrorType Registry_Load_Render_Device( const char * sub_key, bool resize_window = false );
static bool Registry_Load_Render_Device( const char * sub_key, char *device, int device_len, int &width, int &height, int &depth, int &windowed, int& texture_depth);
// 0 = bilinear, 1 = trilinear, 2 = anisotropic
static void Set_Texture_Filter(int filter);
static int Get_Texture_Filter() { return TextureFilter; }
/*
** Rendering functions
** Each frame should be bracketed by a Begin_Render and End_Render call. Between these two calls you will
** normally render scenes. The render function which accepts a single render object is implemented for
** special cases like generating a shadow texture for an object. Basically this function will have the
** entire scene rendering overhead.
*/
static WW3DErrorType Begin_Render(bool clear = false,bool clearz = true,const Vector3 & color = Vector3(0,0,0), void(*network_callback)(void) = NULL);
static WW3DErrorType Render(const LayerListClass & layerlist);
static WW3DErrorType Render(const LayerClass & layer);
static WW3DErrorType Render(SceneClass * scene,CameraClass * cam,bool clear = false,bool clearz = false,const Vector3 & color = Vector3(0,0,0));
static WW3DErrorType Render(RenderObjClass & obj,RenderInfoClass & rinfo);
static void Flush(RenderInfoClass & rinfo); // NOTE: "normal" usage should *NEVER* require the user to call this function
static WW3DErrorType End_Render(bool flip_frame = true);
static void Flip_To_Primary(void);
/*
** Timing
** By calling the Sync function, the application can move the ww3d library time forward. This
** will control things like animated uv-offset mappers and render object animations.
*/
static void Sync( unsigned int sync_time );
static unsigned int Get_Sync_Time(void) { return SyncTime; }
static unsigned int Get_Frame_Time(void) { return SyncTime - PreviousSyncTime; }
static unsigned int Get_Frame_Count(void) { return FrameCount; }
static unsigned int Get_Last_Frame_Poly_Count(void);
static unsigned int Get_Last_Frame_Vertex_Count(void);
/*
** Screen/Movie capturing
** These functions allow you to create screenshots and movies.
*/
static void Make_Screen_Shot( const char * filename = "ScreenShot");
static void Start_Movie_Capture( const char * filename_base = "Movie", float frame_rate = 15);
static void Stop_Movie_Capture( void);
static void Toggle_Movie_Capture( const char * filename_base = "Movie", float frame_rate = 15);
static void Start_Single_Frame_Movie_Capture(const char *filename_base = "Frames");
static void Capture_Next_Movie_Frame();
static void Update_Movie_Capture( void);
static float Get_Movie_Capture_Frame_Rate( void);
static void Pause_Movie(bool mode);
static bool Is_Movie_Paused();
static bool Is_Recording_Next_Frame();
static bool Is_Movie_Ready();
/*
** Set_Ext_Swap_Interval - how many vertical retraces to wait before flipping frames
** Get_Ext_Swap_Interval - what is our current setting for the swap interval?
*/
static void Set_Ext_Swap_Interval(long swap);
static long Get_Ext_Swap_Interval(void);
/*
** Texture Reduction - all currently loaded textures can be de-resed on the fly
** by passing in a non-unit value to Set_Texture_Reduction. Passing in 2 causes
** all textures to be half their normal resolution. Passing in 3 causes them to
** be cut in half twice, etc
*/
static void Set_Texture_Reduction( int value );
static int Get_Texture_Reduction( void );
static void _Invalidate_Mesh_Cache();
static void _Invalidate_Textures();
static void Set_Thumbnail_Enabled(bool b) { ThumbnailEnabled=b; }
static bool Get_Thumbnail_Enabled() { return ThumbnailEnabled; }
static void Enable_Sorting(bool onoff);
static bool Is_Sorting_Enabled(void) { return IsSortingEnabled; }
static void Set_Screen_UV_Bias( bool onoff ) { IsScreenUVBiased = onoff; }
static bool Is_Screen_UV_Biased( void ) { return IsScreenUVBiased; }
static void Set_Collision_Box_Display_Mask(int mask);
static int Get_Collision_Box_Display_Mask(void);
static void Set_Default_Native_Screen_Size(float dnss) { DefaultNativeScreenSize = dnss; }
static float Get_Default_Native_Screen_Size(void) { return DefaultNativeScreenSize; }
static void Normalize_Coordinates(int x, int y, float &fx, float &fy); // convert pixel coordinates to 0..1 screen coordinates
static VertexMaterialClass * Peek_Default_Debug_Material(void);
static ShaderClass Peek_Default_Debug_Shader(void);
static ShaderClass Peek_Backface_Debug_Shader(void);
static ShaderClass Peek_Lightmap_Debug_Shader(void);
static void Set_Prelit_Mode (PrelitModeEnum mode) { PrelitMode = mode; }
static PrelitModeEnum Get_Prelit_Mode () { return (PrelitMode); }
static bool Supports_Prelit_Mode (PrelitModeEnum mode) { return (true); }
static void Expose_Prelit (bool onoff) { ExposePrelit = onoff; }
static bool Expose_Prelit () { return (ExposePrelit); }
static void Set_Texture_Bitdepth(int bitdepth);
static int Get_Texture_Bitdepth();
static void Set_Mesh_Draw_Mode (MeshDrawModeEnum mode) { MeshDrawMode = mode; }
static MeshDrawModeEnum Get_Mesh_Draw_Mode () { return (MeshDrawMode); }
static void Set_NPatches_Gap_Filling_Mode (NPatchesGapFillingModeEnum mode);
static NPatchesGapFillingModeEnum Get_NPatches_Gap_Filling_Mode () { return (NPatchesGapFillingMode); }
static void Set_NPatches_Level(unsigned level);
static unsigned Get_NPatches_Level() { return NPatchesLevel; }
static void Enable_Texturing(bool b);
static bool Is_Texturing_Enabled() { return IsTexturingEnabled; }
static int Get_Last_Frame_Memory_Allocation_Count() { return LastFrameMemoryAllocations; }
static int Get_Last_Frame_Memory_Free_Count() { return LastFrameMemoryFrees; }
/*
** Decal control
** These global settings can control whether decals are rendered at all and
** at what distance to stop rendering/creating decals
*/
static void Enable_Decals(bool onoff) { AreDecalsEnabled = onoff; }
static bool Are_Decals_Enabled(void) { return AreDecalsEnabled; }
static void Set_Decal_Rejection_Distance(float d) { DecalRejectionDistance = d; }
static float Get_Decal_Rejection_Distance(void) { return DecalRejectionDistance; }
/*
** Static sort lists. The ability to temporarily set a different static
** sort list from the default one and a min/max sort list range is for
** specialised uses (such as pipctuire-in-picture windows which need to
** sort at a certain sort level). After this override is called, the
** default sort list must be restored.
*/
static void Enable_Static_Sort_Lists(bool onoff) { AreStaticSortListsEnabled = onoff; }
static bool Are_Static_Sort_Lists_Enabled(void) { return AreStaticSortListsEnabled; }
static void Enable_Munge_Sort_On_Load(bool onoff) { MungeSortOnLoad=onoff; }
static bool Is_Munge_Sort_On_Load_Enabled(void) { return MungeSortOnLoad; }
static void Add_To_Static_Sort_List(RenderObjClass *robj, unsigned int sort_level);
static void Render_And_Clear_Static_Sort_Lists(RenderInfoClass & rinfo);
static void Override_Current_Static_Sort_Lists(RefRenderObjListClass *sort_list, unsigned int min_sort, unsigned int max_sort);
static void Reset_Current_Static_Sort_Lists_To_Default(void);
static bool Is_Snapshot_Activated() { return SnapshotActivated; }
static void Activate_Snapshot(bool b) { SnapshotActivated=b; }
// These clock all the time under user control, and are used to update
// Stats.UserStat* when performance sampling is enabled.
static long UserStat0;
static long UserStat1;
static long UserStat2;
private:
enum
{
DEFAULT_RESOLUTION_WIDTH = 640,
DEFAULT_RESOLUTION_HEIGHT = 480,
DEFAULT_BIT_DEPTH = 16
};
static void Read_Gerd_Render_Device_Description(RenderDeviceDescClass &desc);
static void Update_Pixel_Center(void);
static void Allocate_Debug_Resources(void);
static void Release_Debug_Resources(void);
// Timing info:
// The absolute synchronized frame time (in milliseconds) supplied by the
// application at the start of every frame. Note that wraparound cases
// etc. need to be considered.
static unsigned int SyncTime;
// The previously set absolute sync time - this is used to get the interval between
// the most recently set sync time and the previous one. Assuming the
// application sets sync time at the start of every frame, this represents
// the frame interval.
static unsigned int PreviousSyncTime;
static float PixelCenterX;
static float PixelCenterY;
static bool IsInitted;
static bool IsRendering;
static bool IsCapturing;
static bool IsSortingEnabled;
static bool IsScreenUVBiased;
static bool IsBackfaceDebugEnabled;
static bool AreDecalsEnabled;
static float DecalRejectionDistance;
static bool AreStaticSortListsEnabled;
static bool MungeSortOnLoad;
static FrameGrabClass * Movie;
static bool PauseRecord;
static bool RecordNextFrame;
static int FrameCount;
static VertexMaterialClass * DefaultDebugMaterial;
static VertexMaterialClass * BackfaceDebugMaterial;
static ShaderClass DefaultDebugShader;
static ShaderClass LightmapDebugShader;
static PrelitModeEnum PrelitMode;
static bool ExposePrelit;
static int TextureFilter;
static bool SnapshotActivated;
static bool ThumbnailEnabled;
static MeshDrawModeEnum MeshDrawMode;
static NPatchesGapFillingModeEnum NPatchesGapFillingMode;
static unsigned NPatchesLevel;
static bool IsTexturingEnabled;
static bool Lite;
// This is the default native screen size which will be set for each
// RenderObject on construction. The native screen size is the screen size
// at which the object was designed to be viewed, and it is used in the
// texture resizing algorithm (may be used in future for other things).
// If the default is overriden, it will usually be in the asset manager
// post-load callback.
static float DefaultNativeScreenSize;
// For meshes which have a static sorting order. These will get drawn
// after opaque meshes and before normally sorted meshes. The 'current'
// pointer is so the application can temporarily set a different set of
// static sort lists to be used temporarily. This and the min/max sort
// levels are for specialised uses.
static RefRenderObjListClass *DefaultStaticSortLists;
static RefRenderObjListClass *CurrentStaticSortLists;
static unsigned int MinStaticSortLevel;
static unsigned int MaxStaticSortLevel;
// Memory allocation statistics
static int LastFrameMemoryAllocations;
static int LastFrameMemoryFrees;
};
/*
** RenderStatistics
** This struct holds the results of a performance sampling. The WW3D object returns
** its statistics packaged up in one of these structures.
*/
struct RenderStatistics
{
// General statistics
double ElapsedSeconds;
int FramesRendered;
// Geometry engine statistics
double TrianglesReceived;
double TrianglesSubmitted;
double TrianglesSorted;
double VerticesReceived;
double VerticesSubmitted;
// State change statistics
double ViewStateChanges;
double DrawStateChanges;
double TextureChanges;
double TextureParameterChanges;
double TexturesCreated;
double PaletteChanges;
double ShaderChanges;
double DrawCommands;
double TrianglesClipRemoved;
double TrianglesClipCreated;
double DeviceDriverCalls;
// Rendering device statistics
double TextureTransfers;
double PixelsDrawn;
double PixelsRejected;
// Surface cache statistics
long Hits;
long Misses;
long Insertions;
long Removals;
long MemUsed;
long MaxMemory;
// User stats (can be used to see how often a function is called, etc.)
long UserStat0;
long UserStat1;
long UserStat2;
};
#endif