From 9195dd7c3f032524f66c6cfbf26a29cf472526b1 Mon Sep 17 00:00:00 2001 From: Edgaru089 Date: Thu, 24 Feb 2022 13:18:05 +0800 Subject: [PATCH] move WorldRenderer to game package --- internal/game/game.go | 15 +- internal/game/logic.go | 19 +- .../render_world.go => game/render.go} | 216 +++++++++--------- .../render_debuginfo.go} | 36 +-- internal/render/render_world.go.old | 119 ---------- 5 files changed, 140 insertions(+), 265 deletions(-) rename internal/{render/render_world.go => game/render.go} (70%) rename internal/{render/render_world_debuginfo.go => game/render_debuginfo.go} (69%) delete mode 100755 internal/render/render_world.go.old diff --git a/internal/game/game.go b/internal/game/game.go index 0a7408d..f798dfd 100644 --- a/internal/game/game.go +++ b/internal/game/game.go @@ -16,8 +16,8 @@ type Game struct { player *entity.Entity - view *render.View - worldrender *render.WorldRenderer + view *render.View + render renderData prevCursorPos itype.Vec2d cameraPos itype.Vec3d @@ -36,12 +36,11 @@ type Game struct { // NewGame creates a new, empty Game. func NewGame() (g *Game) { return &Game{ - world: world.NewWorld(), - player: entity.NewEntity("player", itype.Vec3d{18, 80, 18}), - worldrender: &render.WorldRenderer{}, - cameraPos: itype.Vec3d{18, 80, 18}, - rotY: 0, - rotZ: 0, + world: world.NewWorld(), + player: entity.NewEntity("player", itype.Vec3d{18, 80, 18}), + cameraPos: itype.Vec3d{18, 80, 18}, + rotY: 0, + rotZ: 0, } } diff --git a/internal/game/logic.go b/internal/game/logic.go index f93ff41..125a2a8 100644 --- a/internal/game/logic.go +++ b/internal/game/logic.go @@ -6,7 +6,6 @@ import ( "os" "time" - "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" @@ -14,7 +13,6 @@ import ( "edgaru089.ml/go/gl01/internal/util/itype" "edgaru089.ml/go/gl01/internal/world" "edgaru089.ml/go/gl01/internal/world/worldgen" - "github.com/go-gl/gl/all-core/gl" "github.com/go-gl/glfw/v3.3/glfw" "github.com/go-gl/mathgl/mgl64" "github.com/inkyblackness/imgui-go/v4" @@ -39,9 +37,8 @@ func (g *Game) Init(win *glfw.Window) { g.world = world.NewWorld() g.view = &render.View{} - g.worldrender = &render.WorldRenderer{} - err := g.worldrender.Init(g.world) + err := g.initRender() if err != nil { panic(err) } @@ -249,19 +246,5 @@ func (g *Game) Update(win *glfw.Window, delta time.Duration) { imgui.ShowDemoWindow(nil) g.imgui() - - if ok, bc, face, _, _ := g.world.CastViewRay(io.ViewPos, io.ViewDir.Normalize(), 10); ok { - igwrap.TextBackground("Looking At: (%d %d %d) facing %s", bc[0], bc[1], bc[2], itype.DirectionName[face]) - } - io.Diagnostics.Times.GUI = clock.Restart() } - -// 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])) - g.worldrender.Render(g.world, g.view) - render.Framewire.Render(g.view) - - backend.Render(win) -} diff --git a/internal/render/render_world.go b/internal/game/render.go similarity index 70% rename from internal/render/render_world.go rename to internal/game/render.go index 3100cfc..bcdb432 100644 --- a/internal/render/render_world.go +++ b/internal/game/render.go @@ -1,4 +1,4 @@ -package render +package game import ( "errors" @@ -8,11 +8,13 @@ import ( "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" - "edgaru089.ml/go/gl01/internal/world" "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" ) @@ -26,9 +28,8 @@ var ( RandomSize = itype.Vec2i{32, 32} // Size of the random mapping ) -// WorldRenderer holds texture/shader resource and viewport -// information for world rendering. -type WorldRenderer struct { +// renderData holds OpenGL state used by the game renderer. +type renderData struct { lastDisplaySize itype.Vec2i startTime time.Time @@ -36,8 +37,8 @@ type WorldRenderer struct { // Depth mapping pass depthmap struct { - fbo, tex uint32 // Framebuffer Object and Texture. - shader *Shader // Shader. + fbo, tex uint32 // Framebuffer Object and Texture. + shader *render.Shader // Shader. } // Geometry pass @@ -46,33 +47,33 @@ type WorldRenderer struct { // Textures. Position/Depth(View Space); Normal/Lightspace Depth; Diffuse Color/Specular Intensity. pos, norm, color uint32 - depth uint32 // Depth renderbuffer. - shader *Shader // Geometry pass shaders. + 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 *Shader // SSAO pass shader + 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 *Shader + shader *render.Shader } } // Deferred lighting pass lighting struct { - shader *Shader // Deferred lighting pass shaders + shader *render.Shader // Deferred lighting pass shaders } // Semi-transparent pass water struct { - shader *Shader + shader *render.Shader } // Output pass @@ -80,43 +81,40 @@ type WorldRenderer 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 *Shader // Shader used to copy output.tex to back buffer. + shader *render.Shader // Shader used to copy output.tex to back buffer. } - texture *Texture // World texture atlas + texture *render.Texture // World texture atlas } -// The default WorldRenderer. -var DefaultWorldRenderer WorldRenderer +func (g *Game) initRender() (err error) { + r := &g.render -// Init initializes the WorldRenderer. -func (r *WorldRenderer) Init(w *world.World) (err error) { - - r.depthmap.shader, err = NewShader(asset.WorldShaderShadowmapVert, asset.WorldShaderShadowmapFrag) + r.depthmap.shader, err = render.NewShader(asset.WorldShaderShadowmapVert, asset.WorldShaderShadowmapFrag) if err != nil { return errors.New("depthmap: " + err.Error()) } - r.gbuffer.shader, err = NewShader(asset.WorldShaderGeometryVert, asset.WorldShaderGeometryFrag) + r.gbuffer.shader, err = render.NewShader(asset.WorldShaderGeometryVert, asset.WorldShaderGeometryFrag) if err != nil { return errors.New("gbuffer: " + err.Error()) } - r.ssao.shader, err = NewShader(asset.WorldShaderSSAOVert, asset.WorldShaderSSAOFrag) + r.ssao.shader, err = render.NewShader(asset.WorldShaderSSAOVert, asset.WorldShaderSSAOFrag) if err != nil { return errors.New("ssao: " + err.Error()) } - r.ssao.blur.shader, err = NewShader(asset.WorldShaderSSAOBlurVert, asset.WorldShaderSSAOBlurFrag) + 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 = NewShader(asset.WorldShaderLightingVert, asset.WorldShaderLightingFrag) + r.lighting.shader, err = render.NewShader(asset.WorldShaderLightingVert, asset.WorldShaderLightingFrag) if err != nil { return errors.New("lighting: " + err.Error()) } - r.water.shader, err = NewShader(asset.WorldShaderWaterVert, asset.WorldShaderWaterFrag) + r.water.shader, err = render.NewShader(asset.WorldShaderWaterVert, asset.WorldShaderWaterFrag) if err != nil { return errors.New("water: " + err.Error()) } - r.output.shader, err = NewShader(asset.WorldShaderOutputVert, asset.WorldShaderOutputFrag) + r.output.shader, err = render.NewShader(asset.WorldShaderOutputVert, asset.WorldShaderOutputFrag) if err != nil { return errors.New("output: " + err.Error()) } @@ -126,14 +124,14 @@ func (r *WorldRenderer) Init(w *world.World) (err error) { gl.GetFloatv(gl.MAX_TEXTURE_MAX_ANISOTROPY, &maxaf) asset.InitWorldTextureAtlas() - r.texture = NewTexture() + 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_RGBA, igwrap.TextureFlag_FlipY) + 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()) @@ -287,29 +285,28 @@ func (r *WorldRenderer) Init(w *world.World) (err error) { r.lastDisplaySize = io.DisplaySize r.startTime = time.Now() - 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) { - gl.BindTexture(gl.TEXTURE_2D, r.gbuffer.pos) // G-Buffer, Position +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, r.gbuffer.norm) // G-Buffer, Normal + 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, r.gbuffer.color) // G-Buffer, Albedo Color + 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, r.gbuffer.depth) // G-Buffer, Depth (Renderbuffer) + 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, r.ssao.ambient) // SSAO Output Ambient Strength + 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, r.ssao.blur.output) // SSAO Blurred Output + 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, r.output.tex) // Output Texture + 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) - r.lastDisplaySize = newSize + g.render.lastDisplaySize = newSize + } var ( @@ -320,7 +317,12 @@ var ( atlasScale = float32(1) ) -func (r *WorldRenderer) Render(world *world.World, view *View) { +// 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() @@ -328,8 +330,8 @@ func (r *WorldRenderer) Render(world *world.World, view *View) { io.RenderDir = io.ViewDir // re-generate the G-buffers if the display size changed - if r.lastDisplaySize != io.DisplaySize { - r.ResizeDisplay(io.DisplaySize) + if g.render.lastDisplaySize != io.DisplaySize { + g.ResizeDisplay(io.DisplaySize) } imgui.SliderFloat3("Sun", &sun, -1, 1) @@ -346,84 +348,88 @@ func (r *WorldRenderer) Render(world *world.World, view *View) { // 1. Render to depth map gl.Viewport(0, 0, int32(ShadowmapSize[0]), int32(ShadowmapSize[1])) - gl.BindFramebuffer(gl.FRAMEBUFFER, r.depthmap.fbo) + gl.BindFramebuffer(gl.FRAMEBUFFER, g.render.depthmap.fbo) gl.Clear(gl.DEPTH_BUFFER_BIT) - 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) + 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 = view.EyePos.Add(lightPos.Negative()).ToFloat64() + io.RenderDir = g.view.EyePos.Add(lightPos.Negative()).ToFloat64() - r.depthmap.shader.UseProgram() - r.depthmap.shader.SetUniformMat4("lightspace", lightspace) + g.render.depthmap.shader.UseProgram() + g.render.depthmap.shader.SetUniformMat4("lightspace", lightspace) - world.Render() - world.RenderWater() + 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(r.lastDisplaySize[0]), int32(r.lastDisplaySize[1])) - gl.BindFramebuffer(gl.FRAMEBUFFER, r.gbuffer.fbo) + 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) - 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.SetUniformMat4("mvp", view.Perspective().Mul4(view.View())) - r.gbuffer.shader.SetUniformVec3f("viewPos", view.EyePos) + 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) - world.Render() + g.world.Render() + gl.Flush() io.Diagnostics.Times.RenderPasses.Geometry = lastclock.Restart() // 3/1. SSAO pass - gl.BindFramebuffer(gl.FRAMEBUFFER, r.ssao.fbo) + gl.BindFramebuffer(gl.FRAMEBUFFER, g.render.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) + 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) - DrawScreenQuad() + render.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()) + // 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()) - DrawScreenQuad() + render.DrawScreenQuad() + gl.Flush() io.Diagnostics.Times.RenderPasses.SSAO = lastclock.Restart() // 4. Render the actual output with deferred lighting - gl.BindFramebuffer(gl.FRAMEBUFFER, r.output.fbo) + 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) - r.lighting.shader.UseProgram() - r.lighting.shader.BindTextures() - r.lighting.shader.SetUniformMat4("lightspace", lightspace) - r.lighting.shader.SetUniformVec3f("viewPos", view.EyePos) - r.lighting.shader.SetUniformVec4f("fogColor", io.FogColor) - r.lighting.shader.SetUniformVec3f("sun", normalSun) + 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) - DrawScreenQuad() + render.DrawScreenQuad() + gl.Flush() io.Diagnostics.Times.RenderPasses.Lighting = lastclock.Restart() // 5. Render water @@ -433,19 +439,22 @@ func (r *WorldRenderer) Render(world *world.World, view *View) { gl.Enable(gl.BLEND) gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA) gl.BlendEquation(gl.FUNC_ADD) - r.water.shader.UseProgram() - r.water.shader.BindTextures() + g.render.water.shader.UseProgram() + g.render.water.shader.BindTextures() - r.water.shader.SetUniformMat4("lightspace", lightspace) - r.water.shader.SetUniformMat4("view", view.View()) - r.water.shader.SetUniformMat4("projection", view.Perspective()) - r.water.shader.SetUniformVec3f("viewPos", view.EyePos) - r.water.shader.SetUniformVec4f("fogColor", io.FogColor) - r.water.shader.SetUniformVec3f("sun", normalSun) - r.water.shader.SetUniformFloat("alpha", alpha) - r.water.shader.SetUniformVec2f("screenSize", r.lastDisplaySize.ToFloat32()) + 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()) - world.RenderWater() + 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) @@ -453,18 +462,21 @@ func (r *WorldRenderer) Render(world *world.World, view *View) { gl.Clear(gl.COLOR_BUFFER_BIT) gl.Disable(gl.DEPTH_TEST) gl.Disable(gl.BLEND) - r.output.shader.UseProgram() - r.output.shader.BindTextures() - r.output.shader.SetUniformFloat("gamma", gamma) - r.output.shader.SetUniformFloat("exposure", exposure) + g.render.output.shader.UseProgram() + g.render.output.shader.BindTextures() + g.render.output.shader.SetUniformFloat("gamma", gamma) + g.render.output.shader.SetUniformFloat("exposure", exposure) - DrawScreenQuad() + render.DrawScreenQuad() + gl.Flush() io.Diagnostics.Times.RenderPasses.Postfx = lastclock.Restart() io.Diagnostics.Times.Render = allclock.Elapsed() // Show Information? if io.ShowDebugInfo { - r.renderDebugInfo() + g.renderDebugInfo() } + + backend.Render(win) } diff --git a/internal/render/render_world_debuginfo.go b/internal/game/render_debuginfo.go similarity index 69% rename from internal/render/render_world_debuginfo.go rename to internal/game/render_debuginfo.go index a830812..fcabaa1 100644 --- a/internal/render/render_world_debuginfo.go +++ b/internal/game/render_debuginfo.go @@ -1,4 +1,4 @@ -package render +package game import ( "math" @@ -14,7 +14,7 @@ import ( const ( timebarN = 700 - timebarScale = 160 + timebarScale = 256 ) var ( @@ -23,7 +23,7 @@ var ( timebari int ) -func (r *WorldRenderer) renderDebugInfo() { +func (g *Game) renderDebugInfo() { // Render information if igwrap.Begin("F3", nil, 0) { igwrap.TextBlank() @@ -52,7 +52,7 @@ func (r *WorldRenderer) renderDebugInfo() { atlasScale = util.Maxf(1, atlasScale+wheely) } imgui.BeginTooltip() - igwrap.Image(r.texture.Handle(), isize.ToFloat32().Multiply(atlasScale), itype.Rectf{0, 0, 1, 1}) + igwrap.Image(g.render.texture.Handle(), isize.ToFloat32().Multiply(atlasScale), itype.Rectf{0, 0, 1, 1}) imgui.EndTooltip() } @@ -60,18 +60,18 @@ func (r *WorldRenderer) renderDebugInfo() { } // Draw Textures - imgui.SetNextWindowPosV(imgui.Vec2{X: float32(r.lastDisplaySize[0]), Y: 0}, imgui.ConditionAlways, imgui.Vec2{X: 1, Y: 0}) + imgui.SetNextWindowPosV(imgui.Vec2{X: float32(g.render.lastDisplaySize[0]), Y: 0}, imgui.ConditionAlways, imgui.Vec2{X: 1, Y: 0}) if igwrap.Begin("Renderer Textures/Outputs", nil, igwrap.WindowFlagsOverlay) { imgui.PushStyleVarVec2(imgui.StyleVarItemSpacing, imgui.Vec2{}) - imageSize := r.lastDisplaySize.ToFloat32().Multiply(0.25) + imageSize := g.render.lastDisplaySize.ToFloat32().Multiply(0.25) imageSize[1] -= imgui.CurrentStyle().WindowPadding().Y / 2 - imageSize[0] = imageSize[1] / float32(r.lastDisplaySize[1]) * float32(r.lastDisplaySize[0]) + imageSize[0] = imageSize[1] / float32(g.render.lastDisplaySize[1]) * float32(g.render.lastDisplaySize[0]) - igwrap.Image(r.gbuffer.pos, imageSize, itype.Rectf{0, 0, 1, 1}) - igwrap.Image(r.gbuffer.norm, imageSize, itype.Rectf{0, 0, 1, 1}) - igwrap.Image(r.gbuffer.color, imageSize, itype.Rectf{0, 0, 1, 1}) - igwrap.Image(r.ssao.ambient, imageSize, itype.Rectf{0, 0, 1, 1}) + igwrap.Image(g.render.gbuffer.pos, imageSize, itype.Rectf{0, 0, 1, 1}) + igwrap.Image(g.render.gbuffer.norm, imageSize, itype.Rectf{0, 0, 1, 1}) + igwrap.Image(g.render.gbuffer.color, imageSize, itype.Rectf{0, 0, 1, 1}) + igwrap.Image(g.render.ssao.ambient, imageSize, itype.Rectf{0, 0, 1, 1}) imgui.PopStyleVar() imgui.End() @@ -79,11 +79,11 @@ func (r *WorldRenderer) renderDebugInfo() { // Push the next bar timebars[timebari] = []int{ - int(io.Diagnostics.Times.RenderPasses.Depthmap.Nanoseconds() * timebarScale / 1000 / 1000), - int(io.Diagnostics.Times.RenderPasses.Geometry.Nanoseconds() * timebarScale / 1000 / 1000), - int(io.Diagnostics.Times.RenderPasses.SSAO.Nanoseconds() * timebarScale / 1000 / 1000), - int(io.Diagnostics.Times.RenderPasses.Lighting.Nanoseconds() * timebarScale / 1000 / 1000), - int(io.Diagnostics.Times.RenderPasses.Postfx.Nanoseconds() * timebarScale / 1000 / 1000), + int(io.Diagnostics.Times.RenderPasses.Depthmap.Nanoseconds() * timebarScale / 1024 / 1024), + int(io.Diagnostics.Times.RenderPasses.Geometry.Nanoseconds() * timebarScale / 1024 / 1024), + int(io.Diagnostics.Times.RenderPasses.SSAO.Nanoseconds() * timebarScale / 1024 / 1024), + int(io.Diagnostics.Times.RenderPasses.Lighting.Nanoseconds() * timebarScale / 1024 / 1024), + int(io.Diagnostics.Times.RenderPasses.Postfx.Nanoseconds() * timebarScale / 1024 / 1024), } timebari++ if timebari >= len(timebars) { @@ -91,12 +91,12 @@ func (r *WorldRenderer) renderDebugInfo() { } // Draw time bars - size := r.lastDisplaySize + size := g.render.lastDisplaySize dl := imgui.BackgroundDrawList() for i, l := range timebars { ex := 0 for j, d := range l { - dl.AddLine(imgui.Vec2{X: float32(i), Y: float32(size[1] - ex - 1)}, imgui.Vec2{X: float32(i), Y: float32(size[1] - ex - d)}, colorset[j]) + dl.AddLine(imgui.Vec2{X: float32(i), Y: float32(size[1] - ex)}, imgui.Vec2{X: float32(i), Y: float32(size[1] - ex - d)}, colorset[j]) ex += d } } diff --git a/internal/render/render_world.go.old b/internal/render/render_world.go.old deleted file mode 100755 index 61fe631..0000000 --- a/internal/render/render_world.go.old +++ /dev/null @@ -1,119 +0,0 @@ -package render - -import ( - "time" - "unsafe" - - "github.com/Edgaru089/gl01/internal/asset" - "github.com/Edgaru089/gl01/internal/util/itype" - "github.com/Edgaru089/gl01/internal/world" - "github.com/go-gl/gl/all-core/gl" - "github.com/go-gl/mathgl/mgl32" -) - -// WorldRenderer holds texture/shader resource and viewport -// information for world rendering. -type WorldRenderer struct { - shader *Shader - texture *Texture - - vao, vbo uint32 - vbolen int - vertex []world.Vertex - - // for testing! - initTime time.Time -} - -// The default WorldRenderer. -var DefaultWorldRenderer WorldRenderer - -// Init initializes the WorldRenderer. -func (r *WorldRenderer) Init(w *world.World) (err error) { - - r.shader, err = NewShader(asset.WorldShaderVert, asset.WorldShaderFrag) - if err != nil { - return err - } - - asset.InitWorldTextureAtlas() - r.texture = NewTextureRGBA(asset.WorldTextureAtlas.Image) - r.shader.SetUniformTexture("tex", r.texture) - - r.shader.SetUniformMat4("model", mgl32.Ident4()) - // and view and projection uniforms not yet set - gl.BindFragDataLocation(r.shader.Handle(), 0, gl.Str("outputColor\x00")) - - gl.GenVertexArrays(1, &r.vao) - gl.BindVertexArray(r.vao) - gl.GenBuffers(1, &r.vbo) - gl.BindBuffer(gl.ARRAY_BUFFER, r.vbo) - - gensync := make(chan []world.Vertex, len(w.Chunks)) - for _, c := range w.Chunks { - chunk := c - go func() { - arr := chunk.AppendVertex([]world.Vertex{}) - gensync <- arr - }() - } - for range w.Chunks { - r.vertex = append(r.vertex, (<-gensync)...) - } - close(gensync) - - gl.BufferData(gl.ARRAY_BUFFER, int(unsafe.Sizeof(world.Vertex{}))*len(r.vertex), gl.Ptr(r.vertex), gl.DYNAMIC_DRAW) - - vertAttrib := uint32(gl.GetAttribLocation(r.shader.Handle(), gl.Str("vert\x00"))) - gl.VertexAttribPointer(vertAttrib, 3, gl.FLOAT, false, int32(unsafe.Sizeof(world.Vertex{})), gl.PtrOffset(int(unsafe.Offsetof(world.Vertex{}.World)))) - - normalAttrib := uint32(gl.GetAttribLocation(r.shader.Handle(), gl.Str("normal\x00"))) - gl.VertexAttribPointer(normalAttrib, 3, gl.FLOAT, false, int32(unsafe.Sizeof(world.Vertex{})), gl.PtrOffset(int(unsafe.Offsetof(world.Vertex{}.Normal)))) - - texCoordAttrib := uint32(gl.GetAttribLocation(r.shader.Handle(), gl.Str("vertTexCoord\x00"))) - gl.VertexAttribPointer(texCoordAttrib, 2, gl.FLOAT, false, int32(unsafe.Sizeof(world.Vertex{})), gl.PtrOffset(int(unsafe.Offsetof(world.Vertex{}.Texture)))) - - lightAttrib := uint32(gl.GetAttribLocation(r.shader.Handle(), gl.Str("light\x00"))) - gl.VertexAttribPointer(lightAttrib, 1, gl.FLOAT, false, int32(unsafe.Sizeof(world.Vertex{})), gl.PtrOffset(int(unsafe.Offsetof(world.Vertex{}.Light)))) - - gl.EnableVertexAttribArray(vertAttrib) - gl.EnableVertexAttribArray(normalAttrib) - gl.EnableVertexAttribArray(texCoordAttrib) - gl.EnableVertexAttribArray(lightAttrib) - - w.EnableVertexArrayAttrib(vertAttrib) - w.EnableVertexArrayAttrib(normalAttrib) - w.EnableVertexArrayAttrib(texCoordAttrib) - w.EnableVertexArrayAttrib(lightAttrib) - - gl.Enable(gl.CULL_FACE) - gl.Enable(gl.DEPTH_TEST) - gl.DepthFunc(gl.LESS) - - r.initTime = time.Now() - - return nil -} - -func (r *WorldRenderer) Render(world *world.World, view *View) { - - r.shader.UseProgram() - r.shader.BindTextures() - - r.shader.SetUniformMat4("view", view.view) - r.shader.SetUniformMat4("projection", mgl32.Perspective(view.fovy, view.aspect, 0.1, 200)) - r.shader.SetUniformVec3f("sun", itype.Vec3f{-0.2, 1, 0.8}.Normalize()) - - // for testing! - //model := mgl32.HomogRotate3D(float32(time.Since(r.initTime).Seconds()), mgl32.Vec3{0, 1, 0}) - //r.shader.SetUniformMat4("model", model) - - //r.shader.SetUniformMat4("view", r.view) - - gl.BindVertexArray(r.vao) - gl.BindBuffer(gl.ARRAY_BUFFER, r.vbo) - gl.DrawArrays(gl.TRIANGLES, 0, int32(len(r.vertex))) - - world.Render() - //world.Chunk(0, 0).Render() -}