int main(int argc, char* argv[]) { // Initiate random numbers srand(time(NULL)); int angleDeg = rand() % 360; float angleRad = (float) angleDeg * 2.0 * 3.14159 / 360.0; printf("Initial angle = %f\n", angleRad); XYPair pos = { (SCREEN_WIDTH - 100) / 2, (SCREEN_HEIGHT - 100) / 2 }; XYPair vel = GetUnitVector(angleRad); vel = ScaleVector(vel, 200.0 / (float) FRAMERATE); double angle = 0; SDL_Window* window = NULL; SDL_Renderer* renderer = NULL; if (SDL_Init(SDL_INIT_VIDEO) < 0) { printf("SDL initialization error: %s\n", SDL_GetError()); return -1; } SDL_LogSetAllPriority(SDL_LOG_PRIORITY_WARN); printf("Main\n"); window = SDL_CreateWindow("Bouncing Ball", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN); if (window == NULL) { printf("Error creating window: %s\n", SDL_GetError()); return -1; } renderer = SDL_CreateRenderer(window, -1, 0); if (renderer == NULL) { printf("Failed to create the renderer: %s\n", SDL_GetError()); return -1; } SDL_SetRenderDrawColor(renderer, 255,255,255,255); // Load textures IMG_Init(IMG_INIT_PNG|IMG_INIT_JPG); SDL_Texture* ball = LoadTexture("bb.png", renderer); SDL_Texture* bg = LoadTexture("bg.jpg", renderer); IMG_Quit(); if ( (ball == NULL) || (bg == NULL) ) { printf("Error loading the textures\n"); return -1; } printf("Images loaded OK\n"); bool quit = false; while (!quit) { Uint32 startTick = SDL_GetTicks(); SDL_Rect ballPos; ballPos.h = 100; ballPos.w = 100; ballPos.x = pos.x; ballPos.y = pos.y; SDL_RenderClear(renderer); SDL_RenderCopy(renderer, bg, NULL, NULL); SDL_RenderCopyEx(renderer, ball, NULL, &ballPos, angle, NULL, SDL_FLIP_NONE); SDL_RenderPresent(renderer); UpdatePosition(&pos, &vel, &angle, SCREEN_WIDTH - 100, SCREEN_HEIGHT - 100); Uint32 stopTick = SDL_GetTicks(); Uint32 processingTime = (stopTick - startTick); if ( (stopTick - startTick) < (1000 / FRAMERATE) ) { printf("Delaying %u ticks\n", 1000 / FRAMERATE - processingTime); SDL_Delay(1000 / FRAMERATE - processingTime); } SDL_Event e; while(SDL_PollEvent(&e) != 0) { if (e.type == SDL_QUIT) { printf("User quitting\n"); quit = true; } } } SDL_DestroyTexture(ball); SDL_DestroyTexture(bg); SDL_DestroyRenderer(renderer); SDL_DestroyWindow(window); SDL_Quit(); return 0; }
int SDL_MAIN_FUNC(int argc, char *argv[]) { CLogger logger; CSystemUtils* systemUtils = CSystemUtils::Create(); // platform-specific utils systemUtils->Init(); PREV_TIME = GetSystemUtils()->CreateTimeStamp(); CURR_TIME = GetSystemUtils()->CreateTimeStamp(); GetSystemUtils()->GetCurrentTimeStamp(PREV_TIME); GetSystemUtils()->GetCurrentTimeStamp(CURR_TIME); // Without any error checking, for simplicity SDL_Init(SDL_INIT_VIDEO); IMG_Init(IMG_INIT_PNG); const SDL_VideoInfo *videoInfo = SDL_GetVideoInfo(); Uint32 videoFlags = SDL_OPENGL | SDL_GL_DOUBLEBUFFER | SDL_HWPALETTE; if (videoInfo->hw_available) videoFlags |= SDL_HWSURFACE; else videoFlags |= SDL_SWSURFACE; if (videoInfo->blit_hw) videoFlags |= SDL_HWACCEL; 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, 8); SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); SDL_Surface *surface = SDL_SetVideoMode(800, 600, 32, videoFlags); SDL_WM_SetCaption("Transform Test", "Transform Test"); //SDL_WM_GrabInput(SDL_GRAB_ON); SDL_ShowCursor(SDL_DISABLE); Gfx::CGLDevice *device = new Gfx::CGLDevice(Gfx::GLDeviceConfig()); device->Create(); Init(device); bool done = false; while (! done) { Render(device); Update(); SDL_GL_SwapBuffers(); SDL_Event event; while (SDL_PollEvent(&event)) { if (event.type == SDL_QUIT) { break; done = true; } else if (event.type == SDL_KEYDOWN) { if (event.key.keysym.sym == SDLK_q) { done = true; break; } else KeyboardDown(event.key.keysym.sym); } else if (event.type == SDL_KEYUP) KeyboardUp(event.key.keysym.sym); else if (event.type == SDL_MOUSEMOTION) MouseMove(event.motion.x, event.motion.y); } usleep(FRAME_DELAY); } //SDL_WM_GrabInput(SDL_GRAB_OFF); SDL_ShowCursor(SDL_ENABLE); device->Destroy(); delete device; SDL_FreeSurface(surface); IMG_Quit(); SDL_Quit(); GetSystemUtils()->DestroyTimeStamp(PREV_TIME); GetSystemUtils()->DestroyTimeStamp(CURR_TIME); return 0; }
SDL::~SDL() { if (_mix) Mix_Quit(); if (_img) IMG_Quit(); if (_sdl) SDL_Quit(); }
Tetrimino::~Tetrimino(){ releaseResource(); TTF_Quit(); IMG_Quit(); SDL_Quit(); }
void App::run() { is_running = true; //inicjalizacja SDL i utworzenie okan if(SDL_Init(SDL_INIT_VIDEO) == 0) { m_window = SDL_CreateWindow("TANKS", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, AppConfig::windows_rect.w, AppConfig::windows_rect.h, SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE); if(m_window == nullptr) return; if(!(IMG_Init(IMG_INIT_PNG) & IMG_INIT_PNG)) return; if(TTF_Init() == -1) return; srand(time(NULL)); //inicjowanie generatora pseudolosowego Engine& engine = Engine::getEngine(); engine.initModules(); engine.getRenderer()->loadTexture(m_window); engine.getRenderer()->loadFont(); m_app_state = new Menu; double FPS; Uint32 time1, time2, dt, fps_time = 0, fps_count = 0, delay = 15; time1 = SDL_GetTicks(); while(is_running) { time2 = SDL_GetTicks(); dt = time2 - time1; time1 = time2; if(m_app_state->finished()) { AppState* new_state = m_app_state->nextState(); delete m_app_state; m_app_state = new_state; } if(m_app_state == nullptr) break; eventProces(); m_app_state->update(dt); m_app_state->draw(); SDL_Delay(delay); //FPS fps_time += dt; fps_count++; if(fps_time > 200) { FPS = (double)fps_count / fps_time * 1000; if(FPS > 60) delay++; else if(delay > 0) delay--; fps_time = 0; fps_count = 0; } } engine.destroyModules(); } SDL_DestroyWindow(m_window); m_window = nullptr; TTF_Quit(); IMG_Quit(); SDL_Quit(); }
int main(int argc, char *argv[]) { int opt; int can; struct ifreq ifr; struct sockaddr_can addr; struct canfd_frame frame; struct iovec iov; struct msghdr msg; struct cmsghdr *cmsg; struct timeval tv, timeout_config = { 0, 0 }; fd_set rdfs; char ctrlmsg[CMSG_SPACE(sizeof(struct timeval)) + CMSG_SPACE(sizeof(__u32))]; int running = 1; int nbytes, maxdlen; int ret; int seed = 0; int door_id, signal_id, speed_id; SDL_Event event; while ((opt = getopt(argc, argv, "rs:dh?")) != -1) { switch(opt) { case 'r': randomize = 1; break; case 's': seed = atoi(optarg); break; case 'd': debug = 1; break; case 'h': case '?': default: Usage(NULL); break; } } if (optind >= argc) Usage("You must specify at least one can device"); if (seed && randomize) Usage("You can not specify a seed value AND randomize the seed"); // Create a new raw CAN socket can = socket(PF_CAN, SOCK_RAW, CAN_RAW); if(can < 0) Usage("Couldn't create raw socket"); addr.can_family = AF_CAN; memset(&ifr.ifr_name, 0, sizeof(ifr.ifr_name)); strncpy(ifr.ifr_name, argv[optind], strlen(argv[optind])); printf("Using CAN interface %s\n", ifr.ifr_name); if (ioctl(can, SIOCGIFINDEX, &ifr) < 0) { perror("SIOCGIFINDEX"); exit(1); } addr.can_ifindex = ifr.ifr_ifindex; // CAN FD Mode setsockopt(can, SOL_CAN_RAW, CAN_RAW_FD_FRAMES, &canfd_on, sizeof(canfd_on)); iov.iov_base = &frame; iov.iov_len = sizeof(frame); msg.msg_name = &addr; msg.msg_namelen = sizeof(addr); msg.msg_iov = &iov; msg.msg_iovlen = 1; msg.msg_control = &ctrlmsg; msg.msg_controllen = sizeof(ctrlmsg); msg.msg_flags = 0; if (bind(can, (struct sockaddr *)&addr, sizeof(addr)) < 0) { perror("bind"); return 1; } init_car_state(); door_id = DEFAULT_DOOR_ID; signal_id = DEFAULT_SIGNAL_ID; speed_id = DEFAULT_SPEED_ID; if (randomize || seed) { if(randomize) seed = time(NULL); srand(seed); door_id = (rand() % 2046) + 1; signal_id = (rand() % 2046) + 1; speed_id = (rand() % 2046) + 1; door_pos = rand() % 9; signal_pos = rand() % 9; speed_pos = rand() % 8; printf("Seed: %d\n", seed); } SDL_Window *window = NULL; SDL_Surface *screenSurface = NULL; if(SDL_Init ( SDL_INIT_VIDEO ) < 0 ) { printf("SDL Could not initializes\n"); exit(40); } window = SDL_CreateWindow("IC Simulator", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN ); if(window == NULL) { printf("Window could not be shown\n"); } renderer = SDL_CreateRenderer(window, -1, 0); SDL_Surface *image = IMG_Load(get_data("ic.png")); SDL_Surface *needle = IMG_Load(get_data("needle.png")); SDL_Surface *sprites = IMG_Load(get_data("spritesheet.png")); base_texture = SDL_CreateTextureFromSurface(renderer, image); needle_tex = SDL_CreateTextureFromSurface(renderer, needle); sprite_tex = SDL_CreateTextureFromSurface(renderer, sprites); speed_rect.x = 212; speed_rect.y = 175; speed_rect.h = needle->h; speed_rect.w = needle->w; // Draw the IC redraw_ic(); /* For now we will just operate on one CAN interface */ while(running) { while( SDL_PollEvent(&event) != 0 ) { switch(event.type) { case SDL_QUIT: running = 0; break; } } nbytes = recvmsg(can, &msg, 0); if (nbytes < 0) { perror("read"); return 1; } if ((size_t)nbytes == CAN_MTU) maxdlen = CAN_MAX_DLEN; else if ((size_t)nbytes == CANFD_MTU) maxdlen = CANFD_MAX_DLEN; else { fprintf(stderr, "read: incomplete CAN frame\n"); return 1; } for (cmsg = CMSG_FIRSTHDR(&msg); cmsg && (cmsg->cmsg_level == SOL_SOCKET); cmsg = CMSG_NXTHDR(&msg,cmsg)) { if (cmsg->cmsg_type == SO_TIMESTAMP) tv = *(struct timeval *)CMSG_DATA(cmsg); else if (cmsg->cmsg_type == SO_RXQ_OVFL) //dropcnt[i] = *(__u32 *)CMSG_DATA(cmsg); fprintf(stderr, "Dropped packet\n"); } // if(debug) fprint_canframe(stdout, &frame, "\n", 0, maxdlen); if(frame.can_id == door_id) update_door_status(&frame, maxdlen); if(frame.can_id == signal_id) update_signal_status(&frame, maxdlen); if(frame.can_id == speed_id) update_speed_status(&frame, maxdlen); } SDL_DestroyTexture(base_texture); SDL_DestroyTexture(needle_tex); SDL_DestroyTexture(sprite_tex); SDL_FreeSurface(image); SDL_FreeSurface(needle); SDL_FreeSurface(sprites); SDL_DestroyRenderer(renderer); SDL_DestroyWindow(window); IMG_Quit(); SDL_Quit(); return 0; }
~Image() noexcept { IMG_Quit(); }
/* ================================================================================ Game::Shutdown Performs cleanup after the game ends. Deletes any active entities, releases resources, kills the window, and shuts down the supporting libs. ================================================================================ */ void Game::Shutdown() { //Frees the sound chunks and sets it to NULL Mix_FreeChunk(mCoinSound); mCoinSound = NULL; Mix_FreeChunk(mJumpSound); mJumpSound = NULL; Mix_FreeChunk(mStompSound); mStompSound = NULL; Mix_FreeChunk(mDieSound); mDieSound = NULL; Mix_FreeChunk(mStompSoundNoKill); mStompSoundNoKill = NULL; Mix_FreeChunk(mBlockSound); mBlockSound = NULL; //Free the music Mix_FreeMusic(mMusic); mMusic = NULL; Mix_FreeMusic(mGoodGameOverMusic); mGoodGameOverMusic = NULL; Mix_FreeMusic(mBadGameOverMusic); mBadGameOverMusic = NULL; //We also need to quit the mixer Mix_Quit(); delete mRobot; mRobot = NULL; // delete grid delete mGrid; mGrid = NULL; // delete all explosions std::list<Explosion*>::iterator it = mExplosions.begin(); for ( ; it != mExplosions.end(); ++it) { delete *it; } mExplosions.clear(); // delete all meteors std::list<Meteor*>::iterator metIt = mMeteors.begin(); for ( ; metIt != mMeteors.end(); ++metIt) { delete *metIt; } mMeteors.clear(); // delete all crawlers and clear the list std::list<Crawler*>::iterator crawlerIter = mCrawlers.begin(); for ( ; crawlerIter != mCrawlers.end(); ++crawlerIter) { Crawler* crawler = *crawlerIter; delete crawler; } mCrawlers.clear(); // delete all coins and clear the list std::list<Coin*>::iterator coinIter = mCoins.begin(); for ( ; coinIter != mCoins.end(); ++coinIter) { Coin* coin = *coinIter; delete coin; } mCoins.clear(); // delete all mushrooms std::list<Layer*>::iterator mushIter = mMushrooms.begin(); for ( ; mushIter != mMushrooms.end(); ++mushIter) { delete *mushIter; } mMeteors.clear(); // delete the texture manager (and all the textures it loaded for us) delete mTexMgr; mTexMgr = NULL; delete mBackground; mBackground = NULL; delete mForeground; mForeground = NULL; // Shutdown the TTF library TTF_Quit(); // unload the image libraries IMG_Quit(); // shut down SDL (deletes the window and renderer) SDL_Quit(); mWindow = NULL; mRenderer = NULL; mKeyState = NULL; }
int main() { if(SDL_Init(SDL_INIT_VIDEO)) { fprintf(stderr, "SDL_Init Error: %s\n", SDL_GetError()); exit(1); } SDL_Window *win = SDL_CreateWindow("Moving start", 100, 100, SCREEN_HEIGHT, SCREEN_WIDTH, SDL_WINDOW_SHOWN); if(!win) { fprintf(stderr, "SDL_CreateWindow Error: %s\n", SDL_GetError()); SDL_Quit(); exit(1); } if(!IMG_Init(IMG_INIT_PNG)) { fprintf(stderr, "IMG_Init Error: %s\n", IMG_GetError()); SDL_DestroyWindow(win); SDL_Quit(); exit(1); } SDL_Renderer *ren = SDL_CreateRenderer(win, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC); if(!ren) { fprintf(stderr, "SDL_CreateRenderer Error: %s\n", SDL_GetError()); IMG_Quit(); SDL_DestroyWindow(win); SDL_Quit(); exit(1); } SDL_Surface *png = IMG_Load("../../MediaResources/star.png"); if(!png) { fprintf(stderr, "IMG_Load Error: %s\n", IMG_GetError()); SDL_DestroyRenderer(ren); IMG_Quit(); SDL_DestroyWindow(win); SDL_Quit(); exit(1); } SDL_Texture *tex = SDL_CreateTextureFromSurface(ren, png); SDL_FreeSurface(png); if(!tex) { fprintf(stderr, "SDL_CreateTextureFromSurface Error: %s\n", SDL_GetError()); SDL_DestroyRenderer(ren); IMG_Quit(); SDL_DestroyWindow(win); SDL_Quit(); exit(1); } int x0 = SCREEN_WIDTH / 2 - 32, y0 = SCREEN_HEIGHT / 2 - 32; SDL_Rect dstRect = {0, 0, 64, 64}; SDL_SetRenderDrawColor(ren, 0xFF, 0xFF, 0x00, 0xFF); SDL_RenderClear(ren); for(double i = 0; i < 360; i += 30) { dstRect.x = x0 + sin(i * 3.14 / 180) * x0; dstRect.y = y0 + cos(i * 3.14 / 180) * y0; SDL_RenderCopy(ren, tex, NULL, &dstRect); } SDL_RenderPresent(ren); SDL_Delay(5000); SDL_DestroyTexture(tex); SDL_DestroyRenderer(ren); IMG_Quit(); SDL_DestroyWindow(win); SDL_Quit(); return 0; }
/* Desc: Called upon program exit to exit systems. Args: None. Ret: Nothing. */ void quit() { IMG_Quit(); SDL_Quit(); }
int SDL_MAIN_FUNC(int argc, char *argv[]) { CLogger logger; // Without any error checking, for simplicity SDL_Init(SDL_INIT_VIDEO); IMG_Init(IMG_INIT_PNG); const SDL_VideoInfo *videoInfo = SDL_GetVideoInfo(); Uint32 videoFlags = SDL_OPENGL | SDL_GL_DOUBLEBUFFER | SDL_HWPALETTE; if (videoInfo->hw_available) videoFlags |= SDL_HWSURFACE; else videoFlags |= SDL_SWSURFACE; if (videoInfo->blit_hw) videoFlags |= SDL_HWACCEL; 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, 8); SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); SDL_Surface *surface = SDL_SetVideoMode(800, 600, 32, videoFlags); SDL_WM_SetCaption("Texture Test", "Texture Test"); Gfx::CGLDevice *device = new Gfx::CGLDevice(Gfx::GLDeviceConfig()); device->Create(); Init(device); bool done = false; while (! done) { Render(device); SDL_GL_SwapBuffers(); SDL_Event event; SDL_PollEvent(&event); if (event.type == SDL_QUIT) done = true; usleep(10000); } device->Destroy(); delete device; SDL_FreeSurface(surface); IMG_Quit(); SDL_Quit(); return 0; }
int main(int argc, char *argv[]) { /* initialize SDL first */ if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK) < 0) { Debug() << "Error initializing SDL:" << SDL_GetError(); return 0; } if (!EventThread::allocUserEvents()) { Debug() << "Error allocating SDL user events"; return 0; } /* set working directory */ char *dataDir = SDL_GetBasePath(); if (dataDir) { int result = chdir(dataDir); (void)result; SDL_free(dataDir); } /* now we load the config */ Config conf; conf.read(argc, argv); conf.readGameINI(); int imgFlags = IMG_INIT_PNG | IMG_INIT_JPG; if (IMG_Init(imgFlags) != imgFlags) { Debug() << "Error initializing SDL_image:" << SDL_GetError(); SDL_Quit(); return 0; } if (TTF_Init() < 0) { Debug() << "Error initializing SDL_ttf:" << SDL_GetError(); IMG_Quit(); SDL_Quit(); return 0; } if (Sound_Init() == 0) { Debug() << "Error initializing SDL_sound:" << Sound_GetError(); TTF_Quit(); IMG_Quit(); SDL_Quit(); return 0; } SDL_SetHint("SDL_VIDEO_MINIMIZE_ON_FOCUS_LOSS", "0"); SDL_Window *win; Uint32 winFlags = SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN; if (conf.winResizable) winFlags |= SDL_WINDOW_RESIZABLE; if (conf.fullscreen) winFlags |= SDL_WINDOW_FULLSCREEN_DESKTOP; win = SDL_CreateWindow(conf.game.title.c_str(), SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, conf.defScreenW, conf.defScreenH, winFlags); if (!win) { Debug() << "Error creating window"; return 0; } if (!conf.iconPath.empty()) { SDL_Surface *iconImg = IMG_Load(conf.iconPath.c_str()); if (iconImg) { SDL_SetWindowIcon(win, iconImg); SDL_FreeSurface(iconImg); } } EventThread eventThread; RGSSThreadData rtData(&eventThread, argv[0], win, conf); /* Start RGSS thread */ SDL_Thread *rgssThread = SDL_CreateThread(rgssThreadFun, "rgss", &rtData); /* Start event processing */ eventThread.process(rtData); /* Request RGSS thread to stop */ rtData.rqTerm = true; /* Wait for RGSS thread response */ for (int i = 0; i < 1000; ++i) { /* We can stop waiting when the request was ack'd */ if (rtData.rqTermAck) { Debug() << "RGSS thread ack'd request after" << i*10 << "ms"; break; } /* Give RGSS thread some time to respond */ SDL_Delay(10); } /* If RGSS thread ack'd request, wait for it to shutdown, * otherwise abandon hope and just end the process as is. */ if (rtData.rqTermAck) SDL_WaitThread(rgssThread, 0); else SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, conf.game.title.c_str(), "The RGSS script seems to be stuck and mkxp will now force quit", win); if (!rtData.rgssErrorMsg.empty()) SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, conf.game.title.c_str(), rtData.rgssErrorMsg.c_str(), win); /* Clean up any remainin events */ eventThread.cleanup(); Debug() << "Shutting down."; SDL_DestroyWindow(win); Sound_Quit(); TTF_Quit(); IMG_Quit(); SDL_Quit(); return 0; }
void WorldGL::DestructFrameworks () { SDL_Quit (); IMG_Quit (); TTF_Quit (); }
int main(int argc, char * arg[]) { //Controls the game loop bool run = true; // init everyting - SDL, if it is nonzero we have a problem if (SDL_Init(SDL_INIT_EVERYTHING) != 0) { std::cout << "ERROR SDL_Init " << SDL_GetError() << std::endl; return -1; } // int imageInitFlags = IMG_INIT_JPG | IMG_INIT_PNG; int returnInitFlags = IMG_Init(imageInitFlags); if (((returnInitFlags)& (imageInitFlags)) != imageInitFlags) { cout << "ERROR SDL_Image Init " << IMG_GetError() << endl; } if (TTF_Init() == -1) { std::cout << "ERROR TTF_Init: " << TTF_GetError(); } //Request opengl 4.1 context, Core Context SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE); SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4); SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1); //Create a window SDL_Window * window = SDL_CreateWindow( "SDL", // window title SDL_WINDOWPOS_CENTERED, // x position, centered SDL_WINDOWPOS_CENTERED, // y position, centered 640, // width, in pixels 480, // height, in pixels SDL_WINDOW_OPENGL // flags ); // Create an OpenGL context associated with the window. SDL_GLContext glcontext = SDL_GL_CreateContext(window); //Call our InitOpenGL Function initOpenGL(); //Set our viewport setViewport(640, 480); initScene(); //Value to hold the event generated by SDL SDL_Event event; //Game Loop while (run) { //While we still have events in the queue while (SDL_PollEvent(&event)) { //Get event type if (event.type == SDL_QUIT || event.type == SDL_WINDOWEVENT_CLOSE) { //set our boolean which controls the loop to false run = false; } if (event.type == SDL_KEYDOWN){ switch (event.key.keysym.sym) { case SDLK_LEFT: break; case SDLK_RIGHT: break; case SDLK_UP: break; case SDLK_DOWN: break; default: break; } } } //init Scene update(); //render render(); //Call swap so that our GL back buffer is displayed SDL_GL_SwapWindow(window); } // clean up, reverse order!!! cleanUp(); SDL_GL_DeleteContext(glcontext); SDL_DestroyWindow(window); IMG_Quit(); TTF_Quit(); SDL_Quit(); return 0; }
int main(int argc, char** argv) { // Seed and refresh RNG std::srand((unsigned)std::time(NULL) ^ (unsigned)std::rand()); short n = 10 + rand() % 10; for (short i = 0; i < n; i++) { std::rand(); } // Initialize SDL if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO) < 0) { std::cerr << "*** Failed to initialize SDL: " << SDL_GetError() << std::endl; return EXIT_FAILURE; } // Initialize SDL_image library if (!IMG_Init(IMG_INIT_JPG | IMG_INIT_PNG)) { std::cerr << "*** Failed to initialize SDL_image: " << IMG_GetError() << std::endl; return EXIT_FAILURE; } // Initialize SDL_mixer library if (Mix_OpenAudio(44100, MIX_DEFAULT_FORMAT, 2, 1024) < 0) { std::cerr << "*** Failed to initialize SDL_mixer: " << Mix_GetError() << std::endl; return EXIT_FAILURE; } Mix_AllocateChannels(64); // Initialize TTF library if (TTF_Init() == -1) { std::cerr << "*** Failed to initialize SDL_ttf: " << TTF_GetError() << std::endl; return EXIT_FAILURE; } // Create a window g_WindowWidth = 800; g_WindowHeight = 600; g_Window = SDL_CreateWindow("Loading...", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, g_WindowWidth, g_WindowHeight, SDL_WINDOW_SHOWN); if (!g_Window) { std::cerr << "*** Failed to create window: " << SDL_GetError() << std::endl; return EXIT_FAILURE; } // Get a pointer to keyboard state managed by SDL g_KeyStates = SDL_GetKeyboardState(NULL); // Create a renderer that takes care of drawing stuff to the window g_Renderer = SDL_CreateRenderer(g_Window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC); if (!g_Renderer) { std::cerr << "*** Failed to create renderer: " << SDL_GetError() << std::endl; return EXIT_FAILURE; } SDL_SetRenderDrawBlendMode(g_Renderer, SDL_BLENDMODE_BLEND); // Create game Game game; if (!game.Initialize()) { std::cerr << "*** Game initialization failed" << std::endl; return EXIT_FAILURE; } // Main loop // Start tracking total game time and frame time g_Timer.Start(); Timer frameTimer; frameTimer.Start(); while (!g_ShouldQuit) { ++g_FrameNo; // Draw current frame game.Draw(g_Renderer); SDL_RenderPresent(g_Renderer); // Forward events to game handlers SDL_Event e; while (SDL_PollEvent(&e)) { switch (e.type) { case SDL_QUIT: g_ShouldQuit = true; break; case SDL_KEYDOWN: game.OnKeyDown(e.key); break; case SDL_KEYUP: game.OnKeyUp(e.key); break; case SDL_MOUSEBUTTONDOWN: game.OnMouseDown(e.button); break; case SDL_MOUSEBUTTONUP: game.OnMouseUp(e.button); break; case SDL_MOUSEMOTION: game.OnMouseMotion(e.motion); break; default: break; } } // Update total game time g_Time = g_Timer.GetTime(); // Get time elapsed since last frame and restart frame timer g_TimeSinceLastFrame = frameTimer.GetTime(); frameTimer.Start(); // Update game if it's not paused if (!g_IsPaused) { game.Update(g_TimeSinceLastFrame); } } // Cleanup game.Shutdown(); TTF_Quit(); IMG_Quit(); Mix_Quit(); SDL_Quit(); std::cout << "## Goodbye!" << std::endl; return 0; }