doxygen: blender/editors tagged.
[blender.git] / source / blender / editors / space_view3d / drawvolume.c
1 /*
2  * $Id$
3  *
4  * ***** BEGIN GPL 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.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19  *
20  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
21  * All rights reserved.
22  *
23  * Contributor(s): Daniel Genrich
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file blender/editors/space_view3d/drawvolume.c
29  *  \ingroup spview3d
30  */
31
32
33
34 #include <string.h>
35 #include <math.h>
36
37 #include "MEM_guardedalloc.h"
38
39 #include "DNA_scene_types.h"
40 #include "DNA_screen_types.h"
41 #include "DNA_view3d_types.h"
42
43 #include "BLI_blenlib.h"
44 #include "BLI_math.h"
45 #include "BLI_editVert.h"
46 #include "BLI_edgehash.h"
47 #include "BLI_rand.h"
48 #include "BLI_utildefines.h"
49
50 #include "BKE_curve.h"
51 #include "BKE_constraint.h" // for the get_constraint_target function
52 #include "BKE_DerivedMesh.h"
53 #include "BKE_deform.h"
54 #include "BKE_displist.h"
55 #include "BKE_effect.h"
56 #include "BKE_font.h"
57 #include "BKE_global.h"
58 #include "BKE_image.h"
59 #include "BKE_key.h"
60 #include "BKE_lattice.h"
61 #include "BKE_mesh.h"
62 #include "BKE_material.h"
63 #include "BKE_mball.h"
64 #include "BKE_modifier.h"
65 #include "BKE_object.h"
66 #include "BKE_paint.h"
67 #include "BKE_particle.h"
68 #include "BKE_property.h"
69 #include "BKE_smoke.h"
70
71 #include "smoke_API.h"
72
73 #include "BIF_gl.h"
74
75 #include "GPU_extensions.h"
76
77 #include "ED_mesh.h"
78
79
80 #include "BLF_api.h"
81
82
83 #include "view3d_intern.h"      // own include
84
85
86 #ifdef _WIN32
87 #include <time.h>
88 #include <stdio.h>
89 #include <conio.h>
90 #include <windows.h>
91
92 static LARGE_INTEGER liFrequency;
93 static LARGE_INTEGER liStartTime;
94 static LARGE_INTEGER liCurrentTime;
95
96 static void tstart ( void )
97 {
98         QueryPerformanceFrequency ( &liFrequency );
99         QueryPerformanceCounter ( &liStartTime );
100 }
101 static void tend ( void )
102 {
103         QueryPerformanceCounter ( &liCurrentTime );
104 }
105 static double tval( void )
106 {
107         return ((double)( (liCurrentTime.QuadPart - liStartTime.QuadPart)* (double)1000.0/(double)liFrequency.QuadPart ));
108 }
109 #else
110 #include <sys/time.h>
111 static struct timeval _tstart, _tend;
112 static struct timezone tz;
113 static void tstart ( void )
114 {
115         gettimeofday ( &_tstart, &tz );
116 }
117 static void tend ( void )
118 {
119         gettimeofday ( &_tend,&tz );
120 }
121   #if 0
122 static double tval()
123 {
124         double t1, t2;
125         t1 = ( double ) _tstart.tv_sec*1000 + ( double ) _tstart.tv_usec/ ( 1000 );
126         t2 = ( double ) _tend.tv_sec*1000 + ( double ) _tend.tv_usec/ ( 1000 );
127         return t2-t1;
128 }
129   #endif
130 #endif
131
132 struct GPUTexture;
133
134 static int intersect_edges(float *points, float a, float b, float c, float d, float edges[12][2][3])
135 {
136         int i;
137         float t;
138         int numpoints = 0;
139         
140         for (i=0; i<12; i++) {
141                 t = -(a*edges[i][0][0] + b*edges[i][0][1] + c*edges[i][0][2] + d)
142                         / (a*edges[i][1][0] + b*edges[i][1][1] + c*edges[i][1][2]);
143                 if ((t>0)&&(t<1)) {
144                         points[numpoints * 3 + 0] = edges[i][0][0] + edges[i][1][0]*t;
145                         points[numpoints * 3 + 1] = edges[i][0][1] + edges[i][1][1]*t;
146                         points[numpoints * 3 + 2] = edges[i][0][2] + edges[i][1][2]*t;
147                         numpoints++;
148                 }
149         }
150         return numpoints;
151 }
152
153 static int convex(float *p0, float *up, float *a, float *b)
154 {
155         // Vec3 va = a-p0, vb = b-p0;
156         float va[3], vb[3], tmp[3];
157         VECSUB(va, a, p0);
158         VECSUB(vb, b, p0);
159         cross_v3_v3v3(tmp, va, vb);
160         return INPR(up, tmp) >= 0;
161 }
162
163 // copied from gpu_extension.c
164 static int is_pow2(int n)
165 {
166         return ((n)&(n-1))==0;
167 }
168
169 static int larger_pow2(int n)
170 {
171         if (is_pow2(n))
172                 return n;
173
174         while(!is_pow2(n))
175                 n= n&(n-1);
176
177         return n*2;
178 }
179
180 void draw_volume(ARegion *ar, GPUTexture *tex, float *min, float *max, int res[3], float dx, GPUTexture *tex_shadow)
181 {
182         RegionView3D *rv3d= ar->regiondata;
183
184         float viewnormal[3];
185         int i, j, n, good_index;
186         float d, d0, dd, ds;
187         float *points = NULL;
188         int numpoints = 0;
189         float cor[3] = {1.,1.,1.};
190         int gl_depth = 0, gl_blend = 0;
191
192         /* draw slices of smoke is adapted from c++ code authored by: Johannes Schmid and Ingemar Rask, 2006, johnny@grob.org */
193         float cv[][3] = {
194                 {1.0f, 1.0f, 1.0f}, {-1.0f, 1.0f, 1.0f}, {-1.0f, -1.0f, 1.0f}, {1.0f, -1.0f, 1.0f},
195                 {1.0f, 1.0f, -1.0f}, {-1.0f, 1.0f, -1.0f}, {-1.0f, -1.0f, -1.0f}, {1.0f, -1.0f, -1.0f}
196         };
197
198         // edges have the form edges[n][0][xyz] + t*edges[n][1][xyz]
199         float edges[12][2][3] = {
200                 {{1.0f, 1.0f, -1.0f}, {0.0f, 0.0f, 2.0f}},
201                 {{-1.0f, 1.0f, -1.0f}, {0.0f, 0.0f, 2.0f}},
202                 {{-1.0f, -1.0f, -1.0f}, {0.0f, 0.0f, 2.0f}},
203                 {{1.0f, -1.0f, -1.0f}, {0.0f, 0.0f, 2.0f}},
204
205                 {{1.0f, -1.0f, 1.0f}, {0.0f, 2.0f, 0.0f}},
206                 {{-1.0f, -1.0f, 1.0f}, {0.0f, 2.0f, 0.0f}},
207                 {{-1.0f, -1.0f, -1.0f}, {0.0f, 2.0f, 0.0f}},
208                 {{1.0f, -1.0f, -1.0f}, {0.0f, 2.0f, 0.0f}},
209
210                 {{-1.0f, 1.0f, 1.0f}, {2.0f, 0.0f, 0.0f}},
211                 {{-1.0f, -1.0f, 1.0f}, {2.0f, 0.0f, 0.0f}},
212                 {{-1.0f, -1.0f, -1.0f}, {2.0f, 0.0f, 0.0f}},
213                 {{-1.0f, 1.0f, -1.0f}, {2.0f, 0.0f, 0.0f}}
214         };
215
216         /* Fragment program to calculate the view3d of smoke */
217         /* using 2 textures, density and shadow */
218         const char *text = "!!ARBfp1.0\n"
219                                         "PARAM dx = program.local[0];\n"
220                                         "PARAM darkness = program.local[1];\n"
221                                         "PARAM f = {1.442695041, 1.442695041, 1.442695041, 0.01};\n"
222                                         "TEMP temp, shadow, value;\n"
223                                         "TEX temp, fragment.texcoord[0], texture[0], 3D;\n"
224                                         "TEX shadow, fragment.texcoord[0], texture[1], 3D;\n"
225                                         "MUL value, temp, darkness;\n"
226                                         "MUL value, value, dx;\n"
227                                         "MUL value, value, f;\n"
228                                         "EX2 temp, -value.r;\n"
229                                         "SUB temp.a, 1.0, temp.r;\n"
230                                         "MUL temp.r, temp.r, shadow.r;\n"
231                                         "MUL temp.g, temp.g, shadow.r;\n"
232                                         "MUL temp.b, temp.b, shadow.r;\n"
233                                         "MOV result.color, temp;\n"
234                                         "END\n";
235         GLuint prog;
236
237         
238         float size[3];
239
240         if(!tex) {
241                 printf("Could not allocate 3D texture for 3D View smoke drawing.\n");
242                 return;
243         }
244
245         tstart();
246
247         VECSUB(size, max, min);
248
249         // maxx, maxy, maxz
250         cv[0][0] = max[0];
251         cv[0][1] = max[1];
252         cv[0][2] = max[2];
253         // minx, maxy, maxz
254         cv[1][0] = min[0];
255         cv[1][1] = max[1];
256         cv[1][2] = max[2];
257         // minx, miny, maxz
258         cv[2][0] = min[0];
259         cv[2][1] = min[1];
260         cv[2][2] = max[2];
261         // maxx, miny, maxz
262         cv[3][0] = max[0];
263         cv[3][1] = min[1];
264         cv[3][2] = max[2];
265
266         // maxx, maxy, minz
267         cv[4][0] = max[0];
268         cv[4][1] = max[1];
269         cv[4][2] = min[2];
270         // minx, maxy, minz
271         cv[5][0] = min[0];
272         cv[5][1] = max[1];
273         cv[5][2] = min[2];
274         // minx, miny, minz
275         cv[6][0] = min[0];
276         cv[6][1] = min[1];
277         cv[6][2] = min[2];
278         // maxx, miny, minz
279         cv[7][0] = max[0];
280         cv[7][1] = min[1];
281         cv[7][2] = min[2];
282
283         VECCOPY(edges[0][0], cv[4]); // maxx, maxy, minz
284         VECCOPY(edges[1][0], cv[5]); // minx, maxy, minz
285         VECCOPY(edges[2][0], cv[6]); // minx, miny, minz
286         VECCOPY(edges[3][0], cv[7]); // maxx, miny, minz
287
288         VECCOPY(edges[4][0], cv[3]); // maxx, miny, maxz
289         VECCOPY(edges[5][0], cv[2]); // minx, miny, maxz
290         VECCOPY(edges[6][0], cv[6]); // minx, miny, minz
291         VECCOPY(edges[7][0], cv[7]); // maxx, miny, minz
292
293         VECCOPY(edges[8][0], cv[1]); // minx, maxy, maxz
294         VECCOPY(edges[9][0], cv[2]); // minx, miny, maxz
295         VECCOPY(edges[10][0], cv[6]); // minx, miny, minz
296         VECCOPY(edges[11][0], cv[5]); // minx, maxy, minz
297
298         // printf("size x: %f, y: %f, z: %f\n", size[0], size[1], size[2]);
299         // printf("min[2]: %f, max[2]: %f\n", min[2], max[2]);
300
301         edges[0][1][2] = size[2];
302         edges[1][1][2] = size[2];
303         edges[2][1][2] = size[2];
304         edges[3][1][2] = size[2];
305
306         edges[4][1][1] = size[1];
307         edges[5][1][1] = size[1];
308         edges[6][1][1] = size[1];
309         edges[7][1][1] = size[1];
310
311         edges[8][1][0] = size[0];
312         edges[9][1][0] = size[0];
313         edges[10][1][0] = size[0];
314         edges[11][1][0] = size[0];
315
316         glGetBooleanv(GL_BLEND, (GLboolean *)&gl_blend);
317         glGetBooleanv(GL_DEPTH_TEST, (GLboolean *)&gl_depth);
318
319         glLoadMatrixf(rv3d->viewmat);
320         // glMultMatrixf(ob->obmat);    
321
322         glDepthMask(GL_FALSE);
323         glDisable(GL_DEPTH_TEST);
324         glEnable(GL_BLEND);
325         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
326
327         /*
328         printf("Viewinv:\n");
329         printf("%f, %f, %f\n", rv3d->viewinv[0][0], rv3d->viewinv[0][1], rv3d->viewinv[0][2]);
330         printf("%f, %f, %f\n", rv3d->viewinv[1][0], rv3d->viewinv[1][1], rv3d->viewinv[1][2]);
331         printf("%f, %f, %f\n", rv3d->viewinv[2][0], rv3d->viewinv[2][1], rv3d->viewinv[2][2]);
332         */
333
334         // get view vector
335         VECCOPY(viewnormal, rv3d->viewinv[2]);
336         normalize_v3(viewnormal);
337
338         // find cube vertex that is closest to the viewer
339         for (i=0; i<8; i++) {
340                 float x,y,z;
341
342                 x = cv[i][0] - viewnormal[0];
343                 y = cv[i][1] - viewnormal[1];
344                 z = cv[i][2] - viewnormal[2];
345
346                 if ((x>=min[0])&&(x<=max[0])
347                         &&(y>=min[1])&&(y<=max[1])
348                         &&(z>=min[2])&&(z<=max[2])) {
349                         break;
350                 }
351         }
352
353         if(i >= 8) {
354                 /* fallback, avoid using buffer over-run */
355                 i= 0;
356         }
357
358         // printf("i: %d\n", i);
359         // printf("point %f, %f, %f\n", cv[i][0], cv[i][1], cv[i][2]);
360
361         if (GL_TRUE == glewIsSupported("GL_ARB_fragment_program"))
362         {
363                 glEnable(GL_FRAGMENT_PROGRAM_ARB);
364                 glGenProgramsARB(1, &prog);
365
366                 glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, prog);
367                 glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, (GLsizei)strlen(text), text);
368
369                 // cell spacing
370                 glProgramLocalParameter4fARB (GL_FRAGMENT_PROGRAM_ARB, 0, dx, dx, dx, 1.0);
371                 // custom parameter for smoke style (higher = thicker)
372                 glProgramLocalParameter4fARB (GL_FRAGMENT_PROGRAM_ARB, 1, 7.0, 7.0, 7.0, 1.0);
373         }
374         else
375                 printf("Your gfx card does not support 3D View smoke drawing.\n");
376
377         GPU_texture_bind(tex, 0);
378         if(tex_shadow)
379                 GPU_texture_bind(tex_shadow, 1);
380         else
381                 printf("No volume shadow\n");
382
383         if (!GPU_non_power_of_two_support()) {
384                 cor[0] = (float)res[0]/(float)larger_pow2(res[0]);
385                 cor[1] = (float)res[1]/(float)larger_pow2(res[1]);
386                 cor[2] = (float)res[2]/(float)larger_pow2(res[2]);
387         }
388
389         // our slices are defined by the plane equation a*x + b*y +c*z + d = 0
390         // (a,b,c), the plane normal, are given by viewdir
391         // d is the parameter along the view direction. the first d is given by
392         // inserting previously found vertex into the plane equation
393         d0 = (viewnormal[0]*cv[i][0] + viewnormal[1]*cv[i][1] + viewnormal[2]*cv[i][2]);
394         ds = (ABS(viewnormal[0])*size[0] + ABS(viewnormal[1])*size[1] + ABS(viewnormal[2])*size[2]);
395         dd = 0.05; // ds/512.0f;
396         n = 0;
397         good_index = i;
398
399         // printf("d0: %f, dd: %f, ds: %f\n\n", d0, dd, ds);
400
401         points = MEM_callocN(sizeof(float)*12*3, "smoke_points_preview");
402
403         while(1) {
404                 float p0[3];
405                 float tmp_point[3], tmp_point2[3];
406
407                 if(dd*(float)n > ds)
408                         break;
409
410                 VECCOPY(tmp_point, viewnormal);
411                 mul_v3_fl(tmp_point, -dd*((ds/dd)-(float)n));
412                 VECADD(tmp_point2, cv[good_index], tmp_point);
413                 d = INPR(tmp_point2, viewnormal);
414
415                 // printf("my d: %f\n", d);
416
417                 // intersect_edges returns the intersection points of all cube edges with
418                 // the given plane that lie within the cube
419                 numpoints = intersect_edges(points, viewnormal[0], viewnormal[1], viewnormal[2], -d, edges);
420
421                 // printf("points: %d\n", numpoints);
422
423                 if (numpoints > 2) {
424                         VECCOPY(p0, points);
425
426                         // sort points to get a convex polygon
427                         for(i = 1; i < numpoints - 1; i++)
428                         {
429                                 for(j = i + 1; j < numpoints; j++)
430                                 {
431                                         if(!convex(p0, viewnormal, &points[j * 3], &points[i * 3]))
432                                         {
433                                                 float tmp2[3];
434                                                 VECCOPY(tmp2, &points[j * 3]);
435                                                 VECCOPY(&points[j * 3], &points[i * 3]);
436                                                 VECCOPY(&points[i * 3], tmp2);
437                                         }
438                                 }
439                         }
440
441                         // printf("numpoints: %d\n", numpoints);
442                         glBegin(GL_POLYGON);
443                         glColor3f(1.0, 1.0, 1.0);
444                         for (i = 0; i < numpoints; i++) {
445                                 glTexCoord3d((points[i * 3 + 0] - min[0] )*cor[0]/size[0], (points[i * 3 + 1] - min[1])*cor[1]/size[1], (points[i * 3 + 2] - min[2])*cor[2]/size[2]);
446                                 glVertex3f(points[i * 3 + 0], points[i * 3 + 1], points[i * 3 + 2]);
447                         }
448                         glEnd();
449                 }
450                 n++;
451         }
452
453         tend();
454         // printf ( "Draw Time: %f\n",( float ) tval() );
455
456         if(tex_shadow)
457                 GPU_texture_unbind(tex_shadow);
458         GPU_texture_unbind(tex);
459
460         if(GLEW_ARB_fragment_program)
461         {
462                 glDisable(GL_FRAGMENT_PROGRAM_ARB);
463                 glDeleteProgramsARB(1, &prog);
464         }
465
466
467         MEM_freeN(points);
468
469         if(!gl_blend)
470                 glDisable(GL_BLEND);
471         if(gl_depth)
472         {
473                 glEnable(GL_DEPTH_TEST);
474                 glDepthMask(GL_TRUE);   
475         }
476 }
477