xr_string to_string (luabind::object const& o) { using namespace luabind; if (o.type() == LUA_TSTRING) return object_cast<xr_string>(o); lua_State* L = o.lua_state(); LUABIND_CHECK_STACK(L); #ifdef BOOST_NO_STRINGSTREAM std::strstream s; #else std::stringstream s; #endif if (o.type() == LUA_TNUMBER) { s << object_cast<float>(o); return xr_string(s.str().c_str()); } s << "<" << lua_typename(L, o.type()) << ">"; #ifdef BOOST_NO_STRINGSTREAM s << std::ends; #endif return s.str().c_str(); }
void smart_cover::action::add_animation(LPCSTR type, luabind::object const &table) { VERIFY ( table.type() == LUA_TTABLE ); luabind::object::iterator I = table.begin(); luabind::object::iterator E = table.end(); Animations* animations = xr_new<Animations>( ); for ( ; I != E; ++I) { luabind::object string = *I; if (string.type() != LUA_TSTRING) { VERIFY ( string.type() != LUA_TNIL ); continue; } shared_str animation = luabind::object_cast<LPCSTR>(string); VERIFY2 ( std::find( animations->begin(), animations->end(), animation ) == animations->end(), make_string( "duplicated_animation found: %s", animation.c_str() ) ); animations->push_back ( animation ); } m_animations.insert ( std::make_pair( type, animations ) ); }
void parse_table (luabind::object const &table, LPCSTR identifier, luabind::object &result) { VERIFY2 (table.type() == LUA_TTABLE, "invalid loophole description passed"); result = table[identifier]; VERIFY2 (result.type() != LUA_TNIL, make_string("cannot read table value %s", identifier)); VERIFY2 (result.type() == LUA_TTABLE, make_string("cannot read table value %s", identifier)); }
xr_string member_to_string (luabind::object const& e, LPCSTR function_signature) { #if !defined(LUABIND_NO_ERROR_CHECKING3) using namespace luabind; lua_State* L = e.lua_state(); LUABIND_CHECK_STACK(L); if (e.type() == LUA_TFUNCTION) { e.pushvalue(); detail::stack_pop p(L, 1); { if (lua_getupvalue(L, -1, 3) == 0) return to_string(e); detail::stack_pop p2(L, 1); if (lua_touserdata(L, -1) != reinterpret_cast<void*>(0x1337)) return to_string(e); } #ifdef BOOST_NO_STRINGSTREAM std::strstream s; #else std::stringstream s; #endif { lua_getupvalue(L, -1, 2); detail::stack_pop p2(L, 1); } { lua_getupvalue(L, -1, 1); detail::stack_pop p2(L, 1); detail::method_rep* m = static_cast<detail::method_rep*>(lua_touserdata(L, -1)); for (std::vector<detail::overload_rep>::const_iterator i = m->overloads().begin(); i != m->overloads().end(); ++i) { xr_string str; i->get_signature(L, str); if (i != m->overloads().begin()) s << "\n"; s << function_signature << process_signature(str) << ";"; } } #ifdef BOOST_NO_STRINGSTREAM s << std::ends; #endif return s.str().c_str(); } return to_string(e); #else return ""; #endif }
// TODO Move arguments from constructor to here? void timer::start(luabind::object& f) { thread = player->create_lua_thread(); #ifndef NDEBUG int old_top = lua_gettop(thread); #endif //function.push(thread); f.push(f.interpreter()); lua_xmove(f.interpreter(), thread, 1); assert(old_top + 1 == lua_gettop(thread)); timer_thread = boost::thread(&timer::count_down, this); }
void set_voxel_physics_boxes(const luabind::object &node_o, const luabind::object &buffer_o, sp_<VoxelRegistry> voxel_reg) { lua_State *L = node_o.interpreter(); GET_TOLUA_STUFF(node, 1, Node); TRY_GET_TOLUA_STUFF(buf, 2, const VectorBuffer); log_d(MODULE, "set_voxel_physics_boxes(): node=%p", node); log_d(MODULE, "set_voxel_physics_boxes(): buf=%p", buf); ss_ data; if(buf == nullptr) data = lua_tocppstring(L, 2); else data.assign((const char*)&buf->GetBuffer()[0], buf->GetBuffer().Size()); lua_getfield(L, LUA_REGISTRYINDEX, "__buildat_app"); app::App *buildat_app = (app::App*)lua_touserdata(L, -1); lua_pop(L, 1); up_<SetPhysicsBoxesTask> task(new SetPhysicsBoxesTask( node, data, voxel_reg )); auto *thread_pool = buildat_app->get_thread_pool(); thread_pool->add_task(std::move(task)); }
luabind::object menu::build(luabind::object setting) { using namespace luabind; lua_State *L = setting.interpreter(); const char *title = NULL; object m; if (!setting || luabind::type(setting) != LUA_TTABLE) { return m; } iterator i(setting), end; if (setting["title"]) { title = object_cast<const char *>(setting["title"]); } else if (setting["t"]) { title = object_cast<const char *>(setting["t"]); } else if (setting["label"]) { title = object_cast<const char *>(setting["label"]); } else if (type(*i) == LUA_TSTRING) { title = object_cast<const char *>(*i); i++; } m = globals(L)["lev"]["gui"]["menu"](title); for (; i != end; i++) { if (type(*i) == LUA_TTABLE) { m["append"](m, *i); } } return m; }
position LuaQuestScript::getPosition(const luabind::object &potentialPosition) { using namespace luabind; if (!potentialPosition.is_valid()) { throw std::logic_error("no position found"); } try { return object_cast<position>(potentialPosition); } catch (cast_failed &e) { } auto positionType = type(potentialPosition); if (positionType == LUA_TTABLE) { try { int16_t x = object_cast<int16_t>(potentialPosition[1]); int16_t y = object_cast<int16_t>(potentialPosition[2]); int16_t z = object_cast<int16_t>(potentialPosition[3]); return position(x, y, z); } catch (cast_failed &e) { } } throw std::logic_error("no position found"); }
void xd::lua::scheduler::start(luabind::object func) { // create a new thread lua_State *thread = lua_newthread(m_vm.lua_state()); // push the function in the new thread, because the function // the thread calls must be called in its local environment func.push(thread); // construct a callable object from it, the value is copied from stack luabind::object thread_func(luabind::from_stack(thread, -1)); // remove the original value from the stack lua_pop(thread, 1); // set the current thread m_thread_stack->threads.push(thread); m_current_thread = thread; // start the thread luabind::object result = luabind::resume_function<luabind::object>(thread_func); // if the thread was yielded from lua side, and the return value is a callable function int type = luabind::type(result); if (type == LUA_TFUNCTION || type == LUA_TTABLE || type == LUA_TUSERDATA) { yield(xd::create<detail::callback_task_lua>(result)); } // reset current thread m_thread_stack->threads.pop(); if (m_thread_stack->threads.empty()) m_current_thread = nullptr; else m_current_thread = m_thread_stack->threads.top(); }
void LuaProxy::Graphics::__setSimpleSpriteOverride(const std::string & name, const luabind::object & overrideImg, lua_State * L) { HDC mainHdc, maskHdc; if (name.find("hardcoded-") == 0) { // If non of the above applies, then try with the hardcoded ones: HardcodedGraphicsItem::GetHDCByName(name, &mainHdc, &maskHdc); } if (mainHdc == nullptr && maskHdc == nullptr) { luaL_error(L, "Failed to get hardcoded image!"); return; } SMBXMaskedImage* img = SMBXMaskedImage::get(mainHdc, maskHdc); if (!overrideImg.is_valid()) { img->UnsetOverride(); return; } boost::optional<SMBXMaskedImage*> maskImg = luabind::object_cast_nothrow<SMBXMaskedImage*>(overrideImg); if (maskImg != boost::none) { img->SetOverride(*maskImg); return; } boost::optional<LuaProxy::Graphics::LuaImageResource*> rgbaImg = luabind::object_cast_nothrow<LuaProxy::Graphics::LuaImageResource*>(overrideImg); if (rgbaImg != boost::none) { if (*rgbaImg != nullptr && (*rgbaImg)->img) { img->SetOverride((*rgbaImg)->img); } return; } luaL_error(L, "Invalid input for sprite override!"); }
Fvector parse_fvector (luabind::object const &table, LPCSTR identifier) { VERIFY2 (table.type() == LUA_TTABLE, "invalid loophole description passed"); luabind::object result = table[identifier]; VERIFY2 (result.type() != LUA_TNIL, make_string("cannot read vector value %s", identifier)); return (luabind::object_cast<Fvector>(result)); }
static ComponentTypeId ComponentFactory_registerComponentType( ComponentFactory* self, const std::string& name, luabind::object cls ) { lua_State* L = cls.interpreter(); auto type = luabind::type(cls); if (type != LUA_TUSERDATA) { std::string typeName( lua_typename(L, type) ); throw std::runtime_error("Argument 2 must be class object, but is: " + typeName); } ComponentTypeId typeId = self->registerComponentType( name, [cls] (const StorageContainer& storage) { luabind::object classTable = cls; luabind::object obj = classTable(); auto component = std::unique_ptr<Component>( luabind::object_cast<Component*>(obj, luabind::adopt(luabind::result)) ); component->load(storage); return component; } ); cls["TYPE_ID"] = typeId; return typeId; }
void setGeometryIndices( Geometry * pGeom, const luabind::object & indexTable ) { if ( indexTable.is_valid() && indexTable.type() == LUA_TTABLE ) { if ( !pGeom->m_indexBuffer ) pGeom->m_indexBuffer.reset( new vector<unsigned short> ); unsigned int uiNewIndices = 0; pGeom->m_indexBuffer->clear(); for( luabind::object::array_iterator iter = indexTable.abegin(); iter != indexTable.aend(); iter++, uiNewIndices++ ) { boost::optional<unsigned short> oindex = luabind::object_cast_nothrow<unsigned short>( *iter ); if ( oindex ) pGeom->m_indexBuffer->push_back( *oindex.get() ); } pGeom->m_indexCount = uiNewIndices; } }
//------------------------------------------------------------------------------ bool ofxLua::checkType(int type, luabind::object& object) { if(!object.is_valid()) return false; if(luabind::type(object) == type) return true; return false; }
bool ReadScriptDescriptor::_CheckDataType(int32 type, luabind::object& obj_check) { int32 object_type = luabind::type(obj_check); if (obj_check.is_valid() == false) return false; // When this type is passed to the function, we don't care what type the object is as long // as it was seen to be something if (type == LUA_TNIL) { return true; } // Simple type comparison is all that is needed for all non-numeric types else if (type == object_type) { return true; } // Because Lua only has a "number" type, we have to do perform a special cast // to examine integer versus floating point types else if (object_type == LUA_TNUMBER) { if (type == INTEGER_TYPE) { try { luabind::object_cast<int32>(obj_check); return true; } catch (...) { return false; } } else if (type == UINTEGER_TYPE) { try { luabind::object_cast<uint32>(obj_check); return true; } catch (...) { return false; } } else if (type == FLOAT_TYPE) { try { luabind::object_cast<float>(obj_check); return true; } catch (...) { return false; } } else { return false; } } else { return false; } } // bool ReadScriptDescriptor::_CheckDataType(int32 type, luabind::object& obj_check)
void WaypointList::addFromList(const luabind::object &list) { if (list.is_valid()) { if (luabind::type(list) == LUA_TTABLE) { for (luabind::iterator it(list), end; it != end; ++it) { position pos = luabind::object_cast<position>(*it); positions.push_back(pos); } } } }
void LVL_Npc::lua_setSequence(luabind::object frames) { int ltype = luabind::type(frames); if(luabind::type(frames) != LUA_TTABLE) { luaL_error(frames.interpreter(), "setSequence exptected int-array, got %s", lua_typename(frames.interpreter(), ltype)); return; } animator.setSequence(luabind_utils::convArrayTo<int>(frames)); }
void setGeometryTexture1( Geometry * pGeom, const luabind::object & texture1Table ) { if ( texture1Table.is_valid() && texture1Table.type() == LUA_TTABLE ) { if ( !pGeom->m_texture1Buffer ) pGeom->m_texture1Buffer.reset( new vector<float> ); pGeom->m_texture1Buffer->clear(); for( luabind::object::array_iterator iter = texture1Table.abegin(); iter != texture1Table.aend(); iter++ ) { boost::optional<Point2> opt = luabind::object_cast_nothrow<Point2>( *iter ); if ( opt ) { Point2 * pt = opt.get(); pGeom->m_texture1Buffer->push_back( pt->x ); pGeom->m_texture1Buffer->push_back( pt->y ); } } } }
void clear_voxel_geometry(const luabind::object &node_o) { lua_State *L = node_o.interpreter(); GET_TOLUA_STUFF(node, 1, Node); log_d(MODULE, "clear_voxel_geometry(): node=%p", node); CustomGeometry *cg = node->GetComponent<CustomGeometry>(); if(cg) node->RemoveComponent(cg); }
void setGeometryColor( Geometry * pGeom, const luabind::object & colorTable ) { if ( colorTable.is_valid() && colorTable.type() == LUA_TTABLE ) { if ( !pGeom->m_colorBuffer ) pGeom->m_colorBuffer.reset( new vector<float> ); pGeom->m_colorBuffer->clear(); for( luabind::object::array_iterator iter = colorTable.abegin(); iter != colorTable.aend(); iter++ ) { boost::optional<ColorA> opt = luabind::object_cast_nothrow<ColorA>( *iter ); if ( opt ) { ColorA * pt = opt.get(); pGeom->m_colorBuffer->push_back( pt->r ); pGeom->m_colorBuffer->push_back( pt->g ); pGeom->m_colorBuffer->push_back( pt->b ); pGeom->m_colorBuffer->push_back( pt->a ); } } } }
// // Local Functions // void setGeometryVertices( Geometry * pGeom, const luabind::object & vertexTable ) { if ( vertexTable.is_valid() && vertexTable.type() == LUA_TTABLE ) { if ( !pGeom->m_vertexBuffer ) pGeom->m_vertexBuffer.reset( new vector<float> ); pGeom->m_vertexBuffer->clear(); unsigned uiNewVertices = 0; for( luabind::object::array_iterator iter = vertexTable.abegin(); iter != vertexTable.aend(); iter++, uiNewVertices++ ) { boost::optional<Point3> opt = luabind::object_cast_nothrow<Point3>( *iter ); if ( opt ) { Point3 * pt = opt.get(); pGeom->m_vertexBuffer->push_back( pt->x ); pGeom->m_vertexBuffer->push_back( pt->y ); pGeom->m_vertexBuffer->push_back( pt->z ); } } pGeom->m_vertexCount = uiNewVertices; } }
bool ReadScriptDescriptor::RunScriptObject(const luabind::object& object) { // Don't log in that case because we might want to run invalid (empty) objects // to simplify the caller code. if (!object.is_valid()) return true; try { ScriptCallFunction<void>(object); } catch(luabind::error e) { PRINT_ERROR << "Error while loading script object." << std::endl; ScriptManager->HandleLuaError(e); return false; } return true; }
float parse_float ( luabind::object const &table, LPCSTR identifier, float const &min_threshold = flt_min, float const &max_threshold = flt_max ) { VERIFY2 (table.type() == LUA_TTABLE, "invalid loophole description passed"); luabind::object lua_result = table[identifier]; VERIFY2 (lua_result.type() != LUA_TNIL, make_string("cannot read number value %s", identifier)); VERIFY2 (lua_result.type() == LUA_TNUMBER, make_string("cannot read number value %s", identifier)); float result = luabind::object_cast<float>(lua_result); VERIFY2 (result >= min_threshold, make_string("invalid read number value %s", identifier)); VERIFY2 (result <= max_threshold, make_string("invalid number value %s", identifier)); return (result); }
void WaypointList::addFromList(const luabind::object &list) { if (list.is_valid()) { if (luabind::type(list) == LUA_TTABLE) { for (luabind::iterator it(list), end; it != end; ++it) { try { position pos = luabind::object_cast<position>(*it); positions.push_back(pos); } catch (luabind::cast_failed &e) { std::string script = World::get()->getCurrentScript()->getFileName(); std::string err = "Invalid type in parameter list of WaypointList:addFromList in " + script + ":\n"; err += "Expected type position\n"; Logger::writeError("scripts", err); } } } } }
void clear_voxel_physics_boxes(const luabind::object &node_o) { lua_State *L = node_o.interpreter(); GET_TOLUA_STUFF(node, 1, Node); log_d(MODULE, "clear_voxel_physics_boxes(): node=%p", node); RigidBody *body = node->GetComponent<RigidBody>(); if(body) node->RemoveComponent(body); PODVector<CollisionShape*> previous_shapes; node->GetComponents<CollisionShape>(previous_shapes); for(size_t i = 0; i < previous_shapes.Size(); i++) node->RemoveComponent(previous_shapes[i]); }
bool NPL::NPLHelper::StringToLuaObject(const char* input, int nLen, luabind::object& output, lua_State* pState) { NPLLex lex; LexState* ls = lex.SetInput(input, nLen); ls->nestlevel = 0; try { NPLParser::next(ls); /* read first token */ if (ls->t.token == '{') { if (pState == 0) pState = output.interpreter(); luabind::object tabGlobal = luabind::globals(pState); luabind::object_index_proxy tabProxy = tabGlobal["__tmp"]; if (DeserializePureDataBlock(ls, tabProxy)) { NPLParser::testnext(ls, ';'); if (ls->t.token == NPLLex::TK_EOS) { output = tabProxy; // this is not necessary, the next call will overwrite this. // tabGlobal["__tmp"] = luabind::detail::nil_type(); return true; } } } } catch (const char* err) { OUTPUT_LOG("error: %s in NPLHelper::StringToLuaObject()\n", err); return false; } catch (...) { OUTPUT_LOG("error: unknown error in NPLHelper::StringToLuaObject()\n"); return false; } return false; }
void LuaProxy::Graphics::__setSpriteOverride(const std::string& t, int index, const luabind::object& overrideImg, lua_State* L) { SMBXMaskedImage* img = getMaskedImage(t, index); if (img == nullptr) { luaL_error(L, "Graphics.sprite.%s[%d] does not exist", t.c_str(), index); return; } if (!overrideImg.is_valid()) { img->UnsetOverride(); return; } //I found that 'object_cast_nothrow' sometimes casts between incompatible types without returning 'boost::none' //switch order to avoid invalid casting from LIR to SMBXMI boost::optional<LuaProxy::Graphics::LuaImageResource*> rgbaImg = luabind::object_cast_nothrow<LuaProxy::Graphics::LuaImageResource*>(overrideImg); if (rgbaImg != boost::none) { if (*rgbaImg != nullptr && (*rgbaImg)->img) { img->SetOverride((*rgbaImg)->img); } return; } boost::optional<SMBXMaskedImage*> maskImg = luabind::object_cast_nothrow<SMBXMaskedImage*>(overrideImg); if (maskImg != boost::none) { img->SetOverride(*maskImg); return; } luaL_error(L, "Cannot set Graphics.sprite.%s[%d], invalid input type", t.c_str(), index); }
void set_8bit_voxel_geometry(const luabind::object &node_o, int w, int h, int d, const luabind::object &buffer_o, sp_<VoxelRegistry> voxel_reg, sp_<AtlasRegistry> atlas_reg) { lua_State *L = node_o.interpreter(); GET_TOLUA_STUFF(node, 1, Node); TRY_GET_TOLUA_STUFF(buf, 5, const VectorBuffer); log_d(MODULE, "set_8bit_voxel_geometry(): node=%p", node); log_d(MODULE, "set_8bit_voxel_geometry(): buf=%p", buf); ss_ data; if(buf == nullptr) data = lua_tocppstring(L, 5); else data.assign((const char*)&buf->GetBuffer()[0], buf->GetBuffer().Size()); if((int)data.size() != w * h * d){ throw Exception(ss_()+"set_8bit_voxel_geometry(): Data size does not match" " with dimensions ("+cs(data.size())+" vs. "+cs(w*h*d)+")"); } lua_getfield(L, LUA_REGISTRYINDEX, "__buildat_app"); app::App *buildat_app = (app::App*)lua_touserdata(L, -1); lua_pop(L, 1); Context *context = buildat_app->get_scene()->GetContext(); CustomGeometry *cg = node->GetOrCreateComponent<CustomGeometry>(LOCAL); interface::mesh::set_8bit_voxel_geometry(cg, context, w, h, d, data, voxel_reg.get(), atlas_reg.get()); cg->SetOccluder(true); cg->SetCastShadows(true); }
luabind::object menubar::build(luabind::object setting) { using namespace luabind; lua_State *L = setting.interpreter(); object mb; if (!setting || type(setting) != LUA_TTABLE) { return mb; } mb = globals(L)["lev"]["gui"]["menubar"](); for (iterator i(setting), end; i != end; i++) { object m, name; const char *label1 = NULL, *label2 = NULL; iterator j(*i); if (j == end || type(*j) != LUA_TSTRING) { continue; } label1 = object_cast<const char *>(*j++); if (j != end && type(*j) == LUA_TSTRING) { label2 = object_cast<const char *>(*j++); } if (j != end && type(*j) == LUA_TSTRING) { name = *j++; } else if ((*i)["id"]) { name = (*i)["id"]; } else if ((*i)["name"]) { name = (*i)["name"]; } m = globals(L)["lev"]["gui"]["menu"](label2); for (; j != end; j++) { if (type(*j) == LUA_TTABLE) { m["append"](m, *j); } } mb["append"](mb, m, label1, name); } return mb; }
SynchronizedRunBuffer::SynchronizedRunBuffer(luabind::object const& delegate) : _init(false) { _state = delegate.interpreter(); }