484 lines
19 KiB
Go
484 lines
19 KiB
Go
package game
|
|
|
|
import (
|
|
"errors"
|
|
"math/rand"
|
|
"time"
|
|
"unsafe"
|
|
|
|
"edgaru089.ml/go/gl01/internal/asset"
|
|
"edgaru089.ml/go/gl01/internal/igwrap"
|
|
"edgaru089.ml/go/gl01/internal/igwrap/backend"
|
|
"edgaru089.ml/go/gl01/internal/io"
|
|
"edgaru089.ml/go/gl01/internal/render"
|
|
"edgaru089.ml/go/gl01/internal/util"
|
|
"edgaru089.ml/go/gl01/internal/util/itype"
|
|
"github.com/go-gl/gl/all-core/gl"
|
|
"github.com/go-gl/glfw/v3.3/glfw"
|
|
"github.com/go-gl/mathgl/mgl32"
|
|
"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
|
|
)
|
|
|
|
// renderData holds OpenGL state used by the game renderer.
|
|
type renderData struct {
|
|
lastDisplaySize itype.Vec2i
|
|
startTime time.Time
|
|
|
|
texRand uint32 // random texture mapping, RGBA8 (0~1)
|
|
|
|
// Depth mapping pass
|
|
depthmap struct {
|
|
fbo, tex uint32 // Framebuffer Object and Texture.
|
|
shader *render.Shader // Shader.
|
|
}
|
|
|
|
// Geometry pass
|
|
gbuffer struct {
|
|
fbo uint32 // The Framebuffer object.
|
|
|
|
// Textures. Position/Depth(View Space); Normal/Lightspace Depth; Diffuse Color/Specular Intensity.
|
|
pos, norm, color uint32
|
|
depth uint32 // Depth renderbuffer.
|
|
shader *render.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 *render.Shader // SSAO pass shader
|
|
|
|
// SSAO blur pass
|
|
blur struct {
|
|
fbo uint32
|
|
output uint32
|
|
shader *render.Shader
|
|
}
|
|
}
|
|
|
|
// Deferred lighting pass
|
|
lighting struct {
|
|
shader *render.Shader // Deferred lighting pass shaders
|
|
}
|
|
|
|
// Semi-transparent pass
|
|
water struct {
|
|
shader *render.Shader
|
|
}
|
|
|
|
// Output pass
|
|
output struct {
|
|
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 *render.Shader // Shader used to copy output.tex to back buffer.
|
|
}
|
|
|
|
texture *render.Texture // World texture atlas
|
|
}
|
|
|
|
func (g *Game) initRender() (err error) {
|
|
r := &g.render
|
|
|
|
r.depthmap.shader, err = render.NewShader(asset.WorldShaderShadowmapVert, asset.WorldShaderShadowmapFrag)
|
|
if err != nil {
|
|
return errors.New("depthmap: " + err.Error())
|
|
}
|
|
r.gbuffer.shader, err = render.NewShader(asset.WorldShaderGeometryVert, asset.WorldShaderGeometryFrag)
|
|
if err != nil {
|
|
return errors.New("gbuffer: " + err.Error())
|
|
}
|
|
r.ssao.shader, err = render.NewShader(asset.WorldShaderSSAOVert, asset.WorldShaderSSAOFrag)
|
|
if err != nil {
|
|
return errors.New("ssao: " + err.Error())
|
|
}
|
|
r.ssao.blur.shader, err = render.NewShader(asset.WorldShaderSSAOBlurVert, asset.WorldShaderSSAOBlurFrag)
|
|
if err != nil {
|
|
return errors.New("ssao_blur: " + err.Error())
|
|
}
|
|
r.lighting.shader, err = render.NewShader(asset.WorldShaderLightingVert, asset.WorldShaderLightingFrag)
|
|
if err != nil {
|
|
return errors.New("lighting: " + err.Error())
|
|
}
|
|
r.water.shader, err = render.NewShader(asset.WorldShaderWaterVert, asset.WorldShaderWaterFrag)
|
|
if err != nil {
|
|
return errors.New("water: " + err.Error())
|
|
}
|
|
r.output.shader, err = render.NewShader(asset.WorldShaderOutputVert, asset.WorldShaderOutputFrag)
|
|
if err != nil {
|
|
return errors.New("output: " + err.Error())
|
|
}
|
|
|
|
// get the maximum anisotropic filtering level
|
|
var maxaf float32
|
|
gl.GetFloatv(gl.MAX_TEXTURE_MAX_ANISOTROPY, &maxaf)
|
|
|
|
asset.InitWorldTextureAtlas()
|
|
r.texture = render.NewTexture()
|
|
r.texture.UpdatesRGB(asset.WorldTextureAtlas.Image)
|
|
r.texture.GenerateMipMap()
|
|
gl.BindTexture(gl.TEXTURE_2D, r.texture.Handle())
|
|
gl.TexParameterf(gl.TEXTURE_2D, gl.TEXTURE_MAX_ANISOTROPY, maxaf)
|
|
r.gbuffer.shader.SetUniformTexture("tex", r.texture)
|
|
r.water.shader.SetUniformTexture("tex", r.texture)
|
|
igwrap.SetTextureFlag(r.texture.Handle(), igwrap.TextureFlag_Linear, igwrap.TextureFlag_FlipY)
|
|
|
|
r.depthmap.shader.SetUniformMat4("model", mgl32.Ident4())
|
|
r.gbuffer.shader.SetUniformMat4("model", mgl32.Ident4())
|
|
r.water.shader.SetUniformMat4("model", mgl32.Ident4())
|
|
// and view and projection uniforms not yet set
|
|
gl.BindFragDataLocation(r.lighting.shader.Handle(), 0, gl.Str("outputColor\x00"))
|
|
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)
|
|
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)
|
|
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])
|
|
// attach depth texture as FBO's depth buffer
|
|
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.lighting.shader.SetUniformTextureHandle("shadowmap", r.depthmap.tex)
|
|
r.water.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.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)
|
|
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.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)
|
|
r.water.shader.SetUniformTextureHandle("gPos", r.gbuffer.pos)
|
|
|
|
// 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("tex", 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)
|
|
gl.BindFramebuffer(gl.FRAMEBUFFER, r.output.fbo)
|
|
// output
|
|
gl.GenTextures(1, &r.output.tex)
|
|
gl.BindTexture(gl.TEXTURE_2D, r.output.tex)
|
|
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_ATTACHMENT0, gl.TEXTURE_2D, r.output.tex, 0)
|
|
// depth
|
|
gl.FramebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.RENDERBUFFER, r.gbuffer.depth)
|
|
// attach textures
|
|
r.output.shader.SetUniformTextureHandle("tex", r.output.tex)
|
|
|
|
// set the texture flags for ImGUI
|
|
igwrap.SetTextureFlag(r.gbuffer.color, igwrap.TextureFlag_Linear)
|
|
igwrap.SetTextureFlag(r.ssao.ambient, igwrap.TextureFlag_Red)
|
|
|
|
gl.BindFramebuffer(gl.FRAMEBUFFER, 0)
|
|
r.lastDisplaySize = io.DisplaySize
|
|
r.startTime = time.Now()
|
|
|
|
return nil
|
|
}
|
|
|
|
// ResizeDisplay resizes the size of the internal buffers dependent on the window size.
|
|
// It is called automatically most of the time.
|
|
func (g *Game) ResizeDisplay(newSize itype.Vec2i) {
|
|
gl.BindTexture(gl.TEXTURE_2D, g.render.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, g.render.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, g.render.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, g.render.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, g.render.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, g.render.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, g.render.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)
|
|
g.render.lastDisplaySize = newSize
|
|
|
|
}
|
|
|
|
var (
|
|
sun = [3]float32{0.2, 0.4, 0.3}
|
|
alpha = float32(0.55)
|
|
gamma = float32(2.2)
|
|
exposure = float32(1)
|
|
atlasScale = float32(1)
|
|
)
|
|
|
|
// Render, called with a OpenGL context, renders the game.
|
|
func (g *Game) Render(win *glfw.Window) {
|
|
gl.Viewport(0, 0, int32(io.DisplaySize[0]), int32(io.DisplaySize[1]))
|
|
matv, matp := g.view.View(), g.view.Perspective()
|
|
matvp := matp.Mul4(matv)
|
|
|
|
allclock := util.NewClock()
|
|
lastclock := util.NewClock()
|
|
|
|
io.RenderPos = io.ViewPos
|
|
io.RenderDir = io.ViewDir
|
|
|
|
// re-generate the G-buffers if the display size changed
|
|
if g.render.lastDisplaySize != io.DisplaySize {
|
|
g.ResizeDisplay(io.DisplaySize)
|
|
}
|
|
|
|
imgui.SliderFloat3("Sun", &sun, -1, 1)
|
|
normalSun := itype.Vec3f(sun).Normalize()
|
|
imgui.SliderFloat("Water Alpha", &alpha, 0, 1)
|
|
imgui.SliderFloat("Gamma", &gamma, 1.6, 2.8)
|
|
imgui.SliderFloat("Exposure", &exposure, 0, 2)
|
|
|
|
gl.Enable(gl.CULL_FACE)
|
|
gl.Enable(gl.DEPTH_TEST)
|
|
gl.DepthFunc(gl.LESS)
|
|
|
|
lastclock.Restart()
|
|
|
|
// 1. Render to depth map
|
|
gl.Viewport(0, 0, int32(ShadowmapSize[0]), int32(ShadowmapSize[1]))
|
|
gl.BindFramebuffer(gl.FRAMEBUFFER, g.render.depthmap.fbo)
|
|
gl.Clear(gl.DEPTH_BUFFER_BIT)
|
|
|
|
lightPos := g.view.EyePos.Add(normalSun.Multiply(50))
|
|
lightView := mgl32.LookAt(lightPos[0], lightPos[1], lightPos[2], g.view.EyePos[0], g.view.EyePos[1], g.view.EyePos[2], 0, 1, 0)
|
|
lightProjection := mgl32.Ortho(-50, 50, -50, 50, 1, 100)
|
|
lightspace := lightProjection.Mul4(lightView)
|
|
|
|
io.RenderPos = lightPos.ToFloat64()
|
|
io.RenderDir = g.view.EyePos.Add(lightPos.Negative()).ToFloat64()
|
|
|
|
g.render.depthmap.shader.UseProgram()
|
|
g.render.depthmap.shader.SetUniformMat4("lightspace", lightspace)
|
|
|
|
g.world.Render()
|
|
g.world.RenderWater()
|
|
|
|
gl.Flush()
|
|
io.Diagnostics.Times.RenderPasses.Depthmap = lastclock.Restart()
|
|
|
|
// 2. Geometry pass, render to G-buffer
|
|
io.RenderPos = io.ViewPos
|
|
io.RenderDir = io.ViewDir
|
|
|
|
gl.Viewport(0, 0, int32(g.render.lastDisplaySize[0]), int32(g.render.lastDisplaySize[1]))
|
|
gl.BindFramebuffer(gl.FRAMEBUFFER, g.render.gbuffer.fbo)
|
|
gl.ClearColor(0, 0, 0, 1)
|
|
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
|
|
gl.Disable(gl.BLEND)
|
|
|
|
g.render.gbuffer.shader.UseProgram()
|
|
g.render.gbuffer.shader.BindTextures()
|
|
g.render.gbuffer.shader.SetUniformMat4("lightspace", lightspace)
|
|
g.render.gbuffer.shader.SetUniformMat4("view", matv)
|
|
g.render.gbuffer.shader.SetUniformMat4("projection", matp)
|
|
g.render.gbuffer.shader.SetUniformMat4("mvp", matvp)
|
|
g.render.gbuffer.shader.SetUniformVec3f("viewPos", g.view.EyePos)
|
|
|
|
g.world.Render()
|
|
|
|
gl.Flush()
|
|
io.Diagnostics.Times.RenderPasses.Geometry = lastclock.Restart()
|
|
|
|
// 3/1. SSAO pass
|
|
gl.BindFramebuffer(gl.FRAMEBUFFER, g.render.ssao.fbo)
|
|
gl.ClearColor(1, 1, 1, 1)
|
|
gl.Clear(gl.COLOR_BUFFER_BIT)
|
|
|
|
g.render.ssao.shader.UseProgram()
|
|
g.render.ssao.shader.BindTextures()
|
|
g.render.ssao.shader.SetUniformMat4("view", matv)
|
|
g.render.ssao.shader.SetUniformMat4("projection", matp)
|
|
g.render.ssao.shader.SetUniformVec3f("viewPos", g.view.EyePos)
|
|
|
|
render.DrawScreenQuad()
|
|
|
|
// 3/2. SSAO blur pass
|
|
gl.BindFramebuffer(gl.FRAMEBUFFER, g.render.ssao.blur.fbo)
|
|
g.render.ssao.blur.shader.UseProgram()
|
|
g.render.ssao.blur.shader.BindTextures()
|
|
g.render.ssao.blur.shader.SetUniformVec2f("screenSize", g.render.lastDisplaySize.ToFloat32())
|
|
|
|
render.DrawScreenQuad()
|
|
|
|
gl.Flush()
|
|
io.Diagnostics.Times.RenderPasses.SSAO = lastclock.Restart()
|
|
|
|
// 4. Render the actual output with deferred lighting
|
|
gl.BindFramebuffer(gl.FRAMEBUFFER, g.render.output.fbo)
|
|
gl.ClearColor(0, 0, 0, 0)
|
|
gl.Clear(gl.COLOR_BUFFER_BIT)
|
|
gl.Disable(gl.DEPTH_TEST)
|
|
g.render.lighting.shader.UseProgram()
|
|
g.render.lighting.shader.BindTextures()
|
|
g.render.lighting.shader.SetUniformMat4("lightspace", lightspace)
|
|
g.render.lighting.shader.SetUniformVec3f("viewPos", g.view.EyePos)
|
|
g.render.lighting.shader.SetUniformVec4f("fogColor", io.FogColor)
|
|
g.render.lighting.shader.SetUniformVec3f("sun", normalSun)
|
|
|
|
render.DrawScreenQuad()
|
|
|
|
gl.Flush()
|
|
io.Diagnostics.Times.RenderPasses.Lighting = lastclock.Restart()
|
|
|
|
// 5. Render water
|
|
gl.Enable(gl.DEPTH_TEST)
|
|
gl.DepthFunc(gl.LESS)
|
|
gl.Enable(gl.CULL_FACE)
|
|
gl.Enable(gl.BLEND)
|
|
gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
|
|
gl.BlendEquation(gl.FUNC_ADD)
|
|
g.render.water.shader.UseProgram()
|
|
g.render.water.shader.BindTextures()
|
|
|
|
g.render.water.shader.SetUniformMat4("lightspace", lightspace)
|
|
g.render.water.shader.SetUniformMat4("view", matv)
|
|
g.render.water.shader.SetUniformMat4("projection", matp)
|
|
g.render.water.shader.SetUniformVec3f("viewPos", g.view.EyePos)
|
|
g.render.water.shader.SetUniformVec4f("fogColor", io.FogColor)
|
|
g.render.water.shader.SetUniformVec3f("sun", normalSun)
|
|
g.render.water.shader.SetUniformFloat("alpha", alpha)
|
|
g.render.water.shader.SetUniformVec2f("screenSize", g.render.lastDisplaySize.ToFloat32())
|
|
|
|
g.world.RenderWater()
|
|
|
|
// And render framewires
|
|
render.Framewire.Render(g.view)
|
|
|
|
// Finally. Copy the output texture to the back buffer
|
|
gl.BindFramebuffer(gl.FRAMEBUFFER, 0)
|
|
gl.ClearColor(io.ClearColor[0], io.ClearColor[1], io.ClearColor[2], io.ClearColor[3])
|
|
gl.Clear(gl.COLOR_BUFFER_BIT)
|
|
gl.Disable(gl.DEPTH_TEST)
|
|
gl.Disable(gl.BLEND)
|
|
g.render.output.shader.UseProgram()
|
|
g.render.output.shader.BindTextures()
|
|
g.render.output.shader.SetUniformFloat("gamma", gamma)
|
|
g.render.output.shader.SetUniformFloat("exposure", exposure)
|
|
|
|
render.DrawScreenQuad()
|
|
|
|
gl.Flush()
|
|
io.Diagnostics.Times.RenderPasses.Postfx = lastclock.Restart()
|
|
io.Diagnostics.Times.Render = allclock.Elapsed()
|
|
|
|
// Show Information?
|
|
if io.ShowDebugInfo {
|
|
g.renderDebugInfo()
|
|
}
|
|
|
|
backend.Render(win)
|
|
|
|
}
|