diff --git a/cocos/core/game.js b/cocos/core/game.js index df7594afa4..d163cbffcb 100644 --- a/cocos/core/game.js +++ b/cocos/core/game.js @@ -767,8 +767,13 @@ var game = { { // todo, adjust opts here + let gl2 = localCanvas.getContext('webgl2'); + if (!gl2) { + this._gfxDevice = new cc.WebGLGFXDevice; + } else { + this._gfxDevice = new cc.WebGL2GFXDevice; + } - this._gfxDevice = new cc.WebGLGFXDevice; this._gfxDevice.initialize({ canvasElm : localCanvas, debug: true, diff --git a/cocos/gfx/command-buffer.ts b/cocos/gfx/command-buffer.ts index 717941c52f..8da0e7380b 100644 --- a/cocos/gfx/command-buffer.ts +++ b/cocos/gfx/command-buffer.ts @@ -23,6 +23,28 @@ export interface IGFXCommandBufferInfo { type: GFXCommandBufferType; } +export interface IGFXDepthBias { + constantFactor: number; + clamp: number; + slopeFactor: number; +} + +export interface IGFXDepthBounds { + minBounds: number; + maxBounds: number; +} + +export interface IGFXStencilWriteMask { + face: GFXStencilFace; + writeMask: number; +} + +export interface IGFXStencilCompareMask { + face: GFXStencilFace; + reference: number; + compareMask: number; +} + // tslint:disable: max-line-length export abstract class GFXCommandBuffer extends GFXObject { diff --git a/cocos/gfx/index.ts b/cocos/gfx/index.ts index f113ba14e1..4d21bb08b1 100644 --- a/cocos/gfx/index.ts +++ b/cocos/gfx/index.ts @@ -13,6 +13,7 @@ import { GFXShader } from './shader'; import { GFXTexture } from './texture'; import { GFXTextureView } from './texture-view'; import { WebGLGFXDevice } from './webgl/webgl-device'; +import { WebGL2GFXDevice } from './webgl2/webgl2-device'; cc.GFXDevice = GFXDevice; cc.GFXBuffer = GFXBuffer; @@ -28,5 +29,6 @@ cc.GFXPipelineState = GFXPipelineState; cc.GFXCommandBuffer = GFXCommandBuffer; cc.GFXQueue = GFXQueue; cc.WebGLGFXDevice = WebGLGFXDevice; +cc.WebGL2GFXDevice = WebGL2GFXDevice; Object.assign(cc, GFXDefines); diff --git a/cocos/gfx/webgl/webgl-command-buffer.ts b/cocos/gfx/webgl/webgl-command-buffer.ts index 7ab192ffce..440da5a98b 100644 --- a/cocos/gfx/webgl/webgl-command-buffer.ts +++ b/cocos/gfx/webgl/webgl-command-buffer.ts @@ -36,23 +36,23 @@ import { WebGLGFXInputAssembler } from './webgl-input-assembler'; import { WebGLGFXPipelineState } from './webgl-pipeline-state'; import { WebGLGFXTexture } from './webgl-texture'; -export interface IGFXDepthBias { +export interface IWebGLDepthBias { constantFactor: number; clamp: number; slopeFactor: number; } -export interface IGFXDepthBounds { +export interface IWebGLDepthBounds { minBounds: number; maxBounds: number; } -export interface IGFXStencilWriteMask { +export interface IWebGLStencilWriteMask { face: GFXStencilFace; writeMask: number; } -export interface IGFXStencilCompareMask { +export interface IWebGLStencilCompareMask { face: GFXStencilFace; reference: number; compareMask: number; @@ -69,11 +69,11 @@ export class WebGLGFXCommandBuffer extends GFXCommandBuffer { private _curViewport: IGFXViewport | null = null; private _curScissor: IGFXRect | null = null; private _curLineWidth: number | null = null; - private _curDepthBias: IGFXDepthBias | null = null; + private _curDepthBias: IWebGLDepthBias | null = null; private _curBlendConstants: number[] = []; - private _curDepthBounds: IGFXDepthBounds | null = null; - private _curStencilWriteMask: IGFXStencilWriteMask | null = null; - private _curStencilCompareMask: IGFXStencilCompareMask | null = null; + private _curDepthBounds: IWebGLDepthBounds | null = null; + private _curStencilWriteMask: IWebGLStencilWriteMask | null = null; + private _curStencilCompareMask: IWebGLStencilCompareMask | null = null; private _isStateInvalied: boolean = false; constructor (device: GFXDevice) { diff --git a/cocos/gfx/webgl/webgl-commands.ts b/cocos/gfx/webgl/webgl-commands.ts index d65ff8c9ab..91560f4686 100644 --- a/cocos/gfx/webgl/webgl-commands.ts +++ b/cocos/gfx/webgl/webgl-commands.ts @@ -25,7 +25,12 @@ import { WebGLEXT, } from '../define'; import { WebGLGFXCommandAllocator } from './webgl-command-allocator'; -import { IGFXDepthBias, IGFXDepthBounds, IGFXStencilCompareMask, IGFXStencilWriteMask } from './webgl-command-buffer'; +import { + IWebGLDepthBias, + IWebGLDepthBounds, + IWebGLStencilCompareMask, + IWebGLStencilWriteMask, +} from './webgl-command-buffer'; import { WebGLGFXDevice } from './webgl-device'; import { IWebGLGPUUniform, WebGLAttrib, WebGLGPUBindingLayout, WebGLGPUBuffer, WebGLGPUFramebuffer, WebGLGPUInput, WebGLGPUInputAssembler, WebGLGPUPipelineState, @@ -418,11 +423,11 @@ export class WebGLCmdBindStates extends WebGLCmdObject { public viewport: IGFXViewport | null = null; public scissor: IGFXRect | null = null; public lineWidth: number | null = null; - public depthBias: IGFXDepthBias | null = null; + public depthBias: IWebGLDepthBias | null = null; public blendConstants: number[] | null = null; - public depthBounds: IGFXDepthBounds | null = null; - public stencilWriteMask: IGFXStencilWriteMask | null = null; - public stencilCompareMask: IGFXStencilCompareMask | null = null; + public depthBounds: IWebGLDepthBounds | null = null; + public stencilWriteMask: IWebGLStencilWriteMask | null = null; + public stencilCompareMask: IWebGLStencilCompareMask | null = null; constructor () { super(WebGLCmd.BIND_STATES); @@ -1901,12 +1906,12 @@ export function WebGLCmdFuncExecuteCmds (device: WebGLGFXDevice, cmdPackage: Web } } } else { - console.error("Not found texture view on binding unit " + gpuBinding.binding); + console.error('Not found texture view on binding unit ' + gpuBinding.binding); } } } // if } else { - console.error("Not found sampler or texture view on binding unit " + gpuBinding.binding); + console.error('Not found sampler or texture view on binding unit ' + gpuBinding.binding); } break; @@ -2191,7 +2196,11 @@ export function WebGLCmdFuncCopyBufferToTexture ( const buff = buffer as ArrayBuffer; const fmtInfo: IGFXFormatInfo = GFXFormatInfos[gpuTexture.format]; - let m = 0, w = 1, h = 1, f = 0, buffOffset = 0; + let m = 0; + let w = 1; + let h = 1; + let f = 0; + let buffOffset = 0; switch (gpuTexture.glTarget) { case WebGLRenderingContext.TEXTURE_2D: { @@ -2258,12 +2267,12 @@ export function WebGLCmdFuncCopyBufferToTexture ( if (!isCompressed) { for (const region of regions) { buffOffset = region.buffOffset + region.buffTexHeight * region.buffStride; - let fcount = region.texSubres.baseArrayLayer + region.texSubres.layerCount; + const fcount = region.texSubres.baseArrayLayer + region.texSubres.layerCount; for (f = region.texSubres.baseArrayLayer; f < fcount; ++f) { w = region.texExtent.width; h = region.texExtent.height; - let mcount = region.texSubres.baseMipLevel + region.texSubres.levelCount; + const mcount = region.texSubres.baseMipLevel + region.texSubres.levelCount; for (m = region.texSubres.baseMipLevel; m < mcount; ++m) { const memSize = GFXFormatSize(gpuTexture.format, w, h, 1); const data = buff.slice(buffOffset, buffOffset + memSize); @@ -2282,12 +2291,12 @@ export function WebGLCmdFuncCopyBufferToTexture ( } else { for (const region of regions) { buffOffset = region.buffOffset + region.buffTexHeight * region.buffStride; - let fcount = region.texSubres.baseArrayLayer + region.texSubres.layerCount; + const fcount = region.texSubres.baseArrayLayer + region.texSubres.layerCount; for (f = region.texSubres.baseArrayLayer; f < fcount; ++f) { w = region.texExtent.width; h = region.texExtent.height; - let mcount = region.texSubres.baseMipLevel + region.texSubres.levelCount; + const mcount = region.texSubres.baseMipLevel + region.texSubres.levelCount; for (m = region.texSubres.baseMipLevel; m < mcount; ++m) { const memSize = GFXFormatSize(gpuTexture.format, w, h, 1); const data = buff.slice(buffOffset, buffOffset + memSize); diff --git a/cocos/gfx/webgl/webgl-device.ts b/cocos/gfx/webgl/webgl-device.ts index 0319de5c7d..a4613634cd 100644 --- a/cocos/gfx/webgl/webgl-device.ts +++ b/cocos/gfx/webgl/webgl-device.ts @@ -491,7 +491,7 @@ export class WebGLGFXDevice extends GFXDevice { dstBuffer: ArrayBuffer, regions: GFXBufferTextureCopy[]) { - const gl = this._webGLRC as WebGLRenderingContext; + const gl = this._webGLRC!; const gpuFramebuffer = (srcFramebuffer as WebGLGFXFramebuffer).gpuFramebuffer; const curFBO = this.stateCache.glFramebuffer; diff --git a/cocos/gfx/webgl/webgl-render-pass.ts b/cocos/gfx/webgl/webgl-render-pass.ts index 73c214fd3f..4e49c25a0f 100644 --- a/cocos/gfx/webgl/webgl-render-pass.ts +++ b/cocos/gfx/webgl/webgl-render-pass.ts @@ -6,10 +6,6 @@ import { WebGLGPURenderPass } from './webgl-gpu-objects'; export class WebGLGFXRenderPass extends GFXRenderPass { - public get webGLDevice (): WebGLGFXDevice { - return this._device as WebGLGFXDevice; - } - public get gpuRenderPass (): WebGLGPURenderPass { return this._gpuRenderPass!; } diff --git a/cocos/gfx/webgl/webgl-sampler.ts b/cocos/gfx/webgl/webgl-sampler.ts index 6a2e3a0293..2701965a76 100644 --- a/cocos/gfx/webgl/webgl-sampler.ts +++ b/cocos/gfx/webgl/webgl-sampler.ts @@ -1,7 +1,6 @@ import { GFXFilter, GFXStatus } from '../define'; import { GFXDevice } from '../device'; import { GFXSampler, GFXSamplerState, IGFXSamplerInfo } from '../sampler'; -import { WebGLGFXDevice } from './webgl-device'; import { WebGLGPUSampler } from './webgl-gpu-objects'; const WebGLWraps: GLenum[] = [ @@ -13,10 +12,6 @@ const WebGLWraps: GLenum[] = [ export class WebGLGFXSampler extends GFXSampler { - public get webGLDevice (): WebGLGFXDevice { - return this._device as WebGLGFXDevice; - } - public get gpuSampler (): WebGLGPUSampler { return this._gpuSampler!; } diff --git a/cocos/gfx/webgl/webgl-texture-view.ts b/cocos/gfx/webgl/webgl-texture-view.ts index 2ca0752e41..e148b95d80 100644 --- a/cocos/gfx/webgl/webgl-texture-view.ts +++ b/cocos/gfx/webgl/webgl-texture-view.ts @@ -7,10 +7,6 @@ import { WebGLGFXTexture } from './webgl-texture'; export class WebGLGFXTextureView extends GFXTextureView { - public get webGLDevice (): WebGLGFXDevice { - return this._device as WebGLGFXDevice; - } - public get gpuTextureView (): WebGLGPUTextureView { return this._gpuTextureView as WebGLGPUTextureView; } diff --git a/cocos/gfx/webgl/webgl-texture.ts b/cocos/gfx/webgl/webgl-texture.ts index b84c27a546..b459088bb5 100644 --- a/cocos/gfx/webgl/webgl-texture.ts +++ b/cocos/gfx/webgl/webgl-texture.ts @@ -7,10 +7,6 @@ import { WebGLGPUTexture } from './webgl-gpu-objects'; export class WebGLGFXTexture extends GFXTexture { - public get webGLDevice (): WebGLGFXDevice { - return this._device as WebGLGFXDevice; - } - public get gpuTexture (): WebGLGPUTexture { return this._gpuTexture!; } diff --git a/cocos/gfx/webgl/webgl-window.ts b/cocos/gfx/webgl/webgl-window.ts index 4fa627b833..573b59c35e 100644 --- a/cocos/gfx/webgl/webgl-window.ts +++ b/cocos/gfx/webgl/webgl-window.ts @@ -1,7 +1,6 @@ import { GFXLoadOp, GFXStatus, GFXStoreOp, GFXTextureLayout } from '../define'; import { GFXDevice } from '../device'; import { GFXWindow, IGFXWindowInfo } from '../window'; -import { WebGLGFXDevice } from './webgl-device'; export class WebGLGFXWindow extends GFXWindow { @@ -176,9 +175,4 @@ export class WebGLGFXWindow extends GFXWindow { this._width = width; this._height = height; } - - public get webGLDevice (): WebGLGFXDevice { - return this._device as WebGLGFXDevice; - } - } diff --git a/cocos/gfx/webgl2/WebGL2.d.ts b/cocos/gfx/webgl2/WebGL2.d.ts new file mode 100644 index 0000000000..1af7a63b35 --- /dev/null +++ b/cocos/gfx/webgl2/WebGL2.d.ts @@ -0,0 +1,1541 @@ +declare type GLint64 = number; +declare type GLuint64 = GLint64; + +interface EXT_color_buffer_float { +} + +interface EXT_disjoint_timer_query_webgl2 { + readonly QUERY_COUNTER_BITS_EXT: GLenum; + readonly TIME_ELAPSED_EXT: GLenum; + readonly TIMESTAMP_EXT: GLenum; + readonly GPU_DISJOINT_EXT: GLenum; + + queryCounterEXT(query: WebGLQuery, target: GLenum); +} + +interface WebGLQuery extends WebGLObject { +} + +declare var WebGLQuery: { + prototype: WebGLQuery; + new(): WebGLQuery; +} + +interface WebGLSampler extends WebGLObject { +} + +declare var WebGLSampler: { + prototype: WebGLSampler; + new(): WebGLSampler; +} + +interface WebGLSync extends WebGLObject { +} + +declare var WebGLSync: { + prototype: WebGLSync; + new(): WebGLSync; +} + +interface WebGLTransformFeedback extends WebGLObject { +} + +declare var WebGLTransformFeedback: { + prototype: WebGLTransformFeedback; + new(): WebGLTransformFeedback; +} + +interface WebGLVertexArrayObject extends WebGLObject { +} + +declare var WebGLVertexArrayObject: { + prototype: WebGLVertexArrayObject; + new(): WebGLVertexArrayObject; +} + +interface WebGLTimerQueryEXT extends WebGLQuery { +} + +declare var WebGLTimerQueryEXT: { + prototype: WebGLTimerQueryEXT; + new(): WebGLTimerQueryEXT; +} + +interface EXT_disjoint_timer_query { + createQueryEXT(): WebGLTimerQueryEXT | null; + deleteQueryEXT(query: WebGLTimerQueryEXT | null): void; + isQueryEXT(query: WebGLTimerQueryEXT | null): boolean; + beginQueryEXT(target: number, query: WebGLTimerQueryEXT | null): void; + endQueryEXT(target: number): void; + queryCounterEXT(query: WebGLTimerQueryEXT | null, target: number): number; + getQueryEXT(target: number, pname: number): WebGLTimerQueryEXT | number | null; + getQueryObjectEXT(query: WebGLTimerQueryEXT | null, pname: number): number | boolean; + + readonly QUERY_COUNTER_BITS_EXT: number; + readonly CURRENT_QUERY_EXT: number; + readonly QUERY_RESULT_EXT: number; + readonly QUERY_RESULT_AVAILABLE_EXT: number; + readonly TIME_ELAPSED_EXT: number; + readonly TIMESTAMP_EXT: number; + readonly GPU_DISJOINT_EXT: number; +} + +declare var EXT_disjoint_timer_query: { + prototype: EXT_disjoint_timer_query; + new(): EXT_disjoint_timer_query; + + readonly QUERY_COUNTER_BITS_EXT: number; + readonly CURRENT_QUERY_EXT: number; + readonly QUERY_RESULT_EXT: number; + readonly QUERY_RESULT_AVAILABLE_EXT: number; + readonly TIME_ELAPSED_EXT: number; + readonly TIMESTAMP_EXT: number; + readonly GPU_DISJOINT_EXT: number; +} + +interface HTMLCanvasElement { + getContext(contextId: "webgl2" | "experimental-webgl2", contextAttributes?: WebGLContextAttributes): WebGL2RenderingContext | null; +} + +interface WebGL2RenderingContext extends WebGL2RenderingContextBase { +} + +declare var WebGL2RenderingContext: { + prototype: WebGLRenderingContext; + new(): WebGLRenderingContext; + readonly ACTIVE_ATTRIBUTES: GLenum; + readonly ACTIVE_TEXTURE: GLenum; + readonly ACTIVE_UNIFORMS: GLenum; + readonly ALIASED_LINE_WIDTH_RANGE: GLenum; + readonly ALIASED_POINT_SIZE_RANGE: GLenum; + readonly ALPHA: GLenum; + readonly ALPHA_BITS: GLenum; + readonly ALWAYS: GLenum; + readonly ARRAY_BUFFER: GLenum; + readonly ARRAY_BUFFER_BINDING: GLenum; + readonly ATTACHED_SHADERS: GLenum; + readonly BACK: GLenum; + readonly BLEND: GLenum; + readonly BLEND_COLOR: GLenum; + readonly BLEND_DST_ALPHA: GLenum; + readonly BLEND_DST_RGB: GLenum; + readonly BLEND_EQUATION: GLenum; + readonly BLEND_EQUATION_ALPHA: GLenum; + readonly BLEND_EQUATION_RGB: GLenum; + readonly BLEND_SRC_ALPHA: GLenum; + readonly BLEND_SRC_RGB: GLenum; + readonly BLUE_BITS: GLenum; + readonly BOOL: GLenum; + readonly BOOL_VEC2: GLenum; + readonly BOOL_VEC3: GLenum; + readonly BOOL_VEC4: GLenum; + readonly BROWSER_DEFAULT_WEBGL: GLenum; + readonly BUFFER_SIZE: GLenum; + readonly BUFFER_USAGE: GLenum; + readonly BYTE: GLenum; + readonly CCW: GLenum; + readonly CLAMP_TO_EDGE: GLenum; + readonly COLOR_ATTACHMENT0: GLenum; + readonly COLOR_BUFFER_BIT: GLenum; + readonly COLOR_CLEAR_VALUE: GLenum; + readonly COLOR_WRITEMASK: GLenum; + readonly COMPILE_STATUS: GLenum; + readonly COMPRESSED_TEXTURE_FORMATS: GLenum; + readonly CONSTANT_ALPHA: GLenum; + readonly CONSTANT_COLOR: GLenum; + readonly CONTEXT_LOST_WEBGL: GLenum; + readonly CULL_FACE: GLenum; + readonly CULL_FACE_MODE: GLenum; + readonly CURRENT_PROGRAM: GLenum; + readonly CURRENT_VERTEX_ATTRIB: GLenum; + readonly CW: GLenum; + readonly DECR: GLenum; + readonly DECR_WRAP: GLenum; + readonly DELETE_STATUS: GLenum; + readonly DEPTH_ATTACHMENT: GLenum; + readonly DEPTH_BITS: GLenum; + readonly DEPTH_BUFFER_BIT: GLenum; + readonly DEPTH_CLEAR_VALUE: GLenum; + readonly DEPTH_COMPONENT: GLenum; + readonly DEPTH_COMPONENT16: GLenum; + readonly DEPTH_FUNC: GLenum; + readonly DEPTH_RANGE: GLenum; + readonly DEPTH_STENCIL: GLenum; + readonly DEPTH_STENCIL_ATTACHMENT: GLenum; + readonly DEPTH_TEST: GLenum; + readonly DEPTH_WRITEMASK: GLenum; + readonly DITHER: GLenum; + readonly DONT_CARE: GLenum; + readonly DST_ALPHA: GLenum; + readonly DST_COLOR: GLenum; + readonly DYNAMIC_DRAW: GLenum; + readonly ELEMENT_ARRAY_BUFFER: GLenum; + readonly ELEMENT_ARRAY_BUFFER_BINDING: GLenum; + readonly EQUAL: GLenum; + readonly FASTEST: GLenum; + readonly FLOAT: GLenum; + readonly FLOAT_MAT2: GLenum; + readonly FLOAT_MAT3: GLenum; + readonly FLOAT_MAT4: GLenum; + readonly FLOAT_VEC2: GLenum; + readonly FLOAT_VEC3: GLenum; + readonly FLOAT_VEC4: GLenum; + readonly FRAGMENT_SHADER: GLenum; + readonly FRAMEBUFFER: GLenum; + readonly FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: GLenum; + readonly FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: GLenum; + readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: GLenum; + readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: GLenum; + readonly FRAMEBUFFER_BINDING: GLenum; + readonly FRAMEBUFFER_COMPLETE: GLenum; + readonly FRAMEBUFFER_INCOMPLETE_ATTACHMENT: GLenum; + readonly FRAMEBUFFER_INCOMPLETE_DIMENSIONS: GLenum; + readonly FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: GLenum; + readonly FRAMEBUFFER_UNSUPPORTED: GLenum; + readonly FRONT: GLenum; + readonly FRONT_AND_BACK: GLenum; + readonly FRONT_FACE: GLenum; + readonly FUNC_ADD: GLenum; + readonly FUNC_REVERSE_SUBTRACT: GLenum; + readonly FUNC_SUBTRACT: GLenum; + readonly GENERATE_MIPMAP_HINT: GLenum; + readonly GEQUAL: GLenum; + readonly GREATER: GLenum; + readonly GREEN_BITS: GLenum; + readonly HIGH_FLOAT: GLenum; + readonly HIGH_INT: GLenum; + readonly IMPLEMENTATION_COLOR_READ_FORMAT: GLenum; + readonly IMPLEMENTATION_COLOR_READ_TYPE: GLenum; + readonly INCR: GLenum; + readonly INCR_WRAP: GLenum; + readonly INT: GLenum; + readonly INT_VEC2: GLenum; + readonly INT_VEC3: GLenum; + readonly INT_VEC4: GLenum; + readonly INVALID_ENUM: GLenum; + readonly INVALID_FRAMEBUFFER_OPERATION: GLenum; + readonly INVALID_OPERATION: GLenum; + readonly INVALID_VALUE: GLenum; + readonly INVERT: GLenum; + readonly KEEP: GLenum; + readonly LEQUAL: GLenum; + readonly LESS: GLenum; + readonly LINEAR: GLenum; + readonly LINEAR_MIPMAP_LINEAR: GLenum; + readonly LINEAR_MIPMAP_NEAREST: GLenum; + readonly LINES: GLenum; + readonly LINE_LOOP: GLenum; + readonly LINE_STRIP: GLenum; + readonly LINE_WIDTH: GLenum; + readonly LINK_STATUS: GLenum; + readonly LOW_FLOAT: GLenum; + readonly LOW_INT: GLenum; + readonly LUMINANCE: GLenum; + readonly LUMINANCE_ALPHA: GLenum; + readonly MAX_COMBINED_TEXTURE_IMAGE_UNITS: GLenum; + readonly MAX_CUBE_MAP_TEXTURE_SIZE: GLenum; + readonly MAX_FRAGMENT_UNIFORM_VECTORS: GLenum; + readonly MAX_RENDERBUFFER_SIZE: GLenum; + readonly MAX_TEXTURE_IMAGE_UNITS: GLenum; + readonly MAX_TEXTURE_SIZE: GLenum; + readonly MAX_VARYING_VECTORS: GLenum; + readonly MAX_VERTEX_ATTRIBS: GLenum; + readonly MAX_VERTEX_TEXTURE_IMAGE_UNITS: GLenum; + readonly MAX_VERTEX_UNIFORM_VECTORS: GLenum; + readonly MAX_VIEWPORT_DIMS: GLenum; + readonly MEDIUM_FLOAT: GLenum; + readonly MEDIUM_INT: GLenum; + readonly MIRRORED_REPEAT: GLenum; + readonly NEAREST: GLenum; + readonly NEAREST_MIPMAP_LINEAR: GLenum; + readonly NEAREST_MIPMAP_NEAREST: GLenum; + readonly NEVER: GLenum; + readonly NICEST: GLenum; + readonly NONE: GLenum; + readonly NOTEQUAL: GLenum; + readonly NO_ERROR: GLenum; + readonly ONE: GLenum; + readonly ONE_MINUS_CONSTANT_ALPHA: GLenum; + readonly ONE_MINUS_CONSTANT_COLOR: GLenum; + readonly ONE_MINUS_DST_ALPHA: GLenum; + readonly ONE_MINUS_DST_COLOR: GLenum; + readonly ONE_MINUS_SRC_ALPHA: GLenum; + readonly ONE_MINUS_SRC_COLOR: GLenum; + readonly OUT_OF_MEMORY: GLenum; + readonly PACK_ALIGNMENT: GLenum; + readonly POINTS: GLenum; + readonly POLYGON_OFFSET_FACTOR: GLenum; + readonly POLYGON_OFFSET_FILL: GLenum; + readonly POLYGON_OFFSET_UNITS: GLenum; + readonly RED_BITS: GLenum; + readonly RENDERBUFFER: GLenum; + readonly RENDERBUFFER_ALPHA_SIZE: GLenum; + readonly RENDERBUFFER_BINDING: GLenum; + readonly RENDERBUFFER_BLUE_SIZE: GLenum; + readonly RENDERBUFFER_DEPTH_SIZE: GLenum; + readonly RENDERBUFFER_GREEN_SIZE: GLenum; + readonly RENDERBUFFER_HEIGHT: GLenum; + readonly RENDERBUFFER_INTERNAL_FORMAT: GLenum; + readonly RENDERBUFFER_RED_SIZE: GLenum; + readonly RENDERBUFFER_STENCIL_SIZE: GLenum; + readonly RENDERBUFFER_WIDTH: GLenum; + readonly RENDERER: GLenum; + readonly REPEAT: GLenum; + readonly REPLACE: GLenum; + readonly RGB: GLenum; + readonly RGB565: GLenum; + readonly RGB5_A1: GLenum; + readonly RGBA: GLenum; + readonly RGBA4: GLenum; + readonly SAMPLER_2D: GLenum; + readonly SAMPLER_CUBE: GLenum; + readonly SAMPLES: GLenum; + readonly SAMPLE_ALPHA_TO_COVERAGE: GLenum; + readonly SAMPLE_BUFFERS: GLenum; + readonly SAMPLE_COVERAGE: GLenum; + readonly SAMPLE_COVERAGE_INVERT: GLenum; + readonly SAMPLE_COVERAGE_VALUE: GLenum; + readonly SCISSOR_BOX: GLenum; + readonly SCISSOR_TEST: GLenum; + readonly SHADER_TYPE: GLenum; + readonly SHADING_LANGUAGE_VERSION: GLenum; + readonly SHORT: GLenum; + readonly SRC_ALPHA: GLenum; + readonly SRC_ALPHA_SATURATE: GLenum; + readonly SRC_COLOR: GLenum; + readonly STATIC_DRAW: GLenum; + readonly STENCIL_ATTACHMENT: GLenum; + readonly STENCIL_BACK_FAIL: GLenum; + readonly STENCIL_BACK_FUNC: GLenum; + readonly STENCIL_BACK_PASS_DEPTH_FAIL: GLenum; + readonly STENCIL_BACK_PASS_DEPTH_PASS: GLenum; + readonly STENCIL_BACK_REF: GLenum; + readonly STENCIL_BACK_VALUE_MASK: GLenum; + readonly STENCIL_BACK_WRITEMASK: GLenum; + readonly STENCIL_BITS: GLenum; + readonly STENCIL_BUFFER_BIT: GLenum; + readonly STENCIL_CLEAR_VALUE: GLenum; + readonly STENCIL_FAIL: GLenum; + readonly STENCIL_FUNC: GLenum; + readonly STENCIL_INDEX8: GLenum; + readonly STENCIL_PASS_DEPTH_FAIL: GLenum; + readonly STENCIL_PASS_DEPTH_PASS: GLenum; + readonly STENCIL_REF: GLenum; + readonly STENCIL_TEST: GLenum; + readonly STENCIL_VALUE_MASK: GLenum; + readonly STENCIL_WRITEMASK: GLenum; + readonly STREAM_DRAW: GLenum; + readonly SUBPIXEL_BITS: GLenum; + readonly TEXTURE: GLenum; + readonly TEXTURE0: GLenum; + readonly TEXTURE1: GLenum; + readonly TEXTURE10: GLenum; + readonly TEXTURE11: GLenum; + readonly TEXTURE12: GLenum; + readonly TEXTURE13: GLenum; + readonly TEXTURE14: GLenum; + readonly TEXTURE15: GLenum; + readonly TEXTURE16: GLenum; + readonly TEXTURE17: GLenum; + readonly TEXTURE18: GLenum; + readonly TEXTURE19: GLenum; + readonly TEXTURE2: GLenum; + readonly TEXTURE20: GLenum; + readonly TEXTURE21: GLenum; + readonly TEXTURE22: GLenum; + readonly TEXTURE23: GLenum; + readonly TEXTURE24: GLenum; + readonly TEXTURE25: GLenum; + readonly TEXTURE26: GLenum; + readonly TEXTURE27: GLenum; + readonly TEXTURE28: GLenum; + readonly TEXTURE29: GLenum; + readonly TEXTURE3: GLenum; + readonly TEXTURE30: GLenum; + readonly TEXTURE31: GLenum; + readonly TEXTURE4: GLenum; + readonly TEXTURE5: GLenum; + readonly TEXTURE6: GLenum; + readonly TEXTURE7: GLenum; + readonly TEXTURE8: GLenum; + readonly TEXTURE9: GLenum; + readonly TEXTURE_2D: GLenum; + readonly TEXTURE_BINDING_2D: GLenum; + readonly TEXTURE_BINDING_CUBE_MAP: GLenum; + readonly TEXTURE_CUBE_MAP: GLenum; + readonly TEXTURE_CUBE_MAP_NEGATIVE_X: GLenum; + readonly TEXTURE_CUBE_MAP_NEGATIVE_Y: GLenum; + readonly TEXTURE_CUBE_MAP_NEGATIVE_Z: GLenum; + readonly TEXTURE_CUBE_MAP_POSITIVE_X: GLenum; + readonly TEXTURE_CUBE_MAP_POSITIVE_Y: GLenum; + readonly TEXTURE_CUBE_MAP_POSITIVE_Z: GLenum; + readonly TEXTURE_MAG_FILTER: GLenum; + readonly TEXTURE_MIN_FILTER: GLenum; + readonly TEXTURE_WRAP_S: GLenum; + readonly TEXTURE_WRAP_T: GLenum; + readonly TRIANGLES: GLenum; + readonly TRIANGLE_FAN: GLenum; + readonly TRIANGLE_STRIP: GLenum; + readonly UNPACK_ALIGNMENT: GLenum; + readonly UNPACK_COLORSPACE_CONVERSION_WEBGL: GLenum; + readonly UNPACK_FLIP_Y_WEBGL: GLenum; + readonly UNPACK_PREMULTIPLY_ALPHA_WEBGL: GLenum; + readonly UNSIGNED_BYTE: GLenum; + readonly UNSIGNED_INT: GLenum; + readonly UNSIGNED_SHORT: GLenum; + readonly UNSIGNED_SHORT_4_4_4_4: GLenum; + readonly UNSIGNED_SHORT_5_5_5_1: GLenum; + readonly UNSIGNED_SHORT_5_6_5: GLenum; + readonly VALIDATE_STATUS: GLenum; + readonly VENDOR: GLenum; + readonly VERSION: GLenum; + readonly VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: GLenum; + readonly VERTEX_ATTRIB_ARRAY_ENABLED: GLenum; + readonly VERTEX_ATTRIB_ARRAY_NORMALIZED: GLenum; + readonly VERTEX_ATTRIB_ARRAY_POINTER: GLenum; + readonly VERTEX_ATTRIB_ARRAY_SIZE: GLenum; + readonly VERTEX_ATTRIB_ARRAY_STRIDE: GLenum; + readonly VERTEX_ATTRIB_ARRAY_TYPE: GLenum; + readonly VERTEX_SHADER: GLenum; + readonly VIEWPORT: GLenum; + readonly ZERO: GLenum; + + readonly READ_BUFFER: GLenum; + readonly UNPACK_ROW_LENGTH: GLenum; + readonly UNPACK_SKIP_ROWS: GLenum; + readonly UNPACK_SKIP_PIXELS: GLenum; + readonly PACK_ROW_LENGTH: GLenum; + readonly PACK_SKIP_ROWS: GLenum; + readonly PACK_SKIP_PIXELS: GLenum; + readonly COLOR: GLenum; + readonly DEPTH: GLenum; + readonly STENCIL: GLenum; + readonly RED: GLenum; + readonly RGB8: GLenum; + readonly RGBA8: GLenum; + readonly RGB10_A2: GLenum; + readonly TEXTURE_BINDING_3D: GLenum; + readonly UNPACK_SKIP_IMAGES: GLenum; + readonly UNPACK_IMAGE_HEIGHT: GLenum; + readonly TEXTURE_3D: GLenum; + readonly TEXTURE_WRAP_R: GLenum; + readonly MAX_3D_TEXTURE_SIZE: GLenum; + readonly UNSIGNED_INT_2_10_10_10_REV: GLenum; + readonly MAX_ELEMENTS_VERTICES: GLenum; + readonly MAX_ELEMENTS_INDICES: GLenum; + readonly TEXTURE_MIN_LOD: GLenum; + readonly TEXTURE_MAX_LOD: GLenum; + readonly TEXTURE_BASE_LEVEL: GLenum; + readonly TEXTURE_MAX_LEVEL: GLenum; + readonly MIN: GLenum; + readonly MAX: GLenum; + readonly DEPTH_COMPONENT24: GLenum; + readonly MAX_TEXTURE_LOD_BIAS: GLenum; + readonly TEXTURE_COMPARE_MODE: GLenum; + readonly TEXTURE_COMPARE_FUNC: GLenum; + readonly CURRENT_QUERY: GLenum; + readonly QUERY_RESULT: GLenum; + readonly QUERY_RESULT_AVAILABLE: GLenum; + readonly STREAM_READ: GLenum; + readonly STREAM_COPY: GLenum; + readonly STATIC_READ: GLenum; + readonly STATIC_COPY: GLenum; + readonly DYNAMIC_READ: GLenum; + readonly DYNAMIC_COPY: GLenum; + readonly MAX_DRAW_BUFFERS: GLenum; + readonly DRAW_BUFFER0: GLenum; + readonly DRAW_BUFFER1: GLenum; + readonly DRAW_BUFFER2: GLenum; + readonly DRAW_BUFFER3: GLenum; + readonly DRAW_BUFFER4: GLenum; + readonly DRAW_BUFFER5: GLenum; + readonly DRAW_BUFFER6: GLenum; + readonly DRAW_BUFFER7: GLenum; + readonly DRAW_BUFFER8: GLenum; + readonly DRAW_BUFFER9: GLenum; + readonly DRAW_BUFFER10: GLenum; + readonly DRAW_BUFFER11: GLenum; + readonly DRAW_BUFFER12: GLenum; + readonly DRAW_BUFFER13: GLenum; + readonly DRAW_BUFFER14: GLenum; + readonly DRAW_BUFFER15: GLenum; + readonly MAX_FRAGMENT_UNIFORM_COMPONENTS: GLenum; + readonly MAX_VERTEX_UNIFORM_COMPONENTS: GLenum; + readonly SAMPLER_3D: GLenum; + readonly SAMPLER_2D_SHADOW: GLenum; + readonly FRAGMENT_SHADER_DERIVATIVE_HINT: GLenum; + readonly PIXEL_PACK_BUFFER: GLenum; + readonly PIXEL_UNPACK_BUFFER: GLenum; + readonly PIXEL_PACK_BUFFER_BINDING: GLenum; + readonly PIXEL_UNPACK_BUFFER_BINDING: GLenum; + readonly FLOAT_MAT2x3: GLenum; + readonly FLOAT_MAT2x4: GLenum; + readonly FLOAT_MAT3x2: GLenum; + readonly FLOAT_MAT3x4: GLenum; + readonly FLOAT_MAT4x2: GLenum; + readonly FLOAT_MAT4x3: GLenum; + readonly SRGB: GLenum; + readonly SRGB8: GLenum; + readonly SRGB8_ALPHA8: GLenum; + readonly COMPARE_REF_TO_TEXTURE: GLenum; + readonly RGBA32F: GLenum; + readonly RGB32F: GLenum; + readonly RGBA16F: GLenum; + readonly RGB16F: GLenum; + readonly VERTEX_ATTRIB_ARRAY_INTEGER: GLenum; + readonly MAX_ARRAY_TEXTURE_LAYERS: GLenum; + readonly MIN_PROGRAM_TEXEL_OFFSET: GLenum; + readonly MAX_PROGRAM_TEXEL_OFFSET: GLenum; + readonly MAX_VARYING_COMPONENTS: GLenum; + readonly TEXTURE_2D_ARRAY: GLenum; + readonly TEXTURE_BINDING_2D_ARRAY: GLenum; + readonly R11F_G11F_B10F: GLenum; + readonly UNSIGNED_INT_10F_11F_11F_REV: GLenum; + readonly RGB9_E5: GLenum; + readonly UNSIGNED_INT_5_9_9_9_REV: GLenum; + readonly TRANSFORM_FEEDBACK_BUFFER_MODE: GLenum; + readonly MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS: GLenum; + readonly TRANSFORM_FEEDBACK_VARYINGS: GLenum; + readonly TRANSFORM_FEEDBACK_BUFFER_START: GLenum; + readonly TRANSFORM_FEEDBACK_BUFFER_SIZE: GLenum; + readonly TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN: GLenum; + readonly RASTERIZER_DISCARD: GLenum; + readonly MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS: GLenum; + readonly MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS: GLenum; + readonly INTERLEAVED_ATTRIBS: GLenum; + readonly SEPARATE_ATTRIBS: GLenum; + readonly TRANSFORM_FEEDBACK_BUFFER: GLenum; + readonly TRANSFORM_FEEDBACK_BUFFER_BINDING: GLenum; + readonly RGBA32UI: GLenum; + readonly RGB32UI: GLenum; + readonly RGBA16UI: GLenum; + readonly RGB16UI: GLenum; + readonly RGBA8UI: GLenum; + readonly RGB8UI: GLenum; + readonly RGBA32I: GLenum; + readonly RGB32I: GLenum; + readonly RGBA16I: GLenum; + readonly RGB16I: GLenum; + readonly RGBA8I: GLenum; + readonly RGB8I: GLenum; + readonly RED_INTEGER: GLenum; + readonly RGB_INTEGER: GLenum; + readonly RGBA_INTEGER: GLenum; + readonly SAMPLER_2D_ARRAY: GLenum; + readonly SAMPLER_2D_ARRAY_SHADOW: GLenum; + readonly SAMPLER_CUBE_SHADOW: GLenum; + readonly UNSIGNED_INT_VEC2: GLenum; + readonly UNSIGNED_INT_VEC3: GLenum; + readonly UNSIGNED_INT_VEC4: GLenum; + readonly INT_SAMPLER_2D: GLenum; + readonly INT_SAMPLER_3D: GLenum; + readonly INT_SAMPLER_CUBE: GLenum; + readonly INT_SAMPLER_2D_ARRAY: GLenum; + readonly UNSIGNED_INT_SAMPLER_2D: GLenum; + readonly UNSIGNED_INT_SAMPLER_3D: GLenum; + readonly UNSIGNED_INT_SAMPLER_CUBE: GLenum; + readonly UNSIGNED_INT_SAMPLER_2D_ARRAY: GLenum; + readonly DEPTH_COMPONENT32F: GLenum; + readonly DEPTH32F_STENCIL8: GLenum; + readonly FLOAT_32_UNSIGNED_INT_24_8_REV: GLenum; + readonly FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING: GLenum; + readonly FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE: GLenum; + readonly FRAMEBUFFER_ATTACHMENT_RED_SIZE: GLenum; + readonly FRAMEBUFFER_ATTACHMENT_GREEN_SIZE: GLenum; + readonly FRAMEBUFFER_ATTACHMENT_BLUE_SIZE: GLenum; + readonly FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE: GLenum; + readonly FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE: GLenum; + readonly FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE: GLenum; + readonly FRAMEBUFFER_DEFAULT: GLenum; + readonly UNSIGNED_INT_24_8: GLenum; + readonly DEPTH24_STENCIL8: GLenum; + readonly UNSIGNED_NORMALIZED: GLenum; + readonly DRAW_FRAMEBUFFER_BINDING: GLenum; + readonly READ_FRAMEBUFFER: GLenum; + readonly DRAW_FRAMEBUFFER: GLenum; + readonly READ_FRAMEBUFFER_BINDING: GLenum; + + readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER: GLenum; + readonly MAX_COLOR_ATTACHMENTS: GLenum; + readonly COLOR_ATTACHMENT1: GLenum; + readonly COLOR_ATTACHMENT2: GLenum; + readonly COLOR_ATTACHMENT3: GLenum; + readonly COLOR_ATTACHMENT4: GLenum; + readonly COLOR_ATTACHMENT5: GLenum; + readonly COLOR_ATTACHMENT6: GLenum; + readonly COLOR_ATTACHMENT7: GLenum; + readonly COLOR_ATTACHMENT8: GLenum; + readonly COLOR_ATTACHMENT9: GLenum; + readonly COLOR_ATTACHMENT10: GLenum; + readonly COLOR_ATTACHMENT11: GLenum; + readonly COLOR_ATTACHMENT12: GLenum; + readonly COLOR_ATTACHMENT13: GLenum; + readonly COLOR_ATTACHMENT14: GLenum; + readonly COLOR_ATTACHMENT15: GLenum; + readonly FRAMEBUFFER_INCOMPLETE_MULTISAMPLE: GLenum; + readonly MAX_SAMPLES: GLenum; + readonly HALF_FLOAT: GLenum; + readonly RG: GLenum; + readonly RG_INTEGER: GLenum; + readonly R8: GLenum; + readonly RG8: GLenum; + readonly R16F: GLenum; + + readonly R32F: GLenum; + readonly RG16F: GLenum; + readonly RG32F: GLenum; + readonly R8I: GLenum; + readonly R8UI: GLenum; + readonly R16I: GLenum; + readonly R16UI: GLenum; + readonly R32I: GLenum; + readonly R32UI: GLenum; + readonly RG8I: GLenum; + readonly RG8UI: GLenum; + readonly RG16I: GLenum; + readonly RG16UI: GLenum; + readonly RG32I: GLenum; + readonly RG32UI: GLenum; + readonly VERTEX_ARRAY_BINDING: GLenum; + readonly R8_SNORM: GLenum; + readonly RG8_SNORM: GLenum; + readonly RGB8_SNORM: GLenum; + readonly RGBA8_SNORM: GLenum; + readonly SIGNED_NORMALIZED: GLenum; + readonly COPY_READ_BUFFER: GLenum; + readonly COPY_WRITE_BUFFER: GLenum; + readonly COPY_READ_BUFFER_BINDING: GLenum; /* Same as COPY_READ_BUFFER */ + readonly COPY_WRITE_BUFFER_BINDING: GLenum; /* Same as COPY_WRITE_BUFFER */ + readonly UNIFORM_BUFFER: GLenum; + readonly UNIFORM_BUFFER_BINDING: GLenum; + readonly UNIFORM_BUFFER_START: GLenum; + readonly UNIFORM_BUFFER_SIZE: GLenum; + readonly MAX_VERTEX_UNIFORM_BLOCKS: GLenum; + readonly MAX_FRAGMENT_UNIFORM_BLOCKS: GLenum; + readonly MAX_COMBINED_UNIFORM_BLOCKS: GLenum; + readonly MAX_UNIFORM_BUFFER_BINDINGS: GLenum; + readonly MAX_UNIFORM_BLOCK_SIZE: GLenum; + readonly MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS: GLenum; + readonly MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS: GLenum; + readonly UNIFORM_BUFFER_OFFSET_ALIGNMENT: GLenum; + readonly ACTIVE_UNIFORM_BLOCKS: GLenum; + readonly UNIFORM_TYPE: GLenum; + readonly UNIFORM_SIZE: GLenum; + readonly UNIFORM_BLOCK_INDEX: GLenum; + readonly UNIFORM_OFFSET: GLenum; + readonly UNIFORM_ARRAY_STRIDE: GLenum; + readonly UNIFORM_MATRIX_STRIDE: GLenum; + readonly UNIFORM_IS_ROW_MAJOR: GLenum; + readonly UNIFORM_BLOCK_BINDING: GLenum; + readonly UNIFORM_BLOCK_DATA_SIZE: GLenum; + readonly UNIFORM_BLOCK_ACTIVE_UNIFORMS: GLenum; + readonly UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES: GLenum; + readonly UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER: GLenum; + readonly UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER: GLenum; + readonly INVALID_INDEX: GLenum; + readonly MAX_VERTEX_OUTPUT_COMPONENTS: GLenum; + readonly MAX_FRAGMENT_INPUT_COMPONENTS: GLenum; + readonly MAX_SERVER_WAIT_TIMEOUT: GLenum; + readonly OBJECT_TYPE: GLenum; + readonly SYNC_CONDITION: GLenum; + readonly SYNC_STATUS: GLenum; + readonly SYNC_FLAGS: GLenum; + readonly SYNC_FENCE: GLenum; + readonly SYNC_GPU_COMMANDS_COMPLETE: GLenum; + readonly UNSIGNALED: GLenum; + readonly SIGNALED: GLenum; + readonly ALREADY_SIGNALED: GLenum; + readonly TIMEOUT_EXPIRED: GLenum; + readonly CONDITION_SATISFIED: GLenum; + readonly WAIT_FAILED: GLenum; + readonly SYNC_FLUSH_COMMANDS_BIT: GLenum; + readonly VERTEX_ATTRIB_ARRAY_DIVISOR: GLenum; + readonly ANY_SAMPLES_PASSED: GLenum; + readonly ANY_SAMPLES_PASSED_CONSERVATIVE: GLenum; + readonly SAMPLER_BINDING: GLenum; + readonly RGB10_A2UI: GLenum; + readonly INT_2_10_10_10_REV: GLenum; + readonly TRANSFORM_FEEDBACK: GLenum; + readonly TRANSFORM_FEEDBACK_PAUSED: GLenum; + readonly TRANSFORM_FEEDBACK_ACTIVE: GLenum; + readonly TRANSFORM_FEEDBACK_BINDING: GLenum; + readonly TEXTURE_IMMUTABLE_FORMAT: GLenum; + readonly MAX_ELEMENT_INDEX: GLenum; + readonly TEXTURE_IMMUTABLE_LEVELS: GLenum; + + readonly TIMEOUT_IGNORED: GLint64; + + /* WebGL-specific enums */ + readonly MAX_CLIENT_WAIT_TIMEOUT_WEBGL: GLenum; +}; + +interface WebGL2RenderingContextBase { + readonly canvas: HTMLCanvasElement; + readonly drawingBufferHeight: GLsizei; + readonly drawingBufferWidth: GLsizei; + + /* Buffer objects */ + // WebGL1: + bufferData(target: GLenum, size: GLsizeiptr, usage: GLenum); + bufferData(target: GLenum, data: BufferSource | null, usage: GLenum); + bufferSubData(target: GLenum, dstOffset: GLintptr, data: BufferSource); + // WebGL2: + bufferData(target: GLenum, data: BufferSource, usage: GLenum, srcOffset: GLintptr, length?: GLuint); + bufferSubData(target: GLenum, dstOffset: GLintptr, data: BufferSource, srcOffset: GLintptr, length?: GLuint); + + copyBufferSubData(readTarget: GLenum, writeTarget: GLenum, readOffset: GLintptr, writeOffset: GLintptr, size: GLsizeiptr); + // MapBufferRange, in particular its read-only and write-only modes, + // can not be exposed safely to JavaScript. GetBufferSubData + // replaces it for the purpose of fetching data back from the GPU. + getBufferSubData(target: GLenum, srcByteOffset: GLintptr, dstBuffer: BufferSource, dstOffset?: GLuint, length?: GLuint); + + /* Framebuffer objects */ + blitFramebuffer(srcX0: GLint, srcY0: GLint, srcX1: GLint, srcY1: GLint, dstX0: GLint, dstY0: GLint, dstX1: GLint, dstY1: GLint, mask: GLbitfield, filter: GLenum); + framebufferTextureLayer(target: GLenum, attachment: GLenum, texture: WebGLTexture | null, level: GLint, layer: GLint); + invalidateFramebuffer(target: GLenum, attachments: GLenum[]); + invalidateSubFramebuffer(target: GLenum, attachments: GLenum[], x: GLint, y: GLint, width: GLsizei, height: GLsizei); + readBuffer(src: GLenum); + + /* Renderbuffer objects */ + getInternalformatParameter(target: GLenum, internalformat: GLenum, pname: GLenum): any; + renderbufferStorageMultisample(target: GLenum, samples: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei); + + /* Texture objects */ + texStorage2D(target: GLenum, levels: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei); + texStorage3D(target: GLenum, levels: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei); + + // WebGL1 legacy entrypoints: + texImage2D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, pixels: ArrayBufferView | null); + texImage2D(target: GLenum, level: GLint, internalformat: GLenum, format: GLenum, type: GLenum, source: TexImageSource); // May throw DOMException + + texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, pixels: ArrayBufferView | null); + texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, format: GLenum, type: GLenum, source: TexImageSource); // May throw DOMException + + // WebGL2 entrypoints: + texImage2D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, pboOffset: GLintptr); + texImage2D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, source: TexImageSource); // May throw DOMException + texImage2D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, srcData: ArrayBufferView, srcOffset: GLuint); + + texImage3D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, type: GLenum, pboOffset: GLintptr); + texImage3D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, type: GLenum, source: TexImageSource); // May throw DOMException + texImage3D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, type: GLenum, srcData: ArrayBufferView); + texImage3D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, format: GLenum, type: GLenum, srcData: ArrayBufferView, srcOffset: GLuint); + + texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, pboOffset: GLintptr); + texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, source: TexImageSource); // May throw DOMException + texSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, srcData: ArrayBufferView, srcOffset: GLuint); + + texSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, type: GLenum, pboOffset: GLintptr); + texSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, type: GLenum, source: TexImageSource); // May throw DOMException + texSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, type: GLenum, srcData: ArrayBufferView | null, srcOffset?: GLuint); + + copyTexSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, x: GLint, y: GLint, width: GLsizei, height: GLsizei); + + compressedTexImage2D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, border: GLint, imageSize: GLsizei, offset: GLintptr); + compressedTexImage2D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, border: GLint, srcData: ArrayBufferView, srcOffset?: GLuint, srcLengthOverride?: GLuint); + compressedTexImage3D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, imageSize: GLsizei, offset: GLintptr); + compressedTexImage3D(target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, depth: GLsizei, border: GLint, srcData: ArrayBufferView, srcOffset?: GLuint, srcLengthOverride?: GLuint); + + ompressedTexSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, imageSize: GLsizei, offset: GLintptr); + compressedTexSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, width: GLsizei, height: GLsizei, format: GLenum, srcData: ArrayBufferView, srcOffset?: GLuint, srcLengthOverride?: GLuint); + compressedTexSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, imageSize: GLsizei, offset: GLintptr); + compressedTexSubImage3D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, zoffset: GLint, width: GLsizei, height: GLsizei, depth: GLsizei, format: GLenum, srcData: ArrayBufferView, srcOffset?: GLuint, srcLengthOverride?: GLuint); + + /* Programs and shaders */ + getFragDataLocation(program: WebGLProgram, name: string): GLint; + + /* Uniforms */ + uniform1ui(location: WebGLUniformLocation, v0: GLuint); + uniform2ui(location: WebGLUniformLocation, v0: GLuint, v1: GLuint); + uniform3ui(location: WebGLUniformLocation, v0: GLuint, v1: GLuint, v2: GLuint); + uniform4ui(location: WebGLUniformLocation, v0: GLuint, v1: GLuint, v2: GLuint, v3: GLuint); + + uniform1fv(location: WebGLUniformLocation, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint); + uniform2fv(location: WebGLUniformLocation, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint); + uniform3fv(location: WebGLUniformLocation, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint); + uniform4fv(location: WebGLUniformLocation, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint); + + uniform1iv(location: WebGLUniformLocation, data: Int32List, srcOffset?: GLuint, srcLength?: GLuint); + uniform2iv(location: WebGLUniformLocation, data: Int32List, srcOffset?: GLuint, srcLength?: GLuint); + uniform3iv(location: WebGLUniformLocation, data: Int32List, srcOffset?: GLuint, srcLength?: GLuint); + uniform4iv(location: WebGLUniformLocation, data: Int32List, srcOffset?: GLuint, srcLength?: GLuint); + + uniform1uiv(location: WebGLUniformLocation, data: Uint32List, srcOffset?: GLuint, srcLength?: GLuint); + uniform2uiv(location: WebGLUniformLocation, data: Uint32List, srcOffset?: GLuint, srcLength?: GLuint); + uniform3uiv(location: WebGLUniformLocation, data: Uint32List, srcOffset?: GLuint, srcLength?: GLuint); + uniform4uiv(location: WebGLUniformLocation, data: Uint32List, srcOffset?: GLuint, srcLength?: GLuint); + + uniformMatrix2fv(location: WebGLUniformLocation, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint); + uniformMatrix3x2fv(location: WebGLUniformLocation, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint); + uniformMatrix4x2fv(location: WebGLUniformLocation, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint); + uniformMatrix2x3fv(location: WebGLUniformLocation, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint); + uniformMatrix3fv(location: WebGLUniformLocation, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint); + uniformMatrix4x3fv(location: WebGLUniformLocation, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint); + uniformMatrix2x4fv(location: WebGLUniformLocation, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint); + uniformMatrix3x4fv(location: WebGLUniformLocation, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint); + uniformMatrix4fv(location: WebGLUniformLocation, transpose: GLboolean, data: Float32List, srcOffset?: GLuint, srcLength?: GLuint); + + /* Vertex attribs */ + vertexAttribI4i(index: GLuint, x: GLint, y: GLint, z: GLint, w: GLint); + vertexAttribI4iv(index: GLuint, values: Int32List); + vertexAttribI4ui(index: GLuint, x: GLuint, y: GLuint, z: GLuint, w: GLuint); + vertexAttribI4uiv(index: GLuint, values: Uint32List); + vertexAttribIPointer(index: GLuint, size: GLint, type: GLenum, stride: GLsizei, offset: GLintptr); + + /* Writing to the drawing buffer */ + vertexAttribDivisor(index: GLuint, divisor: GLuint); + drawArraysInstanced(mode: GLenum, first: GLint, count: GLsizei, instanceCount: GLsizei); + drawElementsInstanced(mode: GLenum, count: GLsizei, type: GLenum, offset: GLintptr, instanceCount: GLsizei); + drawRangeElements(mode: GLenum, start: GLuint, end: GLuint, count: GLsizei, type: GLenum, offset: GLintptr); + + /* Reading back pixels */ + // WebGL1: + readPixels(x: GLint, y: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, dstData: ArrayBufferView | null); + // WebGL2: + readPixels(x: GLint, y: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, offset: GLintptr); + readPixels(x: GLint, y: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, dstData: ArrayBufferView, dstOffset: GLuint); + + /* Multiple Render Targets */ + drawBuffers(buffers: GLenum[]); + clearBufferfv(buffer: GLenum, drawbuffer: GLint, values: Float32List, srcOffset?: GLuint); + clearBufferiv(buffer: GLenum, drawbuffer: GLint, values: Int32List, srcOffset?: GLuint); + clearBufferuiv(buffer: GLenum, drawbuffer: GLint, values: Uint32List, srcOffset?: GLuint); + clearBufferfi(buffer: GLenum, drawbuffer: GLint, depth: GLfloat, stencil: GLint); + + /* Query Objects */ + createQuery(): WebGLQuery | null; + deleteQuery(query: WebGLQuery | null); + isQuery(query: WebGLQuery): GLboolean; + beginQuery(target: GLenum, query: WebGLQuery); + endQuery(target: GLenum); + getQuery(target: GLenum, pname: GLenum): WebGLQuery | null; + getQueryParameter(query: WebGLQuery, pname: GLenum): any; + + /* Sampler Objects */ + createSampler(): WebGLSampler | null; + deleteSampler(sampler: WebGLSampler | null); + isSampler(sampler: WebGLSampler | null): GLboolean; + bindSampler(unit: GLuint, sampler: WebGLSampler | null); + samplerParameteri(sampler: WebGLSampler, pname: GLenum, param: GLint); + samplerParameterf(sampler: WebGLSampler, pname: GLenum, param: GLfloat); + getSamplerParameter(sampler: WebGLSampler, pname: GLenum): any; + + /* Sync objects */ + fenceSync(condition: GLenum, flags: GLbitfield): WebGLSync | null; + isSync(sync: WebGLSync | null): GLboolean; + deleteSync(sync: WebGLSync | null); + clientWaitSync(sync: WebGLSync, flags: GLbitfield, timeout: GLuint64): GLenum; + waitSync(sync: WebGLSync, flags: GLbitfield, timeout: GLint64); + getSyncParameter(sync: WebGLSync, pname: GLenum): any; + + /* Transform Feedback */ + createTransformFeedback(): WebGLTransformFeedback | null; + deleteTransformFeedback(tf: WebGLTransformFeedback | null); + isTransformFeedback(tf: WebGLTransformFeedback | null): GLboolean; + bindTransformFeedback(target: GLenum, tf: WebGLTransformFeedback | null); + beginTransformFeedback(primitiveMode: GLenum); + endTransformFeedback(); + transformFeedbackVaryings(program: WebGLProgram, varyings: string[], bufferMode: GLenum); + getTransformFeedbackVarying(program: WebGLProgram, index: GLuint): WebGLActiveInfo | null; + pauseTransformFeedback(); + resumeTransformFeedback(); + + /* Uniform Buffer Objects and Transform Feedback Buffers */ + bindBufferBase(target: GLenum, index: GLuint, buffer: WebGLBuffer | null); + bindBufferRange(target: GLenum, index: GLuint, buffer: WebGLBuffer | null, offset: GLintptr, size: GLsizeiptr); + getIndexedParameter(target: GLenum, index: GLuint): any; + getUniformIndices(program: WebGLProgram, uniformNames: string[]): GLuint[] | null; + getActiveUniforms(program: WebGLProgram, uniformIndices: GLuint[], pname: GLenum): any; + getUniformBlockIndex(program: WebGLProgram, uniformBlockName: string): GLuint; + getActiveUniformBlockParameter(program: WebGLProgram, uniformBlockIndex: GLuint, pname: GLenum): any; + getActiveUniformBlockName(program: WebGLProgram, uniformBlockIndex: GLuint): string | null; + uniformBlockBinding(program: WebGLProgram, uniformBlockIndex: GLuint, uniformBlockBinding: GLuint); + + /* Vertex Array Objects */ + createVertexArray(): WebGLVertexArrayObject | null; + deleteVertexArray(vertexArray: WebGLVertexArrayObject | null); + isVertexArray(vertexArray: WebGLVertexArrayObject | null): GLboolean; + bindVertexArray(array: WebGLVertexArrayObject | null); + + activeTexture(texture: GLenum): void; + attachShader(program: WebGLProgram, shader: WebGLShader): void; + bindAttribLocation(program: WebGLProgram, index: GLuint, name: string): void; + bindBuffer(target: GLenum, buffer: WebGLBuffer | null): void; + bindFramebuffer(target: GLenum, framebuffer: WebGLFramebuffer | null): void; + bindRenderbuffer(target: GLenum, renderbuffer: WebGLRenderbuffer | null): void; + bindTexture(target: GLenum, texture: WebGLTexture | null): void; + blendColor(red: GLclampf, green: GLclampf, blue: GLclampf, alpha: GLclampf): void; + blendEquation(mode: GLenum): void; + blendEquationSeparate(modeRGB: GLenum, modeAlpha: GLenum): void; + blendFunc(sfactor: GLenum, dfactor: GLenum): void; + blendFuncSeparate(srcRGB: GLenum, dstRGB: GLenum, srcAlpha: GLenum, dstAlpha: GLenum): void; + bufferData(target: GLenum, size: GLsizeiptr, usage: GLenum): void; + bufferData(target: GLenum, data: BufferSource | null, usage: GLenum): void; + bufferSubData(target: GLenum, offset: GLintptr, data: BufferSource): void; + checkFramebufferStatus(target: GLenum): GLenum; + clear(mask: GLbitfield): void; + clearColor(red: GLclampf, green: GLclampf, blue: GLclampf, alpha: GLclampf): void; + clearDepth(depth: GLclampf): void; + clearStencil(s: GLint): void; + colorMask(red: GLboolean, green: GLboolean, blue: GLboolean, alpha: GLboolean): void; + compileShader(shader: WebGLShader): void; + copyTexImage2D(target: GLenum, level: GLint, internalformat: GLenum, x: GLint, y: GLint, width: GLsizei, height: GLsizei, border: GLint): void; + copyTexSubImage2D(target: GLenum, level: GLint, xoffset: GLint, yoffset: GLint, x: GLint, y: GLint, width: GLsizei, height: GLsizei): void; + createBuffer(): WebGLBuffer | null; + createFramebuffer(): WebGLFramebuffer | null; + createProgram(): WebGLProgram | null; + createRenderbuffer(): WebGLRenderbuffer | null; + createShader(type: GLenum): WebGLShader | null; + createTexture(): WebGLTexture | null; + cullFace(mode: GLenum): void; + deleteBuffer(buffer: WebGLBuffer | null): void; + deleteFramebuffer(framebuffer: WebGLFramebuffer | null): void; + deleteProgram(program: WebGLProgram | null): void; + deleteRenderbuffer(renderbuffer: WebGLRenderbuffer | null): void; + deleteShader(shader: WebGLShader | null): void; + deleteTexture(texture: WebGLTexture | null): void; + depthFunc(func: GLenum): void; + depthMask(flag: GLboolean): void; + depthRange(zNear: GLclampf, zFar: GLclampf): void; + detachShader(program: WebGLProgram, shader: WebGLShader): void; + disable(cap: GLenum): void; + disableVertexAttribArray(index: GLuint): void; + drawArrays(mode: GLenum, first: GLint, count: GLsizei): void; + drawElements(mode: GLenum, count: GLsizei, type: GLenum, offset: GLintptr): void; + enable(cap: GLenum): void; + enableVertexAttribArray(index: GLuint): void; + finish(): void; + flush(): void; + framebufferRenderbuffer(target: GLenum, attachment: GLenum, renderbuffertarget: GLenum, renderbuffer: WebGLRenderbuffer | null): void; + framebufferTexture2D(target: GLenum, attachment: GLenum, textarget: GLenum, texture: WebGLTexture | null, level: GLint): void; + frontFace(mode: GLenum): void; + generateMipmap(target: GLenum): void; + getActiveAttrib(program: WebGLProgram, index: GLuint): WebGLActiveInfo | null; + getActiveUniform(program: WebGLProgram, index: GLuint): WebGLActiveInfo | null; + getAttachedShaders(program: WebGLProgram): WebGLShader[] | null; + getAttribLocation(program: WebGLProgram, name: string): GLint; + getBufferParameter(target: GLenum, pname: GLenum): any; + getContextAttributes(): WebGLContextAttributes | null; + getError(): GLenum; + getExtension(extensionName: string): any; + getFramebufferAttachmentParameter(target: GLenum, attachment: GLenum, pname: GLenum): any; + getParameter(pname: GLenum): any; + getProgramInfoLog(program: WebGLProgram): string | null; + getProgramParameter(program: WebGLProgram, pname: GLenum): any; + getRenderbufferParameter(target: GLenum, pname: GLenum): any; + getShaderInfoLog(shader: WebGLShader): string | null; + getShaderParameter(shader: WebGLShader, pname: GLenum): any; + getShaderPrecisionFormat(shadertype: GLenum, precisiontype: GLenum): WebGLShaderPrecisionFormat | null; + getShaderSource(shader: WebGLShader): string | null; + getSupportedExtensions(): string[] | null; + getTexParameter(target: GLenum, pname: GLenum): any; + getUniform(program: WebGLProgram, location: WebGLUniformLocation): any; + getUniformLocation(program: WebGLProgram, name: string): WebGLUniformLocation | null; + getVertexAttrib(index: GLuint, pname: GLenum): any; + getVertexAttribOffset(index: GLuint, pname: GLenum): GLintptr; + hint(target: GLenum, mode: GLenum): void; + isBuffer(buffer: WebGLBuffer | null): GLboolean; + isContextLost(): boolean; + isEnabled(cap: GLenum): GLboolean; + isFramebuffer(framebuffer: WebGLFramebuffer | null): GLboolean; + isProgram(program: WebGLProgram | null): GLboolean; + isRenderbuffer(renderbuffer: WebGLRenderbuffer | null): GLboolean; + isShader(shader: WebGLShader | null): GLboolean; + isTexture(texture: WebGLTexture | null): GLboolean; + lineWidth(width: GLfloat): void; + linkProgram(program: WebGLProgram): void; + pixelStorei(pname: GLenum, param: GLint): void; + polygonOffset(factor: GLfloat, units: GLfloat): void; + readPixels(x: GLint, y: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, pixels: ArrayBufferView | null): void; + renderbufferStorage(target: GLenum, internalformat: GLenum, width: GLsizei, height: GLsizei): void; + sampleCoverage(value: GLclampf, invert: GLboolean): void; + scissor(x: GLint, y: GLint, width: GLsizei, height: GLsizei): void; + shaderSource(shader: WebGLShader, source: string): void; + stencilFunc(func: GLenum, ref: GLint, mask: GLuint): void; + stencilFuncSeparate(face: GLenum, func: GLenum, ref: GLint, mask: GLuint): void; + stencilMask(mask: GLuint): void; + stencilMaskSeparate(face: GLenum, mask: GLuint): void; + stencilOp(fail: GLenum, zfail: GLenum, zpass: GLenum): void; + stencilOpSeparate(face: GLenum, fail: GLenum, zfail: GLenum, zpass: GLenum): void; + texParameterf(target: GLenum, pname: GLenum, param: GLfloat): void; + texParameteri(target: GLenum, pname: GLenum, param: GLint): void; + + useProgram(program: WebGLProgram | null): void; + validateProgram(program: WebGLProgram): void; + vertexAttrib1f(index: GLuint, x: GLfloat): void; + vertexAttrib1fv(index: GLuint, values: Float32List): void; + vertexAttrib2f(index: GLuint, x: GLfloat, y: GLfloat): void; + vertexAttrib2fv(index: GLuint, values: Float32List): void; + vertexAttrib3f(index: GLuint, x: GLfloat, y: GLfloat, z: GLfloat): void; + vertexAttrib3fv(index: GLuint, values: Float32List): void; + vertexAttrib4f(index: GLuint, x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat): void; + vertexAttrib4fv(index: GLuint, values: Float32List): void; + vertexAttribPointer(index: GLuint, size: GLint, type: GLenum, normalized: GLboolean, stride: GLsizei, offset: GLintptr): void; + viewport(x: GLint, y: GLint, width: GLsizei, height: GLsizei): void; + readonly ACTIVE_ATTRIBUTES: GLenum; + readonly ACTIVE_TEXTURE: GLenum; + readonly ACTIVE_UNIFORMS: GLenum; + readonly ALIASED_LINE_WIDTH_RANGE: GLenum; + readonly ALIASED_POINT_SIZE_RANGE: GLenum; + readonly ALPHA: GLenum; + readonly ALPHA_BITS: GLenum; + readonly ALWAYS: GLenum; + readonly ARRAY_BUFFER: GLenum; + readonly ARRAY_BUFFER_BINDING: GLenum; + readonly ATTACHED_SHADERS: GLenum; + readonly BACK: GLenum; + readonly BLEND: GLenum; + readonly BLEND_COLOR: GLenum; + readonly BLEND_DST_ALPHA: GLenum; + readonly BLEND_DST_RGB: GLenum; + readonly BLEND_EQUATION: GLenum; + readonly BLEND_EQUATION_ALPHA: GLenum; + readonly BLEND_EQUATION_RGB: GLenum; + readonly BLEND_SRC_ALPHA: GLenum; + readonly BLEND_SRC_RGB: GLenum; + readonly BLUE_BITS: GLenum; + readonly BOOL: GLenum; + readonly BOOL_VEC2: GLenum; + readonly BOOL_VEC3: GLenum; + readonly BOOL_VEC4: GLenum; + readonly BROWSER_DEFAULT_WEBGL: GLenum; + readonly BUFFER_SIZE: GLenum; + readonly BUFFER_USAGE: GLenum; + readonly BYTE: GLenum; + readonly CCW: GLenum; + readonly CLAMP_TO_EDGE: GLenum; + readonly COLOR_ATTACHMENT0: GLenum; + readonly COLOR_BUFFER_BIT: GLenum; + readonly COLOR_CLEAR_VALUE: GLenum; + readonly COLOR_WRITEMASK: GLenum; + readonly COMPILE_STATUS: GLenum; + readonly COMPRESSED_TEXTURE_FORMATS: GLenum; + readonly CONSTANT_ALPHA: GLenum; + readonly CONSTANT_COLOR: GLenum; + readonly CONTEXT_LOST_WEBGL: GLenum; + readonly CULL_FACE: GLenum; + readonly CULL_FACE_MODE: GLenum; + readonly CURRENT_PROGRAM: GLenum; + readonly CURRENT_VERTEX_ATTRIB: GLenum; + readonly CW: GLenum; + readonly DECR: GLenum; + readonly DECR_WRAP: GLenum; + readonly DELETE_STATUS: GLenum; + readonly DEPTH_ATTACHMENT: GLenum; + readonly DEPTH_BITS: GLenum; + readonly DEPTH_BUFFER_BIT: GLenum; + readonly DEPTH_CLEAR_VALUE: GLenum; + readonly DEPTH_COMPONENT: GLenum; + readonly DEPTH_COMPONENT16: GLenum; + readonly DEPTH_FUNC: GLenum; + readonly DEPTH_RANGE: GLenum; + readonly DEPTH_STENCIL: GLenum; + readonly DEPTH_STENCIL_ATTACHMENT: GLenum; + readonly DEPTH_TEST: GLenum; + readonly DEPTH_WRITEMASK: GLenum; + readonly DITHER: GLenum; + readonly DONT_CARE: GLenum; + readonly DST_ALPHA: GLenum; + readonly DST_COLOR: GLenum; + readonly DYNAMIC_DRAW: GLenum; + readonly ELEMENT_ARRAY_BUFFER: GLenum; + readonly ELEMENT_ARRAY_BUFFER_BINDING: GLenum; + readonly EQUAL: GLenum; + readonly FASTEST: GLenum; + readonly FLOAT: GLenum; + readonly FLOAT_MAT2: GLenum; + readonly FLOAT_MAT3: GLenum; + readonly FLOAT_MAT4: GLenum; + readonly FLOAT_VEC2: GLenum; + readonly FLOAT_VEC3: GLenum; + readonly FLOAT_VEC4: GLenum; + readonly FRAGMENT_SHADER: GLenum; + readonly FRAMEBUFFER: GLenum; + readonly FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: GLenum; + readonly FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: GLenum; + readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: GLenum; + readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: GLenum; + readonly FRAMEBUFFER_BINDING: GLenum; + readonly FRAMEBUFFER_COMPLETE: GLenum; + readonly FRAMEBUFFER_INCOMPLETE_ATTACHMENT: GLenum; + readonly FRAMEBUFFER_INCOMPLETE_DIMENSIONS: GLenum; + readonly FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: GLenum; + readonly FRAMEBUFFER_UNSUPPORTED: GLenum; + readonly FRONT: GLenum; + readonly FRONT_AND_BACK: GLenum; + readonly FRONT_FACE: GLenum; + readonly FUNC_ADD: GLenum; + readonly FUNC_REVERSE_SUBTRACT: GLenum; + readonly FUNC_SUBTRACT: GLenum; + readonly GENERATE_MIPMAP_HINT: GLenum; + readonly GEQUAL: GLenum; + readonly GREATER: GLenum; + readonly GREEN_BITS: GLenum; + readonly HIGH_FLOAT: GLenum; + readonly HIGH_INT: GLenum; + readonly IMPLEMENTATION_COLOR_READ_FORMAT: GLenum; + readonly IMPLEMENTATION_COLOR_READ_TYPE: GLenum; + readonly INCR: GLenum; + readonly INCR_WRAP: GLenum; + readonly INT: GLenum; + readonly INT_VEC2: GLenum; + readonly INT_VEC3: GLenum; + readonly INT_VEC4: GLenum; + readonly INVALID_ENUM: GLenum; + readonly INVALID_FRAMEBUFFER_OPERATION: GLenum; + readonly INVALID_OPERATION: GLenum; + readonly INVALID_VALUE: GLenum; + readonly INVERT: GLenum; + readonly KEEP: GLenum; + readonly LEQUAL: GLenum; + readonly LESS: GLenum; + readonly LINEAR: GLenum; + readonly LINEAR_MIPMAP_LINEAR: GLenum; + readonly LINEAR_MIPMAP_NEAREST: GLenum; + readonly LINES: GLenum; + readonly LINE_LOOP: GLenum; + readonly LINE_STRIP: GLenum; + readonly LINE_WIDTH: GLenum; + readonly LINK_STATUS: GLenum; + readonly LOW_FLOAT: GLenum; + readonly LOW_INT: GLenum; + readonly LUMINANCE: GLenum; + readonly LUMINANCE_ALPHA: GLenum; + readonly MAX_COMBINED_TEXTURE_IMAGE_UNITS: GLenum; + readonly MAX_CUBE_MAP_TEXTURE_SIZE: GLenum; + readonly MAX_FRAGMENT_UNIFORM_VECTORS: GLenum; + readonly MAX_RENDERBUFFER_SIZE: GLenum; + readonly MAX_TEXTURE_IMAGE_UNITS: GLenum; + readonly MAX_TEXTURE_SIZE: GLenum; + readonly MAX_VARYING_VECTORS: GLenum; + readonly MAX_VERTEX_ATTRIBS: GLenum; + readonly MAX_VERTEX_TEXTURE_IMAGE_UNITS: GLenum; + readonly MAX_VERTEX_UNIFORM_VECTORS: GLenum; + readonly MAX_VIEWPORT_DIMS: GLenum; + readonly MEDIUM_FLOAT: GLenum; + readonly MEDIUM_INT: GLenum; + readonly MIRRORED_REPEAT: GLenum; + readonly NEAREST: GLenum; + readonly NEAREST_MIPMAP_LINEAR: GLenum; + readonly NEAREST_MIPMAP_NEAREST: GLenum; + readonly NEVER: GLenum; + readonly NICEST: GLenum; + readonly NONE: GLenum; + readonly NOTEQUAL: GLenum; + readonly NO_ERROR: GLenum; + readonly ONE: GLenum; + readonly ONE_MINUS_CONSTANT_ALPHA: GLenum; + readonly ONE_MINUS_CONSTANT_COLOR: GLenum; + readonly ONE_MINUS_DST_ALPHA: GLenum; + readonly ONE_MINUS_DST_COLOR: GLenum; + readonly ONE_MINUS_SRC_ALPHA: GLenum; + readonly ONE_MINUS_SRC_COLOR: GLenum; + readonly OUT_OF_MEMORY: GLenum; + readonly PACK_ALIGNMENT: GLenum; + readonly POINTS: GLenum; + readonly POLYGON_OFFSET_FACTOR: GLenum; + readonly POLYGON_OFFSET_FILL: GLenum; + readonly POLYGON_OFFSET_UNITS: GLenum; + readonly RED_BITS: GLenum; + readonly RENDERBUFFER: GLenum; + readonly RENDERBUFFER_ALPHA_SIZE: GLenum; + readonly RENDERBUFFER_BINDING: GLenum; + readonly RENDERBUFFER_BLUE_SIZE: GLenum; + readonly RENDERBUFFER_DEPTH_SIZE: GLenum; + readonly RENDERBUFFER_GREEN_SIZE: GLenum; + readonly RENDERBUFFER_HEIGHT: GLenum; + readonly RENDERBUFFER_INTERNAL_FORMAT: GLenum; + readonly RENDERBUFFER_RED_SIZE: GLenum; + readonly RENDERBUFFER_STENCIL_SIZE: GLenum; + readonly RENDERBUFFER_WIDTH: GLenum; + readonly RENDERER: GLenum; + readonly REPEAT: GLenum; + readonly REPLACE: GLenum; + readonly RGB: GLenum; + readonly RGB565: GLenum; + readonly RGB5_A1: GLenum; + readonly RGBA: GLenum; + readonly RGBA4: GLenum; + readonly SAMPLER_2D: GLenum; + readonly SAMPLER_CUBE: GLenum; + readonly SAMPLES: GLenum; + readonly SAMPLE_ALPHA_TO_COVERAGE: GLenum; + readonly SAMPLE_BUFFERS: GLenum; + readonly SAMPLE_COVERAGE: GLenum; + readonly SAMPLE_COVERAGE_INVERT: GLenum; + readonly SAMPLE_COVERAGE_VALUE: GLenum; + readonly SCISSOR_BOX: GLenum; + readonly SCISSOR_TEST: GLenum; + readonly SHADER_TYPE: GLenum; + readonly SHADING_LANGUAGE_VERSION: GLenum; + readonly SHORT: GLenum; + readonly SRC_ALPHA: GLenum; + readonly SRC_ALPHA_SATURATE: GLenum; + readonly SRC_COLOR: GLenum; + readonly STATIC_DRAW: GLenum; + readonly STENCIL_ATTACHMENT: GLenum; + readonly STENCIL_BACK_FAIL: GLenum; + readonly STENCIL_BACK_FUNC: GLenum; + readonly STENCIL_BACK_PASS_DEPTH_FAIL: GLenum; + readonly STENCIL_BACK_PASS_DEPTH_PASS: GLenum; + readonly STENCIL_BACK_REF: GLenum; + readonly STENCIL_BACK_VALUE_MASK: GLenum; + readonly STENCIL_BACK_WRITEMASK: GLenum; + readonly STENCIL_BITS: GLenum; + readonly STENCIL_BUFFER_BIT: GLenum; + readonly STENCIL_CLEAR_VALUE: GLenum; + readonly STENCIL_FAIL: GLenum; + readonly STENCIL_FUNC: GLenum; + readonly STENCIL_INDEX8: GLenum; + readonly STENCIL_PASS_DEPTH_FAIL: GLenum; + readonly STENCIL_PASS_DEPTH_PASS: GLenum; + readonly STENCIL_REF: GLenum; + readonly STENCIL_TEST: GLenum; + readonly STENCIL_VALUE_MASK: GLenum; + readonly STENCIL_WRITEMASK: GLenum; + readonly STREAM_DRAW: GLenum; + readonly SUBPIXEL_BITS: GLenum; + readonly TEXTURE: GLenum; + readonly TEXTURE0: GLenum; + readonly TEXTURE1: GLenum; + readonly TEXTURE10: GLenum; + readonly TEXTURE11: GLenum; + readonly TEXTURE12: GLenum; + readonly TEXTURE13: GLenum; + readonly TEXTURE14: GLenum; + readonly TEXTURE15: GLenum; + readonly TEXTURE16: GLenum; + readonly TEXTURE17: GLenum; + readonly TEXTURE18: GLenum; + readonly TEXTURE19: GLenum; + readonly TEXTURE2: GLenum; + readonly TEXTURE20: GLenum; + readonly TEXTURE21: GLenum; + readonly TEXTURE22: GLenum; + readonly TEXTURE23: GLenum; + readonly TEXTURE24: GLenum; + readonly TEXTURE25: GLenum; + readonly TEXTURE26: GLenum; + readonly TEXTURE27: GLenum; + readonly TEXTURE28: GLenum; + readonly TEXTURE29: GLenum; + readonly TEXTURE3: GLenum; + readonly TEXTURE30: GLenum; + readonly TEXTURE31: GLenum; + readonly TEXTURE4: GLenum; + readonly TEXTURE5: GLenum; + readonly TEXTURE6: GLenum; + readonly TEXTURE7: GLenum; + readonly TEXTURE8: GLenum; + readonly TEXTURE9: GLenum; + readonly TEXTURE_2D: GLenum; + readonly TEXTURE_BINDING_2D: GLenum; + readonly TEXTURE_BINDING_CUBE_MAP: GLenum; + readonly TEXTURE_CUBE_MAP: GLenum; + readonly TEXTURE_CUBE_MAP_NEGATIVE_X: GLenum; + readonly TEXTURE_CUBE_MAP_NEGATIVE_Y: GLenum; + readonly TEXTURE_CUBE_MAP_NEGATIVE_Z: GLenum; + readonly TEXTURE_CUBE_MAP_POSITIVE_X: GLenum; + readonly TEXTURE_CUBE_MAP_POSITIVE_Y: GLenum; + readonly TEXTURE_CUBE_MAP_POSITIVE_Z: GLenum; + readonly TEXTURE_MAG_FILTER: GLenum; + readonly TEXTURE_MIN_FILTER: GLenum; + readonly TEXTURE_WRAP_S: GLenum; + readonly TEXTURE_WRAP_T: GLenum; + readonly TRIANGLES: GLenum; + readonly TRIANGLE_FAN: GLenum; + readonly TRIANGLE_STRIP: GLenum; + readonly UNPACK_ALIGNMENT: GLenum; + readonly UNPACK_COLORSPACE_CONVERSION_WEBGL: GLenum; + readonly UNPACK_FLIP_Y_WEBGL: GLenum; + readonly UNPACK_PREMULTIPLY_ALPHA_WEBGL: GLenum; + readonly UNSIGNED_BYTE: GLenum; + readonly UNSIGNED_INT: GLenum; + readonly UNSIGNED_SHORT: GLenum; + readonly UNSIGNED_SHORT_4_4_4_4: GLenum; + readonly UNSIGNED_SHORT_5_5_5_1: GLenum; + readonly UNSIGNED_SHORT_5_6_5: GLenum; + readonly VALIDATE_STATUS: GLenum; + readonly VENDOR: GLenum; + readonly VERSION: GLenum; + readonly VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: GLenum; + readonly VERTEX_ATTRIB_ARRAY_ENABLED: GLenum; + readonly VERTEX_ATTRIB_ARRAY_NORMALIZED: GLenum; + readonly VERTEX_ATTRIB_ARRAY_POINTER: GLenum; + readonly VERTEX_ATTRIB_ARRAY_SIZE: GLenum; + readonly VERTEX_ATTRIB_ARRAY_STRIDE: GLenum; + readonly VERTEX_ATTRIB_ARRAY_TYPE: GLenum; + readonly VERTEX_SHADER: GLenum; + readonly VIEWPORT: GLenum; + readonly ZERO: GLenum; + + readonly READ_BUFFER: GLenum; + readonly UNPACK_ROW_LENGTH: GLenum; + readonly UNPACK_SKIP_ROWS: GLenum; + readonly UNPACK_SKIP_PIXELS: GLenum; + readonly PACK_ROW_LENGTH: GLenum; + readonly PACK_SKIP_ROWS: GLenum; + readonly PACK_SKIP_PIXELS: GLenum; + readonly COLOR: GLenum; + readonly DEPTH: GLenum; + readonly STENCIL: GLenum; + readonly RED: GLenum; + readonly RGB8: GLenum; + readonly RGBA8: GLenum; + readonly RGB10_A2: GLenum; + readonly TEXTURE_BINDING_3D: GLenum; + readonly UNPACK_SKIP_IMAGES: GLenum; + readonly UNPACK_IMAGE_HEIGHT: GLenum; + readonly TEXTURE_3D: GLenum; + readonly TEXTURE_WRAP_R: GLenum; + readonly MAX_3D_TEXTURE_SIZE: GLenum; + readonly UNSIGNED_INT_2_10_10_10_REV: GLenum; + readonly MAX_ELEMENTS_VERTICES: GLenum; + readonly MAX_ELEMENTS_INDICES: GLenum; + readonly TEXTURE_MIN_LOD: GLenum; + readonly TEXTURE_MAX_LOD: GLenum; + readonly TEXTURE_BASE_LEVEL: GLenum; + readonly TEXTURE_MAX_LEVEL: GLenum; + readonly MIN: GLenum; + readonly MAX: GLenum; + readonly DEPTH_COMPONENT24: GLenum; + readonly MAX_TEXTURE_LOD_BIAS: GLenum; + readonly TEXTURE_COMPARE_MODE: GLenum; + readonly TEXTURE_COMPARE_FUNC: GLenum; + readonly CURRENT_QUERY: GLenum; + readonly QUERY_RESULT: GLenum; + readonly QUERY_RESULT_AVAILABLE: GLenum; + readonly STREAM_READ: GLenum; + readonly STREAM_COPY: GLenum; + readonly STATIC_READ: GLenum; + readonly STATIC_COPY: GLenum; + readonly DYNAMIC_READ: GLenum; + readonly DYNAMIC_COPY: GLenum; + readonly MAX_DRAW_BUFFERS: GLenum; + readonly DRAW_BUFFER0: GLenum; + readonly DRAW_BUFFER1: GLenum; + readonly DRAW_BUFFER2: GLenum; + readonly DRAW_BUFFER3: GLenum; + readonly DRAW_BUFFER4: GLenum; + readonly DRAW_BUFFER5: GLenum; + readonly DRAW_BUFFER6: GLenum; + readonly DRAW_BUFFER7: GLenum; + readonly DRAW_BUFFER8: GLenum; + readonly DRAW_BUFFER9: GLenum; + readonly DRAW_BUFFER10: GLenum; + readonly DRAW_BUFFER11: GLenum; + readonly DRAW_BUFFER12: GLenum; + readonly DRAW_BUFFER13: GLenum; + readonly DRAW_BUFFER14: GLenum; + readonly DRAW_BUFFER15: GLenum; + readonly MAX_FRAGMENT_UNIFORM_COMPONENTS: GLenum; + readonly MAX_VERTEX_UNIFORM_COMPONENTS: GLenum; + readonly SAMPLER_3D: GLenum; + readonly SAMPLER_2D_SHADOW: GLenum; + readonly FRAGMENT_SHADER_DERIVATIVE_HINT: GLenum; + readonly PIXEL_PACK_BUFFER: GLenum; + readonly PIXEL_UNPACK_BUFFER: GLenum; + readonly PIXEL_PACK_BUFFER_BINDING: GLenum; + readonly PIXEL_UNPACK_BUFFER_BINDING: GLenum; + readonly FLOAT_MAT2x3: GLenum; + readonly FLOAT_MAT2x4: GLenum; + readonly FLOAT_MAT3x2: GLenum; + readonly FLOAT_MAT3x4: GLenum; + readonly FLOAT_MAT4x2: GLenum; + readonly FLOAT_MAT4x3: GLenum; + readonly SRGB: GLenum; + readonly SRGB8: GLenum; + readonly SRGB8_ALPHA8: GLenum; + readonly COMPARE_REF_TO_TEXTURE: GLenum; + readonly RGBA32F: GLenum; + readonly RGB32F: GLenum; + readonly RGBA16F: GLenum; + readonly RGB16F: GLenum; + readonly VERTEX_ATTRIB_ARRAY_INTEGER: GLenum; + readonly MAX_ARRAY_TEXTURE_LAYERS: GLenum; + readonly MIN_PROGRAM_TEXEL_OFFSET: GLenum; + readonly MAX_PROGRAM_TEXEL_OFFSET: GLenum; + readonly MAX_VARYING_COMPONENTS: GLenum; + readonly TEXTURE_2D_ARRAY: GLenum; + readonly TEXTURE_BINDING_2D_ARRAY: GLenum; + readonly R11F_G11F_B10F: GLenum; + readonly UNSIGNED_INT_10F_11F_11F_REV: GLenum; + readonly RGB9_E5: GLenum; + readonly UNSIGNED_INT_5_9_9_9_REV: GLenum; + readonly TRANSFORM_FEEDBACK_BUFFER_MODE: GLenum; + readonly MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS: GLenum; + readonly TRANSFORM_FEEDBACK_VARYINGS: GLenum; + readonly TRANSFORM_FEEDBACK_BUFFER_START: GLenum; + readonly TRANSFORM_FEEDBACK_BUFFER_SIZE: GLenum; + readonly TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN: GLenum; + readonly RASTERIZER_DISCARD: GLenum; + readonly MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS: GLenum; + readonly MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS: GLenum; + readonly INTERLEAVED_ATTRIBS: GLenum; + readonly SEPARATE_ATTRIBS: GLenum; + readonly TRANSFORM_FEEDBACK_BUFFER: GLenum; + readonly TRANSFORM_FEEDBACK_BUFFER_BINDING: GLenum; + readonly RGBA32UI: GLenum; + readonly RGB32UI: GLenum; + readonly RGBA16UI: GLenum; + readonly RGB16UI: GLenum; + readonly RGBA8UI: GLenum; + readonly RGB8UI: GLenum; + readonly RGBA32I: GLenum; + readonly RGB32I: GLenum; + readonly RGBA16I: GLenum; + readonly RGB16I: GLenum; + readonly RGBA8I: GLenum; + readonly RGB8I: GLenum; + readonly RED_INTEGER: GLenum; + readonly RGB_INTEGER: GLenum; + readonly RGBA_INTEGER: GLenum; + readonly SAMPLER_2D_ARRAY: GLenum; + readonly SAMPLER_2D_ARRAY_SHADOW: GLenum; + readonly SAMPLER_CUBE_SHADOW: GLenum; + readonly UNSIGNED_INT_VEC2: GLenum; + readonly UNSIGNED_INT_VEC3: GLenum; + readonly UNSIGNED_INT_VEC4: GLenum; + readonly INT_SAMPLER_2D: GLenum; + readonly INT_SAMPLER_3D: GLenum; + readonly INT_SAMPLER_CUBE: GLenum; + readonly INT_SAMPLER_2D_ARRAY: GLenum; + readonly UNSIGNED_INT_SAMPLER_2D: GLenum; + readonly UNSIGNED_INT_SAMPLER_3D: GLenum; + readonly UNSIGNED_INT_SAMPLER_CUBE: GLenum; + readonly UNSIGNED_INT_SAMPLER_2D_ARRAY: GLenum; + readonly DEPTH_COMPONENT32F: GLenum; + readonly DEPTH32F_STENCIL8: GLenum; + readonly FLOAT_32_UNSIGNED_INT_24_8_REV: GLenum; + readonly FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING: GLenum; + readonly FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE: GLenum; + readonly FRAMEBUFFER_ATTACHMENT_RED_SIZE: GLenum; + readonly FRAMEBUFFER_ATTACHMENT_GREEN_SIZE: GLenum; + readonly FRAMEBUFFER_ATTACHMENT_BLUE_SIZE: GLenum; + readonly FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE: GLenum; + readonly FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE: GLenum; + readonly FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE: GLenum; + readonly FRAMEBUFFER_DEFAULT: GLenum; + readonly UNSIGNED_INT_24_8: GLenum; + readonly DEPTH24_STENCIL8: GLenum; + readonly UNSIGNED_NORMALIZED: GLenum; + readonly DRAW_FRAMEBUFFER_BINDING: GLenum; + readonly READ_FRAMEBUFFER: GLenum; + readonly DRAW_FRAMEBUFFER: GLenum; + readonly READ_FRAMEBUFFER_BINDING: GLenum; + + readonly FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER: GLenum; + readonly MAX_COLOR_ATTACHMENTS: GLenum; + readonly COLOR_ATTACHMENT1: GLenum; + readonly COLOR_ATTACHMENT2: GLenum; + readonly COLOR_ATTACHMENT3: GLenum; + readonly COLOR_ATTACHMENT4: GLenum; + readonly COLOR_ATTACHMENT5: GLenum; + readonly COLOR_ATTACHMENT6: GLenum; + readonly COLOR_ATTACHMENT7: GLenum; + readonly COLOR_ATTACHMENT8: GLenum; + readonly COLOR_ATTACHMENT9: GLenum; + readonly COLOR_ATTACHMENT10: GLenum; + readonly COLOR_ATTACHMENT11: GLenum; + readonly COLOR_ATTACHMENT12: GLenum; + readonly COLOR_ATTACHMENT13: GLenum; + readonly COLOR_ATTACHMENT14: GLenum; + readonly COLOR_ATTACHMENT15: GLenum; + readonly FRAMEBUFFER_INCOMPLETE_MULTISAMPLE: GLenum; + readonly MAX_SAMPLES: GLenum; + readonly HALF_FLOAT: GLenum; + readonly RG: GLenum; + readonly RG_INTEGER: GLenum; + readonly R8: GLenum; + readonly RG8: GLenum; + readonly R16F: GLenum; + + readonly R32F: GLenum; + readonly RG16F: GLenum; + readonly RG32F: GLenum; + readonly R8I: GLenum; + readonly R8UI: GLenum; + readonly R16I: GLenum; + readonly R16UI: GLenum; + readonly R32I: GLenum; + readonly R32UI: GLenum; + readonly RG8I: GLenum; + readonly RG8UI: GLenum; + readonly RG16I: GLenum; + readonly RG16UI: GLenum; + readonly RG32I: GLenum; + readonly RG32UI: GLenum; + readonly VERTEX_ARRAY_BINDING: GLenum; + readonly R8_SNORM: GLenum; + readonly RG8_SNORM: GLenum; + readonly RGB8_SNORM: GLenum; + readonly RGBA8_SNORM: GLenum; + readonly SIGNED_NORMALIZED: GLenum; + readonly COPY_READ_BUFFER: GLenum; + readonly COPY_WRITE_BUFFER: GLenum; + readonly COPY_READ_BUFFER_BINDING: GLenum; /* Same as COPY_READ_BUFFER */ + readonly COPY_WRITE_BUFFER_BINDING: GLenum; /* Same as COPY_WRITE_BUFFER */ + readonly UNIFORM_BUFFER: GLenum; + readonly UNIFORM_BUFFER_BINDING: GLenum; + readonly UNIFORM_BUFFER_START: GLenum; + readonly UNIFORM_BUFFER_SIZE: GLenum; + readonly MAX_VERTEX_UNIFORM_BLOCKS: GLenum; + readonly MAX_FRAGMENT_UNIFORM_BLOCKS: GLenum; + readonly MAX_COMBINED_UNIFORM_BLOCKS: GLenum; + readonly MAX_UNIFORM_BUFFER_BINDINGS: GLenum; + readonly MAX_UNIFORM_BLOCK_SIZE: GLenum; + readonly MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS: GLenum; + readonly MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS: GLenum; + readonly UNIFORM_BUFFER_OFFSET_ALIGNMENT: GLenum; + readonly ACTIVE_UNIFORM_BLOCKS: GLenum; + readonly UNIFORM_TYPE: GLenum; + readonly UNIFORM_SIZE: GLenum; + readonly UNIFORM_BLOCK_INDEX: GLenum; + readonly UNIFORM_OFFSET: GLenum; + readonly UNIFORM_ARRAY_STRIDE: GLenum; + readonly UNIFORM_MATRIX_STRIDE: GLenum; + readonly UNIFORM_IS_ROW_MAJOR: GLenum; + readonly UNIFORM_BLOCK_BINDING: GLenum; + readonly UNIFORM_BLOCK_DATA_SIZE: GLenum; + readonly UNIFORM_BLOCK_ACTIVE_UNIFORMS: GLenum; + readonly UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES: GLenum; + readonly UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER: GLenum; + readonly UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER: GLenum; + readonly INVALID_INDEX: GLenum; + readonly MAX_VERTEX_OUTPUT_COMPONENTS: GLenum; + readonly MAX_FRAGMENT_INPUT_COMPONENTS: GLenum; + readonly MAX_SERVER_WAIT_TIMEOUT: GLenum; + readonly OBJECT_TYPE: GLenum; + readonly SYNC_CONDITION: GLenum; + readonly SYNC_STATUS: GLenum; + readonly SYNC_FLAGS: GLenum; + readonly SYNC_FENCE: GLenum; + readonly SYNC_GPU_COMMANDS_COMPLETE: GLenum; + readonly UNSIGNALED: GLenum; + readonly SIGNALED: GLenum; + readonly ALREADY_SIGNALED: GLenum; + readonly TIMEOUT_EXPIRED: GLenum; + readonly CONDITION_SATISFIED: GLenum; + readonly WAIT_FAILED: GLenum; + readonly SYNC_FLUSH_COMMANDS_BIT: GLenum; + readonly VERTEX_ATTRIB_ARRAY_DIVISOR: GLenum; + readonly ANY_SAMPLES_PASSED: GLenum; + readonly ANY_SAMPLES_PASSED_CONSERVATIVE: GLenum; + readonly SAMPLER_BINDING: GLenum; + readonly RGB10_A2UI: GLenum; + readonly INT_2_10_10_10_REV: GLenum; + readonly TRANSFORM_FEEDBACK: GLenum; + readonly TRANSFORM_FEEDBACK_PAUSED: GLenum; + readonly TRANSFORM_FEEDBACK_ACTIVE: GLenum; + readonly TRANSFORM_FEEDBACK_BINDING: GLenum; + readonly TEXTURE_IMMUTABLE_FORMAT: GLenum; + readonly MAX_ELEMENT_INDEX: GLenum; + readonly TEXTURE_IMMUTABLE_LEVELS: GLenum; + + readonly TIMEOUT_IGNORED: GLint64; + + /* WebGL-specific enums */ + readonly MAX_CLIENT_WAIT_TIMEOUT_WEBGL: GLenum; +} + +type Uint32List = Uint32Array | GLuint[]; \ No newline at end of file diff --git a/cocos/gfx/webgl2/webgl2-binding-layout.ts b/cocos/gfx/webgl2/webgl2-binding-layout.ts new file mode 100644 index 0000000000..2ccfa44e34 --- /dev/null +++ b/cocos/gfx/webgl2/webgl2-binding-layout.ts @@ -0,0 +1,91 @@ +import { GFXBindingLayout, GFXBindingUnit, IGFXBindingLayoutInfo } from '../binding-layout'; +import { GFXBindingType, GFXStatus } from '../define'; +import { GFXDevice } from '../device'; +import { WebGL2GFXBuffer } from './webgl2-buffer'; +import { WebGL2GPUBinding, WebGL2GPUBindingLayout } from './webgl2-gpu-objects'; +import { WebGL2GFXSampler } from './webgl2-sampler'; +import { WebGL2GFXTextureView } from './webgl2-texture-view'; + +export class WebGL2GFXBindingLayout extends GFXBindingLayout { + + public get gpuBindingLayout (): WebGL2GPUBindingLayout { + return this._gpuBindingLayout as WebGL2GPUBindingLayout; + } + + private _gpuBindingLayout: WebGL2GPUBindingLayout | null = null; + + constructor (device: GFXDevice) { + super(device); + } + + public initialize (info: IGFXBindingLayoutInfo): boolean { + + this._bindingUnits = new Array(info.bindings.length); + for (let i = 0; i < info.bindings.length; ++i) { + const binding = info.bindings[i]; + this._bindingUnits[i] = { + binding: binding.binding, + type: binding.type, + name: binding.name, + buffer: null, + texView: null, + sampler: null, + }; + } + + this._gpuBindingLayout = { + gpuBindings: new Array(info.bindings.length), + }; + + for (let i = 0; i < info.bindings.length; ++i) { + const binding = info.bindings[i]; + this._gpuBindingLayout.gpuBindings[i] = { + binding: binding.binding, + type: binding.type, + name: binding.name, + gpuBuffer: null, + gpuTexView: null, + gpuSampler: null, + }; + } + + this._status = GFXStatus.SUCCESS; + + return true; + } + + public destroy () { + this._gpuBindingLayout = null; + this._status = GFXStatus.UNREADY; + } + + public update () { + if (this._isDirty && this._gpuBindingLayout) { + for (let i = 0; i < this._bindingUnits.length; ++i) { + const bindingUnit = this._bindingUnits[i]; + switch (bindingUnit.type) { + case GFXBindingType.UNIFORM_BUFFER: { + if (bindingUnit.buffer) { + this._gpuBindingLayout.gpuBindings[i].gpuBuffer = + (bindingUnit.buffer as WebGL2GFXBuffer).gpuBuffer; + } + break; + } + case GFXBindingType.SAMPLER: { + if (bindingUnit.texView) { + this._gpuBindingLayout.gpuBindings[i].gpuTexView = + (bindingUnit.texView as WebGL2GFXTextureView).gpuTextureView; + } + if (bindingUnit.sampler) { + this._gpuBindingLayout.gpuBindings[i].gpuSampler = + (bindingUnit.sampler as WebGL2GFXSampler).gpuSampler; + } + break; + } + default: + } + } + this._isDirty = false; + } + } +} diff --git a/cocos/gfx/webgl2/webgl2-buffer.ts b/cocos/gfx/webgl2/webgl2-buffer.ts new file mode 100644 index 0000000000..22f006b9c0 --- /dev/null +++ b/cocos/gfx/webgl2/webgl2-buffer.ts @@ -0,0 +1,119 @@ +import { GFXBuffer, GFXBufferSource, IGFXBufferInfo, IGFXIndirectBuffer } from '../buffer'; +import { GFXBufferUsageBit, GFXMemoryUsageBit, GFXStatus } from '../define'; +import { GFXDevice } from '../device'; +import { + WebGL2CmdFuncCreateBuffer, + WebGL2CmdFuncDestroyBuffer, + WebGL2CmdFuncResizeBuffer, + WebGL2CmdFuncUpdateBuffer, +} from './webgl2-commands'; +import { WebGL2GFXDevice } from './webgl2-device'; +import { WebGL2GPUBuffer } from './webgl2-gpu-objects'; + +export class WebGL2GFXBuffer extends GFXBuffer { + + public get gpuBuffer (): WebGL2GPUBuffer { + return this._gpuBuffer!; + } + + private _gpuBuffer: WebGL2GPUBuffer | null = null; + + constructor (device: GFXDevice) { + super(device); + } + + public initialize (info: IGFXBufferInfo): boolean { + + this._usage = info.usage; + this._memUsage = info.memUsage; + this._size = info.size; + this._stride = Math.max(info.stride || 1, 1); + this._count = this._size / this._stride; + + if (this._memUsage & GFXMemoryUsageBit.HOST) { + if (this._usage & GFXBufferUsageBit.INDIRECT) { + this._buffer = { drawInfos: [] }; + } else { + this._buffer = new ArrayBuffer(this._size); + } + } + + this._gpuBuffer = { + usage: info.usage, + memUsage: info.memUsage, + size: info.size, + stride: info.stride ? info.stride : 1, + buffer: null, + vf32: null, + uniforms: [], + indirects: [], + glTarget: 0, + glBuffer: 0, + }; + + if (this._buffer) { + if (info.usage & GFXBufferUsageBit.INDIRECT) { + this._gpuBuffer.indirects = (this._buffer as IGFXIndirectBuffer).drawInfos; + } else { + this._gpuBuffer.buffer = this._buffer as ArrayBuffer; + } + } + + WebGL2CmdFuncCreateBuffer(this._device as WebGL2GFXDevice, this._gpuBuffer); + + this._status = GFXStatus.SUCCESS; + + return true; + } + + public destroy () { + if (this._gpuBuffer) { + WebGL2CmdFuncDestroyBuffer(this._device as WebGL2GFXDevice, this._gpuBuffer); + this._gpuBuffer = null; + } + + this._buffer = null; + this._status = GFXStatus.UNREADY; + } + + public resize (size: number) { + this._size = size; + this._count = this._size / this._stride; + + if (this._memUsage & GFXMemoryUsageBit.HOST) { + if ((this._usage & GFXBufferUsageBit.INDIRECT) === GFXBufferUsageBit.NONE) { + this._buffer = new ArrayBuffer(this._size); + } + } + + if (this._gpuBuffer) { + if (this._buffer) { + if ((this._usage & GFXBufferUsageBit.INDIRECT) === GFXBufferUsageBit.NONE) { + this._gpuBuffer.buffer = this._buffer as ArrayBuffer; + this._gpuBuffer.size = this._gpuBuffer.buffer.byteLength; + } + } + + WebGL2CmdFuncResizeBuffer(this._device as WebGL2GFXDevice, this._gpuBuffer); + } + } + + public update (buffer: GFXBufferSource, offset?: number, size?: number) { + + let buffSize; + if (size !== undefined ) { + buffSize = size; + } else if (this._usage & GFXBufferUsageBit.INDIRECT) { + buffSize = 0; + } else { + buffSize = (buffer as ArrayBuffer).byteLength; + } + + WebGL2CmdFuncUpdateBuffer( + this._device as WebGL2GFXDevice, + this._gpuBuffer!, + buffer, + offset || 0, + buffSize); + } +} diff --git a/cocos/gfx/webgl2/webgl2-command-allocator.ts b/cocos/gfx/webgl2/webgl2-command-allocator.ts new file mode 100644 index 0000000000..f0a6582324 --- /dev/null +++ b/cocos/gfx/webgl2/webgl2-command-allocator.ts @@ -0,0 +1,148 @@ +import { CachedArray } from '../../core/memop/cached-array'; +import { GFXCommandAllocator, IGFXCommandAllocatorInfo } from '../command-allocator'; +import { GFXStatus } from '../define'; +import { GFXDevice } from '../device'; +import { + WebGL2CmdBeginRenderPass, + WebGL2CmdBindStates, + WebGL2CmdCopyBufferToTexture, + WebGL2CmdDraw, + WebGL2CmdObject, + WebGL2CmdPackage, + WebGL2CmdUpdateBuffer, +} from './webgl2-commands'; + +export class WebGL2GFXCommandPool { + + private _frees: Array; + private _freeIdx: number = 0; + private _freeCmds: CachedArray; + + constructor (clazz: new() => T, count: number) { + this._frees = new Array(count); + this._freeCmds = new CachedArray(count); + for (let i = 0; i < count; ++i) { + this._frees[i] = new clazz(); + } + this._freeIdx = count - 1; + } + + public alloc (clazz: new() => T): T { + return new clazz(); + } + + /* + public alloc (clazz: new() => T): T { + if (this._freeIdx < 0) { + const size = this._frees.length * 2; + const temp = this._frees; + this._frees = new Array(size); + + const increase = size - temp.length; + for (let i = 0; i < increase; ++i) { + this._frees[i] = new clazz(); + } + + for (let i = increase, j = 0; i < size; ++i, ++j) { + this._frees[i] = temp[j]; + } + + this._freeIdx += increase; + } + + const cmd = this._frees[this._freeIdx]!; + this._frees[this._freeIdx--] = null; + ++cmd.refCount; + return cmd; + } + */ + + public free (cmd: T) { + if (--cmd.refCount === 0) { + this._freeCmds.push(cmd); + } + } + + public freeCmds (cmds: CachedArray) { + return ; + for (let i = 0; i < cmds.length; ++i) { + if (--cmds.array[i].refCount === 0) { + this._freeCmds.push(cmds.array[i]); + } + } + } + + public release () { + for (let i = 0; i < this._freeCmds.length; ++i) { + const cmd = this._freeCmds.array[i]; + cmd.clear(); + this._frees[++this._freeIdx] = cmd; + } + this._freeCmds.clear(); + } +} + +export class WebGL2GFXCommandAllocator extends GFXCommandAllocator { + + public beginRenderPassCmdPool: WebGL2GFXCommandPool; + public bindStatesCmdPool: WebGL2GFXCommandPool; + public drawCmdPool: WebGL2GFXCommandPool; + public updateBufferCmdPool: WebGL2GFXCommandPool; + public copyBufferToTextureCmdPool: WebGL2GFXCommandPool; + + constructor (device: GFXDevice) { + super(device); + this.beginRenderPassCmdPool = new WebGL2GFXCommandPool(WebGL2CmdBeginRenderPass, 16); + this.bindStatesCmdPool = new WebGL2GFXCommandPool(WebGL2CmdBindStates, 16); + this.drawCmdPool = new WebGL2GFXCommandPool(WebGL2CmdDraw, 16); + this.updateBufferCmdPool = new WebGL2GFXCommandPool(WebGL2CmdUpdateBuffer, 16); + this.copyBufferToTextureCmdPool = new WebGL2GFXCommandPool(WebGL2CmdCopyBufferToTexture, 16); + } + + public initialize (info: IGFXCommandAllocatorInfo): boolean { + this._status = GFXStatus.SUCCESS; + return true; + } + + public destroy () { + this._status = GFXStatus.UNREADY; + } + + public clearCmds (cmdPackage: WebGL2CmdPackage) { + + if (cmdPackage.beginRenderPassCmds.length) { + this.beginRenderPassCmdPool.freeCmds(cmdPackage.beginRenderPassCmds); + cmdPackage.beginRenderPassCmds.clear(); + } + + if (cmdPackage.bindStatesCmds.length) { + this.bindStatesCmdPool.freeCmds(cmdPackage.bindStatesCmds); + cmdPackage.bindStatesCmds.clear(); + } + + if (cmdPackage.drawCmds.length) { + this.drawCmdPool.freeCmds(cmdPackage.drawCmds); + cmdPackage.drawCmds.clear(); + } + + if (cmdPackage.updateBufferCmds.length) { + this.updateBufferCmdPool.freeCmds(cmdPackage.updateBufferCmds); + cmdPackage.updateBufferCmds.clear(); + } + + if (cmdPackage.copyBufferToTextureCmds.length) { + this.copyBufferToTextureCmdPool.freeCmds(cmdPackage.copyBufferToTextureCmds); + cmdPackage.copyBufferToTextureCmds.clear(); + } + + cmdPackage.cmds.clear(); + } + + public releaseCmds () { + this.beginRenderPassCmdPool.release(); + this.bindStatesCmdPool.release(); + this.drawCmdPool.release(); + this.updateBufferCmdPool.release(); + this.copyBufferToTextureCmdPool.release(); + } +} diff --git a/cocos/gfx/webgl2/webgl2-command-buffer.ts b/cocos/gfx/webgl2/webgl2-command-buffer.ts new file mode 100644 index 0000000000..e96e8c40da --- /dev/null +++ b/cocos/gfx/webgl2/webgl2-command-buffer.ts @@ -0,0 +1,475 @@ +import { GFXBindingLayout } from '../binding-layout'; +import { GFXBuffer, GFXBufferSource } from '../buffer'; +import { GFXCommandBuffer, IGFXCommandBufferInfo } from '../command-buffer'; +import { + GFXBufferTextureCopy, + GFXBufferUsageBit, + GFXCommandBufferType, + GFXStatus, + GFXStencilFace, + GFXTextureLayout, + IGFXColor, + IGFXRect, + IGFXViewport, +} from '../define'; +import { GFXDevice } from '../device'; +import { GFXFramebuffer } from '../framebuffer'; +import { GFXInputAssembler } from '../input-assembler'; +import { GFXPipelineState } from '../pipeline-state'; +import { GFXTexture } from '../texture'; +import { WebGL2GFXBindingLayout } from './webgl2-binding-layout'; +import { WebGL2GFXBuffer } from './webgl2-buffer'; +import { WebGL2GFXCommandAllocator } from './webgl2-command-allocator'; +import { + WebGL2Cmd, + WebGL2CmdBeginRenderPass, + WebGL2CmdBindStates, + WebGL2CmdCopyBufferToTexture, + WebGL2CmdDraw, + WebGL2CmdPackage, + WebGL2CmdUpdateBuffer, +} from './webgl2-commands'; +import { WebGL2GFXDevice } from './webgl2-device'; +import { WebGL2GFXFramebuffer } from './webgl2-framebuffer'; +import { WebGL2GPUBindingLayout, WebGL2GPUInputAssembler, WebGL2GPUPipelineState } from './webgl2-gpu-objects'; +import { WebGL2GFXInputAssembler } from './webgl2-input-assembler'; +import { WebGL2GFXPipelineState } from './webgl2-pipeline-state'; +import { WebGL2GFXTexture } from './webgl2-texture'; + +export interface IWebGL2DepthBias { + constantFactor: number; + clamp: number; + slopeFactor: number; +} + +export interface IWebGL2DepthBounds { + minBounds: number; + maxBounds: number; +} + +export interface IWebGL2StencilWriteMask { + face: GFXStencilFace; + writeMask: number; +} + +export interface IWebGL2StencilCompareMask { + face: GFXStencilFace; + reference: number; + compareMask: number; +} + +export class WebGL2GFXCommandBuffer extends GFXCommandBuffer { + + public cmdPackage: WebGL2CmdPackage = new WebGL2CmdPackage(); + private _webGLAllocator: WebGL2GFXCommandAllocator | null = null; + private _isInRenderPass: boolean = false; + private _curGPUPipelineState: WebGL2GPUPipelineState | null = null; + private _curGPUBindingLayout: WebGL2GPUBindingLayout | null = null; + private _curGPUInputAssembler: WebGL2GPUInputAssembler | null = null; + private _curViewport: IGFXViewport | null = null; + private _curScissor: IGFXRect | null = null; + private _curLineWidth: number | null = null; + private _curDepthBias: IWebGL2DepthBias | null = null; + private _curBlendConstants: number[] = []; + private _curDepthBounds: IWebGL2DepthBounds | null = null; + private _curStencilWriteMask: IWebGL2StencilWriteMask | null = null; + private _curStencilCompareMask: IWebGL2StencilCompareMask | null = null; + private _isStateInvalied: boolean = false; + + constructor (device: GFXDevice) { + super(device); + } + + public initialize (info: IGFXCommandBufferInfo): boolean { + + if (!info.allocator) { + return false; + } + + this._allocator = info.allocator; + this._webGLAllocator = this._allocator as WebGL2GFXCommandAllocator; + this._type = info.type; + this._status = GFXStatus.SUCCESS; + + return true; + } + + public destroy () { + if (this._webGLAllocator) { + this._webGLAllocator.clearCmds(this.cmdPackage); + this._allocator = null; + this._webGLAllocator = null; + } + this._status = GFXStatus.UNREADY; + } + + public begin () { + this._webGLAllocator!.clearCmds(this.cmdPackage); + this._curGPUPipelineState = null; + this._curGPUBindingLayout = null; + this._curGPUInputAssembler = null; + this._curViewport = null; + this._curScissor = null; + this._curLineWidth = null; + this._curDepthBias = null; + this._curBlendConstants = []; + this._curDepthBounds = null; + this._curStencilWriteMask = null; + this._curStencilCompareMask = null; + } + + public end () { + if (this._isStateInvalied) { + this.bindStates(); + } + + this._isInRenderPass = false; + } + + public beginRenderPass ( + framebuffer: GFXFramebuffer, + renderArea: IGFXRect, + clearColors: IGFXColor[], + clearDepth: number, + clearStencil: number) { + const cmd = this._webGLAllocator!.beginRenderPassCmdPool.alloc(WebGL2CmdBeginRenderPass); + cmd.gpuFramebuffer = ( framebuffer as WebGL2GFXFramebuffer).gpuFramebuffer; + cmd.renderArea = renderArea; + cmd.clearColors = clearColors.slice(); + cmd.clearDepth = clearDepth; + cmd.clearStencil = clearStencil; + this.cmdPackage.beginRenderPassCmds.push(cmd); + + this.cmdPackage.cmds.push(WebGL2Cmd.BEGIN_RENDER_PASS); + + this._isInRenderPass = true; + } + + public endRenderPass () { + this._isInRenderPass = false; + } + + public bindPipelineState (pipelineState: GFXPipelineState) { + const gpuPipelineState = (pipelineState as WebGL2GFXPipelineState).gpuPipelineState; + this._curGPUPipelineState = gpuPipelineState; + this._isStateInvalied = true; + } + + public bindBindingLayout (bindingLayout: GFXBindingLayout) { + const gpuBindingLayout = (bindingLayout as WebGL2GFXBindingLayout).gpuBindingLayout; + this._curGPUBindingLayout = gpuBindingLayout; + this._isStateInvalied = true; + } + + public bindInputAssembler (inputAssembler: GFXInputAssembler) { + const gpuInputAssembler = (inputAssembler as WebGL2GFXInputAssembler).gpuInputAssembler; + this._curGPUInputAssembler = gpuInputAssembler; + this._isStateInvalied = true; + } + + public setViewport (viewport: IGFXViewport) { + if (!this._curViewport) { + this._curViewport = { + left: viewport.left, + top: viewport.top, + width: viewport.width, + height: viewport.height, + minDepth: viewport.minDepth, + maxDepth: viewport.maxDepth, + }; + } else { + if (this._curViewport.left !== viewport.left || + this._curViewport.top !== viewport.top || + this._curViewport.width !== viewport.width || + this._curViewport.height !== viewport.height || + this._curViewport.minDepth !== viewport.minDepth || + this._curViewport.maxDepth !== viewport.maxDepth) { + + this._curViewport.left = viewport.left; + this._curViewport.top = viewport.top; + this._curViewport.width = viewport.width; + this._curViewport.height = viewport.height; + this._curViewport.minDepth = viewport.minDepth; + this._curViewport.maxDepth = viewport.maxDepth; + this._isStateInvalied = true; + } + } + + if (this._curViewport !== viewport) { + this._curViewport = viewport; + this._isStateInvalied = true; + } + } + + public setScissor (scissor: IGFXRect) { + if (!this._curScissor) { + this._curScissor = { + x: scissor.x, + y: scissor.y, + width: scissor.width, + height: scissor.height, + }; + } else { + if (this._curScissor.x !== scissor.x || + this._curScissor.y !== scissor.y || + this._curScissor.width !== scissor.width || + this._curScissor.height !== scissor.height) { + this._curScissor.x = scissor.x; + this._curScissor.y = scissor.y; + this._curScissor.width = scissor.width; + this._curScissor.height = scissor.height; + this._isStateInvalied = true; + } + } + } + + public setLineWidth (lineWidth: number) { + if (this._curLineWidth !== lineWidth) { + this._curLineWidth = lineWidth; + this._isStateInvalied = true; + } + } + + public setDepthBias (depthBiasConstantFacotr: number, depthBiasClamp: number, depthBiasSlopeFactor: number) { + if (!this._curDepthBias) { + this._curDepthBias = { + constantFactor: depthBiasConstantFacotr, + clamp: depthBiasClamp, + slopeFactor: depthBiasSlopeFactor, + }; + this._isStateInvalied = true; + } else { + if (this._curDepthBias.constantFactor !== depthBiasConstantFacotr || + this._curDepthBias.clamp !== depthBiasClamp || + this._curDepthBias.slopeFactor !== depthBiasSlopeFactor) { + + this._curDepthBias.constantFactor = depthBiasConstantFacotr; + this._curDepthBias.clamp = depthBiasClamp; + this._curDepthBias.slopeFactor = depthBiasSlopeFactor; + this._isStateInvalied = true; + } + } + } + + public setBlendConstants (blendConstants: number[]) { + if (!this._curBlendConstants && + blendConstants.length === 4) { + this._curBlendConstants = [blendConstants[0], blendConstants[1], blendConstants[2], blendConstants[3]]; + this._isStateInvalied = true; + } else { + if (blendConstants.length === 4 && ( + this._curBlendConstants[0] !== blendConstants[0] || + this._curBlendConstants[1] !== blendConstants[1] || + this._curBlendConstants[2] !== blendConstants[2] || + this._curBlendConstants[3] !== blendConstants[3])) { + this._curBlendConstants = [blendConstants[0], blendConstants[1], blendConstants[2], blendConstants[3]]; + this._isStateInvalied = true; + } + } + } + + public setDepthBound (minDepthBounds: number, maxDepthBounds: number) { + if (!this._curDepthBounds) { + this._curDepthBounds = { + minBounds: minDepthBounds, + maxBounds: maxDepthBounds, + }; + this._isStateInvalied = true; + } else { + if (this._curDepthBounds.minBounds !== minDepthBounds || + this._curDepthBounds.maxBounds !== maxDepthBounds) { + this._curDepthBounds = { + minBounds: minDepthBounds, + maxBounds: maxDepthBounds, + }; + this._isStateInvalied = true; + } + } + } + + public setStencilWirteMask (face: GFXStencilFace, writeMask: number) { + if (!this._curStencilWriteMask) { + this._curStencilWriteMask = { + face, + writeMask, + }; + this._isStateInvalied = true; + } else { + if (this._curStencilWriteMask.face !== face || + this._curStencilWriteMask.writeMask !== writeMask) { + + this._curStencilWriteMask.face = face; + this._curStencilWriteMask.writeMask = writeMask; + this._isStateInvalied = true; + } + } + } + + public setStencilCompareMask (face: GFXStencilFace, reference: number, compareMask: number) { + if (!this._curStencilCompareMask) { + this._curStencilCompareMask = { + face, + reference, + compareMask, + }; + this._isStateInvalied = true; + } else { + if (this._curStencilCompareMask.face !== face || + this._curStencilCompareMask.reference !== reference || + this._curStencilCompareMask.compareMask !== compareMask) { + + this._curStencilCompareMask.face = face; + this._curStencilCompareMask.reference = reference; + this._curStencilCompareMask.compareMask = compareMask; + this._isStateInvalied = true; + } + } + } + + public draw (inputAssembler: GFXInputAssembler) { + if (this._type === GFXCommandBufferType.PRIMARY && this._isInRenderPass || + this._type === GFXCommandBufferType.SECONDARY) { + if (this._isStateInvalied) { + this.bindStates(); + } + + const cmd = ( this._allocator as WebGL2GFXCommandAllocator). + drawCmdPool.alloc(WebGL2CmdDraw); + if (cmd) { + (inputAssembler as WebGL2GFXInputAssembler).extractCmdDraw(cmd); + this.cmdPackage.drawCmds.push(cmd); + + this.cmdPackage.cmds.push(WebGL2Cmd.DRAW); + } + } else { + console.error('Command \'draw\' must be recorded inside a render pass.'); + } + } + + public updateBuffer (buffer: GFXBuffer, data: GFXBufferSource, offset?: number, size?: number) { + if (this._type === GFXCommandBufferType.PRIMARY && !this._isInRenderPass || + this._type === GFXCommandBufferType.SECONDARY) { + const gpuBuffer = (buffer as WebGL2GFXBuffer).gpuBuffer; + if (gpuBuffer) { + const cmd = this._webGLAllocator!.updateBufferCmdPool.alloc(WebGL2CmdUpdateBuffer); + if (cmd) { + + let buffSize; + if (size !== undefined ) { + buffSize = size; + } else if (buffer.usage & GFXBufferUsageBit.INDIRECT) { + buffSize = 0; + } else { + buffSize = (data as ArrayBuffer).byteLength; + } + + const buff = data as ArrayBuffer; + + cmd.gpuBuffer = gpuBuffer; + cmd.buffer = buff; + cmd.offset = (offset !== undefined ? offset : 0); + cmd.size = buffSize; + this.cmdPackage.updateBufferCmds.push(cmd); + + this.cmdPackage.cmds.push(WebGL2Cmd.UPDATE_BUFFER); + } + } + } else { + console.error('Command \'updateBuffer\' must be recorded outside a render pass.'); + } + } + + public copyBufferToTexture ( + srcBuff: GFXBuffer, + dstTex: GFXTexture, + dstLayout: GFXTextureLayout, + regions: GFXBufferTextureCopy[]) { + + if (this._type === GFXCommandBufferType.PRIMARY && !this._isInRenderPass || + this._type === GFXCommandBufferType.SECONDARY) { + const gpuBuffer = ( srcBuff as WebGL2GFXBuffer).gpuBuffer; + const gpuTexture = ( dstTex as WebGL2GFXTexture).gpuTexture; + if (gpuBuffer && gpuTexture) { + const cmd = this._webGLAllocator!.copyBufferToTextureCmdPool.alloc(WebGL2CmdCopyBufferToTexture); + if (cmd) { + cmd.gpuBuffer = gpuBuffer; + cmd.gpuTexture = gpuTexture; + cmd.dstLayout = dstLayout; + cmd.regions = regions; + this.cmdPackage.copyBufferToTextureCmds.push(cmd); + + this.cmdPackage.cmds.push(WebGL2Cmd.COPY_BUFFER_TO_TEXTURE); + } + } + } else { + console.error('Command \'copyBufferToTexture\' must be recorded outside a render pass.'); + } + } + + // tslint:disable: max-line-length + public execute (cmdBuffs: GFXCommandBuffer[], count: number) { + + for (let i = 0; i < count; ++i) { + const webGLCmdBuff = cmdBuffs[i] as WebGL2GFXCommandBuffer; + + for (let c = 0; c < webGLCmdBuff.cmdPackage.beginRenderPassCmds.length; ++c) { + const cmd = webGLCmdBuff.cmdPackage.beginRenderPassCmds.array[c]; + ++cmd.refCount; + this.cmdPackage.beginRenderPassCmds.push(cmd); + } + + for (let c = 0; c < webGLCmdBuff.cmdPackage.bindStatesCmds.length; ++c) { + const cmd = webGLCmdBuff.cmdPackage.bindStatesCmds.array[c]; + ++cmd.refCount; + this.cmdPackage.bindStatesCmds.push(cmd); + } + + for (let c = 0; c < webGLCmdBuff.cmdPackage.drawCmds.length; ++c) { + const cmd = webGLCmdBuff.cmdPackage.drawCmds.array[c]; + ++cmd.refCount; + this.cmdPackage.drawCmds.push(cmd); + } + + for (let c = 0; c < webGLCmdBuff.cmdPackage.updateBufferCmds.length; ++c) { + const cmd = webGLCmdBuff.cmdPackage.updateBufferCmds.array[c]; + ++cmd.refCount; + this.cmdPackage.updateBufferCmds.push(cmd); + } + + for (let c = 0; c < webGLCmdBuff.cmdPackage.copyBufferToTextureCmds.length; ++c) { + const cmd = webGLCmdBuff.cmdPackage.copyBufferToTextureCmds.array[c]; + ++cmd.refCount; + this.cmdPackage.copyBufferToTextureCmds.push(cmd); + } + + this.cmdPackage.cmds.concat(webGLCmdBuff.cmdPackage.cmds); + } + } + + public get webGLDevice (): WebGL2GFXDevice { + return this._device as WebGL2GFXDevice; + } + + private bindStates () { + const bindStatesCmd = this._webGLAllocator!.bindStatesCmdPool.alloc(WebGL2CmdBindStates); + + if (bindStatesCmd) { + bindStatesCmd.gpuPipelineState = this._curGPUPipelineState; + bindStatesCmd.gpuBindingLayout = this._curGPUBindingLayout; + bindStatesCmd.gpuInputAssembler = this._curGPUInputAssembler; + bindStatesCmd.viewport = this._curViewport; + bindStatesCmd.scissor = this._curScissor; + bindStatesCmd.lineWidth = this._curLineWidth; + bindStatesCmd.depthBias = this._curDepthBias; + bindStatesCmd.blendConstants = this._curBlendConstants; + bindStatesCmd.depthBounds = this._curDepthBounds; + bindStatesCmd.stencilWriteMask = this._curStencilWriteMask; + bindStatesCmd.stencilCompareMask = this._curStencilCompareMask; + + this.cmdPackage.bindStatesCmds.push(bindStatesCmd); + this.cmdPackage.cmds.push(WebGL2Cmd.BIND_STATES); + + this._isStateInvalied = false; + } + } +} diff --git a/cocos/gfx/webgl2/webgl2-commands.ts b/cocos/gfx/webgl2/webgl2-commands.ts new file mode 100644 index 0000000000..efec3fac11 --- /dev/null +++ b/cocos/gfx/webgl2/webgl2-commands.ts @@ -0,0 +1,2371 @@ +import { CachedArray } from '../../core/memop/cached-array'; +import { GFXBufferSource, IGFXDrawInfo, IGFXIndirectBuffer } from '../buffer'; +import { + GFXBindingType, + GFXBufferTextureCopy, + GFXBufferUsageBit, + GFXColorMask, + GFXCullMode, + GFXDynamicState, + GFXFormat, + GFXFormatInfos, + GFXFormatSize, + GFXLoadOp, + GFXMemoryUsageBit, + GFXShaderType, + GFXStencilFace, + GFXTextureFlagBit, + GFXTextureLayout, + GFXTextureViewType, + GFXType, + IGFXColor, + IGFXFormatInfo, + IGFXRect, + IGFXViewport, + WebGLEXT, +} from '../define'; +import { WebGL2GFXCommandAllocator } from './webgl2-command-allocator'; +import { + IWebGL2DepthBias, + IWebGL2DepthBounds, + IWebGL2StencilCompareMask, + IWebGL2StencilWriteMask, +} from './webgl2-command-buffer'; +import { WebGL2GFXDevice } from './webgl2-device'; +import { + IWebGL2GPUUniform, + WebGL2Attrib, + WebGL2GPUBindingLayout, + WebGL2GPUBuffer, + WebGL2GPUFramebuffer, + WebGL2GPUInput, + WebGL2GPUInputAssembler, + WebGL2GPUPipelineState, + WebGL2GPUShader, + WebGL2GPUTexture, + WebGL2GPUUniformBlock, + WebGL2GPUUniformSampler, +} from './webgl2-gpu-objects'; +import { IWebGL2TexUnit } from './webgl2-state-cache'; + +const _uniformValues = new Array(1024 * 4); + +// tslint:disable: max-line-length + +function CmpF32NotEuqal (a: number, b: number): boolean { + const c = a - b; + return (c > 0.000001 || c < -0.000001); +} + +function GFXFormatToWebGLType (format: GFXFormat, device: WebGL2GFXDevice): GLenum { + switch (format) { + case GFXFormat.R8: return WebGL2RenderingContext.UNSIGNED_BYTE; + case GFXFormat.R8SN: return WebGL2RenderingContext.BYTE; + case GFXFormat.R8UI: return WebGL2RenderingContext.UNSIGNED_BYTE; + case GFXFormat.R8I: return WebGL2RenderingContext.BYTE; + case GFXFormat.R16F: return WebGL2RenderingContext.HALF_FLOAT; + case GFXFormat.R16UI: return WebGL2RenderingContext.UNSIGNED_SHORT; + case GFXFormat.R16I: return WebGL2RenderingContext.SHORT; + case GFXFormat.R32F: return WebGL2RenderingContext.FLOAT; + case GFXFormat.R32UI: return WebGL2RenderingContext.UNSIGNED_INT; + case GFXFormat.R32I: return WebGL2RenderingContext.INT; + + case GFXFormat.RG8: return WebGL2RenderingContext.UNSIGNED_BYTE; + case GFXFormat.RG8SN: return WebGL2RenderingContext.BYTE; + case GFXFormat.RG8UI: return WebGL2RenderingContext.UNSIGNED_BYTE; + case GFXFormat.RG8I: return WebGL2RenderingContext.BYTE; + case GFXFormat.RG16F: return WebGL2RenderingContext.HALF_FLOAT; + case GFXFormat.RG16UI: return WebGL2RenderingContext.UNSIGNED_SHORT; + case GFXFormat.RG16I: return WebGL2RenderingContext.SHORT; + case GFXFormat.RG32F: return WebGL2RenderingContext.FLOAT; + case GFXFormat.RG32UI: return WebGL2RenderingContext.UNSIGNED_INT; + case GFXFormat.RG32I: return WebGL2RenderingContext.INT; + + case GFXFormat.RGB8: return WebGL2RenderingContext.UNSIGNED_BYTE; + case GFXFormat.SRGB8: return WebGL2RenderingContext.UNSIGNED_BYTE; + case GFXFormat.RGB8SN: return WebGL2RenderingContext.BYTE; + case GFXFormat.RGB8UI: return WebGL2RenderingContext.UNSIGNED_BYTE; + case GFXFormat.RGB8I: return WebGL2RenderingContext.BYTE; + case GFXFormat.RGB16F: return WebGL2RenderingContext.HALF_FLOAT; + case GFXFormat.RGB16UI: return WebGL2RenderingContext.UNSIGNED_SHORT; + case GFXFormat.RGB16I: return WebGL2RenderingContext.SHORT; + case GFXFormat.RGB32F: return WebGL2RenderingContext.FLOAT; + case GFXFormat.RGB32UI: return WebGL2RenderingContext.UNSIGNED_INT; + case GFXFormat.RGB32I: return WebGL2RenderingContext.INT; + + case GFXFormat.RGBA8: return WebGL2RenderingContext.UNSIGNED_BYTE; + case GFXFormat.SRGB8_A8: return WebGL2RenderingContext.UNSIGNED_BYTE; + case GFXFormat.RGBA8SN: return WebGL2RenderingContext.BYTE; + case GFXFormat.RGBA8UI: return WebGL2RenderingContext.UNSIGNED_BYTE; + case GFXFormat.RGBA8I: return WebGL2RenderingContext.BYTE; + case GFXFormat.RGBA16F: return WebGL2RenderingContext.HALF_FLOAT; + case GFXFormat.RGBA16UI: return WebGL2RenderingContext.UNSIGNED_SHORT; + case GFXFormat.RGBA16I: return WebGL2RenderingContext.SHORT; + case GFXFormat.RGBA32F: return WebGL2RenderingContext.FLOAT; + case GFXFormat.RGBA32UI: return WebGL2RenderingContext.UNSIGNED_INT; + case GFXFormat.RGBA32I: return WebGL2RenderingContext.INT; + + case GFXFormat.R5G6B5: return WebGL2RenderingContext.UNSIGNED_SHORT_5_6_5; + case GFXFormat.R11G11B10F: return WebGL2RenderingContext.FLOAT; + case GFXFormat.RGB5A1: return WebGL2RenderingContext.UNSIGNED_SHORT_5_5_5_1; + case GFXFormat.RGBA4: return WebGL2RenderingContext.UNSIGNED_SHORT_4_4_4_4; + case GFXFormat.RGB10A2: return WebGL2RenderingContext.UNSIGNED_BYTE; + case GFXFormat.RGB10A2UI: return WebGL2RenderingContext.UNSIGNED_INT; + case GFXFormat.RGB9E5: return WebGL2RenderingContext.UNSIGNED_BYTE; + + case GFXFormat.D16: return WebGL2RenderingContext.UNSIGNED_SHORT; + case GFXFormat.D16S8: return WebGL2RenderingContext.UNSIGNED_SHORT; + case GFXFormat.D24: return WebGL2RenderingContext.UNSIGNED_INT; + case GFXFormat.D24S8: return WebGL2RenderingContext.DEPTH24_STENCIL8; + case GFXFormat.D32F: return WebGL2RenderingContext.FLOAT; + case GFXFormat.D32F_S8: return WebGL2RenderingContext.DEPTH32F_STENCIL8; + + case GFXFormat.BC1: return WebGL2RenderingContext.UNSIGNED_BYTE; + case GFXFormat.BC1_SRGB: return WebGL2RenderingContext.UNSIGNED_BYTE; + case GFXFormat.BC2: return WebGL2RenderingContext.UNSIGNED_BYTE; + case GFXFormat.BC2_SRGB: return WebGL2RenderingContext.UNSIGNED_BYTE; + case GFXFormat.BC3: return WebGL2RenderingContext.UNSIGNED_BYTE; + case GFXFormat.BC3_SRGB: return WebGL2RenderingContext.UNSIGNED_BYTE; + case GFXFormat.BC4: return WebGL2RenderingContext.UNSIGNED_BYTE; + case GFXFormat.BC4_SNORM: return WebGL2RenderingContext.BYTE; + case GFXFormat.BC5: return WebGL2RenderingContext.UNSIGNED_BYTE; + case GFXFormat.BC5_SNORM: return WebGL2RenderingContext.BYTE; + case GFXFormat.BC6H_SF16: return WebGL2RenderingContext.FLOAT; + case GFXFormat.BC6H_UF16: return WebGL2RenderingContext.FLOAT; + case GFXFormat.BC7: return WebGL2RenderingContext.UNSIGNED_BYTE; + case GFXFormat.BC7_SRGB: return WebGL2RenderingContext.UNSIGNED_BYTE; + + case GFXFormat.ETC_RGB8: return WebGL2RenderingContext.UNSIGNED_BYTE; + case GFXFormat.ETC2_RGB8: return WebGL2RenderingContext.UNSIGNED_BYTE; + case GFXFormat.ETC2_SRGB8: return WebGL2RenderingContext.UNSIGNED_BYTE; + case GFXFormat.ETC2_RGB8_A1: return WebGL2RenderingContext.UNSIGNED_BYTE; + case GFXFormat.ETC2_SRGB8_A1: return WebGL2RenderingContext.UNSIGNED_BYTE; + case GFXFormat.ETC2_RGB8: return WebGL2RenderingContext.UNSIGNED_BYTE; + case GFXFormat.ETC2_SRGB8: return WebGL2RenderingContext.UNSIGNED_BYTE; + case GFXFormat.EAC_R11: return WebGL2RenderingContext.UNSIGNED_BYTE; + case GFXFormat.EAC_R11SN: return WebGL2RenderingContext.BYTE; + case GFXFormat.EAC_RG11: return WebGL2RenderingContext.UNSIGNED_BYTE; + case GFXFormat.EAC_RG11SN: return WebGL2RenderingContext.BYTE; + + case GFXFormat.PVRTC_RGB2: return WebGL2RenderingContext.UNSIGNED_BYTE; + case GFXFormat.PVRTC_RGBA2: return WebGL2RenderingContext.UNSIGNED_BYTE; + case GFXFormat.PVRTC_RGB4: return WebGL2RenderingContext.UNSIGNED_BYTE; + case GFXFormat.PVRTC_RGBA4: return WebGL2RenderingContext.UNSIGNED_BYTE; + case GFXFormat.PVRTC2_2BPP: return WebGL2RenderingContext.UNSIGNED_BYTE; + case GFXFormat.PVRTC2_4BPP: return WebGL2RenderingContext.UNSIGNED_BYTE; + + default: { + return WebGL2RenderingContext.UNSIGNED_BYTE; + } + } +} + +function GFXFormatToWebGLInternalFormat (format: GFXFormat): GLenum { + switch (format) { + case GFXFormat.A8: return WebGLRenderingContext.ALPHA; + case GFXFormat.L8: return WebGLRenderingContext.LUMINANCE; + case GFXFormat.LA8: return WebGLRenderingContext.LUMINANCE_ALPHA; + case GFXFormat.RGB8: return WebGLRenderingContext.RGB; + case GFXFormat.RGB16F: return WebGLRenderingContext.RGB; + case GFXFormat.RGB32F: return WebGLRenderingContext.RGB; + case GFXFormat.RGBA8: return WebGLRenderingContext.RGBA; + case GFXFormat.RGBA16F: return WebGLRenderingContext.RGBA; + case GFXFormat.RGBA32F: return WebGLRenderingContext.RGBA; + case GFXFormat.R5G6B5: return WebGLRenderingContext.RGB565; + case GFXFormat.RGB5A1: return WebGLRenderingContext.RGB5_A1; + case GFXFormat.RGBA4: return WebGLRenderingContext.RGBA4; + case GFXFormat.D16: return WebGLRenderingContext.DEPTH_COMPONENT16; + case GFXFormat.D16S8: return WebGLRenderingContext.DEPTH_STENCIL; + case GFXFormat.D24: return WebGLRenderingContext.DEPTH_COMPONENT; + case GFXFormat.D24S8: return WebGLRenderingContext.DEPTH_STENCIL; + case GFXFormat.D32F: return WebGLRenderingContext.DEPTH_COMPONENT; + case GFXFormat.D32F_S8: return WebGLRenderingContext.DEPTH_STENCIL; + + case GFXFormat.BC1: return WebGLEXT.COMPRESSED_RGB_S3TC_DXT1_EXT; + case GFXFormat.BC1_ALPHA: return WebGLEXT.COMPRESSED_RGBA_S3TC_DXT1_EXT; + case GFXFormat.BC1_SRGB: return WebGLEXT.COMPRESSED_SRGB_S3TC_DXT1_EXT; + case GFXFormat.BC1_SRGB_ALPHA: return WebGLEXT.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT; + case GFXFormat.BC2: return WebGLEXT.COMPRESSED_RGBA_S3TC_DXT3_EXT; + case GFXFormat.BC2_SRGB: return WebGLEXT.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT; + case GFXFormat.BC3: return WebGLEXT.COMPRESSED_RGBA_S3TC_DXT5_EXT; + case GFXFormat.BC3_SRGB: return WebGLEXT.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT; + + case GFXFormat.ETC_RGB8: return WebGLEXT.COMPRESSED_RGB_ETC1_WEBGL; + + case GFXFormat.PVRTC_RGB2: return WebGLEXT.COMPRESSED_RGB_PVRTC_2BPPV1_IMG; + case GFXFormat.PVRTC_RGBA2: return WebGLEXT.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG; + case GFXFormat.PVRTC_RGB4: return WebGLEXT.COMPRESSED_RGB_PVRTC_4BPPV1_IMG; + case GFXFormat.PVRTC_RGBA4: return WebGLEXT.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG; + + default: { + console.error('Unsupported GFXFormat, convert to WebGL internal format failed.'); + return WebGLRenderingContext.RGBA; + } + } +} + +function GFXFormatToWebGLFormat (format: GFXFormat): GLenum { + switch (format) { + case GFXFormat.A8: return WebGLRenderingContext.ALPHA; + case GFXFormat.L8: return WebGLRenderingContext.LUMINANCE; + case GFXFormat.LA8: return WebGLRenderingContext.LUMINANCE_ALPHA; + case GFXFormat.RGB8: return WebGLRenderingContext.RGB; + case GFXFormat.RGB16F: return WebGLRenderingContext.RGB; + case GFXFormat.RGB32F: return WebGLRenderingContext.RGB; + case GFXFormat.RGBA8: return WebGLRenderingContext.RGBA; + case GFXFormat.RGBA16F: return WebGLRenderingContext.RGBA; + case GFXFormat.RGBA32F: return WebGLRenderingContext.RGBA; + case GFXFormat.R5G6B5: return WebGLRenderingContext.RGB; + case GFXFormat.RGB5A1: return WebGLRenderingContext.RGBA; + case GFXFormat.RGBA4: return WebGLRenderingContext.RGBA; + case GFXFormat.D16: return WebGLRenderingContext.DEPTH_COMPONENT; + case GFXFormat.D16S8: return WebGLRenderingContext.DEPTH_STENCIL; + case GFXFormat.D24: return WebGLRenderingContext.DEPTH_COMPONENT; + case GFXFormat.D24S8: return WebGLRenderingContext.DEPTH_STENCIL; + case GFXFormat.D32F: return WebGLRenderingContext.DEPTH_COMPONENT; + case GFXFormat.D32F_S8: return WebGLRenderingContext.DEPTH_STENCIL; + + case GFXFormat.BC1: return WebGLEXT.COMPRESSED_RGB_S3TC_DXT1_EXT; + case GFXFormat.BC1_ALPHA: return WebGLEXT.COMPRESSED_RGBA_S3TC_DXT1_EXT; + case GFXFormat.BC1_SRGB: return WebGLEXT.COMPRESSED_SRGB_S3TC_DXT1_EXT; + case GFXFormat.BC1_SRGB_ALPHA: return WebGLEXT.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT; + case GFXFormat.BC2: return WebGLEXT.COMPRESSED_RGBA_S3TC_DXT3_EXT; + case GFXFormat.BC2_SRGB: return WebGLEXT.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT; + case GFXFormat.BC3: return WebGLEXT.COMPRESSED_RGBA_S3TC_DXT5_EXT; + case GFXFormat.BC3_SRGB: return WebGLEXT.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT; + + case GFXFormat.ETC_RGB8: return WebGLEXT.COMPRESSED_RGB_ETC1_WEBGL; + + case GFXFormat.PVRTC_RGB2: return WebGLEXT.COMPRESSED_RGB_PVRTC_2BPPV1_IMG; + case GFXFormat.PVRTC_RGBA2: return WebGLEXT.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG; + case GFXFormat.PVRTC_RGB4: return WebGLEXT.COMPRESSED_RGB_PVRTC_4BPPV1_IMG; + case GFXFormat.PVRTC_RGBA4: return WebGLEXT.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG; + + default: { + console.error('Unsupported GFXFormat, convert to WebGL format failed.'); + return WebGLRenderingContext.RGBA; + } + } +} + +function GFXTypeToWebGLType (type: GFXType): GLenum { + switch (type) { + case GFXType.BOOL: return WebGL2RenderingContext.BOOL; + case GFXType.BOOL2: return WebGL2RenderingContext.BOOL_VEC2; + case GFXType.BOOL3: return WebGL2RenderingContext.BOOL_VEC3; + case GFXType.BOOL4: return WebGL2RenderingContext.BOOL_VEC4; + case GFXType.INT: return WebGL2RenderingContext.INT; + case GFXType.INT2: return WebGL2RenderingContext.INT_VEC2; + case GFXType.INT3: return WebGL2RenderingContext.INT_VEC3; + case GFXType.INT4: return WebGL2RenderingContext.INT_VEC4; + case GFXType.UINT: return WebGL2RenderingContext.UNSIGNED_INT; + case GFXType.FLOAT: return WebGL2RenderingContext.FLOAT; + case GFXType.FLOAT2: return WebGL2RenderingContext.FLOAT_VEC2; + case GFXType.FLOAT3: return WebGL2RenderingContext.FLOAT_VEC3; + case GFXType.FLOAT4: return WebGL2RenderingContext.FLOAT_VEC4; + case GFXType.COLOR4: return WebGL2RenderingContext.FLOAT_VEC4; + case GFXType.MAT2: return WebGL2RenderingContext.FLOAT_MAT2; + case GFXType.MAT2X3: return WebGL2RenderingContext.FLOAT_MAT2x3; + case GFXType.MAT2X4: return WebGL2RenderingContext.FLOAT_MAT2x4; + case GFXType.MAT3X2: return WebGL2RenderingContext.FLOAT_MAT3x2; + case GFXType.MAT3: return WebGL2RenderingContext.FLOAT_MAT3; + case GFXType.MAT3X4: return WebGL2RenderingContext.FLOAT_MAT3x4; + case GFXType.MAT4X2: return WebGL2RenderingContext.FLOAT_MAT4x2; + case GFXType.MAT4X3: return WebGL2RenderingContext.FLOAT_MAT4x3; + case GFXType.MAT4: return WebGL2RenderingContext.FLOAT_MAT4; + case GFXType.SAMPLER2D: return WebGL2RenderingContext.SAMPLER_2D; + case GFXType.SAMPLER2D_ARRAY: return WebGL2RenderingContext.SAMPLER_2D_ARRAY; + case GFXType.SAMPLER3D: return WebGL2RenderingContext.SAMPLER_3D; + case GFXType.SAMPLER_CUBE: return WebGL2RenderingContext.SAMPLER_CUBE; + default: { + console.error('Unsupported GLType, convert to GL type failed.'); + return GFXType.UNKNOWN; + } + } +} + +function WebGLTypeToGFXType (glType: GLenum): GFXType { + switch (glType) { + case WebGLRenderingContext.BOOL: return GFXType.BOOL; + case WebGLRenderingContext.BOOL_VEC2: return GFXType.BOOL2; + case WebGLRenderingContext.BOOL_VEC3: return GFXType.BOOL3; + case WebGLRenderingContext.BOOL_VEC4: return GFXType.BOOL4; + case WebGLRenderingContext.INT: return GFXType.INT; + case WebGLRenderingContext.INT_VEC2: return GFXType.INT2; + case WebGLRenderingContext.INT_VEC3: return GFXType.INT3; + case WebGLRenderingContext.INT_VEC4: return GFXType.INT4; + case WebGLRenderingContext.UNSIGNED_INT: return GFXType.UINT; + case WebGLRenderingContext.FLOAT: return GFXType.FLOAT; + case WebGLRenderingContext.FLOAT_VEC2: return GFXType.FLOAT2; + case WebGLRenderingContext.FLOAT_VEC3: return GFXType.FLOAT3; + case WebGLRenderingContext.FLOAT_VEC4: return GFXType.FLOAT4; + case WebGLRenderingContext.FLOAT_MAT2: return GFXType.MAT2; + case WebGLRenderingContext.FLOAT_MAT3: return GFXType.MAT3; + case WebGLRenderingContext.FLOAT_MAT4: return GFXType.MAT4; + case WebGLRenderingContext.SAMPLER_2D: return GFXType.SAMPLER2D; + case WebGLRenderingContext.SAMPLER_CUBE: return GFXType.SAMPLER_CUBE; + default: { + console.error('Unsupported GLType, convert to GFXType failed.'); + return GFXType.UNKNOWN; + } + } +} + +function WebGLGetTypeSize (glType: GLenum): GFXType { + switch (glType) { + case WebGL2RenderingContext.BOOL: return 4; + case WebGL2RenderingContext.BOOL_VEC2: return 8; + case WebGL2RenderingContext.BOOL_VEC3: return 12; + case WebGL2RenderingContext.BOOL_VEC4: return 16; + case WebGL2RenderingContext.INT: return 4; + case WebGL2RenderingContext.INT_VEC2: return 8; + case WebGL2RenderingContext.INT_VEC3: return 12; + case WebGL2RenderingContext.INT_VEC4: return 16; + case WebGL2RenderingContext.UNSIGNED_INT: return 4; + case WebGL2RenderingContext.UNSIGNED_INT_VEC2: return 8; + case WebGL2RenderingContext.UNSIGNED_INT_VEC3: return 12; + case WebGL2RenderingContext.UNSIGNED_INT_VEC4: return 16; + case WebGL2RenderingContext.FLOAT: return 4; + case WebGL2RenderingContext.FLOAT_VEC2: return 8; + case WebGL2RenderingContext.FLOAT_VEC3: return 12; + case WebGL2RenderingContext.FLOAT_VEC4: return 16; + case WebGL2RenderingContext.FLOAT_MAT2: return 16; + case WebGL2RenderingContext.FLOAT_MAT2x3: return 24; + case WebGL2RenderingContext.FLOAT_MAT2x4: return 32; + case WebGL2RenderingContext.FLOAT_MAT3x2: return 24; + case WebGL2RenderingContext.FLOAT_MAT3: return 36; + case WebGL2RenderingContext.FLOAT_MAT3x4: return 48; + case WebGL2RenderingContext.FLOAT_MAT4x2: return 32; + case WebGL2RenderingContext.FLOAT_MAT4x3: return 48; + case WebGL2RenderingContext.FLOAT_MAT4: return 64; + case WebGL2RenderingContext.SAMPLER_2D: return 4; + case WebGL2RenderingContext.SAMPLER_2D_ARRAY: return 4; + case WebGL2RenderingContext.SAMPLER_2D_ARRAY_SHADOW: return 4; + case WebGL2RenderingContext.SAMPLER_3D: return 4; + case WebGL2RenderingContext.SAMPLER_CUBE: return 4; + case WebGL2RenderingContext.INT_SAMPLER_2D: return 4; + case WebGL2RenderingContext.INT_SAMPLER_2D_ARRAY: return 4; + case WebGL2RenderingContext.INT_SAMPLER_3D: return 4; + case WebGL2RenderingContext.INT_SAMPLER_CUBE: return 4; + case WebGL2RenderingContext.UNSIGNED_INT_SAMPLER_2D: return 4; + case WebGL2RenderingContext.UNSIGNED_INT_SAMPLER_2D_ARRAY: return 4; + case WebGL2RenderingContext.UNSIGNED_INT_SAMPLER_3D: return 4; + case WebGL2RenderingContext.UNSIGNED_INT_SAMPLER_CUBE: return 4; + default: { + console.error('Unsupported GLType, get type failed.'); + return 0; + } + } +} + +function WebGLGetComponentCount (glType: GLenum): GFXType { + switch (glType) { + case WebGL2RenderingContext.FLOAT_MAT2: return 2; + case WebGL2RenderingContext.FLOAT_MAT2x3: return 2; + case WebGL2RenderingContext.FLOAT_MAT2x4: return 2; + case WebGL2RenderingContext.FLOAT_MAT3x2: return 3; + case WebGL2RenderingContext.FLOAT_MAT3: return 3; + case WebGL2RenderingContext.FLOAT_MAT3x4: return 3; + case WebGL2RenderingContext.FLOAT_MAT4x2: return 4; + case WebGL2RenderingContext.FLOAT_MAT4x3: return 4; + case WebGL2RenderingContext.FLOAT_MAT4: return 4; + default: { + return 1; + } + } +} + +const WebGLCmpFuncs: GLenum[] = [ + WebGL2RenderingContext.NEVER, + WebGL2RenderingContext.LESS, + WebGL2RenderingContext.EQUAL, + WebGL2RenderingContext.LEQUAL, + WebGL2RenderingContext.GREATER, + WebGL2RenderingContext.NOTEQUAL, + WebGL2RenderingContext.GEQUAL, + WebGL2RenderingContext.ALWAYS, +]; + +const WebGLStencilOps: GLenum[] = [ + WebGL2RenderingContext.KEEP, + WebGL2RenderingContext.ZERO, + WebGL2RenderingContext.REPLACE, + WebGL2RenderingContext.INCR, + WebGL2RenderingContext.DECR, + WebGL2RenderingContext.INVERT, + WebGL2RenderingContext.INCR_WRAP, + WebGL2RenderingContext.DECR_WRAP, +]; + +const WebGLBlendOps: GLenum[] = [ + WebGL2RenderingContext.FUNC_ADD, + WebGL2RenderingContext.FUNC_SUBTRACT, + WebGL2RenderingContext.FUNC_REVERSE_SUBTRACT, + WebGL2RenderingContext.FUNC_ADD, + WebGL2RenderingContext.FUNC_ADD, +]; + +const WebGLBlendFactors: GLenum[] = [ + WebGL2RenderingContext.ZERO, + WebGL2RenderingContext.ONE, + WebGL2RenderingContext.SRC_ALPHA, + WebGL2RenderingContext.DST_ALPHA, + WebGL2RenderingContext.ONE_MINUS_SRC_ALPHA, + WebGL2RenderingContext.ONE_MINUS_DST_ALPHA, + WebGL2RenderingContext.SRC_COLOR, + WebGL2RenderingContext.DST_COLOR, + WebGL2RenderingContext.SRC_ALPHA_SATURATE, + WebGL2RenderingContext.CONSTANT_COLOR, + WebGL2RenderingContext.ONE_MINUS_CONSTANT_COLOR, + WebGL2RenderingContext.CONSTANT_ALPHA, + WebGL2RenderingContext.ONE_MINUS_CONSTANT_ALPHA, +]; + +export enum WebGL2Cmd { + BEGIN_RENDER_PASS, + END_RENDER_PASS, + BIND_STATES, + DRAW, + UPDATE_BUFFER, + COPY_BUFFER_TO_TEXTURE, + COUNT, +} + +export abstract class WebGL2CmdObject { + public cmdType: WebGL2Cmd; + public refCount: number = 0; + + constructor (type: WebGL2Cmd) { + this.cmdType = type; + } + + public abstract clear (); +} + +export class WebGL2CmdBeginRenderPass extends WebGL2CmdObject { + + public gpuFramebuffer: WebGL2GPUFramebuffer | null = null; + public renderArea: IGFXRect = { x: 0, y: 0, width: 0, height: 0 }; + public clearColors: IGFXColor[] = []; + public clearDepth: number = 1.0; + public clearStencil: number = 0; + + constructor () { + super(WebGL2Cmd.BEGIN_RENDER_PASS); + } + + public clear () { + this.gpuFramebuffer = null; + this.clearColors = []; + } +} + +export class WebGL2CmdBindStates extends WebGL2CmdObject { + + public gpuPipelineState: WebGL2GPUPipelineState | null = null; + public gpuBindingLayout: WebGL2GPUBindingLayout | null = null; + public gpuInputAssembler: WebGL2GPUInputAssembler | null = null; + public viewport: IGFXViewport | null = null; + public scissor: IGFXRect | null = null; + public lineWidth: number | null = null; + public depthBias: IWebGL2DepthBias | null = null; + public blendConstants: number[] | null = null; + public depthBounds: IWebGL2DepthBounds | null = null; + public stencilWriteMask: IWebGL2StencilWriteMask | null = null; + public stencilCompareMask: IWebGL2StencilCompareMask | null = null; + + constructor () { + super(WebGL2Cmd.BIND_STATES); + } + + public clear () { + this.gpuPipelineState = null; + this.gpuBindingLayout = null; + this.gpuInputAssembler = null; + this.viewport = null; + this.scissor = null; + this.lineWidth = null; + this.depthBias = null; + this.blendConstants = null; + this.depthBounds = null; + this.stencilWriteMask = null; + this.stencilCompareMask = null; + } +} + +export class WebGL2CmdDraw extends WebGL2CmdObject { + + public drawInfo: IGFXDrawInfo = { + vertexCount: 0, + firstVertex: 0, + indexCount: 0, + firstIndex: 0, + vertexOffset: 0, + instanceCount: 0, + firstInstance: 0, + }; + + constructor () { + super(WebGL2Cmd.DRAW); + } + + public clear () { + } +} + +export class WebGL2CmdUpdateBuffer extends WebGL2CmdObject { + + public gpuBuffer: WebGL2GPUBuffer | null = null; + public buffer: GFXBufferSource | null = null; + public offset: number = 0; + public size: number = 0; + + constructor () { + super(WebGL2Cmd.UPDATE_BUFFER); + } + + public clear () { + this.gpuBuffer = null; + this.buffer = null; + } +} + +export class WebGL2GFXTextureSubres { + public baseMipLevel: number = 0; + public levelCount: number = 1; + public baseArrayLayer: number = 0; + public layerCount: number = 1; +} + +export class WebGL2GFXBufferTextureCopy { + public buffOffset: number = 0; + public buffStride: number = 0; + public buffTexHeight: number = 0; + public texOffset: number[] = [0, 0, 0]; + public texExtent: number[] = [0, 0, 0]; + public texSubres: WebGL2GFXTextureSubres = new WebGL2GFXTextureSubres(); +} + +export class WebGL2CmdCopyBufferToTexture extends WebGL2CmdObject { + + public gpuBuffer: WebGL2GPUBuffer | null = null; + public gpuTexture: WebGL2GPUTexture | null = null; + public dstLayout: GFXTextureLayout | null = null; + public regions: GFXBufferTextureCopy[] = []; + + constructor () { + super(WebGL2Cmd.COPY_BUFFER_TO_TEXTURE); + } + + public clear () { + this.gpuBuffer = null; + this.gpuTexture = null; + this.dstLayout = null; + this.regions = []; + } +} + +export class WebGL2CmdPackage { + public cmds: CachedArray = new CachedArray(1); + public beginRenderPassCmds: CachedArray = new CachedArray(1); + public bindStatesCmds: CachedArray = new CachedArray(1); + public drawCmds: CachedArray = new CachedArray(1); + public updateBufferCmds: CachedArray = new CachedArray(1); + public copyBufferToTextureCmds: CachedArray = new CachedArray(1); + + public clearCmds (allocator: WebGL2GFXCommandAllocator) { + + if (this.beginRenderPassCmds.length) { + allocator.beginRenderPassCmdPool.freeCmds(this.beginRenderPassCmds); + this.beginRenderPassCmds.clear(); + } + + if (this.bindStatesCmds.length) { + allocator.bindStatesCmdPool.freeCmds(this.bindStatesCmds); + this.bindStatesCmds.clear(); + } + + if (this.drawCmds.length) { + allocator.drawCmdPool.freeCmds(this.drawCmds); + this.drawCmds.clear(); + } + + if (this.updateBufferCmds.length) { + allocator.updateBufferCmdPool.freeCmds(this.updateBufferCmds); + this.updateBufferCmds.clear(); + } + + if (this.copyBufferToTextureCmds.length) { + allocator.copyBufferToTextureCmdPool.freeCmds(this.copyBufferToTextureCmds); + this.copyBufferToTextureCmds.clear(); + } + + this.cmds.clear(); + } +} + +export function WebGL2CmdFuncCreateBuffer (device: WebGL2GFXDevice, gpuBuffer: WebGL2GPUBuffer) { + + const gl = device.gl; + + if (gpuBuffer.usage & GFXBufferUsageBit.VERTEX) { + + gpuBuffer.glTarget = WebGLRenderingContext.ARRAY_BUFFER; + const glBuffer = gl.createBuffer(); + if (glBuffer) { + gpuBuffer.glBuffer = glBuffer; + + if (device.stateCache.glArrayBuffer !== gpuBuffer.glBuffer) { + gl.bindBuffer(WebGLRenderingContext.ARRAY_BUFFER, gpuBuffer.glBuffer); + device.stateCache.glArrayBuffer = gpuBuffer.glBuffer; + } + + const glUsage: GLenum = gpuBuffer.memUsage & GFXMemoryUsageBit.DEVICE ? WebGLRenderingContext.STATIC_DRAW : WebGLRenderingContext.DYNAMIC_DRAW; + gl.bufferData(WebGLRenderingContext.ARRAY_BUFFER, gpuBuffer.size, glUsage); + + gl.bindBuffer(WebGLRenderingContext.ARRAY_BUFFER, null); + device.stateCache.glArrayBuffer = 0; + } + } else if (gpuBuffer.usage & GFXBufferUsageBit.INDEX) { + + gpuBuffer.glTarget = WebGLRenderingContext.ELEMENT_ARRAY_BUFFER; + const glBuffer = gl.createBuffer(); + if (glBuffer) { + gpuBuffer.glBuffer = glBuffer; + + if (device.stateCache.glElementArrayBuffer !== gpuBuffer.glBuffer) { + gl.bindBuffer(WebGLRenderingContext.ELEMENT_ARRAY_BUFFER, gpuBuffer.glBuffer); + device.stateCache.glElementArrayBuffer = gpuBuffer.glBuffer; + } + + const glUsage: GLenum = gpuBuffer.memUsage & GFXMemoryUsageBit.DEVICE ? WebGLRenderingContext.STATIC_DRAW : WebGLRenderingContext.DYNAMIC_DRAW; + gl.bufferData(WebGLRenderingContext.ELEMENT_ARRAY_BUFFER, gpuBuffer.size, glUsage); + + gl.bindBuffer(WebGLRenderingContext.ELEMENT_ARRAY_BUFFER, null); + device.stateCache.glElementArrayBuffer = 0; + } + } else if (gpuBuffer.usage & GFXBufferUsageBit.UNIFORM) { + // console.error("WebGL 1.0 doesn't support uniform buffer."); + gpuBuffer.glTarget = WebGLRenderingContext.NONE; + + if (gpuBuffer.buffer) { + gpuBuffer.vf32 = new Float32Array(gpuBuffer.buffer as ArrayBuffer); + } + } else if (gpuBuffer.usage & GFXBufferUsageBit.INDIRECT) { + gpuBuffer.glTarget = WebGLRenderingContext.NONE; + } else if (gpuBuffer.usage & GFXBufferUsageBit.TRANSFER_DST) { + gpuBuffer.glTarget = WebGLRenderingContext.NONE; + } else if (gpuBuffer.usage & GFXBufferUsageBit.TRANSFER_SRC) { + gpuBuffer.glTarget = WebGLRenderingContext.NONE; + } else { + console.error('Unsupported GFXBufferType, create buffer failed.'); + gpuBuffer.glTarget = WebGLRenderingContext.NONE; + } +} + +export function WebGL2CmdFuncDestroyBuffer (device: WebGL2GFXDevice, gpuBuffer: WebGL2GPUBuffer) { + if (gpuBuffer.glBuffer > 0) { + device.gl.deleteBuffer(gpuBuffer.glBuffer); + gpuBuffer.glBuffer = 0; + } +} + +export function WebGL2CmdFuncResizeBuffer (device: WebGL2GFXDevice, gpuBuffer: WebGL2GPUBuffer) { + + const gl = device.gl; + + if (gpuBuffer.usage & GFXBufferUsageBit.VERTEX) { + + if (device.stateCache.glArrayBuffer !== gpuBuffer.glBuffer) { + gl.bindBuffer(WebGLRenderingContext.ARRAY_BUFFER, gpuBuffer.glBuffer); + } + + const glUsage: GLenum = gpuBuffer.memUsage & GFXMemoryUsageBit.DEVICE ? WebGLRenderingContext.STATIC_DRAW : WebGLRenderingContext.DYNAMIC_DRAW; + gl.bufferData(WebGLRenderingContext.ARRAY_BUFFER, gpuBuffer.size, glUsage); + + gl.bindBuffer(WebGLRenderingContext.ARRAY_BUFFER, null); + device.stateCache.glArrayBuffer = 0; + } else if (gpuBuffer.usage & GFXBufferUsageBit.INDEX) { + + if (device.stateCache.glElementArrayBuffer !== gpuBuffer.glBuffer) { + gl.bindBuffer(WebGLRenderingContext.ELEMENT_ARRAY_BUFFER, gpuBuffer.glBuffer); + } + + const glUsage: GLenum = gpuBuffer.memUsage & GFXMemoryUsageBit.DEVICE ? WebGLRenderingContext.STATIC_DRAW : WebGLRenderingContext.DYNAMIC_DRAW; + gl.bufferData(WebGLRenderingContext.ELEMENT_ARRAY_BUFFER, gpuBuffer.size, glUsage); + + gl.bindBuffer(WebGLRenderingContext.ELEMENT_ARRAY_BUFFER, null); + device.stateCache.glElementArrayBuffer = 0; + } else if (gpuBuffer.usage & GFXBufferUsageBit.UNIFORM) { + // console.error("WebGL 1.0 doesn't support uniform buffer."); + if (gpuBuffer.buffer) { + gpuBuffer.vf32 = new Float32Array(gpuBuffer.buffer as ArrayBuffer); + } + } else if ((gpuBuffer.usage & GFXBufferUsageBit.INDIRECT) || + (gpuBuffer.usage & GFXBufferUsageBit.TRANSFER_DST) || + (gpuBuffer.usage & GFXBufferUsageBit.TRANSFER_SRC)) { + gpuBuffer.glTarget = WebGLRenderingContext.NONE; + } else { + console.error('Unsupported GFXBufferType, create buffer failed.'); + gpuBuffer.glTarget = WebGLRenderingContext.NONE; + } +} + +export function WebGL2CmdFuncUpdateBuffer (device: WebGL2GFXDevice, gpuBuffer: WebGL2GPUBuffer, buffer: GFXBufferSource, offset: number, size: number) { + + if (gpuBuffer.usage & GFXBufferUsageBit.UNIFORM) { + gpuBuffer.vf32!.set(buffer as Float32Array, offset); + } else if (gpuBuffer.usage & GFXBufferUsageBit.INDIRECT) { + gpuBuffer.indirects = (buffer as IGFXIndirectBuffer).drawInfos; + } else { + const buff = buffer as ArrayBuffer; + const gl = device.gl; + + switch (gpuBuffer.glTarget) { + case WebGLRenderingContext.ARRAY_BUFFER: { + if (device.stateCache.glArrayBuffer !== gpuBuffer.glBuffer) { + gl.bindBuffer(WebGLRenderingContext.ARRAY_BUFFER, gpuBuffer.glBuffer); + device.stateCache.glArrayBuffer = gpuBuffer.glBuffer; + } + + if (size === buff.byteLength) { + gl.bufferSubData(gpuBuffer.glTarget, offset, buff); + } else { + gl.bufferSubData(gpuBuffer.glTarget, offset, buff.slice(0, size)); + } + + break; + } + case WebGLRenderingContext.ELEMENT_ARRAY_BUFFER: { + if (device.stateCache.glElementArrayBuffer !== gpuBuffer.glBuffer) { + gl.bindBuffer(WebGLRenderingContext.ELEMENT_ARRAY_BUFFER, gpuBuffer.glBuffer); + device.stateCache.glElementArrayBuffer = gpuBuffer.glBuffer; + } + + if (size === buff.byteLength) { + gl.bufferSubData(gpuBuffer.glTarget, offset, buff); + } else { + gl.bufferSubData(gpuBuffer.glTarget, offset, buff.slice(0, size)); + } + + break; + } + default: { + console.error('Unsupported GFXBufferType, update buffer failed.'); + } + } + } +} + +export function WebGL2CmdFuncCreateTexture (device: WebGL2GFXDevice, gpuTexture: WebGL2GPUTexture) { + + const gl = device.gl; + + gpuTexture.glInternelFmt = GFXFormatToWebGLInternalFormat(gpuTexture.format); + gpuTexture.glFormat = GFXFormatToWebGLFormat(gpuTexture.format); + gpuTexture.glType = GFXFormatToWebGLType(gpuTexture.format, device); + + switch (gpuTexture.viewType) { + case GFXTextureViewType.TV2D: { + + gpuTexture.viewType = GFXTextureViewType.TV2D; + gpuTexture.glTarget = WebGLRenderingContext.TEXTURE_2D; + + const glTexture = gl.createTexture(); + if (glTexture) { + gpuTexture.glTexture = glTexture; + const glTexUnit = device.stateCache.glTex2DUnits[device.stateCache.texUnit]; + + if (glTexUnit.glTexture !== gpuTexture.glTexture) { + gl.bindTexture(WebGLRenderingContext.TEXTURE_2D, gpuTexture.glTexture); + glTexUnit.glTexture = gpuTexture.glTexture; + } + + let w = gpuTexture.width; + let h = gpuTexture.height; + + if (!GFXFormatInfos[gpuTexture.format].isCompressed) { + for (let i = 0; i < gpuTexture.mipLevel; ++i) { + gl.texImage2D(WebGLRenderingContext.TEXTURE_2D, i, gpuTexture.glInternelFmt, w, h, 0, gpuTexture.glFormat, gpuTexture.glType, null); + w = Math.max(1, w >> 1); + h = Math.max(1, h >> 1); + } + } else { + const view: ArrayBufferView = { buffer: new ArrayBuffer(0), byteLength: 0, byteOffset: 0 }; + for (let i = 0; i < gpuTexture.mipLevel; ++i) { + gl.compressedTexImage2D(WebGLRenderingContext.TEXTURE_2D, i, gpuTexture.glInternelFmt, w, h, 0, view); + w = Math.max(1, w >> 1); + h = Math.max(1, h >> 1); + } + } + + gl.texParameteri(gpuTexture.glTarget, WebGLRenderingContext.TEXTURE_WRAP_S, WebGLRenderingContext.CLAMP_TO_EDGE); + gl.texParameteri(gpuTexture.glTarget, WebGLRenderingContext.TEXTURE_WRAP_T, WebGLRenderingContext.CLAMP_TO_EDGE); + gl.texParameteri(gpuTexture.glTarget, WebGLRenderingContext.TEXTURE_MIN_FILTER, WebGLRenderingContext.LINEAR); + gl.texParameteri(gpuTexture.glTarget, WebGLRenderingContext.TEXTURE_MAG_FILTER, WebGLRenderingContext.LINEAR); + gpuTexture.glWrapS = WebGLRenderingContext.CLAMP_TO_EDGE; + gpuTexture.glWrapT = WebGLRenderingContext.CLAMP_TO_EDGE; + gpuTexture.glMinFilter = WebGLRenderingContext.LINEAR; + gpuTexture.glMagFilter = WebGLRenderingContext.LINEAR; + } + + break; + } + case GFXTextureViewType.CUBE: { + + gpuTexture.viewType = GFXTextureViewType.CUBE; + gpuTexture.glTarget = WebGLRenderingContext.TEXTURE_CUBE_MAP; + + const glTexture = gl.createTexture(); + if (glTexture) { + gpuTexture.glTexture = glTexture; + const glTexUnit = device.stateCache.glTexCubeUnits[device.stateCache.texUnit]; + + if (glTexUnit.glTexture !== gpuTexture.glTexture) { + gl.bindTexture(WebGLRenderingContext.TEXTURE_CUBE_MAP, gpuTexture.glTexture); + glTexUnit.glTexture = gpuTexture.glTexture; + } + + if (!GFXFormatInfos[gpuTexture.format].isCompressed) { + for (let f = 0; f < 6; ++f) { + let w = gpuTexture.width; + let h = gpuTexture.height; + for (let i = 0; i < gpuTexture.mipLevel; ++i) { + gl.texImage2D(WebGLRenderingContext.TEXTURE_CUBE_MAP_POSITIVE_X + f, i, gpuTexture.glInternelFmt, w, h, 0, gpuTexture.glFormat, gpuTexture.glType, null); + w = Math.max(1, w >> 1); + h = Math.max(1, h >> 1); + } + } + } else { + const view: ArrayBufferView = { buffer: new ArrayBuffer(0), byteLength: 0, byteOffset: 0 }; + + for (let f = 0; f < 6; ++f) { + let w = gpuTexture.width; + let h = gpuTexture.height; + for (let i = 0; i < gpuTexture.mipLevel; ++i) { + gl.compressedTexImage2D(WebGLRenderingContext.TEXTURE_CUBE_MAP_POSITIVE_X + f, i, gpuTexture.glInternelFmt, w, h, 0, view); + w = Math.max(1, w >> 1); + h = Math.max(1, h >> 1); + } + } + } + + gl.texParameteri(gpuTexture.glTarget, WebGLRenderingContext.TEXTURE_WRAP_S, WebGLRenderingContext.CLAMP_TO_EDGE); + gl.texParameteri(gpuTexture.glTarget, WebGLRenderingContext.TEXTURE_WRAP_T, WebGLRenderingContext.CLAMP_TO_EDGE); + gl.texParameteri(gpuTexture.glTarget, WebGLRenderingContext.TEXTURE_MIN_FILTER, WebGLRenderingContext.LINEAR); + gl.texParameteri(gpuTexture.glTarget, WebGLRenderingContext.TEXTURE_MAG_FILTER, WebGLRenderingContext.LINEAR); + gpuTexture.glWrapS = WebGLRenderingContext.CLAMP_TO_EDGE; + gpuTexture.glWrapT = WebGLRenderingContext.CLAMP_TO_EDGE; + gpuTexture.glMinFilter = WebGLRenderingContext.LINEAR; + gpuTexture.glMagFilter = WebGLRenderingContext.LINEAR; + } + + break; + } + default: { + console.error('Unsupported GFXTextureType, create texture failed.'); + gpuTexture.viewType = GFXTextureViewType.TV2D; + gpuTexture.glTarget = WebGLRenderingContext.TEXTURE_2D; + } + } +} + +export function WebGL2CmdFuncDestroyTexture (device: WebGL2GFXDevice, gpuTexture: WebGL2GPUTexture) { + if (gpuTexture.glTexture > 0) { + device.gl.deleteTexture(gpuTexture.glTexture); + gpuTexture.glTexture = 0; + } +} + +export function WebGL2CmdFuncCreateFramebuffer (device: WebGL2GFXDevice, gpuFramebuffer: WebGL2GPUFramebuffer) { + + if (!gpuFramebuffer.isOffscreen) { + + const gl = device.gl; + + const glFramebuffer = gl.createFramebuffer(); + if (glFramebuffer) { + gpuFramebuffer.glFramebuffer = glFramebuffer; + + if (device.stateCache.glFramebuffer !== gpuFramebuffer.glFramebuffer) { + gl.bindFramebuffer(WebGLRenderingContext.FRAMEBUFFER, gpuFramebuffer.glFramebuffer); + device.stateCache.glFramebuffer = gpuFramebuffer.glFramebuffer; + } + + for (let i = 0; i < gpuFramebuffer.gpuColorViews.length; ++i) { + + const gpuColorView = gpuFramebuffer.gpuColorViews[i]; + if (gpuColorView) { + gl.framebufferTexture2D( + WebGLRenderingContext.FRAMEBUFFER, + WebGLRenderingContext.COLOR_ATTACHMENT0 + i, + gpuColorView.gpuTexture.glTarget, + gpuColorView.gpuTexture.glTexture, + gpuColorView.baseLevel); + } + } + + if (gpuFramebuffer.gpuDepthStencilView) { + + const glAttachment = GFXFormatInfos[gpuFramebuffer.gpuDepthStencilView.format].hasStencil ? + WebGLRenderingContext.DEPTH_STENCIL_ATTACHMENT : WebGLRenderingContext.DEPTH_ATTACHMENT; + + gl.framebufferTexture2D( + WebGLRenderingContext.FRAMEBUFFER, + glAttachment, + gpuFramebuffer.gpuDepthStencilView.gpuTexture.glTarget, + gpuFramebuffer.gpuDepthStencilView.gpuTexture.glTexture, + gpuFramebuffer.gpuDepthStencilView.baseLevel); + } + + /* + const status = gl.checkFramebufferStatus(WebGLRenderingContext.FRAMEBUFFER); + if (status !== WebGLRenderingContext.FRAMEBUFFER_COMPLETE) { + switch (status) { + case WebGLRenderingContext.FRAMEBUFFER_INCOMPLETE_ATTACHMENT: { + console.error('glCheckFramebufferStatus() - FRAMEBUFFER_INCOMPLETE_ATTACHMENT'); + break; + } + case WebGLRenderingContext.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: { + console.error('glCheckFramebufferStatus() - FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT'); + break; + } + case WebGLRenderingContext.FRAMEBUFFER_INCOMPLETE_DIMENSIONS: { + console.error('glCheckFramebufferStatus() - FRAMEBUFFER_INCOMPLETE_DIMENSIONS'); + break; + } + case WebGLRenderingContext.FRAMEBUFFER_UNSUPPORTED: { + console.error('glCheckFramebufferStatus() - FRAMEBUFFER_UNSUPPORTED'); + break; + } + default: + } + } + */ + } + } +} + +export function WebGL2CmdFuncDestroyFramebuffer (device: WebGL2GFXDevice, gpuFramebuffer: WebGL2GPUFramebuffer) { + if (gpuFramebuffer.glFramebuffer > 0) { + device.gl.deleteFramebuffer(gpuFramebuffer.glFramebuffer); + gpuFramebuffer.glFramebuffer = 0; + } +} + +export function WebGL2CmdFuncCreateShader (device: WebGL2GFXDevice, gpuShader: WebGL2GPUShader) { + const gl = device.gl; + + for (const gpuStage of gpuShader.gpuStages) { + + let glShaderType: GLenum = 0; + let shaderTypeStr = ''; + + switch (gpuStage.type) { + case GFXShaderType.VERTEX: { + shaderTypeStr = 'VertexShader'; + glShaderType = WebGLRenderingContext.VERTEX_SHADER; + break; + } + case GFXShaderType.FRAGMENT: { + shaderTypeStr = 'FragmentShader'; + glShaderType = WebGLRenderingContext.FRAGMENT_SHADER; + break; + } + default: { + console.error('Unsupported GFXShaderType.'); + return; + } + } + + const glShader = gl.createShader(glShaderType); + if (glShader) { + gpuStage.glShader = glShader; + gl.shaderSource(gpuStage.glShader, gpuStage.source); + gl.compileShader(gpuStage.glShader); + + if (!gl.getShaderParameter(gpuStage.glShader, gl.COMPILE_STATUS)) { + console.error(shaderTypeStr + ' in \'' + gpuShader.name + '\' compilation failed.'); + console.error(gpuStage.source); + console.error(gl.getShaderInfoLog(gpuStage.glShader)); + + gl.deleteShader(gpuStage.glShader); + gpuStage.glShader = 0; + } + } + } + + const glProgram = gl.createProgram(); + if (!glProgram) { + return; + } + + gpuShader.glProgram = glProgram; + + // link program + for (const gpuStage of gpuShader.gpuStages) { + gl.attachShader(gpuShader.glProgram, gpuStage.glShader); + } + + gl.linkProgram(gpuShader.glProgram); + if (gl.getProgramParameter(gpuShader.glProgram, gl.LINK_STATUS)) { + console.info('Shader \'' + gpuShader.name + '\' compilation successed.'); + } else { + console.error('Failed to link shader \'' + gpuShader.name + '\'.'); + console.error(gl.getProgramInfoLog(gpuShader.glProgram)); + + for (const gpuStage of gpuShader.gpuStages) { + if (gpuStage.glShader > 0) { + gl.deleteShader(gpuStage.glShader); + gpuStage.glShader = 0; + } + } + } + + // parse inputs + const activeAttribCount = gl.getProgramParameter(gpuShader.glProgram, gl.ACTIVE_ATTRIBUTES); + gpuShader.glInputs = new Array(activeAttribCount); + + for (let i = 0; i < activeAttribCount; ++i) { + const attribInfo = gl.getActiveAttrib(gpuShader.glProgram, i); + if (attribInfo) { + let varName: string; + const nameOffset = attribInfo.name.indexOf('['); + if (nameOffset !== -1) { + varName = attribInfo.name.substr(0, nameOffset); + } else { + varName = attribInfo.name; + } + + const glLoc = gl.getAttribLocation(gpuShader.glProgram, varName); + const type = WebGLTypeToGFXType(attribInfo.type); + const stride = WebGLGetTypeSize(attribInfo.type); + + gpuShader.glInputs[i] = { + binding: glLoc, + name: varName, + type, + stride, + count: attribInfo.size, + size: stride * attribInfo.size, + + glType: attribInfo.type, + glLoc, + }; + } + } + + // create uniform blocks + if (gpuShader.blocks.length > 0) { + gpuShader.glBlocks = new Array(gpuShader.blocks.length); + for (let i = 0; i < gpuShader.blocks.length; ++i) { + const block = gpuShader.blocks[i]; + + const glBlock: WebGL2GPUUniformBlock = { + binding: block.binding, + name: block.name, + size: 0, + glUniforms: new Array(block.members.length), + glActiveUniforms: [], + isUniformPackage: true, + }; + + gpuShader.glBlocks[i] = glBlock; + + for (let u = 0; u < block.members.length; ++u) { + const uniform = block.members[u]; + const glType = GFXTypeToWebGLType(uniform.type); + const stride = WebGLGetTypeSize(glType); + const size = stride * uniform.count; + const begin = glBlock.size / 4; + const count = size / 4; + const array = new Array(count); + array.fill(0); + + glBlock.glUniforms[u] = { + binding: -1, + name: uniform.name, + type: uniform.type, + stride, + count: uniform.count, + size, + offset: glBlock.size, + + glType, + glLoc: -1, + array, + begin, + isFirst: true, + }; + + glBlock.size += size; + } + + /* + glBlock.buffer = new ArrayBuffer(glBlock.size); + + for (const glUniform of glBlock.glUniforms) { + switch (glUniform.glType) { + case gl.BOOL: + case gl.BOOL_VEC2: + case gl.BOOL_VEC3: + case gl.BOOL_VEC4: + case gl.INT: + case gl.INT_VEC2: + case gl.INT_VEC3: + case gl.INT_VEC4: + case gl.SAMPLER_2D: + case gl.SAMPLER_CUBE: { + glUniform.vi32 = new Int32Array(glBlock.buffer); + break; + } + default: { + glUniform.vf32 = new Float32Array(glBlock.buffer); + } + } + } + */ + } + } + + // create uniform samplers + if (gpuShader.samplers.length > 0) { + gpuShader.glSamplers = new Array(gpuShader.samplers.length); + + for (let i = 0; i < gpuShader.samplers.length; ++i) { + const sampler = gpuShader.samplers[i]; + gpuShader.glSamplers[i] = { + binding: sampler.binding, + name: sampler.name, + type: sampler.type, + units: [], + glType: GFXTypeToWebGLType(sampler.type), + glLoc: -1, + }; + } + } + + // parse uniforms + const activeUniformCount = gl.getProgramParameter(gpuShader.glProgram, gl.ACTIVE_UNIFORMS); + let unitIdx = 0; + + const glActiveSamplers: WebGL2GPUUniformSampler[] = []; + + for (let i = 0; i < activeUniformCount; ++i) { + const uniformInfo = gl.getActiveUniform(gpuShader.glProgram, i); + if (uniformInfo) { + const glLoc = gl.getUniformLocation(gpuShader.glProgram, uniformInfo.name); + if (glLoc) { + let varName: string; + const nameOffset = uniformInfo.name.indexOf('['); + if (nameOffset !== -1) { + varName = uniformInfo.name.substr(0, nameOffset); + } else { + varName = uniformInfo.name; + } + + const isSampler = (uniformInfo.type === WebGLRenderingContext.SAMPLER_2D) || + (uniformInfo.type === WebGLRenderingContext.SAMPLER_CUBE); + + if (!isSampler) { + // let stride = WebGLGetTypeSize(info.type); + + // build uniform block mapping + for (const glBlock of gpuShader.glBlocks) { + + for (const glUniform of glBlock.glUniforms) { + if (glUniform.name === varName) { + // let varSize = stride * info.size; + + glUniform.glLoc = glLoc; + glBlock.glActiveUniforms.push(glUniform); + + break; + } + } + } // for + } else { + + for (const glSampler of gpuShader.glSamplers) { + if (glSampler.name === varName) { + // let varSize = stride * uniformInfo.size; + + for (let t = 0; t < uniformInfo.size; ++t) { + glSampler.units.push(unitIdx + t); + } + + glSampler.glLoc = glLoc; + + unitIdx += uniformInfo.size; + glActiveSamplers.push(glSampler); + + break; + } + } // for + } + } + } + } // for + + if (glActiveSamplers.length) { + if (device.stateCache.glProgram !== gpuShader.glProgram) { + gl.useProgram(gpuShader.glProgram); + device.stateCache.glProgram = gpuShader.glProgram; + } + + for (const glSampler of glActiveSamplers) { + gl.uniform1iv(glSampler.glLoc, glSampler.units); + } + } +} + +export function WebGL2CmdFuncDestroyShader (device: WebGL2GFXDevice, gpuShader: WebGL2GPUShader) { + + for (const gpuStage of gpuShader.gpuStages) { + if (gpuStage.glShader > 0) { + device.gl.deleteShader(gpuStage.glShader); + gpuStage.glShader = 0; + } + } + + if (gpuShader.glProgram > 0) { + device.gl.deleteProgram(gpuShader.glProgram); + gpuShader.glProgram = 0; + } +} + +export function WebGL2CmdFuncCreateInputAssember (device: WebGL2GFXDevice, gpuInputAssembler: WebGL2GPUInputAssembler) { + + gpuInputAssembler.glAttribs = new Array(gpuInputAssembler.attributes.length); + + const offsets = [0, 0, 0, 0, 0, 0, 0, 0]; + + for (let i = 0; i < gpuInputAssembler.attributes.length; ++i) { + const attrib = gpuInputAssembler.attributes[i]; + + const stream = attrib.stream !== undefined ? attrib.stream : 0; + // if (stream < gpuInputAssembler.gpuVertexBuffers.length) { + + const gpuBuffer = gpuInputAssembler.gpuVertexBuffers[stream]; + + const glType = GFXFormatToWebGLType(attrib.format, device); + const size = GFXFormatInfos[attrib.format].size; + + gpuInputAssembler.glAttribs[i] = { + name: attrib.name, + glBuffer: gpuBuffer.glBuffer, + glType, + size, + count: GFXFormatInfos[attrib.format].count, + stride: gpuBuffer.stride, + componentCount: WebGLGetComponentCount(glType), + isNormalized: (attrib.isNormalized !== undefined ? attrib.isNormalized : false), + isInstanced: (attrib.isInstanced !== undefined ? attrib.isInstanced : false), + offset: offsets[stream], + }; + + offsets[stream] += size; + } +} + +export function WebGL2CmdFuncDestroyInputAssembler (device: WebGL2GFXDevice, gpuInputAssembler: WebGL2GPUInputAssembler) { +} + +export function WebGL2CmdFuncExecuteCmds (device: WebGL2GFXDevice, cmdPackage: WebGL2CmdPackage) { + + const gl = device.gl; + const cmdIds = [0, 0, 0, 0, 0, 0]; // 6 + + let gpuPipelineState: WebGL2GPUPipelineState | null = null; + let gpuShader: WebGL2GPUShader | null = null; + let gpuInputAssembler: WebGL2GPUInputAssembler | null = null; + let glPrimitive = WebGLRenderingContext.TRIANGLES; + + for (let i = 0; i < cmdPackage.cmds.length; ++i) { + const cmd = cmdPackage.cmds.array[i]; + const cmdId = cmdIds[cmd]++; + + switch (cmd) { + case WebGL2Cmd.BEGIN_RENDER_PASS: { + const cmd0 = cmdPackage.beginRenderPassCmds.array[cmdId]; + + let clears: GLbitfield = 0; + + if (cmd0.gpuFramebuffer) { + if (device.stateCache.glFramebuffer !== cmd0.gpuFramebuffer.glFramebuffer) { + const glFBO = (cmd0.gpuFramebuffer.glFramebuffer !== 0 ? cmd0.gpuFramebuffer.glFramebuffer : null); + gl.bindFramebuffer(WebGLRenderingContext.FRAMEBUFFER, glFBO); + device.stateCache.glFramebuffer = cmd0.gpuFramebuffer.glFramebuffer; + } + + if (device.stateCache.viewport.left !== cmd0.renderArea.x || + device.stateCache.viewport.top !== cmd0.renderArea.y || + device.stateCache.viewport.width !== cmd0.renderArea.width || + device.stateCache.viewport.height !== cmd0.renderArea.height) { + + gl.viewport(cmd0.renderArea.x, cmd0.renderArea.y, cmd0.renderArea.width, cmd0.renderArea.height); + + device.stateCache.viewport.left = cmd0.renderArea.x; + device.stateCache.viewport.top = cmd0.renderArea.y; + device.stateCache.viewport.width = cmd0.renderArea.width; + device.stateCache.viewport.height = cmd0.renderArea.height; + } + + if (device.stateCache.scissorRect.x !== cmd0.renderArea.x || + device.stateCache.scissorRect.y !== cmd0.renderArea.y || + device.stateCache.scissorRect.width !== cmd0.renderArea.width || + device.stateCache.scissorRect.height !== cmd0.renderArea.height) { + + gl.scissor(cmd0.renderArea.x, cmd0.renderArea.y, cmd0.renderArea.width, cmd0.renderArea.height); + + device.stateCache.scissorRect.x = cmd0.renderArea.x; + device.stateCache.scissorRect.y = cmd0.renderArea.y; + device.stateCache.scissorRect.width = cmd0.renderArea.width; + device.stateCache.scissorRect.height = cmd0.renderArea.height; + } + + const curGPURenderPass = cmd0.gpuFramebuffer.gpuRenderPass; + + const invalidateAttachments: GLenum[] = [0, 0, 0, 0]; + let numInvalidAttach = 0; + + if (curGPURenderPass.colorAttachments.length > 0 && cmd0.clearColors.length) { + const colorAttachment = curGPURenderPass.colorAttachments[0]; + + if (colorAttachment.format !== GFXFormat.UNKNOWN) { + switch (colorAttachment.loadOp) { + case GFXLoadOp.LOAD: break; // GL default behaviour + case GFXLoadOp.CLEAR: { + + if (device.stateCache.bs.targets[0].blendColorMask !== GFXColorMask.ALL) { + gl.colorMask(true, true, true, true); + } + + const clearColor = cmd0.clearColors[0]; + gl.clearColor(clearColor.r, clearColor.g, clearColor.b, clearColor.a); + clears |= WebGLRenderingContext.COLOR_BUFFER_BIT; + + break; + } + case GFXLoadOp.DISCARD: { + // invalidate the framebuffer + invalidateAttachments[numInvalidAttach++] = WebGLRenderingContext.COLOR_ATTACHMENT0; + break; + } + default: + } + } + } // if (curGPURenderPass) + + if (curGPURenderPass.depthStencilAttachment) { + + if (curGPURenderPass.depthStencilAttachment.format !== GFXFormat.UNKNOWN) { + switch (curGPURenderPass.depthStencilAttachment.depthLoadOp) { + case GFXLoadOp.LOAD: break; // GL default behaviour + case GFXLoadOp.CLEAR: { + + if (!device.stateCache.dss.depthWrite) { + gl.depthMask(true); + } + + gl.clearDepth(cmd0.clearDepth); + + clears |= WebGLRenderingContext.DEPTH_BUFFER_BIT; + + break; + } + case GFXLoadOp.DISCARD: { + // invalidate the framebuffer + invalidateAttachments[numInvalidAttach++] = WebGLRenderingContext.DEPTH_ATTACHMENT; + break; + } + default: + } + + if (GFXFormatInfos[curGPURenderPass.depthStencilAttachment.format].hasStencil) { + switch (curGPURenderPass.depthStencilAttachment.stencilLoadOp) { + case GFXLoadOp.LOAD: break; // GL default behaviour + case GFXLoadOp.CLEAR: { + + if (!device.stateCache.dss.stencilWriteMaskFront) { + gl.stencilMaskSeparate(WebGLRenderingContext.FRONT, 0xFFFFFFFF); + } + + if (!device.stateCache.dss.stencilWriteMaskBack) { + gl.stencilMaskSeparate(WebGLRenderingContext.BACK, 0xFFFFFFFF); + } + + gl.clearStencil(cmd0.clearStencil); + clears |= WebGLRenderingContext.STENCIL_BUFFER_BIT; + + break; + } + case GFXLoadOp.DISCARD: { + // invalidate the framebuffer + invalidateAttachments[numInvalidAttach++] = WebGLRenderingContext.STENCIL_ATTACHMENT; + break; + } + default: + } + } + } + } // if (curGPURenderPass.depthStencilAttachment) + + /* + if (numInvalidAttach) { + gl.invalidateFramebuffer(WebGLRenderingContext.FRAMEBUFFER, numInvalidAttach, invalidateAttachments); + } + */ + + if (clears) { + gl.clear(clears); + } + + // restore states + if (clears & WebGLRenderingContext.COLOR_BUFFER_BIT) { + + const colorMask = device.stateCache.bs.targets[0].blendColorMask; + if (colorMask !== GFXColorMask.ALL) { + const r = (colorMask & GFXColorMask.R) !== GFXColorMask.NONE; + const g = (colorMask & GFXColorMask.G) !== GFXColorMask.NONE; + const b = (colorMask & GFXColorMask.B) !== GFXColorMask.NONE; + const a = (colorMask & GFXColorMask.A) !== GFXColorMask.NONE; + gl.colorMask(r, g, b, a); + } + } + + if ((clears & WebGLRenderingContext.DEPTH_BUFFER_BIT) && + !device.stateCache.dss.depthWrite) { + gl.depthMask(false); + } + + if (clears & WebGLRenderingContext.STENCIL_BUFFER_BIT) { + if (!device.stateCache.dss.stencilWriteMaskFront) { + gl.stencilMaskSeparate(WebGLRenderingContext.FRONT, 0); + } + + if (!device.stateCache.dss.stencilWriteMaskBack) { + gl.stencilMaskSeparate(WebGLRenderingContext.BACK, 0); + } + } + } // if (curGPURenderPass) + + break; + } + case WebGL2Cmd.END_RENDER_PASS: { + // WebGL 1.0 doesn't support store operation of attachments. + // GFXStoreOp.Store is the default GL behaviour. + break; + } + case WebGL2Cmd.BIND_STATES: { + + const cmd2 = cmdPackage.bindStatesCmds.array[cmdId]; + if (cmd2.gpuPipelineState) { + gpuPipelineState = cmd2.gpuPipelineState; + glPrimitive = cmd2.gpuPipelineState.glPrimitive; + + if (cmd2.gpuPipelineState.gpuShader) { + + const glProgram = cmd2.gpuPipelineState.gpuShader.glProgram; + if (device.stateCache.glProgram !== glProgram) { + gl.useProgram(glProgram); + device.stateCache.glProgram = glProgram; + } + + gpuShader = cmd2.gpuPipelineState.gpuShader; + } + + // rasterizer state + const rs = cmd2.gpuPipelineState.rs; + if (rs) { + + if (device.stateCache.rs.cullMode !== rs.cullMode) { + switch (rs.cullMode) { + case GFXCullMode.NONE: { + gl.disable(WebGLRenderingContext.CULL_FACE); + break; + } + case GFXCullMode.FRONT: { + gl.enable(WebGLRenderingContext.CULL_FACE); + gl.cullFace(WebGLRenderingContext.FRONT); + break; + } + case GFXCullMode.BACK: { + gl.enable(WebGLRenderingContext.CULL_FACE); + gl.cullFace(WebGLRenderingContext.BACK); + break; + } + default: + } + + device.stateCache.rs.cullMode = rs.cullMode; + } + + if (device.stateCache.rs.isFrontFaceCCW !== rs.isFrontFaceCCW) { + gl.frontFace(rs.isFrontFaceCCW ? WebGLRenderingContext.CCW : WebGLRenderingContext.CW); + device.stateCache.rs.isFrontFaceCCW = rs.isFrontFaceCCW; + } + + if ((device.stateCache.rs.depthBias !== rs.depthBias) || + (device.stateCache.rs.depthBiasSlop !== rs.depthBiasSlop)) { + gl.polygonOffset(rs.depthBias, rs.depthBiasSlop); + device.stateCache.rs.depthBias = rs.depthBias; + device.stateCache.rs.depthBiasSlop = rs.depthBiasSlop; + } + + if (device.stateCache.rs.lineWidth !== rs.lineWidth) { + gl.lineWidth(rs.lineWidth); + device.stateCache.rs.lineWidth = rs.lineWidth; + } + + } // rasterizater state + + // depth-stencil state + const dss = cmd2.gpuPipelineState.dss; + if (dss) { + + if (device.stateCache.dss.depthTest !== dss.depthTest) { + if (dss.depthTest) { + gl.enable(WebGLRenderingContext.DEPTH_TEST); + } else { + gl.disable(WebGLRenderingContext.DEPTH_TEST); + } + device.stateCache.dss.depthTest = dss.depthTest; + } + + if (device.stateCache.dss.depthWrite !== dss.depthWrite) { + gl.depthMask(dss.depthWrite); + device.stateCache.dss.depthWrite = dss.depthWrite; + } + + if (device.stateCache.dss.depthFunc !== dss.depthFunc) { + gl.depthFunc(WebGLCmpFuncs[dss.depthFunc]); + device.stateCache.dss.depthFunc = dss.depthFunc; + } + + // front + if ((device.stateCache.dss.stencilTestFront !== dss.stencilTestFront) || + (device.stateCache.dss.stencilTestBack !== dss.stencilTestBack)) { + if (dss.stencilTestFront || dss.stencilTestBack) { + gl.enable(WebGLRenderingContext.STENCIL_TEST); + } else { + gl.disable(WebGLRenderingContext.STENCIL_TEST); + } + device.stateCache.dss.stencilTestFront = dss.stencilTestFront; + device.stateCache.dss.stencilTestBack = dss.stencilTestBack; + } + + if ((device.stateCache.dss.stencilFuncFront !== dss.stencilFuncFront) || + (device.stateCache.dss.stencilRefFront !== dss.stencilRefFront) || + (device.stateCache.dss.stencilReadMaskFront !== dss.stencilReadMaskFront)) { + + gl.stencilFuncSeparate( + WebGLRenderingContext.FRONT, + WebGLCmpFuncs[dss.stencilFuncFront], + dss.stencilRefFront, + dss.stencilReadMaskFront); + + device.stateCache.dss.stencilFuncFront = dss.stencilFuncFront; + device.stateCache.dss.stencilRefFront = dss.stencilRefFront; + device.stateCache.dss.stencilReadMaskFront = dss.stencilReadMaskFront; + } + + if ((device.stateCache.dss.stencilFailOpFront !== dss.stencilFailOpFront) || + (device.stateCache.dss.stencilZFailOpFront !== dss.stencilZFailOpFront) || + (device.stateCache.dss.stencilPassOpFront !== dss.stencilPassOpFront)) { + + gl.stencilOpSeparate( + WebGLRenderingContext.FRONT, + WebGLStencilOps[dss.stencilFailOpFront], + WebGLStencilOps[dss.stencilZFailOpFront], + WebGLStencilOps[dss.stencilPassOpFront]); + + device.stateCache.dss.stencilFailOpFront = dss.stencilFailOpFront; + device.stateCache.dss.stencilZFailOpFront = dss.stencilZFailOpFront; + device.stateCache.dss.stencilPassOpFront = dss.stencilPassOpFront; + } + + if (device.stateCache.dss.stencilWriteMaskFront !== dss.stencilWriteMaskFront) { + gl.stencilMaskSeparate(WebGLRenderingContext.FRONT, dss.stencilWriteMaskFront); + device.stateCache.dss.stencilWriteMaskFront = dss.stencilWriteMaskFront; + } + + // back + if ((device.stateCache.dss.stencilFuncBack !== dss.stencilFuncBack) || + (device.stateCache.dss.stencilRefBack !== dss.stencilRefBack) || + (device.stateCache.dss.stencilReadMaskBack !== dss.stencilReadMaskBack)) { + + gl.stencilFuncSeparate( + WebGLRenderingContext.BACK, + WebGLCmpFuncs[dss.stencilFuncBack], + dss.stencilRefBack, + dss.stencilReadMaskBack); + + device.stateCache.dss.stencilFuncBack = dss.stencilFuncBack; + device.stateCache.dss.stencilRefBack = dss.stencilRefBack; + device.stateCache.dss.stencilReadMaskBack = dss.stencilReadMaskBack; + } + + if ((device.stateCache.dss.stencilFailOpBack !== dss.stencilFailOpBack) || + (device.stateCache.dss.stencilZFailOpBack !== dss.stencilZFailOpBack) || + (device.stateCache.dss.stencilPassOpBack !== dss.stencilPassOpBack)) { + + gl.stencilOpSeparate( + WebGLRenderingContext.BACK, + WebGLStencilOps[dss.stencilFailOpBack], + WebGLStencilOps[dss.stencilZFailOpBack], + WebGLStencilOps[dss.stencilPassOpBack]); + + device.stateCache.dss.stencilFailOpBack = dss.stencilFailOpBack; + device.stateCache.dss.stencilZFailOpBack = dss.stencilZFailOpBack; + device.stateCache.dss.stencilPassOpBack = dss.stencilPassOpBack; + } + + if (device.stateCache.dss.stencilWriteMaskBack !== dss.stencilWriteMaskBack) { + gl.stencilMaskSeparate(WebGLRenderingContext.BACK, dss.stencilWriteMaskBack); + device.stateCache.dss.stencilWriteMaskBack = dss.stencilWriteMaskBack; + } + } // depth-stencil state + + // blend state + const bs = cmd2.gpuPipelineState.bs; + if (bs) { + + if (device.stateCache.bs.isA2C !== bs.isA2C) { + if (bs.isA2C) { + gl.enable(WebGLRenderingContext.SAMPLE_ALPHA_TO_COVERAGE); + } else { + gl.disable(WebGLRenderingContext.SAMPLE_ALPHA_TO_COVERAGE); + } + device.stateCache.bs.isA2C = bs.isA2C; + } + + if ((device.stateCache.bs.blendColor[0] !== bs.blendColor[0]) || + (device.stateCache.bs.blendColor[1] !== bs.blendColor[1]) || + (device.stateCache.bs.blendColor[2] !== bs.blendColor[2]) || + (device.stateCache.bs.blendColor[3] !== bs.blendColor[3])) { + + gl.blendColor(bs.blendColor[0], bs.blendColor[1], bs.blendColor[2], bs.blendColor[3]); + + device.stateCache.bs.blendColor[0] = bs.blendColor[0]; + device.stateCache.bs.blendColor[1] = bs.blendColor[1]; + device.stateCache.bs.blendColor[2] = bs.blendColor[2]; + device.stateCache.bs.blendColor[3] = bs.blendColor[3]; + } + + const target0 = bs.targets[0]; + const catchTarget0 = device.stateCache.bs.targets[0]; + + if (catchTarget0.blend !== target0.blend) { + if (target0.blend) { + gl.enable(WebGLRenderingContext.BLEND); + } else { + gl.disable(WebGLRenderingContext.BLEND); + } + catchTarget0.blend = target0.blend; + } + + if ((catchTarget0.blendEq !== target0.blendEq) || + (catchTarget0.blendAlphaEq !== target0.blendAlphaEq)) { + + gl.blendEquationSeparate(WebGLBlendOps[target0.blendEq], WebGLBlendOps[target0.blendAlphaEq]); + + catchTarget0.blendEq = target0.blendEq; + catchTarget0.blendAlphaEq = target0.blendAlphaEq; + } + + if ((catchTarget0.blendSrc !== target0.blendSrc) || + (catchTarget0.blendDst !== target0.blendDst) || + (catchTarget0.blendSrcAlpha !== target0.blendSrcAlpha) || + (catchTarget0.blendDstAlpha !== target0.blendDstAlpha)) { + + gl.blendFuncSeparate( + WebGLBlendFactors[target0.blendSrc], + WebGLBlendFactors[target0.blendDst], + WebGLBlendFactors[target0.blendSrcAlpha], + WebGLBlendFactors[target0.blendDstAlpha]); + + catchTarget0.blendSrc = target0.blendSrc; + catchTarget0.blendDst = target0.blendDst; + catchTarget0.blendSrcAlpha = target0.blendSrcAlpha; + catchTarget0.blendDstAlpha = target0.blendDstAlpha; + } + + if (catchTarget0.blendColorMask !== target0.blendColorMask) { + + gl.colorMask( + (target0.blendColorMask & GFXColorMask.R) !== GFXColorMask.NONE, + (target0.blendColorMask & GFXColorMask.G) !== GFXColorMask.NONE, + (target0.blendColorMask & GFXColorMask.B) !== GFXColorMask.NONE, + (target0.blendColorMask & GFXColorMask.A) !== GFXColorMask.NONE); + + catchTarget0.blendColorMask = target0.blendColorMask; + } + } // blend state + } // bind pso + + if (cmd2.gpuBindingLayout && gpuShader) { + for (const gpuBinding of cmd2.gpuBindingLayout.gpuBindings) { + + switch (gpuBinding.type) { + case GFXBindingType.UNIFORM_BUFFER: { + + if (gpuBinding.gpuBuffer && gpuBinding.gpuBuffer.buffer) { + + let glBlock: WebGL2GPUUniformBlock | null = null; + + for (const block of gpuShader.glBlocks) { + if (block.binding === gpuBinding.binding) { + glBlock = block; + break; + } + } + + if (glBlock && gpuBinding.gpuBuffer.vf32) { + for (const glUniform of glBlock.glActiveUniforms) { + switch (glUniform.glType) { + case WebGLRenderingContext.BOOL: + case WebGLRenderingContext.INT: { + for (let u = 0; u < glUniform.array.length; ++u) { + const idx = glUniform.begin + u; + if (gpuBinding.gpuBuffer.vf32[idx] !== glUniform.array[u]) { + for (let n = u, m = glUniform.begin + u; n < glUniform.array.length; ++n, ++m) { + glUniform.array[n] = gpuBinding.gpuBuffer.vf32[m]; + } + gl.uniform1iv(glUniform.glLoc, glUniform.array); + break; + } + } + break; + } + case WebGLRenderingContext.BOOL_VEC2: + case WebGLRenderingContext.INT_VEC2: { + for (let u = 0; u < glUniform.array.length; ++u) { + const idx = glUniform.begin + u; + if (gpuBinding.gpuBuffer.vf32[idx] !== glUniform.array[u]) { + for (let n = u, m = glUniform.begin + u; n < glUniform.array.length; ++n, ++m) { + glUniform.array[n] = gpuBinding.gpuBuffer.vf32[m]; + } + gl.uniform2iv(glUniform.glLoc, glUniform.array); + break; + } + } + break; + } + case WebGLRenderingContext.BOOL_VEC3: + case WebGLRenderingContext.INT_VEC3: { + for (let u = 0; u < glUniform.array.length; ++u) { + const idx = glUniform.begin + u; + if (gpuBinding.gpuBuffer.vf32[idx] !== glUniform.array[u]) { + for (let n = u, m = glUniform.begin + u; n < glUniform.array.length; ++n, ++m) { + glUniform.array[n] = gpuBinding.gpuBuffer.vf32[m]; + } + gl.uniform3iv(glUniform.glLoc, glUniform.array); + break; + } + } + break; + } + case WebGLRenderingContext.BOOL_VEC4: + case WebGLRenderingContext.INT_VEC4: { + for (let u = 0; u < glUniform.array.length; ++u) { + const idx = glUniform.begin + u; + if (gpuBinding.gpuBuffer.vf32[idx] !== glUniform.array[u]) { + for (let n = u, m = glUniform.begin + u; n < glUniform.array.length; ++n, ++m) { + glUniform.array[n] = gpuBinding.gpuBuffer.vf32[m]; + } + gl.uniform4iv(glUniform.glLoc, glUniform.array); + break; + } + } + break; + } + case WebGLRenderingContext.FLOAT: { + for (let u = 0; u < glUniform.array.length; ++u) { + const idx = glUniform.begin + u; + if (CmpF32NotEuqal(gpuBinding.gpuBuffer.vf32[idx], glUniform.array[u])) { + for (let n = u, m = glUniform.begin + u; n < glUniform.array.length; ++n, ++m) { + glUniform.array[n] = gpuBinding.gpuBuffer.vf32[m]; + } + gl.uniform1fv(glUniform.glLoc, glUniform.array); + break; + } + } + break; + } + case WebGLRenderingContext.FLOAT_VEC2: { + for (let u = 0; u < glUniform.array.length; ++u) { + const idx = glUniform.begin + u; + if (CmpF32NotEuqal(gpuBinding.gpuBuffer.vf32[idx], glUniform.array[u])) { + for (let n = u, m = glUniform.begin + u; n < glUniform.array.length; ++n, ++m) { + glUniform.array[n] = gpuBinding.gpuBuffer.vf32[m]; + } + gl.uniform2fv(glUniform.glLoc, glUniform.array); + break; + } + } + break; + } + case WebGLRenderingContext.FLOAT_VEC3: { + for (let u = 0; u < glUniform.array.length; ++u) { + const idx = glUniform.begin + u; + if (CmpF32NotEuqal(gpuBinding.gpuBuffer.vf32[idx], glUniform.array[u])) { + for (let n = u, m = glUniform.begin + u; n < glUniform.array.length; ++n, ++m) { + glUniform.array[n] = gpuBinding.gpuBuffer.vf32[m]; + } + gl.uniform3fv(glUniform.glLoc, glUniform.array); + break; + } + } + break; + } + case WebGLRenderingContext.FLOAT_VEC4: { + for (let u = 0; u < glUniform.array.length; ++u) { + const idx = glUniform.begin + u; + if (CmpF32NotEuqal(gpuBinding.gpuBuffer.vf32[idx], glUniform.array[u])) { + for (let n = u, m = glUniform.begin + u; n < glUniform.array.length; ++n, ++m) { + glUniform.array[n] = gpuBinding.gpuBuffer.vf32[m]; + } + gl.uniform4fv(glUniform.glLoc, glUniform.array); + break; + } + } + break; + } + case WebGLRenderingContext.FLOAT_MAT2: { + for (let u = 0; u < glUniform.array.length; ++u) { + const idx = glUniform.begin + u; + if (CmpF32NotEuqal(gpuBinding.gpuBuffer.vf32[idx], glUniform.array[u])) { + for (let n = u, m = glUniform.begin + u; n < glUniform.array.length; ++n, ++m) { + glUniform.array[n] = gpuBinding.gpuBuffer.vf32[m]; + } + gl.uniformMatrix2fv(glUniform.glLoc, false, glUniform.array); + break; + } + } + break; + } + case WebGLRenderingContext.FLOAT_MAT3: { + for (let u = 0; u < glUniform.array.length; ++u) { + const idx = glUniform.begin + u; + if (CmpF32NotEuqal(gpuBinding.gpuBuffer.vf32[idx], glUniform.array[u])) { + for (let n = u, m = glUniform.begin + u; n < glUniform.array.length; ++n, ++m) { + glUniform.array[n] = gpuBinding.gpuBuffer.vf32[m]; + } + gl.uniformMatrix3fv(glUniform.glLoc, false, glUniform.array); + break; + } + } + break; + } + case WebGLRenderingContext.FLOAT_MAT4: { + for (let u = 0; u < glUniform.array.length; ++u) { + const idx = glUniform.begin + u; + if (CmpF32NotEuqal(gpuBinding.gpuBuffer.vf32[idx], glUniform.array[u])) { + for (let n = u, m = glUniform.begin + u; n < glUniform.array.length; ++n, ++m) { + glUniform.array[n] = gpuBinding.gpuBuffer.vf32[m]; + } + gl.uniformMatrix4fv(glUniform.glLoc, false, glUniform.array); + break; + } + } + break; + } + default: + } + } + } + } // if + + break; + } + case GFXBindingType.SAMPLER: { + + if (gpuBinding.gpuSampler) { + + let glSampler: WebGL2GPUUniformSampler | null = null; + + for (const sampler of gpuShader.glSamplers) { + if (sampler.binding === gpuBinding.binding) { + glSampler = sampler; + break; + } + } + + if (glSampler) { + for (const texUnit of glSampler.units) { + + if (device.stateCache.texUnit !== texUnit) { + gl.activeTexture(WebGLRenderingContext.TEXTURE0 + texUnit); + device.stateCache.texUnit = texUnit; + } + + let glTexUnit: IWebGL2TexUnit | null = null; + + if (gpuBinding.gpuTexView) { + const gpuTexture = gpuBinding.gpuTexView.gpuTexture; + switch (glSampler.glType) { + case WebGLRenderingContext.SAMPLER_2D: { + glTexUnit = device.stateCache.glTex2DUnits[texUnit]; + if (glTexUnit.glTexture !== gpuTexture.glTexture) { + gl.bindTexture(WebGLRenderingContext.TEXTURE_2D, gpuTexture.glTexture); + glTexUnit.glTexture = gpuTexture.glTexture; + } + break; + } + case WebGLRenderingContext.SAMPLER_CUBE: { + glTexUnit = device.stateCache.glTexCubeUnits[texUnit]; + + if (glTexUnit.glTexture !== gpuTexture.glTexture) { + gl.bindTexture(WebGLRenderingContext.TEXTURE_CUBE_MAP, gpuTexture.glTexture); + glTexUnit.glTexture = gpuTexture.glTexture; + } + break; + } + default: { + console.error('Unsupported GL Texture type.'); + } + } + + if (glTexUnit) { + const gpuSampler = gpuBinding.gpuSampler; + + if (gpuTexture.glWrapS !== gpuSampler.glWrapS) { + gl.texParameteri(gpuTexture.glTarget, WebGLRenderingContext.TEXTURE_WRAP_S, gpuSampler.glWrapS); + gpuTexture.glWrapS = gpuSampler.glWrapS; + } + + if (gpuTexture.glWrapT !== gpuSampler.glWrapT) { + gl.texParameteri(gpuTexture.glTarget, WebGLRenderingContext.TEXTURE_WRAP_T, gpuSampler.glWrapT); + gpuTexture.glWrapT = gpuSampler.glWrapT; + } + + if (gpuTexture.glMinFilter !== gpuSampler.glMinFilter) { + gl.texParameteri(gpuTexture.glTarget, WebGLRenderingContext.TEXTURE_MIN_FILTER, gpuSampler.glMinFilter); + gpuTexture.glMinFilter = gpuSampler.glMinFilter; + } + + if (gpuTexture.glMagFilter !== gpuSampler.glMagFilter) { + gl.texParameteri(gpuTexture.glTarget, WebGLRenderingContext.TEXTURE_MAG_FILTER, gpuSampler.glMagFilter); + gpuTexture.glMagFilter = gpuSampler.glMagFilter; + } + } + } else { + console.error('Not found texture view on binding unit ' + gpuBinding.binding); + } + } + } // if + } else { + console.error('Not found sampler or texture view on binding unit ' + gpuBinding.binding); + } + + break; + } + } + } + } // bind binding layout + + if (cmd2.gpuInputAssembler && gpuShader) { + gpuInputAssembler = cmd2.gpuInputAssembler; + + for (let a = 0; a < device.maxVertexAttributes; ++a) { + device.stateCache.glCurrentAttribLocs[a] = false; + } + + for (const glInput of gpuShader.glInputs) { + let glAttrib: WebGL2Attrib | null = null; + + for (const attrib of gpuInputAssembler.glAttribs) { + if (attrib.name === glInput.name) { + glAttrib = attrib; + break; + } + } + + if (glAttrib) { + if (device.stateCache.glArrayBuffer !== glAttrib.glBuffer) { + gl.bindBuffer(WebGLRenderingContext.ARRAY_BUFFER, glAttrib.glBuffer); + device.stateCache.glArrayBuffer = glAttrib.glBuffer; + } + + for (let c = 0; c < glAttrib.componentCount; ++c) { + const glLoc = glInput.glLoc + c; + const attribOffset = glAttrib.offset + glAttrib.size * c; + + if (!device.stateCache.glEnabledAttribLocs[glLoc] && glLoc >= 0) { + gl.enableVertexAttribArray(glLoc); + device.stateCache.glEnabledAttribLocs[glLoc] = true; + } + device.stateCache.glCurrentAttribLocs[glLoc] = true; + + gl.vertexAttribPointer(glLoc, glAttrib.count, glAttrib.glType, glAttrib.isNormalized, glAttrib.stride, attribOffset); + } + } + } // for + + const gpuBuffer = gpuInputAssembler.gpuIndexBuffer; + if (gpuBuffer) { + if (device.stateCache.glElementArrayBuffer !== gpuBuffer.glBuffer) { + gl.bindBuffer(WebGLRenderingContext.ELEMENT_ARRAY_BUFFER, gpuBuffer.glBuffer); + device.stateCache.glElementArrayBuffer = gpuBuffer.glBuffer; + } + } + + for (let a = 0; a < device.maxVertexAttributes; ++a) { + if (device.stateCache.glEnabledAttribLocs[a] !== device.stateCache.glCurrentAttribLocs[a]) { + gl.disableVertexAttribArray(a); + device.stateCache.glEnabledAttribLocs[a] = false; + } + } + } + + if (gpuPipelineState) { + for (const dynamicState of gpuPipelineState.dynamicStates) { + switch (dynamicState) { + case GFXDynamicState.VIEWPORT: { + if (cmd2.viewport) { + if (device.stateCache.viewport.left !== cmd2.viewport.left || + device.stateCache.viewport.top !== cmd2.viewport.top || + device.stateCache.viewport.width !== cmd2.viewport.width || + device.stateCache.viewport.height !== cmd2.viewport.height) { + + gl.viewport(cmd2.viewport.left, cmd2.viewport.top, cmd2.viewport.width, cmd2.viewport.height); + + device.stateCache.viewport.left = cmd2.viewport.left; + device.stateCache.viewport.top = cmd2.viewport.top; + device.stateCache.viewport.width = cmd2.viewport.width; + device.stateCache.viewport.height = cmd2.viewport.height; + } + } + break; + } + case GFXDynamicState.SCISSOR: { + if (cmd2.scissor) { + if (device.stateCache.scissorRect.x !== cmd2.scissor.x || + device.stateCache.scissorRect.y !== cmd2.scissor.y || + device.stateCache.scissorRect.width !== cmd2.scissor.width || + device.stateCache.scissorRect.height !== cmd2.scissor.height) { + + gl.scissor(cmd2.scissor.x, cmd2.scissor.y, cmd2.scissor.width, cmd2.scissor.height); + + device.stateCache.scissorRect.x = cmd2.scissor.x; + device.stateCache.scissorRect.y = cmd2.scissor.y; + device.stateCache.scissorRect.width = cmd2.scissor.width; + device.stateCache.scissorRect.height = cmd2.scissor.height; + } + } + break; + } + case GFXDynamicState.LINE_WIDTH: { + if (cmd2.lineWidth) { + if (device.stateCache.rs.lineWidth !== cmd2.lineWidth) { + gl.lineWidth(cmd2.lineWidth); + device.stateCache.rs.lineWidth = cmd2.lineWidth; + } + } + break; + } + case GFXDynamicState.DEPTH_BIAS: { + if (cmd2.depthBias) { + + if ((device.stateCache.rs.depthBias !== cmd2.depthBias.constantFactor) || + (device.stateCache.rs.depthBiasSlop !== cmd2.depthBias.slopeFactor)) { + gl.polygonOffset(cmd2.depthBias.constantFactor, cmd2.depthBias.slopeFactor); + device.stateCache.rs.depthBias = cmd2.depthBias.constantFactor; + device.stateCache.rs.depthBiasSlop = cmd2.depthBias.slopeFactor; + } + } + break; + } + case GFXDynamicState.BLEND_CONSTANTS: { + if (cmd2.blendConstants) { + if ((device.stateCache.bs.blendColor[0] !== cmd2.blendConstants[0]) || + (device.stateCache.bs.blendColor[1] !== cmd2.blendConstants[1]) || + (device.stateCache.bs.blendColor[2] !== cmd2.blendConstants[2]) || + (device.stateCache.bs.blendColor[3] !== cmd2.blendConstants[3])) { + + gl.blendColor(cmd2.blendConstants[0], cmd2.blendConstants[1], cmd2.blendConstants[2], cmd2.blendConstants[3]); + + device.stateCache.bs.blendColor[0] = cmd2.blendConstants[0]; + device.stateCache.bs.blendColor[1] = cmd2.blendConstants[1]; + device.stateCache.bs.blendColor[2] = cmd2.blendConstants[2]; + device.stateCache.bs.blendColor[3] = cmd2.blendConstants[3]; + } + } + break; + } + case GFXDynamicState.STENCIL_WRITE_MASK: { + if (cmd2.stencilWriteMask) { + switch (cmd2.stencilWriteMask.face) { + case GFXStencilFace.FRONT: { + if (device.stateCache.dss.stencilWriteMaskFront !== cmd2.stencilWriteMask.writeMask) { + gl.stencilMaskSeparate(WebGLRenderingContext.FRONT, cmd2.stencilWriteMask.writeMask); + device.stateCache.dss.stencilWriteMaskFront = cmd2.stencilWriteMask.writeMask; + } + break; + } + case GFXStencilFace.BACK: { + if (device.stateCache.dss.stencilWriteMaskBack !== cmd2.stencilWriteMask.writeMask) { + gl.stencilMaskSeparate(WebGLRenderingContext.BACK, cmd2.stencilWriteMask.writeMask); + device.stateCache.dss.stencilWriteMaskBack = cmd2.stencilWriteMask.writeMask; + } + break; + } + case GFXStencilFace.ALL: { + if (device.stateCache.dss.stencilWriteMaskFront !== cmd2.stencilWriteMask.writeMask || + device.stateCache.dss.stencilWriteMaskBack !== cmd2.stencilWriteMask.writeMask) { + gl.stencilMask(cmd2.stencilWriteMask.writeMask); + device.stateCache.dss.stencilWriteMaskFront = cmd2.stencilWriteMask.writeMask; + device.stateCache.dss.stencilWriteMaskBack = cmd2.stencilWriteMask.writeMask; + } + break; + } + } + } + break; + } + case GFXDynamicState.STENCIL_COMPARE_MASK: { + if (cmd2.stencilCompareMask) { + switch (cmd2.stencilCompareMask.face) { + case GFXStencilFace.FRONT: { + if (device.stateCache.dss.stencilRefFront !== cmd2.stencilCompareMask.reference || + device.stateCache.dss.stencilReadMaskFront !== cmd2.stencilCompareMask.compareMask) { + gl.stencilFuncSeparate( + WebGLRenderingContext.FRONT, + WebGLCmpFuncs[device.stateCache.dss.stencilFuncFront], + cmd2.stencilCompareMask.reference, + cmd2.stencilCompareMask.compareMask); + device.stateCache.dss.stencilRefFront = cmd2.stencilCompareMask.reference; + device.stateCache.dss.stencilReadMaskFront = cmd2.stencilCompareMask.compareMask; + } + break; + } + case GFXStencilFace.BACK: { + if (device.stateCache.dss.stencilRefBack !== cmd2.stencilCompareMask.reference || + device.stateCache.dss.stencilReadMaskBack !== cmd2.stencilCompareMask.compareMask) { + gl.stencilFuncSeparate( + WebGLRenderingContext.BACK, + WebGLCmpFuncs[device.stateCache.dss.stencilFuncBack], + cmd2.stencilCompareMask.reference, + cmd2.stencilCompareMask.compareMask); + device.stateCache.dss.stencilRefBack = cmd2.stencilCompareMask.reference; + device.stateCache.dss.stencilReadMaskBack = cmd2.stencilCompareMask.compareMask; + } + break; + } + case GFXStencilFace.ALL: { + if (device.stateCache.dss.stencilRefFront !== cmd2.stencilCompareMask.reference || + device.stateCache.dss.stencilReadMaskFront !== cmd2.stencilCompareMask.compareMask || + device.stateCache.dss.stencilRefBack !== cmd2.stencilCompareMask.reference || + device.stateCache.dss.stencilReadMaskBack !== cmd2.stencilCompareMask.compareMask) { + gl.stencilFunc( + WebGLCmpFuncs[device.stateCache.dss.stencilFuncBack], + cmd2.stencilCompareMask.reference, + cmd2.stencilCompareMask.compareMask); + device.stateCache.dss.stencilRefFront = cmd2.stencilCompareMask.reference; + device.stateCache.dss.stencilReadMaskFront = cmd2.stencilCompareMask.compareMask; + device.stateCache.dss.stencilRefBack = cmd2.stencilCompareMask.reference; + device.stateCache.dss.stencilReadMaskBack = cmd2.stencilCompareMask.compareMask; + } + break; + } + } + } + break; + } + } // switch + } // for + } // if + + break; + } + case WebGL2Cmd.DRAW: { + const cmd3: WebGL2CmdDraw = cmdPackage.drawCmds.array[cmdId]; + if (gpuInputAssembler && gpuShader) { + if (!gpuInputAssembler.gpuIndirectBuffer) { + const gpuBuffer = gpuInputAssembler.gpuIndexBuffer; + if (gpuBuffer && cmd3.drawInfo.indexCount > 0) { + const offset = cmd3.drawInfo.firstIndex * gpuBuffer.stride; + gl.drawElements(glPrimitive, cmd3.drawInfo.indexCount, gpuInputAssembler.glIndexType, offset); + } else { + gl.drawArrays(glPrimitive, cmd3.drawInfo.firstVertex, cmd3.drawInfo.vertexCount); + } + } else { + if (gpuInputAssembler.gpuIndirectBuffer) { + for (const drawInfo of gpuInputAssembler.gpuIndirectBuffer.indirects) { + const gpuBuffer = gpuInputAssembler.gpuIndexBuffer; + if (gpuBuffer && drawInfo.indexCount > -1) { + const offset = drawInfo.firstIndex * gpuBuffer.stride; + gl.drawElements(glPrimitive, drawInfo.indexCount, gpuInputAssembler.glIndexType, offset); + } else { + gl.drawArrays(glPrimitive, drawInfo.firstVertex, drawInfo.vertexCount); + } + } + } + } + } + break; + } + case WebGL2Cmd.UPDATE_BUFFER: { + const cmd4 = cmdPackage.updateBufferCmds.array[cmdId]; + WebGL2CmdFuncUpdateBuffer( + device, + cmd4.gpuBuffer as WebGL2GPUBuffer, + cmd4.buffer as GFXBufferSource, + cmd4.offset, + cmd4.size); + + break; + } + case WebGL2Cmd.COPY_BUFFER_TO_TEXTURE: { + const cmd5 = cmdPackage.copyBufferToTextureCmds.array[cmdId]; + WebGL2CmdFuncCopyBufferToTexture( + device, + (cmd5.gpuBuffer as WebGL2GPUBuffer).buffer as GFXBufferSource, + cmd5.gpuTexture as WebGL2GPUTexture, + cmd5.regions); + + break; + } + } // switch + } // for +} + +export function WebGL2CmdFuncCopyBufferToTexture ( + device: WebGL2GFXDevice, + buffer: GFXBufferSource, + gpuTexture: WebGL2GPUTexture, + regions: GFXBufferTextureCopy[]) { + + const gl = device.gl; + + const buff = buffer as ArrayBuffer; + const fmtInfo: IGFXFormatInfo = GFXFormatInfos[gpuTexture.format]; + let m = 0; + let w = 1; + let h = 1; + let f = 0; + let buffOffset = 0; + + switch (gpuTexture.glTarget) { + case WebGLRenderingContext.TEXTURE_2D: { + const glTexUnit = device.stateCache.glTex2DUnits[device.stateCache.texUnit]; + if (glTexUnit.glTexture !== gpuTexture.glTexture) { + gl.bindTexture(WebGLRenderingContext.TEXTURE_2D, gpuTexture.glTexture); + glTexUnit.glTexture = gpuTexture.glTexture; + } + + const isCompressed = GFXFormatInfos[gpuTexture.format].isCompressed; + if (!isCompressed) { + for (const region of regions) { + buffOffset = region.buffOffset + region.buffTexHeight * region.buffStride; + + w = region.texExtent.width; + h = region.texExtent.height; + + for (m = region.texSubres.baseMipLevel; m < region.texSubres.levelCount; ++m) { + const memSize = GFXFormatSize(gpuTexture.format, w, h, 1); + const data = buff.slice(buffOffset, buffOffset + memSize); + const pixels = !fmtInfo.isFloating ? new Uint8Array(data) : new Float32Array(data); + + gl.texSubImage2D(WebGLRenderingContext.TEXTURE_2D, m, + region.texOffset.x, region.texOffset.y, w, h, + gpuTexture.glFormat, gpuTexture.glType, pixels); + + buffOffset += memSize; + w = Math.max(1, w >> 1); + h = Math.max(1, w >> 1); + } + } + } else { + for (const region of regions) { + buffOffset = region.buffOffset + region.buffTexHeight * region.buffStride; + + w = region.texExtent.width; + h = region.texExtent.height; + + for (m = region.texSubres.baseMipLevel; m < region.texSubres.levelCount; ++m) { + const memSize = GFXFormatSize(gpuTexture.format, w, h, 1); + const data = buff.slice(buffOffset, buffOffset + memSize); + const pixels = !fmtInfo.isFloating ? new Uint8Array(data) : new Float32Array(data); + + gl.compressedTexSubImage2D(WebGLRenderingContext.TEXTURE_2D, m, + region.texOffset.x, region.texOffset.y, w, h, + gpuTexture.glFormat, pixels); + + buffOffset += memSize; + w = Math.max(1, w >> 1); + h = Math.max(1, w >> 1); + } + } + } + break; + } + case WebGLRenderingContext.TEXTURE_CUBE_MAP: { + const glTexUnit = device.stateCache.glTexCubeUnits[device.stateCache.texUnit]; + if (glTexUnit.glTexture !== gpuTexture.glTexture) { + gl.bindTexture(WebGLRenderingContext.TEXTURE_CUBE_MAP, gpuTexture.glTexture); + glTexUnit.glTexture = gpuTexture.glTexture; + } + + const isCompressed = GFXFormatInfos[gpuTexture.format].isCompressed; + if (!isCompressed) { + for (const region of regions) { + buffOffset = region.buffOffset + region.buffTexHeight * region.buffStride; + const fcount = region.texSubres.baseArrayLayer + region.texSubres.layerCount; + for (f = region.texSubres.baseArrayLayer; f < fcount; ++f) { + w = region.texExtent.width; + h = region.texExtent.height; + + const mcount = region.texSubres.baseMipLevel + region.texSubres.levelCount; + for (m = region.texSubres.baseMipLevel; m < mcount; ++m) { + const memSize = GFXFormatSize(gpuTexture.format, w, h, 1); + const data = buff.slice(buffOffset, buffOffset + memSize); + const pixels = !fmtInfo.isFloating ? new Uint8Array(data) : new Float32Array(data); + + gl.texSubImage2D(WebGLRenderingContext.TEXTURE_CUBE_MAP_POSITIVE_X + f, m, + region.texOffset.x, region.texOffset.y, w, h, + gpuTexture.glFormat, gpuTexture.glType, pixels); + + buffOffset += memSize; + w = Math.max(1, w >> 1); + h = Math.max(1, w >> 1); + } + } + } + } else { + for (const region of regions) { + buffOffset = region.buffOffset + region.buffTexHeight * region.buffStride; + const fcount = region.texSubres.baseArrayLayer + region.texSubres.layerCount; + for (f = region.texSubres.baseArrayLayer; f < fcount; ++f) { + w = region.texExtent.width; + h = region.texExtent.height; + + const mcount = region.texSubres.baseMipLevel + region.texSubres.levelCount; + for (m = region.texSubres.baseMipLevel; m < mcount; ++m) { + const memSize = GFXFormatSize(gpuTexture.format, w, h, 1); + const data = buff.slice(buffOffset, buffOffset + memSize); + const pixels = !fmtInfo.isFloating ? new Uint8Array(data) : new Float32Array(data); + + gl.compressedTexSubImage2D(WebGLRenderingContext.TEXTURE_CUBE_MAP_POSITIVE_X + f, m, + region.texOffset.x, region.texOffset.y, w, h, + gpuTexture.glFormat, pixels); + + buffOffset += memSize; + w = Math.max(1, w >> 1); + h = Math.max(1, w >> 1); + } + } + } + } + break; + } + default: { + console.error('Unsupported GL texture type, copy buffer to texture failed.'); + } + } + + if (gpuTexture.flags & GFXTextureFlagBit.GEN_MIPMAP) { + gl.generateMipmap(gpuTexture.glTarget); + } +} diff --git a/cocos/gfx/webgl2/webgl2-device.ts b/cocos/gfx/webgl2/webgl2-device.ts new file mode 100644 index 0000000000..bb0b86a487 --- /dev/null +++ b/cocos/gfx/webgl2/webgl2-device.ts @@ -0,0 +1,469 @@ +import { GFXBindingLayout, IGFXBindingLayoutInfo } from '../binding-layout'; +import { GFXBuffer, IGFXBufferInfo } from '../buffer'; +import { GFXCommandAllocator, IGFXCommandAllocatorInfo } from '../command-allocator'; +import { GFXCommandBuffer, IGFXCommandBufferInfo } from '../command-buffer'; +import { GFXBufferTextureCopy, GFXFormat, GFXFormatInfos, GFXFormatSize, GFXQueueType } from '../define'; +import { GFXDevice, GFXFeature, IGFXDeviceInfo } from '../device'; +import { GFXFramebuffer, IGFXFramebufferInfo } from '../framebuffer'; +import { GFXInputAssembler, IGFXInputAssemblerInfo } from '../input-assembler'; +import { GFXPipelineLayout, IGFXPipelineLayoutInfo } from '../pipeline-layout'; +import { GFXPipelineState, IGFXPipelineStateInfo } from '../pipeline-state'; +import { GFXQueue, IGFXQueueInfo } from '../queue'; +import { GFXRenderPass, IGFXRenderPassInfo } from '../render-pass'; +import { GFXSampler, IGFXSamplerInfo } from '../sampler'; +import { GFXShader, IGFXShaderInfo } from '../shader'; +import { GFXTexture, IGFXTextureInfo } from '../texture'; +import { GFXTextureView, IGFXTextureViewInfo } from '../texture-view'; +import { GFXWindow, IGFXWindowInfo } from '../window'; +import { WebGL2GFXBindingLayout } from './webgl2-binding-layout'; +import { WebGL2GFXBuffer } from './webgl2-buffer'; +import { WebGL2GFXCommandAllocator } from './webgl2-command-allocator'; +import { WebGL2GFXCommandBuffer } from './webgl2-command-buffer'; +import { WebGL2CmdFuncCopyBufferToTexture } from './webgl2-commands'; +import { WebGL2GFXFramebuffer } from './webgl2-framebuffer'; +import { WebGL2GFXInputAssembler } from './webgl2-input-assembler'; +import { WebGL2GFXPipelineLayout } from './webgl2-pipeline-layout'; +import { WebGL2GFXPipelineState } from './webgl2-pipeline-state'; +import { WebGL2GFXQueue } from './webgl2-queue'; +import { WebGL2GFXRenderPass } from './webgl2-render-pass'; +import { WebGL2GFXSampler } from './webgl2-sampler'; +import { WebGL2GFXShader } from './webgl2-shader'; +import { WebGL2StateCache } from './webgl2-state-cache'; +import { WebGL2GFXTexture } from './webgl2-texture'; +import { WebGL2GFXTextureView } from './webgl2-texture-view'; +import { WebGL2GFXWindow } from './webgl2-window'; + +export class WebGL2GFXDevice extends GFXDevice { + + public get gl (): WebGL2RenderingContext { + return this._webGL2RC as WebGL2RenderingContext; + } + + public get isAntialias (): boolean { + return this._isAntialias; + } + + public get isPremultipliedAlpha (): boolean { + return this._isPremultipliedAlpha; + } + + public get EXT_texture_filter_anisotropic (): EXT_texture_filter_anisotropic | null { + return this._EXT_texture_filter_anisotropic; + } + + public get OES_texture_float_linear (): OES_texture_float_linear | null { + return this._OES_texture_float_linear; + } + + public get EXT_color_buffer_float (): EXT_color_buffer_float | null { + return this._EXT_color_buffer_float; + } + + public get EXT_disjoint_timer_query_webgl2 (): EXT_disjoint_timer_query_webgl2 | null { + return this._EXT_disjoint_timer_query_webgl2; + } + + public get WEBGL_compressed_texture_s3tc (): WEBGL_compressed_texture_s3tc | null { + return this._WEBGL_compressed_texture_s3tc; + } + + public get WEBGL_compressed_texture_s3tc_srgb (): WEBGL_compressed_texture_s3tc_srgb | null { + return this._WEBGL_compressed_texture_s3tc_srgb; + } + + public stateCache: WebGL2StateCache = new WebGL2StateCache(); + + private _webGL2RC: WebGL2RenderingContext | null = null; + private _isAntialias: boolean = true; + private _isPremultipliedAlpha: boolean = true; + + private _extensions: string[] | null = null; + private _EXT_texture_filter_anisotropic: EXT_texture_filter_anisotropic | null = null; + private _OES_texture_float_linear: OES_texture_float_linear | null = null; + private _EXT_color_buffer_float: EXT_color_buffer_float | null = null; + private _EXT_disjoint_timer_query_webgl2: EXT_disjoint_timer_query_webgl2 | null = null; + private _WEBGL_compressed_texture_s3tc: WEBGL_compressed_texture_s3tc | null = null; + private _WEBGL_compressed_texture_s3tc_srgb: WEBGL_compressed_texture_s3tc_srgb | null = null; + private _WEBGL_debug_renderer_info: WEBGL_debug_renderer_info | null = null; + private _WEBGL_debug_shaders: WEBGL_debug_shaders | null = null; + private _WEBGL_lose_context: WEBGL_lose_context | null = null; + + constructor () { + super(); + } + + public initialize (info: IGFXDeviceInfo): boolean { + + this._canvas = info.canvasElm as HTMLCanvasElement; + this._isAntialias = info.isAntialias !== undefined ? info.isAntialias : true; + this._isPremultipliedAlpha = info.isPremultipliedAlpha !== undefined ? info.isPremultipliedAlpha : true; + + try { + const webGLCtxAttribs: WebGLContextAttributes = { + alpha: true, + antialias: this._isAntialias, + depth: true, + stencil: true, + premultipliedAlpha: this._isPremultipliedAlpha, + preserveDrawingBuffer: false, + powerPreference: 'default', + failIfMajorPerformanceCaveat: false, + }; + + this._webGL2RC = this._canvas.getContext('webgl2', webGLCtxAttribs); + /* + if (this._webGLRC && info.debug) { + this._webGLRC = WebGLDeveloperTools.makeDebugContext(this._webGLRC, this._onWebGLError.bind(this)); + } + */ + } catch (err) { + console.error(err); + return false; + } + + // No errors are thrown using try catch + // Tested through ios baidu browser 4.14.1 + if (!this._webGL2RC) { + console.error('This device does not support WebGL.'); + return false; + } + + this._canvas2D = document.createElement('canvas'); + + console.info('WebGL2 device initialized.'); + + this._deviceName = 'WebGL2'; + const gl = this._webGL2RC; + + this._WEBGL_debug_renderer_info = gl.getExtension('WEBGL_debug_renderer_info'); + if (this._WEBGL_debug_renderer_info) { + this._renderer = gl.getParameter(this._WEBGL_debug_renderer_info.UNMASKED_RENDERER_WEBGL); + this._vendor = gl.getParameter(this._WEBGL_debug_renderer_info.UNMASKED_VENDOR_WEBGL); + } else { + this._renderer = gl.getParameter(WebGLRenderingContext.RENDERER); + this._vendor = gl.getParameter(WebGLRenderingContext.VENDOR); + } + + this._version = gl.getParameter(WebGLRenderingContext.VERSION); + this._maxVertexAttributes = gl.getParameter(WebGLRenderingContext.MAX_VERTEX_ATTRIBS); + this._maxVertexUniformVectors = gl.getParameter(WebGLRenderingContext.MAX_VERTEX_UNIFORM_VECTORS); + this._maxFragmentUniformVectors = gl.getParameter(WebGLRenderingContext.MAX_FRAGMENT_UNIFORM_VECTORS); + this._maxTextureUnits = gl.getParameter(WebGLRenderingContext.MAX_TEXTURE_IMAGE_UNITS); + this._maxVertexTextureUnits = gl.getParameter(WebGLRenderingContext.MAX_VERTEX_TEXTURE_IMAGE_UNITS); + this._depthBits = gl.getParameter(WebGLRenderingContext.DEPTH_BITS); + this._stencilBits = gl.getParameter(WebGLRenderingContext.STENCIL_BITS); + + this._width = this._canvas.width; + this._height = this._canvas.height; + this._colorFmt = GFXFormat.RGBA8; + + if (this._depthBits === 32) { + if (this._stencilBits === 8) { + this._depthStencilFmt = GFXFormat.D32F_S8; + } else { + this._depthStencilFmt = GFXFormat.D32F; + } + } else if (this._depthBits === 24) { + if (this._stencilBits === 8) { + this._depthStencilFmt = GFXFormat.D24S8; + } else { + this._depthStencilFmt = GFXFormat.D24; + } + } else { + if (this._stencilBits === 8) { + this._depthStencilFmt = GFXFormat.D16S8; + } else { + this._depthStencilFmt = GFXFormat.D16; + } + } + + console.info('RENDERER: ' + this._renderer); + console.info('VENDOR: ' + this._vendor); + console.info('VERSION: ' + this._version); + console.info('SCREEN_SIZE: ' + this._width + ' x ' + this._height); + console.info('COLOR_FORMAT: ' + GFXFormatInfos[this._colorFmt].name); + console.info('DEPTH_STENCIL_FORMAT: ' + GFXFormatInfos[this._depthStencilFmt].name); + + console.info('MAX_VERTEX_ATTRIBS: ' + this._maxVertexAttributes); + console.info('MAX_VERTEX_UNIFORM_VECTORS: ' + this._maxVertexUniformVectors); + console.info('MAX_FRAGMENT_UNIFORM_VECTORS: ' + this._maxFragmentUniformVectors); + console.info('MAX_TEXTURE_IMAGE_UNITS: ' + this._maxTextureUnits); + console.info('MAX_VERTEX_TEXTURE_IMAGE_UNITS: ' + this._maxVertexTextureUnits); + console.info('DEPTH_BITS: ' + this._depthBits); + console.info('STENCIL_BITS: ' + this._stencilBits); + + this._extensions = gl.getSupportedExtensions(); + /* + if (this._extensions) { + for (let i = 0; i < this._extensions.length; ++i) { + console.info(this._extensions[i]); + } + } + */ + + this._EXT_texture_filter_anisotropic = gl.getExtension('EXT_texture_filter_anisotropic'); + this._EXT_color_buffer_float = gl.getExtension('EXT_color_buffer_float'); + this._EXT_disjoint_timer_query_webgl2 = gl.getExtension('EXT_disjoint_timer_query_webgl2'); + this._OES_texture_float_linear = gl.getExtension('OES_texture_float_linear'); + this._WEBGL_compressed_texture_s3tc = gl.getExtension('WEBGL_compressed_texture_s3tc'); + this._WEBGL_compressed_texture_s3tc_srgb = gl.getExtension('WEBGL_compressed_texture_s3tc_srgb'); + this._WEBGL_debug_shaders = gl.getExtension('WEBGL_debug_shaders'); + this._WEBGL_lose_context = gl.getExtension('WEBGL_lose_context'); + + this._features.fill(false); + this._features[GFXFeature.TEXTURE_FLOAT] = true; + this._features[GFXFeature.TEXTURE_HALF_FLOAT] = true; + + // init states + this.initStates(gl); + + // create queue + this._queue = this.createQueue({ type: GFXQueueType.GRAPHICS }); + + // create primary window + this._mainWindow = this.createWindow({ + title: this._webGL2RC.canvas.title, + left: this._webGL2RC.canvas.offsetLeft, + top: this._webGL2RC.canvas.offsetTop, + width: this._webGL2RC.drawingBufferWidth, + height: this._webGL2RC.drawingBufferHeight, + colorFmt: this._colorFmt, + depthStencilFmt: this._depthStencilFmt, + }); + + this._cmdAllocator = this.createCommandAllocator({}); + + return true; + } + + public destroy (): void { + + if (this._mainWindow) { + this._mainWindow.destroy(); + this._mainWindow = null; + } + + if (this._cmdAllocator) { + this._cmdAllocator.destroy(); + this._cmdAllocator = null; + } + + if (this._queue) { + this._queue.destroy(); + this._queue = null; + } + + this._webGL2RC = null; + } + + public resize (width: number, height: number) { + this._canvas!.width = width; + this._canvas!.height = height; + this._width = width; + this._height = height; + } + + public createBuffer (info: IGFXBufferInfo): GFXBuffer { + const buffer = new WebGL2GFXBuffer(this); + buffer.initialize(info); + return buffer; + } + + public createTexture (info: IGFXTextureInfo): GFXTexture { + const texture = new WebGL2GFXTexture(this); + texture.initialize(info); + return texture; + } + + public createTextureView (info: IGFXTextureViewInfo): GFXTextureView { + const texView = new WebGL2GFXTextureView(this); + texView.initialize(info); + return texView; + } + + public createSampler (info: IGFXSamplerInfo): GFXSampler { + const sampler = new WebGL2GFXSampler(this); + sampler.initialize(info); + return sampler; + } + + public createBindingLayout (info: IGFXBindingLayoutInfo): GFXBindingLayout { + const bindingLayout = new WebGL2GFXBindingLayout(this); + bindingLayout.initialize(info); + return bindingLayout; + } + + public createShader (info: IGFXShaderInfo): GFXShader { + const shader = new WebGL2GFXShader(this); + shader.initialize(info); + return shader; + } + + public createInputAssembler (info: IGFXInputAssemblerInfo): GFXInputAssembler { + const inputAssembler = new WebGL2GFXInputAssembler(this); + inputAssembler.initialize(info); + return inputAssembler; + } + + public createRenderPass (info: IGFXRenderPassInfo): GFXRenderPass { + const renderPass = new WebGL2GFXRenderPass(this); + renderPass.initialize(info); + return renderPass; + } + + public createFramebuffer (info: IGFXFramebufferInfo): GFXFramebuffer { + const framebuffer = new WebGL2GFXFramebuffer(this); + framebuffer.initialize(info); + return framebuffer; + } + + public createPipelineLayout (info: IGFXPipelineLayoutInfo): GFXPipelineLayout { + const pipelineLayout = new WebGL2GFXPipelineLayout(this); + pipelineLayout.initialize(info); + return pipelineLayout; + } + + public createPipelineState (info: IGFXPipelineStateInfo): GFXPipelineState { + const pipelineState = new WebGL2GFXPipelineState(this); + pipelineState.initialize(info); + return pipelineState; + } + + public createCommandAllocator (info: IGFXCommandAllocatorInfo): GFXCommandAllocator { + const cmdAllocator = new WebGL2GFXCommandAllocator(this); + cmdAllocator.initialize(info); + return cmdAllocator; + } + + public createCommandBuffer (info: IGFXCommandBufferInfo): GFXCommandBuffer { + const cmdBuff = new WebGL2GFXCommandBuffer(this); + cmdBuff.initialize(info); + return cmdBuff; + } + + public createQueue (info: IGFXQueueInfo): GFXQueue { + const queue = new WebGL2GFXQueue(this); + queue.initialize(info); + return queue; + } + + public createWindow (info: IGFXWindowInfo): GFXWindow { + const window = new WebGL2GFXWindow(this); + window.initialize(info); + return window; + } + + public present () { + (this._cmdAllocator as WebGL2GFXCommandAllocator).releaseCmds(); + } + + public copyBufferToTexture (buffer: ArrayBuffer, texture: GFXTexture, regions: GFXBufferTextureCopy[]) { + WebGL2CmdFuncCopyBufferToTexture( + this, + buffer, + (texture as WebGL2GFXTexture).gpuTexture, + regions); + } + + public copyImageSourceToTexture ( + source: CanvasImageSource[], + texture: GFXTexture, + regions: GFXBufferTextureCopy[]) { + + if (!this._canvas2D) { return; } + const context = this._canvas2D.getContext('2d'); + if (!context) { return; } + + const data: Uint8ClampedArray[] = []; + for (let i = 0; i < source.length; i++) { + const level = regions[i].texSubres.baseMipLevel; + this._canvas2D.width = texture.width >> level; + this._canvas2D.height = texture.height >> level; + context.drawImage(source[i], 0, 0); + data.push(context.getImageData(0, 0, this._canvas2D.width, this._canvas2D.height).data); + } + + const buffer = new Uint8ClampedArray(data.reduce((acc, cur) => acc + cur.length, 0)); + data.reduce((acc, cur) => { buffer.set(cur, acc); return acc + cur.length; }, 0); + + WebGL2CmdFuncCopyBufferToTexture( + this, + buffer, + (texture as WebGL2GFXTexture).gpuTexture, + regions); + } + + public copyFramebufferToBuffer ( + srcFramebuffer: GFXFramebuffer, + dstBuffer: ArrayBuffer, + regions: GFXBufferTextureCopy[]) { + + const gl = this._webGL2RC!; + const gpuFramebuffer = (srcFramebuffer as WebGL2GFXFramebuffer).gpuFramebuffer; + + const curFBO = this.stateCache.glFramebuffer; + + if (this.stateCache.glFramebuffer !== gpuFramebuffer.glFramebuffer) { + gl.bindFramebuffer(WebGLRenderingContext.FRAMEBUFFER, gpuFramebuffer.glFramebuffer); + this.stateCache.glFramebuffer = gpuFramebuffer.glFramebuffer; + } + + const view = new Uint8Array(dstBuffer); + + for (const region of regions) { + const buffOffset = region.buffOffset + region.buffTexHeight * region.buffStride; + + const w = region.texExtent.width; + const h = region.texExtent.height; + + const memSize = GFXFormatSize(GFXFormat.RGBA8, w, h, 1); + const data = view.subarray(buffOffset, buffOffset + memSize); + + gl.readPixels(region.texOffset.x, region.texOffset.y, w, h, + WebGLRenderingContext.RGBA, WebGLRenderingContext.UNSIGNED_BYTE, data); + } + + if (this.stateCache.glFramebuffer !== curFBO) { + gl.bindFramebuffer(WebGLRenderingContext.FRAMEBUFFER, curFBO); + this.stateCache.glFramebuffer = curFBO; + } + } + + private initStates (gl: WebGL2RenderingContext) { + + gl.activeTexture(gl.TEXTURE0); + gl.pixelStorei(gl.PACK_ALIGNMENT, 1); + gl.pixelStorei(gl.UNPACK_ALIGNMENT, 1); + gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, 0); + + gl.bindFramebuffer(gl.FRAMEBUFFER, null); + + // rasteriazer state + gl.enable(gl.CULL_FACE); + gl.cullFace(gl.BACK); + gl.frontFace(gl.CCW); + gl.polygonOffset(0.0, 0.0); + + // depth stencil state + gl.enable(gl.DEPTH_TEST); + gl.depthMask(true); + gl.depthFunc(gl.LESS); + + gl.stencilFuncSeparate(gl.FRONT, gl.ALWAYS, 1, 0xffffffff); + gl.stencilOpSeparate(gl.FRONT, gl.KEEP, gl.KEEP, gl.KEEP); + gl.stencilMaskSeparate(gl.FRONT, 0xffffffff); + gl.stencilFuncSeparate(gl.BACK, gl.ALWAYS, 1, 0xffffffff); + gl.stencilOpSeparate(gl.BACK, gl.KEEP, gl.KEEP, gl.KEEP); + gl.stencilMaskSeparate(gl.BACK, 0xffffffff); + + gl.disable(gl.STENCIL_TEST); + + // blend state + gl.disable(gl.SAMPLE_ALPHA_TO_COVERAGE); + gl.disable(gl.BLEND); + gl.blendEquationSeparate(gl.FUNC_ADD, gl.FUNC_ADD); + gl.blendFuncSeparate(gl.ONE, gl.ZERO, gl.ONE, gl.ZERO); + gl.colorMask(true, true, true, true); + gl.blendColor(0.0, 0.0, 0.0, 0.0); + } +} diff --git a/cocos/gfx/webgl2/webgl2-framebuffer.ts b/cocos/gfx/webgl2/webgl2-framebuffer.ts new file mode 100644 index 0000000000..5435a02c67 --- /dev/null +++ b/cocos/gfx/webgl2/webgl2-framebuffer.ts @@ -0,0 +1,74 @@ +import { GFXStatus } from '../define'; +import { GFXDevice } from '../device'; +import { GFXFramebuffer, IGFXFramebufferInfo } from '../framebuffer'; +import { WebGL2CmdFuncCreateFramebuffer, WebGL2CmdFuncDestroyFramebuffer } from './webgl2-commands'; +import { WebGL2GFXDevice } from './webgl2-device'; +import { WebGL2GPUFramebuffer, WebGL2GPUTextureView } from './webgl2-gpu-objects'; +import { WebGL2GFXRenderPass } from './webgl2-render-pass'; +import { WebGL2GFXTextureView } from './webgl2-texture-view'; + +export class WebGL2GFXFramebuffer extends GFXFramebuffer { + + public get gpuFramebuffer (): WebGL2GPUFramebuffer { + return this._gpuFramebuffer!; + } + + private _gpuFramebuffer: WebGL2GPUFramebuffer | null = null; + + constructor (device: GFXDevice) { + super(device); + } + + public initialize (info: IGFXFramebufferInfo): boolean { + + this._renderPass = info.renderPass; + this._colorViews = info.colorViews || []; + this._depthStencilView = info.depthStencilView || null; + this._isOffscreen = info.isOffscreen !== undefined ? info.isOffscreen : false; + + if (this._isOffscreen) { + + const gpuColorViews: WebGL2GPUTextureView[] = []; + if (info.colorViews !== undefined) { + for (const colorView of info.colorViews) { + gpuColorViews.push((colorView as WebGL2GFXTextureView).gpuTextureView); + } + } + + let gpuDepthStencilView: WebGL2GPUTextureView | null = null; + if (info.depthStencilView !== undefined) { + gpuDepthStencilView = (info.depthStencilView as WebGL2GFXTextureView).gpuTextureView; + } + + this._gpuFramebuffer = { + gpuRenderPass: (info.renderPass as WebGL2GFXRenderPass).gpuRenderPass, + gpuColorViews, + gpuDepthStencilView, + isOffscreen: info.isOffscreen, + glFramebuffer: 0, + }; + + WebGL2CmdFuncCreateFramebuffer(this._device as WebGL2GFXDevice, this._gpuFramebuffer); + } else { + this._gpuFramebuffer = { + gpuRenderPass: (info.renderPass as WebGL2GFXRenderPass).gpuRenderPass, + gpuColorViews: [], + gpuDepthStencilView: null, + isOffscreen: info.isOffscreen, + glFramebuffer: 0, + }; + } + + this._status = GFXStatus.SUCCESS; + + return true; + } + + public destroy () { + if (this._isOffscreen && this._gpuFramebuffer) { + WebGL2CmdFuncDestroyFramebuffer(this._device as WebGL2GFXDevice, this._gpuFramebuffer); + } + this._gpuFramebuffer = null; + this._status = GFXStatus.UNREADY; + } +} diff --git a/cocos/gfx/webgl2/webgl2-gpu-objects.ts b/cocos/gfx/webgl2/webgl2-gpu-objects.ts new file mode 100644 index 0000000000..03f27a89e3 --- /dev/null +++ b/cocos/gfx/webgl2/webgl2-gpu-objects.ts @@ -0,0 +1,232 @@ +import { IGFXDrawInfo } from '../buffer'; +import { + GFXBindingType, + GFXBufferUsage, + GFXBufferUsageBit, + GFXDynamicState, + GFXFormat, + GFXMemoryUsage, + GFXMemoryUsageBit, + GFXShaderType, + GFXTextureFlagBit, + GFXTextureFlags, + GFXTextureType, + GFXTextureUsage, + GFXTextureUsageBit, + GFXTextureViewType, + GFXType, +} from '../define'; +import { IGFXInputAttribute } from '../input-assembler'; +import { GFXBlendState, GFXDepthStencilState, GFXRasterizerState } from '../pipeline-state'; +import { GFXColorAttachment, GFXDepthStencilAttachment } from '../render-pass'; +import { GFXUniformBlock, GFXUniformSampler, IGFXShaderMacro } from '../shader'; + +export interface IWebGL2GPUUniformInfo { + name: string; + type: GFXType; + count: number; + offset: number; + view: Float32Array | Int32Array; + isDirty: boolean; +} + +export class WebGL2GPUBuffer { + public usage: GFXBufferUsage = GFXBufferUsageBit.NONE; + public memUsage: GFXMemoryUsage = GFXMemoryUsageBit.NONE; + public size: number = 0; + public stride: number = 0; + + public glTarget: GLenum = 0; + public glBuffer: WebGLBuffer = 0; + public buffer: ArrayBuffer | null = null; + public vf32: Float32Array | null = null; + public uniforms: IWebGL2GPUUniformInfo[] = []; + public indirects: IGFXDrawInfo[] = []; +} + +export class WebGL2GPUTexture { + public type: GFXTextureType = GFXTextureType.TEX2D; + public viewType: GFXTextureViewType = GFXTextureViewType.TV2D; + public format: GFXFormat = GFXFormat.UNKNOWN; + public usage: GFXTextureUsage = GFXTextureUsageBit.NONE; + public width: number = 0; + public height: number = 0; + public depth: number = 1; + public arrayLayer: number = 1; + public mipLevel: number = 1; + public flags: GFXTextureFlags = GFXTextureFlagBit.NONE; + + public glTarget: GLenum = 0; + public glInternelFmt: GLenum = 0; + public glFormat: GLenum = 0; + public glType: GLenum = 0; + public glUsage: GLenum = 0; + public glTexture: WebGLTexture = 0; + public glWrapS: GLenum = 0; + public glWrapT: GLenum = 0; + public glMinFilter: GLenum = 0; + public glMagFilter: GLenum = 0; +} + +export class WebGL2GPUTextureView { + + public gpuTexture: WebGL2GPUTexture; + public type: GFXTextureViewType = GFXTextureViewType.TV2D; + public format: GFXFormat = GFXFormat.UNKNOWN; + public baseLevel: number = 0; + public levelCount: number = 1; + + constructor (texture: WebGL2GPUTexture) { + this.gpuTexture = texture; + } +} + +export class WebGL2GPURenderPass { + + public colorAttachments: GFXColorAttachment[] = []; + public depthStencilAttachment: GFXDepthStencilAttachment | null = null; +} + +export class WebGL2GPUFramebuffer { + + public gpuRenderPass: WebGL2GPURenderPass; + public gpuColorViews: WebGL2GPUTextureView[] = []; + public gpuDepthStencilView: WebGL2GPUTextureView | null = null; + public isOffscreen?: boolean = false; + + public glFramebuffer: WebGLFramebuffer = 0; + + constructor (gpuRenderPass: WebGL2GPURenderPass) { + this.gpuRenderPass = gpuRenderPass; + } +} + +export class WebGL2GPUSampler { + public glMinFilter: GLenum = WebGLRenderingContext.NONE; + public glMagFilter: GLenum = WebGLRenderingContext.NONE; + public glWrapS: GLenum = WebGLRenderingContext.NONE; + public glWrapT: GLenum = WebGLRenderingContext.NONE; + public glWrapR: GLenum = WebGLRenderingContext.NONE; +} + +export class WebGL2GPUInput { + public binding: number = -1; + public name: string = ''; + public type: GFXType = GFXType.UNKNOWN; + public stride: number = 0; + public count: number = 0; + public size: number = 0; + + public glType: GLenum = 0; + public glLoc: GLint = 0; +} + +export interface IWebGL2GPUUniform { + binding: number; + name: string; + type: GFXType; + stride: number; + count: number; + size: number; + offset: number; + + glType: GLenum; + glLoc: WebGLUniformLocation; + array: number[]; + begin: number; + isFirst: boolean; +} + +export class WebGL2GPUUniformBlock { + public binding: number = -1; + public name: string = ''; + public size: number = 0; + public glUniforms: IWebGL2GPUUniform[] = []; + public glActiveUniforms: IWebGL2GPUUniform[] = []; + + public isUniformPackage: boolean = false; // Is a single uniform package? +} + +export class WebGL2GPUUniformSampler { + public binding: number = -1; + public name: string = ''; + public type: GFXType = GFXType.UNKNOWN; + public units: number[] = []; + + public glType: GLenum = 0; + public glLoc: WebGLUniformLocation = -1; +} + +export class WebGL2GPUShaderStage { + public type: GFXShaderType = GFXShaderType.VERTEX; + public source: string = ''; + public macros: IGFXShaderMacro[] = []; + public glShader: WebGLShader = 0; +} + +export class WebGL2GPUShader { + public name: string = ''; + public blocks: GFXUniformBlock[] = []; + public samplers: GFXUniformSampler[] = []; + + public gpuStages: WebGL2GPUShaderStage[] = []; + public glProgram: WebGLProgram = 0; + public glInputs: WebGL2GPUInput[] = []; + public glUniforms: IWebGL2GPUUniform[] = []; + public glBlocks: WebGL2GPUUniformBlock[] = []; + public glSamplers: WebGL2GPUUniformSampler[] = []; +} + +export class WebGL2GPUPipelineLayout { + +} + +export class WebGL2GPUPipelineState { + + public glPrimitive: GLenum = WebGLRenderingContext.TRIANGLES; + public gpuShader: WebGL2GPUShader | null = null; + public rs: GFXRasterizerState = new GFXRasterizerState(); + public dss: GFXDepthStencilState = new GFXDepthStencilState(); + public bs: GFXBlendState = new GFXBlendState(); + public dynamicStates: GFXDynamicState[] = []; + public gpuLayout: WebGL2GPUPipelineLayout | null = null; + public gpuRenderPass: WebGL2GPURenderPass | null = null; +} + +export class WebGL2GPUBinding { + public binding: number = 0; + public type: GFXBindingType = GFXBindingType.UNKNOWN; + public name: string = ''; + public gpuBuffer: WebGL2GPUBuffer | null = null; + public gpuTexView: WebGL2GPUTextureView | null = null; + public gpuSampler: WebGL2GPUSampler | null = null; +} + +export class WebGL2GPUBindingLayout { + + public gpuBindings: WebGL2GPUBinding[] = []; +} + +export class WebGL2Attrib { + public name: string = ''; + public glBuffer: WebGLBuffer = 0; + public glType: GLenum = 0; + public size: number = 0; + public count: number = 0; + public stride: number = 0; + public componentCount: number = 1; + public isNormalized: boolean = false; + public isInstanced: boolean = false; + public offset: number = 0; +} + +export class WebGL2GPUInputAssembler { + public attributes: IGFXInputAttribute[] = []; + public gpuVertexBuffers: WebGL2GPUBuffer[] = []; + public gpuIndexBuffer: WebGL2GPUBuffer | null = null; + public gpuIndirectBuffer: WebGL2GPUBuffer | null = null; + + public glAttribs: WebGL2Attrib[] = []; + public glIndexType: GLenum = 0; + public glVAO: WebGLVertexArrayObject = 0; +} diff --git a/cocos/gfx/webgl2/webgl2-input-assembler.ts b/cocos/gfx/webgl2/webgl2-input-assembler.ts new file mode 100644 index 0000000000..c0b9d2c410 --- /dev/null +++ b/cocos/gfx/webgl2/webgl2-input-assembler.ts @@ -0,0 +1,102 @@ +import { GFXStatus } from '../define'; +import { GFXDevice } from '../device'; +import { GFXInputAssembler, IGFXInputAssemblerInfo } from '../input-assembler'; +import { WebGL2GFXBuffer } from './webgl2-buffer'; +import { WebGL2CmdDraw, WebGL2CmdFuncCreateInputAssember } from './webgl2-commands'; +import { WebGL2GFXDevice } from './webgl2-device'; +import { WebGL2GPUBuffer, WebGL2GPUInputAssembler } from './webgl2-gpu-objects'; + +export class WebGL2GFXInputAssembler extends GFXInputAssembler { + + public get gpuInputAssembler (): WebGL2GPUInputAssembler { + return this._gpuInputAssembler!; + } + + private _gpuInputAssembler: WebGL2GPUInputAssembler | null = null; + + constructor (device: GFXDevice) { + super(device); + } + + public initialize (info: IGFXInputAssemblerInfo): boolean { + + if (info.vertexBuffers.length === 0) { + console.error('GFXInputAssemblerInfo.vertexBuffers is null.'); + return false; + } + + this._attributes = info.attributes; + this._vertexBuffers = info.vertexBuffers; + + if (info.indexBuffer !== undefined) { + this._indexBuffer = info.indexBuffer; + this._indexCount = this._indexBuffer.size / this._indexBuffer.stride; + } else { + const vertBuff = this._vertexBuffers[0]; + this._vertexCount = vertBuff.size / vertBuff.stride; + } + + this._indirectBuffer = info.indirectBuffer || null; + + const gpuVertexBuffers: WebGL2GPUBuffer[] = new Array(info.vertexBuffers.length); + for (let i = 0; i < info.vertexBuffers.length; ++i) { + const vb = info.vertexBuffers[i] as WebGL2GFXBuffer; + if (vb.gpuBuffer) { + gpuVertexBuffers[i] = vb.gpuBuffer; + } + } + + let gpuIndexBuffer: WebGL2GPUBuffer | null = null; + let glIndexType = 0; + if (info.indexBuffer) { + gpuIndexBuffer = (info.indexBuffer as WebGL2GFXBuffer).gpuBuffer; + if (gpuIndexBuffer) { + switch (gpuIndexBuffer.stride) { + case 1: glIndexType = WebGLRenderingContext.UNSIGNED_BYTE; break; + case 2: glIndexType = WebGLRenderingContext.UNSIGNED_SHORT; break; + case 4: glIndexType = WebGLRenderingContext.UNSIGNED_INT; break; + default: { + console.error('Error index buffer stride.'); + } + } + } + } + + let gpuIndirectBuffer: WebGL2GPUBuffer | null = null; + if (info.indirectBuffer !== undefined) { + gpuIndirectBuffer = (info.indirectBuffer as WebGL2GFXBuffer).gpuBuffer; + } + + this._gpuInputAssembler = { + attributes: info.attributes, + gpuVertexBuffers, + gpuIndexBuffer, + gpuIndirectBuffer, + + glAttribs: [], + glIndexType, + glVAO: 0, + }; + + WebGL2CmdFuncCreateInputAssember(this._device as WebGL2GFXDevice, this._gpuInputAssembler); + + this._status = GFXStatus.SUCCESS; + + return true; + } + + public destroy () { + this._gpuInputAssembler = null; + this._status = GFXStatus.UNREADY; + } + + public extractCmdDraw (cmd: WebGL2CmdDraw) { + cmd.drawInfo.vertexCount = this._vertexCount; + cmd.drawInfo.firstVertex = this._firstVertex; + cmd.drawInfo.indexCount = this._indexCount; + cmd.drawInfo.firstIndex = this._firstIndex; + cmd.drawInfo.vertexOffset = this._vertexOffset; + cmd.drawInfo.instanceCount = this._instanceCount; + cmd.drawInfo.firstInstance = this._firstInstance; + } +} diff --git a/cocos/gfx/webgl2/webgl2-pipeline-layout.ts b/cocos/gfx/webgl2/webgl2-pipeline-layout.ts new file mode 100644 index 0000000000..6eaebd7fdb --- /dev/null +++ b/cocos/gfx/webgl2/webgl2-pipeline-layout.ts @@ -0,0 +1,30 @@ +import { GFXStatus } from '../define'; +import { GFXDevice } from '../device'; +import { GFXPipelineLayout, IGFXPipelineLayoutInfo } from '../pipeline-layout'; +import { WebGL2GPUPipelineLayout } from './webgl2-gpu-objects'; + +export class WebGL2GFXPipelineLayout extends GFXPipelineLayout { + + public get gpuPipelineLayout (): WebGL2GPUPipelineLayout { + return this._gpuPipelineLayout!; + } + + private _gpuPipelineLayout: WebGL2GPUPipelineLayout | null = null; + + constructor (device: GFXDevice) { + super(device); + } + + public initialize (info: IGFXPipelineLayoutInfo): boolean { + + this._layouts = info.layouts; + this._pushConstantsRanges = info.pushConstantsRanges || []; + this._status = GFXStatus.SUCCESS; + + return true; + } + + public destroy () { + this._status = GFXStatus.UNREADY; + } +} diff --git a/cocos/gfx/webgl2/webgl2-pipeline-state.ts b/cocos/gfx/webgl2/webgl2-pipeline-state.ts new file mode 100644 index 0000000000..4d45cbd523 --- /dev/null +++ b/cocos/gfx/webgl2/webgl2-pipeline-state.ts @@ -0,0 +1,71 @@ +import { GFXStatus } from '../define'; +import { GFXDevice } from '../device'; +import { GFXPipelineState, IGFXPipelineStateInfo } from '../pipeline-state'; +import { WebGL2GPUPipelineState } from './webgl2-gpu-objects'; +import { WebGL2GFXPipelineLayout } from './webgl2-pipeline-layout'; +import { WebGL2GFXRenderPass } from './webgl2-render-pass'; +import { WebGL2GFXShader } from './webgl2-shader'; + +const WebGLPrimitives: GLenum[] = [ + WebGLRenderingContext.POINTS, + WebGLRenderingContext.LINES, + WebGLRenderingContext.LINE_STRIP, + WebGLRenderingContext.LINE_LOOP, + WebGLRenderingContext.NONE, + WebGLRenderingContext.NONE, + WebGLRenderingContext.NONE, + WebGLRenderingContext.TRIANGLES, + WebGLRenderingContext.TRIANGLE_STRIP, + WebGLRenderingContext.TRIANGLE_FAN, + WebGLRenderingContext.NONE, + WebGLRenderingContext.NONE, + WebGLRenderingContext.NONE, + WebGLRenderingContext.NONE, +]; + +export class WebGL2GFXPipelineState extends GFXPipelineState { + + public get gpuPipelineState (): WebGL2GPUPipelineState { + return this._gpuPipelineState!; + } + + private _gpuPipelineState: WebGL2GPUPipelineState | null = null; + + constructor (device: GFXDevice) { + super(device); + } + + public initialize (info: IGFXPipelineStateInfo): boolean { + + this._primitive = info.primitive; + this._shader = info.shader; + this._is = info.is; + this._rs = info.rs; + this._dss = info.dss; + this._bs = info.bs; + this._dynamicStates = info.dynamicStates || []; + + this._layout = info.layout; + this._renderPass = info.renderPass; + + this._gpuPipelineState = { + glPrimitive: WebGLPrimitives[info.primitive], + gpuShader: (info.shader as WebGL2GFXShader).gpuShader, + rs: info.rs, + dss: info.dss, + bs: info.bs, + dynamicStates: (info.dynamicStates !== undefined ? info.dynamicStates : []), + gpuLayout: (info.layout as WebGL2GFXPipelineLayout).gpuPipelineLayout, + gpuRenderPass: (info.renderPass as WebGL2GFXRenderPass).gpuRenderPass, + }; + + this._status = GFXStatus.SUCCESS; + + return true; + } + + public destroy () { + this._gpuPipelineState = null; + this._status = GFXStatus.UNREADY; + } +} diff --git a/cocos/gfx/webgl2/webgl2-queue.ts b/cocos/gfx/webgl2/webgl2-queue.ts new file mode 100644 index 0000000000..e7b2906d9b --- /dev/null +++ b/cocos/gfx/webgl2/webgl2-queue.ts @@ -0,0 +1,39 @@ +import { GFXCommandBuffer } from '../command-buffer'; +import { GFXStatus } from '../define'; +import { GFXDevice } from '../device'; +import { GFXQueue, IGFXQueueInfo } from '../queue'; +import { WebGL2GFXCommandBuffer } from './webgl2-command-buffer'; +import { WebGL2CmdFuncExecuteCmds } from './webgl2-commands'; +import { WebGL2GFXDevice } from './webgl2-device'; + +export class WebGL2GFXQueue extends GFXQueue { + + private _isAsync: boolean = false; + + constructor (device: GFXDevice) { + super(device); + } + + public initialize (info: IGFXQueueInfo): boolean { + + this._type = info.type; + this._status = GFXStatus.SUCCESS; + + return true; + } + + public destroy () { + this._status = GFXStatus.UNREADY; + } + + public submit (cmdBuffs: GFXCommandBuffer[], fence?) { + + // TODO: Async + if (!this._isAsync) { + for (const cmdBuff of cmdBuffs) { + WebGL2CmdFuncExecuteCmds(this._device as WebGL2GFXDevice, + (cmdBuff as WebGL2GFXCommandBuffer).cmdPackage); + } + } + } +} diff --git a/cocos/gfx/webgl2/webgl2-render-pass.ts b/cocos/gfx/webgl2/webgl2-render-pass.ts new file mode 100644 index 0000000000..c544e97615 --- /dev/null +++ b/cocos/gfx/webgl2/webgl2-render-pass.ts @@ -0,0 +1,38 @@ +import { GFXStatus } from '../define'; +import { GFXDevice } from '../device'; +import { GFXRenderPass, IGFXRenderPassInfo } from '../render-pass'; +import { WebGL2GFXDevice } from './webgl2-device'; +import { WebGL2GPURenderPass } from './webgl2-gpu-objects'; + +export class WebGL2GFXRenderPass extends GFXRenderPass { + + public get gpuRenderPass (): WebGL2GPURenderPass { + return this._gpuRenderPass!; + } + + private _gpuRenderPass: WebGL2GPURenderPass | null = null; + + constructor (device: GFXDevice) { + super(device); + } + + public initialize (info: IGFXRenderPassInfo): boolean { + + this._colorInfos = info.colorAttachments || []; + this._depthStencilInfo = info.depthStencilAttachment || null; + + this._gpuRenderPass = { + colorAttachments: this._colorInfos, + depthStencilAttachment: this._depthStencilInfo, + }; + + this._status = GFXStatus.SUCCESS; + + return true; + } + + public destroy () { + this._gpuRenderPass = null; + this._status = GFXStatus.UNREADY; + } +} diff --git a/cocos/gfx/webgl2/webgl2-sampler.ts b/cocos/gfx/webgl2/webgl2-sampler.ts new file mode 100644 index 0000000000..99b2cc0394 --- /dev/null +++ b/cocos/gfx/webgl2/webgl2-sampler.ts @@ -0,0 +1,134 @@ +import { GFXFilter, GFXStatus } from '../define'; +import { GFXDevice } from '../device'; +import { GFXSampler, GFXSamplerState, IGFXSamplerInfo } from '../sampler'; +import { WebGL2GFXDevice } from './webgl2-device'; +import { WebGL2GPUSampler } from './webgl2-gpu-objects'; + +const WebGLWraps: GLenum[] = [ + WebGLRenderingContext.REPEAT, + WebGLRenderingContext.MIRRORED_REPEAT, + WebGLRenderingContext.CLAMP_TO_EDGE, + WebGLRenderingContext.CLAMP_TO_EDGE, +]; + +export class WebGL2GFXSampler extends GFXSampler { + + public get gpuSampler (): WebGL2GPUSampler { + return this._gpuSampler!; + } + + private _gpuSampler: WebGL2GPUSampler | null = null; + + constructor (device: GFXDevice) { + super(device); + + this._state = new GFXSamplerState(); + } + + public initialize (info: IGFXSamplerInfo): boolean { + + if (info.name !== undefined) { + this._state.name = info.name; + } + + if (info.minFilter !== undefined) { + this._state.minFilter = info.minFilter; + } + + if (info.magFilter !== undefined) { + this._state.magFilter = info.magFilter; + } + + if (info.mipFilter !== undefined) { + this._state.mipFilter = info.mipFilter; + } + + if (info.addressU !== undefined) { + this._state.addressU = info.addressU; + } + + if (info.addressV !== undefined) { + this._state.addressV = info.addressV; + } + + if (info.addressW !== undefined) { + this._state.addressW = info.addressW; + } + + if (info.maxAnisotropy !== undefined) { + this._state.maxAnisotropy = info.maxAnisotropy; + } + + if (info.cmpFunc !== undefined) { + this._state.cmpFunc = info.cmpFunc; + } + + if (info.borderColor !== undefined) { + this._state.borderColor = info.borderColor; + } + + if (info.minLOD !== undefined) { + this._state.minLOD = info.minLOD; + } + + if (info.maxLOD !== undefined) { + this._state.maxLOD = info.maxLOD; + } + + if (info.mipLODBias !== undefined) { + this._state.mipLODBias = info.mipLODBias; + } + + let glMinFilter = WebGLRenderingContext.NONE; + let glMagFilter = WebGLRenderingContext.NONE; + + const minFilter = (info.minFilter !== undefined ? info.minFilter : GFXFilter.LINEAR); + const magFilter = (info.magFilter !== undefined ? info.magFilter : GFXFilter.LINEAR); + const mipFilter = (info.mipFilter !== undefined ? info.mipFilter : GFXFilter.NONE); + + if (minFilter === GFXFilter.LINEAR || minFilter === GFXFilter.ANISOTROPIC) { + if (mipFilter === GFXFilter.LINEAR || mipFilter === GFXFilter.ANISOTROPIC) { + glMinFilter = WebGLRenderingContext.LINEAR_MIPMAP_LINEAR; + } else if (mipFilter === GFXFilter.POINT) { + glMinFilter = WebGLRenderingContext.LINEAR_MIPMAP_NEAREST; + } else { + glMinFilter = WebGLRenderingContext.LINEAR; + } + } else { + if (mipFilter === GFXFilter.LINEAR || mipFilter === GFXFilter.ANISOTROPIC) { + glMinFilter = WebGLRenderingContext.NEAREST_MIPMAP_LINEAR; + } else if (mipFilter === GFXFilter.POINT) { + glMinFilter = WebGLRenderingContext.NEAREST_MIPMAP_NEAREST; + } else { + glMinFilter = WebGLRenderingContext.NEAREST; + } + } + + if (magFilter === GFXFilter.LINEAR || magFilter === GFXFilter.ANISOTROPIC) { + glMagFilter = WebGLRenderingContext.LINEAR; + } else { + glMagFilter = WebGLRenderingContext.NEAREST; + } + + const glWrapS = (info.addressU !== undefined ? WebGLWraps[info.addressU] : WebGLRenderingContext.CLAMP_TO_EDGE); + const glWrapT = (info.addressU !== undefined ? WebGLWraps[info.addressU] : WebGLRenderingContext.CLAMP_TO_EDGE); + const glWrapR = (info.addressU !== undefined ? WebGLWraps[info.addressU] : WebGLRenderingContext.CLAMP_TO_EDGE); + + this._gpuSampler = { + glMinFilter, + glMagFilter, + glWrapS, + glWrapT, + glWrapR, + }; + + this._status = GFXStatus.SUCCESS; + + return true; + } + + public destroy () { + this._gpuSampler = null; + this._status = GFXStatus.UNREADY; + } +} diff --git a/cocos/gfx/webgl2/webgl2-shader.ts b/cocos/gfx/webgl2/webgl2-shader.ts new file mode 100644 index 0000000000..01f24370e0 --- /dev/null +++ b/cocos/gfx/webgl2/webgl2-shader.ts @@ -0,0 +1,70 @@ +import { GFXStatus } from '../define'; +import { GFXDevice } from '../device'; +import { GFXShader, IGFXShaderInfo } from '../shader'; +import { WebGL2CmdFuncCreateShader, WebGL2CmdFuncDestroyShader } from './webgl2-commands'; +import { WebGL2GFXDevice } from './webgl2-device'; +import { WebGL2GPUShader, WebGL2GPUShaderStage } from './webgl2-gpu-objects'; + +export class WebGL2GFXShader extends GFXShader { + + public get gpuShader (): WebGL2GPUShader { + return this._gpuShader!; + } + + private _gpuShader: WebGL2GPUShader | null = null; + + constructor (device: GFXDevice) { + super(device); + } + + public initialize (info: IGFXShaderInfo): boolean { + + this._name = info.name; + this._stages = info.stages; + + if (info.blocks !== undefined) { + this._blocks = info.blocks; + } + + if (info.samplers !== undefined) { + this._samplers = info.samplers; + } + + this._gpuShader = { + name: info.name ? info.name : '', + blocks: (info.blocks !== undefined ? info.blocks : []), + samplers: (info.samplers !== undefined ? info.samplers : []), + + gpuStages: new Array(info.stages.length), + glProgram: 0, + glInputs: [], + glUniforms: [], + glBlocks: [], + glSamplers: [], + }; + + for (let i = 0; i < info.stages.length; ++i) { + const stage = info.stages[i]; + this._gpuShader.gpuStages[i] = { + type: stage.type, + source: stage.source, + macros: stage.macros ? stage.macros : [], + glShader: 0, + }; + } + + WebGL2CmdFuncCreateShader(this._device as WebGL2GFXDevice, this._gpuShader); + + this._status = GFXStatus.SUCCESS; + + return true; + } + + public destroy () { + if (this._gpuShader) { + WebGL2CmdFuncDestroyShader(this._device as WebGL2GFXDevice, this._gpuShader); + this._gpuShader = null; + } + this._status = GFXStatus.UNREADY; + } +} diff --git a/cocos/gfx/webgl2/webgl2-state-cache.ts b/cocos/gfx/webgl2/webgl2-state-cache.ts new file mode 100644 index 0000000000..6e8650607b --- /dev/null +++ b/cocos/gfx/webgl2/webgl2-state-cache.ts @@ -0,0 +1,49 @@ +import { GFX_MAX_TEXTURE_UNITS, GFX_MAX_VERTEX_ATTRIBUTES, IGFXRect, IGFXViewport } from '../define'; +import { GFXBlendState, GFXDepthStencilState, GFXRasterizerState } from '../pipeline-state'; + +export interface IWebGL2TexUnit { + glTexture: WebGLTexture; +} + +export class WebGL2StateCache { + public glArrayBuffer: WebGLBuffer = 0; + public glElementArrayBuffer: WebGLBuffer = 0; + public texUnit: number = 0; + public glTex2DUnits: IWebGL2TexUnit[]; + public glTexCubeUnits: IWebGL2TexUnit[]; + public glFramebuffer: WebGLFramebuffer = 0; + public viewport: IGFXViewport; + public scissorRect: IGFXRect; + public rs: GFXRasterizerState; + public dss: GFXDepthStencilState; + public bs: GFXBlendState; + public glProgram: WebGLProgram = 0; + public glEnabledAttribLocs: boolean[]; + public glCurrentAttribLocs: boolean[]; + + constructor () { + this.glTex2DUnits = new Array(GFX_MAX_TEXTURE_UNITS); + this.glTexCubeUnits = new Array(GFX_MAX_TEXTURE_UNITS); + this.viewport = { left: 0.0, top: 0.0, width: 0.0, height: 0.0, minDepth: 0.0, maxDepth: 0.0 }; + this.scissorRect = { x: 0.0, y: 0.0, width: 0.0, height: 0.0 }; + this.rs = new GFXRasterizerState(); + this.dss = new GFXDepthStencilState(); + this.bs = new GFXBlendState(); + this.glEnabledAttribLocs = new Array(GFX_MAX_VERTEX_ATTRIBUTES); + this.glCurrentAttribLocs = new Array(GFX_MAX_VERTEX_ATTRIBUTES); + + for (let i = 0; i < GFX_MAX_TEXTURE_UNITS; ++i) { + this.glTex2DUnits[i] = { + glTexture: 0, + }; + this.glTexCubeUnits[i] = { + glTexture: 0, + }; + } + + for (let i = 0; i < GFX_MAX_VERTEX_ATTRIBUTES; ++i) { + this.glEnabledAttribLocs[i] = false; + this.glCurrentAttribLocs[i] = false; + } + } +} diff --git a/cocos/gfx/webgl2/webgl2-texture-view.ts b/cocos/gfx/webgl2/webgl2-texture-view.ts new file mode 100644 index 0000000000..fd631bdf02 --- /dev/null +++ b/cocos/gfx/webgl2/webgl2-texture-view.ts @@ -0,0 +1,61 @@ +import { GFXStatus } from '../define'; +import { GFXDevice } from '../device'; +import { GFXTextureView, IGFXTextureViewInfo } from '../texture-view'; +import { WebGL2GFXDevice } from './webgl2-device'; +import { WebGL2GPUTextureView } from './webgl2-gpu-objects'; +import { WebGL2GFXTexture } from './webgl2-texture'; + +export class WebGL2GFXTextureView extends GFXTextureView { + + public get gpuTextureView (): WebGL2GPUTextureView { + return this._gpuTextureView as WebGL2GPUTextureView; + } + + private _gpuTextureView: WebGL2GPUTextureView | null = null; + + constructor (device: GFXDevice) { + super(device); + } + + public initialize (info: IGFXTextureViewInfo): boolean { + + this._texture = info.texture; + this._type = info.type; + this._format = info.format; + this._format = info.format; + + if (info.baseLevel !== undefined) { + this._baseLevel = info.baseLevel; + } + + if (info.levelCount !== undefined) { + this._levelCount = info.levelCount; + } + + if (info.baseLayer !== undefined) { + this._baseLayer = info.baseLayer; + } + + if (info.layerCount !== undefined) { + this._layerCount = info.layerCount; + } + + this._gpuTextureView = { + gpuTexture: (info.texture as WebGL2GFXTexture).gpuTexture, + type: info.type, + format: info.format, + baseLevel: info.baseLevel ? info.baseLevel : 0, + levelCount: info.levelCount ? info.levelCount : 1, + }; + + this._status = GFXStatus.SUCCESS; + + return true; + } + + public destroy () { + this._gpuTextureView = null; + this._texture = null; + this._status = GFXStatus.UNREADY; + } +} diff --git a/cocos/gfx/webgl2/webgl2-texture.ts b/cocos/gfx/webgl2/webgl2-texture.ts new file mode 100644 index 0000000000..5174e76661 --- /dev/null +++ b/cocos/gfx/webgl2/webgl2-texture.ts @@ -0,0 +1,131 @@ +import { GFXFormatSurfaceSize, GFXStatus, GFXTextureFlagBit, GFXTextureType, GFXTextureViewType } from '../define'; +import { GFXDevice } from '../device'; +import { GFXTexture, IGFXTextureInfo } from '../texture'; +import { WebGL2CmdFuncCreateTexture, WebGL2CmdFuncDestroyTexture } from './webgl2-commands'; +import { WebGL2GFXDevice } from './webgl2-device'; +import { WebGL2GPUTexture } from './webgl2-gpu-objects'; + +export class WebGL2GFXTexture extends GFXTexture { + + public get gpuTexture (): WebGL2GPUTexture { + return this._gpuTexture!; + } + + private _gpuTexture: WebGL2GPUTexture | null = null; + + constructor (device: GFXDevice) { + super(device); + } + + public initialize (info: IGFXTextureInfo): boolean { + + this._type = info.type; + this._usage = info.usage; + this._format = info.format; + this._width = info.width; + this._height = info.height; + + if (info.depth !== undefined) { + this._depth = info.depth; + } + + if (info.arrayLayer !== undefined) { + this._arrayLayer = info.arrayLayer; + } + + if (info.mipLevel !== undefined) { + this._mipLevel = info.mipLevel; + } + + if (info.flags !== undefined) { + this._flags = info.flags; + } + + this._size = GFXFormatSurfaceSize(this._format, this.width, this.height, + this.depth, this.mipLevel) * this._arrayLayer; + + if (this._flags & GFXTextureFlagBit.BAKUP_BUFFER) { + this._buffer = new ArrayBuffer(this._size); + } + + let viewType: GFXTextureViewType; + + switch (info.type) { + case GFXTextureType.TEX1D: { + + if (info.arrayLayer) { + viewType = info.arrayLayer <= 1 ? GFXTextureViewType.TV1D : GFXTextureViewType.TV1D_ARRAY; + } else { + viewType = GFXTextureViewType.TV1D; + } + + break; + } + case GFXTextureType.TEX2D: { + let flags = GFXTextureFlagBit.NONE; + if (info.flags) { + flags = info.flags; + } + + if (info.arrayLayer) { + if (info.arrayLayer <= 1) { + viewType = GFXTextureViewType.TV2D; + } else if (flags & GFXTextureFlagBit.CUBEMAP) { + viewType = GFXTextureViewType.CUBE; + } else { + viewType = GFXTextureViewType.TV2D_ARRAY; + } + } else { + viewType = GFXTextureViewType.TV2D; + } + + break; + } + case GFXTextureType.TEX3D: { + viewType = GFXTextureViewType.TV3D; + break; + } + default: { + viewType = GFXTextureViewType.TV2D; + } + } + + this._gpuTexture = { + type: info.type, + viewType, + format: info.format, + usage: info.usage, + width: info.width, + height: info.height, + depth: Math.max(info.depth || 1, 1), + arrayLayer: Math.max(info.arrayLayer || 1, 1), + mipLevel: Math.max(info.mipLevel || 1, 1), + flags: info.flags || GFXTextureFlagBit.NONE, + + glTarget: 0, + glInternelFmt: 0, + glFormat: 0, + glType: 0, + glUsage: 0, + glTexture: 0, + glWrapS: 0, + glWrapT: 0, + glMinFilter: 0, + glMagFilter: 0, + }; + + WebGL2CmdFuncCreateTexture(this._device as WebGL2GFXDevice, this._gpuTexture); + + this._status = GFXStatus.SUCCESS; + + return true; + } + + public destroy () { + if (this._gpuTexture) { + WebGL2CmdFuncDestroyTexture(this._device as WebGL2GFXDevice, this._gpuTexture); + this._gpuTexture = null; + } + this._status = GFXStatus.UNREADY; + } +} diff --git a/cocos/gfx/webgl2/webgl2-window.ts b/cocos/gfx/webgl2/webgl2-window.ts new file mode 100644 index 0000000000..fa587974f4 --- /dev/null +++ b/cocos/gfx/webgl2/webgl2-window.ts @@ -0,0 +1,90 @@ +import { GFXLoadOp, GFXStatus, GFXStoreOp, GFXTextureLayout } from '../define'; +import { GFXDevice } from '../device'; +import { GFXWindow, IGFXWindowInfo } from '../window'; + +export class WebGL2GFXWindow extends GFXWindow { + + constructor (device: GFXDevice) { + super(device); + } + + public initialize (info: IGFXWindowInfo): boolean { + + if (info.title !== undefined) { + this._title = info.title; + } + + if (info.left !== undefined) { + this._left = info.left; + } + + if (info.top !== undefined) { + this._top = info.top; + } + + this._width = info.width; + this._height = info.height; + this._colorFmt = info.colorFmt; + this._depthStencilFmt = info.depthStencilFmt; + + this._renderPass = this._device.createRenderPass({ + colorAttachments: [{ + format: this._colorFmt, + loadOp: GFXLoadOp.CLEAR, + storeOp: GFXStoreOp.STORE, + sampleCount: 1, + beginLayout: GFXTextureLayout.COLOR_ATTACHMENT_OPTIMAL, + endLayout: GFXTextureLayout.COLOR_ATTACHMENT_OPTIMAL, + }], + depthStencilAttachment: { + format : this._depthStencilFmt, + depthLoadOp : GFXLoadOp.CLEAR, + depthStoreOp : GFXStoreOp.STORE, + stencilLoadOp : GFXLoadOp.CLEAR, + stencilStoreOp : GFXStoreOp.STORE, + sampleCount : 1, + beginLayout : GFXTextureLayout.DEPTH_STENCIL_ATTACHMENT_OPTIMAL, + endLayout : GFXTextureLayout.DEPTH_STENCIL_ATTACHMENT_OPTIMAL, + }, + }); + + if (!this._renderPass) { + this.destroy(); + return false; + } + + this._framebuffer = this._device.createFramebuffer({ + renderPass: this._renderPass, + // colorViews: [this._colorTexView], + // depthStencilView: this._depthStencilTexView, + isOffscreen: false, + }); + + if (!this._framebuffer) { + this.destroy(); + return false; + } + this._status = GFXStatus.SUCCESS; + + return true; + } + + public destroy () { + if (this._framebuffer) { + this._framebuffer.destroy(); + this._framebuffer = null; + } + + if (this._renderPass) { + this._renderPass.destroy(); + this._renderPass = null; + } + + this._status = GFXStatus.UNREADY; + } + + public resize (width: number, height: number) { + this._width = width; + this._height = height; + } +}