sscroll.c

一段linux下用OpenGL实现的小程序

		++map_y;
	}
}


unsigned char *new_map(void)
{
	unsigned char *map = calloc(MAP_W, MAP_H);
	if(!map)
	{
		fprintf(stderr, "Failed to allocate space for map!\n");
		return NULL;
	}
	return map;
}


unsigned char *load_map(const char *name)
{
	FILE *f;
	unsigned char *map = new_map();
	if(!map)
		return NULL;

	f = fopen(name, "rb");
	if(!f)
	{
		fprintf(stderr, "Failed to open map!\n");
		free(map);
		return NULL;
	}

	if(fread(map, MAP_W, MAP_H, f) != MAP_H)
	{
		fprintf(stderr, "Error while loading map!\n");
		free(map);
		fclose(f);
		return NULL;
	}

	fclose(f);

	printf("Map loaded.\n");
	return map;
}


int save_map(unsigned char *map, const char *name)
{
	FILE *f = fopen(name, "w+b");
	if(!f)
	{
		fprintf(stderr, "Failed to open map file for writing!\n");
		return -1;
	}

	if(fwrite(map, MAP_W, MAP_H, f) != MAP_H)
	{
		fprintf(stderr, "Error while saving map!\n");
		fclose(f);
		return -1;
	}

	fclose(f);

	printf("Map saved.\n");
	return 0;
}


/*------------------------------------------------
	Editor stuff
------------------------------------------------*/
const char *map_name = "demo.map";
int brushes[3] = { 0, 1, 2 };	/* One for each button... */
int drawing = -1;		/* Drawing what? (Brush index) */
int mousex, mousey;
int select_x, select_y;		/* Selector palette offset */

void edit_cursor(int select)
{
	int px, py;
	Uint32 color = video_map_rgb(255, 0, 255);
	SDL_Rect r;
	r.x = mousex;
	r.y = 0;
	r.w = 1;
	r.h = screen->h;
	video_fillrect(&r, color);
	r.x = 0;
	r.y = mousey;
	r.w = screen->w;
	r.h = 1;
	video_fillrect(&r, color);

	if(select)
	{
		px = (mousex - select_x) / (TILE_W+1) * (TILE_W+1) + select_x;
		py = (mousey - select_y) / (TILE_H+1) * (TILE_H+1) + select_y;
	}
	else
	{
		px = (mousex + (int)xpos) / TILE_W * TILE_W - (int)xpos;
		py = (mousey + (int)ypos) / TILE_H * TILE_H - (int)ypos;
	}
	switch((SDL_GetTicks() >> 6) & 3)
	{
	  case 0:
		r.x = px;
		r.y = py;
		r.w = TILE_W;
		r.h = 1;
		break;
	  case 1:
		r.x = px + TILE_W - 1;
		r.y = py;
		r.w = 1;
		r.h = TILE_H;
		break;
	  case 2:
		r.x = px;
		r.y = py + TILE_H - 1;
		r.w = TILE_W;
		r.h = 1;
		break;
	  case 3:
		r.x = px;
		r.y = py;
		r.w = 1;
		r.h = TILE_H;
		break;
	}
	video_fillrect(&r, color);
}


void edit_draw(void)
{
	int px, py;
	if(drawing < 0)
		return;
	if(drawing >= 3)
		return;
	px = (mousex + (int)xpos) / TILE_W;
	if(px >= MAP_W)
		return;
	py = (mousey + (int)ypos) / TILE_H;
	if(py >= MAP_H)
		return;
	map[py * MAP_W + px] = brushes[drawing];
}


