Event refactoring. Now it is possible to subscribe to events of a specific sender. To be able to send events, one must also derive from EventListener.

Event library removed for containing only a few files. 
Event unsubscribing optimized.
Remote events changed back to a whitelist system.

CMakeLists.txt

@@ -107,7 +107,6 @@ endmacro ()
 add_subdirectory (Engine/Audio)
 add_subdirectory (Engine/Common)
 add_subdirectory (Engine/Engine)
-add_subdirectory (Engine/Event)
 add_subdirectory (Engine/Input)
 add_subdirectory (Engine/Math)
 add_subdirectory (Engine/Network)

Engine/Audio/CMakeLists.txt

@@ -8,11 +8,11 @@ set (SOURCE_FILES ${CPP_FILES} ${H_FILES})
 
 # Include directories
 include_directories (
-    ../Common ../Event ../Math ../Resource ../Scene ../../ThirdParty/STB
+    ../Common ../Math ../Resource ../Scene ../../ThirdParty/STB
 )
 
 # Define target & libraries to link
 add_library (${TARGET_NAME} STATIC ${SOURCE_FILES})
-target_link_libraries (${TARGET_NAME} Common Event Math Resource Scene STB dsound.lib)
+target_link_libraries (${TARGET_NAME} Common Math Resource Scene STB dsound.lib)
 enable_pch ()
 finalize_lib ()

Engine/Event/Event.h → Engine/Common/Event.h

@@ -21,23 +21,12 @@
 // THE SOFTWARE.
 //
 
-#ifndef EVENT_EVENT_H
-#define EVENT_EVENT_H
+#ifndef COMMON_EVENT_H
+#define COMMON_EVENT_H
 
 #include "Variant.h"
 
 #define DEFINE_EVENT(eventID, eventName) static const StringHash eventID(#eventName); namespace eventName
 #define EVENT_PARAM(paramID, paramName) static const ShortStringHash paramID(#paramName)
 
-class EventListener;
-
-//! Send event to all subscribers
-void sendEvent(StringHash eventType);
-//! Send event with parameters to all subscribers
-void sendEvent(StringHash eventType, VariantMap& eventData);
-//! Send event to a specified receiver. Optionally check if the receiver is a valid (by default not)
-void sendEvent(EventListener* receiver, StringHash eventType, bool direct = true);
-//! Send event with parameters to a specified receiver. Optionally check if the receiver is valid (by default not)
-void sendEvent(EventListener* receiver, StringHash eventType, VariantMap& eventData, bool direct = true);
-
-#endif // EVENT_EVENT_H
+#endif // COMMON_EVENT_H

Engine/Common/EventListener.cpp

