Turánszki János
777 lines
20 KiB
C++
777 lines
20 KiB
C++
#include "wiPrimitive_BindLua.h"
|
|
#include "wiMath_BindLua.h"
|
|
|
|
using namespace wi::primitive;
|
|
|
|
namespace wi::lua::primitive
|
|
{
|
|
void Bind()
|
|
{
|
|
static bool initialized = false;
|
|
if (!initialized)
|
|
{
|
|
initialized = true;
|
|
|
|
lua_State* L = wi::lua::GetLuaState();
|
|
|
|
Luna<Ray_BindLua>::Register(L);
|
|
Luna<AABB_BindLua>::Register(L);
|
|
Luna<Sphere_BindLua>::Register(L);
|
|
Luna<Capsule_BindLua>::Register(L);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
Luna<Ray_BindLua>::FunctionType Ray_BindLua::methods[] = {
|
|
lunamethod(Ray_BindLua, Intersects),
|
|
lunamethod(Ray_BindLua, GetOrigin),
|
|
lunamethod(Ray_BindLua, GetDirection),
|
|
lunamethod(Ray_BindLua, SetOrigin),
|
|
lunamethod(Ray_BindLua, SetDirection),
|
|
lunamethod(Ray_BindLua, CreateFromPoints),
|
|
lunamethod(Ray_BindLua, GetPlacementOrientation),
|
|
{ NULL, NULL }
|
|
};
|
|
Luna<Ray_BindLua>::PropertyType Ray_BindLua::properties[] = {
|
|
lunaproperty(Ray_BindLua, Origin),
|
|
lunaproperty(Ray_BindLua, Direction),
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
Ray_BindLua::Ray_BindLua(lua_State *L)
|
|
{
|
|
int argc = wi::lua::SGetArgCount(L);
|
|
if (argc > 1)
|
|
{
|
|
Vector_BindLua* o = Luna<Vector_BindLua>::lightcheck(L, 1);
|
|
Vector_BindLua* d = Luna<Vector_BindLua>::lightcheck(L, 2);
|
|
if (o && d)
|
|
{
|
|
ray = Ray(XMLoadFloat4(&o->data), XMLoadFloat4(&d->data));
|
|
if (argc > 2)
|
|
{
|
|
ray.TMin = wi::lua::SGetFloat(L, 3);
|
|
}
|
|
if (argc > 3)
|
|
{
|
|
ray.TMax = wi::lua::SGetFloat(L, 4);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
wi::lua::SError(L, "Ray(Vector origin,direction, opt float Tmin = 0, TMax = FLT_MAX) requires two arguments of Vector type!");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
wi::lua::SError(L, "Ray(Vector origin,direction) not enough arguments!");
|
|
}
|
|
}
|
|
|
|
int Ray_BindLua::Intersects(lua_State* L)
|
|
{
|
|
int argc = wi::lua::SGetArgCount(L);
|
|
if (argc > 0)
|
|
{
|
|
AABB_BindLua* aabb = Luna<AABB_BindLua>::lightcheck(L, 1);
|
|
if (aabb)
|
|
{
|
|
bool intersects = ray.intersects(aabb->aabb);
|
|
wi::lua::SSetBool(L, intersects);
|
|
return 1;
|
|
}
|
|
|
|
Sphere_BindLua* sphere = Luna<Sphere_BindLua>::lightcheck(L, 1);
|
|
if (sphere)
|
|
{
|
|
bool intersects = ray.intersects(sphere->sphere);
|
|
wi::lua::SSetBool(L, intersects);
|
|
return 1;
|
|
}
|
|
|
|
Capsule_BindLua* capsule = Luna<Capsule_BindLua>::lightcheck(L, 1);
|
|
if (capsule)
|
|
{
|
|
bool intersects = ray.intersects(capsule->capsule);
|
|
wi::lua::SSetBool(L, intersects);
|
|
return 1;
|
|
}
|
|
|
|
Vector_BindLua* vec = Luna<Vector_BindLua>::lightcheck(L, 1);
|
|
if (vec)
|
|
{
|
|
XMVECTOR P = XMLoadFloat4(&vec->data);
|
|
XMVECTOR O = XMLoadFloat3(&ray.origin);
|
|
XMVECTOR D = XMLoadFloat3(&ray.direction);
|
|
XMVECTOR I = XMPlaneIntersectLine(P, O + D * ray.TMin, O + D * ray.TMax);
|
|
Luna<Vector_BindLua>::push(L, I);
|
|
return 1;
|
|
}
|
|
|
|
}
|
|
wi::lua::SError(L, "[Intersects(AABB), Intersects(Sphere), Intersects(Capsule), Intersects(Vector)] no matching arguments! ");
|
|
return 0;
|
|
}
|
|
int Ray_BindLua::GetOrigin(lua_State* L)
|
|
{
|
|
Luna<Vector_BindLua>::push(L, XMLoadFloat3(&ray.origin));
|
|
return 1;
|
|
}
|
|
int Ray_BindLua::SetOrigin(lua_State *L)
|
|
{
|
|
int argc = wi::lua::SGetArgCount(L);
|
|
if (argc > 0)
|
|
{
|
|
Vector_BindLua* v = Luna<Vector_BindLua>::lightcheck(L, 1);
|
|
if (v != nullptr)
|
|
{
|
|
XMStoreFloat3(&ray.origin, XMLoadFloat4(&v->data));
|
|
}
|
|
else
|
|
{
|
|
wi::lua::SError(L, "SetOrigin(Vector vector) argument is not a vector!");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
wi::lua::SError(L, "SetOrigin(Vector vector) not enough arguments!");
|
|
}
|
|
return 0;
|
|
}
|
|
int Ray_BindLua::GetDirection(lua_State* L)
|
|
{
|
|
Luna<Vector_BindLua>::push(L, XMLoadFloat3(&ray.direction));
|
|
return 1;
|
|
}
|
|
int Ray_BindLua::SetDirection(lua_State *L)
|
|
{
|
|
int argc = wi::lua::SGetArgCount(L);
|
|
if (argc > 0)
|
|
{
|
|
Vector_BindLua* v = Luna<Vector_BindLua>::lightcheck(L, 1);
|
|
if (v != nullptr)
|
|
{
|
|
XMStoreFloat3(&ray.direction, XMLoadFloat4(&v->data));
|
|
}
|
|
else
|
|
{
|
|
wi::lua::SError(L, "SetDirection(Vector vector) argument is not a vector!");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
wi::lua::SError(L, "SetDirection(Vector vector) not enough arguments!");
|
|
}
|
|
return 0;
|
|
}
|
|
int Ray_BindLua::CreateFromPoints(lua_State* L)
|
|
{
|
|
int argc = wi::lua::SGetArgCount(L);
|
|
if (argc > 1)
|
|
{
|
|
Vector_BindLua* a = Luna<Vector_BindLua>::lightcheck(L, 1);
|
|
Vector_BindLua* b = Luna<Vector_BindLua>::lightcheck(L, 2);
|
|
if (a != nullptr && b != nullptr)
|
|
{
|
|
ray.CreateFromPoints(a->GetFloat3(), b->GetFloat3());
|
|
}
|
|
else
|
|
{
|
|
wi::lua::SError(L, "CreateFromPoints(Vector a,b) argument is not a vector!");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
wi::lua::SError(L, "CreateFromPoints(Vector a,b) not enough arguments!");
|
|
}
|
|
return 0;
|
|
}
|
|
int Ray_BindLua::GetPlacementOrientation(lua_State* L)
|
|
{
|
|
int argc = wi::lua::SGetArgCount(L);
|
|
if (argc > 1)
|
|
{
|
|
Vector_BindLua* position = Luna<Vector_BindLua>::lightcheck(L, 1);
|
|
if (position == nullptr)
|
|
{
|
|
wi::lua::SError(L, "GetPlacementOrientation(Vector position, normal) first argument is not a Vector!");
|
|
return 0;
|
|
}
|
|
Vector_BindLua* normal = Luna<Vector_BindLua>::lightcheck(L, 2);
|
|
if (normal == nullptr)
|
|
{
|
|
wi::lua::SError(L, "GetPlacementOrientation(Vector position, normal) second argument is not a Vector!");
|
|
return 0;
|
|
}
|
|
Luna<Matrix_BindLua>::push(L, ray.GetPlacementOrientation(position->GetFloat3(), normal->GetFloat3()));
|
|
return 1;
|
|
}
|
|
wi::lua::SError(L, "GetPlacementOrientation(Vector position, normal) not enough arguments!");
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
Luna<AABB_BindLua>::FunctionType AABB_BindLua::methods[] = {
|
|
lunamethod(AABB_BindLua, Intersects),
|
|
lunamethod(AABB_BindLua, Intersects2D),
|
|
lunamethod(AABB_BindLua, GetMin),
|
|
lunamethod(AABB_BindLua, GetMax),
|
|
lunamethod(AABB_BindLua, SetMin),
|
|
lunamethod(AABB_BindLua, SetMax),
|
|
lunamethod(AABB_BindLua, GetCenter),
|
|
lunamethod(AABB_BindLua, GetHalfExtents),
|
|
lunamethod(AABB_BindLua, Transform),
|
|
lunamethod(AABB_BindLua, GetAsBoxMatrix),
|
|
{ NULL, NULL }
|
|
};
|
|
Luna<AABB_BindLua>::PropertyType AABB_BindLua::properties[] = {
|
|
lunaproperty(AABB_BindLua, Min),
|
|
lunaproperty(AABB_BindLua, Max),
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
AABB_BindLua::AABB_BindLua(lua_State *L)
|
|
{
|
|
int argc = wi::lua::SGetArgCount(L);
|
|
if (argc > 1)
|
|
{
|
|
Vector_BindLua* _minV = Luna<Vector_BindLua>::lightcheck(L, 1);
|
|
Vector_BindLua* _maxV = Luna<Vector_BindLua>::lightcheck(L, 2);
|
|
if (_minV && _maxV)
|
|
{
|
|
XMFLOAT3 _min, _max;
|
|
XMStoreFloat3(&_min, XMLoadFloat4(&_minV->data));
|
|
XMStoreFloat3(&_max, XMLoadFloat4(&_maxV->data));
|
|
|
|
aabb = AABB(_min, _max);
|
|
}
|
|
else if (_minV)
|
|
{
|
|
XMFLOAT3 _min;
|
|
XMStoreFloat3(&_min, XMLoadFloat4(&_minV->data));
|
|
|
|
aabb = AABB(_min);
|
|
}
|
|
else
|
|
{
|
|
wi::lua::SError(L, "AABB(opt Vector min,max) arguments must be of Vector type!");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
aabb = AABB();
|
|
}
|
|
}
|
|
|
|
int AABB_BindLua::Intersects(lua_State* L)
|
|
{
|
|
int argc = wi::lua::SGetArgCount(L);
|
|
if (argc > 0)
|
|
{
|
|
Vector_BindLua* _vec = Luna<Vector_BindLua>::lightcheck(L, 1);
|
|
if (_vec)
|
|
{
|
|
wi::lua::SSetBool(L, aabb.intersects(_vec->GetFloat3()));
|
|
return 1;
|
|
}
|
|
|
|
AABB_BindLua* _aabb = Luna<AABB_BindLua>::lightcheck(L, 1);
|
|
if (_aabb)
|
|
{
|
|
//int intersects = (int)aabb.intersects(_aabb->aabb);
|
|
//wi::lua::SSetInt(L, intersects);
|
|
wi::lua::SSetBool(L, aabb.intersects(_aabb->aabb) != AABB::INTERSECTION_TYPE::OUTSIDE); // int intersection type cannot be checked like bool in lua so we give simple bool result here!
|
|
return 1;
|
|
}
|
|
|
|
Sphere_BindLua* _sphere = Luna<Sphere_BindLua>::lightcheck(L, 1);
|
|
if (_sphere)
|
|
{
|
|
bool intersects = aabb.intersects(_sphere->sphere);
|
|
wi::lua::SSetBool(L, intersects);
|
|
return 1;
|
|
}
|
|
|
|
Ray_BindLua* ray = Luna<Ray_BindLua>::lightcheck(L, 1);
|
|
if (ray)
|
|
{
|
|
bool intersects = ray->ray.intersects(aabb);
|
|
wi::lua::SSetBool(L, intersects);
|
|
return 1;
|
|
}
|
|
|
|
}
|
|
wi::lua::SError(L, "[Intersects(AABB), Intersects(Sphere), Intersects(Ray)] no matching arguments! ");
|
|
return 0;
|
|
}
|
|
int AABB_BindLua::Intersects2D(lua_State* L)
|
|
{
|
|
int argc = wi::lua::SGetArgCount(L);
|
|
if (argc > 0)
|
|
{
|
|
AABB_BindLua* _aabb = Luna<AABB_BindLua>::lightcheck(L, 1);
|
|
if (_aabb)
|
|
{
|
|
//int intersects = (int)aabb.intersects(_aabb->aabb);
|
|
//wi::lua::SSetInt(L, intersects);
|
|
wi::lua::SSetBool(L, aabb.intersects2D(_aabb->aabb) != AABB::INTERSECTION_TYPE::OUTSIDE); // int intersection type cannot be checked like bool in lua so we give simple bool result here!
|
|
return 1;
|
|
}
|
|
|
|
}
|
|
wi::lua::SError(L, "Intersects2D(AABB) not enough arguments! ");
|
|
return 0;
|
|
}
|
|
int AABB_BindLua::GetMin(lua_State* L)
|
|
{
|
|
XMFLOAT3 M = aabb.getMin();
|
|
Luna<Vector_BindLua>::push(L, XMLoadFloat3(&M));
|
|
return 1;
|
|
}
|
|
int AABB_BindLua::SetMin(lua_State *L)
|
|
{
|
|
int argc = wi::lua::SGetArgCount(L);
|
|
if (argc > 0)
|
|
{
|
|
Vector_BindLua* v = Luna<Vector_BindLua>::lightcheck(L, 1);
|
|
if (v != nullptr)
|
|
{
|
|
XMStoreFloat3(&aabb._min, XMLoadFloat4(&v->data));
|
|
}
|
|
else
|
|
{
|
|
wi::lua::SError(L, "SetMin(Vector vector) argument is not a vector!");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
wi::lua::SError(L, "SetMin(Vector vector) not enough arguments!");
|
|
}
|
|
return 0;
|
|
}
|
|
int AABB_BindLua::GetMax(lua_State* L)
|
|
{
|
|
XMFLOAT3 M = aabb.getMax();
|
|
Luna<Vector_BindLua>::push(L, XMLoadFloat3(&M));
|
|
return 1;
|
|
}
|
|
int AABB_BindLua::SetMax(lua_State *L)
|
|
{
|
|
int argc = wi::lua::SGetArgCount(L);
|
|
if (argc > 0)
|
|
{
|
|
Vector_BindLua* v = Luna<Vector_BindLua>::lightcheck(L, 1);
|
|
if (v != nullptr)
|
|
{
|
|
XMStoreFloat3(&aabb._max, XMLoadFloat4(&v->data));
|
|
}
|
|
else
|
|
{
|
|
wi::lua::SError(L, "SetMax(Vector vector) argument is not a vector!");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
wi::lua::SError(L, "SetMax(Vector vector) not enough arguments!");
|
|
}
|
|
return 0;
|
|
}
|
|
int AABB_BindLua::GetCenter(lua_State* L)
|
|
{
|
|
XMFLOAT3 C = aabb.getCenter();
|
|
Luna<Vector_BindLua>::push(L, XMLoadFloat3(&C));
|
|
return 1;
|
|
}
|
|
int AABB_BindLua::GetHalfExtents(lua_State* L)
|
|
{
|
|
XMFLOAT3 H = aabb.getHalfWidth();
|
|
Luna<Vector_BindLua>::push(L, XMLoadFloat3(&H));
|
|
return 1;
|
|
}
|
|
int AABB_BindLua::Transform(lua_State* L)
|
|
{
|
|
int argc = wi::lua::SGetArgCount(L);
|
|
if (argc > 0)
|
|
{
|
|
Matrix_BindLua* _matrix = Luna<Matrix_BindLua>::lightcheck(L, 1);
|
|
if (_matrix)
|
|
{
|
|
Luna<AABB_BindLua>::push(L, aabb.transform(_matrix->data));
|
|
return 1;
|
|
}
|
|
else
|
|
{
|
|
wi::lua::SError(L, "Transform(Matrix matrix) argument is not a Matrix! ");
|
|
}
|
|
}
|
|
wi::lua::SError(L, "Transform(Matrix matrix) not enough arguments! ");
|
|
return 0;
|
|
}
|
|
int AABB_BindLua::GetAsBoxMatrix(lua_State* L)
|
|
{
|
|
Luna<Matrix_BindLua>::push(L, aabb.getAsBoxMatrix());
|
|
return 1;
|
|
}
|
|
|
|
|
|
|
|
Luna<Sphere_BindLua>::FunctionType Sphere_BindLua::methods[] = {
|
|
lunamethod(Sphere_BindLua, Intersects),
|
|
lunamethod(Sphere_BindLua, GetCenter),
|
|
lunamethod(Sphere_BindLua, GetRadius),
|
|
lunamethod(Sphere_BindLua, SetCenter),
|
|
lunamethod(Sphere_BindLua, SetRadius),
|
|
lunamethod(Sphere_BindLua, GetPlacementOrientation),
|
|
{ NULL, NULL }
|
|
};
|
|
Luna<Sphere_BindLua>::PropertyType Sphere_BindLua::properties[] = {
|
|
lunaproperty(Sphere_BindLua, Center),
|
|
lunaproperty(Sphere_BindLua, Radius),
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
Sphere_BindLua::Sphere_BindLua(lua_State *L)
|
|
{
|
|
int argc = wi::lua::SGetArgCount(L);
|
|
if (argc > 1)
|
|
{
|
|
Vector_BindLua* cV = Luna<Vector_BindLua>::lightcheck(L, 1);
|
|
if (cV)
|
|
{
|
|
XMFLOAT3 c;
|
|
XMStoreFloat3(&c, XMLoadFloat4(&cV->data));
|
|
|
|
float r = wi::lua::SGetFloat(L, 2);
|
|
|
|
sphere = Sphere(c, r);
|
|
}
|
|
else
|
|
{
|
|
wi::lua::SError(L, "Sphere(Vector center, float radius) requires first argument to be of Vector type!");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
wi::lua::SError(L, "Sphere(Vector center, float radius) not enough arguments!");
|
|
}
|
|
}
|
|
|
|
int Sphere_BindLua::Intersects(lua_State* L)
|
|
{
|
|
int argc = wi::lua::SGetArgCount(L);
|
|
if (argc > 0)
|
|
{
|
|
Vector_BindLua* _vec = Luna<Vector_BindLua>::lightcheck(L, 1);
|
|
if (_vec)
|
|
{
|
|
bool intersects = sphere.intersects(_vec->GetFloat3());
|
|
wi::lua::SSetBool(L, intersects);
|
|
return 1;
|
|
}
|
|
|
|
AABB_BindLua* _aabb = Luna<AABB_BindLua>::lightcheck(L, 1);
|
|
if (_aabb)
|
|
{
|
|
bool intersects = sphere.intersects(_aabb->aabb);
|
|
wi::lua::SSetBool(L, intersects);
|
|
return 1;
|
|
}
|
|
|
|
Sphere_BindLua* _sphere = Luna<Sphere_BindLua>::lightcheck(L, 1);
|
|
if (_sphere)
|
|
{
|
|
bool intersects = sphere.intersects(_sphere->sphere);
|
|
wi::lua::SSetBool(L, intersects);
|
|
return 1;
|
|
}
|
|
|
|
Capsule_BindLua* _capsule = Luna<Capsule_BindLua>::lightcheck(L, 1);
|
|
if (_capsule)
|
|
{
|
|
bool intersects = sphere.intersects(_capsule->capsule);
|
|
wi::lua::SSetBool(L, intersects);
|
|
return 1;
|
|
}
|
|
|
|
Ray_BindLua* ray = Luna<Ray_BindLua>::lightcheck(L, 1);
|
|
if (ray)
|
|
{
|
|
bool intersects = ray->ray.intersects(sphere);
|
|
wi::lua::SSetBool(L, intersects);
|
|
return 1;
|
|
}
|
|
|
|
}
|
|
wi::lua::SError(L, "[Intersects(AABB), Intersects(Sphere), Intersects(Ray)] no matching arguments! ");
|
|
return 0;
|
|
}
|
|
int Sphere_BindLua::GetCenter(lua_State* L)
|
|
{
|
|
Luna<Vector_BindLua>::push(L, XMLoadFloat3(&sphere.center));
|
|
return 1;
|
|
}
|
|
int Sphere_BindLua::GetRadius(lua_State* L)
|
|
{
|
|
wi::lua::SSetFloat(L, sphere.radius);
|
|
return 1;
|
|
}
|
|
int Sphere_BindLua::SetCenter(lua_State* L)
|
|
{
|
|
int argc = wi::lua::SGetArgCount(L);
|
|
if (argc > 0)
|
|
{
|
|
Vector_BindLua* cV = Luna<Vector_BindLua>::lightcheck(L, 1);
|
|
if (cV)
|
|
{
|
|
XMStoreFloat3(&sphere.center, XMLoadFloat4(&cV->data));
|
|
}
|
|
else
|
|
{
|
|
wi::lua::SError(L, "SetCenter(Vector value) requires first argument to be of Vector type!");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
wi::lua::SError(L, "SetCenter(Vector value) not enough arguments!");
|
|
}
|
|
return 0;
|
|
}
|
|
int Sphere_BindLua::SetRadius(lua_State* L)
|
|
{
|
|
int argc = wi::lua::SGetArgCount(L);
|
|
if (argc > 0)
|
|
{
|
|
sphere.radius = wi::lua::SGetFloat(L, 1);
|
|
}
|
|
else
|
|
{
|
|
wi::lua::SError(L, "SetRadius(float value) not enough arguments!");
|
|
}
|
|
return 0;
|
|
}
|
|
int Sphere_BindLua::GetPlacementOrientation(lua_State* L)
|
|
{
|
|
int argc = wi::lua::SGetArgCount(L);
|
|
if (argc > 1)
|
|
{
|
|
Vector_BindLua* position = Luna<Vector_BindLua>::lightcheck(L, 1);
|
|
if (position == nullptr)
|
|
{
|
|
wi::lua::SError(L, "GetPlacementOrientation(Vector position, normal) first argument is not a Vector!");
|
|
return 0;
|
|
}
|
|
Vector_BindLua* normal = Luna<Vector_BindLua>::lightcheck(L, 2);
|
|
if (normal == nullptr)
|
|
{
|
|
wi::lua::SError(L, "GetPlacementOrientation(Vector position, normal) second argument is not a Vector!");
|
|
return 0;
|
|
}
|
|
Luna<Matrix_BindLua>::push(L, sphere.GetPlacementOrientation(position->GetFloat3(), normal->GetFloat3()));
|
|
return 1;
|
|
}
|
|
wi::lua::SError(L, "GetPlacementOrientation(Vector position, normal) not enough arguments!");
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
Luna<Capsule_BindLua>::FunctionType Capsule_BindLua::methods[] = {
|
|
lunamethod(Capsule_BindLua, Intersects),
|
|
lunamethod(Capsule_BindLua, GetAABB),
|
|
lunamethod(Capsule_BindLua, GetBase),
|
|
lunamethod(Capsule_BindLua, GetTip),
|
|
lunamethod(Capsule_BindLua, GetRadius),
|
|
lunamethod(Capsule_BindLua, SetBase),
|
|
lunamethod(Capsule_BindLua, SetTip),
|
|
lunamethod(Capsule_BindLua, SetRadius),
|
|
lunamethod(Capsule_BindLua, GetPlacementOrientation),
|
|
{ NULL, NULL }
|
|
};
|
|
Luna<Capsule_BindLua>::PropertyType Capsule_BindLua::properties[] = {
|
|
lunaproperty(Capsule_BindLua, Base),
|
|
lunaproperty(Capsule_BindLua, Tip),
|
|
lunaproperty(Capsule_BindLua, Radius),
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
Capsule_BindLua::Capsule_BindLua(lua_State* L)
|
|
{
|
|
int argc = wi::lua::SGetArgCount(L);
|
|
if (argc > 2)
|
|
{
|
|
Vector_BindLua* bV = Luna<Vector_BindLua>::lightcheck(L, 1);
|
|
Vector_BindLua* tV = Luna<Vector_BindLua>::lightcheck(L, 2);
|
|
if (bV && tV)
|
|
{
|
|
XMFLOAT3 b;
|
|
XMStoreFloat3(&b, XMLoadFloat4(&bV->data));
|
|
XMFLOAT3 t;
|
|
XMStoreFloat3(&t, XMLoadFloat4(&tV->data));
|
|
|
|
float r = wi::lua::SGetFloat(L, 3);
|
|
|
|
capsule = Capsule(b, t, r);
|
|
}
|
|
else
|
|
{
|
|
wi::lua::SError(L, "Capsule(Vector base, tip, float radius) requires first two arguments to be of Vector type!");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
wi::lua::SError(L, "Capsule(Vector base, tip, float radius) not enough arguments!");
|
|
}
|
|
}
|
|
|
|
int Capsule_BindLua::Intersects(lua_State* L)
|
|
{
|
|
int argc = wi::lua::SGetArgCount(L);
|
|
if (argc > 0)
|
|
{
|
|
Capsule_BindLua* _capsule = Luna<Capsule_BindLua>::lightcheck(L, 1);
|
|
if (_capsule)
|
|
{
|
|
XMFLOAT3 position = XMFLOAT3(0, 0, 0);
|
|
XMFLOAT3 normal = XMFLOAT3(0, 0, 0);
|
|
float depth = 0;
|
|
bool intersects = capsule.intersects(_capsule->capsule, position, normal, depth);
|
|
wi::lua::SSetBool(L, intersects);
|
|
Luna<Vector_BindLua>::push(L, XMLoadFloat3(&position));
|
|
Luna<Vector_BindLua>::push(L, XMLoadFloat3(&normal));
|
|
wi::lua::SSetFloat(L, depth);
|
|
return 4;
|
|
}
|
|
|
|
Sphere_BindLua* sphere = Luna<Sphere_BindLua>::lightcheck(L, 1);
|
|
if (sphere)
|
|
{
|
|
XMFLOAT3 normal = XMFLOAT3(0, 0, 0);
|
|
float depth = 0;
|
|
bool intersects = capsule.intersects(sphere->sphere, depth, normal);
|
|
wi::lua::SSetBool(L, intersects);
|
|
wi::lua::SSetFloat(L, depth);
|
|
Luna<Vector_BindLua>::push(L, XMLoadFloat3(&normal));
|
|
return 3;
|
|
}
|
|
|
|
Ray_BindLua* ray = Luna<Ray_BindLua>::lightcheck(L, 1);
|
|
if (ray)
|
|
{
|
|
wi::lua::SSetBool(L, capsule.intersects(ray->ray));
|
|
return 1;
|
|
}
|
|
|
|
Vector_BindLua* point = Luna<Vector_BindLua>::lightcheck(L, 1);
|
|
if (point)
|
|
{
|
|
wi::lua::SSetBool(L, capsule.intersects(point->GetFloat3()));
|
|
return 1;
|
|
}
|
|
}
|
|
wi::lua::SError(L, "Intersects(Capsule/Ray/Vector other) no matching arguments! ");
|
|
return 0;
|
|
}
|
|
int Capsule_BindLua::GetAABB(lua_State* L)
|
|
{
|
|
Luna<AABB_BindLua>::push(L, capsule.getAABB());
|
|
return 1;
|
|
}
|
|
int Capsule_BindLua::GetBase(lua_State* L)
|
|
{
|
|
Luna<Vector_BindLua>::push(L, XMLoadFloat3(&capsule.base));
|
|
return 1;
|
|
}
|
|
int Capsule_BindLua::GetTip(lua_State* L)
|
|
{
|
|
Luna<Vector_BindLua>::push(L, XMLoadFloat3(&capsule.tip));
|
|
return 1;
|
|
}
|
|
int Capsule_BindLua::GetRadius(lua_State* L)
|
|
{
|
|
wi::lua::SSetFloat(L, capsule.radius);
|
|
return 1;
|
|
}
|
|
int Capsule_BindLua::SetBase(lua_State* L)
|
|
{
|
|
int argc = wi::lua::SGetArgCount(L);
|
|
if (argc > 0)
|
|
{
|
|
Vector_BindLua* cV = Luna<Vector_BindLua>::lightcheck(L, 1);
|
|
if (cV)
|
|
{
|
|
XMStoreFloat3(&capsule.base, XMLoadFloat4(&cV->data));
|
|
}
|
|
else
|
|
{
|
|
wi::lua::SError(L, "SetBase(Vector value) requires first argument to be of Vector type!");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
wi::lua::SError(L, "SetBase(Vector value) not enough arguments!");
|
|
}
|
|
return 0;
|
|
}
|
|
int Capsule_BindLua::SetTip(lua_State* L)
|
|
{
|
|
int argc = wi::lua::SGetArgCount(L);
|
|
if (argc > 0)
|
|
{
|
|
Vector_BindLua* cV = Luna<Vector_BindLua>::lightcheck(L, 1);
|
|
if (cV)
|
|
{
|
|
XMStoreFloat3(&capsule.tip, XMLoadFloat4(&cV->data));
|
|
}
|
|
else
|
|
{
|
|
wi::lua::SError(L, "SetTip(Vector value) requires first argument to be of Vector type!");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
wi::lua::SError(L, "SetTip(Vector value) not enough arguments!");
|
|
}
|
|
return 0;
|
|
}
|
|
int Capsule_BindLua::SetRadius(lua_State* L)
|
|
{
|
|
int argc = wi::lua::SGetArgCount(L);
|
|
if (argc > 0)
|
|
{
|
|
capsule.radius = wi::lua::SGetFloat(L, 1);
|
|
}
|
|
else
|
|
{
|
|
wi::lua::SError(L, "SetRadius(float value) not enough arguments!");
|
|
}
|
|
return 0;
|
|
}
|
|
int Capsule_BindLua::GetPlacementOrientation(lua_State* L)
|
|
{
|
|
int argc = wi::lua::SGetArgCount(L);
|
|
if (argc > 1)
|
|
{
|
|
Vector_BindLua* position = Luna<Vector_BindLua>::lightcheck(L, 1);
|
|
if (position == nullptr)
|
|
{
|
|
wi::lua::SError(L, "GetPlacementOrientation(Vector position, normal) first argument is not a Vector!");
|
|
return 0;
|
|
}
|
|
Vector_BindLua* normal = Luna<Vector_BindLua>::lightcheck(L, 2);
|
|
if (normal == nullptr)
|
|
{
|
|
wi::lua::SError(L, "GetPlacementOrientation(Vector position, normal) second argument is not a Vector!");
|
|
return 0;
|
|
}
|
|
Luna<Matrix_BindLua>::push(L, capsule.GetPlacementOrientation(position->GetFloat3(), normal->GetFloat3()));
|
|
return 1;
|
|
}
|
|
wi::lua::SError(L, "GetPlacementOrientation(Vector position, normal) not enough arguments!");
|
|
return 0;
|
|
}
|
|
|
|
}
|