Initial commit

Code/Sandbox/Editor/Serialization/VariableIArchive.cpp

@@ -0,0 +1,284 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+// Original file Copyright Crytek GMBH or its affiliates, used under license.
+
+#include "EditorDefs.h"
+
+#include "VariableIArchive.h"
+
+// Editor
+#include "Serialization/Decorators/Resources.h"
+#include "Serialization/Decorators/Range.h"
+
+
+using Serialization::CVariableIArchive;
+
+namespace VarUtil
+{
+    _smart_ptr< IVariable > FindChildVariable(const _smart_ptr< IVariable >& pParent, const int childIndexOverride, const char* const name)
+    {
+        if (0 <= childIndexOverride)
+        {
+            return pParent->GetVariable(childIndexOverride);
+        }
+        else
+        {
+            const bool shouldSearchRecursively = false;
+            return pParent->FindVariable(name, shouldSearchRecursively);
+        }
+    }
+
+
+    template< typename T, typename TOut >
+    bool ReadChildVariableAs(const _smart_ptr< IVariable >& pParent, const int childIndexOverride, const char* const name, TOut& valueOut)
+    {
+        _smart_ptr< IVariable > pVariable = FindChildVariable(pParent, childIndexOverride, name);
+        if (pVariable)
+        {
+            T tmp;
+            pVariable->Get(tmp);
+            valueOut = static_cast< TOut >(tmp);
+            return true;
+        }
+        return false;
+    }
+
+
+    template< typename T >
+    bool ReadChildVariable(const _smart_ptr< IVariable >& pParent, const int childIndexOverride, const char* const name, T& valueOut)
+    {
+        return ReadChildVariableAs< T >(pParent, childIndexOverride, name, valueOut);
+    }
+}
+
+
+
+CVariableIArchive::CVariableIArchive(const _smart_ptr< IVariable >& pVariable)
+    : IArchive(IArchive::INPUT | IArchive::EDIT | IArchive::NO_EMPTY_NAMES)
+    , m_pVariable(pVariable)
+    , m_childIndexOverride(-1)
+{
+    CRY_ASSERT(m_pVariable);
+
+    m_structHandlers[ TypeID::get < Serialization::IResourceSelector > ().name() ] = &CVariableIArchive::SerializeResourceSelector;
+    m_structHandlers[ TypeID::get < Serialization::RangeDecorator < float >> ().name() ] = &CVariableIArchive::SerializeRangeFloat;
+    m_structHandlers[ TypeID::get < Serialization::RangeDecorator < int >> ().name() ] = &CVariableIArchive::SerializeRangeInt;
+    m_structHandlers[ TypeID::get < Serialization::RangeDecorator < unsigned int >> ().name() ] = &CVariableIArchive::SerializeRangeUInt;
+    m_structHandlers[ TypeID::get < StringListStaticValue > ().name() ] = &CVariableIArchive::SerializeStringListStaticValue;
+}
+
+
+CVariableIArchive::~CVariableIArchive()
+{
+}
+
+
+bool CVariableIArchive::operator()(bool& value, const char* name, [[maybe_unused]] const char* label)
+{
+    return VarUtil::ReadChildVariableAs< bool >(m_pVariable, m_childIndexOverride, name, value);
+}
+
+
+bool CVariableIArchive::operator()(Serialization::IString& value, const char* name, [[maybe_unused]] const char* label)
+{
+    QString stringValue;
+    const bool readSuccess = VarUtil::ReadChildVariableAs< QString >(m_pVariable, m_childIndexOverride, name, stringValue);
+    if (readSuccess)
+    {
+        value.set(stringValue.toUtf8().data());
+        return true;
+    }
+    return false;
+}
+
+
+bool CVariableIArchive::operator()([[maybe_unused]] Serialization::IWString& value, [[maybe_unused]] const char* name, [[maybe_unused]] const char* label)
+{
+    CryFatalError("CVariableIArchive::operator() with IWString is not implemented");
+    return false;
+}
+
+
+bool CVariableIArchive::operator()(float& value, const char* name, [[maybe_unused]] const char* label)
+{
+    return VarUtil::ReadChildVariableAs< float >(m_pVariable, m_childIndexOverride, name, value);
+}
+
+
+bool CVariableIArchive::operator()(double& value, const char* name, [[maybe_unused]] const char* label)
+{
+    return VarUtil::ReadChildVariableAs< float >(m_pVariable, m_childIndexOverride, name, value);
+}
+
+
+bool CVariableIArchive::operator()(int16& value, const char* name, [[maybe_unused]] const char* label)
+{
+    return VarUtil::ReadChildVariableAs< int >(m_pVariable, m_childIndexOverride, name, value);
+}
+
+
+bool CVariableIArchive::operator()(uint16& value, const char* name, [[maybe_unused]] const char* label)
+{
+    return VarUtil::ReadChildVariableAs< int >(m_pVariable, m_childIndexOverride, name, value);
+}
+
+
+bool CVariableIArchive::operator()(int32& value, const char* name, [[maybe_unused]] const char* label)
+{
+    return VarUtil::ReadChildVariableAs< int >(m_pVariable, m_childIndexOverride, name, value);
+}
+
+
+bool CVariableIArchive::operator()(uint32& value, const char* name, [[maybe_unused]] const char* label)
+{
+    return VarUtil::ReadChildVariableAs< int >(m_pVariable, m_childIndexOverride, name, value);
+}
+
+
+bool CVariableIArchive::operator()(int64& value, const char* name, [[maybe_unused]] const char* label)
+{
+    return VarUtil::ReadChildVariableAs< int >(m_pVariable, m_childIndexOverride, name, value);
+}
+
+
+bool CVariableIArchive::operator()(uint64& value, const char* name, [[maybe_unused]] const char* label)
+{
+    return VarUtil::ReadChildVariableAs< int >(m_pVariable, m_childIndexOverride, name, value);
+}
+
+
+bool CVariableIArchive::operator()(int8& value, const char* name, [[maybe_unused]] const char* label)
+{
+    return VarUtil::ReadChildVariableAs< int >(m_pVariable, m_childIndexOverride, name, value);
+}
+
+
+bool CVariableIArchive::operator()(uint8& value, const char* name, [[maybe_unused]] const char* label)
+{
+    return VarUtil::ReadChildVariableAs< int >(m_pVariable, m_childIndexOverride, name, value);
+}
+
+
+bool CVariableIArchive::operator()(char& value, const char* name, [[maybe_unused]] const char* label)
+{
+    return VarUtil::ReadChildVariableAs< int >(m_pVariable, m_childIndexOverride, name, value);
+}
+
+
+bool CVariableIArchive::operator()(const Serialization::SStruct& ser, const char* name, const char* label)
+{
+    const char* const typeName = ser.type().name();
+    HandlersMap::const_iterator it = m_structHandlers.find(typeName);
+    const bool handlerFound = (it != m_structHandlers.end());
+    if (handlerFound)
+    {
+        StructHandlerFunctionPtr pHandler = it->second;
+        return (this->*pHandler)(ser, name, label);
+    }
+
+    return SerializeStruct(ser, name, label);
+}
+
+
+bool CVariableIArchive::operator()(Serialization::IContainer& ser, const char* name, [[maybe_unused]] const char* label)
+{
+    _smart_ptr< IVariable > pChild = VarUtil::FindChildVariable(m_pVariable, m_childIndexOverride, name);
+    if (pChild)
+    {
+        const int elementCount = pChild->GetNumVariables();
+        ser.resize(elementCount);
+
+        if (0 < elementCount)
+        {
+            CVariableIArchive childArchive(pChild);
+            childArchive.SetFilter(GetFilter());
+            childArchive.SetInnerContext(GetInnerContext());
+
+            for (int i = 0; i < elementCount; ++i)
+            {
+                childArchive.m_childIndexOverride = i;
+
+                ser(childArchive, "", "");
+                ser.next();
+            }
+        }
+        return true;
+    }
+    return false;
+}
+
+
+bool CVariableIArchive::SerializeStruct(const Serialization::SStruct& ser, const char* name, [[maybe_unused]] const char* label)
+{
+    _smart_ptr< IVariable > pChild = VarUtil::FindChildVariable(m_pVariable, m_childIndexOverride, name);
+    if (pChild)
+    {
+        CVariableIArchive childArchive(pChild);
+        childArchive.SetFilter(GetFilter());
+        childArchive.SetInnerContext(GetInnerContext());
+
+        ser(childArchive);
+        return true;
+    }
+    return false;
+}
+
+bool CVariableIArchive::SerializeResourceSelector(const Serialization::SStruct& ser, const char* name, [[maybe_unused]] const char* label)
+{
+    Serialization::IResourceSelector* pSelector = reinterpret_cast< Serialization::IResourceSelector* >(ser.pointer());
+
+    QString stringValue;
+    const bool readSuccess = VarUtil::ReadChildVariableAs< QString >(m_pVariable, m_childIndexOverride, name, stringValue);
+    if (readSuccess)
+    {
+        pSelector->SetValue(stringValue.toUtf8().data());
+        return true;
+    }
+    return false;
+}
+
+
+bool CVariableIArchive::SerializeStringListStaticValue(const Serialization::SStruct& ser, const char* name, [[maybe_unused]] const char* label)
+{
+    StringListStaticValue* const pStringListStaticValue = reinterpret_cast< StringListStaticValue* >(ser.pointer());
+    const StringListStatic& stringListStatic = pStringListStaticValue->stringList();
+
+    _smart_ptr< IVariable > pChild = VarUtil::FindChildVariable(m_pVariable, m_childIndexOverride, name);
+    if (pChild)
+    {
+        int index = -1;
+        pChild->Get(index);
+        *pStringListStaticValue = index;
+        return true;
+    }
+    return false;
+}
+
+
+bool CVariableIArchive::SerializeRangeFloat(const Serialization::SStruct& ser, const char* name, [[maybe_unused]] const char* label)
+{
+    const Serialization::RangeDecorator< float >* const pRange = reinterpret_cast< Serialization::RangeDecorator< float >* >(ser.pointer());
+    return VarUtil::ReadChildVariableAs< float >(m_pVariable, m_childIndexOverride, name, *pRange->value);
+}
+
+
+bool CVariableIArchive::SerializeRangeInt(const Serialization::SStruct& ser, const char* name, [[maybe_unused]] const char* label)
+{
+    const Serialization::RangeDecorator< int >* const pRange = reinterpret_cast< Serialization::RangeDecorator< int >* >(ser.pointer());
+    return VarUtil::ReadChildVariableAs< int >(m_pVariable, m_childIndexOverride, name, *pRange->value);
+}
+
+bool CVariableIArchive::SerializeRangeUInt(const Serialization::SStruct& ser, const char* name, [[maybe_unused]] const char* label)
+{
+    const Serialization::RangeDecorator< unsigned int >* const pRange = reinterpret_cast< Serialization::RangeDecorator< unsigned int >* >(ser.pointer());
+    return VarUtil::ReadChildVariableAs< int >(m_pVariable, m_childIndexOverride, name, *pRange->value);
+}

