Welcome to mirror list, hosted at ThFree Co, Russian Federation.

git.blender.org/blender.git - Unnamed repository; edit this file 'description' to name the repository.
summaryrefslogtreecommitdiff
path: root/source/blender/src/oops.c
diff options
context:
space:
mode:
Diffstat (limited to 'source/blender/src/oops.c')
-rw-r--r--source/blender/src/oops.c1044
1 files changed, 1044 insertions, 0 deletions
diff --git a/source/blender/src/oops.c b/source/blender/src/oops.c
new file mode 100644
index 00000000000..06688d2db9d
--- /dev/null
+++ b/source/blender/src/oops.c
@@ -0,0 +1,1044 @@
+/**
+ * $Id$
+ *
+ * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version. The Blender
+ * Foundation also sells licenses for use in proprietary software under
+ * the Blender License. See http://www.blender.org/BL/ for information
+ * about this.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL/BL DUAL LICENSE BLOCK *****
+ */
+
+#include <math.h>
+#include "MEM_guardedalloc.h"
+
+#include "BLI_blenlib.h"
+#include "BLI_arithb.h"
+#include "BLI_editVert.h"
+
+#include "DNA_curve_types.h"
+#include "DNA_image_types.h"
+#include "DNA_ipo_types.h"
+#include "DNA_lamp_types.h"
+#include "DNA_material_types.h"
+#include "DNA_mesh_types.h"
+#include "DNA_meta_types.h"
+#include "DNA_object_types.h"
+#include "DNA_oops_types.h"
+#include "DNA_scene_types.h"
+#include "DNA_space_types.h"
+#include "DNA_texture_types.h"
+#include "DNA_texture_types.h"
+#include "DNA_key_types.h"
+
+#include "BKE_utildefines.h"
+#include "BKE_global.h"
+#include "BKE_library.h"
+#include "BKE_main.h"
+
+#include "BIF_screen.h"
+#include "BIF_space.h"
+#include "BIF_toolbox.h"
+#include "BIF_oops.h"
+#include "BIF_drawoops.h"
+
+#include "blendef.h"
+#include "mydevice.h"
+
+static int correct_oops_y(Oops *oops);
+
+
+Oops *add_oops(void *id)
+{
+ Oops *oops;
+
+ if(G.soops==0) return NULL;
+ oops= MEM_callocN(sizeof(Oops), "oops");
+
+ BLI_addtail(&G.soops->oops, oops);
+
+ oops->id= id;
+ oops->type= GS(oops->id->name);
+
+ return oops;
+}
+
+
+Oops *find_oops(ID *id)
+{
+ Oops *oops;
+
+ /* op zoek naar een oops met dit ID */
+ oops= G.soops->oops.first;
+ while(oops) {
+ if(oops->id == id) {
+ /* deze fout kwam een keer voor. beveiliging kan geen kwaad */
+ if(oops->type != GS(id->name)) oops->id= 0;
+ else break;
+ }
+ oops= oops->next;
+ }
+ return oops;
+}
+
+int test_oops(Oops *oops)
+{
+ /* test of de eigen ID block nog bestaat */
+ ListBase *lb;
+ ID *id;
+
+ if(G.soops==0) return 0;
+
+ lb= wich_libbase(G.main, oops->type);
+ id= lb->first;
+ while(id) {
+ if(id==oops->id) break;
+ id= id->next;
+ }
+
+ if(id==0) return 0;
+
+
+ return 1;
+}
+
+void test_oopslinko(OopsLink *ol)
+{
+ /* test of links bestaan */
+ Oops *oops;
+ ListBase *lb;
+ ID *id, *from;
+
+ if(G.soops==0) return;
+
+ ol->to= 0;
+ from= *ol->idfrom;
+
+ if(from==0) return;
+
+ lb= wich_libbase(G.main, ol->type);
+ id= lb->first;
+ while(id) {
+ if(id==from) break;
+ id= id->next;
+ }
+
+ if(id==0) {
+ /* ID bestaat niet meer */
+ *ol->idfrom= 0;
+ }
+ else {
+ /* op zoek naar een oops met dit ID */
+ oops= G.soops->oops.first;
+ while(oops) {
+ if(oops->id == id) break;
+ oops= oops->next;
+ }
+
+ ol->to= oops;
+ }
+}
+
+void test_oopslink(OopsLink *ol)
+{
+ /* test of links bestaan */
+ Oops *oops;
+ ID *from;
+
+ if(G.soops==0) return;
+
+ ol->to= 0;
+ from= *ol->idfrom;
+
+ if(from==0) return;
+
+ /* op zoek naar een oops met dit ID */
+ oops= G.soops->oops.first;
+ while(oops) {
+ if(oops->id == from) break;
+ oops= oops->next;
+ }
+
+ ol->to= oops;
+ if(oops) oops->flag |= OOPS_REFER;
+}
+
+
+OopsLink *add_oopslink(char *name, Oops *oops, short type, void *from, float xof, float yof)
+{
+ OopsLink *ol;
+
+ if(G.soops==0) return NULL;
+
+ /* testen offie al bestaat: een andere manier mag ook (linkbuffer) */
+ /* ol= oops->link.first; */
+ /* while(ol) { */
+ /* if(ol->idfrom == from) { */
+ /* strncpy(ol->name, name, 11); */
+ /* ol->type= type; */
+ /* ol->xof= xof; */
+ /* ol->yof= yof; */
+ /* return ol; */
+ /* } */
+ /* ol= ol->next; */
+ /* } */
+
+ if(* ((int *)from) == 0) return NULL;
+
+ /* nieuwe maken */
+ ol= MEM_callocN(sizeof(OopsLink), "oopslink");
+
+ BLI_addtail(&oops->link, ol);
+
+ ol->type= type;
+ ol->idfrom= from;
+ ol->xof= xof;
+ ol->yof= yof;
+ BLI_strncpy(ol->name, name, sizeof(ol->name));
+
+ return ol;
+}
+
+int oops_test_overlap(Oops *test)
+{
+ Oops *oops;
+ rctf rt, ro;
+
+ rt.xmin= test->x;
+ rt.xmax= (float)(test->x+OOPSX);
+ rt.ymin= test->y;
+ rt.ymax= (float)(test->y+OOPSY);
+
+ oops= G.soops->oops.first;
+ while(oops) {
+ if(oops!=test) { /* niet op hide testen: is slechts tijdelijke flag */
+
+ ro.xmin= oops->x;
+ ro.xmax= (float)(oops->x+OOPSX);
+ ro.ymin= oops->y;
+ ro.ymax= (float)(oops->y+OOPSY);
+
+ if( BLI_isect_rctf(&rt, &ro, 0) ) return 1;
+
+ }
+ oops= oops->next;
+ }
+
+ return 0;
+}
+
+int oops_test_overlaphide(Oops *test)
+{
+ Oops *oops;
+ rctf rt, ro;
+
+ rt.xmin= (float)(test->x);
+ rt.xmax= (float)(test->x+OOPSX);
+ rt.ymin= (float)(test->y);
+ rt.ymax= (float)(test->y+OOPSY);
+
+ oops= G.soops->oops.first;
+ while(oops) {
+ if(oops->hide==0 && oops!=test) { /* wel op hide testen, niet gebruiken tijdens build_oops */
+
+ ro.xmin= oops->x;
+ ro.xmax= (float)(oops->x+OOPSX);
+ ro.ymin= oops->y;
+ ro.ymax= (float)(oops->y+OOPSY);
+
+ if( BLI_isect_rctf(&rt, &ro, 0) ) return 1;
+
+ }
+ oops= oops->next;
+ }
+
+ return 0;
+}
+
+float oopslink_totlen(Oops *oops)
+{
+ OopsLink *ol;
+ float vec[4], dx, dy, len= 0.0;
+
+
+ ol= oops->link.first;
+ while(ol) {
+ if(ol->to) {
+ give_oopslink_line(oops, ol, vec, vec+2);
+
+ dx= vec[0]-vec[2];
+ dy= vec[1]-vec[3];
+
+ len+= (float)sqrt( dx*dx + dy*dy );
+ }
+ ol= ol->next;
+ }
+ return len;
+}
+
+
+void add_from_link(Oops *from, Oops *oops)
+{
+ OopsLink *ol;
+
+ ol= MEM_callocN(sizeof(OopsLink), "oopslinktemp");
+ BLI_addtail(&oops->link, ol);
+ ol->from= from;
+
+}
+
+void shuffle_oops()
+{
+ Oops *o2, *oops;
+ OopsLink *ol, *oln;
+ float olen, len1, f1, f2;
+ int go= 1, tot=0, dir=1, type1, type2;
+
+
+ /* we nemen twee oopsen, berkekenen de 'beauty' en de verwisselde beauty */
+
+ if(G.soops==0) return;
+
+ if(okee("Shuffle oops")==0) return;
+
+ waitcursor(1);
+
+ /* om de zaak 100% OK en snel te doen: voegen tijdelijk
+ * aan de ooplinklijst - per oops - de 'from' links ook in.
+ * Wel weer vrijgeven!
+ */
+
+ oops= G.soops->oops.first;
+ while(oops) {
+ if(oops->hide==0) {
+ ol= oops->link.first;
+ while(ol) {
+ if(ol->to && ol->to->hide==0) {
+ if(ol->to->flag & SELECT) {
+ add_from_link(oops, ol->to);
+ }
+ }
+ ol= ol->next;
+ }
+ }
+ oops= oops->next;
+ }
+
+ while(go) {
+
+ go= 0;
+ dir= 1-dir;
+ tot++;
+
+ if(dir) oops= G.soops->oops.last;
+ else oops= G.soops->oops.first;
+ while(oops) {
+
+ if(oops->link.first && oops->hide==0 && (oops->flag & SELECT)) {
+ /* vind een goed verwisselbaar paar */
+ olen= oopslink_totlen(oops);
+
+ if(dir) o2= oops->prev;
+ else o2= oops->next;
+
+ if ELEM3(oops->type, ID_OB, ID_LI, ID_SCE) type1= 1; else type1= 0;
+
+
+ while(o2) {
+ if(o2->hide==0 && (o2->flag & SELECT)) {
+
+ if ELEM3(o2->type, ID_OB, ID_LI, ID_SCE) type2= 1; else type2= 0;
+
+ if(type1==type2) {
+
+ len1= oopslink_totlen(o2);
+
+ SWAP(float, oops->x, o2->x);
+ SWAP(float, oops->y, o2->y);
+
+ f1= oopslink_totlen(oops);
+ f2= oopslink_totlen(o2);
+
+ if( f1<=olen && f2<len1) { /* 1 x <= !!! */
+ olen= oopslink_totlen(oops);
+ go= 1;
+ }
+ else {
+ SWAP(float, oops->x, o2->x);
+ SWAP(float, oops->y, o2->y);
+ }
+ }
+ }
+ if(dir) o2= o2->prev;
+ else o2= o2->next;
+ }
+ }
+ if(dir) oops= oops->prev;
+ else oops= oops->next;
+
+
+ }
+ if(tot>5) break;
+ }
+ waitcursor(0);
+
+ /* from links vrijgeven */
+ oops= G.soops->oops.first;
+ while(oops) {
+ if(oops->hide==0) {
+ ol= oops->link.first;
+ while(ol) {
+ oln= ol->next;
+ if(ol->from) {
+ BLI_remlink(&oops->link, ol);
+ MEM_freeN(ol);
+ }
+ ol= oln;
+ }
+ }
+ oops= oops->next;
+ }
+
+ allqueue(REDRAWOOPS, 1);
+}
+
+void shrink_oops()
+{
+ Oops *oops;
+ OopsLink *ol;
+ float vec[4];
+ int /* go= 1, */tot=4;
+
+
+ if(G.soops==0) return;
+
+ if(okee("Shrink oops")==0) return;
+
+ waitcursor(1);
+
+ /* clear */
+ oops= G.soops->oops.first;
+ while(oops) {
+ oops->dx= oops->dy= 0.0;
+ oops= oops->next;
+ }
+
+ while(tot) {
+ tot--;
+
+ /* shrink */
+ oops= G.soops->oops.first;
+ while(oops) {
+ if(oops->link.first && oops->hide==0 && (oops->flag & SELECT)) {
+
+ ol= oops->link.first;
+ while(ol) {
+ if(ol->to && ol->to->hide==0) {
+
+ give_oopslink_line(oops, ol, vec, vec+2);
+
+ oops->dx= (float)(.8*oops->dx + .2*( vec[2]-vec[0]));
+ oops->dy= (float)(.8*oops->dy + .2*( vec[3]-vec[1]));
+
+ if(ol->to->flag & SELECT) {
+ ol->to->dx= (float)(.8*ol->to->dx + .2*( vec[0]-vec[2]));
+ ol->to->dy= (float)(.8*ol->to->dy + .2*( vec[1]-vec[3]));
+ }
+ }
+
+ ol= ol->next;
+ }
+ }
+ oops= oops->next;
+ }
+
+ /* apply */
+ oops= G.soops->oops.first;
+ while(oops) {
+ if(oops->hide==0 && (oops->flag & SELECT)) {
+
+ /* shrink */
+ oops->x+= oops->dx;
+ oops->y+= oops->dy;
+
+ if(oops_test_overlaphide(oops)) {
+ oops->x-= oops->dx;
+ oops->y-= oops->dy;
+ }
+
+ oops->dx= oops->dy= 0.0;
+ }
+ oops= oops->next;
+ }
+ }
+ waitcursor(0);
+
+ allqueue(REDRAWOOPS, 1);
+}
+
+#define LIMSCE -20.0
+#define LIMOB 14.0
+#define LIMDATA 24.0
+
+static int correct_oops_y(Oops *oops)
+{
+ float y;
+
+ y= oops->y;
+
+ switch(oops->type) {
+ case ID_SCE:
+ case ID_LI:
+ if(oops->y > LIMSCE-OOPSY) oops->y= (float)(LIMSCE-OOPSY);
+ break;
+ case ID_OB:
+ CLAMP(oops->y, LIMSCE, LIMOB);
+ break;
+ case ID_IP:
+ case ID_MA:
+ case ID_TE:
+ if(oops->y < LIMDATA+OOPSY) oops->y= (float)(LIMDATA+OOPSY);
+ break;
+ default:
+ CLAMP(oops->y, (float)(LIMOB+OOPSY), LIMDATA);
+ break;
+ }
+
+ if(y==oops->y) return 0;
+ else return 1;
+}
+
+float oopslastx=0.0, oopslasty= 0.0;
+
+void new_oops_location(Oops *new)
+{
+ float dirvec[4][2];
+ static int cnt=0;
+ int a, b, rc= 1, tel=1, ok=0;
+
+ if(G.soops==0) return;
+
+ if(G.soops->oops.first==G.soops->oops.last) {
+ oopslastx= oopslasty= 0.0;
+ }
+
+ cnt++;
+
+ new->x= oopslastx;
+ new->y= oopslasty;
+
+ correct_oops_y(new);
+
+ /* vanuit centrum vrije plek vinden */
+ dirvec[cnt & 3][0]= 1.2*OOPSX;
+ dirvec[cnt & 3][1]= 0;
+ cnt++;
+ dirvec[cnt & 3][0]= 0;
+ dirvec[cnt & 3][1]= (float)(-1.2*OOPSY);
+ cnt++;
+ dirvec[cnt & 3][0]= -1.2*OOPSX;
+ dirvec[cnt & 3][1]= 0;
+ cnt++;
+ dirvec[cnt & 3][0]= 0;
+ dirvec[cnt & 3][1]= (float)(1.2*OOPSY);
+ cnt++;
+
+
+ new->x+= dirvec[ (rc-2) & 3][0];
+ new->y+= dirvec[ (rc-2) & 3][1];
+ rc+= correct_oops_y(new);
+
+ if( oops_test_overlap(new)==0 ) {
+ ok= 1;
+ }
+
+ rc++;
+
+ if(ok==0) {
+ new->x+= dirvec[ (rc-1) & 3][0];
+ new->y+= dirvec[ (rc-1) & 3][1];
+ rc+= correct_oops_y(new);
+
+ if(oops_test_overlap(new)==0 ) {
+ ok= 1;
+ }
+ rc++;
+ }
+
+
+ while(ok==0) {
+
+ for(a=0;a<2;a++) {
+ for(b=0;b<tel;b++) {
+
+ if( oops_test_overlap(new)==0 ) {
+ ok= 1;
+ break;
+ }
+
+ rc &= 3;
+ new->x += dirvec[rc][0];
+ new->y += dirvec[rc][1];
+ rc+= correct_oops_y(new);
+ }
+ rc++;
+
+
+
+ if(ok) break;
+ }
+ if(ok || tel>100) break;
+ tel++;
+ }
+ oopslastx= new->x;
+ oopslasty= new->y;
+
+}
+
+
+void free_oops(Oops *oops) /* ook oops zelf */
+{
+ BLI_freelistN(&oops->link);
+ MEM_freeN(oops);
+}
+
+void free_oopspace(SpaceOops *so)
+{
+ Oops *oops;
+
+ while( (oops= so->oops.first) ) {
+ BLI_remlink(&so->oops, oops);
+ free_oops(oops);
+ }
+}
+
+void add_material_oopslinks(Material *ma, Oops *oops, short flag)
+{
+ int a;
+
+ if(flag & OOPS_TE) {
+ for(a=0; a<8; a++) {
+ if(ma->mtex[a]) add_oopslink("tex", oops, ID_TE, &(ma->mtex[a]->tex), (float)(0.5*OOPSX), (float)OOPSY);
+ }
+ }
+ if(flag & OOPS_OB) {
+ for(a=0; a<8; a++) {
+ if(ma->mtex[a]) add_oopslink("ob", oops, ID_OB, &(ma->mtex[a]->object), 0.0, (float)(0.2*OOPSY));
+ }
+ }
+ if(flag & OOPS_IP) {
+ if(ma->ipo) add_oopslink("ipo", oops, ID_IP, &(ma->ipo), OOPSX, (float)(0.5*OOPSY));
+ }
+}
+
+
+void add_object_oopslinks(Object *ob, Oops *oops, short flag)
+{
+ ID *id;
+
+ if(ob->parent) add_oopslink("parent", oops, ID_OB, &ob->parent, (float)(.6*OOPSX), (float)OOPSY);
+ if(ob->track) add_oopslink("parent", oops, ID_OB, &ob->track, (float)(.4*OOPSX), (float)OOPSY);
+
+ id= ob->data;
+ if(id) {
+ switch( GS(id->name) ) {
+ case ID_ME:
+ if(flag & OOPS_ME) add_oopslink("data", oops, ID_ME, &ob->data, (float)(.5*OOPSX), (float)OOPSY);
+ break;
+ case ID_CU:
+ if(flag & OOPS_CU) add_oopslink("data", oops, ID_CU, &ob->data, (float)(.5*OOPSX), (float)OOPSY);
+ break;
+ case ID_MB:
+ if(flag & OOPS_MB) add_oopslink("data", oops, ID_MB, &ob->data, (float)(.5*OOPSX), (float)OOPSY);
+ break;
+ case ID_LT:
+ if(flag & OOPS_LT) add_oopslink("data", oops, ID_LT, &ob->data, (float)(.5*OOPSX), (float)OOPSY);
+ break;
+ case ID_LA:
+ if(flag & OOPS_LA) add_oopslink("data", oops, ID_LA, &ob->data, (float)(.5*OOPSX), (float)OOPSY);
+ break;
+ }
+ }
+
+ if(flag & OOPS_MA) {
+ short a;
+
+ for(a=0; a<ob->totcol; a++) {
+ if(ob->mat[a]) {
+ add_oopslink("mat", oops, ID_MA, ob->mat+a, 0, (float)(0.5*OOPSY));
+ }
+ }
+ }
+
+ if(flag & OOPS_IP) add_oopslink("ipo", oops, ID_IP, &ob->ipo, OOPSX, (float)(0.5*OOPSY));
+}
+
+void add_mesh_oopslinks(Mesh *me, Oops *oops, short flag)
+{
+ int a;
+
+ if(flag & OOPS_MA) {
+ for(a=0; a<me->totcol; a++) {
+ if(me->mat[a]) {
+ add_oopslink("ma", oops, ID_MA, me->mat+a, 0.0, (float)(0.5*OOPSY));
+ }
+ }
+ }
+ if(flag & OOPS_IP) {
+ if(me->key) add_oopslink("ipo", oops, ID_IP, &me->key->ipo, OOPSX, (float)(0.5*OOPSY));
+ }
+}
+
+void add_curve_oopslinks(Curve *cu, Oops *oops, short flag)
+{
+ int a;
+
+ if(flag & OOPS_MA) {
+ for(a=0; a<cu->totcol; a++) {
+ if(cu->mat[a]) {
+ add_oopslink("ma", oops, ID_MA, cu->mat+a, 0.0, (float)(0.5*OOPSY));
+ }
+ }
+ }
+ if(flag & OOPS_IP) {
+ add_oopslink("speed", oops, ID_IP, &cu->ipo, OOPSX, (float)(0.5*OOPSY));
+ if(cu->key) add_oopslink("ipo", oops, ID_IP, &cu->key->ipo, OOPSX, (float)(0.5*OOPSY));
+ }
+
+}
+
+void add_mball_oopslinks(MetaBall *mb, Oops *oops, short flag)
+{
+ int a;
+
+ if(flag & OOPS_MA) {
+ for(a=0; a<mb->totcol; a++) {
+ if(mb->mat[a]) {
+ add_oopslink("ma", oops, ID_MA, mb->mat+a, 0.0, (float)(0.5*OOPSY));
+ }
+ }
+ }
+}
+
+Oops *add_test_oops(void *id) /* incl links */
+{
+ Oops *oops;
+ Object *ob;
+ Lamp *la;
+ Tex *tex;
+
+ if(id==0) return NULL;
+
+ /* eerst test ofie al bestaat */
+ oops= find_oops(id);
+
+ if(oops) {
+ oops->hide= 0;
+ }
+ else {
+ oops= add_oops(id);
+ new_oops_location(oops);
+ if(G.soops->flag & SO_NEWSELECTED) {
+ oops->flag |= SELECT;
+ }
+ }
+
+ switch( GS( ((ID *)id)->name)) {
+ case ID_SCE:
+ add_oopslink("set", oops, ID_SCE, &((Scene *)id)->set, (float)(.5*OOPSX), (float)OOPSY);
+ break;
+ case ID_OB:
+ ob= (Object *)id;
+ if(ob->flag & SELECT) oops->flag |= SELECT;
+ else oops->flag &= ~SELECT;
+ add_object_oopslinks(ob, oops, G.soops->visiflag);
+ break;
+ case ID_ME:
+ add_mesh_oopslinks((Mesh *)id, oops, G.soops->visiflag);
+ break;
+ case ID_CU:
+ add_curve_oopslinks((Curve *)id, oops, G.soops->visiflag);
+ break;
+ case ID_MB:
+ add_mball_oopslinks((MetaBall *)id, oops, G.soops->visiflag);
+ break;
+ case ID_LA:
+ /* textures nog doen */
+ la= (Lamp *)id;
+ if(la->ipo) if(G.soops->visiflag & OOPS_IP) add_oopslink("ipo", oops, ID_IP, &la->ipo, OOPSX, (float)(0.3*OOPSY));
+ break;
+ case ID_IP:
+
+ break;
+ case ID_MA:
+ add_material_oopslinks((Material *)id, oops, G.soops->visiflag);
+ break;
+ case ID_TE:
+ tex= (Tex *)id;
+ if(tex->ima) if(G.soops->visiflag & OOPS_IM) add_oopslink("image", oops, ID_IM, &tex->ima, OOPSX, (float)(0.3*OOPSY));
+ }
+
+ return oops;
+}
+
+void add_texture_oops(Material *ma)
+{
+ int a;
+
+ for(a=0; a<8; a++) {
+ if(ma->mtex[a]) {
+ add_test_oops(ma->mtex[a]->tex);
+ if(ma->mtex[a]->tex) if(G.soops->visiflag & OOPS_IM) add_test_oops(ma->mtex[a]->tex->ima);
+ }
+ }
+}
+
+void build_oops()
+{
+ Oops *oops;
+ OopsLink *ol;
+ ID *id;
+ Base *base;
+ Object *ob;
+ short a, type;
+
+ /* altijd alles bouwen! */
+
+ if(G.soops==0) return;
+
+ /* set hide flags */
+ oops= G.soops->oops.first;
+ while(oops) {
+ oops->hide= 1;
+ oops->flag &= ~OOPS_REFER;
+
+ BLI_freelistN(&oops->link); /* veel veiliger */
+
+ oops= oops->next;
+ }
+
+ /* oopsen maken,is ook testen of ie al bestaat */
+
+ /* altijd */
+ if(G.soops->visiflag & OOPS_LI) {
+ Library *li= G.main->library.first;
+ while(li) {
+ oops= add_test_oops(li);
+ li= li->id.next;
+ }
+ }
+
+ /* rest op twee manieren: of alles (OOPS_SCE) of alleen gebruikt in deze scene */
+
+ if(G.soops->visiflag & OOPS_SCE) {
+ Scene *sce= G.main->scene.first;
+
+ while(sce) {
+
+ oops= add_test_oops(sce);
+
+ if(G.soops->visiflag & OOPS_OB) {
+ base= sce->base.first;
+ while(base) {
+
+ add_oopslink("object", oops, ID_OB, &base->object, (float)(.5*OOPSX), (float)OOPSY);
+ base= base->next;
+ }
+ }
+
+ sce= sce->id.next;
+ }
+
+ if(G.soops->visiflag & OOPS_OB) {
+ Object *ob= G.main->object.first;
+
+ while(ob) {
+ oops= add_test_oops(ob);
+ ob= ob->id.next;
+ }
+ }
+ if(G.soops->visiflag & OOPS_ME) {
+ Mesh *me= G.main->mesh.first;
+ while(me) {
+ oops= add_test_oops(me);
+ me= me->id.next;
+ }
+ }
+
+ if(G.soops->visiflag & OOPS_CU) {
+ Curve *cu= G.main->curve.first;
+ while(cu) {
+ oops= add_test_oops(cu);
+ cu= cu->id.next;
+ }
+ }
+
+ if(G.soops->visiflag & OOPS_MB) {
+ MetaBall *mb= G.main->mball.first;
+ while(mb) {
+ oops= add_test_oops(mb);
+ mb= mb->id.next;
+ }
+ }
+
+ if(G.soops->visiflag & OOPS_LA) {
+ Lamp *la= G.main->lamp.first;
+ while(la) {
+ oops= add_test_oops(la);
+ la= la->id.next;
+ }
+ }
+
+ if(G.soops->visiflag & OOPS_IP) {
+ Ipo *ipo= G.main->ipo.first;
+ while(ipo) {
+ oops= add_test_oops(ipo);
+ ipo= ipo->id.next;
+ }
+ }
+
+ if(G.soops->visiflag & OOPS_MA) {
+ Material *ma= G.main->mat.first;
+ while(ma) {
+ oops= add_test_oops(ma);
+ ma= ma->id.next;
+ }
+ }
+ if(G.soops->visiflag & OOPS_TE) {
+ Tex *tex= G.main->tex.first;
+ while(tex) {
+ oops= add_test_oops(tex);
+ tex= tex->id.next;
+ }
+ }
+ if(G.soops->visiflag & OOPS_IM) {
+ Image *ima= G.main->image.first;
+ while(ima) {
+ oops= add_test_oops(ima);
+ ima= ima->id.next;
+ }
+ }
+
+ }
+ else {
+
+ /* alleen blokken uit huidige scene */
+
+ base= FIRSTBASE;
+ while(base) {
+
+ /* layer? */
+ if( (G.soops->visiflag & OOPS_LAY)==0 || (base->lay & G.scene->lay)) {
+ ob= base->object;
+
+ if(G.soops->visiflag & OOPS_OB) {
+ oops= add_test_oops(ob);
+ }
+ if(G.soops->visiflag & OOPS_MA) {
+ for(a=0; a<ob->totcol; a++) {
+ if(ob->mat[a]) {
+ oops= add_test_oops(ob->mat[a]);
+ if(G.soops->visiflag & OOPS_TE) add_texture_oops(ob->mat[a]);
+ }
+ }
+ }
+ if(G.soops->visiflag & OOPS_IP) oops= add_test_oops(ob->ipo);
+
+ id= ob->data;
+ if(id) {
+ type= GS(id->name);
+
+ if(type==ID_ME && G.soops->visiflag & OOPS_ME) {
+ Mesh *me= ob->data;
+ oops= add_test_oops(ob->data);
+
+ if(G.soops->visiflag & OOPS_MA) {
+ for(a=0; a<me->totcol; a++) {
+ if(me->mat[a]) {
+ oops= add_test_oops(me->mat[a]);
+ if(G.soops->visiflag & OOPS_TE) add_texture_oops(me->mat[a]);
+ }
+ }
+ }
+ if(G.soops->visiflag & OOPS_IP) {
+ if(me->key) oops= add_test_oops(me->key->ipo);
+ }
+ }
+ else if(type==ID_CU && G.soops->visiflag & OOPS_CU) {
+ Curve *cu= ob->data;
+ oops= add_test_oops(ob->data);
+
+ if(G.soops->visiflag & OOPS_MA) {
+ for(a=0; a<cu->totcol; a++) {
+ if(cu->mat[a]) {
+ oops= add_test_oops(cu->mat[a]);
+ if(G.soops->visiflag & OOPS_TE) add_texture_oops(cu->mat[a]);
+ }
+ }
+ }
+ if(G.soops->visiflag & OOPS_IP) {
+ if(cu->ipo) oops= add_test_oops(cu->ipo);
+ if(cu->key) oops= add_test_oops(cu->key->ipo);
+ }
+ }
+ else if(type==ID_MB && G.soops->visiflag & OOPS_MB) {
+ oops= add_test_oops(ob->data);
+
+ if(G.soops->visiflag & OOPS_MA) {
+ MetaBall *mb= ob->data;
+ for(a=0; a<mb->totcol; a++) {
+ if(mb->mat[a]) {
+ oops= add_test_oops(mb->mat[a]);
+ if(G.soops->visiflag & OOPS_TE) add_texture_oops(mb->mat[a]);
+ }
+ }
+ }
+ }
+ else if(type==ID_LA && G.soops->visiflag & OOPS_LA) {
+ oops= add_test_oops(ob->data);
+ }
+ }
+ }
+ base= base->next;
+ }
+ }
+
+
+
+
+ /* links testen */
+ oops= G.soops->oops.first;
+ while(oops) {
+ if(oops->hide==0) {
+ ol= oops->link.first;
+ while(ol) {
+ test_oopslink(ol);
+ ol= ol->next;
+ }
+ }
+ oops= oops->next;
+ }
+
+ G.soops->flag &= ~SO_NEWSELECTED;
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-17 08:33:53 +0300