void SimpleSortedSetData< KeyT, CompareKeyT, AllocatorT >::GetItems( DynArray< DataPtr >& items ) const
{
items.Clear();
items.Reserve( m_Data->GetSize() );
DataType::ConstIterator itr = m_Data->Begin();
DataType::ConstIterator end = m_Data->End();
for ( ; itr != end; ++itr )
{
HELIUM_VERIFY( items.New( Data::Bind( const_cast< KeyT& >( *itr ), m_Instance, m_Field ) ) );
}
}
int main()
{
DynArray <char> a;
DynArray <char> b;
char c = 'c';
char d = 'd';
char e = 'e';
char f = 'f';
char g = 'g';
a.Push_Back(c);
a.Push_Back(d);
b.Push_Back(e);
b.Push_Back(f);
char result = a.At(0,result);
//a = c,d
//b = e,f
printf("At 0: %c\n", result);
printf("A at 0,1: %c,%c\nB at 0,1: %c,%c\n", a[0], a[1], b[0], b[1]);
a.Clear();
printf("A clear... Size: %i\n", a.Size());
a.Push_Back(c);
a.Push_Back(d);
a += b;
printf("A after += : %c,%c,%c,%c\n", a[0], a[1], a[2], a[3]);
printf("A[0] = %c, A[3] = %c\n", a[0], a[3]);
printf("A.GetData = %p\n", a.GetData());
printf("Capacity: %i, size = %i\n", a.Capacity(), a.Size());
printf("Empty: ");
if (a.Empty())
{
printf("yes\n");
}
else
{
printf("no\n");
}
a.Flip();
printf("A fliped: %c,%c,%c,%c\n", a[0], a[1], a[2], a[3]);
a.Push_Back(c);
a.Push_Back(d);
a.Push_Back(e);
a.Push_Back(f);
a.Insert(2, g);
printf("A inserted g in 2: %c,%c,%c,%c,%c,%c,%c,%c,%c\n", a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8]);
a.Erase(1);
printf("A: %s\n", a.GetData());
DynArray <int> test;
int swaps = 0;
int z;
time_t t;
test.Push_Back(5);
test.Push_Back(8);
test.Push_Back(3);
test.Push_Back(1);
test.Push_Back(4);
test.Push_Back(2);
printf("Int Array : %i,%i,%i,%i,%i,%i\n", test[0], test[1], test[2], test[3], test[4], test[5]);
swaps = test.BubbleSort();
printf("Int Array : %i,%i,%i,%i,%i,%i\nSwaps: %i\n", test[0], test[1], test[2], test[3], test[4], test[5], swaps);
DynArray <int> test2;
time(&t);
srand(t);
for (int i = 0; i <= 1000; i++)
{
z = rand();
test2.Push_Back(z);
}
system("pause");
return 0;
}
/// Get the list of property tag names.
///
/// Property tag names are formatted as follows:
/// - Top-level properties will contain just a name string (i.e. "m_width").
/// - Properties of structures are identified with the structure name followed by a dot, then followed by the member
/// name (i.e. "m_parameters.type").
/// - Array elements are identified with the array name followed by the element index in brackets (i.e.
/// "m_children[3]").
/// - Arrays can be nested within structs, and structs can be nested within other structs as well as arrays. When
/// this occurs, a dot is used to separate the nested elements (i.e. "m_children[3].parameters.type", where
/// "m_children" is an array of structs, "parameters" is a struct member within the array element, and "type" is
/// a member of the "parameters" struct).
///
/// Note that this is only supported for loading serializers (where GetMode() returns MODE_LOAD) that support tag
/// resolution (where CanResolveTags() returns true). This can also be fairly slow, so it should not be used in
/// production runtime code.
///
/// @param[out] rTagNames List of property tag names. The existing contents of this array will be erased.
void Serializer::GetPropertyTagNames( DynArray< String >& rTagNames ) const
{
HELIUM_TRACE( TRACE_WARNING, TXT( "Serializer::GetPropertyTagNames(): Called on an unsupported serializer.\n" ) );
rTagNames.Clear();
}
/// Synchronize the shader parameter list with those provided by the selected shader variant.
///
/// @see SynchronizeFloatVectorParameters(), SynchronizeTextureParameters()
void Material::SynchronizeShaderParameters()
{
Shader* pShader = m_spShader;
if( !pShader )
{
m_float1Parameters.Clear();
m_float2Parameters.Clear();
m_float3Parameters.Clear();
m_float4Parameters.Clear();
m_textureParameters.Clear();
}
// Synchronize floating-point constant parameters.
Name parameterConstantBufferName = GetParameterConstantBufferName();
size_t existingFloat1Count = m_float1Parameters.GetSize();
size_t existingFloat2Count = m_float2Parameters.GetSize();
size_t existingFloat3Count = m_float3Parameters.GetSize();
size_t existingFloat4Count = m_float4Parameters.GetSize();
DynArray< Float1Parameter > newFloat1Parameters;
DynArray< Float2Parameter > newFloat2Parameters;
DynArray< Float3Parameter > newFloat3Parameters;
DynArray< Float4Parameter > newFloat4Parameters;
for( size_t shaderTypeIndex = 0; shaderTypeIndex < HELIUM_ARRAY_COUNT( m_shaderVariants ); ++shaderTypeIndex )
{
ShaderVariant* pShaderVariant = m_shaderVariants[ shaderTypeIndex ];
if( !pShaderVariant )
{
continue;
}
const ShaderConstantBufferInfoSet* pBufferSet = pShaderVariant->GetConstantBufferInfoSet( 0 );
if( !pBufferSet )
{
continue;
}
bool bCheckDuplicates =
( !newFloat1Parameters.IsEmpty() || !newFloat2Parameters.IsEmpty() || !newFloat3Parameters.IsEmpty() ||
!newFloat4Parameters.IsEmpty() );
const DynArray< ShaderConstantBufferInfo >& rBuffers = pBufferSet->buffers;
size_t bufferCount = rBuffers.GetSize();
for( size_t bufferIndex = 0; bufferIndex < bufferCount; ++bufferIndex )
{
const ShaderConstantBufferInfo& rBufferInfo = rBuffers[ bufferIndex ];
if( rBufferInfo.name != parameterConstantBufferName )
{
continue;
}
const DynArray< ShaderConstantInfo >& rConstants = rBufferInfo.constants;
size_t constantCount = rConstants.GetSize();
for( size_t constantIndex = 0; constantIndex < constantCount; ++constantIndex )
{
const ShaderConstantInfo& rConstantInfo = rConstants[ constantIndex ];
// Constants must be between 1 and 4 floating-point values.
uint16_t constantSize = rConstantInfo.usedSize;
if( constantSize < sizeof( float32_t ) || constantSize > sizeof( float32_t ) * 4 )
{
continue;
}
Name constantName = rConstantInfo.name;
size_t parameterIndex;
if( bCheckDuplicates )
{
size_t parameterCount = newFloat1Parameters.GetSize();
for( parameterIndex = 0; parameterIndex < parameterCount; ++parameterIndex )
{
if( newFloat1Parameters[ parameterIndex ].name == constantName )
{
break;
}
}
if( parameterIndex < parameterCount )
{
continue;
}
parameterCount = newFloat2Parameters.GetSize();
for( parameterIndex = 0; parameterIndex < parameterCount; ++parameterIndex )
{
if( newFloat2Parameters[ parameterIndex ].name == constantName )
{
break;
}
}
if( parameterIndex < parameterCount )
{
continue;
}
parameterCount = newFloat3Parameters.GetSize();
for( parameterIndex = 0; parameterIndex < parameterCount; ++parameterIndex )
{
if( newFloat3Parameters[ parameterIndex ].name == constantName )
{
break;
}
}
if( parameterIndex < parameterCount )
{
continue;
}
parameterCount = newFloat4Parameters.GetSize();
for( parameterIndex = 0; parameterIndex < parameterCount; ++parameterIndex )
{
if( newFloat4Parameters[ parameterIndex ].name == constantName )
{
break;
}
}
if( parameterIndex < parameterCount )
{
continue;
}
}
Simd::Vector4 newValue( 0.0f );
for( parameterIndex = 0; parameterIndex < existingFloat1Count; ++parameterIndex )
{
const Float1Parameter& rExistingParameter = m_float1Parameters[ parameterIndex ];
if( rExistingParameter.name == constantName )
{
newValue.SetElement( 0, rExistingParameter.value );
break;
}
}
if( parameterIndex >= existingFloat1Count )
{
for( parameterIndex = 0; parameterIndex < existingFloat2Count; ++parameterIndex )
{
const Float2Parameter& rExistingParameter = m_float2Parameters[ parameterIndex ];
if( rExistingParameter.name == constantName )
{
newValue.SetElement( 0, rExistingParameter.value.GetX() );
newValue.SetElement( 1, rExistingParameter.value.GetY() );
break;
}
}
if( parameterIndex >= existingFloat2Count )
{
for( parameterIndex = 0; parameterIndex < existingFloat3Count; ++parameterIndex )
{
const Float3Parameter& rExistingParameter = m_float3Parameters[ parameterIndex ];
if( rExistingParameter.name == constantName )
{
newValue.SetElement( 0, rExistingParameter.value.GetElement( 0 ) );
newValue.SetElement( 1, rExistingParameter.value.GetElement( 1 ) );
newValue.SetElement( 2, rExistingParameter.value.GetElement( 2 ) );
break;
}
}
if( parameterIndex >= existingFloat3Count )
{
for( parameterIndex = 0; parameterIndex < existingFloat4Count; ++parameterIndex )
{
const Float4Parameter& rExistingParameter =
m_float4Parameters[ parameterIndex ];
if( rExistingParameter.name == constantName )
{
newValue = rExistingParameter.value;
break;
}
}
}
}
}
if( constantSize < sizeof( float32_t ) * 2 )
{
Float1Parameter* pParameter = newFloat1Parameters.New();
HELIUM_ASSERT( pParameter );
pParameter->name = constantName;
pParameter->value = newValue.GetElement( 0 );
}
else if( constantSize < sizeof( float32_t ) * 3 )
{
Float2Parameter* pParameter = newFloat2Parameters.New();
HELIUM_ASSERT( pParameter );
pParameter->name = constantName;
pParameter->value = Simd::Vector2( newValue.GetElement( 0 ), newValue.GetElement( 1 ) );
}
else if( constantSize < sizeof( float32_t ) * 4 )
{
Float3Parameter* pParameter = newFloat3Parameters.New();
HELIUM_ASSERT( pParameter );
pParameter->name = constantName;
pParameter->value =
Simd::Vector3( newValue.GetElement( 0 ), newValue.GetElement( 1 ), newValue.GetElement( 2 ) );
}
else
{
Float4Parameter* pParameter = newFloat4Parameters.New();
HELIUM_ASSERT( pParameter );
pParameter->name = constantName;
pParameter->value = newValue;
}
}
}
}
newFloat1Parameters.Trim();
newFloat2Parameters.Trim();
newFloat3Parameters.Trim();
newFloat4Parameters.Trim();
m_float1Parameters.Swap( newFloat1Parameters );
m_float2Parameters.Swap( newFloat2Parameters );
m_float3Parameters.Swap( newFloat3Parameters );
m_float4Parameters.Swap( newFloat4Parameters );
newFloat1Parameters.Clear();
newFloat2Parameters.Clear();
newFloat3Parameters.Clear();
newFloat4Parameters.Clear();
// Synchronize texture parameters.
size_t existingTextureCount = m_textureParameters.GetSize();
DynArray< TextureParameter > newTextureParameters;
for( size_t shaderTypeIndex = 0; shaderTypeIndex < HELIUM_ARRAY_COUNT( m_shaderVariants ); ++shaderTypeIndex )
{
ShaderVariant* pShaderVariant = m_shaderVariants[ shaderTypeIndex ];
if( !pShaderVariant )
{
continue;
}
const ShaderTextureInfoSet* pTextureSet = pShaderVariant->GetTextureInfoSet( 0 );
if( !pTextureSet )
{
continue;
}
bool bCheckDuplicates = !newTextureParameters.IsEmpty();
const DynArray< ShaderTextureInfo >& rTextureInputs = pTextureSet->inputs;
size_t textureInputCount = rTextureInputs.GetSize();
for( size_t textureIndex = 0; textureIndex < textureInputCount; ++textureIndex )
{
const ShaderTextureInfo& rTextureInfo = rTextureInputs[ textureIndex ];
// Ignore textures prefixed with an underscore, as they are reserved for system use.
Name textureInputName = rTextureInfo.name;
if( !textureInputName.IsEmpty() && ( *textureInputName )[ 0 ] == TXT( '_' ) )
{
continue;
}
size_t parameterIndex;
if( bCheckDuplicates )
{
size_t textureParameterCount = newTextureParameters.GetSize();
for( parameterIndex = 0; parameterIndex < textureParameterCount; ++parameterIndex )
{
if( newTextureParameters[ parameterIndex ].name == textureInputName )
{
break;
}
}
if( parameterIndex < textureParameterCount )
{
continue;
}
}
TextureParameter* pParameter = newTextureParameters.New();
HELIUM_ASSERT( pParameter );
pParameter->name = textureInputName;
for( parameterIndex = 0; parameterIndex < existingTextureCount; ++parameterIndex )
{
const TextureParameter& rTextureParameter = m_textureParameters[ parameterIndex ];
if( rTextureParameter.name == textureInputName )
{
pParameter->value = rTextureParameter.value;
break;
}
}
}
}
newTextureParameters.Trim();
m_textureParameters.Swap( newTextureParameters );
newTextureParameters.Clear();
}