emil28092005
a306439f22
- GCHandle.Alloc(Pinned) for BufferData to prevent GC relocation - void* null for VertexAttribPointer offsets - ShouldSwapAutomatically=false, manual SwapBuffers - Solid color debug shader active - Still has rendering issues — needs visual debugging
457 lines
18 KiB
C#
457 lines
18 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Numerics;
|
|
using System.Runtime.InteropServices;
|
|
using Engine.Core;
|
|
using Engine.Core.Components;
|
|
using Engine.Graphics;
|
|
using Flecs.NET.Core;
|
|
using Silk.NET.OpenGL;
|
|
using EngineMaterial = Engine.Core.Components.Material;
|
|
using EngineMesh = Engine.Core.Components.Mesh;
|
|
using EngineTransform = Engine.Core.Components.Transform;
|
|
|
|
namespace Engine.Graphics.OpenGL;
|
|
|
|
public sealed class OpenGLRenderer : IRenderer
|
|
{
|
|
private readonly GL _gl;
|
|
private readonly uint _program;
|
|
private readonly uint _shadowProgram;
|
|
private readonly uint _shadowFbo;
|
|
private readonly uint _shadowTexture;
|
|
private const int ShadowMapSize = 2048;
|
|
|
|
private readonly Dictionary<Entity, GLMesh> _meshCache = new();
|
|
|
|
private readonly int _uMVP, _uModel, _uViewPos, _uMaterialColor, _uRoughness, _uMetallic;
|
|
private readonly int _uAmbient, _uLightCount, _uLightDirs, _uLightIntensities, _uLightColors;
|
|
private readonly int _uLightPositions, _uLightTypes, _uLightRanges;
|
|
private readonly int _uLightViewProj, _uShadowMap, _uUseTexture;
|
|
|
|
private readonly float[] _lightDirs = new float[12];
|
|
private readonly float[] _lightPositions = new float[12];
|
|
private readonly float[] _lightIntensities = new float[4];
|
|
private readonly float[] _lightColors = new float[12];
|
|
private readonly int[] _lightTypes = new int[4];
|
|
private readonly float[] _lightRanges = new float[4];
|
|
private int _lightCount;
|
|
|
|
private int _screenWidth = 1280;
|
|
private int _screenHeight = 720;
|
|
private bool _disposed;
|
|
private readonly float[] _matrixBuffer = new float[16];
|
|
|
|
public OpenGLRenderer(GL gl)
|
|
{
|
|
_gl = gl;
|
|
_gl.Enable(GLEnum.DepthTest);
|
|
|
|
_program = CreateProgram(VertexShaderSource, FragmentShaderSource);
|
|
_shadowProgram = CreateProgram(ShadowVertexSource, ShadowFragmentSource);
|
|
|
|
_uMVP = _gl.GetUniformLocation(_program, "mvp");
|
|
_uModel = _gl.GetUniformLocation(_program, "model");
|
|
_uViewPos = _gl.GetUniformLocation(_program, "viewPos");
|
|
_uMaterialColor = _gl.GetUniformLocation(_program, "materialColor");
|
|
_uRoughness = _gl.GetUniformLocation(_program, "roughness");
|
|
_uMetallic = _gl.GetUniformLocation(_program, "metallic");
|
|
_uAmbient = _gl.GetUniformLocation(_program, "ambientColor");
|
|
_uLightCount = _gl.GetUniformLocation(_program, "lightCount");
|
|
_uLightDirs = _gl.GetUniformLocation(_program, "lightDirs");
|
|
_uLightIntensities = _gl.GetUniformLocation(_program, "lightIntensities");
|
|
_uLightColors = _gl.GetUniformLocation(_program, "lightColors");
|
|
_uLightPositions = _gl.GetUniformLocation(_program, "lightPositions");
|
|
_uLightTypes = _gl.GetUniformLocation(_program, "lightTypes");
|
|
_uLightRanges = _gl.GetUniformLocation(_program, "lightRanges");
|
|
_uLightViewProj = _gl.GetUniformLocation(_program, "lightViewProj");
|
|
_uShadowMap = _gl.GetUniformLocation(_program, "shadowMap");
|
|
_uUseTexture = _gl.GetUniformLocation(_program, "useTexture");
|
|
|
|
// Shadow FBO with depth texture
|
|
_shadowFbo = _gl.GenFramebuffer();
|
|
_gl.BindFramebuffer(GLEnum.Framebuffer, _shadowFbo);
|
|
_shadowTexture = _gl.GenTexture();
|
|
_gl.BindTexture(GLEnum.Texture2D, _shadowTexture);
|
|
unsafe
|
|
{
|
|
_gl.TexImage2D(GLEnum.Texture2D, 0, (int)GLEnum.DepthComponent, (uint)ShadowMapSize, (uint)ShadowMapSize, 0, GLEnum.DepthComponent, GLEnum.Float, null);
|
|
}
|
|
_gl.TexParameter(GLEnum.Texture2D, GLEnum.TextureMinFilter, (int)GLEnum.Nearest);
|
|
_gl.TexParameter(GLEnum.Texture2D, GLEnum.TextureMagFilter, (int)GLEnum.Nearest);
|
|
_gl.TexParameter(GLEnum.Texture2D, GLEnum.TextureWrapS, (int)GLEnum.ClampToEdge);
|
|
_gl.TexParameter(GLEnum.Texture2D, GLEnum.TextureWrapT, (int)GLEnum.ClampToEdge);
|
|
_gl.FramebufferTexture2D(GLEnum.Framebuffer, GLEnum.DepthAttachment, GLEnum.Texture2D, _shadowTexture, 0);
|
|
_gl.DrawBuffer(DrawBufferMode.None);
|
|
_gl.ReadBuffer(ReadBufferMode.None);
|
|
_gl.BindFramebuffer(GLEnum.Framebuffer, 0);
|
|
}
|
|
|
|
public void RequestScreenshot(string outputPath) { }
|
|
public bool IsScreenshotRequested => false;
|
|
public IScreenshotProvider ScreenshotProvider => new OpenGLScreenshotProvider();
|
|
|
|
public void SetScreenSize(int w, int h) { _screenWidth = w; _screenHeight = h; }
|
|
|
|
public void RenderWorld(World world)
|
|
{
|
|
var camera = GetCamera(world);
|
|
CollectLights(world);
|
|
|
|
var hasDirLight = _lightCount > 0 && _lightTypes[0] == (int)LightType.Directional;
|
|
Matrix4x4 lightViewProj = Matrix4x4.Identity;
|
|
|
|
// === PASS 1: Shadow map ===
|
|
if (hasDirLight)
|
|
{
|
|
var lightDir = new Vector3(_lightDirs[0], _lightDirs[1], _lightDirs[2]);
|
|
var sceneCenter = new Vector3(0, 0.5f, 0);
|
|
var lightPos = sceneCenter - lightDir * 30f;
|
|
var up = MathF.Abs(Vector3.Dot(lightDir, Vector3.UnitY)) > 0.99f ? Vector3.UnitZ : Vector3.UnitY;
|
|
|
|
lightViewProj = Matrix4x4.CreateOrthographicOffCenter(-15, 15, -15, 15, 1, 80)
|
|
* Matrix4x4.CreateLookAt(lightPos, sceneCenter, up);
|
|
|
|
_gl.Viewport(0, 0, (uint)ShadowMapSize, (uint)ShadowMapSize);
|
|
_gl.BindFramebuffer(GLEnum.Framebuffer, _shadowFbo);
|
|
_gl.Clear((uint)GLEnum.DepthBufferBit);
|
|
_gl.UseProgram(_shadowProgram);
|
|
_gl.CullFace(GLEnum.Front);
|
|
|
|
var shadowMvpLoc = _gl.GetUniformLocation(_shadowProgram, "mvp");
|
|
|
|
world.Each((Entity e, ref EngineMesh mesh, ref EngineTransform transform) =>
|
|
{
|
|
if (e.Name() == "Grid" || e.Name() == "Floor") return;
|
|
var glMesh = GetOrUploadMesh(e, mesh);
|
|
var model = transform.GetMatrix();
|
|
var mvp = lightViewProj * model;
|
|
CopyMatrixToBuffer(mvp);
|
|
unsafe
|
|
{
|
|
fixed (float* p = _matrixBuffer)
|
|
_gl.UniformMatrix4(shadowMvpLoc, 1, false, p);
|
|
}
|
|
DrawMeshImmediate(glMesh);
|
|
});
|
|
|
|
_gl.CullFace(GLEnum.Back);
|
|
_gl.BindFramebuffer(GLEnum.Framebuffer, 0);
|
|
}
|
|
|
|
// === PASS 2: Main render ===
|
|
_gl.Viewport(0, 0, (uint)_screenWidth, (uint)_screenHeight);
|
|
_gl.Enable(GLEnum.DepthTest);
|
|
_gl.Disable(GLEnum.CullFace);
|
|
_gl.ClearColor(0.098f, 0.118f, 0.157f, 1);
|
|
_gl.Clear((uint)(GLEnum.ColorBufferBit | GLEnum.DepthBufferBit));
|
|
_gl.UseProgram(_program);
|
|
|
|
var view = Matrix4x4.CreateLookAt(camera.Position, camera.Target, camera.Up);
|
|
var proj = Matrix4x4.CreatePerspectiveFieldOfView(camera.FieldOfView, camera.AspectRatio, camera.NearPlane, camera.FarPlane);
|
|
|
|
// Frame uniforms
|
|
_gl.Uniform3(_uViewPos, camera.Position.X, camera.Position.Y, camera.Position.Z);
|
|
_gl.Uniform3(_uAmbient, 0.35f, 0.35f, 0.4f);
|
|
_gl.Uniform1(_uLightCount, _lightCount);
|
|
unsafe
|
|
{
|
|
fixed (float* p = _lightDirs) _gl.Uniform3(_uLightDirs, 4, p);
|
|
fixed (float* p = _lightIntensities) _gl.Uniform1(_uLightIntensities, 4, p);
|
|
fixed (float* p = _lightColors) _gl.Uniform3(_uLightColors, 4, p);
|
|
fixed (float* p = _lightPositions) _gl.Uniform3(_uLightPositions, 4, p);
|
|
fixed (int* p = _lightTypes) _gl.Uniform1(_uLightTypes, 4, p);
|
|
fixed (float* p = _lightRanges) _gl.Uniform1(_uLightRanges, 4, p);
|
|
}
|
|
|
|
if (hasDirLight)
|
|
{
|
|
CopyMatrixToBuffer(lightViewProj);
|
|
unsafe
|
|
{
|
|
fixed (float* p = _matrixBuffer)
|
|
_gl.UniformMatrix4(_uLightViewProj, 1, false, p);
|
|
}
|
|
_gl.ActiveTexture(GLEnum.Texture1);
|
|
_gl.BindTexture(GLEnum.Texture2D, _shadowTexture);
|
|
_gl.Uniform1(_uShadowMap, 1);
|
|
_gl.ActiveTexture(GLEnum.Texture0);
|
|
}
|
|
|
|
world.Each((Entity e, ref EngineMesh mesh, ref EngineTransform transform) =>
|
|
{
|
|
if (e.Name() == "Grid") return;
|
|
var material = e.Has<EngineMaterial>() ? e.Get<EngineMaterial>() : EngineMaterial.Default;
|
|
var glMesh = GetOrUploadMesh(e, mesh);
|
|
var model = transform.GetMatrix();
|
|
var mvp = proj * view * model;
|
|
|
|
CopyMatrixToBuffer(mvp);
|
|
unsafe { fixed (float* pmvp = _matrixBuffer) _gl.UniformMatrix4(_uMVP, 1, false, pmvp); }
|
|
CopyMatrixToBuffer(model);
|
|
unsafe { fixed (float* pmodel = _matrixBuffer) _gl.UniformMatrix4(_uModel, 1, false, pmodel); }
|
|
_gl.Uniform4(_uMaterialColor, material.Albedo.X, material.Albedo.Y, material.Albedo.Z, 1.0f);
|
|
_gl.Uniform1(_uRoughness, material.Roughness);
|
|
_gl.Uniform1(_uMetallic, material.Metallic);
|
|
_gl.Uniform1(_uUseTexture, 0);
|
|
|
|
DrawMeshImmediate(glMesh);
|
|
});
|
|
}
|
|
|
|
private void DrawMeshImmediate(GLMesh mesh)
|
|
{
|
|
_gl.BindVertexArray(mesh.Vao);
|
|
unsafe { _gl.DrawElements(GLEnum.Triangles, (uint)mesh.IndexCount, GLEnum.UnsignedInt, null); }
|
|
_gl.BindVertexArray(0);
|
|
}
|
|
|
|
private GLMesh GetOrUploadMesh(Entity e, EngineMesh mesh)
|
|
{
|
|
if (_meshCache.TryGetValue(e, out var existing))
|
|
return existing;
|
|
|
|
var vao = _gl.GenVertexArray();
|
|
_gl.BindVertexArray(vao);
|
|
|
|
// Position (location 0)
|
|
var positions = new float[mesh.Vertices.Length * 3];
|
|
for (var i = 0; i < mesh.Vertices.Length; i++)
|
|
{
|
|
positions[i * 3] = mesh.Vertices[i].Position.X;
|
|
positions[i * 3 + 1] = mesh.Vertices[i].Position.Y;
|
|
positions[i * 3 + 2] = mesh.Vertices[i].Position.Z;
|
|
}
|
|
var posVbo = _gl.GenBuffer();
|
|
_gl.BindBuffer(GLEnum.ArrayBuffer, posVbo);
|
|
UploadBufferData(positions);
|
|
_gl.EnableVertexAttribArray(0);
|
|
unsafe { _gl.VertexAttribPointer(0, 3, GLEnum.Float, false, 3 * sizeof(float), (void*)0); }
|
|
|
|
// Normal (location 1)
|
|
var normals = new float[mesh.Vertices.Length * 3];
|
|
for (var i = 0; i < mesh.Vertices.Length; i++)
|
|
{
|
|
normals[i * 3] = mesh.Vertices[i].Normal.X;
|
|
normals[i * 3 + 1] = mesh.Vertices[i].Normal.Y;
|
|
normals[i * 3 + 2] = mesh.Vertices[i].Normal.Z;
|
|
}
|
|
var nrmVbo = _gl.GenBuffer();
|
|
_gl.BindBuffer(GLEnum.ArrayBuffer, nrmVbo);
|
|
UploadBufferData(normals);
|
|
_gl.EnableVertexAttribArray(1);
|
|
unsafe { _gl.VertexAttribPointer(1, 3, GLEnum.Float, false, 3 * sizeof(float), (void*)0); }
|
|
|
|
// Color (location 2)
|
|
var colors = new float[mesh.Vertices.Length * 4];
|
|
for (var i = 0; i < mesh.Vertices.Length; i++)
|
|
{
|
|
colors[i * 4] = mesh.Vertices[i].Color.X;
|
|
colors[i * 4 + 1] = mesh.Vertices[i].Color.Y;
|
|
colors[i * 4 + 2] = mesh.Vertices[i].Color.Z;
|
|
colors[i * 4 + 3] = 1.0f;
|
|
}
|
|
var colVbo = _gl.GenBuffer();
|
|
_gl.BindBuffer(GLEnum.ArrayBuffer, colVbo);
|
|
UploadBufferData(colors);
|
|
_gl.EnableVertexAttribArray(2);
|
|
unsafe { _gl.VertexAttribPointer(2, 4, GLEnum.Float, false, 4 * sizeof(float), (void*)0); }
|
|
|
|
// Indices — use pinned GCHandle
|
|
var ebo = _gl.GenBuffer();
|
|
_gl.BindBuffer(GLEnum.ElementArrayBuffer, ebo);
|
|
var indexHandle = System.Runtime.InteropServices.GCHandle.Alloc(mesh.Indices, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
unsafe
|
|
{
|
|
_gl.BufferData(GLEnum.ElementArrayBuffer, (nuint)(mesh.Indices.Length * sizeof(uint)), (void*)indexHandle.AddrOfPinnedObject(), GLEnum.StaticDraw);
|
|
}
|
|
indexHandle.Free();
|
|
|
|
_gl.BindVertexArray(0);
|
|
|
|
var glMesh = new GLMesh(vao, mesh.Indices.Length);
|
|
_meshCache[e] = glMesh;
|
|
return glMesh;
|
|
}
|
|
|
|
private void CollectLights(World world)
|
|
{
|
|
var count = 0;
|
|
world.Each((Entity e, ref Light light) =>
|
|
{
|
|
if (count >= 4) return;
|
|
_lightDirs[count * 3] = light.Direction.X;
|
|
_lightDirs[count * 3 + 1] = light.Direction.Y;
|
|
_lightDirs[count * 3 + 2] = light.Direction.Z;
|
|
_lightPositions[count * 3] = light.Position.X;
|
|
_lightPositions[count * 3 + 1] = light.Position.Y;
|
|
_lightPositions[count * 3 + 2] = light.Position.Z;
|
|
_lightIntensities[count] = light.Intensity;
|
|
_lightColors[count * 3] = light.Color.X;
|
|
_lightColors[count * 3 + 1] = light.Color.Y;
|
|
_lightColors[count * 3 + 2] = light.Color.Z;
|
|
_lightTypes[count] = (int)light.Type;
|
|
_lightRanges[count] = light.Range;
|
|
count++;
|
|
});
|
|
|
|
if (count == 0)
|
|
{
|
|
_lightDirs[0] = 0.5f; _lightDirs[1] = -1; _lightDirs[2] = -0.5f;
|
|
_lightIntensities[0] = 1; _lightColors[0] = 1; _lightColors[1] = 0.95f; _lightColors[2] = 0.8f;
|
|
_lightTypes[0] = (int)LightType.Directional; _lightRanges[0] = 20;
|
|
count = 1;
|
|
}
|
|
for (var i = count; i < 4; i++) { _lightIntensities[i] = 0; _lightTypes[i] = 0; }
|
|
_lightCount = count;
|
|
}
|
|
|
|
private Camera GetCamera(World world)
|
|
{
|
|
var cam = new Camera(new Vector3(0, 0.75f, -30), new Vector3(0, 0.5f, 0), Vector3.UnitY, MathF.PI / 12, 16f / 9f, 0.1f, 100f);
|
|
world.Each((Entity e, ref Camera c) => cam = c);
|
|
return cam;
|
|
}
|
|
|
|
private uint CreateProgram(string vs, string fs)
|
|
{
|
|
var vertex = _gl.CreateShader(GLEnum.VertexShader);
|
|
_gl.ShaderSource(vertex, vs);
|
|
_gl.CompileShader(vertex);
|
|
_gl.GetShader(vertex, ShaderParameterName.CompileStatus, out int vStatus);
|
|
if (vStatus == 0) throw new Exception($"VS: {_gl.GetShaderInfoLog(vertex)}");
|
|
|
|
var fragment = _gl.CreateShader(GLEnum.FragmentShader);
|
|
_gl.ShaderSource(fragment, fs);
|
|
_gl.CompileShader(fragment);
|
|
_gl.GetShader(fragment, ShaderParameterName.CompileStatus, out int fStatus);
|
|
if (fStatus == 0) throw new Exception($"FS: {_gl.GetShaderInfoLog(fragment)}");
|
|
|
|
var program = _gl.CreateProgram();
|
|
_gl.AttachShader(program, vertex);
|
|
_gl.AttachShader(program, fragment);
|
|
_gl.LinkProgram(program);
|
|
_gl.GetProgram(program, ProgramPropertyARB.LinkStatus, out int lStatus);
|
|
if (lStatus == 0) throw new Exception($"Link: {_gl.GetProgramInfoLog(program)}");
|
|
|
|
_gl.DeleteShader(vertex);
|
|
_gl.DeleteShader(fragment);
|
|
return program;
|
|
}
|
|
|
|
private unsafe void UploadBufferData(float[] data)
|
|
{
|
|
var handle = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
|
|
try
|
|
{
|
|
_gl.BufferData(GLEnum.ArrayBuffer, (nuint)(data.Length * sizeof(float)), (void*)handle.AddrOfPinnedObject(), GLEnum.StaticDraw);
|
|
}
|
|
finally
|
|
{
|
|
handle.Free();
|
|
}
|
|
}
|
|
|
|
private void CopyMatrixToBuffer(Matrix4x4 m)
|
|
{
|
|
// OpenGL expects column-major; System.Numerics is row-major, so transpose during copy
|
|
_matrixBuffer[0] = m.M11; _matrixBuffer[1] = m.M21; _matrixBuffer[2] = m.M31; _matrixBuffer[3] = m.M41;
|
|
_matrixBuffer[4] = m.M12; _matrixBuffer[5] = m.M22; _matrixBuffer[6] = m.M32; _matrixBuffer[7] = m.M42;
|
|
_matrixBuffer[8] = m.M13; _matrixBuffer[9] = m.M23; _matrixBuffer[10] = m.M33; _matrixBuffer[11] = m.M43;
|
|
_matrixBuffer[12] = m.M14; _matrixBuffer[13] = m.M24; _matrixBuffer[14] = m.M34; _matrixBuffer[15] = m.M44;
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
if (_disposed) return;
|
|
_disposed = true;
|
|
foreach (var m in _meshCache.Values) _gl.DeleteVertexArray(m.Vao);
|
|
_meshCache.Clear();
|
|
_gl.DeleteProgram(_program);
|
|
_gl.DeleteProgram(_shadowProgram);
|
|
_gl.DeleteFramebuffer(_shadowFbo);
|
|
_gl.DeleteTexture(_shadowTexture);
|
|
}
|
|
|
|
private const string ShadowVertexSource = @"#version 330 core
|
|
layout(location=0) in vec3 aPos;
|
|
uniform mat4 mvp;
|
|
void main(){gl_Position=mvp*vec4(aPos,1.0);}";
|
|
private const string ShadowFragmentSource = @"#version 330 core
|
|
void main(){}";
|
|
|
|
private const string VertexShaderSource = @"#version 330 core
|
|
layout(location=0) in vec3 aPos;
|
|
layout(location=1) in vec3 aNormal;
|
|
layout(location=2) in vec4 aColor;
|
|
uniform mat4 mvp;
|
|
uniform mat4 model;
|
|
out vec3 vNormal;
|
|
out vec3 vWorldPos;
|
|
out vec4 vColor;
|
|
void main(){
|
|
vec4 wp=model*vec4(aPos,1.0);
|
|
vWorldPos=wp.xyz;
|
|
vNormal=mat3(transpose(inverse(model)))*aNormal;
|
|
vColor=aColor;
|
|
gl_Position=mvp*vec4(aPos,1.0);
|
|
}";
|
|
|
|
private const string FragmentShaderSource = @"#version 330 core
|
|
in vec3 vNormal;
|
|
in vec3 vWorldPos;
|
|
in vec4 vColor;
|
|
out vec4 finalColor;
|
|
uniform vec4 materialColor;
|
|
uniform float roughness;
|
|
uniform float metallic;
|
|
uniform vec3 viewPos;
|
|
uniform vec3 ambientColor;
|
|
uniform int lightCount;
|
|
uniform vec3 lightDirs[4];
|
|
uniform vec3 lightPositions[4];
|
|
uniform float lightIntensities[4];
|
|
uniform vec3 lightColors[4];
|
|
uniform int lightTypes[4];
|
|
uniform float lightRanges[4];
|
|
uniform mat4 lightViewProj;
|
|
uniform sampler2D shadowMap;
|
|
uniform int useTexture;
|
|
|
|
vec3 ACESFilm(vec3 x){
|
|
const float a=2.51,b=0.03,c=2.43,d=0.59,e=0.14;
|
|
return clamp((x*(a*x+b))/(x*(c*x+d)+e),0.0,1.0);
|
|
}
|
|
float Attenuation(float dist,float range){
|
|
float r=max(range,0.001),d=max(dist,0.001);
|
|
float x=d/r,x2=x*x,x4=x2*x2;
|
|
return clamp(1.0/(1.0+25.0*x4),0.0,1.0)*smoothstep(1.0,0.0,x);
|
|
}
|
|
float CalculateShadow(vec3 worldPos){
|
|
vec4 lp=lightViewProj*vec4(worldPos,1.0);
|
|
vec3 ndc=lp.xyz/lp.w;
|
|
vec3 uvw=ndc*0.5+0.5;
|
|
if(uvw.x<0.0||uvw.x>1.0||uvw.y<0.0||uvw.y>1.0||uvw.z>1.0) return 1.0;
|
|
float bias=0.005;
|
|
vec2 ts=vec2(1.0/2048.0);
|
|
float s=0.0;
|
|
for(int x=-1;x<=1;x++){
|
|
for(int y=-1;y<=1;y++){
|
|
float d=texture(shadowMap,uvw.xy+vec2(x,y)*ts).r;
|
|
s+=(uvw.z-bias>d)?0.3:1.0;
|
|
}
|
|
}
|
|
return s/9.0;
|
|
}
|
|
void main(){
|
|
finalColor=vec4(0.5,0.3,0.1,1.0);
|
|
}";
|
|
|
|
private readonly record struct GLMesh(uint Vao, int IndexCount);
|
|
|
|
private sealed class OpenGLScreenshotProvider : IScreenshotProvider
|
|
{
|
|
public Task<byte[]> CaptureAsync(string outputPath) => Task.FromResult(Array.Empty<byte>());
|
|
}
|
|
}
|