Beispiel #1
0
void			aff_map(char **map)
{
    extern t_sdl	t;

    var_init();
    sdl_init();
    pos_init_joueur();
    pos_init_monstre();
    while (t.continuer)
    {
        if (map[(t.joueur.y / 34) + 1][t.joueur.x / 34] != 'w' && map[(t.joueur.y / 34) + 1][t.joueur.x / 34] != 's')
        {
            t.joueur.y += 34;
            SDL_Delay(30);
        }
        else
            sdl_event();
        sdl_aff();
        sdl_monstre();
        SDL_Flip(t.fenetre);
        if (map[t.joueur.y / 34][t.joueur.x / 34] == 'o')
        {
            t.flag = 2;
            t.continuer = 0;
        }
    }
    sdl_end();
}
Beispiel #2
0
int
bina_init(bina_window_t* window)
{
    /* Init SDL. */
    if (sdl_init(SDL_INIT_VIDEO) != 0) {
        fprintf(stderr, "sdl: unable to initialize: %s\n", sdl_get_error());
        return BINA_LIB_ERROR;
    }

    /* Be verbose in logs. */
    sdl_log_set_all_priority(SDL_LOG_PRIORITY_VERBOSE);

#ifdef HAVE_STDIO_H
    /* Set up our own custom log function without userdata. */
    sdl_log_set_output_function(log_custom, NULL);
#endif

    if (window) {
        m.window = sdl_create_window(window->title, SDL_WINDOWPOS_CENTERED,
                                     SDL_WINDOWPOS_CENTERED,
                                     window->width, window->height,
                                     SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN);

        if (!m.window) {
            sdl_log_error(SDL_LOG_CATEGORY_APPLICATION,
                          "sdl: unable to create window: %s", sdl_get_error());
            return BINA_LIB_ERROR;
        }
    }

    return renderer_init(m.window);
}
Beispiel #3
0
int video_init()
{
	if(video_windowed_default) // Screen defaults as windowed
	{
		if(video_resolution_windowed_default_scale != 0) // Calculate window size based on scale
		{
			if(video_rotation_default & rotated_90) // rotated 90 or -90 degrees, so switch width and height for resolution as seen fit	
			{
				video_resolution_width = video_height * video_resolution_windowed_default_scale;
				video_resolution_height = video_width * video_resolution_windowed_default_scale;
			}
			else // normally rotated, or rotated 180 degrees
			{
				video_resolution_width = video_width * video_resolution_windowed_default_scale;
				video_resolution_height = video_height * video_resolution_windowed_default_scale;
			}
		}
		else
		{
			video_resolution_width = video_resolution_windowed_default_width;
			video_resolution_height = video_resolution_windowed_default_height;
		}
	}
	else
	{
			video_resolution_width = video_resolution_fullscreen_default_width;
			video_resolution_height = video_resolution_fullscreen_default_height;
	}

	video_rotation = video_rotation_default;
	video_windowed = video_windowed_default;
	video_exact_resize = video_exact_resize_default;

	return (sdl_init() || gl_init(video_resolution_width, video_resolution_height));
}
Beispiel #4
0
bool video_ok::init()
{
  sdl_init();
  opengl_init();
  load_texture();
  if (!id)
    return false;
  return true;
}
int main(int argc, char** argv)
{
  SDL_Event event;

  int keypress = 0;
    
  // Init random number generator
  srand(clock());

  // Init everything
  sdl_init("OpenGL example");
  opengl_init();
  audioplayer_init();
  
  // Init internal data
  init_sin_table();
  init_textures();
  
  // Load audioplayer tune
  audioplayer_loadtune(&simpletune);
  audioplayer_play();
  
  // Loop until the end
  while(!keypress && audioplayer_isplaying()) 
  {
    // Lock SDL surface if needed
    if(SDL_MUSTLOCK(screen)) 
      if(SDL_LockSurface(screen) < 0)
	exit(EXIT_FAILURE);
  
    // Draw the plasma
    draw_cube(screen, audioplayer_getpos());

    // Unlock the SDL surface if needed
    if(SDL_MUSTLOCK(screen))
      SDL_UnlockSurface(screen);
  
    // Update screen
    SDL_GL_SwapBuffers();
      
    // Handle SDL events
    while(SDL_PollEvent(&event)) 
    {      
      switch (event.type) 
      {
	case SDL_QUIT:
	case SDL_KEYDOWN:
	  keypress = 1;
	  break;
      }
    }
  }
  
  // Exit gracefully
  SDL_Quit();
  return EXIT_SUCCESS;
}
Beispiel #6
0
Cell* fbfs_mmap(Cell* arg) {
  sdl_init(0);
  Cell* fbtest = alloc_num_bytes(0);
  fbtest->ar.addr = sdl_get_fb();
  fbtest->dr.size = sdl_get_fbsize();
  //printf("fbtest->addr: %p\n",fbtest->addr);
  //printf("fbtest->size: %lx\n",fbtest->size);

  return fbtest;
}
Beispiel #7
0
int main(int argc, char** argv)
{
    int ret = EXIT_SUCCESS;

    /* Initialize param struct to zero */
    memset(&P, 0, sizeof(P));

    if (!parse_input(argc, argv)) {
        return EXIT_FAILURE;
    }

    /* Initialize parameters corresponding to YUV-format */
    setup_param();

    if (!sdl_init()) {
        return EXIT_FAILURE;
    }

    if (!open_input()) {
        return EXIT_FAILURE;
    }

    if (!allocate_memory()) {
        ret = EXIT_FAILURE;
        goto cleanup;
    }

    /* Lets do some basic consistency check on input */
    check_input();

    /* send event to display first frame */
    event.type = SDL_KEYDOWN;
    event.key.keysym.sym = SDLK_RIGHT;
    SDL_PushEvent(&event);

    /* while true */
    event_loop();

cleanup:
    destroy_message_queue();
    SDL_FreeYUVOverlay(my_overlay);
    free(P.raw);
    free(P.y_data);
    free(P.cb_data);
    free(P.cr_data);
    if (fd) {
        fclose(fd);
    }
    if (P.fd2) {
        fclose(P.fd2);
    }

    return ret;
}
Beispiel #8
0
int main(int argc, char **argv)
{
	xmp_context ctx;
	struct xmp_module_info mi;
	struct xmp_frame_info fi;
	int i;

	ctx = xmp_create_context();

	if (sdl_init(ctx) < 0) {
		fprintf(stderr, "%s: can't initialize sound\n", argv[0]);
		exit(1);
	}

	for (i = 1; i < argc; i++) {
		if (xmp_load_module(ctx, argv[i]) < 0) {
			fprintf(stderr, "%s: error loading %s\n", argv[0],
				argv[i]);
			continue;
		}

		if (xmp_start_player(ctx, 44100, 0) == 0) {

			/* Show module data */

			xmp_get_module_info(ctx, &mi);
			printf("%s (%s)\n", mi.mod->name, mi.mod->type);

			/* Play module */

			playing = 1;
			SDL_PauseAudio(0);

			while (playing) {
				SDL_Delay(10);
				xmp_get_frame_info(ctx, &fi);
				printf("%3d/%3d %3d/%3d\r", fi.pos,
					mi.mod->len, fi.row, fi.num_rows);
				fflush(stdout);
			}
			xmp_end_player(ctx);
		}

		xmp_release_module(ctx);
		printf("\n");
	}

	xmp_free_context(ctx);

	sdl_deinit();

	return 0;
}
Beispiel #9
0
Cell* fbfs_write(Cell* arg) {
  sdl_init(0);
  SDL_Event event;
  SDL_PollEvent(&event);

  SDL_Rect sr = {0,0,WIDTH/SCALE,HEIGHT/SCALE};
  SDL_Rect dr = {0,0,WIDTH,HEIGHT};

  SDL_BlitScaled(pixels_surf,&sr,win_surf,&dr);
  
  SDL_UpdateWindowSurface(win);
  return arg;
}
Beispiel #10
0
terminal_t *sdl_new (ini_sct_t *sct)
{
	sdl_t *sdl;

	sdl = malloc (sizeof (sdl_t));
	if (sdl == NULL) {
		return (NULL);
	}

	sdl_init (sdl, sct);

	return (&sdl->trm);
}
Beispiel #11
0
void dev_sdl_init() {
  sdl_mount_fbfs();
  sdl_init(0);
  
  /*Cell* fbtest = alloc_num_bytes(0);
  fbtest->addr = sdl_get_fb();
  fbtest->size = sdl_get_fbsize();
  printf("fbtest->addr: %p\n",fbtest->addr);
  printf("fbtest->size: %lx\n",fbtest->size);
  
  insert_global_symbol(alloc_sym("fb"), fbtest);*/

  sdl_mount_keyfs();
}
Beispiel #12
0
void screen_init ()
{
	screen.width = opt.width;
	screen.height = opt.height;
	screen.bpp = 32;
	screen.running = 1;
	screen.display = SDL_SetVideoMode (screen.width, screen.height, screen.bpp, SDL_SWSURFACE | SDL_DOUBLEBUF);
	if (screen.display == NULL)
	{
		perror ("SDL_SetVideoMode");
		exit (EXIT_FAILURE);
	}
	sdl_init ();
	create_rgb_surface ();
}
Beispiel #13
0
int main (int argc, char *argv[])
{
    SDL_Thread *thread = NULL;

    //setup signal handler
    if ( signal(SIGINT, sig_handler) == SIG_ERR)
    {
        fprintf(stderr, "can't catch SIGINT\n");
        return 1;
    }

    running = 1;
    cmd_index = 0;
    cmd_value = 0;
    cmd_mode = MODE_CMD;
    score_entry = 0;

    if (sdl_init ())
        return 1;
/*
    thread = SDL_CreateThread (recv_thread, "RecvThread", (void *) NULL);
    if (thread == NULL)
    {
        fprintf (stderr, "SDL_CreateThread failed: %s\n", SDL_GetError());
        return 1;
    }
*/


    while (running)
    {
        SDL_SetRenderDrawColor (ren, 0, 0, 0, 0);
        SDL_RenderClear(ren);
        draw_cmd ();
        SDL_RenderPresent (ren);
        read_input ();
    }

    SDLNet_UDP_Close (socket);
    SDL_WaitThread (thread, NULL);
    SDLNet_Quit ();
    TTF_Quit ();
    SDL_Quit ();

    fprintf (stdout, "Exiting\n");
    return 0;
}
Beispiel #14
0
int main(int argc, char *args[])
{
        sdl_init();
        int quit = 0;
        Uint8 *keystate;
        Uint32 black = SDL_MapRGB(screen->format, 0x00, 0x00, 0x00);
        Uint32 white = SDL_MapRGB(screen->format, 0xFF, 0xFF, 0xFF);
        point_t corner0 = {0,0};
        point_t corner1 = {319, 0};
        point_t corner2 = {319, 319};
        point_t corner3 = {0, 319};

        // top left to bottom right
        point_t octet1 = {79, 319};
        point_t octet2 = {319, 79};

        // top right to bottom left
        point_t octet3 = {239, 319};
        point_t octet4 = {0, 79};

        while (!quit) {
                SDL_PumpEvents();
                keystate = SDL_GetKeyState(NULL);
                if(keystate[SDLK_ESCAPE]) {
                        break;
                }

                SDL_FillRect(screen, NULL, white);

                SDL_LockSurface(screen);
                // top left to bottom right
                draw_line(screen, corner0, octet1, black);
                draw_line(screen, corner0, octet2, black);
                draw_line(screen, corner0, corner2, black);

                // top right to bottom left
                draw_line(screen, corner1, octet3, black);
                draw_line(screen, corner1, octet4, black);
                draw_line(screen, corner1, corner3, black);
                SDL_UnlockSurface(screen);
                SDL_UpdateRect(screen, 0, 0, 0, 0);
                SDL_Delay(10);
        }
        SDL_Quit();
        return 0;
}
Beispiel #15
0
//============================================================
//  osd_start_audio_stream
//============================================================
void sdlaudio_init(running_machine &machine)
{
	if (LOG_SOUND)
		sound_log = fopen(SDLMAME_SOUND_LOG, "w");

	// skip if sound disabled
	if (machine.sample_rate() != 0)
	{
		// attempt to initialize SDL
		if (sdl_init(machine))
			return;

		machine.add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(FUNC(sdl_cleanup_audio), &machine));
		// set the startup volume
		machine.osd().set_mastervolume(attenuation);
	}
	return;
}
Beispiel #16
0
//============================================================
//	osd_start_audio_stream
//============================================================
void sdlaudio_init(running_machine *machine)
{
    if (LOG_SOUND)
        sound_log = fopen(SDLMAME_SOUND_LOG, "w");

    // skip if sound disabled
    if (machine->sample_rate != 0)
    {
        // attempt to initialize SDL
        if (sdl_init(machine))
            return;

        add_exit_callback(machine, sdl_cleanup_audio);
        // set the startup volume
        osd_set_mastervolume(attenuation);
    }
    return;
}
Beispiel #17
0
void init(int argc, char *argv[])
{
    Parser::check_if_user_needs_help(argc, argv);

    if (!sdl_init(SCREEN_WIDTH, SCREEN_HEIGHT, Parser::get_display_mode_from_command_line(argc, argv), main_window, main_context)) {
        Error::throw_error(Error::display_init_fail);
    }
    init_input();

    print_welcome();

    renderer.init();
    renderer.init_uniforms(camera);

    Loader::load_scene(Parser::get_scene_file_from_command_line(argc, argv), &camera);
    renderer.init_tweak_bar(&camera);

    Light::init();
}
Beispiel #18
0
int main (int argc, char *argv[]) 
{
    if (!freopen("stdout.txt", "w", stdout)) {
	ERR("Failed to open stdout.txt");
    }

    if (!freopen("stderr.txt", "w", stderr)) {
	ERR("Failed to open stderr.txt");
    }

    color_init();

    if (!config_init()) {
	DIE("Config init");
    }

    if (!sdl_init(video_w, video_h)) {
	DIE("SDL init");
    }

    if (!ttf_init()) {
	DIE("TTF init");
    }

    if (!console_init()) {
	DIE("No console");
    }

    gl_enter_2d_mode();

    console_log("hello\n");
    console_log("there\n");
    console_log("thereabcdefghijklmnopqrstuvwxyz\n");
    console_log("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz\n");
    sdl_loop();
    gl_leave_2d_mode();

    quit();

    LOG("Exit(0)");

    return (0);
}
Beispiel #19
0
int
main(int argc, char *argv[]) {
  if (!sdl_init(SCREEN_HEIGHT, SCREEN_WIDTH)) {
    return 1;
  }

  if (!kinect_init()) {
    return 1;
  }

  while (!sdl_pollevent()) {
    kinect_poll();
    draw_depths();
  }

  /* Shut down */
  kinect_shutdown();
  sdl_shutdown();
  return 0;
}
Beispiel #20
0
uint64_t kick(uint64_t f) {
	switch(f) {
	case 0x102: printf("%lx ", *llsp++); fflush(stdout); break;
	case 0x103: stack(); break;
	case 0x104: if(*llsp) putchar(*llsp); llsp++; fflush(stdout); break;

	case 0x204: { void *p=(void*)(*llsp++); return (uint64_t)realloc(p,*llsp++); }

	case 0x300: sdl_init(); break;
	case 0x301: sdl_poll(); break;
	case 0x302: sdl_clear(); break;
	case 0x303: {
			int c=*llsp++;
			int p=*llsp++;
			return sdl_char(c,p&0xffff,p>>16);
		};
	case 0x304: sdl_color(*llsp++); break;
	}
	return 0;
}
Beispiel #21
0
    void Init() {
        if (sdl_init() != 0) {
            Debug::error << "Error starting SDL." << std::endl;
            running = false;
            return;
        }

        if (gl_init() != 0) {
            Debug::error << "Error loading OpenGL." << std::endl;
            running = false;
            return;
        }

        world = new World();
        wv = new WorldView(world);
        wv2 = new WorldView(world);

        window->set_world(wv);

        window2->set_world(wv);
    }
