WebGLRenderingContextBase.h [plain text]
#pragma once
#include "ActiveDOMObject.h"
#include "ActivityStateChangeObserver.h"
#include "CanvasRenderingContext.h"
#include "GraphicsContext3D.h"
#include "ImageBuffer.h"
#include "Timer.h"
#include "WebGLContextAttributes.h"
#include "WebGLGetInfo.h"
#include "WebGLObject.h"
#include "WebGLStateTracker.h"
#include "WebGLTexture.h"
#include <memory>
#include <runtime/Float32Array.h>
#include <runtime/Int32Array.h>
namespace WebCore {
class ANGLEInstancedArrays;
class EXTBlendMinMax;
class EXTTextureFilterAnisotropic;
class EXTShaderTextureLOD;
class EXTsRGB;
class EXTFragDepth;
class HTMLImageElement;
class HTMLVideoElement;
class ImageBuffer;
class ImageData;
class IntSize;
class OESStandardDerivatives;
class OESTextureFloat;
class OESTextureFloatLinear;
class OESTextureHalfFloat;
class OESTextureHalfFloatLinear;
class OESVertexArrayObject;
class OESElementIndexUint;
class WebGLActiveInfo;
class WebGLBuffer;
class WebGLContextGroup;
class WebGLContextObject;
class WebGLCompressedTextureATC;
class WebGLCompressedTexturePVRTC;
class WebGLCompressedTextureS3TC;
class WebGLDebugRendererInfo;
class WebGLDebugShaders;
class WebGLDepthTexture;
class WebGLDrawBuffers;
class WebGLExtension;
class WebGLFramebuffer;
class WebGLLoseContext;
class WebGLObject;
class WebGLProgram;
class WebGLRenderbuffer;
class WebGLShader;
class WebGLSharedObject;
class WebGLShaderPrecisionFormat;
class WebGLUniformLocation;
class WebGLVertexArrayObjectOES;
inline void clip1D(GC3Dint start, GC3Dsizei range, GC3Dsizei sourceRange, GC3Dint* clippedStart, GC3Dsizei* clippedRange)
{
ASSERT(clippedStart && clippedRange);
if (start < 0) {
range += start;
start = 0;
}
GC3Dint end = start + range;
if (end > sourceRange)
range -= end - sourceRange;
*clippedStart = start;
*clippedRange = range;
}
inline bool clip2D(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height,
GC3Dsizei sourceWidth, GC3Dsizei sourceHeight,
GC3Dint* clippedX, GC3Dint* clippedY, GC3Dsizei* clippedWidth, GC3Dsizei*clippedHeight)
{
ASSERT(clippedX && clippedY && clippedWidth && clippedHeight);
clip1D(x, width, sourceWidth, clippedX, clippedWidth);
clip1D(y, height, sourceHeight, clippedY, clippedHeight);
return (*clippedX != x || *clippedY != y || *clippedWidth != width || *clippedHeight != height);
}
class WebGLRenderingContextBase : public CanvasRenderingContext, private ActivityStateChangeObserver, public ActiveDOMObject {
public:
static std::unique_ptr<WebGLRenderingContextBase> create(HTMLCanvasElement&, WebGLContextAttributes&, const String&);
virtual ~WebGLRenderingContextBase();
#if PLATFORM(WIN)
bool isAccelerated() const override { return false; }
#else
bool isAccelerated() const override { return true; }
#endif
int drawingBufferWidth() const;
int drawingBufferHeight() const;
void activeTexture(GC3Denum texture);
void attachShader(WebGLProgram*, WebGLShader*);
void bindAttribLocation(WebGLProgram*, GC3Duint index, const String& name);
void bindBuffer(GC3Denum target, WebGLBuffer*);
void bindFramebuffer(GC3Denum target, WebGLFramebuffer*);
void bindRenderbuffer(GC3Denum target, WebGLRenderbuffer*);
void bindTexture(GC3Denum target, WebGLTexture*);
void blendColor(GC3Dfloat red, GC3Dfloat green, GC3Dfloat blue, GC3Dfloat alpha);
void blendEquation(GC3Denum mode);
void blendEquationSeparate(GC3Denum modeRGB, GC3Denum modeAlpha);
void blendFunc(GC3Denum sfactor, GC3Denum dfactor);
void blendFuncSeparate(GC3Denum srcRGB, GC3Denum dstRGB, GC3Denum srcAlpha, GC3Denum dstAlpha);
using BufferDataSource = WTF::Variant<RefPtr<ArrayBuffer>, RefPtr<ArrayBufferView>>;
void bufferData(GC3Denum target, long long size, GC3Denum usage);
void bufferData(GC3Denum target, std::optional<BufferDataSource>&&, GC3Denum usage);
void bufferSubData(GC3Denum target, long long offset, std::optional<BufferDataSource>&&);
GC3Denum checkFramebufferStatus(GC3Denum target);
virtual void clear(GC3Dbitfield mask) = 0;
void clearColor(GC3Dfloat red, GC3Dfloat green, GC3Dfloat blue, GC3Dfloat alpha);
void clearDepth(GC3Dfloat);
void clearStencil(GC3Dint);
void colorMask(GC3Dboolean red, GC3Dboolean green, GC3Dboolean blue, GC3Dboolean alpha);
void compileShader(WebGLShader*);
void compressedTexImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, ArrayBufferView& data);
void compressedTexSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dsizei width, GC3Dsizei height, GC3Denum format, ArrayBufferView& data);
void copyTexImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height, GC3Dint border);
void copyTexSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height);
RefPtr<WebGLBuffer> createBuffer();
RefPtr<WebGLFramebuffer> createFramebuffer();
RefPtr<WebGLProgram> createProgram();
RefPtr<WebGLRenderbuffer> createRenderbuffer();
RefPtr<WebGLShader> createShader(GC3Denum type);
RefPtr<WebGLTexture> createTexture();
void cullFace(GC3Denum mode);
void deleteBuffer(WebGLBuffer*);
void deleteFramebuffer(WebGLFramebuffer*);
void deleteProgram(WebGLProgram*);
void deleteRenderbuffer(WebGLRenderbuffer*);
void deleteShader(WebGLShader*);
void deleteTexture(WebGLTexture*);
void depthFunc(GC3Denum);
void depthMask(GC3Dboolean);
void depthRange(GC3Dfloat zNear, GC3Dfloat zFar);
void detachShader(WebGLProgram*, WebGLShader*);
void disable(GC3Denum cap);
void disableVertexAttribArray(GC3Duint index);
void drawArrays(GC3Denum mode, GC3Dint first, GC3Dsizei count);
void drawElements(GC3Denum mode, GC3Dsizei count, GC3Denum type, long long offset);
void enable(GC3Denum cap);
void enableVertexAttribArray(GC3Duint index);
void finish();
void flush();
void framebufferRenderbuffer(GC3Denum target, GC3Denum attachment, GC3Denum renderbuffertarget, WebGLRenderbuffer*);
void framebufferTexture2D(GC3Denum target, GC3Denum attachment, GC3Denum textarget, WebGLTexture*, GC3Dint level);
void frontFace(GC3Denum mode);
void generateMipmap(GC3Denum target);
RefPtr<WebGLActiveInfo> getActiveAttrib(WebGLProgram*, GC3Duint index);
RefPtr<WebGLActiveInfo> getActiveUniform(WebGLProgram*, GC3Duint index);
bool getAttachedShaders(WebGLProgram*, Vector<RefPtr<WebGLShader>>&);
GC3Dint getAttribLocation(WebGLProgram*, const String& name);
WebGLGetInfo getBufferParameter(GC3Denum target, GC3Denum pname);
std::optional<WebGLContextAttributes> getContextAttributes();
GC3Denum getError();
virtual WebGLExtension* getExtension(const String& name) = 0;
virtual WebGLGetInfo getFramebufferAttachmentParameter(GC3Denum target, GC3Denum attachment, GC3Denum pname) = 0;
virtual WebGLGetInfo getParameter(GC3Denum pname) = 0;
WebGLGetInfo getProgramParameter(WebGLProgram*, GC3Denum pname);
String getProgramInfoLog(WebGLProgram*);
WebGLGetInfo getRenderbufferParameter(GC3Denum target, GC3Denum pname);
WebGLGetInfo getShaderParameter(WebGLShader*, GC3Denum pname);
String getShaderInfoLog(WebGLShader*);
RefPtr<WebGLShaderPrecisionFormat> getShaderPrecisionFormat(GC3Denum shaderType, GC3Denum precisionType);
String getShaderSource(WebGLShader*);
virtual Vector<String> getSupportedExtensions() = 0;
WebGLGetInfo getTexParameter(GC3Denum target, GC3Denum pname);
WebGLGetInfo getUniform(WebGLProgram*, const WebGLUniformLocation*);
RefPtr<WebGLUniformLocation> getUniformLocation(WebGLProgram*, const String&);
WebGLGetInfo getVertexAttrib(GC3Duint index, GC3Denum pname);
long long getVertexAttribOffset(GC3Duint index, GC3Denum pname);
virtual void hint(GC3Denum target, GC3Denum mode) = 0;
GC3Dboolean isBuffer(WebGLBuffer*);
bool isContextLost() const;
GC3Dboolean isEnabled(GC3Denum cap);
GC3Dboolean isFramebuffer(WebGLFramebuffer*);
GC3Dboolean isProgram(WebGLProgram*);
GC3Dboolean isRenderbuffer(WebGLRenderbuffer*);
GC3Dboolean isShader(WebGLShader*);
GC3Dboolean isTexture(WebGLTexture*);
void lineWidth(GC3Dfloat);
void linkProgram(WebGLProgram*);
void pixelStorei(GC3Denum pname, GC3Dint param);
void polygonOffset(GC3Dfloat factor, GC3Dfloat units);
void readPixels(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, ArrayBufferView& pixels);
void releaseShaderCompiler();
virtual void renderbufferStorage(GC3Denum target, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height) = 0;
void sampleCoverage(GC3Dfloat value, GC3Dboolean invert);
void scissor(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height);
void shaderSource(WebGLShader*, const String&);
void stencilFunc(GC3Denum func, GC3Dint ref, GC3Duint mask);
void stencilFuncSeparate(GC3Denum face, GC3Denum func, GC3Dint ref, GC3Duint mask);
void stencilMask(GC3Duint);
void stencilMaskSeparate(GC3Denum face, GC3Duint mask);
void stencilOp(GC3Denum fail, GC3Denum zfail, GC3Denum zpass);
void stencilOpSeparate(GC3Denum face, GC3Denum fail, GC3Denum zfail, GC3Denum zpass);
void texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, RefPtr<ArrayBufferView>&&);
using TexImageSource = WTF::Variant<RefPtr<ImageData>, RefPtr<HTMLImageElement>, RefPtr<HTMLCanvasElement>, RefPtr<HTMLVideoElement>>;
ExceptionOr<void> texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Denum format, GC3Denum type, std::optional<TexImageSource>);
void texParameterf(GC3Denum target, GC3Denum pname, GC3Dfloat param);
void texParameteri(GC3Denum target, GC3Denum pname, GC3Dint param);
void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, RefPtr<ArrayBufferView>&&);
ExceptionOr<void> texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, std::optional<TexImageSource>&&);
void uniform1f(const WebGLUniformLocation*, GC3Dfloat x);
void uniform1fv(const WebGLUniformLocation*, Float32Array& v);
void uniform1fv(const WebGLUniformLocation*, GC3Dfloat* v, GC3Dsizei);
void uniform1i(const WebGLUniformLocation*, GC3Dint x);
void uniform1iv(const WebGLUniformLocation*, Int32Array& v);
void uniform1iv(const WebGLUniformLocation*, GC3Dint* v, GC3Dsizei);
void uniform2f(const WebGLUniformLocation*, GC3Dfloat x, GC3Dfloat y);
void uniform2fv(const WebGLUniformLocation*, Float32Array& v);
void uniform2fv(const WebGLUniformLocation*, GC3Dfloat* v, GC3Dsizei);
void uniform2i(const WebGLUniformLocation*, GC3Dint x, GC3Dint y);
void uniform2iv(const WebGLUniformLocation*, Int32Array& v);
void uniform2iv(const WebGLUniformLocation*, GC3Dint* v, GC3Dsizei);
void uniform3f(const WebGLUniformLocation*, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z);
void uniform3fv(const WebGLUniformLocation*, Float32Array& v);
void uniform3fv(const WebGLUniformLocation*, GC3Dfloat* v, GC3Dsizei);
void uniform3i(const WebGLUniformLocation*, GC3Dint x, GC3Dint y, GC3Dint z);
void uniform3iv(const WebGLUniformLocation*, Int32Array& v);
void uniform3iv(const WebGLUniformLocation*, GC3Dint* v, GC3Dsizei);
void uniform4f(const WebGLUniformLocation*, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z, GC3Dfloat w);
void uniform4fv(const WebGLUniformLocation*, Float32Array& v);
void uniform4fv(const WebGLUniformLocation*, GC3Dfloat* v, GC3Dsizei);
void uniform4i(const WebGLUniformLocation*, GC3Dint x, GC3Dint y, GC3Dint z, GC3Dint w);
void uniform4iv(const WebGLUniformLocation*, Int32Array& v);
void uniform4iv(const WebGLUniformLocation*, GC3Dint* v, GC3Dsizei);
void uniformMatrix2fv(const WebGLUniformLocation*, GC3Dboolean transpose, Float32Array& value);
void uniformMatrix2fv(const WebGLUniformLocation*, GC3Dboolean transpose, GC3Dfloat* value, GC3Dsizei);
void uniformMatrix3fv(const WebGLUniformLocation*, GC3Dboolean transpose, Float32Array& value);
void uniformMatrix3fv(const WebGLUniformLocation*, GC3Dboolean transpose, GC3Dfloat* value, GC3Dsizei);
void uniformMatrix4fv(const WebGLUniformLocation*, GC3Dboolean transpose, Float32Array& value);
void uniformMatrix4fv(const WebGLUniformLocation*, GC3Dboolean transpose, GC3Dfloat* value, GC3Dsizei);
void useProgram(WebGLProgram*);
void validateProgram(WebGLProgram*);
void vertexAttrib1f(GC3Duint index, GC3Dfloat x);
void vertexAttrib1fv(GC3Duint index, Float32Array& values);
void vertexAttrib1fv(GC3Duint index, GC3Dfloat* values, GC3Dsizei size);
void vertexAttrib2f(GC3Duint index, GC3Dfloat x, GC3Dfloat y);
void vertexAttrib2fv(GC3Duint index, Float32Array& values);
void vertexAttrib2fv(GC3Duint index, GC3Dfloat* values, GC3Dsizei size);
void vertexAttrib3f(GC3Duint index, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z);
void vertexAttrib3fv(GC3Duint index, Float32Array& values);
void vertexAttrib3fv(GC3Duint index, GC3Dfloat* values, GC3Dsizei size);
void vertexAttrib4f(GC3Duint index, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z, GC3Dfloat w);
void vertexAttrib4fv(GC3Duint index, Float32Array& values);
void vertexAttrib4fv(GC3Duint index, GC3Dfloat* values, GC3Dsizei size);
void vertexAttribPointer(GC3Duint index, GC3Dint size, GC3Denum type, GC3Dboolean normalized,
GC3Dsizei stride, long long offset);
void viewport(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height);
enum LostContextMode {
RealLostContext,
SyntheticLostContext
};
void forceLostContext(LostContextMode);
void recycleContext();
void forceRestoreContext();
void loseContextImpl(LostContextMode);
void dispatchContextChangedEvent();
WEBCORE_EXPORT void simulateContextChanged();
GraphicsContext3D* graphicsContext3D() const { return m_context.get(); }
WebGLContextGroup* contextGroup() const { return m_contextGroup.get(); }
PlatformLayer* platformLayer() const override;
void reshape(int width, int height);
void markLayerComposited();
void paintRenderingResultsToCanvas() override;
RefPtr<ImageData> paintRenderingResultsToImageData();
void removeSharedObject(WebGLSharedObject*);
void removeContextObject(WebGLContextObject*);
unsigned getMaxVertexAttribs() const { return m_maxVertexAttribs; }
void drawArraysInstanced(GC3Denum mode, GC3Dint first, GC3Dsizei count, GC3Dsizei primcount);
void drawElementsInstanced(GC3Denum mode, GC3Dsizei count, GC3Denum type, long long offset, GC3Dsizei primcount);
void vertexAttribDivisor(GC3Duint index, GC3Duint divisor);
protected:
WebGLRenderingContextBase(HTMLCanvasElement&, WebGLContextAttributes);
WebGLRenderingContextBase(HTMLCanvasElement&, RefPtr<GraphicsContext3D>&&, WebGLContextAttributes);
friend class WebGLDrawBuffers;
friend class WebGLFramebuffer;
friend class WebGLObject;
friend class OESVertexArrayObject;
friend class WebGLDebugShaders;
friend class WebGLCompressedTextureATC;
friend class WebGLCompressedTexturePVRTC;
friend class WebGLCompressedTextureS3TC;
friend class WebGLRenderingContextErrorMessageCallback;
friend class WebGLVertexArrayObjectOES;
friend class WebGLVertexArrayObject;
friend class WebGLVertexArrayObjectBase;
virtual void initializeNewContext();
virtual void initializeVertexArrayObjects() = 0;
void setupFlags();
bool hasPendingActivity() const override;
void stop() override;
const char* activeDOMObjectName() const override;
bool canSuspendForDocumentSuspension() const override;
void addSharedObject(WebGLSharedObject*);
void addContextObject(WebGLContextObject*);
void detachAndRemoveAllObjects();
void destroyGraphicsContext3D();
void markContextChanged();
void addActivityStateChangeObserverIfNecessary();
void removeActivityStateChangeObserver();
bool isGLES2Compliant() { return m_isGLES2Compliant; }
bool isGLES2NPOTStrict() { return m_isGLES2NPOTStrict; }
bool isDepthStencilSupported() { return m_isDepthStencilSupported; }
unsigned int sizeInBytes(GC3Denum type);
bool validateElementArraySize(GC3Dsizei count, GC3Denum type, GC3Dintptr offset);
virtual bool validateIndexArrayConservative(GC3Denum type, unsigned& numElementsRequired) = 0;
bool validateIndexArrayPrecise(GC3Dsizei count, GC3Denum type, GC3Dintptr offset, unsigned& numElementsRequired);
bool validateVertexAttributes(unsigned elementCount, unsigned primitiveCount = 0);
bool validateWebGLObject(const char*, WebGLObject*);
bool validateDrawArrays(const char* functionName, GC3Denum mode, GC3Dint first, GC3Dsizei count, GC3Dsizei primcount);
bool validateDrawElements(const char* functionName, GC3Denum mode, GC3Dsizei count, GC3Denum type, long long offset, unsigned& numElements, GC3Dsizei primcount);
bool validateNPOTTextureLevel(GC3Dsizei width, GC3Dsizei height, GC3Dint level, const char* functionName);
void addCompressedTextureFormat(GC3Denum);
RefPtr<Image> drawImageIntoBuffer(Image&, int width, int height, int deviceScaleFactor);
#if ENABLE(VIDEO)
RefPtr<Image> videoFrameToImage(HTMLVideoElement*, BackingStoreCopy);
#endif
WebGLTexture::TextureExtensionFlag textureExtensionFlags() const;
RefPtr<GraphicsContext3D> m_context;
RefPtr<WebGLContextGroup> m_contextGroup;
Timer m_dispatchContextLostEventTimer;
bool m_restoreAllowed;
Timer m_restoreTimer;
bool m_needsUpdate;
bool m_markedCanvasDirty;
HashSet<WebGLContextObject*> m_contextObjects;
RefPtr<WebGLBuffer> m_boundArrayBuffer;
RefPtr<WebGLBuffer> m_boundCopyReadBuffer;
RefPtr<WebGLBuffer> m_boundCopyWriteBuffer;
RefPtr<WebGLBuffer> m_boundPixelPackBuffer;
RefPtr<WebGLBuffer> m_boundPixelUnpackBuffer;
RefPtr<WebGLBuffer> m_boundTransformFeedbackBuffer;
RefPtr<WebGLBuffer> m_boundUniformBuffer;
RefPtr<WebGLVertexArrayObjectBase> m_defaultVertexArrayObject;
RefPtr<WebGLVertexArrayObjectBase> m_boundVertexArrayObject;
void setBoundVertexArrayObject(PassRefPtr<WebGLVertexArrayObjectBase> arrayObject)
{
if (arrayObject)
m_boundVertexArrayObject = arrayObject;
else
m_boundVertexArrayObject = m_defaultVertexArrayObject;
}
class VertexAttribValue {
public:
VertexAttribValue()
{
initValue();
}
void initValue()
{
value[0] = 0.0f;
value[1] = 0.0f;
value[2] = 0.0f;
value[3] = 1.0f;
}
GC3Dfloat value[4];
};
Vector<VertexAttribValue> m_vertexAttribValue;
unsigned m_maxVertexAttribs;
RefPtr<WebGLBuffer> m_vertexAttrib0Buffer;
long m_vertexAttrib0BufferSize;
GC3Dfloat m_vertexAttrib0BufferValue[4];
bool m_forceAttrib0BufferRefill;
bool m_vertexAttrib0UsedBefore;
RefPtr<WebGLProgram> m_currentProgram;
RefPtr<WebGLFramebuffer> m_framebufferBinding;
RefPtr<WebGLRenderbuffer> m_renderbufferBinding;
struct TextureUnitState {
RefPtr<WebGLTexture> texture2DBinding;
RefPtr<WebGLTexture> textureCubeMapBinding;
};
Vector<TextureUnitState> m_textureUnits;
HashSet<unsigned, DefaultHash<unsigned>::Hash, WTF::UnsignedWithZeroKeyHashTraits<unsigned>> m_unrenderableTextureUnits;
unsigned long m_activeTextureUnit;
RefPtr<WebGLTexture> m_blackTexture2D;
RefPtr<WebGLTexture> m_blackTextureCubeMap;
Vector<GC3Denum> m_compressedTextureFormats;
class LRUImageBufferCache {
public:
LRUImageBufferCache(int capacity);
ImageBuffer* imageBuffer(const IntSize& size);
private:
void bubbleToFront(int idx);
std::unique_ptr<std::unique_ptr<ImageBuffer>[]> m_buffers;
int m_capacity;
};
LRUImageBufferCache m_generatedImageCache;
GC3Dint m_maxTextureSize;
GC3Dint m_maxCubeMapTextureSize;
GC3Dint m_maxRenderbufferSize;
GC3Dint m_maxViewportDims[2];
GC3Dint m_maxTextureLevel;
GC3Dint m_maxCubeMapTextureLevel;
GC3Dint m_maxDrawBuffers;
GC3Dint m_maxColorAttachments;
GC3Denum m_backDrawBuffer;
bool m_drawBuffersWebGLRequirementsChecked;
bool m_drawBuffersSupported;
GC3Dint m_packAlignment;
GC3Dint m_unpackAlignment;
bool m_unpackFlipY;
bool m_unpackPremultiplyAlpha;
GC3Denum m_unpackColorspaceConversion;
bool m_contextLost;
LostContextMode m_contextLostMode;
WebGLContextAttributes m_attributes;
bool m_layerCleared;
GC3Dfloat m_clearColor[4];
bool m_scissorEnabled;
GC3Dfloat m_clearDepth;
GC3Dint m_clearStencil;
GC3Dboolean m_colorMask[4];
GC3Dboolean m_depthMask;
bool m_stencilEnabled;
GC3Duint m_stencilMask, m_stencilMaskBack;
GC3Dint m_stencilFuncRef, m_stencilFuncRefBack; GC3Duint m_stencilFuncMask, m_stencilFuncMaskBack;
bool m_isGLES2Compliant;
bool m_isGLES2NPOTStrict;
bool m_isDepthStencilSupported;
bool m_isRobustnessEXTSupported;
bool m_synthesizedErrorsToConsole;
int m_numGLErrorsToConsoleAllowed;
bool m_isPendingPolicyResolution;
bool m_hasRequestedPolicyResolution;
bool isContextLostOrPending();
std::unique_ptr<EXTFragDepth> m_extFragDepth;
std::unique_ptr<EXTBlendMinMax> m_extBlendMinMax;
std::unique_ptr<EXTsRGB> m_extsRGB;
std::unique_ptr<EXTTextureFilterAnisotropic> m_extTextureFilterAnisotropic;
std::unique_ptr<EXTShaderTextureLOD> m_extShaderTextureLOD;
std::unique_ptr<OESTextureFloat> m_oesTextureFloat;
std::unique_ptr<OESTextureFloatLinear> m_oesTextureFloatLinear;
std::unique_ptr<OESTextureHalfFloat> m_oesTextureHalfFloat;
std::unique_ptr<OESTextureHalfFloatLinear> m_oesTextureHalfFloatLinear;
std::unique_ptr<OESStandardDerivatives> m_oesStandardDerivatives;
std::unique_ptr<OESVertexArrayObject> m_oesVertexArrayObject;
std::unique_ptr<OESElementIndexUint> m_oesElementIndexUint;
std::unique_ptr<WebGLLoseContext> m_webglLoseContext;
std::unique_ptr<WebGLDebugRendererInfo> m_webglDebugRendererInfo;
std::unique_ptr<WebGLDebugShaders> m_webglDebugShaders;
std::unique_ptr<WebGLCompressedTextureATC> m_webglCompressedTextureATC;
std::unique_ptr<WebGLCompressedTexturePVRTC> m_webglCompressedTexturePVRTC;
std::unique_ptr<WebGLCompressedTextureS3TC> m_webglCompressedTextureS3TC;
std::unique_ptr<WebGLDepthTexture> m_webglDepthTexture;
std::unique_ptr<WebGLDrawBuffers> m_webglDrawBuffers;
std::unique_ptr<ANGLEInstancedArrays> m_angleInstancedArrays;
WebGLGetInfo getBooleanParameter(GC3Denum);
WebGLGetInfo getBooleanArrayParameter(GC3Denum);
WebGLGetInfo getFloatParameter(GC3Denum);
WebGLGetInfo getIntParameter(GC3Denum);
WebGLGetInfo getUnsignedIntParameter(GC3Denum);
WebGLGetInfo getInt64Parameter(GC3Denum);
WebGLGetInfo getWebGLFloatArrayParameter(GC3Denum);
WebGLGetInfo getWebGLIntArrayParameter(GC3Denum);
bool clearIfComposited(GC3Dbitfield clearMask = 0);
void restoreStateAfterClear();
void texImage2DBase(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, const void* pixels);
void texImage2DImpl(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Denum format, GC3Denum type, Image*, GraphicsContext3D::ImageHtmlDomSource, bool flipY, bool premultiplyAlpha);
void texSubImage2DBase(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dsizei width, GC3Dsizei height, GC3Denum internalformat, GC3Denum format, GC3Denum type, const void* pixels);
void texSubImage2DImpl(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, Image*, GraphicsContext3D::ImageHtmlDomSource, bool flipY, bool premultiplyAlpha);
bool checkTextureCompleteness(const char*, bool);
void createFallbackBlackTextures1x1();
bool isTexInternalFormatColorBufferCombinationValid(GC3Denum texInternalFormat,
GC3Denum colorBufferFormat);
GC3Denum getBoundFramebufferColorFormat();
int getBoundFramebufferWidth();
int getBoundFramebufferHeight();
bool validateLocationLength(const char* functionName, const String&);
bool validateSize(const char* functionName, GC3Dint x, GC3Dint y);
bool validateString(const char* functionName, const String&);
WebGLTexture* validateTextureBinding(const char* functionName, GC3Denum target, bool useSixEnumsForCubeMap);
bool validateTexFuncFormatAndType(const char* functionName, GC3Denum internalformat, GC3Denum format, GC3Denum type, GC3Dint level);
bool validateTexFuncLevel(const char* functionName, GC3Denum target, GC3Dint level);
enum TexFuncValidationFunctionType {
TexImage,
TexSubImage,
CopyTexImage
};
enum TexFuncValidationSourceType {
SourceArrayBufferView,
SourceImageData,
SourceHTMLImageElement,
SourceHTMLCanvasElement,
SourceHTMLVideoElement,
};
bool validateTexFunc(const char* functionName, TexFuncValidationFunctionType, TexFuncValidationSourceType, GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width,
GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, GC3Dint xoffset, GC3Dint yoffset);
bool validateTexFuncParameters(const char* functionName,
TexFuncValidationFunctionType,
GC3Denum target, GC3Dint level,
GC3Denum internalformat,
GC3Dsizei width, GC3Dsizei height, GC3Dint border,
GC3Denum format, GC3Denum type);
enum NullDisposition {
NullAllowed,
NullNotAllowed
};
bool validateTexFuncData(const char* functionName, GC3Dint level,
GC3Dsizei width, GC3Dsizei height,
GC3Denum internalformat, GC3Denum format, GC3Denum type,
ArrayBufferView* pixels,
NullDisposition);
bool validateSettableTexInternalFormat(const char* functionName, GC3Denum format);
bool validateCompressedTexFuncData(const char* functionName, GC3Dsizei width, GC3Dsizei height, GC3Denum format, ArrayBufferView& pixels);
bool validateCompressedTexFormat(GC3Denum format);
bool validateCompressedTexDimensions(const char* functionName, GC3Denum target, GC3Dint level, GC3Dsizei width, GC3Dsizei height, GC3Denum format);
bool validateCompressedTexSubDimensions(const char* functionName, GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,
GC3Dsizei width, GC3Dsizei height, GC3Denum format, WebGLTexture*);
bool validateDrawMode(const char* functionName, GC3Denum);
bool validateStencilSettings(const char* functionName);
bool validateStencilFunc(const char* functionName, GC3Denum);
void texParameter(GC3Denum target, GC3Denum pname, GC3Dfloat parami, GC3Dint paramf, bool isFloat);
void printGLErrorToConsole(const String&);
void printGLWarningToConsole(const char* function, const char* reason);
void printWarningToConsole(const String&);
virtual bool validateFramebufferFuncParameters(const char* functionName, GC3Denum target, GC3Denum attachment) = 0;
virtual bool validateBlendEquation(const char* functionName, GC3Denum) = 0;
bool validateBlendFuncFactors(const char* functionName, GC3Denum src, GC3Denum dst);
virtual bool validateCapability(const char* functionName, GC3Denum) = 0;
bool validateUniformParameters(const char* functionName, const WebGLUniformLocation*, Float32Array&, GC3Dsizei mod);
bool validateUniformParameters(const char* functionName, const WebGLUniformLocation*, Int32Array&, GC3Dsizei mod);
bool validateUniformParameters(const char* functionName, const WebGLUniformLocation*, void*, GC3Dsizei, GC3Dsizei mod);
bool validateUniformMatrixParameters(const char* functionName, const WebGLUniformLocation*, GC3Dboolean transpose, Float32Array&, GC3Dsizei mod);
bool validateUniformMatrixParameters(const char* functionName, const WebGLUniformLocation*, GC3Dboolean transpose, void*, GC3Dsizei, GC3Dsizei mod);
WebGLBuffer* validateBufferDataParameters(const char* functionName, GC3Denum target, GC3Denum usage);
bool validateHTMLImageElement(const char* functionName, HTMLImageElement*);
bool validateHTMLCanvasElement(const char* functionName, HTMLCanvasElement*);
#if ENABLE(VIDEO)
bool validateHTMLVideoElement(const char* functionName, HTMLVideoElement*);
#endif
void vertexAttribfImpl(const char* functionName, GC3Duint index, GC3Dsizei expectedSize, GC3Dfloat, GC3Dfloat, GC3Dfloat, GC3Dfloat);
void vertexAttribfvImpl(const char* functionName, GC3Duint index, Float32Array&, GC3Dsizei expectedSize);
void vertexAttribfvImpl(const char* functionName, GC3Duint index, GC3Dfloat*, GC3Dsizei, GC3Dsizei expectedSize);
bool deleteObject(WebGLObject*);
bool checkObjectToBeBound(const char* functionName, WebGLObject*, bool& deleted);
void initVertexAttrib0();
bool simulateVertexAttrib0(GC3Dsizei numVertex);
bool validateSimulatedVertexAttrib0(GC3Dsizei numVertex);
void restoreStatesAfterVertexAttrib0Simulation();
void dispatchContextLostEvent();
void maybeRestoreContext();
enum ConsoleDisplayPreference { DisplayInConsole, DontDisplayInConsole };
void synthesizeGLError(GC3Denum, const char* functionName, const char* description, ConsoleDisplayPreference = DisplayInConsole);
String ensureNotNull(const String&) const;
void applyStencilTest();
void enableOrDisable(GC3Denum capability, bool enable);
IntSize clampedCanvasSize();
virtual GC3Dint getMaxDrawBuffers() = 0;
virtual GC3Dint getMaxColorAttachments() = 0;
void setBackDrawBuffer(GC3Denum);
void restoreCurrentFramebuffer();
void restoreCurrentTexture2D();
bool supportsDrawBuffers();
private:
bool validateArrayBufferType(const char* functionName, GC3Denum type, std::optional<JSC::TypedArrayType>);
void registerWithWebGLStateTracker();
void checkForContextLossHandling();
void activityStateDidChange(ActivityState::Flags oldActivityState, ActivityState::Flags newActivityState) override;
WebGLStateTracker::Token m_trackerToken;
Timer m_checkForContextLossHandlingTimer;
};
}
SPECIALIZE_TYPE_TRAITS_CANVASRENDERINGCONTEXT(WebCore::WebGLRenderingContextBase, is3d())