//#pragma region pe_params_pos
function(SetPos)
    pe_params_pos params;

    params.pos = lua->CheckVec3(L, 2);

    self->SetParams(&params);

    return 1;
end

function(SetRotation)
    pe_params_pos params;

    params.q = lua->CheckQuat(L, 2);

    self->SetParams(&params);

    return 1;
end

function(SetScale)
    pe_params_pos params;

    params.scale = lua->CheckNumber(L, 2);

    self->SetParams(&params);

    return 1;
end

function(ActionPos)
    if (lua->IsTable(L, 2))
    {
        pe_params_pos params;

        lua->Push(L, "RecalcBounds");
        lua->GetTable(L, -2);
        if(lua->IsVec3(L, -1))
            params.bRecalcBounds = lua->CheckInteger(L, -1);

        lua->Push(L, "SimClass");
        lua->GetTable(L, -2);
        if(lua->IsNumber(L, -1))
            params.iSimClass = lua->CheckInteger(L, -1);

        lua->Push(L, "Position");
        lua->GetTable(L, -2);
        if(lua->IsVec3(L, -1))
            params.pos = lua->CheckVec3(L, -1);

        lua->Push(L, "Rotation");
        lua->GetTable(L, -2);
        if(lua->IsNumber(L, -1))
            params.q = lua->CheckQuat(L, -1);

        lua->Push(L, "Scale");
        lua->GetTable(L, -2);
        if(lua->IsNumber(L, -1))
            params.scale = lua->CheckInteger(L, -1);

        self->SetParams(&params);

        return 1;
    }
    return 0;
end


//#pragma endregion pe_params_pos

//#pragma region pe_params_outer_entity
function(SetOuterPhysicalEntity)
    pe_params_outer_entity params;

    params.pOuterEntity = lua->CheckPhysics(2);

    self->SetParams(&params);

    return 1;
end
//#pragma endregion pe_params_outer_entity

//#pragma region pe_simulation_params
function(SetDamping)
    pe_simulation_params params;

    params.damping = lua->CheckNumber(L, 2);

    self->SetParams(&params);

    return 1;
end

function(SetFreefallDamping)
    pe_simulation_params params;

    params.dampingFreefall = lua->CheckNumber(L, 2);

    self->SetParams(&params);

    return 1;
end

function(SetDensity)
    pe_simulation_params params;

    params.density = lua->CheckNumber(L, 2);

    self->SetParams(&params);

    return 1;
end

function(SetGravity)
    pe_simulation_params params;

    params.gravity = lua->CheckVec3(L, 2);

    self->SetParams(&params);

    return 1;
end

function(SetFreefallGravity)
    pe_simulation_params params;

    params.gravityFreefall = lua->CheckVec3(L, 2);

    self->SetParams(&params);

    return 1;
end

function(SetSimClass)
    pe_simulation_params params;

    params.iSimClass = lua->CheckInteger(L, 2);

    self->SetParams(&params);

    return 1;
end

function(SetMass)
    pe_simulation_params params;

    params.mass = lua->CheckNumber(L, 2);

    self->SetParams(&params);

    return 1;
end

function(SetMaxLoggedCollisions)
    pe_simulation_params params;

    params.maxLoggedCollisions = lua->CheckInteger(L, 2);

    self->SetParams(&params);

    return 1;
end

function(SetMaxTimeStep)
    pe_simulation_params params;

    params.maxTimeStep = lua->CheckNumber(L, 2);

    self->SetParams(&params);

    return 1;
end

function(SetMinEnergy)
    pe_simulation_params params;

    params.minEnergy = lua->CheckNumber(L, 2);

    self->SetParams(&params);

    return 1;
end

function(SetSoftness)
    pe_simulation_params params;

    params.softness = lua->CheckNumber(L, 2);

    self->SetParams(&params);

    return 1;
end

function(SetAngularSoftness)
    pe_simulation_params params;

    params.softnessAngular = lua->CheckNumber(L, 2);

    self->SetParams(&params);

    return 1;
end

function(SetGroupAngularSoftness)
    pe_simulation_params params;

    params.softnessAngularGroup = lua->CheckNumber(L, 2);

    self->SetParams(&params);

    return 1;
end

function(SetGroupSoftness)
    pe_simulation_params params;

    params.softnessGroup = lua->CheckNumber(L, 2);

    self->SetParams(&params);

    return 1;
