2004-05-30 02:46:58 +02:00
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Name: Renderer.h
|
|
|
|
// Author: Rich Cross
|
|
|
|
// Contact: rich@wildfiregames.com
|
|
|
|
//
|
|
|
|
// Description: OpenGL renderer class; a higher level interface
|
|
|
|
// on top of OpenGL to handle rendering the basic visual games
|
|
|
|
// types - terrain, models, sprites, particles etc
|
|
|
|
//
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
#ifndef RENDERER_H
|
|
|
|
#define RENDERER_H
|
|
|
|
|
|
|
|
#include <vector>
|
|
|
|
#include "ogl.h"
|
|
|
|
#include "Camera.h"
|
|
|
|
#include "Frustum.h"
|
|
|
|
#include "PatchRData.h"
|
|
|
|
#include "SHCoeffs.h"
|
|
|
|
#include "Terrain.h"
|
|
|
|
#include "Singleton.h"
|
2005-09-25 23:17:35 +02:00
|
|
|
#include "Overlay.h"
|
2004-05-30 02:46:58 +02:00
|
|
|
|
2005-10-10 16:15:28 +02:00
|
|
|
#include "scripting/ScriptableObject.h"
|
|
|
|
|
2005-10-25 03:43:07 +02:00
|
|
|
#include "renderer/ModelRenderer.h"
|
|
|
|
|
2004-05-30 02:46:58 +02:00
|
|
|
// necessary declarations
|
|
|
|
class CCamera;
|
|
|
|
class CPatch;
|
|
|
|
class CSprite;
|
|
|
|
class CParticleSys;
|
|
|
|
class COverlay;
|
|
|
|
class CMaterial;
|
2005-10-25 03:43:07 +02:00
|
|
|
class CModel;
|
2004-05-30 02:46:58 +02:00
|
|
|
class CLightEnv;
|
|
|
|
class CTexture;
|
|
|
|
class CTerrain;
|
2005-10-25 03:43:07 +02:00
|
|
|
|
2005-10-05 18:42:09 +02:00
|
|
|
class RenderPathVertexShader;
|
2004-05-30 02:46:58 +02:00
|
|
|
|
|
|
|
|
|
|
|
// rendering modes
|
|
|
|
enum ERenderMode { WIREFRAME, SOLID, EDGED_FACES };
|
|
|
|
|
|
|
|
// stream flags
|
2005-10-02 23:11:11 +02:00
|
|
|
#define STREAM_POS 0x01
|
|
|
|
#define STREAM_NORMAL 0x02
|
|
|
|
#define STREAM_COLOR 0x04
|
|
|
|
#define STREAM_UV0 0x08
|
|
|
|
#define STREAM_UV1 0x10
|
|
|
|
#define STREAM_UV2 0x20
|
|
|
|
#define STREAM_UV3 0x40
|
2004-05-30 02:46:58 +02:00
|
|
|
#define STREAM_POSTOUV0 0x80
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// SVertex3D: simple 3D vertex declaration
|
|
|
|
struct SVertex3D
|
|
|
|
{
|
|
|
|
float m_Position[3];
|
|
|
|
float m_TexCoords[2];
|
|
|
|
unsigned int m_Color;
|
|
|
|
};
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// SVertex2D: simple 2D vertex declaration
|
|
|
|
struct SVertex2D
|
|
|
|
{
|
|
|
|
float m_Position[2];
|
|
|
|
float m_TexCoords[2];
|
|
|
|
unsigned int m_Color;
|
|
|
|
};
|
|
|
|
|
|
|
|
// access to sole renderer object
|
|
|
|
#define g_Renderer CRenderer::GetSingleton()
|
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// CRenderer: base renderer class - primary interface to the rendering engine
|
2005-11-19 17:15:34 +01:00
|
|
|
struct CRendererInternals;
|
|
|
|
|
2005-10-10 16:15:28 +02:00
|
|
|
class CRenderer : public Singleton<CRenderer>, public CJSObject<CRenderer>
|
2004-05-30 02:46:58 +02:00
|
|
|
{
|
2005-09-18 05:47:15 +02:00
|
|
|
private:
|
2005-10-09 05:43:03 +02:00
|
|
|
std::vector<CPatch*> m_VisiblePatches;
|
2005-09-18 05:47:15 +02:00
|
|
|
|
|
|
|
public:
|
2005-09-27 20:17:45 +02:00
|
|
|
Handle m_WaterTexture[60];
|
|
|
|
int m_WaterCurrentTex;
|
|
|
|
CColor m_WaterColor;
|
2005-09-18 05:47:15 +02:00
|
|
|
bool m_RenderWater;
|
2005-09-27 20:17:45 +02:00
|
|
|
bool m_WaterScroll;
|
2005-09-18 05:47:15 +02:00
|
|
|
float m_WaterHeight;
|
2005-09-18 08:28:23 +02:00
|
|
|
float m_WaterMaxAlpha;
|
|
|
|
float m_WaterFullDepth;
|
|
|
|
float m_WaterAlphaOffset;
|
2005-09-18 05:47:15 +02:00
|
|
|
|
2005-09-27 20:17:45 +02:00
|
|
|
float m_SWaterSpeed;
|
|
|
|
float m_TWaterSpeed;
|
|
|
|
float m_SWaterTrans;
|
|
|
|
float m_TWaterTrans;
|
|
|
|
float m_SWaterScrollCounter;
|
|
|
|
float m_TWaterScrollCounter;
|
|
|
|
float m_WaterTexTimer;
|
|
|
|
|
2004-05-30 02:46:58 +02:00
|
|
|
public:
|
|
|
|
// various enumerations and renderer related constants
|
|
|
|
enum { NumAlphaMaps=14 };
|
|
|
|
enum { MaxTextureUnits=16 };
|
|
|
|
enum Option {
|
|
|
|
OPT_NOVBO,
|
|
|
|
OPT_NOPBUFFER,
|
|
|
|
OPT_SHADOWS,
|
2004-10-17 23:01:00 +02:00
|
|
|
OPT_SHADOWCOLOR,
|
2004-10-21 17:04:19 +02:00
|
|
|
OPT_LODBIAS
|
2004-05-30 02:46:58 +02:00
|
|
|
};
|
2005-10-05 18:42:09 +02:00
|
|
|
|
|
|
|
enum RenderPath {
|
|
|
|
// If no rendering path is configured explicitly, the renderer
|
|
|
|
// will choose the path when Open() is called.
|
|
|
|
RP_DEFAULT,
|
|
|
|
|
|
|
|
// Classic fixed function.
|
|
|
|
RP_FIXED,
|
|
|
|
|
|
|
|
// Use (GL 2.0) vertex shaders for T&L when possible.
|
|
|
|
RP_VERTEXSHADER
|
|
|
|
};
|
|
|
|
|
2004-05-30 02:46:58 +02:00
|
|
|
// stats class - per frame counts of number of draw calls, poly counts etc
|
|
|
|
struct Stats {
|
|
|
|
// set all stats to zero
|
|
|
|
void Reset() { memset(this,0,sizeof(*this)); }
|
|
|
|
// add given stats to this stats
|
|
|
|
Stats& operator+=(const Stats& rhs) {
|
|
|
|
m_Counter++;
|
|
|
|
m_DrawCalls+=rhs.m_DrawCalls;
|
|
|
|
m_TerrainTris+=rhs.m_TerrainTris;
|
|
|
|
m_ModelTris+=rhs.m_ModelTris;
|
|
|
|
m_BlendSplats+=rhs.m_BlendSplats;
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
// count of the number of stats added together
|
2005-08-09 17:55:44 +02:00
|
|
|
size_t m_Counter;
|
2004-05-30 02:46:58 +02:00
|
|
|
// number of draw calls per frame - total DrawElements + Begin/End immediate mode loops
|
2005-08-09 17:55:44 +02:00
|
|
|
size_t m_DrawCalls;
|
2004-05-30 02:46:58 +02:00
|
|
|
// number of terrain triangles drawn
|
2005-08-09 17:55:44 +02:00
|
|
|
size_t m_TerrainTris;
|
2004-05-30 02:46:58 +02:00
|
|
|
// number of (non-transparent) model triangles drawn
|
2005-08-09 17:55:44 +02:00
|
|
|
size_t m_ModelTris;
|
2004-05-30 02:46:58 +02:00
|
|
|
// number of splat passes for alphamapping
|
2005-08-09 17:55:44 +02:00
|
|
|
size_t m_BlendSplats;
|
2004-05-30 02:46:58 +02:00
|
|
|
};
|
|
|
|
|
2005-10-25 03:43:07 +02:00
|
|
|
// renderer options
|
|
|
|
struct Options {
|
|
|
|
bool m_NoVBO;
|
|
|
|
bool m_Shadows;
|
|
|
|
RGBAColor m_ShadowColor;
|
|
|
|
float m_LodBias;
|
|
|
|
RenderPath m_RenderPath;
|
|
|
|
} m_Options;
|
|
|
|
|
2004-05-30 02:46:58 +02:00
|
|
|
public:
|
|
|
|
// constructor, destructor
|
|
|
|
CRenderer();
|
|
|
|
~CRenderer();
|
|
|
|
|
|
|
|
// open up the renderer: performs any necessary initialisation
|
|
|
|
bool Open(int width,int height,int depth);
|
|
|
|
|
|
|
|
// resize renderer view
|
|
|
|
void Resize(int width,int height);
|
|
|
|
|
|
|
|
// set/get boolean renderer option
|
|
|
|
void SetOptionBool(enum Option opt,bool value);
|
|
|
|
bool GetOptionBool(enum Option opt) const;
|
2004-06-11 00:24:03 +02:00
|
|
|
// set/get RGBA color renderer option
|
|
|
|
void SetOptionColor(enum Option opt,const RGBAColor& value);
|
2004-10-21 17:04:19 +02:00
|
|
|
void SetOptionFloat(enum Option opt, float val);
|
2004-06-11 00:24:03 +02:00
|
|
|
const RGBAColor& GetOptionColor(enum Option opt) const;
|
2005-10-05 18:42:09 +02:00
|
|
|
void SetRenderPath(RenderPath rp);
|
|
|
|
RenderPath GetRenderPath() const { return m_Options.m_RenderPath; }
|
|
|
|
static CStr GetRenderPathName(RenderPath rp);
|
|
|
|
static RenderPath GetRenderPathByName(CStr name);
|
|
|
|
|
2004-05-30 02:46:58 +02:00
|
|
|
// return view width
|
|
|
|
int GetWidth() const { return m_Width; }
|
|
|
|
// return view height
|
|
|
|
int GetHeight() const { return m_Height; }
|
|
|
|
// return view aspect ratio
|
|
|
|
float GetAspect() const { return float(m_Width)/float(m_Height); }
|
|
|
|
|
|
|
|
// signal frame start
|
|
|
|
void BeginFrame();
|
|
|
|
// force rendering of any batched objects
|
|
|
|
void FlushFrame();
|
|
|
|
// signal frame end : implicitly flushes batched objects
|
|
|
|
void EndFrame();
|
|
|
|
|
|
|
|
// set color used to clear screen in BeginFrame()
|
|
|
|
void SetClearColor(u32 color);
|
|
|
|
|
|
|
|
// return current frame counter
|
|
|
|
int GetFrameCounter() const { return m_FrameCounter; }
|
|
|
|
|
|
|
|
// set camera used for subsequent rendering operations; includes viewport, projection and modelview matrices
|
|
|
|
void SetCamera(CCamera& camera);
|
|
|
|
|
2004-08-05 15:07:51 +02:00
|
|
|
// set the viewport
|
|
|
|
void SetViewport(const SViewPort &);
|
|
|
|
|
2004-05-30 02:46:58 +02:00
|
|
|
// submission of objects for rendering; the passed matrix indicating the transform must be scoped such that it is valid beyond
|
|
|
|
// the call to frame end, as must the object itself
|
|
|
|
void Submit(CPatch* patch);
|
|
|
|
void Submit(CModel* model);
|
|
|
|
void Submit(CSprite* sprite);
|
|
|
|
void Submit(CParticleSys* psys);
|
|
|
|
void Submit(COverlay* overlay);
|
|
|
|
|
|
|
|
// basic primitive rendering operations in 2 and 3D; handy for debugging stuff, but also useful in
|
|
|
|
// editor tools (eg for highlighting specific terrain patches)
|
|
|
|
// note:
|
|
|
|
// * all 3D vertices specified in world space
|
|
|
|
// * primitive operations rendered immediatedly, never batched
|
|
|
|
// * primitives rendered in current material (set via SetMaterial)
|
|
|
|
void RenderLine(const SVertex2D* vertices);
|
|
|
|
void RenderLineLoop(int len,const SVertex2D* vertices);
|
|
|
|
void RenderTri(const SVertex2D* vertices);
|
|
|
|
void RenderQuad(const SVertex2D* vertices);
|
|
|
|
void RenderLine(const SVertex3D* vertices);
|
|
|
|
void RenderLineLoop(int len,const SVertex3D* vertices);
|
|
|
|
void RenderTri(const SVertex3D* vertices);
|
|
|
|
void RenderQuad(const SVertex3D* vertices);
|
|
|
|
|
|
|
|
// set the current lighting environment; (note: the passed pointer is just copied to a variable within the renderer,
|
|
|
|
// so the lightenv passed must be scoped such that it is not destructed until after the renderer is no longer rendering)
|
|
|
|
void SetLightEnv(CLightEnv* lightenv) {
|
|
|
|
m_LightEnv=lightenv;
|
|
|
|
}
|
|
|
|
|
|
|
|
// set the mode to render subsequent terrain patches
|
|
|
|
void SetTerrainRenderMode(ERenderMode mode) { m_TerrainRenderMode=mode; }
|
|
|
|
// get the mode to render subsequent terrain patches
|
|
|
|
ERenderMode GetTerrainRenderMode() const { return m_TerrainRenderMode; }
|
|
|
|
|
|
|
|
// set the mode to render subsequent models
|
|
|
|
void SetModelRenderMode(ERenderMode mode) { m_ModelRenderMode=mode; }
|
|
|
|
// get the mode to render subsequent models
|
|
|
|
ERenderMode GetModelRenderMode() const { return m_ModelRenderMode; }
|
|
|
|
|
|
|
|
// try and load the given texture
|
|
|
|
bool LoadTexture(CTexture* texture,u32 wrapflags);
|
2004-06-11 00:24:03 +02:00
|
|
|
// set the given unit to reference the given texture; pass a null texture to disable texturing on any unit;
|
2004-06-07 21:53:58 +02:00
|
|
|
// active texture unit always set to given unit on exit
|
2004-05-30 02:46:58 +02:00
|
|
|
void SetTexture(int unit,CTexture* texture);
|
2004-06-07 21:53:58 +02:00
|
|
|
// bind a GL texture object to active unit
|
2004-05-30 02:46:58 +02:00
|
|
|
void BindTexture(int unit,GLuint tex);
|
|
|
|
// query transparency of given texture
|
|
|
|
bool IsTextureTransparent(CTexture* texture);
|
|
|
|
|
2005-10-12 06:16:41 +02:00
|
|
|
// load the default set of alphamaps.
|
|
|
|
// return a negative error code if anything along the way fails.
|
|
|
|
// called via delay-load mechanism.
|
2005-05-03 23:36:57 +02:00
|
|
|
int LoadAlphaMaps();
|
2004-12-16 13:41:54 +01:00
|
|
|
void UnloadAlphaMaps();
|
|
|
|
|
2005-10-12 06:16:41 +02:00
|
|
|
// load textures for the active water type.
|
|
|
|
// return a negative error code if anything along the way fails.
|
|
|
|
// called via delay-load mechanism.
|
|
|
|
int LoadWaterTextures();
|
|
|
|
void UnloadWaterTextures();
|
|
|
|
|
2004-05-30 02:46:58 +02:00
|
|
|
// return stats accumulated for current frame
|
|
|
|
const Stats& GetStats() { return m_Stats; }
|
|
|
|
|
2005-10-05 18:42:09 +02:00
|
|
|
// return the current light environment
|
|
|
|
const CLightEnv &GetLightEnv() { return *m_LightEnv; }
|
2005-10-25 03:43:07 +02:00
|
|
|
|
2005-11-06 00:15:23 +01:00
|
|
|
// return the current camera
|
|
|
|
const CCamera& GetCamera() const { return m_Camera; }
|
|
|
|
|
2005-10-25 03:43:07 +02:00
|
|
|
/**
|
|
|
|
* SetFastPlayerColor: Tell the renderer which path to take for
|
|
|
|
* player colored models. Both paths should provide the same visual
|
|
|
|
* quality, however the slow path runs on older hardware using multi-pass.
|
|
|
|
*
|
|
|
|
* @param fast true if the fast path should be used from now on. If fast
|
|
|
|
* is true but the OpenGL implementation does not support it, a warning
|
|
|
|
* is printed and the slow path is used instead.
|
|
|
|
*/
|
|
|
|
void SetFastPlayerColor(bool fast);
|
|
|
|
|
2004-05-30 02:46:58 +02:00
|
|
|
protected:
|
2005-11-19 17:37:50 +01:00
|
|
|
friend struct CRendererInternals;
|
2004-06-11 00:24:03 +02:00
|
|
|
friend class CVertexBuffer;
|
2004-05-30 02:46:58 +02:00
|
|
|
friend class CPatchRData;
|
2005-10-25 03:43:07 +02:00
|
|
|
friend class FixedFunctionModelRenderer;
|
|
|
|
friend class ModelRenderer;
|
2005-11-06 00:15:23 +01:00
|
|
|
friend class PolygonSortModelRenderer;
|
|
|
|
friend class SortModelRenderer;
|
2005-10-05 18:42:09 +02:00
|
|
|
friend class RenderPathVertexShader;
|
2005-10-25 03:43:07 +02:00
|
|
|
friend class HWLightingModelRenderer;
|
2005-10-30 02:22:22 +02:00
|
|
|
friend class InstancingModelRenderer;
|
2004-05-30 02:46:58 +02:00
|
|
|
|
2005-10-10 16:15:28 +02:00
|
|
|
// scripting
|
2005-10-25 03:43:07 +02:00
|
|
|
jsval JSI_GetFastPlayerColor(JSContext*);
|
|
|
|
void JSI_SetFastPlayerColor(JSContext* ctx, jsval newval);
|
|
|
|
jsval JSI_GetRenderPath(JSContext*);
|
|
|
|
void JSI_SetRenderPath(JSContext* ctx, jsval newval);
|
2005-10-10 16:15:28 +02:00
|
|
|
static void ScriptingInit();
|
|
|
|
|
2004-05-30 02:46:58 +02:00
|
|
|
// patch rendering stuff
|
|
|
|
void RenderPatchSubmissions();
|
|
|
|
void RenderPatches();
|
2005-10-09 06:40:18 +02:00
|
|
|
void RenderWater();
|
2004-05-30 02:46:58 +02:00
|
|
|
|
|
|
|
// model rendering stuff
|
|
|
|
void RenderModels();
|
2005-10-25 03:43:07 +02:00
|
|
|
void RenderTransparentModels();
|
2004-05-30 02:46:58 +02:00
|
|
|
|
|
|
|
// shadow rendering stuff
|
|
|
|
void CreateShadowMap();
|
|
|
|
void RenderShadowMap();
|
|
|
|
void ApplyShadowMap();
|
2004-06-07 21:53:58 +02:00
|
|
|
void BuildTransformation(const CVector3D& pos,const CVector3D& right,const CVector3D& up,
|
2004-05-30 02:46:58 +02:00
|
|
|
const CVector3D& dir,CMatrix3D& result);
|
|
|
|
void ConstructLightTransform(const CVector3D& pos,const CVector3D& lightdir,CMatrix3D& result);
|
|
|
|
void CalcShadowMatrices();
|
|
|
|
void CalcShadowBounds(CBound& bounds);
|
|
|
|
|
|
|
|
// RENDERER DATA:
|
2005-11-19 17:15:34 +01:00
|
|
|
/// Private data that is not needed by inline functions
|
|
|
|
CRendererInternals* m;
|
2004-05-30 02:46:58 +02:00
|
|
|
// view width
|
|
|
|
int m_Width;
|
|
|
|
// view height
|
|
|
|
int m_Height;
|
|
|
|
// view depth (bpp)
|
|
|
|
int m_Depth;
|
|
|
|
// frame counter
|
|
|
|
int m_FrameCounter;
|
|
|
|
// current terrain rendering mode
|
|
|
|
ERenderMode m_TerrainRenderMode;
|
|
|
|
// current model rendering mode
|
|
|
|
ERenderMode m_ModelRenderMode;
|
|
|
|
// current view camera
|
|
|
|
CCamera m_Camera;
|
|
|
|
// color used to clear screen in BeginFrame
|
|
|
|
float m_ClearColor[4];
|
|
|
|
// submitted object lists for batching
|
|
|
|
std::vector<CSprite*> m_Sprites;
|
|
|
|
std::vector<CParticleSys*> m_ParticleSyses;
|
|
|
|
std::vector<COverlay*> m_Overlays;
|
|
|
|
// current lighting setup
|
|
|
|
CLightEnv* m_LightEnv;
|
|
|
|
// current spherical harmonic coefficients (for unit lighting), derived from lightenv
|
|
|
|
CSHCoeffs m_SHCoeffsUnits;
|
|
|
|
// current spherical harmonic coefficients (for terrain lighting), derived from lightenv
|
|
|
|
CSHCoeffs m_SHCoeffsTerrain;
|
2005-09-20 00:48:20 +02:00
|
|
|
// ogl_tex handle of composite alpha map (all the alpha maps packed into one texture)
|
|
|
|
Handle m_hCompositeAlphaMap;
|
2004-05-30 02:46:58 +02:00
|
|
|
// handle of shadow map
|
|
|
|
u32 m_ShadowMap;
|
2004-06-07 21:53:58 +02:00
|
|
|
// width, height of shadow map
|
|
|
|
u32 m_ShadowMapWidth,m_ShadowMapHeight;
|
2004-06-11 00:24:03 +02:00
|
|
|
// object space bound of shadow casting objects
|
|
|
|
CBound m_ShadowBound;
|
2004-05-30 02:46:58 +02:00
|
|
|
// per-frame flag: has the shadow map been rendered this frame?
|
|
|
|
bool m_ShadowRendered;
|
|
|
|
// projection matrix of shadow casting light
|
|
|
|
CMatrix3D m_LightProjection;
|
|
|
|
// transformation matrix of shadow casting light
|
|
|
|
CMatrix3D m_LightTransform;
|
|
|
|
// coordinates of each (untransformed) alpha map within the packed texture
|
|
|
|
struct {
|
|
|
|
float u0,u1,v0,v1;
|
|
|
|
} m_AlphaMapCoords[NumAlphaMaps];
|
|
|
|
// card capabilities
|
|
|
|
struct Caps {
|
|
|
|
bool m_VBO;
|
|
|
|
bool m_TextureBorderClamp;
|
|
|
|
bool m_GenerateMipmaps;
|
2005-10-01 00:23:48 +02:00
|
|
|
bool m_VertexShader;
|
2004-05-30 02:46:58 +02:00
|
|
|
} m_Caps;
|
|
|
|
// build card cap bits
|
|
|
|
void EnumCaps();
|
|
|
|
// per-frame renderer stats
|
2004-06-11 00:24:03 +02:00
|
|
|
Stats m_Stats;
|
2004-05-30 02:46:58 +02:00
|
|
|
// active textures on each unit
|
|
|
|
GLuint m_ActiveTextures[MaxTextureUnits];
|
2005-10-05 18:42:09 +02:00
|
|
|
|
|
|
|
// Additional state that is only available when the vertex shader
|
|
|
|
// render path is used (according to m_Options.m_RenderPath)
|
|
|
|
RenderPathVertexShader* m_VertexShader;
|
2005-10-10 16:15:28 +02:00
|
|
|
|
2005-10-25 04:22:22 +02:00
|
|
|
/// If false, use a multipass fallback for player colors.
|
2005-10-12 03:07:01 +02:00
|
|
|
bool m_FastPlayerColor;
|
2005-10-25 04:22:22 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* m_SortAllTransparent: If true, all transparent models are
|
|
|
|
* rendered using the TransparencyRenderer which performs sorting.
|
|
|
|
*
|
|
|
|
* Otherwise, transparent models are rendered using the faster
|
|
|
|
* batching renderer when possible.
|
|
|
|
*/
|
|
|
|
bool m_SortAllTransparent;
|
2005-10-28 21:25:47 +02:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* m_FastNormals: Use faster normal transformation in the
|
|
|
|
* software transform by multiplying with the bone matrix itself
|
|
|
|
* instead of the transpose of the inverse.
|
|
|
|
*/
|
|
|
|
bool m_FastNormals;
|
2005-10-14 23:59:08 +02:00
|
|
|
|
|
|
|
// State used by LoadWaterTextures with progressive loading
|
|
|
|
uint cur_loading_water_tex;
|
2005-10-25 03:43:07 +02:00
|
|
|
|
|
|
|
// Various model renderers
|
|
|
|
struct Models {
|
|
|
|
ModelRenderer* NormalFF;
|
|
|
|
ModelRenderer* PlayerFF;
|
|
|
|
ModelRenderer* NormalHWLit;
|
|
|
|
ModelRenderer* PlayerHWLit;
|
2005-10-30 02:22:22 +02:00
|
|
|
ModelRenderer* NormalInstancing;
|
|
|
|
ModelRenderer* PlayerInstancing;
|
2005-10-25 03:43:07 +02:00
|
|
|
|
2005-11-06 00:15:23 +01:00
|
|
|
ModelRenderer* TranspFF;
|
|
|
|
ModelRenderer* TranspHWLit;
|
|
|
|
ModelRenderer* TranspSortAll;
|
|
|
|
|
|
|
|
ModelVertexRendererPtr VertexFF;
|
|
|
|
ModelVertexRendererPtr VertexHWLit;
|
|
|
|
ModelVertexRendererPtr VertexInstancing;
|
|
|
|
ModelVertexRendererPtr VertexPolygonSort;
|
|
|
|
|
2005-10-25 03:43:07 +02:00
|
|
|
RenderModifierPtr ModWireframe;
|
|
|
|
RenderModifierPtr ModPlain;
|
|
|
|
RenderModifierPtr ModPlayer;
|
|
|
|
RenderModifierPtr ModSolidColor;
|
|
|
|
RenderModifierPtr ModTransparent;
|
|
|
|
RenderModifierPtr ModTransparentShadow;
|
|
|
|
} m_Models;
|
2004-05-30 02:46:58 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
#endif
|