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;
}
