From f7d69eb21dc804ebd800bb7c29cd2b9218ed1ac2 Mon Sep 17 00:00:00 2001 From: Chewico Date: Fri, 23 May 2025 03:24:55 +0200 Subject: [PATCH] Impoving api for Environment... --- Deer/Include/Deer/Enviroment.h | 5 +- Deer/src/Deer/Core/Application.cpp | 9 - Deer/src/Deer/Scene/EnvironmentManager.cpp | 31 +- Deer/vendor/angelScript/Build.lua | 1 + .../angelScript/include/scriptdictionary.h | 240 +++ .../angelScript/src/scriptdictionary.cpp | 1299 +++++++++++++++++ DeerStudio/Build.lua | 3 +- DeerStudio/imgui.ini | 38 +- .../DeerStudio/EditorEngine/EditorEngine.cpp | 4 + .../MeshExplorer.as} | 0 roe/Editor/MeshExplorer/MeshPreviewRender.as | 14 + roe/Editor/as.predefined | 60 + roe/tmp/voxel_texture_atlas.png | Bin 123365 -> 121869 bytes 13 files changed, 1648 insertions(+), 56 deletions(-) create mode 100644 Deer/vendor/angelScript/include/scriptdictionary.h create mode 100644 Deer/vendor/angelScript/src/scriptdictionary.cpp rename roe/Editor/{mesh_explorer.as => MeshExplorer/MeshExplorer.as} (100%) create mode 100644 roe/Editor/MeshExplorer/MeshPreviewRender.as diff --git a/Deer/Include/Deer/Enviroment.h b/Deer/Include/Deer/Enviroment.h index b221bcf..e7fb3dc 100755 --- a/Deer/Include/Deer/Enviroment.h +++ b/Deer/Include/Deer/Enviroment.h @@ -165,11 +165,8 @@ namespace Deer { }; namespace EnvironmentManager { - uint16_t createEnvironment(const std::string& name); - uint16_t getEnvironmentId(const std::string& name); - + uint16_t createEnvironment(); Environment& getEnvironment(uint16_t); - const std::string& getEnvironmentName(uint16_t); void clearAllEnvironments(); } diff --git a/Deer/src/Deer/Core/Application.cpp b/Deer/src/Deer/Core/Application.cpp index 92325fd..1ac2ec5 100644 --- a/Deer/src/Deer/Core/Application.cpp +++ b/Deer/src/Deer/Core/Application.cpp @@ -2,15 +2,6 @@ #include #include -#ifdef DEER_RENDER -#include "DeerRender/Render/RenderCommand.h" -#include "DeerRender/Render/RenderUtils.h" -#include "DeerRender/Render/Render.h" - -#include "DeerRender/ImGui/ImGuiLayer.h" -#include "imgui.h" -#endif - namespace Deer { namespace Application { // Implemented in DeerRender/Application diff --git a/Deer/src/Deer/Scene/EnvironmentManager.cpp b/Deer/src/Deer/Scene/EnvironmentManager.cpp index 410b23c..d219386 100644 --- a/Deer/src/Deer/Scene/EnvironmentManager.cpp +++ b/Deer/src/Deer/Scene/EnvironmentManager.cpp @@ -6,45 +6,35 @@ namespace Deer { namespace EnvironmentManager { struct EnvironmentContainer { Environment* env_data = nullptr; - std::string env_name; }; - std::unordered_map environment_name_id; EnvironmentContainer environments[MAX_ENVIRONMENT_COUNT]{}; uint16_t maxEnvironmentId = 1; } - uint16_t EnvironmentManager::createEnvironment(const std::string& name) { + uint16_t EnvironmentManager::createEnvironment() { + if (maxEnvironmentId >= MAX_ENVIRONMENT_COUNT) { + DEER_CORE_ERROR("Max environment count"); + return 0; + } + uint16_t envId = maxEnvironmentId; maxEnvironmentId++; environments[envId].env_data = new Environment(); - environments[envId].env_name = name; - - environment_name_id[name] = envId; return envId; } - uint16_t EnvironmentManager::getEnvironmentId(const std::string& name) { - return environment_name_id[name]; - } - Environment& EnvironmentManager::getEnvironment(uint16_t id) { + DEER_CORE_ASSERT(id >= 0 && id < MAX_ENVIRONMENT_COUNT, "Invalid environment id {0}", id); + if (id == 0) return Scene::environment; return *environments[id].env_data; } - const std::string& EnvironmentManager::getEnvironmentName(uint16_t id) { - const static std::string main_env_name("Main Environment"); - if (id == 0) - return main_env_name; - - return environments[id].env_name; - } - void EnvironmentManager::clearAllEnvironments() { for (int i = 1; i < maxEnvironmentId; i++) { delete environments[i].env_data; @@ -52,11 +42,6 @@ namespace Deer { } environments[0].env_data = &Scene::environment; - environments[0].env_name = "Main Environment"; - - environment_name_id.clear(); - environment_name_id["Main Environment"] = 0; - maxEnvironmentId = 1; } } \ No newline at end of file diff --git a/Deer/vendor/angelScript/Build.lua b/Deer/vendor/angelScript/Build.lua index 635bbcb..155e4b6 100755 --- a/Deer/vendor/angelScript/Build.lua +++ b/Deer/vendor/angelScript/Build.lua @@ -21,6 +21,7 @@ project "angelScript" defines { "ANGELSCRIPT_EXPORT", + "AS_ENABLE_METADATA", "_LIB"} filter "system:linux" diff --git a/Deer/vendor/angelScript/include/scriptdictionary.h b/Deer/vendor/angelScript/include/scriptdictionary.h new file mode 100644 index 0000000..062bb15 --- /dev/null +++ b/Deer/vendor/angelScript/include/scriptdictionary.h @@ -0,0 +1,240 @@ +#ifndef SCRIPTDICTIONARY_H +#define SCRIPTDICTIONARY_H + +// The dictionary class relies on the script string object, thus the script +// string type must be registered with the engine before registering the +// dictionary type + +#ifndef ANGELSCRIPT_H +// Avoid having to inform include path if header is already include before +#include +#endif + +// By default the CScriptDictionary use the std::string for the keys. +// If the application uses a custom string type, then this typedef +// can be changed accordingly. +#include +typedef std::string dictKey_t; + +// Forward declare CScriptDictValue so we can typedef the internal map type +BEGIN_AS_NAMESPACE +class CScriptDictValue; +END_AS_NAMESPACE + +// C++11 introduced the std::unordered_map which is a hash map which is +// is generally more performatic for lookups than the std::map which is a +// binary tree. +// TODO: memory: The map allocator should use the asAllocMem and asFreeMem +#if AS_CAN_USE_CPP11 +#include +typedef std::unordered_map dictMap_t; +#else +#include +typedef std::map dictMap_t; +#endif + + +#ifdef _MSC_VER +// Turn off annoying warnings about truncated symbol names +#pragma warning (disable:4786) +#endif + + + + +// Sometimes it may be desired to use the same method names as used by C++ STL. +// This may for example reduce time when converting code from script to C++ or +// back. +// +// 0 = off +// 1 = on + +#ifndef AS_USE_STLNAMES +#define AS_USE_STLNAMES 0 +#endif + + +BEGIN_AS_NAMESPACE + +class CScriptArray; +class CScriptDictionary; + +class CScriptDictValue +{ +public: + // This class must not be declared as local variable in C++, because it needs + // to receive the script engine pointer in all operations. The engine pointer + // is not kept as member in order to keep the size down + CScriptDictValue(); + CScriptDictValue(asIScriptEngine *engine, void *value, int typeId); + + // Destructor must not be called without first calling FreeValue, otherwise a memory leak will occur + ~CScriptDictValue(); + + // Replace the stored value + void Set(asIScriptEngine *engine, void *value, int typeId); + void Set(asIScriptEngine *engine, const asINT64 &value); + void Set(asIScriptEngine *engine, const double &value); + void Set(asIScriptEngine *engine, CScriptDictValue &value); + + // Gets the stored value. Returns false if the value isn't compatible with the informed typeId + bool Get(asIScriptEngine *engine, void *value, int typeId) const; + bool Get(asIScriptEngine *engine, asINT64 &value) const; + bool Get(asIScriptEngine *engine, double &value) const; + + // Returns the address of the stored value for inspection + const void *GetAddressOfValue() const; + + // Returns the type id of the stored value + int GetTypeId() const; + + // Free the stored value + void FreeValue(asIScriptEngine *engine); + + // GC callback + void EnumReferences(asIScriptEngine *engine); + +protected: + friend class CScriptDictionary; + + union + { + asINT64 m_valueInt; + double m_valueFlt; + void *m_valueObj; + }; + int m_typeId; +}; + +class CScriptDictionary +{ +public: + // Factory functions + static CScriptDictionary *Create(asIScriptEngine *engine); + + // Called from the script to instantiate a dictionary from an initialization list + static CScriptDictionary *Create(asBYTE *buffer); + + // Reference counting + void AddRef() const; + void Release() const; + + // Reassign the dictionary + CScriptDictionary &operator =(const CScriptDictionary &other); + + // Sets a key/value pair + void Set(const dictKey_t &key, void *value, int typeId); + void Set(const dictKey_t &key, const asINT64 &value); + void Set(const dictKey_t &key, const double &value); + + // Gets the stored value. Returns false if the value isn't compatible with the informed typeId + bool Get(const dictKey_t &key, void *value, int typeId) const; + bool Get(const dictKey_t &key, asINT64 &value) const; + bool Get(const dictKey_t &key, double &value) const; + + // Index accessors. If the dictionary is not const it inserts the value if it doesn't already exist + // If the dictionary is const then a script exception is set if it doesn't exist and a null pointer is returned + CScriptDictValue *operator[](const dictKey_t &key); + const CScriptDictValue *operator[](const dictKey_t &key) const; + + // Returns the type id of the stored value, or negative if it doesn't exist + int GetTypeId(const dictKey_t &key) const; + + // Returns true if the key is set + bool Exists(const dictKey_t &key) const; + + // Returns true if there are no key/value pairs in the dictionary + bool IsEmpty() const; + + // Returns the number of key/value pairs in the dictionary + asUINT GetSize() const; + + // Deletes the key + bool Delete(const dictKey_t &key); + + // Deletes all keys + void DeleteAll(); + + // Get an array of all keys + CScriptArray *GetKeys() const; + + // STL style iterator + class CIterator + { + public: + void operator++(); // Pre-increment + void operator++(int); // Post-increment + + // This is needed to support C++11 range-for + CIterator &operator*(); + + bool operator==(const CIterator &other) const; + bool operator!=(const CIterator &other) const; + + // Accessors + const dictKey_t &GetKey() const; + int GetTypeId() const; + bool GetValue(asINT64 &value) const; + bool GetValue(double &value) const; + bool GetValue(void *value, int typeId) const; + const void * GetAddressOfValue() const; + + protected: + friend class CScriptDictionary; + + CIterator(); + CIterator(const CScriptDictionary &dict, + dictMap_t::const_iterator it); + + CIterator &operator=(const CIterator &) {return *this;} // Not used + + dictMap_t::const_iterator m_it; + const CScriptDictionary &m_dict; + }; + + CIterator begin() const; + CIterator end() const; + CIterator find(const dictKey_t &key) const; + + // Garbage collections behaviours + int GetRefCount(); + void SetGCFlag(); + bool GetGCFlag(); + void EnumReferences(asIScriptEngine *engine); + void ReleaseAllReferences(asIScriptEngine *engine); + +protected: + // Since the dictionary uses the asAllocMem and asFreeMem functions to allocate memory + // the constructors are made protected so that the application cannot allocate it + // manually in a different way + CScriptDictionary(asIScriptEngine *engine); + CScriptDictionary(asBYTE *buffer); + + // We don't want anyone to call the destructor directly, it should be called through the Release method + virtual ~CScriptDictionary(); + + // Cache the object types needed + void Init(asIScriptEngine *engine); + + // Our properties + asIScriptEngine *engine; + mutable int refCount; + mutable bool gcFlag; + dictMap_t dict; +}; + +// This function will determine the configuration of the engine +// and use one of the two functions below to register the dictionary object +void RegisterScriptDictionary(asIScriptEngine *engine); + +// Call this function to register the math functions +// using native calling conventions +void RegisterScriptDictionary_Native(asIScriptEngine *engine); + +// Use this one instead if native calling conventions +// are not supported on the target platform +void RegisterScriptDictionary_Generic(asIScriptEngine *engine); + +END_AS_NAMESPACE + +#endif diff --git a/Deer/vendor/angelScript/src/scriptdictionary.cpp b/Deer/vendor/angelScript/src/scriptdictionary.cpp new file mode 100644 index 0000000..35342d6 --- /dev/null +++ b/Deer/vendor/angelScript/src/scriptdictionary.cpp @@ -0,0 +1,1299 @@ +#include +#include +#include "scriptdictionary.h" +#include "scriptarray.h" + +BEGIN_AS_NAMESPACE + +using namespace std; + +//------------------------------------------------------------------------ +// Object types are cached as user data to avoid costly runtime lookups + +// We just define a number here that we assume nobody else is using for +// object type user data. The add-ons have reserved the numbers 1000 +// through 1999 for this purpose, so we should be fine. +const asPWORD DICTIONARY_CACHE = 1003; + +// This cache holds the object type of the dictionary type and array type +// so it isn't necessary to look this up each time the dictionary or array +// is created. +struct SDictionaryCache +{ + asITypeInfo *dictType; + asITypeInfo *arrayType; + asITypeInfo *keyType; + + // This is called from RegisterScriptDictionary + static void Setup(asIScriptEngine *engine) + { + SDictionaryCache *cache = reinterpret_cast(engine->GetUserData(DICTIONARY_CACHE)); + if( cache == 0 ) + { + cache = new SDictionaryCache; + engine->SetUserData(cache, DICTIONARY_CACHE); + engine->SetEngineUserDataCleanupCallback(SDictionaryCache::Cleanup, DICTIONARY_CACHE); + + cache->dictType = engine->GetTypeInfoByName("dictionary"); + cache->arrayType = engine->GetTypeInfoByDecl("array"); + cache->keyType = engine->GetTypeInfoByDecl("string"); + } + } + + // This is called from the engine when shutting down + static void Cleanup(asIScriptEngine *engine) + { + SDictionaryCache *cache = reinterpret_cast(engine->GetUserData(DICTIONARY_CACHE)); + if( cache ) + delete cache; + } +}; + +//-------------------------------------------------------------------------- +// CScriptDictionary implementation + +CScriptDictionary *CScriptDictionary::Create(asIScriptEngine *engine) +{ + // Use the custom memory routine from AngelScript to allow application to better control how much memory is used + CScriptDictionary *obj = (CScriptDictionary*)asAllocMem(sizeof(CScriptDictionary)); + new(obj) CScriptDictionary(engine); + return obj; +} + +CScriptDictionary *CScriptDictionary::Create(asBYTE *buffer) +{ + // Use the custom memory routine from AngelScript to allow application to better control how much memory is used + CScriptDictionary *obj = (CScriptDictionary*)asAllocMem(sizeof(CScriptDictionary)); + new(obj) CScriptDictionary(buffer); + return obj; +} + +CScriptDictionary::CScriptDictionary(asIScriptEngine *engine) +{ + Init(engine); +} + +void CScriptDictionary::Init(asIScriptEngine *e) +{ + // We start with one reference + refCount = 1; + gcFlag = false; + + // Keep a reference to the engine for as long as we live + // We don't increment the reference counter, because the + // engine will hold a pointer to the object in the GC. + engine = e; + + // The dictionary object type is cached to avoid dynamically parsing it each time + SDictionaryCache *cache = reinterpret_cast(engine->GetUserData(DICTIONARY_CACHE)); + + // Notify the garbage collector of this object + engine->NotifyGarbageCollectorOfNewObject(this, cache->dictType); +} + +CScriptDictionary::CScriptDictionary(asBYTE *buffer) +{ + // This constructor will always be called from a script + // so we can get the engine from the active context + asIScriptContext *ctx = asGetActiveContext(); + Init(ctx->GetEngine()); + + // Determine if the dictionary key type is registered as reference type or value type + SDictionaryCache& cache = *reinterpret_cast(engine->GetUserData(DICTIONARY_CACHE)); + bool keyAsRef = cache.keyType->GetFlags() & asOBJ_REF ? true : false; + + // Initialize the dictionary from the buffer + asUINT length = *(asUINT*)buffer; + buffer += 4; + + while( length-- ) + { + // Align the buffer pointer on a 4 byte boundary in + // case previous value was smaller than 4 bytes + if( asPWORD(buffer) & 0x3 ) + buffer += 4 - (asPWORD(buffer) & 0x3); + + // Get the name value pair from the buffer and insert it in the dictionary + dictKey_t name; + if (keyAsRef) + { + name = **(dictKey_t**)buffer; + buffer += sizeof(dictKey_t*); + } + else + { + name = *(dictKey_t*)buffer; + buffer += sizeof(dictKey_t); + } + + // Get the type id of the value + int typeId = *(int*)buffer; + buffer += sizeof(int); + + // Depending on the type id, the value will inline in the buffer or a pointer + void *ref = (void*)buffer; + + if( typeId >= asTYPEID_INT8 && typeId <= asTYPEID_DOUBLE ) + { + // Convert primitive values to either int64 or double, so we can use the overloaded Set methods + asINT64 i64; + double d; + switch( typeId ) + { + case asTYPEID_INT8: i64 = *(char*) ref; break; + case asTYPEID_INT16: i64 = *(short*) ref; break; + case asTYPEID_INT32: i64 = *(int*) ref; break; + case asTYPEID_INT64: i64 = *(asINT64*) ref; break; + case asTYPEID_UINT8: i64 = *(unsigned char*) ref; break; + case asTYPEID_UINT16: i64 = *(unsigned short*)ref; break; + case asTYPEID_UINT32: i64 = *(unsigned int*) ref; break; + case asTYPEID_UINT64: i64 = *(asINT64*) ref; break; + case asTYPEID_FLOAT: d = *(float*) ref; break; + case asTYPEID_DOUBLE: d = *(double*) ref; break; + } + + if( typeId >= asTYPEID_FLOAT ) + Set(name, d); + else + Set(name, i64); + } + else + { + if( (typeId & asTYPEID_MASK_OBJECT) && + !(typeId & asTYPEID_OBJHANDLE) && + (engine->GetTypeInfoById(typeId)->GetFlags() & asOBJ_REF) ) + { + // Dereference the pointer to get the reference to the actual object + ref = *(void**)ref; + } + + Set(name, ref, typeId); + } + + // Advance the buffer pointer with the size of the value + if( typeId & asTYPEID_MASK_OBJECT ) + { + asITypeInfo *ti = engine->GetTypeInfoById(typeId); + if( ti->GetFlags() & asOBJ_VALUE ) + buffer += ti->GetSize(); + else + buffer += sizeof(void*); + } + else if( typeId == 0 ) + { + // null pointer + buffer += sizeof(void*); + } + else + { + buffer += engine->GetSizeOfPrimitiveType(typeId); + } + } +} + +CScriptDictionary::~CScriptDictionary() +{ + // Delete all keys and values + DeleteAll(); +} + +void CScriptDictionary::AddRef() const +{ + // We need to clear the GC flag + gcFlag = false; + asAtomicInc(refCount); +} + +void CScriptDictionary::Release() const +{ + // We need to clear the GC flag + gcFlag = false; + if( asAtomicDec(refCount) == 0 ) + { + this->~CScriptDictionary(); + asFreeMem(const_cast(this)); + } +} + +int CScriptDictionary::GetRefCount() +{ + return refCount; +} + +void CScriptDictionary::SetGCFlag() +{ + gcFlag = true; +} + +bool CScriptDictionary::GetGCFlag() +{ + return gcFlag; +} + +void CScriptDictionary::EnumReferences(asIScriptEngine *inEngine) +{ + // TODO: If garbage collection can be done from a separate thread, then this method must be + // protected so that it doesn't get lost during the iteration if the dictionary is modified + + // Call the gc enum callback for each of the objects + dictMap_t::iterator it; + for( it = dict.begin(); it != dict.end(); it++ ) + { + if (it->second.m_typeId & asTYPEID_MASK_OBJECT) + { + asITypeInfo *subType = engine->GetTypeInfoById(it->second.m_typeId); + if ((subType->GetFlags() & asOBJ_VALUE) && (subType->GetFlags() & asOBJ_GC)) + { + // For value types we need to forward the enum callback + // to the object so it can decide what to do + engine->ForwardGCEnumReferences(it->second.m_valueObj, subType); + } + else + { + // For others, simply notify the GC about the reference + inEngine->GCEnumCallback(it->second.m_valueObj); + } + } + } +} + +void CScriptDictionary::ReleaseAllReferences(asIScriptEngine * /*engine*/) +{ + // We're being told to release all references in + // order to break circular references for dead objects + DeleteAll(); +} + +CScriptDictionary &CScriptDictionary::operator =(const CScriptDictionary &other) +{ + // Clear everything we had before + DeleteAll(); + + // Do a shallow copy of the dictionary + dictMap_t::const_iterator it; + for( it = other.dict.begin(); it != other.dict.end(); it++ ) + { + if( it->second.m_typeId & asTYPEID_OBJHANDLE ) + Set(it->first, (void*)&it->second.m_valueObj, it->second.m_typeId); + else if( it->second.m_typeId & asTYPEID_MASK_OBJECT ) + Set(it->first, (void*)it->second.m_valueObj, it->second.m_typeId); + else + Set(it->first, (void*)&it->second.m_valueInt, it->second.m_typeId); + } + + return *this; +} + +CScriptDictValue *CScriptDictionary::operator[](const dictKey_t &key) +{ + // Return the existing value if it exists, else insert an empty value + return &dict[key]; +} + +const CScriptDictValue *CScriptDictionary::operator[](const dictKey_t &key) const +{ + // Return the existing value if it exists + dictMap_t::const_iterator it; + it = dict.find(key); + if( it != dict.end() ) + return &it->second; + + // Else raise an exception + asIScriptContext *ctx = asGetActiveContext(); + if( ctx ) + ctx->SetException("Invalid access to non-existing value"); + + return 0; +} + +void CScriptDictionary::Set(const dictKey_t &key, void *value, int typeId) +{ + dictMap_t::iterator it; + it = dict.find(key); + if( it == dict.end() ) + it = dict.insert(dictMap_t::value_type(key, CScriptDictValue())).first; + + it->second.Set(engine, value, typeId); +} + +// This overloaded method is implemented so that all integer and +// unsigned integers types will be stored in the dictionary as int64 +// through implicit conversions. This simplifies the management of the +// numeric types when the script retrieves the stored value using a +// different type. +void CScriptDictionary::Set(const dictKey_t &key, const asINT64 &value) +{ + Set(key, const_cast(&value), asTYPEID_INT64); +} + +// This overloaded method is implemented so that all floating point types +// will be stored in the dictionary as double through implicit conversions. +// This simplifies the management of the numeric types when the script +// retrieves the stored value using a different type. +void CScriptDictionary::Set(const dictKey_t &key, const double &value) +{ + Set(key, const_cast(&value), asTYPEID_DOUBLE); +} + +// Returns true if the value was successfully retrieved +bool CScriptDictionary::Get(const dictKey_t &key, void *value, int typeId) const +{ + dictMap_t::const_iterator it; + it = dict.find(key); + if( it != dict.end() ) + return it->second.Get(engine, value, typeId); + + // AngelScript has already initialized the value with a default value, + // so we don't have to do anything if we don't find the element, or if + // the element is incompatible with the requested type. + + return false; +} + +// Returns the type id of the stored value +int CScriptDictionary::GetTypeId(const dictKey_t &key) const +{ + dictMap_t::const_iterator it; + it = dict.find(key); + if( it != dict.end() ) + return it->second.m_typeId; + + return -1; +} + +bool CScriptDictionary::Get(const dictKey_t &key, asINT64 &value) const +{ + return Get(key, &value, asTYPEID_INT64); +} + +bool CScriptDictionary::Get(const dictKey_t &key, double &value) const +{ + return Get(key, &value, asTYPEID_DOUBLE); +} + +bool CScriptDictionary::Exists(const dictKey_t &key) const +{ + dictMap_t::const_iterator it; + it = dict.find(key); + if( it != dict.end() ) + return true; + + return false; +} + +bool CScriptDictionary::IsEmpty() const +{ + if( dict.size() == 0 ) + return true; + + return false; +} + +asUINT CScriptDictionary::GetSize() const +{ + return asUINT(dict.size()); +} + +bool CScriptDictionary::Delete(const dictKey_t &key) +{ + dictMap_t::iterator it; + it = dict.find(key); + if( it != dict.end() ) + { + it->second.FreeValue(engine); + dict.erase(it); + return true; + } + + return false; +} + +void CScriptDictionary::DeleteAll() +{ + dictMap_t::iterator it; + for( it = dict.begin(); it != dict.end(); it++ ) + it->second.FreeValue(engine); + + dict.clear(); +} + +CScriptArray* CScriptDictionary::GetKeys() const +{ + // Retrieve the object type for the array from the cache + SDictionaryCache *cache = reinterpret_cast(engine->GetUserData(DICTIONARY_CACHE)); + asITypeInfo *ti = cache->arrayType; + + // Create the array object + CScriptArray *array = CScriptArray::Create(ti, asUINT(dict.size())); + long current = -1; + dictMap_t::const_iterator it; + for( it = dict.begin(); it != dict.end(); it++ ) + { + current++; + *(dictKey_t*)array->At(current) = it->first; + } + + return array; +} + +//-------------------------------------------------------------------------- +// Generic wrappers + +void ScriptDictionaryFactory_Generic(asIScriptGeneric *gen) +{ + *(CScriptDictionary**)gen->GetAddressOfReturnLocation() = CScriptDictionary::Create(gen->GetEngine()); +} + +void ScriptDictionaryListFactory_Generic(asIScriptGeneric *gen) +{ + asBYTE *buffer = (asBYTE*)gen->GetArgAddress(0); + *(CScriptDictionary**)gen->GetAddressOfReturnLocation() = CScriptDictionary::Create(buffer); +} + +void ScriptDictionaryAddRef_Generic(asIScriptGeneric *gen) +{ + CScriptDictionary *dict = (CScriptDictionary*)gen->GetObject(); + dict->AddRef(); +} + +void ScriptDictionaryRelease_Generic(asIScriptGeneric *gen) +{ + CScriptDictionary *dict = (CScriptDictionary*)gen->GetObject(); + dict->Release(); +} + +void ScriptDictionaryAssign_Generic(asIScriptGeneric *gen) +{ + CScriptDictionary *dict = (CScriptDictionary*)gen->GetObject(); + CScriptDictionary *other = *(CScriptDictionary**)gen->GetAddressOfArg(0); + *dict = *other; + *(CScriptDictionary**)gen->GetAddressOfReturnLocation() = dict; +} + +void ScriptDictionarySet_Generic(asIScriptGeneric *gen) +{ + CScriptDictionary *dict = (CScriptDictionary*)gen->GetObject(); + dictKey_t *key = *(dictKey_t**)gen->GetAddressOfArg(0); + void *ref = *(void**)gen->GetAddressOfArg(1); + int typeId = gen->GetArgTypeId(1); + dict->Set(*key, ref, typeId); +} + +void ScriptDictionarySetInt_Generic(asIScriptGeneric *gen) +{ + CScriptDictionary *dict = (CScriptDictionary*)gen->GetObject(); + dictKey_t *key = *(dictKey_t**)gen->GetAddressOfArg(0); + void *ref = *(void**)gen->GetAddressOfArg(1); + dict->Set(*key, *(asINT64*)ref); +} + +void ScriptDictionarySetFlt_Generic(asIScriptGeneric *gen) +{ + CScriptDictionary *dict = (CScriptDictionary*)gen->GetObject(); + dictKey_t *key = *(dictKey_t**)gen->GetAddressOfArg(0); + void *ref = *(void**)gen->GetAddressOfArg(1); + dict->Set(*key, *(double*)ref); +} + +void ScriptDictionaryGet_Generic(asIScriptGeneric *gen) +{ + CScriptDictionary *dict = (CScriptDictionary*)gen->GetObject(); + dictKey_t *key = *(dictKey_t**)gen->GetAddressOfArg(0); + void *ref = *(void**)gen->GetAddressOfArg(1); + int typeId = gen->GetArgTypeId(1); + *(bool*)gen->GetAddressOfReturnLocation() = dict->Get(*key, ref, typeId); +} + +void ScriptDictionaryGetInt_Generic(asIScriptGeneric *gen) +{ + CScriptDictionary *dict = (CScriptDictionary*)gen->GetObject(); + dictKey_t *key = *(dictKey_t**)gen->GetAddressOfArg(0); + void *ref = *(void**)gen->GetAddressOfArg(1); + *(bool*)gen->GetAddressOfReturnLocation() = dict->Get(*key, *(asINT64*)ref); +} + +void ScriptDictionaryGetFlt_Generic(asIScriptGeneric *gen) +{ + CScriptDictionary *dict = (CScriptDictionary*)gen->GetObject(); + dictKey_t *key = *(dictKey_t**)gen->GetAddressOfArg(0); + void *ref = *(void**)gen->GetAddressOfArg(1); + *(bool*)gen->GetAddressOfReturnLocation() = dict->Get(*key, *(double*)ref); +} + +void ScriptDictionaryExists_Generic(asIScriptGeneric *gen) +{ + CScriptDictionary *dict = (CScriptDictionary*)gen->GetObject(); + dictKey_t *key = *(dictKey_t**)gen->GetAddressOfArg(0); + bool ret = dict->Exists(*key); + *(bool*)gen->GetAddressOfReturnLocation() = ret; +} + +void ScriptDictionaryIsEmpty_Generic(asIScriptGeneric *gen) +{ + CScriptDictionary *dict = (CScriptDictionary*)gen->GetObject(); + bool ret = dict->IsEmpty(); + *(bool*)gen->GetAddressOfReturnLocation() = ret; +} + +void ScriptDictionaryGetSize_Generic(asIScriptGeneric *gen) +{ + CScriptDictionary *dict = (CScriptDictionary*)gen->GetObject(); + asUINT ret = dict->GetSize(); + *(asUINT*)gen->GetAddressOfReturnLocation() = ret; +} + +void ScriptDictionaryDelete_Generic(asIScriptGeneric *gen) +{ + CScriptDictionary *dict = (CScriptDictionary*)gen->GetObject(); + dictKey_t *key = *(dictKey_t**)gen->GetAddressOfArg(0); + *(bool*)gen->GetAddressOfReturnLocation() = dict->Delete(*key); +} + +void ScriptDictionaryDeleteAll_Generic(asIScriptGeneric *gen) +{ + CScriptDictionary *dict = (CScriptDictionary*)gen->GetObject(); + dict->DeleteAll(); +} + +static void ScriptDictionaryGetRefCount_Generic(asIScriptGeneric *gen) +{ + CScriptDictionary *self = (CScriptDictionary*)gen->GetObject(); + *(int*)gen->GetAddressOfReturnLocation() = self->GetRefCount(); +} + +static void ScriptDictionarySetGCFlag_Generic(asIScriptGeneric *gen) +{ + CScriptDictionary *self = (CScriptDictionary*)gen->GetObject(); + self->SetGCFlag(); +} + +static void ScriptDictionaryGetGCFlag_Generic(asIScriptGeneric *gen) +{ + CScriptDictionary *self = (CScriptDictionary*)gen->GetObject(); + *(bool*)gen->GetAddressOfReturnLocation() = self->GetGCFlag(); +} + +static void ScriptDictionaryEnumReferences_Generic(asIScriptGeneric *gen) +{ + CScriptDictionary *self = (CScriptDictionary*)gen->GetObject(); + asIScriptEngine *engine = *(asIScriptEngine**)gen->GetAddressOfArg(0); + self->EnumReferences(engine); +} + +static void ScriptDictionaryReleaseAllReferences_Generic(asIScriptGeneric *gen) +{ + CScriptDictionary *self = (CScriptDictionary*)gen->GetObject(); + asIScriptEngine *engine = *(asIScriptEngine**)gen->GetAddressOfArg(0); + self->ReleaseAllReferences(engine); +} + +static void CScriptDictionaryGetKeys_Generic(asIScriptGeneric *gen) +{ + CScriptDictionary *self = (CScriptDictionary*)gen->GetObject(); + *(CScriptArray**)gen->GetAddressOfReturnLocation() = self->GetKeys(); +} + +static void CScriptDictionary_opIndex_Generic(asIScriptGeneric *gen) +{ + CScriptDictionary *self = (CScriptDictionary*)gen->GetObject(); + dictKey_t *key = *(dictKey_t**)gen->GetAddressOfArg(0); + *(CScriptDictValue**)gen->GetAddressOfReturnLocation() = self->operator[](*key); +} + +static void CScriptDictionary_opIndex_const_Generic(asIScriptGeneric *gen) +{ + const CScriptDictionary *self = (const CScriptDictionary*)gen->GetObject(); + dictKey_t *key = *(dictKey_t**)gen->GetAddressOfArg(0); + *(const CScriptDictValue**)gen->GetAddressOfReturnLocation() = self->operator[](*key); +} + + +//------------------------------------------------------------------------- +// CScriptDictValue + +CScriptDictValue::CScriptDictValue() +{ + m_valueObj = 0; + m_typeId = 0; +} + +CScriptDictValue::CScriptDictValue(asIScriptEngine *engine, void *value, int typeId) +{ + m_valueObj = 0; + m_typeId = 0; + Set(engine, value, typeId); +} + +CScriptDictValue::~CScriptDictValue() +{ + if (m_valueObj && m_typeId) + { + asIScriptContext *ctx = asGetActiveContext(); + if (ctx) + FreeValue(ctx->GetEngine()); + else + { + // Must not hold an object when destroyed, as then the object will never be freed + assert((m_typeId & asTYPEID_MASK_OBJECT) == 0); + } + } +} + +void CScriptDictValue::FreeValue(asIScriptEngine *engine) +{ + // If it is a handle or a ref counted object, call release + if( m_typeId & asTYPEID_MASK_OBJECT ) + { + // Let the engine release the object + engine->ReleaseScriptObject(m_valueObj, engine->GetTypeInfoById(m_typeId)); + m_valueObj = 0; + m_typeId = 0; + } + + // For primitives, there's nothing to do +} + +void CScriptDictValue::EnumReferences(asIScriptEngine *inEngine) +{ + // If we're holding a reference, we'll notify the garbage collector of it + if (m_valueObj) + inEngine->GCEnumCallback(m_valueObj); + + // The object type itself is also garbage collected + if (m_typeId) + inEngine->GCEnumCallback(inEngine->GetTypeInfoById(m_typeId)); +} + +void CScriptDictValue::Set(asIScriptEngine *engine, void *value, int typeId) +{ + FreeValue(engine); + + m_typeId = typeId; + if( typeId & asTYPEID_OBJHANDLE ) + { + // We're receiving a reference to the handle, so we need to dereference it + m_valueObj = *(void**)value; + engine->AddRefScriptObject(m_valueObj, engine->GetTypeInfoById(typeId)); + } + else if( typeId & asTYPEID_MASK_OBJECT ) + { + // Create a copy of the object + m_valueObj = engine->CreateScriptObjectCopy(value, engine->GetTypeInfoById(typeId)); + if( m_valueObj == 0 ) + { + asIScriptContext *ctx = asGetActiveContext(); + if( ctx ) + ctx->SetException("Cannot create copy of object"); + } + } + else + { + // Copy the primitive value + // We receive a pointer to the value. + int size = engine->GetSizeOfPrimitiveType(typeId); + memcpy(&m_valueInt, value, size); + } +} + +void CScriptDictValue::Set(asIScriptEngine *engine, CScriptDictValue &value) +{ + if( value.m_typeId & asTYPEID_OBJHANDLE ) + Set(engine, (void*)&value.m_valueObj, value.m_typeId); + else if( value.m_typeId & asTYPEID_MASK_OBJECT ) + Set(engine, (void*)value.m_valueObj, value.m_typeId); + else + Set(engine, (void*)&value.m_valueInt, value.m_typeId); +} + +// This overloaded method is implemented so that all integer and +// unsigned integers types will be stored in the dictionary as int64 +// through implicit conversions. This simplifies the management of the +// numeric types when the script retrieves the stored value using a +// different type. +void CScriptDictValue::Set(asIScriptEngine *engine, const asINT64 &value) +{ + Set(engine, const_cast(&value), asTYPEID_INT64); +} + +// This overloaded method is implemented so that all floating point types +// will be stored in the dictionary as double through implicit conversions. +// This simplifies the management of the numeric types when the script +// retrieves the stored value using a different type. +void CScriptDictValue::Set(asIScriptEngine *engine, const double &value) +{ + Set(engine, const_cast(&value), asTYPEID_DOUBLE); +} + +bool CScriptDictValue::Get(asIScriptEngine *engine, void *value, int typeId) const +{ + // Return the value + if( typeId & asTYPEID_OBJHANDLE ) + { + // A handle can be retrieved if the stored type is a handle of same or compatible type + // or if the stored type is an object that implements the interface that the handle refer to. + if( (m_typeId & asTYPEID_MASK_OBJECT) ) + { + // Don't allow the get if the stored handle is to a const, but the desired handle is not + if( (m_typeId & asTYPEID_HANDLETOCONST) && !(typeId & asTYPEID_HANDLETOCONST) ) + return false; + + // RefCastObject will increment the refcount if successful + engine->RefCastObject(m_valueObj, engine->GetTypeInfoById(m_typeId), engine->GetTypeInfoById(typeId), reinterpret_cast(value)); + + return true; + } + } + else if( typeId & asTYPEID_MASK_OBJECT ) + { + // Verify that the copy can be made + bool isCompatible = false; + + // Allow a handle to be value assigned if the wanted type is not a handle + if( (m_typeId & ~(asTYPEID_OBJHANDLE | asTYPEID_HANDLETOCONST) ) == typeId && m_valueObj != 0 ) + isCompatible = true; + + // Copy the object into the given reference + if( isCompatible ) + { + engine->AssignScriptObject(value, m_valueObj, engine->GetTypeInfoById(typeId)); + + return true; + } + } + else + { + if( m_typeId == typeId ) + { + int size = engine->GetSizeOfPrimitiveType(typeId); + memcpy(value, &m_valueInt, size); + return true; + } + + // We know all numbers are stored as either int64 or double, since we register overloaded functions for those + // Only bool and enums needs to be treated separately + if( typeId == asTYPEID_DOUBLE ) + { + if( m_typeId == asTYPEID_INT64 ) + *(double*)value = double(m_valueInt); + else if (m_typeId == asTYPEID_BOOL) + { + // Use memcpy instead of type cast to make sure the code is endianess agnostic + char localValue; + memcpy(&localValue, &m_valueInt, sizeof(char)); + *(double*)value = localValue ? 1.0 : 0.0; + } + else if (m_typeId > asTYPEID_DOUBLE && (m_typeId & asTYPEID_MASK_OBJECT) == 0) + { + // Use memcpy instead of type cast to make sure the code is endianess agnostic + int localValue; + memcpy(&localValue, &m_valueInt, sizeof(int)); + *(double*)value = double(localValue); // enums are 32bit + } + else + { + // The stored type is an object + // TODO: Check if the object has a conversion operator to a primitive value + *(double*)value = 0; + return false; + } + return true; + } + else if( typeId == asTYPEID_INT64 ) + { + if( m_typeId == asTYPEID_DOUBLE ) + *(asINT64*)value = asINT64(m_valueFlt); + else if (m_typeId == asTYPEID_BOOL) + { + // Use memcpy instead of type cast to make sure the code is endianess agnostic + char localValue; + memcpy(&localValue, &m_valueInt, sizeof(char)); + *(asINT64*)value = localValue ? 1 : 0; + } + else if (m_typeId > asTYPEID_DOUBLE && (m_typeId & asTYPEID_MASK_OBJECT) == 0) + { + // Use memcpy instead of type cast to make sure the code is endianess agnostic + int localValue; + memcpy(&localValue, &m_valueInt, sizeof(int)); + *(asINT64*)value = localValue; // enums are 32bit + } + else + { + // The stored type is an object + // TODO: Check if the object has a conversion operator to a primitive value + *(asINT64*)value = 0; + return false; + } + return true; + } + else if( typeId > asTYPEID_DOUBLE && (m_typeId & asTYPEID_MASK_OBJECT) == 0 ) + { + // The desired type is an enum. These are always 32bit integers + if( m_typeId == asTYPEID_DOUBLE ) + *(int*)value = int(m_valueFlt); + else if( m_typeId == asTYPEID_INT64 ) + *(int*)value = int(m_valueInt); + else if (m_typeId == asTYPEID_BOOL) + { + // Use memcpy instead of type cast to make sure the code is endianess agnostic + char localValue; + memcpy(&localValue, &m_valueInt, sizeof(char)); + *(int*)value = localValue ? 1 : 0; + } + else if (m_typeId > asTYPEID_DOUBLE && (m_typeId & asTYPEID_MASK_OBJECT) == 0) + { + // Use memcpy instead of type cast to make sure the code is endianess agnostic + int localValue; + memcpy(&localValue, &m_valueInt, sizeof(int)); + *(int*)value = localValue; // enums are 32bit + } + else + { + // The stored type is an object + // TODO: Check if the object has a conversion operator to a primitive value + *(int*)value = 0; + return false; + } + return true; + } + else if( typeId == asTYPEID_BOOL ) + { + if (m_typeId & asTYPEID_OBJHANDLE) + { + // TODO: Check if the object has a conversion operator to a primitive value + *(bool*)value = m_valueObj ? true : false; + } + else if( m_typeId & asTYPEID_MASK_OBJECT ) + { + // TODO: Check if the object has a conversion operator to a primitive value + *(bool*)value = true; + } + else + { + // Compare only the bytes that were actually set + asQWORD zero = 0; + int size = engine->GetSizeOfPrimitiveType(m_typeId); + *(bool*)value = memcmp(&m_valueInt, &zero, size) == 0 ? false : true; + } + return true; + } + } + + // It was not possible to retrieve the value using the desired typeId + return false; +} + +const void * CScriptDictValue::GetAddressOfValue() const +{ + if( (m_typeId & asTYPEID_MASK_OBJECT) && !(m_typeId & asTYPEID_OBJHANDLE) ) + { + // Return the address to the object directly + return m_valueObj; + } + + // Return the address of the primitive or the pointer to the object + return reinterpret_cast(&m_valueObj); +} + +bool CScriptDictValue::Get(asIScriptEngine *engine, asINT64 &value) const +{ + return Get(engine, &value, asTYPEID_INT64); +} + +bool CScriptDictValue::Get(asIScriptEngine *engine, double &value) const +{ + return Get(engine, &value, asTYPEID_DOUBLE); +} + +int CScriptDictValue::GetTypeId() const +{ + return m_typeId; +} + +static void CScriptDictValue_Construct(void *mem) +{ + new(mem) CScriptDictValue(); +} + +static void CScriptDictValue_Destruct(CScriptDictValue *obj) +{ + asIScriptContext *ctx = asGetActiveContext(); + if( ctx ) + { + asIScriptEngine *engine = ctx->GetEngine(); + obj->FreeValue(engine); + } + obj->~CScriptDictValue(); +} + +static CScriptDictValue &CScriptDictValue_opAssign(void *ref, int typeId, CScriptDictValue *obj) +{ + asIScriptContext *ctx = asGetActiveContext(); + if( ctx ) + { + asIScriptEngine *engine = ctx->GetEngine(); + obj->Set(engine, ref, typeId); + } + return *obj; +} + +static CScriptDictValue &CScriptDictValue_opAssign(const CScriptDictValue &other, CScriptDictValue *obj) +{ + asIScriptContext *ctx = asGetActiveContext(); + if( ctx ) + { + asIScriptEngine *engine = ctx->GetEngine(); + obj->Set(engine, const_cast(other)); + } + + return *obj; +} + +static CScriptDictValue &CScriptDictValue_opAssign(double val, CScriptDictValue *obj) +{ + return CScriptDictValue_opAssign(&val, asTYPEID_DOUBLE, obj); +} + +static CScriptDictValue &CScriptDictValue_opAssign(asINT64 val, CScriptDictValue *obj) +{ + return CScriptDictValue_opAssign(&val, asTYPEID_INT64, obj); +} + +static void CScriptDictValue_opCast(void *ref, int typeId, CScriptDictValue *obj) +{ + asIScriptContext *ctx = asGetActiveContext(); + if( ctx ) + { + asIScriptEngine *engine = ctx->GetEngine(); + obj->Get(engine, ref, typeId); + } +} + +static asINT64 CScriptDictValue_opConvInt(CScriptDictValue *obj) +{ + asINT64 value; + CScriptDictValue_opCast(&value, asTYPEID_INT64, obj); + return value; +} + +static double CScriptDictValue_opConvDouble(CScriptDictValue *obj) +{ + double value; + CScriptDictValue_opCast(&value, asTYPEID_DOUBLE, obj); + return value; +} + +//------------------------------------------------------------------- +// generic wrapper for CScriptDictValue + +static void CScriptDictValue_opConvDouble_Generic(asIScriptGeneric *gen) +{ + CScriptDictValue *self = (CScriptDictValue*)gen->GetObject(); + double value; + self->Get(gen->GetEngine(), value); + *(double*)gen->GetAddressOfReturnLocation() = value; +} + +static void CScriptDictValue_opConvInt_Generic(asIScriptGeneric *gen) +{ + CScriptDictValue *self = (CScriptDictValue*)gen->GetObject(); + asINT64 value; + self->Get(gen->GetEngine(), value); + *(asINT64*)gen->GetAddressOfReturnLocation() = value; +} + +static void CScriptDictValue_opCast_Generic(asIScriptGeneric *gen) +{ + CScriptDictValue *self = (CScriptDictValue*)gen->GetObject(); + self->Get(gen->GetEngine(), gen->GetArgAddress(0), gen->GetArgTypeId(0)); +} + +static void CScriptDictValue_opAssign_int64_Generic(asIScriptGeneric *gen) +{ + CScriptDictValue *self = (CScriptDictValue*)gen->GetObject(); + *(CScriptDictValue**)gen->GetAddressOfReturnLocation() = &CScriptDictValue_opAssign((asINT64)gen->GetArgQWord(0), self); +} + +static void CScriptDictValue_opAssign_double_Generic(asIScriptGeneric *gen) +{ + CScriptDictValue *self = (CScriptDictValue*)gen->GetObject(); + *(CScriptDictValue**)gen->GetAddressOfReturnLocation() = &CScriptDictValue_opAssign(gen->GetArgDouble(0), self); +} + +static void CScriptDictValue_opAssign_Generic(asIScriptGeneric *gen) +{ + CScriptDictValue *self = (CScriptDictValue*)gen->GetObject(); + *(CScriptDictValue**)gen->GetAddressOfReturnLocation() = &CScriptDictValue_opAssign(gen->GetArgAddress(0), gen->GetArgTypeId(0), self); +} + +static void CScriptDictValue_opCopyAssign_Generic(asIScriptGeneric *gen) +{ + CScriptDictValue *self = (CScriptDictValue*)gen->GetObject(); + *(CScriptDictValue**)gen->GetAddressOfReturnLocation() = &CScriptDictValue_opAssign(*reinterpret_cast(gen->GetArgAddress(0)), self); +} + +static void CScriptDictValue_Construct_Generic(asIScriptGeneric *gen) +{ + CScriptDictValue *self = (CScriptDictValue*)gen->GetObject(); + CScriptDictValue_Construct(self); +} + +static void CScriptDictValue_Destruct_Generic(asIScriptGeneric *gen) +{ + CScriptDictValue *self = (CScriptDictValue*)gen->GetObject(); + CScriptDictValue_Destruct(self); +} + +static void CScriptDictValue_EnumReferences_Generic(asIScriptGeneric *gen) +{ + CScriptDictValue *self = (CScriptDictValue*)gen->GetObject(); + self->EnumReferences(gen->GetEngine()); +} + +static void CScriptDictValue_FreeValue_Generic(asIScriptGeneric *gen) +{ + CScriptDictValue *self = (CScriptDictValue*)gen->GetObject(); + self->FreeValue(gen->GetEngine()); +} + +//-------------------------------------------------------------------------- +// Register the type + +void RegisterScriptDictionary(asIScriptEngine *engine) +{ + if( strstr(asGetLibraryOptions(), "AS_MAX_PORTABILITY") ) + RegisterScriptDictionary_Generic(engine); + else + RegisterScriptDictionary_Native(engine); +} + +void RegisterScriptDictionary_Native(asIScriptEngine *engine) +{ + int r; + + // The array type must be available + assert( engine->GetTypeInfoByDecl("array") ); + +#if AS_CAN_USE_CPP11 + // With C++11 it is possible to use asGetTypeTraits to automatically determine the correct flags that represents the C++ class + r = engine->RegisterObjectType("dictionaryValue", sizeof(CScriptDictValue), asOBJ_VALUE | asOBJ_ASHANDLE | asOBJ_GC | asGetTypeTraits()); assert( r >= 0 ); +#else + r = engine->RegisterObjectType("dictionaryValue", sizeof(CScriptDictValue), asOBJ_VALUE | asOBJ_ASHANDLE | asOBJ_GC | asOBJ_APP_CLASS_CD); assert( r >= 0 ); +#endif + r = engine->RegisterObjectBehaviour("dictionaryValue", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(CScriptDictValue_Construct), asCALL_CDECL_OBJLAST); assert( r >= 0 ); + r = engine->RegisterObjectBehaviour("dictionaryValue", asBEHAVE_DESTRUCT, "void f()", asFUNCTION(CScriptDictValue_Destruct), asCALL_CDECL_OBJLAST); assert( r >= 0 ); + r = engine->RegisterObjectBehaviour("dictionaryValue", asBEHAVE_ENUMREFS, "void f(int&in)", asMETHOD(CScriptDictValue, EnumReferences), asCALL_THISCALL); assert(r >= 0); + r = engine->RegisterObjectBehaviour("dictionaryValue", asBEHAVE_RELEASEREFS, "void f(int&in)", asMETHOD(CScriptDictValue, FreeValue), asCALL_THISCALL); assert(r >= 0); + r = engine->RegisterObjectMethod("dictionaryValue", "dictionaryValue &opAssign(const dictionaryValue &in)", asFUNCTIONPR(CScriptDictValue_opAssign, (const CScriptDictValue &, CScriptDictValue *), CScriptDictValue &), asCALL_CDECL_OBJLAST); assert( r >= 0 ); + r = engine->RegisterObjectMethod("dictionaryValue", "dictionaryValue &opHndlAssign(const ?&in)", asFUNCTIONPR(CScriptDictValue_opAssign, (void *, int, CScriptDictValue*), CScriptDictValue &), asCALL_CDECL_OBJLAST); assert( r >= 0 ); + r = engine->RegisterObjectMethod("dictionaryValue", "dictionaryValue &opHndlAssign(const dictionaryValue &in)", asFUNCTIONPR(CScriptDictValue_opAssign, (const CScriptDictValue &, CScriptDictValue *), CScriptDictValue &), asCALL_CDECL_OBJLAST); assert(r >= 0); + r = engine->RegisterObjectMethod("dictionaryValue", "dictionaryValue &opAssign(const ?&in)", asFUNCTIONPR(CScriptDictValue_opAssign, (void *, int, CScriptDictValue*), CScriptDictValue &), asCALL_CDECL_OBJLAST); assert( r >= 0 ); + r = engine->RegisterObjectMethod("dictionaryValue", "dictionaryValue &opAssign(double)", asFUNCTIONPR(CScriptDictValue_opAssign, (double, CScriptDictValue*), CScriptDictValue &), asCALL_CDECL_OBJLAST); assert( r >= 0 ); + r = engine->RegisterObjectMethod("dictionaryValue", "dictionaryValue &opAssign(int64)", asFUNCTIONPR(CScriptDictValue_opAssign, (asINT64, CScriptDictValue*), CScriptDictValue &), asCALL_CDECL_OBJLAST); assert( r >= 0 ); + r = engine->RegisterObjectMethod("dictionaryValue", "void opCast(?&out)", asFUNCTIONPR(CScriptDictValue_opCast, (void *, int, CScriptDictValue*), void), asCALL_CDECL_OBJLAST); assert( r >= 0 ); + r = engine->RegisterObjectMethod("dictionaryValue", "void opConv(?&out)", asFUNCTIONPR(CScriptDictValue_opCast, (void *, int, CScriptDictValue*), void), asCALL_CDECL_OBJLAST); assert( r >= 0 ); + r = engine->RegisterObjectMethod("dictionaryValue", "int64 opConv()", asFUNCTIONPR(CScriptDictValue_opConvInt, (CScriptDictValue*), asINT64), asCALL_CDECL_OBJLAST); assert( r >= 0 ); + r = engine->RegisterObjectMethod("dictionaryValue", "double opConv()", asFUNCTIONPR(CScriptDictValue_opConvDouble, (CScriptDictValue*), double), asCALL_CDECL_OBJLAST); assert( r >= 0 ); + + r = engine->RegisterObjectType("dictionary", sizeof(CScriptDictionary), asOBJ_REF | asOBJ_GC); assert( r >= 0 ); + // Use the generic interface to construct the object since we need the engine pointer, we could also have retrieved the engine pointer from the active context + r = engine->RegisterObjectBehaviour("dictionary", asBEHAVE_FACTORY, "dictionary@ f()", asFUNCTION(ScriptDictionaryFactory_Generic), asCALL_GENERIC); assert( r >= 0 ); + r = engine->RegisterObjectBehaviour("dictionary", asBEHAVE_LIST_FACTORY, "dictionary @f(int &in) {repeat {string, ?}}", asFUNCTION(ScriptDictionaryListFactory_Generic), asCALL_GENERIC); assert( r >= 0 ); + r = engine->RegisterObjectBehaviour("dictionary", asBEHAVE_ADDREF, "void f()", asMETHOD(CScriptDictionary,AddRef), asCALL_THISCALL); assert( r >= 0 ); + r = engine->RegisterObjectBehaviour("dictionary", asBEHAVE_RELEASE, "void f()", asMETHOD(CScriptDictionary,Release), asCALL_THISCALL); assert( r >= 0 ); + + r = engine->RegisterObjectMethod("dictionary", "dictionary &opAssign(const dictionary &in)", asMETHODPR(CScriptDictionary, operator=, (const CScriptDictionary &), CScriptDictionary&), asCALL_THISCALL); assert( r >= 0 ); + + r = engine->RegisterObjectMethod("dictionary", "void set(const string &in, const ?&in)", asMETHODPR(CScriptDictionary,Set,(const dictKey_t&,void*,int),void), asCALL_THISCALL); assert( r >= 0 ); + r = engine->RegisterObjectMethod("dictionary", "bool get(const string &in, ?&out) const", asMETHODPR(CScriptDictionary,Get,(const dictKey_t&,void*,int) const,bool), asCALL_THISCALL); assert( r >= 0 ); + + r = engine->RegisterObjectMethod("dictionary", "void set(const string &in, const int64&in)", asMETHODPR(CScriptDictionary,Set,(const dictKey_t&,const asINT64&),void), asCALL_THISCALL); assert( r >= 0 ); + r = engine->RegisterObjectMethod("dictionary", "bool get(const string &in, int64&out) const", asMETHODPR(CScriptDictionary,Get,(const dictKey_t&,asINT64&) const,bool), asCALL_THISCALL); assert( r >= 0 ); + + r = engine->RegisterObjectMethod("dictionary", "void set(const string &in, const double&in)", asMETHODPR(CScriptDictionary,Set,(const dictKey_t&,const double&),void), asCALL_THISCALL); assert( r >= 0 ); + r = engine->RegisterObjectMethod("dictionary", "bool get(const string &in, double&out) const", asMETHODPR(CScriptDictionary,Get,(const dictKey_t&,double&) const,bool), asCALL_THISCALL); assert( r >= 0 ); + + r = engine->RegisterObjectMethod("dictionary", "bool exists(const string &in) const", asMETHOD(CScriptDictionary,Exists), asCALL_THISCALL); assert( r >= 0 ); + r = engine->RegisterObjectMethod("dictionary", "bool isEmpty() const", asMETHOD(CScriptDictionary, IsEmpty), asCALL_THISCALL); assert( r >= 0 ); + r = engine->RegisterObjectMethod("dictionary", "uint getSize() const", asMETHOD(CScriptDictionary, GetSize), asCALL_THISCALL); assert( r >= 0 ); + r = engine->RegisterObjectMethod("dictionary", "bool delete(const string &in)", asMETHOD(CScriptDictionary,Delete), asCALL_THISCALL); assert( r >= 0 ); + r = engine->RegisterObjectMethod("dictionary", "void deleteAll()", asMETHOD(CScriptDictionary,DeleteAll), asCALL_THISCALL); assert( r >= 0 ); + + r = engine->RegisterObjectMethod("dictionary", "array @getKeys() const", asMETHOD(CScriptDictionary,GetKeys), asCALL_THISCALL); assert( r >= 0 ); + + r = engine->RegisterObjectMethod("dictionary", "dictionaryValue &opIndex(const string &in)", asMETHODPR(CScriptDictionary, operator[], (const dictKey_t &), CScriptDictValue*), asCALL_THISCALL); assert( r >= 0 ); + r = engine->RegisterObjectMethod("dictionary", "const dictionaryValue &opIndex(const string &in) const", asMETHODPR(CScriptDictionary, operator[], (const dictKey_t &) const, const CScriptDictValue*), asCALL_THISCALL); assert( r >= 0 ); + + // Register GC behaviours + r = engine->RegisterObjectBehaviour("dictionary", asBEHAVE_GETREFCOUNT, "int f()", asMETHOD(CScriptDictionary,GetRefCount), asCALL_THISCALL); assert( r >= 0 ); + r = engine->RegisterObjectBehaviour("dictionary", asBEHAVE_SETGCFLAG, "void f()", asMETHOD(CScriptDictionary,SetGCFlag), asCALL_THISCALL); assert( r >= 0 ); + r = engine->RegisterObjectBehaviour("dictionary", asBEHAVE_GETGCFLAG, "bool f()", asMETHOD(CScriptDictionary,GetGCFlag), asCALL_THISCALL); assert( r >= 0 ); + r = engine->RegisterObjectBehaviour("dictionary", asBEHAVE_ENUMREFS, "void f(int&in)", asMETHOD(CScriptDictionary,EnumReferences), asCALL_THISCALL); assert( r >= 0 ); + r = engine->RegisterObjectBehaviour("dictionary", asBEHAVE_RELEASEREFS, "void f(int&in)", asMETHOD(CScriptDictionary,ReleaseAllReferences), asCALL_THISCALL); assert( r >= 0 ); + +#if AS_USE_STLNAMES == 1 + // Same as isEmpty + r = engine->RegisterObjectMethod("dictionary", "bool empty() const", asMETHOD(CScriptDictionary, IsEmpty), asCALL_THISCALL); assert( r >= 0 ); + // Same as getSize + r = engine->RegisterObjectMethod("dictionary", "uint size() const", asMETHOD(CScriptDictionary, GetSize), asCALL_THISCALL); assert( r >= 0 ); + // Same as delete + r = engine->RegisterObjectMethod("dictionary", "void erase(const string &in)", asMETHOD(CScriptDictionary,Delete), asCALL_THISCALL); assert( r >= 0 ); + // Same as deleteAll + r = engine->RegisterObjectMethod("dictionary", "void clear()", asMETHOD(CScriptDictionary,DeleteAll), asCALL_THISCALL); assert( r >= 0 ); +#endif + + // Cache some things the dictionary will need at runtime + SDictionaryCache::Setup(engine); +} + +void RegisterScriptDictionary_Generic(asIScriptEngine *engine) +{ + int r; + + // Register the cleanup callback for the object type cache + engine->SetEngineUserDataCleanupCallback(SDictionaryCache::Cleanup, DICTIONARY_CACHE); + +#if AS_CAN_USE_CPP11 + // With C++11 it is possible to use asGetTypeTraits to automatically determine the correct flags that represents the C++ class + r = engine->RegisterObjectType("dictionaryValue", sizeof(CScriptDictValue), asOBJ_VALUE | asOBJ_ASHANDLE | asOBJ_GC | asGetTypeTraits()); assert( r >= 0 ); +#else + r = engine->RegisterObjectType("dictionaryValue", sizeof(CScriptDictValue), asOBJ_VALUE | asOBJ_ASHANDLE | asOBJ_GC | asOBJ_APP_CLASS_CD); assert( r >= 0 ); +#endif + r = engine->RegisterObjectBehaviour("dictionaryValue", asBEHAVE_CONSTRUCT, "void f()", asFUNCTION(CScriptDictValue_Construct_Generic), asCALL_GENERIC); assert( r >= 0 ); + r = engine->RegisterObjectBehaviour("dictionaryValue", asBEHAVE_DESTRUCT, "void f()", asFUNCTION(CScriptDictValue_Destruct_Generic), asCALL_GENERIC); assert( r >= 0 ); + r = engine->RegisterObjectBehaviour("dictionaryValue", asBEHAVE_ENUMREFS, "void f(int&in)", asFUNCTION(CScriptDictValue_EnumReferences_Generic), asCALL_GENERIC); assert(r >= 0); + r = engine->RegisterObjectBehaviour("dictionaryValue", asBEHAVE_RELEASEREFS, "void f(int&in)", asFUNCTION(CScriptDictValue_FreeValue_Generic), asCALL_GENERIC); assert(r >= 0); + r = engine->RegisterObjectMethod("dictionaryValue", "dictionaryValue &opAssign(const dictionaryValue &in)", asFUNCTION(CScriptDictValue_opCopyAssign_Generic), asCALL_GENERIC); assert( r >= 0 ); + r = engine->RegisterObjectMethod("dictionaryValue", "dictionaryValue &opHndlAssign(const ?&in)", asFUNCTION(CScriptDictValue_opAssign_Generic), asCALL_GENERIC); assert( r >= 0 ); + r = engine->RegisterObjectMethod("dictionaryValue", "dictionaryValue &opHndlAssign(const dictionaryValue &in)", asFUNCTION(CScriptDictValue_opCopyAssign_Generic), asCALL_GENERIC); assert( r >= 0 ); + r = engine->RegisterObjectMethod("dictionaryValue", "dictionaryValue &opAssign(const ?&in)", asFUNCTION(CScriptDictValue_opAssign_Generic), asCALL_GENERIC); assert( r >= 0 ); + r = engine->RegisterObjectMethod("dictionaryValue", "dictionaryValue &opAssign(double)", asFUNCTION(CScriptDictValue_opAssign_double_Generic), asCALL_GENERIC); assert( r >= 0 ); + r = engine->RegisterObjectMethod("dictionaryValue", "dictionaryValue &opAssign(int64)", asFUNCTION(CScriptDictValue_opAssign_int64_Generic), asCALL_GENERIC); assert( r >= 0 ); + r = engine->RegisterObjectMethod("dictionaryValue", "void opCast(?&out)", asFUNCTION(CScriptDictValue_opCast_Generic), asCALL_GENERIC); assert( r >= 0 ); + r = engine->RegisterObjectMethod("dictionaryValue", "void opConv(?&out)", asFUNCTION(CScriptDictValue_opCast_Generic), asCALL_GENERIC); assert( r >= 0 ); + r = engine->RegisterObjectMethod("dictionaryValue", "int64 opConv()", asFUNCTION(CScriptDictValue_opConvInt_Generic), asCALL_GENERIC); assert( r >= 0 ); + r = engine->RegisterObjectMethod("dictionaryValue", "double opConv()", asFUNCTION(CScriptDictValue_opConvDouble_Generic), asCALL_GENERIC); assert( r >= 0 ); + + r = engine->RegisterObjectType("dictionary", sizeof(CScriptDictionary), asOBJ_REF | asOBJ_GC); assert( r >= 0 ); + r = engine->RegisterObjectBehaviour("dictionary", asBEHAVE_FACTORY, "dictionary@ f()", asFUNCTION(ScriptDictionaryFactory_Generic), asCALL_GENERIC); assert( r>= 0 ); + r = engine->RegisterObjectBehaviour("dictionary", asBEHAVE_LIST_FACTORY, "dictionary @f(int &in) {repeat {string, ?}}", asFUNCTION(ScriptDictionaryListFactory_Generic), asCALL_GENERIC); assert( r >= 0 ); + r = engine->RegisterObjectBehaviour("dictionary", asBEHAVE_ADDREF, "void f()", asFUNCTION(ScriptDictionaryAddRef_Generic), asCALL_GENERIC); assert( r >= 0 ); + r = engine->RegisterObjectBehaviour("dictionary", asBEHAVE_RELEASE, "void f()", asFUNCTION(ScriptDictionaryRelease_Generic), asCALL_GENERIC); assert( r >= 0 ); + + r = engine->RegisterObjectMethod("dictionary", "dictionary &opAssign(const dictionary &in)", asFUNCTION(ScriptDictionaryAssign_Generic), asCALL_GENERIC); assert( r >= 0 ); + + r = engine->RegisterObjectMethod("dictionary", "void set(const string &in, const ?&in)", asFUNCTION(ScriptDictionarySet_Generic), asCALL_GENERIC); assert( r >= 0 ); + r = engine->RegisterObjectMethod("dictionary", "bool get(const string &in, ?&out) const", asFUNCTION(ScriptDictionaryGet_Generic), asCALL_GENERIC); assert( r >= 0 ); + + r = engine->RegisterObjectMethod("dictionary", "void set(const string &in, const int64&in)", asFUNCTION(ScriptDictionarySetInt_Generic), asCALL_GENERIC); assert( r >= 0 ); + r = engine->RegisterObjectMethod("dictionary", "bool get(const string &in, int64&out) const", asFUNCTION(ScriptDictionaryGetInt_Generic), asCALL_GENERIC); assert( r >= 0 ); + + r = engine->RegisterObjectMethod("dictionary", "void set(const string &in, const double&in)", asFUNCTION(ScriptDictionarySetFlt_Generic), asCALL_GENERIC); assert( r >= 0 ); + r = engine->RegisterObjectMethod("dictionary", "bool get(const string &in, double&out) const", asFUNCTION(ScriptDictionaryGetFlt_Generic), asCALL_GENERIC); assert( r >= 0 ); + + r = engine->RegisterObjectMethod("dictionary", "bool exists(const string &in) const", asFUNCTION(ScriptDictionaryExists_Generic), asCALL_GENERIC); assert( r >= 0 ); + r = engine->RegisterObjectMethod("dictionary", "bool isEmpty() const", asFUNCTION(ScriptDictionaryIsEmpty_Generic), asCALL_GENERIC); assert( r >= 0 ); + r = engine->RegisterObjectMethod("dictionary", "uint getSize() const", asFUNCTION(ScriptDictionaryGetSize_Generic), asCALL_GENERIC); assert( r >= 0 ); + r = engine->RegisterObjectMethod("dictionary", "bool delete(const string &in)", asFUNCTION(ScriptDictionaryDelete_Generic), asCALL_GENERIC); assert( r >= 0 ); + r = engine->RegisterObjectMethod("dictionary", "void deleteAll()", asFUNCTION(ScriptDictionaryDeleteAll_Generic), asCALL_GENERIC); assert( r >= 0 ); + + r = engine->RegisterObjectMethod("dictionary", "array @getKeys() const", asFUNCTION(CScriptDictionaryGetKeys_Generic), asCALL_GENERIC); assert( r >= 0 ); + + r = engine->RegisterObjectMethod("dictionary", "dictionaryValue &opIndex(const string &in)", asFUNCTION(CScriptDictionary_opIndex_Generic), asCALL_GENERIC); assert( r >= 0 ); + r = engine->RegisterObjectMethod("dictionary", "const dictionaryValue &opIndex(const string &in) const", asFUNCTION(CScriptDictionary_opIndex_const_Generic), asCALL_GENERIC); assert( r >= 0 ); + + // Register GC behaviours + r = engine->RegisterObjectBehaviour("dictionary", asBEHAVE_GETREFCOUNT, "int f()", asFUNCTION(ScriptDictionaryGetRefCount_Generic), asCALL_GENERIC); assert( r >= 0 ); + r = engine->RegisterObjectBehaviour("dictionary", asBEHAVE_SETGCFLAG, "void f()", asFUNCTION(ScriptDictionarySetGCFlag_Generic), asCALL_GENERIC); assert( r >= 0 ); + r = engine->RegisterObjectBehaviour("dictionary", asBEHAVE_GETGCFLAG, "bool f()", asFUNCTION(ScriptDictionaryGetGCFlag_Generic), asCALL_GENERIC); assert( r >= 0 ); + r = engine->RegisterObjectBehaviour("dictionary", asBEHAVE_ENUMREFS, "void f(int&in)", asFUNCTION(ScriptDictionaryEnumReferences_Generic), asCALL_GENERIC); assert( r >= 0 ); + r = engine->RegisterObjectBehaviour("dictionary", asBEHAVE_RELEASEREFS, "void f(int&in)", asFUNCTION(ScriptDictionaryReleaseAllReferences_Generic), asCALL_GENERIC); assert( r >= 0 ); + + // Cache some things the dictionary will need at runtime + SDictionaryCache::Setup(engine); +} + +//------------------------------------------------------------------ +// Iterator implementation + +CScriptDictionary::CIterator CScriptDictionary::begin() const +{ + return CIterator(*this, dict.begin()); +} + +CScriptDictionary::CIterator CScriptDictionary::end() const +{ + return CIterator(*this, dict.end()); +} + +CScriptDictionary::CIterator CScriptDictionary::find(const dictKey_t &key) const +{ + return CIterator(*this, dict.find(key)); +} + +CScriptDictionary::CIterator::CIterator( + const CScriptDictionary &dict, + dictMap_t::const_iterator it) + : m_it(it), m_dict(dict) +{} + +void CScriptDictionary::CIterator::operator++() +{ + ++m_it; +} + +void CScriptDictionary::CIterator::operator++(int) +{ + ++m_it; + + // Normally the post increment would return a copy of the object with the original state, + // but it is rarely used so we skip this extra copy to avoid unnecessary overhead +} + +CScriptDictionary::CIterator &CScriptDictionary::CIterator::operator*() +{ + return *this; +} + +bool CScriptDictionary::CIterator::operator==(const CIterator &other) const +{ + return m_it == other.m_it; +} + +bool CScriptDictionary::CIterator::operator!=(const CIterator &other) const +{ + return m_it != other.m_it; +} + +const dictKey_t &CScriptDictionary::CIterator::GetKey() const +{ + return m_it->first; +} + +int CScriptDictionary::CIterator::GetTypeId() const +{ + return m_it->second.m_typeId; +} + +bool CScriptDictionary::CIterator::GetValue(asINT64 &value) const +{ + return m_it->second.Get(m_dict.engine, &value, asTYPEID_INT64); +} + +bool CScriptDictionary::CIterator::GetValue(double &value) const +{ + return m_it->second.Get(m_dict.engine, &value, asTYPEID_DOUBLE); +} + +bool CScriptDictionary::CIterator::GetValue(void *value, int typeId) const +{ + return m_it->second.Get(m_dict.engine, value, typeId); +} + +const void *CScriptDictionary::CIterator::GetAddressOfValue() const +{ + return m_it->second.GetAddressOfValue(); +} + +END_AS_NAMESPACE + + diff --git a/DeerStudio/Build.lua b/DeerStudio/Build.lua index d465328..6c6faa4 100755 --- a/DeerStudio/Build.lua +++ b/DeerStudio/Build.lua @@ -28,7 +28,8 @@ project "DeerStudio" "ImGui", "angelScript" } - defines { "DEER_RENDER" } + defines { "DEER_RENDER", + "AS_ENABLE_METADATA" } targetdir ("../bin/" .. OutputDir .. "/%{prj.name}") objdir ("../bin/int/" .. OutputDir .. "/%{prj.name}") diff --git a/DeerStudio/imgui.ini b/DeerStudio/imgui.ini index 15b403c..e9ae88e 100644 --- a/DeerStudio/imgui.ini +++ b/DeerStudio/imgui.ini @@ -1,6 +1,6 @@ [Window][DockSpace Demo] Pos=0,0 -Size=1920,1011 +Size=1741,1159 Collapsed=0 [Window][Debug##Default] @@ -9,53 +9,53 @@ Size=400,400 Collapsed=0 [Window][Terrain Editor] -Pos=1587,24 -Size=333,745 +Pos=1315,24 +Size=426,893 Collapsed=0 DockId=0x00000006,1 [Window][Viewport] -Pos=294,24 -Size=1291,745 +Pos=361,24 +Size=952,893 Collapsed=0 DockId=0x00000005,1 [Window][ViewportPannel] -Pos=294,24 -Size=1291,745 +Pos=361,24 +Size=952,893 Collapsed=0 DockId=0x00000005,0 [Window][ShaderExplorer] -Pos=0,771 -Size=1920,240 +Pos=0,919 +Size=1741,240 Collapsed=0 DockId=0x00000004,1 [Window][TreePannel] Pos=0,24 -Size=292,745 +Size=359,893 Collapsed=0 DockId=0x00000001,0 [Window][MeshExplorer] -Pos=0,771 -Size=1920,240 +Pos=0,919 +Size=1741,240 Collapsed=0 DockId=0x00000004,0 [Window][PropertiesPannel] -Pos=1587,24 -Size=333,745 +Pos=1315,24 +Size=426,893 Collapsed=0 DockId=0x00000006,0 [Docking][Data] -DockSpace ID=0xA1672E74 Window=0x4647B76E Pos=0,24 Size=1920,987 Split=Y Selected=0x34A4C10F +DockSpace ID=0xA1672E74 Window=0x4647B76E Pos=0,24 Size=1741,1135 Split=Y Selected=0x34A4C10F DockNode ID=0x00000003 Parent=0xA1672E74 SizeRef=1280,454 Split=X - DockNode ID=0x00000001 Parent=0x00000003 SizeRef=292,696 Selected=0xE45B9F93 - DockNode ID=0x00000002 Parent=0x00000003 SizeRef=986,696 Split=X Selected=0x34A4C10F - DockNode ID=0x00000005 Parent=0x00000002 SizeRef=651,454 CentralNode=1 Selected=0x34A4C10F - DockNode ID=0x00000006 Parent=0x00000002 SizeRef=333,454 Selected=0xA35A27E3 + DockNode ID=0x00000001 Parent=0x00000003 SizeRef=359,696 Selected=0xE45B9F93 + DockNode ID=0x00000002 Parent=0x00000003 SizeRef=1380,696 Split=X Selected=0x34A4C10F + DockNode ID=0x00000005 Parent=0x00000002 SizeRef=952,454 CentralNode=1 Selected=0x34A4C10F + DockNode ID=0x00000006 Parent=0x00000002 SizeRef=426,454 Selected=0x2A2C795E DockNode ID=0x00000004 Parent=0xA1672E74 SizeRef=1280,240 Selected=0xD962995A diff --git a/DeerStudio/src/DeerStudio/EditorEngine/EditorEngine.cpp b/DeerStudio/src/DeerStudio/EditorEngine/EditorEngine.cpp index 509dcff..2e0d034 100644 --- a/DeerStudio/src/DeerStudio/EditorEngine/EditorEngine.cpp +++ b/DeerStudio/src/DeerStudio/EditorEngine/EditorEngine.cpp @@ -11,6 +11,8 @@ #include "angelscript.h" #include "scriptbuilder.h" #include "scriptstdstring.h" +#include "scriptarray.h" +#include "scriptdictionary.h" void extract_angelScript(); @@ -34,6 +36,8 @@ namespace Deer { scriptEngine = asCreateScriptEngine(); RegisterStdString(scriptEngine); + RegisterScriptArray(scriptEngine, true); + RegisterScriptDictionary(scriptEngine); AS_RET_CHECK(scriptEngine->SetMessageCallback(asFUNCTION(Deer::EditorEngine::errorCallback), 0, asCALL_CDECL)); diff --git a/roe/Editor/mesh_explorer.as b/roe/Editor/MeshExplorer/MeshExplorer.as similarity index 100% rename from roe/Editor/mesh_explorer.as rename to roe/Editor/MeshExplorer/MeshExplorer.as diff --git a/roe/Editor/MeshExplorer/MeshPreviewRender.as b/roe/Editor/MeshExplorer/MeshPreviewRender.as new file mode 100644 index 0000000..4ff8ef8 --- /dev/null +++ b/roe/Editor/MeshExplorer/MeshPreviewRender.as @@ -0,0 +1,14 @@ +dictionary meshFrameBuffer; + +FrameBuffer getMeshFrameBuffer(string mesh) { + if (meshFrameBuffer.exists(mesh)) + return cast(meshFrameBuffer[mesh]); +} + +FrameBuffer generateMeshFrameBuffer(string mesh) { + FrameBuffer fb = Engine::createRGBA8FrameBuffer(mesh, 64, 64); + + + + return fb; +} \ No newline at end of file diff --git a/roe/Editor/as.predefined b/roe/Editor/as.predefined index b234fbe..fcb8346 100644 --- a/roe/Editor/as.predefined +++ b/roe/Editor/as.predefined @@ -506,3 +506,63 @@ namespace UI { int sliderInt(string&in, int value, int min, int max); float slider(string&in, float value, float min, float max); } + +class array { + T& opIndex(uint index); + const T& opIndex(uint index) const; + T[]& opAssign(const T[]&in); + void insertAt(uint index, const T&in value); + void insertAt(uint index, const T[]&inout arr); + void insertLast(const T&in value); + void removeAt(uint index); + void removeLast(); + void removeRange(uint start, uint count); + uint length() const; + void reserve(uint length); + void resize(uint length); + void sortAsc(); + void sortAsc(uint startAt, uint count); + void sortDesc(); + void sortDesc(uint startAt, uint count); + void reverse(); + int find(const T&in value) const; + int find(uint startAt, const T&in value) const; + int findByRef(const T&in value) const; + int findByRef(uint startAt, const T&in value) const; + bool opEquals(const T[]&in) const; + bool isEmpty() const; + //void sort(T[]::less&in, uint startAt = 0, uint count = uint ( - 1 )); + funcdef bool less(const T&in, const T&in); +} + +class dictionaryValue { + ~dictionaryValue(); + dictionaryValue(); + dictionaryValue& opAssign(const dictionaryValue&in); + dictionaryValue& opHndlAssign(const ?&in); + dictionaryValue& opHndlAssign(const dictionaryValue&in); + dictionaryValue& opAssign(const ?&in); + dictionaryValue& opAssign(double); + dictionaryValue& opAssign(int64); + void opCast(?&out); + void opConv(?&out); + int64 opConv(); + double opConv(); +} +class dictionary { + dictionary& opAssign(const dictionary&in); + void set(const string&in, const ?&in); + bool get(const string&in, ?&out) const; + void set(const string&in, const int64&in); + bool get(const string&in, int64&out) const; + void set(const string&in, const double&in); + bool get(const string&in, double&out) const; + bool exists(const string&in) const; + bool isEmpty() const; + uint getSize() const; + bool delete(const string&in); + void deleteAll(); + string[]@ getKeys() const; + dictionaryValue& opIndex(const string&in); + const dictionaryValue& opIndex(const string&in) const; +} \ No newline at end of file diff --git a/roe/tmp/voxel_texture_atlas.png b/roe/tmp/voxel_texture_atlas.png index ae0872800351b24db1c45b8d1d30bde590c56f9c..5cb7ad79e7e1a15137e28b5e66d81bf3ff58919a 100644 GIT binary patch literal 121869 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

lPzTUj(s2pGU({hD>V7jL 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%0AGHm-?|Y%zipq_ToP~l&{pPe3=CfMfyS?#z_M1 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 BhtL23 literal 123365 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