vertexblending.c

OpeNGL超级宝典源代码. OpeNGL超级宝典源代码.

        // Take upper left 3x3 for 2nd normal matrix
        for (i = 0; i < 9; i++)
        {
            mv2IT_3x3[i] = mv2IT_4x4[((i/3)*4)+(i%3)];
        }
        glUniformMatrix3fvARB(mv2ITLoc, 1, GL_TRUE, mv2IT_3x3);
    }
    else
    {
        glMatrixMode(GL_MATRIX0_ARB);
        glLoadMatrixf(mv2);
        glMatrixMode(GL_MODELVIEW);
    }

    // Draw forearm cylinder
    glColor3f(0.9f, 0.0f, 0.0f);       // Red
    // 40 long, 9 elbow, 5 wrist, with weights applied to first half
    DrawCylinder(40.0f, 9.0f, 5.0f, 0.5f, 1.0f);
}

// Called to draw scene
void RenderScene(void)
{
    // Track camera angle
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(45.0f, 1.0f, 1.0f, 1000.0f);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    gluLookAt(cameraPos[0], cameraPos[1], cameraPos[2], 
              0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f);
    glViewport(0, 0, windowWidth, windowHeight);
    
    // Clear the window with current clearing color
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    // Validate our shader before first use
    if (needsValidation[0])
    {
        GLint success;

        glValidateProgramARB(progObj[0]);
        glGetObjectParameterivARB(progObj[0], GL_OBJECT_VALIDATE_STATUS_ARB, &success);
        if (!success)
        {
            GLbyte infoLog[MAX_INFO_LOG_SIZE];
            glGetInfoLogARB(progObj[0], MAX_INFO_LOG_SIZE, NULL, infoLog);
            fprintf(stderr, "Error in program validation!\n");
            fprintf(stderr, "Info log: %s\n", infoLog);
            Sleep(10000);
            exit(0);
        }

        needsValidation[0] = GL_FALSE;
    }
    
    // Draw objects in the scene
    DrawModels();
    
    if (glGetError() != GL_NO_ERROR)
        fprintf(stderr, "GL Error!\n");

    // Flush drawing commands
    glutSwapBuffers();
}

