public SetConstant ( int index, |
||
index | int | Index of the contant register. |
color | Structure containing 4 packed RGBA color values. | |
return | void |
public void UpdateCustomGpuParameter(GpuProgramParameters.AutoConstantEntry entry, GpuProgramParameters gpuParams) { if (this.customParams.Count > entry.Data && this.customParams[entry.Data] != null) { gpuParams.SetConstant(entry.PhysicalIndex, (Vector4)this.customParams[entry.Data]); } }
public void UpdateCustomGpuParameter(GpuProgramParameters.AutoConstantEntry entry, GpuProgramParameters gpuParams) { if (customParams[entry.data] != null) { gpuParams.SetConstant(entry.index, (Vector4)customParams[entry.data]); } }
public void SetConstantFloatArray() { float[] expected = new[] { (float)Utility.SymmetricRandom(), (float)Utility.SymmetricRandom(), (float)Utility.SymmetricRandom(), (float)Utility.SymmetricRandom() }; float[] actual; GpuProgramParameters parameters = new GpuProgramParameters(); //var floatLogical = new GpuLogicalBufferStruct(); //parameters._setLogicalIndexes( floatLogical, new GpuLogicalBufferStruct() ); parameters.SetConstant( 0, expected ); Assert.IsTrue( parameters.GetFloatConstant( 0 ).isSet ); actual = parameters.GetFloatConstant( 0 ).val; Assert.AreEqual( expected, actual ); }
public void UpdateCustomGpuParameter( GpuProgramParameters.AutoConstantEntry entry, GpuProgramParameters gpuParams ) { if ( customParams[ entry.Data ] != null ) { gpuParams.SetConstant( entry.PhysicalIndex, (Vector4)customParams[ entry.Data ] ); } }
public void SetConstantMatrix4() { float[] expected = new[] { (float)Utility.SymmetricRandom(), (float)Utility.SymmetricRandom(), (float)Utility.SymmetricRandom(), (float)Utility.SymmetricRandom(), (float)Utility.SymmetricRandom(), (float)Utility.SymmetricRandom(), (float)Utility.SymmetricRandom(), (float)Utility.SymmetricRandom(), (float)Utility.SymmetricRandom(), (float)Utility.SymmetricRandom(), (float)Utility.SymmetricRandom(), (float)Utility.SymmetricRandom(), (float)Utility.SymmetricRandom(), (float)Utility.SymmetricRandom(), (float)Utility.SymmetricRandom(), (float)Utility.SymmetricRandom() }; float[] actual = new float[16]; GpuProgramParameters parameters = new GpuProgramParameters(); //var floatLogical = new GpuLogicalBufferStruct(); //parameters._setLogicalIndexes( floatLogical, new GpuLogicalBufferStruct() ); parameters.SetConstant( 0, new Matrix4( expected[ 0 ], expected[ 1 ], expected[ 2 ], expected[ 3 ], expected[ 4 ], expected[ 5 ], expected[ 6 ], expected[ 7 ], expected[ 8 ], expected[ 9 ], expected[ 10 ], expected[ 11 ], expected[ 12 ], expected[ 13 ], expected[ 14 ], expected[ 15 ] ) ); GpuProgramParameters.FloatConstantEntry fcEntry; for (int i = 0; i < 4; i++) { fcEntry = parameters.GetFloatConstant(i); Assert.IsTrue(fcEntry.isSet); fcEntry.val.CopyTo(actual, i * 4); } Assert.AreEqual( expected, actual ); }
public GpuProgramParameters Clone() { GpuProgramParameters p = new GpuProgramParameters(); // copy int constants for ( int i = 0; i < intConstants.Count; i++ ) { IntConstantEntry e = intConstants[ i ] as IntConstantEntry; if ( e.isSet ) { p.SetConstant( i, e.val ); } } // copy float constants for ( int i = 0; i < floatConstants.Count; i++ ) { FloatConstantEntry e = floatConstants[ i ] as FloatConstantEntry; if ( e.isSet ) { p.SetConstant( i, e.val ); } } // copy auto constants for ( int i = 0; i < autoConstantList.Count; i++ ) { AutoConstantEntry entry = autoConstantList[ i ] as AutoConstantEntry; p.SetAutoConstant( entry.Clone() ); } // copy named params foreach ( string key in namedParams.Keys ) { p.MapParamNameToIndex( key, namedParams[ key ] ); } for ( int i = 0; i < paramTypeList.Count; i++ ) { } foreach ( ParameterEntry pEntry in paramTypeList ) { p.AddParameterToDefaultsList( pEntry.ParameterType, pEntry.ParameterName ); } // copy value members p.transposeMatrices = transposeMatrices; p.autoAddParamName = autoAddParamName; return p; }
/// <summary> /// Update a custom GpuProgramParameters constant which is derived from /// information only this Renderable knows. /// </summary> /// <remarks> /// This method allows a Renderable to map in a custom GPU program parameter /// based on it's own data. This is represented by a GPU auto parameter /// of AutoConstantType.Custom, and to allow there to be more than one of these per /// Renderable, the 'data' field on the auto parameter will identify /// which parameter is being updated. The implementation of this method /// must identify the parameter being updated, and call a 'SetConstant' /// method on the passed in <see cref="GpuProgramParameters"/> object, using the details /// provided in the incoming auto constant setting to identify the index /// at which to set the parameter. /// </remarks> /// <param name="constantEntry">The auto constant entry referring to the parameter being updated.</param> /// <param name="param">The parameters object which this method should call to set the updated parameters.</param> public new void UpdateCustomGpuParameter( GpuProgramParameters.AutoConstantEntry constantEntry, GpuProgramParameters param ) { if ( constantEntry.Data == MORPH_CUSTOM_PARAM_ID ) { // Update morph LOD factor param.SetConstant( constantEntry.PhysicalIndex, this.mLODMorphFactor ); //_writeRawConstant(constantEntry.PhysicalIndex, mLODMorphFactor); } else { base.UpdateCustomGpuParameter( constantEntry, param ); } }
protected void _updateParameter( GpuProgramParameters programParameters, String paramName, Object value, int sizeInBytes ) { programParameters.AutoAddParamName = true; if ( value is Axiom.Math.Matrix4 ) { programParameters.SetConstant( programParameters.GetParamIndex( paramName ), (Axiom.Math.Matrix4)value ); } else if ( value is Axiom.Core.ColorEx ) { programParameters.SetConstant( programParameters.GetParamIndex( paramName ), (Axiom.Core.ColorEx)value ); } else if ( value is Axiom.Math.Vector3 ) { programParameters.SetConstant( programParameters.GetParamIndex( paramName ), ( (Axiom.Math.Vector3)value ) ); } else if ( value is Axiom.Math.Vector4 ) { programParameters.SetConstant( programParameters.GetParamIndex( paramName ), (Axiom.Math.Vector4)value ); } else if ( value is float[] ) { programParameters.SetConstant( programParameters.GetParamIndex( paramName ), (float[])value ); } else if ( value is int[] ) { programParameters.SetConstant( programParameters.GetParamIndex( paramName ), (int[])value ); } else if ( value is float ) { programParameters.SetConstant( programParameters.GetParamIndex( paramName ), new float[] { (float)value, 0.0f, 0.0f, 0.0f } ); } else { programParameters.SetConstant( programParameters.GetParamIndex( paramName ), (float[])value ); } }
public void UpdateCustomGpuParameter(GpuProgramParameters.AutoConstantEntry entry, GpuProgramParameters gpuParams) { if( ( customParams != null ) && ( customParams[entry.data] != null ) ) { gpuParams.SetConstant(entry.index, (Vector4)customParams[entry.data]); } }
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;
public void UpdateCustomGpuParameter(GpuProgramParameters.AutoConstantEntry entry, GpuProgramParameters gpuParams) { if (entry.type == AutoConstants.AnimationParametric) { // Set up to 4 values, or up to limit of hardware animation entries // Pack into 4-element constants offset based on constant data index // If there are more than 4 entries, this will be called more than once Vector4 val = Vector4.Zero; int animIndex = entry.data * 4; for (int i = 0; i < 4 && animIndex < hardwareVertexAnimVertexData.HWAnimationDataList.Count; ++i, ++animIndex) { val[i] = hardwareVertexAnimVertexData.HWAnimationDataList[animIndex].Parametric; } // set the parametric morph value gpuParams.SetConstant(entry.index, val); } else if (customParams[entry.data] != null) { gpuParams.SetConstant(entry.index, (Vector4)customParams[entry.data]); } }
protected void _updateParameter( GpuProgramParameters programParameters, String paramName, Object value, int sizeInBytes ) { //programParameters.AutoAddParamName = true; var idx = programParameters.FindNamedConstantDefinition( paramName ).LogicalIndex; if ( value is Matrix4 ) { programParameters.SetConstant( idx, (Matrix4)value ); } else if ( value is ColorEx ) { programParameters.SetConstant( idx, (ColorEx)value ); } else if ( value is Vector3 ) { programParameters.SetConstant( idx, ( (Vector3)value ) ); } else if ( value is Vector4 ) { programParameters.SetConstant( idx, (Vector4)value ); } else if ( value is float[] ) { programParameters.SetConstant( idx, (float[])value ); } else if ( value is int[] ) { programParameters.SetConstant( idx, (int[])value ); } else if ( value is float ) { programParameters.SetConstant( idx, new[] { (float)value, 0.0f, 0.0f, 0.0f } ); } else { programParameters.SetConstant( idx, (float[])value ); } }
public GpuProgramParameters Clone() { GpuProgramParameters p = new GpuProgramParameters(); // copy int constants for ( int i = 0; i < intConstants.Count; i++ ) { IntConstantEntry e = intConstants[i]; if ( e.isSet ) { p.SetConstant(i, e.val); } } // copy float constants p.floatConstantsArray = new float[floatConstantsArray.Length]; Array.Copy(floatConstantsArray, p.floatConstantsArray, floatConstantsArray.Length); p.floatIsSet = new bool[floatIsSet.Length]; Array.Copy(floatIsSet, p.floatIsSet, floatIsSet.Length); p.float4VecConstantsCount = float4VecConstantsCount; p.maxSetCount = maxSetCount; // copy auto constants for(int i = 0; i < autoConstantList.Count; i++) { AutoConstantEntry entry = autoConstantList[i]; p.SetAutoConstant(entry.Clone()); } // copy named params foreach ( DictionaryEntry e in namedParams ) { p.MapParamNameToIndex(e.Key as string, (int)e.Value); } for ( int i = 0; i < paramTypeList.Count; i++ ) { } foreach ( ParameterEntry pEntry in paramTypeList ) { p.AddParameterToDefaultsList(pEntry.ParameterType, pEntry.ParameterName); } // copy value members p.transposeMatrices = transposeMatrices; p.autoAddParamName = autoAddParamName; return p; }