Implement OES_texture_float_linear and OES_texture_half_float_linear extensions in WebGL.

Source/core/html/canvas/WebGLRenderingContext.cpp

 /*
  * Copyright (C) 2009 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 20 matching lines @@
 #include "core/html/HTMLCanvasElement.h"
 #include "core/html/HTMLImageElement.h"
 #include "core/html/HTMLVideoElement.h"
 #include "core/html/ImageData.h"
 #include "core/html/canvas/CheckedInt.h"
 #include "core/html/canvas/EXTDrawBuffers.h"
 #include "core/html/canvas/EXTTextureFilterAnisotropic.h"
 #include "core/html/canvas/OESElementIndexUint.h"
 #include "core/html/canvas/OESStandardDerivatives.h"
 #include "core/html/canvas/OESTextureFloat.h"
+#include "core/html/canvas/OESTextureFloatLinear.h"
 #include "core/html/canvas/OESTextureHalfFloat.h"
+#include "core/html/canvas/OESTextureHalfFloatLinear.h"
 #include "core/html/canvas/OESVertexArrayObject.h"
 #include "core/html/canvas/WebGLActiveInfo.h"
 #include "core/html/canvas/WebGLBuffer.h"
 #include "core/html/canvas/WebGLCompressedTextureATC.h"
 #include "core/html/canvas/WebGLCompressedTexturePVRTC.h"
 #include "core/html/canvas/WebGLCompressedTextureS3TC.h"
 #include "core/html/canvas/WebGLContextAttributes.h"
 #include "core/html/canvas/WebGLContextEvent.h"
 #include "core/html/canvas/WebGLContextGroup.h"
 #include "core/html/canvas/WebGLDebugRendererInfo.h"
@@ skipping 566 matching lines @@
     m_maxColorAttachments = 0;
 
     m_backDrawBuffer = GraphicsContext3D::BACK;
 
     m_defaultVertexArrayObject = WebGLVertexArrayObjectOES::create(this, WebGLVertexArrayObjectOES::VaoTypeDefault);
     addContextObject(m_defaultVertexArrayObject.get());
     m_boundVertexArrayObject = m_defaultVertexArrayObject;
     
     m_vertexAttribValue.resize(m_maxVertexAttribs);
 
-    if (!isGLES2NPOTStrict())
-        createFallbackBlackTextures1x1();
+    createFallbackBlackTextures1x1();
 
     IntSize canvasSize = clampedCanvasSize();
     m_drawingBuffer->reset(canvasSize);
 
     m_context->viewport(0, 0, canvasSize.width(), canvasSize.height());
     m_context->scissor(0, 0, canvasSize.width(), canvasSize.height());
 
     m_context->setContextLostCallback(adoptPtr(new WebGLRenderingContextLostCallback(this)));
     m_context->setErrorMessageCallback(adoptPtr(new WebGLRenderingContextErrorMessageCallback(this)));
 
@@ skipping 1081 matching lines @@
     }
 
     const char* reason = "framebuffer incomplete";
     if (m_framebufferBinding && !m_framebufferBinding->onAccess(graphicsContext3D(), &reason)) {
         synthesizeGLError(GraphicsContext3D::INVALID_FRAMEBUFFER_OPERATION, "drawArrays", reason);
         return;
     }
 
     clearIfComposited();
 
-    bool vertexAttrib0Simulated = false;
-    if (!isGLES2NPOTStrict())
-        handleNPOTTextures("drawArrays", true);
+    handleTexturesCompleteness("drawArrays", true);
     m_context->drawArrays(mode, first, count);
-    if (!isGLES2NPOTStrict())
-        handleNPOTTextures("drawArrays", false);
+    handleTexturesCompleteness("drawArrays", false);
     markContextChanged();
 }
 
 void WebGLRenderingContext::drawElements(GC3Denum mode, GC3Dsizei count, GC3Denum type, long long offset, ExceptionCode& ec)
 {
     UNUSED_PARAM(ec);
 
     if (isContextLost() || !validateDrawMode("drawElements", mode))
         return;
 
@@ skipping 35 matching lines @@
         return;
     }
 
     const char* reason = "framebuffer incomplete";
     if (m_framebufferBinding && !m_framebufferBinding->onAccess(graphicsContext3D(), &reason)) {
         synthesizeGLError(GraphicsContext3D::INVALID_FRAMEBUFFER_OPERATION, "drawElements", reason);
         return;
     }
     clearIfComposited();
 
-    if (!isGLES2NPOTStrict())
-        handleNPOTTextures("drawElements", true);
+    handleTexturesCompleteness("drawElements", true);
     m_context->drawElements(mode, count, type, static_cast<GC3Dintptr>(offset));
-    if (!isGLES2NPOTStrict())
-        handleNPOTTextures("drawElements", false);
+    handleTexturesCompleteness("drawElements", false);
     markContextChanged();
 }
 
 void WebGLRenderingContext::enable(GC3Denum cap)
 {
     if (isContextLost() || !validateCapability("enable", cap))
         return;
     if (cap == GraphicsContext3D::STENCIL_TEST) {
         m_stencilEnabled = true;
         applyStencilTest();
@@ skipping 299 matching lines @@
     if (getExtensionIfMatch<WebGLCompressedTextureATC>(name, m_webglCompressedTextureATC, webkitPrefix, extension))
         return extension;
     if (getExtensionIfMatch<WebGLCompressedTexturePVRTC>(name, m_webglCompressedTexturePVRTC, webkitPrefix, extension))
         return extension;
     if (getExtensionIfMatch<WebGLCompressedTextureS3TC>(name, m_webglCompressedTextureS3TC, bothPrefixes, extension))
         return extension;
     if (getExtensionIfMatch<WebGLDepthTexture>(name, m_webglDepthTexture, bothPrefixes, extension))
         return extension;
     if (getExtensionIfMatch<EXTDrawBuffers>(name, m_extDrawBuffers, unprefixed, extension))
         return extension;
+    if (getExtensionIfMatch<OESTextureFloatLinear>(name, m_oesTextureFloatLinear, unprefixed, extension))
+        return extension;
+    if (getExtensionIfMatch<OESTextureHalfFloatLinear>(name, m_oesTextureHalfFloatLinear, unprefixed, extension))
+        return extension;
     if (allowPrivilegedExtensions()) {
         if (getExtensionIfMatch<WebGLDebugRendererInfo>(name, m_webglDebugRendererInfo, unprefixed, extension))
             return extension;
         if (getExtensionIfMatch<WebGLDebugShaders>(name, m_webglDebugShaders, unprefixed, extension))
             return extension;
     }
 
     return 0;
 }
 
@@ skipping 466 matching lines @@
 {
     Vector<String> result;
     if (isContextLost())
         return result;
 
     appendIfSupported<EXTDrawBuffers>(result, false);
     appendIfSupported<EXTTextureFilterAnisotropic>(result, true);
     appendIfSupported<OESElementIndexUint>(result, false);
     appendIfSupported<OESStandardDerivatives>(result, false);
     appendIfSupported<OESTextureFloat>(result, false);
+    appendIfSupported<OESTextureFloatLinear>(result, false);
+    appendIfSupported<OESTextureHalfFloat>(result, false);
+    appendIfSupported<OESTextureHalfFloatLinear>(result, false);
     appendIfSupported<OESVertexArrayObject>(result, false);
     appendIfSupported<WebGLCompressedTextureATC>(result, true);
     appendIfSupported<WebGLCompressedTexturePVRTC>(result, true);
     appendIfSupported<WebGLCompressedTextureS3TC>(result, true);
     appendIfSupported<WebGLDepthTexture>(result, true);
     appendIfSupported<WebGLLoseContext>(result, false);
 
     if (allowPrivilegedExtensions()) {
         appendIfSupported<WebGLDebugShaders>(result, false);
         appendIfSupported<WebGLDebugRendererInfo>(result, false);
@@ skipping 1708 matching lines @@
     case GraphicsContext3D::SCISSOR_BOX:
     case GraphicsContext3D::VIEWPORT:
         length = 4;
         break;
     default:
         notImplemented();
     }
     return WebGLGetInfo(Int32Array::create(value, length));
 }
 
-void WebGLRenderingContext::handleNPOTTextures(const char* functionName, bool prepareToDraw)
+void WebGLRenderingContext::handleTexturesCompleteness(const char* functionName, bool prepareToDraw)
 {
     // All calling functions check isContextLost, so a duplicate check is not needed here.
     bool resetActiveUnit = false;
+    String msgHint = String();
     for (unsigned ii = 0; ii < m_textureUnits.size(); ++ii) {
-        if ((m_textureUnits[ii].m_texture2DBinding && m_textureUnits[ii].m_texture2DBinding->needToUseBlackTexture())
-            || (m_textureUnits[ii].m_textureCubeMapBinding && m_textureUnits[ii].m_textureCubeMapBinding->needToUseBlackTexture())) {
-            if (ii != m_activeTextureUnit) {
-                m_context->activeTexture(ii);
-                resetActiveUnit = true;
-            } else if (resetActiveUnit) {
-                m_context->activeTexture(ii);
-                resetActiveUnit = false;
+        GC3Denum target[7] = { GraphicsContext3D::TEXTURE_2D,

[Ken Russell (switch to Gerrit), 2013/05/13 20:00:35]

Inlining this code here is inefficient and hard to read. Please move it to
WebGLTexture. WebGLTexture::update() should compute whether the texture is both
"complete" and using a float- or half-float format. Then expand
WebGLTexture::needToUseBlackTexture() to take two enum arguments,
TextureFloatLinearEnabled/Disabled and TextureHalfFloatLinearEnabled/Disabled
(you can define these in WebGLTexture.h). If the texture is using floating-point
formats, needToUseBlackTexture() should return false if the appropriate
extension isn't enabled and the filtering modes require it.

+            GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_X, GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_X,
+            GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_Y, GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_Y,
+            GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_Z, GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_Z };
+        for (unsigned i = 0; i < 7; i++) {
+            WebGLTexture* textureBinding =
+                (target[i] == GraphicsContext3D::TEXTURE_2D) ? (m_textureUnits[ii].m_texture2DBinding ? m_textureUnits[ii].m_texture2DBinding.get() : 0)

[Ken Russell (switch to Gerrit), 2013/05/13 20:00:35]

The test here and below is unnecessary; you can just do
m_textureUnits[ii].m_texture2DBinding.get() all the time. The RefPtr is always
there; it just may not have a referent.

+                    : (m_textureUnits[ii].m_textureCubeMapBinding ? m_textureUnits[ii].m_textureCubeMapBinding.get() : 0);
+            if (textureBinding) {
+                bool needToUseBlackTexture = false;
+                if (textureBinding->needToUseBlackTexture()) {
+                    needToUseBlackTexture = true;
+                    msgHint.append("It maybe non-power-of-2 and have incompatible texture filtering or is not 'texture complete");
+                }
+                if ((textureBinding->getType(target[i], 0) == GraphicsContext3D::FLOAT && !m_oesTextureFloatLinear)
+                    || (textureBinding->getType(target[i], 0) == GraphicsContext3D::HALF_FLOAT_OES && !m_oesTextureHalfFloatLinear)) {
+                    if (textureBinding->getMagFilter() != GraphicsContext3D::NEAREST
+                        || (textureBinding->getMinFilter() != GraphicsContext3D::NEAREST && textureBinding->getMinFilter() != GraphicsContext3D::NEAREST_MIPMAP_NEAREST)) {
+                        needToUseBlackTexture = true;
+                        msgHint.append("the texture is of Float type and requires a linear filtering but the linear filtering extension is disabled or not supported.");
+                    }
+                }
+                if (needToUseBlackTexture) {
+                    if (ii != m_activeTextureUnit) {
+                        m_context->activeTexture(ii);
+                        resetActiveUnit = true;
+                    } else if (resetActiveUnit) {
+                        m_context->activeTexture(ii);
+                        resetActiveUnit = false;
+                    }
+                    WebGLTexture* texTemp = 0;
+                    if (prepareToDraw) {
+                        String msg(String("texture bound to texture unit ") + String::number(ii)
+                            + " is not renderable: " + msgHint);
+                        printGLWarningToConsole(functionName, msg.utf8().data());
+                        texTemp = (target[i] == GraphicsContext3D::TEXTURE_2D) ? m_blackTexture2D.get() : m_blackTextureCubeMap.get();
+                    } else
+                        texTemp = (target[i] == GraphicsContext3D::TEXTURE_2D) ? m_textureUnits[ii].m_texture2DBinding.get() : m_textureUnits[ii].m_textureCubeMapBinding.get();
+                    m_context->bindTexture((target[i] == GraphicsContext3D::TEXTURE_2D) ? GraphicsContext3D::TEXTURE_2D : GraphicsContext3D::TEXTURE_CUBE_MAP, objectOrZero(texTemp));
+                }
             }
-            WebGLTexture* tex2D;
-            WebGLTexture* texCubeMap;
-            if (prepareToDraw) {
-                String msg(String("texture bound to texture unit ") + String::number(ii)
-                    + " is not renderable. It maybe non-power-of-2 and have incompatible texture filtering or is not 'texture complete'");
-                printGLWarningToConsole(functionName, msg.utf8().data());
-                tex2D = m_blackTexture2D.get();
-                texCubeMap = m_blackTextureCubeMap.get();
-            } else {
-                tex2D = m_textureUnits[ii].m_texture2DBinding.get();
-                texCubeMap = m_textureUnits[ii].m_textureCubeMapBinding.get();
-            }
-            if (m_textureUnits[ii].m_texture2DBinding && m_textureUnits[ii].m_texture2DBinding->needToUseBlackTexture())
-                m_context->bindTexture(GraphicsContext3D::TEXTURE_2D, objectOrZero(tex2D));
-            if (m_textureUnits[ii].m_textureCubeMapBinding && m_textureUnits[ii].m_textureCubeMapBinding->needToUseBlackTexture())
-                m_context->bindTexture(GraphicsContext3D::TEXTURE_CUBE_MAP, objectOrZero(texCubeMap));
         }
     }
     if (resetActiveUnit)
         m_context->activeTexture(m_activeTextureUnit);
 }
 
 void WebGLRenderingContext::createFallbackBlackTextures1x1()
 {
     // All calling functions check isContextLost, so a duplicate check is not needed here.
     unsigned char black[] = {0, 0, 0, 255};
@@ skipping 1080 matching lines @@
     bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, m_framebufferBinding.get(), ec);
 }
 
 void WebGLRenderingContext::restoreCurrentTexture2D()
 {
     ExceptionCode ec;
     bindTexture(GraphicsContext3D::TEXTURE_2D, m_textureUnits[m_activeTextureUnit].m_texture2DBinding.get(), ec);
 }
 
 } // namespace WebCore