diff --git a/source/renderer/Renderer.cpp b/source/renderer/Renderer.cpp
index d19657f2a6..aa6d62a246 100644
--- a/source/renderer/Renderer.cpp
+++ b/source/renderer/Renderer.cpp
@@ -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;
+		transparentShadows = m->Model.ModTransparentDepthShadow;
 	}
 
 
@@ -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);
diff --git a/source/renderer/Renderer.h b/source/renderer/Renderer.h
index 45e2984c14..0332184187 100644
--- a/source/renderer/Renderer.h
+++ b/source/renderer/Renderer.h
@@ -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*);
diff --git a/source/renderer/ShadowMap.cpp b/source/renderer/ShadowMap.cpp
index 7001919cd8..e942e7d8e5 100644
--- a/source/renderer/ShadowMap.cpp
+++ b/source/renderer/ShadowMap.cpp
@@ -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,63 +335,50 @@ void ShadowMapInternals::CreateTexture()
 		EffectiveHeight = std::min(Height, g_Renderer.GetHeight());
 	}
 
-	const char* formatname = "LUMINANCE";
+	const char* formatname;
 
-	if (UseDepthTexture)
+	switch(DepthTextureBits)
 	{
-		switch(DepthTextureBits)
-		{
-		case 16: formatname = "DEPTH_COMPONENT16"; break;
-		case 24: formatname = "DEPTH_COMPONENT24"; break;
-		case 32: formatname = "DEPTH_COMPONENT32"; break;
-		default: formatname = "DEPTH_COMPONENT"; break;
-		}
+	case 16: formatname = "DEPTH_COMPONENT16"; break;
+	case 24: formatname = "DEPTH_COMPONENT24"; break;
+	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)
 	{
-		if (g_Renderer.m_Options.m_ShadowAlphaFix)
-		{
-			glGenTextures(1, &DummyTexture);
-			g_Renderer.BindTexture(0, DummyTexture);
-			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-			glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, Width, Height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
-		}
-
-		glGenTextures(1, &Texture);
-		g_Renderer.BindTexture(0, Texture);
-
-		GLenum format;
-
-		switch(DepthTextureBits)
-		{
-		case 16: format = GL_DEPTH_COMPONENT16; break;
-		case 24: format = GL_DEPTH_COMPONENT24; break;
-		case 32: format = GL_DEPTH_COMPONENT32; break;
-		default: format = GL_DEPTH_COMPONENT; break;
-		}
-
-		glTexImage2D(GL_TEXTURE_2D, 0, format, Width, Height, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, NULL);
-
-		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);
+		glGenTextures(1, &DummyTexture);
+		g_Renderer.BindTexture(0, DummyTexture);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, Width, Height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
 	}
-	else
+
+	glGenTextures(1, &Texture);
+	g_Renderer.BindTexture(0, Texture);
+
+	GLenum format;
+
+	switch(DepthTextureBits)
 	{
-		glGenTextures(1, &Texture);
-		g_Renderer.BindTexture(0, Texture);
-
-		glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE8, Width, Height, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, NULL);
+	case 16: format = GL_DEPTH_COMPONENT16; break;
+	case 24: format = GL_DEPTH_COMPONENT24; break;
+	case 32: format = GL_DEPTH_COMPONENT32; break;
+	default: format = GL_DEPTH_COMPONENT; break;
 	}
 
+	glTexImage2D(GL_TEXTURE_2D, 0, format, Width, Height, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, NULL);
+
+	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);
+
 	// set texture parameters
 	glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 	glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T, 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);
-	}
+	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);
-	}
+	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);
-	}
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_R_TO_TEXTURE);
 
 	glEnable(GL_CULL_FACE);
 
diff --git a/source/renderer/ShadowMap.h b/source/renderer/ShadowMap.h
index 2a7371db00..7a2cd7643a 100644
--- a/source/renderer/ShadowMap.h
+++ b/source/renderer/ShadowMap.h
@@ -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.
diff --git a/source/renderer/TransparencyRenderer.cpp b/source/renderer/TransparencyRenderer.cpp
index c533762729..74d137759a 100644
--- a/source/renderer/TransparencyRenderer.cpp
+++ b/source/renderer/TransparencyRenderer.cpp
@@ -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
 
diff --git a/source/renderer/TransparencyRenderer.h b/source/renderer/TransparencyRenderer.h
index 352ab1e5e6..b977a40791 100644
--- a/source/renderer/TransparencyRenderer.h
+++ b/source/renderer/TransparencyRenderer.h
@@ -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,