demo 1

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
 

demo/inc/demo_game.hpp

@@ -12,19 +12,24 @@
 
 #include <engine.hpp>
 #include <game.hpp>
+#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);
+  DemoGame(Engine* engine);
-  ~Demo();
+  ~DemoGame();
 
   void init();
   void loop();
 
  private:
   Engine* engine;
+  StateManager<GlobalStateType> stateManager;
 };
 
-}  // namespace Tyra
+}  // namespace Demo

demo/inc/state/global_state_type.hpp

@@ -8,14 +8,10 @@
 # Sandro Sobczyński <sandro.sobczynski@gmail.com>
 */
 
-#include "demo.hpp"
+#pragma once
 
-namespace Tyra {
+namespace Demo {
 
-Demo::Demo(Engine* t_engine) { engine = t_engine; }
+enum GlobalStateType { STATE_INTRO, STATE_GAME, STATE_EXIT };
-Demo::~Demo() {}
 
-void Demo::init() { TYRA_LOG("Init!"); }
+}  // namespace Demo
-void Demo::loop() {}
-
-}  // namespace Tyra

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 <sandro.sobczynski@gmail.com>
+*/
+
+#pragma once
+
+#include <engine.hpp>
+
+using Tyra::Engine;
+
+namespace Demo {
+
+template <typename StateTypeT>
+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

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 <sandro.sobczynski@gmail.com>
+*/
+
+#pragma once
+
+#include <vector>
+#include "./state.hpp"
+#include "./global_state_type.hpp"
+
+namespace Demo {
+
+template <typename StateTypeT>
+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<StateTypeT>* 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<State<StateTypeT>*> states;
+  StateTypeT currentState;
+};
+
+}  // namespace Demo

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 <sandro.sobczynski@gmail.com>
+*/
+
+#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<GlobalStateType> {
+ 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<IntroStateType> stateManager;
+};
+
+}  // namespace Demo

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 <sandro.sobczynski@gmail.com>
+*/
+
+#pragma once
+
+namespace Demo {
+
+enum IntroStateType {
+  STATE_PS2DEV,
+  STATE_TYRA,
+  STATE_WAR_INFO,
+  STATE_PRESS_KEY,
+  STATE_INTRO_END
+};
+
+}  // namespace Demo

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 <sandro.sobczynski@gmail.com>
+*/
+
+#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<IntroStateType> {
+ 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

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 <sandro.sobczynski@gmail.com>
+*/
+
+#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<IntroStateType> {
+ 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

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 <sandro.sobczynski@gmail.com>
+*/
+
+#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<IntroStateType> {
+ 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

demo/res/.gitignore

@@ -0,0 +1,4 @@
+# Ignore everything in this directory
+*
+# Except this file
+!.gitignore

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 <sandro.sobczynski@gmail.com>
+*/
+
+#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

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;

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 <sandro.sobczynski@gmail.com>
+*/
+
+#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

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 <sandro.sobczynski@gmail.com>
+*/
+
+#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

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 <sandro.sobczynski@gmail.com>
+*/
+
+#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

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 <sandro.sobczynski@gmail.com>
+*/
+
+#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

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();

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;
 

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. */

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. */

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

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();

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();

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);
 }