Exemple #1
0
Image read_image( const char *filename )
{
    printf("loading image '%s'...\n", filename);

    // importer le fichier en utilisant SDL_image
    SDL_Surface *surface= IMG_Load(filename);
    if(surface == NULL)
    {
        printf("loading image '%s'... sdl_image failed.\n", filename);
        return create_image(2, 2, 4, make_color(1, 0, 0));
    }

    // verifier le format, rgb ou rgba
    const SDL_PixelFormat format= *surface->format;
    if(format.BitsPerPixel != 24 && format.BitsPerPixel != 32)
    {
        printf("loading image '%s'... format failed. (bpp %d)\n", filename, format.BitsPerPixel);
        SDL_FreeSurface(surface);
        return create_image(2, 2, 4, make_color(1, 0, 0));
    }

    int height= surface->h;
    int width= surface->w;
    int channels= (format.BitsPerPixel == 32) ? 4 : 3;

    Image im;
    im.data.resize(width*height*channels);
    im.width= width;
    im.height= height;
    im.channels= channels;

    // converti les donnees en pixel rgba, et retourne l'image, openGL utilise une origine en bas a gauche.
    if(format.BitsPerPixel == 32)
    {
        int py= 0;
        for(int y= height -1; y >= 0; y--, py++)
        {
            unsigned char *data= &im.data.front() + im.width * y * im.channels;
            Uint8 *pixel= (Uint8 *) surface->pixels + py * surface->pitch;

            for(int x= 0; x < width; x++, pixel+= format.BytesPerPixel, data+= 4)
            {
                Uint8 r= pixel[format.Rshift / 8];
                Uint8 g= pixel[format.Gshift / 8];
                Uint8 b= pixel[format.Bshift / 8];
                Uint8 a= pixel[format.Ashift / 8];

                data[0]= r;
                data[1]= g;
                data[2]= b;
                data[3]= a;
            }
        }
    }

    else if(format.BitsPerPixel == 24)
    {
        int py= 0;
        for(int y= height -1; y >= 0; y--, py++)
        {
            unsigned char *data= &im.data.front() + im.width * y * im.channels;
            Uint8 *pixel= (Uint8 *) surface->pixels + py * surface->pitch;

            for(int x= 0; x < width; x++, pixel+= format.BytesPerPixel, data+= 3)
            {
                const Uint8 r= pixel[format.Rshift / 8];
                const Uint8 g= pixel[format.Gshift / 8];
                const Uint8 b= pixel[format.Bshift / 8];

                data[0]= r;
                data[1]= g;
                data[2]= b;
            }
        }
    }

    SDL_FreeSurface(surface);

    return im;
}
Exemple #2
0
int main(int argc, char* argv[]) {
    // Init
    initPath(argv[0]);
    SDL_Surface* screen = NULL;
    SDL_Event event;
    int *seed;
    srand((int)seed);
    int previousTime = 0, currentTime = 0;
    Events *flags = createEventFlags();

    SDL_Init(SDL_INIT_VIDEO);
    SDL_SetEventFilter(eventFilter);

    screen = SDL_SetVideoMode(800, 600, 32, SDL_HWSURFACE | SDL_ASYNCBLIT | SDL_DOUBLEBUF | SDL_NOFRAME);
    SDL_WM_SetCaption("Tower Defense", NULL);
    Action *actionList = initAction();

    Map* map = createMap(getPath("resources/Forest.png"));
    _map = map;

    SDL_Rect surface = {0, 0, 720, 600};
    Viewport* viewport = createViewport(screen, surface, map);
    _viewport = viewport;

    // FIXME uh? what's this thing?
    surface.x = 800 - 80;
    surface.y = 0;
    surface.h = 80;
    surface.w = 600;

    // Creation of the enemies
    TypeEn *whiteCat = createTypeEn(100, 5, false, true, true, false, 1,getPath("resources/white_transparent_cat.png"));
    TypeEn *blackCat = createTypeEn(100, 5, false, true, true, false, 1,getPath("resources/black_transparent_cat.png"));
    Enemy *cat1 = createEnemy(1,1,whiteCat);
    Enemy *cat2 = createEnemy(1,10,whiteCat);
    Enemy  *cat3 = createEnemy(5,5,blackCat);
    Enemy *cat4 = createEnemy(21,4,blackCat);

    TypeEn *zombie = createTypeEn(100,5,false,true,true,false,1,getPath("resources/zombie.png"));
    Enemy *zombie1 = createEnemy(4,4,zombie);
    Enemy *zombie2 = createEnemy(9,4,zombie);
    Enemy *zombie3 = createEnemy(9,9,zombie);
    Enemy *zombie4 = createEnemy(7,14,zombie);

    //Add enemy in the List
    List *catList = newList(cat4);
    pushList((void*)catList,cat2);
    pushList((void*)catList,cat3);
//   pushList((void*)catList,cat1);

    List *zombieList = newList(zombie1);
    /*   pushList((void*)zombieList,zombie2);*/
    /*   pushList((void*)zombieList,zombie3);*/
    /*   pushList((void*)zombieList,zombie4);*/

//   removeEnemyFromList(cat4,catList);

    //TOWER
    TypeBul *bullet = createTypeBul(getPath("resources/bullet.png"), 1);
    TypeTo *tower = createTypeTo(0,5,0,0,false,false,false,false,bullet,NULL,getPath("resources/tower.png"));
    upgradeTypeTo(tower,0.5,getPath("resources/towerUP.png"));
    flags->selectedTower = tower->nextType;
    Tower *tower1 = createTower(7,7,tower);

    List *towerList = newList(tower1);
    flags->towerList = towerList;

    // Create and Renders the right panel game menu
    SDL_Rect surfaceMenu = {720, 0, 800, 600};
    Menu* menu = menu_create(screen, surfaceMenu);
    menu_loadBackground(menu, "resources/enemyFont.gif");
    // For testing only, we add a few random buttons
    menu_addButton(menu, button_createBuildButton(tower));
    menu_addButton(menu, button_createBuildButton(tower));
    menu_addButton(menu, button_createBuildButton(tower));
    menu_render(menu);


    _cell = *getCase(20,11);
    // Main loop
    while(actionList[QUIT].boolean == NULL) {
        // Managing the events
        manageEvents(viewport, flags,actionList);
        for(int i=1; i<ACTION_LENGTH; i++) {
            if(actionList[i].boolean) {
                int repeat = (*actionList[i].action)(viewport,flags,actionList[i].boolean);
                if(!repeat) {
                    actionList[i].boolean = NULL;
                }
            }
        }

        // Redraws the map (viewport contents) before blitting stuff on it
        updateViewport(viewport);


///////////////////////////// DEBUG WALL /////////////////////////////
        SDL_Rect position;
        for(int i=0; i < _map->nbCaseW; i++) {
            for(int j=0; j < _map->nbCaseH; j++) {
                Case cell = *getCase(i,j);
                position.x = cell.x;
                position.y = cell.y;
                if(map->matrice[i][j].hasTower == 2) {
                    SDL_Surface *wall = IMG_Load(getPath("resources/brick.png"));
                    blitToViewport(viewport, wall, NULL, &position);
                }
            }
        }
        position.x = _cell.x;
        position.y = _cell.y;
        blitToViewport(viewport, IMG_Load(getPath("resources/candy_cane.png")), NULL, &position);
/////////////////////////////////////////////////////////////////////

        // Move enemies
        if(flags->enemy_Path_Calculation) {
            pathReCalculation(catList);
            pathReCalculation(zombieList);
            flags->enemy_Path_Calculation = false;
        }
        moveEnemyList(zombieList);
        moveEnemyList(catList);

        // Blit enemies
        drawEnemyList(zombieList);
        drawEnemyList(catList);
        //Blit TOWER
        /*      if(event.key.keysym.sym == SDLK_u){*/
        /*         upgrade(tower1);*/
        /*      }*/
        Bullet *bullet1 = createBullet(tower1);
        animateBullet(bullet1);
        drawTowerList(towerList);

        /* This should be handled by event.c
          switch(event.key.keysym.sym){
             case SDLK_a:
                flags->selectedTower = tower;
              break;
             case SDLK_b:
                flags->selectedTower = tower->nextType;
              break;
             default:
              break;

          }*/
        /*      */


        // Ask SDL to swap framebuffers to update the displayed screen
        SDL_Flip(screen);

        // Managing frames
        currentTime = SDL_GetTicks();
        if (currentTime - previousTime <= 20) {
            SDL_Delay(20 - (currentTime - previousTime));
        }

        // DEBUG
        printf("Frame %i : %ims\n", framecounter++, currentTime - previousTime);

        previousTime = SDL_GetTicks();
    }
    free(actionList);
    SDL_Quit();

    return EXIT_SUCCESS;
}
Exemple #3
0
int main()
{
    if(SDL_Init(SDL_INIT_VIDEO))
    {
        fprintf(stderr, "SDL_Init Error: %s\n", SDL_GetError());
        exit(1);
    }

    SDL_Window *win = SDL_CreateWindow("Moving start", 100, 100, SCREEN_HEIGHT, SCREEN_WIDTH, SDL_WINDOW_SHOWN);

    if(!win)
    {
        fprintf(stderr, "SDL_CreateWindow Error: %s\n", SDL_GetError());
        SDL_Quit();
        exit(1);
    }

    if(!IMG_Init(IMG_INIT_PNG)) //***
    {
        fprintf(stderr, "IMG_Init Error: %s\n", IMG_GetError());
        SDL_DestroyWindow(win);
        SDL_Quit();
        exit(1);
    }

    SDL_Renderer *ren = SDL_CreateRenderer(win, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);

    if(!ren)
    {
        fprintf(stderr, "SDL_CreateRenderer Error: %s\n", SDL_GetError());
        IMG_Quit(); //***
        SDL_DestroyWindow(win);
        SDL_Quit();
        exit(1);
    }

    //SDL_Surface *png = IMG_Load("../../MediaResources/star.png"); //***
    SDL_Surface *png = IMG_Load("../../MediaResources/lips.png");

    if(!png)
    {
        fprintf(stderr, "IMG_Load Error: %s\n", IMG_GetError());
        SDL_DestroyRenderer(ren);
        IMG_Quit(); //***
        SDL_DestroyWindow(win);
        SDL_Quit();
        exit(1);
    }

    SDL_Texture *tex = SDL_CreateTextureFromSurface(ren, png);
    SDL_FreeSurface(png);

    if(!tex)
    {
        fprintf(stderr, "SDL_CreateTextureFromSurface Error: %s\n", SDL_GetError());
        SDL_DestroyRenderer(ren);
        IMG_Quit(); //***
        SDL_DestroyWindow(win);
        SDL_Quit();
        exit(1);
    }
    /*
        SDL_Rect dstRect = {SCREEN_HEIGHT / 2 - 32, SCREEN_WIDTH / 2 - 32, 64, 64};

        SDL_SetRenderDrawColor(ren, 0x00, 0xFF, 0xFF, 0xFF);
    */
    /*
        SDL_RenderClear(ren);

        SDL_RenderCopy(ren, tex, NULL, &dstRect);

        SDL_RenderPresent(ren);

        SDL_Delay(4000);
    */
    /*
        for(int i = 0; i < 10; ++i)
        {
            dstRect.h *= 1.5;
            dstRect.w *= 1.5;
            dstRect.x = SCREEN_HEIGHT / 2 - dstRect.h / 2;
            dstRect.y = SCREEN_WIDTH / 2 - dstRect.w / 2;
            SDL_RenderClear(ren);
            SDL_RenderCopy(ren, tex, NULL, &dstRect);
            SDL_RenderPresent(ren);
            SDL_Delay(50);
        }
    */

    bool quit = false;
    SDL_Event e;

    SDL_Rect destRect = {0, 0, 256, 256};
    SDL_Rect rectFrom = {0, 0, 256, 256};

    SDL_SetRenderDrawColor(ren, 0xFF, 0xFF, 0xFF, 0xFF);

    while(!quit)
    {
        while(SDL_PollEvent(&e))
        {
            switch(e.type)
            {
            case SDL_QUIT:
            case SDL_MOUSEBUTTONDOWN:
            case SDL_KEYDOWN:
                quit = true;
                break;
            }
        }
        SDL_RenderClear(ren);
        SDL_RenderCopy(ren, tex, &rectFrom, &destRect);
        SDL_RenderPresent(ren);
        SDL_Delay(500);
        rectFrom.x = (rectFrom.x + 256) % 512;
    }

    SDL_DestroyTexture(tex);
    SDL_DestroyRenderer(ren);
    IMG_Quit(); //***
    SDL_DestroyWindow(win);
    SDL_Quit();

    return 0;
}
Exemple #4
0
bool TEXTURE::LoadCubeVerticalCross(const std::string & path, const TEXTUREINFO & info, std::ostream & error)
{
	std::string cubefile = path;

	GLuint new_handle = 0;
	glGenTextures(1, &new_handle);
	OPENGL_UTILITY::CheckForOpenGLErrors("Cubemap ID generation", error);
	id = new_handle;

	glBindTexture(GL_TEXTURE_CUBE_MAP, new_handle);

	SDL_Surface * texture_surface = IMG_Load(cubefile.c_str());
	if (texture_surface)
	{
		for (int i = 0; i < 6; ++i)
		{
			w = texture_surface->w/3;
			h = texture_surface->h/4;

			//detect channels
			int format = GL_RGB;
			switch (texture_surface->format->BytesPerPixel)
			{
				case 1:
					format = GL_LUMINANCE;
					break;
				case 2:
					format = GL_LUMINANCE_ALPHA;
					break;
				case 3:
					format = GL_RGB;
					break;
				case 4:
					format = GL_RGBA;
					break;
				default:
					error << "Texture has unknown format: " + path << std::endl;
					return false;
					break;
			}

			if (format != GL_RGB)
			{
				//throw EXCEPTION(__FILE__, __LINE__, "Cube map texture format isn't GL_RGB (this causes problems for some reason): " + texture_path + " (" + cubefile + ")");
				//game.WriteDebuggingData("Warning:  Cube map texture format isn't GL_RGB (this causes problems for some reason): " + texture_path + " (" + cubefile + ")");
			}

			int offsetx = 0;
			int offsety = 0;

			GLenum targetparam;
			if (i == 0)
			{
				targetparam = GL_TEXTURE_CUBE_MAP_NEGATIVE_X;
				offsetx = 0;
				offsety = h;
			}
			else if (i == 1)
			{
				targetparam = GL_TEXTURE_CUBE_MAP_POSITIVE_X;
				offsetx = w*2;
				offsety = h;
			}
			else if (i == 2)
			{
				targetparam = GL_TEXTURE_CUBE_MAP_NEGATIVE_Y;
				offsetx = w;
				offsety = h*2;
			}
			else if (i == 3)
			{
				targetparam = GL_TEXTURE_CUBE_MAP_POSITIVE_Y;
				offsetx = w;
				offsety = 0;
			}
			else if (i == 4)
			{
				targetparam = GL_TEXTURE_CUBE_MAP_NEGATIVE_Z;
				offsetx = w;
				offsety = h*3;
			}
			else if (i == 5)
			{
				targetparam = GL_TEXTURE_CUBE_MAP_POSITIVE_Z;
				offsetx = w;
				offsety = h;
			}
			else
			{
				error << "Texture has unknown format: " + path << std::endl;
				return false;
			}

			unsigned char * cubeface = new unsigned char[w*h*texture_surface->format->BytesPerPixel];

			if (i == 4) //special case for negative z
			{
				for (unsigned int yi = 0; yi < h; yi++)
				{
					for (unsigned int xi = 0; xi < w; xi++)
					{
						for (unsigned int ci = 0; ci < texture_surface->format->BytesPerPixel; ci++)
						{
							int idx1 = ((h-yi-1)+offsety)*texture_surface->w*texture_surface->format->BytesPerPixel + (w-xi-1+offsetx)*texture_surface->format->BytesPerPixel + ci;
							int idx2 = yi*w*texture_surface->format->BytesPerPixel+xi*texture_surface->format->BytesPerPixel+ci;
							cubeface[idx2] = ((unsigned char *)(texture_surface->pixels))[idx1];
							//cout << idx1 << "," << idx2 << endl;
						}
					}
				}
			}
			else
			{
				for (unsigned int yi = 0; yi < h; yi++)
				{
					for (unsigned int xi = 0; xi < w; xi++)
					{
						for (unsigned int ci = 0; ci < texture_surface->format->BytesPerPixel; ci++)
						{
							int idx1 = (yi+offsety)*texture_surface->w*texture_surface->format->BytesPerPixel+(xi+offsetx)*texture_surface->format->BytesPerPixel+ci;
							int idx2 = yi*w*texture_surface->format->BytesPerPixel+xi*texture_surface->format->BytesPerPixel+ci;
							cubeface[idx2] = ((unsigned char *)(texture_surface->pixels))[idx1];
							//cout << idx1 << "," << idx2 << endl;
						}
					}
				}
			}
			glTexImage2D( targetparam, 0, format, w, h, 0, format, GL_UNSIGNED_BYTE, cubeface );
			delete [] cubeface;
		}
	}
	else
	{
		error << "Error loading texture file: " + path << std::endl;
		return false;
	}

	if (texture_surface)
	{
		// Free up any memory we may have used
		SDL_FreeSurface( texture_surface );
		texture_surface = NULL;
	}

	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

	if (info.mipmap)
	{
		glTexParameteri(GL_TEXTURE_CUBE_MAP,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_LINEAR);
		glTexParameteri(GL_TEXTURE_CUBE_MAP,GL_TEXTURE_MAG_FILTER,GL_LINEAR);

		if (GLEW_ARB_framebuffer_object)
		{
			glGenerateMipmap(GL_TEXTURE_CUBE_MAP);
		}
	}

	glDisable(GL_TEXTURE_CUBE_MAP);

	OPENGL_UTILITY::CheckForOpenGLErrors("Cubemap creation", error);

	return true;
}
Exemple #5
0
int main(int argc, char *argv[])
{
	// Erectin' a display
	SDL_Surface *screen;
	SDL_Init(SDL_INIT_EVERYTHING);
    screen = SDL_SetVideoMode(SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_BPP, SDL_HWSURFACE);
	
	
	
	SDL_WM_SetCaption("Smuggler Demo", "Smuggler Demo");
	bool quit = false;
	
	
	// Setting up text
	TTF_Font* Font=NULL;
	TTF_Init();
	SDL_Surface* TextSurface = NULL;
	
	
	Font=TTF_OpenFont("DejaVuSansMono.ttf",16);
	SDL_Color color;
	color.r=255;
	color.g=255;
	color.b=255;
	int FontSize = 10;
	bool growing = true;
	
	// Rendering surfaces

	
	// Set background surface to display optimized
	SDL_Surface *background;
	SDL_Surface *oldface;
	oldface = IMG_Load("backimage.png");
	background = SDL_DisplayFormat(oldface);
	SDL_FreeSurface(oldface);
	
	// Set player's image to 
	Player player1("ana.png");
	Player player2("character.png");
	player2.coordX(500);
	player2.coordY(500);
	
	// Load overlay surface and set transparency color to 0
	SDL_Surface *overlay = &map();
	SDL_SetColorKey(overlay, SDL_SRCCOLORKEY,0);
	
	
	// Instantiate timer object
	Timer fps;
	
	int walkFrames = 2;
	
	while(!quit){
		// Start the timer for frame rate limiting
		fps.start();
		
		// The input handling function returns a bool. While quit == false, the game will continue to run
		quit = input(&player1, movementspeed);
		
		// This function animates through the cycle, using an iterating number that triggers the different frames
		// TODO: The walkframes integer should be tucked into the object it is manipulating, in this case, player.
		walkFrames=animate(player1.xvel(), player1.yvel(), movementspeed, walkFrames, walkFrameInterval, &player1);
		
		// Renders the background on the bottom
		SDL_BlitSurface(background, NULL, screen, NULL);
		
		// Puts the player underneath the overlay, which is basically the map
		SDL_BlitSurface(&player1.image(), &player1.frame(), screen, &player1.location());

		// Checks for collisions
		if (collision(&player1.image(), player1.coordX(), player1.coordY(), 100, &player2.image(), player2.coordX(), player2.coordY(), 100))
		{
			cout << "COLLIDE!\n";
			player2.xvel(0);
			player2.yvel(0);
		}
		else
		{
			cout << "NO COLLIDE!\n";
			player2.ai(player1);
		}


		// Puts the NPC underneath the overlay

		walkFrames=animate(player2.xvel(), player2.yvel(), movementspeed/2, walkFrames, walkFrameInterval, &player2);
		SDL_BlitSurface(&player2.image(), &player2.frame(), screen, &player2.location());
		
		

		
		
		// Renders the map
		SDL_BlitSurface(overlay, NULL, screen, NULL);
		
		// Renders the text
		if (growing == true)
		{
			FontSize ++;
		}
		else
		{
			FontSize --;
		}
						
		if (FontSize == 25)
		{
			growing = false;
		}
		if (FontSize == 1)
		{
			growing = true;
		}
				
		Font=TTF_OpenFont("DejaVuSansMono.ttf",FontSize);
		TextSurface=TTF_RenderText_Solid(Font,"I love poop!!",color);
		SDL_BlitSurface(TextSurface, NULL, screen, &player2.speech_bubble());
		TTF_CloseFont(Font);
		SDL_FreeSurface(TextSurface);
		
		
		// Renders it all to the display
		SDL_Flip(screen);


		
		// For performance measuring purposes, this line spits out the max framerate possible if this rate of animation is sustained.
		// printf("Max Frames per second: %d\n", 1000/fps.get_ticks());
	
	// Hard locks the frame rate to 60 frames per second or less
	if(fps.get_ticks() < 1000 / FPS)
	{
		SDL_Delay ((1000/FPS) - fps.get_ticks());
	}
	
	}
    SDL_Quit();

}
Exemple #6
0
texture::texture()
{

    if (TTF_Init() == -1)
        throw MenuError(TTF_GetError());
    if (!(_font = TTF_OpenFont("src_graphic/res/DejaVuSans.ttf", 50)))
        throw ResError(TTF_GetError());

    addImage(IMG_Load("src_graphic/res/hud.png"), "HUD");
    int i = 0;
    std::string s;
    while (i < 300)
    {
        s = std::to_string(i);
        TextTotexture(s);
        i += 1;
    }
    TextTotexture("lvl:");
    TextTotexture("time:");

    addImage(IMG_Load("src_graphic/res/ground/Grass.png"), "GROUND");
    addImage(IMG_Load("src_graphic/res/ground/Gcorner.png"), "GCORNER");
    addImage(IMG_Load("src_graphic/res/ground/GEdge.png"), "GEDGE");
    addImage(IMG_Load("src_graphic/res/bg2.jpg"), "BG");
    addImage(IMG_Load("src_graphic/res/broadcast.png"), "BROADCAST");
    addImage(IMG_Load("src_graphic/res/lvlup.png"), "LVLUP");

    addImage(IMG_Load("src_graphic/res/gemme/food.png"), "food");
    addImage(IMG_Load("src_graphic/res/gemme/cyan.png"), "linemate");
    addImage(IMG_Load("src_graphic/res/gemme/green.png"), "deraumere");
    addImage(IMG_Load("src_graphic/res/gemme/lopez.png"), "sibur");
    addImage(IMG_Load("src_graphic/res/gemme/purple.png"), "Mendiane");
    addImage(IMG_Load("src_graphic/res/gemme/red.png"), "Phiras");
    addImage(IMG_Load("src_graphic/res/gemme/yellow.png"), "Thystame");
}
Exemple #7
0
bool TEXTURE::LoadCube(const std::string & path, const TEXTUREINFO & info, std::ostream & error)
{
	if (info.verticalcross)
	{
		return LoadCubeVerticalCross(path, info, error);
	}

	std::string cubefiles[6];
	cubefiles[0] = path+"-xp.png";
	cubefiles[1] = path+"-xn.png";
	cubefiles[2] = path+"-yn.png";
	cubefiles[3] = path+"-yp.png";
	cubefiles[4] = path+"-zn.png";
	cubefiles[5] = path+"-zp.png";

	GLuint new_handle = 0;
	glGenTextures(1, &new_handle);
	OPENGL_UTILITY::CheckForOpenGLErrors("Cubemap texture ID generation", error);
	id = new_handle;

	glBindTexture(GL_TEXTURE_CUBE_MAP, new_handle);

	for (unsigned int i = 0; i < 6; ++i)
	{
		SDL_Surface * texture_surface = IMG_Load(cubefiles[i].c_str());
		if (texture_surface)
		{
			//store dimensions
			if (i != 0 && (w != (unsigned int) texture_surface->w || h != (unsigned int) texture_surface->h))
			{
				error << "Cube map sides aren't equal sizes" << std::endl;
				return false;
			}
			w = texture_surface->w;
			h = texture_surface->h;

			//detect channels
			int format = GL_RGB;
			switch (texture_surface->format->BytesPerPixel)
			{
				case 1:
					format = GL_LUMINANCE;
					break;
				case 2:
					format = GL_LUMINANCE_ALPHA;
					break;
				case 3:
					format = GL_RGB;
					break;
				case 4:
					format = GL_RGBA;
					break;
				default:
					error << "Texture has unknown format: " + path + " (" + cubefiles[i] + ")" << std::endl;
					return false;
					break;
			}

			if (format != GL_RGB)
			{
				error << "Cube map texture format isn't GL_RGB (this causes problems for some reason): " + path + " (" + cubefiles[i] + ")" << std::endl;
				return false;
			}

			// Create MipMapped Texture

			GLenum targetparam;
			if (i == 0)
				targetparam = GL_TEXTURE_CUBE_MAP_NEGATIVE_X;
			else if (i == 1)
				targetparam = GL_TEXTURE_CUBE_MAP_POSITIVE_X;
			else if (i == 2)
				targetparam = GL_TEXTURE_CUBE_MAP_NEGATIVE_Y;
			else if (i == 3)
				targetparam = GL_TEXTURE_CUBE_MAP_POSITIVE_Y;
			else if (i == 4)
				targetparam = GL_TEXTURE_CUBE_MAP_NEGATIVE_Z;
			else if (i == 5)
				targetparam = GL_TEXTURE_CUBE_MAP_POSITIVE_Z;
			else
			{
				error << "Iterated too far: " + path + " (" + cubefiles[i] + ")" << std::endl;
				assert(0);
			}

			glTexImage2D( targetparam, 0, format,texture_surface->w, texture_surface->h, 0, format, GL_UNSIGNED_BYTE, texture_surface->pixels );
		}
		else
		{
			error << "Error loading texture file: " + path + " (" + cubefiles[i] + ")" << std::endl;
			return false;
		}

		if (texture_surface)
		{
			// Free up any memory we may have used
			SDL_FreeSurface( texture_surface );
			texture_surface = NULL;
		}
	}

	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

	glDisable(GL_TEXTURE_CUBE_MAP);

	OPENGL_UTILITY::CheckForOpenGLErrors("Cubemap creation", error);

	return true;
}
Exemple #8
0
int main(int argc, char *argv[]) {
	SDL_Event ev,az;
	SDL_Surface *screen;
	SDL_Surface *kep;
	SDL_TimerID id;
	FILE *fp;
	int x, y,click=0,clicktwo=0,aut=0,quit=0,gomb=0,egerx,egery,nothinghappened=1;
	cell cells[MAX][MAX]={0};

	kep=IMG_Load("sejt.png");
	if(!kep)
		fprintf(stderr, "Nem sikerult betolteni a kepfajlt!\n");

	/* SDL inicializálása és ablak megnyitása */
	SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER);
	screen=SDL_SetVideoMode(MAX*MERET+KERET*2+100, MAX*MERET+KERET*2-100, 0, SDL_FULLSCREEN);
	if (!screen) {
		fprintf(stderr, "Nem sikerult megnyitni az ablakot!\n");
		exit(1);
	} 
	SDL_WM_SetCaption("Game Of Life", "Game Of Life");
	
	SDL_FillRect(screen, NULL, 0x433e3f);
	boxColor(screen,KERET/3,KERET/3,MAX*MERET+KERET*2-KERET/3,MAX*MERET+KERET*2-KERET/3,KERETSZIN);

	drawcell(cells,screen,kep);



	while(!quit)
	{
		boxColor(screen, MAX*MERET+KERET*2+10,KERET+5,MAX*MERET+KERET*2+90,KERET+40,0xFFDFD2FF);
		boxColor(screen, MAX*MERET+KERET*2+14,KERET+9,MAX*MERET+KERET*2+86,KERET+36,0xE5C8BDFF);
		stringRGBA(screen, MAX*MERET+KERET*2+20, KERET+19, "Leptetes", 255, 255, 255, 255);

		boxColor(screen, MAX*MERET+KERET*2+10,KERET+5+HEZAG,MAX*MERET+KERET*2+90,KERET+40+HEZAG,0xFFDFD2FF);
		boxColor(screen, MAX*MERET+KERET*2+14,KERET+9+HEZAG,MAX*MERET+KERET*2+86,KERET+36+HEZAG,0xE5C8BDFF);
		if(aut==0)
			stringRGBA(screen, MAX*MERET+KERET*2+15, KERET+69, "Szimul.be", 255, 255, 255, 255);
		else
			stringRGBA(screen, MAX*MERET+KERET*2+15, KERET+69, "Szimul.ki", 255, 255, 255, 255);

		boxColor(screen, MAX*MERET+KERET*2+10,KERET+5+HEZAG*2,MAX*MERET+KERET*2+90,KERET+40+HEZAG*2,0xFFDFD2FF);
		boxColor(screen, MAX*MERET+KERET*2+14,KERET+9+HEZAG*2,MAX*MERET+KERET*2+86,KERET+36+HEZAG*2,0xE5C8BDFF);
		stringRGBA(screen, MAX*MERET+KERET*2+26, KERET+19+HEZAG*2, "Torles", 255, 255, 255, 255);

		boxColor(screen, MAX*MERET+KERET*2+10,KERET+5+HEZAG*3,MAX*MERET+KERET*2+90,KERET+40+HEZAG*3,0xFFDFD2FF);
		boxColor(screen, MAX*MERET+KERET*2+14,KERET+9+HEZAG*3,MAX*MERET+KERET*2+86,KERET+36+HEZAG*3,0xE5C8BDFF);
		stringRGBA(screen, MAX*MERET+KERET*2+27, KERET+19+HEZAG*3, "Kilovo", 255, 255, 255, 255);

		filledCircleColor(screen,MAX*MERET+2*KERET+80,9,8,0xFFDFD2FF);
		filledCircleColor(screen,MAX*MERET+2*KERET+80,9,6,0xE5C8BDFF);
		stringRGBA(screen,MAX*MERET+KERET*2+77,6,"X",255,255,255,255);
		
		SDL_Flip(screen);

		
		while(SDL_PollEvent(&ev)){
			switch(ev.type)
			{
				/*case SDL_KEYDOWN:
				switch(ev.key.keysym.sym)
				{
				case SDLK_s:
				mentes(cells);		   
				break;
				case SDLK_l:
				fp=fopen("save.txt","r");

				for(y=0;y<MAX;y++)
				for(x=0;x<MAX;x++)
				fscanf(fp,"%d ",&cells[y][x].alive);

				fclose (fp);

				drawcell(cells,screen,kep);
				SDL_Flip(screen);
				break;
				}
				break;*/

			case SDL_MOUSEBUTTONDOWN:
				if(ev.button.button==SDL_BUTTON_LEFT)
				{
					if(ev.button.x<=MAX*MERET+KERET){
						egerx=holazeger(ev.button.x);
						egery=holazeger(ev.button.y);

						if(cells[egery][egerx].alive==1)
							cells[egery][egerx].alive=0;
						else
							cells[egery][egerx].alive=1;
					}

					else if(incircle(ev.button.x,ev.button.y,MAX*MERET+2*KERET+80,9,8))
						quit=1;

					else if((ev.button.x<=MAX*MERET+KERET*2+90 && ev.button.x>=MAX*MERET+KERET*2+10) && (ev.button.y<=KERET+40 && ev.button.y>=KERET+5))//egyes lépés
					{
						round(cells);

					}
					else if((ev.button.x<=MAX*MERET+KERET*2+90 && ev.button.x>=MAX*MERET+KERET*2+10) && (ev.button.y<=KERET+90 && ev.button.y>=KERET+55))//szimulálás
					{
						if(aut==0)
							aut=1;
						else aut=0;	
					}
					else if((ev.button.x<=MAX*MERET+KERET*2+90 && ev.button.x>=MAX*MERET+KERET*2+10) && (ev.button.y<=KERET+40+HEZAG*2 && ev.button.y>=KERET+5+HEZAG*2))//egyes lépés
					{
						for(y=0;y<MAX;y++)
							for(x=0;x<MAX;x++)
								cells[y][x].alive=0;
					}
					else if((ev.button.x<=MAX*MERET+KERET*2+90 && ev.button.x>=MAX*MERET+KERET*2+10) && (ev.button.y<=KERET+40+HEZAG*3 && ev.button.y>=KERET+5+HEZAG*3))//egyes lépés
					{
						fp=fopen("save.txt","r");

						for(y=0;y<MAX;y++)
							for(x=0;x<MAX;x++)
								fscanf(fp,"%d ",&cells[y][x].alive);

						fclose (fp);

						drawcell(cells,screen,kep);
						SDL_Flip(screen);
					}
					drawcell(cells,screen,kep);
					SDL_Flip(screen);
				}
				break;

			case SDL_MOUSEBUTTONUP:
				if(ev.button.button==SDL_BUTTON_LEFT)
				{
					click=0;
					clicktwo=0;
				}
				break;

			case SDL_QUIT:
				quit=1;
				break;
			}
		}

		if(aut)
		{
			SDL_Delay(100);
			round(cells);
			drawcell(cells,screen,kep);
			SDL_Flip(screen);
		}


	}


	SDL_FreeSurface(kep);
	SDL_Quit();
	exit(0);
	return 0;
}
int
main(int argc, char *argv[])
{
	if(argc < 3)
	{
		printf("Usage: converter source.png target.raw [target bpp = 16 or 32]\n");
		return 1;
	}
	SDL_Surface * src = IMG_Load(argv[1]);
	if(!src)
		return 1;
	bool perPixeAlpha = true;
	bool target32bpp = false;
	if( argc >= 3 && strcmp(argv[3], "32") == 0 )
		target32bpp = true;
	/*
	if( src->format->BitsPerPixel == 32 )
	{
		for( int i = 0; i < src->h; i++ )
		{
			for( int ii = 0; ii < src->w; ii++ )
			{
				Uint32 alpha = (* (Uint32 *) ((Uint8 *)src->pixels + i*src->pitch + ii*4)) & src->format->Amask;
				if( src->format->Amask >= 0x000000ff )
					alpha /= 0x1000000;
				if( alpha > 15 && alpha < 240 )
				{
					perPixeAlpha = true;
					break;
				}
			}
		}
	}
	*/
	printf("Converter: %s BPP %d %dx%d perPixeAlpha %d target %d bpp\n", argv[1], src->format->BitsPerPixel, src->w, src->h, (int)perPixeAlpha, target32bpp ? 32 : 16);
	SDL_Surface * format1 = SDL_CreateRGBSurface( SDL_SWSURFACE|SDL_SRCALPHA, 1, 1, 16, 0xF800, 0x7C0, 0x3E, 0x1 );
	if( perPixeAlpha )
		format1 = SDL_CreateRGBSurface( SDL_SWSURFACE|SDL_SRCALPHA, 1, 1, 16, 0xF000, 0xF00, 0xF0, 0xF );
	if( target32bpp )
		format1 = SDL_CreateRGBSurface( SDL_SWSURFACE|SDL_SRCALPHA, 1, 1, 32, 0xFF, 0xFF00, 0xFF0000, 0xFF000000 );
	if(!format1)
		return 1;
	SDL_Surface * dst = SDL_ConvertSurface(src, format1->format, SDL_SWSURFACE|SDL_SRCALPHA);
	if(!dst)
		return 1;
	FILE * ff = fopen(argv[2], "wb");
	if(!ff)
		return 1;
	int w = htonl(dst->w);
	fwrite( &w, 1, 4, ff );
	int h = htonl(dst->h);
	fwrite( &h, 1, 4, ff );
	int format = htonl(target32bpp ? 2 : (perPixeAlpha ? 1 : 0));
	fwrite( &format, 1, 4, ff );
	for( int i = 0; i < dst->h; i++ )
	{
		for( int ii = 0; ii < dst->w; ii++ )
		{
			if( (!target32bpp) && (
				* (Uint16 *) ((Uint8 *)dst->pixels + i*dst->pitch + ii*2) & 0x1 == 0 && ! perPixeAlpha) )
				* (Uint16 *) ((Uint8 *)dst->pixels + i*dst->pitch + ii*2) = 0;
			fwrite( (Uint8 *)dst->pixels + i*dst->pitch + ii*(target32bpp?4:2), 1, (target32bpp?4:2), ff );
		}
	}
	fclose(ff);
	return 0;
}
int LancerJeu(gpointer *pData)
{
    /* Cette fonction va appeler les fonctions d'initialisations de la SDL et lancer le jeu ou l'éditeur */

    SDL_Renderer *pMoteurRendu = NULL;  //Pointeurs sur le moteur de rendu
    SDL_Window *pFenetre = NULL;        //Pointeur sur la fenêtre
    FMOD_CHANNEL *channelEnCours = NULL;    //Pour le contrôle des différents canaux audios

    Sprite images[50] = {{NULL}, {0,0}};   //Tableau des images (textures + positions)
    TTF_Font *polices[10] = {NULL};		//Tableau des polices

    Options *pOptions = NULL;	//Pointeur sur une structure Options

    FILE *pFichierErreur = fopen("ressources/ErreursLog.txt", "a");        //Pointeur sur le fichier d'erreurs

    SDL_Surface *surf = NULL;	//Pointeur sur une surface
    SDL_Texture *pEcranChargement = NULL;	//Pointeur sur une texture pour l'écran de chargement

    Animation anim[10];	//Tableau de structures Animation

    int erreur=0;	//Code d'erreur

    Joueur *pJoueur = (Joueur *)g_slist_nth_data((GSList*)pData, 6);	//On récupère le pointeur vers la structure Joueur dans la liste chaînée
    Sons *pSons = (Sons*)g_slist_nth_data((GSList*)pData, 4);		//De même avec celui vers la structure Sons
    FMOD_SYSTEM *pMoteurSon = (FMOD_SYSTEM *)g_slist_nth_data((GSList*)pData, 3);	//De même avec celui vers la structure FMOD_SYSTEM

    if(pFichierErreur == NULL)	//Vérification
    {
        exit(EXIT_FAILURE);
    }

    /* On lit les options et on remplit la structure */
    pOptions = DefinirOptions();

    Initialisation(&pMoteurRendu, pFichierErreur, &pFenetre, pOptions);     //Initialisation des principaux éléments (SDL, fenêtre, moteur de rendu)

    FMOD_System_GetChannel(pMoteurSon, M_MENU, &channelEnCours);	//On met en pause la musique du menu
    FMOD_Channel_SetPaused(channelEnCours, true);

    if(BMusique)	//S'il y a de la musique
    {
        FMOD_System_PlaySound(pMoteurSon, M_LOAD, pSons->music[M_LOAD], true, NULL);        // On lit la musique de chargement
        FMOD_System_GetChannel(pMoteurSon, M_LOAD, &channelEnCours);
        FMOD_Channel_SetVolume(channelEnCours, (float)(Volume/100.0));
        FMOD_Channel_SetPaused(channelEnCours, false);
    }

    /* On charge l'image de chargement et on vérifie */
    surf = IMG_Load("ressources/img/load.png");

    if (surf == NULL)
    {
        fprintf(pFichierErreur, "Erreur: impossible d'ouvrir le fichier ressources/img/load.png");
        exit(EXIT_FAILURE);
    }

    /* On transforme la surface en texture pour l'affichage et on libère la mémoire occupée par la surface */
    pEcranChargement = SDL_CreateTextureFromSurface(pMoteurRendu, surf);
    SDL_FreeSurface(surf);

    SDL_ShowCursor(false);	//On masque le curseur pendant le jeu (on affichera un curseur personnalisé dans l'éditeur)

    /* On efface l'écran et on colle l'image de chargement */
    SDL_SetRenderDrawColor(pMoteurRendu, 0, 0, 0, SDL_ALPHA_OPAQUE);
    SDL_RenderClear(pMoteurRendu);
    SDL_RenderCopy(pMoteurRendu, pEcranChargement, NULL, NULL);
    SDL_RenderPresent(pMoteurRendu);

    SDL_EventState(SDL_TEXTEDITING, SDL_DISABLE);   //Désactivation des événements dont on a pas besoin.
    SDL_EventState(SDL_TEXTINPUT, SDL_DISABLE);

    SDL_DisableScreenSaver();       //Désactivation de l'écran de veille.

    erreur = Chargements(images, pMoteurRendu, polices, anim);	//On charge tout !

    /* Traitement des éventuelles erreurs */
    if(erreur == 1)
    {
        fprintf(pFichierErreur, "Erreur lors du chargement des images. Veuillez vérifier ressources\\img\\... \n");
        exit(EXIT_FAILURE);
    }
    else if (erreur == 2)
    {
        fprintf(pFichierErreur, "Erreur lors du chargement des polices. Veuillez vérifier ressources\\fonts\\... \n");
        exit(EXIT_FAILURE);
    }
    else if (erreur == 3)
    {
        fprintf(pFichierErreur, "Erreur lors du chargement des animations. Veuillez vérifier ressources\\anim\\... \n");
        exit(EXIT_FAILURE);
    }

    if (BMusique)
    {
        FMOD_System_GetChannel(pMoteurSon, M_LOAD, &channelEnCours);	//On arrête la musique du chargement
        FMOD_Channel_SetPaused(channelEnCours, true);

        FMOD_Sound_SetLoopCount(pSons->music[M_JEU], -1);      // On active la lecture en boucle

        FMOD_System_PlaySound(pMoteurSon, M_JEU, pSons->music[M_JEU], true, NULL);        // On lit la musique du jeu
        FMOD_System_GetChannel(pMoteurSon, M_JEU, &channelEnCours);
        FMOD_Channel_SetVolume(channelEnCours, (float)(Volume/100.0));
        FMOD_Channel_SetPaused(channelEnCours, false);
    }

    /* On regarde si on a appelé la fonction en mode jeu ou en mode éditeur */
    if (pJoueur->mode == MODE_CAMPAGNE)
    {
        InitialiserInfos(pOptions, pJoueur);	//On définit les infos sur la partie en cours
        erreur = BouclePrincipale(pJoueur, images, anim, pMoteurRendu, pMoteurSon, pSons, polices);    //Boucle du jeu

        if(erreur == JEU_FIN_ERREUR_CHARGEMENT)
        {
            MessageInformations("Erreur lors du chargement d'un niveau, consultez le fichier erreurs.txt", polices, pMoteurRendu, NULL);
        }

        SauverMySql(pJoueur);	//On sauvegarde l'avancée du joueur
    }
    else if(pJoueur->mode == MODE_PERSO)
    {
        InitialiserInfos(pOptions, pJoueur);	//On définit les infos sur la partie en cours
        erreur = BouclePrincipale(pJoueur, images, anim, pMoteurRendu, pMoteurSon, pSons, polices);    //Boucle du jeu

        if(erreur == JEU_FIN_ERREUR_CHARGEMENT)
        {
            MessageInformations("Erreur lors du chargement d'un niveau, consultez le fichier erreurs.txt", polices, pMoteurRendu, NULL);
        }
    }
    else if (pJoueur->mode == MODE_EDITEUR)
    {
        erreur = Editeur(pMoteurRendu, images, pMoteurSon, pSons, polices, pJoueur);	//On lance la boucle de l'éditeur

        if(erreur == JEU_FIN_ERREUR_CHARGEMENT)
        {
            MessageInformations("Erreur lors du chargement d'un niveau, consultez le fichier erreurs.txt", polices, pMoteurRendu, NULL);
        }
    }

    /* Libération de la mémoire */
    LibererMemoire(pMoteurRendu, images, anim, polices, pFenetre, pOptions);

    fclose(pFichierErreur);	//On ferme le fichier d'erreur

    return 0;
}
Exemple #11
0
int main ( int argc, char** argv )
{
    //make sure we have all the necessary arguments
    if( argc < 4 )
    {
        fprintf(stderr, "Usage: %s (input texture filename) (texton neighborhood diameter) \n", argv[0]);
        fprintf(stderr, "                (output size) [number threads] [r weight] [g weight] [b weight]\n");
        fprintf(stderr, "   Options in () are required, options in [] are optional.\n");
		fprintf(stderr, "        Note that if you want to set r weight, number threads must be set too.\n");
        fprintf(stderr, "   Input texture reading is handled by SDL_Image so the file can be tga, bmp, \n");
        fprintf(stderr, "         pnm, xpm, xcf, pcx, gif, jpg, lbm, or png.\n");
        fprintf(stderr, "   If [number threads] is set to 0, no threads will be generated. If it is set\n");
        fprintf(stderr, "         to 1, one thread will be generated to do all the work. Default is %d.\n", TEX_SYN_THREADS);
        fprintf(stderr, "   [rgb weight] defines how much weight to give to the r, g, and b channels\n");
        fprintf(stderr, "         when calculating the similarity between two neighborhoods.\n");
        fprintf(stderr, "         These values are only used if rgb weighting is enabled in the code.\n");
        fprintf(stderr, "         Default Values are %f, %f, and %f respectively.\n", TEX_SYN_RED_WEIGHT, TEX_SYN_GREEN_WEIGHT, TEX_SYN_BLUE_WEIGHT);
        exit(EXIT_FAILURE);
    }
    //looks good, start loading values:

    //diameter
    textonDiameter = atoi(argv[2]);
    //make sure textonDiameter is odd, add one to it if it is even.
    if(textonDiameter % 2 == 0)
        textonDiameter++;

	//output size
    outputSize = atoi(argv[3]);

    //# threads
    if(argc >= 5)
    	TEX_SYN_THREADS = atoi(argv[4]);

    //r weight
    if(argc >= 6)
    	TEX_SYN_RED_WEIGHT = atof(argv[5]);

    //g weight
    if(argc >= 7)
    	TEX_SYN_GREEN_WEIGHT = atof(argv[6]);

    //b weight
    if(argc >= 8)
    	TEX_SYN_BLUE_WEIGHT = atof(argv[7]);

    debug("Will generate texture using file %s as a kernel and\n", argv[1]);
    debug("\tneighborhood size %d to generate unique %d x %d texture\n", textonDiameter, outputSize, outputSize);
#ifdef TEX_SYN_USE_MULTIRESOLUTION
	debug("\twith a multi-resolution synthesis algorithm.\n");
#else
	debug("\twith a single-resolution synthesis algorithm.\n");
#endif
	if(TEX_SYN_THREADS == 0)
		debug("No threads will be generated to compare neighborhoods.\n");
	else
		debug("%d threads will be generated to compare neighborhoods.\n", TEX_SYN_THREADS);
#ifdef TEX_SYN_WEIGHTED_COLORS
	debug("When comparing neighborhoods, red, green, and blue will be weighted\n");
	debug("\twith the values %f, %f, and %f respectively\n", TEX_SYN_RED_WEIGHT, TEX_SYN_GREEN_WEIGHT, TEX_SYN_BLUE_WEIGHT);
#else
	debug("When comparing neighborhoods, red, green, and blue will not be weighted\n");
#endif

    //initialize SDL
    debug("Initializing SDL\n");
    initSDL(outputSize, outputSize);

    // load an image
    debug("Loading Image %s\n", argv[1]);
    SDL_Surface *loadedTexture = IMG_Load(argv[1]);
    if (!loadedTexture)
    {
        printf("Unable to load image %s: %s\n", argv[1], SDL_GetError());
        return 1;
    }

    //convert to be the same format as the display (32 bit)
    debug("Convert input texture to useable format\n");
    inputTexture = SDL_DisplayFormat(loadedTexture);
    SDL_FreeSurface(loadedTexture);

    //run the texture synthesis
	SDL_Surface *outputTexture = textureSynthesis(inputTexture, outputSize, outputSize);

	//this is the texture that will be rendered on screen:
	SDL_Surface *renderTexture = outputTexture;
    // centre the bitmap on screen
    SDL_Rect dstrect;
    dstrect.x = (screen->w - renderTexture->w) / 2;
    dstrect.y = (screen->h - renderTexture->h) / 2;

    // program main loop
    debug("Entering display loop...\n");
    while (!checkEvents())
    {
        // DRAWING STARTS HERE

        // clear screen
        SDL_FillRect(screen, 0, SDL_MapRGB(screen->format, 255, 255, 255));

        // draw bitmap
        SDL_BlitSurface(renderTexture, 0, screen, &dstrect);

        // DRAWING ENDS HERE

        // finally, update the screen :)
        SDL_Flip(screen);
    } // end main loop

	//save output texture
	char stripped[256];
	char outName[256];
	int start = 0, end = 0;
	for(int i = strlen(argv[1]) - 1; i>=0; i--)
	{
		if( argv[1][i] == '/' && i > start )
			start = i + 1;
		if( argv[1][i] == '.' && i > end )
			end = i;
	}
	int i = 0;
	for( int n = start; n < end; n++, i++)
		stripped[i] = argv[1][n];
	stripped[i] = '\0';

	sprintf(outName, "synthesizedTextures/%s-%dx%d,%d.bmp", stripped, outputSize, outputSize, textonDiameter);
	debug("Saving the output image to %s\n", outName);
	if(SDL_SaveBMP(outputTexture, outName) < 0)
	{
		fprintf(stderr, "ERROR saving output texture to file %s: %s\n", outName, SDL_GetError());
		exit(EXIT_FAILURE);
	}

	debug("Cleaning up\n");
    // free loaded bitmap
    SDL_FreeSurface(inputTexture);
    SDL_FreeSurface(outputTexture);

	//note, sdl_quit doesn't need to be here because it's told to run
	//on quit in the init function.
    return 0;
}
Exemple #12
0
int main(int argc, char* argv[])
{
    const unsigned int windowWidth = 640;
    const unsigned int windowHeight = 480;

    SDL_Window* pWindow = NULL; // Ecran principal
    SDL_Surface* pImage = NULL; // Logo
    char mustContinue = 1; // Indicateur boolean pour la boucle principale

    int imgFlags = IMG_INIT_JPG|IMG_INIT_PNG|IMG_INIT_TIF; // Flags pour charger le support du JPG, PNG et TIF
    const char* imagePath = "./data/logo.jpg";

    SDL_Rect blitDestination;

    TTF_Font* pFont = NULL;
    const char* fontPath = "./data/font.ttf";
    SDL_Color fontColor = {99, 140, 222};
    SDL_Surface* pFontSurface = NULL;
    SDL_Rect texteDestination;

    // Demarre SDL
    if ( SDL_Init(SDL_INIT_VIDEO) == -1 )
    {
        fprintf(stderr,"Erreur lors de l'initialisation de la SDL\n");
        return -1;
    }

    if ( IMG_Init(imgFlags) != imgFlags )
    {
        fprintf(stderr,"Erreur lors de l'initialisation de la SDL_image : '%s'\n",IMG_GetError());
        cleanup();
        return -1;
    }

    if ( TTF_Init() == -1 )
    {
        fprintf(stderr,"Erreur lors de l'initialisation de la SDL_TTF : '%s'\n",TTF_GetError());
        cleanup();
        return -1;
    }

    /* Création de la fenêtre */
    pWindow = SDL_CreateWindow("Ma première application SDL2",SDL_WINDOWPOS_UNDEFINED,
                                                              SDL_WINDOWPOS_UNDEFINED,
                                                              640,
                                                              480,
                                                              SDL_WINDOW_SHOWN);
    if ( pWindow != NULL )
    {
        pImage = IMG_Load(imagePath);
        if ( pImage == NULL )
        {
            fprintf(stderr,"Erreur de chargement de l'image %s : %s\n",imagePath,IMG_GetError());
            SDL_DestroyWindow(pWindow);
            cleanup();
            return -3;
        }

        // Charge la police
        pFont = TTF_OpenFont(fontPath,32);
        if ( pFont == NULL )
        {
            fprintf(stderr,"Erreur de chargement de la police %s : %s\n",fontPath,TTF_GetError());
            SDL_DestroyWindow(pWindow);
            cleanup();
            return -3;
        }

        // Genere la SDL_Surface a partir de la police
        pFontSurface = TTF_RenderText_Solid(pFont,"Developpez.com",fontColor);
        if ( !pFontSurface )
        {
            fprintf(stderr,"Erreur pour generer le texte '%s'\n",TTF_GetError());
            SDL_DestroyWindow(pWindow);
            cleanup();
            return -4;
        }

        // Une fois l'image chargée, nous pouvons calculer une position relative à celle-ci
        // Nous centrons l'image dans la fenêtre
        blitDestination.x = windowWidth/2 - pImage->w/2;
        blitDestination.y = windowHeight/2 - pImage->h/2;
        blitDestination.w = pImage->w;
        blitDestination.h = pImage->h;

        // Nous avons notre surface pour le texte donc nous calculons la position relative
        // Le texte est à un quart de la hauteur de l'ecran
        texteDestination.x = windowWidth/2 - pFontSurface->w/2;
        texteDestination.y = windowHeight/4;
        texteDestination.w = pFontSurface->w;
        texteDestination.h = pFontSurface->h;

        // Boucle principale
        while ( mustContinue )
        {
            // Affiche le logo au centre de la fenêtre
            if ( SDL_BlitSurface(pImage,NULL,SDL_GetWindowSurface(pWindow),&blitDestination) != 0 )
            {
                fprintf(stderr,"Erreur de copie de la surface sur l'écran\n");
                mustContinue=0;
            }
            // Affiche le texte
            if ( SDL_BlitSurface(pFontSurface,NULL,SDL_GetWindowSurface(pWindow),&texteDestination) != 0 )
            {
                fprintf(stderr,"Erreur de copie du texte sur l'écran\n");
                mustContinue=0;
            }
            SDL_UpdateWindowSurface(pWindow);

            SDL_Event event;
            SDL_WaitEvent(&event);

            // Detecte si on clique sur la croix
            if( event.type == SDL_QUIT )
            {
                //On quitte le programme
                mustContinue = 0;
            }
            // Detecte si une touche est appuyee
            else if( event.type == SDL_KEYDOWN )
            {
                if ( event.key.keysym.sym == SDLK_ESCAPE )
                {
                    mustContinue = 0;
                }
            }
        }

        SDL_DestroyWindow(pWindow);
        SDL_FreeSurface(pFontSurface);
        TTF_CloseFont(pFont);
        SDL_FreeSurface(pImage);
    }
    else
    {
        fprintf(stderr,"Erreur de création de la fenêtre: %s\n",SDL_GetError());
        cleanup();
        return -3;
    }

    cleanup();

    return 0;
}
Exemple #13
0
int main( int argc, char* args[] )
{
    //Initialize
    init();
    update=new Timer();
    update->start();

    SDL_Surface * game_over = IMG_Load( "game_over.png" );


    Background background(screen);
    Player player(screen);
    Enemy enemy(screen);
    Enemy enemy2(screen);
    Llama Llama(screen);

    SDL_Event event;
    //Quit flag
    bool quit = false;
    while( quit == false )
    {
        //If there's an event to handle
        if( SDL_PollEvent( &event ) )
        {
            //If a key was pressed
            if( event.type == SDL_KEYDOWN )
            {
                //Set the proper message surface
                switch( event.key.keysym.sym )
                {
                    case SDLK_ESCAPE: quit = true; break;
                    case SDLK_UP:
                        if (! player.isJumping){
                            player.jump(); break;
                        }


                }
            }
            //If the user has Xed out the window
            else if( event.type == SDL_QUIT )
            {
                //Quit the program
                quit = true;
            }
        }

        background.logic();
        player.logic();
        enemy.logic();
        enemy2.logic2();
        Llama.logic();

        if(player.x-enemy.x<50
           && player.x-enemy.x>-50
           && player.y-enemy.y<50
           && player.y-enemy.y>-50
            or player.x-Llama.x<50
           && player.x-Llama.x>-50
           && player.y-Llama.y<50
           && player.y-Llama.y>-50)
        {
            player.perder();
        }

        if(player.x-enemy2.x<50
           && player.x-enemy2.x>-50
           && player.y-enemy2.y<50
           && player.y-enemy2.y>-50
           or player.x-Llama.x<50
           && player.x-Llama.x>-50
           && player.y-Llama.y<50
           && player.y-Llama.y>-50)
        {
           player.perder();
        }

        if (player.murio)
                break;
        background.render();
        player.render();
        enemy.render();
        enemy2.render();
        Llama.render();

        frameCap();

        //Update the screen
        if( SDL_Flip( screen ) == -1 )
        {
            return 1;
        }

    }

    while( quit == false )
    {
        //If there's an event to handle
        if( SDL_PollEvent( &event ) )
        {
            //If a key was pressed
            if( event.type == SDL_KEYDOWN )
            {
                //Set the proper message surface
                switch( event.key.keysym.sym )
                {
                    case SDLK_ESCAPE: quit = true; break;
                }
            }
            //If the user has Xed out the window
            else if( event.type == SDL_QUIT )
            {
                //Quit the program
                quit = true;
            }
        }

        //SDL_Rect offset;
        offset.x = 0;
        offset.y = 0;


        SDL_BlitSurface( game_over, NULL, screen, &offset );

        frameCap();

        //Update the screen
        if( SDL_Flip( screen ) == -1 )
        {
            return 1;
        }
    }

    //SDL_Quit();

    return 0;
}
Exemple #14
0
int main(int argc, char *argv[])
{

printf ("\nDemarage du programme\n");

// Declaration de variables.	

    SDL_Surface *ecran = NULL, *Fond = NULL, *titre = NULL, *texte1 = NULL, *texte2 = NULL, *texte3 = NULL, *texte4 = NULL;
    SDL_Rect positionFond;
    SDL_Rect positiontitre;
    SDL_Rect positiontexte1;
    SDL_Rect positiontexte2;
    SDL_Rect positiontexte3;
    SDL_Rect positiontexte4;

    SDL_Event event;

    positionFond.x = 0;
    positionFond.y = 0;

	TTF_Font *police = NULL, *police1 = NULL;
	SDL_Color blanc = {255, 255, 255};

    int continuer = 1;
    int enpause = 0;
    
    struct options options = {0};

// Fin de la declaration de variables

    SDL_Init(SDL_INIT_VIDEO);
    TTF_Init(); 

    SDL_WM_SetCaption("CHESS", NULL);
    SDL_WM_SetIcon(IMG_Load("img/icon.gif"), NULL);
    ecran = SDL_SetVideoMode(400, 400, 32, SDL_HWSURFACE);

    Fond = IMG_Load("img/background.png");
    police = TTF_OpenFont("img/police.ttf", 15);
    police1 = TTF_OpenFont("img/police.ttf", 50);

    chargeroption (&options);
    
	while (continuer)
	{

	    SDL_BlitSurface(Fond, NULL, ecran, &positionFond);
		if ( enpause == 0)
		{
			titre = TTF_RenderText_Blended(police1, "CHESS", blanc);			
		}
		else if ( enpause == 1 )
		{
			titre = TTF_RenderText_Blended(police1, "PAUSE", blanc);
		}

			positiontitre.x = (( 400 - titre->w) / 2);
        		positiontitre.y = 20;
			SDL_BlitSurface(titre, NULL, ecran, &positiontitre);
			texte1 = TTF_RenderText_Blended(police, "[A] Nouvelle partie", blanc);
			texte2 = TTF_RenderText_Blended(police, "[Z] Continuer", blanc);
			texte3 = TTF_RenderText_Blended(police, "[E] Options", blanc);
			texte4 = TTF_RenderText_Blended(police, "[R] Quitter", blanc);
			positiontexte1.x = (( 400 - texte1->w) / 2);
        		positiontexte1.y = 100;
			positiontexte2.x = positiontexte1.x;
        		positiontexte2.y = 150;
			positiontexte3.x = positiontexte1.x;
        		positiontexte3.y = 200;
			positiontexte4.x = positiontexte1.x;
        		positiontexte4.y = 250;
			SDL_BlitSurface(texte1, NULL, ecran, &positiontexte1);
			SDL_BlitSurface(texte2, NULL, ecran, &positiontexte2);
			SDL_BlitSurface(texte3, NULL, ecran, &positiontexte3);
			SDL_BlitSurface(texte4, NULL, ecran, &positiontexte4);
	    
	    SDL_Flip(ecran);

	    SDL_WaitEvent(&event); // Récupèration de l'évènement dans event 
	    switch(event.type) // Test du type d'évènement 
	    {
		case SDL_QUIT: // Si c'est un évènement de type "Quitter" 
		    continuer = 0;
		    break;
		case SDL_KEYDOWN:
			switch(event.key.keysym.sym)
			{
			    case SDLK_ESCAPE: // ECHAP
				continuer = 0;
				break;
			    case SDLK_SPACE: // (SPACE) ==> Jouer
				if (options.o2 > 0) {printf ("\nLancement d'une nouvelle partie.\n"); }
				jouer(ecran, options, &enpause, 0);
				break;
			    case SDLK_o: //(O) ==> Options
				option(ecran, &options);
				break;
			    case SDLK_a: // (A) ==> Jouer
				if (options.o2 > 0) {printf ("\nLancement d'une nouvelle partie.\n"); }
				jouer(ecran, options, &enpause, 0);
				break;
			    case SDLK_z: // (E) ==> Continuer
				if (options.o2 > 0) {printf ("\nReprise d'une partie en cours.\n"); }
				jouer(ecran, options, &enpause, 1);
				break;
			    case SDLK_e: // (E) ==> Option
				option(ecran, &options);
				break;
			    case SDLK_r: //(R) ==> Quitter
				if (options.o2 > 0) { printf ("\nFermeture du programme.\n"); }
				continuer = 0;
				break;
			}
        	break;

	    }
	}


    SDL_FreeSurface(Fond);
    SDL_Quit(); 

    return EXIT_SUCCESS;
}
void loadBackground(SDL_Renderer* renderer, Gamestate* game, SDL_Surface* surface)
{
  surface = IMG_Load("images/terraria_background.png");
  game->background = SDL_CreateTextureFromSurface(renderer, surface);
  SDL_FreeSurface(surface);
} // void loadBackground()
Exemple #16
0
int main(void)
{
//    int good = 0;
//    int numeroMap = 0;
//    do{
//        printf("Quelle map?\n");
//        printf("1 - Original\n");
//        printf("2 - Hard\n");
//        printf("3 - Lol\n");
//        printf("4 - Rez De chaussez Aile Sud Telecom Nancy\n");
//        scanf("%d", &numeroMap);
//        switch(numeroMap){
//            case 1:
//                loadMap("../projec/map/original.map");
//                good = 1;
//                break;
//            case 2:
//                loadMap("../projec/map/hard.map");
//                good = 1;
//                break;

//            case 3:
//                loadMap("../projec/map/maplol.map");
//                good = 1;
//                break;
//            case 4:
//                loadMap("../projec/map/rdastn.map");
//                good = 1;
//                break;

//            case 42:
//                loadMap("../projec/map/rdastn.map");
//                good = 1;
//                setQ();
//                break;
//        }
//    }while(!good);
    //Create SDL objects
    SDL_Window *window = 0;
    SDL_Event event;
    SDL_Renderer *renderer = 0;
    int terminate = 0;

    //Initialise SDL
    if(SDL_Init(SDL_INIT_VIDEO) < 0){
        printf("Error with SDL : %s\n", SDL_GetError());
        SDL_Quit();
        return EXIT_FAILURE;
    }

    window = SDL_CreateWindow("Pacman", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 544, 344, SDL_WINDOW_SHOWN);
    terminate = 0;
    renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
    SDL_Surface *menu = IMG_Load("../projec/texture/menu/menu.jpg");

    SDL_Texture *menuTexture = SDL_CreateTextureFromSurface(renderer, menu);

    SDL_FreeSurface(menu);
    SDL_RenderClear(renderer);
    int x, y;
    while(!terminate){
        SDL_Rect dest = {0, 0, 544, 344};
        SDL_RenderCopy(renderer, menuTexture, NULL, &dest);
        SDL_RenderPresent(renderer);
        SDL_WaitEvent(&event);
        switch(event.type){
            case SDL_MOUSEBUTTONDOWN:
                x = event.motion.x;
                y = event.motion.y;
                if(x >= 57 && x <= (57+54) && y >=  94 && y <= (94 + 74)){
                    loadMap("../projec/map/original.map");
                    terminate = 1;
                }
                if(x >= 124 && x <= (124+53) && y >=  208 && y <= (208 + 73)){
                    loadMap("../projec/map/hard.map");
                    terminate = 1;
                }
                if(x >= 221 && x <= (221+59) && y >=  95 && y <= (95 + 80)){
                    loadMap("../projec/map/maplol.map");
                    terminate = 1;
                }
                if(x >= 311 && x <= (311+63) && y >=  208 && y <= (208 + 76)){
                    loadMap("../projec/map/rdastn.map");
                    terminate = 1;
                }
                if(x >= 350 && x <= (350+124) && y >=  73 && y <= (73 + 109)){
                    loadMap("../projec/map/rdastn.map");
                    terminate = 1;
                    setQ();
                }
                break;
        }

        SDL_Delay(1000 / FPS);
    }
    SDL_DestroyTexture(menuTexture);

    SDL_DestroyRenderer(renderer);
    SDL_DestroyWindow(window);

    //Search the pacman on the map and create him
    Pacman *pacman = getPacmanInstance();
    unsigned int initialX = pacman->x;
    unsigned int initialY = pacman->y;
    Map *map = getMapInstance();
    //If the pacman is not found
    if(!pacman){
        printf("Pacman not found on map\n");
        freeMap(map);
        exit(EXIT_FAILURE);
    }
    printf("Pacman found !\n");

    Ghost *clyde = searchAndCreateGhost(CLYDE);
    if(!clyde){
        printf("Clyde not found on map\n");
        freeMap(map);
        exit(EXIT_FAILURE);
    }
    printf("Clyde found !\n");

    Ghost *blinky = searchAndCreateGhost(BLINKY);
    if(!blinky){
        printf("Blinky not found on map\n");
        freeMap(map);
        freeGhost(clyde);
        exit(EXIT_FAILURE);
    }
    printf("Blinky found !\n");

    Ghost *inky = searchAndCreateGhost(INKY);
    if(!inky){
        printf("Inky not found on map\n");
        freeMap(map);
        freeGhost(clyde);
        freeGhost(blinky);
        exit(EXIT_FAILURE);
    }
    printf("Inky found !\n");

    Ghost *pinky = searchAndCreateGhost(PINKY);
    if(!pinky){
        printf("Pinky not found on map\n");
        freeMap(map);
        freeGhost(clyde);
        freeGhost(blinky);
        freeGhost(inky);
        exit(EXIT_FAILURE);
    }
    printf("Pinky found !\n");
    printf("SDL initialisation\n");



    if(Mix_OpenAudio(44100, MIX_DEFAULT_FORMAT, 2, 4096) == -1){
        printf("%s", Mix_GetError());
    }

    Mix_Music *music = NULL;
    music = Mix_LoadMUS("../projec/pacman.wav");
    if(!music){
        printf("Erreur de chargement de la musique %s \n", Mix_GetError());
    }else{
        Mix_VolumeMusic(MIX_MAX_VOLUME);
        Mix_PlayMusic(music, -1);
    }

    if(TTF_Init() == -1){
        printf("Error during TTF initialization : %s\n", TTF_GetError());
    }

    TTF_Font *police = NULL;

    police = TTF_OpenFont("../projec/monof.ttf", 65);
    if(!police){
        printf("Error during font load : %s\n", TTF_GetError());
    }
    SDL_Color color = { 255, 255, 255, 255};



    //Create the window
    window = SDL_CreateWindow("Pacman", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, TILE_SIZE * map->col, TILE_SIZE * map->row + TILE_SIZE, SDL_WINDOW_SHOWN);

    //If there is an error
    if(window == 0){
        printf("Error during window creation : %s \n", SDL_GetError());
        SDL_Quit();
        freeMap(map);
        return EXIT_FAILURE;
    }
    int j;
    printf("SDL init success\n");
    renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);

    //NEED gerer erreurs

    loadTextures(renderer);

    SDL_Surface *score = TTF_RenderText_Solid(police, "Score : ", color);
    SDL_Texture *scoreT = SDL_CreateTextureFromSurface(renderer, score);
    SDL_FreeSurface(score);
    char scoreString[15];

    SDL_Rect dest = {0, map->row * TILE_SIZE , map->row * TILE_SIZE / 6, 20};
    SDL_RenderCopy(renderer, scoreT, NULL, &dest);
    SDL_Surface *scoreN;
    SDL_Texture *scoreTN;
    int open = 0;
    int konami[10] = {0,0,0,0,0,0,0,0,0,0};
    //Infinite loop until we want to stop the game
    terminate = 0;
    while(!terminate){
        SDL_Rect dest2 = {map->row * TILE_SIZE / 6, map->row * TILE_SIZE, map->row * TILE_SIZE / 15, 20};
        sprintf(scoreString, "%d", pacman->point);
        scoreN = TTF_RenderText_Solid(police, scoreString, color);
        scoreTN = SDL_CreateTextureFromSurface(renderer, score);
        renderMap(renderer);
        open = renderPacman(open, renderer);
        renderClyde(clyde, renderer);
        renderBlinky(blinky, renderer);
        renderPinky(pinky, renderer);
        renderInky(inky, renderer);

        changeDirectionGhost(blinky);
        changeDirectionGhost(clyde);
        changeDirectionGhost(inky);
        changeDirectionGhost(pinky);
        SDL_Rect dest = {0, map->row * TILE_SIZE , map->row * TILE_SIZE / 6, 20};
        SDL_RenderCopy(renderer, scoreT, NULL, &dest);



        SDL_RenderCopy(renderer, scoreTN, NULL, &dest2);

        SDL_RenderPresent(renderer);
        //Event handling

        SDL_PollEvent(&event);
        switch(event.type){
            case SDL_KEYDOWN:
                switch(event.key.keysym.scancode){
                    case SDL_SCANCODE_UP:
                        setPacmanDirection(NORTH);
                        if(konami[0]){
                            if(konami[1]){
                                for(j = 0 ; j < 10 ; j++){
                                    konami[j] = 0;
                                }
//                                printf("Déjà deux\n");
                            }else{
                                konami[1] = 1;
                            }
                        }else{
                            konami[0] = 1;
                        }
                        break;
                    case SDL_SCANCODE_DOWN:
                        setPacmanDirection(SOUTH);
                        break;
                    case SDL_SCANCODE_RIGHT:
                        setPacmanDirection(EAST);
                        break;
                    case SDL_SCANCODE_LEFT:
                        setPacmanDirection(WEST);
                        break;
                    default:
                        break;
                }
                break;
        }
        terminate = update(clyde, blinky, inky, pinky);
        if(terminate){
            if(pacman->life > 0 ){
                pacman->life--;
                terminate = 0;
                pacman->x = initialX;
                pacman->y = initialY;
            }
        }
        if(event.window.event == SDL_WINDOWEVENT_CLOSE){
            terminate = 1;
        }
        SDL_Delay(1000 / FPS);
        SDL_DestroyTexture(scoreTN);
        SDL_FreeSurface(scoreN);
    }
    printf("Score final : %d\n", pacman->point);
    Mix_FreeMusic(music);
    Mix_CloseAudio();
    freeTextures();
    SDL_DestroyRenderer(renderer);
    SDL_DestroyWindow(window);
    SDL_Quit();
    SDL_DestroyTexture(scoreT);
    freePacman();
    freeGhost(clyde);
    freeGhost(blinky);
    freeGhost(inky);
    freeGhost(pinky);
    freeMap();
    TTF_CloseFont(police);
    TTF_Quit();
    return EXIT_SUCCESS;
}
Exemple #17
0
SDL_Surface* Graphics::loadImage(const std::string &filePath) {
	if (this->_spriteSheets.count(filePath) == 0) {
		this->_spriteSheets[filePath] = IMG_Load(filePath.c_str());
	}
	return this->_spriteSheets[filePath];
}
Exemple #18
0
Sprite *sprite_load(char *filename, int frameW, int frameH)
{
	int i;
	SDL_Surface *temp;

	if(!sprite_list)
	{
		slog("error: using sprite system uninitialized");
        return NULL;
	}

	/*first search to see if the requested sprite image is alreday loaded*/
	for(i = 0; i < SPRITE_MAX; i++)
	{
		if (sprite_list[i].refCount == 0)
        {
            continue;
        }
		if(strcmp(filename, sprite_list[i].filename) == 0)
		{
			sprite_list[i].refCount++;
			return &sprite_list[i];
		}
	}

	/*makesure we have the room for a new sprite*/
	if(sprite_num + 1 >= SPRITE_MAX)
	{
		slog("Maximum Sprites Reached.\n");
		exit(1);
	}
	sprite_num++;

	/*if its not already in memory, then load it.*/
	for(i = 0; i <= sprite_num; i++)
	{
		if(!sprite_list[i].refCount)
			break;
	}

	temp = IMG_Load(filename);
	if(!temp)
	{
		slog("unable to load a vital sprite: %s\n", SDL_GetError());
		exit(0);
	}

	/*sets a transparent color for blitting.*/
	//SDL_SetColorKey(temp, SDL_TRUE, SDL_MapRGB(temp->format, 255,255,255));

	sprite_list[i].image = SDL_CreateTextureFromSurface(graphics_renderer, temp);
	SDL_FreeSurface(temp);

	/*then copy the given information to the sprite*/
	strcpy(sprite_list[i].filename, filename);

	/*now sprites don't have to be 16 frames per line, but most will be.*/
	sprite_list[i].fpl = 16;
	sprite_list[i].frameSize.x = frameW;
	sprite_list[i].frameSize.y = frameH;
	sprite_list[i].refCount++;
	return &sprite_list[i];
}
Exemple #19
0
void ZCursor::Init()
{
	int i,j;
	char filename_c[500];
	SDL_Surface *temp_surface;

	//load up the null cursors
	for(j=0;j<4;j++)
	{
		sprintf(filename_c, "assets/cursors/cursor_null_n%02d.png", j);
		cursor[CURSOR_C][0][j].LoadBaseImage(filename_c);

		sprintf(filename_c, "assets/cursors/placed_n%02d.png", j);
		temp_surface = IMG_Load(filename_c);
		cursor[PLACED_C][0][j].LoadBaseImage(temp_surface, false);
		cursor[PLACE_C][0][j].LoadBaseImage(temp_surface);
		//cursor[PLACED_C][0][j] = IMG_Load_Error(filename_c);
		//cursor[PLACE_C][0][j] = cursor[PLACED_C][0][j];

		sprintf(filename_c, "assets/cursors/attacked_n%02d.png", j);
		temp_surface = IMG_Load(filename_c);
		cursor[ATTACKED_C][0][j].LoadBaseImage(temp_surface, false);
		cursor[ATTACK_C][0][j].LoadBaseImage(temp_surface);
		//cursor[ATTACKED_C][0][j] = IMG_Load_Error(filename_c);
		//cursor[ATTACK_C][0][j] = cursor[ATTACKED_C][0][j];

		sprintf(filename_c, "assets/cursors/grabbed_n%02d.png", j);
		temp_surface = IMG_Load(filename_c);
		cursor[GRABBED_C][0][j].LoadBaseImage(temp_surface, false);
		cursor[GRAB_C][0][j].LoadBaseImage(temp_surface);
		//cursor[GRABBED_C][0][j] = IMG_Load_Error(filename_c);
		//cursor[GRAB_C][0][j] = cursor[GRABBED_C][0][j];

		sprintf(filename_c, "assets/cursors/grenaded_n%02d.png", j);
		temp_surface = IMG_Load(filename_c);
		cursor[GRENADED_C][0][j].LoadBaseImage(temp_surface, false);
		cursor[GRENADE_C][0][j].LoadBaseImage(temp_surface);
		//cursor[GRENADED_C][0][j] = IMG_Load_Error(filename_c);
		//cursor[GRENADE_C][0][j] = cursor[GRENADED_C][0][j];

		sprintf(filename_c, "assets/cursors/repaired_n%02d.png", j);
		temp_surface = IMG_Load(filename_c);
		cursor[REPAIRED_C][0][j].LoadBaseImage(temp_surface, false);
		cursor[REPAIR_C][0][j].LoadBaseImage(temp_surface);
		//cursor[REPAIRED_C][0][j] = IMG_Load_Error(filename_c);
		//cursor[REPAIR_C][0][j] = cursor[REPAIRED_C][0][j];
		
		sprintf(filename_c, "assets/cursors/entered_n%02d.png", j);
		temp_surface = IMG_Load(filename_c);
		cursor[ENTERED_C][0][j].LoadBaseImage(temp_surface, false);
		cursor[ENTER_C][0][j].LoadBaseImage(temp_surface);
		//cursor[ENTERED_C][0][j] = IMG_Load_Error(filename_c);
		//cursor[ENTER_C][0][j] = cursor[ENTERED_C][0][j];

		sprintf(filename_c, "assets/cursors/exited_n%02d.png", j);
		temp_surface = IMG_Load(filename_c);
		cursor[EXITED_C][0][j].LoadBaseImage(temp_surface, false);
		cursor[EXIT_C][0][j].LoadBaseImage(temp_surface);
		//cursor[EXITED_C][0][j] = IMG_Load_Error(filename_c);
		//cursor[EXIT_C][0][j] = cursor[EXITED_C][0][j];

		sprintf(filename_c, "assets/cursors/cannoned_n%02d.png", j);
		temp_surface = IMG_Load(filename_c);
		cursor[CANNONED_C][0][j].LoadBaseImage(temp_surface, false);
		cursor[CANNON_C][0][j].LoadBaseImage(temp_surface);
		//cursor[CANNONED_C][0][j] = IMG_Load_Error(filename_c);
		//cursor[CANNON_C][0][j] = cursor[CANNONED_C][0][j];
	}

	for(i=1;i<MAX_TEAM_TYPES;i++)
		for(j=0;j<4;j++)
		{
			sprintf(filename_c, "assets/cursors/cursor_%s_n%02d.png", team_type_string[i].c_str(), j);
			//cursor[CURSOR_C][i][j].LoadBaseImage(filename_c);// = IMG_Load_Error(filename_c);
			ZTeam::LoadZSurface(i, cursor[CURSOR_C][ZTEAM_BASE_TEAM][j], cursor[CURSOR_C][i][j], filename_c);

			sprintf(filename_c, "assets/cursors/place_%s_n%02d.png", team_type_string[i].c_str(), j);
			//cursor[PLACE_C][i][j].LoadBaseImage(filename_c);// = IMG_Load_Error(filename_c);
			ZTeam::LoadZSurface(i, cursor[PLACE_C][ZTEAM_BASE_TEAM][j], cursor[PLACE_C][i][j], filename_c);

			//cursor[PLACED_C][i][j] = cursor[PLACED_C][0][j];
			cursor[PLACED_C][i][j].LoadBaseImage(cursor[PLACED_C][0][j].GetBaseSurface() ,false);

			sprintf(filename_c, "assets/cursors/attack_%s_n%02d.png", team_type_string[i].c_str(), j);
			//cursor[ATTACK_C][i][j].LoadBaseImage(filename_c);// = IMG_Load_Error(filename_c);
			ZTeam::LoadZSurface(i, cursor[ATTACK_C][ZTEAM_BASE_TEAM][j], cursor[ATTACK_C][i][j], filename_c);

			//cursor[ATTACKED_C][i][j] = cursor[ATTACKED_C][0][j];
			cursor[ATTACKED_C][i][j].LoadBaseImage(cursor[ATTACKED_C][0][j].GetBaseSurface() ,false);

			sprintf(filename_c, "assets/cursors/grab_%s_n%02d.png", team_type_string[i].c_str(), j);
			//cursor[GRAB_C][i][j].LoadBaseImage(filename_c);// = IMG_Load_Error(filename_c);
			ZTeam::LoadZSurface(i, cursor[GRAB_C][ZTEAM_BASE_TEAM][j], cursor[GRAB_C][i][j], filename_c);

			//cursor[GRABBED_C][i][j] = cursor[GRABBED_C][0][j];
			cursor[GRABBED_C][i][j].LoadBaseImage(cursor[GRABBED_C][0][j].GetBaseSurface() ,false);

			sprintf(filename_c, "assets/cursors/grenade_%s_n%02d.png", team_type_string[i].c_str(), j);
			//cursor[GRENADE_C][i][j].LoadBaseImage(filename_c);// = IMG_Load_Error(filename_c);
			ZTeam::LoadZSurface(i, cursor[GRENADE_C][ZTEAM_BASE_TEAM][j], cursor[GRENADE_C][i][j], filename_c);

			//cursor[GRENADED_C][i][j] = cursor[GRENADED_C][0][j];
			cursor[GRENADED_C][i][j].LoadBaseImage(cursor[GRENADED_C][0][j].GetBaseSurface() ,false);

			sprintf(filename_c, "assets/cursors/repair_%s_n%02d.png", team_type_string[i].c_str(), j);
			//cursor[REPAIR_C][i][j].LoadBaseImage(filename_c);// = IMG_Load_Error(filename_c);
			ZTeam::LoadZSurface(i, cursor[REPAIR_C][ZTEAM_BASE_TEAM][j], cursor[REPAIR_C][i][j], filename_c);

			//cursor[REPAIRED_C][i][j] = cursor[REPAIRED_C][0][j];
			cursor[REPAIRED_C][i][j].LoadBaseImage(cursor[REPAIRED_C][0][j].GetBaseSurface() ,false);

			sprintf(filename_c, "assets/cursors/nono_%s_n%02d.png", team_type_string[i].c_str(), j);
			//cursor[NONO_C][i][j].LoadBaseImage(filename_c);// = IMG_Load_Error(filename_c);
			ZTeam::LoadZSurface(i, cursor[NONO_C][ZTEAM_BASE_TEAM][j], cursor[NONO_C][i][j], filename_c);

			sprintf(filename_c, "assets/cursors/cannon_%s_n%02d.png", team_type_string[i].c_str(), j);
			//cursor[CANNON_C][i][j].LoadBaseImage(filename_c);// = IMG_Load_Error(filename_c);
			ZTeam::LoadZSurface(i, cursor[CANNON_C][ZTEAM_BASE_TEAM][j], cursor[CANNON_C][i][j], filename_c);

			//cursor[CANNONED_C][i][j] = cursor[CANNONED_C][0][j];
			cursor[CANNONED_C][i][j].LoadBaseImage(cursor[CANNONED_C][0][j].GetBaseSurface() ,false);

			sprintf(filename_c, "assets/cursors/enter_%s_n%02d.png", team_type_string[i].c_str(), j);
			//cursor[ENTER_C][i][j].LoadBaseImage(filename_c);// = IMG_Load_Error(filename_c);
			ZTeam::LoadZSurface(i, cursor[ENTER_C][ZTEAM_BASE_TEAM][j], cursor[ENTER_C][i][j], filename_c);

			//cursor[ENTERED_C][i][j] = cursor[ENTERED_C][0][j];
			cursor[ENTERED_C][i][j].LoadBaseImage(cursor[ENTERED_C][0][j].GetBaseSurface() ,false);

			sprintf(filename_c, "assets/cursors/exit_%s_n%02d.png", team_type_string[i].c_str(), j);
			//cursor[EXIT_C][i][j].LoadBaseImage(filename_c);// = IMG_Load_Error(filename_c);
			ZTeam::LoadZSurface(i, cursor[EXIT_C][ZTEAM_BASE_TEAM][j], cursor[EXIT_C][i][j], filename_c);

			//cursor[EXITED_C][i][j] = cursor[EXITED_C][0][j];
			cursor[EXITED_C][i][j].LoadBaseImage(cursor[EXITED_C][0][j].GetBaseSurface() ,false);
		}
}
Exemple #20
0
void jouer(SDL_Surface* ecran){
    SDL_Surface *mario[4] = {NULL};
    SDL_Surface *mur = NULL, *caisse = NULL, *caisseOK = NULL, *objectif = NULL, *marioActuel = NULL;
    SDL_Rect position, positionJoueur;
    SDL_Event event;
    
    char continuer = 1, objectifsRestants = 0, i = 0, j = 0;
    char carte[NB_BLOCS_LARGEUR][NB_BLOCS_HAUTEUR] = {0};
    
    mur = IMG_Load("images/mur.jpg");
    caisse = IMG_Load("images/caisse.jpg");
    caisseOK = IMG_Load("images/caisse_ok.jpg");
    objectif = IMG_Load("images/objectif.png");
    mario[BAS] = IMG_Load("images/mario_bas.gif");
    mario[GAUCHE] = IMG_Load("images/mario_gauche.gif");
    mario[HAUT] = IMG_Load("images/mario_haut.gif");
    mario[DROITE] = IMG_Load("images/mario_droite.gif");
    
    marioActuel = mario[BAS];
    
    if (!chargerNiveau(carte))
        exit(EXIT_FAILURE);
    
    for (i = 0; i < NB_BLOCS_LARGEUR; i++)
    {
        for (j = 0; j < NB_BLOCS_LARGEUR; j++)
        {
            if (carte[i][j] == MARIO)
            {
                positionJoueur.x = i;
                positionJoueur.y = j;
                carte[i][j] = VIDE;
            }
        }
    }
    
    SDL_EnableKeyRepeat(100, 100);
    
    while (continuer) {
        SDL_WaitEvent(&event);
        switch (event.type) {
            case SDL_QUIT:
                continuer = 0;
                break;
            case SDL_KEYDOWN:
                switch (event.key.keysym.sym) {
                    case SDLK_ESCAPE:
                        continuer = 0;
                        break;
                    case SDLK_UP:
                        marioActuel = mario[HAUT];
                        deplacerJoueur(carte, &positionJoueur, HAUT);
                        break;
                    case SDLK_DOWN:
                        marioActuel = mario[BAS];
                        deplacerJoueur(carte, &positionJoueur, BAS);
                        break;
                    case SDLK_RIGHT:
                        marioActuel = mario[DROITE];
                        deplacerJoueur(carte, &positionJoueur, DROITE);
                        break;
                    case SDLK_LEFT:
                        marioActuel = mario[GAUCHE];
                        deplacerJoueur(carte, &positionJoueur, GAUCHE);
                        break;
                    default:
                        break;
                }
                break;
            default:
                break;
        }
        
        SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 255, 255, 255));
        
        objectifsRestants = 0;
        
        for (i = 0; i < NB_BLOCS_LARGEUR; i++) {
            for (j = 0; j < NB_BLOCS_HAUTEUR; j++) {
                position.x = i * TAILLE_BLOC;
                position.y = j * TAILLE_BLOC;
                
                switch (carte[i][j]) {
                    case MUR:
                        SDL_BlitSurface(mur, NULL, ecran, &position);
                        break;
                    case CAISSE:
                        SDL_BlitSurface(caisse, NULL, ecran, &position);
                        break;
                    case CAISSE_OK:
                        SDL_BlitSurface(caisseOK, NULL, ecran, &position);
                        break;
                    case OBJECTIF:
                        SDL_BlitSurface(objectif, NULL, ecran, &position);
                        objectifsRestants = 1;
                        break;
                }
            }
        }
        
        if (!objectifsRestants)
            continuer = 0;
        
        position.x = positionJoueur.x * TAILLE_BLOC;
        position.y = positionJoueur.y * TAILLE_BLOC;
        
        SDL_BlitSurface(marioActuel, NULL, ecran, &position);
        
        SDL_Flip(ecran);
        
    }
    
    SDL_EnableKeyRepeat(0, 0);
    
    SDL_FreeSurface(mur);
    SDL_FreeSurface(caisse);
    SDL_FreeSurface(caisseOK);
    SDL_FreeSurface(objectif);
    for (i = 0; i < 4; i++) {
        SDL_FreeSurface(mario[i]);
    }
    
}
Exemple #21
0
bool TEXTURE::Load(const std::string & path, const TEXTUREINFO & info, std::ostream & error)
{
	if (id)
	{
		error << "Tried to double load texture " << path << std::endl;
		return false;
	}

	if (path.empty() && !info.surface)
	{
		error << "Tried to load a texture with an empty name" << std::endl;
		return false;
	}

	id = 0;
	if (info.cube)
	{
		cube = true;
		return LoadCube(path, info, error);
	}

	SDL_Surface * orig_surface = info.surface;
	if (!orig_surface)
	{
		orig_surface = IMG_Load(path.c_str());
		if (!orig_surface)
		{
			error << "Error loading texture file: " << path << std::endl;
			return false;
		}
	}

	SDL_Surface * texture_surface(orig_surface);
	if (orig_surface)
	{
	    origw = texture_surface->w;
        origh = texture_surface->h;

		//scale to power of two if necessary
		bool norescale = (IsPowerOfTwo(orig_surface->w) && IsPowerOfTwo(orig_surface->h)) ||
					(info.npot && (GLEW_VERSION_2_0 || GLEW_ARB_texture_non_power_of_two));
		if (!norescale)
	    {
	        int newx = orig_surface->w;
	        int maxsize = 2048;
	        if (!IsPowerOfTwo(orig_surface->w))
	        {
	            for (newx = 1; newx <= maxsize && newx <= orig_surface->w; newx = newx * 2)
	            {
	            }
	        }

	        int newy = orig_surface->h;
	        if (!IsPowerOfTwo(orig_surface->h))
	        {
	            for (newy = 1; newy <= maxsize && newy <= orig_surface->h; newy = newy * 2)
	            {
	            }
	        }

	        float scalew = ((float)newx+0.5) / orig_surface->w;
	        float scaleh = ((float)newy+0.5) / orig_surface->h;

	        SDL_Surface * pot_surface = zoomSurface (orig_surface, scalew, scaleh, SMOOTHING_ON);

	        assert(IsPowerOfTwo(pot_surface->w));
	        assert(IsPowerOfTwo(pot_surface->h));

	        SDL_FreeSurface(orig_surface);
	        orig_surface = pot_surface;
	        texture_surface = orig_surface;
	    }

		//scale texture down if necessary
		scale = Scale(info.size, orig_surface->w, orig_surface->h);
		if (scale < 1.0)
		{
			texture_surface = zoomSurface (orig_surface, scale, scale, SMOOTHING_ON);
		}

		//store dimensions
		w = texture_surface->w;
		h = texture_surface->h;

		GenTexture(texture_surface, info, id, alpha, error);
	}

	//free the texture surface separately if it's a scaled copy of the original
	if (texture_surface != orig_surface && texture_surface)
	{
		SDL_FreeSurface(texture_surface);
	}

	//free the original surface if it's not a custom surface (used for the track map)
	if (!info.surface && orig_surface)
	{
		SDL_FreeSurface(orig_surface);
	}

	return true;
}
Exemple #22
0
	Surface::Surface(const char* pFilename)
	{
		// Create the surface from a loaded image file.
		mSurface = IMG_Load(pFilename);
	}
