blob: 597217d7f052d8c319099a8631d94493b8b438c2 [file] [log] [blame]
/*
* 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
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "modules/webgl/WebGLRenderingContextBase.h"
#include "bindings/core/v8/ExceptionMessages.h"
#include "bindings/core/v8/ExceptionState.h"
#include "bindings/core/v8/V8BindingMacros.h"
#include "bindings/modules/v8/HTMLCanvasElementOrOffscreenCanvas.h"
#include "bindings/modules/v8/WebGLAny.h"
#include "core/dom/DOMArrayBuffer.h"
#include "core/dom/DOMTypedArray.h"
#include "core/dom/FlexibleArrayBufferView.h"
#include "core/fetch/ImageResource.h"
#include "core/frame/ImageBitmap.h"
#include "core/frame/LocalFrame.h"
#include "core/frame/Settings.h"
#include "core/html/HTMLCanvasElement.h"
#include "core/html/HTMLImageElement.h"
#include "core/html/HTMLVideoElement.h"
#include "core/html/ImageData.h"
#include "core/inspector/ConsoleMessage.h"
#include "core/inspector/InspectorInstrumentation.h"
#include "core/layout/LayoutBox.h"
#include "core/loader/FrameLoader.h"
#include "core/loader/FrameLoaderClient.h"
#include "gpu/command_buffer/client/gles2_interface.h"
#include "modules/webgl/ANGLEInstancedArrays.h"
#include "modules/webgl/EXTBlendMinMax.h"
#include "modules/webgl/EXTFragDepth.h"
#include "modules/webgl/EXTShaderTextureLOD.h"
#include "modules/webgl/EXTTextureFilterAnisotropic.h"
#include "modules/webgl/GLStringQuery.h"
#include "modules/webgl/OESElementIndexUint.h"
#include "modules/webgl/OESStandardDerivatives.h"
#include "modules/webgl/OESTextureFloat.h"
#include "modules/webgl/OESTextureFloatLinear.h"
#include "modules/webgl/OESTextureHalfFloat.h"
#include "modules/webgl/OESTextureHalfFloatLinear.h"
#include "modules/webgl/OESVertexArrayObject.h"
#include "modules/webgl/WebGLActiveInfo.h"
#include "modules/webgl/WebGLBuffer.h"
#include "modules/webgl/WebGLCompressedTextureASTC.h"
#include "modules/webgl/WebGLCompressedTextureATC.h"
#include "modules/webgl/WebGLCompressedTextureETC1.h"
#include "modules/webgl/WebGLCompressedTexturePVRTC.h"
#include "modules/webgl/WebGLCompressedTextureS3TC.h"
#include "modules/webgl/WebGLContextAttributeHelpers.h"
#include "modules/webgl/WebGLContextEvent.h"
#include "modules/webgl/WebGLContextGroup.h"
#include "modules/webgl/WebGLDebugRendererInfo.h"
#include "modules/webgl/WebGLDebugShaders.h"
#include "modules/webgl/WebGLDepthTexture.h"
#include "modules/webgl/WebGLDrawBuffers.h"
#include "modules/webgl/WebGLFramebuffer.h"
#include "modules/webgl/WebGLLoseContext.h"
#include "modules/webgl/WebGLProgram.h"
#include "modules/webgl/WebGLRenderbuffer.h"
#include "modules/webgl/WebGLShader.h"
#include "modules/webgl/WebGLShaderPrecisionFormat.h"
#include "modules/webgl/WebGLUniformLocation.h"
#include "modules/webgl/WebGLVertexArrayObject.h"
#include "modules/webgl/WebGLVertexArrayObjectOES.h"
#include "platform/CheckedInt.h"
#include "platform/CrossThreadFunctional.h"
#include "platform/RuntimeEnabledFeatures.h"
#include "platform/WaitableEvent.h"
#include "platform/geometry/IntSize.h"
#include "platform/graphics/GraphicsContext.h"
#include "platform/graphics/UnacceleratedImageBufferSurface.h"
#include "platform/graphics/gpu/AcceleratedImageBufferSurface.h"
#include "public/platform/Platform.h"
#include "public/platform/functional/WebFunction.h"
#include "wtf/Functional.h"
#include "wtf/PtrUtil.h"
#include "wtf/text/StringBuilder.h"
#include "wtf/text/StringUTF8Adaptor.h"
#include "wtf/typed_arrays/ArrayBufferContents.h"
#include <memory>
namespace blink {
namespace {
const double secondsBetweenRestoreAttempts = 1.0;
const int maxGLErrorsAllowedToConsole = 256;
const unsigned maxGLActiveContexts = 16;
const unsigned maxGLActiveContextsOnWorker = 4;
unsigned currentMaxGLContexts()
{
return isMainThread() ? maxGLActiveContexts : maxGLActiveContextsOnWorker;
}
using WebGLRenderingContextBaseSet = PersistentHeapHashSet<WeakMember<WebGLRenderingContextBase>>;
WebGLRenderingContextBaseSet& activeContexts()
{
DEFINE_THREAD_SAFE_STATIC_LOCAL(ThreadSpecific<WebGLRenderingContextBaseSet>, activeContexts, new ThreadSpecific<WebGLRenderingContextBaseSet>());
if (!activeContexts.isSet())
activeContexts->registerAsStaticReference();
return *activeContexts;
}
using WebGLRenderingContextBaseMap = PersistentHeapHashMap<WeakMember<WebGLRenderingContextBase>, int>;
WebGLRenderingContextBaseMap& forciblyEvictedContexts()
{
DEFINE_THREAD_SAFE_STATIC_LOCAL(ThreadSpecific<WebGLRenderingContextBaseMap>, forciblyEvictedContexts, new ThreadSpecific<WebGLRenderingContextBaseMap>());
if (!forciblyEvictedContexts.isSet())
forciblyEvictedContexts->registerAsStaticReference();
return *forciblyEvictedContexts;
}
} // namespace
ScopedRGBEmulationColorMask::ScopedRGBEmulationColorMask(gpu::gles2::GLES2Interface* contextGL, GLboolean* colorMask, DrawingBuffer* drawingBuffer)
: m_contextGL(contextGL)
, m_requiresEmulation(drawingBuffer->requiresAlphaChannelToBePreserved())
{
if (m_requiresEmulation) {
memcpy(m_colorMask, colorMask, 4 * sizeof(GLboolean));
m_contextGL->ColorMask(m_colorMask[0], m_colorMask[1], m_colorMask[2], false);
}
}
ScopedRGBEmulationColorMask::~ScopedRGBEmulationColorMask()
{
if (m_requiresEmulation)
m_contextGL->ColorMask(m_colorMask[0], m_colorMask[1], m_colorMask[2], m_colorMask[3]);
}
void WebGLRenderingContextBase::forciblyLoseOldestContext(const String& reason)
{
WebGLRenderingContextBase* candidate = oldestContext();
if (!candidate)
return;
candidate->printWarningToConsole(reason);
InspectorInstrumentation::didFireWebGLWarning(candidate->canvas());
// This will call deactivateContext once the context has actually been lost.
candidate->forceLostContext(WebGLRenderingContextBase::SyntheticLostContext, WebGLRenderingContextBase::WhenAvailable);
}
WebGLRenderingContextBase* WebGLRenderingContextBase::oldestContext()
{
if (activeContexts().isEmpty())
return nullptr;
WebGLRenderingContextBase* candidate = *(activeContexts().begin());
ASSERT(!candidate->isContextLost());
for (WebGLRenderingContextBase* context : activeContexts()) {
ASSERT(!context->isContextLost());
if (context->contextGL()->GetLastFlushIdCHROMIUM() < candidate->contextGL()->GetLastFlushIdCHROMIUM()) {
candidate = context;
}
}
return candidate;
}
WebGLRenderingContextBase* WebGLRenderingContextBase::oldestEvictedContext()
{
if (forciblyEvictedContexts().isEmpty())
return nullptr;
WebGLRenderingContextBase* candidate = nullptr;
int generation = -1;
for (WebGLRenderingContextBase* context : forciblyEvictedContexts().keys()) {
if (!candidate || forciblyEvictedContexts().get(context) < generation) {
candidate = context;
generation = forciblyEvictedContexts().get(context);
}
}
return candidate;
}
void WebGLRenderingContextBase::activateContext(WebGLRenderingContextBase* context)
{
unsigned maxGLContexts = currentMaxGLContexts();
unsigned removedContexts = 0;
while (activeContexts().size() >= maxGLContexts && removedContexts < maxGLContexts) {
forciblyLoseOldestContext("WARNING: Too many active WebGL contexts. Oldest context will be lost.");
removedContexts++;
}
ASSERT(!context->isContextLost());
activeContexts().add(context);
}
void WebGLRenderingContextBase::deactivateContext(WebGLRenderingContextBase* context)
{
activeContexts().remove(context);
}
void WebGLRenderingContextBase::addToEvictedList(WebGLRenderingContextBase* context)
{
static int generation = 0;
forciblyEvictedContexts().set(context, generation++);
}
void WebGLRenderingContextBase::removeFromEvictedList(WebGLRenderingContextBase* context)
{
forciblyEvictedContexts().remove(context);
}
void WebGLRenderingContextBase::willDestroyContext(WebGLRenderingContextBase* context)
{
// These two sets keep weak references to their contexts;
// verify that the GC already removed the |context| entries.
ASSERT(!forciblyEvictedContexts().contains(context));
ASSERT(!activeContexts().contains(context));
unsigned maxGLContexts = currentMaxGLContexts();
// Try to re-enable the oldest inactive contexts.
while (activeContexts().size() < maxGLContexts && forciblyEvictedContexts().size()) {
WebGLRenderingContextBase* evictedContext = oldestEvictedContext();
if (!evictedContext->m_restoreAllowed) {
forciblyEvictedContexts().remove(evictedContext);
continue;
}
IntSize desiredSize = DrawingBuffer::adjustSize(evictedContext->clampedCanvasSize(), IntSize(), evictedContext->m_maxTextureSize);
// If there's room in the pixel budget for this context, restore it.
if (!desiredSize.isEmpty()) {
forciblyEvictedContexts().remove(evictedContext);
evictedContext->forceRestoreContext();
}
break;
}
}
namespace {
GLint clamp(GLint value, GLint min, GLint max)
{
if (value < min)
value = min;
if (value > max)
value = max;
return value;
}
// Return true if a character belongs to the ASCII subset as defined in
// GLSL ES 1.0 spec section 3.1.
bool validateCharacter(unsigned char c)
{
// Printing characters are valid except " $ ` @ \ ' DEL.
if (c >= 32 && c <= 126
&& c != '"' && c != '$' && c != '`' && c != '@' && c != '\\' && c != '\'')
return true;
// Horizontal tab, line feed, vertical tab, form feed, carriage return
// are also valid.
if (c >= 9 && c <= 13)
return true;
return false;
}
bool isPrefixReserved(const String& name)
{
if (name.startsWith("gl_") || name.startsWith("webgl_") || name.startsWith("_webgl_"))
return true;
return false;
}
// Strips comments from shader text. This allows non-ASCII characters
// to be used in comments without potentially breaking OpenGL
// implementations not expecting characters outside the GLSL ES set.
class StripComments {
public:
StripComments(const String& str)
: m_parseState(BeginningOfLine)
, m_sourceString(str)
, m_length(str.length())
, m_position(0)
{
parse();
}
String result()
{
return m_builder.toString();
}
private:
bool hasMoreCharacters() const
{
return (m_position < m_length);
}
void parse()
{
while (hasMoreCharacters()) {
process(current());
// process() might advance the position.
if (hasMoreCharacters())
advance();
}
}
void process(UChar);
bool peek(UChar& character) const
{
if (m_position + 1 >= m_length)
return false;
character = m_sourceString[m_position + 1];
return true;
}
UChar current()
{
ASSERT_WITH_SECURITY_IMPLICATION(m_position < m_length);
return m_sourceString[m_position];
}
void advance()
{
++m_position;
}
static bool isNewline(UChar character)
{
// Don't attempt to canonicalize newline related characters.
return (character == '\n' || character == '\r');
}
void emit(UChar character)
{
m_builder.append(character);
}
enum ParseState {
// Have not seen an ASCII non-whitespace character yet on
// this line. Possible that we might see a preprocessor
// directive.
BeginningOfLine,
// Have seen at least one ASCII non-whitespace character
// on this line.
MiddleOfLine,
// Handling a preprocessor directive. Passes through all
// characters up to the end of the line. Disables comment
// processing.
InPreprocessorDirective,
// Handling a single-line comment. The comment text is
// replaced with a single space.
InSingleLineComment,
// Handling a multi-line comment. Newlines are passed
// through to preserve line numbers.
InMultiLineComment
};
ParseState m_parseState;
String m_sourceString;
unsigned m_length;
unsigned m_position;
StringBuilder m_builder;
};
void StripComments::process(UChar c)
{
if (isNewline(c)) {
// No matter what state we are in, pass through newlines
// so we preserve line numbers.
emit(c);
if (m_parseState != InMultiLineComment)
m_parseState = BeginningOfLine;
return;
}
UChar temp = 0;
switch (m_parseState) {
case BeginningOfLine:
if (WTF::isASCIISpace(c)) {
emit(c);
break;
}
if (c == '#') {
m_parseState = InPreprocessorDirective;
emit(c);
break;
}
// Transition to normal state and re-handle character.
m_parseState = MiddleOfLine;
process(c);
break;
case MiddleOfLine:
if (c == '/' && peek(temp)) {
if (temp == '/') {
m_parseState = InSingleLineComment;
emit(' ');
advance();
break;
}
if (temp == '*') {
m_parseState = InMultiLineComment;
// Emit the comment start in case the user has
// an unclosed comment and we want to later
// signal an error.
emit('/');
emit('*');
advance();
break;
}
}
emit(c);
break;
case InPreprocessorDirective:
// No matter what the character is, just pass it
// through. Do not parse comments in this state. This
// might not be the right thing to do long term, but it
// should handle the #error preprocessor directive.
emit(c);
break;
case InSingleLineComment:
// Line-continuation characters are processed before comment processing.
// Advance string if a new line character is immediately behind
// line-continuation character.
if (c == '\\') {
if (peek(temp) && isNewline(temp))
advance();
}
// The newline code at the top of this function takes care
// of resetting our state when we get out of the
// single-line comment. Swallow all other characters.
break;
case InMultiLineComment:
if (c == '*' && peek(temp) && temp == '/') {
emit('*');
emit('/');
m_parseState = MiddleOfLine;
advance();
break;
}
// Swallow all other characters. Unclear whether we may
// want or need to just emit a space per character to try
// to preserve column numbers for debugging purposes.
break;
}
}
static bool shouldFailContextCreationForTesting = false;
} // namespace
class ScopedTexture2DRestorer {
STACK_ALLOCATED();
public:
explicit ScopedTexture2DRestorer(WebGLRenderingContextBase* context)
: m_context(context)
{
}
~ScopedTexture2DRestorer()
{
m_context->restoreCurrentTexture2D();
}
private:
Member<WebGLRenderingContextBase> m_context;
};
class ScopedFramebufferRestorer {
STACK_ALLOCATED();
public:
explicit ScopedFramebufferRestorer(WebGLRenderingContextBase* context)
: m_context(context)
{
}
~ScopedFramebufferRestorer()
{
m_context->restoreCurrentFramebuffer();
}
private:
Member<WebGLRenderingContextBase> m_context;
};
static void formatWebGLStatusString(const StringView& glInfo, const StringView& infoString, StringBuilder& builder)
{
if (infoString.isEmpty())
return;
builder.append(", ");
builder.append(glInfo);
builder.append(" = ");
builder.append(infoString);
}
static String extractWebGLContextCreationError(const Platform::GraphicsInfo& info)
{
StringBuilder builder;
builder.append("Could not create a WebGL context");
formatWebGLStatusString("VENDOR", info.vendorId ? String::format("0x%04x", info.vendorId) : "0xffff", builder);
formatWebGLStatusString("DEVICE", info.deviceId ? String::format("0x%04x", info.deviceId) : "0xffff", builder);
formatWebGLStatusString("GL_VENDOR", info.vendorInfo, builder);
formatWebGLStatusString("GL_RENDERER", info.rendererInfo, builder);
formatWebGLStatusString("GL_VERSION", info.driverVersion, builder);
formatWebGLStatusString("Sandboxed", info.sandboxed ? "yes" : "no", builder);
formatWebGLStatusString("Optimus", info.optimus ? "yes" : "no", builder);
formatWebGLStatusString("AMD switchable", info.amdSwitchable ? "yes" : "no", builder);
formatWebGLStatusString("Reset notification strategy", String::format("0x%04x", info.resetNotificationStrategy).utf8().data(), builder);
formatWebGLStatusString("GPU process crash count", String::number(info.processCrashCount), builder);
formatWebGLStatusString("ErrorMessage", info.errorMessage.utf8().data(), builder);
builder.append('.');
return builder.toString();
}
struct ContextProviderCreationInfo {
// Inputs.
Platform::ContextAttributes contextAttributes;
Platform::GraphicsInfo* glInfo;
ScriptState* scriptState;
// Outputs.
std::unique_ptr<WebGraphicsContext3DProvider> createdContextProvider;
};
static void createContextProviderOnMainThread(ContextProviderCreationInfo* creationInfo, WaitableEvent* waitableEvent)
{
ASSERT(isMainThread());
creationInfo->createdContextProvider = wrapUnique(Platform::current()->createOffscreenGraphicsContext3DProvider(
creationInfo->contextAttributes, creationInfo->scriptState->getExecutionContext()->url(), 0, creationInfo->glInfo));
waitableEvent->signal();
}
static std::unique_ptr<WebGraphicsContext3DProvider> createContextProviderOnWorkerThread(Platform::ContextAttributes contextAttributes, Platform::GraphicsInfo* glInfo, ScriptState* scriptState)
{
WaitableEvent waitableEvent;
ContextProviderCreationInfo creationInfo;
creationInfo.contextAttributes = contextAttributes;
creationInfo.glInfo = glInfo;
creationInfo.scriptState = scriptState;
WebTaskRunner* taskRunner = Platform::current()->mainThread()->getWebTaskRunner();
taskRunner->postTask(BLINK_FROM_HERE, crossThreadBind(&createContextProviderOnMainThread, crossThreadUnretained(&creationInfo), crossThreadUnretained(&waitableEvent)));
waitableEvent.wait();
return std::move(creationInfo.createdContextProvider);
}
std::unique_ptr<WebGraphicsContext3DProvider> WebGLRenderingContextBase::createContextProviderInternal(HTMLCanvasElement* canvas, ScriptState* scriptState, const CanvasContextCreationAttributes& attributes, unsigned webGLVersion)
{
// Exactly one of these must be provided.
DCHECK_EQ(!canvas, !!scriptState);
// The canvas is only given on the main thread.
DCHECK(!canvas || isMainThread());
Platform::ContextAttributes contextAttributes = toPlatformContextAttributes(attributes, webGLVersion);
Platform::GraphicsInfo glInfo;
std::unique_ptr<WebGraphicsContext3DProvider> contextProvider;
if (isMainThread()) {
const auto& url = canvas ? canvas->document().topDocument().url() : scriptState->getExecutionContext()->url();
contextProvider = wrapUnique(Platform::current()->createOffscreenGraphicsContext3DProvider(
contextAttributes, url, 0, &glInfo));
} else {
contextProvider = createContextProviderOnWorkerThread(contextAttributes, &glInfo, scriptState);
}
if (contextProvider && !contextProvider->bindToCurrentThread()) {
contextProvider = nullptr;
String errorString(glInfo.errorMessage.utf8().data());
errorString.insert("bindToCurrentThread failed: ", 0);
glInfo.errorMessage = errorString;
}
if (!contextProvider || shouldFailContextCreationForTesting) {
shouldFailContextCreationForTesting = false;
if (canvas)
canvas->dispatchEvent(WebGLContextEvent::create(EventTypeNames::webglcontextcreationerror, false, true, extractWebGLContextCreationError(glInfo)));
return nullptr;
}
gpu::gles2::GLES2Interface* gl = contextProvider->contextGL();
if (!String(gl->GetString(GL_EXTENSIONS)).contains("GL_OES_packed_depth_stencil")) {
if (canvas)
canvas->dispatchEvent(WebGLContextEvent::create(EventTypeNames::webglcontextcreationerror, false, true, "OES_packed_depth_stencil support is required."));
return nullptr;
}
return contextProvider;
}
std::unique_ptr<WebGraphicsContext3DProvider> WebGLRenderingContextBase::createWebGraphicsContext3DProvider(HTMLCanvasElement* canvas, const CanvasContextCreationAttributes& attributes, unsigned webGLVersion)
{
Document& document = canvas->document();
LocalFrame* frame = document.frame();
if (!frame) {
canvas->dispatchEvent(WebGLContextEvent::create(EventTypeNames::webglcontextcreationerror, false, true, "Web page was not allowed to create a WebGL context."));
return nullptr;
}
Settings* settings = frame->settings();
// The FrameLoaderClient might block creation of a new WebGL context despite the page settings; in
// particular, if WebGL contexts were lost one or more times via the GL_ARB_robustness extension.
if (!frame->loader().client()->allowWebGL(settings && settings->webGLEnabled())) {
canvas->dispatchEvent(WebGLContextEvent::create(EventTypeNames::webglcontextcreationerror, false, true, "Web page was not allowed to create a WebGL context."));
return nullptr;
}
return createContextProviderInternal(canvas, nullptr, attributes, webGLVersion);
}
std::unique_ptr<WebGraphicsContext3DProvider> WebGLRenderingContextBase::createWebGraphicsContext3DProvider(ScriptState* scriptState, const CanvasContextCreationAttributes& attributes, unsigned webGLVersion)
{
return createContextProviderInternal(nullptr, scriptState, attributes, webGLVersion);
}
void WebGLRenderingContextBase::forceNextWebGLContextCreationToFail()
{
shouldFailContextCreationForTesting = true;
}
ImageBitmap* WebGLRenderingContextBase::transferToImageBitmapBase()
{
if (!drawingBuffer())
return nullptr;
return ImageBitmap::create(drawingBuffer()->transferToStaticBitmapImage());
}
namespace {
// ES2 enums
static const GLenum kSupportedInternalFormatsES2[] = {
GL_RGB,
GL_RGBA,
GL_LUMINANCE_ALPHA,
GL_LUMINANCE,
GL_ALPHA,
};
// Exposed by GL_ANGLE_depth_texture
static const GLenum kSupportedInternalFormatsOESDepthTex[] = {
GL_DEPTH_COMPONENT,
GL_DEPTH_STENCIL,
};
// Exposed by GL_EXT_sRGB
static const GLenum kSupportedInternalFormatsEXTsRGB[] = {
GL_SRGB,
GL_SRGB_ALPHA_EXT,
};
// ES3 enums supported by both CopyTexImage and TexImage.
static const GLenum kSupportedInternalFormatsES3[] = {
GL_R8,
GL_RG8,
GL_RGB565,
GL_RGB8,
GL_RGBA4,
GL_RGB5_A1,
GL_RGBA8,
GL_RGB10_A2,
GL_RGB10_A2UI,
GL_SRGB8,
GL_SRGB8_ALPHA8,
GL_R8I,
GL_R8UI,
GL_R16I,
GL_R16UI,
GL_R32I,
GL_R32UI,
GL_RG8I,
GL_RG8UI,
GL_RG16I,
GL_RG16UI,
GL_RG32I,
GL_RG32UI,
GL_RGBA8I,
GL_RGBA8UI,
GL_RGBA16I,
GL_RGBA16UI,
GL_RGBA32I,
GL_RGBA32UI,
};
// ES3 enums only supported by TexImage
static const GLenum kSupportedInternalFormatsTexImageES3[] = {
GL_R8_SNORM,
GL_R16F,
GL_R32F,
GL_RG8_SNORM,
GL_RG16F,
GL_RG32F,
GL_RGB8_SNORM,
GL_R11F_G11F_B10F,
GL_RGB9_E5,
GL_RGB16F,
GL_RGB32F,
GL_RGB8UI,
GL_RGB8I,
GL_RGB16UI,
GL_RGB16I,
GL_RGB32UI,
GL_RGB32I,
GL_RGBA8_SNORM,
GL_RGBA16F,
GL_RGBA32F,
GL_DEPTH_COMPONENT16,
GL_DEPTH_COMPONENT24,
GL_DEPTH_COMPONENT32F,
GL_DEPTH24_STENCIL8,
GL_DEPTH32F_STENCIL8,
};
// ES2 enums
static const GLenum kSupportedFormatsES2[] = {
GL_RGB,
GL_RGBA,
GL_LUMINANCE_ALPHA,
GL_LUMINANCE,
GL_ALPHA,
};
// Exposed by GL_ANGLE_depth_texture
static const GLenum kSupportedFormatsOESDepthTex[] = {
GL_DEPTH_COMPONENT,
GL_DEPTH_STENCIL,
};
// Exposed by GL_EXT_sRGB
static const GLenum kSupportedFormatsEXTsRGB[] = {
GL_SRGB,
GL_SRGB_ALPHA_EXT,
};
// ES3 enums
static const GLenum kSupportedFormatsES3[] = {
GL_RED,
GL_RED_INTEGER,
GL_RG,
GL_RG_INTEGER,
GL_RGB,
GL_RGB_INTEGER,
GL_RGBA,
GL_RGBA_INTEGER,
GL_DEPTH_COMPONENT,
GL_DEPTH_STENCIL,
};
// ES2 enums
static const GLenum kSupportedTypesES2[] = {
GL_UNSIGNED_BYTE,
GL_UNSIGNED_SHORT_5_6_5,
GL_UNSIGNED_SHORT_4_4_4_4,
GL_UNSIGNED_SHORT_5_5_5_1,
};
// Exposed by GL_OES_texture_float
static const GLenum kSupportedTypesOESTexFloat[] = {
GL_FLOAT,
};
// Exposed by GL_OES_texture_half_float
static const GLenum kSupportedTypesOESTexHalfFloat[] = {
GL_HALF_FLOAT_OES,
};
// Exposed by GL_ANGLE_depth_texture
static const GLenum kSupportedTypesOESDepthTex[] = {
GL_UNSIGNED_SHORT,
GL_UNSIGNED_INT,
GL_UNSIGNED_INT_24_8,
};
// ES3 enums
static const GLenum kSupportedTypesES3[] = {
GL_BYTE,
GL_UNSIGNED_SHORT,
GL_SHORT,
GL_UNSIGNED_INT,
GL_INT,
GL_HALF_FLOAT,
GL_FLOAT,
GL_UNSIGNED_INT_2_10_10_10_REV,
GL_UNSIGNED_INT_10F_11F_11F_REV,
GL_UNSIGNED_INT_5_9_9_9_REV,
GL_UNSIGNED_INT_24_8,
GL_FLOAT_32_UNSIGNED_INT_24_8_REV,
};
bool isUnsignedIntegerFormat(GLenum internalformat)
{
switch (internalformat) {
case GL_R8UI:
case GL_R16UI:
case GL_R32UI:
case GL_RG8UI:
case GL_RG16UI:
case GL_RG32UI:
case GL_RGB8UI:
case GL_RGB16UI:
case GL_RGB32UI:
case GL_RGBA8UI:
case GL_RGB10_A2UI:
case GL_RGBA16UI:
case GL_RGBA32UI:
return true;
default:
return false;
}
}
bool isSignedIntegerFormat(GLenum internalformat)
{
switch (internalformat) {
case GL_R8I:
case GL_R16I:
case GL_R32I:
case GL_RG8I:
case GL_RG16I:
case GL_RG32I:
case GL_RGB8I:
case GL_RGB16I:
case GL_RGB32I:
case GL_RGBA8I:
case GL_RGBA16I:
case GL_RGBA32I:
return true;
default:
return false;
}
}
bool isIntegerFormat(GLenum internalformat)
{
return (isUnsignedIntegerFormat(internalformat) || isSignedIntegerFormat(internalformat));
}
bool isFloatType(GLenum type)
{
switch (type) {
case GL_FLOAT:
case GL_HALF_FLOAT:
case GL_HALF_FLOAT_OES:
case GL_UNSIGNED_INT_10F_11F_11F_REV:
return true;
default:
return false;
}
}
bool isSRGBFormat(GLenum internalformat)
{
switch (internalformat) {
case GL_SRGB_EXT:
case GL_SRGB_ALPHA_EXT:
case GL_SRGB8:
case GL_SRGB8_ALPHA8:
return true;
default:
return false;
}
}
} // namespace
WebGLRenderingContextBase::WebGLRenderingContextBase(OffscreenCanvas* passedOffscreenCanvas,
std::unique_ptr<WebGraphicsContext3DProvider> contextProvider,
const CanvasContextCreationAttributes& requestedAttributes, unsigned version)
: WebGLRenderingContextBase(nullptr, passedOffscreenCanvas, std::move(contextProvider), requestedAttributes, version)
{ }
WebGLRenderingContextBase::WebGLRenderingContextBase(HTMLCanvasElement* passedCanvas,
std::unique_ptr<WebGraphicsContext3DProvider> contextProvider,
const CanvasContextCreationAttributes& requestedAttributes, unsigned version)
: WebGLRenderingContextBase(passedCanvas, nullptr, std::move(contextProvider), requestedAttributes, version)
{ }
WebGLRenderingContextBase::WebGLRenderingContextBase(HTMLCanvasElement* passedCanvas,
OffscreenCanvas* passedOffscreenCanvas, std::unique_ptr<WebGraphicsContext3DProvider> contextProvider,
const CanvasContextCreationAttributes& requestedAttributes, unsigned version)
: CanvasRenderingContext(passedCanvas, passedOffscreenCanvas, requestedAttributes)
, m_isHidden(false)
, m_contextLostMode(NotLostContext)
, m_autoRecoveryMethod(Manual)
, m_dispatchContextLostEventTimer(this, &WebGLRenderingContextBase::dispatchContextLostEvent)
, m_restoreAllowed(false)
, m_restoreTimer(this, &WebGLRenderingContextBase::maybeRestoreContext)
, m_preservedDefaultVAOObjectWrapper(false)
, m_generatedImageCache(4)
, m_synthesizedErrorsToConsole(true)
, m_numGLErrorsToConsoleAllowed(maxGLErrorsAllowedToConsole)
, m_onePlusMaxNonDefaultTextureUnit(0)
, m_isWebGL2FormatsTypesAdded(false)
, m_isWebGL2InternalFormatsCopyTexImageAdded(false)
, m_isOESTextureFloatFormatsTypesAdded(false)
, m_isOESTextureHalfFloatFormatsTypesAdded(false)
, m_isWebGLDepthTextureFormatsTypesAdded(false)
, m_isEXTsRGBFormatsTypesAdded(false)
, m_version(version)
{
ASSERT(contextProvider);
m_contextGroup = WebGLContextGroup::create();
m_contextGroup->addContext(this);
m_maxViewportDims[0] = m_maxViewportDims[1] = 0;
contextProvider->contextGL()->GetIntegerv(GL_MAX_VIEWPORT_DIMS, m_maxViewportDims);
RefPtr<DrawingBuffer> buffer = createDrawingBuffer(std::move(contextProvider));
if (!buffer) {
m_contextLostMode = SyntheticLostContext;
return;
}
m_drawingBuffer = buffer.release();
m_drawingBuffer->addNewMailboxCallback(WTF::bind(&WebGLRenderingContextBase::notifyCanvasContextChanged, wrapWeakPersistent(this)));
drawingBuffer()->bind(GL_FRAMEBUFFER);
setupFlags();
#define ADD_VALUES_TO_SET(set, values) \
for (size_t i = 0; i < WTF_ARRAY_LENGTH(values); ++i) { \
set.insert(values[i]); \
}
ADD_VALUES_TO_SET(m_supportedInternalFormats, kSupportedInternalFormatsES2);
ADD_VALUES_TO_SET(m_supportedInternalFormatsCopyTexImage, kSupportedInternalFormatsES2);
ADD_VALUES_TO_SET(m_supportedFormats, kSupportedFormatsES2);
ADD_VALUES_TO_SET(m_supportedTypes, kSupportedTypesES2);
}
PassRefPtr<DrawingBuffer> WebGLRenderingContextBase::createDrawingBuffer(std::unique_ptr<WebGraphicsContext3DProvider> contextProvider)
{
bool premultipliedAlpha = creationAttributes().premultipliedAlpha();
bool wantAlphaChannel = creationAttributes().alpha();
bool wantDepthBuffer = creationAttributes().depth();
bool wantStencilBuffer = creationAttributes().stencil();
bool wantAntialiasing = creationAttributes().antialias();
DrawingBuffer::PreserveDrawingBuffer preserve = creationAttributes().preserveDrawingBuffer() ? DrawingBuffer::Preserve : DrawingBuffer::Discard;
DrawingBuffer::WebGLVersion webGLVersion = DrawingBuffer::WebGL1;
if (version() == 1) {
webGLVersion = DrawingBuffer::WebGL1;
} else if (version() == 2) {
webGLVersion = DrawingBuffer::WebGL2;
} else {
NOTREACHED();
}
return DrawingBuffer::create(
std::move(contextProvider),
clampedCanvasSize(),
premultipliedAlpha,
wantAlphaChannel,
wantDepthBuffer,
wantStencilBuffer,
wantAntialiasing,
preserve,
webGLVersion);
}
void WebGLRenderingContextBase::initializeNewContext()
{
ASSERT(!isContextLost());
ASSERT(drawingBuffer());
m_markedCanvasDirty = false;
m_activeTextureUnit = 0;
m_packAlignment = 4;
m_unpackAlignment = 4;
m_unpackFlipY = false;
m_unpackPremultiplyAlpha = false;
m_unpackColorspaceConversion = GC3D_BROWSER_DEFAULT_WEBGL;
m_boundArrayBuffer = nullptr;
m_currentProgram = nullptr;
m_framebufferBinding = nullptr;
m_renderbufferBinding = nullptr;
m_depthMask = true;
m_stencilEnabled = false;
m_stencilMask = 0xFFFFFFFF;
m_stencilMaskBack = 0xFFFFFFFF;
m_stencilFuncRef = 0;
m_stencilFuncRefBack = 0;
m_stencilFuncMask = 0xFFFFFFFF;
m_stencilFuncMaskBack = 0xFFFFFFFF;
m_numGLErrorsToConsoleAllowed = maxGLErrorsAllowedToConsole;
m_clearColor[0] = m_clearColor[1] = m_clearColor[2] = m_clearColor[3] = 0;
drawingBuffer()->setClearColor(m_clearColor);
m_scissorEnabled = false;
m_clearDepth = 1;
m_clearStencil = 0;
m_colorMask[0] = m_colorMask[1] = m_colorMask[2] = m_colorMask[3] = true;
drawingBuffer()->setColorMask(m_colorMask);
GLint numCombinedTextureImageUnits = 0;
contextGL()->GetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &numCombinedTextureImageUnits);
m_textureUnits.clear();
m_textureUnits.resize(numCombinedTextureImageUnits);
GLint numVertexAttribs = 0;
contextGL()->GetIntegerv(GL_MAX_VERTEX_ATTRIBS, &numVertexAttribs);
m_maxVertexAttribs = numVertexAttribs;
m_maxTextureSize = 0;
contextGL()->GetIntegerv(GL_MAX_TEXTURE_SIZE, &m_maxTextureSize);
m_maxTextureLevel = WebGLTexture::computeLevelCount(m_maxTextureSize, m_maxTextureSize, 1);
m_maxCubeMapTextureSize = 0;
contextGL()->GetIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE, &m_maxCubeMapTextureSize);
m_max3DTextureSize = 0;
m_max3DTextureLevel = 0;
m_maxArrayTextureLayers = 0;
if (isWebGL2OrHigher()) {
contextGL()->GetIntegerv(GL_MAX_3D_TEXTURE_SIZE, &m_max3DTextureSize);
m_max3DTextureLevel = WebGLTexture::computeLevelCount(m_max3DTextureSize, m_max3DTextureSize, m_max3DTextureSize);
contextGL()->GetIntegerv(GL_MAX_ARRAY_TEXTURE_LAYERS, &m_maxArrayTextureLayers);
}
m_maxCubeMapTextureLevel = WebGLTexture::computeLevelCount(m_maxCubeMapTextureSize, m_maxCubeMapTextureSize, 1);
m_maxRenderbufferSize = 0;
contextGL()->GetIntegerv(GL_MAX_RENDERBUFFER_SIZE, &m_maxRenderbufferSize);
// These two values from EXT_draw_buffers are lazily queried.
m_maxDrawBuffers = 0;
m_maxColorAttachments = 0;
m_backDrawBuffer = GL_BACK;
m_readBufferOfDefaultFramebuffer = GL_BACK;
m_defaultVertexArrayObject = WebGLVertexArrayObject::create(this, WebGLVertexArrayObjectBase::VaoTypeDefault);
addContextObject(m_defaultVertexArrayObject.get());
// It's not convenient or necessary to pass a ScriptState this far down; while one is available
// during WebGLRenderingContext construction, the wrapper for the context itself hasn't been
// created yet. It's simpler to instead lazily instantiate and preserve the JavaScript wrapper
// for the default VAO. (This object is never exposed to JavaScript, but we need to link other
// JavaScript wrappers to it.)
m_preservedDefaultVAOObjectWrapper = false;
m_boundVertexArrayObject = m_defaultVertexArrayObject;
m_vertexAttribType.resize(m_maxVertexAttribs);
contextGL()->Viewport(0, 0, drawingBufferWidth(), drawingBufferHeight());
contextGL()->Scissor(0, 0, drawingBufferWidth(), drawingBufferHeight());
drawingBuffer()->contextProvider()->setLostContextCallback(
WebClosure(WTF::bind(
&WebGLRenderingContextBase::forceLostContext,
wrapWeakPersistent(this),
WebGLRenderingContextBase::RealLostContext,
WebGLRenderingContextBase::Auto)));
drawingBuffer()->contextProvider()->setErrorMessageCallback(
WebFunction<void(const char*, int32_t)>(WTF::bind(
&WebGLRenderingContextBase::onErrorMessage,
wrapWeakPersistent(this))));
// If WebGL 2, the PRIMITIVE_RESTART_FIXED_INDEX should be always enabled.
// See the section <Primitive Restart is Always Enabled> in WebGL 2 spec:
// https://www.khronos.org/registry/webgl/specs/latest/2.0/#4.1.4
if (isWebGL2OrHigher())
contextGL()->Enable(GL_PRIMITIVE_RESTART_FIXED_INDEX);
// This ensures that the context has a valid "lastFlushID" and won't be mistakenly identified as the "least recently used" context.
contextGL()->Flush();
for (int i = 0; i < WebGLExtensionNameCount; ++i)
m_extensionEnabled[i] = false;
m_isWebGL2FormatsTypesAdded = false;
m_isWebGL2InternalFormatsCopyTexImageAdded = false;
m_isOESTextureFloatFormatsTypesAdded = false;
m_isOESTextureHalfFloatFormatsTypesAdded = false;
m_isWebGLDepthTextureFormatsTypesAdded = false;
m_isEXTsRGBFormatsTypesAdded = false;
m_supportedInternalFormats.clear();
ADD_VALUES_TO_SET(m_supportedInternalFormats, kSupportedInternalFormatsES2);
m_supportedInternalFormatsCopyTexImage.clear();
ADD_VALUES_TO_SET(m_supportedInternalFormatsCopyTexImage, kSupportedInternalFormatsES2);
m_supportedFormats.clear();
ADD_VALUES_TO_SET(m_supportedFormats, kSupportedFormatsES2);
m_supportedTypes.clear();
ADD_VALUES_TO_SET(m_supportedTypes, kSupportedTypesES2);
activateContext(this);
}
void WebGLRenderingContextBase::setupFlags()
{
ASSERT(drawingBuffer());
if (canvas()) {
if (Page* p = canvas()->document().page()) {
m_synthesizedErrorsToConsole = p->settings().webGLErrorsToConsoleEnabled();
}
}
m_isDepthStencilSupported = extensionsUtil()->isExtensionEnabled("GL_OES_packed_depth_stencil");
}
void WebGLRenderingContextBase::addCompressedTextureFormat(GLenum format)
{
if (!m_compressedTextureFormats.contains(format))
m_compressedTextureFormats.append(format);
}
void WebGLRenderingContextBase::removeAllCompressedTextureFormats()
{
m_compressedTextureFormats.clear();
}
// Helper function for V8 bindings to identify what version of WebGL a CanvasRenderingContext supports.
unsigned WebGLRenderingContextBase::getWebGLVersion(const CanvasRenderingContext* context)
{
if (!context->is3d())
return 0;
return static_cast<const WebGLRenderingContextBase*>(context)->version();
}
WebGLRenderingContextBase::~WebGLRenderingContextBase()
{
// Remove all references to WebGLObjects so if they are the last reference
// they will be freed before the last context is removed from the context group.
m_boundArrayBuffer = nullptr;
m_defaultVertexArrayObject = nullptr;
m_boundVertexArrayObject = nullptr;
m_currentProgram = nullptr;
m_framebufferBinding = nullptr;
m_renderbufferBinding = nullptr;
// WebGLTexture shared objects will be detached and deleted
// m_contextGroup->removeContext(this), which will bring about deleteTexture() calls.
// We null these out to avoid accessing those members in deleteTexture().
for (size_t i = 0; i < m_textureUnits.size(); ++i) {
m_textureUnits[i].m_texture2DBinding = nullptr;
m_textureUnits[i].m_textureCubeMapBinding = nullptr;
m_textureUnits[i].m_texture3DBinding = nullptr;
m_textureUnits[i].m_texture2DArrayBinding = nullptr;
}
detachAndRemoveAllObjects();
// Release all extensions now.
for (ExtensionTracker* tracker : m_extensions) {
tracker->loseExtension(true);
}
m_extensions.clear();
// Context must be removed from the group prior to the destruction of the
// GL context, otherwise shared objects may not be properly deleted.
m_contextGroup->removeContext(this);
destroyContext();
willDestroyContext(this);
}
void WebGLRenderingContextBase::destroyContext()
{
if (!drawingBuffer())
return;
m_extensionsUtil.reset();
drawingBuffer()->contextProvider()->setLostContextCallback(WebClosure());
drawingBuffer()->contextProvider()->setErrorMessageCallback(WebFunction<void(const char*, int32_t)>());
drawingBuffer()->addNewMailboxCallback(nullptr);
ASSERT(drawingBuffer());
m_drawingBuffer->beginDestruction();
m_drawingBuffer.clear();
}
void WebGLRenderingContextBase::markContextChanged(ContentChangeType changeType)
{
if (m_framebufferBinding || isContextLost())
return;
drawingBuffer()->markContentsChanged();
if (!canvas())
return;
LayoutBox* layoutBox = canvas()->layoutBox();
if (layoutBox && layoutBox->hasAcceleratedCompositing()) {
m_markedCanvasDirty = true;
canvas()->clearCopiedImage();
layoutBox->contentChanged(changeType);
} else {
if (!m_markedCanvasDirty) {
m_markedCanvasDirty = true;
canvas()->didDraw(FloatRect(FloatPoint(0, 0), FloatSize(clampedCanvasSize())));
}
}
}
void WebGLRenderingContextBase::onErrorMessage(const char* message, int32_t id)
{
if (m_synthesizedErrorsToConsole)
printGLErrorToConsole(message);
InspectorInstrumentation::didFireWebGLErrorOrWarning(canvas(), message);
}
void WebGLRenderingContextBase::notifyCanvasContextChanged()
{
if (!canvas())
return;
canvas()->notifyListenersCanvasChanged();
}
WebGLRenderingContextBase::HowToClear WebGLRenderingContextBase::clearIfComposited(GLbitfield mask)
{
if (isContextLost())
return Skipped;
if (!drawingBuffer()->bufferClearNeeded() || (mask && m_framebufferBinding))
return Skipped;
Nullable<WebGLContextAttributes> contextAttributes;
getContextAttributes(contextAttributes);
if (contextAttributes.isNull()) {
// Unlikely, but context was lost.
return Skipped;
}
// Determine if it's possible to combine the clear the user asked for and this clear.
bool combinedClear = mask && !m_scissorEnabled;
contextGL()->Disable(GL_SCISSOR_TEST);
if (combinedClear && (mask & GL_COLOR_BUFFER_BIT)) {
contextGL()->ClearColor(m_colorMask[0] ? m_clearColor[0] : 0,
m_colorMask[1] ? m_clearColor[1] : 0,
m_colorMask[2] ? m_clearColor[2] : 0,
m_colorMask[3] ? m_clearColor[3] : 0);
} else {
contextGL()->ClearColor(0, 0, 0, 0);
}
contextGL()->ColorMask(true, true, true, !drawingBuffer()->requiresAlphaChannelToBePreserved());
GLbitfield clearMask = GL_COLOR_BUFFER_BIT;
if (contextAttributes.get().depth()) {
if (!combinedClear || !m_depthMask || !(mask & GL_DEPTH_BUFFER_BIT))
contextGL()->ClearDepthf(1.0f);
clearMask |= GL_DEPTH_BUFFER_BIT;
contextGL()->DepthMask(true);
}
if (contextAttributes.get().stencil() || drawingBuffer()->hasImplicitStencilBuffer()) {
if (combinedClear && (mask & GL_STENCIL_BUFFER_BIT))
contextGL()->ClearStencil(m_clearStencil & m_stencilMask);
else
contextGL()->ClearStencil(0);
clearMask |= GL_STENCIL_BUFFER_BIT;
contextGL()->StencilMaskSeparate(GL_FRONT, 0xFFFFFFFF);
}
contextGL()->ColorMask(true, true, true, !drawingBuffer()->defaultBufferRequiresAlphaChannelToBePreserved());
drawingBuffer()->clearFramebuffers(clearMask);
restoreStateAfterClear();
drawingBuffer()->restoreFramebufferBindings();
drawingBuffer()->setBufferClearNeeded(false);
return combinedClear ? CombinedClear : JustClear;
}
void WebGLRenderingContextBase::restoreStateAfterClear()
{
if (isContextLost())
return;
// Restore the state that the context set.
if (m_scissorEnabled)
contextGL()->Enable(GL_SCISSOR_TEST);
contextGL()->ClearColor(m_clearColor[0], m_clearColor[1],
m_clearColor[2], m_clearColor[3]);
contextGL()->ColorMask(m_colorMask[0], m_colorMask[1],
m_colorMask[2], m_colorMask[3]);
contextGL()->ClearDepthf(m_clearDepth);
contextGL()->ClearStencil(m_clearStencil);
contextGL()->StencilMaskSeparate(GL_FRONT, m_stencilMask);
contextGL()->DepthMask(m_depthMask);
}
void WebGLRenderingContextBase::markLayerComposited()
{
if (!isContextLost())
drawingBuffer()->setBufferClearNeeded(true);
}
void WebGLRenderingContextBase::setIsHidden(bool hidden)
{
m_isHidden = hidden;
if (drawingBuffer())
drawingBuffer()->setIsHidden(hidden);
if (!hidden && isContextLost() && m_restoreAllowed && m_autoRecoveryMethod == Auto) {
ASSERT(!m_restoreTimer.isActive());
m_restoreTimer.startOneShot(0, BLINK_FROM_HERE);
}
}
bool WebGLRenderingContextBase::paintRenderingResultsToCanvas(SourceDrawingBuffer sourceBuffer)
{
if (isContextLost())
return false;
bool mustClearNow = clearIfComposited() != Skipped;
if (!m_markedCanvasDirty && !mustClearNow)
return false;
canvas()->clearCopiedImage();
m_markedCanvasDirty = false;
if (!canvas()->buffer())
return false;
ScopedTexture2DRestorer restorer(this);
ScopedFramebufferRestorer fboRestorer(this);
drawingBuffer()->commit();
if (!canvas()->buffer()->copyRenderingResultsFromDrawingBuffer(drawingBuffer(), sourceBuffer)) {
// Currently, copyRenderingResultsFromDrawingBuffer is expected to always succeed because cases
// where canvas()-buffer() is not accelerated are handle before reaching this point.
// If that assumption ever stops holding true, we may need to implement a fallback right here.
ASSERT_NOT_REACHED();
return false;
}
return true;
}
ImageData* WebGLRenderingContextBase::paintRenderingResultsToImageData(SourceDrawingBuffer sourceBuffer)
{
if (isContextLost())
return nullptr;
if (creationAttributes().premultipliedAlpha())
return nullptr;
clearIfComposited();
drawingBuffer()->commit();
ScopedFramebufferRestorer restorer(this);
int width, height;
WTF::ArrayBufferContents contents;
if (!drawingBuffer()->paintRenderingResultsToImageData(width, height, sourceBuffer, contents))
return nullptr;
DOMArrayBuffer* imageDataPixels = DOMArrayBuffer::create(contents);
return ImageData::create(
IntSize(width, height),
DOMUint8ClampedArray::create(imageDataPixels, 0, imageDataPixels->byteLength()));
}
void WebGLRenderingContextBase::reshape(int width, int height)
{
if (isContextLost())
return;
// This is an approximation because at WebGLRenderingContextBase level we don't
// know if the underlying FBO uses textures or renderbuffers.
GLint maxSize = std::min(m_maxTextureSize, m_maxRenderbufferSize);
GLint maxWidth = std::min(maxSize, m_maxViewportDims[0]);
GLint maxHeight = std::min(maxSize, m_maxViewportDims[1]);
width = clamp(width, 1, maxWidth);
height = clamp(height, 1, maxHeight);
// Limit drawing buffer area to 4k*4k to avoid memory exhaustion. Width or height may be larger than
// 4k as long as it's within the max viewport dimensions and total area remains within the limit.
// For example: 5120x2880 should be fine.
const int maxArea = 4096 * 4096;
int currentArea = width * height;
if (currentArea > maxArea) {
// If we've exceeded the area limit scale the buffer down, preserving ascpect ratio, until it fits.
float scaleFactor = sqrtf(static_cast<float>(maxArea) / static_cast<float>(currentArea));
width = std::max(1, static_cast<int>(width * scaleFactor));
height = std::max(1, static_cast<int>(height * scaleFactor));
}
// We don't have to mark the canvas as dirty, since the newly created image buffer will also start off
// clear (and this matches what reshape will do).
drawingBuffer()->reset(IntSize(width, height));
restoreStateAfterClear();
contextGL()->BindTexture(GL_TEXTURE_2D, objectOrZero(m_textureUnits[m_activeTextureUnit].m_texture2DBinding.get()));
contextGL()->BindRenderbuffer(GL_RENDERBUFFER, objectOrZero(m_renderbufferBinding.get()));
drawingBuffer()->restoreFramebufferBindings();
}
int WebGLRenderingContextBase::drawingBufferWidth() const
{
return isContextLost() ? 0 : drawingBuffer()->size().width();
}
int WebGLRenderingContextBase::drawingBufferHeight() const
{
return isContextLost() ? 0 : drawingBuffer()->size().height();
}
void WebGLRenderingContextBase::activeTexture(GLenum texture)
{
if (isContextLost())
return;
if (texture - GL_TEXTURE0 >= m_textureUnits.size()) {
synthesizeGLError(GL_INVALID_ENUM, "activeTexture", "texture unit out of range");
return;
}
m_activeTextureUnit = texture - GL_TEXTURE0;
contextGL()->ActiveTexture(texture);
drawingBuffer()->setActiveTextureUnit(texture);
}
void WebGLRenderingContextBase::attachShader(ScriptState* scriptState, WebGLProgram* program, WebGLShader* shader)
{
if (isContextLost() || !validateWebGLObject("attachShader", program) || !validateWebGLObject("attachShader", shader))
return;
if (!program->attachShader(shader)) {
synthesizeGLError(GL_INVALID_OPERATION, "attachShader", "shader attachment already has shader");
return;
}
contextGL()->AttachShader(objectOrZero(program), objectOrZero(shader));
shader->onAttached();
preserveObjectWrapper(scriptState, program, V8HiddenValue::webglShaders(scriptState->isolate()), program->getPersistentCache(), static_cast<uint32_t>(shader->type()), shader);
}
void WebGLRenderingContextBase::bindAttribLocation(WebGLProgram* program, GLuint index, const String& name)
{
if (isContextLost() || !validateWebGLObject("bindAttribLocation", program))
return;
if (!validateLocationLength("bindAttribLocation", name))
return;
if (isPrefixReserved(name)) {
synthesizeGLError(GL_INVALID_OPERATION, "bindAttribLocation", "reserved prefix");
return;
}
contextGL()->BindAttribLocation(objectOrZero(program), index, name.utf8().data());
}
bool WebGLRenderingContextBase::checkObjectToBeBound(const char* functionName, WebGLObject* object, bool& deleted)
{
deleted = false;
if (isContextLost())
return false;
if (object) {
if (!object->validate(contextGroup(), this)) {
synthesizeGLError(GL_INVALID_OPERATION, functionName, "object not from this context");
return false;
}
deleted = !object->hasObject();
}
return true;
}
bool WebGLRenderingContextBase::validateAndUpdateBufferBindTarget(const char* functionName, GLenum target, WebGLBuffer* buffer)
{
if (!validateBufferTarget(functionName, target))
return false;
if (buffer && buffer->getInitialTarget() && buffer->getInitialTarget() != target) {
synthesizeGLError(GL_INVALID_OPERATION, functionName, "buffers can not be used with multiple targets");
return false;
}
switch (target) {
case GL_ARRAY_BUFFER:
m_boundArrayBuffer = buffer;
break;
case GL_ELEMENT_ARRAY_BUFFER:
m_boundVertexArrayObject->setElementArrayBuffer(buffer);
break;
default:
ASSERT_NOT_REACHED();
return false;
}
if (buffer && !buffer->getInitialTarget())
buffer->setInitialTarget(target);
return true;
}
void WebGLRenderingContextBase::bindBuffer(ScriptState* scriptState, GLenum target, WebGLBuffer* buffer)
{
bool deleted;
if (!checkObjectToBeBound("bindBuffer", buffer, deleted))
return;
if (deleted)
buffer = 0;
if (!validateAndUpdateBufferBindTarget("bindBuffer", target, buffer))
return;
contextGL()->BindBuffer(target, objectOrZero(buffer));
PreservedWrapperIndex idx = PreservedArrayBuffer;
switch (target) {
case GL_ARRAY_BUFFER:
idx = PreservedArrayBuffer;
break;
case GL_ELEMENT_ARRAY_BUFFER:
idx = PreservedElementArrayBuffer;
break;
}
preserveObjectWrapper(scriptState, this, V8HiddenValue::webglMisc(scriptState->isolate()), &m_miscWrappers, static_cast<uint32_t>(idx), buffer);
maybePreserveDefaultVAOObjectWrapper(scriptState);
}
void WebGLRenderingContextBase::bindFramebuffer(ScriptState* scriptState, GLenum target, WebGLFramebuffer* buffer)
{
bool deleted;
if (!checkObjectToBeBound("bindFramebuffer", buffer, deleted))
return;
if (deleted)
buffer = 0;
if (target != GL_FRAMEBUFFER) {
synthesizeGLError(GL_INVALID_ENUM, "bindFramebuffer", "invalid target");
return;
}
setFramebuffer(target, buffer);
// This is called both internally and externally (from JavaScript). We only update which wrapper
// is preserved when it's called from JavaScript.
if (scriptState) {
preserveObjectWrapper(scriptState, this, V8HiddenValue::webglMisc(scriptState->isolate()), &m_miscWrappers, static_cast<uint32_t>(PreservedFramebuffer), buffer);
}
}
void WebGLRenderingContextBase::bindRenderbuffer(ScriptState* scriptState, GLenum target, WebGLRenderbuffer* renderBuffer)
{
bool deleted;
if (!checkObjectToBeBound("bindRenderbuffer", renderBuffer, deleted))
return;
if (deleted)
renderBuffer = 0;
if (target != GL_RENDERBUFFER) {
synthesizeGLError(GL_INVALID_ENUM, "bindRenderbuffer", "invalid target");
return;
}
m_renderbufferBinding = renderBuffer;
contextGL()->BindRenderbuffer(target, objectOrZero(renderBuffer));
preserveObjectWrapper(scriptState, this, V8HiddenValue::webglMisc(scriptState->isolate()), &m_miscWrappers, PreservedRenderbuffer, renderBuffer);
drawingBuffer()->setRenderbufferBinding(objectOrZero(renderBuffer));
if (renderBuffer)
renderBuffer->setHasEverBeenBound();
}
void WebGLRenderingContextBase::bindTexture(ScriptState* scriptState, GLenum target, WebGLTexture* texture)
{
bool deleted;
if (!checkObjectToBeBound("bindTexture", texture, deleted))
return;
if (deleted)
texture = 0;
if (texture && texture->getTarget() && texture->getTarget() != target) {
synthesizeGLError(GL_INVALID_OPERATION, "bindTexture", "textures can not be used with multiple targets");
return;
}
// ScriptState may be null if this method is called internally
// during restoration of texture unit bindings. Skip the
// preserveObjectWrapper work in this case.
v8::Local<v8::String> hiddenValueName;
ScopedPersistent<v8::Array>* persistentCache = nullptr;
if (target == GL_TEXTURE_2D) {
m_textureUnits[m_activeTextureUnit].m_texture2DBinding = texture;
if (!m_activeTextureUnit)
drawingBuffer()->setTexture2DBinding(objectOrZero(texture));
if (scriptState) {
hiddenValueName = V8HiddenValue::webgl2DTextures(scriptState->isolate());
persistentCache = &m_2DTextureWrappers;
}
} else if (target == GL_TEXTURE_CUBE_MAP) {
m_textureUnits[m_activeTextureUnit].m_textureCubeMapBinding = texture;
if (scriptState) {
hiddenValueName = V8HiddenValue::webglCubeMapTextures(scriptState->isolate());
persistentCache = &m_cubeMapTextureWrappers;
}
} else if (isWebGL2OrHigher() && target == GL_TEXTURE_2D_ARRAY) {
m_textureUnits[m_activeTextureUnit].m_texture2DArrayBinding = texture;
if (scriptState) {
hiddenValueName = V8HiddenValue::webgl2DArrayTextures(scriptState->isolate());
persistentCache = &m_2DArrayTextureWrappers;
}
} else if (isWebGL2OrHigher() && target == GL_TEXTURE_3D) {
m_textureUnits[m_activeTextureUnit].m_texture3DBinding = texture;
if (scriptState) {
hiddenValueName = V8HiddenValue::webgl3DTextures(scriptState->isolate());
persistentCache = &m_3DTextureWrappers;
}
} else {
synthesizeGLError(GL_INVALID_ENUM, "bindTexture", "invalid target");
return;
}
contextGL()->BindTexture(target, objectOrZero(texture));
// This is called both internally and externally (from JavaScript). We only update which wrapper
// is preserved when it's called from JavaScript.
if (scriptState) {
preserveObjectWrapper(scriptState, this, hiddenValueName, persistentCache, m_activeTextureUnit, texture);
}
if (texture) {
texture->setTarget(target);
m_onePlusMaxNonDefaultTextureUnit = max(m_activeTextureUnit + 1, m_onePlusMaxNonDefaultTextureUnit);
} else {
// If the disabled index is the current maximum, trace backwards to find the new max enabled texture index
if (m_onePlusMaxNonDefaultTextureUnit == m_activeTextureUnit + 1) {
findNewMaxNonDefaultTextureUnit();
}
}
// Note: previously we used to automatically set the TEXTURE_WRAP_R
// repeat mode to CLAMP_TO_EDGE for cube map textures, because OpenGL
// ES 2.0 doesn't expose this flag (a bug in the specification) and
// otherwise the application has no control over the seams in this
// dimension. However, it appears that supporting this properly on all
// platforms is fairly involved (will require a HashMap from texture ID
// in all ports), and we have not had any complaints, so the logic has
// been removed.
}
void WebGLRenderingContextBase::blendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
{
if (isContextLost())
return;
contextGL()->BlendColor(red, green, blue, alpha);
}
void WebGLRenderingContextBase::blendEquation(GLenum mode)
{
if (isContextLost() || !validateBlendEquation("blendEquation", mode))
return;
contextGL()->BlendEquation(mode);
}
void WebGLRenderingContextBase::blendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
{
if (isContextLost() || !validateBlendEquation("blendEquationSeparate", modeRGB) || !validateBlendEquation("blendEquationSeparate", modeAlpha))
return;
contextGL()->BlendEquationSeparate(modeRGB, modeAlpha);
}
void WebGLRenderingContextBase::blendFunc(GLenum sfactor, GLenum dfactor)
{
if (isContextLost() || !validateBlendFuncFactors("blendFunc", sfactor, dfactor))
return;
contextGL()->BlendFunc(sfactor, dfactor);
}
void WebGLRenderingContextBase::blendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
{
// Note: Alpha does not have the same restrictions as RGB.
if (isContextLost() || !validateBlendFuncFactors("blendFuncSeparate", srcRGB, dstRGB))
return;
contextGL()->BlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
}
void WebGLRenderingContextBase::bufferDataImpl(GLenum target, long long size, const void* data, GLenum usage)
{
WebGLBuffer* buffer = validateBufferDataTarget("bufferData", target);
if (!buffer)
return;
if (!validateBufferDataUsage("bufferData", usage))
return;
if (!validateValueFitNonNegInt32("bufferData", "size", size))
return;
buffer->setSize(size);
contextGL()->BufferData(target, static_cast<GLsizeiptr>(size), data, usage);
}
void WebGLRenderingContextBase::bufferData(GLenum target, long long size, GLenum usage)
{
if (isContextLost())
return;
bufferDataImpl(target, size, 0, usage);
}
void WebGLRenderingContextBase::bufferData(GLenum target, DOMArrayBuffer* data, GLenum usage)
{
if (isContextLost())
return;
if (!data) {
synthesizeGLError(GL_INVALID_VALUE, "bufferData", "no data");
return;
}
bufferDataImpl(target, data->byteLength(), data->data(), usage);
}
void WebGLRenderingContextBase::bufferData(GLenum target, DOMArrayBufferView* data, GLenum usage)
{
if (isContextLost())
return;
if (!data) {
synthesizeGLError(GL_INVALID_VALUE, "bufferData", "no data");
return;
}
bufferDataImpl(target, data->byteLength(), data->baseAddress(), usage);
}
void WebGLRenderingContextBase::bufferSubDataImpl(GLenum target, long long offset, GLsizeiptr size, const void* data)
{
WebGLBuffer* buffer = validateBufferDataTarget("bufferSubData", target);
if (!buffer)
return;
if (!validateValueFitNonNegInt32("bufferSubData", "offset", offset))
return;
if (!data)
return;
if (offset + static_cast<long long>(size) > buffer->getSize()) {
synthesizeGLError(GL_INVALID_VALUE, "bufferSubData", "buffer overflow");
return;
}
contextGL()->BufferSubData(target, static_cast<GLintptr>(offset), size, data);
}
void WebGLRenderingContextBase::bufferSubData(GLenum target, long long offset, DOMArrayBuffer* data)
{
if (isContextLost())
return;
if (!data) {
synthesizeGLError(GL_INVALID_VALUE, "bufferSubData", "no data");
return;
}
bufferSubDataImpl(target, offset, data->byteLength(), data->data());
}
void WebGLRenderingContextBase::bufferSubData(GLenum target, long long offset, const FlexibleArrayBufferView& data)
{
if (isContextLost())
return;
if (!data) {
synthesizeGLError(GL_INVALID_VALUE, "bufferSubData", "no data");
return;
}
bufferSubDataImpl(target, offset, data.byteLength(), data.baseAddressMaybeOnStack());
}
bool WebGLRenderingContextBase::validateFramebufferTarget(GLenum target)
{
if (target == GL_FRAMEBUFFER)
return true;
return false;
}
WebGLFramebuffer* WebGLRenderingContextBase::getFramebufferBinding(GLenum target)
{
if (target == GL_FRAMEBUFFER)
return m_framebufferBinding.get();
return nullptr;
}
WebGLFramebuffer* WebGLRenderingContextBase::getReadFramebufferBinding()
{
return m_framebufferBinding.get();
}
GLenum WebGLRenderingContextBase::checkFramebufferStatus(GLenum target)
{
if (isContextLost())
return GL_FRAMEBUFFER_UNSUPPORTED;
if (!validateFramebufferTarget(target)) {
synthesizeGLError(GL_INVALID_ENUM, "checkFramebufferStatus", "invalid target");
return 0;
}
WebGLFramebuffer* framebufferBinding = getFramebufferBinding(target);
if (framebufferBinding) {
const char* reason = "framebuffer incomplete";
GLenum status = framebufferBinding->checkDepthStencilStatus(&reason);
if (status != GL_FRAMEBUFFER_COMPLETE) {
emitGLWarning("checkFramebufferStatus", reason);
return status;
}
}
return contextGL()->CheckFramebufferStatus(target);
}
void WebGLRenderingContextBase::clear(GLbitfield mask)
{
if (isContextLost())
return;
if (mask & ~(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT)) {
synthesizeGLError(GL_INVALID_VALUE, "clear", "invalid mask");
return;
}
const char* reason = "framebuffer incomplete";
if (m_framebufferBinding && m_framebufferBinding->checkDepthStencilStatus(&reason) != GL_FRAMEBUFFER_COMPLETE) {
synthesizeGLError(GL_INVALID_FRAMEBUFFER_OPERATION, "clear", reason);
return;
}
ScopedRGBEmulationColorMask emulationColorMask(contextGL(), m_colorMask, m_drawingBuffer.get());
if (clearIfComposited(mask) != CombinedClear) {
// If clearing the default back buffer's depth buffer, also clear the stencil buffer, if one
// was allocated implicitly. This avoids performance problems on some GPUs.
if (!m_framebufferBinding && drawingBuffer()->hasImplicitStencilBuffer() && (mask & GL_DEPTH_BUFFER_BIT)) {
// It shouldn't matter what value it's cleared to, since in other queries in the API, we
// claim that the stencil buffer doesn't exist.
mask |= GL_STENCIL_BUFFER_BIT;
}
contextGL()->Clear(mask);
}
markContextChanged(CanvasChanged);
}
void WebGLRenderingContextBase::clearColor(GLfloat r, GLfloat g, GLfloat b, GLfloat a)
{
if (isContextLost())
return;
if (std::isnan(r))
r = 0;
if (std::isnan(g))
g = 0;
if (std::isnan(b))
b = 0;
if (std::isnan(a))
a = 1;
m_clearColor[0] = r;
m_clearColor[1] = g;
m_clearColor[2] = b;
m_clearColor[3] = a;
drawingBuffer()->setClearColor(m_clearColor);
contextGL()->ClearColor(r, g, b, a);
}
void WebGLRenderingContextBase::clearDepth(GLfloat depth)
{
if (isContextLost())
return;
m_clearDepth = depth;
contextGL()->ClearDepthf(depth);
}
void WebGLRenderingContextBase::clearStencil(GLint s)
{
if (isContextLost())
return;
m_clearStencil = s;
contextGL()->ClearStencil(s);
}
void WebGLRenderingContextBase::colorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
{
if (isContextLost())
return;
m_colorMask[0] = red;
m_colorMask[1] = green;
m_colorMask[2] = blue;
m_colorMask[3] = alpha;
drawingBuffer()->setColorMask(m_colorMask);
contextGL()->ColorMask(red, green, blue, alpha);
}
void WebGLRenderingContextBase::compileShader(WebGLShader* shader)
{
if (isContextLost() || !validateWebGLObject("compileShader", shader))
return;
contextGL()->CompileShader(objectOrZero(shader));
}
void WebGLRenderingContextBase::compressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, DOMArrayBufferView* data)
{
if (isContextLost())
return;
if (!validateTexture2DBinding("compressedTexImage2D", target))
return;
if (!validateCompressedTexFormat("compressedTexImage2D", internalformat))
return;
contextGL()->CompressedTexImage2D(target, level, internalformat, width, height,
border, data->byteLength(), data->baseAddress());
}
void WebGLRenderingContextBase::compressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, DOMArrayBufferView* data)
{
if (isContextLost())
return;
if (!validateTexture2DBinding("compressedTexSubImage2D", target))
return;
if (!validateCompressedTexFormat("compressedTexSubImage2D", format))
return;
contextGL()->CompressedTexSubImage2D(target, level, xoffset, yoffset,
width, height, format, data->byteLength(), data->baseAddress());
}
bool WebGLRenderingContextBase::validateSettableTexFormat(const char* functionName, GLenum format)
{
if (isWebGL2OrHigher())
return true;
if (WebGLImageConversion::getChannelBitsByFormat(format) & WebGLImageConversion::ChannelDepthStencil) {
synthesizeGLError(GL_INVALID_OPERATION, functionName, "format can not be set, only rendered to");
return false;
}
return true;
}
bool WebGLRenderingContextBase::validateCopyTexFormat(const char* functionName, GLenum internalformat)
{
if (!m_isWebGL2InternalFormatsCopyTexImageAdded && isWebGL2OrHigher()) {
ADD_VALUES_TO_SET(m_supportedInternalFormatsCopyTexImage, kSupportedInternalFormatsES3);
m_isWebGL2InternalFormatsCopyTexImageAdded = true;
}
if (m_supportedInternalFormatsCopyTexImage.find(internalformat) == m_supportedInternalFormatsCopyTexImage.end()) {
synthesizeGLError(GL_INVALID_ENUM, functionName, "invalid internalformat");
return false;
}
return true;
}
void WebGLRenderingContextBase::copyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
{
if (isContextLost())
return;
if (!validateTexture2DBinding("copyTexImage2D", target))
return;
if (!validateCopyTexFormat("copyTexImage2D", internalformat))
return;
if (!validateSettableTexFormat("copyTexImage2D", internalformat))
return;
WebGLFramebuffer* readFramebufferBinding = nullptr;
if (!validateReadBufferAndGetInfo("copyTexImage2D", readFramebufferBinding))
return;
clearIfComposited();
ScopedDrawingBufferBinder binder(drawingBuffer(), readFramebufferBinding);
contextGL()->CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
}
void WebGLRenderingContextBase::copyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
{
if (isContextLost())
return;
if (!validateTexture2DBinding("copyTexSubImage2D", target))
return;
WebGLFramebuffer* readFramebufferBinding = nullptr;
if (!validateReadBufferAndGetInfo("copyTexSubImage2D", readFramebufferBinding))
return;
clearIfComposited();
ScopedDrawingBufferBinder binder(drawingBuffer(), readFramebufferBinding);
contextGL()->CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
}
WebGLBuffer* WebGLRenderingContextBase::createBuffer()
{
if (isContextLost())
return nullptr;
WebGLBuffer* o = WebGLBuffer::create(this);
addSharedObject(o);
return o;
}
WebGLFramebuffer* WebGLRenderingContextBase::createFramebuffer()
{
if (isContextLost())
return nullptr;
WebGLFramebuffer* o = WebGLFramebuffer::create(this);
addContextObject(o);
return o;
}
WebGLTexture* WebGLRenderingContextBase::createTexture()
{
if (isContextLost())
return nullptr;
WebGLTexture* o = WebGLTexture::create(this);
addSharedObject(o);
return o;
}
WebGLProgram* WebGLRenderingContextBase::createProgram()
{
if (isContextLost())
return nullptr;
WebGLProgram* o = WebGLProgram::create(this);
addSharedObject(o);
return o;
}
WebGLRenderbuffer* WebGLRenderingContextBase::createRenderbuffer()
{
if (isContextLost())
return nullptr;
WebGLRenderbuffer* o = WebGLRenderbuffer::create(this);
addSharedObject(o);
return o;
}
void WebGLRenderingContextBase::setBoundVertexArrayObject(ScriptState* scriptState, WebGLVertexArrayObjectBase* arrayObject)
{
if (arrayObject)
m_boundVertexArrayObject = arrayObject;
else
m_boundVertexArrayObject = m_defaultVertexArrayObject;
preserveObjectWrapper(scriptState, this, V8HiddenValue::webglMisc(scriptState->isolate()), &m_miscWrappers, static_cast<uint32_t>(PreservedVAO), arrayObject);
}
WebGLShader* WebGLRenderingContextBase::createShader(GLenum type)
{
if (isContextLost())
return nullptr;
if (type != GL_VERTEX_SHADER && type != GL_FRAGMENT_SHADER) {
synthesizeGLError(GL_INVALID_ENUM, "createShader", "invalid shader type");
return nullptr;
}
WebGLShader* o = WebGLShader::create(this, type);
addSharedObject(o);
return o;
}
void WebGLRenderingContextBase::cullFace(GLenum mode)
{
if (isContextLost())
return;
contextGL()->CullFace(mode);
}
bool WebGLRenderingContextBase::deleteObject(WebGLObject* object)
{
if (isContextLost() || !object)
return false;
if (!object->validate(contextGroup(), this)) {
synthesizeGLError(GL_INVALID_OPERATION, "delete", "object does not belong to this context");
return false;
}
if (object->hasObject()) {
// We need to pass in context here because we want
// things in this context unbound.
object->deleteObject(contextGL());
}
return true;
}
void WebGLRenderingContextBase::deleteBuffer(WebGLBuffer* buffer)
{
if (!deleteObject(buffer))
return;
removeBoundBuffer(buffer);
}
void WebGLRenderingContextBase::deleteFramebuffer(WebGLFramebuffer* framebuffer)
{
if (!deleteObject(framebuffer))
return;
if (framebuffer == m_framebufferBinding) {
m_framebufferBinding = nullptr;
drawingBuffer()->setFramebufferBinding(GL_FRAMEBUFFER, 0);
// Have to call drawingBuffer()->bind() here to bind back to internal fbo.
drawingBuffer()->bind(GL_FRAMEBUFFER);
}
}
void WebGLRenderingContextBase::deleteProgram(WebGLProgram* program)
{
deleteObject(program);
// We don't reset m_currentProgram to 0 here because the deletion of the
// current program is delayed.
}
void WebGLRenderingContextBase::deleteRenderbuffer(WebGLRenderbuffer* renderbuffer)
{
if (!deleteObject(renderbuffer))
return;
if (renderbuffer == m_renderbufferBinding) {
m_renderbufferBinding = nullptr;
drawingBuffer()->setRenderbufferBinding(0);
}
if (m_framebufferBinding)
m_framebufferBinding->removeAttachmentFromBoundFramebuffer(GL_FRAMEBUFFER, renderbuffer);
if (getFramebufferBinding(GL_READ_FRAMEBUFFER))
getFramebufferBinding(GL_READ_FRAMEBUFFER)->removeAttachmentFromBoundFramebuffer(GL_READ_FRAMEBUFFER, renderbuffer);
}
void WebGLRenderingContextBase::deleteShader(WebGLShader* shader)
{
deleteObject(shader);
}
void WebGLRenderingContextBase::deleteTexture(WebGLTexture* texture)
{
if (!deleteObject(texture))
return;
int maxBoundTextureIndex = -1;
for (size_t i = 0; i < m_onePlusMaxNonDefaultTextureUnit; ++i) {
if (texture == m_textureUnits[i].m_texture2DBinding) {
m_textureUnits[i].m_texture2DBinding = nullptr;
maxBoundTextureIndex = i;
if (!i)
drawingBuffer()->setTexture2DBinding(0);
}
if (texture == m_textureUnits[i].m_textureCubeMapBinding) {
m_textureUnits[i].m_textureCubeMapBinding = nullptr;
maxBoundTextureIndex = i;
}
if (isWebGL2OrHigher()) {
if (texture == m_textureUnits[i].m_texture3DBinding) {
m_textureUnits[i].m_texture3DBinding = nullptr;
maxBoundTextureIndex = i;
}
if (texture == m_textureUnits[i].m_texture2DArrayBinding) {
m_textureUnits[i].m_texture2DArrayBinding = nullptr;
maxBoundTextureIndex = i;
}
}
}
if (m_framebufferBinding)
m_framebufferBinding->removeAttachmentFromBoundFramebuffer(GL_FRAMEBUFFER, texture);
if (getFramebufferBinding(GL_READ_FRAMEBUFFER))
getFramebufferBinding(GL_READ_FRAMEBUFFER)->removeAttachmentFromBoundFramebuffer(GL_READ_FRAMEBUFFER, texture);
// If the deleted was bound to the the current maximum index, trace backwards to find the new max texture index
if (m_onePlusMaxNonDefaultTextureUnit == static_cast<unsigned long>(maxBoundTextureIndex + 1)) {
findNewMaxNonDefaultTextureUnit();
}
}
void WebGLRenderingContextBase::depthFunc(GLenum func)
{
if (isContextLost())
return;
contextGL()->DepthFunc(func);
}
void WebGLRenderingContextBase::depthMask(GLboolean flag)
{
if (isContextLost())
return;
m_depthMask = flag;
contextGL()->DepthMask(flag);
}
void WebGLRenderingContextBase::depthRange(GLfloat zNear, GLfloat zFar)
{
if (isContextLost())
return;
// Check required by WebGL spec section 6.12
if (zNear > zFar) {
synthesizeGLError(GL_INVALID_OPERATION, "depthRange", "zNear > zFar");
return;
}
contextGL()->DepthRangef(zNear, zFar);
}
void WebGLRenderingContextBase::detachShader(ScriptState* scriptState, WebGLProgram* program, WebGLShader* shader)
{
if (isContextLost() || !validateWebGLObject("detachShader", program) || !validateWebGLObject("detachShader", shader))
return;
if (!program->detachShader(shader)) {
synthesizeGLError(GL_INVALID_OPERATION, "detachShader", "shader not attached");
return;
}
contextGL()->DetachShader(objectOrZero(program), objectOrZero(shader));
shader->onDetached(contextGL());
preserveObjectWrapper(scriptState, program, V8HiddenValue::webglShaders(scriptState->isolate()), program->getPersistentCache(), static_cast<uint32_t>(shader->type()), nullptr);
}
void WebGLRenderingContextBase::disable(GLenum cap)
{
if (isContextLost() || !validateCapability("disable", cap))
return;
if (cap == GL_STENCIL_TEST) {
m_stencilEnabled = false;
applyStencilTest();
return;
}
if (cap == GL_SCISSOR_TEST) {
m_scissorEnabled = false;
drawingBuffer()->setScissorEnabled(m_scissorEnabled);
}
contextGL()->Disable(cap);
}
void WebGLRenderingContextBase::disableVertexAttribArray(GLuint index)
{
if (isContextLost())
return;
if (index >= m_maxVertexAttribs) {
synthesizeGLError(GL_INVALID_VALUE, "disableVertexAttribArray", "index out of range");
return;
}
m_boundVertexArrayObject->setAttribEnabled(index, false);
contextGL()->DisableVertexAttribArray(index);
}
bool WebGLRenderingContextBase::validateRenderingState(const char* functionName)
{
// Command buffer will not error if no program is bound.
if (!m_currentProgram) {
synthesizeGLError(GL_INVALID_OPERATION, functionName, "no valid shader program in use");
return false;
}
return true;
}
bool WebGLRenderingContextBase::validateWebGLObject(const char* functionName, WebGLObject* object)
{
if (!object || !object->hasObject()) {
synthesizeGLError(GL_INVALID_VALUE, functionName, "no object or object deleted");
return false;
}
if (!object->validate(contextGroup(), this)) {
synthesizeGLError(GL_INVALID_OPERATION, functionName, "object does not belong to this context");
return false;
}
return true;
}
void WebGLRenderingContextBase::drawArrays(GLenum mode, GLint first, GLsizei count)
{
if (!validateDrawArrays("drawArrays"))
return;
if (!m_boundVertexArrayObject->isAllEnabledAttribBufferBound()) {
synthesizeGLError(GL_INVALID_OPERATION, "drawArrays", "no buffer is bound to enabled attribute");
return;
}
ScopedRGBEmulationColorMask emulationColorMask(contextGL(), m_colorMask, m_drawingBuffer.get());
clearIfComposited();
contextGL()->DrawArrays(mode, first, count);
markContextChanged(CanvasChanged);
}
void WebGLRenderingContextBase::drawElements(GLenum mode, GLsizei count, GLenum type, long long offset)
{
if (!validateDrawElements("drawElements", type, offset))
return;
if (!m_boundVertexArrayObject->isAllEnabledAttribBufferBound()) {
synthesizeGLError(GL_INVALID_OPERATION, "drawElements", "no buffer is bound to enabled attribute");
return;
}
ScopedRGBEmulationColorMask emulationColorMask(contextGL(), m_colorMask, m_drawingBuffer.get());
clearIfComposited();
contextGL()->DrawElements(mode, count, type, reinterpret_cast<void*>(static_cast<intptr_t>(offset)));
markContextChanged(CanvasChanged);
}
void WebGLRenderingContextBase::drawArraysInstancedANGLE(GLenum mode, GLint first, GLsizei count, GLsizei primcount)
{
if (!validateDrawArrays("drawArraysInstancedANGLE"))
return;
if (!m_boundVertexArrayObject->isAllEnabledAttribBufferBound()) {
synthesizeGLError(GL_INVALID_OPERATION, "drawArraysInstancedANGLE", "no buffer is bound to enabled attribute");
return;
}
ScopedRGBEmulationColorMask emulationColorMask(contextGL(), m_colorMask, m_drawingBuffer.get());
clearIfComposited();
contextGL()->DrawArraysInstancedANGLE(mode, first, count, primcount);
markContextChanged(CanvasChanged);
}
void WebGLRenderingContextBase::drawElementsInstancedANGLE(GLenum mode, GLsizei count, GLenum type, long long offset, GLsizei primcount)
{
if (!validateDrawElements("drawElementsInstancedANGLE", type, offset))
return;
if (!m_boundVertexArrayObject->isAllEnabledAttribBufferBound()) {
synthesizeGLError(GL_INVALID_OPERATION, "drawElementsInstancedANGLE", "no buffer is bound to enabled attribute");
return;
}
ScopedRGBEmulationColorMask emulationColorMask(contextGL(), m_colorMask, m_drawingBuffer.get());
clearIfComposited();
contextGL()->DrawElementsInstancedANGLE(mode, count, type, reinterpret_cast<void*>(static_cast<intptr_t>(offset)), primcount);
markContextChanged(CanvasChanged);
}
void WebGLRenderingContextBase::enable(GLenum cap)
{
if (isContextLost() || !validateCapability("enable", cap))
return;
if (cap == GL_STENCIL_TEST) {
m_stencilEnabled = true;
applyStencilTest();
return;
}
if (cap == GL_SCISSOR_TEST) {
m_scissorEnabled = true;
drawingBuffer()->setScissorEnabled(m_scissorEnabled);
}
contextGL()->Enable(cap);
}
void WebGLRenderingContextBase::enableVertexAttribArray(GLuint index)
{
if (isContextLost())
return;
if (index >= m_maxVertexAttribs) {
synthesizeGLError(GL_INVALID_VALUE, "enableVertexAttribArray", "index out of range");
return;
}
m_boundVertexArrayObject->setAttribEnabled(index, true);
contextGL()->EnableVertexAttribArray(index);
}
void WebGLRenderingContextBase::finish()
{
if (isContextLost())
return;
contextGL()->Flush(); // Intentionally a flush, not a finish.
}
void WebGLRenderingContextBase::flush()
{
if (isContextLost())
return;
contextGL()->Flush();
}
void WebGLRenderingContextBase::framebufferRenderbuffer(ScriptState* scriptState, GLenum target, GLenum attachment, GLenum renderbuffertarget, WebGLRenderbuffer* buffer)
{
if (isContextLost() || !validateFramebufferFuncParameters("framebufferRenderbuffer", target, attachment))
return;
if (renderbuffertarget != GL_RENDERBUFFER) {
synthesizeGLError(GL_INVALID_ENUM, "framebufferRenderbuffer", "invalid target");
return;
}
if (buffer && !buffer->validate(contextGroup(), this)) {
synthesizeGLError(GL_INVALID_OPERATION, "framebufferRenderbuffer", "no buffer or buffer not from this context");
return;
}
// Don't allow the default framebuffer to be mutated; all current
// implementations use an FBO internally in place of the default
// FBO.
WebGLFramebuffer* framebufferBinding = getFramebufferBinding(target);
if (!framebufferBinding || !framebufferBinding->object()) {
synthesizeGLError(GL_INVALID_OPERATION, "framebufferRenderbuffer", "no framebuffer bound");
return;
}
GLuint bufferObject = objectOrZero(buffer);
if (isWebGL2OrHigher() && attachment == GL_DEPTH_STENCIL_ATTACHMENT) {
// On ES3, DEPTH_STENCIL_ATTACHMENT is like an alias for DEPTH_ATTACHMENT + STENCIL_ATTACHMENT.
// We divide it here so in WebGLFramebuffer, we don't have to handle DEPTH_STENCIL_ATTACHMENT in WebGL 2.
contextGL()->FramebufferRenderbuffer(target, GL_DEPTH_ATTACHMENT, renderbuffertarget, bufferObject);
contextGL()->FramebufferRenderbuffer(target, GL_STENCIL_ATTACHMENT, renderbuffertarget, bufferObject);
framebufferBinding->setAttachmentForBoundFramebuffer(target, GL_DEPTH_ATTACHMENT, buffer);
framebufferBinding->setAttachmentForBoundFramebuffer(target, GL_STENCIL_ATTACHMENT, buffer);
preserveObjectWrapper(scriptState, framebufferBinding, V8HiddenValue::webglAttachments(scriptState->isolate()), framebufferBinding->getPersistentCache(), GL_DEPTH_ATTACHMENT, buffer);
preserveObjectWrapper(scriptState, framebufferBinding, V8HiddenValue::webglAttachments(scriptState->isolate()), framebufferBinding->getPersistentCache(), GL_STENCIL_ATTACHMENT, buffer);
} else {
contextGL()->FramebufferRenderbuffer(target, attachment, renderbuffertarget, bufferObject);
framebufferBinding->setAttachmentForBoundFramebuffer(target, attachment, buffer);
preserveObjectWrapper(scriptState, framebufferBinding, V8HiddenValue::webglAttachments(scriptState->isolate()), framebufferBinding->getPersistentCache(), attachment, buffer);
}
applyStencilTest();
}
void WebGLRenderingContextBase::framebufferTexture2D(ScriptState* scriptState, GLenum target, GLenum attachment, GLenum textarget, WebGLTexture* texture, GLint level)
{
if (isContextLost() || !validateFramebufferFuncParameters("framebufferTexture2D", target, attachment))
return;
if (texture && !texture->validate(contextGroup(), this)) {
synthesizeGLError(GL_INVALID_OPERATION, "framebufferTexture2D", "no texture or texture not from this context");
return;
}
// Don't allow the default framebuffer to be mutated; all current
// implementations use an FBO internally in place of the default
// FBO.
WebGLFramebuffer* framebufferBinding = getFramebufferBinding(target);
if (!framebufferBinding || !framebufferBinding->object()) {
synthesizeGLError(GL_INVALID_OPERATION, "framebufferTexture2D", "no framebuffer bound");
return;
}
GLuint textureObject = objectOrZero(texture);
if (isWebGL2OrHigher() && attachment == GL_DEPTH_STENCIL_ATTACHMENT) {
// On ES3, DEPTH_STENCIL_ATTACHMENT is like an alias for DEPTH_ATTACHMENT + STENCIL_ATTACHMENT.
// We divide it here so in WebGLFramebuffer, we don't have to handle DEPTH_STENCIL_ATTACHMENT in WebGL 2.
contextGL()->FramebufferTexture2D(target, GL_DEPTH_ATTACHMENT, textarget, textureObject, level);
contextGL()->FramebufferTexture2D(target, GL_STENCIL_ATTACHMENT, textarget, textureObject, level);
framebufferBinding->setAttachmentForBoundFramebuffer(target, GL_DEPTH_ATTACHMENT, textarget, texture, level, 0);
framebufferBinding->setAttachmentForBoundFramebuffer(target, GL_STENCIL_ATTACHMENT, textarget, texture, level, 0);
preserveObjectWrapper(scriptState, framebufferBinding, V8HiddenValue::webglAttachments(scriptState->isolate()), framebufferBinding->getPersistentCache(), GL_DEPTH_ATTACHMENT, texture);
preserveObjectWrapper(scriptState, framebufferBinding, V8HiddenValue::webglAttachments(scriptState->isolate()), framebufferBinding->getPersistentCache(), GL_STENCIL_ATTACHMENT, texture);
} else {
contextGL()->FramebufferTexture2D(target, attachment, textarget, textureObject, level);
framebufferBinding->setAttachmentForBoundFramebuffer(target, attachment, textarget, texture, level, 0);
preserveObjectWrapper(scriptState, framebufferBinding, V8HiddenValue::webglAttachments(scriptState->isolate()), framebufferBinding->getPersistentCache(), attachment, texture);
}
applyStencilTest();
}
void WebGLRenderingContextBase::frontFace(GLenum mode)
{
if (isContextLost())
return;
contextGL()->FrontFace(mode);
}
void WebGLRenderingContextBase::generateMipmap(GLenum target)
{
if (isContextLost())
return;
if (!validateTextureBinding("generateMipmap", target))
return;
contextGL()->GenerateMipmap(target);
}
WebGLActiveInfo* WebGLRenderingContextBase::getActiveAttrib(WebGLProgram* program, GLuint index)
{
if (isContextLost() || !validateWebGLObject("getActiveAttrib", program))
return nullptr;
GLuint programId = objectNonZero(program);
GLint maxNameLength = -1;
contextGL()->GetProgramiv(programId, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &maxNameLength);
if (maxNameLength < 0)
return nullptr;
if (maxNameLength == 0) {
synthesizeGLError(GL_INVALID_VALUE, "getActiveAttrib", "no active attributes exist");
return nullptr;
}
LChar* namePtr;
RefPtr<StringImpl> nameImpl = StringImpl::createUninitialized(maxNameLength, namePtr);
GLsizei length = 0;
GLint size = -1;
GLenum type = 0;
contextGL()->GetActiveAttrib(programId, index, maxNameLength, &length, &size, &type, reinterpret_cast<GLchar*>(namePtr));
if (size < 0)
return nullptr;
return WebGLActiveInfo::create(nameImpl->substring(0, length), type, size);
}
WebGLActiveInfo* WebGLRenderingContextBase::getActiveUniform(WebGLProgram* program, GLuint index)
{
if (isContextLost() || !validateWebGLObject("getActiveUniform", program))
return nullptr;
GLuint programId = objectNonZero(program);
GLint maxNameLength = -1;
contextGL()->GetProgramiv(programId, GL_ACTIVE_UNIFORM_MAX_LENGTH, &maxNameLength);
if (maxNameLength < 0)
return nullptr;
if (maxNameLength == 0) {
synthesizeGLError(GL_INVALID_VALUE, "getActiveUniform", "no active uniforms exist");
return nullptr;
}
LChar* namePtr;
RefPtr<StringImpl> nameImpl = StringImpl::createUninitialized(maxNameLength, namePtr);
GLsizei length = 0;
GLint size = -1;
GLenum type = 0;
contextGL()->GetActiveUniform(programId, index, maxNameLength, &length, &size, &type, reinterpret_cast<GLchar*>(namePtr));
if (size < 0)
return nullptr;
return WebGLActiveInfo::create(nameImpl->substring(0, length), type, size);
}
Nullable<HeapVector<Member<WebGLShader>>> WebGLRenderingContextBase::getAttachedShaders(WebGLProgram* program)
{
if (isContextLost() || !validateWebGLObject("getAttachedShaders", program))
return nullptr;
HeapVector<Member<WebGLShader>> shaderObjects;
const GLenum shaderType[] = {
GL_VERTEX_SHADER,
GL_FRAGMENT_SHADER
};
for (unsigned i = 0; i < sizeof(shaderType) / sizeof(GLenum); ++i) {
WebGLShader* shader = program->getAttachedShader(shaderType[i]);
if (shader)
shaderObjects.append(shader);
}
return shaderObjects;
}
GLint WebGLRenderingContextBase::getAttribLocation(WebGLProgram* program, const String& name)
{
if (isContextLost() || !validateWebGLObject("getAttribLocation", program))
return -1;
if (!validateLocationLength("getAttribLocation", name))
return -1;
if (!validateString("getAttribLocation", name))
return -1;
if (isPrefixReserved(name))
return -1;
if (!program->linkStatus(this)) {
synthesizeGLError(GL_INVALID_OPERATION, "getAttribLocation", "program not linked");
return 0;
}
return contextGL()->GetAttribLocation(objectOrZero(program), name.utf8().data());
}
bool WebGLRenderingContextBase::validateBufferTarget(const char* functionName, GLenum target)
{
switch (target) {
case GL_ARRAY_BUFFER:
case GL_ELEMENT_ARRAY_BUFFER:
return true;
default:
synthesizeGLError(GL_INVALID_ENUM, functionName, "invalid target");
return false;
}
}
ScriptValue WebGLRenderingContextBase::getBufferParameter(ScriptState* scriptState, GLenum target, GLenum pname)
{
if (isContextLost() || !validateBufferTarget("getBufferParameter", target))
return ScriptValue::createNull(scriptState);
switch (pname) {
case GL_BUFFER_USAGE:
{
GLint value = 0;
contextGL()->GetBufferParameteriv(target, pname, &value);
return WebGLAny(scriptState, static_cast<unsigned>(value));
}
case GL_BUFFER_SIZE:
{
GLint value = 0;
contextGL()->GetBufferParameteriv(target, pname, &value);
if (!isWebGL2OrHigher())
return WebGLAny(scriptState, value);
return WebGLAny(scriptState, static_cast<GLint64>(value));
}
default:
synthesizeGLError(GL_INVALID_ENUM, "getBufferParameter", "invalid parameter name");
return ScriptValue::createNull(scriptState);
}
}
void WebGLRenderingContextBase::getContextAttributes(Nullable<WebGLContextAttributes>& result)
{
if (isContextLost())
return;
result.set(toWebGLContextAttributes(creationAttributes()));
// Some requested attributes may not be honored, so we need to query the underlying
// context/drawing buffer and adjust accordingly.
if (creationAttributes().depth() && !drawingBuffer()->hasDepthBuffer())
result.get().setDepth(false);
if (creationAttributes().stencil() && !drawingBuffer()->hasStencilBuffer())
result.get().setStencil(false);
result.get().setAntialias(drawingBuffer()->multisample());
}
GLenum WebGLRenderingContextBase::getError()
{
if (!m_lostContextErrors.isEmpty()) {
GLenum error = m_lostContextErrors.first();
m_lostContextErrors.remove(0);
return error;
}
if (isContextLost())
return GL_NO_ERROR;
if (!m_syntheticErrors.isEmpty()) {
GLenum error = m_syntheticErrors.first();
m_syntheticErrors.remove(0);
return error;
}
return contextGL()->GetError();
}
const char* const* WebGLRenderingContextBase::ExtensionTracker::prefixes() const
{
static const char* const unprefixed[] = { "", 0, };
return m_prefixes ? m_prefixes : unprefixed;
}
bool WebGLRenderingContextBase::ExtensionTracker::matchesNameWithPrefixes(const String& name) const
{
const char* const* prefixSet = prefixes();
for (; *prefixSet; ++prefixSet) {
String prefixedName = String(*prefixSet) + extensionName();
if (equalIgnoringCase(prefixedName, name)) {
return true;
}
}
return false;
}
bool WebGLRenderingContextBase::extensionSupportedAndAllowed(const ExtensionTracker* tracker)
{
if (tracker->draft() && !RuntimeEnabledFeatures::webGLDraftExtensionsEnabled())
return false;
if (!tracker->supported(this))
return false;
return true;
}
ScriptValue WebGLRenderingContextBase::getExtension(ScriptState* scriptState, const String& name)
{
WebGLExtension* extension = nullptr;
bool linkContextToExtension = false;
if (!isContextLost()) {
for (size_t i = 0; i < m_extensions.size(); ++i) {
ExtensionTracker* tracker = m_extensions[i];
if (tracker->matchesNameWithPrefixes(name)) {
if (extensionSupportedAndAllowed(tracker)) {
extension = tracker->getExtension(this);
if (extension) {
if (!m_extensionEnabled[extension->name()]) {
linkContextToExtension = true;
m_extensionEnabled[extension->name()] = true;
}
}