Пример #1
0
void ModoGraficoSDL::actualizar()
{
	SDL_RenderPresent(this->renderizador);
}
Пример #2
0
int main(int argc, const char *argv[])
{
    if(argc != 2) {
        printf("%s takes .ttf file as argument.\n", argv[0]);
        return 1;
    }

    SDL_version compile_version;
    const SDL_version *link_version=TTF_Linked_Version();
    SDL_TTF_VERSION(&compile_version);
    printf("compiled with SDL_ttf version: %d.%d.%d\n",
            compile_version.major,
            compile_version.minor,
            compile_version.patch);
    printf("running with SDL_ttf version: %d.%d.%d\n",
            link_version->major,
            link_version->minor,
            link_version->patch);

    if(SDL_Init(SDL_INIT_EVERYTHING) != 0) {
        printf("Error with import!\n");
        return 1;
    }

    SDL_Window *win = SDL_CreateWindow( "TTF Test",
                                        SDL_WINDOWPOS_CENTERED,
                                        SDL_WINDOWPOS_CENTERED,
                                        800,
                                        600,
                                        SDL_WINDOW_SHOWN);

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

    if(TTF_Init() == -1) {
        printf("Error loading TTF_Init()!\n%s\n", TTF_GetError());
        SDL_Quit();
        exit(2);
    }

    TTF_Font *font;
    /* MS Himalaya (himalaya.ttf): http://fontzone.net/font-details/microsoft-himalaya */
    font = TTF_OpenFont(argv[1], 600);

    if(!font) {
        printf("%s\n", TTF_GetError());
        return 1;
    }

    const char tibstring[] = {  0xe0, 0xbd, 0x96,
                                0xe0, 0xbd, 0xa6,
                                0xe0, 0xbe, 0x90,
                                0xe0, 0xbe, 0xb1,
                                0xe0, 0xbd, 0xbc,
                                0xe0, 0xbd, 0x84,
                                0xe0, 0xbd, 0xa6 };

    SDL_Color colour = { 255, 255, 255, 255 };
    SDL_Surface *surface = TTF_RenderUTF8_Solid(font, tibstring, colour);

    if(surface == NULL) {
        TTF_CloseFont(font);
        printf("Surface error!\n");
        return 0;
    }

    SDL_Texture *texture = SDL_CreateTextureFromSurface(renderer, surface);

    SDL_Event event;
    int quit = 0;

    while (!quit) {

        while (SDL_PollEvent(&event)) {
            if (event.type == SDL_QUIT)
                quit = 1;
        }

        SDL_RenderClear(renderer);
        SDL_RenderCopy(renderer, texture, NULL, NULL);
        SDL_RenderPresent(renderer);
    }

    TTF_CloseFont(font);
    SDL_Quit();

    return 0;
}
Пример #3
0
int main(int argc, char *args[]) {
	SDL_Init(SDL_INIT_EVERYTHING); //Init SDL
	Mix_Init(MIX_INIT_FLAC | MIX_INIT_MOD | MIX_INIT_MP3 | MIX_INIT_OGG); //Init SDL Mixer
	Mix_OpenAudio(22050, AUDIO_S16SYS, 2, 4096); //Open audiostream
	int temp = officalDelay; //The delay it will play
	int holder = -1; //Hold which sound it played before
	int counter = 0; //How many soundclips have been played

	//Create window and check if it's loaded
	SDL_Window *win = SDL_CreateWindow("Omvand Synestesi", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, 800, 800, SDL_WINDOW_SHOWN);
	if (win == NULL) {
		std::cout << "Couldn't create window, unkown error." << std::endl;
	}
	
	//Make a renderer
	SDL_Renderer *renderer = SDL_CreateRenderer(win, 0, SDL_RENDERER_ACCELERATED);
	
	//Create a texture, load it. Check if it's loaded
	SDL_Texture *texture = load_texture("get.bmp", renderer);
	if(texture == NULL) {
		std::cout << "Couldn't load picture, check so it's named get.bmp" << std::endl;
	}

	//Loads a surface, this is the picture it will take and make sound of.
	SDL_Surface *image = SDL_LoadBMP("get.bmp");
	if (image == NULL) {
		std::cout << "Couldn't load picture until surface. Check the name so it is get.bmp" << std::endl;
	}

	//Load soundfiles
	Mix_Music *sound[15];
	for (int i = 1; i < 16; i++) {
		std::string path = "sound/get" + convertInt(i) + ".wav";
		sound[i] = Mix_LoadMUS(path.c_str());
		std::cout << "Loaded soundfile: " << path << std::endl;

		if (sound[i] == NULL) {
			std::cout << "Couldn't load soundfile " << path << ". Check so the name is get" << i << ".wav" << std::endl;
		}
	}

	//Loop through the whole picture
	for (int y = 0; y < size_h; y++) {
		for (int x = 0; x < size_w; x++) {
			Uint32 pix = getPixel(image, x, y);
			SDL_RenderClear(renderer); //Clear the screen
			SDL_RenderCopy(renderer, texture, NULL, NULL); //Print out the picture
			SDL_RenderPresent(renderer); //Actually render the picture
			
			int npix = pix % 16 + 1; //Get's a value from the pixel and makes it so it's just 1 to 16

			std::cout << "!-- " << pix << " --! " << npix << " | " << counter << "/1296" << std::endl; //Prints out some stuff so you can see for debugging mostly

			//If the same value is again, make a longer delay before playing next song, and if not, go back to standard delay
			if (npix == holder) {
				temp = temp + 120;
			}
			else {
				temp = officalDelay;
			}

			//Play right soundfile from value of pixel
			for (int i = 1; i < 15; i++) {
				int newi = i + 1;
				if (i == npix) {
					Mix_PlayMusic(sound[newi], 0);
					SDL_Delay(temp);
					holder = i;
				}
			}

			//If value is 16, don't play a sound and make a 3sec long delay.
			if (npix == 16) {
				std::cout << std::endl << "-----" << std::endl << std::endl;
				SDL_Delay(3000);
			}
			counter++;
		}
	}

	SDL_FreeSurface(image);
	SDL_DestroyRenderer(renderer);
	SDL_DestroyTexture(texture);
	SDL_DestroyWindow(win);

	for (int i = 1; i < 16; i++) {
		Mix_FreeMusic(sound[i]);
	}

	Mix_Quit();
	SDL_Quit();
	return 0;
}
Пример #4
0
void Window::renderUI() {
    SDL_RenderCopy(renderer, textures[UI], NULL, &dstRects[UI]);
    SDL_RenderPresent(renderer);
}
Пример #5
0
void Graphics::flip() {
	SDL_RenderPresent(this->_renderer);
}
Пример #6
0
void Game::render()
{
	SDL_SetRenderDrawColor(_renderer, r, g, b, 0);
	SDL_RenderClear(_renderer);
	SDL_RenderPresent(_renderer);
}
Пример #7
0
int Application::exec()
{
  bool done = false;
  while (!done)
  {
    SDL_Event e;
    if (SDL_WaitEvent(&e))
    {
      switch (e.type)
      {
      case SDL_WINDOWEVENT:
        {
          Widget *w = widgetByWindowId(e.window.windowID);
          switch (e.window.event)
          {
          case SDL_WINDOWEVENT_SHOWN:
            std::cout << "Window " << e.window.windowID << " shown" << std::endl;
            break;
          case SDL_WINDOWEVENT_HIDDEN:
            std::cout << "Window " << e.window.windowID << " hidden" << std::endl;
            break;
          case SDL_WINDOWEVENT_EXPOSED:
            {
              needUpdateWithoutRedraw_ = w;
              break;
            }
          case SDL_WINDOWEVENT_MOVED:
            break;
          case SDL_WINDOWEVENT_RESIZED:
            {
              w->resize(e.window.data1, e.window.data2);
#if __APPLE__==1
              SDL_RenderPresent(w->renderer_); // hack for MacOS X
#endif
              break;
            }
          case SDL_WINDOWEVENT_MINIMIZED:
            std::cout << "Window " << e.window.windowID << " minimized" << std::endl;
            break;
          case SDL_WINDOWEVENT_MAXIMIZED:
            std::cout << "Window " << e.window.windowID << " maximized" << std::endl;
            break;
          case SDL_WINDOWEVENT_RESTORED:
            std::cout << "Window " << e.window.windowID << " restored" << std::endl;
            break;
          case SDL_WINDOWEVENT_ENTER:
            std::cout << "Mouse entered window " << e.window.windowID << std::endl;
            break;
          case SDL_WINDOWEVENT_LEAVE:
            std::cout << "Mouse left window " << e.window.windowID << std::endl;
            break;
          case SDL_WINDOWEVENT_FOCUS_GAINED:
            std::cout << "Window " << e.window.windowID << " gained keyboard focus" << std::endl;
            break;
          case SDL_WINDOWEVENT_FOCUS_LOST:
            std::cout << "Window " << e.window.windowID << " lost keyboard focus" << std::endl;
            break;
          case SDL_WINDOWEVENT_CLOSE:
            std::cout << "Window " << e.window.windowID << " closed" << std::endl;
            break;
          default:
            std::cout << "Window " << e.window.windowID << " got unknown event " << static_cast<int>(e.window.event) << std::endl;
            break;
          }
          break;
        }
      case SDL_KEYDOWN:
        {
          KeyEvent ke { static_cast<KeyEvent::Key>(e.key.keysym.sym), SDL_GetModState(), static_cast<bool>(e.key.repeat) };
          auto w = focusWidget();
          if (!w)
            w = widgetByWindowId(e.key.windowID);
          else if (w->ancestor() != widgetByWindowId(e.key.windowID))
          {
            std::cerr << "Unknown windowID " << e.key.windowID << std::endl;
            break;
          }
          while (w)
          {
            if (w->keyPressEvent(ke))
              break;
            w = w->parent();
          }
          break;
        }
      case SDL_KEYUP:
        {
          KeyEvent ke { static_cast<KeyEvent::Key>(e.key.keysym.sym), SDL_GetModState(), static_cast<bool>(e.key.repeat) };
          auto w = focusWidget();
          if (!w)
            w = widgetByWindowId(e.key.windowID);
          else if (w->ancestor() != widgetByWindowId(e.key.windowID))
          {
            std::cerr << "Unknown windowID " << e.key.windowID << std::endl;
            break;
          }

          while (w)
          {
            if (w->keyReleaseEvent(ke))
              break;
            w = w->parent();
          }
          break;
        }
      case SDL_TEXTINPUT:
        {
          TextInputEvent tie { toUtf16(e.text.text) };
          auto w = focusWidget();
          if (!w)
            w = widgetByWindowId(e.key.windowID);
          else if (w->ancestor() != widgetByWindowId(e.key.windowID))
          {
            std::cerr << "Unknown windowID " << e.key.windowID << std::endl;
            break;
          }

          while (w)
          {
            if (w->textInputEvent(tie))
              break;
            w = w->parent();
          }
          break;
        }
      case SDL_QUIT:
        done = true;
        break;
      }
    }
    const auto isEmpty = (SDL_PeepEvents(&e, 1, SDL_PEEKEVENT, SDL_FIRSTEVENT, SDL_LASTEVENT) == 0);
    if (isEmpty || SDL_GetTicks() > lastUpdate_ + 1000 / 60)
    {
      auto x = SDL_GetTicks();
      for (auto w: widgetList_)
        if (w->needRepaint())
        {
          PaintEvent e;
          w->internalPaint(e);
        }
      if (needUpdateWithoutRedraw_)
      {
        needUpdateWithoutRedraw_->updateWithoutRedraw();
        needUpdateWithoutRedraw_ = nullptr;
      }
      lastUpdate_ = SDL_GetTicks();
      std::cout << "Update time: " << lastUpdate_ - x << " " <<
        (lastUpdate_ - x > 0 ? 1000 / (lastUpdate_ - x) : 999)<< "fps" << std::endl;
    }
    for (auto obj: deletingObjects_)
      delete obj;
    deletingObjects_.clear();
  }
  return 0;
}
Пример #8
0
std::vector<Landmark> createLandmarks()
{
    std::vector<Landmark> lmks;

    SDL_Color color_red = {.r = 255, .g = 0, .b = 0, .a = 255 };
    SDL_Color color_green = {.r = 0, .g = 255, .b = 0, .a = 255 };
    SDL_Color color_blue = {.r = 0, .g = 0, .b = 255, .a = 255 };
    SDL_Color color_purple = {.r = 255, .g = 0, .b = 255, .a = 255 };

    lmks.push_back( Landmark(300.,300.,color_red));
    lmks.push_back( Landmark(124.,478.,color_blue));
//    lmks.push_back( Landmark(214.,312.,color_purple));

    return lmks;
}


