int main( int argc, char* args[] )
{
	//Start up SDL and create window
	if( !init() )
	{
		printf( "Failed to initialize!\n" );
	}
	else
	{
		//Load media
		if( !loadMedia() )
		{
			printf( "Failed to load media!\n" );
		}
		else
		{
			//Main loop flag
			bool quit = false;

			//Event handler
			SDL_Event e;

			//Modulation component
			Uint8 a = 255;

			//While application is running
			while( !quit )
			{
				//Handle events on queue
				while( SDL_PollEvent( &e ) != 0 )
				{
					//User requests quit
					if( e.type == SDL_QUIT )
					{
						quit = true;
					}
					//Handle key presses
					else if( e.type == SDL_KEYDOWN )
					{
						//Increase alpha on w
						if( e.key.keysym.sym == SDLK_w )
						{
							//Cap if over 255
							if( a + 32 > 255 )
							{
								a = 255;
							}
							//Increment otherwise
							else
							{
								a += 32;
							}
						}
						//Decrease alpha on s
						else if( e.key.keysym.sym == SDLK_s )
						{
							//Cap if below 0
							if( a - 32 < 0 )
							{
								a = 0;
							}
							//Decrement otherwise
							else
							{
								a -= 32;
							}
						}
					}
				}

				//Clear screen
				SDL_SetRenderDrawColor( gRenderer, 0xFF, 0xFF, 0xFF, 0xFF );
				SDL_RenderClear( gRenderer );

				//Render background
				gBackgroundTexture.render( 0, 0 );

				//Render front blended
				gModulatedTexture.setAlpha( a );
				gModulatedTexture.render( 0, 0 );

				//Update screen
				SDL_RenderPresent( gRenderer );
			}
		}
	}

	//Free resources and close SDL
	close();

	return 0;
}
Esempio n. 2
0
int main(int argc, char* argv[]) {
    //initialize and loading variables
    char *bgmm[11] = { "l1.mp3", "l2.mp3", "l3.mp3", "l4.mp3", "l5.mp3", "l6.mp3", "l7.mp3", "l8.mp3", "l9.mp3", "l10.mp3", "l11.mp3" };
    char *bv[11] = { "can we live together.wav",
        "can't you just relax do you even remember.wav",
        "chage is good for you.wav",
        "grace and integrity are what define us.wav",
        "how do thrive and grow under pressure.wav",
        "i don't want you to keep going.wav",
        "i know sometimes it feels like you have no controle",
        "i want to help you but you need to let me.wav",
        "is there another way.wav",
        "once an action is done it cannot be undone.wav",
        "push any further and yu will  break.wav" };
    SDL_Color color;
    const point center = { 220.0, 350.0 };
    int currenttick, score=0;
    short circleradius = 44,musicselect=0;
    boolean mainmenu = yes;
    double theta = 0.0,speed=0.09;
    //Uint8 alpha;
    SDL_Renderer *rendertarget = NULL;
    
    SDL_Rect rectangle1 = { 320, 0, 100, 20 }, rectangle2 = { 230, rectangle1.y-80, 100, 20 };
    SDL_Rect littlerectangle1 = { 310, rectangle1.y - 165, 50, 20 };
    SDL_Rect cube1 = { 300, rectangle1.y - 270, 40, 40 }, cube2 = { 310, cube1.y - 90, 40, 40 }, cube3 = { 305, cube2.y - 90, 40, 40 };
    
    SDL_Rect redballposition = { center.x + circleradius*sin(theta), center.y + circleradius*cos(theta), 25, 25 };
    SDL_Rect blueballposition = { center.x - circleradius*sin(theta), center.y - circleradius*cos(theta), 25, 25 };
    
    const Uint8 *keystate;
    SDL_Window *window = NULL;
    SDL_Texture *redball = NULL, *blueball = NULL, *box = NULL; //gametexture
    
    // Initialize SDL2
    SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO);
    Mix_OpenAudio(44100, MIX_DEFAULT_FORMAT, MIX_DEFAULT_CHANNELS, 2560);
    Mix_Music *bgm = Mix_LoadMUS("l1.mp3");
    
    Mix_Chunk *voice = Mix_LoadWAV("trust your instincts.wav"), *hitsound = Mix_LoadWAV("Samples/3816133910831170.wav");
    Mix_PlayChannel(2,voice,0);
    Mix_PlayMusic(bgm, -1);
    
    
    
    // Create an application window with the following settings:
    window = SDL_CreateWindow("An SDL2 window", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, 440, 480, SDL_WINDOW_SHOWN  );
    
    rendertarget = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
    box = loadTexture("box.png", rendertarget);
    
    redball = loadTexture("redball.png", rendertarget);
    blueball = loadTexture("bleuball.png", rendertarget);
    
    
    //SDL_SetRenderDrawColor(rendertarget, 0x23, 0x23, 0x23, 0x23);
    SDL_SetRenderDrawColor(rendertarget, 0x99, 0x99, 0xF8, 0x23);
    color.r = 0x99;
    color.g = 0x99;
    color.b = 0xF8;
    color.a = 0x23;
    option select = exitgame;
    //gameloop
    
    boolean gamerunning = yes, programruns = yes;
    SDL_Event e;
    
    while (programruns == yes){
        while (gamerunning == yes && select == startgame){
            
            
            while (SDL_PollEvent(&e)) {
                if (e.type == SDL_QUIT)
                    gamerunning = no;
            };
            srand(time(0));
            
            currenttick = SDL_GetTicks();
            if (e.key.keysym.scancode == SDL_SCANCODE_ESCAPE){
                SDL_RenderClear(rendertarget);
                SDL_RenderPresent(rendertarget);
                //SDL_RenderCopy(rendertarget, gameTitle, NULL, &Gametitleposition);
                //update(gameTitle, Gametitleposition);
                
                SDL_RenderPresent(rendertarget);
                mainmenu = yes;
                break;
                //code to stop game and get back to menu
            }
            keystate = SDL_GetKeyboardState(NULL);
            
            if (keystate[SDL_SCANCODE_LEFT]) {
                theta += speed;
                redballposition.x = center.x + circleradius*sin(theta);
                redballposition.y = center.y + circleradius*cos(theta);
                blueballposition.x = center.x - circleradius*sin(theta);
                blueballposition.y = center.y - circleradius*cos(theta);
            }
            else if (keystate[SDL_SCANCODE_RIGHT]){
                
                theta -= speed;
                redballposition.x = center.x + circleradius*sin(theta);
                redballposition.y = center.y + circleradius*cos(theta);
                blueballposition.x = center.x - circleradius*sin(theta);
                blueballposition.y = center.y - circleradius*cos(theta);
                
            }
            else if (keystate[SDL_SCANCODE_UP]){
                
                
                circleradius += 2;
                redballposition.x = center.x + circleradius*sin(theta);
                redballposition.y = center.y + circleradius*cos(theta);
                blueballposition.x = center.x - circleradius*sin(theta);
                blueballposition.y = center.y - circleradius*cos(theta);
            }
            else if (keystate[SDL_SCANCODE_DOWN]){
                
                circleradius -= 2;
                redballposition.x = center.x + circleradius*sin(theta);
                redballposition.y = center.y + circleradius*cos(theta);
                blueballposition.x = center.x - circleradius*sin(theta);
                blueballposition.y = center.y - circleradius*cos(theta);
            }
            movebox(rectangle1);
            srand(currenttick);
            movebox(rectangle2);
            
            srand(currenttick);
            movebox(littlerectangle1);
            srand(currenttick);
            movebox(cube1);
            srand(currenttick);
            movebox(cube2);
            srand(currenttick);
            movebox(cube3);
            SDL_RenderClear(rendertarget);
            update(redball, redballposition);
            update(blueball, blueballposition);
            update(box, rectangle1);
            update(box, rectangle2);
            update(box, littlerectangle1);
            update(box, cube1);
            update(box, cube2);
            update(box, cube3);
            
            SDL_RenderPresent(rendertarget);
            
            
            
            
            if (aBallhit(rectangle1) || aBallhit(rectangle2) || aBallhit(littlerectangle1) || aBallhit(cube1) || aBallhit(cube2) || aBallhit(cube3)){
                
                Mix_PlayChannel(1, hitsound, 0);
                //reinitialize Game
                
                //rectangle1 = { 220, 0, 100, 20 };
                rectangle1.x= 220;
                rectangle1.y= 0;
                rectangle1.w= 100;
                rectangle1.h= 20;
                //rectangle2 = { 130, rectangle1.y - 80, 100, 20 };
                rectangle2.x= 130;
                rectangle2.y= rectangle1.y - 80;
                rectangle2.w= 100;
                rectangle2.h= 20;
                //littlerectangle1 = { 210, rectangle1.y - 165, 50, 20 };
                littlerectangle1.x= 210;
                littlerectangle1.y= rectangle1.y - 165;
                littlerectangle1.w= 50;
                littlerectangle1.h= 20;
                //cube1 = { 200, rectangle1.y - 270, 40, 40 };
                cube1.x= 200;
                cube1.y= rectangle1.y - 270;
                cube1.w= 40;
                cube1.h= 40;
                //cube2 = { 210, cube1.y - 90, 40, 40 };
                cube2.x= 210;
                cube2.y= cube1.y - 90;
                cube2.w= 40;
                cube2.h= 40;
                //cube3 = { 205, cube2.y - 90, 40, 40 };
                cube3.x= 205;
                cube3.y= cube2.y - 90;
                cube3.w= 40;
                cube3.h= 40;
                
                
                //redballposition = { center.x + circleradius*sin(theta), center.y + circleradius*cos(theta), 25, 25 };
                redballposition.x= center.x + circleradius*sin(theta);
                redballposition.y= center.y + circleradius*cos(theta);
                redballposition.w= 25;
                redballposition.h= 25;
                //blueballposition = { center.x - circleradius*sin(theta), center.y - circleradius*cos(theta), 25, 25 };
                blueballposition.x=  center.x - circleradius*sin(theta);
                blueballposition.y= center.y - circleradius*cos(theta);
                blueballposition.w= 25;
                blueballposition.h= 25;
                
                circleradius = 44;
                gamerunning = yes;
                mainmenu = yes;
                printf("\n your score is: %d", score);
                score = 0;
                Mix_HaltMusic();
                Mix_FreeMusic(bgm);
                if (musicselect == 10)
                    musicselect = 0;
                else
                    musicselect += 1;
                
                bgm = Mix_LoadMUS(bgmm[musicselect]);
                voice = Mix_LoadWAV(bv[musicselect]);
                Mix_PlayMusic(bgm,-1);
                Mix_PlayChannel(2, voice, 0);
                srand(currenttick);
                
                color.b = rand(); srand(currenttick*100);
                color.a = rand(); srand(currenttick*1000);
                color.g = rand(); srand(currenttick*10000);
                color.r = rand();
                
                SDL_SetRenderDrawColor(rendertarget, color.r, color.g, color.b, color.a);
                
                break;
                
                //insert code when collision happens
                
            }
            if (musicselect == 6 ){
                color.b = rand(); srand(currenttick * 100);
                color.r = rand(); srand(currenttick * 1000);
                color.g = rand();
                SDL_SetTextureColorMod(box, color.r, color.g, color.b);
            }
            else if (musicselect == 7){
                //SDL_SetTextureColorMod(box, 0, 0, 0);
            }
            //if (rectangle1.y >= 200){
            //	alpha = 20;
            //	SDL_SetTextureAlphaMod(box,alpha);
            //}
            //else
            //	alpha=100;
            
            if( (notout(redballposition,blueballposition))&&(rectangle1.y == 400 || rectangle2.y == 400 || littlerectangle1.y == 400 || cube1.y == 400 || cube2.y == 400 || cube3.y == 400)){
                score += 1;
                //	printf("\n score = %d", score);
                
                
            }
            
            if (SDL_GetTicks() - currenttick<1000.0 / 60)/*60 FPS*/
            {
                SDL_Delay(1000 / 60 - SDL_GetTicks() + currenttick);
            }
        }
        runmenu(&programruns,&mainmenu,rendertarget,&select);
    }
    // Close and destroy the window
    SDL_DestroyWindow(window);
    
    // Clean up
    SDL_Quit();
    IMG_Quit();
    Mix_Quit();
    SDL_DestroyTexture(redball);
    SDL_DestroyTexture(blueball);
    SDL_DestroyTexture(box);
    
    SDL_DestroyRenderer(rendertarget);
    
    redball = NULL;
    blueball = NULL;
    box = NULL;
    rendertarget = NULL;
    return 0;
}
Esempio n. 3
0
void Graphics::clear() {
	SDL_RenderClear(this->_renderer);
}
void VideoDecodcEncodc::decodec()
{

	AVFormatContext	*pFormatCtx;
	int				i, videoindex;
	AVCodecContext	*pCodecCtx;
	AVCodec			*pCodec;
	AVFrame	*pFrame, *pFrameYUV;
	uint8_t *out_buffer;
	AVPacket *packet;
	int ret, got_picture,y_size;

	//------------SDL----------------
	int screen_w, screen_h;
	SDL_Window *screen;
	SDL_Renderer* sdlRenderer;
	SDL_Texture* sdlTexture;
	SDL_Rect sdlRect;
	SDL_Thread *video_tid;
	SDL_Event event;

	struct SwsContext *img_convert_ctx;

	FILE *pFile =NULL;
	//char filepath[]="bigbuckbunny_480x272.h265";
	char filepath[] = "Titanic.ts";

	av_register_all();
	avformat_network_init();
	pFormatCtx = avformat_alloc_context();

	if (avformat_open_input(&pFormatCtx, filepath, NULL, NULL) != 0){
		printf("Couldn't open input stream.\n");
		return ;
	}
	if (avformat_find_stream_info(pFormatCtx, NULL)<0){
		printf("Couldn't find stream information.\n");
		return ;
	}
	videoindex = -1;
	for (i = 0; i<pFormatCtx->nb_streams; i++)
	if (pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO){
		videoindex = i;
		break;
	}
	if (videoindex == -1){
		printf("Didn't find a video stream.\n");
		return ;
	}
	pCodecCtx = pFormatCtx->streams[videoindex]->codec;
	pCodec = avcodec_find_decoder(pCodecCtx->codec_id);
	if (pCodec == NULL){
		printf("Codec not found.\n");
		return ;
	}
	if (avcodec_open2(pCodecCtx, pCodec, NULL)<0){
		printf("Could not open codec.\n");
		return ;
	}
#if OUTPUT_YUV420P
	pFile = fopen("output.yuv","wb+");
#endif
	pFrame = av_frame_alloc();
	pFrameYUV = av_frame_alloc();
	out_buffer = (uint8_t *)av_malloc(avpicture_get_size(PIX_FMT_YUV420P, pCodecCtx->width, pCodecCtx->height));
	avpicture_fill((AVPicture *)pFrameYUV, out_buffer, PIX_FMT_YUV420P, pCodecCtx->width, pCodecCtx->height);

	//Output Info-----------------------------
	printf("---------------- File Information ---------------\n");
	av_dump_format(pFormatCtx, 0, filepath, 0);
	printf("-------------------------------------------------\n");

	img_convert_ctx = sws_getContext(pCodecCtx->width, pCodecCtx->height, pCodecCtx->pix_fmt,
		pCodecCtx->width, pCodecCtx->height, PIX_FMT_YUV420P, SWS_BICUBIC, NULL, NULL, NULL);


	if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER)) {
		printf("Could not initialize SDL - %s\n", SDL_GetError());
		return ;
	}
	//SDL 2.0 Support for multiple windows
	screen_w = pCodecCtx->width;
	screen_h = pCodecCtx->height;
	screen = SDL_CreateWindow("Simplest ffmpeg player's Window", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
		screen_w, screen_h, SDL_WINDOW_OPENGL);

	if (!screen) {
		printf("SDL: could not create window - exiting:%s\n", SDL_GetError());
		return ;
	}
	sdlRenderer = SDL_CreateRenderer(screen, -1, 0);
	//IYUV: Y + U + V  (3 planes)
	//YV12: Y + V + U  (3 planes)
	sdlTexture = SDL_CreateTexture(sdlRenderer, SDL_PIXELFORMAT_IYUV, SDL_TEXTUREACCESS_STREAMING, pCodecCtx->width, pCodecCtx->height);

	sdlRect.x = 0;
	sdlRect.y = 0;
	sdlRect.w = screen_w;
	sdlRect.h = screen_h;

	packet = (AVPacket *)av_malloc(sizeof(AVPacket));

	video_tid = SDL_CreateThread(sfp_refresh_thread, NULL, NULL);
	//------------SDL End------------
	//Event Loop

	for (;;) {
		//Wait
		SDL_WaitEvent(&event);
		if (event.type == SFM_REFRESH_EVENT){
			while (1){
				if (av_read_frame(pFormatCtx, packet)<0)
					thread_exit = 1;

				if (packet->stream_index == videoindex)
					break;


			}
			ret = avcodec_decode_video2(pCodecCtx, pFrame, &got_picture, packet);
			if (ret < 0){
				printf("Decode Error.\n");
				return ;
			}
			if (got_picture){
				sws_scale(img_convert_ctx, (const uint8_t* const*)pFrame->data, pFrame->linesize, 0, pCodecCtx->height, pFrameYUV->data, pFrameYUV->linesize);

#if OUTPUT_YUV420P
				y_size = pCodecCtx->width*pCodecCtx->height;
				fwrite(pFrameYUV->data[0], 1, y_size, pFile);    //Y 
				fwrite(pFrameYUV->data[1], 1, y_size / 4, pFile);  //U
				fwrite(pFrameYUV->data[2], 1, y_size / 4, pFile);  //V

#endif
				//SDL---------------------------
				SDL_UpdateTexture(sdlTexture, NULL, pFrameYUV->data[0], pFrameYUV->linesize[0]);
				SDL_RenderClear(sdlRenderer);
				//SDL_RenderCopy( sdlRenderer, sdlTexture, &sdlRect, &sdlRect );  
				SDL_RenderCopy(sdlRenderer, sdlTexture, NULL, NULL);
				SDL_RenderPresent(sdlRenderer);
				//SDL End-----------------------
			}
			av_free_packet(packet);
		}
		else if (event.type == SDL_KEYDOWN){
			//Pause
			if (event.key.keysym.sym == SDLK_SPACE)
				thread_pause = !thread_pause;
		}
		else if (event.type == SDL_QUIT){
			thread_exit = 1;
		}
		else if (event.type == SFM_BREAK_EVENT){
			break;
		}

	}

	sws_freeContext(img_convert_ctx);

	SDL_Quit();
	//--------------
	av_frame_free(&pFrameYUV);
	av_frame_free(&pFrame);
	avcodec_close(pCodecCtx);
	avformat_close_input(&pFormatCtx);
}
Esempio n. 5
0
void CSDL_Setup::Begin()
{	
	SDL_PollEvent(mainEvent);
	SDL_RenderClear(renderer);
}
Esempio n. 6
0
int main(int argc, char **argv)
{
    int done = 0;
    SDL_Window *window;
    SDL_Renderer *renderer;

    /* !!! FIXME: check for errors. */
    SDL_Init(SDL_INIT_VIDEO);
    window = SDL_CreateWindow("Drag the red boxes", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 640, 480, SDL_WINDOW_BORDERLESS | SDL_WINDOW_RESIZABLE);
    renderer = SDL_CreateRenderer(window, -1, 0);

    if (SDL_SetWindowHitTest(window, hitTest, NULL) == -1) {
        SDL_Log("Enabling hit-testing failed!\n");
        SDL_Quit();
        return 1;
    }

    while (!done)
    {
        SDL_Event e;
        int nothing_to_do = 1;

        SDL_SetRenderDrawColor(renderer, 0, 0, 127, 255);
        SDL_RenderClear(renderer);
        SDL_SetRenderDrawColor(renderer, 255, 0, 0, 255);
        SDL_RenderFillRects(renderer, areas, SDL_arraysize(drag_areas));
        SDL_RenderPresent(renderer);

        while (SDL_PollEvent(&e)) {
            nothing_to_do = 0;

            switch (e.type)
            {
                case SDL_MOUSEBUTTONDOWN:
                    SDL_Log("button down!\n");
                    break;

                case SDL_MOUSEBUTTONUP:
                    SDL_Log("button up!\n");
                    break;

                case SDL_WINDOWEVENT:
                    if (e.window.event == SDL_WINDOWEVENT_MOVED) {
                        SDL_Log("Window event moved to (%d, %d)!\n", (int) e.window.data1, (int) e.window.data2);
                    }
                    break;

                case SDL_KEYDOWN:
                    if (e.key.keysym.sym == SDLK_ESCAPE) {
                        done = 1;
                    } else if (e.key.keysym.sym == SDLK_x) {
                        if (!areas) {
                            areas = drag_areas;
                            numareas = SDL_arraysize(drag_areas);
                        } else {
                            areas = NULL;
                            numareas = 0;
                        }
                    }
                    break;

                case SDL_QUIT:
                    done = 1;
                    break;
            }
        }

        if (nothing_to_do) {
            SDL_Delay(50);
        }
    }

    SDL_Quit();
    return 0;
}
Esempio n. 7
0
File: main.c Progetto: odrevet/GE2
game_status state_in_game(SDL_Renderer *renderer, game* p_game)
{
  bool done=false;

  game_status ret_code = QUIT;
  map *p_map = p_game->p_map;
  
  while (!done){
    //update display
    //clear
    SDL_SetRenderDrawColor(renderer, 0x0, 0x0, 0x0, 0xFF);
    SDL_RenderClear(renderer);

    //draw the map
    map_draw(p_map, renderer);

    //draw the chipset
    image_draw(p_map->p_chipset, renderer, 0, 0);
    
    //input
    SDL_Event event;
    while (SDL_PollEvent(&event)){

      if(event.type ==  SDL_QUIT){
	done=true;
	break;
      }

      const int cam_speed = 8;
    
    switch ( event.type )
      {
      case SDL_KEYDOWN:
	switch (event.key.keysym.sym)
	  {
	  case SDLK_q:
	    done=true;
	    break;
	  case SDLK_s:
	    map_save(p_map, p_game->map_save_path);
	    break;
	  case SDLK_LEFT:
	    p_map->o_camera.x -= cam_speed;
	    break;
	  case SDLK_RIGHT:
	    p_map->o_camera.x += cam_speed;
	    break;
	  case SDLK_UP:
	    p_map->o_camera.y -= cam_speed;
	    break;
	  case SDLK_DOWN:
	    p_map->o_camera.y += cam_speed;
	    break;
	  default:
	    break;
	  }
	break;
      case SDL_MOUSEBUTTONDOWN:
	map_tile_click(p_map,
		       event.button.x,
		       event.button.y,
		       event.button.button);	  
	break;
      case SDL_MOUSEMOTION:
	map_mouse_move(p_map,
		       renderer,
		       event.button.x,
		       event.button.y);
	break;	  
      case SDL_MOUSEWHEEL:
	if(event.button.x < 0)
	  p_map->o_camera.y--;
	else if(event.button.x > 0)
	  p_map->o_camera.y++;
	break;
      default:
	break;
      }
    }

    //render
    SDL_RenderPresent(renderer);
  }
    
  return ret_code;
}
Esempio n. 8
0
std::shared_ptr<Texture> Generic::Load(std::vector<std::vector<int>> map, std::shared_ptr<Entity> ent, std::string path, unsigned width, unsigned height, float starting_point_x, float starting_point_y, int frame_width, int frame_height)
{
	if (!path.size())
	{
		Output_Handler::Error << "ERR Generic::Load : No path supplied\n";
		return nullptr;
	}
	if (!map.size() || !map[0].size())
	{
		Output_Handler::Error << "ERR Generic::Change : Given map has width/height equal to 0\n";
		return nullptr;
	}

	SDL_Texture* gt = nullptr;
	for (auto& ttr : Texture::__Textures) if (path == ttr->__Path && dynamic_cast<Generic*>(ttr.get()))
	{
		gt = dynamic_cast<Generic*>(ttr.get())->__Generic_Texture;
		break;
	}
	if (!gt) gt = IMG_LoadTexture(Screen::Renderer, path.c_str());
	if (!gt)
	{
		Output_Handler::Error << "ERR Texture::Load : No valid texture file supplied\n";
		return nullptr;
	}

	auto texture = SDL_CreateTexture
		(
		Screen::Renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET,
		frame_width * map[0].size(),
		frame_height * map.size()
		);
	if (!texture)
	{
		Output_Handler::Error << "ERR Texture::Load : Couldn't create SDL_Texture (probably size is too big)\n";
		SDL_DestroyTexture(gt);
		return nullptr;
	}

	Texture::__Textures.emplace_back(std::make_shared<Generic>());
	Texture::__Load(ent, Texture::__Textures.back(), frame_width * map[0].size(), frame_height * map.size(), starting_point_x, starting_point_y);
	std::shared_ptr<Generic> ts = std::static_pointer_cast<Generic>(Texture::__Textures.back());



	ts->__Generic_Texture = gt;
	ts->__Generic_Width = width;
	ts->__Generic_Height = height;
	ts->__Width = frame_width * map[0].size();
	ts->__Height = frame_height * map.size();
	ts->__SDL_Texture = texture;
	ts->__Tilemap = map;
	ts->__Path = path;

	if (frame_width == 0) ts->Frame_Width = width;
	else if (frame_width < 0) ts->Frame_Width = width / -frame_width;
	else ts->Frame_Width = frame_width;

	if (frame_height == 0) ts->Frame_Height = height;
	else if (frame_height < 0) ts->Frame_Height = height / -frame_height;
	else ts->Frame_Height = frame_height;

	if (ent) ent->texture = Texture::__Textures.back();


	SDL_SetTextureBlendMode(ts->__SDL_Texture, SDL_BLENDMODE_BLEND);
	SDL_SetRenderTarget(Screen::Renderer, ts->__SDL_Texture);


	SDL_Rect src = { 0,0, (int)frame_width, (int)frame_height };
	SDL_Rect dst = { 0,0, (int)frame_width, (int)frame_height };

	auto get_frame_pos = [&ts](int frame)->std::pair<int, int>
	{
		if (frame < 0) return std::pair<int, int>( frame, frame );
		std::pair<int, int> p;
		p.second = 0;
		p.first = frame * (int)ts->Frame_Width;
		while (p.first >= (int)ts->__Generic_Width)
		{
			p.first -= ts->__Generic_Width;
			p.second += ts->Frame_Height;
		}
		return p;
	};

	SDL_RenderClear(Screen::Renderer);
	for (unsigned i = 0; i < map.size(); i++)
	{
		for (unsigned j = 0; j < map[i].size(); j++)
		{
			if (map[i][j] < (int)ts->Tiles_Count())
			{
				auto frame_pos = get_frame_pos(map[i][j]);
				src.x = frame_pos.first;
				src.y = frame_pos.second;
			}
			else
			{
				Output_Handler::Output << "MSG Generic::Change : Tile " << map[i][j] << " doesn't exist (max " << ts->Tiles_Count() - 1 << "); no tile is drawn\n";
				src.x = 0;
				src.y = 0;
			}
			if(src.x >= 0 && src.y >= 0)
				SDL_RenderCopy(Screen::Renderer, ts->__Generic_Texture, &src, &dst);
			dst.x += frame_width;
		}
		dst.y += frame_height;
		dst.x = 0;
	}

	//ent->__Type = ET_Generic;
	SDL_SetRenderTarget(Screen::Renderer, NULL);
	return Texture::__Textures.back();
}
void StateHandler::Game()
{
    bool quit = false;
    bool quitToOs = false;

    double deltaTime = 0.0;

    GameTimer gameTimer;

    DebugInfo debugInfo(myRenderer);

    Enemy a(myRenderer, eEnemyType::Mollusk);
    Entity b(myRenderer);

    a.SetPosition(450, 450);
    b.SetPosition(500, 500);

    SDL_Event eventQueue;

    while (quit == false)
    {
        gameTimer.Update();
        deltaTime = gameTimer.GetDeltaTime();
        debugInfo.Update(gameTimer);

        while(SDL_PollEvent(&eventQueue) != 0)
        {
            if(eventQueue.type == SDL_QUIT)
            {
                quitToOs = true;
                quit = true;
            }
            else if (eventQueue.type == SDL_KEYDOWN)
            {
                switch(eventQueue.key.keysym.sym)
                {
                    case SDLK_ESCAPE:
                        quitToOs = true;
                        quit = true;
                        break;

                    case SDLK_F10:
                        debugInfo.ToggleShow();
                        break;
                }
            }
        }

        SDL_SetRenderDrawColor(myRenderer, 0x00, 0x00, 0x00, 0xFF);
        SDL_RenderClear(myRenderer);

        a.Update(deltaTime);
        //b.Update(deltaTime);

        b.Render();
        a.Render();

        debugInfo.Render();

        SDL_RenderPresent(myRenderer);
    }

    if(quitToOs == true)
    {
        SetState(eGameStates::Quit);
    }
    else
    {
        SetState(eGameStates::MainMenu);
    }
}
			void _Cairo_graphics_surfaces <_Graphics_math_float_impl>::surfaces::_Render_to_native_surface <
				_Cairo::_Cairo_graphics_surfaces <_Graphics_math_float_impl>::surfaces::_Output_surface_data*,
				basic_output_surface <_Cairo::_Cairo_graphics_surfaces <_Graphics_math_float_impl>>
			>
			(
				_Cairo::_Cairo_graphics_surfaces <_Graphics_math_float_impl>::surfaces::_Output_surface_data * & osdp,
				basic_output_surface <_Cairo::_Cairo_graphics_surfaces <_Graphics_math_float_impl>> & sfc
			)
			{
				auto& osd = *osdp;
				const cairo_filter_t cairoFilter = CAIRO_FILTER_GOOD;
				auto& data = osd.data;
				double displayWidth = static_cast<double>(data.display_dimensions.x());
				double displayHeight = static_cast<double>(data.display_dimensions.y());
				double backBufferWidth = static_cast<double>(data.back_buffer.dimensions.x());
				double backBufferHeight = static_cast<double>(data.back_buffer.dimensions.y());
				auto backBufferSfc = data.back_buffer.surface.get();
				auto displaySfc = data.display_surface.get();
				auto displayContext = data.display_context.get();
				cairo_surface_flush(backBufferSfc);
				cairo_set_operator(displayContext, CAIRO_OPERATOR_SOURCE);
				if (osd.user_scaling_callback != nullptr) {
					bool letterbox = false;
					auto userRect = osd.user_scaling_callback(sfc, letterbox);
					if (letterbox) {
						if (data._Letterbox_brush == nullopt) {
							cairo_set_source_rgb(displayContext, 0.0, 0.0, 0.0);
							cairo_paint(displayContext);
						}
						else {
							auto pttn = data._Letterbox_brush.value().data().brush.get();
							if (data._Letterbox_brush_props == nullopt) {
								cairo_pattern_set_extend(pttn, CAIRO_EXTEND_NONE);
								cairo_pattern_set_filter(pttn, CAIRO_FILTER_GOOD);
								cairo_matrix_t cPttnMatrix;
								cairo_matrix_init_identity(&cPttnMatrix);
								cairo_pattern_set_matrix(pttn, &cPttnMatrix);
								cairo_set_source(displayContext, pttn);
								cairo_paint(displayContext);
							}
							else {
								const basic_brush_props<_Cairo_graphics_surfaces<std::experimental::io2d::v1::_Graphics_math_float_impl>>& props = data._Letterbox_brush_props.value();
								cairo_pattern_set_extend(pttn, _Extend_to_cairo_extend_t(props.wrap_mode()));
								cairo_pattern_set_filter(pttn, _Filter_to_cairo_filter_t(props.filter()));
								cairo_matrix_t cPttnMatrix;
								const auto& m = props.brush_matrix();
								cairo_matrix_init(&cPttnMatrix, m.m00(), m.m01(), m.m10(), m.m11(), m.m20(), m.m21());
								cairo_pattern_set_matrix(pttn, &cPttnMatrix);
								cairo_set_source(displayContext, pttn);
								cairo_paint(displayContext);
							}
						}
					}
					cairo_matrix_t ctm;
					cairo_matrix_init_scale(&ctm, 1.0 / displayWidth / static_cast<double>(userRect.width()), 1.0 / displayHeight / static_cast<double>(userRect.height()));
					cairo_matrix_translate(&ctm, -static_cast<double>(userRect.x()), -static_cast<double>(userRect.y()));
					unique_ptr<cairo_pattern_t, decltype(&cairo_pattern_destroy)> pat(cairo_pattern_create_for_surface(backBufferSfc), &cairo_pattern_destroy);
					auto patPtr = pat.get();
					cairo_pattern_set_matrix(patPtr, &ctm);
					cairo_pattern_set_extend(patPtr, CAIRO_EXTEND_NONE);
					cairo_pattern_set_filter(patPtr, cairoFilter);
					cairo_set_source(displayContext, patPtr);
					cairo_paint(displayContext);
				}
				else {
					
					// Calculate the destRect values.
					switch (data.scl) {
						case std::experimental::io2d::scaling::letterbox:
						{
							_Render_for_scaling_uniform_or_letterbox(osd);
						} break;
						case std::experimental::io2d::scaling::uniform:
						{
							_Render_for_scaling_uniform_or_letterbox(osd);
						} break;
						
						case std::experimental::io2d::scaling::fill_uniform:
						{
							// Maintain aspect ratio and center, but overflow if needed rather than letterboxing.
							if (backBufferWidth == displayWidth && backBufferHeight == displayHeight) {
								cairo_set_source_surface(displayContext, backBufferSfc, 0.0, 0.0);
								cairo_paint(displayContext);
							}
							else {
								auto widthRatio = displayWidth / backBufferWidth;
								auto heightRatio = displayHeight / backBufferHeight;
								if (widthRatio < heightRatio) {
									cairo_set_source_rgb(displayContext, 0.0, 0.0, 0.0);
									cairo_paint(displayContext);
									cairo_matrix_t ctm;
									cairo_matrix_init_scale(&ctm, 1.0 / heightRatio, 1.0 / heightRatio);
									cairo_matrix_translate(&ctm, trunc(abs((displayWidth - (backBufferWidth * heightRatio)) / 2.0)), 0.0);
									unique_ptr<cairo_pattern_t, decltype(&cairo_pattern_destroy)> pat(cairo_pattern_create_for_surface(backBufferSfc), &cairo_pattern_destroy);
									auto patPtr = pat.get();
									cairo_pattern_set_matrix(patPtr, &ctm);
									cairo_pattern_set_extend(patPtr, CAIRO_EXTEND_NONE);
									cairo_pattern_set_filter(patPtr, cairoFilter);
									cairo_set_source(displayContext, patPtr);
									cairo_paint(displayContext);
								}
								else {
									cairo_set_source_rgb(displayContext, 0.0, 0.0, 0.0);
									cairo_paint(displayContext);
									cairo_matrix_t ctm;
									cairo_matrix_init_scale(&ctm, 1.0 / widthRatio, 1.0 / widthRatio);
									cairo_matrix_translate(&ctm, 0.0, trunc(abs((displayHeight - (backBufferHeight * widthRatio)) / 2.0)));
									unique_ptr<cairo_pattern_t, decltype(&cairo_pattern_destroy)> pat(cairo_pattern_create_for_surface(backBufferSfc), &cairo_pattern_destroy);
									auto patPtr = pat.get();
									cairo_pattern_set_matrix(patPtr, &ctm);
									cairo_pattern_set_extend(patPtr, CAIRO_EXTEND_NONE);
									cairo_pattern_set_filter(patPtr, cairoFilter);
									cairo_set_source(displayContext, patPtr);
									cairo_paint(displayContext);
								}
							}
						} break;
						case std::experimental::io2d::scaling::fill_exact:
						{
							// Maintain aspect ratio and center, but overflow if needed rather than letterboxing.
							if (backBufferWidth == displayWidth && backBufferHeight == displayHeight) {
								cairo_set_source_surface(displayContext, backBufferSfc, 0.0, 0.0);
								cairo_paint(displayContext);
							}
							else {
								auto widthRatio = displayWidth / backBufferWidth;
								auto heightRatio = displayHeight / backBufferHeight;
								cairo_matrix_t ctm;
								cairo_matrix_init_scale(&ctm, 1.0 / widthRatio, 1.0 / heightRatio);
								unique_ptr<cairo_pattern_t, decltype(&cairo_pattern_destroy)> pat(cairo_pattern_create_for_surface(backBufferSfc), &cairo_pattern_destroy);
								auto patPtr = pat.get();
								cairo_pattern_set_matrix(patPtr, &ctm);
								cairo_pattern_set_extend(patPtr, CAIRO_EXTEND_NONE);
								cairo_pattern_set_filter(patPtr, cairoFilter);
								cairo_set_source(displayContext, patPtr);
								cairo_paint(displayContext);
							}
						} break;
						case std::experimental::io2d::scaling::none:
						{
							cairo_set_source_surface(displayContext, backBufferSfc, 0.0, 0.0);
							cairo_paint(displayContext);
						} break;
						default:
						{
							assert("Unexpected _Scaling value." && false);
						} break;
					}
				}
				
				//     cairo_restore(_Native_context.get());
				// This call to cairo_surface_flush is needed for Win32 surfaces to update.
				cairo_surface_flush(displaySfc);
				cairo_set_source_rgb(displayContext, 0.0, 0.0, 0.0);

				SDL_SetRenderDrawColor(data.renderer, 0, 0, 0, 255);
				if (SDL_RenderClear(data.renderer) != 0) {
					throw ::std::system_error(::std::make_error_code(::std::errc::io_error), SDL_GetError());
				}

				// Copy Cairo canvas to SDL2 texture
				unsigned char * src = cairo_image_surface_get_data(displaySfc);
				// TODO([email protected]): compute the pitch, given  
				const int pitch = (int)backBufferWidth * 4;    // '4' == 4 bytes per pixel
				if (SDL_UpdateTexture(data.texture, nullptr, src, pitch) != 0) {
					throw ::std::system_error(::std::make_error_code(::std::errc::io_error), SDL_GetError());
				}
				if (SDL_RenderCopy(data.renderer, data.texture, nullptr, nullptr) != 0) {
					throw ::std::system_error(::std::make_error_code(::std::errc::io_error), SDL_GetError());
				}

				// Present latest image
				SDL_RenderPresent(data.renderer);
			}
