Add CollisionEdge2D, CollisionChain2D and CollisionPolygon2D (including Lua and AngelScript binding). [ci skip]

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

@@ -0,0 +1,17 @@
+$#include "CollisionChain2D.h"
+
+class CollisionChain2D : CollisionShape2D
+{
+    void SetLoop(bool loop);
+    void SetVertexCount(unsigned count);
+    void SetVertex(unsigned index, const Vector2& vertex);
+    void SetVertices(const PODVector<Vector2>& vertices);
+
+    bool GetLoop() const;
+    unsigned GetVertexCount() const;
+    const Vector2& GetVertex(unsigned index) const;
+    // const PODVector<Vector2>& GetVertices() const;
+
+    tolua_property__get_set bool loop;
+    tolua_property__get_set unsigned vertexCount;
+};

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

@@ -0,0 +1,14 @@
+$#include "CollisionEdge2D.h"
+
+class CollisionEdge2D : CollisionShape2D
+{
+    void SetVertex1(const Vector2& vertex);
+    void SetVertex2(const Vector2& vertex);
+    void SetVertices(const Vector2& vertex1, const Vector2& vertex2);
+
+    const Vector2& GetVertex1() const;
+    const Vector2& GetVertex2() const;
+
+    tolua_property__get_set Vector2& vertex1;
+    tolua_property__get_set Vector2& vertex2;
+};

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

@@ -0,0 +1,14 @@
+$#include "CollisionPolygon2D.h"
+
+class CollisionPolygon2D : CollisionShape2D
+{
+    void SetVertexCount(unsigned count);
+    void SetVertex(unsigned index, const Vector2& vertex);
+    void SetVertices(const PODVector<Vector2>& vertices);
+
+    unsigned GetVertexCount() const;
+    const Vector2& GetVertex(unsigned index) const;
+    // const PODVector<Vector2>& GetVertices() const;
+
+    tolua_property__get_set unsigned vertexCount;
+};

Source/Engine/LuaScript/pkgs/Urho2DLuaAPI.pkg

@@ -6,12 +6,14 @@ $pfile "Urho2D/Animation2D.pkg"
 $pfile "Urho2D/AnimatedSprite2D.pkg"
 $pfile "Urho2D/ParticleModel2D.pkg"
 $pfile "Urho2D/ParticleEmitter2D.pkg"
-
 $pfile "Urho2D/PhysicsWorld2D.pkg"
 $pfile "Urho2D/RigidBody2D.pkg"
 $pfile "Urho2D/CollisionShape2D.pkg"
 $pfile "Urho2D/CollisionBox2D.pkg"
 $pfile "Urho2D/CollisionCircle2D.pkg"
+$pfile "Urho2D/CollisionChain2D.pkg"
+$pfile "Urho2D/CollisionEdge2D.pkg"
+$pfile "Urho2D/CollisionPolygon2D.pkg"
 
 $using namespace Urho3D;
 $#pragma warning(disable:4800)

Source/Engine/Script/Urho2DAPI.cpp

@@ -26,7 +26,10 @@
 #include "Animation2D.h"
 #include "APITemplates.h"
 #include "CollisionBox2D.h"
+#include "CollisionChain2D.h"
 #include "CollisionCircle2D.h"
+#include "CollisionEdge2D.h"
+#include "CollisionPolygon2D.h"
 #include "CollisionShape2D.h"
 #include "Drawable2D.h"
 #include "ParticleEmitter2D.h"
@@ -290,6 +293,40 @@ static void RegisterCollisionCircle2D(asIScriptEngine* engine)
     engine->RegisterObjectMethod("CollisionCircle2D", "const Vector2& get_center() const", asMETHOD(CollisionCircle2D, GetCenter), asCALL_THISCALL);
 }
 