// This function does any needed initialization on the rendering
// context. 
void SetupRC()
{
    const GLubyte *version;
    GLint i;

    fprintf(stdout, "Vertex Blending Demo\n\n");

    // Make sure required functionality is available!
    if (gltIsExtSupported("GL_ARB_vertex_shader") &&
        gltIsExtSupported("GL_ARB_shader_objects") &&
        gltIsExtSupported("GL_ARB_shading_language_100"))
    {
        highLevelAvailable = GL_TRUE;
    }
    if (gltIsExtSupported("GL_ARB_vertex_program"))
    {
        lowLevelAvailable = GL_TRUE;
    }
    if (!lowLevelAvailable && !highLevelAvailable)
    {
        fprintf(stderr, "Neither vertex shader"
                        " extension is available!\n");
        Sleep(2000);
        exit(0);
    }

    // Make sure we have multitexture, cube maps, and texenv add!
    version = glGetString(GL_VERSION);
    if (((version[0] != '1') || (version[1] != '.') || 
         (version[2] < '3') || (version[2] > '9')) &&   // 1.3+
        (!gltIsExtSupported("GL_ARB_multitexture")     ||
         !gltIsExtSupported("GL_ARB_texture_env_add")))
    {
        fprintf(stderr, "Neither OpenGL 1.3 nor necessary"
                        " extensions are available!\n");
        Sleep(2000);
        exit(0);
    }

    glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTexSize);

    if (lowLevelAvailable)
    {
    #ifndef __APPLE__
        glGenProgramsARB = gltGetExtensionPointer("glGenProgramsARB");
        glBindProgramARB = gltGetExtensionPointer("glBindProgramARB");
        glProgramStringARB = gltGetExtensionPointer("glProgramStringARB");
        glDeleteProgramsARB = gltGetExtensionPointer("glDeleteProgramsARB");
        glProgramLocalParameter4fARB = gltGetExtensionPointer("glProgramLocalParameter4fARB");
        glProgramLocalParameter4fvARB = gltGetExtensionPointer("glProgramLocalParameter4fvARB");
        glVertexAttrib1fARB = gltGetExtensionPointer("glVertexAttrib1fARB");

        if (!glGenProgramsARB || !glBindProgramARB || 
            !glProgramStringARB || !glDeleteProgramsARB ||
            !glProgramLocalParameter4fARB || 
            !glProgramLocalParameter4fvARB || !glVertexAttrib1fARB)
        {
            fprintf(stderr, "Not all entrypoints were available!\n");
            Sleep(2000);
            exit(0);
        }
       #endif
    }

    if (highLevelAvailable)
    {
        glCreateShaderObjectARB = gltGetExtensionPointer("glCreateShaderObjectARB");
        glCreateProgramObjectARB = gltGetExtensionPointer("glCreateProgramObjectARB");
        glAttachObjectARB = gltGetExtensionPointer("glAttachObjectARB");
        glDetachObjectARB = gltGetExtensionPointer("glDetachObjectARB");
        glDeleteObjectARB = gltGetExtensionPointer("glDeleteObjectARB");
        glShaderSourceARB = gltGetExtensionPointer("glShaderSourceARB");
        glCompileShaderARB = gltGetExtensionPointer("glCompileShaderARB");
        glLinkProgramARB = gltGetExtensionPointer("glLinkProgramARB");
        glValidateProgramARB = gltGetExtensionPointer("glValidateProgramARB");
        glUseProgramObjectARB = gltGetExtensionPointer("glUseProgramObjectARB");
        glGetObjectParameterivARB = gltGetExtensionPointer("glGetObjectParameterivARB");
        glGetInfoLogARB = gltGetExtensionPointer("glGetInfoLogARB");
        glUniform3fvARB = gltGetExtensionPointer("glUniform3fvARB");
        glUniformMatrix3fvARB = gltGetExtensionPointer("glUniformMatrix3fvARB");
        glUniformMatrix4fvARB = gltGetExtensionPointer("glUniformMatrix4fvARB");
        #ifndef __APPLE__
        glVertexAttrib1fARB = gltGetExtensionPointer("glVertexAttrib1fARB");
        #endif
        glGetUniformLocationARB = gltGetExtensionPointer("glGetUniformLocationARB");
        glGetAttribLocationARB = gltGetExtensionPointer("glGetAttribLocationARB");

        if (!glCreateShaderObjectARB || !glCreateProgramObjectARB || 
            !glAttachObjectARB || !glDetachObjectARB || !glDeleteObjectARB || 
            !glShaderSourceARB || !glCompileShaderARB || !glLinkProgramARB ||
            !glValidateProgramARB || !glUseProgramObjectARB || 
            !glGetObjectParameterivARB || !glGetInfoLogARB || 
            !glUniformMatrix4fvARB || !glUniformMatrix4fvARB || 
            !glUniform3fvARB || 
            #ifndef __APPLE__
            !glVertexAttrib1fARB ||
            #endif
            !glGetUniformLocationARB || !glGetAttribLocationARB)
        {
            fprintf(stderr, "Not all entrypoints were available!\n");
            Sleep(2000);
            exit(0);
        }

        useHighLevel = GL_TRUE;
    }

    fprintf(stdout, "Controls:\n");
    fprintf(stdout, "\tRight-click for menu\n\n");
    fprintf(stdout, "\tL/R arrows\tChange sphere of influence\n");
    fprintf(stdout, "\tU/D arrows\tChange angle of forearm\n\n");
    fprintf(stdout, "\tx/X\t\tMove  +/- in x direction\n");
    fprintf(stdout, "\ty/Y\t\tMove  +/- in y direction\n");
    fprintf(stdout, "\tz/Z\t\tMove  +/- in z direction\n\n");
    fprintf(stdout, "\tq\t\tExit demo\n\n");
    
    // Black background
    glClearColor(0.0f, 0.0f, 0.0f, 1.0f );

    // Hidden surface removal
    glEnable(GL_DEPTH_TEST);
    glDepthFunc(GL_LEQUAL);

    // Misc.
    glShadeModel(GL_SMOOTH);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glPointSize(10.0f);
    glLineWidth(5.0f);

    // Texture state
    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_ADD);
    glBindTexture(GL_TEXTURE_1D, 0);
    glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP);
    CreatePowMap(1.0, 1.0, 1.0);
    glEnable(GL_TEXTURE_1D);

    if (lowLevelAvailable)
    {
        glGenProgramsARB(TOTAL_SHADERS, ids);
        // Low-level will always be enabled, but high-level 
        // will take precedence if they're both enabled
        glEnable(GL_VERTEX_PROGRAM_ARB);
    }

    // Load and compile low- and high-level shaders
    for (i = 0; i < TOTAL_SHADERS; i++)
    {
        PrepareShader(i);
    }

    // Install first shader
    if (lowLevelAvailable)
    {
        glBindProgramARB(GL_VERTEX_PROGRAM_ARB, ids[0]);
    }
    if (useHighLevel)
    {
        glUseProgramObjectARB(progObj[0]);
    }
}

