First test rendering / skelton Game Loop / utility Textureloader

src/DarkRP2D.cpp

@@ -1,17 +1,64 @@
+#include <iostream>
+#include <SDL2/SDL_image.h>
+
 #include "DarkRP2D.h"
+#include "utility/utility.h"
 
-  void DarkRP2D::create() {
+
+
+  void DarkRP2D::create(SDL_Renderer *gRenderer) {
+    this->gRenderer = gRenderer;
+
+    //Load PNG texture
+    gTexture = utility::loadTexture( "assets/police_officer.png", gRenderer);
 
   }
 
-  void DarkRP2D::loop(float deltaTime) {
+  unsigned int ups = 0;
+  unsigned int acc = 0;
+  void DarkRP2D::loop(unsigned int deltaTime) {
+      accumulator += deltaTime;
+      acc += deltaTime;
+
+      //Process Input
+
+      skippedFrames = 0;
+      while (accumulator >= MS_PER_UPDATE && skippedFrames <= MAX_FRAMESKIP) {
+        accumulator -= MS_PER_UPDATE;
+        update(0.0f);
+        ups++;
+        skippedFrames++;
+      }
+
+      if(acc >= 1000) {
+        std::cout << "Updates per second: " << ups << std::endl;
+        acc -= 1000;
+        ups = 0;
+      }
+      render(0.0f);
+  }
+
+  void DarkRP2D::update(float deltaInSec) {
 
   }
 
-  void DarkRP2D::resize() {
+  void DarkRP2D::render(float deltaInSec) {
+    //Clear screen
+    SDL_RenderClear( gRenderer );
+
+    //Render texture to screen
+    SDL_RenderCopy( gRenderer, gTexture, NULL, NULL );
+
+    //Update screen
+    SDL_RenderPresent( gRenderer );
+  }
+
+  void DarkRP2D::resize(int width, int height) {
 
   }
 
   void DarkRP2D::dispose() {
-
+      //Free loaded image
+      SDL_DestroyTexture( gTexture );
+      gTexture = NULL;
   }

src/DarkRP2D.h

@@ -1,11 +1,28 @@
 #ifndef DARKRP2D_H
 #define DARKRP2D_H
 
+#include <SDL2/SDL.h>
+
 class DarkRP2D {
+private:
+  unsigned int accumulator = 0;
+  int skippedFrames = 0;
+  //test texture
+  SDL_Texture* gTexture = NULL;
+
 public:
-  void create();
-  void loop(float deltaTime);
-  void resize();
+  static const int UPDATES_PER_SECOND = 60;
+  static const unsigned int MS_PER_UPDATE = 17; // 1 / UPDATES_PER_SECOND ~ 16,777777777
+  static const int MAX_FRAMESKIP = 5;
+
+  SDL_Renderer* gRenderer = NULL;
+
+  DarkRP2D() {}
+  void create(SDL_Renderer *gRenderer);
+  void loop(unsigned int deltaTime);
+  void update(float deltaInSec);
+  void render(float deltaInSec);
+  void resize(int width, int height);
   void dispose();
 };
 

src/DesktopLauncher.cpp

@@ -3,13 +3,162 @@
 #include <SDL2/SDL.h>
 #include "DarkRP2D.h"
 
-const int WIDTH = 800, HEIGHT = 600;
+#define GAME_NAME "DarkRP2D"
+
+const int SCREEN_WIDTH = 800, SCREEN_HEIGHT = 600;
+
+SDL_Window* gWindow = NULL; //The window we'll be rendering to
+SDL_Surface* gScreenSurface = NULL; //The surface contained by the window
+SDL_Renderer* gRenderer = NULL;
+DarkRP2D* darkRP2D = NULL;
+
+void PrintEvent(const SDL_Event *event) {
+    if (event->type == SDL_WINDOWEVENT) {
+        switch (event->window.event) {
+        case SDL_WINDOWEVENT_SHOWN:
+            SDL_Log("Window %d shown", event->window.windowID);
+            break;
+        case SDL_WINDOWEVENT_HIDDEN:
+            SDL_Log("Window %d hidden", event->window.windowID);
+            break;
+        case SDL_WINDOWEVENT_EXPOSED:
+            SDL_Log("Window %d exposed", event->window.windowID);
+            break;
+        case SDL_WINDOWEVENT_MOVED:
+            SDL_Log("Window %d moved to %d,%d",
+                    event->window.windowID, event->window.data1,
+                    event->window.data2);
+            break;
+        case SDL_WINDOWEVENT_RESIZED:
+            SDL_Log("Window %d resized to %dx%d",
+                    event->window.windowID, event->window.data1,
+                    event->window.data2);
+            break;
+        case SDL_WINDOWEVENT_SIZE_CHANGED:
+            SDL_Log("Window %d size changed to %dx%d",
+                    event->window.windowID, event->window.data1,
+                    event->window.data2);
+            break;
+        case SDL_WINDOWEVENT_MINIMIZED:
+            SDL_Log("Window %d minimized", event->window.windowID);
+            break;
+        case SDL_WINDOWEVENT_MAXIMIZED:
+            SDL_Log("Window %d maximized", event->window.windowID);
+            break;
+        case SDL_WINDOWEVENT_RESTORED:
+            SDL_Log("Window %d restored", event->window.windowID);
+            break;
+        case SDL_WINDOWEVENT_ENTER:
+            SDL_Log("Mouse entered window %d",
+                    event->window.windowID);
+            break;
+        case SDL_WINDOWEVENT_LEAVE:
+            SDL_Log("Mouse left window %d", event->window.windowID);
+            break;
+        case SDL_WINDOWEVENT_FOCUS_GAINED:
+            SDL_Log("Window %d gained keyboard focus",
+                    event->window.windowID);
+            break;
+        case SDL_WINDOWEVENT_FOCUS_LOST:
+            SDL_Log("Window %d lost keyboard focus",
+                    event->window.windowID);
+            break;
+        case SDL_WINDOWEVENT_CLOSE:
+            SDL_Log("Window %d closed", event->window.windowID);
+            break;
+#if SDL_VERSION_ATLEAST(2, 0, 5)
+        case SDL_WINDOWEVENT_TAKE_FOCUS:
+            SDL_Log("Window %d is offered a focus", event->window.windowID);
+            break;
+        case SDL_WINDOWEVENT_HIT_TEST:
+            SDL_Log("Window %d has a special hit test", event->window.windowID);
+            break;
+#endif
+        default:
+            SDL_Log("Window %d got unknown event %d",
+                    event->window.windowID, event->window.event);
+            break;
+        }
+    }
+}
+
+bool init() {
+  bool success = true;
+  //Initialize SDL
+  if( SDL_Init( SDL_INIT_VIDEO ) < 0 ) {
+      printf( "SDL could not initialize! SDL_Error: %s\n", SDL_GetError() );
+      success = false;
+  } else {
+      //Create window
+      gWindow = SDL_CreateWindow( GAME_NAME, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN );
+      if( gWindow == NULL ) {
+            printf( "Window could not be created! SDL_Error: %s\n", SDL_GetError() );
+            success = false;
+        } else {
+            //Get window surface
+            gScreenSurface = SDL_GetWindowSurface( gWindow );
+            if( gScreenSurface == NULL )
+            {
+                printf( "ScreenSurface could not be fetched! SDL Error: %s\n", SDL_GetError() );
+                success = false;
+            }
+            //Create renderer for window
+            gRenderer = SDL_CreateRenderer( gWindow, -1, SDL_RENDERER_ACCELERATED );
+            if( gRenderer == NULL )
+            {
+                printf( "Renderer could not be created! SDL Error: %s\n", SDL_GetError() );
+                success = false;
+            }
+        }
+    }
+
+    darkRP2D = new DarkRP2D();
+    darkRP2D->create(gRenderer);
+
+    return success;
+}
+
+void close() {
+  darkRP2D->dispose();
+  delete darkRP2D;
+  SDL_DestroyRenderer( gRenderer );
+  SDL_FreeSurface( gScreenSurface );
+  SDL_DestroyWindow( gWindow );
+  SDL_Quit();
+}
 
 int main(int argc, char *argv[]) {
-    SDL_Init( SDL_INIT_EVERYTHING );
+  //Initialization flag
+  bool success = true;
 
-    DarkRP2D* darkRP2D = new DarkRP2D();
+    success = init();
 
-    SDL_Quit( );
-    return EXIT_SUCCESS;
+    SDL_SetWindowResizable(gWindow, SDL_TRUE);
+
+    //Main loop flag
+    bool running = true;
+    //Event handler
+    SDL_Event e;
+    //Main GameClass
+
+    unsigned int lastTime = SDL_GetTicks(), currentTime, elapsedTime;
+    //While application is running
+    while( running ) {
+      currentTime = SDL_GetTicks();
+      elapsedTime = currentTime - lastTime;
+      //Handle events on queue
+      while( SDL_PollEvent( &e ) != 0 ) {
+        //User requests quit
+        if( e.type == SDL_QUIT ) {
+              running = false;
+        }
+        PrintEvent(&e);
+      }
+        darkRP2D->loop(elapsedTime);
+        lastTime = currentTime;
+    }
+
+    close();
+
+    return success;
 }

src/test/test.cpp

@@ -1,3 +0,0 @@
-void hello() {
-
-}

src/utility/utility.h

@@ -0,0 +1,12 @@
+#ifndef UTILITY_H
+#define UTILITY_H
+
+#include <string>
+#include <SDL2/SDL.h>
+#include <SDL2/SDL_image.h>
+
+namespace utility {
+  SDL_Texture* loadTexture( std::string path, SDL_Renderer* gRenderer );
+}
+
+#endif // UTILITY_H

src/utility/utitlity.cpp

@@ -0,0 +1,26 @@
+#include "utility.h"
+
+namespace utility {
+
+    SDL_Texture* loadTexture( std::string path, SDL_Renderer* gRenderer ) {
+      //The final texture
+      SDL_Texture* newTexture = NULL;
+
+      //Load image at specified path
+      SDL_Surface* loadedSurface = IMG_Load( path.c_str() );
+      if( loadedSurface == NULL ) {
+          printf( "Unable to load image %s! SDL_image Error: %s\n", path.c_str(), IMG_GetError() );
+      }
+      else {
+          //Create texture from surface pixels
+          newTexture = SDL_CreateTextureFromSurface( gRenderer, loadedSurface );
+          if( newTexture == NULL ) {
+            printf( "Unable to create texture from %s! SDL Error: %s\n", path.c_str(), SDL_GetError() );
+          }
+          //Get rid of old loaded surface
+              SDL_FreeSurface( loadedSurface );
+      }
+      return newTexture;
+    }
+
+}