@@ -0,0 +1,317 @@
+//
+// Urho3D Engine
+// Copyright (c) 2008-2011 Lasse Öörni
+//
+// 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.
+//
+
+#include "Precompiled.h"
+#include "EventListener.h"
+#include "Log.h"
+#include "Profiler.h"
+#include "StringUtils.h"
+
+#include <set>
+
+#include "DebugNew.h"
+
+static VariantMap noEventData;
+
+std::map<StringHash, std::vector<EventListener*> > EventListener::sEventListeners;
+std::map<std::pair<EventListener*, StringHash>, std::vector<EventListener*> > EventListener::sSpecificEventListeners;
+
+EventListener::EventListener()
+{
+}
+
+EventListener::~EventListener()
+{
+    unsubscribeFromAllEvents();
+    
+    // Remove from all specific event listeners
+    for (std::map<std::pair<EventListener*, StringHash>, std::vector<EventListener*> >::iterator i = sSpecificEventListeners.begin();
+        i != sSpecificEventListeners.end();)
+    {
+        std::map<std::pair<EventListener*, StringHash>, std::vector<EventListener*> >::iterator current = i;
+        ++i;
+        if (current->first.first == this)
+        {
+            std::vector<EventListener*>& listeners = current->second;
+            for (std::vector<EventListener*>::iterator j = listeners.begin(); j != listeners.end(); ++j)
+                (*j)->removeSpecificEventHandlers(this);
+            sSpecificEventListeners.erase(current);
+        }
+    }
+}
+
+void EventListener::onEvent(EventListener* sender, StringHash eventType, VariantMap& eventData)
+{
+    // Check first the specific event handlers, which have priority
+    std::map<std::pair<EventListener*, StringHash>, EventHandlerInvoker*>::const_iterator i = mSpecificEventHandlers.find(
+        std::make_pair(sender, eventType));
+    if (i != mSpecificEventHandlers.end())
+    {
+        i->second->invoke(eventType, eventData);
+        return;
+    }
+    
+    std::map<StringHash, EventHandlerInvoker*>::const_iterator j = mEventHandlers.find(eventType);
+    if (j != mEventHandlers.end())
+        j->second->invoke(eventType, eventData);
+}
+
+void EventListener::subscribeToEvent(StringHash eventType, EventHandlerInvoker* handler)
+{
+    if (!handler)
+    {
+        LOGERROR("Null event handler for event " + toString(eventType));
+        return;
+    }
+    
+    // If there already is a handler, delete it
+    std::map<StringHash, EventHandlerInvoker*>::iterator i = mEventHandlers.find(eventType);
+    if (i != mEventHandlers.end())
+        delete i->second;
+    
+    mEventHandlers[eventType] = handler;
+    
+    std::vector<EventListener*>& listeners = sEventListeners[eventType];
+    for (std::vector<EventListener*>::const_iterator j = listeners.begin(); j != listeners.end(); ++j)
+    {
+        // Check if already registered
+        if (*j == this)
+            return;
+    }
+    
+    listeners.push_back(this);
+}
+
+void EventListener::subscribeToEvent(EventListener* sender, StringHash eventType, EventHandlerInvoker* handler)
+{
+    if (!sender)
+    {
+        LOGERROR("Null event sender for event " + toString(eventType));
+        return;
+    }
+    
+    if (!handler)
+    {
+        LOGERROR("Null event handler for event " + toString(eventType));
+        return;
+    }
+    
+    std::pair<EventListener*, StringHash> combination(sender, eventType);
+    
+    // If there already is a handler, delete it
+    std::map<std::pair<EventListener*, StringHash>, EventHandlerInvoker*>::iterator i = mSpecificEventHandlers.find(combination);
+    if (i != mSpecificEventHandlers.end())
+        delete i->second;
+    
+    mSpecificEventHandlers[combination] = handler;
+    
+    std::vector<EventListener*>& listeners = sSpecificEventListeners[combination];
+    for (std::vector<EventListener*>::const_iterator j = listeners.begin(); j != listeners.end(); ++j)
+    {
+        // Check if already registered
+        if (*j == this)
+            return;
+    }
+    
+    listeners.push_back(this);
+}
+
+void EventListener::unsubscribeFromEvent(StringHash eventType)
+{
+    // Check first specific events
+    for (std::map<std::pair<EventListener*, StringHash>, EventHandlerInvoker*>::iterator i = mSpecificEventHandlers.begin();
+        i != mSpecificEventHandlers.end();)
+    {
+        std::map<std::pair<EventListener*, StringHash>, EventHandlerInvoker*>::iterator current = i;
+        ++i;
+        if (current->first.second == eventType)
+        {
+            removeEventListener(current->first.first, current->first.second);
+            delete current->second;
+            mSpecificEventHandlers.erase(current);
+        }
+    }
+    
+    // Then non-specific
+    std::map<StringHash, EventHandlerInvoker*>::iterator i = mEventHandlers.find(eventType);
+    if (i != mEventHandlers.end())
+    {
+        removeEventListener(i->first);
+        delete i->second;
+        mEventHandlers.erase(i);
+    }
+}
+
+void EventListener::unsubscribeFromEvent(EventListener* sender, StringHash eventType)
+{
+    std::pair<EventListener*, StringHash> combination(sender, eventType);
+    
+    std::map<std::pair<EventListener*, StringHash>, EventHandlerInvoker*>::iterator i = mSpecificEventHandlers.find(combination);
+    if (i != mSpecificEventHandlers.end())
+    {
+        removeEventListener(i->first.first, i->first.second);
+        delete i->second;
+        mSpecificEventHandlers.erase(i);
+    }
+}
+
+void EventListener::unsubscribeFromEvents(EventListener* sender)
+{
+    for (std::map<std::pair<EventListener*, StringHash>, EventHandlerInvoker*>::iterator i = mSpecificEventHandlers.begin();
+        i != mSpecificEventHandlers.end();)
+    {
+        std::map<std::pair<EventListener*, StringHash>, EventHandlerInvoker*>::iterator current = i;
+        ++i;
+        if (current->first.first == sender)
+        {
+            removeEventListener(current->first.first, current->first.second);
+            delete current->second;
+            mSpecificEventHandlers.erase(current);
+        }
+    }
+}
+
+void EventListener::unsubscribeFromAllEvents()
+{
+    for (std::map<std::pair<EventListener*, StringHash>, EventHandlerInvoker*>::iterator i = mSpecificEventHandlers.begin();
+        i != mSpecificEventHandlers.end(); ++i)
+    {
+        removeEventListener(i->first.first, i->first.second);
+        delete i->second;
+    }
+    mSpecificEventHandlers.clear();
+    
+    for (std::map<StringHash, EventHandlerInvoker*>::iterator i = mEventHandlers.begin(); i != mEventHandlers.end(); ++i)
+    {
+        removeEventListener(i->first);
+        delete i->second;
+    }
+    mEventHandlers.clear();
+}
+
+void EventListener::sendEvent(StringHash eventType)
+{
+    sendEvent(eventType, noEventData);
+}
+
+void EventListener::sendEvent(StringHash eventType, VariantMap& eventData)
+{
+    std::set<EventListener*> processed;
+    
+    // Check first the specific event listeners
+    std::map<std::pair<EventListener*, StringHash>, std::vector<EventListener*> >::const_iterator i = sSpecificEventListeners.find(
+        std::make_pair(this, eventType));
+    if (i != sSpecificEventListeners.end())
+    {
+        const std::vector<EventListener*>& listeners = i->second;
+        // Iterate in reverse direction in case listeners remove themselves as a response
+        for (unsigned j = listeners.size() - 1; j < listeners.size(); --j)
+        {
+            listeners[j]->onEvent(this, eventType, eventData);
+            processed.insert(listeners[j]);
+        }
+    }
+    
+    // Then the non-specific listeners
+    std::map<StringHash, std::vector<EventListener*> >::const_iterator j = sEventListeners.find(eventType);
+    if (j == sEventListeners.end())
+        return;
+    const std::vector<EventListener*>& listeners = j->second;
+    if (processed.empty())
+    {
+        for (unsigned k = listeners.size() - 1; k < listeners.size(); --k)
+            listeners[k]->onEvent(this, eventType, eventData);
+    }
+    else
+    {
+        // If there were specific listeners, check that the event is not sent doubly to them
+        for (unsigned k = listeners.size() - 1; k < listeners.size(); --k)
+        {
+            if (processed.find(listeners[k]) == processed.end())
+                listeners[k]->onEvent(this, eventType, eventData);
+        }
+    }
+}
+
+void EventListener::sendEvent(EventListener* receiver, StringHash eventType)
+{
+    if (receiver)
+        receiver->onEvent(this, eventType, noEventData);
+}
+
+void EventListener::sendEvent(EventListener* receiver, StringHash eventType, VariantMap& eventData)
+{
+    if (receiver)
+        receiver->onEvent(this, eventType, eventData);
+}
+
+bool EventListener::hasSubscribedToEvent(StringHash eventType) const
+{
+    return mEventHandlers.find(eventType) != mEventHandlers.end();
+}
+
+bool EventListener::hasSubscribedToEvent(EventListener* sender, StringHash eventType) const
+{
+    return mSpecificEventHandlers.find(std::make_pair(sender, eventType)) != mSpecificEventHandlers.end();
+}
+
+void EventListener::removeSpecificEventHandlers(EventListener* sender)
+{
+    for (std::map<std::pair<EventListener*, StringHash>, EventHandlerInvoker*>::iterator i = mSpecificEventHandlers.begin();
+        i != mSpecificEventHandlers.end();)
+    {
+        std::map<std::pair<EventListener*, StringHash>, EventHandlerInvoker*>::iterator current = i;
+        ++i;
+        if (current->first.first == sender)
+        {
+            delete current->second;
+            mSpecificEventHandlers.erase(current);
+        }
+    }
+}
+
+void EventListener::removeEventListener(StringHash eventType)
+{
+    std::vector<EventListener*>& listeners = sEventListeners[eventType];
+    for (std::vector<EventListener*>::iterator i = listeners.begin(); i != listeners.end(); ++i)
+    {
+        if (*i == this)
+        {
+            listeners.erase(i);
+            return;
+        }
+    }
+}
+
+void EventListener::removeEventListener(EventListener* sender, StringHash eventType)
+{
+    std::vector<EventListener*>& listeners = sSpecificEventListeners[std::make_pair(sender, eventType)];
+    for (std::vector<EventListener*>::iterator i = listeners.begin(); i != listeners.end(); ++i)
+    {
+        if (*i == this)
+        {
+            listeners.erase(i);
+            return;
+        }
+    }
+}

Engine/Event/EventListener.h → Engine/Common/EventListener.h

@@ -21,8 +21,8 @@
 // THE SOFTWARE.
 //
 
-#ifndef EVENT_EVENTLISTENER_H
-#define EVENT_EVENTLISTENER_H
+#ifndef COMMON_EVENTLISTENER_H
+#define COMMON_EVENTLISTENER_H
 
 #include "Event.h"
 
@@ -93,9 +93,6 @@ private:
 //! Event listener
 class EventListener
 {
-    friend void sendEvent(StringHash eventType, VariantMap& eventData);
-    friend void sendEvent(EventListener* receiver, StringHash eventType, VariantMap& eventData, bool direct);
-    
 public:
     //! Construct
     EventListener();
@@ -103,20 +100,46 @@ public:
     virtual ~EventListener();
     
     //! Handle an event
-    virtual void handleEvent(StringHash eventType, VariantMap& eventData);
+    virtual void onEvent(EventListener* sender, StringHash eventType, VariantMap& eventData);
     
-    //! Subscribe to an event with a specified handler function
+    //! Subscribe to an event that can be sent by any sender
     void subscribeToEvent(StringHash eventType, EventHandlerInvoker* handler);
+    //! Subscribe to a specific sender's event
+    void subscribeToEvent(EventListener* sender, StringHash eventType, EventHandlerInvoker* handler);
     //! Unsubscribe from an event
     void unsubscribeFromEvent(StringHash eventType);
+    //! Unsubscribe from a specific sender's event
+    void unsubscribeFromEvent(EventListener* sender, StringHash eventType);
+    //! Unsubscribe from a specific sender's events
+    void unsubscribeFromEvents(EventListener* sender);
     //! Unsubscribe from all events
     void unsubscribeFromAllEvents();
-    //! Return whether has subscribed to a specific event
+    //! Send event to all subscribers
+    void sendEvent(StringHash eventType);
+    //! Send event with parameters to all subscribers
+    void sendEvent(StringHash eventType, VariantMap& eventData);
+    //! Send event to a specific receiver
+    void sendEvent(EventListener* receiver, StringHash eventType);
+    //! Send event with parameters to a specific receiver
+    void sendEvent(EventListener* receiver, StringHash eventType, VariantMap& eventData);
+    
+    //! Return whether has subscribed to an event
     bool hasSubscribedToEvent(StringHash eventType) const;
+    //! Return whether has subscribed to a specific sender & event
+    bool hasSubscribedToEvent(EventListener* sender, StringHash eventType) const;
+    
+    //! Remove event handlers related to a specific sender
+    void removeSpecificEventHandlers(EventListener* sender);
+    //! Remove event listener from specific events
+    void removeEventListener(EventListener* sender, StringHash eventType);
+    //! Remove event listener from non-specific events
+    void removeEventListener(StringHash eventType);
     
 protected:
-    //! Event handlers
+    //! Event handlers for non-specific events
     std::map<StringHash, EventHandlerInvoker*> mEventHandlers;
+    //! Event handlers for specific senders' events
+    std::map<std::pair<EventListener*, StringHash>, EventHandlerInvoker*> mSpecificEventHandlers;
     
 private:
     //! Prevent copy construction
@@ -124,8 +147,10 @@ private:
     //! Prevent assignment
     EventListener& operator = (const EventListener& rhs);
     
-    //! Event listeners per event
+    //! Event listeners for non-specific events
     static std::map<StringHash, std::vector<EventListener*> > sEventListeners;
+    //! Event listeners for specific senders' events
+    static std::map<std::pair<EventListener*, StringHash>, std::vector<EventListener*> > sSpecificEventListeners;
 };
 
 #endif // EVENT_EVENTLISTENER_H