Code/Sandbox/Editor/Serialization/VariableIArchive.h

@@ -0,0 +1,71 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+// Original file Copyright Crytek GMBH or its affiliates, used under license.
+
+#pragma once
+
+#include "Util/Variable.h"
+#include "Serialization.h"
+
+namespace Serialization
+{
+    class CVariableIArchive
+        : public IArchive
+    {
+    public:
+        CVariableIArchive(const _smart_ptr< IVariable >& pVariable);
+        virtual ~CVariableIArchive();
+
+        // IArchive
+        virtual bool operator()(bool& value, const char* name = "", const char* label = 0) override;
+        virtual bool operator()(IString& value, const char* name = "", const char* label = 0) override;
+        virtual bool operator()(IWString& value, const char* name = "", const char* label = 0) override;
+        virtual bool operator()(float& value, const char* name = "", const char* label = 0) override;
+        virtual bool operator()(double& value, const char* name = "", const char* label = 0) override;
+        virtual bool operator()(int16& value, const char* name = "", const char* label = 0) override;
+        virtual bool operator()(uint16& value, const char* name = "", const char* label = 0) override;
+        virtual bool operator()(int32& value, const char* name = "", const char* label = 0) override;
+        virtual bool operator()(uint32& value, const char* name = "", const char* label = 0) override;
+        virtual bool operator()(int64& value, const char* name = "", const char* label = 0) override;
+        virtual bool operator()(uint64& value, const char* name = "", const char* label = 0) override;
+
+        virtual bool operator()(int8& value, const char* name = "", const char* label = 0) override;
+        virtual bool operator()(uint8& value, const char* name = "", const char* label = 0) override;
+        virtual bool operator()(char& value, const char* name = "", const char* label = 0);
+
+        virtual bool operator()(const SStruct& ser, const char* name = "", const char* label = 0) override;
+        virtual bool operator()(IContainer& ser, const char* name = "", const char* label = 0) override;
+        //virtual bool operator()( IPointer& ptr, const char* name = "", const char* label = 0 ) override;
+        // ~IArchive
+
+        using IArchive::operator();
+
+    private:
+        bool SerializeResourceSelector(const SStruct& ser, const char* name, const char* label);
+
+        bool SerializeStruct(const SStruct& ser, const char* name, const char* label);
+
+        bool SerializeStringListStaticValue(const SStruct& ser, const char* name, const char* label);
+
+        bool SerializeRangeFloat(const SStruct& ser, const char* name, const char* label);
+        bool SerializeRangeInt(const SStruct& ser, const char* name, const char* label);
+        bool SerializeRangeUInt(const SStruct& ser, const char* name, const char* label);
+
+    private:
+        _smart_ptr< IVariable > m_pVariable;
+        int m_childIndexOverride;
+
+        typedef bool ( CVariableIArchive::* StructHandlerFunctionPtr )(const SStruct&, const char*, const char*);
+        typedef std::map< string, StructHandlerFunctionPtr > HandlersMap;
+        HandlersMap m_structHandlers; // TODO: have only one of these.
+    };
+}