Exemple #23
0
int Menu (  )
{
    bool salir = false;
    SDL_Event evento;
    char opcion;                // 0:JUGAR, 1:CONTINUAR_PARTIDA, 2:SALIR

    // cargamos la imagen del puntero, y creamos la superficie y el SDL_Rect correspondientes
    SDL_Rect *posPuntero = new SDL_Rect;
    SDL_Surface *imagenPuntero;

    imagenPuntero = IMG_Load ( (ConfigManager::gamedataPath+string("punteromenu.png")).c_str() );
    posPuntero->h = imagenPuntero->h;
    posPuntero->w = imagenPuntero->w;
    posPuntero->x = screen->w / 2 - imagenPuntero->w / 2 + ConfigManager::H_RES / 4;
    SDL_SetColorKey ( imagenPuntero, SDL_SRCCOLORKEY,
                      SDL_MapRGB ( screen->format, 0, 0, 0 ) );

    // cargamos la imagen de fondo del men˙ y creamos la superficie correspondiente
    SDL_Surface * fondoMenu = IMG_Load( (ConfigManager::gamedataPath+string("mainmenu.jpg")).c_str());
    SDL_Rect *rectFondoMenu = new SDL_Rect;

    rectFondoMenu->x = ConfigManager::H_RES/2 - fondoMenu->w/2;
    rectFondoMenu->y = ConfigManager::V_RES/2 - fondoMenu->h/2;
    rectFondoMenu->w = fondoMenu->w;
    rectFondoMenu->h = fondoMenu->h;
    // realizamos todo el trabajo de las fuentes de letras TTF
    TTF_Font *fuenteMenu;
    
    if ( !( fuenteMenu = TTF_OpenFont ( (ConfigManager::gamedataPath+string("FreeSerifBold.ttf")).c_str(),42 ) ) )
    {
        printf ( "Error, no se pudo abrir la fuente de letras.\n" );
        exit ( 3 );
    }

    SDL_Color colorLetras;

    colorLetras.r = 255;
    colorLetras.g = 255;
    colorLetras.b = 255;
    colorLetras.unused=0;
    
    SDL_Rect *rectTitulo = new SDL_Rect;
    SDL_Rect *rectOpcion1 = new SDL_Rect;
    SDL_Rect *rectOpcion2 = new SDL_Rect;
    SDL_Rect *rectOpcion3 = new SDL_Rect;

    TTF_SetFontStyle ( fuenteMenu, TTF_STYLE_UNDERLINE );
    SDL_Surface *tituloMenu =
        TTF_RenderText_Solid ( fuenteMenu, "GeekFibres - Menú Principal", colorLetras );

    TTF_SetFontStyle ( fuenteMenu, TTF_STYLE_NORMAL );
    SDL_Surface *menuOpcion1 =
        TTF_RenderText_Solid ( fuenteMenu, "Empezar partida", colorLetras );
    SDL_Surface *menuOpcion2 =
        TTF_RenderText_Solid ( fuenteMenu, "Editar mundo", colorLetras );
    SDL_Surface *menuOpcion3 =
        TTF_RenderText_Solid ( fuenteMenu, "Salir", colorLetras );

    rectTitulo->h = tituloMenu->h;
    rectTitulo->w = tituloMenu->w;
    rectTitulo->x = ConfigManager::H_RES / 3;
    rectTitulo->y = ConfigManager::V_RES / 10;

    rectOpcion1->h = menuOpcion1->h;
    rectOpcion1->w = menuOpcion1->w;
    rectOpcion1->x = ConfigManager::H_RES / 2 - rectOpcion1->w / 2 + ConfigManager::H_RES / 4;
    rectOpcion1->y = int ( 2 * ConfigManager::V_RES / 7.0 );

    rectOpcion2->h = menuOpcion2->h;
    rectOpcion2->w = menuOpcion2->w;
    rectOpcion2->x = ConfigManager::H_RES / 2 - rectOpcion2->w / 2 + ConfigManager::H_RES / 4;
    rectOpcion2->y = int ( 3 * ConfigManager::V_RES / 7.0 );

    rectOpcion3->h = menuOpcion3->h;
    rectOpcion3->w = menuOpcion3->w;
    rectOpcion3->x = ConfigManager::H_RES / 2 - rectOpcion3->w / 2 + ConfigManager::H_RES / 4;
    rectOpcion3->y = int ( 4 * ConfigManager::V_RES / 7.0 );

    // bucle principal del menu
    opcion = 0;
    int cuentaCiclos = 0;

    const Uint32 tiempoPorBucle = 1000/50;
    Uint32 tiempoInicioBucle;
    while ( !salir )
    {       
        tiempoInicioBucle = SDL_GetTicks (  );
	    
        // Hacemos el control del teclado
        while ( SDL_PollEvent ( &evento ) )
        {
            switch ( evento.type )
            {
            case SDL_KEYDOWN:
                switch ( evento.key.keysym.sym )
                {
                case SDLK_UP:
                    opcion--;
                    break;

                case SDLK_DOWN:
                    opcion++;
                    break;

                case SDLK_ESCAPE:
                    opcion = 2;
                    salir = true;
                    break;

                case SDLK_RETURN:
                case SDLK_SPACE:
                    salir = true;
                    break;
                default:
                    break;
                }
                break;
            default:
                break;
            }
        }

        // controlamos la salida del puntero de las opciones posibles
        if ( opcion < 0 ){
            opcion = 0;
        }
        if ( opcion > 2 ){
            opcion = 2;
        }

        // situamos el puntero seg˙n la opciÛn elegida
        posPuntero->y = int ( ConfigManager::V_RES / 7.0 * ( opcion + 2 ) + 10 );

        cuentaCiclos++;
        rectTitulo->x =
            int ( ConfigManager::H_RES / 2 + 30.0 * sin ( cuentaCiclos / 20.0 ) -
                  rectTitulo->w / 2 );

        // pintamos el men˙
        SDL_FillRect ( screen, NULL, ConfigManager::GetIntProperty("menuBackground") );  
        SDL_BlitSurface ( fondoMenu, NULL, screen, rectFondoMenu );
        SDL_BlitSurface ( imagenPuntero, NULL, screen, posPuntero );
        SDL_BlitSurface ( tituloMenu, NULL, screen, rectTitulo );
        SDL_BlitSurface ( menuOpcion1, NULL, screen, rectOpcion1 );
        SDL_BlitSurface ( menuOpcion2, NULL, screen, rectOpcion2 );
        SDL_BlitSurface ( menuOpcion3, NULL, screen, rectOpcion3 );

        SDL_UpdateRect ( screen, 0, 0, 0, 0 );
        
        while ( SDL_GetTicks (  ) - tiempoInicioBucle < tiempoPorBucle ){
            SDL_Delay(tiempoPorBucle - SDL_GetTicks() + tiempoInicioBucle);
        }
        
    }
    SDL_FreeSurface ( tituloMenu );
    SDL_FreeSurface ( menuOpcion1 );
    SDL_FreeSurface ( menuOpcion2 );
    SDL_FreeSurface ( menuOpcion3 );
    SDL_FreeSurface ( fondoMenu );
    SDL_FreeSurface ( imagenPuntero );
    delete rectOpcion1;
    delete rectOpcion2;
    delete rectOpcion3;
    delete rectTitulo;
    delete posPuntero;

    TTF_CloseFont ( fuenteMenu );
    return opcion;
}
Exemple #24
0
int	 Engine::loadGLImage(std::string filename)
{
	SDL_Surface* loadedImage = NULL;
	SDL_Surface* optimizedImage = NULL;
	SDL_Surface* conv;
	float GLSize=1.0;
	unsigned texture;
  ListCounter++;

	loadedImage = IMG_Load(filename.c_str());
  
	if(loadedImage != NULL)
	{
		optimizedImage = SDL_DisplayFormatAlpha(loadedImage);
		SDL_FreeSurface(loadedImage);
	}

	if(optimizedImage == NULL)
        std::cout << "Error, maybe Picture not found: " << filename.c_str() << std::endl;

	  conv = SDL_CreateRGBSurface(SDL_SWSURFACE,
	  													  optimizedImage->w,
	  													  optimizedImage->h,
	  													  32,
	  #if SDL_BYTEORDER == SDL_BIG_ENDIAN
	            0xff000000, 0x00ff0000, 0x0000ff00, 0x000000ff);
	  #else
	                        0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000);
	  #endif
	  SDL_BlitSurface(optimizedImage, 0, conv, 0);


	  glGenTextures(1, &texture);  
	  glBindTexture(GL_TEXTURE_2D, texture);
	  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);  
	  glPixelStorei(GL_UNPACK_ROW_LENGTH, conv->pitch / conv->format->BytesPerPixel);  
	  glTexImage2D(GL_TEXTURE_2D, 0, 3, conv->w, conv->h, 0, GL_RGBA,
	               GL_UNSIGNED_BYTE, conv->pixels); 
	               
    glNewList(ListCounter,GL_COMPILE);
	  glColor3ub(255, 255, 255);
	  glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);

	  glEnable(GL_TEXTURE_2D);
 //   glEnable(GL_BLEND);
