using System; using System.Numerics; System.Console.WriteLine("Goog"); MainProgram.Run(); // ===================================================== // Texture2D // ===================================================== public class Texture2D { public int Width; public int Height; public byte[] Data; public Texture2D(int width, int height) { Width = width; Height = height; Data = new byte[width * height * 4]; } public void SetPixel(int x, int y, float r, float g, float b, float a) { if (x < 0 || x >= Width || y < 0 || y >= Height) return; int index = (y * Width + x) * 4; Data[index + 0] = (byte)(Math.Clamp(r, 0f, 1f) * 255f); Data[index + 1] = (byte)(Math.Clamp(g, 0f, 1f) * 255f); Data[index + 2] = (byte)(Math.Clamp(b, 0f, 1f) * 255f); Data[index + 3] = (byte)(Math.Clamp(a, 0f, 1f) * 255f); } } // ===================================================== // FrameBuffer // ===================================================== public class FrameBuffer { public int Width; public int Height; public Texture2D ColorTexture; public float[] DepthBuffer; public FrameBuffer(int width, int height) { Width = width; Height = height; ColorTexture = new Texture2D(width, height); DepthBuffer = new float[width * height]; } public void Clear(float r, float g, float b, float a) { for (int y = 0; y < Height; y++) { for (int x = 0; x < Width; x++) { ColorTexture.SetPixel(x, y, r, g, b, a); DepthBuffer[y * Width + x] = 1f; } } } public void SetDepth(int x, int y, float depth) { if (x < 0 || x >= Width || y < 0 || y >= Height) return; DepthBuffer[y * Width + x] = depth; } public float GetDepth(int x, int y) { return DepthBuffer[y * Width + x]; } } // ===================================================== // Shader // ===================================================== public struct VertexInput { public Vector3 Position; public Vector3 Normal; } public struct VertexOutput { public Vector4 Position; public Vector3 Normal; public Vector3 WorldPosition; } public struct FragmentOutput { public Vector4 Color; public float Depth; } public class Shader { public Func VertexShader; public Func FragmentShader; } // ===================================================== // Mesh // ===================================================== public class Mesh { public Vector3[] Positions; public Vector3[] Normals; public int[] Indices; } // ===================================================== // Renderer // ===================================================== public static class Renderer { public static FrameBuffer Framebuffer; public static Shader CurrentShader; public static Matrix4x4 View; public static Matrix4x4 Projection; public static void Initialize(int width, int height) { Framebuffer = new FrameBuffer(width, height); } public static void DrawMesh(Mesh mesh, Matrix4x4 model) { Matrix4x4 mvp = model * View * Projection; for (int i = 0; i < mesh.Indices.Length; i += 3) { DrawTriangle( mesh, mesh.Indices[i + 0], mesh.Indices[i + 1], mesh.Indices[i + 2], model, mvp ); } } static void DrawTriangle( Mesh mesh, int i0, int i1, int i2, Matrix4x4 model, Matrix4x4 mvp) { VertexOutput v0 = ProcessVertex(mesh, i0, model, mvp); VertexOutput v1 = ProcessVertex(mesh, i1, model, mvp); VertexOutput v2 = ProcessVertex(mesh, i2, model, mvp); RasterizeTriangle(v0, v1, v2); } static VertexOutput ProcessVertex( Mesh mesh, int index, Matrix4x4 model, Matrix4x4 mvp) { VertexInput input = new VertexInput { Position = mesh.Positions[index], Normal = mesh.Normals[index] }; VertexOutput output = CurrentShader.VertexShader(input); output.Position = Vector4.Transform( new Vector4(input.Position, 1f), mvp ); return output; } static void RasterizeTriangle( VertexOutput v0, VertexOutput v1, VertexOutput v2) { Vector3 p0 = ToScreen(v0.Position); Vector3 p1 = ToScreen(v1.Position); Vector3 p2 = ToScreen(v2.Position); int minX = (int)MathF.Max(0, MathF.Min(p0.X, MathF.Min(p1.X, p2.X))); int maxX = (int)MathF.Min( Framebuffer.Width - 1, MathF.Max(p0.X, MathF.Max(p1.X, p2.X)) ); int minY = (int)MathF.Max(0, MathF.Min(p0.Y, MathF.Min(p1.Y, p2.Y))); int maxY = (int)MathF.Min( Framebuffer.Height - 1, MathF.Max(p0.Y, MathF.Max(p1.Y, p2.Y)) ); for (int y = minY; y <= maxY; y++) { for (int x = minX; x <= maxX; x++) { Vector3 bary = CalculateBarycentric( x, y, p0, p1, p2 ); if (bary.X < 0 || bary.Y < 0 || bary.Z < 0) continue; float depth = p0.Z * bary.X + p1.Z * bary.Y + p2.Z * bary.Z; if (depth >= Framebuffer.GetDepth(x, y)) continue; Vector3 normal = v0.Normal * bary.X + v1.Normal * bary.Y + v2.Normal * bary.Z; // FIX: interpolate WorldPosition so the fragment shader // receives correct per-pixel world position for shading Vector3 worldPos = v0.WorldPosition * bary.X + v1.WorldPosition * bary.Y + v2.WorldPosition * bary.Z; VertexOutput interpolated = new VertexOutput { Normal = Vector3.Normalize(normal), WorldPosition = worldPos }; FragmentOutput frag = CurrentShader.FragmentShader(interpolated); Framebuffer.ColorTexture.SetPixel( x, y, frag.Color.X, frag.Color.Y, frag.Color.Z, frag.Color.W ); Framebuffer.SetDepth(x, y, depth); } } } static Vector3 ToScreen(Vector4 clip) { float invW = 1f / clip.W; float x = (clip.X * invW * 0.5f + 0.5f) * Framebuffer.Width; float y = (-clip.Y * invW * 0.5f + 0.5f) * Framebuffer.Height; float z = clip.Z * invW; return new Vector3(x, y, z); } static Vector3 CalculateBarycentric( float px, float py, Vector3 a, Vector3 b, Vector3 c) { float denominator = ((b.Y - c.Y) * (a.X - c.X)) + ((c.X - b.X) * (a.Y - c.Y)); float u = ((b.Y - c.Y) * (px - c.X) + (c.X - b.X) * (py - c.Y)) / denominator; float v = ((c.Y - a.Y) * (px - c.X) + (a.X - c.X) * (py - c.Y)) / denominator; float w = 1f - u - v; return new Vector3(u, v, w); } } // ===================================================== // Example Diffuse Shader // ===================================================== public static class DiffuseShader { static Vector3 LightDirection = Vector3.Normalize( new Vector3(0.5f, -0.85f, 0.4f) ); public static Shader Create() { return new Shader { VertexShader = Vertex, FragmentShader = Fragment }; } static VertexOutput Vertex(VertexInput input) { return new VertexOutput { Normal = Vector3.Normalize(input.Normal), WorldPosition = input.Position }; } static FragmentOutput Fragment(VertexOutput input) { float diffuse = MathF.Max( 0, Vector3.Dot(input.Normal, -LightDirection) ); Vector3 baseColor = new Vector3( input.WorldPosition.X * 0.5f + 0.5f, input.WorldPosition.Y * 0.5f + 0.5f, input.WorldPosition.Z * 0.5f + 0.5f ); Vector3 finalColor = (baseColor + new Vector3(diffuse)) * 0.5f; return new FragmentOutput { Color = new Vector4(finalColor, 1f), Depth = 0 }; } } // ===================================================== // Main Codetoy Entry // ===================================================== public static class MainProgram { static Mesh Cube; static Shader Shader; static float Rotation; // FIX: use a small internal resolution to keep per-pixel rect // drawing fast enough to actually render each frame const int RenderWidth = 80; const int RenderHeight = 60; public static void Run() { Renderer.Initialize(RenderWidth, RenderHeight); Cube = GenerateCube(); Shader = DiffuseShader.Create(); Renderer.CurrentShader = Shader; Screen.OnUpdate(Update); } public static void Update() { float dt = (float)Screen.DeltaTime; Rotation += dt; Renderer.Framebuffer.Clear(0, 0, 0, 1); Vector3 cameraPosition = new Vector3(0, 0, -3); Vector3 cameraTarget = Vector3.Zero; Vector3 cameraUp = Vector3.UnitY; Renderer.View = Matrix4x4.CreateLookAt( cameraPosition, cameraTarget, cameraUp ); const float PI = 3.1415927f; Renderer.Projection = Matrix4x4.CreatePerspectiveFieldOfView( PI / 2f, 1f, 0.1f, 100f ); Matrix4x4 model = Matrix4x4.CreateFromYawPitchRoll( Rotation, Rotation, Rotation ); Renderer.DrawMesh(Cube, model); PresentFramebuffer(); } static void PresentFramebuffer() { Canvas.Reset(); Canvas.NoStroke(); // FIX: scale each pixel up to fill the actual screen double scaleX = Screen.Width / RenderWidth; double scaleY = Screen.Height / RenderHeight; for (int y = 0; y < Renderer.Framebuffer.Height; y++) { for (int x = 0; x < Renderer.Framebuffer.Width; x++) { int index = (y * Renderer.Framebuffer.Width + x) * 4; byte r = Renderer.Framebuffer.ColorTexture.Data[index + 0]; byte g = Renderer.Framebuffer.ColorTexture.Data[index + 1]; byte b = Renderer.Framebuffer.ColorTexture.Data[index + 2]; Canvas.Fill(r, g, b, 1); Canvas.Rect(x * scaleX, y * scaleY, scaleX, scaleY); } } } static Mesh GenerateCube() { return new Mesh { Positions = new[] { new Vector3(-1,-1,-1), new Vector3( 1,-1,-1), new Vector3( 1, 1,-1), new Vector3(-1, 1,-1), new Vector3(-1,-1, 1), new Vector3( 1,-1, 1), new Vector3( 1, 1, 1), new Vector3(-1, 1, 1) }, Normals = new[] { Vector3.UnitZ, Vector3.UnitZ, Vector3.UnitZ, Vector3.UnitZ, -Vector3.UnitZ, -Vector3.UnitZ, -Vector3.UnitZ, -Vector3.UnitZ }, Indices = new[] { 0,1,2, 0,2,3, 4,6,5, 4,7,6, 0,4,5, 0,5,1, 2,6,7, 2,7,3, 0,7,4, 0,3,7, 1,5,6, 1,6,2 } }; } }