203 lines
3.6 KiB
C++
203 lines
3.6 KiB
C++
#pragma once
|
|
|
|
#include "stdafx.h"
|
|
#include "MassData.cpp"
|
|
#include "ShapeType.cpp"
|
|
|
|
using namespace System::Collections::Generic;
|
|
|
|
namespace Box2D
|
|
{
|
|
namespace Net
|
|
{
|
|
public ref class ShapeDef
|
|
{
|
|
internal:
|
|
bool DeleteOnDtor;
|
|
b2ShapeDef *def;
|
|
ShapeDef(b2ShapeDef *defRef) : def(defRef), DeleteOnDtor(false) { }
|
|
|
|
//Needs to work for derivative types, too
|
|
b2ShapeDef GetShapeDef()
|
|
{
|
|
return *def;
|
|
}
|
|
|
|
public:
|
|
virtual ~ShapeDef()
|
|
{
|
|
if(DeleteOnDtor)
|
|
delete def;
|
|
}
|
|
|
|
property ShapeType ShapeType
|
|
{
|
|
Box2D::Net::ShapeType get()
|
|
{
|
|
return (Box2D::Net::ShapeType) def->type;
|
|
}
|
|
|
|
void set(Box2D::Net::ShapeType value)
|
|
{
|
|
def->type = b2ShapeType(value);
|
|
}
|
|
}
|
|
|
|
property float32 Friction
|
|
{
|
|
float32 get()
|
|
{
|
|
return def->friction;
|
|
}
|
|
|
|
void set(float32 value)
|
|
{
|
|
def->friction = value;
|
|
}
|
|
}
|
|
|
|
property float32 Restitution
|
|
{
|
|
float32 get()
|
|
{
|
|
return def->restitution;
|
|
}
|
|
|
|
void set(float32 value)
|
|
{
|
|
def->restitution = value;
|
|
}
|
|
}
|
|
|
|
property float32 Density
|
|
{
|
|
float32 get()
|
|
{
|
|
return def->density;
|
|
}
|
|
|
|
void set(float32 value)
|
|
{
|
|
def->density = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The collision category bits. Normally you would just set one bit.
|
|
/// </summary>
|
|
property unsigned __int16 CategoryBits
|
|
{
|
|
unsigned __int16 get()
|
|
{
|
|
return def->categoryBits;
|
|
}
|
|
|
|
void set(unsigned __int16 value)
|
|
{
|
|
def->categoryBits = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The collision mask bits. This states the categories that this
|
|
/// shape would accept for collision.
|
|
/// </summary>
|
|
property unsigned __int16 MaskBits
|
|
{
|
|
unsigned __int16 get()
|
|
{
|
|
return def->maskBits;
|
|
}
|
|
|
|
void set(unsigned __int16 value)
|
|
{
|
|
def->maskBits = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Collision groups allow a certain group of objects to never collide (negative)
|
|
/// or always collide (positive). Zero means no collision group. Non-zero group
|
|
/// filtering always wins against the mask bits.
|
|
/// </summary>
|
|
property unsigned __int16 GroupIndex
|
|
{
|
|
unsigned __int16 get()
|
|
{
|
|
return def->groupIndex;
|
|
}
|
|
|
|
void set(unsigned __int16 value)
|
|
{
|
|
def->groupIndex = value;
|
|
}
|
|
}
|
|
|
|
//TODO:
|
|
//void* userData;
|
|
};
|
|
|
|
public ref class CircleDef : public ShapeDef
|
|
{
|
|
public:
|
|
CircleDef() : ShapeDef(new b2CircleDef())
|
|
{
|
|
ShapeDef::DeleteOnDtor = (true);
|
|
}
|
|
|
|
property float32 Radius
|
|
{
|
|
float32 get()
|
|
{
|
|
return reinterpret_cast<b2CircleDef*>(def)->radius;
|
|
}
|
|
|
|
void set(float32 value)
|
|
{
|
|
reinterpret_cast<b2CircleDef*>(def)->radius = value;
|
|
}
|
|
}
|
|
};
|
|
|
|
public ref class PolygonDef : public ShapeDef
|
|
{
|
|
public:
|
|
PolygonDef() : ShapeDef(new b2PolygonDef())
|
|
{
|
|
DeleteOnDtor = (true);
|
|
}
|
|
|
|
void SetAsBox(float X, float Y)
|
|
{
|
|
reinterpret_cast<b2PolygonDef*>(def)->SetAsBox(X, Y);
|
|
}
|
|
|
|
void SetAsBox(float X, float Y, Vector^ Center, float Angle)
|
|
{
|
|
reinterpret_cast<b2PolygonDef*>(def)->SetAsBox(X, Y, Center->getVec2(), Angle);
|
|
}
|
|
|
|
property IList<Vector^>^ Verticies
|
|
{
|
|
IList<Vector^>^ get()
|
|
{
|
|
List<Vector^>^ list = gcnew List<Vector^>();
|
|
for(int x = 0; x < reinterpret_cast<b2PolygonDef*>(def)->vertexCount; ++x)
|
|
{
|
|
list->Add(gcnew Vector(reinterpret_cast<b2PolygonDef*>(def)->vertices[x]));
|
|
}
|
|
return list;
|
|
}
|
|
|
|
void set(IList<Vector^>^ value)
|
|
{
|
|
b2PolygonDef* Def = reinterpret_cast<b2PolygonDef*>(def);
|
|
|
|
for(int x = 0; x < value->Count; ++x)
|
|
Def->vertices[x] = value[x]->getVec2();
|
|
}
|
|
}
|
|
};
|
|
}
|
|
}
|