end
//#pragma endregion pe_simulation_params

//#pragma region pe_params_buoyancy
function(SetFlowVariance)
    pe_params_buoyancy params;

    params.flowVariance = lua->CheckNumber(L, 2);

    self->SetParams(&params);

    return 1;
end

function(SetMedium)
    pe_params_buoyancy params;

    params.iMedium = lua->CheckInteger(L, 2);

    self->SetParams(&params);

    return 1;
end

function(SetkWaterDensity)
    pe_params_buoyancy params;

    params.kwaterDensity = lua->CheckNumber(L, 2);

    self->SetParams(&params);

    return 1;
end

function(SetkWaterResistance)
    pe_params_buoyancy params;

    params.kwaterResistance = lua->CheckNumber(L, 2);

    self->SetParams(&params);

    return 1;
end

function(SetWaterDamping)
    pe_params_buoyancy params;

    params.waterDamping = lua->CheckNumber(L, 2);

    self->SetParams(&params);

    return 1;
end

function(SetWaterDensity)
    pe_params_buoyancy params;

    params.waterDensity = lua->CheckNumber(L, 2);

    self->SetParams(&params);

    return 1;
end

function(SetWaterEmin)
    pe_params_buoyancy params;

    params.waterEmin = lua->CheckNumber(L, 2);

    self->SetParams(&params);

    return 1;
end

function(SetWaterResistance)
    pe_params_buoyancy params;

    params.waterResistance = lua->CheckNumber(L, 2);

    self->SetParams(&params);

    return 1;
end
//#pragma endregion pe_params_buoyancy

//#pragma region pe_params_flags
function(SetFlags)
    pe_params_flags params;

    params.flags = lua->CheckInteger(L, 2);

    self->SetParams(&params);

    return 1;
end
//#pragma endregion pe_params_flags

//#pragma region pe_action_impulse
function(AddAngularImpulse)
    pe_action_impulse params;

    params.angImpulse = lua->CheckVec3(L, 2);

    self->Action(&params);

    return 1;
end

function(AddImpulse)
    pe_action_impulse params;

    params.impulse = lua->CheckVec3(L, 2);

    self->Action(&params);

    //lua_pop(L, -2);

    return 1;
end

