Min LOD and Max LOD sampler parameters

src/OpenGL/libGLESv2/Context.cpp

@@ -3040,6 +3040,7 @@ void Context::applyTextures(sw::SamplerType samplerType)
 			if(texture->isSamplerComplete())
 			{
 				GLenum wrapS, wrapT, wrapR, minFilter, magFilter;
+				GLfloat minLOD, maxLOD;
 
 				Sampler *samplerObject = mState.sampler[textureUnit];
 				if(samplerObject)
@@ -3049,6 +3050,8 @@ void Context::applyTextures(sw::SamplerType samplerType)
 					wrapR = samplerObject->getWrapR();
 					minFilter = samplerObject->getMinFilter();
 					magFilter = samplerObject->getMagFilter();
+					minLOD = samplerObject->getMinLod();
+					maxLOD = samplerObject->getMaxLod();
 				}
 				else
 				{
@@ -3057,6 +3060,8 @@ void Context::applyTextures(sw::SamplerType samplerType)
 					wrapR = texture->getWrapR();
 					minFilter = texture->getMinFilter();
 					magFilter = texture->getMagFilter();
+					minLOD = texture->getMinLOD();
+					maxLOD = texture->getMaxLOD();
 				}
 				GLfloat maxAnisotropy = texture->getMaxAnisotropy();
 
@@ -3074,6 +3079,8 @@ void Context::applyTextures(sw::SamplerType samplerType)
 				device->setSwizzleG(samplerType, samplerIndex, es2sw::ConvertSwizzleType(swizzleG));
 				device->setSwizzleB(samplerType, samplerIndex, es2sw::ConvertSwizzleType(swizzleB));
 				device->setSwizzleA(samplerType, samplerIndex, es2sw::ConvertSwizzleType(swizzleA));
+				device->setMinLod(samplerType, samplerIndex, minLOD);
+				device->setMaxLod(samplerType, samplerIndex, maxLOD);
 				device->setBaseLevel(samplerType, samplerIndex, baseLevel);
 				device->setMaxLevel(samplerType, samplerIndex, maxLevel);
 

src/Renderer/PixelProcessor.cpp

@@ -498,6 +498,24 @@ namespace sw
 		else ASSERT(false);
 	}
 
+	void PixelProcessor::setMinLod(unsigned int sampler, float minLod)
+	{
+		if(sampler < TEXTURE_IMAGE_UNITS)
+		{
+			context->sampler[sampler].setMinLod(minLod);
+		}
+		else ASSERT(false);
+	}
+
+	void PixelProcessor::setMaxLod(unsigned int sampler, float maxLod)
+	{
+		if(sampler < TEXTURE_IMAGE_UNITS)
+		{
+			context->sampler[sampler].setMaxLod(maxLod);
+		}
+		else ASSERT(false);
+	}
+
 	void PixelProcessor::setWriteSRGB(bool sRGB)
 	{
 		context->setWriteSRGB(sRGB);

src/Renderer/PixelProcessor.hpp

@@ -237,6 +237,8 @@ namespace sw
 		virtual void setSwizzleA(unsigned int sampler, SwizzleType swizzleA);
 		virtual void setBaseLevel(unsigned int sampler, int baseLevel);
 		virtual void setMaxLevel(unsigned int sampler, int maxLevel);
+		virtual void setMinLod(unsigned int sampler, float minLod);
+		virtual void setMaxLod(unsigned int sampler, float maxLod);
 
 		virtual void setWriteSRGB(bool sRGB);
 		virtual void setDepthBufferEnable(bool depthBufferEnable);

src/Renderer/Renderer.cpp

@@ -2371,6 +2371,30 @@ namespace sw
 		}
 	}
 