+static void RegisterCollisionChain2D(asIScriptEngine* engine)
+{
+    RegisterCollisionShape2D<CollisionChain2D>(engine, "CollisionChain2D");
+    engine->RegisterObjectMethod("CollisionChain2D", "void set_loop(bool)", asMETHOD(CollisionChain2D, SetLoop), asCALL_THISCALL);
+    engine->RegisterObjectMethod("CollisionChain2D", "bool get_loop() const", asMETHOD(CollisionChain2D, GetLoop), asCALL_THISCALL);
+    engine->RegisterObjectMethod("CollisionChain2D", "void set_vertexCount(unsigned)", asMETHOD(CollisionChain2D, SetVertexCount), asCALL_THISCALL);
+    engine->RegisterObjectMethod("CollisionChain2D", "unsigned get_vertexCount() const", asMETHOD(CollisionChain2D, GetVertexCount), asCALL_THISCALL);
+    engine->RegisterObjectMethod("CollisionChain2D", "void SetVertex(unsigned, const Vector2&)", asMETHOD(CollisionChain2D, SetVertex), asCALL_THISCALL);
+    engine->RegisterObjectMethod("CollisionChain2D", "const Vector2& GetVertex(unsigned) const", asMETHOD(CollisionChain2D, GetVertex), asCALL_THISCALL);
+    engine->RegisterObjectMethod("CollisionChain2D", "void SetVertices(const PODVector<Vector2>&)", asMETHOD(CollisionChain2D, SetVertices), asCALL_THISCALL);
+    engine->RegisterObjectMethod("CollisionChain2D", "const PODVector<Vector2>& GetVertices() const", asMETHOD(CollisionChain2D, GetVertices), asCALL_THISCALL);
+}
+
+static void RegisterCollisionEdge2D(asIScriptEngine* engine)
+{
+    RegisterCollisionShape2D<CollisionEdge2D>(engine, "CollisionEdge2D");
+    engine->RegisterObjectMethod("CollisionEdge2D", "void set_vertex1(const Vector2&)", asMETHOD(CollisionEdge2D, SetVertex1), asCALL_THISCALL);
+    engine->RegisterObjectMethod("CollisionEdge2D", "const Vector2& get_vertex1() const", asMETHOD(CollisionEdge2D, GetVertex1), asCALL_THISCALL);
+    engine->RegisterObjectMethod("CollisionEdge2D", "void set_vertex2(const Vector2&)", asMETHOD(CollisionEdge2D, SetVertex2), asCALL_THISCALL);
+    engine->RegisterObjectMethod("CollisionEdge2D", "const Vector2& get_vertex2() const", asMETHOD(CollisionEdge2D, GetVertex2), asCALL_THISCALL);
+    engine->RegisterObjectMethod("CollisionEdge2D", "void SetVertices(const Vector2&, const Vector2&)", asMETHOD(CollisionEdge2D, SetVertices), asCALL_THISCALL);
+}
+
+static void RegisterCollisionPolygon2D(asIScriptEngine* engine)
+{
+    RegisterCollisionShape2D<CollisionPolygon2D>(engine, "CollisionPolygon2D");
+    engine->RegisterObjectMethod("CollisionPolygon2D", "void set_vertexCount(unsigned)", asMETHOD(CollisionPolygon2D, SetVertexCount), asCALL_THISCALL);
+    engine->RegisterObjectMethod("CollisionPolygon2D", "unsigned get_vertexCount() const", asMETHOD(CollisionPolygon2D, GetVertexCount), asCALL_THISCALL);
+    engine->RegisterObjectMethod("CollisionPolygon2D", "void SetVertex(unsigned, const Vector2&)", asMETHOD(CollisionPolygon2D, SetVertex), asCALL_THISCALL);
+    engine->RegisterObjectMethod("CollisionPolygon2D", "const Vector2& GetVertex(unsigned) const", asMETHOD(CollisionPolygon2D, GetVertex), asCALL_THISCALL);
+    engine->RegisterObjectMethod("CollisionPolygon2D", "void SetVertices(const PODVector<Vector2>&)", asMETHOD(CollisionPolygon2D, SetVertices), asCALL_THISCALL);
+    engine->RegisterObjectMethod("CollisionPolygon2D", "const PODVector<Vector2>& GetVertices() const", asMETHOD(CollisionPolygon2D, GetVertices), asCALL_THISCALL);
+}
+
 void RegisterUrho2DAPI(asIScriptEngine* engine)
 {
     RegisterSprite2D(engine);
@@ -305,6 +342,9 @@ void RegisterUrho2DAPI(asIScriptEngine* engine)
     RegisterCollisionShape2D(engine);
     RegisterCollisionBox2D(engine);
     RegisterCollisionCircle2D(engine);
+    RegisterCollisionChain2D(engine);
+    RegisterCollisionEdge2D(engine);
+    RegisterCollisionPolygon2D(engine);
 }
 
 }

Source/Engine/Urho2D/CollisionChain2D.cpp

