go/gl01
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

render: deferred shading

Browse Source
This commit is contained in:
Edgaru089
2022-01-22 23:06:41 +08:00
parent dfe0ff8b63
commit d8d7fe8233
9 changed files with 279 additions and 84 deletions
Download Patch File Download Diff File Expand all files Collapse all files

161
internal/render/render_world.go
View File

@ -1,8 +1,6 @@
package render
import (
"unsafe"
"edgaru089.ml/go/gl01/internal/asset"
"edgaru089.ml/go/gl01/internal/io"
"edgaru089.ml/go/gl01/internal/util/itype"
@ -13,17 +11,30 @@ import (
)
var (
ShadowmapSize = itype.Vec2i{3072, 3072} // Size of the shadow mapping
ShadowmapSize = itype.Vec2i{6144, 6144} // Size of the shadow mapping
)
// WorldRenderer holds texture/shader resource and viewport
// information for world rendering.
type WorldRenderer struct {
shader *Shader
texture *Texture
lastDisplaySize itype.Vec2i
depthmapFBO, depthmap uint32
depthmapShader *Shader
depthmap struct {
fbo, tex uint32 // Framebuffer Object and Texture.
shader *Shader // Shader.
}
gbuffer struct {
fbo uint32 // The Framebuffer object.
// Textures. Position/Lightspace Depth; Normal/Specular Intensity; Diffuse Color.
pos, norm, color uint32
depth uint32
shader *Shader // Geometry pass shaders.
}
shader *Shader // Deffered lighting pass shaders
texture *Texture // World texture atlas
}
// The default WorldRenderer.
@ -36,8 +47,11 @@ func (r *WorldRenderer) Init(w *world.World) (err error) {
if err != nil {
return err
}
r.depthmapShader, err = NewShader(asset.WorldShaderShadowmapVert, asset.WorldShaderShadowmapFrag)
r.depthmap.shader, err = NewShader(asset.WorldShaderShadowmapVert, asset.WorldShaderShadowmapFrag)
if err != nil {
return err
}
r.gbuffer.shader, err = NewShader(asset.WorldShaderGeometryVert, asset.WorldShaderGeometryFrag)
if err != nil {
return err
}
@ -45,27 +59,17 @@ func (r *WorldRenderer) Init(w *world.World) (err error) {
asset.InitWorldTextureAtlas()
r.texture = NewTextureRGBA(asset.WorldTextureAtlas.Image)
r.texture.GenerateMipMap()
r.shader.SetUniformTexture("tex", r.texture)
r.gbuffer.shader.SetUniformTexture("tex", r.texture)
r.shader.SetUniformMat4("model", mgl32.Ident4())
r.depthmapShader.SetUniformMat4("model", mgl32.Ident4())
r.depthmap.shader.SetUniformMat4("model", mgl32.Ident4())
r.gbuffer.shader.SetUniformMat4("model", mgl32.Ident4())
// and view and projection uniforms not yet set
gl.BindFragDataLocation(r.shader.Handle(), 0, gl.Str("outputColor\x00"))
// Set the pointers for attributions
vertAttrib := r.shader.GetAttribLocation("vert")
gl.VertexAttribPointer(vertAttrib, 3, gl.FLOAT, false, int32(unsafe.Sizeof(world.Vertex{})), gl.PtrOffset(int(unsafe.Offsetof(world.Vertex{}.World))))
normalAttrib := r.shader.GetAttribLocation("normal")
gl.VertexAttribPointer(normalAttrib, 3, gl.FLOAT, false, int32(unsafe.Sizeof(world.Vertex{})), gl.PtrOffset(int(unsafe.Offsetof(world.Vertex{}.Normal))))
texCoordAttrib := r.shader.GetAttribLocation("vertTexCoord")
gl.VertexAttribPointer(texCoordAttrib, 2, gl.FLOAT, false, int32(unsafe.Sizeof(world.Vertex{})), gl.PtrOffset(int(unsafe.Offsetof(world.Vertex{}.Texture))))
lightAttrib := r.shader.GetAttribLocation("light")
gl.VertexAttribPointer(lightAttrib, 1, gl.FLOAT, false, int32(unsafe.Sizeof(world.Vertex{})), gl.PtrOffset(int(unsafe.Offsetof(world.Vertex{}.Light))))
// generate the depthmap and depthmap FBO
gl.GenFramebuffers(1, &r.depthmapFBO)
gl.GenTextures(1, &r.depthmap)
gl.BindTexture(gl.TEXTURE_2D, r.depthmap)
gl.GenFramebuffers(1, &r.depthmap.fbo)
gl.GenTextures(1, &r.depthmap.tex)
gl.BindTexture(gl.TEXTURE_2D, r.depthmap.tex)
gl.TexImage2D(gl.TEXTURE_2D, 0, gl.DEPTH_COMPONENT, int32(ShadowmapSize[0]), int32(ShadowmapSize[1]), 0, gl.DEPTH_COMPONENT, gl.FLOAT, nil)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST)
@ -74,56 +78,129 @@ func (r *WorldRenderer) Init(w *world.World) (err error) {
borderColor := []float32{1, 1, 1, 1}
gl.TexParameterfv(gl.TEXTURE_2D, gl.TEXTURE_BORDER_COLOR, &borderColor[0])
// attach depth texture as FBO's depth buffer
gl.BindFramebuffer(gl.FRAMEBUFFER, r.depthmapFBO)
gl.FramebufferTexture2D(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.TEXTURE_2D, r.depthmap, 0)
gl.BindFramebuffer(gl.FRAMEBUFFER, r.depthmap.fbo)
gl.FramebufferTexture2D(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.TEXTURE_2D, r.depthmap.tex, 0)
gl.DrawBuffer(gl.NONE)
gl.ReadBuffer(gl.NONE)
// attach the shadowmap to the shader
r.shader.SetUniformTextureHandle("shadowmap", r.depthmap.tex)
// generate G-buffer and friends
gl.GenFramebuffers(1, &r.gbuffer.fbo)
gl.BindFramebuffer(gl.FRAMEBUFFER, r.gbuffer.fbo)
// position
gl.GenTextures(1, &r.gbuffer.pos)
gl.BindTexture(gl.TEXTURE_2D, r.gbuffer.pos)
gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RGBA32F, int32(io.DisplaySize[0]), int32(io.DisplaySize[1]), 0, gl.RGBA, gl.FLOAT, nil)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST)
gl.FramebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, r.gbuffer.pos, 0)
// normal
gl.GenTextures(1, &r.gbuffer.norm)
gl.BindTexture(gl.TEXTURE_2D, r.gbuffer.norm)
gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RGBA16F, int32(io.DisplaySize[0]), int32(io.DisplaySize[1]), 0, gl.RGBA, gl.FLOAT, nil)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST)
gl.FramebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT1, gl.TEXTURE_2D, r.gbuffer.norm, 0)
// diffuse color
gl.GenTextures(1, &r.gbuffer.color)
gl.BindTexture(gl.TEXTURE_2D, r.gbuffer.color)
gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RGBA, int32(io.DisplaySize[0]), int32(io.DisplaySize[1]), 0, gl.RGBA, gl.UNSIGNED_BYTE, nil)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST)
gl.FramebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT2, gl.TEXTURE_2D, r.gbuffer.color, 0)
// depth
gl.GenRenderbuffers(1, &r.gbuffer.depth)
gl.BindRenderbuffer(gl.RENDERBUFFER, r.gbuffer.depth)
gl.RenderbufferStorage(gl.RENDERBUFFER, gl.DEPTH_COMPONENT16, int32(io.DisplaySize[0]), int32(io.DisplaySize[1]))
gl.FramebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.RENDERBUFFER, r.gbuffer.depth)
// tell OpenGL which color attachments we'll use (of this framebuffer)
attachments := [...]uint32{gl.COLOR_ATTACHMENT0, gl.COLOR_ATTACHMENT1, gl.COLOR_ATTACHMENT2}
gl.DrawBuffers(int32(len(attachments)), &attachments[0])
// attach the textures
r.shader.SetUniformTextureHandle("gPos", r.gbuffer.pos)
r.shader.SetUniformTextureHandle("gNorm", r.gbuffer.norm)
r.shader.SetUniformTextureHandle("gColor", r.gbuffer.color)
gl.BindFramebuffer(gl.FRAMEBUFFER, 0)
r.lastDisplaySize = io.DisplaySize
r.shader.SetUniformTextureHandle("shadowmap", r.depthmap)
gl.Enable(gl.CULL_FACE)
gl.Enable(gl.DEPTH_TEST)
gl.DepthFunc(gl.LESS)
initScreenQuad()
return nil
}
// ResizeDisplay resizes the size of the internal buffers dependent on the window size.
// It is called automatically most of the time.
func (r *WorldRenderer) ResizeDisplay(newSize itype.Vec2i) {
}
var sun = [3]float32{0.2, 0.4, 0.3}
func (r *WorldRenderer) Render(world *world.World, view *View) {
// re-generate the G-buffers if the display size changed
if r.lastDisplaySize != io.DisplaySize {
gl.BindTexture(gl.TEXTURE_2D, r.gbuffer.pos)
gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RGBA16F, int32(io.DisplaySize[0]), int32(io.DisplaySize[1]), 0, gl.RGBA, gl.FLOAT, nil)
gl.BindTexture(gl.TEXTURE_2D, r.gbuffer.norm)
gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RGBA16F, int32(io.DisplaySize[0]), int32(io.DisplaySize[1]), 0, gl.RGBA, gl.FLOAT, nil)
gl.BindTexture(gl.TEXTURE_2D, r.gbuffer.color)
gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RGBA, int32(io.DisplaySize[0]), int32(io.DisplaySize[1]), 0, gl.RGBA, gl.UNSIGNED_BYTE, nil)
gl.BindRenderbuffer(gl.RENDERBUFFER, r.gbuffer.norm)
gl.RenderbufferStorage(gl.RENDERBUFFER, gl.DEPTH_COMPONENT16, int32(io.DisplaySize[0]), int32(io.DisplaySize[1]))
r.lastDisplaySize = io.DisplaySize
}
imgui.SliderFloat3("Sun", &sun, -1, 1)
normalSun := itype.Vec3f(sun).Normalize()
gl.Enable(gl.CULL_FACE)
gl.Enable(gl.DEPTH_TEST)
gl.DepthFunc(gl.LESS)
// 1. Render to depth map
gl.Viewport(0, 0, int32(ShadowmapSize[0]), int32(ShadowmapSize[1]))
gl.BindFramebuffer(gl.FRAMEBUFFER, r.depthmapFBO)
gl.BindFramebuffer(gl.FRAMEBUFFER, r.depthmap.fbo)
gl.Clear(gl.DEPTH_BUFFER_BIT)
lightPos := view.EyePos.Add(normalSun.Multiply(20))
lightPos := view.EyePos.Add(normalSun.Multiply(50))
lightView := mgl32.LookAt(lightPos[0], lightPos[1], lightPos[2], view.EyePos[0], view.EyePos[1], view.EyePos[2], 0, 1, 0)
lightProjection := mgl32.Ortho(-50, 50, -50, 50, 1, 50)
lightProjection := mgl32.Ortho(-50, 50, -50, 50, 1, 100)
lightspace := lightProjection.Mul4(lightView)
r.depthmapShader.UseProgram()
r.depthmapShader.SetUniformMat4("lightspace", lightspace)
r.depthmap.shader.UseProgram()
r.depthmap.shader.SetUniformMat4("lightspace", lightspace)
world.Render()
// 2. Geometry pass, render to G-buffer
gl.Viewport(0, 0, int32(r.lastDisplaySize[0]), int32(r.lastDisplaySize[1]))
gl.BindFramebuffer(gl.FRAMEBUFFER, r.gbuffer.fbo)
gl.ClearColor(0, 0, 0, 1)
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
gl.Disable(gl.BLEND)
r.gbuffer.shader.UseProgram()
r.gbuffer.shader.BindTextures()
r.gbuffer.shader.SetUniformMat4("lightspace", lightspace)
r.gbuffer.shader.SetUniformMat4("view", view.View())
r.gbuffer.shader.SetUniformMat4("projection", view.Perspective())
r.gbuffer.shader.SetUniformVec3f("viewPos", view.EyePos)
world.Render()
gl.BindFramebuffer(gl.FRAMEBUFFER, 0)
// 2. Render the scene
gl.Viewport(0, 0, int32(io.DisplaySize[0]), int32(io.DisplaySize[1]))
// 3. Render the actual output with deferred lighting
gl.Clear(gl.DEPTH_BUFFER_BIT)
r.shader.UseProgram()
r.shader.BindTextures()
r.shader.SetUniformMat4("lightspace", lightspace)
r.shader.SetUniformMat4("view", view.View())
r.shader.SetUniformMat4("projection", view.Perspective())
r.shader.SetUniformVec3f("viewPos", view.EyePos)
r.shader.SetUniformVec4f("fogColor", itype.Vec4f{0.6, 0.8, 1.0, 1.0})
r.shader.SetUniformVec3f("sun", normalSun)
world.Render()
r.drawScreenQuad()
}

