Example #1
0
void Image::reload(SDL_Surface *surface) {
	m_filename = "";

	if(m_texture) SDL_DestroyTexture(m_texture);

	m_width = surface->w;
	m_height = surface->h;

	m_texture = SDL_CreateTextureFromSurface(GameWindow::main->renderer(), surface);
	SDL_SetTextureBlendMode(m_texture, SDL_BLENDMODE_BLEND);
	SDL_FreeSurface(surface);

	m_clipRect.x = 0;
	m_clipRect.y = 0;
	m_clipRect.w = m_width;
	m_clipRect.h = m_height;

	m_posRect.x = 0;
	m_posRect.y = 0;
	m_posRect.w = m_width;
	m_posRect.h = m_height;

	m_hidden = false;
}
Example #2
0
Planet::Planet(std::string name):
	Object(),
	Drawable(),
	Touchable(),
	weaponAim_(0, 0)
{

	type_ = Assets::instance().info("Planet", name);

	b2BodyDef temp;
	temp.position = b2Vec2(0.0, 0.0);
	temp.type = b2_staticBody;
	CreateBody(temp, type_.def);

	laser_ = new Laser(GetBody());

	SDL_Log("Planet m=%f", GetMass());

	SDL_Surface* surface = Screen::CreateSurface(1, 1, 32);
	Uint32 color = SDL_MapRGBA(surface->format, 255, 90, 255, 250);
	SDL_FillRect(surface, NULL, color);

	texture_ = SDL_CreateTextureFromSurface(Screen::instance().renderer(), surface);
}
Example #3
0
void Image::reload(const char *filename) {
	m_filename = filename;

	if(m_texture) SDL_DestroyTexture(m_texture);

	SDL_RWops *image = SDL_RWFromFile(filename, "rb");
	SDL_Surface *surface = IMG_Load_RW(image, 1);

	if(!surface) {
		error("Failed to load image \"%s\": %s\n", filename, IMG_GetError());
		exit(EXIT_FAILURE);
	}

	m_width = surface->w;
	m_height = surface->h;

	m_texture = SDL_CreateTextureFromSurface(GameWindow::main->renderer(), surface);
	if(!m_texture) {
		error("Failed to create texture from image: %s", SDL_GetError());
		exit(EXIT_FAILURE);
	}
	SDL_SetTextureBlendMode(m_texture, SDL_BLENDMODE_BLEND);
	SDL_FreeSurface(surface);

	m_clipRect.x = 0;
	m_clipRect.y = 0;
	m_clipRect.w = m_width;
	m_clipRect.h = m_height;

	m_posRect.x = 0;
	m_posRect.y = 0;
	m_posRect.w = m_width;
	m_posRect.h = m_height;

	m_hidden = false;
}
int draw_msg(SDL_Surface *screen, int x, int y, const char *msg)
{
	//SDL_Color bg={0x19,0x19,0x19,0x40};
	SDL_Color bg={0,0,0,0};
	SDL_Color fg={238,238,230,0x40};

        //defaultTextColor.setAllColors(238, 238, 230, 0x40);
        //colorDefaultWidgetBackground.setAllColors(0x19, 0x19, 0x19, 0x40);
	//SDL_Color bg={0,0,0,0};
	//SDL_Color fg={255,255,255,255};

	SDL_Surface *surf= TTF_RenderText_Shaded(font,msg,fg, bg);

        SDL_TextureID text = SDL_CreateTextureFromSurface(0, surf);

        //Central alignment for subtitle
        //x=(int) ((320.0*fs_screen_width/640.0) -(surf->w/2.0));

        SDL_Rect rect = {x, y, surf->w, surf->h };
        SDL_RenderCopy(text, NULL, &rect);

        SDL_FreeSurface(surf);
        SDL_DestroyTexture(text);
}
Example #5
0
/* Set the Text */
SDL_Texture* Font::RenderText(const std::string &message, SDL_Color color,
                              int fontSize, SDL_Renderer *renderer)
{
	font = TTF_OpenFont(this->fontPath.c_str(), fontSize);
	if (!font){
		logging(TTF_GetError());
		return NULL;
	}
	surf = TTF_RenderText_Blended(font, message.c_str(), color);
	if (!surf){
		logging(TTF_GetError());
		return NULL;
	}
	SDL_Texture *texture = SDL_CreateTextureFromSurface(renderer, surf);
	if (!texture){
		logging(TTF_GetError());
		return NULL;
	}

	TTF_CloseFont(font);
	font = NULL;
	SDL_FreeSurface(surf);
	return texture;
}
Example #6
0
void cGame::mWorldMapLoad(string path){
	if (!mIsLoaded()){
		if (!loadMedia(path.c_str())){
			printf("Failed to load media!\n");
		}
		else{
			mSetLoaded(true);
			//Set up player quad
			player1.mPlayerQuad.x = player1.getPlayerX();
			player1.mPlayerQuad.y = player1.getPlayerY();
			player1.mPlayerQuad.w = player1.getPlayerWidth();
			player1.mPlayerQuad.h = player1.getPlayerHeight();

			player1.mPlayerSurface = IMG_Load("Images/Character/hero_jimmy.png");
			player1.mPlayerTexture = SDL_CreateTextureFromSurface(mRenderer, player1.mPlayerSurface);

			player1.mPlayerSteps = 0;
			mRandomEncounter = rand() % 500;
			if (mRandomEncounter < 30)
				mRandomEncounter = rand() % 500;
		}
			mWorldMapUpdate();
	}
}
Example #7
0
bool ResourceFontTexture::LoadResource(const std::string& text, ResourceFont font, SDL_Renderer * renderer, Color color)
{
	if (initialized)
	{
		DEBUG_LOG("Trying to load resource in already initialized instantion.");
		return false;
	}
	SDL_Surface * surface = TTF_RenderText_Solid(font.getFont(), text.c_str(), {color.r,color.g,color.b,color.a});
	if (surface == nullptr)
	{
		DEBUG_LOG("Error loading surface from font.");
		return false;
	}

	texture.reset(SDL_CreateTextureFromSurface(renderer, surface), SDL_DestroyTexture);
	SDL_FreeSurface(surface);
	if (texture == nullptr)
	{
		DEBUG_LOG("Failed to create texture from surface");
		return false;
	}
	initialized = true;
	return true;
}
Example #8
0
Renderer::Renderer()
{
	assertf(SDL_Init(SDL_INIT_VIDEO) >= 0,
			"Failed to initialize SDL: %s", SDL_GetError());

	_window = SDL_CreateWindow("Water Simulator",
			SDL_WINDOWPOS_CENTERED,
			SDL_WINDOWPOS_CENTERED,
			800, 600,
			0);
	assertf(_window != NULL, "Failed to create window: %s", SDL_GetError());

	_renderer = SDL_CreateRenderer(_window, -1, 0);
	assertf(_renderer != NULL, "Failed to create renderer: %s", SDL_GetError());

	SDL_SetRenderDrawColor(_renderer, 20, 20, 20, 255);
	SDL_RenderClear(_renderer);

	SDL_Surface *squareSurf = SDL_LoadBMP("square.bmp");
	assertf(squareSurf != NULL,
			"Failed to load image \"square.bmp\": %s", SDL_GetError());
	_square = SDL_CreateTextureFromSurface(_renderer, squareSurf);
	SDL_FreeSurface(squareSurf);
}
Example #9
0
// ouvrir un fichier png et le placer dans une texture
SDL_Texture *SDLS_loadImage( char *name)
{
    SDL_Surface *loadedImage = NULL;
    SDL_Texture *texture = NULL;

// Charge les images avec SDL Image dans une SDL_Surface
// pour PNG
    loadedImage = IMG_Load(name);
// pour BMP
// SDL_Surface * image = SDL_LoadBMP(name);
    //Color key image, le fond blanc est enlevé... Pas besoin de détourrer l'image
	SDL_SetColorKey( loadedImage, SDL_TRUE, SDL_MapRGB( loadedImage->format, 0xFF, 0xFF, 0xFF ) );
    if (loadedImage != NULL)
    {
// Conversion de l'image en texture
        texture = SDL_CreateTextureFromSurface(gRenderer, loadedImage);
// On se débarrasse du pointeur vers une surface
        SDL_FreeSurface(loadedImage);
        loadedImage = NULL;
    }
    else
        printf("L'image n'a pas pu être chargée! SDL_Error : %s\n", SDL_GetError());
    return texture;
}
Example #10
0
bool RenderManagerSDL::setBackground(const std::string& filename)
{
    try
    {
        SDL_Surface *tempBackgroundSurface = loadSurface(filename);
        SDL_Texture *tempBackgroundTexture = SDL_CreateTextureFromSurface(mRenderer, tempBackgroundSurface);
        BufferedImage* oldBackground = mImageMap["background"];
        SDL_DestroyTexture(oldBackground->sdlImage);
        delete oldBackground;

        BufferedImage* newImage = new BufferedImage;
        newImage->w = tempBackgroundSurface->w;
        newImage->h = tempBackgroundSurface->h;
        newImage->sdlImage = tempBackgroundTexture;
        SDL_FreeSurface(tempBackgroundSurface);
        mBackground = newImage->sdlImage;
        mImageMap["background"] = newImage;
    }
    catch (FileLoadException)
    {
        return false;
    }
    return true;
}
Example #11
0
bool Texture::loadFromFile(std::string path, SDL_Renderer* mR) {
	//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(mR, 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;
}
Example #12
0
void Images::Load(int i_id, string i_path, int i_x, int i_y, int i_mtime, int i_a, int i_atime)
{
	//detect that if it exist an images,unload it
	for (auto it = m_imgs.begin(); it != m_imgs.end(); ++it)
	if (it->id == i_id)
		Unload(i_id);
	//create a new texture struct and add it to the vector
	Image newImg;
	if (m_files->ReadRW(i_path, &(newImg.rw), newImg.index)){
		if (!(newImg.sur = IMG_Load_RW(newImg.rw, AUTOFREE))){
			SekaiAlert("cannot analyse the picture file from " + i_path);
			return;
		}
		newImg.tex = SDL_CreateTextureFromSurface(m_ren, newImg.sur);
        SDL_FreeSurface(newImg.sur);
		newImg.id = i_id;
		SDL_QueryTexture(newImg.tex, NULL, NULL, &(newImg.rect.w), &newImg.rect.h);
		newImg.rect.x = i_x;
		newImg.rect.y = i_y;
		newImg.a = i_a;
		newImg.path = i_path;
		m_imgs.push_back(newImg);
	}
}
Example #13
0
void maj_panneau(SDL_Renderer* ren, int nb_fleche[]){

    SDL_Texture *texture_directions = NULL;
    SDL_Surface *Directions = IMG_Load("IMG/Directions.png");
    texture_directions = SDL_CreateTextureFromSurface(ren,Directions);
    SDL_FreeSurface(Directions);
    SDL_Rect dst_directions;
    dst_directions.x = 730;
    dst_directions.y = 80;
    SDL_QueryTexture(texture_directions, NULL, NULL, &dst_directions.w, &dst_directions.h);
    SDL_RenderCopy(ren, texture_directions, NULL, &dst_directions);
    SDL_DestroyTexture(texture_directions);

    affichage_nb(ren,768,210,nb_fleche[0]);//d1
    affichage_nb(ren,818,210,nb_fleche[1]);//d2
    affichage_nb(ren,868,210,nb_fleche[2]);//d3
    affichage_nb(ren,768,160,nb_fleche[3]);//d4
    affichage_nb(ren,868,160,nb_fleche[5]);//d6
    affichage_nb(ren,768,110,nb_fleche[6]);//d7
    affichage_nb(ren,818,110,nb_fleche[7]);//d8
    affichage_nb(ren,868,110,nb_fleche[8]);//d9
    
    SDL_RenderPresent(ren);
}
Example #14
0
bool Player::LoadTexture(std::string textureFile) {
    m_surface = SDL_LoadBMP(textureFile.c_str());
    if (!m_surface)
    {
        return false;
    }

    m_texture = SDL_CreateTextureFromSurface(m_sdlRenderer, m_surface);

    // centre the player on screen
    SDL_Rect displayRect;

    SDL_GetDisplayBounds(0, &displayRect);

    m_xPos = displayRect.w / 2;
    m_yPos = displayRect.h / 2;

    UpdateTexturePos();

    m_textureRect.w = m_surface->w;
    m_textureRect.h = m_surface->h;

    return true;
}
Example #15
0
bool Texture::Load(const std::string &Path, SDL_Renderer *const Renderer)
{
	Free();

	SDL_Texture *New=NULL;
	SDL_Surface *Surface=NULL;
	// Load the surface
	Surface=IMG_Load(Path.c_str());
	if(Surface==NULL)
	{
		Print("Failed to load file \""+Path+"\".");
		return false;
	}

	// Create texture
	New=SDL_CreateTextureFromSurface(Renderer, Surface);
	if(New==NULL)
	{
		SDL_FreeSurface(Surface);
		Print("Failed to create texture from Surface from file \""+Path+"\".");
		return false;
	}

	// Store the texture dimensions
	Width=Surface->w;
	Height=Surface->h;

	// Free up the memory
	SDL_FreeSurface(Surface);

	// Store the fully loaded texture
	Image=New;

	Print("Loaded image from \""+Path+"\".");
	return true;
}
SDL_Texture* MySDL2::loadTexture(string path)
{
	SDL_Texture* newTexture = NULL;

	SDL_Surface* loadedSurface = IMG_Load(path.c_str());

	if (loadedSurface == NULL)
	{
		cout << "Unable to load image, SDL Error: " << path.c_str() << ", " << SDL_GetError();
	}
	else
	{
		newTexture = SDL_CreateTextureFromSurface(gRenderer, loadedSurface);

		if (newTexture == NULL)
		{
			cout << "Unable to optimize image SDL Error: " << path.c_str() << ", " << SDL_GetError();
		}

		SDL_FreeSurface(loadedSurface);
	}

	return newTexture;
}
Example #17
0
//Initialization
void Bola::Init(SDL_Renderer *renderer){
    rect.h = BOLA_SIZE;
    rect.w = BOLA_SIZE;
    rect.y = WIN_HEIGHT/2;
    rect.x = WIN_WIDTH/2;
	//Iniciar con un angulo random, pero que nunca sea completamente horizontal o vertical
	int type = rand() % 4;
	switch (type)
	{
	case 0:	//15-75
		angle = rand() % 60 + 15;
		break;
	case 1: //105-165
		angle = rand() % 60 + 105;
		break;
	case 2: //195-255
		angle = rand() % 60 + 195;
		break;
	case 3://285-345
		angle = rand() % 60 + 285;
		break;
	}
    SDL_Surface *surf = IMG_Load("assets/pelota.png");
    imagen = SDL_CreateTextureFromSurface(renderer, surf);

	dx = dy = 0.0f;
	speed = 0.4f;
	rebotandoY = rebotandoX =  false;

	speedX = (float)cos(angle*M_PI / 180.0f) * speed;
	speedY = (float)sin(angle*M_PI / 180.0f) * speed;

	MAX_speed = speed *2;

	InitMedia();
}
Example #18
0
/* this function loads our font into an SDL_Texture and returns the SDL_Texture  */
SDL_Texture*
loadFont(void)
{

    SDL_Surface *surface = SDL_LoadBMP("kromasky_16x16.bmp");

    if (!surface) {
        printf("Error loading bitmap: %s\n", SDL_GetError());
        return 0;
    } else {
        /* set the transparent color for the bitmap font (hot pink) */
        SDL_SetColorKey(surface, 1, SDL_MapRGB(surface->format, 238, 0, 252));
        /* now we convert the surface to our desired pixel format */
        int format = SDL_PIXELFORMAT_ABGR8888;  /* desired texture format */
        Uint32 Rmask, Gmask, Bmask, Amask;      /* masks for desired format */
        int bpp;                /* bits per pixel for desired format */
        SDL_PixelFormatEnumToMasks(format, &bpp, &Rmask, &Gmask, &Bmask,
                                   &Amask);
        SDL_Surface *converted =
            SDL_CreateRGBSurface(0, surface->w, surface->h, bpp, Rmask, Gmask,
                                 Bmask, Amask);
        SDL_BlitSurface(surface, NULL, converted, NULL);
        /* create our texture */
        texture =
            SDL_CreateTextureFromSurface(renderer, converted);
        if (texture == 0) {
            printf("texture creation failed: %s\n", SDL_GetError());
        } else {
            /* set blend mode for our texture */
            SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND);
        }
        SDL_FreeSurface(surface);
        SDL_FreeSurface(converted);
        return texture;
    }
}
Example #19
0
SDL_Texture * Painter::textToTexture(std::string text) {
	SDL_Surface *surface = getFont()->toSurface(text, getPen());
	return SDL_CreateTextureFromSurface(renderer, surface);
}
Example #20
0
void Painter::paintSurface(SDL_Surface *surface, SDL_Rect r) {
	SDL_Texture *texture = SDL_CreateTextureFromSurface(renderer, surface);
	paintTexture(texture, r);
}
Example #21
0
int main(int, char**)
{


    // inicia SDL
     SDL_Init(SDL_INIT_VIDEO);
	if (SDL_Init(SDL_INIT_VIDEO) != 0){
		std::cerr << "SDL_Init Error: " << SDL_GetError() << std::endl;
		return 1;
	}

	// crea la ventana
    SDL_Window *win = SDL_CreateWindow("Gestor de eventos de teclado y raton", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 800, 600, SDL_WINDOW_SHOWN);
    if (win == nullptr){
        std::cerr << "SDL_CreateWindow Error: " << SDL_GetError() << std::endl;
        SDL_Quit();
        return 1;
    }

    // crea el "renderer"
    SDL_Renderer *ren = SDL_CreateRenderer(win, -1, 1);
    if (ren == nullptr){
        cleanup(win); // SDL_DestroyWindow(win);
        std::cerr << "SDL_CreateRenderer Error: " << SDL_GetError() << std::endl;
        SDL_Quit();
        return 1;
    }

    std::string imagePath1 = "panel3.bmp";


    SDL_Surface *panel = SDL_LoadBMP(imagePath1.c_str());

    //SDL_Surface *screen = SDL_CreateRGBSurface(0, 640, 480, 32, 0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000);
    SDL_Texture *texPanel = SDL_CreateTextureFromSurface(ren, panel);

    //SDL_Texture * tex = SDL_CreateTexture(ren, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STREAMING, 640, 480);

        // Select the color for drawing. It is set to red here.
        SDL_SetRenderDrawColor(ren, 0, 204, 255, 255);
        SDL_RenderClear(ren);

               //SDL_DrawLine(screen, 20, 10, 70, 90, 255, 0, 0, 255);
        SDL_SetRenderDrawColor(ren, 255, 0, 0, 255);

         SDL_RenderDrawLine(ren, 10, 10, 200, 200);

        // Up until now everything was drawn behind the scenes.
        // This will show the new, red contents of the window.

        SDL_RenderCopy(ren, texPanel, NULL, NULL);

        SDL_RenderPresent(ren);

	//Our event structure
	SDL_Event e;
	//For tracking if we want to quit
	bool quit = false;

	SDL_SetRenderDrawColor(ren, 255, 0, 0, 255);
    ///Variables
    int i=0;
    bool pinta=false;
    ///Variables END
	while (!quit){


		//Read any events that occurred, for now we'll just quit if any event occurs
		while (SDL_PollEvent(&e)){
			//If user closes the window
			if (e.type == SDL_QUIT){
				quit = true;
			}
			//If user presses any key
			if (e.type == SDL_KEYDOWN) {
                SDL_Keycode key = e.key.keysym.sym;
                std::cout << "Tecla pulsada: " << SDL_GetKeyName(key)
                          << std::endl;
                if (key == SDLK_ESCAPE){
                    quit = true;
                }
			}




			//If user clicks the mouse
			if (e.type == SDL_MOUSEBUTTONDOWN){
				std::cout << "Boton de raton pulsado en X = "
                          << e.button.x << "\tY = " << e.button.y << std::endl;
			               //SDL_DrawLine(screen, 20, 10, 70, 90, 255, 0, 0, 255);
            //APAÑAR EL BUCLE CON LOS 2 CLICKS DE RATON     <<<GUILLER>>>       APAÑADO ;)

            //BOTON DE CERRAR
            if ((e.button.x > 708 && e.button.x < 800) & (e.button.y > 0 && e.button.y < 55)){
                quit = true;
            }
            //BOTON CREAR LINEA
            if ((e.button.x > 708 && e.button.x < 800) & (e.button.y > 115 && e.button.y < 168)){
                if (pinta == false)
                    pinta=true;
                else
                    pinta=false;

            }
            if ((pinta == true) & (e.button.x > 12 && e.button.x < 692) & (e.button.y > 77 && e.button.y < 588)){

            int x1;
            int y1;
            int x2;
            int y2;

            if (i==0){
                std::cout <<" 1 ";
                x1 = e.button.x;
                y1 = e.button.y;
                }
                if (i==1){
                std::cout <<" 2 ";
                x2 = e.button.x;
                y2 = e.button.y;
                SDL_RenderDrawLine(ren, x1, y1, x2, y2);
                }
                i++;
                if (i==2)
                    i=0;
            }


       /*
        for(int i=0; i<2; i++){
         x1 = e.button.x;
         y1 = e.button.y;
        std::cout << "e1 = "<< e.button.x<< std::endl;
        if (x1!=0){
         x2 = e.button.x;
         y2 = e.button.y;
        std::cout << "e2 = "<< e.button.x << std::endl;
         i++;
            }
        }*/



         }

		}

        //Update the screen
        SDL_RenderPresent(ren);
        //Take a quick break after all that hard work
	}






    // limpia y termina
    cleanup(ren, win); // SDL_DestroyTexture(tex); SDL_DestroyRenderer(ren); SDL_DestroyWindow(win);
	std::cout << "Todo correcto. Bye!" << std::endl;
	SDL_Quit();

	return 0;
}
Example #22
0
File: ui.c Project: zbanks/radiance
void ui_init() {
    // Init SDL
    if(SDL_Init(SDL_INIT_VIDEO) < 0) FAIL("SDL could not initialize! SDL Error: %s\n", SDL_GetError());
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);

    ww = config.ui.window_width;
    wh = config.ui.window_height;

    window = SDL_CreateWindow("Radiance", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, ww, wh, SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN);
    if(window == NULL) FAIL("Window could not be created: %s\n", SDL_GetError());
    context = SDL_GL_CreateContext(window);
    if(context == NULL) FAIL("OpenGL context could not be created: %s\n", SDL_GetError());
    if(SDL_GL_SetSwapInterval(1) < 0) fprintf(stderr, "Warning: Unable to set VSync: %s\n", SDL_GetError());
    renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
    if(renderer == NULL) FAIL("Could not create renderer: %s\n", SDL_GetError());
    if(TTF_Init() < 0) FAIL("Could not initialize font library: %s\n", TTF_GetError());

    // Init OpenGL
    GLenum e;
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glMatrixMode(GL_MODELVIEW);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glClearColor(0, 0, 0, 0);
    if((e = glGetError()) != GL_NO_ERROR) FAIL("OpenGL error: %s\n", gluErrorString(e));

    // Make framebuffers
    glGenFramebuffersEXT(1, &select_fb);
    glGenFramebuffersEXT(1, &pat_fb);
    glGenFramebuffersEXT(1, &crossfader_fb);
    glGenFramebuffersEXT(1, &pat_entry_fb);
    glGenFramebuffersEXT(1, &spectrum_fb);
    glGenFramebuffersEXT(1, &waveform_fb);
    glGenFramebuffersEXT(1, &strip_fb);
    if((e = glGetError()) != GL_NO_ERROR) FAIL("OpenGL error: %s\n", gluErrorString(e));

    // Init select texture
    glGenTextures(1, &select_tex);
    glBindTexture(GL_TEXTURE_2D, select_tex);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, ww, wh, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
    glBindTexture(GL_TEXTURE_2D, 0);

    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, select_fb);
    glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, select_tex, 0);

    // Init pattern textures
    pattern_textures = calloc(config.ui.n_patterns, sizeof(GLuint));
    if(pattern_textures == NULL) MEMFAIL();
    pattern_name_textures = calloc(config.ui.n_patterns, sizeof(SDL_Texture *));
    pattern_name_width = calloc(config.ui.n_patterns, sizeof(int));
    pattern_name_height = calloc(config.ui.n_patterns, sizeof(int));
    if(pattern_name_textures == NULL || pattern_name_width == NULL || pattern_name_height == NULL) MEMFAIL();
    glGenTextures(config.ui.n_patterns, pattern_textures);
    if((e = glGetError()) != GL_NO_ERROR) FAIL("OpenGL error: %s\n", gluErrorString(e));
    for(int i = 0; i < config.ui.n_patterns; i++) {
        glBindTexture(GL_TEXTURE_2D, pattern_textures[i]);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, config.ui.pattern_width, config.ui.pattern_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
    }

    // Init crossfader texture
    glGenTextures(1, &crossfader_texture);
    glBindTexture(GL_TEXTURE_2D, crossfader_texture);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, config.ui.crossfader_width, config.ui.crossfader_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, crossfader_fb);
    glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, crossfader_texture, 0);

    // Init pattern entry texture
    glGenTextures(1, &pat_entry_texture);
    glBindTexture(GL_TEXTURE_2D, pat_entry_texture);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, config.ui.pat_entry_width, config.ui.pat_entry_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, pat_entry_fb);
    glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, pat_entry_texture, 0);

    // Spectrum data texture
    glGenTextures(1, &tex_spectrum_data);
    glBindTexture(GL_TEXTURE_1D, tex_spectrum_data);
    glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameterf(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameterf(GL_TEXTURE_1D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glTexImage1D(GL_TEXTURE_1D, 0, GL_R32F, config.audio.spectrum_bins, 0, GL_RED, GL_FLOAT, NULL);

    // Spectrum UI element
    glGenTextures(1, &spectrum_texture);
    glBindTexture(GL_TEXTURE_2D, spectrum_texture);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, config.ui.spectrum_width, config.ui.spectrum_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, spectrum_fb);
    glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, spectrum_texture, 0);

    // Waveform data texture
    glGenTextures(1, &tex_waveform_data);
    glBindTexture(GL_TEXTURE_1D, tex_waveform_data);
    glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameterf(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameterf(GL_TEXTURE_1D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glTexImage1D(GL_TEXTURE_1D, 0, GL_RGBA32F, config.audio.waveform_length, 0, GL_RGBA, GL_FLOAT, NULL);

    glGenTextures(1, &tex_waveform_beats_data);
    glBindTexture(GL_TEXTURE_1D, tex_waveform_beats_data);
    glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameterf(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameterf(GL_TEXTURE_1D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glTexImage1D(GL_TEXTURE_1D, 0, GL_RGBA32F, config.audio.waveform_length, 0, GL_RGBA, GL_FLOAT, NULL);

    // Waveform UI element
    glGenTextures(1, &waveform_texture);
    glBindTexture(GL_TEXTURE_2D, waveform_texture);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, config.ui.waveform_width, config.ui.waveform_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, waveform_fb);
    glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, waveform_texture, 0);

    // Strip indicators
    glGenTextures(1, &strip_texture);
    glBindTexture(GL_TEXTURE_2D, strip_texture);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, config.pattern.master_width, config.pattern.master_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, strip_fb);
    glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, strip_texture, 0);

    // Done allocating textures & FBOs, unbind and check for errors
    glBindTexture(GL_TEXTURE_2D, 0);
    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
    if((e = glGetError()) != GL_NO_ERROR) FAIL("OpenGL error: %s\n", gluErrorString(e));

    if((blit_shader = load_shader("resources/blit.glsl")) == 0) FAIL("Could not load blit shader!\n%s", load_shader_error);
    if((main_shader = load_shader("resources/ui_main.glsl")) == 0) FAIL("Could not load UI main shader!\n%s", load_shader_error);
    if((pat_shader = load_shader("resources/ui_pat.glsl")) == 0) FAIL("Could not load UI pattern shader!\n%s", load_shader_error);
    if((crossfader_shader = load_shader("resources/ui_crossfader.glsl")) == 0) FAIL("Could not load UI crossfader shader!\n%s", load_shader_error);
    if((text_shader = load_shader("resources/ui_text.glsl")) == 0) FAIL("Could not load UI text shader!\n%s", load_shader_error);
    if((spectrum_shader = load_shader("resources/ui_spectrum.glsl")) == 0) FAIL("Could not load UI spectrum shader!\n%s", load_shader_error);
    if((waveform_shader = load_shader("resources/ui_waveform.glsl")) == 0) FAIL("Could not load UI waveform shader!\n%s", load_shader_error);
    if((strip_shader = load_shader("resources/strip.glsl")) == 0) FAIL("Could not load strip indicator shader!\n%s", load_shader_error);

    // Stop text input
    SDL_StopTextInput();

    // Open the font
    font = TTF_OpenFont(config.ui.font, config.ui.fontsize);
    if(font == NULL) FAIL("Could not open font %s: %s\n", config.ui.font, SDL_GetError());

    // Init statics
    pat_entry = false;

    SDL_Surface * surf;
    surf = TTF_RenderText_Blended(font, "wtf, why is this necessary", font_color);
    if(surf == NULL) FAIL("Could not create surface: %s\n", SDL_GetError());
    SDL_Texture *texture = SDL_CreateTextureFromSurface(renderer, surf);
    if(texture == NULL) FAIL("Could not create texture: %s\n", SDL_GetError());
    SDL_FreeSurface(surf);
    SDL_DestroyTexture(texture);
}
Example #23
0
void button::texture(SDL_Renderer *R)
{
	tp = SDL_CreateTextureFromSurface(R, image_p);
	tt = SDL_CreateTextureFromSurface(R, image_t);
	tu = SDL_CreateTextureFromSurface(R, image_u);
}
Example #24
0
static bool loadTileset(struct Tileset *tileset, SDL_Renderer *renderer, const struct Turbo_Value *tilesetValue, struct Map *reuse_images){
    unsigned i;
    
    assert(tilesetValue);
    assert(tileset);

    memset(tileset, 0, sizeof(struct Tileset));
    
    if(tilesetValue->type == TJ_Error){
        Turbo_WriteError(tilesetValue, stderr, 0);
        return false;
    }
    
    if(tilesetValue->type != TJ_Object){
        fprintf(stderr, "Invalid tileset object\n");
        return false;
    }
    
    {
        const struct Turbo_Value *const atlasWidth = jsonFindObjectValue(tilesetValue, "columns"),
            *const tileCount  = jsonFindObjectValue(tilesetValue, "tilecount"),
            *const tileWidth  = jsonFindObjectValue(tilesetValue, "tilewidth"),
            *const tileHeight = jsonFindObjectValue(tilesetValue, "tileheight"),
            *const tileData   = jsonFindObjectValue(tilesetValue, "tiles"),
            *const imagePath  = jsonFindObjectValue(tilesetValue, "image");
        
        if(!atlasWidth  || atlasWidth->type != TJ_Number ||
            !tileCount  || tileCount->type  != TJ_Number ||
            !tileWidth  || tileWidth->type  != TJ_Number ||
            !tileHeight || tileHeight->type != TJ_Number ||
            !tileData   || tileData->type   != TJ_Object ||
            !imagePath  || imagePath->type  != TJ_String){
            fprintf(stderr, "Invalid tileset format\n");
            return false;
        }
        
        tileset->tileWidth = (int)tileWidth->value.number;
        tileset->tileHeight = (int)tileHeight->value.number;
        tileset->atlasWidth = (int)atlasWidth->value.number;
        tileset->atlasHeight = ((int)tileCount->value.number) / tileset->atlasWidth;

        if(imagePath->length >= 0xFF - 1){
            fprintf(stderr, "Overlength tileset image path.\n");
            return false;
        }

        memcpy(tileset->imagePath, imagePath->value.string, imagePath->length);
        tileset->imagePath[imagePath->length] = '\0';

        // Normalize the path, because Tiled's JSON exporter is a bit jacked.
        {
            char *path = tileset->imagePath;
            while(*path){
                if(path[0] == '\\' && path[1] == '/'){
                    char *iter = path;
                    iter[0] = '/';
                    while(*iter){
                        iter[0] = iter[1];
                        iter++;
                    }
                }
                path++;
            }
        }
        
        tileset->obstruction = calloc(1, (int)tileCount->value.number);

        // Get obstruction data.
        for(i = 0; i < tileData->length; i++){
            // HACK: The Tiled JSON exporter will only print the names of tiles with attributes.
            const int index = atoi(tileData->value.object[i].name);
            assert(index < (int)tileCount->value.number);
            tileset->obstruction[index] = true;
        }
        
        tileset->tileHeight = (int)tileHeight->value.number;
    }

    // Load the tileset image, or reuse it from the map.
    if(reuse_images){
        for(i = 0; i < reuse_images->numTilesets; i++){
            if(strncmp(tileset->imagePath, reuse_images->tilesets[i].imagePath, 0xFF) == 0){
                tileset->image = reuse_images->tilesets[i].image;
                break;
            }
        }
    }
    if(!tileset->image){
        SDL_Surface *const surface = IMG_Load(tileset->imagePath);
        if(!surface){
            fprintf(stderr, "Could not load image %i for tileset\n", tileset->imagePath);
            return false;
        }
        
        tileset->image = SDL_CreateTextureFromSurface(renderer, surface);
        SDL_FreeSurface(surface);
    }

    return true;
}
Example #25
0
File: loop.c Project: djxr/lrn_sdl2
int main (int argc, char *argv[]) 
{
	int		i = 0;
	int		j = 0;
	SDL_Surface	*sur = NULL;
	SDL_Rect	tile[NUM_TILES];
	SDL_Rect	target;
	int		scale = 32;
	
/* HANDLE ARGUMENTS *//*{{{*/
	for(i = 1; i < argc; i++)
	{
		if(strncmp(argv[i], "-d", 3) == 0)
		{
			i++;
			d_sel = atoi(argv[i]);
		}else if(strncmp(argv[i], "-s", 3) == 0)
		{
			i++;
			scale = atoi(argv[i]);
		}
	}/*}}}*/

	init();

/* DEFINE TILE-ATLAS SRC_RECTS *//*{{{*/
	for(i = 0; i < NUM_TILES; i++)
	{
		tile[i].x = i * 16;
		tile[i].y = 0;
		tile[i].h = 16;
		tile[i].w = 16;
	}/*}}}*/

/* LOAD THE ATLAS */ /*{{{*/
	sur = SDL_LoadBMP("tiles.bmp");
	atlas = SDL_CreateTextureFromSurface(rend, sur);
	SDL_FreeSurface(sur);/*}}}*/
	SDL_Event e;

	while(!game_quit)
	{
		if(SDL_PollEvent(&e))/*{{{*/
		{
			switch(e.type)
			{
				case SDL_QUIT:
					SDL_Log("Program quit after %i ticks", e.quit.timestamp);
					game_quit = true;
					break;
			}
		}/*}}}*/
		// UPDATE GAME BASED ON TIME!
		// RENDER ONLY WHAT NEEDS TO CHANGE!
		/* CLEAR RENDERER *//*{{{*/
		SDL_SetRenderDrawColor(rend,0,0,0,255);
		SDL_RenderClear(rend);/*}}}*/
		/* PAINT TILES TO THE RENDERER *//*{{{*/
		for(i = 0; i < 10; i++)
		{
			for(j = 0; j < 10; j++)
			{
				target.x = j * scale;
				target.y = i * scale;
				target.h = scale;
				target.w = scale;
				SDL_RenderCopy(rend, atlas, &tile[brush], &target);
			}
		}/*}}}*/
		SDL_RenderPresent(rend);
	}

	tini();
	printf("I ran till the end\n");
	return 0;
}
Example #26
0
int main(int argc, const char * argv[])
{

  if (SDL_Init(SDL_INIT_EVERYTHING) != 0) {
    std::cout << "SDL init error: " << SDL_GetError() << std::endl;
    return 1;
  }
  
  SDL_Window *win = SDL_CreateWindow("SpaceThing", 100, 100, 640, 480, SDL_WINDOW_SHOWN);
  if (win == nullptr) {
    std::cout << "SDL create window error: " << SDL_GetError() << std::endl;
    SDL_Quit();
    return 1;
  }
  
  SDL_Renderer *ren = SDL_CreateRenderer(win, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
  if (ren == nullptr) {
    SDL_DestroyWindow(win);
    std::cout << "SDL create renderer error: " << SDL_GetError() << std::endl;
    SDL_Quit();
    return 1;
  }
  
  char * basePath = SDL_GetBasePath();
  std::string imagePath = std::string(basePath) + "Assets/farback.gif";
  std::cout << "Image path is: " << imagePath << std::endl;
  
  SDL_Surface *bg = IMG_Load(imagePath.c_str());
  if (bg == nullptr) {
    SDL_DestroyRenderer(ren);
    SDL_DestroyWindow(win);
    std::cout << "SDL load bmp error loading background: " << SDL_GetError() << std::endl;
    SDL_Quit();
    return 1;
  }
  
  SDL_free(basePath);
  
  SDL_Texture *tex = SDL_CreateTextureFromSurface(ren, bg);
  SDL_FreeSurface(bg);
  if (tex == nullptr) {
    SDL_DestroyRenderer(ren);
    SDL_DestroyWindow(win);
    std::cout << "SDL create background texture error: " << SDL_GetError() << std::endl;
    SDL_Quit();
    return 1;
  }
  
  int w, h;
  SDL_QueryTexture(tex, nullptr, nullptr, &w, &h);
  
  SDL_Event e;
  bool quit = false;
  while (!quit) {
    while (SDL_PollEvent(&e)) {
      if (e.type == SDL_QUIT) {
        quit = true;
      }
    }
    
    // Render the scene
    SDL_RenderClear(ren);
    SDL_Rect dst;
    dst.x = 0;
    dst.y = 0;
    dst.w = w;
    dst.h = h;
    SDL_RenderCopy(ren, tex, nullptr, &dst);
    SDL_RenderPresent(ren);
  }
  
  SDL_DestroyTexture(tex);
  SDL_DestroyRenderer(ren);
  SDL_DestroyWindow(win);
  SDL_Quit();
  
  std::cout << "SDL Sample Exiting\n";
    return 0;
}
Example #27
0
list<SDL_Texture*> createSheet(const char* file, int frames, int delay) {

    if(frames <= 0) {
        //return NULL;
        SDL_Log("Graphics::createSheet Frames cannot <= 0!");
    }

    list<SDL_Texture*> frameList;
    //list<SDL_Texture*> dummy;
    //list<SDL_Texture*>* frameList = &dummy;

    SDL_Surface* surface;
    SDL_Surface* tempSurface;


    SDL_Rect surfaceRect;
    SDL_Rect tempRect;

    int frameWidth;

    surface = IMG_Load(file);

    if(surface != NULL) {
        //SDL_Log("Sprite sheet is not null");
        SDL_Log("Height: %d", surface->h);
        SDL_Log("Width: %d", surface->w);

        frameWidth = (surface->w)/frames;


        SDL_Log("frameWidth: %d", frameWidth);
        for (int i = 0; i < frames; i++) {

		    Uint32 rmask = 0x000000ff;
    		Uint32 gmask = 0x0000ff00;
    		Uint32 bmask = 0x00ff0000;
			Uint32 amask = 0xff000000;
			
            tempSurface = SDL_CreateRGBSurface(0, (surface->w/frames), surface->h, 32, rmask, gmask, bmask, amask);

            SDL_SetSurfaceBlendMode(surface, SDL_BLENDMODE_NONE);

            SDL_Log("Frame: %d", i);
            surfaceRect.x = i * (surface->w)/frames;
            surfaceRect.y = 0;
            surfaceRect.h = surface->h;
            surfaceRect.w = (surface->w)/frames;

            tempRect.x = 0;
            tempRect.y = 0;
            tempRect.h = surface->h;
            tempRect.w = (surface->w)/frames;
            SDL_Log("sourceRect.x = %d", surfaceRect.x);
            if(surface != NULL) {
                SDL_BlitSurface(surface, &surfaceRect, tempSurface, &tempRect);

                if(tempSurface != NULL) {
					SDL_Texture* frame = SDL_CreateTextureFromSurface(mainRender, tempSurface);
					
					for (int i = 0; i < delay;  i++) {
                    	frameList.push_back(frame);
					}
                } else {
                    SDL_Log("tempSurface = NULL Error: %s", SDL_GetError());
                }
            } else {
                SDL_Log("Sheet Sprite Surface was Null Error: %s", SDL_GetError());
            }

        }
        if(!frameList.empty()) {
            SDL_Log("Returning Framelist");
            return frameList;
        } else {
            SDL_Log("frameList is equal to NULL!");

        }



    } else {
        SDL_Log("Couldn't load sprite sheet");
        SDL_Log(SDL_GetError());


    }




}
Example #28
0
int main() {
  
  die_if(SDL_Init(SDL_INIT_VIDEO), "unable to init SDL");
  die_if(!(g_window = SDL_CreateWindow(WIN_TITLE, WIN_X, WIN_Y, WIN_WIDTH, WIN_HEIGHT, 0)),
	 "unable to create window");
  die_if(!(g_screen = SDL_GetWindowSurface(g_window)), "unable to create window surface");
  die_if(!(g_renderer = SDL_CreateRenderer(g_window, -1, SDL_RENDERER_ACCELERATED)),
	 "unable to create renderer");

  die_if(SDL_SetRenderDrawColor( g_renderer, 0x0, 0x0, 0x0, 0xFF ),
	 "unable to set draw color");

  g_perf_freq = SDL_GetPerformanceFrequency();

  // init textures
{
  SDL_Surface *srfc = NULL;
  for(unsigned int i = 0; i < NUM_TEX; ++i)
    {
      die_if(!(srfc = SDL_LoadBMP((char*)g_tex[i])), "unable to load bitmap");
      die_if(!(g_tex[i] = SDL_CreateTextureFromSurface(g_renderer, srfc))
	     , "unable to create bmp texture");

      g_tex_w[i] = srfc->w;
      g_tex_h[i] = srfc->h;
  
      SDL_FreeSurface(srfc);
    }
}
  
  alloc_obj(SHIP_TID);

int nufos = NUM_UFOS;

for(int i = 0; i < nufos; ++i)
{
  alloc_obj(UFO_TID);
}

  Uint64 t0 = SDL_GetPerformanceCounter();

/* used to optimize (minimize) calls to rand() */
#define HASBITS(x,y) (((x) & (y)) == (y))

/* int foo = 0; */
/* for(int i = 0; i < 100000; ++i) */
/* { */
/* int r = rand(); */
/* if (HASBITS(r,0x7) || HASBITS(r,0x70)) ++foo; */
/* } */

// printf("%d\n", foo);
// exit(-1);
while (1) {
// SDL_Delay(10);
    SDL_Event e;

    Uint64 t1 = SDL_GetPerformanceCounter();
    float dt;
    dt = (float)(t1 - t0)/g_perf_freq;
    t0 = t1;

    /* user events */
    if (SDL_PollEvent(&e)) {
      if (e.type == SDL_QUIT) { exit_cleanup(0); }
      if (e.type == SDL_KEYDOWN)
	{
          SDL_Keycode sym = e.key.keysym.sym;
	  if(sym == SDLK_SPACE)
	    {
	      alloc_timer_1s(alloc_obj(PHOTON_TID), t1);
	    }
	  g_obj_ax[0] = sym == SDLK_LEFT ? -(X_ACC) : (sym == SDLK_RIGHT ? X_ACC : 0.0f);
	  g_obj_ay[0] = sym == SDLK_UP ? -(Y_ACC) : (sym == SDLK_DOWN ? Y_ACC : 0.0f);
	}
    }

    /* ai events */
    for(int i = 1; i < nufos + 1; ++i)
      {
	int r = rand();
#define RAND_FREQ 0xf
	g_obj_ax[i] = HASBITS(r,RAND_FREQ) ? X_ACC : 0.0f;
	g_obj_ax[i] += HASBITS(r,RAND_FREQ << 8) ? -(X_ACC) : 0.0f;
	g_obj_ax[i] /= 100.0f;
	g_obj_ay[i] = HASBITS(r,RAND_FREQ << 16) ? Y_ACC : 0.0f;
	g_obj_ay[i] += HASBITS(r,RAND_FREQ << 24) ? -(Y_ACC) : 0.0f;
	g_obj_ay[i] /= 100.0f;
      }


    /* timer events */
    for(int i = 0; i < g_ntimers; ++i)
      {
	if(t1 >= g_timer_expire[i])
	  {
	    dealloc_timer_1s(i);
	  }
      }

    /* physics update */
    
    for(int i = g_nobjs - 1; i >= 0 ; --i)
      {
        update(&g_obj_x[i], &g_obj_vx[i], &g_obj_ax[i], dt, -OBJ_W(i), WIN_WIDTH);
        update(&g_obj_y[i], &g_obj_vy[i], &g_obj_ay[i], dt, -OBJ_H(i), WIN_HEIGHT);
      }

    /* collisions */
    for(int i = g_nobjs - 1; i >= 0 ; --i)
      {
	for(int j = i - 1; j >= 0 ; --j)
	  {
	    if (colliding(i,j))
	      {
	      }
	  }
      }
    /* rendering */
    SDL_RenderClear(g_renderer); /* ignore return */

    SDL_Texture *tex = g_tex[UFO_TID];
      
    for(int i = 1; i < nufos + 1; ++i)
      {
	render(i, tex);
      }
    render(0, g_tex[SHIP_TID]);
    tex = g_tex[PHOTON_TID];
    for(int i = 1 + nufos; i < 1 + nufos + g_ntimers; ++i)
      {
	render(i, tex);
      }

    SDL_RenderPresent(g_renderer);
  }
 
  return 0;
}
Example #29
0
int main()
{
  Invader invaders[ROWS][COLS];
  Defender player;
  Bullet playerBullet;
  Ship spaceShip;
  Bullet invaderBullet[bulletNumber];
  Shelter shelter[shelterNumber];

  initializeInvaders(invaders);

  //Initialise playerBullet and initial invader bullet firing setting
  playerBullet.fire=0;
  playerBullet.invaderCount=0;
  playerBullet.score=0;
  playerBullet.lives=3;
  playerBullet.bulletHitPlayer=0;
  for(int i=0; i<bulletNumber; ++i)
  {
    invaderBullet[i].fire=1;
    invaderBullet[i].active=1;
  }


  // initialise SDL and check that it worked otherwise exit
  // see here for details http://wiki.libsdl.org/CategoryAPI
  if (SDL_Init(SDL_INIT_EVERYTHING) == -1)
  {
    printf("%s\n",SDL_GetError());
    return EXIT_FAILURE;
  }
  // we are now going to create an SDL window

  SDL_Window *win = 0;
  win = SDL_CreateWindow("Invaders", 100, 100, WIDTH, HEIGHT, SDL_WINDOW_SHOWN);
  if (win == 0)
  {
    printf("%s\n",SDL_GetError());
    return EXIT_FAILURE;
  }

  // the renderer is the core element we need to draw, each call to SDL for drawing will need the
  // renderer pointer
  SDL_Renderer *ren = 0;
  ren = SDL_CreateRenderer(win, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
  // check to see if this worked
  if (ren == 0)
  {
    printf("%s\n",SDL_GetError() );
    return EXIT_FAILURE;
  }
  // this will set the background colour to white.
  // however we will overdraw all of this so only for reference
  SDL_SetRenderDrawColor(ren, 255, 255, 255, 255);

//  // SDL image is an abstraction for all images
  SDL_Surface *image;
//  // we are going to use the extension SDL_image library to load a png, documentation can be found here
//  // http://www.libsdl.org/projects/SDL_image/
  image=IMG_Load("invaders.png");
  if(!image)
  {
    printf("IMG_Load: %s\n", IMG_GetError());
    return EXIT_FAILURE;
  }
//  // SDL texture converts the image to a texture suitable for SDL rendering  / blitting
//  // once we have the texture it will be store in hardware and we don't need the image data anymore

  SDL_Texture *tex = 0;
  tex = SDL_CreateTextureFromSurface(ren, image);
  // free the image
  SDL_FreeSurface(image);

  // Initialise player
  player.move = NONE;
  player.pos.x = WIDTH/2;
  player.pos.y = HEIGHT - 30;
  player.pos.w = DEFENDERSIZE;
  player.pos.h = DEFENDERSIZE/2;

  player.srcDefender.w=188;
  player.srcDefender.h=105;
  player.srcDefender.x=0;
  player.srcDefender.y=0;

  // Initialise player bullet
  playerBullet.pos.x = (WIDTH/2)+(DEFENDERSIZE/2);
  playerBullet.pos.y = HEIGHT - 50;
  playerBullet.pos.w = 2;
  playerBullet.pos.h = 15;

  playerBullet.srcBullet.w=bulletWidth;
  playerBullet.srcBullet.h=250;
  playerBullet.srcBullet.x=0;
  playerBullet.srcBullet.y=0;

  // Initialise invader bullet
  for(int i=0; i<bulletNumber; ++i)
  {
    //a random column is chosen, it then goes through the invaders one by one starting with the bottom one
    //if the invader is active then it will shoot and break the loop
    //otherwise it will go to the next invader up until it finds the top
    //so only the bottom invader for each column is firing
    int x = 0;
    int y = rand()%(COLS-2);
    y +=2;
    for(int j=ROWS-1; j>=0; j--)
    {
      if(invaders[j][y].active==1)
      {
        invaders[j][y].shooting=1;
        x=j;
        break;
      }
    }

    //if the invader rnadomly chosen is active then the bullet is placed at it's x and y coordinates and fired
    if(invaders[x][y].shooting==1)
    {
      invaderBullet[i].pos.y=invaders[x][y].pos.y;
      invaderBullet[i].pos.x=((SPRITEWIDTH/2)-(5))+invaders[x][y].pos.x;
    }
    else if(invaders[x][y].shooting==0)
    {
      invaderBullet[i].fire=0;
    }

    invaderBullet[i].pos.w = 10;
    invaderBullet[i].pos.h = 20;

    invaderBullet[i].srcBullet.w=24;
    invaderBullet[i].srcBullet.h=56;
    invaderBullet[i].srcBullet.x=0;
    invaderBullet[i].srcBullet.y=0;
  }

  //randomise spaceship start direction
  //will end up either appearing from the right or the left
  //if its from the left the shipDelay has to be minus so the image is off screen and the opposite for the right
  srand(time(NULL));
  spaceShip.randomDir = rand()%2;
  int x;
  if (spaceShip.randomDir==0)
  {
    x=-shipDelay;
  }
  else if (spaceShip.randomDir==1)
  {
    x=shipDelay;
  }

  //initialise shelter
  for(int j=0; j<shelterNumber; j++)
  {
    shelter[j].pos.y=500;
    shelter[j].pos.x=(j*200)+50;
    shelter[j].pos.w=75;
    shelter[j].pos.h=25;

    shelter[j].srcShelter.y=0;
    shelter[j].srcShelter.w=shelterWidth;
    shelter[j].srcShelter.h=shelterHeight;
  }

  //initialise space ship
  spaceShip.pos.x=(spaceShip.randomDir*(WIDTH-spaceShipWidth)+x);
  spaceShip.pos.y=20;
  spaceShip.pos.w=spaceShipWidth;
  spaceShip.pos.h=25;

  spaceShip.srcShip.x=0;
  spaceShip.srcShip.y=204;
  spaceShip.srcShip.w=196;
  spaceShip.srcShip.h=88;

  int quit=0;
  // now we are going to loop forever, process the keys then draw

  //loading in the Defender spritesheet
  SDL_Surface *imageDefender;
  imageDefender=IMG_Load("Defender.png");
  if(!imageDefender)
  {
    printf("IMG_Load: %s\n", IMG_GetError());
    return EXIT_FAILURE;
  }
  SDL_Texture *texDefender = 0;
  texDefender = SDL_CreateTextureFromSurface(ren, imageDefender);
  SDL_FreeSurface(imageDefender);

  //loading in the enemy fire spritesheet
  SDL_Surface *imageenemyFire;
  imageenemyFire=IMG_Load("EnemyShot1.png");
  if(!imageenemyFire)
  {
    printf("IMG_Load: %s\n", IMG_GetError());
    return EXIT_FAILURE;
  }
  SDL_Texture *texEnemyFire = 0;
  texEnemyFire = SDL_CreateTextureFromSurface(ren, imageenemyFire);
  SDL_FreeSurface(imageenemyFire);

  //loading in the Shelter spritesheet
  SDL_Surface *imageShelter;
  imageShelter=IMG_Load("bunker.png");
  if(!imageShelter)
  {
    printf("IMG_Load: %s\n", IMG_GetError());
    return EXIT_FAILURE;
  }
  SDL_Texture *texShelter = 0;
  texShelter = SDL_CreateTextureFromSurface(ren, imageShelter);
  SDL_FreeSurface(imageShelter);

  //loading in the laser spritesheet
  SDL_Surface *imageBullet;
  imageBullet=IMG_Load("laser.png");
  if(!imageBullet)
  {
    printf("IMG_Load: %s\n", IMG_GetError());
    return EXIT_FAILURE;
  }
  SDL_Texture *texBullet = 0;
  texBullet = SDL_CreateTextureFromSurface(ren, imageBullet);
  SDL_FreeSurface(imageBullet);

  while (quit !=1)
  {
    SDL_Event event;
    // grab the SDL even (this will be keys etc)
    while (SDL_PollEvent(&event))
    {
      player.move=NONE;
      playerBullet.start=NONE;
      // look for the x of the window being clicked and exit
      if (event.type == SDL_QUIT)
        quit = 1;
      // check for a key down
      if (event.type == SDL_KEYDOWN)
      {
        switch (event.key.keysym.sym)
        {
          // if we have an escape quit
          case SDLK_ESCAPE :
          {
            quit=1;
            break;
          }
          //if we have a right key then the defender moves right along with the bullet before its fired
          case SDLK_RIGHT :
          case SDLK_d :
          {
            player.move=RIGHT;
            playerBullet.start=RIGHT;
            break;
          }
          //if we have a left key then the defender moves left along with the bullet before its fired
          case SDLK_LEFT :
          case SDLK_a :
          {
            player.move=LEFT;
            playerBullet.start=LEFT;
            break;
          }
          //if we have a space key then the player bullet is fired
          case SDLK_SPACE :
          {
            playerBullet.fire=1;
            break;
          }
        }
      }
    }


    // now we clear the screen (will use the clear colour set previously)
    SDL_SetRenderDrawColor(ren, 0, 0, 0, 255);
    SDL_RenderClear(ren);

    updateInvaders(invaders);
    drawInvaders(ren,tex,invaders);
    // Up until now everything was drawn behind the scenes.
    // This will show the new, red contents of the window.

    moveDefender(ren, texDefender, &player);
    playerFire(ren, texBullet, &playerBullet, &player, shelter);
    invaderFire(ren, texEnemyFire, shelter, invaderBullet, &playerBullet, &player);
    invaderHit(&playerBullet, invaders);
    drawSpaceShip(ren, tex, &spaceShip);
    spaceShipHit(&playerBullet, &spaceShip);
    invaderReachBottom(&player,invaders, &playerBullet);
    drawShelter(ren, texShelter, shelter);

    SDL_RenderPresent(ren);

    //if the player is hit or the bullet has gone offscreen, or has hit the shelter then
    //the random position for the next invader is chosen
    for(int i=0; i<bulletNumber; ++i)
    {
      if((invaderBullet[i].bulletHitPlayer==1)||
         (invaderBullet[i].bulletOffScreen==1)||
         (invaderBullet[i].bulletHitShelter==1))
      {
        //a random column is chosen, it then goes through the invaders one by one starting with the bottom one
        //if the invader is active then it will shoot and break the loop
        //otherwise it will go to the next invader up until it finds the top
        //so only the bottom invader for each column is firing
        int x = 0;
        int y = rand()%COLS;
        for(int j=ROWS-1; j>=0; j--)
        {

          invaders[j][y].shooting=0;
          if(invaders[j][y].active==1)
          {
            invaders[j][y].shooting=1;
            x=j;
            break;
          }
        }

        //only if the invader is active and is the bottom of it's column will the shooting value be set to 1
        //then the bullet is placed at the coordinates of the random invader chosen
        if(invaders[x][y].shooting==1)
        {
          invaderBullet[i].pos.y=invaders[x][y].pos.y;
          invaderBullet[i].pos.x=((SPRITEWIDTH/2)-(5))+invaders[x][y].pos.x;
          invaderBullet[i].active=1;
          invaderBullet[i].fire=1;
        }
        else if(invaders[x][y].shooting==0)
        {
          invaderBullet[i].fire=0;
        }

        invaderBullet[i].bulletOffScreen=0;
        invaderBullet[i].bulletHitPlayer=0;

      }
    }

    //when the invaders shot = the amount of invaders on screen then they redraw and
    // reset themselves at the top of the screen along with the counter
    //shelters do not reset
    if(playerBullet.invaderCount==ROWS*COLS)
    {
      initializeInvaders(invaders);
      updateInvaders(invaders);
      drawInvaders(ren,tex,invaders);
      playerBullet.invaderCount=0;
      playerBullet.lives+=1;
    }

    //if the escpae button is hit or player loses all of their lives then the game ends
    if((playerBullet.lives<=0)||(player.gameOver==1))
    {
      printf("you lose!\n");
      quit=1;
    }
  }

  printf("Your score = [%d]\n",playerBullet.score);
  printf("Your lives = [%d]\n",playerBullet.lives);

  SDL_Quit();
  return 0;
}
Example #30
-1
BTexture loadTextTexture(char *text, SDL_Color color)
{
	// Convert *text to string before calling this function
	SDL_Surface *textSurface = TTF_RenderText_Solid(font, text, color);
	BTexture textTexture;

	if (textSurface == NULL)
		printf("Unable to render text surface! Error: %s\n", TTF_GetError());
	else
	{
		textTexture.texture = SDL_CreateTextureFromSurface(renderer, textSurface);
		if (textTexture.texture == NULL)
			printf("Unable to create texture from renderer text! Error: %s\n", SDL_GetError());
		else
		{
			textTexture.w = textSurface->w;
			textTexture.h = textSurface->h;
		}

		SDL_FreeSurface(textSurface);
	}

	return textTexture;
}