@@ -0,0 +1,115 @@
+//
+// Copyright (c) 2008-2014 the Urho3D project.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+
+#include "Precompiled.h"
+#include "Context.h"
+#include "CollisionChain2D.h"
+#include "PhysicsUtils2D.h"
+
+#include "DebugNew.h"
+
+namespace Urho3D
+{
+
+extern const char* URHO2D_CATEGORY;
+
+CollisionChain2D::CollisionChain2D(Context* context) : CollisionShape2D(context),
+    loop_(false)
+{
+    fixtureDef_.shape = &chainShape_;
+}
+
+CollisionChain2D::~CollisionChain2D()
+{
+}
+
+void CollisionChain2D::RegisterObject(Context* context)
+{
+    context->RegisterFactory<CollisionChain2D>(URHO2D_CATEGORY);
+    ACCESSOR_ATTRIBUTE(CollisionChain2D, VAR_BOOL, "Loop", GetLoop, SetLoop, bool, false, AM_DEFAULT);
+    COPY_BASE_ATTRIBUTES(CollisionChain2D, CollisionShape2D);
+}
+
+void CollisionChain2D::SetLoop(bool loop)
+{
+    if (loop == loop_)
+        return;
+
+    loop_ = loop;
+
+    MarkNetworkUpdate();
+    RecreateFixture();
+}
+
+void CollisionChain2D::SetVertexCount(unsigned count)
+{
+    vertices_.Resize(count);
+}
+
+void CollisionChain2D::SetVertex(unsigned index, const Vector2& vertex)
+{
+    if (index >= vertices_.Size())
+        return;
+
+    vertices_[index] = vertex;
+
+    if (index == vertices_.Size() - 1)
+    {
+        MarkNetworkUpdate();
+        RecreateFixture();
+    }
+}
+
+void CollisionChain2D::SetVertices(const PODVector<Vector2>& vertices)
+{
+    vertices_ = vertices;
+
+    MarkNetworkUpdate();
+    RecreateFixture();
+}
+
+void CollisionChain2D::ApplyNodeWorldScale()
+{
+    RecreateFixture();
+}
+
+void CollisionChain2D::RecreateFixture()
+{
+    ReleaseFixture();
+
+    PODVector<b2Vec2> b2Vertices;
+    unsigned count = vertices_.Size();
+    b2Vertices.Resize(count);
+
+    Vector2 worldScale(cachedWorldScale_.x_, cachedWorldScale_.y_);
+    for (unsigned i = 0; i < count; ++i)
+        b2Vertices[i] = ToB2Vec2(vertices_[i] * worldScale);
+
+    if (loop_)
+        chainShape_.CreateLoop(&b2Vertices[0], count);
+    else
+        chainShape_.CreateChain(&b2Vertices[0], count);
+
+    CreateFixture();
+}
+
+}

Source/Engine/Urho2D/CollisionChain2D.h

@@ -0,0 +1,74 @@
+//
+// Copyright (c) 2008-2014 the Urho3D project.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+
+#pragma once
+
+#include "CollisionShape2D.h"
+
+namespace Urho3D
+{
+/// 2D chain collision component.
+class URHO3D_API CollisionChain2D : public CollisionShape2D
+{
+    OBJECT(CollisionChain2D);
+
+public:
+    /// Construct.
+    CollisionChain2D(Context* scontext);
+    /// Destruct.
+    virtual ~CollisionChain2D();
+    /// Register object factory.
+    static void RegisterObject(Context* context);
+
+    /// Set loop.
+    void SetLoop(bool loop);
+    /// Set vertex count.
+    void SetVertexCount(unsigned count);
+    /// Set vertex.
+    void SetVertex(unsigned index, const Vector2& vertex);
+    /// Set vertices.
+    void SetVertices(const PODVector<Vector2>& vertices);
+
+    /// Return loop.
+    bool GetLoop() const { return loop_; }
+    /// Return vertex count.
+    unsigned GetVertexCount() const { return vertices_.Size(); }
+    /// Return vertex.
+    const Vector2& GetVertex(unsigned index) const { return (index < vertices_.Size()) ? vertices_[index] : Vector2::ZERO; }
+    /// Return vertices.
+    const PODVector<Vector2>& GetVertices() const { return vertices_; }
+
+private:
+    /// Apply node world scale.
+    virtual void ApplyNodeWorldScale();
+    /// Recreate fixture.
+    void RecreateFixture();
+
+    /// Chain shape.
+    b2ChainShape chainShape_;
+    /// Loop.
+    bool loop_;
+    /// Vertices.
+    PODVector<Vector2> vertices_;
+};
+
+}

Source/Engine/Urho2D/CollisionEdge2D.cpp