Code/Sandbox/Editor/Serialization/VariableOArchive.cpp

@@ -0,0 +1,416 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+// Original file Copyright Crytek GMBH or its affiliates, used under license.
+
+#include "EditorDefs.h"
+
+#include "VariableOArchive.h"
+
+// Editor
+#include "Serialization/Decorators/Resources.h"
+#include "Serialization/Decorators/Range.h"
+
+
+using Serialization::CVariableOArchive;
+
+namespace VarUtil
+{
+    template< typename T >
+    _smart_ptr< IVariable > AddChildVariable(const _smart_ptr< IVariable >& pVariableArray, const T& value, const char* const name, const char* label)
+    {
+        CRY_ASSERT(pVariableArray);
+
+        _smart_ptr< IVariable > pVariable = new CVariable< T >();
+        pVariable->SetName(name);
+        pVariable->SetHumanName(label);
+        pVariable->Set(value);
+
+        pVariableArray->AddVariable(pVariable);
+
+        return pVariable;
+    }
+
+    template< typename TMin, typename TMax >
+    void SetLimits(const _smart_ptr< IVariable >& pVariable, const TMin minValue, const TMax maxValue)
+    {
+        pVariable->SetLimits(static_cast< float >(minValue), static_cast< float >(maxValue));
+    }
+}
+
+CVariableOArchive::CVariableOArchive()
+    : IArchive(IArchive::OUTPUT | IArchive::EDIT | IArchive::NO_EMPTY_NAMES)
+    , m_pVariable(new CVariableArray())
+{
+    m_resourceHandlers[ "Animation" ] = &CVariableOArchive::SerializeAnimationName;
+    m_resourceHandlers[ "Sound" ] = &CVariableOArchive::SerializeSoundName;
+    m_resourceHandlers[ "Model" ] = &CVariableOArchive::SerializeObjectFilename;
+
+    m_structHandlers[ TypeID::get < Serialization::IResourceSelector > ().name() ] = &CVariableOArchive::SerializeIResourceSelector;
+    m_structHandlers[ TypeID::get < Serialization::RangeDecorator < float >> ().name() ] = &CVariableOArchive::SerializeRangeFloat;
+    m_structHandlers[ TypeID::get < Serialization::RangeDecorator < int >> ().name() ] = &CVariableOArchive::SerializeRangeInt;
+    m_structHandlers[ TypeID::get < Serialization::RangeDecorator < unsigned int >> ().name() ] = &CVariableOArchive::SerializeRangeUInt;
+    m_structHandlers[ TypeID::get < StringListStaticValue > ().name() ] = &CVariableOArchive::SerializeStringListStaticValue;
+}
+
+
+CVariableOArchive::~CVariableOArchive()
+{
+}
+
+
+_smart_ptr< IVariable > CVariableOArchive::GetIVariable() const
+{
+    return m_pVariable;
+}
+
+
+CVarBlockPtr CVariableOArchive::GetVarBlock() const
+{
+    CVarBlockPtr pVarBlock = new CVarBlock();
+    pVarBlock->AddVariable(m_pVariable);
+    return pVarBlock;
+}
+
+
+bool CVariableOArchive::operator()(bool& value, const char* name, const char* label)
+{
+    VarUtil::AddChildVariable< bool >(m_pVariable, value, name, label);
+    return true;
+}
+
+
+bool CVariableOArchive::operator()(Serialization::IString& value, const char* name, const char* label)
+{
+    const QString valueString = value.get();
+    VarUtil::AddChildVariable< QString >(m_pVariable, valueString, name, label);
+    return true;
+}
+
+
+bool CVariableOArchive::operator()([[maybe_unused]] Serialization::IWString& value, [[maybe_unused]] const char* name, [[maybe_unused]] const char* label)
+{
+    CryFatalError("CVarBlockOArchive::operator() with IWString is not implemented");
+    return false;
+}
+
+
+bool CVariableOArchive::operator()(float& value, const char* name, const char* label)
+{
+    VarUtil::AddChildVariable< float >(m_pVariable, value, name, label);
+    return true;
+}
+
+
+bool CVariableOArchive::operator()(double& value, const char* name, const char* label)
+{
+    VarUtil::AddChildVariable< float >(m_pVariable, value, name, label);
+    return true;
+}
+
+
+bool CVariableOArchive::operator()(int16& value, const char* name, const char* label)
+{
+    _smart_ptr< IVariable > pVariable = VarUtil::AddChildVariable< int >(m_pVariable, value, name, label);
+    VarUtil::SetLimits(pVariable, SHRT_MIN, SHRT_MAX);
+    return true;
+}
+
+
+bool CVariableOArchive::operator()(uint16& value, const char* name, const char* label)
+{
+    _smart_ptr< IVariable > pVariable = VarUtil::AddChildVariable< int >(m_pVariable, value, name, label);
+    VarUtil::SetLimits(pVariable, 0, USHRT_MAX);
+    return true;
+}
+
+
+bool CVariableOArchive::operator()(int32& value, const char* name, const char* label)
+{
+    _smart_ptr< IVariable > pVariable = VarUtil::AddChildVariable< int >(m_pVariable, value, name, label);
+    VarUtil::SetLimits(pVariable, INT_MIN, INT_MAX);
+    return true;
+}
+
+
+bool CVariableOArchive::operator()(uint32& value, const char* name, const char* label)
+{
+    _smart_ptr< IVariable > pVariable = VarUtil::AddChildVariable< int >(m_pVariable, value, name, label);
+    VarUtil::SetLimits(pVariable, 0, INT_MAX);
+    return true;
+}
+
+
+bool CVariableOArchive::operator()(int64& value, const char* name, const char* label)
+{
+    _smart_ptr< IVariable > pVariable = VarUtil::AddChildVariable< int >(m_pVariable, value, name, label);
+    VarUtil::SetLimits(pVariable, INT_MIN, INT_MAX);
+    return true;
+}
+
+
+bool CVariableOArchive::operator()(uint64& value, const char* name, const char* label)
+{
+    _smart_ptr< IVariable > pVariable = VarUtil::AddChildVariable< int >(m_pVariable, value, name, label);
+    VarUtil::SetLimits(pVariable, 0, INT_MAX);
+    return true;
+}
+
+
+bool CVariableOArchive::operator()(int8& value, const char* name, const char* label)
+{
+    _smart_ptr< IVariable > pVariable = VarUtil::AddChildVariable< int >(m_pVariable, value, name, label);
+    VarUtil::SetLimits(pVariable, SCHAR_MIN, SCHAR_MAX);
+    return true;
+}
+
+
+bool CVariableOArchive::operator()(uint8& value, const char* name, const char* label)
+{
+    _smart_ptr< IVariable > pVariable = VarUtil::AddChildVariable< int >(m_pVariable, value, name, label);
+    VarUtil::SetLimits(pVariable, 0, UCHAR_MAX);
+    return true;
+}
+
+
+bool CVariableOArchive::operator()(char& value, const char* name, const char* label)
+{
+    _smart_ptr< IVariable > pVariable = VarUtil::AddChildVariable< int >(m_pVariable, value, name, label);
+    VarUtil::SetLimits(pVariable, CHAR_MIN, CHAR_MAX);
+    return true;
+}
+
+
+bool CVariableOArchive::operator()(const Serialization::SStruct& ser, const char* name, const char* label)
+{
+    const char* const typeName = ser.type().name();
+    HandlersMap::const_iterator it = m_structHandlers.find(typeName);
+    const bool handlerFound = (it != m_structHandlers.end());
+    if (handlerFound)
+    {
+        StructHandlerFunctionPtr pHandler = it->second;
+        return (this->*pHandler)(ser, name, label);
+    }
+
+    return SerializeStruct(ser, name, label);
+}
+
+static const char* gVec4Names[] = { "X", "Y", "Z", "W" };
+static const char* gEmptyNames[] = { "" };
+
+bool CVariableOArchive::operator()(Serialization::IContainer& ser, const char* name, const char* label)
+{
+    CVariableOArchive childArchive;
+    childArchive.SetFilter(GetFilter());
+    childArchive.SetInnerContext(GetInnerContext());
+
+    _smart_ptr< IVariable > pChildVariable = childArchive.GetIVariable();
+    pChildVariable->SetName(name);
+    pChildVariable->SetHumanName(label);
+
+    m_pVariable->AddVariable(pChildVariable);
+
+    const size_t containerSize = ser.size();
+
+    const char** nameArray = gEmptyNames;
+    size_t nameArraySize = 1;
+    if (containerSize >= 2 && containerSize <= 4)
+    {
+        nameArray = gVec4Names;
+        nameArraySize = containerSize;
+    }
+
+    size_t index = 0;
+    if (0 < containerSize)
+    {
+        do
+        {
+            ser(childArchive, nameArray[index % nameArraySize], nameArray[index % nameArraySize]);
+            ++index;
+        } while (ser.next());
+    }
+
+    return true;
+}
+
+
+bool CVariableOArchive::SerializeStruct(const Serialization::SStruct& ser, const char* name, const char* label)
+{
+    CVariableOArchive childArchive;
+    childArchive.SetFilter(GetFilter());
+    childArchive.SetInnerContext(GetInnerContext());
+
+    _smart_ptr< IVariable > pChildVariable = childArchive.GetIVariable();
+    pChildVariable->SetName(name);
+    pChildVariable->SetHumanName(label);
+
+    m_pVariable->AddVariable(pChildVariable);
+
+    const bool serializeSuccess = ser(childArchive);
+
+    return serializeSuccess;
+}
+
+
+bool CVariableOArchive::SerializeAnimationName(const Serialization::IResourceSelector* pSelector, const char* name, const char* label)
+{
+    const QString valueString = pSelector->GetValue();
+    _smart_ptr< IVariable > pVariable = VarUtil::AddChildVariable< QString >(m_pVariable, valueString, name, label);
+    pVariable->SetDataType(IVariable::DT_ANIMATION);
+
+    return true;
+}
+
+
+bool CVariableOArchive::SerializeSoundName(const Serialization::IResourceSelector* pSelector, const char* name, const char* label)
+{
+    const QString valueString = pSelector->GetValue();
+    _smart_ptr< IVariable > pVariable = VarUtil::AddChildVariable< QString >(m_pVariable, valueString, name, label);
+    pVariable->SetDataType(IVariable::DT_AUDIO_TRIGGER);
+
+    return true;
+}
+
+void CVariableOArchive::CreateChildEnumVariable(const QStringList& enumValues, const QString& value, const char* name, const char* label)
+{
+    if (enumValues.empty())
+    {
+        VarUtil::AddChildVariable< QString >(m_pVariable, value, name, label);
+    }
+    else
+    {
+        _smart_ptr< CVariableEnum< QString > > pVariable = new CVariableEnum< QString >();
+        pVariable->SetName(name);
+        pVariable->SetHumanName(label);
+
+        pVariable->AddEnumItem("", "");
+
+        const size_t enumValuesCount = enumValues.size();
+        for (size_t i = 0; i < enumValuesCount; ++i)
+        {
+            pVariable->AddEnumItem(enumValues[ i ], enumValues[ i ]);
+        }
+
+        pVariable->Set(value);
+
+        m_pVariable->AddVariable(pVariable);
+    }
+}
+
+bool CVariableOArchive::SerializeObjectFilename(const Serialization::IResourceSelector* pSelector, const char* name, const char* label)
+{
+    const QString valueString = pSelector->GetValue();
+    _smart_ptr< IVariable > pVariable = VarUtil::AddChildVariable< QString >(m_pVariable, valueString, name, label);
+    pVariable->SetDataType(IVariable::DT_OBJECT);
+
+    return true;
+}
+
+
+bool CVariableOArchive::SerializeStringListStaticValue(const Serialization::SStruct& ser, const char* name, const char* label)
+{
+    const StringListStaticValue* const pStringListStaticValue = reinterpret_cast< StringListStaticValue* >(ser.pointer());
+    const StringListStatic& stringListStatic = pStringListStaticValue->stringList();
+    const int index = pStringListStaticValue->index();
+
+    _smart_ptr< CVariableEnum< int > > pVariable = new CVariableEnum< int >();
+    pVariable->SetName(name);
+    pVariable->SetHumanName(label);
+
+    const size_t stringListStaticSize = stringListStatic.size();
+    for (size_t i = 0; i < stringListStaticSize; ++i)
+    {
+        pVariable->AddEnumItem(stringListStatic[ i ], static_cast< int >(i));
+    }
+
+    if (0 <= index)
+    {
+        CRY_ASSERT(index < stringListStaticSize);
+        pVariable->Set(static_cast< int >(index));
+    }
+
+    m_pVariable->AddVariable(pVariable);
+
+    return true;
+}
+
+bool CVariableOArchive::SerializeIResourceSelector(const Serialization::SStruct& ser, const char* name, const char* label)
+{
+    const Serialization::IResourceSelector* pSelector = reinterpret_cast< Serialization::IResourceSelector* >(ser.pointer());
+
+    ResourceHandlersMap::iterator it = m_resourceHandlers.find(pSelector->resourceType);
+    if (it != m_resourceHandlers.end())
+    {
+        return (this->*(it->second))(pSelector, name, label);
+    }
+    return false;
+}
+
+template<class T>
+static void SetLimits(IVariable* pVariable, const Serialization::RangeDecorator<T>* pRange, float stepValue)
+{
+    if (pRange->softMin != std::numeric_limits<T>::lowest() || pRange->softMax != std::numeric_limits<T>::max())
+    {
+        float minimal = (float)pRange->softMin;
+        float maximal = (float)pRange->softMax;
+        bool hardMin = false;
+        bool hardMax = false;
+        if (pRange->hardMin != std::numeric_limits<T>::lowest())
+        {
+            minimal = pRange->hardMin;
+            hardMin = true;
+        }
+        if (pRange->hardMax != std::numeric_limits<T>::max())
+        {
+            maximal = pRange->hardMax;
+            hardMax = true;
+        }
+        pVariable->SetLimits(minimal, maximal, stepValue, hardMin, hardMax);
+    }
+    else
+    {
+        float minimal = 0.0f;
+        float maximal = 0.0f;
+        float oldStep = 0.0f;
+        bool hardMin = false;
+        bool hardMax = false;
+        pVariable->GetLimits(minimal, maximal, oldStep, hardMin, hardMax);
+        pVariable->SetLimits(minimal, maximal, stepValue, hardMin, hardMax);
+    }
+}
+
+bool CVariableOArchive::SerializeRangeFloat(const Serialization::SStruct& ser, const char* name, const char* label)
+{
+    const Serialization::RangeDecorator< float >* const pRange = reinterpret_cast< Serialization::RangeDecorator< float >* >(ser.pointer());
+
+    _smart_ptr< IVariable > pVariable = VarUtil::AddChildVariable< float >(m_pVariable, *pRange->value, name, label);
+
+    SetLimits(pVariable.get(), pRange, 0.01f);
+    return true;
+}
+
+bool CVariableOArchive::SerializeRangeInt(const Serialization::SStruct& ser, const char* name, const char* label)
+{
+    const Serialization::RangeDecorator< int >* const pRange = reinterpret_cast< Serialization::RangeDecorator< int >* >(ser.pointer());
+
+    _smart_ptr< IVariable > pVariable = VarUtil::AddChildVariable< int >(m_pVariable, *pRange->value, name, label);
+    SetLimits(pVariable.get(), pRange, 1.0f);
+    return true;
+}
+
+bool CVariableOArchive::SerializeRangeUInt(const Serialization::SStruct& ser, const char* name, const char* label)
+{
+    const Serialization::RangeDecorator< unsigned int >* const pRange = reinterpret_cast< Serialization::RangeDecorator< unsigned int >* >(ser.pointer());
+
+    _smart_ptr< IVariable > pVariable = VarUtil::AddChildVariable< int >(m_pVariable, *pRange->value, name, label);
+    SetLimits(pVariable, pRange, 1.0f);
+    return true;
+}

