ShaderPropertySet

void SetShaderProperty(NiAVObject * node, OVRValue * value, bool immediate)
{
    NiGeometry * geometry = node->GetAsNiGeometry();
    if(geometry)
    {
        BSShaderProperty * shaderProperty = (BSShaderProperty *)geometry->m_spEffectState;
        if(value->key >= OVRValue::kParam_ControllersStart && value->key <= OVRValue::kParam_ControllersEnd)
        {
            SInt8 currentIndex = 0;
            SInt8 controllerIndex = value->index;
            if(controllerIndex != -1)
            {
                NiTimeController * controller = shaderProperty->m_controller;
                while(controller)
                {
                    if(currentIndex == controllerIndex)
                        break;

                    controller = (NiTimeController *)controller->next;
                    currentIndex++;
                }

                if(controller)
                {
                    switch(value->key)
                    {
                        case OVRValue::kParam_ControllerFrequency:  UnpackValue(&controller->m_fFrequency, value);  break;
                        case OVRValue::kParam_ControllerPhase:      UnpackValue(&controller->m_fPhase, value);      break;
                        case OVRValue::kParam_ControllerStartTime:  UnpackValue(&controller->m_fLoKeyTime, value);  break;
                        case OVRValue::kParam_ControllerStopTime:   UnpackValue(&controller->m_fHiKeyTime, value);  break;

                        // Special cases
                        case OVRValue::kParam_ControllerStartStop:
                            {
                                float fValue;
                                UnpackValue(&fValue, value);
                                if(fValue < 0.0)
                                    controller->Stop();
                                else
                                    controller->Start(fValue);
                            }
                            break;
                        default:
                            _MESSAGE("Unknown controller key %d %s", value->key, node->m_name);
                            break;
                    }
                }
            }
        }
        if(shaderProperty->GetRTTI() == NiRTTI_BSEffectShaderProperty)
        {
            BSEffectShaderMaterial * material = (BSEffectShaderMaterial*)shaderProperty->material;
            switch(value->key)
            {
                case OVRValue::kParam_ShaderEmissiveColor:      UnpackValue(&material->emissiveColor, value);       break;
                case OVRValue::kParam_ShaderEmissiveMultiple:   UnpackValue(&material->emissiveMultiple, value);    break;
                default:
                    _MESSAGE("Unknown shader key %d %s", value->key, node->m_name);
                    break;
            }
#ifdef _DEBUG
            _MESSAGE("Applied EffectShader property %d %X to %s", value->key, value->data.u, node->m_name);
#endif
        }
        else if(shaderProperty->GetRTTI() == NiRTTI_BSLightingShaderProperty)
        {
            BSLightingShaderProperty * lightingShader = (BSLightingShaderProperty *)shaderProperty;
            BSLightingShaderMaterial * material = (BSLightingShaderMaterial *)shaderProperty->material;
            switch(value->key)
            {
                case OVRValue::kParam_ShaderEmissiveColor:      UnpackValue(lightingShader->emissiveColor, value);      break;
                case OVRValue::kParam_ShaderEmissiveMultiple:   UnpackValue(&lightingShader->emissiveMultiple, value);  break;
                case OVRValue::kParam_ShaderGlossiness:         UnpackValue(&material->glossiness, value);              break;
                case OVRValue::kParam_ShaderSpecularStrength:   UnpackValue(&material->specularStrength, value);        break;
                case OVRValue::kParam_ShaderLightingEffect1:    UnpackValue(&material->lightingEffect1, value);         break;
                case OVRValue::kParam_ShaderLightingEffect2:    UnpackValue(&material->lightingEffect2, value);         break;

                // Special cases
                case OVRValue::kParam_ShaderTextureSet:
                    {
                        BGSTextureSet * textureSet = (BGSTextureSet *)value->data.p;
                        if(textureSet)
                        {
                            if(immediate)
                            {
                                char buffer[MAX_PATH];
                                for(UInt32 i = 0; i < BSTextureSet::kNumTextures; i++)
                                {
                                    const char * texturePath = textureSet->textureSet.GetTexturePath(i);
                                    if(texturePath)
                                    {
                                        strcpy_s(buffer, MAX_PATH, "Data\\Textures\\");
                                        strcat_s(buffer, MAX_PATH, texturePath);
                                        material->textureSet->SetTexturePath(i, buffer);
                                    }
                                }
                                material->ReleaseTextures();
                                CALL_MEMBER_FN(lightingShader, InvalidateTextures)(0);
                            }
                            else
                                CALL_MEMBER_FN(BSTaskPool::GetSingleton(), SetNiGeometryTexture)(geometry, textureSet);
                        }
                    }
                    break;
                case OVRValue::kParam_ShaderTintColor:
                    {
                        if(material->GetShaderType() == BSShaderMaterial::kShaderType_SkinTint) {
                            BSTintedShaderMaterial * tintedMaterial = (BSTintedShaderMaterial *)material;
                            UnpackValue(&tintedMaterial->tintColor, value);
                        }
                    }
                    break;
                default:
                    _MESSAGE("Unknown lighting shader key %d %s", value->key, node->m_name);
                    break;
            }
#ifdef _DEBUG
            _MESSAGE("Applied LightingShader property %d %X to %s", value->key, value->data.u, node->m_name);
#endif
        }
    } else {
        _MESSAGE("Failed to cast %s to geometry", node->m_name);
    }
}