C# GpuProgramParameters.GetFloatPointer方法代码示例

		public override void BindProgramParameters( GpuProgramParameters parms, GpuProgramParameters.GpuParamVariability mask )
		{
			// only supports float constants
			var floatStruct = parms.FloatLogicalBufferStruct;

			foreach ( var i in floatStruct.Map )
			{
				if ( ( i.Value.Variability & mask ) != 0 )
				{
					var logicalIndex = i.Key;
					var pFloat = parms.GetFloatPointer( i.Value.PhysicalIndex ).Pointer;
					// Iterate over the params, set in 4-float chunks (low-level)
					for ( var j = 0; j < i.Value.CurrentSize; j += 4 )
					{
						Gl.glSetFragmentShaderConstantATI( Gl.GL_CON_0_ATI + logicalIndex, pFloat.Pin() );
						pFloat.UnPin();
						pFloat += 4;
						++logicalIndex;
					}
				}
			}
		}

		public void CopyMatchingNamedConstantsFrom( GpuProgramParameters source )
		{
			if ( this._namedConstants == null || source == null )
			{
				return;
			}

			var srcToDestNamedMap = new Dictionary<int, string>();
			foreach ( var i in source._namedConstants.Map )
			{
				var paramName = i.Key;
				var olddef = i.Value;
				var newdef = FindNamedConstantDefinition( paramName, false );
				if ( newdef == null )
				{
					continue;
				}

				// Copy data across, based on smallest common definition size
				var srcsz = olddef.ElementSize*olddef.ArraySize;
				var destsz = newdef.ElementSize*newdef.ArraySize;
				var sz = Utility.Min( srcsz, destsz );
				if ( newdef.IsFloat )
				{
					Memory.Copy( source.GetFloatPointer( olddef.PhysicalIndex ).Pointer,
								 GetFloatPointer( newdef.PhysicalIndex ).Pointer, sz*sizeof ( float ) );
				}
				else
				{
					Memory.Copy( source.GetIntPointer( olddef.PhysicalIndex ).Pointer, GetIntPointer( newdef.PhysicalIndex ).Pointer,
								 sz*sizeof ( int ) );
				}
				// we'll use this map to resolve autos later
				// ignore the [0] aliases
				if ( !paramName.EndsWith( "[0]" ) )
				{
					srcToDestNamedMap.Add( olddef.PhysicalIndex, paramName );
				}
			}

			foreach ( var i in source.autoConstants )
			{
				var autoEntry = i;
				// find dest physical index
				if ( srcToDestNamedMap.ContainsKey( autoEntry.PhysicalIndex ) )
				{
					var miSecond = srcToDestNamedMap[ autoEntry.PhysicalIndex ];
					if ( autoEntry.FData != 0 )
					{
						SetNamedAutoConstantReal( miSecond, autoEntry.Type, autoEntry.FData );
					}
					else
					{
						SetNamedAutoConstant( miSecond, autoEntry.Type, autoEntry.Data );
					}
				}
			}

			// Copy shared param sets
			foreach ( var usage in source._sharedParamSets )
			{
				if ( !IsUsingSharedParameters( usage.Name ) )
				{
					AddSharedParameters( usage.SharedParameters );
				}
			}
		}

        public override void BindProgramParameters(GpuProgramParameters parms, GpuProgramParameters.GpuParamVariability mask)
		{
			// program constants done internally by compiler for local
			if ( parms.HasFloatConstants )
			{
				for ( int index = 0; index < parms.FloatConstantCount; index++ )
				{
                    using (var entry = parms.GetFloatPointer(index))
                    {
                        // send the params 4 at a time
                        throw new AxiomException( "Update this!" );
                        Gl.glSetFragmentShaderConstantATI( Gl.GL_CON_0_ATI + index, entry.Pointer );
                    }
				}
			}
		}

		/// <summary>
		///     Called to pass parameters to the Nvparse program.
		/// </summary>
		/// <param name="parms"></param>
        public override void BindProgramParameters(GpuProgramParameters parms, GpuProgramParameters.GpuParamVariability mask)
		{
			// Register combiners uses 2 constants per texture stage (0 and 1)
			// We have stored these as (stage * 2) + const_index
			if ( parms.HasFloatConstants )
			{
				for ( int index = 0; index < parms.FloatConstantCount; index++ )
				{
					var entry = parms.GetFloatPointer( index );

					{
						int combinerStage = Gl.GL_COMBINER0_NV + ( index / 2 );
						int pname = Gl.GL_CONSTANT_COLOR0_NV + ( index % 2 );

						// send the params 4 at a time
                        throw new AxiomException("Update this!");
						Gl.glCombinerStageParameterfvNV( combinerStage, pname, entry.Pointer );
					}
				}
			}
		}

        public override void BindProgramParameters(GpuProgramParameters parms, GpuProgramParameters.GpuParamVariability mask)
		{
            var type = programType;
    
	        // only supports float constants
	        var floatStruct = parms.FloatLogicalBufferStruct;

	        foreach (var i in floatStruct.Map)
	        {
		        if ((i.Value.Variability & mask) != 0)
		        {
			        var logicalIndex = i.Key;
		            var pFloat = parms.GetFloatPointer();
		            var ptr = i.Value.PhysicalIndex;
			        {
                        for (var j = 0; j < i.Value.CurrentSize; j += 4)
                        {
                            var x = pFloat[ ptr + j ];
                            var y = pFloat[ ptr + j + 1 ];
                            var z = pFloat[ ptr + j + 2 ];
                            var w = pFloat[ ptr + j + 3 ];
                            Gl.glProgramLocalParameter4fARB( type, logicalIndex, x, y, z, w );
                            ++logicalIndex;
                        }
                    }
		        }
	        }
		}

		/// <summary>
		///     Binds params by index to the vp30 program.
		/// </summary>
		/// <param name="parms"></param>
        public override void BindProgramParameters(GpuProgramParameters parms, GpuProgramParameters.GpuParamVariability mask)
		{
			if ( parms.HasFloatConstants )
			{
				for ( int index = 0; index < parms.FloatConstantCount; index++ )
				{
					using (var entry = parms.GetFloatPointer( index ))
					{
						// send the params 4 at a time
					    throw new AxiomException( "Update this!" );
						Gl.glProgramParameter4fvNV( programType, index, entry.Pointer );
					}
				}
			}
		}