@@ -0,0 +1,97 @@
+//
+// Copyright (c) 2008-2014 the Urho3D project.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+
+#include "Precompiled.h"
+#include "Context.h"
+#include "CollisionEdge2D.h"
+#include "PhysicsUtils2D.h"
+
+#include "DebugNew.h"
+
+namespace Urho3D
+{
+
+extern const char* URHO2D_CATEGORY;
+static const Vector2 DEFAULT_VERTEX1(-0.01f, 0.0f);
+static const Vector2 DEFAULT_VERTEX2(0.01f, 0.0f);
+
+CollisionEdge2D::CollisionEdge2D(Context* context) : CollisionShape2D(context),
+    vertex1_(DEFAULT_VERTEX1),
+    vertex2_(DEFAULT_VERTEX2)
+
+{
+    Vector2 worldScale(cachedWorldScale_.x_, cachedWorldScale_.y_);
+    edgeShape_.Set(ToB2Vec2(vertex1_ * worldScale), ToB2Vec2(vertex2_ * worldScale));
+    fixtureDef_.shape = &edgeShape_;
+}
+
+CollisionEdge2D::~CollisionEdge2D()
+{
+}
+
+void CollisionEdge2D::RegisterObject(Context* context)
+{
+    context->RegisterFactory<CollisionEdge2D>(URHO2D_CATEGORY);
+
+    REF_ACCESSOR_ATTRIBUTE(CollisionEdge2D, VAR_VECTOR2, "Vertex 1", GetVertex1, SetVertex1, Vector2, DEFAULT_VERTEX1, AM_DEFAULT);
+    REF_ACCESSOR_ATTRIBUTE(CollisionEdge2D, VAR_VECTOR2, "Vertex 2", GetVertex2, SetVertex2, Vector2, DEFAULT_VERTEX2, AM_DEFAULT);
+    COPY_BASE_ATTRIBUTES(CollisionEdge2D, CollisionShape2D);
+}
+
+void CollisionEdge2D::SetVertex1(const Vector2& vertex)
+{
+    SetVertices(vertex, vertex2_);
+}
+
+void CollisionEdge2D::SetVertex2(const Vector2& vertex)
+{
+    SetVertices(vertex1_, vertex);
+}
+
+void CollisionEdge2D::SetVertices(const Vector2& vertex1, const Vector2& vertex2)
+{
+    if (vertex1 == vertex1_ && vertex2 == vertex2_)
+        return;
+
+    vertex1_ = vertex1;
+    vertex2_ = vertex2;
+
+    MarkNetworkUpdate();
+    RecreateFixture();
+}
+
+void CollisionEdge2D::ApplyNodeWorldScale()
+{
+    RecreateFixture();
+}
+
+void CollisionEdge2D::RecreateFixture()
+{
+    ReleaseFixture();
+
+    Vector2 worldScale(cachedWorldScale_.x_, cachedWorldScale_.y_);
+    edgeShape_.Set(ToB2Vec2(vertex1_ * worldScale), ToB2Vec2(vertex2_ * worldScale));
+
+    CreateFixture();
+}
+
+}

Source/Engine/Urho2D/CollisionEdge2D.h

@@ -0,0 +1,69 @@
+//
+// Copyright (c) 2008-2014 the Urho3D project.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+
+#pragma once
+
+#include "CollisionShape2D.h"
+
+namespace Urho3D
+{
+
+/// 2D edge collision component.
+class URHO3D_API CollisionEdge2D : public CollisionShape2D
+{
+    OBJECT(CollisionEdge2D);
+
+public:
+    /// Construct.
+    CollisionEdge2D(Context* scontext);
+    /// Destruct.
+    virtual ~CollisionEdge2D();
+    /// Register object factory.
+    static void RegisterObject(Context* context);
+
+    /// Set vertex 1.
+    void SetVertex1(const Vector2& vertex);
+    /// Set vertex 2.
+    void SetVertex2(const Vector2& vertex);
+    /// Set vertices.
+    void SetVertices(const Vector2& vertex1, const Vector2& vertex2);
+
+    /// Return vertex 1.
+    const Vector2& GetVertex1() const { return vertex1_; }
+    /// Return vertex 2.
+    const Vector2& GetVertex2() const { return vertex2_; }
+
+private:
+    /// Apply node world scale.
+    virtual void ApplyNodeWorldScale();
+    /// Recreate fixture.
+    void RecreateFixture();
+
+    /// Edge shape.
+    b2EdgeShape edgeShape_;
+    /// Vertex 1.
+    Vector2 vertex1_;
+    /// Vertex 2.
+    Vector2 vertex2_;
+};
+
+}

Source/Engine/Urho2D/CollisionPolygon2D.cpp