Beispiel #22
0
Datei: main.c Projekt: odrevet/GE
int main(int argc, char** argv)
{
  SDL_Surface *screen=NULL;
  srand(time(NULL));

  int flags = 0;

  sdl_init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_JOYSTICK);
  sound_init();
  font_init();

  freopen ("res/logs/out.txt", "w", stdout);
  freopen ("res/logs/err.txt", "w", stderr);

  SDL_WM_SetCaption("RPG", NULL);

  // make sure SDL cleans up before exit
  atexit(SDL_Quit);
  SDL_ShowCursor(SDL_DISABLE);
  
  flags = SDL_DOUBLEBUF | SDL_HWSURFACE;
  // create a new window
  screen = sdl_set_video(SCREEN_WIDTH, SCREEN_HEIGHT, 16, flags);
  backbuffer = SDL_DisplayFormat(screen);

  game* p_game = NULL;

  switch(state_main_menu(screen, p_game)){
  case GAME_OVER:
    state_game_over(screen, p_game);
    break;
  default:
    break;
  }

  SDL_Quit();
  return EXIT_SUCCESS;
}
Beispiel #23
0
int gui_init(int argc, char **argv)
{
	if (gui == NULL) {
		gui = (struct _GuiCore*)malloc(sizeof(struct _GuiCore));
		if (gui == NULL) return -1;
	}

	
	memset(gui, 0, sizeof(struct _GuiCore) );
	gui->running = 1;
	gui->need_update = 1;

	register_widget("Window"     , &window_ops      );
	register_widget("ListBox"    , &listbox_ops     );
	register_widget("ListBoxItem", &listboxitem_ops );
	register_widget("Button"     , &button_ops      );
	register_widget("Image"      , &image_ops       );
	register_widget("label"      , &label_ops       );
	register_widget("NoteBook"   , &notebook_ops    );
	register_widget("MessageBox"   , &msgbox_ops    );
//	register_widget("MessageBox" , &messagebox_ops	);

	gui->signal_hash = hash_new(1, signal_Free      );
	gui->font_hash   = hash_new(1, FontDesc_Free    );
	gui->image_hash  = hash_new(9, ImageDesc_Free   );
	gui->theme_hash  = hash_new(1, Theme_Free       );

	gui->win_stack   = stack_new(NULL);
	gui->root_widget = widget_new("root", "Window", NULL);
	gui->argc = argc;
	gui->argv = argv;

	if (gui_load("./gui.xml") != 0 ) return -1;
	if (sdl_init(gui->width, gui->height, gui->bpp) != 0) return -1;

	return 0;
}
Beispiel #24
0
Cell* fbfs_write(Cell* arg) {
  sdl_init(0);
  SDL_Event event;
  if (SDL_PollEvent(&event))
  {
    if (event.type==SDL_QUIT) exit(0);
  }

  SDL_Rect sr = {0,0,WIDTH,HEIGHT};
  SDL_Rect dr = {0,0,WIDTH*SCALE,HEIGHT*SCALE};

  if (SCALE!=1) {
    SDL_BlitScaled(pixels_surf,&sr,win_surf,&dr);
  } else {
    SDL_BlitSurface(pixels_surf,NULL,win_surf,NULL);
  }

  // TODO only if changes happened
  SDL_UpdateWindowSurface(win);

  SDL_Delay(20);
  
  return arg;
}
Beispiel #25
0
int chess_init(struct chess_t *chess)
{
    int ret;

    memset(chess, 0, sizeof(struct chess_t));

    memset(chess->board, '+', sizeof(chess->board));
    chess->x = COL / 2;
    chess->y = ROW / 2;
    chess->flag = 1;

    chess->sdl.width = WIDTH;
    chess->sdl.height = HEIGHT;
    chess->sdl.bpp = BPP;

    ret = sdl_init(&chess->sdl);
    ERRP(ret != TRUE, goto ERR1, 0);

    show_board(chess);

    return TRUE;
ERR1:
    return FALSE;
}
Beispiel #26
0
/* Main stuff */
int main (int argc, char *argv[])
{
	int width = 1000, height = 600;
	int i, j;
	int freeze = 0;
	int depthflag = 0;
	int alpha = 190;
	int xoff = 0, yoff = -90;
	int sxsize = 1000;
	int sysize = 700;
	int interpol = VISUAL_VIDEO_SCALE_NEAREST;
        int frames = 0;
	VisTime start, end;
		
	bpp = 4;
	sdl_init (width, height);

	scrbuf = malloc (screen->pitch * screen->h);
	memset (scrbuf, 0, screen->pitch * screen->h);

	SDL_Event event;

	visual_init (&argc, &argv);
	
	if (argc > 1)
		actor = visual_actor_new (argv[1]);
	else
		actor = visual_actor_new ("corona");

	visual_actor_realize (actor);

	video = visual_video_new ();

	if (argc > 2)
		video = visual_bitmap_load_new_video (argv[2]);
	else
		video = visual_bitmap_load_new_video ("bg.bmp");

	actvid = visual_video_new ();
	visual_actor_set_video (actor, actvid);
	visual_video_set_depth (actvid, visual_video_depth_get_highest (visual_actor_get_supported_depth (actor)));
	visual_video_set_dimension (actvid, width, height);
	visual_video_allocate_buffer (actvid);

	visual_actor_video_negotiate (actor, 0, FALSE, FALSE);

	video32 = visual_video_new ();
	visual_video_set_depth (video32, VISUAL_VIDEO_DEPTH_32BIT);
	visual_video_set_dimension (video32, video->width, video->height);
	visual_video_allocate_buffer (video32);
	
	scalevid = visual_video_new ();
	visual_video_set_depth (scalevid, VISUAL_VIDEO_DEPTH_32BIT);
	visual_video_set_dimension (scalevid, sxsize, sysize);
	visual_video_allocate_buffer (scalevid);

	sdlvid = visual_video_new ();
	visual_video_set_depth (sdlvid, VISUAL_VIDEO_DEPTH_32BIT);
	visual_video_set_dimension (sdlvid, screen->w, screen->h);
	visual_video_set_pitch (sdlvid, screen->pitch);
	visual_video_set_buffer (sdlvid, scrbuf);
	
	input = visual_input_new ("xmms2");
	visual_input_realize (input);

	SDL_EnableKeyRepeat (SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
        
	visual_time_get (&start);
	
	while (1) {
		visual_input_run (input);
		visual_actor_run (actor, input->audio);
	
		/* place on screen */
//		visual_video_blit_overlay (sdlvid, video, 0, 0, FALSE);
	
		if (sxsize < 0)
			sxsize = 0;

		if (sysize < 0)
			sysize = 0;
		
		if (sxsize != scalevid->width || sysize != scalevid->height) {
			visual_video_set_dimension (scalevid, sxsize, sysize);
			visual_video_allocate_buffer (scalevid);
		}

		visual_video_depth_transform (video32, video);


//		visual_video_alpha_fill (sdlvid, 0);
		
//		visual_video_alpha_fill (video32, alpha);
//		visual_video_alpha_color (video32, 0, 0, 0, 255);
	

		do_alpha (video32, alpha);
		visual_video_scale (scalevid, video32, interpol);

		
		visual_video_blit_overlay (sdlvid, actvid, 0, 0, FALSE);
		visual_video_blit_overlay (sdlvid, scalevid, xoff, yoff, TRUE);

		sdl_draw_buf ();
		frames++;
		
		while (SDL_PollEvent (&event)) {
			switch (event.type) {
				case SDL_KEYDOWN:
					switch (event.key.keysym.sym) {
						case SDLK_F11:
							SDL_WM_ToggleFullScreen (screen);
							break;

						case SDLK_UP:
							yoff -= 10;

							break;

						case SDLK_DOWN:
							yoff += 10;

							break;
						
						case SDLK_LEFT:
							xoff -= 10;

							break;

						case SDLK_RIGHT:
							xoff += 10;

							break;
						
						case SDLK_q:
							sysize -= 10;

							break;

						case SDLK_a:
							sysize += 10;

							break;
						
						case SDLK_z:
							sxsize -= 10;

							break;

						case SDLK_x:
							sxsize += 10;

							break;

						case SDLK_i:
							if (interpol == VISUAL_VIDEO_SCALE_NEAREST)
								interpol = VISUAL_VIDEO_SCALE_BILINEAR;
							else
								interpol = VISUAL_VIDEO_SCALE_NEAREST;
							
							break;

						case SDLK_o:
							alpha -= 8;
							if (alpha < 0)
								alpha = 0;

							break;

						case SDLK_p:
							alpha += 8;
							if (alpha > 255)
								alpha = 255;

							break;
							
						case SDLK_ESCAPE:
							goto out;
							break;
					}
					break;

				case SDL_VIDEORESIZE:
					sdl_size_request (event.resize.w, event.resize.h);
					break;

				case SDL_QUIT:
					goto out;
					break;
			}
		}
	}
out:
	visual_time_get (&end);
	
	VisTime diff;

	visual_time_difference (&diff, &start, &end);


	printf ("Ran: %d:%d, drawn %d frames\n",
			diff.tv_sec, diff.tv_usec, frames);

	SDL_Quit ();
}
Beispiel #27
0
int
main(int argc, char const *argv[]) {
    if(argc < 2) return 1;  // TODO: Show usage.

    puts("Chipmunk: CHIP-8 Emulator");

    // NOTE: Chip8 initialization.
    struct chip8 c8 = {0};
    if(!chipmunk_init(&c8, argv[1])) return 1;

    // NOTE: SDL setup.
    SDL_Window *w = NULL;
    SDL_Renderer *r = NULL;
    SDL_Texture *t = NULL;

    // NOTE: SDL initialization.
    if(!sdl_init("chipmunk", 64 * 14, 32 * 14, &w, &r)) goto escape;
    t = SDL_CreateTexture(r, SDL_PIXELFORMAT_RGB332, SDL_TEXTUREACCESS_STREAMING, 64, 32);

    // NOTE: Timer and frame rate set up.
    double seconds_per_tick = 1.0 / (double)SDL_GetPerformanceFrequency();
    double newtime = 0.0, oldtime = 0.0, time_accumulated = 0.0;
    double target_fps = 1.0 / 60.0;
    u64 time_count = SDL_GetPerformanceCounter();

    for(;;) {
        // NOTE: SDL event processing
        SDL_Event event;
        sdl_pump_events();

        if(sdl_event_exists(&event, SDL_QUIT)) goto escape;

        sdl_flush_events();

        // NOTE: Run the emulator.
        chipmunk_run(&c8, 2000);

        // NOTE: Timing update
        newtime = sys_float_time(&time_count, seconds_per_tick);
        time_accumulated += newtime - oldtime;
        oldtime = newtime;

        // NOTE: Do sound and rendering every 60th of a second.
        if(time_accumulated > target_fps) {
            if(c8.beep) {
                puts("BEEP");
                c8.beep = false;
            }

            // TODO: Has to be a better way to do this...
            for(u32 i = sizeof(c8.display); i--;) {
                if(c8.display[i]) c8.display[i] = 255;
            }

            SDL_UpdateTexture(t, NULL, c8.display, 64 * sizeof(u8));
            SDL_RenderClear(r);
            SDL_RenderCopy(r, t, NULL, NULL);
            SDL_RenderPresent(r);

            time_accumulated -= target_fps;
        }
    }

escape:
    if(t) SDL_DestroyTexture(t);
    if(r) SDL_DestroyRenderer(r);
    if(w) SDL_DestroyWindow(w);
    SDL_Quit();

    return 0;
}
Beispiel #28
0
int main(int argc, char** argv)
{
  int flags = 0;
  //parse command line arguments
  int c;
  while ((c = getopt (argc, argv, "f")) != -1){
    switch (c)
      {
      case 'f':
	flags = SDL_WINDOW_FULLSCREEN_DESKTOP;
        break;
      default:
        abort ();
      }
  }  
  srand(time(NULL));
  sdl_init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK);
  atexit(SDL_Quit);
  SDL_ShowCursor(SDL_DISABLE);

  // create a new window
  SDL_Window* window = sdl_create_window("Tetris simple",
					 &WINDOW_WIDTH,
					 &WINDOW_HEIGHT,
					 flags);

  //create a renderer
  SDL_Renderer* renderer = SDL_CreateRenderer(window,
					      0,
					      SDL_RENDERER_ACCELERATED |
					      SDL_RENDERER_PRESENTVSYNC);
  SDL_RenderSetLogicalSize(renderer, SCREEN_WIDTH, SCREEN_HEIGHT);
  
  //new game
  game o_game;
  
  //init fontmap
  fontmap o_fontmap;
  // the 'A' is mapped to a full block to draw shapes
  const char layout[] = "0123456789A";

  // size in pixels for each characters
  o_fontmap.size = 7;

  // number of characters in the layout
  o_fontmap.layout = (char*)&layout;
  fontmap_init_from_bmp(&o_fontmap, "res/font.bmp", renderer);
  
  o_game.p_fontmap = &o_fontmap;
  
  game_status ret_code = IN_GAME;
  while(ret_code != QUIT){
    switch(ret_code){
    case IN_GAME:
      ret_code = state_in_game(renderer, &o_game);
      break;
    case GAME_OVER:
      ret_code = state_game_over(renderer, &o_game);
      break;
    default:
      break;
    }
    }

  SDL_Quit();
  return EXIT_SUCCESS;
}
Beispiel #29
0
int main(int argc, char* argv[]) {
  CONFIGURATION config;
  config_parse(argc, argv, &config);

  if (config.action == NULL || strcmp("help", config.action) == 0)
    help();
  
  enum platform system = platform_check(config.platform);
  if (system == 0) {
    fprintf(stderr, "Platform '%s' not found\n", config.platform);
    exit(-1);
  }
  
  if (strcmp("map", config.action) == 0) {
    if (config.address == NULL) {
      perror("No filename for mapping");
      exit(-1);
    }
    udev_init(!inputAdded, config.mapping);
    for (int i=0;i<config.inputsCount;i++)
      evdev_create(config.inputs[i].path, config.inputs[i].mapping);
    
    evdev_map(config.address);
    exit(0);
  }

  if (config.address == NULL) {
    config.address = malloc(MAX_ADDRESS_SIZE);
    if (config.address == NULL) {
      perror("Not enough memory");
      exit(-1);
    }
    config.address[0] = 0;
    gs_discover_server(config.address);
    if (config.address[0] == 0) {
      fprintf(stderr, "Autodiscovery failed. Specify an IP address next time.\n");
      exit(-1);
    }
  }
  
  char host_config_file[128];
  sprintf(host_config_file, "hosts/%s.conf", config.address);
  config_file_parse(host_config_file, &config);

  SERVER_DATA server;
  server.address = config.address;
  int ret;
  if ((ret = gs_init(&server, config.key_dir)) == GS_OUT_OF_MEMORY) {
    fprintf(stderr, "Not enough memory\n");
    exit(-1);
  } else if (ret == GS_INVALID) {
    fprintf(stderr, "Invalid data received from server: %s\n", config.address, gs_error);
    exit(-1);
  } else if (ret != GS_OK) {
    fprintf(stderr, "Can't connect to server %s\n", config.address);
    exit(-1);
  }

  if (strcmp("list", config.action) == 0) {
    pair_check(&server);
    applist(&server);
  } else if (strcmp("stream", config.action) == 0) {
    pair_check(&server);
    if (IS_EMBEDDED(system)) {
      for (int i=0;i<config.inputsCount;i++)
        evdev_create(config.inputs[i].path, config.inputs[i].mapping);

      udev_init(!inputAdded, config.mapping);
      evdev_init();
      #ifdef HAVE_LIBCEC
      cec_init();
      #endif /* HAVE_LIBCEC */
    }
    #ifdef HAVE_SDL
    else if (system == SDL)
      sdl_init(config.stream.width, config.stream.height);
    #endif

    stream(&server, &config, system);
  } else if (strcmp("pair", config.action) == 0) {
    char pin[5];
    sprintf(pin, "%d%d%d%d", (int)random() % 10, (int)random() % 10, (int)random() % 10, (int)random() % 10);
    printf("Please enter the following PIN on the target PC: %s\n", pin);
    if (gs_pair(&server, &pin[0]) != GS_OK) {
      fprintf(stderr, "Failed to pair to server: %s\n", gs_error);
    } else {
      printf("Succesfully paired\n");
    }
  } else if (strcmp("quit", config.action) == 0) {
    pair_check(&server);
    gs_quit_app(&server);
  } else
    fprintf(stderr, "%s is not a valid action\n", config.action);
}
Beispiel #30
0
int v_initialize (void)
{
	sdl_init();
	setup_hex( hex_size );

	{
	    int i;

	    for (i=0; i<256; i++) {
		cols[i].r = i*16;
		cols[i].g = i*16;
		cols[i].b = i*16;
		cols[i].unused = 255;
	    }
	}
	

	MAKE_COLOR(TEXT_INDEX		,  64,  64,  64, 255);
	MAKE_COLOR(STATUS_INDEX		, 255, 255, 255, 255);
	
	MAKE_COLOR(ROCK_INDEX		, 128, 128, 128, 255);
	MAKE_COLOR(ROCK2_INDEX		,  64,  64, 128, 255);
	MAKE_COLOR(EMPTY_INDEX		, 240, 240, 240, 255);
	MAKE_COLOR(FRAME_INDEX		, 200, 200, 200, 255);
	MAKE_COLOR(HEAD_INDEX		,   0,   0,   0, 255);

	MAKE_COLOR(RED_INDEX		, 240,   0,   0, 255);
	MAKE_COLOR(BLACK_INDEX		,   0, 128,   0, 255);
	MAKE_COLOR(RED_HOME_INDEX	, 200,   0,   0, 128);
	MAKE_COLOR(BLACK_HOME_INDEX	,   0, 200,   0, 128);

	MAKE_COLOR(RED_ANT_INDEX	, 240,   0,   0, 255);
	MAKE_COLOR(BLACK_ANT_INDEX	,   0, 160,   0, 255);

	MAKE_COLOR(RED_FOOD_INDEX	, 240, 128, 128, 255);
	MAKE_COLOR(BLACK_FOOD_INDEX	, 128, 200, 128, 255);

	MAKE_COLOR(S_BACK_INDEX		, 240, 240, 240, 255);
	MAKE_COLOR(S_DIR_INDEX		,   0,   0,   0, 255);
	MAKE_COLOR(S_BIT3_INDEX		, 255, 200, 200, 255);
	MAKE_COLOR(S_BIT4_INDEX		, 200, 255, 200, 255);
	MAKE_COLOR(S_BIT5_INDEX		, 200, 200, 255, 255);


	MAKE_MASK(  4, 0,	MASK_RED,	0, 0x3, 32);
	MAKE_MASK(  4, 1,	MASK_RED,	2, 0x3, 32);
	MAKE_MASK(  4, 2,	MASK_RED,	4, 0x3, 32);
	MAKE_MASK(  4, 3,	MASK_BLACK,	0, 0x3, 32);
	MAKE_MASK(  4, 4,	MASK_BLACK,	2, 0x3, 32);
	MAKE_MASK(  4, 5,	MASK_BLACK,	4, 0x3, 32);

	MAKE_MASK(  5, 0,	MASK_RED,	0, 0x1, 64);
	MAKE_MASK(  5, 1,	MASK_RED,	1, 0x1, 64);
	MAKE_MASK(  5, 2,	MASK_RED,	2, 0x1, 64);
	MAKE_MASK(  5, 3,	MASK_RED,	3, 0x1, 64);
	MAKE_MASK(  5, 4,	MASK_RED,	4, 0x1, 64);
	MAKE_MASK(  5, 5,	MASK_RED,	5, 0x1, 64);

	MAKE_MASK(  6, 0,	MASK_BLACK,	0, 0x1, 64);
	MAKE_MASK(  6, 1,	MASK_BLACK,	1, 0x1, 64);
	MAKE_MASK(  6, 2,	MASK_BLACK,	2, 0x1, 64);
	MAKE_MASK(  6, 3,	MASK_BLACK,	3, 0x1, 64);
	MAKE_MASK(  6, 4,	MASK_BLACK,	4, 0x1, 64);
	MAKE_MASK(  6, 5,	MASK_BLACK,	5, 0x1, 64);


	sdl_setcols(&cols[64], 64, 16); 

	return 0;
}