void edit_palette(void)
{
	int x, y;
	SDL_Rect r;
	Uint32 color = video_map_rgb(64, 64, 64);
	r.x = 0;
	r.y = 0;
	r.w = screen->w;
	r.h = screen->h;
	video_fillrect(&r, color);
	select_x = (screen->w - PALETTE_TW * (TILE_W + 1)) / 2;
	select_y = (screen->h - PALETTE_TH * (TILE_H + 1)) / 2;
	select_x -= TILE_W;
	select_y -= TILE_H;
	if(select_x < 0)
		select_x = 2*select_x * mousex / screen->w;
	if(select_y < 0)
		select_y = 2*select_y * mousey / screen->h;
	select_x += TILE_W;
	select_y += TILE_H;
	for(y = 0; y < PALETTE_TH; ++y)
		for(x = 0; x < PALETTE_TW; ++x)
			video_draw_tile(select_x + x * (TILE_W+1),
					select_y + y * (TILE_H+1),
					y * PALETTE_TW + x);
}


void edit_select(void)
{
	while(1)
	{
		SDL_Event event;
		while(SDL_PollEvent(&event))
			switch(event.type)
			{
			  case SDL_MOUSEBUTTONDOWN:
			  {
				int px = (mousex - select_x) / (TILE_W + 1);
				int py = (mousey - select_y) / (TILE_W + 1);
				if(event.button.button > 3)
					break;
				if((px < 0) || (px >= PALETTE_TW) ||
						(py < 0) || (py >= PALETTE_TH))
					break;
				brushes[event.button.button - 1] =
						py * PALETTE_TW + px;
				break;
			  }
			  case SDL_MOUSEMOTION:
				mousex = event.motion.x / mscale;
				mousey = event.motion.y / mscale;
				break;
			  case SDL_KEYDOWN:
				switch(event.key.keysym.sym)
				{
				  case SDLK_SPACE:
				  case SDLK_ESCAPE:
					return;
				  default:
					break;
				}
				break;
			  case SDL_KEYUP:
				switch(event.key.keysym.sym)
				{
				  case SDLK_LCTRL:
				  case SDLK_RCTRL:
					return;
				  default:
					break;
				}
				break;
			  default:
				break;
			}
		edit_palette();
		edit_cursor(1);
		video_flip();
	}
}


void edit_event(SDL_Event *event)
{
	switch(event->type)
	{
	  case SDL_MOUSEBUTTONDOWN:
		mousex = event->button.x / mscale;
		mousey = event->button.y / mscale;
		drawing = event->button.button - 1;
		edit_draw();
		break;
	  case SDL_MOUSEBUTTONUP:
		drawing = -1;
		break;
	  case SDL_MOUSEMOTION:
		mousex = event->motion.x / mscale;
		mousey = event->motion.y / mscale;
		edit_draw();
		break;
	  case SDL_KEYDOWN:
		switch(event->key.keysym.sym)
		{
		  case SDLK_SPACE:
		  case SDLK_LCTRL:
		  case SDLK_RCTRL:
			edit_select();
			break;
		  case SDLK_s:
		  case SDLK_F2:
			save_map(map, map_name);
			break;
		  default:
			break;
		}
		break;
	  default:
		break;
	}
}


/*------------------------------------------------
	main
------------------------------------------------*/

