Add Lua binding and AngelScript Binding.[ci skip]

Source/Engine/LuaScript/pkgs/Urho2D/CollisionBox2D.pkg

@@ -0,0 +1,18 @@
+$#include "CollisionBox2D.h"
+
+class CollisionBox2D : CollisionShape2D
+{
+    void SetSize(const Vector2& size);
+    void SetSize(float width, float height);
+    void SetCenter(const Vector2& center);
+    void SetCenter(float x, float y);
+    void SetAngle(float angle);
+
+    const Vector2& GetSize() const;
+    const Vector2& GetCenter() const;
+    float GetAngle() const;
+
+    tolua_property__get_set Vector2& size;
+    tolua_property__get_set Vector2& center;
+    tolua_property__get_set float angle;
+};

Source/Engine/LuaScript/pkgs/Urho2D/CollisionCircle2D.pkg

@@ -0,0 +1,14 @@
+$#include "CollisionCircle2D.h"
+
+class CollisionCircle2D : CollisionShape2D
+{
+    void SetRadius(float radius);
+    void SetCenter(const Vector2& center);
+    void SetCenter(float x, float y);
+
+    float GetRadius() const;
+    const Vector2& GetCenter() const;
+
+    tolua_property__get_set float radius;
+    tolua_property__get_set Vector2& center;
+};

Source/Engine/LuaScript/pkgs/Urho2D/CollisionShape2D.pkg

