Initial revision
This commit is contained in:
Hans Lambermont
753
source/blender/bpython/intern/b_interface.c
Normal file
753
source/blender/bpython/intern/b_interface.c
Normal file
@@ -0,0 +1,753 @@
|
||||
/** Interfacing with Blender
|
||||
*
|
||||
* ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version. The Blender
|
||||
* Foundation also sells licenses for use in proprietary software under
|
||||
* the Blender License. See http://www.blender.org/BL/ for information
|
||||
* about this.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software Foundation,
|
||||
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*
|
||||
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
||||
* All rights reserved.
|
||||
*
|
||||
* The Original Code is: all of this file.
|
||||
*
|
||||
* Contributor(s): none yet.
|
||||
*
|
||||
* ***** END GPL/BL DUAL LICENSE BLOCK *****
|
||||
*
|
||||
* $Id$
|
||||
*
|
||||
* This code is currently messy and an attempt to restructure
|
||||
* some Blender kernel level code.
|
||||
* Hopefully a template for a future C-API...
|
||||
*
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
#include "BLI_blenlib.h" // mallocs
|
||||
#include "BLI_arithb.h"
|
||||
|
||||
#include "BKE_library.h"
|
||||
#include "BKE_global.h"
|
||||
#include "BKE_main.h"
|
||||
#include "BKE_object.h"
|
||||
#include "BKE_mesh.h"
|
||||
#include "BKE_ipo.h"
|
||||
|
||||
#include "MEM_guardedalloc.h"
|
||||
|
||||
#include "Python.h"
|
||||
#include "BPY_macros.h"
|
||||
#include "structmember.h"
|
||||
|
||||
#include "BDR_editobject.h"
|
||||
|
||||
#include "b_interface.h"
|
||||
|
||||
/************************************************************************
|
||||
* Generic low level routines
|
||||
*
|
||||
*/
|
||||
|
||||
/** This just returns a pointer to the global struct.
|
||||
*
|
||||
* Mainly introduced for debugging purposes..
|
||||
*
|
||||
*/
|
||||
|
||||
Global *getGlobal(void)
|
||||
{
|
||||
return &G;
|
||||
}
|
||||
|
||||
/** define list getters:
|
||||
These functions return a linked list pointer (ListBase *) from the global
|
||||
Blender-object list.
|
||||
|
||||
Example:
|
||||
oblist = getObjectList();
|
||||
firstobject = oblist->first;
|
||||
|
||||
*/
|
||||
|
||||
/*
|
||||
DEF_GETLIST(Scene, scene)
|
||||
DEF_GETLIST(Object, object)
|
||||
DEF_GETLIST(Mesh, mesh)
|
||||
DEF_GETLIST(Camera, camera)
|
||||
DEF_GETLIST(Material, mat)
|
||||
DEF_GETLIST(Lamp, lamp)
|
||||
DEF_GETLIST(World, world)
|
||||
DEF_GETLIST(Ipo, ipo)
|
||||
DEF_GETLIST(Image, image)
|
||||
DEF_GETLIST(Texture, tex)
|
||||
DEF_GETLIST(Text, text)
|
||||
DEF_GETLIST(Key, key)
|
||||
*/
|
||||
|
||||
/* gets a datablock object from the ID list by name */
|
||||
ID *getFromList(ListBase *list, char *name)
|
||||
{
|
||||
ID *id = list->first;
|
||||
|
||||
while (id) {
|
||||
if(STREQ(name, getIDName(id))) break;
|
||||
id= id->next;
|
||||
}
|
||||
return id;
|
||||
}
|
||||
|
||||
void printList(ListBase *list)
|
||||
{
|
||||
ID *walk = list->first;
|
||||
ID *lastwalk = 0;
|
||||
printf("List: %s\n", walk->name);
|
||||
while (walk) {
|
||||
printf(" %s\n", walk->name);
|
||||
lastwalk = walk;
|
||||
walk= walk->next;
|
||||
}
|
||||
if (list->last != lastwalk)
|
||||
{
|
||||
printf("****: listbase->last pointing to wrong end!\n");
|
||||
// list->last = lastwalk;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/** (future) garbage collector subroutine */
|
||||
|
||||
|
||||
int gc_mainlist(ListBase *lb)
|
||||
{
|
||||
ID *id = (ID *) lb->first;
|
||||
|
||||
while (id) {
|
||||
if (getIDUsers(id) == 0) {
|
||||
switch(GET_ID_TYPE(id)) {
|
||||
case ID_OB:
|
||||
BPY_debug(("free [Object %s]\n", getIDName(id)));
|
||||
unlink_object((Object *) id);
|
||||
free_libblock(lb, id);
|
||||
break;
|
||||
default: break;
|
||||
}
|
||||
}
|
||||
id = id->next;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
/** Garbage collection function. EXPERIMENTAL!
|
||||
* This should free Blender from all unreferenced Objects (i.e.
|
||||
* user count == 0).
|
||||
* Don't expect too much yet -- User counting isn't done
|
||||
* consequently in Blender. Neither parenting or bevelcurves
|
||||
* etc. respect user counts...therefore, no circular references
|
||||
* show up -- which are in fact possible; example:
|
||||
*
|
||||
* A BevelCurve is parenting its BevelObject: so there is a
|
||||
* reference from the BevelObject to the BevelCurve, and a
|
||||
* reference back from the Bevelcurve to the BevelObject.
|
||||
*
|
||||
* There are a lot of cleanup functions in Blender taking care
|
||||
* of updating (invalidating) references to deleted objects.
|
||||
* See unlink_object() for more details.
|
||||
*
|
||||
* This function must not be called inside a script, so don't go
|
||||
* and create a wrapper for it :-)
|
||||
* In a hopefully later implementation, the Python garbage collection
|
||||
* might be used. For the moment, this is better than 'Save and Reload'
|
||||
*/
|
||||
|
||||
int garbage_collect(Main *m)
|
||||
{
|
||||
/* Remember, all descriptor objects must BOB_DECUSER on their raw
|
||||
Blender Datablock in their __del__ method (C-API: dealloc function) */
|
||||
|
||||
gc_mainlist(&m->object);
|
||||
|
||||
/* TODO proper kernel level functions for safely freeing these objects
|
||||
* must first be implemented...
|
||||
gc_mainlist(&m->mesh);
|
||||
gc_mainlist(&m->mat);
|
||||
gc_mainlist(&m->lamp);
|
||||
gc_mainlist(&m->camera);
|
||||
|
||||
.. and this list is far from being complete.
|
||||
*/
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
/** expands pointer array of length 'oldsize' to length 'newsize'.
|
||||
* A pointer to the (void *) array must be passed as first argument
|
||||
* The array pointer content can be NULL, in this case a new array of length
|
||||
* 'newsize' is created.
|
||||
*/
|
||||
|
||||
static int expandPtrArray(void **p, int oldsize, int newsize)
|
||||
{
|
||||
void *newarray;
|
||||
|
||||
if (newsize < oldsize) {
|
||||
return 0;
|
||||
}
|
||||
newarray = MEM_callocN(newsize * sizeof(void *), "PtrArray");
|
||||
if (*p) {
|
||||
memcpy(newarray, *p, oldsize);
|
||||
MEM_freeN(*p);
|
||||
}
|
||||
*p = newarray;
|
||||
return 1;
|
||||
}
|
||||
|
||||
/************************************************************************
|
||||
* Material object low level routines
|
||||
*
|
||||
*/
|
||||
|
||||
/* MAXMAT = maximum number of materials per object/ object data */
|
||||
|
||||
#define MATINDEX_CHECK(x) \
|
||||
if ((x) < 0 || (x) >= MAXMAT) { printf("illegal matindex!\n"); return 0; }
|
||||
|
||||
/** Returns a new material list (material pointer array) of length 'len'
|
||||
*
|
||||
*/
|
||||
|
||||
Material **newMaterialList(int len)
|
||||
{
|
||||
Material **matlist =
|
||||
(Material **) MEM_mallocN(len * sizeof(Material *), "MaterialList");
|
||||
return matlist;
|
||||
}
|
||||
|
||||
/** releases material list and decrements user count on materials */
|
||||
|
||||
int releaseMaterialList(Material **matlist, int len)
|
||||
{
|
||||
int i;
|
||||
Material *m;
|
||||
|
||||
MATINDEX_CHECK(len);
|
||||
|
||||
for (i= 0; i < len; i++) {
|
||||
|
||||
m = matlist[i];
|
||||
BOB_XDECUSER((ID *) m);
|
||||
}
|
||||
MEM_freeN(matlist);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/** Synchronizes Object <-> data material lists. Blender just wants it. */
|
||||
|
||||
int synchronizeMaterialLists(Object *object, void *data)
|
||||
{
|
||||
// get pointer to data's material array:
|
||||
// and number of data materials
|
||||
// ... because they will need modification.
|
||||
|
||||
Material ***p_dataMaterials = give_matarar(object);
|
||||
short *nmaterials = give_totcolp(object);
|
||||
|
||||
if (object->totcol > *nmaterials){ // more object mats than data mats
|
||||
*nmaterials = object->totcol;
|
||||
return expandPtrArray((void *) p_dataMaterials, *nmaterials, object->totcol);
|
||||
} else if (object->totcol < *nmaterials) {
|
||||
object->totcol = *nmaterials;
|
||||
return expandPtrArray((void *) &object->mat, object->totcol, *nmaterials);
|
||||
}
|
||||
return 1; // in this case, no synchronization needed; they're of equal
|
||||
// length
|
||||
}
|
||||
|
||||
/************************************************************************
|
||||
* Object low level routines
|
||||
*
|
||||
*/
|
||||
|
||||
/** creates a new empty object of type OB_ (TODO: should be enum)
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
Object *object_new(int type)
|
||||
{
|
||||
Object *object;
|
||||
char name[32];
|
||||
|
||||
Global *g = getGlobal();
|
||||
|
||||
switch(type) {
|
||||
case OB_MESH: strcpy(name, "Mesh"); break;
|
||||
case OB_CURVE: strcpy(name, "Curve"); break;
|
||||
case OB_SURF: strcpy(name, "Surf"); break;
|
||||
case OB_FONT: strcpy(name, "Text"); break;
|
||||
case OB_MBALL: strcpy(name, "Mball"); break;
|
||||
case OB_CAMERA: strcpy(name, "Camera"); break;
|
||||
case OB_LAMP: strcpy(name, "Lamp"); break;
|
||||
case OB_IKA: strcpy(name, "Ika"); break;
|
||||
case OB_LATTICE: strcpy(name, "Lattice"); break;
|
||||
case OB_WAVE: strcpy(name, "Wave"); break;
|
||||
case OB_ARMATURE: strcpy(name,"Armature");break;
|
||||
default: strcpy(name, "Empty");
|
||||
}
|
||||
|
||||
object = alloc_libblock(getObjectList(), ID_OB, name);
|
||||
|
||||
/* user count is set to 1 by alloc_libblock, we just reset it to 0... */
|
||||
BOB_USERCOUNT((ID*) object) = 0; // it's a new object, so no user yet
|
||||
object->flag = 0;
|
||||
object->type = type;
|
||||
|
||||
/* transforms */
|
||||
QuatOne(object->quat);
|
||||
QuatOne(object->dquat);
|
||||
|
||||
object->col[3]= 1.0; // alpha
|
||||
|
||||
object->size[0] = object->size[1] = object->size[2] = 1.0;
|
||||
object->loc[0] = object->loc[1] = object->loc[2] = 0.0;
|
||||
Mat4One(object->parentinv);
|
||||
Mat4One(object->obmat);
|
||||
object->dt = OB_SHADED; // drawtype
|
||||
|
||||
object_setdefaults(object);
|
||||
|
||||
object->lay = 1; // Layer, by default visible
|
||||
|
||||
switch(type) {
|
||||
case OB_MESH: object->data= add_mesh(); g->totmesh++; break;
|
||||
case OB_CAMERA: object->data= add_camera(); break;
|
||||
case OB_LAMP: object->data= add_lamp(); g->totlamp++; break;
|
||||
|
||||
// TODO the following types will be supported later
|
||||
// case OB_CURVE: object->data= add_curve(OB_CURVE); g->totcurve++; break;
|
||||
// case OB_SURF: object->data= add_curve(OB_SURF); g->totcurve++; break;
|
||||
// case OB_FONT: object->data= add_curve(OB_FONT); break;
|
||||
// case OB_MBALL: object->data= add_mball(); break;
|
||||
// case OB_IKA: object->data= add_ika(); object->dt= OB_WIRE; break;
|
||||
// case OB_LATTICE: object->data= (void *)add_lattice(); object->dt= OB_WIRE; break;
|
||||
// case OB_WAVE: object->data= add_wave(); break;
|
||||
// case OB_ARMATURE: object->data=add_armature();break;
|
||||
}
|
||||
|
||||
g->totobj++; // gee, I *hate* G
|
||||
return object;
|
||||
}
|
||||
|
||||
/* returns new Base */
|
||||
Base *object_newBase(Object *object)
|
||||
{
|
||||
Base *base;
|
||||
base = MEM_callocN(sizeof(Base), "newbase");
|
||||
if (!base)
|
||||
return 0;
|
||||
base->object = object;
|
||||
base->lay = object->lay;
|
||||
base->flag = object->flag;
|
||||
return base;
|
||||
}
|
||||
|
||||
Object *object_copy(Object *object)
|
||||
{
|
||||
Object *new;
|
||||
|
||||
new = copy_object(object);
|
||||
BOB_USERCOUNT((ID*) new) = 0; // it's a new object, so no user yet
|
||||
return new;
|
||||
}
|
||||
|
||||
/* Set draw mode of object */
|
||||
void object_setDrawMode(Object *object, int modebits)
|
||||
{
|
||||
object->dt = (modebits & 0xff);
|
||||
object->dtx = (modebits >> 8);
|
||||
}
|
||||
|
||||
int object_getDrawMode(Object *object)
|
||||
{
|
||||
return (((int) object->dtx) << 8 ) + object->dt;
|
||||
}
|
||||
|
||||
/* link data to Object object */
|
||||
int object_linkdata(Object *object, void *data)
|
||||
{
|
||||
ID *oldid, *id;
|
||||
int valid;
|
||||
|
||||
if (!data) return 0;
|
||||
|
||||
oldid = (ID*) object->data;
|
||||
id = (ID*) data;
|
||||
|
||||
valid = 0;
|
||||
|
||||
#define _CASE(objtype, idtype) \
|
||||
case objtype:\
|
||||
if (GET_ID_TYPE(id) == idtype) \
|
||||
valid = 1; \
|
||||
break;
|
||||
|
||||
switch (object->type) {
|
||||
_CASE(OB_MESH, ID_ME)
|
||||
_CASE(OB_CAMERA, ID_CA)
|
||||
_CASE(OB_LAMP, ID_LA)
|
||||
default: // not supported
|
||||
return 0;
|
||||
}
|
||||
if (valid) {
|
||||
object->data = data;
|
||||
BOB_INCUSER(id);
|
||||
if (oldid)
|
||||
BOB_DECUSER(oldid); // dec users
|
||||
|
||||
// extra check for multi materials on meshes:
|
||||
// This is a hack to check whether object material lists are of same
|
||||
// length as their data material lists..
|
||||
//if (GET_ID_TYPE(id) == ID_ME) {
|
||||
//test_object_materials(id);
|
||||
//}
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* release data from object object */
|
||||
|
||||
int object_unlinkdata(Object *object)
|
||||
{
|
||||
ID *id = object->data;
|
||||
|
||||
BOB_XDECUSER(id);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/** set Object materials:
|
||||
* takes a list of Material pointers of maximum length MAXMAT
|
||||
*/
|
||||
|
||||
int object_setMaterials(Object *object, Material **matlist, int len)
|
||||
{
|
||||
int i;
|
||||
|
||||
MATINDEX_CHECK(len)
|
||||
if (object->mat) {
|
||||
releaseMaterialList(object->mat, len);
|
||||
}
|
||||
// inc user count on all materials
|
||||
for (i = 0; i < len; i++) {
|
||||
BOB_XINCUSER( (ID *) matlist[i]);
|
||||
}
|
||||
|
||||
object->mat = matlist;
|
||||
object->totcol = len;
|
||||
object->actcol = len - 1; // XXX
|
||||
// workaround: blender wants the object's data material list
|
||||
// to be of the same length, otherwise colourful fun happens.
|
||||
// so, we synchronize this here:
|
||||
|
||||
switch (object->type)
|
||||
{
|
||||
case OB_MESH:
|
||||
case OB_CURVE:
|
||||
case OB_FONT:
|
||||
case OB_SURF:
|
||||
case OB_MBALL:
|
||||
synchronizeMaterialLists(object, object->data);
|
||||
break;
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
/** make 'object' the parent of the object 'child'
|
||||
*
|
||||
* mode = 1: set parent inverse matrix to _1_ ('clear inverse')
|
||||
* fast = 1: Don't update scene base (hierarchy). In this case,
|
||||
* sort_baselist() needs to be called explicitely before redraw.
|
||||
*/
|
||||
|
||||
int object_makeParent(Object *parent, Object *child, int mode, int fast)
|
||||
{
|
||||
if (test_parent_loop(parent, child)) {
|
||||
PyErr_SetString(PyExc_RuntimeError, "parenting loop detected!");
|
||||
return 0;
|
||||
}
|
||||
child->partype = PAROBJECT;
|
||||
child->parent = parent;
|
||||
if (mode == 1) {
|
||||
Mat4One(child->parentinv); // parent inverse = unity
|
||||
child->loc[0] = 0.0; child->loc[1] = 0.0; child->loc[2] = 0.0;
|
||||
} else {
|
||||
what_does_parent(child);
|
||||
Mat4Invert(child->parentinv, parent->obmat); // save inverse
|
||||
}
|
||||
|
||||
/* This is some bad global thing again -- we should determine
|
||||
the current scene
|
||||
another way. Later. */
|
||||
if (!fast)
|
||||
sort_baselist(getGlobal()->scene);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
/** Unlink parenting hierarchy:
|
||||
*
|
||||
* mode = 2: keep transform
|
||||
* fast = 1: don't update scene bases. see makeParent()
|
||||
*/
|
||||
|
||||
int object_clrParent(Object *child, int mode, int fast)
|
||||
{
|
||||
Object *par;
|
||||
|
||||
par = child->parent;
|
||||
child->parent = 0;
|
||||
if (mode == 2) { // keep transform
|
||||
apply_obmat(child);
|
||||
}
|
||||
if (!fast)
|
||||
sort_baselist(getGlobal()->scene);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/** Set object's defaults */
|
||||
|
||||
int object_setdefaults(Object *ob)
|
||||
{
|
||||
if(U.flag & MAT_ON_OB) ob->colbits= -1;
|
||||
switch(ob->type) {
|
||||
case OB_CAMERA:
|
||||
case OB_LAMP:
|
||||
ob->trackflag = OB_NEGZ;
|
||||
ob->upflag = OB_POSY;
|
||||
break;
|
||||
default:
|
||||
ob->trackflag = OB_POSY;
|
||||
ob->upflag = OB_POSZ;
|
||||
}
|
||||
ob->ipoflag = OB_OFFS_OB + OB_OFFS_PARENT;
|
||||
|
||||
/* duplivert settings */
|
||||
|
||||
ob->dupon = 1; ob->dupoff = 0;
|
||||
ob->dupsta = 1; ob->dupend = 100;
|
||||
|
||||
/* Gameengine defaults*/
|
||||
ob->mass= ob->inertia= 1.0;
|
||||
ob->formfactor= 0.4;
|
||||
ob->damping= 0.04;
|
||||
ob->rdamping= 0.1;
|
||||
ob->anisotropicFriction[0] = 1.0;
|
||||
ob->anisotropicFriction[1] = 1.0;
|
||||
ob->anisotropicFriction[2] = 1.0;
|
||||
|
||||
/* default to not use fh in new system */
|
||||
ob->gameflag= OB_PROP; /*|OB_DO_FH; */
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
/************************************************************************
|
||||
* Creation of new data blocks
|
||||
*
|
||||
* We [ab|re]use the blender kernel functions, but set the user count to 0,
|
||||
* because the object does not have users yet.
|
||||
* Currently, the user count is abused as reference count which should be
|
||||
* separate in future
|
||||
*/
|
||||
|
||||
Material *material_new(void)
|
||||
{
|
||||
Material *m = add_material("Material");
|
||||
BOB_USERCOUNT((ID*) m) = 0; // set 'refcount' to 0, because
|
||||
// it's a free material
|
||||
return m;
|
||||
}
|
||||
|
||||
Lamp *lamp_new()
|
||||
{
|
||||
Lamp *la;
|
||||
|
||||
la = add_lamp();
|
||||
BOB_USERCOUNT((ID*) la) = 0;
|
||||
|
||||
return la;
|
||||
}
|
||||
|
||||
Camera *camera_new()
|
||||
{
|
||||
Camera *cam;
|
||||
|
||||
cam = add_camera();
|
||||
BOB_USERCOUNT((ID*) cam) = 0;
|
||||
return cam;
|
||||
}
|
||||
|
||||
Ipo *ipo_new(int type, char *name)
|
||||
{
|
||||
Ipo *ipo;
|
||||
|
||||
ipo = add_ipo(name, type);
|
||||
BOB_USERCOUNT((ID*) ipo) = 0;
|
||||
return ipo;
|
||||
}
|
||||
|
||||
|
||||
/* Finds the ipo curve with channel code 'code' in the datablock 'ipo'
|
||||
and returns it, if found (NULL otherwise) */
|
||||
|
||||
IpoCurve *ipo_findcurve(Ipo *ipo, int code)
|
||||
{
|
||||
IpoCurve *ipocurve;
|
||||
|
||||
ipocurve = ipo->curve.first;
|
||||
while(ipocurve) {
|
||||
if (ipocurve->adrcode == code) break;
|
||||
ipocurve = ipocurve->next;
|
||||
}
|
||||
return ipocurve;
|
||||
}
|
||||
|
||||
|
||||
/** Returns a new Ipo curve */
|
||||
IpoCurve *ipocurve_new()
|
||||
{
|
||||
IpoCurve *curve;
|
||||
|
||||
curve = MEM_callocN(sizeof(IpoCurve), "new_ipocurve");
|
||||
curve->flag = IPO_VISIBLE;
|
||||
return curve;
|
||||
}
|
||||
|
||||
IpoCurve *ipocurve_copy(IpoCurve *curve)
|
||||
{
|
||||
IpoCurve *newcurve;
|
||||
|
||||
newcurve = MEM_callocN(sizeof(IpoCurve), "new_ipocurve");
|
||||
memcpy(newcurve, curve, sizeof(IpoCurve));
|
||||
// copy bez triples:
|
||||
newcurve->bezt= MEM_mallocN(curve->totvert*sizeof(BezTriple), "ipocurve_copy");
|
||||
memcpy(newcurve->bezt, curve->bezt, curve->totvert*sizeof(BezTriple));
|
||||
return newcurve;
|
||||
}
|
||||
|
||||
/** Assign ipo to object object */
|
||||
|
||||
/* macros, see b_interface.h */
|
||||
|
||||
DEF_ASSIGN_IPO(object, Object) // defines object_assignIpo()
|
||||
|
||||
DEF_ASSIGN_IPO(camera, Camera)
|
||||
|
||||
DEF_ASSIGN_IPO(lamp, Lamp)
|
||||
|
||||
DEF_ASSIGN_IPO(material, Material)
|
||||
|
||||
/************************************************************************
|
||||
* Mesh object low level routines
|
||||
*
|
||||
*/
|
||||
|
||||
/** Returns a new, free (non owned) mesh.
|
||||
* add_mesh() automatically returns a mesh object with users = 1,
|
||||
* so we set it to 0. Hack, hack.
|
||||
*/
|
||||
|
||||
Mesh *mesh_new(void)
|
||||
{
|
||||
Mesh *me = add_mesh();
|
||||
((ID *) me)->us = 0;
|
||||
return me;
|
||||
}
|
||||
|
||||
/** updates drawing properties etc. of mesh */
|
||||
|
||||
void mesh_update(Mesh *mesh)
|
||||
{
|
||||
edge_drawflags_mesh(mesh);
|
||||
tex_space_mesh(mesh);
|
||||
}
|
||||
|
||||
/************************************************************************
|
||||
* Scene object low level routines
|
||||
*
|
||||
*/
|
||||
|
||||
/** Returns current Scene */
|
||||
|
||||
Scene *scene_getCurrent(void)
|
||||
{
|
||||
return getGlobal()->scene;
|
||||
}
|
||||
|
||||
/* returns base of object 'object' in Scene 'scene', 0 if nonexistant
|
||||
* A base is basically an visual instantiation of an 3D object (Object)
|
||||
* in a Scene. See scene_linkObject()
|
||||
*
|
||||
*/
|
||||
|
||||
Base *scene_getObjectBase(Scene *scene, Object *object)
|
||||
{
|
||||
Base *base;
|
||||
base = scene->base.first;
|
||||
while (base)
|
||||
{
|
||||
if (object == base->object) // it exists
|
||||
return base;
|
||||
base = base->next;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* links an object into a scene */
|
||||
int scene_linkObject(Scene *scene, Object *object)
|
||||
{
|
||||
Base *base, *b;
|
||||
b = scene_getObjectBase(scene, object);
|
||||
if (b)
|
||||
return 0;
|
||||
base = object_newBase(object);
|
||||
if (!base) {
|
||||
return 0;
|
||||
}
|
||||
BOB_INCUSER((ID *) object); // incref the object
|
||||
BLI_addhead(&scene->base, base);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* unlinks an object from a scene */
|
||||
int scene_unlinkObject(Scene *scene, Object *object)
|
||||
{
|
||||
Base *base;
|
||||
base = scene_getObjectBase(scene, object);
|
||||
if (base) {
|
||||
BLI_remlink(&scene->base, base);
|
||||
BOB_DECUSER((ID *) object);
|
||||
MEM_freeN(base);
|
||||
scene->basact = 0; // make sure the just deleted object has no longer an
|
||||
// active base (which happens if it was selected
|
||||
return 1;
|
||||
}
|
||||
else return 0;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user