Engine/Common/Variant.cpp

@@ -24,6 +24,7 @@
 #include "Precompiled.h"
 #include "Deserializer.h"
 #include "Exception.h"
+#include "Log.h"
 #include "Serializer.h"
 #include "StringUtils.h"
 
@@ -64,7 +65,10 @@ void Variant::fromString(const std::string& type, const std::string& value)
         *this = buffer;
     }
     else if (typeLower == "pointer")
-        *this = (void*)toInt(value);
+    {
+        LOGWARNING("Deserialized pointer Variant set to null");
+        *this = (void*)0;
+    }
     else
         clear();
 }
@@ -121,7 +125,8 @@ void Variant::write(Serializer& dest) const
         break;
         
     case VAR_PTR:
-        dest.writeUInt((unsigned)mValue.mPtr);
+        LOGWARNING("Serialized pointer Variant set to null");
+        dest.writeUInt(0);
         break;
     }
 }
@@ -178,7 +183,9 @@ void Variant::read(Deserializer& source)
         break;
         
     case VAR_PTR:
-        mValue.mPtr = (void*)source.readUInt();
+        LOGWARNING("Deserialized pointer Variant set to null");
+        source.readUInt();
+        mValue.mPtr = 0;
         break;
         
     default:
@@ -248,7 +255,8 @@ std::string Variant::toString() const
             return ret;
         }
     case VAR_PTR:
-        return ::toString((unsigned)mValue.mPtr);
+        LOGWARNING("Serialized pointer Variant set to null");
+        return ::toString((unsigned)0);
     }
     
     return std::string();

Engine/Engine/CMakeLists.txt

@@ -8,13 +8,13 @@ set (SOURCE_FILES ${CPP_FILES} ${H_FILES})
 
 # Include directories
 include_directories (
-    ../Audio ../Common ../Event ../Input ../Math ../Network ../Physics ../Renderer ../Resource ../Scene
-    ../Script ../UI ../../ThirdParty/AngelScript/include
+    ../Audio ../Common ../Input ../Math ../Network ../Physics ../Renderer ../Resource ../Scene ../Script
+    ../UI ../../ThirdParty/AngelScript/include
 )
 
 # Define target & libraries to link
 add_library (${TARGET_NAME} STATIC ${SOURCE_FILES})
-target_link_libraries (${TARGET_NAME} Audio Common Event Input Math Network Physics Renderer Resource
+target_link_libraries (${TARGET_NAME} Audio Common Input Math Network Physics Renderer Resource
     Scene Script UI)
 enable_pch ()
 finalize_lib ()

Engine/Engine/Connection.h

@@ -47,7 +47,7 @@ enum JoinState
 };
 
 //! A remote connection in the high-level networking protocol
-class Connection : public RefCounted
+class Connection : public RefCounted, public EventListener
 {
 public:
     //! Construct with a pointer to the network peer

Engine/Engine/Console.cpp

@@ -73,7 +73,7 @@ Console::Console(Engine* engine) :
         
         updateElements();
         
-        subscribeToEvent(EVENT_TEXTFINISHED, EVENT_HANDLER(Console, handleTextFinished));
+        subscribeToEvent(mLineEdit, EVENT_TEXTFINISHED, EVENT_HANDLER(Console, handleTextFinished));
         subscribeToEvent(EVENT_WINDOWRESIZED, EVENT_HANDLER(Console, handleWindowResized));
     }
 }
@@ -187,14 +187,11 @@ void Console::handleTextFinished(StringHash eventType, VariantMap& eventData)
 {
     using namespace TextFinished;
     
-    if (eventData[P_ELEMENT].getPtr() == (void*)mLineEdit)
-    {
-        std::string line = mLineEdit->getText();
-        ScriptEngine* scriptEngine = mEngine->getScriptEngine();
-        if (scriptEngine)
-            scriptEngine->execute(line);
-        mLineEdit->setText(std::string());
-    }
+    std::string line = mLineEdit->getText();
+    ScriptEngine* scriptEngine = mEngine->getScriptEngine();
+    if (scriptEngine)
+        scriptEngine->execute(line);
+    mLineEdit->setText(std::string());
 }
 
 void Console::handleWindowResized(StringHash eventType, VariantMap& eventData)

Engine/Engine/Engine.cpp

@@ -95,9 +95,6 @@ Engine::Engine(const std::string& windowTitle, const std::string& logFileName, b
     
     mCache = new ResourceCache();
     
-    // Register the engine and library events as local only
-    resetLocalOnlyEvents();
-    
     sInstance = this;
 }
 
@@ -366,24 +363,6 @@ DebugHud* Engine::createDebugHud()
     return mDebugHud;
 }
 
-void Engine::resetLocalOnlyEvents()
-{
-    static const std::string inbuiltEvents[] = {
-        "Update", "PostUpdate", "PostRenderUpdate", "ClientIdentity", "ClientJoinedScene", "ClientLeftScene", "ClientControls",
-        "ClientDisconnected", "GotSceneInfoList", "JoinedScene", "JoinSceneFailed", "FileTransferCompleted", "FileTransferFailed",
-        "ControlsUpdate", "ControlsPlayback", "MouseButtonDown", "MouseButtonUp", "MouseMove", "KeyDown", "KeyUp", "Char",
-        "PeerConnected", "NetworkPacket", "PeerDisconnected", "PhysicsPreStep", "PhysicsPostStep", "PhysicsCollision",
-        "EntityCollision", "WindowMessage", "WindowResized", "BeginFrame", "EndFrame", "SceneUpdate", "ScenePostUpdate",
-        "AsyncLoadProgress", "AsyncLoadFinished", "TryFocus", "Focused", "Defocused", "Pressed", "Toggled", "SliderChanged",
-        "ViewChanged", "TextChanged", "TextFinished", "ItemSelected", ""
-    };
-    
-    // First clear existing registrations, then register the inbuild events
-    removeAllLocalOnlyEvents();
-    for (unsigned i = 0; inbuiltEvents[i].length(); ++i)
-        registerLocalOnlyEvent(inbuiltEvents[i]);
-}
-
 void Engine::setDefaultScene(Scene* scene)
 {
     mDefaultScene = scene;
@@ -631,9 +610,6 @@ void Engine::registerScriptAPI()
     LOGDEBUG("Registering Common library");
     registerCommonLibrary(engine);
     
-    LOGDEBUG("Registering Event library");
-    registerEventLibrary(engine);
-    
     LOGDEBUG("Registering Resource library");
     registerResourceLibrary(engine);
     

Engine/Engine/Engine.h

@@ -90,8 +90,6 @@ public:
     void removeClient();
     //! Remove the server subsystem
     void removeServer();
-    //! Clear previous and register the default local only events
-    void resetLocalOnlyEvents();
     //! Set the default scene. This will always be available as the "scene" global property to scripting
     void setDefaultScene(Scene* scene);
     //! Set minimum frames per second. If FPS goes lower than this, time will appear to slow down

Engine/Engine/RegisterCommon.cpp

@@ -26,6 +26,7 @@
 #include "PackageFile.h"
 #include "ProcessUtils.h"
 #include "RegisterTemplates.h"
+#include "ScriptInstance.h"
 #include "StringUtils.h"
 #include "VectorBuffer.h"
 
@@ -635,6 +636,42 @@ static void registerProcessUtils(asIScriptEngine* engine)
     engine->RegisterGlobalFunction("uint getNumLogicalProcessors()", asFUNCTION(getNumLogicalProcessors), asCALL_CDECL);
 }
 