@@ -3,17 +3,17 @@ $#include "CollisionShape2D.h"
 class CollisionShape2D : Component
 {
     void SetSensor(bool sensor);
-    void SetCategoryBits(unsigned short categoryBits);
-    void SetMaskBits(unsigned short maskBits);
-    void SetGroupIndex(short groupIndex);
+    void SetCategoryBits(int categoryBits);
+    void SetMaskBits(int maskBits);
+    void SetGroupIndex(int groupIndex);
     void SetDensity(float density);
     void SetFriction(float friction);
     void SetRestitution(float restitution);
 
     bool IsSensor() const;
-    unsigned short GetCategoryBits() const;
-    unsigned short GetMaskBits() const;
-    short GetGroupIndex() const;
+    int GetCategoryBits() const;
+    int GetMaskBits() const;
+    int GetGroupIndex() const;
     float GetDensity() const;
     float GetFriction() const;
     float GetRestitution() const;
@@ -22,9 +22,9 @@ class CollisionShape2D : Component
     Vector2 GetMassCenter() const;
 
     tolua_property__is_set bool sensor;
-    tolua_property__get_set unsigned short categoryBits;
-    tolua_property__get_set unsigned short maskBits;
-    tolua_property__get_set short groupIndex;
+    tolua_property__get_set int categoryBits;
+    tolua_property__get_set int maskBits;
+    tolua_property__get_set int groupIndex;
     tolua_property__get_set float density;
     tolua_property__get_set float friction;
     tolua_property__get_set float restitution;

Source/Engine/LuaScript/pkgs/Urho2D/PhysicsWorld2D.pkg

@@ -1,6 +1,6 @@
 $#include "PhysicsWorld2D.h"
 
-class PhysicsWorld2D : public Component
+class PhysicsWorld2D : Component
 {
     void SetDrawShape(bool drawShape);
     void SetDrawJoint(bool drawJoint);
@@ -11,10 +11,10 @@ class PhysicsWorld2D : public Component
     void SetWarmStarting(bool enable);
     void SetContinuousPhysics(bool enable);
     void SetSubStepping(bool enable);
-    void SetGravity(Vector2 gravity);
+    void SetGravity(const Vector2& gravity);
     void SetAutoClearForces(bool enable);
-    void SetVelocityIterations(unsigned velocityIterations);
-    void SetPositionIterations(unsigned positionIterations);
+    void SetVelocityIterations(int velocityIterations);
+    void SetPositionIterations(int positionIterations);
 
     void DrawDebugGeometry();
 
@@ -28,9 +28,9 @@ class PhysicsWorld2D : public Component
     bool GetContinuousPhysics() const;
     bool GetSubStepping() const;
     bool GetAutoClearForces() const;
-    Vector2 GetGravity() const;
-    unsigned GetVelocityIterations() const;
-    unsigned GetPositionIterations() const;
+    const Vector2& GetGravity() const;
+    int GetVelocityIterations() const;
+    int GetPositionIterations() const;
 
     tolua_property__get_set bool drawShape;
     tolua_property__get_set bool drawJoint;
@@ -42,7 +42,7 @@ class PhysicsWorld2D : public Component
     tolua_property__get_set bool continuousPhysics;
     tolua_property__get_set bool subStepping;
     tolua_property__get_set bool autoClearForces;
-    tolua_property__get_set Vector2 gravity;
-    tolua_property__get_set unsigned velocityIterations;
-    tolua_property__get_set unsigned positionIterations;
+    tolua_property__get_set Vector2& gravity;
+    tolua_property__get_set int velocityIterations;
+    tolua_property__get_set int positionIterations;
 };

Source/Engine/LuaScript/pkgs/Urho2D/RigidBody2D.pkg

@@ -12,7 +12,7 @@ class RigidBody2D : Component
     void SetBodyType(BodyType2D bodyType);
     void SetMass(float mass);
     void SetInertia(float inertia);
-    void SetMassCenter(const Vector2& center);
+    void SetMassCenter(Vector2 center);
     void SetUseFixtureMass(bool useFixtureMass);
     void SetLinearDamping(float linearDamping);
     void SetAngularDamping(float angularDamping);
@@ -21,7 +21,7 @@ class RigidBody2D : Component
     void SetBullet(bool bullet);
     void SetGravityScale(float gravityScale);
     void SetAwake(bool awake);
-    void SetLinearVelocity(const Vector2& linearVelocity);
+    void SetLinearVelocity(Vector2 linearVelocity);
     void SetAngularVelocity(float angularVelocity);
     void ApplyForce(const Vector2& force, const Vector2& point,  bool wake);
     void ApplyForceToCenter(const Vector2& force, bool wake);
@@ -42,6 +42,7 @@ class RigidBody2D : Component
     float GetGravityScale() const;
     bool IsAwake() const;
     Vector2 GetLinearVelocity() const;
+    float GetAngularVelocity() const;
 
     tolua_property__get_set BodyType2D bodyType;
     tolua_property__get_set float mass;
@@ -56,4 +57,5 @@ class RigidBody2D : Component
     tolua_property__get_set float gravityScale;
     tolua_property__is_set bool awake;
     tolua_property__get_set Vector2 linearVelocity;
+    tolua_property__get_set float angularVelocity;
 };

Source/Engine/LuaScript/pkgs/Urho2DLuaAPI.pkg

@@ -10,6 +10,8 @@ $pfile "Urho2D/ParticleEmitter2D.pkg"
 $pfile "Urho2D/PhysicsWorld2D.pkg"
 $pfile "Urho2D/RigidBody2D.pkg"
 $pfile "Urho2D/CollisionShape2D.pkg"
+$pfile "Urho2D/CollisionBox2D.pkg"
+$pfile "Urho2D/CollisionCircle2D.pkg"
 
 $using namespace Urho3D;
 $#pragma warning(disable:4800)

Source/Engine/Script/Urho2DAPI.cpp

@@ -21,15 +21,19 @@
 //
 
 #include "Precompiled.h"
+#include "APITemplates.h"
 #include "AnimatedSprite2D.h"
 #include "Animation2D.h"
 #include "APITemplates.h"
+#include "CollisionBox2D.h"
+#include "CollisionCircle2D.h"
 #include "CollisionShape2D.h"
 #include "Drawable2D.h"
 #include "ParticleEmitter2D.h"
 #include "ParticleModel2D.h"
 #include "PhysicsWorld2D.h"
 #include "RigidBody2D.h"
