2456 lines
74 KiB
C++
2456 lines
74 KiB
C++
/* -----------------------------------------------------------------------------
|
|
GSFramework
|
|
Copyright 2001-2013 Emmanuel Julien. All Rights Reserved.
|
|
----------------------------------------------------------------------------- */
|
|
|
|
|
|
#include "binding_helpers.h"
|
|
#include "script_squirrel/cobject/matrix_decl.h"
|
|
#include "scene3d/mitem_event_interface.h"
|
|
#include "scene3d/scene_ace_manager.h"
|
|
#include "scene3d/mcamera.h"
|
|
#include "scene3d/mlight.h"
|
|
#include "scene3d/mobject.h"
|
|
#include "scene3d/memitter.h"
|
|
#include "scene3d/mtrigger.h"
|
|
#include "scene3d/instance.h"
|
|
#include "scene3d/scene.h"
|
|
#include "scene3d/group.h"
|
|
#include "motion/motion_automation_source.h"
|
|
#include "script/scripted_object.h"
|
|
#include "script/script_unit.h"
|
|
#include "metafile/nml_object.h"
|
|
#include "core/resource_factories.h"
|
|
|
|
using namespace GS;
|
|
using namespace GS::S3D;
|
|
using namespace GS::Script;
|
|
|
|
|
|
static CObjectType item_derived_types[] = { typetag_Item, typetag_Camera, typetag_Object, typetag_Light, typetag_Trigger, typetag_Emitter, typetag_Undefined };
|
|
|
|
//------------------------------------------------------------------------------
|
|
SQInteger ItemTranslate(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(i, MItem, item_derived_types)
|
|
__SQ_GETVECTOR(t)
|
|
__SQ_GETEND
|
|
i->GetBaseItem()->SetPosition(i->GetBaseItem()->GetPosition() + t);
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger ItemRotate(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(i, MItem, item_derived_types)
|
|
__SQ_GETVECTOR(e)
|
|
__SQ_GETEND
|
|
i->GetBaseItem()->SetRotation(i->GetBaseItem()->GetRotation() + e);
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger ItemScale(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(i, MItem, item_derived_types)
|
|
__SQ_GETVECTOR(s)
|
|
__SQ_GETEND
|
|
i->GetBaseItem()->SetScale(i->GetBaseItem()->GetScale() * s);
|
|
__SQ_RETURN
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
SQInteger ItemCastToEmitter(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(i, MItem, typetag_Item)
|
|
if (i->GetItemType() != Type_Emitter)
|
|
return sq_throwerror(vm, "Invalid item cast, item is not a particle emitter.");
|
|
__SQ_RETURNSAFEPTR((MEmitter *)i, typetag_Emitter)
|
|
}
|
|
SQInteger ItemCastToCamera(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(i, MItem, typetag_Item)
|
|
if (i->GetItemType() != Type_Camera)
|
|
return sq_throwerror(vm, "Invalid item cast, item is not a camera.");
|
|
__SQ_RETURNSAFEPTR((MCamera *)i, typetag_Camera)
|
|
}
|
|
SQInteger ItemCastToObject(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(i, MItem, typetag_Item)
|
|
if (i->GetItemType() != Type_Object)
|
|
return sq_throwerror(vm, "Invalid item cast, item is not an object.");
|
|
__SQ_RETURNSAFEPTR((MObject *)i, typetag_Object)
|
|
}
|
|
SQInteger ItemCastToTrigger(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(i, MItem, typetag_Item)
|
|
if (i->GetItemType() != Type_Trigger)
|
|
return sq_throwerror(vm, "Invalid item cast, item is not a trigger.");
|
|
__SQ_RETURNSAFEPTR((MTrigger *)i, typetag_Trigger)
|
|
}
|
|
SQInteger ItemCastToLight(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(i, MItem, typetag_Item)
|
|
if (i->GetItemType() != Type_Light)
|
|
return sq_throwerror(vm, "Invalid item cast, item is not a light.");
|
|
__SQ_RETURNSAFEPTR((MLight *)i, typetag_Light)
|
|
}
|
|
SQInteger ItemCastToInstance(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(i, MItem, typetag_Item)
|
|
if (i->GetItemType() != Type_Instance)
|
|
return sq_throwerror(vm, "Invalid item cast, item is not an instance.");
|
|
__SQ_RETURNSAFEPTR((Instance *)i, typetag_Instance)
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
SQInteger ItemDerivedCastToItem(HSQUIRRELVM vm)
|
|
{
|
|
MItem *item = NULL;
|
|
|
|
//-----------------------------------
|
|
#define __GrabDerivedItem(__T__)\
|
|
{\
|
|
__T__ *i;\
|
|
CObject::Get(vm, -1, (void **)&i);\
|
|
item = i;\
|
|
}\
|
|
break;
|
|
//-----------------------------------
|
|
|
|
CObjectType type;
|
|
if (!CObject::GetType(vm, -1, type))
|
|
return -1;
|
|
|
|
switch (type)
|
|
{
|
|
case typetag_Camera:
|
|
__GrabDerivedItem(MCamera)
|
|
case typetag_Light:
|
|
__GrabDerivedItem(MLight)
|
|
case typetag_Object:
|
|
__GrabDerivedItem(MObject)
|
|
case typetag_Trigger:
|
|
__GrabDerivedItem(MTrigger)
|
|
case typetag_Emitter:
|
|
__GrabDerivedItem(MEmitter)
|
|
|
|
case typetag_Item:
|
|
__GrabDerivedItem(MItem)
|
|
|
|
default: break;
|
|
}
|
|
sq_pop(vm, 1);
|
|
|
|
__SQ_RETURNSAFEPTR(item, typetag_Item)
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
SQInteger ItemRegistrySetKey(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(3)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETSTRING(key)
|
|
GS::Variant value;
|
|
HSQOBJECT o;
|
|
sq_getstackobj(vm, __SQ_STACKPOS, &o);
|
|
switch (sq_type(o))
|
|
{
|
|
case OT_BOOL:
|
|
{ __SQ_GETBOOL(v) value = asbool(v); } break;
|
|
case OT_INTEGER:
|
|
{ __SQ_GETINT(v) value = (int)v; } break;
|
|
case OT_FLOAT:
|
|
{ __SQ_GETFLOAT(v) value = v; } break;
|
|
case OT_STRING:
|
|
{ __SQ_GETSTRING(s) value = s; } break;
|
|
|
|
default: return sq_throwerror(vm, "Unsupported key value type.");
|
|
}
|
|
item->GetBaseItem()->registry.CreateKey(key, &value);
|
|
__SQ_GETEND
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger ItemRegistryGetKey(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETSTRING(key)
|
|
__SQ_GETEND
|
|
|
|
GS::Variant v(-1);
|
|
GS::NML::Tag *tag = item->GetBaseItem()->registry.GetTag(key);
|
|
if (tag)
|
|
v = tag->GetValue();
|
|
|
|
switch (v.GetType())
|
|
{
|
|
case GS::Variant::VariantBool: __SQ_RETURNBOOL(v.b_value)
|
|
case GS::Variant::VariantInteger: __SQ_RETURNINT(v.i_value)
|
|
case GS::Variant::VariantFloat: __SQ_RETURNFLOAT(v.f_value)
|
|
case GS::Variant::VariantString: __SQ_RETURNSTRING(v.s_value.c_str())
|
|
}
|
|
__SQ_RETURNINT(-1)
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
SQInteger ItemSetCommandList(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETSTRING(list)
|
|
ACEManager::Get()->LoadACECommandList(list, item);
|
|
__SQ_GETEND
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger ItemResetCommandList(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(item, MItem, typetag_Item)
|
|
item->ResetCommandList();
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger ItemIsCommandListDone(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__SQ_RETURNBOOL(item ? item->IsCommandListDone() : true)
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
SQInteger ItemPrint(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__LOG__ << "Item: " << (asbool(item) ? item->name.c_str() : "Null") << " (Uid = " << (asbool(item) ? item->GetUid() : -1) << ").\n";
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger ItemReset(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
item->Reset();
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger ItemGetType(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__SQ_RETURNINT(item ? item->GetItemType() : 0)
|
|
}
|
|
|
|
SQInteger ItemRenderSetup(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETSAFEPTR(f, Core::ResourceFactories, typetag_ResourceFactories)
|
|
__SQ_GETEND
|
|
if (item->GetBaseItem())
|
|
item->GetBaseItem()->RenderSetup(f);
|
|
__SQ_RETURN
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
#define __SQ_GETMITEMSCRIPTOBJECT(__SRC) ScriptedObject *scripted_object = __SRC->scripted_object; if (!scripted_object) return sq_throwerror(vm, "No script system in scene!");
|
|
#define __SQ_ASSERTSCRIPTUNITOPEN(__UNIT, __NAME) if (!(__UNIT)->IsOpen()) return sq_throwerror(vm, GS::String::Format("Script unit for '%s' is not open.", __NAME));
|
|
|
|
SQInteger ItemSetScript(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(3)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETSTRING(script_file)
|
|
__SQ_GETSTRING(script_class)
|
|
__SQ_GETMITEMSCRIPTOBJECT(item)
|
|
|
|
if (!scripted_object->GetUnitList().GetCount())
|
|
scripted_object->AddUnit(scripted_object->NewUnit());
|
|
|
|
if (GS::Script::Unit *unit = scripted_object->GetUnitList().ObjectAt(0))
|
|
{
|
|
unit->script_file = script_file;
|
|
unit->script_class = script_class;
|
|
}
|
|
|
|
__SQ_GETEND
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger ItemGetScriptInstance(HSQUIRRELVM vm) // LEGACY
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__SQ_GETMITEMSCRIPTOBJECT(item)
|
|
if (!scripted_object->GetUnitList().GetCount())
|
|
return sq_throwerror(vm, GS::String::Format("Item '%s' has no script unit.", item->name.c_str()));
|
|
Script::Unit *unit = scripted_object->GetUnitList()[0];
|
|
__SQ_ASSERTSCRIPTUNITOPEN(unit, item->name.c_str())
|
|
__SQ_RETURNOBJECT(((Script::SquirrelObject *)unit->Self())->object);
|
|
}
|
|
SQInteger ItemGetScriptInstanceCount(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__SQ_GETMITEMSCRIPTOBJECT(item)
|
|
__SQ_RETURNINT(scripted_object->GetUnitList().GetCount())
|
|
}
|
|
SQInteger ItemGetScriptInstanceFromIndex(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETINT(index)
|
|
__SQ_GETEND
|
|
__SQ_GETMITEMSCRIPTOBJECT(item)
|
|
Script::Unit *unit = scripted_object->GetUnitList().ObjectAt(index);
|
|
__SQ_ASSERTSCRIPTUNITOPEN(unit, item->name.c_str())
|
|
__SQ_RETURNOBJECT(((Script::SquirrelObject *)unit->Self())->object);
|
|
}
|
|
SQInteger ItemGetScriptInstanceFromClass(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETSTRING(_class)
|
|
__SQ_GETMITEMSCRIPTOBJECT(item)
|
|
|
|
Script::Unit *_unit = 0;
|
|
ListForeachPtr(Script::Unit *, unit, scripted_object->GetUnitList())
|
|
if (unit->script_class == _class)
|
|
{
|
|
_unit = unit;
|
|
break;
|
|
}
|
|
|
|
__SQ_GETEND
|
|
|
|
if (_unit)
|
|
{
|
|
__SQ_ASSERTSCRIPTUNITOPEN(_unit, item->name.c_str())
|
|
__SQ_RETURNOBJECT(((Script::SquirrelObject *)_unit->Self())->object);
|
|
}
|
|
return sq_throwerror(vm, "Script unit not found");
|
|
}
|
|
SQInteger ItemHasScript(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETSTRING(_class)
|
|
__SQ_GETMITEMSCRIPTOBJECT(item)
|
|
|
|
Script::Unit *_unit = 0;
|
|
ListForeachPtr(Script::Unit *, unit, scripted_object->GetUnitList())
|
|
if (unit->script_class == _class)
|
|
{
|
|
_unit = unit;
|
|
break;
|
|
}
|
|
|
|
__SQ_GETEND
|
|
__SQ_RETURNBOOL(asbool(_unit))
|
|
}
|
|
SQInteger ItemSetupScript(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__SQ_GETMITEMSCRIPTOBJECT(item)
|
|
|
|
if (!scripted_object->GetUnitList().GetCount())
|
|
scripted_object->AddUnit(scripted_object->NewUnit());
|
|
|
|
if (Script::Unit *unit = scripted_object->GetUnitList().ObjectAt(0))
|
|
unit->Open();
|
|
__SQ_RETURN
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
SQInteger ItemCompare(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item_a, MItem, item_derived_types)
|
|
__SQ_GETCOBJECTBASE(item_b, MItem, item_derived_types)
|
|
__SQ_GETEND
|
|
__SQ_RETURNBOOL(item_a == item_b ? true : false)
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
SQInteger ItemIsActive(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__SQ_RETURNBOOL(item ? item->isActive() : false)
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
SQInteger ItemIsInvisible(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__SQ_RETURNBOOL(item ? item->GetBaseItem()->item_flags.IsSet(ItemFlagInvisible) : true)
|
|
}
|
|
|
|
SQInteger ItemSetInvisible(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETBOOL(invisible)
|
|
__SQ_GETEND
|
|
item->GetBaseItem()->item_flags.Raise(ItemFlagInvisible, invisible ? true : false);
|
|
__SQ_RETURN
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
static void SetItemInvisibleRecursive(Core::Item *i, bool v)
|
|
{
|
|
i->item_flags.Raise(ItemFlagInvisible, v);
|
|
ListForeachPtr(Core::Item *, c, i->GetChildren())
|
|
SetItemInvisibleRecursive(c, v);
|
|
}
|
|
SQInteger ItemHierarchySetInvisible(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETBOOL(invisible)
|
|
__SQ_GETEND
|
|
SetItemInvisibleRecursive(item->GetBaseItem(), asbool(invisible));
|
|
__SQ_RETURN
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
SQInteger ItemRecordLocation(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
item->SetInitialTransformation();
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger ItemGetMinMax(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
MinMax minmax;
|
|
item->GetBaseItem()->ComputeLocalMinMax(minmax);
|
|
__SQ_RETURNMINMAX(minmax)
|
|
}
|
|
|
|
SQInteger ItemGetMatrix(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__SQ_RETURNMATRIX4(item->GetBaseItem()->GetMatrix())
|
|
}
|
|
|
|
SQInteger ItemGetInverseMatrix(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__SQ_RETURNMATRIX4(item->GetBaseItem()->GetInverseMatrix())
|
|
}
|
|
|
|
SQInteger ItemGetLocalMatrix(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__SQ_RETURNMATRIX4(item->GetBaseItem()->GetLocalMatrix())
|
|
}
|
|
|
|
SQInteger ItemSetMatrix(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETMATRIX4(mtx)
|
|
__SQ_GETEND
|
|
item->GetBaseItem()->SetMatrix(mtx);
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger ItemGetRotationMatrix(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__SQ_RETURNMATRIX3(GS::Matrix3::FromMatrix4(item->GetBaseItem()->GetMatrix()))
|
|
}
|
|
|
|
SQInteger ItemSetRotationMatrix(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETMATRIX3(mtx)
|
|
__SQ_GETEND
|
|
item->GetBaseItem()->SetRotation(mtx);
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger ItemSnapshotTransformation(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
item->GetBaseItem()->SnapshotTransformation(item->GetBaseItem()->GetMatrix());
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger ItemSnapshotMatrix(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETMATRIX4(m)
|
|
__SQ_GETEND
|
|
item->GetBaseItem()->SnapshotTransformation(m);
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger ItemGetGeometry(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
if (item->GetItemType() != Type_Object)
|
|
return sq_throwerror(vm, "Item is not an object, cannot get geometry");
|
|
|
|
if (((MObject *)item)->render_data.IsNull())
|
|
__SQ_RETURNNULL
|
|
|
|
__SQ_RETURNSAFEPTR(((MObject *)item)->render_data->geometry.c_ptr(), typetag_Geometry)
|
|
}
|
|
SQInteger ItemSaveGeometry(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(3)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETSTRING(path)
|
|
__SQ_GETSAFEPTR(f, Core::ResourceFactories, typetag_ResourceFactories)
|
|
__SQ_GETEND
|
|
|
|
if (item->GetItemType() != Type_Object)
|
|
return sq_throwerror(vm, "Item is not an object, cannot get geometry");
|
|
else
|
|
{
|
|
NML::SaveToFile(*f->graphic->LoadGeometry(((MObject *)item)->geometry), path);
|
|
}
|
|
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger ItemGetOpacity(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__SQ_RETURNFLOAT(item->GetBaseItem()->opacity)
|
|
}
|
|
|
|
SQInteger ItemSetOpacity(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETFLOAT(a)
|
|
__SQ_GETEND
|
|
item->GetBaseItem()->opacity = Types::Clamp(a);
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger ItemSetPriority(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETFLOAT(p)
|
|
__SQ_GETEND
|
|
item->SetPriority(p);
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger ItemSetExcludeFromRecord(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETFLOAT(exclude)
|
|
__SQ_GETEND
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger ItemGetExcludeFromRecord(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__SQ_RETURNBOOL(false)
|
|
}
|
|
|
|
SQInteger ItemGetChild(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETSTRING(name)
|
|
__SQ_GETEND
|
|
|
|
MItem *_ci = NULL;
|
|
ListForeachPtr(Core::Item *, ci, item->GetBaseItem()->GetChildren())
|
|
if (Scene::LocateManagedItem(ci)->name == name)
|
|
{
|
|
_ci = Scene::LocateManagedItem(ci);
|
|
break;
|
|
}
|
|
|
|
__SQ_RETURNSAFEPTR(_ci, typetag_Item)
|
|
}
|
|
|
|
SQInteger ItemGetName(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__SQ_RETURNSTRING(item->name.c_str())
|
|
}
|
|
|
|
SQInteger ItemSetName(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETSTRING(_name)
|
|
item->name = _name;
|
|
__SQ_GETEND
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger ItemGetRotationOrder(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__SQ_RETURNINT((int)item->GetBaseItem()->GetRotationOrder())
|
|
}
|
|
|
|
SQInteger ItemSetRotationOrder(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETINT(rorder)
|
|
__SQ_GETEND
|
|
item->GetBaseItem()->SetRotationOrder((Math::rOrder)rorder);
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger ItemComputeMatrix(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger ItemComputeLocalMatrix(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger ItemComputeMinMax(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(item, MItem, typetag_Item)
|
|
MinMax minmax;
|
|
item->GetBaseItem()->ComputeLocalMinMax(minmax);
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger ItemSetLinkInheritsPositionOnly(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETBOOL(flag)
|
|
__SQ_GETEND
|
|
item->GetBaseItem()->item_flags.Raise(ItemFlagInheritPositionOnly, asbool(flag));
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger ItemSetPosition(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETVECTOR(p)
|
|
item->GetBaseItem()->SetPosition(p);
|
|
__SQ_GETEND
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger ItemGetPosition(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__SQ_RETURNVECTOR(item->GetBaseItem()->GetPosition())
|
|
}
|
|
|
|
SQInteger ItemSetScale(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETVECTOR(s)
|
|
__SQ_GETEND
|
|
item->GetBaseItem()->SetScale(s);
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger ItemGetScale(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__SQ_RETURNVECTOR(item->GetBaseItem()->GetScale())
|
|
}
|
|
|
|
SQInteger ItemGetWorldPosition(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__SQ_RETURNVECTOR(item->GetBaseItem()->GetMatrix().GetRow(3))
|
|
}
|
|
SQInteger ItemGetWorldRotation(HSQUIRRELVM vm) {
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__SQ_RETURNVECTOR(GS::Matrix3::FromMatrix4(item->GetBaseItem()->GetMatrix()).AsEuler())
|
|
}
|
|
SQInteger ItemGetPreviousWorldPosition(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__SQ_RETURNVECTOR(item->GetBaseItem()->GetPreviousMatrix().GetRow(3))
|
|
}
|
|
|
|
SQInteger ItemSetPivot(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETVECTOR(p)
|
|
__SQ_GETEND
|
|
GS::Matrix4 m;
|
|
m.SetRow(3, p);
|
|
item->GetBaseItem()->SetPivot(m);
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger ItemGetPivot(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__SQ_RETURNVECTOR(item->GetBaseItem()->GetPivot().GetRow(3))
|
|
}
|
|
|
|
SQInteger ItemSetRotation(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETVECTOR(e)
|
|
__SQ_GETEND
|
|
item->GetBaseItem()->SetRotation(e);
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger ItemSetRotationQuaternion(HSQUIRRELVM vm)
|
|
{ return ItemSetRotation(vm); }
|
|
|
|
SQInteger ItemGetRotation(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__SQ_RETURNVECTOR(item->GetBaseItem()->GetRotation())
|
|
}
|
|
|
|
SQInteger ItemSetTarget(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETVECTOR(target)
|
|
__SQ_GETEND
|
|
item->GetBaseItem()->SetTarget(&target);
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger ItemSetNoTarget(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
item->GetBaseItem()->SetTarget(NULL);
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger ItemGetTarget(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__SQ_RETURNVECTOR(item->GetBaseItem()->target)
|
|
}
|
|
SQInteger ItemHasTarget(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__SQ_RETURNBOOL(item->GetBaseItem()->item_flags.IsSet(ItemFlagHasTarget));
|
|
}
|
|
|
|
SQInteger ItemGetParent(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__SQ_RETURNSAFEPTR(Scene::LocateManagedItem(item->GetBaseItem()->GetParent()), typetag_Item)
|
|
}
|
|
|
|
SQInteger ItemSetLink(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETCOBJECTBASEALLOWNULL(link, MItem, item_derived_types)
|
|
__SQ_GETEND
|
|
item->GetBaseItem()->SetParent(link ? link->GetBaseItem() : NULL);
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger ItemGetChildList(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
sq_newarray(vm, 0);
|
|
ListForeachPtr(Core::Item *, i, item->GetBaseItem()->GetChildren())
|
|
{
|
|
CObject::Push(vm, (void *)Scene::LocateManagedItem(i), typetag_Item);
|
|
sq_arrayappend(vm, -2);
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
SQInteger ItemGetScriptLogicFrequency(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__SQ_RETURNFLOAT(-1.f)
|
|
}
|
|
|
|
SQInteger ItemSetScriptLogicFrequency(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETFLOAT(fq)
|
|
__SQ_GETEND
|
|
// item->logic_fq = fq;
|
|
__SQ_RETURN
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
#define __SQ_GETPHYSICITEM(__I__) PhysicItem *iphysic = (__I__)->physic_item.c_ptr(); if (!iphysic) return sq_throwerror(vm, "No physics found, did you setup this item?");
|
|
|
|
SQInteger ItemGetSpeed(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__SQ_GETPHYSICITEM(item)
|
|
__SQ_RETURNFLOAT(iphysic->GetLinearVelocity().Len())
|
|
}
|
|
SQInteger ItemWake(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__SQ_GETPHYSICITEM(item)
|
|
iphysic->SetSleeping(false);
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger ItemSleep(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__SQ_GETPHYSICITEM(item)
|
|
iphysic->SetSleeping(true);
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger ItemIsSleeping(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__SQ_GETPHYSICITEM(item)
|
|
__SQ_RETURNBOOL(iphysic->IsSleeping())
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
SQInteger ItemPhysicResetTransformation(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(3)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETVECTOR(p)
|
|
__SQ_GETVECTOR(r)
|
|
__SQ_GETEND
|
|
__SQ_GETPHYSICITEM(item)
|
|
iphysic->SetMatrix(GS::Matrix4::TransformationMatrix(p, r, Vector4(1, 1, 1)));
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger ItemGetLinearDamping(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__SQ_GETPHYSICITEM(item)
|
|
__SQ_RETURNFLOAT(iphysic->GetLinearDamping())
|
|
}
|
|
SQInteger ItemSetLinearDamping(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETFLOAT(d)
|
|
__SQ_GETEND
|
|
__SQ_GETPHYSICITEM(item)
|
|
iphysic->SetLinearDamping(d);
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger ItemSetGravityScale(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETFLOAT(k)
|
|
__SQ_GETEND
|
|
__SQ_GETPHYSICITEM(item)
|
|
// item->GetPhysics()->SetGravity(item->GetScene().GetPhysics()->GetGravity() * k);
|
|
__LOG_W__ << "ItemSetGravityScale(): STUB\n";
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger ItemSetGravity(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETVECTOR(g)
|
|
__SQ_GETEND
|
|
__SQ_GETPHYSICITEM(item)
|
|
iphysic->SetGravity(g);
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger ItemGetGravity(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__SQ_GETPHYSICITEM(item)
|
|
__SQ_RETURNVECTOR(iphysic->GetGravity())
|
|
}
|
|
SQInteger ItemGetAngularDamping(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__SQ_GETPHYSICITEM(item)
|
|
__SQ_RETURNFLOAT(iphysic->GetAngularDamping())
|
|
}
|
|
SQInteger ItemSetAngularDamping(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETFLOAT(k)
|
|
__SQ_GETEND
|
|
__SQ_GETPHYSICITEM(item)
|
|
iphysic->SetAngularDamping(k);
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger ItemGetAngularVelocity(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__SQ_GETPHYSICITEM(item)
|
|
__SQ_RETURNVECTOR(iphysic->GetAngularVelocity())
|
|
}
|
|
SQInteger ItemSetAngularVelocity(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETVECTOR(w)
|
|
__SQ_GETEND
|
|
__SQ_GETPHYSICITEM(item)
|
|
iphysic->SetAngularVelocity(w);
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger ItemGetMass(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__SQ_RETURNFLOAT(item->physic_item_desc.GetMass())
|
|
}
|
|
SQInteger ItemCollided(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__SQ_RETURNBOOL(false) // TODO
|
|
}
|
|
SQInteger ItemUpdateInertiaTensorFromCollision(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__SQ_GETPHYSICITEM(item)
|
|
// iphysic->SetupBody();
|
|
__LOG_E__ << "ItemUpdateInertiaTensorFromCollision::FIXME\n";
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger ItemPhysicGetFlag(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__SQ_RETURNINT(0)
|
|
}
|
|
SQInteger ItemPhysicSetFlag(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETINT(f)
|
|
__SQ_GETEND
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger ItemGetPhysicMode(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__SQ_GETPHYSICITEM(item)
|
|
__SQ_RETURNINT(item->physic_item_desc.physic_mode)
|
|
}
|
|
SQInteger ItemSetPhysicMode(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETINT(m)
|
|
__SQ_GETEND
|
|
__SQ_GETPHYSICITEM(item)
|
|
item->physic_item_desc.physic_mode = PhysicItemDesc::Mode(m);
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger ItemSetInertiaTensorAndCom(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(3)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETMATRIX3(tensor)
|
|
__SQ_GETVECTOR(com)
|
|
__SQ_GETEND
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger ItemPhysicSetLinearFactor(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETVECTOR(k)
|
|
__SQ_GETEND
|
|
__SQ_GETPHYSICITEM(item)
|
|
item->physic_item_desc.linear_factor.Set(k);
|
|
iphysic->SetLinearFactor(k);
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger ItemPhysicSetAngularFactor(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETVECTOR(k)
|
|
__SQ_GETEND
|
|
__SQ_GETPHYSICITEM(item)
|
|
item->physic_item_desc.angular_factor.Set(k);
|
|
iphysic->SetAngularFactor(k);
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger ItemApplyLinearForce(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETVECTOR(F)
|
|
__SQ_GETEND
|
|
__SQ_GETPHYSICITEM(item)
|
|
iphysic->ApplyForce(F);
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger ItemApplyForce(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(3)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETVECTOR(p)
|
|
__SQ_GETVECTOR(F)
|
|
__SQ_GETEND
|
|
__SQ_GETPHYSICITEM(item)
|
|
iphysic->ApplyForce(F, &p);
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger ItemApplyImpulse(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(3)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETVECTOR(p)
|
|
__SQ_GETVECTOR(J)
|
|
__SQ_GETEND
|
|
__SQ_GETPHYSICITEM(item)
|
|
iphysic->ApplyImpulse(J, &p);
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger ItemApplyLinearImpulse(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETVECTOR(J)
|
|
__SQ_GETEND
|
|
__SQ_GETPHYSICITEM(item)
|
|
iphysic->ApplyImpulse(J);
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger ItemApplyTorque(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETVECTOR(T)
|
|
__SQ_GETEND
|
|
__SQ_GETPHYSICITEM(item)
|
|
iphysic->ApplyTorque(T);
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger ItemGetLinearAcceleration(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__SQ_RETURNVECTOR(Vector4(0, 0, 0))
|
|
}
|
|
SQInteger ItemGetLinearVelocity(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__SQ_GETPHYSICITEM(item)
|
|
__SQ_RETURNVECTOR(iphysic->GetLinearVelocity())
|
|
}
|
|
SQInteger ItemGetPreviousLinearVelocity(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__SQ_GETPHYSICITEM(item)
|
|
__SQ_RETURNVECTOR(iphysic->GetLinearVelocity())
|
|
}
|
|
SQInteger ItemSetLinearVelocity(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETVECTOR(V)
|
|
__SQ_GETEND
|
|
__SQ_GETPHYSICITEM(item)
|
|
iphysic->SetLinearVelocity(V);
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger ItemGetLocalPointVelocity(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETVECTOR(p)
|
|
__SQ_GETEND
|
|
__SQ_GETPHYSICITEM(item)
|
|
__SQ_RETURNVECTOR(iphysic->GetLocalPointVelocity(p))
|
|
}
|
|
SQInteger ItemGetWorldPointVelocity(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETVECTOR(p)
|
|
__SQ_GETEND
|
|
__SQ_GETPHYSICITEM(item)
|
|
__SQ_RETURNVECTOR(iphysic->GetWorldPointVelocity(p))
|
|
}
|
|
SQInteger ItemGetPhysicPosition(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__SQ_GETPHYSICITEM(item)
|
|
GS::Matrix4 m;
|
|
iphysic->GetMatrix(m);
|
|
__SQ_RETURNVECTOR(m.GetRow(3))
|
|
}
|
|
SQInteger ItemSetPhysicPosition(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETVECTOR(p)
|
|
__SQ_GETEND
|
|
__SQ_GETPHYSICITEM(item)
|
|
GS::Matrix4 m;
|
|
iphysic->GetMatrix(m);
|
|
m.SetRow(3, p);
|
|
iphysic->SetMatrix(m);
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger ItemGetPhysicPreviousPosition(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__SQ_RETURNVECTOR(Vector4(0, 0, 0))
|
|
}
|
|
SQInteger ItemSetPhysicPreviousPosition(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETVECTOR(position)
|
|
__SQ_GETEND
|
|
__LOG_E__ << "OBSOLETE\n";
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger ItemGetPhysicRotation(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__SQ_GETPHYSICITEM(item)
|
|
GS::Matrix4 m;
|
|
iphysic->GetMatrix(m);
|
|
__SQ_RETURNVECTOR(GS::Matrix3::FromMatrix4(m).AsEuler())
|
|
}
|
|
SQInteger ItemSetPhysicRotation(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETVECTOR(r)
|
|
__SQ_GETEND
|
|
__SQ_GETPHYSICITEM(item)
|
|
GS::Matrix4 m;
|
|
iphysic->GetMatrix(m);
|
|
Vector4 p, s;
|
|
m.Decompose(&p, &s);
|
|
iphysic->SetMatrix(GS::Matrix4::TransformationMatrix(p, r, s));
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger ItemPhysicSynchronizeCollision(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__ERR__(__LOG_E__ << "OBSOLETE", 0)
|
|
}
|
|
SQInteger ItemWorldPointVelocity(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETVECTOR(wp)
|
|
__SQ_GETEND
|
|
__SQ_GETPHYSICITEM(item)
|
|
__SQ_RETURNVECTOR(iphysic->GetWorldPointVelocity(wp))
|
|
}
|
|
SQInteger ItemPointVelocity(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETVECTOR(p)
|
|
__SQ_GETEND
|
|
__SQ_GETPHYSICITEM(item)
|
|
__SQ_RETURNVECTOR(iphysic->GetLocalPointVelocity(p))
|
|
}
|
|
SQInteger ItemGetCenterOfMass(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__SQ_GETPHYSICITEM(item)
|
|
__SQ_RETURNVECTOR(iphysic->GetCenterOfMass())
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
SQInteger ItemPhysicCharacterSetRotationMatrix(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETMATRIX3(m)
|
|
__SQ_GETEND
|
|
__SQ_GETPHYSICITEM(item)
|
|
iphysic->CharacterSetRotationMatrix(m);
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger ItemPhysicCharacterSetVelocity(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETVECTOR(V)
|
|
__SQ_GETEND
|
|
__SQ_GETPHYSICITEM(item)
|
|
iphysic->CharacterSetVelocity(V);
|
|
__SQ_RETURN
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
SQInteger ItemPhysicVehicleSetForce(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(3)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETINT(index)
|
|
__SQ_GETFLOAT(F)
|
|
__SQ_GETEND
|
|
__SQ_GETPHYSICITEM(item)
|
|
iphysic->VehicleSetForce(F, index);
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger ItemPhysicVehicleSetBrake(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(3)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETINT(index)
|
|
__SQ_GETFLOAT(F)
|
|
__SQ_GETEND
|
|
__SQ_GETPHYSICITEM(item)
|
|
iphysic->VehicleSetBrake(F, index);
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger ItemPhysicVehicleSetSteering(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(3)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETINT(index)
|
|
__SQ_GETFLOAT(v)
|
|
__SQ_GETEND
|
|
__SQ_GETPHYSICITEM(item)
|
|
iphysic->VehicleSetSteering(v, index);
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger ItemPhysicVehicleSetFriction(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(3)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETINT(index)
|
|
__SQ_GETFLOAT(f)
|
|
__SQ_GETEND
|
|
__SQ_GETPHYSICITEM(item)
|
|
iphysic->VehicleSetFriction(f, index);
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger ItemPhysicVehicleGetWheelMatrix(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETINT(index)
|
|
__SQ_GETEND
|
|
__SQ_GETPHYSICITEM(item)
|
|
__SQ_RETURNMATRIX4(iphysic->VehicleGetWheelMatrix(index))
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
SQInteger ItemGetLocalMinMax(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
|
|
MinMax mm;
|
|
if (item->GetItemType() == Type_Object)
|
|
{
|
|
MObject *obj = (MObject *)item;
|
|
|
|
if (obj->geometry.IsEmpty())
|
|
mm.Set(obj->GetMatrix().GetRow(3), obj->GetMatrix().GetRow(3));
|
|
|
|
else
|
|
{
|
|
if (obj->render_data.IsNull())
|
|
return sq_throwerror(vm, "Object has no render data, you need to call ObjectRenderSetup() first.");
|
|
if (obj->render_data->geometry.IsNull())
|
|
return sq_throwerror(vm, "Object has no render geometry, you need to call ObjectRenderSetup() first.");
|
|
|
|
mm = obj->render_data->geometry->minmax;
|
|
}
|
|
}
|
|
__SQ_RETURNMINMAX(mm)
|
|
}
|
|
|
|
SQInteger ItemGetWorldMinMax(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
|
|
MinMax mm;
|
|
if (item->GetItemType() == Type_Object)
|
|
{
|
|
MObject *obj = (MObject *)item;
|
|
|
|
if (obj->geometry.IsEmpty())
|
|
mm.Set(obj->GetMatrix().GetRow(3), obj->GetMatrix().GetRow(3));
|
|
|
|
else
|
|
{
|
|
if (obj->render_data.IsNull())
|
|
return sq_throwerror(vm, "Object has no render data, you need to call ObjectRenderSetup() first.");
|
|
if (obj->render_data->geometry.IsNull())
|
|
return sq_throwerror(vm, "Object has no render geometry, you need to call ObjectRenderSetup() first.");
|
|
|
|
OBB obb(obj->render_data->geometry->minmax);
|
|
obb.Transform(obj->GetMatrix());
|
|
obb.ComputeMinMax(mm);
|
|
}
|
|
}
|
|
__SQ_RETURNMINMAX(mm)
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
SQInteger ItemGetSkinBoneItemsGroup(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
|
|
if (item->GetItemType() != Type_Object)
|
|
return sq_throwerror(vm, String("Item '") << item->name << "' is not an object.");
|
|
|
|
MObject *o = (MObject *)item;
|
|
Core::Skin *skin = o->GetSkin();
|
|
|
|
if (!skin)
|
|
return sq_throwerror(vm, String("Object '") << item->name << "' has no skin.");
|
|
|
|
Group *g = new Group;
|
|
for (uint n = 0; n < skin->bones.GetCount(); ++n)
|
|
g->Add(Scene::LocateManagedItem(skin->bones[n]));
|
|
|
|
__SQ_RETURNMANAGEDSAFEPTR(g, typetag_Group)
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
SQInteger ItemGetMotionCount(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__SQ_RETURNINT(item->automation_player->GetMotionList().GetCount())
|
|
}
|
|
SQInteger ItemGetMotionFromIndex(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETINT(index)
|
|
__SQ_GETEND
|
|
__SQ_RETURNSAFEPTR(item->automation_player->GetMotionFromIndex(index), typetag_Motion)
|
|
}
|
|
|
|
SQInteger ItemStopAllMotions(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
item->automation_player->DisposeAutomationSources();
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger ItemSetMotion(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(3)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETSTRING(name)
|
|
__SQ_GETFLOAT(blend)
|
|
Automation::Source *source = item->automation_player->StartAutomation(new Automation::MotionSource(item->automation_player->GetMotion(name), NULL), blend, Automation::Player::SourceSet);
|
|
__SQ_GETEND
|
|
__SQ_RETURNSAFEPTR(source, typetag_AutomationSource)
|
|
}
|
|
SQInteger ItemSetMotionRelative(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETBOOL(v)
|
|
__SQ_GETEND
|
|
item->automation_player->flags.Raise(Automation::Player::FlagRelativeMotion, asbool(v));
|
|
__SQ_RETURN
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
SQInteger ItemSetFlags(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(3)
|
|
__SQ_GETCOBJECTBASE(item, MItem, item_derived_types)
|
|
__SQ_GETINT(flags)
|
|
__SQ_GETBOOL(set_flags)
|
|
__SQ_GETEND
|
|
item->mitem_flags.Raise(flags, asbool(set_flags));
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger ItemGetFlags(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, MItem, item_derived_types))
|
|
__SQ_RETURNINT(0) // item->item_flags.Get())
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
void RegisterItemBinding(HSQUIRRELVM vm)
|
|
{
|
|
/*#
|
|
Topic: Item
|
|
Type: Item
|
|
Desc: The item object is the base of all scene 3d entities such as cameras, objects, lights or triggers.
|
|
It stores the entity transformation and motions.
|
|
Related: Scene,Camera,Object,Light,Trigger
|
|
#*/
|
|
|
|
/*#
|
|
Section: ItemRegistry
|
|
Desc: Item registry
|
|
#*/
|
|
/*#
|
|
Func: ItemRegistrySetKey
|
|
Proto: void:Item,string key,value
|
|
Desc: Set item registry key value.
|
|
#*/
|
|
sq_register(vm, ItemRegistrySetKey, "ItemRegistrySetKey", _SC(".xs."));
|
|
/*#
|
|
Func: ItemRegistryGetKey
|
|
Proto: value:Item,string key
|
|
Desc: Get item registry key value.
|
|
#*/
|
|
sq_register(vm, ItemRegistryGetKey, "ItemRegistryGetKey", _SC(".xs"));
|
|
|
|
/*#
|
|
Section: ItemACE
|
|
Desc: ACE
|
|
#*/
|
|
/*#
|
|
Func: ItemSetCommandList
|
|
Proto: void:Item,string command_list
|
|
Desc: Set item asynchronous command list (see ACE).
|
|
#*/
|
|
sq_register(vm, ItemSetCommandList, "ItemSetCommandList", _SC(".xs"));
|
|
/*#
|
|
Func: ItemResetCommandList
|
|
Proto: void:Item
|
|
Desc: Reset item asynchronous command list (see ACE).
|
|
#*/
|
|
sq_register(vm, ItemResetCommandList, "ItemResetCommandList", _SC(".x"));
|
|
/*#
|
|
Func: ItemIsCommandListDone
|
|
Proto: bool:Item
|
|
Desc: Reset item asynchronous command list (see ACE).
|
|
#*/
|
|
sq_register(vm, ItemIsCommandListDone, "ItemIsCommandListDone", _SC(".x"));
|
|
|
|
/*#
|
|
Section: ItemRender
|
|
Desc: Rendering
|
|
#*/
|
|
/*#
|
|
Func: ItemGetMinMax
|
|
Proto: MinMax:Item
|
|
Desc: Return the axis aligned bounding box in world space of the item.
|
|
#*/
|
|
sq_register(vm, ItemGetMinMax, "ItemGetMinMax", _SC(".x"));
|
|
/*#
|
|
Func: ItemGetOpacity
|
|
Proto: float:Item
|
|
Desc: Get item opacity.
|
|
#*/
|
|
sq_register(vm, ItemGetOpacity, "ItemGetOpacity", _SC(".x"));
|
|
sq_register(vm, ItemGetOpacity, "ItemGetAlpha", _SC(".x"));
|
|
/*#
|
|
Func: ItemSetOpacity
|
|
Proto: void:Item,float opacity
|
|
Desc: Set item opacity.
|
|
#*/
|
|
sq_register(vm, ItemSetOpacity, "ItemSetOpacity", _SC(".xn"));
|
|
sq_register(vm, ItemSetOpacity, "ItemSetAlpha", _SC(".xn"));
|
|
|
|
/*#
|
|
Section: ItemMotion
|
|
Desc: Motion
|
|
#*/
|
|
/*#
|
|
Func: ItemGetMotionCount
|
|
Proto: int:Item
|
|
Desc: Get the number of motion in the item motion bank.
|
|
#*/
|
|
sq_register(vm, ItemGetMotionCount, "ItemGetMotionCount", _SC(".x"));
|
|
/*#
|
|
Func: ItemGetMotionFromIndex
|
|
Proto: Motion:Item,int index
|
|
Desc: Get a motion from its index in the item motion bank.
|
|
#*/
|
|
sq_register(vm, ItemGetMotionFromIndex, "ItemGetMotionFromIndex", _SC(".xi"));
|
|
/*#
|
|
Func: ItemStopAllMotions
|
|
Proto: void:Item
|
|
Desc: Stop all motions on this item.
|
|
#*/
|
|
sq_register(vm, ItemStopAllMotions, "ItemStopAllMotions", _SC(".x"));
|
|
/*#
|
|
Func: ItemSetMotion
|
|
Proto: AnimationSource:Item,string name,float blend
|
|
Desc: Start a new motion on this item.
|
|
#*/
|
|
sq_register(vm, ItemSetMotion, "ItemSetMotion", _SC(".xsn"));
|
|
/*#
|
|
Func: ItemSetMotionRelative
|
|
Proto: void:Item,bool relative
|
|
Desc: Set this item to use relative motion source. Motion started on this item will automatically be set to the correct evaluation mode (relative/absolute).
|
|
#*/
|
|
sq_register(vm, ItemSetMotionRelative, "ItemSetMotionRelative", _SC(".xb"));
|
|
|
|
/*#
|
|
Section: ItemTransform
|
|
Desc: Transformation
|
|
#*/
|
|
/*#
|
|
Func: TranslateItem
|
|
Proto: void:Item item,Vector translation
|
|
Desc: Translate an item, the translation vector is expressed in the item parent space.
|
|
#*/
|
|
sq_register(vm, ItemTranslate, "TranslateItem", _SC(".xx"));
|
|
/*#
|
|
Func: RotateItem
|
|
Proto: void:Item item,Vector rotation
|
|
Desc: Rotate an item by a triplet of Euler angles stored in a vector.
|
|
#*/
|
|
sq_register(vm, ItemRotate, "RotateItem", _SC(".xx"));
|
|
/*#
|
|
Func: ScaleItem
|
|
Proto: void:Item item,Vector scale
|
|
Desc: Scale an item by a triplet of scale coefficients stored in a vector.
|
|
#*/
|
|
sq_register(vm, ItemScale, "ScaleItem", _SC(".xx"));
|
|
|
|
/*#
|
|
Func: ItemSetLinkInheritsPositionOnly
|
|
Proto: void:Item,bool inherits
|
|
Desc: Set the item to inherits only the position from its parent item.
|
|
#*/
|
|
sq_register(vm, ItemSetLinkInheritsPositionOnly, "ItemSetLinkInheritsPositionOnly", _SC(".xb"));
|
|
/*#
|
|
Func: ItemGetPosition
|
|
Proto: Vector:Item
|
|
Desc: Get item position in parent space (world space if no parent).
|
|
#*/
|
|
sq_register(vm, ItemGetPosition, "ItemGetPosition", _SC(".x"));
|
|
/*#
|
|
Func: ItemSetPosition
|
|
Proto: void:Item,Vector position
|
|
Desc: Set item position in parent space (world space if no parent).
|
|
#*/
|
|
sq_register(vm, ItemSetPosition, "ItemSetPosition", _SC(".xx"));
|
|
/*#
|
|
Func: ItemGetScale
|
|
Proto: Vector:Item
|
|
Desc: Get item scale.
|
|
#*/
|
|
sq_register(vm, ItemGetScale, "ItemGetScale", _SC(".x"));
|
|
/*#
|
|
Func: ItemSetScale
|
|
Proto: void:Item,Vector scale
|
|
Desc: Set item scale.
|
|
#*/
|
|
sq_register(vm, ItemSetScale, "ItemSetScale", _SC(".xx"));
|
|
/*#
|
|
Func: ItemGetWorldPosition
|
|
Proto: Vector:Item
|
|
Desc: Return item position in world space.
|
|
#*/
|
|
sq_register(vm, ItemGetWorldPosition, "ItemGetWorldPosition", _SC(".x"));
|
|
/*#
|
|
Func: ItemGetWorldRotation
|
|
Proto: Vector:Item
|
|
Desc: Get item rotation in world space as Euler angles (x, y, z).
|
|
Example:
|
|
// Get the world rotation of an item
|
|
local world_rot = ItemGetWorldRotation(item)
|
|
*/
|
|
sq_register(vm, ItemGetWorldRotation, "ItemGetWorldRotation", _SC(".x"));
|
|
|
|
/*#
|
|
Func: ItemGetPreviousWorldPosition
|
|
Proto: Vector:Item
|
|
Desc: Return item position in world space during the previously rendered frame.
|
|
#*/
|
|
sq_register(vm, ItemGetPreviousWorldPosition, "ItemGetPreviousWorldPosition", _SC(".x"));
|
|
/*#
|
|
Func: ItemGetRotation
|
|
Proto: Vector:Item
|
|
Desc: Get item rotation in Euler angles (x, y, z).
|
|
#*/
|
|
sq_register(vm, ItemGetRotation, "ItemGetRotation", _SC(".x"));
|
|
/*#
|
|
Func: ItemSetRotation
|
|
Proto: void:Item,Vector euler
|
|
Desc: Set item rotation in Euler angles (x, y, z).
|
|
Example:
|
|
// Set the item rotation to +90 degree on the Y axis.
|
|
ItemSetRotation(item, Vector(Deg(0), Deg(90), Deg(0)))
|
|
#*/
|
|
sq_register(vm, ItemSetRotation, "ItemSetRotation", _SC(".xx"));
|
|
/*#
|
|
Func: ItemSetRotationQuaternion
|
|
Proto: void:Item,Quaternion rotation
|
|
Desc: Set item rotation quaternion.
|
|
#*/
|
|
sq_register(vm, ItemSetRotationQuaternion, "ItemSetRotationQuaternion", _SC(".xx"));
|
|
/*#
|
|
Func: ItemGetPivot
|
|
Proto: Vector:Item
|
|
Desc: Get item pivot.
|
|
#*/
|
|
sq_register(vm, ItemGetPivot, "ItemGetPivot", _SC(".x"));
|
|
/*#
|
|
Func: ItemSetPivot
|
|
Proto: void:Item,Vector pivot
|
|
Desc: Set item pivot.
|
|
#*/
|
|
sq_register(vm, ItemSetPivot, "ItemSetPivot", _SC(".xx"));
|
|
|
|
/*#
|
|
Func: ItemComputeMatrix
|
|
Proto: void:Item
|
|
Desc: Compute item matrix and inverse matrix.
|
|
#*/
|
|
sq_register(vm, ItemComputeMatrix, "ItemComputeMatrix", _SC(".x"));
|
|
/*#
|
|
Func: ItemComputeLocalMatrix
|
|
Proto: void:Item
|
|
Desc: Compute item local matrix.
|
|
#*/
|
|
sq_register(vm, ItemComputeLocalMatrix, "ItemComputeLocalMatrix", _SC(".x"));
|
|
/*#
|
|
Func: ItemComputeMinMax
|
|
Proto: void:Item
|
|
Desc: Compute item minmax.
|
|
#*/
|
|
sq_register(vm, ItemComputeMinMax, "ItemComputeMinMax", _SC(".x"));
|
|
|
|
/*#
|
|
Func: ItemGetParent
|
|
Proto: Item:Item
|
|
Desc: Get item parent item.
|
|
#*/
|
|
sq_register(vm, ItemGetParent, "ItemGetParent", _SC(".x"));
|
|
/*#
|
|
Func: ItemSetParent
|
|
Proto: void:Item,Item parent
|
|
Desc: Set item parent item.
|
|
#*/
|
|
sq_register(vm, ItemSetLink, "ItemSetLink", _SC(".xx"));
|
|
sq_register(vm, ItemSetLink, "ItemSetParent", _SC(".xx"));
|
|
/*#
|
|
Func: ItemGetChildList
|
|
Proto: array:Item
|
|
Desc: Returns an array containing child items of this item.
|
|
#*/
|
|
sq_register(vm, ItemGetChildList, "ItemGetChildList", _SC(".x"));
|
|
/*#
|
|
Func: ItemSetTarget
|
|
Proto: void:Item,Vector world_target
|
|
Desc: Set item target position in world space.
|
|
#*/
|
|
sq_register(vm, ItemSetTarget, "ItemSetTarget", _SC(".xx"));
|
|
/*#
|
|
Func: ItemSetNoTarget
|
|
Proto: void:Item
|
|
Desc: Set no item target.
|
|
#*/
|
|
sq_register(vm, ItemSetNoTarget, "ItemSetNoTarget", _SC(".x"));
|
|
/*#
|
|
Func: ItemGetTarget
|
|
Proto: Vector:Item
|
|
Desc: Get item target position in world space.
|
|
#*/
|
|
sq_register(vm, ItemGetTarget, "ItemGetTarget", _SC(".x"));
|
|
/*#
|
|
Func: ItemHasTarget
|
|
Proto: bool:Item
|
|
Desc: Returns true if the item is set to target a specific location.
|
|
#*/
|
|
sq_register(vm, ItemHasTarget, "ItemHasTarget", _SC(".x"));
|
|
/*#
|
|
Func: ItemGetRotationOrder
|
|
Proto: RotationOrder:Item
|
|
Desc: Return the item rotation order.
|
|
#*/
|
|
sq_register(vm, ItemGetRotationOrder, "ItemGetRotationOrder", _SC(".x"));
|
|
/*#
|
|
Func: ItemSetRotationOrder
|
|
Proto: void:Item,RotationOrder
|
|
Desc: Set the item rotation order.
|
|
#*/
|
|
sq_register(vm, ItemSetRotationOrder, "ItemSetRotationOrder", _SC(".xi"));
|
|
/*#
|
|
Func: ItemGetRotationMatrix
|
|
Proto: Matrix3:Item
|
|
Desc: Return the 3x3 item rotation matrix.
|
|
#*/
|
|
sq_register(vm, ItemGetRotationMatrix, "ItemGetRotationMatrix", _SC(".x"));
|
|
/*#
|
|
Func: ItemSetRotationMatrix
|
|
Proto: void:Item,Matrix3 rotation
|
|
Desc: Set the 3x3 item rotation matrix.
|
|
#*/
|
|
sq_register(vm, ItemSetRotationMatrix, "ItemSetRotationMatrix", _SC(".xx"));
|
|
/*#
|
|
Func: ItemGetMatrix
|
|
Proto: Matrix4:Item
|
|
Desc: Return the 4x4 item transformation matrix in world space.
|
|
#*/
|
|
sq_register(vm, ItemGetMatrix, "ItemGetMatrix", _SC(".x"));
|
|
/*#
|
|
Func: ItemGetInverseMatrix
|
|
Proto: Matrix4:Item
|
|
Desc: Return the inverse 4x4 item transformation matrix.
|
|
#*/
|
|
sq_register(vm, ItemGetInverseMatrix, "ItemGetInverseMatrix", _SC(".x"));
|
|
/*#
|
|
Func: ItemGetLocalMatrix
|
|
Proto: Matrix4:Item
|
|
Desc: Return the 4x4 item transformation matrix in parent space.
|
|
#*/
|
|
sq_register(vm, ItemGetLocalMatrix, "ItemGetLocalMatrix", _SC(".x"));
|
|
/*#
|
|
Func: ItemSetMatrix
|
|
Proto: void:Item,Matrix4
|
|
Desc: Set the 4x4 item transformation matrix.
|
|
#*/
|
|
sq_register(vm, ItemSetMatrix, "ItemSetMatrix", _SC(".xx"));
|
|
/*#
|
|
Func: ItemRecordLocation
|
|
Proto: void:Item
|
|
Desc: Record item start location, item is set back to this location when reseted.
|
|
#*/
|
|
sq_register(vm, ItemRecordLocation, "ItemRecordLocation", _SC(".x"));
|
|
/*#
|
|
Func: ItemSnapshotTransformation
|
|
Proto: void:Item
|
|
Desc: Snapshot current item transformation matrix to the current orientation method.
|
|
#*/
|
|
sq_register(vm, ItemSnapshotTransformation, "ItemSnapshotTransformation", _SC(".x"));
|
|
/*#
|
|
Func: ItemSnapshotMatrix
|
|
Proto: void:Item,Matrix4
|
|
Desc: Snapshot matrix as item transformation.
|
|
#*/
|
|
sq_register(vm, ItemSnapshotMatrix, "ItemSnapshotMatrix", _SC(".xx"));
|
|
/*#
|
|
Func: ItemGetLocalMinMax
|
|
Proto: MinMax:Item
|
|
Desc: Return an item bounding box in local space.
|
|
#*/
|
|
sq_register(vm, ItemGetLocalMinMax, "ItemGetLocalMinMax", _SC(".x"));
|
|
/*#
|
|
Func: ItemGetWorldMinMax
|
|
Proto: MinMax:Item
|
|
Desc: Return an item bounding box in world space.
|
|
#*/
|
|
sq_register(vm, ItemGetWorldMinMax, "ItemGetWorldMinMax", _SC(".x"));
|
|
|
|
/*#
|
|
Section: ItemCast
|
|
Desc: Type cast
|
|
#*/
|
|
/*#
|
|
Func: ItemCastToObject
|
|
Proto: Object:Item
|
|
Desc: Cast item to object.
|
|
#*/
|
|
sq_register(vm, ItemCastToObject, "ItemCastToObject", _SC(".x"));
|
|
/*#
|
|
Func: ItemCastToCamera
|
|
Proto: Camera:Item
|
|
Desc: Cast item to camera.
|
|
#*/
|
|
sq_register(vm, ItemCastToCamera, "ItemCastToCamera", _SC(".x"));
|
|
/*#
|
|
Func: ItemCastToTrigger
|
|
Proto: Trigger:Item
|
|
Desc: Cast item to trigger.
|
|
#*/
|
|
sq_register(vm, ItemCastToTrigger, "ItemCastToTrigger", _SC(".x"));
|
|
/*#
|
|
Func: ItemCastToLight
|
|
Proto: Light:Item
|
|
Desc: Cast item to light.
|
|
Example:
|
|
local light = ItemCastToLight(item)
|
|
LightSetRange(light, Mtr(20))
|
|
#*/
|
|
sq_register(vm, ItemCastToLight, "ItemCastToLight", _SC(".x"));
|
|
/*#
|
|
Func: ItemCastToInstance
|
|
Proto: Instance:Item
|
|
Desc: Cast item to instance.
|
|
#*/
|
|
sq_register(vm, ItemCastToInstance, "ItemCastToInstance", _SC(".x"));
|
|
/*#
|
|
Func: ItemCastToEmitter
|
|
Proto: Emitter:Item
|
|
Desc: Cast item to emitter.
|
|
#*/
|
|
sq_register(vm, ItemCastToEmitter, "ItemCastToEmitter", _SC(".x"));
|
|
/*#
|
|
Func: ItemDerivedCastToItem
|
|
Proto: Item:ItemDerived
|
|
Desc: Cast an item derived object (camera, object, light, trigger) to an item.
|
|
#*/
|
|
sq_register(vm, ItemDerivedCastToItem, "ItemDerivedCastToItem", _SC(".x"));
|
|
|
|
/*#
|
|
Section: ItemState
|
|
Desc: State
|
|
#*/
|
|
/*#
|
|
Func: ItemIsInvisible
|
|
Proto: bool:Item
|
|
Desc: Return the visibility state of the item.
|
|
#*/
|
|
sq_register(vm, ItemIsInvisible, "ItemIsInvisible", _SC(".x"));
|
|
/*#
|
|
Func: ItemSetInvisible
|
|
Proto: void:Item,bool invisible
|
|
Desc: Set item display flag, item is still updated but not displayed anymore.
|
|
#*/
|
|
sq_register(vm, ItemSetInvisible, "ItemSetInvisible", _SC(".xb"));
|
|
/*#
|
|
Func: ItemHierarchySetInvisible
|
|
Proto: void:Item,bool
|
|
Desc: Set item and children display flag, item and children are still updated but not displayed anymore.
|
|
#*/
|
|
sq_register(vm, ItemHierarchySetInvisible, "ItemHierarchySetInvisible", _SC(".xb"));
|
|
/*#
|
|
Func: ItemIsActive
|
|
Proto: bool:Item
|
|
Desc: Return true if the given item is active, false otherwise.
|
|
#*/
|
|
sq_register(vm, ItemIsActive, "ItemIsActive", _SC(".x"));
|
|
|
|
/*#
|
|
Section: Item
|
|
Desc: General
|
|
#*/
|
|
/*#
|
|
Func: ItemReset
|
|
Proto: void:Item
|
|
Desc: Reset an item, effectively calling its OnReset script callbacks and resetting its physic state to the current item transformation.
|
|
#*/
|
|
sq_register(vm, ItemReset, "ItemReset", _SC(".x"));
|
|
/*#
|
|
Func: ItemRenderSetup
|
|
Proto: void:Item,ResourceFactory
|
|
Desc: Setup the resources required to render an item.
|
|
#*/
|
|
sq_register(vm, ItemRenderSetup, "ItemRenderSetup", _SC(".xx"));
|
|
/*#
|
|
Func: ItemSetup
|
|
Proto: void:Item
|
|
Desc: Setup an item.
|
|
Deprecated: SceneSetupItem
|
|
#*/
|
|
;
|
|
/*#
|
|
Func: ItemGetType
|
|
Proto: ItemType:Item
|
|
Desc: Return the item type (camera, light, object, trigger, etc...).
|
|
#*/
|
|
sq_register(vm, ItemGetType, "ItemGetType", _SC(".x"));
|
|
/*#
|
|
Func: ItemCompare
|
|
Proto: bool:Item,Item
|
|
Desc: Compare two items, returns true is both items are the same object.
|
|
#*/
|
|
sq_register(vm, ItemCompare, "ItemCompare", _SC(".xx"));
|
|
/*#
|
|
Func: ItemGetGeometry
|
|
Proto: Geometry:Item
|
|
Desc: Get item geometry, an item may have no geometry.
|
|
See: ObjectIsValid
|
|
#*/
|
|
sq_register(vm, ItemGetGeometry, "ItemGetGeometry", _SC(".x"));
|
|
/*#
|
|
Func: ItemSaveGeometry
|
|
Proto: void:Item, path
|
|
Desc:save the item geometry into the path.
|
|
#*/
|
|
sq_register(vm, ItemSaveGeometry, "ItemSaveGeometry", _SC(".xsx"));
|
|
/*#
|
|
Func: ItemSetPriority
|
|
Proto: void:Item,float priority
|
|
Desc: Set an item priority.
|
|
#*/
|
|
sq_register(vm, ItemSetPriority, "ItemSetPriority", _SC(".xn"));
|
|
/*#
|
|
Func: ItemGetChild
|
|
Proto: Item:Item,string name
|
|
Desc: Get an item child from its name.
|
|
Example: local hand = ItemGetChild(arm_item, "hand")
|
|
#*/
|
|
sq_register(vm, ItemGetChild, "ItemGetChild", _SC(".xs"));
|
|
|
|
/*#
|
|
Func: ItemGetName
|
|
Proto: string:Item
|
|
Desc: Get item name.
|
|
#*/
|
|
sq_register(vm, ItemGetName, "ItemGetName", _SC(".x"));
|
|
/*#
|
|
Func: ItemSetName
|
|
Proto: void:Item,string
|
|
Desc: Set item name.
|
|
#*/
|
|
sq_register(vm, ItemSetName, "ItemSetName", _SC(".xs"));
|
|
/*#
|
|
Func: ItemGetFlags
|
|
Proto: ItemFlag:Item
|
|
Desc: Get item flags.
|
|
#*/
|
|
sq_register(vm, ItemGetFlags, "ItemGetFlags", _SC(".x"));
|
|
/*#
|
|
Func: ItemSetFlags
|
|
Proto: void:Item,ItemFlag flag,bool set
|
|
Desc: Set or remove one or several item flags.
|
|
#*/
|
|
sq_register(vm, ItemSetFlags, "ItemSetFlags", _SC(".xib"));
|
|
|
|
/*#
|
|
Section: ItemSkin
|
|
Desc: Skinning
|
|
#*/
|
|
/*#
|
|
Func: ItemGetSkinBoneItemsGroup
|
|
Proto: Group:Item
|
|
Desc: Return the item skin bone items as an item group.
|
|
See: GroupGetRootItem, GroupGetItemList
|
|
#*/
|
|
sq_register(vm, ItemGetSkinBoneItemsGroup, "ItemGetSkinBoneItemsGroup", _SC(".x"));
|
|
|
|
/*#
|
|
Section: ItemPhysicState
|
|
Desc: Physic state
|
|
#*/
|
|
/*#
|
|
Func: ItemWake
|
|
Proto: void:Item
|
|
Desc: Wake a physic item, all collision and physic evaluation will resume.
|
|
#*/
|
|
sq_register(vm, ItemWake, "ItemWake", _SC(".x"));
|
|
/*#
|
|
Func: ItemSleep
|
|
Proto: void:Item
|
|
Desc: Put a physic item to sleep, all collision and physic evaluation will stop.
|
|
#*/
|
|
sq_register(vm, ItemSleep, "ItemSleep", _SC(".x"));
|
|
/*#
|
|
Func: ItemIsSleeping
|
|
Proto: bool:Item
|
|
Desc: Returns true if the item is sleeping, false otherwise.
|
|
#*/
|
|
sq_register(vm, ItemIsSleeping, "ItemIsSleeping", _SC(".x"));
|
|
/*#
|
|
Func: ItemPhysicGetFlag
|
|
Proto: PhysicFlag:Item
|
|
Desc: Get item physic flag.
|
|
#*/
|
|
sq_register(vm, ItemPhysicGetFlag, "ItemPhysicGetFlag", _SC(".x"));
|
|
/*#
|
|
Func: ItemPhysicSetFlag
|
|
Proto: void:Item,PhysicFlag
|
|
Desc: Set item physic flag.
|
|
#*/
|
|
sq_register(vm, ItemPhysicSetFlag, "ItemPhysicSetFlag", _SC(".xi"));
|
|
|
|
/*#
|
|
Section: ItemCharacterPhysic
|
|
Desc: Character Physic
|
|
#*/
|
|
/*#
|
|
Func: ItemPhysicCharacterSetRotationMatrix
|
|
Proto: void:Item,Matrix3 m
|
|
Desc: Set physics character rotation matrix.
|
|
#*/
|
|
sq_register(vm, ItemPhysicCharacterSetRotationMatrix, "ItemPhysicCharacterSetRotationMatrix", _SC(".xx"));
|
|
/*#
|
|
Func: ItemPhysicCharacterSetVelocity
|
|
Proto: void:Item,Vector V
|
|
Desc: Set physics character controller velocity.
|
|
#*/
|
|
sq_register(vm, ItemPhysicCharacterSetVelocity, "ItemPhysicCharacterSetVelocity", _SC(".xx"));
|
|
|
|
/*#
|
|
Section: ItemVehiclePhysic
|
|
Desc: Vehicle Physic
|
|
#*/
|
|
/*#
|
|
Func: ItemPhysicVehicleSetForce
|
|
Proto: void:Item,int wheel_index,float F
|
|
Desc: Set engine force F for a specific wheel in the vehicle model.
|
|
#*/
|
|
sq_register(vm, ItemPhysicVehicleSetForce, "ItemPhysicVehicleSetForce", _SC(".xin"));
|
|
/*#
|
|
Func: ItemPhysicVehicleSetBrake
|
|
Proto: void:Item,int wheel_index,float F
|
|
Desc: Set brake force F for a specific wheel in the vehicle model.
|
|
#*/
|
|
sq_register(vm, ItemPhysicVehicleSetBrake, "ItemPhysicVehicleSetBrake", _SC(".xin"));
|
|
/*#
|
|
Func: ItemPhysicVehicleSetSteering
|
|
Proto: void:Item,int wheel_index,float angle
|
|
Desc: Set steering on a specific wheel of the vehicle model.
|
|
#*/
|
|
sq_register(vm, ItemPhysicVehicleSetSteering, "ItemPhysicVehicleSetSteering", _SC(".xin"));
|
|
/*#
|
|
Func: ItemPhysicVehicleSetFriction
|
|
Proto: void:Item,int wheel_index,float friction_slip
|
|
Desc: Set friction on a specific wheel of the vehicle model.
|
|
#*/
|
|
sq_register(vm, ItemPhysicVehicleSetFriction, "ItemPhysicVehicleSetFriction", _SC(".xin"));
|
|
/*#
|
|
Func: ItemPhysicVehicleGetWheelMatrix
|
|
Proto: Matrix4:Item,int wheel_index
|
|
Desc: Get a specific wheel matrix from the vehicle model.
|
|
#*/
|
|
sq_register(vm, ItemPhysicVehicleGetWheelMatrix, "ItemPhysicVehicleGetWheelMatrix", _SC(".xi"));
|
|
|
|
/*#
|
|
Section: ItemPhysic
|
|
Desc: Physic
|
|
#*/
|
|
/*#
|
|
Func: ItemSetInertiaTensorAndCom
|
|
Proto: void:Item,Matrix3 tensor,Vector center_of_mass
|
|
Desc: Manually set the item inertia tensor and center of mass.
|
|
See: ItemUpdateInertiaTensorFromCollision
|
|
#*/
|
|
sq_register(vm, ItemSetInertiaTensorAndCom, "ItemSetInertiaTensorAndCom", _SC(".xxx"));
|
|
/*#
|
|
Func: ItemUpdateInertiaTensorFromCollision
|
|
Proto: void:Item
|
|
Desc: Compute item inertia tensor and center of mass from the associated collision shape description.
|
|
#*/
|
|
sq_register(vm, ItemUpdateInertiaTensorFromCollision, "ItemUpdateInertiaTensorFromCollision", _SC(".x"));
|
|
/*#
|
|
Func: ItemGetSpeed
|
|
Proto: float:Item
|
|
Desc: Get item center of mass speed (in m.s).
|
|
Note: This is the equivalent of ItemGetLinearVelocity(item).Len()
|
|
See: ItemPointVelocity, ItemWorldPointVelocity
|
|
#*/
|
|
sq_register(vm, ItemGetSpeed, "ItemGetSpeed", _SC(".x"));
|
|
|
|
/*#
|
|
Func: ItemApplyLinearForce
|
|
Proto: void:Item,Vector force
|
|
Desc: Apply a force to the item center of mass. Rotation is not affected.
|
|
#*/
|
|
sq_register(vm, ItemApplyLinearForce, "ItemApplyLinearForce", _SC(".xx"));
|
|
/*#
|
|
Func: ItemApplyForce
|
|
Proto: void:Item,Vector position,Vector force
|
|
Desc: Apply a force at a specific position in world space to the item.
|
|
Example:
|
|
// Apply thrust to a ship item, the reactor item is parented to the ship item.
|
|
local reactor_matrix = ItemGetMatrix(reactor_item)
|
|
|
|
// Get the reactor position and the vector pointing toward its back (and the back of the ship).
|
|
local reactor_world_position = reactor_matrix.GetPosition()
|
|
local reactor_back_vector = reactor_matrix.GetBack()
|
|
|
|
// Apply thrust to the ship at the position of the reactor and in the correct direction.
|
|
local thrust_strength = 10.0 // the thrust strength
|
|
ItemApplyForce(ship_item, reactor_world_position, reactor_back_vector * thrust_strength)
|
|
#*/
|
|
sq_register(vm, ItemApplyForce, "ItemApplyForce", _SC(".xxx"));
|
|
/*#
|
|
Func: ItemApplyLinearImpulse
|
|
Proto: void:Item,Vector impulse
|
|
Desc: Apply an impulse to the item center of mass. Rotation is not affected. An impulse is an immediate change of velocity. It is expressed as the difference between the target velocity and the current velocity.
|
|
See: ItemApplyImpulse
|
|
Example:
|
|
// Retrieve the current item linear velocity.
|
|
local current_v = ItemGetLinearVelocity(item)
|
|
|
|
// Compute the impulse to force the item velocity to {1, 0, 0}.
|
|
local J = Vector(1, 0, 0) - current_v
|
|
|
|
// Force the item linear velocity to {1, 0, 0}
|
|
ItemApplyImpulse(item, J)
|
|
#*/
|
|
sq_register(vm, ItemApplyLinearImpulse, "ItemApplyLinearImpulse", _SC(".xx"));
|
|
/*#
|
|
Func: ItemApplyImpulse
|
|
Proto: void:Item,Vector position,Vector impulse
|
|
Desc: Apply an impulse at a specific position in world space to the item.
|
|
See: ItemApplyLinearImpulse
|
|
#*/
|
|
sq_register(vm, ItemApplyImpulse, "ItemApplyImpulse", _SC(".xxx"));
|
|
/*#
|
|
Func: ItemApplyTorque
|
|
Proto: void:Item,Vector torque
|
|
Desc: Apply a torque to the item. The torque is the rotational equivalent of the force. It will increase the body angular velocity which will in turn rotate it.
|
|
#*/
|
|
sq_register(vm, ItemApplyTorque, "ItemApplyTorque", _SC(".xx"));
|
|
|
|
/*#
|
|
Func: ItemPhysicSetLinearFactor
|
|
Proto: void:Item,Vector factor
|
|
Desc: Set the scale factor for all forces applied to this item linear velocity. All forces applied directly and indirectly to this item will be scaled by this factor.
|
|
Example:
|
|
// Restrict all motions to the XY plane by canceling out all forces Z component.
|
|
ItemPhysicSetLinearFactor(item, Vector(1, 1, 0))
|
|
#*/
|
|
sq_register(vm, ItemPhysicSetLinearFactor, "ItemPhysicSetLinearFactor", _SC(".xx"));
|
|
/*#
|
|
Func: ItemPhysicSetAngularFactor
|
|
Proto: void:Item,Vector factor
|
|
Desc: Set the scale factor for all forces applied to this item angular velocity. All torques applied directly and indirectly to this item will be scaled by this factor.
|
|
Example:
|
|
// Restrict all rotations to the Z axis by canceling out all torques on the X and Y axises.
|
|
ItemPhysicSetangularFactor(item, Vector(0, 0, 1))
|
|
#*/
|
|
sq_register(vm, ItemPhysicSetAngularFactor, "ItemPhysicSetAngularFactor", _SC(".xx"));
|
|
|
|
/*#
|
|
Func: ItemPhysicResetTransformation
|
|
Proto: void:Item,Vector position,Vector euler
|
|
Desc: Reset item physic transformation to specific location (in item local space).
|
|
#*/
|
|
sq_register(vm, ItemPhysicResetTransformation, "ItemPhysicResetTransformation", _SC(".xxx"));
|
|
/*#
|
|
Func: ItemGetLinearDamping
|
|
Proto: float:Item
|
|
Desc: Get item linear damping.
|
|
#*/
|
|
sq_register(vm, ItemGetLinearDamping, "ItemGetLinearDamping", _SC(".x"));
|
|
/*#
|
|
Func: ItemSetLinearDamping
|
|
Proto: void:Item,float damping
|
|
Desc: Set item linear damping by which the item linear velocity is scaled after each solver iteration.<br>
|
|
A damping value of 1 will not affect velocity, a damping of 0 will completely cancel velocity and a damping of 0.5 will make the object appear as if moving through a thick invisible material.<br>
|
|
Note: A small amount of damping (0.99) can help the solver as it prevents sudden change and oscillation in velocity.<br>Too much damping can prevent the solver from reaching a stable configuration.
|
|
#*/
|
|
sq_register(vm, ItemSetLinearDamping, "ItemSetLinearDamping", _SC(".xn"));
|
|
/*#
|
|
Func: ItemGetAngularDamping
|
|
Proto: float:Item
|
|
Desc: Get item angular damping.
|
|
#*/
|
|
sq_register(vm, ItemGetAngularDamping, "ItemGetAngularDamping", _SC(".x"));
|
|
/*#
|
|
Func: ItemSetAngularDamping
|
|
Proto: void:Item,float damping
|
|
Desc: Set item angular damping. This is the rotational equivalent of the linear damping.
|
|
See: ItemSetLinearDamping
|
|
#*/
|
|
sq_register(vm, ItemSetAngularDamping, "ItemSetAngularDamping", _SC(".xn"));
|
|
/*#
|
|
Func: ItemGetAngularVelocity
|
|
Proto: Vector:Item
|
|
Desc: Get item angular velocity (rad.s). The angular velocity is the rate of change in rotation over time.
|
|
Note: The angular velocity only affects rotation, position is affected by the linear velocity.
|
|
See: ItemGetLinearVelocity
|
|
#*/
|
|
sq_register(vm, ItemGetAngularVelocity, "ItemGetAngularVelocity", _SC(".x"));
|
|
/*#
|
|
Func: ItemSetAngularVelocity
|
|
Proto: void:Item,Vector angular_velocity
|
|
Desc: Set item angular velocity (rad.s).
|
|
Note: This function sets the item angular velocity by bypassing the physics solver. This can lead to all sorts of problems depending on the scene configuration. You are advised to perform such change using an impulse instead.
|
|
See: ItemApplyAngularImpulse
|
|
#*/
|
|
sq_register(vm, ItemSetAngularVelocity, "ItemSetAngularVelocity", _SC(".xx"));
|
|
|
|
/*#
|
|
Func: ItemGetPhysicMode
|
|
Proto: PhysicMode:Item
|
|
Desc: Get the current item physic mode.
|
|
#*/
|
|
sq_register(vm, ItemGetPhysicMode, "ItemGetPhysicMode", _SC(".x"));
|
|
/*#
|
|
Func: ItemSetPhysicMode
|
|
Proto: void:Item,PhysicMode mode
|
|
Desc: Set item physic mode.
|
|
#*/
|
|
sq_register(vm, ItemSetPhysicMode, "ItemSetPhysicMode", _SC(".xi"));
|
|
/*#
|
|
Func: ItemCollided
|
|
Proto: bool:Item
|
|
Desc: Returns true if the item collided during the last physic step, false otherwise.
|
|
#*/
|
|
sq_register(vm, ItemCollided, "ItemCollided", _SC(".x"));
|
|
|
|
/*#
|
|
Func: ItemGetLinearAcceleration
|
|
Proto: Vector:Item
|
|
Desc: Get item linear acceleration (m.s²). Acceleration is the rate of change in speed over time.
|
|
#*/
|
|
sq_register(vm, ItemGetLinearAcceleration, "ItemGetLinearAcceleration", _SC(".x"));
|
|
/*#
|
|
Func: ItemGetMass
|
|
Proto: float:Item
|
|
Desc: Get item mass (in Kg).
|
|
#*/
|
|
sq_register(vm, ItemGetMass, "ItemGetMass", _SC(".x"));
|
|
/*#
|
|
Func: ItemGetCenterOfMass
|
|
Proto: Vector:Item
|
|
Desc: Get item center of mass position in item space.
|
|
#*/
|
|
sq_register(vm, ItemGetCenterOfMass, "ItemGetCenterOfMass", _SC(".x"));
|
|
/*#
|
|
Func: ItemGetLocalPointVelocity
|
|
Proto: Vector:Item
|
|
Desc: Get an item local point velocity (m.s) in world space.
|
|
#*/
|
|
sq_register(vm, ItemGetLocalPointVelocity, "ItemGetLocalPointVelocity", _SC(".x"));
|
|
/*#
|
|
Func: ItemGetWorldPointVelocity
|
|
Proto: Vector:Item
|
|
Desc: Get an item world point velocity (m.s) in world space.
|
|
#*/
|
|
sq_register(vm, ItemGetWorldPointVelocity, "ItemGetWorldPointVelocity", _SC(".x"));
|
|
/*#
|
|
Func: ItemGetLinearVelocity
|
|
Proto: Vector:Item
|
|
Desc: Get the item linear velocity (m.s). Velocity is the rate of change of position over time.
|
|
Note: The linear velocity only affects position, rotation is affected by the angular velocity.
|
|
See: ItemGetLinearAcceleration, ItemGetAngularVelocity
|
|
#*/
|
|
sq_register(vm, ItemGetLinearVelocity, "ItemGetLinearVelocity", _SC(".x"));
|
|
/*#
|
|
Func: ItemGetPreviousLinearVelocity
|
|
Proto: Vector:Item
|
|
Desc: Get item previous linear velocity (m.s).
|
|
#*/
|
|
sq_register(vm, ItemGetPreviousLinearVelocity, "ItemGetPreviousLinearVelocity", _SC(".x"));
|
|
/*#
|
|
Func: ItemSetLinearVelocity
|
|
Proto: void:Item,Vector linear_velocity
|
|
Desc: Set item linear velocity (m.s).
|
|
Note: This function sets the item linear velocity by bypassing the physics solver. This can lead to all sorts of problems depending on the scene configuration. You are advised to perform such change using an impulse instead.
|
|
See: ItemApplyLinearImpulse
|
|
#*/
|
|
sq_register(vm, ItemSetLinearVelocity, "ItemSetLinearVelocity", _SC(".xx"));
|
|
|
|
/*#
|
|
Func: ItemSetGravityScale
|
|
Proto: void:Item,float scale
|
|
Desc: Set item gravity scale (g = world_gravity * scale).
|
|
#*/
|
|
sq_register(vm, ItemSetGravityScale, "ItemSetGravityScale", _SC(".xn"));
|
|
/*#
|
|
Func: ItemSetGravity
|
|
Proto: void:Item,Vector g
|
|
Desc: Set item gravity (in m.s²).
|
|
Example: ItemSetGravity(item, Vector(0.0, -9.8, 0.0)) // Earth gravity.
|
|
#*/
|
|
sq_register(vm, ItemSetGravity, "ItemSetGravity", _SC(".xx"));
|
|
/*#
|
|
Func: ItemGetGravity
|
|
Proto: Vector:Item
|
|
Desc: Get item gravity (m.s²).
|
|
#*/
|
|
sq_register(vm, ItemGetGravity, "ItemGetGravity", _SC(".x"));
|
|
|
|
/*#
|
|
Func: ItemWorldPointVelocity
|
|
Proto: void:Item,Vector world_position
|
|
Desc: Compute the velocity of an item particle, particle position is in world space (in m.s).
|
|
#*/
|
|
sq_register(vm, ItemWorldPointVelocity, "ItemWorldPointVelocity", _SC(".xx"));
|
|
/*#
|
|
Func: ItemPointVelocity
|
|
Proto: void:Item,Vector local_position
|
|
Desc: Compute the velocity of an item particle, particle position is in item space (in m.s).
|
|
#*/
|
|
sq_register(vm, ItemPointVelocity, "ItemPointVelocity", _SC(".xx"));
|
|
|
|
/*#
|
|
Section: ItemPhysicHack
|
|
Desc: Physic hacking
|
|
#*/
|
|
/*#
|
|
Func: ItemGetPhysicPosition
|
|
Proto: Vector:Item
|
|
Desc: Get item physic position.
|
|
#*/
|
|
sq_register(vm, ItemGetPhysicPosition, "ItemGetPhysicPosition", _SC(".x"));
|
|
/*#
|
|
Func: ItemSetPhysicPosition
|
|
Proto: void:Item,Vector position
|
|
Desc: Set item physic position.
|
|
Note: Tampering with the internal physic state is likely to cause troubles, use with extreme care!
|
|
#*/
|
|
sq_register(vm, ItemSetPhysicPosition, "ItemSetPhysicPosition", _SC(".xx"));
|
|
/*#
|
|
Func: ItemGetPhysicPreviousPosition
|
|
Proto: Vector:Item
|
|
Desc: Get item physic previous position.
|
|
#*/
|
|
sq_register(vm, ItemGetPhysicPreviousPosition, "ItemGetPhysicPreviousPosition", _SC(".x"));
|
|
/*#
|
|
Func: ItemGetPhysicRotation
|
|
Proto: Vector:Item
|
|
Desc: Get item physic rotation.
|
|
#*/
|
|
sq_register(vm, ItemGetPhysicRotation, "ItemGetPhysicRotation", _SC(".x"));
|
|
/*#
|
|
Func: ItemSetPhysicRotation
|
|
Proto: void:Item,Vector euler
|
|
Desc: Set item physic rotation.
|
|
Note: Tampering with the internal physic state is likely to cause troubles, use with extreme care!
|
|
#*/
|
|
sq_register(vm, ItemSetPhysicRotation, "ItemSetPhysicRotation", _SC(".xx"));
|
|
/*#
|
|
Func: ItemPhysicSynchronizeCollision
|
|
Proto: void:Item
|
|
Desc: Synchronize the collision interface to the physic interface.
|
|
#*/
|
|
sq_register(vm, ItemPhysicSynchronizeCollision, "ItemPhysicSynchronizeCollision", _SC(".x"));
|
|
|
|
/*#
|
|
Section: ItemScript
|
|
Desc: Script
|
|
#*/
|
|
/*#
|
|
Func: ItemSetScript
|
|
Proto: void:Item,String file,String class
|
|
Desc: Set item script file and class to instantiate for the item first script unit.
|
|
#*/
|
|
sq_register(vm, ItemSetScript, "ItemSetScript", _SC(".xss"));
|
|
/*#
|
|
Func: ItemSetupScript
|
|
Proto: void:Item
|
|
Desc: Setup item script.
|
|
#*/
|
|
sq_register(vm, ItemSetupScript, "ItemSetupScript", _SC(".x"));
|
|
/*#
|
|
Func: ItemGetScriptInstance
|
|
Proto: instance:Item
|
|
Desc: Get an item script instance on its first script unit.
|
|
See: ItemGetScriptInstanceFromClass
|
|
|
|
Example:
|
|
local enemy_item = SceneFindItem(g_scene, "an_enemy")
|
|
local enemy = ItemGetScriptInstance(enemy_item)
|
|
|
|
// Instance can be used to call the script assigned to the item.
|
|
enemy->TakeHit(20)
|
|
#*/
|
|
sq_register(vm, ItemGetScriptInstance, "ItemGetScriptInstance", _SC(".x"));
|
|
/*#
|
|
Func: ItemGetScriptInstanceCount
|
|
Proto: int:Item
|
|
Desc: Get the number of script instance available on an item.
|
|
#*/
|
|
sq_register(vm, ItemGetScriptInstanceCount, "ItemGetScriptInstanceCount", _SC(".x"));
|
|
/*#
|
|
Func: ItemGetScriptInstanceFromIndex
|
|
Proto: instance:Item,int index
|
|
Desc: Get an item script instance from its index.
|
|
See: ItemGetScriptInstanceFromClass
|
|
#*/
|
|
sq_register(vm, ItemGetScriptInstanceFromIndex, "ItemGetScriptInstanceFromIndex", _SC(".xi"));
|
|
/*#
|
|
Func: ItemGetScriptInstanceFromClass
|
|
Proto: instance:Item,string class_name
|
|
Desc: Get an item script instance from the name of the class it instantiates.
|
|
|
|
Example:
|
|
local enemy_item = SceneFindItem(g_scene, "an_enemy")
|
|
local ai = ItemGetScriptInstanceFromClass(item, "AIComponent")
|
|
|
|
// Instance can be used to call the AIComponent instance assigned to the enemy item.
|
|
ai->Flee()
|
|
#*/
|
|
sq_register(vm, ItemGetScriptInstanceFromClass, "ItemGetScriptInstanceFromClass", _SC(".xs"));
|
|
#if 1
|
|
sq_register(vm, ItemSetPhysicPreviousPosition, "ItemSetPhysicPreviousPosition", _SC(".xx"));
|
|
#endif
|
|
/*#
|
|
Func: ItemHasScript
|
|
Proto: bool:Item,string class_name
|
|
Desc: Test if a specific script is assigned to an item. The script is identified by its class name.
|
|
|
|
Example:
|
|
// Will return true if this script is instantiated for this item.
|
|
local has_some_component = ItemHasScript(item, "AComponentClass")
|
|
#*/
|
|
sq_register(vm, ItemHasScript, "ItemHasScript", _SC(".xs"));
|
|
|
|
/*#
|
|
Section: ItemDebug
|
|
Desc: Debug
|
|
#*/
|
|
/*#
|
|
Func: ItemPrint
|
|
Proto: void:Item
|
|
Desc: Print item instance address in memory.
|
|
#*/
|
|
sq_register(vm, ItemPrint, "ItemPrint", _SC(".x"));
|
|
|
|
/*#
|
|
Enum: PhysicMode
|
|
Values: PhysicModeNone,PhysicModeStatic,PhysicModeDynamic,PhysicModeKinematic
|
|
#*/
|
|
sq_pushstring(vm, "PhysicModeNone", -1); sq_pushinteger(vm, PhysicItemDesc::Mode_None); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "PhysicModeStatic", -1); sq_pushinteger(vm, PhysicItemDesc::Mode_Static); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "PhysicModeDynamic", -1); sq_pushinteger(vm, PhysicItemDesc::Mode_Dynamic); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "PhysicModeKinematic", -1); sq_pushinteger(vm, PhysicItemDesc::Mode_Kinematic); sq_newslot(vm, -3, true);
|
|
|
|
#if 1
|
|
sq_pushstring(vm, "PhysicModeRigidBody", -1); sq_pushinteger(vm, PhysicItemDesc::Mode_Dynamic); sq_newslot(vm, -3, true);
|
|
|
|
sq_pushstring(vm, "OrientationEuler", -1); sq_pushinteger(vm, 0); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "OrientationMatrix", -1); sq_pushinteger(vm, 0); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "OrientationQuaternion", -1); sq_pushinteger(vm, 0); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "OrientationExternal", -1); sq_pushinteger(vm, 0); sq_newslot(vm, -3, true);
|
|
#endif
|
|
|
|
/*#
|
|
Enum: PhysicFlag
|
|
Values: PhysicFlagNone,PhysicFlagNoGravity,PhysicFlagNoForceField,PhysicFlagMobile,PhysicFlagGhost
|
|
#*/
|
|
sq_pushstring(vm, "PhysicFlagNone", -1); sq_pushinteger(vm, 0); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "PhysicFlagNoGravity", -1); sq_pushinteger(vm, 0); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "PhysicFlagNoForceField", -1); sq_pushinteger(vm, 0); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "PhysicFlagMobile", -1); sq_pushinteger(vm, 0); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "PhysicFlagGhost", -1); sq_pushinteger(vm, 0); sq_newslot(vm, -3, true);
|
|
|
|
/*#
|
|
Enum: RotationOrder
|
|
Values: RotationOrderDefault,RotationOrderZYX,RotationOrderYZX,RotationOrderZXY,RotationOrderXZY,RotationOrderYXZ,RotationOrderXYZ,RotationOrderXY
|
|
#*/
|
|
sq_pushstring(vm, "RotationOrderDefault", -1); sq_pushinteger(vm, Math::rOrder_Default); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "RotationOrderZYX", -1); sq_pushinteger(vm, Math::rOrder_ZYX); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "RotationOrderYZX", -1); sq_pushinteger(vm, Math::rOrder_YZX); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "RotationOrderZXY", -1); sq_pushinteger(vm, Math::rOrder_ZXY); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "RotationOrderXZY", -1); sq_pushinteger(vm, Math::rOrder_XZY); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "RotationOrderYXZ", -1); sq_pushinteger(vm, Math::rOrder_YXZ); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "RotationOrderXYZ", -1); sq_pushinteger(vm, Math::rOrder_XYZ); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "RotationOrderXY", -1); sq_pushinteger(vm, Math::rOrder_XY); sq_newslot(vm, -3, true);
|
|
|
|
/*#
|
|
Enum: ItemType
|
|
Values: ItemTypeNone,ItemTypeCamera,ItemTypeObject,ItemTypeLight,ItemTypeTrigger,ItemTypeEmitter,ItemTypeInstance
|
|
#*/
|
|
sq_pushstring(vm, "ItemTypeNone", -1); sq_pushinteger(vm, Type_None); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "ItemTypeCamera", -1); sq_pushinteger(vm, Type_Camera); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "ItemTypeObject", -1); sq_pushinteger(vm, Type_Object); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "ItemTypeLight", -1); sq_pushinteger(vm, Type_Light); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "ItemTypeTrigger", -1); sq_pushinteger(vm, Type_Trigger); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "ItemTypeEmitter", -1); sq_pushinteger(vm, Type_Emitter); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "ItemTypeInstance", -1); sq_pushinteger(vm, Type_Instance); sq_newslot(vm, -3, true);
|
|
|
|
/*#
|
|
Enum: ItemFlag
|
|
Values: ItemFlagNone,ItemFlagBillboard,ItemFlagSolveOverlap
|
|
#*/
|
|
sq_pushstring(vm, "ItemFlagNone", -1); sq_pushinteger(vm, MItem::Flag_None); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "ItemFlagBillboard", -1); sq_pushinteger(vm, MItem::Flag_Billboard); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "ItemFlagSolveOverlap", -1); sq_pushinteger(vm, MItem::Flag_SolveOverlap); sq_newslot(vm, -3, true);
|
|
|
|
sq_pushstring(vm, "NullGeometry", -1); CObject::Push(vm, NULL, typetag_Geometry); sq_newslot(vm, -3, true);
|
|
}
|
|
//------------------------------------------------------------------------------
|