+static void SendEvent(const std::string& eventType, VariantMap& parameters)
+{
+    ScriptEventListener* sender = getScriptContextEventListener();
+    if (sender)
+        sender->sendEvent(StringHash(eventType), parameters);
+}
+
+static void SubscribeToEvent(const std::string& eventType, const std::string& handlerName)
+{
+    ScriptEventListener* listener = getScriptContextEventListener();
+    if (listener)
+        listener->addEventHandler(StringHash(eventType), handlerName);
+}
+
+static void UnsubscribeFromEvent(const std::string& eventType)
+{
+    ScriptEventListener* listener = getScriptContextEventListener();
+    if (listener)
+        listener->removeEventHandler(StringHash(eventType));
+}
+
+static void UnsubscribeFromAllEvents()
+{
+    ScriptEventListener* listener = getScriptContextEventListener();
+    if (listener)
+        listener->removeAllEventHandlers();
+}
+
+void registerEvents(asIScriptEngine* engine)
+{
+    engine->RegisterGlobalFunction("void sendEvent(const string& in, VariantMap&)", asFUNCTION(SendEvent), asCALL_CDECL);
+    engine->RegisterGlobalFunction("void subscribeToEvent(const string& in, const string& in)", asFUNCTION(SubscribeToEvent), asCALL_CDECL);
+    engine->RegisterGlobalFunction("void unsubscribeFromEvent(const string& in)", asFUNCTION(UnsubscribeFromEvent), asCALL_CDECL);
+    engine->RegisterGlobalFunction("void unsubscribeFromAllEvents()", asFUNCTION(UnsubscribeFromAllEvents), asCALL_CDECL);
+}
+
 void registerCommonLibrary(asIScriptEngine* engine)
 {
     registerColor(engine);
@@ -646,4 +683,5 @@ void registerCommonLibrary(asIScriptEngine* engine)
     registerPackageFile(engine);
     registerTimer(engine);
     registerProcessUtils(engine);
+    registerEvents(engine);
 }

Engine/Engine/RegisterEngine.cpp

@@ -139,7 +139,9 @@ static void registerConnection(asIScriptEngine* engine)
     engine->RegisterGlobalFunction("void sendRemoteEvent(Entity@+, const string& in, const VariantMap& in)", asFUNCTION(SendRemoteEntityEventToAll), asCALL_CDECL);
     engine->RegisterGlobalFunction("void sendRemoteEvent(Entity@+, const string& in, const VariantMap& in, Connection@+)", asFUNCTION(SendRemoteEntityEvent), asCALL_CDECL);
     engine->RegisterGlobalFunction("void sendRemoteEvent(Entity@+, const string& in, const VariantMap& in, Connection@+, uint16)", asFUNCTION(SendRemoteEntityEventTTL), asCALL_CDECL);
-    engine->RegisterGlobalFunction("void registerLocalOnlyEvent(const string& in)", asFUNCTIONPR(registerLocalOnlyEvent, (const std::string&), void), asCALL_CDECL);
+    engine->RegisterGlobalFunction("void registerRemoteEvent(const string& in)", asFUNCTIONPR(registerRemoteEvent, (const std::string&), void), asCALL_CDECL);
+    engine->RegisterGlobalFunction("void unregisterRemoteEvent(const string& in)", asFUNCTIONPR(unregisterRemoteEvent, (const std::string&), void), asCALL_CDECL);
+    engine->RegisterGlobalFunction("void unregisterAllRemoteEvents()", asFUNCTION(unregisterAllRemoteEvents), asCALL_CDECL);
     engine->RegisterGlobalFunction("Connection@+ getRemoteEventSender()", asFUNCTION(getRemoteEventSender), asCALL_CDECL);
 }
 
@@ -435,7 +437,6 @@ static void registerEngine(asIScriptEngine* engine)
     engine->RegisterObjectMethod("Engine", "DebugHud@+ createDebugHud()", asMETHOD(Engine, createDebugHud), asCALL_THISCALL);
     engine->RegisterObjectMethod("Engine", "void removeClient()", asMETHOD(Engine, removeClient), asCALL_THISCALL);
     engine->RegisterObjectMethod("Engine", "void removeServer()", asMETHOD(Engine, removeServer), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Engine", "void resetLocalOnlyEvents()", asMETHOD(Engine, resetLocalOnlyEvents), asCALL_THISCALL);
     engine->RegisterObjectMethod("Engine", "void setDefaultScene(Scene@+)", asMETHOD(Engine, setDefaultScene), asCALL_THISCALL);
     engine->RegisterObjectMethod("Engine", "void setMinFps(int)", asMETHOD(Engine, setMinFps), asCALL_THISCALL);
     engine->RegisterObjectMethod("Engine", "void setMaxFps(int)", asMETHOD(Engine, setMaxFps), asCALL_THISCALL);

Engine/Engine/RegisterEvent.cpp

@@ -1,85 +0,0 @@
-//
-// Urho3D Engine
-// Copyright (c) 2008-2011 Lasse Öörni
-//
-// 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.
-//
-
-#include "Precompiled.h"
-#include "ScriptFile.h"
-#include "ScriptInstance.h"
-
-#include <angelscript.h>
-
-#include "DebugNew.h"
-
-void SendEvent(const std::string& eventType, VariantMap& parameters)
-{
-    sendEvent(StringHash(eventType), parameters);
-}
-
-void SubscribeToEvent(const std::string& eventType, const std::string& handlerName)
-{
-    // Try to subscribe to an instance event first, then to a script file event if not found
-    ScriptInstance* instance = getScriptContextInstance();
-    if (instance)
-        instance->addEventHandler(StringHash(eventType), handlerName);
-    else
-    {
-        ScriptFile* file = getScriptContextFile();
-        if (file)
-            file->addEventHandler(StringHash(eventType), handlerName);
-    }
-}
-
-void UnsubscribeFromEvent(const std::string& eventType)
-{
-    // Try to unsubscribe from an instance event first, then from a script file event if not found
-    ScriptInstance* instance = getScriptContextInstance();
-    if (instance)
-        instance->removeEventHandler(StringHash(eventType));
-    else
-    {
-        ScriptFile* file = getScriptContextFile();
-        if (file)
-            file->removeEventHandler(StringHash(eventType));
-    }
-}
-
-void UnsubscribeFromAllEvents()
-{
-    // Try to unsubscribe from instance events first, then from script file events if not found
-    ScriptInstance* instance = getScriptContextInstance();
-    if (instance)
-        instance->removeAllEventHandlers();
-    else
-    {
-        ScriptFile* file = getScriptContextFile();
-        if (file)
-            file->removeAllEventHandlers();
-    }
-}
-
-void registerEventLibrary(asIScriptEngine* engine)
-{
-    engine->RegisterGlobalFunction("void sendEvent(const string& in, VariantMap&)", asFUNCTION(SendEvent), asCALL_CDECL);
-    engine->RegisterGlobalFunction("void subscribeToEvent(const string& in, const string& in)", asFUNCTION(SubscribeToEvent), asCALL_CDECL);
-    engine->RegisterGlobalFunction("void unsubscribeFromEvent(const string& in)", asFUNCTION(UnsubscribeFromEvent), asCALL_CDECL);
-    engine->RegisterGlobalFunction("void unsubscribeFromAllEvents()", asFUNCTION(UnsubscribeFromAllEvents), asCALL_CDECL);
-}

Engine/Engine/RegisterLibraries.h

@@ -30,8 +30,6 @@ class asIScriptEngine;
 void registerMathLibrary(asIScriptEngine* engine);
 //! Register the Common library to script
 void registerCommonLibrary(asIScriptEngine* engine);
-//! Register the Event library to script
-void registerEventLibrary(asIScriptEngine* engine);
 //! Register the Resource library to script
 void registerResourceLibrary(asIScriptEngine* engine);
 //! Register the Scene library to script

Engine/Engine/RegisterScene.cpp

@@ -47,11 +47,25 @@ static void DestructComponentRef(ComponentRef* ptr)
     ptr->~ComponentRef();
 }
 
