public SetNamedConstant ( string name, |
||
name | string | Name of the param. |
color | Structure containing 4 packed RGBA color values. | |
return | void |
public void UpdateCustomGpuParameter(GpuProgramParameters.AutoConstantEntry constant, GpuProgramParameters parameters) { parameters.SetNamedConstant(_scaleFactorName, ScaleFactor); parameters.SetNamedConstant(_fineBlockOriginName, FineBlockOrigin); }
/// <summary> /// /// </summary> /// <param name="prof"></param> /// <param name="terrain"></param> /// <param name="tt"></param> /// <param name="gpuparams"></param> public virtual void UpdateVpParams( SM2Profile prof, Terrain terrain, TechniqueType tt, GpuProgramParameters gpuparams ) { gpuparams.IgnoreMissingParameters = true; uint maxLayers = prof.GetMaxLayers( terrain ); uint numLayers = Utility.Min( maxLayers, (uint)terrain.LayerCount ); uint numUVMul = numLayers/4; if ( numUVMul%4 == 0 ) { ++numUVMul; } for ( uint i = 0; i < numUVMul; ++i ) { var uvMul = new Vector4( terrain.GetLayerUVMultiplier( (byte)( i*4 ) ), terrain.GetLayerUVMultiplier( (byte)( i*4 + 1 ) ), terrain.GetLayerUVMultiplier( (byte)( i*4 + 2 ) ), terrain.GetLayerUVMultiplier( (byte)( i*4 + 3 ) ) ); #if true gpuparams.SetNamedConstant( "uvMul" + i.ToString(), uvMul ); #endif } }
/// <summary> /// /// </summary> /// <param name="prof"></param> /// <param name="terrain"></param> /// <param name="tt"></param> /// <param name="gpuparams"></param> public virtual void UpdateFpParams( SM2Profile prof, Terrain terrain, TechniqueType tt, GpuProgramParameters gpuparams ) { gpuparams.IgnoreMissingParameters = true; // TODO - parameterise this? var scaleBiasSpecular = new Vector4( 0.03f, -0.04f, 32, 1 ); gpuparams.SetNamedConstant( "scaleBiasSpecular", scaleBiasSpecular ); }
public static void TranslateProgramParameters( ScriptCompiler compiler, /*it should be GpuProgramParametersShared*/ GpuProgramParameters parameters, ObjectAbstractNode obj ) { int animParametricsCount = 0; foreach ( AbstractNode i in obj.Children ) { if ( i is PropertyAbstractNode ) { PropertyAbstractNode prop = (PropertyAbstractNode)i; LogManager.Instance.Write("TranslateProgramParameters {0}", (Keywords)prop.Id); switch ( (Keywords)prop.Id ) { #region ID_SHARED_PARAMS_REF case Keywords.ID_SHARED_PARAMS_REF: { if ( prop.Values.Count != 1 ) { compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line, "shared_params_ref requires a single parameter" ); continue; } AbstractNode i0 = getNodeAt( prop.Values, 0 ); if ( !( i0 is AtomAbstractNode ) ) { compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line, "shared parameter set name expected" ); continue; } AtomAbstractNode atom0 = (AtomAbstractNode)i0; throw new NotImplementedException(); #if UNREACHABLE_CODE try { //TODO //parameters->addSharedParameters(atom0->value); } catch ( AxiomException e ) { compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line, e.Message ); } } break; #else } #endif #endregion ID_SHARED_PARAMS_REF #region ID_PARAM_INDEXED || ID_PARAM_NAMED case Keywords.ID_PARAM_INDEXED: case Keywords.ID_PARAM_NAMED: { if ( prop.Values.Count >= 3 ) { bool named = ( prop.Id == (uint)Keywords.ID_PARAM_NAMED ); AbstractNode i0 = getNodeAt( prop.Values, 0 ), i1 = getNodeAt( prop.Values, 1 ), k = getNodeAt( prop.Values, 2 ); if ( !(i0 is AtomAbstractNode) || !(i1 is AtomAbstractNode) ) { compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line, "name or index and parameter type expected" ); return; } AtomAbstractNode atom0 = (AtomAbstractNode)i0, atom1 = (AtomAbstractNode)i1; if ( !named && !atom0.IsNumber ) { compiler.AddError( CompileErrorCode.NumberExpected, prop.File, prop.Line, "parameter index expected" ); return; } string name = string.Empty; int index = 0; // Assign the name/index if ( named ) name = atom0.Value; else index = (int)atom0.Number; // Determine the type if ( atom1.Value == "matrix4x4" ) { Matrix4 m; if ( getMatrix4( prop.Values, 2, out m ) ) { try { if ( named ) parameters.SetNamedConstant( name, m ); else parameters.SetConstant( index, m ); } catch { compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line, "setting matrix4x4 parameter failed" ); } } else { compiler.AddError( CompileErrorCode.NumberExpected, prop.File, prop.Line, "incorrect matrix4x4 declaration" ); } } else { // Find the number of parameters var isValid = true; GpuProgramParameters.ElementType type = GpuProgramParameters.ElementType.Real; int count = 0; if ( atom1.Value.Contains( "float" ) ) { type = GpuProgramParameters.ElementType.Real; if ( atom1.Value.Length >= 6 ) count = int.Parse( atom1.Value.Substring( 5 ) ); else { count = 1; } } else if ( atom1.Value.Contains( "int" ) ) { type = GpuProgramParameters.ElementType.Int; if ( atom1.Value.Length >= 4 ) count = int.Parse( atom1.Value.Substring( 3 ) ); else { count = 1; } } else { compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line, "incorrect type specified; only variants of int and float allowed" ); isValid = false; } if ( isValid ) { // First, clear out any offending auto constants if ( named ) { parameters.ClearNamedAutoConstant(name); } else { parameters.ClearAutoConstant(index); } int roundedCount = count % 4 != 0 ? count + 4 - ( count % 4 ) : count; if ( type == GpuProgramParameters.ElementType.Int ) { int[] vals = new int[ roundedCount ]; if ( getInts( prop.Values, 2, out vals, roundedCount ) ) { try { if ( named ) { parameters.SetNamedConstant(name, vals, count, 1); } else { parameters.SetConstant(index , vals, roundedCount/4); } } catch { compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line, "setting of constant failed" ); } } else { compiler.AddError( CompileErrorCode.NumberExpected, prop.File, prop.Line, "incorrect integer constant declaration" ); } } else { float[] vals = new float[ roundedCount ]; if ( getFloats( prop.Values, 2, out vals, roundedCount ) ) { try { if ( named ) { parameters.SetNamedConstant(name, vals, count, 1); } else { parameters.SetConstant(index , vals, roundedCount/4); } } catch { compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line, "setting of constant failed" ); } } else { compiler.AddError( CompileErrorCode.NumberExpected, prop.File, prop.Line, "incorrect float constant declaration" ); } } } } } else { compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line, "param_named and param_indexed properties requires at least 3 arguments" ); } } break; #endregion ID_PARAM_INDEXED || ID_PARAM_NAMED #region ID_PARAM_INDEXED_AUTO || ID_PARAM_NAMED_AUTO case Keywords.ID_PARAM_INDEXED_AUTO: case Keywords.ID_PARAM_NAMED_AUTO: { bool named = ( prop.Id == (uint)Keywords.ID_PARAM_NAMED_AUTO ); string name = string.Empty; int index = 0; if ( prop.Values.Count >= 2 ) { AbstractNode i0 = getNodeAt( prop.Values, 0 ), i1 = getNodeAt( prop.Values, 1 ), i2 = getNodeAt( prop.Values, 2 ), i3 = getNodeAt( prop.Values, 3 ); if ( !(i0 is AtomAbstractNode) || !(i1 is AtomAbstractNode) ) { compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line, "name or index and auto constant type expected" ); return; } AtomAbstractNode atom0 = (AtomAbstractNode)i0, atom1 = (AtomAbstractNode)i1; if ( !named && !atom0.IsNumber ) { compiler.AddError( CompileErrorCode.NumberExpected, prop.File, prop.Line, "parameter index expected" ); return; } if ( named ) name = atom0.Value; else index = int.Parse( atom0.Value ); // Look up the auto constant atom1.Value = atom1.Value.ToLower(); GpuProgramParameters.AutoConstantDefinition def; bool defFound = GpuProgramParameters.GetAutoConstantDefinition( atom1.Value, out def ); if ( defFound ) { switch ( def.DataType ) { #region None case GpuProgramParameters.AutoConstantDataType.None: // Set the auto constant try { if ( named ) parameters.SetNamedAutoConstant( name, def.AutoConstantType ); else parameters.SetAutoConstant( index, def.AutoConstantType ); } catch { compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line, "setting of constant failed" ); } break; #endregion None #region Int case GpuProgramParameters.AutoConstantDataType.Int: if ( def.AutoConstantType == GpuProgramParameters.AutoConstantType.AnimationParametric ) { try { if ( named ) parameters.SetNamedAutoConstant( name, def.AutoConstantType, animParametricsCount++ ); else parameters.SetAutoConstant( index, def.AutoConstantType, animParametricsCount++ ); } catch { compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line, "setting of constant failed" ); } } else { // Only certain texture projection auto params will assume 0 // Otherwise we will expect that 3rd parameter if ( i2 == null ) { if ( def.AutoConstantType == GpuProgramParameters.AutoConstantType.TextureViewProjMatrix || def.AutoConstantType == GpuProgramParameters.AutoConstantType.TextureWorldViewProjMatrix || def.AutoConstantType == GpuProgramParameters.AutoConstantType.SpotLightViewProjMatrix || def.AutoConstantType == GpuProgramParameters.AutoConstantType.SpotLightWorldViewProjMatrix ) { try { if ( named ) parameters.SetNamedAutoConstant( name, def.AutoConstantType, 0 ); else parameters.SetAutoConstant( index, def.AutoConstantType, 0 ); } catch { compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line, "setting of constant failed" ); } } else { compiler.AddError( CompileErrorCode.NumberExpected, prop.File, prop.Line, "extra parameters required by constant definition " + atom1.Value ); } } else { bool success = false; int extraInfo = 0; if ( i3 == null ) { // Handle only one extra value if ( getInt( i2, out extraInfo ) ) { success = true; } } else { // Handle two extra values int extraInfo1 = 0, extraInfo2 = 0; if ( getInt( i2, out extraInfo1 ) && getInt( i3, out extraInfo2 ) ) { extraInfo = extraInfo1 | ( extraInfo2 << 16 ); success = true; } } if ( success ) { try { if ( named ) parameters.SetNamedAutoConstant( name, def.AutoConstantType, extraInfo ); else parameters.SetAutoConstant( index, def.AutoConstantType, extraInfo ); } catch { compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line, "setting of constant failed" ); } } else { compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line, "invalid auto constant extra info parameter" ); } } } break; #endregion Int #region Real case GpuProgramParameters.AutoConstantDataType.Real: if ( def.AutoConstantType == GpuProgramParameters.AutoConstantType.Time || def.AutoConstantType == GpuProgramParameters.AutoConstantType.FrameTime ) { Real f = 1.0f; if ( i2 != null ) getReal( i2, out f ); try { if ( named ) { parameters.SetNamedAutoConstantReal(name, def.AutoConstantType, f); } else parameters.SetAutoConstantReal( index, def.AutoConstantType, f ); } catch { compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line, "setting of constant failed" ); } } else { if ( i2 != null ) { Real extraInfo = 0.0f; if ( getReal( i2, out extraInfo ) ) { try { if ( named ) { parameters.SetNamedAutoConstantReal(name, def.AutoConstantType, extraInfo); } else parameters.SetAutoConstantReal( index, def.AutoConstantType, extraInfo ); } catch { compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line, "setting of constant failed" ); } } else { compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line, "incorrect float argument definition in extra parameters" ); } } else { compiler.AddError( CompileErrorCode.NumberExpected, prop.File, prop.Line, "extra parameters required by constant definition " + atom1.Value ); } } break; #endregion Real } } else { compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line ); } } else { compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line ); } } break;