The 3ds Max 8 SDK shader interface required that the shader be loaded and compiled by the material. The parser simply got the compiled object. NVIDIA has a different compile system, so without fundamental changes to the shader interface design, the material would have to include a special case for Cg support - a definite limitation. Moving the loading and compilation of the shaders removes the restriction of the type of shader the system can support. The material simply supplies a filename or buffer to compile.

Beyond the need to introduce Cg support, new shader languages are often introduced with the release of new gaming platforms. The new 3ds Max 9 shader language interface breaks a material's reliance on any specific interface, in this case the LPD3DEffect interface, allowing runtime bindings to take place in the parser DLLs. This approach makes the materials and the 3ds Max-centric aspects of shading independent of specific shader languages with D3D runtime support.

Within the 3ds Max 9 SDK itself, changes were made to define parameter access by name, and not by handle. Plug-in developers can maintain a list of handles internally for use directly with the runtime, but any access to 3ds Max is by name. Even though, in theory, the D3DXHANDLE is a pointer to a string, it can be ambiguous as to whether it is a handle or an actual string - and this could cause problems if the interface assumes a string.

Previously all data that 3ds Max provided was set by 3ds Max in the material. This is now impossible as the parser maintains the link to the runtime, so it needs to set the data itself. The new system now provides all the data by means of theIParameterManager. This is a new interface that provides access to the data requested by the parsers. The following code sample shows how to access data either by name or iteratively. The choice of approach depends on how the parser holds its internal data.

switch(pm->GetParamType(i))
{
    case  IParameterManager::kPType_Float:
    {
        float fval;
        pm->GetParamData((void*)&fval,i);
        pEffect->SetFloat(pm->GetParamName(i), fval);
    }
    break;
    case  IParameterManager::kPType_Color:
    case  IParameterManager::kPType_Point4:
    {
        D3DCOLORVALUE cval;
        pm->GetParamData((void*)&cval,i);
        pEffect->SetVector(pm->GetParamName(i), (D3DXVECTOR4*)&cval);
    }
    break;
    case  IParameterManager::kPType_Bool:
    {
        BOOL bval;
        pm->GetParamData((void*)&bval,i);
        pEffect->SetBool(pm->GetParamName(i), bval);
    }
    break;
    case  IParameterManager::kPType_Int:
    {
        int ival;
        pm->GetParamData((void*)&ival,i);
        pEffect->SetInt(pm->GetParamName(i), ival);
    }
    break;
}

As more shader types become available, materials must be able to display these in the File Opendialog. To accommodate this, new methods have been added to the EffectDescriptor. The parser defines supported file extensions in the descriptor since the actual parser has not been loaded until the file has been accessed to determine which parser to load. File extensions are supplied as a localizable strings.

To allow the future support of DirectX10, some methods now use void data types, which are then cast accordingly. For example:

bool MaxEffectParser::LoadTexture(LPVOID pDevice, LPD3DXEFFECT pEffect,TCHAR * paramName, TCHAR * filename, bool forceReload)
{
    LPDIRECT3DDEVICE9 pd3dDevice = static_cast<LPDIRECT3DDEVICE9>(pDevice);
}

Plug-in developers can query which version of DirectX is running so they can perform the appropriate cast. This approach kept the API changes smaller, otherwise a copy of the IEffectParser interface would be needed ( IEffectParser10) that had the same methods but with Dx10 counterparts.

The material is responsible for displaying any errors generated, so additional parser methods need to provide access to error buffers.

D3DXMATRIXMatInvWorld;
D3DXMatrixInverse(&MatInvWorld,NULL,&MatWorld);
*(D3DXMATRIX*)data = MatInvWorld;

typedef struct D3DXMATRIX {
    FLOAT _11, FLOAT _12, FLOAT _13, FLOAT _14,
    FLOAT _21, FLOAT _22, FLOAT _23, FLOAT _24,
    FLOAT _31, FLOAT _32, FLOAT _33, FLOAT _34,
    FLOAT _41, FLOAT _42, FLOAT _43, FLOAT _44 );
} D3DXMATRIX;

bool MaxEffectParser::LoadEffectFile(LPVOID pDevice, IEffectManager * em,TCHAR * fileName, bool forceReload)
{
    int index;
    HRESULT hr;
    LPDIRECT3DDEVICE9 pd3dDevice = static_cast<LPDIRECT3DDEVICE9>(pDevice); //Used later when we have a Dx10 version of the parser.
    bDirectX9 = em->GetDirectXVersion() ==  IEffectManager::kDirectX9?true:false;
    index = IDxShaderCache::GetIDxShaderCache()->FindShader(fileName);
    if(index<0)
    {
        D3DXMACRO macros[5 =
        {
            { "_3DSMAX_", NULL },
            { "_MAX_",NULL },
            { "MAX",NULL },
            { "3DSMAX",NULL },
            { NULL,NULL }
        };
        hr = D3DXCreateEffectFromFile(pd3dDevice,fileName,macros,NULL,NULL,NULL,&m_pEffect,NULL);
        if(FAILED(hr) || !m_pEffect){
             return false ;
        }
        IDxShaderCache::GetIDxShaderCache()->SetShader(fileName,(LPCVOID)m_pEffect);
    }
    else
    {
             m_pEffect = (LPD3DXEFFECT) IDxShaderCache::GetIDxShaderCache()->GetShader(index);
    }
    return true;
}

texHandle = pEffect->GetParameterByName(NULL,paramName);