| public GetFloatPointer ( int physicalIndex ) : float[] | ||
| physicalIndex | int | |
| return | float[] | |
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 );
}
}
}
}
