mirror of
https://github.com/bailwillharr/engine.git
synced 2024-09-21 04:51:18 +00:00
Cleanup libs; change clangformat
This commit is contained in:
parent
84f7647258
commit
53804696b3
@ -69,7 +69,7 @@ BraceWrapping:
|
||||
SplitEmptyNamespace: true
|
||||
BreakBeforeBinaryOperators: None
|
||||
BreakBeforeConceptDeclarations: Always
|
||||
BreakBeforeBraces: Attach
|
||||
BreakBeforeBraces: Stroustrup
|
||||
BreakBeforeInheritanceComma: false
|
||||
BreakInheritanceList: BeforeColon
|
||||
BreakBeforeTernaryOperators: true
|
||||
@ -77,7 +77,7 @@ BreakConstructorInitializersBeforeComma: false
|
||||
BreakConstructorInitializers: BeforeColon
|
||||
BreakAfterJavaFieldAnnotations: false
|
||||
BreakStringLiterals: true
|
||||
ColumnLimit: 80
|
||||
ColumnLimit: 160
|
||||
CommentPragmas: '^ IWYU pragma:'
|
||||
QualifierAlignment: Leave
|
||||
CompactNamespaces: false
|
||||
@ -128,20 +128,20 @@ IndentGotoLabels: true
|
||||
IndentPPDirectives: None
|
||||
IndentExternBlock: AfterExternBlock
|
||||
IndentRequiresClause: true
|
||||
IndentWidth: 2
|
||||
IndentWidth: 4
|
||||
IndentWrappedFunctionNames: false
|
||||
InsertBraces: false
|
||||
InsertTrailingCommas: None
|
||||
JavaScriptQuotes: Leave
|
||||
JavaScriptWrapImports: true
|
||||
KeepEmptyLinesAtTheStartOfBlocks: false
|
||||
KeepEmptyLinesAtTheStartOfBlocks: true
|
||||
LambdaBodyIndentation: Signature
|
||||
MacroBlockBegin: ''
|
||||
MacroBlockEnd: ''
|
||||
MaxEmptyLinesToKeep: 1
|
||||
NamespaceIndentation: None
|
||||
ObjCBinPackProtocolList: Never
|
||||
ObjCBlockIndentWidth: 2
|
||||
ObjCBlockIndentWidth: 4
|
||||
ObjCBreakBeforeNestedBlockParam: true
|
||||
ObjCSpaceAfterProperty: false
|
||||
ObjCSpaceBeforeProtocolList: true
|
||||
@ -219,7 +219,7 @@ SpaceAroundPointerQualifiers: Default
|
||||
SpaceBeforeRangeBasedForLoopColon: true
|
||||
SpaceInEmptyBlock: false
|
||||
SpaceInEmptyParentheses: false
|
||||
SpacesBeforeTrailingComments: 2
|
||||
SpacesBeforeTrailingComments: 1
|
||||
SpacesInAngles: Never
|
||||
SpacesInConditionalStatement: false
|
||||
SpacesInContainerLiterals: true
|
||||
@ -237,7 +237,7 @@ StatementAttributeLikeMacros:
|
||||
StatementMacros:
|
||||
- Q_UNUSED
|
||||
- QT_REQUIRE_VERSION
|
||||
TabWidth: 8
|
||||
TabWidth: 4
|
||||
UseCRLF: false
|
||||
UseTab: Never
|
||||
WhitespaceSensitiveMacros:
|
||||
|
@ -26,12 +26,9 @@ set(SRC_FILES
|
||||
"src/imgui/imgui_internal.h"
|
||||
"src/imgui/imgui_tables.cpp"
|
||||
"src/imgui/imgui_widgets.cpp"
|
||||
"src/imgui/imstb_rectpack.h"
|
||||
"src/imgui/imstb_textedit.h"
|
||||
"src/imgui/imstb_truetype.h"
|
||||
"src/input_manager.cpp"
|
||||
"src/libs/stb_image.cpp"
|
||||
"src/libs/stb_truetype.cpp"
|
||||
"src/libs/stb_impl.cpp"
|
||||
"src/renderer.cpp"
|
||||
"src/resources/font.cpp"
|
||||
"src/resources/material.cpp"
|
||||
@ -46,6 +43,7 @@ set(SRC_FILES
|
||||
"src/systems/ui_render_system.cpp"
|
||||
"src/systems/transform.cpp"
|
||||
"src/util/files.cpp"
|
||||
"src/util/gltf_loader.cpp"
|
||||
"src/util/model_loader.cpp"
|
||||
"src/vulkan/device.cpp"
|
||||
"src/vulkan/device.h"
|
||||
@ -91,6 +89,7 @@ set(INCLUDE_FILES
|
||||
"include/systems/transform.h"
|
||||
"include/util.h"
|
||||
"include/util/files.h"
|
||||
"include/util/gltf_loader.h"
|
||||
"include/util/model_loader.h"
|
||||
"include/window.h"
|
||||
)
|
||||
@ -139,6 +138,7 @@ target_include_directories(${PROJECT_NAME} PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
|
||||
if (ENGINE_BUILD_TEST)
|
||||
add_subdirectory(test)
|
||||
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY $<TARGET_FILE_DIR:enginetest>)
|
||||
set_property(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY VS_STARTUP_PROJECT enginetest)
|
||||
endif()
|
||||
|
||||
# private libraries:
|
||||
|
11
include/util/gltf_loader.h
Normal file
11
include/util/gltf_loader.h
Normal file
@ -0,0 +1,11 @@
|
||||
#pragma once
|
||||
|
||||
#include <string>
|
||||
|
||||
#include "scene.h"
|
||||
|
||||
namespace engine::util {
|
||||
|
||||
engine::Entity LoadGLTF(Scene& scene, const std::string& path, bool isStatic = false);
|
||||
|
||||
}
|
@ -41,7 +41,8 @@ static struct ImGuiThings {
|
||||
|
||||
namespace engine {
|
||||
|
||||
static std::filesystem::path getResourcesPath() {
|
||||
static std::filesystem::path getResourcesPath()
|
||||
{
|
||||
std::filesystem::path resourcesPath{};
|
||||
|
||||
#ifdef _MSC_VER
|
||||
@ -56,7 +57,8 @@ static std::filesystem::path getResourcesPath() {
|
||||
|
||||
if (std::filesystem::is_directory(cwd / "res")) {
|
||||
resourcesPath = cwd / "res";
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
resourcesPath = cwd.parent_path() / "share" / "sdltest";
|
||||
}
|
||||
|
||||
@ -65,15 +67,14 @@ static std::filesystem::path getResourcesPath() {
|
||||
}
|
||||
|
||||
if (std::filesystem::is_directory(resourcesPath) == false) {
|
||||
throw std::runtime_error("Unable to determine resources location. CWD: " +
|
||||
cwd.string());
|
||||
throw std::runtime_error("Unable to determine resources location. CWD: " + cwd.string());
|
||||
}
|
||||
|
||||
return resourcesPath;
|
||||
}
|
||||
|
||||
Application::Application(const char* appName, const char* appVersion,
|
||||
gfx::GraphicsSettings graphicsSettings) {
|
||||
Application::Application(const char* appName, const char* appVersion, gfx::GraphicsSettings graphicsSettings)
|
||||
{
|
||||
window_ = std::make_unique<Window>(appName, true, false);
|
||||
input_manager_ = std::make_unique<InputManager>(window_.get());
|
||||
scene_manager_ = std::make_unique<SceneManager>(this);
|
||||
@ -92,15 +93,12 @@ Application::Application(const char* appName, const char* appVersion,
|
||||
// ImGuiIO& io = ImGui::GetIO()
|
||||
ImGui_ImplSDL2_InitForVulkan(window_->GetHandle());
|
||||
|
||||
renderer_ = std::make_unique<Renderer>(
|
||||
appName, appVersion, window_->GetHandle(), graphicsSettings);
|
||||
renderer_ = std::make_unique<Renderer>(appName, appVersion, window_->GetHandle(), graphicsSettings);
|
||||
|
||||
/* default fonts */
|
||||
{
|
||||
auto monoFont = std::make_unique<resources::Font>(
|
||||
GetResourcePath("engine/fonts/mono.ttf"));
|
||||
GetResourceManager<resources::Font>()->AddPersistent("builtin.mono",
|
||||
std::move(monoFont));
|
||||
auto monoFont = std::make_unique<resources::Font>(GetResourcePath("engine/fonts/mono.ttf"));
|
||||
GetResourceManager<resources::Font>()->AddPersistent("builtin.mono", std::move(monoFont));
|
||||
}
|
||||
|
||||
/* default shaders */
|
||||
@ -114,12 +112,9 @@ Application::Application(const char* appName, const char* appVersion,
|
||||
shaderSettings.cull_backface = true;
|
||||
shaderSettings.write_z = true;
|
||||
shaderSettings.render_order = 0;
|
||||
auto texturedShader = std::make_unique<resources::Shader>(
|
||||
renderer(), GetResourcePath("engine/shaders/standard.vert").c_str(),
|
||||
GetResourcePath("engine/shaders/standard.frag").c_str(),
|
||||
shaderSettings);
|
||||
GetResourceManager<resources::Shader>()->AddPersistent(
|
||||
"builtin.standard", std::move(texturedShader));
|
||||
auto texturedShader = std::make_unique<resources::Shader>(renderer(), GetResourcePath("engine/shaders/standard.vert").c_str(),
|
||||
GetResourcePath("engine/shaders/standard.frag").c_str(), shaderSettings);
|
||||
GetResourceManager<resources::Shader>()->AddPersistent("builtin.standard", std::move(texturedShader));
|
||||
}
|
||||
{
|
||||
resources::Shader::VertexParams vertParams{};
|
||||
@ -131,11 +126,9 @@ Application::Application(const char* appName, const char* appVersion,
|
||||
shaderSettings.cull_backface = true;
|
||||
shaderSettings.write_z = true;
|
||||
shaderSettings.render_order = 0;
|
||||
auto skyboxShader = std::make_unique<resources::Shader>(
|
||||
renderer(), GetResourcePath("engine/shaders/skybox.vert").c_str(),
|
||||
auto skyboxShader = std::make_unique<resources::Shader>(renderer(), GetResourcePath("engine/shaders/skybox.vert").c_str(),
|
||||
GetResourcePath("engine/shaders/skybox.frag").c_str(), shaderSettings);
|
||||
GetResourceManager<resources::Shader>()->AddPersistent(
|
||||
"builtin.skybox", std::move(skyboxShader));
|
||||
GetResourceManager<resources::Shader>()->AddPersistent("builtin.skybox", std::move(skyboxShader));
|
||||
}
|
||||
if (0) {
|
||||
resources::Shader::VertexParams vertParams{};
|
||||
@ -147,35 +140,31 @@ Application::Application(const char* appName, const char* appVersion,
|
||||
shaderSettings.cull_backface = true;
|
||||
shaderSettings.write_z = false;
|
||||
shaderSettings.render_order = 1;
|
||||
auto quadShader = std::make_unique<resources::Shader>(
|
||||
renderer(), GetResourcePath("engine/shaders/quad.vert").c_str(),
|
||||
auto quadShader = std::make_unique<resources::Shader>(renderer(), GetResourcePath("engine/shaders/quad.vert").c_str(),
|
||||
GetResourcePath("engine/shaders/quad.frag").c_str(), shaderSettings);
|
||||
GetResourceManager<resources::Shader>()->AddPersistent(
|
||||
"builtin.quad", std::move(quadShader));
|
||||
GetResourceManager<resources::Shader>()->AddPersistent("builtin.quad", std::move(quadShader));
|
||||
}
|
||||
|
||||
/* default textures */
|
||||
{
|
||||
auto whiteTexture = std::make_unique<resources::Texture>(
|
||||
renderer(), GetResourcePath("engine/textures/white.png"),
|
||||
resources::Texture::Filtering::kOff);
|
||||
GetResourceManager<resources::Texture>()->AddPersistent(
|
||||
"builtin.white", std::move(whiteTexture));
|
||||
auto whiteTexture = std::make_unique<resources::Texture>(renderer(), GetResourcePath("engine/textures/white.png"), resources::Texture::Filtering::kOff);
|
||||
GetResourceManager<resources::Texture>()->AddPersistent("builtin.white", std::move(whiteTexture));
|
||||
}
|
||||
}
|
||||
|
||||
Application::~Application() {
|
||||
Application::~Application()
|
||||
{
|
||||
renderer_->GetDevice()->ShutdownImguiBackend();
|
||||
ImGui_ImplSDL2_Shutdown();
|
||||
ImGui::DestroyContext(im_gui_things.context);
|
||||
}
|
||||
|
||||
void Application::GameLoop() {
|
||||
void Application::GameLoop()
|
||||
{
|
||||
LOG_DEBUG("Begin game loop...");
|
||||
|
||||
constexpr int FPS_LIMIT = 240;
|
||||
constexpr auto FRAMETIME_LIMIT =
|
||||
std::chrono::nanoseconds(1000000000 / FPS_LIMIT);
|
||||
constexpr auto FRAMETIME_LIMIT = std::chrono::nanoseconds(1000000000 / FPS_LIMIT);
|
||||
auto beginFrame = std::chrono::steady_clock::now();
|
||||
auto endFrame = beginFrame + FRAMETIME_LIMIT;
|
||||
|
||||
@ -190,12 +179,15 @@ void Application::GameLoop() {
|
||||
// single-threaded game loop
|
||||
while (window_->IsRunning()) {
|
||||
/* logic */
|
||||
|
||||
const float avg_fps = static_cast<float>(delta_times.size()) / std::accumulate(delta_times.begin(), delta_times.end(), 0.0f);
|
||||
|
||||
Scene* scene = scene_manager_->UpdateActiveScene(window_->dt());
|
||||
|
||||
uint64_t now = window_->GetNanos();
|
||||
if (now - lastTick >= 1000000000LL * 5LL) [[unlikely]] {
|
||||
lastTick = now;
|
||||
LOG_INFO("fps: {}", window_->GetAvgFPS());
|
||||
LOG_INFO("fps: {}", std::lroundf(avg_fps));
|
||||
// renderer()->GetDevice()->LogPerformanceInfo();
|
||||
window_->ResetAvgFPS();
|
||||
}
|
||||
@ -217,17 +209,21 @@ void Application::GameLoop() {
|
||||
if (debug_menu_state.menu_active) {
|
||||
if (ImGui::Begin("debugMenu")) {
|
||||
ImGui::Text("Test!");
|
||||
ImGui::Text("FPS: %.3f", std::roundf(avg_fps));
|
||||
}
|
||||
ImGui::End();
|
||||
}
|
||||
|
||||
if (debug_menu_state.show_info_window) {
|
||||
if (ImGui::Begin("infoWindow", nullptr, ImGuiWindowFlags_NoInputs | ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoFocusOnAppearing)) {
|
||||
if (ImGui::Begin(
|
||||
"infoWindow", nullptr,
|
||||
ImGuiWindowFlags_NoInputs | ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoFocusOnAppearing)) {
|
||||
ImGui::Text("Scene hierarchy:");
|
||||
|
||||
std::function<int(Entity, int)> find_depth = [&](Entity e, int current_depth)-> int {
|
||||
std::function<int(Entity, int)> find_depth = [&](Entity e, int current_depth) -> int {
|
||||
Entity parent = scene->GetComponent<TransformComponent>(e)->parent;
|
||||
if (parent == 0) return current_depth;
|
||||
if (parent == 0)
|
||||
return current_depth;
|
||||
else {
|
||||
return find_depth(parent, current_depth + 1);
|
||||
}
|
||||
@ -237,12 +233,10 @@ void Application::GameLoop() {
|
||||
auto t = scene->GetComponent<TransformComponent>(i);
|
||||
std::string tabs{};
|
||||
int depth = find_depth(i, 0);
|
||||
for (int j = 0; j < depth; ++j) tabs += std::string{ " " };
|
||||
ImGui::Text("%s%s", tabs, t->tag.c_str());
|
||||
|
||||
for (int j = 0; j < depth; ++j) tabs += std::string{" "};
|
||||
ImGui::Text("%s%s", tabs.c_str(), t->tag.c_str());
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
ImGui::End();
|
||||
}
|
||||
@ -253,9 +247,7 @@ void Application::GameLoop() {
|
||||
const RenderList* dynamic_list = nullptr;
|
||||
glm::mat4 camera_transform{1.0f};
|
||||
if (scene) {
|
||||
camera_transform =
|
||||
scene->GetComponent<TransformComponent>(scene->GetEntity("camera"))
|
||||
->world_matrix;
|
||||
camera_transform = scene->GetComponent<TransformComponent>(scene->GetEntity("camera"))->world_matrix;
|
||||
auto mesh_render_system = scene->GetSystem<MeshRenderSystem>();
|
||||
static_list = mesh_render_system->GetStaticRenderList();
|
||||
dynamic_list = mesh_render_system->GetDynamicRenderList();
|
||||
|
@ -60,11 +60,10 @@
|
||||
|
||||
//---- Avoid multiple STB libraries implementations, or redefine path/filenames to prioritize another version
|
||||
// By default the embedded implementations are declared static and not available outside of Dear ImGui sources files.
|
||||
//#define IMGUI_STB_TRUETYPE_FILENAME "my_folder/stb_truetype.h"
|
||||
//#define IMGUI_STB_RECT_PACK_FILENAME "my_folder/stb_rect_pack.h"
|
||||
#define IMGUI_STB_TRUETYPE_FILENAME "stb_truetype.h"
|
||||
#define IMGUI_STB_RECT_PACK_FILENAME "stb_rect_pack.h"
|
||||
//#define IMGUI_STB_SPRINTF_FILENAME "my_folder/stb_sprintf.h" // only used if IMGUI_USE_STB_SPRINTF is defined.
|
||||
//#define IMGUI_DISABLE_STB_TRUETYPE_IMPLEMENTATION
|
||||
//#define IMGUI_DISABLE_STB_RECT_PACK_IMPLEMENTATION
|
||||
#define IMGUI_DISABLE_STB_RECT_PACK_IMPLEMENTATION
|
||||
//#define IMGUI_DISABLE_STB_SPRINTF_IMPLEMENTATION // only disabled if IMGUI_USE_STB_SPRINTF is defined.
|
||||
|
||||
//---- Use stb_sprintf.h for a faster implementation of vsnprintf instead of the one from libc (unless IMGUI_DISABLE_DEFAULT_FORMAT_FUNCTIONS is defined)
|
||||
|
@ -208,7 +208,7 @@ namespace ImStb
|
||||
#define STB_TEXTEDIT_GETWIDTH_NEWLINE (-1.0f)
|
||||
#define STB_TEXTEDIT_UNDOSTATECOUNT 99
|
||||
#define STB_TEXTEDIT_UNDOCHARCOUNT 999
|
||||
#include "imstb_textedit.h"
|
||||
#include "stb_textedit.h"
|
||||
|
||||
} // namespace ImStb
|
||||
|
||||
|
@ -1,627 +0,0 @@
|
||||
// [DEAR IMGUI]
|
||||
// This is a slightly modified version of stb_rect_pack.h 1.01.
|
||||
// Grep for [DEAR IMGUI] to find the changes.
|
||||
//
|
||||
// stb_rect_pack.h - v1.01 - public domain - rectangle packing
|
||||
// Sean Barrett 2014
|
||||
//
|
||||
// Useful for e.g. packing rectangular textures into an atlas.
|
||||
// Does not do rotation.
|
||||
//
|
||||
// Before #including,
|
||||
//
|
||||
// #define STB_RECT_PACK_IMPLEMENTATION
|
||||
//
|
||||
// in the file that you want to have the implementation.
|
||||
//
|
||||
// Not necessarily the awesomest packing method, but better than
|
||||
// the totally naive one in stb_truetype (which is primarily what
|
||||
// this is meant to replace).
|
||||
//
|
||||
// Has only had a few tests run, may have issues.
|
||||
//
|
||||
// More docs to come.
|
||||
//
|
||||
// No memory allocations; uses qsort() and assert() from stdlib.
|
||||
// Can override those by defining STBRP_SORT and STBRP_ASSERT.
|
||||
//
|
||||
// This library currently uses the Skyline Bottom-Left algorithm.
|
||||
//
|
||||
// Please note: better rectangle packers are welcome! Please
|
||||
// implement them to the same API, but with a different init
|
||||
// function.
|
||||
//
|
||||
// Credits
|
||||
//
|
||||
// Library
|
||||
// Sean Barrett
|
||||
// Minor features
|
||||
// Martins Mozeiko
|
||||
// github:IntellectualKitty
|
||||
//
|
||||
// Bugfixes / warning fixes
|
||||
// Jeremy Jaussaud
|
||||
// Fabian Giesen
|
||||
//
|
||||
// Version history:
|
||||
//
|
||||
// 1.01 (2021-07-11) always use large rect mode, expose STBRP__MAXVAL in public section
|
||||
// 1.00 (2019-02-25) avoid small space waste; gracefully fail too-wide rectangles
|
||||
// 0.99 (2019-02-07) warning fixes
|
||||
// 0.11 (2017-03-03) return packing success/fail result
|
||||
// 0.10 (2016-10-25) remove cast-away-const to avoid warnings
|
||||
// 0.09 (2016-08-27) fix compiler warnings
|
||||
// 0.08 (2015-09-13) really fix bug with empty rects (w=0 or h=0)
|
||||
// 0.07 (2015-09-13) fix bug with empty rects (w=0 or h=0)
|
||||
// 0.06 (2015-04-15) added STBRP_SORT to allow replacing qsort
|
||||
// 0.05: added STBRP_ASSERT to allow replacing assert
|
||||
// 0.04: fixed minor bug in STBRP_LARGE_RECTS support
|
||||
// 0.01: initial release
|
||||
//
|
||||
// LICENSE
|
||||
//
|
||||
// See end of file for license information.
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// INCLUDE SECTION
|
||||
//
|
||||
|
||||
#ifndef STB_INCLUDE_STB_RECT_PACK_H
|
||||
#define STB_INCLUDE_STB_RECT_PACK_H
|
||||
|
||||
#define STB_RECT_PACK_VERSION 1
|
||||
|
||||
#ifdef STBRP_STATIC
|
||||
#define STBRP_DEF static
|
||||
#else
|
||||
#define STBRP_DEF extern
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef struct stbrp_context stbrp_context;
|
||||
typedef struct stbrp_node stbrp_node;
|
||||
typedef struct stbrp_rect stbrp_rect;
|
||||
|
||||
typedef int stbrp_coord;
|
||||
|
||||
#define STBRP__MAXVAL 0x7fffffff
|
||||
// Mostly for internal use, but this is the maximum supported coordinate value.
|
||||
|
||||
STBRP_DEF int stbrp_pack_rects (stbrp_context *context, stbrp_rect *rects, int num_rects);
|
||||
// Assign packed locations to rectangles. The rectangles are of type
|
||||
// 'stbrp_rect' defined below, stored in the array 'rects', and there
|
||||
// are 'num_rects' many of them.
|
||||
//
|
||||
// Rectangles which are successfully packed have the 'was_packed' flag
|
||||
// set to a non-zero value and 'x' and 'y' store the minimum location
|
||||
// on each axis (i.e. bottom-left in cartesian coordinates, top-left
|
||||
// if you imagine y increasing downwards). Rectangles which do not fit
|
||||
// have the 'was_packed' flag set to 0.
|
||||
//
|
||||
// You should not try to access the 'rects' array from another thread
|
||||
// while this function is running, as the function temporarily reorders
|
||||
// the array while it executes.
|
||||
//
|
||||
// To pack into another rectangle, you need to call stbrp_init_target
|
||||
// again. To continue packing into the same rectangle, you can call
|
||||
// this function again. Calling this multiple times with multiple rect
|
||||
// arrays will probably produce worse packing results than calling it
|
||||
// a single time with the full rectangle array, but the option is
|
||||
// available.
|
||||
//
|
||||
// The function returns 1 if all of the rectangles were successfully
|
||||
// packed and 0 otherwise.
|
||||
|
||||
struct stbrp_rect
|
||||
{
|
||||
// reserved for your use:
|
||||
int id;
|
||||
|
||||
// input:
|
||||
stbrp_coord w, h;
|
||||
|
||||
// output:
|
||||
stbrp_coord x, y;
|
||||
int was_packed; // non-zero if valid packing
|
||||
|
||||
}; // 16 bytes, nominally
|
||||
|
||||
|
||||
STBRP_DEF void stbrp_init_target (stbrp_context *context, int width, int height, stbrp_node *nodes, int num_nodes);
|
||||
// Initialize a rectangle packer to:
|
||||
// pack a rectangle that is 'width' by 'height' in dimensions
|
||||
// using temporary storage provided by the array 'nodes', which is 'num_nodes' long
|
||||
//
|
||||
// You must call this function every time you start packing into a new target.
|
||||
//
|
||||
// There is no "shutdown" function. The 'nodes' memory must stay valid for
|
||||
// the following stbrp_pack_rects() call (or calls), but can be freed after
|
||||
// the call (or calls) finish.
|
||||
//
|
||||
// Note: to guarantee best results, either:
|
||||
// 1. make sure 'num_nodes' >= 'width'
|
||||
// or 2. call stbrp_allow_out_of_mem() defined below with 'allow_out_of_mem = 1'
|
||||
//
|
||||
// If you don't do either of the above things, widths will be quantized to multiples
|
||||
// of small integers to guarantee the algorithm doesn't run out of temporary storage.
|
||||
//
|
||||
// If you do #2, then the non-quantized algorithm will be used, but the algorithm
|
||||
// may run out of temporary storage and be unable to pack some rectangles.
|
||||
|
||||
STBRP_DEF void stbrp_setup_allow_out_of_mem (stbrp_context *context, int allow_out_of_mem);
|
||||
// Optionally call this function after init but before doing any packing to
|
||||
// change the handling of the out-of-temp-memory scenario, described above.
|
||||
// If you call init again, this will be reset to the default (false).
|
||||
|
||||
|
||||
STBRP_DEF void stbrp_setup_heuristic (stbrp_context *context, int heuristic);
|
||||
// Optionally select which packing heuristic the library should use. Different
|
||||
// heuristics will produce better/worse results for different data sets.
|
||||
// If you call init again, this will be reset to the default.
|
||||
|
||||
enum
|
||||
{
|
||||
STBRP_HEURISTIC_Skyline_default=0,
|
||||
STBRP_HEURISTIC_Skyline_BL_sortHeight = STBRP_HEURISTIC_Skyline_default,
|
||||
STBRP_HEURISTIC_Skyline_BF_sortHeight
|
||||
};
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// the details of the following structures don't matter to you, but they must
|
||||
// be visible so you can handle the memory allocations for them
|
||||
|
||||
struct stbrp_node
|
||||
{
|
||||
stbrp_coord x,y;
|
||||
stbrp_node *next;
|
||||
};
|
||||
|
||||
struct stbrp_context
|
||||
{
|
||||
int width;
|
||||
int height;
|
||||
int align;
|
||||
int init_mode;
|
||||
int heuristic;
|
||||
int num_nodes;
|
||||
stbrp_node *active_head;
|
||||
stbrp_node *free_head;
|
||||
stbrp_node extra[2]; // we allocate two extra nodes so optimal user-node-count is 'width' not 'width+2'
|
||||
};
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// IMPLEMENTATION SECTION
|
||||
//
|
||||
|
||||
#ifdef STB_RECT_PACK_IMPLEMENTATION
|
||||
#ifndef STBRP_SORT
|
||||
#include <stdlib.h>
|
||||
#define STBRP_SORT qsort
|
||||
#endif
|
||||
|
||||
#ifndef STBRP_ASSERT
|
||||
#include <assert.h>
|
||||
#define STBRP_ASSERT assert
|
||||
#endif
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#define STBRP__NOTUSED(v) (void)(v)
|
||||
#define STBRP__CDECL __cdecl
|
||||
#else
|
||||
#define STBRP__NOTUSED(v) (void)sizeof(v)
|
||||
#define STBRP__CDECL
|
||||
#endif
|
||||
|
||||
enum
|
||||
{
|
||||
STBRP__INIT_skyline = 1
|
||||
};
|
||||
|
||||
STBRP_DEF void stbrp_setup_heuristic(stbrp_context *context, int heuristic)
|
||||
{
|
||||
switch (context->init_mode) {
|
||||
case STBRP__INIT_skyline:
|
||||
STBRP_ASSERT(heuristic == STBRP_HEURISTIC_Skyline_BL_sortHeight || heuristic == STBRP_HEURISTIC_Skyline_BF_sortHeight);
|
||||
context->heuristic = heuristic;
|
||||
break;
|
||||
default:
|
||||
STBRP_ASSERT(0);
|
||||
}
|
||||
}
|
||||
|
||||
STBRP_DEF void stbrp_setup_allow_out_of_mem(stbrp_context *context, int allow_out_of_mem)
|
||||
{
|
||||
if (allow_out_of_mem)
|
||||
// if it's ok to run out of memory, then don't bother aligning them;
|
||||
// this gives better packing, but may fail due to OOM (even though
|
||||
// the rectangles easily fit). @TODO a smarter approach would be to only
|
||||
// quantize once we've hit OOM, then we could get rid of this parameter.
|
||||
context->align = 1;
|
||||
else {
|
||||
// if it's not ok to run out of memory, then quantize the widths
|
||||
// so that num_nodes is always enough nodes.
|
||||
//
|
||||
// I.e. num_nodes * align >= width
|
||||
// align >= width / num_nodes
|
||||
// align = ceil(width/num_nodes)
|
||||
|
||||
context->align = (context->width + context->num_nodes-1) / context->num_nodes;
|
||||
}
|
||||
}
|
||||
|
||||
STBRP_DEF void stbrp_init_target(stbrp_context *context, int width, int height, stbrp_node *nodes, int num_nodes)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i=0; i < num_nodes-1; ++i)
|
||||
nodes[i].next = &nodes[i+1];
|
||||
nodes[i].next = NULL;
|
||||
context->init_mode = STBRP__INIT_skyline;
|
||||
context->heuristic = STBRP_HEURISTIC_Skyline_default;
|
||||
context->free_head = &nodes[0];
|
||||
context->active_head = &context->extra[0];
|
||||
context->width = width;
|
||||
context->height = height;
|
||||
context->num_nodes = num_nodes;
|
||||
stbrp_setup_allow_out_of_mem(context, 0);
|
||||
|
||||
// node 0 is the full width, node 1 is the sentinel (lets us not store width explicitly)
|
||||
context->extra[0].x = 0;
|
||||
context->extra[0].y = 0;
|
||||
context->extra[0].next = &context->extra[1];
|
||||
context->extra[1].x = (stbrp_coord) width;
|
||||
context->extra[1].y = (1<<30);
|
||||
context->extra[1].next = NULL;
|
||||
}
|
||||
|
||||
// find minimum y position if it starts at x1
|
||||
static int stbrp__skyline_find_min_y(stbrp_context *c, stbrp_node *first, int x0, int width, int *pwaste)
|
||||
{
|
||||
stbrp_node *node = first;
|
||||
int x1 = x0 + width;
|
||||
int min_y, visited_width, waste_area;
|
||||
|
||||
STBRP__NOTUSED(c);
|
||||
|
||||
STBRP_ASSERT(first->x <= x0);
|
||||
|
||||
#if 0
|
||||
// skip in case we're past the node
|
||||
while (node->next->x <= x0)
|
||||
++node;
|
||||
#else
|
||||
STBRP_ASSERT(node->next->x > x0); // we ended up handling this in the caller for efficiency
|
||||
#endif
|
||||
|
||||
STBRP_ASSERT(node->x <= x0);
|
||||
|
||||
min_y = 0;
|
||||
waste_area = 0;
|
||||
visited_width = 0;
|
||||
while (node->x < x1) {
|
||||
if (node->y > min_y) {
|
||||
// raise min_y higher.
|
||||
// we've accounted for all waste up to min_y,
|
||||
// but we'll now add more waste for everything we've visted
|
||||
waste_area += visited_width * (node->y - min_y);
|
||||
min_y = node->y;
|
||||
// the first time through, visited_width might be reduced
|
||||
if (node->x < x0)
|
||||
visited_width += node->next->x - x0;
|
||||
else
|
||||
visited_width += node->next->x - node->x;
|
||||
} else {
|
||||
// add waste area
|
||||
int under_width = node->next->x - node->x;
|
||||
if (under_width + visited_width > width)
|
||||
under_width = width - visited_width;
|
||||
waste_area += under_width * (min_y - node->y);
|
||||
visited_width += under_width;
|
||||
}
|
||||
node = node->next;
|
||||
}
|
||||
|
||||
*pwaste = waste_area;
|
||||
return min_y;
|
||||
}
|
||||
|
||||
typedef struct
|
||||
{
|
||||
int x,y;
|
||||
stbrp_node **prev_link;
|
||||
} stbrp__findresult;
|
||||
|
||||
static stbrp__findresult stbrp__skyline_find_best_pos(stbrp_context *c, int width, int height)
|
||||
{
|
||||
int best_waste = (1<<30), best_x, best_y = (1 << 30);
|
||||
stbrp__findresult fr;
|
||||
stbrp_node **prev, *node, *tail, **best = NULL;
|
||||
|
||||
// align to multiple of c->align
|
||||
width = (width + c->align - 1);
|
||||
width -= width % c->align;
|
||||
STBRP_ASSERT(width % c->align == 0);
|
||||
|
||||
// if it can't possibly fit, bail immediately
|
||||
if (width > c->width || height > c->height) {
|
||||
fr.prev_link = NULL;
|
||||
fr.x = fr.y = 0;
|
||||
return fr;
|
||||
}
|
||||
|
||||
node = c->active_head;
|
||||
prev = &c->active_head;
|
||||
while (node->x + width <= c->width) {
|
||||
int y,waste;
|
||||
y = stbrp__skyline_find_min_y(c, node, node->x, width, &waste);
|
||||
if (c->heuristic == STBRP_HEURISTIC_Skyline_BL_sortHeight) { // actually just want to test BL
|
||||
// bottom left
|
||||
if (y < best_y) {
|
||||
best_y = y;
|
||||
best = prev;
|
||||
}
|
||||
} else {
|
||||
// best-fit
|
||||
if (y + height <= c->height) {
|
||||
// can only use it if it first vertically
|
||||
if (y < best_y || (y == best_y && waste < best_waste)) {
|
||||
best_y = y;
|
||||
best_waste = waste;
|
||||
best = prev;
|
||||
}
|
||||
}
|
||||
}
|
||||
prev = &node->next;
|
||||
node = node->next;
|
||||
}
|
||||
|
||||
best_x = (best == NULL) ? 0 : (*best)->x;
|
||||
|
||||
// if doing best-fit (BF), we also have to try aligning right edge to each node position
|
||||
//
|
||||
// e.g, if fitting
|
||||
//
|
||||
// ____________________
|
||||
// |____________________|
|
||||
//
|
||||
// into
|
||||
//
|
||||
// | |
|
||||
// | ____________|
|
||||
// |____________|
|
||||
//
|
||||
// then right-aligned reduces waste, but bottom-left BL is always chooses left-aligned
|
||||
//
|
||||
// This makes BF take about 2x the time
|
||||
|
||||
if (c->heuristic == STBRP_HEURISTIC_Skyline_BF_sortHeight) {
|
||||
tail = c->active_head;
|
||||
node = c->active_head;
|
||||
prev = &c->active_head;
|
||||
// find first node that's admissible
|
||||
while (tail->x < width)
|
||||
tail = tail->next;
|
||||
while (tail) {
|
||||
int xpos = tail->x - width;
|
||||
int y,waste;
|
||||
STBRP_ASSERT(xpos >= 0);
|
||||
// find the left position that matches this
|
||||
while (node->next->x <= xpos) {
|
||||
prev = &node->next;
|
||||
node = node->next;
|
||||
}
|
||||
STBRP_ASSERT(node->next->x > xpos && node->x <= xpos);
|
||||
y = stbrp__skyline_find_min_y(c, node, xpos, width, &waste);
|
||||
if (y + height <= c->height) {
|
||||
if (y <= best_y) {
|
||||
if (y < best_y || waste < best_waste || (waste==best_waste && xpos < best_x)) {
|
||||
best_x = xpos;
|
||||
//STBRP_ASSERT(y <= best_y); [DEAR IMGUI]
|
||||
best_y = y;
|
||||
best_waste = waste;
|
||||
best = prev;
|
||||
}
|
||||
}
|
||||
}
|
||||
tail = tail->next;
|
||||
}
|
||||
}
|
||||
|
||||
fr.prev_link = best;
|
||||
fr.x = best_x;
|
||||
fr.y = best_y;
|
||||
return fr;
|
||||
}
|
||||
|
||||
static stbrp__findresult stbrp__skyline_pack_rectangle(stbrp_context *context, int width, int height)
|
||||
{
|
||||
// find best position according to heuristic
|
||||
stbrp__findresult res = stbrp__skyline_find_best_pos(context, width, height);
|
||||
stbrp_node *node, *cur;
|
||||
|
||||
// bail if:
|
||||
// 1. it failed
|
||||
// 2. the best node doesn't fit (we don't always check this)
|
||||
// 3. we're out of memory
|
||||
if (res.prev_link == NULL || res.y + height > context->height || context->free_head == NULL) {
|
||||
res.prev_link = NULL;
|
||||
return res;
|
||||
}
|
||||
|
||||
// on success, create new node
|
||||
node = context->free_head;
|
||||
node->x = (stbrp_coord) res.x;
|
||||
node->y = (stbrp_coord) (res.y + height);
|
||||
|
||||
context->free_head = node->next;
|
||||
|
||||
// insert the new node into the right starting point, and
|
||||
// let 'cur' point to the remaining nodes needing to be
|
||||
// stiched back in
|
||||
|
||||
cur = *res.prev_link;
|
||||
if (cur->x < res.x) {
|
||||
// preserve the existing one, so start testing with the next one
|
||||
stbrp_node *next = cur->next;
|
||||
cur->next = node;
|
||||
cur = next;
|
||||
} else {
|
||||
*res.prev_link = node;
|
||||
}
|
||||
|
||||
// from here, traverse cur and free the nodes, until we get to one
|
||||
// that shouldn't be freed
|
||||
while (cur->next && cur->next->x <= res.x + width) {
|
||||
stbrp_node *next = cur->next;
|
||||
// move the current node to the free list
|
||||
cur->next = context->free_head;
|
||||
context->free_head = cur;
|
||||
cur = next;
|
||||
}
|
||||
|
||||
// stitch the list back in
|
||||
node->next = cur;
|
||||
|
||||
if (cur->x < res.x + width)
|
||||
cur->x = (stbrp_coord) (res.x + width);
|
||||
|
||||
#ifdef _DEBUG
|
||||
cur = context->active_head;
|
||||
while (cur->x < context->width) {
|
||||
STBRP_ASSERT(cur->x < cur->next->x);
|
||||
cur = cur->next;
|
||||
}
|
||||
STBRP_ASSERT(cur->next == NULL);
|
||||
|
||||
{
|
||||
int count=0;
|
||||
cur = context->active_head;
|
||||
while (cur) {
|
||||
cur = cur->next;
|
||||
++count;
|
||||
}
|
||||
cur = context->free_head;
|
||||
while (cur) {
|
||||
cur = cur->next;
|
||||
++count;
|
||||
}
|
||||
STBRP_ASSERT(count == context->num_nodes+2);
|
||||
}
|
||||
#endif
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
static int STBRP__CDECL rect_height_compare(const void *a, const void *b)
|
||||
{
|
||||
const stbrp_rect *p = (const stbrp_rect *) a;
|
||||
const stbrp_rect *q = (const stbrp_rect *) b;
|
||||
if (p->h > q->h)
|
||||
return -1;
|
||||
if (p->h < q->h)
|
||||
return 1;
|
||||
return (p->w > q->w) ? -1 : (p->w < q->w);
|
||||
}
|
||||
|
||||
static int STBRP__CDECL rect_original_order(const void *a, const void *b)
|
||||
{
|
||||
const stbrp_rect *p = (const stbrp_rect *) a;
|
||||
const stbrp_rect *q = (const stbrp_rect *) b;
|
||||
return (p->was_packed < q->was_packed) ? -1 : (p->was_packed > q->was_packed);
|
||||
}
|
||||
|
||||
STBRP_DEF int stbrp_pack_rects(stbrp_context *context, stbrp_rect *rects, int num_rects)
|
||||
{
|
||||
int i, all_rects_packed = 1;
|
||||
|
||||
// we use the 'was_packed' field internally to allow sorting/unsorting
|
||||
for (i=0; i < num_rects; ++i) {
|
||||
rects[i].was_packed = i;
|
||||
}
|
||||
|
||||
// sort according to heuristic
|
||||
STBRP_SORT(rects, num_rects, sizeof(rects[0]), rect_height_compare);
|
||||
|
||||
for (i=0; i < num_rects; ++i) {
|
||||
if (rects[i].w == 0 || rects[i].h == 0) {
|
||||
rects[i].x = rects[i].y = 0; // empty rect needs no space
|
||||
} else {
|
||||
stbrp__findresult fr = stbrp__skyline_pack_rectangle(context, rects[i].w, rects[i].h);
|
||||
if (fr.prev_link) {
|
||||
rects[i].x = (stbrp_coord) fr.x;
|
||||
rects[i].y = (stbrp_coord) fr.y;
|
||||
} else {
|
||||
rects[i].x = rects[i].y = STBRP__MAXVAL;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// unsort
|
||||
STBRP_SORT(rects, num_rects, sizeof(rects[0]), rect_original_order);
|
||||
|
||||
// set was_packed flags and all_rects_packed status
|
||||
for (i=0; i < num_rects; ++i) {
|
||||
rects[i].was_packed = !(rects[i].x == STBRP__MAXVAL && rects[i].y == STBRP__MAXVAL);
|
||||
if (!rects[i].was_packed)
|
||||
all_rects_packed = 0;
|
||||
}
|
||||
|
||||
// return the all_rects_packed status
|
||||
return all_rects_packed;
|
||||
}
|
||||
#endif
|
||||
|
||||
/*
|
||||
------------------------------------------------------------------------------
|
||||
This software is available under 2 licenses -- choose whichever you prefer.
|
||||
------------------------------------------------------------------------------
|
||||
ALTERNATIVE A - MIT License
|
||||
Copyright (c) 2017 Sean Barrett
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
this software and associated documentation files (the "Software"), to deal in
|
||||
the Software without restriction, including without limitation the rights to
|
||||
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
|
||||
of the Software, and to permit persons to whom the Software is furnished to do
|
||||
so, subject to the following conditions:
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
------------------------------------------------------------------------------
|
||||
ALTERNATIVE B - Public Domain (www.unlicense.org)
|
||||
This is free and unencumbered software released into the public domain.
|
||||
Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
|
||||
software, either in source code form or as a compiled binary, for any purpose,
|
||||
commercial or non-commercial, and by any means.
|
||||
In jurisdictions that recognize copyright laws, the author or authors of this
|
||||
software dedicate any and all copyright interest in the software to the public
|
||||
domain. We make this dedication for the benefit of the public at large and to
|
||||
the detriment of our heirs and successors. We intend this dedication to be an
|
||||
overt act of relinquishment in perpetuity of all present and future rights to
|
||||
this software under copyright law.
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
------------------------------------------------------------------------------
|
||||
*/
|
File diff suppressed because it is too large
Load Diff
@ -1,2 +0,0 @@
|
||||
#define STB_IMAGE_IMPLEMENTATION
|
||||
#include "stb_image.h"
|
8
src/libs/stb_impl.cpp
Normal file
8
src/libs/stb_impl.cpp
Normal file
@ -0,0 +1,8 @@
|
||||
#define STB_IMAGE_IMPLEMENTATION
|
||||
#include "stb_image.h"
|
||||
#define STB_IMAGE_WRITE_IMPLEMENTATION
|
||||
#include "stb_image_write.h"
|
||||
#define STB_RECT_PACK_IMPLEMENTATION
|
||||
#include "stb_rect_pack.h"
|
||||
#define STB_TRUETYPE_IMPLEMENTATION
|
||||
#include "stb_truetype.h"
|
@ -1,2 +0,0 @@
|
||||
#define STB_TRUETYPE_IMPLEMENTATION
|
||||
#include <stb_truetype.h>
|
18
src/util/gltf_loader.cpp
Normal file
18
src/util/gltf_loader.cpp
Normal file
@ -0,0 +1,18 @@
|
||||
#include "util/gltf_loader.h"
|
||||
|
||||
#include "log.h"
|
||||
#include "util/files.h"
|
||||
|
||||
namespace engine::util {
|
||||
|
||||
engine::Entity LoadGLTF(Scene& scene, const std::string& path, bool isStatic)
|
||||
{
|
||||
|
||||
auto file = ReadTextFile(path);
|
||||
|
||||
|
||||
|
||||
return static_cast<Entity>(0u);
|
||||
}
|
||||
|
||||
} // namespace engine::util
|
@ -15,13 +15,15 @@
|
||||
#include "scene_manager.h"
|
||||
#include "systems/mesh_render_system.h"
|
||||
#include "systems/transform.h"
|
||||
#include "util/gltf_loader.h"
|
||||
#include "util/model_loader.h"
|
||||
#include "log.h"
|
||||
#include "window.h"
|
||||
|
||||
#include "config.h"
|
||||
|
||||
static void ConfigureInputs(engine::InputManager* input_manager) {
|
||||
static void ConfigureInputs(engine::InputManager* input_manager)
|
||||
{
|
||||
// user interface mappings
|
||||
input_manager->AddInputButton("fullscreen", engine::inputs::Key::K_F11);
|
||||
input_manager->AddInputButton("exit", engine::inputs::Key::K_ESCAPE);
|
||||
@ -31,19 +33,17 @@ static void ConfigureInputs(engine::InputManager* input_manager) {
|
||||
input_manager->AddInputButton("jump", engine::inputs::Key::K_SPACE);
|
||||
input_manager->AddInputButton("sprint", engine::inputs::Key::K_LSHIFT);
|
||||
// game movement
|
||||
input_manager->AddInputButtonAsAxis("movex", engine::inputs::Key::K_D,
|
||||
engine::inputs::Key::K_A);
|
||||
input_manager->AddInputButtonAsAxis("movey", engine::inputs::Key::K_W,
|
||||
engine::inputs::Key::K_S);
|
||||
input_manager->AddInputButtonAsAxis("movex", engine::inputs::Key::K_D, engine::inputs::Key::K_A);
|
||||
input_manager->AddInputButtonAsAxis("movey", engine::inputs::Key::K_W, engine::inputs::Key::K_S);
|
||||
// looking around
|
||||
input_manager->AddInputAxis("lookx", engine::inputs::MouseAxis::X);
|
||||
input_manager->AddInputAxis("looky", engine::inputs::MouseAxis::Y);
|
||||
}
|
||||
|
||||
void PlayGame(GameSettings settings) {
|
||||
void PlayGame(GameSettings settings)
|
||||
{
|
||||
LOG_INFO("FPS limiter: {}", settings.enable_frame_limiter ? "ON" : "OFF");
|
||||
LOG_INFO("Graphics Validation: {}",
|
||||
settings.enable_validation ? "ON" : "OFF");
|
||||
LOG_INFO("Graphics Validation: {}", settings.enable_validation ? "ON" : "OFF");
|
||||
|
||||
engine::gfx::GraphicsSettings graphics_settings{};
|
||||
graphics_settings.enable_validation = settings.enable_validation;
|
||||
@ -66,8 +66,7 @@ void PlayGame(GameSettings settings) {
|
||||
/* as of right now, the entity with tag 'camera' is used to build the view
|
||||
* matrix */
|
||||
|
||||
auto camera_transform =
|
||||
my_scene->GetComponent<engine::TransformComponent>(camera);
|
||||
auto camera_transform = my_scene->GetComponent<engine::TransformComponent>(camera);
|
||||
camera_transform->position = {0.0f, 0.0f, 10.0f};
|
||||
|
||||
my_scene->RegisterComponent<CameraControllerComponent>();
|
||||
@ -76,73 +75,60 @@ void PlayGame(GameSettings settings) {
|
||||
}
|
||||
|
||||
/* shared resources */
|
||||
auto grass_texture = std::make_shared<engine::resources::Texture>(
|
||||
app.renderer(), app.GetResourcePath("textures/grass.png"),
|
||||
auto grass_texture = std::make_shared<engine::resources::Texture>(app.renderer(), app.GetResourcePath("textures/grass.png"),
|
||||
engine::resources::Texture::Filtering::kAnisotropic);
|
||||
|
||||
auto sky_texture = std::make_shared<engine::resources::Texture>(
|
||||
app.renderer(), app.GetResourcePath("textures/sky.jpg"),
|
||||
auto sky_texture = std::make_shared<engine::resources::Texture>(app.renderer(), app.GetResourcePath("textures/sky.jpg"),
|
||||
engine::resources::Texture::Filtering::kAnisotropic);
|
||||
|
||||
/* skybox */
|
||||
{
|
||||
engine::Entity skybox = my_scene->CreateEntity("skybox");
|
||||
|
||||
auto skybox_renderable =
|
||||
my_scene->AddComponent<engine::MeshRenderableComponent>(skybox);
|
||||
skybox_renderable->material =
|
||||
std::make_unique<engine::resources::Material>(
|
||||
app.GetResource<engine::resources::Shader>("builtin.skybox"));
|
||||
auto skybox_renderable = my_scene->AddComponent<engine::MeshRenderableComponent>(skybox);
|
||||
skybox_renderable->material = std::make_unique<engine::resources::Material>(app.GetResource<engine::resources::Shader>("builtin.skybox"));
|
||||
skybox_renderable->material->texture_ = sky_texture;
|
||||
skybox_renderable->mesh = GenCuboidMesh(app.renderer()->GetDevice(),
|
||||
10.0f, 10.0f, 10.0f, 1.0f, true);
|
||||
skybox_renderable->mesh = GenCuboidMesh(app.renderer()->GetDevice(), 10.0f, 10.0f, 10.0f, 1.0f, true);
|
||||
|
||||
auto skybox_transform =
|
||||
my_scene->GetComponent<engine::TransformComponent>(skybox);
|
||||
auto skybox_transform = my_scene->GetComponent<engine::TransformComponent>(skybox);
|
||||
skybox_transform->is_static = true;
|
||||
skybox_transform->position = {-5.0f, -5.0f, -5.0f};
|
||||
}
|
||||
|
||||
/* floor */
|
||||
{
|
||||
engine::Entity floor = engine::util::LoadMeshFromFile(
|
||||
my_scene, app.GetResourcePath("models/terrain.dae"), true);
|
||||
engine::Entity floor = engine::util::LoadMeshFromFile(my_scene, app.GetResourcePath("models/terrain.dae"), true);
|
||||
|
||||
auto floor_transform =
|
||||
my_scene->GetComponent<engine::TransformComponent>(floor);
|
||||
auto floor_transform = my_scene->GetComponent<engine::TransformComponent>(floor);
|
||||
floor_transform->is_static = true;
|
||||
}
|
||||
|
||||
/* building */
|
||||
{
|
||||
auto cobbleHouse = engine::util::LoadMeshFromFile(
|
||||
my_scene, app.GetResourcePath("models/cobble_house/cobble_house.dae"),
|
||||
false);
|
||||
my_scene->GetComponent<engine::TransformComponent>(cobbleHouse)
|
||||
->position += glm::vec3{33.0f, 35.0f, 0.1f};
|
||||
auto cobbleCustom =
|
||||
my_scene->AddComponent<engine::CustomComponent>(cobbleHouse);
|
||||
cobbleCustom->onInit = [](void) {
|
||||
LOG_INFO("Cobble house spin component initialised!");
|
||||
};
|
||||
auto cobbleHouse = engine::util::LoadMeshFromFile(my_scene, app.GetResourcePath("models/cobble_house/cobble_house.dae"), false);
|
||||
my_scene->GetComponent<engine::TransformComponent>(cobbleHouse)->position += glm::vec3{33.0f, 35.0f, 0.1f};
|
||||
auto cobbleCustom = my_scene->AddComponent<engine::CustomComponent>(cobbleHouse);
|
||||
cobbleCustom->onInit = [](void) { LOG_INFO("Cobble house spin component initialised!"); };
|
||||
cobbleCustom->onUpdate = [&](float ts) {
|
||||
static auto t =
|
||||
my_scene->GetComponent<engine::TransformComponent>(cobbleHouse);
|
||||
static auto t = my_scene->GetComponent<engine::TransformComponent>(cobbleHouse);
|
||||
t->rotation *= glm::angleAxis(ts, glm::vec3{0.0f, 0.0f, 1.0f});
|
||||
};
|
||||
}
|
||||
|
||||
static auto cube = engine::util::LoadMeshFromFile(my_scene, app.GetResourcePath("models/far_away_cube.dae"), true);
|
||||
{
|
||||
engine::Entity cube = my_scene->CreateEntity("cube", 0, glm::vec3{40.0f, 10.0f, 5.0f});
|
||||
auto cubeRenderable = my_scene->AddComponent<engine::MeshRenderableComponent>(cube);
|
||||
cubeRenderable->mesh = GenCuboidMesh(app.renderer()->GetDevice(), 1.0f, 1.0f, 1.0f);
|
||||
cubeRenderable->material = std::make_unique<engine::resources::Material>(app.GetResource<engine::resources::Shader>("builtin.standard"));
|
||||
cubeRenderable->material->texture_ = std::make_unique<engine::resources::Texture>(app.renderer(), app.GetResourcePath("textures/uvcheck.png"),
|
||||
engine::resources::Texture::Filtering::kAnisotropic);
|
||||
}
|
||||
|
||||
/* some text */
|
||||
{
|
||||
engine::Entity textbox =
|
||||
my_scene->CreateEntity("textbox", 0, glm::vec3{0.0f, 0.8f, 0.0f});
|
||||
auto textboxComponent =
|
||||
my_scene->AddComponent<engine::CustomComponent>(textbox);
|
||||
textboxComponent->onInit = [](void) {
|
||||
LOG_DEBUG("Textbox custom component initialised!");
|
||||
};
|
||||
engine::Entity textbox = my_scene->CreateEntity("textbox", 0, glm::vec3{0.0f, 0.8f, 0.0f});
|
||||
auto textboxComponent = my_scene->AddComponent<engine::CustomComponent>(textbox);
|
||||
textboxComponent->onInit = [](void) { LOG_DEBUG("Textbox custom component initialised!"); };
|
||||
|
||||
textboxComponent->onUpdate = [&](float ts) {
|
||||
static float time_elapsed;
|
||||
@ -154,15 +140,15 @@ void PlayGame(GameSettings settings) {
|
||||
}
|
||||
|
||||
engine::util::LoadMeshFromFile(my_scene, app.GetResourcePath("models/MY_AXES.dae"), true);
|
||||
my_scene->GetComponent<engine::TransformComponent>(engine::util::LoadMeshFromFile(my_scene, app.GetResourcePath("models/uvcheck.dae"), true))->position += glm::vec3{20.0f, 20.0f, 20.0f};
|
||||
my_scene->GetComponent<engine::TransformComponent>(engine::util::LoadMeshFromFile(my_scene, app.GetResourcePath("models/uvcheck.dae"), true))
|
||||
->position += glm::vec3{20.0f, 20.0f, 20.0f};
|
||||
|
||||
/* teapot */
|
||||
my_scene
|
||||
->GetComponent<engine::TransformComponent>(
|
||||
engine::util::LoadMeshFromFile(
|
||||
my_scene, app.GetResourcePath("models/teapot.dae"), true))
|
||||
my_scene->GetComponent<engine::TransformComponent>(engine::util::LoadMeshFromFile(my_scene, app.GetResourcePath("models/teapot.dae"), true))
|
||||
->position += glm::vec3{10.0f, 10.0f, 10.0f};
|
||||
|
||||
//engine::util::LoadGLTF(*my_scene, app.GetResourcePath("engine/models/test/test.gltf"));
|
||||
|
||||
app.GameLoop();
|
||||
}
|
||||
}
|
||||
|
@ -8,10 +8,8 @@
|
||||
|
||||
#include "resources/mesh.h"
|
||||
|
||||
std::unique_ptr<engine::resources::Mesh> GenSphereMesh(engine::GFXDevice* gfx,
|
||||
float r, int detail,
|
||||
bool wind_inside,
|
||||
bool flip_normals) {
|
||||
std::unique_ptr<engine::resources::Mesh> GenSphereMesh(engine::GFXDevice* gfx, float r, int detail, bool wind_inside, bool flip_normals)
|
||||
{
|
||||
using namespace glm;
|
||||
|
||||
std::vector<engine::Vertex> vertices{};
|
||||
@ -27,14 +25,10 @@ std::unique_ptr<engine::resources::Mesh> GenSphereMesh(engine::GFXDevice* gfx,
|
||||
float phi = j * angle_step;
|
||||
float phi2 = phi + angle_step;
|
||||
|
||||
vec3 top_left{r * sin(phi) * cos(theta), r * cos(phi),
|
||||
r * sin(phi) * sin(theta)};
|
||||
vec3 bottom_left{r * sin(phi) * cos(theta2), r * cos(phi),
|
||||
r * sin(phi) * sin(theta2)};
|
||||
vec3 top_right{r * sin(phi2) * cos(theta), r * cos(phi2),
|
||||
r * sin(phi2) * sin(theta)};
|
||||
vec3 bottom_right{r * sin(phi2) * cos(theta2), r * cos(phi2),
|
||||
r * sin(phi2) * sin(theta2)};
|
||||
vec3 top_left{r * sin(phi) * cos(theta), r * cos(phi), r * sin(phi) * sin(theta)};
|
||||
vec3 bottom_left{r * sin(phi) * cos(theta2), r * cos(phi), r * sin(phi) * sin(theta2)};
|
||||
vec3 top_right{r * sin(phi2) * cos(theta), r * cos(phi2), r * sin(phi2) * sin(theta)};
|
||||
vec3 bottom_right{r * sin(phi2) * cos(theta2), r * cos(phi2), r * sin(phi2) * sin(theta2)};
|
||||
|
||||
if (wind_inside == false) {
|
||||
// tris are visible from outside the sphere
|
||||
@ -47,8 +41,8 @@ std::unique_ptr<engine::resources::Mesh> GenSphereMesh(engine::GFXDevice* gfx,
|
||||
vertices.push_back({top_right, {}, {1.0f, 0.0f}});
|
||||
vertices.push_back({top_left, {}, {0.0f, 0.0f}});
|
||||
vertices.push_back({bottom_right, {}, {1.0f, 1.0f}});
|
||||
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
// tris are visible from inside the sphere
|
||||
|
||||
// triangle 1
|
||||
@ -81,10 +75,8 @@ std::unique_ptr<engine::resources::Mesh> GenSphereMesh(engine::GFXDevice* gfx,
|
||||
return std::make_unique<engine::resources::Mesh>(gfx, vertices);
|
||||
}
|
||||
|
||||
std::unique_ptr<engine::resources::Mesh> GenCuboidMesh(engine::GFXDevice* gfx,
|
||||
float x, float y,
|
||||
float z, float tiling,
|
||||
bool wind_inside) {
|
||||
std::unique_ptr<engine::resources::Mesh> GenCuboidMesh(engine::GFXDevice* gfx, float x, float y, float z, float tiling, bool wind_inside)
|
||||
{
|
||||
// x goes ->
|
||||
// y goes ^
|
||||
// z goes into the screen
|
||||
@ -94,52 +86,47 @@ std::unique_ptr<engine::resources::Mesh> GenCuboidMesh(engine::GFXDevice* gfx,
|
||||
std::vector<engine::Vertex> v{};
|
||||
|
||||
// front
|
||||
v.push_back({{x, 0.0f, 0.0f}, {0.0f, 0.0f, -1.0f}, {tiling, 0.0f}});
|
||||
v.push_back({{0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, -1.0f}, {0.0f, 0.0f}});
|
||||
v.push_back({{0.0f, y, 0.0f}, {0.0f, 0.0f, -1.0f}, {0.0f, tiling}});
|
||||
v.push_back({{x, 0.0f, 0.0f}, {0.0f, 0.0f, -1.0f}, {tiling, 0.0f}});
|
||||
v.push_back({{0.0f, y, 0.0f}, {0.0f, 0.0f, -1.0f}, {0.0f, tiling}});
|
||||
v.push_back({{x, y, 0.0f}, {0.0f, 0.0f, -1.0f}, {tiling, tiling}});
|
||||
|
||||
v.push_back({ {0.0f, 0.0f, z}, {0.0f, -1.0f, 0.0f}, {0.0f, 0.0f} });
|
||||
v.push_back({ {0.0f, 0.0f, 0.0f}, {0.0f, -1.0f, 0.0f}, {0.0f, tiling} });
|
||||
v.push_back({ {x, 0.0f, 0.0f}, {0.0f, -1.0f, 0.0f}, {tiling, tiling} });
|
||||
v.push_back({ {x, 0.0f, 0.0f}, {0.0f, -1.0f, 0.0f}, {tiling, tiling} });
|
||||
v.push_back({ {x, 0.0f, z}, {0.0f, -1.0f, 0.0f}, {tiling, 0.0f} });
|
||||
v.push_back({ {0.0f, 0.0f, z}, {0.0f, -1.0f, 0.0f}, {0.0f, 0.0f} });
|
||||
// back
|
||||
v.push_back({{0.0f, 0.0f, z}, {0.0f, 0.0f, 1.0f}, {0.0f, 0.0f}});
|
||||
v.push_back({{x, 0.0f, z}, {0.0f, 0.0f, 1.0f}, {tiling, 0.0f}});
|
||||
v.push_back({{0.0f, y, z}, {0.0f, 0.0f, 1.0f}, {0.0f, tiling}});
|
||||
v.push_back({{x, 0.0f, z}, {0.0f, 0.0f, 1.0f}, {tiling, 0.0f}});
|
||||
v.push_back({{x, y, z}, {0.0f, 0.0f, 1.0f}, {tiling, tiling}});
|
||||
v.push_back({{0.0f, y, z}, {0.0f, 0.0f, 1.0f}, {0.0f, tiling}});
|
||||
|
||||
v.push_back({ {x, y, z}, {0.0f, 1.0f, 0.0f}, {0.0f, 0.0f} });
|
||||
v.push_back({ {x, y, 0.0f}, {0.0f, 1.0f, 0.0f}, {0.0f, tiling} });
|
||||
v.push_back({ {0.0f, y, 0.0f}, {0.0f, 1.0f, 0.0f}, {tiling, tiling} });
|
||||
v.push_back({ {0.0f, y, 0.0f}, {0.0f, 1.0f, 0.0f}, {tiling, tiling} });
|
||||
v.push_back({ {0.0f, y, z}, {0.0f, 1.0f, 0.0f}, {tiling, 0.0f} });
|
||||
v.push_back({ {x, y, z}, {0.0f, 1.0f, 0.0f}, {0.0f, 0.0f} });
|
||||
// left
|
||||
v.push_back({{0.0f, 0.0f, 0.0f}, {-1.0f, 0.0f, 0.0f}, {0.0f, 0.0f}});
|
||||
v.push_back({{0.0f, 0.0f, x}, {-1.0f, 0.0f, 0.0f}, {0.0f, tiling}});
|
||||
v.push_back({{0.0f, y, 0.0f}, {-1.0f, 0.0f, 0.0f}, {tiling, 0.0f}});
|
||||
v.push_back({{0.0f, 0.0f, x}, {-1.0f, 0.0f, 0.0f}, {0.0f, tiling}});
|
||||
v.push_back({{0.0f, y, x}, {-1.0f, 0.0f, 0.0f}, {tiling, tiling}});
|
||||
v.push_back({{0.0f, y, 0.0f}, {-1.0f, 0.0f, 0.0f}, {tiling, 0.0f}});
|
||||
|
||||
v.push_back({ {0.0f, y, z}, {-1.0f, 0.0f, 0.0f}, {0.0f, 0.0f} });
|
||||
v.push_back({ {0.0f, y, 0.0f}, {-1.0f, 0.0f, 0.0f}, {0.0f, tiling} });
|
||||
v.push_back({ {0.0f, 0.0f, 0.0f}, {-1.0f, 0.0f, 0.0f}, {tiling, tiling} });
|
||||
v.push_back({ {0.0f, 0.0f, 0.0f}, {-1.0f, 0.0f, 0.0f}, {tiling, tiling} });
|
||||
v.push_back({ {0.0f, 0.0f, z}, {-1.0f, 0.0f, 0.0f}, {tiling, 0.0f} });
|
||||
v.push_back({ {0.0f, y, z}, {-1.0f, 0.0f, 0.0f}, {0.0f, 0.0f} });
|
||||
// right
|
||||
v.push_back({{x, y, 0.0f}, {1.0f, 0.0f, 0.0f}, {tiling, 0.0f}});
|
||||
v.push_back({{x, 0.0f, x}, {1.0f, 0.0f, 0.0f}, {0.0f, tiling}});
|
||||
v.push_back({{x, 0.0f, 0.0f}, {1.0f, 0.0f, 0.0f}, {0.0f, 0.0f}});
|
||||
v.push_back({{x, y, 0.0f}, {1.0f, 0.0f, 0.0f}, {tiling, 0.0f}});
|
||||
v.push_back({{x, y, x}, {1.0f, 0.0f, 0.0f}, {tiling, tiling}});
|
||||
v.push_back({{x, 0.0f, x}, {1.0f, 0.0f, 0.0f}, {0.0f, tiling}});
|
||||
|
||||
// bottom
|
||||
v.push_back({{0.0f, 0.0f, z}, {0.0f, -1.0f, 0.0f}, {0.0f, tiling}});
|
||||
v.push_back({{0.0f, 0.0f, 0.0f}, {0.0f, -1.0f, 0.0f}, {0.0f, 0.0f}});
|
||||
v.push_back({{x, 0.0f, 0.0f}, {0.0f, -1.0f, 0.0f}, {tiling, 0.0f}});
|
||||
v.push_back({{x, 0.0f, z}, {0.0f, -1.0f, 0.0f}, {tiling, tiling}});
|
||||
v.push_back({{0.0f, 0.0f, z}, {0.0f, -1.0f, 0.0f}, {0.0f, tiling}});
|
||||
v.push_back({{x, 0.0f, 0.0f}, {0.0f, -1.0f, 0.0f}, {tiling, 0.0f}});
|
||||
|
||||
v.push_back({ {x, 0.0f, z}, {1.0f, 0.0f, 0.0f}, {0.0f, 0.0f} });
|
||||
v.push_back({ {x, 0.0f, 0.0f}, {1.0f, 0.0f, 0.0f}, {0.0f, tiling} });
|
||||
v.push_back({ {x, y, 0.0f}, {1.0f, 0.0f, 0.0f}, {tiling, tiling} });
|
||||
v.push_back({ {x, y, 0.0f}, {1.0f, 0.0f, 0.0f}, {tiling, tiling} });
|
||||
v.push_back({ {x, y, z}, {1.0f, 0.0f, 0.0f}, {tiling, 0.0f} });
|
||||
v.push_back({ {x, 0.0f, z}, {1.0f, 0.0f, 0.0f}, {0.0f, 0.0f} });
|
||||
// top
|
||||
v.push_back({{x, y, 0.0f}, {0.0f, 1.0f, 0.0f}, {tiling, 0.0f}});
|
||||
v.push_back({{0.0f, y, 0.0f}, {0.0f, 1.0f, 0.0f}, {0.0f, 0.0f}});
|
||||
v.push_back({{0.0f, y, z}, {0.0f, 1.0f, 0.0f}, {0.0f, tiling}});
|
||||
v.push_back({{x, y, 0.0f}, {0.0f, 1.0f, 0.0f}, {tiling, 0.0f}});
|
||||
v.push_back({{0.0f, y, z}, {0.0f, 1.0f, 0.0f}, {0.0f, tiling}});
|
||||
v.push_back({{x, y, z}, {0.0f, 1.0f, 0.0f}, {tiling, tiling}});
|
||||
v.push_back({ {0.0f, y, z}, {0.0f, 0.0f, 1.0f}, {0.0f, 0.0f} });
|
||||
v.push_back({ {0.0f, 0.0f, z}, {0.0f, 0.0f, 1.0f}, {0.0f, tiling} });
|
||||
v.push_back({ {x, 0.0f, z}, {0.0f, 0.0f, 1.0f}, {tiling, tiling} });
|
||||
v.push_back({ {x, 0.0f, z}, {0.0f, 0.0f, 1.0f}, {tiling, tiling} });
|
||||
v.push_back({ {x, y, z}, {0.0f, 0.0f, 1.0f}, {tiling, 0.0f} });
|
||||
v.push_back({ {0.0f, y, z}, {0.0f, 0.0f, 1.0f}, {0.0f, 0.0f} });
|
||||
// bottom
|
||||
v.push_back({ {x, y, 0.0f}, {0.0f, 0.0f, -1.0f}, {0.0f, 0.0f} });
|
||||
v.push_back({ {x, 0.0f, 0.0f}, {0.0f, 0.0f, -1.0f}, {0.0f, tiling} });
|
||||
v.push_back({ {0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, -1.0f}, {tiling, tiling} });
|
||||
v.push_back({ {0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, -1.0f}, {tiling, tiling} });
|
||||
v.push_back({ {0.0f, y, 0.0f}, {0.0f, 0.0f, -1.0f}, {tiling, 0.0f} });
|
||||
v.push_back({ {x, y, 0.0f}, {0.0f, 0.0f, -1.0f}, {0.0f, 0.0f} });
|
||||
|
||||
if (wind_inside) {
|
||||
for (size_t i = 0; i < v.size(); i += 3) {
|
||||
|
Loading…
Reference in New Issue
Block a user