asuro/PuzGame
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

camera movement & formatting

Browse Source
This commit is contained in:
Asuro
2025-02-12 01:24:28 +01:00
parent bf2371eca0
commit 03aecb6d44
18 changed files with 1316 additions and 574 deletions
Download Patch File Download Diff File Expand all files Collapse all files

380
src/game/rendering/Rendering.cpp
View File

@@ -1,215 +1,239 @@
#include "Rendering.h"
#include "../Log.h"
#include "../../engine/Shared.h"
#include "../Global.h"
#include "../Input.h"
#include "../Instance.h"
#include "../Log.h"
#include "../Mesh.h"
#include "Rendering.h"
#include "bgfx/defines.h"
#include "bx/timer.h"
#include <bx/file.h>
#include <bgfx/bgfx.h>
#include <bx/file.h>
#include <thread>
using namespace std::chrono_literals;
namespace Game
{
namespace
{
static const bgfx::Memory* loadMem(bx::FileReaderI* _reader, const bx::FilePath& _filePath)
{
if (bx::open(_reader, _filePath))
{
uint32_t size = (uint32_t)bx::getSize(_reader);
const bgfx::Memory* mem = bgfx::alloc(size + 1);
bx::read(_reader, mem->data, size, bx::ErrorAssert{});
bx::close(_reader);
mem->data[mem->size - 1] = '\0';
return mem;
}
namespace
{
static const bgfx::Memory* loadMem(bx::FileReaderI* _reader, const bx::FilePath& _filePath)
{
if (bx::open(_reader, _filePath))
{
uint32_t size = (uint32_t)bx::getSize(_reader);
const bgfx::Memory* mem = bgfx::alloc(size + 1);
bx::read(_reader, mem->data, size, bx::ErrorAssert{});
bx::close(_reader);
mem->data[mem->size - 1] = '\0';
return mem;
}
Log("Failed to load %s.", _filePath.getCPtr());
return NULL;
}
Log("Failed to load %s.", _filePath.getCPtr());
return NULL;
}
bgfx::ShaderHandle loadShader(const char* FILENAME)
{
const char* shaderPath = "???";
bgfx::ShaderHandle loadShader(const char* FILENAME)
{
const char* shaderPath = "???";
switch (bgfx::getRendererType()) {
case bgfx::RendererType::Agc:
case bgfx::RendererType::Nvn:
case bgfx::RendererType::Count:
case bgfx::RendererType::Noop: break;
case bgfx::RendererType::Direct3D11:
case bgfx::RendererType::Direct3D12: shaderPath = "game/compiled-shaders/dx11/"; break;
case bgfx::RendererType::Gnm: shaderPath = "game/compiled-shaders/pssl/"; break;
case bgfx::RendererType::Metal: shaderPath = "game/compiled-shaders/metal/"; break;
case bgfx::RendererType::OpenGL: shaderPath = "game/compiled-shaders/glsl/"; break;
case bgfx::RendererType::OpenGLES: shaderPath = "game/compiled-shaders/essl/"; break;
case bgfx::RendererType::Vulkan: shaderPath = "game/compiled-shaders/spirv/"; break;
}
switch (bgfx::getRendererType())
{
case bgfx::RendererType::Agc:
case bgfx::RendererType::Nvn:
case bgfx::RendererType::Count:
case bgfx::RendererType::Noop:
break;
case bgfx::RendererType::Direct3D11:
case bgfx::RendererType::Direct3D12:
shaderPath = "game/compiled-shaders/dx11/";
break;
case bgfx::RendererType::Gnm:
shaderPath = "game/compiled-shaders/pssl/";
break;
case bgfx::RendererType::Metal:
shaderPath = "game/compiled-shaders/metal/";
break;
case bgfx::RendererType::OpenGL:
shaderPath = "game/compiled-shaders/glsl/";
break;
case bgfx::RendererType::OpenGLES:
shaderPath = "game/compiled-shaders/essl/";
break;
case bgfx::RendererType::Vulkan:
shaderPath = "game/compiled-shaders/spirv/";
break;
}
char buffer[512]{ 0 };
bx::strCopy(buffer, sizeof(buffer), shaderPath);
bx::strCat(buffer, sizeof(buffer), FILENAME);
bx::strCat(buffer, sizeof(buffer), ".bin");
char buffer[512]{0};
bx::strCopy(buffer, sizeof(buffer), shaderPath);
bx::strCat(buffer, sizeof(buffer), FILENAME);
bx::strCat(buffer, sizeof(buffer), ".bin");
Log("Loading shader at %s", buffer);
Log("Loading shader at %s", buffer);
FILE* file;
for (int32_t i = 0; i < 3; ++i)
{
file = fopen(buffer, "rb");
if (file == nullptr)
{
std::this_thread::sleep_for(100ms);
break;
}
fseek(file, 0, SEEK_END);
long fileSize = ftell(file);
fseek(file, 0, SEEK_SET);
FILE* file;
for (int32_t i = 0; i < 3; ++i)
{
file = fopen(buffer, "rb");
if (file == nullptr)
{
std::this_thread::sleep_for(100ms);
break;
}
const bgfx::Memory* mem = bgfx::alloc(fileSize + 1);
fread(mem->data, 1, fileSize, file);
mem->data[mem->size - 1] = '\0';
fclose(file);
fseek(file, 0, SEEK_END);
long fileSize = ftell(file);
fseek(file, 0, SEEK_SET);
return bgfx::createShader(mem);
}
Log("Failed to load shader %s", FILENAME);
return {};
}
}
const bgfx::Memory* mem = bgfx::alloc(fileSize + 1);
fread(mem->data, 1, fileSize, file);
mem->data[mem->size - 1] = '\0';
fclose(file);
void GameRendering::Setup()
{
Log("Game rendering setup...");
SharedData& shared = GetShared();
bgfx::Init init;
init.type = bgfx::RendererType::Direct3D12;
init.debug = true;
init.callback = &Callback;
init.platformData.nwh = shared.Window.Handle;
init.platformData.ndt = nullptr;
init.platformData.type = bgfx::NativeWindowHandleType::Default;
init.resolution.width = shared.Window.WindowWidth;
init.resolution.height = shared.Window.WindowHeight;
init.resolution.reset = BGFX_RESET_VSYNC;
return bgfx::createShader(mem);
}
Log("%i by %i", init.resolution.width, init.resolution.height);
if (!bgfx::init(init))
{
Log("BGFX setup failed!");
}
else
{
Log("BGFX setup succeded!");
}
bgfx::setDebug(BGFX_DEBUG_TEXT);
bgfx::setViewClear(0, BGFX_CLEAR_COLOR | BGFX_CLEAR_DEPTH, 0x303030ff, 1.0f, 0);
Log("Failed to load shader %s", FILENAME);
return {};
}
} // namespace
LoadMesh(Models[0]);
bgfx::ShaderHandle vertexShader = loadShader("vert");
bgfx::ShaderHandle fragmentShader = loadShader("frag");
Materials[0].Shader = bgfx::createProgram(vertexShader, fragmentShader, true);
Materials[0].State = 0
| BGFX_STATE_WRITE_RGB
| BGFX_STATE_WRITE_A
| BGFX_STATE_WRITE_Z
| BGFX_STATE_DEPTH_TEST_LESS
| BGFX_STATE_CULL_CCW
| BGFX_STATE_MSAA;
Materials[0].Uniforms[Material::UniformTimeIdx] = bgfx::createUniform("u_time", bgfx::UniformType::Vec4);
if (!GetInstance().IsInitialized)
{
GetInstance().StartTime = bx::getHPCounter();
}
}
void GameRendering::Setup()
{
Log("Game rendering setup...");
SharedData& shared = GetShared();
void GameRendering::Update()
{
SharedData& shared = GetShared();
bgfx::Init init;
init.type = bgfx::RendererType::Direct3D12;
init.debug = true;
init.callback = &Callback;
init.platformData.nwh = shared.Window.Handle;
init.platformData.ndt = nullptr;
init.platformData.type = bgfx::NativeWindowHandleType::Default;
init.resolution.width = shared.Window.WindowWidth;
init.resolution.height = shared.Window.WindowHeight;
init.resolution.reset = BGFX_RESET_VSYNC;
// Reload shaders if necessary
FileChangeNotification* shaderChange = nullptr;
if (shared.Dev.ChangedShaderCount > 0)
{
shared.Dev.ChangedShaderCount = 0;
// TODO: when to destroy shader?
// bgfx::destroy(Shader);
bgfx::ShaderHandle vertexShader = loadShader("vert");
bgfx::ShaderHandle fragmentShader = loadShader("frag");
if (isValid(vertexShader) && isValid(fragmentShader))
{
bgfx::ProgramHandle newProgram = bgfx::createProgram(vertexShader, fragmentShader, true);
if (isValid(newProgram))
{
Materials[0].Shader = newProgram;
}
else
{
Log("Failed to load shader!");
}
}
}
Log("%i by %i", init.resolution.width, init.resolution.height);
GetInstance().GameLevel.Update();
const bx::Vec3 at = { 0.0f, 0.0f, 0.0f };
const bx::Vec3 eye = { 0.0f, 0.0f, -35.0f };
if (!bgfx::init(init))
{
Log("BGFX setup failed!");
}
else
{
Log("BGFX setup succeded!");
}
bgfx::setDebug(BGFX_DEBUG_TEXT);
bgfx::setViewClear(0, BGFX_CLEAR_COLOR | BGFX_CLEAR_DEPTH, 0x303030ff, 1.0f, 0);
// Set view and projection matrix for view 0.
{
float view[16];
bx::mtxLookAt(view, eye, at);
LoadMesh(Models[0]);
float proj[16];
bx::mtxProj(proj, 75.0f, float(shared.Window.WindowWidth) / float(shared.Window.WindowHeight), 0.1f, 1000.0f, bgfx::getCaps()->homogeneousDepth);
bgfx::setViewTransform(0, view, proj);
bgfx::ShaderHandle vertexShader = loadShader("vert");
bgfx::ShaderHandle fragmentShader = loadShader("frag");
// Set view 0 default viewport.
bgfx::setViewRect(0, 0, 0, shared.Window.WindowWidth, shared.Window.WindowHeight);
}
Materials[0].Shader = bgfx::createProgram(vertexShader, fragmentShader, true);
Materials[0].State = 0 | BGFX_STATE_WRITE_RGB | BGFX_STATE_WRITE_A | BGFX_STATE_WRITE_Z |
BGFX_STATE_DEPTH_TEST_LESS | BGFX_STATE_CULL_CCW | BGFX_STATE_MSAA;
Materials[0].Uniforms[Material::UniformTimeIdx] = bgfx::createUniform("u_time", bgfx::UniformType::Vec4);
float TimeValues[4]{0.0f};
TimeValues[0] = GetInstance().Now;
if (!GetInstance().IsInitialized)
{
GetInstance().StartTime = bx::getHPCounter();
}
}
for (int32_t i = 0; i < GetInstance().GameLevel.Cubes.Count; ++i)
{
Cube* c = GetInstance().GameLevel.Cubes.Get(i);
if (c)
{
bgfx::setTransform(c->Transform.M);
void GameRendering::Update()
{
SharedData& shared = GetShared();
Model& currentModel = Models[c->ModelIdx];
Material& currentMaterial = Materials[c->MaterialIdx];
bgfx::setVertexBuffer(0, currentModel.VertexBuffer);
bgfx::setIndexBuffer(currentModel.IndexBuffer);
bgfx::setState(currentMaterial.State);
bgfx::setUniform(Materials[0].Uniforms[Material::UniformTimeIdx], TimeValues);
// Reload shaders if necessary
FileChangeNotification* shaderChange = nullptr;
if (shared.Dev.ChangedShaderCount > 0)
{
shared.Dev.ChangedShaderCount = 0;
// Submit primitive for rendering to view 0.
bgfx::submit(0, currentMaterial.Shader);
}
}
// TODO: when to destroy shader?
// bgfx::destroy(Shader);
bgfx::ShaderHandle vertexShader = loadShader("vert");
bgfx::ShaderHandle fragmentShader = loadShader("frag");
if (isValid(vertexShader) && isValid(fragmentShader))
{
bgfx::ProgramHandle newProgram = bgfx::createProgram(vertexShader, fragmentShader, true);
if (isValid(newProgram))
{
Materials[0].Shader = newProgram;
}
else
{
Log("Failed to load shader!");
}
}
}
bgfx::dbgTextPrintf(1, 1, 0x0F, "Time: %.1f", GetInstance().Now);
bgfx::dbgTextPrintf(1, 2, 0x0f, "Frame: %u", GetInstance().FrameCounter);
{
GetInstance().GameLevel.Update();
float forwardInput =
(GetKey(ScanCode::SDL_SCANCODE_W) ? 1.0f : 0.0f) + (GetKey(ScanCode::SDL_SCANCODE_S) ? -1.0f : 0.0f);
float rightInput =
(GetKey(ScanCode::SDL_SCANCODE_D) ? 1.0f : 0.0f) + (GetKey(ScanCode::SDL_SCANCODE_A) ? -1.0f : 0.0f);
Vec3 inputVec = {rightInput, 0.0f, forwardInput};
bgfx::frame();
}
Vec3 camForward = Cam.Transform.Forward();
Vec3 camRight = Cam.Transform.Right();
void GameRendering::Shutdown()
{
bgfx::shutdown();
}
}
Cam.Transform.Translate(
{camForward.X * forwardInput, camForward.Y * forwardInput, camForward.Z * forwardInput});
Cam.Transform.Translate({camRight.X * rightInput, camRight.Y * rightInput, camRight.Z * rightInput});
}
// Set view and projection matrix for view 0.
{
float proj[16];
bx::mtxProj(proj,
75.0f,
float(shared.Window.WindowWidth) / float(shared.Window.WindowHeight),
0.1f,
1000.0f,
bgfx::getCaps()->homogeneousDepth);
bgfx::setViewTransform(0, Cam.Transform.M, proj);
// Set view 0 default viewport.
bgfx::setViewRect(0, 0, 0, shared.Window.WindowWidth, shared.Window.WindowHeight);
}
float TimeValues[4]{0.0f};
TimeValues[0] = GetInstance().Now;
for (int32_t i = 0; i < GetInstance().GameLevel.Cubes.Count; ++i)
{
Cube* c = GetInstance().GameLevel.Cubes.Get(i);
if (c)
{
bgfx::setTransform(c->Transform.M);
Model& currentModel = Models[c->ModelIdx];
Material& currentMaterial = Materials[c->MaterialIdx];
bgfx::setVertexBuffer(0, currentModel.VertexBuffer);
bgfx::setIndexBuffer(currentModel.IndexBuffer);
bgfx::setState(currentMaterial.State);
bgfx::setUniform(Materials[0].Uniforms[Material::UniformTimeIdx], TimeValues);
// Submit primitive for rendering to view 0.
bgfx::submit(0, currentMaterial.Shader);
}
}
bgfx::dbgTextPrintf(1, 1, 0x0F, "Time: %.1f", GetInstance().Now);
bgfx::dbgTextPrintf(1, 2, 0x0F, "Frame: %u", GetInstance().FrameCounter);
bgfx::dbgTextPrintf(1, 3, 0x0F, "Delta: %.3fms / %.0ffps", GetInstance().Delta, 1.0 / GetInstance().Delta);
bgfx::frame();
}
void GameRendering::Shutdown()
{
bgfx::shutdown();
}
} // namespace Game

