bumpref.c

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

                 GL_RGB8,
                 w,
                 h,
                 0,
                 GL_RGB,
                 GL_UNSIGNED_BYTE,
                 sdata);*/
    } else {
        glTexImage2D(GL_TEXTURE_2D,
                     0,
                     GL_SIGNED_HILO16_NV,
                     w,
                     h,
                     0,
                     GL_HILO_NV,
                     GL_SHORT,
                     sdata);
    }

//    g_normalmap_bind = texbind;
    if(hilo){
        free(sdata);
    }

    return(texbind);
#else
    return(0);
#endif
}













BumpRefType bumpref_setup_vp_ts_rc(
                            char * map_name, double strength,
                            char * posx_name,
                            char * posy_name,
                            char * posz_name,
                            char * negx_name,
                            char * negy_name,
                            char * negz_name,
                            float zoffs, int hilo,
                            int texgen
                           )
/* dont call this 1st time inside a GL display list */
/* doesnt have any effect when called 1st */
{
#ifdef USE_NV_BUMPREF
    BumpRefType bumpref;
/*    static int init=0;
    static int bumpref_list;
    static int g_cubemap_bind=0;
    static int g_normalmap_bind=0;
    static unsigned int    vert_prog_bind;*/

    static unsigned char * vert_prog_str=
            "!!VP1.0 \n"
//            #
//            # c[0-3]  = modelview projection (composite) matrix
//            #           TrackMatrixNV(GL_VERTEX_PROGRAM_NV, 0, GL_MODELVIEW_PROJECTION_NV, GL_IDENTITY_NV);
//            # c[4-7]  = modelview transpose
//            #           TrackMatrixNV(GL_VERTEX_PROGRAM_NV, 0, GL_MODELVIEW, GL_INVERSE_TRANSPOSE_NV);
//            # c[8].z  = z offset for z-buffer
//            # c[8].x  = 0.0 ...to circumvent "ADD   R0.z,  R0.z, -R0.z"
//            #
//            # outputs homogenous position and surface basis + eye coord as texture coords
//            #
            /* R2 = mormal vector n */
            "MOV   R2, v[NRML];                      \n"
            /* R0 = xy tangent vector n_xy */
            "MOV   R0.x, -R2.y;                      \n"
            "MOV   R0.y,  R2.x;                      \n"
            "MOV   R0.z,  c[8].x;                    \n"
//            "ADD   R0.z,  R0.z, -R0.z;               \n"
//            "ADD   R0.z,  R0.z, -R0.z;  # R0.z=0 uarrghh \n"
               /* normalize */
            "MOV   R1, R0;                           \n"
            "DP3   R0.w, R1, R1;                     \n"
            "RSQ   R0.w, R0.w;                       \n"
            "MUL   R0.xyz, R1, R0.w;                 \n"
            /* R1 = other tangent vector n_t = n x n_xy */
            "MUL   R1, R2.zxyw, R0.yzxw;             \n"
            "MAD   R1, R2.yzxw, R0.zxyw, -R1;        \n"
            /*transpose of (n_xy, n_t, n) to (tex1, tex2, tex3)*/
            "MOV   o[TEX1].x, R0.x;                  \n"
            "MOV   o[TEX1].y, R1.x;                  \n"
            "MOV   o[TEX1].z, R2.x;                  \n"
            "MOV   o[TEX2].x, R0.y;                  \n"
            "MOV   o[TEX2].y, R1.y;                  \n"
            "MOV   o[TEX2].z, R2.y;                  \n"
            "MOV   o[TEX3].x, R0.z;                  \n"
            "MOV   o[TEX3].y, R1.z;                  \n"
            "MOV   o[TEX3].z, R2.z;                  \n"
            /* dont forget tex0 */
            "MOV   o[TEX0], v[TEX0];                 \n"
            /* R0=camdir=dist(cam,pos) */
            "ADD   R0, c[7], -v[OPOS];               \n"
            /* put this to 4th tex coord */
            "MOV   o[TEX1].w, R0.x;                  \n"
            "MOV   o[TEX2].w, R0.y;                  \n"
            "MOV   o[TEX3].w, R0.z;                  \n"
            /* propagate primary color */
            "MOV   o[COL0], v[COL0];                 \n"
            /* apply modelview + projection and add zbuffer-offset for correct multisampling */
            "DP4   o[HPOS].x, c[0], v[OPOS];         \n"
            "DP4   o[HPOS].y, c[1], v[OPOS];         \n"
            "DP4   R1.z,      c[2], v[OPOS];         \n"
            "DP4   o[HPOS].w, c[3], v[OPOS];         \n"
            /* add zbuffer-offset for correct multisampling */
            "ADD   o[HPOS].z, -c[8].z, R1.z;         \n"
            "END                                     \n";

    GLfloat t_gen_params[] = {1.0,0.0,0.0,0.0};
    GLfloat s_gen_params[] = {0.0,1.0,0.0,0.0};

    bumpref.texgen=texgen;
    {

        if ( bumpref.texgen ){
            glGenProgramsNV(1, &bumpref.vert_prog_bind);
            glBindProgramNV(GL_VERTEX_PROGRAM_NV, bumpref.vert_prog_bind);
            glLoadProgramNV(GL_VERTEX_PROGRAM_NV, bumpref.vert_prog_bind, strlen(vert_prog_str), vert_prog_str);
        }

#if 1
        bumpref.bumpref_list = glGenLists(1);
        glNewList(bumpref.bumpref_list, GL_COMPILE);

        /*vertex program*/
        glTrackMatrixNV(GL_VERTEX_PROGRAM_NV, 0 /* c[0..3] */, GL_MODELVIEW_PROJECTION_NV, GL_IDENTITY_NV);
        glTrackMatrixNV(GL_VERTEX_PROGRAM_NV, 4 /* c[4..7] */, GL_MODELVIEW, GL_INVERSE_TRANSPOSE_NV /*GL_IDENTITY_NV*/);
        glProgramParameter4fNV( GL_VERTEX_PROGRAM_NV, 8, /* c[8] */
                               0.0,     /* needed by vertex prog as constant 0.0 */
                               1.0,     /* dummy - not used */
                               zoffs,   /* z-shift for correct zbuffering when multisampling */
                               1.0      /* dummy - not used */
                              );
        glBindProgramNV(GL_VERTEX_PROGRAM_NV, bumpref.vert_prog_bind);

        /* texture shader */
        glActiveTextureARB(GL_TEXTURE0_ARB);
        glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_TEXTURE_2D);
        glActiveTextureARB(GL_TEXTURE1_ARB);
        glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_DOT_PRODUCT_NV);
        if(!hilo) glTexEnvi(GL_TEXTURE_SHADER_NV, GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV, GL_EXPAND_NORMAL_NV);
        glTexEnvi(GL_TEXTURE_SHADER_NV, GL_PREVIOUS_TEXTURE_INPUT_NV, GL_TEXTURE0_ARB);
        glActiveTextureARB(GL_TEXTURE2_ARB);
        glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_DOT_PRODUCT_NV);
        if(!hilo) glTexEnvi(GL_TEXTURE_SHADER_NV, GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV, GL_EXPAND_NORMAL_NV);
        glTexEnvi(GL_TEXTURE_SHADER_NV, GL_PREVIOUS_TEXTURE_INPUT_NV, GL_TEXTURE0_ARB);
        glActiveTextureARB(GL_TEXTURE3_ARB);
        glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV);
        if(!hilo) glTexEnvi(GL_TEXTURE_SHADER_NV, GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV, GL_EXPAND_NORMAL_NV);
        glTexEnvi(GL_TEXTURE_SHADER_NV, GL_PREVIOUS_TEXTURE_INPUT_NV, GL_TEXTURE0_ARB);
        glActiveTextureARB(GL_TEXTURE0_ARB);

        glCombinerParameteriNV(GL_NUM_GENERAL_COMBINERS_NV,0);
        glCombinerOutputNV(GL_COMBINER0_NV,
                           GL_RGB,
                           GL_DISCARD_NV,
                           GL_DISCARD_NV,
                           GL_DISCARD_NV /* sum */,
                           GL_NONE /* scale */,
                           GL_NONE /* bias */,
                           GL_FALSE /* dotprod ab */,
                           GL_FALSE /* dotprod cd */,
                           GL_FALSE /* sum discarded anyway */);
        glCombinerOutputNV(GL_COMBINER1_NV,
                           GL_RGB,
                           GL_DISCARD_NV,
                           GL_DISCARD_NV,
                           GL_DISCARD_NV /* sum */,
                           GL_NONE /* scale */,
                           GL_NONE /* bias */,
                           GL_FALSE /* dotprod ab */,
                           GL_FALSE /* dotprod cd */,
                           GL_FALSE /* sum discarded anyway */);
        glCombinerOutputNV(GL_COMBINER2_NV,
                           GL_RGB,
                           GL_DISCARD_NV,
                           GL_DISCARD_NV,
                           GL_DISCARD_NV /* sum */,
                           GL_NONE /* scale */,
                           GL_NONE /* bias */,
                           GL_FALSE /* dotprod ab */,
                           GL_FALSE /* dotprod cd */,
                           GL_FALSE /* sum discarded anyway */);
        glFinalCombinerInputNV(GL_VARIABLE_A_NV,
//                               GL_ZERO,
                               GL_TEXTURE3_ARB,
//                               GL_PRIMARY_COLOR_NV,
                               GL_UNSIGNED_IDENTITY_NV,
                               GL_RGB);
        glFinalCombinerInputNV(GL_VARIABLE_B_NV,
//                               GL_ZERO,
                               GL_PRIMARY_COLOR_NV,
                               GL_UNSIGNED_IDENTITY_NV,
                               GL_RGB);
        glFinalCombinerInputNV(GL_VARIABLE_C_NV,
                               GL_ZERO,
                               GL_UNSIGNED_IDENTITY_NV,
                               GL_RGB);
        glFinalCombinerInputNV(GL_VARIABLE_D_NV,
                               GL_ZERO,
//                               GL_TEXTURE3_ARB,
                               GL_UNSIGNED_IDENTITY_NV,
                               GL_RGB);
        glFinalCombinerInputNV(GL_VARIABLE_G_NV,
                               GL_ZERO,
                               GL_UNSIGNED_INVERT_NV,
                               GL_ALPHA);

        glEndList();