+static void SendTargetedEvent(EventListener* listener, const std::string& eventType, VariantMap& parameters)
+{
+    // Try to send through the instance first, then through the script file event if not found
+    ScriptInstance* instance = getScriptContextInstance();
+    if (instance)
+        instance->sendEvent(listener, StringHash(eventType), parameters);
+    else
+    {
+        ScriptFile* file = getScriptContextFile();
+        if (file)
+            file->sendEvent(listener, StringHash(eventType), parameters);
+    }
+}
+
 static void SendComponentEvent(Component* component, const std::string& eventType, VariantMap& eventData)
 {
     EventListener* listener = dynamic_cast<EventListener*>(component);
     if (listener)
-        sendEvent(listener, StringHash(eventType), eventData);
+        SendTargetedEvent(listener, eventType, eventData);
 }
 
 static void registerComponent(asIScriptEngine* engine)
@@ -256,7 +270,7 @@ static Entity* GetEntity()
 
 static void SendEntityEvent(Entity* entity, const std::string& eventType, VariantMap& eventData)
 {
-    sendEvent(entity, StringHash(eventType), eventData);
+    SendTargetedEvent(entity, eventType, eventData);
 }
 
 static void registerEntity(asIScriptEngine* engine)

Engine/Event/CMakeLists.txt

@@ -1,17 +0,0 @@
-# Define target name
-set (TARGET_NAME Event)
-
-# Define source files
-file (GLOB CPP_FILES *.cpp)
-file (GLOB H_FILES *.h)
-set (SOURCE_FILES ${CPP_FILES} ${H_FILES})
-
-# Include directories
-include_directories (
-    ../Common ../Math
-)
-
-# Define target & libraries to link
-add_library (${TARGET_NAME} STATIC ${SOURCE_FILES})
-target_link_libraries (${TARGET_NAME} Common Math)
-finalize_lib ()

Engine/Event/Event.cpp

@@ -1,61 +0,0 @@
-//
-// Urho3D Engine
-// Copyright (c) 2008-2011 Lasse Öörni
-//
-// 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.
-//
-
-#include "EventListener.h"
-
-static VariantMap noEventData;
-
-void sendEvent(StringHash eventType)
-{
-    sendEvent(eventType, noEventData);
-}
-
-void sendEvent(StringHash eventType, VariantMap& eventData)
-{
-    std::vector<EventListener*>& listeners = EventListener::sEventListeners[eventType];
-    for (unsigned i = 0; i < listeners.size(); ++i)
-        listeners[i]->handleEvent(eventType, eventData);
-}
-
-void sendEvent(EventListener* receiver, StringHash eventType, bool direct)
-{
-    sendEvent(receiver, eventType, noEventData, direct);
-}
-
-void sendEvent(EventListener* receiver, StringHash eventType, VariantMap& eventData, bool direct)
-{
-    if ((direct) && (receiver))
-        receiver->handleEvent(eventType, eventData);
-    else
-    {
-        std::vector<EventListener*>& listeners = EventListener::sEventListeners[eventType];
-        for (std::vector<EventListener*>::iterator i = listeners.begin(); i != listeners.end(); ++i)
-        {
-            if (*i == receiver)
-            {
-                (*i)->handleEvent(eventType, eventData);
-                return;
-            }
-        }
-    }
-}

Engine/Event/EventListener.cpp

@@ -1,119 +0,0 @@
-//
-// Urho3D Engine
-// Copyright (c) 2008-2011 Lasse Öörni
-//
-// 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.
-//
-
-#include "EventListener.h"
-#include "Log.h"
-#include "Profiler.h"
-#include "StringUtils.h"
-
-#include "DebugNew.h"
-
-std::map<StringHash, std::vector<EventListener*> > EventListener::sEventListeners;
-
-EventListener::EventListener()
-{
-}
-
-EventListener::~EventListener()
-{
-    unsubscribeFromAllEvents();
-}
-
-void EventListener::handleEvent(StringHash eventType, VariantMap& eventData)
-{
-    std::map<StringHash, EventHandlerInvoker*>::const_iterator i = mEventHandlers.find(eventType);
-    if (i != mEventHandlers.end())
-        i->second->invoke(eventType, eventData);
-}
-
-void EventListener::subscribeToEvent(StringHash eventType, EventHandlerInvoker* handler)
-{
-    if (!handler)
-    {
-        LOGERROR("Null event handler for event " + toString((int)eventType));
-        return;
-    }
-    
-    // If there already is a handler, delete it
-    std::map<StringHash, EventHandlerInvoker*>::iterator i = mEventHandlers.find(eventType);
-    if (i != mEventHandlers.end())
-        delete i->second;
-    
-    mEventHandlers[eventType] = handler;
-    
-    std::vector<EventListener*>& listeners = sEventListeners[eventType];
-    for (std::vector<EventListener*>::const_iterator j = listeners.begin(); j != listeners.end(); ++j)
-    {
-        // Check if already registered
-        if (*j == this)
-            return;
-    }
-    
-    listeners.push_back(this);
-}
-
-void EventListener::unsubscribeFromEvent(StringHash eventType)
-{
-    std::map<StringHash, EventHandlerInvoker*>::iterator i = mEventHandlers.find(eventType);
-    if (i != mEventHandlers.end())
-    {
-        delete i->second;
-        mEventHandlers.erase(i);
-    }
-    
-    std::vector<EventListener*>& listeners = sEventListeners[eventType];
-    for (std::vector<EventListener*>::iterator j = listeners.begin(); j != listeners.end(); ++j)
-    {
-        if (*j == this)
-        {
-            listeners.erase(j);
-            return;
-        }
-    }
-}
-
-void EventListener::unsubscribeFromAllEvents()
-{
-    for (std::map<StringHash, EventHandlerInvoker*>::iterator i = mEventHandlers.begin(); i != mEventHandlers.end(); ++i)
-        delete i->second;
-    
-    mEventHandlers.clear();
-    
-    for (std::map<StringHash, std::vector<EventListener*> >::iterator i = sEventListeners.begin(); i != sEventListeners.end(); ++i)
-    {
-        std::vector<EventListener*>& listeners = i->second;
-        for (std::vector<EventListener*>::iterator j = listeners.begin(); j != listeners.end(); ++j)
-        {
-            if (*j == this)
-            {
-                listeners.erase(j);
-                break;
-            }
-        }
-    }
-}
-
-bool EventListener::hasSubscribedToEvent(StringHash eventType) const
-{
-    return mEventHandlers.find(eventType) != mEventHandlers.end();
-}

