void ReflectStlVectorInterpreter::OnMoveDown( const ButtonClickedArgs& args )
{
Reflect::ObjectPtr clientData = args.m_Control->GetClientData();
if ( clientData.ReferencesObject() && clientData->IsClass( Reflect::GetClass<ClientData>() ) )
{
ClientData* data = static_cast< ClientData* >( clientData.Ptr() );
List* list = static_cast< List* >( data->GetControl() );
std::set< size_t > selectedItemIndices = list->a_SelectedItemIndices.Get();
if ( !selectedItemIndices.empty() )
{
// for each array in the selection set (the objects the array data is connected to)
std::vector< DataPtr >::const_iterator serItr = m_Datas.begin();
std::vector< DataPtr >::const_iterator serEnd = m_Datas.end();
for ( ; serItr != serEnd; ++serItr )
{
Reflect::StlVectorData* arrayData = Reflect::AssertCast<Reflect::StlVectorData>(*serItr);
arrayData->MoveDown( selectedItemIndices );
}
list->a_SelectedItemIndices.Set( selectedItemIndices );
args.m_Control->GetCanvas()->Read();
}
}
}
///////////////////////////////////////////////////////////////////////////////
// Callback for when the remove button is pressed. If there are any items
// selected in the list control, they will be removed from the list.
//
void ReflectStlSetInterpreter::OnRemove( const ButtonClickedArgs& args )
{
Reflect::ObjectPtr clientData = args.m_Control->GetClientData();
if ( clientData.ReferencesObject() && clientData->IsClass( Reflect::GetClass<ClientData>() ) )
{
ClientData* data = static_cast< ClientData* >( clientData.Ptr() );
List* list = static_cast< List* >( data->GetControl() );
const std::set< size_t >& selectedItemIndices = list->a_SelectedItemIndices.Get();
if ( !selectedItemIndices.empty() )
{
// for each item in the array to remove (by index)
std::set< size_t >::const_reverse_iterator itr = selectedItemIndices.rbegin();
std::set< size_t >::const_reverse_iterator end = selectedItemIndices.rend();
for ( ; itr != end; ++itr )
{
// for each array in the selection set (the objects the array data is connected to)
std::vector< DataPtr >::const_iterator serItr = m_Datas.begin();
std::vector< DataPtr >::const_iterator serEnd = m_Datas.end();
for ( ; serItr != serEnd; ++serItr )
{
Reflect::StlSetData* setData = Reflect::AssertCast<Reflect::StlSetData>(*serItr);
std::vector< DataPtr > items;
setData->GetItems( items );
setData->RemoveItem( items[ *itr ] );
}
}
list->a_SelectedItemIndices.Set( std::set< size_t > () );
args.m_Control->GetCanvas()->Read();
}
}
}
void SettingsDialog::OnRestoreDefaults( wxCommandEvent& args )
{
wxMessageDialog dialog( this, wxT( "Are you sure you want to reset these settings to the default values?" ), wxT( "Confirm Default Settings" ), wxYES_NO );
if ( dialog.ShowModal() == wxID_NO )
{
return;
}
if ( !m_CurrentSetting )
{
return;
}
Reflect::ObjectPtr defaultElement = Reflect::SafeCast<Reflect::Object>( Reflect::Registry::GetInstance()->CreateInstance( m_CurrentSetting->m_Clone->GetClass() ) );
if ( !defaultElement )
{
return;
}
if ( !defaultElement->Equals( m_CurrentSetting->m_Clone ) )
{
defaultElement->CopyTo( m_CurrentSetting->m_Clone );
m_CurrentSetting->m_Clone->RaiseChanged();
m_CurrentSetting->m_Canvas->Read();
}
}
///////////////////////////////////////////////////////////////////////////////
// Returns true if the specified item can be added to the array. This is
// determined by checking to make sure that the item derived from the common
// base class that was specified earlier.
//
bool ClipboardElementArray::CanAdd( const Reflect::ObjectPtr& item ) const
{
if ( !item.ReferencesObject() )
{
return false;
}
return item->IsA( GetCommonBaseClass() );
}
///////////////////////////////////////////////////////////////////////////////
// Callback for when the add button is pressed. Displays a dialog that lets
// you enter a new key-value pair. If you enter a key that already exists in
// the list, you will be asked if you want to replace it or not.
//
void ReflectStlSetInterpreter::OnAdd( const ButtonClickedArgs& args )
{
Reflect::ObjectPtr clientData = args.m_Control->GetClientData();
if ( clientData.ReferencesObject() && clientData->IsClass( Reflect::GetClass<ClientData>() ) )
{
ClientData* data = static_cast< ClientData* >( clientData.Ptr() );
List* list = static_cast< List* >( data->GetControl() );
list->e_AddItem.Raise( AddItemArgs() );
args.m_Control->GetCanvas()->Read();
}
}
bool Helium::Material::LoadPersistentResourceObject( Reflect::ObjectPtr &_object )
{
HELIUM_ASSERT(_object.ReferencesObject());
if (!_object.ReferencesObject())
{
return false;
}
_object->CopyTo(&m_persistentResourceData);
return true;
}
bool Helium::Font::LoadPersistentResourceObject( Reflect::ObjectPtr &_object )
{
HELIUM_ASSERT(_object.ReferencesObject());
if (!_object.ReferencesObject())
{
return false;
}
_object->CopyTo(&m_persistentResourceData);
uint_fast32_t characterCount = static_cast<uint_fast32_t>(m_persistentResourceData.m_characters.GetSize());
uint_fast8_t textureCount = m_persistentResourceData.m_textureCount;
delete [] m_persistentResourceData.m_pspTextures;
m_persistentResourceData.m_pspTextures = NULL;
delete [] m_persistentResourceData.m_pTextureLoadIds;
m_persistentResourceData.m_pTextureLoadIds = NULL;
if( textureCount != 0 )
{
m_persistentResourceData.m_pspTextures = new RTexture2dPtr [ textureCount ];
HELIUM_ASSERT( m_persistentResourceData.m_pspTextures );
if( m_persistentResourceData.m_pspTextures )
{
m_persistentResourceData.m_pTextureLoadIds = new size_t [ textureCount ];
HELIUM_ASSERT( m_persistentResourceData.m_pTextureLoadIds );
if( m_persistentResourceData.m_pTextureLoadIds )
{
MemorySet(
m_persistentResourceData.m_pTextureLoadIds,
0xff,
static_cast< size_t >( textureCount ) * sizeof( m_persistentResourceData.m_pTextureLoadIds[ 0 ] ) );
}
else
{
delete [] m_persistentResourceData.m_pspTextures;
m_persistentResourceData.m_pspTextures = NULL;
}
}
if( !m_persistentResourceData.m_pspTextures )
{
m_persistentResourceData.m_textureCount = 0;
}
}
return true;
}
bool Helium::Mesh::LoadPersistentResourceObject( Reflect::ObjectPtr &_object )
{
m_spVertexBuffer.Release();
m_spIndexBuffer.Release();
HELIUM_ASSERT(_object.ReferencesObject());
if (!_object.ReferencesObject())
{
return false;
}
_object->CopyTo(&m_persistentResourceData);
return true;
}
/// @copydoc ResourceHandler::CacheResource()
bool MaterialResourceHandler::CacheResource(
AssetPreprocessor* pAssetPreprocessor,
Resource* pResource,
const String& /*rSourceFilePath*/ )
{
HELIUM_ASSERT( pAssetPreprocessor );
HELIUM_ASSERT( pResource );
Material* pMaterial = Reflect::AssertCast< Material >( pResource );
Shader* pShader = pMaterial->GetShader();
bool failedToWriteASubdata = false;
StrongPtr< Material::PersistentResourceData > resource_data( new Material::PersistentResourceData() );
// Compute the shader variant indices from the user options selected in the material, as the array of indices in
// the material is not yet initialized.
//uint32_t shaderVariantIndices[ RShader::TYPE_MAX ];
if( pShader )
{
const Shader::Options& rShaderUserOptions = pShader->GetUserOptions();
const DynamicArray< Shader::SelectPair >& rMaterialUserOptions = pMaterial->GetUserOptions();
for( size_t shaderTypeIndex = 0; shaderTypeIndex < RShader::TYPE_MAX; ++shaderTypeIndex )
{
size_t optionSetIndex = rShaderUserOptions.GetOptionSetIndex(
static_cast< RShader::EType >( shaderTypeIndex ),
rMaterialUserOptions.GetData(),
rMaterialUserOptions.GetSize() );
resource_data->m_shaderVariantIndices[ shaderTypeIndex ] = static_cast< uint32_t >( optionSetIndex );
}
}
else
{
MemoryZero( resource_data->m_shaderVariantIndices, sizeof( resource_data->m_shaderVariantIndices ) );
}
size_t float1ParameterCount = pMaterial->GetFloat1ParameterCount();
size_t float2ParameterCount = pMaterial->GetFloat2ParameterCount();
size_t float3ParameterCount = pMaterial->GetFloat3ParameterCount();
size_t float4ParameterCount = pMaterial->GetFloat4ParameterCount();
Name parameterConstantBufferName = Material::GetParameterConstantBufferName();
for( size_t platformIndex = 0; platformIndex < static_cast< size_t >( Cache::PLATFORM_MAX ); ++platformIndex )
{
PlatformPreprocessor* pPreprocessor = pAssetPreprocessor->GetPlatformPreprocessor(
static_cast< Cache::EPlatform >( platformIndex ) );
if( !pPreprocessor )
{
continue;
}
Resource::PreprocessedData& rPreprocessedData = pResource->GetPreprocessedData(
static_cast< Cache::EPlatform >( platformIndex ) );
SaveObjectToPersistentDataBuffer(resource_data.Get(), rPreprocessedData.persistentDataBuffer);
rPreprocessedData.bLoaded = true;
// Write out the parameter constant buffer data as the resource sub-data.
size_t shaderProfileCount = pPreprocessor->GetShaderProfileCount();
DynamicArray< DynamicArray< uint8_t > >& rSubDataBuffers = rPreprocessedData.subDataBuffers;
rSubDataBuffers.Clear();
rSubDataBuffers.Reserve( shaderProfileCount * RShader::TYPE_MAX );
rSubDataBuffers.Resize( shaderProfileCount * RShader::TYPE_MAX );
if( pShader )
{
// deserializer.SetByteSwapping( bSwapBytes );
for( size_t shaderTypeIndex = 0; shaderTypeIndex < RShader::TYPE_MAX; ++shaderTypeIndex )
{
RShader::EType shaderType = static_cast< RShader::EType >( shaderTypeIndex );
size_t variantLoadId = pShader->BeginLoadVariant(
shaderType,
resource_data->m_shaderVariantIndices[ shaderTypeIndex ] );
if( IsInvalid( variantLoadId ) )
{
continue;
}
ShaderVariantPtr spVariant;
while( !pShader->TryFinishLoadVariant( variantLoadId, spVariant ) )
{
}
ShaderVariant* pVariant = spVariant;
if( !pVariant )
{
continue;
}
const Resource::PreprocessedData& rVariantData = pVariant->GetPreprocessedData(
static_cast< Cache::EPlatform >( platformIndex ) );
HELIUM_ASSERT( rVariantData.bLoaded );
const DynamicArray< DynamicArray< uint8_t > >& rVariantSubDataBuffers = rVariantData.subDataBuffers;
size_t variantSubDataCount = rVariantSubDataBuffers.GetSize();
HELIUM_ASSERT( variantSubDataCount != 0 );
HELIUM_ASSERT( variantSubDataCount % shaderProfileCount == 0 );
size_t systemOptionSetCount = variantSubDataCount / shaderProfileCount;
for( size_t profileIndex = 0; profileIndex < shaderProfileCount; ++profileIndex )
{
// Get the first option set of each profile
const DynamicArray< uint8_t >& rVariantSubData =
rVariantSubDataBuffers[ profileIndex * systemOptionSetCount ];
Reflect::ObjectPtr variantSubDataObjectPtr =
Cache::ReadCacheObjectFromBuffer(rVariantSubData);
if (!variantSubDataObjectPtr.ReferencesObject())
{
HELIUM_TRACE(
TraceLevels::Error,
"MaterialResourceHandler: A shader variant subdata could not be read. (Option Set: %d Profile: %d)",
0,
profileIndex );
failedToWriteASubdata = true;
}
else if (!variantSubDataObjectPtr->IsA(Reflect::GetMetaClass<CompiledShaderData>()))
{
HELIUM_TRACE(
TraceLevels::Error,
"MaterialResourceHandler: A shader variant subdata was of an unexpected type. (Option Set: %d Profile: %d)\n",
0,
profileIndex );
failedToWriteASubdata = true;
}
else
{
CompiledShaderData &csd = *Reflect::AssertCast<CompiledShaderData>(variantSubDataObjectPtr.Get());
size_t bufferCount = csd.constantBuffers.GetSize();
for( size_t bufferIndex = 0; bufferIndex < bufferCount; ++bufferIndex )
{
const ShaderConstantBufferInfo& rBufferInfo = csd.constantBuffers[ bufferIndex ];
if( rBufferInfo.name != parameterConstantBufferName )
{
continue;
}
size_t bufferSize = rBufferInfo.size;
DynamicArray< uint8_t >& rMaterialSubData =
rSubDataBuffers[ profileIndex * RShader::TYPE_MAX + shaderTypeIndex ];
rMaterialSubData.Clear();
rMaterialSubData.Reserve( bufferSize );
rMaterialSubData.Add( 0, bufferSize );
DynamicMemoryStream memoryStream( &rMaterialSubData );
ByteSwappingStream byteSwapStream( &memoryStream );
Stream& rOutputStream = memoryStream;
//Stream& rOutputStream =
// ( bSwapBytes
// ? static_cast< Stream& >( byteSwapStream )
// : static_cast< Stream& >( memoryStream ) );
const DynamicArray< ShaderConstantInfo >& rConstants = rBufferInfo.constants;
size_t constantCount = rConstants.GetSize();
for( size_t constantIndex = 0; constantIndex < constantCount; ++constantIndex )
{
const ShaderConstantInfo& rConstantInfo = rConstants[ constantIndex ];
Name constantName = rConstantInfo.name;
size_t parameterIndex;
for( parameterIndex = 0; parameterIndex < float1ParameterCount; ++parameterIndex )
{
const Material::Float1Parameter& rParameter = pMaterial->GetFloat1Parameter(
parameterIndex );
if( rParameter.name == constantName )
{
rOutputStream.Seek( rConstantInfo.offset, SeekOrigins::Begin );
rOutputStream.Write(
&rParameter.value,
sizeof( float32_t ),
Min< size_t >( 1, rConstantInfo.size / sizeof( float32_t ) ) );
break;
}
}
if( parameterIndex >= float1ParameterCount )
{
for( parameterIndex = 0; parameterIndex < float2ParameterCount; ++parameterIndex )
{
const Material::Float2Parameter& rParameter = pMaterial->GetFloat2Parameter(
parameterIndex );
if( rParameter.name == constantName )
{
rOutputStream.Seek( rConstantInfo.offset, SeekOrigins::Begin );
rOutputStream.Write(
&rParameter.value,
sizeof( float32_t ),
Min< size_t >( 2, rConstantInfo.size / sizeof( float32_t ) ) );
break;
}
}
if( parameterIndex >= float2ParameterCount )
{
for( parameterIndex = 0;
parameterIndex < float3ParameterCount;
++parameterIndex )
{
const Material::Float3Parameter& rParameter = pMaterial->GetFloat3Parameter(
parameterIndex );
if( rParameter.name == constantName )
{
rOutputStream.Seek( rConstantInfo.offset, SeekOrigins::Begin );
rOutputStream.Write(
&rParameter.value,
sizeof( float32_t ),
Min< size_t >( 3, rConstantInfo.size / sizeof( float32_t ) ) );
break;
}
}
if( parameterIndex >= float3ParameterCount )
{
for( parameterIndex = 0;
parameterIndex < float4ParameterCount;
++parameterIndex )
{
const Material::Float4Parameter& rParameter =
pMaterial->GetFloat4Parameter( parameterIndex );
if( rParameter.name == constantName )
{
rOutputStream.Seek(
rConstantInfo.offset,
SeekOrigins::Begin );
rOutputStream.Write(
&rParameter.value,
sizeof( float32_t ),
Min< size_t >( 4, rConstantInfo.size / sizeof( float32_t ) ) );
break;
}
}
}
}
}
}
break;
}
}
}
}
}
}
return !failedToWriteASubdata;
}
bool Helium::AssetIdentifier::Identify( const Reflect::ObjectPtr& object, Name* identity )
{
Asset *pAsset = Reflect::SafeCast<Asset>(object);
if ( pAsset )
{
if ( identity )
{
identity->Set(pAsset->GetPath().ToString());
HELIUM_TRACE( TraceLevels::Info, "Identifying object [%s]\n", identity->Get() );
}
return true;
}
else if ( object )
{
HELIUM_TRACE( TraceLevels::Info, "Deferring identification of object of type [%s]\n", object->GetMetaClass()->m_Name );
}
return false;
}