static void run_demo (void)
{
set_color_depth (16);
if (set_gfx_mode(GFX_OPENGL, width, height, 0, 0) < 0) {
allegro_message ("Error setting OpenGL graphics mode:\n%s\nAllegro GL error : %s\n", allegro_error, allegro_gl_error);
return;
}
install_keyboard();
LOCK_FUNCTION(secs_timer);
LOCK_VARIABLE(secs);
glClearColor (0, 0, 0, 0);
glShadeModel (GL_FLAT);
glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
glPolygonMode (GL_BACK, GL_POINTS);
glEnable (GL_DEPTH_TEST);
glCullFace (GL_BACK);
glEnable (GL_CULL_FACE);
install_int (secs_timer, 1000);
do {
keyboard();
rest(2);
} while (!key[KEY_ESC]);
remove_int (secs_timer);
remove_keyboard();
}
/* gfx_gdi_lock:
*/
static void gfx_gdi_lock(struct BITMAP *bmp)
{
/* to prevent the drawing threads and the rendering proc
* from concurrently accessing the dirty lines array
*/
_enter_gfx_critical();
/* arrange for drawing requests to pause when we are in the background */
if (!_win_app_foreground) {
/* stop timer */
remove_int(render_proc);
_exit_gfx_critical();
if (GFX_CRITICAL_RELEASED)
_win_thread_switch_out();
_enter_gfx_critical();
/* restart timer */
install_int(render_proc, RENDER_DELAY);
}
lock_nesting++;
bmp->id |= BMP_ID_LOCKED;
}
int main( void )
{
/* first, set up Allegro and the graphics mode */
allegro_init(); /* initialize Allegro */
install_keyboard(); /* install the keyboard for Allegro to use */
install_sound( DIGI_AUTODETECT, MIDI_AUTODETECT, NULL );
install_timer(); /* install the timer handler */
set_color_depth( 16 ); /* set the color depth to 16-bit */
set_gfx_mode( GFX_AUTODETECT, 640, 480, 0, 0 ); /* set graphics mode */
buffer = create_bitmap(SCREEN_W, SCREEN_H);/* create buffer */
pongData = load_datafile( "pongdatafile.dat" ); /* load the datafile */
ball_x = SCREEN_W / 2; /* give ball its initial x-coordinate */
ball_y = SCREEN_H / 2; /* give ball its initial y-coordinate */
barL_y = SCREEN_H / 2; /* give left paddle its initial y-coordinate */
barR_y = SCREEN_H / 2; /* give right paddle its initial y-coordinate */
scoreL = 0; /* set left player’s score to 0 */
scoreR = 0; /* set right player’s score to 0 */
srand( time( NULL ) ); /* seed the random function ... */
direction = rand() % 4; /* and then make a random initial direction */
/* add timer that calls moveBall every 5 milliseconds */
install_int( moveBall, 5 );
/* add timer that calls respondToKeyboard every 10 milliseconds */
install_int( respondToKeyboard, 10 );
while ( !key[KEY_ESC] ) /* until the escape key is pressed ... */
{
/* now, perform double buffering */
clear_to_color( buffer, makecol( 255, 255, 255 ) );
blit( pongData[BALL].dat, buffer, 0, 0, ball_x, ball_y, 40, 40 );
blit( pongData[BAR].dat, buffer, 0, 0, 0, barL_y, 20, 100 );
blit( pongData[BAR].dat, buffer, 0, 0, 620, barR_y, 20, 100 );
line( buffer, 0, 30, 640, 30, makecol( 0, 0, 0 ) );
/* draw text onto the buffer */
textprintf_ex( buffer, pongData[PONGFONT].dat, 75, 0, makecol( 0, 0, 0 ),
-1, "Left Player Score: %d", scoreL );
textprintf_ex( buffer, pongData[PONGFONT].dat, 400, 0, makecol( 0, 0, 0 ),
-1, "Right Player Score: %d", scoreR );
blit( buffer, screen, 0, 0, 0, 0, buffer->w, buffer->h );
clear_bitmap( buffer );
} /* end while */
remove_int( moveBall ); /* remove moveBall timer */
remove_int( respondToKeyboard ); /* remove respondToKeyboard timer */
destroy_bitmap( buffer ); /* destroy the buffer bitmap */
unload_datafile( pongData ); /* unload the datafile */
return 0;
} /* end function main */
//---------------------------------------------------
void initAllegroTimer()
{
if(isInit)
return;
LOCK_VARIABLE(speed_counter);
LOCK_VARIABLE(milliSec);
LOCK_VARIABLE(fps);
LOCK_VARIABLE(frame_counter);
LOCK_FUNCTION(inc_milliSec);
LOCK_FUNCTION(increment_speed_counter);
LOCK_FUNCTION(fps_proc);
install_int(inc_milliSec, 10);// every second //ever 10 of a sec
install_int_ex(increment_speed_counter, BPS_TO_TIMER(60));
install_int(fps_proc, 1000);
isInit = true;
}
/* gfx_gdi_init:
*/
static struct BITMAP *gfx_gdi_init(int w, int h, int v_w, int v_h, int color_depth)
{
/* virtual screen are not supported */
if ((v_w!=0 && v_w!=w) || (v_h!=0 && v_h!=h))
return NULL;
_enter_critical();
gfx_gdi.w = w;
gfx_gdi.h = h;
if (adjust_window(w, h) != 0) {
_TRACE(PREFIX_E "window size not supported.\n");
ustrzcpy(allegro_error, ALLEGRO_ERROR_SIZE, get_config_text("Resolution not supported"));
goto Error;
}
/* the last flag serves as an end of loop delimiter */
gdi_dirty_lines = _AL_MALLOC_ATOMIC((h+1) * sizeof(char));
ASSERT(gdi_dirty_lines);
memset(gdi_dirty_lines, 0, (h+1) * sizeof(char));
gdi_dirty_lines[h] = 1;
/* create the screen surface */
screen_surf = _AL_MALLOC_ATOMIC(w * h * BYTES_PER_PIXEL(color_depth));
gdi_screen = _make_bitmap(w, h, (unsigned long)screen_surf, &gfx_gdi, color_depth, w * BYTES_PER_PIXEL(color_depth));
gdi_screen->write_bank = gfx_gdi_write_bank;
_screen_vtable.acquire = gfx_gdi_lock;
_screen_vtable.release = gfx_gdi_unlock;
_screen_vtable.unwrite_bank = gfx_gdi_unwrite_bank;
/* create render timer */
vsync_event = CreateEvent(NULL, FALSE, FALSE, NULL);
install_int(render_proc, RENDER_DELAY);
/* connect to the system driver */
win_gfx_driver = &win_gfx_driver_gdi;
/* set the default switching policy */
set_display_switch_mode(SWITCH_PAUSE);
/* grab input devices */
win_grab_input();
_exit_critical();
return gdi_screen;
Error:
_exit_critical();
gfx_gdi_exit(NULL);
return NULL;
}
/* show_os_cursor:
* Tries to display the OS cursor. Returns 0 if a cursor is displayed after the
* function returns, else -1. This is similar to calling show_mouse(screen)
* after calling enable_hardware_cursor and checking gfx_capabilities for
* GFX_HW_CURSOR, but is easier to use in cases where you don't need Allegro's
* software cursor even if no os cursor is available.
*/
int show_os_cursor(int cursor)
{
int r = -1;
if (!mouse_driver)
return r;
remove_int(mouse_move);
gfx_capabilities &= ~(GFX_HW_CURSOR|GFX_SYSTEM_CURSOR);
if (cursor != MOUSE_CURSOR_NONE) {
if (mouse_driver->enable_hardware_cursor) {
mouse_driver->enable_hardware_cursor(TRUE);
}
/* default system cursor? */
if (cursor != MOUSE_CURSOR_ALLEGRO) {
if (mouse_driver->select_system_cursor) {
if (mouse_driver->select_system_cursor(cursor) != 0) {
gfx_capabilities |= (GFX_HW_CURSOR|GFX_SYSTEM_CURSOR);
r = 0;
goto done;
}
}
goto done;
}
else {
/* set custom hardware cursor */
if (gfx_driver) {
if (gfx_driver->set_mouse_sprite) {
if (gfx_driver->set_mouse_sprite(mouse_sprite, mouse_x_focus, mouse_y_focus))
goto done;
}
if (gfx_driver->show_mouse) {
if (gfx_driver->show_mouse(screen, mouse_x, mouse_y))
goto done;
}
gfx_capabilities |= GFX_HW_CURSOR;
r = 0;
goto done;
}
}
}
else {
if (gfx_driver && gfx_driver->hide_mouse)
gfx_driver->hide_mouse();
}
done:
if (mouse_driver->timer_poll)
install_int(mouse_move, 10);
return r;
}
/*following functions are architecture dependent */
void
tl_update_time (void)
{
#ifdef __BEOS__
currenttime = system_time ();
#else
#ifdef _WIN32
QueryPerformanceCounter (¤ttime);
#else
#ifdef USE_ALLEGRO
if (allegromode)
{
if (counter == -1)
{
LOCK_VARIABLE (counter);
LOCK_FUNCTION (timer);
install_int (timer, 1000 / TICKSPERSEC);
ainstalled = 1;
counter = 0;
}
currenttime = counter;
return;
}
#endif
#ifdef HAVE_UCLOCK
currenttime = uclock ();
#else
#ifdef USE_CLOCK
currenttime = clock ();
#else
#ifdef HAVE_GETTIMEOFDAY
do
{
gettimeofday (¤ttime, &tzp);
}
while (currenttime.tv_usec > 999999);
#else
#ifdef HAVE_FTIME
ftime (¤ttime);
#endif
#endif
#endif
#endif
#endif
#endif
#ifdef _plan9_
currenttime = plan9_msec ();
#endif
}
int main ()
{
allegro_init();
install_allegro_gl();
allegro_gl_clear_settings();
allegro_gl_set (AGL_COLOR_DEPTH, 32);
allegro_gl_set (AGL_Z_DEPTH, 24);
allegro_gl_set (AGL_FULLSCREEN, TRUE);
allegro_gl_set (AGL_DOUBLEBUFFER, 1);
allegro_gl_set (AGL_SUGGEST, AGL_COLOR_DEPTH | AGL_Z_DEPTH
| AGL_DOUBLEBUFFER | AGL_FULLSCREEN);
if (set_gfx_mode(GFX_OPENGL, 640, 480, 0, 0) < 0) {
allegro_message ("Error setting OpenGL graphics mode:\n%s\n"
"Allegro GL error : %s\n",
allegro_error, allegro_gl_error);
return -1;
}
install_keyboard();
install_timer();
LOCK_FUNCTION(secs_timer);
LOCK_VARIABLE(secs);
glShadeModel (GL_FLAT);
glEnable (GL_DEPTH_TEST);
glCullFace (GL_BACK);
glEnable (GL_CULL_FACE);
install_int (secs_timer, 1000);
do {
keyboard();
} while (!key[KEY_ESC]);
set_gfx_mode (GFX_TEXT, 0, 0, 0, 0);
allegro_message("Frames: %i, Seconds: %i, FPS: %f\n",
frames, secs, (float)frames / (float)secs);
return 0;
}
void init_at_startup(void)
{
allegro_init();
install_keyboard();
install_timer();
three_finger_flag = 0;
key_led_flag = 0;
// LOCK_FUNCTION (framecount);
LOCK_FUNCTION (tickover);
LOCK_VARIABLE (ticked);
// LOCK_VARIABLE (tick_counter);
// LOCK_VARIABLE (frames_per_second);
// LOCK_VARIABLE (framecounter);
LOCK_VARIABLE (turns_per_second);
LOCK_VARIABLE (turncounter);
// LOCK_VARIABLE (inputs_per_second);
// LOCK_VARIABLE (inputcounter);
// install_int (framecount, 1000);
install_int (tickover, 30);
set_color_depth(8);
init_config();
if (set_gfx_mode((options.windowed == 1) ? GFX_AUTODETECT_WINDOWED : GFX_AUTODETECT_FULLSCREEN, 640, 480, 0, 0) != 0)
{
set_gfx_mode(GFX_TEXT, 0, 0, 0, 0);
allegro_message("Unable to set 640x480 mode\n%s\n", allegro_error);
exit(1);
}
init_palette();
init_display();
init_menus_once_only();
init_sound(); // must come after init_menus_once_only, as that's where
// options.sound_enabled is set.
}
int initialize(){
allegro_init();
install_timer();
install_keyboard();
set_color_depth(16);
set_gfx_mode(MODE,WIDTH,HEIGHT,0,0);
srand(time(NULL));
buffer=create_bitmap(SCREEN_W,SCREEN_H);
clear(buffer);
if(install_sound(DIGI_AUTODETECT,MIDI_AUTODETECT,"")!=0){
allegro_message("Error initializing sound system");
return 0;
}
welcome=load_bitmap("welcome.bmp",NULL);
instruction1=load_bitmap("instruction1.bmp",NULL);
instruction2=load_bitmap("instruction2.bmp",NULL);
instruction3=load_bitmap("instruction3.bmp",NULL);
gameoverscreen=load_bitmap("gameover.bmp",NULL);
if(!welcome || !instruction2 || ! instruction3 || !instruction1 || ! gameoverscreen){
set_gfx_mode(GFX_TEXT,0,0,0,0);
allegro_message("WELCOME BMPS MISSING");
return 0;
}
//level1=load_sample("stage1.wav");
/*if(!level1){
allegro_message("No sound file");
return 0;
}*/
if(MapLoad("level1.fmp")){
set_gfx_mode(GFX_TEXT,0,0,0,0);
allegro_message("Can't find level1.fmp");
return 0;
}
LOCK_FUNCTION(timer1);
LOCK_VARIABLE(ticks);
LOCK_VARIABLE(framerate);
LOCK_VARIABLE(counter);
install_int(timer1,100);
return 1;
}
int main()
{
int i, exit_flag = 0;
int vnum, pnum;
VEC3F *map_vertex;
POLY3D *map_poly;
BSP_NODE *root, *node;
convert_map_to_3d("map.txt", &map_vertex, &map_poly, &vnum, &pnum);
add_bsp_root(&root, &map_poly[0]);
for(i = 1; i < pnum; i++)
add_bsp_node(root, &map_poly[i], &map_vertex, &vnum);
init();
LOCK_VARIABLE(fps);
LOCK_VARIABLE(frame_count);
LOCK_FUNCTION(update_fps);
install_int(update_fps, 1000);
while(!exit_flag)
{
if(key[KEY_ESC]) { exit_flag = 1; }
clear_bitmap(buffer);
blit(buffer, screen, 0, 0, 0, 0, SCREEN_W, SCREEN_H);
frame_count++;
}
free(map_vertex);
for(i = 0; i < pnum; i++)
free(map_poly[i].vind);
free(map_poly);
destroy_bsp_tree(root);
destroy_bitmap(buffer);
return 0;
}
int main()
{
int exit_flag = 0, i, j;
MAT16F tmat;
int vnum, node_num;
VERTEX *map_vertex;
STATIC_BSP_NODE *tree;
init();
load_static_bsp("map.bsp", &map_vertex, &vnum, &tree, &node_num);
printf("Vertex Number: %d.\nNode Number: %d.\n", vnum, node_num);
LOCK_VARIABLE(fps);
LOCK_VARIABLE(frame_count);
LOCK_FUNCTION(update_fps);
install_int(update_fps, 1000);
float frame = 0.0;
VEC3F view_volume[5];
VEC3F cam_pos = vec3f(0.0, 3.0, 0.0), cam_dir, cam_dir_normal, cam_ang = vec3f(0.0, 0.0, 0.0);
while(!exit_flag)
{
int mx, my;
get_mouse_mickeys(&mx, &my);
position_mouse(SCREEN_W / 2, SCREEN_H / 2);
cam_ang.x += my * 0.001;
cam_ang.y -= mx * 0.001;
cam_dir.x = CAM_SPEED * cos(0.5 * M_PI + cam_ang.y);
cam_dir.y = CAM_SPEED * cos(0.5 * M_PI + cam_ang.x);
cam_dir.z = CAM_SPEED * sin(0.5 * M_PI + cam_ang.y);
cam_dir_normal = vec3f(-cam_dir.z, 0.0, cam_dir.x);
if(key[KEY_ESC]) {
exit_flag = 1;
}
if(key[KEY_W]) {
cam_pos = VEC3F_SUM(cam_pos, cam_dir);
}
if(key[KEY_S]) {
cam_pos = VEC3F_DIFF(cam_pos, cam_dir);
}
if(key[KEY_A]) {
cam_pos = VEC3F_SUM(cam_pos, cam_dir_normal);
}
if(key[KEY_D]) {
cam_pos = VEC3F_DIFF(cam_pos, cam_dir_normal);
}
set_fov(90.0);
if(mouse_b > 1)
set_fov(30.0);
build_view_volume(view_volume);
reset_mat16f(tmat);
rotate_x_mat16f(tmat, cam_ang.x);
rotate_y_mat16f(tmat, cam_ang.y);
rotate_z_mat16f(tmat, 0.0);
translate_mat16f(tmat, cam_pos.x, cam_pos.y, cam_pos.z);
for(i = 0; i < 5; i++)
transform_vec3f(&view_volume[i], view_volume[i], tmat);
reset_mat16f(tmat);
translate_mat16f(tmat, -cam_pos.x, -cam_pos.y, -cam_pos.z);
rotate_z_mat16f(tmat, 0.0);
rotate_y_mat16f(tmat, -cam_ang.y);
rotate_x_mat16f(tmat, -cam_ang.x);
for(i = 0; i < vnum; i++)
{
transform_vec3f(&map_vertex[i].trans, map_vertex[i].object, tmat);
project_vertex(&map_vertex[i]);
}
for(i = 0; i < node_num; i++)
tree[i].flag = 0;
int checks = 0;
mark_nodes_inside_volume(tree, 0, map_vertex, view_volume, 5, &checks);
int count = 0;
for(i = 0; i < node_num; i++)
if(tree[i].flag == 1)
count++;
clear_to_color(buffer, 0);
clear_to_color(BASE_INT_z_buffer, BASE_INT_z_buffer_precision);
traverse_tree(tree, 0, cam_pos, map_vertex, -1);
textprintf_ex(buffer, font, 10, 10, makecol(255, 255, 255), 0, "FPS: %d", fps);
textprintf_ex(buffer, font, 10, 10, makecol(255, 255, 255), 0, "FPS: %d", fps);
textprintf_ex(buffer, font, 10, 20, makecol(255, 255, 255), 0, "Rendered: %d of nodes, %d of faces.",
(int)((float)checks / (float)node_num * 100.0), (int)((float)count / (float)node_num * 100.0));
//textprintf_ex(buffer, font, 10, 20, makecol(255, 255, 255), 0, "%d", checks);
blit(buffer, screen, 0, 0, 0, 0, SCREEN_W, SCREEN_H);
frame_count++;
}
deinit_engine();
for(i = 0; i < node_num; i++)
free(tree[i].poly.vind);
free(tree);
free(map_vertex);
return 0;
}
int main() {
BITMAP *mysha = NULL, *buffer = NULL;
PARTICLE *particle[NUM_PARTICLES];
int old_time = 0, old_time2 = 0;
int i;
int count = 0;
int use_alleg = FALSE;
int depth = 16;
allegro_init();
install_keyboard();
install_timer();
set_config_file("examples.cfg");
depth = get_config_int("examples", "depth", 16);
set_color_depth(depth);
if (set_gfx_mode(GFX_AUTODETECT, 640, 480, 0, 0)) {
set_color_depth(16);
if (set_gfx_mode(GFX_AUTODETECT, 640, 480, 0, 0)) {
set_color_depth(15);
if (set_gfx_mode(GFX_AUTODETECT, 640, 480, 0, 0)) {
set_color_depth(32);
if (set_gfx_mode(GFX_AUTODETECT, 640, 480, 0, 0)) {
allegro_message("Unable to set 640x480 screen mode!\n");
return -1;
}
}
}
}
mysha = load_bitmap("mysha.pcx", NULL);
if (!mysha) {
set_gfx_mode(GFX_TEXT, 0, 0, 0, 0);
allegro_message("Unable to load mysha.pcx. Copy it from the allegro examples directory.\n");
return -2;
}
TRACE("Got here!\n");
for (i = 0; i < NUM_PARTICLES; i++)
particle[i] = NULL;
TRACE("Still here!\n");
for (i = 0; i < NUM_PARTICLES; i++) {
int j;
int r, g, b;
TRACE("Going for particle: %i\n", i);
particle[i] = malloc(sizeof(PARTICLE));
if (!particle[i]) {
TRACE("Out of memory while creating particle!\n");
goto Error;
}
TRACE("Clearing particle\n");
memset(particle[i], 0, sizeof(PARTICLE));
TRACE("Creating bitmap\n");
particle[i]->bmp = create_bitmap(64, 64);
if (!particle[i]->bmp) {
TRACE("Out of memory while creating particle bitmap!\n");
goto Error;
}
TRACE("Clearing bitmap\n");
clear(particle[i]->bmp);
TRACE("Setting up coordinates\n");
particle[i]->x = rand() % SCREEN_W;
particle[i]->y = rand() % SCREEN_H;
particle[i]->vx = rand() % 10 - 5;
particle[i]->vy = rand() % 10 - 5;
particle[i]->a = rand() & 255;
particle[i]->a_dir = 1;
TRACE("Setting up colors\n");
hsv_to_rgb(rand() % 360, 1, 1, &r, &g, &b);
TRACE("Drawing circles\n");
for (j = 1; j < 31; j++) {
circle(particle[i]->bmp, 31, 32, j, makecol(r*2/(j+1), g*2/(j+1), b*2/(j+1)));
circle(particle[i]->bmp, 32, 32, j, makecol(r*2/(j+1), g*2/(j+1), b*2/(j+1)));
}
}
LOCK_FUNCTION(the_timer);
LOCK_VARIABLE(chrono);
buffer = create_bitmap(SCREEN_W, SCREEN_H);
if (!buffer) {
TRACE("Out of memory while creating back buffer!\n");
goto Error;
}
clear(buffer);
TRACE("Starting...\n");
install_int(the_timer, 1);
old_time = chrono;
text_mode(0);
do {
int chrono2;
/* Tile mysha over the screen */
#ifndef COMPARE_WITH_ALLEGRO
blit(mysha, buffer, 0, 0, 0, 0, mysha->w, mysha->h);
blit(mysha, buffer, 0, 0, 320, 0, mysha->w, mysha->h);
blit(mysha, buffer, 0, 0, 0, 200, mysha->w, mysha->h);
blit(mysha, buffer, 0, 0, 320, 200, mysha->w, mysha->h);
blit(mysha, buffer, 0, 0, 0, 400, mysha->w, mysha->h);
blit(mysha, buffer, 0, 0, 320, 400, mysha->w, mysha->h);
#endif
if (use_alleg) {
for (i = 0; i < NUM_PARTICLES; i++) {
set_difference_blender(0, 0, 0, particle[i]->a);
draw_trans_sprite(buffer, particle[i]->bmp, particle[i]->x - particle[i]->bmp->w/2, particle[i]->y - particle[i]->bmp->h/2);
}
}
else {
for (i = 0; i < NUM_PARTICLES; i++)
fblend_sub(particle[i]->bmp, buffer, particle[i]->x - particle[i]->bmp->w/2, particle[i]->y - particle[i]->bmp->h/2, particle[i]->a);
}
if (key[KEY_SPACE]) {
use_alleg = !use_alleg;
key[KEY_SPACE] = 0;
chrono = 0;
count = 0;
old_time = 0;
old_time2 = 0;
}
count++;
#ifdef COMPARE_WITH_ALLEGRO
textprintf(screen, font, 0, 0, makecol(255, 255, 255), "%s %.2f fps (%.3f avg)", use_alleg ? "Using Allegro" : "Using new", (chrono - old_time2) == 0 ? 1000.0 : 1000 / ((double)chrono - old_time2), count * 1000.0 / chrono);
#else
textprintf(buffer, font, 0, 0, makecol(255, 255, 255), "%s %.2f fps (%.3f avg)", use_alleg ? "Using Allegro" : "Using new", (chrono - old_time2) == 0 ? 1000.0 : 1000 / ((double)chrono - old_time2), count * 1000.0 / chrono);
#endif
old_time2 = chrono;
#ifndef COMPARE_WITH_ALLEGRO
/* Draw the buffer */
blit(buffer, screen, 0, 0, 0, 0, SCREEN_W, SCREEN_H);
#endif
chrono2 = chrono / 40;
for (i = old_time/40; i < chrono2; i++) {
int j;
for (j = 0; j < NUM_PARTICLES; j++) {
particle[j]->x += particle[j]->vx;
particle[j]->y += particle[j]->vy;
if (particle[j]->x <= 0 || particle[j]->x >= SCREEN_W)
particle[j]->vx = -particle[j]->vx;
if (particle[j]->y <= 0 || particle[j]->y >= SCREEN_H)
particle[j]->vy = -particle[j]->vy;
if (particle[j]->a <= 0 || particle[j]->a >= 256)
particle[j]->a_dir = -particle[j]->a_dir;
particle[j]->a += particle[j]->a_dir;
}
}
old_time = chrono;
} while (!key[KEY_ESC]);
Error:
TRACE("Shutting down.\n");
if (mysha)
destroy_bitmap(mysha);
if (buffer)
destroy_bitmap(buffer);
for (i = 0; i < NUM_PARTICLES; i++) {
if (particle[i]) {
if (particle[i]->bmp)
destroy_bitmap(particle[i]->bmp);
free(particle[i]);
}
}
set_gfx_mode(GFX_TEXT, 0, 0, 0, 0);
return 0;
} END_OF_MAIN();
int main()
{
int exit_flag = 0, i;
MAT16F tmat, modelmat;
VEC3F pos = vec3f(0.0, 0.0, 0.5), ang = vec3f(0.0, 0.0, 0.0);
int vnum, snum;
VEC2F *map_vec2f;
WALL_SEGMENT *map_segment;
VERTEX *map_vertex;
MD2_MODEL mdl;
VERTEX *model_verts;
TRI *model_tris;
VERTEX floor[4];
floor[0].local = vec3f(-200.0, 0.0, 200.0);
floor[1].local = vec3f(200.0, 0.0, 200.0);
floor[2].local = vec3f(200.0, 0.0, -200.0);
floor[3].local = vec3f(-200.0, 0.0, -200.0);
NODE *head = NULL;
init();
if(load_md2("data/babe.md2", &mdl))
{
allegro_message("Error: I need the MD2 model, stupid!");
exit(1);
}
convert_md2_to_base(&model_verts, &model_tris, &mdl, 0.2);
load_map("map.txt", &map_vec2f, &map_segment, &vnum, &snum, 1.0);
head = (NODE *)malloc(sizeof(NODE));
head->val = val;
head->a = map_segment[0].a;
head->b = map_segment[0].b;
head->n = NORMALIZED_NORMAL_VEC2F(map_vec2f[map_segment[0].a], map_vec2f[map_segment[0].b]);
head->parent = NULL;
head->left = NULL;
head->right = NULL;
val++;
for(i = 1; i < snum; i++)
{
add_node(head, &val, map_segment[i].a, map_segment[i].b, &map_vec2f, &vnum);
val++;
}
map_vertex = (VERTEX *)malloc(vnum * 2 * sizeof(VERTEX));
for(i = 0; i < vnum; i++)
{
map_vertex[i * 2].local = USCALE_VEC3F(vec3f(map_vec2f[i].x, 0.0, map_vec2f[i].y), 0.2);
map_vertex[i * 2 + 1].local = USCALE_VEC3F(vec3f(map_vec2f[i].x, WALL_HEIGHT, map_vec2f[i].y), 0.2);
map_vec2f[i] = USCALE_VEC2F(map_vec2f[i], 0.2);
}
LOCK_VARIABLE(fps);
LOCK_VARIABLE(frame_count);
LOCK_FUNCTION(update_fps);
install_int(update_fps, 1000);
float frame = 0.0;
VEC3F cam_pos = vec3f(0.0, 3.0, 0.0), cam_dir, cam_dir_normal, cam_ang = vec3f(0.0, 0.0, 0.0);
while(!exit_flag)
{
set_texture_mapping_mode(0);
int mx, my;
get_mouse_mickeys(&mx, &my);
position_mouse(SCREEN_W / 2, SCREEN_H / 2);
cam_ang.x += my * 0.001;
cam_ang.y -= mx * 0.001;
cam_dir.x = SPEED * cos(0.5 * M_PI + cam_ang.y);
cam_dir.y = 0.0;
cam_dir.z = SPEED * sin(0.5 * M_PI + cam_ang.y);
cam_dir_normal = vec3f(-cam_dir.z, 0.0, cam_dir.x);
if(key[KEY_ESC]) { exit_flag = 1; }
if(key[KEY_W]) { cam_pos = VEC3F_SUM(cam_pos, cam_dir); }
if(key[KEY_S]) { cam_pos = VEC3F_DIFF(cam_pos, cam_dir); }
if(key[KEY_A]) { cam_pos = VEC3F_SUM(cam_pos, cam_dir_normal); }
if(key[KEY_D]) { cam_pos = VEC3F_DIFF(cam_pos, cam_dir_normal); }
//if(key[KEY_SPACE]) { set_texture_mapping_mode(1); }
reset_mat16f(tmat);
translate_mat16f(tmat, -cam_pos.x, -cam_pos.y, -cam_pos.z);
rotate_mat16f(tmat, -cam_ang.x, -cam_ang.y, 0.0);
convert_md2_frame_to_base(model_verts, &mdl, frame, 0.2);
frame += 0.1;
reset_mat16f(modelmat);
rotate_mat16f(modelmat, M_PI * 1.5, 0.0, 0.0);
translate_mat16f(modelmat, 0.0, 5.0, 0.0);
translate_mat16f(modelmat, -cam_pos.x, -cam_pos.y, -cam_pos.z);
rotate_mat16f(modelmat, -cam_ang.x, -cam_ang.y, 0.0);
for(i = 0; i < vnum * 2; i++)
transform_vec3f(&map_vertex[i].world, map_vertex[i].local, tmat);
for(i = 0; i < 4; i++)
transform_vec3f(&floor[i].world, floor[i].local, tmat);
for(i = 0; i < mdl.header.num_vertices; i++)
transform_vec3f(&model_verts[i].world, model_verts[i].local, modelmat);
clear_bitmap(buffer);
clear_to_color(zbuffer, ZBUFFER_PRECISION);
bind_texture(texture);
VEC2F p = vec2f(cam_pos.x, cam_pos.z);
VEC2F v = vec2f(cam_dir.x, cam_dir.z);
traverse_tree(head, p, v, map_vec2f, map_vertex);
bind_texture(skin);
for(i = 0; i < mdl.header.num_tris; i++)
{
update_tri_normal(&model_tris[i], model_verts);
model_tris[i].n = NORMALIZED_VEC3F(model_tris[i].n);
if(cull_backface(&model_tris[i], model_verts))
render_tri(&model_tris[i], model_verts);
}
bind_texture(texture2);
TRI temp;
temp.a = 0; temp.b = 1; temp.c = 2;
temp.tex[0] = vec2f(0.0, 0.0); temp.tex[1] = vec2f(20.0, 0.0); temp.tex[2] = vec2f(20.0, 20.0);
render_tri(&temp, floor);
temp.a = 2; temp.b = 3; temp.c = 0;
temp.tex[0] = vec2f(20.0, 20.0); temp.tex[1] = vec2f(20.0, 0.0); temp.tex[2] = vec2f(0.0, 0.0);
render_tri(&temp, floor);
textprintf_ex(buffer, font, 10, 10, makecol(255, 255, 255), 0, "FPS: %d", fps);
blit(buffer, screen, 0, 0, 0, 0, SCREEN_W, SCREEN_H);
frame_count++;
}
destroy_bitmap(texture2);
destroy_tree(head);
free_md2(&mdl);
free(model_tris);
free(model_verts);
free(map_vertex);
free(map_vec2f);
free(map_segment);
destroy_bitmap(skin);
destroy_bitmap(texture);
destroy_bitmap(zbuffer);
destroy_bitmap(buffer);
deinit_renderer();
return 0;
}
int main(void)
{
BITMAP *textura, *back_buffer;
int x, y, c; // para rellenar la textura
int tecla;
int nPol;
int i;
char angulo_x = 0, angulo_y = 0, angulo_z = 0;
float trans_z = 12.1;
POLIGONO3D cara[6]; // un cubo
PUNTO3D ver_t[4]; // v‚rtices transformados para un pol¡gono
V3D_f ver_p[4]; // v‚rtices proyectados (2d) para un pol¡gono
MATRIX_f matriz;
printf("\nEjemplo de: backface culling (eliminaci¢n de caras posteriores)");
printf("\n\nControles:");
printf("\n Q, W, flechas = rotar cubo.");
printf("\n A, Z = z++, z--.");
printf("\n\n\nPresione una tecla para comenzar...\n");
getch();
// inicializar allegro y otras cosas
allegro_init();
set_gfx_mode(GFX_AUTODETECT, 320, 200, 0, 0);
install_keyboard();
install_timer();
install_int(&cont_frames, 1000);
LOCK_VARIABLE(nFrames);
LOCK_VARIABLE(nFramesPorSegundo);
LOCK_FUNCTION(cont_frames);
back_buffer = create_bitmap(SCREEN_W, SCREEN_H);
clear(back_buffer);
// crear una textura
textura = create_bitmap(TEX_W, TEX_H);
clear(textura);
c = 1; // color
for(x = 0; x < TEX_W; x++) {
for(y = 0; y < TEX_H; y++) {
putpixel(textura, x, y, c);
if(c++ > 64)
c = 1;
}
}
line(textura, 0, 0, TEX_W, TEX_H, 4);
line(textura, TEX_W, 0, 0, TEX_H, 4);
line(textura, 0, 0, 0, TEX_H, 4);
line(textura, 0, 0, TEX_W, 0, 4);
line(textura, 0, TEX_H - 1, TEX_W - 1, TEX_H - 1, 4);
line(textura, TEX_W - 1, TEX_H - 1, TEX_W - 1, 0, 4);
textprintf(textura, font, 1, 1, 13, "Textura");
// inicializar las coordenadas 3d del cubo
cara[0].ver[0].x = -2;
cara[0].ver[0].y = -2;
cara[0].ver[0].z = -2;
cara[0].ver[1].x = 2;
cara[0].ver[1].y = -2;
cara[0].ver[1].z = -2;
cara[0].ver[2].x = 2;
cara[0].ver[2].y = 2;
cara[0].ver[2].z = -2;
cara[0].ver[3].x = -2;
cara[0].ver[3].y = 2;
cara[0].ver[3].z = -2;
cara[1].ver[0].x = 2;
cara[1].ver[0].y = -2;
cara[1].ver[0].z = 2;
cara[1].ver[1].x = -2;
cara[1].ver[1].y = -2;
cara[1].ver[1].z = 2;
cara[1].ver[2].x = -2;
cara[1].ver[2].y = 2;
cara[1].ver[2].z = 2;
cara[1].ver[3].x = 2;
cara[1].ver[3].y = 2;
cara[1].ver[3].z = 2;
cara[2].ver[0].x = -2;
cara[2].ver[0].y = -2;
cara[2].ver[0].z = 2;
cara[2].ver[1].x = -2;
cara[2].ver[1].y = -2;
cara[2].ver[1].z = -2;
cara[2].ver[2].x = -2;
cara[2].ver[2].y = 2;
cara[2].ver[2].z = -2;
cara[2].ver[3].x = -2;
cara[2].ver[3].y = 2;
cara[2].ver[3].z = 2;
cara[3].ver[0].x = 2;
cara[3].ver[0].y = -2;
cara[3].ver[0].z = -2;
cara[3].ver[1].x = 2;
cara[3].ver[1].y = -2;
cara[3].ver[1].z = 2;
cara[3].ver[2].x = 2;
cara[3].ver[2].y = 2;
cara[3].ver[2].z = 2;
cara[3].ver[3].x = 2;
cara[3].ver[3].y = 2;
cara[3].ver[3].z = -2;
cara[4].ver[0].x = -2;
cara[4].ver[0].y = -2;
cara[4].ver[0].z = 2;
cara[4].ver[1].x = 2;
cara[4].ver[1].y = -2;
cara[4].ver[1].z = 2;
cara[4].ver[2].x = 2;
cara[4].ver[2].y = -2;
cara[4].ver[2].z = -2;
cara[4].ver[3].x = -2;
cara[4].ver[3].y = -2;
cara[4].ver[3].z = -2;
cara[5].ver[0].x = -2;
cara[5].ver[0].y = 2;
cara[5].ver[0].z = -2;
cara[5].ver[1].x = 2;
cara[5].ver[1].y = 2;
cara[5].ver[1].z = -2;
cara[5].ver[2].x = 2;
cara[5].ver[2].y = 2;
cara[5].ver[2].z = 2;
cara[5].ver[3].x = -2;
cara[5].ver[3].y = 2;
cara[5].ver[3].z = 2;
// inicializar las coordenadas de la textura
ver_p[0].u = 0;
ver_p[0].v = 0;
ver_p[1].u = TEX_W;
ver_p[1].v = 0;
ver_p[2].u = TEX_W;
ver_p[2].v = TEX_H;
ver_p[3].u = 0;
ver_p[3].v = TEX_H;
set_projection_viewport(0, 0, SCREEN_W, SCREEN_H);
do {
// teclado
if(key[KEY_UP]) {
angulo_x++;
}
if(key[KEY_DOWN]) {
angulo_x--;
}
if(key[KEY_RIGHT]) {
angulo_y--;
}
if(key[KEY_LEFT]) {
angulo_y++;
}
if(key[KEY_Q]) {
angulo_z++;
}
if(key[KEY_W]) {
angulo_z--;
}
if(key[KEY_A]) {
trans_z+=0.2;
}
if(key[KEY_Z]) {
trans_z-=0.2;
}
get_transformation_matrix_f(&matriz,
1, // escala
angulo_x, // angulo rotaci¢n x
angulo_y, // angulo rotaci¢n y
angulo_z, // angulo rotaci¢n z
0, // translaci¢n x
0, // translaci¢n y
trans_z); // translaci¢n z
for(nPol = 0; nPol < 6; nPol++) { // cada pol¡gono
for(i = 0; i < 4; i++) { // cada v‚rtice del pol¡gono
// transformaci¢n
apply_matrix_f(&matriz,
cara[nPol].ver[i].x,
cara[nPol].ver[i].y,
cara[nPol].ver[i].z,
&ver_t[i].x,
&ver_t[i].y,
&ver_t[i].z);
// proyecci¢n
persp_project_f(ver_t[i].x,
ver_t[i].y,
ver_t[i].z,
&ver_p[i].x,
&ver_p[i].y);
ver_p[i].z = ver_t[i].z; // requerido para renderizar la textura
}
// si la normal al pol¡gono es positiva -> pintar
if(polygon_z_normal_f(&ver_p[0], &ver_p[1], &ver_p[2]) > 0) {
quad3d_f(back_buffer,
POLYTYPE_PTEX,
textura,
&ver_p[0],
&ver_p[1],
&ver_p[2],
&ver_p[3]);
}
}
textprintf(back_buffer, font, 0, 190, 2, "%d FPS", nFramesPorSegundo);
blit(back_buffer, screen, 0, 0, 0, 0, SCREEN_W, SCREEN_H);
nFrames++;
clear(back_buffer);
} while(!key[KEY_ESC]);
allegro_exit();
return 0;
}
int
main(int argc, char **argv)
{
BITMAP *bmp;
PACKFILE *f;
char *file = NULL, *times = NULL, *memory = NULL;
int arg, i, n, start, end, size;
allegro_init();
install_keyboard();
install_timer();
jpgalleg_init();
set_color_conversion(COLORCONV_NONE);
for (arg = 1; arg < argc; arg++) {
if (!strcmp(argv[arg], "-nommx"))
cpu_capabilities &= ~CPU_MMX;
else if (!strcmp(argv[arg], "-f"))
file = argv[++arg];
else if (!times)
times = argv[arg];
else
about();
}
if (times)
n = atoi(times);
else
n = 30;
if (!file)
file = "jpgalleg.jpg";
bmp = load_jpg(file, NULL);
if (!bmp) {
printf("Cannot find %s!\n", file);
return -1;
}
size = file_size(file);
memory = (char *)malloc(size);
if (!memory) {
printf("Not enough memory!\n");
return -1;
}
f = pack_fopen(file, F_READ);
pack_fread(memory, size, f);
pack_fclose(f);
LOCK_FUNCTION(timer_handler);
LOCK_VARIABLE(timer);
install_int(timer_handler, 10);
printf("Average timing for %d function calls:\n", n);
start = timer;
for (i = 0; i < n; i++)
bmp = load_jpg(file, NULL);
end = timer;
printf("load_jpg: %f seconds\n", ((float)end - (float)start) / 1000.0 / (float)n);
start = timer;
for (i = 0; i < n; i++)
bmp = load_memory_jpg(memory, size, NULL);
end = timer;
printf("load_memory_jpg: %f seconds\n", ((float)end - (float)start) / 1000.0 / (float)n);
free(memory);
return 0;
}
void inicia_allegro() {
int profundidade, res;
allegro_init();
install_timer();
install_keyboard();
clear_keybuf();
install_mouse();
set_uformat(U_ASCII); // Habilita acentuação em ALGUMAS FONTES
/*profundidade = desktop_color_depth();
if (profundidade == 0) profundidade = 32;
set_color_depth(profundidade);*/
//roda configuracao de um arquivo
set_config_file("config.txt");
profundidade = get_config_int("Inicializacao", "colordepth",32);
int v = GetVersion() & 65535;
float versao = (v%256) + (v/256)/10.;
/*if (versao<=5.1) //5.1 = XP, 6.0 = Vista, 6.1 Win7
profundidade=16;
else
profundidade=32;*/
set_color_depth(profundidade); //padrao é 32 bits, no XP é 16
volume=get_config_int("Inicializacao", "volume", 128); //usa as config de volume do arquivo
exibirFPS=get_config_int("Inicializacao", "exibirFps", 0);
#define GFX_BWINDOWSCREEN_ACCEL AL_ID('B','W','S','A')
#define GFX_BWINDOWSCREEN AL_ID('B','W','S',' ')
AL_VAR(GFX_DRIVER, gfx_beos_bwindowscreen_accel);
AL_VAR(GFX_DRIVER, gfx_beos_bwindowscreen);
vSync = get_config_int("Inicializacao", "vsync",0);
resolucaoX = get_config_int("Inicializacao", "resolucaox",800);
resolucaoY = get_config_int("Inicializacao", "resolucaoy",600);
//Fullscreen
//res = set_gfx_mode(GFX_AUTODETECT_FULLSCREEN & GFX_BWINDOWSCREEN_ACCEL, resolucaoX, resolucaoY, 0, 0);
//Janela
res = set_gfx_mode(GFX_AUTODETECT_WINDOWED, resolucaoX, resolucaoY, 0, 0);
if (res != 0) {
allegro_message(allegro_error);
exit(-1);
}
if(install_sound(DIGI_AUTODETECT, MIDI_AUTODETECT, NULL))
{
allegro_message("Sound Error: %s", allegro_error);
}
//inicializa o metodo de atualizacao
initialize_screen_updating(get_config_int("Inicializacao", "updatemethod", UPDATE_TRIPLE_BUFFER));
set_window_title("Snake Criado por Arthur Assuncao"); //nome da Janela
set_display_switch_mode(SWITCH_BACKGROUND); //roda o allegro em segundo plano
//Botao fechar
LOCK_FUNCTION(BotaoFechar);
set_close_button_callback(BotaoFechar);
//Contador de frames
// Faz o lock das variaveis usadas pela funcao de timer e da propria funcao
LOCK_VARIABLE(fps);
LOCK_VARIABLE(contFrames);
LOCK_FUNCTION(funcFPS);
//chama a funcao funcFPS
install_int_ex(funcFPS,BPS_TO_TIMER(MAXFPS)); //Frames por segundo, 60FPS
//chama a funcao funcTempo
LOCK_VARIABLE(contTempo);
LOCK_FUNCTION(funcTempo);
install_int(funcTempo, 1000); //Timer "ticks" a cada mil milisegundos, ou seja, 1 segundo
/* adicione outras iniciacoes aqui */
}
/* install_mouse:
* Installs the Allegro mouse handler. You must do this before using any
* other mouse functions. Return -1 if it can't find a mouse driver,
* otherwise the number of buttons on the mouse.
*/
int install_mouse(void)
{
_DRIVER_INFO *driver_list;
int num_buttons = -1;
int config_num_buttons;
AL_CONST char *emulate;
char tmp1[64], tmp2[64];
int i;
if (mouse_driver)
return 0;
LOCK_VARIABLE(mouse_driver);
LOCK_VARIABLE(mousedrv_none);
LOCK_VARIABLE(mouse_x);
LOCK_VARIABLE(mouse_y);
LOCK_VARIABLE(mouse_z);
LOCK_VARIABLE(mouse_w);
LOCK_VARIABLE(mouse_b);
LOCK_VARIABLE(mouse_pos);
LOCK_VARIABLE(_mouse_x);
LOCK_VARIABLE(_mouse_y);
LOCK_VARIABLE(_mouse_z);
LOCK_VARIABLE(_mouse_w);
LOCK_VARIABLE(_mouse_b);
LOCK_VARIABLE(_mouse_on);
LOCK_VARIABLE(mon);
LOCK_VARIABLE(emulate_three);
LOCK_VARIABLE(freeze_mouse_flag);
LOCK_VARIABLE(mouse_callback);
LOCK_VARIABLE(mouse_x_focus);
LOCK_VARIABLE(mouse_y_focus);
LOCK_VARIABLE(mouse_sprite);
LOCK_VARIABLE(_mouse_pointer);
LOCK_VARIABLE(_mouse_screen);
LOCK_VARIABLE(mx);
LOCK_VARIABLE(my);
LOCK_VARIABLE(ms);
LOCK_VARIABLE(mtemp);
LOCK_VARIABLE(mouse_polled);
LOCK_VARIABLE(mouse_semaphore);
LOCK_VARIABLE(cursors);
LOCK_FUNCTION(draw_mouse_doublebuffer);
LOCK_FUNCTION(draw_mouse);
LOCK_FUNCTION(update_mouse);
LOCK_FUNCTION(mouse_move);
LOCK_FUNCTION(poll_mouse);
LOCK_FUNCTION(mouse_needs_poll);
LOCK_FUNCTION(_handle_mouse_input);
/* Construct mouse pointers */
if (!default_cursors[MOUSE_CURSOR_ARROW])
default_cursors[MOUSE_CURSOR_ARROW] = create_mouse_pointer(mouse_arrow_data);
if (!default_cursors[MOUSE_CURSOR_BUSY])
default_cursors[MOUSE_CURSOR_BUSY] = create_mouse_pointer(mouse_busy_data);
if (!default_cursors[MOUSE_CURSOR_QUESTION])
default_cursors[MOUSE_CURSOR_QUESTION] = create_mouse_pointer(mouse_arrow_data);
if (!default_cursors[MOUSE_CURSOR_EDIT])
default_cursors[MOUSE_CURSOR_EDIT] = create_mouse_pointer(mouse_arrow_data);
cursors[MOUSE_CURSOR_ARROW] = default_cursors[MOUSE_CURSOR_ARROW];
cursors[MOUSE_CURSOR_BUSY] = default_cursors[MOUSE_CURSOR_BUSY];
cursors[MOUSE_CURSOR_QUESTION] = default_cursors[MOUSE_CURSOR_QUESTION];
cursors[MOUSE_CURSOR_EDIT] = default_cursors[MOUSE_CURSOR_EDIT];
if (system_driver->mouse_drivers)
driver_list = system_driver->mouse_drivers();
else
driver_list = _mouse_driver_list;
if (_mouse_type == MOUSEDRV_AUTODETECT)
_mouse_type = get_config_id(uconvert_ascii("mouse", tmp1), uconvert_ascii("mouse", tmp2), MOUSEDRV_AUTODETECT);
if (_mouse_type != MOUSEDRV_AUTODETECT) {
for (i=0; driver_list[i].driver; i++) {
if (driver_list[i].id == _mouse_type) {
mouse_driver = driver_list[i].driver;
break;
}
}
}
if (mouse_driver) {
mouse_driver->name = mouse_driver->desc = get_config_text(mouse_driver->ascii_name);
num_buttons = mouse_driver->init();
}
else {
for (i=0; num_buttons<0; i++) {
if (!driver_list[i].driver)
break;
mouse_driver = driver_list[i].driver;
mouse_driver->name = mouse_driver->desc = get_config_text(mouse_driver->ascii_name);
num_buttons = mouse_driver->init();
}
}
if (num_buttons < 0) {
mouse_driver = NULL;
return -1;
}
config_num_buttons = get_config_int(uconvert_ascii("mouse", tmp1), uconvert_ascii("num_buttons", tmp2), -1);
emulate = get_config_string(uconvert_ascii("mouse", tmp1), uconvert_ascii("emulate_three", tmp2), NULL);
/* clamp config_num_buttons to zero/positive values */
if (config_num_buttons >= 0)
num_buttons = config_num_buttons;
if ((emulate) && ((i = ugetc(emulate)) != 0)) {
if ((i == 'y') || (i == 'Y') || (i == '1'))
emulate_three = TRUE;
else
emulate_three = FALSE;
}
else {
emulate_three = FALSE;
}
mouse_polled = (mouse_driver->poll) ? TRUE : FALSE;
_mouse_installed = TRUE;
disable_hardware_cursor();
set_mouse_etc();
_add_exit_func(remove_mouse, "remove_mouse");
if (mouse_driver->timer_poll)
install_int(mouse_move, 10);
return num_buttons;
}
//main function
void main()
{
//setup allegro
allegro_init();
install_mouse();
install_timer();
set_color_depth(COLOR_DEPTH);
set_gfx_mode(MODE, WIDTH, HEIGHT, 0, 0);
//setup the timer
install_int(update_timer, 1);
//seed random number
srand(time(NULL));
//set up the close button
set_close_button_callback(quit);
//initialize the buffer
buffer = create_bitmap(WIDTH, HEIGHT);
//main loop
while (!end_game)
{
//log the start time
start_time = timer;
F_PLUS = (loop_num/50);
if (F_PLUS > 120) F_PLUS = 120;
mx = (mouse_x+mx*7)/8;
my = (mouse_y+my*7)/8;
if (mouse_b & 2) {nshots = 0; score = 0; ray_t = 50; game_over = false;}
//fire a new shot
if (loop_num % 10-F_PLUS/30 == 0)
{
if (rand()%2)
{
shot[nshots].x = rand()%2*WIDTH;
shot[nshots].y = rand()%HEIGHT;
shot[nshots].vy = 0;
shot[nshots].vx = (WIDTH/2-shot[nshots].x)/(WIDTH/2);
nshots++;
}
else
{
shot[nshots].y = rand()%2*HEIGHT;
shot[nshots].x = rand()%WIDTH;
shot[nshots].vx = 0;
shot[nshots].vy = (HEIGHT/2-shot[nshots].y)/(HEIGHT/2);
nshots++;
}
}
//rays
if ((loop_num % 300-F_PLUS == 0)&&(loop_num > 300))
{
ray_x = mx+rand()%11-5;
ray_y = my+rand()%11-5;
ray_t = -40;
}
if (loop_num % 2) ray_t++;
//bullet move
for (int i = 0; i < nshots; i++)
{
shot[i].x += shot[i].vx;
shot[i].y += shot[i].vy;
if ((shot[i].x > WIDTH)||(shot[i].y > HEIGHT)||(shot[i].x < 0)||(shot[i].y < 0)){nshots--; shot[i] = shot[nshots];}
if (hit(mx, my, shot[i].x, shot[i].y, 5)){game_over = true;}
}
//death
if ((abs(ray_t) < 20)&&(((mx < ray_x+(20-abs(ray_t)))&&(mx > ray_x-(20-abs(ray_t))))
||((my < ray_y+(20-abs(ray_t)))&&(my > ray_y-(20-abs(ray_t)))))){game_over = true;}
////drawing////
//player
if (!game_over)
circle(buffer, mx, my, 5, WHITE);
else
circle(buffer, mx, my, 5, makecol(255, 0, 0));
//bullets
for (int i = 0; i < nshots; i++)
{
circlefill(buffer, shot[i].x, shot[i].y, 2, WHITE);
}
//beams
if (ray_t <= -20)
{
hline(buffer, 0, ray_y, WIDTH, WHITE);
vline(buffer, ray_x, 0, HEIGHT, WHITE);
}
if (abs(ray_t) < 20)
{
rectfill(buffer, 0, ray_y-(20-abs(ray_t)), WIDTH, ray_y+(20-abs(ray_t)), WHITE);
rectfill(buffer, ray_x-(20-abs(ray_t)), 0, ray_x+(20-abs(ray_t)), HEIGHT, WHITE);
rectfill(buffer, 0, ray_y-(20-abs(ray_t))/2, WIDTH, ray_y+(20-abs(ray_t))/2, SILVER);
rectfill(buffer, ray_x-(20-abs(ray_t))/2, 0, ray_x+(20-abs(ray_t))/2, HEIGHT, SILVER);
}
//text
if (!game_over)
textprintf_centre_ex(buffer, font, WIDTH/2, 10, WHITE, BLACK, "%i", score*LOOP_TIME/1000);
else
{
textprintf_centre_ex(buffer, font, WIDTH/2, 10, makecol(255, 0, 0), BLACK, "%i", score*LOOP_TIME/1000);
textprintf_centre_ex(buffer, font, WIDTH/2, HEIGHT/2-5, WHITE, BLACK, "Game Over");
textprintf_centre_ex(buffer, font, WIDTH/2, HEIGHT/2+10, WHITE, BLACK, "Right-Click to restart");
}
//draw to the screen
blit(buffer, screen, 0, 0, 0, 0, WIDTH, HEIGHT);
//clear the buffer
clear_to_color(buffer, BLACK);
//wait
while (timer < start_time + LOOP_TIME)
{rest(1);}
loop_num++;
if (game_over == false) score++;
}
remove_int(update_timer);
destroy_bitmap(buffer);
return;
}
/*
Self-explanatory.
*/
void init_at_startup(void)
{
LOCK_FUNCTION (framecount);
LOCK_FUNCTION (tickover);
LOCK_VARIABLE (ticked);
LOCK_VARIABLE (frames_per_second);
LOCK_VARIABLE (framecounter);
LOCK_VARIABLE (turns_per_second);
LOCK_VARIABLE (turncounter);
install_int (framecount, 1000);
install_int (tickover, 20);
set_color_depth(8);
int randseed = get_config_int("Misc", "Seed", 0);
srand(randseed);
options.windowed = get_config_int("Misc", "Windowed", 0);
int windowed;
switch(options.windowed)
{
default:
case 1: windowed = GFX_AUTODETECT_WINDOWED; break;
case 0: windowed = GFX_AUTODETECT_FULLSCREEN; break;
}
// windowed = GFX_AUTODETECT_WINDOWED;
// windowed = GFX_AUTODETECT_FULLSCREEN;
// if (set_gfx_mode(GFX_AUTODETECT_WINDOWED, 640, 480, 0, 0) != 0)
if (set_gfx_mode(windowed, 640, 480, 0, 0) != 0)
{
set_gfx_mode(GFX_TEXT, 0, 0, 0, 0);
allegro_message("Unable to set 640x480 display mode\n%s\n", allegro_error);
exit(1);
}
init_trig();
prepare_display();
init_sound();
/*
player[0].ckey [CKEY_UP] = KEY_UP;
player[0].ckey [CKEY_DOWN] = KEY_DOWN;
player[0].ckey [CKEY_LEFT] = KEY_LEFT;
player[0].ckey [CKEY_RIGHT] = KEY_RIGHT;
player[0].ckey [CKEY_FIRE1] = KEY_Z;
player[0].ckey [CKEY_FIRE2] = KEY_X;
player[0].ckey [CKEY_FIRE3] = KEY_C;
*/
player[0].ckey [CKEY_UP] = get_config_int("Misc", "key_up", KEY_UP);
player[0].ckey [CKEY_DOWN] = get_config_int("Misc", "key_down", KEY_DOWN);
player[0].ckey [CKEY_LEFT] = get_config_int("Misc", "key_left", KEY_LEFT);
player[0].ckey [CKEY_RIGHT] = get_config_int("Misc", "key_right", KEY_RIGHT);
player[0].ckey [CKEY_FIRE1] = get_config_int("Misc", "key_fire1", KEY_Z);
player[0].ckey [CKEY_FIRE2] = get_config_int("Misc", "key_fire2", KEY_X);
options.joy_stick = get_config_int("Misc", "joy_stick", 0);
options.joy_sensitivity = get_config_int("Misc", "joy_sensitivity", 70);
options.init_joystick = get_config_int("Misc", "joy_init", 1);
options.joystick = 0;
options.key_or_joy = 0; // don't put in initfile!
options.sfx_volume = get_config_int("Misc", "sfx_volume", 70);
options.ambience_volume = get_config_int("Misc", "ambience_volume", 100);
options.run_vsync = get_config_int("Misc", "run_vsync", 0);
// set_config_int("Misc", "Tourist", 3);
// set_config_int("Misc", "joy_stick", 0);
if (options.init_joystick)
init_joystick();
if (options.joystick == 1) // set in init_joystick
{
options.joy_button [0] = get_config_int("Misc", "joy_button_1", 0);
if (options.joy_button [0] > joy[0].num_buttons)
options.joy_button [0] = joy[0].num_buttons - 1;
options.joy_button [1] = get_config_int("Misc", "joy_button_2", 1);
if (options.joy_button [1] > joy[0].num_buttons)
options.joy_button [1] = joy[0].num_buttons - 1;
options.joy_button [2] = get_config_int("Misc", "joy_button_engine", 3);
if (options.joy_button [2] > joy[0].num_buttons)
options.joy_button [2] = joy[0].num_buttons - 1;
options.joy_button [3] = get_config_int("Misc", "joy_button_brake", 2);
if (options.joy_button [3] > joy[0].num_buttons)
options.joy_button [3] = joy[0].num_buttons - 1;
}
ticked = 0;
}
int main(void)
{
int c;
if (allegro_init() != 0)
return 1;
install_keyboard();
install_timer();
if (set_gfx_mode(GFX_AUTODETECT_WINDOWED, 320, 200, 0, 0) != 0) {
if (set_gfx_mode(GFX_SAFE, 320, 200, 0, 0) != 0) {
set_gfx_mode(GFX_TEXT, 0, 0, 0, 0);
allegro_message("Unable to set any graphic mode\n%s\n", allegro_error);
return 1;
}
}
set_palette(desktop_palette);
clear_to_color(screen, makecol(255, 255, 255));
textprintf_centre_ex(screen, font, SCREEN_W/2, 8, makecol(0, 0, 0),
makecol(255, 255, 255), "Driver: %s",
timer_driver->name);
/* use rest() to delay for a specified number of milliseconds */
textprintf_centre_ex(screen, font, SCREEN_W/2, 48, makecol(0, 0, 0),
makecol(255, 255, 255), "Timing five seconds:");
for (c=1; c<=5; c++) {
textprintf_centre_ex(screen, font, SCREEN_W/2, 62+c*10,
makecol(0, 0, 0), makecol(255, 255, 255), "%d", c);
rest(1000);
if (keypressed()) {
return 0;
}
}
textprintf_centre_ex(screen, font, SCREEN_W/2, 142, makecol(0, 0, 0),
makecol(255, 255, 255),
"Press a key to set up interrupts");
readkey();
/* all variables and code used inside interrupt handlers must be locked */
LOCK_VARIABLE(x);
LOCK_VARIABLE(y);
LOCK_VARIABLE(z);
LOCK_FUNCTION(inc_x);
LOCK_FUNCTION(inc_y);
LOCK_FUNCTION(inc_z);
/* the speed can be specified in milliseconds (this is once a second) */
install_int(inc_x, 1000);
/* or in beats per second (this is 10 ticks a second) */
install_int_ex(inc_y, BPS_TO_TIMER(10));
/* or in seconds (this is 10 seconds a tick) */
install_int_ex(inc_z, SECS_TO_TIMER(10));
/* the interrupts are now active... */
while (!keypressed()) {
textprintf_centre_ex(screen, font, SCREEN_W/2, 176, makecol(0, 0, 0),
makecol(255, 255, 255), "x=%d, y=%d, z=%d", x, y, z);
rest(1);
}
return 0;
}
int main() {
FONT *lucidia_fnt;
FONT *allegro_fnt;
DATAFILE *dat;
struct {
float x, y, z;
int c;
} coord[NUM_STRINGS];
char *string = STRING;
int i;
allegro_init();
install_allegro_gl();
install_timer();
LOCK_FUNCTION(the_timer);
LOCK_VARIABLE(chrono);
install_int(the_timer, 2);
allegro_gl_clear_settings();
allegro_gl_set(AGL_COLOR_DEPTH, 32);
allegro_gl_set(AGL_Z_DEPTH, 24);
allegro_gl_set(AGL_WINDOWED, TRUE);
allegro_gl_set(AGL_DOUBLEBUFFER, 1);
allegro_gl_set(AGL_RENDERMETHOD, 1);
allegro_gl_set(AGL_SUGGEST, AGL_COLOR_DEPTH | AGL_DOUBLEBUFFER
| AGL_RENDERMETHOD | AGL_Z_DEPTH | AGL_WINDOWED);
if (set_gfx_mode(GFX_OPENGL, 640, 480, 0, 0)) {
allegro_message("Error initializing OpenGL!\n");
return -1;
}
install_keyboard();
/* Load 2 copies of the datafile */
dat = load_datafile("lucidia.dat");
if (!dat) {
set_gfx_mode(GFX_TEXT, 0, 0, 0, 0);
allegro_message("Unable to load lucidia.dat\n");
return -2;
}
lucidia_fnt = allegro_gl_convert_allegro_font((FONT*)dat[0].dat,
AGL_FONT_TYPE_TEXTURED, 16.0);
if (!lucidia_fnt) {
unload_datafile(dat);
set_gfx_mode(GFX_TEXT, 0, 0, 0, 0);
allegro_message("Unable to convert font!\n");
return -3;
}
allegro_fnt = allegro_gl_convert_allegro_font(font,
AGL_FONT_TYPE_TEXTURED, 16.0);
if (!allegro_fnt) {
allegro_gl_destroy_font(lucidia_fnt);
unload_datafile(dat);
set_gfx_mode(GFX_TEXT, 0, 0, 0, 0);
allegro_message("Unable to convert font!\n");
return -4;
}
srand(time(NULL));
for (i = 0; i < NUM_STRINGS; i++) {
coord[i].z = 0;
coord[i].c = 0;
}
i = 0;
/* Start nice text demo */
/* Setup OpenGL like we want */
glEnable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
glViewport(0, 0, SCREEN_W, SCREEN_H);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glFrustum(-1.0, 1.0, -1.0, 1.0, 1, 60.0);
/* Set culling mode - not that we have anything to cull */
glEnable(GL_CULL_FACE);
glFrontFace(GL_CCW);
glMatrixMode(GL_MODELVIEW);
do {
int c;
/* Update rotation angle of text */
glLoadIdentity();
glTranslatef(0, 0, -30);
glRotatef(-45, 1, 0, 0);
glRotatef(-30, 0, 1, 0);
/* Clear the screen and set a nice blender mode */
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_COLOR);
/* Print the text wheel */
for (i = 0; i < NUM_STRINGS; i++) {
allegro_gl_printf(lucidia_fnt, coord[i].x, coord[i].y, coord[i].z,
coord[i].c, string);
}
/* Update the text wheel's position */
for (i = 0; i < NUM_STRINGS; i++) {
int r, g, b;
float angle2 = angle + i * M_PI * 2 / NUM_STRINGS;
coord[i].x = 10 * cos(angle2) - 10;
coord[i].y = 10 * sin(angle2);
angle2 = angle2 * 180.0 / M_PI;
#if ((((ALLEGRO_VERSION) << 16) | ((ALLEGRO_SUB_VERSION) << 8) | (ALLEGRO_WIP_VERSION)) == 0x40200)
/* Work around an Allegro bug that's only in 4.2.0 */
while (angle2 > 360.0f) angle2 -= 360.0f;
while (angle2 < 0) angle2 += 360.0f;
#endif
hsv_to_rgb(angle2, 1, 1, &r, &g, &b);
coord[i].c = makeacol(r, g, b, 255);
}
/* Draw "AllegroGL" */
glLoadIdentity();
c = MID(0, (int)(255 - chrono / 100), 255);
allegro_gl_printf(allegro_fnt, -(strlen(STRING0) * 1 / 2.0f) / 2,
-3.0f, -chrono / 200.0 + 0, makecol(c, c, c), STRING0);
c = MID(0, (int)(255 - chrono / 100) + 24, 255);
allegro_gl_printf(allegro_fnt, -(strlen(STRING1) * 1 / 2.0f) / 2,
-3.0f, -chrono / 200.0 + 12, makecol(c, c, c), STRING1);
c = MID(0, (int)(255 - chrono / 100) + 48, 255);
allegro_gl_printf(allegro_fnt, -(strlen(STRING2) * 1 / 2.0f) / 2,
-3.0f, -chrono / 200.0 + 24, makecol(c, c, c), STRING2);
c = MID(0, (int)(255 - chrono / 100) + 72, 255);
allegro_gl_printf(allegro_fnt, -(strlen(STRING3) * 1 / 2.0f) / 2,
-3.0f, -chrono / 200.0 + 36, makecol(c, c, c), STRING3);
c = MID(0, (int)(255 - chrono / 100) + 96, 255);
allegro_gl_printf(allegro_fnt, -(strlen(STRING4) * 1 / 2.0f) / 2,
-3.0f, -chrono / 200.0 + 48, makecol(c, c, c), STRING4);
c = MID(0, (int)(255 - chrono / 100) + 120, 255);
allegro_gl_printf(allegro_fnt, -(strlen(URL) * 1 / 2.0f) / 2,
-3.0f, -chrono / 200.0 + 60, makecol(c, c, c), URL);
allegro_gl_flip();
rest(2);
} while (!key[KEY_ESC]);
return 0;
}
int main() {
BITMAP *backbuffer = NULL, *mysha;
int count = 0;
int old_time = 0, old_time2 = 0;
int depth;
int i;
int use_alleg = 0;
allegro_init();
install_keyboard();
install_timer();
set_config_file("examples.cfg");
depth = get_config_int("examples", "depth", 16);
set_color_depth(depth);
if (set_gfx_mode(GFX_AUTODETECT, 640, 480, 0, 0)) {
set_color_depth(16);
if (set_gfx_mode(GFX_AUTODETECT, 640, 480, 0, 0)) {
set_color_depth(15);
if (set_gfx_mode(GFX_AUTODETECT, 640, 480, 0, 0)) {
set_color_depth(32);
if (set_gfx_mode(GFX_AUTODETECT, 640, 480, 0, 0)) {
allegro_message("Unable to set 640x480 screen mode!\n");
return -1;
}
}
}
}
mysha = load_bitmap("mysha.pcx", NULL);
if (!mysha) {
set_gfx_mode(GFX_TEXT, 0, 0, 0, 0);
allegro_message("Unable to load mysha.pcx. Copy it from the allegro examples directory.\n");
return -2;
}
backbuffer = create_bitmap(SCREEN_W, SCREEN_H);
if (!backbuffer) {
destroy_bitmap(mysha);
set_gfx_mode(GFX_TEXT, 0, 0, 0, 0);
allegro_message("Not enough memory to create backbuffer.\n");
return -3;
}
LOCK_FUNCTION(the_timer);
LOCK_VARIABLE(chrono);
stretch_blit(mysha, backbuffer, 0, 0, mysha->w, mysha->h, 0, 0, SCREEN_W, SCREEN_H);
for (i = 0; i < 4; i++) {
fade[i].x = (SCREEN_W/2) * (i & 1);
fade[i].y = (SCREEN_H/2) * (i & 2) >> 1;
fade[i].fact = rand() & 255;
fade[i].dir = (rand() & 1) ? 1 : -1;
fade[i].src = create_sub_bitmap(backbuffer, fade[i].x, fade[i].y, SCREEN_W/2, SCREEN_H/2);
fade[i].color = makecol((i & 1) * 255, ((i & 2) >> 1) * 255, 0);
}
install_int(the_timer, 1);
old_time = chrono;
while (!key[KEY_ESC]) {
if (use_alleg) {
stretch_blit(mysha, backbuffer, 0, 0, mysha->w, mysha->h, 0, 0, SCREEN_W, SCREEN_H);
}
textprintf(backbuffer, font, 0, 0, makecol(255, 255, 255), "%s %.2f fps (%.3f avg)", use_alleg ? "Using Allegro" : "Using FBlend", (chrono - old_time2) == 0 ? 1000.0 : 1000 / ((double)chrono - old_time2), count * 1000.0 / chrono);
if (use_alleg) {
drawing_mode(DRAW_MODE_TRANS, NULL, 0, 0);
for (i = 0; i < 4; i++) {
set_trans_blender(0, 0, 0, 255 - fade[i].fact);
rectfill(fade[i].src, 0, 0, fade[i].src->w - 1, fade[i].src->h - 1, fade[i].color);
}
drawing_mode(DRAW_MODE_SOLID, NULL, 0, 0);
}
else {
for (i = 0; i < 4; i++) {
fblend_fade_to_color(fade[i].src, screen, fade[i].x, fade[i].y, fade[i].color, fade[i].fact);
}
}
if (key[KEY_SPACE]) {
use_alleg = !use_alleg;
key[KEY_SPACE] = 0;
chrono = 0;
count = 0;
old_time = 0;
old_time2 = 0;
}
count++;
old_time2 = chrono;
/* Draw the buffer */
if (use_alleg) {
blit(backbuffer, screen, 0, 0, 0, 0, SCREEN_W, SCREEN_H);
}
for (i = 0; i < 4; i++) {
fade[i].fact += fade[i].dir;
if (fade[i].fact >= 255 || fade[i].fact <= 0)
fade[i].dir = -fade[i].dir;
fade[i].fact = MID(0, fade[i].fact, 255);
}
}
for (i = 0; i < 4; i++) {
destroy_bitmap(fade[i].src);
}
destroy_bitmap(backbuffer);
destroy_bitmap(mysha);
return 0;
}
int main()
{
/* Setup Allegro/AllegroGL */
if (allegro_init())
return 1;
if (install_allegro_gl())
return 1;
if (install_keyboard() < 0)
{
allegro_message("Unable to install keyboard\n");
return 1;
}
if (install_mouse() == -1)
{
allegro_message("Unable to install mouse\n");
return 1;
}
if (install_timer() < 0)
{
allegro_message("Unable to install timers\n");
return 1;
}
/* lock timer */
LOCK_VARIABLE(rotation_counter);
LOCK_FUNCTION(rotation_counter_handler);
/* set desktop resolution */
DESKTOP_W = GetSystemMetrics(SM_CXVIRTUALSCREEN);
DESKTOP_H = GetSystemMetrics(SM_CYVIRTUALSCREEN);
/* get monitor resolution/count */
int monitor_count;
MONITOR *monitors = get_monitors(&monitor_count);
/* generate point data */
PLACE places[POINT_COUNT];
int c;
for (c = 1; c < POINT_COUNT - 1; c++)
{
places[c].x = sin((M_PI * (GLfloat)c) / 10.0f) * 200.0f;
places[c].y = cos((M_PI * (GLfloat)c) / 10.0f) * 200.0f;
}
places[0].x = 0.01;
places[0].y = 200.0f;
places[POINT_COUNT - 1].x = 0.01;
places[POINT_COUNT - 1].y = -200.0f;
/* setup display */
allegro_gl_set(AGL_Z_DEPTH, 8);
allegro_gl_set(AGL_COLOR_DEPTH, 16);
allegro_gl_set(AGL_SUGGEST, AGL_Z_DEPTH | AGL_COLOR_DEPTH);
glDepthFunc(GL_LEQUAL);
if (set_gfx_mode(GFX_OPENGL_WINDOWED_BORDERLESS, DESKTOP_W, DESKTOP_H, 0, 0)) {
set_gfx_mode(GFX_TEXT, 0, 0, 0, 0);
allegro_message("Unable to set graphic mode\n%s\n", allegro_error);
return 1;
}
/* move window so it covers the desktop */
position_window(0, 0);
/* fake information to use if only 1 monitor */
MONITOR fake = {0, 512, 512, 512};
/* setup lighting model */
glShadeModel(GL_FLAT);
glEnable(GL_LIGHT0);
glEnable(GL_COLOR_MATERIAL);
GLfloat light_position[] = { 1.0, 1.0, 1.0, 0.0 };
glLightfv(GL_LIGHT0, GL_POSITION, light_position);
GLfloat ambient[] = { 0.1f, 0.1f, 0.1f };
glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
int selected = -1; /* the point currently being moved */
GLfloat rotation[3] = {0, 0, 0}; /* the rotation of the mesh */
install_int(rotation_counter_handler, 20); /* install the rotation handler */
/* enter main program loop */
while(!key[KEY_ESC])
{
while (rotation_counter > 0)
{
/* rotate the mesh */
rotation[0] += M_PI / 24.0f;
rotation[1] += M_PI / 16.0f;
rotation[2] += M_PI / 8.0f;
rotation_counter--;
}
/* clear the buffers */
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
/* process monitor 0 */
MONITOR *m = &monitors[0];
/* adjust mouse so its relative to the monitor */
int mx = (mouse_x - m->x) - (m->w / 2);
int my = (mouse_y - m->y) - (m->h / 2);
/* if the left mouse is pushed, find a close point */
if (mouse_b & 1)
{
if (selected == -1)
{
GLfloat distance = 10;
for (c = 0; c < POINT_COUNT; c++)
{
GLfloat dx = mx - places[c].x;
GLfloat dy = my - places[c].y;
GLfloat d = sqrt(dx * dx + dy * dy);
if (d < distance)
{
distance = d;
selected = c;
}
}
}
}
else
selected = -1;
/* move selected point */
if (selected >= 0)
{
places[selected].x = mx;
places[selected].y = my;
}
/* center the viewport on monitor */
glViewport(m->x, DESKTOP_H - m->h - m->y, m->w, m->h);
/* setup viewport projection */
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(-m->w / 2, m->w / 2, m->h / 2, -m->h / 2);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
/* draw points */
glColor3ub(0, 255, 0);
glBegin(GL_LINE_STRIP);
for (c = 0; c < POINT_COUNT; c++)
{
glVertex2f(places[c].x, places[c].y);
}
glEnd();
glColor3ub(255, 255, 255);
for (c = 0; c < POINT_COUNT; c++)
{
draw_square(places[c].x, places[c].y, 10);
}
/* draw vertical line */
glBegin(GL_LINE_STRIP);
glVertex2f(0.0f, -m->h);
glVertex2f(0.0f, m->h);
glEnd();
/* draw the mouse */
glColor3ub(255, 255, 255);
draw_square(mx, my, 20);
/* process viewport 1 */
/* select second monitor */
if (monitor_count > 1)
{
/* if 2nd monitor exists use it */
m = &monitors[1];
}
else
{
/* use fake monitor */
m = &fake;
}
/* adjust mouse so its relative to the monitor*/
mx = (mouse_x - m->x) - (m->w / 2);
my = (mouse_y - m->y) - (m->h / 2);
/* center the viewport on the monitor*/
glViewport(m->x, DESKTOP_H - m->h - m->y, m->w, m->h);
/* setup viewport projection */
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45.0f, (float)m->w / (float)m->h, 0.1f, 2000.0f);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
/* turn on lighting and depth testing */
glEnable(GL_LIGHTING);
glEnable(GL_DEPTH_TEST);
/* move mesh so its visible */
glTranslatef(0.0f, 0.0f, -1000.0f);
/* rotate mesh */
glRotatef(rotation[0], 1.0f, 0.0f, 0.0f);
glRotatef(rotation[1], 0.0f, 1.0f, 0.0f);
glRotatef(rotation[2], 0.0f, 0.0f, 1.0f);
GLfloat p1[3] = {0, 0, 0};
GLfloat p2[3] = {0, 0, 0};
GLfloat p3[3] = {0, 0, 0};
GLfloat p4[3] = {0, 0, 0};
GLfloat vec1[3];
GLfloat vec2[3];
GLfloat normal[3];
/* draw mesh to screen */
glColor3ub(0, 255, 0);
for (c = 0; c < (POINT_COUNT - 1); c++)
{
GLfloat a1 = 0;
GLfloat a2 = M_PI / 16.0f;
GLfloat d1 = places[c].x;
GLfloat d2 = places[c + 1].x;
p1[0] = sin(a1) * d1; p1[1] = places[c].y; p1[2] = cos(a1) * d1;
p2[0] = sin(a2) * d1; p2[1] = places[c].y; p2[2] = cos(a2) * d1;
p3[0] = sin(a2) * d2; p3[1] = places[c + 1].y; p3[2] = cos(a2) * d2;
p4[0] = sin(a1) * d2; p4[1] = places[c + 1].y; p4[2] = cos(a1) * d2;
buildVector(vec1, p1, p2);
buildVector(vec2, p1, p4);
cross_product_f(vec2[0], vec2[1], vec2[2], vec1[0], vec1[1], vec1[2], &normal[0], &normal[1], &normal[2]);
normalize_vector_f(&normal[0], &normal[1], &normal[2]);
glBegin(GL_QUAD_STRIP);
glNormal3fv(normal);
glVertex3fv(p1);
glVertex3fv(p4);
int s = 0;
for (s = 1; s < 32; s++)
{
a2 = (M_PI * (GLfloat)(s + 1)) / 16.0f;
d1 = places[c].x;
d2 = places[c + 1].x;
copyPoint(p1, p2);
copyPoint(p4, p3);
p2[0] = sin(a2) * d1; p2[1] = places[c].y; p2[2] = cos(a2) * d1;
p3[0] = sin(a2) * d2; p3[1] = places[c + 1].y; p3[2] = cos(a2) * d2;
buildVector(vec1, p1, p2);
buildVector(vec2, p1, p4);
cross_product_f(vec2[0], vec2[1], vec2[2], vec1[0], vec1[1], vec1[2], &normal[0], &normal[1], &normal[2]);
normalize_vector_f(&normal[0], &normal[1], &normal[2]);
glNormal3fv(normal);
glVertex3fv(p2);
glVertex3fv(p3);
}
glEnd();
}
/* turn off lighting and depth testing */
glDisable(GL_DEPTH_TEST);
glDisable(GL_LIGHTING);
/* if not using the fake monitor */
if (m != &fake)
{
/* setup viewport projection */
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(-m->w / 2, m->w / 2, m->h / 2, -m->h / 2);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
/* draw the mouse */
glColor3ub(255, 255, 255);
draw_square(mx, my, 20);
}
/* flip the contents to the screen */
allegro_gl_flip();
}
free(monitors);
return 0;
}
int main(void)
{
BITMAP *textura, *back_buffer;
int x, y, c; // para rellenar la textura
int tecla;
int nPol;
int i;
char angulo_x = 0, angulo_y = 0, angulo_z = 0;
POLIGONO3D cara[6]; // un cubo
PUNTO3D ver_t[4]; // v‚rtices transformados para un pol¡gono
V3D_f ver_p[4]; // v‚rtices proyectados (2d) para un pol¡gono
PUNTO3D cam_p; // posici¢n de la camara
VECTOR cam_f; // vector frente de la camara
VECTOR cam_a; // vector arriba de la camara
MATRIX_f matriz;
printf("\nEjemplo de c mara en un solo plano.");
printf("\n\nControles:");
printf("\n Flechas: mover la camara.");
printf("\n\n\nPresione una tecla para comenzar...\n");
getch();
// inicializar allegro y otras cosas
allegro_init();
set_gfx_mode(GFX_AUTODETECT, 640, 480, 0, 0);
install_keyboard();
install_timer();
install_int(&cont_frames, 1000);
LOCK_VARIABLE(nFrames);
LOCK_VARIABLE(nFramesPorSegundo);
LOCK_FUNCTION(cont_frames);
back_buffer = create_bitmap(SCREEN_W, SCREEN_H);
clear(back_buffer);
// crear una textura
textura = create_bitmap(TEX_W, TEX_H);
clear(textura);
c = 1; // color
for(x = 0; x < TEX_W; x++) {
for(y = 0; y < TEX_H; y++) {
putpixel(textura, x, y, c);
if(c++ > 64)
c = 1;
}
}
line(textura, 0, 0, TEX_W, TEX_H, 4);
line(textura, TEX_W, 0, 0, TEX_H, 4);
line(textura, 0, 0, 0, TEX_H, 4);
line(textura, 0, 0, TEX_W, 0, 4);
line(textura, 0, TEX_H - 1, TEX_W - 1, TEX_H - 1, 4);
line(textura, TEX_W - 1, TEX_H - 1, TEX_W - 1, 0, 4);
textprintf(textura, font, 1, 1, 13, "Textura");
// inicializar las coordenadas 3d del cubo
cara[0].ver[0].x = -2;
cara[0].ver[0].y = -2;
cara[0].ver[0].z = -2;
cara[0].ver[1].x = 2;
cara[0].ver[1].y = -2;
cara[0].ver[1].z = -2;
cara[0].ver[2].x = 2;
cara[0].ver[2].y = 2;
cara[0].ver[2].z = -2;
cara[0].ver[3].x = -2;
cara[0].ver[3].y = 2;
cara[0].ver[3].z = -2;
cara[1].ver[0].x = 2;
cara[1].ver[0].y = -2;
cara[1].ver[0].z = 2;
cara[1].ver[1].x = -2;
cara[1].ver[1].y = -2;
cara[1].ver[1].z = 2;
cara[1].ver[2].x = -2;
cara[1].ver[2].y = 2;
cara[1].ver[2].z = 2;
cara[1].ver[3].x = 2;
cara[1].ver[3].y = 2;
cara[1].ver[3].z = 2;
cara[2].ver[0].x = -2;
cara[2].ver[0].y = -2;
cara[2].ver[0].z = 2;
cara[2].ver[1].x = -2;
cara[2].ver[1].y = -2;
cara[2].ver[1].z = -2;
cara[2].ver[2].x = -2;
cara[2].ver[2].y = 2;
cara[2].ver[2].z = -2;
cara[2].ver[3].x = -2;
cara[2].ver[3].y = 2;
cara[2].ver[3].z = 2;
cara[3].ver[0].x = 2;
cara[3].ver[0].y = -2;
cara[3].ver[0].z = -2;
cara[3].ver[1].x = 2;
cara[3].ver[1].y = -2;
cara[3].ver[1].z = 2;
cara[3].ver[2].x = 2;
cara[3].ver[2].y = 2;
cara[3].ver[2].z = 2;
cara[3].ver[3].x = 2;
cara[3].ver[3].y = 2;
cara[3].ver[3].z = -2;
cara[4].ver[0].x = -2;
cara[4].ver[0].y = -2;
cara[4].ver[0].z = 2;
cara[4].ver[1].x = 2;
cara[4].ver[1].y = -2;
cara[4].ver[1].z = 2;
cara[4].ver[2].x = 2;
cara[4].ver[2].y = -2;
cara[4].ver[2].z = -2;
cara[4].ver[3].x = -2;
cara[4].ver[3].y = -2;
cara[4].ver[3].z = -2;
cara[5].ver[0].x = -2;
cara[5].ver[0].y = 2;
cara[5].ver[0].z = -2;
cara[5].ver[1].x = 2;
cara[5].ver[1].y = 2;
cara[5].ver[1].z = -2;
cara[5].ver[2].x = 2;
cara[5].ver[2].y = 2;
cara[5].ver[2].z = 2;
cara[5].ver[3].x = -2;
cara[5].ver[3].y = 2;
cara[5].ver[3].z = 2;
// inicializar las coordenadas de la textura
ver_p[0].u = 0;
ver_p[0].v = 0;
ver_p[1].u = TEX_W;
ver_p[1].v = 0;
ver_p[2].u = TEX_W;
ver_p[2].v = TEX_H;
ver_p[3].u = 0;
ver_p[3].v = TEX_H;
// inicializar c mara
cam_p.x = 0;
cam_p.y = 0;
cam_p.z = -35;
cam_f.x = 0;
cam_f.y = 0;
cam_f.z = 1;
cam_a.x = 0;
cam_a.y = -1;
cam_a.z = 0;
set_projection_viewport(0, 0, SCREEN_W, SCREEN_H);
do {
// teclado
if(key[KEY_RIGHT]) {
get_rotation_matrix_f(&matriz,
0,
-1,
0);
apply_matrix_f(&matriz,
cam_f.x,
cam_f.y,
cam_f.z,
&cam_f.x,
&cam_f.y,
&cam_f.z);
}
if(key[KEY_LEFT]) {
get_rotation_matrix_f(&matriz,
0,
1,
0);
apply_matrix_f(&matriz,
cam_f.x,
cam_f.y,
cam_f.z,
&cam_f.x,
&cam_f.y,
&cam_f.z);
}
if(key[KEY_UP]) {
cam_p.x += cam_f.x;
cam_p.y += cam_f.y;
cam_p.z += cam_f.z;
}
if(key[KEY_DOWN]) {
cam_p.x -= cam_f.x;
cam_p.y -= cam_f.y;
cam_p.z -= cam_f.z;
}
get_camera_matrix_f(&matriz,
cam_p.x,
cam_p.y,
cam_p.z,
cam_f.x,
cam_f.y,
cam_f.z,
cam_a.x,
cam_a.y,
cam_a.z,
32,
1);
for(nPol = 0; nPol < 6; nPol++) { // cada pol¡gono
for(i = 0; i < 4; i++) { // cada v‚rtice del pol¡gono
// transformaci¢n
apply_matrix_f(&matriz,
cara[nPol].ver[i].x,
cara[nPol].ver[i].y,
cara[nPol].ver[i].z,
&ver_t[i].x,
&ver_t[i].y,
&ver_t[i].z);
// proyecci¢n
persp_project_f(ver_t[i].x,
ver_t[i].y,
ver_t[i].z,
&ver_p[i].x,
&ver_p[i].y);
ver_p[i].z = ver_t[i].z; // requerido para renderizar la textura
}
// backface culling
if(polygon_z_normal_f(&ver_p[0], &ver_p[1], &ver_p[2]) > 0) {
quad3d_f(back_buffer,
POLYTYPE_PTEX,
textura,
&ver_p[0],
&ver_p[1],
&ver_p[2],
&ver_p[3]);
}
}
textprintf(back_buffer, font, 0, 190, 2, "%d FPS", nFramesPorSegundo);
blit(back_buffer, screen, 0, 0, 0, 0, SCREEN_W, SCREEN_H);
nFrames++;
clear(back_buffer);
} while(!key[KEY_ESC]);
allegro_exit();
return 0;
}
int main()
{
int exit_flag = 0, i;
MAT16F tmat;
VEC3F pos = vec3f(0.0, 0.0, 0.5), ang = vec3f(0.0, 0.0, 0.0);
MD2_MODEL mdl;
VERTEX *model_verts;
TRI *model_tris;
if(load_md2("data/babe.md2", &mdl))
{
allegro_message("Error: I need the MD2 model, stupid!");
exit(1);
}
convert_md2_to_base(&model_verts, &model_tris, &mdl, 0.02);
init();
LOCK_VARIABLE(fps);
LOCK_VARIABLE(frame_count);
LOCK_FUNCTION(update_fps);
install_int(update_fps, 1000);
float frame = 0.0;
int flag = 0, flag2 = 0;
int anim_flag = 0, point_flag = 0;
while(!exit_flag)
{
set_texture_mapping_mode(0);
if(key[KEY_ESC]) { exit_flag = 1; }
if(key[KEY_LEFT]) { pos.x -= 0.01; }
if(key[KEY_RIGHT]) { pos.x += 0.01; }
if(key[KEY_UP]) { pos.z += 0.02; }
if(key[KEY_DOWN]) { pos.z -= 0.02; }
if(key[KEY_SPACE]) { frame += 0.1; }
if(key[KEY_P]) { anim_flag = anim_flag ? 0 : 1; key[KEY_P] = 0; }
if(key[KEY_O]) { point_flag = point_flag ? 0 : 1; key[KEY_O] = 0; }
VEC2F mp, cp;
cp = vec2f(mouse_x, mouse_y);
if(mouse_b == 1)
{
if(flag == 0)
mp = cp;
flag = 1;
ang.y -= ((cp.x - mp.x) * 0.0002);
}
else
flag = 0;
if(mouse_b == 2)
{
if(flag2 == 0)
mp = cp;
flag2 = 1;
pos.z -= ((cp.y - mp.y) * 0.0002);
}
else
flag2 = 0;
ang.x = M_PI * 1.5;
convert_md2_frame_to_base(model_verts, &mdl, frame, 0.02);
if(anim_flag)
frame += 0.1 * (60.0 / (fps + 1.0));
reset_mat16f(tmat);
rotate_mat16f(tmat, ang.x, ang.y, ang.z);
translate_mat16f(tmat, pos.x, pos.y, pos.z);
for(i = 0; i < mdl.header.num_vertices; i++)
{
transform_vec3f(&model_verts[i].world, model_verts[i].local, tmat);
project_vertex(&model_verts[i]);
}
clear_bitmap(buffer);
clear_to_color(zbuffer, ZBUFFER_PRECISION);
for(i = 0; i < mdl.header.num_tris; i++)
{
update_tri_normal(&model_tris[i], model_verts);
frustum_cull(&model_tris[i], model_verts, -0.95, 20.0);
cull_backface(&model_tris[i], model_verts);
}
for(i = 0; i < mdl.header.num_tris; i++)
if(model_tris[i].vis)
my_triangle(buffer, model_verts, model_tris[i]);
if(point_flag)
for(i = 0; i < mdl.header.num_tris; i++)
if(model_tris[i].vis)
{
int x1 = model_verts[model_tris[i].a].sx, y1 = model_verts[model_tris[i].a].sy,
x2 = model_verts[model_tris[i].b].sx, y2 = model_verts[model_tris[i].b].sy,
x3 = model_verts[model_tris[i].c].sx, y3 = model_verts[model_tris[i].c].sy;
float z, z1 = model_verts[model_tris[i].a].screen.z,
z2 = model_verts[model_tris[i].b].screen.z,
z3 = model_verts[model_tris[i].c].screen.z;
if(on_bitmap(x1, y1, SCREEN_W, SCREEN_H))
{
z = (float)RI_PIXEL_Z(x1, y1) / (float)(ZBUFFER_PRECISION);
if(z1 < z + 0.001) circlefill(buffer, x1, y1, 1, makecol(255, 0, 0));
}
if(on_bitmap(x2, y2, SCREEN_W, SCREEN_H))
{
z = (float)RI_PIXEL_Z(x2, y2) / (float)(ZBUFFER_PRECISION);
if(z2 < z + 0.001) circlefill(buffer, x2, y2, 1, makecol(255, 0, 0));
}
if(on_bitmap(x3, y3, SCREEN_W, SCREEN_H))
{
z = (float)RI_PIXEL_Z(x3, y3) / (float)(ZBUFFER_PRECISION);
if(z3 < z + 0.001) circlefill(buffer, x3, y3, 1, makecol(255, 0, 0));
}
}
textprintf_ex(buffer, font, 10, 10, makecol(255, 255, 255), 0, "FPS: %d", fps);
blit(buffer, screen, 0, 0, 0, 0, SCREEN_W, SCREEN_H);
frame_count++;
}
free_md2(&mdl);
free(model_tris);
free(model_verts);
destroy_bitmap(texture);
destroy_bitmap(zbuffer);
destroy_bitmap(buffer);
deinit_renderer();
return 0;
}
/***
Function : install()
Returns : TRUE on succes, FALSE on failure
Purpose : Will install game variables, sets up the entire game.
***/
bool install()
{
// Each time we run the game, we clear out the logbook
FILE *fp;
fp = fopen("log.txt", "wt");
if (fp)
{
fprintf(fp, "Counter-Strike 2D Logbook\n");
fprintf(fp, "-------------------------\n\n"); // print head of logbook
fclose(fp);
}
logbook("--------------");
logbook("Initialization");
logbook("--------------");
// init game
map.init();
game.init();
steam.init();
logbook("Creating entity types.");
game.install_entities();
// Logbook notification
logbook("\n-------");
logbook("Allegro");
logbook("-------");
// ALLEGRO - INIT
if (allegro_init() != 0)
return false;
logbook(allegro_id);
yield_timeslice();
logbook("yield_timeslice()");
int r = install_timer();
if (r > -1) logbook("install_timer()");
else
{
logbook("FAILED");
return false;
}
alfont_init();
logbook("alfont_init()");
install_keyboard();
logbook("install_keyboard()");
install_mouse();
logbook("install_mouse()");
logbook("setting up timer functions / locking functions & memory");
/* set up the interrupt routines... */
LOCK_VARIABLE(RUNNING_TIMER_tenth);
LOCK_VARIABLE(RUNNING_TIMER_fps);
LOCK_FUNCTION(timer_tenth);
LOCK_FUNCTION(fps_proc);
install_int(timer_tenth, 10);
install_int(fps_proc, 1000);
logbook("Timers installed");
frame_count = fps = 0;
// set window title
char title[80];
sprintf(title, "Counter-Strike 2D");
// Set window title
set_window_title(title);
char window_title[256];
sprintf(window_title, "Window title set: [%s]", title);
logbook(window_title);
set_color_depth(16); // run in 16 bit mode
if (game.windowed)
{
int r = set_gfx_mode(GFX_AUTODETECT_WINDOWED, game.screen_x, game.screen_y, game.screen_x, game.screen_y);
if (r > -1)
{
// Succes
}
else
{
// GFX_DIRECTX_ACCEL / GFX_AUTODETECT
r = set_gfx_mode(GFX_DIRECTX_ACCEL, game.screen_x, game.screen_y, game.screen_x, game.screen_y);
if (r > -1)
{
game.windowed = false;
logbook("Could not enter windowed-mode; settings.d3 adjusted");
}
else
{
logbook("ERROR - !");
return false;
}
}
}
else
{
int r = set_gfx_mode(GFX_AUTODETECT, game.screen_x, game.screen_y, game.screen_x, game.screen_y);
// succes
if (r > -1)
{
}
else
{
logbook("ERROR - !!");
return false;
}
}
text_mode(0);
logbook("Loading font data");
// loading font
game_font = alfont_load_font("gfx\\font\\tahoma.ttf");
if (game_font != NULL)
{
alfont_set_font_size(game_font, 20); // set size
}
else
allegro_message("Error loading tahoma.ttf!");
// CS Font
cs_font = alfont_load_font("gfx\\font\\cs.ttf");
if (cs_font != NULL)
{
alfont_set_font_size(cs_font, 20); // set size
}
else
allegro_message("Error loading cs.ttf");
alfont_text_mode(-1);
if (set_display_switch_mode(SWITCH_BACKGROUND) < 0)
{
set_display_switch_mode(SWITCH_PAUSE);
logbook("Display 'switch and pause' mode set");
}
else
logbook("Display 'switch to background' mode set");
// sound
logbook("Initializing sound");
int s = install_sound(DIGI_AUTODETECT, MIDI_AUTODETECT, NULL);
/***
Bitmap Creation
***/
bmp_screen = create_bitmap(game.screen_x, game.screen_y);
if (bmp_screen == NULL)
{
logbook("ERROR: Could not create bitmap: bmp_screen");
return false;
}
else
logbook("Bitmap created: bmp_screen");
bmp_collide = create_bitmap(game.screen_x, game.screen_y);
if (bmp_collide == NULL)
{
logbook("ERROR: Could not create bitmap: bmp_collide");
return false;
}
else
logbook("Bitmap created: bmp_collide");
/*** End of Bitmap Creation ***/
// load datafiles
graphics = load_datafile("graphics.dat");
if (graphics == NULL)
{
logbook("ERROR: Could not load datafile: graphics.dat");
return false;
}
else
logbook("Datafile loaded: graphics.dat");
// Shadows
shadows = load_datafile("shadows.dat");
if (shadows == NULL)
{
logbook("ERROR: Could not load datafile: shadows.dat");
return false;
}
else
logbook("Datafile loaded: shadows.dat");
// HUD
hud = load_datafile("hud.dat");
if (hud == NULL)
{
logbook("ERROR: Could not load datafile: hud.dat");
return false;
}
else
logbook("Datafile loaded: hud.dat");
//set_color_conversion(COLORCONV_NONE);
set_color_conversion(COLORCONV_MOST);
logbook("Color conversion method set");
// setup mouse speed
set_mouse_speed(2,2);
logbook("Mouse speed set");
logbook("");
logbook("----");
logbook("GAME ");
logbook("----");
game.LOAD_TexturesFromDataFile("data//de_aztec.dat");
// DATA_Init();
// randomize timer
srand( (unsigned)time( NULL ) );
//srand(time(NULL));
// normal sounds are loud, the music is lower (its background music, so it should not be disturbing)
set_volume(255, 200);
set_trans_blender(128, 128, 128, 128);
logbook("");
logbook("--------------");
logbook("BATTLE CONTROL");
logbook("--------------");
logbook("\n3...2...1... GO!\n");
return true;
}
int main()
{
int exit = 0, i, vnum, pnum;
VEC3F pos = vec3f(0.0, 0.0, 0.3), ang = ZERO_VEC3F;
MAT16F tmat;
VERTEX *vertex;
POLY3D *poly;
init();
load_map("quake_map2.txt", &vertex, &poly, &vnum, &pnum, 0.2);
LOCK_VARIABLE(fps);
LOCK_VARIABLE(frame_count);
LOCK_FUNCTION(update_fps);
install_int(update_fps, 1000);
VEC3F cam_pos = vec3f(0.0, 3.0, 0.0), cam_dir, cam_dir_normal, cam_ang = vec3f(0.0, 0.0, 0.0);
while(!exit)
{
int mx, my;
get_mouse_mickeys(&mx, &my);
position_mouse(SCREEN_W / 2, SCREEN_H / 2);
cam_ang.x += my * 0.001;
cam_ang.y -= mx * 0.001;
cam_dir.x = CAM_SPEED * cos(0.5 * M_PI + cam_ang.y);
cam_dir.y = CAM_SPEED * cos(0.5 * M_PI + cam_ang.x);
cam_dir.z = CAM_SPEED * sin(0.5 * M_PI + cam_ang.y);
cam_dir_normal = vec3f(-cam_dir.z, 0.0, cam_dir.x);
if(key[KEY_ESC]) { exit = 1; }
if(key[KEY_W]) { cam_pos = VEC3F_SUM(cam_pos, cam_dir); }
if(key[KEY_S]) { cam_pos = VEC3F_DIFF(cam_pos, cam_dir); }
if(key[KEY_A]) { cam_pos = VEC3F_SUM(cam_pos, cam_dir_normal); }
if(key[KEY_D]) { cam_pos = VEC3F_DIFF(cam_pos, cam_dir_normal); }
set_fov(90.0);
if(mouse_b > 1)
set_fov(30.0);
reset_mat16f(tmat);
translate_mat16f(tmat, -cam_pos.x, -cam_pos.y, -cam_pos.z);
rotate_z_mat16f(tmat, 0.0);
rotate_y_mat16f(tmat, -cam_ang.y);
rotate_x_mat16f(tmat, -cam_ang.x);
for(i = 0; i < vnum; i++)
{
transform_vec3f(&vertex[i].trans, vertex[i].object, tmat);
project_vertex(&vertex[i]);
}
clear_to_color(buffer, 0);
clear_to_color(BASE_INT_z_buffer, BASE_INT_z_buffer_precision);
for(i = 0; i < pnum; i++)
{
update_poly3d_normal(&poly[i], vertex);
V0 = vertex[poly[i].vind[0]].trans;
global_n = USCALE_VEC3F(NORMALIZED_VEC3F(poly[i].normal), -1.0);
VEC3F N = global_n;
DIST = -VEC3F_DOT_PRODUCT(V0, N);
get_axes(vertex[poly[i].vind[0]].trans,
vertex[poly[i].vind[1]].trans,
vertex[poly[i].vind[2]].trans,
to_vec3f(poly[i].texcoord[0]),
to_vec3f(poly[i].texcoord[1]),
to_vec3f(poly[i].texcoord[2]), &A, &B, &C);
T0 = to_vec3f(poly[i].texcoord[0]);
if(cull_backface(&poly[i], vertex))
render_poly3d(&poly[i], vertex);
}
textprintf_ex(buffer, font, 10, 10, makecol(255, 255, 255), 0, "FPS: %d", fps);
blit(buffer, screen, 0, 0, 0, 0, SCREEN_W, SCREEN_H);
frame_count++;
}
for(i = 0; i < pnum; i++)
destroy_poly3d(&poly[i]);
free(vertex);
deinit_engine();
return 0;
}
/*
Self-explanatory.
*/
void init_at_startup(void)
{
LOCK_FUNCTION (framecount);
LOCK_FUNCTION (tickover);
LOCK_VARIABLE (ticked);
LOCK_VARIABLE (frames_per_second);
LOCK_VARIABLE (framecounter);
LOCK_VARIABLE (turns_per_second);
LOCK_VARIABLE (turncounter);
install_int (framecount, 1000);
install_int (tickover, 20);
set_color_depth(8);
int randseed = get_config_int("Misc", "Seed", 0);
srand(randseed);
options.windowed = get_config_int("Misc", "Windowed", 0);
int windowed;
switch(options.windowed)
{
default:
case 1: windowed = GFX_AUTODETECT_WINDOWED; break;
case 0: windowed = GFX_AUTODETECT_FULLSCREEN; break;
}
// windowed = GFX_AUTODETECT_WINDOWED;
// windowed = GFX_AUTODETECT_FULLSCREEN;
// if (set_gfx_mode(GFX_AUTODETECT_WINDOWED, 640, 480, 0, 0) != 0)
// if (set_gfx_mode(windowed, 640, 480, 0, 0) != 0)
if (set_gfx_mode(windowed, 800, 600, 0, 0) != 0)
{
set_gfx_mode(GFX_TEXT, 0, 0, 0, 0);
allegro_message("Unable to set 800x600 256 colour display mode. Sorry!\n%s\n", allegro_error);
exit(1);
}
init_trig();
prepare_display();
init_sound();
/*
PP.ckey [CKEY_UP] = KEY_UP;
PP.ckey [CKEY_DOWN] = KEY_DOWN;
PP.ckey [CKEY_LEFT] = KEY_LEFT;
PP.ckey [CKEY_RIGHT] = KEY_RIGHT;
PP.ckey [CKEY_FIRE1] = KEY_Z;
PP.ckey [CKEY_FIRE2] = KEY_X;
PP.ckey [CKEY_FIRE3] = KEY_C;
*/
int p = 0;
init_joystick();
player[0].control = get_config_int("misc", "player1_control", CONTROL_KEY_A);
player[1].control = get_config_int("misc", "player2_control", CONTROL_KEY_B);
// if a particular joystick isn't available, default to keyboard controls.
// note that this doesn't set the config values
for (p = 0; p < 2; p ++)
{
if (options.joystick_available [0] == 0
&& PP.control == CONTROL_JOY_A)
{
PP.control = CONTROL_KEY_A;
if (PP.control == CONTROL_KEY_A)
PP.control = CONTROL_KEY_B;
}
if (options.joystick_available [1] == 0
&& PP.control == CONTROL_JOY_B)
{
PP.control = CONTROL_KEY_A;
if (PP.control == CONTROL_KEY_A)
PP.control = CONTROL_KEY_B;
}
}
options.ckey [0] [CKEY_UP] = get_config_int("Misc", "key1_up", KEY_8_PAD);
options.ckey [0] [CKEY_DOWN] = get_config_int("Misc", "key1_down", KEY_2_PAD);
options.ckey [0] [CKEY_LEFT] = get_config_int("Misc", "key1_left", KEY_4_PAD);
options.ckey [0] [CKEY_RIGHT] = get_config_int("Misc", "key1_right", KEY_6_PAD);
options.ckey [0] [CKEY_LEFT2] = get_config_int("Misc", "key1_left2", KEY_1_PAD);
options.ckey [0] [CKEY_RIGHT2] = get_config_int("Misc", "key1_right2", KEY_3_PAD);
options.ckey [0] [CKEY_FIRE1] = get_config_int("Misc", "key1_fire1", KEY_Z);
options.ckey [0] [CKEY_FIRE2] = get_config_int("Misc", "key1_fire2", KEY_X);
options.ckey [0] [CKEY_FIRE3] = get_config_int("Misc", "key1_fire3", KEY_C);
options.ckey [0] [CKEY_FIRE4] = get_config_int("Misc", "key1_fire4", KEY_V);
options.ckey [0] [CKEY_COMMAND] = get_config_int("Misc", "key1_command", KEY_A);
options.ckey [1] [CKEY_UP] = get_config_int("Misc", "key2_up", KEY_UP);
options.ckey [1] [CKEY_DOWN] = get_config_int("Misc", "key2_down", KEY_DOWN);
options.ckey [1] [CKEY_LEFT] = get_config_int("Misc", "key2_left", KEY_LEFT);
options.ckey [1] [CKEY_RIGHT] = get_config_int("Misc", "key2_right", KEY_RIGHT);
options.ckey [1] [CKEY_LEFT2] = get_config_int("Misc", "key2_left2", KEY_J);
options.ckey [1] [CKEY_RIGHT2] = get_config_int("Misc", "key2_right2", KEY_K);
options.ckey [1] [CKEY_FIRE1] = get_config_int("Misc", "key2_fire1", KEY_T);
options.ckey [1] [CKEY_FIRE2] = get_config_int("Misc", "key2_fire2", KEY_Y);
options.ckey [1] [CKEY_FIRE3] = get_config_int("Misc", "key2_fire3", KEY_U);
options.ckey [1] [CKEY_FIRE4] = get_config_int("Misc", "key2_fire4", KEY_I);
options.ckey [1] [CKEY_COMMAND] = get_config_int("Misc", "key2_command", KEY_O);
/*
PP.ckey [CKEY_UP] = get_config_int("Misc", "key_up", KEY_UP);
PP.ckey [CKEY_DOWN] = get_config_int("Misc", "key_down", KEY_DOWN);
PP.ckey [CKEY_LEFT] = get_config_int("Misc", "key_left", KEY_LEFT);
PP.ckey [CKEY_RIGHT] = get_config_int("Misc", "key_right", KEY_RIGHT);
PP.ckey [CKEY_FIRE1] = get_config_int("Misc", "key_fire1", KEY_Z);
PP.ckey [CKEY_FIRE2] = get_config_int("Misc", "key_fire2", KEY_X);
PP.ckey [CKEY_FIRE3] = get_config_int("Misc", "key_fire3", KEY_C);
PP.ckey [CKEY_FIRE4] = get_config_int("Misc", "key_fire4", KEY_V);
*/
/*
player[1].ckey [CKEY_UP] = get_config_int("MiscP2", "key_up", KEY_UP);
player[1].ckey [CKEY_DOWN] = get_config_int("MiscP2", "key_down", KEY_DOWN);
player[1].ckey [CKEY_LEFT] = get_config_int("MiscP2", "key_left", KEY_LEFT);
player[1].ckey [CKEY_RIGHT] = get_config_int("MiscP2", "key_right", KEY_RIGHT);
player[1].ckey [CKEY_LEFT2] = get_config_int("MiscP2", "key_left2", KEY_K);
player[1].ckey [CKEY_RIGHT2] = get_config_int("MiscP2", "key_right2", KEY_L);
player[1].ckey [CKEY_FIRE1] = get_config_int("MiscP2", "key_fire1", KEY_0_PAD);
player[1].ckey [CKEY_FIRE2] = get_config_int("MiscP2", "key_fire2", KEY_P);
player[1].ckey [CKEY_FIRE3] = get_config_int("MiscP2", "key_fire3", KEY_O);
player[1].ckey [CKEY_FIRE4] = get_config_int("MiscP2", "key_fire4", KEY_I);
options.joy_stick = get_config_int("Misc", "joy_stick", 0);
options.joy_sensitivity = get_config_int("Misc", "joy_sensitivity", 70);
options.init_joystick = get_config_int("Misc", "joy_init", 1);*/
// options.joystick = 0;
// options.key_or_joy = 0; // don't put in initfile!
options.sfx_volume = get_config_int("Misc", "sfx_volume", 70);
options.ambience_volume = get_config_int("Misc", "ambience_volume", 100);
options.run_vsync = get_config_int("Misc", "run_vsync", 0);
options.fix_camera_angle = get_config_int("Misc", "fix_camera_angle", 0);
options.joystick_dual = get_config_int("Misc", "joystick_dual", 1);
// set_config_int("Misc", "Tourist", 3);
// set_config_int("Misc", "joy_stick", 0);
// if (options.init_joystick)
// if (options.joystick == 1) // set in init_joystick
{
options.joy_button [0] [0] = get_config_int("Misc", "joy1_button_1", 0);
if (options.joy_button [0] [0] > joy[0].num_buttons)
options.joy_button [0] [0] = joy[0].num_buttons - 1;
options.joy_button [0] [1] = get_config_int("Misc", "joy1_button_2", 1);
if (options.joy_button [0] [1] > joy[0].num_buttons)
options.joy_button [0] [1] = joy[0].num_buttons - 1;
options.joy_button [0] [2] = get_config_int("Misc", "joy1_button_3", 2);
if (options.joy_button [0] [2] > joy[0].num_buttons)
options.joy_button [0] [2] = joy[0].num_buttons - 1;
options.joy_button [0] [3] = get_config_int("Misc", "joy1_button_4", 4);
if (options.joy_button [0] [3] > joy[0].num_buttons)
options.joy_button [0] [3] = joy[0].num_buttons - 1;
options.joy_button [0] [4] = get_config_int("Misc", "joy1_button_5", 5);
if (options.joy_button [0] [4] > joy[0].num_buttons)
options.joy_button [0] [4] = joy[0].num_buttons - 1;
options.joy_button [0] [5] = get_config_int("Misc", "joy1_button_6", 6);
if (options.joy_button [0] [5] > joy[0].num_buttons)
options.joy_button [0] [5] = joy[0].num_buttons - 1;
options.joy_button [1] [0] = get_config_int("Misc", "joy2_button_1", 0);
if (options.joy_button [1] [0] > joy[0].num_buttons)
options.joy_button [1] [0] = joy[0].num_buttons - 1;
options.joy_button [1] [1] = get_config_int("Misc", "joy2_button_2", 1);
if (options.joy_button [1] [1] > joy[0].num_buttons)
options.joy_button [1] [1] = joy[0].num_buttons - 1;
options.joy_button [1] [2] = get_config_int("Misc", "joy2_button_3", 2);
if (options.joy_button [1] [2] > joy[0].num_buttons)
options.joy_button [1] [2] = joy[0].num_buttons - 1;
options.joy_button [1] [3] = get_config_int("Misc", "joy2_button_4", 4);
if (options.joy_button [1] [3] > joy[0].num_buttons)
options.joy_button [1] [3] = joy[0].num_buttons - 1;
options.joy_button [1] [4] = get_config_int("Misc", "joy2_button_5", 5);
if (options.joy_button [1] [4] > joy[0].num_buttons)
options.joy_button [1] [4] = joy[0].num_buttons - 1;
options.joy_button [1] [5] = get_config_int("Misc", "joy2_button_6", 6);
if (options.joy_button [1] [5] > joy[0].num_buttons)
options.joy_button [1] [5] = joy[0].num_buttons - 1;
}
ticked = 0;
arena.players = 1;
// NOTE: it's assumed in a few places that if there's just one player, it's player[0].
}
/* show_mouse:
* Tells Allegro to display a mouse pointer. This only works when the timer
* module is active. The mouse pointer will be drawn onto the bitmap bmp,
* which should normally be the hardware screen. To turn off the mouse
* pointer, which you must do before you draw anything onto the screen, call
* show_mouse(NULL). If you forget to turn off the mouse pointer when
* drawing something, the SVGA bank switching code will become confused and
* will produce garbage all over the screen.
*/
void show_mouse(BITMAP *bmp)
{
if (!mouse_driver)
return;
remove_int(mouse_move);
/* Remove the mouse cursor */
if (_mouse_screen) {
acquire_bitmap(_mouse_screen);
if (gfx_capabilities & GFX_HW_CURSOR) {
gfx_driver->hide_mouse();
gfx_capabilities &= ~(GFX_HW_CURSOR|GFX_SYSTEM_CURSOR);
hw_cursor_dirty = TRUE;
}
else
draw_mouse(TRUE, FALSE);
release_bitmap(_mouse_screen);
}
_mouse_screen = bmp;
if (bmp && (current_cursor != MOUSE_CURSOR_NONE)) {
acquire_bitmap(_mouse_screen);
/* Default system cursor? */
if ((current_cursor != MOUSE_CURSOR_ALLEGRO) && allow_system_cursor) {
if (mouse_driver && mouse_driver->select_system_cursor) {
use_system_cursor = mouse_driver->select_system_cursor(current_cursor);
if (use_system_cursor) {
gfx_capabilities |= GFX_HW_CURSOR|GFX_SYSTEM_CURSOR;
hw_cursor_dirty = FALSE;
got_hw_cursor = TRUE;
}
}
}
else {
use_system_cursor = FALSE;
}
/* Custom hardware cursor? */
if (hw_cursor_dirty) {
got_hw_cursor = FALSE;
if ((gfx_driver) && (gfx_driver->set_mouse_sprite) && (!_dispsw_status))
if (gfx_driver->set_mouse_sprite(mouse_sprite, mouse_x_focus, mouse_y_focus) == 0)
got_hw_cursor = TRUE;
hw_cursor_dirty = FALSE;
}
/* Try to display hardware (custom or system) cursor */
if ((got_hw_cursor) && (is_same_bitmap(bmp, screen)))
if (gfx_driver->show_mouse(bmp, mx=mouse_x, my=mouse_y) == 0)
gfx_capabilities |= GFX_HW_CURSOR;
/* Draw cursor manually if we can't do that */
if (!(gfx_capabilities & GFX_HW_CURSOR)) {
draw_mouse(FALSE, TRUE);
use_system_cursor = FALSE;
}
release_bitmap(_mouse_screen);
install_int(mouse_move, 10);
}
else {
if (mouse_driver->timer_poll)
install_int(mouse_move, 10);
}
}
