table.c

这是一个相当棒的Linux下的台球游戏

/* table.c
**
**    create the billard-table display lists
**    Copyright (C) 2001  Florian Berger
**    Email:  [e-mail],  [e-mail]
**
**    This program is free software; you can redistribute it and/or modify
**    it under the terms of the GNU General Public License Version 2 as
**    published by the Free Software Foundation;
**
**    This program is distributed in the hope that it will be useful,
**    but WITHOUT ANY WARRANTY; without even the implied warranty of
**    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**    GNU General Public License for more details.
**
**    You should have received a copy of the GNU General Public License
**    along with this program; if not, write to the Free Software
**    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
**
*/

#include <math.h>
#include <stdlib.h>
#include <stdio.h>
#include <GL/glu.h>
#include <GL/gl.h>
#include "billard.h"
#include "table.h"
#include "options.h"
#include "png_loader.h"
#include "bumpref.h"



void my_glBox( float x1, float y1, float z1,
               float x2, float y2, float z2 )
{
    float dummy;

    if( x1 > x2 ){ dummy=x1; x1=x2; x2=dummy; }
    if( y1 > y2 ){ dummy=y1; y1=y2; y2=dummy; }
    if( z1 > z2 ){ dummy=z1; z1=z2; z2=dummy; }
    
    glBegin(GL_QUADS);
    
       glNormal3f( 0.0, -1.0, 0.0 );
       glVertex3f(x1,y1,z1); glVertex3f(x1,y1,z2);
       glVertex3f(x2,y1,z2); glVertex3f(x2,y1,z1);

       glNormal3f( 1.0, 0.0, 0.0 );
       glVertex3f(x2,y1,z1); glVertex3f(x2,y1,z2);
       glVertex3f(x2,y2,z2); glVertex3f(x2,y2,z1);
       
       glNormal3f( 0.0, 1.0, 0.0 );
       glVertex3f(x2,y2,z1); glVertex3f(x2,y2,z2);
       glVertex3f(x1,y2,z2); glVertex3f(x1,y2,z1);

       glNormal3f( -1.0, 0.0, 0.0 );
       glVertex3f(x1,y2,z1); glVertex3f(x1,y2,z2);
       glVertex3f(x1,y1,z2); glVertex3f(x1,y1,z1);

       glNormal3f( 0.0, 0.0, -1.0 );
       glVertex3f(x1,y1,z1); glVertex3f(x2,y1,z1);
       glVertex3f(x2,y2,z1); glVertex3f(x1,y2,z1);
       
       glNormal3f( 0.0, 0.0, 1.0 );
       glVertex3f(x1,y1,z2); glVertex3f(x1,y2,z2);
       glVertex3f(x2,y2,z2); glVertex3f(x2,y1,z2);
       
    glEnd();

}


void autonormalize_quad( VMvect v1, VMvect v2, VMvect v3, VMvect v4, int order )
{
    VMvect n;
    n=vec_unit(vec_cross(vec_diff(v2,v1),vec_diff(v3,v1)));
    glNormal3f( n.x, n.y, n.z );
    if( !order ) {
        glVertex3f(v4.x,v4.y,v4.z);
        glVertex3f(v3.x,v3.y,v3.z);
        glVertex3f(v2.x,v2.y,v2.z);
        glVertex3f(v1.x,v1.y,v1.z);
    } else {
        glVertex3f(v1.x,v1.y,v1.z);
        glVertex3f(v2.x,v2.y,v2.z);
        glVertex3f(v3.x,v3.y,v3.z);
        glVertex3f(v4.x,v4.y,v4.z);
    }
}


void autonormalize_triangle( VMvect v1, VMvect v2, VMvect v3, int order )
{
    VMvect n;
    n=vec_unit(vec_cross(vec_diff(v2,v1),vec_diff(v3,v1)));
    if( !order ) {
        glNormal3f( n.x, n.y, n.z );
        glVertex3f(v3.x,v3.y,v3.z);
        glNormal3f( n.x, n.y, n.z );
        glVertex3f(v2.x,v2.y,v2.z);
        glNormal3f( n.x, n.y, n.z );
        glVertex3f(v1.x,v1.y,v1.z);
    } else {
        glNormal3f( n.x, n.y, n.z );
        glVertex3f(v1.x,v1.y,v1.z);
        glNormal3f( n.x, n.y, n.z );
        glVertex3f(v2.x,v2.y,v2.z);
        glNormal3f( n.x, n.y, n.z );
        glVertex3f(v3.x,v3.y,v3.z);
    }
}