+#include "Scene.h"
 #include "Sprite2D.h"
 #include "SpriteSheet2D.h"
 #include "StaticSprite2D.h"
@@ -143,6 +147,16 @@ static void RegisterParticleEmitter2D(asIScriptEngine* engine)
     engine->RegisterObjectMethod("ParticleEmitter2D", "ParticleModel2D@+ get_model() const", asMETHOD(ParticleEmitter2D, GetModel), asCALL_THISCALL);
 }
 
+static PhysicsWorld2D* SceneGetPhysicsWorld2D(Scene* ptr)
+{
+    return ptr->GetComponent<PhysicsWorld2D>();
+}
+
+static PhysicsWorld2D* GetPhysicsWorld2D()
+{
+    Scene* scene = GetScriptContextScene();
+    return scene ? scene->GetComponent<PhysicsWorld2D>() : 0;
+}
 
 static void RegisterPhysicsWorld2D(asIScriptEngine* engine)
 {
@@ -174,6 +188,10 @@ static void RegisterPhysicsWorld2D(asIScriptEngine* engine)
     engine->RegisterObjectMethod("PhysicsWorld2D", "uint get_velocityIterations() const", asMETHOD(PhysicsWorld2D, GetVelocityIterations), asCALL_THISCALL);
     engine->RegisterObjectMethod("PhysicsWorld2D", "void set_positionIterations(uint)", asMETHOD(PhysicsWorld2D, SetPositionIterations), asCALL_THISCALL);
     engine->RegisterObjectMethod("PhysicsWorld2D", "uint get_positionIterations() const", asMETHOD(PhysicsWorld2D, GetPositionIterations), asCALL_THISCALL);
+    engine->RegisterObjectMethod("PhysicsWorld2D", "void DrawDebugGeometry() const", asMETHOD(PhysicsWorld2D, DrawDebugGeometry), asCALL_THISCALL);
+
+    engine->RegisterObjectMethod("Scene", "PhysicsWorld2D@+ get_physicsWorld2D() const", asFUNCTION(SceneGetPhysicsWorld2D), asCALL_CDECL_OBJLAST);
+    engine->RegisterGlobalFunction("PhysicsWorld2D@+ get_physicsWorld2D()", asFUNCTION(GetPhysicsWorld2D), asCALL_CDECL);
 }
 
 static void RegisterRigidBody2D(asIScriptEngine* engine)
@@ -219,28 +237,57 @@ static void RegisterRigidBody2D(asIScriptEngine* engine)
     engine->RegisterObjectMethod("RigidBody2D", "void ApplyAngularImpulse(float, bool)", asMETHOD(RigidBody2D, ApplyAngularImpulse), asCALL_THISCALL);
 }
 
