ライティング インタフェース

class hwPhongShaderOverride : public MHWRender::MPxShaderOverride
{
protected:
    // Color shader
    MHWRender::MShaderInstance *fColorShaderInstance;
    // Shadow shader
    MHWRender::MShaderInstance *fShadowShaderInstance;
    
public:
    void createShaderInstance()
    {
        MHWRender::MRenderer *renderer = MHWRender::MRenderer::theRenderer();
        const MHWRender::MShaderManager* shaderMgr = renderer->getShaderManager();

        // If no shadow shader instance created yet acquire one. Use
        // the stock shadow shader provided.
        if (!fShadowShaderInstance)
        {
            fShadowShaderInstance = 
                shaderMgr->getStockShader( MHWRender::MShaderManager::k3dShadowerShader );
        }

        // If no color shader instance created yet acquire one. For
        // now it's just using an internal shader for convenience but
        // a custom shader could be written here as well.
        if (!fColorShaderInstance)
        {
            fColorShaderInstance = 
                shaderMgr->getStockShader( MHWRender::MShaderManager::k3dBlinnShader );
        }
    }
    
    /* virtual */ void activateKey(MHWRender::MDrawContext& context, const MString& key)
    {
        // Bind color or shadower shader as appropriate
        if (fInColorPass)
            fColorShaderInstance->bind( context );
        else if (fInShadowPass)
        {
            // Update the parameters on the shadow shader. Use the view projection 
            // matrix from the active context
            MMatrix viewProj =                                     
                context.getMatrix(MHWRender::MDrawContext::kViewProjMtx);
            fShadowShaderInstance->setParameter("shadowViewProj", viewProj );
            fShadowShaderInstance->bind( context );
        }
    }
    
    // Example of using MShaderInstace to draw. Terminate
    // the shader instance here.
    /* virtual */ void terminateKey(MHWRender::MDrawContext& context, const MString& key)
    {
        if (fInColorPass)
            fColorShaderInstance->unbind( context );
        else if (fInShadowPass)
            fShadowShaderInstance->unbind( context );
    }
    
    /* virtual */ bool draw(MHWRender::MDrawContext& context,
                       const MHWRender::MRenderItemList& renderItemList) const
    {
        // Draw for color pass with a blend state change
        if (fInColorPass)
        {
            stateMgr->setBlendState(sBlendState);
            unsigned int passCount = fColorShaderInstance->getPassCount( context );
            for (unsigned int i=0; i<passCount; i++)
            {
                fColorShaderInstance->activatePass( context, i );
                MHWRender::MPxShaderOverride::drawGeometry(context);
            }
            stateMgr->setBlendState(pOldBlendState);
        }
        // Draw for shadow pass
        else if (fInShadowPass)
        {
            unsigned int passCount = fShadowShaderInstance->getPassCount( context );
            for (unsigned int i=0; i<passCount; i++)
            {
                fShadowShaderInstance->activatePass( context, i );
                MHWRender::MPxShaderOverride::drawGeometry(context);
            }
        }
    }
}

MStatus status;

// Take into account only the 8 lights supported by the basic
// OpenGL profile.
const unsigned int nbLights =
    std::min(context.numberOfActiveLights(&status), 8u);
if (status != MStatus::kSuccess) return false;