194
src/game/rendering/Rendering.h
View File

@@ -1,108 +1,132 @@
#pragma once
#include "../Global.h"
#include <bgfx/bgfx.h>
#include <bx/string.h>
#include <cstdio>
namespace Game
{
struct PosColorVertex
{
float x;
float y;
float z;
uint32_t abgr;
float uv_x;
float uv_y;
};
struct PosColorVertex
{
float x;
float y;
float z;
uint32_t abgr;
float uv_x;
float uv_y;
};
struct BgfxCallback : public bgfx::CallbackI
{
virtual ~BgfxCallback()
{
}
struct BgfxCallback : public bgfx::CallbackI
{
virtual ~BgfxCallback()
{
}
virtual void fatal(const char* _filePath, uint16_t _line, bgfx::Fatal::Enum _code, const char* _str) override
{
// Something unexpected happened, inform user and bail out.
printf("Fatal error: 0x%08x: %s", _code, _str);
virtual void fatal(const char* _filePath, uint16_t _line, bgfx::Fatal::Enum _code, const char* _str) override
{
// Something unexpected happened, inform user and bail out.
printf("Fatal error: 0x%08x: %s", _code, _str);
// Must terminate, continuing will cause crash anyway.
abort();
}
// Must terminate, continuing will cause crash anyway.
abort();
}
virtual void traceVargs(const char* _filePath, uint16_t _line, const char* _format, va_list _argList) override
{
printf("%s (%d): ", _filePath, _line);
vprintf(_format, _argList);
}
virtual void traceVargs(const char* _filePath, uint16_t _line, const char* _format, va_list _argList) override
{
printf("%s (%d): ", _filePath, _line);
vprintf(_format, _argList);
}
virtual void profilerBegin(const char* /*_name*/, uint32_t /*_abgr*/, const char* /*_filePath*/, uint16_t /*_line*/) override
{
}
virtual void profilerBegin(const char* /*_name*/,
uint32_t /*_abgr*/,
const char* /*_filePath*/,
uint16_t /*_line*/) override
{
}
virtual void profilerBeginLiteral(const char* /*_name*/, uint32_t /*_abgr*/, const char* /*_filePath*/, uint16_t /*_line*/) override
{
}
virtual void profilerBeginLiteral(const char* /*_name*/,
uint32_t /*_abgr*/,
const char* /*_filePath*/,
uint16_t /*_line*/) override
{
}
virtual void profilerEnd() override
{
}
virtual void profilerEnd() override
{
}
virtual uint32_t cacheReadSize(uint64_t _id) override
{
return 0;
}
virtual uint32_t cacheReadSize(uint64_t _id) override
{
return 0;
}
virtual bool cacheRead(uint64_t _id, void* _data, uint32_t _size) override
{
return false;
}
virtual bool cacheRead(uint64_t _id, void* _data, uint32_t _size) override
{
return false;
}
virtual void cacheWrite(uint64_t _id, const void* _data, uint32_t _size) override
{
}
virtual void cacheWrite(uint64_t _id, const void* _data, uint32_t _size) override
{
}
virtual void screenShot(const char* _filePath, uint32_t _width, uint32_t _height, uint32_t _pitch, const void* _data, uint32_t /*_size*/, bool _yflip) override
{
}
virtual void screenShot(const char* _filePath,
uint32_t _width,
uint32_t _height,
uint32_t _pitch,
const void* _data,
uint32_t /*_size*/,
bool _yflip) override
{
}
virtual void captureBegin(uint32_t _width, uint32_t _height, uint32_t /*_pitch*/, bgfx::TextureFormat::Enum /*_format*/, bool _yflip) override
{
}
virtual void captureBegin(uint32_t _width,
uint32_t _height,
uint32_t /*_pitch*/,
bgfx::TextureFormat::Enum /*_format*/,
bool _yflip) override
{
}
virtual void captureEnd() override
{
}
virtual void captureEnd() override
{
}
virtual void captureFrame(const void* _data, uint32_t /*_size*/) override
{
}
};
virtual void captureFrame(const void* _data, uint32_t /*_size*/) override
{
}
};
struct Model
{
bgfx::VertexBufferHandle VertexBuffer;
bgfx::IndexBufferHandle IndexBuffer;
bgfx::VertexLayout VertLayout;
};
struct Material
{
static constexpr uint32_t UniformTimeIdx = 0;
bgfx::ProgramHandle Shader;
bgfx::UniformHandle Uniforms[8];
uint64_t State = 0;
};
struct Model
{
bgfx::VertexBufferHandle VertexBuffer;
bgfx::IndexBufferHandle IndexBuffer;
bgfx::VertexLayout VertLayout;
};
class GameRendering
{
private:
Material Materials[8];
Model Models[8];
BgfxCallback Callback;
public:
void Setup();
void Update();
void Shutdown();
};
}
struct Material
{
static constexpr uint32_t UniformTimeIdx = 0;
bgfx::ProgramHandle Shader;
bgfx::UniformHandle Uniforms[8];
uint64_t State = 0;
};
struct Camera
{
Mat4 Transform;
};
class GameRendering
{
private:
Material Materials[8];
Model Models[8];
BgfxCallback Callback;
Camera Cam;
public:
void Setup();
void Update();
void Shutdown();
};
} // namespace Game