Norse_Harold/0ad
1
0
Fork 0
forked from 0ad/0ad
Code Pull Requests Activity

Renderer simplification: Remove old non-depth-texture shadows.

Browse Source 
This was SVN commit r9188.
This commit is contained in:
Ykkrosh 2011-04-06 22:08:07 +00:00
parent 7339a346e3
commit a1eb830f2c
6 changed files with 37 additions and 225 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
source/renderer/Renderer.cpp
View File

@ -282,7 +282,6 @@ public:
RenderModifierPtr ModWireframe;
RenderModifierPtr ModSolidColor;
RenderModifierPtr ModSolidPlayerColor;
RenderModifierPtr ModTransparentShadow;
RenderModifierPtr ModTransparentDepthShadow;
// RenderModifiers that are selected from the palette below
@ -597,8 +596,6 @@ bool CRenderer::Open(int width, int height)
// Must query card capabilities before creating renderers that depend
// on card capabilities.
EnumCaps();
m->shadow->SetUseDepthTexture(true);
// model rendering
m->Model.VertexFF = ModelVertexRendererPtr(new FixedFunctionModelRenderer);
@ -624,7 +621,6 @@ bool CRenderer::Open(int width, int height)
m->Model.ModSolidColor = RenderModifierPtr(new SolidColorRenderModifier);
m->Model.ModSolidPlayerColor = RenderModifierPtr(new SolidPlayerColorRender);
m->Model.ModTransparentUnlit = RenderModifierPtr(new TransparentRenderModifier);
m->Model.ModTransparentShadow = RenderModifierPtr(new TransparentShadowRenderModifier);
m->Model.ModTransparentDepthShadow = RenderModifierPtr(new TransparentDepthShadowModifier);
// Dimensions
@ -910,10 +906,7 @@ void CRenderer::RenderShadowMap()
}
else
{
if (m->shadow->GetUseDepthTexture())
transparentShadows = m->Model.ModTransparentDepthShadow;
else
transparentShadows = m->Model.ModTransparentShadow;
}
@ -921,7 +914,6 @@ void CRenderer::RenderShadowMap()
// the correct result)
glCullFace(GL_FRONT);
if (m->shadow->GetUseDepthTexture())
{
PROFILE("render patches");
m->terrainRenderer->RenderPatches();
@ -1922,21 +1914,6 @@ void CRenderer::JSI_SetRenderPath(JSContext* ctx, jsval newval)
SetRenderPath(GetRenderPathByName(name));
}
jsval CRenderer::JSI_GetUseDepthTexture(JSContext*)
{
return ToJSVal(m->shadow->GetUseDepthTexture());
}
void CRenderer::JSI_SetUseDepthTexture(JSContext* ctx, jsval newval)
{
bool depthTexture;
if (!ToPrimitive(ctx, newval, depthTexture))
return;
m->shadow->SetUseDepthTexture(depthTexture);
}
jsval CRenderer::JSI_GetDepthTextureBits(JSContext*)
{
return ToJSVal(m->shadow->GetDepthTextureBits());
@ -1994,7 +1971,6 @@ void CRenderer::ScriptingInit()
{
AddProperty(L"fastPlayerColor", &CRenderer::JSI_GetFastPlayerColor, &CRenderer::JSI_SetFastPlayerColor);
AddProperty(L"renderpath", &CRenderer::JSI_GetRenderPath, &CRenderer::JSI_SetRenderPath);
AddProperty(L"useDepthTexture", &CRenderer::JSI_GetUseDepthTexture, &CRenderer::JSI_SetUseDepthTexture);
AddProperty(L"sortAllTransparent", &CRenderer::m_SortAllTransparent);
AddProperty(L"displayFrustum", &CRenderer::m_DisplayFrustum);
AddProperty(L"shadowZBias", &CRenderer::m_ShadowZBias);

2
source/renderer/Renderer.h
View File

@ -323,8 +323,6 @@ protected:
void JSI_SetFastPlayerColor(JSContext* ctx, jsval newval);
jsval JSI_GetRenderPath(JSContext*);
void JSI_SetRenderPath(JSContext* ctx, jsval newval);
jsval JSI_GetUseDepthTexture(JSContext*);
void JSI_SetUseDepthTexture(JSContext* ctx, jsval newval);
jsval JSI_GetDepthTextureBits(JSContext*);
void JSI_SetDepthTextureBits(JSContext* ctx, jsval newval);
jsval JSI_GetShadows(JSContext*);

72
source/renderer/ShadowMap.cpp
View File

@ -44,9 +44,7 @@
*/
struct ShadowMapInternals
{
// whether we're using depth texture or luminance map
bool UseDepthTexture;
// bit depth for the depth texture, if used
// bit depth for the depth texture
int DepthTextureBits;
// if non-zero, we're using EXT_framebuffer_object for shadow rendering,
// and this is the framebuffer
@ -99,7 +97,6 @@ ShadowMap::ShadowMap()
m->Height = 0;
m->EffectiveWidth = 0;
m->EffectiveHeight = 0;
m->UseDepthTexture = false;
m->DepthTextureBits = 0;
// DepthTextureBits: 24/32 are very much faster than 16, on GeForce 4 and FX;
// but they're very much slower on Radeon 9800.
@ -305,7 +302,7 @@ void ShadowMapInternals::CreateTexture()
// Prepare FBO if available
// Note: luminance is not an RGB format, so a luminance texture cannot be used
// as a color buffer
if (UseDepthTexture && g_Renderer.GetCapabilities().m_FramebufferObject)
if (g_Renderer.GetCapabilities().m_FramebufferObject)
{
pglGenFramebuffersEXT(1, &Framebuffer);
}
@ -338,10 +335,8 @@ void ShadowMapInternals::CreateTexture()
EffectiveHeight = std::min(Height, g_Renderer.GetHeight());
}
const char* formatname = "LUMINANCE";
const char* formatname;
if (UseDepthTexture)
{
switch(DepthTextureBits)
{
case 16: formatname = "DEPTH_COMPONENT16"; break;
@ -349,14 +344,11 @@ void ShadowMapInternals::CreateTexture()
case 32: formatname = "DEPTH_COMPONENT32"; break;
default: formatname = "DEPTH_COMPONENT"; break;
}
}
LOGMESSAGE(L"Creating shadow texture (size %dx%d) (format = %hs)%ls",
Width, Height, formatname, Framebuffer ? L" (using EXT_framebuffer_object)" : L"");
if (UseDepthTexture)
{
if (g_Renderer.m_Options.m_ShadowAlphaFix)
{
glGenTextures(1, &DummyTexture);
@ -386,14 +378,6 @@ void ShadowMapInternals::CreateTexture()
glTexParameteri(GL_TEXTURE_2D, GL_DEPTH_TEXTURE_MODE, GL_LUMINANCE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_R_TO_TEXTURE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);
}
else
{
glGenTextures(1, &Texture);
g_Renderer.BindTexture(0, Texture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE8, Width, Height, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, NULL);
}
// set texture parameters
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
@ -404,8 +388,6 @@ void ShadowMapInternals::CreateTexture()
// bind to framebuffer object
if (Framebuffer)
{
debug_assert(UseDepthTexture);
glBindTexture(GL_TEXTURE_2D, 0);
pglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, Framebuffer);
@ -456,18 +438,11 @@ void ShadowMap::BeginRender()
}
// clear buffers
if (m->UseDepthTexture)
{
PROFILE("clear depth texture");
glClear(GL_DEPTH_BUFFER_BIT);
glColorMask(0,0,0,0);
}
else
{
PROFILE("clear shadow texture");
glClearColor(1,1,1,0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
// setup viewport
glViewport(0, 0, m->EffectiveWidth, m->EffectiveHeight);
@ -509,10 +484,7 @@ void ShadowMap::EndRender()
glViewport(0, 0, g_Renderer.GetWidth(), g_Renderer.GetHeight());
if (m->UseDepthTexture)
{
glColorMask(1,1,1,1);
}
// restore matrix stack
glPopMatrix();
@ -535,38 +507,6 @@ const CMatrix3D& ShadowMap::GetTextureMatrix() const
}
///////////////////////////////////////////////////////////////////////////////////////////////////
// Using depth textures vs. a simple luminance map
bool ShadowMap::GetUseDepthTexture() const
{
return m->UseDepthTexture;
}
void ShadowMap::SetUseDepthTexture(bool depthTexture)
{
if (depthTexture)
{
if (!g_Renderer.GetCapabilities().m_DepthTextureShadows)
{
LOGWARNING(L"Depth textures are not supported by your graphics card/driver. Fallback to luminance map (no self-shadowing)!");
depthTexture = false;
}
}
if (depthTexture != m->UseDepthTexture)
{
if (m->Texture)
{
glDeleteTextures(1, &m->Texture);
m->Texture = 0;
}
m->Width = m->Height = 0;
m->UseDepthTexture = depthTexture;
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
// Depth texture bits
int ShadowMap::GetDepthTextureBits() const
@ -668,10 +608,7 @@ void ShadowMap::RenderDebugDisplay()
glDisable(GL_DEPTH_TEST);
g_Renderer.BindTexture(0, m->Texture);
if (m->UseDepthTexture)
{
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_NONE);
}
glColor3f(1.0f, 1.0f, 1.0f);
glBegin(GL_QUADS);
glTexCoord2f(0.0f, 0.0f); glVertex2f(0.0f, 0.0f);
@ -679,10 +616,7 @@ void ShadowMap::RenderDebugDisplay()
glTexCoord2f(1.0f, 1.0f); glVertex2f(0.2f, 0.2f);
glTexCoord2f(0.0f, 1.0f); glVertex2f(0.0f, 0.2f);
glEnd();
if (m->UseDepthTexture)
{
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_R_TO_TEXTURE);
}
glEnable(GL_CULL_FACE);

26
source/renderer/ShadowMap.h
View File

@ -35,10 +35,6 @@ struct ShadowMapInternals;
*
* The class will automatically generate a texture the first time the shadow map is rendered into.
* The texture will not be resized afterwards.
*
* Can use a simple luminance map to store shadows (no self-shadowing possible) or
* depth textures (with self-shadowing). Default is to use a luminance map, use SetUseDepthTexture
* to override the default.
*/
class ShadowMap
{
@ -53,28 +49,6 @@ public:
*/
void RecreateTexture();
/**
* GetUseDepthTexture: Return whether rendering uses a depth texture (instead of
* a luminance texture).
*
* Note that this value may be changed automatically based on OpenGL capabilities.
* It is guarantueed that it stays constant after SetupFrame until the end of the
* frame or the next call to SetUseDepthTexture.
*
* @return whether shadow rendering uses depth textures
*/
bool GetUseDepthTexture() const;
/**
* SetUseDepthTexture: Set whether shadowing should use depth textures.
* Note that even passing @c true for depthTexture does not actually guarantuee that
* depth textures will be used (mostly due to OpenGL capabilities). See the comment
* for GetUseDepthTexture.
*
* @param depthTexture whether shadow rendering should use depth textures
*/
void SetUseDepthTexture(bool depthTexture);
/**
* GetDepthTextureBits: Return the number of bits to use for depth textures when
* enabled.

53
source/renderer/TransparencyRenderer.cpp
View File

@ -672,59 +672,6 @@ void TransparentRenderModifier::PrepareModel(int UNUSED(pass), CModel* UNUSED(mo
}
///////////////////////////////////////////////////////////////////////////////////////////////////
// TransparentShadowRenderModifier implementation
TransparentShadowRenderModifier::TransparentShadowRenderModifier()
{
}
TransparentShadowRenderModifier::~TransparentShadowRenderModifier()
{
}
int TransparentShadowRenderModifier::BeginPass(int pass)
{
debug_assert(pass == 0);
glDepthMask(0);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PREVIOUS);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA);
// Set the proper LOD bias
glTexEnvf(GL_TEXTURE_FILTER_CONTROL, GL_TEXTURE_LOD_BIAS, g_Renderer.m_Options.m_LodBias);
return STREAM_POS|STREAM_UV0;
}
bool TransparentShadowRenderModifier::EndPass(int UNUSED(pass))
{
glDepthMask(1);
glDisable(GL_BLEND);
return true;
}
void TransparentShadowRenderModifier::PrepareTexture(int UNUSED(pass), CTexturePtr& texture)
{
texture->Bind(0);
}
void TransparentShadowRenderModifier::PrepareModel(int UNUSED(pass), CModel* UNUSED(model))
{
// No per-model setup necessary
}
///////////////////////////////////////////////////////////////////////////////////////////////////
// TransparentDepthShadowModifier implementation

17
source/renderer/TransparencyRenderer.h
View File

@ -110,23 +110,6 @@ public:
};
/**
* Class TransparentShadowRenderModifier: Use to render shadow data for
* transparent models into a luminance map.
*/
class TransparentShadowRenderModifier : public RenderModifier
{
public:
TransparentShadowRenderModifier();
~TransparentShadowRenderModifier();
// Implementation
int BeginPass(int pass);
bool EndPass(int pass);
void PrepareTexture(int pass, CTexturePtr& texture);
void PrepareModel(int pass, CModel* model);
};
/**
* Class TransparentDepthShadowModifier: Use to render shadow data for
* transparent models into a depth texture: Writes into the depth buffer,