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

render: SSAO

Browse Source
This commit is contained in:
Edgaru089
2022-02-05 19:25:44 +08:00
parent 05a85ac27f
commit 92b0ace7a2
9 changed files with 289 additions and 26 deletions
Download Patch File Download Diff File Expand all files Collapse all files

159
internal/render/render_world.go
View File

@ -1,8 +1,14 @@
package render
import (
"errors"
"math/rand"
"time"
"unsafe"
"edgaru089.ml/go/gl01/internal/asset"
"edgaru089.ml/go/gl01/internal/io"
"edgaru089.ml/go/gl01/internal/util"
"edgaru089.ml/go/gl01/internal/util/itype"
"edgaru089.ml/go/gl01/internal/world"
"github.com/go-gl/gl/all-core/gl"
@ -10,14 +16,22 @@ import (
"github.com/inkyblackness/imgui-go/v4"
)
const (
SSAOSampleCount = 32 // Number of samples in the SSAO pass. Must stay the same with ssao.frag
)
var (
ShadowmapSize = itype.Vec2i{6144, 6144} // Size of the shadow mapping
RandomSize = itype.Vec2i{32, 32} // Size of the random mapping
)
// WorldRenderer holds texture/shader resource and viewport
// information for world rendering.
type WorldRenderer struct {
lastDisplaySize itype.Vec2i
startTime time.Time
texRand uint32 // random texture mapping, RGBA8 (0~1)
// Depth mapping pass
depthmap struct {
@ -29,12 +43,27 @@ type WorldRenderer struct {
gbuffer struct {
fbo uint32 // The Framebuffer object.
// Textures. Position/Lightspace Depth; Normal/Depth; Diffuse Color/Specular Intensity.
// Textures. Position/Depth(View Space); Normal/Lightspace Depth; Diffuse Color/Specular Intensity.
pos, norm, color uint32
depth uint32
depth uint32 // Depth renderbuffer.
shader *Shader // Geometry pass shaders.
}
// Screen-Space Ambient Occlusion (SSAO) pass
ssao struct {
fbo uint32 // Framebuffer
ambient uint32 // Ambient strength output texture [0,1] (Red channel)
uboSamples uint32 // Uniform Buffer Object pointing to the array of samples
shader *Shader // SSAO pass shader
// SSAO blur pass
blur struct {
fbo uint32
output uint32
shader *Shader
}
}
// Deferred lighting pass
lighting struct {
shader *Shader // Deferred lighting pass shaders
@ -47,7 +76,7 @@ type WorldRenderer struct {
// Output pass
output struct {
fbo uint32 // Output framebuffer object.
fbo uint32 // Output framebuffer object, rendering to the output texture.
tex uint32 // Output texture, rendered to the back buffer at the end.
//depth uint32 // Output depth renderbuffer, use gbuffer.depth
shader *Shader // Shader used to copy output.tex to back buffer.
@ -64,23 +93,31 @@ func (r *WorldRenderer) Init(w *world.World) (err error) {
r.depthmap.shader, err = NewShader(asset.WorldShaderShadowmapVert, asset.WorldShaderShadowmapFrag)
if err != nil {
return err
return errors.New("depthmap: " + err.Error())
}
r.gbuffer.shader, err = NewShader(asset.WorldShaderGeometryVert, asset.WorldShaderGeometryFrag)
if err != nil {
return err
return errors.New("gbuffer: " + err.Error())
}
r.ssao.shader, err = NewShader(asset.WorldShaderSSAOVert, asset.WorldShaderSSAOFrag)
if err != nil {
return errors.New("ssao: " + err.Error())
}
r.ssao.blur.shader, err = NewShader(asset.WorldShaderSSAOBlurVert, asset.WorldShaderSSAOBlurFrag)
if err != nil {
return errors.New("ssao_blur: " + err.Error())
}
r.lighting.shader, err = NewShader(asset.WorldShaderLightingVert, asset.WorldShaderLightingFrag)
if err != nil {
return err
return errors.New("lighting: " + err.Error())
}
r.water.shader, err = NewShader(asset.WorldShaderWaterVert, asset.WorldShaderWaterFrag)
if err != nil {
return err
return errors.New("water: " + err.Error())
}
r.output.shader, err = NewShader(asset.WorldShaderOutputVert, asset.WorldShaderOutputFrag)
if err != nil {
return err
return errors.New("output: " + err.Error())
}
asset.InitWorldTextureAtlas()
@ -97,6 +134,23 @@ func (r *WorldRenderer) Init(w *world.World) (err error) {
gl.BindFragDataLocation(r.water.shader.Handle(), 0, gl.Str("outputColor\x00"))
gl.BindFragDataLocation(r.output.shader.Handle(), 0, gl.Str("outputColor\x00"))
// generate random mapping
{
data := make([]uint32, RandomSize[0]*RandomSize[1])
for i := range data {
data[i] = rand.Uint32()
}
gl.GenTextures(1, &r.texRand)
gl.BindTexture(gl.TEXTURE_2D, r.texRand)
gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RGBA, int32(RandomSize[0]), int32(RandomSize[1]), 0, gl.RGBA, gl.UNSIGNED_BYTE, util.Ptr(data))
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.REPEAT)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.REPEAT)
}
r.ssao.shader.SetUniformTextureHandle("rand", r.texRand)
r.ssao.shader.SetUniformVec2f("randSize", RandomSize.ToFloat32())
// generate the depthmap and depthmap FBO
gl.GenFramebuffers(1, &r.depthmap.fbo)
gl.GenTextures(1, &r.depthmap.tex)
@ -126,6 +180,10 @@ func (r *WorldRenderer) Init(w *world.World) (err error) {
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.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_BORDER)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_BORDER)
borderColor = []float32{1, 1, 1, 1}
gl.TexParameterfv(gl.TEXTURE_2D, gl.TEXTURE_BORDER_COLOR, &borderColor[0])
gl.FramebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, r.gbuffer.pos, 0)
// normal
gl.GenTextures(1, &r.gbuffer.norm)
@ -153,6 +211,48 @@ func (r *WorldRenderer) Init(w *world.World) (err error) {
r.lighting.shader.SetUniformTextureHandle("gPos", r.gbuffer.pos)
r.lighting.shader.SetUniformTextureHandle("gNorm", r.gbuffer.norm)
r.lighting.shader.SetUniformTextureHandle("gColor", r.gbuffer.color)
r.ssao.shader.SetUniformTextureHandle("gPos", r.gbuffer.pos)
r.ssao.shader.SetUniformTextureHandle("gNorm", r.gbuffer.norm)
// generate SSAO friends
gl.GenFramebuffers(1, &r.ssao.fbo)
gl.BindFramebuffer(gl.FRAMEBUFFER, r.ssao.fbo)
// ambient strength texture
gl.GenTextures(1, &r.ssao.ambient)
gl.BindTexture(gl.TEXTURE_2D, r.ssao.ambient)
gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RED, int32(io.DisplaySize[0]), int32(io.DisplaySize[1]), 0, gl.RED, 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_ATTACHMENT0, gl.TEXTURE_2D, r.ssao.ambient, 0)
r.ssao.blur.shader.SetUniformTextureHandle("input", r.ssao.ambient)
// uniform buffer object for samples
ssaoSamples := make([]itype.Vec4f, SSAOSampleCount)
for i := range ssaoSamples {
sample := itype.Vec3d{rand.Float64()*2 - 1, rand.Float64()*2 - 1, rand.Float64() + 0.05}
sample = sample.Normalize().Multiply(rand.Float64()).Multiply(rand.Float64())
ssaoSamples[i] = itype.Vec4f{
float32(sample[0]),
float32(sample[1]),
float32(sample[2]),
0,
}
}
gl.GenBuffers(1, &r.ssao.uboSamples)
gl.BindBuffer(gl.UNIFORM_BUFFER, r.ssao.uboSamples)
gl.BufferData(gl.UNIFORM_BUFFER, int(unsafe.Sizeof(float32(0))*4*SSAOSampleCount), util.Ptr(ssaoSamples), gl.STATIC_DRAW)
// bind UBO (onto binding 0 for now)
gl.BindBufferBase(gl.UNIFORM_BUFFER, 0, r.ssao.uboSamples)
gl.UniformBlockBinding(r.ssao.shader.Handle(), gl.GetUniformBlockIndex(r.ssao.shader.Handle(), gl.Str("uboSamples\x00")), 0)
// SSAO blur pass
gl.GenFramebuffers(1, &r.ssao.blur.fbo)
gl.BindFramebuffer(gl.FRAMEBUFFER, r.ssao.blur.fbo)
gl.GenTextures(1, &r.ssao.blur.output)
gl.BindTexture(gl.TEXTURE_2D, r.ssao.blur.output)
gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RED, int32(io.DisplaySize[0]), int32(io.DisplaySize[1]), 0, gl.RED, 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_ATTACHMENT0, gl.TEXTURE_2D, r.ssao.blur.output, 0)
r.lighting.shader.SetUniformTextureHandle("ssaoAmbient", r.ssao.blur.output)
// generate the output texture and friends
gl.GenFramebuffers(1, &r.output.fbo)
@ -171,6 +271,7 @@ func (r *WorldRenderer) Init(w *world.World) (err error) {
gl.BindFramebuffer(gl.FRAMEBUFFER, 0)
r.lastDisplaySize = io.DisplaySize
r.startTime = time.Now()
initScreenQuad()
@ -191,15 +292,19 @@ 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.BindTexture(gl.TEXTURE_2D, r.gbuffer.pos) // G-Buffer, Position
gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RGBA32F, int32(io.DisplaySize[0]), int32(io.DisplaySize[1]), 0, gl.RGBA, gl.FLOAT, nil)
gl.BindTexture(gl.TEXTURE_2D, r.gbuffer.norm) // G-Buffer, Normal
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.BindTexture(gl.TEXTURE_2D, r.gbuffer.color) // G-Buffer, Albedo 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.depth)
gl.BindRenderbuffer(gl.RENDERBUFFER, r.gbuffer.depth) // G-Buffer, Depth (Renderbuffer)
gl.RenderbufferStorage(gl.RENDERBUFFER, gl.DEPTH_COMPONENT16, int32(io.DisplaySize[0]), int32(io.DisplaySize[1]))
gl.BindTexture(gl.TEXTURE_2D, r.output.tex)
gl.BindTexture(gl.TEXTURE_2D, r.ssao.ambient) // SSAO Output Ambient Strength
gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RED, int32(io.DisplaySize[0]), int32(io.DisplaySize[1]), 0, gl.RED, gl.UNSIGNED_BYTE, nil)
gl.BindTexture(gl.TEXTURE_2D, r.ssao.blur.output) // SSAO Blurred Output
gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RED, int32(io.DisplaySize[0]), int32(io.DisplaySize[1]), 0, gl.RED, gl.UNSIGNED_BYTE, nil)
gl.BindTexture(gl.TEXTURE_2D, r.output.tex) // Output Texture
gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RGBA, int32(io.DisplaySize[0]), int32(io.DisplaySize[1]), 0, gl.RGBA, gl.UNSIGNED_BYTE, nil)
r.lastDisplaySize = io.DisplaySize
}
@ -250,7 +355,29 @@ func (r *WorldRenderer) Render(world *world.World, view *View) {
world.Render()
// 3. Render the actual output with deferred lighting
// 3/1. SSAO pass
gl.BindFramebuffer(gl.FRAMEBUFFER, r.ssao.fbo)
gl.ClearColor(1, 1, 1, 1)
gl.Clear(gl.COLOR_BUFFER_BIT)
r.ssao.shader.UseProgram()
r.ssao.shader.BindTextures()
r.ssao.shader.SetUniformMat4("view", view.View())
r.ssao.shader.SetUniformMat4("projection", view.Perspective())
r.ssao.shader.SetUniformVec3f("viewPos", view.EyePos)
r.ssao.shader.SetUniformFloat("time", float32(time.Since(r.startTime).Seconds()))
DrawScreenQuad()
// 3/2. SSAO blur pass (TODO)
gl.BindFramebuffer(gl.FRAMEBUFFER, r.ssao.blur.fbo)
r.ssao.blur.shader.UseProgram()
r.ssao.blur.shader.BindTextures()
r.ssao.blur.shader.SetUniformVec2f("screenSize", r.lastDisplaySize.ToFloat32())
DrawScreenQuad()
// 4. Render the actual output with deferred lighting
gl.BindFramebuffer(gl.FRAMEBUFFER, r.output.fbo)
gl.ClearColor(io.ClearColor[0], io.ClearColor[1], io.ClearColor[2], io.ClearColor[3])
gl.Clear(gl.COLOR_BUFFER_BIT)
@ -264,7 +391,7 @@ func (r *WorldRenderer) Render(world *world.World, view *View) {
DrawScreenQuad()
// 4. Render water
// 5. Render water
gl.Enable(gl.DEPTH_TEST)
gl.DepthFunc(gl.LESS)
gl.Enable(gl.CULL_FACE)