diff options
Diffstat (limited to 'Runtime/Graphics/ProceduralMaterial.cpp')
| -rw-r--r-- | Runtime/Graphics/ProceduralMaterial.cpp | 1339 |
1 files changed, 1339 insertions, 0 deletions
diff --git a/Runtime/Graphics/ProceduralMaterial.cpp b/Runtime/Graphics/ProceduralMaterial.cpp new file mode 100644 index 0000000..69b616a --- /dev/null +++ b/Runtime/Graphics/ProceduralMaterial.cpp @@ -0,0 +1,1339 @@ +#include "UnityPrefix.h" +#include "ProceduralMaterial.h" +#include "SubstanceArchive.h" +#include "Runtime/Serialize/TransferFunctions/SerializeTransfer.h" +#include "Runtime/GfxDevice/GfxDevice.h" +#include "Runtime/Threads/Thread.h" +#include "Runtime/Input/TimeManager.h" +#include "SubstanceSystem.h" +#include "Runtime/Graphics/Image.h" + +#if ENABLE_SUBSTANCE +#include "Runtime/BaseClasses/IsPlaying.h" +#endif + +#if UNITY_EDITOR +#include "Editor/Src/AssetPipeline/SubstanceImporter.h" +#include "Editor/Src/EditorUserBuildSettings.h" +#endif + +size_t GetProceduralMemoryBudget(ProceduralCacheSize budget) +{ + switch(budget) + { + case ProceduralCacheSize_NoLimit: + return 0; + case ProceduralCacheSize_Heavy: + return 512 * 1024 * 1024; + case ProceduralCacheSize_Medium: + return 256 * 1024 * 1024; + case ProceduralCacheSize_Tiny: + return 128 * 1024 * 1024; + case ProceduralCacheSize_None: + default: + return 1; + } +} + +Mutex ProceduralMaterial::m_InputMutex; + +IMPLEMENT_CLASS( ProceduralMaterial ) +IMPLEMENT_OBJECT_SERIALIZE( ProceduralMaterial ) + +ProceduralMaterial::ProceduralMaterial( MemLabelId label, ObjectCreationMode mode ) : + Super( label, mode ), + m_SubstanceData( NULL ), + m_Flags( 0 ), + m_LoadingBehavior( ProceduralLoadingBehavior_Generate ), + m_Width( 9 ), + m_Height( 9 ), +#if UNITY_EDITOR + m_isAlreadyLoadedInCurrentScene( false ), +#endif + m_AnimationUpdateRate( 42 ), // 24fps + m_AnimationTime( 0.0f ), + m_PingedPackage( NULL ), + m_PrototypeName( "" ) +{ +#if ENABLE_SUBSTANCE + integrationTimeStamp = GetSubstanceSystem().integrationTimeStamp; +#endif +} + +ProceduralMaterial::~ProceduralMaterial() +{ +#if ENABLE_SUBSTANCE + + /////@TODO: This is an incredible hack. Waiting for another process to complete in the destructor is a big no no, especially when it involves a Thread::Sleep ()... + UnlockObjectCreation(); + GetSubstanceSystem().NotifySubstanceDestruction(this); + LockObjectCreation(); + + Clean(); + + // Delete texture inputs (TODO: try to remove std::vector<Image*>) + for (std::vector<TextureInput>::iterator it=m_TextureInputs.begin();it!=m_TextureInputs.end();++it) + { + delete it->inputParameters; + delete it->image; + + if (it->buffer) + { + UNITY_FREE(kMemSubstance, it->buffer); + } + } +#endif +} + +void ProceduralMaterial::Clean() +{ +#if ENABLE_SUBSTANCE + if (m_SubstanceData!=NULL) + { + if (m_SubstanceData->instanceCount==1) + { + substanceHandleRelease(m_SubstanceData->substanceHandle); + // Clones do not delete their SBSBIN data, this is done in the destructor of the SubstanceArchive + // the clone was created from. + if (!IsFlagEnabled(Flag_Clone)) + { + UNITY_FREE( kMemSubstance, m_SubstanceData->substanceData ); + } + UNITY_FREE( kMemSubstance, m_SubstanceData ); + } + else + { + --m_SubstanceData->instanceCount; + } + } + m_SubstanceData = NULL; + // Awake inputs + for (SubstanceInputs::iterator i=m_Inputs.begin();i != m_Inputs.end();i++) + { + i->EnableFlag(SubstanceInput::Flag_Awake, true); + } +#endif +} + +ProceduralMaterial* ProceduralMaterial::Clone() +{ + ProceduralMaterial* clone = CreateObjectFromCode<ProceduralMaterial>(); + clone->m_SubstancePackage = m_SubstancePackage; + clone->m_PrototypeName = m_PrototypeName; + clone->m_Width = m_Width; + clone->m_Height = m_Height; + clone->m_Textures = m_Textures; + // Rename cloned textures + for (int idx=0 ; idx<m_Textures.size() ; ++idx) + { + clone->m_Textures[idx]->SetName(m_Textures[idx]->GetName()); + } + clone->m_AnimationUpdateRate = m_AnimationUpdateRate; + clone->m_Inputs = m_Inputs; + clone->m_Flags = ((m_Flags | Flag_Clone | Flag_AwakeClone) & (~Flag_ConstSize)); + clone->m_LoadingBehavior = m_LoadingBehavior; + clone->AwakeDependencies(false); + return clone; +} + +void ProceduralMaterial::RebuildClone() +{ + EnableFlag(Flag_AwakeClone, false); + + // Clone textures +#if ENABLE_SUBSTANCE + if (!IsWorldPlaying() || m_LoadingBehavior!=ProceduralLoadingBehavior_BakeAndDiscard) + { + for (Textures::iterator it=m_Textures.begin();it!=m_Textures.end();++it) + { + *it = (*it)->Clone(this); + } + + // Awake inputs + for (SubstanceInputs::iterator i=m_Inputs.begin();i != m_Inputs.end();i++) + { + i->EnableFlag(SubstanceInput::Flag_Awake, true); + } + + AwakeDependencies(false); + + // Force generation if required + if (m_LoadingBehavior==ProceduralLoadingBehavior_None) + EnableFlag(ProceduralMaterial::Flag_ForceGenerate); + + GetSubstanceSystem().QueueLoading(this); + } +#endif +} + +#if UNITY_EDITOR +void ProceduralMaterial::Init( SubstanceArchive& substancePackage, const UnityStr& prototypeName, const SubstanceInputs& inputs, const Textures& textures ) +{ + Assert(m_SubstancePackage.GetInstanceID () == 0); + + m_SubstancePackage = &substancePackage; + m_PrototypeName = prototypeName; + m_Inputs = inputs; + m_Textures = textures; + + EnableFlag(Flag_ConstSize); + + // Update Flag_Animated + EnableFlag(Flag_Animated, HasSubstanceProperty("$time")); +} + +const char* ProceduralMaterial::GetSubstancePackageName() +{ + if (m_PingedPackage) + { + return m_PingedPackage->GetName(); + } + else + { + return m_SubstancePackage->GetName(); + } +} + +#endif + +SubstanceHandle* ProceduralMaterial::GetSubstanceHandle() +{ + if (m_SubstanceData!=NULL) + return m_SubstanceData->substanceHandle; + return NULL; +} + +void ProceduralMaterial::SetSize(int width, int height) +{ + m_Width = width; + m_Height = height; + + Mutex::AutoLock locker(m_InputMutex); + SubstanceInput* input = FindSubstanceInput("$outputsize"); + if (input!=NULL) + { + input->value.scalar[0] = (float)m_Width; + input->value.scalar[1] = (float)m_Height; + } +} + +void ProceduralMaterial::AwakeFromLoadThreaded() +{ + Super::AwakeFromLoadThreaded(); + AwakeDependencies(true); +#if ENABLE_SUBSTANCE +#if UNITY_EDITOR + EnableFlag(Flag_Awake); +#endif + // Neither Baked (keep or discard) nor DoNothing substances must be generated at this time + ProceduralLoadingBehavior behavior = GetLoadingBehavior(); + if (behavior != ProceduralLoadingBehavior_BakeAndKeep && + behavior != ProceduralLoadingBehavior_BakeAndDiscard && + behavior != ProceduralLoadingBehavior_None) + { + GetSubstanceSystem().QueueLoading(this); + } +#endif +} + +void ProceduralMaterial::AwakeFromLoad( AwakeFromLoadMode awakeMode ) +{ + Super::AwakeFromLoad( awakeMode ); + + if ((awakeMode & kDidLoadThreaded)==0) + { + AwakeDependencies(false); + +#if ENABLE_SUBSTANCE + +#if UNITY_EDITOR + EnableFlag(Flag_Awake); + if (awakeMode!=kInstantiateOrCreateFromCodeAwakeFromLoad + && SubstanceImporter::OnLoadSubstance(*this) + && !(IsWorldPlaying() && m_LoadingBehavior==ProceduralLoadingBehavior_None)) +#else + // Don't link and render the DoNothing substances when loading them + // This is done when calling RebuildTextures instead + if (m_LoadingBehavior!=ProceduralLoadingBehavior_None) +#endif + { + GetSubstanceSystem().QueueSubstance(this); + } + +#endif + } + +#if ENABLE_SUBSTANCE + GetSubstanceSystem().NotifySubstanceCreation(this); +#endif +} + +#if ENABLE_SUBSTANCE +void ProceduralMaterial::ApplyInputs (bool& it_has_changed, bool asHint, std::set<unsigned int>& modifiedOutputsUID) +{ + int textureInputIndex(0); + + // Handle input alteration + for (SubstanceInputs::iterator i=m_Inputs.begin();i != m_Inputs.end();i++) + { + SubstanceInput& input = *i; + + // Skip const inputs at runtime +#if !UNITY_EDITOR + if (IsFlagEnabled(Flag_ConstSize) + && (input.name=="$outputsize" || input.name=="$randomseed")) + { + continue; + } +#endif + + // Check texture instance hasn't changed, in the editor in case of texture changes +#if UNITY_EDITOR + if (!input.IsFlagEnabled(SubstanceInput::Flag_Modified) && (input.internalType==Substance_IType_Image) + && textureInputIndex<m_TextureInputs.size()) + { + Texture2D* checkTexture = dynamic_pptr_cast<Texture2D*>( + InstanceIDToObjectThreadSafe(input.value.texture.GetInstanceID())); + if (m_TextureInputs[textureInputIndex].texture!=checkTexture) + m_TextureInputs[textureInputIndex].texture = checkTexture; + } +#endif + + if (asHint) + { + // Push hint if needed + if (input.IsFlagEnabled(SubstanceInput::Flag_Modified) || input.IsFlagEnabled(SubstanceInput::Flag_Cached)) + { + if (!input.IsFlagEnabled(SubstanceInput::Flag_SkipHint)) + { + if (substanceHandlePushSetInput( m_SubstanceData->substanceHandle, Substance_PushOpt_HintOnly, input.internalIndex, input.internalType, 0, 0 )!=0) + ErrorStringObject("Failed to apply substance input as hint", this); + } + it_has_changed = true; + input.EnableFlag(SubstanceInput::Flag_Modified, false); + } + + if (input.IsFlagEnabled(SubstanceInput::Flag_Awake)) + { + it_has_changed = true; + input.EnableFlag(SubstanceInput::Flag_Awake, false); + } + } + else if (input.IsFlagEnabled(SubstanceInput::Flag_Modified) || input.IsFlagEnabled(SubstanceInput::Flag_Awake)) + { + int error = 0; + + // Apply Float values + if (IsSubstanceAnyFloatType(input.internalType)) + { + error = substanceHandlePushSetInput( m_SubstanceData->substanceHandle, Substance_PushOpt_NotAHint, input.internalIndex, input.internalType, input.value.scalar, 0 ); + } + // Apply integer values + else if (IsSubstanceAnyIntType(input.internalType)) + { + int intValue[4]; + intValue[0] = (int)input.value.scalar[0]; + intValue[1] = (int)input.value.scalar[1]; + intValue[2] = (int)input.value.scalar[2]; + intValue[3] = (int)input.value.scalar[3]; + error = substanceHandlePushSetInput( m_SubstanceData->substanceHandle, Substance_PushOpt_NotAHint, input.internalIndex, input.internalType, intValue, 0 ); + } + // Apply image values + else if (input.internalType == Substance_IType_Image) + { + if (textureInputIndex>=m_TextureInputs.size()) + { + ErrorStringObject("failed to apply substance input image", this); + } + else + { + error = substanceHandlePushSetInput( m_SubstanceData->substanceHandle, Substance_PushOpt_NotAHint, input.internalIndex, input.internalType, m_TextureInputs[textureInputIndex].inputParameters, 0 ); + } + } + else + { + ErrorStringObject("unsupported substance input type", this); + } + if (error != 0) + ErrorStringObject("Failed to apply substance input", this); + + // Add modified output + modifiedOutputsUID.insert(input.alteredTexturesUID.begin(), input.alteredTexturesUID.end()); + } + + // Keep the texture input index up to date + if (input.internalType == Substance_IType_Image) + { + ++textureInputIndex; + } + } +} + +void ProceduralMaterial::ApplyOutputs (bool& it_has_changed, bool asHint, std::set<unsigned int>& modifiedOutputsUID, const std::set<unsigned int>& cachedTextureIDs) +{ + // Add the invalid outputs + if (!asHint) + { + for (PingedTextures::iterator it=m_PingedTextures.begin();it!=m_PingedTextures.end();++it) + { + if (*it!=NULL && !(*it)->IsValid()) + { + modifiedOutputsUID.insert((*it)->GetSubstanceBaseTextureUID()); + it_has_changed = true; + } + } + } + + // Push outputs + unsigned int flags = Substance_OutOpt_TextureId | Substance_OutOpt_CopyNeeded | (asHint?Substance_PushOpt_HintOnly:0); + GetSubstanceSystem ().processedTextures.clear(); + std::vector<unsigned int> textureIDs; + for (PingedTextures::iterator i=m_PingedTextures.begin();i!=m_PingedTextures.end();++i) + { + ProceduralTexture* texture = *i; + if (texture!=NULL && modifiedOutputsUID.find(texture->GetSubstanceBaseTextureUID())!=modifiedOutputsUID.end() + && cachedTextureIDs.find(texture->GetSubstanceBaseTextureUID())==cachedTextureIDs.end()) + { + GetSubstanceSystem ().processedTextures[texture->GetSubstanceTextureUID()] = texture; + textureIDs.push_back(texture->GetSubstanceTextureUID()); + } + } + + if (textureIDs.size()==0) + { + modifiedOutputsUID.clear(); + it_has_changed = false; + } + + if (textureIDs.size()>0 && substanceHandlePushOutputs( m_SubstanceData->substanceHandle, flags, &textureIDs[0], textureIDs.size(), 0 )!=0) + { + ErrorStringObject("Failed to apply substance texture outputs", this); + } +} +#endif + +void ProceduralMaterial::RebuildTextures() +{ + if (IsFlagEnabled(Flag_AwakeClone)) + { + RebuildClone(); + } +#if ENABLE_SUBSTANCE + else if (!IsWorldPlaying() || m_LoadingBehavior!=ProceduralLoadingBehavior_BakeAndDiscard) + { + GetSubstanceSystem().QueueSubstance(this); + } +#endif +} + +void ProceduralMaterial::RebuildTexturesImmediately() +{ + ASSERT_RUNNING_ON_MAIN_THREAD; + RebuildTextures(); +#if ENABLE_SUBSTANCE + GetSubstanceSystem().WaitFinished(this); +#endif +} + +void ProceduralMaterial::ReloadAll (bool unload, bool load) +{ +#if ENABLE_SUBSTANCE + std::vector<SInt32> objects; + Object::FindAllDerivedObjects (ClassID (ProceduralMaterial), &objects); + std::sort(objects.begin(), objects.end()); + + if (objects.empty()) + return; + + GetSubstanceSystem().WaitFinished(); + for (int i=0;i<objects.size ();i++) + { + ProceduralMaterial& mat = *PPtr<ProceduralMaterial> (objects[i]); + Textures& textures = mat.GetTextures(); + for (Textures::iterator it=textures.begin() ; it!=textures.end() ; ++it) + { +#if UNITY_EDITOR + (*it)->EnableFlag(ProceduralTexture::Flag_Cached, false); +#endif + (*it)->Invalidate(); + } +#if UNITY_EDITOR + mat.EnableFlag(ProceduralMaterial::Flag_Awake); +#endif + if (mat.m_LoadingBehavior==ProceduralLoadingBehavior_BakeAndDiscard || (unload && !load)) + { + for (Textures::iterator it=textures.begin() ; it!=textures.end() ; ++it) + { + if (unload) + (*it)->UnloadFromGfxDevice(false); + if (load) + (*it)->UploadToGfxDevice(); + } + } + else + { + mat.RebuildTextures (); + } + } + SubstanceSystem::Context context(ProceduralProcessorUsage_All); + GetSubstanceSystem().WaitFinished(); +#endif +} + +template<class _class_> +void AwakeProceduralObject(PPtr<_class_>& pptr, _class_*& object, bool awakeThreaded) +{ + if (awakeThreaded) + { + #if SUPPORT_THREADS + Assert (!Thread::CurrentThreadIsMainThread()); + #endif + + // Awake the object + object = dynamic_pptr_cast<_class_*> (InstanceIDToObjectThreadSafe(pptr.GetInstanceID())); + } + else + { + #if SUPPORT_THREADS + Assert (Thread::CurrentThreadIsMainThread()); + #endif + + // We can safely load it synchroneously + object = pptr; + } + + // Clear the PPtr if the object no more exist (removed/deprecated) + if (object==NULL) + pptr.SetInstanceID(0); +} + +void ProceduralMaterial::AwakeDependencies(bool awakeThreaded) +{ + // Simplest validity check + if (m_Textures.size()==0) + { + EnableFlag(Flag_Broken); + return; + } + +#if ENABLE_SUBSTANCE + // Awake package + AwakeProceduralObject(m_SubstancePackage, m_PingedPackage, awakeThreaded); + if (m_PingedPackage==NULL && m_LoadingBehavior!=ProceduralLoadingBehavior_BakeAndDiscard) + { + EnableFlag(Flag_Broken); + return; + } + + // Awake texture inputs + unsigned int input_count(0); + for (SubstanceInputs::iterator it=m_Inputs.begin();it!=m_Inputs.end();++it) + { + if (it->internalType==Substance_IType_Image) + { + if (input_count>=m_TextureInputs.size()) + { + m_TextureInputs.push_back( TextureInput() ); + m_TextureInputs.back().inputParameters = new SubstanceTextureInput(); + memset(m_TextureInputs.back().inputParameters, 0, sizeof(SubstanceTextureInput)); + m_TextureInputs.back().image = new Image(); + m_TextureInputs.back().buffer = NULL; + } + + AwakeProceduralObject(it->value.texture, m_TextureInputs[input_count].texture, awakeThreaded); + ++input_count; + } + } +#endif + + // Awake textures + if (m_PingedTextures.size()!=m_Textures.size()) + { + int size = m_PingedTextures.size(); + m_PingedTextures.resize(m_Textures.size()); + if (size<m_PingedTextures.size()) + memset(&m_PingedTextures[size], 0, sizeof(ProceduralTexture*)*(m_Textures.size()-size)); + } + + int texture_index(0); + for (ProceduralMaterial::Textures::iterator i=m_Textures.begin();i!=m_Textures.end();++i,++texture_index) + { + AwakeProceduralObject(*i, m_PingedTextures[texture_index], awakeThreaded); + if (m_PingedTextures[texture_index]==NULL) + { + EnableFlag(Flag_Broken); + return; + } + m_PingedTextures[texture_index]->SetOwner(this); + } +} + +#if ENABLE_SUBSTANCE + +bool ProceduralMaterial::ProcessTexturesThreaded(const std::map<ProceduralTexture*, SubstanceTexture>& textures) +{ + if (IsFlagEnabled(Flag_Broken)) + return true; + + GetSubstanceSystem().UpdateMemoryBudget(); + + std::set<unsigned int> cachedTextureIDs; +#if ENABLE_CACHING && !UNITY_EDITOR + if (PreProcess(cachedTextureIDs)) + { + return true; + } +#else + // Force rebuild if it's cached and no input is modified + InvalidateIfCachedOrInvalidTextures(); +#endif + + // Apply substance parameters (this is the exact ordering the engine needs) + std::set<unsigned int> modifiedOutputsUID; + bool it_has_changed(false); + // Apply inputs values + ApplyInputs (it_has_changed, false, modifiedOutputsUID); + + // For readable textures, force the rebuild by pushing all output UIDs, + // even if no input was changed (Bnecessary for a clean workflow for case 538383 / GetPixels32()) + if (IsFlagEnabled(Flag_Readable)) + { + for (PingedTextures::iterator i=m_PingedTextures.begin() ; i!=m_PingedTextures.end() ; ++i) + { + ProceduralTexture* texture = *i; + modifiedOutputsUID.insert(texture->GetSubstanceBaseTextureUID()); + } + } + + // Apply outputs uid + ApplyOutputs(it_has_changed, false, modifiedOutputsUID, cachedTextureIDs); + // Apply input hints + ApplyInputs (it_has_changed, true, modifiedOutputsUID); + // Apply outputs hints + ApplyOutputs(it_has_changed, true, modifiedOutputsUID, cachedTextureIDs); + + if (!IsFlagEnabled(Flag_Readable) && !it_has_changed) + { + // Flush render list + substanceHandleFlush( m_SubstanceData->substanceHandle ); + return false; + } + + if (substanceHandleStart( m_SubstanceData->substanceHandle, Substance_Sync_Synchronous )!=0) + ErrorStringObject("Failed to start substance computation", this); + + // Flush render list + substanceHandleFlush( m_SubstanceData->substanceHandle ); + +#if ENABLE_CACHING && !UNITY_EDITOR + PostProcess(textures, cachedTextureIDs); +#endif + return true; +} + +void ProceduralMaterial::ApplyTextureInput (int substanceInputIndex, const SubstanceTextureInput& requiredTextureInput) +{ + // Find which input needs update + bool found(false); + int textureInputIndex(0); + SubstanceInput* input; + for (SubstanceInputs::iterator i=m_Inputs.begin();i != m_Inputs.end();i++) + { + input = &*i; + if (input->internalIndex==substanceInputIndex) + { + found = true; + break; + } + if (input->internalType==Substance_IType_Image) + { + ++textureInputIndex; + } + } + if (!found || textureInputIndex>=m_TextureInputs.size()) + { + ErrorStringObject("Failed to push Substance texture input", this); + return; + } + + // Check format + TextureFormat format; + bool need16bitsConvert(false); + if (requiredTextureInput.pixelFormat==Substance_PF_RGBA) + format = kTexFormatRGBA32; + else if (requiredTextureInput.pixelFormat==Substance_PF_RGB) + format = kTexFormatRGB24; + else if (requiredTextureInput.pixelFormat==(Substance_PF_16b | Substance_PF_RGBA)) + { + format = kTexFormatRGBA32; + need16bitsConvert = true; + } + else if (requiredTextureInput.pixelFormat==(Substance_PF_16b | Substance_PF_RGB)) + { + format = kTexFormatRGB24; + need16bitsConvert = true; + } + else if (requiredTextureInput.pixelFormat==Substance_PF_DXT1) + format = kTexFormatDXT1; + else if (requiredTextureInput.pixelFormat==Substance_PF_DXT3) + format = kTexFormatDXT3; + else if (requiredTextureInput.pixelFormat==Substance_PF_DXT5) + format = kTexFormatDXT5; + else if (requiredTextureInput.pixelFormat==Substance_PF_L) + format = kTexFormatAlpha8; + else + { + ErrorStringObject("Failed to push Substance texture input : unsupported format", this); + return; + } + + if (m_TextureInputs.size()<=textureInputIndex) + { + ErrorStringObject("Failed to push Substance texture input : unexpected error", this); + return; + } + + // Initialize the texture input if required + TextureInput& textureInput = m_TextureInputs[textureInputIndex]; + if (textureInput.inputParameters->level0Width!=requiredTextureInput.level0Width + || textureInput.inputParameters->level0Height!=requiredTextureInput.level0Height + || textureInput.inputParameters->pixelFormat!=requiredTextureInput.pixelFormat) + { + // Fill format description + memcpy(textureInput.inputParameters, &requiredTextureInput, sizeof(SubstanceTextureInput)); + textureInput.inputParameters->mTexture.level0Width = textureInput.inputParameters->level0Width; + textureInput.inputParameters->mTexture.level0Height = textureInput.inputParameters->level0Height; + textureInput.inputParameters->mTexture.mipmapCount = textureInput.inputParameters->mipmapCount; + textureInput.inputParameters->mTexture.pixelFormat = textureInput.inputParameters->pixelFormat; + textureInput.inputParameters->mTexture.channelsOrder = 0; + textureInput.image->SetImage(textureInput.inputParameters->level0Width, textureInput.inputParameters->level0Height, format, true); + + if (textureInput.buffer!=NULL) + { + UNITY_FREE(kMemSubstance, textureInput.buffer); + textureInput.buffer = NULL; + } + + if (need16bitsConvert) + { + size_t pitch = ((requiredTextureInput.pixelFormat | Substance_PF_RGBA)?4:3)*sizeof(unsigned short); + textureInput.buffer = UNITY_MALLOC_ALIGNED_NULL(kMemSubstance, pitch*textureInput.inputParameters->level0Width*textureInput.inputParameters->level0Height, 16); + if (!textureInput.buffer) + { + ErrorString("Could not allocate memory for textureInput.buffer (ApplyTextureInput)"); + return; + } + textureInput.inputParameters->mTexture.buffer = textureInput.buffer; + } + else + { + textureInput.inputParameters->mTexture.buffer = textureInput.image->GetImageData(); + } + } + + Texture2D* texture = textureInput.texture; + if (texture==NULL) + { + // Default to white texture + textureInput.image->ClearImage(ColorRGBAf(1.0f, 1.0f, 1.0f, 1.0f)); + } + else + { + // Try to retrieve current texture + if (texture->ExtractImage(textureInput.image)) + { + textureInput.image->FlipImageY(); + } + else + { + ErrorStringObject("Incorrect ProceduralMaterial input", this); + if (texture->GetRawImageData()==NULL) + { + ErrorStringObject("ProceduralMaterial: Unexpected error (Texture input is not in RAM), try a reimport", texture); + } + else + { + ErrorStringObject("ProceduralMaterial: Texture input is compressed in undecompressable format, you should switch it to RAW, then reimport the material", texture); + } + + textureInput.image->ClearImage(ColorRGBAf(1.0f, 0.0f, 0.0f, 1.0f)); + } + } + + // Actually we can't force the input texture format using the Substance API, + // so here it requires 8bits -> 16bits conversion. + if (need16bitsConvert) + { + size_t pitch = (requiredTextureInput.pixelFormat | Substance_PF_RGBA)?4:3; + unsigned short * output = (unsigned short*)textureInput.buffer; + unsigned char * input = textureInput.image->GetImageData(); + unsigned char * inputEnd = input + pitch*textureInput.image->GetWidth()*textureInput.image->GetHeight(); + while(input!=inputEnd) + { + *(output++) = (unsigned short)*(input++)*257; + } + } +} +#endif + +void ProceduralMaterial::UpdateAnimation(float time) +{ + if (m_AnimationUpdateRate>0) + { + if (time<m_AnimationTime + || time>m_AnimationTime+m_AnimationUpdateRate/1000.0f) + { + m_AnimationTime = time; + SetSubstanceFloat("$time", time); + RebuildTextures(); + } + } +} + +std::vector<std::string> ProceduralMaterial::GetSubstanceProperties() const +{ + std::vector<std::string> properties; + for (SubstanceInputs::const_iterator i=m_Inputs.begin();i!=m_Inputs.end();++i) + { + properties.push_back(i->name); + } + return properties; +} + +bool ProceduralMaterial::HasSubstanceProperty( const std::string& inputName ) const +{ + Mutex::AutoLock locker(m_InputMutex); + return FindSubstanceInput(inputName)!=NULL; +} + +bool ProceduralMaterial::GetSubstanceBoolean( const std::string& inputName ) const +{ + Mutex::AutoLock locker(m_InputMutex); + const SubstanceInput* input = FindSubstanceInput(inputName); + if (input!=NULL) + { + return input->value.scalar[0]>0.5f; + } + return false; +} + +void ProceduralMaterial::SetSubstanceBoolean( const std::string& inputName, bool value ) +{ + SetSubstanceFloat( inputName, value?1.0f:0.0f ); +} + +float ProceduralMaterial::GetSubstanceFloat( const std::string& inputName ) const +{ + Mutex::AutoLock locker(m_InputMutex); + const SubstanceInput* input = FindSubstanceInput(inputName); + if (input!=NULL) + return input->value.scalar[0]; + return 0.0F; +} + +void ProceduralMaterial::SetSubstanceFloat( const std::string& inputName, float value ) +{ + SetSubstanceVector(inputName, Vector4f(value, 0.0f, 0.0f, 0.0f)); +} + +Vector4f ProceduralMaterial::GetSubstanceVector( const std::string& inputName ) const +{ + Mutex::AutoLock locker(m_InputMutex); + const SubstanceInput* input = FindSubstanceInput(inputName); + if (input!=NULL) + { + Vector4f value; + value.Set(input->value.scalar); + return value; + } + return Vector4f(0.0F, 0.0F, 0.0F, 0.0F); +} + +void ProceduralMaterial::SetSubstanceVector( const std::string& inputName, const Vector4f& value ) +{ + Mutex::AutoLock locker(m_InputMutex); + const SubstanceInput* input = FindSubstanceInput(inputName); + if (input!=NULL) + { + SubstanceValue inputValue; + memcpy(inputValue.scalar, value.GetPtr(), sizeof(float)*4); + SetDirty(); +#if ENABLE_SUBSTANCE + GetSubstanceSystem().QueueInput(this, inputName, inputValue); +#endif + } +} + +ColorRGBAf ProceduralMaterial::GetSubstanceColor( const std::string& inputName ) const +{ + Mutex::AutoLock locker(m_InputMutex); + const SubstanceInput* input = FindSubstanceInput(inputName); + if (input!=NULL) + { + ColorRGBAf value; + memcpy(value.GetPtr(), input->value.scalar, sizeof(float)*4); + return value; + } + + return ColorRGBAf(0.0F, 0.0F, 0.0F, 0.0F); +} + +void ProceduralMaterial::SetSubstanceColor( const std::string& inputName, const ColorRGBAf& value ) +{ + SetSubstanceVector(inputName, Vector4f(value.r, value.g, value.b, value.a)); +} + +int ProceduralMaterial::GetSubstanceEnum( const string& inputName ) +{ + Mutex::AutoLock locker(m_InputMutex); + SubstanceInput* input = FindSubstanceInput(inputName); + if (input!=NULL) + { + int index(0); + for (std::vector<SubstanceEnumItem>::iterator it=input->enumValues.begin();it!=input->enumValues.end();++it) + { + if ((int)input->value.scalar[0]==it->value) + { + return index; + } + + ++index; + } + } + return -1; +} + +void ProceduralMaterial::SetSubstanceEnum( const string& inputName, int value ) +{ + Mutex::AutoLock locker(m_InputMutex); + SubstanceInput* input = FindSubstanceInput(inputName); + if (input!=NULL && value>=0 && value<input->enumValues.size()) + { + SubstanceEnumItem& item = input->enumValues[value]; + SubstanceValue inputValue; + inputValue.scalar[0] = (float)item.value; + SetDirty(); +#if ENABLE_SUBSTANCE + GetSubstanceSystem().QueueInput(this, inputName, inputValue); +#endif + } +} + +Texture2D* ProceduralMaterial::GetSubstanceTexture( const string& inputName ) const +{ + Mutex::AutoLock locker(m_InputMutex); + const SubstanceInput* input = FindSubstanceInput(inputName); + if (input!=NULL && input->internalType == Substance_IType_Image) + return input->value.texture; + return NULL; +} + +void ProceduralMaterial::SetSubstanceTexture( const string& inputName, Texture2D* value ) +{ + Mutex::AutoLock locker(m_InputMutex); + const SubstanceInput* input(NULL); + int texture_index(0); + for (SubstanceInputs::iterator i=m_Inputs.begin();i!=m_Inputs.end();++i) + { + if (i->name==inputName) + { + input = &*i; + break; + } + if (i->type==ProceduralPropertyType_Texture) + ++texture_index; + } + + if (input!=NULL && input->type==ProceduralPropertyType_Texture + && texture_index<m_TextureInputs.size()) + { + m_TextureInputs[texture_index].texture = value; + SubstanceValue inputValue; + inputValue.texture = value; + SetDirty(); +#if ENABLE_SUBSTANCE + GetSubstanceSystem().QueueInput(this, inputName, inputValue); +#endif + } +} + +#if ENABLE_SUBSTANCE +void ProceduralMaterial::Callback_SetSubstanceInput( const string& inputName, SubstanceValue& inputValue) +{ + Mutex::AutoLock locker(m_InputMutex); + SubstanceInput* input = FindSubstanceInput(inputName); + + //AreSubstanceInputValuesEqual(input->internalType, input->value, inputValue)) + // Its up to the user to set value if it hasn't changed, he may want to really set the value + // even if it hasn't changed, to cache it for instance. + if (input==NULL) + return; + + ClampSubstanceInputValues(*input, inputValue); + + if (input->type==ProceduralPropertyType_Texture) + { + input->value.texture = inputValue.texture; + } + else + { + memcpy(input->value.scalar, inputValue.scalar, + sizeof(float)*GetRequiredInputComponentCount(input->internalType)); + } + + input->EnableFlag(SubstanceInput::Flag_Modified); + +#if !UNITY_EDITOR + if (IsFlagEnabled(Flag_ConstSize) && (input->name=="$outputsize" || input->name=="$randomseed")) + { + EnableFlag(Flag_ConstSize, false); + Clean(); + + // Initialize fresh substance data + std::vector<ProceduralMaterial*> materials; + materials.push_back(this); + PackSubstances(materials); + } +#endif +} +#endif + +const SubstanceInput* ProceduralMaterial::FindSubstanceInput( const string& inputName ) const +{ + for (SubstanceInputs::const_iterator i=m_Inputs.begin();i!=m_Inputs.end();++i) + { + if (i->name==inputName) + return &*i; + } + return NULL; +} + +SubstanceInput* ProceduralMaterial::FindSubstanceInput( const string& inputName ) +{ + for (SubstanceInputs::iterator i=m_Inputs.begin();i!=m_Inputs.end();++i) + { + if (i->name==inputName) + return &*i; + } + return NULL; +} + +bool ProceduralMaterial::IsSubstancePropertyCached( const string& inputName ) const +{ + const SubstanceInput* input = FindSubstanceInput(inputName); + if (input!=NULL) + return input->IsFlagEnabled(SubstanceInput::Flag_Cached); + return false; +} + +void ProceduralMaterial::CacheSubstanceProperty( const string& inputName, bool value ) +{ + SubstanceInput* input = FindSubstanceInput(inputName); + if (input!=NULL) + input->EnableFlag(SubstanceInput::Flag_Cached, value); +} + +void ProceduralMaterial::ClearCache() +{ +#if ENABLE_SUBSTANCE + for (SubstanceInputs::iterator it=m_Inputs.begin() ; it!=m_Inputs.end() ; ++it) + it->EnableFlag(SubstanceInput::Flag_Cached, false); + GetSubstanceSystem().QueryClearCache(this); +#endif +} + +void ProceduralMaterial::SetProceduralMemoryBudget(ProceduralCacheSize budget) +{ + SetProceduralMemorySleepBudget(budget); + + switch(budget) + { + case ProceduralCacheSize_Tiny: SetProceduralMemoryWorkBudget(ProceduralCacheSize_Medium); break; + case ProceduralCacheSize_Medium: SetProceduralMemoryWorkBudget(ProceduralCacheSize_Heavy); break; + case ProceduralCacheSize_Heavy: SetProceduralMemoryWorkBudget(ProceduralCacheSize_NoLimit); break; + case ProceduralCacheSize_NoLimit: SetProceduralMemoryWorkBudget(ProceduralCacheSize_NoLimit); break; + default: + case ProceduralCacheSize_None: SetProceduralMemoryWorkBudget(ProceduralCacheSize_Tiny); break; + } +} + +ProceduralCacheSize ProceduralMaterial::GetProceduralMemoryBudget() const +{ + if (m_SubstanceData==NULL) + return ProceduralCacheSize_None; + return m_SubstanceData->memoryWorkBudget; +} + +void ProceduralMaterial::SetProceduralMemoryWorkBudget(ProceduralCacheSize budget) +{ + if (m_SubstanceData!=NULL) + m_SubstanceData->memoryWorkBudget = budget; +} + +ProceduralCacheSize ProceduralMaterial::GetProceduralMemoryWorkBudget() const +{ + if (m_SubstanceData==NULL) + return ProceduralCacheSize_None; + return m_SubstanceData->memoryWorkBudget; +} + +void ProceduralMaterial::SetProceduralMemorySleepBudget(ProceduralCacheSize budget) +{ + if (m_SubstanceData!=NULL) + m_SubstanceData->memorySleepBudget = budget; +} + +ProceduralCacheSize ProceduralMaterial::GetProceduralMemorySleepBudget() const +{ + if (m_SubstanceData==NULL) + return ProceduralCacheSize_None; + return m_SubstanceData->memorySleepBudget; +} + +#if UNITY_EDITOR +// Strips substance data during serialization when building a player +struct TemporarilyStripSubstanceData +{ + ProceduralMaterial* material; + PPtr<SubstanceArchive> substancePackage; + SubstanceInputs inputs; + + TemporarilyStripSubstanceData (ProceduralMaterial& mat, bool isBuildingPlayer) + { + bool shouldDiscardSubstanceData; + shouldDiscardSubstanceData = !IsSubstanceSupportedOnPlatform(GetEditorUserBuildSettings().GetActiveBuildTarget()); + shouldDiscardSubstanceData |= mat.GetLoadingBehavior() == ProceduralLoadingBehavior_BakeAndDiscard; + + // Should we discard the substance data? + if (isBuildingPlayer && shouldDiscardSubstanceData) + { + material = &mat; + + // Clear m_SubstancePackage & m_Inputs and back it up so we can revert them after serialization + swap(substancePackage, mat.m_SubstancePackage); + swap(inputs, mat.m_Inputs); + } + else + { + material = NULL; + } + } + + ~TemporarilyStripSubstanceData () + { + if (material != NULL) + { + swap(material->m_Inputs, inputs); + swap(material->m_SubstancePackage, substancePackage); + } + } +}; +#endif + + + +template<class T> void ProceduralMaterial::Transfer( T& transfer ) +{ + Super::Transfer( transfer ); + + // Serialize maximum sizes + if (transfer.IsVersionSmallerOrEqual (2)) + { + int m_MaximumSize; + TRANSFER( m_MaximumSize ); + m_Width = m_MaximumSize; + m_Height = m_MaximumSize; + } + else + { + TRANSFER( m_Width ); + TRANSFER( m_Height ); + } + + TRANSFER( m_Textures ); + TRANSFER( m_Flags ); + + // Serialize load behavior + if (transfer.IsReading ()) + { + // Handle deprecated GenerateAtLoad flag, replaced by LoadingBehavior + m_LoadingBehavior = IsFlagEnabled(Flag_DeprecatedGenerateAtLoad)?ProceduralLoadingBehavior_Generate:ProceduralLoadingBehavior_None; + EnableFlag(Flag_DeprecatedGenerateAtLoad, false); + } + transfer.Transfer(reinterpret_cast<int&> (m_LoadingBehavior), "m_LoadingBehavior"); + + #if UNITY_EDITOR + // Strip unused data when building/collecting assets + TemporarilyStripSubstanceData stripData (*this, transfer.GetFlags () & kBuildPlayerOnlySerializeBuildProperties); + #endif + + TRANSFER( m_SubstancePackage ); + TRANSFER( m_Inputs ); + + TRANSFER( m_PrototypeName ); + if (m_PrototypeName=="") + { + m_PrototypeName = GetName(); + } + + TRANSFER( m_AnimationUpdateRate ); + + TRANSFER(m_Hash); +} + +bool ProceduralMaterial::IsProcessing() const +{ +#if ENABLE_SUBSTANCE + return GetSubstanceSystem().IsSubstanceProcessing(this); +#else + return false; +#endif +} + +void ProceduralMaterial::SetProceduralProcessorUsage(ProceduralProcessorUsage processorUsage) +{ +#if ENABLE_SUBSTANCE + GetSubstanceSystem().SetProcessorUsage(processorUsage); +#endif +} + +ProceduralProcessorUsage ProceduralMaterial::GetProceduralProcessorUsage() +{ +#if ENABLE_SUBSTANCE + return GetSubstanceSystem().GetProcessorUsage(); +#else + return ProceduralProcessorUsage_Unsupported; +#endif +} + +void ProceduralMaterial::StopProcessing() +{ +#if ENABLE_SUBSTANCE + GetSubstanceSystem().ClearProcessingQueue(); +#endif +} + +#if UNITY_EDITOR + +void ProceduralMaterial::InvalidateIfCachedOrInvalidTextures() +{ + // Check if some textures are cached + bool cachedOrInvalid=false; + for (PingedTextures::iterator i=m_PingedTextures.begin();i!=m_PingedTextures.end();++i) + { + ProceduralTexture* texture = *i; + if (texture!=NULL + && (texture->IsFlagEnabled(ProceduralTexture::Flag_Cached) + || !texture->IsValid())) + { + cachedOrInvalid = true; + break; + } + } + + if (cachedOrInvalid) + { + // Check if an input has been modified + bool modified = false; + for (SubstanceInputs::iterator i=m_Inputs.begin();i != m_Inputs.end();++i) + { + SubstanceInput& input = *i; + if (input.IsFlagEnabled(SubstanceInput::Flag_Modified)) + { + modified = true; + break; + } + } + // Force rebuild since no input is modified + if (!modified) + { + for (SubstanceInputs::iterator i=m_Inputs.begin();i != m_Inputs.end();++i) + { + SubstanceInput& input = *i; + input.EnableFlag(SubstanceInput::Flag_Awake); + } + } + } +} + +bool IsSubstanceSupportedOnPlatform(BuildTargetPlatform platform) +{ +return (platform == kBuildWebPlayerLZMA + || platform == kBuildWebPlayerLZMAStreamed + || platform == kBuildStandaloneOSXIntel + || platform == kBuildStandaloneOSXIntel64 + || platform == kBuildStandaloneOSXUniversal + || platform == kBuildStandaloneWinPlayer + || platform == kBuildStandaloneWin64Player + || platform == kBuildStandaloneLinux + || platform == kBuildStandaloneLinux64 + || platform == kBuildStandaloneLinuxUniversal + || platform == kBuild_Android + || platform == kBuild_iPhone + || platform == kBuildNaCl + ); +} +#endif + +bool IsSubstanceSupported() +{ +#if UNITY_EDITOR + BuildTargetPlatform platform = GetEditorUserBuildSettings().GetActiveBuildTarget(); + return IsSubstanceSupportedOnPlatform(platform); +#endif + +#if ENABLE_SUBSTANCE + return true; +#else + return false; +#endif +} + +TextureFormat GetSubstanceTextureFormat(SubstanceOutputFormat outputFormat, bool requireCompressed) +{ +#if ENABLE_SUBSTANCE +#if UNITY_EDITOR + BuildTargetPlatform platform = GetEditorUserBuildSettings().GetActiveBuildTarget(); + if (!requireCompressed || IsSubstanceSupportedOnPlatform(platform)) +#endif + { + TextureFormat format(kTexFormatRGBA32); + + if (outputFormat==Substance_OFormat_Compressed) + { +#if UNITY_IPHONE + format = kTexFormatPVRTC_RGBA4; +#elif UNITY_ANDROID + if (gGraphicsCaps.supportsTextureFormat[kTexFormatDXT5]) + { + format = kTexFormatDXT5; + } + else if (gGraphicsCaps.supportsTextureFormat[kTexFormatPVRTC_RGBA4]) + { + format = kTexFormatPVRTC_RGBA4; + } + else + { + // Lowest common denominator = ETC + // But this will cancel the alpha, need to think of something else for non-DXT non-PVR platforms + // format = kTexFormatETC_RGB4; + } +#else + format = kTexFormatDXT5; +#endif + } + + return format; + } +#endif + + return kTexFormatRGBA32; +} + +SubstanceEngineIDEnum GetSubstanceEngineID() +{ +#if defined(__ppc__) + return Substance_EngineID_xenos; +#endif + return Substance_EngineID_sse2; +} |