Engine/Input/CMakeLists.txt

@@ -8,10 +8,10 @@ set (SOURCE_FILES ${CPP_FILES} ${H_FILES})
 
 # Include directories
 include_directories (
-    ../Common ../Event ../Math ../Renderer ../Resource
+    ../Common ../Math ../Renderer ../Resource
 )
 
 # Define target & libraries to link
 add_library (${TARGET_NAME} STATIC ${SOURCE_FILES})
-target_link_libraries (${TARGET_NAME} Common Event Math Renderer Resource)
+target_link_libraries (${TARGET_NAME} Common Math Renderer Resource)
 finalize_lib ()

Engine/Input/Input.cpp

@@ -44,7 +44,7 @@ Input::Input(Renderer* renderer) :
     
     makeActive();
     
-    subscribeToEvent(EVENT_WINDOWMESSAGE, EVENT_HANDLER(Input, handleWindowMessage));
+    subscribeToEvent(mRenderer, EVENT_WINDOWMESSAGE, EVENT_HANDLER(Input, handleWindowMessage));
 }
 
 Input::~Input()
@@ -190,7 +190,7 @@ void Input::handleWindowMessage(StringHash eventType, VariantMap& eventData)
 {
     using namespace WindowMessage;
     
-    if ((!mRenderer) || (eventData[P_WINDOW].getInt() != mRenderer->getWindowHandle()))
+    if (!mRenderer)
         return;
     
     int msg = eventData[P_MSG].getInt();

Engine/Network/CMakeLists.txt

@@ -8,11 +8,11 @@ set (SOURCE_FILES ${CPP_FILES} ${H_FILES})
 
 # Include directories
 include_directories (
-    ../Common ../Event ../Math ../../ThirdParty/ENet/include
+    ../Common ../Math ../../ThirdParty/ENet/include
 )
 
 # Define target & libraries to link
 add_library (${TARGET_NAME} STATIC ${SOURCE_FILES})
-target_link_libraries (${TARGET_NAME} Common ENet Event Math)
+target_link_libraries (${TARGET_NAME} Common ENet Math)
 enable_pch ()
 finalize_lib ()

Engine/Physics/CMakeLists.txt

@@ -8,12 +8,12 @@ set (SOURCE_FILES ${CPP_FILES} ${H_FILES})
 
 # Include directories
 include_directories (
-    ../Common ../Event ../Math ../Renderer ../Resource ../Scene ../../ThirdParty/ODE/include
+    ../Common ../Math ../Renderer ../Resource ../Scene ../../ThirdParty/ODE/include
     ../../ThirdParty/StanHull
 )
 
 # Define target & libraries to link
 add_library (${TARGET_NAME} STATIC ${SOURCE_FILES})
-target_link_libraries (${TARGET_NAME} Common Event Math ODE Renderer Resource Scene StanHull)
+target_link_libraries (${TARGET_NAME} Common Math ODE Renderer Resource Scene StanHull)
 enable_pch ()
 finalize_lib ()

Engine/Physics/PhysicsWorld.cpp

@@ -587,7 +587,7 @@ void PhysicsWorld::nearCallback(void *userData, dGeomID geomA, dGeomID geomB)
     
     // Send collision events
     collisionData[PhysicsCollision::P_CONTACTS] = contactsA.getBuffer();
-    sendEvent(EVENT_PHYSICSCOLLISION, collisionData);
+    world->sendEvent(EVENT_PHYSICSCOLLISION, collisionData);
     
     if (entityA)
     {
@@ -595,7 +595,7 @@ void PhysicsWorld::nearCallback(void *userData, dGeomID geomA, dGeomID geomB)
         entityCollisionData[EntityCollision::P_OTHERBODY] = (void*)rigidBodyB;
         entityCollisionData[EntityCollision::P_OTHERENTITY] = (void*)entityB;
         entityCollisionData[EntityCollision::P_CONTACTS] = contactsA.getBuffer();
-        sendEvent(entityA, EVENT_ENTITYCOLLISION, entityCollisionData);
+        world->sendEvent(entityA, EVENT_ENTITYCOLLISION, entityCollisionData);
     }
     if (entityB)
     {
@@ -603,7 +603,7 @@ void PhysicsWorld::nearCallback(void *userData, dGeomID geomA, dGeomID geomB)
         entityCollisionData[EntityCollision::P_OTHERBODY] = (void*)rigidBodyA;
         entityCollisionData[EntityCollision::P_OTHERENTITY] = (void*)entityA;
         entityCollisionData[EntityCollision::P_CONTACTS] = contactsB.getBuffer();
-        sendEvent(entityB, EVENT_ENTITYCOLLISION, entityCollisionData);
+        world->sendEvent(entityB, EVENT_ENTITYCOLLISION, entityCollisionData);
     }
     
     // Propagate transient prediction based on physics interactions

Engine/Renderer/CMakeLists.txt

@@ -8,11 +8,11 @@ set (SOURCE_FILES ${CPP_FILES} ${H_FILES})
 
 # Include directories
 include_directories (
-    ../Common ../Event ../Math ../Resource ../Scene
+    ../Common ../Math ../Resource ../Scene
 )
 
 # Define target & libraries to link
 add_library (${TARGET_NAME} STATIC ${SOURCE_FILES})
-target_link_libraries (${TARGET_NAME} Common Event Math Resource Scene d3d9.lib)
+target_link_libraries (${TARGET_NAME} Common Math Resource Scene d3d9.lib)
 enable_pch ()
 finalize_lib ()

Engine/Renderer/Renderer.cpp

@@ -60,8 +60,10 @@ static const D3DCMPFUNC d3dCmpFunc[] =
 };
 
 // These are for optimizing the case where user supplies a single vertex buffer in setVertexBuffer()
-static std::vector<VertexBuffer*> vertexBuffers;
-static std::vector<unsigned> elementMasks;
+std::vector<VertexBuffer*> vertexBuffers;
+std::vector<unsigned> elementMasks;
+
+std::map<HWND, Renderer*> renderers;
 
 static LRESULT CALLBACK wndProc(HWND wnd, UINT msg, WPARAM wParam, LPARAM lParam);
 
@@ -137,6 +139,7 @@ Renderer::~Renderer()
     if (mImpl->mWindow)
     {
         DestroyWindow(mImpl->mWindow);
+        renderers.erase(mImpl->mWindow);
         mImpl->mWindow = 0;
     }
     
@@ -372,6 +375,7 @@ void Renderer::close()
         mImmediateVertexBuffers.clear();
         
         DestroyWindow(mImpl->mWindow);
+        renderers.erase(mImpl->mWindow);
         mImpl->mWindow = 0;
         mClosed = true;
     }
@@ -1894,6 +1898,8 @@ void Renderer::createWindow(int width, int height)
         mWindowPosX = wndpl.rcNormalPosition.left;
         mWindowPosY = wndpl.rcNormalPosition.top;
     }
+    
+    renderers[mImpl->mWindow] = this;
 }
 
 void Renderer::createInterface()
