private void SetFaceCulling(NUD.Material material) { bool enabled = true; CullFaceMode cullFaceMode = CullFaceMode.Back; switch (material.cullMode) { case 0x0000: enabled = false; break; case 0x0404: cullFaceMode = CullFaceMode.Front; break; case 0x0405: cullFaceMode = CullFaceMode.Back; break; default: enabled = false; break; } renderSettings.faceCullingSettings = new FaceCullingSettings(enabled, cullFaceMode); }
public static void CullFace(CullFaceMode mode) { Debug.Assert(Delegates.pglCullFace != null, "pglCullFace not implemented"); Delegates.pglCullFace((Int32)mode); CallLog("glCullFace({0})", mode); DebugCheckErrors(); }
public static void CullFace(CullFaceMode mode) { #if USE_OPENGL OpenTK.Graphics.OpenGL.GL.CullFace((OpenTK.Graphics.OpenGL.CullFaceMode)mode); #else OpenTK.Graphics.ES11.GL.CullFace((OpenTK.Graphics.ES11.All)mode); #endif }
public void CullFaceMode(CullFaceMode cullFaceMode) { if (mCullFaceMode == cullFaceMode) { return; } GL.CullFace(mCullFaceMode = cullFaceMode); }
internal static CullMode Convert(CullFaceMode cullMode) { if (!cullModes.ContainsValue(cullMode)) { throw new NotSupportedException("cullMode is not supported"); } return(cullModes.First((f) => f.Value == cullMode).Key); }
public static void CullFace(CullFaceMode mode) { GL.CullFace(mode); if (enableErrorCheck) { LogErrors(); } }
public static void CullFace(CullFaceMode mode) { #if USE_OPENGL if (HardwareAvailable) { OpenTK.Graphics.OpenGL.GL.CullFace((OpenTK.Graphics.OpenGL.CullFaceMode)mode); } #else OpenTK.Graphics.ES11.GL.CullFace((OpenTK.Graphics.ES11.All)mode); #endif }
public GLState(CullFaceMode cullFaceMode, DepthFunction depthFunction, BlendingFactorSrc blendingFactorSrc, BlendingFactorDest blendingFactorDest, params EnableCap[] enableCaps) { CullFaceMode = cullFaceMode; DepthFunction = depthFunction; BlendingFactorSrc = blendingFactorSrc; BlendingFactorDest = blendingFactorDest; EnableCaps = enableCaps; _fullHash = "{" + CullFaceMode + "}{" + DepthFunction + "}{" + BlendingFactorSrc + "}{" + BlendingFactorDest + "}{" + EnableCaps.Aggregate("", (left, cap) => left + cap.ToString()) + "}"; }
public MeshRender(Transform transformParent, Mesh mesh, Shader shader, Texture texture) { _cullType = CullFaceMode.Front; transform = transformParent; _mesh = mesh; _shader = shader; _texture = texture; /*if (_shader != null) * { * _shader.Use(); * }*/ IBO = GL.GenBuffer(); VAO = GL.GenVertexArray(); vbo = GL.GenBuffer(); dbo = GL.GenBuffer(); tbo = GL.GenBuffer(); nbo = GL.GenBuffer(); GL.BindBuffer(BufferTarget.ElementArrayBuffer, IBO); GL.BufferData(BufferTarget.ElementArrayBuffer, _mesh._indices.Length * sizeof(int), _mesh._indices, BufferUsageHint.StaticDraw); GL.BindVertexArray(VAO); GL.BindBuffer(BufferTarget.ArrayBuffer, vbo); GL.BufferData(BufferTarget.ArrayBuffer, _mesh._vertices.Length * Vector3.SizeInBytes, _mesh._vertices, BufferUsageHint.StaticDraw); GL.VertexAttribPointer(0, 3, VertexAttribPointerType.Float, false, 0, 0); GL.EnableVertexAttribArray(0); //Colors GL.BindBuffer(BufferTarget.ArrayBuffer, dbo); GL.BufferData(BufferTarget.ArrayBuffer, _mesh._Colors.Length * sizeof(float), _mesh._Colors, BufferUsageHint.StaticDraw); GL.VertexAttribPointer(1, 4, VertexAttribPointerType.Float, false, 0, 0); GL.EnableVertexAttribArray(1); //Texture GL.BindBuffer(BufferTarget.ArrayBuffer, tbo); GL.BufferData(BufferTarget.ArrayBuffer, _mesh._texCoords.Length * Vector2.SizeInBytes, _mesh._texCoords, BufferUsageHint.StaticDraw); GL.VertexAttribPointer(2, 2, VertexAttribPointerType.Float, false, 0, 0); GL.EnableVertexAttribArray(2); GL.BindBuffer(BufferTarget.ArrayBuffer, nbo); GL.BufferData(BufferTarget.ArrayBuffer, _mesh._Normals.Length * Vector3.SizeInBytes, _mesh._Normals, BufferUsageHint.StaticDraw); GL.VertexAttribPointer(3, 3, VertexAttribPointerType.Float, false, 0, 0); GL.EnableVertexAttribArray(3); TickSystem.AddRenderItemT(this); }
public void setCullFace(CullFaceMode face) { if (face != cullFace) { cullFace = face; if ((face == CullFaceMode.Front) || (face == CullFaceMode.Back) || (face == CullFaceMode.FrontAndBack)) { GL.Enable(EnableCap.CullFace); GL.CullFace(face); } else { GL.Disable(EnableCap.CullFace); } } }
public ChunkCloudRender(Transform transformParent) { isReady = false; _cullType = CullFaceMode.Front; transform = new Transform(); transform.Position = new Vector3(transformParent.Position.X, 50, transformParent.Position.Z); transform.Rotation = new Quaternion(MathHelper.DegreesToRadians(90), 0, 0, 1); transform.Size = new Vector3(10, 10, 1); C_shader = AssetsManager.GetShader("Cloud"); C_texture = AssetsManager.GetTexture("Cloud"); CreteCloudMesh(); if (mesh != null) { if (C_shader != null) { C_shader.Use(); } C_VAO = GL.GenVertexArray(); C_IBO = GL.GenBuffer(); C_vbo = GL.GenBuffer(); C_tbo = GL.GenBuffer(); GL.BindBuffer(BufferTarget.ElementArrayBuffer, C_IBO); GL.BufferData(BufferTarget.ElementArrayBuffer, mesh._indices.Length * sizeof(int), mesh._indices, BufferUsageHint.StaticDraw); GL.BindVertexArray(C_VAO); GL.BindBuffer(BufferTarget.ArrayBuffer, C_vbo); GL.BufferData(BufferTarget.ArrayBuffer, mesh._vertices.Length * Vector3.SizeInBytes, mesh._vertices, BufferUsageHint.StaticDraw); GL.VertexAttribPointer(0, 3, VertexAttribPointerType.Float, false, 0, 0); GL.EnableVertexAttribArray(0); //Texture GL.BindBuffer(BufferTarget.ArrayBuffer, C_tbo); GL.BufferData(BufferTarget.ArrayBuffer, mesh._texCoords.Length * Vector2.SizeInBytes, mesh._texCoords, BufferUsageHint.StaticDraw); GL.VertexAttribPointer(1, 2, VertexAttribPointerType.Float, false, 0, 0); GL.EnableVertexAttribArray(1); TickSystem.AddRenderItem(this); isReady = true; } }
public DemoMesh(Demo demo) { this.demo = demo; Render = new RenderMeshDeferredPNT(); meshVertexBuffer = -1; meshIndexBuffer = -1; meshVertices = null; meshIndices16Bit = null; meshIndices32Bit = null; meshIndicesType = 0; meshCullMode = CullFaceMode.Back; dynamic = false; scaleNormals = false; SetTexture(null); }
/// <summary> /// Merge this state with another one. /// </summary> /// <param name="state"> /// A <see cref="IGraphicsState"/> having the same <see cref="StateIdentifier"/> of this state. /// </param> public override void Merge(IGraphicsState state) { if (state == null) { throw new ArgumentNullException("state"); } CullFaceState otherState = state as CullFaceState; if (otherState == null) { throw new ArgumentException("not a CullFaceState", "state"); } _FrontFaceMode = otherState._FrontFaceMode; _Enabled = otherState._Enabled; _CulledFace = otherState._CulledFace; }
public RenderState(Framebuffer fbuf, ShaderProgram prog, StorageBuffer[] ssboBindings, UniformBuffer[] uboBindings, bool dWrite, bool colorWrite, DepthFunc dTest, float far, float near, BlendFactor src, BlendFactor dst, Vector4 ClearColor, float ClearDepth, CullFaceMode cullMode, IndexBuffer iBuffer = null, Vector4[] viewports = null) { Framebuffer = fbuf; ShaderProgram = prog; DepthWrite = dWrite; ColorWrite = colorWrite; DepthTest = dTest; FarPlane = far; NearPlane = near; Src = src; Dst = dst; this.ClearColor = ClearColor; this.ClearDepth = ClearDepth; CullMode = cullMode; ShaderStorageBufferBindings = ssboBindings; UniformBufferBindings = uboBindings; IndexBuffer = iBuffer; if (viewports == null) { Viewports = new Vector4[] { new Vector4(0, 0, Framebuffer == null ? 0 : Framebuffer.Width, Framebuffer == null ? 0 : Framebuffer.Height) } } ; else { Viewports = viewports; } }
private void SetUpGL() { _cullType = CullFaceMode.Front; IBO = GL.GenBuffer(); VAO = GL.GenVertexArray(); vbo = GL.GenBuffer(); dbo = GL.GenBuffer(); tbo = GL.GenBuffer(); nbo = GL.GenBuffer(); GL.BindBuffer(BufferTarget.ElementArrayBuffer, IBO); GL.BufferData(BufferTarget.ElementArrayBuffer, AssetsManager.GetMesh(_mesh)._indices.Length *sizeof(int), AssetsManager.GetMesh(_mesh)._indices, BufferUsageHint.StaticDraw); GL.BindVertexArray(VAO); GL.BindBuffer(BufferTarget.ArrayBuffer, vbo); GL.BufferData(BufferTarget.ArrayBuffer, AssetsManager.GetMesh(_mesh)._vertices.Length *Vector3.SizeInBytes, AssetsManager.GetMesh(_mesh)._vertices, BufferUsageHint.StaticDraw); GL.VertexAttribPointer(0, 3, VertexAttribPointerType.Float, false, 0, 0); GL.EnableVertexAttribArray(0); //Colors GL.BindBuffer(BufferTarget.ArrayBuffer, dbo); GL.BufferData(BufferTarget.ArrayBuffer, AssetsManager.GetMesh(_mesh)._Colors.Length *sizeof(float), AssetsManager.GetMesh(_mesh)._Colors, BufferUsageHint.StaticDraw); GL.VertexAttribPointer(1, 4, VertexAttribPointerType.Float, false, 0, 0); GL.EnableVertexAttribArray(1); //Texture GL.BindBuffer(BufferTarget.ArrayBuffer, tbo); GL.BufferData(BufferTarget.ArrayBuffer, AssetsManager.GetMesh(_mesh)._texCoords.Length *Vector2.SizeInBytes, AssetsManager.GetMesh(_mesh)._texCoords, BufferUsageHint.StaticDraw); GL.VertexAttribPointer(2, 2, VertexAttribPointerType.Float, false, 0, 0); GL.EnableVertexAttribArray(2); GL.BindBuffer(BufferTarget.ArrayBuffer, nbo); GL.BufferData(BufferTarget.ArrayBuffer, AssetsManager.GetMesh(_mesh)._Normals.Length *Vector3.SizeInBytes, AssetsManager.GetMesh(_mesh)._Normals, BufferUsageHint.StaticDraw); GL.VertexAttribPointer(3, 3, VertexAttribPointerType.Float, false, 0, 0); GL.EnableVertexAttribArray(3); TickSystem.AddRenderItem(this); }
public void SetCullFace(CullFaceMode mode, CullFaceDirection direction) { OpenTK.Graphics.ES20.CullFaceMode mode_ = 0; OpenTK.Graphics.ES20.FrontFaceDirection mode2_ = 0; switch (mode) { case CullFaceMode.Back: mode_ = OpenTK.Graphics.ES20.CullFaceMode.Back; break; } switch (direction) { case CullFaceDirection.Ccw: mode2_ = OpenTK.Graphics.ES20.FrontFaceDirection.Ccw; break; } GL.CullFace(mode_); GL.FrontFace(mode2_); //Debug.Assert(false); __curCullFace = new CullFace(mode, direction); }
public RasterizerStateDesc(RasterizerStateTypes type) { switch (type) { case RasterizerStateTypes.Solid_CullNone: cullMode = CullFaceMode.None; break; case RasterizerStateTypes.Solid_CullCW: cullMode = CullFaceMode.Back; break; case RasterizerStateTypes.Solid_CullCCW: cullMode = CullFaceMode.Front; break; default: Debug.ThrowError("RasterizerStateDesc", "Unsuported RasterizerStateType"); break; } }
public static void FaceCulling(bool enable = true, CullFaceMode cullFaceMode = CullFaceMode.Back, FrontFaceDirection frontFace = FrontFaceDirection.Ccw) { if (enable) { if (!_faceCullingEnabled) { GL.Enable(EnableCap.CullFace); } GL.CullFace(cullFaceMode); GL.FrontFace(frontFace); _faceCullingMode = cullFaceMode; _faceCullingFrontFaceDirection = frontFace; } else if (_faceCullingEnabled) { GL.Disable(EnableCap.CullFace); } _faceCullingEnabled = enable; }
public GraphicsContext(GraphicsDevice Device, Box Viewport) { this.CoreNum = 6; this.Device = Device; this.Viewport = Viewport; this.FrameCount = 0; this.ColorBuffer = null; this.ZBuffer = new float[Viewport.Width * Viewport.Height]; this.Vertices = new ListCore <Vertex>(this.CoreNum); this.Fragments = new ListCore <Fragment>(this.CoreNum); this.Indices = null; this.ClearColor = Colorf.Black; this.FillModeState = FillMode.Solid; this.CullFaceModeState = CullFaceMode.Back; this.FrontFaceModeState = FrontFaceMode.CCW; this.Shader = null; this.VertexBuffer = null; this.IndexBuffer = null; }
/// <summary> /// /// </summary> /// <param name="mode"></param> /// <param name="enableCapacity">Enable() or Disable() this capacity?</param> public CullFaceSwitch(CullFaceMode mode, bool enableCapacity) : base(OpenGL.GL_CULL_FACE, enableCapacity) { this.Init(mode); }
public CullFaceSwitch(CullFaceMode mode) : base(OpenGL.GL_CULL_FACE, true) { this.Init(mode); }
public static Reaction <T> Culling <T> (this Reaction <T> render, CullFaceMode mode = CullFaceMode.Back, FrontFaceDirection frontFace = FrontFaceDirection.Cw) { return(render.Culling(i => Tuple.Create(mode, frontFace))); }
public static void SetCullMode(CullFaceMode cull) { GL.Enable(EnableCap.CullFace); GL.CullFace(cull); }
/// <summary> /// Construct a CullFaceState, specifying front face and enabling culling of the specified faces. /// </summary> /// <param name="frontFace"> /// A <see cref="FrontFaceDirection"/> that specify how front faces are determined. /// </param> /// <param name="culledFace"> /// A <see cref="CullFaceMode"/> that specify which faces are culled. /// </param> public CullFaceState(FrontFaceDirection frontFace, CullFaceMode culledFace) { _FrontFaceMode = frontFace; _Enabled = true; _CulledFace = culledFace; }
public DemoMesh(Demo demo, TriangleMesh triangleMesh, DemoTexture texture, Vector2 textureScale, bool indices, bool indices16Bit, bool flipTriangles, bool flipNormals, bool smoothNormals, CullFaceMode cullMode, bool dynamic, bool scaleNormals) { this.demo = demo; Render = new RenderMeshDeferredPNT(); meshVertexBuffer = -1; meshIndexBuffer = -1; meshVertices = null; meshIndices16Bit = null; meshIndices32Bit = null; meshIndicesType = 0; this.dynamic = dynamic; this.scaleNormals = scaleNormals; SetCullMode(cullMode); SetTexture(texture); if (indices) { triangleMesh.GetMeshVertices(flipNormals, smoothNormals, out meshVertices); CreateVertexBuffer(meshVertices, dynamic); if (indices16Bit) { triangleMesh.GetMesh16BitIndices(flipTriangles, out meshIndices16Bit); CreateIndexBuffer(meshIndices16Bit, false); } else { triangleMesh.GetMesh32BitIndices(flipTriangles, out meshIndices32Bit); CreateIndexBuffer(meshIndices32Bit, false); } } else { triangleMesh.GetMesh(textureScale, flipTriangles, flipNormals, smoothNormals, out meshVertices); CreateVertexBuffer(meshVertices, dynamic); } }
/// <summary> /// Merge this state with another one. /// </summary> /// <param name="state"> /// A <see cref="IGraphicsState"/> having the same <see cref="StateIdentifier"/> of this state. /// </param> public override void Merge(IGraphicsState state) { if (state == null) throw new ArgumentNullException("state"); CullFaceState otherState = state as CullFaceState; if (otherState == null) throw new ArgumentException("not a CullFaceState", "state"); _FrontFaceMode = otherState._FrontFaceMode; _Enabled = otherState._Enabled; _CulledFace = otherState._CulledFace; }
/// <summary> /// Push a FaceCull flag on the engine's stack. /// </summary> /// <param name="mode">FaceCull flag.</param> public void PushCullFaceMode(CullFaceMode mode) { UnsafeNativeMethods.CRhinoDisplayPipeline_PushCullFaceMode(m_ptr, (int)mode); }
/// <summary> /// Construct a CullFaceState, enabling front/back face culling (front face is defaulted to CCW). /// </summary> /// <param name="culledFace"> /// A <see cref="CullFaceMode"/> that specify which faces are culled. /// </param> public CullFaceState(CullFaceMode culledFace) : this(FrontFaceDirection.Ccw, culledFace) { }
public static void CullFace(CullFaceMode mode) { #if USE_OPENGL if (openGlHardwareAvailable) { OpenTK.Graphics.OpenGL.GL.CullFace((OpenTK.Graphics.OpenGL.CullFaceMode)mode); } #else OpenTK.Graphics.ES11.GL.CullFace((OpenTK.Graphics.ES11.All)mode); #endif }
public static void CullMode(CullFaceMode mode) { GL.Enable(EnableCap.CullFace); GL.CullFace(mode); }
private void Init(CullFaceMode mode) { this.Mode = mode; }
public static extern void CullFace( CullFaceMode mode );
public static void glCullFace(CullFaceMode mode) { i_OpenGL1_0.glCullFace(mode); }
public void SetCullMode(CullFaceMode cullMode) { meshCullMode = cullMode; }
public int CreateRenderState(bool enableAlphaBlend = false, bool enableDepthWrite = true, bool enableDepthTest = true, BlendingFactorSrc src = BlendingFactorSrc.Zero, BlendingFactorDest dest = BlendingFactorDest.One, CullFaceMode cullFaceMode = CullFaceMode.Back, bool enableCullFace = true, DepthFunction depthFunction = DepthFunction.Less) { return RenderSystem.CreateRenderState(enableAlphaBlend, enableDepthWrite, enableDepthTest, src, dest, cullFaceMode, enableCullFace, depthFunction); }
public DemoMesh(Demo demo, Shape shape, DemoTexture texture, Vector2 textureScale, bool indices, bool indices16Bit, bool flipTriangles, bool flipNormals, bool smoothNormals, CullFaceMode cullMode, bool dynamic, bool scaleNormals) { this.demo = demo; Render = new RenderMeshDeferredPNT(); meshVertexBuffer = -1; meshIndexBuffer = -1; meshVertices = null; meshIndices16Bit = null; meshIndices32Bit = null; meshIndicesType = 0; this.dynamic = dynamic; this.scaleNormals = scaleNormals; SetCullMode(cullMode); SetTexture(texture); if (indices) { meshVertices = new VertexPositionNormalTexture[shape.VertexCount]; shape.GetMeshVertices(textureScale.X, textureScale.Y, flipNormals, smoothNormals, meshVertices); CreateVertexBuffer(meshVertices, dynamic); if (indices16Bit) { meshIndices16Bit = new ushort[shape.IndexCount]; shape.GetMesh16BitIndices(flipTriangles, meshIndices16Bit); CreateIndexBuffer(meshIndices16Bit, false); } else { meshIndices32Bit = new int[shape.IndexCount]; shape.GetMesh32BitIndices(flipTriangles, meshIndices32Bit); CreateIndexBuffer(meshIndices32Bit, false); } } else { meshVertices = new VertexPositionNormalTexture[shape.TriangleVertexCount]; shape.GetMesh(textureScale.X, textureScale.Y, flipTriangles, flipNormals, smoothNormals, meshVertices); CreateVertexBuffer(meshVertices, dynamic); } }
public ChunkMeshRender(Transform transformParent, Mesh mesh, Shader shader, Texture texture) { isReady = false; _cullType = CullFaceMode.Front; transform = transformParent; _Mesh = new Mesh(mesh); if (_Mesh != null) { _shader = shader; _texture = texture; shader.SetInt("texture0", 0); /*if (_shader != null) * { * _shader.Use(); * }*/ IndiceLength = _Mesh._indices.Length; IBO = GL.GenBuffer(); VAO = GL.GenVertexArray(); vbo = GL.GenBuffer(); dbo = GL.GenBuffer(); tbo = GL.GenBuffer(); nbo = GL.GenBuffer(); GL.BindBuffer(BufferTarget.ElementArrayBuffer, IBO); GL.BufferData(BufferTarget.ElementArrayBuffer, _Mesh._indices.Length * sizeof(int), _Mesh._indices, BufferUsageHint.StreamDraw); GL.BindVertexArray(VAO); //Vertices(Vector3) GL.BindBuffer(BufferTarget.ArrayBuffer, vbo); GL.BufferData(BufferTarget.ArrayBuffer, _Mesh._vertices.Length * Vector3.SizeInBytes, _Mesh._vertices, BufferUsageHint.StreamDraw); GL.VertexAttribPointer(0, 3, VertexAttribPointerType.Float, false, 0, 0); GL.EnableVertexAttribArray(0); //Colors(Vectro4|Color) GL.BindBuffer(BufferTarget.ArrayBuffer, dbo); GL.BufferData(BufferTarget.ArrayBuffer, _Mesh._Colors.Length * Vector4.SizeInBytes, _Mesh._Colors, BufferUsageHint.StreamDraw); GL.VertexAttribPointer(1, 4, VertexAttribPointerType.Float, false, 0, 0); GL.EnableVertexAttribArray(1); //Texture(Vector2) GL.BindBuffer(BufferTarget.ArrayBuffer, tbo); GL.BufferData(BufferTarget.ArrayBuffer, _Mesh._texCoords.Length * Vector2.SizeInBytes, _Mesh._texCoords, BufferUsageHint.StreamDraw); GL.VertexAttribPointer(2, 2, VertexAttribPointerType.Float, false, 0, 0); GL.EnableVertexAttribArray(2); //Mesh Normals(Vector3) GL.BindBuffer(BufferTarget.ArrayBuffer, nbo); GL.BufferData(BufferTarget.ArrayBuffer, _Mesh._Normals.Length * Vector3.SizeInBytes, _Mesh._Normals, BufferUsageHint.StreamDraw); GL.VertexAttribPointer(3, 3, VertexAttribPointerType.Float, false, 0, 0); GL.EnableVertexAttribArray(3); isReady = true; TickSystem.AddRenderItem(this); } }
/// <summary> /// /// </summary> /// <param name="mode"></param> public CullFaceState(CullFaceMode mode) : base(OpenGL.GL_CULL_FACE, true) { this.Init(mode); }
/// <summary> /// /// </summary> /// <param name="mode"></param> /// <param name="enableCapacity">Enable() or Disable() this capacity?</param> public CullFaceState(CullFaceMode mode, bool enableCapacity) : base(OpenGL.GL_CULL_FACE, enableCapacity) { this.Init(mode); }
internal static extern void glCullFace(CullFaceMode mode);
public static void CullFace(CullFaceMode mode) { Instance?.CullFace(mode); }
public static void CullFace(CullFaceMode mode) { glCullFace deleg = BaseGraphicsContext.Current.Loader.Get<glCullFace>(); if (deleg != null) deleg(mode); }