+	void Renderer::setMinLod(SamplerType type, int sampler, float minLod)
+	{
+		if(type == SAMPLER_PIXEL)
+		{
+			PixelProcessor::setMinLod(sampler, minLod);
+		}
+		else
+		{
+			VertexProcessor::setMinLod(sampler, minLod);
+		}
+	}
+
+	void Renderer::setMaxLod(SamplerType type, int sampler, float maxLod)
+	{
+		if(type == SAMPLER_PIXEL)
+		{
+			PixelProcessor::setMaxLod(sampler, maxLod);
+		}
+		else
+		{
+			VertexProcessor::setMaxLod(sampler, maxLod);
+		}
+	}
+
 	void Renderer::setPointSpriteEnable(bool pointSpriteEnable)
 	{
 		context->setPointSpriteEnable(pointSpriteEnable);

src/Renderer/Renderer.hpp

@@ -347,6 +347,8 @@ namespace sw
 		virtual void setSwizzleA(SamplerType type, int sampler, SwizzleType swizzleA);
 		virtual void setBaseLevel(SamplerType type, int sampler, int baseLevel);
 		virtual void setMaxLevel(SamplerType type, int sampler, int maxLevel);
+		virtual void setMinLod(SamplerType type, int sampler, float minLod);
+		virtual void setMaxLod(SamplerType type, int sampler, float maxLod);
 
 		virtual void setPointSpriteEnable(bool pointSpriteEnable);
 		virtual void setPointScaleEnable(bool pointScaleEnable);

src/Renderer/Sampler.cpp

@@ -73,6 +73,11 @@ namespace sw
 
 		texture.LOD = 0.0f;
 		exp2LOD = 1.0f;
+
+		texture.baseLevel = 0;
+		texture.maxLevel = 1000;
+		texture.maxLod = 1000;
+		texture.minLod = -1000;
 	}
 
 	Sampler::~Sampler()
@@ -344,6 +349,16 @@ namespace sw
 		texture.maxLevel = maxLevel;
 	}
 
+	void Sampler::setMinLod(float minLod)
+	{
+		texture.minLod = minLod;
+	}
+
+	void Sampler::setMaxLod(float maxLod)
+	{
+		texture.maxLod = maxLod;
+	}
+
 	void Sampler::setFilterQuality(FilterType maximumFilterQuality)
 	{
 		Sampler::maximumTextureFilterQuality = maximumFilterQuality;

src/Renderer/Sampler.hpp

@@ -69,6 +69,8 @@ namespace sw
 		float maxAnisotropy;
 		int baseLevel;
 		int maxLevel;
+		float minLod;
+		float maxLod;
 	};
 
 	enum SamplerType
@@ -182,6 +184,8 @@ namespace sw
 		void setSwizzleA(SwizzleType swizzleA);
 		void setBaseLevel(int baseLevel);
 		void setMaxLevel(int maxLevel);
+		void setMinLod(float minLod);
+		void setMaxLod(float maxLod);
 
 		static void setFilterQuality(FilterType maximumFilterQuality);
 		static void setMipmapQuality(MipmapType maximumFilterQuality);

src/Renderer/VertexProcessor.cpp

@@ -656,6 +656,24 @@ namespace sw
 		else ASSERT(false);
 	}
 
+	void VertexProcessor::setMinLod(unsigned int sampler, float minLod)
+	{
+		if(sampler < VERTEX_TEXTURE_IMAGE_UNITS)
+		{
+			context->sampler[TEXTURE_IMAGE_UNITS + sampler].setMinLod(minLod);
+		}
+		else ASSERT(false);
+	}
+
+	void VertexProcessor::setMaxLod(unsigned int sampler, float maxLod)
+	{
+		if(sampler < VERTEX_TEXTURE_IMAGE_UNITS)
+		{
+			context->sampler[TEXTURE_IMAGE_UNITS + sampler].setMaxLod(maxLod);
+		}
+		else ASSERT(false);
+	}
+
 	void VertexProcessor::setPointSize(float pointSize)
 	{
 		point.pointSize = replicate(pointSize);

src/Renderer/VertexProcessor.hpp

@@ -262,6 +262,8 @@ namespace sw
 		virtual void setSwizzleA(unsigned int sampler, SwizzleType swizzleA);
 		virtual void setBaseLevel(unsigned int sampler, int baseLevel);
 		virtual void setMaxLevel(unsigned int sampler, int maxLevel);
+		virtual void setMinLod(unsigned int sampler, float minLod);
+		virtual void setMaxLod(unsigned int sampler, float maxLod);
 
 		virtual void setPointSize(float pointSize);
 		virtual void setPointSizeMin(float pointSizeMin);