void autonormalize_triangle_round( VMvect v1, VMvect v2, VMvect v3, int order, double round )
{
    VMvect n0,c,n;
    n0=vec_cross(vec_diff(v2,v1),vec_diff(v3,v1));
    c=tri_center(v1,v2,v3);
    if( !order ) {
        n=vec_unit(vec_add(n0,vec_scale(vec_diff(v3,c),round))); glNormal3f( n.x, n.y, n.z );
        glVertex3f(v3.x,v3.y,v3.z);
        n=vec_unit(vec_add(n0,vec_scale(vec_diff(v2,c),round))); glNormal3f( n.x, n.y, n.z );
        glVertex3f(v2.x,v2.y,v2.z);
        n=vec_unit(vec_add(n0,vec_scale(vec_diff(v1,c),round))); glNormal3f( n.x, n.y, n.z );
        glVertex3f(v1.x,v1.y,v1.z);
    } else {
        n=vec_unit(vec_add(n0,vec_scale(vec_diff(v1,c),round))); glNormal3f( n.x, n.y, n.z );
        glVertex3f(v1.x,v1.y,v1.z);
        n=vec_unit(vec_add(n0,vec_scale(vec_diff(v2,c),round))); glNormal3f( n.x, n.y, n.z );
        glVertex3f(v2.x,v2.y,v2.z);
        n=vec_unit(vec_add(n0,vec_scale(vec_diff(v3,c),round))); glNormal3f( n.x, n.y, n.z );
        glVertex3f(v3.x,v3.y,v3.z);
    }
}


void my_Diamondxy( float wx, float wy, float h, int order )
{
    VMvect p[10];
    p[3] = vec_xyz( -wx, 0.0, 0.0 );
    p[2] = vec_xyz( 0.0,  wy, 0.0 );
    p[1] = vec_xyz(  wx, 0.0, 0.0 );
    p[0] = vec_xyz( 0.0, -wy, 0.0 );
    p[4] = vec_xyz( 0.0, 0.0,   h );

    glBegin(GL_TRIANGLES);
       autonormalize_triangle_round(p[0],p[1],p[4],order,-0.002);
       autonormalize_triangle_round(p[1],p[2],p[4],order,-0.002);
       autonormalize_triangle_round(p[2],p[3],p[4],order,-0.002);
       autonormalize_triangle_round(p[3],p[0],p[4],order,-0.002);
    glEnd();
}


void my_Rectxy( float x1, float y1, float z1,    /* inside up */
                float x2, float y2, float z2,
                int fall_x, int order )   /* outside down */
{
    VMvect p[10];

    if(fall_x){
        p[0]=vec_xyz(x1,y1,z1);
        p[1]=vec_xyz(x1,y2,z1);
        p[2]=vec_xyz(x2,y2,z2);
        p[3]=vec_xyz(x2,y1,z2);
        glBegin(GL_QUADS);
          autonormalize_quad(p[0],p[1],p[2],p[3],order);
        glEnd();
    } else {
        p[0]=vec_xyz(x1,y1,z1);
        p[1]=vec_xyz(x1,y2,z2);
        p[2]=vec_xyz(x2,y2,z2);
        p[3]=vec_xyz(x2,y1,z1);
        glBegin(GL_QUADS);
          autonormalize_quad(p[3],p[2],p[1],p[0],!order);
        glEnd();
    }
}


double r1func( double phi )
{
    double phi1, rval;
//    return(HOLE1_W/SQR2);
//    return(HOLE1_W/SQR2+(1.0-pow((phi-M_PI/4.0)/M_PI*4.0,2))*0.02);
//    return(HOLE1_R*SQR2+(1.0-pow((phi-M_PI/4.0)/M_PI*4.0,2))*0.03);
    phi1=atan(HOLE1_XYOFFS/(HOLE1_R*SQR2+HOLE1_XYOFFS));
    if(phi<phi1){
        rval=HOLE1_R/cos(phi+M_PI/4.0);
    } else if (phi>M_PI/2.0-phi1){
        rval=HOLE1_R/cos(M_PI/2.0-phi+M_PI/4.0);
    } else {
        rval=HOLE1_R/cos(phi1+M_PI/4.0)+0.7*HOLE1_R*sin((phi-phi1)/(M_PI/2-phi1-phi1)*M_PI);
    }
    return(rval);
}


double r2func( double phi )
{
    double phi1, rval;
//    return(HOLE1_W/SQR2+FRAME_D-BANDE_D);
//    return(HOLE1_R*SQR2-BANDE_D+FRAME_D);
    phi1=M_PI/8.0;
    if(phi<phi1){
        rval=(HOLE1_R*SQR2-BANDE_D+FRAME_D)/cos(phi);
    } else if (phi>M_PI/2.0-phi1){
        rval=(HOLE1_R*SQR2-BANDE_D+FRAME_D)/cos(M_PI/2.0-phi);
    } else {
        rval=(HOLE1_R*SQR2-BANDE_D+FRAME_D)/cos(phi1);

    }
    return(rval);
}


