raylib-silk
Fast integration labs
Yes. Absolutely. My previous answer made Silk sound more “2D-ish” than it is.
Silk.NET is essentially access to the graphics APIs. If you're using Silk.NET.OpenGL, you're talking to OpenGL directly, and OpenGL has no meaningful distinction of “2D renderer” versus “3D renderer.”
Ultimately:
3D vertices
↓
Model transform
↓
World transform
↓
View transform
↓
Projection transform
↓
Clip space
↓
Perspective divide
↓
2D screen coordinates + depth
↓
Rasterization
↓
PixelsSo your statement is basically correct:
3D rendering is math that eventually produces 2D fragments.
The GPU gets triangles. Whether those triangles represent a HUD rectangle or a dragon standing 20 metres away is largely a question of matrices, depth testing, shaders, and coordinate systems.
Silk can therefore do all of it
A Novolis Silk renderer could quite reasonably support:
Novolis.Rendering.Silk
│
├─ 2D
│ ├─ sprites
│ ├─ text
│ ├─ shapes
│ └─ UI
│
├─ 3D
│ ├─ meshes
│ ├─ materials
│ ├─ cameras
│ ├─ lights
│ └─ models
│
├─ particles
├─ render targets
├─ post processing
└─ computeA basic difference between 2D and 3D might be little more than this:
var transform =
model *
view *
projection;versus:
var transform =
model *
orthographicProjection;And:
gl.Enable(EnableCap.DepthTest);for the 3D scene, followed by:
gl.Disable(EnableCap.DepthTest);for a HUD.
That's essentially the “layering.”
What Raylib gives you is not 3D capability
Raylib gives you convenience.
This:
BeginMode3D(camera);
DrawModel(model, position, scale, tint);
EndMode3D();hides a substantial pile of:
shader management
VAOs
VBOs
index buffers
texture bindings
uniforms
camera matrices
projection matrices
draw calls
resource lifetime
state changesWith Silk, you can absolutely build the same thing, but you own that abstraction.
That's potentially exactly what you want in Novolis.
Instead of thinking:
Raylib = 3D
Silk = 2DI'd think:
Raylib
= batteries-included rendering API
Silk
= low-level graphics foundationAnd therefore a Novolis architecture could actually become:
Novolis.Rendering
│
┌──────────┴──────────┐
│ │
Render abstractions Assets/math
│
┌─────┴──────┐
│ │
Raylib Silk
backend backendOr, if you find that your Silk implementation becomes sufficiently complete:
Novolis.Rendering.Silk
│
├── Renderer2D
├── Renderer3D
├── SpriteBatch
├── MeshRenderer
├── MaterialRenderer
└── PostProcessorAt that point Raylib becomes the rapid-development backend, while Silk is the backend where you can reach into the machinery and rearrange the gears.
And interestingly, 2D can just be a special case of 3D
You don't technically need separate Renderer2D and Renderer3D concepts at the bottom.
You could have:
renderer.Draw(mesh, material, transform);where a sprite is merely:
Mesh:
quad
Material:
sprite shader + texture
Transform:
XY position
Z = HUD layerThen your FPS HUD really is:
Perspective camera
→ world
Orthographic camera
→ HUDusing the same renderer.
That is probably the cleaner mental model.
The separation into “2D” and “3D” should live mainly in the ergonomic API, not deep inside the graphics architecture.