public override void Create() { VAO = new("Cubemap VAO"); VBO = new("Cubemap VBO"); VAO.Bind(); VBO.Bind(BufferTarget.ArrayBuffer); VBO.Data(skyboxVertices, BufferUsageHint.DynamicDraw); var VS = File.ReadAllText("EngineResources/Shaders/Cubemap/cubemap.vert"); var FS = File.ReadAllText("EngineResources/Shaders/Cubemap/cubemap.frag"); var VP = new GLShader(VS, GLShaderType.Vertex); var FP = new GLShader(FS, GLShaderType.Fragment); CubemapShader = new GLShaderProgram() .Label("Cubemap Shader") .Attach(VP) .Attach(FP) .Link(); GL.EnableVertexAttribArray(0); GL.VertexAttribPointer(0, 3, VertexAttribPointerType.Float, false, 3 * sizeof(float), 0); GL.BindVertexArray(0); }
private void DrawInitVertices() { //Console.WriteLine(WGL.wglGetCurrentContext()); _verticesPositionBuffer = GLBuffer.Create(); _verticesNormalBuffer = GLBuffer.Create(); _verticesTexcoordsBuffer = GLBuffer.Create(); _verticesColorsBuffer = GLBuffer.Create(); _verticesWeightsBuffer = GLBuffer.Create(); _shader = new GLShader( typeof(OpenglGpuImpl).Assembly.GetManifestResourceStream("CSPspEmu.Core.Gpu.Impl.Opengl.shader.vert") .ReadAllContentsAsString(), typeof(OpenglGpuImpl).Assembly.GetManifestResourceStream("CSPspEmu.Core.Gpu.Impl.Opengl.shader.frag") .ReadAllContentsAsString() ); Console.WriteLine("###################################"); foreach (var uniform in _shader.Uniforms) { Console.WriteLine(uniform); } foreach (var attribute in _shader.Attributes) { Console.WriteLine(attribute); } Console.WriteLine("###################################"); _shader.BindUniformsAndAttributes(ShaderInfo); }
private static GLShader FragmentShader() { return(GLShader.Create(ShaderType.FragmentShader, () => from f in Shader.Inputs <TerrainFragment> () from u in Shader.Uniforms <Terrain> () from l in Shader.Uniforms <LightingUniforms> () from c in Shader.Uniforms <CascadedShadowUniforms> () let rockColor = FragmentShaders.TextureColor(!u.rockSampler, f.fragTexturePos) let grassColor = FragmentShaders.TextureColor(!u.grassSampler, f.fragTexturePos) let sandColor = FragmentShaders.TextureColor(!u.sandSampler, f.fragTexturePos) let sandBlend = FMath.SmoothStep(2f, 4f, f.height) let flatColor = grassColor.Mix(sandColor, sandBlend) let rockBlend = FMath.SmoothStep(0.8f, 0.9f, f.slope) let terrainColor = rockColor.Mix(flatColor, rockBlend) let diffuseLight = LightingShaders.LightDiffuseIntensity( (!l.directionalLight).direction, (!l.directionalLight).intensity, f.vertexNormal) let ambient = (!l.globalLighting).ambientLightIntensity //let shadow = ShadowShaders.PcfShadowMapFactor (f.fragPositionLightSpace, 0.0015f) //let shadow = ShadowShaders.VarianceShadowMapFactor (new Vec4 (f.vertexPos, 1f)) let shadow = ShadowShaders.CascadedShadowMapFactor(new Vec4(f.vertexPos, 1f), 0.0015f) let litColor = LightingShaders.GlobalLightIntensity(!l.globalLighting, ambient, diffuseLight * shadow, new Vec3(0f), terrainColor, new Vec3(0f)) select new { outputColor = litColor.Mix(!u.skyColor, f.visibility) })); }
public static GLShader GeometryShaderCascaded() { return(GLShader.CreateGeometryShader <PerVertexOut> (3, CascadedShadowUniforms.MapCount, PrimitiveType.Triangles, PrimitiveType.TriangleStrip, () => from p in Shader.Inputs <Primitive> () from u in Shader.Uniforms <Shadows> () from c in Shader.Uniforms <CascadedShadowUniforms> () let viewLight = (!c.viewLightMatrices)[p.gl_InvocationID] select new PerVertexOut[3] { new PerVertexOut() { gl_Position = ShadowShaders.ClampToNearPlane(viewLight * p.gl_in[0].gl_Position), gl_Layer = p.gl_InvocationID }, new PerVertexOut() { gl_Position = ShadowShaders.ClampToNearPlane(viewLight * p.gl_in[1].gl_Position), gl_Layer = p.gl_InvocationID }, new PerVertexOut() { gl_Position = ShadowShaders.ClampToNearPlane(viewLight * p.gl_in[2].gl_Position), gl_Layer = p.gl_InvocationID } } )); }
public GLShaderProgram(GlInterface gl, string vertex_shader_source, string fragment_shader_source) { this.gl = gl; this.GlVersion = gl.ContextInfo.Version; vertex_shader_source = GetShader(false, vertex_shader_source); fragment_shader_source = GetShader(true, fragment_shader_source); vertex_shader = new GLShader(gl, GL_VERTEX_SHADER, vertex_shader_source); fragment_shader = new GLShader(gl, GL_FRAGMENT_SHADER, fragment_shader_source); ProgramId = gl.CreateProgram(); gl.AttachShader(ProgramId, vertex_shader.ShaderId); gl.AttachShader(ProgramId, fragment_shader.ShaderId); gl.LinkProgram(ProgramId); int link_succeeded; gl.GetProgramiv(ProgramId, GL_LINK_STATUS, &link_succeeded); if (link_succeeded == 0) { byte[] buf = new byte[MaxErrorLength]; string log; fixed(byte *pbuf = buf) { gl.GetProgramInfoLog(ProgramId, MaxErrorLength, out int log_length, pbuf); log = Encoding.UTF8.GetString(pbuf, log_length); } throw new InvalidOperationException($"Failed to link program : {log}"); } }
public object RegisterSnapItem(SnapItem Item) { if (Item == null) { return(null); } if (RegisterLocked) { return(null); } if ((Device.RenderKind != RenderKind.SnapBuffer) && (!Entity.Compiling)) { return(null); } if (CurrentSnapItem == null) { OpenGlDevice.CheckError(); CurrentSnapItem = Item; if (!Item.Udated) { Item.Device = Device; Item.ModelMatrix = Device.ModelMatrix; if (Item.PolygonMode != PolygonMode.Point) { Item.PolygonMode = Device.PolygonMode; } Item.Object = Entity.CurrentEntity; //if ((Item.Object != null) && (Item.Object is Entity)) // (Item.Object as Entity).MySnapItem = Item; Item.Udated = true; } else { } if (Tags.Count > 0) { Item.Tag = Tags.Peek(); } StoredSnapItems.Add(Item); GLShader S = Device.Shader; if (Entity.Compiling) { //MeshCreator.SnapItem = Item; //if (MeshCreator.MeshCurrent != null) // MeshCreator.MeshCurrent.ObjectNumber = (int)CurrentObject; } OpenGlDevice.CheckError(); if (Device.Shader == PickingShader) { S.SetVar(CurrentObjectIndex, (int)CurrentObject); } OpenGlDevice.CheckError(); return(Item); } return(null); }
public RGBNormalMaterial(float alpha) { //mAlpha = alpha; // Ignore and set a global alpha mAlpha = 0.5f; mShader = new GLShader(); mShader.init("RGBNormalMaterial", ShaderSource.RGBNormalVertShader, ShaderSource.RGBNormalFragShader); }
protected override void OnCreated() { base.OnCreated(); SaveShader = Shader; EarthTexture.LoadFromFile("earthmap1k.jpg"); Shadow = true; }
protected Shader() { ShaderProgram = GLShaderProgram.Create(GLShader.CreateVertex(VertexShaderSource), GLShader.CreateFragment(FragmentShaderSource), GLShader.CreateGeometry(GeometryShaderSource)); if (ShaderProgram is not null) { InitializeUniforms(); InitializeAttributes(); } }
public XBRShader() { Console.WriteLine("{0}", string.Join("\n", Assembly.GetExecutingAssembly().GetManifestResourceNames())); Shader = new GLShader( GLShaderFilter.DefaultVertexShader, Assembly.GetExecutingAssembly().GetManifestResourceStream("CSPspEmu.Gui.XBR.Shader.Shader_2xBR.frag") .ReadAllContentsAsString() ); Filter = GLShaderFilter.Create(1, 1, Shader); }
public static GLShader WhiteOutput <F> () where F : Fragment { return(GLShader.Create(ShaderType.FragmentShader, () => from f in Shader.Inputs <F> () select new { outputColor = new Vec3(1f) })); }
public static GLShader DirectOutput <F> () where F : Fragment, IFragmentDiffuse { return(GLShader.Create(ShaderType.FragmentShader, () => from f in Shader.Inputs <F> () select new { outputColor = new Vec3(f.fragDiffuse) })); }
private static GLShader FragmentShader() { return(GLShader.Create(ShaderType.FragmentShader, () => from f in Shader.Inputs <SkyboxFragment> () from u in Shader.Uniforms <Skybox> () select new { outputColor = (!u.cubeMap).Texture(f.texturePos)[Coord.x, Coord.y, Coord.z] })); }
private static GLShader DepthFragmentShader() { return(GLShader.Create(ShaderType.FragmentShader, () => from f in Shader.Inputs <Fragment> () select new { depth = f.gl_FragCoord[2] } )); }
private static GLShader VertexShaderCascaded() { return(GLShader.Create(ShaderType.VertexShader, () => from v in Shader.Inputs <EntityVertex> () from u in Shader.Uniforms <Shadows> () select new Fragment() { gl_Position = !u.modelViewMatrix * new Vec4(v.position, 1f) } )); }
/// <summary> /// Returns the location of the uniform variable in the shader. /// </summary> /// <param name="shader"></param> /// <param name="name">The name of the parameter.</param> /// <returns>The location of the uniform variable, or -1.</returns> public static int GetParameterLocationSafe(this GLShader shader, string name) { try { return(shader.GetParameterLocation(name)); } catch (InvalidIdentifierException e) { return(-1); } }
public static GLShader Passthrough <V, F> () where V : struct, IVertex3D where F : Fragment, new () { return(GLShader.Create(ShaderType.VertexShader, () => from v in Shader.Inputs <V> () select new F() { gl_Position = new Vec4(v.position, 1f) })); }
private static GLShader VertexShader() { return(GLShader.Create(ShaderType.VertexShader, () => from v in Shader.Inputs <PositionalVertex> () from u in Shader.Uniforms <Skybox> () select new SkyboxFragment() { gl_Position = !u.perspectiveMatrix * !u.worldMatrix * new Vec4(v.position, 1f), texturePos = v.position + new Vec3(0f, 0.5f, 0f) })); }
private static void unbindVignetteShader() { var shader = _vignetteShader; if (shader == null) { return; } AGSGame.Game.Events.OnScreenResize.Unsubscribe(onVignetteShaderResize); _vignetteShader = null; }
public static GLShader TexturedOutput <F, U> () where F : Fragment, IFragmentTexture <Vec2> where U : TextureUniforms { return(GLShader.Create(ShaderType.FragmentShader, () => from f in Shader.Inputs <F> () from u in Shader.Uniforms <U> () select new { outputColor = (!u.textureMap).Texture(f.fragTexturePos) })); }
/// <summary> /// Sets the parameter and catches any exception if it fails. /// </summary> /// <param name="shader"></param> /// <param name="name"></param> /// <param name="value"></param> public static void SetParameterSafe(this GLShader shader, string name, object value) { try { SetParameter(shader, name, value); } catch (InvalidIdentifierException e) { } catch (InvalidParameterTypeException e) { } }
public static GLShader FragmentShader() { return(GLShader.Create(ShaderType.FragmentShader, () => from f in Shader.Inputs <PanelFragment> () from t in Shader.Uniforms <TextureUniforms> () from u in Shader.Uniforms <MaterialPanels> () let col = (!t.textureMap).Texture(f.fragTexturePos) select new { outputColor = !u.ColorOutput != 0 ? col : new Vec4(col[Coord.x, Coord.x, Coord.x], 1f) })); }
public static GLShader PassthroughTexture <V, F> () where V : struct, IVertex3D, ITextured where F : Fragment, IFragmentTexture <Vec2>, new () { return(GLShader.Create(ShaderType.VertexShader, () => from v in Shader.Inputs <V> () select new F() { gl_Position = new Vec4(v.position, 1f), fragTexturePos = v.texturePos } )); }
private GLShaderProgram _compileProgram(string vertexSource, string fragmentSource, string name = null) { GLShader vertexShader = null; GLShader fragmentShader = null; try { try { vertexShader = new GLShader(this, ShaderType.VertexShader, vertexSource, name == null ? $"{name}-vertex" : null); } catch (ShaderCompilationException e) { throw new ShaderCompilationException( "Failed to compile vertex shader, see inner for details.", e); } try { fragmentShader = new GLShader(this, ShaderType.FragmentShader, fragmentSource, name == null ? $"{name}-fragment" : null); } catch (ShaderCompilationException e) { throw new ShaderCompilationException( "Failed to compile fragment shader, see inner for details.", e); } var program = new GLShaderProgram(this, name); program.Add(vertexShader); program.Add(fragmentShader); try { program.Link(); } catch (ShaderCompilationException e) { program.Delete(); throw new ShaderCompilationException("Failed to link shaders. See inner for details.", e); } return(program); } finally { vertexShader?.Delete(); fragmentShader?.Delete(); } }
public static GLShader TransformedTexture <V, F, U> () where V : struct, IVertex3D, ITextured where F : Fragment, IFragmentTexture <Vec2>, new () where U : TransformUniforms { return(GLShader.Create(ShaderType.VertexShader, () => from v in Shader.Inputs <V> () from u in Shader.Uniforms <U> () select new F() { gl_Position = !u.perspectiveMatrix * !u.modelViewMatrix * new Vec4(v.position, 1f), fragTexturePos = v.texturePos })); }
private static GLShader VarianceFragmentShader() { return(GLShader.Create(ShaderType.FragmentShader, () => from f in Shader.Inputs <Fragment> () let depth = f.gl_FragCoord.Z let dx = FMath.dFdx(depth) let dy = FMath.dFdy(depth) let moment2 = depth * depth + 0.25f * (dx * dx + dy * dy) select new { variance = new Vec2(depth, moment2) } )); }
public Program(string[] vertexSource, string[] fragmentSource) { // Create vertex and frament shaders // Note: they can be disposed after linking to program; resources are freed when deleting the program using (GLShader vObject = new GLShader(ShaderType.VertexShader, vertexSource)) using (GLShader fObject = new GLShader(ShaderType.FragmentShader, fragmentSource)) { // Create program ProgramName = Gl.CreateProgram(); // Attach shaders Gl.AttachShader(ProgramName, vObject.ShaderName); Gl.AttachShader(ProgramName, fObject.ShaderName); // Link program Gl.LinkProgram(ProgramName); // Check linkage status int linked; Gl.GetProgram(ProgramName, ProgramProperty.LinkStatus, out linked); if (linked == 0) { const int logMaxLength = 1024; StringBuilder infolog = new StringBuilder(logMaxLength); int infologLength; Gl.GetProgramInfoLog(ProgramName, 1024, out infologLength, infolog); throw new InvalidOperationException($"unable to link program: {infolog}"); } // Get uniform locations if ((LocationMVP = Gl.GetUniformLocation(ProgramName, "uMVP")) < 0) { throw new InvalidOperationException("no uniform uMVP"); } // Get attributes locations if ((LocationPosition = Gl.GetAttribLocation(ProgramName, "aPosition")) < 0) { throw new InvalidOperationException("no attribute aPosition"); } if ((LocationColor = Gl.GetAttribLocation(ProgramName, "aColor")) < 0) { throw new InvalidOperationException("no attribute aColor"); } } }
private static GLShader FragmentShader() { return(GLShader.Create(ShaderType.FragmentShader, () => from f in Shader.Inputs <GaussianFragment> () from u in Shader.Uniforms <TextureUniforms> () from c in Shader.Constants(new { weights = new float[] { 0.00598f, 0.060626f, 0.241843f, 0.383103f, 0.241843f, 0.060626f, 0.00598f } }) select new { outColor = Enumerable.Range(0, 7).Aggregate(new Vec4(0f), (r, i) => r + (!u.textureMap).Texture(f.fragTexturePos [i]) * c.weights[i]) } )); }
public OpenTK(bool restoreRenderState = true) : base() { m_Vertices = new Vertex[MaxVerts]; m_VertexSize = Marshal.SizeOf(m_Vertices[0]); m_StringCache = new Dictionary<Tuple<String, Font>, TextRenderer>(); m_Graphics = Graphics.FromImage(new Bitmap(1024, 1024, PixelFormat.Format32bppArgb)); m_StringFormat = new StringFormat(StringFormat.GenericTypographic); m_StringFormat.FormatFlags |= StringFormatFlags.MeasureTrailingSpaces; m_RestoreRenderState = restoreRenderState; CreateBuffers (); guiShader = new GLShader (); guiShader.Load ("gui"); }
public LambertianMaterial(float r, float g, float b, float a) { mColor = new OpenTK.Graphics.Color4(r, g, b, a); mShader = new GLShader(); mShader.init("LambertianMaterial", ShaderSource.LambertianVertShader, ShaderSource.LambertianFragShader); lightPositions[0] = new Vector3(0, 3, 0); lightIntensities[0] = new Vector3(5, 5, 5); lightPositions[1] = new Vector3(1, 2, 0); lightIntensities[1] = new Vector3(.5f, .5f, 1); lightPositions[2] = new Vector3(-1, 3, -1); lightIntensities[2] = new Vector3(0, 1f, 0); lightPositions[3] = new Vector3(-1, 2, 1); lightIntensities[3] = new Vector3(1, .5f, .5f); lightPositions[4] = new Vector3(-1, 3, 1); lightIntensities[4] = new Vector3(1, 0, 0); }
public void Add(GLShader shader) { ClearCaches(); switch (shader.Type) { case ShaderType.VertexShader: _vertexShader = shader; break; case ShaderType.FragmentShader: _fragmentShader = shader; break; default: throw new NotImplementedException("Tried to add unsupported shader type!"); } }
protected override void OnLoad(EventArgs e) { //Create the shader Shader = new Shaders.PlaneShader(); //Compile it Shader.Compile(); //Set light direction Shader.SetParameter("LightDir", new Vector3(0, 0.5f, 0.5f)); //Create buffers CreateBuffers(); //Create vertex array object CreateVAO(); GL.Enable(EnableCap.DepthTest); GL.ClearColor(0.0f, 0.0f, 0.0f, 1f); //GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Line); //GL.Enable(EnableCap.CullFace); GL.FrontFace(FrontFaceDirection.Cw); }
/// <summary> /// Creates a shader object that accesses the given shader. /// </summary> /// <param name="Shader"></param> public DynamicShaderObject(GLShader Shader) { this.Shader = Shader; }