//	  glBlendFunc(GL_ONE, GL_ONE);
	  glBindTexture(GL_TEXTURE_2D, texture);
	  glBegin(GL_QUADS);
	  
//	    float factor = 0.1;
	    glTexCoord2f(0, 1);    glVertex2d(0, 0);
	    glTexCoord2f(1, 1);    glVertex2d( conv->w*GLSize,0);
	    glTexCoord2f(1, 0);    glVertex2d( conv->w*GLSize,conv->h*GLSize);
	    glTexCoord2f(0, 0);    glVertex2d(0,conv->h*GLSize);
	  glEnd();    
	  glDisable(GL_TEXTURE_2D);
//	  glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
	  glEndList();
  	
  std::cout << "GL-image load: " << filename << ", " << ListCounter << std::endl;

  return   ListCounter;
}
Exemple #25
0
void GameOverPanel::enable(int currentScore)
{
	SceneObject::enable();
	animTime = 0;
	score = currentScore;
	newHighScore = currentScore > highScore;
	if(newHighScore)
	{
		highScore = currentScore;
	}

	// copy texts to texture
	SDL_Surface *panelSurface = IMG_Load("panel.png");
	if(panelSurface == NULL)
	{
		throw std::logic_error("Couldn't load texture panel.png");
	}
	SDL_Surface *scoreSurface = Text::getSurface(scoreFont, intToString(score), Vector3::one, 2, Vector3::zero);
	SDL_Surface *highScoreSurface = Text::getSurface(scoreFont,  intToString(highScore), Vector3::one, 2, Vector3::zero);

	SDL_Rect scoreDstRect = {
		panelSurface->w - scoreSurface->w - 25,
		panelSurface->h / 2 - 50,
		scoreSurface->w,
		scoreSurface->h
	};
	SDL_Rect highScoreDstRect = {
		panelSurface->w - highScoreSurface->w - 25,
		panelSurface->h / 2 + 30,
		highScoreSurface->w,
		highScoreSurface->h
	};
	
	if(SDL_BlitSurface(scoreSurface, NULL, panelSurface, &scoreDstRect) < 0)
	{
		throw SceneError::fromSDLError("Couldn't copy surface");
	}
	if(SDL_BlitSurface(highScoreSurface, NULL, panelSurface, &highScoreDstRect) < 0)
	{
		throw SceneError::fromSDLError("Couldn't copy surface");
	}

	if(newHighScore)
	{
		SDL_Surface *newSurface = IMG_Load("new.png");
		if(newSurface == NULL)
		{
			throw std::logic_error("Couldn't load texture new.png");
		}
		SDL_Rect newDstRect = {
			panelSurface->w / 2 - 35,
			panelSurface->h / 2 - 5,
			highScoreSurface->w,
			highScoreSurface->h
		};
		if(SDL_BlitSurface(newSurface, NULL, panelSurface, &newDstRect) < 0)
		{
			throw SceneError::fromSDLError("Couldn't copy surface");
		}
		SDL_FreeSurface(newSurface);
	}

	SDL_FreeSurface(scoreSurface);
	SDL_FreeSurface(highScoreSurface);

	glDeleteTextures(texture);
	texture = Texture(panelSurface);
}
Exemple #26
0
 void Gestion_Jeux(SDL_Surface **ecran, SDL_Surface **carte, char JeuxDeCarte[MAX][MAX], SDL_Rect *position_carte, int* MainJouer[NB_CARTE],FLAG *FLAG, int *Selection_Carte[NB_CARTE], int *JeuxActuel[NB_CARTE], char **JeuxActuel1, int MainGagnante[NB_CARTE], int *MainGarder[NB_CARTE], int *Credit)
 {
    SDL_Surface *initialisation = NULL;
    SDL_Rect position_initialisation;
    TTF_Font *police_contenu = NULL;
    int selection = 0;
    int compteur = 0;
    int MainEnCours[5] = RAZ_CARTE;
    int nombre;


    /* Le flag permet de vérifier que nous somme au debut d'une partie */
    if (FLAG->FLAG_JEUX == 1){
        MainGarder[0] = 0;
        MainGarder[1] = 0;
        MainGarder[2] = 0;
        MainGarder[3] = 0;
        MainGarder[4] = 0;
        MainGarder[5] = 0;
        MainJouer[0] = 7;
        MainJouer[1] = 7;
        MainJouer[2] = 7;
        MainJouer[3] = 7;
        MainJouer[4] = 7;
        MainJouer[5] = 7;


        /* Géneration des cartes aléatoire pour le premier tour*/
        for (compteur = 0 ; compteur <= 4 ; compteur++)
        {
            if (MainJouer[compteur] == 7){
                if (compteur == 0){
                    MainEnCours[compteur] = Random (1,52);
                }else{
                    do
                    {
                        MainEnCours[compteur] = Random (1,52);
                        nombre = MainEnCours[compteur];
                        JeuxActuel[compteur] = nombre;
                    } while(!isvalid(nombre, &MainEnCours, 4, compteur));
                }
            }
        }

        for (compteur = 0 ; compteur <= 4 ; compteur++)
        {
            selection = MainEnCours[compteur];
            MainGagnante[compteur] = selection;
            JeuxActuel[compteur] = selection;
            JeuxActuel1[compteur] = JeuxDeCarte[selection];
            carte[compteur] = IMG_Load(JeuxDeCarte[selection]);

        }

        /*Blit du jeu generé */

        for (compteur = 0 ; compteur <= 4 ; compteur++)
        {
            SDL_BlitSurface(carte[compteur], NULL, *ecran, &position_carte[compteur]);
        }

    }



    /* Le flag permet de vérifier que nous somme au second tour de la partie */

    if (FLAG->FLAG_GAIM == 1){

        for (compteur = 0 ; compteur <= 4 ; compteur++)
        {
            if (MainJouer[compteur]==7){
                do
                {
                    MainEnCours[compteur] = Random(1,52);
                    nombre = MainEnCours[compteur];
                    JeuxActuel[compteur] = nombre;
                } while(!isvalid(nombre, JeuxActuel, 4, compteur));
            }
         }


        for (compteur = 0 ; compteur <= 4 ; compteur++)
        {
            if (MainJouer[compteur]==7){
                selection = MainEnCours[compteur];
                MainGagnante[compteur] = selection;
                JeuxActuel1[compteur] = JeuxDeCarte[selection];
                carte[compteur] = IMG_Load(JeuxDeCarte[selection]);
            }
        }


        /*Blit du jeu generé */
        for (compteur = 0 ; compteur <= 4 ; compteur++)
        {
            SDL_BlitSurface(carte[compteur], NULL, *ecran, &position_carte[compteur]);
        }


        Affichage_Main(&initialisation, &police_contenu, &position_initialisation, JeuxActuel1, MainGagnante, Credit);

        SDL_BlitSurface(initialisation, NULL, *ecran, &position_initialisation);

        /*RAZ Flag permettant de reprendre une nouvelle partie */
        FLAG->FLAG_GAIM = 0;
        FLAG->FLAG_INI = 1;
        FLAG->FLAG_JEUX = 0;
        FLAG->FLAG_SELECTION = 0;
        //FLAG permetant d'afficher le GAIN
        FLAG->FLAG_RESULTAT = 1;
        /* Remise a zéro des cartes */
        MainJouer[0] = 7;
        MainJouer[1] = 7;
        MainJouer[2] = 7;
        MainJouer[3] = 7;
        MainJouer[4] = 7;

    }

    /* Mise en place des parametres afin de passer au second tour */

    if (FLAG->FLAG_JEUX == 1){

        FLAG->FLAG_JEUX = 0;
        FLAG->FLAG_SELECTION = 1;
        FLAG->FLAG_GAIM = 1;
        FLAG->FLAG_RESULTAT = 0;
        Selection_Carte[0] = 1;
        Selection_Carte[1] = 1;
        Selection_Carte[2] = 1;
        Selection_Carte[3] = 1;
        Selection_Carte[4] = 1;

   }



    /*Mise a jour de l'écran */
    SDL_Flip(*ecran);

 }
