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;
}