void my_Edge( int segnr, double  (*r1)(double), double (*r2)(double), int order )
/* edge shows to positive x,y direction*/
{
    int i;
    double phi1,phi2,dphi1,dphi2;
    VMvect n00,n10,n20,n30,n40,n0,n1,n2,n3,n4,n5,n6,n7,n8,n9,v0,v1,v2,v3,v4,v5,v6,v7,v8,v9, v8_2,v8_3, v4_2,v4_3;
    n00 = vec_xyz(-1,0,0);
    n10 = vec_xyz(0,0,1);
    n20 = vec_unit(vec_xyz(FRAME_DH,0,FRAME_D-BANDE_D-FRAME_PHASE));
    n30 = vec_unit(vec_xyz(FRAME_H-FRAME_PHASE,0,-FRAME_PHASE));
    n40 = vec_unit(vec_xyz(FRAME_H-FRAME_PHASE,0,-FRAME_PHASE));
    for(i=0;i<segnr;i++){
        phi1 = M_PI/2.0*(double)i/(double)segnr;
        phi2 = M_PI/2.0*(double)(i+1)/(double)segnr;
        dphi1 = atan((r2(phi1-0.01)-r2(phi1+0.01))/r2(phi1)/0.02);
        dphi2 = atan((r2(phi2-0.01)-r2(phi2+0.01))/r2(phi2)/0.02);
        n0 = vec_rotate(n00,vec_xyz(0,0,phi1+dphi1));
        v0 = vec_xyz(r1(phi1)*cos(phi1),r1(phi1)*sin(phi1),FRAME_DH-0.006);
        n1 = vec_rotate(n10,vec_xyz(0,0,phi1+dphi1));
        v1 = vec_xyz(r1(phi1)*cos(phi1),r1(phi1)*sin(phi1),FRAME_DH);
        n2 = vec_rotate(n20,vec_xyz(0,0,phi1+dphi1));
        v2 = vec_xyz((r2(phi1)-FRAME_PHASE)*cos(phi1),(r2(phi1)-FRAME_PHASE)*sin(phi1),0);
        n3 = vec_rotate(n30,vec_xyz(0,0,phi1+dphi1));
        v3 = vec_xyz(r2(phi1)*cos(phi1),r2(phi1)*sin(phi1),-FRAME_PHASE);
        n4 = vec_rotate(n40,vec_xyz(0,0,phi1+dphi1));
        v4 = vec_xyz((r2(phi1)-FRAME_PHASE)*cos(phi1),(r2(phi1)-FRAME_PHASE)*sin(phi1),-FRAME_H);
        v4_2 = vec_xyz((r2(phi1)-FRAME_PHASE-FRAME_DW)*cos(phi1),(r2(phi1)-FRAME_PHASE-FRAME_DW)*sin(phi1),-FRAME_H);
        v4_3 = vec_xyz((r2(phi1)-FRAME_PHASE-2.0*FRAME_DW)*cos(phi1),(r2(phi1)-FRAME_PHASE-2.0*FRAME_DW)*sin(phi1),-FRAME_H2);
        n5 = vec_rotate(n10,vec_xyz(0,0,phi2+dphi2));
        v5 = vec_xyz(r1(phi2)*cos(phi2),r1(phi2)*sin(phi2),FRAME_DH);
        n6 = vec_rotate(n20,vec_xyz(0,0,phi2+dphi2));
        v6 = vec_xyz((r2(phi2)-FRAME_PHASE)*cos(phi2),(r2(phi2)-FRAME_PHASE)*sin(phi2),0);
        n7 = vec_rotate(n30,vec_xyz(0,0,phi2+dphi2));
        v7 = vec_xyz(r2(phi2)*cos(phi2),r2(phi2)*sin(phi2),-FRAME_PHASE);
        n8 = vec_rotate(n40,vec_xyz(0,0,phi2+dphi2));
        v8 = vec_xyz((r2(phi2)-FRAME_PHASE)*cos(phi2),(r2(phi2)-FRAME_PHASE)*sin(phi2),-FRAME_H);
        v8_2 = vec_xyz((r2(phi2)-FRAME_PHASE-FRAME_DW)*cos(phi2),(r2(phi2)-FRAME_PHASE-FRAME_DW)*sin(phi2),-FRAME_H);
        v8_3 = vec_xyz((r2(phi2)-FRAME_PHASE-2.0*FRAME_DW)*cos(phi2),(r2(phi2)-FRAME_PHASE-2.0*FRAME_DW)*sin(phi2),-FRAME_H2);
        n9 = vec_rotate(n00,vec_xyz(0,0,phi2+dphi2));
        v9 = vec_xyz(r1(phi2)*cos(phi2),r1(phi2)*sin(phi2),FRAME_DH-0.006);
        if(!order){
#define FACT 8.0
            glBegin(GL_QUAD_STRIP);
/*            glNormal3f(n0.x,n0.y,n0.z);
            glVertex3f(v0.x,v0.y,v0.z);
            glNormal3f(n9.x,n9.y,n9.z);
            glVertex3f(v9.x,v9.y,v9.z);*/
//            glTexCoord2f(v1.x*FACT,v1.y*FACT);
            glTexCoord2f(phi1/M_PI*2.0, 0.0*0.5);
            glNormal3f(n1.x,n1.y,n1.z);
            glVertex3f(v1.x,v1.y,v1.z);
//            glTexCoord2f(v5.x*FACT,v5.y*FACT);
            glTexCoord2f(phi2/M_PI*2.0, 0.0*0.5);
            glNormal3f(n5.x,n5.y,n5.z);
            glVertex3f(v5.x,v5.y,v5.z);
//            glTexCoord2f(v2.x*FACT,v2.y*FACT);
            glTexCoord2f(phi1/M_PI*2.0, 0.9*0.5);
            glNormal3f(n2.x,n2.y,n2.z);
            glVertex3f(v2.x,v2.y,v2.z);
//            glTexCoord2f(v6.x*FACT,v6.y*FACT);
            glTexCoord2f(phi2/M_PI*2.0, 0.9*0.5);
            glNormal3f(n6.x,n6.y,n6.z);
            glVertex3f(v6.x,v6.y,v6.z);
//            glTexCoord2f(v3.x*FACT,v3.y*FACT);
            glTexCoord2f(phi1/M_PI*2.0, 1.0*0.5);
            glNormal3f(n3.x,n3.y,n3.z);
            glVertex3f(v3.x,v3.y,v3.z);
//            glTexCoord2f(v7.x*FACT,v7.y*FACT);
            glTexCoord2f(phi2/M_PI*2.0, 1.0*0.5);
            glNormal3f(n7.x,n7.y,n7.z);
            glVertex3f(v7.x,v7.y,v7.z);
//            glTexCoord2f(v4.x*FACT,v4.y*FACT);
            glTexCoord2f(phi1/M_PI*2.0, 2.0*0.5);
            glNormal3f(n4.x,n4.y,n4.z);
            glVertex3f(v4.x,v4.y,v4.z);
//            glTexCoord2f(v8.x*FACT,v8.y*FACT);
            glTexCoord2f(phi2/M_PI*2.0, 2.0*0.5);
            glNormal3f(n8.x,n8.y,n8.z);
            glVertex3f(v8.x,v8.y,v8.z);
//            glTexCoord2f(v4.x*FACT,v4.y*FACT);
            glTexCoord2f(phi1/M_PI*2.0, 2.0*0.5);
            glNormal3f(n4.x,n4.y,n4.z);
            glVertex3f(v4_2.x,v4_2.y,v4_2.z);
//            glTexCoord2f(v8.x*FACT,v8.y*FACT);
            glTexCoord2f(phi2/M_PI*2.0, 2.0*0.5);
            glNormal3f(n8.x,n8.y,n8.z);
            glVertex3f(v8_2.x,v8_2.y,v8_2.z);
//            glTexCoord2f(v4.x*FACT,v4.y*FACT);
            glTexCoord2f(phi1/M_PI*2.0, 3.0*0.5);
            glNormal3f(n4.x,n4.y,n4.z);
            glVertex3f(v4_3.x,v4_3.y,v4_3.z);
//            glTexCoord2f(v8.x*FACT,v8.y*FACT);
            glTexCoord2f(phi2/M_PI*2.0, 3.0*0.5);
            glNormal3f(n8.x,n8.y,n8.z);
            glVertex3f(v8_3.x,v8_3.y,v8_3.z);
            glEnd();
        } else {
            glBegin(GL_QUAD_STRIP);
/*            glNormal3f(n9.x,n9.y,n9.z);
            glVertex3f(v9.x,v9.y,v9.z);
            glNormal3f(n0.x,n0.y,n0.z);
            glVertex3f(v0.x,v0.y,v0.z);*/
//            glTexCoord2f(v5.x*FACT,v5.y*FACT);
            glTexCoord2f(1.0-phi2/M_PI*2.0, 0.0*0.5);