WebGLRenderingContext.h [plain text]
#ifndef WebGLRenderingContext_h
#define WebGLRenderingContext_h
#include "ActiveDOMObject.h"
#include "CanvasRenderingContext.h"
#include "DrawingBuffer.h"
#include "GraphicsContext3D.h"
#include "ImageBuffer.h"
#include "Timer.h"
#include "WebGLGetInfo.h"
#include <wtf/Float32Array.h>
#include <wtf/Int32Array.h>
#include <wtf/OwnArrayPtr.h>
#include <wtf/Uint8Array.h>
#include <wtf/text/WTFString.h>
namespace WebCore {
class EXTDrawBuffers;
class EXTTextureFilterAnisotropic;
class HTMLImageElement;
class HTMLVideoElement;
class ImageBuffer;
class ImageData;
class IntSize;
class OESStandardDerivatives;
class OESTextureFloat;
class OESTextureHalfFloat;
class OESVertexArrayObject;
class OESElementIndexUint;
class WebGLActiveInfo;
class WebGLBuffer;
class WebGLContextGroup;
class WebGLContextObject;
class WebGLCompressedTextureATC;
class WebGLCompressedTexturePVRTC;
class WebGLCompressedTextureS3TC;
class WebGLContextAttributes;
class WebGLDebugRendererInfo;
class WebGLDebugShaders;
class WebGLDepthTexture;
class WebGLExtension;
class WebGLFramebuffer;
class WebGLLoseContext;
class WebGLObject;
class WebGLProgram;
class WebGLRenderbuffer;
class WebGLShader;
class WebGLSharedObject;
class WebGLShaderPrecisionFormat;
class WebGLTexture;
class WebGLUniformLocation;
class WebGLVertexArrayObjectOES;
typedef int ExceptionCode;
class WebGLRenderingContext : public CanvasRenderingContext, public ActiveDOMObject {
public:
static PassOwnPtr<WebGLRenderingContext> create(HTMLCanvasElement*, WebGLContextAttributes*);
virtual ~WebGLRenderingContext();
virtual bool is3d() const { return true; }
virtual bool isAccelerated() const { return true; }
int drawingBufferWidth() const;
int drawingBufferHeight() const;
void activeTexture(GC3Denum texture, ExceptionCode&);
void attachShader(WebGLProgram*, WebGLShader*, ExceptionCode&);
void bindAttribLocation(WebGLProgram*, GC3Duint index, const String& name, ExceptionCode&);
void bindBuffer(GC3Denum target, WebGLBuffer*, ExceptionCode&);
void bindFramebuffer(GC3Denum target, WebGLFramebuffer*, ExceptionCode&);
void bindRenderbuffer(GC3Denum target, WebGLRenderbuffer*, ExceptionCode&);
void bindTexture(GC3Denum target, WebGLTexture*, ExceptionCode&);
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);
void bufferData(GC3Denum target, long long size, GC3Denum usage, ExceptionCode&);
void bufferData(GC3Denum target, ArrayBuffer* data, GC3Denum usage, ExceptionCode&);
void bufferData(GC3Denum target, ArrayBufferView* data, GC3Denum usage, ExceptionCode&);
void bufferSubData(GC3Denum target, long long offset, ArrayBuffer* data, ExceptionCode&);
void bufferSubData(GC3Denum target, long long offset, ArrayBufferView* data, ExceptionCode&);
GC3Denum checkFramebufferStatus(GC3Denum target);
void clear(GC3Dbitfield mask);
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*, ExceptionCode&);
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);
PassRefPtr<WebGLBuffer> createBuffer();
PassRefPtr<WebGLFramebuffer> createFramebuffer();
PassRefPtr<WebGLProgram> createProgram();
PassRefPtr<WebGLRenderbuffer> createRenderbuffer();
PassRefPtr<WebGLShader> createShader(GC3Denum type, ExceptionCode&);
PassRefPtr<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*, ExceptionCode&);
void disable(GC3Denum cap);
void disableVertexAttribArray(GC3Duint index, ExceptionCode&);
void drawArrays(GC3Denum mode, GC3Dint first, GC3Dsizei count, ExceptionCode&);
void drawElements(GC3Denum mode, GC3Dsizei count, GC3Denum type, long long offset, ExceptionCode&);
void enable(GC3Denum cap);
void enableVertexAttribArray(GC3Duint index, ExceptionCode&);
void finish();
void flush();
void framebufferRenderbuffer(GC3Denum target, GC3Denum attachment, GC3Denum renderbuffertarget, WebGLRenderbuffer*, ExceptionCode&);
void framebufferTexture2D(GC3Denum target, GC3Denum attachment, GC3Denum textarget, WebGLTexture*, GC3Dint level, ExceptionCode&);
void frontFace(GC3Denum mode);
void generateMipmap(GC3Denum target);
PassRefPtr<WebGLActiveInfo> getActiveAttrib(WebGLProgram*, GC3Duint index, ExceptionCode&);
PassRefPtr<WebGLActiveInfo> getActiveUniform(WebGLProgram*, GC3Duint index, ExceptionCode&);
bool getAttachedShaders(WebGLProgram*, Vector<RefPtr<WebGLShader> >&, ExceptionCode&);
GC3Dint getAttribLocation(WebGLProgram*, const String& name);
WebGLGetInfo getBufferParameter(GC3Denum target, GC3Denum pname, ExceptionCode&);
PassRefPtr<WebGLContextAttributes> getContextAttributes();
GC3Denum getError();
WebGLExtension* getExtension(const String& name);
WebGLGetInfo getFramebufferAttachmentParameter(GC3Denum target, GC3Denum attachment, GC3Denum pname, ExceptionCode&);
WebGLGetInfo getParameter(GC3Denum pname, ExceptionCode&);
WebGLGetInfo getProgramParameter(WebGLProgram*, GC3Denum pname, ExceptionCode&);
String getProgramInfoLog(WebGLProgram*, ExceptionCode&);
WebGLGetInfo getRenderbufferParameter(GC3Denum target, GC3Denum pname, ExceptionCode&);
WebGLGetInfo getShaderParameter(WebGLShader*, GC3Denum pname, ExceptionCode&);
String getShaderInfoLog(WebGLShader*, ExceptionCode&);
PassRefPtr<WebGLShaderPrecisionFormat> getShaderPrecisionFormat(GC3Denum shaderType, GC3Denum precisionType, ExceptionCode&);
String getShaderSource(WebGLShader*, ExceptionCode&);
Vector<String> getSupportedExtensions();
WebGLGetInfo getTexParameter(GC3Denum target, GC3Denum pname, ExceptionCode&);
WebGLGetInfo getUniform(WebGLProgram*, const WebGLUniformLocation*, ExceptionCode&);
PassRefPtr<WebGLUniformLocation> getUniformLocation(WebGLProgram*, const String&, ExceptionCode&);
WebGLGetInfo getVertexAttrib(GC3Duint index, GC3Denum pname, ExceptionCode&);
long long getVertexAttribOffset(GC3Duint index, GC3Denum pname);
void hint(GC3Denum target, GC3Denum mode);
GC3Dboolean isBuffer(WebGLBuffer*);
bool isContextLost();
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*, ExceptionCode&);
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, ExceptionCode&);
void releaseShaderCompiler();
void renderbufferStorage(GC3Denum target, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height);
void sampleCoverage(GC3Dfloat value, GC3Dboolean invert);
void scissor(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height);
void shaderSource(WebGLShader*, const String&, ExceptionCode&);
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, ArrayBufferView*, ExceptionCode&);
void texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,
GC3Denum format, GC3Denum type, ImageData*, ExceptionCode&);
void texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,
GC3Denum format, GC3Denum type, HTMLImageElement*, ExceptionCode&);
void texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,
GC3Denum format, GC3Denum type, HTMLCanvasElement*, ExceptionCode&);
#if ENABLE(VIDEO)
void texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,
GC3Denum format, GC3Denum type, HTMLVideoElement*, ExceptionCode&);
#endif
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, ArrayBufferView*, ExceptionCode&);
void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,
GC3Denum format, GC3Denum type, ImageData*, ExceptionCode&);
void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,
GC3Denum format, GC3Denum type, HTMLImageElement*, ExceptionCode&);
void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,
GC3Denum format, GC3Denum type, HTMLCanvasElement*, ExceptionCode&);
#if ENABLE(VIDEO)
void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,
GC3Denum format, GC3Denum type, HTMLVideoElement*, ExceptionCode&);
#endif
void uniform1f(const WebGLUniformLocation* location, GC3Dfloat x, ExceptionCode&);
void uniform1fv(const WebGLUniformLocation* location, Float32Array* v, ExceptionCode&);
void uniform1fv(const WebGLUniformLocation* location, GC3Dfloat* v, GC3Dsizei size, ExceptionCode&);
void uniform1i(const WebGLUniformLocation* location, GC3Dint x, ExceptionCode&);
void uniform1iv(const WebGLUniformLocation* location, Int32Array* v, ExceptionCode&);
void uniform1iv(const WebGLUniformLocation* location, GC3Dint* v, GC3Dsizei size, ExceptionCode&);
void uniform2f(const WebGLUniformLocation* location, GC3Dfloat x, GC3Dfloat y, ExceptionCode&);
void uniform2fv(const WebGLUniformLocation* location, Float32Array* v, ExceptionCode&);
void uniform2fv(const WebGLUniformLocation* location, GC3Dfloat* v, GC3Dsizei size, ExceptionCode&);
void uniform2i(const WebGLUniformLocation* location, GC3Dint x, GC3Dint y, ExceptionCode&);
void uniform2iv(const WebGLUniformLocation* location, Int32Array* v, ExceptionCode&);
void uniform2iv(const WebGLUniformLocation* location, GC3Dint* v, GC3Dsizei size, ExceptionCode&);
void uniform3f(const WebGLUniformLocation* location, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z, ExceptionCode&);
void uniform3fv(const WebGLUniformLocation* location, Float32Array* v, ExceptionCode&);
void uniform3fv(const WebGLUniformLocation* location, GC3Dfloat* v, GC3Dsizei size, ExceptionCode&);
void uniform3i(const WebGLUniformLocation* location, GC3Dint x, GC3Dint y, GC3Dint z, ExceptionCode&);
void uniform3iv(const WebGLUniformLocation* location, Int32Array* v, ExceptionCode&);
void uniform3iv(const WebGLUniformLocation* location, GC3Dint* v, GC3Dsizei size, ExceptionCode&);
void uniform4f(const WebGLUniformLocation* location, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z, GC3Dfloat w, ExceptionCode&);
void uniform4fv(const WebGLUniformLocation* location, Float32Array* v, ExceptionCode&);
void uniform4fv(const WebGLUniformLocation* location, GC3Dfloat* v, GC3Dsizei size, ExceptionCode&);
void uniform4i(const WebGLUniformLocation* location, GC3Dint x, GC3Dint y, GC3Dint z, GC3Dint w, ExceptionCode&);
void uniform4iv(const WebGLUniformLocation* location, Int32Array* v, ExceptionCode&);
void uniform4iv(const WebGLUniformLocation* location, GC3Dint* v, GC3Dsizei size, ExceptionCode&);
void uniformMatrix2fv(const WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* value, ExceptionCode&);
void uniformMatrix2fv(const WebGLUniformLocation* location, GC3Dboolean transpose, GC3Dfloat* value, GC3Dsizei size, ExceptionCode&);
void uniformMatrix3fv(const WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* value, ExceptionCode&);
void uniformMatrix3fv(const WebGLUniformLocation* location, GC3Dboolean transpose, GC3Dfloat* value, GC3Dsizei size, ExceptionCode&);
void uniformMatrix4fv(const WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* value, ExceptionCode&);
void uniformMatrix4fv(const WebGLUniformLocation* location, GC3Dboolean transpose, GC3Dfloat* value, GC3Dsizei size, ExceptionCode&);
void useProgram(WebGLProgram*, ExceptionCode&);
void validateProgram(WebGLProgram*, ExceptionCode&);
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, ExceptionCode&);
void viewport(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height);
enum LostContextMode {
RealLostContext,
SyntheticLostContext
};
void forceLostContext(LostContextMode);
void forceRestoreContext();
void loseContextImpl(LostContextMode);
GraphicsContext3D* graphicsContext3D() const { return m_context.get(); }
WebGLContextGroup* contextGroup() const { return m_contextGroup.get(); }
#if USE(ACCELERATED_COMPOSITING)
virtual PlatformLayer* platformLayer() const;
#endif
void reshape(int width, int height);
void markLayerComposited();
virtual void paintRenderingResultsToCanvas();
virtual PassRefPtr<ImageData> paintRenderingResultsToImageData();
void removeSharedObject(WebGLSharedObject*);
void removeContextObject(WebGLContextObject*);
unsigned getMaxVertexAttribs() const { return m_maxVertexAttribs; }
virtual bool hasPendingActivity() const;
virtual void stop();
private:
friend class EXTDrawBuffers;
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;
WebGLRenderingContext(HTMLCanvasElement*, PassRefPtr<GraphicsContext3D>, GraphicsContext3D::Attributes);
void initializeNewContext();
void setupFlags();
void addSharedObject(WebGLSharedObject*);
void addContextObject(WebGLContextObject*);
void detachAndRemoveAllObjects();
void destroyGraphicsContext3D();
void markContextChanged();
void cleanupAfterGraphicsCall(bool changed)
{
if (changed)
markContextChanged();
}
bool isGLES2Compliant() { return m_isGLES2Compliant; }
bool isGLES2NPOTStrict() { return m_isGLES2NPOTStrict; }
bool isErrorGeneratedOnOutOfBoundsAccesses() { return m_isErrorGeneratedOnOutOfBoundsAccesses; }
bool isResourceSafe() { return m_isResourceSafe; }
bool isDepthStencilSupported() { return m_isDepthStencilSupported; }
unsigned int sizeInBytes(GC3Denum type);
bool validateElementArraySize(GC3Dsizei count, GC3Denum type, GC3Dintptr offset);
bool validateIndexArrayConservative(GC3Denum type, unsigned& numElementsRequired);
bool validateIndexArrayPrecise(GC3Dsizei count, GC3Denum type, GC3Dintptr offset, unsigned& numElementsRequired);
bool validateRenderingState(unsigned numElements);
bool validateWebGLObject(const char*, WebGLObject*);
void addCompressedTextureFormat(GC3Denum);
#if ENABLE(VIDEO)
PassRefPtr<Image> videoFrameToImage(HTMLVideoElement*, BackingStoreCopy, ExceptionCode&);
#endif
RefPtr<GraphicsContext3D> m_context;
RefPtr<WebGLContextGroup> m_contextGroup;
RefPtr<DrawingBuffer> m_drawingBuffer;
Timer<WebGLRenderingContext> m_dispatchContextLostEventTimer;
bool m_restoreAllowed;
Timer<WebGLRenderingContext> m_restoreTimer;
bool m_needsUpdate;
bool m_markedCanvasDirty;
HashSet<WebGLContextObject*> m_contextObjects;
RefPtr<WebGLBuffer> m_boundArrayBuffer;
RefPtr<WebGLVertexArrayObjectOES> m_defaultVertexArrayObject;
RefPtr<WebGLVertexArrayObjectOES> m_boundVertexArrayObject;
void setBoundVertexArrayObject(PassRefPtr<WebGLVertexArrayObjectOES> 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;
class TextureUnitState {
public:
RefPtr<WebGLTexture> m_texture2DBinding;
RefPtr<WebGLTexture> m_textureCubeMapBinding;
};
Vector<TextureUnitState> m_textureUnits;
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);
OwnArrayPtr<OwnPtr<ImageBuffer> > m_buffers;
int m_capacity;
};
LRUImageBufferCache m_videoCache;
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;
GraphicsContext3D::Attributes 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_isErrorGeneratedOnOutOfBoundsAccesses;
bool m_isResourceSafe;
bool m_isDepthStencilSupported;
bool m_isRobustnessEXTSupported;
bool m_synthesizedErrorsToConsole;
int m_numGLErrorsToConsoleAllowed;
OwnPtr<EXTDrawBuffers> m_extDrawBuffers;
OwnPtr<EXTTextureFilterAnisotropic> m_extTextureFilterAnisotropic;
OwnPtr<OESTextureFloat> m_oesTextureFloat;
OwnPtr<OESTextureHalfFloat> m_oesTextureHalfFloat;
OwnPtr<OESStandardDerivatives> m_oesStandardDerivatives;
OwnPtr<OESVertexArrayObject> m_oesVertexArrayObject;
OwnPtr<OESElementIndexUint> m_oesElementIndexUint;
OwnPtr<WebGLLoseContext> m_webglLoseContext;
OwnPtr<WebGLDebugRendererInfo> m_webglDebugRendererInfo;
OwnPtr<WebGLDebugShaders> m_webglDebugShaders;
OwnPtr<WebGLCompressedTextureATC> m_webglCompressedTextureATC;
OwnPtr<WebGLCompressedTexturePVRTC> m_webglCompressedTexturePVRTC;
OwnPtr<WebGLCompressedTextureS3TC> m_webglCompressedTextureS3TC;
OwnPtr<WebGLDepthTexture> m_webglDepthTexture;
WebGLGetInfo getBooleanParameter(GC3Denum);
WebGLGetInfo getBooleanArrayParameter(GC3Denum);
WebGLGetInfo getFloatParameter(GC3Denum);
WebGLGetInfo getIntParameter(GC3Denum);
WebGLGetInfo getUnsignedIntParameter(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, ExceptionCode&);
void texImage2DImpl(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Denum format, GC3Denum type, Image*, GraphicsContext3D::ImageHtmlDomSource, bool flipY, bool premultiplyAlpha, ExceptionCode&);
void texSubImage2DBase(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, const void* pixels, ExceptionCode&);
void texSubImage2DImpl(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, Image*, GraphicsContext3D::ImageHtmlDomSource, bool flipY, bool premultiplyAlpha, ExceptionCode&);
void handleNPOTTextures(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 format, GC3Denum type, GC3Dint level);
bool validateTexFuncLevel(const char* functionName, GC3Denum target, GC3Dint level);
enum TexFuncValidationFunctionType {
NotTexSubImage2D,
TexSubImage2D,
};
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 format, GC3Denum type,
ArrayBufferView* pixels,
NullDisposition);
bool validateSettableTexFormat(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, 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&);
bool validateFramebufferFuncParameters(const char* functionName, GC3Denum target, GC3Denum attachment);
bool validateBlendEquation(const char* functionName, GC3Denum);
bool validateBlendFuncFactors(const char* functionName, GC3Denum src, GC3Denum dst);
bool validateCapability(const char* functionName, GC3Denum);
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*, ExceptionCode&);
bool validateHTMLCanvasElement(const char* functionName, HTMLCanvasElement*, ExceptionCode&);
#if ENABLE(VIDEO)
bool validateHTMLVideoElement(const char* functionName, HTMLVideoElement*, ExceptionCode&);
#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);
void restoreStatesAfterVertexAttrib0Simulation();
void dispatchContextLostEvent(Timer<WebGLRenderingContext>*);
void maybeRestoreContext(Timer<WebGLRenderingContext>*);
bool allowPrivilegedExtensions() const;
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();
GC3Dint getMaxDrawBuffers();
GC3Dint getMaxColorAttachments();
void setBackDrawBuffer(GC3Denum);
void restoreCurrentFramebuffer();
void restoreCurrentTexture2D();
bool supportsDrawBuffers();
friend class WebGLStateRestorer;
};
}
#endif