int main(int argc, char* argv[])
{
	SDL_Event	event;
	Uint8		*keys;
	int		edit = 0;
	int		do_exit = 0;
	int		res, i;
	int		use_gl = 1;
	int		filter = 1;
	long		tick1, tick2;
	float		dt = 0.01;

	SDL_Init(SDL_INIT_VIDEO);
	atexit(SDL_Quit);

	flags |= SDL_FULLSCREEN;

	for(i = 1; i < argc; ++i)
	{
		if(strncmp(argv[i], "-sdl", 4) == 0)
			use_gl = 0;
		else if(strncmp(argv[i], "-gl", 3) == 0)
			use_gl = 1;
		else if(strncmp(argv[i], "-tf", 3) == 0)
			filter = 1;
		else if(strncmp(argv[i], "-ntf", 3) == 0)
			filter = 0;
		else if(strncmp(argv[i], "-f", 2) == 0)
			flags |= SDL_FULLSCREEN;
		else if(strncmp(argv[i], "-w", 2) == 0)
			flags &= ~SDL_FULLSCREEN;
		else if(strncmp(argv[i], "-s", 2) == 0)
			scale = atoi(&argv[i][2]);
		else if(strncmp(argv[i], "-e", 2) == 0)
			edit = 1;
		else if(strncmp(argv[i], "-m", 2) == 0)
		{
			++i;
			if(i >= argc)
			{
				fprintf(stderr, "'-m' must be followed by "
						"a file name!\n");
				exit(1);
			}
			map_name = argv[i];
		}
		else if(strncmp(argv[i], "-b", 2) == 0)
			bpp = atoi(&argv[i][2]);
		else
		{
			fprintf(stderr, "Unknown switch '%s'!\n", argv[i]);
			exit(1);
		}
	}

	if(edit)
	{
		if(scale < 0)
			scale = 1;
		mscale = 1;
		vscreen_w = SCREEN_W * scale;
		vscreen_h = SCREEN_H * scale;
	}
	else
	{
		if(use_gl)
		{
			if(scale < 0)
				scale = 2;
			mscale = scale;
			vscreen_w = SCREEN_W;
			vscreen_h = SCREEN_H;
		}
		else
		{
			if(scale < 0)
				scale = 1;
			mscale = 1;
			vscreen_w = SCREEN_W * scale;
			vscreen_h = SCREEN_H * scale;
		}
	}
	screen_w = SCREEN_W * scale;
	screen_h = SCREEN_H * scale;
	maxx = MAP_W * TILE_W - vscreen_w;
	maxy = MAP_H * TILE_H - vscreen_h;
	if(maxx < 0)
		maxx = 0;
	if(maxy < 0)
		maxy = 0;

	if(!use_gl && (scale != 1) && !edit)
		fprintf(stderr, "Warning: No scaling without OpenGL!\n");

	map = load_map(map_name);
	if(edit)
	{
		if(!map)
			map = new_map();
		if(!map)
			exit(1);
	}
	else if(!map)
		exit(1);

	flags |= SDL_DOUBLEBUF;

	if(use_gl)
		res = init_gl();
	else
		res = init_sdl();
	if(res < 0)
		exit(-1);

	if(use_gl)
		SDL_WM_SetCaption("OpenGL Smooth Scrolling", "SmoothScroll");
	else
		SDL_WM_SetCaption("Not All That Smooth Scrolling", "SmoothScroll");
	SDL_ShowCursor(0);

	if(edit)
		sx = sy = 0.0;

	gl_reset();
	keys = SDL_GetKeyState(&i);
	tick1 = SDL_GetTicks();
	while(!do_exit)
	{
		tick2 = SDL_GetTicks();
		if(filter)
			dt += ((tick2 - tick1) * 0.001f - dt) * 0.1;
		else
			dt = (tick2 - tick1) * 0.001f;
		tick1 = tick2;

		while(SDL_PollEvent(&event))
		{
			if(edit)
				edit_event(&event);
			else
				if(event.type == SDL_MOUSEBUTTONDOWN)
					do_exit = 1;
			if(keys[SDLK_ESCAPE])
			{
				do_exit = 1;
				break;
			}
			if(keys[SDLK_SPACE])
				sx = sy = 0.0;
		}

		if(edit)
		{
			if(keys[SDLK_UP] || (mousey < 10))
				ypos -= dt * 300.0;
			else if(keys[SDLK_DOWN] ||
					(mousey > screen_h - 10))
				ypos += dt * 300.0;

			if(keys[SDLK_LEFT] || (mousex < 10))
				xpos -= dt * 300.0;
			else if(keys[SDLK_RIGHT] ||
					(mousex > screen_w - 10))
				xpos += dt * 300.0;

			video_limit(dt);
		}
		else
		{
			if(keys[SDLK_UP])
				sy -= dt * 100.0;
			else if(keys[SDLK_DOWN])
				sy += dt * 100.0;

			if(keys[SDLK_LEFT])
				sx -= dt * 100.0;
			else if(keys[SDLK_RIGHT])
				sx += dt * 100.0;
			xpos += dt * sx;
			ypos += dt * sy;
			video_bounce(dt);
		}

		video_render();
		if(edit)
			edit_cursor(0);
		video_flip();
	}

	video_close();
	exit(0);
}