diff --git a/ROADMAP.txt b/ROADMAP.txt index 4ff8968..ff29092 100644 --- a/ROADMAP.txt +++ b/ROADMAP.txt @@ -1,4 +1,5 @@ ------------ Tyra's v2.0 roadmap to publish on GitHub ------------ +- [Renderer] Fog - [Demo] Create cool demo which will show all features of Tyra - [General] CI in Github via docker image diff --git a/demo/inc/demo.hpp b/demo/inc/demo_game.hpp similarity index 61% rename from demo/inc/demo.hpp rename to demo/inc/demo_game.hpp index 45433ff..8f0d820 100644 --- a/demo/inc/demo.hpp +++ b/demo/inc/demo_game.hpp @@ -12,19 +12,24 @@ #include #include +#include "state/state_manager.hpp" -namespace Tyra { +using Tyra::Engine; +using Tyra::Game; -class Demo : public Game { +namespace Demo { + +class DemoGame : public Game { public: - Demo(Engine* engine); - ~Demo(); + DemoGame(Engine* engine); + ~DemoGame(); void init(); void loop(); private: Engine* engine; + StateManager stateManager; }; -} // namespace Tyra +} // namespace Demo diff --git a/demo/src/demo.cpp b/demo/inc/state/global_state_type.hpp similarity index 59% rename from demo/src/demo.cpp rename to demo/inc/state/global_state_type.hpp index 48d9fe7..b34458b 100644 --- a/demo/src/demo.cpp +++ b/demo/inc/state/global_state_type.hpp @@ -8,14 +8,10 @@ # Sandro Sobczyński */ -#include "demo.hpp" +#pragma once -namespace Tyra { +namespace Demo { -Demo::Demo(Engine* t_engine) { engine = t_engine; } -Demo::~Demo() {} +enum GlobalStateType { STATE_INTRO, STATE_GAME, STATE_EXIT }; -void Demo::init() { TYRA_LOG("Init!"); } -void Demo::loop() {} - -} // namespace Tyra +} // namespace Demo diff --git a/demo/inc/state/state.hpp b/demo/inc/state/state.hpp new file mode 100644 index 0000000..5d4dbeb --- /dev/null +++ b/demo/inc/state/state.hpp @@ -0,0 +1,40 @@ +/* +# ______ ____ ___ +# | \/ ____| |___| +# | | | \ | | +#----------------------------------------------------------------------- +# Copyright 2022, tyra - https://github.com/h4570/tyra +# Licenced under Apache License 2.0 +# Sandro Sobczyński +*/ + +#pragma once + +#include + +using Tyra::Engine; + +namespace Demo { + +template +class State { + public: + State(Engine* t_engine) : engine(t_engine) {} + virtual ~State() {} + + virtual const StateTypeT& getState() const = 0; + + virtual const bool& wantFinish() const = 0; + + virtual void onStart() = 0; + + virtual void update() = 0; + + /** @return Next game state */ + virtual StateTypeT onFinish() = 0; + + protected: + Engine* engine; +}; + +} // namespace Demo diff --git a/demo/inc/state/state_manager.hpp b/demo/inc/state/state_manager.hpp new file mode 100644 index 0000000..028c903 --- /dev/null +++ b/demo/inc/state/state_manager.hpp @@ -0,0 +1,63 @@ +/* +# ______ ____ ___ +# | \/ ____| |___| +# | | | \ | | +#----------------------------------------------------------------------- +# Copyright 2022, tyra - https://github.com/h4570/tyra +# Licenced under Apache License 2.0 +# Sandro Sobczyński +*/ + +#pragma once + +#include +#include "./state.hpp" +#include "./global_state_type.hpp" + +namespace Demo { + +template +class StateManager { + public: + StateManager(const StateTypeT& initialState) { + stateInitialized = false; + currentState = initialState; + } + + ~StateManager() { + for (auto& state : states) { + delete state; + } + } + + const StateTypeT& getCurrentState() const { return currentState; } + + void add(State* state) { states.push_back(state); } + + void update() { + for (auto& state : states) { + if (state->getState() == currentState) { + if (state->wantFinish()) { + currentState = state->onFinish(); + stateInitialized = false; + break; + } + + if (!stateInitialized) { + state->onStart(); + stateInitialized = true; + } + + state->update(); + break; + } + } + } + + private: + bool stateInitialized; + std::vector*> states; + StateTypeT currentState; +}; + +} // namespace Demo diff --git a/demo/inc/states/intro/intro_state.hpp b/demo/inc/states/intro/intro_state.hpp new file mode 100644 index 0000000..d8b4136 --- /dev/null +++ b/demo/inc/states/intro/intro_state.hpp @@ -0,0 +1,43 @@ +/* +# ______ ____ ___ +# | \/ ____| |___| +# | | | \ | | +#----------------------------------------------------------------------- +# Copyright 2022, tyra - https://github.com/h4570/tyra +# Licenced under Apache License 2.0 +# Sandro Sobczyński +*/ + +#pragma once + +#include "state/state.hpp" +#include "state/global_state_type.hpp" +#include "state/state_manager.hpp" +#include "./intro_state_type.hpp" + +namespace Demo { + +class IntroState : public State { + public: + IntroState(Engine* t_engine); + ~IntroState(); + + const GlobalStateType& getState() const { return state; } + + const bool& wantFinish() const { return _wantFinish; }; + + void onStart(); + + void update(); + + /** @return Next game state */ + GlobalStateType onFinish(); + + private: + GlobalStateType state; + bool _wantFinish; + + StateManager stateManager; +}; + +} // namespace Demo diff --git a/demo/inc/states/intro/intro_state_type.hpp b/demo/inc/states/intro/intro_state_type.hpp new file mode 100644 index 0000000..8ad2374 --- /dev/null +++ b/demo/inc/states/intro/intro_state_type.hpp @@ -0,0 +1,23 @@ +/* +# ______ ____ ___ +# | \/ ____| |___| +# | | | \ | | +#----------------------------------------------------------------------- +# Copyright 2022, tyra - https://github.com/h4570/tyra +# Licenced under Apache License 2.0 +# Sandro Sobczyński +*/ + +#pragma once + +namespace Demo { + +enum IntroStateType { + STATE_PS2DEV, + STATE_TYRA, + STATE_WAR_INFO, + STATE_PRESS_KEY, + STATE_INTRO_END +}; + +} // namespace Demo diff --git a/demo/inc/states/intro/states/intro_ps2dev_state.hpp b/demo/inc/states/intro/states/intro_ps2dev_state.hpp new file mode 100644 index 0000000..17bcca3 --- /dev/null +++ b/demo/inc/states/intro/states/intro_ps2dev_state.hpp @@ -0,0 +1,55 @@ +/* +# ______ ____ ___ +# | \/ ____| |___| +# | | | \ | | +#----------------------------------------------------------------------- +# Copyright 2022, tyra - https://github.com/h4570/tyra +# Licenced under Apache License 2.0 +# Sandro Sobczyński +*/ + +#pragma once + +#include "state/state.hpp" +#include "../intro_state_type.hpp" +#include "renderer/core/2d/sprite/sprite.hpp" +#include "time/timer.hpp" + +using Tyra::Sprite; +using Tyra::Texture; +using Tyra::Timer; + +namespace Demo { + +class IntroPs2DevState : public State { + public: + IntroPs2DevState(Engine* t_engine); + ~IntroPs2DevState(); + + const IntroStateType& getState() const { return state; } + + const bool& wantFinish() const { return _wantFinish; }; + + void onStart(); + + void update(); + + /** @return Next game state */ + IntroStateType onFinish(); + + private: + IntroStateType state; + bool _wantFinish; + + Texture* texture; + Timer initialDelayTimer; + bool initialized; + bool initialDelayElapsed; + bool fadeinActivated; + bool fadeoutActivated; + u8 frameSkipper; + + Sprite* sprite; +}; + +} // namespace Demo diff --git a/demo/inc/states/intro/states/intro_tyra_state.hpp b/demo/inc/states/intro/states/intro_tyra_state.hpp new file mode 100644 index 0000000..80d775c --- /dev/null +++ b/demo/inc/states/intro/states/intro_tyra_state.hpp @@ -0,0 +1,64 @@ +/* +# ______ ____ ___ +# | \/ ____| |___| +# | | | \ | | +#----------------------------------------------------------------------- +# Copyright 2022, tyra - https://github.com/h4570/tyra +# Licenced under Apache License 2.0 +# Sandro Sobczyński +*/ + +#pragma once + +#include "state/state.hpp" +#include "../intro_state_type.hpp" +#include "renderer/core/2d/sprite/sprite.hpp" +#include "time/timer.hpp" + +using Tyra::Sprite; +using Tyra::Texture; +using Tyra::Timer; + +namespace Demo { + +class IntroTyraState : public State { + public: + IntroTyraState(Engine* t_engine); + ~IntroTyraState(); + + const IntroStateType& getState() const { return state; } + + const bool& wantFinish() const { return _wantFinish; }; + + void onStart(); + + void update(); + + /** @return Next game state */ + IntroStateType onFinish(); + + private: + IntroStateType state; + bool _wantFinish; + + Texture* tyraTexture; + Texture* bgTexture; + Texture* bg2Texture; + Texture* fillerTexture; + + Timer initialDelayTimer; + bool initialized; + bool initialDelayElapsed; + bool animActivated; + bool fadeoutActivated; + u8 frameSkipper; + + Sprite* tyraSprite; + Sprite* bgSprite; + Sprite* bg2Sprite; + Sprite* fillerSprite; + + void renderFillers(); +}; + +} // namespace Demo diff --git a/demo/inc/states/intro/states/intro_war_info_state.hpp b/demo/inc/states/intro/states/intro_war_info_state.hpp new file mode 100644 index 0000000..f0abcc2 --- /dev/null +++ b/demo/inc/states/intro/states/intro_war_info_state.hpp @@ -0,0 +1,46 @@ +/* +# ______ ____ ___ +# | \/ ____| |___| +# | | | \ | | +#----------------------------------------------------------------------- +# Copyright 2022, tyra - https://github.com/h4570/tyra +# Licenced under Apache License 2.0 +# Sandro Sobczyński +*/ + +#pragma once + +#include "state/state.hpp" +#include "../intro_state_type.hpp" +#include "renderer/core/2d/sprite/sprite.hpp" +#include "time/timer.hpp" + +using Tyra::Sprite; +using Tyra::Texture; +using Tyra::Timer; + +namespace Demo { + +class IntroWarInfoState : public State { + public: + IntroWarInfoState(Engine* t_engine); + ~IntroWarInfoState(); + + const IntroStateType& getState() const { return state; } + + const bool& wantFinish() const { return _wantFinish; }; + + void onStart(); + + void update(); + + /** @return Next game state */ + IntroStateType onFinish(); + + private: + IntroStateType state; + bool _wantFinish; + bool initialized; +}; + +} // namespace Demo diff --git a/demo/res/.gitignore b/demo/res/.gitignore new file mode 100644 index 0000000..44c5ea8 --- /dev/null +++ b/demo/res/.gitignore @@ -0,0 +1,4 @@ +# Ignore everything in this directory +* +# Except this file +!.gitignore \ No newline at end of file diff --git a/demo/src/demo_game.cpp b/demo/src/demo_game.cpp new file mode 100644 index 0000000..01a9d8f --- /dev/null +++ b/demo/src/demo_game.cpp @@ -0,0 +1,23 @@ +/* +# ______ ____ ___ +# | \/ ____| |___| +# | | | \ | | +#----------------------------------------------------------------------- +# Copyright 2022, tyra - https://github.com/h4570/tyra +# Licenced under Apache License 2.0 +# Sandro Sobczyński +*/ + +#include "demo_game.hpp" +#include "states/intro/intro_state.hpp" + +namespace Demo { + +DemoGame::DemoGame(Engine* t_engine) + : engine(t_engine), stateManager(STATE_INTRO) {} +DemoGame::~DemoGame() {} + +void DemoGame::init() { stateManager.add(new IntroState(engine)); } +void DemoGame::loop() { stateManager.update(); } + +} // namespace Demo diff --git a/demo/src/main.cpp b/demo/src/main.cpp index 16e90f3..66af2ec 100644 --- a/demo/src/main.cpp +++ b/demo/src/main.cpp @@ -9,11 +9,11 @@ */ #include "engine.hpp" -#include "demo.hpp" +#include "demo_game.hpp" int main() { Tyra::Engine engine; - Tyra::Demo game(&engine); + Demo::DemoGame game(&engine); engine.run(&game); SleepThread(); return 0; diff --git a/demo/src/states/intro/intro_state.cpp b/demo/src/states/intro/intro_state.cpp new file mode 100644 index 0000000..5d51bb3 --- /dev/null +++ b/demo/src/states/intro/intro_state.cpp @@ -0,0 +1,46 @@ +/* +# ______ ____ ___ +# | \/ ____| |___| +# | | | \ | | +#----------------------------------------------------------------------- +# Copyright 2022, tyra - https://github.com/h4570/tyra +# Licenced under Apache License 2.0 +# Sandro Sobczyński +*/ + +#include "states/intro/intro_state.hpp" +#include "file/file_utils.hpp" +#include "debug/debug.hpp" + +#include "states/intro/states/intro_ps2dev_state.hpp" +#include "states/intro/states/intro_tyra_state.hpp" +#include "states/intro/states/intro_war_info_state.hpp" + +using Tyra::FileUtils; + +namespace Demo { + +IntroState::IntroState(Engine* t_engine) + : State(t_engine), stateManager(STATE_PS2DEV) { + state = STATE_INTRO; + _wantFinish = false; +} + +IntroState::~IntroState() {} + +void IntroState::onStart() { + engine->audio.loadSong(FileUtils::fromCwd("intro/intro.wav")); + engine->audio.setSongLoop(false); + engine->audio.setSongVolume(80); + engine->audio.playSong(); + + stateManager.add(new IntroPs2DevState(engine)); + stateManager.add(new IntroTyraState(engine)); + stateManager.add(new IntroWarInfoState(engine)); +} + +void IntroState::update() { stateManager.update(); } + +GlobalStateType IntroState::onFinish() { return STATE_EXIT; } + +} // namespace Demo diff --git a/demo/src/states/intro/states/intro_ps2dev_state.cpp b/demo/src/states/intro/states/intro_ps2dev_state.cpp new file mode 100644 index 0000000..dcdacd4 --- /dev/null +++ b/demo/src/states/intro/states/intro_ps2dev_state.cpp @@ -0,0 +1,99 @@ +/* +# ______ ____ ___ +# | \/ ____| |___| +# | | | \ | | +#----------------------------------------------------------------------- +# Copyright 2022, tyra - https://github.com/h4570/tyra +# Licenced under Apache License 2.0 +# Sandro Sobczyński +*/ + +#include "states/intro/states/intro_ps2dev_state.hpp" +#include "loaders/texture/png_loader.hpp" +#include "file/file_utils.hpp" +#include "debug/debug.hpp" +#include "thread/threading.hpp" + +using Tyra::FileUtils; +using Tyra::PngLoader; +using Tyra::Threading; + +namespace Demo { + +IntroPs2DevState::IntroPs2DevState(Engine* t_engine) : State(t_engine) { + state = STATE_PS2DEV; + _wantFinish = false; + initialized = false; + initialDelayElapsed = false; + frameSkipper = 0; + fadeinActivated = true; + fadeoutActivated = false; +} + +IntroPs2DevState::~IntroPs2DevState() { + if (!initialized) return; + + delete sprite; + engine->renderer.core.texture.repository.free(texture->getId()); +} + +void IntroPs2DevState::onStart() { + const auto& settings = engine->renderer.core.getSettings(); + + TYRA_LOG("Init!"); + + initialDelayTimer.prime(); + + sprite = new Sprite; + sprite->size.set(256.0F, 64.0F); + sprite->position.set(settings.getWidth() / 2 - sprite->size.x / 2, + settings.getHeight() / 2 - sprite->size.y / 2); + sprite->color.a = 0; + + texture = engine->renderer.core.texture.repository.add( + FileUtils::fromCwd("intro/ps2dev.png")); + texture->addLink(sprite->getId()); + + initialized = true; +} + +void IntroPs2DevState::update() { + engine->renderer.beginFrame(); + + if (initialDelayTimer.getTimeDelta() >= 60000) initialDelayElapsed = true; + + frameSkipper++; + if (frameSkipper > 3) { + frameSkipper = 0; + } + + if (fadeinActivated && initialDelayElapsed && frameSkipper == 0) { + if (sprite->color.a < 128.0F) + sprite->color.a += 2.0F; + else { + fadeoutActivated = true; + fadeinActivated = false; + } + if (sprite->color.a >= 96.0F && sprite->color.a < 128.0F) { + sprite->color.g -= 6.0F; + sprite->color.b -= 6.0F; + } + } + + Threading::switchThread(); + + if (fadeoutActivated && frameSkipper == 0) { + if (sprite->color.a > 0) + sprite->color.a -= 4; + else + _wantFinish = true; + } + + engine->renderer.renderer2D.render(sprite); + + engine->renderer.endFrame(); +} + +IntroStateType IntroPs2DevState::onFinish() { return STATE_TYRA; } + +} // namespace Demo diff --git a/demo/src/states/intro/states/intro_tyra_state.cpp b/demo/src/states/intro/states/intro_tyra_state.cpp new file mode 100644 index 0000000..04b3f97 --- /dev/null +++ b/demo/src/states/intro/states/intro_tyra_state.cpp @@ -0,0 +1,173 @@ +/* +# ______ ____ ___ +# | \/ ____| |___| +# | | | \ | | +#----------------------------------------------------------------------- +# Copyright 2022, tyra - https://github.com/h4570/tyra +# Licenced under Apache License 2.0 +# Sandro Sobczyński +*/ + +#include "states/intro/states/intro_tyra_state.hpp" +#include "loaders/texture/png_loader.hpp" +#include "file/file_utils.hpp" +#include "debug/debug.hpp" +#include "thread/threading.hpp" +#include "math/math.hpp" + +using Tyra::FileUtils; +using Tyra::Math; +using Tyra::PngLoader; +using Tyra::Threading; + +namespace Demo { + +IntroTyraState::IntroTyraState(Engine* t_engine) : State(t_engine) { + state = STATE_TYRA; + _wantFinish = false; + initialized = false; + initialDelayElapsed = false; + animActivated = true; + fadeoutActivated = false; + frameSkipper = 0; +} + +IntroTyraState::~IntroTyraState() { + if (!initialized) return; + + engine->renderer.core.texture.repository.free(tyraTexture->getId()); + engine->renderer.core.texture.repository.free(bgTexture->getId()); + engine->renderer.core.texture.repository.free(fillerTexture->getId()); + + delete tyraSprite; + delete bgSprite; + delete fillerSprite; +} + +void IntroTyraState::onStart() { + const auto& settings = engine->renderer.core.getSettings(); + + initialDelayTimer.prime(); + + tyraSprite = new Sprite; + tyraSprite->size.set(256.0F, 64.0F); + tyraSprite->position.set(settings.getWidth() / 2 - tyraSprite->size.x / 2, + settings.getHeight() / 2 - tyraSprite->size.y / 2); + + bgSprite = new Sprite; + bgSprite->size.set(256.0F, 256.0F); + bgSprite->position.set(settings.getWidth() / 2 - bgSprite->size.x / 2, + settings.getHeight() / 3 * 2.0F); + + bg2Sprite = new Sprite; + bg2Sprite->size.set(256.0F, 256.0F); + bg2Sprite->position.set( + settings.getWidth() / 2 - bg2Sprite->size.x / 2, + (settings.getHeight() / 3 * 2.0F) + bg2Sprite->size.y + 1.0F); + + fillerSprite = new Sprite; + fillerSprite->size.set(256.0F, 256.0F); + fillerSprite->position.set(0.0F, 0.0F); + + tyraTexture = engine->renderer.core.texture.repository.add( + FileUtils::fromCwd("intro/tyra.png")); + tyraTexture->addLink(tyraSprite->getId()); + + bgTexture = engine->renderer.core.texture.repository.add( + FileUtils::fromCwd("intro/tyra_bg.png")); + bgTexture->addLink(bgSprite->getId()); + + bg2Texture = engine->renderer.core.texture.repository.add( + FileUtils::fromCwd("intro/tyra_bg2.png")); + bg2Texture->addLink(bg2Sprite->getId()); + + fillerTexture = engine->renderer.core.texture.repository.add( + FileUtils::fromCwd("intro/filler.png")); + fillerTexture->addLink(fillerSprite->getId()); + + initialized = true; +} + +void IntroTyraState::update() { + engine->renderer.beginFrame(); + + if (initialDelayTimer.getTimeDelta() >= 15000) initialDelayElapsed = true; + + frameSkipper++; + if (frameSkipper > 3) { + frameSkipper = 0; + } + + const float slideUpMaxPost = -128.0F; + + if (initialDelayElapsed) { + if (bgSprite->position.y <= 32.0F) fadeoutActivated = true; + + float offset = 1.0F; + if (bgSprite->position.y > slideUpMaxPost && bgSprite->position.y <= 64.0F) + offset /= 1.6F; + else if (bgSprite->position.y > 64.0F && bgSprite->position.y <= 128.0F) + offset /= 1.2F; + + if (bgSprite->position.y > 32.0F && bgSprite->position.y <= 64.0F && + bgSprite->color.g > 0.0F) { + const float colorOffset = 1.5F; + bgSprite->color.g -= colorOffset; + bgSprite->color.b -= colorOffset; + bg2Sprite->color.g -= colorOffset; + bg2Sprite->color.b -= colorOffset; + } + + if (bgSprite->position.y > slideUpMaxPost) { + bgSprite->position.y -= offset; + bg2Sprite->position.y -= offset; + } + } + + if (fadeoutActivated && frameSkipper == 0) { + if (bgSprite->color.a > 0) { + bgSprite->color.a -= 4.0F; + bg2Sprite->color.a -= 4.0F; + } else + _wantFinish = true; + } + + Threading::switchThread(); + + engine->renderer.renderer2D.render(bgSprite); + engine->renderer.renderer2D.render(bg2Sprite); + engine->renderer.renderer2D.render(tyraSprite); + + Threading::switchThread(); + renderFillers(); + + engine->renderer.endFrame(); +} + +void IntroTyraState::renderFillers() { + // Up + fillerSprite->position.set(0.0F, -63.0F); + engine->renderer.renderer2D.render(fillerSprite); + + fillerSprite->position.set(256.0F, -63.0F); + engine->renderer.renderer2D.render(fillerSprite); + + // Left + fillerSprite->position.set(-124.0F, 128.0F); + engine->renderer.renderer2D.render(fillerSprite); + + // Down + fillerSprite->position.set(0.0F, 256.0F); + engine->renderer.renderer2D.render(fillerSprite); + + fillerSprite->position.set(256.0F, 256.0F); + engine->renderer.renderer2D.render(fillerSprite); + + // Right + fillerSprite->position.set(386.0F, 128.0F); + engine->renderer.renderer2D.render(fillerSprite); +} + +IntroStateType IntroTyraState::onFinish() { return STATE_WAR_INFO; } + +} // namespace Demo diff --git a/demo/src/states/intro/states/intro_war_info_state.cpp b/demo/src/states/intro/states/intro_war_info_state.cpp new file mode 100644 index 0000000..19ec422 --- /dev/null +++ b/demo/src/states/intro/states/intro_war_info_state.cpp @@ -0,0 +1,43 @@ +/* +# ______ ____ ___ +# | \/ ____| |___| +# | | | \ | | +#----------------------------------------------------------------------- +# Copyright 2022, tyra - https://github.com/h4570/tyra +# Licenced under Apache License 2.0 +# Sandro Sobczyński +*/ + +#include "states/intro/states/intro_war_info_state.hpp" +#include "loaders/texture/png_loader.hpp" +#include "file/file_utils.hpp" +#include "debug/debug.hpp" +#include "thread/threading.hpp" +#include "math/math.hpp" + +using Tyra::FileUtils; +using Tyra::Math; +using Tyra::PngLoader; +using Tyra::Threading; + +namespace Demo { + +IntroWarInfoState::IntroWarInfoState(Engine* t_engine) : State(t_engine) { + state = STATE_WAR_INFO; + _wantFinish = false; +} + +IntroWarInfoState::~IntroWarInfoState() { + if (!initialized) return; +} + +void IntroWarInfoState::onStart() { initialized = true; } + +void IntroWarInfoState::update() { + engine->renderer.beginFrame(); + + engine->renderer.endFrame(); +} +IntroStateType IntroWarInfoState::onFinish() { return STATE_PRESS_KEY; } + +} // namespace Demo diff --git a/engine/inc/math/math.hpp b/engine/inc/math/math.hpp index 2b82cb5..dc0ade6 100644 --- a/engine/inc/math/math.hpp +++ b/engine/inc/math/math.hpp @@ -30,6 +30,8 @@ class Math { static inline float sin(float x) { return cos(x - HALF_PI); } static inline float tan(float x) { return sin(x) / cos(x); } static float invSqrt(float x); + static bool equalf(const float& a, const float& b, + const float& epsilon = 0.00001F); private: Math(); diff --git a/engine/inc/renderer/core/3d/renderer_core_3d.hpp b/engine/inc/renderer/core/3d/renderer_core_3d.hpp index 1df90b7..ecb055c 100644 --- a/engine/inc/renderer/core/3d/renderer_core_3d.hpp +++ b/engine/inc/renderer/core/3d/renderer_core_3d.hpp @@ -35,9 +35,16 @@ class RendererCore3D { void setFov(const float& t_fov); + /** + * Called by beginFrame(); + * Sets 3D support to off + */ + void update(); + /** * Called by beginFrame(); * Updates camera info, to get proper frustum culling. + * Sets 3D support to on */ void update(const CameraInfo3D& cameraInfo); @@ -48,13 +55,13 @@ class RendererCore3D { * Get view (camera) matrix * Updated at every beginFrame() */ - const M4x4& getView() { return view; } + const M4x4& getView(); /** * Get projection * view matrix * Updated at every beginFrame() */ - const M4x4& getViewProj() { return viewProj; } + const M4x4& getViewProj(); /** * @brief @@ -80,6 +87,7 @@ class RendererCore3D { private: M4x4 view, projection, viewProj; float fov; + bool is3DSupportEnabled; RendererSettings* settings; diff --git a/engine/inc/renderer/core/renderer_core.hpp b/engine/inc/renderer/core/renderer_core.hpp index 3bef33f..826fdcd 100644 --- a/engine/inc/renderer/core/renderer_core.hpp +++ b/engine/inc/renderer/core/renderer_core.hpp @@ -47,7 +47,10 @@ class RendererCore { /** World background color */ void setClearScreenColor(const Color& color); - /** Clear screen and update view frustum for frustum culling. */ + /** Clear screen and update view frustum for frustum culling. NO 3D support */ + void beginFrame(); + + /** Clear screen and update view frustum for frustum culling. 3D support */ void beginFrame(const CameraInfo3D& cameraInfo); /** VSync and swap frame double buffer. */ diff --git a/engine/inc/renderer/renderer.hpp b/engine/inc/renderer/renderer.hpp index ff5a796..0995986 100644 --- a/engine/inc/renderer/renderer.hpp +++ b/engine/inc/renderer/renderer.hpp @@ -37,7 +37,10 @@ class Renderer { void setFrameLimit(const bool& onoff) { core.setFrameLimit(onoff); } - /** Update view frustum for frustum culling. */ + /** Update view frustum for frustum culling. 3D support - off */ + void beginFrame(); + + /** Update view frustum for frustum culling. 3D support - on */ void beginFrame(const CameraInfo3D& cameraInfo); /** VSync and swap frame double buffer. */ diff --git a/engine/src/math/math.cpp b/engine/src/math/math.cpp index 4efcb83..ad7fc61 100644 --- a/engine/src/math/math.cpp +++ b/engine/src/math/math.cpp @@ -136,6 +136,10 @@ float Math::asin(float x) { return r; } +bool Math::equalf(const float& a, const float& b, const float& epsilon) { + return fabs(a - b) < epsilon; +} + float Math::mod(float x, float y) { /* * Portable fmod(x,y) implementation for systems diff --git a/engine/src/renderer/core/3d/renderer_core_3d.cpp b/engine/src/renderer/core/3d/renderer_core_3d.cpp index 46cbcf4..09a87fa 100644 --- a/engine/src/renderer/core/3d/renderer_core_3d.cpp +++ b/engine/src/renderer/core/3d/renderer_core_3d.cpp @@ -12,13 +12,19 @@ namespace Tyra { -RendererCore3D::RendererCore3D() { fov = 60.0F; } +RendererCore3D::RendererCore3D() { + fov = 60.0F; + is3DSupportEnabled = false; +} RendererCore3D::~RendererCore3D() {} +void RendererCore3D::update() { is3DSupportEnabled = false; } + void RendererCore3D::update(const CameraInfo3D& cameraInfo) { frustumPlanes.update(cameraInfo, fov); M4x4::lookAt(&view, *cameraInfo.position, *cameraInfo.looksAt); viewProj = projection * view; + is3DSupportEnabled = true; } void RendererCore3D::init(RendererSettings* t_settings, Path1* t_path1) { @@ -29,7 +35,20 @@ void RendererCore3D::init(RendererSettings* t_settings, Path1* t_path1) { TYRA_LOG("RendererCore3D initialized!"); } -// TODO, usunac albo private core? przesunac set/get fov? +const M4x4& RendererCore3D::getView() { + TYRA_ASSERT(is3DSupportEnabled, + "You can't compute 3D without camera information. Please correct " + "your beginFrame()"); + return view; +} + +const M4x4& RendererCore3D::getViewProj() { + TYRA_ASSERT(is3DSupportEnabled, + "You can't compute 3D without camera information. Please correct " + "your beginFrame()"); + return viewProj; +} + void RendererCore3D::setFov(const float& t_fov) { fov = t_fov; setProjection(); diff --git a/engine/src/renderer/core/renderer_core.cpp b/engine/src/renderer/core/renderer_core.cpp index 7de3ac2..787dd30 100644 --- a/engine/src/renderer/core/renderer_core.cpp +++ b/engine/src/renderer/core/renderer_core.cpp @@ -27,6 +27,12 @@ void RendererCore::init() { void RendererCore::setClearScreenColor(const Color& color) { bgColor = color; } +void RendererCore::beginFrame() { + renderer3D.update(); + Threading::switchThread(); + path3.clearScreen(&gs.zBuffer, bgColor); +} + void RendererCore::beginFrame(const CameraInfo3D& cameraInfo) { renderer3D.update(cameraInfo); Threading::switchThread(); diff --git a/engine/src/renderer/renderer.cpp b/engine/src/renderer/renderer.cpp index 5b1c72e..122ac44 100644 --- a/engine/src/renderer/renderer.cpp +++ b/engine/src/renderer/renderer.cpp @@ -20,6 +20,8 @@ void Renderer::init() { renderer2D.init(&core); } +void Renderer::beginFrame() { core.beginFrame(); } + void Renderer::beginFrame(const CameraInfo3D& cameraInfo) { core.beginFrame(cameraInfo); }