Groundwork for Steam Controller support

Picking

.gitignore

@@ -4,7 +4,3 @@ bin/
 lib/
 # Because apparently nobody has any self control
 *.orig
-
-tools/LiveTexturing/mayaPluginRTT/mayaPluginRTT/x64/Debug/
-tools/LiveTexturing/mayaPluginRTT/x64/Debug/
-*.suo

cmake/FindXerces.cmake

@@ -1,13 +1,13 @@
-# XERCES_FOUND
-# XERCES_INCLUDE_DIRS
-# XERCES_LIBRARIES
+# Xerces_FOUND
+# Xerces_INCLUDE_DIRS
+# Xerces_LIBRARIES
 
-find_path(XERCES_INCLUDE_DIR xercesc/dom/dom.hpp
+find_path(Xerces_INCLUDE_DIR xercesc/dom/dom.hpp
 	/usr/local/include
 	/usr/include
 )
 
-find_library(XERCES_LIBRARY
+find_library(Xerces_LIBRARY
 	NAMES
 	xerces-c_3
 	xerces-c_3D
@@ -16,8 +16,8 @@ find_library(XERCES_LIBRARY
 	/usr/lib
 )
 
-set(XERCES_INCLUDE_DIRS ${XERCES_INCLUDE_DIR})
-set(XERCES_LIBRARIES ${XERCES_LIBRARY})
+set(Xerces_INCLUDE_DIRS ${Xerces_INCLUDE_DIR})
+set(Xerces_LIBRARIES ${Xerces_LIBRARY})
 
-find_package_handle_standard_args(Xerces DEFAULT_MSG XERCES_LIBRARY XERCES_INCLUDE_DIR)
-mark_as_advanced(Xerces_FOUND XERCES_INCLUDE_DIR XERCES_LIBRARY)
+find_package_handle_standard_args(Xerces DEFAULT_MSG Xerces_LIBRARY Xerces_INCLUDE_DIR)
+mark_as_advanced(Xerces_FOUND Xerces_INCLUDE_DIR Xerces_LIBRARY)

include/Engine/Core/ComponentWrapper.h

@@ -2,7 +2,7 @@
 #define ComponentWrapper_h__
 
 #include "../Common.h"
-#include "EntityWrapper.h"
+#include "Entity.h"
 #include "ComponentInfo.h"
 #include "Util/Any.h"
 
@@ -11,7 +11,7 @@ struct ComponentWrapper
     ComponentWrapper(const ComponentInfo& componentInfo, char* data)
         : Info(componentInfo)
         , EntityID(*reinterpret_cast<::EntityID*>(data))
-        , Data(data + sizeof(EntityID))
+        , Data(data + sizeof(::EntityID))
     { }
 
     const ComponentInfo& Info;

include/Engine/Core/Entity.h

@@ -0,0 +1,6 @@
+#ifndef Entity_h__
+#define Entity_h__
+
+typedef unsigned int EntityID;
+
+#endif

include/Engine/Core/EntityFile.h

@@ -1,12 +0,0 @@
-#include "ResourceManager.h"
-
-class EntityFile : public Resource
-{
-	friend class ResourceManager;
-
-private:
-	EntityFile(std::string path);
-
-public:
-
-};

include/Engine/Core/EntityWrapper.h

@@ -1,15 +0,0 @@
-#ifndef Entity_h__
-#define Entity_h__
-
-typedef unsigned int EntityID;
-
-struct EntityWrapper
-{
-    EntityWrapper(EntityID entityID)
-        : ID(entityID)
-    { }
-
-	EntityID ID;
-};
-
-#endif

include/Engine/Core/EntityXMLFile.h

@@ -0,0 +1,141 @@
+#ifndef EntityXMLFile_h__
+#define EntityXMLFile_h__
+
+#include <sstream>
+
+#include "../Common.h"
+#include "../GLM.h"
+#include <xercesc/dom/DOM.hpp>
+#include <xercesc/dom/DOMLSInput.hpp>
+#include <xercesc/dom/DOMElement.hpp>
+#include <xercesc/framework/Wrapper4InputSource.hpp>
+#include <xercesc/framework/LocalFileInputSource.hpp>
+#include <xercesc/framework/LocalFileFormatTarget.hpp>
+#include <xercesc/framework/MemBufFormatTarget.hpp>
+#include <xercesc/framework/MemBufInputSource.hpp>
+#include <xercesc/sax/HandlerBase.hpp>
+#include <xercesc/util/PlatformUtils.hpp>
+#include <xercesc/util/XMLFloat.hpp>
+#include <xercesc/framework/XMLGrammarPoolImpl.hpp>
+#include <xercesc/parsers/XercesDOMParser.hpp>
+#include <xercesc/framework/psvi/XSElementDeclaration.hpp>
+#include <xercesc/framework/psvi/XSComplexTypeDefinition.hpp>
+#include <xercesc/framework/psvi/XSParticle.hpp>
+#include <xercesc/framework/psvi/XSModelGroup.hpp>
+#include <xercesc/framework/psvi/XSAnnotation.hpp>
+#include <xercesc/framework/psvi/XSValue.hpp>
+#include <xercesc/framework/XMLValidator.hpp>
+
+#include "ResourceManager.h"
+#include "Entity.h"
+#include "ComponentInfo.h"
+class World;
+
+class EntityPreprocessorXMLErrorHandler : public xercesc::DOMErrorHandler
+{
+public:
+	bool handleError(const xercesc::DOMError &e) override
+	{
+		char* message = xercesc::XMLString::transcode(e.getMessage());
+		std::cerr << "Preprocessor DOMError: " << message << std::endl;
+		xercesc::XMLString::release(&message);
+		return false;
+	}
+};
+
+class EntityParserXMLErrorHandler : public xercesc::ErrorHandler
+{
+public:
+	void warning(const xercesc::SAXParseException& e) override
+	{
+		reportParseException("Warning", e);
+	}
+	void error(const xercesc::SAXParseException& e) override
+	{
+		reportParseException("Error", e);
+	}
+	void fatalError(const xercesc::SAXParseException& e) override
+	{
+		reportParseException("FATAL ERROR", e);
+	}
+	void resetErrors() override { }
+
+private:
+	void reportParseException(std::string type, const xercesc::SAXParseException& e)
+	{
+		char* message = xercesc::XMLString::transcode(e.getMessage());
+		char* systemID = xercesc::XMLString::transcode(e.getSystemId());
+		std::cerr << systemID << ":" << e.getLineNumber() << ":" << e.getColumnNumber() << std::endl;
+		std::cerr << type << ": " << message << std::endl;
+		xercesc::XMLString::release(&systemID);
+		xercesc::XMLString::release(&message);
+	}
+};
+
+class XSTR
+{
+public:
+	XSTR(const XMLCh* const xmlString) 
+	{
+		m_AsChar = xercesc::XMLString::transcode(xmlString);
+	}
+
+	XSTR(const char* normalString)
+	{
+		m_AsXMLCh = xercesc::XMLString::transcode(normalString);
+	}
+
+	~XSTR()
+	{
+		if (m_AsChar != nullptr) {
+			xercesc::XMLString::release(&m_AsChar);
+		}
+		if (m_AsXMLCh != nullptr) {
+			xercesc::XMLString::release(&m_AsXMLCh);
+		}
+	}
+
+	operator const char*() const { return m_AsChar; }
+	operator const XMLCh*() const { return m_AsXMLCh; }
+
+private:
+	char* m_AsChar = nullptr;
+	XMLCh* m_AsXMLCh = nullptr;
+};
+
+class EntityXMLFile : public Resource
+{
+	friend class ResourceManager;
+
+private:
+	EntityXMLFile(std::string path);
+
+public:
+    ~EntityXMLFile();
+
+    void PopulateWorld(World* world);
+
+private:
+    static unsigned int InstanceCount;
+
+	std::string m_EntityFile;
+	xercesc::XMLGrammarPool* m_GrammarPool = nullptr;
+	EntityParserXMLErrorHandler* m_ErrorHandler = nullptr;
+	xercesc::XercesDOMParser* m_DOMParser = nullptr;
+	xercesc::DOMDocument* m_DOMDocument = nullptr;
+	std::map<std::string, ComponentInfo> m_ComponentInfo;
+
+    // Preprocesses the entity file to insert include-by-copy child entities
+    // TODO: Make this work in memory instead of saving to file
+    void preprocess(std::string inPath, std::string outPath);
+
+    void parseComponentInfo();
+    void parseDefaults();
+    void predictComponentAllocation();
+    void parseEntityGraph(World* world, xercesc::DOMElement* parent, EntityID parentEntity);
+    std::size_t getTypeStride(std::string typeName);
+    float getFloatAttribute(const xercesc::DOMElement* element, const char* attribute) const;
+    void writeData(const xercesc::DOMElement* element, std::string typeName, char* outData);
+};
+
+#endif

include/Engine/Core/ResourceManager.h

@@ -81,6 +81,8 @@ public:
 	 	@param resourceName Fully qualified name of the resource to reload.
 	*/
     static void Reload(std::string resourceName);
+    
+    static void Release(std::string resourceType, std::string resourceName);
 
 	static void Update();
 

include/Engine/Core/System.h

@@ -0,0 +1,25 @@
+#ifndef System_h__
+#define System_h__
+
+#include "EventBroker.h"
+#include "World.h"
+#include "ComponentWrapper.h"
+
+class System
+{
+    friend class SystemPipeline;
+
+public:
+    System(const EventBroker* eventBroker, std::string componentType)
+        : m_EventBroker(eventBroker)
+        , m_ComponentType(componentType)
+    { }
+
+    virtual void Update(World* world, ComponentWrapper& component, double dt) = 0;
+
+private:
+    const EventBroker* m_EventBroker;
+    std::string m_ComponentType;
+};
+
+#endif

include/Engine/Core/SystemPipeline.h

@@ -0,0 +1,58 @@
+#ifndef SystemPipeline_h__
+#define SystemPipeline_h__
+
+#include "../Common.h"
+#include "EventBroker.h"
+#include "System.h"
+#include "World.h"
+
+class SystemPipeline
+{
+public:
+    SystemPipeline(const EventBroker* eventBroker)
+        : m_EventBroker(eventBroker)
+    { }
+    ~SystemPipeline()
+    {
+        for (auto& pair : m_Systems) {
+            for (auto& system : pair.second) {
+                delete system;
+            }
+        }
+    }
+
+    template <typename T, typename... Arguments>
+    void AddSystem(Arguments... args)
+    {
+        System* system = new T(m_EventBroker, args...);
+        if (!system->m_ComponentType.empty()) {
+            m_Systems[system->m_ComponentType].push_back(system);
+        } else {
+            LOG_ERROR("Failed to add system \"%s\": Missing component type!", typeid(T).name());
+            delete system;
+        }
+    }
+
+    void Update(World* world, double dt)
+    {
+        for (auto& pair : m_Systems) {
+            const std::string& componentName = pair.first;
+            auto& systems = pair.second;
+            const ComponentPool* pool = world->GetComponents(componentName);
+            if (pool == nullptr) {
+                continue;
+            }
+            for (auto& component : *pool) {
+                for (auto& system : systems) {
+                    system->Update(world, component, dt);
+                }
+            }
+        }
+    }
+
+private:
+    const EventBroker* m_EventBroker;
+    std::unordered_map<std::string, std::vector<System*>> m_Systems;
+};
+
+#endif

include/Engine/Core/World.h

@@ -2,7 +2,7 @@
 #define World_h__
 
 #include "../Common.h"
-#include "EntityWrapper.h"
+#include "Entity.h"
 #include "ObjectPool.h"
 #include "ComponentPool.h"
 
@@ -12,6 +12,7 @@ public:
     World() = default;
     ~World();
 
+    // Create empty entity
     EntityID CreateEntity(EntityID parent = 0);
 
     // Register a component type and allocate space for it
@@ -21,10 +22,12 @@ public:
     // Get a component of an entity
     ComponentWrapper GetComponent(EntityID entity, std::string componentType);
     // Get all components of the specified type
-    const ComponentPool& GetComponents(std::string componentType);
+    const ComponentPool* GetComponents(std::string componentType);
+    // Get entity parent
+    EntityID GetParent(EntityID entity);
 
 private:
-    EntityID m_CurrentEntityID = 0;
+    EntityID m_CurrentEntityID = 1;
 
     std::unordered_map<EntityID, EntityID> m_EntityParents;
     std::unordered_multimap<EntityID, EntityID> m_EntityChildren;

include/Engine/Input/EBindOrigin.h

@@ -0,0 +1,22 @@
+#ifndef Events_BindOrigin_h__
+#define Events_BindOrigin_h__
+
+#include "Core/EventBroker.h"
+
+namespace Events
+{
+
+/** Called to bind an input origin to an input command. */
+struct BindOrigin : Event
+{
+	/** The input origin to bind. */
+	std::string Origin;
+	/** The command to send. */
+	std::string Command;
+	/** The value to send for positive stimulation. */
+	float Value = 1.f;
+};
+
+}
+
+#endif

include/Engine/Input/EInputCommand.h

@@ -13,7 +13,7 @@ struct InputCommand : Event
 	/** The command that was sent. */
 	std::string Command;
 	/** The value of the command. */
-	float Value;
+	float Value = 0;
 };
 
 }

include/Engine/Input/InputProxy.h

@@ -0,0 +1,146 @@
+#ifndef InputSystem_h__
+#define InputSystem_h__
+
+#include <array>
+#include <unordered_map>
+
+#include <steam/steam_api.h>
+
+#include "Core/EKeyUp.h"
+#include "Core/EKeyDown.h"
+#include "Core/EMousePress.h"
+#include "Core/EMouseRelease.h"
+#include "Core/EGamepadAxis.h"
+#include "Core/EGamepadButton.h"
+#include "Core/Util/EnumClassHash.h"
+#include "EBindKey.h"
+#include "EBindMouseButton.h"
+#include "EBindGamepadAxis.h"
+#include "EBindGamepadButton.h"
+#include "EInputCommand.h"
+#include "EBindOrigin.h"
+
+class InputProxy;
+
+class InputHandler
+{
+public:
+    InputHandler(EventBroker* eventBroker, InputProxy* inputProxy)
+        : m_EventBroker(eventBroker)
+        , m_InputProxy(inputProxy)
+    { }
+
+    virtual void Update(double dt) { }
+    virtual bool BindOrigin(std::string origin, std::string command, float value) = 0;
+
+protected:
+    EventBroker* m_EventBroker;
+    InputProxy* m_InputProxy;
+};
+
+class InputProxy
+{
+public:
+    InputProxy(EventBroker* eventBroker)
+        : m_EventBroker(eventBroker)
+    {
+        EVENT_SUBSCRIBE_MEMBER(m_EBindOrigin, &InputProxy::OnBindOrigin);
+    }
+
+	void Update(double dt)
+    {
+        m_EventBroker->Process<InputProxy>();
+        m_EventBroker->Process<InputHandler>();
+        for (auto& handler : m_Handlers) {
+            handler->Update(dt);
+        }
+    }
+
+    void Process()
+    {
+        // Accumulate the input values of all unique commands published by input handlers
+        for (auto& pair : m_CommandQueue) {
+            Events::InputCommand e;
+            e.PlayerID = pair.first.first;
+            e.Command = pair.first.second;
+            e.Value = 0;
+            for (auto& value : pair.second) {
+                e.Value += value;
+            }
+	        e.Value = std::max(-1.f, std::min(e.Value, 1.f));
+            m_EventBroker->Publish(e);
+            LOG_DEBUG("Input: Published command %s=%f for player %i", e.Command.c_str(), e.Value, e.PlayerID);
+        }
+        m_CommandQueue.clear();
+    }
+
+    template <typename T>
+    void AddHandler()
+    {
+        m_Handlers.push_back(new T(m_EventBroker, this));
+    }
+
+    void Publish(const Events::InputCommand& e)
+    {
+        auto key = std::make_pair(e.PlayerID, e.Command);
+        m_CommandQueue[key].push_back(e.Value);
+    }
+
+protected:
+    EventBroker* m_EventBroker;
+    std::vector<InputHandler*> m_Handlers;
+    // Represents every unique command (has of PlayerID & Command) and all values reported for that command
+    std::map<std::pair<unsigned int, std::string>, std::vector<float>> m_CommandQueue;
+
+	EventRelay<InputProxy, Events::BindOrigin> m_EBindOrigin;
+	bool OnBindOrigin(const Events::BindOrigin& e)
+    {
+        bool originBound = false;
+        for (auto& handler : m_Handlers) {
+            bool result = handler->BindOrigin(e.Origin, e.Command, e.Value);
+            if (result) {
+                if (originBound) {
+                    LOG_WARNING("Multiple handlers responded to binding input origin \"%s\"!", e.Origin.c_str());
+                }
+                originBound = true;
+            }
+        }
+
+        if (!originBound) {
+            LOG_ERROR("No input handler responded to binding input origin \"%s\"!", e.Origin.c_str());
+        }
+
+        return originBound;
+    }
+	//std::unordered_map<std::string, std::unordered_map<int, float>> m_CommandMouseButtonValues; // command string -> mouse button value for command
+	//std::unordered_map<std::string, std::unordered_map<Gamepad::Axis, float, EnumClassHash>> m_CommandGamepadAxisValues; // command string -> gamepad axis value for command
+	//std::unordered_map<std::string, std::unordered_map<Gamepad::Button, float, EnumClassHash>> m_CommandGamepadButtonValues; // command string -> gamepad button value for command
+	//// Input binding tables
+	//std::unordered_multimap<int, std::tuple<std::string, float>> m_MouseButtonBindings; // GLFW_MOUSE_BUTTON... -> command string
+	//std::unordered_multimap<Gamepad::Axis, std::tuple<std::string, float>, EnumClassHash> m_GamepadAxisBindings; // Gamepad::Axis -> command string & value
+	//std::unordered_multimap<Gamepad::Button, std::tuple<std::string, float>, EnumClassHash> m_GamepadButtonBindings; // Gamepad::Button -> command string
+
+	//// Input events
+	//EventRelay<InputProxy, Events::MousePress> m_EMousePress;
+	//bool OnMousePress(const Events::MousePress &event);
+	//EventRelay<InputProxy, Events::MouseRelease> m_EMouseRelease;
+	//bool OnMouseRelease(const Events::MouseRelease &event);
+	//EventRelay<InputProxy, Events::GamepadAxis> m_EGamepadAxis;
+	//bool OnGamepadAxis(const Events::GamepadAxis &event);
+	//EventRelay<InputProxy, Events::GamepadButtonDown> m_EGamepadButtonDown;
+	//bool OnGamepadButtonDown(const Events::GamepadButtonDown &event);
+	//EventRelay<InputProxy, Events::GamepadButtonUp> m_EGamepadButtonUp;
+	//bool OnGamepadButtonUp(const Events::GamepadButtonUp &event);
+	//// Input binding events
+	//EventRelay<InputProxy, Events::BindMouseButton> m_EBindMouseButton;
+	//bool OnBindMouseButton(const Events::BindMouseButton &event);
+	//EventRelay<InputProxy, Events::BindGamepadAxis> m_EBindGamepadAxis;
+	//bool OnBindGamepadAxis(const Events::BindGamepadAxis &event);
+	//EventRelay<InputProxy, Events::BindGamepadButton> m_EBindGamepadButton;
+	//bool OnBindGamepadButton(const Events::BindGamepadButton &event);
+
+	//float GetCommandTotalValue(std::string command);
+	//void PublishCommand(int playerID, std::string command, float value);
+};
+
+#endif

include/Engine/Input/InputSystem.h

@@ -1,78 +0,0 @@
-#ifndef InputSystem_h__
-#define InputSystem_h__
-
-#include <array>
-#include <unordered_map>
-
-#include "Core/System.h"
-#include "Core/EKeyUp.h"
-#include "Core/EKeyDown.h"
-#include "Core/EMousePress.h"
-#include "Core/EMouseRelease.h"
-#include "Core/EGamepadAxis.h"
-#include "Core/EGamepadButton.h"
-#include "Core/Util/EnumClassHash.h"
-#include "EBindKey.h"
-#include "EBindMouseButton.h"
-#include "EBindGamepadAxis.h"
-#include "EBindGamepadButton.h"
-#include "EInputCommand.h"
-
-namespace Systems
-{
-
-class InputSystem : public System
-{
-public:
-	InputSystem(World* world, std::shared_ptr<dd::EventBroker> eventBroker)
-		: System(world, eventBroker)
-	{ }
-
-	void RegisterComponents(ComponentFactory* cf) override;
-	void Initialize() override;
-
-	void Update(double dt) override;
-
-private:
-	std::unordered_map<std::string, std::unordered_map<int, float>> m_CommandKeyboardValues; // command string -> keyboard key value for command
-	std::unordered_map<std::string, std::unordered_map<int, float>> m_CommandMouseButtonValues; // command string -> mouse button value for command
-	std::unordered_map<std::string, std::unordered_map<Gamepad::Axis, float, EnumClassHash>> m_CommandGamepadAxisValues; // command string -> gamepad axis value for command
-	std::unordered_map<std::string, std::unordered_map<Gamepad::Button, float, EnumClassHash>> m_CommandGamepadButtonValues; // command string -> gamepad button value for command
-	// Input binding tables
-	std::unordered_multimap<int, std::tuple<std::string, float>> m_KeyBindings; // GLFW_KEY... -> command string & value
-	std::unordered_multimap<int, std::tuple<std::string, float>> m_MouseButtonBindings; // GLFW_MOUSE_BUTTON... -> command string
-	std::unordered_multimap<Gamepad::Axis, std::tuple<std::string, float>, EnumClassHash> m_GamepadAxisBindings; // Gamepad::Axis -> command string & value
-	std::unordered_multimap<Gamepad::Button, std::tuple<std::string, float>, EnumClassHash> m_GamepadButtonBindings; // Gamepad::Button -> command string
-
-	// Input events
-	EventRelay<InputSystem, Events::KeyDown> m_EKeyDown;
-	bool OnKeyDown(const Events::KeyDown &event);
-	EventRelay<InputSystem, Events::KeyUp> m_EKeyUp;
-	bool OnKeyUp(const Events::KeyUp &event);
-	EventRelay<InputSystem, Events::MousePress> m_EMousePress;
-	bool OnMousePress(const Events::MousePress &event);
-	EventRelay<InputSystem, Events::MouseRelease> m_EMouseRelease;
-	bool OnMouseRelease(const Events::MouseRelease &event);
-	EventRelay<InputSystem, Events::GamepadAxis> m_EGamepadAxis;
-	bool OnGamepadAxis(const Events::GamepadAxis &event);
-	EventRelay<InputSystem, Events::GamepadButtonDown> m_EGamepadButtonDown;
-	bool OnGamepadButtonDown(const Events::GamepadButtonDown &event);
-	EventRelay<InputSystem, Events::GamepadButtonUp> m_EGamepadButtonUp;
-	bool OnGamepadButtonUp(const Events::GamepadButtonUp &event);
-	// Input binding events
-	EventRelay<InputSystem, Events::BindKey> m_EBindKey;
-	bool OnBindKey(const Events::BindKey &event);
-	EventRelay<InputSystem, Events::BindMouseButton> m_EBindMouseButton;
-	bool OnBindMouseButton(const Events::BindMouseButton &event);
-	EventRelay<InputSystem, Events::BindGamepadAxis> m_EBindGamepadAxis;
-	bool OnBindGamepadAxis(const Events::BindGamepadAxis &event);
-	EventRelay<InputSystem, Events::BindGamepadButton> m_EBindGamepadButton;
-	bool OnBindGamepadButton(const Events::BindGamepadButton &event);
-
-	float GetCommandTotalValue(std::string command);
-	void PublishCommand(int playerID, std::string command, float value);
-};
-
-}
-
-#endif

include/Engine/Input/KeyboardInputHandler.h

@@ -0,0 +1,67 @@
+#include <GLFW/glfw3.h>
+#include "InputProxy.h"
+#include "Core/EKeyDown.h"
+#include "Core/EKeyUp.h"
+
+class KeyboardInputHandler : public InputHandler
+{
+public:
+    KeyboardInputHandler(EventBroker* eventBroker, InputProxy* inputProxy)
+        : InputHandler(eventBroker, inputProxy)
+    {
+        EVENT_SUBSCRIBE_MEMBER(m_EKeyDown, &KeyboardInputHandler::OnKeyDown);
+        EVENT_SUBSCRIBE_MEMBER(m_EKeyUp, &KeyboardInputHandler::OnKeyUp);
+
+        m_OriginKeyCodes["R"] = GLFW_KEY_R;
+    }
+
+    bool BindOrigin(std::string origin, std::string command, float value) override
+    {
+        auto originIt = m_OriginKeyCodes.find(origin);
+        if (originIt == m_OriginKeyCodes.end()) {
+            return false;
+        }
+
+        int keyCode = originIt->second;
+        m_KeyBindings[keyCode] = std::make_tuple(command, value);
+        return true;
+    }
+
+private:
+    std::unordered_map<std::string, int> m_OriginKeyCodes;
+	std::unordered_map<int, std::tuple<std::string, float>> m_KeyBindings; // GLFW_KEY... -> command string & value
+
+	EventRelay<InputHandler, Events::KeyDown> m_EKeyDown;
+    bool OnKeyDown(const Events::KeyDown& e)
+    {
+        auto it = m_KeyBindings.find(e.KeyCode);
+        if (it == m_KeyBindings.end()) {
+            return false;
+        }
+
+        Events::InputCommand ic;
+        ic.PlayerID = 0;
+        std::tie(ic.Command, ic.Value) = it->second;
+        m_InputProxy->Publish(ic);
+
+        return true;
+    }
+
+	EventRelay<InputHandler, Events::KeyUp> m_EKeyUp;
+	bool OnKeyUp(const Events::KeyUp& e)
+    {
+        auto it = m_KeyBindings.find(e.KeyCode);
+        if (it == m_KeyBindings.end()) {
+            return false;
+        }
+
+        Events::InputCommand ic;
+        ic.PlayerID = 0;
+        std::tie(ic.Command, std::ignore) = it->second;
+        ic.Value = 0;
+        m_InputProxy->Publish(ic);
+
+        return true;
+    }
+
+};

include/Engine/Input/SteamControllerInputHandler.h

@@ -0,0 +1,98 @@
+#include <steam/steam_api.h>
+#include "InputProxy.h"
+
+class SteamControllerInputHandler : public InputHandler
+{
+public:
+    SteamControllerInputHandler(EventBroker* eventBroker, InputProxy* inputProxy)
+        : InputHandler(eventBroker, inputProxy)
+    {
+        SteamController()->Init();
+    }
+
+    ~SteamControllerInputHandler()
+    {
+        SteamController()->Shutdown();
+    }
+
+    void Update(double dt) override
+    {
+        std::array<ControllerHandle_t, STEAM_CONTROLLER_MAX_COUNT> controllers;
+        int numControllers = SteamController()->GetConnectedControllers(controllers.data());
+        for (int i = 0; i < numControllers; i++) {
+            auto controllerHandle = controllers.at(i);
+            auto actionSetHandle = SteamController()->GetActionSetHandle("InGameControls");
+            //SteamController()->ShowBindingPanel(controllerHandle);
+            SteamController()->ActivateActionSet(controllerHandle, actionSetHandle);
+            for (auto& command : m_Commands) {
+                Events::InputCommand ic;
+                ic.PlayerID = i + 1;
+                ic.Command = command.first;
+
+                auto digitalActionHandle = m_DigitalActionHandles.at(ic.Command);
+                auto handle = SteamController()->GetDigitalActionHandle("DebugReload");
+                auto data = SteamController()->GetDigitalActionData(controllerHandle, handle);
+                LOG_DEBUG("Controller %i, active %i, value %i", i, data.bActive, data.bState);
+                if (data.bState) {
+                    ic.Value = command.second;
+                } else {
+                    ic.Value = 0.f;
+                }
+                //m_InputProxy->Publish(ic);
+            }
+        }
+        
+    }
+
+    bool BindOrigin(std::string origin, std::string command, float value) override
+    {
+        if (origin != "SteamController") {
+            return false;
+        }
+
+        m_Commands[command] = value;
+        m_DigitalActionHandles[command] = SteamController()->GetDigitalActionHandle(command.c_str());
+        return true;
+    }
+
+private:
+    std::map<std::string, float> m_Commands;
+    std::map<std::string, ControllerDigitalActionHandle_t> m_DigitalActionHandles;
+
+	//std::unordered_map<std::string, std::unordered_map<int, float>> m_CommandKeyboardValues; // command string -> keyboard key value for command
+	std::unordered_map<int, std::tuple<std::string, float>> m_KeyBindings; // GLFW_KEY... -> command string & value
+
+	EventRelay<InputHandler, Events::KeyDown> m_EKeyDown;
+    bool OnKeyDown(const Events::KeyDown& e)
+    {
+        auto it = m_KeyBindings.find(e.KeyCode);
+        if (it == m_KeyBindings.end()) {
+            return false;
+        }
+
+        Events::InputCommand ic;
+        ic.PlayerID = 0;
+        std::tie(ic.Command, ic.Value) = it->second;
+        m_InputProxy->Publish(ic);
+
+        return true;
+    }
+
+	EventRelay<InputHandler, Events::KeyUp> m_EKeyUp;
+	bool OnKeyUp(const Events::KeyUp& e)
+    {
+        auto it = m_KeyBindings.find(e.KeyCode);
+        if (it == m_KeyBindings.end()) {
+            return false;
+        }
+
+        Events::InputCommand ic;
+        ic.PlayerID = 0;
+        std::tie(ic.Command, std::ignore) = it->second;
+        ic.Value = 0;
+        m_InputProxy->Publish(ic);
+
+        return true;
+    }
+
+};

include/Engine/Rendering/EPicking.h

@@ -0,0 +1,69 @@
+#ifndef Events_Picking_h__
+#define Events_Picking_h__
+
+#include "../OpenGL.h"
+#include "../GLM.h"
+
+#include "../Core/EventBroker.h"
+#include "Util/ScreenCoords.h"
+#include "FrameBuffer.h"
+#include "../Core/Entity.h"
+#include "Util/UnorderedMapVec2.h"
+
+namespace Events
+{
+
+/** Thrown Every frame, use functions to pick*/
+struct Picking : Event
+{
+public:
+    Picking(FrameBuffer* pickingBuffer, GLuint* depthBuffer, glm::mat4 projectionMatrix, glm::mat4 viewMatrix, Rectangle resolution, const std::unordered_map<glm::vec2, EntityID>* pickingColorsToEntity)
+        : PickingBuffer(pickingBuffer)
+        , DepthBuffer(depthBuffer)
+        , ProjectionMatrix(projectionMatrix)
+        , ViewMatrix(viewMatrix)
+        , Resolution(resolution)
+        , PickingColorsToEntity(pickingColorsToEntity)
+    { }
+        
+    
+
+    struct PickData
+    {
+        //Picked Entity
+        EntityID Entity;
+        //World position of the "pick"
+        glm::vec3 Position;
+    };
+
+    PickData Pick(glm::vec2 screenCoord) const
+    {
+        PickData pickData;
+
+        ScreenCoords::PixelData data = ScreenCoords::ToPixelData(screenCoord, PickingBuffer, *DepthBuffer);
+
+        auto it = PickingColorsToEntity->find(glm::vec2(data.Color[0], data.Color[1]));
+        if (it != PickingColorsToEntity->end()) {
+            pickData.Entity = it->second;
+        } else {
+            pickData.Entity = -1;
+        }
+        pickData.Position = ScreenCoords::ToWorldPos(screenCoord.x, Resolution.Width - screenCoord.y, data.Depth, Resolution, ProjectionMatrix, ViewMatrix);
+
+        return pickData;
+    }
+
+
+private:
+    FrameBuffer* PickingBuffer;
+    GLuint* DepthBuffer;
+    const glm::mat4 ProjectionMatrix;
+    const glm::mat4 ViewMatrix;
+    const Rectangle Resolution;
+    const std::unordered_map<glm::vec2, EntityID>* PickingColorsToEntity;
+    
+};
+
+}
+
+#endif

include/Engine/Rendering/RenderQueue.h

@@ -7,7 +7,7 @@
 #include "../Common.h"
 #include "../GLM.h"
 #include "../Core/Util/Rectangle.h"
-#include "../Core/EntityWrapper.h"
+#include "../Core/Entity.h"
 
 class Model;
 class Skeleton;

include/Engine/Rendering/RenderQueueFactory.h

@@ -22,7 +22,10 @@ private:
     void FillLights(World* world, RenderQueue* renderQueue);
 
     glm::mat4 ModelMatrix(World* world, EntityID entity);
-    glm::vec3 GetAbsolutePosition(World* world, ComponentWrapper transformComponent);
+
+    glm::vec3 AbsolutePosition(World* world, EntityID entity);
+    glm::quat AbsoluteOrientation(World* world, EntityID entity);
+    glm::vec3 AbsoluteScale(World* world, EntityID entity);
 };
 
 #endif

include/Engine/Rendering/Renderer.h

@@ -11,15 +11,24 @@
 #include "FrameBuffer.h"
 #include "../Core/World.h"
 
+#include "../Core/EventBroker.h"
+#include "EPicking.h"
+
 class Renderer : public IRenderer
 {
 public:
+    Renderer(EventBroker* eventBroker) 
+        : m_EventBroker(eventBroker)
+    { }
+
 	virtual void Initialize() override;
 	virtual void Update(double dt) override;
 	virtual void Draw(RenderQueueCollection& rq) override;
 
 private:
 	//----------------------Variables----------------------//
+    EventBroker* m_EventBroker;
+
 	Texture* m_ErrorTexture;
 	Texture* m_WhiteTexture;
 	float m_CameraMoveSpeed;
@@ -31,8 +40,6 @@ private:
     Model* m_UnitQuad;
     Model* m_UnitSphere;
 
-
-    
     std::unordered_map<glm::vec2, EntityID> m_PickingColorsToEntity;
 
 	//----------------------Functions----------------------//

include/Engine/Rendering/Util/ScreenCoords.h

@@ -11,6 +11,13 @@ class ScreenCoords
 {
 public: 
     ScreenCoords() = delete;
+
+    struct PixelData
+    {
+        int Color[2];
+        float Depth;
+    };
+
     //Return world position from given screenspace coordinates and depth value in viewspace.
     static glm::vec3 ToWorldPos(glm::vec2 screenCoord, float depth, Rectangle resolution, glm::mat4 cameraProjectionMat, glm::mat4 cameraViewMat);
     static glm::vec3 ToWorldPos(float x, float y, float depth, Rectangle resolution, glm::mat4 cameraProjectionMat, glm::mat4 cameraViewMat);
@@ -18,8 +25,8 @@ public:
     static glm::vec3 ToWorldPos(float x, float y, float depth, float screenWidth, float screenHeight, glm::mat4 cameraProjectionMat, glm::mat4 cameraViewMat);
     //Return data from the given buffers at the coordinates given in screenspace. Buffer should probably have a texture that covers the screen.
     //Data is given as R = x, B = y, and 
-    static glm::vec3 ToPixelData(glm::vec2 screenCoord, FrameBuffer* PickDataBuffer, GLuint DepthBuffer);
-    static glm::vec3 ToPixelData(float x, float y, FrameBuffer* PickDataBuffer, GLuint DepthBuffer);
+    static PixelData ToPixelData(glm::vec2 screenCoord, FrameBuffer* PickDataBuffer, GLuint DepthBuffer);
+    static PixelData ToPixelData(float x, float y, FrameBuffer* PickDataBuffer, GLuint DepthBuffer);
     //Return EntityID of the clicked coordinate in given screenspace coordinates.
     //EntityID ScreenCoordsToEntityID(glm::vec2 screenCoord, float depth);
 

include/Game/Game.h

@@ -9,6 +9,13 @@
 #include "GUI/Frame.h"
 #include "Core/World.h"
 #include "Rendering/RenderQueueFactory.h"
+#include "Input/InputProxy.h"
+#include "Input/KeyboardInputHandler.h"
+#include "Input/SteamControllerInputHandler.h"
+#include "Core/EKeyDown.h"
+#include "Core/EntityXMLFile.h"
+#include "Core/SystemPipeline.h"
+#include "RaptorCopterSystem.h"
 
 class Game
 {
@@ -25,9 +32,17 @@ private:
 	EventBroker* m_EventBroker;
 	IRenderer* m_Renderer;
 	InputManager* m_InputManager;
+    InputProxy* m_InputProxy;
 	GUI::Frame* m_FrameStack;
     World* m_World;
+    SystemPipeline* m_SystemPipeline;
     RenderQueueFactory* m_RenderQueueFactory;
+
+    EventRelay<Game, Events::KeyUp> m_EKeyUp;
+    bool testOnKeyUp(const Events::KeyUp& e);
+
+    void testIntialize();
+    void testTick(double dt);
 };
 
 #endif

include/Game/HardcodedTestWorld.h

@@ -1,110 +0,0 @@
-#include <list>
-#include <tuple>
-#include <boost/any.hpp>
-#include "GLM.h"
-#include "Core/World.h"
-#include "Core/Util/Any.h"
-
-class HardcodedTestWorld : public World
-{
-public:
-    HardcodedTestWorld()
-        : World()
-    {
-        registerTestComponents();
-        createTestEntities();
-    }
-
-private:
-    void registerTestComponents()
-    {
-        ComponentWrapperFactory f;
-            
-
-        f = ComponentWrapperFactory("Test");
-        f.AddProperty("TestInteger", 1337);
-        f.AddProperty("TestFloat", 13.37f);
-        f.AddProperty("TestString", std::string("Carlito"));
-        RegisterComponent(f);
-
-        f = ComponentWrapperFactory("Debug");
-        f.AddProperty("Name", std::string("Unnamed"));
-        RegisterComponent(f);
-
-        f = ComponentWrapperFactory("Transform");
-        f.AddProperty("Position", glm::vec3(0.f, 0.f, 0.f));
-        f.AddProperty("Orientation", glm::quat());
-        f.AddProperty("Scale", glm::vec3(1.f, 1.f, 1.f));
-        RegisterComponent(f);
-
-        f = ComponentWrapperFactory("Model");
-        f.AddProperty("Resource", std::string());
-        f.AddProperty("Color", glm::vec4(1.f, 1.f, 1.f, 1.f));
-        f.AddProperty("Visible", true);
-        RegisterComponent(f);
-    }
-
-    void createTestEntities()
-    {
-        World& world = *this;
-
-        // Create an entity
-        EntityID e = world.CreateEntity();
-
-        // Attach a Debug component
-        ComponentWrapper debug = world.AttachComponent(e, "Debug");
-        // Set the Name field of the Debug component using subscript operator
-        debug["Name"] = "Carlito";
-
-        // Attach a Transform component
-        world.AttachComponent(e, "Transform");
-        // Fetch the component based on EntityID and component type
-        ComponentWrapper transform = world.GetComponent(e, "Transform");
-        // Set the fields of the Transform component
-        transform["Position"] = glm::vec3(0.f, 0.f, 0.f);
-        transform["Scale"] = glm::vec3(1.f, 1.f, 1.f);
-
-        // Move on the X axis by fetching field as reference
-        ((glm::vec3&)transform["Position"]).x += 10.f;
-        // Shrink by a factor of 100
-        ((glm::vec3&)transform["Scale"]) /= 100.f;
-
-        // Loop through all Transform components and print them
-        for (auto& transform : world.GetComponents("Transform")) {
-            glm::vec3 pos = transform["Position"];
-            std::cout << "Position: " << pos.x << " " << pos.y << " " << pos.z << std::endl;
-            glm::vec3 scale = transform["Scale"];
-            std::cout << "Scale: " << scale.x << " " << scale.y << " " << scale.z << std::endl;
-
-            // Fetch the Debug component also present in this entity
-            ComponentWrapper debug = world.GetComponent(transform.EntityID, "Debug");
-            std::cout << "Name: " << (std::string)debug["Name"] << std::endl;
-        }
-        
-        //Create some test widgets
-        {
-            EntityID entityScaleWidget = world.CreateEntity();
-            ComponentWrapper transform = world.AttachComponent(entityScaleWidget, "Transform");
-            transform["Position"] = glm::vec3(-1.5f, 0.f, 0.f);
-            ComponentWrapper model = world.AttachComponent(entityScaleWidget, "Model");
-            model["Resource"] = "Models/ScaleWidget.obj";
-        }
-        {
-            EntityID entityRotationWidget = world.CreateEntity();
-            ComponentWrapper transform = world.AttachComponent(entityRotationWidget, "Transform");
-            transform["Position"] = glm::vec3(1.5f, 0.f, 0.f);
-            ComponentWrapper model = world.AttachComponent(entityRotationWidget, "Model");
-            model["Resource"] = "Models/RotationWidget.obj";
-        }
-        {
-            EntityID entityDummyScene = world.CreateEntity();
-            ComponentWrapper transform = world.AttachComponent(entityDummyScene, "Transform");
-            transform["Position"] = glm::vec3(0, 0.f, 0.f);
-            ComponentWrapper model = world.AttachComponent(entityDummyScene, "Model");
-            model["Resource"] = "Models/DummyScene.obj";
-        }
-
-
-
-    }
-};

include/Game/RaptorCopterSystem.h

@@ -0,0 +1,16 @@
+#include "Common.h"
+#include "Core/System.h"
+
+class RaptorCopterSystem : public System
+{
+public:
+    RaptorCopterSystem(const EventBroker* eventBroker)
+        : System(eventBroker, "RaptorCopter")
+    { }
+
+    virtual void Update(World* world, ComponentWrapper& raptorCopter, double dt) override
+    {
+        ComponentWrapper& transform = world->GetComponent(raptorCopter.EntityID, "Transform");
+        (glm::vec3&)transform["Orientation"] += (float)(double)raptorCopter["Speed"] * (float)dt * (glm::vec3)raptorCopter["Axis"];
+    }
+};

resources/DefaultConfig.ini

@@ -1,5 +1,6 @@
 [Debug]
 LogLevel=1
+LoadMap=
 
 [Video]
 Fullscreen=false

resources/Schema/Components.xsd

@@ -2,5 +2,7 @@
 
 <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="components" elementFormDefault="qualified">
 	<xs:include schemaLocation="Components/Transform.xsd"/>
+	<xs:include schemaLocation="Components/Model.xsd"/>
 	<xs:include schemaLocation="Components/Test.xsd"/>
+	<xs:include schemaLocation="Components/RaptorCopter.xsd"/>
 </xs:schema>

resources/Schema/Components/Model.xml

@@ -0,0 +1,5 @@
+<c:Model>
+	<Resource></Resource>
+	<Color R="1" G="1" B="1" A="1"/>
+	<Visible>true</Visible>
+</c:Model>

resources/Schema/Components/Model.xsd

@@ -0,0 +1,24 @@
+<?xml version="1.0"?>
+
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:t="types">
+	<xs:import schemaLocation="../Types.xsd" namespace="types"/>
+
+	<xs:element name="Model">
+		<xs:annotation>
+			<xs:documentation>A visible model loaded from disk</xs:documentation>
+		</xs:annotation>
+		<xs:complexType>
+			<xs:all>
+				<xs:element name="Resource" type="t:string" minOccurs="0">
+					<xs:annotation><xs:documentation>Model file</xs:documentation></xs:annotation>
+				</xs:element>
+				<xs:element name="Color" type="t:Color" minOccurs="0">
+					<xs:annotation><xs:documentation>Color tint</xs:documentation></xs:annotation>
+				</xs:element>
+				<xs:element name="Visible" type="t:bool" minOccurs="0">
+					<xs:annotation><xs:documentation>Wether the model is visible or not</xs:documentation></xs:annotation>
+				</xs:element>
+			</xs:all>
+		</xs:complexType>
+	</xs:element>
+</xs:schema>

resources/Schema/Components/RaptorCopter.xml

@@ -0,0 +1,4 @@
+<c:RaptorCopter>
+	<Speed>0</Speed>
+	<Axis X="0" Y="0" Z="0"/>
+</c:RaptorCopter>

resources/Schema/Components/RaptorCopter.xsd

@@ -0,0 +1,14 @@
+<?xml version="1.0"?>
+
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:t="types">
+	<xs:import schemaLocation="../Types.xsd" namespace="types"/>
+
+	<xs:element name="RaptorCopter">
+		<xs:complexType>
+			<xs:all>
+				<xs:element name="Speed" type="t:double" minOccurs="0"/>
+				<xs:element name="Axis" type="t:Vector" minOccurs="0"/>
+			</xs:all>
+		</xs:complexType>
+	</xs:element>
+</xs:schema>

resources/Schema/Components/Test.xml

@@ -2,5 +2,5 @@
 	<Integer>1</Integer>
 	<Float>1.333</Float>
 	<Vector X="1.33333" Y="2.33333" Z="3.33333"/>
-	<Quaternion I="1.33333" J="2.33333" K="3.33333"/>
+	<Quaternion X="1.33333" Y="2.33333" Z="3.33333" W="4.44444"/>
 </c:Test>

resources/Schema/Components/Transform.xml

@@ -1,5 +1,5 @@
-<TransformComponent>
+<c:Transform>
 	<Position X="0" Y="0" Z="0"/>
-	<Orientation I="0" J="0" K="0"/>
+	<Orientation X="0" Y="0" Z="0" W="0"/>
 	<Scale X="1" Y="1" Z="1"/>
-</TransformComponent>
+</c:Transform>

resources/Schema/Components/Transform.xsd

@@ -12,7 +12,7 @@
 				<xs:element name="Position" type="t:Vector" minOccurs="0">
 					<xs:annotation><xs:documentation>The position vector</xs:documentation></xs:annotation>
 				</xs:element>
-				<xs:element name="Orientation" type="t:Quaternion" minOccurs="0"/>
+				<xs:element name="Orientation" type="t:Vector" minOccurs="0"/>
 				<xs:element name="Scale" type="t:Vector" minOccurs="0"/>
 			</xs:all>
 		</xs:complexType>

resources/Schema/Entities/Test.xml

@@ -3,18 +3,114 @@
 <Entity xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xi="http://www.w3.org/2001/XInclude" xsi:noNamespaceSchemaLocation="../Types/Entity.xsd" xmlns:c="components">
 	<Components>
 		<c:Transform>
-			<Position X="1.02" Y="3.123123" Z="41.123"/>
-			<Orientation I="1.234" J="1.234" K="1.234"/>
-			<Scale X="1.02" Y="3.123123" Z="41.123"/>
+			<Orientation X="0" Y="0" Z="0"/>
 		</c:Transform>
-		<c:Test>
-			<Integer>12</Integer>
-			<Double>11.11</Double>
-			<String>Hello World</String>
-		</c:Test>
+		<c:Model>
+			<Resource>Models/DummyScene.obj</Resource>
+		</c:Model>
 	</Components>
 	<Children>
-		<xi:include href="OtherEntity.xml"/>
-		<xi:include href="OtherEntity.xml"/>
+		<Entity>
+			<Components>
+				<c:Transform>
+					<Position X="-1.5"/>
+					<Scale X="1" Y="1" Z="1"/>
+				</c:Transform>
+				<c:Model>
+					<Resource>Models/ScaleWidget.obj</Resource>
+				</c:Model>
+			</Components>
+		</Entity>
+		<Entity>
+			<Components>
+				<c:Transform>
+					<Position X="1.5"/>
+				</c:Transform>
+				<c:Model>
+					<Resource>Models/RotationWidget.obj</Resource>
+				</c:Model>
+			</Components>
+		</Entity>
+		<Entity>
+			<Components>
+				<c:Transform>
+					<Position X="0" Y="-0"/>
+					<Scale X="1" Y="1" Z="1"/>
+				</c:Transform>
+				<!--<c:Move>
+					<Speed>1</Speed>
+					<Direction X="-1"/>
+					<Rotation Y="3.14"/>
+				</c:Move>-->
+			</Components>
+			<Children>
+				<Entity>
+					<Components>
+						<c:Transform>
+							<Position X="0" Y="0"/>
+							<Orientation X="0.0" Y="0" Z="0.0"/>
+						</c:Transform>
+						<c:Model>
+							<Resource>Models/Core/UnitRaptor.obj</Resource>
+							<Color R="1" G="0.4" B="0.8"/>
+						</c:Model>
+					</Components>
+					<Children>
+						<Entity>
+							<Components>
+								<c:Transform>
+									<Position X="0" Y="0"/>
+									<Orientation X="0" Y="0" Z="0"/>
+								</c:Transform>
+								<c:RaptorCopter>
+									<Speed>20</Speed>
+									<Axis Y="1"/>
+								</c:RaptorCopter>
+							</Components>
+							<Children>
+								<Entity>
+									<Components>
+										<c:Transform>
+											<Position X="0" Y="0.4"/>
+											<Scale X="0.1" Y="0.4" Z="0.1"/>
+										</c:Transform>
+										<c:Model>
+											<Resource>Models/Core/UnitCylinder.obj</Resource>
+											<Color R="1" G="0.4" B="0.8"/>
+										</c:Model>
+									</Components>
+								</Entity>
+								<Entity>
+									<Components>
+										<c:Transform>
+											<Position X="0" Y="0.6"/>
+											<Scale X="1.7" Y="0.03" Z="0.1"/>
+											<Orientation X="0" Y="0" Z="0"/>
+										</c:Transform>
+										<c:Model>
+											<Resource>Models/Core/UnitCube.obj</Resource>
+											<Color R="1" G="0.4" B="0.8"/>
+										</c:Model>
+									</Components>
+								</Entity>
+								<Entity>
+									<Components>
+										<c:Transform>
+											<Position X="0" Y="0.6"/>
+											<Scale X="1.7" Y="0.03" Z="0.1"/>
+											<Orientation X="0" Y="1.57" Z="0"/>
+										</c:Transform>
+										<c:Model>
+											<Resource>Models/Core/UnitCube.obj</Resource>
+											<Color R="1" G="0.4" B="0.8"/>
+										</c:Model>
+									</Components>
+								</Entity>
+							</Children>
+						</Entity>
+					</Children>
+				</Entity>
+			</Children>
+		</Entity>
 	</Children>
 </Entity>

resources/Schema/Types.xsd

@@ -3,6 +3,10 @@
 <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="types" elementFormDefault="qualified">
 	<xs:include schemaLocation="Types/Quaternion.xsd"/>
 	<xs:include schemaLocation="Types/Vector.xsd"/>
+	<xs:include schemaLocation="Types/Color.xsd"/>
+	<xs:simpleType name="bool">
+		<xs:restriction base="xs:boolean"></xs:restriction>
+	</xs:simpleType>
 	<xs:simpleType name="int">
 		<xs:restriction base="xs:integer"></xs:restriction>
 	</xs:simpleType>

resources/Schema/Types/Color.xsd

@@ -0,0 +1,10 @@
+<?xml version="1.0"?>
+
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="types" elementFormDefault="qualified">
+	<xs:complexType name="Color">
+		<xs:attribute name="R" type="xs:decimal" default="0.0"/>
+		<xs:attribute name="G" type="xs:decimal" default="0.0"/>
+		<xs:attribute name="B" type="xs:decimal" default="0.0"/>
+		<xs:attribute name="A" type="xs:decimal" default="1.0"/>
+	</xs:complexType>
+</xs:schema>

resources/Schema/Types/Entity.xsd

@@ -7,11 +7,13 @@
 	<xs:element name="Entity">
 		<xs:complexType>
 			<xs:all>
-				<xs:element name="Components">
+				<xs:element name="Components" minOccurs="0">
 					<xs:complexType>
 						<xs:all>
 							<xs:element ref="c:Transform" minOccurs="0"/>
+							<xs:element ref="c:Model" minOccurs="0"/>
 							<xs:element ref="c:Test" minOccurs="0"/>
+							<xs:element ref="c:RaptorCopter" minOccurs="0"/>
 						</xs:all>
 					</xs:complexType>
 				</xs:element>

resources/Shaders/Picking.frag.glsl

@@ -13,7 +13,7 @@ out vec4 TextureFragment;
 
 void main()
 {
-	TextureFragment = vec4(PickingColor, 0, 1);
+	TextureFragment = vec4(PickingColor/255, 0, 1);
 }
 
 

src/Engine/CMakeLists.txt

@@ -73,7 +73,7 @@ source_group(GUI FILES ${SOURCE_FILES_GUI})
 set(SOURCE_FILES
     ${SOURCE_FILES_Core}
     ${SOURCE_FILES_Core_Util}
-    #${SOURCE_FILES_Input}
+    ${SOURCE_FILES_Input}
 	${SOURCE_FILES_Network}
     ${SOURCE_FILES_GUI}
     ${SOURCE_FILES_Rendering}

src/Engine/Core/EntityXMLFile.cpp

@@ -0,0 +1,481 @@
+#include "Core/EntityXMLFile.h"
+#include "Core/World.h"
+
+unsigned int EntityXMLFile::InstanceCount = 0;
+
+EntityXMLFile::EntityXMLFile(std::string path)
+    : m_EntityFile(path)
+{
+    using namespace xercesc;
+
+    if (InstanceCount == 0) {
+        XMLPlatformUtils::Initialize();
+    }
+    InstanceCount++;
+
+    m_GrammarPool = new XMLGrammarPoolImpl();
+    m_ErrorHandler = new EntityParserXMLErrorHandler();
+    m_DOMParser = new XercesDOMParser(nullptr, XMLPlatformUtils::fgMemoryManager, m_GrammarPool);
+    m_DOMParser->setErrorHandler(m_ErrorHandler);
+    m_DOMParser->setDoNamespaces(true);
+    m_DOMParser->setDoXInclude(true);
+    m_DOMParser->setDoSchema(true);
+    m_DOMParser->setValidationSchemaFullChecking(true);
+    m_DOMParser->setValidationScheme(xercesc::XercesDOMParser::Val_Auto);
+    m_DOMParser->setValidationSchemaFullChecking(true);
+    m_DOMParser->setValidationConstraintFatal(false);
+    m_DOMParser->setIncludeIgnorableWhitespace(false);
+    // Make sure schema grammar is kept after validation
+    m_DOMParser->cacheGrammarFromParse(true);
+
+    // HACK: Use Sax2 parser instead so the entire DOM doesn't have to reside in memory
+    m_DOMParser->parse(m_EntityFile.c_str());
+    m_DOMDocument = m_DOMParser->getDocument();
+
+    // 1. Fill in ComponentInfo name, fields, default values and metadata from PSVI
+    parseComponentInfo();
+    // 2. Parse default value files for those components
+    parseDefaults();
+    // 3. Allocate component structures
+    predictComponentAllocation();
+}
+
+EntityXMLFile::~EntityXMLFile()
+{
+    using namespace xercesc;
+
+    if (m_DOMParser != nullptr) {
+        delete m_DOMParser;
+    }
+    if (m_ErrorHandler != nullptr) {
+        delete m_ErrorHandler;
+    }
+    if (m_GrammarPool != nullptr) {
+        delete m_GrammarPool;
+    }
+
+    InstanceCount--;
+    if (InstanceCount == 0) {
+        XMLPlatformUtils::Terminate();
+    }
+}
+
+void EntityXMLFile::PopulateWorld(World* world)
+{
+    for (auto& pair : m_ComponentInfo) {
+        world->RegisterComponent(pair.second);
+    }
+
+    // 4. Parse entity hierarchy
+    auto root = m_DOMDocument->getDocumentElement();
+    parseEntityGraph(world, root, 0);
+}
+
+
+void EntityXMLFile::preprocess(std::string inPath, std::string outPath)
+{
+    using namespace xercesc;
+
+    static const XMLCh gLS[] = { 'L', 'S', '\0' };
+    DOMImplementationLS* di = static_cast<DOMImplementationLS*>(DOMImplementationRegistry::getDOMImplementation(gLS));
+
+    // Parse the file
+    DOMLSParser* parser = di->createLSParser(DOMImplementationLS::MODE_SYNCHRONOUS, nullptr);
+    DOMConfiguration* config = parser->getDomConfig();
+    config->setParameter(XMLUni::fgDOMNamespaces, true);
+    config->setParameter(XMLUni::fgXercesSchema, true);
+    config->setParameter(XMLUni::fgXercesHandleMultipleImports, true);
+    config->setParameter(XMLUni::fgXercesSchemaFullChecking, true);
+    config->setParameter(XMLUni::fgXercesDoXInclude, true);
+    auto errHandler = new EntityPreprocessorXMLErrorHandler();
+    config->setParameter(XMLUni::fgDOMErrorHandler, errHandler);
+
+    auto source = new LocalFileInputSource(XSTR(inPath.c_str()));
+    Wrapper4InputSource* domSourceWrapper = new Wrapper4InputSource(source);
+    DOMDocument* doc = parser->parse(dynamic_cast<DOMLSInput*>(domSourceWrapper));
+
+    // Serialize and output the new XML
+    DOMLSSerializer* writer = di->createLSSerializer();
+    DOMLSOutput* output = di->createLSOutput();
+    XMLFormatTarget* formatTarget = new LocalFileFormatTarget(outPath.c_str());
+    // TODO: MemBufFormatTarget* formatTarget = new MemBufFormatTarget()
+    output->setByteStream(formatTarget);
+    writer->write(doc, output);
+
+    delete formatTarget;
+    output->release();
+    writer->release();
+    parser->release();
+}
+
+void EntityXMLFile::parseComponentInfo()
+{
+    using namespace xercesc;
+    bool wasChanged;
+    XSModel* xsModel = m_GrammarPool->getXSModel(wasChanged);
+
+    // Find component xsd element declarations
+    std::cout << "Enumerating components..." << std::endl;
+    // <xs:element name="ComponentName">
+    auto topLevelElements = xsModel->getComponents(XSConstants::ELEMENT_DECLARATION);
+    for (unsigned int i = 0; i < topLevelElements->getLength(); ++i) {
+        auto element = static_cast<XSElementDeclaration*>(topLevelElements->item(i));
+
+        std::string nameSpace(XSTR(element->getNamespace()));
+        if (nameSpace != "components") {
+            continue;
+        }
+
+        ComponentInfo compInfo;
+
+        // Name
+        compInfo.Name = XSTR(element->getName());
+        // Annotation
+        auto componentAnnotation = element->getAnnotation();
+        if (componentAnnotation != nullptr) {
+            // Parse annotation XML
+            char* annotationString = XMLString::transcode(componentAnnotation->getAnnotationString());
+            MemBufInputSource annotationInput(reinterpret_cast<const XMLByte*>(annotationString), strlen(annotationString), "MemBuf: Annotation String");
+            XercesDOMParser parser(nullptr, XMLPlatformUtils::fgMemoryManager, m_GrammarPool);
+            parser.setErrorHandler(m_ErrorHandler);
+            parser.parse(annotationInput);
+            XMLString::release(&annotationString);
+            auto doc = parser.getDocument();
+
+            // Add allocation estimation(s)
+            auto allocationTags = doc->getElementsByTagName(XSTR("meta:allocation"));
+            for (int i = 0; i < allocationTags->getLength(); ++i) {
+                auto allocation = dynamic_cast<DOMElement*>(allocationTags->item(i));
+                auto child = allocation->getFirstChild();
+                if (child == nullptr) {
+                    continue;
+                }
+
+                XSValue::Status status;
+                XSValue* val = XSValue::getActualValue(child->getNodeValue(), XSValue::dt_integer, status);
+                compInfo.Meta.Allocation += val->fData.fValue.f_int;
+            }
+
+            // Save documentation string
+            auto documentationTags = doc->getElementsByTagName(XSTR("xs:documentation"));
+            if (documentationTags->getLength() != 0) {
+                auto child = documentationTags->item(0)->getFirstChild();
+                if (child != nullptr) {
+                    compInfo.Meta.Annotation = XSTR(child->getNodeValue());
+                }
+            }
+            // TODO: Parse annotation string XML
+            // compInfo.Meta.Allocation = ...
+        } else {
+            std::cout << "Warning: Component is missing an annotation!" << std::endl;
+        }
+
+        // <xs:complexType>
+        auto typeDefinition = element->getTypeDefinition();
+        if (typeDefinition->getTypeCategory() != XSTypeDefinition::COMPLEX_TYPE) {
+            std::cerr << "Error: Type definition wasn't COMPLEX_TYPE! Skipping." << std::endl;
+            continue;
+        }
+        auto complexTypeDefinition = dynamic_cast<XSComplexTypeDefinition*>(typeDefinition);
+
+        // <xs:all>
+        auto modelGroupParticle = complexTypeDefinition->getParticle();
+        if (modelGroupParticle->getTermType() != XSParticle::TERM_MODELGROUP) {
+            std::cerr << "Error: Model group particle wasn't TERM_MODELGROUP! Skipping." << std::endl;
+            continue;
+        }
+        auto modelGroup = modelGroupParticle->getModelGroupTerm();
+
+        // <xs:element... 
+        // <xs:attribute...
+        unsigned int fieldOffset = 0;
+        auto particles = modelGroup->getParticles();
+        for (unsigned int i = 0; i < particles->size(); ++i) {
+            auto particle = particles->elementAt(i);
+            if (particle->getTermType() != XSParticle::TERM_ELEMENT) {
+                std::cerr << "Error: Particle wasn't TERM_ELEMENT! Skipping." << std::endl;
+                continue;
+            }
+            auto elementDeclaration = particle->getElementTerm();
+
+            std::string name = XSTR(elementDeclaration->getName());
+            std::string type = XSTR(elementDeclaration->getTypeDefinition()->getName());
+
+            size_t stride = getTypeStride(type);
+            if (stride == 0) {
+                std::cout << "Warning: Field \"" << name << "\" in component \"" << compInfo.Name << "\" uses unexpected field type \"" << type << "\". Skipping." << std::endl;
+                continue;
+            }
+
+            compInfo.FieldTypes[name] = type;
+            compInfo.FieldOffsets[name] = fieldOffset;
+            fieldOffset += getTypeStride(type);
+        }
+
+        compInfo.Meta.Stride = fieldOffset;
+        m_ComponentInfo[compInfo.Name] = compInfo;
+    }
+}
+
+void EntityXMLFile::parseDefaults()
+{
+    using namespace xercesc;
+
+    for (auto& ci : m_ComponentInfo) {
+        // Allocate memory for default values
+        ci.second.Defaults = std::shared_ptr<char>(new char[ci.second.Meta.Stride]);
+        memset(ci.second.Defaults.get(), 0, ci.second.Meta.Stride);
+
+        XercesDOMParser parser(nullptr, XMLPlatformUtils::fgMemoryManager);
+        parser.setErrorHandler(m_ErrorHandler);
+
+        std::string componentName = ci.first;
+        LOG_DEBUG("Parsing defaults for component %s", componentName.c_str());
+        boost::filesystem::path defaultsFile = "Schema/Components/" + componentName + ".xml";
+
+        parser.parse(defaultsFile.string().c_str());
+        auto doc = parser.getDocument();
+        if (doc == nullptr) {
+            LOG_ERROR("%s not found! Skipping.", defaultsFile.string().c_str());
+            continue;
+        }
+
+        // Find the node in the components namespace matching the component name
+        std::string tagName = "c:" + componentName;
+        auto rootNodes = doc->getElementsByTagName(XSTR(tagName.c_str()));
+        if (rootNodes->getLength() == 0) {
+            LOG_ERROR("Couldn't find defaults for component \"%s\"! Skipping.", componentName.c_str());
+            continue;
+        }
+        auto componentElement = dynamic_cast<DOMElement*>(rootNodes->item(0));
+       
+        // Fill the default value buffer with values
+        for (auto& field : ci.second.FieldOffsets) {
+            std::string fieldName = field.first;
+            auto fieldNodes = componentElement->getElementsByTagName(XSTR(fieldName.c_str()));
+            auto fieldNode = fieldNodes->item(0);
+            if (fieldNode == nullptr) {
+                LOG_ERROR("Defaults for component \"%s\" is missing field \"%s\"!", componentName.c_str(), fieldName.c_str());
+                continue;
+            }
+            auto fieldElement = dynamic_cast<DOMElement*>(fieldNode);
+
+            std::string fieldType = ci.second.FieldTypes.at(fieldName);
+            unsigned int fieldOffset = ci.second.FieldOffsets.at(fieldName);
+            writeData(fieldElement, fieldType, ci.second.Defaults.get() + fieldOffset);
+        }
+    }
+}
+
+void EntityXMLFile::predictComponentAllocation()
+{
+    using namespace xercesc;
+
+    auto root = m_DOMDocument->getDocumentElement();
+
+    // Count static instances of components present in entity hierarchy
+    auto components = m_DOMDocument->getElementsByTagNameNS(XSTR("components"), XSTR("*"));
+    for (int i = 0; i < components->getLength(); ++i) {
+        auto component = dynamic_cast<DOMElement*>(components->item(i));
+
+        std::string componentName = XSTR(component->getLocalName());
+        auto& compInfo = m_ComponentInfo.at(componentName);
+        compInfo.Meta.Allocation += 1;
+    }
+
+    std::cout << "COMPONENT INFO" << std::endl;
+    for (auto& pair : m_ComponentInfo) {
+        ComponentInfo& ci = pair.second;
+        std::cout << "Component: " << ci.Name << " (" << ci.Meta.Annotation << ")" << std::endl;
+        std::cout << "  Allocation: " << ci.Meta.Allocation << std::endl;
+        std::cout << "  Fields:" << std::endl;
+
+        // Calculate component size
+        std::size_t stride = 0;
+        // Add size of fields
+        for (auto& field : ci.FieldTypes) {
+            std::cout << "    " << field.second << " " << field.first << " (" << getTypeStride(field.second) << " byte)" << std::endl;
+            stride += getTypeStride(field.second);
+        }
+        std::cout << "  Stride: " << ci.Meta.Stride << std::endl;
+    }
+}
+
+void EntityXMLFile::parseEntityGraph(World* world, xercesc::DOMElement* element, EntityID parentEntity)
+{
+    using namespace xercesc;
+
+    // Create entity
+    EntityID entity = world->CreateEntity(parentEntity);
+    LOG_DEBUG("Created entity %i, parent %i", entity, parentEntity);
+
+    // Add components
+    auto components = m_DOMDocument->evaluate(XSTR("Components/*"), element, nullptr,  DOMXPathResult::ORDERED_NODE_SNAPSHOT_TYPE, nullptr);
+    for (int i = 0; i < components->getSnapshotLength(); i++) {
+        components->snapshotItem(i);
+        auto componentElement = dynamic_cast<DOMElement*>(components->getNodeValue());
+        std::string componentName = XSTR(componentElement->getLocalName());
+        auto& ci = m_ComponentInfo.at(componentName);
+
+        // Attach the component
+        auto c = world->AttachComponent(entity, componentName);
+        LOG_DEBUG("Attached %s component", componentName.c_str());
+
+        // Write field data
+        auto fields = componentElement->getChildNodes();
+        for (int j = 0; j < fields->getLength(); ++j) {
+            auto fieldNode = fields->item(j);
+            auto nodeType = fieldNode->getNodeType();
+            if (nodeType != DOMNode::ELEMENT_NODE) {
+                continue;
+            }
+            auto field = dynamic_cast<DOMElement*>(fields->item(j));
+            //const XMLCh* value = fields->item(j)->getTextContent();
+            std::string fieldName(XSTR(field->getLocalName()));
+            if (ci.FieldTypes.find(fieldName) == ci.FieldTypes.end()) {
+                std::cout << "Warning: Component \"" << componentName << "\" contains invalid field \"" << fieldName << "\". Skipping." << std::endl;
+                continue;
+            }
+
+            std::string fieldType = ci.FieldTypes.at(fieldName);
+            unsigned int fieldOffset = ci.FieldOffsets.at(fieldName);
+            std::string fieldValue(XSTR(field->getTextContent()));
+            LOG_DEBUG("    %s %s = %s", fieldType.c_str(), fieldName.c_str(), fieldValue.c_str());
+            writeData(field, fieldType, c.Data + fieldOffset);
+        }
+    }
+
+    // Recurse children
+    auto children = m_DOMDocument->evaluate(XSTR("Children/Entity"), element, nullptr, DOMXPathResult::ORDERED_NODE_SNAPSHOT_TYPE, nullptr);
+    for (int i = 0; i < children->getSnapshotLength(); i++) {
+        children->snapshotItem(i);
+        parseEntityGraph(world, dynamic_cast<DOMElement*>(children->getNodeValue()), entity);
+    }
+
+    //auto components = m_DOMDocument->getElementsByTagNameNS(XSTR("components"), XSTR("*"));
+    //for (int i = 0; i < components->getLength(); ++i) {
+    //    auto component = dynamic_cast<DOMElement*>(components->item(i));
+
+    //    std::string componentName = XSTR(component->getLocalName());
+    //    auto& compStore = m_ComponentStore.at(componentName);
+    //    auto& compInfo = compStore.Info;
+
+    //    char* data = &compStore.Data[compStore.Size*compStore.Stride];
+    //    compStore.Size += 1;
+
+    //    auto fields = component->getChildNodes();
+    //    for (int j = 0; j < fields->getLength(); ++j) {
+    //        auto field = fields->item(j);
+    //        auto nodeType = field->getNodeType();
+    //        if (nodeType != DOMNode::ELEMENT_NODE) {
+    //            continue;
+    //        }
+    //        //auto field = dynamic_cast<DOMElement*>(fields->item(j));
+    //        //const XMLCh* value = fields->item(j)->getTextContent();
+    //        std::string fieldName = XSTR(field->getLocalName());
+    //        if (compInfo.FieldTypes.find(fieldName) == compInfo.FieldTypes.end()) {
+    //            std::cout << "Warning: Component \"" << componentName << "\" contains invalid field \"" << fieldName << "\". Skipping." << std::endl;
+    //            continue;
+    //        }
+
+    //        std::string fieldType = compInfo.FieldTypes.at(fieldName);
+    //        unsigned int fieldOffset = compInfo.FieldOffsets.at(fieldName);
+
+    //        XSValue::DataType dataType = XSValue::getDataType(XSTR(fieldType.c_str()));
+    //        if (dataType == XSValue::DataType::dt_MAXCOUNT) {
+    //            // TODO:
+    //            continue;
+    //        }
+    //        if (dataType == XSValue::DataType::dt_string) {
+    //            char* str = XMLString::transcode(field->getTextContent());
+    //            std::string standardString(str);
+    //            XMLString::release(&str);
+    //            memcpy(&data[fieldOffset], reinterpret_cast<char*>(&standardString), getTypeStride(fieldType));
+    //        } else {
+    //            XSValue::Status status;
+    //            XSValue* val = XSValue::getActualValue(field->getTextContent(), dataType, status);
+    //            memcpy(&data[fieldOffset], reinterpret_cast<char*>(&val->fData.fValue), getTypeStride(fieldType));
+    //        }
+    //    }
+    //}
+
+    //auto entities = m_DOMDocument->getElementsByTagName(XSTR("Entity"));
+    //for (int i = 0; i < entities->getLength(); ++i) {
+    //    auto entity = dynamic_cast<DOMElement*>(entities->item(i));
+
+
+    //    //entity->setIdAttribute()
+
+    //    std::cout << "ENTITY " << i + 1 << std::endl;
+    //}
+}
+
+std::size_t EntityXMLFile::getTypeStride(std::string typeName)
+{
+    std::map<std::string, size_t> typeStrides{
+        { "bool", sizeof(bool) },
+        { "int", sizeof(int) },
+        { "double", sizeof(double) },
+        { "string", sizeof(std::string) },
+        { "Vector", sizeof(glm::vec3) },
+        { "Quaternion", sizeof(glm::quat) },
+        { "Color", sizeof(glm::vec4) }
+    };
+
+    auto it = typeStrides.find(typeName);
+    return (it != typeStrides.end()) ? it->second : 0;
+}
+
+float EntityXMLFile::getFloatAttribute(const xercesc::DOMElement* element, const char* attribute) const
+{
+    using namespace xercesc;
+    XSValue::Status status;
+    XSValue* val = XSValue::getActualValue(element->getAttribute(XSTR(attribute)), xercesc::XSValue::DataType::dt_float, status);
+    if (val == nullptr) {
+        LOG_ERROR("Element \"%s\" doesn't have an \"%s\" attribute!", XSTR(element->getTagName()), attribute);
+        return 0.f;
+    } else {
+        return val->fData.fValue.f_float;
+    }
+}
+
+void EntityXMLFile::writeData(const xercesc::DOMElement* element, std::string typeName, char* outData)
+{
+    using namespace xercesc;
+
+    XSValue::DataType dataType = XSValue::getDataType(XSTR(typeName.c_str()));
+    if (dataType == XSValue::DataType::dt_MAXCOUNT) {
+        if (typeName == "Vector") {
+            glm::vec3 vec;
+            vec.x = getFloatAttribute(element, "X");
+            vec.y = getFloatAttribute(element, "Y");
+            vec.z = getFloatAttribute(element, "Z");
+            memcpy(outData, reinterpret_cast<char*>(&vec), getTypeStride(typeName));
+        } else if (typeName == "Color") {
+            glm::vec4 vec;
+            vec.r = getFloatAttribute(element, "R");
+            vec.g = getFloatAttribute(element, "G");
+            vec.b = getFloatAttribute(element, "B");
+            vec.a = getFloatAttribute(element, "A");
+            memcpy(outData, reinterpret_cast<char*>(&vec), getTypeStride(typeName));
+        } else if (typeName == "Quaternion") {
+            glm::quat q;
+            q.x = getFloatAttribute(element, "X");
+            q.y = getFloatAttribute(element, "Y");
+            q.z = getFloatAttribute(element, "Z");
+            q.w = getFloatAttribute(element, "W");
+            memcpy(outData, reinterpret_cast<char*>(&q), getTypeStride(typeName));
+        }
+    } else if (dataType == XSValue::DataType::dt_string) {
+        char* str = XMLString::transcode(element->getTextContent());
+        std::string standardString(str);
+        new (outData) std::string(str);
+        XMLString::release(&str);
+        //memcpy(outData, reinterpret_cast<char*>(&standardString), getTypeStride(typeName));
+    } else {
+        XSValue::Status status;
+        XSValue* val = XSValue::getActualValue(element->getTextContent(), dataType, status);
+        memcpy(outData, reinterpret_cast<char*>(&val->fData.fValue), getTypeStride(typeName));
+    }
+}
+

src/Engine/Core/ResourceManager.cpp

@@ -35,6 +35,20 @@ void ResourceManager::Reload(std::string resourceName)
 	}
 }
 
+
+void ResourceManager::Release(std::string resourceType, std::string resourceName)
+{
+    auto key = std::make_pair(resourceType, resourceName);
+    if (m_ResourceCache.find(key) == m_ResourceCache.end()) {
+        return;
+    }
+    auto resource = m_ResourceCache.at(key);
+    m_ResourceCache.erase(key);
+    m_ResourceFromName.erase(resourceName);
+    m_ResourceParents.erase(resource);
+    delete resource;
+}
+
 unsigned int ResourceManager::GetNewResourceID(unsigned int typeID)
 {
 	return m_ResourceCount[typeID]++;

src/Engine/Core/World.cpp

@@ -41,9 +41,16 @@ ComponentWrapper World::GetComponent(EntityID entity, std::string componentType)
     return pool->GetByEntity(entity);
 }
 
-const ComponentPool& World::GetComponents(std::string componentType)
+const ComponentPool* World::GetComponents(std::string componentType)
 {
-    return *m_ComponentPools.at(componentType);
+    auto it = m_ComponentPools.find(componentType);
+    return (it != m_ComponentPools.end()) ? it->second : nullptr;
+}
+
+
+EntityID World::GetParent(EntityID entity)
+{
+    return m_EntityParents.at(entity);
 }
 
 EntityID World::generateEntityID()

src/Engine/Input/InputProxy.cpp

@@ -0,0 +1,221 @@
+#include "Input/InputProxy.h"
+#include "Core/World.h"
+
+//InputProxy::InputProxy(EventBroker* eventBroker)
+//    : m_EventBroker(eventBroker)
+//{
+//	// Subscribe to events
+//	EVENT_SUBSCRIBE_MEMBER(m_EMousePress, &InputProxy::OnMousePress);
+//	EVENT_SUBSCRIBE_MEMBER(m_EMouseRelease, &InputProxy::OnMouseRelease);
+//	EVENT_SUBSCRIBE_MEMBER(m_EGamepadAxis, &InputProxy::OnGamepadAxis);
+//	EVENT_SUBSCRIBE_MEMBER(m_EGamepadButtonDown, &InputProxy::OnGamepadButtonDown);
+//	EVENT_SUBSCRIBE_MEMBER(m_EGamepadButtonUp, &InputProxy::OnGamepadButtonUp);
+//	EVENT_SUBSCRIBE_MEMBER(m_EBindKey, &InputProxy::OnBindKey);
+//	EVENT_SUBSCRIBE_MEMBER(m_EBindMouseButton, &InputProxy::OnBindMouseButton);
+//	EVENT_SUBSCRIBE_MEMBER(m_EBindGamepadAxis, &InputProxy::OnBindGamepadAxis);
+//	EVENT_SUBSCRIBE_MEMBER(m_EBindGamepadButton, &InputProxy::OnBindGamepadButton);
+//    
+//    SteamController()->Init();
+//    
+//}
+//
+//void InputProxy::Update(double dt)
+//{
+//    std::array<ControllerHandle_t, STEAM_CONTROLLER_MAX_COUNT> controllers;
+//    int numControllers = SteamController()->GetConnectedControllers(controllers.data());
+//
+//    ControllerDigitalActionHandle_t debug_reload_handle = SteamController()->GetDigitalActionHandle("debug_reload");
+//    SteamController()->
+//}
+//
+//bool InputProxy::OnKeyDown(const Events::KeyDown &event)
+//{
+//	auto range = m_KeyBindings.equal_range(event.KeyCode);
+//	for (auto bindingIt = range.first; bindingIt != range.second; bindingIt++) {
+//		std::string command;
+//		float value;
+//		std::tie(command, value) = bindingIt->second;
+//		m_CommandKeyboardValues[command][event.KeyCode] = value;
+//		PublishCommand(1, command, GetCommandTotalValue(command));
+//	}
+//
+//	return true;
+//}
+//
+//bool InputProxy::OnKeyUp(const Events::KeyUp &event)
+//{
+//	auto range = m_KeyBindings.equal_range(event.KeyCode);
+//	for (auto bindingIt = range.first; bindingIt != range.second; bindingIt++) {
+//		std::string command;
+//		float value;
+//		std::tie(command, value) = bindingIt->second;
+//		m_CommandKeyboardValues[command][event.KeyCode] = 0;
+//		PublishCommand(1, command, GetCommandTotalValue(command));;
+//	}
+//
+//	return true;
+//}
+//
+//bool InputProxy::OnMousePress(const Events::MousePress &event)
+//{
+//	auto range = m_MouseButtonBindings.equal_range(event.Button);
+//	for (auto bindingIt = range.first; bindingIt != range.second; bindingIt++) {
+//		std::string command;
+//		float value;
+//		std::tie(command, value) = bindingIt->second;
+//		m_CommandMouseButtonValues[command][event.Button] = value;
+//		PublishCommand(1, command, GetCommandTotalValue(command));
+//	}
+//
+//	return true;
+//}
+//
+//bool InputProxy::OnMouseRelease(const Events::MouseRelease &event)
+//{
+//	auto range = m_MouseButtonBindings.equal_range(event.Button);
+//	for (auto bindingIt = range.first; bindingIt != range.second; bindingIt++) {
+//		std::string command;
+//		float value;
+//		std::tie(command, value) = bindingIt->second;
+//		m_CommandMouseButtonValues[command][event.Button] = 0;
+//		PublishCommand(1, command, GetCommandTotalValue(command));
+//	}
+//
+//	return true;
+//}
+//
+//bool InputProxy::OnGamepadAxis(const Events::GamepadAxis &event)
+//{
+//	auto range = m_GamepadAxisBindings.equal_range(event.Axis);
+//	for (auto bindingIt = range.first; bindingIt != range.second; bindingIt++) {
+//		std::string command;
+//		float value;
+//		std::tie(command, value) = bindingIt->second;
+//		m_CommandGamepadAxisValues[command][event.Axis] = event.Value * value;
+//		PublishCommand(event.GamepadID + 1, command, GetCommandTotalValue(command));
+//	}
+//
+//	return true;
+//}
+//
+//bool InputProxy::OnGamepadButtonDown(const Events::GamepadButtonDown &event)
+//{
+//	auto range = m_GamepadButtonBindings.equal_range(event.Button);
+//	for (auto bindingIt = range.first; bindingIt != range.second; bindingIt++) {
+//		std::string command;
+//		float value;
+//		std::tie(command, value) = bindingIt->second;
+//		m_CommandGamepadButtonValues[command][event.Button] = value;
+//		PublishCommand(event.GamepadID + 1, command, GetCommandTotalValue(command));
+//	}
+//
+//	return true;
+//}
+//
+//bool InputProxy::OnGamepadButtonUp(const Events::GamepadButtonUp &event)
+//{
+//	auto range = m_GamepadButtonBindings.equal_range(event.Button);
+//	for (auto bindingIt = range.first; bindingIt != range.second; bindingIt++) {
+//		std::string command;
+//		float value;
+//		std::tie(command, value) = bindingIt->second;
+//		m_CommandGamepadButtonValues[command][event.Button] = 0;
+//		PublishCommand(event.GamepadID + 1, command, GetCommandTotalValue(command));
+//	}
+//
+//	return true;
+//}
+//
+//bool InputProxy::OnBindKey(const Events::BindKey &event)
+//{
+//	if (event.Command.empty()) {
+//		return false;
+//	}
+//
+//	m_KeyBindings.insert(std::make_pair(event.KeyCode, std::make_tuple(event.Command, event.Value)));
+//	LOG_DEBUG("Input: Bound key %i to %s", event.KeyCode, event.Command.c_str());
+//
+//	return true;
+//}
+//
+//bool InputProxy::OnBindMouseButton(const Events::BindMouseButton &event)
+//{
+//	if (event.Command.empty()) {
+//		return false;
+//	}
+//
+//	m_MouseButtonBindings.insert(std::make_pair(event.Button, std::make_tuple(event.Command, event.Value)));
+//	LOG_DEBUG("Input: Bound mouse button %i to %s", event.Button, event.Command.c_str());
+//
+//	return true;
+//}
+//
+//bool InputProxy::OnBindGamepadAxis(const Events::BindGamepadAxis &event)
+//{
+//	if (event.Command.empty()) {
+//		return false;
+//	}
+//
+//	m_GamepadAxisBindings.insert(std::make_pair(event.Axis, std::make_tuple(event.Command, event.Value)));
+//	LOG_DEBUG("Input: Bound gamepad axis %i to %s", event.Axis, event.Command.c_str());
+//
+//	return true;
+//}
+//
+//bool InputProxy::OnBindGamepadButton(const Events::BindGamepadButton &event)
+//{
+//	if (event.Command.empty()) {
+//		return false;
+//	}
+//
+//	m_GamepadButtonBindings.insert(std::make_pair(event.Button, std::make_tuple(event.Command, event.Value)));
+//	LOG_DEBUG("Input: Bound gamepad axis %i to %s", event.Button, event.Command.c_str());
+//
+//	return true;
+//}
+//
+//float InputProxy::GetCommandTotalValue(std::string command)
+//{
+//	float value = 0.f;
+//
+//	auto keyboardIt = m_CommandKeyboardValues.find(command);
+//	if (keyboardIt != m_CommandKeyboardValues.end()) {
+//		for (auto &key : keyboardIt->second) {
+//			value += key.second;
+//		}
+//	}
+//
+//	auto mouseButtonIt = m_CommandMouseButtonValues.find(command);
+//	if (mouseButtonIt != m_CommandMouseButtonValues.end()) {
+//		for (auto &button : mouseButtonIt->second) {
+//			value += button.second;
+//		}
+//	}
+//
+//	auto gamepadAxisIt = m_CommandGamepadAxisValues.find(command);
+//	if (gamepadAxisIt != m_CommandGamepadAxisValues.end()) {
+//		for (auto &axis : gamepadAxisIt->second) {
+//			value += axis.second;
+//		}
+//	}
+//
+//	auto gamepadButtonIt = m_CommandGamepadButtonValues.find(command);
+//	if (gamepadButtonIt != m_CommandGamepadButtonValues.end()) {
+//		for (auto &button : gamepadButtonIt->second) {
+//			value += button.second;
+//		}
+//	}
+//
+//	return std::max(-1.f, std::min(value, 1.f));
+//}
+//
+//void InputProxy::PublishCommand(int playerID, std::string command, float value)
+//{
+//	Events::InputCommand e;
+//	e.PlayerID = playerID;
+//	e.Command = command;
+//	e.Value = value;
+//	m_EventBroker->Publish(e);
+//
+//	LOG_DEBUG("Input: Published command %s=%f for player %i", e.Command.c_str(), e.Value, playerID);
+//}

src/Engine/Input/InputSystem.cpp

@@ -1,221 +0,0 @@
-#include "PrecompiledHeader.h"
-#include "Input/InputSystem.h"
-#include "Core/World.h"
-
-void Systems::InputSystem::RegisterComponents(ComponentFactory* cf)
-{
-	
-}
-
-void Systems::InputSystem::Initialize()
-{
-	// Subscribe to events
-	EVENT_SUBSCRIBE_MEMBER(m_EKeyDown, &Systems::InputSystem::OnKeyDown);
-	EVENT_SUBSCRIBE_MEMBER(m_EKeyUp, &Systems::InputSystem::OnKeyUp);
-	EVENT_SUBSCRIBE_MEMBER(m_EMousePress, &Systems::InputSystem::OnMousePress);
-	EVENT_SUBSCRIBE_MEMBER(m_EMouseRelease, &Systems::InputSystem::OnMouseRelease);
-	EVENT_SUBSCRIBE_MEMBER(m_EGamepadAxis, &Systems::InputSystem::OnGamepadAxis);
-	EVENT_SUBSCRIBE_MEMBER(m_EGamepadButtonDown, &Systems::InputSystem::OnGamepadButtonDown);
-	EVENT_SUBSCRIBE_MEMBER(m_EGamepadButtonUp, &Systems::InputSystem::OnGamepadButtonUp);
-	EVENT_SUBSCRIBE_MEMBER(m_EBindKey, &Systems::InputSystem::OnBindKey);
-	EVENT_SUBSCRIBE_MEMBER(m_EBindMouseButton, &Systems::InputSystem::OnBindMouseButton);
-	EVENT_SUBSCRIBE_MEMBER(m_EBindGamepadAxis, &Systems::InputSystem::OnBindGamepadAxis);
-	EVENT_SUBSCRIBE_MEMBER(m_EBindGamepadButton, &Systems::InputSystem::OnBindGamepadButton);
-}
-
-void Systems::InputSystem::Update(double dt)
-{
-
-}
-
-bool Systems::InputSystem::OnKeyDown(const Events::KeyDown &event)
-{
-	auto range = m_KeyBindings.equal_range(event.KeyCode);
-	for (auto bindingIt = range.first; bindingIt != range.second; bindingIt++) {
-		std::string command;
-		float value;
-		std::tie(command, value) = bindingIt->second;
-		m_CommandKeyboardValues[command][event.KeyCode] = value;
-		PublishCommand(1, command, GetCommandTotalValue(command));
-	}
-
-	return true;
-}
-
-bool Systems::InputSystem::OnKeyUp(const Events::KeyUp &event)
-{
-	auto range = m_KeyBindings.equal_range(event.KeyCode);
-	for (auto bindingIt = range.first; bindingIt != range.second; bindingIt++) {
-		std::string command;
-		float value;
-		std::tie(command, value) = bindingIt->second;
-		m_CommandKeyboardValues[command][event.KeyCode] = 0;
-		PublishCommand(1, command, GetCommandTotalValue(command));;
-	}
-
-	return true;
-}
-
-bool Systems::InputSystem::OnMousePress(const Events::MousePress &event)
-{
-	auto range = m_MouseButtonBindings.equal_range(event.Button);
-	for (auto bindingIt = range.first; bindingIt != range.second; bindingIt++) {
-		std::string command;
-		float value;
-		std::tie(command, value) = bindingIt->second;
-		m_CommandMouseButtonValues[command][event.Button] = value;
-		PublishCommand(1, command, GetCommandTotalValue(command));
-	}
-
-	return true;
-}
-
-bool Systems::InputSystem::OnMouseRelease(const Events::MouseRelease &event)
-{
-	auto range = m_MouseButtonBindings.equal_range(event.Button);
-	for (auto bindingIt = range.first; bindingIt != range.second; bindingIt++) {
-		std::string command;
-		float value;
-		std::tie(command, value) = bindingIt->second;
-		m_CommandMouseButtonValues[command][event.Button] = 0;
-		PublishCommand(1, command, GetCommandTotalValue(command));
-	}
-
-	return true;
-}
-
-bool Systems::InputSystem::OnGamepadAxis(const Events::GamepadAxis &event)
-{
-	auto range = m_GamepadAxisBindings.equal_range(event.Axis);
-	for (auto bindingIt = range.first; bindingIt != range.second; bindingIt++) {
-		std::string command;
-		float value;
-		std::tie(command, value) = bindingIt->second;
-		m_CommandGamepadAxisValues[command][event.Axis] = event.Value * value;
-		PublishCommand(event.GamepadID + 1, command, GetCommandTotalValue(command));
-	}
-
-	return true;
-}
-
-bool Systems::InputSystem::OnGamepadButtonDown(const Events::GamepadButtonDown &event)
-{
-	auto range = m_GamepadButtonBindings.equal_range(event.Button);
-	for (auto bindingIt = range.first; bindingIt != range.second; bindingIt++) {
-		std::string command;
-		float value;
-		std::tie(command, value) = bindingIt->second;
-		m_CommandGamepadButtonValues[command][event.Button] = value;
-		PublishCommand(event.GamepadID + 1, command, GetCommandTotalValue(command));
-	}
-
-	return true;
-}
-
-bool Systems::InputSystem::OnGamepadButtonUp(const Events::GamepadButtonUp &event)
-{
-	auto range = m_GamepadButtonBindings.equal_range(event.Button);
-	for (auto bindingIt = range.first; bindingIt != range.second; bindingIt++) {
-		std::string command;
-		float value;
-		std::tie(command, value) = bindingIt->second;
-		m_CommandGamepadButtonValues[command][event.Button] = 0;
-		PublishCommand(event.GamepadID + 1, command, GetCommandTotalValue(command));
-	}
-
-	return true;
-}
-
-bool Systems::InputSystem::OnBindKey(const Events::BindKey &event)
-{
-	if (event.Command.empty()) {
-		return false;
-	}
-
-	m_KeyBindings.insert(std::make_pair(event.KeyCode, std::make_tuple(event.Command, event.Value)));
-	LOG_DEBUG("Input: Bound key %i to %s", event.KeyCode, event.Command.c_str());
-
-	return true;
-}
-
-bool Systems::InputSystem::OnBindMouseButton(const Events::BindMouseButton &event)
-{
-	if (event.Command.empty()) {
-		return false;
-	}
-
-	m_MouseButtonBindings.insert(std::make_pair(event.Button, std::make_tuple(event.Command, event.Value)));
-	LOG_DEBUG("Input: Bound mouse button %i to %s", event.Button, event.Command.c_str());
-
-	return true;
-}
-
-bool Systems::InputSystem::OnBindGamepadAxis(const Events::BindGamepadAxis &event)
-{
-	if (event.Command.empty()) {
-		return false;
-	}
-
-	m_GamepadAxisBindings.insert(std::make_pair(event.Axis, std::make_tuple(event.Command, event.Value)));
-	LOG_DEBUG("Input: Bound gamepad axis %i to %s", event.Axis, event.Command.c_str());
-
-	return true;
-}
-
-bool Systems::InputSystem::OnBindGamepadButton(const Events::BindGamepadButton &event)
-{
-	if (event.Command.empty()) {
-		return false;
-	}
-
-	m_GamepadButtonBindings.insert(std::make_pair(event.Button, std::make_tuple(event.Command, event.Value)));
-	LOG_DEBUG("Input: Bound gamepad axis %i to %s", event.Button, event.Command.c_str());
-
-	return true;
-}
-
-float Systems::InputSystem::GetCommandTotalValue(std::string command)
-{
-	float value = 0.f;
-
-	auto keyboardIt = m_CommandKeyboardValues.find(command);
-	if (keyboardIt != m_CommandKeyboardValues.end()) {
-		for (auto &key : keyboardIt->second) {
-			value += key.second;
-		}
-	}
-
-	auto mouseButtonIt = m_CommandMouseButtonValues.find(command);
-	if (mouseButtonIt != m_CommandMouseButtonValues.end()) {
-		for (auto &button : mouseButtonIt->second) {
-			value += button.second;
-		}
-	}
-
-	auto gamepadAxisIt = m_CommandGamepadAxisValues.find(command);
-	if (gamepadAxisIt != m_CommandGamepadAxisValues.end()) {
-		for (auto &axis : gamepadAxisIt->second) {
-			value += axis.second;
-		}
-	}
-
-	auto gamepadButtonIt = m_CommandGamepadButtonValues.find(command);
-	if (gamepadButtonIt != m_CommandGamepadButtonValues.end()) {
-		for (auto &button : gamepadButtonIt->second) {
-			value += button.second;
-		}
-	}
-
-	return std::max(-1.f, std::min(value, 1.f));
-}
-
-void Systems::InputSystem::PublishCommand(int playerID, std::string command, float value)
-{
-	Events::InputCommand e;
-	e.PlayerID = playerID;
-	e.Command = command;
-	e.Value = value;
-	EventBroker->Publish(e);
-
-	LOG_DEBUG("Input: Published command %s=%f for player %i", e.Command.c_str(), e.Value, playerID);
-}

src/Engine/Rendering/RawModel.cpp

@@ -34,10 +34,10 @@ RawModel::RawModel(std::string fileName)
 			numIndices += face.mNumIndices;
 		}
 	}
-	LOG_DEBUG("Vertex count %i", numVertices);
-	LOG_DEBUG("Index count %i", numIndices);
+	//LOG_DEBUG("Vertex count %i", numVertices);
+	//LOG_DEBUG("Index count %i", numIndices);
 
-	LOG_DEBUG("Model has %i embedded textures", scene->mNumTextures);
+	//LOG_DEBUG("Model has %i embedded textures", scene->mNumTextures);
 
 	std::vector<std::tuple<std::string, glm::mat4>> boneInfo;
 	std::map<std::string, int> boneNameMapping;
@@ -132,35 +132,35 @@ RawModel::RawModel(std::string fileName)
 		matGroup.EndIndex = m_Indices.size() - 1;
 		// Material shininess
 		material->Get(AI_MATKEY_SHININESS, matGroup.Shininess);
-		LOG_DEBUG("Shininess: %f", matGroup.Shininess);
+		//LOG_DEBUG("Shininess: %f", matGroup.Shininess);
 		// Diffuse texture
-		LOG_DEBUG("%i diffuse textures found", material->GetTextureCount(aiTextureType_DIFFUSE));
+		//LOG_DEBUG("%i diffuse textures found", material->GetTextureCount(aiTextureType_DIFFUSE));
 		if (material->GetTextureCount(aiTextureType_DIFFUSE)) {
 			aiString path;
 			aiTextureMapping mapping;
 			material->GetTexture(aiTextureType_DIFFUSE, 0, &path, &mapping);
 			std::string absolutePath = (boost::filesystem::path(fileName).branch_path() / path.C_Str()).string();
-			LOG_DEBUG("Diffuse texture: %s", absolutePath.c_str());
+			//LOG_DEBUG("Diffuse texture: %s", absolutePath.c_str());
 			matGroup.Texture = std::shared_ptr<Texture>(ResourceManager::Load<Texture>(absolutePath));
 		}
 		// Normal map
-		LOG_DEBUG("%i normal maps found", material->GetTextureCount(aiTextureType_HEIGHT));
+		//LOG_DEBUG("%i normal maps found", material->GetTextureCount(aiTextureType_HEIGHT));
 		if (material->GetTextureCount(aiTextureType_HEIGHT)) {
 			aiString path;
 			aiTextureMapping mapping;
 			material->GetTexture(aiTextureType_HEIGHT, 0, &path, &mapping);
 			std::string absolutePath = (boost::filesystem::path(fileName).branch_path() / path.C_Str()).string();
-			LOG_DEBUG("Normal map: %s", absolutePath.c_str());
+			//LOG_DEBUG("Normal map: %s", absolutePath.c_str());
 			matGroup.NormalMap = std::shared_ptr<Texture>(ResourceManager::Load<Texture>(absolutePath));
 		}
 		// Specular map
-		LOG_DEBUG("%i specular maps found", material->GetTextureCount(aiTextureType_SPECULAR));
+		//LOG_DEBUG("%i specular maps found", material->GetTextureCount(aiTextureType_SPECULAR));
 		if (material->GetTextureCount(aiTextureType_SPECULAR)) {
 			aiString path;
 			aiTextureMapping mapping;
 			material->GetTexture(aiTextureType_SPECULAR, 0, &path, &mapping);
 			std::string absolutePath = (boost::filesystem::path(fileName).branch_path() / path.C_Str()).string();
-			LOG_DEBUG("Specular map: %s", absolutePath.c_str());
+			//LOG_DEBUG("Specular map: %s", absolutePath.c_str());
 			matGroup.SpecularMap = std::shared_ptr<Texture>(ResourceManager::Load<Texture>(absolutePath));
 		}
 		TextureGroups.push_back(matGroup);
@@ -216,20 +216,20 @@ RawModel::RawModel(std::string fileName)
 		m_Skeleton = new Skeleton();
 		CreateSkeleton(boneInfo, boneNameMapping, scene->mRootNode, -1);
 		int numBones = m_Skeleton->Bones.size();
-		LOG_DEBUG("Bone count: %i", numBones);
+		//LOG_DEBUG("Bone count: %i", numBones);
 		if (numBones > 0) {
 			m_Skeleton->PrintSkeleton();
 		}
 	}
 
 	// Animations
-	LOG_DEBUG("Animation count: %i", scene->mNumAnimations);
+	//LOG_DEBUG("Animation count: %i", scene->mNumAnimations);
 	for (int i = 0; i < scene->mNumAnimations; ++i) {
 		auto animation = scene->mAnimations[i];
 		std::string animationName = animation->mName.C_Str();
-		LOG_DEBUG("Animation: %s", animationName.c_str());
-		LOG_DEBUG("Duration: %f", animation->mDuration);
-		LOG_DEBUG("Ticks per second: %f", animation->mTicksPerSecond);
+		//LOG_DEBUG("Animation: %s", animationName.c_str());
+		//LOG_DEBUG("Duration: %f", animation->mDuration);
+		//LOG_DEBUG("Ticks per second: %f", animation->mTicksPerSecond);
 
 		Skeleton::Animation skelAnim;
 		skelAnim.Name = animationName;
@@ -303,7 +303,7 @@ void RawModel::CreateSkeleton(std::vector<std::tuple<std::string, glm::mat4>> &b
 
 	// Find the bone by name in the bone info list
 	if (boneNameMapping.find(nodeName) == boneNameMapping.end()) {
-		LOG_DEBUG("Node \"%s\" was not a bone", nodeName.c_str());
+		//LOG_DEBUG("Node \"%s\" was not a bone", nodeName.c_str());
 	} else {
 		glm::mat4 offsetMatrix;
 		int ID = boneNameMapping[nodeName];

src/Engine/Rendering/RenderQueueFactory.cpp

@@ -15,49 +15,87 @@ void RenderQueueFactory::Update(World* world)
 
 glm::mat4 RenderQueueFactory::ModelMatrix(World* world, EntityID entity)
 {
-    //should really return absolute model matrix based on parents position, scale and orientation
-    //GetAbsolutePosition(World* world, ComponentWrapper transformComponent)
+    glm::vec3 position = AbsolutePosition(world, entity);
+    glm::quat orientation = AbsoluteOrientation(world, entity);
+    glm::vec3 scale = AbsoluteScale(world, entity);
 
-    ComponentWrapper transformComponent = world->GetComponent(entity, "Transform");
-    glm::vec3 position = transformComponent["Position"];
-    glm::vec3 scale = transformComponent["Scale"];
-    glm::quat oritentation = transformComponent["Orientation"];
-
-    glm::mat4 modelMatrix = glm::translate(glm::mat4(), position) * glm::toMat4(oritentation) * glm::scale(scale);
+    glm::mat4 modelMatrix = glm::translate(glm::mat4(), position) * glm::toMat4(orientation) * glm::scale(scale);
     return modelMatrix;
 }
 
-glm::vec3 GetAbsolutePosition(World* world, ComponentWrapper transformComponent)
+
+glm::vec3 RenderQueueFactory::AbsolutePosition(World* world, EntityID entity)
 {
-  //  positionComponent.EntityID
-    return glm::vec3();
+    glm::vec3 position;
+
+    do {
+        ComponentWrapper transform = world->GetComponent(entity, "Transform");
+        position += AbsoluteOrientation(world, entity) * (glm::vec3)transform["Position"];
+        entity = world->GetParent(entity);
+    } while (entity != 0);
+   
+    return position;
+}
+
+glm::quat RenderQueueFactory::AbsoluteOrientation(World* world, EntityID entity)
+{
+    glm::quat orientation;
+
+    do {
+        ComponentWrapper transform = world->GetComponent(entity, "Transform");
+        orientation = glm::quat((glm::vec3)transform["Orientation"]) * orientation;
+        entity = world->GetParent(entity);
+    } while (entity != 0);
+    
+    return orientation;
+}
+
+glm::vec3 RenderQueueFactory::AbsoluteScale(World* world, EntityID entity)
+{
+    ComponentWrapper transform = world->GetComponent(entity, "Transform");
+    glm::vec3 scale = (glm::vec3)transform["Scale"];
+
+    EntityID parent = world->GetParent(entity);
+    if (parent != 0) {
+        return AbsoluteScale(world, parent) * scale;
+    } else {
+        return scale;
+    }
 }
 
 void RenderQueueFactory::FillModels(World* world, RenderQueue* renderQueue)
 {
-   for(auto& modelC : world->GetComponents("Model")) {
-       ModelJob job;
-       std::string resource = modelC["Resource"];
-       glm::vec4 color = modelC["Color"];
-       Model* model = ResourceManager::Load<Model>(resource);
+    auto models = world->GetComponents("Model");
+    if (models == nullptr) {
+        return;
+    }
 
-       for (auto texGroup : model->TextureGroups) {
-           job.TextureID = (texGroup.Texture) ? texGroup.Texture->ResourceID : 0;
-           job.DiffuseTexture = texGroup.Texture.get();
-           job.NormalTexture = texGroup.NormalMap.get();
-           job.SpecularTexture = texGroup.SpecularMap.get();
-           job.Model = model;
-           job.StartIndex = texGroup.StartIndex;
-           job.EndIndex = texGroup.EndIndex;
-           job.ModelMatrix = model->m_Matrix * ModelMatrix(world, modelC.EntityID);
-           job.Color = color;
+    for (auto& modelC : *models) {
+        std::string resource = modelC["Resource"];
+        if (resource.empty()) {
+            continue;
+        }
+        glm::vec4 color = modelC["Color"];
+        Model* model = ResourceManager::Load<Model>(resource);
 
-           //TODO: RENDERER: Not sure if the best solution for pickingColor to entity link is this
-           job.Entity = modelC.EntityID;
+        for (auto texGroup : model->TextureGroups) {
+            ModelJob job;
+            job.TextureID = (texGroup.Texture) ? texGroup.Texture->ResourceID : 0;
+            job.DiffuseTexture = texGroup.Texture.get();
+            job.NormalTexture = texGroup.NormalMap.get();
+            job.SpecularTexture = texGroup.SpecularMap.get();
+            job.Model = model;
+            job.StartIndex = texGroup.StartIndex;
+            job.EndIndex = texGroup.EndIndex;
+            job.ModelMatrix = model->m_Matrix * ModelMatrix(world, modelC.EntityID);
+            job.Color = color;
 
-           renderQueue->Add(job);
-       }
-   }
+            //TODO: RENDERER: Not sure if the best solution for pickingColor to entity link is this
+            job.Entity = modelC.EntityID;
+
+            renderQueue->Add(job);
+        }
+    }
 }
 
 void RenderQueueFactory::FillLights(World* world, RenderQueue* renderQueue)

src/Engine/Rendering/Renderer.cpp

@@ -3,7 +3,6 @@
 void Renderer::Initialize()
 {
 	InitializeWindow();
-
 	// Create default camera
 	m_DefaultCamera = new ::Camera((float)m_Resolution.Width / m_Resolution.Height, glm::radians(45.f), 0.01f, 5000.f);
 	m_DefaultCamera->SetPosition(glm::vec3(0, 0, 10));
@@ -116,23 +115,6 @@ void Renderer::InputUpdate(double dt)
 
     static double mousePosX, mousePosY;
     glfwGetCursorPos(m_Window, &mousePosX, &mousePosY);
-    if (glfwGetMouseButton(m_Window, GLFW_MOUSE_BUTTON_1) == GLFW_PRESS) {
-        glm::vec3 data = ScreenCoords::ToPixelData(mousePosX, m_Resolution.Height - mousePosY, &m_PickingBuffer, m_DepthBuffer);
-        glm::vec2 color = glm::vec2(data);
-        float depth = data.z;
-        
-        glm::vec3 viewPos = ScreenCoords::ToWorldPos(mousePosX, m_Resolution.Height - mousePosY, depth, m_Resolution, m_Camera->ProjectionMatrix(), m_Camera->ViewMatrix());
-      //  glm::vec3 worldPos = glm::vec3(glm::inverse(m_Camera->ViewMatrix()) * glm::vec4(viewPos, 1.f));
-
-        //printf("R: %f, G: %f, Depth: %f\n", color.r, color.g, depth);
-        //printf("view: x: %f, y: %f z: %f, Length: %f\n\n", viewPos.x, viewPos.y, viewPos.z, glm::length(viewPos));
-
-        if (color != glm::vec2(0, 0)) {
-            EntityID pickedEntity = m_PickingColorsToEntity[color];
-            printf("Picked Entity: %i", pickedEntity);
-
-        }
-    }
 
 	if (glfwGetKey(m_Window, GLFW_KEY_SPACE) == GLFW_PRESS) {
 
@@ -158,7 +140,8 @@ void Renderer::InputUpdate(double dt)
 
 void Renderer::Update(double dt)
 {
-	InputUpdate(dt);
+    m_EventBroker->Process<Renderer>();
+    InputUpdate(dt);
     
 }
 
@@ -213,10 +196,12 @@ void Renderer::DrawScene(RenderQueueCollection& rq)
             continue;
         }
     }
+    GLERROR("DrawScene Error");
 }
 
 void Renderer::PickingPass(RenderQueueCollection& rq)
 {
+    m_PickingColorsToEntity.clear();
     m_PickingBuffer.Bind();
 
     glEnable(GL_DEPTH_TEST);
@@ -225,7 +210,7 @@ void Renderer::PickingPass(RenderQueueCollection& rq)
 
     glClearColor(0.f, 0.f, 0.f, 1.f);
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-    int r = 30;
+    int r = 1;
     int g = 0;
     //TODO: Render: Add code for more jobs than modeljobs.
 
@@ -237,8 +222,18 @@ void Renderer::PickingPass(RenderQueueCollection& rq)
         auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
 
         if (modelJob) {
-            glm::vec2 pickColor = glm::vec2(r/255.f, g/255.f);
-            m_PickingColorsToEntity[pickColor] = modelJob->Entity;
+            //---------------
+            //TODO: Renderer: IMPORTANT: Fixa detta så det inte loopar igenom listan varje frame.
+            //---------------
+            int pickColor[2] = { r, g };
+            for (auto i : m_PickingColorsToEntity) {
+                if(modelJob->Entity == i.second) {
+                    pickColor[0] = i.first.x;
+                    pickColor[1] = i.first.y;
+                    r -= 1;
+                }
+            }
+            m_PickingColorsToEntity[glm::vec2(pickColor[0], pickColor[1])] = modelJob->Entity;
             
 
             //Render picking stuff
@@ -246,19 +241,32 @@ void Renderer::PickingPass(RenderQueueCollection& rq)
             glUniformMatrix4fv(glGetUniformLocation(ShaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->ModelMatrix));
             glUniformMatrix4fv(glGetUniformLocation(ShaderHandle, "V"), 1, GL_FALSE, glm::value_ptr(m_Camera->ViewMatrix()));
             glUniformMatrix4fv(glGetUniformLocation(ShaderHandle, "P"), 1, GL_FALSE, glm::value_ptr(m_Camera->ProjectionMatrix()));
-            glUniform2fv(glGetUniformLocation(ShaderHandle, "PickingColor"), 1, glm::value_ptr(pickColor));
+            glUniform2fv(glGetUniformLocation(ShaderHandle, "PickingColor"), 1, glm::value_ptr(glm::vec2(pickColor[0], pickColor[1])));
 
             glBindVertexArray(modelJob->Model->VAO);
             glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);
             glDrawElementsBaseVertex(GL_TRIANGLES, modelJob->EndIndex - modelJob->StartIndex + 1, GL_UNSIGNED_INT, 0, modelJob->StartIndex);
-            r+=50;
+            r += 1;
             if(r > 255) {
                 r = 0;
-                g+=50;
+                g += 1;
             }
         }
     }
     m_PickingBuffer.Unbind();
+    GLERROR("PickingPass Error");
+
+    //Publish pick event every frame with the pick data that can be picked by the event
+    Events::Picking pickEvent = Events::Picking(
+        &m_PickingBuffer, 
+        &m_DepthBuffer, 
+        m_Camera->ProjectionMatrix(), 
+        m_Camera->ViewMatrix(), 
+        m_Resolution, 
+        &m_PickingColorsToEntity);
+
+    m_EventBroker->Publish(pickEvent);
+
 }
 
 
@@ -300,7 +308,7 @@ void Renderer::InitializeTextures()
     */
 
     GenerateTexture(&m_PickingTexture, GL_CLAMP_TO_BORDER, GL_LINEAR,
-        glm::vec2(m_Resolution.Width, m_Resolution.Height), GL_RG8, GL_RG, GL_FLOAT);
+        glm::vec2(m_Resolution.Width, m_Resolution.Height), GL_RG8, GL_RG, GL_UNSIGNED_BYTE);
 }
 
 void Renderer::GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type)

src/Engine/Rendering/Util/ScreenCoords.cpp

@@ -29,22 +29,31 @@ glm::vec3 ScreenCoords::ToWorldPos(glm::vec2 screenCoord, float depth, float scr
     return ToWorldPos(screenCoord.x, screenCoord.y, depth, screenWidth, screenHeight, cameraProjectionMat, cameraViewMat);
 }
 
-glm::vec3 ScreenCoords::ToPixelData(float x, float y, FrameBuffer* PickDataBuffer, GLuint DepthBuffer)
+ScreenCoords::PixelData ScreenCoords::ToPixelData(float x, float y, FrameBuffer* PickDataBuffer, GLuint DepthBuffer)
 {
     PickDataBuffer->Bind();
-    glm::vec2 pixelData;
-    glReadPixels(x, y, 1, 1, GL_RG, GL_FLOAT, &pixelData);
+    unsigned char pdata[2];
+    glReadPixels(x, y, 1, 1, GL_RG, GL_UNSIGNED_BYTE, &pdata);
     PickDataBuffer->Unbind();
 
+
     glBindFramebuffer(GL_FRAMEBUFFER, DepthBuffer);
     float depthData;
     glReadPixels(x, y, 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &depthData);
     glBindFramebuffer(GL_FRAMEBUFFER, 0);
 
-    return glm::vec3(pixelData, depthData);
+    PixelData p;
+    p.Color[0] = (int)pdata[0];
+    p.Color[1] = (int)pdata[1];
+    p.Depth = depthData;
+
+    GLERROR("ScreenCoords::ToPixelData Error");
+
+    return p;
 }
 
-glm::vec3 ScreenCoords::ToPixelData(glm::vec2 screenCoord, FrameBuffer* PickDataBuffer, GLuint DepthBuffer)
+ScreenCoords::PixelData ScreenCoords::ToPixelData(glm::vec2 screenCoord, FrameBuffer* PickDataBuffer, GLuint DepthBuffer)
 {
     return ToPixelData(screenCoord.x, screenCoord.y, PickDataBuffer, DepthBuffer);
 }
+

src/Game/Game.cpp

@@ -1,11 +1,13 @@
 #include "Game.h"
-#include "HardcodedTestWorld.h"
 
 Game::Game(int argc, char* argv[])
 {
+    bool steamResult = SteamAPI_Init();
+
 	ResourceManager::RegisterType<ConfigFile>("ConfigFile");
 	ResourceManager::RegisterType<Model>("Model");
 	ResourceManager::RegisterType<Texture>("Texture");
+    ResourceManager::RegisterType<EntityXMLFile>("EntityXMLFile");
 
 	m_Config = ResourceManager::Load<ConfigFile>("Config.ini");
 	LOG_LEVEL = static_cast<_LOG_LEVEL>(m_Config->Get<int>("Debug.LogLevel", 1));
@@ -16,7 +18,7 @@ Game::Game(int argc, char* argv[])
     m_RenderQueueFactory = new RenderQueueFactory();
 
 	// Create the renderer
-	m_Renderer = new Renderer();
+	m_Renderer = new Renderer(m_EventBroker);
 	m_Renderer->SetFullscreen(m_Config->Get<bool>("Video.Fullscreen", false));
 	m_Renderer->SetVSYNC(m_Config->Get<bool>("Video.VSYNC", false));
 	m_Renderer->SetResolution(Rectangle(
@@ -29,16 +31,29 @@ Game::Game(int argc, char* argv[])
 
 	// Create input manager
 	m_InputManager = new InputManager(m_Renderer->Window(), m_EventBroker);
+    m_InputProxy = new InputProxy(m_EventBroker);
+    m_InputProxy->AddHandler<KeyboardInputHandler>();
+    m_InputProxy->AddHandler<SteamControllerInputHandler>();
 
 	// Create the root level GUI frame
 	m_FrameStack = new GUI::Frame(m_EventBroker);
 	m_FrameStack->Width = m_Renderer->Resolution().Width;
 	m_FrameStack->Height = m_Renderer->Resolution().Height;
 
-    // Create a TEST WORLD
-    m_World = new HardcodedTestWorld();
+    // Create a world
+    m_World = new World();
+    std::string mapToLoad = m_Config->Get<std::string>("Debug.LoadMap", "");
+    if (!mapToLoad.empty()) {
+        ResourceManager::Load<EntityXMLFile>(mapToLoad)->PopulateWorld(m_World);
+    }
+    
+    // Create system pipeline
+    m_SystemPipeline = new SystemPipeline(m_EventBroker);
+    m_SystemPipeline->AddSystem<RaptorCopterSystem>();
 
 	m_LastTime = glfwGetTime();
+
+    testIntialize();
 }
 
 Game::~Game()
@@ -53,13 +68,23 @@ void Game::Tick()
 	double dt = currentTime - m_LastTime;
 	m_LastTime = currentTime;
 
+    SteamAPI_RunCallbacks();
+
+    // Handle input in a weird looking but responsive way
 	m_EventBroker->Swap();
 	m_InputManager->Update(dt);
-	m_Renderer->Update(dt);
+    m_EventBroker->Swap();
+    m_InputProxy->Update(dt);
+    m_EventBroker->Swap();
+    m_InputProxy->Process();
 	m_EventBroker->Swap();
 
-    m_RenderQueueFactory->Update(m_World);
+    // Iterate through systems and update world!
+    m_SystemPipeline->Update(m_World, dt);
+    testTick(dt);
+    m_Renderer->Update(dt);
 
+    m_RenderQueueFactory->Update(m_World);
 	m_Renderer->Draw(m_RenderQueueFactory->RenderQueues());
 
 	m_EventBroker->Swap();
@@ -67,3 +92,51 @@ void Game::Tick()
 
 	glfwPollEvents();
 }
+
+
+bool Game::testOnKeyUp(const Events::KeyUp& e)
+{
+    if (e.KeyCode == GLFW_KEY_R) {
+        std::string mapToLoad = m_Config->Get<std::string>("Debug.LoadMap", "");
+        if (!mapToLoad.empty()) {
+            delete m_World;
+            m_World = new World();
+            ResourceManager::Release("EntityXMLFile", mapToLoad);
+            ResourceManager::Load<EntityXMLFile>(mapToLoad)->PopulateWorld(m_World);
+        }
+    }
+
+    return false;
+}
+
+void Game::testIntialize()
+{
+    EVENT_SUBSCRIBE_MEMBER(m_EKeyUp, &Game::testOnKeyUp);
+
+    {
+        Events::BindOrigin e;
+        e.Origin = "R";
+        e.Command = "DebugReload";
+        e.Value = 1.f;
+        m_EventBroker->Publish(e);
+    }
+    {
+        Events::BindOrigin e;
+        e.Origin = "SteamController";
+        e.Command = "DebugReload";
+        e.Value = 1.f;
+        m_EventBroker->Publish(e);
+    }
+    {
+        Events::BindOrigin e;
+        e.Origin = "X";
+        e.Command = "DebugReload";
+        e.Value = 1.f;
+        m_EventBroker->Publish(e);
+    }
+}
+
+void Game::testTick(double dt)
+{
+    m_EventBroker->Process<Game>();
+}

tools/LiveTexturing/LiveTexturing/main.js

@@ -1,135 +0,0 @@
-/*
- * Copyright (c) 2013 Adobe Systems Incorporated. All rights reserved.
- *  
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"), 
- * to deal in the Software without restriction, including without limitation 
- * the rights to use, copy, modify, merge, publish, distribute, sublicense, 
- * and/or sell copies of the Software, and to permit persons to whom the 
- * Software is furnished to do so, subject to the following conditions:
- *  
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *  
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
- * DEALINGS IN THE SOFTWARE.
- * 
- */
-
-(function () {
-    "use strict";
-    var start = 0;
-    var zmq = require('zmq');
-    var publisher = zmq.socket('pub');
-
-    publisher.bind('tcp://*:5555', function (err) {
-        if (err) {
-            console.log(err);
-        }
-        else {
-            console.log("5555");
-        }
-    });
-
-
-
-    process.on('SIGINT', function () {
-        publisher.close();
-    });
-
-
-    var PLUGIN_ID = require("./package.json").name,
-          MENU_ID = "TeamFisk plugins",
-          MENU_LABEL = "$$$/JavaScripts/Generator/TeamFisk plugins/Menu=Live Texturing RAMDisk";
-
-    var _generator = null;
-
-    // Initialize script here 
-    function init(generator, config) {
-        _generator = generator;
-        _generator.addMenuItem(MENU_ID, MENU_LABEL, true, false)
-           .then(
-               function () {
-                   console.log("Menu created", MENU_ID);
-               }, function () {
-                   console.error("Menu creation failed", MENU_ID);
-               }
-           );
-
-        _generator.onPhotoshopEvent("imageChanged", handleImageChanged);
-    }
-
-    var lastSent = 0;
-    var isSaving = false;
-    function handleImageChanged(document) {
-
-        var start = new Date().getTime();
-        if (start - lastSent > 100 && !isSaving) {
-            isSaving = true;
-            //console.log("DOC: " + document.id);
-            _generator.getDocumentInfo(document.id).then(
-            function (document) {
-                // console.log(new Date().getTime() / 1000);
-                // console.log(stringify(document.timeStamp));
-                //console.log("HELLO 1");
-                //lastSent = document.timeStamp
-                // console.log(stringify(document));
-                //console.log("Received complete document:", stringify(document));
-                //var str = 'var options = new PNGSaveOptions(); app.activeDocument.saveAs (new File("D:/HejHej.png"),options, false);';
-                var str = 'app.activeDocument.save()';
-                
-                _generator.evaluateJSXString(str).then(function () {
-                    isSaving = false;
-                    //console.log("Save succes");
-                    var size = (4 + document.file.length + 1);
-                    var message = new Buffer(size);
-
-                    var offset = 0;
-
-                    //console.log("document.file.length: " + document.file.length);
-                    //console.log("document.fileName: " + document.file);
-
-                    message.writeInt32LE(document.file.length + 1, offset);
-
-                    offset += 4;
-
-                    var fileName = document.file.replace(/\\/g, "/");
-                    message.write(fileName, offset, fileName.length, 'utf8');
-                    offset += fileName.length;
-                    message.writeUInt8(0, offset); //Null byte
-                    offset += 1;
-
-                    publisher.send(message);
-
-                    var asd = new Date().getTime();
-                    var time = asd - start;
-                    //console.log(time);
-                    lastSent = new Date().getTime();
-                    //console.log("LastSent: " + lastSent);
-                    
-                },
-                function () {
-                    console.log("Save Failure");
-                    isSaving = false;
-                }).done();
-            });
-        }
-    }
-
-    function stringify(object) {
-        try {
-            return JSON.stringify(object, null, "    ");
-        } catch (e) {
-            console.error(e);
-        }
-        return String(object);
-    }
-
-    //Declare entery function in the script
-    exports.init = init;
-}());

tools/LiveTexturing/LiveTexturing/node_modules/zmq/.editorconfig

@@ -1,15 +0,0 @@
-root = true
-
-[*]
-end_of_line = lf
-charset = utf-8
-trim_trailing_whitespace = true
-
-[*.js]
-indent_style = space
-indent_size = 2
-
-[*.cc]
-indent_style = space
-indent_size = 2
-

tools/LiveTexturing/LiveTexturing/node_modules/zmq/.npmignore

@@ -1,13 +0,0 @@
-*.swp
-*.swo
-*.o
-build
-*.lock*
-binding.node
-examples/stress-test-client
-node_modules
-Makefile.gyp
-binding.Makefile
-binding.target.gyp.mk
-gyp-mac-tool
-out/

tools/LiveTexturing/LiveTexturing/node_modules/zmq/.travis.yml

@@ -1,37 +0,0 @@
-addons:
-  apt:
-    sources:
-    - ubuntu-toolchain-r-test
-    packages:
-    - g++-4.8
-env:
- - ZMQ="git://github.com/zeromq/zeromq2-x.git"
- - ZMQ="git://github.com/zeromq/zeromq3-x.git -b v3.1.0"
- - ZMQ="git://github.com/zeromq/zeromq3-x.git -b v3.2.5"
- - ZMQ="git://github.com/zeromq/zeromq4-x.git -b v4.0.5" SODIUM="git://github.com/jedisct1/libsodium.git -b 0.4.5"
-before_install:
- - export CXX=g++-4.8
- - sudo apt-get install uuid-dev
- - '[ -z "$SODIUM" ] || git clone --depth 1 $SODIUM libsodium'
- - '[ -z "$SODIUM" ] || cd libsodium'
- - '[ -z "$SODIUM" ] || ./autogen.sh'
- - '[ -z "$SODIUM" ] || ./configure'
- - '[ -z "$SODIUM" ] || make'
- - '[ -z "$SODIUM" ] || sudo make install'
- - '[ -z "$SODIUM" ] || cd ..'
- - git clone --depth 1 $ZMQ zmqlib
- - cd zmqlib
- - ./autogen.sh
- - ./configure
- - make
- - sudo make install
- - sudo /sbin/ldconfig
- - cd ..
-language: node_js
-node_js:
- - "0.8"
- - "0.10"
- - "0.12"
- - "4"
- - "5"
-script: travis_retry npm test

tools/LiveTexturing/LiveTexturing/node_modules/zmq/History.md

@@ -1,154 +0,0 @@
-2.14.0 / 2015-11-20
-===================
-
-  * A socket.read() method was added to retrieve messages while paused [sshutovskyi]
-  * socket.send() now takes a callback as 3rd argument which is called once the message is sent [ronkorving]
-  * Now tested on Node.js 0.8, 0.10, 0.12, 4 and 5 [ronkorving]
-
-2.13.0 / 2015-08-26
-===================
-
-  * io.js 3.x compatible [kkoopa]
-  * corrections to type casting operations [kkoopa]
-  * "make clean" now also removes node_modules [reqshark]
-
-2.12.0 / 2015-07-10
-===================
-
-  * Massive improvements to monitoring code, with new documentation and tests [ValYouW]
-  * Improved documentation [reqshark]
-  * Updated bindings from ~1.1.1 to ~1.2.1 [reqshark]
-  * Test suite improvements [reqshark]
-  * Updated the Windows bundle to ZeroMQ 4.0.4 [kkoopa]
-  * License attribute added to package.json [pdehaan]
-
-2.11.1 / 2015-05-21
-===================
-
-  * io.js 2.x compatible [transcranial]
-  * replaced asserts with proper exceptions [reqshark]
-
-2.11.0 / 2015-03-31
-===================
-
-  * Added pause() and resume() APIs on sockets to allow backpressure [philip1986]
-  * Elegant handling of EINTR return codes [hurricaneLTG]
-  * Small performance improvements in send() and internal flush methods [ronkorving]
-  * Updated test suite to cover io.js and Node 0.12 (removed 0.11) [ronkorving]
-  * Added "make perf" for easy benchmarking [ronkorving]
-
-2.10.0 / 2015-01-22
-===================
-
-  * Added ZMQ_STREAM socket type [reqshark]
-  * Update NAN to io.js compatible 1.5.0 [kkoopa]
-  * Hitting open file descriptor limit now throws an error during zmq.socket() [briansorahan]
-  * More reliable benchmarking [maxired]
-
-2.9.0 / 2015-01-05
-==================
-
-  * More unit tests [bluebery and reqshark]
-  * More reliable testing [f34rdotcom and kkoopa]
-  * Improved ReadMe [dminkovsky and skibz]
-  * Support for zmq_proxy sockets [reqshark]
-  * Removed "docs" and related deps in favor of ReadMe [reqshark]
-
-2.8.0 / 2014-08-27
-==================
-
-  * Fixed: monitor API would keep CPU busy at 100% [f34rdotcom]
-  * Fixed: an exception during flush could render a socket unusable [ronkorving]
-  * Fixed: Travis changed behavior and broke our tests [ronkorving]
-  * Code cleanup [kkoopa and ronkorving]
-  * Removed legacy nextTick event emission during flush [utvara and ronkorving]
-  * Context API added: setMaxThreads, getMaxThreads, setMaxSockets, getMaxSockets [yoneal]
-  * Changed unit test suite to Mocha [skeggse and yoneal]
-  * NAN updated to ~1.3.0 [kkoopa]
-
-2.7.0 / 2014-04-24
-==================
-
-  * Fixed memory leak when closing socket [rasky]
-  * Fixed high water mark [soplwang, kkoopa]
-  * Added socket opts for zeromq 4.x security mechanisms [msealand]
-  * Use MakeCallback [kkoopa]
-  * Remove useless setImmediate [kkoopa]
-  * Use `zmq_msg_send` for ZMQ >= 4.0 [kkoopa]
-  * Expose the Socket class as zmq.Socket [tcr]
-
-2.6.0 / 2014-01-23
-==================
-
-  * Monitor support [f34rdotcom, dr-fozzy]
-  * Unbind support [kkoopa]
-  * Node 0.11.9 compatibility [kkoopa]
-  * Support for ZMQ 4 [atrniv]
-  * Fixed memory leak [utvara]
-  * OSX Homebrew support [jwalton]
-  * Fix unit tests [ryanlelek]
-
-2.5.1 / 2013-08-28
-==================
-
-  * Regression fix for IPC socket bind failure [christopherobin]
-
-2.5.0 / 2013-08-20
-==================
-
-  * Added testing against Node.js v0.11 [AlexeyKupershtokh]
-  * Add support for Joyent SmartMachines [JonGretar]
-  * Use pkg-config on OS X too [blalor]
-  * Patch for Node 0.11.3 [kkoopa]
-  * Fix for bind / connect / send problem [kkoopa]
-  * Fixed multiple bugs in perf tests and changed them to push/pull [ronkorving]
-  * Add definitions for building on openbsd & freebsd [Minjung]
-
-2.4.0 / 2013-04-09
-==================
-
-  * added: Windows support [mscdex]
-  * added: support for all options ever [AlexeyKupershtokh]
-  * fixed: prevent zeromq sockets from being destroyed by GC [AlexeyKupershtokh]
-
-2.3.0 / 2013-03-15
-==================
-
-  * added: xpub/xsub socket types [xla]
-  * added: support for zmq_disconnect [matehat]
-  * added: LAST_ENDPOINT socket option [ronkorving]
-  * added: local/remote_lat local/remote_thr perf test [wavded]
-  * fixed: tests improved [qubyte, jeremybarnes, ronkorving]
-  * fixed: Node v0.9.4+ compatibility [mscdex]
-  * fixed: SNDHWM and RCVHWM options were given the wrong type [freehaha]
-  * removed: waf support [mscdex]
-
-2.2.0 / 2012-10-17
-==================
-
-  * add support for pkg-config
-  * add libzmq 3.x support [aaudis]
-  * fix: prevent GC happening too soon for connect/bindSync
-
-2.1.0 / 2012-06-29
-==================
-
-  * fix require() for 0.8.0
-  * change: use uv_poll in place of IOWatcher
-  * remove stupid engines field
-
-2.0.3 / 2012-03-14
-==================
-
-  * Removed -Wall (libuv unused vars caused the build to fail...)
-
-2.0.2 / 2012-02-16
-==================
-
-  * Added back `.createSocket()` for BC. Closes #86
-
-2.0.1 / 2012-01-26
-==================
-
-  * Added `.zmqVersion` [patricklucas]
-  * Fixed multipart support [joshrtay]

tools/LiveTexturing/LiveTexturing/node_modules/zmq/LICENSE

@@ -1,20 +0,0 @@
-Copyright (c) 2011 TJ Holowaychuk
-Copyright (c) 2010, 2011 Justin Tulloss
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.

tools/LiveTexturing/LiveTexturing/node_modules/zmq/Makefile

@@ -1,18 +0,0 @@
-
-build/Release/binding.node: binding.cc binding.gyp
-	npm install
-
-test:
-	npm test
-
-clean:
-	rm -fr build node_modules
-
-distclean:
-	node-gyp clean
-
-perf:
-	node perf/local_lat.js tcp://127.0.0.1:5555 1 100000& node perf/remote_lat.js tcp://127.0.0.1:5555 1 100000
-	node perf/local_thr.js tcp://127.0.0.1:5556 1 100000& node perf/remote_thr.js tcp://127.0.0.1:5556 1 100000
-
-.PHONY: test clean distclean perf

tools/LiveTexturing/LiveTexturing/node_modules/zmq/README.md

@@ -1,224 +0,0 @@
-# zmq   [![Build Status](https://travis-ci.org/JustinTulloss/zeromq.node.png)](https://travis-ci.org/JustinTulloss/zeromq.node)  [![Build status](https://ci.appveyor.com/api/projects/status/n0h0sjs127eadfuo/branch/windowsbuild?svg=true)](https://ci.appveyor.com/project/reqshark/zeromq-node)
-
-[ØMQ](http://www.zeromq.org/) bindings for node.js.
-
-## Installation
-
-### on Windows:
-First install [Visual Studio](https://www.visualstudio.com/) and either
-[Node.js](https://nodejs.org/download/) or [io.js](https://iojs.org/dist/latest/).
-
-Ensure you're building zmq from a conservative location on disk, one without
-unusual characters or spaces, for example somewhere like: `C:\sources\myproject`.
-
-Installing the ZeroMQ library is optional and not required on Windows. We
-recommend running `npm install` and node executable commands from a
-[github for windows](https://windows.github.com/) shell or similar environment.
-
-### installing on Unix/POSIX (and osx):
-
-First install `pkg-config` and the [ZeroMQ library](http://www.zeromq.org/intro:get-the-software).
-
-This module is compatible with ZeroMQ versions 2, 3 and 4. The installation
-process varies by platform, but headers are mandatory. Most Linux distributions
-provide these headers with `-devel` packages like `zeromq-devel` or
-`zeromq3-devel`. Homebrew for OS X provides versions 4 and 3 with packages
-`zeromq` and `zeromq3`, respectively. A
-[Chris Lea PPA](https://launchpad.net/~chris-lea/+archive/ubuntu/zeromq)
-is available for Debian-like users who want a version newer than currently
-provided by their distribution. Windows is supported but not actively
-maintained.
-
-Note: For zap support with versions >=4 you need to have libzmq built and linked
-against libsodium. Check the [Travis configuration](.travis.yml) for a list of what is tested
-and therefore known to work.
-
-#### with your platform-specifics taken care of, install and use this module:
-
-    $ npm install zmq
-
-## Examples
-
-### Push/Pull
-
-```js
-// producer.js
-var zmq = require('zmq')
-  , sock = zmq.socket('push');
-
-sock.bindSync('tcp://127.0.0.1:3000');
-console.log('Producer bound to port 3000');
-
-setInterval(function(){
-  console.log('sending work');
-  sock.send('some work');
-}, 500);
-```
-
-```js
-// worker.js
-var zmq = require('zmq')
-  , sock = zmq.socket('pull');
-
-sock.connect('tcp://127.0.0.1:3000');
-console.log('Worker connected to port 3000');
-
-sock.on('message', function(msg){
-  console.log('work: %s', msg.toString());
-});
-```
-
-### Pub/Sub
-
-```js
-// pubber.js
-var zmq = require('zmq')
-  , sock = zmq.socket('pub');
-
-sock.bindSync('tcp://127.0.0.1:3000');
-console.log('Publisher bound to port 3000');
-
-setInterval(function(){
-  console.log('sending a multipart message envelope');
-  sock.send(['kitty cats', 'meow!']);
-}, 500);
-```
-
-```js
-// subber.js
-var zmq = require('zmq')
-  , sock = zmq.socket('sub');
-
-sock.connect('tcp://127.0.0.1:3000');
-sock.subscribe('kitty cats');
-console.log('Subscriber connected to port 3000');
-
-sock.on('message', function(topic, message) {
-  console.log('received a message related to:', topic, 'containing message:', message);
-});
-```
-## Monitoring
-
-You can get socket state changes events by calling to the `monitor` function.
-The supported events are (see ZMQ [docs](http://api.zeromq.org/4-2:zmq-socket-monitor) for full description):
-* connect - ZMQ_EVENT_CONNECTED
-* connect_delay - ZMQ_EVENT_CONNECT_DELAYED
-* connect_retry - ZMQ_EVENT_CONNECT_RETRIED
-* listen - ZMQ_EVENT_LISTENING
-* bind_error - ZMQ_EVENT_BIND_FAILED
-* accept - ZMQ_EVENT_ACCEPTED
-* accept_error - ZMQ_EVENT_ACCEPT_FAILED
-* close - ZMQ_EVENT_CLOSED
-* close_error - ZMQ_EVENT_CLOSE_FAILED
-* disconnect - ZMQ_EVENT_DISCONNECTED
-
-All events get 2 arguments:
-* fd - The file descriptor of the underlying socket (if available)
-* endpoint - The underlying socket endpoint
-
-A special `monitor_error` event will be raised when there was an error in the monitoring process, after this event no more
-monitoring events will be sent, you can try and call `monitor` again to restart the monitoring process.
-
-### monitor(interval, numOfEvents)
-Will create an inproc PAIR socket where zmq will publish socket state changes events, the events from this socket will
-be read every `interval` (defaults to 10ms).
-By default only 1 message will be read every interval, this can be configured by using the `numOfEvents` parameter,
-where passing 0 will read all available messages per interval.
-
-### unmonitor()
-Stop the monitoring process
-
-### example
-
-```js
-// Create a socket
-var zmq = require('zmq');
-socket = zmq.socket('req');
-
-// Register to monitoring events
-socket.on('connect', function(fd, ep) {console.log('connect, endpoint:', ep);});
-socket.on('connect_delay', function(fd, ep) {console.log('connect_delay, endpoint:', ep);});
-socket.on('connect_retry', function(fd, ep) {console.log('connect_retry, endpoint:', ep);});
-socket.on('listen', function(fd, ep) {console.log('listen, endpoint:', ep);});
-socket.on('bind_error', function(fd, ep) {console.log('bind_error, endpoint:', ep);});
-socket.on('accept', function(fd, ep) {console.log('accept, endpoint:', ep);});
-socket.on('accept_error', function(fd, ep) {console.log('accept_error, endpoint:', ep);});
-socket.on('close', function(fd, ep) {console.log('close, endpoint:', ep);});
-socket.on('close_error', function(fd, ep) {console.log('close_error, endpoint:', ep);});
-socket.on('disconnect', function(fd, ep) {console.log('disconnect, endpoint:', ep);});
-
-// Handle monitor error
-socket.on('monitor_error', function(err) {
-	console.log('Error in monitoring: %s, will restart monitoring in 5 seconds', err);
-	setTimeout(function() { socket.monitor(500, 0); }, 5000);
-});
-
-// Call monitor, check for events every 500ms and get all available events.
-console.log('Start monitoring...');
-socket.monitor(500, 0);
-socket.connect('tcp://127.0.0.1:1234');
-
-setTimeout(function() {
-	console.log('Stop the monitoring...');
-	socket.unmonitor();
-}, 20000);
-
-```
-
-## Running tests
-
-#### Install dev deps:
-```sh
-$ git clone https://github.com/JustinTulloss/zeromq.node.git zmq && cd zmq
-$ npm i
-```
-#### Build:
-```sh
-# on unix:
-$ make
-
-# building on windows:
-> npm i
-```
-#### Test:
-```sh
-# on unix:
-$ make test
-
-# testing on windows:
-> npm t
-```
-## Running benchmarks
-
-Benchmarks are available in the `perf` directory, and have been implemented
-according to the zmq documentation:
-[How to run performance tests](http://www.zeromq.org/results:perf-howto)
-
-In the following examples, the arguments are respectively:
-- the host to connect to/bind on
-- message size (in bytes)
-- message count
-
-You can run a latency benchmark by running these two commands in two separate
-shells:
-
-```sh
-node ./local_lat.js tcp://127.0.0.1:5555 1 100000
-```
-
-```sh
-node ./remote_lat.js tcp://127.0.0.1:5555 1 100000
-```
-
-And you can run throughput tests by running these two commands in two
-separate shells:
-
-```sh
-node ./local_thr.js tcp://127.0.0.1:5555 1 100000
-```
-
-```sh
-node ./remote_thr.js tcp://127.0.0.1:5555 1 100000
-```
-
-Running `make perf` will run the commands listed above.

tools/LiveTexturing/LiveTexturing/node_modules/zmq/appveyor.yml

@@ -1,24 +0,0 @@
-environment:
-  matrix:
-    - nodejs_version: "0.10"
-    - nodejs_version: "0.12"
-    - nodejs_version: "2"
-
-#platform:
-#  - x86
-#  - x64
-
-install:
-  - ps: Install-Product node $env:nodejs_version #$env:platform
-  - npm install
-
-test_script:
-  - node --version
-  - npm --version
-  - npm test
-
-build: off
-
-matrix:
-  allow_failures:
-    - nodejs_version: "2"

tools/LiveTexturing/LiveTexturing/node_modules/zmq/binding.gyp

@@ -1,76 +0,0 @@
-{
-  'targets': [
-    {
-      'target_name': 'zmq',
-      'sources': [ 'binding.cc' ],
-      'include_dirs' : [
-        "<!(node -e \"require('nan')\")"
-      ],
-      'conditions': [
-        ['OS=="win"', {
-          'win_delay_load_hook': 'true',
-          'include_dirs': ['windows/include'],
-          'link_settings': {
-            'libraries': [
-              'Delayimp.lib',
-            ],
-            'conditions': [
-              ['target_arch=="ia32"', {
-                'libraries': [
-                  '<(PRODUCT_DIR)/../../windows/lib/x86/libzmq-v100-mt-4_0_4.lib',
-                ]
-              },{
-                'libraries': [
-                  '<(PRODUCT_DIR)/../../windows/lib/x64/libzmq-v100-mt-4_0_4.lib',
-                ]
-              }]
-            ],
-          },
-          'msvs_settings': {
-            'VCLinkerTool': {
-              'DelayLoadDLLs': ['libzmq-v100-mt-4_0_4.dll']
-            }
-          },
-        }, {
-          'libraries': ['-lzmq'],
-          'cflags!': ['-fno-exceptions'],
-          'cflags_cc!': ['-fno-exceptions'],
-        }],
-        ['OS=="mac" or OS=="solaris"', {
-          'xcode_settings': {
-            'GCC_ENABLE_CPP_EXCEPTIONS': 'YES'
-          },
-          # add macports include & lib dirs, homebrew include & lib dirs
-          'include_dirs': [
-            '<!@(pkg-config libzmq --cflags-only-I | sed s/-I//g)',
-            '/opt/local/include',
-            '/usr/local/include',
-          ],
-          'libraries': [
-            '<!@(pkg-config libzmq --libs)',
-            '-L/opt/local/lib',
-            '-L/usr/local/lib',
-          ]
-        }],
-        ['OS=="openbsd" or OS=="freebsd"', {
-          'include_dirs': [
-            '<!@(pkg-config libzmq --cflags-only-I | sed s/-I//g)',
-            '/usr/local/include',
-          ],
-          'libraries': [
-            '<!@(pkg-config libzmq --libs)',
-            '-L/usr/local/lib',
-          ]
-        }],
-        ['OS=="linux"', {
-          'cflags': [
-            '<!(pkg-config libzmq --cflags 2>/dev/null || echo "")',
-          ],
-          'libraries': [
-            '<!(pkg-config libzmq --libs 2>/dev/null || echo "")',
-          ],
-        }],
-      ]
-    }
-  ]
-}

tools/LiveTexturing/LiveTexturing/node_modules/zmq/examples/dealer_router.js

@@ -1,54 +0,0 @@
-/*
- *
- * One client two servers (round roobin)
- *
- */
-
-var cluster = require('cluster')
-  , zmq = require('../')
-  , port = 'tcp://127.0.0.1:12345';
-
-if (cluster.isMaster) {
-  for (var i = 0; i < 2; i++) cluster.fork();
-
-  cluster.on('death', function(worker) {
-    console.log('worker ' + worker.pid + ' died');
-  });
-
-  //dealer = client
-
-  var socket = zmq.socket('dealer');
-
-  socket.identity = 'client' + process.pid;
-
-  socket.bind(port, function(err) {
-    if (err) throw err;
-    console.log('bound!');
-
-    setInterval(function() {
-      var value = Math.floor(Math.random()*100);
-
-      console.log(socket.identity + ': asking ' + value);
-      socket.send(value);
-    }, 100);
-
-
-    socket.on('message', function(data) {
-      console.log(socket.identity + ': answer data ' + data);
-    });
-  });
-} else {
-  //router = server
-
-  var socket = zmq.socket('router');
-
-  socket.identity = 'server' + process.pid;
-
-  socket.connect(port);
-  console.log('connected!');
-
-  socket.on('message', function(envelope, data) {
-    console.log(socket.identity + ': received ' + envelope + ' - ' + data.toString());
-    socket.send([envelope, data * 2]);
-  });
-}

tools/LiveTexturing/LiveTexturing/node_modules/zmq/examples/devices/forwarder.js

@@ -1,69 +0,0 @@
-/*
- *
- * Forwarder device
- *
- */
-
-var zmq = require('../../')
-    , frontPort = 'tcp://127.0.0.1:12345'
-    , backPort = 'tcp://127.0.0.1:12346';
-
-function createClient (port) {
-    var socket = zmq.socket('pub');
-
-    socket.identity = 'client' + process.pid;
-
-    socket.connect(port);
-    console.log('client connected!');
-
-    setInterval(function() {
-        var value = Math.floor(Math.random()*100);
-
-        console.log(socket.identity + ': broadcasting ' + value);
-        socket.send(value);
-    }, 100);
-};
-
-function createWorker (port) {
-    var socket = zmq.socket('sub');
-
-    socket.identity = 'worker' + process.pid;
-
-    socket.subscribe('');
-    socket.on('message', function(data) {
-        console.log(socket.identity + ': got ' + data.toString());
-    });
-
-    socket.connect(port, function(err) {
-        if (err) throw err;
-        console.log('worker connected!');
-    });
-};
-
-function createForwarderDevice(frontPort, backPort) {
-    var frontSocket = zmq.socket('sub'),
-        backSocket = zmq.socket('pub');
-
-    frontSocket.identity = 'sub' + process.pid;
-    backSocket.identity = 'pub' + process.pid;
-
-    frontSocket.subscribe('');
-    frontSocket.bind(frontPort, function (err) {
-        console.log('bound', frontPort);
-    });
-    
-    frontSocket.on('message', function() {
-        //pass to back
-        console.log('forwarder: recasting', arguments[0].toString());
-        backSocket.send(Array.prototype.slice.call(arguments));
-    });
-
-    backSocket.bind(backPort, function (err) {
-        console.log('bound', backPort);
-    });
-}
-
-createForwarderDevice(frontPort, backPort);
-
-createClient(frontPort);
-createWorker(backPort);   

tools/LiveTexturing/LiveTexturing/node_modules/zmq/examples/devices/queue.js

@@ -1,78 +0,0 @@
-/*
- *
- * Queue device
- *
- */
-
-var zmq = require('../../')
-    , frontPort = 'tcp://127.0.0.1:12345'
-    , backPort = 'tcp://127.0.0.1:12346';
-
-function createClient (port) {
-    var socket = zmq.socket('req');
-
-    socket.identity = 'client' + process.pid;
-
-    socket.on('message', function(data) {
-        console.log(socket.identity + ': answer data ' + data);
-    });
-
-    socket.connect(port);
-    console.log('client connected!');
-
-    setInterval(function() {
-        var value = Math.floor(Math.random()*100);
-
-        console.log(socket.identity + ': asking ' + value);
-        socket.send(value);
-    }, 100);
-};
-
-function createServer (port) {
-    var socket = zmq.socket('rep');
-
-    socket.identity = 'server' + process.pid;
-
-    socket.on('message', function(data) {
-        console.log(socket.identity + ': received ' + data.toString());
-        socket.send(data * 2);
-    });
-
-    socket.connect(port, function(err) {
-        if (err) throw err;
-        console.log('server connected!');
-    });
-};
-
-function createQueueDevice(frontPort, backPort) {
-    var frontSocket = zmq.socket('router'),
-        backSocket = zmq.socket('dealer');
-
-    frontSocket.identity = 'router' + process.pid;
-    backSocket.identity = 'dealer' + process.pid;
-    
-    frontSocket.bind(frontPort, function (err) {
-        console.log('bound', frontPort);
-    });
-    
-    frontSocket.on('message', function() {
-        //pass to back
-        console.log('router: sending to server', arguments[0].toString(), arguments[2].toString());
-        backSocket.send(Array.prototype.slice.call(arguments));
-    });
-
-    backSocket.bind(backPort, function (err) {
-        console.log('bound', backPort);
-    });
-    
-    backSocket.on('message', function() {
-        //pass to front
-        console.log('dealer: sending to client', arguments[0].toString(), arguments[2].toString());
-        frontSocket.send(Array.prototype.slice.call(arguments));
-    });
-}
-
-createQueueDevice(frontPort, backPort);
-
-createClient(frontPort);
-createServer(backPort);   

tools/LiveTexturing/LiveTexturing/node_modules/zmq/examples/devices/streamer.js

@@ -1,67 +0,0 @@
-/*
- *
- * Forwarder device
- *
- */
-
-var zmq = require('../../')
-    , frontPort = 'tcp://127.0.0.1:12345'
-    , backPort = 'tcp://127.0.0.1:12346';
-
-function createClient (port) {
-    var socket = zmq.socket('push');
-
-    socket.identity = 'client' + process.pid;
-
-    socket.connect(port);
-    console.log('client connected!');
-
-    setInterval(function() {
-        var value = Math.floor(Math.random()*100);
-
-        console.log(socket.identity + ': pushing ' + value);
-        socket.send(value);
-    }, 100);
-};
-
-function createWorker (port) {
-    var socket = zmq.socket('pull');
-
-    socket.identity = 'worker' + process.pid;
-
-    socket.on('message', function(data) {
-        console.log(socket.identity + ': pulled ' + data.toString());
-    });
-
-    socket.connect(port, function(err) {
-        if (err) throw err;
-        console.log('worker connected!');
-    });
-};
-
-function createStreamerDevice(frontPort, backPort) {
-    var frontSocket = zmq.socket('pull'),
-        backSocket = zmq.socket('push');
-
-    frontSocket.identity = 'sub' + process.pid;
-    backSocket.identity = 'pub' + process.pid;
-
-    frontSocket.bind(frontPort, function (err) {
-        console.log('bound', frontPort);
-    });
-
-    frontSocket.on('message', function() {
-        //pass to back
-        console.log('forwarder: sending downstream', arguments[0].toString());
-        backSocket.send(Array.prototype.slice.call(arguments));
-    });
-
-    backSocket.bind(backPort, function (err) {
-        console.log('bound', backPort);
-    });
-}
-
-createStreamerDevice(frontPort, backPort);
-
-createClient(frontPort);
-createWorker(backPort);   

tools/LiveTexturing/LiveTexturing/node_modules/zmq/examples/pub_sub.js

@@ -1,55 +0,0 @@
-/*
- *
- * Publisher subscriber pattern
- *
- */
-
-var cluster = require('cluster')
-  , zmq = require('../')
-  , port = 'tcp://127.0.0.1:12345';
-
-if (cluster.isMaster) {
-  for (var i = 0; i < 2; i++) cluster.fork();
-
-  cluster.on('death', function(worker) {
-    console.log('worker ' + worker.pid + ' died');
-  });
-  
-  //publisher = send only
-  
-  var socket = zmq.socket('pub');
-
-  socket.identity = 'publisher' + process.pid;
-  
-  var stocks = ['AAPL', 'GOOG', 'YHOO', 'MSFT', 'INTC'];
-
-  socket.bind(port, function(err) {
-    if (err) throw err;
-    console.log('bound!');
-    
-    setInterval(function() {
-      var symbol = stocks[Math.floor(Math.random()*stocks.length)]
-        , value = Math.random()*1000;
-
-      console.log(socket.identity + ': sent ' + symbol + ' ' + value);
-      socket.send(symbol + ' ' + value);
-    }, 100);
-  });
-} else {
-  //subscriber = receive only
-  
-  var socket = zmq.socket('sub');
-
-  socket.identity = 'subscriber' + process.pid;
-  
-  socket.connect(port);
-  
-  socket.subscribe('AAPL');
-  socket.subscribe('GOOG');
-
-  console.log('connected!');
-
-  socket.on('message', function(data) {
-    console.log(socket.identity + ': received data ' + data.toString());
-  });
-}

tools/LiveTexturing/LiveTexturing/node_modules/zmq/examples/push_pull.js

@@ -1,48 +0,0 @@
-/*
- *
- * Pipeline
- *
- */
-
-var cluster = require('cluster')
-  , zmq = require('../')
-  , port = 'tcp://127.0.0.1:12345';
-
-if (cluster.isMaster) {
-  for (var i = 0; i < 2; i++) cluster.fork();
-
-  cluster.on('death', function(worker) {
-    console.log('worker ' + worker.pid + ' died');
-  });
-  
-  //push = upstream
-  
-  var socket = zmq.socket('push');
-
-  socket.identity = 'upstream' + process.pid;
-
-  socket.bind(port, function(err) {
-    if (err) throw err;
-    console.log('bound!');
-
-    setInterval(function() {
-      var date = new Date();
-
-      console.log(socket.identity + ': sending data ' + date.toString());
-      socket.send(date.toString());
-    }, 500);
-  });
-} else {
-  //pull = downstream
-  
-  var socket = zmq.socket('pull');
-
-  socket.identity = 'downstream' + process.pid;
-  
-  socket.connect(port);
-  console.log('connected!');
-
-  socket.on('message', function(data) {
-    console.log(socket.identity + ': received data ' + data.toString());
-  });
-}

tools/LiveTexturing/LiveTexturing/node_modules/zmq/examples/rep_req.js

@@ -1,53 +0,0 @@
-/*
- *
- * One responseder two requesters
- *
- */
-
-var cluster = require('cluster')
-  , zmq = require('../')
-  , port = 'tcp://127.0.0.1:12345';
-
-if (cluster.isMaster) {
-  for (var i = 0; i < 2; i++) cluster.fork();
-
-  cluster.on('death', function(worker) {
-      console.log('worker ' + worker.pid + ' died');
-  });
-  
-  //responseder = server
-  
-  var socket = zmq.socket('rep');
-
-  socket.identity = 'server' + process.pid;
-
-  socket.bind(port, function(err) {
-    if (err) throw err;
-    console.log('bound!');
-
-    socket.on('message', function(data) {
-      console.log(socket.identity + ': received ' + data.toString());
-      socket.send(2 * data);
-    });
-  });
-} else {
-  //requester = client
-  
-  var socket = zmq.socket('req');
-
-  socket.identity = 'client' + process.pid;
-  
-  socket.connect(port);
-  console.log('connected!');
-
-  setInterval(function() {
-    var value = Math.floor(Math.random()*100);
-      
-    socket.send(value);
-    console.log(socket.identity + ': asking ' + value);
-  }, 100);
-
-  socket.on('message', function(data) {
-    console.log(socket.identity + ': answer data ' + data);
-  });
-}

tools/LiveTexturing/LiveTexturing/node_modules/zmq/examples/req_rep.js

@@ -1,57 +0,0 @@
-/*
- *
- * One requester two responders (round robin)
- *
- */
-
-var cluster = require('cluster')
-    , zeromq = require('../')
-    , port = 'tcp://127.0.0.1:12345';
-
-if (cluster.isMaster) {
-    //Fork servers.
-    for (var i = 0; i < 2; i++) {
-        cluster.fork();
-    }
-
-    cluster.on('death', function(worker) {
-        console.log('worker ' + worker.pid + ' died');
-    });
-
-    //requester = client
-
-    var socket = zeromq.socket('req');
-
-    socket.identity = 'client' + process.pid;
-
-    socket.bind(port, function(err) {
-        if (err) throw err;
-        console.log('bound!');
-
-        setInterval(function() {
-            var value = Math.floor(Math.random()*100);
-
-            console.log(socket.identity + ': asking ' + value);
-            socket.send(value);
-        }, 100);
-
-
-        socket.on('message', function(data) {
-            console.log(socket.identity + ': answer data ' + data);
-        });
-    });
-} else {
-    //responder = server
-
-    var socket = zeromq.socket('rep');
-
-    socket.identity = 'server' + process.pid;
-
-    socket.connect(port);
-    console.log('connected!');
-
-    socket.on('message', function(data) {
-        console.log(socket.identity + ': received ' + data.toString());
-        socket.send(data * 2);
-    });
-}

tools/LiveTexturing/LiveTexturing/node_modules/zmq/examples/router_dealer.js

@@ -1,53 +0,0 @@
-/*
- * 
- * One server two clients
- *
- */
-
-var cluster = require('cluster')
-  , zeromq = require('../')
-  , port = 'tcp://127.0.0.1:12345';
-
-if (cluster.isMaster) {
-  for (var i = 0; i < 2; i++) cluster.fork();
-
-  cluster.on('death', function(worker) {
-    console.log('worker ' + worker.pid + ' died');
-  });
-
-  //router = server
-
-  var socket = zeromq.socket('router');
-
-  socket.identity = 'server' + process.pid;
-
-  socket.bind(port, function(err) {
-    if (err) throw err;
-    console.log('bound!');
-
-    socket.on('message', function(envelope, data) {
-      console.log(socket.identity + ': received ' + envelope + ' - ' + data.toString());
-      socket.send([envelope, data * 2]);
-    });
-  });
-} else {
-  //dealer = client
-
-  var socket = zeromq.socket('dealer');
-
-  socket.identity = 'client' + process.pid;
-
-  socket.connect(port);
-  console.log('connected!');
-
-  setInterval(function() {
-    var value = Math.floor(Math.random()*100);
-
-    socket.send(value);
-    console.log(socket.identity + ': asking ' + value);
-  }, 100);
-
-  socket.on('message', function(data) {
-    console.log(socket.identity + ': answer data ' + data);
-  });
-}

tools/LiveTexturing/LiveTexturing/node_modules/zmq/examples/rpc.js

@@ -1,17 +0,0 @@
-
-/**
- * One server two clients
- */
-
-var cluster = require('cluster')
-  , zmq = require('../')
-  , port = 'tcp://127.0.0.1:12345';
-
-if (cluster.isMaster) {
-  for (var i = 0; i < 2; i++) cluster.fork();
-
-  
-} else {
-  var sock = zmq.socket('dealer');
-  sock.connect(port);
-}

tools/LiveTexturing/LiveTexturing/node_modules/zmq/examples/workers/producer.js

@@ -1,11 +0,0 @@
-
-var zmq = require('../../')
-  , sock = zmq.socket('push');
-
-sock.bindSync('tcp://127.0.0.1:3000');
-console.log('Producer bound to port 3000');
-
-setInterval(function(){
-  console.log('sending work');
-  sock.send('some work');
-}, 500);

tools/LiveTexturing/LiveTexturing/node_modules/zmq/examples/workers/worker.js

@@ -1,10 +0,0 @@
-
-var zmq = require('../../')
-  , sock = zmq.socket('pull');
-
-sock.connect('tcp://127.0.0.1:3000');
-console.log('Worker connected to port 3000');
-
-sock.on('message', function(msg){
-  console.log('work: %s', msg.toString());
-});

tools/LiveTexturing/LiveTexturing/node_modules/zmq/index.js

@@ -1,2 +0,0 @@
-
-module.exports = require('./lib');

tools/LiveTexturing/LiveTexturing/node_modules/zmq/node_modules/bindings/README.md

@@ -1,97 +0,0 @@
-node-bindings
-=============
-### Helper module for loading your native module's .node file
-
-This is a helper module for authors of Node.js native addon modules.
-It is basically the "swiss army knife" of `require()`ing your native module's
-`.node` file.
-
-Throughout the course of Node's native addon history, addons have ended up being
-compiled in a variety of different places, depending on which build tool and which
-version of node was used. To make matters worse, now the _gyp_ build tool can
-produce either a _Release_ or _Debug_ build, each being built into different
-locations.
-
-This module checks _all_ the possible locations that a native addon would be built
-at, and returns the first one that loads successfully.
-
-
-Installation
-------------
-
-Install with `npm`:
-
-``` bash
-$ npm install bindings
-```
-
-Or add it to the `"dependencies"` section of your _package.json_ file.
-
-
-Example
--------
-
-`require()`ing the proper bindings file for the current node version, platform
-and architecture is as simple as:
-
-``` js
-var bindings = require('bindings')('binding.node')
-
-// Use your bindings defined in your C files
-bindings.your_c_function()
-```
-
-
-Nice Error Output
------------------
-
-When the `.node` file could not be loaded, `node-bindings` throws an Error with
-a nice error message telling you exactly what was tried. You can also check the
-`err.tries` Array property.
-
-```
-Error: Could not load the bindings file. Tried:
- → /Users/nrajlich/ref/build/binding.node
- → /Users/nrajlich/ref/build/Debug/binding.node
- → /Users/nrajlich/ref/build/Release/binding.node
- → /Users/nrajlich/ref/out/Debug/binding.node
- → /Users/nrajlich/ref/Debug/binding.node
- → /Users/nrajlich/ref/out/Release/binding.node
- → /Users/nrajlich/ref/Release/binding.node
- → /Users/nrajlich/ref/build/default/binding.node
- → /Users/nrajlich/ref/compiled/0.8.2/darwin/x64/binding.node
-    at bindings (/Users/nrajlich/ref/node_modules/bindings/bindings.js:84:13)
-    at Object.<anonymous> (/Users/nrajlich/ref/lib/ref.js:5:47)
-    at Module._compile (module.js:449:26)
-    at Object.Module._extensions..js (module.js:467:10)
-    at Module.load (module.js:356:32)
-    at Function.Module._load (module.js:312:12)
-    ...
-```
-
-
-License
--------
-
-(The MIT License)
-
-Copyright (c) 2012 Nathan Rajlich &lt;nathan@tootallnate.net&gt;
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-'Software'), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

tools/LiveTexturing/LiveTexturing/node_modules/zmq/node_modules/bindings/bindings.js

@@ -1,166 +0,0 @@
-
-/**
- * Module dependencies.
- */
-
-var fs = require('fs')
-  , path = require('path')
-  , join = path.join
-  , dirname = path.dirname
-  , exists = fs.existsSync || path.existsSync
-  , defaults = {
-        arrow: process.env.NODE_BINDINGS_ARROW || ' → '
-      , compiled: process.env.NODE_BINDINGS_COMPILED_DIR || 'compiled'
-      , platform: process.platform
-      , arch: process.arch
-      , version: process.versions.node
-      , bindings: 'bindings.node'
-      , try: [
-          // node-gyp's linked version in the "build" dir
-          [ 'module_root', 'build', 'bindings' ]
-          // node-waf and gyp_addon (a.k.a node-gyp)
-        , [ 'module_root', 'build', 'Debug', 'bindings' ]
-        , [ 'module_root', 'build', 'Release', 'bindings' ]
-          // Debug files, for development (legacy behavior, remove for node v0.9)
-        , [ 'module_root', 'out', 'Debug', 'bindings' ]
-        , [ 'module_root', 'Debug', 'bindings' ]
-          // Release files, but manually compiled (legacy behavior, remove for node v0.9)
-        , [ 'module_root', 'out', 'Release', 'bindings' ]
-        , [ 'module_root', 'Release', 'bindings' ]
-          // Legacy from node-waf, node <= 0.4.x
-        , [ 'module_root', 'build', 'default', 'bindings' ]
-          // Production "Release" buildtype binary (meh...)
-        , [ 'module_root', 'compiled', 'version', 'platform', 'arch', 'bindings' ]
-        ]
-    }
-
-/**
- * The main `bindings()` function loads the compiled bindings for a given module.
- * It uses V8's Error API to determine the parent filename that this function is
- * being invoked from, which is then used to find the root directory.
- */
-
-function bindings (opts) {
-
-  // Argument surgery
-  if (typeof opts == 'string') {
-    opts = { bindings: opts }
-  } else if (!opts) {
-    opts = {}
-  }
-  opts.__proto__ = defaults
-
-  // Get the module root
-  if (!opts.module_root) {
-    opts.module_root = exports.getRoot(exports.getFileName())
-  }
-
-  // Ensure the given bindings name ends with .node
-  if (path.extname(opts.bindings) != '.node') {
-    opts.bindings += '.node'
-  }
-
-  var tries = []
-    , i = 0
-    , l = opts.try.length
-    , n
-    , b
-    , err
-
-  for (; i<l; i++) {
-    n = join.apply(null, opts.try[i].map(function (p) {
-      return opts[p] || p
-    }))
-    tries.push(n)
-    try {
-      b = opts.path ? require.resolve(n) : require(n)
-      if (!opts.path) {
-        b.path = n
-      }
-      return b
-    } catch (e) {
-      if (!/not find/i.test(e.message)) {
-        throw e
-      }
-    }
-  }
-
-  err = new Error('Could not locate the bindings file. Tried:\n'
-    + tries.map(function (a) { return opts.arrow + a }).join('\n'))
-  err.tries = tries
-  throw err
-}
-module.exports = exports = bindings
-
-
-/**
- * Gets the filename of the JavaScript file that invokes this function.
- * Used to help find the root directory of a module.
- * Optionally accepts an filename argument to skip when searching for the invoking filename
- */
-
-exports.getFileName = function getFileName (calling_file) {
-  var origPST = Error.prepareStackTrace
-    , origSTL = Error.stackTraceLimit
-    , dummy = {}
-    , fileName
-
-  Error.stackTraceLimit = 10
-
-  Error.prepareStackTrace = function (e, st) {
-    for (var i=0, l=st.length; i<l; i++) {
-      fileName = st[i].getFileName()
-      if (fileName !== __filename) {
-        if (calling_file) {
-            if (fileName !== calling_file) {
-              return
-            }
-        } else {
-          return
-        }
-      }
-    }
-  }
-
-  // run the 'prepareStackTrace' function above
-  Error.captureStackTrace(dummy)
-  dummy.stack
-
-  // cleanup
-  Error.prepareStackTrace = origPST
-  Error.stackTraceLimit = origSTL
-
-  return fileName
-}
-
-/**
- * Gets the root directory of a module, given an arbitrary filename
- * somewhere in the module tree. The "root directory" is the directory
- * containing the `package.json` file.
- *
- *   In:  /home/nate/node-native-module/lib/index.js
- *   Out: /home/nate/node-native-module
- */
-
-exports.getRoot = function getRoot (file) {
-  var dir = dirname(file)
-    , prev
-  while (true) {
-    if (dir === '.') {
-      // Avoids an infinite loop in rare cases, like the REPL
-      dir = process.cwd()
-    }
-    if (exists(join(dir, 'package.json')) || exists(join(dir, 'node_modules'))) {
-      // Found the 'package.json' file or 'node_modules' dir; we're done
-      return dir
-    }
-    if (prev === dir) {
-      // Got to the top
-      throw new Error('Could not find module root given file: "' + file
-                    + '". Do you have a `package.json` file? ')
-    }
-    // Try the parent dir next
-    prev = dir
-    dir = join(dir, '..')
-  }
-}

tools/LiveTexturing/LiveTexturing/node_modules/zmq/node_modules/bindings/package.json

@@ -1,56 +0,0 @@
-{
-  "name": "bindings",
-  "description": "Helper module for loading your native module's .node file",
-  "keywords": [
-    "native",
-    "addon",
-    "bindings",
-    "gyp",
-    "waf",
-    "c",
-    "c++"
-  ],
-  "version": "1.2.1",
-  "author": {
-    "name": "Nathan Rajlich",
-    "email": "nathan@tootallnate.net",
-    "url": "http://tootallnate.net"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git://github.com/TooTallNate/node-bindings.git"
-  },
-  "main": "./bindings.js",
-  "bugs": {
-    "url": "https://github.com/TooTallNate/node-bindings/issues"
-  },
-  "homepage": "https://github.com/TooTallNate/node-bindings",
-  "license": "MIT",
-  "gitHead": "e404152ee27f8478ccbc7122ee051246e8e5ec02",
-  "_id": "bindings@1.2.1",
-  "scripts": {},
-  "_shasum": "14ad6113812d2d37d72e67b4cacb4bb726505f11",
-  "_from": "bindings@>=1.2.1 <1.3.0",
-  "_npmVersion": "1.4.14",
-  "_npmUser": {
-    "name": "tootallnate",
-    "email": "nathan@tootallnate.net"
-  },
-  "maintainers": [
-    {
-      "name": "TooTallNate",
-      "email": "nathan@tootallnate.net"
-    },
-    {
-      "name": "tootallnate",
-      "email": "nathan@tootallnate.net"
-    }
-  ],
-  "dist": {
-    "shasum": "14ad6113812d2d37d72e67b4cacb4bb726505f11",
-    "tarball": "http://registry.npmjs.org/bindings/-/bindings-1.2.1.tgz"
-  },
-  "directories": {},
-  "_resolved": "https://registry.npmjs.org/bindings/-/bindings-1.2.1.tgz",
-  "readme": "ERROR: No README data found!"
-}

tools/LiveTexturing/LiveTexturing/node_modules/zmq/node_modules/nan/.dntrc

@@ -1,30 +0,0 @@
-## DNT config file
-## see https://github.com/rvagg/dnt
-
-NODE_VERSIONS="\
-  master   \
-  v0.11.13 \
-  v0.10.30 \
-  v0.10.29 \
-  v0.10.28 \
-  v0.10.26 \
-  v0.10.25 \
-  v0.10.24 \
-  v0.10.23 \
-  v0.10.22 \
-  v0.10.21 \
-  v0.10.20 \
-  v0.10.19 \
-  v0.8.28  \
-  v0.8.27  \
-  v0.8.26  \
-  v0.8.24  \
-"
-OUTPUT_PREFIX="nan-"
-TEST_CMD="                                                                        \
-  cd /dnt/ &&                                                                     \
-  npm install &&                                                                  \
-  node_modules/.bin/node-gyp --nodedir /usr/src/node/ rebuild --directory test && \
-  node_modules/.bin/tap --gc test/js/*-test.js                                    \
-"
-

tools/LiveTexturing/LiveTexturing/node_modules/zmq/node_modules/nan/CHANGELOG.md

@@ -1,374 +0,0 @@
-# NAN ChangeLog
-
-**Version 2.0.9: current Node 4.0.0, Node 12: 0.12.7, Node 10: 0.10.40, iojs: 3.2.0**
-
-### 2.0.9 Sep 8 2015
-
-  - Bugfix: EscapableHandleScope in Nan::NewBuffer for Node 0.8 and 0.10 b1654d7
-
-### 2.0.8 Aug 28 2015
-
-  - Work around duplicate linking bug in clang 11902da
-
-### 2.0.7 Aug 26 2015
-
-  - Build: Repackage
-
-### 2.0.6 Aug 26 2015
-
-  - Bugfix: Properly handle null callback in FunctionTemplate factory 6e99cb1
-  - Bugfix: Remove unused static std::map instances 525bddc
-  - Bugfix: Make better use of maybe versions of APIs bfba85b
-  - Bugfix: Fix shadowing issues with handle in ObjectWrap 0a9072d
-
-### 2.0.5 Aug 10 2015
-
-  - Bugfix: Reimplement weak callback in ObjectWrap 98d38c1
-  - Bugfix: Make sure callback classes are not assignable, copyable or movable 81f9b1d
-
-### 2.0.4 Aug 6 2015
-
-  - Build: Repackage
-
-### 2.0.3 Aug 6 2015
-
-  - Bugfix: Don't use clang++ / g++ syntax extension. 231450e
-
-### 2.0.2 Aug 6 2015
-
-  - Build: Repackage
-
-### 2.0.1 Aug 6 2015
-
-  - Bugfix: Add workaround for missing REPLACE_INVALID_UTF8 60d6687
-  - Bugfix: Reimplement ObjectWrap from scratch to prevent memory leaks 6484601
-  - Bugfix: Fix Persistent leak in FunctionCallbackInfo and PropertyCallbackInfo 641ef5f
-  - Bugfix: Add missing overload for Nan::NewInstance that takes argc/argv 29450ed
-
-### 2.0.0 Jul 31 2015
-
-  - Change: Renamed identifiers with leading underscores	b5932b4
-  - Change: Replaced NanObjectWrapHandle with class NanObjectWrap	464f1e1
-  - Change: Replace NanScope and NanEscpableScope macros with classes	47751c4
-  - Change: Rename NanNewBufferHandle to NanNewBuffer	6745f99
-  - Change: Rename NanBufferUse to NanNewBuffer	3e8b0a5
-  - Change: Rename NanNewBuffer to NanCopyBuffer	d6af78d
-  - Change: Remove Nan prefix from all names	72d1f67
-  - Change: Update Buffer API for new upstream changes	d5d3291
-  - Change: Rename Scope and EscapableScope to HandleScope and EscapableHandleScope	21a7a6a
-  - Change: Get rid of Handles	 e6c0daf
-  - Feature: Support io.js 3 with V8 4.4
-  - Feature: Introduce NanPersistent	7fed696
-  - Feature: Introduce NanGlobal	4408da1
-  - Feature: Added NanTryCatch	10f1ca4
-  - Feature: Update for V8 v4.3	4b6404a
-  - Feature: Introduce NanNewOneByteString	c543d32
-  - Feature: Introduce namespace Nan	67ed1b1
-  - Removal: Remove NanLocker and NanUnlocker	dd6e401
-  - Removal: Remove string converters, except NanUtf8String, which now follows the node implementation b5d00a9
-  - Removal: Remove NanReturn* macros	d90a25c
-  - Removal: Remove HasInstance	e8f84fe
-
-
-### 1.9.0 Jul 31 2015
-
-  - Feature: Added `NanFatalException` 81d4a2c
-  - Feature: Added more error types 4265f06
-  - Feature: Added dereference and function call operators to NanCallback c4b2ed0
-  - Feature: Added indexed GetFromPersistent and SaveToPersistent edd510c
-  - Feature: Added more overloads of SaveToPersistent and GetFromPersistent 8b1cef6
-  - Feature: Added NanErrnoException dd87d9e
-  - Correctness: Prevent assign, copy, and move for classes that do not support it 1f55c59, 4b808cb, c96d9b2, fba4a29, 3357130
-  - Deprecation: Deprecate `NanGetPointerSafe` and `NanSetPointerSafe` 81d4a2c
-  - Deprecation: Deprecate `NanBooleanOptionValue` and `NanUInt32OptionValue` 0ad254b
-
-### 1.8.4 Apr 26 2015
-
-  - Build: Repackage
-
-### 1.8.3 Apr 26 2015
-
-  - Bugfix: Include missing header 1af8648
-
-### 1.8.2 Apr 23 2015
-
-  - Build: Repackage
-
-### 1.8.1 Apr 23 2015
-
-  - Bugfix: NanObjectWrapHandle should take a pointer 155f1d3
-
-### 1.8.0 Apr 23 2015
-
-  - Feature: Allow primitives with NanReturnValue 2e4475e
-  - Feature: Added comparison operators to NanCallback 55b075e
-  - Feature: Backport thread local storage 15bb7fa
-  - Removal: Remove support for signatures with arguments 8a2069d
-  - Correcteness: Replaced NanObjectWrapHandle macro with function 0bc6d59
-
-### 1.7.0 Feb 28 2015
-
-  - Feature: Made NanCallback::Call accept optional target 8d54da7
-  - Feature: Support atom-shell 0.21 0b7f1bb
-
-### 1.6.2 Feb 6 2015
-
-  - Bugfix: NanEncode: fix argument type for node::Encode on io.js 2be8639
-
-### 1.6.1 Jan 23 2015
-
-  - Build: version bump
-
-### 1.5.3 Jan 23 2015
-
-  - Build: repackage
-
-### 1.6.0 Jan 23 2015
-
- - Deprecated `NanNewContextHandle` in favor of `NanNew<Context>` 49259af
- - Support utility functions moved in newer v8 versions (Node 0.11.15, io.js 1.0) a0aa179
- - Added `NanEncode`, `NanDecodeBytes` and `NanDecodeWrite` 75e6fb9
-
-### 1.5.2 Jan 23 2015
-
-  - Bugfix: Fix non-inline definition build error with clang++ 21d96a1, 60fadd4
-  - Bugfix: Readded missing String constructors 18d828f
-  - Bugfix: Add overload handling NanNew<FunctionTemplate>(..) 5ef813b
-  - Bugfix: Fix uv_work_cb versioning 997e4ae
-  - Bugfix: Add function factory and test 4eca89c
-  - Bugfix: Add object template factory and test cdcb951
-  - Correctness: Lifted an io.js related typedef c9490be
-  - Correctness: Make explicit downcasts of String lengths 00074e6
-  - Windows: Limit the scope of disabled warning C4530 83d7deb
-
-### 1.5.1 Jan 15 2015
-
-  - Build: version bump
-
-### 1.4.3 Jan 15 2015
-
-  - Build: version bump
-
-### 1.4.2 Jan 15 2015
-
-  - Feature: Support io.js 0dbc5e8
-
-### 1.5.0 Jan 14 2015
-
- - Feature: Support io.js b003843
- - Correctness: Improved NanNew internals 9cd4f6a
- - Feature: Implement progress to NanAsyncWorker 8d6a160
-
-### 1.4.1 Nov 8 2014
-
- - Bugfix: Handle DEBUG definition correctly
- - Bugfix: Accept int as Boolean
-
-### 1.4.0 Nov 1 2014
-
- - Feature: Added NAN_GC_CALLBACK 6a5c245
- - Performance: Removed unnecessary local handle creation 18a7243, 41fe2f8
- - Correctness: Added constness to references in NanHasInstance 02c61cd
- - Warnings: Fixed spurious warnings from -Wundef and -Wshadow, 541b122, 99d8cb6
- - Windoze: Shut Visual Studio up when compiling 8d558c1
- - License: Switch to plain MIT from custom hacked MIT license 11de983
- - Build: Added test target to Makefile e232e46
- - Performance: Removed superfluous scope in NanAsyncWorker f4b7821
- - Sugar/Feature: Added NanReturnThis() and NanReturnHolder() shorthands 237a5ff, d697208
- - Feature: Added suitable overload of NanNew for v8::Integer::NewFromUnsigned b27b450
-
-### 1.3.0 Aug 2 2014
-
- - Added NanNew<v8::String, std::string>(std::string)
- - Added NanNew<v8::String, std::string&>(std::string&)
- - Added NanAsciiString helper class
- - Added NanUtf8String helper class
- - Added NanUcs2String helper class
- - Deprecated NanRawString()
- - Deprecated NanCString()
- - Added NanGetIsolateData(v8::Isolate *isolate)
- - Added NanMakeCallback(v8::Handle<v8::Object> target, v8::Handle<v8::Function> func, int argc, v8::Handle<v8::Value>* argv)
- - Added NanMakeCallback(v8::Handle<v8::Object> target, v8::Handle<v8::String> symbol, int argc, v8::Handle<v8::Value>* argv)
- - Added NanMakeCallback(v8::Handle<v8::Object> target, const char* method, int argc, v8::Handle<v8::Value>* argv)
- - Added NanSetTemplate(v8::Handle<v8::Template> templ, v8::Handle<v8::String> name , v8::Handle<v8::Data> value, v8::PropertyAttribute attributes)
- - Added NanSetPrototypeTemplate(v8::Local<v8::FunctionTemplate> templ, v8::Handle<v8::String> name, v8::Handle<v8::Data> value, v8::PropertyAttribute attributes)
- - Added NanSetInstanceTemplate(v8::Local<v8::FunctionTemplate> templ, const char *name, v8::Handle<v8::Data> value)
- - Added NanSetInstanceTemplate(v8::Local<v8::FunctionTemplate> templ, v8::Handle<v8::String> name, v8::Handle<v8::Data> value, v8::PropertyAttribute attributes)
-
-### 1.2.0 Jun 5 2014
-
- - Add NanSetPrototypeTemplate
- - Changed NAN_WEAK_CALLBACK internals, switched _NanWeakCallbackData to class,
-     introduced _NanWeakCallbackDispatcher
- - Removed -Wno-unused-local-typedefs from test builds
- - Made test builds Windows compatible ('Sleep()')
-
-### 1.1.2 May 28 2014
-
- - Release to fix more stuff-ups in 1.1.1
-
-### 1.1.1 May 28 2014
-
- - Release to fix version mismatch in nan.h and lack of changelog entry for 1.1.0
-
-### 1.1.0 May 25 2014
-
- - Remove nan_isolate, use v8::Isolate::GetCurrent() internally instead
- - Additional explicit overloads for NanNew(): (char*,int), (uint8_t*[,int]),
-     (uint16_t*[,int), double, int, unsigned int, bool, v8::String::ExternalStringResource*,
-     v8::String::ExternalAsciiStringResource*
- - Deprecate NanSymbol()
- - Added SetErrorMessage() and ErrorMessage() to NanAsyncWorker
-
-### 1.0.0 May 4 2014
-
- - Heavy API changes for V8 3.25 / Node 0.11.13
- - Use cpplint.py
- - Removed NanInitPersistent
- - Removed NanPersistentToLocal
- - Removed NanFromV8String
- - Removed NanMakeWeak
- - Removed NanNewLocal
- - Removed NAN_WEAK_CALLBACK_OBJECT
- - Removed NAN_WEAK_CALLBACK_DATA
- - Introduce NanNew, replaces NanNewLocal, NanPersistentToLocal, adds many overloaded typed versions
- - Introduce NanUndefined, NanNull, NanTrue and NanFalse
- - Introduce NanEscapableScope and NanEscapeScope
- - Introduce NanMakeWeakPersistent (requires a special callback to work on both old and new node)
- - Introduce NanMakeCallback for node::MakeCallback
- - Introduce NanSetTemplate
- - Introduce NanGetCurrentContext
- - Introduce NanCompileScript and NanRunScript
- - Introduce NanAdjustExternalMemory
- - Introduce NanAddGCEpilogueCallback, NanAddGCPrologueCallback, NanRemoveGCEpilogueCallback, NanRemoveGCPrologueCallback
- - Introduce NanGetHeapStatistics
- - Rename NanAsyncWorker#SavePersistent() to SaveToPersistent()
-
-### 0.8.0 Jan 9 2014
-
- - NanDispose -> NanDisposePersistent, deprecate NanDispose
- - Extract _NAN_*_RETURN_TYPE, pull up NAN_*()
-
-### 0.7.1 Jan 9 2014
-
- - Fixes to work against debug builds of Node
- - Safer NanPersistentToLocal (avoid reinterpret_cast)
- - Speed up common NanRawString case by only extracting flattened string when necessary
-
-### 0.7.0 Dec 17 2013
-
- - New no-arg form of NanCallback() constructor.
- - NanCallback#Call takes Handle rather than Local
- - Removed deprecated NanCallback#Run method, use NanCallback#Call instead
- - Split off _NAN_*_ARGS_TYPE from _NAN_*_ARGS
- - Restore (unofficial) Node 0.6 compatibility at NanCallback#Call()
- - Introduce NanRawString() for char* (or appropriate void*) from v8::String
-     (replacement for NanFromV8String)
- - Introduce NanCString() for null-terminated char* from v8::String
-
-### 0.6.0 Nov 21 2013
-
- - Introduce NanNewLocal<T>(v8::Handle<T> value) for use in place of
-     v8::Local<T>::New(...) since v8 started requiring isolate in Node 0.11.9
-
-### 0.5.2 Nov 16 2013
-
- - Convert SavePersistent and GetFromPersistent in NanAsyncWorker from protected and public
-
-### 0.5.1 Nov 12 2013
-
- - Use node::MakeCallback() instead of direct v8::Function::Call()
-
-### 0.5.0 Nov 11 2013
-
- - Added @TooTallNate as collaborator
- - New, much simpler, "include_dirs" for binding.gyp
- - Added full range of NAN_INDEX_* macros to match NAN_PROPERTY_* macros
-
-### 0.4.4 Nov 2 2013
-
- - Isolate argument from v8::Persistent::MakeWeak removed for 0.11.8+
-
-### 0.4.3 Nov 2 2013
-
- - Include node_object_wrap.h, removed from node.h for Node 0.11.8.
-
-### 0.4.2 Nov 2 2013
-
- - Handle deprecation of v8::Persistent::Dispose(v8::Isolate* isolate)) for
-     Node 0.11.8 release.
-
-### 0.4.1 Sep 16 2013
-
- - Added explicit `#include <uv.h>` as it was removed from node.h for v0.11.8
-
-### 0.4.0 Sep 2 2013
-
- - Added NAN_INLINE and NAN_DEPRECATED and made use of them
- - Added NanError, NanTypeError and NanRangeError
- - Cleaned up code
-
-### 0.3.2 Aug 30 2013
-
- - Fix missing scope declaration in GetFromPersistent() and SaveToPersistent
-     in NanAsyncWorker
-
-### 0.3.1 Aug 20 2013
-
- - fix "not all control paths return a value" compile warning on some platforms
-
-### 0.3.0 Aug 19 2013
-
- - Made NAN work with NPM
- - Lots of fixes to NanFromV8String, pulling in features from new Node core
- - Changed node::encoding to Nan::Encoding in NanFromV8String to unify the API
- - Added optional error number argument for NanThrowError()
- - Added NanInitPersistent()
- - Added NanReturnNull() and NanReturnEmptyString()
- - Added NanLocker and NanUnlocker
- - Added missing scopes
- - Made sure to clear disposed Persistent handles
- - Changed NanAsyncWorker to allocate error messages on the heap
- - Changed NanThrowError(Local<Value>) to NanThrowError(Handle<Value>)
- - Fixed leak in NanAsyncWorker when errmsg is used
-
-### 0.2.2 Aug 5 2013
-
- - Fixed usage of undefined variable with node::BASE64 in NanFromV8String()
-
-### 0.2.1 Aug 5 2013
-
- - Fixed 0.8 breakage, node::BUFFER encoding type not available in 0.8 for
-     NanFromV8String()
-
-### 0.2.0 Aug 5 2013
-
- - Added NAN_PROPERTY_GETTER, NAN_PROPERTY_SETTER, NAN_PROPERTY_ENUMERATOR,
-     NAN_PROPERTY_DELETER, NAN_PROPERTY_QUERY
- - Extracted _NAN_METHOD_ARGS, _NAN_GETTER_ARGS, _NAN_SETTER_ARGS,
-     _NAN_PROPERTY_GETTER_ARGS, _NAN_PROPERTY_SETTER_ARGS,
-     _NAN_PROPERTY_ENUMERATOR_ARGS, _NAN_PROPERTY_DELETER_ARGS,
-     _NAN_PROPERTY_QUERY_ARGS
- - Added NanGetInternalFieldPointer, NanSetInternalFieldPointer
- - Added NAN_WEAK_CALLBACK, NAN_WEAK_CALLBACK_OBJECT,
-     NAN_WEAK_CALLBACK_DATA, NanMakeWeak
- - Renamed THROW_ERROR to _NAN_THROW_ERROR
- - Added NanNewBufferHandle(char*, size_t, node::smalloc::FreeCallback, void*)
- - Added NanBufferUse(char*, uint32_t)
- - Added NanNewContextHandle(v8::ExtensionConfiguration*,
-       v8::Handle<v8::ObjectTemplate>, v8::Handle<v8::Value>)
- - Fixed broken NanCallback#GetFunction()
- - Added optional encoding and size arguments to NanFromV8String()
- - Added NanGetPointerSafe() and NanSetPointerSafe()
- - Added initial test suite (to be expanded)
- - Allow NanUInt32OptionValue to convert any Number object
-
-### 0.1.0 Jul 21 2013
-
- - Added `NAN_GETTER`, `NAN_SETTER`
- - Added `NanThrowError` with single Local<Value> argument
- - Added `NanNewBufferHandle` with single uint32_t argument
- - Added `NanHasInstance(Persistent<FunctionTemplate>&, Handle<Value>)`
- - Added `Local<Function> NanCallback#GetFunction()`
- - Added `NanCallback#Call(int, Local<Value>[])`
- - Deprecated `NanCallback#Run(int, Local<Value>[])` in favour of Call

tools/LiveTexturing/LiveTexturing/node_modules/zmq/node_modules/nan/LICENSE.md

@@ -1,13 +0,0 @@
-The MIT License (MIT)
-=====================
-
-Copyright (c) 2015 NAN contributors
------------------------------------
-
-*NAN contributors listed at <https://github.com/nodejs/nan#contributors>*
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

tools/LiveTexturing/LiveTexturing/node_modules/zmq/node_modules/nan/README.md

@@ -1,367 +0,0 @@
-Native Abstractions for Node.js
-===============================
-
-**A header file filled with macro and utility goodness for making add-on development for Node.js easier across versions 0.8, 0.10 and 0.12 as well as io.js.**
-
-***Current version: 2.0.9***
-
-*(See [CHANGELOG.md](https://github.com/nodejs/nan/blob/master/CHANGELOG.md) for complete ChangeLog)*
-
-[![NPM](https://nodei.co/npm/nan.png?downloads=true&downloadRank=true)](https://nodei.co/npm/nan/) [![NPM](https://nodei.co/npm-dl/nan.png?months=6&height=3)](https://nodei.co/npm/nan/)
-
-[![Build Status](https://api.travis-ci.org/nodejs/nan.svg?branch=master)](http://travis-ci.org/nodejs/nan)
-[![Build status](https://ci.appveyor.com/api/projects/status/kh73pbm9dsju7fgh)](https://ci.appveyor.com/project/RodVagg/nan)
-
-Thanks to the crazy changes in V8 (and some in Node core), keeping native addons compiling happily across versions, particularly 0.10 to 0.12, is a minor nightmare. The goal of this project is to store all logic necessary to develop native Node.js addons without having to inspect `NODE_MODULE_VERSION` and get yourself into a macro-tangle.
-
-This project also contains some helper utilities that make addon development a bit more pleasant.
-
- * **[News & Updates](#news)**
- * **[Usage](#usage)**
- * **[Example](#example)**
- * **[API](#api)**
- * **[Tests](#tests)**
- * **[Governance & Contributing](#governance)**
-
-<a name="news"></a>
-## News & Updates
-
-<a name="usage"></a>
-## Usage
-
-Simply add **NAN** as a dependency in the *package.json* of your Node addon:
-
-``` bash
-$ npm install --save nan
-```
-
-Pull in the path to **NAN** in your *binding.gyp* so that you can use `#include <nan.h>` in your *.cpp* files:
-
-``` python
-"include_dirs" : [
-    "<!(node -e \"require('nan')\")"
-]
-```
-
-This works like a `-I<path-to-NAN>` when compiling your addon.
-
-<a name="example"></a>
-## Example
-
-Just getting started with Nan? Refer to a [quick-start **Nan** Boilerplate](https://github.com/fcanas/node-native-boilerplate) for a ready-to-go project that utilizes basic Nan functionality.
-
-For a simpler example, see the **[async pi estimation example](https://github.com/nodejs/nan/tree/master/examples/async_pi_estimate)** in the examples directory for full code and an explanation of what this Monte Carlo Pi estimation example does. Below are just some parts of the full example that illustrate the use of **NAN**.
-
-For another example, see **[nan-example-eol](https://github.com/CodeCharmLtd/nan-example-eol)**. It shows newline detection implemented as a native addon.
-
-<a name="api"></a>
-## API
-
-Additional to the NAN documentation below, please consult:
-
-* [The V8 Getting Started Guide](https://developers.google.com/v8/get_started)
-* [The V8 Embedders Guide](https://developers.google.com/v8/embed)
-* [V8 API Documentation](http://v8docs.nodesource.com/)
-
-<!-- START API -->
-
-### JavaScript-accessible methods
-
-A _template_ is a blueprint for JavaScript functions and objects in a context. You can use a template to wrap C++ functions and data structures within JavaScript objects so that they can be manipulated from JavaScript. See the V8 Embedders Guide section on [Templates](https://developers.google.com/v8/embed#templates) for further information.
-
-In order to expose functionality to JavaScript via a template, you must provide it to V8 in a form that it understands. Across the versions of V8 supported by NAN, JavaScript-accessible method signatures vary widely, NAN fully abstracts method declaration and provides you with an interface that is similar to the most recent V8 API but is backward-compatible with older versions that still use the now-deceased `v8::Argument` type.
-
-* **Method argument types**
- - <a href="doc/methods.md#api_nan_function_callback_info"><b><code>Nan::FunctionCallbackInfo</code></b></a>
- - <a href="doc/methods.md#api_nan_property_callback_info"><b><code>Nan::PropertyCallbackInfo</code></b></a>
- - <a href="doc/methods.md#api_nan_return_value"><b><code>Nan::ReturnValue</code></b></a>
-* **Method declarations**
- - <a href="doc/methods.md#api_nan_method"><b>Method declaration</b></a>
- - <a href="doc/methods.md#api_nan_getter"><b>Getter declaration</b></a>
- - <a href="doc/methods.md#api_nan_setter"><b>Setter declaration</b></a>
- - <a href="doc/methods.md#api_nan_property_getter"><b>Property getter declaration</b></a>
- - <a href="doc/methods.md#api_nan_property_setter"><b>Property setter declaration</b></a>
- - <a href="doc/methods.md#api_nan_property_enumerator"><b>Property enumerator declaration</b></a>
- - <a href="doc/methods.md#api_nan_property_deleter"><b>Property deleter declaration</b></a>
- - <a href="doc/methods.md#api_nan_property_query"><b>Property query declaration</b></a>
- - <a href="doc/methods.md#api_nan_index_getter"><b>Index getter declaration</b></a>
- - <a href="doc/methods.md#api_nan_index_setter"><b>Index setter declaration</b></a>
- - <a href="doc/methods.md#api_nan_index_enumerator"><b>Index enumerator declaration</b></a>
- - <a href="doc/methods.md#api_nan_index_deleter"><b>Index deleter declaration</b></a>
- - <a href="doc/methods.md#api_nan_index_query"><b>Index query declaration</b></a>
-* Method and template helpers
- - <a href="doc/methods.md#api_nan_set_method"><b><code>Nan::SetMethod()</code></b></a>
- - <a href="doc/methods.md#api_nan_set_named_property_handler"><b><code>Nan::SetNamedPropertyHandler()</code></b></a>
- - <a href="doc/methods.md#api_nan_set_indexed_property_handler"><b><code>Nan::SetIndexedPropertyHandler()</code></b></a>
- - <a href="doc/methods.md#api_nan_set_prototype_method"><b><code>Nan::SetPrototypeMethod()</code></b></a>
- - <a href="doc/methods.md#api_nan_set_template"><b><code>Nan::SetTemplate()</code></b></a>
- - <a href="doc/methods.md#api_nan_set_prototype_template"><b><code>Nan::SetPrototypeTemplate()</code></b></a>
- - <a href="doc/methods.md#api_nan_set_instance_template"><b><code>Nan::SetInstanceTemplate()</code></b></a>
-
-### Scopes
-
-A _local handle_ is a pointer to an object. All V8 objects are accessed using handles, they are necessary because of the way the V8 garbage collector works.
-
-A handle scope can be thought of as a container for any number of handles. When you've finished with your handles, instead of deleting each one individually you can simply delete their scope.
-
-The creation of `HandleScope` objects is different across the supported versions of V8. Therefore, NAN provides its own implementations that can be used safely across these.
-
- - <a href="doc/scopes.md#api_nan_handle_scope"><b><code>Nan::HandleScope</code></b></a>
- - <a href="doc/scopes.md#api_nan_escapable_handle_scope"><b><code>Nan::EscapableHandleScope</code></b></a>
-
-Also see the V8 Embedders Guide section on [Handles and Garbage Collection](https://developers.google.com/v8/embed#handles).
-
-### Persistent references
-
-An object reference that is independent of any `HandleScope` is a _persistent_ reference. Where a `Local` handle only lives as long as the `HandleScope` in which it was allocated, a `Persistent` handle remains valid until it is explicitly disposed.
-
-Due to the evolution of the V8 API, it is necessary for NAN to provide a wrapper implementation of the `Persistent` classes to supply compatibility across the V8 versions supported.
-
- - <a href="doc/persistent.md#api_nan_persistent_base"><b><code>Nan::PersistentBase & v8::PersistentBase</code></b></a>
- - <a href="doc/persistent.md#api_nan_non_copyable_persistent_traits"><b><code>Nan::NonCopyablePersistentTraits & v8::NonCopyablePersistentTraits</code></b></a>
- - <a href="doc/persistent.md#api_nan_copyable_persistent_traits"><b><code>Nan::CopyablePersistentTraits & v8::CopyablePersistentTraits</code></b></a>
- - <a href="doc/persistent.md#api_nan_persistent"><b><code>Nan::Persistent</code></b></a>
- - <a href="doc/persistent.md#api_nan_global"><b><code>Nan::Global</code></b></a>
- - <a href="doc/persistent.md#api_nan_weak_callback_info"><b><code>Nan::WeakCallbackInfo</code></b></a>
- - <a href="doc/persistent.md#api_nan_weak_callback_type"><b><code>Nan::WeakCallbackType</code></b></a>
-
-Also see the V8 Embedders Guide section on [Handles and Garbage Collection](https://developers.google.com/v8/embed#handles).
-
-### New
-
-NAN provides a `Nan::New()` helper for the creation of new JavaScript objects in a way that's compatible across the supported versions of V8.
-
- - <a href="doc/new.md#api_nan_new"><b><code>Nan::New()</code></b></a>
- - <a href="doc/new.md#api_nan_undefined"><b><code>Nan::Undefined()</code></b></a>
- - <a href="doc/new.md#api_nan_null"><b><code>Nan::Null()</code></b></a>
- - <a href="doc/new.md#api_nan_true"><b><code>Nan::True()</code></b></a>
- - <a href="doc/new.md#api_nan_false"><b><code>Nan::False()</code></b></a>
- - <a href="doc/new.md#api_nan_empty_string"><b><code>Nan::EmptyString()</code></b></a>
-
-
-### Converters
-
-NAN contains functions that convert `v8::Value`s to other `v8::Value` types and native types. Since type conversion is not guaranteed to succeed, they return `Nan::Maybe` types. These converters can be used in place of `value->ToX()` and `value->XValue()` (where `X` is one of the types, e.g. `Boolean`) in a way that provides a consistent interface across V8 versions. Newer versions of V8 use the new `v8::Maybe` and `v8::MaybeLocal` types for these conversions, older versions don't have this functionality so it is provided by NAN.
-
- - <a href="doc/converters.md#api_nan_to"><b><code>Nan::To()</code></b></a>
-
-### Maybe Types
-
-The `Nan::MaybeLocal` and `Nan::Maybe` types are monads that encapsulate `v8::Local` handles that _may be empty_.
-
-* **Maybe Types**
-  - <a href="doc/maybe_types.md#api_nan_maybe_local"><b><code>Nan::MaybeLocal</code></b></a>
-  - <a href="doc/maybe_types.md#api_nan_maybe"><b><code>Nan::Maybe</code></b></a>
-  - <a href="doc/maybe_types.md#api_nan_nothing"><b><code>Nan::Nothing</code></b></a>
-  - <a href="doc/maybe_types.md#api_nan_just"><b><code>Nan::Just</code></b></a>
-* **Maybe Helpers**
-  - <a href="doc/maybe_types.md#api_nan_to_detail_string"><b><code>Nan::ToDetailString()</code></b></a>
-  - <a href="doc/maybe_types.md#api_nan_to_array_index"><b><code>Nan::ToArrayIndex()</code></b></a>
-  - <a href="doc/maybe_types.md#api_nan_equals"><b><code>Nan::Equals()</code></b></a>
-  - <a href="doc/maybe_types.md#api_nan_new_instance"><b><code>Nan::NewInstance()</code></b></a>
-  - <a href="doc/maybe_types.md#api_nan_get_function"><b><code>Nan::GetFunction()</code></b></a>
-  - <a href="doc/maybe_types.md#api_nan_set"><b><code>Nan::Set()</code></b></a>
-  - <a href="doc/maybe_types.md#api_nan_force_set"><b><code>Nan::ForceSet()</code></b></a>
-  - <a href="doc/maybe_types.md#api_nan_get"><b><code>Nan::Get()</code></b></a>
-  - <a href="doc/maybe_types.md#api_nan_get_property_attribute"><b><code>Nan::GetPropertyAttributes()</code></b></a>
-  - <a href="doc/maybe_types.md#api_nan_has"><b><code>Nan::Has()</code></b></a>
-  - <a href="doc/maybe_types.md#api_nan_delete"><b><code>Nan::Delete()</code></b></a>
-  - <a href="doc/maybe_types.md#api_nan_get_property_names"><b><code>Nan::GetPropertyNames()</code></b></a>
-  - <a href="doc/maybe_types.md#api_nan_get_own_property_names"><b><code>Nan::GetOwnPropertyNames()</code></b></a>
-  - <a href="doc/maybe_types.md#api_nan_set_prototype"><b><code>Nan::SetPrototype()</code></b></a>
-  - <a href="doc/maybe_types.md#api_nan_object_proto_to_string"><b><code>Nan::ObjectProtoToString()</code></b></a>
-  - <a href="doc/maybe_types.md#api_nan_has_own_property"><b><code>Nan::HasOwnProperty()</code></b></a>
-  - <a href="doc/maybe_types.md#api_nan_has_real_named_property"><b><code>Nan::HasRealNamedProperty()</code></b></a>
-  - <a href="doc/maybe_types.md#api_nan_has_real_indexed_property"><b><code>Nan::HasRealIndexedProperty()</code></b></a>
-  - <a href="doc/maybe_types.md#api_nan_has_real_named_callback_property"><b><code>Nan::HasRealNamedCallbackProperty()</code></b></a>
-  - <a href="doc/maybe_types.md#api_nan_get_real_named_property_in_prototype_chain"><b><code>Nan::GetRealNamedPropertyInPrototypeChain()</code></b></a>
-  - <a href="doc/maybe_types.md#api_nan_get_real_named_property"><b><code>Nan::GetRealNamedProperty()</code></b></a>
-  - <a href="doc/maybe_types.md#api_nan_call_as_function"><b><code>Nan::CallAsFunction()</code></b></a>
-  - <a href="doc/maybe_types.md#api_nan_call_as_constructor"><b><code>Nan::CallAsConstructor()</code></b></a>
-  - <a href="doc/maybe_types.md#api_nan_get_source_line"><b><code>Nan::GetSourceLine()</code></b></a>
-  - <a href="doc/maybe_types.md#api_nan_get_line_number"><b><code>Nan::GetLineNumber()</code></b></a>
-  - <a href="doc/maybe_types.md#api_nan_get_start_column"><b><code>Nan::GetStartColumn()</code></b></a>
-  - <a href="doc/maybe_types.md#api_nan_get_end_column"><b><code>Nan::GetEndColumn()</code></b></a>
-  - <a href="doc/maybe_types.md#api_nan_clone_element_at"><b><code>Nan::CloneElementAt()</code></b></a>
-
-### Script
-
-NAN provides a `v8::Script` helpers as the API has changed over the supported versions of V8.
-
- - <a href="doc/script.md#api_nan_compile_script"><b><code>Nan::CompileScript()</code></b></a>
- - <a href="doc/script.md#api_nan_run_script"><b><code>Nan::RunScript()</code></b></a>
-
-
-### Errors
-
-NAN includes helpers for creating, throwing and catching Errors as much of this functionality varies across the supported versions of V8 and must be abstracted.
-
-Note that an Error object is simply a specialized form of `v8::Value`.
-
-Also consult the V8 Embedders Guide section on [Exceptions](https://developers.google.com/v8/embed#exceptions) for more information.
-
- - <a href="doc/errors.md#api_nan_error"><b><code>Nan::Error()</code></b></a>
- - <a href="doc/errors.md#api_nan_range_error"><b><code>Nan::RangeError()</code></b></a>
- - <a href="doc/errors.md#api_nan_reference_error"><b><code>Nan::ReferenceError()</code></b></a>
- - <a href="doc/errors.md#api_nan_syntax_error"><b><code>Nan::SyntaxError()</code></b></a>
- - <a href="doc/errors.md#api_nan_type_error"><b><code>Nan::TypeError()</code></b></a>
- - <a href="doc/errors.md#api_nan_throw_error"><b><code>Nan::ThrowError()</code></b></a>
- - <a href="doc/errors.md#api_nan_throw_range_error"><b><code>Nan::ThrowRangeError()</code></b></a>
- - <a href="doc/errors.md#api_nan_throw_reference_error"><b><code>Nan::ThrowReferenceError()</code></b></a>
- - <a href="doc/errors.md#api_nan_throw_syntax_error"><b><code>Nan::ThrowSyntaxError()</code></b></a>
- - <a href="doc/errors.md#api_nan_throw_type_error"><b><code>Nan::ThrowTypeError()</code></b></a>
- - <a href="doc/errors.md#api_nan_fatal_exception"><b><code>Nan::FatalException()</code></b></a>
- - <a href="doc/errors.md#api_nan_errno_exception"><b><code>Nan::ErrnoException()</code></b></a>
- - <a href="doc/errors.md#api_nan_try_catch"><b><code>Nan::TryCatch</code></b></a>
-
-
-### Buffers
-
-NAN's `node::Buffer` helpers exist as the API has changed across supported Node versions. Use these methods to ensure compatibility.
-
- - <a href="doc/buffers.md#api_nan_new_buffer"><b><code>Nan::NewBuffer()</code></b></a>
- - <a href="doc/buffers.md#api_nan_copy_buffer"><b><code>Nan::CopyBuffer()</code></b></a>
- - <a href="doc/buffers.md#api_nan_free_callback"><b><code>Nan::FreeCallback()</code></b></a>
-
-### Nan::Callback
-
-`Nan::Callback` makes it easier to use `v8::Function` handles as callbacks. A class that wraps a `v8::Function` handle, protecting it from garbage collection and making it particularly useful for storage and use across asynchronous execution.
-
- - <a href="doc/callback.md#api_nan_callback"><b><code>Nan::Callback</code></b></a>
-
-### Asynchronous work helpers
-
-`Nan::AsyncWorker` and `Nan::AsyncProgressWorker` are helper classes that make working with asynchronous code easier.
-
- - <a href="doc/asyncworker.md#api_nan_async_worker"><b><code>Nan::AsyncWorker</code></b></a>
- - <a href="doc/asyncworker.md#api_nan_async_progress_worker"><b><code>Nan::AsyncProgressWorker</code></b></a>
- - <a href="doc/asyncworker.md#api_nan_async_queue_worker"><b><code>Nan::AsyncQueueWorker</code></b></a>
-
-### Strings & Bytes
-
-Miscellaneous string & byte encoding and decoding functionality provided for compatibility across supported versions of V8 and Node. Implemented by NAN to ensure that all encoding types are supported, even for older versions of Node where they are missing.
-
- - <a href="doc/string_bytes.md#api_nan_encoding"><b><code>Nan::Encoding</code></b></a>
- - <a href="doc/string_bytes.md#api_nan_encode"><b><code>Nan::Encode()</code></b></a>
- - <a href="doc/string_bytes.md#api_nan_decode_bytes"><b><code>Nan::DecodeBytes()</code></b></a>
- - <a href="doc/string_bytes.md#api_nan_decode_write"><b><code>Nan::DecodeWrite()</code></b></a>
-
-
-### V8 internals
-
-The hooks to access V8 internals—including GC and statistics—are different across the supported versions of V8, therefore NAN provides its own hooks that call the appropriate V8 methods.
-
- - <a href="doc/v8_internals.md#api_nan_gc_callback"><b><code>NAN_GC_CALLBACK()</code></b></a>
- - <a href="doc/v8_internals.md#api_nan_add_gc_epilogue_callback"><b><code>Nan::AddGCEpilogueCallback()</code></b></a>
- - <a href="doc/v8_internals.md#api_nan_remove_gc_epilogue_callback"><b><code>Nan::RemoveGCEpilogueCallback()</code></b></a>
- - <a href="doc/v8_internals.md#api_nan_add_gc_prologue_callback"><b><code>Nan::AddGCPrologueCallback()</code></b></a>
- - <a href="doc/v8_internals.md#api_nan_remove_gc_prologue_callback"><b><code>Nan::RemoveGCPrologueCallback()</code></b></a>
- - <a href="doc/v8_internals.md#api_nan_get_heap_statistics"><b><code>Nan::GetHeapStatistics()</code></b></a>
- - <a href="doc/v8_internals.md#api_nan_set_counter_function"><b><code>Nan::SetCounterFunction()</code></b></a>
- - <a href="doc/v8_internals.md#api_nan_set_create_histogram_function"><b><code>Nan::SetCreateHistogramFunction()</code></b></a>
- - <a href="doc/v8_internals.md#api_nan_set_add_histogram_sample_function"><b><code>Nan::SetAddHistogramSampleFunction()</code></b></a>
- - <a href="doc/v8_internals.md#api_nan_idle_notification"><b><code>Nan::IdleNotification()</code></b></a>
- - <a href="doc/v8_internals.md#api_nan_low_memory_notification"><b><code>Nan::LowMemoryNotification()</code></b></a>
- - <a href="doc/v8_internals.md#api_nan_context_disposed_notification"><b><code>Nan::ContextDisposedNotification()</code></b></a>
- - <a href="doc/v8_internals.md#api_nan_get_internal_field_pointer"><b><code>Nan::GetInternalFieldPointer()</code></b></a>
- - <a href="doc/v8_internals.md#api_nan_set_internal_field_pointer"><b><code>Nan::SetInternalFieldPointer()</code></b></a>
- - <a href="doc/v8_internals.md#api_nan_adjust_external_memory"><b><code>Nan::AdjustExternalMemory()</code></b></a>
-
-
-### Miscellaneous V8 Helpers
-
- - <a href="doc/v8_misc.md#api_nan_utf8_string"><b><code>Nan::Utf8String</code></b></a>
- - <a href="doc/v8_misc.md#api_nan_get_current_context"><b><code>Nan::GetCurrentContext()</code></b></a>
- - <a href="doc/v8_misc.md#api_nan_set_isolate_data"><b><code>Nan::SetIsolateData()</code></b></a>
- - <a href="doc/v8_misc.md#api_nan_get_isolate_data"><b><code>Nan::GetIsolateData()</code></b></a>
-
-
-### Miscellaneous Node Helpers
-
- - <a href="doc/node_misc.md#api_nan_make_callback"><b><code>Nan::MakeCallback()</code></b></a>
- - <a href="doc/node_misc.md#api_nan_object_wrap"><b><code>Nan::ObjectWrap</code></b></a>
- - <a href="doc/node_misc.md#api_nan_module_init"><b><code>NAN_MODULE_INIT()</code></b></a>
- - <a href="doc/node_misc.md#api_nan_export"><b><code>Nan::Export()</code></b></a>
-
-<!-- END API -->
-
-
-<a name="tests"></a>
-### Tests
-
-To run the NAN tests do:
-
-``` sh
-npm install
-npm run-script rebuild-tests
-npm test
-```
-
-Or just:
-
-``` sh
-npm install
-make test
-```
-
-<a name="governance"></a>
-## Governance & Contributing
-
-NAN is governed by the [io.js](https://iojs.org/) Addon API Working Group
-
-### Addon API Working Group (WG)
-
-The NAN project is jointly governed by a Working Group which is responsible for high-level guidance of the project.
-
-Members of the WG are also known as Collaborators, there is no distinction between the two, unlike other io.js projects.
-
-The WG has final authority over this project including:
-
-* Technical direction
-* Project governance and process (including this policy)
-* Contribution policy
-* GitHub repository hosting
-* Maintaining the list of additional Collaborators
-
-For the current list of WG members, see the project [README.md](./README.md#collaborators).
-
-Individuals making significant and valuable contributions are made members of the WG and given commit-access to the project. These individuals are identified by the WG and their addition to the WG is discussed via GitHub and requires unanimous consensus amongst those WG members participating in the discussion with a quorum of 50% of WG members required for acceptance of the vote.
-
-_Note:_ If you make a significant contribution and are not considered for commit-access log an issue or contact a WG member directly.
-
-For the current list of WG members / Collaborators, see the project [README.md](./README.md#collaborators).
-
-### Consensus Seeking Process
-
-The WG follows a [Consensus Seeking](http://en.wikipedia.org/wiki/Consensus-seeking_decision-making) decision making model.
-
-Modifications of the contents of the NAN repository are made on a collaborative basis. Anybody with a GitHub account may propose a modification via pull request and it will be considered by the WG. All pull requests must be reviewed and accepted by a WG member with sufficient expertise who is able to take full responsibility for the change. In the case of pull requests proposed by an existing WG member, an additional WG member is required for sign-off. Consensus should be sought if additional WG members participate and there is disagreement around a particular modification.
-
-If a change proposal cannot reach a consensus, a WG member can call for a vote amongst the members of the WG. Simple majority wins.
-
-### Developer's Certificate of Origin 1.0
-
-By making a contribution to this project, I certify that:
-
-* (a) The contribution was created in whole or in part by me and I have the right to submit it under the open source license indicated in the file; or
-* (b) The contribution is based upon previous work that, to the best of my knowledge, is covered under an appropriate open source license and I have the right under that license to submit that work with modifications, whether created in whole or in part by me, under the same open source license (unless I am permitted to submit under a different license), as indicated in the file; or
-* (c) The contribution was provided directly to me by some other person who certified (a), (b) or (c) and I have not modified it.
-
-<a name="collaborators"></a>
-### WG Members / Collaborators
-
-<table><tbody>
-<tr><th align="left">Rod Vagg</th><td><a href="https://github.com/rvagg">GitHub/rvagg</a></td><td><a href="http://twitter.com/rvagg">Twitter/@rvagg</a></td></tr>
-<tr><th align="left">Benjamin Byholm</th><td><a href="https://github.com/kkoopa/">GitHub/kkoopa</a></td><td>-</td></tr>
-<tr><th align="left">Trevor Norris</th><td><a href="https://github.com/trevnorris">GitHub/trevnorris</a></td><td><a href="http://twitter.com/trevnorris">Twitter/@trevnorris</a></td></tr>
-<tr><th align="left">Nathan Rajlich</th><td><a href="https://github.com/TooTallNate">GitHub/TooTallNate</a></td><td><a href="http://twitter.com/TooTallNate">Twitter/@TooTallNate</a></td></tr>
-<tr><th align="left">Brett Lawson</th><td><a href="https://github.com/brett19">GitHub/brett19</a></td><td><a href="http://twitter.com/brett19x">Twitter/@brett19x</a></td></tr>
-<tr><th align="left">Ben Noordhuis</th><td><a href="https://github.com/bnoordhuis">GitHub/bnoordhuis</a></td><td><a href="http://twitter.com/bnoordhuis">Twitter/@bnoordhuis</a></td></tr>
-<tr><th align="left">David Siegel</th><td><a href="https://github.com/agnat">GitHub/agnat</a></td><td>-</td></tr>
-</tbody></table>
-
-## Licence &amp; copyright
-
-Copyright (c) 2015 NAN WG Members / Collaborators (listed above).
-
-Native Abstractions for Node.js is licensed under an MIT license. All rights not explicitly granted in the MIT license are reserved. See the included LICENSE file for more details.

tools/LiveTexturing/LiveTexturing/node_modules/zmq/node_modules/nan/appveyor.yml

@@ -1,38 +0,0 @@
-# http://www.appveyor.com/docs/appveyor-yml
-
-# Test against these versions of Io.js and Node.js.
-environment:
-  matrix:
-  # node.js
-    - nodejs_version: "0.8"
-    - nodejs_version: "0.10"
-    - nodejs_version: "0.12"
-  # io.js
-    - nodejs_version: "1"
-    - nodejs_version: "2"
-    - nodejs_version: "3"
-
-# Install scripts. (runs after repo cloning)
-install:
-  # Get the latest stable version of Node 0.STABLE.latest
-  - ps: if($env:nodejs_version -eq "0.8") {Install-Product node $env:nodejs_version}
-  - ps: if($env:nodejs_version -ne "0.8") {Update-NodeJsInstallation (Get-NodeJsLatestBuild $env:nodejs_version)}
-  - IF %nodejs_version% LSS 1 npm -g install npm
-  - IF %nodejs_version% LSS 1 set PATH=%APPDATA%\npm;%PATH%
-  # Typical npm stuff.
-  - npm install
-  - IF %nodejs_version% EQU 0.8 (node node_modules\node-gyp\bin\node-gyp.js rebuild --msvs_version=2013 --directory test) ELSE (npm run rebuild-tests)
-
-# Post-install test scripts.
-test_script:
-  # Output useful info for debugging.
-  - node --version
-  - npm --version
-  # run tests
-  - IF %nodejs_version% LSS 1 (npm test) ELSE (iojs node_modules\tap\bin\tap.js --gc test/js/*-test.js)
-
-# Don't actually build.
-build: off
-
-# Set build version format here instead of in the admin panel.
-version: "{build}"

tools/LiveTexturing/LiveTexturing/node_modules/zmq/node_modules/nan/doc/.build.sh

@@ -1,38 +0,0 @@
-#!/usr/bin/env bash
-
-files="           \
-  methods.md      \
-  scopes.md       \
-  persistent.md   \
-  new.md          \
-  converters.md   \
-  maybe_types.md  \
-  script.md       \
-  errors.md       \
-  buffers.md      \
-  callback.md     \
-  asyncworker.md  \
-  string_bytes.md \
-  v8_internals.md \
-  v8_misc.md      \
-  node_misc.md    \
-"
-
-__dirname=$(dirname "${BASH_SOURCE[0]}")
-head=$(perl -e 'while (<>) { if (!$en){print;} if ($_=~/<!-- START/){$en=1} };' $__dirname/../README.md)
-tail=$(perl -e 'while (<>) { if ($_=~/<!-- END/){$st=1} if ($st){print;} };' $__dirname/../README.md)
-apidocs=$(for f in $files; do
-  perl -pe '
-    last if /^<a name/;
-    $_ =~ s/^## /### /;
-    $_ =~ s/<a href="#/<a href="doc\/'$f'#/;
-  ' $__dirname/$f;
-done)
-
-cat > $__dirname/../README.md << EOF
-$head
-
-$apidocs
-
-$tail
-EOF

tools/LiveTexturing/LiveTexturing/node_modules/zmq/node_modules/nan/doc/asyncworker.md

@@ -1,97 +0,0 @@
-## Asynchronous work helpers
-
-`Nan::AsyncWorker` and `Nan::AsyncProgressWorker` are helper classes that make working with asynchronous code easier.
-
- - <a href="#api_nan_async_worker"><b><code>Nan::AsyncWorker</code></b></a>
- - <a href="#api_nan_async_progress_worker"><b><code>Nan::AsyncProgressWorker</code></b></a>
- - <a href="#api_nan_async_queue_worker"><b><code>Nan::AsyncQueueWorker</code></b></a>
-
-<a name="api_nan_async_worker"></a>
-### Nan::AsyncWorker
-
-`Nan::AsyncWorker` is an _abstract_ class that you can subclass to have much of the annoying asynchronous queuing and handling taken care of for you. It can even store arbitrary V8 objects for you and have them persist while the asynchronous work is in progress.
-
-Definition:
-
-```c++
-class AsyncWorker {
- public:
-  explicit AsyncWorker(Callback *callback_);
-
-  virtual ~AsyncWorker();
-
-  virtual void WorkComplete();
-
-  void SaveToPersistent(const char *key, const v8::Local<v8::Value> &value);
-
-  void SaveToPersistent(const v8::Local<v8::String> &key,
-                        const v8::Local<v8::Value> &value);
-
-  void SaveToPersistent(uint32_t index,
-                        const v8::Local<v8::Value> &value);
-
-  v8::Local<v8::Value> GetFromPersistent(const char *key) const;
-
-  v8::Local<v8::Value> GetFromPersistent(const v8::Local<v8::String> &key) const;
-
-  v8::Local<v8::Value> GetFromPersistent(uint32_t index) const;
-
-  virtual void Execute() = 0;
-
-  uv_work_t request;
-
-  virtual void Destroy();
-
- protected:
-  Persistent<v8::Object> persistentHandle;
-
-  Callback *callback;
-
-  virtual void HandleOKCallback();
-
-  virtual void HandleErrorCallback();
-
-  void SetErrorMessage(const char *msg);
-
-  const char* ErrorMessage();
-};
-```
-
-<a name="api_nan_async_progress_worker"></a>
-### Nan::AsyncProgressWorker
-
-`Nan::AsyncProgressWorker` is an _abstract_ class that extends `Nan::AsyncWorker` and adds additional progress reporting callbacks that can be used during the asynchronous work execution to provide progress data back to JavaScript.
-
-Definition:
-
-```c++
-class AsyncProgressWorker : public AsyncWorker {
- public:
-  explicit AsyncProgressWorker(Callback *callback_);
-
-  virtual ~AsyncProgressWorker();
-
-  void WorkProgress();
-
-  class ExecutionProgress {
-   public:
-    void Send(const char* data, size_t size) const;
-  };
-
-  virtual void Execute(const ExecutionProgress& progress) = 0;
-
-  virtual void HandleProgressCallback(const char *data, size_t size) = 0;
-
-  virtual void Destroy();
-```
-
-<a name="api_nan_async_queue_worker"></a>
-### Nan::AsyncQueueWorker
-
-`Nan::AsyncQueueWorker` will run a `Nan::AsyncWorker` asynchronously via libuv. Both the `execute` and `after_work` steps are taken care of for you. Most of the logic for this is embedded in `Nan::AsyncWorker`.
-
-Definition:
-
-```c++
-void AsyncQueueWorker(AsyncWorker *);
-```

tools/LiveTexturing/LiveTexturing/node_modules/zmq/node_modules/nan/doc/buffers.md

@@ -1,54 +0,0 @@
-## Buffers
-
-NAN's `node::Buffer` helpers exist as the API has changed across supported Node versions. Use these methods to ensure compatibility.
-
- - <a href="#api_nan_new_buffer"><b><code>Nan::NewBuffer()</code></b></a>
- - <a href="#api_nan_copy_buffer"><b><code>Nan::CopyBuffer()</code></b></a>
- - <a href="#api_nan_free_callback"><b><code>Nan::FreeCallback()</code></b></a>
-
-<a name="api_nan_new_buffer"></a>
-### Nan::NewBuffer()
-
-Allocate a new `node::Buffer` object with the specified size and optional data. Calls `node::Buffer::New()`.
-
-Note that when creating a `Buffer` using `Nan::NewBuffer()` and an existing `char*`, it is assumed that the ownership of the pointer is being transferred to the new `Buffer` for management.
-When a `node::Buffer` instance is garbage collected and a `FreeCallback` has not been specified, `data` will be disposed of via a call to `free()`.
-You _must not_ free the memory space manually once you have created a `Buffer` in this way.
-
-Signature:
-
-```c++
-Nan::MaybeLocal<v8::Object> Nan::NewBuffer(uint32_t size)
-Nan::MaybeLocal<v8::Object> Nan::NewBuffer(char* data, uint32_t size)
-Nan::MaybeLocal<v8::Object> Nan::NewBuffer(char *data,
-                                           size_t length,
-                                           Nan::FreeCallback callback,
-                                           void *hint)
-```
-
-
-<a name="api_nan_copy_buffer"></a>
-### Nan::CopyBuffer()
-
-Similar to [`Nan::NewBuffer()`](#api_nan_new_buffer) except that an implicit memcpy will occur within Node. Calls `node::Buffer::Copy()`.
-
-Management of the `char*` is left to the user, you should manually free the memory space if necessary as the new `Buffer` will have its own copy.
-
-Signature:
-
-```c++
-Nan::MaybeLocal<v8::Object> Nan::CopyBuffer(const char *data, uint32_t size)
-```
-
-
-<a name="api_nan_free_callback"></a>
-### Nan::FreeCallback()
-
-A free callback that can be provided to [`Nan::NewBuffer()`](#api_nan_new_buffer).
-The supplied callback will be invoked when the `Buffer` undergoes garbage collection.
-
-Signature:
-
-```c++
-typedef void (*FreeCallback)(char *data, void *hint);
-```

tools/LiveTexturing/LiveTexturing/node_modules/zmq/node_modules/nan/doc/callback.md

@@ -1,52 +0,0 @@
-## Nan::Callback
-
-`Nan::Callback` makes it easier to use `v8::Function` handles as callbacks. A class that wraps a `v8::Function` handle, protecting it from garbage collection and making it particularly useful for storage and use across asynchronous execution.
-
- - <a href="#api_nan_callback"><b><code>Nan::Callback</code></b></a>
-
-<a name="api_nan_callback"></a>
-### Nan::Callback
-
-```c++
-class Callback {
- public:
-  Callback();
-
-  explicit Callback(const v8::Local<v8::Function> &fn);
-
-  ~Callback();
-
-  bool operator==(const Callback &other) const;
-
-  bool operator!=(const Callback &other) const;
-
-  v8::Local<v8::Function> operator*() const;
-
-  v8::Local<v8::Value> operator()(v8::Local<v8::Object> target,
-                                  int argc = 0,
-                                  v8::Local<v8::Value> argv[] = 0) const;
-
-  v8::Local<v8::Value> operator()(int argc = 0,
-                                  v8::Local<v8::Value> argv[] = 0) const;
-
-  void SetFunction(const v8::Local<v8::Function> &fn);
-
-  v8::Local<v8::Function> GetFunction() const;
-
-  bool IsEmpty() const;
-
-  v8::Local<v8::Value> Call(v8::Local<v8::Object> target,
-                            int argc,
-                            v8::Local<v8::Value> argv[]) const;
-
-  v8::Local<v8::Value> Call(int argc, v8::Local<v8::Value> argv[]) const;
-};
-```
-
-Example usage:
-
-```c++
-v8::Local<v8::Function> function;
-Nan::Callback callback(function);
-callback->Call(0, 0);
-```

tools/LiveTexturing/LiveTexturing/node_modules/zmq/node_modules/nan/doc/converters.md

@@ -1,41 +0,0 @@
-## Converters
-
-NAN contains functions that convert `v8::Value`s to other `v8::Value` types and native types. Since type conversion is not guaranteed to succeed, they return `Nan::Maybe` types. These converters can be used in place of `value->ToX()` and `value->XValue()` (where `X` is one of the types, e.g. `Boolean`) in a way that provides a consistent interface across V8 versions. Newer versions of V8 use the new `v8::Maybe` and `v8::MaybeLocal` types for these conversions, older versions don't have this functionality so it is provided by NAN.
-
- - <a href="#api_nan_to"><b><code>Nan::To()</code></b></a>
-
-<a name="api_nan_to"></a>
-### Nan::To()
-
-Converts a `v8::Local<v8::Value>` to a different subtype of `v8::Value` or to a native data type. Returns a `Nan::MaybeLocal<>` or a `Nan::Maybe<>` accordingly.
-
-See [maybe_types.md](./maybe_types.md) for more information on `Nan::Maybe` types.
-
-Signatures:
-
-```c++
-// V8 types
-Nan::MaybeLocal<v8::Boolean> Nan::To<v8::Boolean>(v8::Local<v8::Value> val);
-Nan::MaybeLocal<v8::Int32> Nan::To<v8::Int32>(v8::Local<v8::Value> val);
-Nan::MaybeLocal<v8::Integer> Nan::To<v8::Integer>(v8::Local<v8::Value> val);
-Nan::MaybeLocal<v8::Object> Nan::To<v8::Object>(v8::Local<v8::Value> val);
-Nan::MaybeLocal<v8::Number> Nan::To<v8::Number>(v8::Local<v8::Value> val);
-Nan::MaybeLocal<v8::String> Nan::To<v8::String>(v8::Local<v8::Value> val);
-Nan::MaybeLocal<v8::Uint32> Nan::To<v8::Uint32>(v8::Local<v8::Value> val);
-
-// Native types
-Nan::Maybe<bool> Nan::To<bool>(v8::Local<v8::Value> val);
-Nan::Maybe<double> Nan::To<double>(v8::Local<v8::Value> val);
-Nan::Maybe<int32_t> Nan::To<int32_t>(v8::Local<v8::Value> val);
-Nan::Maybe<int64_t> Nan::To<int64_t>(v8::Local<v8::Value> val);
-Nan::Maybe<uint32_t> Nan::To<uint32_t>(v8::Local<v8::Value> val);
-```
-
-### Example
-
-```c++
-v8::Local<v8::Value> val;
-Nan::MaybeLocal<v8::String> str = Nan::To<v8::String>(val);
-Nan::Maybe<double> d = Nan::To<double>(val);
-```
-

tools/LiveTexturing/LiveTexturing/node_modules/zmq/node_modules/nan/doc/errors.md

@@ -1,226 +0,0 @@
-## Errors
-
-NAN includes helpers for creating, throwing and catching Errors as much of this functionality varies across the supported versions of V8 and must be abstracted.
-
-Note that an Error object is simply a specialized form of `v8::Value`.
-
-Also consult the V8 Embedders Guide section on [Exceptions](https://developers.google.com/v8/embed#exceptions) for more information.
-
- - <a href="#api_nan_error"><b><code>Nan::Error()</code></b></a>
- - <a href="#api_nan_range_error"><b><code>Nan::RangeError()</code></b></a>
- - <a href="#api_nan_reference_error"><b><code>Nan::ReferenceError()</code></b></a>
- - <a href="#api_nan_syntax_error"><b><code>Nan::SyntaxError()</code></b></a>
- - <a href="#api_nan_type_error"><b><code>Nan::TypeError()</code></b></a>
- - <a href="#api_nan_throw_error"><b><code>Nan::ThrowError()</code></b></a>
- - <a href="#api_nan_throw_range_error"><b><code>Nan::ThrowRangeError()</code></b></a>
- - <a href="#api_nan_throw_reference_error"><b><code>Nan::ThrowReferenceError()</code></b></a>
- - <a href="#api_nan_throw_syntax_error"><b><code>Nan::ThrowSyntaxError()</code></b></a>
- - <a href="#api_nan_throw_type_error"><b><code>Nan::ThrowTypeError()</code></b></a>
- - <a href="#api_nan_fatal_exception"><b><code>Nan::FatalException()</code></b></a>
- - <a href="#api_nan_errno_exception"><b><code>Nan::ErrnoException()</code></b></a>
- - <a href="#api_nan_try_catch"><b><code>Nan::TryCatch</code></b></a>
-
-
-<a name="api_nan_error"></a>
-### Nan::Error()
-
-Create a new Error object using the [v8::Exception](https://v8docs.nodesource.com/io.js-3.0/da/d6a/classv8_1_1_exception.html) class in a way that is compatible across the supported versions of V8.
-
-Note that an Error object is simply a specialized form of `v8::Value`.
-
-Signature:
-
-```c++
-v8::Local<v8::Value> Nan::Error(const char *msg);
-v8::Local<v8::Value> Nan::Error(v8::Local<v8::String> msg);
-```
-
-
-<a name="api_nan_range_error"></a>
-### Nan::RangeError()
-
-Create a new RangeError object using the [v8::Exception](https://v8docs.nodesource.com/io.js-3.0/da/d6a/classv8_1_1_exception.html) class in a way that is compatible across the supported versions of V8.
-
-Note that an RangeError object is simply a specialized form of `v8::Value`.
-
-Signature:
-
-```c++
-v8::Local<v8::Value> Nan::RangeError(const char *msg);
-v8::Local<v8::Value> Nan::RangeError(v8::Local<v8::String> msg);
-```
-
-
-<a name="api_nan_reference_error"></a>
-### Nan::ReferenceError()
-
-Create a new ReferenceError object using the [v8::Exception](https://v8docs.nodesource.com/io.js-3.0/da/d6a/classv8_1_1_exception.html) class in a way that is compatible across the supported versions of V8.
-
-Note that an ReferenceError object is simply a specialized form of `v8::Value`.
-
-Signature:
-
-```c++
-v8::Local<v8::Value> Nan::ReferenceError(const char *msg);
-v8::Local<v8::Value> Nan::ReferenceError(v8::Local<v8::String> msg);
-```
-
-
-<a name="api_nan_syntax_error"></a>
-### Nan::SyntaxError()
-
-Create a new SyntaxError object using the [v8::Exception](https://v8docs.nodesource.com/io.js-3.0/da/d6a/classv8_1_1_exception.html) class in a way that is compatible across the supported versions of V8.
-
-Note that an SyntaxError object is simply a specialized form of `v8::Value`.
-
-Signature:
-
-```c++
-v8::Local<v8::Value> Nan::SyntaxError(const char *msg);
-v8::Local<v8::Value> Nan::SyntaxError(v8::Local<v8::String> msg);
-```
-
-
-<a name="api_nan_type_error"></a>
-### Nan::TypeError()
-
-Create a new TypeError object using the [v8::Exception](https://v8docs.nodesource.com/io.js-3.0/da/d6a/classv8_1_1_exception.html) class in a way that is compatible across the supported versions of V8.
-
-Note that an TypeError object is simply a specialized form of `v8::Value`.
-
-Signature:
-
-```c++
-v8::Local<v8::Value> Nan::TypeError(const char *msg);
-v8::Local<v8::Value> Nan::TypeError(v8::Local<v8::String> msg);
-```
-
-
-<a name="api_nan_throw_error"></a>
-### Nan::ThrowError()
-
-Throw an Error object (a specialized `v8::Value` as above) in the current context. If a `msg` is provided, a new Error object will be created.
-
-Signature:
-
-```c++
-void Nan::ThrowError(const char *msg);
-void Nan::ThrowError(v8::Local<v8::String> msg);
-void Nan::ThrowError(v8::Local<v8::Value> error);
-```
-
-
-<a name="api_nan_throw_range_error"></a>
-### Nan::ThrowRangeError()
-
-Throw an RangeError object (a specialized `v8::Value` as above) in the current context. If a `msg` is provided, a new RangeError object will be created.
-
-Signature:
-
-```c++
-void Nan::ThrowRangeError(const char *msg);
-void Nan::ThrowRangeError(v8::Local<v8::String> msg);
-void Nan::ThrowRangeError(v8::Local<v8::Value> error);
-```
-
-
-<a name="api_nan_throw_reference_error"></a>
-### Nan::ThrowReferenceError()
-
-Throw an ReferenceError object (a specialized `v8::Value` as above) in the current context. If a `msg` is provided, a new ReferenceError object will be created.
-
-Signature:
-
-```c++
-void Nan::ThrowReferenceError(const char *msg);
-void Nan::ThrowReferenceError(v8::Local<v8::String> msg);
-void Nan::ThrowReferenceError(v8::Local<v8::Value> error);
-```
-
-
-<a name="api_nan_throw_syntax_error"></a>
-### Nan::ThrowSyntaxError()
-
-Throw an SyntaxError object (a specialized `v8::Value` as above) in the current context. If a `msg` is provided, a new SyntaxError object will be created.
-
-Signature:
-
-```c++
-void Nan::ThrowSyntaxError(const char *msg);
-void Nan::ThrowSyntaxError(v8::Local<v8::String> msg);
-void Nan::ThrowSyntaxError(v8::Local<v8::Value> error);
-```
-
-
-<a name="api_nan_throw_type_error"></a>
-### Nan::ThrowTypeError()
-
-Throw an TypeError object (a specialized `v8::Value` as above) in the current context. If a `msg` is provided, a new TypeError object will be created.
-
-Signature:
-
-```c++
-void Nan::ThrowTypeError(const char *msg);
-void Nan::ThrowTypeError(v8::Local<v8::String> msg);
-void Nan::ThrowTypeError(v8::Local<v8::Value> error);
-```
-
-<a name="api_nan_fatal_exception"></a>
-### Nan::FatalException()
-
-Replaces `node::FatalException()` which has a different API across supported versions of Node. For use with [`Nan::TryCatch`](#api_nan_try_catch).
-
-Signature:
-
-```c++
-void Nan::FatalException(const Nan::TryCatch& try_catch);
-```
-
-<a name="api_nan_errno_exception"></a>
-### Nan::ErrnoException()
-
-Replaces `node::ErrnoException()` which has a different API across supported versions of Node. 
-
-Signature:
-
-```c++
-v8::Local<v8::Value> Nan::ErrnoException(int errorno,
-                                         const char* syscall = NULL,
-                                         const char* message = NULL,
-                                         const char* path = NULL);
-```
-
-
-<a name="api_nan_try_catch"></a>
-### Nan::TryCatch
-
-A simple wrapper around [`v8::TryCatch`](https://v8docs.nodesource.com/io.js-3.0/d4/dc6/classv8_1_1_try_catch.html) compatible with all supported versions of V8. Can be used as a direct replacement in most cases. See also [`Nan::FatalException()`](#api_nan_fatal_exception) for an internal use compatible with `node::FatalException`.
-
-Signature:
-
-```c++
-class Nan::TryCatch {
- public:
-  Nan::TryCatch();
-
-  bool HasCaught() const;
-
-  bool CanContinue() const;
-
-  v8::Local<v8::Value> ReThrow();
-
-  v8::Local<v8::Value> Exception() const;
-
-  // Nan::MaybeLocal for older versions of V8
-  v8::MaybeLocal<v8::Value> StackTrace() const;
-
-  v8::Local<v8::Message> Message() const;
-
-  void Reset();
-
-  void SetVerbose(bool value);
-
-  void SetCaptureMessage(bool value);
-};
-```
-

tools/LiveTexturing/LiveTexturing/node_modules/zmq/node_modules/nan/doc/maybe_types.md

@@ -1,480 +0,0 @@
-## Maybe Types
-
-The `Nan::MaybeLocal` and `Nan::Maybe` types are monads that encapsulate `v8::Local` handles that _may be empty_.
-
-* **Maybe Types**
-  - <a href="#api_nan_maybe_local"><b><code>Nan::MaybeLocal</code></b></a>
-  - <a href="#api_nan_maybe"><b><code>Nan::Maybe</code></b></a>
-  - <a href="#api_nan_nothing"><b><code>Nan::Nothing</code></b></a>
-  - <a href="#api_nan_just"><b><code>Nan::Just</code></b></a>
-* **Maybe Helpers**
-  - <a href="#api_nan_to_detail_string"><b><code>Nan::ToDetailString()</code></b></a>
-  - <a href="#api_nan_to_array_index"><b><code>Nan::ToArrayIndex()</code></b></a>
-  - <a href="#api_nan_equals"><b><code>Nan::Equals()</code></b></a>
-  - <a href="#api_nan_new_instance"><b><code>Nan::NewInstance()</code></b></a>
-  - <a href="#api_nan_get_function"><b><code>Nan::GetFunction()</code></b></a>
-  - <a href="#api_nan_set"><b><code>Nan::Set()</code></b></a>
-  - <a href="#api_nan_force_set"><b><code>Nan::ForceSet()</code></b></a>
-  - <a href="#api_nan_get"><b><code>Nan::Get()</code></b></a>
-  - <a href="#api_nan_get_property_attribute"><b><code>Nan::GetPropertyAttributes()</code></b></a>
-  - <a href="#api_nan_has"><b><code>Nan::Has()</code></b></a>
-  - <a href="#api_nan_delete"><b><code>Nan::Delete()</code></b></a>
-  - <a href="#api_nan_get_property_names"><b><code>Nan::GetPropertyNames()</code></b></a>
-  - <a href="#api_nan_get_own_property_names"><b><code>Nan::GetOwnPropertyNames()</code></b></a>
-  - <a href="#api_nan_set_prototype"><b><code>Nan::SetPrototype()</code></b></a>
-  - <a href="#api_nan_object_proto_to_string"><b><code>Nan::ObjectProtoToString()</code></b></a>
-  - <a href="#api_nan_has_own_property"><b><code>Nan::HasOwnProperty()</code></b></a>
-  - <a href="#api_nan_has_real_named_property"><b><code>Nan::HasRealNamedProperty()</code></b></a>
-  - <a href="#api_nan_has_real_indexed_property"><b><code>Nan::HasRealIndexedProperty()</code></b></a>
-  - <a href="#api_nan_has_real_named_callback_property"><b><code>Nan::HasRealNamedCallbackProperty()</code></b></a>
-  - <a href="#api_nan_get_real_named_property_in_prototype_chain"><b><code>Nan::GetRealNamedPropertyInPrototypeChain()</code></b></a>
-  - <a href="#api_nan_get_real_named_property"><b><code>Nan::GetRealNamedProperty()</code></b></a>
-  - <a href="#api_nan_call_as_function"><b><code>Nan::CallAsFunction()</code></b></a>
-  - <a href="#api_nan_call_as_constructor"><b><code>Nan::CallAsConstructor()</code></b></a>
-  - <a href="#api_nan_get_source_line"><b><code>Nan::GetSourceLine()</code></b></a>
-  - <a href="#api_nan_get_line_number"><b><code>Nan::GetLineNumber()</code></b></a>
-  - <a href="#api_nan_get_start_column"><b><code>Nan::GetStartColumn()</code></b></a>
-  - <a href="#api_nan_get_end_column"><b><code>Nan::GetEndColumn()</code></b></a>
-  - <a href="#api_nan_clone_element_at"><b><code>Nan::CloneElementAt()</code></b></a>
-
-<a name="api_nan_maybe_local"></a>
-### Nan::MaybeLocal
-
-A `Nan::MaybeLocal<T>` is a wrapper around [`v8::Local<T>`](https://v8docs.nodesource.com/io.js-3.0/de/deb/classv8_1_1_local.html) that enforces a check that determines whether the `v8::Local<T>` is empty before it can be used.
-
-If an API method returns a `Nan::MaybeLocal`, the API method can potentially fail either because an exception is thrown, or because an exception is pending, e.g. because a previous API call threw an exception that hasn't been caught yet, or because a `v8::TerminateExecution` exception was thrown. In that case, an empty `Nan::MaybeLocal` is returned.
-
-Definition:
-
-```c++
-template<typename T> class Nan::MaybeLocal {
- public:
-  MaybeLocal();
-
-  template<typename S> MaybeLocal(v8::Local<S> that);
-
-  bool IsEmpty() const;
-
-  template<typename S> bool ToLocal(v8::Local<S> *out);
-
-  // Will crash if the MaybeLocal<> is empty.
-  v8::Local<T> ToLocalChecked();
-
-  template<typename S> v8::Local<S> FromMaybe(v8::Local<S> default_value) const;
-};
-```
-
-See the documentation for [`v8::MaybeLocal`](https://v8docs.nodesource.com/io.js-3.0/d8/d7d/classv8_1_1_maybe_local.html) for further details.
-
-<a name="api_nan_maybe"></a>
-### Nan::Maybe
-
-A simple `Nan::Maybe` type, representing an object which may or may not have a value, see https://hackage.haskell.org/package/base/docs/Data-Maybe.html.
-
-If an API method returns a `Nan::Maybe<>`, the API method can potentially fail either because an exception is thrown, or because an exception is pending, e.g. because a previous API call threw an exception that hasn't been caught yet, or because a `v8::TerminateExecution` exception was thrown. In that case, a "Nothing" value is returned.
-
-Definition:
-
-```c++
-template<typename T> class Nan::Maybe {
- public:
-  bool IsNothing() const;
-  bool IsJust() const;
-
-  // Will crash if the Maybe<> is nothing.
-  T FromJust();
-
-  T FromMaybe(const T& default_value);
-
-  bool operator==(const Maybe &other);
-
-  bool operator!=(const Maybe &other);
-};
-```
-
-See the documentation for [`v8::Maybe`](https://v8docs.nodesource.com/io.js-3.0/d9/d4b/classv8_1_1_maybe.html) for further details.
-
-<a name="api_nan_nothing"></a>
-### Nan::Nothing
-
-Construct an empty `Nan::Maybe` type representing _nothing_.
-
-```c++
-template<typename T> Nan::Maybe<T> Nan::Nothing();
-```
-
-<a name="api_nan_just"></a>
-### Nan::Just
-
-Construct a `Nan::Maybe` type representing _just_ a value.
-
-```c++
-template<typename T> Nan::Maybe<T> Nan::Just(const T &t);
-```
-
-
-<a name="api_nan_to_detail_string"></a>
-### Nan::ToDetailString()
-
-A helper method for calling [`v8::Value#ToDetailString()`](https://v8docs.nodesource.com/io.js-3.0/dc/d0a/classv8_1_1_value.html#a2f9770296dc2c8d274bc8cc0dca243e5) in a way compatible across supported versions of V8.
-
-Signature:
-
-```c++
-Nan::MaybeLocal<v8::String> Nan::ToDetailString(v8::Local<v8::Value> val);
-```
-
-
-<a name="api_nan_to_array_index"></a>
-### Nan::ToArrayIndex()
-
-A helper method for calling [`v8::Value#ToArrayIndex()`](https://v8docs.nodesource.com/io.js-3.0/dc/d0a/classv8_1_1_value.html#acc5bbef3c805ec458470c0fcd6f13493) in a way compatible across supported versions of V8.
-
-Signature:
-
-```c++
-Nan::MaybeLocal<v8::Uint32> Nan::ToArrayIndex(v8::Local<v8::Value> val);
-```
-
-
-<a name="api_nan_equals"></a>
-### Nan::Equals()
-
-A helper method for calling [`v8::Value#Equals()`](https://v8docs.nodesource.com/io.js-3.0/dc/d0a/classv8_1_1_value.html#a0d9616ab2de899d4e3047c30a10c9285) in a way compatible across supported versions of V8.
-
-Signature:
-
-```c++
-Nan::Maybe<bool> Nan::Equals(v8::Local<v8::Value> a, v8::Local<v8::Value>(b));
-```
-
-
-<a name="api_nan_new_instance"></a>
-### Nan::NewInstance()
-
-A helper method for calling [`v8::Function#NewInstance()`](https://v8docs.nodesource.com/io.js-3.0/d5/d54/classv8_1_1_function.html#a691b13f7a553069732cbacf5ac8c62ec) and [`v8::ObjectTemplate#NewInstance()`](https://v8docs.nodesource.com/io.js-3.0/db/d5f/classv8_1_1_object_template.html#ad605a7543cfbc5dab54cdb0883d14ae4) in a way compatible across supported versions of V8.
-
-Signature:
-
-```c++
-Nan::MaybeLocal<v8::Object> Nan::NewInstance(v8::Local<v8::Function> h);
-Nan::MaybeLocal<v8::Object> Nan::NewInstance(v8::Local<v8::Function> h, int argc, v8::Local<v8::Value> argv[]);
-Nan::MaybeLocal<v8::Object> Nan::NewInstance(v8::Local<v8::ObjectTemplate> h);
-```
-
-
-<a name="api_nan_get_function"></a>
-### Nan::GetFunction()
-
-A helper method for calling [`v8::FunctionTemplate#GetFunction()`](https://v8docs.nodesource.com/io.js-3.0/d8/d83/classv8_1_1_function_template.html#a56d904662a86eca78da37d9bb0ed3705) in a way compatible across supported versions of V8.
-
-Signature:
-
-```c++
-Nan::MaybeLocal<v8::Function> Nan::GetFunction(v8::Local<v8::FunctionTemplate> t);
-```
-
-
-<a name="api_nan_set"></a>
-### Nan::Set()
-
-A helper method for calling [`v8::Object#Set()`](https://v8docs.nodesource.com/io.js-3.0/db/d85/classv8_1_1_object.html#a67604ea3734f170c66026064ea808f20) in a way compatible across supported versions of V8.
-
-Signature:
-
-```c++
-Nan::Maybe<bool> Nan::Set(v8::Local<v8::Object> obj,
-                          v8::Local<v8::Value> key,
-                          v8::Local<v8::Value> value)
-Nan::Maybe<bool> Nan::Set(v8::Local<v8::Object> obj,
-                          uint32_t index,
-                          v8::Local<v8::Value> value);
-```
-
-
-<a name="api_nan_force_set"></a>
-### Nan::ForceSet()
-
-A helper method for calling [`v8::Object#ForceSet()`](https://v8docs.nodesource.com/io.js-3.0/db/d85/classv8_1_1_object.html#a796b7b682896fb64bf1872747734e836) in a way compatible across supported versions of V8.
-
-Signature:
-
-```c++
-Nan::Maybe<bool> Nan::ForceSet(v8::Local<v8::Object> obj,
-                               v8::Local<v8::Value> key,
-                               v8::Local<v8::Value> value,
-                               v8::PropertyAttribute attribs = v8::None);
-```
-
-
-<a name="api_nan_get"></a>
-### Nan::Get()
-
-A helper method for calling [`v8::Object#Get()`](https://v8docs.nodesource.com/io.js-3.0/db/d85/classv8_1_1_object.html#a2565f03e736694f6b1e1cf22a0b4eac2) in a way compatible across supported versions of V8.
-
-Signature:
-
-```c++
-Nan::MaybeLocal<v8::Value> Nan::Get(v8::Local<v8::Object> obj,
-                                    v8::Local<v8::Value> key);
-Nan::MaybeLocal<v8::Value> Nan::Get(v8::Local<v8::Object> obj, uint32_t index);
-```
-
-
-<a name="api_nan_get_property_attribute"></a>
-### Nan::GetPropertyAttributes()
-
-A helper method for calling [`v8::Object#GetPropertyAttributes()`](https://v8docs.nodesource.com/io.js-3.0/db/d85/classv8_1_1_object.html#a9b898894da3d1db2714fd9325a54fe57) in a way compatible across supported versions of V8.
-
-Signature:
-
-```c++
-Nan::Maybe<v8::PropertyAttribute> Nan::GetPropertyAttributes(
-    v8::Local<v8::Object> obj,
-    v8::Local<v8::Value> key);
-```
-
-
-<a name="api_nan_has"></a>
-### Nan::Has()
-
-A helper method for calling [`v8::Object#Has()`](https://v8docs.nodesource.com/io.js-3.0/db/d85/classv8_1_1_object.html#ab3c3d89ea7c2f9afd08965bd7299a41d) in a way compatible across supported versions of V8.
-
-Signature:
-
-```c++
-Nan::Maybe<bool> Nan::Has(v8::Local<v8::Object> obj, v8::Local<v8::String> key);
-Nan::Maybe<bool> Nan::Has(v8::Local<v8::Object> obj, uint32_t index);
-```
-
-
-<a name="api_nan_delete"></a>
-### Nan::Delete()
-
-A helper method for calling [`v8::Object#Delete()`](https://v8docs.nodesource.com/io.js-3.0/db/d85/classv8_1_1_object.html#a2fa0f5a592582434ed1ceceff7d891ef) in a way compatible across supported versions of V8.
-
-Signature:
-
-```c++
-Nan::Maybe<bool> Nan::Delete(v8::Local<v8::Object> obj,
-                             v8::Local<v8::String> key);
-Nan::Maybe<bool> Nan::Delete(v8::Local<v8::Object> obj, uint32_t index);
-```
-
-
-<a name="api_nan_get_property_names"></a>
-### Nan::GetPropertyNames()
-
-A helper method for calling [`v8::Object#GetPropertyNames()`](https://v8docs.nodesource.com/io.js-3.0/db/d85/classv8_1_1_object.html#aced885270cfd2c956367b5eedc7fbfe8) in a way compatible across supported versions of V8.
-
-Signature:
-
-```c++
-Nan::MaybeLocal<v8::Array> Nan::GetPropertyNames(v8::Local<v8::Object> obj);
-```
-
-
-<a name="api_nan_get_own_property_names"></a>
-### Nan::GetOwnPropertyNames()
-
-A helper method for calling [`v8::Object#GetOwnPropertyNames()`](https://v8docs.nodesource.com/io.js-3.0/db/d85/classv8_1_1_object.html#a79a6e4d66049b9aa648ed4dfdb23e6eb) in a way compatible across supported versions of V8.
-
-Signature:
-
-```c++
-Nan::MaybeLocal<v8::Array> Nan::GetOwnPropertyNames(v8::Local<v8::Object> obj);
-```
-
-
-<a name="api_nan_set_prototype"></a>
-### Nan::SetPrototype()
-
-A helper method for calling [`v8::Object#SetPrototype()`](https://v8docs.nodesource.com/io.js-3.0/db/d85/classv8_1_1_object.html#a442706b22fceda6e6d1f632122a9a9f4) in a way compatible across supported versions of V8.
-
-Signature:
-
-```c++
-Nan::Maybe<bool> Nan::SetPrototype(v8::Local<v8::Object> obj,
-                                   v8::Local<v8::Value> prototype);
-```
-
-
-<a name="api_nan_object_proto_to_string"></a>
-### Nan::ObjectProtoToString()
-
-A helper method for calling [`v8::Object#ObjectProtoToString()`](https://v8docs.nodesource.com/io.js-3.0/db/d85/classv8_1_1_object.html#ab7a92b4dcf822bef72f6c0ac6fea1f0b) in a way compatible across supported versions of V8.
-
-Signature:
-
-```c++
-Nan::MaybeLocal<v8::String> Nan::ObjectProtoToString(v8::Local<v8::Object> obj);
-```
-
-
-<a name="api_nan_has_own_property"></a>
-### Nan::HasOwnProperty()
-
-A helper method for calling [`v8::Object#HasOwnProperty()`](https://v8docs.nodesource.com/io.js-3.0/db/d85/classv8_1_1_object.html#ab7b7245442ca6de1e1c145ea3fd653ff) in a way compatible across supported versions of V8.
-
-Signature:
-
-```c++
-Nan::Maybe<bool> Nan::HasOwnProperty(v8::Local<v8::Object> obj,
-                                     v8::Local<v8::String> key);
-```
-
-
-<a name="api_nan_has_real_named_property"></a>
-### Nan::HasRealNamedProperty()
-
-A helper method for calling [`v8::Object#HasRealNamedProperty()`](https://v8docs.nodesource.com/io.js-3.0/db/d85/classv8_1_1_object.html#ad8b80a59c9eb3c1e6c3cd6c84571f767) in a way compatible across supported versions of V8.
-
-Signature:
-
-```c++
-Nan::Maybe<bool> Nan::HasRealNamedProperty(v8::Local<v8::Object> obj,
-                                           v8::Local<v8::String> key);
-```
-
-
-<a name="api_nan_has_real_indexed_property"></a>
-### Nan::HasRealIndexedProperty()
-
-A helper method for calling [`v8::Object#HasRealIndexedProperty()`](https://v8docs.nodesource.com/io.js-3.0/db/d85/classv8_1_1_object.html#af94fc1135a5e74a2193fb72c3a1b9855) in a way compatible across supported versions of V8.
-
-Signature:
-
-```c++
-Nan::Maybe<bool> Nan::HasRealIndexedProperty(v8::Local<v8::Object> obj,
-                                             uint32_t index);
-```
-
-
-<a name="api_nan_has_real_named_callback_property"></a>
-### Nan::HasRealNamedCallbackProperty()
-
-A helper method for calling [`v8::Object#HasRealNamedCallbackProperty()`](https://v8docs.nodesource.com/io.js-3.0/db/d85/classv8_1_1_object.html#af743b7ea132b89f84d34d164d0668811) in a way compatible across supported versions of V8.
-
-Signature:
-
-```c++
-Nan::Maybe<bool> Nan::HasRealNamedCallbackProperty(
-    v8::Local<v8::Object> obj,
-    v8::Local<v8::String> key);
-```
-
-
-<a name="api_nan_get_real_named_property_in_prototype_chain"></a>
-### Nan::GetRealNamedPropertyInPrototypeChain()
-
-A helper method for calling [`v8::Object#GetRealNamedPropertyInPrototypeChain()`](https://v8docs.nodesource.com/io.js-3.0/db/d85/classv8_1_1_object.html#a8700b1862e6b4783716964ba4d5e6172) in a way compatible across supported versions of V8.
-
-Signature:
-
-```c++
-Nan::MaybeLocal<v8::Value> Nan::GetRealNamedPropertyInPrototypeChain(
-    v8::Local<v8::Object> obj,
-    v8::Local<v8::String> key);
-```
-
-
-<a name="api_nan_get_real_named_property"></a>
-### Nan::GetRealNamedProperty()
-
-A helper method for calling [`v8::Object#GetRealNamedProperty()`](https://v8docs.nodesource.com/io.js-3.0/db/d85/classv8_1_1_object.html#a84471a824576a5994fdd0ffcbf99ccc0) in a way compatible across supported versions of V8.
-
-Signature:
-
-```c++
-Nan::MaybeLocal<v8::Value> Nan::GetRealNamedProperty(v8::Local<v8::Object> obj,
-                                                     v8::Local<v8::String> key);
-```
-
-
-<a name="api_nan_call_as_function"></a>
-### Nan::CallAsFunction()
-
-A helper method for calling [`v8::Object#CallAsFunction()`](https://v8docs.nodesource.com/io.js-3.0/db/d85/classv8_1_1_object.html#a9ef18be634e79b4f0cdffa1667a29f58) in a way compatible across supported versions of V8.
-
-Signature:
-
-```c++
-Nan::MaybeLocal<v8::Value> Nan::CallAsFunction(v8::Local<v8::Object> obj,
-                                               v8::Local<v8::Object> recv,
-                                               int argc,
-                                               v8::Local<v8::Value> argv[]);
-```
-
-
-<a name="api_nan_call_as_constructor"></a>
-### Nan::CallAsConstructor()
-
-A helper method for calling [`v8::Object#CallAsConstructor()`](https://v8docs.nodesource.com/io.js-3.0/db/d85/classv8_1_1_object.html#a50d571de50d0b0dfb28795619d07a01b) in a way compatible across supported versions of V8.
-
-Signature:
-
-```c++
-Nan::MaybeLocal<v8::Value> Nan::CallAsConstructor(v8::Local<v8::Object> obj,
-                                                  int argc,
-                                                  v8::Local<v8::Value> argv[]);
-```
-
-
-<a name="api_nan_get_source_line"></a>
-### Nan::GetSourceLine()
-
-A helper method for calling [`v8::Message#GetSourceLine()`](https://v8docs.nodesource.com/io.js-3.0/d9/d28/classv8_1_1_message.html#a849f7a6c41549d83d8159825efccd23a) in a way compatible across supported versions of V8.
-
-Signature:
-
-```c++
-Nan::MaybeLocal<v8::String> Nan::GetSourceLine(v8::Local<v8::Message> msg);
-```
-
-
-<a name="api_nan_get_line_number"></a>
-### Nan::GetLineNumber()
-
-A helper method for calling [`v8::Message#GetLineNumber()`](https://v8docs.nodesource.com/io.js-3.0/d9/d28/classv8_1_1_message.html#adbe46c10a88a6565f2732a2d2adf99b9) in a way compatible across supported versions of V8.
-
-Signature:
-
-```c++
-Nan::Maybe<int> Nan::GetLineNumber(v8::Local<v8::Message> msg);
-```
-
-
-<a name="api_nan_get_start_column"></a>
-### Nan::GetStartColumn()
-
-A helper method for calling [`v8::Message#GetStartColumn()`](https://v8docs.nodesource.com/io.js-3.0/d9/d28/classv8_1_1_message.html#a60ede616ba3822d712e44c7a74487ba6) in a way compatible across supported versions of V8.
-
-Signature:
-
-```c++
-Nan::Maybe<int> Nan::GetStartColumn(v8::Local<v8::Message> msg);
-```
-
-
-<a name="api_nan_get_end_column"></a>
-### Nan::GetEndColumn()
-
-A helper method for calling [`v8::Message#GetEndColumn()`](https://v8docs.nodesource.com/io.js-3.0/d9/d28/classv8_1_1_message.html#aaa004cf19e529da980bc19fcb76d93be) in a way compatible across supported versions of V8.
-
-Signature:
-
-```c++
-Nan::Maybe<int> Nan::GetEndColumn(v8::Local<v8::Message> msg);
-```
-
-
-<a name="api_nan_clone_element_at"></a>
-### Nan::CloneElementAt()
-
-A helper method for calling [`v8::Array#CloneElementAt()`](https://v8docs.nodesource.com/io.js-3.0/d3/d32/classv8_1_1_array.html#a1d3a878d4c1c7cae974dd50a1639245e) in a way compatible across supported versions of V8.
-
-Signature:
-
-```c++
-Nan::MaybeLocal<v8::Object> Nan::CloneElementAt(v8::Local<v8::Array> array, uint32_t index);
-```

tools/LiveTexturing/LiveTexturing/node_modules/zmq/node_modules/nan/doc/methods.md

@@ -1,624 +0,0 @@
-## JavaScript-accessible methods
-
-A _template_ is a blueprint for JavaScript functions and objects in a context. You can use a template to wrap C++ functions and data structures within JavaScript objects so that they can be manipulated from JavaScript. See the V8 Embedders Guide section on [Templates](https://developers.google.com/v8/embed#templates) for further information.
-
-In order to expose functionality to JavaScript via a template, you must provide it to V8 in a form that it understands. Across the versions of V8 supported by NAN, JavaScript-accessible method signatures vary widely, NAN fully abstracts method declaration and provides you with an interface that is similar to the most recent V8 API but is backward-compatible with older versions that still use the now-deceased `v8::Argument` type.
-
-* **Method argument types**
- - <a href="#api_nan_function_callback_info"><b><code>Nan::FunctionCallbackInfo</code></b></a>
- - <a href="#api_nan_property_callback_info"><b><code>Nan::PropertyCallbackInfo</code></b></a>
- - <a href="#api_nan_return_value"><b><code>Nan::ReturnValue</code></b></a>
-* **Method declarations**
- - <a href="#api_nan_method"><b>Method declaration</b></a>
- - <a href="#api_nan_getter"><b>Getter declaration</b></a>
- - <a href="#api_nan_setter"><b>Setter declaration</b></a>
- - <a href="#api_nan_property_getter"><b>Property getter declaration</b></a>
- - <a href="#api_nan_property_setter"><b>Property setter declaration</b></a>
- - <a href="#api_nan_property_enumerator"><b>Property enumerator declaration</b></a>
- - <a href="#api_nan_property_deleter"><b>Property deleter declaration</b></a>
- - <a href="#api_nan_property_query"><b>Property query declaration</b></a>
- - <a href="#api_nan_index_getter"><b>Index getter declaration</b></a>
- - <a href="#api_nan_index_setter"><b>Index setter declaration</b></a>
- - <a href="#api_nan_index_enumerator"><b>Index enumerator declaration</b></a>
- - <a href="#api_nan_index_deleter"><b>Index deleter declaration</b></a>
- - <a href="#api_nan_index_query"><b>Index query declaration</b></a>
-* Method and template helpers
- - <a href="#api_nan_set_method"><b><code>Nan::SetMethod()</code></b></a>
- - <a href="#api_nan_set_named_property_handler"><b><code>Nan::SetNamedPropertyHandler()</code></b></a>
- - <a href="#api_nan_set_indexed_property_handler"><b><code>Nan::SetIndexedPropertyHandler()</code></b></a>
- - <a href="#api_nan_set_prototype_method"><b><code>Nan::SetPrototypeMethod()</code></b></a>
- - <a href="#api_nan_set_template"><b><code>Nan::SetTemplate()</code></b></a>
- - <a href="#api_nan_set_prototype_template"><b><code>Nan::SetPrototypeTemplate()</code></b></a>
- - <a href="#api_nan_set_instance_template"><b><code>Nan::SetInstanceTemplate()</code></b></a>
-
-<a name="api_nan_function_callback_info"></a>
-### Nan::FunctionCallbackInfo
-
-`Nan::FunctionCallbackInfo` should be used in place of [`v8::FunctionCallbackInfo`](https://v8docs.nodesource.com/io.js-3.0/dd/d0d/classv8_1_1_function_callback_info.html), even with older versions of Node where `v8::FunctionCallbackInfo` does not exist.
-
-Definition:
-
-```c++
-template<typename T> class FunctionCallbackInfo {
- public:
-  ReturnValue<T> GetReturnValue() const;
-  v8::Local<v8::Function> Callee();
-  v8::Local<v8::Value> Data();
-  v8::Local<v8::Object> Holder();
-  bool IsConstructCall();
-  int Length() const;
-  v8::Local<v8::Value> operator[](int i) const;
-  v8::Local<v8::Object> This() const;
-  v8::Isolate *GetIsolate() const;
-};
-```
-
-See the [`v8::FunctionCallbackInfo`](https://v8docs.nodesource.com/io.js-3.0/dd/d0d/classv8_1_1_function_callback_info.html) documentation for usage details on these. See [`Nan::ReturnValue`](#api_nan_return_value) for further information on how to set a return value from methods.
-
-<a name="api_nan_property_callback_info"></a>
-### Nan::PropertyCallbackInfo
-
-`Nan::PropertyCallbackInfo` should be used in place of [`v8::PropertyCallbackInfo`](https://v8docs.nodesource.com/io.js-3.0/d7/dc5/classv8_1_1_property_callback_info.html), even with older versions of Node where `v8::PropertyCallbackInfo` does not exist.
-
-Definition:
-
-```c++
-template<typename T> class PropertyCallbackInfo : public PropertyCallbackInfoBase<T> {
- public:
-  ReturnValue<T> GetReturnValue() const;
-  v8::Isolate* GetIsolate() const;
-  v8::Local<v8::Value> Data() const;
-  v8::Local<v8::Object> This() const;
-  v8::Local<v8::Object> Holder() const;
-};
-```
-
-See the [`v8::PropertyCallbackInfo](https://v8docs.nodesource.com/io.js-3.0/d7/dc5/classv8_1_1_property_callback_info.html) documentation for usage details on these. See [`Nan::ReturnValue`](#api_nan_return_value) for further information on how to set a return value from property accessor methods.
-
-<a name="api_nan_return_value"></a>
-### Nan::ReturnValue
-
-`Nan::ReturnValue` is used in place of [`v8::ReturnValue`](https://v8docs.nodesource.com/io.js-3.0/da/da7/classv8_1_1_return_value.html) on both [`Nan::FunctionCallbackInfo`](#api_nan_function_callback_info) and [`Nan::PropertyCallbackInfo`](#api_nan_property_callback_info) as the return type of `GetReturnValue()`.
-
-Example usage:
-
-```c++
-void EmptyArray(const Nan::FunctionCallbackInfo<v8::Value>& info) {
-  info.GetReturnValue().Set(Nan::New<v8::Array>());
-}
-```
-
-Definition:
-
-```c++
-template<typename T> class ReturnValue {
- public:
-  // Handle setters
-  template <typename S> void Set(const v8::Local<S> &handle);
-  template <typename S> void Set(const Nan::Global<S> &handle);
-
-  // Fast primitive setters
-  void Set(bool value);
-  void Set(double i);
-  void Set(int32_t i);
-  void Set(uint32_t i);
-
-  // Fast JS primitive setters
-  void SetNull();
-  void SetUndefined();
-  void SetEmptyString();
-
-  // Convenience getter for isolate
-  v8::Isolate *GetIsolate() const;
-};
-```
-
-See the documentation on [`v8::ReturnValue`](https://v8docs.nodesource.com/io.js-3.0/da/da7/classv8_1_1_return_value.html) for further information on this.
-
-<a name="api_nan_method"></a>
-### Method declaration
-
-JavaScript-accessible methods should be declared with the following signature to form a `Nan::FunctionCallback`:
-
-```c++
-typedef void(*FunctionCallback)(const FunctionCallbackInfo<v8::Value>&);
-```
-
-Example:
-
-```c++
-void MethodName(const Nan::FunctionCallbackInfo<v8::Value>& info) {
-  ...
-}
-
-You do not need to declare a new `HandleScope` within a method as one is implicitly created for you.
-
-**Example usage**
-
-```c++
-// .h:
-class Foo : public Nan::ObjectWrap {
-  ...
-
-  static void Bar(const Nan::FunctionCallbackInfo<v8::Value>& info);
-  static void Baz(const Nan::FunctionCallbackInfo<v8::Value>& info);
-}
-
-
-// .cc:
-void Foo::Bar(const Nan::FunctionCallbackInfo<v8::Value>& info) {
-  ...
-}
-
-void Foo::Baz(const Nan::FunctionCallbackInfo<v8::Value>& info) {
-  ...
-}
-```
-
-A helper macro `NAN_METHOD(methodname)` exists, compatible with NAN v1 method declarations.
-
-**Example usage with `NAN_METHOD(methodname)`**
-
-```c++
-// .h:
-class Foo : public Nan::ObjectWrap {
-  ...
-
-  static NAN_METHOD(Bar);
-  static NAN_METHOD(Baz);
-}
-
-
-// .cc:
-NAN_METHOD(Foo::Bar) {
-  ...
-}
-
-NAN_METHOD(Foo::Baz) {
-  ...
-}
-```
-
-Use [`Nan::SetPrototypeMethod`](#api_nan_set_prototype_method) to attach a method to a JavaScript function prototype or [`Nan::SetMethod`](#api_nan_set_method) to attach a method directly on a JavaScript object.
-
-<a name="api_nan_getter"></a>
-### Getter declaration
-
-JavaScript-accessible getters should be declared with the following signature to form a `Nan::GetterCallback`:
-
-```c++
-typedef void(*GetterCallback)(v8::Local<v8::String>,
-                              const PropertyCallbackInfo<v8::Value>&);
-```
-
-Example:
-
-```c++
-void GetterName(v8::Local<v8::String> property,
-                const Nan::PropertyCallbackInfo<v8::Value>& info) {
-  ...
-}
-```
-
-You do not need to declare a new `HandleScope` within a getter as one is implicitly created for you.
-
-A helper macro `NAN_GETTER(methodname)` exists, compatible with NAN v1 method declarations.
-
-Also see the V8 Embedders Guide documentation on [Accessors](https://developers.google.com/v8/embed#accesssors).
-
-<a name="api_nan_setter"></a>
-### Setter declaration
-
-JavaScript-accessible setters should be declared with the following signature to form a <b><code>Nan::SetterCallback</code></b>:
-
-```c++
-typedef void(*SetterCallback)(v8::Local<v8::String>,
-                              v8::Local<v8::Value>,
-                              const PropertyCallbackInfo<void>&);
-```
-
-Example:
-
-```c++
-void SetterName(v8::Local<v8::String> property,
-                v8::Local<v8::Value> value,
-                const Nan::PropertyCallbackInfo<v8::Value>& info) {
-  ...
-}
-```
-
-You do not need to declare a new `HandleScope` within a setter as one is implicitly created for you.
-
-A helper macro `NAN_SETTER(methodname)` exists, compatible with NAN v1 method declarations.
-
-Also see the V8 Embedders Guide documentation on [Accessors](https://developers.google.com/v8/embed#accesssors).
-
-<a name="api_nan_property_getter"></a>
-### Property getter declaration
-
-JavaScript-accessible property getters should be declared with the following signature to form a <b><code>Nan::PropertyGetterCallback</code></b>:
-
-```c++
-typedef void(*PropertyGetterCallback)(v8::Local<v8::String>,
-                                      const PropertyCallbackInfo<v8::Value>&);
-```
-
-Example:
-
-```c++
-void PropertyGetterName(v8::Local<v8::String> property,
-                        const Nan::PropertyCallbackInfo<v8::Value>& info) {
-  ...
-}
-```
-
-You do not need to declare a new `HandleScope` within a property getter as one is implicitly created for you.
-
-A helper macro `NAN_PROPERTY_GETTER(methodname)` exists, compatible with NAN v1 method declarations.
-
-Also see the V8 Embedders Guide documentation on named property [Interceptors](https://developers.google.com/v8/embed#interceptors).
-
-<a name="api_nan_property_setter"></a>
-### Property setter declaration
-
-JavaScript-accessible property setters should be declared with the following signature to form a <b><code>Nan::PropertySetterCallback</code></b>:
-
-```c++
-typedef void(*PropertySetterCallback)(v8::Local<v8::String>,
-                                      v8::Local<v8::Value>,
-                                      const PropertyCallbackInfo<v8::Value>&);
-```
-
-Example:
-
-```c++
-void PropertySetterName(v8::Local<v8::String> property,
-                        v8::Local<v8::Value> value,
-                        const Nan::PropertyCallbackInfo<v8::Value>& info);
-```
-
-You do not need to declare a new `HandleScope` within a property setter as one is implicitly created for you.
-
-A helper macro `NAN_PROPERTY_SETTER(methodname)` exists, compatible with NAN v1 method declarations.
-
-Also see the V8 Embedders Guide documentation on named property [Interceptors](https://developers.google.com/v8/embed#interceptors).
-
-<a name="api_nan_property_enumerator"></a>
-### Property enumerator declaration
-
-JavaScript-accessible property enumerators should be declared with the following signature to form a <b><code>Nan::PropertyEnumeratorCallback</code></b>:
-
-```c++
-typedef void(*PropertyEnumeratorCallback)(const PropertyCallbackInfo<v8::Array>&);
-```
-
-Example:
-
-```c++
-void PropertyEnumeratorName(const Nan::PropertyCallbackInfo<v8::Array>& info);
-```
-
-You do not need to declare a new `HandleScope` within a property enumerator as one is implicitly created for you.
-
-A helper macro `NAN_PROPERTY_ENUMERATOR(methodname)` exists, compatible with NAN v1 method declarations.
-
-Also see the V8 Embedders Guide documentation on named property [Interceptors](https://developers.google.com/v8/embed#interceptors).
-
-<a name="api_nan_property_deleter"></a>
-### Property deleter declaration
-
-JavaScript-accessible property deleters should be declared with the following signature to form a <b><code>Nan::PropertyDeleterCallback</code></b>:
-
-```c++
-typedef void(*PropertyDeleterCallback)(v8::Local<v8::String>,
-                                       const PropertyCallbackInfo<v8::Boolean>&);
-```
-
-Example:
-
-```c++
-void PropertyDeleterName(v8::Local<v8::String> property,
-                         const Nan::PropertyCallbackInfo<v8::Boolean>& info);
-```
-
-You do not need to declare a new `HandleScope` within a property deleter as one is implicitly created for you.
-
-A helper macro `NAN_PROPERTY_DELETER(methodname)` exists, compatible with NAN v1 method declarations.
-
-Also see the V8 Embedders Guide documentation on named property [Interceptors](https://developers.google.com/v8/embed#interceptors).
-
-<a name="api_nan_property_query"></a>
-### Property query declaration
-
-JavaScript-accessible property query methods should be declared with the following signature to form a <b><code>Nan::PropertyQueryCallback</code></b>:
-
-```c++
-typedef void(*PropertyQueryCallback)(v8::Local<v8::String>,
-                                     const PropertyCallbackInfo<v8::Integer>&);
-```
-
-Example:
-
-```c++
-void PropertyQueryName(v8::Local<v8::String> property,
-                       const Nan::PropertyCallbackInfo<v8::Integer>& info);
-```
-
-You do not need to declare a new `HandleScope` within a property query method as one is implicitly created for you.
-
-A helper macro `NAN_PROPERTY_QUERY(methodname)` exists, compatible with NAN v1 method declarations.
-
-Also see the V8 Embedders Guide documentation on named property [Interceptors](https://developers.google.com/v8/embed#interceptors).
-
-<a name="api_nan_index_getter"></a>
-### Index getter declaration
-
-JavaScript-accessible index getter methods should be declared with the following signature to form a <b><code>Nan::IndexGetterCallback</code></b>:
-
-```c++
-typedef void(*IndexGetterCallback)(uint32_t,
-                                   const PropertyCallbackInfo<v8::Value>&);
-```
-
-Example:
-
-```c++
-void IndexGetterName(uint32_t index, const PropertyCallbackInfo<v8::Value>& info);
-```
-
-You do not need to declare a new `HandleScope` within a index getter as one is implicitly created for you.
-
-A helper macro `NAN_INDEX_GETTER(methodname)` exists, compatible with NAN v1 method declarations.
-
-Also see the V8 Embedders Guide documentation on indexed property [Interceptors](https://developers.google.com/v8/embed#interceptors).
-
-<a name="api_nan_index_setter"></a>
-### Index setter declaration
-
-JavaScript-accessible index setter methods should be declared with the following signature to form a <b><code>Nan::IndexSetterCallback</code></b>:
-
-```c++
-typedef void(*IndexSetterCallback)(uint32_t,
-                                   v8::Local<v8::Value>,
-                                   const PropertyCallbackInfo<v8::Value>&);
-```
-
-Example:
-
-```c++
-void IndexSetterName(uint32_t index,
-                     v8::Local<v8::Value> value,
-                     const PropertyCallbackInfo<v8::Value>& info);
-```
-
-You do not need to declare a new `HandleScope` within a index setter as one is implicitly created for you.
-
-A helper macro `NAN_INDEX_SETTER(methodname)` exists, compatible with NAN v1 method declarations.
-
-Also see the V8 Embedders Guide documentation on indexed property [Interceptors](https://developers.google.com/v8/embed#interceptors).
-
-<a name="api_nan_index_enumerator"></a>
-### Index enumerator declaration
-
-JavaScript-accessible index enumerator methods should be declared with the following signature to form a <b><code>Nan::IndexEnumeratorCallback</code></b>:
-
-```c++
-typedef void(*IndexEnumeratorCallback)(const PropertyCallbackInfo<v8::Array>&);
-```
-
-Example:
-
-```c++
-void IndexEnumeratorName(const PropertyCallbackInfo<v8::Array>& info);
-```
-
-You do not need to declare a new `HandleScope` within a index enumerator as one is implicitly created for you.
-
-A helper macro `NAN_INDEX_ENUMERATOR(methodname)` exists, compatible with NAN v1 method declarations.
-
-Also see the V8 Embedders Guide documentation on indexed property [Interceptors](https://developers.google.com/v8/embed#interceptors).
-
-<a name="api_nan_index_deleter"></a>
-### Index deleter declaration
-
-JavaScript-accessible index deleter methods should be declared with the following signature to form a <b><code>Nan::IndexDeleterCallback</code></b>:
-
-```c++
-typedef void(*IndexDeleterCallback)(uint32_t,
-                                    const PropertyCallbackInfo<v8::Boolean>&);
-```
-
-Example:
-
-```c++
-void IndexDeleterName(uint32_t index, const PropertyCallbackInfo<v8::Boolean>& info);
-```
-
-You do not need to declare a new `HandleScope` within a index deleter as one is implicitly created for you.
-
-A helper macro `NAN_INDEX_DELETER(methodname)` exists, compatible with NAN v1 method declarations.
-
-Also see the V8 Embedders Guide documentation on indexed property [Interceptors](https://developers.google.com/v8/embed#interceptors).
-
-<a name="api_nan_index_query"></a>
-### Index query declaration
-
-JavaScript-accessible index query methods should be declared with the following signature to form a <b><code>Nan::IndexQueryCallback</code></b>:
-
-```c++
-typedef void(*IndexQueryCallback)(uint32_t,
-                                  const PropertyCallbackInfo<v8::Integer>&);
-```
-
-Example:
-
-```c++
-void IndexQueryName(uint32_t index, const PropertyCallbackInfo<v8::Integer>& info);
-```
-
-You do not need to declare a new `HandleScope` within a index query method as one is implicitly created for you.
-
-A helper macro `NAN_INDEX_QUERY(methodname)` exists, compatible with NAN v1 method declarations.
-
-Also see the V8 Embedders Guide documentation on indexed property [Interceptors](https://developers.google.com/v8/embed#interceptors).
-
-<a name="api_nan_set_method"></a>
-### Nan::SetMethod()
-
-Sets a method with a given name directly on a JavaScript object where the method has the `Nan::FunctionCallback` signature (see <a href="#api_nan_method">Method declaration</a>).
-
-Signature:
-
-```c++
-template<typename T> void Nan::SetMethod(const T &recv,
-                                    const char *name,
-                                    Nan::FunctionCallback callback)
-```
-
-<a name="api_nan_set_prototype_method"></a>
-### Nan::SetPrototypeMethod()
-
-Sets a method with a given name on a `FunctionTemplate`'s prototype where the method has the `Nan::FunctionCallback` signature (see <a href="#api_nan_method">Method declaration</a>).
-
-Signature:
-
-```c++
-void Nan::SetPrototypeMethod(v8::Local<v8::FunctionTemplate> recv,
-                             const char* name,
-                             Nan::FunctionCallback callback)
-```
-
-<a name="api_nan_set_accessor"></a>
-### Nan::SetAccessor()
-
-Sets getters and setters for a property with a given name on an `ObjectTemplate` or a plain `Object`. Accepts getters with the `Nan::GetterCallback` signature (see <a href="#api_nan_getter">Getter declaration</a>) and setters with the `Nan::SetterCallback` signature (see <a href="#api_nan_setter">Setter declaration</a>).
-
-Signature:
-
-```c++
-void SetAccessor(v8::Local<v8::ObjectTemplate> tpl,
-                 v8::Local<v8::String> name,
-                 Nan::GetterCallback getter,
-                 Nan::SetterCallback setter = 0,
-                 v8::Local<v8::Value> data = v8::Local<v8::Value>(),
-                 v8::AccessControl settings = v8::DEFAULT,
-                 v8::PropertyAttribute attribute = v8::None,
-                 imp::Sig signature = imp::Sig())
-bool SetAccessor(v8::Local<v8::Object> obj,
-                 v8::Local<v8::String> name,
-                 Nan::GetterCallback getter,
-                 Nan::SetterCallback setter = 0,
-                 v8::Local<v8::Value> data = v8::Local<v8::Value>(),
-                 v8::AccessControl settings = v8::DEFAULT,
-                 v8::PropertyAttribute attribute = v8::None)
-```
-
-See the V8 [`ObjectTemplate#SetAccessor()`](https://v8docs.nodesource.com/io.js-3.0/db/d5f/classv8_1_1_object_template.html#aa90691622f01269c6a11391d372ca0c5) and [`Object#SetAccessor()`](https://v8docs.nodesource.com/io.js-3.0/db/d85/classv8_1_1_object.html#a3f9dee085f5ec346465f1dc924325043) for further information about how to use `Nan::SetAccessor()`.
-
-<a name="api_nan_set_named_property_handler"></a>
-### Nan::SetNamedPropertyHandler()
-
-Sets named property getters, setters, query, deleter and enumerator methods on an `ObjectTemplate`. Accepts:
-
-* Property getters with the `Nan::PropertyGetterCallback` signature (see <a href="#api_nan_property_getter">Property getter declaration</a>)
-* Property setters with the `Nan::PropertySetterCallback` signature (see <a href="#api_nan_property_setter">Property setter declaration</a>)
-* Property query methods with the `Nan::PropertyQueryCallback` signature (see <a href="#api_nan_property_query">Property query declaration</a>)
-* Property deleters with the `Nan::PropertyDeleterCallback` signature (see <a href="#api_nan_property_deleter">Property deleter declaration</a>)
-* Property enumerators with the `Nan::PropertyEnumeratorCallback` signature (see <a href="#api_nan_property_enumerator">Property enumerator declaration</a>)
-
-Signature:
-
-```c++
-void SetNamedPropertyHandler(v8::Local<v8::ObjectTemplate> tpl,
-                             Nan::PropertyGetterCallback getter,
-                             Nan::PropertySetterCallback setter = 0,
-                             Nan::PropertyQueryCallback query = 0,
-                             Nan::PropertyDeleterCallback deleter = 0,
-                             Nan::PropertyEnumeratorCallback enumerator = 0,
-                             v8::Local<v8::Value> data = v8::Local<v8::Value>())
-```
-
-See the V8 [`ObjectTemplate#SetNamedPropertyHandler()`](https://v8docs.nodesource.com/io.js-3.0/db/d5f/classv8_1_1_object_template.html#a34d1cc45b642cd131706663801aadd76) for further information about how to use `Nan::SetNamedPropertyHandler()`.
-
-<a name="api_nan_set_indexed_property_handler"></a>
-### Nan::SetIndexedPropertyHandler()
-
-Sets indexed property getters, setters, query, deleter and enumerator methods on an `ObjectTemplate`. Accepts:
-
-* Indexed property getters with the `Nan::IndexGetterCallback` signature (see <a href="#api_nan_index_getter">Index getter declaration</a>)
-* Indexed property setters with the `Nan::IndexSetterCallback` signature (see <a href="#api_nan_index_setter">Index setter declaration</a>)
-* Indexed property query methods with the `Nan::IndexQueryCallback` signature (see <a href="#api_nan_index_query">Index query declaration</a>)
-* Indexed property deleters with the `Nan::IndexDeleterCallback` signature (see <a href="#api_nan_index_deleter">Index deleter declaration</a>)
-* Indexed property enumerators with the `Nan::IndexEnumeratorCallback` signature (see <a href="#api_nan_index_enumerator">Index enumerator declaration</a>)
-
-Signature:
-
-```c++
-void SetIndexedPropertyHandler(v8::Local<v8::ObjectTemplate> tpl,
-                             Nan::IndexGetterCallback getter,
-                             Nan::IndexSetterCallback setter = 0,
-                             Nan::IndexQueryCallback query = 0,
-                             Nan::IndexDeleterCallback deleter = 0,
-                             Nan::IndexEnumeratorCallback enumerator = 0,
-                             v8::Local<v8::Value> data = v8::Local<v8::Value>())
-```
-
-See the V8 [`ObjectTemplate#SetIndexedPropertyHandler()`](https://v8docs.nodesource.com/io.js-3.0/db/d5f/classv8_1_1_object_template.html#ac0234cbede45d51778bb5f6a32a9e125) for further information about how to use `Nan::SetIndexedPropertyHandler()`.
-
-<a name="api_nan_set_template"></a>
-### Nan::SetTemplate()
-
-Adds properties on an `Object`'s or `Function`'s template.
-
-Signature:
-
-```c++
-void Nan::SetTemplate(v8::Local<v8::Template> templ,
-                      const char *name,
-                      v8::Local<v8::Data> value)
-void Nan::SetTemplate(v8::Local<v8::Template> templ,
-                      v8::Local<v8::String> name,
-                      v8::Local<v8::Data> value,
-                      v8::PropertyAttribute attributes)
-```
-
-Calls the `Template`'s [`Set()`](https://v8docs.nodesource.com/io.js-3.0/db/df7/classv8_1_1_template.html#a2db6a56597bf23c59659c0659e564ddf).
-
-<a name="api_nan_set_prototype_template"></a>
-### Nan::SetPrototypeTemplate()
-
-Adds properties on an `Object`'s or `Function`'s prototype template.
-
-Signature:
-
-```c++
-void Nan::SetPrototypeTemplate(v8::Local<v8::FunctionTemplate> templ,
-                               const char *name,
-                               v8::Local<v8::Data> value)
-void Nan::SetPrototypeTemplate(v8::Local<v8::FunctionTemplate> templ,
-                               v8::Local<v8::String> name,
-                               v8::Local<v8::Data> value,
-                               v8::PropertyAttribute attributes)
-```
-
-Calls the `FunctionTemplate`'s _PrototypeTemplate's_ [`Set()`](https://v8docs.nodesource.com/io.js-3.0/db/df7/classv8_1_1_template.html#a2db6a56597bf23c59659c0659e564ddf).
-
-<a name="api_nan_set_instance_template"></a>
-### Nan::SetInstanceTemplate()
-
-Use to add instance properties on `FunctionTemplate`'s.
-
-Signature:
-
-```c++
-void Nan::SetInstanceTemplate(v8::Local<v8::FunctionTemplate> templ,
-                              const char *name,
-                              v8::Local<v8::Data> value)
-void Nan::SetInstanceTemplate(v8::Local<v8::FunctionTemplate> templ,
-                              v8::Local<v8::String> name,
-                              v8::Local<v8::Data> value,
-                              v8::PropertyAttribute attributes)
-```
-
-Calls the `FunctionTemplate`'s _InstanceTemplate's_ [`Set()`](https://v8docs.nodesource.com/io.js-3.0/db/df7/classv8_1_1_template.html#a2db6a56597bf23c59659c0659e564ddf).
-

tools/LiveTexturing/LiveTexturing/node_modules/zmq/node_modules/nan/doc/new.md

@@ -1,141 +0,0 @@
-## New
-
-NAN provides a `Nan::New()` helper for the creation of new JavaScript objects in a way that's compatible across the supported versions of V8.
-
- - <a href="#api_nan_new"><b><code>Nan::New()</code></b></a>
- - <a href="#api_nan_undefined"><b><code>Nan::Undefined()</code></b></a>
- - <a href="#api_nan_null"><b><code>Nan::Null()</code></b></a>
- - <a href="#api_nan_true"><b><code>Nan::True()</code></b></a>
- - <a href="#api_nan_false"><b><code>Nan::False()</code></b></a>
- - <a href="#api_nan_empty_string"><b><code>Nan::EmptyString()</code></b></a>
-
-
-<a name="api_nan_new"></a>
-### Nan::New()
-
-`Nan::New()` should be used to instantiate new JavaScript objects.
-
-Refer to the specific V8 type in the [V8 documentation](https://v8docs.nodesource.com/io.js-3.0/d1/d83/classv8_1_1_data.html) for information on the types of arguments required for instantiation.
-
-Signatures:
-
-Return types are mostly omitted from the signatures for simplicity. In most cases the type will be contained within a `v8::Local<T>`. The following types will be contained within a `Nan::MaybeLocal<T>`: `v8::String`, `v8::Date`, `v8::RegExp`, `v8::Script`, `v8::UnboundScript`.
-
-Empty objects:
-
-```c++
-Nan::New<T>();
-```
-
-Generic single and multiple-argument:
-
-```c++
-Nan::New<T>(A0 arg0);
-Nan::New<T>(A0 arg0, A1 arg1);
-Nan::New<T>(A0 arg0, A1 arg1, A2 arg2);
-Nan::New<T>(A0 arg0, A1 arg1, A2 arg2, A3 arg3);
-```
-
-For creating `v8::FunctionTemplate` and `v8::Function` objects:
-
-_The definition of `Nan::FunctionCallback` can be found in the [Method declaration](./methods.md#api_nan_method) documentation._
-
-```c++
-Nan::New<T>(Nan::FunctionCallback callback,
-            v8::Local<v8::Value> data = v8::Local<v8::Value>());
-Nan::New<T>(Nan::FunctionCallback callback,
-            v8::Local<v8::Value> data = v8::Local<v8::Value>(),
-            A2 a2 = A2());
-```
-
-Native types:
-
-```c++
-v8::Local<v8::Boolean> Nan::New<T>(bool value);
-v8::Local<v8::Int32> Nan::New<T>(int32_t value);
-v8::Local<v8::Uint32> Nan::New<T>(uint32_t value);
-v8::Local<v8::Number> Nan::New<T>(double value);
-v8::Local<v8::String> Nan::New<T>(std::string const& value);
-v8::Local<v8::String> Nan::New<T>(const char * value, int length);
-v8::Local<v8::String> Nan::New<T>(const char * value);
-v8::Local<v8::String> Nan::New<T>(const uint16_t * value);
-```
-
-Specialized types:
-
-```c++
-v8::Local<v8::String> Nan::New<T>(v8::String::ExternalStringResource * value);
-v8::Local<v8::String> Nan::New<T>(Nan::ExternalOneByteStringResource * value);
-v8::Local<v8::RegExp> Nan::New<T>(v8::Local<v8::String> pattern, v8::RegExp::Flags flags);
-```
-
-Note that `Nan::ExternalOneByteStringResource` maps to [`v8::String::ExternalOneByteStringResource`](https://v8docs.nodesource.com/io.js-3.0/d9/db3/classv8_1_1_string_1_1_external_one_byte_string_resource.html), and `v8::String::ExternalAsciiStringResource` in older versions of V8.
-
-
-<a name="api_nan_undefined"></a>
-### Nan::Undefined()
-
-A helper method to reference the `v8::Undefined` object in a way that is compatible across all supported versions of V8.
-
-Signature:
-
-```c++
-v8::Local<v8::Primitive> Nan::Undefined()
-```
-
-<a name="api_nan_null"></a>
-### Nan::Null()
-
-A helper method to reference the `v8::Null` object in a way that is compatible across all supported versions of V8.
-
-Signature:
-
-```c++
-v8::Local<v8::Primitive> Nan::Null()
-```
-
-<a name="api_nan_true"></a>
-### Nan::True()
-
-A helper method to reference the `v8::Boolean` object representing the `true` value in a way that is compatible across all supported versions of V8.
-
-Signature:
-
-```c++
-v8::Local<v8::Boolean> Nan::True()
-```
-
-<a name="api_nan_false"></a>
-### Nan::False()
-
-A helper method to reference the `v8::Boolean` object representing the `false` value in a way that is compatible across all supported versions of V8.
-
-Signature:
-
-```c++
-v8::Local<v8::Boolean> Nan::False()
-```
-
-<a name="api_nan_empty_string"></a>
-### Nan::EmptyString()
-
-Call [`v8::String::Empty`](https://v8docs.nodesource.com/io.js-3.0/d2/db3/classv8_1_1_string.html#a7c1bc8886115d7ee46f1d571dd6ebc6d) to reference the empty string in a way that is compatible across all supported versions of V8.
-
-Signature:
-
-```c++
-v8::Local<v8::String> Nan::EmptyString() 
-```
-
-
-<a name="api_nan_new_one_byte_string"></a>
-### Nan::NewOneByteString()
-
-An implementation of [`v8::String::NewFromOneByte()`](https://v8docs.nodesource.com/io.js-3.0/d2/db3/classv8_1_1_string.html#a5264d50b96d2c896ce525a734dc10f09) provided for consistent availability and API across supported versions of V8. Allocates a new string from Latin-1 data.
-
-Signature:
-
-```c++
-Nan::MaybeLocal<v8::String> Nan::NewOneByteString(const uint8_t * value,
-                                                  int length = -1) 
-```

tools/LiveTexturing/LiveTexturing/node_modules/zmq/node_modules/nan/doc/node_misc.md

@@ -1,114 +0,0 @@
-## Miscellaneous Node Helpers
-
- - <a href="#api_nan_make_callback"><b><code>Nan::MakeCallback()</code></b></a>
- - <a href="#api_nan_object_wrap"><b><code>Nan::ObjectWrap</code></b></a>
- - <a href="#api_nan_module_init"><b><code>NAN_MODULE_INIT()</code></b></a>
- - <a href="#api_nan_export"><b><code>Nan::Export()</code></b></a>
-
-
-<a name="api_nan_make_callback"></a>
-### Nan::MakeCallback()
-
-Wrappers around `node::MakeCallback()` providing a consistent API across all supported versions of Node.
-
-Use `MakeCallback()` rather than using `v8::Function#Call()` directly in order to properly process internal Node functionality including domains, async hooks, the microtask queue, and other debugging functionality.
-
-Signatures:
-
-```c++
-v8::Local<v8::Value> Nan::MakeCallback(v8::Local<v8::Object> target,
-                                       v8::Local<v8::Function> func,
-                                       int argc,
-                                       v8::Local<v8::Value>* argv);
-v8::Local<v8::Value> Nan::MakeCallback(v8::Local<v8::Object> target,
-                                       v8::Local<v8::String> symbol,
-                                       int argc,
-                                       v8::Local<v8::Value>* argv);
-v8::Local<v8::Value> Nan::MakeCallback(v8::Local<v8::Object> target,
-                                       const char* method,
-                                       int argc,
-                                       v8::Local<v8::Value>* argv);
-```
-
-
-<a name="api_nan_object_wrap"></a>
-### Nan::ObjectWrap()
-
-A reimplementation of `node::ObjectWrap` that adds some API not present in older versions of Node. Should be preferred over `node::ObjectWrap` in all cases for consistency.
-
-See the Node documentation on [Wrapping C++ Objects](https://nodejs.org/api/addons.html#addons_wrapping_c_objects) for more details.
-
-Definition:
-
-```c++
-class ObjectWrap {
- public:
-  ObjectWrap();
-
-  virtual ~ObjectWrap();
-
-  template <class T>
-  static inline T* Unwrap(v8::Local<v8::Object> handle);
-
-  inline v8::Local<v8::Object> handle();
-
-  inline Nan::Persistent<v8::Object>& persistent();
-
- protected:
-  inline void Wrap(v8::Local<v8::Object> handle);
-
-  inline void MakeWeak();
-
-  /* Ref() marks the object as being attached to an event loop.
-   * Refed objects will not be garbage collected, even if
-   * all references are lost.
-   */
-  virtual void Ref();
-
-  /* Unref() marks an object as detached from the event loop.  This is its
-   * default state.  When an object with a "weak" reference changes from
-   * attached to detached state it will be freed. Be careful not to access
-   * the object after making this call as it might be gone!
-   * (A "weak reference" means an object that only has a
-   * persistant handle.)
-   *
-   * DO NOT CALL THIS FROM DESTRUCTOR
-   */
-  virtual void Unref();
-
-  int refs_;  // ro
-};
-```
-
-
-<a name="api_nan_module_init"></a>
-### NAN_MODULE_INIT()
-
-Used to define the entry point function to a Node add-on. Creates a function with a given `name` that receives a `target` object representing the equivalent of the JavaScript `exports` object.
-
-See example below.
-
-<a name="api_nan_export"></a>
-### Nan::Export()
-
-A simple helper to register a `v8::FunctionTemplate` from a JavaScript-accessible method (see [Methods](./methods.md)) as a property on an object. Can be used in a way similar to assigning properties to `module.exports` in JavaScript.
-
-Signature:
-
-```c++
-void Export(v8::Local<v8::Object> target, const char *name, Nan::FunctionCallback f)
-```
-
-Also available as the shortcut `NAN_EXPORT` macro.
-
-Example:
-
-```c++
-NAN_METHOD(Foo) {
-  ...
-}
-
-NAN_MODULE_INIT(Init) {
-  NAN_EXPORT(target, Foo);
-}
-```

tools/LiveTexturing/LiveTexturing/node_modules/zmq/node_modules/nan/doc/persistent.md

@@ -1,292 +0,0 @@
-## Persistent references
-
-An object reference that is independent of any `HandleScope` is a _persistent_ reference. Where a `Local` handle only lives as long as the `HandleScope` in which it was allocated, a `Persistent` handle remains valid until it is explicitly disposed.
-
-Due to the evolution of the V8 API, it is necessary for NAN to provide a wrapper implementation of the `Persistent` classes to supply compatibility across the V8 versions supported.
-
- - <a href="#api_nan_persistent_base"><b><code>Nan::PersistentBase & v8::PersistentBase</code></b></a>
- - <a href="#api_nan_non_copyable_persistent_traits"><b><code>Nan::NonCopyablePersistentTraits & v8::NonCopyablePersistentTraits</code></b></a>
- - <a href="#api_nan_copyable_persistent_traits"><b><code>Nan::CopyablePersistentTraits & v8::CopyablePersistentTraits</code></b></a>
- - <a href="#api_nan_persistent"><b><code>Nan::Persistent</code></b></a>
- - <a href="#api_nan_global"><b><code>Nan::Global</code></b></a>
- - <a href="#api_nan_weak_callback_info"><b><code>Nan::WeakCallbackInfo</code></b></a>
- - <a href="#api_nan_weak_callback_type"><b><code>Nan::WeakCallbackType</code></b></a>
-
-Also see the V8 Embedders Guide section on [Handles and Garbage Collection](https://developers.google.com/v8/embed#handles).
-
-<a name="api_nan_persistent_base"></a>
-### Nan::PersistentBase & v8::PersistentBase
-
-A persistent handle contains a reference to a storage cell in V8 which holds an object value and which is updated by the garbage collector whenever the object is moved. A new storage cell can be created using the constructor or `Nan::PersistentBase::Reset()`. Existing handles can be disposed using an argument-less `Nan::PersistentBase::Reset()`.
-
-Definition:
-
-_(note: this is implemented as `Nan::PersistentBase` for older versions of V8 and the native `v8::PersistentBase` is used for newer versions of V8)_
-
-```c++
-template<typename T> class PersistentBase {
- public:
-  /**
-   * If non-empty, destroy the underlying storage cell
-   */
-  void Reset();
-
-  /**
-   * If non-empty, destroy the underlying storage cell and create a new one with
-   * the contents of another if it is also non-empty
-   */
-  template<typename S> void Reset(const v8::Local<S> &other);
-
-  /**
-   * If non-empty, destroy the underlying storage cell and create a new one with
-   * the contents of another if it is also non-empty
-   */
-  template<typename S> void Reset(const PersistentBase<S> &other);
-
-  /**
-   * If non-empty, destroy the underlying storage cell
-   * IsEmpty() will return true after this call.
-   */
-  bool IsEmpty();
-
-  void Empty();
-
-  template<typename S> bool operator==(const PersistentBase<S> &that);
-
-  template<typename S> bool operator==(const v8::Local<S> &that);
-
-  template<typename S> bool operator!=(const PersistentBase<S> &that);
-
-  template<typename S> bool operator!=(const v8::Local<S> &that);
-
-   /**
-   *  Install a finalization callback on this object.
-   *  NOTE: There is no guarantee as to *when* or even *if* the callback is
-   *  invoked. The invocation is performed solely on a best effort basis.
-   *  As always, GC-based finalization should *not* be relied upon for any
-   *  critical form of resource management! At the moment you can either
-   *  specify a parameter for the callback or the location of two internal
-   *  fields in the dying object.
-   */
-  template<typename P>
-  void SetWeak(P *parameter,
-               typename WeakCallbackInfo<P>::Callback callback,
-               WeakCallbackType type);
-
-  void ClearWeak();
-
-  /**
-   * Marks the reference to this object independent. Garbage collector is free
-   * to ignore any object groups containing this object. Weak callback for an
-   * independent handle should not assume that it will be preceded by a global
-   * GC prologue callback or followed by a global GC epilogue callback.
-   */
-  void MarkIndependent() const;
-
-  bool IsIndependent() const;
-
-  /** Checks if the handle holds the only reference to an object. */
-  bool IsNearDeath() const;
-
-  /** Returns true if the handle's reference is weak.  */
-  bool IsWeak() const
-};
-```
-
-See the V8 documentation for [`PersistentBase`](https://v8docs.nodesource.com/io.js-3.0/d4/dca/classv8_1_1_persistent_base.html) for further information.
-
-<a name="api_nan_non_copyable_persistent_traits"></a>
-### Nan::NonCopyablePersistentTraits & v8::NonCopyablePersistentTraits
-
-Default traits for `Nan::Persistent`. This class does not allow use of the a copy constructor or assignment operator. At present `kResetInDestructor` is not set, but that will change in a future version.
-
-Definition:
-
-_(note: this is implemented as `Nan::NonCopyablePersistentTraits` for older versions of V8 and the native `v8::NonCopyablePersistentTraits` is used for newer versions of V8)_
-
-```c++
-template<typename T> class NonCopyablePersistentTraits {
- public:
-  typedef Persistent<T, NonCopyablePersistentTraits<T> > NonCopyablePersistent;
-  
-  static const bool kResetInDestructor = false;
-  
-  template<typename S, typename M> 
-  static void Copy(const Persistent<S, M> &source,
-                   NonCopyablePersistent *dest);
-
-  template<typename O> static void Uncompilable();
-};
-```
-
-See the V8 documentation for [`NonCopyablePersistentTraits`](https://v8docs.nodesource.com/io.js-3.0/de/d73/classv8_1_1_non_copyable_persistent_traits.html) for further information.
-
-<a name="api_nan_copyable_persistent_traits"></a>
-### Nan::CopyablePersistentTraits & v8::CopyablePersistentTraits
-
-A helper class of traits to allow copying and assignment of `Persistent`. This will clone the contents of storage cell, but not any of the flags, etc..
-
-Definition:
-
-_(note: this is implemented as `Nan::CopyablePersistentTraits` for older versions of V8 and the native `v8::NonCopyablePersistentTraits` is used for newer versions of V8)_
-
-```c++
-template<typename T>
-class CopyablePersistentTraits {
- public:
-  typedef Persistent<T, CopyablePersistentTraits<T> > CopyablePersistent;
-
-  static const bool kResetInDestructor = true;
-
-  template<typename S, typename M>
-  static void Copy(const Persistent<S, M> &source,
-                   CopyablePersistent *dest);
-};
-```
-
-See the V8 documentation for [`CopyablePersistentTraits`](https://v8docs.nodesource.com/io.js-3.0/da/d5c/structv8_1_1_copyable_persistent_traits.html) for further information.
-
-<a name="api_nan_persistent"></a>
-### Nan::Persistent
-
-A type of `PersistentBase` which allows copy and assignment. Copy, assignment and destructor behavior is controlled by the traits class `M`.
-
-Definition:
-
-```c++
-template<typename T, typename M = NonCopyablePersistentTraits<T> >
-class Persistent;
-
-template<typename T, typename M> class Persistent : public PersistentBase<T> {
- public:
- /**
-  * A Persistent with no storage cell.
-  */
-  Persistent();
-
-  /**
-   * Construct a Persistent from a v8::Local. When the v8::Local is non-empty, a
-   * new storage cell is created pointing to the same object, and no flags are
-   * set.
-   */
-  template<typename S> Persistent(v8::Local<S> that);
-
-  /**
-   * Construct a Persistent from a Persistent. When the Persistent is non-empty,
-   * a new storage cell is created pointing to the same object, and no flags are
-   * set.
-   */
-  Persistent(const Persistent &that);
-
-  /**
-   * The copy constructors and assignment operator create a Persistent exactly
-   * as the Persistent constructor, but the Copy function from the traits class
-   * is called, allowing the setting of flags based on the copied Persistent.
-   */
-  Persistent &operator=(const Persistent &that);
-
-  template <typename S, typename M2>
-  Persistent &operator=(const Persistent<S, M2> &that);
-
-  /**
-   * The destructor will dispose the Persistent based on the kResetInDestructor
-   * flags in the traits class.  Since not calling dispose can result in a
-   * memory leak, it is recommended to always set this flag.
-   */
-  ~Persistent();
-};
-```
-
-See the V8 documentation for [`Persistent`](https://v8docs.nodesource.com/io.js-3.0/d2/d78/classv8_1_1_persistent.html) for further information.
-
-<a name="api_nan_global"></a>
-### Nan::Global
-
-A type of `PersistentBase` which has move semantics.
-
-```c++
-template<typename T> class Global : public PersistentBase<T> {
- public:
-  /**
-   * A Global with no storage cell.
-   */
-  Global();
-
-  /**
-   * Construct a Global from a v8::Local. When the v8::Local is non-empty, a new
-   * storage cell is created pointing to the same object, and no flags are set.
-   */
-  template<typename S> Global(v8::Local<S> that);
-  /**
-   * Construct a Global from a PersistentBase. When the Persistent is non-empty,
-   * a new storage cell is created pointing to the same object, and no flags are
-   * set.
-   */
-  template<typename S> Global(const PersistentBase<S> &that);
-
-  /**
-   * Pass allows returning globals from functions, etc.
-   */
-  Global Pass();
-};
-```
-
-See the V8 documentation for [`Global`](https://v8docs.nodesource.com/io.js-3.0/d5/d40/classv8_1_1_global.html) for further information.
-
-<a name="api_nan_weak_callback_type"></a>
-### Nan::WeakCallbackType
-
-<a name="api_nan_weak_callback_info"></a>
-### Nan::WeakCallbackInfo
-
-`Nan::WeakCallbackInfo` is used as an argument when setting a persistent reference as weak. You may need to free any external resources attached to the object. It is a mirror of `v8:WeakCallbackInfo` as found in newer versions of V8.
-
-Definition:
-
-```c++
-template<typename T> class WeakCallbackInfo {
- public:
-  typedef void (*Callback)(const WeakCallbackInfo<T>& data);
-
-  v8::Isolate *GetIsolate() const;
-
-  /**
-   * Get the parameter that was associated with the weak handle.
-   */
-  T *GetParameter() const;
-
-  /**
-   * Get pointer from internal field, index can be 0 or 1.
-   */
-  void *GetInternalField(int index) const;
-};
-```
-
-Example usage:
-
-```c++
-void weakCallback(const WeakCallbackInfo<int> &data) {
-  int *parameter = data.GetParameter();
-  delete parameter;
-}
-
-Persistent<v8::Object> obj;
-int *data = new int(0);
-obj.SetWeak(data, callback, WeakCallbackType::kParameter);
-```
-
-See the V8 documentation for [`WeakCallbackInfo`](https://v8docs.nodesource.com/io.js-3.0/d8/d06/classv8_1_1_weak_callback_info.html) for further information.
-
-<a name="api_nan_weak_callback_type"></a>
-### Nan::WeakCallbackType
-
-Represents the type of a weak callback.
-A weak callback of type `kParameter` makes the supplied parameter to `Nan::PersistentBase::SetWeak` available through `WeakCallbackInfo::GetParameter`.
-A weak callback of type `kInternalFields` uses up to two internal fields at indices 0 and 1 on the `Nan::PersistentBase<v8::Object>` being made weak.
-Note that only `v8::Object`s and derivatives can have internal fields.
-
-Definition:
-
-```c++
-enum class WeakCallbackType { kParameter, kInternalFields };
-```

tools/LiveTexturing/LiveTexturing/node_modules/zmq/node_modules/nan/doc/scopes.md

@@ -1,73 +0,0 @@
-## Scopes
-
-A _local handle_ is a pointer to an object. All V8 objects are accessed using handles, they are necessary because of the way the V8 garbage collector works.
-
-A handle scope can be thought of as a container for any number of handles. When you've finished with your handles, instead of deleting each one individually you can simply delete their scope.
-
-The creation of `HandleScope` objects is different across the supported versions of V8. Therefore, NAN provides its own implementations that can be used safely across these.
-
- - <a href="#api_nan_handle_scope"><b><code>Nan::HandleScope</code></b></a>
- - <a href="#api_nan_escapable_handle_scope"><b><code>Nan::EscapableHandleScope</code></b></a>
-
-Also see the V8 Embedders Guide section on [Handles and Garbage Collection](https://developers.google.com/v8/embed#handles).
-
-<a name="api_nan_handle_scope"></a>
-### Nan::HandleScope
-
-A simple wrapper around [`v8::HandleScope`](https://v8docs.nodesource.com/io.js-3.0/d3/d95/classv8_1_1_handle_scope.html).
-
-Definition:
-
-```c++
-class Nan::HandleScope {
- public:
-  Nan::HandleScope();
-  static int NumberOfHandles();
-};
-```
-
-Allocate a new `Nan::HandleScope` whenever you are creating new V8 JavaScript objects. Note that an implicit `HandleScope` is created for you on JavaScript-accessible methods so you do not need to insert one yourself.
-
-Example:
-
-```c++
-// new object is created, it needs a new scope:
-void Pointless() {
-  Nan::HandleScope scope;
-  v8::Local<v8::Object> obj = Nan::New<v8::Object>();
-}
-
-// JavaScript-accessible method already has a HandleScope
-NAN_METHOD(Pointless2) {
-  v8::Local<v8::Object> obj = Nan::New<v8::Object>();
-}
-```
-
-<a name="api_nan_escapable_handle_scope"></a>
-### Nan::EscapableHandleScope
-
-Similar to [`Nan::HandleScope`](#api_nan_handle_scope) but should be used in cases where a function needs to return a V8 JavaScript type that has been created within it.
-
-Definition:
-
-```c++
-class Nan::EscapableHandleScope {
- public:
-  Nan::EscapableHandleScope();
-  static int NumberOfHandles();
-  template<typename T> v8::Local<T> Escape(v8::Local<T> value);
-}
-```
-
-Use `Escape(value)` to return the object.
-
-Example:
-
-```c++
-v8::Local<v8::Object> EmptyObj() {
-  Nan::EscapableHandleScope scope;
-  v8::Local<v8::Object> obj = Nan::New<v8::Object>();
-  return scope.Escape(obj);
-}
-```
-

tools/LiveTexturing/LiveTexturing/node_modules/zmq/node_modules/nan/doc/script.md

@@ -1,38 +0,0 @@
-## Script
-
-NAN provides a `v8::Script` helpers as the API has changed over the supported versions of V8.
-
- - <a href="#api_nan_compile_script"><b><code>Nan::CompileScript()</code></b></a>
- - <a href="#api_nan_run_script"><b><code>Nan::RunScript()</code></b></a>
-
-
-<a name="api_nan_compile_script"></a>
-### Nan::CompileScript()
-
-A wrapper around [`v8::Script::Compile()`](https://v8docs.nodesource.com/io.js-3.0/da/da5/classv8_1_1_script_compiler.html#a93f5072a0db55d881b969e9fc98e564b).
-
-Note that `Nan::BoundScript` is an alias for `v8::Script`.
-
-Signature:
-
-```c++
-Nan::MaybeLocal<Nan::BoundScript> Nan::CompileScript(
-    v8::Local<v8::String> s,
-    const v8::ScriptOrigin& origin);
-Nan::MaybeLocal<Nan::BoundScript> Nan::CompileScript(v8::Local<v8::String> s);
-```
-
-
-<a name="api_nan_run_script"></a>
-### Nan::RunScript()
-
-Calls `script->Run()` or `script->BindToCurrentContext()->Run(Nan::GetCurrentContext())`.
-
-Note that `Nan::BoundScript` is an alias for `v8::Script` and `Nan::UnboundScript` is an alias for `v8::UnboundScript` where available and `v8::Script` on older versions of V8.
-
-Signature:
-
-```c++
-Nan::MaybeLocal<v8::Value> Nan::RunScript(v8::Local<Nan::UnboundScript> script)
-Nan::MaybeLocal<v8::Value> Nan::RunScript(v8::Local<Nan::BoundScript> script) 
-```

tools/LiveTexturing/LiveTexturing/node_modules/zmq/node_modules/nan/doc/string_bytes.md

@@ -1,62 +0,0 @@
-## Strings & Bytes
-
-Miscellaneous string & byte encoding and decoding functionality provided for compatibility across supported versions of V8 and Node. Implemented by NAN to ensure that all encoding types are supported, even for older versions of Node where they are missing.
-
- - <a href="#api_nan_encoding"><b><code>Nan::Encoding</code></b></a>
- - <a href="#api_nan_encode"><b><code>Nan::Encode()</code></b></a>
- - <a href="#api_nan_decode_bytes"><b><code>Nan::DecodeBytes()</code></b></a>
- - <a href="#api_nan_decode_write"><b><code>Nan::DecodeWrite()</code></b></a>
-
-
-<a name="api_nan_encoding"></a>
-### Nan::Encoding
-
-An enum representing the supported encoding types. A copy of `node::encoding` that is consistent across versions of Node.
-
-Definition:
-
-```c++
-enum Nan::Encoding { ASCII, UTF8, BASE64, UCS2, BINARY, HEX, BUFFER }
-```
-
-
-<a name="api_nan_encode"></a>
-### Nan::Encode()
-
-A wrapper around `node::Encode()` that provides a consistent implementation across supported versions of Node.
-
-Signature:
-
-```c++
-v8::Local<v8::Value> Nan::Encode(const void *buf,
-                                 size_t len,
-                                 enum Nan::Encoding encoding = BINARY);
-```
-
-
-<a name="api_nan_decode_bytes"></a>
-### Nan::DecodeBytes()
-
-A wrapper around `node::DecodeBytes()` that provides a consistent implementation across supported versions of Node.
-
-Signature:
-
-```c++
-ssize_t Nan::DecodeBytes(v8::Local<v8::Value> val,
-                         enum Nan::Encoding encoding = BINARY);
-```
-
-
-<a name="api_nan_decode_write"></a>
-### Nan::DecodeWrite()
-
-A wrapper around `node::DecodeWrite()` that provides a consistent implementation across supported versions of Node.
-
-Signature:
-
-```c++
-ssize_t Nan::DecodeWrite(char *buf,
-                         size_t len,
-                         v8::Local<v8::Value> val,
-                         enum Nan::Encoding encoding = BINARY);
-```

tools/LiveTexturing/LiveTexturing/node_modules/zmq/node_modules/nan/doc/v8_internals.md

@@ -1,199 +0,0 @@
-## V8 internals
-
-The hooks to access V8 internals—including GC and statistics—are different across the supported versions of V8, therefore NAN provides its own hooks that call the appropriate V8 methods.
-
- - <a href="#api_nan_gc_callback"><b><code>NAN_GC_CALLBACK()</code></b></a>
- - <a href="#api_nan_add_gc_epilogue_callback"><b><code>Nan::AddGCEpilogueCallback()</code></b></a>
- - <a href="#api_nan_remove_gc_epilogue_callback"><b><code>Nan::RemoveGCEpilogueCallback()</code></b></a>
- - <a href="#api_nan_add_gc_prologue_callback"><b><code>Nan::AddGCPrologueCallback()</code></b></a>
- - <a href="#api_nan_remove_gc_prologue_callback"><b><code>Nan::RemoveGCPrologueCallback()</code></b></a>
- - <a href="#api_nan_get_heap_statistics"><b><code>Nan::GetHeapStatistics()</code></b></a>
- - <a href="#api_nan_set_counter_function"><b><code>Nan::SetCounterFunction()</code></b></a>
- - <a href="#api_nan_set_create_histogram_function"><b><code>Nan::SetCreateHistogramFunction()</code></b></a>
- - <a href="#api_nan_set_add_histogram_sample_function"><b><code>Nan::SetAddHistogramSampleFunction()</code></b></a>
- - <a href="#api_nan_idle_notification"><b><code>Nan::IdleNotification()</code></b></a>
- - <a href="#api_nan_low_memory_notification"><b><code>Nan::LowMemoryNotification()</code></b></a>
- - <a href="#api_nan_context_disposed_notification"><b><code>Nan::ContextDisposedNotification()</code></b></a>
- - <a href="#api_nan_get_internal_field_pointer"><b><code>Nan::GetInternalFieldPointer()</code></b></a>
- - <a href="#api_nan_set_internal_field_pointer"><b><code>Nan::SetInternalFieldPointer()</code></b></a>
- - <a href="#api_nan_adjust_external_memory"><b><code>Nan::AdjustExternalMemory()</code></b></a>
-
-
-<a name="api_nan_gc_callback"></a>
-### NAN_GC_CALLBACK(callbackname)
-
-Use `NAN_GC_CALLBACK` to declare your callbacks for `Nan::AddGCPrologueCallback()` and `Nan::AddGCEpilogueCallback()`. Your new method receives the arguments `v8::GCType type` and `v8::GCCallbackFlags flags`.
-
-```c++
-static Nan::Persistent<Function> callback;
-
-NAN_GC_CALLBACK(gcPrologueCallback) {
-  v8::Local<Value> argv[] = { Nan::New("prologue").ToLocalChecked() };
-  Nan::MakeCallback(Nan::GetCurrentContext()->Global(), Nan::New(callback), 1, argv);
-}
-
-NAN_METHOD(Hook) {
-  callback.Reset(args[0].As<Function>());
-  Nan::AddGCPrologueCallback(gcPrologueCallback);
-  info.GetReturnValue().Set(info.Holder());
-}
-```
-
-<a name="api_nan_add_gc_epilogue_callback"></a>
-### Nan::AddGCEpilogueCallback()
-
-Signature:
-
-```c++
-void Nan::AddGCEpilogueCallback(v8::Isolate::GCEpilogueCallback callback, v8::GCType gc_type_filter = v8::kGCTypeAll)
-```
-
-Calls V8's [`AddGCEpilogueCallback()`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#a90d1860babc76059c62514b422f56960).
-
-<a name="api_nan_remove_gc_epilogue_callback"></a>
-### Nan::RemoveGCEpilogueCallback()
-
-Signature:
-
-```c++
-void Nan::RemoveGCEpilogueCallback(v8::Isolate::GCEpilogueCallback callback)
-```
-
-Calls V8's [`RemoveGCEpilogueCallback()`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#a05c60859fd4b8e96bfcd451281ed6c7c).
-
-<a name="api_nan_add_gc_prologue_callback"></a>
-### Nan::AddGCPrologueCallback()
-
-Signature:
-
-```c++
-void Nan::AddGCPrologueCallback(v8::Isolate::GCPrologueCallback, v8::GCType gc_type_filter callback)
-```
-
-Calls V8's [`AddGCPrologueCallback()`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#ab4b87b8f9f8e5bf95eba4009357e001f).
-
-<a name="api_nan_remove_gc_prologue_callback"></a>
-### Nan::RemoveGCPrologueCallback()
-
-Signature:
-
-```c++
-void Nan::RemoveGCPrologueCallback(v8::Isolate::GCPrologueCallback callback)
-```
-
-Calls V8's [`RemoveGCEpilogueCallback()`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#a9f6c51932811593f81ff30b949124186).
-
-<a name="api_nan_get_heap_statistics"></a>
-### Nan::GetHeapStatistics()
-
-Signature:
-
-```c++
-void Nan::GetHeapStatistics(v8::HeapStatistics *heap_statistics)
-```
-
-Calls V8's [`GetHeapStatistics()`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#a5593ac74687b713095c38987e5950b34).
-
-<a name="api_nan_set_counter_function"></a>
-### Nan::SetCounterFunction()
-
-Signature:
-
-```c++
-void Nan::SetCounterFunction(v8::CounterLookupCallback cb)
-```
-
-Calls V8's [`SetCounterFunction()`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#a045d7754e62fa0ec72ae6c259b29af94).
-
-<a name="api_nan_set_create_histogram_function"></a>
-### Nan::SetCreateHistogramFunction()
-
-Signature:
-
-```c++
-void Nan::SetCreateHistogramFunction(v8::CreateHistogramCallback cb) 
-```
-
-Calls V8's [`SetCreateHistogramFunction()`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#a542d67e85089cb3f92aadf032f99e732).
-
-<a name="api_nan_set_add_histogram_sample_function"></a>
-### Nan::SetAddHistogramSampleFunction()
-
-Signature:
-
-```c++
-void Nan::SetAddHistogramSampleFunction(v8::AddHistogramSampleCallback cb) 
-```
-
-Calls V8's [`SetAddHistogramSampleFunction()`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#aeb420b690bc2c216882d6fdd00ddd3ea).
-
-<a name="api_nan_idle_notification"></a>
-### Nan::IdleNotification()
-
-Signature:
-
-```c++
-void Nan::IdleNotification(v8::HeapStatistics *heap_statistics)
-```
-
-Calls V8's [`IdleNotification()` or `IdleNotificationDeadline()`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#ad6a2a02657f5425ad460060652a5a118) depending on V8 version.
-
-<a name="api_nan_low_memory_notification"></a>
-### Nan::LowMemoryNotification()
-
-Signature:
-
-```c++
-void Nan::LowMemoryNotification() 
-```
-
-Calls V8's [`IdleNotification()`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#a24647f61d6b41f69668094bdcd6ea91f).
-
-<a name="api_nan_context_disposed_notification"></a>
-### Nan::ContextDisposedNotification()
-
-Signature:
-
-```c++
-void Nan::ContextDisposedNotification()
-```
-
-Calls V8's [`ContextDisposedNotification()`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#ad7f5dc559866343fe6cd8db1f134d48b).
-
-<a name="api_nan_get_internal_field_pointer"></a>
-### Nan::GetInternalFieldPointer()
-
-Gets a pointer to the internal field with at `index` from a V8 `Object` handle.
-
-Signature:
-
-```c++
-void* Nan::GetInternalFieldPointer(v8::Local<v8::Object> object, int index) 
-```
-
-Calls the Object's [`GetAlignedPointerFromInternalField()` or `GetPointerFromInternalField()`](https://v8docs.nodesource.com/io.js-3.0/db/d85/classv8_1_1_object.html#ab3c57184263cf29963ef0017bec82281) depending on the version of V8.
-
-<a name="api_nan_set_internal_field_pointer"></a>
-### Nan::SetInternalFieldPointer()
-
-Sets the value of the internal field at `index` on a V8 `Object` handle.
-
-Signature:
-
-```c++
-void Nan::SetInternalFieldPointer(v8::Local<v8::Object> object, int index, void* value)
-```
-
-Calls the Object's [`SetAlignedPointerInInternalField()` or `SetPointerInInternalField()`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#ad7f5dc559866343fe6cd8db1f134d48b) depending on the version of V8.
-
-<a name="api_nan_adjust_external_memory"></a>
-### Nan::AdjustExternalMemory()
-
-Signature:
-
-```c++
-int Nan::AdjustExternalMemory(int bytesChange)
-```
-
-Calls V8's [`AdjustAmountOfExternalAllocatedMemory()` or `AdjustAmountOfExternalAllocatedMemory()`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#ae1a59cac60409d3922582c4af675473e) depending on the version of V8.
-

tools/LiveTexturing/LiveTexturing/node_modules/zmq/node_modules/nan/doc/v8_misc.md

@@ -1,63 +0,0 @@
-## Miscellaneous V8 Helpers
-
- - <a href="#api_nan_utf8_string"><b><code>Nan::Utf8String</code></b></a>
- - <a href="#api_nan_get_current_context"><b><code>Nan::GetCurrentContext()</code></b></a>
- - <a href="#api_nan_set_isolate_data"><b><code>Nan::SetIsolateData()</code></b></a>
- - <a href="#api_nan_get_isolate_data"><b><code>Nan::GetIsolateData()</code></b></a>
-
-
-<a name="api_nan_utf8_string"></a>
-### Nan::Utf8String
-
-Converts an object to a UTF-8-encoded character array. If conversion to a string fails (e.g. due to an exception in the toString() method of the object) then the length() method returns 0 and the * operator returns NULL. The underlying memory used for this object is managed by the object.
-
-An implementation of [`v8::String::Utf8Value`](https://v8docs.nodesource.com/io.js-3.0/d4/d1b/classv8_1_1_string_1_1_utf8_value.html) that is consistent across all supported versions of V8.
-
-Definition:
-
-```c++
-class Nan::Utf8String {
- public:
-  Nan::Utf8String(v8::Local<v8::Value> from);
-
-  int length() const;
-
-  char* operator*();
-  const char* operator*() const;
-};
-```
-
-<a name="api_nan_get_current_context"></a>
-### Nan::GetCurrentContext()
-
-A call to [`v8::Isolate::GetCurrent()->GetCurrentContext()`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#a81c7a1ed7001ae2a65e89107f75fd053) that works across all supported versions of V8.
-
-Signature:
-
-```c++
-v8::Local<v8::Context> Nan::GetCurrentContext()
-```
-
-<a name="api_nan_set_isolate_data"></a>
-### Nan::SetIsolateData()
-
-A helper to provide a consistent API to [`v8::Isolate#SetData()`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#a7acadfe7965997e9c386a05f098fbe36).
-
-Signature:
-
-```c++
-void Nan::SetIsolateData(v8::Isolate *isolate, T *data)
-```
-
-
-<a name="api_nan_get_isolate_data"></a>
-### Nan::GetIsolateData()
-
-A helper to provide a consistent API to [`v8::Isolate#GetData()`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#aabd223436bc1100a787dadaa024c6257).
-
-Signature:
-
-```c++
-T *Nan::GetIsolateData(v8::Isolate *isolate)
-```
-