@@ -2222,16 +2228,20 @@ LRESULT CALLBACK wndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
 {
     using namespace WindowMessage;
     
-    VariantMap eventData;
-    eventData[P_WINDOW] = (int)hwnd;
-    eventData[P_MSG] = (int)msg;
-    eventData[P_WPARAM] = (int)wParam;
-    eventData[P_LPARAM] = (int)lParam;
-    eventData[P_HANDLED] = false;
-    
-    sendEvent(EVENT_WINDOWMESSAGE, eventData);
-    if (eventData[P_HANDLED].getBool())
-        return 0;
+    std::map<HWND, Renderer*>::const_iterator i = renderers.find(hwnd);
+    if (i != renderers.end())
+    {
+        VariantMap eventData;
+        eventData[P_WINDOW] = (int)hwnd;
+        eventData[P_MSG] = (int)msg;
+        eventData[P_WPARAM] = (int)wParam;
+        eventData[P_LPARAM] = (int)lParam;
+        eventData[P_HANDLED] = false;
+        
+        i->second->sendEvent(EVENT_WINDOWMESSAGE, eventData);
+        if (eventData[P_HANDLED].getBool())
+            return 0;
+    }
     
     return DefWindowProc(hwnd, msg, wParam, lParam);
 }

Engine/Scene/CMakeLists.txt

@@ -8,11 +8,11 @@ set (SOURCE_FILES ${CPP_FILES} ${H_FILES})
 
 # Include directories
 include_directories (
-    ../Common ../Event ../Math ../Resource ../../ThirdParty/TinyXML
+    ../Common ../Math ../Resource ../../ThirdParty/TinyXML
 )
 
 # Define target & libraries to link
 add_library (${TARGET_NAME} STATIC ${SOURCE_FILES})
-target_link_libraries (${TARGET_NAME} Common Event Math Resource TinyXML)
+target_link_libraries (${TARGET_NAME} Common Math Resource TinyXML)
 enable_pch ()
 finalize_lib ()

Engine/Scene/Entity.cpp

@@ -46,13 +46,13 @@ Entity::~Entity()
     removeAllComponents();
 }
 
-void Entity::handleEvent(StringHash eventType, VariantMap& eventData)
+void Entity::onEvent(EventListener* sender, StringHash eventType, VariantMap& eventData)
 {
     // Special-case event handling: send to all components that are event listeners
     for (std::vector<EventListener*>::const_iterator i = mEventListeners.begin(); i != mEventListeners.end(); ++i)
     {
-        // Note: we do not check if the component actually subscribes to the event, because handleEvent() does this check
-        (*i)->handleEvent(eventType, eventData);
+        // Note: we do not check if the component actually subscribes to the event, because onEvent() does this check
+        (*i)->onEvent(sender, eventType, eventData);
     }
 }
 

Engine/Scene/Entity.h

@@ -67,7 +67,8 @@ public:
     virtual ~Entity();
     
     //! Pass event to components who have subscribed to it if any
-    virtual void handleEvent(StringHash eventType, VariantMap& eventData);
+    virtual void onEvent(EventListener* sender, StringHash eventType, VariantMap& eventData);
+    
     //! Write properties and components to a stream
     void save(Serializer& dest);
     //! Read properties and components from a stream

Engine/Scene/RemoteEvent.cpp

@@ -31,7 +31,7 @@
 
 #include "DebugNew.h"
 
-static std::set<StringHash> localOnlyEvents;
+static std::set<StringHash> remoteEvents;
 Connection* remoteEventSender = 0;
 
 void RemoteEvent::write(Serializer& dest) const
@@ -56,7 +56,7 @@ void RemoteEvent::read(Deserializer& source, bool hasEntity)
 
 bool RemoteEvent::dispatch(Connection* sender, Scene* scene)
 {
-    if (!sender)
+    if ((!sender) || (!scene))
         return false;
     
     if (!checkRemoteEvent(mEventType))
@@ -65,45 +65,52 @@ bool RemoteEvent::dispatch(Connection* sender, Scene* scene)
         return false;
     }
     
+    // Note: because the Connection object is not known in the Scene library, we must use Scene as the sender
+    
     remoteEventSender = sender;
     if (!mEntityID)
-        sendEvent(mEventType, mEventData);
+        scene->sendEvent(mEventType, mEventData);
     else
     {
-        if (scene)
-        {
-            Entity* entity = scene->getEntity(mEntityID);
-            if (!entity)
-                LOGWARNING("Entity ID " + toString(mEntityID) + " not found for remote event " + toString(mEventType));
-            else
-                sendEvent(entity, mEventType, mEventData);
-        }
+        Entity* entity = scene->getEntity(mEntityID);
+        if (!entity)
+            LOGWARNING("Entity ID " + toString(mEntityID) + " not found for remote event " + toString(mEventType));
         else
-            LOGERROR("No scene for entity event");
+            scene->sendEvent(entity, mEventType, mEventData);
     }
     remoteEventSender = 0;
     return true;
 }
 
-void registerLocalOnlyEvent(StringHash eventType)
+void registerRemoteEvent(StringHash eventType)
 {
-    localOnlyEvents.insert(eventType);
+    remoteEvents.insert(eventType);
 }
 
-void registerLocalOnlyEvent(const std::string& name)
+void registerRemoteEvent(const std::string& name)
 {
     registerHash(name, false);
-    localOnlyEvents.insert(StringHash(name));
+    remoteEvents.insert(StringHash(name));
+}
+
+void unregisterRemoteEvent(StringHash eventType)
+{
+    remoteEvents.erase(eventType);
+}
+
+void unregisterRemoteEvent(const std::string& name)
+{
+    remoteEvents.erase(StringHash(name));
 }
 
-void removeAllLocalOnlyEvents()
+void unregisterAllRemoteEvents()
 {
-    localOnlyEvents.clear();
+    remoteEvents.clear();
 }
 
 bool checkRemoteEvent(StringHash eventType)
 {
-    return localOnlyEvents.find(eventType) == localOnlyEvents.end();
+    return remoteEvents.find(eventType) != remoteEvents.end();
 }
 
 Connection* getRemoteEventSender()

Engine/Scene/RemoteEvent.h

@@ -81,12 +81,16 @@ struct RemoteEvent
     unsigned short mTimeToLive;
 };
 
-//! Register an event to be only sent locally
-void registerLocalOnlyEvent(StringHash eventType);
-//! Register an event to be only sent locally
-void registerLocalOnlyEvent(const std::string& name);
-//! Remove all registered local only events
-void removeAllLocalOnlyEvents();
+//! Register an event to be sent/received remotely
+void registerRemoteEvent(StringHash eventType);
+//! Register an event to be sent/received remotely
+void registerRemoteEvent(const std::string& name);
+//! Unregister an event from being sent/received remotely
+void unregisterRemoteEvent(StringHash eventType);
+//! Unregister an event from being sent/received remotely
+void unregisterRemoteEvent(const std::string& name);
+//! Unregister all remote events
+void unregisterAllRemoteEvents();
 //! Check if an event is allowed to be sent remotely
 bool checkRemoteEvent(StringHash eventType);
 //! Return remote event sender connection. Only non-null during the event handling

Engine/Script/CMakeLists.txt

@@ -8,11 +8,11 @@ set (SOURCE_FILES ${CPP_FILES} ${H_FILES})
 
 # Include directories
 include_directories (
-    ../Common ../Event ../Math ../Physics ../Resource ../Scene ../../ThirdParty/AngelScript/include
+    ../Common ../Math ../Physics ../Resource ../Scene ../../ThirdParty/AngelScript/include
 )
 
 # Define target & libraries to link
 add_library (${TARGET_NAME} STATIC ${SOURCE_FILES})
-target_link_libraries (${TARGET_NAME} AngelScript Common Event Math Physics Resource Scene)
+target_link_libraries (${TARGET_NAME} AngelScript Common Math Physics Resource Scene)
 enable_pch ()
 finalize_lib ()

