Initial commit.
This commit is contained in:
commit
d99b70eaa1
33 changed files with 2291 additions and 0 deletions
805
src/core/Engine.cpp
Normal file
805
src/core/Engine.cpp
Normal file
|
|
@ -0,0 +1,805 @@
|
|||
#include <iostream>
|
||||
#include <memory>
|
||||
|
||||
#include <glfw3webgpu.h>
|
||||
#include <webgpu/webgpu.h>
|
||||
#define NK_INCLUDE_FIXED_TYPES
|
||||
#define NK_INCLUDE_STANDARD_IO
|
||||
#define NK_INCLUDE_STANDARD_VARARGS
|
||||
#define NK_INCLUDE_DEFAULT_ALLOCATOR
|
||||
#define NK_INCLUDE_VERTEX_BUFFER_OUTPUT
|
||||
#define NK_INCLUDE_FONT_BAKING
|
||||
#define NK_INCLUDE_DEFAULT_FONT
|
||||
#include <nuklear.h>
|
||||
#include <gtc/matrix_transform.hpp>
|
||||
|
||||
#include <Engine.h>
|
||||
#include <Events.h>
|
||||
#include <Util.h>
|
||||
#include <UI.h>
|
||||
#include <ClientWorld.h>
|
||||
#include <Server.h>
|
||||
|
||||
#define STEP_SIZE 1000
|
||||
|
||||
/*
|
||||
|
||||
namespace Artifact {
|
||||
|
||||
void Engine::init() {
|
||||
instance = wgpuCreateInstance(nullptr);
|
||||
surface = glfwCreateWindowWGPUSurface(instance, window);
|
||||
}
|
||||
|
||||
void Engine::run() {
|
||||
init();
|
||||
while(!glfwWindowShouldClose(window)) {
|
||||
glfwPollEvents();
|
||||
}
|
||||
}
|
||||
|
||||
Engine::Engine() {
|
||||
world = std::make_unique<World::World>();
|
||||
}
|
||||
|
||||
Engine::~Engine() {
|
||||
std::cout << "Destructing engine..." << std::endl;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/*/
|
||||
|
||||
|
||||
static struct _glfwInit {
|
||||
_glfwInit() {
|
||||
if(!glfwInit()) printf("Failed to initialize GLFW.");
|
||||
}
|
||||
~_glfwInit() {
|
||||
glfwTerminate();
|
||||
}
|
||||
} __glfwinit;
|
||||
|
||||
namespace Artifact {
|
||||
|
||||
Engine::Engine() {
|
||||
world = std::make_unique<World::ClientWorld>();
|
||||
}
|
||||
|
||||
Engine::~Engine() {
|
||||
std::cout << "Destructing engine..." << std::endl;
|
||||
}
|
||||
|
||||
void Engine::init() {
|
||||
instance = wgpuCreateInstance(nullptr);
|
||||
surface = window.createWGPUSurface(instance);
|
||||
if (!surface) {
|
||||
std::cerr << "Failed to create surface" << std::endl;
|
||||
return;
|
||||
}
|
||||
WGPURequestAdapterCallbackInfo adapterCallbackOpts = {};
|
||||
adapterCallbackOpts.callback = [](WGPURequestAdapterStatus status, WGPUAdapter adapter, WGPUStringView error, void* engine, void*) {
|
||||
if(status == WGPURequestAdapterStatus_Success) {
|
||||
static_cast<Engine*>(engine)->adapter = adapter;
|
||||
}
|
||||
};
|
||||
adapterCallbackOpts.mode = WGPUCallbackMode_AllowProcessEvents;
|
||||
adapterCallbackOpts.userdata1 = this;
|
||||
WGPURequestAdapterOptions adapterOpts = {};
|
||||
adapterOpts.compatibleSurface = surface;
|
||||
wgpuInstanceRequestAdapter(instance, &adapterOpts, adapterCallbackOpts);
|
||||
while(!adapter) wgpuInstanceProcessEvents(instance);
|
||||
|
||||
WGPURequestDeviceCallbackInfo deviceCallbackOpts = {};
|
||||
deviceCallbackOpts.callback = [](WGPURequestDeviceStatus status, WGPUDevice device, WGPUStringView error, void* engine, void*) {
|
||||
if(status == WGPURequestDeviceStatus_Success) {
|
||||
static_cast<Engine*>(engine)->device = device;
|
||||
} else {
|
||||
std::cerr << error.data << std::endl;
|
||||
}
|
||||
};
|
||||
deviceCallbackOpts.mode = WGPUCallbackMode_AllowProcessEvents;
|
||||
deviceCallbackOpts.userdata1 = this;
|
||||
|
||||
WGPUUncapturedErrorCallbackInfo errorCallbackInfo = {};
|
||||
errorCallbackInfo.callback = [](auto device, WGPUErrorType type, WGPUStringView message, void*, void*) {
|
||||
const char* msg = (message.data ? reinterpret_cast<const char*>(message.data) : "No message");
|
||||
fprintf(stderr, "Uncaptured WebGPU Error (type %d): %s\n", type, msg);
|
||||
|
||||
if (type == WGPUErrorType_Validation) {
|
||||
// Optional: Break into debugger or abort for inspection
|
||||
__builtin_trap();
|
||||
}
|
||||
};
|
||||
errorCallbackInfo.userdata1 = nullptr; // Optional user data
|
||||
WGPUDeviceDescriptor deviceDesc = {};
|
||||
deviceDesc.uncapturedErrorCallbackInfo = errorCallbackInfo;
|
||||
wgpuAdapterRequestDevice(adapter, nullptr, deviceCallbackOpts);
|
||||
while(!device) wgpuInstanceProcessEvents(instance);
|
||||
|
||||
|
||||
queue = wgpuDeviceGetQueue(device);
|
||||
|
||||
WGPUSurfaceConfiguration surfaceConfig = {};
|
||||
surfaceConfig.device = device;
|
||||
surfaceConfig.format = surfaceFormat;
|
||||
surfaceConfig.usage = WGPUTextureUsage_RenderAttachment;
|
||||
surfaceConfig.width = viewportWidth;
|
||||
surfaceConfig.height = viewportHeight;
|
||||
surfaceConfig.presentMode = WGPUPresentMode_Fifo;
|
||||
wgpuSurfaceConfigure(surface, &surfaceConfig);
|
||||
|
||||
WGPUTextureDescriptor depthDesc = {};
|
||||
depthDesc.dimension = WGPUTextureDimension_2D;
|
||||
depthDesc.size.width = viewportWidth;
|
||||
depthDesc.size.height = viewportHeight;
|
||||
depthDesc.size.depthOrArrayLayers = 1;
|
||||
depthDesc.format = WGPUTextureFormat_Depth24Plus;
|
||||
depthDesc.usage = WGPUTextureUsage_RenderAttachment;
|
||||
depthDesc.mipLevelCount = 1;
|
||||
depthDesc.sampleCount = 1;
|
||||
depthTexture = std::make_unique<Util::Texture>();
|
||||
depthTexture->texture = wgpuDeviceCreateTexture(device, &depthDesc);
|
||||
depthTexture->view = wgpuTextureCreateView(depthTexture->texture, nullptr);
|
||||
|
||||
std::cout << "Initializing Nuklear..." << std::endl;
|
||||
// Initialize Nuklear
|
||||
ui = std::make_unique<nk_context>();
|
||||
nk_init_default(ui.get(), nullptr);
|
||||
|
||||
nk_font_atlas* atlas = (nk_font_atlas*)malloc(sizeof(nk_font_atlas));
|
||||
nk_font_atlas_init_default(atlas);
|
||||
nk_font_atlas_begin(atlas);
|
||||
|
||||
|
||||
std::cout << "Loading font..." << std::endl;
|
||||
|
||||
nk_font* font;
|
||||
void* fontData = nullptr;
|
||||
|
||||
FILE* fontFile = fopen((assetPath + "/fonts/Arial.ttf").c_str(), "rb");
|
||||
if (fontFile) {
|
||||
fseek(fontFile, 0, SEEK_END);
|
||||
long fontSize = ftell(fontFile);
|
||||
fseek(fontFile, 0, SEEK_SET);
|
||||
fontData = malloc(fontSize);
|
||||
fread(fontData, 1, fontSize, fontFile);
|
||||
fclose(fontFile);
|
||||
font = nk_font_atlas_add_from_memory(atlas, fontData, fontSize, 13.0f, nullptr);
|
||||
} else {
|
||||
std::cerr << "Failed to load font: " << (assetPath + "/fonts/Arial.ttf") << std::endl;
|
||||
font = nk_font_atlas_add_default(atlas, 13.0f, nullptr);
|
||||
}
|
||||
|
||||
int fontWidth, fontHeight;
|
||||
const void* fontImage = nk_font_atlas_bake(atlas, &fontWidth, &fontHeight, NK_FONT_ATLAS_RGBA32);
|
||||
uiFontTexture = Util::createTextureFromData(device, queue, fontImage, fontWidth, fontHeight);
|
||||
nk_font_atlas_end(atlas, nk_handle_id(0), nullptr);
|
||||
nk_style_set_font(ui.get(), &font->handle);
|
||||
if (fontData) free(fontData);
|
||||
free(atlas);
|
||||
|
||||
unsigned char whitePixel[4] = {255, 255, 255, 255};
|
||||
uiDummyTexture = Util::createTextureFromData(device, queue, whitePixel, 1, 1);
|
||||
|
||||
nk_buffer_init_default(&uiVertexBufferNK);
|
||||
nk_buffer_init_default(&uiIndexBufferNK);
|
||||
nk_buffer_init_default(&uiCommandBufferNK);
|
||||
|
||||
auto window_ = &window;
|
||||
auto ui_ = ui.get();
|
||||
window.listen<Events::Key>([window_, ui_](auto ev) {
|
||||
bool press = ev.action == GLFW_PRESS;
|
||||
switch (ev.key) {
|
||||
case GLFW_KEY_ESCAPE:
|
||||
window_->close();
|
||||
break;
|
||||
case GLFW_KEY_DELETE:
|
||||
nk_input_key(ui_, NK_KEY_DEL, press);
|
||||
break;
|
||||
case GLFW_KEY_ENTER:
|
||||
nk_input_key(ui_, NK_KEY_ENTER, press);
|
||||
break;
|
||||
case GLFW_KEY_TAB:
|
||||
nk_input_key(ui_, NK_KEY_TAB, press);
|
||||
break;
|
||||
case GLFW_KEY_BACKSPACE:
|
||||
nk_input_key(ui_, NK_KEY_BACKSPACE, press);
|
||||
break;
|
||||
case GLFW_KEY_UP:
|
||||
nk_input_key(ui_, NK_KEY_UP, press);
|
||||
break;
|
||||
case GLFW_KEY_DOWN:
|
||||
nk_input_key(ui_, NK_KEY_DOWN, press);
|
||||
break;
|
||||
case GLFW_KEY_HOME:
|
||||
nk_input_key(ui_, NK_KEY_TEXT_START, press);
|
||||
nk_input_key(ui_, NK_KEY_SCROLL_START, press);
|
||||
break;
|
||||
case GLFW_KEY_END:
|
||||
nk_input_key(ui_, NK_KEY_TEXT_END, press);
|
||||
nk_input_key(ui_, NK_KEY_SCROLL_END, press);
|
||||
break;
|
||||
case GLFW_KEY_PAGE_DOWN:
|
||||
nk_input_key(ui_, NK_KEY_SCROLL_DOWN, press);
|
||||
break;
|
||||
case GLFW_KEY_PAGE_UP:
|
||||
nk_input_key(ui_, NK_KEY_SCROLL_UP, press);
|
||||
break;
|
||||
case GLFW_KEY_LEFT_SHIFT:
|
||||
case GLFW_KEY_RIGHT_SHIFT:
|
||||
nk_input_key(ui_, NK_KEY_SHIFT, press);
|
||||
break;
|
||||
// case GLFW_KEY_LEFT_CONTROL:
|
||||
// case GLFW_KEY_RIGHT_CONTROL:
|
||||
// if (press) {
|
||||
// nk_input_key(ui.get(), NK_KEY_COPY, glfwGetKey(window, GLFW_KEY_C) == GLFW_PRESS);
|
||||
// nk_input_key(ui.get(), NK_KEY_PASTE, glfwGetKey(window, GLFW_KEY_P) == GLFW_PRESS);
|
||||
// nk_input_key(ui.get(), NK_KEY_CUT, glfwGetKey(window, GLFW_KEY_X) == GLFW_PRESS);
|
||||
// nk_input_key(ui.get(), NK_KEY_TEXT_UNDO, glfwGetKey(window, GLFW_KEY_Z) == GLFW_PRESS);
|
||||
// nk_input_key(ui.get(), NK_KEY_TEXT_REDO, glfwGetKey(window, GLFW_KEY_R) == GLFW_PRESS);
|
||||
// nk_input_key(ui.get(), NK_KEY_TEXT_WORD_LEFT, glfwGetKey(window, GLFW_KEY_LEFT) == GLFW_PRESS);
|
||||
// nk_input_key(ui.get(), NK_KEY_TEXT_WORD_RIGHT, glfwGetKey(window, GLFW_KEY_RIGHT) == GLFW_PRESS);
|
||||
// nk_input_key(ui.get(), NK_KEY_TEXT_LINE_START, glfwGetKey(window, GLFW_KEY_B) == GLFW_PRESS);
|
||||
// nk_input_key(ui.get(), NK_KEY_TEXT_LINE_END, glfwGetKey(window, GLFW_KEY_E) == GLFW_PRESS);
|
||||
// } else {
|
||||
// nk_input_key(ui.get(), NK_KEY_LEFT, glfwGetKey(window, GLFW_KEY_LEFT) == GLFW_PRESS);
|
||||
// nk_input_key(ui.get(), NK_KEY_RIGHT, glfwGetKey(window, GLFW_KEY_RIGHT) == GLFW_PRESS);
|
||||
// nk_input_key(ui.get(), NK_KEY_COPY, false);
|
||||
// nk_input_key(ui.get(), NK_KEY_PASTE, false);
|
||||
// nk_input_key(ui.get(), NK_KEY_CUT, false);
|
||||
// nk_input_key(ui.get(), NK_KEY_SHIFT, false);
|
||||
// }
|
||||
// break;
|
||||
}
|
||||
});
|
||||
|
||||
window.listen<Events::CursorPos>([this](auto ev) {
|
||||
nk_input_motion(ui.get(), ev.x, ev.y);
|
||||
});
|
||||
|
||||
window.listen<Events::Action>([this](auto ev) {
|
||||
nk_buttons type;
|
||||
switch(ev.type) {
|
||||
case Events::ActionType::PRIMARY:
|
||||
type = NK_BUTTON_LEFT;
|
||||
break;
|
||||
case Events::ActionType::SECONDARY:
|
||||
type = NK_BUTTON_RIGHT;
|
||||
break;
|
||||
case Events::ActionType::TERTIARY:
|
||||
type = NK_BUTTON_MIDDLE;
|
||||
break;
|
||||
default:
|
||||
return;
|
||||
}
|
||||
nk_input_button(ui.get(), type, (int)ev.x, (int)ev.y, ev.state);
|
||||
});
|
||||
|
||||
int atlasWidth, atlasHeight;
|
||||
std::vector<unsigned char> atlasData;
|
||||
if (!world->nodeRegistry.generateTextureAtlas(atlasWidth, atlasHeight, atlasData)) {
|
||||
std::cerr << "Failed to generate texture atlas\n";
|
||||
return;
|
||||
}
|
||||
|
||||
std::cout << "Creating texture atlas..." << std::endl;
|
||||
|
||||
nodeTextureAtlas = Util::createTextureFromData(device, queue, atlasData.data(), atlasWidth, atlasHeight);
|
||||
if (!nodeTextureAtlas->texture || !nodeTextureAtlas->view) {
|
||||
std::cerr << "Failed to load texture atlas\n";
|
||||
return;
|
||||
}
|
||||
|
||||
std::cout << "Texture atlas created." << std::endl;
|
||||
|
||||
// MARK: Setup pipelines
|
||||
|
||||
reloadShaders();
|
||||
|
||||
dispatch(Events::Initialized{});
|
||||
}
|
||||
|
||||
void Engine::reloadShaders() {
|
||||
makeWorldPipelines();
|
||||
makeObjectPipeline();
|
||||
makeUIPipeline();
|
||||
dispatch(Events::PipelineReload{});
|
||||
}
|
||||
|
||||
void Engine::makeWorldPipelines() {
|
||||
WGPUBufferDescriptor uniformBufferDesc = {};
|
||||
uniformBufferDesc.size = sizeof(glm::mat4);
|
||||
uniformBufferDesc.usage = WGPUBufferUsage_Uniform | WGPUBufferUsage_CopyDst;
|
||||
worldUniformBuffer = wgpuDeviceCreateBuffer(device, &uniformBufferDesc);
|
||||
if (!worldUniformBuffer) {
|
||||
std::cerr << "Failed to create uniform buffer" << std::endl;
|
||||
return;
|
||||
}
|
||||
|
||||
WGPUSamplerDescriptor samplerDesc = {};
|
||||
samplerDesc.addressModeU = WGPUAddressMode_Repeat;
|
||||
samplerDesc.addressModeV = WGPUAddressMode_Repeat;
|
||||
samplerDesc.addressModeW = WGPUAddressMode_Repeat;
|
||||
samplerDesc.magFilter = WGPUFilterMode_Nearest;
|
||||
samplerDesc.minFilter = WGPUFilterMode_Nearest;
|
||||
samplerDesc.mipmapFilter = WGPUMipmapFilterMode_Linear;
|
||||
samplerDesc.maxAnisotropy = 1;
|
||||
worldSampler = wgpuDeviceCreateSampler(device, &samplerDesc);
|
||||
if (!worldSampler) {
|
||||
std::cerr << "Failed to create sampler" << std::endl;
|
||||
return;
|
||||
}
|
||||
|
||||
WGPUBindGroupLayoutEntry bglEntries[3] = {};
|
||||
bglEntries[0].binding = 0;
|
||||
bglEntries[0].visibility = WGPUShaderStage_Vertex;
|
||||
bglEntries[0].buffer.type = WGPUBufferBindingType_Uniform;
|
||||
bglEntries[1].binding = 1;
|
||||
bglEntries[1].visibility = WGPUShaderStage_Fragment;
|
||||
bglEntries[1].texture.sampleType = WGPUTextureSampleType_Float;
|
||||
bglEntries[1].texture.viewDimension = WGPUTextureViewDimension_2D;
|
||||
bglEntries[2].binding = 2;
|
||||
bglEntries[2].visibility = WGPUShaderStage_Fragment;
|
||||
bglEntries[2].sampler.type = WGPUSamplerBindingType_Filtering;
|
||||
|
||||
WGPUBindGroupLayoutDescriptor bglDesc = {};
|
||||
bglDesc.entryCount = 3;
|
||||
bglDesc.entries = bglEntries;
|
||||
worldBgl = wgpuDeviceCreateBindGroupLayout(device, &bglDesc);
|
||||
if (!worldBgl) {
|
||||
std::cerr << "Failed to create bind group layout" << std::endl;
|
||||
return;
|
||||
}
|
||||
|
||||
WGPUBindGroupEntry bgEntries[3] = {};
|
||||
bgEntries[0].binding = 0;
|
||||
bgEntries[0].buffer = worldUniformBuffer;
|
||||
bgEntries[0].offset = 0;
|
||||
bgEntries[0].size = sizeof(glm::mat4);
|
||||
bgEntries[1].binding = 1;
|
||||
bgEntries[1].textureView = nodeTextureAtlas->view;
|
||||
bgEntries[2].binding = 2;
|
||||
bgEntries[2].sampler = worldSampler;
|
||||
|
||||
WGPUBindGroupDescriptor bgDesc = {};
|
||||
bgDesc.layout = worldBgl;
|
||||
bgDesc.entryCount = 3;
|
||||
bgDesc.entries = bgEntries;
|
||||
worldBindGroup = wgpuDeviceCreateBindGroup(device, &bgDesc);
|
||||
if (!worldBindGroup) {
|
||||
std::cerr << "Failed to create cube bind group" << std::endl;
|
||||
return;
|
||||
}
|
||||
|
||||
const char* cubeVSCode = R"(
|
||||
struct Uniforms {
|
||||
mvp: mat4x4<f32>,
|
||||
}
|
||||
@group(0) @binding(0) var<uniform> uniforms: Uniforms;
|
||||
struct VertexOutput {
|
||||
@builtin(position) pos: vec4<f32>,
|
||||
@location(0) uv: vec2<f32>
|
||||
}
|
||||
@vertex
|
||||
fn vs_main(
|
||||
@location(0) pos: vec3<f32>,
|
||||
@location(1) uv: vec2<f32>
|
||||
) -> VertexOutput {
|
||||
var out: VertexOutput;
|
||||
out.pos = uniforms.mvp * vec4<f32>(pos, 1.0);
|
||||
out.uv = uv;
|
||||
return out;
|
||||
}
|
||||
)";
|
||||
|
||||
const char* cubeFSCode = R"(
|
||||
@group(0) @binding(1) var texture: texture_2d<f32>;
|
||||
@group(0) @binding(2) var sampler_: sampler;
|
||||
@fragment
|
||||
fn fs_main(
|
||||
@location(0) uv: vec2<f32>
|
||||
) -> @location(0) vec4<f32> {
|
||||
var color = textureSample(texture, sampler_, uv);
|
||||
return color;
|
||||
}
|
||||
)";
|
||||
|
||||
WGPUShaderModuleDescriptor cubeVSDesc = {};
|
||||
WGPUShaderSourceWGSL src = {.code = WGPUStringView{cubeVSCode, WGPU_STRLEN}};
|
||||
src.chain.sType = WGPUSType_ShaderSourceWGSL;
|
||||
cubeVSDesc.nextInChain = &src.chain;
|
||||
WGPUShaderModule cubeVSModule = wgpuDeviceCreateShaderModule(device, &cubeVSDesc);
|
||||
|
||||
WGPUShaderModuleDescriptor cubeFSDesc = {};
|
||||
src = {.code = WGPUStringView{cubeFSCode, WGPU_STRLEN}};
|
||||
src.chain.sType = WGPUSType_ShaderSourceWGSL;
|
||||
cubeFSDesc.nextInChain = &src.chain;
|
||||
WGPUShaderModule cubeFSModule = wgpuDeviceCreateShaderModule(device, &cubeFSDesc);
|
||||
|
||||
WGPUVertexAttribute cubeAttributes[2] = {};
|
||||
cubeAttributes[0].format = WGPUVertexFormat_Float32x3;
|
||||
cubeAttributes[0].offset = offsetof(Vertex, pos);
|
||||
cubeAttributes[0].shaderLocation = 0;
|
||||
cubeAttributes[1].format = WGPUVertexFormat_Float32x2;
|
||||
cubeAttributes[1].offset = offsetof(Vertex, uv);
|
||||
cubeAttributes[1].shaderLocation = 1;
|
||||
|
||||
WGPUVertexBufferLayout cubeVBLayout = {};
|
||||
cubeVBLayout.arrayStride = sizeof(Vertex);
|
||||
cubeVBLayout.stepMode = WGPUVertexStepMode_Vertex;
|
||||
cubeVBLayout.attributeCount = 2;
|
||||
cubeVBLayout.attributes = cubeAttributes;
|
||||
|
||||
WGPUPipelineLayoutDescriptor plDesc = {};
|
||||
plDesc.bindGroupLayoutCount = 1;
|
||||
plDesc.bindGroupLayouts = &worldBgl;
|
||||
WGPUPipelineLayout pipelineLayout = wgpuDeviceCreatePipelineLayout(device, &plDesc);
|
||||
|
||||
WGPUColorTargetState cubeColorTarget = {};
|
||||
cubeColorTarget.format = surfaceFormat;
|
||||
cubeColorTarget.writeMask = WGPUColorWriteMask_All;
|
||||
|
||||
WGPUFragmentState cubeFragmentState = {};
|
||||
cubeFragmentState.module = cubeFSModule;
|
||||
cubeFragmentState.entryPoint = WGPUStringView{"fs_main", WGPU_STRLEN};
|
||||
cubeFragmentState.targetCount = 1;
|
||||
cubeFragmentState.targets = &cubeColorTarget;
|
||||
|
||||
WGPUDepthStencilState depthStencilState = {};
|
||||
depthStencilState.format = WGPUTextureFormat_Depth24Plus;
|
||||
depthStencilState.depthWriteEnabled = WGPUOptionalBool_True;
|
||||
depthStencilState.depthCompare = WGPUCompareFunction_Less;
|
||||
|
||||
|
||||
WGPURenderPipelineDescriptor cubePipelineDesc = {};
|
||||
cubePipelineDesc.vertex.module = cubeVSModule;
|
||||
cubePipelineDesc.vertex.entryPoint = WGPUStringView{"vs_main", WGPU_STRLEN};
|
||||
cubePipelineDesc.vertex.bufferCount = 1;
|
||||
cubePipelineDesc.vertex.buffers = &cubeVBLayout;
|
||||
cubePipelineDesc.fragment = &cubeFragmentState;
|
||||
cubePipelineDesc.primitive.topology = WGPUPrimitiveTopology_TriangleList;
|
||||
cubePipelineDesc.primitive.frontFace = WGPUFrontFace_CCW;
|
||||
cubePipelineDesc.primitive.cullMode = WGPUCullMode_None;
|
||||
cubePipelineDesc.depthStencil = &depthStencilState;
|
||||
cubePipelineDesc.layout = pipelineLayout;
|
||||
cubePipelineDesc.multisample.count = 1;
|
||||
cubePipelineDesc.multisample.mask = ~0u;
|
||||
|
||||
worldPipeline = wgpuDeviceCreateRenderPipeline(device, &cubePipelineDesc);
|
||||
std::cout << "Created world pipeline." << std::endl;
|
||||
}
|
||||
|
||||
void Engine::makeObjectPipeline() {
|
||||
|
||||
}
|
||||
|
||||
void Engine::makeUIPipeline() {
|
||||
WGPUBufferDescriptor uiVertexBufferDesc = {};
|
||||
uiVertexBufferDesc.size = 1024 * 1024 * sizeof(NKVertex);
|
||||
uiVertexBufferDesc.usage = WGPUBufferUsage_Vertex | WGPUBufferUsage_CopyDst;
|
||||
uiVertexBufferDesc.label = WGPUStringView{"UI Vertex Buffer", WGPU_STRLEN};
|
||||
uiVertexBuffer = wgpuDeviceCreateBuffer(device, &uiVertexBufferDesc);
|
||||
|
||||
WGPUBufferDescriptor uiIndexBufferDesc = {};
|
||||
uiIndexBufferDesc.size = 1024 * 1024 * sizeof(uint16_t);
|
||||
uiIndexBufferDesc.usage = WGPUBufferUsage_Index | WGPUBufferUsage_CopyDst;
|
||||
uiIndexBufferDesc.label = WGPUStringView{"UI Index Buffer", WGPU_STRLEN};
|
||||
uiIndexBuffer = wgpuDeviceCreateBuffer(device, &uiIndexBufferDesc);
|
||||
|
||||
WGPUBufferDescriptor uiUniformBufferDesc = {};
|
||||
uiUniformBufferDesc.size = sizeof(glm::mat4);
|
||||
uiUniformBufferDesc.usage = WGPUBufferUsage_Uniform | WGPUBufferUsage_CopyDst;
|
||||
uiUniformBufferDesc.label = WGPUStringView{"UI Uniform Buffer", WGPU_STRLEN};
|
||||
uiUniformBuffer = wgpuDeviceCreateBuffer(device, &uiUniformBufferDesc);
|
||||
|
||||
std::string uiVSCode = R"(
|
||||
struct Uniforms {
|
||||
ortho: mat4x4<f32>,
|
||||
}
|
||||
@group(0) @binding(0) var<uniform> uniforms: Uniforms;
|
||||
struct VertexOutput {
|
||||
@builtin(position) pos: vec4<f32>,
|
||||
@location(0) uv: vec2<f32>,
|
||||
@location(1) color: vec4<f32>,
|
||||
}
|
||||
@vertex
|
||||
fn vs_main(@location(0) pos: vec2<f32>, @location(1) uv: vec2<f32>, @location(2) color: vec4<f32>) -> VertexOutput {
|
||||
var out: VertexOutput;
|
||||
out.pos = uniforms.ortho * vec4<f32>(pos, 0.0, 1.0);
|
||||
out.uv = uv;
|
||||
out.color = color;
|
||||
return out;
|
||||
}
|
||||
)";
|
||||
std::string uiFSCode = R"(
|
||||
@group(0) @binding(1) var texture: texture_2d<f32>;
|
||||
@group(0) @binding(2) var sampler_: sampler;
|
||||
@fragment
|
||||
fn fs_main(@location(0) uv: vec2<f32>, @location(1) color: vec4<f32>) -> @location(0) vec4<f32> {
|
||||
return textureSample(texture, sampler_, uv) * color;
|
||||
}
|
||||
)";
|
||||
|
||||
WGPUShaderModuleDescriptor uiVSDesc = {};
|
||||
WGPUShaderSourceWGSL src = {.code = WGPUStringView{uiVSCode.c_str(), uiVSCode.size()}};
|
||||
src.chain.sType = WGPUSType_ShaderSourceWGSL;
|
||||
uiVSDesc.nextInChain = &src.chain;
|
||||
WGPUShaderModule uiVSModule = wgpuDeviceCreateShaderModule(device, &uiVSDesc);
|
||||
|
||||
WGPUShaderModuleDescriptor uiFSDesc = {};
|
||||
src = {.code = WGPUStringView{uiFSCode.c_str(), uiFSCode.size()}};
|
||||
src.chain.sType = WGPUSType_ShaderSourceWGSL;
|
||||
uiFSDesc.nextInChain = &src.chain;
|
||||
WGPUShaderModule uiFSModule = wgpuDeviceCreateShaderModule(device, &uiFSDesc);
|
||||
|
||||
WGPUSamplerDescriptor uiSamplerDesc = {};
|
||||
uiSamplerDesc.addressModeU = WGPUAddressMode_ClampToEdge;
|
||||
uiSamplerDesc.addressModeV = WGPUAddressMode_ClampToEdge;
|
||||
uiSamplerDesc.addressModeW = WGPUAddressMode_ClampToEdge;
|
||||
uiSamplerDesc.magFilter = WGPUFilterMode_Linear;
|
||||
uiSamplerDesc.minFilter = WGPUFilterMode_Linear;
|
||||
uiSamplerDesc.mipmapFilter = WGPUMipmapFilterMode_Linear;
|
||||
uiSamplerDesc.maxAnisotropy = 1;
|
||||
uiSampler = wgpuDeviceCreateSampler(device, &uiSamplerDesc);
|
||||
if (!uiSampler) {
|
||||
std::cerr << "Failed to create UI sampler" << std::endl;
|
||||
return;
|
||||
}
|
||||
|
||||
WGPUBindGroupLayoutEntry uiBglEntries[3] = {};
|
||||
uiBglEntries[0].binding = 0;
|
||||
uiBglEntries[0].visibility = WGPUShaderStage_Vertex;
|
||||
uiBglEntries[0].buffer.type = WGPUBufferBindingType_Uniform;
|
||||
uiBglEntries[1].binding = 1;
|
||||
uiBglEntries[1].visibility = WGPUShaderStage_Fragment;
|
||||
uiBglEntries[1].texture.sampleType = WGPUTextureSampleType_Float;
|
||||
uiBglEntries[1].texture.viewDimension = WGPUTextureViewDimension_2D;
|
||||
uiBglEntries[2].binding = 2;
|
||||
uiBglEntries[2].visibility = WGPUShaderStage_Fragment;
|
||||
uiBglEntries[2].sampler.type = WGPUSamplerBindingType_Filtering;
|
||||
|
||||
WGPUBindGroupLayoutDescriptor uiBglDesc = {};
|
||||
uiBglDesc.entryCount = 3;
|
||||
uiBglDesc.entries = uiBglEntries;
|
||||
uiBgl = wgpuDeviceCreateBindGroupLayout(device, &uiBglDesc);
|
||||
if (!uiBgl) {
|
||||
std::cerr << "Failed to create bind group layout" << std::endl;
|
||||
return;
|
||||
}
|
||||
|
||||
WGPUVertexAttribute uiAttributes[3] = {};
|
||||
uiAttributes[0].format = WGPUVertexFormat_Float32x2;
|
||||
uiAttributes[0].offset = offsetof(NKVertex, pos);
|
||||
uiAttributes[0].shaderLocation = 0;
|
||||
uiAttributes[1].format = WGPUVertexFormat_Float32x2;
|
||||
uiAttributes[1].offset = offsetof(NKVertex, uv);
|
||||
uiAttributes[1].shaderLocation = 1;
|
||||
uiAttributes[2].format = WGPUVertexFormat_Unorm8x4;
|
||||
uiAttributes[2].offset = offsetof(NKVertex, color);
|
||||
uiAttributes[2].shaderLocation = 2;
|
||||
|
||||
WGPUVertexBufferLayout uiVBLayout = {};
|
||||
uiVBLayout.arrayStride = sizeof(NKVertex);
|
||||
uiVBLayout.stepMode = WGPUVertexStepMode_Vertex;
|
||||
uiVBLayout.attributeCount = 3;
|
||||
uiVBLayout.attributes = uiAttributes;
|
||||
|
||||
WGPUBlendState uiBlendState = {};
|
||||
uiBlendState.color.srcFactor = WGPUBlendFactor_SrcAlpha;
|
||||
uiBlendState.color.dstFactor = WGPUBlendFactor_OneMinusSrcAlpha;
|
||||
uiBlendState.color.operation = WGPUBlendOperation_Add;
|
||||
uiBlendState.alpha.srcFactor = WGPUBlendFactor_One;
|
||||
uiBlendState.alpha.dstFactor = WGPUBlendFactor_OneMinusSrcAlpha;
|
||||
uiBlendState.alpha.operation = WGPUBlendOperation_Add;
|
||||
|
||||
WGPUColorTargetState uiColorTarget = {};
|
||||
uiColorTarget.format = surfaceFormat;
|
||||
uiColorTarget.blend = &uiBlendState;
|
||||
uiColorTarget.writeMask = WGPUColorWriteMask_All;
|
||||
|
||||
WGPUFragmentState uiFragmentState = {};
|
||||
uiFragmentState.module = uiFSModule;
|
||||
uiFragmentState.entryPoint = WGPUStringView{"fs_main", WGPU_STRLEN};
|
||||
uiFragmentState.targetCount = 1;
|
||||
uiFragmentState.targets = &uiColorTarget;
|
||||
|
||||
WGPUPipelineLayoutDescriptor uiPlDesc = {};
|
||||
uiPlDesc.bindGroupLayoutCount = 1;
|
||||
uiPlDesc.bindGroupLayouts = &uiBgl;
|
||||
WGPUPipelineLayout uiPipelineLayout = wgpuDeviceCreatePipelineLayout(device, &uiPlDesc);
|
||||
|
||||
WGPURenderPipelineDescriptor uiPipelineDesc = {};
|
||||
uiPipelineDesc.vertex.module = uiVSModule;
|
||||
uiPipelineDesc.vertex.entryPoint = WGPUStringView{"vs_main", WGPU_STRLEN};
|
||||
uiPipelineDesc.vertex.bufferCount = 1;
|
||||
uiPipelineDesc.vertex.buffers = &uiVBLayout;
|
||||
uiPipelineDesc.fragment = &uiFragmentState;
|
||||
uiPipelineDesc.primitive.topology = WGPUPrimitiveTopology_TriangleList;
|
||||
uiPipelineDesc.primitive.frontFace = WGPUFrontFace_CCW;
|
||||
uiPipelineDesc.primitive.cullMode = WGPUCullMode_None;
|
||||
uiPipelineDesc.layout = uiPipelineLayout;
|
||||
uiPipelineDesc.multisample.count = 1;
|
||||
uiPipelineDesc.multisample.mask = ~0u;
|
||||
|
||||
uiPipeline = wgpuDeviceCreateRenderPipeline(device, &uiPipelineDesc);
|
||||
}
|
||||
|
||||
// Default main loop handler.
|
||||
void Engine::run() {
|
||||
init();
|
||||
|
||||
time_t last_time;
|
||||
time(&last_time);
|
||||
|
||||
while(!window.shouldClose()) {
|
||||
nk_input_begin(ui.get());
|
||||
glfwPollEvents();
|
||||
nk_input_end(ui.get());
|
||||
render();
|
||||
time_t now;
|
||||
time(&now);
|
||||
if(now - last_time > STEP_SIZE) {
|
||||
tick();
|
||||
dispatch(Events::Tick{now - last_time});
|
||||
last_time = now;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void Engine::render() {
|
||||
dispatch(Events::DrawUI{ui.get()});
|
||||
|
||||
nk_buffer_clear(&uiVertexBufferNK);
|
||||
nk_buffer_clear(&uiIndexBufferNK);
|
||||
nk_buffer_clear(&uiCommandBufferNK);
|
||||
struct nk_convert_config config = {};
|
||||
static const struct nk_draw_vertex_layout_element vertex_layout[] = {
|
||||
{NK_VERTEX_POSITION, NK_FORMAT_FLOAT, NK_OFFSETOF(NKVertex, pos)},
|
||||
{NK_VERTEX_TEXCOORD, NK_FORMAT_FLOAT, NK_OFFSETOF(NKVertex, uv)},
|
||||
{NK_VERTEX_COLOR, NK_FORMAT_R8G8B8A8, NK_OFFSETOF(NKVertex, color)},
|
||||
{NK_VERTEX_LAYOUT_END}
|
||||
};
|
||||
config.vertex_layout = vertex_layout;
|
||||
config.vertex_size = sizeof(NKVertex);
|
||||
config.vertex_alignment = alignof(NKVertex);
|
||||
config.tex_null.texture = nk_handle_id(0);
|
||||
config.tex_null.uv = {0.0f, 0.0f};
|
||||
config.circle_segment_count = 22;
|
||||
config.curve_segment_count = 22;
|
||||
config.arc_segment_count = 22;
|
||||
config.global_alpha = 1.0f;
|
||||
config.shape_AA = NK_ANTI_ALIASING_ON;
|
||||
config.line_AA = NK_ANTI_ALIASING_ON;
|
||||
nk_convert(ui.get(), &uiCommandBufferNK, &uiVertexBufferNK, &uiIndexBufferNK, &config);
|
||||
|
||||
|
||||
ortho = glm::ortho(0.0f, (float)viewportWidth, (float)viewportHeight, 0.0f, -1.0f, 1.0f);
|
||||
wgpuQueueWriteBuffer(queue, uiUniformBuffer, 0, &ortho, sizeof(ortho));
|
||||
|
||||
WGPUSurfaceTexture surfaceTexture;
|
||||
wgpuSurfaceGetCurrentTexture(surface, &surfaceTexture);
|
||||
if (surfaceTexture.status == WGPUSurfaceGetCurrentTextureStatus_Error || !surfaceTexture.texture) {
|
||||
std::cerr << "Failed to get surface texture" << std::endl;
|
||||
return;
|
||||
}
|
||||
WGPUTextureView nextTexture = wgpuTextureCreateView(surfaceTexture.texture, nullptr);
|
||||
if (!nextTexture) {
|
||||
std::cerr << "Failed to create texture view" << std::endl;
|
||||
return;
|
||||
}
|
||||
|
||||
WGPUCommandEncoder encoder = wgpuDeviceCreateCommandEncoder(device, nullptr);
|
||||
|
||||
for(const auto &pair : world->chunks) {
|
||||
chunkRenderer->render(pair.first, pair.second.get(), encoder, nextTexture);
|
||||
}
|
||||
|
||||
WGPURenderPassColorAttachment colorAttachment = {};
|
||||
colorAttachment.view = nextTexture;
|
||||
colorAttachment.loadOp = WGPULoadOp_Clear;
|
||||
colorAttachment.storeOp = WGPUStoreOp_Store;
|
||||
colorAttachment.clearValue = {0, 0.2, 0.4, 1};
|
||||
colorAttachment.depthSlice = -1;
|
||||
|
||||
WGPURenderPassDepthStencilAttachment depthAttachment = {};
|
||||
depthAttachment.view = depthTexture->view;
|
||||
depthAttachment.depthLoadOp = WGPULoadOp_Clear;
|
||||
depthAttachment.depthStoreOp = WGPUStoreOp_Store;
|
||||
depthAttachment.depthClearValue = 1.0f;
|
||||
depthAttachment.depthReadOnly = false;
|
||||
depthAttachment.stencilLoadOp = WGPULoadOp_Undefined;
|
||||
depthAttachment.stencilStoreOp = WGPUStoreOp_Undefined;
|
||||
|
||||
WGPURenderPassDescriptor renderPassDesc = {};
|
||||
renderPassDesc.colorAttachmentCount = 1;
|
||||
renderPassDesc.colorAttachments = &colorAttachment;
|
||||
renderPassDesc.depthStencilAttachment = &depthAttachment;
|
||||
|
||||
colorAttachment.loadOp = WGPULoadOp_Load;
|
||||
WGPURenderPassDescriptor uiRenderPassDesc = {};
|
||||
uiRenderPassDesc.colorAttachmentCount = 1;
|
||||
uiRenderPassDesc.colorAttachments = &colorAttachment;
|
||||
|
||||
WGPURenderPassEncoder uiRenderPass = wgpuCommandEncoderBeginRenderPass(encoder, &uiRenderPassDesc);
|
||||
wgpuRenderPassEncoderSetPipeline(uiRenderPass, uiPipeline);
|
||||
wgpuRenderPassEncoderSetViewport(uiRenderPass, 0, 0, (float)viewportWidth, (float)viewportHeight, 0.0f, 1.0f);
|
||||
|
||||
|
||||
size_t vertexSize = nk_buffer_total(&uiVertexBufferNK);
|
||||
size_t indexSize = nk_buffer_total(&uiIndexBufferNK);
|
||||
if (vertexSize > 0 && indexSize > 0) {
|
||||
wgpuQueueWriteBuffer(queue, uiVertexBuffer, 0, uiVertexBufferNK.memory.ptr, vertexSize);
|
||||
wgpuQueueWriteBuffer(queue, uiIndexBuffer, 0, uiIndexBufferNK.memory.ptr, indexSize);
|
||||
|
||||
wgpuRenderPassEncoderSetVertexBuffer(uiRenderPass, 0, uiVertexBuffer, 0, vertexSize);
|
||||
wgpuRenderPassEncoderSetIndexBuffer(uiRenderPass, uiIndexBuffer, WGPUIndexFormat_Uint16, 0, indexSize);
|
||||
|
||||
std::vector<WGPUBindGroup> bindGroups;
|
||||
WGPUBindGroupEntry uiBgEntries[3] = {};
|
||||
uiBgEntries[0].binding = 0;
|
||||
uiBgEntries[0].buffer = uiUniformBuffer;
|
||||
uiBgEntries[0].offset = 0;
|
||||
uiBgEntries[0].size = sizeof(glm::mat4);
|
||||
uiBgEntries[2].binding = 2;
|
||||
uiBgEntries[2].sampler = uiSampler;
|
||||
|
||||
std::map<int, WGPUTextureView> textureMap = {{0, uiFontTexture->view}};
|
||||
const struct nk_draw_command* cmd;
|
||||
uint32_t offset = 0;
|
||||
nk_draw_foreach(cmd, ui.get(), &uiCommandBufferNK) {
|
||||
if (!cmd->elem_count) continue;
|
||||
if (offset + cmd->elem_count > indexSize / sizeof(uint16_t)) break;
|
||||
|
||||
uint32_t scissorX = static_cast<uint32_t>(cmd->clip_rect.x < 0 ? 0 : cmd->clip_rect.x);
|
||||
uint32_t scissorY = static_cast<uint32_t>(cmd->clip_rect.y < 0 ? 0 : cmd->clip_rect.y);
|
||||
uint32_t scissorW = static_cast<uint32_t>(cmd->clip_rect.w);
|
||||
uint32_t scissorH = static_cast<uint32_t>(cmd->clip_rect.h);
|
||||
scissorX = std::min(scissorX, (uint32_t)viewportWidth - 1);
|
||||
scissorY = std::min(scissorY, (uint32_t)viewportHeight - 1);
|
||||
if (scissorW > viewportWidth || scissorH > viewportHeight || scissorX + scissorW > viewportWidth || scissorY + scissorH > viewportHeight) {
|
||||
scissorW = std::min(scissorW, viewportWidth - scissorX);
|
||||
scissorH = std::min(scissorH, viewportHeight - scissorY);
|
||||
}
|
||||
wgpuRenderPassEncoderSetScissorRect(uiRenderPass, scissorX, scissorY, scissorW, scissorH);
|
||||
|
||||
uiBgEntries[1].binding = 1;
|
||||
uiBgEntries[1].textureView = cmd->texture.id >= 0 && textureMap.count(cmd->texture.id) ? textureMap[cmd->texture.id] : uiDummyTexture->view;
|
||||
|
||||
WGPUBindGroupDescriptor uiBgDesc = {};
|
||||
uiBgDesc.layout = uiBgl;
|
||||
uiBgDesc.entryCount = 3;
|
||||
uiBgDesc.entries = uiBgEntries;
|
||||
|
||||
WGPUBindGroup uiDynamicBindGroup = wgpuDeviceCreateBindGroup(device, &uiBgDesc);
|
||||
bindGroups.push_back(uiDynamicBindGroup);
|
||||
|
||||
wgpuRenderPassEncoderSetBindGroup(uiRenderPass, 0, uiDynamicBindGroup, 0, nullptr);
|
||||
wgpuRenderPassEncoderDrawIndexed(uiRenderPass, cmd->elem_count, 1, offset, 0, 0);
|
||||
|
||||
offset += cmd->elem_count;
|
||||
}
|
||||
wgpuRenderPassEncoderEnd(uiRenderPass);
|
||||
for (WGPUBindGroup bg : bindGroups) wgpuBindGroupRelease(bg);
|
||||
} else {
|
||||
wgpuRenderPassEncoderEnd(uiRenderPass);
|
||||
}
|
||||
|
||||
WGPUCommandBufferDescriptor cmdBufferDesc = {};
|
||||
cmdBufferDesc.label = WGPUStringView{"Command buffer", WGPU_STRLEN};
|
||||
WGPUCommandBuffer cmdBuffer = wgpuCommandEncoderFinish(encoder, nullptr);
|
||||
wgpuQueueSubmit(queue, 1, &cmdBuffer);
|
||||
#ifndef WASM_BUILD
|
||||
wgpuSurfacePresent(surface);
|
||||
#endif
|
||||
wgpuTextureViewRelease(nextTexture);
|
||||
wgpuTextureRelease(surfaceTexture.texture);
|
||||
nk_clear(ui.get());
|
||||
}
|
||||
|
||||
void Engine::tick() {
|
||||
if(server) server->tick();
|
||||
}
|
||||
|
||||
}
|
||||
//*/
|
||||
Loading…
Add table
Add a link
Reference in a new issue