Camera tracking integration
[blender.git] / source / blender / blenkernel / intern / object.c
1 /* object.c
2  *
3  * 
4  * $Id$
5  *
6  * ***** BEGIN GPL LICENSE BLOCK *****
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License
10  * as published by the Free Software Foundation; either version 2
11  * of the License, or (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software Foundation,
20  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
21  *
22  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
23  * All rights reserved.
24  *
25  * The Original Code is: all of this file.
26  *
27  * Contributor(s): none yet.
28  *
29  * ***** END GPL LICENSE BLOCK *****
30  */
31
32 /** \file blender/blenkernel/intern/object.c
33  *  \ingroup bke
34  */
35
36
37 #include <string.h>
38 #include <math.h>
39 #include <stdio.h>                      
40
41 #include "MEM_guardedalloc.h"
42
43 #include "DNA_anim_types.h"
44 #include "DNA_armature_types.h"
45 #include "DNA_camera_types.h"
46 #include "DNA_constraint_types.h"
47 #include "DNA_group_types.h"
48 #include "DNA_key_types.h"
49 #include "DNA_lamp_types.h"
50 #include "DNA_lattice_types.h"
51 #include "DNA_material_types.h"
52 #include "DNA_meta_types.h"
53 #include "DNA_meshdata_types.h"
54 #include "DNA_scene_types.h"
55 #include "DNA_screen_types.h"
56 #include "DNA_sequence_types.h"
57 #include "DNA_space_types.h"
58 #include "DNA_view3d_types.h"
59 #include "DNA_world_types.h"
60
61 #include "BLI_blenlib.h"
62 #include "BLI_editVert.h"
63 #include "BLI_math.h"
64 #include "BLI_pbvh.h"
65 #include "BLI_utildefines.h"
66
67 #include "BKE_main.h"
68 #include "BKE_global.h"
69 #include "BKE_idprop.h"
70 #include "BKE_armature.h"
71 #include "BKE_action.h"
72 #include "BKE_bullet.h"
73 #include "BKE_colortools.h"
74 #include "BKE_deform.h"
75 #include "BKE_DerivedMesh.h"
76 #include "BKE_animsys.h"
77 #include "BKE_anim.h"
78 #include "BKE_constraint.h"
79 #include "BKE_curve.h"
80 #include "BKE_displist.h"
81 #include "BKE_effect.h"
82 #include "BKE_fcurve.h"
83 #include "BKE_group.h"
84 #include "BKE_icons.h"
85 #include "BKE_key.h"
86 #include "BKE_lattice.h"
87 #include "BKE_library.h"
88 #include "BKE_mesh.h"
89 #include "BKE_mball.h"
90 #include "BKE_modifier.h"
91 #include "BKE_object.h"
92 #include "BKE_paint.h"
93 #include "BKE_particle.h"
94 #include "BKE_pointcache.h"
95 #include "BKE_property.h"
96 #include "BKE_sca.h"
97 #include "BKE_scene.h"
98 #include "BKE_sequencer.h"
99 #include "BKE_softbody.h"
100 #include "BKE_material.h"
101
102 #include "LBM_fluidsim.h"
103
104 #ifdef WITH_PYTHON
105 #include "BPY_extern.h"
106 #endif
107
108 #include "GPU_material.h"
109
110 /* Local function protos */
111 static void solve_parenting (Scene *scene, Object *ob, Object *par, float obmat[][4], float slowmat[][4], int simul);
112
113 float originmat[3][3];  /* after where_is_object(), can be used in other functions (bad!) */
114
115 void clear_workob(Object *workob)
116 {
117         memset(workob, 0, sizeof(Object));
118         
119         workob->size[0]= workob->size[1]= workob->size[2]= 1.0f;
120         workob->rotmode= ROT_MODE_EUL;
121 }
122
123 void copy_baseflags(struct Scene *scene)
124 {
125         Base *base= scene->base.first;
126         
127         while(base) {
128                 base->object->flag= base->flag;
129                 base= base->next;
130         }
131 }
132
133 void copy_objectflags(struct Scene *scene)
134 {
135         Base *base= scene->base.first;
136         
137         while(base) {
138                 base->flag= base->object->flag;
139                 base= base->next;
140         }
141 }
142
143 void update_base_layer(struct Scene *scene, Object *ob)
144 {
145         Base *base= scene->base.first;
146
147         while (base) {
148                 if (base->object == ob) base->lay= ob->lay;
149                 base= base->next;
150         }
151 }
152
153 void object_free_particlesystems(Object *ob)
154 {
155         while(ob->particlesystem.first){
156                 ParticleSystem *psys = ob->particlesystem.first;
157                 
158                 BLI_remlink(&ob->particlesystem,psys);
159                 
160                 psys_free(ob,psys);
161         }
162 }
163
164 void object_free_softbody(Object *ob)
165 {
166         if(ob->soft) {
167                 sbFree(ob->soft);
168                 ob->soft= NULL;
169         }
170 }
171
172 void object_free_bulletsoftbody(Object *ob)
173 {
174         if(ob->bsoft) {
175                 bsbFree(ob->bsoft);
176                 ob->bsoft= NULL;
177         }
178 }
179
180 void object_free_modifiers(Object *ob)
181 {
182         while (ob->modifiers.first) {
183                 ModifierData *md = ob->modifiers.first;
184                 
185                 BLI_remlink(&ob->modifiers, md);
186                 
187                 modifier_free(md);
188         }
189
190         /* particle modifiers were freed, so free the particlesystems as well */
191         object_free_particlesystems(ob);
192
193         /* same for softbody */
194         object_free_softbody(ob);
195 }
196
197 void object_link_modifiers(struct Object *ob, struct Object *from)
198 {
199         ModifierData *md;
200         object_free_modifiers(ob);
201
202         for (md=from->modifiers.first; md; md=md->next) {
203                 ModifierData *nmd = NULL;
204
205                 if(ELEM4(md->type, eModifierType_Hook, eModifierType_Softbody, eModifierType_ParticleInstance, eModifierType_Collision)) continue;
206
207                 nmd = modifier_new(md->type);
208                 modifier_copyData(md, nmd);
209                 BLI_addtail(&ob->modifiers, nmd);
210         }
211
212         copy_object_particlesystems(ob, from);
213         copy_object_softbody(ob, from);
214
215         // TODO: smoke?, cloth?
216 }
217
218 /* here we will collect all local displist stuff */
219 /* also (ab)used in depsgraph */
220 void object_free_display(Object *ob)
221 {
222         if(ob->derivedDeform) {
223                 ob->derivedDeform->needsFree = 1;
224                 ob->derivedDeform->release(ob->derivedDeform);
225                 ob->derivedDeform= NULL;
226         }
227         if(ob->derivedFinal) {
228                 ob->derivedFinal->needsFree = 1;
229                 ob->derivedFinal->release(ob->derivedFinal);
230                 ob->derivedFinal= NULL;
231         }
232         
233         freedisplist(&ob->disp);
234 }
235
236 void free_sculptsession(Object *ob)
237 {
238         if(ob && ob->sculpt) {
239                 SculptSession *ss = ob->sculpt;
240                 DerivedMesh *dm= ob->derivedFinal;
241
242                 if(ss->pbvh)
243                         BLI_pbvh_free(ss->pbvh);
244                 if(dm && dm->getPBVH)
245                         dm->getPBVH(NULL, dm); /* signal to clear */
246
247                 if(ss->texcache)
248                         MEM_freeN(ss->texcache);
249
250                 if(ss->layer_co)
251                         MEM_freeN(ss->layer_co);
252
253                 if(ss->orig_cos)
254                         MEM_freeN(ss->orig_cos);
255                 if(ss->deform_cos)
256                         MEM_freeN(ss->deform_cos);
257                 if(ss->deform_imats)
258                         MEM_freeN(ss->deform_imats);
259
260                 MEM_freeN(ss);
261
262                 ob->sculpt = NULL;
263         }
264 }
265
266 /* do not free object itself */
267 void free_object(Object *ob)
268 {
269         int a;
270         
271         object_free_display(ob);
272         
273         /* disconnect specific data */
274         if(ob->data) {
275                 ID *id= ob->data;
276                 id->us--;
277                 if(id->us==0) {
278                         if(ob->type==OB_MESH) unlink_mesh(ob->data);
279                         else if(ob->type==OB_CURVE) unlink_curve(ob->data);
280                         else if(ob->type==OB_MBALL) unlink_mball(ob->data);
281                 }
282                 ob->data= NULL;
283         }
284         
285         for(a=0; a<ob->totcol; a++) {
286                 if(ob->mat[a]) ob->mat[a]->id.us--;
287         }
288         if(ob->mat) MEM_freeN(ob->mat);
289         if(ob->matbits) MEM_freeN(ob->matbits);
290         ob->mat= NULL;
291         ob->matbits= NULL;
292         if(ob->bb) MEM_freeN(ob->bb); 
293         ob->bb= NULL;
294         if(ob->path) free_path(ob->path); 
295         ob->path= NULL;
296         if(ob->adt) BKE_free_animdata((ID *)ob);
297         if(ob->poselib) ob->poselib->id.us--;
298         if(ob->gpd) ((ID *)ob->gpd)->us--;
299         if(ob->defbase.first)
300                 BLI_freelistN(&ob->defbase);
301         if(ob->pose)
302                 free_pose(ob->pose);
303         if(ob->mpath)
304                 animviz_free_motionpath(ob->mpath);
305         free_properties(&ob->prop);
306         object_free_modifiers(ob);
307         
308         free_sensors(&ob->sensors);
309         free_controllers(&ob->controllers);
310         free_actuators(&ob->actuators);
311         
312         free_constraints(&ob->constraints);
313         
314         free_partdeflect(ob->pd);
315
316         if(ob->soft) sbFree(ob->soft);
317         if(ob->bsoft) bsbFree(ob->bsoft);
318         if(ob->gpulamp.first) GPU_lamp_free(ob);
319
320         free_sculptsession(ob);
321
322         if(ob->pc_ids.first) BLI_freelistN(&ob->pc_ids);
323 }
324
325 static void unlink_object__unlinkModifierLinks(void *userData, Object *ob, Object **obpoin)
326 {
327         Object *unlinkOb = userData;
328
329         if (*obpoin==unlinkOb) {
330                 *obpoin = NULL;
331                 ob->recalc |= OB_RECALC_OB|OB_RECALC_DATA|OB_RECALC_TIME; // XXX: should this just be OB_RECALC_DATA?
332         }
333 }
334
335 void unlink_object(Object *ob)
336 {
337         Main *bmain= G.main;
338         Object *obt;
339         Material *mat;
340         World *wrld;
341         bScreen *sc;
342         Scene *sce;
343         Curve *cu;
344         Tex *tex;
345         Group *group;
346         Camera *camera;
347         bConstraint *con;
348         //bActionStrip *strip; // XXX animsys 
349         ModifierData *md;
350         ARegion *ar;
351         RegionView3D *rv3d;
352         int a, found;
353         
354         unlink_controllers(&ob->controllers);
355         unlink_actuators(&ob->actuators);
356         
357         /* check all objects: parents en bevels and fields, also from libraries */
358         // FIXME: need to check all animation blocks (drivers)
359         obt= bmain->object.first;
360         while(obt) {
361                 if(obt->proxy==ob)
362                         obt->proxy= NULL;
363                 if(obt->proxy_from==ob) {
364                         obt->proxy_from= NULL;
365                         obt->recalc |= OB_RECALC_OB;
366                 }
367                 if(obt->proxy_group==ob)
368                         obt->proxy_group= NULL;
369                 
370                 if(obt->parent==ob) {
371                         obt->parent= NULL;
372                         obt->recalc |= OB_RECALC_OB|OB_RECALC_DATA|OB_RECALC_TIME;
373                 }
374                 
375                 modifiers_foreachObjectLink(obt, unlink_object__unlinkModifierLinks, ob);
376                 
377                 if ELEM(obt->type, OB_CURVE, OB_FONT) {
378                         cu= obt->data;
379
380                         if(cu->bevobj==ob) {
381                                 cu->bevobj= NULL;
382                                 obt->recalc |= OB_RECALC_OB|OB_RECALC_DATA|OB_RECALC_TIME;
383                         }
384                         if(cu->taperobj==ob) {
385                                 cu->taperobj= NULL;
386                                 obt->recalc |= OB_RECALC_OB|OB_RECALC_DATA|OB_RECALC_TIME;
387                         }
388                         if(cu->textoncurve==ob) {
389                                 cu->textoncurve= NULL;
390                                 obt->recalc |= OB_RECALC_OB|OB_RECALC_DATA|OB_RECALC_TIME;
391                         }
392                 }
393                 else if(obt->type==OB_ARMATURE && obt->pose) {
394                         bPoseChannel *pchan;
395                         for(pchan= obt->pose->chanbase.first; pchan; pchan= pchan->next) {
396                                 for (con = pchan->constraints.first; con; con=con->next) {
397                                         bConstraintTypeInfo *cti= constraint_get_typeinfo(con);
398                                         ListBase targets = {NULL, NULL};
399                                         bConstraintTarget *ct;
400                                         
401                                         if (cti && cti->get_constraint_targets) {
402                                                 cti->get_constraint_targets(con, &targets);
403                                                 
404                                                 for (ct= targets.first; ct; ct= ct->next) {
405                                                         if (ct->tar == ob) {
406                                                                 ct->tar = NULL;
407                                                                 strcpy(ct->subtarget, "");
408                                                                 obt->recalc |= OB_RECALC_DATA;
409                                                         }
410                                                 }
411                                                 
412                                                 if (cti->flush_constraint_targets)
413                                                         cti->flush_constraint_targets(con, &targets, 0);
414                                         }
415                                 }
416                                 if(pchan->custom==ob)
417                                         pchan->custom= NULL;
418                         }
419                 } else if(ELEM(OB_MBALL, ob->type, obt->type)) {
420                         if(is_mball_basis_for(obt, ob))
421                                 obt->recalc|= OB_RECALC_DATA;
422                 }
423                 
424                 sca_remove_ob_poin(obt, ob);
425                 
426                 for (con = obt->constraints.first; con; con=con->next) {
427                         bConstraintTypeInfo *cti= constraint_get_typeinfo(con);
428                         ListBase targets = {NULL, NULL};
429                         bConstraintTarget *ct;
430                         
431                         if (cti && cti->get_constraint_targets) {
432                                 cti->get_constraint_targets(con, &targets);
433                                 
434                                 for (ct= targets.first; ct; ct= ct->next) {
435                                         if (ct->tar == ob) {
436                                                 ct->tar = NULL;
437                                                 strcpy(ct->subtarget, "");
438                                                 obt->recalc |= OB_RECALC_DATA;
439                                         }
440                                 }
441                                 
442                                 if (cti->flush_constraint_targets)
443                                         cti->flush_constraint_targets(con, &targets, 0);
444                         }
445                 }
446                 
447                 /* object is deflector or field */
448                 if(ob->pd) {
449                         if(obt->soft)
450                                 obt->recalc |= OB_RECALC_DATA;
451
452                         /* cloth */
453                         for(md=obt->modifiers.first; md; md=md->next)
454                                 if(md->type == eModifierType_Cloth)
455                                         obt->recalc |= OB_RECALC_DATA;
456                 }
457                 
458                 /* strips */
459 #if 0 // XXX old animation system
460                 for(strip= obt->nlastrips.first; strip; strip= strip->next) {
461                         if(strip->object==ob)
462                                 strip->object= NULL;
463                         
464                         if(strip->modifiers.first) {
465                                 bActionModifier *amod;
466                                 for(amod= strip->modifiers.first; amod; amod= amod->next)
467                                         if(amod->ob==ob)
468                                                 amod->ob= NULL;
469                         }
470                 }
471 #endif // XXX old animation system
472
473                 /* particle systems */
474                 if(obt->particlesystem.first) {
475                         ParticleSystem *tpsys= obt->particlesystem.first;
476                         for(; tpsys; tpsys=tpsys->next) {
477                                 BoidState *state = NULL;
478                                 BoidRule *rule = NULL;
479
480                                 ParticleTarget *pt = tpsys->targets.first;
481                                 for(; pt; pt=pt->next) {
482                                         if(pt->ob==ob) {
483                                                 pt->ob = NULL;
484                                                 obt->recalc |= OB_RECALC_DATA;
485                                                 break;
486                                         }
487                                 }
488
489                                 if(tpsys->target_ob==ob) {
490                                         tpsys->target_ob= NULL;
491                                         obt->recalc |= OB_RECALC_DATA;
492                                 }
493
494                                 if(tpsys->part->dup_ob==ob)
495                                         tpsys->part->dup_ob= NULL;
496
497                                 if(tpsys->part->phystype==PART_PHYS_BOIDS) {
498                                         ParticleData *pa;
499                                         BoidParticle *bpa;
500                                         int p;
501
502                                         for(p=0,pa=tpsys->particles; p<tpsys->totpart; p++,pa++) {
503                                                 bpa = pa->boid;
504                                                 if(bpa->ground == ob)
505                                                         bpa->ground = NULL;
506                                         }
507                                 }
508                                 if(tpsys->part->boids) {
509                                         for(state = tpsys->part->boids->states.first; state; state=state->next) {
510                                                 for(rule = state->rules.first; rule; rule=rule->next) {
511                                                         if(rule->type==eBoidRuleType_Avoid) {
512                                                                 BoidRuleGoalAvoid *gabr = (BoidRuleGoalAvoid*)rule;
513                                                                 if(gabr->ob==ob)
514                                                                         gabr->ob= NULL;
515                                                         }
516                                                         else if(rule->type==eBoidRuleType_FollowLeader) {
517                                                                 BoidRuleFollowLeader *flbr = (BoidRuleFollowLeader*)rule;
518                                                                 if(flbr->ob==ob)
519                                                                         flbr->ob= NULL;
520                                                         }
521                                                 }
522                                         }
523                                 }
524                         }
525                         if(ob->pd)
526                                 obt->recalc |= OB_RECALC_DATA;
527                 }
528
529                 obt= obt->id.next;
530         }
531         
532         /* materials */
533         mat= bmain->mat.first;
534         while(mat) {
535         
536                 for(a=0; a<MAX_MTEX; a++) {
537                         if(mat->mtex[a] && ob==mat->mtex[a]->object) {
538                                 /* actually, test for lib here... to do */
539                                 mat->mtex[a]->object= NULL;
540                         }
541                 }
542
543                 mat= mat->id.next;
544         }
545         
546         /* textures */
547         for(tex= bmain->tex.first; tex; tex= tex->id.next) {
548                 if(tex->env && (ob==tex->env->object)) tex->env->object= NULL;
549                 if(tex->pd  && (ob==tex->pd->object))  tex->pd->object= NULL;
550                 if(tex->vd  && (ob==tex->vd->object))  tex->vd->object= NULL;
551         }
552
553         /* worlds */
554         wrld= bmain->world.first;
555         while(wrld) {
556                 if(wrld->id.lib==NULL) {
557                         for(a=0; a<MAX_MTEX; a++) {
558                                 if(wrld->mtex[a] && ob==wrld->mtex[a]->object)
559                                         wrld->mtex[a]->object= NULL;
560                         }
561                 }
562                 
563                 wrld= wrld->id.next;
564         }
565                 
566         /* scenes */
567         sce= bmain->scene.first;
568         while(sce) {
569                 if(sce->id.lib==NULL) {
570                         if(sce->camera==ob) sce->camera= NULL;
571                         if(sce->toolsettings->skgen_template==ob) sce->toolsettings->skgen_template = NULL;
572                         if(sce->toolsettings->particle.object==ob) sce->toolsettings->particle.object= NULL;
573
574 #ifdef DURIAN_CAMERA_SWITCH
575                         {
576                                 TimeMarker *m;
577
578                                 for (m= sce->markers.first; m; m= m->next) {
579                                         if(m->camera==ob)
580                                                 m->camera= NULL;
581                                 }
582                         }
583 #endif
584                         if(sce->ed) {
585                                 Sequence *seq;
586                                 SEQ_BEGIN(sce->ed, seq)
587                                         if(seq->scene_camera==ob) {
588                                                 seq->scene_camera= NULL;
589                                         }
590                                 SEQ_END
591                         }
592                 }
593
594                 sce= sce->id.next;
595         }
596         
597 #if 0 // XXX old animation system
598         /* ipos */
599         ipo= bmain->ipo.first;
600         while(ipo) {
601                 if(ipo->id.lib==NULL) {
602                         IpoCurve *icu;
603                         for(icu= ipo->curve.first; icu; icu= icu->next) {
604                                 if(icu->driver && icu->driver->ob==ob)
605                                         icu->driver->ob= NULL;
606                         }
607                 }
608                 ipo= ipo->id.next;
609         }
610 #endif // XXX old animation system
611         
612         /* screens */
613         sc= bmain->screen.first;
614         while(sc) {
615                 ScrArea *sa= sc->areabase.first;
616                 while(sa) {
617                         SpaceLink *sl;
618
619                         for (sl= sa->spacedata.first; sl; sl= sl->next) {
620                                 if(sl->spacetype==SPACE_VIEW3D) {
621                                         View3D *v3d= (View3D*) sl;
622
623                                         found= 0;
624                                         if(v3d->camera==ob) {
625                                                 v3d->camera= NULL;
626                                                 found= 1;
627                                         }
628                                         if(v3d->localvd && v3d->localvd->camera==ob ) {
629                                                 v3d->localvd->camera= NULL;
630                                                 found += 2;
631                                         }
632
633                                         if (found) {
634                                                 if (sa->spacetype == SPACE_VIEW3D) {
635                                                         for (ar= sa->regionbase.first; ar; ar= ar->next) {
636                                                                 if (ar->regiontype==RGN_TYPE_WINDOW) {
637                                                                         rv3d= (RegionView3D *)ar->regiondata;
638                                                                         if (found == 1 || found == 3) {
639                                                                                 if (rv3d->persp == RV3D_CAMOB)
640                                                                                         rv3d->persp= RV3D_PERSP;
641                                                                         }
642                                                                         if (found == 2 || found == 3) {
643                                                                                 if (rv3d->localvd && rv3d->localvd->persp == RV3D_CAMOB)
644                                                                                         rv3d->localvd->persp= RV3D_PERSP;
645                                                                         }
646                                                                 }
647                                                         }
648                                                 }
649                                         }
650                                 }
651                                 else if(sl->spacetype==SPACE_OUTLINER) {
652                                         SpaceOops *so= (SpaceOops *)sl;
653
654                                         if(so->treestore) {
655                                                 TreeStoreElem *tselem= so->treestore->data;
656                                                 int a;
657                                                 for(a=0; a<so->treestore->usedelem; a++, tselem++) {
658                                                         if(tselem->id==(ID *)ob) tselem->id= NULL;
659                                                 }
660                                         }
661                                 }
662                                 else if(sl->spacetype==SPACE_BUTS) {
663                                         SpaceButs *sbuts= (SpaceButs *)sl;
664
665                                         if(sbuts->pinid==(ID *)ob) {
666                                                 sbuts->flag&= ~SB_PIN_CONTEXT;
667                                                 sbuts->pinid= NULL;
668                                         }
669                                 }
670                         }
671
672                         sa= sa->next;
673                 }
674                 sc= sc->id.next;
675         }
676
677         /* groups */
678         group= bmain->group.first;
679         while(group) {
680                 rem_from_group(group, ob, NULL, NULL);
681                 group= group->id.next;
682         }
683         
684         /* cameras */
685         camera= bmain->camera.first;
686         while(camera) {
687                 if (camera->dof_ob==ob) {
688                         camera->dof_ob = NULL;
689                 }
690                 camera= camera->id.next;
691         }
692 }
693
694 int exist_object(Object *obtest)
695 {
696         Object *ob;
697         
698         if(obtest==NULL) return 0;
699         
700         ob= G.main->object.first;
701         while(ob) {
702                 if(ob==obtest) return 1;
703                 ob= ob->id.next;
704         }
705         return 0;
706 }
707
708 void *add_camera(const char *name)
709 {
710         Camera *cam;
711         
712         cam=  alloc_libblock(&G.main->camera, ID_CA, name);
713
714         cam->lens= 35.0f;
715         cam->sensor_x = 32.f;
716         cam->clipsta= 0.1f;
717         cam->clipend= 100.0f;
718         cam->drawsize= 0.5f;
719         cam->ortho_scale= 6.0;
720         cam->flag |= CAM_SHOWPASSEPARTOUT;
721         cam->passepartalpha = 0.5f;
722         
723         return cam;
724 }
725
726 Camera *copy_camera(Camera *cam)
727 {
728         Camera *camn;
729         
730         camn= copy_libblock(cam);
731         
732         return camn;
733 }
734
735
736
737 void make_local_camera(Camera *cam)
738 {
739         Main *bmain= G.main;
740         Object *ob;
741         int local=0, lib=0;
742
743         /* - only lib users: do nothing
744          * - only local users: set flag
745          * - mixed: make copy
746          */
747         
748         if(cam->id.lib==NULL) return;
749         if(cam->id.us==1) {
750                 cam->id.lib= NULL;
751                 cam->id.flag= LIB_LOCAL;
752                 new_id(&bmain->camera, (ID *)cam, NULL);
753                 return;
754         }
755         
756         for(ob= bmain->object.first; ob && ELEM(0, lib, local); ob= ob->id.next) {
757                 if(ob->data==cam) {
758                         if(ob->id.lib) lib= 1;
759                         else local= 1;
760                 }
761         }
762         
763         if(local && lib==0) {
764                 cam->id.lib= NULL;
765                 cam->id.flag= LIB_LOCAL;
766                 new_id(&bmain->camera, (ID *)cam, NULL);
767         }
768         else if(local && lib) {
769                 Camera *camn= copy_camera(cam);
770                 camn->id.us= 0;
771                 
772                 for(ob= bmain->object.first; ob; ob= ob->id.next) {
773                         if(ob->data == cam) {
774                                 if(ob->id.lib==NULL) {
775                                         ob->data= camn;
776                                         camn->id.us++;
777                                         cam->id.us--;
778                                 }
779                         }
780                 }
781         }
782 }
783
784 /* get the camera's dof value, takes the dof object into account */
785 float dof_camera(Object *ob)
786 {
787         Camera *cam = (Camera *)ob->data; 
788         if (ob->type != OB_CAMERA)
789                 return 0.0f;
790         if (cam->dof_ob) {      
791                 /* too simple, better to return the distance on the view axis only
792                  * return len_v3v3(ob->obmat[3], cam->dof_ob->obmat[3]); */
793                 float mat[4][4], imat[4][4], obmat[4][4];
794                 
795                 copy_m4_m4(obmat, ob->obmat);
796                 normalize_m4(obmat);
797                 invert_m4_m4(imat, obmat);
798                 mul_m4_m4m4(mat, cam->dof_ob->obmat, imat);
799                 return (float)fabs(mat[3][2]);
800         }
801         return cam->YF_dofdist;
802 }
803
804 void *add_lamp(const char *name)
805 {
806         Lamp *la;
807         
808         la=  alloc_libblock(&G.main->lamp, ID_LA, name);
809         
810         la->r= la->g= la->b= la->k= 1.0f;
811         la->haint= la->energy= 1.0f;
812         la->dist= 25.0f;
813         la->spotsize= 45.0f;
814         la->spotblend= 0.15f;
815         la->att2= 1.0f;
816         la->mode= LA_SHAD_BUF;
817         la->bufsize= 512;
818         la->clipsta= 0.5f;
819         la->clipend= 40.0f;
820         la->shadspotsize= 45.0f;
821         la->samp= 3;
822         la->bias= 1.0f;
823         la->soft= 3.0f;
824         la->compressthresh= 0.05f;
825         la->ray_samp= la->ray_sampy= la->ray_sampz= 1; 
826         la->area_size=la->area_sizey=la->area_sizez= 1.0f; 
827         la->buffers= 1;
828         la->buftype= LA_SHADBUF_HALFWAY;
829         la->ray_samp_method = LA_SAMP_HALTON;
830         la->adapt_thresh = 0.001f;
831         la->preview=NULL;
832         la->falloff_type = LA_FALLOFF_INVSQUARE;
833         la->curfalloff = curvemapping_add(1, 0.0f, 1.0f, 1.0f, 0.0f);
834         la->sun_effect_type = 0;
835         la->horizon_brightness = 1.0;
836         la->spread = 1.0;
837         la->sun_brightness = 1.0;
838         la->sun_size = 1.0;
839         la->backscattered_light = 1.0f;
840         la->atm_turbidity = 2.0f;
841         la->atm_inscattering_factor = 1.0f;
842         la->atm_extinction_factor = 1.0f;
843         la->atm_distance_factor = 1.0f;
844         la->sun_intensity = 1.0f;
845         la->skyblendtype= MA_RAMP_ADD;
846         la->skyblendfac= 1.0f;
847         la->sky_colorspace= BLI_XYZ_CIE;
848         la->sky_exposure= 1.0f;
849         
850         curvemapping_initialize(la->curfalloff);
851         return la;
852 }
853
854 Lamp *copy_lamp(Lamp *la)
855 {
856         Lamp *lan;
857         int a;
858         
859         lan= copy_libblock(la);
860
861         for(a=0; a<MAX_MTEX; a++) {
862                 if(lan->mtex[a]) {
863                         lan->mtex[a]= MEM_mallocN(sizeof(MTex), "copylamptex");
864                         memcpy(lan->mtex[a], la->mtex[a], sizeof(MTex));
865                         id_us_plus((ID *)lan->mtex[a]->tex);
866                 }
867         }
868         
869         lan->curfalloff = curvemapping_copy(la->curfalloff);
870         
871         if(la->preview)
872                 lan->preview = BKE_previewimg_copy(la->preview);
873         
874         return lan;
875 }
876
877 Lamp *localize_lamp(Lamp *la)
878 {
879         Lamp *lan;
880         int a;
881         
882         lan= copy_libblock(la);
883         BLI_remlink(&G.main->lamp, lan);
884
885         for(a=0; a<MAX_MTEX; a++) {
886                 if(lan->mtex[a]) {
887                         lan->mtex[a]= MEM_mallocN(sizeof(MTex), "localize_lamp");
888                         memcpy(lan->mtex[a], la->mtex[a], sizeof(MTex));
889                         /* free lamp decrements */
890                         id_us_plus((ID *)lan->mtex[a]->tex);
891                 }
892         }
893         
894         lan->curfalloff = curvemapping_copy(la->curfalloff);
895
896         lan->preview= NULL;
897         
898         return lan;
899 }
900
901 void make_local_lamp(Lamp *la)
902 {
903         Main *bmain= G.main;
904         Object *ob;
905         Lamp *lan;
906         int local=0, lib=0;
907
908         /* - only lib users: do nothing
909                 * - only local users: set flag
910                 * - mixed: make copy
911                 */
912         
913         if(la->id.lib==NULL) return;
914         if(la->id.us==1) {
915                 la->id.lib= NULL;
916                 la->id.flag= LIB_LOCAL;
917                 new_id(&bmain->lamp, (ID *)la, NULL);
918                 return;
919         }
920         
921         ob= bmain->object.first;
922         while(ob) {
923                 if(ob->data==la) {
924                         if(ob->id.lib) lib= 1;
925                         else local= 1;
926                 }
927                 ob= ob->id.next;
928         }
929         
930         if(local && lib==0) {
931                 la->id.lib= NULL;
932                 la->id.flag= LIB_LOCAL;
933                 new_id(&bmain->lamp, (ID *)la, NULL);
934         }
935         else if(local && lib) {
936                 lan= copy_lamp(la);
937                 lan->id.us= 0;
938                 
939                 ob= bmain->object.first;
940                 while(ob) {
941                         if(ob->data==la) {
942                                 
943                                 if(ob->id.lib==NULL) {
944                                         ob->data= lan;
945                                         lan->id.us++;
946                                         la->id.us--;
947                                 }
948                         }
949                         ob= ob->id.next;
950                 }
951         }
952 }
953
954 void free_camera(Camera *ca)
955 {
956         BKE_free_animdata((ID *)ca);
957 }
958
959 void free_lamp(Lamp *la)
960 {
961         MTex *mtex;
962         int a;
963
964         for(a=0; a<MAX_MTEX; a++) {
965                 mtex= la->mtex[a];
966                 if(mtex && mtex->tex) mtex->tex->id.us--;
967                 if(mtex) MEM_freeN(mtex);
968         }
969         
970         BKE_free_animdata((ID *)la);
971
972         curvemapping_free(la->curfalloff);
973         
974         BKE_previewimg_free(&la->preview);
975         BKE_icon_delete(&la->id);
976         la->id.icon_id = 0;
977 }
978
979 /* *************************************************** */
980
981 static void *add_obdata_from_type(int type)
982 {
983         switch (type) {
984         case OB_MESH: return add_mesh("Mesh");
985         case OB_CURVE: return add_curve("Curve", OB_CURVE);
986         case OB_SURF: return add_curve("Surf", OB_SURF);
987         case OB_FONT: return add_curve("Text", OB_FONT);
988         case OB_MBALL: return add_mball("Meta");
989         case OB_CAMERA: return add_camera("Camera");
990         case OB_LAMP: return add_lamp("Lamp");
991         case OB_LATTICE: return add_lattice("Lattice");
992         case OB_ARMATURE: return add_armature("Armature");
993         case OB_EMPTY: return NULL;
994         default:
995                 printf("add_obdata_from_type: Internal error, bad type: %d\n", type);
996                 return NULL;
997         }
998 }
999
1000 static const char *get_obdata_defname(int type)
1001 {
1002         switch (type) {
1003         case OB_MESH: return "Mesh";
1004         case OB_CURVE: return "Curve";
1005         case OB_SURF: return "Surf";
1006         case OB_FONT: return "Text";
1007         case OB_MBALL: return "Mball";
1008         case OB_CAMERA: return "Camera";
1009         case OB_LAMP: return "Lamp";
1010         case OB_LATTICE: return "Lattice";
1011         case OB_ARMATURE: return "Armature";
1012         case OB_EMPTY: return "Empty";
1013         default:
1014                 printf("get_obdata_defname: Internal error, bad type: %d\n", type);
1015                 return "Empty";
1016         }
1017 }
1018
1019 /* more general add: creates minimum required data, but without vertices etc. */
1020 Object *add_only_object(int type, const char *name)
1021 {
1022         Object *ob;
1023
1024         ob= alloc_libblock(&G.main->object, ID_OB, name);
1025
1026         /* default object vars */
1027         ob->type= type;
1028         
1029         ob->col[0]= ob->col[1]= ob->col[2]= 1.0;
1030         ob->col[3]= 1.0;
1031         
1032         ob->size[0]= ob->size[1]= ob->size[2]= 1.0;
1033         
1034         /* objects should default to having Euler XYZ rotations, 
1035          * but rotations default to quaternions 
1036          */
1037         ob->rotmode= ROT_MODE_EUL;
1038
1039         unit_axis_angle(ob->rotAxis, &ob->rotAngle);
1040         unit_axis_angle(ob->drotAxis, &ob->drotAngle);
1041
1042         unit_qt(ob->quat);
1043         unit_qt(ob->dquat);
1044
1045         /* rotation locks should be 4D for 4 component rotations by default... */
1046         ob->protectflag = OB_LOCK_ROT4D;
1047         
1048         unit_m4(ob->constinv);
1049         unit_m4(ob->parentinv);
1050         unit_m4(ob->obmat);
1051         ob->dt= OB_TEXTURE;
1052         ob->empty_drawtype= OB_PLAINAXES;
1053         ob->empty_drawsize= 1.0;
1054
1055         if(type==OB_CAMERA || type==OB_LAMP) {
1056                 ob->trackflag= OB_NEGZ;
1057                 ob->upflag= OB_POSY;
1058         }
1059         else {
1060                 ob->trackflag= OB_POSY;
1061                 ob->upflag= OB_POSZ;
1062         }
1063         
1064         ob->dupon= 1; ob->dupoff= 0;
1065         ob->dupsta= 1; ob->dupend= 100;
1066         ob->dupfacesca = 1.0;
1067
1068         /* Game engine defaults*/
1069         ob->mass= ob->inertia= 1.0f;
1070         ob->formfactor= 0.4f;
1071         ob->damping= 0.04f;
1072         ob->rdamping= 0.1f;
1073         ob->anisotropicFriction[0] = 1.0f;
1074         ob->anisotropicFriction[1] = 1.0f;
1075         ob->anisotropicFriction[2] = 1.0f;
1076         ob->gameflag= OB_PROP|OB_COLLISION;
1077         ob->margin = 0.0;
1078         ob->init_state=1;
1079         ob->state=1;
1080         /* ob->pad3 == Contact Processing Threshold */
1081         ob->m_contactProcessingThreshold = 1.;
1082         
1083         /* NT fluid sim defaults */
1084         ob->fluidsimFlag = 0;
1085         ob->fluidsimSettings = NULL;
1086
1087         ob->pc_ids.first = ob->pc_ids.last = NULL;
1088         
1089         /* Animation Visualisation defaults */
1090         animviz_settings_init(&ob->avs);
1091
1092         return ob;
1093 }
1094
1095 /* general add: to scene, with layer from area and default name */
1096 /* creates minimum required data, but without vertices etc. */
1097 Object *add_object(struct Scene *scene, int type)
1098 {
1099         Object *ob;
1100         Base *base;
1101         char name[32];
1102
1103         BLI_strncpy(name, get_obdata_defname(type), sizeof(name));
1104         ob = add_only_object(type, name);
1105
1106         ob->data= add_obdata_from_type(type);
1107
1108         ob->lay= scene->lay;
1109         
1110         base= scene_add_base(scene, ob);
1111         scene_select_base(scene, base);
1112         ob->recalc |= OB_RECALC_OB|OB_RECALC_DATA|OB_RECALC_TIME;
1113
1114         return ob;
1115 }
1116
1117 SoftBody *copy_softbody(SoftBody *sb)
1118 {
1119         SoftBody *sbn;
1120         
1121         if (sb==NULL) return(NULL);
1122         
1123         sbn= MEM_dupallocN(sb);
1124         sbn->totspring= sbn->totpoint= 0;
1125         sbn->bpoint= NULL;
1126         sbn->bspring= NULL;
1127         
1128         sbn->keys= NULL;
1129         sbn->totkey= sbn->totpointkey= 0;
1130         
1131         sbn->scratch= NULL;
1132
1133         sbn->pointcache= BKE_ptcache_copy_list(&sbn->ptcaches, &sb->ptcaches);
1134
1135         if(sb->effector_weights)
1136                 sbn->effector_weights = MEM_dupallocN(sb->effector_weights);
1137
1138         return sbn;
1139 }
1140
1141 BulletSoftBody *copy_bulletsoftbody(BulletSoftBody *bsb)
1142 {
1143         BulletSoftBody *bsbn;
1144
1145         if (bsb == NULL)
1146                 return NULL;
1147         bsbn = MEM_dupallocN(bsb);
1148         /* no pointer in this structure yet */
1149         return bsbn;
1150 }
1151
1152 static ParticleSystem *copy_particlesystem(ParticleSystem *psys)
1153 {
1154         ParticleSystem *psysn;
1155         ParticleData *pa;
1156         int p;
1157
1158         psysn= MEM_dupallocN(psys);
1159         psysn->particles= MEM_dupallocN(psys->particles);
1160         psysn->child= MEM_dupallocN(psys->child);
1161
1162         if(psys->part->type == PART_HAIR) {
1163                 for(p=0, pa=psysn->particles; p<psysn->totpart; p++, pa++)
1164                         pa->hair = MEM_dupallocN(pa->hair);
1165         }
1166
1167         if(psysn->particles && (psysn->particles->keys || psysn->particles->boid)) {
1168                 ParticleKey *key = psysn->particles->keys;
1169                 BoidParticle *boid = psysn->particles->boid;
1170
1171                 if(key)
1172                         key = MEM_dupallocN(key);
1173                 
1174                 if(boid)
1175                         boid = MEM_dupallocN(boid);
1176                 
1177                 for(p=0, pa=psysn->particles; p<psysn->totpart; p++, pa++) {
1178                         if(boid)
1179                                 pa->boid = boid++;
1180                         if(key) {
1181                                 pa->keys = key;
1182                                 key += pa->totkey;
1183                         }
1184                 }
1185         }
1186
1187         if(psys->clmd) {
1188                 psysn->clmd = (ClothModifierData *)modifier_new(eModifierType_Cloth);
1189                 modifier_copyData((ModifierData*)psys->clmd, (ModifierData*)psysn->clmd);
1190                 psys->hair_in_dm = psys->hair_out_dm = NULL;
1191         }
1192
1193         BLI_duplicatelist(&psysn->targets, &psys->targets);
1194
1195         psysn->pathcache= NULL;
1196         psysn->childcache= NULL;
1197         psysn->edit= NULL;
1198         psysn->frand= NULL;
1199         psysn->pdd= NULL;
1200         psysn->effectors= NULL;
1201         
1202         psysn->pathcachebufs.first = psysn->pathcachebufs.last = NULL;
1203         psysn->childcachebufs.first = psysn->childcachebufs.last = NULL;
1204         psysn->renderdata = NULL;
1205         
1206         psysn->pointcache= BKE_ptcache_copy_list(&psysn->ptcaches, &psys->ptcaches);
1207
1208         /* XXX - from reading existing code this seems correct but intended usage of
1209          * pointcache should /w cloth should be added in 'ParticleSystem' - campbell */
1210         if(psysn->clmd) {
1211                 psysn->clmd->point_cache= psysn->pointcache;
1212         }
1213
1214         id_us_plus((ID *)psysn->part);
1215
1216         return psysn;
1217 }
1218
1219 void copy_object_particlesystems(Object *obn, Object *ob)
1220 {
1221         ParticleSystemModifierData *psmd;
1222         ParticleSystem *psys, *npsys;
1223         ModifierData *md;
1224
1225         obn->particlesystem.first= obn->particlesystem.last= NULL;
1226         for(psys=ob->particlesystem.first; psys; psys=psys->next) {
1227                 npsys= copy_particlesystem(psys);
1228
1229                 BLI_addtail(&obn->particlesystem, npsys);
1230
1231                 /* need to update particle modifiers too */
1232                 for(md=obn->modifiers.first; md; md=md->next) {
1233                         if(md->type==eModifierType_ParticleSystem) {
1234                                 psmd= (ParticleSystemModifierData*)md;
1235                                 if(psmd->psys==psys)
1236                                         psmd->psys= npsys;
1237                         }
1238                 }
1239         }
1240 }
1241
1242 void copy_object_softbody(Object *obn, Object *ob)
1243 {
1244         if(ob->soft)
1245                 obn->soft= copy_softbody(ob->soft);
1246 }
1247
1248 static void copy_object_pose(Object *obn, Object *ob)
1249 {
1250         bPoseChannel *chan;
1251         
1252         /* note: need to clear obn->pose pointer first, so that copy_pose works (otherwise there's a crash) */
1253         obn->pose= NULL;
1254         copy_pose(&obn->pose, ob->pose, 1);     /* 1 = copy constraints */
1255
1256         for (chan = obn->pose->chanbase.first; chan; chan=chan->next){
1257                 bConstraint *con;
1258                 
1259                 chan->flag &= ~(POSE_LOC|POSE_ROT|POSE_SIZE);
1260                 
1261                 for (con= chan->constraints.first; con; con= con->next) {
1262                         bConstraintTypeInfo *cti= constraint_get_typeinfo(con);
1263                         ListBase targets = {NULL, NULL};
1264                         bConstraintTarget *ct;
1265                         
1266 #if 0 // XXX old animation system
1267                         /* note that we can't change lib linked ipo blocks. for making
1268                          * proxies this still works correct however because the object
1269                          * is changed to object->proxy_from when evaluating the driver. */
1270                         if(con->ipo && !con->ipo->id.lib) {
1271                                 IpoCurve *icu;
1272                                 
1273                                 con->ipo= copy_ipo(con->ipo);
1274                                 
1275                                 for(icu= con->ipo->curve.first; icu; icu= icu->next) {
1276                                         if(icu->driver && icu->driver->ob==ob)
1277                                                 icu->driver->ob= obn;
1278                                 }
1279                         }
1280 #endif // XXX old animation system
1281                         
1282                         if (cti && cti->get_constraint_targets) {
1283                                 cti->get_constraint_targets(con, &targets);
1284                                 
1285                                 for (ct= targets.first; ct; ct= ct->next) {
1286                                         if (ct->tar == ob)
1287                                                 ct->tar = obn;
1288                                 }
1289                                 
1290                                 if (cti->flush_constraint_targets)
1291                                         cti->flush_constraint_targets(con, &targets, 0);
1292                         }
1293                 }
1294         }
1295 }
1296
1297 static void copy_object_transform(Object *ob_tar, Object *ob_src)
1298 {
1299         copy_v3_v3(ob_tar->loc, ob_src->loc);
1300         copy_v3_v3(ob_tar->rot, ob_src->rot);
1301         copy_v3_v3(ob_tar->quat, ob_src->quat);
1302         copy_v3_v3(ob_tar->rotAxis, ob_src->rotAxis);
1303         ob_tar->rotAngle= ob_src->rotAngle;
1304         ob_tar->rotmode= ob_src->rotmode;
1305         copy_v3_v3(ob_tar->size, ob_src->size);
1306 }
1307
1308 Object *copy_object(Object *ob)
1309 {
1310         Object *obn;
1311         ModifierData *md;
1312         int a;
1313
1314         obn= copy_libblock(ob);
1315         
1316         if(ob->totcol) {
1317                 obn->mat= MEM_dupallocN(ob->mat);
1318                 obn->matbits= MEM_dupallocN(ob->matbits);
1319                 obn->totcol= ob->totcol;
1320         }
1321         
1322         if(ob->bb) obn->bb= MEM_dupallocN(ob->bb);
1323         obn->path= NULL;
1324         obn->flag &= ~OB_FROMGROUP;
1325         
1326         obn->modifiers.first = obn->modifiers.last= NULL;
1327         
1328         for (md=ob->modifiers.first; md; md=md->next) {
1329                 ModifierData *nmd = modifier_new(md->type);
1330                 BLI_strncpy(nmd->name, md->name, sizeof(nmd->name));
1331                 modifier_copyData(md, nmd);
1332                 BLI_addtail(&obn->modifiers, nmd);
1333         }
1334
1335         obn->prop.first = obn->prop.last = NULL;
1336         copy_properties(&obn->prop, &ob->prop);
1337         
1338         copy_sensors(&obn->sensors, &ob->sensors);
1339         copy_controllers(&obn->controllers, &ob->controllers);
1340         copy_actuators(&obn->actuators, &ob->actuators);
1341         
1342         if(ob->pose) {
1343                 copy_object_pose(obn, ob);
1344                 /* backwards compat... non-armatures can get poses in older files? */
1345                 if(ob->type==OB_ARMATURE)
1346                         armature_rebuild_pose(obn, obn->data);
1347         }
1348         defgroup_copy_list(&obn->defbase, &ob->defbase);
1349         copy_constraints(&obn->constraints, &ob->constraints, TRUE);
1350
1351         obn->mode = 0;
1352         obn->sculpt = NULL;
1353
1354         /* increase user numbers */
1355         id_us_plus((ID *)obn->data);
1356         id_us_plus((ID *)obn->gpd);
1357         id_lib_extern((ID *)obn->dup_group);
1358
1359         for(a=0; a<obn->totcol; a++) id_us_plus((ID *)obn->mat[a]);
1360         
1361         obn->disp.first= obn->disp.last= NULL;
1362         
1363         if(ob->pd){
1364                 obn->pd= MEM_dupallocN(ob->pd);
1365                 if(obn->pd->tex)
1366                         id_us_plus(&(obn->pd->tex->id));
1367                 if(obn->pd->rng)
1368                         obn->pd->rng = MEM_dupallocN(ob->pd->rng);
1369         }
1370         obn->soft= copy_softbody(ob->soft);
1371         obn->bsoft = copy_bulletsoftbody(ob->bsoft);
1372
1373         copy_object_particlesystems(obn, ob);
1374         
1375         obn->derivedDeform = NULL;
1376         obn->derivedFinal = NULL;
1377
1378         obn->gpulamp.first = obn->gpulamp.last = NULL;
1379         obn->pc_ids.first = obn->pc_ids.last = NULL;
1380
1381         obn->mpath= NULL;
1382         
1383         return obn;
1384 }
1385
1386 static void extern_local_object(Object *ob)
1387 {
1388         //bActionStrip *strip;
1389         ParticleSystem *psys;
1390
1391 #if 0 // XXX old animation system
1392         id_lib_extern((ID *)ob->action);
1393         id_lib_extern((ID *)ob->ipo);
1394 #endif // XXX old animation system
1395         id_lib_extern((ID *)ob->data);
1396         id_lib_extern((ID *)ob->dup_group);
1397         id_lib_extern((ID *)ob->poselib);
1398         id_lib_extern((ID *)ob->gpd);
1399
1400         extern_local_matarar(ob->mat, ob->totcol);
1401
1402 #if 0 // XXX old animation system
1403         for (strip=ob->nlastrips.first; strip; strip=strip->next) {
1404                 id_lib_extern((ID *)strip->act);
1405         }
1406 #endif // XXX old animation system
1407         for(psys=ob->particlesystem.first; psys; psys=psys->next)
1408                 id_lib_extern((ID *)psys->part);
1409 }
1410
1411 void make_local_object(Object *ob)
1412 {
1413         Main *bmain= G.main;
1414         Scene *sce;
1415         Base *base;
1416         int local=0, lib=0;
1417
1418         /* - only lib users: do nothing
1419          * - only local users: set flag
1420          * - mixed: make copy
1421          */
1422
1423         if(ob->id.lib==NULL) return;
1424         
1425         ob->proxy= ob->proxy_from= NULL;
1426         
1427         if(ob->id.us==1) {
1428                 ob->id.lib= NULL;
1429                 ob->id.flag= LIB_LOCAL;
1430                 new_id(&bmain->object, (ID *)ob, NULL);
1431         }
1432         else {
1433                 for(sce= bmain->scene.first; sce && ELEM(0, lib, local); sce= sce->id.next) {
1434                         if(object_in_scene(ob, sce)) {
1435                                 if(sce->id.lib) lib= 1;
1436                                 else local= 1;
1437                         }
1438                 }
1439
1440                 if(local && lib==0) {
1441                         ob->id.lib= NULL;
1442                         ob->id.flag= LIB_LOCAL;
1443                         new_id(&bmain->object, (ID *)ob, NULL);
1444                 }
1445                 else if(local && lib) {
1446                         Object *obn= copy_object(ob);
1447                         obn->id.us= 0;
1448                         
1449                         sce= bmain->scene.first;
1450                         while(sce) {
1451                                 if(sce->id.lib==NULL) {
1452                                         base= sce->base.first;
1453                                         while(base) {
1454                                                 if(base->object==ob) {
1455                                                         base->object= obn;
1456                                                         obn->id.us++;
1457                                                         ob->id.us--;
1458                                                 }
1459                                                 base= base->next;
1460                                         }
1461                                 }
1462                                 sce= sce->id.next;
1463                         }
1464                 }
1465         }
1466         
1467         extern_local_object(ob);
1468 }
1469
1470 /*
1471  * Returns true if the Object is a from an external blend file (libdata)
1472  */
1473 int object_is_libdata(Object *ob)
1474 {
1475         if (!ob) return 0;
1476         if (ob->proxy) return 0;
1477         if (ob->id.lib) return 1;
1478         return 0;
1479 }
1480
1481 /* Returns true if the Object data is a from an external blend file (libdata) */
1482 int object_data_is_libdata(Object *ob)
1483 {
1484         if(!ob) return 0;
1485         if(ob->proxy && (ob->data==NULL || ((ID *)ob->data)->lib==NULL)) return 0;
1486         if(ob->id.lib) return 1;
1487         if(ob->data==NULL) return 0;
1488         if(((ID *)ob->data)->lib) return 1;
1489
1490         return 0;
1491 }
1492
1493 /* *************** PROXY **************** */
1494
1495 /* when you make proxy, ensure the exposed layers are extern */
1496 static void armature_set_id_extern(Object *ob)
1497 {
1498         bArmature *arm= ob->data;
1499         bPoseChannel *pchan;
1500         unsigned int lay= arm->layer_protected;
1501         
1502         for (pchan = ob->pose->chanbase.first; pchan; pchan=pchan->next) {
1503                 if(!(pchan->bone->layer & lay))
1504                         id_lib_extern((ID *)pchan->custom);
1505         }
1506                         
1507 }
1508
1509 void object_copy_proxy_drivers(Object *ob, Object *target)
1510 {
1511         if ((target->adt) && (target->adt->drivers.first)) {
1512                 FCurve *fcu;
1513                 
1514                 /* add new animdata block */
1515                 if(!ob->adt)
1516                         ob->adt= BKE_id_add_animdata(&ob->id);
1517                 
1518                 /* make a copy of all the drivers (for now), then correct any links that need fixing */
1519                 free_fcurves(&ob->adt->drivers);
1520                 copy_fcurves(&ob->adt->drivers, &target->adt->drivers);
1521                 
1522                 for (fcu= ob->adt->drivers.first; fcu; fcu= fcu->next) {
1523                         ChannelDriver *driver= fcu->driver;
1524                         DriverVar *dvar;
1525                         
1526                         for (dvar= driver->variables.first; dvar; dvar= dvar->next) {
1527                                 /* all drivers */
1528                                 DRIVER_TARGETS_LOOPER(dvar) 
1529                                 {
1530                                         if(dtar->id) {
1531                                                 if ((Object *)dtar->id == target)
1532                                                         dtar->id= (ID *)ob;
1533                                                 else {
1534                                                         /* only on local objects because this causes indirect links a -> b -> c,blend to point directly to a.blend
1535                                                          * when a.blend has a proxy thats linked into c.blend  */
1536                                                         if(ob->id.lib==NULL)
1537                                                                 id_lib_extern((ID *)dtar->id);
1538                                                 }
1539                                         }
1540                                 }
1541                                 DRIVER_TARGETS_LOOPER_END
1542                         }
1543                 }
1544         }
1545 }
1546
1547 /* proxy rule: lib_object->proxy_from == the one we borrow from, set temporally while object_update */
1548 /*             local_object->proxy == pointer to library object, saved in files and read */
1549 /*             local_object->proxy_group == pointer to group dupli-object, saved in files and read */
1550
1551 void object_make_proxy(Object *ob, Object *target, Object *gob)
1552 {
1553         /* paranoia checks */
1554         if(ob->id.lib || target->id.lib==NULL) {
1555                 printf("cannot make proxy\n");
1556                 return;
1557         }
1558         
1559         ob->proxy= target;
1560         ob->proxy_group= gob;
1561         id_lib_extern(&target->id);
1562         
1563         ob->recalc= target->recalc= OB_RECALC_OB|OB_RECALC_DATA|OB_RECALC_TIME;
1564         
1565         /* copy transform
1566          * - gob means this proxy comes from a group, just apply the matrix
1567          *   so the object wont move from its dupli-transform.
1568          *
1569          * - no gob means this is being made from a linked object,
1570          *   this is closer to making a copy of the object - in-place. */
1571         if(gob) {
1572                 ob->rotmode= target->rotmode;
1573                 mul_m4_m4m4(ob->obmat, target->obmat, gob->obmat);
1574                 if(gob->dup_group) { /* should always be true */
1575                         float tvec[3];
1576                         copy_v3_v3(tvec, gob->dup_group->dupli_ofs);
1577                         mul_mat3_m4_v3(ob->obmat, tvec);
1578                         sub_v3_v3(ob->obmat[3], tvec);
1579                 }
1580                 object_apply_mat4(ob, ob->obmat, FALSE, TRUE);
1581         }
1582         else {
1583                 copy_object_transform(ob, target);
1584                 ob->parent= target->parent;     /* libdata */
1585                 copy_m4_m4(ob->parentinv, target->parentinv);
1586         }
1587         
1588         /* copy animdata stuff - drivers only for now... */
1589         object_copy_proxy_drivers(ob, target);
1590
1591         /* skip constraints? */
1592         // FIXME: this is considered by many as a bug
1593         
1594         /* set object type and link to data */
1595         ob->type= target->type;
1596         ob->data= target->data;
1597         id_us_plus((ID *)ob->data);             /* ensures lib data becomes LIB_EXTERN */
1598         
1599         /* copy material and index information */
1600         ob->actcol= ob->totcol= 0;
1601         if(ob->mat) MEM_freeN(ob->mat);
1602         if(ob->matbits) MEM_freeN(ob->matbits);
1603         ob->mat = NULL;
1604         ob->matbits= NULL;
1605         if ((target->totcol) && (target->mat) && ELEM5(ob->type, OB_MESH, OB_CURVE, OB_SURF, OB_FONT, OB_MBALL)) { //XXX OB_SUPPORT_MATERIAL
1606                 int i;
1607                 ob->colbits = target->colbits;
1608                 
1609                 ob->actcol= target->actcol;
1610                 ob->totcol= target->totcol;
1611                 
1612                 ob->mat = MEM_dupallocN(target->mat);
1613                 ob->matbits = MEM_dupallocN(target->matbits);
1614                 for(i=0; i<target->totcol; i++) {
1615                         /* dont need to run test_object_materials since we know this object is new and not used elsewhere */
1616                         id_us_plus((ID *)ob->mat[i]); 
1617                 }
1618         }
1619         
1620         /* type conversions */
1621         if(target->type == OB_ARMATURE) {
1622                 copy_object_pose(ob, target);   /* data copy, object pointers in constraints */
1623                 rest_pose(ob->pose);                    /* clear all transforms in channels */
1624                 armature_rebuild_pose(ob, ob->data);    /* set all internal links */
1625                 
1626                 armature_set_id_extern(ob);
1627         }
1628         else if (target->type == OB_EMPTY) {
1629                 ob->empty_drawtype = target->empty_drawtype;
1630                 ob->empty_drawsize = target->empty_drawsize;
1631         }
1632
1633         /* copy IDProperties */
1634         if(ob->id.properties) {
1635                 IDP_FreeProperty(ob->id.properties);
1636                 MEM_freeN(ob->id.properties);
1637                 ob->id.properties= NULL;
1638         }
1639         if(target->id.properties) {
1640                 ob->id.properties= IDP_CopyProperty(target->id.properties);
1641         }
1642
1643         /* copy drawtype info */
1644         ob->dt= target->dt;
1645 }
1646
1647
1648 /* *************** CALC ****************** */
1649
1650 /* there is also a timing calculation in drawobject() */
1651
1652
1653 // XXX THIS CRUFT NEEDS SERIOUS RECODING ASAP!
1654 /* ob can be NULL */
1655 float bsystem_time(struct Scene *scene, Object *UNUSED(ob), float cfra, float ofs)
1656 {
1657         /* returns float ( see BKE_curframe in scene.c) */
1658         cfra += scene->r.subframe;
1659         
1660         /* global time */
1661         if (scene)
1662                 cfra*= scene->r.framelen;       
1663         
1664 #if 0 // XXX old animation system
1665         if (ob) {
1666                 /* ofset frames */
1667                 if ((ob->ipoflag & OB_OFFS_PARENT) && (ob->partype & PARSLOW)==0) 
1668                         cfra-= give_timeoffset(ob);
1669         }
1670 #endif // XXX old animation system
1671         
1672         cfra-= ofs;
1673
1674         return cfra;
1675 }
1676
1677 void object_scale_to_mat3(Object *ob, float mat[][3])
1678 {
1679         float vec[3];
1680         add_v3_v3v3(vec, ob->size, ob->dsize);
1681         size_to_mat3( mat,vec);
1682 }
1683
1684
1685 void object_rot_to_mat3(Object *ob, float mat[][3])
1686 {
1687         float rmat[3][3], dmat[3][3];
1688         
1689         /* 'dmat' is the delta-rotation matrix, which will get (pre)multiplied
1690          * with the rotation matrix to yield the appropriate rotation
1691          */
1692
1693         /* rotations may either be quats, eulers (with various rotation orders), or axis-angle */
1694         if (ob->rotmode > 0) {
1695                 /* euler rotations (will cause gimble lock, but this can be alleviated a bit with rotation orders) */
1696                 eulO_to_mat3(rmat, ob->rot, ob->rotmode);
1697                 eulO_to_mat3(dmat, ob->drot, ob->rotmode);
1698         }
1699         else if (ob->rotmode == ROT_MODE_AXISANGLE) {
1700                 /* axis-angle -  not really that great for 3D-changing orientations */
1701                 axis_angle_to_mat3(rmat, ob->rotAxis, ob->rotAngle);
1702                 axis_angle_to_mat3(dmat, ob->drotAxis, ob->drotAngle);
1703         }
1704         else {
1705                 /* quats are normalised before use to eliminate scaling issues */
1706                 float tquat[4];
1707                 
1708                 normalize_qt_qt(tquat, ob->quat);
1709                 quat_to_mat3(rmat, tquat);
1710                 
1711                 normalize_qt_qt(tquat, ob->dquat);
1712                 quat_to_mat3(dmat, tquat);
1713         }
1714         
1715         /* combine these rotations */
1716         mul_m3_m3m3(mat, dmat, rmat);
1717 }
1718
1719 void object_mat3_to_rot(Object *ob, float mat[][3], short use_compat)
1720 {
1721         switch(ob->rotmode) {
1722         case ROT_MODE_QUAT:
1723                 {
1724                         float dquat[4];
1725                         mat3_to_quat(ob->quat, mat);
1726                         normalize_qt_qt(dquat, ob->dquat);
1727                         invert_qt(dquat);
1728                         mul_qt_qtqt(ob->quat, dquat, ob->quat);
1729                 }
1730                 break;
1731         case ROT_MODE_AXISANGLE:
1732                 mat3_to_axis_angle(ob->rotAxis, &ob->rotAngle, mat);
1733                 sub_v3_v3(ob->rotAxis, ob->drotAxis);
1734                 ob->rotAngle -= ob->drotAngle;
1735                 break;
1736         default: /* euler */
1737                 {
1738                         float quat[4];
1739                         float dquat[4];
1740                         float tmat[3][3];
1741
1742                         /* without drot we could apply 'mat' directly */
1743                         mat3_to_quat(quat, mat);
1744                         eulO_to_quat(dquat, ob->drot, ob->rotmode);
1745                         invert_qt(dquat);
1746                         mul_qt_qtqt(quat, dquat, quat);
1747                         quat_to_mat3(tmat, quat);
1748                         /* end drot correction */
1749
1750                         if(use_compat)  mat3_to_compatible_eulO(ob->rot, ob->rot, ob->rotmode, tmat);
1751                         else                    mat3_to_eulO(ob->rot, ob->rotmode, tmat);
1752                 }
1753         }
1754 }
1755
1756 /* see pchan_apply_mat4() for the equivalent 'pchan' function */
1757 void object_apply_mat4(Object *ob, float mat[][4], const short use_compat, const short use_parent)
1758 {
1759         float rot[3][3];
1760
1761         if(use_parent && ob->parent) {
1762                 float rmat[4][4], diff_mat[4][4], imat[4][4];
1763                 mul_m4_m4m4(diff_mat, ob->parentinv, ob->parent->obmat);
1764                 invert_m4_m4(imat, diff_mat);
1765                 mul_m4_m4m4(rmat, mat, imat); /* get the parent relative matrix */
1766                 object_apply_mat4(ob, rmat, use_compat, FALSE);
1767                 
1768                 /* same as below, use rmat rather than mat */
1769                 mat4_to_loc_rot_size(ob->loc, rot, ob->size, rmat);
1770                 object_mat3_to_rot(ob, rot, use_compat);
1771         }
1772         else {
1773                 mat4_to_loc_rot_size(ob->loc, rot, ob->size, mat);
1774                 object_mat3_to_rot(ob, rot, use_compat);
1775         }
1776         
1777         sub_v3_v3(ob->loc, ob->dloc);
1778         sub_v3_v3(ob->size, ob->dsize);
1779         /* object_mat3_to_rot handles delta rotations */
1780 }
1781
1782 void object_to_mat3(Object *ob, float mat[][3]) /* no parent */
1783 {
1784         float smat[3][3];
1785         float rmat[3][3];
1786         /*float q1[4];*/
1787         
1788         /* size */
1789         object_scale_to_mat3(ob, smat);
1790
1791         /* rot */
1792         object_rot_to_mat3(ob, rmat);
1793         mul_m3_m3m3(mat, rmat, smat);
1794 }
1795
1796 void object_to_mat4(Object *ob, float mat[][4])
1797 {
1798         float tmat[3][3];
1799         
1800         object_to_mat3(ob, tmat);
1801         
1802         copy_m4_m3(mat, tmat);
1803
1804         add_v3_v3v3(mat[3], ob->loc, ob->dloc);
1805 }
1806
1807 /* extern */
1808 int enable_cu_speed= 1;
1809
1810 static void ob_parcurve(Scene *scene, Object *ob, Object *par, float mat[][4])
1811 {
1812         Curve *cu;
1813         float vec[4], dir[3], quat[4], radius, ctime;
1814         float timeoffs = 0.0, sf_orig = 0.0;
1815         
1816         unit_m4(mat);
1817         
1818         cu= par->data;
1819         if(cu->path==NULL || cu->path->data==NULL) /* only happens on reload file, but violates depsgraph still... fix! */
1820                 makeDispListCurveTypes(scene, par, 0);
1821         if(cu->path==NULL) return;
1822         
1823         /* exception, timeoffset is regarded as distance offset */
1824         if(cu->flag & CU_OFFS_PATHDIST) {
1825                 timeoffs = give_timeoffset(ob);
1826                 SWAP(float, sf_orig, ob->sf);
1827         }
1828         
1829         /* catch exceptions: feature for nla stride editing */
1830         if(ob->ipoflag & OB_DISABLE_PATH) {
1831                 ctime= 0.0f;
1832         }
1833         /* catch exceptions: curve paths used as a duplicator */
1834         else if(enable_cu_speed) {
1835                 /* ctime is now a proper var setting of Curve which gets set by Animato like any other var that's animated,
1836                  * but this will only work if it actually is animated... 
1837                  *
1838                  * we divide the curvetime calculated in the previous step by the length of the path, to get a time
1839                  * factor, which then gets clamped to lie within 0.0 - 1.0 range
1840                  */
1841                 if (IS_EQF(cu->pathlen, 0.0f) == 0)
1842                         ctime= cu->ctime / cu->pathlen;
1843                 else
1844                         ctime= cu->ctime;
1845
1846                 CLAMP(ctime, 0.0f, 1.0f);
1847         }
1848         else {
1849                 ctime= scene->r.cfra - give_timeoffset(ob);
1850                 if (IS_EQF(cu->pathlen, 0.0f) == 0)
1851                         ctime /= cu->pathlen;
1852                 
1853                 CLAMP(ctime, 0.0f, 1.0f);
1854         }
1855         
1856         /* time calculus is correct, now apply distance offset */
1857         if(cu->flag & CU_OFFS_PATHDIST) {
1858                 ctime += timeoffs/cu->path->totdist;
1859
1860                 /* restore */
1861                 SWAP(float, sf_orig, ob->sf);
1862         }
1863         
1864         
1865         /* vec: 4 items! */
1866         if( where_on_path(par, ctime, vec, dir, cu->flag & CU_FOLLOW ? quat:NULL, &radius, NULL) ) {
1867
1868                 if(cu->flag & CU_FOLLOW) {
1869 #if 0
1870                         float x1, q[4];
1871                         vec_to_quat( quat,dir, ob->trackflag, ob->upflag);
1872                         
1873                         /* the tilt */
1874                         normalize_v3(dir);
1875                         q[0]= (float)cos(0.5*vec[3]);
1876                         x1= (float)sin(0.5*vec[3]);
1877                         q[1]= -x1*dir[0];
1878                         q[2]= -x1*dir[1];
1879                         q[3]= -x1*dir[2];
1880                         mul_qt_qtqt(quat, q, quat);
1881 #else
1882                         quat_apply_track(quat, ob->trackflag, ob->upflag);
1883 #endif
1884                         normalize_qt(quat);
1885                         quat_to_mat4(mat, quat);
1886                 }
1887                 
1888                 if(cu->flag & CU_PATH_RADIUS) {
1889                         float tmat[4][4], rmat[4][4];
1890                         scale_m4_fl(tmat, radius);
1891                         mul_m4_m4m4(rmat, mat, tmat);
1892                         copy_m4_m4(mat, rmat);
1893                 }
1894
1895                 copy_v3_v3(mat[3], vec);
1896                 
1897         }
1898 }
1899
1900 static void ob_parbone(Object *ob, Object *par, float mat[][4])
1901 {       
1902         bPoseChannel *pchan;
1903         float vec[3];
1904         
1905         if (par->type!=OB_ARMATURE) {
1906                 unit_m4(mat);
1907                 return;
1908         }
1909         
1910         /* Make sure the bone is still valid */
1911         pchan= get_pose_channel(par->pose, ob->parsubstr);
1912         if (!pchan){
1913                 printf ("Object %s with Bone parent: bone %s doesn't exist\n", ob->id.name+2, ob->parsubstr);
1914                 unit_m4(mat);
1915                 return;
1916         }
1917
1918         /* get bone transform */
1919         copy_m4_m4(mat, pchan->pose_mat);
1920
1921         /* but for backwards compatibility, the child has to move to the tail */
1922         copy_v3_v3(vec, mat[1]);
1923         mul_v3_fl(vec, pchan->bone->length);
1924         add_v3_v3(mat[3], vec);
1925 }
1926
1927 static void give_parvert(Object *par, int nr, float *vec)
1928 {
1929         EditMesh *em;
1930         int a, count;
1931         
1932         vec[0]=vec[1]=vec[2]= 0.0f;
1933         
1934         if(par->type==OB_MESH) {
1935                 Mesh *me= par->data;
1936                 DerivedMesh *dm;
1937
1938                 em = BKE_mesh_get_editmesh(me);
1939                 dm = (em)? em->derivedFinal: par->derivedFinal;
1940                         
1941                 if(dm) {
1942                         MVert *mvert= dm->getVertArray(dm);
1943                         int *index = (int *)dm->getVertDataArray(dm, CD_ORIGINDEX);
1944                         int i, vindex, numVerts = dm->getNumVerts(dm);
1945
1946                         /* get the average of all verts with (original index == nr) */
1947                         count= 0;
1948                         for(i = 0; i < numVerts; i++) {
1949                                 vindex= (index)? index[i]: i;
1950
1951                                 if(vindex == nr) {
1952                                         add_v3_v3(vec, mvert[i].co);
1953                                         count++;
1954                                 }
1955                         }
1956
1957                         if (count==0) {
1958                                 /* keep as 0,0,0 */
1959                         } else if(count > 0) {
1960                                 mul_v3_fl(vec, 1.0f / count);
1961                         } else {
1962                                 /* use first index if its out of range */
1963                                 dm->getVertCo(dm, 0, vec);
1964                         }
1965                 }
1966
1967                 if(em)
1968                         BKE_mesh_end_editmesh(me, em);
1969         }
1970         else if (ELEM(par->type, OB_CURVE, OB_SURF)) {
1971                 Nurb *nu;
1972                 Curve *cu;
1973                 BPoint *bp;
1974                 BezTriple *bezt;
1975                 int found= 0;
1976                 ListBase *nurbs;
1977
1978                 cu= par->data;
1979                 nurbs= BKE_curve_nurbs(cu);
1980                 nu= nurbs->first;
1981
1982                 count= 0;
1983                 while(nu && !found) {
1984                         if(nu->type == CU_BEZIER) {
1985                                 bezt= nu->bezt;
1986                                 a= nu->pntsu;
1987                                 while(a--) {
1988                                         if(count==nr) {
1989                                                 found= 1;
1990                                                 VECCOPY(vec, bezt->vec[1]);
1991                                                 break;
1992                                         }
1993                                         count++;
1994                                         bezt++;
1995                                 }
1996                         }
1997                         else {
1998                                 bp= nu->bp;
1999                                 a= nu->pntsu*nu->pntsv;
2000                                 while(a--) {
2001                                         if(count==nr) {
2002                                                 found= 1;
2003                                                 memcpy(vec, bp->vec, sizeof(float)*3);
2004                                                 break;
2005                                         }
2006                                         count++;
2007                                         bp++;
2008                                 }
2009                         }
2010                         nu= nu->next;
2011                 }
2012
2013         }
2014         else if(par->type==OB_LATTICE) {
2015                 Lattice *latt= par->data;
2016                 BPoint *bp;
2017                 DispList *dl = find_displist(&par->disp, DL_VERTS);
2018                 float *co = dl?dl->verts:NULL;
2019                 
2020                 if(latt->editlatt) latt= latt->editlatt->latt;
2021                 
2022                 a= latt->pntsu*latt->pntsv*latt->pntsw;
2023                 count= 0;
2024                 bp= latt->def;
2025                 while(a--) {
2026                         if(count==nr) {
2027                                 if(co)
2028                                         memcpy(vec, co, 3*sizeof(float));
2029                                 else
2030                                         memcpy(vec, bp->vec, 3*sizeof(float));
2031                                 break;
2032                         }
2033                         count++;
2034                         if(co) co+= 3;
2035                         else bp++;
2036                 }
2037         }
2038 }
2039
2040 static void ob_parvert3(Object *ob, Object *par, float mat[][4])
2041 {
2042         float cmat[3][3], v1[3], v2[3], v3[3], q[4];
2043
2044         /* in local ob space */
2045         unit_m4(mat);
2046         
2047         if (ELEM4(par->type, OB_MESH, OB_SURF, OB_CURVE, OB_LATTICE)) {
2048                 
2049                 give_parvert(par, ob->par1, v1);
2050                 give_parvert(par, ob->par2, v2);
2051                 give_parvert(par, ob->par3, v3);
2052                                 
2053                 tri_to_quat( q,v1, v2, v3);
2054                 quat_to_mat3( cmat,q);
2055                 copy_m4_m3(mat, cmat);
2056                 
2057                 if(ob->type==OB_CURVE) {
2058                         VECCOPY(mat[3], v1);
2059                 }
2060                 else {
2061                         add_v3_v3v3(mat[3], v1, v2);
2062                         add_v3_v3(mat[3], v3);
2063                         mul_v3_fl(mat[3], 0.3333333f);
2064                 }
2065         }
2066 }
2067
2068 // XXX what the hell is this?
2069 static int no_parent_ipo=0;
2070 void set_no_parent_ipo(int val)
2071 {
2072         no_parent_ipo= val;
2073 }
2074
2075 void where_is_object_time(Scene *scene, Object *ob, float ctime)
2076 {
2077         float *fp1, *fp2, slowmat[4][4] = MAT4_UNITY;
2078         float stime=ctime, fac1, fac2;
2079         int a;
2080         
2081         /* new version: correct parent+vertexparent and track+parent */
2082         /* this one only calculates direct attached parent and track */
2083         /* is faster, but should keep track of timeoffs */
2084         
2085         if(ob==NULL) return;
2086         
2087         /* execute drivers only, as animation has already been done */
2088         BKE_animsys_evaluate_animdata(&ob->id, ob->adt, ctime, ADT_RECALC_DRIVERS);
2089         
2090         if(ob->parent) {
2091                 Object *par= ob->parent;
2092                 
2093                 // XXX depreceated - animsys
2094                 if(ob->ipoflag & OB_OFFS_PARENT) ctime-= give_timeoffset(ob);
2095                 
2096                 /* hurms, code below conflicts with depgraph... (ton) */
2097                 /* and even worse, it gives bad effects for NLA stride too (try ctime != par->ctime, with MBlur) */
2098                 if(no_parent_ipo==0 && stime != par->ctime) {
2099                         // only for ipo systems? 
2100                         Object tmp= *par;
2101                         
2102                         if(par->proxy_from);    // was a copied matrix, no where_is! bad...
2103                         else where_is_object_time(scene, par, ctime);
2104
2105                         solve_parenting(scene, ob, par, ob->obmat, slowmat, 0);
2106
2107                         *par= tmp;
2108                 }
2109                 else
2110                         solve_parenting(scene, ob, par, ob->obmat, slowmat, 0);
2111                 
2112                 if(ob->partype & PARSLOW) {
2113                         // include framerate
2114                         fac1= ( 1.0f / (1.0f + (float)fabs(give_timeoffset(ob))) );
2115                         if(fac1 >= 1.0f) return;
2116                         fac2= 1.0f-fac1;
2117                         
2118                         fp1= ob->obmat[0];
2119                         fp2= slowmat[0];
2120                         for(a=0; a<16; a++, fp1++, fp2++) {
2121                                 fp1[0]= fac1*fp1[0] + fac2*fp2[0];
2122                         }
2123                 }
2124         }
2125         else {
2126                 object_to_mat4(ob, ob->obmat);
2127         }
2128
2129         /* solve constraints */
2130         if (ob->constraints.first && !(ob->transflag & OB_NO_CONSTRAINTS)) {
2131                 bConstraintOb *cob;
2132                 
2133                 cob= constraints_make_evalob(scene, ob, NULL, CONSTRAINT_OBTYPE_OBJECT);
2134                 
2135                 /* constraints need ctime, not stime. Some call where_is_object_time and bsystem_time */
2136                 solve_constraints (&ob->constraints, cob, ctime);
2137                 
2138                 constraints_clear_evalob(cob);
2139         }
2140         
2141         /* set negative scale flag in object */
2142         if(is_negative_m4(ob->obmat))   ob->transflag |= OB_NEG_SCALE;
2143         else                                                    ob->transflag &= ~OB_NEG_SCALE;
2144 }
2145
2146 /* get object transformation matrix without recalculating dependencies and
2147    constraints -- assume dependencies are already solved by depsgraph.
2148    no changes to object and it's parent would be done.
2149    used for bundles orientation in 3d space relative to parented blender camera */
2150 void where_is_object_mat(Scene *scene, Object *ob, float obmat[4][4])
2151 {
2152         float *fp1, *fp2, slowmat[4][4] = MAT4_UNITY;
2153         float fac1, fac2;
2154         int a;
2155
2156         if(ob->parent) {
2157                 Object *par= ob->parent;
2158
2159                 solve_parenting(scene, ob, par, obmat, slowmat, 1);
2160
2161                 if(ob->partype & PARSLOW) {
2162                         // include framerate
2163                         fac1= ( 1.0f / (1.0f + (float)fabs(give_timeoffset(ob))) );
2164                         if(fac1 >= 1.0f) return;
2165                         fac2= 1.0f-fac1;
2166
2167                         fp1= obmat[0];
2168                         fp2= slowmat[0];
2169                         for(a=0; a<16; a++, fp1++, fp2++) {
2170                                 fp1[0]= fac1*fp1[0] + fac2*fp2[0];
2171                         }
2172                 }
2173         }
2174         else {
2175                 object_to_mat4(ob, obmat);
2176         }
2177 }
2178
2179 static void solve_parenting (Scene *scene, Object *ob, Object *par, float obmat[][4], float slowmat[][4], int simul)
2180 {
2181         float totmat[4][4];
2182         float tmat[4][4];
2183         float locmat[4][4];
2184         float vec[3];
2185         int ok;
2186         
2187         object_to_mat4(ob, locmat);
2188         
2189         if(ob->partype & PARSLOW) copy_m4_m4(slowmat, obmat);
2190
2191         switch(ob->partype & PARTYPE) {
2192         case PAROBJECT:
2193                 ok= 0;
2194                 if(par->type==OB_CURVE) {
2195                         if( ((Curve *)par->data)->flag & CU_PATH ) {
2196                                 ob_parcurve(scene, ob, par, tmat);
2197                                 ok= 1;
2198                         }
2199                 }
2200                 
2201                 if(ok) mul_serie_m4(totmat, par->obmat, tmat, 
2202                         NULL, NULL, NULL, NULL, NULL, NULL);
2203                 else copy_m4_m4(totmat, par->obmat);
2204                 
2205                 break;
2206         case PARBONE:
2207                 ob_parbone(ob, par, tmat);
2208                 mul_serie_m4(totmat, par->obmat, tmat,         
2209                         NULL, NULL, NULL, NULL, NULL, NULL);
2210                 break;
2211                 
2212         case PARVERT1:
2213                 unit_m4(totmat);
2214                 if (simul){
2215                         VECCOPY(totmat[3], par->obmat[3]);
2216                 }
2217                 else{
2218                         give_parvert(par, ob->par1, vec);
2219                         mul_v3_m4v3(totmat[3], par->obmat, vec);
2220                 }
2221                 break;
2222         case PARVERT3:
2223                 ob_parvert3(ob, par, tmat);
2224                 
2225                 mul_serie_m4(totmat, par->obmat, tmat,         
2226                         NULL, NULL, NULL, NULL, NULL, NULL);
2227                 break;
2228                 
2229         case PARSKEL:
2230                 copy_m4_m4(totmat, par->obmat);
2231                 break;
2232         }
2233         
2234         // total 
2235         mul_serie_m4(tmat, totmat, ob->parentinv,         
2236                 NULL, NULL, NULL, NULL, NULL, NULL);
2237         mul_serie_m4(obmat, tmat, locmat,         
2238                 NULL, NULL, NULL, NULL, NULL, NULL);
2239         
2240         if (simul) {
2241
2242         }
2243         else{
2244                 // external usable originmat 
2245                 copy_m3_m4(originmat, tmat);
2246                 
2247                 // origin, voor help line
2248                 if( (ob->partype & PARTYPE)==PARSKEL ) {
2249                         VECCOPY(ob->orig, par->obmat[3]);
2250                 }
2251                 else {
2252                         VECCOPY(ob->orig, totmat[3]);
2253                 }
2254         }
2255
2256 }
2257
2258 void where_is_object(struct Scene *scene, Object *ob)
2259 {
2260         where_is_object_time(scene, ob, (float)scene->r.cfra);
2261 }
2262
2263
2264 void where_is_object_simul(Scene *scene, Object *ob)
2265 /* was written for the old game engine (until 2.04) */
2266 /* It seems that this function is only called
2267 for a lamp that is the child of another object */
2268 {
2269         Object *par;
2270         //Ipo *ipo;
2271         float *fp1, *fp2;
2272         float slowmat[4][4];
2273         float fac1, fac2;
2274         int a;
2275         
2276         /* NO TIMEOFFS */
2277         if(ob->parent) {
2278                 par= ob->parent;
2279                 
2280                 solve_parenting(scene, ob, par, ob->obmat, slowmat, 1);
2281
2282                 if(ob->partype & PARSLOW) {
2283
2284                         fac1= (float)(1.0/(1.0+ fabs(give_timeoffset(ob))));
2285                         fac2= 1.0f-fac1;
2286                         fp1= ob->obmat[0];
2287                         fp2= slowmat[0];
2288                         for(a=0; a<16; a++, fp1++, fp2++) {
2289                                 fp1[0]= fac1*fp1[0] + fac2*fp2[0];
2290                         }
2291                 }
2292                 
2293         }
2294         else {
2295                 object_to_mat4(ob, ob->obmat);
2296         }
2297         
2298         /* solve constraints */
2299         if (ob->constraints.first) {
2300                 bConstraintOb *cob;
2301                 
2302                 cob= constraints_make_evalob(scene, ob, NULL, CONSTRAINT_OBTYPE_OBJECT);
2303                 solve_constraints(&ob->constraints, cob, (float)scene->r.cfra);
2304                 constraints_clear_evalob(cob);
2305         }
2306 }
2307
2308 /* for calculation of the inverse parent transform, only used for editor */
2309 void what_does_parent(Scene *scene, Object *ob, Object *workob)
2310 {
2311         clear_workob(workob);
2312         
2313         unit_m4(workob->obmat);
2314         unit_m4(workob->parentinv);
2315         unit_m4(workob->constinv);
2316         workob->parent= ob->parent;
2317
2318         workob->trackflag= ob->trackflag;
2319         workob->upflag= ob->upflag;
2320         
2321         workob->partype= ob->partype;
2322         workob->par1= ob->par1;
2323         workob->par2= ob->par2;
2324         workob->par3= ob->par3;
2325
2326         workob->constraints.first = ob->constraints.first;
2327         workob->constraints.last = ob->constraints.last;
2328
2329         BLI_strncpy(workob->parsubstr, ob->parsubstr, sizeof(workob->parsubstr));
2330
2331         where_is_object(scene, workob);
2332 }
2333
2334 BoundBox *unit_boundbox(void)
2335 {
2336         BoundBox *bb;
2337         float min[3] = {-1.0f,-1.0f,-1.0f}, max[3] = {-1.0f,-1.0f,-1.0f};
2338
2339         bb= MEM_callocN(sizeof(BoundBox), "bb");
2340         boundbox_set_from_min_max(bb, min, max);
2341         
2342         return bb;
2343 }
2344
2345 void boundbox_set_from_min_max(BoundBox *bb, float min[3], float max[3])
2346 {
2347         bb->vec[0][0]=bb->vec[1][0]=bb->vec[2][0]=bb->vec[3][0]= min[0];
2348         bb->vec[4][0]=bb->vec[5][0]=bb->vec[6][0]=bb->vec[7][0]= max[0];
2349         
2350         bb->vec[0][1]=bb->vec[1][1]=bb->vec[4][1]=bb->vec[5][1]= min[1];
2351         bb->vec[2][1]=bb->vec[3][1]=bb->vec[6][1]=bb->vec[7][1]= max[1];
2352
2353         bb->vec[0][2]=bb->vec[3][2]=bb->vec[4][2]=bb->vec[7][2]= min[2];
2354         bb->vec[1][2]=bb->vec[2][2]=bb->vec[5][2]=bb->vec[6][2]= max[2];
2355 }
2356
2357 BoundBox *object_get_boundbox(Object *ob)
2358 {
2359         BoundBox *bb= NULL;
2360         
2361         if(ob->type==OB_MESH) {
2362                 bb = mesh_get_bb(ob);
2363         }
2364         else if (ELEM3(ob->type, OB_CURVE, OB_SURF, OB_FONT)) {
2365                 bb= ob->bb ? ob->bb : ( (Curve *)ob->data )->bb;
2366         }
2367         else if(ob->type==OB_MBALL) {
2368                 bb= ob->bb;
2369         }
2370         return bb;
2371 }
2372
2373 /* used to temporally disable/enable boundbox */
2374 void object_boundbox_flag(Object *ob, int flag, int set)
2375 {
2376         BoundBox *bb= object_get_boundbox(ob);
2377         if(bb) {
2378                 if(set) bb->flag |= flag;
2379                 else bb->flag &= ~flag;
2380         }
2381 }
2382
2383 void object_get_dimensions(Object *ob, float *value)
2384 {
2385         BoundBox *bb = NULL;
2386         
2387         bb= object_get_boundbox(ob);
2388         if (bb) {
2389                 float scale[3];
2390                 
2391                 mat4_to_size( scale,ob->obmat);
2392                 
2393                 value[0] = fabsf(scale[0]) * (bb->vec[4][0] - bb->vec[0][0]);
2394                 value[1] = fabsf(scale[1]) * (bb->vec[2][1] - bb->vec[0][1]);
2395                 value[2] = fabsf(scale[2]) * (bb->vec[1][2] - bb->vec[0][2]);
2396         } else {
2397                 value[0] = value[1] = value[2] = 0.f;
2398         }
2399 }
2400
2401 void object_set_dimensions(Object *ob, const float *value)
2402 {
2403         BoundBox *bb = NULL;
2404         
2405         bb= object_get_boundbox(ob);
2406         if (bb) {
2407                 float scale[3], len[3];
2408                 
2409                 mat4_to_size( scale,ob->obmat);
2410                 
2411                 len[0] = bb->vec[4][0] - bb->vec[0][0];
2412                 len[1] = bb->vec[2][1] - bb->vec[0][1];
2413                 len[2] = bb->vec[1][2] - bb->vec[0][2];
2414                 
2415                 if (len[0] > 0.f) ob->size[0] = value[0] / len[0];
2416                 if (len[1] > 0.f) ob->size[1] = value[1] / len[1];
2417                 if (len[2] > 0.f) ob->size[2] = value[2] / len[2];
2418         }
2419 }
2420
2421 void minmax_object(Object *ob, float *min, float *max)
2422 {
2423         BoundBox bb;
2424         float vec[3];
2425         int a;
2426         short change= FALSE;
2427         
2428         switch(ob->type) {
2429         case OB_CURVE:
2430         case OB_FONT:
2431         case OB_SURF:
2432                 {
2433                         Curve *cu= ob->data;
2434
2435                         if(cu->bb==NULL) tex_space_curve(cu);
2436                         bb= *(cu->bb);
2437
2438                         for(a=0; a<8; a++) {
2439                                 mul_m4_v3(ob->obmat, bb.vec[a]);
2440                                 DO_MINMAX(bb.vec[a], min, max);
2441                         }
2442                         change= TRUE;
2443                 }
2444                 break;
2445         case OB_LATTICE:
2446                 {
2447                         Lattice *lt= ob->data;
2448                         BPoint *bp= lt->def;
2449                         int u, v, w;
2450
2451                         for(w=0; w<lt->pntsw; w++) {
2452                                 for(v=0; v<lt->pntsv; v++) {
2453                                         for(u=0; u<lt->pntsu; u++, bp++) {
2454                                                 mul_v3_m4v3(vec, ob->obmat, bp->vec);
2455                                                 DO_MINMAX(vec, min, max);
2456                                         }
2457                                 }
2458                         }
2459                         change= TRUE;
2460                 }
2461                 break;
2462         case OB_ARMATURE:
2463                 if(ob->pose) {
2464                         bPoseChannel *pchan;
2465                         for(pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) {
2466                                 mul_v3_m4v3(vec, ob->obmat, pchan->pose_head);
2467                                 DO_MINMAX(vec, min, max);
2468                                 mul_v3_m4v3(vec, ob->obmat, pchan->pose_tail);
2469                                 DO_MINMAX(vec, min, max);
2470                         }
2471                         change= TRUE;
2472                 }
2473                 break;
2474         case OB_MESH:
2475                 {
2476                         Mesh *me= get_mesh(ob);
2477
2478                         if(me) {
2479                                 bb = *mesh_get_bb(ob);
2480
2481                                 for(a=0; a<8; a++) {
2482                                         mul_m4_v3(ob->obmat, bb.vec[a]);
2483                                         DO_MINMAX(bb.vec[a], min, max);
2484                                 }
2485                                 change= TRUE;
2486                         }
2487                 }
2488                 break;
2489         }
2490
2491         if(change == FALSE) {
2492                 DO_MINMAX(ob->obmat[3], min, max);
2493
2494                 copy_v3_v3(vec, ob->obmat[3]);
2495                 add_v3_v3(vec, ob->size);
2496                 DO_MINMAX(vec, min, max);
2497
2498                 copy_v3_v3(vec, ob->obmat[3]);
2499                 sub_v3_v3(vec, ob->size);
2500                 DO_MINMAX(vec, min, max);
2501         }
2502 }
2503
2504 int minmax_object_duplis(Scene *scene, Object *ob, float *min, float *max)
2505 {
2506         int ok= 0;
2507         if ((ob->transflag & OB_DUPLI)==0) {
2508                 return ok;
2509         } else {
2510                 ListBase *lb;
2511                 DupliObject *dob;
2512                 
2513                 lb= object_duplilist(scene, ob);
2514                 for(dob= lb->first; dob; dob= dob->next) {
2515                         if(dob->no_draw == 0) {
2516                                 BoundBox *bb= object_get_boundbox(dob->ob);
2517
2518                                 if(bb) {
2519                                         int i;
2520                                         for(i=0; i<8; i++) {
2521                                                 float vec[3];
2522                                                 mul_v3_m4v3(vec, dob->mat, bb->vec[i]);
2523                                                 DO_MINMAX(vec, min, max);
2524                                         }
2525
2526                                         ok= 1;
2527                                 }
2528                         }
2529                 }
2530                 free_object_duplilist(lb);      /* does restore */
2531         }
2532
2533         return ok;
2534 }
2535
2536 /* copied from DNA_object_types.h */
2537 typedef struct ObTfmBack {
2538         float loc[3], dloc[3], orig[3];
2539         float size[3], dsize[3];        /* scale and delta scale */
2540         float rot[3], drot[3];          /* euler rotation */
2541         float quat[4], dquat[4];        /* quaternion rotation */
2542         float rotAxis[3], drotAxis[3];  /* axis angle rotation - axis part */
2543         float rotAngle, drotAngle;      /* axis angle rotation - angle part */
2544         float obmat[4][4];              /* final worldspace matrix with constraints & animsys applied */
2545         float parentinv[4][4]; /* inverse result of parent, so that object doesn't 'stick' to parent */
2546         float constinv[4][4]; /* inverse result of constraints. doesn't include effect of parent or object local transform */
2547         float imat[4][4];       /* inverse matrix of 'obmat' for during render, old game engine, temporally: ipokeys of transform  */
2548 } ObTfmBack;
2549
2550 void *object_tfm_backup(Object *ob)
2551 {
2552         ObTfmBack *obtfm= MEM_mallocN(sizeof(ObTfmBack), "ObTfmBack");
2553         copy_v3_v3(obtfm->loc, ob->loc);
2554         copy_v3_v3(obtfm->dloc, ob->dloc);
2555         copy_v3_v3(obtfm->orig, ob->orig);
2556         copy_v3_v3(obtfm->size, ob->size);
2557         copy_v3_v3(obtfm->dsize, ob->dsize);
2558         copy_v3_v3(obtfm->rot, ob->rot);
2559         copy_v3_v3(obtfm->drot, ob->drot);
2560         copy_qt_qt(obtfm->quat, ob->quat);
2561         copy_qt_qt(obtfm->dquat, ob->dquat);
2562         copy_v3_v3(obtfm->rotAxis, ob->rotAxis);
2563         copy_v3_v3(obtfm->drotAxis, ob->drotAxis);
2564         obtfm->rotAngle= ob->rotAngle;
2565         obtfm->drotAngle= ob->drotAngle;
2566         copy_m4_m4(obtfm->obmat, ob->obmat);
2567         copy_m4_m4(obtfm->parentinv, ob->parentinv);
2568         copy_m4_m4(obtfm->constinv, ob->constinv);
2569         copy_m4_m4(obtfm->imat, ob->imat);
2570
2571         return (void *)obtfm;
2572 }
2573
2574 void object_tfm_restore(Object *ob, void *obtfm_pt)
2575 {
2576         ObTfmBack *obtfm= (ObTfmBack *)obtfm_pt;
2577         copy_v3_v3(ob->loc, obtfm->loc);
2578         copy_v3_v3(ob->dloc, obtfm->dloc);
2579         copy_v3_v3(ob->orig, obtfm->orig);
2580         copy_v3_v3(ob->size, obtfm->size);
2581         copy_v3_v3(ob->dsize, obtfm->dsize);
2582         copy_v3_v3(ob->rot, obtfm->rot);
2583         copy_v3_v3(ob->drot, obtfm->drot);
2584         copy_qt_qt(ob->quat, obtfm->quat);
2585         copy_qt_qt(ob->dquat, obtfm->dquat);
2586         copy_v3_v3(ob->rotAxis, obtfm->rotAxis);
2587         copy_v3_v3(ob->drotAxis, obtfm->drotAxis);
2588         ob->rotAngle= obtfm->rotAngle;
2589         ob->drotAngle= obtfm->drotAngle;
2590         copy_m4_m4(ob->obmat, obtfm->obmat);
2591         copy_m4_m4(ob->parentinv, obtfm->parentinv);
2592         copy_m4_m4(ob->constinv, obtfm->constinv);
2593         copy_m4_m4(ob->imat, obtfm->imat);
2594 }
2595
2596 /* proxy rule: lib_object->proxy_from == the one we borrow from, only set temporal and cleared here */
2597 /*           local_object->proxy      == pointer to library object, saved in files and read */
2598
2599 /* function below is polluted with proxy exceptions, cleanup will follow! */
2600
2601 /* the main object update call, for object matrix, constraints, keys and displist (modifiers) */
2602 /* requires flags to be set! */
2603 void object_handle_update(Scene *scene, Object *ob)
2604 {
2605         if(ob->recalc & OB_RECALC_ALL) {
2606                 /* speed optimization for animation lookups */
2607                 if(ob->pose)
2608                         make_pose_channels_hash(ob->pose);
2609
2610                 if(ob->recalc & OB_RECALC_DATA) {
2611                         if(ob->type==OB_ARMATURE) {
2612                                 /* this happens for reading old files and to match library armatures
2613                                    with poses we do it ahead of where_is_object to ensure animation
2614                                    is evaluated on the rebuilt pose, otherwise we get incorrect poses
2615                                    on file load */
2616                                 if(ob->pose==NULL || (ob->pose->flag & POSE_RECALC))
2617                                         armature_rebuild_pose(ob, ob->data);
2618                         }
2619                 }
2620
2621                 /* XXX new animsys warning: depsgraph tag OB_RECALC_DATA should not skip drivers, 
2622                    which is only in where_is_object now */
2623                 // XXX: should this case be OB_RECALC_OB instead?
2624                 if(ob->recalc & OB_RECALC_ALL) {
2625                         
2626                         if (G.f & G_DEBUG)
2627                                 printf("recalcob %s\n", ob->id.name+2);
2628                         
2629                         /* handle proxy copy for target */
2630                         if(ob->id.lib && ob->proxy_from) {
2631                                 // printf("ob proxy copy, lib ob %s proxy %s\n", ob->id.name, ob->proxy_from->id.name);
2632                                 if(ob->proxy_from->proxy_group) {/* transform proxy into group space */
2633                                         Object *obg= ob->proxy_from->proxy_group;
2634                                         invert_m4_m4(obg->imat, obg->obmat);
2635                                         mul_m4_m4m4(ob->obmat, ob->proxy_from->obmat, obg->imat);
2636                                         if(obg->dup_group) { /* should always be true */
2637                                                 add_v3_v3(ob->obmat[3], obg->dup_group->dupli_ofs);
2638                                         }
2639                                 }
2640                                 else
2641                                         copy_m4_m4(ob->obmat, ob->proxy_from->obmat);
2642                         }
2643                         else
2644                                 where_is_object(scene, ob);
2645                 }
2646                 
2647                 if(ob->recalc & OB_RECALC_DATA) {
2648                         ID *data_id= (ID *)ob->data;
2649                         AnimData *adt= BKE_animdata_from_id(data_id);
2650                         float ctime= (float)scene->r.cfra; // XXX this is bad...
2651                         ListBase pidlist;
2652                         PTCacheID *pid;
2653                         
2654                         if (G.f & G_DEBUG)
2655                                 printf("recalcdata %s\n", ob->id.name+2);
2656
2657                         if(adt) {
2658                                 /* evaluate drivers */
2659                                 // XXX: for mesh types, should we push this to derivedmesh instead?
2660                                 BKE_animsys_evaluate_animdata(data_id, adt, ctime, ADT_RECALC_DRIVERS);
2661                         }
2662
2663                         /* includes all keys and modifiers */
2664                         switch(ob->type) {
2665                         case OB_MESH:
2666                                 {
2667 #if 0                           // XXX, comment for 2.56a release, background wont set 'scene->customdata_mask'
2668                                         EditMesh *em = (ob == scene->obedit)? BKE_mesh_get_editmesh(ob->data): NULL;
2669                                         BLI_assert((scene->customdata_mask & CD_MASK_BAREMESH) == CD_MASK_BAREMESH);
2670                                         if(em) {
2671                                                 makeDerivedMesh(scene, ob, em,  scene->customdata_mask); /* was CD_MASK_BAREMESH */
2672                                                 BKE_mesh_end_editmesh(ob->data, em);
2673                                         } else
2674                                                 makeDerivedMesh(scene, ob, NULL, scene->customdata_mask);
2675
2676 #else                           /* ensure CD_MASK_BAREMESH for now */
2677                                         EditMesh *em = (ob == scene->obedit)? BKE_mesh_get_editmesh(ob->data): NULL;
2678                                         unsigned int data_mask= scene->customdata_mask | ob->customdata_mask | CD_MASK_BAREMESH;
2679                                         if(em) {
2680                                                 makeDerivedMesh(scene, ob, em,  data_mask); /* was CD_MASK_BAREMESH */
2681                                                 BKE_mesh_end_editmesh(ob->data, em);
2682                                         } else
2683                                                 makeDerivedMesh(scene, ob, NULL, data_mask);
2684 #endif
2685
2686                                 }
2687                                 break;
2688
2689                         case OB_ARMATURE:
2690                                 if(ob->id.lib && ob->proxy_from) {
2691                                         // printf("pose proxy copy, lib ob %s proxy %s\n", ob->id.name, ob->proxy_from->id.name);
2692                                         copy_pose_result(ob->pose, ob->proxy_from->pose);
2693                                 }
2694                                 else {
2695                                         where_is_pose(scene, ob);
2696                                 }
2697                                 break;
2698
2699                         case OB_MBALL:
2700                                 makeDispListMBall(scene, ob);
2701                                 break;
2702
2703                         case OB_CURVE:
2704                         case OB_SURF:
2705                         case OB_FONT:
2706                                 makeDispListCurveTypes(scene, ob, 0);
2707                                 break;
2708                                 
2709                         case OB_LATTICE:
2710                                 lattice_calc_modifiers(scene, ob);
2711                                 break;
2712                         }
2713
2714
2715                         if(ob->particlesystem.first) {
2716                                 ParticleSystem *tpsys, *psys;
2717                                 DerivedMesh *dm;
2718                                 ob->transflag &= ~OB_DUPLIPARTS;
2719                                 
2720                                 psys= ob->particlesystem.first;
2721                                 while(psys) {
2722                                         if(psys_check_enabled(ob, psys)) {
2723                                                 /* check use of dupli objects here */
2724                                                 if(psys->part && (psys->part->draw_as == PART_DRAW_REND || G.rendering) &&
2725                                                         ((psys->part->ren_as == PART_DRAW_OB && psys->part->dup_ob)
2726                                                         || (psys->part->ren_as == PART_DRAW_GR && psys->part->dup_group)))
2727                                                         ob->transflag |= OB_DUPLIPARTS;
2728
2729                                                 particle_system_update(scene, ob, psys);
2730                                                 psys= psys->next;
2731                                         }
2732                                         else if(psys->flag & PSYS_DELETE) {
2733                                                 tpsys=psys->next;
2734                                                 BLI_remlink(&ob->particlesystem, psys);
2735                                                 psys_free(ob,psys);
2736                                                 psys= tpsys;
2737                                         }
2738                                         else
2739                                                 psys= psys->next;
2740                                 }
2741
2742                                 if(G.rendering && ob->transflag & OB_DUPLIPARTS) {
2743                                         /* this is to make sure we get render level duplis in groups:
2744                                          * the derivedmesh must be created before init_render_mesh,
2745                                          * since object_duplilist does dupliparticles before that */
2746                                         dm = mesh_create_derived_render(scene, ob, CD_MASK_BAREMESH|CD_MASK_MTFACE|CD_MASK_MCOL);
2747                                         dm->release(dm);
2748
2749                                         for(psys=ob->particlesystem.first; psys; psys=psys->next)
2750                                                 psys_get_modifier(ob, psys)->flag &= ~eParticleSystemFlag_psys_updated;
2751                                 }
2752                         }
2753
2754                         /* check if quick cache is needed */
2755                         BKE_ptcache_ids_from_object(&pidlist, ob, scene, MAX_DUPLI_RECUR);
2756
2757                         for(pid=pidlist.first; pid; pid=pid->next) {
2758                                 if((pid->cache->flag & PTCACHE_BAKED)
2759                                         || (pid->cache->flag & PTCACHE_QUICK_CACHE)==0)
2760                                         continue;
2761
2762                                 if(pid->cache->flag & PTCACHE_OUTDATED || (pid->cache->flag & PTCACHE_SIMULATION_VALID)==0) {
2763                                         scene->physics_settings.quick_cache_step =
2764                                                 scene->physics_settings.quick_cache_step ?
2765                                                 MIN2(scene->physics_settings.quick_cache_step, pid->cache->step) :
2766                                                 pid->cache->step;
2767                                 }
2768                         }
2769
2770                         BLI_freelistN(&pidlist);
2771                 }
2772
2773                 /* the no-group proxy case, we call update */
2774                 if(ob->proxy && ob->proxy_group==NULL) {
2775                         /* set pointer in library proxy target, for copying, but restore it */
2776                         ob->proxy->proxy_from= ob;
2777                         // printf("call update, lib ob %s proxy %s\n", ob->proxy->id.name, ob->id.name);
2778                         object_handle_update(scene, ob->proxy);
2779                 }
2780         
2781                 ob->recalc &= ~OB_RECALC_ALL;
2782         }
2783
2784         /* the case when this is a group proxy, object_update is called in group.c */
2785         if(ob->proxy) {
2786                 ob->proxy->proxy_from= ob;
2787                 // printf("set proxy pointer for later group stuff %s\n", ob->id.name);
2788         }
2789 }
2790
2791 float give_timeoffset(Object *ob) {
2792         if ((ob->ipoflag & OB_OFFS_PARENTADD) && ob->parent) {
2793                 return ob->sf + give_timeoffset(ob->parent);
2794         } else {
2795                 return ob->sf;
2796         }
2797 }
2798
2799 int give_obdata_texspace(Object *ob, short **texflag, float **loc, float **size, float **rot) {
2800         
2801         if (ob->data==NULL)
2802                 return 0;
2803         
2804         switch (GS(((ID *)ob->data)->name)) {
2805         case ID_ME:
2806         {
2807                 Mesh *me= ob->data;
2808                 if (texflag)    *texflag = &me->texflag;
2809                 if (loc)                *loc = me->loc;
2810                 if (size)               *size = me->size;
2811                 if (rot)                *rot = me->rot;
2812                 break;
2813         }
2814         case ID_CU:
2815         {
2816                 Curve *cu= ob->data;
2817                 if (texflag)    *texflag = &cu->texflag;
2818                 if (loc)                *loc = cu->loc;
2819                 if (size)               *size = cu->size;
2820                 if (rot)                *rot = cu->rot;
2821                 break;
2822         }
2823         case ID_MB:
2824         {
2825                 MetaBall *mb= ob->data;
2826                 if (texflag)    *texflag = &mb->texflag;
2827                 if (loc)                *loc = mb->loc;
2828                 if (size)               *size = mb->size;
2829                 if (rot)                *rot = mb->rot;
2830                 break;
2831         }
2832         default:
2833                 return 0;
2834         }
2835         return 1;
2836 }
2837
2838 /*
2839  * Test a bounding box for ray intersection
2840  * assumes the ray is already local to the boundbox space
2841  */
2842 int ray_hit_boundbox(struct BoundBox *bb, float ray_start[3], float ray_normal[3])
2843 {
2844         static int triangle_indexes[12][3] = {{0, 1, 2}, {0, 2, 3},
2845                                                                                   {3, 2, 6}, {3, 6, 7},
2846                                                                                   {1, 2, 6}, {1, 6, 5}, 
2847                                                                                   {5, 6, 7}, {4, 5, 7},
2848                                                                                   {0, 3, 7}, {0, 4, 7},
2849                                                                                   {0, 1, 5}, {0, 4, 5}};
2850         int result = 0;
2851         int i;
2852         
2853         for (i = 0; i < 12 && result == 0; i++)
2854         {
2855                 float lambda;
2856                 int v1, v2, v3;
2857                 v1 = triangle_indexes[i][0];
2858                 v2 = triangle_indexes[i][1];
2859                 v3 = triangle_indexes[i][2];
2860                 result = isect_ray_tri_v3(ray_start, ray_normal, bb->vec[v1], bb->vec[v2], bb->vec[v3], &lambda, NULL);
2861         }
2862         
2863         return result;
2864 }
2865
2866 static int pc_cmp(void *a, void *b)
2867 {
2868         LinkData *ad = a, *bd = b;
2869         if(GET_INT_FROM_POINTER(ad->data) > GET_INT_FROM_POINTER(bd->data))
2870                 return 1;
2871         else return 0;
2872 }
2873
2874 int object_insert_ptcache(Object *ob) 
2875 {
2876         LinkData *link = NULL;
2877         int i = 0;
2878
2879         BLI_sortlist(&ob->pc_ids, pc_cmp);
2880
2881         for(link=ob->pc_ids.first, i = 0; link; link=link->next, i++) 
2882         {
2883                 int index = GET_INT_FROM_POINTER(link->data);
2884
2885                 if(i < index)
2886                         break;
2887         }
2888
2889         link = MEM_callocN(sizeof(LinkData), "PCLink");
2890         link->data = SET_INT_IN_POINTER(i);
2891         BLI_addtail(&ob->pc_ids, link);
2892
2893         return i;
2894 }
2895
2896 void object_camera_mode(RenderData *rd, Object *camera)
2897 {
2898         rd->mode &= ~(R_ORTHO|R_PANORAMA);
2899         if(camera && camera->type==OB_CAMERA) {
2900                 Camera *cam= camera->data;
2901                 if(cam->type == CAM_ORTHO) rd->mode |= R_ORTHO;
2902                 if(cam->flag & CAM_PANORAMA) rd->mode |= R_PANORAMA;
2903         }
2904 }
2905
2906 /* 'lens' may be set for envmap only */
2907 void object_camera_matrix(
2908                 RenderData *rd, Object *camera, int winx, int winy, short field_second,
2909                 float winmat[][4], rctf *viewplane, float *clipsta, float *clipend, float *lens, float *sensor_x, float *ycor,
2910                 float *viewdx, float *viewdy
2911 ) {
2912         Camera *cam=NULL;
2913         float pixsize;
2914         float shiftx=0.0, shifty=0.0, winside, viewfac;
2915         short is_ortho= FALSE;
2916
2917         /* question mark */
2918         (*ycor)= rd->yasp / rd->xasp;
2919         if(rd->mode & R_FIELDS)
2920                 (*ycor) *= 2.0f;
2921
2922         if(camera->type==OB_CAMERA) {
2923                 cam= camera->data;
2924
2925                 if(cam->type == CAM_ORTHO) {
2926                         is_ortho= TRUE;
2927                 }
2928
2929                 /* solve this too... all time depending stuff is in convertblender.c?
2930                  * Need to update the camera early because it's used for projection matrices
2931                  * and other stuff BEFORE the animation update loop is done
2932                  * */
2933 #if 0 // XXX old animation system
2934                 if(cam->ipo) {
2935                         calc_ipo(cam->ipo, frame_to_float(re->scene, re->r.cfra));
2936                         execute_ipo(&cam->id, cam->ipo);
2937                 }
2938 #endif // XXX old animation system
2939                 shiftx=cam->shiftx;
2940                 shifty=cam->shifty;
2941                 (*lens)= cam->lens;
2942                 (*sensor_x)= cam->sensor_x;
2943                 (*clipsta)= cam->clipsta;
2944                 (*clipend)= cam->clipend;
2945         }
2946         else if(camera->type==OB_LAMP) {
2947                 Lamp *la= camera->data;
2948                 float fac= cosf((float)M_PI*la->spotsize/360.0f);
2949                 float phi= acos(fac);
2950
2951                 (*lens)= 16.0f*fac/sinf(phi);
2952                 if((*lens)==0.0f)
2953                         (*lens)= 35.0f;
2954                 (*clipsta)= la->clipsta;
2955                 (*clipend)= la->clipend;
2956         }
2957         else {  /* envmap exception... */;
2958                 if((*lens)==0.0f) /* is this needed anymore? */
2959                         (*lens)= 16.0f;
2960
2961                 if((*clipsta)==0.0f || (*clipend)==0.0f) {
2962                         (*clipsta)= 0.1f;
2963                         (*clipend)= 1000.0f;
2964                 }
2965         }
2966
2967         /* ortho only with camera available */
2968         if(cam && is_ortho) {
2969                 if(rd->xasp*winx >= rd->yasp*winy) {
2970                         viewfac= winx;
2971                 }
2972                 else {
2973                         viewfac= (*ycor) * winy;
2974                 }
2975                 /* ortho_scale == 1.0 means exact 1 to 1 mapping */
2976                 pixsize= cam->ortho_scale/viewfac;
2977         }
2978         else {
2979                 if(rd->xasp*winx >= rd->yasp*winy)      viewfac= ((*lens) * winx) / (*sensor_x);
2980                 else                                    viewfac= (*ycor) * ((*lens) * winy) / (*sensor_x);
2981                 pixsize= (*clipsta) / viewfac;
2982         }
2983
2984         /* viewplane fully centered, zbuffer fills in jittered between -.5 and +.5 */
2985         winside= MAX2(winx, winy);
2986         viewplane->xmin= -0.5f*(float)winx + shiftx*winside;
2987         viewplane->ymin= -0.5f*(*ycor)*(float)winy + shifty*winside;
2988         viewplane->xmax=  0.5f*(float)winx + shiftx*winside;
2989         viewplane->ymax=  0.5f*(*ycor)*(float)winy + shifty*winside;
2990
2991         if(field_second) {
2992                 if(rd->mode & R_ODDFIELD) {
2993                         viewplane->ymin-= 0.5f * (*ycor);
2994                         viewplane->ymax-= 0.5f * (*ycor);
2995                 }
2996                 else {
2997                         viewplane->ymin+= 0.5f * (*ycor);
2998                         viewplane->ymax+= 0.5f * (*ycor);
2999                 }
3000         }
3001         /* the window matrix is used for clipping, and not changed during OSA steps */
3002         /* using an offset of +0.5 here would give clip errors on edges */
3003         viewplane->xmin *= pixsize;
3004         viewplane->xmax *= pixsize;
3005         viewplane->ymin *= pixsize;
3006         viewplane->ymax *= pixsize;
3007
3008         (*viewdx)= pixsize;
3009         (*viewdy)= (*ycor) * pixsize;
3010
3011         if(is_ortho)
3012                 orthographic_m4(winmat, viewplane->xmin, viewplane->xmax, viewplane->ymin, viewplane->ymax, *clipsta, *clipend);
3013         else
3014                 perspective_m4(winmat, viewplane->xmin, viewplane->xmax, viewplane->ymin, viewplane->ymax, *clipsta, *clipend);
3015
3016 }
3017
3018 #if 0
3019 static int pc_findindex(ListBase *listbase, int index)
3020 {
3021         LinkData *link= NULL;
3022         int number= 0;
3023         
3024         if (listbase == NULL) return -1;
3025         
3026         link= listbase->first;
3027         while (link) {
3028                 if ((int)link->data == index)
3029                         return number;
3030                 
3031                 number++;
3032                 link= link->next;
3033         }
3034         
3035         return -1;
3036 }
3037
3038 void object_delete_ptcache(Object *ob, int index) 
3039 {
3040         int list_index = pc_findindex(&ob->pc_ids, index);
3041         LinkData *link = BLI_findlink(&ob->pc_ids, list_index);
3042         BLI_freelinkN(&ob->pc_ids, link);
3043 }
3044 #endif
3045
3046 /* shape key utility function */
3047
3048 /************************* Mesh ************************/
3049 static KeyBlock *insert_meshkey(Scene *scene, Object *ob, const char *name, int from_mix)
3050 {
3051         Mesh *me= ob->data;
3052         Key *key= me->key;
3053         KeyBlock *kb;
3054         int newkey= 0;
3055
3056         if(key == NULL) {
3057                 key= me->key= add_key((ID *)me);
3058                 key->type= KEY_RELATIVE;
3059                 newkey= 1;
3060         }
3061
3062         if(newkey || from_mix==FALSE) {
3063                 /* create from mesh */
3064                 kb= add_keyblock(key, name);
3065                 mesh_to_key(me, kb);
3066         }
3067         else {
3068                 /* copy from current values */
3069                 float *data= do_ob_key(scene, ob);
3070
3071                 /* create new block with prepared data */
3072                 kb= add_keyblock(key, name);
3073                 kb->data= data;
3074                 kb->totelem= me->totvert;
3075         }
3076
3077         return kb;
3078 }
3079 /************************* Lattice ************************/
3080 static KeyBlock *insert_lattkey(Scene *scene, Object *ob, const char *name, int from_mix)
3081 {
3082         Lattice *lt= ob->data;
3083         Key *key= lt->key;
3084         KeyBlock *kb;
3085         int newkey= 0;
3086
3087         if(key==NULL) {
3088                 key= lt->key= add_key( (ID *)lt);
3089                 key->type= KEY_RELATIVE;
3090                 newkey= 1;
3091         }
3092
3093         if(newkey || from_mix==FALSE) {
3094                 kb= add_keyblock(key, name);
3095                 if (!newkey) {
3096                         KeyBlock *basekb= (KeyBlock *)key->block.first;
3097                         kb->data= MEM_dupallocN(basekb->data);
3098                         kb->totelem= basekb->totelem;
3099                 }
3100                 else {
3101                         latt_to_key(lt, kb);
3102                 }
3103         }
3104         else {
3105                 /* copy from current values */
3106                 float *data= do_ob_key(scene, ob);
3107
3108                 /* create new block with prepared data */
3109                 kb= add_keyblock(key, name);
3110                 kb->totelem= lt->pntsu*lt->pntsv*lt->pntsw;
3111                 kb->data= data;
3112         }
3113
3114         return kb;
3115 }
3116 /************************* Curve ************************/
3117 static KeyBlock *insert_curvekey(Scene *scene, Object *ob, const char *name, int from_mix)
3118 {
3119         Curve *cu= ob->data;
3120         Key *key= cu->key;
3121         KeyBlock *kb;
3122         ListBase *lb= BKE_curve_nurbs(cu);
3123         int newkey= 0;
3124
3125         if(key==NULL) {
3126                 key= cu->key= add_key( (ID *)cu);
3127                 key->type = KEY_RELATIVE;
3128                 newkey= 1;
3129         }
3130
3131         if(newkey || from_mix==FALSE) {
3132                 /* create from curve */
3133                 kb= add_keyblock(key, name);
3134                 if (!newkey) {
3135                         KeyBlock *basekb= (KeyBlock *)key->block.first;
3136                         kb->data= MEM_dupallocN(basekb->data);
3137                         kb->totelem= basekb->totelem;
3138                 }
3139                 else {
3140                         curve_to_key(cu, kb, lb);
3141                 }
3142         }
3143         else {
3144                 /* copy from current values */
3145                 float *data= do_ob_key(scene, ob);
3146