initial commit

src/engine/engine.cpp

@@ -0,0 +1,57 @@
+//
+// Created by m on 12/3/21.
+//
+
+#include "engine.hpp"
+#include <cstdio>
+#include <memory>
+#include <chrono>
+#include <thread>
+#include <SDL.h>
+using namespace std::chrono_literals;
+void Engine::start_loop() {
+    const auto one_second_milli = std::chrono::milliseconds(1s);
+    if(game == nullptr) {
+        printf("game is null\n");
+        return;
+    }
+    if(renderer == nullptr) {
+        printf("renderer is null\n");
+        return;
+    }
+    RendererParams renderParams = game->get_renderer_params();
+    renderer->initialize(renderParams);
+    renderer->flush();
+    auto duration_per_frame = one_second_milli / game->get_framerate();
+    auto last_frame = std::chrono::high_resolution_clock::now();
+    while(true) {
+        auto starttime = std::chrono::high_resolution_clock::now();
+        bool end = game->update();
+        if(end) {
+            break;
+        }
+        game->render(renderer.get());
+        renderer->flush();
+        auto endtime = std::chrono::high_resolution_clock::now();
+        last_frame = render_fps(endtime, last_frame);
+
+        std::this_thread::sleep_for(duration_per_frame);
+    }
+}
+
+Engine::Engine(std::unique_ptr<Game> game, std::unique_ptr<Renderer> renderer) {
+    this->renderer = std::move(renderer);
+    this->game = std::move(game);
+}
+
+std::chrono::time_point<std::chrono::system_clock>
+Engine::render_fps(std::chrono::time_point<std::chrono::system_clock> end,
+                   std::chrono::time_point<std::chrono::system_clock> lastframe) {
+    double frames = 1;
+    std::chrono::duration<double> dur = end - lastframe;
+    if(SHOW_FPS) {
+        printf("fps: %f\n", frames/dur.count());
+    }
+    return end;
+}
+

src/engine/engine.hpp

@@ -0,0 +1,23 @@
+//
+// Created by m on 12/3/21.
+//
+
+#ifndef RLA_IIPP_ENGINE_HPP
+#define RLA_IIPP_ENGINE_HPP
+#include <memory>
+#include <chrono>
+#include "game/game.hpp"
+#include "rendering/renderer.hpp"
+static const bool SHOW_FPS = true;
+class Engine {
+public:
+    Engine(std::unique_ptr<Game> game, std::unique_ptr<Renderer> renderer);
+    void start_loop();
+    std::chrono::time_point<std::chrono::system_clock> render_fps(std::chrono::time_point<std::chrono::system_clock> end, std::chrono::time_point<std::chrono::system_clock> lastframe);
+private:
+    std::unique_ptr<Game> game;
+    std::unique_ptr<Renderer> renderer;
+};
+
+
+#endif //RLA_IIPP_ENGINE_HPP

src/engine/game/game.hpp

@@ -0,0 +1,16 @@
+//
+// Created by m on 12/3/21.
+//
+
+#ifndef RLA_IIPP_GAME_HPP
+#define RLA_IIPP_GAME_HPP
+#include "../rendering/renderer.hpp"
+class Game {
+public:
+    virtual bool update() = 0;
+    virtual void render(Renderer* renderer) = 0;
+    virtual RendererParams get_renderer_params() = 0;
+    virtual unsigned int get_framerate() = 0;
+};
+
+#endif //RLA_IIPP_GAME_HPP

src/engine/rendering/renderer.hpp

@@ -0,0 +1,31 @@
+//
+// Created by m on 12/3/21.
+//
+
+#ifndef RLA_IIPP_RENDERER_HPP
+#define RLA_IIPP_RENDERER_HPP
+
+struct Color {
+public:
+    unsigned char r;
+    unsigned char g;
+    unsigned char b;
+    unsigned char a;
+
+    Color(unsigned char r, unsigned char g, unsigned char b, unsigned char a) : r(r), g(g), b(b), a(a) {}
+};
+
+struct RendererParams {
+    char* title;
+    unsigned int width;
+    unsigned int height;
+};
+
+class Renderer {
+public:
+    virtual void initialize(RendererParams params)=0;
+    virtual void flush() = 0;
+    virtual void draw_point(int x, int y, Color color) = 0;
+};
+
+#endif //RLA_IIPP_RENDERER_HPP

src/engine/rendering/sdl/sdlrenderer.cpp

