int main(int argc,char** argv) { SDL_Init(SDL_INIT_EVERYTHING); //init the SDL SDL_Surface* screen=SDL_SetVideoMode(BLOCK_SIZE*WIDTH+BLOCK_SIZE*10,BLOCK_SIZE*HEIGHT,32,SDL_SWSURFACE); //and our screen TTF_Init(); //the TTF as well, cus we want to write out stuff TTF_Font* font=TTF_OpenFont("air.ttf",12); Uint32 start; //the start time, to limit FPS bool running=true; //is the program still running? SDL_Event event; //What event has happened? srand(time(0)); //seed the random number generator int db=0; //how many blocks do we have (init 0)? int elements[8][4][4]; //we store all of the blocks in this 3D array int table[HEIGHT][WIDTH]; //This is our whole game-table, all of the blocks, which already put down is stored here int currentblock[4][4]; //our current falling block fillelement(elements,db); //load the blocks SDL_Surface* blocks=SDL_LoadBMP("blocks.bmp"); //load the image, which stores, the part of the images SDL_SetColorKey(blocks,SDL_SRCCOLORKEY,SDL_MapRGB(screen->format,255,0,255)); //The purple color should be invisible int blockx; //the init position of the falling block int blocky; bool h; //if it's the 1. or 2. block, we need 4x4, else 3x3 Uint32 lastmove=SDL_GetTicks(); //how often should the block come down one Uint32 lastkey=SDL_GetTicks(); //how often should react the block, when the key is pressed (without release) bool keys[2]={0,0}; //if left arrow pressed, than keys[0]=1 if right arrow is pressed keys[1]=1 int points; int normalspeed; //how quick the tetris blocks fall (in this case once every 0.5 seconds) int speed=500; //the speed, the game currently running (the speed increase, when you press the down arrow) const int FPS=30; //how many FPS the game will run (this effect minimally, how quick the blocks fall) int nextblock; //what is the next block? int deletedlines; //how much lines we already deleted int movingspeed=400; //if we hold down the left/right arrow, how often (150ms) we want to move the block int quickmovingspeed=30; bool mousepointing=false; //do we pointing to the toplist text? int tmpx,tmpy; //the location of the mouse cursor //we initialize the game (set every parameter to default) initGame(&blockx,&blocky,&h,elements,table,currentblock,&normalspeed,&points,&deletedlines,&nextblock,&speed,db); int moved=0; while(running) //while the game running { start=SDL_GetTicks(); //get the current time (for FPS limitation) while(SDL_PollEvent(&event)) { switch(event.type) { case SDL_KEYDOWN: switch(event.key.keysym.sym) { case SDLK_ESCAPE: //if escape is pressed, escape running=false; break; case SDLK_UP: //if up arrow is pressed rotateleft(currentblock,h); //rotate the block if(checkCollision(currentblock,blockx,blocky,table)) //and check if there is a collision for(int i=0;i<3;i++) rotateleft(currentblock,h); //if there was a collision, rotate back (rotate 4 times, is like if you haven't done anything) break; case SDLK_LEFT: keys[0]=1; break; case SDLK_RIGHT: keys[1]=1; break; case SDLK_DOWN: speed=10; //if down key is pressed, speed up a little bit break; } break; case SDL_KEYUP: switch(event.key.keysym.sym) { case SDLK_DOWN: speed=normalspeed; //if you released the down arrow, set back the speed break; case SDLK_LEFT: keys[0]=0; moved=0; break; case SDLK_RIGHT: keys[1]=0; moved=0; break; } break; case SDL_QUIT: running=false; break; case SDL_MOUSEMOTION: //if we moved the mouse tmpx=event.motion.x; //get the coordinates tmpy=event.motion.y; //if we are pointing to the square, which contain the toplist text if(tmpx>BLOCK_SIZE*WIDTH+2 && tmpx<BLOCK_SIZE*WIDTH+80 && tmpy>80+BLOCK_SIZE*5 && tmpy<80+BLOCK_SIZE*5+20) mousepointing=true; //make this boolean true else mousepointing=false; //else false break; case SDL_MOUSEBUTTONDOWN: //if we hit the mousebutton tmpx=event.button.x; tmpy=event.button.y; //on the toplist text if(tmpx>BLOCK_SIZE*WIDTH && tmpx<BLOCK_SIZE*WIDTH+80 && tmpy>80+BLOCK_SIZE*5 && tmpy<80+BLOCK_SIZE*5+20) displayToplist(font); //display it break; } } //LOGIC //if the collision happens, and the block is at the top of the screen, than game is over if(checkCollision(currentblock,blockx,blocky,table) && blocky==0) { if(addToplist(font,points)) //try to add out points to the toplist, if addtoplist returns 1, restart the game initGame(&blockx,&blocky,&h,elements,table,currentblock,&normalspeed,&points,&deletedlines,&nextblock,&speed,db); else running=false; //else we exit } //if we exceeded the time, how often should it go down, than move it down, and set back the time if(SDL_GetTicks()-lastmove>speed) { blocky++; lastmove=SDL_GetTicks(); } //if (left) key was pressed, and last time, when we moved the block is more than 200ms, than move it again if((keys[0] && moved>=2 && SDL_GetTicks()-lastkey>quickmovingspeed) || (keys[0] && moved==0) || (keys[0] && moved==1 && SDL_GetTicks()-lastkey>movingspeed)) { blockx--; //move moved++; lastkey=SDL_GetTicks(); //set back the time if(checkCollision(currentblock,blockx,blocky,table)==1)//if there is a collision blockx++; //move back }else if((keys[1] && moved>=2 && SDL_GetTicks()-lastkey>quickmovingspeed) || (keys[1] && moved==0) || (keys[1] && moved==1 && SDL_GetTicks()-lastkey>movingspeed)) //same with right arrow { blockx++; moved++; lastkey=SDL_GetTicks(); if(checkCollision(currentblock,blockx,blocky,table)==1) blockx--; } //RENDER SDL_FillRect(screen,&screen->clip_rect,SDL_MapRGB(screen->format,0,0,0)); //clear the screen for(int i=0;i<24;i++) //render out the table for(int j=0;j<12;j++) { if(!table[i][j]) //if a value=0, than don't do anything, else draw the corresponding block (1 is the first block on the images, 2 is the 2...) continue; else blitSurface(blocks,(table[i][j]-1)*BLOCK_SIZE,0,BLOCK_SIZE,BLOCK_SIZE,screen,j*BLOCK_SIZE,i*BLOCK_SIZE,BLOCK_SIZE,BLOCK_SIZE); } //render the falling block for(int i=0;i<4;i++) for(int j=0;j<4;j++) { if(currentblock[i][j]) //if not "empty", draw the corresponding block blitSurface(blocks,(currentblock[i][j]-1)*BLOCK_SIZE,0,BLOCK_SIZE,BLOCK_SIZE,screen,blockx*BLOCK_SIZE+j*BLOCK_SIZE,blocky*BLOCK_SIZE+i*BLOCK_SIZE,BLOCK_SIZE,BLOCK_SIZE); } //here I check the collision, first I move the object down blocky++; if(checkCollision(currentblock,blockx,blocky,table))//and if there is a collision { blocky--; //move back for(int i=0;i<4;i++) for(int j=0;j<4;j++) { if(currentblock[i][j]!=0) table[blocky+i][blockx+j]=currentblock[i][j]; //and draw the block to the table matrix (except the 0), so we handle it as fallen block, it's not falling anymore } blocky=0; //and generate a new block the same way, as we did in the beginning of the main blockx=4; setCurrentblock(elements,currentblock,nextblock); h=(nextblock>2); nextblock=rand()%(db+1); }else blocky--; //if there was no collision, move the object back (else it will go every 2nd line) //this while loop will go as long, as we have full lines while(1) { int k=checkful(table); if(k==-1) break; deletedlines++; //if we have full lines for(int i=k;i>0;i--) for(int j=0;j<WIDTH;j++) table[i][j]=table[i-1][j]; //delete them, by move everything above it a line down for(int i=0;i<HEIGHT;i++) table[0][i]=0; //and 0 out the most top line (usually this has no effect, except, if there is a block-part in the top row) points+=(550-normalspeed)/10; if((points%50)==0 && normalspeed>0) //if the points are dividable by 50 (50,100,150...), speed up the game { if(normalspeed>50) normalspeed-=50; else if(normalspeed>0) normalspeed-=10; } } //render the menu SDL_Rect rec={BLOCK_SIZE*WIDTH,0,screen->clip_rect.w,screen->clip_rect.h}; //the background of the tetris is black (if you want SDL_FillRect(screen,&rec,SDL_MapRGB(screen->format,50,50,50)); //you can change it to an image) rec.x=BLOCK_SIZE*WIDTH+10; //this is the part next to the tetris (the menu) rec.w=4*BLOCK_SIZE; rec.y=20; rec.h=4*BLOCK_SIZE; SDL_FillRect(screen,&rec,SDL_MapRGB(screen->format,100,100,100)); //fill it with gray for(int i=0;i<4;i++) for(int j=0;j<4;j++) { if(elements[nextblock][i][j]) //if not "empty", draw the corresponding block { blitSurface(blocks,(elements[nextblock][i][j]-1)*BLOCK_SIZE,0,BLOCK_SIZE,BLOCK_SIZE,screen,(BLOCK_SIZE*WIDTH)+j*BLOCK_SIZE+20,20+i*BLOCK_SIZE,BLOCK_SIZE,BLOCK_SIZE); } } //draw all of the menutext (huhh, it's good, that I have this function, else it would be a 4,5 times that amount of line) writeText(font,BLOCK_SIZE*WIDTH,0,"NEXT BLOCK",255,255,255); writeText(font,BLOCK_SIZE*WIDTH,20+BLOCK_SIZE*5,"POINTS: ",255,255,255); writeText(font,BLOCK_SIZE*WIDTH+150,20+BLOCK_SIZE*5,points,255,255,255); writeText(font,BLOCK_SIZE*WIDTH,40+BLOCK_SIZE*5,"CURRENT SPEED:",255,255,255); writeText(font,BLOCK_SIZE*WIDTH+150,40+BLOCK_SIZE*5,normalspeed,255,255,255); writeText(font,BLOCK_SIZE*WIDTH,60+BLOCK_SIZE*5,"DELETED LINES: ",255,255,255); writeText(font,BLOCK_SIZE*WIDTH+150,60+BLOCK_SIZE*5,deletedlines,255,255,255); rec.x=BLOCK_SIZE*WIDTH+2; //the toplist square rec.y=80+BLOCK_SIZE*5; rec.w=80; rec.h=20; if(!mousepointing) //if we are not pointing to the toplist square, fill it with { SDL_FillRect(screen,&rec,SDL_MapRGB(screen->format,0,0,0)); //black }else { SDL_FillRect(screen,&rec,SDL_MapRGB(screen->format,255,0,0)); //else red } writeText(font,BLOCK_SIZE*WIDTH+5,80+BLOCK_SIZE*5,"TOPLIST",255,255,255); //and write the toplist text SDL_Flip(screen); //show evrything o the real screen if(1000.0/FPS>SDL_GetTicks()-start) SDL_Delay(1000.0/FPS-(SDL_GetTicks()-start)); //regulate the FPS } SDL_FreeSurface(blocks); //delete and close everything TTF_CloseFont(font); TTF_Quit(); SDL_Quit(); return 0; }
int main(int argc, char *argv[]) { SDL_Surface *screen; // Slightly different SDL initialization if ( SDL_Init(SDL_INIT_VIDEO) != 0 ) { printf("Unable to initialize SDL: %s\n", SDL_GetError()); return 1; } SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 ); // *new* screen = SDL_SetVideoMode( 640, 480, 16, SDL_OPENGL ); // *changed* if ( !screen ) { printf("Unable to set video mode: %s\n", SDL_GetError()); return 1; } // Set the OpenGL state after creating the context with SDL_SetVideoMode glClearColor( 0, 0, 0, 0 ); #ifndef __EMSCRIPTEN__ glEnable( GL_TEXTURE_2D ); // Need this to display a texture XXX unnecessary in OpenGL ES 2.0/WebGL #endif glViewport( 0, 0, 640, 480 ); glMatrixMode( GL_PROJECTION ); GLfloat matrixData[] = { 2.0/640, 0, 0, 0, 0, -2.0/480, 0, 0, 0, 0, -1, 0, -1, 1, 0, 1 }; glLoadMatrixf(matrixData); // test loadmatrix glMatrixMode( GL_MODELVIEW ); glLoadIdentity(); // Load the OpenGL texture GLuint texture; // Texture object handle SDL_Surface *surface; // Gives us the information to make the texture if ( (surface = IMG_Load("screenshot.png")) ) { // Check that the image's width is a power of 2 if ( (surface->w & (surface->w - 1)) != 0 ) { printf("warning: image.bmp's width is not a power of 2\n"); } // Also check if the height is a power of 2 if ( (surface->h & (surface->h - 1)) != 0 ) { printf("warning: image.bmp's height is not a power of 2\n"); } // Have OpenGL generate a texture object handle for us glGenTextures( 1, &texture ); // Bind the texture object glBindTexture( GL_TEXTURE_2D, texture ); // Set the texture's stretching properties glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR ); //SDL_LockSurface(surface); // Add some greyness memset(surface->pixels, 0x66, surface->w*surface->h); // Edit the texture object's image data using the information SDL_Surface gives us glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, surface->w, surface->h, 0, GL_RGBA, GL_UNSIGNED_BYTE, surface->pixels ); //SDL_UnlockSurface(surface); } else { printf("SDL could not load image.bmp: %s\n", SDL_GetError()); SDL_Quit(); return 1; } // Free the SDL_Surface only if it was successfully created if ( surface ) { SDL_FreeSurface( surface ); } // Clear the screen before drawing glClear( GL_COLOR_BUFFER_BIT ); shaders(); // Bind the texture to which subsequent calls refer to glBindTexture( GL_TEXTURE_2D, texture ); // Use clientside vertex pointers to render two items GLfloat vertexData[] = { 0, 0, 10, 10, // texture2, position2 1, 0, 300, 10, 1, 1, 300, 128, 0, 1, 10, 128, 0, 0.5, 410, 10, 1, 0.5, 600, 10, 1, 1, 630, 200, 0.5, 1, 310, 250, 0, 0, 100, 300, 1, 0, 300, 300, 1, 1, 300, 400, 0, 1, 100, 400 }; glEnableClientState(GL_TEXTURE_COORD_ARRAY); glTexCoordPointer(2, GL_FLOAT, 4*4, &vertexData[0]); glEnableClientState(GL_VERTEX_ARRAY); glVertexPointer(2, GL_FLOAT, 4*4, &vertexData[2]); glDrawArrays(GL_QUADS, 0, 12); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glDisableClientState(GL_VERTEX_ARRAY); SDL_GL_SwapBuffers(); #ifndef __EMSCRIPTEN__ // Wait for 3 seconds to give us a chance to see the image SDL_Delay(3000); #endif // Now we can delete the OpenGL texture and close down SDL glDeleteTextures( 1, &texture ); SDL_Quit(); return 0; }
bool Game::OnInit() { if (SDL_Init(SDL_INIT_EVERYTHING) < 0) { printf("SDL_Init > SDL_INIT_EVERYTHING failed.\n"); return false; } SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); if ((gameScreen = SDL_SetVideoMode(SCREEN_W, SCREEN_H, 32, SDL_OPENGL)) == NULL) { printf("Setting gameScreen failed.\n"); return false; } // enable texture 2d glEnable(GL_TEXTURE_2D); // set clear color to black glClearColor(0.0f, 0.0f, 0.0f, 0.0f); // set our viewport glViewport(0, 0, SCREEN_W, SCREEN_H); // enable alpha glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // clear screen glClear(GL_COLOR_BUFFER_BIT); // set the matrix for projection glMatrixMode(GL_PROJECTION); glLoadIdentity(); // set the ortho to the screen glOrtho(0.0f, SCREEN_W, SCREEN_H, 0.0f, -1.0f, 1.0f); // switch to model view glMatrixMode(GL_MODELVIEW); glLoadIdentity(); // load lua if ((LuaController::Controller.OnInit()) == false) { printf("Lua initialization failed.\n"); return false; } // load player if (player.OnLoad("../resources/sprites/player.png", 3, true) == false) { printf("Loading player failed.\n"); return false; } Entity::EntityStack.push_back(&player); // Load map /* if (map.OnLoad("../resources/maps/autotest.map") == false) { printf("Loading map failed.\n"); return false; } */ map.OnCreate(30, 25); Map::MapStack.push_back(&map); player.setPosition(map.getStartX(), map.getStartY()); if (debugWindow.OnLoad("../resources/sprites/window.png") == false) { printf("Loading window failed.\n"); return false; } debugWindow.setSize(160, 32); debugWindow.setPosition(8, 8); Window::WindowStack.push_back(&debugWindow); Camera::CameraControl.targetMode = TARGET_MODE_CENTER; Camera::CameraControl.SetBounds((SDL_Rect){0, 0, map.getTilesX() * TILE_SIZE, map.getTilesY() * TILE_SIZE}); SDL_WM_SetCaption("Blade Brothers Engine", "../resources/icons/icon.png"); return true; }
int main(int argc, char *argv[]) { SDL_Event event; VideoState *is; is = av_mallocz(sizeof(VideoState)); if(argc < 2) { fprintf(stderr, "Usage: test <file>\n"); exit(1); } // Register all formats and codecs av_register_all(); if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER)) { fprintf(stderr, "Could not initialize SDL - %s\n", SDL_GetError()); exit(1); } // Make a screen to put our video #ifndef __DARWIN__ screen = SDL_SetVideoMode(640, 480, 0, 0); #else screen = SDL_SetVideoMode(640, 480, 24, 0); #endif if(!screen) { fprintf(stderr, "SDL: could not set video mode - exiting\n"); exit(1); } av_strlcpy(is->filename, argv[1], 1024); // 初始化为视频缓冲准备的锁(pictq) // 因为一旦事件驱动调用视频函数, 视频函数会从 pictq 抽出预解码帧。 // 同时, 视频解码器会把信息放进去, 我们不知道那个动作会先发生。 is->pictq_mutex = SDL_CreateMutex(); is->pictq_cond = SDL_CreateCond(); // schedule_refresh 是一个将要定义的函数。它的动作是告诉系统在某个特定的毫秒数后弹出 FF_REFRESH_EVENT 事件。 schedule_refresh(is, 40); is->av_sync_type = DEFAULT_AV_SYNC_TYPE; // 生成一个新线程能完全访问原始进程中的内存,启动我们给的线程,在这种情况下, 调用 decode_thread()并与 VideoState 结构体连接。 is->parse_tid = SDL_CreateThread(decode_thread, is); if(!is->parse_tid) { av_free(is); return -1; } // 事件循环 for(;;) { SDL_WaitEvent(&event); switch(event.type) { case FF_QUIT_EVENT: case SDL_QUIT: is->quit = 1; /* * If the video has finished playing, then both the picture and * audio queues are waiting for more data. Make them stop * waiting and terminate normally. */ SDL_CondSignal(is->audioq.cond); SDL_CondSignal(is->videoq.cond); SDL_Quit(); exit(0); break; case FF_ALLOC_EVENT: alloc_picture(event.user.data1); break; case FF_REFRESH_EVENT: video_refresh_timer(event.user.data1); break; default: break; } } return 0; }
/* w, h is layer resolution */ int plat_sdl_change_video_mode(int w, int h, int force) { static int prev_w, prev_h; if (w == 0) w = prev_w; else prev_w = w; if (h == 0) h = prev_h; else prev_h = h; // skip GL recreation if window doesn't change - avoids flicker if (plat_target.vout_method == vout_mode_gl && plat_sdl_gl_active && plat_target.vout_fullscreen == old_fullscreen && !force) { return 0; } if (plat_sdl_overlay != NULL) { SDL_FreeYUVOverlay(plat_sdl_overlay); plat_sdl_overlay = NULL; } if (plat_sdl_gl_active) { gl_finish(); plat_sdl_gl_active = 0; } if (plat_target.vout_method != 0) { Uint32 flags = SDL_RESIZABLE | SDL_SWSURFACE; int win_w = window_w; int win_h = window_h; if (plat_target.vout_fullscreen) { flags |= SDL_FULLSCREEN; win_w = fs_w; win_h = fs_h; } // XXX: workaround some occasional mysterious deadlock in SDL_SetVideoMode SDL_PumpEvents(); plat_sdl_screen = SDL_SetVideoMode(win_w, win_h, 0, flags); if (plat_sdl_screen == NULL) { fprintf(stderr, "SDL_SetVideoMode failed: %s\n", SDL_GetError()); plat_target.vout_method = 0; } } if (plat_target.vout_method == vout_mode_overlay) { plat_sdl_overlay = SDL_CreateYUVOverlay(w, h, SDL_UYVY_OVERLAY, plat_sdl_screen); if (plat_sdl_overlay != NULL) { if ((long)plat_sdl_overlay->pixels[0] & 3) fprintf(stderr, "warning: overlay pointer is unaligned\n"); plat_sdl_overlay_clear(); } else { fprintf(stderr, "warning: could not create overlay.\n"); plat_target.vout_method = 0; } } else if (plat_target.vout_method == vout_mode_gl) { plat_sdl_gl_active = (gl_init(display, window, &gl_quirks) == 0); if (!plat_sdl_gl_active) { fprintf(stderr, "warning: could not init GL.\n"); plat_target.vout_method = 0; } } if (plat_target.vout_method == 0) { SDL_PumpEvents(); plat_sdl_screen = SDL_SetVideoMode(w, h, 16, SDL_SWSURFACE); if (plat_sdl_screen == NULL) { fprintf(stderr, "SDL_SetVideoMode failed: %s\n", SDL_GetError()); return -1; } } old_fullscreen = plat_target.vout_fullscreen; if (plat_sdl_resize_cb != NULL) plat_sdl_resize_cb(plat_sdl_screen->w, plat_sdl_screen->h); return 0; }
int g_Open( char *file ) { char c; int i; float f; float screenfactor; unsigned long x, y; FILE *fp; char name[32]; char valid_data[10]; Mix_Chunk *psize; gameloop = 1; hx=xres>>1; hy=yres>>1; hz = hx; screenfactor = ((float)(xres))/320.0; //SDL_Rect src, dest; //src.x=0; dest.x=0; //src.y=0; dest.y=0; //src.w=1280*screenfactor; dest.w=0; //src.h=468*screenfactor; dest.h=0; // allocate memory for tables zbuffer = (float *) malloc(sizeof(f)*yres*xres); floorbuffer = (int *) malloc(sizeof(i)*yres*xres*2); floorbuffer_s = (int *) malloc(sizeof(i)*yres*xres*2); rowbuffer = (char *) malloc(sizeof(c)*yres); // build some tables map.loaded = 0; for( x=0; x<xres; x++ ) { for( y=0; y<yres; y++ ) { floorbuffer_s[y+x*yres]=16383; floorbuffer_s[y+x*yres+vidsize]=-1; } } // load general bitmaps font8_bmp = SDL_LoadBMP("images/8font.bmp"); SDL_SetColorKey( font8_bmp, SDL_SRCCOLORKEY, SDL_MapRGB( font8_bmp->format, 255, 0, 255 ) ); font16_bmp = SDL_LoadBMP("images/16font.bmp"); SDL_SetColorKey( font16_bmp, SDL_SRCCOLORKEY, SDL_MapRGB( font16_bmp->format, 255, 0, 255 ) ); r_LoadBmp("images/console.bmp", &console_bmp); // load textures sky2_bmp = SDL_LoadBMP("images/sky.bmp"); sky_bmp = r_ScaleSurface(sky2_bmp, 1280*screenfactor,468*screenfactor); //sky_bmp = SDL_CreateRGBSurface(SDL_HWSURFACE,1280*screenfactor,468*screenfactor,32,0,0,0,0); //SDL_BlitSurface( SPG_Scale( sky2_bmp, screenfactor, screenfactor ), &src, sky_bmp, &dest ); //SDL_BlitSurface( sky2_bmp, &src, sky_bmp, &dest ); //SDL_BlitSurface( sky2_bmp, &src, sky_bmp, &dest ); fp = fopen("images/textures.txt","r"); for( texture_num=0; !feof(fp); texture_num++ ) { while( fgetc(fp) != '\n' ) if( feof(fp) ) break; } fclose(fp); walltex_bmp = (bitmap_t *) malloc(sizeof(bitmap_t)*texture_num); fp = fopen("images/textures.txt","r"); for( x=0; !feof(fp); x++ ) { fscanf(fp,"%s",name); while( fgetc(fp) != '\n' ) if( feof(fp) ) break; r_LoadBmp(name, &walltex_bmp[x]); } fclose(fp); // load sprites fp = fopen("images/sprites.txt","r"); for( sprite_num=0; !feof(fp); sprite_num++ ) { while( fgetc(fp) != '\n' ) if( feof(fp) ) break; } fclose(fp); sprite_bmp = (bitmap_t *) malloc(sizeof(bitmap_t)*sprite_num); fp = fopen("images/sprites.txt","r"); for( x=0; !feof(fp); x++ ) { fscanf(fp,"%s",name); while( fgetc(fp) != '\n' ) if( feof(fp) ) break; r_LoadBmp(name, &sprite_bmp[x]); } fclose(fp); // load weapon bitmaps r_LoadBmp( "images/pistol1.bmp", &pistol_bmp[0] ); r_LoadBmp( "images/pistol2.bmp", &pistol_bmp[1] ); r_LoadBmp( "images/pistol3.bmp", &pistol_bmp[2] ); r_LoadBmp( "images/pistol4.bmp", &pistol_bmp[3] ); r_LoadBmp( "images/pistol5.bmp", &pistol_bmp[4] ); r_LoadBmp( "images/shotgun1.bmp", &shotgun_bmp[0] ); r_LoadBmp( "images/shotgun3.bmp", &shotgun_bmp[1] ); shotgun_bmp[2] = shotgun_bmp[0]; shotgun_bmp[3] = shotgun_bmp[0]; shotgun_bmp[4] = shotgun_bmp[0]; shotgun_bmp[5] = shotgun_bmp[0]; r_LoadBmp( "images/shotgun4.bmp", &shotgun_bmp[6] ); shotgun_bmp[7] = shotgun_bmp[6]; r_LoadBmp( "images/shotgun5.bmp", &shotgun_bmp[8] ); shotgun_bmp[9] = shotgun_bmp[6]; shotgun_bmp[10] = shotgun_bmp[6]; r_LoadBmp( "images/shotgun2.bmp", &shotgun_bmp[11] ); // swapped with shotgun[1] when needed // precompute some things sprsize = 2.45*((double)yres/240); texsize = 2.5*((double)yres/240); // load a map if( strstr(file,".bsm") == NULL ) strcat(file,".bsm"); fp = fopen(file, "rb"); if( fp == NULL ) { printf( "ERROR: Could not load map file: %s\n\n", file ); g_Close(); exit(15); } // validate the file fread(valid_data, sizeof(char), strlen("BSDLMAP"), fp); if( strncmp(valid_data,"BSDLMAP",7) || fgetc(fp) != MAPVERSION ) { printf( "ERROR: Not a valid map file: %s\n\n", file ); fclose(fp); g_Close(); exit(46); } else map.loaded = 1; // lets the engine know that there's junk to be freed // header fread(map.name, sizeof(char), 32, fp); // map name fread(map.author, sizeof(char), 32, fp); // map author fread(&map.width, sizeof(int), 1, fp); // map width fread(&map.height, sizeof(int), 1, fp); // map height // allocate data map.floors = (int *) malloc(sizeof(int)*map.width*map.height); map.floors_tex = (int *) malloc(sizeof(int)*map.width*map.height); map.floors_tex2 = (int *) malloc(sizeof(int)*map.width*map.height); map.ceilings = (int *) malloc(sizeof(int)*map.width*map.height); map.ceilings_tex = (int *) malloc(sizeof(int)*map.width*map.height); map.ceilings_tex2 = (int *) malloc(sizeof(int)*map.width*map.height); // map data fread(map.floors, sizeof(int), map.width*map.height, fp); // floor height fread(map.floors_tex, sizeof(int), map.width*map.height, fp); // lower wall texture fread(map.floors_tex2, sizeof(int), map.width*map.height, fp); // floor texture fread(map.ceilings, sizeof(int), map.width*map.height, fp); // ceiling height fread(map.ceilings_tex, sizeof(int), map.width*map.height, fp); // upper wall texture fread(map.ceilings_tex2, sizeof(int), map.width*map.height, fp); // ceiling texture // close the file fclose(fp); // spawn the player if( !server ) { e_CreateEntity(); player = lastentity; player->behavior = &e_ActPlayer; player->sizex = .5; player->sizey = .5; player->sizez = 52; player->x=2.5; player->y=2.5; player->z=0; player->ang=0; } vang=0; bob1 = 0; bob2 = 0; bob3 = 1; weap_mag[2]=2; // set camera camx=8; camy=2.5; camz=0; camang=0; // initiate SDL if( SDL_Init( SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER ) == -1 ) { printf("ERROR: Could not initialize SDL. Aborting...\n\n"); g_Close(); exit(4); } //SDL_WM_GrabInput(SDL_GRAB_ON); // open audio if(Mix_OpenAudio(audio_rate, audio_format, audio_channels, audio_buffers)) { printf("Unable to open audio!\n"); exit(1); } // create a screen surface screen = SDL_CreateRGBSurface(SDL_HWSURFACE,xres,yres,32,0,0,0,0); if( !windowed ) screen2 = SDL_SetVideoMode( xres, yres, 32, SDL_HWSURFACE | SDL_FULLSCREEN ); else screen2 = SDL_SetVideoMode( xres, yres, 32, SDL_HWSURFACE ); if( screen == NULL || screen2 == NULL ) { printf("ERROR: Could not create video surface. Aborting...\n\n"); g_Close(); exit(5); } SDL_WM_SetCaption( "Bubbenstein/SDL\n\n", 0 ); SDL_ShowCursor(SDL_DISABLE); // reset the clock ot=SDL_GetTicks(); i_GetFrameRate(); // load sound effects fp = fopen("sound/sounds.txt","r"); for( sound_num=0; !feof(fp); sound_num++ ) { while( fgetc(fp) != '\n' ) if( feof(fp) ) break; } fclose(fp); sounds = (Mix_Chunk **) malloc(sizeof(psize)*sound_num); fp = fopen("sound/sounds.txt","r"); for( x=0; !feof(fp); x++ ) { fscanf(fp,"%s",name); while( fgetc(fp) != '\n' ) if( feof(fp) ) break; sounds[x] = Mix_LoadWAV(name); } fclose(fp); // load music music = Mix_LoadMUS("music/dead.ogg"); Mix_VolumeMusic(64); //Mix_PlayMusic(music, -1); musicplaying=0; // multiplayer if (SDLNet_Init() < 0) { g_Close(); printf("ERROR: SDLNet_Init: %s\n", SDLNet_GetError()); exit(EXIT_FAILURE); } // starting a server if( server ) { // listen on the host's port if( !(sd = SDLNet_UDP_Open(PORT)) ) { g_Close(); printf("ERROR: SDLNet_UDP_Open: %s\n", SDLNet_GetError()); exit(EXIT_FAILURE); } // Allocate memory for the packet if( !(packet = SDLNet_AllocPacket(512)) ) { printf("ERROR: SDLNet_AllocPacket: %s\n", SDLNet_GetError()); exit(EXIT_FAILURE); } } // joining a server else if( address != NULL ) { if( !(sd = SDLNet_UDP_Open(0)) ) { g_Close(); printf("ERROR: SDLNet_UDP_Open: %s\n", SDLNet_GetError()); exit(EXIT_FAILURE); } if( SDLNet_ResolveHost(&ip, address, PORT) < 0 ) { printf("ERROR: SDLNet_ResolveHost: %s\n", SDLNet_GetError()); exit(EXIT_FAILURE); } // Allocate memory for the packet if( !(packet = SDLNet_AllocPacket(512)) ) { printf("ERROR: SDLNet_AllocPacket: %s\n", SDLNet_GetError()); exit(EXIT_FAILURE); } } // report a success! if( address == NULL ) i_Message( "Map loaded: %s", file ); else i_Message( "Map loaded: %s\nConnected to %s", file, address ); return(0); }
void SDLWindow::create(const String& name, unsigned int width, unsigned int height, bool fullScreen, const NameValuePairList *miscParams) { int colourDepth = 32; String title = name; if(miscParams) { // Parse miscellenous parameters NameValuePairList::const_iterator opt; // Bit depth opt = miscParams->find("colourDepth"); if(opt != miscParams->end()) //check for FSAA parameter, if not ignore it... colourDepth = StringConverter::parseUnsignedInt(opt->second); // Full screen antialiasing opt = miscParams->find("FSAA"); if(opt != miscParams->end()) //check for FSAA parameter, if not ignore it... { size_t fsaa_x_samples = StringConverter::parseUnsignedInt(opt->second); if(fsaa_x_samples>1) { // If FSAA is enabled in the parameters, enable the MULTISAMPLEBUFFERS // and set the number of samples before the render window is created. SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS,1); SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES,fsaa_x_samples); } } // Window title opt = miscParams->find("title"); if(opt != miscParams->end()) //check for FSAA parameter, if not ignore it... title = opt->second; } LogManager::getSingleton().logMessage("SDLWindow::create", LML_TRIVIAL); SDL_Surface* screen; int flags = SDL_OPENGL | SDL_HWPALETTE | SDL_RESIZABLE; SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 ); // request good stencil size if 32-bit colour if (colourDepth == 32) { SDL_GL_SetAttribute( SDL_GL_STENCIL_SIZE, 8); } if (fullScreen) flags |= SDL_FULLSCREEN; LogManager::getSingleton().logMessage("Create window", LML_TRIVIAL); screen = SDL_SetVideoMode(width, height, colourDepth, flags); if (!screen) { LogManager::getSingleton().logMessage(LML_CRITICAL, String("Could not make screen: ") + SDL_GetError()); exit(1); } LogManager::getSingleton().logMessage("screen is valid", LML_TRIVIAL); mScreen = screen; mName = name; mWidth = width; mHeight = height; mActive = true; if (!fullScreen) SDL_WM_SetCaption(title.c_str(), 0); glXGetVideoSyncSGI = (int (*)(unsigned int *))SDL_GL_GetProcAddress("glXGetVideoSyncSGI"); glXWaitVideoSyncSGI = (int (*)(int, int, unsigned int *))SDL_GL_GetProcAddress("glXWaitVideoSyncSGI"); }
/** * Display a video frame * * @param st Video display state * @param title Window title * @param frame Video frame * * @return 0 if success, otherwise errorcode * * @note: On Darwin, this must be called from the main thread */ static int display(struct vidisp_st *st, const char *title, const struct vidframe *frame) { SDL_Rect rect; if (!st || !sdl.open) return EINVAL; if (!vidsz_cmp(&sdl.size, &frame->size)) { if (sdl.size.w && sdl.size.h) { info("sdl: reset size %u x %u ---> %u x %u\n", sdl.size.w, sdl.size.h, frame->size.w, frame->size.h); } sdl_reset(); } if (!sdl.screen) { int flags = SDL_HWSURFACE | SDL_ASYNCBLIT | SDL_HWACCEL; char capt[256]; if (sdl.fullscreen) flags |= SDL_FULLSCREEN; else if (sdl.resizeh) flags |= SDL_RESIZABLE; if (title) { re_snprintf(capt, sizeof(capt), "%s - %u x %u", title, frame->size.w, frame->size.h); } else { re_snprintf(capt, sizeof(capt), "%u x %u", frame->size.w, frame->size.h); } SDL_WM_SetCaption(capt, capt); sdl.screen = SDL_SetVideoMode(frame->size.w, frame->size.h, 0, flags); if (!sdl.screen) { warning("sdl: unable to get video screen: %s\n", SDL_GetError()); return ENODEV; } sdl.size = frame->size; } if (!sdl.bmp) { sdl.bmp = SDL_CreateYUVOverlay(frame->size.w, frame->size.h, SDL_YV12_OVERLAY, sdl.screen); if (!sdl.bmp) { warning("sdl: unable to create overlay: %s\n", SDL_GetError()); return ENODEV; } } SDL_LockYUVOverlay(sdl.bmp); picture_copy(sdl.bmp->pixels, sdl.bmp->pitches, frame); SDL_UnlockYUVOverlay(sdl.bmp); rect.x = 0; rect.y = 0; rect.w = sdl.size.w; rect.h = sdl.size.h; SDL_DisplayYUVOverlay(sdl.bmp, &rect); return 0; }
int main() { #ifdef __MIPSEL__ create_app_dir(BASE_PATH); #endif if (SDL_Init(SDL_INIT_VIDEO) < 0) { log(FATAL, "Cannot init SDL."); } if (!(screen = SDL_SetVideoMode(WIDTH, HEIGHT, DEPTH, SDL_HWSURFACE | SDL_DOUBLEBUF))) { SDL_Quit(); log(FATAL, "Cannot SetVideoMode."); } SDL_ShowCursor(SDL_DISABLE); if (TTF_Init() < 0) { SDL_Quit(); log(FATAL, "Unable to start the TTF."); } int img_flags = IMG_INIT_PNG; if(!(IMG_Init(img_flags) & img_flags)) { TTF_Quit(); SDL_Quit(); log(FATAL, "SDL_image could not initialize. %s.", IMG_GetError()); } pconfig = new Config(); pconfig->load(); pmixer = new Mixer(); current_volume = pmixer->get_speaker_volume(); pmixer->set_speaker_volume(current_volume); load_resources(); draw_buttons(); draw_timer(0, 0, 0); draw_volume(); draw_vu(1, -1); draw_vu(1, 1); pmic = new Mic(); pmic->set_on_terminate_event(on_terminate_exec); pmic->set_on_vu_change_event(on_vu_changed); main_loop(); delete pmic; delete pmixer; delete pconfig; TTF_CloseFont(font_10); TTF_CloseFont(font_28); IMG_Quit(); TTF_Quit(); SDL_Quit(); return 0; }
static void SetVideoMode(screen_mode_t *mode, int w, int h) { byte *doompal; int flags = 0; doompal = W_CacheLumpName(DEH_String("PLAYPAL"), PU_CACHE); // If we are already running and in a true color mode, we need // to free the screenbuffer surface before setting the new mode. if (screenbuffer != NULL && screen != screenbuffer) { SDL_FreeSurface(screenbuffer); } // Generate lookup tables before setting the video mode. if (mode != NULL && mode->InitMode != NULL) { mode->InitMode(doompal); } // Set the video mode. flags |= SDL_SWSURFACE | SDL_DOUBLEBUF; if (screen_bpp == 8) { flags |= SDL_HWPALETTE; } if (fullscreen) { flags |= SDL_FULLSCREEN; } else { // In windowed mode, the window can be resized while the game is // running. This feature is disabled on OS X, as it adds an ugly // scroll handle to the corner of the screen. #ifndef __MACOSX__ flags |= SDL_RESIZABLE; #endif } screen = SDL_SetVideoMode(w, h, screen_bpp, flags); if (screen == NULL) { I_Error("Error setting video mode %ix%ix%ibpp: %s\n", w, h, screen_bpp, SDL_GetError()); } // Blank out the full screen area in case there is any junk in // the borders that won't otherwise be overwritten. SDL_FillRect(screen, NULL, 0); // If mode was not set, it must be set now that we know the // screen size. if (mode == NULL) { mode = I_FindScreenMode(screen->w, screen->h); if (mode == NULL) { I_Error("I_InitGraphics: Unable to find a screen mode small " "enough for %ix%i", screen->w, screen->h); } // Generate lookup tables before setting the video mode. if (mode->InitMode != NULL) { mode->InitMode(doompal); } } // Create the screenbuffer surface; if we have a real 8-bit palettized // screen, then we can use the screen as the screenbuffer. if (screen->format->BitsPerPixel == 8) { screenbuffer = screen; } else { screenbuffer = SDL_CreateRGBSurface(SDL_SWSURFACE, mode->width, mode->height, 8, 0, 0, 0, 0); SDL_FillRect(screenbuffer, NULL, 0); } // Save screen mode. screen_mode = mode; }
/* ** GLimp_InitGraphics ** ** This initializes the software refresh's implementation specific ** graphics subsystem. In the case of Windows it creates DIB or ** DDRAW surfaces. ** ** The necessary width and height parameters are grabbed from ** vid.width and vid.height. */ static qboolean GLimp_InitGraphics( qboolean fullscreen ) { int flags; /* Just toggle fullscreen if that's all that has been changed */ if (surface && (surface->w == vid.width) && (surface->h == vid.height)) { int isfullscreen = (surface->flags & SDL_FULLSCREEN) ? 1 : 0; if (fullscreen != isfullscreen) SDL_WM_ToggleFullScreen(surface); isfullscreen = (surface->flags & SDL_FULLSCREEN) ? 1 : 0; if (fullscreen == isfullscreen) return true; } srandom(getpid()); // free resources in use if (surface) SDL_FreeSurface(surface); // let the sound and input subsystems know about the new window ri.Vid_NewWindow (vid.width, vid.height); SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); if (1) { SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24); SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8); } else { SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5); SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 5); SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5); SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16); } flags = SDL_OPENGL; if (fullscreen) flags |= SDL_FULLSCREEN; SetSDLIcon(); /* currently uses q2icon.xbm data */ if ((surface = SDL_SetVideoMode(vid.width, vid.height, 0, flags)) == NULL) { Sys_Error("(SDLGL) SDL SetVideoMode failed: %s\n", SDL_GetError()); return false; } // stencilbuffer shadows { int stencil_bits; have_stencil = false; if (!SDL_GL_GetAttribute(SDL_GL_STENCIL_SIZE, &stencil_bits)) { ri.Con_Printf(PRINT_ALL, "I got %d bits of stencil\n", stencil_bits); if (stencil_bits >= 1) { have_stencil = true; } } } SDL_WM_SetCaption(WINDOW_CLASS_NAME, WINDOW_CLASS_NAME); SDL_ShowCursor(0); X11_active = true; SetSDLGamma(); SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL); return true; }
static rt_err_t sdlfb_control(rt_device_t dev, rt_uint8_t cmd, void *args) { struct sdlfb_device *device; device = (struct sdlfb_device*)dev; RT_ASSERT(device != RT_NULL); RT_ASSERT(device->screen != RT_NULL); switch (cmd) { case RTGRAPHIC_CTRL_GET_INFO: { struct rt_device_graphic_info *info; info = (struct rt_device_graphic_info*) args; info->bits_per_pixel = 16; info->pixel_format = RTGRAPHIC_PIXEL_FORMAT_RGB565P; info->framebuffer = device->screen->pixels; info->width = device->screen->w; info->height = device->screen->h; } break; case RTGRAPHIC_CTRL_RECT_UPDATE: { struct rt_device_rect_info *rect; rect = (struct rt_device_rect_info*)args; /* SDL_UpdateRect(_device.screen, rect->x, rect->y, rect->x + rect->w, rect->y + rect->h); */ SDL_UpdateRect(_device.screen, 0, 0, device->width, device->height); } break; case RTGRAPHIC_CTRL_SET_MODE: { struct rt_device_rect_info* rect; rect = (struct rt_device_rect_info*)args; if ((_device.width == rect->width) && (_device.height == rect->height)) return -RT_ERROR; _device.width = rect->width; _device.height = rect->height; if (_device.screen != RT_NULL) { SDL_FreeSurface(_device.screen); /* re-create screen surface */ _device.screen = SDL_SetVideoMode(_device.width, _device.height, 16, SDL_SWSURFACE | SDL_DOUBLEBUF); if ( _device.screen == NULL ) { fprintf(stderr, "Couldn't set video mode: %s\n", SDL_GetError()); exit(1); } SDL_WM_SetCaption ("RT-Thread/GUI Simulator", NULL); } } break; } return RT_EOK; }
void sdl_free( void ) { if( config_get()->iface.full_screen ) SDL_SetVideoMode( saved_video.current_w, saved_video.current_h, saved_video.vfmt->BitsPerPixel, SDL_FULLSCREEN ); SDL_Quit(); }
int main(int argc, char *argv[]) { //inicializando SDL if(SDL_Init(SDL_INIT_VIDEO)<0) { printf("Error al establecer modo video\n");exit(1);} SDL_WM_SetCaption("Prueba_botones",NULL); screen=SDL_SetVideoMode(ancho,alto,24,SDL_SWSURFACE); if(screen==NULL) { printf("No se establecio el modo de video\n"); exit(1); } //font TTF_Init(); font_num=TTF_OpenFont("fonts/quid.ttf",60); if(font_num==NULL) printf("Error al cargar font\n"); font_menu=TTF_OpenFont("fonts/font_menu.ttf",80); if(font_menu==NULL) printf("Error al cargar font_menu\n"); font=TTF_OpenFont("fonts/FUAA.ttf",34); if(font==NULL) printf("Error en font\n"); font_op=TTF_OpenFont("fonts/FUAA.ttf",20); arbol_ttf=TTF_OpenFont("fonts/arbol.ttf",25); if(arbol_ttf==NULL) printf("Error al cargar arbol\n"); recorrido_ttf=TTF_OpenFont("fonts/arbol.ttf",17); fcolor.r=0; fcolor.g=0; fcolor.b=0; //principal A=NULL; int opcion=-1,n,dato; SDL_Rect pos; cargando_interface(); menu_principal(); draw_interface_principal(); SDL_Event evento; while(opcion!=0) { SDL_WaitEvent(&evento); if(evento.type==SDL_MOUSEMOTION) { if(posicion_cursor(20,85,12,35,evento.motion.x,evento.motion.y)) { pos.x=20; pos.y=12; SDL_BlitSurface(boton_insertar[1],NULL,screen,&pos); } else if(posicion_cursor(145,210,12,35,evento.motion.x,evento.motion.y)) { pos.x=145; pos.y=12; SDL_BlitSurface(boton_eliminar[1],NULL,screen,&pos); } else if(posicion_cursor(270,335,12,35,evento.motion.x,evento.motion.y)) { pos.x=270; pos.y=12; SDL_BlitSurface(boton_recorridos[1],NULL,screen,&pos); } else if(posicion_cursor(820,885,12,35,evento.motion.x,evento.motion.y)) { pos.x=820; pos.y=12; SDL_BlitSurface(boton_salir[1],NULL,screen,&pos); } else draw_menu_botones(); SDL_Flip(screen); } else if(evento.type==SDL_MOUSEBUTTONDOWN) { if(posicion_cursor(820,885,12,35,evento.button.x,evento.button.y)) { menu_principal(); } else if(posicion_cursor(20,85,12,35,evento.button.x,evento.button.y)) { dato=mini_ventana("Insertar dato: ",1); if(bandera!=0 && nivel_superado(A,0,dato)) ventana_alerta("La rama supero el maximo"); else { if(bandera!=0) insertar_arbol(&A,dato); calcular_posiciones(A,70,450,450,0); } print_arbol(A,0); SDL_Flip(screen); } else if(posicion_cursor(145,210,12,35,evento.button.x,evento.button.y)) { dato=mini_ventana("Eliminar dato: ",2); eliminar(&A,dato); draw_interface_principal(); calcular_posiciones(A,70,450,450,0); print_arbol(A,0); SDL_Flip(screen); } else if(posicion_cursor(270,335,12,35,evento.button.x,evento.button.y)) { ventana_recorridos(); } } else if(evento.type==SDL_KEYDOWN) { switch(evento.key.keysym.sym) { case SDLK_1: { dato=mini_ventana("Insertar dato: ",1); if(bandera!=0 && nivel_superado(A,0,dato)) ventana_alerta("La rama supero el maximo"); else { if(bandera!=0) insertar_arbol(&A,dato); calcular_posiciones(A,70,450,450,0); } print_arbol(A,0); SDL_Flip(screen); break; } case SDLK_2: { dato=mini_ventana("Eliminar dato: ",2); eliminar(&A,dato); draw_interface_principal(); calcular_posiciones(A,70,450,450,0); print_arbol(A,0); SDL_Flip(screen); break; } case SDLK_4: { menu_principal(); break; } case SDLK_3: { ventana_recorridos(); break; } } } } SDL_Quit(); return 0; }
//----------------------------------------------------------------------------- // Initialize //----------------------------------------------------------------------------- bool GraphicsPlugin::initialize(GFX_INFO* graphicsInfo) { //Initialize video output if (CoreVideo_Init() != M64ERR_SUCCESS) { Logger::getSingleton().printMsg("Could not initialize video.", M64MSG_ERROR); return false; } //Save pointer to graphics info m_graphicsInfo = graphicsInfo; m_numDListProcessed = 0; //Detect what rom it is m_romDetector = &ROMDetector::getSingleton(); m_romDetector->initialize( m_graphicsInfo->HEADER ); #ifdef HAVE_GLES SDL_SetVideoMode(m_config->fullscreenWidth, m_config->fullscreenHeight, m_config->fullscreenBitDepth, SDL_FULLSCREEN); SDL_ShowCursor(SDL_DISABLE); EGL_Open(m_config->fullscreenWidth, m_config->fullscreenHeight); #else if (m_config->multiSampling > 0) { CoreVideo_GL_SetAttribute(M64P_GL_MULTISAMPLEBUFFERS, 1); if (m_config->multiSampling <= 2) CoreVideo_GL_SetAttribute(M64P_GL_MULTISAMPLESAMPLES, 2); else if (m_config->multiSampling <= 4) CoreVideo_GL_SetAttribute(M64P_GL_MULTISAMPLESAMPLES, 4); else if (m_config->multiSampling <= 8) CoreVideo_GL_SetAttribute(M64P_GL_MULTISAMPLESAMPLES, 8); else CoreVideo_GL_SetAttribute(M64P_GL_MULTISAMPLESAMPLES, 16); } if (CoreVideo_GL_SetAttribute(M64P_GL_DOUBLEBUFFER, 1) != M64ERR_SUCCESS || CoreVideo_GL_SetAttribute(M64P_GL_BUFFER_SIZE, 32) != M64ERR_SUCCESS || CoreVideo_GL_SetAttribute(M64P_GL_DEPTH_SIZE, 24) != M64ERR_SUCCESS) { Logger::getSingleton().printMsg("Could not set video attributes.", M64MSG_ERROR); return false; } if (CoreVideo_SetVideoMode(m_config->fullscreenWidth, m_config->fullscreenHeight, m_config->fullscreenBitDepth, m_config->startFullscreen ? M64VIDEO_FULLSCREEN : M64VIDEO_WINDOWED, (m64p_video_flags) 0) != M64ERR_SUCCESS) { Logger::getSingleton().printMsg("Could not set video mode.", M64MSG_ERROR); return false; } CoreVideo_SetCaption("Arachnoid"); #endif //Initialize Video Interface m_vi = new VI(); m_vi->calcSize(m_graphicsInfo); //Initialize Memory m_memory = new Memory(); if ( !m_memory->initialize(m_graphicsInfo->RDRAM, m_graphicsInfo->DMEM) ) { return false; } m_displayListParser = new DisplayListParser(); m_displayListParser->initialize(&m_rsp, &m_rdp, &m_gbi, m_memory); //Init OpenGL if ( !m_openGLMgr.initialize(m_config->startFullscreen, m_config->fullscreenWidth, m_config->fullscreenHeight, m_config->fullscreenBitDepth, m_config->fullscreenRefreshRate, true, false) ) { Logger::getSingleton().printMsg("Unable to initialize OpenGL", M64MSG_ERROR); return false; } m_openGLMgr.calcViewScale(m_vi->getWidth(), m_vi->getHeight()); //Initialize Fog Manager m_fogManager = new FogManager(); m_fogManager->initialize(); //Initialize Texture Cache //! @todo Not "hardcode" TextureBitDepth. m_textureCache.initialize(&m_rsp, &m_rdp, m_memory, 16); m_textureCache.setMipmap( m_config->mipmapping ); //Initialize OpenGL Renderer if ( !OpenGLRenderer::getSingleton().initialize(&m_rsp, &m_rdp, &m_textureCache, m_vi, m_fogManager) ) { Logger::getSingleton().printMsg("Unable to initialize OpenGL Renderer", M64MSG_ERROR); return false; } //Initialize Processors m_rdp.initialize(m_graphicsInfo, &m_rsp, m_memory, &m_gbi, &m_textureCache, m_vi, m_displayListParser, m_fogManager); m_rsp.initialize(m_graphicsInfo, &m_rdp, m_memory, m_vi, m_displayListParser, m_fogManager); m_gbi.initialize(&m_rsp, &m_rdp, m_memory, m_displayListParser); //Set Background color m_openGLMgr.setClearColor(0.0f, 0.0f, 0.0f); m_openGLMgr.setLighting(false); glDisable(GL_LIGHTING); m_openGLMgr.setCullMode(false, true); m_openGLMgr.setWireFrame(m_config->wireframe); //Initialize framebuffer //framebuffer01.initialize(width, height); // framebuffer02.initialize(width, height); m_initialized = true; return true; }
int main(int argc, char *argv[]) { SDL_Surface *screen; SDL_Surface *icon; Uint8 *icon_mask; int i, parsed; Uint8 *buffer; SDL_Color palette[256]; Uint32 init_flags; Uint8 video_bpp; Uint32 video_flags; SDL_Thread *mouse_thread; SDL_Thread *keybd_thread; /* Set the options, based on command line arguments */ init_flags = SDL_INIT_VIDEO; video_bpp = 8; video_flags = SDL_SWSURFACE; parsed = 1; while ( parsed ) { /* If the threaded option is enabled, and the SDL library hasn't been compiled with threaded events enabled, then the mouse and keyboard won't respond. */ if ( (argc >= 2) && (strcmp(argv[1], "-threaded") == 0) ) { init_flags |= SDL_INIT_EVENTTHREAD; argc -= 1; argv += 1; printf("Running with threaded events\n"); } else if ( (argc >= 2) && (strcmp(argv[1], "-fullscreen") == 0) ) { video_flags |= SDL_FULLSCREEN; argc -= 1; argv += 1; } else if ( (argc >= 3) && (strcmp(argv[1], "-bpp") == 0) ) { video_bpp = atoi(argv[2]); argc -= 2; argv += 2; } else { parsed = 0; } } /* Initialize SDL with the requested flags */ if ( SDL_Init(init_flags) < 0 ) { fprintf(stderr, "Couldn't initialize SDL: %s\n", SDL_GetError()); return(1); } /* Set the icon -- this must be done before the first mode set */ icon = LoadIconSurface("app/native/icon.bmp", &icon_mask); if ( icon != NULL ) { SDL_WM_SetIcon(icon, icon_mask); } if ( icon_mask != NULL ) free(icon_mask); /* Initialize the display */ screen = SDL_SetVideoMode(640, 480, video_bpp, video_flags); if ( screen == NULL ) { fprintf(stderr, "Couldn't set 640x480x%d video mode: %s\n", video_bpp, SDL_GetError()); quit(1); } printf("Running in %s mode\n", screen->flags & SDL_FULLSCREEN ? "fullscreen" : "windowed"); /* Enable printable characters */ SDL_EnableUNICODE(1); /* Set an event filter that discards everything but QUIT */ SDL_SetEventFilter(FilterEvents); /* Create the event handling threads */ mouse_thread = SDL_CreateThread(HandleMouse, NULL); keybd_thread = SDL_CreateThread(HandleKeyboard, NULL); /* Set the surface pixels and refresh! */ for ( i=0; i<256; ++i ) { palette[i].r = 255-i; palette[i].g = 255-i; palette[i].b = 255-i; } SDL_SetColors(screen, palette, 0, 256); if ( SDL_LockSurface(screen) < 0 ) { fprintf(stderr, "Couldn't lock display surface: %s\n", SDL_GetError()); quit(2); } buffer = (Uint8 *)screen->pixels; for ( i=0; i<screen->h; ++i ) { memset(buffer,(i*255)/screen->h, screen->w*screen->format->BytesPerPixel); buffer += screen->pitch; } SDL_UnlockSurface(screen); SDL_UpdateRect(screen, 0, 0, 0, 0); /* Loop, waiting for QUIT */ while ( ! done ) { if ( ! (init_flags & SDL_INIT_EVENTTHREAD) ) { SDL_PumpEvents(); /* Needed when event thread is off */ } if ( SDL_PeepEvents(NULL, 0, SDL_PEEKEVENT, SDL_QUITMASK) ) { done = 1; } /* Give up some CPU so the events can accumulate */ SDL_Delay(20); } SDL_WaitThread(mouse_thread, NULL); SDL_WaitThread(keybd_thread, NULL); SDL_Quit(); return(0); }
/** Sets the height and width of the window. @param iWidth The width of the window @param iHeight The height of the window **/ void CEngine::SetSize(const int& iWidth, const int& iHeight) { m_iWidth = iWidth; m_iHeight = iHeight; m_pScreen = SDL_SetVideoMode( iWidth, iHeight, 0, SDL_SWSURFACE ); }
int main(int argc, char *argv[]) { AVFormatContext *pFormatCtx = NULL; int i, videoStream; AVCodecContext *pCodecCtx = NULL; AVCodecParameters *pCodecParam = NULL; AVCodec *pCodec = NULL; AVFrame *pFrame = NULL; AVPacket packet; int send_packet, receive_frame; //float aspect_ratio; AVFrame *pict; /* std::unique_ptr<AVFrame, std::function<void(AVFrame*)>> frame_converted{ av_frame_alloc(), [](AVFrame* f){ av_free(f->data[0]); } }; if (av_frame_copy_props(frame_converted.get(), frame_decoded.get()) < 0) { throw std::runtime_error("Copying frame properties"); } if (av_image_alloc( frame_converted->data, frame_converted->linesize, video_decoder_->width(), video_decoder_->height(), video_decoder_->pixel_format(), 1) < 0) { throw std::runtime_error("Allocating picture"); } */ AVDictionary *optionsDict = NULL; struct SwsContext *sws_ctx = NULL; SDL_Texture* pTexture = nullptr; SDL_Window* pWindows = nullptr; SDL_Renderer* pRenderer = nullptr; SDL_Event event; if (argc < 2) { fprintf(stderr, "Usage: test <file>\n"); exit(1); } // Register all formats and codecs av_register_all(); if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER)) { fprintf(stderr, "Could not initialize SDL - %s\n", SDL_GetError()); exit(1); } // Open video file if (avformat_open_input(&pFormatCtx, argv[1], NULL, NULL) != 0) return -1; // Couldn't open file // Retrieve stream information if (avformat_find_stream_info(pFormatCtx, NULL)<0) return -1; // Couldn't find stream information // Dump information about file onto standard error av_dump_format(pFormatCtx, 0, argv[1], 0); // Find the first video stream videoStream = -1; for (i = 0; i<pFormatCtx->nb_streams; i++) if (pFormatCtx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) { videoStream = i; break; } if (videoStream == -1) return -1; // Didn't find a video stream // Get a pointer to the codec context for the video stream //AVCodecContext *codec is deprecated,so use the codecpar struct (AVCodecParameters) instead. pCodecParam = pFormatCtx->streams[videoStream]->codecpar; //but function avcodec_open2() need pCodecCtx,so copy (AVCodecParameters) pCodecParam to (AVCodecContext) pCodecCtx pCodec = avcodec_find_decoder(pCodecParam->codec_id); // Find the decoder for the video stream if (pCodec == NULL) { fprintf(stderr, "Unsupported codec!\n"); return -1; // Codec not found } pCodecCtx = avcodec_alloc_context3(pCodec); avcodec_parameters_to_context(pCodecCtx, pCodecParam); // Open codec if (avcodec_open2(pCodecCtx, pCodec, &optionsDict)<0) return -1; // Could not open codec // Allocate video frame pFrame = av_frame_alloc(); // Make a screen to put our video #ifndef __DARWIN__ pWindows = SDL_CreateWindow(argv[1],SDL_WINDOWPOS_CENTERED,SDL_WINDOWPOS_CENTERED,pCodecParam->width, pCodecParam->height,SDL_WINDOW_BORDERLESS|SDL_WINDOW_RESIZABLE); #else screen = SDL_SetVideoMode(pCodecParam->width, pCodecParam->height, 24, 0); #endif if (!pWindows) { fprintf(stderr, "SDL: could not set video mode - exiting\n"); exit(1); } // Allocate a place to put our YUV image on that screen pRenderer = SDL_CreateRenderer(pWindows, -1, 0); if (!pRenderer) { fprintf(stderr, "SDL: could not create renderer - exiting\n"); exit(1); } pTexture = SDL_CreateTexture(pRenderer, SDL_PIXELFORMAT_YV12, SDL_TEXTUREACCESS_STREAMING, pCodecParam->width, pCodecParam->height); sws_ctx = sws_getContext ( pCodecParam->width, pCodecParam->height, (AVPixelFormat)pCodecParam->format, pCodecParam->width, pCodecParam->height, AV_PIX_FMT_YUV420P, SWS_BILINEAR, NULL, NULL, NULL ); pict = av_frame_alloc(); if (pict == nullptr){ exit(1); } if (av_image_alloc(pict->data, pict->linesize, pCodecParam->width, pCodecParam->height, (AVPixelFormat)pCodecParam->format, 1) < 0){ exit(1); } // Read frames and save first five frames to disk i = 0; while (av_read_frame(pFormatCtx, &packet) >= 0) { // Is this a packet from the video stream? if (packet.stream_index == videoStream) { // Decode video frame //avcodec_decode_video2 is deprecated Use avcodec_send_packet() and avcodec_receive_frame(). send_packet = avcodec_send_packet(pCodecCtx, &packet); receive_frame = avcodec_receive_frame(pCodecCtx, pFrame); // Did we get a video frame? if (send_packet == SEND_PACKET_SUCCESS && receive_frame == RECEIVE_FRAME_SUCCESS) { //SDL_LockYUVOverlay(bmp); //SDL_LockTexture(pTexture,NULL,); // Convert the image into YUV format that SDL uses if (av_frame_copy_props(pFrame, pict) < 0) { exit(1); } sws_scale ( sws_ctx, pFrame->data, pFrame->linesize, 0, pCodecParam->height, pict->data, pict->linesize ); //SDL_UnlockYUVOverlay(bmp); SDL_UpdateYUVTexture(pTexture, NULL, pict->data[0], pict->linesize[0], pict->data[1], pict->linesize[1], pict->data[2], pict->linesize[2]); SDL_RenderCopy(pRenderer, pTexture, NULL, NULL); SDL_RenderPresent(pRenderer); } } // Free the packet that was allocated by av_read_frame av_packet_unref(&packet); SDL_PollEvent(&event); switch (event.type) { case SDL_QUIT: SDL_DestroyRenderer(pRenderer); SDL_DestroyTexture(pTexture); SDL_DestroyWindow(pWindows); SDL_Quit(); exit(0); break; default: break; } } // Free the YUV frame av_frame_free(&pFrame); //free pict av_freep(&pict->data[0]); av_frame_free(&pict); // Close the codec avcodec_close(pCodecCtx); // Close the video file avformat_close_input(&pFormatCtx); return 0; }
int main(int argc, char *argv[]) { const SDL_VideoInfo *info; SDL_Surface *screen; int w, h; Uint8 video_bpp; Uint32 videoflags; int i, done; SDL_Event event; SDL_Surface *light; int mouse_pressed; Uint32 ticks, lastticks; /* Initialize SDL */ if (SDL_Init(SDL_INIT_VIDEO) < 0) { fprintf(stderr, "Couldn't initialize SDL: %s\n", SDL_GetError()); return (1); } /* Alpha blending doesn't work well at 8-bit color */ #ifdef _WIN32_WCE /* Pocket PC */ w = 240; h = 320; #else w = 640; h = 480; #endif info = SDL_GetVideoInfo(); if (info->vfmt->BitsPerPixel > 8) { video_bpp = info->vfmt->BitsPerPixel; } else { video_bpp = 16; fprintf(stderr, "forced 16 bpp mode\n"); } videoflags = SDL_SWSURFACE; for (i = 1; argv[i]; ++i) { if (strcmp(argv[i], "-bpp") == 0) { video_bpp = atoi(argv[++i]); if (video_bpp <= 8) { video_bpp = 16; fprintf(stderr, "forced 16 bpp mode\n"); } } else if (strcmp(argv[i], "-hw") == 0) { videoflags |= SDL_HWSURFACE; } else if (strcmp(argv[i], "-warp") == 0) { videoflags |= SDL_HWPALETTE; } else if (strcmp(argv[i], "-width") == 0 && argv[i + 1]) { w = atoi(argv[++i]); } else if (strcmp(argv[i], "-height") == 0 && argv[i + 1]) { h = atoi(argv[++i]); } else if (strcmp(argv[i], "-resize") == 0) { videoflags |= SDL_RESIZABLE; } else if (strcmp(argv[i], "-noframe") == 0) { videoflags |= SDL_NOFRAME; } else if (strcmp(argv[i], "-fullscreen") == 0) { videoflags |= SDL_FULLSCREEN; } else { fprintf(stderr, "Usage: %s [-width N] [-height N] [-bpp N] [-warp] [-hw] [-fullscreen]\n", argv[0]); quit(1); } } /* Set video mode */ if ((screen = SDL_SetVideoMode(w, h, video_bpp, videoflags)) == NULL) { fprintf(stderr, "Couldn't set %dx%dx%d video mode: %s\n", w, h, video_bpp, SDL_GetError()); quit(2); } FillBackground(screen); /* Create the light */ light = CreateLight(82); if (light == NULL) { quit(1); } /* Load the sprite */ if (LoadSprite(screen, "icon.bmp") < 0) { SDL_FreeSurface(light); quit(1); } /* Print out information about our surfaces */ printf("Screen is at %d bits per pixel\n", screen->format->BitsPerPixel); if ((screen->flags & SDL_HWSURFACE) == SDL_HWSURFACE) { printf("Screen is in video memory\n"); } else { printf("Screen is in system memory\n"); } if ((screen->flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF) { printf("Screen has double-buffering enabled\n"); } if ((sprite->flags & SDL_HWSURFACE) == SDL_HWSURFACE) { printf("Sprite is in video memory\n"); } else { printf("Sprite is in system memory\n"); } /* Run a sample blit to trigger blit acceleration */ MoveSprite(screen, NULL); if ((sprite->flags & SDL_HWACCEL) == SDL_HWACCEL) { printf("Sprite blit uses hardware alpha acceleration\n"); } else { printf("Sprite blit dosn't uses hardware alpha acceleration\n"); } /* Set a clipping rectangle to clip the outside edge of the screen */ { SDL_Rect clip; clip.x = 32; clip.y = 32; clip.w = screen->w - (2 * 32); clip.h = screen->h - (2 * 32); SDL_SetClipRect(screen, &clip); } /* Wait for a keystroke */ lastticks = SDL_GetTicks(); done = 0; mouse_pressed = 0; while (!done) { /* Update the frame -- move the sprite */ if (mouse_pressed) { MoveSprite(screen, light); mouse_pressed = 0; } else { MoveSprite(screen, NULL); } /* Slow down the loop to 30 frames/second */ ticks = SDL_GetTicks(); if ((ticks - lastticks) < FRAME_TICKS) { #ifdef CHECK_SLEEP_GRANULARITY fprintf(stderr, "Sleeping %d ticks\n", FRAME_TICKS - (ticks - lastticks)); #endif SDL_Delay(FRAME_TICKS - (ticks - lastticks)); #ifdef CHECK_SLEEP_GRANULARITY fprintf(stderr, "Slept %d ticks\n", (SDL_GetTicks() - ticks)); #endif } lastticks = ticks; /* Check for events */ while (SDL_PollEvent(&event)) { switch (event.type) { case SDL_VIDEORESIZE: screen = SDL_SetVideoMode(event.resize.w, event.resize.h, video_bpp, videoflags); if (screen) { FillBackground(screen); } break; /* Attract sprite while mouse is held down */ case SDL_MOUSEMOTION: if (event.motion.state != 0) { AttractSprite(event.motion.x, event.motion.y); mouse_pressed = 1; } break; case SDL_MOUSEBUTTONDOWN: if (event.button.button == 1) { AttractSprite(event.button.x, event.button.y); mouse_pressed = 1; } else { SDL_Rect area; area.x = event.button.x - 16; area.y = event.button.y - 16; area.w = 32; area.h = 32; SDL_FillRect(screen, &area, SDL_MapRGB(screen->format, 0, 0, 0)); SDL_UpdateRects(screen, 1, &area); } break; case SDL_KEYDOWN: if (event.key.keysym.sym == SDLK_ESCAPE) { done = 1; } if (event.key.keysym.sym == SDLK_RETURN) { SDL_WM_ToggleFullScreen(screen); } break; case SDL_QUIT: done = 1; break; default: break; } } } SDL_FreeSurface(light); SDL_FreeSurface(sprite); SDL_FreeSurface(backing); /* Print out some timing information */ if (flashes > 0) { printf("%d alpha blits, ~%4.4f ms per blit\n", flashes, (float) flashtime / flashes); } SDL_Quit(); return (0); }
// Entry point int main(int argc, char *argv[]) { // Initialize SDL's subsystems - in this case, only video. if ( SDL_Init(SDL_INIT_VIDEO) < 0 ) { fprintf(stderr, "Unable to init SDL: %s\n", SDL_GetError()); exit(1); } // printf(" size %d ", sizeof(coordlist)/sizeof(Coord)); // Register SDL_Quit to be called at exit; makes sure things are // cleaned up when we quit. atexit(SDL_Quit); // Attempt to create a 640x480 window with 32bit pixels. screen = SDL_SetVideoMode(800, 600, 32, SDL_SWSURFACE); // If we fail, return error. if ( screen == NULL ) { fprintf(stderr, "Unable to set 640x480 video: %s\n", SDL_GetError()); exit(1); } List *list = new List(); Coord* crd1 = new Coord(12,123); Coord* crd2 = new Coord(300,100); list->append(*crd1); list->append(*crd2); list->add_after_last_point(-10,20); // list->get(0).x=10; this is bad I guess... -fpermissive? printf("0--> %d %d\n",list->get(0).x,list->get(0).y); printf("1--> %d %d\n",list->get(1).x,list->get(1).y); printf("2--> %d %d\n",list->get(2).x,list->get(2).y); // Main loop: loop forever. while (1) { // Render stuff render(); // Poll for events, and handle the ones we care about. SDL_Event event; while (SDL_PollEvent(&event)) { switch (event.type) { case SDL_KEYDOWN: break; case SDL_KEYUP: // If escape is pressed, return (and thus, quit) if (event.key.keysym.sym == SDLK_ESCAPE) return 0; break; case SDL_QUIT: return(0); } } } return 0; }
//@param flags Video flags for SDL video subsystem //@return 0 on success. static int setupVideo(int *flags, SDL_Surface *surface) { int videoFlags = 0; /* initialize SDL */ if ( SDL_Init( SDL_INIT_VIDEO ) < 0 ) { fprintf( stderr, "Video initialization failed: %s\n", SDL_GetError( ) ); return 1; } /* this holds some info about our display */ const SDL_VideoInfo *videoInfo; /* Fetch the video info */ videoInfo = SDL_GetVideoInfo( ); if ( !videoInfo ) { fprintf( stderr, "Video query failed: %s\n", SDL_GetError( ) ); return 1; } /* the flags to pass to SDL_SetVideoMode */ videoFlags = SDL_OPENGL; /* Enable OpenGL in SDL */ videoFlags |= SDL_GL_DOUBLEBUFFER; /* Enable double buffering */ videoFlags |= SDL_HWPALETTE; /* Store the palette in hardware */ videoFlags |= SDL_RESIZABLE; /* Enable window resizing */ //videoFlags |= SDL_FULLSCREEN; /* This checks to see if surfaces can be stored in memory */ if ( videoInfo->hw_available ) videoFlags |= SDL_HWSURFACE; else videoFlags |= SDL_SWSURFACE; /* This checks if hardware blits can be done */ if ( videoInfo->blit_hw ) videoFlags |= SDL_HWACCEL; /* Sets up OpenGL double buffering */ SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 ); SDL_GL_SetAttribute(SDL_GL_SWAP_CONTROL, TRUE); *flags = videoFlags; /* get a SDL surface */ surface = SDL_SetVideoMode( SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_BPP, videoFlags ); /* Verify there is a surface */ if ( !surface ) { fprintf( stderr, "Video mode set failed: %s\n", SDL_GetError( ) ); return 1; } /* initialize OpenGL */ initGL( ); /* resize the initial window */ resizeWindow( SCREEN_WIDTH, SCREEN_HEIGHT ); SDL_WM_GrabInput( SDL_GRAB_ON ); SDL_ShowCursor(0); return 0; }
int main(int argc, char **argv) { char inp[60]; int i, j, seed; seed = time((time_t *)0); srand(seed); /* Initialize SDL */ if (SDL_Init(SDL_INIT_VIDEO) < 0) exit(1); atexit(SDL_Quit); pdc_screen = SDL_SetVideoMode(640, 480, 0, SDL_SWSURFACE|SDL_ANYFORMAT); /* Initialize PDCurses */ pdc_yoffset = 416; /* 480 - 4 * 16 */ initscr(); start_color(); scrollok(stdscr, TRUE); PDC_set_title("PDCurses for SDL"); /* Do some SDL stuff */ for (i = 640, j = 416; j; i -= 2, j -= 2) { SDL_Rect dest; dest.x = (640 - i) / 2; dest.y = (416 - j) / 2; dest.w = i; dest.h = j; SDL_FillRect(pdc_screen, &dest, SDL_MapRGB(pdc_screen->format, rand() % 256, rand() % 256, rand() % 256)); } SDL_UpdateRect(pdc_screen, 0, 0, 640, 416); /* Do some curses stuff */ init_pair(1, COLOR_WHITE + 8, COLOR_BLUE); bkgd(COLOR_PAIR(1)); addstr("This is a demo of "); attron(A_UNDERLINE); addstr("PDCurses for SDL"); attroff(A_UNDERLINE); addstr(".\nYour comments here: "); getnstr(inp, 59); addstr("Press any key to exit."); getch(); endwin(); return 0; }
int plat_sdl_init(void) { static const char *vout_list[] = { NULL, NULL, NULL, NULL }; const SDL_VideoInfo *info; SDL_SysWMinfo wminfo; int overlay_works = 0; int gl_works = 0; int i, ret, h; ret = SDL_Init(SDL_INIT_VIDEO | SDL_INIT_NOPARACHUTE); if (ret != 0) { fprintf(stderr, "SDL_Init failed: %s\n", SDL_GetError()); return -1; } info = SDL_GetVideoInfo(); if (info != NULL) { fs_w = info->current_w; fs_h = info->current_h; printf("plat_sdl: using %dx%d as fullscreen resolution\n", fs_w, fs_h); } g_menuscreen_w = 640; if (fs_w != 0 && g_menuscreen_w > fs_w) g_menuscreen_w = fs_w; g_menuscreen_h = 480; if (fs_h != 0) { h = fs_h; if (info && info->wm_available && h > WM_DECORATION_H) h -= WM_DECORATION_H; if (g_menuscreen_h > h) g_menuscreen_h = h; } ret = plat_sdl_change_video_mode(g_menuscreen_w, g_menuscreen_h, 1); if (ret != 0) { plat_sdl_screen = SDL_SetVideoMode(0, 0, 16, SDL_SWSURFACE); if (plat_sdl_screen == NULL) { fprintf(stderr, "SDL_SetVideoMode failed: %s\n", SDL_GetError()); goto fail; } if (plat_sdl_screen->w < 320 || plat_sdl_screen->h < 240) { fprintf(stderr, "resolution %dx%d is too small, sorry.\n", plat_sdl_screen->w, plat_sdl_screen->h); goto fail; } } g_menuscreen_w = window_w = plat_sdl_screen->w; g_menuscreen_h = window_h = plat_sdl_screen->h; plat_sdl_overlay = SDL_CreateYUVOverlay(plat_sdl_screen->w, plat_sdl_screen->h, SDL_UYVY_OVERLAY, plat_sdl_screen); if (plat_sdl_overlay != NULL) { printf("plat_sdl: overlay: fmt %x, planes: %d, pitch: %d, hw: %d\n", plat_sdl_overlay->format, plat_sdl_overlay->planes, *plat_sdl_overlay->pitches, plat_sdl_overlay->hw_overlay); if (plat_sdl_overlay->hw_overlay) overlay_works = 1; else fprintf(stderr, "warning: video overlay is not hardware accelerated, " "not going to use it.\n"); SDL_FreeYUVOverlay(plat_sdl_overlay); plat_sdl_overlay = NULL; } else fprintf(stderr, "overlay is not available.\n"); // get x11 display/window for GL SDL_VideoDriverName(vid_drv_name, sizeof(vid_drv_name)); #ifdef SDL_VIDEO_DRIVER_X11 if (strcmp(vid_drv_name, "x11") == 0) { SDL_VERSION(&wminfo.version); ret = SDL_GetWMInfo(&wminfo); if (ret > 0) { display = wminfo.info.x11.display; window = (void *)wminfo.info.x11.window; } } #endif ret = gl_init(display, window, &gl_quirks); if (ret == 0) { gl_works = 1; gl_finish(); } i = 0; vout_list[i++] = "SDL Window"; if (overlay_works) { plat_target.vout_method = vout_mode_overlay = i; vout_list[i++] = "Video Overlay"; } if (gl_works) { plat_target.vout_method = vout_mode_gl = i; vout_list[i++] = "OpenGL"; } plat_target.vout_methods = vout_list; return 0; fail: SDL_Quit(); return -1; }
int main(int argc, char *argv[]) { AVFormatContext *pFormatCtx = NULL; int i, videoStream; AVCodecContext *pCodecCtx; AVCodec *pCodec; AVFrame *pFrame; AVPacket packet; int frameFinished; float aspect_ratio; struct SwsContext *img_convert_ctx; SDL_Overlay *bmp; SDL_Surface *screen; SDL_Rect rect; SDL_Event event; if(argc < 2) { fprintf(stderr, "Usage: test <file>\n"); exit(1); } // Register all formats and codecs av_register_all(); if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER)) { fprintf(stderr, "Could not initialize SDL - %s\n", SDL_GetError()); exit(1); } // Open video file if(avformat_open_input(&pFormatCtx, argv[1], NULL, NULL)!=0) return -1; // Couldn't open file // Retrieve stream information if(avformat_find_stream_info(pFormatCtx, NULL)<0) return -1; // Couldn't find stream information // Find the first video stream videoStream=-1; for(i=0; i<pFormatCtx->nb_streams; i++) if(pFormatCtx->streams[i]->codec->codec_type==AVMEDIA_TYPE_VIDEO) { videoStream=i; break; } if(videoStream==-1) return -1; // Didn't find a video stream // Get a pointer to the codec context for the video stream pCodecCtx=pFormatCtx->streams[videoStream]->codec; // Find the decoder for the video stream pCodec=avcodec_find_decoder(pCodecCtx->codec_id); if(pCodec==NULL) { fprintf(stderr, "Unsupported codec!\n"); return -1; // Codec not found } // Open codec if(avcodec_open2(pCodecCtx, pCodec, NULL)<0) return -1; // Could not open codec // Allocate video frame pFrame=av_frame_alloc(); // Make a screen to put our video screen = SDL_SetVideoMode(pCodecCtx->width, pCodecCtx->height, 0, 0); if(!screen) { fprintf(stderr, "SDL: could not set video mode - exiting\n"); exit(1); } // Allocate a place to put our YUV image on that screen bmp = SDL_CreateYUVOverlay(pCodecCtx->width, pCodecCtx->height, SDL_YV12_OVERLAY, screen); // Read frames and save first five frames to disk i=0; while(av_read_frame(pFormatCtx, &packet)>=0) { // Is this a packet from the video stream? if(packet.stream_index==videoStream) { // Decode video frame avcodec_decode_video2(pCodecCtx, pFrame, &frameFinished, &packet); // Did we get a video frame? if(frameFinished) { SDL_LockYUVOverlay(bmp); AVPicture pict; pict.data[0] = bmp->pixels[0]; pict.data[1] = bmp->pixels[2]; pict.data[2] = bmp->pixels[1]; pict.linesize[0] = bmp->pitches[0]; pict.linesize[1] = bmp->pitches[2]; pict.linesize[2] = bmp->pitches[1]; // Convert the image into YUV format that SDL uses img_convert_ctx = sws_getContext(pCodecCtx->width, pCodecCtx->height, pCodecCtx->pix_fmt, pCodecCtx->width, pCodecCtx->height, PIX_FMT_YUV420P, SWS_BICUBIC,NULL, NULL,NULL); sws_scale(img_convert_ctx, pFrame->data, pFrame->linesize, 0, pFrame->height, pict.data, pict.linesize); SDL_UnlockYUVOverlay(bmp); rect.x = 0; rect.y = 0; rect.w = pCodecCtx->width; rect.h = pCodecCtx->height; SDL_DisplayYUVOverlay(bmp, &rect); } } // Free the packet that was allocated by av_read_frame av_free_packet(&packet); SDL_PollEvent(&event); switch(event.type) { case SDL_QUIT: SDL_Quit(); exit(0); break; default: break; } } // Free the YUV frame av_free(pFrame); // Close the codec avcodec_close(pCodecCtx); // Close the video file avformat_close_input(&pFormatCtx); return 0; }
int SDL_main (int argc,char* argv[]) { #elif __APPLE__ int SDL_main (int argc,char* argv[]) { #else #ifdef main #undef main #endif int main(int argc,char* argv[]) { #endif printf("[INFO] Entering main\n"); uint32_t flags=SDL_INIT_VIDEO; #ifndef WIN32 flags|=SDL_INIT_EVENTTHREAD; #endif #ifdef __MACH__ flags = SDL_INIT_EVERYTHING; #endif if (SDL_Init(flags)==-1) { printf("SDL_Init: %s\n", SDL_GetError ()); return -1; } screen=SDL_SetVideoMode(SCREEN_WIDTH,SCREEN_HEIGHT, 32, SDL_SWSURFACE); if(screen == NULL) { printf("SDL_SetVideoMode failed!\n"); return -2; } SDL_WM_SetCaption ("Pebble Local Simulator - 24H Style",0); pebbleScreen = createScreen; if(TTF_Init()==-1) { printf("TTF_Init: %s\n", TTF_GetError()); return -3; } if (IMG_Init (IMG_INIT_PNG)==-1) { printf("IMG_Init: %s\n", IMG_GetError()); return -4; } if (!loadSimulatorImages()) return -5; bodyImg=getSimulatorImage(SIM_IMG_BODY); shadowImg=getSimulatorImage(SIM_IMG_SCREEN_SHADOW); vibeImg=getSimulatorImage(SIM_IMG_VIBE); lightImg=getSimulatorImage(SIM_IMG_BACKLIGHT); logFile=fopen (LOG_FILE,"a"); if (!initRender(pebbleScreen)) return -9; initHardwareOutput (); initButtons(); pbl_main(); unloadSystemFonts (); quitRender(); if (logFile!=0) fclose(logFile); freeSimulatorImages(); IMG_Quit (); TTF_Quit (); SDL_Quit (); return 0; }
int main(int /*argc*/, char** /*argv*/) { // Init SDL if (SDL_Init(SDL_INIT_EVERYTHING) != 0) { printf("Could not initialise SDL\n"); return -1; } // Center window char env[] = "SDL_VIDEO_CENTERED=1"; putenv(env); // Init OpenGL SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24); SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8); //#ifndef WIN32 SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1); SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 4); //#endif const SDL_VideoInfo* vi = SDL_GetVideoInfo(); bool presentationMode = false; int width, height; SDL_Surface* screen = 0; if (presentationMode) { width = vi->current_w; height = vi->current_h; screen = SDL_SetVideoMode(width, height, 0, SDL_OPENGL|SDL_FULLSCREEN); } else { width = rcMin(vi->current_w, (int)(vi->current_h * 16.0 / 9.0)); width = width - 80; height = vi->current_h - 80; screen = SDL_SetVideoMode(width, height, 0, SDL_OPENGL); } if (!screen) { printf("Could not initialise SDL opengl\n"); return -1; } glEnable(GL_MULTISAMPLE); SDL_WM_SetCaption("Recast Demo", 0); if (!imguiRenderGLInit("DroidSans.ttf")) { printf("Could not init GUI renderer.\n"); SDL_Quit(); return -1; } float t = 0.0f; float timeAcc = 0.0f; Uint32 lastTime = SDL_GetTicks(); int mx = 0, my = 0; float rx = 45; float ry = -45; float moveW = 0, moveS = 0, moveA = 0, moveD = 0; float camx = 0, camy = 0, camz = 0, camr = 1000; float origrx = 0, origry = 0; int origx = 0, origy = 0; float scrollZoom = 0; bool rotate = false; bool movedDuringRotate = false; float rays[3], raye[3]; bool mouseOverMenu = false; bool showMenu = !presentationMode; bool showLog = false; bool showTools = true; bool showLevels = false; bool showSample = false; bool showTestCases = false; int propScroll = 0; int logScroll = 0; int toolsScroll = 0; char sampleName[64] = "Choose Sample..."; FileList files; char meshName[128] = "Choose Mesh..."; float mpos[3] = {0,0,0}; bool mposSet = false; SlideShow slideShow; slideShow.init("slides/"); InputGeom* geom = 0; Sample* sample = 0; TestCase* test = 0; bool trinityCoreSettings = false; BuildContext ctx; glEnable(GL_CULL_FACE); float fogCol[4] = { 0.32f, 0.31f, 0.30f, 1.0f }; glEnable(GL_FOG); glFogi(GL_FOG_MODE, GL_LINEAR); glFogf(GL_FOG_START, camr*0.1f); glFogf(GL_FOG_END, camr*1.25f); glFogfv(GL_FOG_COLOR, fogCol); glDepthFunc(GL_LEQUAL); bool done = false; while(!done) { // Handle input events. int mscroll = 0; bool processHitTest = false; bool processHitTestShift = false; SDL_Event event; if (sample) trinityCoreSettings = sample->getTrinityCoreValues(); while (SDL_PollEvent(&event)) { switch (event.type) { case SDL_KEYDOWN: // Handle any key presses here. if (event.key.keysym.sym == SDLK_ESCAPE) { done = true; } else if (event.key.keysym.sym == SDLK_t) { showLevels = false; showSample = false; showTestCases = true; scanDirectory("Tests", ".txt", files); } else if (event.key.keysym.sym == SDLK_TAB) { showMenu = !showMenu; } else if (event.key.keysym.sym == SDLK_SPACE) { if (sample) sample->handleToggle(); } else if (event.key.keysym.sym == SDLK_1) { if (sample) sample->handleStep(); } else if (event.key.keysym.sym == SDLK_9) { if (geom) geom->save("geomset.txt"); } else if (event.key.keysym.sym == SDLK_0) { delete geom; geom = new InputGeom; if (!geom || !geom->load(&ctx, "geomset.txt", trinityCoreSettings)) { delete geom; geom = 0; showLog = true; logScroll = 0; ctx.dumpLog("Geom load log %s:", meshName); } if (sample && geom) { sample->handleMeshChanged(geom); } if (geom || sample) { const float* bmin = 0; const float* bmax = 0; if (sample) { bmin = sample->getBoundsMin(); bmax = sample->getBoundsMax(); } else if (geom) { bmin = geom->getMeshBoundsMin(); bmax = geom->getMeshBoundsMax(); } // Reset camera and fog to match the mesh bounds. if (bmin && bmax) { camr = sqrtf(rcSqr(bmax[0]-bmin[0]) + rcSqr(bmax[1]-bmin[1]) + rcSqr(bmax[2]-bmin[2])) / 2; camx = (bmax[0] + bmin[0]) / 2 + camr; camy = (bmax[1] + bmin[1]) / 2 + camr; camz = (bmax[2] + bmin[2]) / 2 + camr; camr *= 3; } rx = 45; ry = -45; glFogf(GL_FOG_START, camr*0.2f); glFogf(GL_FOG_END, camr*1.25f); } } else if (event.key.keysym.sym == SDLK_RIGHT) { slideShow.nextSlide(); } else if (event.key.keysym.sym == SDLK_LEFT) { slideShow.prevSlide(); } break; case SDL_MOUSEBUTTONDOWN: if (event.button.button == SDL_BUTTON_RIGHT) { if (!mouseOverMenu) { // Rotate view rotate = true; movedDuringRotate = false; origx = mx; origy = my; origrx = rx; origry = ry; } } else if (event.button.button == SDL_BUTTON_WHEELUP) { if (mouseOverMenu) mscroll--; else scrollZoom -= 10.0f; } else if (event.button.button == SDL_BUTTON_WHEELDOWN) { if (mouseOverMenu) mscroll++; else scrollZoom += 10.0f; } break; case SDL_MOUSEBUTTONUP: // Handle mouse clicks here. if (event.button.button == SDL_BUTTON_RIGHT) { rotate = false; if (!mouseOverMenu) { if (!movedDuringRotate) { processHitTest = true; processHitTestShift = true; } } } else if (event.button.button == SDL_BUTTON_LEFT) { if (!mouseOverMenu) { processHitTest = true; processHitTestShift = (SDL_GetModState() & KMOD_SHIFT) ? true : false; } } break; case SDL_MOUSEMOTION: mx = event.motion.x; my = height-1 - event.motion.y; if (rotate) { int dx = mx - origx; int dy = my - origy; rx = origrx - dy*0.25f; ry = origry + dx*0.25f; if (dx*dx+dy*dy > 3*3) movedDuringRotate = true; } break; case SDL_QUIT: done = true; break; default: break; } } unsigned char mbut = 0; if (SDL_GetMouseState(0,0) & SDL_BUTTON_LMASK) mbut |= IMGUI_MBUT_LEFT; if (SDL_GetMouseState(0,0) & SDL_BUTTON_RMASK) mbut |= IMGUI_MBUT_RIGHT; Uint32 time = SDL_GetTicks(); float dt = (time - lastTime) / 1000.0f; lastTime = time; t += dt; // Hit test mesh. if (processHitTest && geom && sample) { float hitt; bool hit = geom->raycastMesh(rays, raye, hitt); if (hit) { if (SDL_GetModState() & KMOD_CTRL) { // Marker mposSet = true; mpos[0] = rays[0] + (raye[0] - rays[0])*hitt; mpos[1] = rays[1] + (raye[1] - rays[1])*hitt; mpos[2] = rays[2] + (raye[2] - rays[2])*hitt; } else { float pos[3]; pos[0] = rays[0] + (raye[0] - rays[0])*hitt; pos[1] = rays[1] + (raye[1] - rays[1])*hitt; pos[2] = rays[2] + (raye[2] - rays[2])*hitt; sample->handleClick(rays, pos, processHitTestShift); } } else { if (SDL_GetModState() & KMOD_CTRL) { // Marker mposSet = false; } } } // Update sample simulation. const float SIM_RATE = 20; const float DELTA_TIME = 1.0f/SIM_RATE; timeAcc = rcClamp(timeAcc+dt, -1.0f, 1.0f); int simIter = 0; while (timeAcc > DELTA_TIME) { timeAcc -= DELTA_TIME; if (simIter < 5) { if (sample) sample->handleUpdate(DELTA_TIME); } simIter++; } // Clamp the framerate so that we do not hog all the CPU. const float MIN_FRAME_TIME = 1.0f/40.0f; if (dt < MIN_FRAME_TIME) { int ms = (int)((MIN_FRAME_TIME - dt)*1000.0f); if (ms > 10) ms = 10; if (ms >= 0) SDL_Delay(ms); } // Update and render glViewport(0, 0, width, height); glClearColor(0.3f, 0.3f, 0.32f, 1.0f); glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glDisable(GL_TEXTURE_2D); // Render 3d glEnable(GL_DEPTH_TEST); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective(50.0f, (float)width/(float)height, 1.0f, camr); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glRotatef(rx,1,0,0); glRotatef(ry,0,1,0); glTranslatef(-camx, -camy, -camz); // Get hit ray position and direction. GLdouble proj[16]; GLdouble model[16]; GLint view[4]; glGetDoublev(GL_PROJECTION_MATRIX, proj); glGetDoublev(GL_MODELVIEW_MATRIX, model); glGetIntegerv(GL_VIEWPORT, view); GLdouble x, y, z; gluUnProject(mx, my, 0.0f, model, proj, view, &x, &y, &z); rays[0] = (float)x; rays[1] = (float)y; rays[2] = (float)z; gluUnProject(mx, my, 1.0f, model, proj, view, &x, &y, &z); raye[0] = (float)x; raye[1] = (float)y; raye[2] = (float)z; // Handle keyboard movement. Uint8* keystate = SDL_GetKeyState(NULL); moveW = rcClamp(moveW + dt * 4 * (keystate[SDLK_w] ? 1 : -1), 0.0f, 1.0f); moveS = rcClamp(moveS + dt * 4 * (keystate[SDLK_s] ? 1 : -1), 0.0f, 1.0f); moveA = rcClamp(moveA + dt * 4 * (keystate[SDLK_a] ? 1 : -1), 0.0f, 1.0f); moveD = rcClamp(moveD + dt * 4 * (keystate[SDLK_d] ? 1 : -1), 0.0f, 1.0f); float keybSpeed = 22.0f; if (SDL_GetModState() & KMOD_SHIFT) keybSpeed *= 20.0f; float movex = (moveD - moveA) * keybSpeed * dt; float movey = (moveS - moveW) * keybSpeed * dt; movey += scrollZoom * 2.0f; scrollZoom = 0; camx += movex * (float)model[0]; camy += movex * (float)model[4]; camz += movex * (float)model[8]; camx += movey * (float)model[2]; camy += movey * (float)model[6]; camz += movey * (float)model[10]; glEnable(GL_FOG); if (sample) sample->handleRender(); if (test) test->handleRender(); glDisable(GL_FOG); // Render GUI glDisable(GL_DEPTH_TEST); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluOrtho2D(0, width, 0, height); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); mouseOverMenu = false; imguiBeginFrame(mx,my,mbut,mscroll); if (sample) { sample->handleRenderOverlay((double*)proj, (double*)model, (int*)view); } if (test) { if (test->handleRenderOverlay((double*)proj, (double*)model, (int*)view)) mouseOverMenu = true; } // Help text. if (showMenu) { const char msg[] = "W/S/A/D: Move RMB: Rotate"; imguiDrawText(280, height-20, IMGUI_ALIGN_LEFT, msg, imguiRGBA(255,255,255,128)); } if (showMenu) { if (imguiBeginScrollArea("Properties", width-250-10, 10, 250, height-20, &propScroll)) mouseOverMenu = true; if (imguiCheck("Show Log", showLog)) showLog = !showLog; if (imguiCheck("Show Tools", showTools)) showTools = !showTools; imguiSeparator(); imguiLabel("Sample"); if (imguiButton(sampleName)) { if (showSample) { showSample = false; } else { showSample = true; showLevels = false; showTestCases = false; } } imguiSeparator(); imguiLabel("Input Mesh"); if (imguiButton(meshName)) { if (showLevels) { showLevels = false; } else { showSample = false; showTestCases = false; showLevels = true; scanDirectory("Meshes", ".obj", files); } } if (geom) { char text[64]; snprintf(text, 64, "Verts: %.1fk Tris: %.1fk", geom->getMesh()->getVertCount()/1000.0f, geom->getMesh()->getTriCount()/1000.0f); imguiValue(text); } imguiSeparator(); if (geom && sample) { imguiSeparatorLine(); sample->handleSettings(); if (imguiButton("Build")) { ctx.resetLog(); if (!sample->handleBuild()) { showLog = true; logScroll = 0; } ctx.dumpLog("Build log %s:", meshName); // Clear test. delete test; test = 0; } if (imguiButton("Load mmtile")) { ctx.resetLog(); if (!sample->handleLoad()) { showLog = true; logScroll = 0; } ctx.dumpLog("Load log %s:", meshName); // Clear test. delete test; test = 0; } if (imguiButton("Load sub mmtile")) { ctx.resetLog(); if (!sample->handleLoadSubTiles()) { showLog = true; logScroll = 0; } ctx.dumpLog("Load log %s:", meshName); // Clear test. delete test; test = 0; } imguiSeparator(); } if (sample) { imguiSeparatorLine(); sample->handleDebugMode(); } imguiEndScrollArea(); } // Sample selection dialog. if (showSample) { static int levelScroll = 0; if (imguiBeginScrollArea("Choose Sample", width-10-250-10-200, height-10-250, 200, 250, &levelScroll)) mouseOverMenu = true; Sample* newSample = 0; for (int i = 0; i < g_nsamples; ++i) { if (imguiItem(g_samples[i].name)) { newSample = g_samples[i].create(); if (newSample) strcpy(sampleName, g_samples[i].name); } } if (newSample) { delete sample; sample = newSample; sample->setContext(&ctx); if (geom && sample) { sample->handleMeshChanged(geom); } showSample = false; } if (geom || sample) { const float* bmin = 0; const float* bmax = 0; if (sample) { bmin = sample->getBoundsMin(); bmax = sample->getBoundsMax(); } else if (geom) { bmin = geom->getMeshBoundsMin(); bmax = geom->getMeshBoundsMax(); } // Reset camera and fog to match the mesh bounds. if (bmin && bmax) { camr = sqrtf(rcSqr(bmax[0]-bmin[0]) + rcSqr(bmax[1]-bmin[1]) + rcSqr(bmax[2]-bmin[2])) / 2; camx = (bmax[0] + bmin[0]) / 2 + camr; camy = (bmax[1] + bmin[1]) / 2 + camr; camz = (bmax[2] + bmin[2]) / 2 + camr; camr *= 3; } rx = 45; ry = -45; glFogf(GL_FOG_START, camr*0.1f); glFogf(GL_FOG_END, camr*1.25f); } imguiEndScrollArea(); } // Level selection dialog. if (showLevels) { static int levelScroll = 0; if (imguiBeginScrollArea("Choose Level", width-10-250-10-200, height-10-450, 200, 450, &levelScroll)) mouseOverMenu = true; int levelToLoad = -1; for (int i = 0; i < files.size; ++i) { if (imguiItem(files.files[i])) levelToLoad = i; } if (levelToLoad != -1) { strncpy(meshName, files.files[levelToLoad], sizeof(meshName)); meshName[sizeof(meshName)-1] = '\0'; showLevels = false; delete geom; geom = 0; char path[256]; strcpy(path, "Meshes/"); strcat(path, meshName); geom = new InputGeom; if (!geom || !geom->loadMesh(&ctx, path, trinityCoreSettings)) { delete geom; geom = 0; showLog = true; logScroll = 0; ctx.dumpLog("Geom load log %s:", meshName); } if (sample && geom) { sample->handleMeshChanged(geom); } if (geom || sample) { const float* bmin = 0; const float* bmax = 0; if (sample) { bmin = sample->getBoundsMin(); bmax = sample->getBoundsMax(); } else if (geom) { bmin = geom->getMeshBoundsMin(); bmax = geom->getMeshBoundsMax(); } // Reset camera and fog to match the mesh bounds. if (bmin && bmax) { camr = sqrtf(rcSqr(bmax[0]-bmin[0]) + rcSqr(bmax[1]-bmin[1]) + rcSqr(bmax[2]-bmin[2])) / 2; camx = (bmax[0] + bmin[0]) / 2 + camr; camy = (bmax[1] + bmin[1]) / 2 + camr; camz = (bmax[2] + bmin[2]) / 2 + camr; camr *= 3; } rx = 45; ry = -45; glFogf(GL_FOG_START, camr*0.1f); glFogf(GL_FOG_END, camr*1.25f); } } imguiEndScrollArea(); } // Test cases if (showTestCases) { static int testScroll = 0; if (imguiBeginScrollArea("Choose Test To Run", width-10-250-10-200, height-10-450, 200, 450, &testScroll)) mouseOverMenu = true; int testToLoad = -1; for (int i = 0; i < files.size; ++i) { if (imguiItem(files.files[i])) testToLoad = i; } if (testToLoad != -1) { char path[256]; strcpy(path, "Tests/"); strcat(path, files.files[testToLoad]); test = new TestCase; if (test) { // Load the test. if (!test->load(path)) { delete test; test = 0; } // Create sample Sample* newSample = 0; for (int i = 0; i < g_nsamples; ++i) { if (strcmp(g_samples[i].name, test->getSampleName()) == 0) { newSample = g_samples[i].create(); if (newSample) strcpy(sampleName, g_samples[i].name); } } if (newSample) { delete sample; sample = newSample; sample->setContext(&ctx); showSample = false; } // Load geom. strcpy(meshName, test->getGeomFileName()); meshName[sizeof(meshName)-1] = '\0'; delete geom; geom = 0; strcpy(path, "Meshes/"); strcat(path, meshName); geom = new InputGeom; if (!geom || !geom->loadMesh(&ctx, path, trinityCoreSettings)) { delete geom; geom = 0; showLog = true; logScroll = 0; ctx.dumpLog("Geom load log %s:", meshName); } if (sample && geom) { sample->handleMeshChanged(geom); } // This will ensure that tile & poly bits are updated in tiled sample. if (sample) sample->handleSettings(); ctx.resetLog(); if (sample && !sample->handleBuild()) { ctx.dumpLog("Build log %s:", meshName); } if (geom || sample) { const float* bmin = 0; const float* bmax = 0; if (sample) { bmin = sample->getBoundsMin(); bmax = sample->getBoundsMax(); } else if (geom) { bmin = geom->getMeshBoundsMin(); bmax = geom->getMeshBoundsMax(); } // Reset camera and fog to match the mesh bounds. if (bmin && bmax) { camr = sqrtf(rcSqr(bmax[0]-bmin[0]) + rcSqr(bmax[1]-bmin[1]) + rcSqr(bmax[2]-bmin[2])) / 2; camx = (bmax[0] + bmin[0]) / 2 + camr; camy = (bmax[1] + bmin[1]) / 2 + camr; camz = (bmax[2] + bmin[2]) / 2 + camr; camr *= 3; } rx = 45; ry = -45; glFogf(GL_FOG_START, camr*0.2f); glFogf(GL_FOG_END, camr*1.25f); } // Do the tests. if (sample) test->doTests(sample->getNavMesh(), sample->getNavMeshQuery()); } } imguiEndScrollArea(); } // Log if (showLog && showMenu) { if (imguiBeginScrollArea("Log", 250+20, 10, width - 300 - 250, 200, &logScroll)) mouseOverMenu = true; for (int i = 0; i < ctx.getLogCount(); ++i) imguiLabel(ctx.getLogText(i)); imguiEndScrollArea(); } // Tools if (!showTestCases && showTools && showMenu) // && geom && sample) { if (imguiBeginScrollArea("Tools", 10, 10, 250, height-20, &toolsScroll)) mouseOverMenu = true; if (sample) sample->handleTools(); imguiEndScrollArea(); } slideShow.updateAndDraw(dt, (float)width, (float)height); // Marker if (mposSet && gluProject((GLdouble)mpos[0], (GLdouble)mpos[1], (GLdouble)mpos[2], model, proj, view, &x, &y, &z)) { // Draw marker circle glLineWidth(5.0f); glColor4ub(240,220,0,196); glBegin(GL_LINE_LOOP); const float r = 25.0f; for (int i = 0; i < 20; ++i) { const float a = (float)i / 20.0f * RC_PI*2; const float fx = (float)x + cosf(a)*r; const float fy = (float)y + sinf(a)*r; glVertex2f(fx,fy); } glEnd(); glLineWidth(1.0f); } imguiEndFrame(); imguiRenderGLDraw(); glEnable(GL_DEPTH_TEST); SDL_GL_SwapBuffers(); } imguiRenderGLDestroy(); SDL_Quit(); delete sample; delete geom; return 0; }
void GFXEngine::toggleFullscreen() { SDL_Surface *screen = SDL_GetVideoSurface(); SDL_SetVideoMode(screen->w, screen->h, screen->format->BitsPerPixel, screen->flags^ SDL_FULLSCREEN); }
int main(int argc, char *argv[]) { Uint32 flags; SDL_Surface *screen, *image; int i, depth, done; SDL_Event event; #if 0 SDL_RWops* rw_ops; #endif /* Check command line usage */ if ( ! argv[1] ) { fprintf(stderr, "Usage: %s <image_file>\n", argv[0]); return(1); } /* Initialize the SDL library */ if ( SDL_Init(SDL_INIT_VIDEO) < 0 ) { fprintf(stderr, "Couldn't initialize SDL: %s\n",SDL_GetError()); return(255); } flags = SDL_SWSURFACE; for ( i=1; argv[i]; ++i ) { if ( strcmp(argv[i], "-fullscreen") == 0 ) { SDL_ShowCursor(0); flags |= SDL_FULLSCREEN; continue; } #if 0 rw_ops = SDL_RWFromFile(argv[1], "r"); fprintf(stderr, "BMP:\t%d\n", IMG_isBMP(rw_ops)); fprintf(stderr, "GIF:\t%d\n", IMG_isGIF(rw_ops)); fprintf(stderr, "JPG:\t%d\n", IMG_isJPG(rw_ops)); fprintf(stderr, "PNG:\t%d\n", IMG_isPNG(rw_ops)); fprintf(stderr, "TIF:\t%d\n", IMG_isTIF(rw_ops)); /* fprintf(stderr, "TGA:\t%d\n", IMG_isTGA(rw_ops)); */ fprintf(stderr, "PCX:\t%d\n", IMG_isPCX(rw_ops)); #endif /* Open the image file */ #ifdef XPM_INCLUDED image = IMG_ReadXPMFromArray(picture_xpm); #else image = IMG_Load(argv[i]); #endif if ( image == NULL ) { fprintf(stderr, "Couldn't load %s: %s\n", argv[i], SDL_GetError()); continue; } SDL_WM_SetCaption(argv[i], "showimage"); /* Create a display for the image */ depth = SDL_VideoModeOK(image->w, image->h, 32, flags); /* Use the deepest native mode, except that we emulate 32bpp for viewing non-indexed images on 8bpp screens */ if ( depth == 0 ) { if ( image->format->BytesPerPixel > 1 ) { depth = 32; } else { depth = 8; } } else if ( (image->format->BytesPerPixel > 1) && (depth == 8) ) { depth = 32; } if(depth == 8) flags |= SDL_HWPALETTE; screen = SDL_SetVideoMode(image->w, image->h, depth, flags); if ( screen == NULL ) { fprintf(stderr,"Couldn't set %dx%dx%d video mode: %s\n", image->w, image->h, depth, SDL_GetError()); continue; } /* Set the palette, if one exists */ if ( image->format->palette ) { SDL_SetColors(screen, image->format->palette->colors, 0, image->format->palette->ncolors); } /* Draw a background pattern if the surface has transparency */ if(image->flags & (SDL_SRCALPHA | SDL_SRCCOLORKEY)) draw_background(screen); /* Display the image */ SDL_BlitSurface(image, NULL, screen, NULL); SDL_UpdateRect(screen, 0, 0, 0, 0); done = 0; while ( ! done ) { if ( SDL_PollEvent(&event) ) { switch (event.type) { case SDL_KEYUP: switch (event.key.keysym.sym) { case SDLK_LEFT: if ( i > 1 ) { i -= 2; done = 1; } break; case SDLK_RIGHT: if ( argv[i+1] ) { done = 1; } break; case SDLK_ESCAPE: case SDLK_q: argv[i+1] = NULL; /* Drop through to done */ case SDLK_SPACE: case SDLK_TAB: done = 1; break; default: break; } break; case SDL_MOUSEBUTTONDOWN: done = 1; break; case SDL_QUIT: argv[i+1] = NULL; done = 1; break; default: break; } } else { SDL_Delay(10); } } SDL_FreeSurface(image); } /* We're done! */ SDL_Quit(); return(0); }
int PDC_scr_open(int argc, char **argv) { int i; PDC_LOG(("PDC_scr_open() - called\n")); SP = calloc(1, sizeof(SCREEN)); if (!SP) return ERR; pdc_own_screen = !pdc_screen; if (pdc_own_screen) { if (SDL_Init(SDL_INIT_VIDEO|SDL_INIT_TIMER) < 0) { fprintf(stderr, "Could not start SDL: %s\n", SDL_GetError()); return ERR; } atexit(SDL_Quit); } if (!pdc_font) { const char *fname = getenv("PDC_FONT"); pdc_font = SDL_LoadBMP(fname ? fname : "pdcfont.bmp"); } if (!pdc_font) pdc_font = SDL_LoadBMP_RW(SDL_RWFromMem(deffont, sizeof(deffont)), 0); if (!pdc_font) { fprintf(stderr, "Could not load font\n"); return ERR; } SP->mono = !pdc_font->format->palette; if (!SP->mono && !pdc_back) { const char *bname = getenv("PDC_BACKGROUND"); pdc_back = SDL_LoadBMP(bname ? bname : "pdcback.bmp"); } if (!SP->mono && (pdc_back || !pdc_own_screen)) { SP->orig_attr = TRUE; SP->orig_fore = COLOR_WHITE; SP->orig_back = -1; } else SP->orig_attr = FALSE; pdc_fheight = pdc_font->h / 8; pdc_fwidth = pdc_font->w / 32; if (!SP->mono) pdc_flastc = pdc_font->format->palette->ncolors - 1; if (pdc_own_screen && !pdc_icon) { const char *iname = getenv("PDC_ICON"); pdc_icon = SDL_LoadBMP(iname ? iname : "pdcicon.bmp"); if (!pdc_icon) pdc_icon = SDL_LoadBMP_RW(SDL_RWFromMem(deficon, sizeof(deficon)), 0); if (pdc_icon) SDL_WM_SetIcon(pdc_icon, NULL); } if (pdc_own_screen) { const char *env = getenv("PDC_LINES"); pdc_sheight = (env ? atoi(env) : 25) * pdc_fheight; env = getenv("PDC_COLS"); pdc_swidth = (env ? atoi(env) : 80) * pdc_fwidth; pdc_screen = SDL_SetVideoMode(pdc_swidth, pdc_sheight, 0, SDL_SWSURFACE|SDL_ANYFORMAT|SDL_RESIZABLE); } else { if (!pdc_sheight) pdc_sheight = pdc_screen->h - pdc_yoffset; if (!pdc_swidth) pdc_swidth = pdc_screen->w - pdc_xoffset; } if (!pdc_screen) { fprintf(stderr, "Couldn't create a surface: %s\n", SDL_GetError()); return ERR; } if (SP->orig_attr) PDC_retile(); for (i = 0; i < 8; i++) { pdc_color[i].r = (i & COLOR_RED) ? 0xc0 : 0; pdc_color[i].g = (i & COLOR_GREEN) ? 0xc0 : 0; pdc_color[i].b = (i & COLOR_BLUE) ? 0xc0 : 0; pdc_color[i + 8].r = (i & COLOR_RED) ? 0xff : 0x40; pdc_color[i + 8].g = (i & COLOR_GREEN) ? 0xff : 0x40; pdc_color[i + 8].b = (i & COLOR_BLUE) ? 0xff : 0x40; } for (i = 0; i < 16; i++) pdc_mapped[i] = SDL_MapRGB(pdc_screen->format, pdc_color[i].r, pdc_color[i].g, pdc_color[i].b); SDL_EnableUNICODE(1); PDC_mouse_set(); if (pdc_own_screen) PDC_set_title(argc ? argv[0] : "PDCurses"); SP->lines = PDC_get_rows(); SP->cols = PDC_get_columns(); SP->mouse_wait = PDC_CLICK_PERIOD; SP->audible = FALSE; PDC_reset_prog_mode(); return OK; }
int main(int argc, char *argv[]) { const char* chunkfile = "crater/crater.chu"; const char* texturefile = "crater/crater.jpg"; // Process command-line args. int file_arg_index = 0; for (int i = 1; i < argc; i++) { switch (argv[i][0]) { case '-': { switch (argv[i][1]) { case 0: default: printf("error: unknown switch '%s'\n\n", argv[i]); print_usage(); exit(1); break; case 'w': // window width. i++; if (i >= argc) { printf("error: -w switch must be followed by a window width (in pixels)\n\n"); print_usage(); exit(1); } window_width = atoi(argv[i]); // bounds checking here? break; case 'h': // window height. i++; if (i >= argc) { printf("error: -h switch must be followed by a window height (in pixels)\n\n"); print_usage(); exit(1); } window_height = atoi(argv[i]); // bounds checking here? break; case 'b': // bits per pixel i++; if (i >= argc) { printf("error: -b switch must be followed by the desired window bits per pixel\n\n"); print_usage(); exit(1); } bits_per_pixel = atoi(argv[i]); break; case 'f': // fullscreen flag. fullscreen = true; break; } break; } default: { // file args. if (file_arg_index == 0) { chunkfile = argv[i]; file_arg_index++; } else if (file_arg_index == 1) { texturefile = argv[i]; file_arg_index++; } else { printf("error: too many args, starting with '%s'.\n\n", argv[i]); print_usage(); exit(1); } break; } } } // Print out program info. print_usage(); // Initialize the SDL subsystems we're using. if (SDL_Init(SDL_INIT_VIDEO /* | SDL_INIT_JOYSTICK | SDL_INIT_CDROM | SDL_INIT_AUDIO*/)) { fprintf(stderr, "Unable to init SDL: %s\n", SDL_GetError()); exit(1); } atexit(SDL_Quit); // Get current display info. const SDL_VideoInfo* info = NULL; info = SDL_GetVideoInfo(); if (!info) { fprintf(stderr, "SDL_GetVideoInfo() failed."); exit(1); } if (bits_per_pixel == 0) { // Take the default desktop depth. bits_per_pixel = info->vfmt->BitsPerPixel; } int flags = SDL_OPENGL | (fullscreen ? SDL_FULLSCREEN : 0); int component_depth = 0; if (bits_per_pixel <= 16) { component_depth = 5; } else if (bits_per_pixel <= 32) { component_depth = 8; } else { component_depth = bits_per_pixel / 4; // Assume the user knows what they're trying to do. } SDL_GL_SetAttribute( SDL_GL_RED_SIZE, component_depth ); SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, component_depth ); SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, component_depth ); SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, 24 ); SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 ); // Set the video mode. if (SDL_SetVideoMode(window_width, window_height, bits_per_pixel, flags) == 0) { fprintf(stderr, "SDL_SetVideoMode() failed."); exit(1); } // Initialize the engine's opengl subsystem (loads extensions if possible). ogl::open(); printf("Window: %d x %d x %d\n", window_width, window_height, bits_per_pixel); // Load a texture or a texture-quadtree object. tqt* texture_quadtree = NULL; // Does it look like a .tqt file? if (tqt::is_tqt_file(texturefile)) { texture_quadtree = new tqt(texturefile); } if (texture_quadtree == NULL) { // // No texture quadtree; try to load the texture arg as an ordinary texture. // SDL_Surface* texture = IMG_Load(texturefile); if (texture) { glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, 1); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); // glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); // glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, texture->w, texture->h, 0, GL_RGB, GL_UNSIGNED_BYTE, texture->pixels); gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGB, texture->w, texture->h, GL_RGB, GL_UNSIGNED_BYTE, texture->pixels); SDL_FreeSurface(texture); glBindTexture(GL_TEXTURE_2D, 1); } } glEnable(GL_TEXTURE_2D); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); // GL_MODULATE // Sometimes (under Win32) for debugging it's better to not catch // exceptions. //#define CATCH_EXCEPTIONS #ifdef CATCH_EXCEPTIONS try #endif // CATCH_EXCEPTIONS { // Load our chunked model. SDL_RWops* in = SDL_RWFromFile(chunkfile, "rb"); if (in == NULL) { printf("Can't open '%s'\n", chunkfile); exit(1); } lod_chunk_tree* model = new lod_chunk_tree(in); // Enable vertex array, and just leave it on. glEnableClientState(GL_VERTEX_ARRAY); view.m_frame_number = 1; if (texture_quadtree == NULL) { // Set up automatic texture-coordinate generation. // Basically we're just stretching the current texture // over the entire model. vec3 center, extent; model->get_bounding_box(¢er, &extent); float xsize = extent.get_x() * 2; float zsize = extent.get_z() * 2; glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR); float p[4] = { 0, 0, 0, 0 }; p[0] = 1.0f / xsize; glTexGenfv(GL_S, GL_OBJECT_PLANE, p); p[0] = 0; glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR); p[2] = 1.0f / zsize; glTexGenfv(GL_T, GL_OBJECT_PLANE, p); glEnable(GL_TEXTURE_GEN_S); glEnable(GL_TEXTURE_GEN_T); } // Main loop. Uint32 last_ticks = SDL_GetTicks(); for (;;) { Uint32 ticks = SDL_GetTicks(); int delta_ticks = ticks - last_ticks; float delta_t = delta_ticks / 1000.f; last_ticks = ticks; process_events(); if ( move_forward ) { // Drift the viewpoint forward. viewer_pos += viewer_dir * delta_t * (float) (1 << speed) * 0.50f; } model->set_parameters(max_pixel_error, (float) window_width, horizontal_fov_degrees); if (enable_update) { model->update(viewer_pos, texture_quadtree); } clear(); frame_triangle_count += model->render(view, render_opt); SDL_GL_SwapBuffers(); view.m_frame_number++; // Performance counting. if ( measure_performance ) { frame_count ++; total_triangle_count += frame_triangle_count; performance_timer += delta_ticks; // See if one second has elapsed. if ( performance_timer > 1000 ) { // Print out stats for the previous second. float fps = frame_count / ( performance_timer / 1000.f ); float tps = total_triangle_count / ( performance_timer / 1000.f ); printf( "fps = %3.1f : tri/s = %3.2fM : tri/frame = %2.3fM\n", fps, tps / 1000000.f, frame_triangle_count / 1000000.f ); total_triangle_count = 0; performance_timer = 0; frame_count = 0; } frame_triangle_count = 0; } } SDL_RWclose(in); } #ifdef CATCH_EXCEPTIONS catch (const char* message) { printf("run-time exception: %s\n", message); exit(1); } catch (...) { printf("run-time exception: unknown type\n"); exit(1); } #endif // CATCH_EXCEPTIONS return 0; }