function(ActionImpulse)
    if (lua->IsTable(L, 2))
    {
        pe_action_impulse params;

        lua->Push(L, "AngularImpulse");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.angImpulse = lua->CheckVec3(L, -1);

        lua->Push(L, "ApplyTime");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.iApplyTime = lua->CheckInteger(L, -1);

        lua->Push(L, "Impulse");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.impulse = lua->CheckVec3(L, -1);

        lua->Push(L, "Part");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.ipart = lua->CheckInteger(L, -1);

        lua->Push(L, "PartID");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.partid = lua->CheckInteger(L, -1);

        lua->Push(L, "Point");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.pofunction(= lua->CheckVec3(L, -1);

        self->Action(&params);

        return 1;
    }
    return 0;
end
//#pragma endregion pe_action_impulse

//#pragma region pe_action_reset
function(Reset)
    pe_action_reset params;

    params.bClearContacts = lua->CheckInteger(L, 2);

    self->Action(&params);

    return 1;
end
//#pragma endregion pe_action_reset

//#pragma region pe_action_awake
function(Wake)
    pe_action_awake params;

    params.bAwake = lua->CheckInteger(L, 2);

    self->Action(&params);

    return 1;
end
//#pragma endregion pe_action_awake

//#pragma region pe_action_set_velocity
function(SetVelocity)
    pe_action_set_velocity params;

    params.v = lua->CheckVec3(L, 2);

    self->Action(&params);

    return 1;
end

function(SetAngularVelocity)
    pe_action_set_velocity params;

    params.w = lua->CheckVec3(L, 2);

    self->Action(&params);

    return 1;
end

function(ActionVelocity)
    if (lua->IsTable(L, 2))
    {
        pe_action_set_velocity params;

        lua->Push(L, "Part");
        lua->GetTable(L, -2);
        if(lua->IsNumber(L, -1))
            params.ipart = lua->CheckInteger(L, -1);

        lua->Push(L, "PartID");
        lua->GetTable(L, -2);
        if(lua->IsNumber(L, -1))
            params.partid = lua->CheckInteger(L, -1);

        lua->Push(L, "Velocity");
        lua->GetTable(L, -2);
        if(lua->IsNumber(L, -1))
            params.v = lua->CheckVec3(L, -1);

        lua->Push(L, "AngularVelocity");
        lua->GetTable(L, -2);
        if(lua->IsVec3(L, -1))
            params.w = lua->CheckVec3(L, -1);

        self->Action(&params);

        return 1;
    }
    return 0;
end
//#pragma endregion pe_action_set_velocity

//#pragma endregion Set~

//#pragma region Get

//#pragma region pe_status_pos
function(GetBBoxMin)
    pe_status_pos params;

    self->GetStatus(&params);

    lua->Push(L, params.BBox[0]);

    return 1;
end

function(GetBBoxMax)
    pe_status_pos params;

    self->GetStatus(&params);

    lua->Push(L, params.BBox[1]);

    return 1;
end

function(GetFlags)
    pe_status_pos params;

    self->GetStatus(&params);

    lua->Push(L, params.flags);

    return 1;
end

function(GetSimClass)
    pe_status_pos params;

    self->GetStatus(&params);

    lua->Push(L, params.iSimClass);

    return 1;
end

function(GetPartID)
    pe_status_pos params;

    self->GetStatus(&params);

    lua->Push(L, params.partid);

    return 1;
end

function(GetPos)
    pe_status_pos params;

    self->GetStatus(&params);

    lua->Push(L, params.pos);

    return 1;
end

function(GetRotation)
    pe_status_pos params;

    self->GetStatus(&params);

    lua->Push(L, params.q);

    return 1;
end

function(GetScale)
    pe_status_pos params;

    self->GetStatus(&params);

    lua->Push(L, params.scale);

    return 1;
end
//#pragma endregion pe_status_pos

//#pragma region pe_status_random
function(GetRandomPos)
    pe_status_random params;

    self->GetStatus(&params);

    lua->Push(L, params.ran.vPos);
    lua->Push(L, params.ran.vNorm);

    return 2;
end
//#pragma endregion pe_status_random

//#pragma region pe_status_dynamics
function(GetAcceleration)
    pe_status_dynamics params;

    self->GetStatus(&params);

    lua->Push(L, params.a);

    return 1;
end

function(GetCenterOfMass)
    pe_status_dynamics params;

    self->GetStatus(&params);

    lua->Push(L, params.centerOfMass);

    return 1;
end

function(GetEnergy)
    pe_status_dynamics params;

    self->GetStatus(&params);

    lua->Push(L, params.energy);

    return 1;
end

function(GetMass)
    pe_status_dynamics params;

    self->GetStatus(&params);

    lua->Push(L, params.mass);

    return 1;
end

function(GetNumberOfContacts)
    pe_status_dynamics params;

    self->GetStatus(&params);

    lua->Push(L, params.nContacts);

    return 1;
end

function(GetSubmergedFraction)
    pe_status_dynamics params;

    self->GetStatus(&params);

    lua->Push(L, params.submergedFraction);

    return 1;
end
/*
function(GetTimeInterval)
    pe_status_dynamics params;

    self->GetStatus(&params);

    lua->Push(L, params.time_interval);

    return 1;
end*/
function(GetVelocity)
    pe_status_dynamics params;

    self->GetStatus(&params);

    lua->Push(L, params.v);

    return 1;
end

function(GetAngularVelocity)
    pe_status_dynamics params;

    self->GetStatus(&params);

    lua->Push(L, params.w);

    return 1;
end

function(GetAngularAcceleration)
    pe_status_dynamics params;

    self->GetStatus(&params);

    lua->Push(L, params.wa);

    return 1;
end
//#pragma endregion pe_status_dynamics

//#pragma region pe_status_collisions
function(GetLastCollisionAge)
    pe_status_collisions params;

    self->GetStatus(&params);

    lua->Push(L, params.age);

    return 1;
end

function(GetLastCollisionID)
    pe_status_collisions params;

    self->GetStatus(&params);

    if(!params.pHistory) return 0;

    lua->Push(L, params.pHistory->idCollider);

    return 1;
end

function(GetLastCollisionMaterials)
    pe_status_collisions params;

    self->GetStatus(&params);

    if(!params.pHistory) return 0;

    lua->Push(L, params.pHistory->idmat[1]);
    lua->Push(L, params.pHistory->idmat[2]);

    return 1;
end

function(GetLastCollisionNormal)
    pe_status_collisions params;

    self->GetStatus(&params);

    if(!params.pHistory) return 0;

    lua->Push(L, params.pHistory->n);

    return 1;
end

function(GetLastCollisionPoint)
    pe_status_collisions params;

    self->GetStatus(&params);

    if(!params.pHistory) return 0;

    lua->Push(L, params.pHistory->pt);

    return 1;
end

function(GetLastCollisionPoints)
    pe_status_collisions params;

    self->GetStatus(&params);

    if(!params.pHistory) return 0;

    lua->Push(L, params.pHistory->v[1]);
    lua->Push(L, params.pHistory->v[2]);

    return 1;
end
//#pragma endregion pe_status_collisions

//#pragma region pe_status_timeslices
function(GetPrecision)
    pe_status_timeslices params;

    self->GetStatus(&params);

    lua->Push(L, params.precision);

    return 1;
end

function(GetTimeInterval)
    pe_status_timeslices params;

    self->GetStatus(&params);

    lua->Push(L, params.time_interval);

    return 1;
end
//#pragma endregion pe_status_timeslices

//#pragma region pe_status_awake
function(IsAwake)
    pe_status_awake params;

    self->GetStatus(&params);

    lua->Push(L, params.lag);

    return 1;
end
//#pragma endregion pe_status_awake

//#pragma region Get~

//pe_params_articulated_body
function(SetArticulatedBody)
    if (lua->IsTable(L, 2))
    {
        pe_params_articulated_body params;

        lua->Push(L, "Acceleration");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.a = lua->CheckVec3(L, -1);

        lua->Push(L, "ApplyDqext");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.bApply_dqext = luaL_checkbool(L, -1);

        lua->Push(L, "Awake");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.bAwake = luaL_checkbool(L, -1);

        lua->Push(L, "CheckCollisions");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.bCheckCollisions = luaL_checkbool(L, -1);

        lua->Push(L, "CollisionResponse");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.bCollisionResp = luaL_checkbool(L, -1);

        lua->Push(L, "ExpandHinges");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.bExpandHinges = luaL_checkbool(L, -1);

        lua->Push(L, "Grounded");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.bGrounded = luaL_checkbool(L, -1);

        lua->Push(L, "InheritVelocity");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.bInheritVel = luaL_checkbool(L, -1);

        lua->Push(L, "RecalcJoints");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.bRecalcJoints = luaL_checkbool(L, -1);

        lua->Push(L, "DampingLyingMode");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.dampingLyingMode = lua->CheckNumber(L, -1);

        lua->Push(L, "GravityLyingMode");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.gravityLyingMode = lua->CheckVec3(L, -1);

        lua->Push(L, "SimType");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.iSimType = lua->CheckInteger(L, -1);

        lua->Push(L, "SimTypeLyingMode");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.iSimTypeLyingMode = lua->CheckInteger(L, -1);

        lua->Push(L, "MinEnergyLyingMode");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.minEnergyLyingMode = lua->CheckNumber(L, -1);

        lua->Push(L, "CollidingLyingMode");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.nCollLyingMode = lua->CheckInteger(L, -1);

        lua->Push(L, "Roots");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.nRoots = lua->CheckInteger(L, -1);

        lua->Push(L, "Host");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.pHost = Check(L, -1);

        lua->Push(L, "Pivot");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.pivot = lua->CheckVec3(L, -1);

        lua->Push(L, "Vec3HostPivot");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.posHostPivot = lua->CheckVec3(L, -1);

        lua->Push(L, "QuatHostPivot");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.qHostPivot = lua->CheckQuat(L, -1);

        lua->Push(L, "ScaleBounceResponse");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.scaleBounceResponse = lua->CheckNumber(L, -1);

        //I don't know what the following are shortened for
        lua->Push(L, "v");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.v = lua->CheckVec3(L, -1);

        lua->Push(L, "w");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.w = lua->CheckVec3(L, -1);

        lua->Push(L, "wa");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.wa = lua->CheckVec3(L, -1);

        lua->Push(L, self->SetParams(&params));

        return 1;
    }
    return 0;
end

function(SetJoint)
    if (lua->IsTable(L, 2))
    {
        pe_params_jofunction(params;

        lua->Push(L, "AnimationTimeStep");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.animationTimeStep = lua->CheckNumber(L, -1);

        lua->Push(L, "NoUpdate");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.bNoUpdate = luaL_checkbool(L, -1);

        lua->Push(L, "Bounciness");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.bounciness = lua->CheckVec3(L, -1);

        lua->Push(L, "Flags");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.flags = lua->CheckInteger(L, -1);

        lua->Push(L, "FlagsPivot");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.flagsPivot = lua->CheckInteger(L, -1);

        lua->Push(L, "kd");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.kd = lua->CheckVec3(L, -1);

        lua->Push(L, "kdashpot");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.kdashpot = lua->CheckVec3(L, -1);

        lua->Push(L, "ks");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.ks = lua->CheckVec3(L, -1);

        lua->Push(L, "Limits1");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.limits[1] = lua->CheckVec3(L, -1);

        lua->Push(L, "Limits2");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.limits[2] = lua->CheckVec3(L, -1);

        lua->Push(L, "SelfCollidingParts");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.nSelfCollidingParts = lua->CheckInteger(L, -1);

        lua->Push(L, "op1");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.op[1] = lua->CheckInteger(L, -1);

        lua->Push(L, "op2");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.op[2] = lua->CheckInteger(L, -1);

        lua->Push(L, "Pivot");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.pivot = lua->CheckVec3(L, -1);

        lua->Push(L, "Angle");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.q = Lua_Ang3::Check(L, -1);

        lua->Push(L, "Quat0");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.q0 = lua->CheckQuat(L, -1);

        lua->Push(L, "qdashpot");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.qdashpot = lua->CheckVec3(L, -1);

        lua->Push(L, "qext");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.qext = Lua_Ang3::Check(L, -1);

        lua->Push(L, "AngleTarget");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.qtarget = Lua_Ang3::Check(L, -1);

        lua->Push(L, "rAnimationTimeStep");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.ranimationTimeStep = lua->CheckNumber(L, -1);

        lua->Push(L, self->SetParams(&params));

        return 1;
    }
    return 0;
end

function(AddConstraint)
    if (lua->IsTable(L, 2))
    {
        pe_action_add_constrafunction(params;

        lua->Push(L, "Damping");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.damping = lua->CheckNumber(L, -1);

        lua->Push(L, "Flags");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.flags = lua->CheckInteger(L, -1);

        lua->Push(L, "ID");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.id = lua->CheckInteger(L, -1);

        lua->Push(L, "MaxBendTorque");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.maxBendTorque = lua->CheckNumber(L, -1);

        lua->Push(L, "MaxPullForce");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.maxPullForce = lua->CheckNumber(L, -1);

        lua->Push(L, "PartID1");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.partid[1] = lua->CheckInteger(L, -1);

        lua->Push(L, "PartID2");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.partid[2] = lua->CheckInteger(L, -1);

        lua->Push(L, "Buddy");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.pBuddy = Check(L, -1);

        lua->Push(L, "ConstraintEntity");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.pConstraintEntity = Check(L, -1);

        lua->Push(L, "Point1");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.pt[1] = lua->CheckVec3(L, -1);

        lua->Push(L, "Point1");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.pt[2] = lua->CheckVec3(L, -1);

        lua->Push(L, "QuatFrame1");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.qframe[1] = lua->CheckQuat(L, -1);

        lua->Push(L, "QuatFrame1");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.qframe[2] = lua->CheckQuat(L, -1);

        lua->Push(L, "SensorRadius");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.sensorRadius = lua->CheckNumber(L, -1);

        lua->Push(L, "XLimits1");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.xlimits[1] = lua->CheckNumber(L, -1);

        lua->Push(L, "XLimits2");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.xlimits[2] = lua->CheckNumber(L, -1);

        lua->Push(L, "YZLimits1");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.yzlimits[1] = lua->CheckNumber(L, -1);

        lua->Push(L, "YZLimits2");
        lua->GetTable(L, 2);
        if(!lua->IsNil(L, -1))
            params.yzlimits[2] = lua->CheckNumber(L, -1);

        lua->Push(L, self->Action(&params));

        return 1;
    }
    return 0;
end

function(GetEntity)
    Lua_IEntity::Push(L, gEnv->pEntitySystem->GetEntityFromPhysics(self));
    return 1;
end

function(AssignPhysicalEntity)
    IEntity *entity = gEnv->pEntitySystem->GetEntityFromPhysics(self);

    if(!entity) return 0;

    IEntityPhysicalProxy *proxy = (IEntityPhysicalProxy *)entity->GetProxy(ENTITY_PROXY_PHYSICS);

    if(!proxy) return 0;

    proxy->AssignPhysicalEntity(Get(L, 2), luaL_optint(L, 3, -1));

    return 1;
end

function(DephysicalizeFoliage)
    IEntity *entity = gEnv->pEntitySystem->GetEntityFromPhysics(self);

    if(!entity) return 0;

    IEntityPhysicalProxy *proxy = (IEntityPhysicalProxy *)entity->GetProxy(ENTITY_PROXY_PHYSICS);

    if(!proxy) return 0;

    proxy->DephysicalizeFoliage(lua->CheckInteger(L, 2));

    return 1;
end

function(EnablePhysics)
    IEntity *entity = gEnv->pEntitySystem->GetEntityFromPhysics(self);

    if(!entity) return 0;

    IEntityPhysicalProxy *proxy = (IEntityPhysicalProxy *)entity->GetProxy(ENTITY_PROXY_PHYSICS);

    if(!proxy) return 0;

    proxy->EnablePhysics(tobool(luaL_checkbool(L, 2)));

    return 1;
end

function(EnableRestrictedRagdoll)
    IEntity *entity = gEnv->pEntitySystem->GetEntityFromPhysics(self);

    if(!entity) return 0;

    IEntityPhysicalProxy *proxy = (IEntityPhysicalProxy *)entity->GetProxy(ENTITY_PROXY_PHYSICS);

    if(!proxy) return 0;

    proxy->EnableRestrictedRagdoll(tobool(luaL_checkbool(L, 2)));

    return 1;
end

function(GetLocalBounds)
    IEntity *entity = gEnv->pEntitySystem->GetEntityFromPhysics(self);

    if(!entity) return 0;

    IEntityPhysicalProxy *proxy = (IEntityPhysicalProxy *)entity->GetProxy(ENTITY_PROXY_PHYSICS);

    if(!proxy) return 0;

    AABB aabb;

    proxy->GetLocalBounds(aabb);

    lua->NewTable(L);

    lua->Push(L, "Center");
    lua->Push(L, aabb.GetCenter());
    lua->SetTable(L, -3);

    lua->Push(L, "Radius");
    lua->Push(L, aabb.GetRadius());
    lua->SetTable(L, -3);

    lua->Push(L, "Size");
    lua->Push(L, aabb.GetSize());
    lua->SetTable(L, -3);

    lua->Push(L, "Volume");
    lua->Push(L, aabb.GetVolume());
    lua->SetTable(L, -3);

    lua->Push(L, "Max");
    lua->Push(L, aabb.max);
    lua->SetTable(L, -3);

    lua->Push(L, "Min");
    lua->Push(L, aabb.min);
    lua->SetTable(L, -3);

    return 1;
end

function(GetWorldBounds)
    IEntity *entity = gEnv->pEntitySystem->GetEntityFromPhysics(self);

    if(!entity) return 0;

    IEntityPhysicalProxy *proxy = (IEntityPhysicalProxy *)entity->GetProxy(ENTITY_PROXY_PHYSICS);

    if(!proxy) return 0;

    AABB aabb;

    proxy->GetWorldBounds(aabb);

    lua->NewTable(L);

    lua->Push(L, "Center");
    lua->Push(L, aabb.GetCenter());
    lua->SetTable(L, -3);

    lua->Push(L, "Radius");
    lua->Push(L, aabb.GetRadius());
    lua->SetTable(L, -3);

    lua->Push(L, "Size");
    lua->Push(L, aabb.GetSize());
    lua->SetTable(L, -3);

    lua->Push(L, "Volume");
    lua->Push(L, aabb.GetVolume());
    lua->SetTable(L, -3);

    lua->Push(L, "Max");
    lua->Push(L, aabb.max);
    lua->SetTable(L, -3);

    lua->Push(L, "Min");
    lua->Push(L, aabb.min);
    lua->SetTable(L, -3);

    return 1;
end

function(IsRestrictedRagdoll)
    IEntity *entity = gEnv->pEntitySystem->GetEntityFromPhysics(self);

    if(!entity) return 0;

    IEntityPhysicalProxy *proxy = (IEntityPhysicalProxy *)entity->GetProxy(ENTITY_PROXY_PHYSICS);

    if(!proxy) return 0;

    lua->Push(L, proxy->IsRestrictedRagdoll());

    return 1;
end