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 575 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 1094 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);
+    handleTextureCompleteness("drawArrays", true);
     m_context->drawArrays(mode, first, count);
-    if (!isGLES2NPOTStrict())
-        handleNPOTTextures("drawArrays", false);
+    handleTextureCompleteness("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);
+    handleTextureCompleteness("drawElements", true);
     m_context->drawElements(mode, count, type, static_cast<GC3Dintptr>(offset));
-    if (!isGLES2NPOTStrict())
-        handleNPOTTextures("drawElements", false);
+    handleTextureCompleteness("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::handleTextureCompleteness(const char* functionName, bool prepareToDraw)
 {
     // All calling functions check isContextLost, so a duplicate check is not needed here.
     bool resetActiveUnit = false;
+    WebGLTexture::TextureExtensionFlag flag = static_cast<WebGLTexture::TextureExtensionFlag>((m_oesTextureFloatLinear ? WebGLTexture::TextureFloatLinearExtensionEnabled : 0)
+        | (m_oesTextureHalfFloatLinear ? WebGLTexture::TextureHalfFloatLinearExtensionEnabled : 0));
     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 ((m_textureUnits[ii].m_texture2DBinding.get() && m_textureUnits[ii].m_texture2DBinding->needToUseBlackTexture(flag))
+            || (m_textureUnits[ii].m_textureCubeMapBinding.get() && m_textureUnits[ii].m_textureCubeMapBinding->needToUseBlackTexture(flag))) {
             if (ii != m_activeTextureUnit) {
                 m_context->activeTexture(ii);
                 resetActiveUnit = true;
             } else if (resetActiveUnit) {
                 m_context->activeTexture(ii);
                 resetActiveUnit = false;
             }
             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'");
+                    + " is not renderable. It maybe non-power-of-2 and have incompatible texture filtering or is not 'texture complete'."
+                    + " Or the texture is Float or Half Float type with linear filtering while OES_float_linear or OES_half_float_linear extension is not enabled.");
                 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())
+            if (m_textureUnits[ii].m_texture2DBinding && m_textureUnits[ii].m_texture2DBinding->needToUseBlackTexture(flag))
                 m_context->bindTexture(GraphicsContext3D::TEXTURE_2D, objectOrZero(tex2D));
-            if (m_textureUnits[ii].m_textureCubeMapBinding && m_textureUnits[ii].m_textureCubeMapBinding->needToUseBlackTexture())
+            if (m_textureUnits[ii].m_textureCubeMapBinding && m_textureUnits[ii].m_textureCubeMapBinding->needToUseBlackTexture(flag))
                 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.
@@ skipping 1095 matching lines @@
 
 void WebGLRenderingContext::multisamplingChanged(bool enabled)
 {
     if (m_multisamplingAllowed != enabled) {
         m_multisamplingAllowed = enabled;
         forceLostContext(WebGLRenderingContext::AutoRecoverSyntheticLostContext);
     }
 }
 
 } // namespace WebCore