int _tmain(int argc, _TCHAR* argv[])
{

	AVFormatContext	*pFormatCtx;
	int				i, videoindex;
	AVCodecContext	*pCodecCtx;
	AVCodec			*pCodec;
	char filepath[]="src01_480x272_22.h265";

	av_register_all();
	avformat_network_init();
	pFormatCtx = avformat_alloc_context();

	if(avformat_open_input(&pFormatCtx,filepath,NULL,NULL)!=0){
		printf("Couldn't open input stream.(无法打开输入流)\n");
		return -1;
	}
	if(av_find_stream_info(pFormatCtx)<0)
	{
		printf("Couldn't find stream information.(无法获取流信息)\n");
		return -1;
	}
	videoindex=-1;
	for(i=0; i<pFormatCtx->nb_streams; i++) 
		if(pFormatCtx->streams[i]->codec->codec_type==AVMEDIA_TYPE_VIDEO)
		{
			videoindex=i;
			break;
		}
	if(videoindex==-1)
	{
		printf("Didn't find a video stream.(没有找到视频流)\n");
		return -1;
	}
	pCodecCtx=pFormatCtx->streams[videoindex]->codec;
	pCodec=avcodec_find_decoder(pCodecCtx->codec_id);
	if(pCodec==NULL)
	{
		printf("Codec not found.(没有找到解码器)\n");
		return -1;
	}
	if(avcodec_open2(pCodecCtx, pCodec,NULL)<0)
	{
		printf("Could not open codec.(无法打开解码器)\n");
		return -1;
	}
	AVFrame	*pFrame,*pFrameYUV;
	pFrame=avcodec_alloc_frame();
	pFrameYUV=avcodec_alloc_frame();
	uint8_t *out_buffer=(uint8_t *)av_malloc(avpicture_get_size(PIX_FMT_YUV420P, pCodecCtx->width, pCodecCtx->height));
	avpicture_fill((AVPicture *)pFrameYUV, out_buffer, PIX_FMT_YUV420P, pCodecCtx->width, pCodecCtx->height);
//------------SDL----------------
	if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER)) {  
		printf( "Could not initialize SDL - %s\n", SDL_GetError()); 
		return -1;
	} 

	int screen_w=0,screen_h=0;
	SDL_Window *screen; 
	//SDL 2.0 Support for multiple windows
	screen_w = pCodecCtx->width;
	screen_h = pCodecCtx->height;
	screen = SDL_CreateWindow("Simplest ffmpeg player's Window", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
		screen_w, screen_h,
		SDL_WINDOW_OPENGL);

	if(!screen) {  
		printf("SDL: could not create window - exiting:%s\n",SDL_GetError());  
		return -1;
	}


	SDL_Renderer* sdlRenderer = SDL_CreateRenderer(screen, -1, 0);  
	//IYUV: Y + U + V  (3 planes)
	//YV12: Y + V + U  (3 planes)
	SDL_Texture* sdlTexture = SDL_CreateTexture(sdlRenderer, SDL_PIXELFORMAT_IYUV, SDL_TEXTUREACCESS_STREAMING,pCodecCtx->width,pCodecCtx->height);  

	SDL_Rect sdlRect;  
	sdlRect.x = 0;  
	sdlRect.y = 0;  
	sdlRect.w = screen_w;  
	sdlRect.h = screen_h;  

	int ret, got_picture;

	AVPacket *packet=(AVPacket *)av_malloc(sizeof(AVPacket));
	//Output Info-----------------------------
	printf("File Information(文件信息)---------------------\n");
	av_dump_format(pFormatCtx,0,filepath,0);
	printf("-------------------------------------------------\n");
	
	struct SwsContext *img_convert_ctx;
	img_convert_ctx = sws_getContext(pCodecCtx->width, pCodecCtx->height, pCodecCtx->pix_fmt, pCodecCtx->width, pCodecCtx->height, PIX_FMT_YUV420P, SWS_BICUBIC, NULL, NULL, NULL); 
	//--------------
	SDL_Thread *video_tid = SDL_CreateThread(sfp_refresh_thread,NULL,NULL);
	//
	//Event Loop
	SDL_Event event;
	for (;;) {
		//Wait
		SDL_WaitEvent(&event);
		if(event.type==SFM_REFRESH_EVENT){
			//------------------------------
			if(av_read_frame(pFormatCtx, packet)>=0){
				if(packet->stream_index==videoindex){
					ret = avcodec_decode_video2(pCodecCtx, pFrame, &got_picture, packet);
					if(ret < 0){
						printf("Decode Error.(解码错误)\n");
						return -1;
					}
					if(got_picture){
						sws_scale(img_convert_ctx, (const uint8_t* const*)pFrame->data, pFrame->linesize, 0, pCodecCtx->height, pFrameYUV->data, pFrameYUV->linesize);
						//SDL---------------------------
						SDL_UpdateTexture( sdlTexture, &sdlRect, pFrameYUV->data[0], pFrameYUV->linesize[0] );  
						SDL_RenderClear( sdlRenderer );  
						SDL_RenderCopy( sdlRenderer, sdlTexture, &sdlRect, &sdlRect );  
						SDL_RenderPresent( sdlRenderer );  
						//SDL End-----------------------
					}
				}
				av_free_packet(packet);
			}else{
				//Exit Thread
				thread_exit=1;
				break;
			}
		}

	}

	sws_freeContext(img_convert_ctx);

	SDL_Quit();
	//--------------
	av_free(out_buffer);
	av_free(pFrameYUV);
	avcodec_close(pCodecCtx);
	avformat_close_input(&pFormatCtx);

	return 0;
}
Esempio n. 12
0
int main( int argc, char* args[] )
{
	//Start up SDL and create window
	if( !init() )
	{
		printf( "Failed to initialize!\n" );
	}
	else
	{
		//The level tiles
		Tile* tileSet[ TOTAL_TILES ];

		//Load media
		if( !loadMedia( tileSet ) )
		{
			printf( "Failed to load media!\n" );
		}
		else
		{	
			//Main loop flag
			bool quit = false;

			//Event handler
			SDL_Event e;

			//The dot that will be moving around on the screen
			Dot dot;

			//Level camera
			SDL_Rect camera = { 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT };

			//While application is running
			while( !quit )
			{
				//Handle events on queue
				while( SDL_PollEvent( &e ) != 0 )
				{
					//User requests quit
					if( e.type == SDL_QUIT )
					{
						quit = true;
					}

					//Handle input for the dot
					dot.handleEvent( e );
				}

				//Move the dot
				dot.move( tileSet );
				dot.setCamera( camera );

				//Clear screen
				SDL_SetRenderDrawColor( gRenderer, 0xFF, 0xFF, 0xFF, 0xFF );
				SDL_RenderClear( gRenderer );

				//Render level
				for( int i = 0; i < TOTAL_TILES; ++i )
				{
					tileSet[ i ]->render( camera );
				}

				//Render dot
				dot.render( camera );

				//Update screen
				SDL_RenderPresent( gRenderer );
			}
		}
		
		//Free resources and close SDL
		close( tileSet );
	}

	return 0;
}
Esempio n. 13
0
int main(int, char**){
	//Start up SDL and make sure it went ok
	if (SDL_Init(SDL_INIT_VIDEO) != 0){
		logSDLError(std::cout, "SDL_Init");
		return 1;
	}

	//Setup our window and renderer
	SDL_Window *window = SDL_CreateWindow("Lesson 5", SDL_WINDOWPOS_CENTERED,
			SDL_WINDOWPOS_CENTERED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN);
	if (window == nullptr){
		logSDLError(std::cout, "CreateWindow");
		SDL_Quit();
		return 1;
	}
	SDL_Renderer *renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
	if (renderer == nullptr){
		logSDLError(std::cout, "CreateRenderer");
		cleanup(window);
		SDL_Quit();
		return 1;
	}
	const std::string resPath = getResourcePath("Lesson5");
	SDL_Texture *image = loadTexture(resPath + "image.png", renderer);
	if (image == nullptr){
		cleanup(image, renderer, window);
		IMG_Quit();
		SDL_Quit();
		return 1;
	}

	//iW and iH are the clip width and height
	//We'll be drawing only clips so get a center position for the w/h of a clip
	int iW = 100, iH = 100;
	int x = SCREEN_WIDTH / 2 - iW / 2;
	int y = SCREEN_HEIGHT / 2 - iH / 2;

	//Setup the clips for our image
	SDL_Rect clips[4];
	//Since our clips our uniform in size we can generate a list of their
	//positions using some math (the specifics of this are covered in the lesson)
	for (int i = 0; i < 4; ++i){
		clips[i].x = i / 2 * iW;
		clips[i].y = i % 2 * iH;
		clips[i].w = iW;
		clips[i].h = iH;
	}
	//Specify a default clip to start with
	int useClip = 0;

	SDL_Event e;
	bool quit = false;
	while (!quit){
		//Event Polling
		while (SDL_PollEvent(&e)){
			if (e.type == SDL_QUIT){
				quit = true;
			}
			//Use number input to select which clip should be drawn
			if (e.type == SDL_KEYDOWN){
				switch (e.key.keysym.sym){
					case SDLK_1:
						useClip = 0;
						break;
					case SDLK_2:
						useClip = 1;
						break;
					case SDLK_3:
						useClip = 2;
						break;
					case SDLK_4:
						useClip = 3;
						break;
					case SDLK_ESCAPE:
						quit = true;
						break;
					default:
						break;
				}
			}
		}
		//Rendering
		SDL_RenderClear(renderer);
		//Draw the image
		renderTexture(image, renderer, x, y, &clips[useClip]);
		//Update the screen
		SDL_RenderPresent(renderer);
	}
	//Clean up
	cleanup(image, renderer, window);
	IMG_Quit();
	SDL_Quit();

	return 0;
}
Esempio n. 14
0
/******************************************************************************
 * Display BackBuffer Flipping
******************************************************************************/
void display::flip() {
    SDL_SetRenderDrawColor(pRenderer, 0, 0, 0, 255);
    SDL_RenderPresent(pRenderer);
    SDL_RenderClear(pRenderer);
}
Esempio n. 15
0
void Game::Draw() {
	SDL_RenderClear(m_pRenderer);

	switch (StateManager::stateMachine->getCurrentGameStates()) {
	case MENU:


		m_StartGameMenu.backGroundMenu.Draw(m_pRenderer);
		//		buttonsMenu.Draw(m_pRenderer);
		for (int iter = 0; iter < 5; iter++)
			m_StartGameMenu.m_buttonSet[iter].Draw(m_pRenderer);
//		txt.Draw(m_pRenderer);
//		level.Draw(m_pRenderer);
		break;

	case STARTGAME:

		texture.Draw(m_pRenderer);
//			for (int iter = 0; iter < 14; iter++)
//					m_cardSet[iter].Draw(m_pRenderer);
		m_cardLogic.Draw(m_pRenderer);
		m_Play.Draw(m_pRenderer);
		m_Bet.Draw(m_pRenderer);
		m_WIN.Draw(m_pRenderer);
		m_Credits.Draw(m_pRenderer);
		m_Menu.Draw(m_pRenderer);  //BUTTON MENU
		txt.Draw(m_pRenderer);
		break;

	case RULES_OF_GAMES:
		m_StartGameMenu.backGroundForTeam.DrawRules(m_pRenderer);
		break;

	case TEAM_PROJECT:
		m_StartGameMenu.backGroundForTeam.DrawTeam(m_pRenderer);
		break;

	case GAMEOVER:

		texture.Draw(m_pRenderer);
		m_Play.Draw(m_pRenderer);
		m_Bet.Draw(m_pRenderer);
		m_WIN.Draw(m_pRenderer);
		m_Credits.Draw(m_pRenderer);
		m_Menu.Draw(m_pRenderer);  //BUTTON MENU
		break;

	case VIEW_CARDS:
		if (m_Play.isIsClicked()) {
			m_cardLogic.GetCardFromDeck();
			m_cardLogic.m_TwoCard.clear();
			m_Play.setIsClicked(false);
		}

		texture.Draw(m_pRenderer);
		m_Play.Draw(m_pRenderer);
		m_Bet.Draw(m_pRenderer);
		m_WIN.Draw(m_pRenderer);
		m_Credits.Draw(m_pRenderer);
		m_Menu.Draw(m_pRenderer);  //BUTTON MENU
		m_cardLogic.Draw(m_pRenderer);
		txt.Draw(m_pRenderer);

		break;

	}

	SDL_RenderPresent(m_pRenderer);
}/*end of Draw*/
Esempio n. 16
0
int video_copy_screen(s_screen *src)
{
    void *data;
    int pitch, linew, i, h;
    unsigned char *sp;
    unsigned char *dp;
    SDL_Rect rectdes, rectsrc;
    rectsrc.x = rectsrc.y = 0;
    rectsrc.w = textureWidth;
    rectsrc.h = textureHeight;
    int hide_touch;
    extern int hide_t;

    linew = src->width * bytes_per_pixel;
    if(bscreen)
    {
        if(src->width != bscreen->w || src->height != bscreen->h)
        {
            return 0;
        }

        if(SDL_MUSTLOCK(bscreen))
        {
            SDL_LockSurface(bscreen);
        }
        sp = (unsigned char *)src->data;
        dp = bscreen->pixels;
        h = src->height;
        do
        {
            //u16pcpy((unsigned short*)dp, sp, glpalette, linew);
            i = linew - 1;
            do
            {
                ((unsigned *)dp)[i] = glpalette[sp[i]];
            }
            while(i--);
            sp += linew;
            dp += bscreen->pitch;
        }
        while(--h);
        data = bscreen->pixels;
        pitch = bscreen->pitch;
    }
    else
    {
        data = src->data;
        pitch = linew;
    }
    SDL_UpdateTexture(texture, &rectsrc, data, pitch);
    if(bscreen && SDL_MUSTLOCK(bscreen))
    {
        SDL_UnlockSurface(bscreen);
    }

    if(stretch)
    {
        //rectdes.w = textureWidth;
        //rectdes.h = textureHeight;
        //rectdes.x = (viewportWidth-rectdes.w)/2;
        //rectdes.y = (viewportHeight-rectdes.h)/2;
        rectdes.w = viewportWidth;
        rectdes.h = viewportHeight;
        rectdes.x = 0;
        rectdes.y = 0;
    }
    else if(savedata.glscale > 0)
    {
        rectdes.w = textureWidth * savedata.glscale;
        rectdes.h = textureHeight * savedata.glscale;
        rectdes.x = (viewportWidth - rectdes.w) / 2;
        rectdes.y = (viewportHeight - rectdes.h) / 2;
        if(rectdes.h < viewportHeight - 2)
        {
            if(screendocking & DOCKTOP)
            {
                rectdes.y = 1;
            }
            else if(screendocking & DOCKBOTTOM)
            {
                rectdes.y = viewportHeight - 1 - rectdes.h;
            }
        }
        if(rectdes.w < viewportWidth - 2)
        {
            if(screendocking & DOCKLEFT)
            {
                rectdes.x = 1;
            }
            else if(screendocking & DOCKRIGHT)
            {
                rectdes.x = viewportWidth - 1 - rectdes.w;
            }
        }
    }
    else if((float)viewportWidth / (float)viewportHeight > (float)textureWidth / (float)textureHeight)
    {
        rectdes.h = viewportHeight;
        rectdes.w = rectdes.h * textureWidth / textureHeight;
        rectdes.x = (viewportWidth - rectdes.w) / 2;
        rectdes.y = 0;
    }
    else
    {
        rectdes.w = viewportWidth;
        rectdes.h = rectdes.w * textureHeight / textureWidth;
        rectdes.y = (viewportHeight - rectdes.h) / 2;
        rectdes.x = 0;
    }

    //SDL_SetHintWithPriority(SDL_HINT_RENDER_SCALE_QUALITY, savedata.glfilter[savedata.fullscreen]?"linear":"nearest", SDL_HINT_DEFAULT);
    SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
    SDL_RenderClear(renderer);
    SDL_RenderCopy(renderer, texture, &rectsrc, &rectdes);

    hide_touch = (timer_gettick() > hide_t);
    for(i = 0, h = 0; i < MAXTOUCHB; i++)
    {
        h += touchstates[i];
        if(!hide_touch && (i != SDID_SCREENSHOT || touchstates[i]))
        {
            SDL_SetTextureAlphaMod(buttons, touchstates[i] ? 128 : 64);
            SDL_RenderCopy(renderer, buttons, &btnsrc[i], &btndes[i]);
        }
    }
    if(h)
    {
        hide_t = timer_gettick() + 5000;
    }
    SDL_RenderPresent(renderer);

    SDL_Delay(1);
    return 1;
}
Esempio n. 17
0
int main(int argc, char* args[])
{
	Screen screen = {};
	screen.width = SQUARE_DIM*SCALE*COLUMNS;
	screen.height = SQUARE_DIM*SCALE*ROWS;
	
	//init everything (window, main surface, renderer, SDL_Image)
	//NOTE: This is probably a bad way to do this since I am changing data inside function instead of returning something
	if(!init(&screen))
	{
		printf("Something could not be initialized! Error: %s\n", SDL_GetError());
	}

	//set Texture class render pointer
	Texture::setRenderer(screen.renderer);

	//set Square's main texture
	Square::setTexture("tiles.png");

	//create a blockbuilder
	BlockBuilder builder;

	//get a block pointer
	Block* block = null;

	//create an array for the Tetris board that will hold all inanimate squares
	Board board = {0};
	//int numGrid = ROWS*COLUMNS;
	//Square board_squares[ROWS*COLUMNS];
	
	//set up locations for board squares
	board.numSquares = COLUMNS*ROWS;	
	for(int i = 0; i < board.numSquares; ++i)
	{
		int x = (i%COLUMNS)*SQUARE_DIM*SCALE;
		int y = (i/COLUMNS)*SQUARE_DIM*SCALE;

		board.squares[i].setX(x);
		board.squares[i].setY(y);
		board.squares[i].concrete = 0;
	}

	//create vector for blocks
	//std::vector<Block*> blocks;
	//blocks.push_back(builder.buildBlock(L_BLOCK, RED, 0, 0));

	bool quit = false;
	SDL_Event event;
	
	//timer variables
	uint32 currentTime = SDL_GetTicks();
	uint32 previousTime = 0;

	//init RNG
	srand(time(0));

	Color colors[4];
	colors[0] = RED;
	colors[1] = BLUE;
	colors[2] = GREEN;
	colors[3] = YELLOW;

	BlockType blockTypes[5];

	blockTypes[0] = T_BLOCK;
	blockTypes[1] = I_BLOCK;
	blockTypes[2] = O_BLOCK;
	blockTypes[3] = S_BLOCK;
	blockTypes[4] = L_BLOCK;

	while(!quit)
	{
		//check to see if there is no active block
		if(!block)
		{
			int color = rand()%4;
			int blockType = rand()%5;
			block = builder.buildBlock(blockTypes[blockType], colors[color], 210, 30);
			block->setLowestPoint(board.blocksInColumn);
			//block->setLowestBlockY();
		}

		while(SDL_PollEvent(&event))
		{
			if(event.type == SDL_QUIT)
			{
				quit = true;
				printf("QUITTING! Another successful run! :)\n");
			}	
			else if(event.type == SDL_KEYDOWN)
			{
				switch(event.key.keysym.sym)
				{
					case SDLK_UP:
					{
						//rotate block counter - clockwise
						block->rotateBlock(board.squares, board.blocksInColumn, -1);
					} break;

					case SDLK_DOWN:
					{
					} break;

					case SDLK_RIGHT:
					{
						block->moveBlock(VELOCITY, board.squares, board.blocksInColumn);
					} break;

					case SDLK_LEFT:
					{
						block->moveBlock(-VELOCITY, board.squares, board.blocksInColumn);
					} break;
					case SDLK_SPACE:
					{
						//first set block's squares to resting place height
						block->setToRest();
					} break;

					default:
					{
					}
				}
			
			}
			
		}
		
		//clear screen set to light gray	
		SDL_SetRenderDrawColor(screen.renderer, 0, 0, 0, 0);
		SDL_RenderClear(screen.renderer);
	
		//render the grid
		renderGrid(screen.renderer);
		//the block
		block->render();	
		//printf("Final Y: %d, LowY: %d\n", block->finalY, block->blockLowY);
		//render board
		for(int i = 0; i < board.numSquares; ++i)
		{
			if(!board.squares[i].concrete) //check if null
			{
				continue;
			}
			board.squares[i].renderBoardSquare();
		}

		//printf("x: %d y: %d\n", block->getX(), block->getY());
		SDL_RenderPresent(screen.renderer);
		
		//bool makeStatic = false; // has block reached its final resting place?

		//check to see if 1/2 of a second has passed. 
		//if so, update locationsj
 		currentTime = SDL_GetTicks();	
		if((currentTime - previousTime) > 500)
		{
			//printf("currentTime - previousTime = %d\n", currentTime - previousTime);
			//updateBlocks(&blocks, board_squares);
			if(updateBlocks(block, &board))
			{
				block = null;

				//check to see if any rows are full
				FilledRowRegion check = checkBoard(&board);

				if(check.firstFilledRow > -1) //then there is a row that is filled!
				{
					clearBoard(check.firstFilledRow, check.lastFilledRow, &board);
				}
			}
			previousTime = currentTime;
		}
		
	}
	
	SDL_DestroyRenderer(screen.renderer);
	SDL_DestroyWindow(screen.window);
	screen.window = null;

	SDL_Quit();
	IMG_Quit();
	return 0;
}
Esempio n. 18
0
void video_clearscreen()
{
    SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
    SDL_RenderClear(renderer);
    //SDL_RenderPresent(renderer);
}
Esempio n. 19
0
void Window::fill(int r, int g, int b)
{
	SDL_SetRenderDrawColor(renderer, r, 75, b, 255);
		
	SDL_RenderClear(renderer);
}
Esempio n. 20
0
void AppRenderer::clear() {
	SDL_RenderClear(this->get());
}
void CApp::OnRender()
{
	SDL_RenderClear(renderer);

	levels[currentLevel]->display(renderer, player);


	// draw loot...
	levels[currentLevel]->drawLoot(renderer, player);
	levels[currentLevel]->drawMonsters(renderer, player);
	 
	// draw player...

	if (moving_left) {
		player->direction = 0;
		player->setActiveAnimation(player->runLeft);
		if (levels[currentLevel]->getColAt(player->pos_x - 20 - (player->getWidth() / 2)/ 2, player->pos_y) != 1 && player->pos_x > 0) {
			player->pos_x -= 20 * delay;
		}
		player->idle = false;
	} else if (moving_right) {
		player->direction = 1;
		player->setActiveAnimation(player->runRight);
		if (levels[currentLevel]->getColAt(player->pos_x + 20 + (player->getWidth() / 2)/ 2, player->pos_y) != 1 && player->pos_x < levels[currentLevel]->getWidth() * 64) {
			player->pos_x += 20 * delay;
		}
		player->idle = false;
	} 
	if (jumping >= 0) {
		if (player->direction == 0) {
			player->setActiveAnimation(player->jumpLeft);
		} else {
			player->setActiveAnimation(player->jumpRight);
		}
		player->idle = false;
	}

	if (player->idle) {
		if (player->direction == 0) {
			player->setActiveAnimation(player->idleLeft);
		} else {
			player->setActiveAnimation(player->idleRight);
		}
	}

	SDL_Texture *playertex = player->getActiveAnimation()->getFrame();


	SDL_Rect dest;

	int x = player->pos_x - (player->getWidth() / 2);
	int y = player->pos_y - (player->getHeight() / 2);

	if (x > (levels[currentLevel]->getWidth() * 64) - 640) {
		x = 1280 - ((levels[currentLevel]->getWidth() * 64) - x);
	} else if (x > 640) {
		x = 640;
	}

	if (y > (levels[currentLevel]->getHeight() * 64) - 360) {
		y = 720 - ((levels[currentLevel]->getHeight() * 64) - y);
	} else if (y > 360) {
		y = 360;
	}

	dest.x = x;
	dest.y = y;
	dest.w = player->getWidth();
	dest.h = player->getHeight();

	SDL_RenderCopy(renderer, playertex, NULL, &dest);


	levels[currentLevel]->displayfg(renderer, player);
	levels[currentLevel]->drawFloaties(renderer, player, delay);
	// draw the gui
	std::stringstream ss;

	ss << "Level: " << (currentLevel + 1);

	SDL_Texture *lvlTex = RenderString(ss.str());

	SDL_QueryTexture(lvlTex, NULL, NULL, &dest.w, &dest.h);

	dest.x = 640 - (dest.w / 2);
	dest.y = 10;

	SDL_RenderCopy(renderer, lvlTex, NULL, &dest);

	ss.str("");

	ss << "Score: " << player->score;

	SDL_Texture *score = RenderString(ss.str());
	SDL_QueryTexture(score, NULL, NULL, &dest.w, &dest.h);

	dest.x = 10;
	dest.y = 10;

	SDL_RenderCopy(renderer, score, NULL, &dest);

	SDL_RenderPresent(renderer);
}
void SDLHardwareRenderDevice::blankScreen() {
	SDL_SetRenderTarget(renderer, texture);
	SDL_SetRenderDrawColor(renderer, background_color.r, background_color.g, background_color.b, background_color.a);
	SDL_RenderClear(renderer);
	return;
}
Esempio n. 23
0
void Page::background_clear_render(int r, int g, int b, int a)
{
	SDL_SetRenderDrawColor(gRenderer, r, g, b, a);
	SDL_RenderClear(gRenderer);
}
Esempio n. 24
0
 void clear(){
     SDL_RenderClear(this->ren);
 }