#endif

        bumpref.normalmap_bind = bumpref_create_bumpmap( map_name, strength, hilo );
        bumpref.cubemap_bind   = bumpref_create_cubemap( posx_name, posy_name, posz_name, negx_name, negy_name, negz_name );
        bumpref.init=1;
    }

    return bumpref ;
#endif /* ifdef USE_NV_BUMPREF */
}

void bumpref_use(BumpRefType * bumpref)
{
#ifdef USE_NV_BUMPREF
    if(bumpref->init){
//        glCombinerParameteriNV(GL_NUM_GENERAL_COMBINERS_NV,0);
        glCallList(bumpref->bumpref_list);

        glEnable(GL_REGISTER_COMBINERS_NV);
        glEnable(GL_TEXTURE_SHADER_NV);
        if(bumpref->texgen){
            glEnable(GL_VERTEX_PROGRAM_NV);
        }

        /* normalmap to tex0 */
        glActiveTextureARB(GL_TEXTURE0_ARB);
        //    glEnable(GL_TEXTURE_2D);
        glBindTexture(GL_TEXTURE_2D, bumpref->normalmap_bind);
        /*    glEnable(GL_TEXTURE_GEN_S);
         glEnable(GL_TEXTURE_GEN_T);
         glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
         glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
         glTexGenfv(GL_S, GL_OBJECT_PLANE, s_gen_params);
         glTexGenfv(GL_T, GL_OBJECT_PLANE, t_gen_params);*/

        /* cubemap to tex3 */
        glActiveTextureARB(GL_TEXTURE3_ARB);
        //    glEnable(GL_TEXTURE_CUBE_MAP_ARB);
        glBindTexture(GL_TEXTURE_CUBE_MAP_ARB, bumpref->cubemap_bind);
        /*    glEnable(GL_TEXTURE_GEN_S);
         glEnable(GL_TEXTURE_GEN_T);
         glEnable(GL_TEXTURE_GEN_R);
         glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_ARB);
         glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_ARB);
         glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_ARB);*/

        //    glGetFloatv(GL_MODELVIEW_MATRIX, texmat);
        /* maybe set this per ball to camaera direction */
        //    texmat[12]=0.0;
        //    texmat[13]=0.0;
        //    texmat[14]=0.0;
        /* transpose */
        //    dummy=texmat[1]; texmat[1]=texmat[4]; texmat[4]=dummy;
        //    dummy=texmat[2]; texmat[2]=texmat[8]; texmat[8]=dummy;
        //    du^mmy=texmat[6]; texmat[6]=texmat[9]; texmat[9]=dummy;
        //    glMatrixMode(GL_TEXTURE);
        //    glLoadMatrixf(texmat);
        //    glMatrixMode(GL_MODELVIEW);

        glActiveTextureARB(GL_TEXTURE0_ARB);
/*        glPolygonOffset( 0.0, -2.0 );
        glEnable( GL_POLYGON_OFFSET_FILL );*/
    }


#endif /* ifdef USE_NV_BUMPREF */
}



void bumpref_restore()
{
#ifdef USE_NV_BUMPREF
    glDisable(GL_REGISTER_COMBINERS_NV);
    glDisable(GL_TEXTURE_SHADER_NV);
    glDisable(GL_VERTEX_PROGRAM_NV);

    glActiveTextureARB(GL_TEXTURE3_ARB);
    glDisable(GL_TEXTURE_CUBE_MAP_ARB);
    glDisable(GL_TEXTURE_2D);
    glActiveTextureARB(GL_TEXTURE2_ARB);
    glDisable(GL_TEXTURE_CUBE_MAP_ARB);
    glDisable(GL_TEXTURE_2D);
    glActiveTextureARB(GL_TEXTURE1_ARB);