void ProcessMenu(int value)
{
    switch(value)
    {
    case 1:
        useBlending = !useBlending;
        if (useBlending)
        {
            glutChangeToMenuEntry(1, "Toggle vertex blending (currently ON)", 1);
        }
        else
        {
            glutChangeToMenuEntry(1, "Toggle vertex blending (currently OFF)", 1);
        }
        break;

    case 2:
        showBones = !showBones;
        if (showBones)
        {
            glutChangeToMenuEntry(2, "Show bones (currently ON)", 2);
        }
        else
        {
            glutChangeToMenuEntry(2, "Show bones (currently OFF)", 2);
        }
        break;

    case 3:
        useHighLevel = !useHighLevel;
        if (useHighLevel)
        {
            glutChangeToMenuEntry(3, "Switch to low-level vertex shader", 3);
            glUseProgramObjectARB(progObj[0]);
        }
        else
        {
            glutChangeToMenuEntry(3, "Switch to high-level vertex shader", 3);
            glUseProgramObjectARB(0);
        }
        break;

    default:
        break;
    }

    // Refresh the Window
    glutPostRedisplay();
}

void KeyPressFunc(unsigned char key, int x, int y)
{
    switch (key)
    {
    case 'x':
        cameraPos[0] += 5.0f;
        break;
    case 'X':
        cameraPos[0] -= 5.0f;
        break;
    case 'y':
        cameraPos[1] += 5.0f;
        break;
    case 'Y':
        cameraPos[1] -= 5.0f;
        break;
    case 'z':
        cameraPos[2] += 5.0f;
        break;
    case 'Z':
        cameraPos[2] -= 5.0f;
        break;
    case 'q':
    case 'Q':
    case 27 : /* ESC */
        exit(0);
    }

    // Refresh the Window
    glutPostRedisplay();
}

void SpecialKeys(int key, int x, int y)
{
    switch (key)
    {
    case GLUT_KEY_LEFT:
        sphereOfInfluence -= 0.05f;
        if (sphereOfInfluence < 0.05f)
            sphereOfInfluence = 0.0f;
        break;
    case GLUT_KEY_RIGHT:
        sphereOfInfluence += 0.05f;
        if (sphereOfInfluence > 0.95f)
            sphereOfInfluence = 1.0f;
        break;
    case GLUT_KEY_UP:
        elbowBend += 5.0f;
        if (elbowBend > 150.0f)
            elbowBend = 150.0f;
        break;
    case GLUT_KEY_DOWN:
        elbowBend -= 5.0f;
        if (elbowBend < -150.0f)
            elbowBend = -150.0f;
        break;
    default:
        break;
    }

    // Refresh the Window
    glutPostRedisplay();
}

void ChangeSize(int w, int h)
{
    windowWidth = w;
    windowHeight = h;
}

int main(int argc, char* argv[])
{
    GLint i;

    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
    glutInitWindowSize(windowWidth, windowHeight);
    glutCreateWindow("Vertex Blending Demo");
    glutReshapeFunc(ChangeSize);
    glutKeyboardFunc(KeyPressFunc);
    glutSpecialFunc(SpecialKeys);
    glutDisplayFunc(RenderScene);

    SetupRC();

    // Create the menus
    mainMenu = glutCreateMenu(ProcessMenu);
    glutAddMenuEntry("Toggle vertex blending (currently ON)", 1);
    glutAddMenuEntry("Show bones (currently OFF)", 2);
    if (lowLevelAvailable && highLevelAvailable)
    {
        if (useHighLevel)
        {
            glutAddMenuEntry("Switch to low-level vertex shader", 3);
        }
        else
        {
            glutAddMenuEntry("Switch to high-level vertex shader", 3);
        }
    }
    glutAttachMenu(GLUT_RIGHT_BUTTON);

    glutMainLoop();

    if (glDeleteObjectARB)
    {
        for (i = 0; i < TOTAL_SHADERS; i++)
        {
            glDeleteObjectARB(progObj[i]);
            glDeleteObjectARB(vShader[i]);
        }
    }
    
#ifndef __APPLE__
    if (glDeleteProgramsARB)
    {
        glDeleteProgramsARB(TOTAL_SHADERS, ids);
    }
#endif

    return 0;
}