sln_render_gl.cpp
idea/sleela-native/sln_render_gl.cpp · 247 line(s) · c
/*
* idea/sleela-native/sln_render_gl.cpp
* Sleela-Native -- OpenGL renderer: lit physical model, moving light, vignette.
*
* Idea System(TM) / Idea(TM). From Author; distributive.
* Clean-room original, including all GLSL. SPDX-License-Identifier: MIT.
*
* NOT compiled/verified in the headless sandbox (no GL). Written to the
* OpenGL 3.3 core profile against our own loader (sln_gl_loader).
*/
#include "sln_render_gl.h"
#include "sln_gl_loader.h"
#include <cstdio>
#include <vector>
/* GL enum constants we use (from the spec; stable values). */
#define GL_FRAGMENT_SHADER 0x8B30
#define GL_VERTEX_SHADER 0x8B31
#define GL_COMPILE_STATUS 0x8B81
#define GL_ARRAY_BUFFER 0x8892
#define GL_ELEMENT_ARRAY_BUFFER 0x8893
#define GL_STATIC_DRAW 0x88E4
#define GL_FLOAT 0x1406
#define GL_FALSE 0
#define GL_TRIANGLES 0x0004
#define GL_UNSIGNED_INT 0x1405
#define GL_COLOR_BUFFER_BIT 0x00004000
#define GL_DEPTH_BUFFER_BIT 0x00000100
#define GL_DEPTH_TEST 0x0B71
#define GL_TEXTURE_2D 0x0DE1
#define GL_TEXTURE0 0x84C0
#define GL_FRAMEBUFFER 0x8D40
#define GL_COLOR_ATTACHMENT0 0x8CE0
#define GL_RGBA 0x1908
#define GL_UNSIGNED_BYTE 0x1401
#define GL_TEXTURE_MIN_FILTER 0x2801
#define GL_TEXTURE_MAG_FILTER 0x2800
#define GL_LINEAR 0x2601
namespace sln {
/* ---- original GLSL -------------------------------------------------- */
static const char *kModelVert =
"#version 330 core\n"
"layout(location=0) in vec3 aPos;\n"
"layout(location=1) in vec3 aNormal;\n"
"layout(location=2) in vec3 aColor;\n"
"uniform mat4 uModel; uniform mat4 uView; uniform mat4 uProj;\n"
"out vec3 vN; out vec3 vWorld; out vec3 vColor;\n"
"void main(){\n"
" vec4 w = uModel * vec4(aPos,1.0);\n"
" vWorld = w.xyz;\n"
" vN = mat3(uModel) * aNormal;\n"
" vColor = aColor;\n"
" gl_Position = uProj * uView * w;\n"
"}\n";
static const char *kModelFrag =
"#version 330 core\n"
"in vec3 vN; in vec3 vWorld; in vec3 vColor;\n"
"uniform vec3 uLightPos; uniform vec3 uLightColor; uniform float uLightI;\n"
"uniform vec3 uEye;\n"
"out vec4 o;\n"
"void main(){\n"
" vec3 N = normalize(vN);\n"
" vec3 L = normalize(uLightPos - vWorld);\n"
" vec3 V = normalize(uEye - vWorld);\n"
" vec3 R = reflect(-L, N);\n"
" float diff = max(dot(N,L), 0.0);\n"
" float spec = pow(max(dot(R,V),0.0), 24.0) * 0.4;\n"
" float dist = length(uLightPos - vWorld);\n"
" float atten = uLightI / (1.0 + 0.08*dist*dist);\n"
" vec3 ambient = 0.12 * vColor;\n"
" vec3 lit = (vColor*diff + spec) * uLightColor * atten + ambient;\n"
" o = vec4(lit, 1.0);\n"
"}\n";
/* Fullscreen vignette pass: samples the scene texture, darkens the edges. */
static const char *kPostVert =
"#version 330 core\n"
"out vec2 uv;\n"
"void main(){\n"
" vec2 p = vec2((gl_VertexID<<1)&2, gl_VertexID&2);\n"
" uv = p; gl_Position = vec4(p*2.0-1.0, 0.0, 1.0);\n"
"}\n";
static const char *kPostFrag =
"#version 330 core\n"
"in vec2 uv; out vec4 o;\n"
"uniform sampler2D uScene;\n"
"uniform float uRadius; uniform float uSoftness; uniform float uStrength;\n"
"void main(){\n"
" vec3 c = texture(uScene, uv).rgb;\n"
" vec2 d = uv - vec2(0.5);\n"
" float r = length(d) * 1.41421356;\n" /* 0 center .. 1 corner */
" float v = smoothstep(uRadius, uRadius - uSoftness, r);\n"
" float vig = mix(1.0 - uStrength, 1.0, v);\n"
" o = vec4(c * vig, 1.0);\n"
"}\n";
struct GlRenderer::Impl {
SlnGL gl{};
bool ok = false;
GLuint modelProg = 0, postProg = 0;
GLuint vao = 0, vbo = 0, ebo = 0, emptyVao = 0;
GLuint fbo = 0, sceneTex = 0;
int icount = 0;
int w = 0, h = 0;
GLuint compile(GLenum type, const char *src) {
GLuint s = gl.CreateShader(type);
gl.ShaderSource(s, 1, &src, nullptr);
gl.CompileShader(s);
GLint okc = 0; gl.GetShaderiv(s, GL_COMPILE_STATUS, &okc);
if (!okc) {
char log[1024]; gl.GetShaderInfoLog(s, sizeof log, nullptr, log);
std::fprintf(stderr, "sleela-native shader: %s\n", log);
}
return s;
}
GLuint link(const char *vs, const char *fs) {
GLuint v = compile(GL_VERTEX_SHADER, vs), f = compile(GL_FRAGMENT_SHADER, fs);
GLuint p = gl.CreateProgram();
gl.AttachShader(p, v); gl.AttachShader(p, f); gl.LinkProgram(p);
gl.DeleteShader(v); gl.DeleteShader(f);
return p;
}
};
GlRenderer::~GlRenderer() { shutdown(); }
int GlRenderer::init(const Scene &scene, int fb_width, int fb_height) {
impl_ = new Impl();
Impl &I = *impl_;
if (sln_gl_load(&I.gl) != 0) {
std::fprintf(stderr, "sleela-native: failed to load OpenGL entry points\n");
return -1;
}
I.w = fb_width; I.h = fb_height;
I.gl.Enable(GL_DEPTH_TEST);
I.modelProg = I.link(kModelVert, kModelFrag);
I.postProg = I.link(kPostVert, kPostFrag);
/* interleaved VBO: pos(3) normal(3) color(3) */
std::vector<float> buf;
buf.reserve(scene.model.vertices.size() * 9);
for (const auto &v : scene.model.vertices) {
buf.insert(buf.end(), { v.pos.x, v.pos.y, v.pos.z,
v.normal.x, v.normal.y, v.normal.z,
v.color.x, v.color.y, v.color.z });
}
I.icount = (int)scene.model.indices.size();
I.gl.GenVertexArrays(1, &I.vao);
I.gl.BindVertexArray(I.vao);
I.gl.GenBuffers(1, &I.vbo);
I.gl.BindBuffer(GL_ARRAY_BUFFER, I.vbo);
I.gl.BufferData(GL_ARRAY_BUFFER, (GLsizeiptr)(buf.size()*sizeof(float)), buf.data(), GL_STATIC_DRAW);
I.gl.GenBuffers(1, &I.ebo);
I.gl.BindBuffer(GL_ELEMENT_ARRAY_BUFFER, I.ebo);
I.gl.BufferData(GL_ELEMENT_ARRAY_BUFFER,
(GLsizeiptr)(scene.model.indices.size()*sizeof(uint32_t)),
scene.model.indices.data(), GL_STATIC_DRAW);
const GLsizei stride = 9 * sizeof(float);
I.gl.EnableVertexAttribArray(0); I.gl.VertexAttribPointer(0,3,GL_FLOAT,GL_FALSE,stride,(void*)0);
I.gl.EnableVertexAttribArray(1); I.gl.VertexAttribPointer(1,3,GL_FLOAT,GL_FALSE,stride,(void*)(3*sizeof(float)));
I.gl.EnableVertexAttribArray(2); I.gl.VertexAttribPointer(2,3,GL_FLOAT,GL_FALSE,stride,(void*)(6*sizeof(float)));
/* offscreen colour target for the vignette pass */
I.gl.GenTextures(1, &I.sceneTex);
I.gl.BindTexture(GL_TEXTURE_2D, I.sceneTex);
I.gl.TexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, fb_width, fb_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
I.gl.TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
I.gl.TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
I.gl.GenFramebuffers(1, &I.fbo);
I.gl.BindFramebuffer(GL_FRAMEBUFFER, I.fbo);
I.gl.FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, I.sceneTex, 0);
I.gl.BindFramebuffer(GL_FRAMEBUFFER, 0);
I.gl.GenVertexArrays(1, &I.emptyVao);
I.ok = true;
return 0;
}
void GlRenderer::render(const Scene &scene) {
if (!impl_ || !impl_->ok) return;
Impl &I = *impl_;
const float aspect = (I.h > 0) ? (float)I.w / (float)I.h : 1.0f;
Mat4 model = scene.model.transform();
Mat4 view = scene.camera.view();
Mat4 proj = scene.camera.projection(aspect);
Vec3 lp = scene.light.world_position();
Vec3 eye = scene.camera.eye();
/* pass 1: lit model into the offscreen target */
I.gl.BindFramebuffer(GL_FRAMEBUFFER, I.fbo);
I.gl.Viewport(0, 0, I.w, I.h);
I.gl.ClearColor(0.03f, 0.03f, 0.05f, 1.0f);
I.gl.Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
I.gl.UseProgram(I.modelProg);
I.gl.UniformMatrix4fv(I.gl.GetUniformLocation(I.modelProg, "uModel"), 1, GL_FALSE, model.m);
I.gl.UniformMatrix4fv(I.gl.GetUniformLocation(I.modelProg, "uView"), 1, GL_FALSE, view.m);
I.gl.UniformMatrix4fv(I.gl.GetUniformLocation(I.modelProg, "uProj"), 1, GL_FALSE, proj.m);
I.gl.Uniform3f(I.gl.GetUniformLocation(I.modelProg, "uLightPos"), lp.x, lp.y, lp.z);
I.gl.Uniform3f(I.gl.GetUniformLocation(I.modelProg, "uLightColor"),
scene.light.color.x, scene.light.color.y, scene.light.color.z);
I.gl.Uniform1f(I.gl.GetUniformLocation(I.modelProg, "uLightI"), scene.light.intensity);
I.gl.Uniform3f(I.gl.GetUniformLocation(I.modelProg, "uEye"), eye.x, eye.y, eye.z);
I.gl.BindVertexArray(I.vao);
I.gl.DrawElements(GL_TRIANGLES, I.icount, GL_UNSIGNED_INT, (void*)0);
/* pass 2: vignette fullscreen pass to the default framebuffer */
I.gl.BindFramebuffer(GL_FRAMEBUFFER, 0);
I.gl.Viewport(0, 0, I.w, I.h);
I.gl.Clear(GL_COLOR_BUFFER_BIT);
I.gl.UseProgram(I.postProg);
I.gl.ActiveTexture(GL_TEXTURE0);
I.gl.BindTexture(GL_TEXTURE_2D, I.sceneTex);
I.gl.Uniform1i(I.gl.GetUniformLocation(I.postProg, "uScene"), 0);
I.gl.Uniform1f(I.gl.GetUniformLocation(I.postProg, "uRadius"),
scene.vignette.enabled ? scene.vignette.radius : 2.0f);
I.gl.Uniform1f(I.gl.GetUniformLocation(I.postProg, "uSoftness"), scene.vignette.softness);
I.gl.Uniform1f(I.gl.GetUniformLocation(I.postProg, "uStrength"),
scene.vignette.enabled ? scene.vignette.strength : 0.0f);
I.gl.BindVertexArray(I.emptyVao);
I.gl.DrawArrays(GL_TRIANGLES, 0, 3); /* fullscreen triangle */
}
void GlRenderer::resize(int w, int h) {
if (!impl_) return;
impl_->w = w; impl_->h = h;
if (impl_->ok) {
impl_->gl.BindTexture(GL_TEXTURE_2D, impl_->sceneTex);
impl_->gl.TexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
}
}
void GlRenderer::shutdown() {
if (impl_) { delete impl_; impl_ = nullptr; }
}
} // namespace sln