+/// Template function for registering a class derived from CollisionShape2D.
+template <class T> void RegisterCollisionShape2D(asIScriptEngine* engine, const char* className)
+{
+    RegisterComponent<T>(engine, className);
+    RegisterSubclass<CollisionShape2D, T>(engine, "CollisionShape2D", className);
+
+    engine->RegisterObjectMethod(className, "void set_sensor(bool)", asMETHOD(T, SetSensor), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "bool get_sensor() const", asMETHOD(T, IsSensor), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void set_categoryBits(int)", asMETHOD(T, SetCategoryBits), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "int get_categoryBits() const", asMETHOD(T, GetCategoryBits), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void set_maskBits(int)", asMETHOD(T, SetMaskBits), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "int get_maskBits() const", asMETHOD(T, GetMaskBits), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void set_groupIndex(int)", asMETHOD(T, SetGroupIndex), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "int get_groupIndex() const", asMETHOD(T, GetGroupIndex), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void set_density(float)", asMETHOD(T, SetDensity), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "float get_density() const", asMETHOD(T, GetDensity), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void set_friction(float)", asMETHOD(T, SetFriction), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "float get_friction() const", asMETHOD(T, GetFriction), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "void set_restitution(float)", asMETHOD(T, SetRestitution), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "float get_restitution() const", asMETHOD(T, GetRestitution), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "float get_mass() const", asMETHOD(T, GetMass), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "float get_inertia() const", asMETHOD(T, GetInertia), asCALL_THISCALL);
+    engine->RegisterObjectMethod(className, "Vector2 get_massCenter() const", asMETHOD(T, GetMassCenter), asCALL_THISCALL);
+}
+
 static void RegisterCollisionShape2D(asIScriptEngine* engine)
 {
-    RegisterComponent<CollisionShape2D>(engine, "CollisionShape2D");
-
-    engine->RegisterObjectMethod("CollisionShape2D", "void set_sensor(bool)", asMETHOD(CollisionShape2D, SetSensor), asCALL_THISCALL);
-    engine->RegisterObjectMethod("CollisionShape2D", "bool get_sensor() const", asMETHOD(CollisionShape2D, IsSensor), asCALL_THISCALL);
-    engine->RegisterObjectMethod("CollisionShape2D", "void set_categoryBits(uint16)", asMETHOD(CollisionShape2D, SetCategoryBits), asCALL_THISCALL);
-    engine->RegisterObjectMethod("CollisionShape2D", "uint16 get_categoryBits() const", asMETHOD(CollisionShape2D, GetCategoryBits), asCALL_THISCALL);
-    engine->RegisterObjectMethod("CollisionShape2D", "void set_maskBits(uint16)", asMETHOD(CollisionShape2D, SetMaskBits), asCALL_THISCALL);
-    engine->RegisterObjectMethod("CollisionShape2D", "uint16 get_maskBits() const", asMETHOD(CollisionShape2D, GetMaskBits), asCALL_THISCALL);
-    engine->RegisterObjectMethod("CollisionShape2D", "void set_groupIndex(int16)", asMETHOD(CollisionShape2D, SetGroupIndex), asCALL_THISCALL);
-    engine->RegisterObjectMethod("CollisionShape2D", "int16 get_groupIndex() const", asMETHOD(CollisionShape2D, GetGroupIndex), asCALL_THISCALL);
-    engine->RegisterObjectMethod("CollisionShape2D", "void set_density(float)", asMETHOD(CollisionShape2D, SetDensity), asCALL_THISCALL);
-    engine->RegisterObjectMethod("CollisionShape2D", "float get_density() const", asMETHOD(CollisionShape2D, GetDensity), asCALL_THISCALL);
-    engine->RegisterObjectMethod("CollisionShape2D", "void set_friction(float)", asMETHOD(CollisionShape2D, SetFriction), asCALL_THISCALL);
-    engine->RegisterObjectMethod("CollisionShape2D", "float get_friction() const", asMETHOD(CollisionShape2D, GetFriction), asCALL_THISCALL);
-    engine->RegisterObjectMethod("CollisionShape2D", "void set_restitution(float)", asMETHOD(CollisionShape2D, SetRestitution), asCALL_THISCALL);
-    engine->RegisterObjectMethod("CollisionShape2D", "float get_restitution() const", asMETHOD(CollisionShape2D, GetRestitution), asCALL_THISCALL);
-    engine->RegisterObjectMethod("CollisionShape2D", "float get_mass() const", asMETHOD(CollisionShape2D, GetMass), asCALL_THISCALL);
-    engine->RegisterObjectMethod("CollisionShape2D", "float get_inertia() const", asMETHOD(CollisionShape2D, GetInertia), asCALL_THISCALL);
-    engine->RegisterObjectMethod("CollisionShape2D", "Vector2 get_massCenter() const", asMETHOD(CollisionShape2D, GetMassCenter), asCALL_THISCALL);
+    RegisterCollisionShape2D<CollisionShape2D>(engine, "CollisionShape2D");
+}
+
+static void RegisterCollisionBox2D(asIScriptEngine* engine)
+{
+    RegisterCollisionShape2D<CollisionBox2D>(engine, "CollisionBox2D");
+    engine->RegisterObjectMethod("CollisionBox2D", "void set_size(const Vector2&in)", asMETHODPR(CollisionBox2D, SetSize, (const Vector2&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("CollisionBox2D", "void SetSize(float, float)", asMETHODPR(CollisionBox2D, SetSize, (float, float), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("CollisionBox2D", "const Vector2& get_size() const", asMETHOD(CollisionBox2D, GetSize), asCALL_THISCALL);
+    engine->RegisterObjectMethod("CollisionBox2D", "void set_center(const Vector2&in)", asMETHODPR(CollisionBox2D, SetCenter, (const Vector2&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("CollisionBox2D", "void SetCenter(float, float)", asMETHODPR(CollisionBox2D, SetCenter, (float, float), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("CollisionBox2D", "const Vector2& get_center() const", asMETHOD(CollisionBox2D, GetCenter), asCALL_THISCALL);
+    engine->RegisterObjectMethod("CollisionBox2D", "void set_angle(float)", asMETHOD(CollisionBox2D, SetAngle), asCALL_THISCALL);
+    engine->RegisterObjectMethod("CollisionBox2D", "float get_angle() const", asMETHOD(CollisionBox2D, GetAngle), asCALL_THISCALL);
+}
 
+static void RegisterCollisionCircle2D(asIScriptEngine* engine)
+{
+    RegisterCollisionShape2D<CollisionCircle2D>(engine, "CollisionCircle2D");
+    engine->RegisterObjectMethod("CollisionCircle2D", "void set_radius(float)", asMETHOD(CollisionCircle2D, SetRadius), asCALL_THISCALL);
+    engine->RegisterObjectMethod("CollisionCircle2D", "float get_radius() const", asMETHOD(CollisionCircle2D, GetRadius), asCALL_THISCALL);
+    engine->RegisterObjectMethod("CollisionCircle2D", "void set_center(const Vector2&in)", asMETHODPR(CollisionCircle2D, SetCenter, (const Vector2&), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("CollisionCircle2D", "void SetCenter(float, float)", asMETHODPR(CollisionCircle2D, SetCenter, (float, float), void), asCALL_THISCALL);
+    engine->RegisterObjectMethod("CollisionCircle2D", "const Vector2& get_center() const", asMETHOD(CollisionCircle2D, GetCenter), asCALL_THISCALL);
 }
 
 void RegisterUrho2DAPI(asIScriptEngine* engine)
@@ -256,6 +303,8 @@ void RegisterUrho2DAPI(asIScriptEngine* engine)
     RegisterPhysicsWorld2D(engine);
     RegisterRigidBody2D(engine);
     RegisterCollisionShape2D(engine);
+    RegisterCollisionBox2D(engine);
+    RegisterCollisionCircle2D(engine);
 }
 
 }

Source/Engine/Urho2D/CollisionBox2D.cpp

@@ -121,7 +121,7 @@ void CollisionBox2D::RecreateFixture()
     if (scaledCenter == Vector2::ZERO && angle_ == 0.0f)
         boxShape_.SetAsBox(halfWidth, halfHeight);
     else
-        boxShape_.SetAsBox(halfWidth, halfHeight, ToB2Vec2(scaledCenter), angle_);
+        boxShape_.SetAsBox(halfWidth, halfHeight, ToB2Vec2(scaledCenter), angle_ * M_DEGTORAD);
 
     CreateFixture();
 }

Source/Engine/Urho2D/PhysicsWorld2D.cpp

@@ -84,7 +84,7 @@ void PhysicsWorld2D::RegisterObject(Context* context)
     ACCESSOR_ATTRIBUTE(PhysicsWorld2D, VAR_BOOL, "Warm Starting", GetWarmStarting, SetWarmStarting, bool, false, AM_DEFAULT);
     ACCESSOR_ATTRIBUTE(PhysicsWorld2D, VAR_BOOL, "Continuous Physics", GetContinuousPhysics, SetContinuousPhysics, bool, false, AM_DEFAULT);
     ACCESSOR_ATTRIBUTE(PhysicsWorld2D, VAR_BOOL, "Sub Stepping", GetSubStepping, SetSubStepping, bool, false, AM_DEFAULT);
-    ACCESSOR_ATTRIBUTE(PhysicsWorld2D, VAR_VECTOR2, "Gravity", GetGravity, SetGravity, Vector2, DEFAULT_GRAVITY, AM_DEFAULT);
+    REF_ACCESSOR_ATTRIBUTE(PhysicsWorld2D, VAR_VECTOR2, "Gravity", GetGravity, SetGravity, Vector2, DEFAULT_GRAVITY, AM_DEFAULT);
     ACCESSOR_ATTRIBUTE(PhysicsWorld2D, VAR_BOOL, "Auto Clear Forces", GetAutoClearForces, SetAutoClearForces, bool, false, AM_DEFAULT);
     ACCESSOR_ATTRIBUTE(PhysicsWorld2D, VAR_INT, "Velocity Iterations", GetVelocityIterations, SetVelocityIterations, int, false, AM_DEFAULT);
     ACCESSOR_ATTRIBUTE(PhysicsWorld2D, VAR_INT, "Position Iterations", GetPositionIterations, SetPositionIterations, int, false, AM_DEFAULT);
@@ -291,7 +291,7 @@ void PhysicsWorld2D::SetSubStepping(bool enable)
     world_->SetSubStepping(enable);
 }
 
-void PhysicsWorld2D::SetGravity(Vector2 gravity)
+void PhysicsWorld2D::SetGravity(const Vector2& gravity)
 {
     gravity_ = gravity;
 

Source/Engine/Urho2D/PhysicsWorld2D.h

@@ -86,7 +86,7 @@ public:
     /// Set sub stepping.
     void SetSubStepping(bool enable);
     /// Set gravity.
-    void SetGravity(Vector2 gravity);
+    void SetGravity(const Vector2& gravity);
     /// Set auto clear forces.
     void SetAutoClearForces(bool enable);
     /// Set velocity iterations.
@@ -128,7 +128,7 @@ public:
     /// Return auto clear forces.
     bool GetAutoClearForces() const;
     /// Return gravity.
-    Vector2 GetGravity() const { return gravity_; }
+    const Vector2& GetGravity() const { return gravity_; }
     /// Return velocity iterations.
     int GetVelocityIterations() const { return velocityIterations_; }
     /// Return position iterations.

Source/Engine/Urho2D/RigidBody2D.cpp

@@ -35,6 +35,20 @@ namespace Urho3D
 {
 
 extern const char* URHO2D_CATEGORY;
+static const BodyType2D DEFAULT_BODYTYPE = BT_STATIC;
+
+static const char* bodyTypeNames[] =
+{
+    "Static",
+    "Dynamic",
+    "Kinematic",
+    0
+};
+
+template<> BodyType2D Variant::Get<BodyType2D>() const
+{
+    return (BodyType2D)GetInt();
+}
 
 RigidBody2D::RigidBody2D(Context* context) : Component(context),
     body_(0),
@@ -58,12 +72,18 @@ void RigidBody2D::RegisterObject(Context* context)
 {
     context->RegisterFactory<RigidBody2D>(URHO2D_CATEGORY);
 
+    ENUM_ACCESSOR_ATTRIBUTE(RigidBody2D, "Body Type", GetBodyType, SetBodyType, BodyType2D, bodyTypeNames, DEFAULT_BODYTYPE, AM_DEFAULT);
+    ACCESSOR_ATTRIBUTE(RigidBody2D, VAR_FLOAT, "Mass", GetMass, SetMass, float, 0.0f, AM_DEFAULT);
+    ACCESSOR_ATTRIBUTE(RigidBody2D, VAR_FLOAT, "Inertia", GetInertia, SetInertia, float, 0.0f, AM_DEFAULT);
     ACCESSOR_ATTRIBUTE(RigidBody2D, VAR_VECTOR2, "Mass Center", GetMassCenter, SetMassCenter, Vector2, Vector2::ZERO, AM_DEFAULT);
-    ACCESSOR_ATTRIBUTE(RigidBody2D, VAR_BOOL, "Use Fixture Mass", GetUseFixtureMass, SetUseFixtureMass, bool, false, AM_DEFAULT);
+    ACCESSOR_ATTRIBUTE(RigidBody2D, VAR_BOOL, "Use Fixture Mass", GetUseFixtureMass, SetUseFixtureMass, bool, true, AM_DEFAULT);
     ACCESSOR_ATTRIBUTE(RigidBody2D, VAR_FLOAT, "Linear Damping", GetLinearDamping, SetLinearDamping, float, 0.0f, AM_DEFAULT);
     ACCESSOR_ATTRIBUTE(RigidBody2D, VAR_FLOAT, "Angular Damping", GetAngularDamping, SetAngularDamping, float, 0.0f, AM_DEFAULT);
+    ACCESSOR_ATTRIBUTE(RigidBody2D, VAR_BOOL, "Allow Sleep", IsAllowSleep, SetAllowSleep, bool, true, AM_DEFAULT);
     ACCESSOR_ATTRIBUTE(RigidBody2D, VAR_BOOL, "Fixed Rotation", IsFixedRotation, SetFixedRotation, bool, false, AM_DEFAULT);
+    ACCESSOR_ATTRIBUTE(RigidBody2D, VAR_BOOL, "Bullet", IsBullet, SetBullet, bool, false, AM_DEFAULT);
     ACCESSOR_ATTRIBUTE(RigidBody2D, VAR_FLOAT, "Gravity Scale", GetGravityScale, SetGravityScale, float, 1.0f, AM_DEFAULT);
+    ACCESSOR_ATTRIBUTE(RigidBody2D, VAR_BOOL, "Awake", IsAwake, SetAwake, bool, true, AM_DEFAULT);
     ACCESSOR_ATTRIBUTE(RigidBody2D, VAR_VECTOR2, "Linear Velocity", GetLinearVelocity, SetLinearVelocity, Vector2, Vector2::ZERO, AM_DEFAULT);
     ACCESSOR_ATTRIBUTE(RigidBody2D, VAR_FLOAT, "Angular Velocity", GetAngularVelocity, SetAngularVelocity, float, 0.0f, AM_DEFAULT);
 

Source/Samples/27_Urho2DPhysics/Urho2DPhysics.cpp

@@ -43,7 +43,7 @@
 
 DEFINE_APPLICATION_MAIN(Urho2DPhysics)
 
-static const unsigned NUM_OBJECT = 100;
+static const unsigned NUM_OBJECTS = 100;
 
 Urho2DPhysics::Urho2DPhysics(Context* context) : Sample(context)
 {    
@@ -87,9 +87,7 @@ void Urho2DPhysics::CreateScene()
 
     // Create 2D physics world component
     PhysicsWorld2D* physicsWorld = scene_->CreateComponent<PhysicsWorld2D>();
-    // Define the gravity vector.
-    physicsWorld->SetGravity(Vector2(0.0f, -10.0f));
-
+    
     // Create ground.
     Node* groundNode = scene_->CreateChild("Ground");
     groundNode->SetPosition(Vector3(0.0f, -3.0f, 0.0f));
@@ -105,7 +103,7 @@ void Urho2DPhysics::CreateScene()
     // Set friction
     groundShape->SetFriction(0.5f);
 
-    for (unsigned i = 0; i < NUM_OBJECT; ++i)
+    for (unsigned i = 0; i < NUM_OBJECTS; ++i)
     {
         Node* node  = scene_->CreateChild("RigidBody");
         node->SetPosition(Vector3(Random(-0.1f, 0.1f), 5.0f + i * 0.4f, 0.0f));