private VBO(WebGLContext gl, int count, float[] data, WebGLBuffer dataBuffer) { _gl = gl; _count = count; _size = data.Length / count; _dataBuffer = dataBuffer; }
public void Run() { InitContextAttributes(); gl = new WebGL2RenderingContext(canvas, contextAttributes); var vertexShaderCode = @"#version 300 es in vec4 aPos; void main(void) { gl_PointSize = 20.; gl_Position = vec4(-aPos.x, aPos.yzw); } "; var fragmentShaderCode = @"#version 300 es precision highp float; out vec4 fragColor; void main(void) { fragColor = vec4(1., 0., 0., 1. ); } "; var vertexShader = GLExtensions.GetShader( gl, vertexShaderCode, WebGLRenderingContextBase.VERTEX_SHADER); var fragmentShader = GLExtensions.GetShader( gl, fragmentShaderCode, WebGLRenderingContextBase.FRAGMENT_SHADER); var shaderProgram = gl.CreateProgram(); gl.AttachShader(shaderProgram, vertexShader); gl.AttachShader(shaderProgram, fragmentShader); gl.TransformFeedbackVaryings( shaderProgram, new string[] { "gl_Position" }, WebGL2RenderingContextBase.SEPARATE_ATTRIBS); gl.LinkProgram(shaderProgram); gl.UseProgram(shaderProgram); aPosLoc = (uint)gl.GetAttribLocation(shaderProgram, "aPos"); gl.EnableVertexAttribArray(aPosLoc); var bufAData = new float[] { 0.8f, 0, 0, 1 }; bufA = gl.CreateArrayBufferWithUsage(bufAData, WebGL2RenderingContextBase.DYNAMIC_COPY); var bufBData = new float[4 * 4]; bufB = gl.CreateArrayBufferWithUsage(bufBData, WebGL2RenderingContextBase.DYNAMIC_COPY); var transformFeedback = gl.CreateTransformFeedback(); gl.BindTransformFeedback(WebGL2RenderingContextBase.TRANSFORM_FEEDBACK, transformFeedback); }
/// <summary> /// </summary> public virtual void dispose() { if (this._vertexBuffer != null) { this._scene.getEngine()._releaseBuffer(this._vertexBuffer); this._vertexBuffer = null; } if (this._indexBuffer != null) { this._scene.getEngine()._releaseBuffer(this._indexBuffer); this._indexBuffer = null; } if (this.texture != null) { this.texture.dispose(); this.texture = null; } var index = this._scene.layers.IndexOf(this); this._scene.layers.RemoveAt(index); if (this.onDispose != null) { this.onDispose(); } }
/// <summary> /// </summary> /// <param name="mesh"> /// </param> /// <param name="shouldDispose"> /// </param> public virtual void releaseForMesh(Mesh mesh, bool shouldDispose = false) { var meshes = this._meshes; var index = meshes.IndexOf(mesh); if (index == -1) { return; } foreach (var kind in this._vertexBuffers.Keys) { this._vertexBuffers[kind].dispose(); } if (this._indexBuffer != null && this._engine._releaseBuffer(this._indexBuffer)) { this._indexBuffer = null; } meshes.RemoveAt(index); mesh._geometry = null; if (meshes.Length == 0 && shouldDispose) { this.dispose(); } }
public void Draw() { if (!shouldDraw) { return; } gl.Enable(WebGLRenderingContextBase.DEPTH_TEST); gl.Viewport(0, 0, canvasWidth, canvasHeight); gl.ClearColor(clearColor.X, clearColor.Y, clearColor.Z, clearColor.W); gl.Clear(WebGLRenderingContextBase.COLOR_BUFFER_BIT); gl.BindBuffer(WebGLRenderingContextBase.ARRAY_BUFFER, bufA); gl.VertexAttribPointer(aPosLoc, 4, WebGLRenderingContextBase.FLOAT, false, 0, 0); gl.BindBufferBase(WebGL2RenderingContextBase.TRANSFORM_FEEDBACK_BUFFER, 0, bufB); gl.BeginTransformFeedback(WebGLRenderingContextBase.POINTS); gl.DrawArrays(WebGLRenderingContextBase.POINTS, 0, 1); gl.EndTransformFeedback(); gl.BindBufferBase(WebGL2RenderingContextBase.TRANSFORM_FEEDBACK_BUFFER, 0, null); var t = bufA; bufA = bufB; bufB = t; shouldDraw = false; }
void IDualityBackend.Shutdown() { if (activeInstance == this) { activeInstance = null; } if (DualityApp.ExecContext != DualityApp.ExecutionContext.Terminated) { for (int i = 0; i < this.perVertexTypeVBO.Count; i++) { WebGLBuffer handle = this.perVertexTypeVBO[i]; if (handle != null) { GL.DeleteBuffer(handle); } } this.perVertexTypeVBO.Clear(); for (int i = 0; i < this.perBatchEBO.Count; i++) { WebGLBuffer handle = this.perBatchEBO[i]; if (handle != null) { GL.DeleteBuffer(handle); } } this.perBatchEBO.Clear(); } }
public void Unlock() { VertexBuffer = Tile.PrepDevice.createBuffer(); Tile.PrepDevice.bindBuffer(GL.ARRAY_BUFFER, VertexBuffer); Float32Array f32array = new Float32Array(Count * 19); float[] buffer = (float[])(object)f32array; int index = 0; foreach (KeplerVertex pt in verts) { buffer[index++] = (float)pt.ABC.X; buffer[index++] = (float)pt.ABC.Y; buffer[index++] = (float)pt.ABC.Z; buffer[index++] = (float)pt.abc1.X; buffer[index++] = (float)pt.abc1.Y; buffer[index++] = (float)pt.abc1.Z; buffer[index++] = (float)pt.PointSize; buffer[index++] = (float)pt.Color.R / 255; buffer[index++] = (float)pt.Color.G / 255; buffer[index++] = (float)pt.Color.B / 255; buffer[index++] = (float)pt.Color.A / 255; buffer[index++] = (float)pt.w; buffer[index++] = (float)pt.e; buffer[index++] = (float)pt.n; buffer[index++] = (float)pt.T; buffer[index++] = (float)pt.a; buffer[index++] = (float)pt.z; buffer[index++] = (float)pt.orbitPos; buffer[index++] = (float)pt.orbits; } Tile.PrepDevice.bufferData(GL.ARRAY_BUFFER, f32array, GL.STATIC_DRAW); }
public static void Use(RenderContext renderContext, WebGLBuffer vertex) { GL gl = renderContext.gl; if (gl != null) { if (!initialized) { Init(renderContext); } gl.useProgram(prog); Matrix3d mvMat = Matrix3d.MultiplyMatrix(renderContext.World, renderContext.View); gl.uniformMatrix4fv(mvMatLoc, false, mvMat.FloatArray()); gl.uniformMatrix4fv(projMatLoc, false, renderContext.Projection.FloatArray()); gl.uniform1i(sampLoc, 0); gl.disable(GL.DEPTH_TEST); gl.enableVertexAttribArray(vertLoc); gl.enableVertexAttribArray(textureLoc); gl.enableVertexAttribArray(colorLoc); gl.bindBuffer(GL.ARRAY_BUFFER, vertex); gl.vertexAttribPointer(vertLoc, 3, GL.FLOAT, false, 36, 0); gl.vertexAttribPointer(colorLoc, 4, GL.FLOAT, false, 36, 12); gl.bindBuffer(GL.ELEMENT_ARRAY_BUFFER, null); gl.blendFunc(GL.SRC_ALPHA, GL.ONE_MINUS_SRC_ALPHA); } }
/// <summary> /// </summary> /// <param name="name"> /// </param> /// <param name="imgUrl"> /// </param> /// <param name="scene"> /// </param> /// <param name="isBackground"> /// </param> /// <param name="color"> /// </param> public Layer(string name, string imgUrl, Scene scene, bool isBackground = false, Color4 color = null) { this.name = name; this.texture = (imgUrl != null) ? new Texture(imgUrl, scene, true) : null; this.isBackground = isBackground; this.color = (color == null) ? new Color4(1, 1, 1, 1) : color; this._scene = scene; this._scene.layers.Add(this); var vertices = new Array <double>(); vertices.Add(1, 1); vertices.Add(-1, 1); vertices.Add(-1, -1); vertices.Add(1, -1); this._vertexBuffer = scene.getEngine().createVertexBuffer(vertices); var indices = new Array <int>(); indices.Add(0); indices.Add(1); indices.Add(2); indices.Add(0); indices.Add(2); indices.Add(3); this._indexBuffer = scene.getEngine().createIndexBuffer(indices); this._effect = this._scene.getEngine() .createEffect( new EffectBaseName { baseName = "layer" }, new Array <string>("position"), new Array <string>("textureMatrix", "color"), new Array <string>("textureSampler"), string.Empty); }
/// <summary> /// </summary> /// <param name="doNotRecurse"> /// </param> public virtual void dispose(bool doNotRecurse = false) { if (this._vertexBuffer != null) { this._scene.getEngine()._releaseBuffer(this._vertexBuffer); this._vertexBuffer = null; } if (this._indexBuffer != null) { this._scene.getEngine()._releaseBuffer(this._indexBuffer); this._indexBuffer = null; } if (this.particleTexture != null) { this.particleTexture.dispose(); this.particleTexture = null; } var index = this._scene.particleSystems.IndexOf(this); this._scene.particleSystems.RemoveAt(index); if (this.onDispose != null) { this.onDispose(); } }
public async Task Initialize() { _context = await _canvasReference.CreateWebGLAsync(new WebGLContextAttributes { PowerPreference = WebGLContextAttributes.POWER_PREFERENCE_HIGH_PERFORMANCE }); vertexBuffer = await _context.CreateBufferAsync(); await _context.BindBufferAsync(BufferType.ARRAY_BUFFER, vertexBuffer); var program = await this.InitProgramAsync(this._context, VS_SOURCE, FS_SOURCE); var positionLocation = await _context.GetAttribLocationAsync(program, "aPos"); var texcoordLocation = await _context.GetAttribLocationAsync(program, "aTex"); await _context.VertexAttribPointerAsync((uint)positionLocation, 3, DataType.FLOAT, false, 6 *sizeof(float), 0); await _context.VertexAttribPointerAsync((uint)texcoordLocation, 2, DataType.FLOAT, false, 6 *sizeof(float), 3 *sizeof(float)); await _context.EnableVertexAttribArrayAsync((uint)positionLocation); await _context.EnableVertexAttribArrayAsync((uint)texcoordLocation); await _context.UseProgramAsync(program); var texture = await _context.CreateTextureAsync(); await _context.BindTextureAsync(TextureType.TEXTURE_2D, texture); }
public void Unlock() { VertexBuffer = Tile.PrepDevice.createBuffer(); Tile.PrepDevice.bindBuffer(GL.ARRAY_BUFFER, VertexBuffer); Float32Array f32array = new Float32Array(Count * 10); float[] buffer = (float[])(object)f32array; int index = 0; foreach (TimeSeriesPointVertex pt in verts) { buffer[index++] = (float)pt.Position.X; buffer[index++] = (float)pt.Position.Y; buffer[index++] = (float)pt.Position.Z; buffer[index++] = (float)pt.Color.R / 255.0f; buffer[index++] = (float)pt.Color.G / 255.0f; buffer[index++] = (float)pt.Color.B / 255.0f; buffer[index++] = (float)pt.Color.A / 255.0f; buffer[index++] = (float)pt.Tu; buffer[index++] = (float)pt.Tv; buffer[index++] = (float)pt.PointSize; } Tile.PrepDevice.bufferData(GL.ARRAY_BUFFER, f32array, GL.STATIC_DRAW); }
/// <summary> /// </summary> /// <param name="data"> /// </param> public virtual void create(Array <double> data = null) { if (data == null && this._buffer != null) { return; } data = data ?? this._data; if (this._buffer == null) { if (this._updatable) { this._buffer = this._engine.createDynamicVertexBuffer(data.Length * 4); } else { this._buffer = this._engine.createVertexBuffer(data); } } if (this._updatable) { this._engine.updateDynamicVertexBuffer(this._buffer, data); this._data = data; } }
/// <summary> /// </summary> /// <param name="name"> /// </param> /// <param name="emitter"> /// </param> /// <param name="scene"> /// </param> public LensFlareSystem(string name, object emitter, Scene scene) { this.name = name; this._scene = scene; this._emitter = emitter; scene.lensFlareSystems.Add(this); this.meshesSelectionPredicate = (m) => m.material != null && m.isVisible && m.isEnabled() && m.checkCollisions && ((m.layerMask & scene.activeCamera.layerMask) != 0); var vertices = new Array <double>(); vertices.Add(1, 1); vertices.Add(-1, 1); vertices.Add(-1, -1); vertices.Add(1, -1); this._vertexBuffer = scene.getEngine().createVertexBuffer(vertices); var indices = new Array <int>(); indices.Add(0); indices.Add(1); indices.Add(2); indices.Add(0); indices.Add(2); indices.Add(3); this._indexBuffer = scene.getEngine().createIndexBuffer(indices); this._effect = this._scene.getEngine() .createEffect( new EffectBaseName { baseName = "lensFlare" }, new Array <string>("position"), new Array <string>("color", "viewportMatrix"), new Array <string>("textureSampler"), string.Empty); }
public void record() { //记录状态 this.DEPTH_WRITEMASK = (bool)this.webgl.GetParameter(this.webgl.DEPTH_WRITEMASK); this.DEPTH_TEST = (bool)this.webgl.GetParameter(this.webgl.DEPTH_TEST); this.DEPTH_FUNC = (int)this.webgl.GetParameter(this.webgl.DEPTH_FUNC); //alphablend ,跟着mat走 this.BLEND = (bool)this.webgl.GetParameter(this.webgl.BLEND); this.BLEND_EQUATION = (int)this.webgl.GetParameter(this.webgl.BLEND_EQUATION); this.BLEND_SRC_RGB = (int)this.webgl.GetParameter(this.webgl.BLEND_SRC_RGB); this.BLEND_SRC_ALPHA = (int)this.webgl.GetParameter(this.webgl.BLEND_SRC_ALPHA); this.BLEND_DST_RGB = (int)this.webgl.GetParameter(this.webgl.BLEND_DST_RGB); this.BLEND_DST_ALPHA = (int)this.webgl.GetParameter(this.webgl.BLEND_DST_ALPHA); // this.webgl.blendFuncSeparate(this.webgl.ONE, this.webgl.ONE_MINUS_SRC_ALPHA, // this.webgl.SRC_ALPHA, this.webgl.ONE); var p = this.webgl.GetParameter(this.webgl.CURRENT_PROGRAM); this.CURRENT_PROGRAM = p.As <WebGLProgram>(); var pb = this.webgl.GetParameter(this.webgl.ARRAY_BUFFER_BINDING); this.ARRAY_BUFFER = pb.As <WebGLBuffer>(); this.ACTIVE_TEXTURE = (int)this.webgl.GetParameter(this.webgl.ACTIVE_TEXTURE); this.TEXTURE_BINDING_2D = this.webgl.GetParameter(this.webgl.TEXTURE_BINDING_2D).As <WebGLTexture>(); }
/// <summary> /// </summary> /// <param name="mesh"> /// </param> private void _applyToMesh(Mesh mesh) { var numOfMeshes = this._meshes.Length; foreach (var kind in this._vertexBuffers.Keys) { if (numOfMeshes == 1) { this._vertexBuffers[kind].create(); } this._vertexBuffers[kind]._buffer.references = numOfMeshes; if (kind == VertexBufferKind.PositionKind) { mesh._resetPointsArrayCache(); var extend = Tools.ExtractMinAndMax(this._vertexBuffers[kind].getData(), 0, this._totalVertices); mesh._boundingInfo = new BoundingInfo(extend.minimum, extend.maximum); mesh._createGlobalSubMesh(); } } if (numOfMeshes == 1 && this._indices != null) { this._indexBuffer = this._engine.createIndexBuffer(this._indices); } if (this._indexBuffer != null) { this._indexBuffer.references = numOfMeshes; } }
public override void Destroy() { if (buffer != null) { GL.deleteBuffer(buffer); buffer = null; } }
internal override void Bind() { if (buffer != currentlyBoundIndexBuffer) { GL.bindBuffer(GL.ELEMENT_ARRAY_BUFFER, buffer); currentlyBoundIndexBuffer = buffer; } }
internal override void Bind() { if (buffer != currentlyBoundVertexBuffer) { GL.bindBuffer(GL.ARRAY_BUFFER, buffer); currentlyBoundVertexBuffer = buffer; } }
public void bindBufferBase(decimal target, decimal index, WebGLBuffer buffer = null) { EventHorizonBlazorInterop.Func <CachedEntity>( new object[] { new string[] { this.___guid, "bindBufferBase" }, target, index, buffer } ); }
internal void DisposeBuffer(WebGLBuffer handle) { if (!_isDisposed) { lock (_disposeActionsLock) { _disposeNextFrame.Add(ResourceHandle.Buffer(handle)); } } }
/// <summary> /// </summary> /// <param name="subMesh"> /// </param> /// <param name="wireFrame"> /// </param> /// <param name="batch"> /// </param> /// <param name="effect"> /// </param> /// <param name="engine"> /// </param> public virtual void _renderWithInstances(SubMesh subMesh, bool wireFrame, _InstancesBatch batch, Effect effect, Engine engine) { var matricesCount = this.instances.Length + 1; var bufferSize = matricesCount * 16 * 4; while (this._instancesBufferSize < bufferSize) { this._instancesBufferSize *= 2; } if (this._worldMatricesInstancesBuffer == null || this._worldMatricesInstancesBuffer.capacity < this._instancesBufferSize) { if (this._worldMatricesInstancesBuffer != null) { engine.deleteInstancesBuffer(this._worldMatricesInstancesBuffer); } this._worldMatricesInstancesBuffer = engine.createInstancesBuffer(this._instancesBufferSize); this._worldMatricesInstancesArray = new double[this._instancesBufferSize / 4]; } var offset = 0; var instancesCount = 0; var world = this.getWorldMatrix(); if (batch.renderSelf[subMesh._id]) { world.copyToArray(this._worldMatricesInstancesArray, offset); offset += 16; instancesCount++; } var visibleInstances = batch.visibleInstances[subMesh._id]; if (visibleInstances != null) { for (var instanceIndex = 0; instanceIndex < visibleInstances.Length; instanceIndex++) { var instance = visibleInstances[instanceIndex]; instance.getWorldMatrix().copyToArray(this._worldMatricesInstancesArray, offset); offset += 16; instancesCount++; } } var offsetLocation0 = effect.getAttributeLocationByName("world0"); var offsetLocation1 = effect.getAttributeLocationByName("world1"); var offsetLocation2 = effect.getAttributeLocationByName("world2"); var offsetLocation3 = effect.getAttributeLocationByName("world3"); var offsetLocations = new Array <int>(offsetLocation0, offsetLocation1, offsetLocation2, offsetLocation3); engine.updateAndBindInstancesBuffer(this._worldMatricesInstancesBuffer, this._worldMatricesInstancesArray, offsetLocations); this._draw(subMesh, !wireFrame, instancesCount); engine.unBindInstancesBuffer(this._worldMatricesInstancesBuffer, offsetLocations); }
public static void Use(RenderContext renderContext, WebGLBuffer vertex, WebGLTexture texture, Color lineColor, bool zBuffer, float jNow, float decay, Vector3d camera, float scale) { GL gl = renderContext.gl; if (gl != null) { if (!initialized) { Init(renderContext); } gl.useProgram(prog); Matrix3d mvMat = Matrix3d.MultiplyMatrix(renderContext.World, renderContext.View); gl.uniformMatrix4fv(mvMatLoc, false, mvMat.FloatArray()); gl.uniformMatrix4fv(projMatLoc, false, renderContext.Projection.FloatArray()); gl.uniform1i(sampLoc, 0); gl.uniform1f(jNowLoc, jNow); gl.uniform1f(decayLoc, decay); gl.uniform4f(lineColorLoc, lineColor.R / 255f, lineColor.G / 255f, lineColor.B / 255f, 1f); gl.uniform3f(cameraPosLoc, (float)camera.X, (float)camera.Y, (float)camera.Z); gl.uniform1f(scaleLoc, scale); if (zBuffer) { gl.enable(GL.DEPTH_TEST); } else { gl.disable(GL.DEPTH_TEST); } //gl.enable(0x8642); gl.disableVertexAttribArray(0); gl.disableVertexAttribArray(1); gl.disableVertexAttribArray(2); gl.disableVertexAttribArray(3); gl.enableVertexAttribArray(vertLoc); gl.enableVertexAttribArray(colorLoc); gl.enableVertexAttribArray(pointSizeLoc); gl.enableVertexAttribArray(timeLoc); gl.bindBuffer(GL.ARRAY_BUFFER, vertex); gl.bindBuffer(GL.ELEMENT_ARRAY_BUFFER, null); gl.vertexAttribPointer(vertLoc, 3, GL.FLOAT, false, 40, 0); gl.vertexAttribPointer(colorLoc, 4, GL.FLOAT, false, 40, 12); gl.vertexAttribPointer(pointSizeLoc, 1, GL.FLOAT, false, 40, 36); gl.vertexAttribPointer(timeLoc, 2, GL.FLOAT, false, 40, 28); gl.activeTexture(GL.TEXTURE0); gl.bindTexture(GL.TEXTURE_2D, texture); gl.lineWidth(1.0f); gl.blendFunc(GL.SRC_ALPHA, GL.ONE); } }
public void Dispose() { if (DualityApp.ExecContext != DualityApp.ExecutionContext.Terminated && this.handle != null) { //DefaultOpenTKBackendPlugin.GuardSingleThreadState(); GraphicsBackend.GL.DeleteBuffer(this.handle); } this.handle = null; this.bufferSize = 0; }
/// <summary> /// </summary> public virtual void dispose() { if (this._buffer == null) { return; } if (this._engine._releaseBuffer(this._buffer)) { this._buffer = null; } }
/// <summary> /// </summary> public virtual void dispose() { if (this._linesIndexBuffer != null) { this._mesh.getScene().getEngine()._releaseBuffer(this._linesIndexBuffer); this._linesIndexBuffer = null; } var index = this._mesh.subMeshes.IndexOf(this); this._mesh.subMeshes.RemoveAt(index); }
/// <summary> /// </summary> public virtual void dispose() { if (this._vertexBuffer != null) { this._scene.getEngine()._releaseBuffer(this._vertexBuffer); this._vertexBuffer = null; } if (this._indexBuffer != null) { this._scene.getEngine()._releaseBuffer(this._indexBuffer); this._indexBuffer = null; } }
/// <summary> /// </summary> /// <param name="name"> /// </param> /// <param name="imgUrl"> /// </param> /// <param name="capacity"> /// </param> /// <param name="cellSize"> /// </param> /// <param name="scene"> /// </param> /// <param name="epsilon"> /// </param> public SpriteManager(string name, string imgUrl, int capacity, int cellSize, Scene scene, double epsilon = 0.01) { this.name = name; this.cellSize = cellSize; this._capacity = capacity; this._spriteTexture = new Texture(imgUrl, scene, true, false); this._spriteTexture.wrapU = Texture.CLAMP_ADDRESSMODE; this._spriteTexture.wrapV = Texture.CLAMP_ADDRESSMODE; this._epsilon = epsilon; this._scene = scene; this._scene.spriteManagers.Add(this); this._vertexDeclaration = new Array <VertexBufferKind>( VertexBufferKind.UVKind, VertexBufferKind.UV2Kind, VertexBufferKind.UV2Kind, VertexBufferKind.UV2Kind); this._vertexStrideSize = 15 * 4; this._vertexBuffer = scene.getEngine().createDynamicVertexBuffer(capacity * this._vertexStrideSize * 4); var indices = new Array <int>(); var index = 0; for (var count = 0; count < capacity; count++) { indices.Add(index); indices.Add(index + 1); indices.Add(index + 2); indices.Add(index); indices.Add(index + 2); indices.Add(index + 3); index += 4; } this._indexBuffer = scene.getEngine().createIndexBuffer(indices); this._vertices = new double[capacity * this._vertexStrideSize]; this._effectBase = this._scene.getEngine() .createEffect( new EffectBaseName { baseName = "sprites" }, new Array <string>("position", "options", "cellInfo", "color"), new Array <string>("view", "projection", "textureInfos", "alphaTest"), new Array <string>("diffuseSampler"), string.Empty); this._effectFog = this._scene.getEngine() .createEffect( new EffectBaseName { baseName = "sprites" }, new Array <string>("position", "options", "cellInfo", "color"), new Array <string>("view", "projection", "textureInfos", "alphaTest", "vFogInfos", "vFogColor"), new Array <string>("diffuseSampler"), "#define FOG"); }
/// <summary> /// If the IBO does not exist, create it. /// </summary> void GenerateIfRequired() { if (ibo == null) { var sizeInBytes = IndexCount * (this.IndexElementSize == IndexElementSize.SixteenBits ? 2 : 4); ibo = gl.createBuffer(); GraphicsExtensions.CheckGLError(); gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, ibo); GraphicsExtensions.CheckGLError(); gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, new Int16Array(0), _isDynamic ? gl.STREAM_DRAW : gl.STATIC_DRAW); GraphicsExtensions.CheckGLError(); } }
public void bindBuffer(int target, WebGLBuffer buffer) { var bufferId = (int)(buffer != null ? buffer.Value : 0); #if _DEBUG Log.Info(string.Format("bindBuffer {0} {1}", target, bufferId)); #endif #if GLEW_STATIC Gl.glBindBuffer(target, bufferId); #else Gl.__glewBindBuffer(target, bufferId); #endif this.ErrorTest(); }
public WebGL15ContextImpl() : base(100, 100) { gl = null; #endif if (gl == null) throw new Exception("UnsupportedOperationException: WebGL N/A"); InitShaders(); CheckError("initShader"); _elementBuffer = gl.CreateBuffer(); CheckError("createBuffer f. elements"); for (int index = 0; index < _buffers.Length; index++) { WebGLBufferData b = new WebGLBufferData(); b.ToBind = null; b.Buffer = gl.CreateBuffer(); CheckError("createBuffer" + index); b.Stride = 0; b.Size = 0; b.Type = 0; b.ByteSize = 0; b.Normalized = false; _buffers[index] = b; } }
public void bindBuffer(int target, WebGLBuffer buffer) { }
public void InitBuffers() { this.cubeVertexPositionBuffer = gl.CreateBuffer(); gl.BindBuffer(gl.ARRAY_BUFFER, cubeVertexPositionBuffer); var vertices = new double[] { // Front face -1.0, -1.0, 1.0, 1.0, -1.0, 1.0, 1.0, 1.0, 1.0, -1.0, 1.0, 1.0, // Back face -1.0, -1.0, -1.0, -1.0, 1.0, -1.0, 1.0, 1.0, -1.0, 1.0, -1.0, -1.0, // Top face -1.0, 1.0, -1.0, -1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, -1.0, // Bottom face -1.0, -1.0, -1.0, 1.0, -1.0, -1.0, 1.0, -1.0, 1.0, -1.0, -1.0, 1.0, // Right face 1.0, -1.0, -1.0, 1.0, 1.0, -1.0, 1.0, 1.0, 1.0, 1.0, -1.0, 1.0, // Left face -1.0, -1.0, -1.0, -1.0, -1.0, 1.0, -1.0, 1.0, 1.0, -1.0, 1.0, -1.0, }; gl.BufferData(gl.ARRAY_BUFFER, new Float32Array(vertices), gl.STATIC_DRAW); this.cubeVertexNormalBuffer = gl.CreateBuffer(); gl.BindBuffer(gl.ARRAY_BUFFER, cubeVertexNormalBuffer); var vertexNormals = new double[] { // Front face 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, // Back face 0.0, 0.0, -1.0, 0.0, 0.0, -1.0, 0.0, 0.0, -1.0, 0.0, 0.0, -1.0, // Top face 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, // Bottom face 0.0, -1.0, 0.0, 0.0, -1.0, 0.0, 0.0, -1.0, 0.0, 0.0, -1.0, 0.0, // Right face 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, // Left face -1.0, 0.0, 0.0, -1.0, 0.0, 0.0, -1.0, 0.0, 0.0, -1.0, 0.0, 0.0 }; gl.BufferData(gl.ARRAY_BUFFER, new Float32Array(vertexNormals), gl.STATIC_DRAW); this.cubeVertexTextureCoordBuffer = gl.CreateBuffer(); gl.BindBuffer(gl.ARRAY_BUFFER, cubeVertexTextureCoordBuffer); var textureCoords = new double[] { // Front face 0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0, 1.0, // Back face 1.0, 0.0, 1.0, 1.0, 0.0, 1.0, 0.0, 0.0, // Top face 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 1.0, // Bottom face 1.0, 1.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, // Right face 1.0, 0.0, 1.0, 1.0, 0.0, 1.0, 0.0, 0.0, // Left face 0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0, 1.0 }; gl.BufferData(gl.ARRAY_BUFFER, new Float32Array(textureCoords), gl.STATIC_DRAW); this.cubeVertexIndexBuffer = gl.CreateBuffer(); gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, cubeVertexIndexBuffer); var cubeVertexIndices = new int[] { 0, 1, 2, 0, 2, 3, // Front face 4, 5, 6, 4, 6, 7, // Back face 8, 9, 10, 8, 10, 11, // Top face 12, 13, 14, 12, 14, 15, // Bottom face 16, 17, 18, 16, 18, 19, // Right face 20, 21, 22, 20, 22, 23 // Left face }; gl.BufferData(gl.ELEMENT_ARRAY_BUFFER, new Uint16Array(cubeVertexIndices), gl.STATIC_DRAW); }
/// <summary> /// Delete a specific buffer. /// If a buffer has already been deleted, this method has no effect. /// </summary> /// <param name="buffer">The buffer to delete</param> public virtual void DeleteBuffer(WebGLBuffer buffer) { }
public void deleteBuffer(WebGLBuffer buffer) { }
/// <summary> /// Associates a buffer with a buffer target. /// </summary> /// <param name="target">One of the following: gl.ARRAY_BUFFER or gl.ELEMENT_ARRAY_BUFFER</param> /// <param name="buffer">A WebGLBuffer object to bind to target.</param> public virtual void BindBuffer(int target, WebGLBuffer buffer) { }
public bool isBuffer(WebGLBuffer buffer) { return default(bool); }
/// <summary> /// Gets state of WebGLBuffer. Returns true if buffer is valid, false otherwise. /// </summary> /// <param name="buffer">The buffer to query.</param> /// <returns>Returns true if buffer is valid, false otherwise. </returns> public virtual bool IsBuffer(WebGLBuffer buffer) { return false; }