1745 lines
51 KiB
C++
1745 lines
51 KiB
C++
/* -----------------------------------------------------------------------------
|
|
GSFramework
|
|
Copyright 2001-2013 Emmanuel Julien. All Rights Reserved.
|
|
----------------------------------------------------------------------------- */
|
|
|
|
|
|
#include "binding_helpers.h"
|
|
#include "scene3d/scene.h"
|
|
#include "scene3d/instance.h"
|
|
#include "scene3d/mlight.h"
|
|
#include "scene3d/mobject.h"
|
|
#include "scene3d/mcamera.h"
|
|
#include "scene3d/mtrigger.h"
|
|
#include "scene3d/mconstraint.h"
|
|
#include "scene3d/group.h"
|
|
#include "physic/physic_world.h"
|
|
#include "core/renderer.h"
|
|
#include "core/resource_factories.h"
|
|
#include "script/scripted_object.h"
|
|
#include "script/script_unit.h"
|
|
#include "metafile/nml_object.h"
|
|
#include "tools/scene_merge_object_list.h"
|
|
#include "core/cached_graphic_resource_factory.h"
|
|
|
|
using namespace GS;
|
|
using namespace GS::S3D;
|
|
using namespace GS::Script;
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
SQInteger GetSceneOrInstance(HSQUIRRELVM vm, int idx, Scene **scene, Instance **instance)
|
|
{
|
|
*scene = NULL;
|
|
*instance = NULL;
|
|
|
|
CObjectType type;
|
|
if (!CObject::GetType(vm, idx, type))
|
|
return sq_throwerror(vm, "Invalid object, expected scene or instance.");
|
|
|
|
switch (type)
|
|
{
|
|
case typetag_Scene3d:
|
|
CObject::Get(vm, idx, (void **)scene, typetag_Scene3d);
|
|
break;
|
|
|
|
case typetag_Item:
|
|
{
|
|
MItem *item;
|
|
CObject::Get(vm, idx, (void **)&item, typetag_Item);
|
|
|
|
if (item->GetItemType() != Type_Instance)
|
|
return sq_throwerror(vm, "Expected scene or instance.");
|
|
|
|
*instance = (Instance *)item;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
return sq_throwerror(vm, "Expected scene or instance.");
|
|
}
|
|
if (!*scene && !*instance)
|
|
return sq_throwerror(vm, "Scene/instance object is null.");
|
|
|
|
return 0;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
#define __SQ_GETSCENEORINSTANCE(__S, __I) \
|
|
Scene *__S; \
|
|
Instance *__I; \
|
|
if (GetSceneOrInstance(vm, __SQ_STACKPOS, &__S, &__I) == -1) \
|
|
return -1; \
|
|
__SQ_GETUPDATESTACK
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
SQInteger SceneGetGroupList(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(scene, Scene, typetag_Scene3d)
|
|
sq_newarray(vm, 0);
|
|
ListForeachPtr(Group *, g, scene->GetGroupList())
|
|
{
|
|
CObject::Push(vm, (void *)g, typetag_Group);
|
|
sq_arrayappend(vm, -2);
|
|
}
|
|
return 1;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
SQInteger SceneGroupActivate(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(3)
|
|
__SQ_GETSAFEPTR(s, Scene, typetag_Scene3d)
|
|
__SQ_GETSAFEPTR(g, Group, typetag_Group)
|
|
__SQ_GETBOOL(v)
|
|
__SQ_GETEND
|
|
s->GroupMembersSetActive(g, asbool(v));
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger SceneSetupItem(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(s, Scene, typetag_Scene3d)
|
|
__SQ_GETSAFEPTR(i, MItem, typetag_Item)
|
|
__SQ_GETEND
|
|
i->Setup(s->physic_world);
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger SceneForceUpdateMassShapePhysicItem(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(s, Scene, typetag_Scene3d)
|
|
__SQ_GETSAFEPTR(i, MItem, typetag_Item)
|
|
__SQ_GETEND
|
|
i->ForceUpdateMassShapePhysic(s->physic_world);
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger SceneRenderSetup(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(s, Scene, typetag_Scene3d)
|
|
__SQ_GETSAFEPTR(f, Core::ResourceFactories, typetag_ResourceFactories)
|
|
__SQ_GETEND
|
|
s->RenderSetup(f, false);
|
|
__SQ_RETURN
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
SQInteger SceneResetClock(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(s, Scene, typetag_Scene3d)
|
|
s->GetClock()->Reset();
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger SceneSetFixedDeltaFrame(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(s, Scene, typetag_Scene3d)
|
|
__SQ_GETFLOAT(scale)
|
|
__SQ_GETEND
|
|
s->GetClock()->SetFixedDeltaFramef(scale);
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger SceneSetClockScale(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(s, Scene, typetag_Scene3d)
|
|
__SQ_GETFLOAT(scale)
|
|
__SQ_GETEND
|
|
s->GetClock()->SetScalef(scale);
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger SceneGetClockScale(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(s, Scene, typetag_Scene3d)
|
|
__SQ_RETURNFLOAT(s->GetClock()->GetScalef())
|
|
}
|
|
SQInteger SceneGetClock(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(s, Scene, typetag_Scene3d)
|
|
__SQ_RETURNFLOAT(s->GetClock()->Getf())
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
/*
|
|
static void MergePhysicShape(MItem *to, MItem *from)
|
|
{
|
|
if (!from->physic_item)
|
|
return;
|
|
|
|
ListForeachPtr(nPhysicShape *, shape, from->physic_item->GetShapeList())
|
|
{
|
|
nPhysicShape *new_shape = to->physic_item->AddShape();
|
|
new_shape->SetMatrix(from->GetBaseItem()->GetMatrix() * shape->GetMatrix());
|
|
|
|
switch (shape->GetType())
|
|
{
|
|
case nPhysicShape::TypeBox:
|
|
case nPhysicShape::TypeCapsule:
|
|
case nPhysicShape::TypeCone:
|
|
case nPhysicShape::TypeSphere:
|
|
new_shape->Set(shape->GetType(), shape->dimensions);
|
|
break;
|
|
|
|
case nPhysicShape::TypeConvex:
|
|
case nPhysicShape::TypeMesh:
|
|
new_shape->Set(shape->GetType(), shape->path);
|
|
break;
|
|
}
|
|
}
|
|
|
|
to->physic_item->SetPhysicMode(from->physic_item->GetPhysicMode());
|
|
}
|
|
*/
|
|
SQInteger SceneSetMotion(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(3)
|
|
__SQ_GETSCENEORINSTANCE(scene, instance)
|
|
__SQ_GETSTRING(name)
|
|
__SQ_GETFLOAT(blend)
|
|
Automation::SourceGroup *group = NULL;
|
|
if (scene)
|
|
scene->SetMotion(name, &group, blend);
|
|
else instance->instance_group->SetMotion(name, &group, blend);
|
|
__SQ_GETEND
|
|
__SQ_RETURNMANAGEDSAFEPTR(group, typetag_AutomationSourceGroup)
|
|
}
|
|
|
|
SQInteger SceneSetMotionAdd(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(3)
|
|
__SQ_GETSCENEORINSTANCE(scene, instance)
|
|
__SQ_GETSTRING(name)
|
|
__SQ_GETFLOAT(blend)
|
|
Automation::SourceGroup *group = NULL;
|
|
if (scene)
|
|
scene->SetMotion(name, &group, blend, Automation::Player::SourceAdd);
|
|
else instance->instance_group->SetMotion(name, &group, blend, Automation::Player::SourceAdd);
|
|
__SQ_GETEND
|
|
__SQ_RETURNMANAGEDSAFEPTR(group, typetag_AutomationSourceGroup)
|
|
}
|
|
|
|
SQInteger SceneGetFileName(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(scene, Scene, typetag_Scene3d)
|
|
__SQ_RETURNSTRING(scene->name.CutFilePath().toUtf8())
|
|
}
|
|
SQInteger SceneGetFilePath(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(scene, Scene, typetag_Scene3d)
|
|
__SQ_RETURNSTRING(scene->name.CutFileName().toUtf8())
|
|
}
|
|
|
|
SQInteger SceneSetGlobal(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(scene, Scene, typetag_Scene3d)
|
|
scene->SetAsScriptGlobalScene(scene->GetVM());
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger SceneGetAmbientIntensity(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(scene, Scene, typetag_Scene3d)
|
|
__SQ_RETURNFLOAT(scene->ambient_intensity)
|
|
}
|
|
|
|
SQInteger SceneSetAmbientIntensity(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(scene, Scene, typetag_Scene3d)
|
|
__SQ_GETFLOAT(i)
|
|
__SQ_GETEND
|
|
scene->ambient_intensity = i;
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger SceneGetAmbientColor(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(scene, Scene, typetag_Scene3d)
|
|
__SQ_RETURNVECTOR(scene->ambient_color)
|
|
}
|
|
|
|
SQInteger SceneSetAmbientColor(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(scene, Scene, typetag_Scene3d)
|
|
__SQ_GETVECTORTO(scene->ambient_color, scene)
|
|
__SQ_GETEND
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger SceneGetBackgroundColor(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(scene, Scene, typetag_Scene3d)
|
|
__SQ_RETURNVECTOR(scene->background_color)
|
|
}
|
|
|
|
SQInteger SceneSetBackgroundColor(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(scene, Scene, typetag_Scene3d)
|
|
__SQ_GETVECTORTO(scene->background_color, scene)
|
|
__SQ_GETEND
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger SceneEnd(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(scene, Scene, typetag_Scene3d)
|
|
scene->flags.Set(Scene::FlagEnd);
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger SceneRaytraceTriggerList(HSQUIRRELVM vm)
|
|
{
|
|
Scene *scene;
|
|
if (!CObject::Get(vm, -4, (void **)&scene, typetag_Scene3d))
|
|
return -1;
|
|
|
|
Vector4 s, d;
|
|
GetVector(vm, -3, s);
|
|
GetVector(vm, -2, d);
|
|
|
|
float l;
|
|
sq_getfloat(vm, -1, &l);
|
|
sq_pop(vm, 4);
|
|
|
|
MItem *hit = NULL;
|
|
if (scene)
|
|
hit = (MItem *)scene->RaytraceTriggerList(s, d, l);
|
|
CObject::Push(vm, (void *)hit, typetag_Item);
|
|
return 1;
|
|
}
|
|
|
|
SQInteger ScenePhysicAllocateCollisionNode(HSQUIRRELVM vm)
|
|
{ __ERR__(__LOG__ << "ScenePhysicAllocateCollisionNode is obsolete.\n", 0)}
|
|
|
|
SQInteger ScenePhysicEnableDeactivation(HSQUIRRELVM vm)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
SQInteger SceneSetItemStatic(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(3)
|
|
__SQ_GETSAFEPTR(scene, Scene, typetag_Scene3d)
|
|
__SQ_GETSAFEPTR(item, MItem, typetag_Item)
|
|
__SQ_GETBOOL(v)
|
|
__SQ_GETEND
|
|
scene->SetItemStatic(item, asbool(v));
|
|
__SQ_RETURN
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
#define __SQ_GETSCENESCRIPTOBJECT(__SRC) GS::Script::ScriptedObject *scripted_object = __SRC->scripted_object; if (!scripted_object) return sq_throwerror(vm, "No script system in scene!");
|
|
|
|
SQInteger SceneGetScriptInstance(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(scene, Scene, typetag_Scene3d)
|
|
__SQ_GETSCENESCRIPTOBJECT(scene)
|
|
if (!scripted_object->GetUnitList().GetCount())
|
|
return sq_throwerror(vm, "No script unit");
|
|
Script::SquirrelObject *o = (Script::SquirrelObject *)scripted_object->GetUnitList()[0]->Self();
|
|
__SQ_RETURNOBJECT(o->object);
|
|
}
|
|
SQInteger SceneGetScriptInstanceFromClass(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(scene, Scene, typetag_Scene3d)
|
|
__SQ_GETSTRING(_class)
|
|
__SQ_GETSCENESCRIPTOBJECT(scene)
|
|
|
|
Script::Unit *_unit = 0;
|
|
ListForeachPtr(Script::Unit *, unit, scripted_object->GetUnitList())
|
|
if (unit->script_class == _class)
|
|
{
|
|
_unit = unit;
|
|
break;
|
|
}
|
|
|
|
__SQ_GETEND
|
|
|
|
if (_unit)
|
|
{
|
|
if (!_unit->IsOpen())
|
|
return sq_throwerror(vm, "Script unit is not open");
|
|
|
|
__SQ_RETURNOBJECT(((Script::SquirrelObject *)_unit->Self())->object);
|
|
}
|
|
return sq_throwerror(vm, "Script unit not found");
|
|
}
|
|
SQInteger SceneSetScript(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(3)
|
|
__SQ_GETSAFEPTR(scene, Scene, typetag_Scene3d)
|
|
__SQ_GETSTRING(script_file)
|
|
__SQ_GETSTRING(script_class)
|
|
__SQ_GETSCENESCRIPTOBJECT(scene)
|
|
if (Script::Unit *unit = scripted_object->GetUnitList().GetCount() ? scripted_object->GetUnitList()[0] : scripted_object->AddUnit(scripted_object->NewUnit()))
|
|
{
|
|
unit->script_file = script_file;
|
|
unit->script_class = script_class;
|
|
}
|
|
__SQ_GETEND
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger SceneRemoveAllScripts(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(1)
|
|
__SQ_GETSAFEPTR(scene, Scene, typetag_Scene3d)
|
|
__SQ_GETSCENESCRIPTOBJECT(scene)
|
|
|
|
scripted_object->RemoveAllUnit();
|
|
|
|
__SQ_GETEND
|
|
__SQ_RETURN
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
SQInteger ScenePreloadResources(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(f, Core::ResourceFactories, typetag_ResourceFactories)
|
|
__SQ_GETSTRING(path)
|
|
bool r = Scene::PreloadResources(*f->render, path);
|
|
__SQ_GETEND
|
|
__SQ_RETURNBOOL(r)
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
SQInteger SceneFromNML(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(scene, Scene, typetag_Scene3d)
|
|
__SQ_GETSTRING(path)
|
|
Group *group = NULL;
|
|
if (!scene->FromMetaFileStoreGroup(path, &group))
|
|
return sq_throwerror(vm, "Failed to load scene.");
|
|
scene->InstanceSetup();
|
|
__SQ_GETEND
|
|
__SQ_RETURNSAFEPTR(group, typetag_Group)
|
|
}
|
|
SQInteger SceneFromNMLStoreGroup(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(3)
|
|
__SQ_GETSAFEPTR(scene, Scene, typetag_Scene3d)
|
|
__SQ_GETSTRING(path)
|
|
__SQ_GETINT(flag)
|
|
Group *group = NULL;
|
|
if (!scene->FromMetaFileStoreGroup(path, &group, flag))
|
|
return sq_throwerror(vm, "Failed to load scene.");
|
|
scene->InstanceSetup();
|
|
__SQ_GETEND
|
|
__SQ_RETURNSAFEPTR(group, typetag_Group)
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
|
|
SQInteger SceneDeleteGroup(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(scene, Scene, typetag_Scene3d)
|
|
__SQ_GETSAFEPTR(group, Group, typetag_Group)
|
|
__SQ_GETEND
|
|
scene->DeleteGroupAndMembers(group);
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger SceneReset(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(scene, Scene, typetag_Scene3d)
|
|
scene->Reset();
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger SceneSetPhysicContactSolverIteration(HSQUIRRELVM vm)
|
|
{ return 0; }
|
|
|
|
SQInteger SceneSetPhysicConstraintSolverIteration(HSQUIRRELVM vm)
|
|
{ return 0; }
|
|
|
|
SQInteger SceneRecordLocation(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(scene, Scene, typetag_Scene3d)
|
|
scene->RecordAllItemLocation();
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger SceneGetPhysicFrequency(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(scene, Scene, typetag_Scene3d)
|
|
__SQ_RETURNFLOAT(scene->physic_world ? 1.f / scene->physic_world->GetTimestep() : 0.f)
|
|
}
|
|
|
|
SQInteger SceneSetPhysicFrequency(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(scene, Scene, typetag_Scene3d)
|
|
__SQ_GETFLOAT(timestep)
|
|
__SQ_GETEND
|
|
if (scene->physic_world)
|
|
scene->physic_world->SetTimestep(1.f / timestep);
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger SceneSetGravity(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(scene, Scene, typetag_Scene3d)
|
|
__SQ_GETVECTOR(g)
|
|
__SQ_GETEND
|
|
if (scene->physic_world)
|
|
scene->physic_world->SetGravity(g);
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger SceneSave(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(scene, Scene, typetag_Scene3d)
|
|
__SQ_GETSTRING(path)
|
|
bool r = NML::SaveToFile(*scene, path);
|
|
__SQ_GETEND
|
|
__SQ_RETURNBOOL(r)
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
SQInteger SceneFindConstraint(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSCENEORINSTANCE(scene, instance)
|
|
__SQ_GETSTRING(name)
|
|
__SQ_GETEND
|
|
MConstraint *c = scene->FindItemByType <MConstraint> (name);
|
|
if (!c)
|
|
return sq_throwerror(vm, String::Format("Constraint '%s' not found.", name));
|
|
__SQ_RETURNSAFEPTR(c, typetag_Constraint)
|
|
}
|
|
SQInteger SceneFindGroup(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSCENEORINSTANCE(scene, instance)
|
|
__SQ_GETSTRING(name)
|
|
Group *group = scene ? scene->FindGroup(name) : instance->instance_group->GetGroup(name);
|
|
if (!group)
|
|
return sq_throwerror(vm, String::Format("Group '%s' not found.", name));
|
|
__SQ_GETEND
|
|
__SQ_RETURNSAFEPTR(group, typetag_Group)
|
|
}
|
|
SQInteger SceneFindItem(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSCENEORINSTANCE(scene, instance)
|
|
__SQ_GETSTRING(name)
|
|
MItem *item = scene ? scene->Item(name) : instance->instance_group->Item(name);
|
|
if (!item)
|
|
return sq_throwerror(vm, String::Format("Item '%s' not found.", name));
|
|
__SQ_GETEND
|
|
__SQ_RETURNSAFEPTR(item, typetag_Item)
|
|
}
|
|
SQInteger SceneFindItemChild(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(3)
|
|
__SQ_GETSCENEORINSTANCE(scene, instance)
|
|
__SQ_GETSAFEPTR(item, MItem, typetag_Item)
|
|
__SQ_GETSTRING(name)
|
|
MItem *child = scene ? scene->Item(name, item) : NULL;
|
|
if (!child)
|
|
return sq_throwerror(vm, String::Format("Child item '%s' not found", name));
|
|
__SQ_GETEND
|
|
__SQ_RETURNSAFEPTR(child, typetag_Item)
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
SQInteger SceneDeleteContent(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(scene, Scene, typetag_Scene3d)
|
|
scene->Clear(true);
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger SceneFlushDeletionQueue(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(scene, Scene, typetag_Scene3d)
|
|
scene->ProcessItemRemovalQueue();
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger SceneSetRenderless(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(scene, Scene, typetag_Scene3d)
|
|
__SQ_GETBOOL(v)
|
|
__SQ_GETEND
|
|
scene->flags.Raise(Scene::FlagRenderless, asbool(v));
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger ScenePushRenderable(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(scene, Scene, typetag_Scene3d)
|
|
__SQ_GETSAFEPTR(renderer, Renderer, typetag_Renderer)
|
|
__SQ_GETEND
|
|
scene->PushRenderable(*renderer);
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger SceneRenderUI(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(scene, Scene, typetag_Scene3d)
|
|
__SQ_GETSAFEPTR(renderer, Renderer, typetag_Renderer)
|
|
__SQ_GETEND
|
|
scene->RenderUI(*renderer);
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger SceneUpdate(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(scene, Scene, typetag_Scene3d)
|
|
scene->Update();
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger SceneRegisterAsPropertyCallback(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(scene, Scene, typetag_Scene3d)
|
|
__SQ_GETSAFEPTR(renderer, Renderer, typetag_Renderer)
|
|
__SQ_GETEND
|
|
renderer->SetEnvironmentInterface(scene->irenderer_environment);
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger ScenePrintItemList(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(scene, Scene, typetag_Scene3d)
|
|
scene->DumpContentToLog();
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger SceneAddObject(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(scene, Scene, typetag_Scene3d)
|
|
__SQ_GETSTRING(name)
|
|
MObject *o = new MObject;
|
|
if (!o)
|
|
return sq_throwerror(vm, String::Format("Failed to allocate object '%s'.", name));
|
|
o->name = name;
|
|
scene->AddItem(o, true);
|
|
o->Setup(scene->physic_world);
|
|
o->Reset();
|
|
__SQ_GETEND
|
|
__SQ_RETURNSAFEPTR(o, typetag_Object);
|
|
}
|
|
|
|
SQInteger SceneDeleteObject(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(scene, Scene, typetag_Scene3d)
|
|
__SQ_GETSAFEPTR(object, MObject, typetag_Object)
|
|
__SQ_GETEND
|
|
scene->QueueItemRemoval(object);
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger SceneAddTrigger(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(scene, Scene, typetag_Scene3d)
|
|
__SQ_GETSTRING(name)
|
|
MTrigger *t = new MTrigger;
|
|
if (!t)
|
|
return sq_throwerror(vm, String::Format("Failed to allocate trigger '%s'.", name));
|
|
t->name = name;
|
|
scene->AddItem(t, true);
|
|
t->Setup(scene->physic_world);
|
|
t->Reset();
|
|
__SQ_GETEND
|
|
__SQ_RETURNSAFEPTR(t, typetag_Trigger);
|
|
}
|
|
|
|
SQInteger SceneDeleteTrigger(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(scene, Scene, typetag_Scene3d)
|
|
__SQ_GETSAFEPTR(trigger, MTrigger, typetag_Trigger)
|
|
__SQ_GETEND
|
|
scene->QueueItemRemoval(trigger);
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger SceneAddCamera(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(scene, Scene, typetag_Scene3d)
|
|
__SQ_GETSTRING(name)
|
|
MCamera *c = new MCamera;
|
|
if (!c)
|
|
return sq_throwerror(vm, String::Format("Failed to allocate camera '%s'.", name));
|
|
c->name = name;
|
|
scene->AddItem(c, true);
|
|
c->Setup(scene->physic_world);
|
|
c->Reset();
|
|
__SQ_GETEND
|
|
__SQ_RETURNSAFEPTR(c, typetag_Camera);
|
|
}
|
|
|
|
SQInteger SceneGetCurrentCamera(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(scene, Scene, typetag_Scene3d)
|
|
__SQ_RETURNSAFEPTR((MCamera *)scene->current_camera, typetag_Camera)
|
|
}
|
|
SQInteger SceneSetCurrentCamera(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(scene, Scene, typetag_Scene3d)
|
|
__SQ_GETSAFEPTR(camera, MCamera, typetag_Camera)
|
|
__SQ_GETEND
|
|
scene->current_camera = camera;
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger SceneAddLight(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(scene, Scene, typetag_Scene3d)
|
|
__SQ_GETSTRING(name)
|
|
MLight *l = new MLight;
|
|
if (!l)
|
|
return sq_throwerror(vm, String::Format("Failed to create light '%s'.", name));
|
|
l->name = name;
|
|
scene->AddItem(l, true);
|
|
l->Setup(scene->physic_world);
|
|
l->Reset();
|
|
__SQ_GETEND
|
|
__SQ_RETURNSAFEPTR(l, typetag_Light);
|
|
}
|
|
|
|
SQInteger SceneDuplicateItem(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(scene, Scene, typetag_Scene3d)
|
|
__SQ_GETSAFEPTR(item, MItem, typetag_Item)
|
|
__SQ_GETEND
|
|
__SQ_RETURNSAFEPTR(scene && item ? scene->DuplicateItem(item) : NULL, typetag_Item)
|
|
}
|
|
|
|
SQInteger SceneMergeItems(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(5)
|
|
__SQ_GETSAFEPTR(scene, Scene, typetag_Scene3d)
|
|
__SQ_GETSTRING(name)
|
|
__SQ_GETSAFEPTR(f, Core::ResourceFactories, typetag_ResourceFactories)
|
|
__SQ_GETINT(nb_item)
|
|
|
|
if (nb_item > 0)
|
|
{
|
|
SharedList <MItem *> merge_list;
|
|
|
|
// get the list of item
|
|
sq_pushnull(vm);//null iterator
|
|
for(int i=0; i<nb_item; ++i)
|
|
{
|
|
sq_next(vm, __SQ_STACKPOS-1 );
|
|
MItem *itemA; if (!GS::Script::CObject::Get(vm, __sq_stackpos, (void **)&itemA, typetag_Item)) return -1; if (!itemA) return sq_throwerror(vm, "Object is null");
|
|
|
|
merge_list.Add(itemA);
|
|
sq_pop(vm,2);
|
|
}
|
|
sq_pop(vm,1); //pops the null iterator
|
|
|
|
__SQ_GETEND
|
|
|
|
sMItem out_i;
|
|
|
|
if(scene)
|
|
{
|
|
SceneMergeObjectList merge_tool;
|
|
Core::sGeometry out_g;
|
|
|
|
merge_tool.Merge(scene, merge_list, *f->graphic, out_i, out_g);
|
|
|
|
if(out_g.IsValid())
|
|
{
|
|
// Save merged geometry to disk.
|
|
String merged_name(scene->name.CutFileName()+name+String(".nmg"));
|
|
NML::SaveToFile(*out_g, merged_name);
|
|
|
|
// Set geometry and setup merged object.
|
|
if (MObject *object = (MObject *)out_i.c_ptr())
|
|
{
|
|
object->geometry = merged_name;
|
|
object->name = name;
|
|
object->RenderSetup(f);
|
|
__SQ_RETURNSAFEPTR(out_i.c_ptr(), typetag_Item)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
__SQ_RETURNSAFEPTR(NULL, typetag_Item)
|
|
}
|
|
|
|
SQInteger SceneGetItemList(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(1)
|
|
__SQ_GETSCENEORINSTANCE(scene, instance)
|
|
__SQ_GETEND
|
|
|
|
const SharedList <MItem *> *list = NULL;
|
|
if (scene)
|
|
list = &scene->GetItemList();
|
|
else
|
|
list = &instance->instance_group->GetItemList();
|
|
|
|
sq_newarray(vm, 0);
|
|
ListForeachPtr(MItem *, i, *list)
|
|
{
|
|
// Skip items with no base item (e.g. const raints): they are not
|
|
// positionable, and exposing them as typetag_Item makes scripts crash
|
|
// when calling ItemGetWorldPosition/GetMatrix (MConstraint::GetBaseItem
|
|
// returns NULL -> null Item::GetMatrix() -> access violation -> paf memory error).
|
|
if (!i->GetBaseItem())
|
|
continue;
|
|
|
|
CObject::Push(vm, (void *)i, typetag_Item);
|
|
sq_arrayappend(vm, -2);
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
SQInteger SceneGetItemChildrenList(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(scene, Scene, typetag_Scene3d)
|
|
__SQ_GETSAFEPTR(item, MItem, typetag_Item)
|
|
__SQ_GETEND
|
|
|
|
sq_newarray(vm, 0);
|
|
if (scene)
|
|
ListForeachPtr(MItem *, i, scene->GetItemList())
|
|
if (i->GetBaseItem()->GetParent() == item->GetBaseItem())
|
|
{
|
|
CObject::Push(vm, (void *)i, typetag_Item);
|
|
sq_arrayappend(vm, -2);
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
SQInteger SceneDeleteItem(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(scene, Scene, typetag_Scene3d)
|
|
__SQ_GETSAFEPTR(item, MItem, typetag_Item)
|
|
__SQ_GETEND
|
|
scene->QueueItemRemoval(item);
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger SceneDeleteLight(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(scene, Scene, typetag_Scene3d)
|
|
__SQ_GETSTRING(name)
|
|
scene->QueueItemRemoval(scene->FindItemByType <MLight> (name));
|
|
__SQ_GETEND
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger SceneDeleteAllLights(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(scene, Scene, typetag_Scene3d)
|
|
ListForeachPtr(MItem *, i, scene->GetItemList())
|
|
if (i->GetItemType() == Type_Light)
|
|
scene->QueueItemRemoval(i);
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger ItemSetActive(HSQUIRRELVM vm) {
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(item, MItem, typetag_Item)
|
|
__SQ_GETBOOL(active)
|
|
__SQ_GETEND
|
|
item->mitem_flags.Raise(MItem::Flag_IsActive, active);
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger SceneCollisionRaytrace(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(6)
|
|
__SQ_GETSAFEPTR(scene, Scene, typetag_Scene3d)
|
|
__SQ_GETVECTOR(from)
|
|
__SQ_GETVECTOR(direction)
|
|
__SQ_GETINT(mask)
|
|
__SQ_GETINT(shape_mask)
|
|
__SQ_GETFLOAT(max_distance)
|
|
__SQ_GETEND
|
|
|
|
if (!scene->physic_world)
|
|
return sq_throwerror(vm, "No collision system in scene.");
|
|
|
|
PhysicTrace result;
|
|
bool hit = scene && scene->physic_world->Raytrace(from, direction, result, mask, shape_mask, max_distance);
|
|
|
|
sq_newtable(vm);
|
|
|
|
sq_pushstring(vm, "hit", 3);
|
|
sq_pushbool(vm, hit);
|
|
sq_newslot(vm, -3, false);
|
|
|
|
if (hit)
|
|
{
|
|
sq_pushstring(vm, "shape", 5);
|
|
CObject::Push(vm, (void *)result.s, typetag_ColShape);
|
|
sq_newslot(vm, -3, false);
|
|
|
|
sq_pushstring(vm, "item", 4);
|
|
CObject::Push(vm, (void *)((MItem *)result.i->GetUserPointer()), typetag_Item);
|
|
sq_newslot(vm, -3, false);
|
|
|
|
sq_pushstring(vm, "material", 8);
|
|
sq_pushstring(vm, result.m, result.m.Len());
|
|
sq_newslot(vm, -3, false);
|
|
|
|
sq_pushstring(vm, "p", 1);
|
|
PushVector(vm, result.p);
|
|
sq_newslot(vm, -3, false);
|
|
|
|
sq_pushstring(vm, "n", 1);
|
|
PushVector(vm, result.n);
|
|
sq_newslot(vm, -3, false);
|
|
|
|
sq_pushstring(vm, "d", 1);
|
|
sq_pushfloat(vm, Vector4::Dist(from, result.p));
|
|
sq_newslot(vm, -3, false);
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
SQInteger SceneSetFog(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(5)
|
|
__SQ_GETSAFEPTR(scene, Scene, typetag_Scene3d)
|
|
__SQ_GETBOOL(enable)
|
|
__SQ_GETCOLOR(color)
|
|
__SQ_GETFLOAT(n)
|
|
__SQ_GETFLOAT(f)
|
|
__SQ_GETEND
|
|
scene->fog_color = color;
|
|
scene->fog_near = enable ? n : 0;
|
|
scene->fog_far = enable ? f : 0;
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger SceneGetTimeOfDay(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(scene, Scene, typetag_Scene3d)
|
|
__SQ_RETURNFLOAT(scene->time_of_day)
|
|
}
|
|
SQInteger SceneSetTimeOfDay(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(scene, Scene, typetag_Scene3d)
|
|
__SQ_GETFLOAT(t)
|
|
__SQ_GETEND
|
|
scene->time_of_day = t;
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger SceneSetFlagDebugPhysic(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(scene, Scene, typetag_Scene3d)
|
|
__SQ_GETBOOL(enable)
|
|
__SQ_GETEND
|
|
scene->flags.Raise(GS::S3D::Scene::FlagDebugPhysics, enable);
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger SceneSetSkyShader(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(scene, Scene, typetag_Scene3d)
|
|
__SQ_GETSTRING(s)
|
|
__SQ_GETEND
|
|
scene->skybox_shader = s;
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger SceneSetSkyLayer(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(3)
|
|
__SQ_GETSAFEPTR(scene, Scene, typetag_Scene3d)
|
|
__SQ_GETSTRING(s)
|
|
__SQ_GETINT(n)
|
|
__SQ_GETEND
|
|
if ((n < 0) || (n > 1))
|
|
return sq_throwerror(vm, "Invalid sky layer index.");
|
|
scene->skybox_layer[n] = s;
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger SceneGetFogColor(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(scene, Scene, typetag_Scene3d)
|
|
__SQ_RETURNCOLOR(scene->fog_color)
|
|
}
|
|
|
|
SQInteger SceneGetFogNear(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(scene, Scene, typetag_Scene3d)
|
|
__SQ_RETURNFLOAT(scene->fog_near)
|
|
}
|
|
|
|
SQInteger SceneGetFogFar(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(scene, Scene, typetag_Scene3d)
|
|
__SQ_RETURNFLOAT(scene->fog_far)
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
SQInteger SceneItemActivate(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(3)
|
|
__SQ_GETSAFEPTR(scene, Scene, typetag_Scene3d)
|
|
__SQ_GETSAFEPTR(item, MItem, typetag_Item)
|
|
__SQ_GETBOOL(active)
|
|
__SQ_GETEND
|
|
scene->QueueItemActivation(item, asbool(active));
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger SceneItemActivateHierarchy(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(3)
|
|
__SQ_GETSAFEPTR(scene, Scene, typetag_Scene3d)
|
|
__SQ_GETSAFEPTR(item, MItem, typetag_Item)
|
|
__SQ_GETBOOL(active)
|
|
__SQ_GETEND
|
|
scene->QueueItemActivation(item, asbool(active), true);
|
|
__SQ_RETURN
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
SQInteger SceneProcessItemActivationQueue(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(1)
|
|
__SQ_GETSAFEPTR(scene, Scene, typetag_Scene3d)
|
|
__SQ_GETEND
|
|
scene->ProcessItemActivationQueue();
|
|
__SQ_RETURN
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//----------------------------------------------h,v
|
|
void RegisterSceneBinding(HSQUIRRELVM vm)
|
|
//----------------------------------------------
|
|
{
|
|
/*#
|
|
Topic: Scene
|
|
Related: Camera,Object,Light,Trigger,Item
|
|
Type: Scene
|
|
Type: Record
|
|
#*/
|
|
|
|
/*#
|
|
Section: SceneClock
|
|
Desc: Clock
|
|
#*/
|
|
/*#
|
|
Func: SceneResetClock
|
|
Proto: void:Scene
|
|
Desc: Reset engine clock. This function can be used to prevent the engine from taking a large clock step after a long script operation has been run.
|
|
Example:
|
|
function LoadLevelBlock(level_scene, block_path)
|
|
{
|
|
// Import the level block scene into the level_scene.
|
|
SceneLoad(level_scene, block_path)
|
|
|
|
// The load operation is known to take some time,
|
|
// so in order to prevent clock-dependent components
|
|
// from going nuts, we reset the level scene clock.
|
|
SceneResetClock(level_scene)
|
|
}
|
|
#*/
|
|
sq_register(vm, SceneResetClock, "SceneResetClock", _SC(".x"));
|
|
/*#
|
|
Func: SceneSetClockScale
|
|
Proto: void:Scene,float
|
|
Desc: Set engine clock scale. All clock dependent components in the engine are affected by this scale.
|
|
#*/
|
|
sq_register(vm, SceneSetClockScale, "SceneSetClockScale", _SC(".xn"));
|
|
/*#
|
|
Func: SceneGetClockScale
|
|
Proto: float:Scene
|
|
Desc: Get engine clock scale.
|
|
#*/
|
|
sq_register(vm, SceneGetClockScale, "SceneGetClockScale", _SC(".x"));
|
|
/*#
|
|
Func: SceneSetFixedDeltaFrame
|
|
Proto: void:Scene,float
|
|
Desc: Force a constant fixed delta frame value. Note: All clock dependent components will become frame rate dependent.
|
|
Example: SceneSetFixedDeltaFrame(scene, 1.0 / 60.0) // Lock dt_clock to 60 frame per second (1/60th between 2 frames).
|
|
#*/
|
|
sq_register(vm, SceneSetFixedDeltaFrame, "SceneSetFixedDeltaFrame", _SC(".xn"));
|
|
|
|
/*#
|
|
Section: SceneMotion
|
|
Desc: Motion
|
|
#*/
|
|
/*#
|
|
Func: SceneSetMotion
|
|
Proto: AnimationSourceGroup:Scene,string name,float blend
|
|
Desc: Set motion on all scene items, specify the blend duration, stop all current animation sources.
|
|
#*/
|
|
sq_register(vm, SceneSetMotion, "SceneSetMotion", _SC(".xsn"));
|
|
/*#
|
|
Func: SceneSetMotionAdd
|
|
Proto: AnimationSourceGroup:Scene,string name,float blend
|
|
Desc: Set motion on all scene items, specify the blend duration, current sources are not stopped.
|
|
#*/
|
|
sq_register(vm, SceneSetMotionAdd, "SceneSetMotionAdd", _SC(".xsn"));
|
|
|
|
/*#
|
|
Section: SceneIO
|
|
Desc: I/O
|
|
#*/
|
|
/*#
|
|
Func: ScenePreloadResources
|
|
Proto: bool:String path, RenderResourceFactory factory
|
|
Desc: Load all scene resources and their dependencies.<br>
|
|
As long as the render factory cache is not explicitly emptied, all subsequent load requests will return a cached resource instance.
|
|
This function can be used to implement streaming by preloading scene instance resources and instantiating/deinstantiating level <em>blocks</em> on the fly without requiring a complete load.
|
|
|
|
Example:
|
|
if (ScenePreloadResources("level/block_dark_street.nms", g_factory))
|
|
print("Dark street resources loaded.");
|
|
#*/
|
|
sq_register(vm, ScenePreloadResources, "ScenePreloadResources", _SC(".xs"));
|
|
/*#
|
|
Func: SceneLoad
|
|
Proto: bool:Scene,string
|
|
Desc: Append a scene to this scene, returns true on success, false otherwise.
|
|
See: SceneLoadAndStoreGroup
|
|
#*/
|
|
sq_register(vm, SceneFromNML, "SceneLoad", _SC(".xs"));
|
|
sq_register(vm, SceneFromNML, "SceneFromFile", _SC(".xs"));
|
|
sq_register(vm, SceneFromNML, "SceneFromNML", _SC(".xs"));
|
|
/*#
|
|
Func: SceneLoadAndStoreGroup
|
|
Proto: Group:Scene scene_to_import_to,string path,ImportFlag import_flag
|
|
Desc: Append a scene to this scene, store all appended content (item, light, group, etc...) in a group.
|
|
|
|
Example:
|
|
class LevelScene
|
|
{
|
|
diablo_ai = 0
|
|
diablo_fist = 0
|
|
|
|
function OnSetup(scene)
|
|
{
|
|
// Import the Diablo AI character into this scene.
|
|
diablo_ai = SceneLoadAndStoreGroup(scene, "enemy/ai/diablo.nms")
|
|
|
|
// Grab item 'fist' from this specific copy of the Diablo scene.
|
|
diablo_fist = GroupFindItem(diablo_ai, "fist")
|
|
}
|
|
}
|
|
#*/
|
|
sq_register(vm, SceneFromNMLStoreGroup, "SceneLoadAndStoreGroup", _SC(".xsi"));
|
|
sq_register(vm, SceneFromNMLStoreGroup, "SceneFromFileStoreGroup", _SC(".xsi"));
|
|
sq_register(vm, SceneFromNMLStoreGroup, "SceneFromNMLStoreGroup", _SC(".xsi"));
|
|
/*#
|
|
Func: SceneSave
|
|
Proto: bool:Scene,string
|
|
Desc: Save scene content to file. Returns true on success, false otherwise.<br>
|
|
The created scene can be directly opened in the editor provided that it has been saved in the same directory as the source scene. If not, resource path remapping will be required.
|
|
#*/
|
|
sq_register(vm, SceneSave, "SceneSave", _SC(".xs"));
|
|
|
|
/*#
|
|
Section: SceneManagement
|
|
Desc: Management
|
|
#*/
|
|
/*#
|
|
Func: SceneRenderSetup
|
|
Proto: void:Scene,ResourceFactory
|
|
Desc: Setup all scene render resources.
|
|
#*/
|
|
sq_register(vm, SceneRenderSetup, "SceneRenderSetup", _SC(".xx"));
|
|
/*#
|
|
Func: SceneDeleteItem
|
|
Proto: void:Scene,item
|
|
Desc: Delete an item from scene.
|
|
#*/
|
|
sq_register(vm, SceneDeleteItem, "SceneDeleteItem", _SC(".xx"));
|
|
/*#
|
|
Func: SceneEnd
|
|
Proto: void:Scene
|
|
Desc: Signal scene end. Calling this function when executing or previewing a scene will exit the viewer.
|
|
See: ProjectEnd
|
|
#*/
|
|
sq_register(vm, SceneEnd, "SceneEnd", _SC(".x"));
|
|
/*#
|
|
Func: SceneSetGlobal
|
|
Proto: void:Scene
|
|
Desc: Assign a scene to the script VM global variable g_scene. The engine does this automatically before calling scene and item callbacks.
|
|
#*/
|
|
sq_register(vm, SceneSetGlobal, "SceneSetGlobal", _SC(".x"));
|
|
|
|
/*#
|
|
Func: SceneGetScriptInstance
|
|
Proto: instance:Scene
|
|
Desc: Return the script instance for a scene. The scene first script unit instance is returned.
|
|
See: SceneGetScriptInstanceFromClass
|
|
|
|
Example:
|
|
local instance = SceneGetScriptInstance(g_scene)
|
|
|
|
// Instance can be used to call the script assigned to the scene.
|
|
instance->TurnLightOn()
|
|
#*/
|
|
sq_register(vm, SceneGetScriptInstance, "SceneGetScriptInstance", _SC(".x"));
|
|
/*#
|
|
Func: SceneGetScriptInstanceFromClass
|
|
Proto: Instance:Scene scene,string class_name
|
|
Desc: Return the script instance of a specific script for a scene.
|
|
|
|
Example:
|
|
// Get the scene script instance of class SceneLightManager.
|
|
local instance = SceneGetScriptInstanceFromClass(g_scene, "SceneLightManager")
|
|
|
|
// Instance can be used to call the SceneLightManager instance assigned to the scene.
|
|
instance->TurnLightOn()
|
|
#*/
|
|
sq_register(vm, SceneGetScriptInstanceFromClass, "SceneGetScriptInstanceFromClass", _SC(".xs"));
|
|
|
|
/*#
|
|
Func: SceneSetScript
|
|
Proto: void:Scene scene,string script_path,string script_class
|
|
Desc: Set the scene script file and class to instantiate on the scene script unit. Current script unit settings will be overwritten.
|
|
#*/
|
|
sq_register(vm, SceneSetScript, "SceneSetScript", _SC(".xss"));
|
|
/*#
|
|
Func: SceneRemoveAllScripts
|
|
Proto: void:Scene scene
|
|
Desc: remove all scripts from this scene.
|
|
#*/
|
|
sq_register(vm, SceneRemoveAllScripts, "SceneRemoveAllScripts", _SC(".x"));
|
|
|
|
/*#
|
|
Func: SceneGetFileName
|
|
Proto: String:Scene
|
|
Desc: Return the scene file name, without the path.
|
|
See: SceneGetFilePath
|
|
#*/
|
|
sq_register(vm, SceneGetFileName, "SceneGetFileName", _SC(".x"));
|
|
/*#
|
|
Func: SceneGetFilePath
|
|
Proto: String:Scene
|
|
Desc: Return the scene file path.
|
|
See: SceneGetFileName
|
|
#*/
|
|
sq_register(vm, SceneGetFilePath, "SceneGetFilePath", _SC(".x"));
|
|
/*#
|
|
Func: SceneReset
|
|
Proto: void:Scene
|
|
Desc: Reset a scene object. Note: All items are move back to their default transformation if recorded.
|
|
See: SceneRecordLocation
|
|
#*/
|
|
sq_register(vm, SceneReset, "SceneReset", _SC(".x"));
|
|
/*#
|
|
Func: SceneUpdate
|
|
Proto: void:Scene
|
|
Desc: Update scene, run all logic, physic and call script callbacks.
|
|
#*/
|
|
sq_register(vm, SceneUpdate, "SceneUpdate", _SC(".x"));
|
|
/*#
|
|
Func: SceneSetRenderless
|
|
Proto: void:Scene,bool
|
|
Desc: Controls automatic rendering of the scene. If a scene is renderless it is up to the user to implement its rendering code.
|
|
See: ScenePushRenderable, RendererRenderQueue, RendererRenderQueueReset, SceneRegisterAsPropertyCallback
|
|
|
|
Example:
|
|
class RenderLessScene
|
|
{
|
|
function OnSetup(scene)
|
|
{
|
|
// Set the scene to be renderless.
|
|
SceneSetRenderless(scene, true)
|
|
}
|
|
|
|
function OnRender(scene)
|
|
{
|
|
// Register the scene as the renderer property provider.
|
|
// Such properties as: ambient color, skybox and light rig are passed through this provider.
|
|
SceneRegisterAsPropertyCallback(scene, g_render)
|
|
|
|
// Push scene renderable to the renderer.
|
|
ScenePushRenderable(scene, g_render)
|
|
|
|
// Render renderable.
|
|
RendererRenderQueue(g_render)
|
|
|
|
// Reset renderable so that it does not get drawn by the next render call.
|
|
RendererRenderQueueReset(g_render)
|
|
}
|
|
}
|
|
#*/
|
|
sq_register(vm, SceneSetRenderless, "SceneSetRenderless", _SC(".xb"));
|
|
/*#
|
|
Func: ScenePushRenderable
|
|
Proto: void:Scene,Renderer
|
|
Desc: Push the scene renderable onto the renderer render queue.
|
|
#*/
|
|
sq_register(vm, ScenePushRenderable, "ScenePushRenderable", _SC(".xx"));
|
|
/*#
|
|
Func: SceneRenderUI
|
|
Proto: void:Scene,Renderer
|
|
Desc: Render the ui of the scene.
|
|
#*/
|
|
sq_register(vm, SceneRenderUI, "SceneRenderUI", _SC(".xx"));
|
|
|
|
/*#
|
|
Func: SceneRecordLocation
|
|
Proto: void:Scene
|
|
Desc: For each item, record the current transformation as the default transformation. The default transformation is used to move items to their original transformation when a scene reset is performed.
|
|
See: SceneReset
|
|
#*/
|
|
sq_register(vm, SceneRecordLocation, "SceneRecordLocation", _SC(".x"));
|
|
|
|
/*#
|
|
Func: SceneSetItemStatic
|
|
Proto: void:Scene,Item,bool
|
|
Desc: Flag item as static. The item will be stored in a spatial structure such as a quadtree with other static items to improve culling performance.
|
|
Note: If a static item is moved culling errors will happen.
|
|
#*/
|
|
sq_register(vm, SceneSetItemStatic, "SceneSetItemStatic", _SC(".xxb"));
|
|
|
|
/*#
|
|
Func: SceneDeleteContent
|
|
Proto: void:Scene
|
|
Desc: Delete all scene content.
|
|
#*/
|
|
sq_register(vm, SceneDeleteContent, "SceneDeleteContent", _SC(".x"));
|
|
/*#
|
|
Func: SceneFlushDeletionQueue
|
|
Proto: void:Scene
|
|
Desc: Immediately delete all items marked for deletion.
|
|
#*/
|
|
sq_register(vm, SceneFlushDeletionQueue, "SceneFlushDeletionQueue", _SC(".x"));
|
|
|
|
/*#
|
|
Func: SceneGetCurrentCamera
|
|
Proto: camera:scene
|
|
Desc: Get scene current camera.
|
|
#*/
|
|
sq_register(vm, SceneGetCurrentCamera, "SceneGetCurrentCamera", _SC(".x"));
|
|
/*#
|
|
Func: SceneSetCurrentCamera
|
|
Proto: void:scene,camera
|
|
Desc: Set camera as scene current camera.
|
|
#*/
|
|
sq_register(vm, SceneSetCurrentCamera, "SceneSetCurrentCamera", _SC(".xx"));
|
|
|
|
/*#
|
|
Func: SceneAddCamera
|
|
Proto: camera:scene,string name
|
|
Desc: Create a new camera.
|
|
#*/
|
|
sq_register(vm, SceneAddCamera, "SceneAddCamera", _SC(".xs"));
|
|
/*#
|
|
Func: SceneAddLight
|
|
Proto: Light:Scene,string name
|
|
Desc: Add a new light to scene.
|
|
#*/
|
|
sq_register(vm, SceneAddLight, "SceneAddLight", _SC(".xs"));
|
|
/*#
|
|
Func: SceneDeleteLight
|
|
Proto: void:Scene,Light
|
|
Desc: Delete light from scene.
|
|
#*/
|
|
sq_register(vm, SceneDeleteLight, "SceneDeleteLight", _SC(".xs"));
|
|
/*#
|
|
Func: SceneDeleteAllLights
|
|
Proto: void:Scene
|
|
Desc: Delete all lights from scene.
|
|
#*/
|
|
sq_register(vm, SceneDeleteAllLights, "SceneDeleteAllLights", _SC(".x"));
|
|
/*#
|
|
Func: SceneAddObject
|
|
Proto: Object:Scene,string name
|
|
Desc: Add a new object to scene.
|
|
#*/
|
|
sq_register(vm, SceneAddObject, "SceneAddObject", _SC(".xs"));
|
|
/*#
|
|
Func: SceneDeleteObject
|
|
Proto: void:Scene,Object
|
|
Desc: Delete object from scene.
|
|
#*/
|
|
sq_register(vm, SceneDeleteObject, "SceneDeleteObject", _SC(".xx"));
|
|
/*#
|
|
Func: SceneAddTrigger
|
|
Proto: Trigger:Scene,string name
|
|
Desc: Add a new trigger to scene.
|
|
#*/
|
|
sq_register(vm, SceneAddTrigger, "SceneAddTrigger", _SC(".xs"));
|
|
/*#
|
|
Func: SceneDeleteTrigger
|
|
Proto: void:Scene,Trigger
|
|
Desc: Delete trigger from scene.
|
|
#*/
|
|
sq_register(vm, SceneDeleteTrigger, "SceneDeleteTrigger", _SC(".xx"));
|
|
|
|
/*#
|
|
Func: SceneGetGroupList
|
|
Proto: array:Scene
|
|
Desc: Return an array containing all scene groups.
|
|
#*/
|
|
sq_register(vm, SceneGetGroupList, "SceneGetGroupList", _SC(".x"));
|
|
/*#
|
|
Func: SceneGroupActivate
|
|
Proto: void:Scene,Group,bool active
|
|
Desc: Set group member items active flag, effectively stops all physic, collision and display operations from happening on all group items.
|
|
#*/
|
|
sq_register(vm, SceneGroupActivate, "SceneGroupActivate", _SC(".xxb"));
|
|
/*#
|
|
Func: SceneItemActivate
|
|
Proto: void:Scene,Item,bool active
|
|
Desc: Set item active flag, when set to false this will stop all physic, collision and display operations from happening for this item.
|
|
#*/
|
|
sq_register(vm, SceneItemActivate, "SceneItemActivate", _SC(".xxb"));
|
|
/*#
|
|
Func: SceneItemActivateHierarchy
|
|
Proto: void:Scene,Item,bool active
|
|
Desc: Set item active flag on an item and its children recursively.
|
|
#*/
|
|
sq_register(vm, SceneItemActivateHierarchy, "SceneItemActivateHierarchy", _SC(".xxb"));
|
|
/*#
|
|
Func: SceneProcessItemActivationQueue
|
|
Proto: void:Scene
|
|
Desc: process the SceneProcessItemActivationQueue.
|
|
#*/
|
|
sq_register(vm, SceneProcessItemActivationQueue, "SceneProcessItemActivationQueue", _SC(".x"));
|
|
/*#
|
|
Func: ItemSetActive
|
|
Proto: void:Scene,Item,bool active
|
|
Desc: Set item active flag, when set to false this will stop all physic, collision and display operations from happening for this item.
|
|
#*/
|
|
sq_register(vm, ItemSetActive, "ItemSetActive", _SC(".xb"));
|
|
|
|
/*#
|
|
Section: SceneEnvironment
|
|
Desc: Environment
|
|
#*/
|
|
/*#
|
|
Func: SceneGetAmbientIntensity
|
|
Proto: float:Scene
|
|
Desc: Get the scene ambient intensity.
|
|
#*/
|
|
sq_register(vm, SceneGetAmbientIntensity, "SceneGetAmbientIntensity", _SC(".x"));
|
|
/*#
|
|
Func: SceneSetAmbientIntensity
|
|
Proto: void:Scene,float
|
|
Desc: Set the scene ambient intensity.
|
|
#*/
|
|
sq_register(vm, SceneSetAmbientIntensity, "SceneSetAmbientIntensity", _SC(".xn"));
|
|
/*#
|
|
Func: SceneGetAmbientColor
|
|
Proto: Vector:Scene
|
|
Desc: Get the scene ambient color.
|
|
#*/
|
|
sq_register(vm, SceneGetAmbientColor, "SceneGetAmbientColor", _SC(".x"));
|
|
/*#
|
|
Func: SceneSetAmbientColor
|
|
Proto: void:Scene,Vector
|
|
Desc: Set the scene ambient color.
|
|
Example: SceneSetAmbientColor(g_scene, Vector(1.0, 0.0, 0.0)) // Pure red ambient.
|
|
#*/
|
|
sq_register(vm, SceneSetAmbientColor, "SceneSetAmbientColor", _SC(".xx"));
|
|
/*#
|
|
Func: SceneGetBackgroundColor
|
|
Proto: Vector:Scene
|
|
Desc: Get the scene background color.
|
|
#*/
|
|
sq_register(vm, SceneGetBackgroundColor, "SceneGetBackgroundColor", _SC(".x"));
|
|
/*#
|
|
Func: SceneSetBackgroundColor
|
|
Proto: void:Scene,Vector
|
|
Desc: Set the scene background color.
|
|
Example: SceneSetAmbientColor(g_scene, Vector(0.0, 1.0, 0.0)) // Pure green background.
|
|
#*/
|
|
sq_register(vm, SceneSetBackgroundColor, "SceneSetBackgroundColor", _SC(".xx"));
|
|
/*#
|
|
Func: SceneGetFogColor
|
|
Proto: Vector:Scene
|
|
Desc: Return the fog color.
|
|
#*/
|
|
sq_register(vm, SceneGetFogColor, "SceneGetFogColor", _SC(".x"));
|
|
/*#
|
|
Func: SceneGetFogNear
|
|
Proto: float:Scene
|
|
Desc: Return the fog Z near.
|
|
#*/
|
|
sq_register(vm, SceneGetFogNear, "SceneGetFogNear", _SC(".x"));
|
|
/*#
|
|
Func: SceneGetFogFar
|
|
Proto: float:Scene
|
|
Desc: Return the fog Z far.
|
|
#*/
|
|
sq_register(vm, SceneGetFogFar, "SceneGetFogFar", _SC(".x"));
|
|
/*#
|
|
Func: SceneSetFog
|
|
Proto: void:Scene,bool enable,Vector color,float z_near,float z_far
|
|
Desc: Control scene fog.
|
|
Example:
|
|
// Set a white fog starting 10 meters from the camera and fully covering view at 50 meters from the camera.
|
|
SceneSetFog(g_scene, true, Vector(1.0, 1.0, 1.0), Mtr(10), Mtr(50))
|
|
#*/
|
|
sq_register(vm, SceneSetFog, "SceneSetFog", _SC(".xbxnn"));
|
|
|
|
/*#
|
|
Func: SceneSetFlagDebugPhysic
|
|
Proto: void:Scene, bool active
|
|
Desc: Activate/Deactivate the flag debug physic.
|
|
#*/
|
|
sq_register(vm, SceneSetFlagDebugPhysic, "SceneSetFlagDebugPhysic", _SC(".xb"));
|
|
|
|
/*#
|
|
Func: SceneGetTimeOfDay
|
|
Proto: float:Scene
|
|
Desc: Get time of day as a normalized value.
|
|
#*/
|
|
sq_register(vm, SceneGetTimeOfDay, "SceneGetTimeOfDay", _SC(".x"));
|
|
/*#
|
|
Func: SceneSetTimeOfDay
|
|
Proto: void:Scene,float time
|
|
Desc: Set time of day as a normalized value.
|
|
#*/
|
|
sq_register(vm, SceneSetTimeOfDay, "SceneSetTimeOfDay", _SC(".xn"));
|
|
/*#
|
|
Func: SceneSetSkyShader
|
|
Proto: void:Scene,string shader
|
|
Desc: Set sky shader name file.
|
|
#*/
|
|
sq_register(vm, SceneSetSkyShader, "SceneSetSkyShader", _SC(".xs"));
|
|
/*#
|
|
Func: SceneSetSkyLayer
|
|
Proto: void:Scene,string picture_layer,int index_sky_layer
|
|
Desc: Set sky layer picture.
|
|
#*/
|
|
sq_register(vm, SceneSetSkyLayer, "SceneSetSkyLayer", _SC(".xsi"));
|
|
|
|
/*#
|
|
Section: SceneRender
|
|
Desc: Rendering
|
|
#*/
|
|
/*#
|
|
Func: SceneRegisterAsPropertyCallback
|
|
Proto: void:Scene,Renderer
|
|
Desc: Register a scene as the renderer property callback.
|
|
#*/
|
|
sq_register(vm, SceneRegisterAsPropertyCallback, "SceneRegisterAsPropertyCallback", _SC(".xx"));
|
|
|
|
/*#
|
|
Section: SceneDebug
|
|
Desc: Debug/profile
|
|
#*/
|
|
/*#
|
|
Func: ScenePrintItemList
|
|
Proto: void:Scene
|
|
Desc: Dump scene item list to log.
|
|
#*/
|
|
sq_register(vm, ScenePrintItemList, "ScenePrintItemList", _SC(".x"));
|
|
|
|
/*#
|
|
Section: SceneItem
|
|
Desc: Item management
|
|
#*/
|
|
/*#
|
|
Func: SceneGetItemList
|
|
Proto: Array:Scene|Instance
|
|
Desc: Returns an array of all items in the scene.
|
|
#*/
|
|
sq_register(vm, SceneGetItemList, "SceneGetItemList", _SC(".x"));
|
|
/*#
|
|
Func: SceneGetItemChildrenList
|
|
Proto: Array:Scene,Item
|
|
Desc: Returns an array of all the children items in the scene of a given parent item.
|
|
#*/
|
|
sq_register(vm, SceneGetItemChildrenList, "SceneGetItemChildrenList", _SC(".xx"));
|
|
/*#
|
|
Func: SceneFindItem
|
|
Proto: Item:Scene|Instance,string
|
|
Desc: Find an item in scene.
|
|
#*/
|
|
sq_register(vm, SceneFindItem, "SceneFindItem", _SC(".xs"));
|
|
/*#
|
|
Func: SceneFindItemChild
|
|
Proto: void:Scene|Instance,Item parent,string child_name
|
|
Desc: Find child item of a given item in scene.
|
|
#*/
|
|
sq_register(vm, SceneFindItemChild, "SceneFindItemChild", _SC(".xxs"));
|
|
/*#
|
|
Func: SceneSetupItem
|
|
Proto: void:Scene,Item
|
|
Desc: Setup an item. You need to call ItemRenderSetup() to setup the render object of this item.
|
|
#*/
|
|
sq_register(vm, SceneSetupItem, "SceneSetupItem", _SC(".xx"));
|
|
/*#
|
|
Func: SceneForceUpdateMassShapePhysicItem
|
|
Proto: void:Scene,Item
|
|
Desc:for to update the mass from the shape physic if the item and rigid is already created.
|
|
#*/
|
|
sq_register(vm, SceneForceUpdateMassShapePhysicItem, "SceneForceUpdateMassShapePhysicItem", _SC(".xx"));
|
|
/*#
|
|
Func: SceneDuplicateItem
|
|
Proto: void:Scene,Item
|
|
Desc: Duplicate an item and all its properties, returns the new instance.<br>You need to call SceneSetupItem() and ItemRenderSetup() on the new instance if you use this function at runtime.
|
|
#*/
|
|
sq_register(vm, SceneDuplicateItem, "SceneDuplicateItem", _SC(".xx"));
|
|
|
|
/*#
|
|
Func: SceneMergeItems
|
|
Proto: Object:Scene, RenderResourceFactory factory, nb item, array item
|
|
Desc: Merge 2 items together.
|
|
#*/
|
|
sq_register(vm, SceneMergeItems, "SceneMergeItems", _SC(".xsxia"));
|
|
|
|
/*#
|
|
Section: SceneGroup
|
|
Desc: Group management
|
|
#*/
|
|
/*#
|
|
Func: SceneDeleteGroup
|
|
Proto: void:Scene|Instance,Group
|
|
Desc: Delete a group and all its members from a scene.
|
|
#*/
|
|
sq_register(vm, SceneDeleteGroup, "SceneDeleteGroup", _SC(".xx"));
|
|
/*#
|
|
Func: SceneFindGroup
|
|
Proto: Group:Scene|Instance,string name
|
|
Desc: Find a group in scene from its name.
|
|
#*/
|
|
sq_register(vm, SceneFindGroup, "SceneFindGroup", _SC(".xs"));
|
|
|
|
/*#
|
|
Section: ScenePhysic
|
|
Desc: Physic
|
|
#*/
|
|
/*#
|
|
Func: ScenePhysicAllocateCollisionNode
|
|
Proto: void:Scene,int max_node, int max_contact
|
|
Desc: Allocate physic system internal structures. A collision node is used for each collision occurring during the collision detection phase. Many contacts can be generated for each collision occurring.
|
|
#*/
|
|
sq_register(vm, ScenePhysicAllocateCollisionNode, "ScenePhysicAllocateCollisionNode", _SC(".xii"));
|
|
/*#
|
|
Func: ScenePhysicEnableDeactivation
|
|
Proto: void:Scene,bool
|
|
Desc: Enable or disable physic system item deactivation.
|
|
#*/
|
|
sq_register(vm, ScenePhysicEnableDeactivation, "ScenePhysicEnableDeactivation", _SC(".xb"));
|
|
/*#
|
|
Func: SceneSetPhysicContactSolverIteration
|
|
Proto: void:Scene,int
|
|
Desc: Set the number of iteration used by the physic contact solver.
|
|
#*/
|
|
sq_register(vm, SceneSetPhysicContactSolverIteration, "SceneSetPhysicContactSolverIteration", _SC(".xi"));
|
|
/*#
|
|
Func: SceneSetPhysicConstraintSolverIteration
|
|
Proto: void:Scene,int
|
|
Desc: Set the number of iteration used by the physic constraint solver.
|
|
#*/
|
|
sq_register(vm, SceneSetPhysicConstraintSolverIteration, "SceneSetPhysicConstraintSolverIteration", _SC(".xi"));
|
|
/*#
|
|
Func: SceneSetPhysicFrequency
|
|
Proto: void:Scene,float
|
|
Desc: Set the physic system update frequency (default: 75 Hertz).
|
|
#*/
|
|
sq_register(vm, SceneSetPhysicFrequency, "SceneSetPhysicFrequency", _SC(".xn"));
|
|
/*#
|
|
Func: SceneGetPhysicFrequency
|
|
Proto: float:Scene
|
|
Desc: Returns the physic system update frequency in Hertz.
|
|
#*/
|
|
sq_register(vm, SceneGetPhysicFrequency, "SceneGetPhysicFrequency", _SC(".x"));
|
|
/*#
|
|
Func: SceneSetGravity
|
|
Proto: void:Scene,Vector
|
|
Desc: Set default physic system gravity (Default: Earth gravity: 0.0, -9.8, 0.0).
|
|
Note: This only affects the gravity for newly created items. In order to modify the gravity for a given item please use the item Physics functions.
|
|
#*/
|
|
sq_register(vm, SceneSetGravity, "SceneSetGravity", _SC(".xx"));
|
|
/*#
|
|
Func: SceneFindConstraint
|
|
Proto: Constraint:Scene,string name
|
|
Desc: Find a constraint in scene from its name.
|
|
#*/
|
|
sq_register(vm, SceneFindConstraint, "SceneFindConstraint", _SC(".xs"));
|
|
|
|
/*#
|
|
Section: SceneCollision
|
|
Desc: Collision
|
|
#*/
|
|
/*#
|
|
Func: SceneCollisionRaytrace
|
|
Proto: TraceResult:Scene,Vector from,Vector direction,int collision_mask,ShapeMask,float max_distance
|
|
Desc: Raytrace the collision system, collision shape type and collision ids can be filtered through bit mask usage.
|
|
#*/
|
|
sq_register(vm, SceneCollisionRaytrace, "SceneCollisionRaytrace", _SC(".xxxiin"));
|
|
/*#
|
|
Func: SceneRaytraceTriggerList
|
|
Proto: Item:Scene,Vector ray_origin,Vector ray_direction,float ray_length
|
|
Desc: Raytrace scene triggers, return the trigger item hit.
|
|
#*/
|
|
sq_register(vm, SceneRaytraceTriggerList, "SceneRaytraceTriggerList", _SC(".xxxn"));
|
|
|
|
// Push defines.
|
|
sq_pushroottable(vm);
|
|
|
|
/*#
|
|
Struct: TraceResult
|
|
Member: bool hit: true if the ray hit something, false otherwise.
|
|
Member: Item item: Item hit by the ray.
|
|
Member: ColShape shape: Collision shape hit by the ray.
|
|
Member: Material material: Material at hit point.
|
|
Member: Vector p: Hit point location in world space.
|
|
Member: Vector n: Hit point normal in world space.
|
|
Member: float d: Distance to hit point from ray origin.
|
|
#*/
|
|
|
|
/*#
|
|
Enum: ImportFlag
|
|
Values: ImportFlagCamera,ImportFlagLight,ImportFlagObject,ImportFlagTrigger,ImportFlagGroup,ImportFlagMotion,ImportFlagGlobals,ImportFlagCollision,ImportFlagPhysic,ImportFlagPath,ImportFlagAll
|
|
#*/
|
|
#if 1
|
|
sq_pushstring(vm, "FlagLoadCamera", -1); sq_pushinteger(vm, SceneIOCamera); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "FlagLoadLight", -1); sq_pushinteger(vm, SceneIOLight); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "FlagLoadObject", -1); sq_pushinteger(vm, SceneIOObject); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "FlagLoadTrigger", -1); sq_pushinteger(vm, SceneIOTrigger); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "FlagLoadGroup", -1); sq_pushinteger(vm, SceneIOGroup); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "FlagLoadSettings", -1); sq_pushinteger(vm, SceneIOSettings); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "FlagLoadGlobals", -1); sq_pushinteger(vm, SceneIOGlobals); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "FlagLoadMotion", -1); sq_pushinteger(vm, SceneIOMotion); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "FlagLoadCollision", -1); sq_pushinteger(vm, SceneIOCollision); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "FlagLoadPhysic", -1); sq_pushinteger(vm, SceneIOPhysic); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "FlagLoadPath", -1); sq_pushinteger(vm, SceneIOPath); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "FlagLoadAll", -1); sq_pushinteger(vm, SceneIOAll); sq_newslot(vm, -3, true);
|
|
#endif
|
|
sq_pushstring(vm, "ImportFlagCamera", -1); sq_pushinteger(vm, SceneIOCamera); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "ImportFlagLight", -1); sq_pushinteger(vm, SceneIOLight); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "ImportFlagObject", -1); sq_pushinteger(vm, SceneIOObject); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "ImportFlagTrigger", -1); sq_pushinteger(vm, SceneIOTrigger); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "ImportFlagInstance", -1); sq_pushinteger(vm, SceneIOInstance); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "ImportFlagGroup", -1); sq_pushinteger(vm, SceneIOGroup); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "ImportFlagSettings", -1); sq_pushinteger(vm, SceneIOSettings); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "ImportFlagGlobals", -1); sq_pushinteger(vm, SceneIOGlobals); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "ImportFlagMotion", -1); sq_pushinteger(vm, SceneIOMotion); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "ImportFlagCollision", -1); sq_pushinteger(vm, SceneIOCollision); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "ImportFlagPhysic", -1); sq_pushinteger(vm, SceneIOPhysic); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "ImportFlagPath", -1); sq_pushinteger(vm, SceneIOPath); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "ImportFlagAll", -1); sq_pushinteger(vm, SceneIOAll); sq_newslot(vm, -3, true);
|
|
|
|
sq_pushstring(vm, "NullItem", -1); CObject::Push(vm, NULL, typetag_Item); sq_newslot(vm, -3, true);
|
|
|
|
sq_pop(vm, 1);
|
|
}
|