@@ -0,0 +1,32 @@
+//
+// Created by m on 12/3/21.
+//
+#include <cstdio>
+#include "sdlrenderer.hpp"
+
+void SdlRenderer::initialize(RendererParams params) {
+    if(SDL_Init(SDL_INIT_VIDEO) < 0) {
+        printf("SDL vide oinit failed: %s\n", SDL_GetError());
+    }
+    SDL_Window* sdl_window = SDL_CreateWindow(params.title, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, params.width, params.height, SDL_WINDOW_SHOWN);
+    if(sdl_window == nullptr) {
+        printf("error making window: %s\n", SDL_GetError());
+    }
+    else {
+        this->window = sdl_window;
+        SDL_Renderer* sdl_renderer = SDL_CreateRenderer(this->window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
+        this->renderer = sdl_renderer;
+        SDL_RenderClear(this->renderer);
+    }
+}
+
+void SdlRenderer::flush() {
+    SDL_RenderPresent(this->renderer);
+    SDL_SetRenderDrawColor(this->renderer, 0, 0, 0, 255);
+    SDL_RenderClear(this->renderer);
+}
+
+void SdlRenderer::draw_point(int x, int y, Color color) {
+    SDL_SetRenderDrawColor(this->renderer, color.r, color.g, color.b, color.a);
+    SDL_RenderDrawPoint(this->renderer, x, y);
+}

src/engine/rendering/sdl/sdlrenderer.hpp

@@ -0,0 +1,22 @@
+//
+// Created by m on 12/3/21.
+//
+
+#ifndef RLA_IIPP_SDLRENDERER_HPP
+#define RLA_IIPP_SDLRENDERER_HPP
+#include "../renderer.hpp"
+#include <SDL.h>
+
+class SdlRenderer : public Renderer {
+    void initialize(RendererParams params) override;
+
+    void flush() override;
+
+    void draw_point(int x, int y, Color color) override;
+private:
+    SDL_Window* window = nullptr;
+    SDL_Renderer* renderer = nullptr;
+};
+
+
+#endif //RLA_IIPP_SDLRENDERER_HPP

src/game/visualizer.cpp

@@ -0,0 +1,32 @@
+//
+// Created by m on 12/3/21.
+//
+
+#include "visualizer.hpp"
+#define TITLE "test"
+#define WIN_WIDTH 800
+#define WIN_HEIGHT 600
+#define TARGET_FPS 60
+bool Visualizer::update() {
+    this->x += 1;
+    if(this->x > WIN_WIDTH) {
+        this->x = 0;
+        return true;
+    }
+    return false;
+}
+
+RendererParams Visualizer::get_renderer_params() {
+    return {.title =  TITLE, .width =  WIN_WIDTH, .height =  WIN_HEIGHT};
+}
+
+unsigned int Visualizer::get_framerate() {
+    return TARGET_FPS;
+}
+
+void Visualizer::render(Renderer *renderer) {
+    Color color = Color(255, 255, 255, 255);
+    for(int y=0;y<WIN_HEIGHT;y++) {
+        renderer->draw_point(this->x, y, color);
+    }
+}

src/game/visualizer.hpp

@@ -0,0 +1,24 @@
+//
+// Created by m on 12/3/21.
+//
+#include "../engine/game/game.hpp"
+#ifndef RLA_IIPP_VISUALIZER_HPP
+#define RLA_IIPP_VISUALIZER_HPP
+
+
+class Visualizer : public Game {
+public:
+    bool update() override;
+
+    void render(Renderer* renderer) override;
+
+    RendererParams get_renderer_params() override;
+
+    unsigned int get_framerate() override;
+
+private:
+    int x = 0;
+
+};
+
+#endif //RLA_IIPP_VISUALIZER_HPP

src/main.cpp

@@ -0,0 +1,17 @@
+#include <cstdio>
+#include <memory>
+#include "engine/rendering/renderer.hpp"
+#include "engine/rendering/sdl/sdlrenderer.hpp"
+#include "engine/engine.hpp"
+#include "game/visualizer.hpp"
+
+int main() {
+    const char* TITLE = "Test";
+
+    std::unique_ptr<Renderer> renderer = std::make_unique<SdlRenderer>();
+    std::unique_ptr<Game> game = std::make_unique<Visualizer>();
+    Engine* engine = new Engine(std::move(game), std::move(renderer));
+    engine->start_loop();
+
+    return 0;
+}