mirror of https://github.com/bjornbytes/lovr.git
Lots of Joint stuff;
This commit is contained in:
bjorn
parent
795b585e75
commit
5d7811903b
|
|
@ -56,6 +56,7 @@ extern StringEntry lovrShapeType[];
|
|||
extern StringEntry lovrSmoothMode[];
|
||||
extern StringEntry lovrStackType[];
|
||||
extern StringEntry lovrStencilAction[];
|
||||
extern StringEntry lovrTargetType[];
|
||||
extern StringEntry lovrTextureFeature[];
|
||||
extern StringEntry lovrTextureFormat[];
|
||||
extern StringEntry lovrTextureType[];
|
||||
|
|
|
|||
|
|
@ -23,6 +23,13 @@ StringEntry lovrJointType[] = {
|
|||
{ 0 }
|
||||
};
|
||||
|
||||
StringEntry lovrTargetType[] = {
|
||||
[TARGET_NONE] = ENTRY("none"),
|
||||
[TARGET_VELOCITY] = ENTRY("velocity"),
|
||||
[TARGET_POSITION] = ENTRY("position"),
|
||||
{ 0 }
|
||||
};
|
||||
|
||||
static int l_lovrPhysicsNewWorld(lua_State* L) {
|
||||
WorldInfo info = {
|
||||
.maxColliders = 65536,
|
||||
|
|
|
|||
|
|
@ -1,6 +1,7 @@
|
|||
#include "api.h"
|
||||
#include "physics/physics.h"
|
||||
#include "util.h"
|
||||
#include <math.h>
|
||||
#include <string.h>
|
||||
|
||||
void luax_pushjoint(lua_State* L, Joint* joint) {
|
||||
|
|
@ -82,6 +83,20 @@ static int l_lovrJointSetUserData(lua_State* L) {
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int l_lovrJointGetPriority(lua_State* L) {
|
||||
Joint* joint = luax_checktype(L, 1, Joint);
|
||||
uint32_t priority = lovrJointGetPriority(joint);
|
||||
lua_pushinteger(L, priority);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int l_lovrJointSetPriority(lua_State* L) {
|
||||
Joint* joint = luax_checktype(L, 1, Joint);
|
||||
uint32_t priority = luax_checku32(L, 2);
|
||||
lovrJointSetPriority(joint, priority);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int l_lovrJointIsEnabled(lua_State* L) {
|
||||
Joint* joint = luax_checkjoint(L, 1);
|
||||
lua_pushboolean(L, lovrJointIsEnabled(joint));
|
||||
|
|
@ -116,6 +131,8 @@ static int l_lovrJointGetTorque(lua_State* L) {
|
|||
{ "getColliders", l_lovrJointGetColliders }, \
|
||||
{ "getUserData", l_lovrJointGetUserData }, \
|
||||
{ "setUserData", l_lovrJointSetUserData }, \
|
||||
{ "getPriority", l_lovrJointGetPriority }, \
|
||||
{ "setPriority", l_lovrJointSetPriority }, \
|
||||
{ "isEnabled", l_lovrJointIsEnabled }, \
|
||||
{ "setEnabled", l_lovrJointSetEnabled }, \
|
||||
{ "getForce", l_lovrJointGetForce }, \
|
||||
|
|
@ -153,43 +170,9 @@ static int l_lovrBallJointGetAnchors(lua_State* L) {
|
|||
return 6;
|
||||
}
|
||||
|
||||
static int l_lovrBallJointGetResponseTime(lua_State* L) {
|
||||
Joint* joint = luax_checkjoint(L, 1);
|
||||
float responseTime = lovrBallJointGetResponseTime(joint);
|
||||
lua_pushnumber(L, responseTime);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int l_lovrBallJointSetResponseTime(lua_State* L) {
|
||||
Joint* joint = luax_checkjoint(L, 1);
|
||||
float responseTime = luax_checkfloat(L, 2);
|
||||
lovrCheck(responseTime >= 0, "Negative response time causes simulation instability");
|
||||
lovrBallJointSetResponseTime(joint, responseTime);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int l_lovrBallJointGetTightness(lua_State* L) {
|
||||
Joint* joint = luax_checkjoint(L, 1);
|
||||
float tightness = lovrBallJointGetTightness(joint);
|
||||
lua_pushnumber(L, tightness);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int l_lovrBallJointSetTightness(lua_State* L) {
|
||||
Joint* joint = luax_checkjoint(L, 1);
|
||||
float tightness = luax_checkfloat(L, 2);
|
||||
lovrCheck(tightness >= 0, "Negative tightness factor causes simulation instability");
|
||||
lovrBallJointSetTightness(joint, tightness);
|
||||
return 0;
|
||||
}
|
||||
|
||||
const luaL_Reg lovrBallJoint[] = {
|
||||
lovrJoint,
|
||||
{ "getAnchors", l_lovrBallJointGetAnchors },
|
||||
{ "getResponseTime", l_lovrBallJointGetResponseTime},
|
||||
{ "setResponseTime", l_lovrBallJointSetResponseTime},
|
||||
{ "getTightness", l_lovrBallJointGetTightness},
|
||||
{ "setTightness", l_lovrBallJointSetTightness},
|
||||
{ NULL, NULL }
|
||||
};
|
||||
|
||||
|
|
@ -206,58 +189,47 @@ static int l_lovrDistanceJointGetAnchors(lua_State* L) {
|
|||
return 6;
|
||||
}
|
||||
|
||||
static int l_lovrDistanceJointGetDistance(lua_State* L) {
|
||||
static int l_lovrDistanceJointGetLimits(lua_State* L) {
|
||||
DistanceJoint* joint = luax_checktype(L, 1, DistanceJoint);
|
||||
lua_pushnumber(L, lovrDistanceJointGetDistance(joint));
|
||||
return 1;
|
||||
float min, max;
|
||||
lovrDistanceJointGetLimits(joint, &min, &max);
|
||||
lua_pushnumber(L, min);
|
||||
lua_pushnumber(L, max);
|
||||
return 2;
|
||||
}
|
||||
|
||||
static int l_lovrDistanceJointSetDistance(lua_State* L) {
|
||||
static int l_lovrDistanceJointSetLimits(lua_State* L) {
|
||||
DistanceJoint* joint = luax_checktype(L, 1, DistanceJoint);
|
||||
float distance = luax_checkfloat(L, 2);
|
||||
lovrDistanceJointSetDistance(joint, distance);
|
||||
float min = luax_optfloat(L, 2, 0.f);
|
||||
float max = luax_optfloat(L, 3, lua_type(L, 2) == LUA_TNUMBER ? min : HUGE_VALF);
|
||||
lovrDistanceJointSetLimits(joint, min, max);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int l_lovrDistanceJointGetResponseTime(lua_State* L) {
|
||||
Joint* joint = luax_checkjoint(L, 1);
|
||||
float responseTime = lovrDistanceJointGetResponseTime(joint);
|
||||
lua_pushnumber(L, responseTime);
|
||||
return 1;
|
||||
static int l_lovrDistanceJointGetSpring(lua_State* L) {
|
||||
DistanceJoint* joint = luax_checktype(L, 1, DistanceJoint);
|
||||
float frequency, damping;
|
||||
lovrDistanceJointGetSpring(joint, &frequency, &damping);
|
||||
lua_pushnumber(L, frequency);
|
||||
lua_pushnumber(L, damping);
|
||||
return 2;
|
||||
}
|
||||
|
||||
static int l_lovrDistanceJointSetResponseTime(lua_State* L) {
|
||||
Joint* joint = luax_checkjoint(L, 1);
|
||||
float responseTime = luax_checkfloat(L, 2);
|
||||
lovrCheck(responseTime >= 0, "Negative response time causes simulation instability");
|
||||
lovrDistanceJointSetResponseTime(joint, responseTime);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int l_lovrDistanceJointGetTightness(lua_State* L) {
|
||||
Joint* joint = luax_checkjoint(L, 1);
|
||||
float tightness = lovrDistanceJointGetTightness(joint);
|
||||
lua_pushnumber(L, tightness);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int l_lovrDistanceJointSetTightness(lua_State* L) {
|
||||
Joint* joint = luax_checkjoint(L, 1);
|
||||
float tightness = luax_checkfloat(L, 2);
|
||||
lovrCheck(tightness >= 0, "Negative tightness factor causes simulation instability");
|
||||
lovrDistanceJointSetTightness(joint, tightness);
|
||||
static int l_lovrDistanceJointSetSpring(lua_State* L) {
|
||||
DistanceJoint* joint = luax_checktype(L, 1, DistanceJoint);
|
||||
float frequency = luax_checkfloat(L, 2);
|
||||
float damping = luax_checkfloat(L, 3);
|
||||
lovrDistanceJointSetSpring(joint, frequency, damping);
|
||||
return 0;
|
||||
}
|
||||
|
||||
const luaL_Reg lovrDistanceJoint[] = {
|
||||
lovrJoint,
|
||||
{ "getAnchors", l_lovrDistanceJointGetAnchors },
|
||||
{ "getDistance", l_lovrDistanceJointGetDistance },
|
||||
{ "setDistance", l_lovrDistanceJointSetDistance },
|
||||
{ "getResponseTime", l_lovrDistanceJointGetResponseTime},
|
||||
{ "setResponseTime", l_lovrDistanceJointSetResponseTime},
|
||||
{ "getTightness", l_lovrDistanceJointGetTightness},
|
||||
{ "setTightness", l_lovrDistanceJointSetTightness},
|
||||
{ "getLimits", l_lovrDistanceJointGetLimits },
|
||||
{ "setLimits", l_lovrDistanceJointSetLimits },
|
||||
{ "getSpring", l_lovrDistanceJointGetSpring },
|
||||
{ "setSpring", l_lovrDistanceJointSetSpring },
|
||||
{ NULL, NULL }
|
||||
};
|
||||
|
||||
|
|
@ -284,59 +256,133 @@ static int l_lovrHingeJointGetAxis(lua_State* L) {
|
|||
return 3;
|
||||
}
|
||||
|
||||
static int l_lovrHingeJointSetAxis(lua_State* L) {
|
||||
HingeJoint* joint = luax_checktype(L, 1, HingeJoint);
|
||||
float axis[3];
|
||||
luax_readvec3(L, 2, axis, NULL);
|
||||
lovrHingeJointSetAxis(joint, axis);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int l_lovrHingeJointGetAngle(lua_State* L) {
|
||||
HingeJoint* joint = luax_checktype(L, 1, HingeJoint);
|
||||
lua_pushnumber(L, lovrHingeJointGetAngle(joint));
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int l_lovrHingeJointGetLowerLimit(lua_State* L) {
|
||||
HingeJoint* joint = luax_checktype(L, 1, HingeJoint);
|
||||
lua_pushnumber(L, lovrHingeJointGetLowerLimit(joint));
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int l_lovrHingeJointSetLowerLimit(lua_State* L) {
|
||||
HingeJoint* joint = luax_checktype(L, 1, HingeJoint);
|
||||
float limit = luax_checkfloat(L, 2);
|
||||
lovrHingeJointSetLowerLimit(joint, limit);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int l_lovrHingeJointGetUpperLimit(lua_State* L) {
|
||||
HingeJoint* joint = luax_checktype(L, 1, HingeJoint);
|
||||
lua_pushnumber(L, lovrHingeJointGetUpperLimit(joint));
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int l_lovrHingeJointSetUpperLimit(lua_State* L) {
|
||||
HingeJoint* joint = luax_checktype(L, 1, HingeJoint);
|
||||
float limit = luax_checkfloat(L, 2);
|
||||
lovrHingeJointSetUpperLimit(joint, limit);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int l_lovrHingeJointGetLimits(lua_State* L) {
|
||||
HingeJoint* joint = luax_checktype(L, 1, HingeJoint);
|
||||
lua_pushnumber(L, lovrHingeJointGetLowerLimit(joint));
|
||||
lua_pushnumber(L, lovrHingeJointGetUpperLimit(joint));
|
||||
float min, max;
|
||||
lovrHingeJointGetLimits(joint, &min, &max);
|
||||
lua_pushnumber(L, min);
|
||||
lua_pushnumber(L, max);
|
||||
return 2;
|
||||
}
|
||||
|
||||
static int l_lovrHingeJointSetLimits(lua_State* L) {
|
||||
HingeJoint* joint = luax_checktype(L, 1, HingeJoint);
|
||||
float lower = luax_checkfloat(L, 2);
|
||||
float upper = luax_checkfloat(L, 3);
|
||||
lovrHingeJointSetLowerLimit(joint, lower);
|
||||
lovrHingeJointSetUpperLimit(joint, upper);
|
||||
if (lua_isnoneornil(L, 2)) {
|
||||
lovrHingeJointSetLimits(joint, (float) -M_PI, (float) M_PI);
|
||||
} else {
|
||||
float min = luax_checkfloat(L, 2);
|
||||
float max = luax_checkfloat(L, 3);
|
||||
lovrHingeJointSetLimits(joint, min, max);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int l_lovrHingeJointGetFriction(lua_State* L) {
|
||||
HingeJoint* joint = luax_checktype(L, 1, HingeJoint);
|
||||
float friction = lovrHingeJointGetFriction(joint);
|
||||
lua_pushnumber(L, friction);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int l_lovrHingeJointSetFriction(lua_State* L) {
|
||||
HingeJoint* joint = luax_checktype(L, 1, HingeJoint);
|
||||
float friction = luax_optfloat(L, 2, 0.f);
|
||||
lovrHingeJointSetFriction(joint, friction);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int l_lovrHingeJointGetMotorTarget(lua_State* L) {
|
||||
HingeJoint* joint = luax_checktype(L, 1, HingeJoint);
|
||||
TargetType type;
|
||||
float value;
|
||||
lovrHingeJointGetMotorTarget(joint, &type, &value);
|
||||
if (type == TARGET_NONE) {
|
||||
lua_pushnil(L);
|
||||
return 1;
|
||||
} else {
|
||||
luax_pushenum(L, TargetType, type);
|
||||
lua_pushnumber(L, value);
|
||||
return 2;
|
||||
}
|
||||
}
|
||||
|
||||
static int l_lovrHingeJointSetMotorTarget(lua_State* L) {
|
||||
HingeJoint* joint = luax_checktype(L, 1, HingeJoint);
|
||||
if (lua_isnoneornil(L, 2)) {
|
||||
lovrHingeJointSetMotorTarget(joint, TARGET_NONE, 0.f);
|
||||
} else {
|
||||
TargetType type = luax_checkenum(L, 2, TargetType, NULL);
|
||||
float value = luax_checkfloat(L, 3);
|
||||
lovrHingeJointSetMotorTarget(joint, type, value);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int l_lovrHingeJointGetMotorSpring(lua_State* L) {
|
||||
HingeJoint* joint = luax_checktype(L, 1, HingeJoint);
|
||||
float frequency, damping;
|
||||
lovrHingeJointGetMotorSpring(joint, &frequency, &damping);
|
||||
lua_pushnumber(L, frequency);
|
||||
lua_pushnumber(L, damping);
|
||||
return 2;
|
||||
}
|
||||
|
||||
static int l_lovrHingeJointSetMotorSpring(lua_State* L) {
|
||||
HingeJoint* joint = luax_checktype(L, 1, HingeJoint);
|
||||
float frequency = luax_checkfloat(L, 2);
|
||||
float damping = luax_checkfloat(L, 3);
|
||||
lovrHingeJointSetMotorSpring(joint, frequency, damping);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int l_lovrHingeJointGetMaxMotorForce(lua_State* L) {
|
||||
HingeJoint* joint = luax_checktype(L, 1, HingeJoint);
|
||||
float positive, negative;
|
||||
lovrHingeJointGetMaxMotorForce(joint, &positive, &negative);
|
||||
lua_pushnumber(L, positive);
|
||||
lua_pushnumber(L, negative);
|
||||
return 2;
|
||||
}
|
||||
|
||||
static int l_lovrHingeJointSetMaxMotorForce(lua_State* L) {
|
||||
HingeJoint* joint = luax_checktype(L, 1, HingeJoint);
|
||||
if (lua_isnoneornil(L, 2)) {
|
||||
lovrHingeJointSetMaxMotorForce(joint, HUGE_VALF, HUGE_VALF);
|
||||
} else {
|
||||
float positive = luax_checkfloat(L, 2);
|
||||
float negative = luax_optfloat(L, 3, positive);
|
||||
lovrHingeJointSetMaxMotorForce(joint, positive, negative);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int l_lovrHingeJointGetMotorForce(lua_State* L) {
|
||||
HingeJoint* joint = luax_checktype(L, 1, HingeJoint);
|
||||
float force = lovrHingeJointGetMotorForce(joint);
|
||||
lua_pushnumber(L, force);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int l_lovrHingeJointGetSpring(lua_State* L) {
|
||||
HingeJoint* joint = luax_checktype(L, 1, HingeJoint);
|
||||
float frequency, damping;
|
||||
lovrHingeJointGetSpring(joint, &frequency, &damping);
|
||||
lua_pushnumber(L, frequency);
|
||||
lua_pushnumber(L, damping);
|
||||
return 2;
|
||||
}
|
||||
|
||||
static int l_lovrHingeJointSetSpring(lua_State* L) {
|
||||
HingeJoint* joint = luax_checktype(L, 1, HingeJoint);
|
||||
float frequency = luax_checkfloat(L, 2);
|
||||
float damping = luax_checkfloat(L, 3);
|
||||
lovrHingeJointSetSpring(joint, frequency, damping);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -344,17 +390,36 @@ const luaL_Reg lovrHingeJoint[] = {
|
|||
lovrJoint,
|
||||
{ "getAnchors", l_lovrHingeJointGetAnchors },
|
||||
{ "getAxis", l_lovrHingeJointGetAxis },
|
||||
{ "setAxis", l_lovrHingeJointSetAxis },
|
||||
{ "getAngle", l_lovrHingeJointGetAngle },
|
||||
{ "getLowerLimit", l_lovrHingeJointGetLowerLimit },
|
||||
{ "setLowerLimit", l_lovrHingeJointSetLowerLimit },
|
||||
{ "getUpperLimit", l_lovrHingeJointGetUpperLimit },
|
||||
{ "setUpperLimit", l_lovrHingeJointSetUpperLimit },
|
||||
{ "getLimits", l_lovrHingeJointGetLimits },
|
||||
{ "setLimits", l_lovrHingeJointSetLimits },
|
||||
{ "getFriction", l_lovrHingeJointGetFriction },
|
||||
{ "setFriction", l_lovrHingeJointSetFriction },
|
||||
{ "getMotorTarget", l_lovrHingeJointGetMotorTarget },
|
||||
{ "setMotorTarget", l_lovrHingeJointSetMotorTarget },
|
||||
{ "getMotorSpring", l_lovrHingeJointGetMotorSpring },
|
||||
{ "setMotorSpring", l_lovrHingeJointSetMotorSpring },
|
||||
{ "getMaxMotorForce", l_lovrHingeJointGetMaxMotorForce },
|
||||
{ "setMaxMotorForce", l_lovrHingeJointSetMaxMotorForce },
|
||||
{ "getMotorForce", l_lovrHingeJointGetMotorForce },
|
||||
{ "getSpring", l_lovrHingeJointGetSpring },
|
||||
{ "setSpring", l_lovrHingeJointSetSpring },
|
||||
{ NULL, NULL }
|
||||
};
|
||||
|
||||
static int l_lovrSliderJointGetAnchors(lua_State* L) {
|
||||
SliderJoint* joint = luax_checktype(L, 1, SliderJoint);
|
||||
float anchor1[3], anchor2[3];
|
||||
lovrSliderJointGetAnchors(joint, anchor1, anchor2);
|
||||
lua_pushnumber(L, anchor1[0]);
|
||||
lua_pushnumber(L, anchor1[1]);
|
||||
lua_pushnumber(L, anchor1[2]);
|
||||
lua_pushnumber(L, anchor2[0]);
|
||||
lua_pushnumber(L, anchor2[1]);
|
||||
lua_pushnumber(L, anchor2[2]);
|
||||
return 6;
|
||||
}
|
||||
|
||||
static int l_lovrSliderJointGetAxis(lua_State* L) {
|
||||
SliderJoint* joint = luax_checktype(L, 1, SliderJoint);
|
||||
float axis[3];
|
||||
|
|
@ -365,72 +430,153 @@ static int l_lovrSliderJointGetAxis(lua_State* L) {
|
|||
return 3;
|
||||
}
|
||||
|
||||
static int l_lovrSliderJointSetAxis(lua_State* L) {
|
||||
SliderJoint* joint = luax_checktype(L, 1, SliderJoint);
|
||||
float axis[3];
|
||||
luax_readvec3(L, 2, axis, NULL);
|
||||
lovrSliderJointSetAxis(joint, axis);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int l_lovrSliderJointGetPosition(lua_State* L) {
|
||||
SliderJoint* joint = luax_checktype(L, 1, SliderJoint);
|
||||
lua_pushnumber(L, lovrSliderJointGetPosition(joint));
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int l_lovrSliderJointGetLowerLimit(lua_State* L) {
|
||||
SliderJoint* joint = luax_checktype(L, 1, SliderJoint);
|
||||
lua_pushnumber(L, lovrSliderJointGetLowerLimit(joint));
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int l_lovrSliderJointSetLowerLimit(lua_State* L) {
|
||||
SliderJoint* joint = luax_checktype(L, 1, SliderJoint);
|
||||
float limit = luax_checkfloat(L, 2);
|
||||
lovrSliderJointSetLowerLimit(joint, limit);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int l_lovrSliderJointGetUpperLimit(lua_State* L) {
|
||||
SliderJoint* joint = luax_checktype(L, 1, SliderJoint);
|
||||
lua_pushnumber(L, lovrSliderJointGetUpperLimit(joint));
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int l_lovrSliderJointSetUpperLimit(lua_State* L) {
|
||||
SliderJoint* joint = luax_checktype(L, 1, SliderJoint);
|
||||
float limit = luax_checkfloat(L, 2);
|
||||
lovrSliderJointSetUpperLimit(joint, limit);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int l_lovrSliderJointGetLimits(lua_State* L) {
|
||||
SliderJoint* joint = luax_checktype(L, 1, SliderJoint);
|
||||
lua_pushnumber(L, lovrSliderJointGetLowerLimit(joint));
|
||||
lua_pushnumber(L, lovrSliderJointGetUpperLimit(joint));
|
||||
float min, max;
|
||||
lovrSliderJointGetLimits(joint, &min, &max);
|
||||
lua_pushnumber(L, min);
|
||||
lua_pushnumber(L, max);
|
||||
return 2;
|
||||
}
|
||||
|
||||
static int l_lovrSliderJointSetLimits(lua_State* L) {
|
||||
SliderJoint* joint = luax_checktype(L, 1, SliderJoint);
|
||||
float lower = luax_checkfloat(L, 2);
|
||||
float upper = luax_checkfloat(L, 3);
|
||||
lovrSliderJointSetLowerLimit(joint, lower);
|
||||
lovrSliderJointSetUpperLimit(joint, upper);
|
||||
if (lua_isnoneornil(L, 2)) {
|
||||
lovrSliderJointSetLimits(joint, (float) -HUGE_VALF, (float) HUGE_VALF);
|
||||
} else {
|
||||
float min = luax_checkfloat(L, 2);
|
||||
float max = luax_checkfloat(L, 3);
|
||||
lovrSliderJointSetLimits(joint, min, max);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int l_lovrSliderJointGetFriction(lua_State* L) {
|
||||
SliderJoint* joint = luax_checktype(L, 1, SliderJoint);
|
||||
float friction = lovrSliderJointGetFriction(joint);
|
||||
lua_pushnumber(L, friction);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int l_lovrSliderJointSetFriction(lua_State* L) {
|
||||
SliderJoint* joint = luax_checktype(L, 1, SliderJoint);
|
||||
float friction = luax_optfloat(L, 2, 0.f);
|
||||
lovrSliderJointSetFriction(joint, friction);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int l_lovrSliderJointGetMotorTarget(lua_State* L) {
|
||||
SliderJoint* joint = luax_checktype(L, 1, SliderJoint);
|
||||
TargetType type;
|
||||
float value;
|
||||
lovrSliderJointGetMotorTarget(joint, &type, &value);
|
||||
if (type == TARGET_NONE) {
|
||||
lua_pushnil(L);
|
||||
return 1;
|
||||
} else {
|
||||
luax_pushenum(L, TargetType, type);
|
||||
lua_pushnumber(L, value);
|
||||
return 2;
|
||||
}
|
||||
}
|
||||
|
||||
static int l_lovrSliderJointSetMotorTarget(lua_State* L) {
|
||||
SliderJoint* joint = luax_checktype(L, 1, SliderJoint);
|
||||
if (lua_isnoneornil(L, 2)) {
|
||||
lovrSliderJointSetMotorTarget(joint, TARGET_NONE, 0.f);
|
||||
} else {
|
||||
TargetType type = luax_checkenum(L, 2, TargetType, NULL);
|
||||
float value = luax_checkfloat(L, 3);
|
||||
lovrSliderJointSetMotorTarget(joint, type, value);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int l_lovrSliderJointGetMotorSpring(lua_State* L) {
|
||||
SliderJoint* joint = luax_checktype(L, 1, SliderJoint);
|
||||
float frequency, damping;
|
||||
lovrSliderJointGetMotorSpring(joint, &frequency, &damping);
|
||||
lua_pushnumber(L, frequency);
|
||||
lua_pushnumber(L, damping);
|
||||
return 2;
|
||||
}
|
||||
|
||||
static int l_lovrSliderJointSetMotorSpring(lua_State* L) {
|
||||
SliderJoint* joint = luax_checktype(L, 1, SliderJoint);
|
||||
float frequency = luax_checkfloat(L, 2);
|
||||
float damping = luax_checkfloat(L, 3);
|
||||
lovrSliderJointSetMotorSpring(joint, frequency, damping);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int l_lovrSliderJointGetMaxMotorForce(lua_State* L) {
|
||||
SliderJoint* joint = luax_checktype(L, 1, SliderJoint);
|
||||
float positive, negative;
|
||||
lovrSliderJointGetMaxMotorForce(joint, &positive, &negative);
|
||||
lua_pushnumber(L, positive);
|
||||
lua_pushnumber(L, negative);
|
||||
return 2;
|
||||
}
|
||||
|
||||
static int l_lovrSliderJointSetMaxMotorForce(lua_State* L) {
|
||||
SliderJoint* joint = luax_checktype(L, 1, SliderJoint);
|
||||
if (lua_isnoneornil(L, 2)) {
|
||||
lovrSliderJointSetMaxMotorForce(joint, HUGE_VALF, HUGE_VALF);
|
||||
} else {
|
||||
float positive = luax_checkfloat(L, 2);
|
||||
float negative = luax_optfloat(L, 3, positive);
|
||||
lovrSliderJointSetMaxMotorForce(joint, positive, negative);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int l_lovrSliderJointGetMotorForce(lua_State* L) {
|
||||
SliderJoint* joint = luax_checktype(L, 1, SliderJoint);
|
||||
float force = lovrSliderJointGetMotorForce(joint);
|
||||
lua_pushnumber(L, force);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int l_lovrSliderJointGetSpring(lua_State* L) {
|
||||
SliderJoint* joint = luax_checktype(L, 1, SliderJoint);
|
||||
float frequency, damping;
|
||||
lovrSliderJointGetSpring(joint, &frequency, &damping);
|
||||
lua_pushnumber(L, frequency);
|
||||
lua_pushnumber(L, damping);
|
||||
return 2;
|
||||
}
|
||||
|
||||
static int l_lovrSliderJointSetSpring(lua_State* L) {
|
||||
SliderJoint* joint = luax_checktype(L, 1, SliderJoint);
|
||||
float frequency = luax_checkfloat(L, 2);
|
||||
float damping = luax_checkfloat(L, 3);
|
||||
lovrSliderJointSetSpring(joint, frequency, damping);
|
||||
return 0;
|
||||
}
|
||||
|
||||
const luaL_Reg lovrSliderJoint[] = {
|
||||
lovrJoint,
|
||||
{ "getAnchors", l_lovrSliderJointGetAnchors },
|
||||
{ "getAxis", l_lovrSliderJointGetAxis },
|
||||
{ "setAxis", l_lovrSliderJointSetAxis },
|
||||
{ "getPosition", l_lovrSliderJointGetPosition },
|
||||
{ "getLowerLimit", l_lovrSliderJointGetLowerLimit },
|
||||
{ "setLowerLimit", l_lovrSliderJointSetLowerLimit },
|
||||
{ "getUpperLimit", l_lovrSliderJointGetUpperLimit },
|
||||
{ "setUpperLimit", l_lovrSliderJointSetUpperLimit },
|
||||
{ "getLimits", l_lovrSliderJointGetLimits },
|
||||
{ "setLimits", l_lovrSliderJointSetLimits },
|
||||
{ "getFriction", l_lovrSliderJointGetFriction },
|
||||
{ "setFriction", l_lovrSliderJointSetFriction },
|
||||
{ "getMotorTarget", l_lovrSliderJointGetMotorTarget },
|
||||
{ "setMotorTarget", l_lovrSliderJointSetMotorTarget },
|
||||
{ "getMotorSpring", l_lovrSliderJointGetMotorSpring },
|
||||
{ "setMotorSpring", l_lovrSliderJointSetMotorSpring },
|
||||
{ "getMaxMotorForce", l_lovrSliderJointGetMaxMotorForce },
|
||||
{ "setMaxMotorForce", l_lovrSliderJointSetMaxMotorForce },
|
||||
{ "getMotorForce", l_lovrSliderJointGetMotorForce },
|
||||
{ "getSpring", l_lovrSliderJointGetSpring },
|
||||
{ "setSpring", l_lovrSliderJointSetSpring },
|
||||
{ NULL, NULL }
|
||||
};
|
||||
|
|
|
|||
|
|
@ -208,6 +208,12 @@ typedef enum {
|
|||
JOINT_SLIDER
|
||||
} JointType;
|
||||
|
||||
typedef enum {
|
||||
TARGET_NONE,
|
||||
TARGET_VELOCITY,
|
||||
TARGET_POSITION
|
||||
} TargetType;
|
||||
|
||||
void lovrJointDestroy(void* ref);
|
||||
void lovrJointDestroyData(Joint* joint);
|
||||
bool lovrJointIsDestroyed(Joint* joint);
|
||||
|
|
@ -215,6 +221,8 @@ JointType lovrJointGetType(Joint* joint);
|
|||
Collider* lovrJointGetColliderA(Joint* joint);
|
||||
Collider* lovrJointGetColliderB(Joint* joint);
|
||||
Joint* lovrJointGetNext(Joint* joint, Collider* collider);
|
||||
uint32_t lovrJointGetPriority(Joint* joint);
|
||||
void lovrJointSetPriority(Joint* joint, uint32_t priority);
|
||||
bool lovrJointIsEnabled(Joint* joint);
|
||||
void lovrJointSetEnabled(Joint* joint, bool enable);
|
||||
float lovrJointGetForce(Joint* joint);
|
||||
|
|
@ -225,38 +233,49 @@ void lovrWeldJointGetAnchors(WeldJoint* joint, float anchor1[3], float anchor2[3
|
|||
|
||||
BallJoint* lovrBallJointCreate(Collider* a, Collider* b, float anchor[3]);
|
||||
void lovrBallJointGetAnchors(BallJoint* joint, float anchor1[3], float anchor2[3]);
|
||||
float lovrBallJointGetResponseTime(Joint* joint);
|
||||
void lovrBallJointSetResponseTime(Joint* joint, float responseTime);
|
||||
float lovrBallJointGetTightness(Joint* joint);
|
||||
void lovrBallJointSetTightness(Joint* joint, float tightness);
|
||||
|
||||
DistanceJoint* lovrDistanceJointCreate(Collider* a, Collider* b, float anchor1[3], float anchor2[3]);
|
||||
void lovrDistanceJointGetAnchors(DistanceJoint* joint, float anchor1[3], float anchor2[3]);
|
||||
float lovrDistanceJointGetDistance(DistanceJoint* joint);
|
||||
void lovrDistanceJointSetDistance(DistanceJoint* joint, float distance);
|
||||
float lovrDistanceJointGetResponseTime(Joint* joint);
|
||||
void lovrDistanceJointSetResponseTime(Joint* joint, float responseTime);
|
||||
float lovrDistanceJointGetTightness(Joint* joint);
|
||||
void lovrDistanceJointSetTightness(Joint* joint, float tightness);
|
||||
void lovrDistanceJointGetLimits(DistanceJoint* joint, float* min, float* max);
|
||||
void lovrDistanceJointSetLimits(DistanceJoint* joint, float min, float max);
|
||||
void lovrDistanceJointGetSpring(DistanceJoint* joint, float* frequency, float* damping);
|
||||
void lovrDistanceJointSetSpring(DistanceJoint* joint, float frequency, float damping);
|
||||
|
||||
HingeJoint* lovrHingeJointCreate(Collider* a, Collider* b, float anchor[3], float axis[3]);
|
||||
void lovrHingeJointGetAnchors(HingeJoint* joint, float anchor1[3], float anchor2[3]);
|
||||
void lovrHingeJointGetAxis(HingeJoint* joint, float axis[3]);
|
||||
void lovrHingeJointSetAxis(HingeJoint* joint, float axis[3]);
|
||||
float lovrHingeJointGetAngle(HingeJoint* joint);
|
||||
float lovrHingeJointGetLowerLimit(HingeJoint* joint);
|
||||
void lovrHingeJointSetLowerLimit(HingeJoint* joint, float limit);
|
||||
float lovrHingeJointGetUpperLimit(HingeJoint* joint);
|
||||
void lovrHingeJointSetUpperLimit(HingeJoint* joint, float limit);
|
||||
void lovrHingeJointGetLimits(HingeJoint* joint, float* min, float* max);
|
||||
void lovrHingeJointSetLimits(HingeJoint* joint, float min, float max);
|
||||
float lovrHingeJointGetFriction(HingeJoint* joint);
|
||||
void lovrHingeJointSetFriction(HingeJoint* joint, float friction);
|
||||
void lovrHingeJointGetMotorTarget(HingeJoint* joint, TargetType* type, float* value);
|
||||
void lovrHingeJointSetMotorTarget(HingeJoint* joint, TargetType type, float value);
|
||||
void lovrHingeJointGetMotorSpring(HingeJoint* joint, float* frequency, float* damping);
|
||||
void lovrHingeJointSetMotorSpring(HingeJoint* joint, float frequency, float damping);
|
||||
void lovrHingeJointGetMaxMotorForce(HingeJoint* joint, float* positive, float* negative);
|
||||
void lovrHingeJointSetMaxMotorForce(HingeJoint* joint, float positive, float negative);
|
||||
float lovrHingeJointGetMotorForce(HingeJoint* joint);
|
||||
void lovrHingeJointGetSpring(HingeJoint* joint, float* frequency, float* damping);
|
||||
void lovrHingeJointSetSpring(HingeJoint* joint, float frequency, float damping);
|
||||
|
||||
SliderJoint* lovrSliderJointCreate(Collider* a, Collider* b, float axis[3]);
|
||||
void lovrSliderJointGetAnchors(SliderJoint* joint, float anchor1[3], float anchor2[3]);
|
||||
void lovrSliderJointGetAxis(SliderJoint* joint, float axis[3]);
|
||||
void lovrSliderJointSetAxis(SliderJoint* joint, float axis[3]);
|
||||
float lovrSliderJointGetPosition(SliderJoint* joint);
|
||||
float lovrSliderJointGetLowerLimit(SliderJoint* joint);
|
||||
void lovrSliderJointSetLowerLimit(SliderJoint* joint, float limit);
|
||||
float lovrSliderJointGetUpperLimit(SliderJoint* joint);
|
||||
void lovrSliderJointSetUpperLimit(SliderJoint* joint, float limit);
|
||||
void lovrSliderJointGetLimits(SliderJoint* joint, float* min, float* max);
|
||||
void lovrSliderJointSetLimits(SliderJoint* joint, float min, float max);
|
||||
float lovrSliderJointGetFriction(SliderJoint* joint);
|
||||
void lovrSliderJointSetFriction(SliderJoint* joint, float friction);
|
||||
void lovrSliderJointGetMotorTarget(SliderJoint* joint, TargetType* type, float* value);
|
||||
void lovrSliderJointSetMotorTarget(SliderJoint* joint, TargetType type, float value);
|
||||
void lovrSliderJointGetMotorSpring(SliderJoint* joint, float* frequency, float* damping);
|
||||
void lovrSliderJointSetMotorSpring(SliderJoint* joint, float frequency, float damping);
|
||||
void lovrSliderJointGetMaxMotorForce(SliderJoint* joint, float* positive, float* negative);
|
||||
void lovrSliderJointSetMaxMotorForce(SliderJoint* joint, float positive, float negative);
|
||||
float lovrSliderJointGetMotorForce(SliderJoint* joint);
|
||||
void lovrSliderJointGetSpring(SliderJoint* joint, float* frequency, float* damping);
|
||||
void lovrSliderJointSetSpring(SliderJoint* joint, float frequency, float damping);
|
||||
|
||||
// These tokens need to exist for Lua bindings
|
||||
#define lovrWeldJointDestroy lovrJointDestroy
|
||||
|
|
|
|||
|
|
@ -1108,6 +1108,14 @@ Joint* lovrJointGetNext(Joint* joint, Collider* collider) {
|
|||
return lovrJointGetNode(joint, collider)->next;
|
||||
}
|
||||
|
||||
uint32_t lovrJointGetPriority(Joint* joint) {
|
||||
return JPH_Constraint_GetConstraintPriority(joint->constraint);
|
||||
}
|
||||
|
||||
void lovrJointSetPriority(Joint* joint, uint32_t priority) {
|
||||
JPH_Constraint_SetConstraintPriority(joint->constraint, priority);
|
||||
}
|
||||
|
||||
bool lovrJointIsEnabled(Joint* joint) {
|
||||
return JPH_Constraint_GetEnabled(joint->constraint);
|
||||
}
|
||||
|
|
@ -1159,16 +1167,18 @@ float lovrJointGetTorque(Joint* joint) {
|
|||
}
|
||||
}
|
||||
|
||||
// WeldJoint
|
||||
|
||||
WeldJoint* lovrWeldJointCreate(Collider* a, Collider* b, float anchor[3]) {
|
||||
lovrCheck(a->world == b->world, "Joint bodies must exist in same World");
|
||||
WeldJoint* joint = lovrCalloc(sizeof(WeldJoint));
|
||||
joint->ref = 1;
|
||||
joint->type = JOINT_WELD;
|
||||
JPH_FixedConstraintSettings* settings = JPH_FixedConstraintSettings_Create();
|
||||
JPH_FixedConstraintSettings_SetPoint1(settings, vec3_toJolt(anchor));
|
||||
JPH_FixedConstraintSettings_SetPoint2(settings, vec3_toJolt(anchor));
|
||||
joint->constraint = (JPH_Constraint*) JPH_FixedConstraintSettings_CreateConstraint(settings, a->body, b->body);
|
||||
JPH_ConstraintSettings_Destroy((JPH_ConstraintSettings*) settings);
|
||||
JPH_FixedConstraintSettings settings;
|
||||
JPH_FixedConstraintSettings_InitDefault(&settings);
|
||||
settings.point1 = (JPH_Vec3) { anchor[0], anchor[1], anchor[2] };
|
||||
settings.point2 = (JPH_Vec3) { anchor[0], anchor[1], anchor[2] };
|
||||
joint->constraint = (JPH_Constraint*) JPH_FixedConstraintSettings_CreateConstraint(&settings, a->body, b->body);
|
||||
JPH_PhysicsSystem_AddConstraint(a->world->system, joint->constraint);
|
||||
lovrJointInit(joint, a, b);
|
||||
lovrRetain(joint);
|
||||
|
|
@ -1179,6 +1189,8 @@ void lovrWeldJointGetAnchors(WeldJoint* joint, float anchor1[3], float anchor2[3
|
|||
lovrJointGetAnchors((Joint*) joint, anchor1, anchor2);
|
||||
}
|
||||
|
||||
// BallJoint
|
||||
|
||||
BallJoint* lovrBallJointCreate(Collider* a, Collider* b, float anchor[3]) {
|
||||
lovrCheck(a->world == b->world, "Joint bodies must exist in same World");
|
||||
BallJoint* joint = lovrCalloc(sizeof(BallJoint));
|
||||
|
|
@ -1200,21 +1212,7 @@ void lovrBallJointGetAnchors(BallJoint* joint, float anchor1[3], float anchor2[3
|
|||
lovrJointGetAnchors((Joint*) joint, anchor1, anchor2);
|
||||
}
|
||||
|
||||
float lovrBallJointGetResponseTime(Joint* joint) {
|
||||
lovrLog(LOG_WARN, "PHY", "Jolt does not support BallJoint response time");
|
||||
}
|
||||
|
||||
void lovrBallJointSetResponseTime(Joint* joint, float responseTime) {
|
||||
lovrLog(LOG_WARN, "PHY", "Jolt does not support BallJoint response time");
|
||||
}
|
||||
|
||||
float lovrBallJointGetTightness(Joint* joint) {
|
||||
lovrLog(LOG_WARN, "PHY", "Jolt does not support BallJoint tightness");
|
||||
}
|
||||
|
||||
void lovrBallJointSetTightness(Joint* joint, float tightness) {
|
||||
lovrLog(LOG_WARN, "PHY", "Jolt does not support BallJoint tightness");
|
||||
}
|
||||
// DistanceJoint
|
||||
|
||||
DistanceJoint* lovrDistanceJointCreate(Collider* a, Collider* b, float anchor1[3], float anchor2[3]) {
|
||||
lovrCheck(a->world == b->world, "Joint bodies must exist in same World");
|
||||
|
|
@ -1237,35 +1235,30 @@ void lovrDistanceJointGetAnchors(DistanceJoint* joint, float anchor1[3], float a
|
|||
lovrJointGetAnchors((Joint*) joint, anchor1, anchor2);
|
||||
}
|
||||
|
||||
float lovrDistanceJointGetDistance(DistanceJoint* joint) {
|
||||
return JPH_DistanceConstraint_GetMaxDistance((JPH_DistanceConstraint*) joint->constraint);
|
||||
void lovrDistanceJointGetLimits(DistanceJoint* joint, float* min, float* max) {
|
||||
*min = JPH_DistanceConstraint_GetMinDistance((JPH_DistanceConstraint*) joint->constraint);
|
||||
*max = JPH_DistanceConstraint_GetMaxDistance((JPH_DistanceConstraint*) joint->constraint);
|
||||
}
|
||||
|
||||
void lovrDistanceJointSetDistance(DistanceJoint* joint, float distance) {
|
||||
JPH_DistanceConstraint_SetDistance((JPH_DistanceConstraint*) joint->constraint, distance, distance);
|
||||
void lovrDistanceJointSetLimits(DistanceJoint* joint, float min, float max) {
|
||||
JPH_DistanceConstraint_SetDistance((JPH_DistanceConstraint*) joint->constraint, min, max);
|
||||
}
|
||||
|
||||
float lovrDistanceJointGetResponseTime(Joint* joint) {
|
||||
JPH_SpringSettings* settings = JPH_DistanceConstraint_GetLimitsSpringSettings((JPH_DistanceConstraint*) joint->constraint);
|
||||
return 1.f / JPH_SpringSettings_GetFrequency(settings);
|
||||
void lovrDistanceJointGetSpring(DistanceJoint* joint, float* frequency, float* damping) {
|
||||
JPH_SpringSettings settings;
|
||||
JPH_DistanceConstraint_GetLimitsSpringSettings((JPH_DistanceConstraint*) joint->constraint, &settings);
|
||||
*frequency = settings.frequencyOrStiffness;
|
||||
*damping = settings.damping;
|
||||
}
|
||||
|
||||
void lovrDistanceJointSetResponseTime(Joint* joint, float responseTime) {
|
||||
JPH_SpringSettings* settings = JPH_SpringSettings_Create(1.f / responseTime, 0.f);
|
||||
JPH_DistanceConstraint_SetLimitsSpringSettings((JPH_DistanceConstraint*) joint->constraint, settings);
|
||||
JPH_SpringSettings_Destroy(settings);
|
||||
void lovrDistanceJointSetSpring(DistanceJoint* joint, float frequency, float damping) {
|
||||
JPH_DistanceConstraint_SetLimitsSpringSettings((JPH_DistanceConstraint*) joint->constraint, &(JPH_SpringSettings) {
|
||||
.frequencyOrStiffness = frequency,
|
||||
.damping = damping
|
||||
});
|
||||
}
|
||||
|
||||
float lovrDistanceJointGetTightness(Joint* joint) {
|
||||
// todo: jolt has spring damping instead of tightness, not compatible with lovr API
|
||||
// (but body's damping is not that different)
|
||||
lovrLog(LOG_WARN, "PHY", "Jolt does not support DistanceJoint tightness");
|
||||
return 0.f;
|
||||
}
|
||||
|
||||
void lovrDistanceJointSetTightness(Joint* joint, float tightness) {
|
||||
lovrLog(LOG_WARN, "PHY", "Jolt does not support DistanceJoint tightness");
|
||||
}
|
||||
// HingeJoint
|
||||
|
||||
HingeJoint* lovrHingeJointCreate(Collider* a, Collider* b, float anchor[3], float axis[3]) {
|
||||
lovrCheck(a->world == b->world, "Joint bodies must exist in the same World");
|
||||
|
|
@ -1313,33 +1306,105 @@ void lovrHingeJointGetAxis(HingeJoint* joint, float axis[3]) {
|
|||
axis[2] = translation[2];
|
||||
}
|
||||
|
||||
void lovrHingeJointSetAxis(HingeJoint* joint, float axis[3]) {
|
||||
lovrLog(LOG_WARN, "PHY", "Jolt does not support modifying joint axis after creation");
|
||||
// todo: no setter available, but the constraint could be removed and re-added
|
||||
}
|
||||
|
||||
float lovrHingeJointGetAngle(HingeJoint* joint) {
|
||||
return -JPH_HingeConstraint_GetCurrentAngle((JPH_HingeConstraint*) joint->constraint);
|
||||
}
|
||||
|
||||
float lovrHingeJointGetLowerLimit(HingeJoint* joint) {
|
||||
return JPH_HingeConstraint_GetLimitsMin((JPH_HingeConstraint*) joint->constraint);
|
||||
void lovrHingeJointGetLimits(HingeJoint* joint, float* min, float* max) {
|
||||
*min = JPH_HingeConstraint_GetLimitsMin((JPH_HingeConstraint*) joint->constraint);
|
||||
*max = JPH_HingeConstraint_GetLimitsMax((JPH_HingeConstraint*) joint->constraint);
|
||||
}
|
||||
|
||||
void lovrHingeJointSetLowerLimit(HingeJoint* joint, float limit) {
|
||||
float upper_limit = JPH_HingeConstraint_GetLimitsMax((JPH_HingeConstraint*) joint->constraint);
|
||||
JPH_HingeConstraint_SetLimits((JPH_HingeConstraint*) joint->constraint, limit, upper_limit);
|
||||
void lovrHingeJointSetLimits(HingeJoint* joint, float min, float max) {
|
||||
JPH_HingeConstraint_SetLimits((JPH_HingeConstraint*) joint->constraint, min, max);
|
||||
}
|
||||
|
||||
float lovrHingeJointGetUpperLimit(HingeJoint* joint) {
|
||||
return JPH_HingeConstraint_GetLimitsMax((JPH_HingeConstraint*) joint->constraint);
|
||||
float lovrHingeJointGetFriction(HingeJoint* joint) {
|
||||
return JPH_HingeConstraint_GetMaxFrictionTorque((JPH_HingeConstraint*) joint->constraint);
|
||||
}
|
||||
|
||||
void lovrHingeJointSetUpperLimit(HingeJoint* joint, float limit) {
|
||||
float lower_limit = JPH_HingeConstraint_GetLimitsMin((JPH_HingeConstraint*) joint->constraint);
|
||||
JPH_HingeConstraint_SetLimits((JPH_HingeConstraint*) joint->constraint, lower_limit, limit);
|
||||
void lovrHingeJointSetFriction(HingeJoint* joint, float friction) {
|
||||
JPH_HingeConstraint_SetMaxFrictionTorque((JPH_HingeConstraint*) joint->constraint, friction);
|
||||
}
|
||||
|
||||
void lovrHingeJointGetMotorTarget(HingeJoint* joint, TargetType* type, float* value) {
|
||||
JPH_HingeConstraint* constraint = (JPH_HingeConstraint*) joint->constraint;
|
||||
JPH_MotorState motorState = JPH_HingeConstraint_GetMotorState(constraint);
|
||||
*type = (TargetType) motorState;
|
||||
switch (motorState) {
|
||||
case JPH_MotorState_Velocity: *value = JPH_HingeConstraint_GetTargetAngularVelocity(constraint); break;
|
||||
case JPH_MotorState_Position: *value = JPH_HingeConstraint_GetTargetAngle(constraint); break;
|
||||
default: *value = 0.f; break;
|
||||
}
|
||||
}
|
||||
|
||||
void lovrHingeJointSetMotorTarget(HingeJoint* joint, TargetType type, float value) {
|
||||
JPH_HingeConstraint* constraint = (JPH_HingeConstraint*) joint->constraint;
|
||||
switch (type) {
|
||||
case TARGET_VELOCITY:
|
||||
JPH_HingeConstraint_SetMotorState(constraint, JPH_MotorState_Velocity);
|
||||
JPH_HingeConstraint_SetTargetAngularVelocity(constraint, value);
|
||||
break;
|
||||
case TARGET_POSITION:
|
||||
JPH_HingeConstraint_SetMotorState(constraint, JPH_MotorState_Position);
|
||||
JPH_HingeConstraint_SetTargetAngle(constraint, value);
|
||||
break;
|
||||
default:
|
||||
JPH_HingeConstraint_SetMotorState(constraint, JPH_MotorState_Off);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void lovrHingeJointGetMotorSpring(HingeJoint* joint, float* frequency, float* damping) {
|
||||
JPH_MotorSettings settings;
|
||||
JPH_HingeConstraint_GetMotorSettings((JPH_HingeConstraint*) joint->constraint, &settings);
|
||||
*frequency = settings.springSettings.frequencyOrStiffness;
|
||||
*damping = settings.springSettings.damping;
|
||||
}
|
||||
|
||||
void lovrHingeJointSetMotorSpring(HingeJoint* joint, float frequency, float damping) {
|
||||
JPH_MotorSettings settings;
|
||||
JPH_HingeConstraint_GetMotorSettings((JPH_HingeConstraint*) joint->constraint, &settings);
|
||||
settings.springSettings.frequencyOrStiffness = frequency;
|
||||
settings.springSettings.damping = damping;
|
||||
JPH_HingeConstraint_SetMotorSettings((JPH_HingeConstraint*) joint->constraint, &settings);
|
||||
}
|
||||
|
||||
void lovrHingeJointGetMaxMotorForce(HingeJoint* joint, float* positive, float* negative) {
|
||||
JPH_MotorSettings settings;
|
||||
JPH_HingeConstraint_GetMotorSettings((JPH_HingeConstraint*) joint->constraint, &settings);
|
||||
*positive = settings.maxTorqueLimit;
|
||||
*negative = -settings.minTorqueLimit;
|
||||
}
|
||||
|
||||
void lovrHingeJointSetMaxMotorForce(HingeJoint* joint, float positive, float negative) {
|
||||
JPH_MotorSettings settings;
|
||||
JPH_HingeConstraint_GetMotorSettings((JPH_HingeConstraint*) joint->constraint, &settings);
|
||||
settings.minTorqueLimit = -negative;
|
||||
settings.maxTorqueLimit = positive;
|
||||
JPH_HingeConstraint_SetMotorSettings((JPH_HingeConstraint*) joint->constraint, &settings);
|
||||
}
|
||||
|
||||
float lovrHingeJointGetMotorForce(HingeJoint* joint) {
|
||||
return JPH_HingeConstraint_GetTotalLambdaMotor((JPH_HingeConstraint*) joint->constraint);
|
||||
}
|
||||
|
||||
void lovrHingeJointGetSpring(HingeJoint* joint, float* frequency, float* damping) {
|
||||
JPH_SpringSettings settings;
|
||||
JPH_HingeConstraint_GetLimitsSpringSettings((JPH_HingeConstraint*) joint->constraint, &settings);
|
||||
*frequency = settings.frequencyOrStiffness;
|
||||
*damping = settings.damping;
|
||||
}
|
||||
|
||||
void lovrHingeJointSetSpring(HingeJoint* joint, float frequency, float damping) {
|
||||
JPH_HingeConstraint_SetLimitsSpringSettings((JPH_HingeConstraint*) joint->constraint, &(JPH_SpringSettings) {
|
||||
.frequencyOrStiffness = frequency,
|
||||
.damping = damping
|
||||
});
|
||||
}
|
||||
|
||||
// SliderJoint
|
||||
|
||||
SliderJoint* lovrSliderJointCreate(Collider* a, Collider* b, float axis[3]) {
|
||||
lovrCheck(a->world == b->world, "Joint bodies must exist in the same World");
|
||||
|
||||
|
|
@ -1357,6 +1422,10 @@ SliderJoint* lovrSliderJointCreate(Collider* a, Collider* b, float axis[3]) {
|
|||
return joint;
|
||||
}
|
||||
|
||||
void lovrSliderJointGetAnchors(SliderJoint* joint, float anchor1[3], float anchor2[3]) {
|
||||
lovrJointGetAnchors(joint, anchor1, anchor2);
|
||||
}
|
||||
|
||||
void lovrSliderJointGetAxis(SliderJoint* joint, float axis[3]) {
|
||||
JPH_Vec3 resultAxis;
|
||||
JPH_SliderConstraintSettings* settings = JPH_SliderConstraint_GetSettings((JPH_SliderConstraint*) joint->constraint);
|
||||
|
|
@ -1378,29 +1447,99 @@ void lovrSliderJointGetAxis(SliderJoint* joint, float axis[3]) {
|
|||
axis[2] = translation[2];
|
||||
}
|
||||
|
||||
void lovrSliderJointSetAxis(SliderJoint* joint, float axis[3]) {
|
||||
lovrLog(LOG_WARN, "PHY", "Jolt does not support modifying joint axis after creation");
|
||||
// todo: no setter available, but the constraint could be removed and re-added
|
||||
}
|
||||
|
||||
float lovrSliderJointGetPosition(SliderJoint* joint) {
|
||||
return JPH_SliderConstraint_GetCurrentPosition((JPH_SliderConstraint*) joint->constraint);
|
||||
}
|
||||
|
||||
float lovrSliderJointGetLowerLimit(SliderJoint* joint) {
|
||||
return JPH_SliderConstraint_GetLimitsMin((JPH_SliderConstraint*) joint->constraint);
|
||||
void lovrSliderJointGetLimits(SliderJoint* joint, float* min, float* max) {
|
||||
*min = JPH_SliderConstraint_GetLimitsMin((JPH_SliderConstraint*) joint->constraint);
|
||||
*max = JPH_SliderConstraint_GetLimitsMax((JPH_SliderConstraint*) joint->constraint);
|
||||
}
|
||||
|
||||
void lovrSliderJointSetLowerLimit(SliderJoint* joint, float limit) {
|
||||
float upper_limit = JPH_SliderConstraint_GetLimitsMax((JPH_SliderConstraint*) joint->constraint);
|
||||
JPH_SliderConstraint_SetLimits((JPH_SliderConstraint*) joint->constraint, limit, upper_limit);
|
||||
void lovrSliderJointSetLimits(SliderJoint* joint, float min, float max) {
|
||||
JPH_SliderConstraint_SetLimits((JPH_SliderConstraint*) joint->constraint, min, max);
|
||||
}
|
||||
|
||||
float lovrSliderJointGetUpperLimit(SliderJoint* joint) {
|
||||
return JPH_SliderConstraint_GetLimitsMax((JPH_SliderConstraint*) joint->constraint);
|
||||
float lovrSliderJointGetFriction(SliderJoint* joint) {
|
||||
return JPH_SliderConstraint_GetMaxFrictionForce((JPH_SliderConstraint*) joint->constraint);
|
||||
}
|
||||
|
||||
void lovrSliderJointSetUpperLimit(SliderJoint* joint, float limit) {
|
||||
float lower_limit = JPH_SliderConstraint_GetLimitsMin((JPH_SliderConstraint*) joint->constraint);
|
||||
JPH_SliderConstraint_SetLimits((JPH_SliderConstraint*) joint->constraint, lower_limit, limit);
|
||||
void lovrSliderJointSetFriction(SliderJoint* joint, float friction) {
|
||||
JPH_SliderConstraint_SetMaxFrictionForce((JPH_SliderConstraint*) joint->constraint, friction);
|
||||
}
|
||||
|
||||
void lovrSliderJointGetMotorTarget(SliderJoint* joint, TargetType* type, float* value) {
|
||||
JPH_SliderConstraint* constraint = (JPH_SliderConstraint*) joint->constraint;
|
||||
JPH_MotorState motorState = JPH_SliderConstraint_GetMotorState(constraint);
|
||||
*type = (TargetType) motorState;
|
||||
switch (motorState) {
|
||||
case JPH_MotorState_Velocity: *value = JPH_SliderConstraint_GetTargetVelocity(constraint); break;
|
||||
case JPH_MotorState_Position: *value = JPH_SliderConstraint_GetTargetPosition(constraint); break;
|
||||
default: *value = 0.f; break;
|
||||
}
|
||||
}
|
||||
|
||||
void lovrSliderJointSetMotorTarget(SliderJoint* joint, TargetType type, float value) {
|
||||
JPH_SliderConstraint* constraint = (JPH_SliderConstraint*) joint->constraint;
|
||||
switch (type) {
|
||||
case TARGET_VELOCITY:
|
||||
JPH_SliderConstraint_SetMotorState(constraint, JPH_MotorState_Velocity);
|
||||
JPH_SliderConstraint_SetTargetVelocity(constraint, value);
|
||||
break;
|
||||
case TARGET_POSITION:
|
||||
JPH_SliderConstraint_SetMotorState(constraint, JPH_MotorState_Position);
|
||||
JPH_SliderConstraint_SetTargetPosition(constraint, value);
|
||||
break;
|
||||
default:
|
||||
JPH_SliderConstraint_SetMotorState(constraint, JPH_MotorState_Off);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void lovrSliderJointGetMotorSpring(SliderJoint* joint, float* frequency, float* damping) {
|
||||
JPH_MotorSettings settings;
|
||||
JPH_SliderConstraint_GetMotorSettings((JPH_SliderConstraint*) joint->constraint, &settings);
|
||||
*frequency = settings.springSettings.frequencyOrStiffness;
|
||||
*damping = settings.springSettings.damping;
|
||||
}
|
||||
|
||||
void lovrSliderJointSetMotorSpring(SliderJoint* joint, float frequency, float damping) {
|
||||
JPH_MotorSettings settings;
|
||||
JPH_SliderConstraint_GetMotorSettings((JPH_SliderConstraint*) joint->constraint, &settings);
|
||||
settings.springSettings.frequencyOrStiffness = frequency;
|
||||
settings.springSettings.damping = damping;
|
||||
JPH_SliderConstraint_SetMotorSettings((JPH_SliderConstraint*) joint->constraint, &settings);
|
||||
}
|
||||
|
||||
void lovrSliderJointGetMaxMotorForce(SliderJoint* joint, float* positive, float* negative) {
|
||||
JPH_MotorSettings settings;
|
||||
JPH_SliderConstraint_GetMotorSettings((JPH_SliderConstraint*) joint->constraint, &settings);
|
||||
*positive = settings.maxForceLimit;
|
||||
*negative = -settings.minForceLimit;
|
||||
}
|
||||
|
||||
void lovrSliderJointSetMaxMotorForce(SliderJoint* joint, float positive, float negative) {
|
||||
JPH_MotorSettings settings;
|
||||
JPH_SliderConstraint_GetMotorSettings((JPH_SliderConstraint*) joint->constraint, &settings);
|
||||
settings.minForceLimit = -negative;
|
||||
settings.maxForceLimit = positive;
|
||||
JPH_SliderConstraint_SetMotorSettings((JPH_SliderConstraint*) joint->constraint, &settings);
|
||||
}
|
||||
|
||||
float lovrSliderJointGetMotorForce(SliderJoint* joint) {
|
||||
return JPH_SliderConstraint_GetTotalLambdaMotor((JPH_SliderConstraint*) joint->constraint);
|
||||
}
|
||||
|
||||
void lovrSliderJointGetSpring(SliderJoint* joint, float* frequency, float* damping) {
|
||||
JPH_SpringSettings settings;
|
||||
JPH_SliderConstraint_GetLimitsSpringSettings((JPH_SliderConstraint*) joint->constraint, &settings);
|
||||
*frequency = settings.frequencyOrStiffness;
|
||||
*damping = settings.damping;
|
||||
}
|
||||
|
||||
void lovrSliderJointSetSpring(SliderJoint* joint, float frequency, float damping) {
|
||||
JPH_SliderConstraint_SetLimitsSpringSettings((JPH_SliderConstraint*) joint->constraint, &(JPH_SpringSettings) {
|
||||
.frequencyOrStiffness = frequency,
|
||||
.damping = damping
|
||||
});
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1071,6 +1071,14 @@ Collider* lovrJointGetColliderB(Joint* joint) {
|
|||
return bodyB ? dBodyGetData(bodyB) : NULL;
|
||||
}
|
||||
|
||||
uint32_t lovrJointGetPriority(Joint* joint) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
void lovrJointSetPriority(Joint* joint, uint32_t priority) {
|
||||
//
|
||||
}
|
||||
|
||||
bool lovrJointIsEnabled(Joint* joint) {
|
||||
return dJointIsEnabled(joint->id);
|
||||
}
|
||||
|
|
@ -1124,22 +1132,6 @@ void lovrBallJointGetAnchors(BallJoint* joint, float anchor1[3], float anchor2[3
|
|||
anchor2[2] = anchor[2];
|
||||
}
|
||||
|
||||
float lovrBallJointGetResponseTime(Joint* joint) {
|
||||
return dJointGetBallParam(joint->id, dParamCFM);
|
||||
}
|
||||
|
||||
void lovrBallJointSetResponseTime(Joint* joint, float responseTime) {
|
||||
dJointSetBallParam(joint->id, dParamCFM, responseTime);
|
||||
}
|
||||
|
||||
float lovrBallJointGetTightness(Joint* joint) {
|
||||
return dJointGetBallParam(joint->id, dParamERP);
|
||||
}
|
||||
|
||||
void lovrBallJointSetTightness(Joint* joint, float tightness) {
|
||||
dJointSetBallParam(joint->id, dParamERP, tightness);
|
||||
}
|
||||
|
||||
DistanceJoint* lovrDistanceJointCreate(Collider* a, Collider* b, float anchor1[3], float anchor2[3]) {
|
||||
lovrCheck(a->world == b->world, "Joint bodies must exist in same World");
|
||||
DistanceJoint* joint = lovrCalloc(sizeof(DistanceJoint));
|
||||
|
|
@ -1166,28 +1158,21 @@ void lovrDistanceJointGetAnchors(DistanceJoint* joint, float anchor1[3], float a
|
|||
anchor2[2] = anchor[2];
|
||||
}
|
||||
|
||||
float lovrDistanceJointGetDistance(DistanceJoint* joint) {
|
||||
return dJointGetDBallDistance(joint->id);
|
||||
void lovrDistanceJointGetLimits(DistanceJoint* joint, float* min, float* max) {
|
||||
*min = dJointGetDBallDistance(joint->id);
|
||||
*max = dJointGetDBallDistance(joint->id);
|
||||
}
|
||||
|
||||
void lovrDistanceJointSetDistance(DistanceJoint* joint, float distance) {
|
||||
dJointSetDBallDistance(joint->id, distance);
|
||||
void lovrDistanceJointSetLimits(DistanceJoint* joint, float min, float max) {
|
||||
dJointSetDBallDistance(joint->id, max);
|
||||
}
|
||||
|
||||
float lovrDistanceJointGetResponseTime(Joint* joint) {
|
||||
return dJointGetDBallParam(joint->id, dParamCFM);
|
||||
void lovrDistanceJointGetSpring(DistanceJoint* joint, float* frequency, float* damping) {
|
||||
// TODO
|
||||
}
|
||||
|
||||
void lovrDistanceJointSetResponseTime(Joint* joint, float responseTime) {
|
||||
dJointSetDBallParam(joint->id, dParamCFM, responseTime);
|
||||
}
|
||||
|
||||
float lovrDistanceJointGetTightness(Joint* joint) {
|
||||
return dJointGetDBallParam(joint->id, dParamERP);
|
||||
}
|
||||
|
||||
void lovrDistanceJointSetTightness(Joint* joint, float tightness) {
|
||||
dJointSetDBallParam(joint->id, dParamERP, tightness);
|
||||
void lovrDistanceJointSetSpring(DistanceJoint* joint, float frequency, float damping) {
|
||||
// TODO
|
||||
}
|
||||
|
||||
HingeJoint* lovrHingeJointCreate(Collider* a, Collider* b, float anchor[3], float axis[3]) {
|
||||
|
|
@ -1199,7 +1184,7 @@ HingeJoint* lovrHingeJointCreate(Collider* a, Collider* b, float anchor[3], floa
|
|||
dJointSetData(joint->id, joint);
|
||||
dJointAttach(joint->id, a->body, b->body);
|
||||
dJointSetHingeAnchor(joint->id, anchor[0], anchor[1], anchor[2]);
|
||||
lovrHingeJointSetAxis(joint, axis);
|
||||
dJointSetHingeAxis(joint->id, axis[0], axis[1], axis[2]);
|
||||
lovrRetain(joint);
|
||||
return joint;
|
||||
}
|
||||
|
|
@ -1224,28 +1209,62 @@ void lovrHingeJointGetAxis(HingeJoint* joint, float axis[3]) {
|
|||
axis[2] = daxis[2];
|
||||
}
|
||||
|
||||
void lovrHingeJointSetAxis(HingeJoint* joint, float axis[3]) {
|
||||
dJointSetHingeAxis(joint->id, axis[0], axis[1], axis[2]);
|
||||
}
|
||||
|
||||
float lovrHingeJointGetAngle(HingeJoint* joint) {
|
||||
return dJointGetHingeAngle(joint->id);
|
||||
}
|
||||
|
||||
float lovrHingeJointGetLowerLimit(HingeJoint* joint) {
|
||||
return dJointGetHingeParam(joint->id, dParamLoStop);
|
||||
void lovrHingeJointGetLimits(HingeJoint* joint, float* min, float* max) {
|
||||
*min = dJointGetHingeParam(joint->id, dParamLoStop);
|
||||
*max = dJointGetHingeParam(joint->id, dParamHiStop);
|
||||
}
|
||||
|
||||
void lovrHingeJointSetLowerLimit(HingeJoint* joint, float limit) {
|
||||
dJointSetHingeParam(joint->id, dParamLoStop, limit);
|
||||
void lovrHingeJointSetLimits(HingeJoint* joint, float min, float max) {
|
||||
dJointSetHingeParam(joint->id, dParamLoStop, min);
|
||||
dJointSetHingeParam(joint->id, dParamHiStop, max);
|
||||
}
|
||||
|
||||
float lovrHingeJointGetUpperLimit(HingeJoint* joint) {
|
||||
return dJointGetHingeParam(joint->id, dParamHiStop);
|
||||
float lovrHingeJointGetFriction(HingeJoint* joint) {
|
||||
return 0.f;
|
||||
}
|
||||
|
||||
void lovrHingeJointSetUpperLimit(HingeJoint* joint, float limit) {
|
||||
dJointSetHingeParam(joint->id, dParamHiStop, limit);
|
||||
void lovrHingeJointSetFriction(HingeJoint* joint, float friction) {
|
||||
//
|
||||
}
|
||||
|
||||
void lovrHingeJointGetMotorTarget(HingeJoint* joint, TargetType* type, float* value) {
|
||||
//
|
||||
}
|
||||
|
||||
void lovrHingeJointSetMotorTarget(HingeJoint* joint, TargetType type, float value) {
|
||||
//
|
||||
}
|
||||
|
||||
void lovrHingeJointGetMotorSpring(HingeJoint* joint, float* frequency, float* damping) {
|
||||
//
|
||||
}
|
||||
|
||||
void lovrHingeJointSetMotorSpring(HingeJoint* joint, float frequency, float damping) {
|
||||
//
|
||||
}
|
||||
|
||||
void lovrHingeJointGetMaxMotorForce(HingeJoint* joint, float* positive, float* negative) {
|
||||
//
|
||||
}
|
||||
|
||||
void lovrHingeJointSetMaxMotorForce(HingeJoint* joint, float positive, float negative) {
|
||||
//
|
||||
}
|
||||
|
||||
float lovrHingeJointGetMotorForce(HingeJoint* joint) {
|
||||
return 0.f;
|
||||
}
|
||||
|
||||
void lovrHingeJointGetSpring(HingeJoint* joint, float* frequency, float* damping) {
|
||||
//
|
||||
}
|
||||
|
||||
void lovrHingeJointSetSpring(HingeJoint* joint, float frequency, float damping) {
|
||||
//
|
||||
}
|
||||
|
||||
SliderJoint* lovrSliderJointCreate(Collider* a, Collider* b, float axis[3]) {
|
||||
|
|
@ -1256,11 +1275,15 @@ SliderJoint* lovrSliderJointCreate(Collider* a, Collider* b, float axis[3]) {
|
|||
joint->id = dJointCreateSlider(a->world->id, 0);
|
||||
dJointSetData(joint->id, joint);
|
||||
dJointAttach(joint->id, a->body, b->body);
|
||||
lovrSliderJointSetAxis(joint, axis);
|
||||
dJointSetSliderAxis(joint->id, axis[0], axis[1], axis[2]);
|
||||
lovrRetain(joint);
|
||||
return joint;
|
||||
}
|
||||
|
||||
void lovrSliderJointGetAnchors(SliderJoint* joint, float anchor1[3], float anchor2[3]) {
|
||||
//
|
||||
}
|
||||
|
||||
void lovrSliderJointGetAxis(SliderJoint* joint, float axis[3]) {
|
||||
dReal daxis[4];
|
||||
dJointGetSliderAxis(joint->id, axis);
|
||||
|
|
@ -1269,26 +1292,60 @@ void lovrSliderJointGetAxis(SliderJoint* joint, float axis[3]) {
|
|||
axis[2] = daxis[2];
|
||||
}
|
||||
|
||||
void lovrSliderJointSetAxis(SliderJoint* joint, float axis[3]) {
|
||||
dJointSetSliderAxis(joint->id, axis[0], axis[1], axis[2]);
|
||||
}
|
||||
|
||||
float lovrSliderJointGetPosition(SliderJoint* joint) {
|
||||
return dJointGetSliderPosition(joint->id);
|
||||
}
|
||||
|
||||
float lovrSliderJointGetLowerLimit(SliderJoint* joint) {
|
||||
return dJointGetSliderParam(joint->id, dParamLoStop);
|
||||
void lovrSliderJointGetLimits(SliderJoint* joint, float* min, float* max) {
|
||||
*min = dJointGetSliderParam(joint->id, dParamLoStop);
|
||||
*min = dJointGetSliderParam(joint->id, dParamHiStop);
|
||||
}
|
||||
|
||||
void lovrSliderJointSetLowerLimit(SliderJoint* joint, float limit) {
|
||||
dJointSetSliderParam(joint->id, dParamLoStop, limit);
|
||||
void lovrSliderJointSetLimits(SliderJoint* joint, float min, float max) {
|
||||
dJointSetSliderParam(joint->id, dParamLoStop, min);
|
||||
dJointSetSliderParam(joint->id, dParamHiStop, max);
|
||||
}
|
||||
|
||||
float lovrSliderJointGetUpperLimit(SliderJoint* joint) {
|
||||
return dJointGetSliderParam(joint->id, dParamHiStop);
|
||||
float lovrSliderJointGetFriction(SliderJoint* joint) {
|
||||
return 0.f;
|
||||
}
|
||||
|
||||
void lovrSliderJointSetUpperLimit(SliderJoint* joint, float limit) {
|
||||
dJointSetSliderParam(joint->id, dParamHiStop, limit);
|
||||
void lovrSliderJointSetFriction(SliderJoint* joint, float friction) {
|
||||
//
|
||||
}
|
||||
|
||||
void lovrSliderJointGetMotorTarget(SliderJoint* joint, TargetType* type, float* value) {
|
||||
//
|
||||
}
|
||||
|
||||
void lovrSliderJointSetMotorTarget(SliderJoint* joint, TargetType type, float value) {
|
||||
//
|
||||
}
|
||||
|
||||
void lovrSliderJointGetMotorSpring(SliderJoint* joint, float* frequency, float* damping) {
|
||||
//
|
||||
}
|
||||
|
||||
void lovrSliderJointSetMotorSpring(SliderJoint* joint, float frequency, float damping) {
|
||||
//
|
||||
}
|
||||
|
||||
void lovrSliderJointGetMaxMotorForce(SliderJoint* joint, float* positive, float* negative) {
|
||||
//
|
||||
}
|
||||
|
||||
void lovrSliderJointSetMaxMotorForce(SliderJoint* joint, float positive, float negative) {
|
||||
//
|
||||
}
|
||||
|
||||
float lovrSliderJointGetMotorForce(SliderJoint* joint) {
|
||||
return 0.f;
|
||||
}
|
||||
|
||||
void lovrSliderJointGetSpring(SliderJoint* joint, float* frequency, float* damping) {
|
||||
//
|
||||
}
|
||||
|
||||
void lovrSliderJointSetSpring(SliderJoint* joint, float frequency, float damping) {
|
||||
//
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue