Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found

Target

Select target project
  • gamedev/fggl
  • onuralpsezer/fggl
2 results
Show changes
Hide whitespace changes
Inline Side-by-side
Showing
with 776 additions and 326 deletions
fggl/entity/module.cpp
View file @ bd58e207
...@@ -37,21 +37,54 @@ namespace fggl::entity { ...@@ -37,21 +37,54 @@ namespace fggl::entity {
factory->bind(math::Transform::guid, make_transform); factory->bind(math::Transform::guid, make_transform);
} }
bool ECS::factory(modules::ModuleService service, modules::Services &services) { static auto is_scene(std::filesystem::path path) -> assets::AssetTypeID {
if ( path.extension() == ".yml" ) {
return ENTITY_SCENE;
}
return assets::INVALID_ASSET_TYPE;
}
auto get_scene_deps(const std::string& /*packName*/, std::filesystem::path /*packRoot*/, assets::ResourceRecord& rr) -> bool {
auto nodes = YAML::LoadAllFromFile( rr.m_path );
for ( auto& node : nodes ) {
auto scripts = node["scripts"];
if ( !scripts ) {
continue;
}
for (auto script : scripts) {
auto scriptName = script.as<std::string>();
auto scriptRef = assets::asset_from_user(scriptName, rr.m_pack);
rr.m_requires.push_back(scriptRef);
}
}
return true;
}
auto ECS::factory(modules::ServiceName service, modules::Services &services) -> bool {
if (service == EntityFactory::service) { if (service == EntityFactory::service) {
auto *factory = services.create<EntityFactory>(services); auto *factory = services.create<EntityFactory>(services);
install_component_factories(factory); install_component_factories(factory);
// we are responsible for prefabs... // we are responsible for prefabs...
auto *assetLoader = services.get<assets::Loader>(); auto *assetLoader = services.get<assets::Loader>();
assetLoader->setFactory(PROTOTYPE_ASSET, [factory](assets::Loader* loader, const assets::AssetGUID &a, assets::AssetData b, void* ptr) { assetLoader->setFactory(ENTITY_PROTOTYPE, [factory](assets::Loader* loader, const assets::AssetID& a, assets::LoaderContext b, void* ptr) {
EntityFactory* facPtr = factory; EntityFactory* facPtr = factory;
if ( ptr != nullptr ) { if ( ptr != nullptr ) {
facPtr = (EntityFactory*)ptr; facPtr = (EntityFactory*)ptr;
} }
return load_prototype(loader, a, b, facPtr); return load_prototype(loader, a, b, facPtr);
}, assets::LoadType::PATH); }, assets::LoadType::PATH);
assetLoader->setFactory(SCENE, load_scene, assets::LoadType::PATH); assetLoader->setFactory(ENTITY_SCENE, load_scene, assets::LoadType::PATH);
// allow auto-detection
auto *checkin = services.get<assets::CheckinAdapted>();
checkin->setLoader(MIME_SCENE, assets::NEEDS_CHECKIN, is_scene);
checkin->setProcessor(MIME_SCENE, get_scene_deps);
return true; return true;
} }
......
fggl/gfx/atlas.cpp
View file @ bd58e207
...@@ -14,10 +14,8 @@ ...@@ -14,10 +14,8 @@
#include <fggl/gfx/atlas.hpp> #include <fggl/gfx/atlas.hpp>
#include <fggl/math/types.hpp>
#include <array> #include <array>
#include <vector> #include <vector>
#include <string>
#define STBRP_STATIC #define STBRP_STATIC
#define STB_RECT_PACK_IMPLEMENTATION #define STB_RECT_PACK_IMPLEMENTATION
...@@ -44,8 +42,8 @@ static void unpack_stbrp_query(Query &query, std::vector<stbrp_rect> &data) { ...@@ -44,8 +42,8 @@ static void unpack_stbrp_query(Query &query, std::vector<stbrp_rect> &data) {
} }
} }
bool pack_iter(int width, int height, std::vector<stbrp_rect> &query) { auto pack_iter(int width, int height, std::vector<stbrp_rect> &query) -> bool {
stbrp_node *tmp = new stbrp_node[width]; auto *tmp = new stbrp_node[width];
// setup context // setup context
stbrp_context context; stbrp_context context;
...@@ -58,7 +56,7 @@ bool pack_iter(int width, int height, std::vector<stbrp_rect> &query) { ...@@ -58,7 +56,7 @@ bool pack_iter(int width, int height, std::vector<stbrp_rect> &query) {
namespace fggl::gfx { namespace fggl::gfx {
bool pack(std::vector<Bounds2D> &pack) { auto pack(std::vector<Bounds2D> &pack) -> bool {
// setup query structure // setup query structure
std::vector<stbrp_rect> query; std::vector<stbrp_rect> query;
query.reserve(pack.size()); query.reserve(pack.size());
......
fggl/gfx/input.cpp
View file @ bd58e207
...@@ -13,10 +13,6 @@ ...@@ -13,10 +13,6 @@
*/ */
#include <fggl/gfx/input.hpp> #include <fggl/gfx/input.hpp>
#include <cassert>
#include <bitset>
#include <iostream>
using fggl::gfx::Input; using fggl::gfx::Input;
...@@ -57,15 +53,15 @@ void Input::mousePos(double x, double y) { ...@@ -57,15 +53,15 @@ void Input::mousePos(double x, double y) {
m_mouse_curr.cursor[1] = y; m_mouse_curr.cursor[1] = y;
} }
double Input::cursorDeltaX() const { auto Input::cursorDeltaX() const -> double {
return m_mouse_last.cursor[0] - m_mouse_curr.cursor[0]; return m_mouse_last.cursor[0] - m_mouse_curr.cursor[0];
} }
double Input::cursorDeltaY() const { auto Input::cursorDeltaY() const -> double {
return m_mouse_last.cursor[1] - m_mouse_curr.cursor[1]; return m_mouse_last.cursor[1] - m_mouse_curr.cursor[1];
} }
const double *Input::mousePos() const { auto Input::mousePos() const -> const double * {
return m_mouse_curr.scroll.data(); return m_mouse_curr.scroll.data();
} }
...@@ -74,15 +70,15 @@ void Input::mouseScroll(double deltaX, double deltaY) { ...@@ -74,15 +70,15 @@ void Input::mouseScroll(double deltaX, double deltaY) {
m_mouse_curr.scroll[1] = deltaY; m_mouse_curr.scroll[1] = deltaY;
} }
const double *Input::mouseScroll() const { auto Input::mouseScroll() const -> const double * {
return m_mouse_curr.scroll.data(); return m_mouse_curr.scroll.data();
} }
double Input::scrollDeltaX() const { auto Input::scrollDeltaX() const -> double {
return m_mouse_curr.scroll[0]; return m_mouse_curr.scroll[0];
} }
double Input::scrollDeltaY() const { auto Input::scrollDeltaY() const -> double {
return m_mouse_curr.scroll[1]; return m_mouse_curr.scroll[1];
} }
...@@ -94,15 +90,15 @@ void Input::mouseBtn(const MouseButton btn, bool state) { ...@@ -94,15 +90,15 @@ void Input::mouseBtn(const MouseButton btn, bool state) {
} }
} }
bool Input::mouseDown(const MouseButton btn) const { auto Input::mouseDown(const MouseButton btn) const -> bool {
return m_mouse_curr.buttons & btn; return m_mouse_curr.buttons & btn;
} }
bool Input::mousePressed(const MouseButton btn) const { auto Input::mousePressed(const MouseButton btn) const -> bool {
return (m_mouse_curr.buttons & btn) && !(m_mouse_last.buttons & btn); return (m_mouse_curr.buttons & btn) && !(m_mouse_last.buttons & btn);
} }
bool Input::mouseReleased(const MouseButton btn) const { auto Input::mouseReleased(const MouseButton btn) const -> bool {
return !(m_mouse_curr.buttons & btn) && (m_mouse_last.buttons & btn); return !(m_mouse_curr.buttons & btn) && (m_mouse_last.buttons & btn);
} }
...@@ -118,11 +114,11 @@ void Input::joystickDisconnect(int id) { ...@@ -118,11 +114,11 @@ void Input::joystickDisconnect(int id) {
m_joydata[id] = Joystick(); m_joydata[id] = Joystick();
} }
bool Input::hasJoystick(int id) const { auto Input::hasJoystick(int id) const -> bool {
return m_joysticks[id]; return m_joysticks[id];
} }
const fggl::gfx::Joystick &Input::joystick(int id) const { auto Input::joystick(int id) const -> const fggl::gfx::Joystick & {
return m_joydata[id]; return m_joydata[id];
} }
...@@ -130,22 +126,22 @@ void Input::padState(int id, const PadState &state) { ...@@ -130,22 +126,22 @@ void Input::padState(int id, const PadState &state) {
m_pad_curr[id] = state; m_pad_curr[id] = state;
} }
bool Input::padDown(int id, PadButton btn) { auto Input::padDown(int id, PadButton btn) -> bool {
return m_pad_curr[id].buttons[(int) btn]; return m_pad_curr[id].buttons[(int) btn];
} }
bool Input::padPressed(int id, PadButton btn) { auto Input::padPressed(int id, PadButton btn) -> bool {
return m_pad_curr[id].buttons[(int) btn] && !m_pad_last[id].buttons[(int) btn]; return m_pad_curr[id].buttons[(int) btn] && !m_pad_last[id].buttons[(int) btn];
} }
bool Input::padReleased(int id, PadButton btn) { auto Input::padReleased(int id, PadButton btn) -> bool {
return !m_pad_curr[id].buttons[(int) btn] && m_pad_last[id].buttons[(int) btn]; return !m_pad_curr[id].buttons[(int) btn] && m_pad_last[id].buttons[(int) btn];
} }
float Input::padAxis(int id, PadAxis axis) { auto Input::padAxis(int id, PadAxis axis) -> float {
return m_pad_curr[id].axes[(int) axis]; return m_pad_curr[id].axes[(int) axis];
} }
float Input::padAxisDelta(int id, PadAxis axis) { auto Input::padAxisDelta(int id, PadAxis axis) -> float {
return m_pad_last[id].axes[(int) axis] - m_pad_curr[id].axes[(int) axis]; return m_pad_last[id].axes[(int) axis] - m_pad_curr[id].axes[(int) axis];
} }
fggl/gfx/ogl/renderer.cpp
View file @ bd58e207
...@@ -27,7 +27,6 @@ ...@@ -27,7 +27,6 @@
#include <glm/ext/matrix_clip_space.hpp> #include <glm/ext/matrix_clip_space.hpp>
#include <glm/ext/matrix_transform.hpp> #include <glm/ext/matrix_transform.hpp>
#include <glm/glm.hpp> #include <glm/glm.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <memory> #include <memory>
...@@ -64,24 +63,15 @@ constexpr auto fggl_ogl_source(GLenum source) -> const char * { ...@@ -64,24 +63,15 @@ constexpr auto fggl_ogl_source(GLenum source) -> const char * {
constexpr auto static fggl_ogl_type(GLenum type) -> const char * { constexpr auto static fggl_ogl_type(GLenum type) -> const char * {
switch (type) { switch (type) {
case GL_DEBUG_TYPE_ERROR: return "Error"; case GL_DEBUG_TYPE_ERROR: return "Error";
break;
case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR: return "Deprecated Behaviour"; case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR: return "Deprecated Behaviour";
break;
case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR: return "Undefined Behaviour"; case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR: return "Undefined Behaviour";
break;
case GL_DEBUG_TYPE_PERFORMANCE: return "Performance"; case GL_DEBUG_TYPE_PERFORMANCE: return "Performance";
break;
case GL_DEBUG_TYPE_PORTABILITY: return "Portability"; case GL_DEBUG_TYPE_PORTABILITY: return "Portability";
break;
case GL_DEBUG_TYPE_MARKER: return "Marker"; case GL_DEBUG_TYPE_MARKER: return "Marker";
break;
case GL_DEBUG_TYPE_PUSH_GROUP: return "Push Group"; case GL_DEBUG_TYPE_PUSH_GROUP: return "Push Group";
break;
case GL_DEBUG_TYPE_POP_GROUP: return "Pop Group"; case GL_DEBUG_TYPE_POP_GROUP: return "Pop Group";
break;
default: default:
case GL_DEBUG_TYPE_OTHER: return "Other"; case GL_DEBUG_TYPE_OTHER: return "Other";
break;
} }
assert(false); assert(false);
return "unknown"; return "unknown";
...@@ -92,7 +82,7 @@ PRAGMA_DIAGNOSTIC_PUSH ...@@ -92,7 +82,7 @@ PRAGMA_DIAGNOSTIC_PUSH
constexpr const char *OGL_LOG_FMT{"[GL] {}, {}: [{}]: {}"}; constexpr const char *OGL_LOG_FMT{"[GL] {}, {}: [{}]: {}"};
void static GLAPIENTRY fggl_ogl_to_spdlog(GLenum source, void static GLAPIENTRY fggl_ogl_log(GLenum source,
GLenum type, GLenum type,
unsigned int msgId, unsigned int msgId,
GLenum severity, GLenum severity,
...@@ -139,13 +129,73 @@ namespace fggl::gfx { ...@@ -139,13 +129,73 @@ namespace fggl::gfx {
using data::Mesh2D; using data::Mesh2D;
using data::Vertex2D; using data::Vertex2D;
OpenGL4Backend::OpenGL4Backend(data::Storage *storage, gui::FontLibrary *fonts, assets::AssetManager *assets) static void setup_shaders(ShaderCache* cache) {
// FIXME this should not be hard-coded, it should be part of the scene loading process
cache->load(ShaderConfig::named("phong"));
cache->load(ShaderConfig::named("redbook/lighting"));
cache->load(ShaderConfig::named("redbook/debug"));
// debug shaders
cache->load(ShaderConfig::named("normals", true));
cache->load(ShaderConfig::named("debug"));
}
static void splat_checkerboard(GLuint* memory, unsigned int width = 128, unsigned int height = 128) {
int counter = 0;
auto colour = ogl4::TEX_CHECKER;
for ( auto i = 0u; i < width * height; ++i) {
memory[i] = ogl4::TEX_CHECKER;
counter++;
if (counter == 5) {
counter = 0;
colour = colour == ogl4::TEX_CHECKER ? ogl4::TEX_WHITE : ogl4::TEX_CHECKER;
}
}
}
static auto make_solid(uint8_t width, uint8_t height, GLuint colour) -> ogl::Image {
ogl::PixelDataArray data(ogl::PixelFormat::UNSIGNED_INT, width * height);
for ( auto i = 0u; i < width * height; ++i) {
data.ui[i] = colour;
}
return ogl::Image(
ogl::ImageFormat::RGBA,
{width, height},
std::move(data)
);
}
static void setup_fallback_texture(assets::AssetManager* assets) {
{
// generate the image
ogl::Image image(ogl::ImageFormat::RGBA, ogl::PixelFormat::UNSIGNED_INT, {128,128});
splat_checkerboard( image.data.ui );
// setup the texture
auto *fallback2D = new ogl::Texture(ogl::TextureType::Tex2D);
fallback2D->setData(ogl::InternalImageFormat::RedGreenBlueAlpha, image, ogl::PixelFormat::UNSIGNED_BYTE);
assets->set(ogl4::FALLBACK_TEX, fallback2D);
}
{
ogl::Image image = make_solid(128, 128, ogl4::TEX_WHITE);
auto *solid2D = new ogl::Texture(ogl::TextureType::Tex2D);
solid2D->setData(ogl::InternalImageFormat::RedGreenBlueAlpha, image);
assets->set(ogl4::SOLID_TEX, solid2D);
}
}
OpenGL4Backend::OpenGL4Backend(data::Storage *storage, gui::FontLibrary *fonts, assets::AssetManager *assets, GlFunctionLoader loader)
: fggl::gfx::Graphics(), m_canvasPipeline(nullptr), m_storage(storage) { : fggl::gfx::Graphics(), m_canvasPipeline(nullptr), m_storage(storage) {
// initialise GLEW, or fail
// FIXME this binds the graphics stack to GLFW :'( // load OpenGL context, or fail.
int version = gladLoadGLLoader((GLADloadproc) glfwGetProcAddress); int version = gladLoadGLLoader(loader);
if (version == 0) { if (version == 0) {
printf("Failed to initialize OpenGL context\n"); debug::error("Failed to initialize OpenGL context\n");
return;
} }
// OpenGL debug Support // OpenGL debug Support
...@@ -155,7 +205,7 @@ namespace fggl::gfx { ...@@ -155,7 +205,7 @@ namespace fggl::gfx {
debug::info("enabling OpenGL debug output"); debug::info("enabling OpenGL debug output");
glEnable(GL_DEBUG_OUTPUT); glEnable(GL_DEBUG_OUTPUT);
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS); glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
glDebugMessageCallback(fggl_ogl_to_spdlog, nullptr); glDebugMessageCallback(fggl_ogl_log, nullptr);
glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, nullptr, GL_TRUE); glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, nullptr, GL_TRUE);
} }
...@@ -165,6 +215,7 @@ namespace fggl::gfx { ...@@ -165,6 +215,7 @@ namespace fggl::gfx {
// setup the shader cache // setup the shader cache
m_cache = std::make_unique<ShaderCache>(m_storage); m_cache = std::make_unique<ShaderCache>(m_storage);
setup_shaders(m_cache.get());
// setup 2D rendering system // setup 2D rendering system
ShaderConfig shader2DConfig = ShaderConfig::named("canvas"); ShaderConfig shader2DConfig = ShaderConfig::named("canvas");
...@@ -174,10 +225,8 @@ namespace fggl::gfx { ...@@ -174,10 +225,8 @@ namespace fggl::gfx {
m_canvasPipeline = m_cache->get(ogl4::FALLBACK_CANVAS_PIPELINE); m_canvasPipeline = m_cache->get(ogl4::FALLBACK_CANVAS_PIPELINE);
} }
// FIXME this should not be hard-coded, it should be part of the scene loading process // fallback textures
m_cache->load(ShaderConfig::named("phong")); setup_fallback_texture(assets);
m_cache->load(ShaderConfig::named("redbook/lighting"));
m_cache->load(ShaderConfig::named("redbook/debug"));
// rendering helpers // rendering helpers
m_canvasRenderer = std::make_unique<ogl4::CanvasRenderer>(fonts); m_canvasRenderer = std::make_unique<ogl4::CanvasRenderer>(fonts);
...@@ -202,9 +251,9 @@ namespace fggl::gfx { ...@@ -202,9 +251,9 @@ namespace fggl::gfx {
m_canvasRenderer->render(*m_canvasPipeline, paint); m_canvasRenderer->render(*m_canvasPipeline, paint);
} }
void OpenGL4Backend::drawScene(entity::EntityManager &world) { void OpenGL4Backend::drawScene(entity::EntityManager &world, bool debugMode) {
if (m_modelRenderer) { if (m_modelRenderer) {
m_modelRenderer->render(world); m_modelRenderer->render(world, debugMode);
} }
if (m_debugRenderer) { if (m_debugRenderer) {
......
fggl/gfx/ogl/shader.cpp
View file @ bd58e207
...@@ -17,12 +17,13 @@ ...@@ -17,12 +17,13 @@
#include "fggl/gfx/ogl4/fallback.hpp" #include "fggl/gfx/ogl4/fallback.hpp"
#include <iostream> #include <iostream>
#include <fstream>
#include <vector> #include <vector>
#include <spdlog/spdlog.h> #include <spdlog/spdlog.h>
namespace fggl::gfx { namespace fggl::gfx {
bool ShaderCache::compileShaderFromSource(const std::string &source, GLuint sid) { auto ShaderCache::compileShaderFromSource(const std::string &source, GLuint sid) -> bool {
// upload and compile shader // upload and compile shader
const char *src = source.c_str(); const char *src = source.c_str();
glShaderSource(sid, 1, &src, nullptr); glShaderSource(sid, 1, &src, nullptr);
...@@ -46,7 +47,7 @@ namespace fggl::gfx { ...@@ -46,7 +47,7 @@ namespace fggl::gfx {
return true; return true;
} }
bool ShaderCache::readAndCompileShader(const std::string &filename, GLuint shader) { auto ShaderCache::readAndCompileShader(const std::string &filename, GLuint shader) -> bool {
std::string source; std::string source;
bool result = m_storage->load(fggl::data::Data, filename, &source); bool result = m_storage->load(fggl::data::Data, filename, &source);
if (!result) { if (!result) {
...@@ -88,7 +89,7 @@ namespace fggl::gfx { ...@@ -88,7 +89,7 @@ namespace fggl::gfx {
} }
bool ShaderCache::loadFromDisk(GLuint pid, const std::string &pipelineName) { auto ShaderCache::loadFromDisk(GLuint pid, const std::string &pipelineName) -> bool {
BinaryCache cache; BinaryCache cache;
auto fname = "shader_" + pipelineName + ".bin"; auto fname = "shader_" + pipelineName + ".bin";
...@@ -112,7 +113,7 @@ namespace fggl::gfx { ...@@ -112,7 +113,7 @@ namespace fggl::gfx {
m_storage->save(fggl::data::Cache, fname, &cache); m_storage->save(fggl::data::Cache, fname, &cache);
} }
ShaderCache::ShaderPtr ShaderCache::getOrLoad(const ShaderConfig &config) { auto ShaderCache::getOrLoad(const ShaderConfig &config) -> ShaderCache::ShaderPtr {
try { try {
return m_shaders.at(config.name); return m_shaders.at(config.name);
} catch (std::out_of_range &e) { } catch (std::out_of_range &e) {
...@@ -120,11 +121,15 @@ namespace fggl::gfx { ...@@ -120,11 +121,15 @@ namespace fggl::gfx {
} }
} }
ShaderCache::ShaderPtr ShaderCache::get(const std::string &name) { auto ShaderCache::get(const std::string &name) -> ShaderCache::ShaderPtr {
return m_shaders.at(name); auto itr = m_shaders.find(name);
if ( itr != m_shaders.end() ){
return itr->second;
}
return nullptr;
} }
ShaderCache::ShaderPtr ShaderCache::load(const ShaderConfig &config) { auto ShaderCache::load(const ShaderConfig &config) -> ShaderCache::ShaderPtr {
spdlog::debug("starting shader program generation for {}", config.name); spdlog::debug("starting shader program generation for {}", config.name);
GLuint pid = glCreateProgram(); GLuint pid = glCreateProgram();
...@@ -195,7 +200,7 @@ namespace fggl::gfx { ...@@ -195,7 +200,7 @@ namespace fggl::gfx {
return shaderPtr; return shaderPtr;
} }
ShaderCache::ShaderPtr ShaderCache::load(const ShaderSources &sources, bool allowBinaryCache) { auto ShaderCache::load(const ShaderSources &sources, bool allowBinaryCache) -> ShaderCache::ShaderPtr {
spdlog::debug("starting shader program generation for {}", sources.name); spdlog::debug("starting shader program generation for {}", sources.name);
...@@ -276,7 +281,7 @@ namespace fggl::gfx { ...@@ -276,7 +281,7 @@ namespace fggl::gfx {
glGetProgramBinary(pid, length, &cache->size, &cache->format, cache->data); glGetProgramBinary(pid, length, &cache->size, &cache->format, cache->data);
} }
bool ShaderCache::cacheLoad(GLuint pid, const BinaryCache *cache) { auto ShaderCache::cacheLoad(GLuint pid, const BinaryCache *cache) -> bool {
if (!m_binary) { if (!m_binary) {
return false; return false;
} }
...@@ -301,8 +306,8 @@ namespace fggl::gfx { ...@@ -301,8 +306,8 @@ namespace fggl::gfx {
} }
template<> template<>
bool fggl::data::fggl_deserialize(std::filesystem::path &data, fggl::gfx::BinaryCache *out) { auto fggl::data::fggl_deserialize(std::filesystem::path &data, fggl::gfx::BinaryCache *out) -> bool {
auto f = auto* f =
#ifdef _MSC_VER #ifdef _MSC_VER
_wfopen(data.c_str(), L"r"); _wfopen(data.c_str(), L"r");
#else #else
...@@ -343,11 +348,9 @@ namespace fggl::gfx { ...@@ -343,11 +348,9 @@ namespace fggl::gfx {
return result; return result;
} }
#include <iostream>
#include <fstream>
template<> template<>
bool fggl::data::fggl_deserialize(std::filesystem::path &data, std::string *out) { auto fggl::data::fggl_deserialize(std::filesystem::path &data, std::string *out) -> bool {
std::ifstream ifs(data); std::ifstream ifs(data);
out->assign((std::istreambuf_iterator<char>(ifs)), out->assign((std::istreambuf_iterator<char>(ifs)),
(std::istreambuf_iterator<char>())); (std::istreambuf_iterator<char>()));
...@@ -355,10 +358,10 @@ bool fggl::data::fggl_deserialize(std::filesystem::path &data, std::string *out) ...@@ -355,10 +358,10 @@ bool fggl::data::fggl_deserialize(std::filesystem::path &data, std::string *out)
} }
template<> template<>
bool fggl::data::fggl_serialize(std::filesystem::path &data, const fggl::gfx::BinaryCache *out) { auto fggl::data::fggl_serialize(std::filesystem::path &data, const fggl::gfx::BinaryCache *out) -> bool {
// try and write // try and write
auto f = auto *f =
#ifdef _MSC_VER #ifdef _MSC_VER
_wfopen( data.c_str(), L"w"); _wfopen( data.c_str(), L"w");
#else #else
......
fggl/gfx/ogl/types.cpp
View file @ bd58e207
...@@ -44,7 +44,7 @@ namespace fggl::gfx::ogl { ...@@ -44,7 +44,7 @@ namespace fggl::gfx::ogl {
other.m_obj = 0; other.m_obj = 0;
} }
VertexArray &VertexArray::operator=(VertexArray &&other) { auto VertexArray::operator=(VertexArray &&other) -> VertexArray & {
if (this != &other) { if (this != &other) {
release(); release();
std::swap(m_obj, other.m_obj); std::swap(m_obj, other.m_obj);
...@@ -115,7 +115,7 @@ namespace fggl::gfx::ogl { ...@@ -115,7 +115,7 @@ namespace fggl::gfx::ogl {
#endif #endif
} }
void VertexArray::drawElements(const ElementBuffer &buff, Primative drawType, std::size_t size) { void VertexArray::drawElements(const ElementBuffer &buff, Primitive drawType, std::size_t size) {
bind(); bind();
#ifndef FGGL_I_BOUND #ifndef FGGL_I_BOUND
...@@ -130,7 +130,7 @@ namespace fggl::gfx::ogl { ...@@ -130,7 +130,7 @@ namespace fggl::gfx::ogl {
#endif #endif
} }
void VertexArray::draw(Primative drawType, int first, std::size_t count) { void VertexArray::draw(Primitive drawType, int first, std::size_t count) {
glDrawArrays((GLenum) drawType, first, count); glDrawArrays((GLenum) drawType, first, count);
} }
......
fggl/gfx/ogl4/CMakeLists.txt
View file @ bd58e207
...@@ -6,5 +6,6 @@ target_sources(fggl ...@@ -6,5 +6,6 @@ target_sources(fggl
canvas.cpp canvas.cpp
models.cpp models.cpp
debug.cpp debug.cpp
meshes.cpp
module.cpp module.cpp
) )
fggl/gfx/ogl4/canvas.cpp
View file @ bd58e207
...@@ -137,7 +137,7 @@ namespace fggl::gfx::ogl4 { ...@@ -137,7 +137,7 @@ namespace fggl::gfx::ogl4 {
shader.setUniformMtx(shader.uniform("projection"), projMat); shader.setUniformMtx(shader.uniform("projection"), projMat);
// draw elements // draw elements
m_vao.drawElements(m_indexList, ogl::Primative::TRIANGLE, mesh.indexList.size()); m_vao.drawElements(m_indexList, ogl::Primitive::TRIANGLE, mesh.indexList.size());
// cleanup // cleanup
glUseProgram(0); glUseProgram(0);
...@@ -153,21 +153,21 @@ namespace fggl::gfx::ogl4 { ...@@ -153,21 +153,21 @@ namespace fggl::gfx::ogl4 {
// get the expected font // get the expected font
std::shared_ptr<gui::FontFace> face = m_fonts->getFont("LiberationSans-Regular.ttf"); std::shared_ptr<gui::FontFace> face = m_fonts->getDefaultFont();
if (face == nullptr) { if (face == nullptr) {
// we don't know about that font... // we don't know about that font...
return; return;
} }
// setup the shader // set up the shader
shader.use(); shader.use();
auto projMat = glm::ortho(0.0f, 1920.0f, 1080.0f, 0.f); auto projMat = glm::ortho(0.0F, 1920.0F, 1080.0F, 0.F);
shader.setUniformMtx(shader.uniform("projection"), projMat); shader.setUniformMtx(shader.uniform("projection"), projMat);
// bind the vbo we'll use for writing // bind the vbo we'll use for writing
m_vao.bind(); m_vao.bind();
// setup the openGL state we expect for rendering // set up the openGL state we expect for rendering
glDisable(GL_DEPTH_TEST); glDisable(GL_DEPTH_TEST);
glDisable(GL_CULL_FACE); glDisable(GL_CULL_FACE);
...@@ -179,14 +179,15 @@ namespace fggl::gfx::ogl4 { ...@@ -179,14 +179,15 @@ namespace fggl::gfx::ogl4 {
const auto label = textCmd.text; const auto label = textCmd.text;
math::vec2 penPos(textCmd.pos); math::vec2 penPos(textCmd.pos);
// set up a non-owning holder for the characters
data::Texture2D tex;
tex.channels = 1;
for (auto letter : label) { for (auto letter : label) {
ogl::Image img{};
img.format = ogl::ImageFormat::R;
img.type = ogl::PixelFormat::UNSIGNED_BYTE;
glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
face->texture(letter, img.size.x, img.size.y, &img.data); face->texture(letter, tex.size.x, tex.size.y, &tex.data);
m_fontTex.setData(ogl::InternalImageFormat::Red, img); m_fontTex.setData(ogl::InternalImageFormat::Red, &tex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
...@@ -214,10 +215,13 @@ namespace fggl::gfx::ogl4 { ...@@ -214,10 +215,13 @@ namespace fggl::gfx::ogl4 {
m_vertexList.replace(verts.size(), verts.data()); m_vertexList.replace(verts.size(), verts.data());
m_vao.bind(); m_vao.bind();
m_vao.draw(ogl::Primative::TRIANGLE, 0, verts.size()); m_vao.draw(ogl::Primitive::TRIANGLE, 0, verts.size());
penPos.x += (metrics.advance >> 6); penPos.x += (metrics.advance >> 6);
} }
// textures assume they own their contained data, we need to make sure we clear it
tex.data = nullptr;
} }
glDisable(GL_BLEND); glDisable(GL_BLEND);
......
fggl/gfx/ogl4/debug.cpp
View file @ bd58e207
...@@ -55,7 +55,7 @@ namespace fggl::gfx::ogl4 { ...@@ -55,7 +55,7 @@ namespace fggl::gfx::ogl4 {
m_lineVbo.bind(); m_lineVbo.bind();
m_lineVbo.replace<dd::DrawVertex>(count, lines); m_lineVbo.replace<dd::DrawVertex>(count, lines);
m_lineVao.draw(ogl::Primative::LINE, 0, count); m_lineVao.draw(ogl::Primitive::LINE, 0, count);
glUseProgram(0); glUseProgram(0);
glBindVertexArray(0); glBindVertexArray(0);
......
fggl/gfx/ogl4/meshes.cpp 0 → 100644
View file @ bd58e207
/*
* This file is part of FGGL.
*
* FGGL is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any
* later version.
*
* FGGL is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License along with FGGL.
* If not, see <https://www.gnu.org/licenses/>.
*/
#include "fggl/gfx/ogl4/meshes.hpp"
#include "fggl/gfx/phong.hpp"
#include "fggl/data/texture.hpp"
//
// Created by webpigeon on 22/10/22.
//
namespace fggl::gfx::ogl4 {
static auto setup_array_buffer(std::shared_ptr<ogl::VertexArray> &vao,
const std::vector<mesh::Vertex3D> &data) -> std::shared_ptr<ogl::ArrayBuffer> {
// upload the data to the GPU
auto buff = std::make_shared<ogl::ArrayBuffer>();
buff->write(data.size() * sizeof(mesh::Vertex3D), data.data(), ogl::BufUsage::STATIC_DRAW);
// set up the vertex attributes
auto posAttr = ogl::attribute<mesh::Vertex3D, math::vec3>(offsetof(mesh::Vertex3D, position));
auto normalAttr = ogl::attribute<mesh::Vertex3D, math::vec3>(offsetof(mesh::Vertex3D, normal));
auto colAttr = ogl::attribute<mesh::Vertex3D, math::vec3>(offsetof(mesh::Vertex3D, colour));
auto texAttr = ogl::attribute<mesh::Vertex3D, math::vec2>(offsetof(mesh::Vertex3D, texPos));
vao->setAttribute(*buff, 0, posAttr);
vao->setAttribute(*buff, 1, normalAttr);
vao->setAttribute(*buff, 2, colAttr);
vao->setAttribute(*buff, 3, texAttr);
return buff;
}
static auto setup_index_buffer(const std::vector<uint32_t>& data) -> std::shared_ptr<ogl::ElementBuffer> {
auto elementBuffer = std::make_shared<ogl::ElementBuffer>();
elementBuffer->write(data.size() * sizeof(uint32_t),
data.data(), ogl::BufUsage::STATIC_DRAW);
return elementBuffer;
}
void setup_material(const std::shared_ptr<ogl::Shader>& shader, const PhongMaterial* material) {
if ( !shader->hasUniform("material.ambient") ) {
return;
}
// setup material block
shader->setUniformF(shader->uniform("material.emission"), material->emission);
shader->setUniformF(shader->uniform("material.ambient"), material->ambient);
shader->setUniformF(shader->uniform("material.diffuse"), material->diffuse);
shader->setUniformF(shader->uniform("material.specular"), material->specular);
//shader->setUniformF(shader->uniform("material.shininess"), material->shininess);
}
void setup_material(const std::shared_ptr<ogl::Shader>& shader, const Material* material) {
if ( shader->hasUniform("material.diffuse") ) {
// setup material block
// shader->setUniformF(shader->uniform("material.emission"), material->emission);
// shader->setUniformF(shader->uniform("material.ambient"), material->ambient);
shader->setUniformF(shader->uniform("material.diffuse"), material->m_diffCol);
shader->setUniformF(shader->uniform("material.specular"), material->m_specCol);
}
// setup diffuse texture
if (material->m_diffuse != nullptr) {
material->m_diffuse->bind(0);
if (shader->hasUniform("diffuseTexture")) {
shader->setUniformI(shader->uniform("diffuseTexture"), 0);
}
}
// setup specular texture
if (material->m_specular != nullptr) {
material->m_specular->bind(1);
if (shader->hasUniform("specularTexture")) {
shader->setUniformI(shader->uniform("specularTexture"), 1);
}
}
//shader->setUniformF(shader->uniform("material.shininess"), material->shininess);
}
void MeshData::draw(std::shared_ptr<ogl::Shader> shader) const {
vao->bind();
vertexData->bind();
if ( material != nullptr ) {
setup_material(shader, material);
} else {
debug::info("no material is active, cannot bind textures!");
}
if ( drawInfo.restartIndex != ogl::NO_RESTART_IDX) {
glEnable(GL_PRIMITIVE_RESTART);
glPrimitiveRestartIndex( drawInfo.restartIndex );
}
vao->drawElements(*elements, drawInfo.mode, elementCount);
if ( drawInfo.restartIndex != ogl::NO_RESTART_IDX ) {
glDisable(GL_PRIMITIVE_RESTART);
}
}
void StaticMultiMesh::draw() const {
for ( const auto& mesh : meshes ) {
mesh.draw(pipeline);
}
}
void setup_lighting(const std::shared_ptr<ogl::Shader>& shader, const DirectionalLight* light) {
assert( light != nullptr );
if ( !shader->hasUniform("light.direction") ) {
fggl::debug::warning("asked for directional lighting, but shader does not support!");
return;
}
shader->setUniformF( shader->uniform("light.direction"), light->position);
shader->setUniformF( shader->uniform("light.ambient"), light->ambient);
shader->setUniformF( shader->uniform("light.diffuse"), light->diffuse);
shader->setUniformF( shader->uniform("light.specular"), light->specular);
}
void setup_lighting(const std::shared_ptr<ogl::Shader>& shader, const math::mat4& viewMatrix, const math::Transform& camTransform, const math::Transform& transform, math::vec3 lightPos) {
if (shader->hasUniform("lightPos")) {
shader->setUniformF(shader->uniform("lightPos"), lightPos);
}
if ( !shader->hasUniform("lights[0].isEnabled") ) {
return;
}
bool local = true;
shader->setUniformI(shader->uniform("lights[0].isEnabled"), 1);
shader->setUniformI(shader->uniform("lights[0].isLocal"), local);
shader->setUniformI(shader->uniform("lights[0].isSpot"), 0);
shader->setUniformF(shader->uniform("lights[0].constantAttenuation"), 5.0F);
shader->setUniformF(shader->uniform("lights[0].linearAttenuation"), 0.0F);
shader->setUniformF(shader->uniform("lights[0].quadraticAttenuation"), 0.0F);
shader->setUniformF(shader->uniform("Strength"), 0.6F);
if (!local) {
lightPos = glm::normalize(lightPos);
auto viewDir = glm::normalize(camTransform.origin() - transform.origin());
auto halfVector = glm::normalize(lightPos + viewDir);
shader->setUniformF(shader->uniform("lights[0].halfVector"), halfVector);
shader->setUniformF(shader->uniform("EyeDirection"), viewDir);
shader->setUniformF(shader->uniform("lights[0].position"), lightPos);
} else {
auto camModelView = (viewMatrix * camTransform.model() * math::vec4(0.0F, 0.0F, 0.0F, 1.0F));
auto modelModelView = (viewMatrix * transform.model() * math::vec4(0.0F, 0.0F, 0.0F, 1.0F));
math::vec3 viewDir = glm::normalize(camModelView - modelModelView);
shader->setUniformF(shader->uniform("EyeDirection"), viewDir);
shader->setUniformF(shader->uniform("lights[0].position"),
math::vec3(viewMatrix * math::vec4(lightPos, 1.0F)));
}
shader->setUniformF(shader->uniform("lights[0].ambient"), {0.0F, 0.5F, 0.0F});
shader->setUniformF(shader->uniform("lights[0].colour"), {0.5F, 0.5F, 0.5F});
}
static auto upload_texture( assets::AssetID name, assets::AssetManager* manager ) -> ogl::Texture* {
debug::info("loading texture: {}", name.get());
auto uploadedTex = assets::make_asset_id_rt("ogl", std::to_string(name.get()) );
auto* texture = manager->get<ogl::Texture>( uploadedTex );
if ( texture != nullptr ) {
return texture;
}
// get the texture data we plan to load
auto *textureData = manager->get<data::Texture2D>(name);
// create a texture
texture = new ogl::Texture(ogl::TextureType::Tex2D);
texture->setData( ogl::InternalImageFormat::RedGreenBlue, textureData);
return manager->set(uploadedTex, texture);
}
static auto get_fallback_material(assets::AssetManager* manager) -> Material* {
auto* fallback = manager->get<Material>(FALLBACK_MAT);
if ( fallback != nullptr ) {
return fallback;
}
auto* mat = new Material();
mat->m_diffCol = FALLBACK_COLOUR;
mat->m_specCol= FALLBACK_COLOUR;
mat->m_diffuse = manager->get<ogl::Texture>(FALLBACK_TEX);
mat->m_specular = manager->get<ogl::Texture>(FALLBACK_TEX);
mat->m_normals = manager->get<ogl::Texture>(SOLID_TEX);
return manager->set(FALLBACK_MAT, mat);
}
static auto upload_material( assets::AssetID name, assets::AssetManager* manager ) -> Material* {
auto* meshMaterial = manager->get<mesh::Material>(name);
if ( meshMaterial == nullptr ){
debug::error("attempted to load material {}, but did not exist!", name.get());
return get_fallback_material(manager);
}
auto uploadedMat = assets::make_asset_id_rt("ogl", std::to_string(name.get()) );
auto* material = manager->get<Material>( uploadedMat );
if ( material != nullptr ) {
return material;
}
material = new Material();
material->m_diffCol = meshMaterial->diffuse;
material->m_specCol = meshMaterial->specular;
// do we have a diffuse texture?
if ( !meshMaterial->diffuseTextures.empty() ) {
material->m_diffuse = upload_texture(meshMaterial->getPrimaryDiffuse(), manager);
} else {
material->m_diffuse = manager->get<ogl::Texture>( ogl4::SOLID_TEX );
}
// do we have a normal Texture?
if ( !meshMaterial->normalTextures.empty() ) {
material->m_normals = upload_texture(meshMaterial->getPrimaryNormals(), manager);
} else {
material->m_normals = manager->get<ogl::Texture>( ogl4::SOLID_TEX );
}
// do we have a specular texture?
if ( !meshMaterial->specularTextures.empty() ) {
material->m_specular = upload_texture(meshMaterial->getPrimarySpecular(), manager);
} else {
material->m_specular = manager->get<ogl::Texture>( ogl4::SOLID_TEX );
}
return manager->set( uploadedMat, material);
}
auto upload_mesh(const mesh::Mesh3D& rawMesh, assets::AssetManager* manager) -> MeshData {
auto vao = std::make_shared<ogl::VertexArray>();
return {
.vao = vao,
.elements = setup_index_buffer( rawMesh.indices ),
.vertexData = setup_array_buffer(vao, rawMesh.data ),
.elementCount = rawMesh.indices.size(),
.drawInfo = { .mode = ogl::Primitive::TRIANGLE },
.material = upload_material( rawMesh.material, manager )
};
}
auto upload_multi_mesh(const mesh::MultiMesh3D& rawMesh, assets::AssetManager* manager) -> std::vector<MeshData> {
std::vector<MeshData> gpuMeshes;
for (const auto& mesh : rawMesh.meshes) {
gpuMeshes.push_back( upload_mesh(mesh, manager) );
}
return gpuMeshes;
}
}
fggl/gfx/ogl4/models.cpp
View file @ bd58e207
...@@ -17,17 +17,19 @@ ...@@ -17,17 +17,19 @@
// //
#include "fggl/gfx/ogl4/models.hpp" #include "fggl/gfx/ogl4/models.hpp"
#include "fggl/gfx/ogl4/meshes.hpp"
#include "fggl/data/heightmap.hpp" #include "fggl/data/heightmap.hpp"
#include "fggl/data/texture.hpp"
#include "fggl/debug/logging.hpp"
#include "fggl/gfx/camera.hpp" #include "fggl/gfx/camera.hpp"
#include "fggl/gfx/phong.hpp" #include "fggl/gfx/phong.hpp"
#include <spdlog/spdlog.h>
namespace fggl::gfx::ogl4 { namespace fggl::gfx::ogl4 {
static std::shared_ptr<ogl::ArrayBuffer> setupArrayBuffer(std::shared_ptr<ogl::VertexArray> &vao, static auto setup_array_buffer(std::shared_ptr<ogl::VertexArray> &vao,
const std::vector<data::Vertex> &data) { const std::vector<data::Vertex> &data) -> std::shared_ptr<ogl::ArrayBuffer> {
auto buff = std::make_shared<ogl::ArrayBuffer>(); auto buff = std::make_shared<ogl::ArrayBuffer>();
buff->write(data.size() * sizeof(data::Vertex), data.data(), ogl::BufUsage::STATIC_DRAW); buff->write(data.size() * sizeof(data::Vertex), data.data(), ogl::BufUsage::STATIC_DRAW);
...@@ -42,18 +44,19 @@ namespace fggl::gfx::ogl4 { ...@@ -42,18 +44,19 @@ namespace fggl::gfx::ogl4 {
return buff; return buff;
} }
static std::shared_ptr<ogl::ElementBuffer> setupIndexBuffer(std::shared_ptr<ogl::VertexArray> &vao,
const std::vector<uint32_t> &data) { static auto setup_index_buffer(std::shared_ptr<ogl::VertexArray> &vao,
const std::vector<uint32_t> &data) -> std::shared_ptr<ogl::ElementBuffer> {
auto elementBuffer = std::make_shared<ogl::ElementBuffer>(); auto elementBuffer = std::make_shared<ogl::ElementBuffer>();
elementBuffer->write(data.size() * sizeof(uint32_t), elementBuffer->write(data.size() * sizeof(uint32_t),
data.data(), ogl::BufUsage::STATIC_DRAW); data.data(), ogl::BufUsage::STATIC_DRAW);
return elementBuffer; return elementBuffer;
} }
static void setupComponent(StaticModel &modelComp, std::shared_ptr<ogl::Shader> &shader, data::Mesh &mesh) { static void setup_component(StaticModel &modelComp, std::shared_ptr<ogl::Shader> &shader, data::Mesh &mesh) {
auto vao = std::make_shared<ogl::VertexArray>(); auto vao = std::make_shared<ogl::VertexArray>();
auto meshBuffer = setupArrayBuffer(vao, mesh.vertexList()); auto meshBuffer = setup_array_buffer(vao, mesh.vertexList());
auto elementBuffer = setupIndexBuffer(vao, mesh.indexList()); auto elementBuffer = setup_index_buffer(vao, mesh.indexList());
// set up the element attributes // set up the element attributes
modelComp.vao = vao; modelComp.vao = vao;
...@@ -61,10 +64,10 @@ namespace fggl::gfx::ogl4 { ...@@ -61,10 +64,10 @@ namespace fggl::gfx::ogl4 {
modelComp.elements = elementBuffer; modelComp.elements = elementBuffer;
modelComp.pipeline = shader; modelComp.pipeline = shader;
modelComp.elementCount = mesh.indexCount(); modelComp.elementCount = mesh.indexCount();
modelComp.drawType = ogl::Primative::TRIANGLE; modelComp.drawType = ogl::Primitive::TRIANGLE;
} }
StaticModel* StaticModelRenderer::uploadMesh(assets::AssetGUID guid, const data::Mesh &mesh, bool allowCache) { auto StaticModelRenderer::uploadMesh(assets::AssetID guid, const data::Mesh &mesh, bool allowCache) -> StaticModel* {
assert( m_assets != nullptr ); assert( m_assets != nullptr );
// if the asset has already been uploaded, we don't need to do anything // if the asset has already been uploaded, we don't need to do anything
...@@ -76,10 +79,10 @@ namespace fggl::gfx::ogl4 { ...@@ -76,10 +79,10 @@ namespace fggl::gfx::ogl4 {
// the asset does not exist, we need to upload it // the asset does not exist, we need to upload it
auto* modelAsset = new StaticModel(); auto* modelAsset = new StaticModel();
modelAsset->vao = std::make_shared<ogl::VertexArray>(); modelAsset->vao = std::make_shared<ogl::VertexArray>();
modelAsset->vertexData = setupArrayBuffer(modelAsset->vao, mesh.vertexList()); modelAsset->vertexData = setup_array_buffer(modelAsset->vao, mesh.vertexList());
modelAsset->elements = setupIndexBuffer(modelAsset->vao, mesh.indexList()); modelAsset->elements = setup_index_buffer(modelAsset->vao, mesh.indexList());
modelAsset->elementCount = mesh.indexCount(); modelAsset->elementCount = mesh.indexCount();
modelAsset->drawType = ogl::Primative::TRIANGLE; modelAsset->drawType = ogl::Primitive::TRIANGLE;
// if caching is enabled, then use the cache // if caching is enabled, then use the cache
if ( allowCache ) { if ( allowCache ) {
...@@ -89,7 +92,32 @@ namespace fggl::gfx::ogl4 { ...@@ -89,7 +92,32 @@ namespace fggl::gfx::ogl4 {
return modelAsset; return modelAsset;
} }
StaticModelGPU* StaticModelRenderer::uploadMesh2(const assets::AssetGUID& meshName, const data::Mesh &mesh) { /*MeshData* StaticModelRenderer::uploadMesh(assets::AssetGUID guid, const mesh::Mesh3D &mesh, bool allowCache) {
assert( m_assets != nullptr );
// if the asset has already been uploaded, we don't need to do anything
if ( allowCache && m_assets->has(guid) ) {
m_assets->require(guid);
return m_assets->get<MeshData>(guid);
}
// the asset does not exist, we need to upload it
auto* modelAsset = new MeshData();
modelAsset->vao = std::make_shared<ogl::VertexArray>();
modelAsset->vertexData = setupArrayBuffer(modelAsset->vao, mesh.data);
modelAsset->elements = setupIndexBuffer(modelAsset->vao, mesh.indices);
modelAsset->elementCount = mesh.indices.size();
modelAsset->drawInfo.mode = ogl::Primitive::TRIANGLE;
// if caching is enabled, then use the cache
if ( allowCache ) {
m_assets->set(guid, modelAsset);
}
return modelAsset;
}*/
auto StaticModelRenderer::uploadMesh2(const assets::AssetID& meshName, const data::Mesh &mesh) -> StaticModelGPU* {
assert( m_assets != nullptr ); assert( m_assets != nullptr );
if ( m_assets->has(meshName) ) { if ( m_assets->has(meshName) ) {
...@@ -99,43 +127,72 @@ namespace fggl::gfx::ogl4 { ...@@ -99,43 +127,72 @@ namespace fggl::gfx::ogl4 {
auto* modelAsset = new StaticModelGPU(); auto* modelAsset = new StaticModelGPU();
modelAsset->vao = std::make_shared<ogl::VertexArray>(); modelAsset->vao = std::make_shared<ogl::VertexArray>();
modelAsset->vertices = setupArrayBuffer(modelAsset->vao, mesh.vertexList()); modelAsset->vertices = setup_array_buffer(modelAsset->vao, mesh.vertexList());
modelAsset->elements = setupIndexBuffer(modelAsset->vao, mesh.indexList()); modelAsset->elements = setup_index_buffer(modelAsset->vao, mesh.indexList());
modelAsset->elementCount = mesh.indexCount(); modelAsset->elementCount = mesh.indexCount();
modelAsset->drawType = ogl::Primative::TRIANGLE; modelAsset->drawType = ogl::Primitive::TRIANGLE;
return m_assets->set(meshName, modelAsset); return m_assets->set(meshName, modelAsset);
} }
#ifdef FGGL_ALLOW_DEFERRED_UPLOAD #ifdef FGGL_ALLOW_DEFERRED_UPLOAD
void StaticModelRenderer::resolveModels(entity::EntityManager &world) { static void setup_meshes(entity::EntityManager& world, ShaderCache* shaders, assets::AssetManager* manager) {
// FIXME: this needs something reactive or performance will suck. auto entsWithModels = world.find<mesh::StaticMesh3D>();
auto renderableEnts = world.find<data::StaticMesh>(); for ( const auto& mesher : entsWithModels ) {
for (const auto &renderable : renderableEnts) {
auto *currModel = world.tryGet<StaticModel>(renderable); // check if this entity already has a mesh...
if (currModel != nullptr) { const auto* currModel = world.tryGet<StaticMesh>(mesher);
if ( currModel != nullptr ) {
continue; continue;
} }
auto &meshComp = world.get<data::StaticMesh>(renderable); // figure out the requirements
auto& rawMesh = world.get<mesh::StaticMesh3D>(mesher);
if ( rawMesh.guid != util::make_guid("__NO_CACHE__") ){
// TODO support fetching of loaded meshes
debug::warning("multiple entities sharing a mesh has not been implemented yet...");
}
// model loading (should be via asset system) auto& entityMesh = world.add<StaticMesh>(mesher);
auto loadedModel = uploadMesh("DEFER_ENT_"+ std::to_string((uint64_t)renderable), meshComp.mesh, false); entityMesh.pipeline = shaders->get( rawMesh.pipeline );
auto loadedShader = m_shaders->get(meshComp.pipeline); entityMesh.mesh = upload_mesh( rawMesh.mesh, manager );
// splice the loaded asset into the ecs }
auto& entityModel = world.add<StaticModel>(renderable); }
entityModel = *loadedModel;
entityModel.pipeline = loadedShader; static void setup_multi_meshes(entity::EntityManager& world, ShaderCache* shaders, assets::AssetManager* manager) {
auto entsWithModels = world.find<mesh::StaticMultiMesh3D>();
for ( const auto& mesher : entsWithModels ) {
// check if this entity already has a mesh...
const auto* currModel = world.tryGet<StaticMultiMesh>(mesher);
if ( currModel != nullptr ) {
continue;
}
// figure out the requirements
auto& multiMesh = world.get<mesh::StaticMultiMesh3D>(mesher);
if ( multiMesh.guid != util::make_guid("__NO_CACHE__") ){
// TODO support fetching of loaded meshes
debug::warning("multiple entities sharing a mesh has not been implemented yet...");
}
// let the user know we just did this... auto& entityMesh = world.add<StaticMultiMesh>(mesher);
debug::log(debug::Level::info, "Added static mesh to {}, pipeline was: {}", (uint64_t) renderable, meshComp.pipeline); entityMesh.pipeline = shaders->get( multiMesh.pipeline );
entityMesh.meshes = upload_multi_mesh(multiMesh.mesh, manager);
//entityMesh.material = setup_material( multiMesh.mesh.materials[0], manager);
} }
}
void StaticModelRenderer::resolveModels(entity::EntityManager &world) {
// new mesh formats
setup_meshes(world, m_shaders, m_assets);
setup_multi_meshes(world, m_shaders, m_assets);
// terrain // terrain
auto terrain = world.find<data::HeightMap>(); auto terrain = world.find<data::HeightMap>();
for (auto &renderable : terrain) { for (const auto &renderable : terrain) {
auto currModel = world.tryGet<StaticModel>(renderable); auto *currModel = world.tryGet<StaticModel>(renderable);
if (currModel != nullptr) { if (currModel != nullptr) {
continue; continue;
} }
...@@ -145,11 +202,11 @@ namespace fggl::gfx::ogl4 { ...@@ -145,11 +202,11 @@ namespace fggl::gfx::ogl4 {
data::generateHeightMesh(heightmap, heightMapMesh); data::generateHeightMesh(heightmap, heightMapMesh);
auto &modelComp = world.add<StaticModel>(renderable); auto &modelComp = world.add<StaticModel>(renderable);
setupComponent(modelComp, m_phong, heightMapMesh); setup_component(modelComp, m_phong, heightMapMesh);
// we know this is a triangle strip with a restart vertex... // we know this is a triangle strip with a restart vertex...
// FIXME the model should be telling us this... // FIXME the model should be telling us this...
modelComp.drawType = ogl::Primative::TRIANGLE_STRIP; modelComp.drawType = ogl::Primitive::TRIANGLE_STRIP;
modelComp.restartIndex = heightMapMesh.restartVertex; modelComp.restartIndex = heightMapMesh.restartVertex;
// no active model, we need to resolve/load one. // no active model, we need to resolve/load one.
...@@ -158,145 +215,33 @@ namespace fggl::gfx::ogl4 { ...@@ -158,145 +215,33 @@ namespace fggl::gfx::ogl4 {
} }
#endif #endif
static void forward_camera_pass(const entity::EntityID& camera, const fggl::entity::EntityManager& world) {
// enable required OpenGL state
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
// enable depth testing
glEnable(GL_DEPTH_TEST);
// set-up camera matrices
const auto &camTransform = world.get<fggl::math::Transform>(camera);
const auto &camComp = world.get<fggl::gfx::Camera>(camera);
const math::mat4 projectionMatrix =
glm::perspective(camComp.fov, camComp.aspectRatio, camComp.nearPlane, camComp.farPlane);
const math::mat4 viewMatrix = glm::lookAt(camTransform.origin(), camComp.target, camTransform.up());
// TODO lighting needs to not be this...
math::vec3 lightPos{0.0f, 10.0f, 0.0f};
std::shared_ptr<ogl::Shader> shader = nullptr;
ogl::Location mvpMatrixUniform = 0;
ogl::Location mvMatrixUniform = 0;
auto renderables = world.find<StaticModel>();
for (const auto &entity : renderables) {
// ensure that the model pipeline actually exists...
const auto &model = world.get<StaticModel>(entity);
if (model.pipeline == nullptr) {
debug::warning("shader was null, aborting render");
continue;
}
// check if we switched shaders
if (shader == nullptr || shader->shaderID() != model.pipeline->shaderID()) {
// new shader - need to re-send the view and projection matrices
shader = model.pipeline;
shader->use();
if (shader->hasUniform("projection")) {
shader->setUniformMtx(shader->uniform("view"), viewMatrix);
shader->setUniformMtx(shader->uniform("projection"), projectionMatrix);
}
mvpMatrixUniform = shader->uniform("MVPMatrix");
mvMatrixUniform = shader->uniform("MVMatrix");
}
// set model transform
const auto &transform = world.get<math::Transform>(entity);
shader->setUniformMtx(mvpMatrixUniform, projectionMatrix * viewMatrix * transform.model());
shader->setUniformMtx(mvMatrixUniform, viewMatrix * transform.model());
auto normalMatrix = glm::mat3(glm::transpose(inverse(transform.model())));
shader->setUniformMtx(shader->uniform("NormalMatrix"), normalMatrix);
// setup lighting mode
if (shader->hasUniform("lights[0].isEnabled")) {
bool local = true;
shader->setUniformI(shader->uniform("lights[0].isEnabled"), 1);
shader->setUniformI(shader->uniform("lights[0].isLocal"), local);
shader->setUniformI(shader->uniform("lights[0].isSpot"), 0);
shader->setUniformF(shader->uniform("lights[0].constantAttenuation"), 5.0f);
shader->setUniformF(shader->uniform("lights[0].linearAttenuation"), 0.0f);
shader->setUniformF(shader->uniform("lights[0].quadraticAttenuation"), 0.0f);
shader->setUniformF(shader->uniform("Strength"), 0.6F);
if (!local) {
lightPos = glm::normalize(lightPos);
auto viewDir = glm::normalize(camTransform.origin() - transform.origin());
auto halfVector = glm::normalize(lightPos + viewDir);
shader->setUniformF(shader->uniform("lights[0].halfVector"), halfVector);
shader->setUniformF(shader->uniform("EyeDirection"), viewDir);
shader->setUniformF(shader->uniform("lights[0].position"), lightPos);
} else {
auto camModelView = (viewMatrix * camTransform.model() * math::vec4(0.0f, 0.0f, 0.0f, 1.0f));
auto modelModelView = (viewMatrix * transform.model() * math::vec4(0.0f, 0.0f, 0.0f, 1.0f));
math::vec3 viewDir = glm::normalize(camModelView - modelModelView);
shader->setUniformF(shader->uniform("EyeDirection"), viewDir);
shader->setUniformF(shader->uniform("lights[0].position"),
math::vec3(viewMatrix * math::vec4(lightPos, 1.0f)));
}
shader->setUniformF(shader->uniform("lights[0].ambient"), {0.0f, 0.5f, 0.0f});
shader->setUniformF(shader->uniform("lights[0].colour"), {0.5f, 0.5f, 0.5f});
}
// material detection with fallback
auto* material = world.tryGet<PhongMaterial>(entity);
if ( material == nullptr ) {
material = &DEFAULT_MATERIAL;
}
if ( shader->hasUniform("materials[0].ambient") ) {
shader->setUniformF(shader->uniform("materials[0].emission"), material->emission);
shader->setUniformF(shader->uniform("materials[0].ambient"), material->ambient);
shader->setUniformF(shader->uniform("materials[0].diffuse"), material->diffuse);
shader->setUniformF(shader->uniform("materials[0].specular"), material->specular);
shader->setUniformF(shader->uniform("materials[0].shininess"), material->shininess);
}
if (shader->hasUniform("lightPos")) { void StaticModelRenderer::renderModelsForward(const entity::EntityManager &world, bool debugMode) {
shader->setUniformF(shader->uniform("lightPos"), lightPos);
}
auto vao = model.vao;
vao->bind();
model.vertexData->bind();
if (model.restartIndex != NO_RESTART_IDX) {
glEnable(GL_PRIMITIVE_RESTART);
glPrimitiveRestartIndex(model.restartIndex);
}
auto *elements = model.elements.get();
vao->drawElements(*elements, model.drawType, model.elementCount);
if (model.restartIndex != NO_RESTART_IDX) {
glDisable(GL_PRIMITIVE_RESTART);
}
}
}
void StaticModelRenderer::renderModelsForward(const entity::EntityManager &world) {
// fetch cameras we will need to render with // fetch cameras we will need to render with
auto cameras = world.find<gfx::Camera>(); auto cameras = world.find<gfx::Camera>();
// if there are no cameras, we can't do anything... // if there are no cameras, we can't do anything...
if (cameras.empty()) { if (cameras.empty()) {
spdlog::warn("asked to render static models, but there were no cameras"); debug::warning("asked to render static models, but there were no cameras");
return; return;
} }
// perform a rendering pass for each camera (will usually only be one...) // perform a rendering pass for each camera (will usually only be one...)
for (const auto &cameraEnt : cameras) { for (const auto &cameraEnt : cameras) {
//TODO should be clipping this to only visible objects //TODO should be clipping this to only visible objects
forward_camera_pass(cameraEnt, world); //forward_camera_pass(cameraEnt, world);
forward_pass<ogl4::StaticMesh>(cameraEnt, world, m_assets);
forward_pass<ogl4::StaticMultiMesh>(cameraEnt, world, m_assets);
// enable rendering normals
if ( debugMode ) {
auto normalShader = m_shaders->get("normals");
forward_pass_normals<StaticMesh>(cameraEnt, world, normalShader);
forward_pass_normals<StaticMultiMesh>(cameraEnt, world, normalShader);
//forward_normal_pass(cameraEnt, world, normalShader);
}
} }
} }
......
fggl/gfx/ogl4/module.cpp
View file @ bd58e207
...@@ -18,6 +18,7 @@ ...@@ -18,6 +18,7 @@
#include "fggl/gfx/ogl4/module.hpp" #include "fggl/gfx/ogl4/module.hpp"
#include "fggl/gfx/phong.hpp" #include "fggl/gfx/phong.hpp"
#include "fggl/mesh/components.hpp"
#include "fggl/data/procedural.hpp" #include "fggl/data/procedural.hpp"
#include "fggl/assets/loader.hpp" #include "fggl/assets/loader.hpp"
...@@ -30,29 +31,32 @@ namespace fggl::gfx { ...@@ -30,29 +31,32 @@ namespace fggl::gfx {
constexpr const char *SHAPE_SPHERE{"sphere"}; constexpr const char *SHAPE_SPHERE{"sphere"};
constexpr const char *SHAPE_BOX{"box"}; constexpr const char *SHAPE_BOX{"box"};
static void process_shape(const YAML::Node &node, data::Mesh &mesh) { namespace {
auto transform = data::OFFSET_NONE; void process_shape(const YAML::Node &node, mesh::Mesh3D &mesh) {
auto transform = data::OFFSET_NONE;
auto offset = node["offset"].as<math::vec3>(math::VEC3_ZERO);
transform = glm::translate(transform, offset); auto offset = node["offset"].as<math::vec3>(math::VEC3_ZERO);
transform = glm::translate(transform, offset);
auto scale = node["scale"].as<math::vec3>(math::VEC3_ONES);
transform = glm::scale(transform, scale); auto scale = node["scale"].as<math::vec3>(math::VEC3_ONES);
debug::debug("scale: {}, {}, {}", scale.x, scale.y, scale.z); transform = glm::scale(transform, scale);
debug::debug("scale: {}, {}, {}", scale.x, scale.y, scale.z);
// now the shape itself
auto type = node["type"].as<std::string>(); // now the shape itself
if (type == SHAPE_BOX) { auto type = node["type"].as<std::string>();
data::make_cube(mesh, transform); if (type == SHAPE_BOX) {
} else if (type == SHAPE_SPHERE) { data::make_cube(mesh, transform);
auto stacks = node["stacks"].as<uint32_t>(DEFAULT_STACKS); } else if (type == SHAPE_SPHERE) {
auto slices = node["slices"].as<uint32_t>(DEFAULT_SLICES); auto stacks = node["stacks"].as<uint32_t>(DEFAULT_STACKS);
data::make_sphere(mesh, transform, stacks, slices); auto slices = node["slices"].as<uint32_t>(DEFAULT_SLICES);
} else { data::make_sphere(mesh, transform, stacks, slices);
debug::log(debug::Level::warning, "unknown shape type requested: {}", type); } else {
debug::log(debug::Level::warning, "unknown shape type requested: {}", type);
}
} }
} }
void attach_mesh(const entity::ComponentSpec &spec, entity::EntityManager &manager, const entity::EntityID &id, modules::Services &services) { void attach_mesh(const entity::ComponentSpec &spec, entity::EntityManager &manager, const entity::EntityID &id, modules::Services &services) {
// check for the asset service // check for the asset service
...@@ -65,46 +69,57 @@ namespace fggl::gfx { ...@@ -65,46 +69,57 @@ namespace fggl::gfx {
// asset is a procedural mesh description // asset is a procedural mesh description
if (spec.has("shape")) { if (spec.has("shape")) {
data::Mesh* meshAsset = nullptr;
auto pipeline = spec.get<std::string>("pipeline", ""); auto pipeline = spec.get<std::string>("pipeline", "");
// check if we had previously loaded this asset // check if we had previously loaded this asset
const auto shapeName = spec.get<std::string>("shape_id", ""); /*const auto shapeName = spec.get<std::string>("shape_id", "");
if ( !shapeName.empty() ) { if ( !shapeName.empty() ) {
meshAsset = assetService->get<data::Mesh>(shapeName); meshAsset = assetService->get<data::Mesh>(shapeName);
} }*/
// we've not loaded this before - generate mesh // we've not loaded this before - generate mesh
if ( meshAsset == nullptr ) { if ( true ) {
// procedural meshes are build as static meshes first
auto* meshTmp = new data::Mesh();
// procedural meshes are build as static meshes first
if (spec.config["shape"].IsSequence()) { if (spec.config["shape"].IsSequence()) {
mesh::MultiMesh3D* multiMesh;
for (const auto &node : spec.config["shape"]) { for (const auto &node : spec.config["shape"]) {
process_shape(node, *meshTmp); auto* meshAsset = new mesh::Mesh3D();
process_shape(node, *meshAsset);
multiMesh->meshes.push_back(*meshAsset);
delete meshAsset;
} }
} else {
process_shape(spec.config["shape"], *meshTmp);
}
meshTmp->removeDups();
if (!shapeName.empty()) { #ifdef FGGL_ALLOW_DEFERRED_UPLOAD
meshAsset = assetService->set(shapeName, meshTmp); // the graphics stack can detect static meshes without a rendering proxy at runtime and fix it but this
// requires loading the whole model into the ECS (and should be removed in the future). instead we should
// be triggering the upload at this point (if needed).
auto &entityMesh = manager.add<mesh::StaticMultiMesh3D>(id);
entityMesh.mesh = *multiMesh;
entityMesh.pipeline = pipeline;
debug::warning("HACKY: Triggered proc mesh - using deferred upload");
#endif
} else { } else {
meshAsset = meshTmp; auto* meshAsset = new mesh::Mesh3D();
process_shape(spec.config["shape"], *meshAsset);
#ifdef FGGL_ALLOW_DEFERRED_UPLOAD
// the graphics stack can detect static meshes without a rendering proxy at runtime and fix it but this
// requires loading the whole model into the ECS (and should be removed in the future). instead we should
// be triggering the upload at this point (if needed).
auto &entityMesh = manager.add<mesh::StaticMesh3D>(id);
entityMesh.mesh = *meshAsset;
entityMesh.pipeline = pipeline;
debug::warning("HACKY: Triggered proc mesh - using deferred upload");
#endif
} }
//assetService->set(shapeName, meshTmp);
} }
// TODO we need to trigger an upload to the GPU (somehow) // TODO we need to trigger an upload to the GPU (somehow)
#ifdef FGGL_ALLOW_DEFERRED_UPLOAD
// the graphics stack can detect static meshes without a rendering proxy at runtime and fix it but this
// requires loading the whole model into the ECS (and should be removed in the future). instead we should
// be triggering the upload at this point (if needed).
auto &entityMesh = manager.add<data::StaticMesh>(id);
entityMesh.pipeline = pipeline;
entityMesh.mesh = *meshAsset;
debug::warning("HACKY: Triggered proc mesh - using deferred upload");
#endif
return; return;
} }
...@@ -113,7 +128,9 @@ namespace fggl::gfx { ...@@ -113,7 +128,9 @@ namespace fggl::gfx {
if ( spec.has("model") ) { if ( spec.has("model") ) {
// figure out what model we want // figure out what model we want
auto assetStr = spec.get<std::string>("model", ""); auto assetStr = spec.get<std::string>("model", "");
auto* asset = assetService->get<ogl4::StaticModel>(assetStr); auto assetId = assets::asset_from_user( assetStr );
auto* asset = assetService->get<ogl4::StaticModel>(assetId);
if ( asset == nullptr ) { if ( asset == nullptr ) {
// the asset is not loaded/does not exist // the asset is not loaded/does not exist
...@@ -130,7 +147,7 @@ namespace fggl::gfx { ...@@ -130,7 +147,7 @@ namespace fggl::gfx {
void attach_material(const entity::ComponentSpec &spec, void attach_material(const entity::ComponentSpec &spec,
entity::EntityManager &manager, entity::EntityManager &manager,
const entity::EntityID &id, const entity::EntityID &id,
modules::Services& services ) { modules::Services& /*services*/ ) {
auto &mat = manager.add<gfx::PhongMaterial>(id); auto &mat = manager.add<gfx::PhongMaterial>(id);
mat.ambient = spec.get<math::vec3>("ambient", gfx::DEFAULT_AMBIENT); mat.ambient = spec.get<math::vec3>("ambient", gfx::DEFAULT_AMBIENT);
mat.diffuse = spec.get<math::vec3>("diffuse", gfx::DEFAULT_DIFFUSE); mat.diffuse = spec.get<math::vec3>("diffuse", gfx::DEFAULT_DIFFUSE);
...@@ -138,24 +155,40 @@ namespace fggl::gfx { ...@@ -138,24 +155,40 @@ namespace fggl::gfx {
mat.shininess = spec.get<float>("ambient", gfx::DEFAULT_SHININESS); mat.shininess = spec.get<float>("ambient", gfx::DEFAULT_SHININESS);
} }
void attach_light(const entity::ComponentSpec &spec, entity::EntityManager &manager, const entity::EntityID &id, modules::Services& services) { void attach_light_directional(const entity::ComponentSpec &spec, entity::EntityManager &manager, const entity::EntityID &id, modules::Services& /*services*/) {
auto &light = manager.add<gfx::Light>(id); auto &light = manager.add<gfx::DirectionalLight>(id);
light.position = spec.get<math::vec3>("direction", -math::UP);
light.ambient = spec.get<math::vec3>("ambient", gfx::colours::WHITE);
light.specular = spec.get<math::vec3>("specular", gfx::colours::WHITE);
light.diffuse = spec.get<math::vec3>("diffuse", gfx::colours::WHITE);
}
void attach_light_point(const entity::ComponentSpec &spec, entity::EntityManager &manager, const entity::EntityID &id, modules::Services& /*services*/) {
auto &light = manager.add<gfx::PointLight>(id);
light.position = spec.get<math::vec3>("position", math::VEC3_ZERO);
light.constant = spec.get<float>("constant", 1.0F);
light.linear = spec.get<float>("linear", 0.0014F);
light.quadratic = spec.get<float>("quadratic", 0.000007F);
} }
bool OpenGL4::factory(modules::ModuleService service, modules::Services &services) { auto OpenGL4::factory(modules::ServiceName service, modules::Services &services) -> bool {
if (service == WindowGraphics::service) { if (service == WindowGraphics::service) {
// setup the thing responsible for graphics // setup the thing responsible for graphics
auto *storage = services.get<data::Storage>(); auto *storage = services.get<data::Storage>();
auto *fontLibrary = services.get<gui::FontLibrary>(); auto *fontLibrary = services.get<gui::FontLibrary>();
auto *assets = services.get<assets::AssetManager>(); auto *assets = services.get<assets::AssetManager>();
services.bind<WindowGraphics, ogl4::WindowGraphics>(storage, fontLibrary, assets); services.bind<WindowGraphics, ogl4::WindowGraphics>(storage, fontLibrary, assets);
// register as responsible for creating rendering components // register as responsible for creating rendering components
auto *entityFactory = services.get<entity::EntityFactory>(); auto *entityFactory = services.get<entity::EntityFactory>();
entityFactory->bind(data::StaticMesh::guid, attach_mesh); entityFactory->bind(data::StaticMesh::guid, attach_mesh);
entityFactory->bind(mesh::StaticMesh3D::guid, attach_mesh);
entityFactory->bind(mesh::StaticMultiMesh3D::guid, attach_mesh);
entityFactory->bind(gfx::PhongMaterial::guid, attach_material); entityFactory->bind(gfx::PhongMaterial::guid, attach_material);
entityFactory->bind(gfx::Light::guid, attach_light);
entityFactory->bind(gfx::DirectionalLight::guid, attach_light_directional);
entityFactory->bind(gfx::PointLight::guid, attach_light_point);
return true; return true;
} }
......
fggl/gfx/ogl4/setup.cpp
View file @ bd58e207
...@@ -20,8 +20,8 @@ ...@@ -20,8 +20,8 @@
namespace fggl::gfx::ogl4 { namespace fggl::gfx::ogl4 {
Graphics *WindowGraphics::create(display::Window &window) { auto WindowGraphics::create(display::Window &window) -> Graphics * {
return new OpenGL4Backend(m_storage, m_fonts, m_assets); return new OpenGL4Backend(m_storage, m_fonts, m_assets, (GlFunctionLoader)glfwGetProcAddress);
} }
} }
\ No newline at end of file
fggl/gfx/window.cpp
View file @ bd58e207
...@@ -21,7 +21,6 @@ ...@@ -21,7 +21,6 @@
#include <string> #include <string>
#include <stdexcept> #include <stdexcept>
#include <GLFW/glfw3.h> #include <GLFW/glfw3.h>
#include <spdlog/spdlog.h>
namespace fggl::display::glfw { namespace fggl::display::glfw {
...@@ -34,37 +33,37 @@ namespace fggl::display::glfw { ...@@ -34,37 +33,37 @@ namespace fggl::display::glfw {
fgglWindow->framesize(width, height); fgglWindow->framesize(width, height);
} }
static void fggl_input_cursor(GLFWwindow *window, double x, double y) { static void fggl_input_cursor(GLFWwindow *window, double xPos, double yPos) {
auto &input = GlfwInputManager::instance(); auto &input = GlfwInputManager::instance();
auto *fgglWin = static_cast<Window *>(glfwGetWindowUserPointer(window)); auto *fgglWin = static_cast<Window *>(glfwGetWindowUserPointer(window));
#ifndef FGGL_INPUT_SCREEN_COORDS #ifndef FGGL_INPUT_SCREEN_COORDS
// convert to nice ranges... // convert to nice ranges...
x = (x / fgglWin->width() * 2) - 1.0; // [-1, 1] xPos = (xPos / fgglWin->width() * 2) - 1.0; // [-1, 1]
y = (y / fgglWin->height() * 2) - 1.0; // [-1, 1] yPos = (yPos / fgglWin->height() * 2) - 1.0; // [-1, 1]
#endif #endif
// inform the input system // inform the input system
input.onMouseMove(x, y); input.onMouseMove(xPos, yPos);
} }
static void fggl_input_scroll(GLFWwindow *window, double x, double y) { static void fggl_input_scroll(GLFWwindow */*window*/, double xPos, double yPos) {
auto &input = GlfwInputManager::instance(); auto &input = GlfwInputManager::instance();
input.onMouseScroll(x, y); input.onMouseScroll(xPos, yPos);
} }
static void fggl_input_mouse_btn(GLFWwindow *window, int btn, int action, int mods) { static void fggl_input_mouse_btn(GLFWwindow */*window*/, int btn, int action, int /*mods*/) {
auto &input = GlfwInputManager::instance(); auto &input = GlfwInputManager::instance();
input.onMouseButton(btn, action == GLFW_PRESS); input.onMouseButton(btn, action == GLFW_PRESS);
} }
static void fggl_input_keyboard(GLFWwindow *window, int key, int scancode, int action, int mods) { static void fggl_input_keyboard(GLFWwindow */*window*/, int /*key*/, int scancode, int action, int /*mods*/) {
auto &input = GlfwInputManager::instance(); auto &input = GlfwInputManager::instance();
input.onKeyEvent(scancode, action == GLFW_PRESS || action == GLFW_REPEAT); input.onKeyEvent(scancode, action == GLFW_PRESS || action == GLFW_REPEAT);
} }
static void fggl_update_joystick(fggl::input::GamepadInput &input, int jid) { static void fggl_update_joystick(fggl::input::GamepadInput &input, int jid) {
bool isGamepad = glfwJoystickIsGamepad(jid); bool isGamepad = (glfwJoystickIsGamepad(jid) == GLFW_TRUE);
if (isGamepad) { if (isGamepad) {
if (!input.present(jid)) { if (!input.present(jid)) {
...@@ -144,7 +143,7 @@ namespace fggl::display::glfw { ...@@ -144,7 +143,7 @@ namespace fggl::display::glfw {
GlfwContext::~GlfwContext() { GlfwContext::~GlfwContext() {
glfwTerminate(); glfwTerminate();
spdlog::debug("[glfw] context terminated"); debug::trace("[glfw] context terminated");
} }
void GlfwContext::pollEvents() { void GlfwContext::pollEvents() {
...@@ -157,7 +156,9 @@ namespace fggl::display::glfw { ...@@ -157,7 +156,9 @@ namespace fggl::display::glfw {
Window::Window(std::shared_ptr<GlfwContext> context, gfx::WindowGraphics *graphics) Window::Window(std::shared_ptr<GlfwContext> context, gfx::WindowGraphics *graphics)
: m_context(std::move(context)), m_window(nullptr), m_framesize() { : m_context(std::move(context)), m_window(nullptr), m_framesize() {
spdlog::debug("[glfw] creating window");
// don't iconify when focus is lost.
glfwWindowHint( GLFW_AUTO_ICONIFY, GLFW_FALSE );
// FIXME - this ties the graphics API before window creation // FIXME - this ties the graphics API before window creation
auto graphicsConfig = graphics->config(); auto graphicsConfig = graphics->config();
...@@ -185,12 +186,11 @@ namespace fggl::display::glfw { ...@@ -185,12 +186,11 @@ namespace fggl::display::glfw {
// bind the graphics API // bind the graphics API
glfwMakeContextCurrent(m_window); glfwMakeContextCurrent(m_window);
m_graphics = graphics->createMain(*this); m_graphics = graphics->createMain(*this);
spdlog::debug("[glfw] window creation complete");
} }
Window::~Window() { Window::~Window() {
if ( m_graphics != nullptr ) { if ( m_graphics != nullptr ) {
delete m_graphics;
m_graphics = nullptr; m_graphics = nullptr;
} }
...@@ -219,14 +219,14 @@ namespace fggl::display::glfw { ...@@ -219,14 +219,14 @@ namespace fggl::display::glfw {
glfwMakeContextCurrent(m_window); glfwMakeContextCurrent(m_window);
} }
fggl::math::vec2i Window::frameSize() const { auto Window::frameSize() const -> fggl::math::vec2i {
assert(m_window != nullptr); assert(m_window != nullptr);
math::vec2i size; math::vec2i size;
glfwGetFramebufferSize(m_window, &size.x, &size.y); glfwGetFramebufferSize(m_window, &size.x, &size.y);
return size; return size;
} }
bool Window::wantClose() const { auto Window::wantClose() const -> bool {
assert(m_window != nullptr); assert(m_window != nullptr);
return glfwWindowShouldClose(m_window) == GLFW_TRUE; return glfwWindowShouldClose(m_window) == GLFW_TRUE;
} }
......
fggl/grid/CMakeLists.txt 0 → 100644
View file @ bd58e207
target_sources( fggl
PRIVATE
hexagon.cpp
)
\ No newline at end of file
fggl/grid/hexagon.cpp 0 → 100644
View file @ bd58e207
/*
* This file is part of FGGL.
*
* FGGL is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any
* later version.
*
* FGGL is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License along with FGGL.
* If not, see <https://www.gnu.org/licenses/>.
*/
//
// Created by webpigeon on 10/12/22.
//
#include "fggl/grid/hexagon.hpp"
namespace fggl::grid {
std::vector<IntHex> lineTo(const IntHex& start, const IntHex& end) {
const int distance = start.distance(end);
std::vector<IntHex> line;
for (auto i=0; i < distance; ++i) {
line.push_back( round2(hexLerp(start, end, 1.0F/distance * i)) );
}
return line;
}
} // namespace fggl:grid
fggl/gui/CMakeLists.txt 0 → 100644
View file @ bd58e207
target_sources( ${PROJECT_NAME}
PRIVATE
widget.cpp
widgets.cpp
containers.cpp
fonts.cpp
model/parser.cpp
model/structure.cpp
renderer/renderer.cpp
)
find_package(Freetype)
target_link_libraries(${PROJECT_NAME} PUBLIC Freetype::Freetype)
fggl/gui/containers.cpp
View file @ bd58e207
...@@ -17,7 +17,7 @@ ...@@ -17,7 +17,7 @@
namespace fggl::gui { namespace fggl::gui {
Widget *Container::getChildAt(const math::vec2 &point) { auto Container::getChildAt(const math::vec2 &point) -> Widget * {
for (auto &child : m_children) { for (auto &child : m_children) {
if (child->contains(point)) { if (child->contains(point)) {
return child->getChildAt(point); return child->getChildAt(point);
...@@ -27,7 +27,7 @@ namespace fggl::gui { ...@@ -27,7 +27,7 @@ namespace fggl::gui {
return nullptr; return nullptr;
} }
bool Container::contains(const math::vec2 &point) { auto Container::contains(const math::vec2 &point) -> bool {
return true; return true;
} }
...@@ -82,8 +82,8 @@ namespace fggl::gui { ...@@ -82,8 +82,8 @@ namespace fggl::gui {
int rows = m_children.size() / m_cols; int rows = m_children.size() / m_cols;
// figure out the width and heights // figure out the width and heights
float* widths = new float[m_cols]{0.0F}; auto* widths = new float[m_cols]{0.0F};
float* heights = new float[rows]{0.0F}; auto* heights = new float[rows]{0.0F};
for ( auto idx = 0U; idx < m_children.size(); ++idx) { for ( auto idx = 0U; idx < m_children.size(); ++idx) {
auto& child = m_children[idx]; auto& child = m_children[idx];
int col = idx % m_cols; int col = idx % m_cols;
...@@ -95,8 +95,8 @@ namespace fggl::gui { ...@@ -95,8 +95,8 @@ namespace fggl::gui {
// populate the grid // populate the grid
fggl::math::vec2i pos{0, 0}; fggl::math::vec2i pos{0, 0};
int row = 0; unsigned int row = 0;
int col = 0; unsigned int col = 0;
for ( auto& child : m_children ) { for ( auto& child : m_children ) {
fggl::math::vec2i size{ widths[col], heights[row] }; fggl::math::vec2i size{ widths[col], heights[row] };
child->size(pos, size); child->size(pos, size);
...@@ -113,6 +113,9 @@ namespace fggl::gui { ...@@ -113,6 +113,9 @@ namespace fggl::gui {
} }
} }
// cleanup variables
delete[] widths;
delete[] heights;
} }
} }
...@@ -145,7 +148,7 @@ namespace fggl::gui { ...@@ -145,7 +148,7 @@ namespace fggl::gui {
void Panel::render(gfx::Paint &paint) { void Panel::render(gfx::Paint &paint) {
// background painting time // background painting time
gfx::Path2D background(topLeft()); gfx::Path2D background(topLeft());
background.colour(math::vec3(32.0f / 255.0f, 74.0F / 255.0F, 135.0F / 255.0F)); background.colour(math::vec3(32.0F / 255.0F, 74.0F / 255.0F, 135.0F / 255.0F));
draw_box(background, topLeft(), bottomRight()); draw_box(background, topLeft(), bottomRight());
paint.fill(background); paint.fill(background);
......
fggl/gui/fonts.cpp
View file @ bd58e207
...@@ -25,19 +25,19 @@ namespace fggl::gui { ...@@ -25,19 +25,19 @@ namespace fggl::gui {
FontLibrary::FontLibrary(data::Storage *storage) : m_context(nullptr), m_storage(storage) { FontLibrary::FontLibrary(data::Storage *storage) : m_context(nullptr), m_storage(storage) {
FT_Init_FreeType(&m_context); FT_Init_FreeType(&m_context);
m_defaultFont = getFont(DEFAULT_FONT_NAME);
} }
FontLibrary::~FontLibrary() { FontLibrary::~FontLibrary() {
// free all fonts // free all fonts
for (auto &face : m_cache) { m_defaultFont = nullptr;
face.second = nullptr; m_cache.clear();
}
// shut the library down // shut the library down
FT_Done_FreeType(m_context); FT_Done_FreeType(m_context);
} }
GlyphMetrics &FontFace::populateMetrics(char letter) { auto FontFace::populateMetrics(char letter) -> GlyphMetrics & {
if (FT_Load_Char(m_face, letter, FT_LOAD_RENDER)) { if (FT_Load_Char(m_face, letter, FT_LOAD_RENDER)) {
// something bad happened // something bad happened
return m_metrics['?']; return m_metrics['?'];
...@@ -54,7 +54,7 @@ namespace fggl::gui { ...@@ -54,7 +54,7 @@ namespace fggl::gui {
return it.first->second; return it.first->second;
} }
void FontFace::texture(char letter, int &width, int &height, void **buff) { void FontFace::texture(char letter, int &width, int &height, unsigned char **buff) {
if (FT_Load_Char(m_face, letter, FT_LOAD_RENDER)) { if (FT_Load_Char(m_face, letter, FT_LOAD_RENDER)) {
// something bad happened // something bad happened
return; return;
......
fggl/gui/model/parser.cpp 0 → 100644
View file @ bd58e207
/*
* This file is part of FGGL.
*
* FGGL is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any
* later version.
*
* FGGL is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License along with FGGL.
* If not, see <https://www.gnu.org/licenses/>.
*/
//
// Created by webpigeon on 11/03/23.
//
#include "fggl/gui/model/parser.hpp"
#include <yaml-cpp/yaml.h>
namespace fggl::gui::model {
Widget* YamlToWidgetTree(WidgetFactory& factory, const YAML::Node& config) {
Widget* root;
if ( config["template"] ) {
root = factory.build( config["template"].as<std::string>());
} else {
root = factory.buildEmpty();
}
// deal with attrs
for ( auto attr : config["attrs"] ) {
root->set(attr.first.as<std::string>(), attr.second.as<std::string>());
}
// deal with child nodes
for ( auto child : config["children"] ) {
Widget* childWidget = YamlToWidgetTree(factory, child);
root->addChild(*childWidget);
}
// are we a template definition?
if ( config["define"] ) {
factory.push( config["define"].as<std::string>(), std::move(*root) );
return factory.getTemplate( config["define"].as<std::string>() );
}
return root;
}
inline Widget* parseFile(WidgetFactory& factory, const std::string& path) {
YAML::Node root = YAML::LoadFile(path);
if ( !root ){
return nullptr;
}
return YamlToWidgetTree(factory, root);
}
}
\ No newline at end of file