Engine/Script/ScriptInstance.cpp

@@ -656,3 +656,13 @@ Entity* getScriptContextEntity()
     ScriptInstance* instance = getScriptContextInstance();
     return instance ? instance->getEntity() : 0;
 }
+
+ScriptEventListener* getScriptContextEventListener()
+{
+    // First try to get the script instance. If not found, get the script file for procedural event handling
+    ScriptInstance* instance = getScriptContextInstance();
+    if (instance)
+        return instance;
+    ScriptFile* file = getScriptContextFile();
+    return file;
+}

Engine/Script/ScriptInstance.h

@@ -185,5 +185,7 @@ private:
 ScriptInstance* getScriptContextInstance();
 //! Return the entity of the active context
 Entity* getScriptContextEntity();
+//! Return the event listener of the active context
+ScriptEventListener* getScriptContextEventListener();
 
 #endif // SCRIPT_SCRIPTINSTANCE_H

Engine/UI/CMakeLists.txt

@@ -8,11 +8,11 @@ set (SOURCE_FILES ${CPP_FILES} ${H_FILES})
 
 # Include directories
 include_directories (
-    ../Common ../Event ../Input ../Math ../Renderer ../Resource ../../ThirdParty/STB ../../ThirdParty/TinyXML
+    ../Common ../Input ../Math ../Renderer ../Resource ../../ThirdParty/STB ../../ThirdParty/TinyXML
 )
 
 # Define target & libraries to link
 add_library (${TARGET_NAME} STATIC ${SOURCE_FILES})
-target_link_libraries (${TARGET_NAME} Common Event Input Math Renderer Resource STB TinyXML)
+target_link_libraries (${TARGET_NAME} Common Input Math Renderer Resource STB TinyXML)
 enable_pch ()
 finalize_lib ()

Examples/NetworkTest/CMakeLists.txt

@@ -8,11 +8,11 @@ set (SOURCE_FILES ${CPP_FILES} ${H_FILES})
 
 # Include directories
 include_directories (
-    ../../Engine/Common ../../Engine/Event ../../Engine/Math ../../Engine/Network
+    ../../Engine/Common ../../Engine/Math ../../Engine/Network
 )
 
 # Define target & libraries to link
 add_executable (${TARGET_NAME} ${SOURCE_FILES})
 set_target_properties (${TARGET_NAME} PROPERTIES DEBUG_POSTFIX _d)
-target_link_libraries (${TARGET_NAME} Common Event Math Network)
+target_link_libraries (${TARGET_NAME} Common Math Network)
 finalize_exe ()

Examples/NinjaSnowWar/CMakeLists.txt

@@ -8,15 +8,15 @@ set (SOURCE_FILES ${CPP_FILES} ${H_FILES})
 
 # Include directories
 include_directories (
-    ../../Engine/Audio ../../Engine/Common ../../Engine/Engine ../../Engine/Event ../../Engine/Input
-    ../../Engine/Math ../../Engine/Network ../../Engine/Physics ../../Engine/Renderer ../../Engine/Resource
+    ../../Engine/Audio ../../Engine/Common ../../Engine/Engine ../../Engine/Input ../../Engine/Math
+    ../../Engine/Network ../../Engine/Physics ../../Engine/Renderer ../../Engine/Resource 
     ../../Engine/Scene ../../Engine/Script ../../Engine/UI ../../ThirdParty/TinyXML
 )
 
 # Define target & libraries to link
 add_executable (${TARGET_NAME} WIN32 ${SOURCE_FILES})
 set_target_properties (${TARGET_NAME} PROPERTIES DEBUG_POSTFIX _d)
-target_link_libraries (${TARGET_NAME} Audio Common Engine Event Input Math Network Physics Renderer
-    Resource Scene TinyXML UI)
+target_link_libraries (${TARGET_NAME} Audio Common Engine Input Math Network Physics Renderer Resource
+    Scene TinyXML UI)
 enable_pch ()
 finalize_exe ()

Examples/NinjaSnowWar/Game.cpp

@@ -122,13 +122,7 @@ Game::Game() :
     subscribeToEvent(EVENT_CLIENTLEFTSCENE, EVENT_HANDLER(Game, handleClientLeft));
     subscribeToEvent(EVENT_PLAYERSPAWNED, EVENT_HANDLER(Game, handlePlayerSpawned));
     
-    // Register the inbuilt game events as local only; only EVENT_PLAYERSPAWNED is to be sent remote
-    static const std::string inbuiltEvents[] = {
-        "Create", "Remove", "Damage", "Heal", "Die", ""
-    };
-    
-    for (unsigned i = 0; inbuiltEvents[i].length(); ++i)
-        registerLocalOnlyEvent(inbuiltEvents[i]);
+    registerRemoteEvent(EVENT_PLAYERSPAWNED);
 }
 
 Game::~Game()

Examples/Urho3D/CMakeLists.txt

@@ -8,14 +8,14 @@ set (SOURCE_FILES ${CPP_FILES} ${H_FILES})
 
 # Include directories
 include_directories (
-    ../../Engine/Audio ../../Engine/Common ../../Engine/Engine ../../Engine/Event ../../Engine/Input
-    ../../Engine/Math ../../Engine/Network ../../Engine/Physics ../../Engine/Renderer ../../Engine/Resource
+    ../../Engine/Audio ../../Engine/Common ../../Engine/Engine ../../Engine/Input ../../Engine/Math
+    ../../Engine/Network ../../Engine/Physics ../../Engine/Renderer ../../Engine/Resource 
     ../../Engine/Scene ../../Engine/Script ../../Engine/UI ../../ThirdParty/AngelScript/include
 )
 
 # Define target & libraries to link
 add_executable (${TARGET_NAME} WIN32 ${SOURCE_FILES})
 set_target_properties (${TARGET_NAME} PROPERTIES DEBUG_POSTFIX _d)
-target_link_libraries (${TARGET_NAME} Audio Common Engine Event Input Math Network Physics Renderer
-    Resource Scene Script UI)
+target_link_libraries (${TARGET_NAME} Audio Common Engine Input Math Network Physics Renderer Resource
+    Scene Script UI)
 finalize_exe ()

Tools/AssetImporter/CMakeLists.txt

@@ -8,12 +8,12 @@ set (SOURCE_FILES ${CPP_FILES} ${H_FILES})
 
 # Include directories
 include_directories (
-    ../../Engine/Common ../../Engine/Event ../../Engine/Math ../../Engine/Physics ../../Engine/Renderer 
-    ../../Engine/Resource ../../Engine/Scene ../../ThirdParty/Assimp/include
+    ../../Engine/Common ../../Engine/Math ../../Engine/Physics ../../Engine/Renderer ../../Engine/Resource 
+    ../../Engine/Scene ../../ThirdParty/Assimp/include
 )
 
 # Define target & libraries to link
 add_executable (${TARGET_NAME} ${SOURCE_FILES})
-target_link_libraries (${TARGET_NAME} Assimp Common Event Math Physics Renderer Scene Resource)
+target_link_libraries (${TARGET_NAME} Assimp Common Math Physics Renderer Scene Resource)
 finalize_exe ()
 

Tools/OgreImporter/CMakeLists.txt

@@ -8,8 +8,8 @@ set (SOURCE_FILES ${CPP_FILES} ${H_FILES})
 
 # Include directories
 include_directories (
-    ../../Engine/Common ../../Engine/Event ../../Engine/Math ../../Engine/Physics ../../Engine/Renderer
-    ../../Engine/Resource ../../ThirdParty/TinyXML
+    ../../Engine/Common ../../Engine/Math ../../Engine/Physics ../../Engine/Renderer ../../Engine/Resource
+    ../../ThirdParty/TinyXML
 )
 
 # Define target & libraries to link