538 lines
16 KiB
C++
538 lines
16 KiB
C++
/* -----------------------------------------------------------------------------
|
|
GSFramework
|
|
Copyright 2001-2013 Emmanuel Julien. All Rights Reserved.
|
|
----------------------------------------------------------------------------- */
|
|
|
|
|
|
#include "binding_helpers.h"
|
|
#include "core/render_data.h"
|
|
#include "core/geometry.h"
|
|
#include "core/iso_surface.h"
|
|
#include "core/resource_factories.h"
|
|
#include "core/graphic_resource_factory.h"
|
|
#include "metafile/nml_object.h"
|
|
#include "gpu/gpu_material.h"
|
|
|
|
using namespace GS;
|
|
using namespace GS::Render;
|
|
using namespace GS::Script;
|
|
|
|
//------------------------------------------------------------------------------
|
|
SQInteger GeometrySaveOnItself(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(g, Geometry, typetag_Geometry)
|
|
__SQ_GETSAFEPTR(f, Core::ResourceFactories, typetag_ResourceFactories)
|
|
__SQ_GETEND
|
|
|
|
// get the geo from core
|
|
GS::Core::Geometry * core_geo = f->graphic->LoadGeometry(g->name);
|
|
|
|
core_geo->flag = g->flag;
|
|
core_geo->lod_distance = g->lod_distance;
|
|
|
|
if(g->lod_proxy.IsValid())
|
|
core_geo->lod_proxy = g->lod_proxy->name;
|
|
else
|
|
core_geo->lod_proxy = "";
|
|
|
|
if(g->shadow_proxy.IsValid())
|
|
core_geo->shadow_proxy = g->shadow_proxy->name;
|
|
else
|
|
core_geo->shadow_proxy = "";
|
|
|
|
bool r = NML::SaveToFile(*core_geo, core_geo->name);
|
|
|
|
__SQ_RETURN
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
SQInteger GeometryGetShadowProxyNull(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(g, Geometry, typetag_Geometry)
|
|
__SQ_RETURNBOOL(g->flag.IsSet(Core::Geometry::FlagNullShadowProxy))
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
SQInteger GeometrySetShadowProxyNull(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(g, Geometry, typetag_Geometry)
|
|
__SQ_GETBOOL(ShadowProxyNull)
|
|
__SQ_GETEND
|
|
g->flag.Raise(Core::Geometry::FlagNullShadowProxy, asbool(ShadowProxyNull));
|
|
__SQ_RETURN
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
SQInteger GeometryGetLodNull(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(g, Geometry, typetag_Geometry)
|
|
__SQ_RETURNBOOL(g->flag.IsSet(Core::Geometry::FlagNullLodProxy))
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
SQInteger GeometrySetLodNull(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(g, Geometry, typetag_Geometry)
|
|
__SQ_GETBOOL(LodNull)
|
|
__SQ_GETEND
|
|
g->flag.Raise(Core::Geometry::FlagNullLodProxy, asbool(LodNull));
|
|
__SQ_RETURN
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
SQInteger GeometryGetLodDistance(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(g, Geometry, typetag_Geometry)
|
|
__SQ_RETURNFLOAT(g->lod_distance)
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
SQInteger GeometrySetLodDistance(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(g, Geometry, typetag_Geometry)
|
|
__SQ_GETFLOAT(n)
|
|
__SQ_GETEND
|
|
g->lod_distance = n;
|
|
__SQ_RETURN
|
|
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
SQInteger GeometryGetLod(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(g, Geometry, typetag_Geometry)
|
|
__SQ_RETURNSAFEPTR(g->lod_proxy.c_ptr(), typetag_Geometry)
|
|
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
SQInteger GeometrySetLod(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(g, Geometry, typetag_Geometry)
|
|
__SQ_GETSAFEPTRALLOWNULL(geo_Lod, GS::Render::Geometry, typetag_Geometry)
|
|
__SQ_GETEND
|
|
g->lod_proxy = geo_Lod ? geo_Lod : NULL;
|
|
__SQ_RETURN
|
|
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
SQInteger GeometryGetShadowProxy(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(g, Geometry, typetag_Geometry)
|
|
__SQ_RETURNSAFEPTR(g->shadow_proxy.c_ptr(), typetag_Geometry)
|
|
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
SQInteger GeometrySetShadowProxy(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(g, Geometry, typetag_Geometry)
|
|
__SQ_GETSAFEPTRALLOWNULL(geo_shadow_proxy, GS::Render::Geometry, typetag_Geometry)
|
|
__SQ_GETEND
|
|
g->shadow_proxy = geo_shadow_proxy? geo_shadow_proxy : NULL;
|
|
__SQ_RETURN
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
SQInteger GeometryGetName(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(g, Geometry, typetag_Geometry)
|
|
__SQ_RETURNSTRING(g->name)
|
|
}
|
|
SQInteger GeometryGetMinMax(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(g, Geometry, typetag_Geometry)
|
|
__SQ_RETURNMINMAX(g->minmax)
|
|
}
|
|
SQInteger GeometrySetHidden(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(g, Geometry, typetag_Geometry)
|
|
__SQ_GETBOOL(hidden)
|
|
__SQ_GETEND
|
|
g->flag.Raise(Core::Geometry::FlagHidden, asbool(hidden));
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger GeometryOptimize(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(g, Geometry, typetag_Geometry)
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger GeometryComputeIsoSurface(HSQUIRRELVM vm)
|
|
{
|
|
sq_pop(vm, 4);
|
|
/*
|
|
__SQ_GETSTART(4)
|
|
__SQ_GETSAFEPTR(Item, nMItem, typetag_Item)
|
|
__SQ_GETINT(nb_metaball)
|
|
|
|
if ((nb_metaball > 0) && (Item->GetItemType() == Type_Object))
|
|
{
|
|
// get the geometry, or if it doesn't have it create one
|
|
nSharedPtr <nGeometry> g;
|
|
if(((nMObject *)Item)->GetGeometry().IsNull())
|
|
{
|
|
g = new nGeometry(Item->GetScene().GetEngine());
|
|
((nMObject *)Item)->SetGeometry(g.c_ptr());
|
|
}
|
|
else
|
|
g = ((nMObject *)Item)->GetGeometry();
|
|
|
|
nVector* pos_metaball = new nVector[nb_metaball];
|
|
|
|
// get the list of metaball
|
|
sq_pushnull(vm);//null iterator
|
|
for(int i=0; i<nb_metaball; ++i)
|
|
{
|
|
sq_next(vm, __SQ_STACKPOS-1 );
|
|
GetVector(vm, -1, pos_metaball[i]);
|
|
sq_pop(vm,2);
|
|
}
|
|
sq_pop(vm,1); //pops the null iterator
|
|
|
|
__SQ_GETUPDATESTACK
|
|
|
|
float* value_metaball = new float[nb_metaball];
|
|
sq_pushnull(vm);//null iterator
|
|
for(int i=0; i<nb_metaball; ++i)
|
|
{
|
|
sq_next(vm, __SQ_STACKPOS-1 );
|
|
sq_getfloat(vm, -1, &value_metaball[i]);
|
|
sq_pop(vm, 2);
|
|
}
|
|
sq_pop(vm,1); //pops the null iterator
|
|
|
|
__SQ_GETEND
|
|
|
|
// compute min max from the metaball
|
|
nVector MinGrid(10000000.0f,10000000.0f,10000000.0f);
|
|
nVector MaxGrid(-10000000.0f,-10000000.0f,-10000000.0f);
|
|
|
|
for(int i=0; i<nb_metaball; ++i)
|
|
{
|
|
if (pos_metaball[i].x+value_metaball[i] > MaxGrid.x) MaxGrid.x = pos_metaball[i].x+value_metaball[i];
|
|
if (pos_metaball[i].y+value_metaball[i] > MaxGrid.y) MaxGrid.y = pos_metaball[i].y+value_metaball[i];
|
|
if (pos_metaball[i].z+value_metaball[i] > MaxGrid.z) MaxGrid.z = pos_metaball[i].z+value_metaball[i];
|
|
if (pos_metaball[i].x-value_metaball[i] < MinGrid.x) MinGrid.x = pos_metaball[i].x-value_metaball[i];
|
|
if (pos_metaball[i].y-value_metaball[i] < MinGrid.y) MinGrid.y = pos_metaball[i].y-value_metaball[i];
|
|
if (pos_metaball[i].z-value_metaball[i] < MinGrid.z) MinGrid.z = pos_metaball[i].z-value_metaball[i];
|
|
}
|
|
|
|
nIsosurface isosurface(g->GetEngine());
|
|
isosurface.Init(MinGrid, MaxGrid-MinGrid, nVector(90, 90, 90));
|
|
|
|
g->Free();
|
|
isosurface.Triangularize(g.c_ptr(), nb_metaball, pos_metaball, value_metaball);
|
|
g->material_table.Allocate(1);
|
|
|
|
nMaterial *m = g->material_table[0] = new nMaterial(g->GetEngine());
|
|
m->renderword |= nMaterial::Render_Smooth;
|
|
// m->shader_map = m->AsShaderMap();
|
|
//g->ComputeVertexToPolygon();
|
|
// // Update ISO
|
|
g->render_data = g->GetEngine().GetRenderer().SetupGeometry(g.c_ptr());
|
|
|
|
_safe_delete_array(value_metaball);
|
|
_safe_delete_array(pos_metaball);
|
|
}
|
|
*/
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger GeometrySetup(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(g, Geometry, typetag_Geometry)
|
|
__LOG_V__ << "GeometrySetup() STUB\n";
|
|
__SQ_RETURN
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
SQInteger GeometryGetMaterialList(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(g, Geometry, typetag_Geometry)
|
|
sq_newarray(vm, 0);
|
|
|
|
for (uint n = 0; n < g->material_table.GetCount(); ++n)
|
|
{
|
|
CObject::Push(vm, (void *)g->material_table[n].c_ptr(), typetag_Material);
|
|
sq_arrayappend(vm, -2);
|
|
}
|
|
return 1;
|
|
}
|
|
SQInteger GeometryGetMaterialCount(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(g, Geometry, typetag_Geometry)
|
|
__SQ_RETURNINT(g->material_table.GetCount())
|
|
}
|
|
SQInteger GeometryGetMaterial(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(g, Geometry, typetag_Geometry)
|
|
__SQ_GETSTRING(name)
|
|
|
|
Material *m = NULL;
|
|
for (uint n = 0; n < g->material_table.GetCount(); ++n)
|
|
if (g->material_table[n]->name == name)
|
|
{
|
|
m = g->material_table[n];
|
|
break;
|
|
}
|
|
|
|
__SQ_GETEND
|
|
__SQ_RETURNSAFEPTR(m, typetag_Material)
|
|
}
|
|
SQInteger GeometryGetMaterialFromIndex(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(g, Geometry, typetag_Geometry)
|
|
__SQ_GETINT(index)
|
|
__SQ_GETEND
|
|
__SQ_RETURNSAFEPTR(g->material_table[(int)index].c_ptr(), typetag_Material)
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
SQInteger GeometrySetMaterial(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(3)
|
|
__SQ_GETSAFEPTR(g, Geometry, typetag_Geometry)
|
|
__SQ_GETINT(index)
|
|
__SQ_GETSAFEPTR(m, Material, typetag_Material)
|
|
__SQ_GETEND
|
|
__SQ_RETURNBOOL(g->SetMaterial(uint(index), m))
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
SQInteger GeometryCloneMaterials(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(g, Geometry, typetag_Geometry)
|
|
|
|
__LOG_W__ << "[SQ] GeometryCloneMaterials: Cloning all materials for geometry '" << g->name << "'...\n";
|
|
|
|
uint mat_count = g->material_table.GetCount();
|
|
__LOG_W__ << "[SQ] GeometryCloneMaterials: Found " << mat_count << " materials.\n";
|
|
|
|
for (uint i = 0; i < mat_count; ++i)
|
|
{
|
|
Material *original = g->material_table[i].c_ptr();
|
|
if (!original)
|
|
{
|
|
__LOG_W__ << "[SQ] GeometryCloneMaterials: Material " << i << " is NULL, skipping.\n";
|
|
continue;
|
|
}
|
|
|
|
__LOG_W__ << "[SQ] GeometryCloneMaterials: Cloning material " << i << " ('" << original->name << "')...\n";
|
|
|
|
// Cast to GPU::Material
|
|
GPU::Material *gpu_mat = dynamic_cast<GPU::Material*>(original);
|
|
if (!gpu_mat)
|
|
{
|
|
__LOG_W__ << "[SQ] GeometryCloneMaterials: Material " << i << " is not GPU::Material, skipping.\n";
|
|
continue;
|
|
}
|
|
|
|
// Clone manually (same as MaterialClone)
|
|
try
|
|
{
|
|
GPU::Renderer &rend = gpu_mat->renderer;
|
|
Material *cloned = new GPU::Material(rend);
|
|
|
|
// Copy properties
|
|
cloned->name = gpu_mat->name + "_clone";
|
|
*((Core::BasicMaterial *)cloned) = *((Core::BasicMaterial *)gpu_mat);
|
|
((GPU::Material*)cloned)->shader = gpu_mat->shader;
|
|
|
|
// Copy texture table
|
|
for (uint n = 0; n < Core::Material::max_texture_stage; ++n)
|
|
{
|
|
cloned->texture_table[n] = gpu_mat->texture_table[n];
|
|
}
|
|
|
|
// Assign cloned material back to geometry
|
|
g->SetMaterial(i, cloned);
|
|
|
|
__LOG_W__ << "[SQ] GeometryCloneMaterials: Material " << i << " cloned successfully.\n";
|
|
}
|
|
catch (...)
|
|
{
|
|
__LOG_E__ << "[SQ] GeometryCloneMaterials: Exception while cloning material " << i << "!\n";
|
|
}
|
|
}
|
|
|
|
__LOG_W__ << "[SQ] GeometryCloneMaterials: Done!\n";
|
|
__SQ_RETURN
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//-------------------------------------------------
|
|
void RegisterGeometryBinding(HSQUIRRELVM vm)
|
|
//-------------------------------------------------
|
|
{
|
|
/*#
|
|
Topic: Geometry
|
|
Type: Geometry
|
|
#*/
|
|
|
|
/*#
|
|
Section: GeometryGeneric
|
|
Desc: Generic functions
|
|
#*/
|
|
|
|
/*#
|
|
Func: GeometryGetLod
|
|
Proto: Geometry:Geometry geo
|
|
Desc: Get geometry get geometry LOD.
|
|
#*/
|
|
sq_register(vm, GeometryGetLod, "GeometryGetLod", _SC(".x"));
|
|
/*#
|
|
Func: GeometrySetLod
|
|
Proto: void:Geometry geo, Geometry geo_LOD
|
|
Desc: Set geometry LOD.
|
|
#*/
|
|
sq_register(vm, GeometrySetLod, "GeometrySetLod", _SC(".xx"));
|
|
|
|
/*#
|
|
Func: GeometryGetShadowProxy
|
|
Proto: Geometry:Geometry geo
|
|
Desc: Get geometry get geometry Shadow proxy.
|
|
#*/
|
|
sq_register(vm, GeometryGetShadowProxy, "GeometryGetShadowProxy", _SC(".x"));
|
|
/*#
|
|
Func: GeometrySetShadowProxy
|
|
Proto: void:Geometry geo, Geometry show_proxy
|
|
Desc: Set geometry shadow proxy
|
|
#*/
|
|
sq_register(vm, GeometrySetShadowProxy, "GeometrySetShadowProxy", _SC(".xx"));
|
|
|
|
/*#
|
|
Func: GeometryGetLodDistance
|
|
Proto: float:Geometry geo
|
|
Desc: Get geometry Lod distance.
|
|
#*/
|
|
sq_register(vm, GeometryGetLodDistance, "GeometryGetLodDistance", _SC(".x"));
|
|
/*#
|
|
Func: GeometrySetLodDistance
|
|
Proto: void:Geometry geo, float Lod distance
|
|
Desc: Set geometry Lod distance
|
|
#*/
|
|
sq_register(vm, GeometrySetLodDistance, "GeometrySetLodDistance", _SC(".xn"));
|
|
|
|
/*#
|
|
Func: GeometryGetLodNull
|
|
Proto: bool:Geometry geo
|
|
Desc: Get geometry Lod Null.
|
|
#*/
|
|
sq_register(vm, GeometryGetLodNull, "GeometryGetLodNull", _SC(".x"));
|
|
/*#
|
|
Func: GeometrySetLodNull
|
|
Proto: void:Geometry geo, bool LodNull
|
|
Desc: Set geometry Lod Null
|
|
#*/
|
|
sq_register(vm, GeometrySetLodNull, "GeometrySetLodNull", _SC(".xb"));
|
|
/*#
|
|
Func: GeometryGetShadowProxyNull
|
|
Proto: bool:Geometry geo
|
|
Desc: Get geometry ShadowProxy Null.
|
|
#*/
|
|
sq_register(vm, GeometryGetShadowProxyNull, "GeometryGetShadowProxyNull", _SC(".x"));
|
|
/*#
|
|
Func: GeometrySetShadowProxyNull
|
|
Proto: void:Geometry geo, bool ShadowProxyNull
|
|
Desc: Set geometry ShadowProxy Null
|
|
#*/
|
|
sq_register(vm, GeometrySetShadowProxyNull, "GeometrySetShadowProxyNull", _SC(".xb"));
|
|
|
|
/*#
|
|
Func: GeometrySaveOnItself
|
|
Proto: void:Geometry geo, g_factory
|
|
Desc: Save the geometry on it's own nmg.
|
|
#*/
|
|
sq_register(vm, GeometrySaveOnItself, "GeometrySaveOnItself", _SC(".xx"));
|
|
|
|
|
|
/*#
|
|
Func: GeometryGetName
|
|
Proto: string:Geometry geo
|
|
Desc: Get geometry name.
|
|
#*/
|
|
sq_register(vm, GeometryGetName, "GeometryGetName", _SC(".x"));
|
|
/*#
|
|
Func: GeometrySetHidden
|
|
Proto: void:Geometry geo,bool hidden
|
|
Desc: Hide or show geometry, items referring to this geometry will still be updated.
|
|
#*/
|
|
sq_register(vm, GeometrySetHidden, "GeometrySetHidden", _SC(".xb"));
|
|
/*#
|
|
Func: GeometryOptimize
|
|
Proto: void:Geometry geo
|
|
Desc: Optimize geometry for realtime rendering.
|
|
#*/
|
|
sq_register(vm, GeometryOptimize, "GeometryOptimize", _SC(".x"));
|
|
/*#
|
|
Func: GeometryComputeIsoSurface
|
|
Proto: void:Item item, int nb_metaball,array pos_metaball,array value_metaball
|
|
Desc: Create an iso surface to the geometry with the array of metaball.
|
|
#*/
|
|
sq_register(vm, GeometryComputeIsoSurface, "GeometryComputeIsoSurface", _SC(".xiaa"));
|
|
/*#
|
|
Func: GeometrySetup
|
|
Proto: void:Geometry geo
|
|
Desc: Setup geometry in the renderer.
|
|
#*/
|
|
sq_register(vm, GeometrySetup, "GeometrySetup", _SC(".x"));
|
|
|
|
/*#
|
|
Section: GeometryTopology
|
|
Desc: Topology functions
|
|
#*/
|
|
|
|
/*#
|
|
Func: GeometryGetMinMax
|
|
Proto: MinMax:Geometry geo
|
|
Desc: Get geometry minmax.
|
|
#*/
|
|
sq_register(vm, GeometryGetMinMax, "GeometryGetMinMax", _SC(".x"));
|
|
|
|
/*#
|
|
Section: GeometryMaterial
|
|
Desc: Material functions
|
|
#*/
|
|
|
|
/*#
|
|
Func: GeometryGetMaterialList
|
|
Proto: array:Geometry geo
|
|
Desc: Return a list of all materials in a geometry.
|
|
#*/
|
|
sq_register(vm, GeometryGetMaterialList, "GeometryGetMaterialList", _SC(".x"));
|
|
/*#
|
|
Func: GeometryGetMaterialCount
|
|
Proto: int:Geometry geo
|
|
Desc: Get geometry material count.
|
|
#*/
|
|
sq_register(vm, GeometryGetMaterialCount, "GeometryGetMaterialCount", _SC(".x"));
|
|
/*#
|
|
Func: GeometryGetMaterial
|
|
Proto: Material:Geometry geo,string name
|
|
Desc: Get material from name.
|
|
#*/
|
|
sq_register(vm, GeometryGetMaterial, "GeometryGetMaterial", _SC(".xs"));
|
|
/*#
|
|
Func: GeometrySetMaterial
|
|
Proto: bool:Geometry geo,int index,Material material
|
|
Desc: Replace a material in the geometry material table.
|
|
#*/
|
|
sq_register(vm, GeometrySetMaterial, "GeometrySetMaterial", _SC(".xix"));
|
|
/*#
|
|
Func: GeometryCloneMaterials
|
|
Proto: void:Geometry geo
|
|
Desc: Clone all materials in the geometry. Each material becomes an independent copy.
|
|
Note: This allows you to modify materials for one geometry without affecting others that share the same loaded geometry file.
|
|
Example: GeometryCloneMaterials(geo)
|
|
#*/
|
|
sq_register(vm, GeometryCloneMaterials, "GeometryCloneMaterials", _SC(".x"));
|
|
/*#
|
|
Func: GeometryGetMaterialFromIndex
|
|
Proto: Material:Geometry geo,int index
|
|
Desc: Get material from index.
|
|
#*/
|
|
sq_register(vm, GeometryGetMaterialFromIndex, "GeometryGetMaterialFromIndex", _SC(".xi"));
|
|
}
|