@@ -0,0 +1,99 @@
+//
+// Copyright (c) 2008-2014 the Urho3D project.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+
+#include "Precompiled.h"
+#include "Context.h"
+#include "CollisionPolygon2D.h"
+#include "PhysicsUtils2D.h"
+
+#include "DebugNew.h"
+
+namespace Urho3D
+{
+
+extern const char* URHO2D_CATEGORY;
+
+CollisionPolygon2D::CollisionPolygon2D(Context* context) : CollisionShape2D(context)
+{
+    fixtureDef_.shape = &polygonShape_;
+}
+
+CollisionPolygon2D::~CollisionPolygon2D()
+{
+}
+
+void CollisionPolygon2D::RegisterObject(Context* context)
+{
+    context->RegisterFactory<CollisionPolygon2D>(URHO2D_CATEGORY);
+    COPY_BASE_ATTRIBUTES(CollisionPolygon2D, CollisionShape2D);
+}
+
+void CollisionPolygon2D::SetVertexCount(unsigned count)
+{
+    vertices_.Resize(count);
+}
+
+void CollisionPolygon2D::SetVertex(unsigned index, const Vector2& vertex)
+{
+    if (index >= vertices_.Size())
+        return;
+
+    vertices_[index] = vertex;
+
+    if (index == vertices_.Size() - 1)
+    {
+        MarkNetworkUpdate();
+        RecreateFixture();
+    }
+}
+
+void CollisionPolygon2D::SetVertices(const PODVector<Vector2>& vertices)
+{
+    vertices_ = vertices;
+
+    MarkNetworkUpdate();
+    RecreateFixture();
+}
+
+void CollisionPolygon2D::ApplyNodeWorldScale()
+{
+    RecreateFixture();
+}
+
+void CollisionPolygon2D::RecreateFixture()
+{
+    ReleaseFixture();
+
+    PODVector<b2Vec2> b2Vertices;
+    unsigned count = vertices_.Size();
+    b2Vertices.Resize(count);
+
+    Vector2 worldScale(cachedWorldScale_.x_, cachedWorldScale_.y_);
+    for (unsigned i = 0; i < count; ++i)
+        b2Vertices[i] = ToB2Vec2(vertices_[i] * worldScale);
+
+    polygonShape_.Set(&b2Vertices[0], count);
+
+    CreateFixture();
+}
+
+}

Source/Engine/Urho2D/CollisionPolygon2D.h

@@ -0,0 +1,69 @@
+//
+// Copyright (c) 2008-2014 the Urho3D project.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+
+#pragma once
+
+#include "CollisionShape2D.h"
+
+namespace Urho3D
+{
+
+/// 2D polygon collision component.
+class URHO3D_API CollisionPolygon2D : public CollisionShape2D
+{
+    OBJECT(CollisionPolygon2D);
+
+public:
+    /// Construct.
+    CollisionPolygon2D(Context* scontext);
+    /// Destruct.
+    virtual ~CollisionPolygon2D();
+    /// Register object factory.
+    static void RegisterObject(Context* context);
+
+    /// Set vertex count.
+    void SetVertexCount(unsigned count);
+    /// Set vertex.
+    void SetVertex(unsigned index, const Vector2& vertex);
+    /// Set vertices.
+    void SetVertices(const PODVector<Vector2>& vertices);
+
+    /// Return vertex count.
+    unsigned GetVertexCount() const { return vertices_.Size(); }
+    /// Return vertex.
+    const Vector2& GetVertex(unsigned index) const { return (index < vertices_.Size()) ? vertices_[index] : Vector2::ZERO; }
+    /// Return vertices.
+    const PODVector<Vector2>& GetVertices() const { return vertices_; }
+
+private:
+    /// Apply node world scale.
+    virtual void ApplyNodeWorldScale();
+    /// Recreate fixture.
+    void RecreateFixture();
+
+    /// Polygon shape.
+    b2PolygonShape polygonShape_;
+    /// Vertices.
+    PODVector<Vector2> vertices_;
+};
+
+}

Source/Engine/Urho2D/Urho2D.cpp

@@ -24,7 +24,10 @@
 #include "AnimatedSprite2D.h"
 #include "Animation2D.h"
 #include "CollisionBox2D.h"
+#include "CollisionChain2D.h"
 #include "CollisionCircle2D.h"
+#include "CollisionEdge2D.h"
+#include "CollisionPolygon2D.h"
 #include "CollisionShape2D.h"
 #include "Drawable2D.h"
 #include "ParticleEmitter2D.h"
@@ -58,7 +61,10 @@ void RegisterUrho2DLibrary(Context* context)
     RigidBody2D::RegisterObject(context);
     CollisionShape2D::RegisterObject(context);
     CollisionBox2D::RegisterObject(context);
+    CollisionChain2D::RegisterObject(context);
     CollisionCircle2D::RegisterObject(context);
+    CollisionEdge2D::RegisterObject(context);
+    CollisionPolygon2D::RegisterObject(context);
 }
 
 }