argon
/
tacraft
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
tacraft/main.cpp

511 lines
24 KiB
C++
Raw Permalink Normal View History

first commit
2022-12-15 02:28:00 +00:00
#include <iostream>
#include <cstdio>
#define GLFW_INCLUDE_NONE
#define GLFW_INCLUDE_VULKAN
#include <GLFW/glfw3.h>
#include "rusty.hpp"
#include "vulkan.hpp"
#include "tmath.hpp"
#include "image.hpp"
#include "model_object.hpp"
const uint32_t object_matrix_count = 2048;
struct GlobalVars {
tmath::fmat4 proj_view;
alignas(16) tmath::fvec3 light;
alignas(16) tmath::fvec3 eye;
};
class Application {
public:
~Application() {
if(device)
device->wait_idle();
swapchain.reset();
}
void init(GLFWwindow* window) {
mdl_objects.push_back(std::make_shared<mdo::MDLAxis>(verts));
field = std::make_shared<mdo::MDLField>(verts);
mdl_objects.push_back(field);
auto u1 = std::make_shared<mdo::MDLUnit1>(verts);
u1->set_pos(0, 0);
mdl_objects.push_back(u1);
auto u4 = std::make_shared<mdo::MDLUnit1>(verts);
u4->set_pos(4, 0);
u1->attack(*u4, 0.4f);
mdl_objects.push_back(u4);
this->window = window;
uint32_t ext_count;
const char** ext_names = glfwGetRequiredInstanceExtensions(&ext_count);
instance = vk::Instance::begin_build().set_application_name("Tacraft").set_enging_name("tacraft")
.set_layers({"VK_LAYER_LUNARG_standard_validation"})
.set_extensions(rs::vector<const char*>(ext_names, ext_names + ext_count))
.end();
physical_device = instance->enumerate_physical_device().nth(0).value();
auto maxsample = std::min(physical_device->properties()->limits.framebufferColorSampleCounts,
physical_device->properties()->limits.framebufferDepthSampleCounts);
VkSurfaceKHR raw_surface;
glfwCreateWindowSurface(instance->handle(), window, nullptr, &raw_surface);
surface = vk::Surface::from_raw_surface(raw_surface, *instance, *physical_device);
auto findex = physical_device->enumerate_queue_families().enumerate().filter([&](size_t idx, const VkQueueFamilyProperties* p) -> bool {
VkBool32 support_present = false;
vkGetPhysicalDeviceSurfaceSupportKHR(physical_device->handle(), idx, raw_surface, &support_present);
return (p->queueFlags & VK_QUEUE_GRAPHICS_BIT) != 0 && support_present
&& glfwGetPhysicalDevicePresentationSupport(instance->handle(), physical_device->handle(), idx);
}).unzip().first.nth(0).value();
device = vk::Device::begin_build(*physical_device).set_extensions({"VK_KHR_swapchain"})
.add_queue_family(findex, 1.0f).add_queue_family(findex, 1.0f)
.enable_features(*physical_device->supported_features())
.end();
auto gqueue = device->enumerate_queues().next().value();
auto pqueue = device->enumerate_queues().next().value_or(gqueue);
graphic_queue = *gqueue;
present_queue = *pqueue;
vert_shader = vk::ShaderModule::load_from_src(*device, "./shader/shader.vert", vk::ShaderModule::shader_type_vertex);
if(!vert_shader) {
std::cout << "vertex shader null!" << std::endl;
return;
}
frag_shader = vk::ShaderModule::load_from_src(*device, "./shader/shader.frag", vk::ShaderModule::shader_type_fragment);
if(!frag_shader) {
std::cout << "fragment shader null!" << std::endl;
return;
}
render_pass = vk::RenderPass::begin_build(*device)
.set_samples(sample_count)
.end();
if(!render_pass) {
std::cout << "renderpass null!" << std::endl;
return;
}
auto& vertices = verts.all_vertices();
auto& vert_indices = verts.all_indices();
vertex_buffer = vk::Buffer::begin_build(*device, *physical_device).alloc_size(vertices.size() * sizeof(Vertex))
.set_usage(VK_BUFFER_USAGE_VERTEX_BUFFER_BIT)
.set_sharing_mode(VK_SHARING_MODE_EXCLUSIVE)
.set_cpu_accessible()
.end();
vertex_buffer->update_buffer(vertices.data(), vertices.size() * sizeof(Vertex));
index_buffer = vk::Buffer::begin_build(*device, *physical_device).alloc_size(vert_indices.size() * sizeof(uint32_t))
.set_usage(VK_BUFFER_USAGE_INDEX_BUFFER_BIT)
.set_sharing_mode(VK_SHARING_MODE_EXCLUSIVE)
.set_cpu_accessible()
.end();
index_buffer->update_buffer(vert_indices.data(), vert_indices.size() * sizeof(uint32_t));
auto image = Image::load_from_file("res/snow.tga");
auto [imgx, imgy] = image->img_size();
img_buffer = vk::Buffer::begin_build(*device, *physical_device).alloc_size(imgx * imgy * 4 + 64)
.set_usage(VK_BUFFER_USAGE_TRANSFER_SRC_BIT)
.set_sharing_mode(VK_SHARING_MODE_EXCLUSIVE)
.set_cpu_accessible()
.end();
img_buffer->update_buffer(image->img_data(), imgx * imgy * 4);
memset(img_buffer->map(imgx * imgy * 4, 64), 0xff, 64);
img_buffer->unmap();
teximage = vk::Image::begin_build(*device, *physical_device)
.set_device_local()
.set_format(VK_FORMAT_R8G8B8A8_UNORM)
.set_extent({(uint32_t)imgx, (uint32_t)imgy, 1})
.end();
teximage_view = teximage->create_view(VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_ASPECT_COLOR_BIT);
whiteimage = vk::Image::begin_build(*device, *physical_device)
.set_device_local()
.set_format(VK_FORMAT_R8G8B8A8_UNORM)
.set_extent({(uint32_t)4, (uint32_t)4, 1})
.end();
whiteimage_view = whiteimage->create_view(VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_ASPECT_COLOR_BIT);
sampler = vk::Sampler::begin_build(*device).set_anisotrophy(16.0f).end();
descriptor_set_layout = vk::DescriptorSetLayout::begin_build(*device)
.add_binding(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER).set_count(1).set_stage(VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT)
.add_binding(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER).set_count(1).set_stage(VK_SHADER_STAGE_VERTEX_BIT)
.add_binding(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER).set_count(2).set_stage(VK_SHADER_STAGE_FRAGMENT_BIT)
.end();
descriptor_pool = vk::DescriptorPool::begin_build(*device).set_max_sets(2)
.add_pool_size(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 16)
.add_pool_size(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 16)
.add_pool_size(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 16)
.end();
descriptor_sets = descriptor_pool->alloc_descriptor_set(*descriptor_set_layout, 2);
uint32_t buffer_size = 0x100 + sizeof(VertexAttribute) * object_matrix_count;
for(uint32_t i = 0; i < 2; ++i) {
uniform_buffers.emplace_back(vk::Buffer::begin_build(*device, *physical_device).alloc_size(buffer_size)
.set_usage(VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT)
.set_sharing_mode(VK_SHARING_MODE_EXCLUSIVE)
.set_cpu_accessible()
.end());
for(auto& ds : descriptor_sets) {
ds->update_write(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 0, 0)
.update_write_buffer_info(*uniform_buffers.back(), 0, sizeof(GlobalVars), 1)
.update_end();
ds->update_write(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, 0)
.update_write_buffer_info(*uniform_buffers.back(), 0x100, sizeof(VertexAttribute) * object_matrix_count, 1)
.update_write(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 2, 0)
.update_write_image_info(*whiteimage_view, *sampler)
.update_write_image_info(*teximage_view, *sampler)
.update_end();
}
}
draw_command_pool = vk::CommandPool::begin_build(*device)
.set_queue_family_index(graphic_queue.queue_family_index)
.set_pool_flag(VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT)
.end();
onetime_command_pool = vk::CommandPool::begin_build(*device)
.set_queue_family_index(graphic_queue.queue_family_index)
.set_pool_flag(VK_COMMAND_POOL_CREATE_TRANSIENT_BIT)
.end();
draw_command_pool->alloc_command_buffer(command_buffers, VK_COMMAND_BUFFER_LEVEL_PRIMARY, 2);
renderer = vk::Renderer::create_renderer(*device, 2);
onetime_command_pool->alloc_command_buffer(onetime_commands, VK_COMMAND_BUFFER_LEVEL_PRIMARY, 2);
onetime_commands[0]->begin_command(VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT)
.begin_pipeline_barrior(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT)
.add_image_memory_barrior(*teximage)
.image_set_layout(VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL)
.image_set_aspect_mask(VK_IMAGE_ASPECT_COLOR_BIT)
.image_set_access_mask(0, VK_ACCESS_TRANSFER_WRITE_BIT)
.end_pipeline_barrior()
.begin_copy_buffer_to_image(*img_buffer, *teximage)
.add_region(0, {0, 0, 0}, {(uint32_t)imgx, (uint32_t)imgy, 1u})
.end_buffer_image_copy()
.begin_pipeline_barrior(VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT)
.add_image_memory_barrior(*teximage)
.image_set_layout(VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL)
.image_set_aspect_mask(VK_IMAGE_ASPECT_COLOR_BIT)
.image_set_access_mask(VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT)
.end_pipeline_barrior()
.end_command();
onetime_commands[1]->begin_command(VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT)
.begin_pipeline_barrior(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT)
.add_image_memory_barrior(*whiteimage)
.image_set_layout(VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL)
.image_set_aspect_mask(VK_IMAGE_ASPECT_COLOR_BIT)
.image_set_access_mask(0, VK_ACCESS_TRANSFER_WRITE_BIT)
.end_pipeline_barrior()
.begin_copy_buffer_to_image(*img_buffer, *whiteimage)
.add_region(imgx * imgy * 4, {0, 0, 0}, {4u, 4u, 1u})
.end_buffer_image_copy()
.begin_pipeline_barrior(VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT)
.add_image_memory_barrior(*whiteimage)
.image_set_layout(VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL)
.image_set_aspect_mask(VK_IMAGE_ASPECT_COLOR_BIT)
.image_set_access_mask(VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT)
.end_pipeline_barrior()
.end_command();
recreate_sized_object();
}
void draw_frame() {
if(skipdraw)
return;
if(recreate || renderer->out_of_date()) {
recreate_sized_object();
recreate = false;
}
uint32_t frame_index = renderer->prepare_for_next_frame();
uint32_t image_index = renderer->accquire_next_image(*swapchain);
if(renderer->out_of_date())
return;
// update attributes
// global_vars.light = tmath::fmat4::identity().translate(5.0f, 0.0f, 8.0f).rotatex(glfwGetTime() * 0.5f).rotatez(pi * 0.25f) * tmath::fvec3{0.0f, 0.0f, 0.0f};
for(auto& mdo : mdl_objects)
mdo->update(glfwGetTime());
auto ptr = uniform_buffers[frame_index]->map(0, 0x100 + sizeof(VertexAttribute) * object_matrix_count);
memcpy(ptr, &global_vars, sizeof(GlobalVars));
auto att_ptr = reinterpret_cast<VertexAttribute*>((uintptr_t)ptr + 0x100);
memcpy(att_ptr, verts.all_attributes().data(), verts.all_attributes().size() * sizeof(VertexAttribute));
uniform_buffers[frame_index]->unmap();
if(!onetime_commands.empty()) {
renderer->submit_onetime_command(graphic_queue, onetime_commands).wait_idle(graphic_queue);
onetime_commands.clear();
}
command_buffers[frame_index]->begin_command(VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT)
.begin_render_pass(*render_pass, *framebuffers[image_index], VkClearValue{0.0, 0.0, 0.0, 0.8})
.bind_pipeline_and_descriptor_sets(*pipeline, *descriptor_sets[frame_index])
.draw_indexed(*vertex_buffer, *index_buffer, verts.all_indices().size())
.end_render_pass()
.end_command();
renderer->submit_draw_command(graphic_queue, *command_buffers[frame_index]);
renderer->present(present_queue, *swapchain, image_index);
}
void recreate_sized_object() {
device->wait_idle();
swapchain = nullptr;
framebuffers.clear();
glfwGetFramebufferSize(window, &width, &height);
surface->refresh();
const VkSurfaceFormatKHR* format = surface->default_format();
auto caps = surface->capabilities();
swapchain = vk::Swapchain::begin_build(*device)
.set_surface(*surface)
.set_min_image_count(caps->maxImageCount)
.set_format(format->format)
.set_extent({(uint32_t)width, (uint32_t)height})
.set_image_usage(caps->supportedUsageFlags)
.set_queue_family_indices(device->queue_family_in_use())
.set_transform(caps->currentTransform)
.end();
auto swapchain_images = swapchain->get_swapchain_images();
depthimage = vk::Image::begin_build(*device, *physical_device)
.set_device_local()
.set_samples(sample_count)
.set_usage(VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT)
.set_format(VK_FORMAT_D24_UNORM_S8_UINT)
.set_tilling(VK_IMAGE_TILING_OPTIMAL)
.set_extent({(uint32_t)width, (uint32_t)height, 1u})
.end();
depthimage_view = depthimage->create_view(VK_FORMAT_D24_UNORM_S8_UINT, VK_IMAGE_ASPECT_DEPTH_BIT);
onetime_command_pool->alloc_command_buffer(onetime_commands, VK_COMMAND_BUFFER_LEVEL_PRIMARY, 1);
onetime_commands.back()->begin_command(VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT)
.begin_pipeline_barrior(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT)
.add_image_memory_barrior(*depthimage)
.image_set_layout(VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL)
.image_set_aspect_mask(VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)
.image_set_access_mask(0, VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT)
.end_pipeline_barrior()
.end_command();
if(sample_count != VK_SAMPLE_COUNT_1_BIT) {
msaaimage = vk::Image::begin_build(*device, *physical_device)
.set_device_local()
.set_usage(VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT)
.set_samples(sample_count)
.set_format(format->format)
.set_tilling(VK_IMAGE_TILING_OPTIMAL)
.set_extent({(uint32_t)width, (uint32_t)height, 1u})
.end();
msaaimage_view = msaaimage->create_view(format->format, VK_IMAGE_ASPECT_COLOR_BIT);
onetime_command_pool->alloc_command_buffer(onetime_commands, VK_COMMAND_BUFFER_LEVEL_PRIMARY, 1);
onetime_commands.back()->begin_command(VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT)
.begin_pipeline_barrior(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT)
.add_image_memory_barrior(*msaaimage)
.image_set_layout(VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL)
.image_set_aspect_mask(VK_IMAGE_ASPECT_COLOR_BIT)
.image_set_access_mask(0, VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT)
.end_pipeline_barrior()
.end_command();
}
framebuffers.clear();
for(auto view : swapchain_images) {
if(sample_count == VK_SAMPLE_COUNT_1_BIT) {
framebuffers.emplace_back(vk::Framebuffer::begin_build(*device)
.set_render_pass(*render_pass)
.set_framebuffer_size(width, height)
.add_image_view(*view)
.add_image_view(*depthimage_view)
.end()
);
} else {
framebuffers.emplace_back(vk::Framebuffer::begin_build(*device)
.set_render_pass(*render_pass)
.set_framebuffer_size(width, height)
.add_image_view(*msaaimage_view)
.add_image_view(*depthimage_view)
.add_image_view(*view)
.end()
);
}
}
pipeline = vk::Pipeline::begin_build(*device)
.set_render_pass(*render_pass)
.set_vertex_shader(*vert_shader)
.set_fragment_shader(*frag_shader)
.set_cull_mode(VK_CULL_MODE_BACK_BIT)
.normal_viewport((float)width, (float)height)
.normal_scissor((uint32_t)width, (uint32_t)height)
.add_descriptor_set_layout(*descriptor_set_layout)
.set_samples(sample_count)
.bind_vertex_size(sizeof(Vertex))
.add_binding_attribute(VK_FORMAT_R32G32B32_SFLOAT, offsetof(Vertex, position))
.add_binding_attribute(VK_FORMAT_R32G32B32_SFLOAT, offsetof(Vertex, normal))
.add_binding_attribute(VK_FORMAT_R32G32_SFLOAT, offsetof(Vertex, texcoord))
.add_binding_attribute(VK_FORMAT_R32G32_SINT, offsetof(Vertex, index))
.end();
global_vars.proj_view = tmath::fmat4::perspective_fov(3.1415926f / 3.0f, (float)width / (float)height, 0.1f, 100.0f).scale(1.0f, -1.0f, 1.0f)
* tmath::fmat4::look_at({8.0f, 20.0f, 10.0f}, {8.0f, 10.0f, 0.0f}, {0.0f, 0.0f, 1.0f});
global_vars.light = {8.0f, 24.0f, 20.0f};
global_vars.eye = {8.0f, 20.0f, 10.0f};
}
void copy_buffer_to_image() {
}
void post_window_resized(bool skip = false) { skipdraw = skip; recreate = true; }
void mouse_move(float x, float y) {
auto& m = global_vars.proj_view;
float w = x * 2.0f / width - 1.0f;
float h = y * 2.0f / height - 1.0f;
float a1 = m[0] - w * m[3];
float b1 = m[4] - w * m[7];
float c1 = m[12] - w * m[15];
float a2 = m[1] - h * m[3];
float b2 = m[5] - h * m[7];
float c2 = m[13] - h * m[15];
float d = a1 * b2 - a2 * b1;
float zx = (b1 * c2 - b2 * c1) / d;
float zy = (c1 * a2 - c2 * a1) / d;
field->mouse_point(zx, zy);
}
private:
bool recreate = false;
bool skipdraw = false;
GLFWwindow* window = nullptr;
std::shared_ptr<vk::Instance> instance;
const vk::PhysicalDevice* physical_device;
std::shared_ptr<vk::Device> device;
std::shared_ptr<vk::Swapchain> swapchain;
std::shared_ptr<vk::Surface> surface;
rs::vector<std::shared_ptr<vk::Framebuffer>> framebuffers;
std::shared_ptr<vk::ShaderModule> vert_shader;
std::shared_ptr<vk::ShaderModule> frag_shader;
std::shared_ptr<vk::RenderPass> render_pass;
std::shared_ptr<vk::Pipeline> pipeline;
std::shared_ptr<vk::CommandPool> draw_command_pool;
std::shared_ptr<vk::CommandPool> onetime_command_pool;
rs::vector<std::shared_ptr<vk::CommandBuffer>> command_buffers;
rs::vector<std::shared_ptr<vk::CommandBuffer>> onetime_commands;
std::shared_ptr<vk::Renderer> renderer;
vk::Queue graphic_queue;
vk::Queue present_queue;
std::shared_ptr<vk::Buffer> vertex_buffer;
std::shared_ptr<vk::Buffer> index_buffer;
rs::vector<std::shared_ptr<vk::Buffer>> uniform_buffers;
std::shared_ptr<vk::DescriptorSetLayout> descriptor_set_layout;
std::shared_ptr<vk::DescriptorPool> descriptor_pool;
rs::vector<std::shared_ptr<vk::DescriptorSet>> descriptor_sets;
std::shared_ptr<vk::Buffer> img_buffer;
std::shared_ptr<vk::Image> teximage;
std::shared_ptr<vk::Image> whiteimage;
std::shared_ptr<vk::Image> depthimage;
std::shared_ptr<vk::Image> msaaimage;
std::shared_ptr<vk::ImageView> teximage_view;
std::shared_ptr<vk::ImageView> whiteimage_view;
std::shared_ptr<vk::ImageView> depthimage_view;
std::shared_ptr<vk::ImageView> msaaimage_view;
std::shared_ptr<vk::Sampler> sampler;
GlobalVars global_vars;
VkSampleCountFlagBits sample_count = VK_SAMPLE_COUNT_4_BIT;
VertCollection verts;
rs::vector<std::shared_ptr<ModelObject>> mdl_objects;
std::shared_ptr<mdo::MDLField> field;
int32_t width;
int32_t height;
};
Application app;
void show_mat4(tmath::fmat4& m) {
printf("| %f %f %f %f |\n", m[0], m[4], m[8], m[12]);
printf("| %f %f %f %f |\n", m[1], m[5], m[9], m[13]);
printf("| %f %f %f %f |\n", m[2], m[6], m[10], m[14]);
printf("| %f %f %f %f |\n", m[3], m[7], m[11], m[15]);
}
GLFWwindow* window;
int dx, dy, dwx, dwy;
bool window_moving = false;
int main(int argc, char *argv[]) {
if (!glfwInit())
exit(EXIT_FAILURE);
if (!glfwVulkanSupported()) {
std::cout << "Vulkan not supported" << std::endl;
exit(EXIT_FAILURE);
}
GLFWmonitor* monitor = glfwGetPrimaryMonitor();
glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
glfwWindowHint(GLFW_TRANSPARENT_FRAMEBUFFER, GLFW_TRUE);
glfwWindowHint(GLFW_DECORATED, GLFW_FALSE);
window = glfwCreateWindow(1280, 800, "Tacraft!", NULL, NULL);
if (!window) {
glfwTerminate();
exit(EXIT_FAILURE);
}
const GLFWvidmode *mode = glfwGetVideoMode(monitor);
int monitorX, monitorY;
glfwGetMonitorPos(monitor, &monitorX, &monitorY);
int windowWidth, windowHeight;
glfwGetWindowSize(window, &windowWidth, &windowHeight);
glfwSetWindowPos(window, monitorX + (mode->width - windowWidth) / 2, monitorY + (mode->height - windowHeight) / 2);
float xscale, yscale;
glfwGetWindowContentScale(window, &xscale, &yscale);
app.init(window);
glfwSetKeyCallback(window, [](GLFWwindow* window, int key, int scancode, int action, int mods) {
if(action == GLFW_PRESS) {
if(key == GLFW_KEY_ESCAPE)
glfwSetWindowShouldClose(window, GLFW_TRUE);
} else {
}
});
glfwSetWindowSizeCallback(window, [](GLFWwindow* window, int x, int y) {
app.post_window_resized(x == 0 && y == 0);
});
glfwSetMouseButtonCallback(window, [](GLFWwindow*,int button,int action,int mods){
if(action == GLFW_PRESS) {
if(button == GLFW_MOUSE_BUTTON_RIGHT) {
double mx, my;
glfwGetWindowPos(window, &dwx, &dwy);
glfwGetCursorPos(window, &mx, &my);
dx = dwx + (int)mx;
dy = dwy + (int)my;
window_moving = true;
}
} else {
if(button == GLFW_MOUSE_BUTTON_RIGHT) {
window_moving = false;
}
}
});
glfwSetCursorPosCallback(window, [](GLFWwindow*,double x,double y) {
if(window_moving) {
int wx, wy, delx, dely;
glfwGetWindowPos(window, &wx, &wy);
delx = wx + (int)x - dx;
dely = wy + (int)y - dy;
glfwSetWindowPos(window, dwx + delx, dwy + dely);
}
app.mouse_move(x, y);
});
glfwSetTime(0.0);
double prev_time = 0.0;
double time_check= 0.0;
uint32_t frame = 0;
while (!glfwWindowShouldClose(window)) {
glfwPollEvents();
app.draw_frame();
frame++;
double curtime = glfwGetTime();
time_check += (curtime - prev_time);
prev_time = curtime;
if(time_check > 1.0) {
time_check -= 1.0;
char buffer[50];
sprintf(buffer, "Tacraft! %d", frame);
glfwSetWindowTitle(window, buffer);
frame = 0;
}
}
glfwDestroyWindow(window);
glfwTerminate();
exit(EXIT_SUCCESS);
return 0;
};