int main() {

    if (SDL_Init(SDL_INIT_VIDEO) != 0){
        std::cout << "SDL_Init Error: " << SDL_GetError() << std::endl;
        return 1;
    }


    SDL_Window *win = SDL_CreateWindow("Robot Program", XSTART, YSTART, WWIDTH, WHEIGHT, SDL_WINDOW_SHOWN);
    if (win == nullptr){
        std::cout << "SDL_CreateWindow Error: " << SDL_GetError() << std::endl;
        SDL_Quit();
        return 1;
    }

    SDL_Renderer *ren = SDL_CreateRenderer(win, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
    if (ren == nullptr){
        SDL_DestroyWindow(win);
        std::cout << "SDL_CreateRenderer Error: " << SDL_GetError() << std::endl;
        SDL_Quit();
        return 1;
    }


    std::vector<Landmark> landmarks = createLandmarks();

    SDL_Color orange {.r=255, .g=165, .b=0, .a=255};
    SDL_Color red {.r=255, .g=0, .b=0, .a=255};
    SDL_Color gray {.r=128, .g=128, .b=128, .a=255};

    Robot robby(200, 200, 0.0, 20, red);

    // Kalman filter stuff
    int n = 3; // number of state variables (x,y,phi)
    int m = 3; // number of measurements (landmark x, y, index)

    // Best guess of initial states
    Eigen::VectorXf x0(n); //[x, y, phi]
    x0 << 200., 200., 0.0;
    Robot robby_estimate(x0(0), x0(1), x0(2), 18, gray);

    // control vector:
    Eigen::VectorXf control(2); //  [v, omega]


    Eigen::MatrixXf A(n, n); // System dynamics matrix
    Eigen::MatrixXf C(m, n); // Output matrix
    Eigen::MatrixXf Q(n, n); // Process noise covariance
    Eigen::MatrixXf R(m, m); // Measurement noise covariance
    Eigen::MatrixXf covariance(n, n); // Estimate error covariance


    // Reasonable covariance matrices
    covariance <<    5., .0, .0,
                     .0, 5., .0,
                    .0, .0,  5.;

    R <<    1.0, 0., 0.,
            0., 1.0, 0.,
            0., 0.,  0.1;

    Q <<    0.1, 0.1, 0.1,
            0.1, 0.1, 0.1,
            0.1, 0.1, 0.1;

    KalmanFilter kf(DT, A, C, Q, R, covariance);

    float t0 = 0.0;
    kf.init(t0, x0);

    // rendering loop
    int i = 0;
    while (i < 10000) {

        //First clear the renderer
        SDL_RenderClear(ren);

        //Draw the texture
        SDL_SetRenderDrawColor(ren, 200, 200, 255, 255);

        SDL_RenderClear(ren); // fill the scene with white

        SDL_SetRenderDrawColor(ren, 0, 0, 0, 255);

        // update renderer
        SDL_RenderPresent(ren);

        // move robot
        SDL_PumpEvents();
        const Uint8 *key_pressed = SDL_GetKeyboardState(NULL);
        robby.move(key_pressed, control);

        // measure landmark positions
        auto observed_landmarks = robby.measureLandmarks(landmarks);

        // get robot state
        Eigen::VectorXf state = robby.get_state();

        // Localize via Landmarks
        kf.localization_landmarks(observed_landmarks, landmarks, control);

        // get estimated state (x,y,phi) as estimated by the EKF
        auto x_hat = kf.get_state();

        printf("True x,y,phi: %f, %f, %f\n", state(0), state(1),state(2));
        printf("Estimated x,y,phi: %f, %f, %f\n", x_hat(0), x_hat(1), x_hat(2));

        // move robby estimate to new pose as calculated by kalman filter:
        robby_estimate.setPose(x_hat(0), x_hat(1), x_hat(2));
        robby_estimate.render(ren);

        // render robot
        robby.render(ren);

        // render landmarks
        for (auto lm = landmarks.begin(); lm != landmarks.end(); ++lm)
        {
            SDL_SetRenderDrawColor(ren, lm->id.r, lm->id.g, lm->id.b, lm->id.a);
            lm->render(ren);
        }

        SDL_SetRenderDrawColor(ren, gray.r, gray.g, gray.b, gray.a);

        // render sampled probability distribution
        kf.renderSamples(ren);

        SDL_RenderPresent(ren);

        //Take a quick break after all that hard work
        SDL_Delay(30);


        if (key_pressed[SDL_SCANCODE_RETURN])
        {
            printf("Exiting Program!\n");
            break;
        }

        i+=1;
    }

    SDL_DestroyRenderer(ren);
    SDL_DestroyWindow(win);
    SDL_Quit();


    return EXIT_SUCCESS;
}
Пример #9
0
int main(){


    TempSettings gamesettings;

    gamesettings.mapw = 10;
    gamesettings.maph = 6;
    gamesettings.mapx = 0;
    gamesettings.mapy = 0;
    gamesettings.mapmidx = gamesettings.mapw/2.0;
    gamesettings.mapmidy = gamesettings.maph/2.0;
    gamesettings.window_width = 1300;
    gamesettings.window_height = 800;

    // initialize window, renderer, textures
    if (SDL_Init(SDL_INIT_EVERYTHING) != 0){
        std::cerr << "SDL_Init error: " << SDL_GetError() << std::endl;
        return 1;
    }

    if (TTF_Init() != 0){
        std::cerr << "TTF_Init error: " << SDL_GetError() << std::endl;
        SDL_Quit();
        return 1;
    }

    SDL_Window* window = SDL_CreateWindow("deathblade_floating", 0, 0, gamesettings.window_width, gamesettings.window_height, SDL_WINDOW_SHOWN);
    if (window == nullptr){
        std::cerr << "SDL_CreateWindow error: " << SDL_GetError() << std::endl;
        SDL_Quit();
        return 1;
    }

    SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
    if (renderer == nullptr){
        std::cerr << "SDL_CreateRenderer error: " << SDL_GetError() << std::endl;
        SDL_DestroyWindow(window);
        SDL_Quit();
        return 1;
    }
    std::string resource_path = getResourcePath("");
    std::string charfile = resource_path + "initialcharacter.png";
    std::string bgfile = resource_path + "initialbackgroundtile.png";
    std::string starfile = resource_path + "star.png";
    std::string wallfile = resource_path + "wall.png";
    SDL_Texture* character_texture = IMG_LoadTexture(renderer, charfile.c_str());
    SDL_Texture* bgtile_texture = IMG_LoadTexture(renderer, bgfile.c_str());
    SDL_Texture* star_texture = IMG_LoadTexture(renderer, starfile.c_str());
    SDL_Texture* wall_texture = IMG_LoadTexture(renderer,wallfile.c_str());
    if (character_texture == nullptr || bgtile_texture == nullptr || star_texture == nullptr || wall_texture == nullptr){
            std::cerr << "IMG_LoadTexture error: " << SDL_GetError() << std::endl;
            SDL_DestroyTexture(character_texture);
            SDL_DestroyTexture(bgtile_texture);
            SDL_DestroyRenderer(renderer);
            SDL_DestroyWindow(window);
            SDL_Quit();
            return 1;
    }

    std::string fontfile = resource_path + "sample.ttf";
    TTF_Font* font = TTF_OpenFont(fontfile.c_str(), 15);
    if (font == NULL){
        std::cerr << "TTF_OpenFont error: " << SDL_GetError() << std::endl;
    }


	CameraControl camera(&gamesettings);
    ObjectController objects;
    DeveloperConsoleClass console(&gamesettings);
    console.add_controller(&console);
    console.add_controller(&camera);

    const double tilew = 0.5;
    const double tileh = 0.5;
    double mousex = gamesettings.mapmidx;
    double mousey = gamesettings.mapmidy;
    int mousepx = gamesettings.window_width/2;
    int mousepy = gamesettings.window_height/2;

    double wallthickness = 0.1;
    TextureWall bottomwall, topwall, leftwall, rightwall;
    bottomwall.x = gamesettings.mapw/2;
    bottomwall.y = gamesettings.maph+wallthickness/2;
    bottomwall.setTexture(wall_texture,gamesettings.mapw,wallthickness);
    objects.add_object(&bottomwall);

    topwall.x = gamesettings.mapw/2;
    topwall.y = -wallthickness/2;
    topwall.setTexture(wall_texture,gamesettings.mapw,wallthickness);
    objects.add_object(&topwall);

    leftwall.x = -wallthickness/2;
    leftwall.y = gamesettings.maph/2;
    leftwall.setTexture(wall_texture,wallthickness,gamesettings.maph);
    objects.add_object(&leftwall);

    rightwall.x = gamesettings.mapw + wallthickness/2;
    rightwall.y = gamesettings.maph/2;
    rightwall.setTexture(wall_texture,wallthickness,gamesettings.maph);
    objects.add_object(&rightwall);

    Player human;
    human.x = 5; human.y = 5;
    human.dx = -0.025; human.dy = -0.03;
    human.setTexture(character_texture, 0.05, 0.05);
    objects.add_object(&human);

    // map x [0, 10]
    // map y [0,  6]
    // star width 0.256
    std::vector<vec2d> star_positions = {
        vec2d(6,4),
        vec2d(3,4.1),
        vec2d(9,0.2),
        vec2d(1,0.4),
        vec2d(2,2.5),
        vec2d(3,2.5),
        vec2d(9,4.9),
        vec2d(0.2,5.1),
        vec2d(4.1,4.1)
    };
    std::vector<double> star_thetas = {
        0,
        45,
        15,
        60,
        85,
        4,
        50,
        66,
        31
    };

    std::vector<Star*> star_field;
    for(unsigned int i = 0; i < star_positions.size(); ++i){
        Star* newstar = new Star();

        newstar->x = star_positions[i].x;
        newstar->y = star_positions[i].y;
        newstar->setTexture(star_texture, 0.256, 0.256);

        if(i < star_thetas.size())
            newstar->rotate(star_thetas[i]*3.14159265359/180.0);


        star_field.push_back(newstar);
        objects.add_object(star_field[i]);

    }

    bool rightmouse_down = false;

    SDL_Event event;	
    bool quitnow = false;
    Uint32 fps_lastframe = SDL_GetTicks();
    while(!quitnow){
		
        int zoomdirection = 0;

        while(SDL_PollEvent(&event)){

            if (console.is_active()){
                if (event.type == SDL_KEYDOWN){
                    switch(event.key.keysym.sym){
                    case SDLK_BACKQUOTE:
                        console.toggle();
                        break;
                    case SDLK_BACKSPACE:
                        console.backspace();
                        break;
                    case SDLK_RETURN:
                    case SDLK_RETURN2:
                        console.enter();
                        break;
                    case SDLK_UP:
                        console.goback_inhistory();
                        break;
                    case SDLK_DOWN:
                        console.goforward_inhistory();
                        break;
                    default:
                        break;
                    }
                    console.render_current_command(renderer);

                }
                else if (event.type == SDL_TEXTINPUT && event.text.text[0] != '`'){
                    console.addinput(event.text.text);
                    console.render_current_command(renderer);
                }
                else if (event.type == SDL_MOUSEBUTTONDOWN){
                    if (event.button.button == SDL_BUTTON_LEFT){
                        if(!console.mouse_grab(true, event.button.x, event.button.y))
                            camera.mousecontrol_on();
                    }
                    //if (event.button.button == SDL_BUTTON_RIGHT)

                }
                else if (event.type == SDL_MOUSEBUTTONUP){
                    if (event.button.button == SDL_BUTTON_LEFT){
                        console.mouse_grab(false, -1,-1);
                        camera.mousecontrol_off();
                    }
                }
                else if (event.type == SDL_MOUSEMOTION){
                    mousepx = event.motion.x;
                    mousepy = event.motion.y;
                    console.handle_mouse(event.motion.xrel, event.motion.yrel);

                    if (camera.mouse_controlling()){
                        camera.mousecontrol_move(mousepx, mousepy, event.motion.xrel, event.motion.yrel,SDL_GetModState()==KMOD_LCTRL);
                    }
                    else{
                        mousex = camera.xfrompixel(event.motion.x, event.motion.y, db::Player);
                        mousey = camera.yfrompixel(event.motion.x, event.motion.y, db::Player);
                    }
                }
                else if (event.type == SDL_MOUSEWHEEL){
                    if(!console.scroll(event.wheel.y, mousepx, mousepy))
                        zoomdirection += event.wheel.y;
                }
                else if (event.type == SDL_QUIT){
                    quitnow = true;
                }

                continue;
            }

            // if console is not up
            if (event.type == SDL_KEYDOWN){
                switch(event.key.keysym.sym){
                case SDLK_ESCAPE:
                        quitnow = true;
                        break;
                case SDLK_BACKQUOTE:
                    console.toggle();
                    break;
                case SDLK_t:
                    if (!camera.is_tracking())
                        camera.track_object(&(human.x), &(human.y));
                    else
                        camera.stop_tracking();
                    break;
                case SDLK_w:
                case SDLK_UP:
                    camera.pan_updown(-1);
                    break;
                case SDLK_a:
                case SDLK_LEFT:
                    camera.pan_leftright(-1);
                    break;
                case SDLK_s:
                case SDLK_DOWN:
                    camera.pan_updown(1);
                    break;
                case SDLK_d:
                case SDLK_RIGHT:
                    camera.pan_leftright(1);
                    break;
                default:
                    break;
                }
            }
            else if (event.type == SDL_KEYUP){
                switch(event.key.keysym.sym){
                case SDLK_w:
                case SDLK_UP:
                    camera.pan_updown(0);
                    break;
                case SDLK_a:
                case SDLK_LEFT:
                    camera.pan_leftright(0);
                    break;
                case SDLK_s:
                case SDLK_DOWN:
                    camera.pan_updown(0);
                    break;
                case SDLK_d:
                case SDLK_RIGHT:
                    camera.pan_leftright(0);
                    break;
                default:
                    break;
                }
            }
            else if (event.type == SDL_MOUSEBUTTONDOWN){
                if (event.button.button == SDL_BUTTON_LEFT){
                    camera.mousecontrol_on();
                }
                else if (event.button.button == SDL_BUTTON_RIGHT){
                    rightmouse_down = true;
                    human.bound.xclick = camera.xfrompixel(event.button.x,event.button.y,db::Player);
                    human.bound.yclick = camera.yfrompixel(event.button.x,event.button.y,db::Player);
                    human.bound.xdrag = 0;
                    human.bound.ydrag = 0;
                    human.bound.enabled = true;
                }
            }
            else if (event.type == SDL_MOUSEBUTTONUP){
                if (event.button.button == SDL_BUTTON_LEFT){
                    camera.mousecontrol_off();
                }
                else if (event.button.button == SDL_BUTTON_RIGHT){
                    rightmouse_down = false;
                }
            }
            else if (event.type == SDL_MOUSEWHEEL){
                zoomdirection += event.wheel.y;
            }
            else if (event.type == SDL_MOUSEMOTION){
                mousepx = event.motion.x;
                mousepy = event.motion.y;

                if (camera.mouse_controlling()){
                    camera.mousecontrol_move(mousepx, mousepy, event.motion.xrel, event.motion.yrel,SDL_GetModState()==KMOD_LCTRL);
                }
                else{
                    mousex = camera.xfrompixel(event.motion.x, event.motion.y, db::Player);
                    mousey = camera.yfrompixel(event.motion.x, event.motion.y, db::Player);
                    if(mousepx <= 1) camera.pan_leftright(-1);
                    else if (mousepx >= (int)gamesettings.window_width-1) camera.pan_leftright(1);
                    else if (mousepx - event.motion.xrel <= 1) camera.pan_leftright(0);
                    else if (mousepx - event.motion.xrel >= (int)gamesettings.window_width-1) camera.pan_leftright(0);
                    if(mousepy <= 1) camera.pan_updown(-1);
                    else if (mousepy >= (int)gamesettings.window_height-1) camera.pan_updown(1);
                    else if (mousepy - event.motion.yrel <= 1) camera.pan_updown(0);
                    else if (mousepy - event.motion.yrel >= (int)gamesettings.window_height-1) camera.pan_updown(0);

                    if(rightmouse_down){
                        human.bound.xdrag += event.motion.xrel;
                        human.bound.ydrag += event.motion.yrel;
                    }
                }

            }
            else if (event.type == SDL_QUIT){
                quitnow = true;
            }
	
        }


        objects.step_time();

        SDL_SetRenderDrawColor(renderer, 0,0,0,255);
        SDL_RenderClear(renderer);

        camera.adjust_zoom(zoomdirection, mousex, mousey);
		
        for (double x = gamesettings.mapx+tilew/2; x < gamesettings.mapx+gamesettings.mapw+tilew/2; x += tilew){
            for (double y = gamesettings.mapy+tileh/2; y < gamesettings.mapy+gamesettings.maph+tileh/2; y += tileh){
                SDL_Rect dst = camera.calculate_display_destination(x,y,tilew,tileh,db::Floor);
                SDL_RenderCopyEx(renderer, bgtile_texture, NULL, &dst, -camera.camyaw*180.0/3.14156033, NULL, SDL_FLIP_NONE);
            }
        }

        objects.drawon(renderer, &camera);
        if(console.is_active()) console.drawon(renderer);
        human.bound.drawon(renderer, &camera);


        Uint32 fps_newframe = SDL_GetTicks();
        if((fps_newframe-fps_lastframe) < SCREEN_TICKS_PER_FRAME){
            SDL_Delay(SCREEN_TICKS_PER_FRAME - (fps_newframe-fps_lastframe));
        }
        draw_fps(renderer, font, 1.0/(fps_newframe/1000.0 - fps_lastframe/1000.0));
        fps_lastframe = fps_newframe;

        SDL_RenderPresent(renderer);
	}
    SDL_DestroyTexture(character_texture);
	SDL_DestroyTexture(bgtile_texture);
    SDL_DestroyRenderer(renderer);
    SDL_DestroyWindow(window);
    SDL_Quit();

    for(unsigned int i = 0; i < star_field.size(); ++i)
        delete star_field[i];

    return 0;
}
Пример #10
0
void render(Scene& scene, Texture& screen, int renderno = 0, int outof = 1) {
  char titlebuf[200];
  if (settings.show_preview) {
    sprintf(titlebuf, "%s", TITLE);
    SDL_SetWindowTitle(window, titlebuf);
  }

  Vect4 color;
  bool exitflag = 0;

  int v; //Return value from threads
  RenderQueue rq(&scene, &screen);
  SDL_Thread** threads = new SDL_Thread* [settings.nworkers];

  rq.pushRow(0);
  for (int i = 0; i < settings.nworkers; i++) threads[i] = SDL_CreateThread(&renderThread, NULL, &rq);
  for (int i = 0; i < settings.nworkers; i++) SDL_WaitThread(threads[i], &v);

  for (int r = 1; r < screen.height(); r++) {
    if (settings.show_preview) {
      SDL_Event event;
      while (SDL_PollEvent(&event))
	if (event.type == SDL_QUIT || (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_ESCAPE)) exit(0);
	else if (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_RETURN) exitflag = 1;
      if (exitflag) break;
    }

    rq.pushRow(r);
    
    for (int i = 0; i < settings.nworkers; i++) threads[i] = SDL_CreateThread(&renderThread, NULL, &rq);

    if (settings.show_preview) {
      drawRow(screen, r - 1);
      px->redraw();
      SDL_RenderPresent(px->getRenderer()); 
    }

    for (int i = 0; i < settings.nworkers; i++) SDL_WaitThread(threads[i], &v);

    if (outof > 1) sprintf(titlebuf, "%s [%d / %d, %d of %d]",TITLE, r + 1, screen.height(), renderno, outof);
    else sprintf(titlebuf, "%s [%d / %d]", TITLE, r + 1, screen.height());

    if (settings.show_preview)
      SDL_SetWindowTitle(window, titlebuf);
    else {
      printf("\r%s", titlebuf);
      fflush(0);
    }
  }

  if (settings.show_preview) {
    drawRow(screen, screen.height() - 1);
    px->redraw();
    SDL_RenderPresent(px->getRenderer()); 
  }
  else printf("\n");
  
  if (!settings.aa_enabled) {
    delete [] threads;
    return;
  }

  Texture dmap = screen.differenceMap();
  float d;
  for (int r = 1; r < screen.height() - 1; r++) {
    if (settings.show_preview) {
      SDL_Event event;
      while (SDL_PollEvent(&event))
	if (event.type == SDL_QUIT || (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_ESCAPE)) exit(0);
	else if (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_RETURN) exitflag = 1;
      if (exitflag) break;
    }
    
    for (int c = 1; c < screen.width() - 1; c++) {
      d = dot(dmap.getColor(r, c), Vect4(1, 1, 1, 0));
      if (d > settings.aa_threshold) rq.push(r, c);
    }

    for (int i = 0; i < settings.nworkers; i++) threads[i] = SDL_CreateThread(&renderThread_AA, NULL, &rq);

    if (settings.show_preview) {
      drawRow(screen, r - 1);
      px->redraw();
      SDL_RenderPresent(px->getRenderer());
    }

    for (int i = 0; i < settings.nworkers; i++) SDL_WaitThread(threads[i], &v);

    if (outof > 1) sprintf(titlebuf, "%s [AA: %d / %d, %d of %d]", TITLE, r + 2, screen.height(), renderno, outof);
    else sprintf(titlebuf, "%s [AA: %d / %d]",TITLE, r + 2, screen.height());

    if (settings.show_preview)
      SDL_SetWindowTitle(window, titlebuf);
    else {
      printf("\r%s", titlebuf);
      fflush(0);
    }
  }

  delete [] threads;

  if (settings.show_preview) {
    drawRow(screen, screen.height() - 2);
    px->redraw();
    SDL_RenderPresent(px->getRenderer());
    SDL_SetWindowTitle(window, TITLE);
  }
  else printf("\n");
}
Пример #11
0
int vid_thread (void* arg)
{
SDL_Event event;
static char *eventtypes[SDL_LASTEVENT];
static t_bool initialized = FALSE;

if (!initialized) {
    initialized = TRUE;
    eventtypes[SDL_QUIT] = "QUIT";          /**< User-requested quit */

    /* These application events have special meaning on iOS, see README-ios.txt for details */
    eventtypes[SDL_APP_TERMINATING] = "APP_TERMINATING";   /**< The application is being terminated by the OS
                                     Called on iOS in applicationWillTerminate()
                                     Called on Android in onDestroy()
                                */
    eventtypes[SDL_APP_LOWMEMORY] = "APP_LOWMEMORY";          /**< The application is low on memory, free memory if possible.
                                     Called on iOS in applicationDidReceiveMemoryWarning()
                                     Called on Android in onLowMemory()
                                */
    eventtypes[SDL_APP_WILLENTERBACKGROUND] = "APP_WILLENTERBACKGROUND"; /**< The application is about to enter the background
                                     Called on iOS in applicationWillResignActive()
                                     Called on Android in onPause()
                                */
    eventtypes[SDL_APP_DIDENTERBACKGROUND] = "APP_DIDENTERBACKGROUND"; /**< The application did enter the background and may not get CPU for some time
                                     Called on iOS in applicationDidEnterBackground()
                                     Called on Android in onPause()
                                */
    eventtypes[SDL_APP_WILLENTERFOREGROUND] = "APP_WILLENTERFOREGROUND"; /**< The application is about to enter the foreground
                                     Called on iOS in applicationWillEnterForeground()
                                     Called on Android in onResume()
                                */
    eventtypes[SDL_APP_DIDENTERFOREGROUND] = "APP_DIDENTERFOREGROUND"; /**< The application is now interactive
                                     Called on iOS in applicationDidBecomeActive()
                                     Called on Android in onResume()
                                */

    /* Window events */
    eventtypes[SDL_WINDOWEVENT] = "WINDOWEVENT"; /**< Window state change */
    eventtypes[SDL_SYSWMEVENT] = "SYSWMEVENT";             /**< System specific event */

    /* Keyboard events */
    eventtypes[SDL_KEYDOWN] = "KEYDOWN"; /**< Key pressed */
    eventtypes[SDL_KEYUP] = "KEYUP";                  /**< Key released */
    eventtypes[SDL_TEXTEDITING] = "TEXTEDITING";            /**< Keyboard text editing (composition) */
    eventtypes[SDL_TEXTINPUT] = "TEXTINPUT";              /**< Keyboard text input */

    /* Mouse events */
    eventtypes[SDL_MOUSEMOTION] = "MOUSEMOTION"; /**< Mouse moved */
    eventtypes[SDL_MOUSEBUTTONDOWN] = "MOUSEBUTTONDOWN";        /**< Mouse button pressed */
    eventtypes[SDL_MOUSEBUTTONUP] = "MOUSEBUTTONUP";          /**< Mouse button released */
    eventtypes[SDL_MOUSEWHEEL] = "MOUSEWHEEL";             /**< Mouse wheel motion */

    /* Joystick events */
    eventtypes[SDL_JOYAXISMOTION] = "JOYAXISMOTION"; /**< Joystick axis motion */
    eventtypes[SDL_JOYBALLMOTION] = "JOYBALLMOTION";          /**< Joystick trackball motion */
    eventtypes[SDL_JOYHATMOTION] = "JOYHATMOTION";           /**< Joystick hat position change */
    eventtypes[SDL_JOYBUTTONDOWN] = "JOYBUTTONDOWN";          /**< Joystick button pressed */
    eventtypes[SDL_JOYBUTTONUP] = "JOYBUTTONUP";            /**< Joystick button released */
    eventtypes[SDL_JOYDEVICEADDED] = "JOYDEVICEADDED";         /**< A new joystick has been inserted into the system */
    eventtypes[SDL_JOYDEVICEREMOVED] = "JOYDEVICEREMOVED";       /**< An opened joystick has been removed */

    /* Game controller events */
    eventtypes[SDL_CONTROLLERAXISMOTION] = "CONTROLLERAXISMOTION"; /**< Game controller axis motion */
    eventtypes[SDL_CONTROLLERBUTTONDOWN] = "CONTROLLERBUTTONDOWN";          /**< Game controller button pressed */
    eventtypes[SDL_CONTROLLERBUTTONUP] = "CONTROLLERBUTTONUP";            /**< Game controller button released */
    eventtypes[SDL_CONTROLLERDEVICEADDED] = "CONTROLLERDEVICEADDED";         /**< A new Game controller has been inserted into the system */
    eventtypes[SDL_CONTROLLERDEVICEREMOVED] = "CONTROLLERDEVICEREMOVED";       /**< An opened Game controller has been removed */
    eventtypes[SDL_CONTROLLERDEVICEREMAPPED] = "CONTROLLERDEVICEREMAPPED";      /**< The controller mapping was updated */

    /* Touch events */
    eventtypes[SDL_FINGERDOWN] = "FINGERDOWN";
    eventtypes[SDL_FINGERUP] = "FINGERUP";
    eventtypes[SDL_FINGERMOTION] = "FINGERMOTION";

    /* Gesture events */
    eventtypes[SDL_DOLLARGESTURE] = "DOLLARGESTURE";
    eventtypes[SDL_DOLLARRECORD] = "DOLLARRECORD";
    eventtypes[SDL_MULTIGESTURE] = "MULTIGESTURE";

    /* Clipboard events */
    eventtypes[SDL_CLIPBOARDUPDATE] = "CLIPBOARDUPDATE"; /**< The clipboard changed */

    /* Drag and drop events */
    eventtypes[SDL_DROPFILE] = "DROPFILE"; /**< The system requests a file open */

    /** Events ::SDL_USEREVENT through ::SDL_LASTEVENT are for your use,
     *  and should be allocated with SDL_RegisterEvents()
     */
    eventtypes[SDL_USEREVENT] = "USEREVENT";

    }

sim_debug (SIM_VID_DBG_VIDEO|SIM_VID_DBG_KEY|SIM_VID_DBG_MOUSE, vid_dev, "vid_thread() - Starting\n");

vid_mono_palette[0] = sim_end ? 0xFF000000 : 0x000000FF;
vid_mono_palette[1] = 0xFFFFFFFF;

memset (&vid_key_state, 0, sizeof(vid_key_state));

SDL_Init (SDL_INIT_VIDEO);

SDL_CreateWindowAndRenderer (vid_width, vid_height, SDL_WINDOW_SHOWN, &vid_window, &vid_renderer);

if ((vid_window == NULL) || (vid_renderer == NULL)) {
    sim_printf ("%s: Error Creating Video Window: %s\b", sim_dname(vid_dev), SDL_GetError());
    SDL_Quit ();
    return 0;
    }

SDL_SetRenderDrawColor (vid_renderer, 0, 0, 0, 255);
SDL_RenderClear (vid_renderer);
SDL_RenderPresent (vid_renderer);

vid_texture = SDL_CreateTexture (vid_renderer,
                                 SDL_PIXELFORMAT_ARGB8888,
                                 SDL_TEXTUREACCESS_STREAMING,
                                 vid_width, vid_height);
if (!vid_texture) {
    sim_printf ("%s: Error configuring Video environment: %s\b", sim_dname(vid_dev), SDL_GetError());
    SDL_DestroyRenderer(vid_renderer);
    vid_renderer = NULL;
    SDL_DestroyWindow(vid_window);
    vid_window = NULL;
    SDL_Quit ();
    return 0;
    }

SDL_StopTextInput ();

sim_debug (SIM_VID_DBG_VIDEO|SIM_VID_DBG_KEY|SIM_VID_DBG_MOUSE, vid_dev, "vid_thread() - Started\n");

while (vid_active) {
    if (SDL_WaitEvent (&event)) {
        switch (event.type) {

            case SDL_KEYDOWN:
            case SDL_KEYUP:
                vid_key ((SDL_KeyboardEvent*)&event);
                break;

            case SDL_MOUSEBUTTONDOWN:
            case SDL_MOUSEBUTTONUP:
                vid_mouse_button ((SDL_MouseButtonEvent*)&event);
                break;

            case SDL_MOUSEMOTION:
                vid_mouse_move ((SDL_MouseMotionEvent*)&event);
                break;

            case SDL_USEREVENT:
                /* There are 2 user events generated */
                /* EVENT_REDRAW to update the display */
                /* EVENT_CLOSE  to wake up this thread and let */
                /*              it notice vid_active has changed */
                if (event.user.code == EVENT_REDRAW)
                    vid_update ();
                break;

            default:
                sim_debug (SIM_VID_DBG_VIDEO|SIM_VID_DBG_KEY|SIM_VID_DBG_MOUSE, vid_dev, "vid_thread() - Ignored Event: Type: %s(%d)\n", eventtypes[event.type], event.type);
                break;
            }
        }
    }
SDL_DestroyTexture(vid_texture);
vid_texture = NULL;
SDL_DestroyRenderer(vid_renderer);
vid_renderer = NULL;
SDL_DestroyWindow(vid_window);
vid_window = NULL;
SDL_Quit ();
sim_debug (SIM_VID_DBG_VIDEO|SIM_VID_DBG_KEY|SIM_VID_DBG_MOUSE, vid_dev, "vid_thread() - Exiting\n");
return 0;
}
Пример #12
0
int LancerJeu(gpointer *pData)
{
    /* Cette fonction va appeler les fonctions d'initialisations de la SDL et lancer le jeu ou l'éditeur */

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

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

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

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

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

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

    int erreur=0;	//Code d'erreur

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    return 0;
}
Пример #13
0
void gfxengine_t::flip()
{
	if(!screen_surface)
		return;

	// Init dirtyrect table flipping, if necessary.
	switch(_pages)
	{
	  case -1:
		if(!_doublebuf)
			frontpage = backpage = 0;
		else if(frontpage == backpage)
		{
			frontpage = 0;
			backpage = 1;
		}
		break;
	  case 0:
		frontpage = backpage = 0;
		invalidate();
		break;
	  case 1:
		frontpage = backpage = 0;
		break;
	  case 2:
	  case 3:
		if(frontpage == backpage)
		{
			frontpage = 0;
			backpage = 1;
		}
		break;
	}

	// Process the dirtyrects.
	int i;
	for(i = 0; i < dirtyrects[backpage]; ++i)
	{
		if(dirtywtable[backpage][i])
		{
			if(!dirtywtable[backpage][i]->visible())
				continue;
			SDL_Rect dr = dirtytable[backpage][i];
			dirtywtable[backpage][i]->phys_refresh(&dr);
		}
		else
			refresh_rect(&dirtytable[backpage][i]);
	}

	// Perform the actual flip or update
	if(_shadow)
	{
		for(i = 0; i < dirtyrects[backpage]; ++i)
			SDL_BlitSurface(softbuf,
					&dirtytable[backpage][i],
					screen_surface,
					&dirtytable[backpage][i]);
	}
	if(_doublebuf)
	{
		dirtyrects[backpage] = 0;
		if(_pages == -1)
		{
			backpage = !backpage;
			frontpage = !frontpage;
		}
		else if(_pages > 1)
		{
			backpage = (backpage + 1) % _pages;
			frontpage = (frontpage + 1) % _pages;
		}
		SDL_UpdateTexture(sdlTexture, NULL, screen_surface->pixels, screen_surface->pitch);
		SDL_RenderClear(renderer);
		SDL_RenderCopy(renderer, sdlTexture, NULL, NULL);
		SDL_RenderPresent(renderer);
//		SDL_UpdateWindowSurface(myscreen);
//		SDL_Flip(screen_surface);
//		SDL_RenderPresent(SDL_CreateSoftwareRenderer(screen_surface));
	}
	else
	{
		SDL_UpdateTexture(sdlTexture, NULL, screen_surface->pixels, screen_surface->pitch);
		SDL_RenderClear(renderer);
		SDL_RenderCopy(renderer, sdlTexture, NULL, NULL);
		SDL_RenderPresent(renderer);
//		SDL_UpdateWindowSurface(myscreen);
//		SDL_UpdateRects(screen_surface, dirtyrects[0], dirtytable[0]);
//		SDL_RenderPresent(SDL_CreateSoftwareRenderer(screen_surface));
		dirtyrects[0] = 0;
	}
}
Пример #14
0
void SDLApp::OnFrame(float dt)
{
    SDL_SetRenderDrawColor(renderer_, 255, 0, 0, 255);
    SDL_RenderClear(renderer_);
    SDL_RenderPresent(renderer_);
}
void CSDL_setup::end()
{
	SDL_RenderPresent(renderer);
}
Пример #16
0
/* In order to avoid rendering race conditions and the ensuing segmentation
 * faults, this should only be called when it would normally be and not
 * specifically to force screen refreshes.  To this end, and to avoid
 * threading complications it takes care of special cases internally.  */
static void render(void *vbitmap, int console_width, int console_height, char_t *console_buffer, char_t *prev_console_buffer) {
	char_t *prev_console_buffer_ptr = prev_console_buffer;
	if ( TCOD_ctx.renderer == TCOD_RENDERER_SDL ) {
		int console_width_p = console_width*TCOD_ctx.font_width;
		int console_height_p = console_height*TCOD_ctx.font_height;

		/* Make a bitmap of exact rendering size and correct format. */
		if (scale_screen == NULL) {
			int bpp;
			Uint32 rmask, gmask, bmask, amask;
			if (SDL_PixelFormatEnumToMasks(SDL_GetWindowPixelFormat(window), &bpp, &rmask, &gmask, &bmask, &amask) == SDL_FALSE) {
				TCOD_fatal("SDL : failed to create scaling surface : indeterminate window pixel format");
				return;
			}
			scale_screen=SDL_CreateRGBSurface(SDL_SWSURFACE,console_width_p,console_height_p,bpp,rmask,gmask,bmask,amask);
			if (scale_screen == NULL) {
				TCOD_fatal("SDL : failed to create scaling surface");
				return;
			}
		} else if (clear_screen) {
			clear_screen=false;
			SDL_FillRect(scale_screen,0,0);
			/* Implicitly do complete console redraw, not just tracked changes. */
			prev_console_buffer_ptr = NULL;
		}

		TCOD_sys_console_to_bitmap(scale_screen, console_width, console_height, console_buffer, prev_console_buffer_ptr);

		/* Scale the rendered bitmap to the screen, preserving aspect ratio, and blit it.
		 * This data is also used for console coordinate resolution.. */
		if (scale_data.last_scale_factor != scale_factor || scale_data.last_scale_xc != scale_xc || scale_data.last_scale_yc != scale_yc ||
				scale_data.last_fullscreen != TCOD_ctx.fullscreen || scale_data.force_recalc) {
			/* Preserve old value of input variables, to enable recalculation if they change. */
			scale_data.last_scale_factor = scale_factor;
			scale_data.last_scale_xc = scale_xc;
			scale_data.last_scale_yc = scale_yc;
			scale_data.last_fullscreen = TCOD_ctx.fullscreen;
			scale_data.force_recalc = 0;

			if (scale_data.last_fullscreen) {
				scale_data.surface_width = TCOD_ctx.actual_fullscreen_width;
				scale_data.surface_height = TCOD_ctx.actual_fullscreen_height;
			} else {
				scale_data.surface_width = console_width_p;
				scale_data.surface_height = console_height_p;
			}
			scale_data.min_scale_factor = MAX((float)console_width_p/scale_data.surface_width, (float)console_height_p/scale_data.surface_height);
			if (scale_data.min_scale_factor > 1.0f)
				scale_data.min_scale_factor = 1.0f;
			/*printf("min_scale_factor %0.3f = MAX(%d/%d, %d/%d)", scale_data.min_scale_factor, console_width_p, scale_data.surface_width, console_height_p, scale_data.surface_height);*/

			scale_data.dst_height_width_ratio = (float)scale_data.surface_height/scale_data.surface_width;
			scale_data.src_proportionate_width = (int)(console_width_p / scale_factor);
			scale_data.src_proportionate_height = (int)((console_width_p * scale_data.dst_height_width_ratio) / scale_factor);

			/* Work out how much of the console to copy. */
			scale_data.src_x0 = (scale_xc * console_width_p) - (0.5f * scale_data.src_proportionate_width);
			if (scale_data.src_x0 + scale_data.src_proportionate_width > console_width_p)
				scale_data.src_x0 = console_width_p - scale_data.src_proportionate_width;
			if (scale_data.src_x0 < 0)
				scale_data.src_x0 = 0;
			scale_data.src_copy_width = scale_data.src_proportionate_width;
			if (scale_data.src_x0 + scale_data.src_copy_width > console_width_p)
				scale_data.src_copy_width = console_width_p - scale_data.src_x0;

			scale_data.src_y0 = (scale_yc * console_height_p) - (0.5f * scale_data.src_proportionate_height);
			if (scale_data.src_y0 + scale_data.src_proportionate_height > console_height_p)
				scale_data.src_y0 = console_height_p - scale_data.src_proportionate_height;
			if (scale_data.src_y0 < 0)
				scale_data.src_y0 = 0;
			scale_data.src_copy_height = scale_data.src_proportionate_height;
			if (scale_data.src_y0 + scale_data.src_copy_height > console_height_p)
				scale_data.src_copy_height = console_height_p - scale_data.src_y0;

			scale_data.dst_display_width = (scale_data.src_copy_width * scale_data.surface_width) / scale_data.src_proportionate_width;
			scale_data.dst_display_height = (scale_data.src_copy_height * scale_data.surface_height) / scale_data.src_proportionate_height;
			scale_data.dst_offset_x = (scale_data.surface_width - scale_data.dst_display_width)/2;
			scale_data.dst_offset_y = (scale_data.surface_height - scale_data.dst_display_height)/2;
		}

		SDL_RenderClear(renderer);
		actual_rendering();
		SDL_RenderPresent(renderer);
	}
#ifndef NO_OPENGL
	else {
		TCOD_opengl_render(oldFade, ascii_updated, console_buffer, prev_console_buffer);
		TCOD_opengl_swap();
	}  
#endif
	oldFade=(int)TCOD_console_get_fade();
	if ( any_ascii_updated ) {
		memset(ascii_updated,0,sizeof(bool)*TCOD_ctx.max_font_chars);
		any_ascii_updated=false;
	}
}
Пример #17
0
void CSDL_Setup::End()
{
	SDL_RenderPresent(renderer);
}
Пример #18
0
void
loop()
{
    int i;
    SDL_Event event;
        /* Check for events */
        while (SDL_PollEvent(&event)) {
            SDLTest_CommonEvent(state, &event, &done);

            if (event.type == SDL_WINDOWEVENT) {
                if (event.window.event == SDL_WINDOWEVENT_RESIZED) {
                    SDL_Window *window = SDL_GetWindowFromID(event.window.windowID);
                    if (window) {
                        SDL_Log("Window %d resized to %dx%d\n",
                            event.window.windowID,
                            event.window.data1,
                            event.window.data2);
                    }
                }
                if (event.window.event == SDL_WINDOWEVENT_MOVED) {
                    SDL_Window *window = SDL_GetWindowFromID(event.window.windowID);
                    if (window) {
                        SDL_Log("Window %d moved to %d,%d (display %s)\n",
                            event.window.windowID,
                            event.window.data1,
                            event.window.data2,
                            SDL_GetDisplayName(SDL_GetWindowDisplayIndex(window)));
                    }
                }
            }
            if (event.type == SDL_KEYUP) {
                SDL_bool updateCursor = SDL_FALSE;

                if (event.key.keysym.sym == SDLK_LEFT) {
                    --system_cursor;
                    if (system_cursor < 0) {
                        system_cursor = SDL_NUM_SYSTEM_CURSORS - 1;
                    }
                    updateCursor = SDL_TRUE;
                } else if (event.key.keysym.sym == SDLK_RIGHT) {
                    ++system_cursor;
                    if (system_cursor >= SDL_NUM_SYSTEM_CURSORS) {
                        system_cursor = 0;
                    }
                    updateCursor = SDL_TRUE;
                }
                if (updateCursor) {
                    SDL_Log("Changing cursor to \"%s\"", cursorNames[system_cursor]);
                    SDL_FreeCursor(cursor);
                    cursor = SDL_CreateSystemCursor((SDL_SystemCursor)system_cursor);
                    SDL_SetCursor(cursor);
                }
            }
        }

        for (i = 0; i < state->num_windows; ++i) {
            SDL_Renderer *renderer = state->renderers[i];
            SDL_RenderClear(renderer);
            SDL_RenderPresent(renderer);
        }
#ifdef __EMSCRIPTEN__
    if (done) {
        emscripten_cancel_main_loop();
    }
#endif
}
Пример #19
0
void ViewerSdl::EndDraw() {
	SDL_RenderPresent(this->renderer);
}
Пример #20
0
Файл: main.c Проект: Zix777/C
int main(int argc, char** argv)
{
    SDL_Init(SDL_INIT_VIDEO);
    SDL_Window* window = SDL_CreateWindow("SDL Practice4",
                                          SDL_WINDOWPOS_UNDEFINED,SDL_WINDOWPOS_UNDEFINED,
                                          800,700,
                                          SDL_WINDOW_SHOWN);
    SDL_Renderer* rend = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);  //创建renderer
    SDL_RenderClear(rend);  //清空rend

    SDL_Surface* image_surface = SDL_LoadBMP("x.bmp");
    SDL_Texture* image_texture = SDL_CreateTextureFromSurface(rend, image_surface); //将surface转换为texture并显示在rend上

    SDL_Event event;
    SDL_Rect pos;
    pos.x=0;
    pos.y=0;
    pos.w=image_surface->w;
    pos.h=image_surface->h;

    SDL_Rect image_pos;
    image_pos.x = 0;
    image_pos.y = 0;
    image_pos.w = image_surface->w;
    image_pos.h = image_surface->h;
    bool quit=false;
    bool pressed = false;
    while(!quit)
    {
        while(SDL_PollEvent(&event))
        {
            if(event.type == SDL_QUIT)
                quit = true;
            if(event.type == SDL_MOUSEBUTTONDOWN)
            {
                if(event.button.button == SDL_BUTTON_LEFT)
                {
                    image_pos.x = event.motion.x - pos.x;
                    image_pos.y = event.motion.y - pos.y;
                    if(image_pos.x>=0 && image_pos.x<=image_pos.w && image_pos.y>0 && image_pos.y<image_pos.h)
                        pressed = true;
                }
            }
            if(pressed && event.type == SDL_MOUSEMOTION)
            {
                pos.x = event.motion.x - image_pos.x;
                pos.y = event.motion.y - image_pos.y;
            }
            if(event.type == SDL_MOUSEBUTTONUP)
            {
                if(pressed && event.button.button == SDL_BUTTON_LEFT)
                {
                    pressed = false;
                }
            }
        }
        SDL_RenderClear(rend);  //清空rend
        SDL_RenderCopy(rend, image_texture, NULL, &pos);    //将texture显示到rend上
        SDL_Delay(5);
        SDL_RenderPresent(rend);    //显示rend
    }

    SDL_DestroyWindow(window);
    SDL_Quit();
    return 0;
}
Пример #21
0
int main(int argc, char *argv[])
{
    // initialize SDL
    if (SDL_Init(SDL_INIT_VIDEO)) {
        printf("SDL_Init: %s\n", SDL_GetError());
        return -1;
    }

    // create the window
    SDL_Window *window = SDL_CreateWindow(
                            "Template",
                            SDL_WINDOWPOS_UNDEFINED,
                            SDL_WINDOWPOS_UNDEFINED,
                            640, 480,
                            0);
    if (!window) {
        printf("SDL_CreateWindow: %s\n", SDL_GetError());
        return -1;
    }

    // create a renderer for the window
    SDL_Renderer *renderer = SDL_CreateRenderer(window, -1, 0);
    if (!renderer) {
        printf("SDL_CreateRenderer: %s\n", SDL_GetError());
        return -1;
    }

    // load the mario image
    SDL_Surface *marioSurface = SDL_LoadBMP("mario.bmp");
    if (!marioSurface) {
        printf("SDL_LoadBMP: %s\n", SDL_GetError());
        return -1;
    }

    // create a duplicate of the mario surface with the same pixel format as the window
    SDL_Surface *newMarioSurface = SDL_ConvertSurfaceFormat(marioSurface, SDL_GetWindowPixelFormat(window), 0);

    // no longer need to hang on to the original image
    SDL_FreeSurface(marioSurface);

    // set (255,0,255) as the transparent color
    if (SDL_SetColorKey(newMarioSurface, SDL_TRUE, SDL_MapRGB(newMarioSurface->format, 255, 0, 255))) {
        printf("SDL_SetColorKey: %s\n", SDL_GetError());
        return -1;
    }

    // create a renderable texture from the image
    SDL_Texture *marioTexture = SDL_CreateTextureFromSurface(renderer, newMarioSurface);
    if (!marioTexture) {
        printf("SDL_CreateTextureFromSurface: %s\n", SDL_GetError());
        return -1;
    }

    // no longer need to hang on to the converted image
    SDL_FreeSurface(newMarioSurface);

    typedef enum MarioState {
        MARIO_JUMPING,
        MARIO_WALKING,
        MARIO_IDLE
    } MarioState;

    // current state of mario
    MarioState marioState = MARIO_IDLE;

    // position of mario in the world
    float marioXPosition = 200;
    float marioYPosition = 200;
    float marioMovementSpeed = 50; // pixels per second
    
    // stores whether or not the mario state should be flipped
    SDL_RendererFlip marioFlipping = SDL_FLIP_NONE;

    // will use the time between state switches to know what frame of animation to use
    Uint32 timeOfLastStateSwitch = SDL_GetTicks();

    Uint32 timeOfLastFrame = SDL_GetTicks();

    // begin main loop
    int isGameRunning = 1;
    while (isGameRunning)
    {
        // count the number of milliseconds since the last frame
        Uint32 timeOfThisFrame = SDL_GetTicks();
        Uint32 frameDeltaTime = timeOfThisFrame - timeOfLastFrame;
        timeOfLastFrame = timeOfThisFrame;

        // handle all the events
        SDL_Event e;
        while (SDL_PollEvent(&e))
        {
            // if the window is being requested to close, then stop the game.
            if (e.type == SDL_QUIT) {
                isGameRunning = 0;
            }
        }

        // store the old state to know if the state has changed
        MarioState oldMarioState = marioState;

        // get a lookup table to know if keys are pressed
        const Uint8 *keyboardState = SDL_GetKeyboardState(NULL);

        // handle left movement key
        if (keyboardState[SDL_SCANCODE_LEFT]) {
            marioXPosition -= marioMovementSpeed * (frameDeltaTime / 1000.0f);
            marioFlipping = SDL_FLIP_NONE;
            
            // switch to walking state
            marioState = MARIO_WALKING;
        }
        
        // handle right movement key
        if (keyboardState[SDL_SCANCODE_RIGHT]) {
            marioXPosition += marioMovementSpeed * (frameDeltaTime / 1000.0f);
            marioFlipping = SDL_FLIP_HORIZONTAL;
            
            // switch to walking state
            marioState = MARIO_WALKING;
        }

        // if nothing's being pressed, then we're in the idle state
        if (!keyboardState[SDL_SCANCODE_LEFT] && !keyboardState[SDL_SCANCODE_RIGHT]) {
            marioState = MARIO_IDLE;
        }

        // update the time of the last state switch
        if (marioState != oldMarioState) {
            timeOfLastStateSwitch = SDL_GetTicks();
        }

        // render everything
        if (SDL_RenderClear(renderer)) {
            printf("SDL_RenderClear: %s\n", SDL_GetError());
            return -1;
        }

        // decide frame of animation to use
        int currentSpriteFrame;
        if (marioState == MARIO_IDLE) {
            currentSpriteFrame = 2;
        } else if (marioState == MARIO_WALKING) {
            // get the index of the frame we're currently at (12 fps animation speed)
            Uint32 millisecondsPerFrame = 1000/12;
            Uint32 framesPassedSinceStateSwitch = (SDL_GetTicks() - timeOfLastStateSwitch) / millisecondsPerFrame;
            // if we're on an odd frame, use the standing animation.
            // if we're on an even frame, use the walking animation.
            if (framesPassedSinceStateSwitch & 1) {
                currentSpriteFrame = 2;
            } else {
                currentSpriteFrame = 1;
            }
        } else {
            currentSpriteFrame = 0;
        }

        // set up the rendering for mario
        // note: each frame in the animation has size 16x32 in the sprite sheet
        
        // the source rectangle defines which region of the sprite sheet to use
        SDL_Rect renderSourceRect; 
        renderSourceRect.x = currentSpriteFrame * 16;
        renderSourceRect.y = 0;
        renderSourceRect.w = 16;
        renderSourceRect.h = 32;

        // the destination rectangle defines which region of the screen to draw it to
        SDL_Rect renderDestinationRect;
        renderDestinationRect.x = marioXPosition;
        renderDestinationRect.y = marioYPosition - 32 * 2; // sprite is scaled 2x
        renderDestinationRect.w = 16 * 2; // sprite is scaled 2x
        renderDestinationRect.h = 32 * 2; // sprite is scaled 2x

        // finally, do the real rendering
        if (SDL_RenderCopyEx(
                renderer,
                marioTexture,
                &renderSourceRect,
                &renderDestinationRect,
                0.0, // no rotation
                NULL, // no center of rotation
                marioFlipping)) {
            printf("SDL_RenderCopy: %s\n", SDL_GetError());
            return -1;
        }

        // flip the display
        SDL_RenderPresent(renderer);

        // throttle the frame rate to 60fps
        SDL_Delay(1000/60);
    }

    // throw everything away
    SDL_Quit();

    return 0;
}
Пример #22
0
int main(void)
{
//    int good = 0;
//    int numeroMap = 0;
//    do{
//        printf("Quelle map?\n");
//        printf("1 - Original\n");
//        printf("2 - Hard\n");
//        printf("3 - Lol\n");
//        printf("4 - Rez De chaussez Aile Sud Telecom Nancy\n");
//        scanf("%d", &numeroMap);
//        switch(numeroMap){
//            case 1:
//                loadMap("../projec/map/original.map");
//                good = 1;
//                break;
//            case 2:
//                loadMap("../projec/map/hard.map");
//                good = 1;
//                break;

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

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

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

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

    SDL_Texture *menuTexture = SDL_CreateTextureFromSurface(renderer, menu);

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

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

    SDL_DestroyRenderer(renderer);
    SDL_DestroyWindow(window);

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

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

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

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

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



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

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

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

    TTF_Font *police = NULL;

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



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

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

    //NEED gerer erreurs

    loadTextures(renderer);

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

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

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



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

        SDL_RenderPresent(renderer);
        //Event handling

        SDL_PollEvent(&event);
        switch(event.type){
            case SDL_KEYDOWN:
                switch(event.key.keysym.scancode){
                    case SDL_SCANCODE_UP:
                        setPacmanDirection(NORTH);
                        if(konami[0]){
                            if(konami[1]){
                                for(j = 0 ; j < 10 ; j++){
                                    konami[j] = 0;
                                }
//                                printf("Déjà deux\n");
                            }else{
                                konami[1] = 1;
                            }
                        }else{
                            konami[0] = 1;
                        }
                        break;
                    case SDL_SCANCODE_DOWN:
                        setPacmanDirection(SOUTH);
                        break;
                    case SDL_SCANCODE_RIGHT:
                        setPacmanDirection(EAST);
                        break;
                    case SDL_SCANCODE_LEFT:
                        setPacmanDirection(WEST);
                        break;
                    default:
                        break;
                }
                break;
        }
        terminate = update(clyde, blinky, inky, pinky);
        if(terminate){
            if(pacman->life > 0 ){
                pacman->life--;
                terminate = 0;
                pacman->x = initialX;
                pacman->y = initialY;
            }
        }
        if(event.window.event == SDL_WINDOWEVENT_CLOSE){
            terminate = 1;
        }
        SDL_Delay(1000 / FPS);
        SDL_DestroyTexture(scoreTN);
        SDL_FreeSurface(scoreN);
    }
    printf("Score final : %d\n", pacman->point);
    Mix_FreeMusic(music);
    Mix_CloseAudio();
    freeTextures();
    SDL_DestroyRenderer(renderer);
    SDL_DestroyWindow(window);
    SDL_Quit();
    SDL_DestroyTexture(scoreT);
    freePacman();
    freeGhost(clyde);
    freeGhost(blinky);
    freeGhost(inky);
    freeGhost(pinky);
    freeMap();
    TTF_CloseFont(police);
    TTF_Quit();
    return EXIT_SUCCESS;
}
Пример #23
0
int
main(int argc, char **argv)
{
    if(argc < 2)
        return 1;

    char dvd_filename[MAX_PATH];
    char dvm_filename[MAX_PATH];
    snprintf(dvd_filename, MAX_PATH-1, "%s.dvd", argv[1]);
    snprintf(dvm_filename, MAX_PATH-1, "%s.dvm", argv[1]);

    int err = 0;
    struct dvd_file *file = dvd_file_open(dvd_filename, &err);
    if (!file) {
        fprintf(stderr, "dvd_file_open failed\n");
        return -1;
    }

    union dvd_entry entry;
    while (dvd_file_has_next(file)) {
        if ((err = dvd_file_get_next(file, &entry))) {
            fprintf(stderr, "dvd_file_get_next failed\n");
            return -2;
        }

        switch (entry.type) {
            case DVD_ENTRY_TYPE_MISC:
                printf("misc entry: size %d\n", entry.misc.size);
                break;
            case DVD_ENTRY_TYPE_UNKN:
            default:
                break;
        }

        dvd_entry_done(&entry);
    }

    dvd_file_close(file);

    return 0;

    unsigned int width, height;
    void *pixmap = dvm_file_get_pixmap(dvm_filename, &width, &height, NULL);

    if (!pixmap) {
        fprintf(stderr, "failed getting pixmap\n");
        return -1;
    }

    SDL_Init(SDL_INIT_VIDEO);
    SDL_Window *w = SDL_CreateWindow("DVF tool",
                                     SDL_WINDOWPOS_UNDEFINED,
                                     SDL_WINDOWPOS_UNDEFINED,
                                     -1,
                                     -1,
                                     SDL_WINDOW_FULLSCREEN_DESKTOP);
    SDL_Renderer *renderer = SDL_CreateRenderer(w, -1, SDL_RENDERER_ACCELERATED);

    SDL_Surface *surface = SDL_CreateRGBSurface(0,
                           width,
                           height,
                           16, 0, 0, 0, 0);
    surface->pixels = pixmap;

    SDL_Texture *tex = SDL_CreateTextureFromSurface(renderer,
                                                    surface);
    SDL_FreeSurface(surface);

    SDL_Rect rect;
    rect.x = 0;
    rect.y = 0;
    rect.w = width;
    rect.h = height;

    int move = 0, mouse_x, mouse_y, diff_x = 0, diff_y = 0;
    int offset_x, offset_y;
    SDL_Event event;
    while (1) {
        while(SDL_PollEvent(&event)) {
            if (event.type == SDL_QUIT) {
                goto exit;
            }
            switch (event.type) {
            case SDL_MOUSEBUTTONDOWN:
                move = 1;
                mouse_x = event.button.x;
                mouse_y = event.button.y;
                break;
            case SDL_MOUSEBUTTONUP:
                move = 0;
                diff_x = 0;
                diff_y = 0;
                break;
            case SDL_MOUSEMOTION:
                if (move) {
                    rect.x -= diff_x;
                    rect.y -= diff_y;
                    diff_x = event.motion.x - mouse_x;
                    diff_y = event.motion.y - mouse_y;
                    rect.x += diff_x;
                    rect.y += diff_y;
                }
                break;
            }
        }

        SDL_RenderClear(renderer);
        SDL_RenderCopy(renderer, tex, NULL, &rect);
        SDL_RenderPresent(renderer);
        SDL_Delay(10);
    }

exit:
    SDL_DestroyTexture(tex);

    SDL_DestroyRenderer(renderer);
    SDL_DestroyWindow(w);
    SDL_Quit();

    return 0;
}
Пример #24
0
void screen_update(Screen* s, CPU* c)
{
	int i;
	int mem = 0;
	SDL_Rect fr;
	fr.w = char_w;
	fr.h = char_h;
	SDL_Rect sr;
	sr.x = 0;
	sr.y = 0;
	sr.w = char_w;
	sr.h = char_h;
	
	SDL_SetRenderDrawColor(s->renderer, 0, 0, 0, 0);
	SDL_RenderClear(s->renderer);	

	int x = 0;
	int y = 0;
	for(i = 0; i < 80*30; i++) {
		u8 ch = c->mem[VIDEO_START+(mem++)];
		u8 col = c->mem[VIDEO_START+(mem++)];
		if(col == 0) {
			x++;
			if(x >= 80) {
				x = 0;
				y++;
			}
			continue;
		}		

		u8 ch_x = (ch % font_w) * char_w;
		u8 ch_y = (ch / font_h) * char_h;

		fr.x = ch_x;
		fr.y = ch_y;
		
		sr.x = x * char_w;
		sr.y = y * char_h;
		
		u8 bg = (col & 0xF0) >> 4;
		if(bg != 0) {
			SDL_SetRenderDrawColor(s->renderer, colors[bg].r, colors[bg].g, colors[bg].b, 255);
			SDL_RenderFillRect(s->renderer, &sr);
		}
		u8 fg = (col & 0xF);
		SDL_SetTextureColorMod(s->font, colors[fg].r, colors[fg].g, colors[fg].b);
		SDL_RenderCopy(s->renderer, s->font, &fr, &sr);

		x++;
		if(x >= 80) {
			x = 0;
			y++;
		}
	}
	
	u8 fg = c->mem[SCREEN_COLOR] & 0x0F;
	if(c->mem[SCREEN_BLINK_INTERVAL] == 0){
		
	}else if(c->mem[SCREEN_BLINK_INTERVAL] == 1) {
		SDL_SetRenderDrawColor(s->renderer, colors[fg].r, colors[fg].g, colors[fg].b, 255);
		SDL_RenderFillRect(s->renderer,&(SDL_Rect){c->mem[SCREEN_CURSOR_X]*char_w, c->mem[SCREEN_CURSOR_Y]*char_h+(char_h-2), char_w, 2});
	}else if(blinky >= c->mem[SCREEN_BLINK_INTERVAL]) {
		blinky++;
		if(blinky >= c->mem[SCREEN_BLINK_INTERVAL]*2) blinky = 0;
	}else {
		SDL_SetRenderDrawColor(s->renderer, colors[fg].r, colors[fg].g, colors[fg].b, 255);
		SDL_RenderFillRect(s->renderer,&(SDL_Rect){c->mem[SCREEN_CURSOR_X]*char_w, c->mem[SCREEN_CURSOR_Y]*char_h+(char_h-2), char_w, 2});
		blinky++;
	}

	SDL_RenderPresent(s->renderer);
}
Пример #25
0
int main(int argc, char **argv){
	SDL_Window		*window = 0;
	SDL_Renderer	*renderer = 0;
	SDL_Texture		*texture = 0;
	SDL_Event		event;
	bool			run = true;

	mouse mymouse;
	timer timer(60);
	unit myunit(300,300);


	if(SDL_Init(SDL_INIT_EVERYTHING) != 0 ){
		std::cout<< "SDL init error: " << SDL_GetError() << std::endl;
		return 1;
	}
	
	
	if(SDL_CreateWindowAndRenderer(KSCREEN_WIDTH,KSCREEN_HEIGHT,0,&window,&renderer) !=0 ){
		std::cout<< "Create window and renderer error: " << SDL_GetError() << std::endl;
		return 1;
	}
	
	texture = util_create_texture_from_bitmap("background.bmp",renderer);
	
	while(run){
		
		timer.start();
	
		while(SDL_PollEvent(&event)){
			switch(event.type){
				case SDL_QUIT:
					run = false;
					break;
				case SDL_KEYDOWN:
					switch(event.key.keysym.sym){
						case SDLK_ESCAPE:
							run = false;
							break;
						case SDLK_DOWN:
							printf("left pressed\n");
							break;
					
					}
					break;
			}
		}
		
		myunit.run(renderer,&event,mymouse);      //doesnt flicker when here
		mymouse.run(renderer,&event);
		//SDL_RenderDrawLine(renderer,0,0,640,480); // test line..
		
		SDL_RenderPresent(renderer);
		util_render_texture_to_renderer(0,0,texture,renderer); //using background as a clear..

		timer.end();
		timer.delay();
	}
	
	SDL_DestroyTexture(texture);
	SDL_DestroyRenderer(renderer);
	SDL_DestroyWindow(window);
	SDL_Quit();
	
	std::cout<<"quit success" << std::endl;
	
	return 0;
}
Пример #26
0
void NextFrame()
{
    SDL_RenderPresent(renderer);
    FrameDelay();
}
Пример #27
0
void Init_2DGraphics( Dict *config )
{
  int flags = 0;
  int tmp = 0;
  
  if( !config )
  {
    Log( FATAL, "No config to initialize graphics system" );
    exit( -1 );
  }
  
  Log( INFO, "Initializing Graphics" );
  
  Vec2_Clear( _resolution );
  Vec2_Clear( _render_resolution );
  Vec4_Clear( _background_color_v );
  
  /* set config stuff */
  Str_As_Vec2( Find_In_Dict( config, "resolution" ), _resolution );
  Str_As_Vec2( Find_In_Dict( config, "render_resolution" ), _render_resolution );
  Str_As_UInt( Find_In_Dict( config, "bpp" ), &_bpp );
  Str_As_UInt( Find_In_Dict( config, "frame_delay" ), &_frame_delay );
  Str_As_Vec4( Find_In_Dict( config, "background_color" ), _background_color_v );
  Str_As_Int( Find_In_Dict( config, "fullscreen" ), &tmp );
  if( tmp )
    flags |= SDL_WINDOW_FULLSCREEN;
  Str_As_Int( Find_In_Dict( config, "borderless" ), &tmp );
  if( tmp )
    flags |= SDL_WINDOW_BORDERLESS;
  
  /* set up the graphics */
  _main_window = SDL_CreateWindow( "Game", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, _resolution[ 0 ], _resolution[ 1 ], flags );
  if( !_main_window )
  {
    Log( FATAL, "Failed to Create the Main Window" );
    exit( -1 );
  }
  
  _renderer = SDL_CreateRenderer( _main_window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_TARGETTEXTURE );
  if( !_renderer )
  {
    Log( FATAL, "Failed to Create the Renderer" );
    exit( -1 );
  }
  
  SDL_SetRenderDrawColor( _renderer, 0, 0, 0, 255 );
  SDL_RenderClear( _renderer );
  SDL_RenderPresent( _renderer );
  SDL_SetHint( SDL_HINT_RENDER_SCALE_QUALITY, "linear" );
  SDL_RenderSetLogicalSize( _renderer, _render_resolution[ 0 ], _render_resolution[ 1 ] );
  
  SDL_PixelFormatEnumToMasks( SDL_PIXELFORMAT_RGBA8888, ( int* )&_bpp, &_rmask, &_gmask, &_bmask, &_amask );
  
  _surface = SDL_CreateRGBSurface( 0, _render_resolution[ 0 ], _render_resolution[ 1 ], _bpp, _rmask, _gmask, _bmask, _amask );
  if( !_surface )
  {
    Log( FATAL, "Failed to Create the Screen Surface" );
    exit( -1 );
  }
  
  _texture = SDL_CreateTexture( _renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_STREAMING, _render_resolution[ 0 ], _render_resolution[ 1 ] );
  if( !_texture )
  {
    Log( FATAL, "Failed to Create the Screen Texture due to: %s", SDL_GetError() );
    exit( -1 );
  }
  
  _background_color = SDL_MapRGB( _surface->format, _background_color_v[ 0 ], _background_color_v[ 1 ], _background_color_v[ 2 ] );

  /* init camera */
  /* init mouse  */
  
  Log( INFO, "Graphics Initialized" );
}
Пример #28
0
void Game::Draw() {
    SDL_RenderClear(m_pRenderer);

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

        m_StartGameMenu.backGroundMenu.Draw(m_pRenderer);

        for (int iter = 0; iter < 5; iter++)
            m_StartGameMenu.m_buttonSet[iter].Draw(m_pRenderer);

        break;

    case STARTGAME:

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

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

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

    case GAMEOVER:

        texture.Draw(m_pRenderer);
        m_Play.Draw(m_pRenderer);
        m_Bet.Draw(m_pRenderer);
        m_WIN.Draw(m_pRenderer);
        m_Credits.Draw(m_pRenderer);
        m_Menu.Draw(m_pRenderer);
        level.Draw(m_pRenderer);
        txt.Draw(m_pRenderer);
        credit.Draw(m_pRenderer);
        profit.Draw(m_pRenderer);
        break;

    case VIEW_CARDS:

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

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

    }

    SDL_RenderPresent(m_pRenderer);
}/*end of Draw*/
Пример #29
0
void
MoveSprites(SDL_WindowID window, SDL_TextureID sprite)
{
    int i, n;
    int window_w, window_h;
    SDL_Rect temp;
    SDL_Rect *position, *velocity;

    SDL_SelectRenderer(window);

    /* Query the sizes */
    SDL_GetWindowSize(window, &window_w, &window_h);

    /* Cycle the color and alpha, if desired */
    if (cycle_color) {
        current_color += cycle_direction;
        if (current_color < 0) {
            current_color = 0;
            cycle_direction = -cycle_direction;
        }
        if (current_color > 255) {
            current_color = 255;
            cycle_direction = -cycle_direction;
        }
        SDL_SetTextureColorMod(sprite, 255, (Uint8) current_color,
                               (Uint8) current_color);
    }
    if (cycle_alpha) {
        current_alpha += cycle_direction;
        if (current_alpha < 0) {
            current_alpha = 0;
            cycle_direction = -cycle_direction;
        }
        if (current_alpha > 255) {
            current_alpha = 255;
            cycle_direction = -cycle_direction;
        }
        SDL_SetTextureAlphaMod(sprite, (Uint8) current_alpha);
    }

    /* Draw a gray background */
    SDL_SetRenderDrawColor(0xA0, 0xA0, 0xA0, 0xFF);
    SDL_RenderRect(NULL);

    /* Test points */
    SDL_SetRenderDrawColor(0xFF, 0x00, 0x00, 0xFF);
    SDL_RenderPoint(0, 0);
    SDL_RenderPoint(window_w-1, 0);
    SDL_RenderPoint(0, window_h-1);
    SDL_RenderPoint(window_w-1, window_h-1);

    /* Test horizontal and vertical lines */
    SDL_SetRenderDrawColor(0x00, 0xFF, 0x00, 0xFF);
    SDL_RenderLine(1, 0, window_w-2, 0);
    SDL_RenderLine(1, window_h-1, window_w-2, window_h-1);
    SDL_RenderLine(0, 1, 0, window_h-2);
    SDL_RenderLine(window_w-1, 1, window_w-1, window_h-2);

    /* Test fill and copy */
    SDL_SetRenderDrawColor(0xFF, 0xFF, 0xFF, 0xFF);
    temp.x = 1;
    temp.y = 1;
    temp.w = sprite_w;
    temp.h = sprite_h;
    SDL_RenderRect(&temp);
    SDL_RenderCopy(sprite, NULL, &temp);
    temp.x = window_w-sprite_w-1;
    temp.y = 1;
    temp.w = sprite_w;
    temp.h = sprite_h;
    SDL_RenderRect(&temp);
    SDL_RenderCopy(sprite, NULL, &temp);
    temp.x = 1;
    temp.y = window_h-sprite_h-1;
    temp.w = sprite_w;
    temp.h = sprite_h;
    SDL_RenderRect(&temp);
    SDL_RenderCopy(sprite, NULL, &temp);
    temp.x = window_w-sprite_w-1;
    temp.y = window_h-sprite_h-1;
    temp.w = sprite_w;
    temp.h = sprite_h;
    SDL_RenderRect(&temp);
    SDL_RenderCopy(sprite, NULL, &temp);

    /* Test diagonal lines */
    SDL_SetRenderDrawColor(0x00, 0xFF, 0x00, 0xFF);
    SDL_RenderLine(sprite_w, sprite_h,
                   window_w-sprite_w-2, window_h-sprite_h-2);
    SDL_RenderLine(window_w-sprite_w-2, sprite_h,
                   sprite_w, window_h-sprite_h-2);

    /* Move the sprite, bounce at the wall, and draw */
    n = 0;
    for (i = 0; i < num_sprites; ++i) {
        position = &positions[i];
        velocity = &velocities[i];
        position->x += velocity->x;
        if ((position->x < 0) || (position->x >= (window_w - sprite_w))) {
            velocity->x = -velocity->x;
            position->x += velocity->x;
        }
        position->y += velocity->y;
        if ((position->y < 0) || (position->y >= (window_h - sprite_h))) {
            velocity->y = -velocity->y;
            position->y += velocity->y;
        }

        /* Blit the sprite onto the screen */
        SDL_RenderCopy(sprite, NULL, position);
    }

    /* Update the screen! */
    SDL_RenderPresent();
}
int main(int argc, char *argv[])
{

#ifdef _WIN32

	/*Initialise SDL needed for desktop*/
	if (SDL_Init(SDL_INIT_VIDEO) < 0) //Check SDL initialisation
	{
		//Failed initialisation
		SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Failed to initialise SDL");
		return -1;
	}

#endif

	/*Initialise SDL_ttf*/
	if (TTF_Init() < 0) /*Check SDL_ttf initialisation*/
	{
		/*Failed initialisation*/
		SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Failed to initialise SDL_ttf");
		return -1;
	}

	/*Initialise SDL_mixer*/
	Mix_Init(MIX_INIT_OGG);
	if (Mix_OpenAudio(44100, MIX_DEFAULT_FORMAT, 2, 2048) < 0)
	{
		/*Failed initialisation*/
		SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Failed to initialise SDL_Mixer");
		return -1;
	}

	/*Initialize PNG loading*/
	int imgFlags = IMG_INIT_PNG;
	if (!(IMG_Init(imgFlags) & imgFlags))
	{
		/*Failed initialisation*/
		SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Failed to initialise SDL_image");
		return -1;
	}

	/*Time Check*/
	unsigned int lastTime = SDL_GetTicks();

	SDL_Window* window;
	SDL_Renderer* renderer;
	int winWidth;
	int winHeight;

#ifdef __ANDROID__

	if(SDL_CreateWindowAndRenderer(0, 0, 0, &window, &renderer) < 0)
		exit(2);

	SDL_GetWindowSize(window, &winWidth, &winHeight);

#elif _WIN32

	/*Create Window*/
	int winPosX = 100;
	int winPosY = 100;
	winWidth = 640;
	winHeight = 480;
	window = SDL_CreateWindow("MGPDemoAudio",  /*The first parameter is the window title*/
		winPosX, winPosY,
		winWidth, winHeight,
		SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL);

	/*Create Renderer from the window*/
	renderer = SDL_CreateRenderer(window, -1, 0);

#endif

	/*setup state manager*/
	JAM_StateManager * stateManager = new JAM_StateManager();
	/*set the initial state*/
	stateManager->addState(new Game(stateManager, renderer, winWidth, winHeight));

	/*Start Game Loop*/
	bool go = true;
	while (go)
	{
		/*Time Check*/
		unsigned int current = SDL_GetTicks();
		float deltaTime = (float)(current - lastTime) / 1000.0f;
		lastTime = current;

		/*handle the current state inputs*/
		go = stateManager->input();

		/*update the current state*/
		stateManager->update(deltaTime);

		/*set draw colour to white*/
		SDL_SetRenderDrawColor(renderer, 0xFF, 0xFF, 0xFF, 0xFF);

		/*Clear the entire screen to the set colour*/
		SDL_RenderClear(renderer);

		/*draw the states*/
		stateManager->draw();

		/*display renderer*/
		SDL_RenderPresent(renderer);

		/*Time Limiter*/
		if (deltaTime < (1.0f / 50.0f))
		{
			SDL_Delay((unsigned int)(((1.0f / 50.0f) - deltaTime)*1000.0f));
		}
	}
	/*destroy data*/
	delete stateManager;
	SDL_DestroyWindow(window);
	SDL_Quit();
	exit(0);
	return 0;
}