if (nbLights > 0) {
    // Lights are specified in world space and needs to be
    // converted to view space.
    const MMatrix worldToView =
        context.getMatrix(MHWRender::MFrameContext::kViewMtx, &status);
    gGLFT->glLoadMatrixd(worldToView.matrix[0]);

    gGLFT->glEnable(MGL_LIGHTING);
    gGLFT->glColorMaterial(MGL_FRONT_AND_BACK, MGL_AMBIENT_AND_DIFFUSE);
    gGLFT->glEnable(MGL_COLOR_MATERIAL) ;
    gGLFT->glEnable(MGL_NORMALIZE) ;

    {
        const MGLfloat ambient[4]  = { 0.0f, 0.0f, 0.0f, 1.0f };
        const MGLfloat specular[4] = { 0.0f, 0.0f, 0.0f, 1.0f };

        gGLFT->glMaterialfv(MGL_FRONT_AND_BACK, MGL_AMBIENT,  ambient);
        gGLFT->glMaterialfv(MGL_FRONT_AND_BACK, MGL_SPECULAR, specular);

        gGLFT->glLightModelfv(MGL_LIGHT_MODEL_AMBIENT, ambient);

        // Check for two sided lighting in VP2.0.
        if (context.getDisplayStyle() & MHWRender::MFrameContext::kTwoSidedLighting) {
            gGLFT->glLightModeli(MGL_LIGHT_MODEL_TWO_SIDE, 1);
        }
        else {
            gGLFT->glLightModeli(MGL_LIGHT_MODEL_TWO_SIDE, 0);
        }
    }

    for (unsigned int i=0; i<nbLights; ++i) 
    {
        MFloatPointArray positions;
        MFloatVector direction;
        float intensity;
        MColor color;
        bool hasDirection;
        bool hasPosition;
        // Use simple interface to get basic lighting information for the
        // current light.
        status = context.getLightInformation(
            i, positions, direction, intensity, color,
            hasDirection, hasPosition);

        // Handle lights which have a direction:
        if (hasDirection) 
        {
            if (hasPosition) 
            {
                // Set up a “spot light” as we have direction and position
                MFloatPoint position;
                position[0] = positions[0][0];
                position[1] = positions[0][1];
                position[2] = positions[0][2];
                const MGLfloat ambient[4] = { 0.0f, 0.0f, 0.0f, 1.0f };
                const MGLfloat diffuse[4] = { intensity * color[0],
                                                intensity * color[1],
                                                intensity * color[2],
                                                1.0f };
                const MGLfloat pos[4] = { position[0],
                                            position[1],
                                            position[2],
                                            1.0f };
                const MGLfloat dir[3] = { direction[0],
                                            direction[1],
                                            direction[2]};


                gGLFT->glLightfv(MGL_LIGHT0+i, MGL_AMBIENT,  ambient);
                gGLFT->glLightfv(MGL_LIGHT0+i, MGL_DIFFUSE,  diffuse);
                gGLFT->glLightfv(MGL_LIGHT0+i, MGL_POSITION, pos);
                gGLFT->glLightfv(MGL_LIGHT0+i, MGL_SPOT_DIRECTION, dir);

                // Just using default value's for spot lights.
                // Could use the parameter interface to get more information.
                gGLFT->glLightf(MGL_LIGHT0+i,  MGL_SPOT_EXPONENT, 0.0);
                gGLFT->glLightf(MGL_LIGHT0+i,  MGL_SPOT_CUTOFF,  20.0);
            }
            else 
            {                
                // Set up a “directional” light which has a 180 degree cone.
                const MGLfloat ambient[4] = { 0.0f, 0.0f, 0.0f, 1.0f };
                const MGLfloat diffuse[4] = { intensity * color[0],
                                                intensity * color[1],
                                                intensity * color[2],
                                                1.0f };
                const MGLfloat pos[4] = { -direction[0],
                                            -direction[1],
                                            -direction[2],
                                            0.0f };

                gGLFT->glLightfv(MGL_LIGHT0+i, MGL_AMBIENT,  ambient);
                gGLFT->glLightfv(MGL_LIGHT0+i, MGL_DIFFUSE,  diffuse);
                gGLFT->glLightfv(MGL_LIGHT0+i, MGL_POSITION, pos);
                gGLFT->glLightf(MGL_LIGHT0+i, MGL_SPOT_CUTOFF, 180.0);
            }
        }

        // Handle setting up a point light:
        else if (hasPosition) 
        {
            MFloatPoint position;
            position[0] = positions[0][0];
            position[1] = positions[0][1];
            position[2] = positions[0][2];
            const MGLfloat ambient[4] = { 0.0f, 0.0f, 0.0f, 1.0f };
            const MGLfloat diffuse[4] = { intensity * color[0],
                                            intensity * color[1],
                                            intensity * color[2],
                                            1.0f };
            const MGLfloat pos[4] = { position[0],
                                        position[1],
                                        position[2],
                                        1.0f };


            gGLFT->glLightfv(MGL_LIGHT0+i, MGL_AMBIENT,  ambient);
            gGLFT->glLightfv(MGL_LIGHT0+i, MGL_DIFFUSE,  diffuse);
            gGLFT->glLightfv(MGL_LIGHT0+i, MGL_POSITION, pos);
            gGLFT->glLightf(MGL_LIGHT0+i, MGL_SPOT_CUTOFF, 180.0);
        }

        // Handle setting up an ambient light for the ambient term:
        else 
        {
            const MGLfloat ambient[4] = { intensity * color[0],
                                            intensity * color[1],
                                            intensity * color[2],
                                            1.0f };
            const MGLfloat diffuse[4] = { 0.0f, 0.0f, 0.0f, 1.0f };
            const MGLfloat pos[4] = { 0.0f, 0.0f, 0.0f, 1.0f };


            gGLFT->glLightfv(MGL_LIGHT0+i, MGL_AMBIENT,  ambient);
            gGLFT->glLightfv(MGL_LIGHT0+i, MGL_DIFFUSE,  diffuse);
            gGLFT->glLightfv(MGL_LIGHT0+i, MGL_POSITION, pos);
            gGLFT->glLightf(MGL_LIGHT0+i, MGL_SPOT_CUTOFF, 180.0);
        }

        // Enable the light
        gGLFT->glEnable(MGL_LIGHT0+i);
    }
}