--- /dev/null
+Name
+
+ CHROMIUM_texture_filtering_hint
+
+Name Strings
+
+ GL_CHROMIUM_texture_filtering_hint
+
+Contributors
+
+ Alexis Hetu, Google Inc.
+ Nicolas Capens, Google Inc.
+ Shannon Woods, Google Inc.
+
+Contact
+
+ Alexis Hetu, Google Inc. (sugoi 'at' chromium 'dot' org)
+
+Version
+
+ Last Modifed Date: July 18, 2017
+
+Dependencies
+
+ This extension is written against the OpenGL ES 2.0 specification.
+
+ OpenGL ES 2.0 is required.
+
+Overview
+
+ This extension defines a way to request high precision texture filtering
+ using a new value to Hint.
+
+ When this extension is enabled, TEXTURE_FILTERING_HINT_CHROMIUM can be used
+ by the implementation as a means to distinguish between a performance
+ focused implementation, using FASTEST, or a precision focused
+ implementation, using NICEST.
+
+ Like other hints, either option is spec compliant and the behavior of
+ DONT_CARE is implementation specific.
+
+New Tokens
+
+ Accepted by the <pname> parameter of GetIntegerv, GetFloatv and GetBooleanv
+ and by the <target> parameter of Hint:
+
+ TEXTURE_FILTERING_HINT_CHROMIUM 0x8AF0
+
+New Procedures and Functions
+
+ None.
+
+Errors
+
+ None.
+
+New State
+
+ None.
+
+Issues
+
+ 1) When does the hint take effect?
+
+ At the time of the next draw call, and all subsequent draw calls.
+
+ 2) Does the first draw call after the filtering hint is changed use the
+ updated filtering method?
+
+ Yes
+
+ 3) Can I switch it back and forth between every draw call, multiple times
+ during a single frame?
+
+ Yes
+
+ 4) Do program objects which were created before the filtering hint was
+ changed and which contain sampling instructions use the filtering method
+ from when they were created, or the method at the time of draw call?
+
+ At the time of draw call.
+
+Revision History
+
+ 2/7/2014 Documented the extension
mState.rasterizerDiscardEnabled = false;
mState.generateMipmapHint = GL_DONT_CARE;
mState.fragmentShaderDerivativeHint = GL_DONT_CARE;
+ mState.textureFilteringHint = GL_DONT_CARE;
mState.lineWidth = 1.0f;
// Ignore for now. It is valid for implementations to ignore hint.
}
+void Context::setTextureFilteringHint(GLenum hint)
+{
+ mState.textureFilteringHint = hint;
+}
+
void Context::setViewportParams(GLint x, GLint y, GLsizei width, GLsizei height)
{
mState.viewportX = x;
case GL_UNPACK_ALIGNMENT: *params = mState.unpackInfo.alignment; return true;
case GL_GENERATE_MIPMAP_HINT: *params = mState.generateMipmapHint; return true;
case GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES: *params = mState.fragmentShaderDerivativeHint; return true;
+ case GL_TEXTURE_FILTERING_HINT_CHROMIUM: *params = mState.textureFilteringHint; return true;
case GL_ACTIVE_TEXTURE: *params = (mState.activeSampler + GL_TEXTURE0); return true;
case GL_STENCIL_FUNC: *params = mState.stencilFunc; return true;
case GL_STENCIL_REF: *params = mState.stencilRef; return true;
case GL_UNPACK_ALIGNMENT:
case GL_GENERATE_MIPMAP_HINT:
case GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES:
+ case GL_TEXTURE_FILTERING_HINT_CHROMIUM:
case GL_RED_BITS:
case GL_GREEN_BITS:
case GL_BLUE_BITS:
device->setTextureFilter(samplerType, samplerIndex, es2sw::ConvertTextureFilter(minFilter, magFilter, maxAnisotropy));
device->setMipmapFilter(samplerType, samplerIndex, es2sw::ConvertMipMapFilter(minFilter));
device->setMaxAnisotropy(samplerType, samplerIndex, maxAnisotropy);
+ device->setHighPrecisionFiltering(samplerType, samplerIndex, mState.textureFilteringHint == GL_NICEST);
applyTexture(samplerType, samplerIndex, texture);
}
"GL_ANGLE_texture_compression_dxt3",
"GL_ANGLE_texture_compression_dxt5",
#endif
+ "GL_CHROMIUM_texture_filtering_hint",
"GL_NV_fence",
"GL_NV_framebuffer_blit",
"GL_NV_read_depth",
#endif
};
+const GLenum GL_TEXTURE_FILTERING_HINT_CHROMIUM = 0x8AF0;
+
const GLint NUM_COMPRESSED_TEXTURE_FORMATS = sizeof(compressedTextureFormats) / sizeof(compressedTextureFormats[0]);
const GLint multisampleCount[] = {4, 2, 1};
GLenum generateMipmapHint;
GLenum fragmentShaderDerivativeHint;
+ GLenum textureFilteringHint;
GLint viewportX;
GLint viewportY;
void setGenerateMipmapHint(GLenum hint);
void setFragmentShaderDerivativeHint(GLenum hint);
+ void setTextureFilteringHint(GLenum hint);
void setViewportParams(GLint x, GLint y, GLsizei width, GLsizei height);
case GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES:
if(context) context->setFragmentShaderDerivativeHint(mode);
break;
+ case GL_TEXTURE_FILTERING_HINT_CHROMIUM:
+ if(context) context->setTextureFilteringHint(mode);
+ break;
default:
return error(GL_INVALID_ENUM);
}
else ASSERT(false);
}
+ void PixelProcessor::setHighPrecisionFiltering(unsigned int sampler, bool highPrecisionFiltering)
+ {
+ if(sampler < TEXTURE_IMAGE_UNITS)
+ {
+ context->sampler[sampler].setHighPrecisionFiltering(highPrecisionFiltering);
+ }
+ else ASSERT(false);
+ }
+
void PixelProcessor::setSwizzleR(unsigned int sampler, SwizzleType swizzleR)
{
if(sampler < TEXTURE_IMAGE_UNITS)
void setMipmapLOD(unsigned int sampler, float bias);
void setBorderColor(unsigned int sampler, const Color<float> &borderColor);
void setMaxAnisotropy(unsigned int sampler, float maxAnisotropy);
+ void setHighPrecisionFiltering(unsigned int sampler, bool highPrecisionFiltering);
void setSwizzleR(unsigned int sampler, SwizzleType swizzleR);
void setSwizzleG(unsigned int sampler, SwizzleType swizzleG);
void setSwizzleB(unsigned int sampler, SwizzleType swizzleB);
}
}
+ void Renderer::setHighPrecisionFiltering(SamplerType type, int sampler, bool highPrecisionFiltering)
+ {
+ if(type == SAMPLER_PIXEL)
+ {
+ PixelProcessor::setHighPrecisionFiltering(sampler, highPrecisionFiltering);
+ }
+ else
+ {
+ VertexProcessor::setHighPrecisionFiltering(sampler, highPrecisionFiltering);
+ }
+ }
+
void Renderer::setSwizzleR(SamplerType type, int sampler, SwizzleType swizzleR)
{
if(type == SAMPLER_PIXEL)
void setMipmapLOD(SamplerType type, int sampler, float bias);
void setBorderColor(SamplerType type, int sampler, const Color<float> &borderColor);
void setMaxAnisotropy(SamplerType type, int sampler, float maxAnisotropy);
+ void setHighPrecisionFiltering(SamplerType type, int sampler, bool highPrecisionFiltering);
void setSwizzleR(SamplerType type, int sampler, SwizzleType swizzleR);
void setSwizzleG(SamplerType type, int sampler, SwizzleType swizzleG);
void setSwizzleB(SamplerType type, int sampler, SwizzleType swizzleB);
mipmapFilterState = MIPMAP_NONE;
sRGB = false;
gather = false;
+ highPrecisionFiltering = false;
swizzleR = SWIZZLE_RED;
swizzleG = SWIZZLE_GREEN;
state.swizzleG = swizzleG;
state.swizzleB = swizzleB;
state.swizzleA = swizzleA;
+ state.highPrecisionFiltering = highPrecisionFiltering;
#if PERF_PROFILE
state.compressedFormat = Surface::isCompressed(externalTextureFormat);
texture.maxAnisotropy = maxAnisotropy;
}
+ void Sampler::setHighPrecisionFiltering(bool highPrecisionFiltering)
+ {
+ this->highPrecisionFiltering = highPrecisionFiltering;
+ }
+
void Sampler::setSwizzleR(SwizzleType swizzleR)
{
this->swizzleR = swizzleR;
SwizzleType swizzleG : BITS(SWIZZLE_LAST);
SwizzleType swizzleB : BITS(SWIZZLE_LAST);
SwizzleType swizzleA : BITS(SWIZZLE_LAST);
+ bool highPrecisionFiltering : 1;
#if PERF_PROFILE
bool compressedFormat : 1;
void setReadSRGB(bool sRGB);
void setBorderColor(const Color<float> &borderColor);
void setMaxAnisotropy(float maxAnisotropy);
+ void setHighPrecisionFiltering(bool highPrecisionFiltering);
void setSwizzleR(SwizzleType swizzleR);
void setSwizzleG(SwizzleType swizzleG);
void setSwizzleB(SwizzleType swizzleB);
MipmapType mipmapFilterState;
bool sRGB;
bool gather;
+ bool highPrecisionFiltering;
SwizzleType swizzleR;
SwizzleType swizzleG;
else ASSERT(false);
}
+ void VertexProcessor::setHighPrecisionFiltering(unsigned int sampler, bool highPrecisionFiltering)
+ {
+ if(sampler < TEXTURE_IMAGE_UNITS)
+ {
+ context->sampler[sampler].setHighPrecisionFiltering(highPrecisionFiltering);
+ }
+ else ASSERT(false);
+ }
+
void VertexProcessor::setSwizzleR(unsigned int sampler, SwizzleType swizzleR)
{
if(sampler < VERTEX_TEXTURE_IMAGE_UNITS)
void setMipmapLOD(unsigned int sampler, float bias);
void setBorderColor(unsigned int sampler, const Color<float> &borderColor);
void setMaxAnisotropy(unsigned int stage, float maxAnisotropy);
+ void setHighPrecisionFiltering(unsigned int sampler, bool highPrecisionFiltering);
void setSwizzleR(unsigned int sampler, SwizzleType swizzleR);
void setSwizzleG(unsigned int sampler, SwizzleType swizzleG);
void setSwizzleB(unsigned int sampler, SwizzleType swizzleB);
}
else
{
- if(hasFloatTexture()) // FIXME: Mostly identical to integer sampling
+ if(hasFloatTexture() || state.highPrecisionFiltering) // FIXME: Mostly identical to integer sampling
{
Float4 uuuu = u;
Float4 vvvv = v;