46
internal/render/render_world_helper.go Normal file
View File

@ -0,0 +1,46 @@
package render
import (
"unsafe"
"github.com/go-gl/gl/all-core/gl"
)
var (
screenQuadVerts = []float32{
-1, -1,
1, -1,
1, 1,
-1, -1,
1, 1,
-1, 1,
}
screenQuadVAO uint32
screenQuadVBO uint32
)
func initScreenQuad() {
gl.GenBuffers(1, &screenQuadVBO)
gl.BindBuffer(gl.ARRAY_BUFFER, screenQuadVBO)
gl.BufferData(gl.ARRAY_BUFFER, int(unsafe.Sizeof(float32(0)))*len(screenQuadVerts), gl.Ptr(screenQuadVerts), gl.STATIC_DRAW)
gl.GenVertexArrays(1, &screenQuadVAO)
gl.BindVertexArray(screenQuadVAO)
gl.VertexAttribPointer(0, 2, gl.FLOAT, false, int32(2*unsafe.Sizeof(float32(0))), gl.PtrOffset(0))
gl.EnableVertexAttribArray(0)
}
// drawScreenQuad draws a Quad covering the entire screen.
//
// Attribute: vert: [ -1.0 --> 1.0]
func (r *WorldRenderer) drawScreenQuad() {
if screenQuadVAO == 0 {
initScreenQuad()
}
gl.Disable(gl.DEPTH_TEST)
gl.Disable(gl.CULL_FACE)
gl.BindVertexArray(screenQuadVAO)
gl.DrawArrays(gl.TRIANGLES, 0, 6)
}