Exemple #27
0
gui_options::gui_options(app_wiiradio* _theapp) :
    logo(0),
    media_free_space_desc("unknown"),
    last_time_ds(0)
{
    theapp = _theapp;
    fnts = theapp->GetFonts();
    guibuffer =  theapp->ui->guibuffer;

    logo = IMG_Load(make_path("data/imgs/def_logo.png"));

    loopi(O_MAX) b_option_item[i] = 0;
    loopi(OB_MAX) option_buts[i] = 0;

    //quit

    option_buts[OB_QUIT] = new gui_button(theapp, 20,425,0,0,false);
    option_buts[OB_QUIT]->set_images((char*)"data/imgs/button_out.png",(char*)"data/imgs/button_over.png",0,0);
    option_buts[OB_QUIT]->set_text(theapp->GetVariables()->search_var("$LANG_TXT_EXIT"));
    option_buts[OB_QUIT]->pad_y = 5;
    option_buts[OB_QUIT]->text_color = 0x000000;
    option_buts[OB_QUIT]->text_color_over = 0xff0044;
    option_buts[OB_QUIT]->font_sz = FS_SYSTEM;
    option_buts[OB_QUIT]->center_text = true;
    option_buts[OB_QUIT]->bind_screen = S_OPTIONS;
    option_buts[OB_QUIT]->parent = (gui_object*)this;

    //return
    option_buts[OB_RETURN] = new gui_button(theapp,150,425,0,0,false);
    option_buts[OB_RETURN]->set_images((char*)"data/imgs/button_out.png",(char*)"data/imgs/button_over.png",0,0);
    option_buts[OB_RETURN]->set_text(theapp->GetVariables()->search_var("$LANG_TXT_OK"));
    option_buts[OB_RETURN]->pad_y = 5;
    option_buts[OB_RETURN]->text_color = 0x000000;
    option_buts[OB_RETURN]->text_color_over = 0xff0044;
    option_buts[OB_RETURN]->font_sz = FS_SYSTEM;
    option_buts[OB_RETURN]->center_text = true;
    option_buts[OB_RETURN]->bind_screen = S_OPTIONS;
    option_buts[OB_RETURN]->parent = (gui_object*)this;

    //more
/*
    option_buts[OB_MORE] = new gui_button(theapp,500,425,0,0,false);
    option_buts[OB_MORE]->set_images((char*)"data/imgs/button_out.png",(char*)"data/imgs/button_over.png",0,0);
    option_buts[OB_MORE]->set_text("More >>>");//theapp->vars->search_var("$LANG_TXT_OK"));
    option_buts[OB_MORE]->pad_y = 5;
    option_buts[OB_MORE]->text_color = 0x000000;
    option_buts[OB_MORE]->text_color_over = 0xff0044;
    option_buts[OB_MORE]->font_sz = FS_SYSTEM;
    option_buts[OB_MORE]->center_text = true;
    option_buts[OB_MORE]->bind_screen = S_OPTIONS;
    option_buts[OB_MORE]->parent = (gui_object*)this;
*/
    int y = 90;

    service_group = new gui_group(theapp,2,220,y,41,26,143,NULL);
    service_group->set_on(theapp->GetSettings()->oservicetype);


    y += 35;
/*  Removed for now this is kinda annoying to most
    b_option_item[O_SCROLL_TEXT] = new gui_button(theapp,220,y,0,0,0);
    b_option_item[O_SCROLL_TEXT]->set_images((char*)"data/imgs/toggle_out.png",(char*)"data/imgs/toggle_out.png",(char*)"data/imgs/toggle_out.png",(char*)"data/imgs/toggle_on.png");
    b_option_item[O_SCROLL_TEXT]->bind_screen = S_OPTIONS;
    b_option_item[O_SCROLL_TEXT]->set_image_onout((char*)"data/imgs/toggle_on.png");
    b_option_item[O_SCROLL_TEXT]->parent = (gui_object*)this;
*/
    b_option_item[O_WIDESCREEN] = new gui_button(theapp,403,y,0,0,0);
    b_option_item[O_WIDESCREEN]->set_images((char*)"data/imgs/toggle_out.png",(char*)"data/imgs/toggle_out.png",(char*)"data/imgs/toggle_out.png",(char*)"data/imgs/toggle_on.png");
    b_option_item[O_WIDESCREEN]->bind_screen = S_OPTIONS;
    b_option_item[O_WIDESCREEN]->parent = (gui_object*)this;
    b_option_item[O_WIDESCREEN]->set_image_onout((char*)"data/imgs/toggle_on.png");
    y += 35;

    b_option_item[O_STARTFROMLAST] = new gui_button(theapp,220,y,0,0,0);
    b_option_item[O_STARTFROMLAST]->set_images((char*)"data/imgs/toggle_out.png",(char*)"data/imgs/toggle_out.png",(char*)"data/imgs/toggle_out.png",(char*)"data/imgs/toggle_on.png");
    b_option_item[O_STARTFROMLAST]->bind_screen = S_OPTIONS;
    b_option_item[O_STARTFROMLAST]->parent = (gui_object*)this;
    b_option_item[O_STARTFROMLAST]->set_image_onout((char*)"data/imgs/toggle_on.png");

    b_option_item[O_RIPMUSIC] = new gui_button(theapp,403,y,0,0,0);
    b_option_item[O_RIPMUSIC]->set_images((char*)"data/imgs/toggle_out.png",(char*)"data/imgs/toggle_out.png",(char*)"data/imgs/toggle_out.png",(char*)"data/imgs/toggle_on.png");
    b_option_item[O_RIPMUSIC]->bind_screen = S_OPTIONS;
    b_option_item[O_RIPMUSIC]->parent = (gui_object*)this;
    b_option_item[O_RIPMUSIC]->set_image_onout((char*)"data/imgs/toggle_on.png");

    y += 50;

    saver_group = new gui_group(theapp,4,220,y,41,26,20,NULL);
    saver_group->set_on(theapp->GetSettings()->oscreensavetime);
    saver_group->bind_screen = S_OPTIONS;

    y += 45;

    sleep_timer_group = new gui_group(theapp,6,220,y,41,26,20,&sleep_timer_callback);
    sleep_timer_group->set_on(theapp->GetSettings()->osleep_timer_time);
    sleep_timer_group->bind_screen = S_OPTIONS;
    sleep_timer_group->parent = (gui_object*)this;

    y += 45;

    // visual type
    visuals_group = new gui_group(theapp,2,220,y,41,26,40,NULL);
    visuals_group->set_on(theapp->GetSettings()->ovisual_mode);
    visuals_group->bind_screen = S_OPTIONS;
    visuals_group->parent = (gui_object*)this;

    y += 35;

    // next skin
    option_buts[OB_NEXT_SKIN] = new gui_button(theapp, 420,y,0,0,false);
    option_buts[OB_NEXT_SKIN]->set_images((char*)"data/imgs/button_out.png",(char*)"data/imgs/button_out.png",0,0);
    option_buts[OB_NEXT_SKIN]->set_text(theapp->GetVariables()->search_var("$LANG_TXT_NEXT_SKIN"));
    option_buts[OB_NEXT_SKIN]->pad_y = 5;
    option_buts[OB_NEXT_SKIN]->text_color = 0x000000;
    option_buts[OB_NEXT_SKIN]->text_color_over = 0xff0044;
    option_buts[OB_NEXT_SKIN]->font_sz = FS_SYSTEM;
    option_buts[OB_NEXT_SKIN]->center_text = true;
    option_buts[OB_NEXT_SKIN]->bind_screen = S_OPTIONS;
    option_buts[OB_NEXT_SKIN]->parent = (gui_object*)this;

    y += 50;

    // next lang
    option_buts[OB_NEXT_LANG] = new gui_button(theapp,420,y,0,0,false);
    option_buts[OB_NEXT_LANG]->set_images((char*)"data/imgs/button_out.png",(char*)"data/imgs/button_out.png",0,0);
    option_buts[OB_NEXT_LANG]->set_text(theapp->GetVariables()->search_var("$LANG_TXT_NEXT_LANG"));
    option_buts[OB_NEXT_LANG]->pad_y = 5;
    option_buts[OB_NEXT_LANG]->text_color = 0x000000;
    option_buts[OB_NEXT_LANG]->text_color_over = 0xff0044;
    option_buts[OB_NEXT_LANG]->font_sz = FS_SYSTEM;
    option_buts[OB_NEXT_LANG]->center_text = true;
    option_buts[OB_NEXT_LANG]->bind_screen = S_OPTIONS;
    option_buts[OB_NEXT_LANG]->parent = (gui_object*)this;

//#ifdef _WII_
    // reinir network
    option_buts[OB_NET_REINIT] = new gui_button(theapp,280,425,0,0,false);
    option_buts[OB_NET_REINIT]->set_images((char*)"data/imgs/button_out.png",(char*)"data/imgs/button_out.png",0,0);
    option_buts[OB_NET_REINIT]->set_text(theapp->GetVariables()->search_var("$LANG_REINTNET"));
    option_buts[OB_NET_REINIT]->pad_y = 5;
    option_buts[OB_NET_REINIT]->text_color = 0x000000;
    option_buts[OB_NET_REINIT]->text_color_over = 0xff0044;
    option_buts[OB_NET_REINIT]->font_sz = FS_SYSTEM;
    option_buts[OB_NET_REINIT]->center_text = true;
    option_buts[OB_NET_REINIT]->bind_screen = S_OPTIONS;
    option_buts[OB_NET_REINIT]->parent = (gui_object*)this;
//#endif
    // set options
//    theapp->GetSettings()->oscrolltext ? b_option_item[O_SCROLL_TEXT]->obj_sub_state = B_ON : b_option_item[O_SCROLL_TEXT]->obj_sub_state = B_OFF;
    theapp->GetSettings()->owidescreen ? b_option_item[O_WIDESCREEN]->obj_sub_state = B_ON : b_option_item[O_WIDESCREEN]->obj_sub_state = B_OFF;
    theapp->GetSettings()->oripmusic ? b_option_item[O_RIPMUSIC]->obj_sub_state = B_ON : b_option_item[O_RIPMUSIC]->obj_sub_state = B_OFF;
//    GetSYSVariable(SYS_RIPPING) ? b_option_item[O_RIPMUSIC]->obj_sub_state = B_ON : b_option_item[O_RIPMUSIC]->obj_sub_state = B_OFF;
    theapp->GetSettings()->ostartfromlast ? b_option_item[O_STARTFROMLAST]->obj_sub_state = B_ON : b_option_item[O_STARTFROMLAST]->obj_sub_state = B_OFF;

    // Try calc. ds on construction
    media_free_space_desc = get_media_free_space_desc();
};
void loadBalloon(SDL_Renderer* renderer, Gamestate* game, SDL_Surface* surface)
{
  surface = IMG_Load("images/HotAirBalloon.png");
  game->balloonTex = SDL_CreateTextureFromSurface(renderer, surface);
  SDL_FreeSurface(surface);
} // void loadBalloon
Exemple #29
0
int main(int argc, char ** argv)
{
    int finp = 0,first = 1;
    SDL_Surface * menu = NULL;
    SDL_Surface * ecran = NULL;
    SDL_Rect position_menu;
    SDL_Event event;
    FSOUND_STREAM * musique = NULL;
    
    SDL_Init(SDL_INIT_VIDEO);
    TTF_Init();
    FSOUND_Init(44100,32,0);
    
    ecran = SDL_SetVideoMode(800,800,32,SDL_HWSURFACE | SDL_DOUBLEBUF);
    
    if(ecran == NULL)
       exit(EXIT_FAILURE);
    SDL_WM_SetCaption("Prozet zz1",NULL);
    
    menu = IMG_Load("./dessin/menu.jpg");
    if(menu == NULL)
       exit(EXIT_FAILURE);
    
    position_menu.x = 0;
    position_menu.y = 0;
        
    musique = FSOUND_Stream_Open("./son/jourdefoot.mp3",0,0,0);
    if(musique == NULL)
       exit(EXIT_FAILURE);
    while(finp == 0)
    {
       if(first == 1)
       {
          SDL_BlitSurface(menu,NULL,ecran,&position_menu);
          SDL_Flip(ecran);
          FSOUND_Stream_Play(FSOUND_FREE,musique);
	  first = 0;
       }
       SDL_WaitEvent(&event);
       switch(event.type)
       {
          case SDL_QUIT:
	               finp = 1;
	               break;
	  case SDL_MOUSEBUTTONDOWN:
	               if(event.button.button == SDL_BUTTON_LEFT)
		       {
		          if(event.button.x >= 250 && event.button.x <= 550)
			  {
			     if(event.button.y >= 300 && event.button.y <= 400)
			     {
			        FSOUND_Stream_Stop(musique);
				mode_solo(ecran);
				first = 1;
			     }
			     else
			     {
			        if(event.button.y >= 450 && event.button.y <= 550)
				{
			           FSOUND_Stream_Stop(musique);
				   mode_local_serveur(ecran);
				   first = 1;
				}
				else
				{
				   if(event.button.y >= 600 && event.button.y <= 700)
				   {
			              FSOUND_Stream_Stop(musique);
				      mode_local_client(ecran);
				      first = 1;
				   }
				}
			     }
			  }
		       }
		       break;
       }
       
    }
    
    FSOUND_Stream_Stop(musique);
    FSOUND_Stream_Close(musique);
    FSOUND_Close();
    SDL_FreeSurface(menu);
    SDL_FreeSurface(ecran);
    TTF_Quit();
    SDL_Quit();
    return(EXIT_SUCCESS);
      
}
Exemple #30
0
int main(int argc, char **argv)
{
	char romName[150];

#ifdef GIZMONDO
		strcpy(romName, "\\SD Card\\GizRACE\\");
		strcat(romName, argv[1]);
#else
#ifndef TEST_CFC2_ONLY
	if(argc == 1)
	{
		dbg_printf("Defaulting to runme.ngp\n");
		strncpy(romName, "runme.ngp", 50);
		//dbg_printf("Defaulting to runme.ws\n");
		//strncpy(romName, "runme.ws", 50);
	}
	else if(argc != 2)
	{
		fprintf(stderr, "argc != 2\n");
		return -1;
	}
	else
		strncpy(romName, argv[1], 50);

	dbg_printf("romName=%s\n", romName);
#endif
#endif
	// Initialize SDL
#if defined (TARGET_GP2X) || defined (GIZMONDO)
    if (SDL_Init(SDL_INIT_VIDEO|SDL_INIT_AUDIO|SDL_INIT_JOYSTICK) < 0)
#else
    if (SDL_Init(SDL_INIT_VIDEO|SDL_INIT_AUDIO|SDL_INIT_TIMER) < 0)
#endif
	{
		fprintf(stderr, "SDL_Init failed!\n");
		return -1;//Log::Instance()->die(1, SV_FATALERROR, "Couldn't initialize SDL: %s\n", SDL_GetError());
	}

#ifdef TARGET_GP2X
	GP2X_JoystickOpen();
#else
#ifdef GIZMONDO
	joystick = SDL_JoystickOpen(0);
#else
    SDL_WM_SetCaption("RACE!", 0);
#endif
#endif

	// Set up quiting so that it automatically runs on exit.
	atexit (SDL_Quit);

//#define DO_HWDBLBUF
#ifdef DO_HWDBLBUF
	screen = SDL_SetVideoMode (SIZEX, SIZEY, 16, SDL_HWSURFACE | SDL_DOUBLEBUF);
#else
	//screen = SDL_SetVideoMode (SIZEX, SIZEY, 8, SDL_SWSURFACE | SDL_HWPALETTE);
	//screen = SDL_SetVideoMode (SIZEX, SIZEY, 16, SDL_SWSURFACE);
#ifdef GIZMONDO
	screen = SDL_SetVideoMode (320, 240, 16, SDL_HWSURFACE | SDL_HWPALETTE | SDL_FULLSCREEN);
#else
	screen = SDL_SetVideoMode (320, 240, 16, SDL_SWSURFACE);
#endif
#endif
	if (screen == NULL)
	{
		fprintf(stderr, "SDL_SetVideoMode failed!\n");
		return -1;
	}
	else
	{
		dbg_print("screen params: bpp=%d\n", screen->format->BitsPerPixel);
	}

	SDL_ShowCursor(0);  //disable the cursor

	/* Set up the SDL_TTF */
	TTF_Init();
	atexit(TTF_Quit);

#if !defined(GIZMONDO) && !defined(TARGET_WIZ)
    SDL_AudioSpec wav,retFmt;
    SDL_Surface *splash = IMG_Load("splash.jpg");
    if(splash)
    {
        SDL_BlitSurface(splash, NULL, screen, NULL);
        SDL_Flip(screen);
    }
    else
    {
        SDL_Surface *splash = IMG_Load("splash.bmp");
        if(splash)
        {
            SDL_BlitSurface(splash, NULL, screen, NULL);
            SDL_Flip(screen);
        }
    }

	InitInput(NULL);

    if(SDL_LoadWAV("intro.wav", &wav, &audio_buf, &audio_len) == NULL)
    {
        printf("Unable to open intro wav!\n");
    }
    else
    {
        wav.callback = introAudioCallback;
        wav.userdata = NULL;
        if ( SDL_OpenAudio(&wav, &retFmt) < 0 ) {
            fprintf(stderr, "Unable to open audio: %s\n", SDL_GetError());
            exit(1);
        }

        SDL_PauseAudio(0);

        while (played<audio_len)
        {
            UpdateInputState();
            if (ngpInputState & 0x70)
                break;
        }
        while (ngpInputState & 0x70)
        {
            UpdateInputState();
        }
    }

    SDL_PauseAudio(0);

    SDL_CloseAudio();
    SDL_FreeSurface(splash);
    SDL_FreeWAV(audio_buf);

    if(LoadRomFromGP2X(romName, screen) <= 0)
    {
        dbg_print("LoadRomFromPSP failed!\n");
        exit(1);
    }
#else
    InitInput(NULL);

    if(LoadRomFromGP2X(romName, screen) <= 0)
    {
        dbg_print("LoadRomFromPSP failed!\n");
        exit(1);
    }
#endif

	//dbg_print("openNgp(%s)\n", romName);

	//emulate
	//see ngpc.cpp and ngpcDoc.cpp

    //system_sound_init();
    sound_system_init();

    handleInputFile(romName);

#if defined(TARGET_GP2X) && !defined(TARGET_WIZ)
	system("/sbin/rmmod mmuhack");
	system("/sbin/insmod mmuhack.o");

	int mmufd = open("/dev/mmuhack", O_RDWR);
	if(mmufd < 0)
	{
	printf("MMU hack failed\n");
	}
	else
	{
	printf("MMU hack loaded\n");
	close(mmufd);
	}
#endif

	dbg_print("Running NGPC Emulation\n");

    ngpc_run();

	flashShutdown();

#if defined(TARGET_GP2X) && !defined(TARGET_WIZ)
	system("/sbin/rmmod mmuhack");
#endif
	return 0;
}