public static void Render() { if (Player.Instance == null) { return; } Gl.UseProgram(shader.ProgramID); int minx, maxx, miny, maxy; Terrain.Range(out minx, out maxx, out miny, out maxy); int mingx = (int)Math.Floor((float)minx / GridX); int mingy = (int)Math.Floor((float)miny / GridY); int maxgx = (int)Math.Ceiling((float)maxx / GridX); int maxgy = (int)Math.Ceiling((float)maxy / GridY); MathUtil.Clamp(ref mingx, 0, EntityGrid.GetLength(0) - 1); MathUtil.Clamp(ref mingy, 0, EntityGrid.GetLength(1) - 1); MathUtil.Clamp(ref maxgx, 0, EntityGrid.GetLength(0) - 1); MathUtil.Clamp(ref maxgy, 0, EntityGrid.GetLength(1) - 1); Dictionary <EntityID, HashSet <Entity> > EntitiesMap = new Dictionary <EntityID, HashSet <Entity> >(); for (int i = mingx; i <= maxgx; i++) { for (int j = mingy; j <= maxgy; j++) { HashSet <Entity> set = EntityGrid[i, j]; foreach (Entity e in set) { HashSet <Entity> setbatch; if (EntitiesMap.TryGetValue(e.entityId, out setbatch)) { setbatch.Add(e); } else { setbatch = new HashSet <Entity>(); setbatch.Add(e); EntitiesMap.Add(e.entityId, setbatch); } } } } LoadedEntities = 0; Gl.Enable(EnableCap.Blend); Gl.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha); Gl.BindTexture(Assets.Textures.EntityTexture.TextureTarget, Assets.Textures.EntityTexture.TextureID); foreach (EntityID entityId in EntitiesMap.Keys) { EntityModel model = Assets.Models.GetModel(entityId); Gl.BindVertexArray(model.vao.ID); foreach (Entity e in EntitiesMap[entityId]) { LoadedEntities++; shader["modelMatrix"].SetValue(e.ModelMatrix()); if (e.data.recentDmg > 0) { float offsetval = 1 - e.data.recentDmg / EntityData.maxRecentDmgTime; offsetval /= 2; Vector4 colouroffset = TextureUtil.ToVec4(Color.DarkGoldenrod) * new Vector4(offsetval, offsetval, offsetval, 1); colouroffset *= e.data.colour; shader["clr"].SetValue(colouroffset); } else { shader["clr"].SetValue(e.data.colour); } Gl.DrawElements(model.drawmode, model.vao.count, DrawElementsType.UnsignedInt, IntPtr.Zero); } } if (GameLogic.RenderHitboxes) { var model = Assets.Models.GetModel(EntityID.HitboxOutline); Gl.BindVertexArray(model.vao.ID); foreach (EntityID entityId in EntitiesMap.Keys) { foreach (Entity e in EntitiesMap[entityId]) { var h = e.hitbox; shader["modelMatrix"].SetValue(MathUtil.ModelMatrix(h.Size, 0, h.Position)); Gl.DrawElements(model.drawmode, model.vao.count, DrawElementsType.UnsignedInt, IntPtr.Zero); } } Gl.BindVertexArray(0); } Gl.BindTexture(Assets.Textures.EntityTexture.TextureTarget, 0); Gl.Disable(EnableCap.Blend); Gl.BindVertexArray(0); Gl.UseProgram(0); }
private static void OnRenderFrame() { watch.Stop(); float deltaTime = (float)watch.ElapsedTicks / System.Diagnostics.Stopwatch.Frequency; watch.Restart(); // perform rotation of the scene depending on keyboard input if (right) { phi += deltaTime; } if (left) { phi -= deltaTime; } if (up) { theta += deltaTime; } if (down) { theta -= deltaTime; } if (theta < 0) { theta += (float)Math.PI * 2; } // set up the viewport and clear the previous depth and color buffers Gl.Viewport(0, 0, width, height); Gl.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit); // make sure the shader program and texture are being used Gl.UseProgram(program.ProgramID); Gl.BindTexture(flagTexture); // calculate the camera position using some fancy polar co-ordinates Vector3 position = 20 * new Vector3((float)(Math.Cos(phi) * Math.Sin(theta)), (float)Math.Cos(theta), (float)(Math.Sin(phi) * Math.Sin(theta))); Vector3 upVector = ((theta % (Math.PI * 2)) > Math.PI) ? new Vector3(0, 1, 0) : new Vector3(0, -1, 0); program["view_matrix"].SetValue(Matrix4.LookAt(position, Vector3.Zero, upVector)); program["time"].SetValue(flagTime); flagTime += deltaTime; Gl.BindBufferToShaderAttribute(flagVertices, program, "vertexPosition"); Gl.BindBufferToShaderAttribute(flagUVs, program, "vertexUV"); Gl.BindBuffer(flagTriangles); Gl.DrawElements(BeginMode.Triangles, flagTriangles.Count, DrawElementsType.UnsignedInt, IntPtr.Zero); // bind the font program as well as the font texture Gl.UseProgram(fontProgram.ProgramID); Gl.BindTexture(font.FontTexture); // build this string every frame, since theta and phi can change FontVAO vao = font.CreateString(fontProgram, string.Format("Theta: {0:0.000}, Phi: {1:0.000}, Time: {2:0.000}", theta, phi, flagTime), BMFont.Justification.Right); vao.Position = new Vector2(width / 2 - 10, height / 2 - font.Height - 10); vao.Draw(); vao.Dispose(); // draw the tutorial information, which is static information.Draw(); Glut.glutSwapBuffers(); }
public void Draw() { // apply our camera view matrix to the shader view matrix (this can be used for all objects in the scene) // Gl.UseProgram(program); program.Use(); program["view_matrix"].SetValue(theCamera.ViewMatrix); program["projection_matrix"].SetValue(projectionMatrix); Gl.ActiveTexture(TextureUnit.Texture0); Gl.BindTexture(TextureTarget.Texture2DArray, textureId); // Gl.BindBuffer(gVertexBuffer); // in vec3 position; // in vec2 texCoord; uint location = (uint)Gl.GetAttribLocation(program.ProgramID, "position"); // int tempStride = stride; // int tempStride = sizeof(Single) * 4; int tempStride = sizeof(Single) * stride; // ***** // int tempStride = sizeof(float)*stride; // int tempStride = Marshal.SizeOf(typeof (float))*stride; Gl.EnableVertexAttribArray(location); Gl.BindBuffer(gVertexBuffer); Gl.VertexAttribPointer(location, 3, VertexAttribPointerType.Float, false, tempStride, IntPtr.Zero); uint locationTexCoord = (uint)Gl.GetAttribLocation(program.ProgramID, "texCoord"); Gl.EnableVertexAttribArray(locationTexCoord); Gl.VertexAttribPointer(locationTexCoord, 2, VertexAttribPointerType.Float, false, tempStride, // (IntPtr)(3 )); // (IntPtr)(3 * sizeof())); new IntPtr(3 * sizeof(Single))); Gl.BindBuffer(gIndirectBuffer); location = (uint)Gl.GetAttribLocation(program.ProgramID, "drawid"); Gl.EnableVertexAttribArray(location); Gl.BindBuffer(gDrawIdBuffer); Gl.VertexAttribPointer(location, 1, VertexAttribPointerType.Int, true, Marshal.SizeOf(typeof(int)), IntPtr.Zero); // Gl.VertexAttribPointer(location, 1, VertexAttribPointerType.UnsignedInt, true, 0, IntPtr.Zero); Gl.VertexAttribDivisor(location, 1); // Gl.VertexAttribDivisor(2, 1); // This needs to be implemented. // https://www.opengl.org/wiki/GLAPI/glMultiDrawElementsIndirect // glClear( GL_COLOR_BUFFER_BIT ); // Gl.MultiDrawElements(BeginMode.Triangles, ); Gl.MultiDrawElementsIndirect(BeginMode.Triangles, DrawElementsType.UnsignedInt, IntPtr.Zero, numberOfTiles, 0); // glMultiDrawElementsIndirect( GL_TRIANGLES, // GL_UNSIGNED_INT, // (GLvoid*)0, // 100, // 0 ); // glutSwapBuffers(); Gl.BindTexture(TextureTarget.Texture2DArray, 0); // Gl.UnmapBuffer() Gl.BindBuffer(BufferTarget.ArrayBuffer, 0); Gl.BindBuffer(BufferTarget.DrawIndirectBuffer, 0); Gl.BindBuffer(BufferTarget.ElementArrayBuffer, 0); Gl.UseProgram(0); }
public static TextureBinding <T> Bind(T texture) { Gl.BindTexture(TextureTarget, texture.Handle); return(new TextureBinding <T>()); }
public Texture(TextureTarget t, string file) : this() { Gl.BindTexture(t, ID); TextureGl(t, file); }
/// <summary> /// Unbind the current texture array /// </summary> public void Unbind() { Gl.BindTexture(TextureTarget.Texture2dArray, 0); }
private static void OnRenderFrame() { //calculate how much time has elapsed since the last frame watch.Stop(); float deltaTime = (float)watch.ElapsedTicks / System.Diagnostics.Stopwatch.Frequency; watch.Restart(); //use the deltaTime to adjust the angle of the cube and pyramid if (autoRotate) { yangle += deltaTime / 2; xangle += deltaTime; } if (up) { xangle -= deltaTime; } if (down) { xangle += deltaTime; } if (left) { yangle += deltaTime; } if (right) { yangle -= deltaTime; } //set up the OpenGl viewport and clear both the color and depth bits Gl.Viewport(0, 0, width, height); Gl.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit); //use our shader program program.Use(); Gl.BindTexture(glassTexture); uint vertexPositionIndex = (uint)Gl.GetAttribLocation(program.ProgramID, "vertexPosition"); Gl.EnableVertexAttribArray(vertexPositionIndex); //enable disable lighting program["enable_lighting"].SetValue(lighting); //bind the vertex position, colors and elemnets of the cube program["model_matrix"].SetValue(Matrix4.CreateRotationY(yangle) * Matrix4.CreateRotationX(xangle)); // System.Diagnostics.Debug.WriteLine("{0} {1} {2} {3}",yangle, xangle, up, down); Gl.BindBufferToShaderAttribute(cube, program, "vertexPosition"); Gl.BindBufferToShaderAttribute(cubeNormals, program, "vertexNormal"); Gl.BindBufferToShaderAttribute(cubeUV, program, "vertexUV"); Gl.BindBuffer(cubeElements); // draw my cube Gl.DrawElements(BeginMode.Quads, cubeElements.Count, DrawElementsType.UnsignedInt, IntPtr.Zero); Glut.glutSwapBuffers(); }
private void BindFrameBuffer(uint frameBuffer, int width, int height) { Gl.BindTexture(TextureTarget.Texture2d, 0); //To make sure the texture isn't bound Gl.BindFramebuffer(FramebufferTarget.Framebuffer, frameBuffer); Gl.Viewport(0, 0, width, height); }
private static void OnRenderFrame() { watch.Stop(); float deltaTime = (float)watch.ElapsedTicks / System.Diagnostics.Stopwatch.Frequency; watch.Restart(); if (msaa) { Gl.Enable(EnableCap.Multisample); } else { Gl.Disable(EnableCap.Multisample); } // update our camera by moving it up to 5 units per second in each direction if (down) { camera.MoveRelative(Vector3.UnitZ * deltaTime * 5); } if (up) { camera.MoveRelative(-Vector3.UnitZ * deltaTime * 5); } if (left) { camera.MoveRelative(-Vector3.UnitX * deltaTime * 5); } if (right) { camera.MoveRelative(Vector3.UnitX * deltaTime * 5); } if (space) { camera.MoveRelative(Vector3.UnitY * deltaTime * 3); } // set up the viewport and clear the previous depth and color buffers Gl.Viewport(0, 0, width, height); Gl.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit); // apply our camera view matrix to the shader view matrix (this can be used for all objects in the scene) Gl.UseProgram(program); program["view_matrix"].SetValue(camera.ViewMatrix); // now draw the object file if (wireframe) { Gl.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Line); } objectFile.Draw(); Gl.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Fill); // bind the font program as well as the font texture Gl.UseProgram(fontProgram.ProgramID); Gl.BindTexture(font.FontTexture); // draw the tutorial information, which is static information.Draw(); Glut.glutSwapBuffers(); }
public void TestGenTexture() { if (!HasVersion(1, 1) && !HasEsVersion(1, 0)) { Assert.Inconclusive("OpenGL 1.1 or OpenGL ES 1.0"); } uint[] textureObjects = new uint[3]; uint textureObject; textureObject = Gl.GenTexture(); Assert.AreNotEqual(0, textureObject); Assert.IsFalse(Gl.IsTexture(textureObject)); try { Gl.BindTexture(TextureTarget.Texture2d, textureObject); Assert.IsTrue(Gl.IsTexture(textureObject)); } finally { Gl.DeleteTextures(textureObject); Assert.IsFalse(Gl.IsTexture(textureObject)); } Gl.GenTextures(textureObjects); try { for (int i = 0; i < textureObjects.Length; i++) { Assert.AreNotEqual(0, textureObjects[i]); Assert.IsFalse(Gl.IsTexture(textureObjects[i])); Gl.BindTexture(TextureTarget.Texture2d, textureObjects[i]); Assert.IsTrue(Gl.IsTexture(textureObjects[i])); } } finally { for (int i = 0; i < textureObjects.Length; i++) { if (Gl.IsTexture(textureObjects[i])) { Gl.DeleteTextures(textureObjects[i]); Assert.IsFalse(Gl.IsTexture(textureObjects[i])); } } } Gl.GenTextures(textureObjects); try { for (int i = 0; i < textureObjects.Length; i++) { Assert.AreNotEqual(0, textureObjects[i]); Assert.IsFalse(Gl.IsTexture(textureObjects[i])); Gl.BindTexture(TextureTarget.Texture2d, textureObjects[i]); Assert.IsTrue(Gl.IsTexture(textureObjects[i])); } } finally { Gl.DeleteTextures(textureObjects); for (int i = 0; i < textureObjects.Length; i++) { Assert.IsFalse(Gl.IsTexture(textureObjects[i])); } } Gl.GenTextures(textureObjects); try { for (int i = 0; i < textureObjects.Length; i++) { Assert.AreNotEqual(0, textureObjects[i]); Assert.IsFalse(Gl.IsTexture(textureObjects[i])); Gl.BindTexture(TextureTarget.Texture2d, textureObjects[i]); Assert.IsTrue(Gl.IsTexture(textureObjects[i])); } } finally { Gl.DeleteTextures(textureObjects[0], textureObjects[1], textureObjects[2]); for (int i = 0; i < textureObjects.Length; i++) { Assert.IsFalse(Gl.IsTexture(textureObjects[i])); } } }
private static void OnRenderFrame() { watch.Stop(); float deltaTime = (float)watch.ElapsedTicks / System.Diagnostics.Stopwatch.Frequency; watch.Restart(); Console.WriteLine("FPS : " + 1f / deltaTime); time += deltaTime * timedir; // perform rotation of the cube depending on the keyboard state if (autoRotate) { xangle += deltaTime / 2; yangle += deltaTime; } if (right) { yangle += deltaTime; } if (left) { yangle -= deltaTime; } if (up) { xangle -= deltaTime; } if (down) { xangle += deltaTime; } // set up the viewport and clear the previous depth and color buffers Gl.Viewport(0, 0, width, height); Gl.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit); //Gl.ClearColor(255f/255,255f/255,255f/255,255f/255); // make sure the shader program and texture are being used Gl.UseProgram(program); Gl.BindTexture(CarModel.bodyTexture); Gl.Disable(EnableCap.Blend); Gl.Enable(EnableCap.DepthTest); // set up the model matrix and draw the cube program["model_matrix"].SetValue(Matrix4.CreateRotationY(yangle) * Matrix4.CreateRotationX(xangle)); program["enable_lighting"].SetValue(lighting); Gl.BindBufferToShaderAttribute(CarModel.cube, program, "vertexPosition"); Gl.BindBufferToShaderAttribute(CarModel.cubeNormals, program, "vertexNormal"); Gl.BindBufferToShaderAttribute(CarModel.cubeUV, program, "vertexUV"); Gl.BindBuffer(CarModel.cubeQuads); Gl.DrawElements(BeginMode.Quads, CarModel.cubeQuads.Count, DrawElementsType.UnsignedInt, IntPtr.Zero); //Draw window Gl.BindTexture(CarModel.kacaTexture); program["max_diffuse"].SetValue(maxdiffuse); program["ambient"].SetValue(ambient); Gl.BindBufferToShaderAttribute(CarModel.window, program, "vertexPosition"); Gl.BindBufferToShaderAttribute(CarModel.windowNormals, program, "vertexNormal"); Gl.BindBufferToShaderAttribute(CarModel.windowUV, program, "vertexUV"); Gl.BindBuffer(CarModel.windowQuads); Gl.DrawElements(BeginMode.Quads, CarModel.windowQuads.Count, DrawElementsType.UnsignedInt, IntPtr.Zero); //drawwheel Gl.BindTexture(CarModel.rodaTexture); Gl.BindBufferToShaderAttribute(CarModel.wheel1, program, "vertexPosition"); Gl.BindBufferToShaderAttribute(CarModel.wheel1Normals, program, "vertexNormal"); Gl.BindBufferToShaderAttribute(CarModel.wheel1UV, program, "vertexUV"); Gl.BindBuffer(CarModel.wheel1Quads); Gl.DrawElements(BeginMode.TriangleStrip, CarModel.wheel1Quads.Count, DrawElementsType.UnsignedInt, IntPtr.Zero); Gl.BindBufferToShaderAttribute(CarModel.wheel2, program, "vertexPosition"); Gl.DrawElements(BeginMode.TriangleStrip, CarModel.wheel1Quads.Count, DrawElementsType.UnsignedInt, IntPtr.Zero); Gl.BindBufferToShaderAttribute(CarModel.wheel2Normals, program, "vertexNormal"); Gl.BindBufferToShaderAttribute(CarModel.wheel3, program, "vertexPosition"); Gl.DrawElements(BeginMode.TriangleStrip, CarModel.wheel1Quads.Count, DrawElementsType.UnsignedInt, IntPtr.Zero); Gl.BindBufferToShaderAttribute(CarModel.wheel4, program, "vertexPosition"); Gl.DrawElements(BeginMode.TriangleStrip, CarModel.wheel1Quads.Count, DrawElementsType.UnsignedInt, IntPtr.Zero); //Gl.BindTexture(velgTexture); Gl.BindBufferToShaderAttribute(CarModel.wheel1Normals, program, "vertexNormal"); Gl.BindBufferToShaderAttribute(CarModel.velg1, program, "vertexPosition"); Gl.DrawElements(BeginMode.TriangleFan, CarModel.wheel1Quads.Count, DrawElementsType.UnsignedInt, IntPtr.Zero); Gl.BindBufferToShaderAttribute(CarModel.velg2, program, "vertexPosition"); Gl.DrawElements(BeginMode.TriangleFan, CarModel.wheel1Quads.Count, DrawElementsType.UnsignedInt, IntPtr.Zero); Gl.BindBufferToShaderAttribute(CarModel.wheel2Normals, program, "vertexNormal"); Gl.BindBufferToShaderAttribute(CarModel.velg3, program, "vertexPosition"); Gl.DrawElements(BeginMode.TriangleFan, CarModel.wheel1Quads.Count, DrawElementsType.UnsignedInt, IntPtr.Zero); Gl.BindBufferToShaderAttribute(CarModel.velg4, program, "vertexPosition"); Gl.DrawElements(BeginMode.TriangleFan, CarModel.wheel1Quads.Count, DrawElementsType.UnsignedInt, IntPtr.Zero); Gl.Enable(EnableCap.Blend); Gl.Disable(EnableCap.DepthTest); //Draw Rain // make sure the shader program and texture are being used Gl.UseProgram(Rain.program.ProgramID); Gl.BindTexture(Rain.particleTexture); Rain.program["model_matrix"].SetValue(Matrix4.CreateRotationY(yangle) * Matrix4.CreateRotationX(xangle)); // update our particle list for (int i = 0; i < Rain.particles.Count; i++) { Rain.particles[i].Update(deltaTime); //if (particles[i].Life < 0) particles[i] = new Particle(Vector3.Zero); if (Rain.particles[i].Life < 0) { Rain.particles[i] = new Rain.Particle(new Vector3((float)Rain.generator.NextDouble() * 50 - 25, 20, (float)Rain.generator.NextDouble() * 50 - 25)); } Rain.particlePositions[i] = Rain.particles[i].Position; } // delete our previous particle positions (if applicable) and then create a new VBO if (Rain.particleVertices != null) { Rain.particleVertices.Dispose(); } Rain.particleVertices = new VBO <Vector3>(Rain.particlePositions); // bind the VBOs to their shader attributes Gl.BindBufferToShaderAttribute(Rain.particleVertices, Rain.program, "vertexPosition"); Gl.BindBufferToShaderAttribute(Rain.particleColors, Rain.program, "vertexColor"); Gl.BindBuffer(Rain.particlePoints); // enable point sprite mode (which enables the gl_PointCoord value) Gl.Enable(EnableCap.PointSprite); Gl.DrawElements(BeginMode.Points, Rain.particlePoints.Count, DrawElementsType.UnsignedInt, IntPtr.Zero); Gl.Disable(EnableCap.PointSprite); //Draw Smoke // make sure the shader program and texture are being used Gl.UseProgram(Smoke.program.ProgramID); Gl.BindTexture(Smoke.particleTexture); Smoke.program["model_matrix"].SetValue(Matrix4.CreateRotationY(yangle) * Matrix4.CreateRotationX(xangle)); if (time > 5f) { timedir = -1; } else if (time < 0f) { timedir = 1; } Smoke.program["mixer"].SetValue(time / 2.5f); // update our particle list for (int i = 0; i < Smoke.particles.Count; i++) { Smoke.particles[i].Update(deltaTime); //if (particles[i].Life < 0) particles[i] = new Particle(Vector3.Zero); if (Smoke.particles[i].Life < 0) { Smoke.particles[i] = new Smoke.Particle(new Vector3(1.8f, 0.2f, 0.3f)); } Smoke.particlePositions[i] = Smoke.particles[i].Position; } // delete our previous particle positions (if applicable) and then create a new VBO if (Smoke.particleVertices != null) { Smoke.particleVertices.Dispose(); } Smoke.particleVertices = new VBO <Vector3>(Smoke.particlePositions); // bind the VBOs to their shader attributes Gl.BindBufferToShaderAttribute(Smoke.particleVertices, Smoke.program, "vertexPosition"); Gl.BindBufferToShaderAttribute(Smoke.particleColors, Smoke.program, "vertexColor"); Gl.BindBuffer(Smoke.particlePoints); // enable point sprite mode (which enables the gl_PointCoord value) Gl.Enable(EnableCap.PointSprite); Gl.DrawElements(BeginMode.Points, Smoke.particlePoints.Count, DrawElementsType.UnsignedInt, IntPtr.Zero); Gl.Disable(EnableCap.PointSprite); Glut.glutSwapBuffers(); }
public static void Unbind() => Gl.BindTexture(TextureTarget.Texture2d, 0u);
public void Bind() { // Lock(); Gl.BindTexture(TextureTarget.Texture2d, TexturePointer); // Unlock(); }
public override void DrawMesh(ICubismTexture itexture, float[] vertex_buffer, float[] uv_buffer, short[] index_buffer, ICubismClippingMask iclipping_mask, Matrix clipping_matrix, BlendModeType blend_mode, bool use_culling, double opacity) { var texture = (CubismOpenGlNetTexture)itexture; var clipping_mask = iclipping_mask as CubismOpenGlNetClippingMask; bool use_clipping_mask = (clipping_mask != null); UseCulling = use_culling; BlendMode = blend_mode; var shader = ShaderManager.ShaderForDrawMesh(use_clipping_mask, UsePremultipliedAlpha); Gl.UseProgram(shader.ProgramId); // 頂点バッファを設定する Gl.EnableVertexAttribArray((uint)shader.AttributePositionLocation); GCHandle pinned_vertex_buffer = GCHandle.Alloc(vertex_buffer, GCHandleType.Pinned); Gl.VertexAttribPointer((uint)shader.AttributePositionLocation, 2, VertexAttribType.Float, false, sizeof(float) * 2, pinned_vertex_buffer.AddrOfPinnedObject()); // UVバッファを設定する Gl.EnableVertexAttribArray((uint)shader.AttributeTexCoordLocation); GCHandle pinned_uv_buffer = GCHandle.Alloc(uv_buffer, GCHandleType.Pinned); Gl.VertexAttribPointer((uint)shader.AttributeTexCoordLocation, 2, VertexAttribType.Float, false, sizeof(float) * 2, pinned_uv_buffer.AddrOfPinnedObject()); if (use_clipping_mask == true) { Gl.ActiveTexture(TextureUnit.Texture1); Gl.BindTexture(TextureTarget.Texture2d, clipping_mask.TextureId); Gl.Uniform1(shader.SamplerTexture1Location, 1); // View座標をClippingContextの座標に変換するための行列を設定 Gl.UniformMatrix4(shader.UniformClipMatrixLocation, false, clipping_matrix.AsColumnMajorArray()); // 使用するカラーチャンネルを設定 Gl.Uniform4(shader.UnifromChannelFlagLocation, 1.0f, 0.0f, 0.0f, 0.0f); } else { Gl.ActiveTexture(TextureUnit.Texture1); Gl.BindTexture(TextureTarget.Texture2d, 0); } //テクスチャ設定 Gl.ActiveTexture(TextureUnit.Texture0); Gl.BindTexture(TextureTarget.Texture2d, texture.TextureId); Gl.Uniform1(shader.SamplerTexture0Location, 0); // 座標変換 Gl.UniformMatrix4(shader.UniformMatrixLocation, false, MvpMatrix.AsColumnMajorArray()); // モデルの色を設定する float[] color = new float[4]; ModelColor.CopyTo(color, 0); color[3] *= (float)opacity; if (UsePremultipliedAlpha == true) { color[0] *= color[3]; color[1] *= color[3]; color[2] *= color[3]; } Gl.Uniform4(shader.UniformBaseColorLocation, color[0], color[1], color[2], color[3]); // 描画する GCHandle pinned_index_buffer = GCHandle.Alloc(index_buffer, GCHandleType.Pinned); Gl.DrawElements(PrimitiveType.Triangles, index_buffer.Length, DrawElementsType.UnsignedShort, pinned_index_buffer.AddrOfPinnedObject()); // バッファのアドレスの固定を解除する pinned_vertex_buffer.Free(); pinned_uv_buffer.Free(); pinned_index_buffer.Free(); }
public void Bind(Texture texture) { GlHelper.ThrowNullException(Target); Gl.BindTexture(Target, texture.Id); GlHelper.GetError(); }
private static void OnRenderFrame() { watch.Stop(); float deltaTime = (float)watch.ElapsedTicks / System.Diagnostics.Stopwatch.Frequency; watch.Restart(); // update our camera by moving it up to 5 units per second in each direction if (down) { camera.MoveRelative(Vector3.UnitZ * deltaTime * 5); } if (up) { camera.MoveRelative(-Vector3.UnitZ * deltaTime * 5); } if (left) { camera.MoveRelative(-Vector3.UnitX * deltaTime * 5); } if (right) { camera.MoveRelative(Vector3.UnitX * deltaTime * 5); } if (space) { camera.MoveRelative(Vector3.Up * deltaTime * 3); } // set up the viewport and clear the previous depth and color buffers Gl.Viewport(0, 0, width, height); Gl.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit); // make sure the shader program and texture are being used Gl.UseProgram(program); Gl.ActiveTexture(TextureUnit.Texture1); Gl.BindTexture(brickNormals); Gl.ActiveTexture(TextureUnit.Texture0); Gl.BindTexture(brickDiffuse); // apply our camera view matrix to the shader view matrix (this can be used for all objects in the scene) program["view_matrix"].SetValue(camera.ViewMatrix); // set up the model matrix and draw the cube program["model_matrix"].SetValue(Matrix4.Identity); program["enable_lighting"].SetValue(lighting); program["enable_mapping"].SetValue(normalMapping); Gl.BindBufferToShaderAttribute(cube, program, "vertexPosition"); Gl.BindBufferToShaderAttribute(cubeNormals, program, "vertexNormal"); Gl.BindBufferToShaderAttribute(cubeTangents, program, "vertexTangent"); Gl.BindBufferToShaderAttribute(cubeUV, program, "vertexUV"); Gl.BindBuffer(cubeTriangles); Gl.DrawElements(BeginMode.Triangles, cubeTriangles.Count, DrawElementsType.UnsignedInt, IntPtr.Zero); // bind the font program as well as the font texture Gl.UseProgram(fontProgram.ProgramID); Gl.BindTexture(font.FontTexture); // draw the tutorial information, which is static information.Draw(); Glut.glutSwapBuffers(); }
/// <summary> /// bind the curent texture array /// </summary> public void Bind() { Gl.BindTexture(TextureTarget.Texture2dArray, id); }
private static void Main() { if (!Glfw.Init()) { Environment.Exit(-1); } Glfw.WindowHint(Glfw.Hint.Resizable, false); Glfw.WindowHint(Glfw.Hint.Doublebuffer, true); Glfw.WindowHint(Glfw.Hint.Samples, 4); Glfw.Window window = Glfw.CreateWindow(1280, 720, "Hello World!"); if (!window) { Glfw.Terminate(); Environment.Exit(-1); } Gl.Initialize(); Glfw.MakeContextCurrent(window); Gl.Enable(EnableCap.Multisample); Gl.Enable(EnableCap.Texture2d); Gl.BlendFunc(BlendingFactor.SrcAlpha, BlendingFactor.OneMinusSrcAlpha); Gl.Enable(EnableCap.Blend); System.Diagnostics.Trace.TraceInformation($"Renderer: {Gl.GetString(StringName.Renderer)}"); System.Diagnostics.Trace.TraceInformation($"Version: {Gl.GetString(StringName.Version)}"); uint vao = Gl.GenVertexArray(); Gl.BindVertexArray(vao); float[] points = { // Pos color tex -0.5f, 0.5f, 0f, 1f, 1f, 1f, 0f, 0f, 0.5f, 0.5f, 0f, 1f, 1f, 1f, 1f, 0f, 0.5f, -0.5f, 0f, 1f, 1f, 1f, 1f, 1f, -0.5f, -0.5f, 0f, 1f, 1f, 1f, 0f, 1f, 0f, 0f, 0f, 1f, 1f, 1f, 0f, 0f, 1f, 0f, 0f, 1f, 1f, 1f, 1f, 0f, 1f, -1f, 0f, 1f, 1f, 1f, 1f, 1f, 0f, -1f, 0f, 1f, 1f, 1f, 0f, 1f }; uint buffer = Gl.GenBuffer(); Gl.BindBuffer(BufferTarget.ArrayBuffer, buffer); Gl.BufferData(BufferTarget.ArrayBuffer, (uint)points.Length * 4, points, BufferUsage.StaticDraw); uint[] elements = { 0, 1, 2, 2, 3, 0, 4, 5, 6, 6, 7, 4 }; uint ebo = Gl.GenBuffer(); Gl.BindBuffer(BufferTarget.ElementArrayBuffer, ebo); Gl.BufferData(BufferTarget.ElementArrayBuffer, (uint)elements.Length * 4, elements, BufferUsage.StaticDraw); uint texture = Gl.CreateTexture(TextureTarget.Texture2d); { Gl.BindTexture(TextureTarget.Texture2d, texture); using (var image = new System.Drawing.Bitmap(".\\resources\\textures\\dirt.png")) { System.Drawing.Imaging.BitmapData data = image.LockBits(new System.Drawing.Rectangle(0, 0, image.Width, image.Height), System.Drawing.Imaging.ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb); Gl.TexImage2D(TextureTarget.Texture2d, 0, InternalFormat.Rgba, data.Width, data.Height, 0, PixelFormat.Bgra, PixelType.UnsignedByte, data.Scan0); image.UnlockBits(data); } Gl.TexParameter(TextureTarget.Texture2d, TextureParameterName.TextureMinFilter, Gl.NEAREST); Gl.TexParameter(TextureTarget.Texture2d, TextureParameterName.TextureMagFilter, Gl.NEAREST); } ShaderProgram program; using (var vertexShader = Shader.FromFile(".\\src\\shaders\\SimpleVertexShader.vert", ShaderType.VertexShader)) using (var fragmentShader = Shader.FromFile(".\\src\\shaders\\SimpleFragmentShader.frag", ShaderType.FragmentShader)) { program = new ShaderProgram( new[] { vertexShader, fragmentShader }, new string[] { "model", "projection" }, new[] { "position", "color", "texcoord" } ); } program.Use(); var posAttrib = (uint)program.Attributes["position"]; Gl.EnableVertexAttribArray(posAttrib); Gl.VertexAttribPointer(posAttrib, 3, VertexAttribType.Float, false, 8 * 4, IntPtr.Zero); var colAttrib = (uint)program.Attributes["color"]; Gl.EnableVertexAttribArray(colAttrib); Gl.VertexAttribPointer(colAttrib, 3, VertexAttribType.Float, false, 8 * 4, new IntPtr(3 * 4)); var texAttrib = (uint)program.Attributes["texcoord"]; Gl.EnableVertexAttribArray(texAttrib); Gl.VertexAttribPointer(texAttrib, 2, VertexAttribType.Float, false, 8 * 4, new IntPtr(6 * 4)); // var modelView = Matrix4x4f.Translated(0f, 0f, 0f); // var projection = Matrix4x4d.Ortho2D(-1f, 1f, -1f, 1f); // var modelAttrib = Gl.GetAttribLocation(programId, "model"); //var viewAttrib = Gl.GetAttribLocation(programId, "view"); //Gl.UniformMatrix4f(viewAttrib, 1, false, ref view); // var projectionAttrib = Gl.GetAttribLocation(programId, "projection"); // Gl.UniformMatrix4f(projectionAttrib, 1, false, projection); while (!Glfw.WindowShouldClose(window)) { Gl.ClearColor(1.0f, 0.0f, 1.0f, 1.0f); Gl.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit); // Gl.UniformMatrix4f(modelAttrib, 1, false, projection * modelView); Gl.DrawElements(PrimitiveType.Triangles, elements.Length, DrawElementsType.UnsignedInt, IntPtr.Zero); Glfw.SwapBuffers(window); Glfw.PollEvents(); if (Glfw.GetKey(window, (int)Glfw.KeyCode.Escape)) { Glfw.SetWindowShouldClose(window, true); } } Console.WriteLine("Exiting..."); Gl.DeleteBuffers(buffer); Gl.DeleteVertexArrays(vao); Glfw.Terminate(); }
private static void OnRenderFrame() { watch.Stop(); float deltaTime = (float)watch.ElapsedTicks / System.Diagnostics.Stopwatch.Frequency; watch.Restart(); // perform rotation of the scene depending on keyboard input if (right) { phi += deltaTime; } if (left) { phi -= deltaTime; } if (up) { theta += deltaTime; } if (down) { theta -= deltaTime; } if (theta < 0) { theta += (float)Math.PI * 2; } // set up the viewport and clear the previous depth and color buffers Gl.Viewport(0, 0, width, height); Gl.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit); // make sure the shader program and texture are being used Gl.UseProgram(program.ProgramID); Gl.BindTexture(starTexture); // calculate the camera position using some fancy polar co-ordinates Vector3 position = 20 * new Vector3((float)(Math.Cos(phi) * Math.Sin(theta)), (float)Math.Cos(theta), (float)(Math.Sin(phi) * Math.Sin(theta))); Vector3 upVector = ((theta % (Math.PI * 2)) > Math.PI) ? new Vector3(0, 1, 0) : new Vector3(0, -1, 0); program["view_matrix"].SetValue(Matrix4.LookAt(position, Vector3.Zero, upVector)); // loop through the stars, drawing each one for (int i = 0; i < stars.Count; i++) { // set the position and color of this star program["model_matrix"].SetValue(Matrix4.CreateTranslation(new Vector3(stars[i].dist, 0, 0)) * Matrix4.CreateRotationZ(stars[i].angle)); program["color"].SetValue(stars[i].color); Gl.BindBufferToShaderAttribute(star, program, "vertexPosition"); Gl.BindBufferToShaderAttribute(starUV, program, "vertexUV"); Gl.BindBuffer(starQuads); Gl.DrawElements(BeginMode.Triangles, starQuads.Count, DrawElementsType.UnsignedInt, IntPtr.Zero); // update the position of the star stars[i].angle += (float)i / stars.Count * deltaTime * 2; stars[i].dist -= 0.2f * deltaTime; // if we've reached the center then move this star outwards and give it a new color if (stars[i].dist < 0f) { stars[i].dist += 5f; stars[i].color = new Vector3((float)generator.NextDouble(), (float)generator.NextDouble(), (float)generator.NextDouble()); } } // bind the font program as well as the font texture Gl.UseProgram(fontProgram.ProgramID); Gl.BindTexture(font.FontTexture); // build this string every frame, since theta and phi can change FontVAO vao = font.CreateString(fontProgram, string.Format("Theta: {0:0.000}, Phi: {1:0.000}", theta, phi), BMFont.Justification.Right); vao.Position = new Vector2(width / 2 - 10, height / 2 - font.Height - 10); vao.Draw(); vao.Dispose(); // draw the tutorial information, which is static information.Draw(); Glut.glutSwapBuffers(); }
private static void OnRenderFrame() { watch.Stop(); float deltaTime = (float)watch.ElapsedTicks / System.Diagnostics.Stopwatch.Frequency; watch.Restart(); // set up the viewport and clear the previous depth and color buffers Gl.Viewport(0, 0, width, height); Gl.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit); // perform rotation of the cube depending on the keyboard state if (autoRotate) { xangle += deltaTime / 2; yangle += deltaTime; } if (right) { yangle += deltaTime; } if (left) { yangle -= deltaTime; } if (up) { xangle -= deltaTime; } if (down) { xangle += deltaTime; } // make sure the shader program and texture are being used Gl.UseProgram(program); Gl.ActiveTexture(TextureUnit.Texture1); Gl.BindTexture(brickNormals); Gl.ActiveTexture(TextureUnit.Texture0); Gl.BindTexture(brickDiffuse); // set up the model matrix and draw the cube program["model_matrix"].SetValue(Matrix4.CreateRotationY(yangle) * Matrix4.CreateRotationX(xangle)); program["enable_lighting"].SetValue(lighting); program["enable_mapping"].SetValue(normalMapping); Gl.BindBufferToShaderAttribute(cube, program, "vertexPosition"); Gl.BindBufferToShaderAttribute(cubeNormals, program, "vertexNormal"); Gl.BindBufferToShaderAttribute(cubeTangents, program, "vertexTangent"); Gl.BindBufferToShaderAttribute(cubeUV, program, "vertexUV"); Gl.BindBuffer(cubeTriangles); Gl.DrawElements(BeginMode.Triangles, cubeTriangles.Count, DrawElementsType.UnsignedInt, IntPtr.Zero); // bind the font program as well as the font texture Gl.UseProgram(fontProgram.ProgramID); Gl.BindTexture(font.FontTexture); // draw the tutorial information, which is static information.Draw(); Glut.glutSwapBuffers(); }
public TextureBinding(T texture) { Gl.BindTexture(TextureTarget, texture.Handle); }
public void Bind() { Gl.BindTexture(TextureTarget.Texture2d, _id); }
public void Dispose() => Gl.BindTexture(TextureTarget, 0u);
private static void OnRenderFrame() { //Clock tick used for animation watch.Stop(); float deltaTime = (float)watch.ElapsedTicks / System.Diagnostics.Stopwatch.Frequency; watch.Restart(); angle += deltaTime; Gl.Viewport(0, 0, width, height); Gl.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit); //Use shader Gl.UseProgram(program); //Drawing cube #region Gl.BindTexture(crateTexture); program["model_matrix"].SetValue( Matrix4.CreateRotationZ(angle * speedS) * Matrix4.CreateRotationY(angle * speedS) * Matrix4.CreateRotationX(angle * speedS) * Matrix4.CreateScaling(new Vector3(0.5f, 0.5f, 0.5f)) * Matrix4.CreateTranslation(new Vector3(0, 0, -5))); Gl.BindBufferToShaderAttribute(cube, program, "vertexPosition"); Gl.BindBufferToShaderAttribute(cubeUV, program, "vertexUV"); Gl.BindBuffer(cubeElements); //Dibuja el cube Gl.DrawElements(BeginMode.Quads, cubeElements.Count, DrawElementsType.UnsignedInt, IntPtr.Zero); #endregion //Drawing rect #region Gl.BindTexture(rectTexture); program["model_matrix"].SetValue( Matrix4.CreateRotationY(angle * speedS) * Matrix4.CreateScaling(new Vector3(0.5f, 0.5f, 0.5f)) * Matrix4.CreateTranslation(new Vector3(-3, 0, -2))); Gl.BindBufferToShaderAttribute(rect, program, "vertexPosition"); Gl.BindBufferToShaderAttribute(rectUV, program, "vertexUV"); Gl.BindBuffer(rectElements); Gl.DrawElements(BeginMode.Quads, rectElements.Count, DrawElementsType.UnsignedInt, IntPtr.Zero); #endregion //Drawing pyramid #region Gl.BindTexture(pyTexture); program["model_matrix"].SetValue( Matrix4.CreateRotationZ(angle * speedS) * Matrix4.CreateTranslation(new Vector3(2, 0, -2))); Gl.BindBufferToShaderAttribute(pyramid, program, "vertexPosition"); Gl.BindBufferToShaderAttribute(pyUV, program, "vertexUV"); Gl.BindBuffer(pyramidElements); Gl.DrawElements(BeginMode.Triangles, pyramidElements.Count, DrawElementsType.UnsignedInt, IntPtr.Zero); #endregion Glut.glutSwapBuffers(); }
private static uint CreatePrefilteredEnvironmentMap(Shader shader, Action preRender) { var cube = new Cube(); var captureFbo = Gl.GenFramebuffer(); Gl.BindFramebuffer(FramebufferTarget.Framebuffer, captureFbo); var captureRbo = Gl.GenRenderbuffer(); Gl.BindRenderbuffer(RenderbufferTarget.Renderbuffer, captureRbo); Gl.RenderbufferStorage(RenderbufferTarget.Renderbuffer, InternalFormat.DepthComponent24, 128, 128); Gl.FramebufferRenderbuffer(FramebufferTarget.Framebuffer, FramebufferAttachment.DepthAttachment, RenderbufferTarget.Renderbuffer, captureRbo); var prefilterMap = Gl.GenTexture(); Gl.BindTexture(TextureTarget.TextureCubeMap, prefilterMap); for (int i = 0; i < 6; ++i) { Gl.TexImage2D(TextureTarget.TextureCubeMapPositiveX + i, 0, InternalFormat.Rgb16f, 128, 128, 0, PixelFormat.Rgb, PixelType.Float, IntPtr.Zero); } Gl.TexParameter(TextureTarget.TextureCubeMap, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.LinearMipmapLinear); Gl.TexParameter(TextureTarget.TextureCubeMap, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear); Gl.TexParameter(TextureTarget.TextureCubeMap, TextureParameterName.TextureWrapS, (int)TextureWrapMode.ClampToEdge); Gl.TexParameter(TextureTarget.TextureCubeMap, TextureParameterName.TextureWrapT, (int)TextureWrapMode.ClampToEdge); Gl.TexParameter(TextureTarget.TextureCubeMap, TextureParameterName.TextureWrapR, (int)TextureWrapMode.ClampToEdge); Gl.GenerateMipmap(TextureTarget.TextureCubeMap); var projMatrix = Matrix4x4f.Perspective(90f, 1.0f, 0.1f, 10.0f); var viewMatrices = new Matrix4x4f[] { Matrix4x4f.LookAt(new Vertex3f(0f, 0f, 0f), new Vertex3f(1f, 0f, 0f), new Vertex3f(0f, -1f, 0f)), Matrix4x4f.LookAt(new Vertex3f(0f, 0f, 0f), new Vertex3f(-1f, 0f, 0f), new Vertex3f(0f, -1f, 0f)), Matrix4x4f.LookAt(new Vertex3f(0f, 0f, 0f), new Vertex3f(0f, 1f, 0f), new Vertex3f(0f, 0f, 1f)), Matrix4x4f.LookAt(new Vertex3f(0f, 0f, 0f), new Vertex3f(0f, -1f, 0f), new Vertex3f(0f, 0f, -1f)), Matrix4x4f.LookAt(new Vertex3f(0f, 0f, 0f), new Vertex3f(0f, 0f, 1f), new Vertex3f(0f, -1f, 0f)), Matrix4x4f.LookAt(new Vertex3f(0f, 0f, 0f), new Vertex3f(0f, 0f, -1f), new Vertex3f(0f, -1f, 0f)), }; shader.Use(); preRender.Invoke(); shader.SetMatrix("projectionMatrix", projMatrix); Gl.BindFramebuffer(FramebufferTarget.Framebuffer, captureFbo); int mipLevels = 5; for (int mips = 0; mips < mipLevels; ++mips) { int mipSize = (int)(128 * (float)Math.Pow(0.5, mips)); Gl.BindRenderbuffer(RenderbufferTarget.Renderbuffer, captureRbo); Gl.RenderbufferStorage(RenderbufferTarget.Renderbuffer, InternalFormat.DepthComponent24, mipSize, mipSize); Gl.Viewport(0, 0, mipSize, mipSize); float roughness = mips / (float)(mipLevels - 1); shader.SetFloat("roughness", roughness); for (int i = 0; i < 6; ++i) { shader.SetMatrix("viewMatrix", viewMatrices[i]); Gl.FramebufferTexture2D(FramebufferTarget.Framebuffer, FramebufferAttachment.ColorAttachment0, TextureTarget.TextureCubeMapPositiveX + i, prefilterMap, mips); Gl.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit); cube.Draw(); } } Gl.BindFramebuffer(FramebufferTarget.Framebuffer, 0); return(prefilterMap); }
private static void OnRenderFrame() { watch.Stop(); float deltaTime = (float)watch.ElapsedTicks / System.Diagnostics.Stopwatch.Frequency; watch.Restart(); // perform rotation of the cube depending on the keyboard state if (autoRotate) { xangle += deltaTime / 2; yangle += deltaTime; } if (right) { yangle += deltaTime; } if (left) { yangle -= deltaTime; } if (up) { xangle -= deltaTime; } if (down) { xangle += deltaTime; } // set up the viewport and clear the previous depth and color buffers Gl.Viewport(0, 0, width, height); Gl.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit); Gl.ClearColor(30f / 255, 144f / 255, 255f / 255, 255f / 255); // make sure the shader program and texture are being used Gl.UseProgram(program); Gl.BindTexture(CarModel.bodyTexture); // set up the model matrix and draw the cube program["model_matrix"].SetValue(Matrix4.CreateRotationY(yangle) * Matrix4.CreateRotationX(xangle)); program["enable_lighting"].SetValue(lighting); Gl.BindBufferToShaderAttribute(CarModel.cube, program, "vertexPosition"); Gl.BindBufferToShaderAttribute(CarModel.cubeNormals, program, "vertexNormal"); Gl.BindBufferToShaderAttribute(CarModel.cubeUV, program, "vertexUV"); Gl.BindBuffer(CarModel.cubeQuads); Gl.DrawElements(BeginMode.Quads, CarModel.cubeQuads.Count, DrawElementsType.UnsignedInt, IntPtr.Zero); //Draw window Gl.BindTexture(CarModel.kacaTexture); program["max_diffuse"].SetValue(maxdiffuse); program["ambient"].SetValue(ambient); Gl.BindBufferToShaderAttribute(CarModel.window, program, "vertexPosition"); Gl.BindBufferToShaderAttribute(CarModel.windowNormals, program, "vertexNormal"); Gl.BindBufferToShaderAttribute(CarModel.windowUV, program, "vertexUV"); Gl.BindBuffer(CarModel.windowQuads); Gl.DrawElements(BeginMode.Quads, CarModel.windowQuads.Count, DrawElementsType.UnsignedInt, IntPtr.Zero); //drawwheel Gl.BindTexture(CarModel.rodaTexture); Gl.BindBufferToShaderAttribute(CarModel.wheel1, program, "vertexPosition"); Gl.BindBufferToShaderAttribute(CarModel.wheel1Normals, program, "vertexNormal"); Gl.BindBufferToShaderAttribute(CarModel.wheel1UV, program, "vertexUV"); Gl.BindBuffer(CarModel.wheel1Quads); Gl.DrawElements(BeginMode.TriangleStrip, CarModel.wheel1Quads.Count, DrawElementsType.UnsignedInt, IntPtr.Zero); Gl.BindBufferToShaderAttribute(CarModel.wheel2, program, "vertexPosition"); Gl.DrawElements(BeginMode.TriangleStrip, CarModel.wheel1Quads.Count, DrawElementsType.UnsignedInt, IntPtr.Zero); Gl.BindBufferToShaderAttribute(CarModel.wheel2Normals, program, "vertexNormal"); Gl.BindBufferToShaderAttribute(CarModel.wheel3, program, "vertexPosition"); Gl.DrawElements(BeginMode.TriangleStrip, CarModel.wheel1Quads.Count, DrawElementsType.UnsignedInt, IntPtr.Zero); Gl.BindBufferToShaderAttribute(CarModel.wheel4, program, "vertexPosition"); Gl.DrawElements(BeginMode.TriangleStrip, CarModel.wheel1Quads.Count, DrawElementsType.UnsignedInt, IntPtr.Zero); //Gl.BindTexture(velgTexture); Gl.BindBufferToShaderAttribute(CarModel.wheel1Normals, program, "vertexNormal"); Gl.BindBufferToShaderAttribute(CarModel.velg1, program, "vertexPosition"); Gl.DrawElements(BeginMode.TriangleFan, CarModel.wheel1Quads.Count, DrawElementsType.UnsignedInt, IntPtr.Zero); Gl.BindBufferToShaderAttribute(CarModel.velg2, program, "vertexPosition"); Gl.DrawElements(BeginMode.TriangleFan, CarModel.wheel1Quads.Count, DrawElementsType.UnsignedInt, IntPtr.Zero); Gl.BindBufferToShaderAttribute(CarModel.wheel2Normals, program, "vertexNormal"); Gl.BindBufferToShaderAttribute(CarModel.velg3, program, "vertexPosition"); Gl.DrawElements(BeginMode.TriangleFan, CarModel.wheel1Quads.Count, DrawElementsType.UnsignedInt, IntPtr.Zero); Gl.BindBufferToShaderAttribute(CarModel.velg4, program, "vertexPosition"); Gl.DrawElements(BeginMode.TriangleFan, CarModel.wheel1Quads.Count, DrawElementsType.UnsignedInt, IntPtr.Zero); Glut.glutSwapBuffers(); }
private void GenerateArrayTexture() { //Generate an array texture // Gl.GenTextures(1, gArrayTexture); textureId = Gl.GenTexture(); Gl.ActiveTexture(TextureUnit.Texture0); Gl.BindTexture(TextureTarget.Texture2DArray, textureId); //Generate an array texture // glGenTextures( 1, &gArrayTexture ); // glActiveTexture(GL_TEXTURE0); // glBindTexture(GL_TEXTURE_2D_ARRAY, gArrayTexture); Size textureSize = new Size(256, 256); Dictionary <Tile.TileIds, Bitmap> tempTiletypeList = RenderObjects.CreateTileBitmaps(new Size(256, 256)); // int numberOfTiles = tempTiles.Count(); int numberOfTextures = tempTiletypeList.Count; // replace glTexStorage3D with following code // https://www.opengl.org/sdk/docs/man/html/glTexStorage3D.xhtml //http://stackoverflow.com/questions/17760193/correct-storage-allocation-for-textures-in-gl-texture-2d-array //No mipmaps as textures are 1x1 int levels = 1; // Specify the number of texture levels int width = textureSize.Width; int height = textureSize.Height; for (int i = 0; i < levels; i++) { Gl.TexImage3D(TextureTarget.Texture2DArray, i, PixelInternalFormat.Rgb8, width, height, numberOfTextures, 0, PixelFormat.Bgra, PixelType.UnsignedByte, IntPtr.Zero); width = Math.Max(1, (width / 2)); height = Math.Max(1, (height / 2)); } //Create storage for the texture. (100 layers of 1x1 texels) // glTexStorage3D( GL_TEXTURE_2D_ARRAY, // 1, //No mipmaps as textures are 1x1 // GL_RGB8, //Internal format // 1, 1, //width,height // 100 //Number of layers // ); for (int i = 0; i != numberOfTextures; ++i) { //Choose a random color for the i-essim image // Gl. // GLubyte color[3] = {rand()%255,rand()%255,rand()%255}; //Specify i-essim image Bitmap tempBmp = tempTiletypeList.Values.ToArray()[i]; Size tempSize = tempBmp.Size; // must be Format32bppArgb file format, so convert it if it isn't in that format BitmapData bitmapData = tempBmp.LockBits(new Rectangle(0, 0, tempSize.Width, tempSize.Height), ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb); Gl.TexSubImage3D(TextureTarget.Texture2DArray, 0, //Mipmap number 0, 0, i, //xoffset, yoffset, zoffset textureSize.Width, textureSize.Height, 1, //width, height, depth PixelFormat.Bgra, //format PixelType.UnsignedByte, //type bitmapData.Scan0 //pointer to data ); tempBmp.UnlockBits(bitmapData); // glTexSubImage3D( GL_TEXTURE_2D_ARRAY, // 0, //Mipmap number // 0,0,i, //xoffset, yoffset, zoffset // 1,1,1, //width, height, depth // GL_RGB, //format // GL_UNSIGNED_BYTE, //type // color); //pointer to data } Gl.TexParameteri(TextureTarget.Texture2DArray, TextureParameterName.TextureMinFilter, TextureParameter.Linear); Gl.TexParameteri(TextureTarget.Texture2DArray, TextureParameterName.TextureMagFilter, TextureParameter.Linear); Gl.TexParameteri(TextureTarget.Texture2DArray, TextureParameterName.TextureWrapS, TextureParameter.ClampToEdge); Gl.TexParameteri(TextureTarget.Texture2DArray, TextureParameterName.TextureWrapT, TextureParameter.ClampToEdge); // glTexParameteri(GL_TEXTURE_2D_ARRAY,GL_TEXTURE_MIN_FILTER,GL_LINEAR); // glTexParameteri(GL_TEXTURE_2D_ARRAY,GL_TEXTURE_MAG_FILTER,GL_LINEAR); // glTexParameteri(GL_TEXTURE_2D_ARRAY,GL_TEXTURE_WRAP_S,GL_CLAMP_TO_EDGE); // glTexParameteri(GL_TEXTURE_2D_ARRAY,GL_TEXTURE_WRAP_T,GL_CLAMP_TO_EDGE); }
internal Texture(uint handle, Vector2I size) : base(handle, tex => Gl.BindTexture(TextureTarget.Texture2d, tex), Gl.DeleteTextures) { Size = size; ContextManager.ContextChange += OnContextChange; }
public void Use() { Gl.ActiveTexture(TextureUnit.Texture0); Gl.BindTexture(TextureTarget.Texture2DArray, TextureID); }
public void DrawImage(GlImage image, float x, float y, float w, float h, float ix, float iy, float iw, float ih) { if (ix < 0) { x += -w * ix / iw; ix = 0; } if (ix + iw > image.Width) { w -= (ix + iw - image.Width) * w / iw; iw = image.Width - ix; } if (iy < 0) { y += -h * iy / ih; iy = 0; } if (iy + ih > image.Height) { h -= (iy + ih - image.Height) * h / ih; ih = image.Height - iy; } Gl.UseProgram(image.ShaderProgram); Gl.ActiveTexture(Gl.GL_TEXTURE0); Gl.BindTexture(Gl.GL_TEXTURE_2D, image.Id); Gl.Uniform1(Gl.GetUniformLocation(image.ShaderProgram, "tex"), 0); var vert = (uint)Gl.GetAttribLocation(image.ShaderProgram, "vert"); var tvert = (uint)Gl.GetAttribLocation(image.ShaderProgram, "vertTexCoord"); var projectionMatrix = new float[16]; Gl.GetFloat(Gl.GL_PROJECTION_MATRIX, projectionMatrix); Gl.UniformMatrix4(Gl.GetUniformLocation(image.ShaderProgram, "projectionMatrix"), 1, false, projectionMatrix); Gl.PolygonMode(Gl.GL_FRONT, Gl.GL_FILL); Gl.Color(Color.Transparent); Gl.Enable(Gl.GL_TEXTURE_2D); Gl.Begin(Gl.GL_QUADS); Gl.VertexAttrib2(vert, x, y); Gl.VertexAttrib2(tvert, ix / image.Width, iy / image.Height); Gl.VertexAttrib2(vert, x, y + h); Gl.VertexAttrib2(tvert, ix / image.Width, (iy + ih) / image.Height); Gl.VertexAttrib2(vert, x + w, y + h); Gl.VertexAttrib2(tvert, (ix + iw) / image.Width, (iy + ih) / image.Height); Gl.VertexAttrib2(vert, x + w, y); Gl.VertexAttrib2(tvert, (ix + iw) / image.Width, iy / image.Height); Gl.End(); Gl.Disable(Gl.GL_TEXTURE_2D); Gl.BindTexture(Gl.GL_TEXTURE_2D, 0); Gl.UseProgram(0); Gl.Flush(); }