int l_physics_newShape(lua_State* state)
{
l_tools_checkUserDataPlusErrMsg(state, 1, "You must provide a space");
l_tools_checkUserDataPlusErrMsg(state, 2, "You must provide a body");
l_physics_PhysicsData* physics = (l_physics_PhysicsData*)lua_touserdata(state, 1);
l_physics_Body* body = (l_physics_Body*)lua_touserdata(state, 2);
float x1 = l_tools_toNumberOrError(state, 3);
float y1 = l_tools_toNumberOrError(state, 4);
float x2 = l_tools_toNumberOrError(state, 5);
float y2 = l_tools_toNumberOrError(state, 6);
float radius = l_tools_toNumberOrError(state, 7);
moduleData.shape = (l_physics_Shape*)lua_newuserdata(state, sizeof(l_physics_Shape));
moduleData.shape->physics = malloc(sizeof(physics_PhysicsData));
moduleData.shape->physics = physics->physics;
moduleData.shape->shape = cpSpaceAddShape(physics->physics->space, cpSegmentShapeNew(body->body, cpv(x1, y1), cpv(x2, y2), radius));
lua_rawgeti(state, LUA_REGISTRYINDEX, moduleData.shapeMT);
lua_setmetatable(state, -2);
return 1;
}
static int l_geometry_rectangle(lua_State* state) {
const char* type = l_tools_toStringOrError(state, 1);
float x = l_tools_toNumberOrError(state, 2);
float y = l_tools_toNumberOrError(state, 3);
float w = l_tools_toNumberOrError(state, 4);
float h = l_tools_toNumberOrError(state, 5);
float r = 0;
if (lua_tonumber(state, 6)) r = luaL_checknumber(state, 6);
float sx = 1;
if (lua_tonumber(state, 7)) sx = luaL_checknumber(state, 7);
float sy = 1;
if (lua_tonumber(state, 8)) sy = luaL_checknumber(state, 8);
float ox = 0;
if (lua_tonumber(state, 9)) ox = luaL_checknumber(state, 9);
float oy = 0;
if (lua_tonumber(state, 10)) oy = luaL_checknumber(state, 10);
if (strncmp(type,"line",4) == 0)
graphics_geometry_fillRectangle(0, x, y, w, h, r, sx, sy, ox, oy);
else if(strncmp(type,"fill", 4) == 0)
graphics_geometry_fillRectangle(1, x, y, w, h, r, sx, sy, ox, oy);
else
{
luaL_argerror(state,1,"expected string");
lua_error(state);
}
return 1;
}
static int l_graphics_printf(lua_State* state) {
if(!moduleData.currentFont) {
l_graphics_loadDefaultFont();
}
char const* text = lua_tostring(state, 1);
if(!text) {
lua_pushstring(state, "string or number required");
return lua_error(state);
}
int x = l_tools_toNumberOrError(state, 2);
int y = l_tools_toNumberOrError(state, 3);
int limit = l_tools_toNumberOrError(state, 4);
// TODO
graphics_TextAlign align = graphics_TextAlign_left;
if(!lua_isnoneornil(state, 5)) {
align = l_tools_toEnumOrError(state, 5, l_graphics_AlignMode);
}
float r = luaL_optnumber(state, 6, 0);
float sx = luaL_optnumber(state, 7, 1.0f);
float sy = luaL_optnumber(state, 8, sx);
float ox = luaL_optnumber(state, 9, 0);
float oy = luaL_optnumber(state, 10, 0);
float kx = luaL_optnumber(state, 11, 0);
float ky = luaL_optnumber(state, 12, 0);
graphics_Font_printf(moduleData.currentFont, text, x, y, limit, align, r, sx, sy, ox, oy, kx, ky);
return 0;
}
int l_physics_newSpace(lua_State* state)
{
moduleData.onBegin = false;
moduleData.onPostSolve = false;
moduleData.onPreSolve = false;
moduleData.onSeparate = false;
//moduleData.letBeginCollide = true;
//moduleData.letPreSolveCollide = true;
float x = l_tools_toNumberOrError(state, 1);
float y = l_tools_toNumberOrError(state, 2);
moduleData.physics = (l_physics_PhysicsData*)lua_newuserdata(state, sizeof(l_physics_PhysicsData));
moduleData.physics->physics = malloc(sizeof(physics_PhysicsData));
moduleData.physics->physics->space = cpSpaceNew();
moduleData.physics->physics->gravity = cpv(x, y);
cpSpaceSetGravity(moduleData.physics->physics->space, moduleData.physics->physics->gravity);
lua_rawgeti(state, LUA_REGISTRYINDEX, moduleData.physicsMT);
lua_setmetatable(state, -2);
return 1;
}
static int l_graphics_Mesh_setVertexMap(lua_State *state) {
l_assertType(state, 1, l_graphics_isMesh);
l_graphics_Mesh *mesh = l_graphics_toMesh(state, 1);
size_t top = (size_t)lua_gettop(state);
if(top == 1) {
graphics_Mesh_setVertexMap(&mesh->mesh, 0, 0);
return 0;
}
size_t count;
if(top > 2) {
ensureBufferSize(sizeof(uint32_t) * (top - 1));
for(int i = 0; i < top - 1; ++i) {
((uint32_t*)moduleData.buffer)[i] = (uint32_t)l_tools_toNumberOrError(state, i + 2) - 1;
printf("Index: %d\n", ((uint32_t*)moduleData.buffer)[i]);
}
count = top - 1;
} else {
size_t len = (size_t)lua_objlen(state, 2);
ensureBufferSize(len * sizeof(uint32_t));
for(int i = 0; i < len; ++i) {
lua_rawgeti(state, 2, i+1);
((uint32_t*)moduleData.buffer)[i] = (uint32_t)l_tools_toNumberOrError(state, -1) - 1;
}
count = len;
}
graphics_Mesh_setVertexMap(&mesh->mesh, count, (uint32_t*)moduleData.buffer);
return 0;
}
int l_physics_newCircleShape(lua_State* state)
{
l_tools_checkUserDataPlusErrMsg(state, 1, "You must provide a space!");
l_physics_PhysicsData* physics = (l_physics_PhysicsData*)lua_touserdata(state, 1);
l_tools_checkUserDataPlusErrMsg(state, 2, "You must provide a body");
l_physics_Body* body = (l_physics_Body*)lua_touserdata(state, 2);
float radius = l_tools_toNumberOrError(state, 3);
cpVect offset = cpvzero;
offset.x = l_tools_toNumberOrError(state, 4);
offset.y = l_tools_toNumberOrError(state, 5);
moduleData.shape = (l_physics_Shape*)lua_newuserdata(state, sizeof(l_physics_Shape));
moduleData.shape->physics = malloc(sizeof(physics_PhysicsData));
moduleData.shape->physics = physics->physics;
moduleData.shape->shape = cpSpaceAddShape(physics->physics->space, cpCircleShapeNew(body->body, radius, offset));
lua_rawgeti(state, LUA_REGISTRYINDEX, moduleData.shapeMT);
lua_setmetatable(state, -2);
return 1;
}
static int l_geometry_points(lua_State* state) {
float x = l_tools_toNumberOrError(state, 1);
float y = l_tools_toNumberOrError(state, 2);
graphics_geometry_points(x,y);
return 1;
}
static int l_physics_setBodyCenterOfGravity(lua_State* state)
{
l_tools_checkUserDataPlusErrMsg(state, 1, "You must provide a body");
l_physics_Body* body = (l_physics_Body*)lua_touserdata(state, 1);
cpVect value = cpvzero;
value.x = l_tools_toNumberOrError(state, 2);
value.y = l_tools_toNumberOrError(state, 3);
cpBodySetCenterOfGravity(body->body, value);
return 0;
}
static int l_geometry_circle(lua_State* state) {
const char* type = l_tools_toStringOrError(state, 1);
float x = l_tools_toNumberOrError(state, 2);
float y = l_tools_toNumberOrError(state, 3);
float radius = l_tools_toNumberOrError(state, 4);
float segments = l_tools_toNumberOrError(state, 5);
if (strncmp(type,"line",4) == 0)
graphics_geometry_drawCircle(x, y, radius, segments);
else if(strncmp(type,"fill", 4) == 0)
graphics_geometry_fillCircle(x, y, radius, segments);
return 1;
}
static int l_physics_setBodyVelocity(lua_State* state)
{
l_tools_checkUserDataPlusErrMsg(state, 1, "You must provide a body");
l_physics_Body* body = (l_physics_Body*)lua_touserdata(state, 1);
cpVect vec = cpvzero;
vec.x = l_tools_toNumberOrError(state, 2);
vec.y = l_tools_toNumberOrError(state, 3);
cpBodySetVelocity(body->body, vec);
return 0;
}
static int l_physics_onPreSolve(lua_State* state)
{
l_physics_PhysicsData* data = (l_physics_PhysicsData*)lua_touserdata(state, 1);
uint32_t a_type = l_tools_toNumberOrError(state, 2);
uint32_t b_type = l_tools_toNumberOrError(state, 3);
moduleData.handler = cpSpaceAddCollisionHandler(data->physics->space, a_type, b_type);
moduleData.handler->preSolveFunc = preSolve;
lua_pushboolean(state, moduleData.onPreSolve);
moduleData.onPreSolve = false;
return 1;
}
static int l_graphics_SpriteBatch_set(lua_State* state) {
l_assertType(state, 1, l_graphics_isBatch);
l_graphics_Batch * batch = l_graphics_toBatch(state, 1);
int id = l_tools_toNumberOrError(state, 2);
graphics_Quad const * quad = &defaultQuad;
int baseidx = 3;
if(l_graphics_isQuad(state, 3)) {
quad = l_graphics_toQuad(state, 3);
baseidx = 4;
}
float x = luaL_optnumber(state, baseidx, 0.0f);
float y = luaL_optnumber(state, baseidx + 1, 0.0f);
float r = luaL_optnumber(state, baseidx + 2, 0.0f);
float sx = luaL_optnumber(state, baseidx + 3, 1.0f);
float sy = luaL_optnumber(state, baseidx + 4, sx);
float ox = luaL_optnumber(state, baseidx + 5, 0.0f);
float oy = luaL_optnumber(state, baseidx + 6, 0.0f);
float kx = luaL_optnumber(state, baseidx + 7, 0.0f);
float ky = luaL_optnumber(state, baseidx + 8, 0.0f);
//graphics_Batch_set(&batch->batch, id, quad, x, y, r, sx, sy, ox, oy, kx, ky);
return 0;
}
static int l_audio_SourceCommon_setVolume(lua_State *state) {
l_assertType(state, 1, isSource);
float gain = l_tools_toNumberOrError(state, 2);
audio_SourceCommon *source = (audio_SourceCommon*)lua_touserdata(state, 1);
audio_SourceCommon_setVolume(source, gain);
return 0;
}
static int l_graphics_Quad_setViewport(lua_State* state) {
l_assertType(state, 1, l_graphics_isQuad);
graphics_Quad *quad = l_graphics_toQuad(state, 1);
float x = l_tools_toNumberOrError(state, 2);
float y = l_tools_toNumberOrError(state, 3);
float w = l_tools_toNumberOrError(state, 4);
float h = l_tools_toNumberOrError(state, 5);
quad->x = x;
quad->y = y;
quad->w = w;
quad->h = h;
return 0;
}
static int l_graphics_Mesh_setDrawRange(lua_State *state) {
l_assertType(state, 1, l_graphics_isMesh);
l_graphics_Mesh * mesh = l_graphics_toMesh(state, 1);
int top = lua_gettop(state);
if(top == 3) {
int idx1 = l_tools_toNumberOrError(state, 2) - 1;
int idx2 = l_tools_toNumberOrError(state, 3) - 1;
graphics_Mesh_setDrawRange(&mesh->mesh, idx1, idx2);
} else if(top == 1) {
graphics_Mesh_resetDrawRange(&mesh->mesh);
} else {
lua_pushstring(state, "Need none or two numbers");
return lua_error(state);
}
return 0;
}
int l_graphics_SpriteBatch_setColor(lua_State* state) {
l_assertType(state, 1, l_graphics_isBatch);
l_graphics_Batch * batch = l_graphics_toBatch(state, 1);
if(!lua_isnumber(state, 2)) {
graphics_Batch_clearColor(&batch->batch);
} else {
float r = l_tools_toNumberOrError(state, 2);
float g = l_tools_toNumberOrError(state, 3);
float b = l_tools_toNumberOrError(state, 4);
float a = luaL_optnumber(state, 5, 255);
graphics_Batch_setColor(&batch->batch, r / 255.0f, g / 255.0f, b / 255.0f, a / 255.0f);
}
return 0;
}
static int l_filesystem_compare(lua_State* state) {
const char* a = l_tools_toStringOrError(state, 1);
const char* b = l_tools_toStringOrError(state, 2);
int l = l_tools_toNumberOrError(state, 3);
if ( filesystem_compare(a, b, l))
lua_pushboolean(state, 1);
else
lua_pushboolean(state, 0);
return 1;
}
static int l_physics_setShapeMass(lua_State* state)
{
l_physics_Shape* shape = (l_physics_Shape*)lua_touserdata(state, 1);
float value = l_tools_toNumberOrError(state, 2);
cpShapeSetMass(shape->shape, value);
return 0;
}
static int l_graphics_Mesh_setVertex(lua_State* state) {
l_assertType(state, 1, l_graphics_isMesh);
l_graphics_Mesh * mesh = l_graphics_toMesh(state, 1);
size_t index = l_tools_toNumberOrError(state, 2) - 1;
graphics_Vertex v;
float *vf = (float*)&v;
for(int i = 0; i < 4; ++i) {
vf[i] = l_tools_toNumberOrError(state, i+3);
}
for(int i = 4; i < 8; ++i) {
vf[i] = luaL_optnumber(state, i+3, 255.0f) / 255.0f;
}
graphics_Mesh_setVertex(&mesh->mesh, index, &v);
return 0;
}
static int l_audio_SourceCommon_setPitch(lua_State *state) {
float pitch = l_tools_toNumberOrError(state, 2);
if (moduleData.audio_type == audio_type_stream){
audio_StreamSource* source = (audio_StreamSource *)lua_touserdata(state, 1);
audio_StreamSource_setPitch(source, pitch);
} else {
audio_SourceCommon* source = (audio_SourceCommon*)lua_touserdata(state, 1);
audio_SourceCommon_setPitch(source, pitch);
}
return 1;
}
int l_graphics_SpriteBatch_setBufferSize(lua_State* state) {
l_assertType(state, 1, l_graphics_isBatch);
l_graphics_Batch * batch = l_graphics_toBatch(state, 1);
int newsize = l_tools_toNumberOrError(state, 2);
graphics_Batch_changeBufferSize(&batch->batch, newsize);
return 0;
}
static int l_physics_setSpaceDamping(lua_State* state)
{
l_tools_checkUserDataPlusErrMsg(state, 1, "You must provide a space");
l_physics_PhysicsData* physics = (l_physics_PhysicsData*)lua_touserdata(state, 1);
float damping = l_tools_toNumberOrError(state, 2);
cpSpaceSetDamping(physics->physics->space, damping);
return 0;
}
static int l_graphics_Font_getWrap(lua_State* state) {
l_assertType(state, 1, l_graphics_isFont);
graphics_Font* font = l_graphics_toFont(state, 1);
char const* line = l_tools_toStringOrError(state, 2);
int width = l_tools_toNumberOrError(state, 3);
lua_pushinteger(state, graphics_Font_getWrap(font, line, width, NULL));
return 1;
}
static int l_physics_setBodyTorque(lua_State* state)
{
l_tools_checkUserDataPlusErrMsg(state, 1, "You must provide a body");
l_physics_Body* body = (l_physics_Body*)lua_touserdata(state, 1);
float value = l_tools_toNumberOrError(state, 2);
cpBodySetTorque(body->body, value);
return 0;
}
static int l_physics_setSpaceSleepTime(lua_State* state)
{
l_tools_checkUserDataPlusErrMsg(state, 1, "You must provide a space");
l_physics_PhysicsData* physics = (l_physics_PhysicsData*)lua_touserdata(state, 1);
float sleep = l_tools_toNumberOrError(state, 2);
cpSpaceSetSleepTimeThreshold(physics->physics->space, sleep);
return 0;
}
static int l_graphics_print(lua_State* state) {
if(!moduleData.currentFont) {
l_graphics_loadDefaultFont();
}
char const* text = lua_tostring(state, 1);
if(!text) {
lua_pushstring(state, "need string");
return lua_error(state);
}
int x = l_tools_toNumberOrError(state, 2);
int y = l_tools_toNumberOrError(state, 3);
float r = luaL_optnumber(state, 4, 0);
float sx = luaL_optnumber(state, 5, 1.0f);
float sy = luaL_optnumber(state, 6, sx);
float ox = luaL_optnumber(state, 7, 0);
float oy = luaL_optnumber(state, 8, 0);
float kx = luaL_optnumber(state, 9, 0);
float ky = luaL_optnumber(state, 10, 0);
graphics_Font_render(moduleData.currentFont, text, x, y, r, sx, sy, ox, oy, kx, ky);
return 0;
}
static int l_physics_setBodyPosition(lua_State* state)
{
l_tools_checkUserDataPlusErrMsg(state, 1, "You must provide a body");
l_tools_checkUserDataPlusErrMsg(state, 2, "You must provide a space");
l_physics_Body* body = (l_physics_Body*)lua_touserdata(state, 1);
l_physics_PhysicsData* space = (l_physics_PhysicsData*)lua_touserdata(state, 2);
cpVect vec = cpvzero;
vec.x = l_tools_toNumberOrError(state, 3);
vec.y = l_tools_toNumberOrError(state, 4);
cpBodySetPosition(body->body, vec);
/*
* Docs:
* When changing the position you may also want to call cpSpaceReindexShapesForBody()
* to update the collision detection information for the attached shapes if plan to
* make any queries against the space.
*/
cpSpaceReindexShapesForBody(space->physics->space, body->body);
return 0;
}
static int l_graphics_Mesh_getVertex(lua_State* state) {
l_assertType(state, 1, l_graphics_isMesh);
l_graphics_Mesh const* mesh = l_graphics_toMesh(state, 1);
size_t index = l_tools_toNumberOrError(state, 2) - 1;
graphics_Vertex const* vertex = graphics_Mesh_getVertex(&mesh->mesh, index);
float const* vf = (float const*)vertex;
for(size_t j = 0; j < 4; ++j) {
lua_pushnumber(state, vf[j]);
}
for(size_t j = 4; j < 8; ++j) {
lua_pushnumber(state, floor(vf[j] * 255.0f));
}
return 8;
}
int l_graphics_newQuad(lua_State* state) {
float x = l_tools_toNumberOrError(state, 1);
float y = l_tools_toNumberOrError(state, 2);
float w = l_tools_toNumberOrError(state, 3);
float h = l_tools_toNumberOrError(state, 4);
float rw = l_tools_toNumberOrError(state, 5);
float rh = l_tools_toNumberOrError(state, 6);
graphics_Quad* obj = lua_newuserdata(state, sizeof(graphics_Quad));
graphics_Quad_newWithRef(obj, x, y, w, h, rw, rh);
lua_rawgeti(state, LUA_REGISTRYINDEX, moduleData.quadMT);
lua_setmetatable(state, -2);
return 1;
}
static void readVertex(lua_State* state, graphics_Vertex* out, bool *hasVertexColor) {
if(!lua_istable(state, -1) || lua_objlen(state, -1) < 4) {
lua_pushstring(state, "Table entry is not a vertex");
lua_error(state); // does not return
return; // hint the compiler
}
_Static_assert(sizeof(graphics_Vertex) == 8*sizeof(float), "");
float *t = (float*)out;
for(int i = 0; i < 4; ++i) {
lua_rawgeti(state, -1, i+1);
t[i] = l_tools_toNumberOrError(state, -1);
lua_pop(state, 1);
}
for(int i = 4; i < 8; ++i) {
lua_rawgeti(state, -1, i+1);
t[i] = luaL_optnumber(state, -1, 255.0f) / 255.0f;
*hasVertexColor = (*hasVertexColor) || t[i] != 1.0f;
lua_pop(state, 1);
}
}
