init project
authorwatkinsr <ryanwatkins54@gmail.com>
Thu, 18 Jun 2020 08:39:16 +0000 (09:39 +0100)
committerwatkinsr <ryanwatkins54@gmail.com>
Thu, 18 Jun 2020 08:39:16 +0000 (09:39 +0100)
31_scrolling_backgrounds.cpp [new file with mode: 0755]
Makefile [new file with mode: 0644]
bg.png [new file with mode: 0755]
dot.bmp [new file with mode: 0755]

diff --git a/31_scrolling_backgrounds.cpp b/31_scrolling_backgrounds.cpp
new file mode 100755 (executable)
index 0000000..7d805a4
--- /dev/null
@@ -0,0 +1,503 @@
+/*This source code copyrighted by Lazy Foo' Productions (2004-2020)
+and may not be redistributed without written permission.*/
+
+//Using SDL, SDL_image, standard IO, vectors, and strings
+#include <SDL2/SDL.h>
+#include <SDL2/SDL_image.h>
+#include <stdio.h>
+#include <string>
+
+//Screen dimension constants
+const int SCREEN_WIDTH = 640;
+const int SCREEN_HEIGHT = 480;
+
+//Texture wrapper class
+class LTexture
+{
+       public:
+               //Initializes variables
+               LTexture();
+
+               //Deallocates memory
+               ~LTexture();
+
+               //Loads image at specified path
+               bool loadFromFile( std::string path );
+               
+               #if defined(_SDL_TTF_H) || defined(SDL_TTF_H)
+               //Creates image from font string
+               bool loadFromRenderedText( std::string textureText, SDL_Color textColor );
+               #endif
+
+               //Deallocates texture
+               void free();
+
+               //Set color modulation
+               void setColor( Uint8 red, Uint8 green, Uint8 blue );
+
+               //Set blending
+               void setBlendMode( SDL_BlendMode blending );
+
+               //Set alpha modulation
+               void setAlpha( Uint8 alpha );
+               
+               //Renders texture at given point
+               void render( int x, int y, SDL_Rect* clip = NULL, double angle = 0.0, SDL_Point* center = NULL, SDL_RendererFlip flip = SDL_FLIP_NONE );
+
+               //Gets image dimensions
+               int getWidth();
+               int getHeight();
+
+       private:
+               //The actual hardware texture
+               SDL_Texture* mTexture;
+
+               //Image dimensions
+               int mWidth;
+               int mHeight;
+};
+
+//The dot that will move around on the screen
+class Dot
+{
+    public:
+
+               //Maximum axis velocity of the dot
+               static const int DOT_VEL = 10;
+
+               //Initializes the variables
+               Dot();
+
+               //Takes key presses and adjusts the dot's velocity
+               void handleEvent( SDL_Event& e );
+
+               //Moves the dot
+               void move();
+
+               // Change dimensions
+         void setDimensions(Uint8 w, Uint8 h);
+
+               //Shows the dot on the screen
+               void render();
+
+    private:
+               //The X and Y offsets of the dot
+               int mPosX, mPosY;
+
+               //The velocity of the dot
+               int mVelX, mVelY;
+               //The dimensions of the dot
+               
+         int mWidth;
+         int mHeight;
+};
+
+//Starts up SDL and creates window
+bool init();
+
+//Loads media
+bool loadMedia();
+
+//Frees media and shuts down SDL
+void close();
+
+//The window we'll be rendering to
+SDL_Window* gWindow = NULL;
+
+//The window renderer
+SDL_Renderer* gRenderer = NULL;
+
+//Scene textures
+LTexture gDotTexture;
+LTexture gBGTexture;
+
+LTexture::LTexture()
+{
+       //Initialize
+       mTexture = NULL;
+       mWidth = 0;
+       mHeight = 0;
+}
+
+LTexture::~LTexture()
+{
+       //Deallocate
+       free();
+}
+
+bool LTexture::loadFromFile( std::string path )
+{
+       //Get rid of preexisting texture
+       free();
+
+       //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
+       {
+               //Color key image
+               SDL_SetColorKey( loadedSurface, SDL_TRUE, SDL_MapRGB( loadedSurface->format, 0, 0xFF, 0xFF ) );
+
+               //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() );
+               }
+               else
+               {
+                       //Get image dimensions
+                       mWidth = loadedSurface->w;
+                       mHeight = loadedSurface->h;
+               }
+
+               //Get rid of old loaded surface
+               SDL_FreeSurface( loadedSurface );
+       }
+
+       //Return success
+       mTexture = newTexture;
+       return mTexture != NULL;
+}
+
+#if defined(_SDL_TTF_H) || defined(SDL_TTF_H)
+bool LTexture::loadFromRenderedText( std::string textureText, SDL_Color textColor )
+{
+       //Get rid of preexisting texture
+       free();
+
+       //Render text surface
+       SDL_Surface* textSurface = TTF_RenderText_Solid( gFont, textureText.c_str(), textColor );
+       if( textSurface != NULL )
+       {
+               //Create texture from surface pixels
+        mTexture = SDL_CreateTextureFromSurface( gRenderer, textSurface );
+               if( mTexture == NULL )
+               {
+                       printf( "Unable to create texture from rendered text! SDL Error: %s\n", SDL_GetError() );
+               }
+               else
+               {
+                       //Get image dimensions
+                       mWidth = textSurface->w;
+                       mHeight = textSurface->h;
+               }
+
+               //Get rid of old surface
+               SDL_FreeSurface( textSurface );
+       }
+       else
+       {
+               printf( "Unable to render text surface! SDL_ttf Error: %s\n", TTF_GetError() );
+       }
+
+       
+       //Return success
+       return mTexture != NULL;
+}
+#endif
+
+void LTexture::free()
+{
+       //Free texture if it exists
+       if( mTexture != NULL )
+       {
+               SDL_DestroyTexture( mTexture );
+               mTexture = NULL;
+               mWidth = 0;
+               mHeight = 0;
+       }
+}
+
+void LTexture::setColor( Uint8 red, Uint8 green, Uint8 blue )
+{
+       //Modulate texture rgb
+       SDL_SetTextureColorMod( mTexture, red, green, blue );
+}
+
+void LTexture::setBlendMode( SDL_BlendMode blending )
+{
+       //Set blending function
+       SDL_SetTextureBlendMode( mTexture, blending );
+}
+               
+void LTexture::setAlpha( Uint8 alpha )
+{
+       //Modulate texture alpha
+       SDL_SetTextureAlphaMod( mTexture, alpha );
+}
+
+void LTexture::render( int x, int y, SDL_Rect* clip, double angle, SDL_Point* center, SDL_RendererFlip flip )
+{
+       //Set rendering space and render to screen
+       SDL_Rect renderQuad = { x, y, mWidth, mHeight };
+
+       //Set clip rendering dimensions
+       if( clip != NULL )
+       {
+               renderQuad.w = clip->w;
+               renderQuad.h = clip->h;
+       }
+
+       //Render to screen
+       SDL_RenderCopyEx( gRenderer, mTexture, clip, &renderQuad, angle, center, flip );
+}
+
+int LTexture::getWidth()
+{
+       return mWidth;
+}
+
+int LTexture::getHeight()
+{
+       return mHeight;
+}
+
+Dot::Dot()
+{
+    //Initialize the offsets
+    mPosX = 0;
+    mPosY = 0;
+
+    //Initialize the velocity
+    mVelX = 0;
+    mVelY = 0;
+
+    mWidth = 10;
+    mHeight = 10;
+}
+
+void Dot::setDimensions(Uint8 w, Uint8 h)
+{
+  mWidth = w;
+  mHeight = h;
+}
+
+void Dot::handleEvent( SDL_Event& e )
+{
+    //If a key was pressed
+       if( e.type == SDL_KEYDOWN && e.key.repeat == 0 )
+    {
+        //Adjust the velocity
+        switch( e.key.keysym.sym )
+        {
+            case SDLK_UP: mVelY -= DOT_VEL; break;
+            case SDLK_DOWN: mVelY += DOT_VEL; break;
+            // case SDLK_LEFT: mVelX -= DOT_VEL; break;
+            // case SDLK_RIGHT: mVelX += DOT_VEL; break;
+        }
+    }
+    //If a key was released
+    else if( e.type == SDL_KEYUP && e.key.repeat == 0 )
+    {
+        //Adjust the velocity
+        switch( e.key.keysym.sym )
+        {
+            case SDLK_UP: mVelY += DOT_VEL; break;
+            case SDLK_DOWN: mVelY -= DOT_VEL; break;
+            // case SDLK_LEFT: mVelX += DOT_VEL; break;
+            // case SDLK_RIGHT: mVelX -= DOT_VEL; break;
+        }
+    }
+}
+
+void Dot::move()
+{
+    //Move the dot up or down
+    mPosY += mVelY;
+
+    //If the dot went too far up or down
+    if( ( mPosY < 0 ) || ( mPosY + mHeight > SCREEN_HEIGHT ) )
+    {
+        //Move back
+        mPosY -= mVelY;
+    }
+}
+
+void Dot::render()
+{
+    //Show the dot
+       gDotTexture.render( mPosX, mPosY );
+}
+
+bool init()
+{
+       //Initialization flag
+       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
+       {
+               //Set texture filtering to linear
+               if( !SDL_SetHint( SDL_HINT_RENDER_SCALE_QUALITY, "1" ) )
+               {
+                       printf( "Warning: Linear texture filtering not enabled!" );
+               }
+
+               //Create window
+               gWindow = SDL_CreateWindow( "SDL Tutorial", 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
+               {
+                       //Create vsynced renderer for window
+                       gRenderer = SDL_CreateRenderer( gWindow, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC );
+                       if( gRenderer == NULL )
+                       {
+                               printf( "Renderer could not be created! SDL Error: %s\n", SDL_GetError() );
+                               success = false;
+                       }
+                       else
+                       {
+                               //Initialize renderer color
+                               SDL_SetRenderDrawColor( gRenderer, 0xFF, 0xFF, 0xFF, 0xFF );
+                               //Initialize PNG loading
+                               int imgFlags = IMG_INIT_PNG;
+                               if( !( IMG_Init( imgFlags ) & imgFlags ) )
+                               {
+                                       printf( "SDL_image could not initialize! SDL_image Error: %s\n", IMG_GetError() );
+                                       success = false;
+                               }
+                       }
+               }
+       }
+
+       return success;
+}
+
+bool loadMedia()
+{
+       //Loading success flag
+       bool success = true;
+
+       //Load dot texture
+       if( !gDotTexture.loadFromFile( "dot.bmp" ) )
+       {
+               printf( "Failed to load dot texture!\n" );
+               success = false;
+       }
+
+       //Load background texture
+       if( !gBGTexture.loadFromFile( "bg.png" ) )
+       {
+               printf( "Failed to load background texture!\n" );
+               success = false;
+       }
+
+       return success;
+}
+
+void close()
+{
+       //Free loaded images
+       gDotTexture.free();
+       gBGTexture.free();
+
+       //Destroy window        
+       SDL_DestroyRenderer( gRenderer );
+       SDL_DestroyWindow( gWindow );
+       gWindow = NULL;
+       gRenderer = NULL;
+
+       //Quit SDL subsystems
+       IMG_Quit();
+       SDL_Quit();
+}
+
+int main( int argc, char* args[] )
+{
+       //Start up SDL and create window
+       if( !init() )
+       {
+               printf( "Failed to initialize!\n" );
+       }
+       else
+       {
+               //Load media
+               if( !loadMedia() )
+               {
+                       printf( "Failed to load media!\n" );
+               }
+               else
+               {       
+                       //Main loop flag
+                       bool quit = false;
+
+                       //Event handler
+                       SDL_Event e;
+
+                       //The dot that will be moving around on the screen
+                       Dot dot;
+
+                       Dot movingDot;
+                       movingDot.setDimensions(3, 3);
+
+                       //The background scrolling offset
+                       int scrollingOffset = 0;
+
+                       //While application is running
+                       while( !quit )
+                       {
+                               //Handle events on queue
+                               while( SDL_PollEvent( &e ) != 0 )
+                               {
+                                       //User requests quit
+                                       if( e.type == SDL_QUIT )
+                                       {
+                                               quit = true;
+                                       }
+
+                                       //Handle input for the dot
+                                       dot.handleEvent( e );
+                               }
+
+                               //Move the dot
+                               dot.move();
+
+                               //Scroll background
+                               --scrollingOffset;
+                               if( scrollingOffset < -gBGTexture.getWidth() )
+                               {
+                                       scrollingOffset = 0;
+                               }
+
+                               //Clear screen
+                               SDL_SetRenderDrawColor( gRenderer, 0xFF, 0xFF, 0xFF, 0xFF );
+                               SDL_RenderClear( gRenderer );
+
+                               //Render background
+                               gBGTexture.render( scrollingOffset, 0 );
+                               gBGTexture.render( scrollingOffset + gBGTexture.getWidth(), 0 );
+
+                               //Render middle line
+                               //SDL_SetRenderDrawColor( gRenderer, 0xFF, 0xFF, 0xFF, 0xFF );
+                               SDL_RenderDrawLine(gRenderer, SCREEN_WIDTH/2, 0, SCREEN_WIDTH/2, SCREEN_HEIGHT);
+
+                               //Render objects
+                               dot.render();
+
+                               //Update screen
+                               SDL_RenderPresent( gRenderer );
+                       }
+               }
+       }
+
+       //Free resources and close SDL
+       close();
+
+       return 0;
+}
diff --git a/Makefile b/Makefile
new file mode 100644 (file)
index 0000000..30b025c
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,19 @@
+#OBJS specifies which files to compile as part of the project
+OBJS = *.cpp
+
+#CC specifies which compiler we're using
+CC = g++
+
+#COMPILER_FLAGS specifies the additional compilation options we're using
+# -w suppresses all warnings
+COMPILER_FLAGS = -w
+
+#LINKER_FLAGS specifies the libraries we're linking against
+LINKER_FLAGS = -lSDL2 -lSDL2_image
+
+#OBJ_NAME specifies the name of our exectuable
+OBJ_NAME = out
+
+#This is the target that compiles our executable
+all : $(OBJS)
+       $(CC) $(OBJS) $(COMPILER_FLAGS) $(LINKER_FLAGS) -o $(OBJ_NAME)
diff --git a/bg.png b/bg.png
new file mode 100755 (executable)
index 0000000..f89f058
Binary files /dev/null and b/bg.png differ
diff --git a/dot.bmp b/dot.bmp
new file mode 100755 (executable)
index 0000000..16ed38d
Binary files /dev/null and b/dot.bmp differ