Filling in branch from trunk
[blender.git] / source / blender / src / drawdeps.c
1 /**
2  * $Id$
3  *
4  * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version. The Blender
10  * Foundation also sells licenses for use in proprietary software under
11  * the Blender License.  See http://www.blender.org/BL/ for information
12  * about this.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software Foundation,
21  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
22  *
23  * The Original Code is Copyright (C) 2004 Blender Foundation.
24  * All rights reserved.
25  *
26  * Contributor(s): none yet.
27  *
28  * ***** END GPL/BL DUAL LICENSE BLOCK *****
29  */
30
31 #include <stdio.h>
32 #include <string.h>
33 #include <math.h>
34
35 #ifdef _WIN32
36 #include "BLI_winstuff.h"
37 #endif
38
39 #include "BMF_Api.h"
40
41 #include "BLI_blenlib.h"
42 #include "BLI_arithb.h"
43
44 #include "DNA_ID.h"
45 #include "DNA_object_types.h"
46 #include "DNA_oops_types.h"
47 #include "DNA_scene_types.h"
48 #include "DNA_screen_types.h"
49 #include "DNA_space_types.h"
50 #include "DNA_view2d_types.h"
51 #include "DNA_action_types.h"
52
53 #include "BKE_utildefines.h"
54 #include "BKE_global.h"
55
56 #include "BIF_interface.h"
57 #include "BIF_gl.h"
58 #include "BIF_glutil.h"
59 #include "BIF_mywindow.h"
60 #include "BIF_resources.h"
61 #include "BIF_screen.h"
62
63 #include "BIF_oops.h"
64
65 #include "BSE_drawipo.h"
66 #include "BSE_drawoops.h"
67 #include "MEM_guardedalloc.h"
68 #include "blendef.h"
69
70
71 #include "depsgraph_private.h"
72
73 #ifdef WIN32
74 #else
75 #include <sys/time.h>
76 #endif
77
78
79
80 void boundbox_deps()
81 {
82         DagNode *node;
83         float min[2], max[2];
84         
85         if(G.soops==0) return;
86         
87         min[0]= 1000.0;
88         max[0]= -10000.0;
89         min[1]= 1000.0;
90         max[1]= -1000.0;
91         
92         node = getMainDag()->DagNode.first;
93         while(node) {
94                 min[0]= MIN2(min[0], node->x);
95                 max[0]= MAX2(max[0], node->x+OOPSX);
96                 min[1]= MIN2(min[1], node->y);
97                 max[1]= MAX2(max[1], node->y+OOPSY);
98                 
99                 node= node->next;
100         }
101                 
102         G.v2d->tot.xmin= min[0];
103         G.v2d->tot.xmax= max[0];
104         G.v2d->tot.ymin= min[1];
105         G.v2d->tot.ymax= max[1];
106 }
107
108 static unsigned int get_line_color(DagAdjList *child)
109 {
110         switch  (child->type) {
111                 case DAG_RL_SCENE :
112                         return 0x00000;
113                 case DAG_RL_DATA :
114                         return 0xFF0000;
115                 case DAG_RL_OB_OB :
116                         return 0x00FF00;
117                 case DAG_RL_OB_DATA :
118                         return 0xFFFF00;
119                 case DAG_RL_DATA_OB :
120                         return 0x000000;
121                 case DAG_RL_DATA_DATA :
122                         return 0x0000FF;
123                 default :
124                         return 0xFF00FF;
125         }
126         //return 0x00000;
127 }
128
129
130 static void draw_deps(DagNode *node)
131 {
132         float v1[2], x1, y1, x2, y2;
133         unsigned int body, border;
134         short line= 0;
135         char str[32];
136         DagAdjList *itA = node->child;
137
138         x1= node->x; 
139         x2= node->x+DEPSX;
140         y1= node->y; 
141         y2= node->y+DEPSY;
142
143         if(x2 < G.v2d->cur.xmin || x1 > G.v2d->cur.xmax) return;
144         if(y2 < G.v2d->cur.ymin || y1 > G.v2d->cur.ymax) return;
145
146         body =  give_oops_color(node->type, 0, &border);
147
148         line= 0;
149 //      border= 00;
150         cpack(body);
151
152         glRectf(x1,  y1,  x2,  y2);
153         
154         v1[0]= x1; 
155         v1[1]= (y1+y2)/2 -0.3f;
156         sprintf(str, "     %s", ((ID *) node->ob)->name+2);
157         
158         calc_oopstext(str, v1);
159         
160                 /* ICON */
161 //      if(str[1] && oopscalex>1.1) {
162         draw_icon_oops(v1, node->type);
163 //      }
164
165         
166         cpack(0x0);
167         glRasterPos3f(v1[0],  v1[1], 0.0);
168         BMF_DrawString(G.fonts, str);
169
170         
171         if(line) setlinestyle(2);
172         cpack(border);
173
174         glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
175         glRectf(x1,  y1,  x2,  y2);
176         glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
177         if(line) setlinestyle(0);
178
179         while (itA) { /* draw connection lines */
180                 cpack(get_line_color(itA));
181                 glBegin(GL_LINE_STRIP);
182                         glVertex2f(node->x+DEPSX, node->y+ 0.5*DEPSY);
183                         glVertex2f(itA->node->x, itA->node->y+ 0.5*DEPSY);                      
184                 glEnd();
185                 itA = itA->next;
186         }
187                         /* Draw the little rounded connection point */
188                 glColor3ub(0, 0, 0);
189                 glPushMatrix();
190
191                 glTranslatef(node->x , node->y+ 0.5*DEPSY, 0.0);
192                 glutil_draw_filled_arc(-M_PI/2, M_PI, 0.07*DEPSX, 7);
193
194                 glPopMatrix();
195
196 }
197
198 void    draw_all_deps(void)
199 {
200         DagNode *node;
201         DagForest *dag;
202         
203         dag = getMainDag();
204          node = dag->DagNode.first;
205         //node = node->next;
206         while(node) {
207                 draw_deps(node);
208                 node = node->next;
209         }
210         free_forest(dag);
211         MEM_freeN(dag);
212         setMainDag(NULL);
213 }
214
215
216
217
218 int build_deps(short mask)
219 {
220         Base *base;
221         Object *ob = NULL;
222         DagNode * node = NULL; 
223         DagNode * node2 = NULL ;
224 DagNode * scenenode;
225         DagForest *dag;
226
227 #ifdef DEPS_DEBUG
228         //timers
229         struct timeval tp1, tp2, tp3, tp4;
230         
231         gettimeofday(&tp1,NULL);
232 #endif
233         
234         DagNodeQueue *retqueue;
235         
236 //      float y = 0;
237 //      int maxlev = 0;
238
239         if(G.soops==0) return -1;
240         
241         
242         // rebuilt each time for now
243         dag = getMainDag();
244         if ( dag)
245                 free_forest( dag ); 
246         else {
247                 dag = dag_init();
248                 setMainDag(dag);
249                 }
250                 
251         // add base node for scene. scene is always the first node in DAG
252         scenenode = dag_add_node(dag, G.scene);
253         set_node_xy(scenenode,0.0, 0.0);        
254                 /* blocks from this scene */
255                 
256                 
257                 /* targets in object struct yet to be added. should even they ?
258                                 struct Ipo *ipo;
259                         ListBase nlastrips;
260                         ListBase hooks;
261                 */
262                 
263                 
264         base= FIRSTBASE;
265         while(base) { // add all objects in any case
266                 int addtoroot = 1;
267                 
268                 //                               graph_print_adj_list();
269                 ob= (Object *) base->object;
270
271                 node = dag_get_node(dag,ob);
272         
273                 if ((ob->data) && (mask&DAG_RL_DATA)) {
274                         node2 = dag_get_node(dag,ob->data);
275                         dag_add_relation(dag,node,node2,DAG_RL_DATA);
276                         node2->first_ancestor = ob;
277                         node2->ancestor_count += 1;
278                         
279                 } 
280                 
281                 if (addtoroot == 1 )
282                         dag_add_relation(dag,scenenode,node,DAG_RL_SCENE);
283                 
284                 base= base->next;
285         }
286
287 //graph_print_adj_list();
288 //fprintf(stderr,"building deps\n");
289 #ifdef DEPS_DEBUG
290         gettimeofday(&tp2,NULL);
291 #endif
292
293 //graph_bfs(); //set levels
294
295 #ifdef DEPS_DEBUG
296 gettimeofday(&tp3,NULL);
297 #endif
298
299
300 retqueue = graph_dfs(); //set levels
301 #ifdef DEPS_DEBUG
302 gettimeofday(&tp4,NULL);
303 fprintf(stderr,"************************************\n");
304 graph_print_queue_dist(retqueue);
305 //graph_print_queue(retqueue);
306
307 fprintf(stderr,"TIME BUILD %d %d BFS %d %d DFS  %d %d\n",tp2.tv_sec-tp1.tv_sec ,tp2.tv_usec-tp1.tv_usec
308                                                                                                                 , tp3.tv_sec-tp2.tv_sec ,tp3.tv_usec-tp2.tv_usec
309                                                                                                                 , tp4.tv_sec-tp3.tv_sec ,tp4.tv_usec-tp3.tv_usec);
310 #endif
311
312 queue_delete(retqueue);
313
314 //graph_print_adj_list();
315 return 0;
316 }