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; }