int main(void)
{
allegro_init();
install_timer();
install_keyboard();
rgb_map = malloc(sizeof(RGB_MAP));
create_rgb_table(rgb_map, desktop_palette, NULL);
set_gfx_mode(GFX_AUTODETECT, 320, 200, 0, 0);
buffer = create_bitmap(SCREEN_W, SCREEN_H);
set_projection_viewport(0, 0, SCREEN_W, SCREEN_H);
init_shape();
while (!key[KEY_ESC]) {
move_shape();
translate_shape();
vsync();
draw();
}
destroy_bitmap(buffer);
free(rgb_map);
allegro_exit();
return 0;
}
/* draw everything */
void render(BITMAP *bmp)
{
char buf[80];
MATRIX_f roller, camera;
int x, y, w, h;
float xfront, yfront, zfront;
float xup, yup, zup;
/* clear the background */
clear(bmp);
set_projection_viewport(0, 0, SCREEN_W, SCREEN_H);
/* calculate the in-front vector */
xfront = sin(heading) * cos(pitch);
yfront = sin(pitch);
zfront = cos(heading) * cos(pitch);
/* rotate the up vector around the in-front vector by the roll angle */
get_vector_rotation_matrix_f(&roller, xfront, yfront, zfront, roll*128.0/M_PI);
apply_matrix_f(&roller, 0, -1, 0, &xup, &yup, &zup);
/* build the camera matrix */
get_camera_matrix_f(&camera,
xpos, ypos, zpos, /* camera position */
xfront, yfront, zfront, /* in-front vector */
xup, yup, zup, /* up vector */
fov, /* field of view */
aspect); /* aspect ratio */
/* draw the grid of squares */
for (x=0; x<GRID_SIZE; x++)
for (y=0; y<GRID_SIZE; y++)
draw_square(bmp, &camera, x * TILE_SIZE, y * TILE_SIZE);
/* overlay some text */
set_clip_rect(bmp, 0, 0, bmp->w, bmp->h);
sprintf(buf, "Field of view: %d (f/F changes)", fov);
textout_ex(bmp, font, buf, 0, 16, 255, -1);
sprintf(buf, "Aspect ratio: %.2f (a/A changes)", aspect);
textout_ex(bmp, font, buf, 0, 24, 255, -1);
sprintf(buf, "X position: %.2f (x/X changes)", xpos);
textout_ex(bmp, font, buf, 0, 32, 255, -1);
sprintf(buf, "Y position: %.2f (y/Y changes)", ypos);
textout_ex(bmp, font, buf, 0, 40, 255, -1);
sprintf(buf, "Z position: %.2f (z/Z changes)", zpos);
textout_ex(bmp, font, buf, 0, 48, 255, -1);
sprintf(buf, "Heading: %.2f deg (left/right changes)", DEG(heading));
textout_ex(bmp, font, buf, 0, 56, 255, -1);
sprintf(buf, "Pitch: %.2f deg (pgup/pgdn changes)", DEG(pitch));
textout_ex(bmp, font, buf, 0, 64, 255, -1);
sprintf(buf, "Roll: %.2f deg (r/R changes)", DEG(roll));
textout_ex(bmp, font, buf, 0, 72, 255, -1);
sprintf(buf, "Front vector: %.2f, %.2f, %.2f", xfront, yfront, zfront);
textout_ex(bmp, font, buf, 0, 80, 255, -1);
sprintf(buf, "Up vector: %.2f, %.2f, %.2f", xup, yup, zup);
textout_ex(bmp, font, buf, 0, 88, 255, -1);
}
void init_camera(CAMERA *cam) { // init the camera
cam->incspeed = (float) (SCREEN_W) / 91.5;
cam->maxspeed = (float) (SCREEN_W) / 22.5;
cam->decspeed = cam->incspeed / 1.5;
cam->fov = 64;
cam->currentspeed.x = 0;
cam->currentspeed.y = 0;
cam->currentspeed.z = 0;
set_projection_viewport(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
}
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(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;
}
void TextureUtil::initGrx() {
Config * config = Config::getInstance();
#if EM_USE_SDL
cerr << "Initing SDL" << endl << endl;
if (SDL_InitSubSystem(SDL_INIT_VIDEO) < 0) {
cerr << "Couldn't initialize SDL video" << SDL_GetError() << endl;
exit(1);
}
if (SDL_InitSubSystem(SDL_INIT_JOYSTICK) < 0) {
cerr << "Couldn't initialize SDL joystick: " << SDL_GetError() << endl << endl;
} else {
int njoystick = SDL_NumJoysticks();
cerr << njoystick << " joysticks were found." << endl;
if (njoystick != 0) {
cerr << "The names of the joysticks are:" << endl;
for(int a=0; a<njoystick; a++ ) {
cerr << " " << SDL_JoystickName(a) << endl;
}
cerr << "Using " << SDL_JoystickName(0) << endl << endl;
SDL_JoystickOpen(0);
SDL_JoystickEventState(SDL_ENABLE);
}
}
// See if we should detect the display depth
if ( SDL_GetVideoInfo()->vfmt->BitsPerPixel <= 8 ) {
SDL_GL_SetAttribute( SDL_GL_RED_SIZE, 2 );
SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, 3 );
SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, 3 );
} else if ( SDL_GetVideoInfo()->vfmt->BitsPerPixel <= 16 ) {
SDL_GL_SetAttribute( SDL_GL_RED_SIZE, 5 );
SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, 5 );
SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, 5 );
} else {
SDL_GL_SetAttribute( SDL_GL_RED_SIZE, 8 );
SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, 8 );
SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, 8 );
}
SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, 16 );
SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
/* Initialize the display */
SDL_Surface* screen =
SDL_SetVideoMode(config->getWidth(), config->getHeight(), config->getBpp(),
SDL_OPENGL
| (config->useFullScreen() ? SDL_FULLSCREEN : 0));
// if (config->useFullScreen()) {
SDL_ShowCursor(SDL_DISABLE);
// }
SDL_WM_SetCaption("Emilia Pinball", NULL);
if (screen == NULL) {
cerr << "Couldn't set video mode: " << SDL_GetError() << endl;
exit(1);
}
cerr << "Vendor : " << glGetString( GL_VENDOR ) << endl;
cerr << "Renderer : " << glGetString( GL_RENDERER ) << endl;
cerr << "Version : " << glGetString( GL_VERSION ) << endl;
cerr << "Extensions : " << glGetString( GL_EXTENSIONS ) << endl << endl;
//TODO: that would be usefull to report CPU/RAM specs also //!rzr
int value;
SDL_GL_GetAttribute( SDL_GL_RED_SIZE, &value );
cerr << "SDL_GL_RED_SIZE: " << value << endl;
SDL_GL_GetAttribute( SDL_GL_GREEN_SIZE, &value );
cerr << "SDL_GL_GREEN_SIZE: " << value << endl;
SDL_GL_GetAttribute( SDL_GL_BLUE_SIZE, &value );
cerr << "SDL_GL_BLUE_SIZE: " << value << endl;
SDL_GL_GetAttribute( SDL_GL_DEPTH_SIZE, &value );
cerr << "SDL_GL_DEPTH_SIZE: " << value << endl;
SDL_GL_GetAttribute( SDL_GL_DOUBLEBUFFER, &value );
cerr << "SDL_GL_DOUBLEBUFFER: " << value << endl << endl;
this->resizeView(config->getWidth(), config->getHeight());
#endif // EM_USE_SDL
#if EM_USE_ALLEGRO
//config->setSize(320, 240);
allegro_init();
install_keyboard();
install_timer();
install_mouse();
COLOR_MAP colorMap;
RGB_MAP rgbMap;
COLOR_MAP transMap;
RGB* paPalette = (RGB*) calloc(256, sizeof(RGB));
generate_332_palette(paPalette);
// create rgb table
create_rgb_table(&rgbMap, paPalette, NULL);
rgb_map = &rgbMap;
// create light table and setup the truecolor blending functions.
create_light_table(&colorMap, paPalette, 0, 0, 0, NULL);
color_map = &colorMap;
// texture and flat polygons are 50% transparent
create_trans_table(&transMap, paPalette, 128, 128, 128, NULL);
set_trans_blender(0, 0, 0, 128);
// set the graphics mode
int tc = GFX_AUTODETECT_WINDOWED, tw = config->getWidth();
int th = config->getHeight(), tbpp = 16;
/*
set_gfx_mode(GFX_SAFE, 320, 200, 0, 0);
set_palette(desktop_palette);
if (!gfx_mode_select_ex(&tc, &tw, &th, &tbpp)) {
allegro_exit();
cerr << "Error setting safe graphics mode" << endl;
}
*/
set_color_depth(tbpp);
if (set_gfx_mode(tc, tw, th, 0, 0) != 0) {
allegro_exit();
cerr << "Error setting graphics mode " << endl << allegro_error << endl;
}
set_palette(paPalette);
config->setSize(tw, th);
set_projection_viewport(0, 0, tw, th);
// Create back buffer.
backbuffer = create_bitmap(tw, th);
clear(backbuffer);
zbuffer = create_zbuffer(backbuffer);
set_zbuffer(zbuffer);
clear_zbuffer(zbuffer, 0);
#endif // EM_USE_ALLEGRO
}
void view3d(MAPGEN &mapgen, float hflat, float lflat){
lc=0;
MAP map(mapgen,hflat,lflat);
BITMAP *buffer=create_bitmap(480,320);
ZBUFFER *zbuf=create_zbuffer(buffer);
set_zbuffer(zbuf);
MATRIX_f roller,camera;
// create_scene(4*(mapgen.size()*mapgen.size()), (mapgen.size()*mapgen.size()));
set_projection_viewport(0, 0, buffer->w, buffer->h);
float xfront, yfront, zfront;
float xup, yup, zup;
float heading=0,pitch=0,roll=0;
int fov=32;
float x=128,y=128,z=128;
float xs=0,ys=0,zs=0;
int fps=0,frames[101];
for(int i=0;i<101;i++)
frames[i]=0;
int mx,my,tc;
//To get rid of that annoying roll I reset mickeys.
get_mouse_mickeys(&mx,&my);
while(!(mouse_b || key[KEY_ESC])){
tc=lc;
lc=0;
while(!mouse_b && tc){
tc--;
fps-=frames[100];
for(int i=100;i>0;i--)
frames[i]=frames[i-1];
frames[0]=0;
fps+=frames[1];
/* if(key[KEY_Q])
y++;
if(key[KEY_Z])
y--;
if(key[KEY_W]){
x+=sin(heading);
z+=cos(heading);
}
if(key[KEY_S]){
x-=sin(heading);
z-=cos(heading);
}
if(key[KEY_A]){
x+=sin(heading+M_PI/2);
z+=cos(heading+M_PI/2);
}
if(key[KEY_D]){
x-=sin(heading+M_PI/2);
z-=cos(heading+M_PI/2);
}
*/
if(key[KEY_Q])
ys++;
if(key[KEY_Z])
ys--;
if(key[KEY_W]){
xs+=sin(heading);
zs+=cos(heading);
}
if(key[KEY_S]){
xs-=sin(heading);
zs-=cos(heading);
}
if(key[KEY_A]){
xs+=sin(heading+M_PI/2);
zs+=cos(heading+M_PI/2);
roll+=.02;
}
if(key[KEY_D]){
xs-=sin(heading+M_PI/2);
zs-=cos(heading+M_PI/2);
roll-=.02;
}
xs*=.99;
ys*=.9;
zs*=.99;
x+=xs;
y+=ys;
z+=zs;
get_mouse_mickeys(&mx,&my);
position_mouse(SCREEN_W/2,SCREEN_H/2);
heading-=mx/100.;
pitch-=my/100.;
if(pitch>M_PI/3) pitch=M_PI/3;
if(pitch<-M_PI/3) pitch=-M_PI/3;
roll-=mx/100.;
roll*=.95;
/* if(x>=0 && z>=0 && x/tilesize<mapgen.size() && z/tilesize<mapgen.size())
y=200+mapgen.heightmap()[int(x/tilesize)][int(z/tilesize)]*tilesize;
*/ }
/* calculate the in-front vector */
xfront = sin(heading) * cos(pitch);
yfront = sin(pitch);
zfront = cos(heading) * cos(pitch);
/* rotate the up vector around the in-front vector by the roll angle */
get_vector_rotation_matrix_f(&roller, xfront, yfront, zfront, roll*128.0/M_PI);
apply_matrix_f(&roller, 0, 1, 0, &xup, &yup, &zup);
/* build the camera matrix */
get_camera_matrix_f(&camera, x, y, z, xfront, yfront, zfront, xup, yup, zup, fov, 1);
polys_drawn=0;
clear_bitmap(buffer);
// clear_scene(buffer);
clear_zbuffer(zbuf,0);
map.render(buffer,&camera,int(x),int(y));
// render_scene();
textprintf_ex(buffer,font,8,8,-1,-1,"FPS: %i",fps);
textprintf_ex(buffer,font,8,16,-1,-1,"Polygon count: %i",polys_drawn);
blit(buffer, screen, 0, 0, 280, 8, buffer->w, buffer->h);
frames[0]++;
}
destroy_bitmap(buffer);
destroy_zbuffer(zbuf);
// destroy_scene();
while(mouse_b || key[KEY_ESC]);
clear_keybuf();
}