Code/Sandbox/Editor/Serialization/VariableOArchive.h

@@ -0,0 +1,83 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+// Original file Copyright Crytek GMBH or its affiliates, used under license.
+
+#pragma once
+
+#include "Util/Variable.h"
+#include "Serialization.h"
+
+
+namespace Serialization
+{
+    struct IResourceSelector;
+
+    class CVariableOArchive
+        : public IArchive
+    {
+    public:
+        CVariableOArchive();
+        virtual ~CVariableOArchive();
+
+        _smart_ptr< IVariable > GetIVariable() const;
+        CVarBlockPtr GetVarBlock() const;
+
+        // IArchive
+        virtual bool operator()(bool& value, const char* name = "", const char* label = 0) override;
+        virtual bool operator()(IString& value, const char* name = "", const char* label = 0) override;
+        virtual bool operator()(IWString& value, const char* name = "", const char* label = 0) override;
+        virtual bool operator()(float& value, const char* name = "", const char* label = 0) override;
+        virtual bool operator()(double& value, const char* name = "", const char* label = 0) override;
+        virtual bool operator()(int16& value, const char* name = "", const char* label = 0) override;
+        virtual bool operator()(uint16& value, const char* name = "", const char* label = 0) override;
+        virtual bool operator()(int32& value, const char* name = "", const char* label = 0) override;
+        virtual bool operator()(uint32& value, const char* name = "", const char* label = 0) override;
+        virtual bool operator()(int64& value, const char* name = "", const char* label = 0) override;
+        virtual bool operator()(uint64& value, const char* name = "", const char* label = 0) override;
+
+        virtual bool operator()(int8& value, const char* name = "", const char* label = 0) override;
+        virtual bool operator()(uint8& value, const char* name = "", const char* label = 0) override;
+        virtual bool operator()(char& value, const char* name = "", const char* label = 0);
+
+        virtual bool operator()(const SStruct& ser, const char* name = "", const char* label = 0) override;
+        virtual bool operator()(IContainer& ser, const char* name = "", const char* label = 0) override;
+        //virtual bool operator()( IPointer& ptr, const char* name = "", const char* label = 0 ) override;
+        // ~IArchive
+
+        using IArchive::operator();
+
+    private:
+        bool SerializeStruct(const SStruct& ser, const char* name, const char* label);
+        bool SerializeStringListStaticValue(const SStruct& ser, const char* name, const char* label);
+        bool SerializeRangeFloat(const SStruct& ser, const char* name, const char* label);
+        bool SerializeRangeInt(const SStruct& ser, const char* name, const char* label);
+        bool SerializeRangeUInt(const SStruct& ser, const char* name, const char* label);
+        bool SerializeIResourceSelector(const SStruct& ser, const char* name, const char* label);
+
+        bool SerializeAnimationName(const IResourceSelector* pSelector, const char* name, const char* label);
+        bool SerializeSoundName(const IResourceSelector* pSelector, const char* name, const char* label);
+        bool SerializeObjectFilename(const IResourceSelector* pSelector, const char* name, const char* label);
+
+        void CreateChildEnumVariable(const QStringList& enumValues, const QString& value, const char* name, const char* label);
+
+    private:
+        _smart_ptr< IVariable > m_pVariable;
+
+        typedef bool ( CVariableOArchive::* StructHandlerFunctionPtr )(const SStruct&, const char*, const char*);
+        typedef std::map< string, StructHandlerFunctionPtr > HandlersMap;
+        HandlersMap m_structHandlers; // TODO: have only one of these.
+
+        typedef bool ( CVariableOArchive::* ResourceHandlerFunctionPtr )(const IResourceSelector*, const char*, const char*);
+        typedef std::map< string, ResourceHandlerFunctionPtr > ResourceHandlersMap;
+        ResourceHandlersMap m_resourceHandlers;
+    };
+}