Core compile delta

Build/CMake/Modules/AtomicCommon.cmake

@@ -20,6 +20,8 @@
 # THE SOFTWARE.
 #
 
+# Urho compatibility
+add_definitions(-DATOMIC_IS_BUILDING=1 -DATOMIC_CXX11=1)
 
 set (CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -DATOMIC_DEBUG")
 set (CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DATOMIC_DEBUG")

Source/Atomic/Atomic2D/AnimatedSprite2D.cpp

@@ -27,18 +27,18 @@
 #include "../Resource/ResourceCache.h"
 #include "../Scene/Scene.h"
 #include "../Scene/SceneEvents.h"
-#include "../Urho2D/AnimatedSprite2D.h"
-#include "../Urho2D/AnimationSet2D.h"
-#include "../Urho2D/Sprite2D.h"
-#include "../Urho2D/SpriterInstance2D.h"
+#include "../Atomic2D/AnimatedSprite2D.h"
+#include "../Atomic2D/AnimationSet2D.h"
+#include "../Atomic2D/Sprite2D.h"
+#include "../Atomic2D/SpriterInstance2D.h"
 
 #include "../DebugNew.h"
 
-#ifdef URHO3D_SPINE
+#ifdef ATOMIC_SPINE
 #include <spine/spine.h>
 #endif 
 
-namespace Urho3D
+namespace Atomic
 {
 
 extern const char* URHO2D_CATEGORY;
@@ -54,7 +54,7 @@ const char* loopModeNames[] =
 
 AnimatedSprite2D::AnimatedSprite2D(Context* context) :
     StaticSprite2D(context),
-#ifdef URHO3D_SPINE
+#ifdef ATOMIC_SPINE
     skeleton_(0),
     animationStateData_(0),
     animationState_(0),
@@ -74,14 +74,14 @@ void AnimatedSprite2D::RegisterObject(Context* context)
 {
     context->RegisterFactory<AnimatedSprite2D>(URHO2D_CATEGORY);
 
-    URHO3D_COPY_BASE_ATTRIBUTES(StaticSprite2D);
-    URHO3D_REMOVE_ATTRIBUTE("Sprite");
-    URHO3D_ACCESSOR_ATTRIBUTE("Speed", GetSpeed, SetSpeed, float, 1.0f, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Entity", GetEntity, SetEntity, String, String::EMPTY, AM_DEFAULT);
-    URHO3D_MIXED_ACCESSOR_ATTRIBUTE("Animation Set", GetAnimationSetAttr, SetAnimationSetAttr, ResourceRef,
+    ATOMIC_COPY_BASE_ATTRIBUTES(StaticSprite2D);
+    ATOMIC_REMOVE_ATTRIBUTE("Sprite");
+    ATOMIC_ACCESSOR_ATTRIBUTE("Speed", GetSpeed, SetSpeed, float, 1.0f, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Entity", GetEntity, SetEntity, String, String::EMPTY, AM_DEFAULT);
+    ATOMIC_MIXED_ACCESSOR_ATTRIBUTE("Animation Set", GetAnimationSetAttr, SetAnimationSetAttr, ResourceRef,
         ResourceRef(AnimatedSprite2D::GetTypeStatic()), AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Animation", GetAnimation, SetAnimationAttr, String, String::EMPTY, AM_DEFAULT);
-    URHO3D_ENUM_ACCESSOR_ATTRIBUTE("Loop Mode", GetLoopMode, SetLoopMode, LoopMode2D, loopModeNames, LM_DEFAULT, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Animation", GetAnimation, SetAnimationAttr, String, String::EMPTY, AM_DEFAULT);
+    ATOMIC_ENUM_ACCESSOR_ATTRIBUTE("Loop Mode", GetLoopMode, SetLoopMode, LoopMode2D, loopModeNames, LM_DEFAULT, AM_DEFAULT);
 }
 
 void AnimatedSprite2D::OnSetEnabled()
@@ -94,7 +94,7 @@ void AnimatedSprite2D::OnSetEnabled()
     if (scene)
     {
         if (enabled)
-            SubscribeToEvent(scene, E_SCENEPOSTUPDATE, URHO3D_HANDLER(AnimatedSprite2D, HandleScenePostUpdate));
+            SubscribeToEvent(scene, E_SCENEPOSTUPDATE, ATOMIC_HANDLER(AnimatedSprite2D, HandleScenePostUpdate));
         else
             UnsubscribeFromEvent(scene, E_SCENEPOSTUPDATE);
     }
@@ -113,7 +113,7 @@ void AnimatedSprite2D::SetAnimationSet(AnimationSet2D* animationSet)
 
     SetSprite(animationSet_->GetSprite());
 
-#ifdef URHO3D_SPINE
+#ifdef ATOMIC_SPINE
     if (animationSet_->GetSkeletonData())
     {
         spSkeletonData* skeletonData = animationSet->GetSkeletonData();
@@ -159,7 +159,7 @@ void AnimatedSprite2D::SetEntity(const String& entity)
 
     entity_ = entity;
 
-#ifdef URHO3D_SPINE
+#ifdef ATOMIC_SPINE
     if (skeleton_)
         spSkeleton_setSkinByName(skeleton_, entity_.CString());
 #endif
@@ -175,7 +175,7 @@ void AnimatedSprite2D::SetAnimation(const String& name, LoopMode2D loopMode)
     if (!animationSet_ || !animationSet_->HasAnimation(animationName_))
         return;
 
-#ifdef URHO3D_SPINE
+#ifdef ATOMIC_SPINE
     if (skeleton_)
         SetSpineAnimation();
 #endif
@@ -217,9 +217,9 @@ void AnimatedSprite2D::OnSceneSet(Scene* scene)
     if (scene)
     {
         if (scene == node_)
-            URHO3D_LOGWARNING(GetTypeName() + " should not be created to the root scene node");
+            ATOMIC_LOGWARNING(GetTypeName() + " should not be created to the root scene node");
         if (IsEnabledEffective())
-            SubscribeToEvent(scene, E_SCENEPOSTUPDATE, URHO3D_HANDLER(AnimatedSprite2D, HandleScenePostUpdate));
+            SubscribeToEvent(scene, E_SCENEPOSTUPDATE, ATOMIC_HANDLER(AnimatedSprite2D, HandleScenePostUpdate));
     }
     else
         UnsubscribeFromEvent(E_SCENEPOSTUPDATE);
@@ -233,7 +233,7 @@ void AnimatedSprite2D::SetAnimationAttr(const String& name)
 
 void AnimatedSprite2D::UpdateSourceBatches()
 {
-#ifdef URHO3D_SPINE
+#ifdef ATOMIC_SPINE
     if (skeleton_ && animationState_)
         UpdateSourceBatchesSpine();
 #endif
@@ -252,7 +252,7 @@ void AnimatedSprite2D::HandleScenePostUpdate(StringHash eventType, VariantMap& e
 
 void AnimatedSprite2D::UpdateAnimation(float timeStep)
 {
-#ifdef URHO3D_SPINE
+#ifdef ATOMIC_SPINE
     if (skeleton_ && animationState_)
         UpdateSpineAnimation(timeStep);
 #endif
@@ -260,7 +260,7 @@ void AnimatedSprite2D::UpdateAnimation(float timeStep)
         UpdateSpriterAnimation(timeStep);
 }
 
-#ifdef URHO3D_SPINE
+#ifdef ATOMIC_SPINE
 void AnimatedSprite2D::SetSpineAnimation()
 {
     if (!animationStateData_)
@@ -268,7 +268,7 @@ void AnimatedSprite2D::SetSpineAnimation()
         animationStateData_ = spAnimationStateData_create(animationSet_->GetSkeletonData());
         if (!animationStateData_)
         {
-            URHO3D_LOGERROR("Create animation state data failed");
+            ATOMIC_LOGERROR("Create animation state data failed");
             return;
         }
     }
@@ -278,7 +278,7 @@ void AnimatedSprite2D::SetSpineAnimation()
         animationState_ = spAnimationState_create(animationStateData_);
         if (!animationState_)
         {
-            URHO3D_LOGERROR("Create animation state failed");
+            ATOMIC_LOGERROR("Create animation state failed");
             return;
         }
     }
@@ -414,13 +414,13 @@ void AnimatedSprite2D::SetSpriterAnimation()
 
     if (!spriterInstance_->SetEntity(entity_.CString()))
     {
-        URHO3D_LOGERROR("Set entity failed");
+        ATOMIC_LOGERROR("Set entity failed");
         return;
     }
 
     if (!spriterInstance_->SetAnimation(animationName_.CString(), (Spriter::LoopMode)loopMode_))
     {
-        URHO3D_LOGERROR("Set animation failed");
+        ATOMIC_LOGERROR("Set animation failed");
         return;
     }
 
@@ -508,7 +508,7 @@ void AnimatedSprite2D::UpdateSourceBatchesSpriter()
 
 void AnimatedSprite2D::Dispose()
 {
-#ifdef URHO3D_SPINE
+#ifdef ATOMIC_SPINE
     if (animationState_)
     {
         spAnimationState_dispose(animationState_);

Source/Atomic/Atomic2D/AnimatedSprite2D.h

@@ -22,9 +22,9 @@
 
 #pragma once
 
-#include "../Urho2D/StaticSprite2D.h"
+#include "../Atomic2D/StaticSprite2D.h"
 
-#ifdef URHO3D_SPINE
+#ifdef ATOMIC_SPINE
 struct spAnimationState;
 struct spAnimationStateData;
 struct spSkeleton;
@@ -41,7 +41,7 @@ enum LoopMode2D
     LM_FORCE_CLAMPED
 };
 
-namespace Urho3D
+namespace Atomic
 {
 
 namespace Spriter
@@ -52,9 +52,9 @@ namespace Spriter
 class AnimationSet2D;
 
 /// Animated sprite component, it uses to play animation created by Spine (http://www.esotericsoftware.com) and Spriter (http://www.brashmonkey.com/).
-class URHO3D_API AnimatedSprite2D : public StaticSprite2D
+class ATOMIC_API AnimatedSprite2D : public StaticSprite2D
 {
-    URHO3D_OBJECT(AnimatedSprite2D, StaticSprite2D);
+    ATOMIC_OBJECT(AnimatedSprite2D, StaticSprite2D);
 
 public:
     /// Construct.
@@ -105,7 +105,7 @@ protected:
     void HandleScenePostUpdate(StringHash eventType, VariantMap& eventData);
     /// Update animation.
     void UpdateAnimation(float timeStep);
-#ifdef URHO3D_SPINE
+#ifdef ATOMIC_SPINE
     /// Handle set spine animation.
     void SetSpineAnimation();
     /// Update spine animation.
@@ -133,7 +133,7 @@ protected:
     /// Loop mode.
     LoopMode2D loopMode_;
 
-#ifdef URHO3D_SPINE
+#ifdef ATOMIC_SPINE
     /// Skeleton.
     spSkeleton* skeleton_;
     /// Animation state data.

Source/Atomic/Atomic2D/AnimationSet2D.cpp

@@ -32,25 +32,25 @@
 #include "../Resource/Image.h"
 #include "../Resource/ResourceCache.h"
 #include "../Resource/XMLFile.h"
-#include "../Urho2D/AnimationSet2D.h"
-#include "../Urho2D/Sprite2D.h"
-#include "../Urho2D/SpriterData2D.h"
-#include "../Urho2D/SpriteSheet2D.h"
+#include "../Atomic2D/AnimationSet2D.h"
+#include "../Atomic2D/Sprite2D.h"
+#include "../Atomic2D/SpriterData2D.h"
+#include "../Atomic2D/SpriteSheet2D.h"
 
 #include "../DebugNew.h"
 
-#ifdef URHO3D_SPINE
+#ifdef ATOMIC_SPINE
 #include <spine/spine.h>
 #include <spine/extension.h>
 #endif
 
-#ifdef URHO3D_SPINE
+#ifdef ATOMIC_SPINE
 // Current animation set
-static Urho3D::AnimationSet2D* currentAnimationSet = 0;
+static Atomic::AnimationSet2D* currentAnimationSet = 0;
 
 void _spAtlasPage_createTexture(spAtlasPage* self, const char* path)
 {
-    using namespace Urho3D;
+    using namespace Atomic;
     if (!currentAnimationSet)
         return;
 
@@ -68,7 +68,7 @@ void _spAtlasPage_createTexture(spAtlasPage* self, const char* path)
 
 void _spAtlasPage_disposeTexture(spAtlasPage* self)
 {
-    using namespace Urho3D;
+    using namespace Atomic;
     Sprite2D* sprite = static_cast<Sprite2D*>(self->rendererObject);
     if (sprite)
         sprite->ReleaseRef();
@@ -78,7 +78,7 @@ void _spAtlasPage_disposeTexture(spAtlasPage* self)
 
 char* _spUtil_readFile(const char* path, int* length)
 {
-    using namespace Urho3D;
+    using namespace Atomic;
     
     if (!currentAnimationSet)
         return 0;
@@ -101,12 +101,12 @@ char* _spUtil_readFile(const char* path, int* length)
 }
 #endif
 
-namespace Urho3D
+namespace Atomic
 {
 
 AnimationSet2D::AnimationSet2D(Context* context) :
     Resource(context),
-#ifdef URHO3D_SPINE
+#ifdef ATOMIC_SPINE
     skeletonData_(0),
     atlas_(0),
 #endif
@@ -133,21 +133,21 @@ bool AnimationSet2D::BeginLoad(Deserializer& source)
         SetName(source.GetName());
 
     String extension = GetExtension(source.GetName());
-#ifdef URHO3D_SPINE
+#ifdef ATOMIC_SPINE
     if (extension == ".json")
         return BeginLoadSpine(source);
 #endif
     if (extension == ".scml")
         return BeginLoadSpriter(source);
 
-    URHO3D_LOGERROR("Unsupport animation set file: " + source.GetName());
+    ATOMIC_LOGERROR("Unsupport animation set file: " + source.GetName());
 
     return false;
 }
 
 bool AnimationSet2D::EndLoad()
 {
-#ifdef URHO3D_SPINE
+#ifdef ATOMIC_SPINE
     if (jsonData_)
         return EndLoadSpine();
 #endif
@@ -159,7 +159,7 @@ bool AnimationSet2D::EndLoad()
 
 unsigned AnimationSet2D::GetNumAnimations() const
 {
-#ifdef URHO3D_SPINE
+#ifdef ATOMIC_SPINE
     if (skeletonData_)
         return (unsigned)skeletonData_->animationsCount;
 #endif
@@ -173,7 +173,7 @@ String AnimationSet2D::GetAnimation(unsigned index) const
     if (index >= GetNumAnimations())
         return String::EMPTY;
 
-#ifdef URHO3D_SPINE
+#ifdef ATOMIC_SPINE
     if (skeletonData_)
         return skeletonData_->animations[index]->name;
 #endif
@@ -185,7 +185,7 @@ String AnimationSet2D::GetAnimation(unsigned index) const
 
 bool AnimationSet2D::HasAnimation(const String& animationName) const
 {
-#ifdef URHO3D_SPINE
+#ifdef ATOMIC_SPINE
     if (skeletonData_)
     {
         for (int i = 0; i < skeletonData_->animationsCount; ++i)
@@ -223,7 +223,7 @@ Sprite2D* AnimationSet2D::GetSpriterFileSprite(int folderId, int fileId) const
     return 0;
 }
 
-#ifdef URHO3D_SPINE
+#ifdef ATOMIC_SPINE
 bool AnimationSet2D::BeginLoadSpine(Deserializer& source)
 {
     if (GetName().Empty())
@@ -245,7 +245,7 @@ bool AnimationSet2D::EndLoadSpine()
     atlas_ = spAtlas_createFromFile(atlasFileName.CString(), 0);
     if (!atlas_)
     {
-        URHO3D_LOGERROR("Create spine atlas failed");
+        ATOMIC_LOGERROR("Create spine atlas failed");
         return false;
     }
 
@@ -259,7 +259,7 @@ bool AnimationSet2D::EndLoadSpine()
 
     if (numAtlasPages > 1)
     {
-        URHO3D_LOGERROR("Only one page is supported in Urho3D");
+        ATOMIC_LOGERROR("Only one page is supported in Urho3D");
         return false;
     }
 
@@ -268,7 +268,7 @@ bool AnimationSet2D::EndLoadSpine()
     spSkeletonJson* skeletonJson = spSkeletonJson_create(atlas_);
     if (!skeletonJson)
     {
-        URHO3D_LOGERROR("Create skeleton Json failed");
+        ATOMIC_LOGERROR("Create skeleton Json failed");
         return false;
     }
 
@@ -289,7 +289,7 @@ bool AnimationSet2D::BeginLoadSpriter(Deserializer& source)
     unsigned dataSize = source.GetSize();
     if (!dataSize && !source.GetName().Empty())
     {
-        URHO3D_LOGERROR("Zero sized XML data in " + source.GetName());
+        ATOMIC_LOGERROR("Zero sized XML data in " + source.GetName());
         return false;
     }
 
@@ -300,7 +300,7 @@ bool AnimationSet2D::BeginLoadSpriter(Deserializer& source)
     spriterData_ = new Spriter::SpriterData();
     if (!spriterData_->Load(buffer.Get(), dataSize))
     {
-        URHO3D_LOGERROR("Could not spriter data from " + source.GetName());
+        ATOMIC_LOGERROR("Could not spriter data from " + source.GetName());
         return false;
     }
 
@@ -370,7 +370,7 @@ bool AnimationSet2D::EndLoadSpriter()
                 SharedPtr<Sprite2D> sprite(spriteSheet_->GetSprite(GetFileName(file->name_)));
                 if (!sprite)
                 {
-                    URHO3D_LOGERROR("Could not load sprite " + file->name_);
+                    ATOMIC_LOGERROR("Could not load sprite " + file->name_);
                     return false;
                 }
 
@@ -413,17 +413,17 @@ bool AnimationSet2D::EndLoadSpriter()
                 SharedPtr<Image> image(cache->GetResource<Image>(imagePath));
                 if (!image)
                 {
-                    URHO3D_LOGERROR("Could not load image");
+                    ATOMIC_LOGERROR("Could not load image");
                     return false;
                 }
                 if (image->IsCompressed())
                 {
-                    URHO3D_LOGERROR("Compressed image is not support");
+                    ATOMIC_LOGERROR("Compressed image is not support");
                     return false;
                 }
                 if (image->GetComponents() != 4)
                 {
-                    URHO3D_LOGERROR("Only support image with 4 components");
+                    ATOMIC_LOGERROR("Only support image with 4 components");
                     return false;
                 }
 
@@ -448,7 +448,7 @@ bool AnimationSet2D::EndLoadSpriter()
                 Image* image = info.image_;
                 if (!allocator.Allocate(image->GetWidth() + 1, image->GetHeight() + 1, info.x, info.y))
                 {
-                    URHO3D_LOGERROR("Could not allocate area");
+                    ATOMIC_LOGERROR("Could not allocate area");
                     return false;
                 }
             }
@@ -511,7 +511,7 @@ bool AnimationSet2D::EndLoadSpriter()
 
 void AnimationSet2D::Dispose()
 {
-#ifdef URHO3D_SPINE
+#ifdef ATOMIC_SPINE
     if (skeletonData_)
     {
         spSkeletonData_dispose(skeletonData_);

Source/Atomic/Atomic2D/AnimationSet2D.h

@@ -25,13 +25,13 @@
 #include "../Container/ArrayPtr.h"
 #include "../Resource/Resource.h"
 
-#ifdef URHO3D_SPINE
+#ifdef ATOMIC_SPINE
 struct spAtlas;
 struct spSkeletonData;
 struct spAnimationStateData;
 #endif
 
-namespace Urho3D
+namespace Atomic
 {
 
 namespace Spriter
@@ -43,9 +43,9 @@ class Sprite2D;
 class SpriteSheet2D;
 
 /// Spriter animation set, it includes one or more animations, for more information please refer to http://www.esotericsoftware.com and http://www.brashmonkey.com/spriter.htm.
-class URHO3D_API AnimationSet2D : public Resource
+class ATOMIC_API AnimationSet2D : public Resource
 {
-    URHO3D_OBJECT(AnimationSet2D, Resource);
+    ATOMIC_OBJECT(AnimationSet2D, Resource);
 
 public:
     /// Construct.
@@ -70,7 +70,7 @@ public:
     /// Return sprite.
     Sprite2D* GetSprite() const;
 
-#ifdef URHO3D_SPINE
+#ifdef ATOMIC_SPINE
     /// Return spine skeleton data.
     spSkeletonData* GetSkeletonData() const { return skeletonData_; }
 #endif
@@ -83,7 +83,7 @@ public:
 private:
     /// Return sprite by hash.
     Sprite2D* GetSpriterFileSprite(const StringHash& hash) const;
-#ifdef URHO3D_SPINE
+#ifdef ATOMIC_SPINE
     /// Begin load spine.
     bool BeginLoadSpine(Deserializer& source);
     /// Finish load spine.
@@ -99,7 +99,7 @@ private:
     /// Spine sprite.
     SharedPtr<Sprite2D> sprite_;
     
-#ifdef URHO3D_SPINE
+#ifdef ATOMIC_SPINE
     /// Spine json data.
     SharedArrayPtr<char> jsonData_;
     /// Spine skeleton data.

Source/Atomic/Atomic2D/Atomic2D.cpp

@@ -22,44 +22,44 @@
 #include "../Precompiled.h"
 
 #include "../Core/Context.h"
-#include "../Urho2D/AnimatedSprite2D.h"
-#include "../Urho2D/AnimationSet2D.h"
-#include "../Urho2D/CollisionBox2D.h"
-#include "../Urho2D/CollisionChain2D.h"
-#include "../Urho2D/CollisionCircle2D.h"
-#include "../Urho2D/CollisionEdge2D.h"
-#include "../Urho2D/CollisionPolygon2D.h"
-#include "../Urho2D/Constraint2D.h"
-#include "../Urho2D/ConstraintDistance2D.h"
-#include "../Urho2D/ConstraintFriction2D.h"
-#include "../Urho2D/ConstraintGear2D.h"
-#include "../Urho2D/ConstraintMotor2D.h"
-#include "../Urho2D/ConstraintMouse2D.h"
-#include "../Urho2D/ConstraintPrismatic2D.h"
-#include "../Urho2D/ConstraintPulley2D.h"
-#include "../Urho2D/ConstraintRevolute2D.h"
-#include "../Urho2D/ConstraintRope2D.h"
-#include "../Urho2D/ConstraintWeld2D.h"
-#include "../Urho2D/ConstraintWheel2D.h"
-#include "../Urho2D/ParticleEffect2D.h"
-#include "../Urho2D/ParticleEmitter2D.h"
-#include "../Urho2D/PhysicsWorld2D.h"
-#include "../Urho2D/Renderer2D.h"
-#include "../Urho2D/RigidBody2D.h"
-#include "../Urho2D/Sprite2D.h"
-#include "../Urho2D/SpriteSheet2D.h"
-#include "../Urho2D/TileMap2D.h"
-#include "../Urho2D/TileMapLayer2D.h"
-#include "../Urho2D/TmxFile2D.h"
+#include "../Atomic2D/AnimatedSprite2D.h"
+#include "../Atomic2D/AnimationSet2D.h"
+#include "../Atomic2D/CollisionBox2D.h"
+#include "../Atomic2D/CollisionChain2D.h"
+#include "../Atomic2D/CollisionCircle2D.h"
+#include "../Atomic2D/CollisionEdge2D.h"
+#include "../Atomic2D/CollisionPolygon2D.h"
+#include "../Atomic2D/Constraint2D.h"
+#include "../Atomic2D/ConstraintDistance2D.h"
+#include "../Atomic2D/ConstraintFriction2D.h"
+#include "../Atomic2D/ConstraintGear2D.h"
+#include "../Atomic2D/ConstraintMotor2D.h"
+#include "../Atomic2D/ConstraintMouse2D.h"
+#include "../Atomic2D/ConstraintPrismatic2D.h"
+#include "../Atomic2D/ConstraintPulley2D.h"
+#include "../Atomic2D/ConstraintRevolute2D.h"
+#include "../Atomic2D/ConstraintRope2D.h"
+#include "../Atomic2D/ConstraintWeld2D.h"
+#include "../Atomic2D/ConstraintWheel2D.h"
+#include "../Atomic2D/ParticleEffect2D.h"
+#include "../Atomic2D/ParticleEmitter2D.h"
+#include "../Atomic2D/PhysicsWorld2D.h"
+#include "../Atomic2D/Renderer2D.h"
+#include "../Atomic2D/RigidBody2D.h"
+#include "../Atomic2D/Sprite2D.h"
+#include "../Atomic2D/SpriteSheet2D.h"
+#include "../Atomic2D/TileMap2D.h"
+#include "../Atomic2D/TileMapLayer2D.h"
+#include "../Atomic2D/TmxFile2D.h"
 
 #include "../DebugNew.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
-const char* URHO2D_CATEGORY = "Urho2D";
+const char* URHO2D_CATEGORY = "Atomic2D";
 
-void RegisterUrho2DLibrary(Context* context)
+void RegisterAtomic2DLibrary(Context* context)
 {
     Renderer2D::RegisterObject(context);
 

Source/Atomic/Atomic2D/Atomic2D.h

@@ -22,10 +22,10 @@
 
 #pragma once
 
-namespace Urho3D
+namespace Atomic
 {
 
-/// Register Urho2D library objects.
-void URHO3D_API RegisterUrho2DLibrary(Context* context);
+/// Register Atomic2D library objects.
+void ATOMIC_API RegisterAtomic2DLibrary(Context* context);
 
 }

Source/Atomic/Atomic2D/CollisionBox2D.cpp

@@ -23,12 +23,12 @@
 #include "../Precompiled.h"
 
 #include "../Core/Context.h"
-#include "../Urho2D/CollisionBox2D.h"
-#include "../Urho2D/PhysicsUtils2D.h"
+#include "../Atomic2D/CollisionBox2D.h"
+#include "../Atomic2D/PhysicsUtils2D.h"
 
 #include "../DebugNew.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 extern const char* URHO2D_CATEGORY;
@@ -54,11 +54,11 @@ void CollisionBox2D::RegisterObject(Context* context)
 {
     context->RegisterFactory<CollisionBox2D>(URHO2D_CATEGORY);
 
-    URHO3D_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Size", GetSize, SetSize, Vector2, DEFAULT_BOX_SIZE, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Center", GetCenter, SetCenter, Vector2, Vector2::ZERO, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Angle", GetAngle, SetAngle, float, 0.0f, AM_DEFAULT);
-    URHO3D_COPY_BASE_ATTRIBUTES(CollisionShape2D);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Size", GetSize, SetSize, Vector2, DEFAULT_BOX_SIZE, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Center", GetCenter, SetCenter, Vector2, Vector2::ZERO, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Angle", GetAngle, SetAngle, float, 0.0f, AM_DEFAULT);
+    ATOMIC_COPY_BASE_ATTRIBUTES(CollisionShape2D);
 }
 
 void CollisionBox2D::SetSize(const Vector2& size)

Source/Atomic/Atomic2D/CollisionBox2D.h

@@ -22,15 +22,15 @@
 
 #pragma once
 
-#include "../Urho2D/CollisionShape2D.h"
+#include "../Atomic2D/CollisionShape2D.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 /// 2D box collision component.
-class URHO3D_API CollisionBox2D : public CollisionShape2D
+class ATOMIC_API CollisionBox2D : public CollisionShape2D
 {
-    URHO3D_OBJECT(CollisionBox2D, CollisionShape2D);
+    ATOMIC_OBJECT(CollisionBox2D, CollisionShape2D);
 
 public:
     /// Construct.

Source/Atomic/Atomic2D/CollisionChain2D.cpp

@@ -25,12 +25,12 @@
 #include "../Core/Context.h"
 #include "../IO/MemoryBuffer.h"
 #include "../IO/VectorBuffer.h"
-#include "../Urho2D/CollisionChain2D.h"
-#include "../Urho2D/PhysicsUtils2D.h"
+#include "../Atomic2D/CollisionChain2D.h"
+#include "../Atomic2D/PhysicsUtils2D.h"
 
 #include "../DebugNew.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 extern const char* URHO2D_CATEGORY;
@@ -50,10 +50,10 @@ void CollisionChain2D::RegisterObject(Context* context)
 {
     context->RegisterFactory<CollisionChain2D>(URHO2D_CATEGORY);
 
-    URHO3D_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Loop", GetLoop, SetLoop, bool, false, AM_DEFAULT);
-    URHO3D_COPY_BASE_ATTRIBUTES(CollisionShape2D);
-    URHO3D_MIXED_ACCESSOR_ATTRIBUTE("Vertices", GetVerticesAttr, SetVerticesAttr, PODVector<unsigned char>, Variant::emptyBuffer, AM_FILE);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Loop", GetLoop, SetLoop, bool, false, AM_DEFAULT);
+    ATOMIC_COPY_BASE_ATTRIBUTES(CollisionShape2D);
+    ATOMIC_MIXED_ACCESSOR_ATTRIBUTE("Vertices", GetVerticesAttr, SetVerticesAttr, PODVector<unsigned char>, Variant::emptyBuffer, AM_FILE);
 }
 
 void CollisionChain2D::SetLoop(bool loop)

Source/Atomic/Atomic2D/CollisionChain2D.h

@@ -22,14 +22,14 @@
 
 #pragma once
 
-#include "../Urho2D/CollisionShape2D.h"
+#include "../Atomic2D/CollisionShape2D.h"
 
-namespace Urho3D
+namespace Atomic
 {
 /// 2D chain collision component.
-class URHO3D_API CollisionChain2D : public CollisionShape2D
+class ATOMIC_API CollisionChain2D : public CollisionShape2D
 {
-    URHO3D_OBJECT(CollisionChain2D, CollisionShape2D);
+    ATOMIC_OBJECT(CollisionChain2D, CollisionShape2D);
 
 public:
     /// Construct.

Source/Atomic/Atomic2D/CollisionCircle2D.cpp

@@ -23,12 +23,12 @@
 #include "../Precompiled.h"
 
 #include "../Core/Context.h"
-#include "../Urho2D/CollisionCircle2D.h"
-#include "../Urho2D/PhysicsUtils2D.h"
+#include "../Atomic2D/CollisionCircle2D.h"
+#include "../Atomic2D/PhysicsUtils2D.h"
 
 #include "../DebugNew.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 extern const char* URHO2D_CATEGORY;
@@ -51,10 +51,10 @@ void CollisionCircle2D::RegisterObject(Context* context)
 {
     context->RegisterFactory<CollisionCircle2D>(URHO2D_CATEGORY);
 
-    URHO3D_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Radius", GetRadius, SetRadius, float, DEFAULT_CLRCLE_RADIUS, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Center", GetCenter, SetCenter, Vector2, Vector2::ZERO, AM_DEFAULT);
-    URHO3D_COPY_BASE_ATTRIBUTES(CollisionShape2D);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Radius", GetRadius, SetRadius, float, DEFAULT_CLRCLE_RADIUS, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Center", GetCenter, SetCenter, Vector2, Vector2::ZERO, AM_DEFAULT);
+    ATOMIC_COPY_BASE_ATTRIBUTES(CollisionShape2D);
 }
 
 void CollisionCircle2D::SetRadius(float radius)

Source/Atomic/Atomic2D/CollisionCircle2D.h

@@ -22,15 +22,15 @@
 
 #pragma once
 
-#include "../Urho2D/CollisionShape2D.h"
+#include "../Atomic2D/CollisionShape2D.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 /// 2D circle collision component.
-class URHO3D_API CollisionCircle2D : public CollisionShape2D
+class ATOMIC_API CollisionCircle2D : public CollisionShape2D
 {
-    URHO3D_OBJECT(CollisionCircle2D, CollisionShape2D);
+    ATOMIC_OBJECT(CollisionCircle2D, CollisionShape2D);
 
 public:
     /// Construct.

Source/Atomic/Atomic2D/CollisionEdge2D.cpp

@@ -23,12 +23,12 @@
 #include "../Precompiled.h"
 
 #include "../Core/Context.h"
-#include "../Urho2D/CollisionEdge2D.h"
-#include "../Urho2D/PhysicsUtils2D.h"
+#include "../Atomic2D/CollisionEdge2D.h"
+#include "../Atomic2D/PhysicsUtils2D.h"
 
 #include "../DebugNew.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 extern const char* URHO2D_CATEGORY;
@@ -54,10 +54,10 @@ void CollisionEdge2D::RegisterObject(Context* context)
 {
     context->RegisterFactory<CollisionEdge2D>(URHO2D_CATEGORY);
 
-    URHO3D_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Vertex 1", GetVertex1, SetVertex1, Vector2, DEFAULT_VERTEX1, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Vertex 2", GetVertex2, SetVertex2, Vector2, DEFAULT_VERTEX2, AM_DEFAULT);
-    URHO3D_COPY_BASE_ATTRIBUTES(CollisionShape2D);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Vertex 1", GetVertex1, SetVertex1, Vector2, DEFAULT_VERTEX1, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Vertex 2", GetVertex2, SetVertex2, Vector2, DEFAULT_VERTEX2, AM_DEFAULT);
+    ATOMIC_COPY_BASE_ATTRIBUTES(CollisionShape2D);
 }
 
 void CollisionEdge2D::SetVertex1(const Vector2& vertex)

Source/Atomic/Atomic2D/CollisionEdge2D.h

@@ -22,15 +22,15 @@
 
 #pragma once
 
-#include "../Urho2D/CollisionShape2D.h"
+#include "../Atomic2D/CollisionShape2D.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 /// 2D edge collision component.
-class URHO3D_API CollisionEdge2D : public CollisionShape2D
+class ATOMIC_API CollisionEdge2D : public CollisionShape2D
 {
-    URHO3D_OBJECT(CollisionEdge2D, CollisionShape2D);
+    ATOMIC_OBJECT(CollisionEdge2D, CollisionShape2D);
 
 public:
     /// Construct.

Source/Atomic/Atomic2D/CollisionPolygon2D.cpp

@@ -25,12 +25,12 @@
 #include "../Core/Context.h"
 #include "../IO/MemoryBuffer.h"
 #include "../IO/VectorBuffer.h"
-#include "../Urho2D/CollisionPolygon2D.h"
-#include "../Urho2D/PhysicsUtils2D.h"
+#include "../Atomic2D/CollisionPolygon2D.h"
+#include "../Atomic2D/PhysicsUtils2D.h"
 
 #include "../DebugNew.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 extern const char* URHO2D_CATEGORY;
@@ -49,9 +49,9 @@ void CollisionPolygon2D::RegisterObject(Context* context)
 {
     context->RegisterFactory<CollisionPolygon2D>(URHO2D_CATEGORY);
 
-    URHO3D_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
-    URHO3D_COPY_BASE_ATTRIBUTES(CollisionShape2D);
-    URHO3D_MIXED_ACCESSOR_ATTRIBUTE("Vertices", GetVerticesAttr, SetVerticesAttr, PODVector<unsigned char>, Variant::emptyBuffer, AM_FILE);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
+    ATOMIC_COPY_BASE_ATTRIBUTES(CollisionShape2D);
+    ATOMIC_MIXED_ACCESSOR_ATTRIBUTE("Vertices", GetVerticesAttr, SetVerticesAttr, PODVector<unsigned char>, Variant::emptyBuffer, AM_FILE);
 }
 
 void CollisionPolygon2D::SetVertexCount(unsigned count)

Source/Atomic/Atomic2D/CollisionPolygon2D.h

@@ -22,15 +22,15 @@
 
 #pragma once
 
-#include "../Urho2D/CollisionShape2D.h"
+#include "../Atomic2D/CollisionShape2D.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 /// 2D polygon collision component.
-class URHO3D_API CollisionPolygon2D : public CollisionShape2D
+class ATOMIC_API CollisionPolygon2D : public CollisionShape2D
 {
-    URHO3D_OBJECT(CollisionPolygon2D, CollisionShape2D);
+    ATOMIC_OBJECT(CollisionPolygon2D, CollisionShape2D);
 
 public:
     /// Construct.

Source/Atomic/Atomic2D/CollisionShape2D.cpp

@@ -26,13 +26,13 @@
 #include "../IO/Log.h"
 #include "../Scene/Node.h"
 #include "../Scene/Scene.h"
-#include "../Urho2D/CollisionShape2D.h"
-#include "../Urho2D/PhysicsUtils2D.h"
-#include "../Urho2D/RigidBody2D.h"
+#include "../Atomic2D/CollisionShape2D.h"
+#include "../Atomic2D/PhysicsUtils2D.h"
+#include "../Atomic2D/RigidBody2D.h"
 
 #include "../DebugNew.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 CollisionShape2D::CollisionShape2D(Context* context) :
@@ -53,13 +53,13 @@ CollisionShape2D::~CollisionShape2D()
 
 void CollisionShape2D::RegisterObject(Context* context)
 {
-    URHO3D_ACCESSOR_ATTRIBUTE("Trigger", IsTrigger, SetTrigger, bool, false, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Category Bits", GetCategoryBits, SetCategoryBits, int, 0, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Mask Bits", GetMaskBits, SetMaskBits, int, 0, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Group Index", GetGroupIndex, SetGroupIndex, int, 0, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Density", GetDensity, SetDensity, float, 0.0f, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Friction", GetFriction, SetFriction, float, 0.2f, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Restitution", GetRestitution, SetRestitution, float, 0.0f, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Trigger", IsTrigger, SetTrigger, bool, false, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Category Bits", GetCategoryBits, SetCategoryBits, int, 0, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Mask Bits", GetMaskBits, SetMaskBits, int, 0, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Group Index", GetGroupIndex, SetGroupIndex, int, 0, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Density", GetDensity, SetDensity, float, 0.0f, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Friction", GetFriction, SetFriction, float, 0.2f, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Restitution", GetRestitution, SetRestitution, float, 0.0f, AM_DEFAULT);
 }
 
 void CollisionShape2D::OnSetEnabled()

Source/Atomic/Atomic2D/CollisionShape2D.h

@@ -26,15 +26,15 @@
 
 #include <Box2D/Box2D.h>
 
-namespace Urho3D
+namespace Atomic
 {
 
 class RigidBody2D;
 
 /// 2D collision shape component.
-class URHO3D_API CollisionShape2D : public Component
+class ATOMIC_API CollisionShape2D : public Component
 {
-    URHO3D_OBJECT(CollisionShape2D, Component);
+    ATOMIC_OBJECT(CollisionShape2D, Component);
 
 public:
     /// Construct.

Source/Atomic/Atomic2D/Constraint2D.cpp

@@ -26,14 +26,14 @@
 #include "../IO/Log.h"
 #include "../Scene/Node.h"
 #include "../Scene/Scene.h"
-#include "../Urho2D/Constraint2D.h"
-#include "../Urho2D/PhysicsUtils2D.h"
-#include "../Urho2D/RigidBody2D.h"
-#include "../Urho2D/PhysicsWorld2D.h"
+#include "../Atomic2D/Constraint2D.h"
+#include "../Atomic2D/PhysicsUtils2D.h"
+#include "../Atomic2D/RigidBody2D.h"
+#include "../Atomic2D/PhysicsWorld2D.h"
 
 #include "../DebugNew.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 extern const char* URHO2D_CATEGORY;
@@ -59,7 +59,7 @@ Constraint2D::~Constraint2D()
 
 void Constraint2D::RegisterObject(Context* context)
 {
-    URHO3D_ACCESSOR_ATTRIBUTE("Collide Connected", GetCollideConnected, SetCollideConnected, bool, false, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Collide Connected", GetCollideConnected, SetCollideConnected, bool, false, AM_DEFAULT);
 }
 
 void Constraint2D::OnSetEnabled()
@@ -130,7 +130,7 @@ void Constraint2D::OnNodeSet(Node* node)
         ownerBody_ = node->GetComponent<RigidBody2D>();
         if (!ownerBody_)
         {
-            URHO3D_LOGERROR("No right body component in node, can not create constraint");
+            ATOMIC_LOGERROR("No right body component in node, can not create constraint");
             return;
         }
     }

Source/Atomic/Atomic2D/Constraint2D.h

@@ -26,16 +26,16 @@
 
 #include <Box2D/Box2D.h>
 
-namespace Urho3D
+namespace Atomic
 {
 
 class RigidBody2D;
 class PhysicsWorld2D;
 
 /// 2D physics constraint component.
-class URHO3D_API Constraint2D : public Component
+class ATOMIC_API Constraint2D : public Component
 {
-    URHO3D_OBJECT(Constraint2D, Component);
+    ATOMIC_OBJECT(Constraint2D, Component);
 
 public:
     /// Construct.

Source/Atomic/Atomic2D/ConstraintDistance2D.cpp

@@ -23,13 +23,13 @@
 #include "../Precompiled.h"
 
 #include "../Core/Context.h"
-#include "../Urho2D/ConstraintDistance2D.h"
-#include "../Urho2D/PhysicsUtils2D.h"
-#include "../Urho2D/RigidBody2D.h"
+#include "../Atomic2D/ConstraintDistance2D.h"
+#include "../Atomic2D/PhysicsUtils2D.h"
+#include "../Atomic2D/RigidBody2D.h"
 
 #include "../DebugNew.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 extern const char* URHO2D_CATEGORY;
@@ -50,12 +50,12 @@ void ConstraintDistance2D::RegisterObject(Context* context)
 {
     context->RegisterFactory<ConstraintDistance2D>(URHO2D_CATEGORY);
 
-    URHO3D_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Owner Body Anchor", GetOwnerBodyAnchor, SetOwnerBodyAnchor, Vector2, Vector2::ZERO, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Other Body Anchor", GetOtherBodyAnchor, SetOtherBodyAnchor, Vector2, Vector2::ZERO, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Frequency Hz", GetFrequencyHz, SetFrequencyHz, float, 0.0f, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Damping Ratio", GetDampingRatio, SetDampingRatio, float, 0.0f, AM_DEFAULT);
-    URHO3D_COPY_BASE_ATTRIBUTES(Constraint2D);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Owner Body Anchor", GetOwnerBodyAnchor, SetOwnerBodyAnchor, Vector2, Vector2::ZERO, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Other Body Anchor", GetOtherBodyAnchor, SetOtherBodyAnchor, Vector2, Vector2::ZERO, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Frequency Hz", GetFrequencyHz, SetFrequencyHz, float, 0.0f, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Damping Ratio", GetDampingRatio, SetDampingRatio, float, 0.0f, AM_DEFAULT);
+    ATOMIC_COPY_BASE_ATTRIBUTES(Constraint2D);
 }
 
 void ConstraintDistance2D::SetOwnerBodyAnchor(const Vector2& anchor)

Source/Atomic/Atomic2D/ConstraintDistance2D.h

@@ -22,15 +22,15 @@
 
 #pragma once
 
-#include "../Urho2D/Constraint2D.h"
+#include "../Atomic2D/Constraint2D.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 /// 2D distance constraint component.
-class URHO3D_API ConstraintDistance2D : public Constraint2D
+class ATOMIC_API ConstraintDistance2D : public Constraint2D
 {
-    URHO3D_OBJECT(ConstraintDistance2D, Constraint2D);
+    ATOMIC_OBJECT(ConstraintDistance2D, Constraint2D);
 
 public:
     /// Construct.

Source/Atomic/Atomic2D/ConstraintFriction2D.cpp

@@ -23,13 +23,13 @@
 #include "../Precompiled.h"
 
 #include "../Core/Context.h"
-#include "../Urho2D/ConstraintFriction2D.h"
-#include "../Urho2D/PhysicsUtils2D.h"
-#include "../Urho2D/RigidBody2D.h"
+#include "../Atomic2D/ConstraintFriction2D.h"
+#include "../Atomic2D/PhysicsUtils2D.h"
+#include "../Atomic2D/RigidBody2D.h"
 
 #include "../DebugNew.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 extern const char* URHO2D_CATEGORY;
@@ -49,11 +49,11 @@ void ConstraintFriction2D::RegisterObject(Context* context)
 {
     context->RegisterFactory<ConstraintFriction2D>(URHO2D_CATEGORY);
 
-    URHO3D_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Anchor", GetAnchor, SetAnchor, Vector2, Vector2::ZERO, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Max Force", GetMaxForce, SetMaxForce, float, 0.0f, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Max Torque", GetMaxTorque, SetMaxTorque, float, 0.0f, AM_DEFAULT);
-    URHO3D_COPY_BASE_ATTRIBUTES(Constraint2D);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Anchor", GetAnchor, SetAnchor, Vector2, Vector2::ZERO, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Max Force", GetMaxForce, SetMaxForce, float, 0.0f, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Max Torque", GetMaxTorque, SetMaxTorque, float, 0.0f, AM_DEFAULT);
+    ATOMIC_COPY_BASE_ATTRIBUTES(Constraint2D);
 }
 
 void ConstraintFriction2D::SetAnchor(const Vector2& anchor)

Source/Atomic/Atomic2D/ConstraintFriction2D.h

@@ -22,15 +22,15 @@
 
 #pragma once
 
-#include "../Urho2D/Constraint2D.h"
+#include "../Atomic2D/Constraint2D.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 /// 2D friction constraint component.
-class URHO3D_API ConstraintFriction2D : public Constraint2D
+class ATOMIC_API ConstraintFriction2D : public Constraint2D
 {
-    URHO3D_OBJECT(ConstraintFriction2D, Constraint2D);
+    ATOMIC_OBJECT(ConstraintFriction2D, Constraint2D);
 
 public:
     /// Construct.

Source/Atomic/Atomic2D/ConstraintGear2D.cpp

@@ -23,13 +23,13 @@
 #include "../Precompiled.h"
 
 #include "../Core/Context.h"
-#include "../Urho2D/ConstraintGear2D.h"
-#include "../Urho2D/PhysicsUtils2D.h"
-#include "../Urho2D/RigidBody2D.h"
+#include "../Atomic2D/ConstraintGear2D.h"
+#include "../Atomic2D/PhysicsUtils2D.h"
+#include "../Atomic2D/RigidBody2D.h"
 
 #include "../DebugNew.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 extern const char* URHO2D_CATEGORY;
@@ -47,9 +47,9 @@ void ConstraintGear2D::RegisterObject(Context* context)
 {
     context->RegisterFactory<ConstraintGear2D>(URHO2D_CATEGORY);
 
-    URHO3D_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Ratio", GetRatio, SetRatio, float, 0.0f, AM_DEFAULT);
-    URHO3D_COPY_BASE_ATTRIBUTES(Constraint2D);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Ratio", GetRatio, SetRatio, float, 0.0f, AM_DEFAULT);
+    ATOMIC_COPY_BASE_ATTRIBUTES(Constraint2D);
 }
 
 void ConstraintGear2D::SetOwnerConstraint(Constraint2D* constraint)

Source/Atomic/Atomic2D/ConstraintGear2D.h

@@ -22,15 +22,15 @@
 
 #pragma once
 
-#include "../Urho2D/Constraint2D.h"
+#include "../Atomic2D/Constraint2D.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 /// 2D gear constraint component.
-class URHO3D_API ConstraintGear2D : public Constraint2D
+class ATOMIC_API ConstraintGear2D : public Constraint2D
 {
-    URHO3D_OBJECT(ConstraintGear2D, Constraint2D);
+    ATOMIC_OBJECT(ConstraintGear2D, Constraint2D);
 
 public:
     /// Construct.

Source/Atomic/Atomic2D/ConstraintMotor2D.cpp

@@ -23,13 +23,13 @@
 #include "../Precompiled.h"
 
 #include "../Core/Context.h"
-#include "../Urho2D/ConstraintMotor2D.h"
-#include "../Urho2D/PhysicsUtils2D.h"
-#include "../Urho2D/RigidBody2D.h"
+#include "../Atomic2D/ConstraintMotor2D.h"
+#include "../Atomic2D/PhysicsUtils2D.h"
+#include "../Atomic2D/RigidBody2D.h"
 
 #include "../DebugNew.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 extern const char* URHO2D_CATEGORY;
@@ -49,13 +49,13 @@ void ConstraintMotor2D::RegisterObject(Context* context)
 {
     context->RegisterFactory<ConstraintMotor2D>(URHO2D_CATEGORY);
 
-    URHO3D_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Linear Offset", GetLinearOffset, SetLinearOffset, Vector2, Vector2::ZERO, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Angular Offset", GetAngularOffset, SetAngularOffset, float, 0.0f, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Max Force", GetMaxForce, SetMaxForce, float, 1.0f, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Max Torque", GetMaxTorque, SetMaxTorque, float, 1.0f, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Correction Factor", GetCorrectionFactor, SetCorrectionFactor, float, 0.3f, AM_DEFAULT);
-    URHO3D_COPY_BASE_ATTRIBUTES(Constraint2D);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Linear Offset", GetLinearOffset, SetLinearOffset, Vector2, Vector2::ZERO, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Angular Offset", GetAngularOffset, SetAngularOffset, float, 0.0f, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Max Force", GetMaxForce, SetMaxForce, float, 1.0f, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Max Torque", GetMaxTorque, SetMaxTorque, float, 1.0f, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Correction Factor", GetCorrectionFactor, SetCorrectionFactor, float, 0.3f, AM_DEFAULT);
+    ATOMIC_COPY_BASE_ATTRIBUTES(Constraint2D);
 }
 
 void ConstraintMotor2D::SetLinearOffset(const Vector2& linearOffset)

Source/Atomic/Atomic2D/ConstraintMotor2D.h

@@ -22,15 +22,15 @@
 
 #pragma once
 
-#include "../Urho2D/Constraint2D.h"
+#include "../Atomic2D/Constraint2D.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 /// 2D motor constraint component.
-class URHO3D_API ConstraintMotor2D : public Constraint2D
+class ATOMIC_API ConstraintMotor2D : public Constraint2D
 {
-    URHO3D_OBJECT(ConstraintMotor2D, Constraint2D);
+    ATOMIC_OBJECT(ConstraintMotor2D, Constraint2D);
 
 public:
     /// Construct.

Source/Atomic/Atomic2D/ConstraintMouse2D.cpp

@@ -23,13 +23,13 @@
 #include "../Precompiled.h"
 
 #include "../Core/Context.h"
-#include "../Urho2D/ConstraintMouse2D.h"
-#include "../Urho2D/PhysicsUtils2D.h"
-#include "../Urho2D/RigidBody2D.h"
+#include "../Atomic2D/ConstraintMouse2D.h"
+#include "../Atomic2D/PhysicsUtils2D.h"
+#include "../Atomic2D/RigidBody2D.h"
 
 #include "../DebugNew.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 extern const char* URHO2D_CATEGORY;
@@ -49,12 +49,12 @@ void ConstraintMouse2D::RegisterObject(Context* context)
 {
     context->RegisterFactory<ConstraintMouse2D>(URHO2D_CATEGORY);
 
-    URHO3D_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Target", GetTarget, SetTarget, Vector2, Vector2::ZERO, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Max Force", GetMaxForce, SetMaxForce, float, 0.0f, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Frequency Hz", GetFrequencyHz, SetFrequencyHz, float, 5.0f, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Damping Ratio", GetDampingRatio, SetDampingRatio, float, 0.7f, AM_DEFAULT);
-    URHO3D_COPY_BASE_ATTRIBUTES(Constraint2D);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Target", GetTarget, SetTarget, Vector2, Vector2::ZERO, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Max Force", GetMaxForce, SetMaxForce, float, 0.0f, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Frequency Hz", GetFrequencyHz, SetFrequencyHz, float, 5.0f, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Damping Ratio", GetDampingRatio, SetDampingRatio, float, 0.7f, AM_DEFAULT);
+    ATOMIC_COPY_BASE_ATTRIBUTES(Constraint2D);
 }
 
 void ConstraintMouse2D::SetTarget(const Vector2& target)

Source/Atomic/Atomic2D/ConstraintMouse2D.h

@@ -22,15 +22,15 @@
 
 #pragma once
 
-#include "../Urho2D/Constraint2D.h"
+#include "../Atomic2D/Constraint2D.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 /// 2D mouse constraint component.
-class URHO3D_API ConstraintMouse2D : public Constraint2D
+class ATOMIC_API ConstraintMouse2D : public Constraint2D
 {
-    URHO3D_OBJECT(ConstraintMouse2D, Constraint2D);
+    ATOMIC_OBJECT(ConstraintMouse2D, Constraint2D);
 
 public:
     /// Construct.

Source/Atomic/Atomic2D/ConstraintPrismatic2D.cpp

@@ -23,13 +23,13 @@
 #include "../Precompiled.h"
 
 #include "../Core/Context.h"
-#include "../Urho2D/ConstraintPrismatic2D.h"
-#include "../Urho2D/PhysicsUtils2D.h"
-#include "../Urho2D/RigidBody2D.h"
+#include "../Atomic2D/ConstraintPrismatic2D.h"
+#include "../Atomic2D/PhysicsUtils2D.h"
+#include "../Atomic2D/RigidBody2D.h"
 
 #include "../DebugNew.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 extern const char* URHO2D_CATEGORY;
@@ -49,16 +49,16 @@ void ConstraintPrismatic2D::RegisterObject(Context* context)
 {
     context->RegisterFactory<ConstraintPrismatic2D>(URHO2D_CATEGORY);
 
-    URHO3D_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Anchor", GetAnchor, SetAnchor, Vector2, Vector2::ZERO, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Axis", GetAxis, SetAxis, Vector2, Vector2::RIGHT, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Enable Limit", GetEnableLimit, SetEnableLimit, bool, false, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Lower translation", GetLowerTranslation, SetLowerTranslation, float, 0.0f, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Upper translation", GetUpperTranslation, SetUpperTranslation, float, 0.0f, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Enable Motor", GetEnableMotor, SetEnableMotor, bool, false, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Max Motor Force", GetMaxMotorForce, SetMaxMotorForce, float, 2.0f, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Motor Speed", GetMotorSpeed, SetMotorSpeed, float, 0.7f, AM_DEFAULT);
-    URHO3D_COPY_BASE_ATTRIBUTES(Constraint2D);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Anchor", GetAnchor, SetAnchor, Vector2, Vector2::ZERO, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Axis", GetAxis, SetAxis, Vector2, Vector2::RIGHT, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Enable Limit", GetEnableLimit, SetEnableLimit, bool, false, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Lower translation", GetLowerTranslation, SetLowerTranslation, float, 0.0f, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Upper translation", GetUpperTranslation, SetUpperTranslation, float, 0.0f, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Enable Motor", GetEnableMotor, SetEnableMotor, bool, false, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Max Motor Force", GetMaxMotorForce, SetMaxMotorForce, float, 2.0f, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Motor Speed", GetMotorSpeed, SetMotorSpeed, float, 0.7f, AM_DEFAULT);
+    ATOMIC_COPY_BASE_ATTRIBUTES(Constraint2D);
 }
 
 void ConstraintPrismatic2D::SetAnchor(const Vector2& anchor)

Source/Atomic/Atomic2D/ConstraintPrismatic2D.h

@@ -22,15 +22,15 @@
 
 #pragma once
 
-#include "../Urho2D/Constraint2D.h"
+#include "../Atomic2D/Constraint2D.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 /// 2D prismatic constraint component.
-class URHO3D_API ConstraintPrismatic2D : public Constraint2D
+class ATOMIC_API ConstraintPrismatic2D : public Constraint2D
 {
-    URHO3D_OBJECT(ConstraintPrismatic2D, Constraint2D);
+    ATOMIC_OBJECT(ConstraintPrismatic2D, Constraint2D);
 
 public:
     /// Construct.

Source/Atomic/Atomic2D/ConstraintPulley2D.cpp

@@ -23,13 +23,13 @@
 #include "../Precompiled.h"
 
 #include "../Core/Context.h"
-#include "../Urho2D/ConstraintPulley2D.h"
-#include "../Urho2D/PhysicsUtils2D.h"
-#include "../Urho2D/RigidBody2D.h"
+#include "../Atomic2D/ConstraintPulley2D.h"
+#include "../Atomic2D/PhysicsUtils2D.h"
+#include "../Atomic2D/RigidBody2D.h"
 
 #include "../DebugNew.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 extern const char* URHO2D_CATEGORY;
@@ -52,15 +52,15 @@ void ConstraintPulley2D::RegisterObject(Context* context)
 {
     context->RegisterFactory<ConstraintPulley2D>(URHO2D_CATEGORY);
 
-    URHO3D_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Owner Body Ground Anchor", GetOwnerBodyGroundAnchor, SetOwnerBodyGroundAnchor, Vector2, Vector2::ZERO,
+    ATOMIC_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Owner Body Ground Anchor", GetOwnerBodyGroundAnchor, SetOwnerBodyGroundAnchor, Vector2, Vector2::ZERO,
         AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Other Body Ground Anchor", GetOtherBodyGroundAnchor, SetOtherBodyGroundAnchor, Vector2, Vector2::ZERO,
+    ATOMIC_ACCESSOR_ATTRIBUTE("Other Body Ground Anchor", GetOtherBodyGroundAnchor, SetOtherBodyGroundAnchor, Vector2, Vector2::ZERO,
         AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Owner Body Anchor", GetOwnerBodyAnchor, SetOwnerBodyAnchor, Vector2, Vector2::ZERO, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Other Body Anchor", GetOtherBodyAnchor, SetOtherBodyAnchor, Vector2, Vector2::ZERO, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Ratio", GetRatio, SetRatio, float, 0.0f, AM_DEFAULT);
-    URHO3D_COPY_BASE_ATTRIBUTES(Constraint2D);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Owner Body Anchor", GetOwnerBodyAnchor, SetOwnerBodyAnchor, Vector2, Vector2::ZERO, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Other Body Anchor", GetOtherBodyAnchor, SetOtherBodyAnchor, Vector2, Vector2::ZERO, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Ratio", GetRatio, SetRatio, float, 0.0f, AM_DEFAULT);
+    ATOMIC_COPY_BASE_ATTRIBUTES(Constraint2D);
 }
 
 void ConstraintPulley2D::SetOwnerBodyGroundAnchor(const Vector2& groundAnchor)

Source/Atomic/Atomic2D/ConstraintPulley2D.h

@@ -22,15 +22,15 @@
 
 #pragma once
 
-#include "../Urho2D/Constraint2D.h"
+#include "../Atomic2D/Constraint2D.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 /// 2D pulley constraint component.
-class URHO3D_API ConstraintPulley2D : public Constraint2D
+class ATOMIC_API ConstraintPulley2D : public Constraint2D
 {
-    URHO3D_OBJECT(ConstraintPulley2D, Constraint2D);
+    ATOMIC_OBJECT(ConstraintPulley2D, Constraint2D);
 
 public:
     /// Construct.

Source/Atomic/Atomic2D/ConstraintRevolute2D.cpp

@@ -23,13 +23,13 @@
 #include "../Precompiled.h"
 
 #include "../Core/Context.h"
-#include "../Urho2D/ConstraintRevolute2D.h"
-#include "../Urho2D/PhysicsUtils2D.h"
-#include "../Urho2D/RigidBody2D.h"
+#include "../Atomic2D/ConstraintRevolute2D.h"
+#include "../Atomic2D/PhysicsUtils2D.h"
+#include "../Atomic2D/RigidBody2D.h"
 
 #include "../DebugNew.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 extern const char* URHO2D_CATEGORY;
@@ -48,15 +48,15 @@ void ConstraintRevolute2D::RegisterObject(Context* context)
 {
     context->RegisterFactory<ConstraintRevolute2D>(URHO2D_CATEGORY);
 
-    URHO3D_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Anchor", GetAnchor, SetAnchor, Vector2, Vector2::ZERO, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Enable Limit", GetEnableLimit, SetEnableLimit, bool, false, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Lower Angle", GetLowerAngle, SetLowerAngle, float, 0.0f, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Upper Angle", GetUpperAngle, SetUpperAngle, float, 0.0f, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Enable Motor", GetEnableMotor, SetEnableMotor, bool, false, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Motor Speed", GetMotorSpeed, SetMotorSpeed, float, 0.0f, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Max Motor Torque", GetMaxMotorTorque, SetMaxMotorTorque, float, 0.0f, AM_DEFAULT);
-    URHO3D_COPY_BASE_ATTRIBUTES(Constraint2D);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Anchor", GetAnchor, SetAnchor, Vector2, Vector2::ZERO, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Enable Limit", GetEnableLimit, SetEnableLimit, bool, false, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Lower Angle", GetLowerAngle, SetLowerAngle, float, 0.0f, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Upper Angle", GetUpperAngle, SetUpperAngle, float, 0.0f, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Enable Motor", GetEnableMotor, SetEnableMotor, bool, false, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Motor Speed", GetMotorSpeed, SetMotorSpeed, float, 0.0f, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Max Motor Torque", GetMaxMotorTorque, SetMaxMotorTorque, float, 0.0f, AM_DEFAULT);
+    ATOMIC_COPY_BASE_ATTRIBUTES(Constraint2D);
 }
 
 void ConstraintRevolute2D::SetAnchor(const Vector2& anchor)

Source/Atomic/Atomic2D/ConstraintRevolute2D.h

@@ -22,15 +22,15 @@
 
 #pragma once
 
-#include "../Urho2D/Constraint2D.h"
+#include "../Atomic2D/Constraint2D.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 /// 2D revolute constraint component.
-class URHO3D_API ConstraintRevolute2D : public Constraint2D
+class ATOMIC_API ConstraintRevolute2D : public Constraint2D
 {
-    URHO3D_OBJECT(ConstraintRevolute2D, Constraint2D);
+    ATOMIC_OBJECT(ConstraintRevolute2D, Constraint2D);
 
 public:
     /// Construct.

Source/Atomic/Atomic2D/ConstraintRope2D.cpp

@@ -23,13 +23,13 @@
 #include "../Precompiled.h"
 
 #include "../Core/Context.h"
-#include "../Urho2D/ConstraintRope2D.h"
-#include "../Urho2D/PhysicsUtils2D.h"
-#include "../Urho2D/RigidBody2D.h"
+#include "../Atomic2D/ConstraintRope2D.h"
+#include "../Atomic2D/PhysicsUtils2D.h"
+#include "../Atomic2D/RigidBody2D.h"
 
 #include "../DebugNew.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 extern const char* URHO2D_CATEGORY;
@@ -50,11 +50,11 @@ void ConstraintRope2D::RegisterObject(Context* context)
 {
     context->RegisterFactory<ConstraintRope2D>(URHO2D_CATEGORY);
 
-    URHO3D_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Owner Body Anchor", GetOwnerBodyAnchor, SetOwnerBodyAnchor, Vector2, Vector2::ZERO, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Other Body Anchor", GetOtherBodyAnchor, SetOtherBodyAnchor, Vector2, Vector2::ZERO, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Max Length", GetMaxLength, SetMaxLength, float, 0.0f, AM_DEFAULT);
-    URHO3D_COPY_BASE_ATTRIBUTES(Constraint2D);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Owner Body Anchor", GetOwnerBodyAnchor, SetOwnerBodyAnchor, Vector2, Vector2::ZERO, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Other Body Anchor", GetOtherBodyAnchor, SetOtherBodyAnchor, Vector2, Vector2::ZERO, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Max Length", GetMaxLength, SetMaxLength, float, 0.0f, AM_DEFAULT);
+    ATOMIC_COPY_BASE_ATTRIBUTES(Constraint2D);
 }
 
 void ConstraintRope2D::SetOwnerBodyAnchor(const Vector2& anchor)

Source/Atomic/Atomic2D/ConstraintRope2D.h

@@ -22,15 +22,15 @@
 
 #pragma once
 
-#include "../Urho2D/Constraint2D.h"
+#include "../Atomic2D/Constraint2D.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 /// 2D rope constraint component.
-class URHO3D_API ConstraintRope2D : public Constraint2D
+class ATOMIC_API ConstraintRope2D : public Constraint2D
 {
-    URHO3D_OBJECT(ConstraintRope2D, Constraint2D);
+    ATOMIC_OBJECT(ConstraintRope2D, Constraint2D);
 
 public:
     /// Construct.

Source/Atomic/Atomic2D/ConstraintWeld2D.cpp

@@ -23,13 +23,13 @@
 #include "../Precompiled.h"
 
 #include "../Core/Context.h"
-#include "../Urho2D/ConstraintWeld2D.h"
-#include "../Urho2D/PhysicsUtils2D.h"
-#include "../Urho2D/RigidBody2D.h"
+#include "../Atomic2D/ConstraintWeld2D.h"
+#include "../Atomic2D/PhysicsUtils2D.h"
+#include "../Atomic2D/RigidBody2D.h"
 
 #include "../DebugNew.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 extern const char* URHO2D_CATEGORY;
@@ -48,11 +48,11 @@ void ConstraintWeld2D::RegisterObject(Context* context)
 {
     context->RegisterFactory<ConstraintWeld2D>(URHO2D_CATEGORY);
 
-    URHO3D_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Anchor", GetAnchor, SetAnchor, Vector2, Vector2::ZERO, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Frequency Hz", GetFrequencyHz, SetFrequencyHz, float, 0.0f, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Damping Ratio", GetDampingRatio, SetDampingRatio, float, 0.0f, AM_DEFAULT);
-    URHO3D_COPY_BASE_ATTRIBUTES(Constraint2D);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Anchor", GetAnchor, SetAnchor, Vector2, Vector2::ZERO, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Frequency Hz", GetFrequencyHz, SetFrequencyHz, float, 0.0f, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Damping Ratio", GetDampingRatio, SetDampingRatio, float, 0.0f, AM_DEFAULT);
+    ATOMIC_COPY_BASE_ATTRIBUTES(Constraint2D);
 }
 
 void ConstraintWeld2D::SetAnchor(const Vector2& anchor)

Source/Atomic/Atomic2D/ConstraintWeld2D.h

@@ -22,15 +22,15 @@
 
 #pragma once
 
-#include "../Urho2D/Constraint2D.h"
+#include "../Atomic2D/Constraint2D.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 /// 2D weld constraint component.
-class URHO3D_API ConstraintWeld2D : public Constraint2D
+class ATOMIC_API ConstraintWeld2D : public Constraint2D
 {
-    URHO3D_OBJECT(ConstraintWeld2D, Constraint2D);
+    ATOMIC_OBJECT(ConstraintWeld2D, Constraint2D);
 
 public:
     /// Construct.

Source/Atomic/Atomic2D/ConstraintWheel2D.cpp

@@ -23,13 +23,13 @@
 #include "../Precompiled.h"
 
 #include "../Core/Context.h"
-#include "../Urho2D/ConstraintWheel2D.h"
-#include "../Urho2D/PhysicsUtils2D.h"
-#include "../Urho2D/RigidBody2D.h"
+#include "../Atomic2D/ConstraintWheel2D.h"
+#include "../Atomic2D/PhysicsUtils2D.h"
+#include "../Atomic2D/RigidBody2D.h"
 
 #include "../DebugNew.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 extern const char* URHO2D_CATEGORY;
@@ -49,15 +49,15 @@ void ConstraintWheel2D::RegisterObject(Context* context)
 {
     context->RegisterFactory<ConstraintWheel2D>(URHO2D_CATEGORY);
 
-    URHO3D_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Anchor", GetAnchor, SetAnchor, Vector2, Vector2::ZERO, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Axis", GetAxis, SetAxis, Vector2, Vector2::RIGHT, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Enable Motor", GetEnableMotor, SetEnableMotor, bool, false, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Max Motor Torque", GetMaxMotorTorque, SetMaxMotorTorque, float, 0.0f, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Motor Speed", GetMotorSpeed, SetMotorSpeed, float, 0.0f, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Frequency Hz", GetFrequencyHz, SetFrequencyHz, float, 2.0f, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Damping Ratio", GetDampingRatio, SetDampingRatio, float, 0.7f, AM_DEFAULT);
-    URHO3D_COPY_BASE_ATTRIBUTES(Constraint2D);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Anchor", GetAnchor, SetAnchor, Vector2, Vector2::ZERO, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Axis", GetAxis, SetAxis, Vector2, Vector2::RIGHT, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Enable Motor", GetEnableMotor, SetEnableMotor, bool, false, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Max Motor Torque", GetMaxMotorTorque, SetMaxMotorTorque, float, 0.0f, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Motor Speed", GetMotorSpeed, SetMotorSpeed, float, 0.0f, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Frequency Hz", GetFrequencyHz, SetFrequencyHz, float, 2.0f, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Damping Ratio", GetDampingRatio, SetDampingRatio, float, 0.7f, AM_DEFAULT);
+    ATOMIC_COPY_BASE_ATTRIBUTES(Constraint2D);
 }
 
 void ConstraintWheel2D::SetAnchor(const Vector2& anchor)

Source/Atomic/Atomic2D/ConstraintWheel2D.h

@@ -22,15 +22,15 @@
 
 #pragma once
 
-#include "../Urho2D/Constraint2D.h"
+#include "../Atomic2D/Constraint2D.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 /// 2D wheel constraint component.
-class URHO3D_API ConstraintWheel2D : public Constraint2D
+class ATOMIC_API ConstraintWheel2D : public Constraint2D
 {
-    URHO3D_OBJECT(ConstraintWheel2D, Constraint2D);
+    ATOMIC_OBJECT(ConstraintWheel2D, Constraint2D);
 
 public:
     /// Construct.

Source/Atomic/Atomic2D/Drawable2D.cpp

@@ -27,12 +27,12 @@
 #include "../Graphics/Material.h"
 #include "../Graphics/Texture2D.h"
 #include "../Scene/Scene.h"
-#include "../Urho2D/Drawable2D.h"
-#include "../Urho2D/Renderer2D.h"
+#include "../Atomic2D/Drawable2D.h"
+#include "../Atomic2D/Renderer2D.h"
 
 #include "../DebugNew.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 const float PIXEL_SIZE = 0.01f;
@@ -59,9 +59,9 @@ Drawable2D::~Drawable2D()
 
 void Drawable2D::RegisterObject(Context* context)
 {
-    URHO3D_ACCESSOR_ATTRIBUTE("Layer", GetLayer, SetLayer, int, 0, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Order in Layer", GetOrderInLayer, SetOrderInLayer, int, 0, AM_DEFAULT);
-    URHO3D_ATTRIBUTE("View Mask", int, viewMask_, DEFAULT_VIEWMASK, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Layer", GetLayer, SetLayer, int, 0, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Order in Layer", GetOrderInLayer, SetOrderInLayer, int, 0, AM_DEFAULT);
+    ATOMIC_ATTRIBUTE("View Mask", int, viewMask_, DEFAULT_VIEWMASK, AM_DEFAULT);
 }
 
 void Drawable2D::OnSetEnabled()

Source/Atomic/Atomic2D/Drawable2D.h

@@ -25,7 +25,7 @@
 #include "../Graphics/Drawable.h"
 #include "../Graphics/GraphicsDefs.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 class Drawable2D; 
@@ -63,12 +63,12 @@ struct SourceBatch2D
 };
 
 /// Pixel size (equal 0.01f).
-extern URHO3D_API const float PIXEL_SIZE;
+extern ATOMIC_API const float PIXEL_SIZE;
 
 /// Base class for 2D visible components.
-class URHO3D_API Drawable2D : public Drawable
+class ATOMIC_API Drawable2D : public Drawable
 {
-    URHO3D_OBJECT(Drawable2D, Drawable);
+    ATOMIC_OBJECT(Drawable2D, Drawable);
 
 public:
     /// Construct.

Source/Atomic/Atomic2D/Light2D.cpp

@@ -130,16 +130,16 @@ void Light2D::AddVertices(Vector<Vertex2D>& vertices)
 void Light2D::RegisterObject(Context* context)
 {
     context->RegisterFactory<Light2D>(ATOMIC2D_CATEGORY);
-    COPY_BASE_ATTRIBUTES(Component);
+    ATOMIC_COPY_BASE_ATTRIBUTES(Component);
 
-    ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
-    ACCESSOR_ATTRIBUTE("LightGroup", GetLightGroupID, SetLightGroupID, int, 0, AM_DEFAULT);
-    ACCESSOR_ATTRIBUTE("Color", GetColor, SetColor, Color, Color::WHITE, AM_DEFAULT);
-    ACCESSOR_ATTRIBUTE("Cast Shadows", GetCastShadows, SetCastShadows, bool, false, AM_DEFAULT);
-    ACCESSOR_ATTRIBUTE("Num Rays", GetNumRays, SetNumRays, int, 32, AM_DEFAULT);
-    ACCESSOR_ATTRIBUTE("Soft Shadows", GetSoftShadows, SetSoftShadows, bool, false, AM_DEFAULT);
-    ACCESSOR_ATTRIBUTE("Soft Shadows Length", GetSoftShadowLength, SetSoftShadowLength, float, 2.5f, AM_DEFAULT);
-    ACCESSOR_ATTRIBUTE("Backtrace", GetBacktrace, SetBacktrace, bool, false, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("LightGroup", GetLightGroupID, SetLightGroupID, int, 0, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Color", GetColor, SetColor, Color, Color::WHITE, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Cast Shadows", GetCastShadows, SetCastShadows, bool, false, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Num Rays", GetNumRays, SetNumRays, int, 32, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Soft Shadows", GetSoftShadows, SetSoftShadows, bool, false, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Soft Shadows Length", GetSoftShadowLength, SetSoftShadowLength, float, 2.5f, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Backtrace", GetBacktrace, SetBacktrace, bool, false, AM_DEFAULT);
 
 }
 
@@ -221,9 +221,9 @@ DirectionalLight2D::~DirectionalLight2D()
 void DirectionalLight2D::RegisterObject(Context* context)
 {
     context->RegisterFactory<DirectionalLight2D>(ATOMIC2D_CATEGORY);
-    COPY_BASE_ATTRIBUTES(Light2D);
+    ATOMIC_COPY_BASE_ATTRIBUTES(Light2D);
 
-    ACCESSOR_ATTRIBUTE("Direction", GetDirection, SetDirection, float, -45.0f, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Direction", GetDirection, SetDirection, float, -45.0f, AM_DEFAULT);
 }
 
 void DirectionalLight2D::UpdateVertices()
@@ -396,7 +396,7 @@ PositionalLight2D::~PositionalLight2D()
 void PositionalLight2D::RegisterObject(Context* context)
 {
     context->RegisterFactory<PositionalLight2D>(ATOMIC2D_CATEGORY);
-    COPY_BASE_ATTRIBUTES(Light2D);
+    ATOMIC_COPY_BASE_ATTRIBUTES(Light2D);
 }
 
 void PositionalLight2D::UpdateVertices()
@@ -508,9 +508,9 @@ PointLight2D::~PointLight2D()
 void PointLight2D::RegisterObject(Context* context)
 {
     context->RegisterFactory<PointLight2D>(ATOMIC2D_CATEGORY);
-    COPY_BASE_ATTRIBUTES(PositionalLight2D);
+    ATOMIC_COPY_BASE_ATTRIBUTES(PositionalLight2D);
 
-    ACCESSOR_ATTRIBUTE("Radius", GetRadius, SetRadius, float, 4.0f, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Radius", GetRadius, SetRadius, float, 4.0f, AM_DEFAULT);
 }
 
 void PointLight2D::UpdateVertices()
@@ -546,7 +546,7 @@ void PointLight2D::UpdateVertices()
 void Light2DGroup::RegisterObject(Context* context)
 {
     context->RegisterFactory<Light2DGroup>(ATOMIC2D_CATEGORY);
-    COPY_BASE_ATTRIBUTES(Drawable2D);
+    ATOMIC_COPY_BASE_ATTRIBUTES(Drawable2D);
 }
 
 
@@ -564,7 +564,9 @@ void Light2DGroup::OnSceneSet(Scene* scene)
 
         renderer_ = node_->GetOrCreateComponent<Renderer2D>();
         renderer_->SetTemporary(true);
-        renderer_->SetUseTris(true);
+// ATOMIC_UPDATE_FIX_BEGIN
+        //renderer_->SetUseTris(true);
+// ATOMIC_UPDATE_FIX_END
 
         if (light2DMaterial_.Null())
             CreateLight2DMaterial();
@@ -588,8 +590,8 @@ Light2DGroup::Light2DGroup(Context* context) : Drawable2D(context),
     frustum_(0)
 {
     sourceBatches_.Resize(1);
-    SubscribeToEvent(E_BEGINRENDERING, HANDLER(Light2DGroup, HandleBeginRendering));
-    SubscribeToEvent(E_BEGINVIEWUPDATE, HANDLER(Light2DGroup, HandleBeginViewUpdate));
+    SubscribeToEvent(E_BEGINRENDERING, ATOMIC_HANDLER(Light2DGroup, HandleBeginRendering));
+    SubscribeToEvent(E_BEGINVIEWUPDATE, ATOMIC_HANDLER(Light2DGroup, HandleBeginViewUpdate));
 }
 
 Light2DGroup::~Light2DGroup()

Source/Atomic/Atomic2D/Light2D.h

@@ -50,7 +50,7 @@ struct Light2DRay
 
 class ATOMIC_API Light2D : public Component
 {
-    OBJECT(Light2D);
+    ATOMIC_OBJECT(Light2D, Component);
 
 public:
     /// Construct.
@@ -112,7 +112,7 @@ protected:
 
 class ATOMIC_API DirectionalLight2D : public Light2D
 {
-    OBJECT(DirectionalLight2D);
+    ATOMIC_OBJECT(DirectionalLight2D, Light2D);
 
 public:
     /// Construct.
@@ -137,7 +137,7 @@ protected:
 
 class ATOMIC_API PositionalLight2D : public Light2D
 {
-    OBJECT(PositionalLight2D);
+    ATOMIC_OBJECT(PositionalLight2D, Light2D);
 
 public:
     /// Construct.
@@ -156,7 +156,7 @@ protected:
 
 class ATOMIC_API PointLight2D : public PositionalLight2D
 {
-    OBJECT(PointLight2D);
+    ATOMIC_OBJECT(PointLight2D, PositionalLight2D);
 
 public:
     /// Construct.
@@ -181,7 +181,7 @@ protected:
 
 class ATOMIC_API Light2DGroup : public Drawable2D
 {
-    OBJECT(Light2DGroup);
+    ATOMIC_OBJECT(Light2DGroup, Drawable2D);
 
 public:
     /// Construct.

Source/Atomic/Atomic2D/ParticleEffect2D.cpp

@@ -27,12 +27,12 @@
 #include "../IO/Log.h"
 #include "../Resource/ResourceCache.h"
 #include "../Resource/XMLFile.h"
-#include "../Urho2D/ParticleEffect2D.h"
-#include "../Urho2D/Sprite2D.h"
+#include "../Atomic2D/ParticleEffect2D.h"
+#include "../Atomic2D/Sprite2D.h"
 
 #include "../DebugNew.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 static const int srcBlendFuncs[] =
@@ -210,7 +210,7 @@ bool ParticleEffect2D::EndLoad()
         ResourceCache* cache = GetSubsystem<ResourceCache>();
         sprite_ = cache->GetResource<Sprite2D>(loadSpriteName_);
         if (!sprite_)
-            URHO3D_LOGERROR("Could not load sprite " + loadSpriteName_ + " for particle effect");
+            ATOMIC_LOGERROR("Could not load sprite " + loadSpriteName_ + " for particle effect");
 
         loadSpriteName_.Clear();
     }

Source/Atomic/Atomic2D/ParticleEffect2D.h

@@ -25,7 +25,7 @@
 #include "../Graphics/GraphicsDefs.h"
 #include "../Resource/Resource.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 class XMLElement;
@@ -39,9 +39,9 @@ enum EmitterType2D
 };
 
 /// 2D particle effect resource.
-class URHO3D_API ParticleEffect2D : public Resource
+class ATOMIC_API ParticleEffect2D : public Resource
 {
-    URHO3D_OBJECT(ParticleEffect2D, Resource);
+    ATOMIC_OBJECT(ParticleEffect2D, Resource);
 
 public:
     /// Construct.

Source/Atomic/Atomic2D/ParticleEmitter2D.cpp

@@ -28,14 +28,14 @@
 #include "../Resource/ResourceCache.h"
 #include "../Scene/Scene.h"
 #include "../Scene/SceneEvents.h"
-#include "../Urho2D/ParticleEffect2D.h"
-#include "../Urho2D/ParticleEmitter2D.h"
-#include "../Urho2D/Renderer2D.h"
-#include "../Urho2D/Sprite2D.h"
+#include "../Atomic2D/ParticleEffect2D.h"
+#include "../Atomic2D/ParticleEmitter2D.h"
+#include "../Atomic2D/Renderer2D.h"
+#include "../Atomic2D/Sprite2D.h"
 
 #include "../DebugNew.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 extern const char* URHO2D_CATEGORY;
@@ -62,13 +62,13 @@ void ParticleEmitter2D::RegisterObject(Context* context)
 {
     context->RegisterFactory<ParticleEmitter2D>(URHO2D_CATEGORY);
 
-    URHO3D_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
-    URHO3D_COPY_BASE_ATTRIBUTES(Drawable2D);
-    URHO3D_MIXED_ACCESSOR_ATTRIBUTE("Particle Effect", GetParticleEffectAttr, SetParticleEffectAttr, ResourceRef,
+    ATOMIC_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
+    ATOMIC_COPY_BASE_ATTRIBUTES(Drawable2D);
+    ATOMIC_MIXED_ACCESSOR_ATTRIBUTE("Particle Effect", GetParticleEffectAttr, SetParticleEffectAttr, ResourceRef,
         ResourceRef(ParticleEffect2D::GetTypeStatic()), AM_DEFAULT);
-    URHO3D_MIXED_ACCESSOR_ATTRIBUTE("Sprite ", GetSpriteAttr, SetSpriteAttr, ResourceRef, ResourceRef(Sprite2D::GetTypeStatic()),
+    ATOMIC_MIXED_ACCESSOR_ATTRIBUTE("Sprite ", GetSpriteAttr, SetSpriteAttr, ResourceRef, ResourceRef(Sprite2D::GetTypeStatic()),
         AM_DEFAULT);
-    URHO3D_ENUM_ACCESSOR_ATTRIBUTE("Blend Mode", GetBlendMode, SetBlendMode, BlendMode, blendModeNames, BLEND_ALPHA, AM_DEFAULT);
+    ATOMIC_ENUM_ACCESSOR_ATTRIBUTE("Blend Mode", GetBlendMode, SetBlendMode, BlendMode, blendModeNames, BLEND_ALPHA, AM_DEFAULT);
 }
 
 void ParticleEmitter2D::OnSetEnabled()
@@ -79,7 +79,7 @@ void ParticleEmitter2D::OnSetEnabled()
     if (scene)
     {
         if (IsEnabledEffective())
-            SubscribeToEvent(scene, E_SCENEPOSTUPDATE, URHO3D_HANDLER(ParticleEmitter2D, HandleScenePostUpdate));
+            SubscribeToEvent(scene, E_SCENEPOSTUPDATE, ATOMIC_HANDLER(ParticleEmitter2D, HandleScenePostUpdate));
         else
             UnsubscribeFromEvent(scene, E_SCENEPOSTUPDATE);
     }
@@ -174,7 +174,7 @@ void ParticleEmitter2D::OnSceneSet(Scene* scene)
     Drawable2D::OnSceneSet(scene);
 
     if (scene && IsEnabledEffective())
-        SubscribeToEvent(scene, E_SCENEPOSTUPDATE, URHO3D_HANDLER(ParticleEmitter2D, HandleScenePostUpdate));
+        SubscribeToEvent(scene, E_SCENEPOSTUPDATE, ATOMIC_HANDLER(ParticleEmitter2D, HandleScenePostUpdate));
     else if (!scene)
         UnsubscribeFromEvent(E_SCENEPOSTUPDATE);
 }

Source/Atomic/Atomic2D/ParticleEmitter2D.h

@@ -22,9 +22,9 @@
 
 #pragma once
 
-#include "../Urho2D/Drawable2D.h"
+#include "../Atomic2D/Drawable2D.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 class ParticleEffect2D;
@@ -73,9 +73,9 @@ struct Particle2D
 };
 
 /// 2D particle emitter component.
-class URHO3D_API ParticleEmitter2D : public Drawable2D
+class ATOMIC_API ParticleEmitter2D : public Drawable2D
 {
-    URHO3D_OBJECT(ParticleEmitter2D, Drawable2D);
+    ATOMIC_OBJECT(ParticleEmitter2D, Drawable2D);
 
 public:
     /// Construct.

Source/Atomic/Atomic2D/PhysicsEvents2D.h

@@ -28,29 +28,29 @@
 // on whether 3D physics support or Bullet has been compiled in.
 #include "../Physics/PhysicsEvents.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 /// Physics begin contact.
-URHO3D_EVENT(E_PHYSICSBEGINCONTACT2D, PhysicsBeginContact2D)
+ATOMIC_EVENT(E_PHYSICSBEGINCONTACT2D, PhysicsBeginContact2D)
 {
-    URHO3D_PARAM(P_WORLD, World);                  // PhysicsWorld2D pointer
-    URHO3D_PARAM(P_BODYA, BodyA);                  // RigidBody2D pointer
-    URHO3D_PARAM(P_BODYB, BodyB);                  // RigidBody2D pointer
-    URHO3D_PARAM(P_NODEA, NodeA);                  // Node pointer
-    URHO3D_PARAM(P_NODEB, NodeB);                  // Node pointer
-    URHO3D_PARAM(P_CONTACT, Contact);              // b2Contact pointer
+    ATOMIC_PARAM(P_WORLD, World);                  // PhysicsWorld2D pointer
+    ATOMIC_PARAM(P_BODYA, BodyA);                  // RigidBody2D pointer
+    ATOMIC_PARAM(P_BODYB, BodyB);                  // RigidBody2D pointer
+    ATOMIC_PARAM(P_NODEA, NodeA);                  // Node pointer
+    ATOMIC_PARAM(P_NODEB, NodeB);                  // Node pointer
+    ATOMIC_PARAM(P_CONTACT, Contact);              // b2Contact pointer
 }
 
 /// Physics end contact.
-URHO3D_EVENT(E_PHYSICSENDCONTACT2D, PhysicsEndContact2D)
+ATOMIC_EVENT(E_PHYSICSENDCONTACT2D, PhysicsEndContact2D)
 {
-    URHO3D_PARAM(P_WORLD, World);                  // PhysicsWorld2D pointer
-    URHO3D_PARAM(P_BODYA, BodyA);                  // RigidBody2D pointer
-    URHO3D_PARAM(P_BODYB, BodyB);                  // RigidBody2D pointer
-    URHO3D_PARAM(P_NODEA, NodeA);                  // Node pointer
-    URHO3D_PARAM(P_NODEB, NodeB);                  // Node pointer
-    URHO3D_PARAM(P_CONTACT, Contact);              // b2Contact pointer
+    ATOMIC_PARAM(P_WORLD, World);                  // PhysicsWorld2D pointer
+    ATOMIC_PARAM(P_BODYA, BodyA);                  // RigidBody2D pointer
+    ATOMIC_PARAM(P_BODYB, BodyB);                  // RigidBody2D pointer
+    ATOMIC_PARAM(P_NODEA, NodeA);                  // Node pointer
+    ATOMIC_PARAM(P_NODEB, NodeB);                  // Node pointer
+    ATOMIC_PARAM(P_CONTACT, Contact);              // b2Contact pointer
 }
 
 }

Source/Atomic/Atomic2D/PhysicsUtils2D.h

@@ -28,7 +28,7 @@
 
 #include <Box2D/Box2D.h>
 
-namespace Urho3D
+namespace Atomic
 {
 
 inline Color ToColor(const b2Color& color)

Source/Atomic/Atomic2D/PhysicsWorld2D.cpp

@@ -30,14 +30,14 @@
 #include "../IO/Log.h"
 #include "../Scene/Scene.h"
 #include "../Scene/SceneEvents.h"
-#include "../Urho2D/PhysicsEvents2D.h"
-#include "../Urho2D/PhysicsUtils2D.h"
-#include "../Urho2D/PhysicsWorld2D.h"
-#include "../Urho2D/RigidBody2D.h"
+#include "../Atomic2D/PhysicsEvents2D.h"
+#include "../Atomic2D/PhysicsUtils2D.h"
+#include "../Atomic2D/PhysicsWorld2D.h"
+#include "../Atomic2D/RigidBody2D.h"
 
 #include "../DebugNew.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 extern const char* SUBSYSTEM_CATEGORY;
@@ -84,20 +84,20 @@ void PhysicsWorld2D::RegisterObject(Context* context)
 {
     context->RegisterFactory<PhysicsWorld2D>(SUBSYSTEM_CATEGORY);
 
-    URHO3D_ACCESSOR_ATTRIBUTE("Draw Shape", GetDrawShape, SetDrawShape, bool, false, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Draw Joint", GetDrawJoint, SetDrawJoint, bool, false, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Draw Aabb", GetDrawAabb, SetDrawAabb, bool, false, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Draw Pair", GetDrawPair, SetDrawPair, bool, false, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Draw CenterOfMass", GetDrawCenterOfMass, SetDrawCenterOfMass, bool, false, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Allow Sleeping", GetAllowSleeping, SetAllowSleeping, bool, false, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Warm Starting", GetWarmStarting, SetWarmStarting, bool, false, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Continuous Physics", GetContinuousPhysics, SetContinuousPhysics, bool, false, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Sub Stepping", GetSubStepping, SetSubStepping, bool, false, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Gravity", GetGravity, SetGravity, Vector2, DEFAULT_GRAVITY, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Auto Clear Forces", GetAutoClearForces, SetAutoClearForces, bool, false, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Velocity Iterations", GetVelocityIterations, SetVelocityIterations, int, DEFAULT_VELOCITY_ITERATIONS,
+    ATOMIC_ACCESSOR_ATTRIBUTE("Draw Shape", GetDrawShape, SetDrawShape, bool, false, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Draw Joint", GetDrawJoint, SetDrawJoint, bool, false, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Draw Aabb", GetDrawAabb, SetDrawAabb, bool, false, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Draw Pair", GetDrawPair, SetDrawPair, bool, false, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Draw CenterOfMass", GetDrawCenterOfMass, SetDrawCenterOfMass, bool, false, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Allow Sleeping", GetAllowSleeping, SetAllowSleeping, bool, false, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Warm Starting", GetWarmStarting, SetWarmStarting, bool, false, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Continuous Physics", GetContinuousPhysics, SetContinuousPhysics, bool, false, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Sub Stepping", GetSubStepping, SetSubStepping, bool, false, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Gravity", GetGravity, SetGravity, Vector2, DEFAULT_GRAVITY, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Auto Clear Forces", GetAutoClearForces, SetAutoClearForces, bool, false, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Velocity Iterations", GetVelocityIterations, SetVelocityIterations, int, DEFAULT_VELOCITY_ITERATIONS,
         AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Position Iterations", GetPositionIterations, SetPositionIterations, int, DEFAULT_POSITION_ITERATIONS,
+    ATOMIC_ACCESSOR_ATTRIBUTE("Position Iterations", GetPositionIterations, SetPositionIterations, int, DEFAULT_POSITION_ITERATIONS,
         AM_DEFAULT);
 }
 
@@ -105,7 +105,7 @@ void PhysicsWorld2D::DrawDebugGeometry(DebugRenderer* debug, bool depthTest)
 {
     if (debug)
     {
-        URHO3D_PROFILE(Physics2DDrawDebug);
+        ATOMIC_PROFILE(Physics2DDrawDebug);
 
         debugRenderer_ = debug;
         debugDepthTest_ = depthTest;
@@ -226,7 +226,7 @@ void PhysicsWorld2D::DrawTransform(const b2Transform& xf)
 
 void PhysicsWorld2D::Update(float timeStep)
 {
-    URHO3D_PROFILE(UpdatePhysics2D);
+    ATOMIC_PROFILE(UpdatePhysics2D);
 
     using namespace PhysicsPreStep;
 
@@ -654,7 +654,7 @@ void PhysicsWorld2D::OnSceneSet(Scene* scene)
 {
     // Subscribe to the scene subsystem update, which will trigger the physics simulation step
     if (scene)
-        SubscribeToEvent(scene, E_SCENESUBSYSTEMUPDATE, URHO3D_HANDLER(PhysicsWorld2D, HandleSceneSubsystemUpdate));
+        SubscribeToEvent(scene, E_SCENESUBSYSTEMUPDATE, ATOMIC_HANDLER(PhysicsWorld2D, HandleSceneSubsystemUpdate));
     else
         UnsubscribeFromEvent(E_SCENESUBSYSTEMUPDATE);
 }

Source/Atomic/Atomic2D/PhysicsWorld2D.h

@@ -26,14 +26,14 @@
 
 #include <Box2D/Box2D.h>
 
-namespace Urho3D
+namespace Atomic
 {
 
 class Camera;
 class RigidBody2D;
 
 /// 2D Physics raycast hit.
-struct URHO3D_API PhysicsRaycastResult2D
+struct ATOMIC_API PhysicsRaycastResult2D
 {
     /// Construct with defaults.
     PhysicsRaycastResult2D() :
@@ -71,9 +71,9 @@ struct DelayedWorldTransform2D
 };
 
 /// 2D physics simulation world component. Should be added only to the root scene node.
-class URHO3D_API PhysicsWorld2D : public Component, public b2ContactListener, public b2Draw
+class ATOMIC_API PhysicsWorld2D : public Component, public b2ContactListener, public b2Draw
 {
-    URHO3D_OBJECT(PhysicsWorld2D, Component);
+    ATOMIC_OBJECT(PhysicsWorld2D, Component);
 
 public:
     /// Construct.

Source/Atomic/Atomic2D/Renderer2D.cpp

@@ -38,12 +38,12 @@
 #include "../IO/Log.h"
 #include "../Scene/Node.h"
 #include "../Scene/Scene.h"
-#include "../Urho2D/Drawable2D.h"
-#include "../Urho2D/Renderer2D.h"
+#include "../Atomic2D/Drawable2D.h"
+#include "../Atomic2D/Renderer2D.h"
 
 #include "../DebugNew.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 extern const char* blendModeNames[];
@@ -65,12 +65,12 @@ Renderer2D::Renderer2D(Context* context) :
     indexBuffer_(new IndexBuffer(context_)),
     viewMask_(DEFAULT_VIEWMASK)
 {
-    material_->SetName("Urho2D");
+    material_->SetName("Atomic2D");
 
     Technique* tech = new Technique(context_);
     Pass* pass = tech->CreatePass("alpha");
-    pass->SetVertexShader("Urho2D");
-    pass->SetPixelShader("Urho2D");
+    pass->SetVertexShader("Atomic2D");
+    pass->SetPixelShader("Atomic2D");
     pass->SetDepthWrite(false);
     cachedTechniques_[BLEND_REPLACE] = tech;
 
@@ -78,7 +78,7 @@ Renderer2D::Renderer2D(Context* context) :
     material_->SetCullMode(CULL_NONE);
 
     frame_.frameNumber_ = 0;
-    SubscribeToEvent(E_BEGINVIEWUPDATE, URHO3D_HANDLER(Renderer2D, HandleBeginViewUpdate));
+    SubscribeToEvent(E_BEGINVIEWUPDATE, ATOMIC_HANDLER(Renderer2D, HandleBeginViewUpdate));
 }
 
 Renderer2D::~Renderer2D()
@@ -182,7 +182,7 @@ void Renderer2D::UpdateGeometry(const FrameInfo& frame)
         }
         else
         {
-            URHO3D_LOGERROR("Failed to lock index buffer");
+            ATOMIC_LOGERROR("Failed to lock index buffer");
             return;
         }
     }
@@ -214,7 +214,7 @@ void Renderer2D::UpdateGeometry(const FrameInfo& frame)
                 vertexBuffer->Unlock();
             }
             else
-                URHO3D_LOGERROR("Failed to lock vertex buffer");
+                ATOMIC_LOGERROR("Failed to lock vertex buffer");
         }
 
         viewBatchInfo.vertexBufferUpdateFrameNumber_ = frame_.frameNumber_;
@@ -291,8 +291,8 @@ SharedPtr<Material> Renderer2D::CreateMaterial(Texture2D* texture, BlendMode ble
     {
         SharedPtr<Technique> tech(new Technique(context_));
         Pass* pass = tech->CreatePass("alpha");
-        pass->SetVertexShader("Urho2D");
-        pass->SetPixelShader("Urho2D");
+        pass->SetVertexShader("Atomic2D");
+        pass->SetPixelShader("Atomic2D");
         pass->SetDepthWrite(false);
         pass->SetBlendMode(blendMode);
         techIt = cachedTechniques_.Insert(MakePair((int)blendMode, tech));
@@ -329,7 +329,7 @@ void Renderer2D::HandleBeginViewUpdate(StringHash eventType, VariantMap& eventDa
 
     frame_ = static_cast<View*>(eventData[P_VIEW].GetPtr())->GetFrameInfo();
 
-    URHO3D_PROFILE(UpdateRenderer2D);
+    ATOMIC_PROFILE(UpdateRenderer2D);
 
     Camera* camera = static_cast<Camera*>(eventData[P_CAMERA].GetPtr());
     frustum_ = camera->GetFrustum();
@@ -337,7 +337,7 @@ void Renderer2D::HandleBeginViewUpdate(StringHash eventType, VariantMap& eventDa
 
     // Check visibility
     {
-        URHO3D_PROFILE(CheckDrawableVisibility);
+        ATOMIC_PROFILE(CheckDrawableVisibility);
 
         WorkQueue* queue = GetSubsystem<WorkQueue>();
         int numWorkItems = queue->GetNumThreads() + 1; // Worker threads + main thread

Source/Atomic/Atomic2D/Renderer2D.h

@@ -25,7 +25,7 @@
 #include "../Graphics/Drawable.h"
 #include "../Math/Frustum.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 class Drawable2D;
@@ -65,9 +65,9 @@ struct ViewBatchInfo2D
 };
 
 /// 2D renderer component.
-class URHO3D_API Renderer2D : public Drawable
+class ATOMIC_API Renderer2D : public Drawable
 {
-    URHO3D_OBJECT(Renderer2D, Drawable);
+    ATOMIC_OBJECT(Renderer2D, Drawable);
 
     friend void CheckDrawableVisibility(const WorkItem* item, unsigned threadIndex);
 

Source/Atomic/Atomic2D/RigidBody2D.cpp

@@ -25,15 +25,15 @@
 #include "../Core/Context.h"
 #include "../IO/Log.h"
 #include "../Scene/Scene.h"
-#include "../Urho2D/CollisionShape2D.h"
-#include "../Urho2D/Constraint2D.h"
-#include "../Urho2D/PhysicsUtils2D.h"
-#include "../Urho2D/PhysicsWorld2D.h"
-#include "../Urho2D/RigidBody2D.h"
+#include "../Atomic2D/CollisionShape2D.h"
+#include "../Atomic2D/Constraint2D.h"
+#include "../Atomic2D/PhysicsUtils2D.h"
+#include "../Atomic2D/PhysicsWorld2D.h"
+#include "../Atomic2D/RigidBody2D.h"
 
 #include "../DebugNew.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 extern const char* URHO2D_CATEGORY;
@@ -50,7 +50,10 @@ static const char* bodyTypeNames[] =
 RigidBody2D::RigidBody2D(Context* context) :
     Component(context),
     useFixtureMass_(true),
-    body_(0)
+    body_(0),
+// ATOMIC BEGIN
+    castShadows_(false)
+// ATOMIC END
 {
     // Make sure the massData members are zero-initialized.
     massData_.mass = 0.0f;
@@ -72,21 +75,21 @@ void RigidBody2D::RegisterObject(Context* context)
 {
     context->RegisterFactory<RigidBody2D>(URHO2D_CATEGORY);
 
-    URHO3D_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
-    URHO3D_ENUM_ACCESSOR_ATTRIBUTE("Body Type", GetBodyType, SetBodyType, BodyType2D, bodyTypeNames, DEFAULT_BODYTYPE, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Mass", GetMass, SetMass, float, 0.0f, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Inertia", GetInertia, SetInertia, float, 0.0f, AM_DEFAULT);
-    URHO3D_MIXED_ACCESSOR_ATTRIBUTE("Mass Center", GetMassCenter, SetMassCenter, Vector2, Vector2::ZERO, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Use Fixture Mass", GetUseFixtureMass, SetUseFixtureMass, bool, true, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Linear Damping", GetLinearDamping, SetLinearDamping, float, 0.0f, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Angular Damping", GetAngularDamping, SetAngularDamping, float, 0.0f, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Allow Sleep", IsAllowSleep, SetAllowSleep, bool, true, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Fixed Rotation", IsFixedRotation, SetFixedRotation, bool, false, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Bullet", IsBullet, SetBullet, bool, false, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Gravity Scale", GetGravityScale, SetGravityScale, float, 1.0f, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Awake", IsAwake, SetAwake, bool, true, AM_DEFAULT);
-    URHO3D_MIXED_ACCESSOR_ATTRIBUTE("Linear Velocity", GetLinearVelocity, SetLinearVelocity, Vector2, Vector2::ZERO, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Angular Velocity", GetAngularVelocity, SetAngularVelocity, float, 0.0f, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
+    ATOMIC_ENUM_ACCESSOR_ATTRIBUTE("Body Type", GetBodyType, SetBodyType, BodyType2D, bodyTypeNames, DEFAULT_BODYTYPE, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Mass", GetMass, SetMass, float, 0.0f, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Inertia", GetInertia, SetInertia, float, 0.0f, AM_DEFAULT);
+    ATOMIC_MIXED_ACCESSOR_ATTRIBUTE("Mass Center", GetMassCenter, SetMassCenter, Vector2, Vector2::ZERO, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Use Fixture Mass", GetUseFixtureMass, SetUseFixtureMass, bool, true, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Linear Damping", GetLinearDamping, SetLinearDamping, float, 0.0f, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Angular Damping", GetAngularDamping, SetAngularDamping, float, 0.0f, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Allow Sleep", IsAllowSleep, SetAllowSleep, bool, true, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Fixed Rotation", IsFixedRotation, SetFixedRotation, bool, false, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Bullet", IsBullet, SetBullet, bool, false, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Gravity Scale", GetGravityScale, SetGravityScale, float, 1.0f, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Awake", IsAwake, SetAwake, bool, true, AM_DEFAULT);
+    ATOMIC_MIXED_ACCESSOR_ATTRIBUTE("Linear Velocity", GetLinearVelocity, SetLinearVelocity, Vector2, Vector2::ZERO, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Angular Velocity", GetAngularVelocity, SetAngularVelocity, float, 0.0f, AM_DEFAULT);
 }
 
 

Source/Atomic/Atomic2D/RigidBody2D.h

@@ -26,7 +26,7 @@
 
 #include <Box2D/Box2D.h>
 
-namespace Urho3D
+namespace Atomic
 {
 
 class CollisionShape2D;
@@ -42,9 +42,9 @@ enum BodyType2D
 };
 
 /// 2D rigid body component.
-class URHO3D_API RigidBody2D : public Component
+class ATOMIC_API RigidBody2D : public Component
 {
-    URHO3D_OBJECT(RigidBody2D, Component);
+    ATOMIC_OBJECT(RigidBody2D, Component);
 
 public:
     /// Construct.
@@ -155,6 +155,13 @@ public:
     /// Return Box2D body.
     b2Body* GetBody() const { return body_; }
 
+    // ATOMIC BEGIN
+
+    bool GetCastShadows() const { return castShadows_; }
+    void SetCastShadows(bool castShadows) { castShadows_ = castShadows; }
+
+    // ATOMIC END
+
 private:
     /// Handle node being assigned.
     virtual void OnNodeSet(Node* node);
@@ -177,6 +184,10 @@ private:
     Vector<WeakPtr<CollisionShape2D> > collisionShapes_;
     /// Constraints.
     Vector<WeakPtr<Constraint2D> > constraints_;
+
+// ATOMIC BEGIN
+    bool castShadows_;
+// ATOMIC END
 };
 
 }

Source/Atomic/Atomic2D/Sprite2D.cpp

@@ -26,13 +26,13 @@
 #include "../Graphics/Texture2D.h"
 #include "../IO/Deserializer.h"
 #include "../Resource/ResourceCache.h"
-#include "../Urho2D/Drawable2D.h"
-#include "../Urho2D/Sprite2D.h"
-#include "../Urho2D/SpriteSheet2D.h"
+#include "../Atomic2D/Drawable2D.h"
+#include "../Atomic2D/Sprite2D.h"
+#include "../Atomic2D/SpriteSheet2D.h"
 
 #include "../DebugNew.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 Sprite2D::Sprite2D(Context* context) :

Source/Atomic/Atomic2D/Sprite2D.h

@@ -24,16 +24,16 @@
 
 #include "../Resource/Resource.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 class SpriteSheet2D;
 class Texture2D;
 
 /// Sprite.
-class URHO3D_API Sprite2D : public Resource
+class ATOMIC_API Sprite2D : public Resource
 {
-    URHO3D_OBJECT(Sprite2D, Resource);
+    ATOMIC_OBJECT(Sprite2D, Resource);
 
 public:
     /// Construct.

Source/Atomic/Atomic2D/SpriteSheet2D.cpp

@@ -31,12 +31,12 @@
 #include "../Resource/ResourceCache.h"
 #include "../Resource/XMLFile.h"
 #include "../Resource/JSONFile.h"
-#include "../Urho2D/Sprite2D.h"
-#include "../Urho2D/SpriteSheet2D.h"
+#include "../Atomic2D/Sprite2D.h"
+#include "../Atomic2D/SpriteSheet2D.h"
 
 #include "../DebugNew.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 SpriteSheet2D::SpriteSheet2D(Context* context) :
@@ -72,7 +72,7 @@ bool SpriteSheet2D::BeginLoad(Deserializer& source)
         return BeginLoadFromJSONFile(source);
 
 
-    URHO3D_LOGERROR("Unsupported file type");
+    ATOMIC_LOGERROR("Unsupported file type");
     return false;
 }
 
@@ -129,7 +129,7 @@ bool SpriteSheet2D::BeginLoadFromPListFile(Deserializer& source)
     loadPListFile_ = new PListFile(context_);
     if (!loadPListFile_->Load(source))
     {
-        URHO3D_LOGERROR("Could not load sprite sheet");
+        ATOMIC_LOGERROR("Could not load sprite sheet");
         loadPListFile_.Reset();
         return false;
     }
@@ -154,7 +154,7 @@ bool SpriteSheet2D::EndLoadFromPListFile()
     texture_ = cache->GetResource<Texture2D>(loadTextureName_);
     if (!texture_)
     {
-        URHO3D_LOGERROR("Could not load texture " + loadTextureName_);
+        ATOMIC_LOGERROR("Could not load texture " + loadTextureName_);
         loadXMLFile_.Reset();
         loadTextureName_.Clear();
         return false;
@@ -169,7 +169,7 @@ bool SpriteSheet2D::EndLoadFromPListFile()
         const PListValueMap& frameInfo = i->second_.GetValueMap();
         if (frameInfo["rotated"]->GetBool())
         {
-            URHO3D_LOGWARNING("Rotated sprite is not support now");
+            ATOMIC_LOGWARNING("Rotated sprite is not support now");
             continue;
         }
 
@@ -201,7 +201,7 @@ bool SpriteSheet2D::BeginLoadFromXMLFile(Deserializer& source)
     loadXMLFile_ = new XMLFile(context_);
     if (!loadXMLFile_->Load(source))
     {
-        URHO3D_LOGERROR("Could not load sprite sheet");
+        ATOMIC_LOGERROR("Could not load sprite sheet");
         loadXMLFile_.Reset();
         return false;
     }
@@ -211,7 +211,7 @@ bool SpriteSheet2D::BeginLoadFromXMLFile(Deserializer& source)
     XMLElement rootElem = loadXMLFile_->GetRoot("TextureAtlas");
     if (!rootElem)
     {
-        URHO3D_LOGERROR("Invalid sprite sheet");
+        ATOMIC_LOGERROR("Invalid sprite sheet");
         loadXMLFile_.Reset();
         return false;
     }
@@ -230,7 +230,7 @@ bool SpriteSheet2D::EndLoadFromXMLFile()
     texture_ = cache->GetResource<Texture2D>(loadTextureName_);
     if (!texture_)
     {
-        URHO3D_LOGERROR("Could not load texture " + loadTextureName_);
+        ATOMIC_LOGERROR("Could not load texture " + loadTextureName_);
         loadXMLFile_.Reset();
         loadTextureName_.Clear();
         return false;
@@ -275,7 +275,7 @@ bool SpriteSheet2D::BeginLoadFromJSONFile(Deserializer& source)
     loadJSONFile_ = new JSONFile(context_);
     if (!loadJSONFile_->Load(source))
     {
-        URHO3D_LOGERROR("Could not load sprite sheet");
+        ATOMIC_LOGERROR("Could not load sprite sheet");
         loadJSONFile_.Reset();
         return false;
     }
@@ -285,7 +285,7 @@ bool SpriteSheet2D::BeginLoadFromJSONFile(Deserializer& source)
     JSONValue rootElem = loadJSONFile_->GetRoot();
     if (rootElem.IsNull())
     {
-        URHO3D_LOGERROR("Invalid sprite sheet");
+        ATOMIC_LOGERROR("Invalid sprite sheet");
         loadJSONFile_.Reset();
         return false;
     }
@@ -304,7 +304,7 @@ bool SpriteSheet2D::EndLoadFromJSONFile()
     texture_ = cache->GetResource<Texture2D>(loadTextureName_);
     if (!texture_)
     {
-        URHO3D_LOGERROR("Could not load texture " + loadTextureName_);
+        ATOMIC_LOGERROR("Could not load texture " + loadTextureName_);
         loadJSONFile_.Reset();
         loadTextureName_.Clear();
         return false;

Source/Atomic/Atomic2D/SpriteSheet2D.h

@@ -24,7 +24,7 @@
 
 #include "../Resource/Resource.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 class PListFile;
@@ -34,9 +34,9 @@ class XMLFile;
 class JSONFile;
 
 /// Sprite sheet.
-class URHO3D_API SpriteSheet2D : public Resource
+class ATOMIC_API SpriteSheet2D : public Resource
 {
-    URHO3D_OBJECT(SpriteSheet2D, Resource);
+    ATOMIC_OBJECT(SpriteSheet2D, Resource);
 
 public:
     /// Construct.

Source/Atomic/Atomic2D/SpriterData2D.cpp

@@ -23,15 +23,17 @@
 #include "../Precompiled.h"
 
 #include "../Math/MathDefs.h"
-#include "../Urho2D/SpriterData2D.h"
+#include "../Atomic2D/SpriterData2D.h"
 
-#include <PugiXml/pugixml.hpp>
+// ATOMIC BEGIN
+#include <PugiXml/src/pugixml.hpp>
+// ATOMIC END
 
 #include <cstring>
 
 using namespace pugi;
 
-namespace Urho3D
+namespace Atomic
 {
 
 namespace Spriter

Source/Atomic/Atomic2D/SpriterData2D.h

@@ -27,7 +27,7 @@ namespace pugi
 class xml_node;
 }
 
-namespace Urho3D
+namespace Atomic
 {
 
 namespace Spriter

Source/Atomic/Atomic2D/SpriterInstance2D.cpp

@@ -25,11 +25,11 @@
 #include "../Graphics/DrawableEvents.h"
 #include "../Scene/Component.h"
 #include "../Scene/Node.h"
-#include "../Urho2D/SpriterInstance2D.h"
+#include "../Atomic2D/SpriterInstance2D.h"
 
 #include <cmath>
 
-namespace Urho3D
+namespace Atomic
 {
 
 namespace Spriter

Source/Atomic/Atomic2D/SpriterInstance2D.h

@@ -22,9 +22,9 @@
 
 #pragma once
 
-#include "../Urho2D/SpriterData2D.h"
+#include "../Atomic2D/SpriterData2D.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 class Component;

Source/Atomic/Atomic2D/StaticSprite2D.cpp

@@ -27,13 +27,13 @@
 #include "../Graphics/Texture2D.h"
 #include "../Resource/ResourceCache.h"
 #include "../Scene/Scene.h"
-#include "../Urho2D/Renderer2D.h"
-#include "../Urho2D/Sprite2D.h"
-#include "../Urho2D/StaticSprite2D.h"
+#include "../Atomic2D/Renderer2D.h"
+#include "../Atomic2D/Sprite2D.h"
+#include "../Atomic2D/StaticSprite2D.h"
 
 #include "../DebugNew.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 extern const char* URHO2D_CATEGORY;
@@ -60,15 +60,15 @@ void StaticSprite2D::RegisterObject(Context* context)
 {
     context->RegisterFactory<StaticSprite2D>(URHO2D_CATEGORY);
 
-    URHO3D_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
-    URHO3D_COPY_BASE_ATTRIBUTES(Drawable2D);
-    URHO3D_MIXED_ACCESSOR_ATTRIBUTE("Sprite", GetSpriteAttr, SetSpriteAttr, ResourceRef, ResourceRef(Sprite2D::GetTypeStatic()),
+    ATOMIC_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
+    ATOMIC_COPY_BASE_ATTRIBUTES(Drawable2D);
+    ATOMIC_MIXED_ACCESSOR_ATTRIBUTE("Sprite", GetSpriteAttr, SetSpriteAttr, ResourceRef, ResourceRef(Sprite2D::GetTypeStatic()),
         AM_DEFAULT);
-    URHO3D_ENUM_ACCESSOR_ATTRIBUTE("Blend Mode", GetBlendMode, SetBlendMode, BlendMode, blendModeNames, BLEND_ALPHA, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Flip X", GetFlipX, SetFlipX, bool, false, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Flip Y", GetFlipY, SetFlipY, bool, false, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Color", GetColor, SetColor, Color, Color::WHITE, AM_DEFAULT);
-    URHO3D_MIXED_ACCESSOR_ATTRIBUTE("Custom material", GetCustomMaterialAttr, SetCustomMaterialAttr, ResourceRef,
+    ATOMIC_ENUM_ACCESSOR_ATTRIBUTE("Blend Mode", GetBlendMode, SetBlendMode, BlendMode, blendModeNames, BLEND_ALPHA, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Flip X", GetFlipX, SetFlipX, bool, false, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Flip Y", GetFlipY, SetFlipY, bool, false, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Color", GetColor, SetColor, Color, Color::WHITE, AM_DEFAULT);
+    ATOMIC_MIXED_ACCESSOR_ATTRIBUTE("Custom material", GetCustomMaterialAttr, SetCustomMaterialAttr, ResourceRef,
         ResourceRef(Material::GetTypeStatic()), AM_DEFAULT);
 }
 

Source/Atomic/Atomic2D/StaticSprite2D.h

@@ -22,17 +22,17 @@
 
 #pragma once
 
-#include "../Urho2D/Drawable2D.h"
+#include "../Atomic2D/Drawable2D.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 class Sprite2D;
 
 /// Static sprite component.
-class URHO3D_API StaticSprite2D : public Drawable2D
+class ATOMIC_API StaticSprite2D : public Drawable2D
 {
-    URHO3D_OBJECT(StaticSprite2D, Drawable2D);
+    ATOMIC_OBJECT(StaticSprite2D, Drawable2D);
 
 public:
     /// Construct.

Source/Atomic/Atomic2D/TileMap2D.cpp

@@ -27,13 +27,13 @@
 #include "../Resource/ResourceCache.h"
 #include "../Scene/Node.h"
 #include "../Scene/Scene.h"
-#include "../Urho2D/TileMap2D.h"
-#include "../Urho2D/TileMapLayer2D.h"
-#include "../Urho2D/TmxFile2D.h"
+#include "../Atomic2D/TileMap2D.h"
+#include "../Atomic2D/TileMapLayer2D.h"
+#include "../Atomic2D/TmxFile2D.h"
 
 #include "../DebugNew.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 extern const float PIXEL_SIZE;
@@ -52,8 +52,8 @@ void TileMap2D::RegisterObject(Context* context)
 {
     context->RegisterFactory<TileMap2D>(URHO2D_CATEGORY);
 
-    URHO3D_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
-    URHO3D_MIXED_ACCESSOR_ATTRIBUTE("Tmx File", GetTmxFileAttr, SetTmxFileAttr, ResourceRef, ResourceRef(TmxFile2D::GetTypeStatic()),
+    ATOMIC_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
+    ATOMIC_MIXED_ACCESSOR_ATTRIBUTE("Tmx File", GetTmxFileAttr, SetTmxFileAttr, ResourceRef, ResourceRef(TmxFile2D::GetTypeStatic()),
         AM_DEFAULT);
 }
 

Source/Atomic/Atomic2D/TileMap2D.h

@@ -23,18 +23,18 @@
 #pragma once
 
 #include "../Scene/Component.h"
-#include "../Urho2D/TileMapDefs2D.h"
+#include "../Atomic2D/TileMapDefs2D.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 class TileMapLayer2D;
 class TmxFile2D;
 
 /// Tile map component.
-class URHO3D_API TileMap2D : public Component
+class ATOMIC_API TileMap2D : public Component
 {
-    URHO3D_OBJECT(TileMap2D, Component);
+    ATOMIC_OBJECT(TileMap2D, Component);
 
 public:
     /// Construct.

Source/Atomic/Atomic2D/TileMapDefs2D.cpp

@@ -24,13 +24,13 @@
 
 #include "../Resource/XMLElement.h"
 #include "../Resource/JSONFile.h"
-#include "../Urho2D/TileMapDefs2D.h"
+#include "../Atomic2D/TileMapDefs2D.h"
 
 #include "../DebugNew.h"
 
-namespace Urho3D
+namespace Atomic
 {
-extern URHO3D_API const float PIXEL_SIZE;
+extern ATOMIC_API const float PIXEL_SIZE;
 
 float TileMapInfo2D::GetMapWidth() const
 {

Source/Atomic/Atomic2D/TileMapDefs2D.h

@@ -23,9 +23,9 @@
 #pragma once
 
 #include "../Container/RefCounted.h"
-#include "../Urho2D/Sprite2D.h"
+#include "../Atomic2D/Sprite2D.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 class XMLElement;
@@ -44,7 +44,7 @@ enum Orientation2D
 };
 
 /// Tile map information.
-struct URHO3D_API TileMapInfo2D
+struct ATOMIC_API TileMapInfo2D
 {
     /// Orientation.
     Orientation2D orientation_;
@@ -100,7 +100,7 @@ enum TileMapObjectType2D
 };
 
 /// Property set.
-class URHO3D_API PropertySet2D : public RefCounted
+class ATOMIC_API PropertySet2D : public RefCounted
 {
 public:
     PropertySet2D();
@@ -119,7 +119,7 @@ protected:
 };
 
 /// Tile define.
-class URHO3D_API Tile2D : public RefCounted
+class ATOMIC_API Tile2D : public RefCounted
 {
 public:
     /// Construct.
@@ -147,7 +147,7 @@ private:
 };
 
 /// Tile map object.
-class URHO3D_API TileMapObject2D : public RefCounted
+class ATOMIC_API TileMapObject2D : public RefCounted
 {
 public:
     TileMapObject2D();

Source/Atomic/Atomic2D/TileMapLayer2D.cpp

@@ -26,14 +26,14 @@
 #include "../Graphics/DebugRenderer.h"
 #include "../Resource/ResourceCache.h"
 #include "../Scene/Node.h"
-#include "../Urho2D/StaticSprite2D.h"
-#include "../Urho2D/TileMap2D.h"
-#include "../Urho2D/TileMapLayer2D.h"
-#include "../Urho2D/TmxFile2D.h"
+#include "../Atomic2D/StaticSprite2D.h"
+#include "../Atomic2D/TileMap2D.h"
+#include "../Atomic2D/TileMapLayer2D.h"
+#include "../Atomic2D/TmxFile2D.h"
 
 #include "../DebugNew.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 TileMapLayer2D::TileMapLayer2D(Context* context) :

Source/Atomic/Atomic2D/TileMapLayer2D.h

@@ -23,9 +23,9 @@
 #pragma once
 
 #include "../Scene/Component.h"
-#include "../Urho2D/TileMapDefs2D.h"
+#include "../Atomic2D/TileMapDefs2D.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 class DebugRenderer;
@@ -37,9 +37,9 @@ class TmxObjectGroup2D;
 class TmxTileLayer2D;
 
 /// Tile map component.
-class URHO3D_API TileMapLayer2D : public Component
+class ATOMIC_API TileMapLayer2D : public Component
 {
-    URHO3D_OBJECT(TileMapLayer2D, Component);
+    ATOMIC_OBJECT(TileMapLayer2D, Component);
 
 public:
     /// Construct.

Source/Atomic/Atomic2D/TmxFile2D.cpp

@@ -28,12 +28,12 @@
 #include "../IO/Log.h"
 #include "../Resource/ResourceCache.h"
 #include "../Resource/XMLFile.h"
-#include "../Urho2D/Sprite2D.h"
-#include "../Urho2D/TmxFile2D.h"
+#include "../Atomic2D/Sprite2D.h"
+#include "../Atomic2D/TmxFile2D.h"
 
 #include "../DebugNew.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 extern const float PIXEL_SIZE;
@@ -97,13 +97,13 @@ bool TmxTileLayer2D::Load(const XMLElement& element, const TileMapInfo2D& info)
     XMLElement dataElem = element.GetChild("data");
     if (!dataElem)
     {
-        URHO3D_LOGERROR("Could not find data in layer");
+        ATOMIC_LOGERROR("Could not find data in layer");
         return false;
     }
 
     if (dataElem.HasAttribute("encoding") && dataElem.GetAttribute("encoding") != "xml")
     {
-        URHO3D_LOGERROR("Encoding not support now");
+        ATOMIC_LOGERROR("Encoding not support now");
         return false;
     }
 
@@ -270,7 +270,7 @@ bool TmxImageLayer2D::Load(const XMLElement& element, const TileMapInfo2D& info)
     SharedPtr<Texture2D> texture(cache->GetResource<Texture2D>(textureFilePath));
     if (!texture)
     {
-        URHO3D_LOGERROR("Could not load texture " + textureFilePath);
+        ATOMIC_LOGERROR("Could not load texture " + textureFilePath);
         return false;
     }
 
@@ -315,7 +315,7 @@ bool TmxFile2D::BeginLoad(Deserializer& source)
     loadXMLFile_ = new XMLFile(context_);
     if (!loadXMLFile_->Load(source))
     {
-        URHO3D_LOGERROR("Load XML failed " + source.GetName());
+        ATOMIC_LOGERROR("Load XML failed " + source.GetName());
         loadXMLFile_.Reset();
         return false;
     }
@@ -323,7 +323,7 @@ bool TmxFile2D::BeginLoad(Deserializer& source)
     XMLElement rootElem = loadXMLFile_->GetRoot("map");
     if (!rootElem)
     {
-        URHO3D_LOGERROR("Invalid tmx file " + source.GetName());
+        ATOMIC_LOGERROR("Invalid tmx file " + source.GetName());
         loadXMLFile_.Reset();
         return false;
     }
@@ -374,7 +374,7 @@ bool TmxFile2D::EndLoad()
     String version = rootElem.GetAttribute("version");
     if (version != "1.0")
     {
-        URHO3D_LOGERROR("Invalid version");
+        ATOMIC_LOGERROR("Invalid version");
         return false;
     }
 
@@ -389,7 +389,7 @@ bool TmxFile2D::EndLoad()
         info_.orientation_ = O_HEXAGONAL;
     else
     {
-        URHO3D_LOGERROR("Unsupported orientation type " + orientation);
+        ATOMIC_LOGERROR("Unsupported orientation type " + orientation);
         return false;
     }
 
@@ -501,7 +501,7 @@ SharedPtr<XMLFile> TmxFile2D::LoadTSXFile(const String& source)
     SharedPtr<XMLFile> tsxXMLFile(new XMLFile(context_));
     if (!tsxFile || !tsxXMLFile->Load(*tsxFile))
     {
-        URHO3D_LOGERROR("Load TSX file failed " + tsxFilePath);
+        ATOMIC_LOGERROR("Load TSX file failed " + tsxFilePath);
         return SharedPtr<XMLFile>();
     }
 
@@ -540,7 +540,7 @@ bool TmxFile2D::LoadTileSet(const XMLElement& element)
     SharedPtr<Texture2D> texture(cache->GetResource<Texture2D>(textureFilePath));
     if (!texture)
     {
-        URHO3D_LOGERROR("Could not load texture " + textureFilePath);
+        ATOMIC_LOGERROR("Could not load texture " + textureFilePath);
         return false;
     }
 

Source/Atomic/Atomic2D/TmxFile2D.h

@@ -23,9 +23,9 @@
 #pragma once
 
 #include "../Resource/Resource.h"
-#include "../Urho2D/TileMapDefs2D.h"
+#include "../Atomic2D/TileMapDefs2D.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 class Sprite2D;
@@ -151,9 +151,9 @@ private:
 };
 
 /// Tile map file.
-class URHO3D_API TmxFile2D : public Resource
+class ATOMIC_API TmxFile2D : public Resource
 {
-    URHO3D_OBJECT(TmxFile2D, Resource);
+    ATOMIC_OBJECT(TmxFile2D, Resource);
 
 public:
     /// Construct.
@@ -175,7 +175,7 @@ public:
     void AddLayer(unsigned index, TmxLayer2D *layer);
 
     /// Append layer to end.
-    void AddLayer(Urho3D::TmxLayer2D* layer);
+    void AddLayer(Atomic::TmxLayer2D* layer);
 
     /// Return Tilemap information.
     const TileMapInfo2D& GetInfo() const { return info_; }

Source/Atomic/Atomic3D/AnimatedModel.cpp

@@ -44,7 +44,7 @@
 
 #include "../DebugNew.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 extern const char* GEOMETRY_CATEGORY;
@@ -92,24 +92,24 @@ void AnimatedModel::RegisterObject(Context* context)
 {
     context->RegisterFactory<AnimatedModel>(GEOMETRY_CATEGORY);
 
-    URHO3D_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
-    URHO3D_MIXED_ACCESSOR_ATTRIBUTE("Model", GetModelAttr, SetModelAttr, ResourceRef, ResourceRef(Model::GetTypeStatic()), AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Material", GetMaterialsAttr, SetMaterialsAttr, ResourceRefList, ResourceRefList(Material::GetTypeStatic()),
+    ATOMIC_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
+    ATOMIC_MIXED_ACCESSOR_ATTRIBUTE("Model", GetModelAttr, SetModelAttr, ResourceRef, ResourceRef(Model::GetTypeStatic()), AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Material", GetMaterialsAttr, SetMaterialsAttr, ResourceRefList, ResourceRefList(Material::GetTypeStatic()),
         AM_DEFAULT);
-    URHO3D_ATTRIBUTE("Is Occluder", bool, occluder_, false, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Can Be Occluded", IsOccludee, SetOccludee, bool, true, AM_DEFAULT);
-    URHO3D_ATTRIBUTE("Cast Shadows", bool, castShadows_, false, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Update When Invisible", GetUpdateInvisible, SetUpdateInvisible, bool, false, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Draw Distance", GetDrawDistance, SetDrawDistance, float, 0.0f, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Shadow Distance", GetShadowDistance, SetShadowDistance, float, 0.0f, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("LOD Bias", GetLodBias, SetLodBias, float, 1.0f, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Animation LOD Bias", GetAnimationLodBias, SetAnimationLodBias, float, 1.0f, AM_DEFAULT);
-    URHO3D_COPY_BASE_ATTRIBUTES(Drawable);
-    URHO3D_MIXED_ACCESSOR_ATTRIBUTE("Bone Animation Enabled", GetBonesEnabledAttr, SetBonesEnabledAttr, VariantVector,
+    ATOMIC_ATTRIBUTE("Is Occluder", bool, occluder_, false, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Can Be Occluded", IsOccludee, SetOccludee, bool, true, AM_DEFAULT);
+    ATOMIC_ATTRIBUTE("Cast Shadows", bool, castShadows_, false, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Update When Invisible", GetUpdateInvisible, SetUpdateInvisible, bool, false, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Draw Distance", GetDrawDistance, SetDrawDistance, float, 0.0f, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Shadow Distance", GetShadowDistance, SetShadowDistance, float, 0.0f, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("LOD Bias", GetLodBias, SetLodBias, float, 1.0f, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Animation LOD Bias", GetAnimationLodBias, SetAnimationLodBias, float, 1.0f, AM_DEFAULT);
+    ATOMIC_COPY_BASE_ATTRIBUTES(Drawable);
+    ATOMIC_MIXED_ACCESSOR_ATTRIBUTE("Bone Animation Enabled", GetBonesEnabledAttr, SetBonesEnabledAttr, VariantVector,
         Variant::emptyVariantVector, AM_FILE | AM_NOEDIT);
-    URHO3D_MIXED_ACCESSOR_ATTRIBUTE("Animation States", GetAnimationStatesAttr, SetAnimationStatesAttr, VariantVector,
+    ATOMIC_MIXED_ACCESSOR_ATTRIBUTE("Animation States", GetAnimationStatesAttr, SetAnimationStatesAttr, VariantVector,
         Variant::emptyVariantVector, AM_FILE);
-    URHO3D_ACCESSOR_ATTRIBUTE("Morphs", GetMorphsAttr, SetMorphsAttr, PODVector<unsigned char>, Variant::emptyBuffer,
+    ATOMIC_ACCESSOR_ATTRIBUTE("Morphs", GetMorphsAttr, SetMorphsAttr, PODVector<unsigned char>, Variant::emptyBuffer,
         AM_DEFAULT | AM_NOEDIT);
 }
 
@@ -330,7 +330,7 @@ void AnimatedModel::SetModel(Model* model, bool createBones)
 
     if (model)
     {
-        SubscribeToEvent(model, E_RELOADFINISHED, URHO3D_HANDLER(AnimatedModel, HandleModelReloadFinished));
+        SubscribeToEvent(model, E_RELOADFINISHED, ATOMIC_HANDLER(AnimatedModel, HandleModelReloadFinished));
 
         // Copy the subgeometry & LOD level structure
         SetNumGeometries(model->GetNumGeometries());
@@ -422,7 +422,7 @@ AnimationState* AnimatedModel::AddAnimationState(Animation* animation)
 {
     if (!isMaster_)
     {
-        URHO3D_LOGERROR("Can not add animation state to non-master model");
+        ATOMIC_LOGERROR("Can not add animation state to non-master model");
         return 0;
     }
 
@@ -675,7 +675,7 @@ void AnimatedModel::SetSkeleton(const Skeleton& skeleton, bool createBones)
 {
     if (!node_ && createBones)
     {
-        URHO3D_LOGERROR("AnimatedModel not attached to a scene node, can not create bone nodes");
+        ATOMIC_LOGERROR("AnimatedModel not attached to a scene node, can not create bone nodes");
         return;
     }
 

Source/Atomic/Atomic3D/AnimatedModel.h

@@ -26,16 +26,16 @@
 #include "../Graphics/Skeleton.h"
 #include "../Graphics/StaticModel.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 class Animation;
 class AnimationState;
 
 /// Animated model component.
-class URHO3D_API AnimatedModel : public StaticModel
+class ATOMIC_API AnimatedModel : public StaticModel
 {
-    URHO3D_OBJECT(AnimatedModel, StaticModel);
+    ATOMIC_OBJECT(AnimatedModel, StaticModel);
 
     friend class AnimationState;
 

Source/Atomic/Atomic3D/Animation.cpp

@@ -36,7 +36,7 @@
 
 #include "../DebugNew.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 inline bool CompareTriggers(AnimationTriggerPoint& lhs, AnimationTriggerPoint& rhs)
@@ -54,7 +54,7 @@ void AnimationTrack::SetKeyFrame(unsigned index, const AnimationKeyFrame& keyFra
     if (index < keyFrames_.Size())
     {
         keyFrames_[index] = keyFrame;
-        Urho3D::Sort(keyFrames_.Begin(), keyFrames_.End(), CompareKeyFrames);
+        Atomic::Sort(keyFrames_.Begin(), keyFrames_.End(), CompareKeyFrames);
     }
     else if (index == keyFrames_.Size())
         AddKeyFrame(keyFrame);
@@ -65,13 +65,13 @@ void AnimationTrack::AddKeyFrame(const AnimationKeyFrame& keyFrame)
     bool needSort = keyFrames_.Size() ? keyFrames_.Back().time_ > keyFrame.time_ : false;
     keyFrames_.Push(keyFrame);
     if (needSort)
-        Urho3D::Sort(keyFrames_.Begin(), keyFrames_.End(), CompareKeyFrames);
+        Atomic::Sort(keyFrames_.Begin(), keyFrames_.End(), CompareKeyFrames);
 }
 
 void AnimationTrack::InsertKeyFrame(unsigned index, const AnimationKeyFrame& keyFrame)
 {
     keyFrames_.Insert(index, keyFrame);
-    Urho3D::Sort(keyFrames_.Begin(), keyFrames_.End(), CompareKeyFrames);
+    Atomic::Sort(keyFrames_.Begin(), keyFrames_.End(), CompareKeyFrames);
 }
 
 void AnimationTrack::RemoveKeyFrame(unsigned index)
@@ -128,7 +128,7 @@ bool Animation::BeginLoad(Deserializer& source)
     // Check ID
     if (source.ReadFileID() != "UANI")
     {
-        URHO3D_LOGERROR(source.GetName() + " is not a valid animation file");
+        ATOMIC_LOGERROR(source.GetName() + " is not a valid animation file");
         return false;
     }
 
@@ -273,7 +273,7 @@ bool Animation::Save(Serializer& dest) const
             xml->Save(xmlFile);
         }
         else
-            URHO3D_LOGWARNING("Can not save animation trigger data when not saving into a file");
+            ATOMIC_LOGWARNING("Can not save animation trigger data when not saving into a file");
     }
 
     return true;

Source/Atomic/Atomic3D/Animation.h

@@ -27,7 +27,7 @@
 #include "../Math/Vector3.h"
 #include "../Resource/Resource.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 /// Skeletal animation keyframe.
@@ -51,7 +51,7 @@ struct AnimationKeyFrame
 };
 
 /// Skeletal animation track, stores keyframes of a single bone.
-struct URHO3D_API AnimationTrack
+struct ATOMIC_API AnimationTrack
 {
     /// Construct.
     AnimationTrack() :
@@ -107,9 +107,9 @@ static const unsigned char CHANNEL_ROTATION = 0x2;
 static const unsigned char CHANNEL_SCALE = 0x4;
 
 /// Skeletal animation resource.
-class URHO3D_API Animation : public Resource
+class ATOMIC_API Animation : public Resource
 {
-    URHO3D_OBJECT(Animation, Resource);
+    ATOMIC_OBJECT(Animation, Resource);
 
 public:
     /// Construct.

Source/Atomic/Atomic3D/AnimationController.cpp

@@ -36,7 +36,7 @@
 
 #include "../DebugNew.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 static const unsigned char CTRL_LOOPED = 0x1;
@@ -65,12 +65,12 @@ void AnimationController::RegisterObject(Context* context)
 {
     context->RegisterFactory<AnimationController>(LOGIC_CATEGORY);
 
-    URHO3D_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
-    URHO3D_MIXED_ACCESSOR_ATTRIBUTE("Animations", GetAnimationsAttr, SetAnimationsAttr, VariantVector, Variant::emptyVariantVector,
+    ATOMIC_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
+    ATOMIC_MIXED_ACCESSOR_ATTRIBUTE("Animations", GetAnimationsAttr, SetAnimationsAttr, VariantVector, Variant::emptyVariantVector,
         AM_FILE | AM_NOEDIT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Network Animations", GetNetAnimationsAttr, SetNetAnimationsAttr, PODVector<unsigned char>,
+    ATOMIC_ACCESSOR_ATTRIBUTE("Network Animations", GetNetAnimationsAttr, SetNetAnimationsAttr, PODVector<unsigned char>,
         Variant::emptyBuffer, AM_NET | AM_LATESTDATA | AM_NOEDIT);
-    URHO3D_MIXED_ACCESSOR_ATTRIBUTE("Node Animation States", GetNodeAnimationStatesAttr, SetNodeAnimationStatesAttr, VariantVector,
+    ATOMIC_MIXED_ACCESSOR_ATTRIBUTE("Node Animation States", GetNodeAnimationStatesAttr, SetNodeAnimationStatesAttr, VariantVector,
         Variant::emptyVariantVector, AM_FILE | AM_NOEDIT);
 }
 
@@ -80,7 +80,7 @@ void AnimationController::OnSetEnabled()
     if (scene)
     {
         if (IsEnabledEffective())
-            SubscribeToEvent(scene, E_SCENEPOSTUPDATE, URHO3D_HANDLER(AnimationController, HandleScenePostUpdate));
+            SubscribeToEvent(scene, E_SCENEPOSTUPDATE, ATOMIC_HANDLER(AnimationController, HandleScenePostUpdate));
         else
             UnsubscribeFromEvent(scene, E_SCENEPOSTUPDATE);
     }
@@ -613,7 +613,7 @@ void AnimationController::SetNetAnimationsAttr(const PODVector<unsigned char>& v
             state = AddAnimationState(newAnimation);
             if (!state)
             {
-                URHO3D_LOGERROR("Animation update applying aborted due to unknown animation");
+                ATOMIC_LOGERROR("Animation update applying aborted due to unknown animation");
                 return;
             }
         }
@@ -819,7 +819,7 @@ VariantVector AnimationController::GetNodeAnimationStatesAttr() const
 void AnimationController::OnSceneSet(Scene* scene)
 {
     if (scene && IsEnabledEffective())
-        SubscribeToEvent(scene, E_SCENEPOSTUPDATE, URHO3D_HANDLER(AnimationController, HandleScenePostUpdate));
+        SubscribeToEvent(scene, E_SCENEPOSTUPDATE, ATOMIC_HANDLER(AnimationController, HandleScenePostUpdate));
     else if (!scene)
         UnsubscribeFromEvent(E_SCENEPOSTUPDATE);
 }

Source/Atomic/Atomic3D/AnimationController.h

@@ -26,7 +26,7 @@
 #include "../Scene/Component.h"
 #include "../Graphics/AnimationState.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 class AnimatedModel;
@@ -81,9 +81,9 @@ struct AnimationControl
 };
 
 /// %Component that drives an AnimatedModel's animations.
-class URHO3D_API AnimationController : public Component
+class ATOMIC_API AnimationController : public Component
 {
-    URHO3D_OBJECT(AnimationController, Component);
+    ATOMIC_OBJECT(AnimationController, Component);
 
 public:
     /// Construct.

Source/Atomic/Atomic3D/AnimationState.cpp

@@ -30,7 +30,7 @@
 
 #include "../DebugNew.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 AnimationStateTrack::AnimationStateTrack() :
@@ -91,7 +91,7 @@ AnimationState::AnimationState(Node* node, Animation* animation) :
                     if (targetNode)
                         stateTrack.node_ = targetNode;
                     else
-                        URHO3D_LOGWARNING("Node " + i->second_.name_ + " not found for node animation " + animation_->GetName());
+                        ATOMIC_LOGWARNING("Node " + i->second_.name_ + " not found for node animation " + animation_->GetName());
                 }
 
                 if (stateTrack.node_)

Source/Atomic/Atomic3D/AnimationState.h

@@ -25,7 +25,7 @@
 #include "../Container/HashMap.h"
 #include "../Container/Ptr.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 class Animation;
@@ -66,7 +66,7 @@ struct AnimationStateTrack
 };
 
 /// %Animation instance.
-class URHO3D_API AnimationState : public RefCounted
+class ATOMIC_API AnimationState : public RefCounted
 {
 public:
     /// Construct with animated model and animation pointers.

Source/Atomic/Atomic3D/BillboardSet.cpp

@@ -38,7 +38,7 @@
 
 #include "../DebugNew.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 extern const char* GEOMETRY_CATEGORY;
@@ -99,23 +99,23 @@ void BillboardSet::RegisterObject(Context* context)
 {
     context->RegisterFactory<BillboardSet>(GEOMETRY_CATEGORY);
 
-    URHO3D_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
-    URHO3D_MIXED_ACCESSOR_ATTRIBUTE("Material", GetMaterialAttr, SetMaterialAttr, ResourceRef, ResourceRef(Material::GetTypeStatic()),
+    ATOMIC_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
+    ATOMIC_MIXED_ACCESSOR_ATTRIBUTE("Material", GetMaterialAttr, SetMaterialAttr, ResourceRef, ResourceRef(Material::GetTypeStatic()),
         AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Relative Position", IsRelative, SetRelative, bool, true, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Relative Scale", IsScaled, SetScaled, bool, true, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Sort By Distance", IsSorted, SetSorted, bool, false, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Fixed Screen Size", IsFixedScreenSize, SetFixedScreenSize, bool, false, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Can Be Occluded", IsOccludee, SetOccludee, bool, true, AM_DEFAULT);
-    URHO3D_ATTRIBUTE("Cast Shadows", bool, castShadows_, false, AM_DEFAULT);
-    URHO3D_ENUM_ACCESSOR_ATTRIBUTE("Face Camera Mode", GetFaceCameraMode, SetFaceCameraMode, FaceCameraMode, faceCameraModeNames, FC_ROTATE_XYZ, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Draw Distance", GetDrawDistance, SetDrawDistance, float, 0.0f, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Shadow Distance", GetShadowDistance, SetShadowDistance, float, 0.0f, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Animation LOD Bias", GetAnimationLodBias, SetAnimationLodBias, float, 1.0f, AM_DEFAULT);
-    URHO3D_COPY_BASE_ATTRIBUTES(Drawable);
-    URHO3D_MIXED_ACCESSOR_ATTRIBUTE("Billboards", GetBillboardsAttr, SetBillboardsAttr, VariantVector, Variant::emptyVariantVector,
+    ATOMIC_ACCESSOR_ATTRIBUTE("Relative Position", IsRelative, SetRelative, bool, true, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Relative Scale", IsScaled, SetScaled, bool, true, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Sort By Distance", IsSorted, SetSorted, bool, false, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Fixed Screen Size", IsFixedScreenSize, SetFixedScreenSize, bool, false, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Can Be Occluded", IsOccludee, SetOccludee, bool, true, AM_DEFAULT);
+    ATOMIC_ATTRIBUTE("Cast Shadows", bool, castShadows_, false, AM_DEFAULT);
+    ATOMIC_ENUM_ACCESSOR_ATTRIBUTE("Face Camera Mode", GetFaceCameraMode, SetFaceCameraMode, FaceCameraMode, faceCameraModeNames, FC_ROTATE_XYZ, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Draw Distance", GetDrawDistance, SetDrawDistance, float, 0.0f, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Shadow Distance", GetShadowDistance, SetShadowDistance, float, 0.0f, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Animation LOD Bias", GetAnimationLodBias, SetAnimationLodBias, float, 1.0f, AM_DEFAULT);
+    ATOMIC_COPY_BASE_ATTRIBUTES(Drawable);
+    ATOMIC_MIXED_ACCESSOR_ATTRIBUTE("Billboards", GetBillboardsAttr, SetBillboardsAttr, VariantVector, Variant::emptyVariantVector,
         AM_FILE);
-    URHO3D_ACCESSOR_ATTRIBUTE("Network Billboards", GetNetBillboardsAttr, SetNetBillboardsAttr, PODVector<unsigned char>,
+    ATOMIC_ACCESSOR_ATTRIBUTE("Network Billboards", GetNetBillboardsAttr, SetNetBillboardsAttr, PODVector<unsigned char>,
         Variant::emptyBuffer, AM_NET | AM_NOEDIT);
 }
 

Source/Atomic/Atomic3D/BillboardSet.h

@@ -28,14 +28,14 @@
 #include "../Math/Matrix3x4.h"
 #include "../Math/Rect.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 class IndexBuffer;
 class VertexBuffer;
 
 /// One billboard in the billboard set.
-struct URHO3D_API Billboard
+struct ATOMIC_API Billboard
 {
     /// Position.
     Vector3 position_;
@@ -60,9 +60,9 @@ struct URHO3D_API Billboard
 static const unsigned MAX_BILLBOARDS = 65536 / 4;
 
 /// %Billboard component.
-class URHO3D_API BillboardSet : public Drawable
+class ATOMIC_API BillboardSet : public Drawable
 {
-    URHO3D_OBJECT(BillboardSet, Drawable);
+    ATOMIC_OBJECT(BillboardSet, Drawable);
 
 public:
     /// Construct.

Source/Atomic/Atomic3D/CustomGeometry.cpp

@@ -39,7 +39,7 @@
 
 #include "../DebugNew.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 extern const char* GEOMETRY_CATEGORY;
@@ -64,19 +64,19 @@ void CustomGeometry::RegisterObject(Context* context)
 {
     context->RegisterFactory<CustomGeometry>(GEOMETRY_CATEGORY);
 
-    URHO3D_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
-    URHO3D_ATTRIBUTE("Dynamic Vertex Buffer", bool, dynamic_, false, AM_DEFAULT);
-    URHO3D_MIXED_ACCESSOR_ATTRIBUTE("Geometry Data", GetGeometryDataAttr, SetGeometryDataAttr, PODVector<unsigned char>,
+    ATOMIC_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
+    ATOMIC_ATTRIBUTE("Dynamic Vertex Buffer", bool, dynamic_, false, AM_DEFAULT);
+    ATOMIC_MIXED_ACCESSOR_ATTRIBUTE("Geometry Data", GetGeometryDataAttr, SetGeometryDataAttr, PODVector<unsigned char>,
         Variant::emptyBuffer, AM_FILE | AM_NOEDIT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Materials", GetMaterialsAttr, SetMaterialsAttr, ResourceRefList, ResourceRefList(Material::GetTypeStatic()),
+    ATOMIC_ACCESSOR_ATTRIBUTE("Materials", GetMaterialsAttr, SetMaterialsAttr, ResourceRefList, ResourceRefList(Material::GetTypeStatic()),
         AM_DEFAULT);
-    URHO3D_ATTRIBUTE("Is Occluder", bool, occluder_, false, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Can Be Occluded", IsOccludee, SetOccludee, bool, true, AM_DEFAULT);
-    URHO3D_ATTRIBUTE("Cast Shadows", bool, castShadows_, false, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Draw Distance", GetDrawDistance, SetDrawDistance, float, 0.0f, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Shadow Distance", GetShadowDistance, SetShadowDistance, float, 0.0f, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("LOD Bias", GetLodBias, SetLodBias, float, 1.0f, AM_DEFAULT);
-    URHO3D_COPY_BASE_ATTRIBUTES(Drawable);
+    ATOMIC_ATTRIBUTE("Is Occluder", bool, occluder_, false, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Can Be Occluded", IsOccludee, SetOccludee, bool, true, AM_DEFAULT);
+    ATOMIC_ATTRIBUTE("Cast Shadows", bool, castShadows_, false, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Draw Distance", GetDrawDistance, SetDrawDistance, float, 0.0f, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Shadow Distance", GetShadowDistance, SetShadowDistance, float, 0.0f, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("LOD Bias", GetLodBias, SetLodBias, float, 1.0f, AM_DEFAULT);
+    ATOMIC_COPY_BASE_ATTRIBUTES(Drawable);
 }
 
 void CustomGeometry::ProcessRayQuery(const RayOctreeQuery& query, PODVector<RayQueryResult>& results)
@@ -132,7 +132,7 @@ void CustomGeometry::ProcessRayQuery(const RayOctreeQuery& query, PODVector<RayQ
         break;
 
     case RAY_TRIANGLE_UV:
-        URHO3D_LOGWARNING("RAY_TRIANGLE_UV query level is not supported for CustomGeometry component");
+        ATOMIC_LOGWARNING("RAY_TRIANGLE_UV query level is not supported for CustomGeometry component");
         break;
     }
 }
@@ -242,7 +242,7 @@ void CustomGeometry::BeginGeometry(unsigned index, PrimitiveType type)
 {
     if (index > geometries_.Size())
     {
-        URHO3D_LOGERROR("Geometry index out of bounds");
+        ATOMIC_LOGERROR("Geometry index out of bounds");
         return;
     }
 
@@ -305,7 +305,7 @@ void CustomGeometry::DefineGeometry(unsigned index, PrimitiveType type, unsigned
 {
     if (index > geometries_.Size())
     {
-        URHO3D_LOGERROR("Geometry index out of bounds");
+        ATOMIC_LOGERROR("Geometry index out of bounds");
         return;
     }
 
@@ -328,7 +328,7 @@ void CustomGeometry::DefineGeometry(unsigned index, PrimitiveType type, unsigned
 
 void CustomGeometry::Commit()
 {
-    URHO3D_PROFILE(CommitCustomGeometry);
+    ATOMIC_PROFILE(CommitCustomGeometry);
 
     unsigned totalVertices = 0;
     boundingBox_.Clear();
@@ -397,7 +397,7 @@ void CustomGeometry::Commit()
             vertexBuffer_->Unlock();
         }
         else
-            URHO3D_LOGERROR("Failed to lock custom geometry vertex buffer");
+            ATOMIC_LOGERROR("Failed to lock custom geometry vertex buffer");
     }
     else
     {
@@ -423,7 +423,7 @@ bool CustomGeometry::SetMaterial(unsigned index, Material* material)
 {
     if (index >= batches_.Size())
     {
-        URHO3D_LOGERROR("Material index out of bounds");
+        ATOMIC_LOGERROR("Material index out of bounds");
         return false;
     }
 

Source/Atomic/Atomic3D/CustomGeometry.h

@@ -24,7 +24,7 @@
 
 #include "../Graphics/Drawable.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 /// Custom geometry vertex.
@@ -45,9 +45,9 @@ struct CustomGeometryVertex
 class VertexBuffer;
 
 /// Custom geometry component.
-class URHO3D_API CustomGeometry : public Drawable
+class ATOMIC_API CustomGeometry : public Drawable
 {
-    URHO3D_OBJECT(CustomGeometry, Drawable);
+    ATOMIC_OBJECT(CustomGeometry, Drawable);
 
 public:
     /// Construct.

Source/Atomic/Atomic3D/DecalSet.cpp

@@ -46,7 +46,7 @@
 #pragma warning(disable:6293)
 #endif
 
-namespace Urho3D
+namespace Atomic
 {
 
 extern const char* GEOMETRY_CATEGORY;
@@ -183,15 +183,15 @@ void DecalSet::RegisterObject(Context* context)
 {
     context->RegisterFactory<DecalSet>(GEOMETRY_CATEGORY);
 
-    URHO3D_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
-    URHO3D_MIXED_ACCESSOR_ATTRIBUTE("Material", GetMaterialAttr, SetMaterialAttr, ResourceRef, ResourceRef(Material::GetTypeStatic()),
+    ATOMIC_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
+    ATOMIC_MIXED_ACCESSOR_ATTRIBUTE("Material", GetMaterialAttr, SetMaterialAttr, ResourceRef, ResourceRef(Material::GetTypeStatic()),
         AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Max Vertices", GetMaxVertices, SetMaxVertices, unsigned, DEFAULT_MAX_VERTICES, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Max Indices", GetMaxIndices, SetMaxIndices, unsigned, DEFAULT_MAX_INDICES, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Can Be Occluded", IsOccludee, SetOccludee, bool, true, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Draw Distance", GetDrawDistance, SetDrawDistance, float, 0.0f, AM_DEFAULT);
-    URHO3D_COPY_BASE_ATTRIBUTES(Drawable);
-    URHO3D_MIXED_ACCESSOR_ATTRIBUTE("Decals", GetDecalsAttr, SetDecalsAttr, PODVector<unsigned char>, Variant::emptyBuffer,
+    ATOMIC_ACCESSOR_ATTRIBUTE("Max Vertices", GetMaxVertices, SetMaxVertices, unsigned, DEFAULT_MAX_VERTICES, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Max Indices", GetMaxIndices, SetMaxIndices, unsigned, DEFAULT_MAX_INDICES, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Can Be Occluded", IsOccludee, SetOccludee, bool, true, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Draw Distance", GetDrawDistance, SetDrawDistance, float, 0.0f, AM_DEFAULT);
+    ATOMIC_COPY_BASE_ATTRIBUTES(Drawable);
+    ATOMIC_MIXED_ACCESSOR_ATTRIBUTE("Decals", GetDecalsAttr, SetDecalsAttr, PODVector<unsigned char>, Variant::emptyBuffer,
         AM_FILE | AM_NOEDIT);
 }
 
@@ -293,7 +293,7 @@ bool DecalSet::AddDecal(Drawable* target, const Vector3& worldPosition, const Qu
     float aspectRatio, float depth, const Vector2& topLeftUV, const Vector2& bottomRightUV, float timeToLive, float normalCutoff,
     unsigned subGeometry)
 {
-    URHO3D_PROFILE(AddDecal);
+    ATOMIC_PROFILE(AddDecal);
 
     // Do not add decals in headless mode
     if (!node_ || !GetSubsystem<Graphics>())
@@ -301,7 +301,7 @@ bool DecalSet::AddDecal(Drawable* target, const Vector3& worldPosition, const Qu
 
     if (!target || !target->GetNode())
     {
-        URHO3D_LOGERROR("Null target drawable for decal");
+        ATOMIC_LOGERROR("Null target drawable for decal");
         return false;
     }
 
@@ -426,14 +426,14 @@ bool DecalSet::AddDecal(Drawable* target, const Vector3& worldPosition, const Qu
 
     if (newDecal.vertices_.Size() > maxVertices_)
     {
-        URHO3D_LOGWARNING("Can not add decal, vertex count " + String(newDecal.vertices_.Size()) + " exceeds maximum " +
+        ATOMIC_LOGWARNING("Can not add decal, vertex count " + String(newDecal.vertices_.Size()) + " exceeds maximum " +
                    String(maxVertices_));
         decals_.Pop();
         return false;
     }
     if (newDecal.indices_.Size() > maxIndices_)
     {
-        URHO3D_LOGWARNING("Can not add decal, index count " + String(newDecal.indices_.Size()) + " exceeds maximum " +
+        ATOMIC_LOGWARNING("Can not add decal, index count " + String(newDecal.indices_.Size()) + " exceeds maximum " +
                    String(maxIndices_));
         decals_.Pop();
         return false;
@@ -463,7 +463,7 @@ bool DecalSet::AddDecal(Drawable* target, const Vector3& worldPosition, const Qu
     while (decals_.Size() && (numVertices_ > maxVertices_ || numIndices_ > maxIndices_))
         RemoveDecals(1);
 
-    URHO3D_LOGDEBUG("Added decal with " + String(newDecal.vertices_.Size()) + " vertices");
+    ATOMIC_LOGDEBUG("Added decal with " + String(newDecal.vertices_.Size()) + " vertices");
 
     // If new decal is time limited, subscribe to scene post-update
     if (newDecal.timeToLive_ > 0.0f && !subscribed_)
@@ -747,7 +747,7 @@ void DecalSet::GetFaces(Vector<PODVector<DecalVertex> >& faces, Drawable* target
         geometry->GetRawData(positionData, positionStride, indexData, indexStride, elements);
         if (!positionData)
         {
-            URHO3D_LOGWARNING("Can not add decal, target drawable has no CPU-side geometry data");
+            ATOMIC_LOGWARNING("Can not add decal, target drawable has no CPU-side geometry data");
             return;
         }
     }
@@ -896,7 +896,7 @@ bool DecalSet::GetBones(Drawable* target, unsigned batchIndex, const float* blen
 
             if (!bone)
             {
-                URHO3D_LOGWARNING("Out of range bone index for skinned decal");
+                ATOMIC_LOGWARNING("Out of range bone index for skinned decal");
                 return false;
             }
 
@@ -921,7 +921,7 @@ bool DecalSet::GetBones(Drawable* target, unsigned batchIndex, const float* blen
             {
                 if (bones_.Size() >= Graphics::GetMaxBones())
                 {
-                    URHO3D_LOGWARNING("Maximum skinned decal bone count reached");
+                    ATOMIC_LOGWARNING("Maximum skinned decal bone count reached");
                     return false;
                 }
                 else
@@ -1139,7 +1139,7 @@ void DecalSet::UpdateEventSubscription(bool checkAllDecals)
 
     if (enabled && !subscribed_)
     {
-        SubscribeToEvent(scene, E_SCENEPOSTUPDATE, URHO3D_HANDLER(DecalSet, HandleScenePostUpdate));
+        SubscribeToEvent(scene, E_SCENEPOSTUPDATE, ATOMIC_HANDLER(DecalSet, HandleScenePostUpdate));
         subscribed_ = true;
     }
     else if (!enabled && subscribed_)

Source/Atomic/Atomic3D/DecalSet.h

@@ -27,7 +27,7 @@
 #include "../Graphics/Skeleton.h"
 #include "../Math/Frustum.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 class IndexBuffer;
@@ -102,9 +102,9 @@ struct Decal
 };
 
 /// %Decal renderer component.
-class URHO3D_API DecalSet : public Drawable
+class ATOMIC_API DecalSet : public Drawable
 {
-    URHO3D_OBJECT(DecalSet, Drawable);
+    ATOMIC_OBJECT(DecalSet, Drawable);
 
 public:
     /// Construct.

Source/Atomic/Atomic3D/LMStaticModel.h

@@ -13,7 +13,7 @@ namespace Atomic
 
 class LMStaticModel: public StaticModel
 {
-    OBJECT(LMStaticModel);
+    ATOMIC_OBJECT(LMStaticModel, StaticModel);
 
 public:
     /// Construct.

Source/Atomic/Atomic3D/Model.cpp

@@ -34,7 +34,7 @@
 
 #include "../DebugNew.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 unsigned LookupVertexBuffer(VertexBuffer* buffer, const Vector<SharedPtr<VertexBuffer> >& buffers)
@@ -77,7 +77,7 @@ bool Model::BeginLoad(Deserializer& source)
     String fileID = source.ReadFileID();
     if (fileID != "UMDL" && fileID != "UMD2")
     {
-        URHO3D_LOGERROR(source.GetName() + " is not a valid model file");
+        ATOMIC_LOGERROR(source.GetName() + " is not a valid model file");
         return false;
     }
 
@@ -218,7 +218,7 @@ bool Model::BeginLoad(Deserializer& source)
 
             if (vbRef >= vertexBuffers_.Size())
             {
-                URHO3D_LOGERROR("Vertex buffer index out of bounds");
+                ATOMIC_LOGERROR("Vertex buffer index out of bounds");
                 loadVBData_.Clear();
                 loadIBData_.Clear();
                 loadGeometries_.Clear();
@@ -226,7 +226,7 @@ bool Model::BeginLoad(Deserializer& source)
             }
             if (ibRef >= indexBuffers_.Size())
             {
-                URHO3D_LOGERROR("Index buffer index out of bounds");
+                ATOMIC_LOGERROR("Index buffer index out of bounds");
                 loadVBData_.Clear();
                 loadIBData_.Clear();
                 loadGeometries_.Clear();
@@ -468,12 +468,12 @@ bool Model::SetVertexBuffers(const Vector<SharedPtr<VertexBuffer> >& buffers, co
     {
         if (!buffers[i])
         {
-            URHO3D_LOGERROR("Null model vertex buffers specified");
+            ATOMIC_LOGERROR("Null model vertex buffers specified");
             return false;
         }
         if (!buffers[i]->IsShadowed())
         {
-            URHO3D_LOGERROR("Model vertex buffers must be shadowed");
+            ATOMIC_LOGERROR("Model vertex buffers must be shadowed");
             return false;
         }
     }
@@ -498,12 +498,12 @@ bool Model::SetIndexBuffers(const Vector<SharedPtr<IndexBuffer> >& buffers)
     {
         if (!buffers[i])
         {
-            URHO3D_LOGERROR("Null model index buffers specified");
+            ATOMIC_LOGERROR("Null model index buffers specified");
             return false;
         }
         if (!buffers[i]->IsShadowed())
         {
-            URHO3D_LOGERROR("Model index buffers must be shadowed");
+            ATOMIC_LOGERROR("Model index buffers must be shadowed");
             return false;
         }
     }
@@ -530,12 +530,12 @@ bool Model::SetNumGeometryLodLevels(unsigned index, unsigned num)
 {
     if (index >= geometries_.Size())
     {
-        URHO3D_LOGERROR("Geometry index out of bounds");
+        ATOMIC_LOGERROR("Geometry index out of bounds");
         return false;
     }
     if (!num)
     {
-        URHO3D_LOGERROR("Zero LOD levels not allowed");
+        ATOMIC_LOGERROR("Zero LOD levels not allowed");
         return false;
     }
 
@@ -547,12 +547,12 @@ bool Model::SetGeometry(unsigned index, unsigned lodLevel, Geometry* geometry)
 {
     if (index >= geometries_.Size())
     {
-        URHO3D_LOGERROR("Geometry index out of bounds");
+        ATOMIC_LOGERROR("Geometry index out of bounds");
         return false;
     }
     if (lodLevel >= geometries_[index].Size())
     {
-        URHO3D_LOGERROR("LOD level index out of bounds");
+        ATOMIC_LOGERROR("LOD level index out of bounds");
         return false;
     }
 
@@ -564,7 +564,7 @@ bool Model::SetGeometryCenter(unsigned index, const Vector3& center)
 {
     if (index >= geometryCenters_.Size())
     {
-        URHO3D_LOGERROR("Geometry index out of bounds");
+        ATOMIC_LOGERROR("Geometry index out of bounds");
         return false;
     }
 
@@ -620,7 +620,7 @@ SharedPtr<Model> Model::Clone(const String& cloneName) const
                 if (origData)
                     cloneBuffer->SetData(origData);
                 else
-                    URHO3D_LOGERROR("Failed to lock original vertex buffer for copying");
+                    ATOMIC_LOGERROR("Failed to lock original vertex buffer for copying");
             }
             vbMapping[origBuffer] = cloneBuffer;
         }
@@ -648,7 +648,7 @@ SharedPtr<Model> Model::Clone(const String& cloneName) const
                 if (origData)
                     cloneBuffer->SetData(origData);
                 else
-                    URHO3D_LOGERROR("Failed to lock original index buffer for copying");
+                    ATOMIC_LOGERROR("Failed to lock original index buffer for copying");
             }
             ibMapping[origBuffer] = cloneBuffer;
         }

Source/Atomic/Atomic3D/Model.h

@@ -29,7 +29,7 @@
 #include "../Math/BoundingBox.h"
 #include "../Resource/Resource.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 class Geometry;
@@ -105,9 +105,9 @@ struct GeometryDesc
 };
 
 /// 3D model resource.
-class URHO3D_API Model : public Resource
+class ATOMIC_API Model : public Resource
 {
-    URHO3D_OBJECT(Model, Resource);
+    ATOMIC_OBJECT(Model, Resource);
 
 public:
     /// Construct.

Source/Atomic/Atomic3D/ParticleEffect.cpp

@@ -33,7 +33,7 @@
 
 #include "../DebugNew.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 extern const char* faceCameraModeNames[];
@@ -104,7 +104,7 @@ bool ParticleEffect::BeginLoad(Deserializer& source)
     XMLFile file(context_);
     if (!file.Load(source))
     {
-        URHO3D_LOGERROR("Load particle effect file failed");
+        ATOMIC_LOGERROR("Load particle effect file failed");
         return false;
     }
 
@@ -167,7 +167,7 @@ bool ParticleEffect::Load(const XMLElement& source)
 
     if (source.IsNull())
     {
-        URHO3D_LOGERROR("Can not load particle effect from null XML element");
+        ATOMIC_LOGERROR("Can not load particle effect from null XML element");
         return false;
     }
 
@@ -329,7 +329,7 @@ bool ParticleEffect::Save(XMLElement& dest) const
 {
     if (dest.IsNull())
     {
-        URHO3D_LOGERROR("Can not save particle effect to null XML element");
+        ATOMIC_LOGERROR("Can not save particle effect to null XML element");
         return false;
     }
 

Source/Atomic/Atomic3D/ParticleEffect.h

@@ -25,7 +25,7 @@
 #include "../Graphics/GraphicsDefs.h"
 #include "../Resource/Resource.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 /// Particle emitter shapes.
@@ -100,9 +100,9 @@ class XMLFile;
 class XMLElement;
 
 /// %Particle effect definition.
-class URHO3D_API ParticleEffect : public Resource
+class ATOMIC_API ParticleEffect : public Resource
 {
-    URHO3D_OBJECT(ParticleEffect, Resource);
+    ATOMIC_OBJECT(ParticleEffect, Resource);
 
 public:
     /// Construct.

Source/Atomic/Atomic3D/ParticleEmitter.cpp

@@ -34,7 +34,7 @@
 
 #include "../DebugNew.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 extern const char* GEOMETRY_CATEGORY;
@@ -63,23 +63,23 @@ void ParticleEmitter::RegisterObject(Context* context)
 {
     context->RegisterFactory<ParticleEmitter>(GEOMETRY_CATEGORY);
 
-    URHO3D_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
-    URHO3D_MIXED_ACCESSOR_ATTRIBUTE("Effect", GetEffectAttr, SetEffectAttr, ResourceRef, ResourceRef(ParticleEffect::GetTypeStatic()),
+    ATOMIC_ACCESSOR_ATTRIBUTE("Is Enabled", IsEnabled, SetEnabled, bool, true, AM_DEFAULT);
+    ATOMIC_MIXED_ACCESSOR_ATTRIBUTE("Effect", GetEffectAttr, SetEffectAttr, ResourceRef, ResourceRef(ParticleEffect::GetTypeStatic()),
         AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Can Be Occluded", IsOccludee, SetOccludee, bool, true, AM_DEFAULT);
-    URHO3D_ATTRIBUTE("Cast Shadows", bool, castShadows_, false, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Draw Distance", GetDrawDistance, SetDrawDistance, float, 0.0f, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Shadow Distance", GetShadowDistance, SetShadowDistance, float, 0.0f, AM_DEFAULT);
-    URHO3D_ACCESSOR_ATTRIBUTE("Animation LOD Bias", GetAnimationLodBias, SetAnimationLodBias, float, 1.0f, AM_DEFAULT);
-    URHO3D_ATTRIBUTE("Is Emitting", bool, emitting_, true, AM_FILE);
-    URHO3D_ATTRIBUTE("Period Timer", float, periodTimer_, 0.0f, AM_FILE | AM_NOEDIT);
-    URHO3D_ATTRIBUTE("Emission Timer", float, emissionTimer_, 0.0f, AM_FILE | AM_NOEDIT);
-    URHO3D_COPY_BASE_ATTRIBUTES(Drawable);
-    URHO3D_MIXED_ACCESSOR_ATTRIBUTE("Particles", GetParticlesAttr, SetParticlesAttr, VariantVector, Variant::emptyVariantVector,
+    ATOMIC_ACCESSOR_ATTRIBUTE("Can Be Occluded", IsOccludee, SetOccludee, bool, true, AM_DEFAULT);
+    ATOMIC_ATTRIBUTE("Cast Shadows", bool, castShadows_, false, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Draw Distance", GetDrawDistance, SetDrawDistance, float, 0.0f, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Shadow Distance", GetShadowDistance, SetShadowDistance, float, 0.0f, AM_DEFAULT);
+    ATOMIC_ACCESSOR_ATTRIBUTE("Animation LOD Bias", GetAnimationLodBias, SetAnimationLodBias, float, 1.0f, AM_DEFAULT);
+    ATOMIC_ATTRIBUTE("Is Emitting", bool, emitting_, true, AM_FILE);
+    ATOMIC_ATTRIBUTE("Period Timer", float, periodTimer_, 0.0f, AM_FILE | AM_NOEDIT);
+    ATOMIC_ATTRIBUTE("Emission Timer", float, emissionTimer_, 0.0f, AM_FILE | AM_NOEDIT);
+    ATOMIC_COPY_BASE_ATTRIBUTES(Drawable);
+    ATOMIC_MIXED_ACCESSOR_ATTRIBUTE("Particles", GetParticlesAttr, SetParticlesAttr, VariantVector, Variant::emptyVariantVector,
         AM_FILE | AM_NOEDIT);
-    URHO3D_MIXED_ACCESSOR_ATTRIBUTE("Billboards", GetParticleBillboardsAttr, SetBillboardsAttr, VariantVector, Variant::emptyVariantVector,
+    ATOMIC_MIXED_ACCESSOR_ATTRIBUTE("Billboards", GetParticleBillboardsAttr, SetBillboardsAttr, VariantVector, Variant::emptyVariantVector,
         AM_FILE | AM_NOEDIT);
-    URHO3D_ATTRIBUTE("Serialize Particles", bool, serializeParticles_, true, AM_FILE);
+    ATOMIC_ATTRIBUTE("Serialize Particles", bool, serializeParticles_, true, AM_FILE);
 }
 
 void ParticleEmitter::OnSetEnabled()
@@ -90,7 +90,7 @@ void ParticleEmitter::OnSetEnabled()
     if (scene)
     {
         if (IsEnabledEffective())
-            SubscribeToEvent(scene, E_SCENEPOSTUPDATE, URHO3D_HANDLER(ParticleEmitter, HandleScenePostUpdate));
+            SubscribeToEvent(scene, E_SCENEPOSTUPDATE, ATOMIC_HANDLER(ParticleEmitter, HandleScenePostUpdate));
         else
             UnsubscribeFromEvent(scene, E_SCENEPOSTUPDATE);
     }
@@ -272,7 +272,7 @@ void ParticleEmitter::SetEffect(ParticleEffect* effect)
     effect_ = effect;
 
     if (effect_)
-        SubscribeToEvent(effect_, E_RELOADFINISHED, URHO3D_HANDLER(ParticleEmitter, HandleEffectReloadFinished));
+        SubscribeToEvent(effect_, E_RELOADFINISHED, ATOMIC_HANDLER(ParticleEmitter, HandleEffectReloadFinished));
 
     ApplyEffect();
     MarkNetworkUpdate();
@@ -432,7 +432,7 @@ void ParticleEmitter::OnSceneSet(Scene* scene)
     BillboardSet::OnSceneSet(scene);
 
     if (scene && IsEnabledEffective())
-        SubscribeToEvent(scene, E_SCENEPOSTUPDATE, URHO3D_HANDLER(ParticleEmitter, HandleScenePostUpdate));
+        SubscribeToEvent(scene, E_SCENEPOSTUPDATE, ATOMIC_HANDLER(ParticleEmitter, HandleScenePostUpdate));
     else if (!scene)
          UnsubscribeFromEvent(E_SCENEPOSTUPDATE);
 }

Source/Atomic/Atomic3D/ParticleEmitter.h

@@ -24,7 +24,7 @@
 
 #include "../Graphics/BillboardSet.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 class ParticleEffect;
@@ -51,9 +51,9 @@ struct Particle
 };
 
 /// %Particle emitter component.
-class URHO3D_API ParticleEmitter : public BillboardSet
+class ATOMIC_API ParticleEmitter : public BillboardSet
 {
-    URHO3D_OBJECT(ParticleEmitter, BillboardSet);
+    ATOMIC_OBJECT(ParticleEmitter, BillboardSet);
 
 public:
     /// Construct.

Source/Atomic/Atomic3D/Skeleton.cpp

@@ -27,7 +27,7 @@
 
 #include "../DebugNew.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 Skeleton::Skeleton() :
@@ -119,7 +119,7 @@ void Skeleton::SetRootBoneIndex(unsigned index)
     if (index < bones_.Size())
         rootBoneIndex_ = index;
     else
-        URHO3D_LOGERROR("Root bone index out of bounds");
+        ATOMIC_LOGERROR("Root bone index out of bounds");
 }
 
 void Skeleton::ClearBones()

Source/Atomic/Atomic3D/Skeleton.h

@@ -25,7 +25,7 @@
 #include "../Math/BoundingBox.h"
 #include "../Scene/Node.h"
 
-namespace Urho3D
+namespace Atomic
 {
 
 static const unsigned BONECOLLISION_NONE = 0x0;
@@ -78,7 +78,7 @@ struct Bone
 };
 
 /// Hierarchical collection of bones.
-class URHO3D_API Skeleton
+class ATOMIC_API Skeleton
 {
 public:
     /// Construct an empty skeleton.