Esempio n. 25
0
int
main(int argc, char *argv[])
{
    int i, done;
    SDL_Event event;

    /* Enable standard application logging */
    SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO);

    /* Initialize test framework */
    state = SDLTest_CommonCreateState(argv, SDL_INIT_VIDEO);
    if (!state) {
        return 1;
    }

    for (i = 1; i < argc;) {
        int consumed;

        consumed = SDLTest_CommonArg(state, i);
        /* needed voodoo to allow app to launch via OS X Finder */
        if (SDL_strncmp(argv[i], "-psn", 4)==0) {
            consumed = 1;
        }
        if (consumed == 0) {
            consumed = -1;
        }
        if (consumed < 0) {
            SDL_Log("Usage: %s %s\n", argv[0], SDLTest_CommonUsage(state));
            quit(1);
        }
        i += consumed;
    }
    if (!SDLTest_CommonInit(state)) {
        quit(2);
    }

    for (i = 0; i < state->num_windows; ++i) {
        SDL_Renderer *renderer = state->renderers[i];
        SDL_SetRenderDrawColor(renderer, 0xA0, 0xA0, 0xA0, 0xFF);
        SDL_RenderClear(renderer);
        SDL_RenderPresent(renderer);
    }

    SDL_EventState(SDL_DROPFILE, SDL_ENABLE);

    /* Main render loop */
    done = 0;
    while (!done) {
        /* Check for events */
        while (SDL_PollEvent(&event)) {
            SDLTest_CommonEvent(state, &event, &done);

            if (event.type == SDL_DROPBEGIN) {
                SDL_Log("Drop beginning on window %u", (unsigned int) event.drop.windowID);
            } else if (event.type == SDL_DROPCOMPLETE) {
                SDL_Log("Drop complete on window %u", (unsigned int) event.drop.windowID);
            } else if ((event.type == SDL_DROPFILE) || (event.type == SDL_DROPTEXT)) {
                const char *typestr = (event.type == SDL_DROPFILE) ? "File" : "Text";
                char *dropped_filedir = event.drop.file;
                SDL_Log("%s dropped on window %u: %s", typestr, (unsigned int) event.drop.windowID, dropped_filedir);
                SDL_free(dropped_filedir);
            }
        }
    }

    quit(0);
    /* keep the compiler happy ... */
    return(0);
}
Esempio n. 26
0
int video_display_process(uint8_t* frame, int width, int height, int size) {

	//if we get a NULL frame, stop displaying.
	if(frame == NULL) {
		video_display_destroy();
		return 0;
	}

	//first time called ? Initialize things.
	if(!initialized) {
		if(video_display_init_size(width, height) < 0) {
			fprintf(stderr, "[~][Display] Failed initialization.\n");
			return -1;
		}
		if(video_display_set_size(width, height) < 0)
			return -1;
		initialized = 1;
	}

	//check whether the size of the video has changed
	if (width != current_width || height != current_height)
		if (video_display_set_size(width, height) < 0)
			return -1;

	//check whether there's new stuff in the input com buffer
	double new_update = jakopter_com_get_timestamp(com_in);
	if (new_update > prev_update) {
		update_infos();
		if (want_screenshot) {
			take_screenshot(frame, size);
			want_screenshot = 0;
			jakopter_com_write_int(com_in, 24, 0);
		}
		prev_update = new_update;
	}
	pthread_mutex_lock(&mutex_process);

	if (current_process != NULL) {
		current_process(frame, width, height, size);
	}
	pthread_mutex_unlock(&mutex_process);

	unload_element();

	if (load_element() < 0)
		fprintf(stderr, "Couldn't load graphic element\n");

	// update the texture with our new frame
	if (SDL_UpdateTexture(frameTex, NULL, frame, width) < 0) {
		fprintf(stderr, "[~][Display] Failed to update frame texture : %s\n", SDL_GetError());
		return -1;
	}

	//clear the renderer, then update it so that we get the new frame displayed.
	SDL_RenderClear(renderer);
	SDL_RenderCopy(renderer, frameTex, NULL, NULL);
	//SDL_RenderFillRect(renderer, &rectangle);
	//draw all overlay elements, when they exist
	int i = 0;
	for (i = 0 ; i < VIDEO_NB_NAV_INFOS ; i++)
		if (graphs[i].tex != NULL)
			SDL_RenderCopy(renderer, graphs[i].tex, NULL, &graphs[i].pos);

	pthread_mutex_lock(&mutex_graphics_list);
	struct graphics_list *current = icon_registry;
	while (current != NULL) {
		if (current->graphic != NULL && current->graphic->tex != NULL){
			int ret = SDL_RenderCopy(renderer, current->graphic->tex, NULL, &current->graphic->pos);
			if (ret < 0)
				fprintf(stderr, "[~][display] RenderCopy() failed: %s\n", SDL_GetError());
		}

		current = current->next;
	}
	pthread_mutex_unlock(&mutex_graphics_list);

	draw_attitude_indic();
	draw_compass();
	SDL_RenderPresent(renderer);

	return 0;
}
int main( int argc, char* args[] )
{
	//Start up SDL and create window
	if( !init() )
	{
		printf( "Failed to initialize!\n" );
	}
	else
	{
		//Load media
		if( !loadMedia() )
		{
			printf( "Failed to load media!\n" );
		}
		else
		{	
			//Main loop flag
			bool quit = false;

			//Event handler
			SDL_Event e;

			//Text rendering color
			SDL_Color textColor = { 0, 0, 0, 0xFF };
			SDL_Color highlightColor = { 0xFF, 0, 0, 0xFF };

			//Current input point
			int currentData = 0;

			//While application is running
			while( !quit )
			{
				//Handle events on queue
				while( SDL_PollEvent( &e ) != 0 )
				{
					//User requests quit
					if( e.type == SDL_QUIT )
					{
						quit = true;
					}
					else if( e.type == SDL_KEYDOWN )
					{
						switch( e.key.keysym.sym )
						{
							//Previous data entry
							case SDLK_UP:
							//Rerender previous entry input point
							gDataTextures[ currentData ].loadFromRenderedText( std::to_string( (_Longlong)gData[ currentData ] ), textColor );
							--currentData;
							if( currentData < 0 )
							{
								currentData = TOTAL_DATA - 1;
							}
							
							//Rerender current entry input point
							gDataTextures[ currentData ].loadFromRenderedText( std::to_string( (_Longlong)gData[ currentData ] ), highlightColor );
							break;
							
							//Next data entry
							case SDLK_DOWN:
							//Rerender previous entry input point
							gDataTextures[ currentData ].loadFromRenderedText( std::to_string( (_Longlong)gData[ currentData ] ), textColor );
							++currentData;
							if( currentData == TOTAL_DATA )
							{
								currentData = 0;
							}
							
							//Rerender current entry input point
							gDataTextures[ currentData ].loadFromRenderedText( std::to_string( (_Longlong)gData[ currentData ] ), highlightColor );
							break;

							//Decrement input point
							case SDLK_LEFT:
							--gData[ currentData ];
							gDataTextures[ currentData ].loadFromRenderedText( std::to_string( (_Longlong)gData[ currentData ] ), highlightColor );
							break;
							
							//Increment input point
							case SDLK_RIGHT:
							++gData[ currentData ];
							gDataTextures[ currentData ].loadFromRenderedText( std::to_string( (_Longlong)gData[ currentData ] ), highlightColor );
							break;
						}
					}
				}

				//Clear screen
				SDL_SetRenderDrawColor( gRenderer, 0xFF, 0xFF, 0xFF, 0xFF );
				SDL_RenderClear( gRenderer );

				//Render text textures
				gPromptTextTexture.render( ( SCREEN_WIDTH - gPromptTextTexture.getWidth() ) / 2, 0 );
				for( int i = 0; i < TOTAL_DATA; ++i )
				{
					gDataTextures[ i ].render( ( SCREEN_WIDTH - gDataTextures[ i ].getWidth() ) / 2, gPromptTextTexture.getHeight() + gDataTextures[ 0 ].getHeight() * i );
				}

				//Update screen
				SDL_RenderPresent( gRenderer );
			}
		}
	}

	//Free resources and close SDL
	close();

	return 0;
}
Esempio n. 28
0
void ClearScreen()
{
    SDL_RenderClear(renderer);
}
Esempio n. 29
0
void hello_world_run (HelloWorld* self) {
	gboolean quit = FALSE;
	SDL_Event e = {0};
	gint frame = 0;
	g_return_if_fail (self != NULL);
	quit = FALSE;
	frame = 0;
	while (TRUE) {
		gboolean _tmp0_ = FALSE;
		SDL_Renderer* _tmp5_ = NULL;
		SDL_Renderer* _tmp6_ = NULL;
		SDL_Rect currentClip = {0};
		gint _tmp7_ = 0;
		SDL_Rect _tmp8_ = {0};
		MyTexture* _tmp9_ = NULL;
		SDL_Renderer* _tmp10_ = NULL;
		SDL_Rect _tmp11_ = {0};
		gint _tmp12_ = 0;
		SDL_Rect _tmp13_ = {0};
		gint _tmp14_ = 0;
		SDL_Rect _tmp15_ = {0};
		SDL_Renderer* _tmp16_ = NULL;
		gint _tmp17_ = 0;
		gint _tmp18_ = 0;
		_tmp0_ = quit;
		if (!(!_tmp0_)) {
			break;
		}
		while (TRUE) {
			SDL_Event _tmp1_ = {0};
			gint _tmp2_ = 0;
			SDL_Event _tmp3_ = {0};
			SDL_EventType _tmp4_ = 0;
			_tmp2_ = SDL_PollEvent (&_tmp1_);
			 (e);
			e = _tmp1_;
			if (!(_tmp2_ != 0)) {
				break;
			}
			_tmp3_ = e;
			_tmp4_ = _tmp3_.type;
			if (_tmp4_ == SDL_QUIT) {
				quit = TRUE;
			}
		}
		_tmp5_ = self->priv->renderer;
		SDL_SetRenderDrawColor (_tmp5_, (guint8) 0xFF, (guint8) 0xFF, (guint8) 0xFF, (guint8) SDL_ALPHA_OPAQUE);
		_tmp6_ = self->priv->renderer;
		SDL_RenderClear (_tmp6_);
		_tmp7_ = frame;
		_tmp8_ = self->priv->spriteClips[_tmp7_ / 4];
		currentClip = _tmp8_;
		_tmp9_ = self->priv->spriteSheetTexture;
		_tmp10_ = self->priv->renderer;
		_tmp11_ = currentClip;
		_tmp12_ = _tmp11_.w;
		_tmp13_ = currentClip;
		_tmp14_ = _tmp13_.h;
		_tmp15_ = currentClip;
		my_texture_render (_tmp9_, _tmp10_, (HELLO_WORLD_SCREEN_WIDTH - _tmp12_) / 2, (HELLO_WORLD_SCREEN_HEIGHT - _tmp14_) / 2, &_tmp15_);
		_tmp16_ = self->priv->renderer;
		SDL_RenderPresent (_tmp16_);
		_tmp17_ = frame;
		frame = _tmp17_ + 1;
		_tmp18_ = frame;
		if ((_tmp18_ / 4) >= HELLO_WORLD_WALKING_ANIMATION_FRAMES) {
			frame = 0;
		}
	}
	 (e);
}
Esempio n. 30
0
void World::Render(GUIstate* state)
{
    SDL_RenderClear(m_render);
    Background_layer_one->Draw(0,0,0,true,m_render);
    for(unsigned int i = 0;i<m_meteorite.size();i++)
    {
        m_meteorite[i]->DrawMeteorite(true, m_render);
        m_meteorite[i]->Update();
    }
    Background_layer_two->Draw(0,0,0,true,m_render);
    for(unsigned int i = 0;i<m_meteorite_two.size();i++)
    {
        m_meteorite_two[i]->DrawMeteorite(true, m_render);
        m_meteorite_two[i]->Update();
    }
    if(state->m_gravity_active==1)
    {
        m_gravity->Draw((m_WWidth/2)-( m_gravity->m_img_width/2),(m_WHeight/2)-( m_gravity->m_img_height/2),1,true,m_render);
    }
    else
    {
        m_gravity->Draw((m_WWidth/2)-( m_gravity->m_img_width/2),(m_WHeight/2)-( m_gravity->m_img_height/2),0,true,m_render);
    }
    Background_layer_three->Draw(0,0,0,true,m_render);
    for(unsigned int i = 0;i<m_meteorite_three.size();i++)
    {
        m_meteorite_three[i]->DrawMeteorite(true, m_render);
        m_meteorite_three[i]->Update();
    }

    for(unsigned int i = 0;i<m_Players.size();i++)
    {
        if(m_Players[i]->m_HP>0)
        {
            m_Players[i]->Draw(m_render);
        }
        else
        {
            if(!m_Players[i]->m_once_dead) m_Players[i]->CalculateDeath();
            m_Players[i]->m_alive = m_Players[i]->Draw_Destroy_Ship(m_render);
        }
    }



    if(state->m_planet_active == 1)
    {
        m_planet_glow->Draw((m_WWidth/2)-( m_planet_glow->m_img_width/2),(m_WHeight/2)-( m_planet_glow->m_img_height/2),0,true,m_render);
        Planet->Draw((m_WWidth/2)-(Planet->m_passive_img_width/2),(m_WHeight/2)-(Planet->m_passive_img_height/2), 0, true,m_render);
    }

    int percent = (m_Players[0]->m_HP*100)/m_Players[0]->m_FullHP;
    hp_bar1->Draw_HpBar(0, 10,percent, m_render);
    int percent2 = (m_Players[1]->m_HP*100)/m_Players[1]->m_FullHP;
    hp_bar2->Draw_HpBar2(m_WWidth-(hp_bar2->m_passive_img_width), m_WHeight-(hp_bar2->m_passive_img_height),percent2, m_render);

    m_score_bar->Draw((m_WWidth/2)-(m_score_bar->m_img_width/2),0, 0, true,m_render);
    m_magenta_numbers->DrawButton (m_Players[0]->m_lives, m_render);
    m_cyan_numbers->DrawButton (m_Players[1]->m_lives, m_render);

    if(m_Players[0]->m_lives == 0||m_Players[1]->m_lives == 0)
    {

        m_OpacityFill->Draw(0,0,0,true,m_render);
        if(m_Players[0]->m_lives == 0 && !m_Players[0]->m_alive)
        {
           Player2Win->Draw((m_WWidth/2)-(Player1Win->m_img_width/2),(m_WHeight/2)-(Player1Win->m_img_height/2), 0, true,m_render);
        }
        else if(!m_Players[1]->m_alive)
        {
           Player1Win->Draw((m_WWidth/2)-(Player2Win->m_img_width/2),(m_WHeight/2)-(Player2Win->m_img_height/2), 0, true,m_render);
        }
    }
    SDL_RenderPresent(m_render);
}