implemented two-pass compiling
[swftools.git] / lib / devices / opengl.c
1 #include <stdlib.h>
2 #include <stdio.h>
3 #include <string.h>
4 #include <math.h>
5
6 #include "../gfxdevice.h"
7 #include "../gfxtools.h"
8 #include "../MD5.h"
9 #include "../types.h"
10
11 #include <math.h>
12 #include <time.h>
13 #include <GL/gl.h>
14 #include <GL/glut.h>
15
16 #include <stdarg.h>
17
18 //#define ZSTEP (1/65536.0)
19 #define ZSTEP (1/32.0)
20 //#define ZSTEP (1/4.0)
21
22 typedef struct _fontlist {
23     gfxfont_t*font;
24     struct _fontlist*next;
25 } fontlist_t;
26
27 typedef struct _internal {
28     gfxfont_t*font;
29     char*fontid;
30     fontlist_t* fontlist;
31     int width, height;
32     int currentz;
33    
34     int config_polygonoutlines;
35    
36     GLUtesselator *tesselator;
37     GLUtesselator *tesselator_line;
38     GLUtesselator *tesselator_tex;
39 } internal_t;
40
41 static int verbose = 0;
42 static void dbg(char*format, ...)
43 {
44     char buf[1024];
45     int l;
46     va_list arglist;
47     if(!verbose)
48         return;
49     va_start(arglist, format);
50     vsprintf(buf, format, arglist);
51     va_end(arglist);
52     l = strlen(buf);
53     while(l && buf[l-1]=='\n') {
54         buf[l-1] = 0;
55         l--;
56     }
57     printf("(device-opengl) %s\n", buf);
58     fflush(stdout);
59 }
60
61 #ifndef CALLBACK 
62 #define CALLBACK
63 #endif
64
65 typedef void(*callbackfunction_t)();
66
67 void CALLBACK errorCallback(GLenum errorCode)
68 {
69    const GLubyte *estring;
70    estring = gluErrorString(errorCode);
71    printf("Tessellation Error: %s\n", estring);
72    exit(0);
73 }
74 void CALLBACK beginCallback(GLenum which)
75 {
76     glBegin(which);
77 }
78 void CALLBACK endCallback(void)
79 {
80     glEnd();
81 }
82 void CALLBACK vertexCallback(GLvoid *vertex)
83 {
84    double*xyz = (GLdouble*)vertex;
85    glVertex3d(xyz[0],xyz[1],xyz[2]);
86 }
87 void CALLBACK combineCallback(GLdouble coords[3], GLdouble *data[4], GLfloat w[4], GLdouble **out)
88 {
89    GLdouble *vertex;
90    vertex = (GLdouble *) malloc(6 * sizeof(GLdouble));
91    vertex[0] = coords[0];
92    vertex[1] = coords[1];
93    vertex[2] = coords[2];
94    *out = vertex;
95 }
96 void CALLBACK vertexCallbackTex(GLvoid *vertex)
97 {
98    double*v = (GLdouble*)vertex;
99    glTexCoord2f(v[3],v[4]);
100    glVertex3d(v[0],v[1],v[2]);
101 }
102 void CALLBACK combineCallbackTex(GLdouble coords[3], GLdouble *data[4], GLfloat w[4], GLdouble **out)
103 {
104    GLdouble *vertex;
105    vertex = (GLdouble *) malloc(5 * sizeof(GLdouble));
106    vertex[0] = coords[0];
107    vertex[1] = coords[1];
108    vertex[2] = coords[2];
109    if(data[2] && data[3]) {
110        vertex[3] = w[0]*data[0][3] + w[1]*data[1][3] + w[2]*data[2][3] + w[3]*data[3][3];
111        vertex[4] = w[0]*data[0][4] + w[1]*data[1][4] + w[2]*data[2][4] + w[3]*data[3][4];
112    } else {
113        vertex[3] = w[0]*data[0][3] + w[1]*data[1][3];
114        vertex[4] = w[0]*data[0][4] + w[1]*data[1][4];
115    }
116    *out = vertex;
117 }
118
119 int opengl_setparameter(struct _gfxdevice*dev, const char*key, const char*value)
120 {
121     internal_t*i = (internal_t*)dev->internal;
122     dbg("setparameter %s=%s", key, value);
123     if(!strcmp(key, "polygonoutlines")) {
124         i->config_polygonoutlines = atoi(value);
125     }
126     return 0;
127 }
128
129 void opengl_startpage(struct _gfxdevice*dev, int width, int height)
130 {
131     dbg("startpage %d %d", width, height);
132     internal_t*i = (internal_t*)dev->internal;
133     i->width = width;
134     i->height = height;
135     i->currentz = 0;
136 }
137
138 void opengl_startclip(struct _gfxdevice*dev, gfxline_t*line)
139 {
140     dbg("startclip");
141 }
142
143 void opengl_endclip(struct _gfxdevice*dev)
144 {
145     dbg("endclip");
146 }
147
148 void opengl_stroke(struct _gfxdevice*dev, gfxline_t*line, gfxcoord_t width, gfxcolor_t*color, gfx_capType cap_style, gfx_joinType joint_style, gfxcoord_t miterLimit)
149 {
150     dbg("stroke");
151     internal_t*i = (internal_t*)dev->internal;
152     i->currentz++;
153     char running = 0;
154     gfxline_t*l=0;
155
156     glColor4f(color->r/255.0, color->g/255.0, color->b/255.0, color->a/255.0);
157     
158     //glLineWidth(width*64);
159     if(width <= 0) {
160         width = 1.0;
161     }
162     glLineWidth(width);
163     double z = i->currentz*ZSTEP;
164
165     glPolygonOffset(0.0, 500.0);
166
167     l = line;
168     while(l) {
169         if(l->type == gfx_moveTo) {
170             if(running) {
171                 running = 0;
172                 glEnd();
173             }
174         }
175         if(!running) {
176             running = 1;
177             glBegin(GL_LINE_STRIP);
178         }
179         glVertex3d(l->x, l->y, z);
180         l=l->next;
181     }
182     if(running) {
183         running = 0;
184         glEnd();
185     }
186     glLineWidth(1.0);
187 }
188
189 #define SPLINE_SUBDIVISION 2
190
191 void tesselatePolygon(GLUtesselator*tesselator, double z, gfxline_t*line)
192 {
193     int len = 0;
194     gfxline_t*l=0;
195     double lastx=0,lasty=0;
196     double*xyz=0;
197     char running = 0;
198     gluTessBeginPolygon(tesselator, NULL);
199     l = line;
200     len = 0;
201     while(l) {
202         if(l->type == gfx_splineTo) {
203             double c = sqrt(abs(l->x-2*l->sx+lastx) + abs(l->y-2*l->sy+lasty))*SPLINE_SUBDIVISION;
204             int steps = (int)c;
205             if(steps<1) steps = 1;
206             len += steps;
207         } else {
208             len++;
209         }
210         l = l->next;
211     }
212     //printf("full len:%d\n", len);
213     xyz = malloc(sizeof(double)*3*len);
214     l = line;
215     len = 0;
216     while(l) {
217         if(l->type == gfx_moveTo) {
218             if(running) {
219                 running = 0;
220                 gluTessEndContour(tesselator);
221             }
222         }
223         if(!running) {
224             running = 1;
225             gluTessBeginContour(tesselator);
226         }
227
228         if(l->type == gfx_splineTo) {
229             int j;
230             double c = sqrt(abs(l->x-2*l->sx+lastx) + abs(l->y-2*l->sy+lasty))*SPLINE_SUBDIVISION;
231             int steps = (int)c;
232             if(steps<1) steps = 1;
233             //printf("c=%f d1=%f (%f/%f) d2=%f (%f/%f)\n", c,d1,l->x-l->sx,l->y-l->sy,d2,lastx-l->sx,lasty-l->sy);
234             //printf("%f %f %f\n", lastx, l->sx, l->x);
235             //printf("%f %f %f\n", lasty, l->sy, l->y);
236             for(j=1;j<=steps;j++) {
237                 //printf("%d\n", j);
238                 double t = (double)j / (double)steps;
239                 xyz[len*3+0] = lastx*(1-t)*(1-t) + 2*l->sx*(1-t)*t + l->x*t*t;
240                 xyz[len*3+1] = lasty*(1-t)*(1-t) + 2*l->sy*(1-t)*t + l->y*t*t;
241                 xyz[len*3+2] = z;
242                 gluTessVertex(tesselator, &xyz[len*3], &xyz[len*3]);
243                 len++;
244             }
245             //printf("%d\n", len);
246         } else {
247             xyz[len*3+0] = l->x;
248             xyz[len*3+1] = l->y;
249             xyz[len*3+2] = z;
250             gluTessVertex(tesselator, &xyz[len*3], &xyz[len*3]);
251             len++;
252         }
253         lastx = l->x;
254         lasty = l->y;
255
256         l=l->next;
257     }
258     if(running) {
259         running = 0;
260         gluTessEndContour(tesselator);
261     }
262     gluTessEndPolygon(tesselator);
263     free(xyz);
264 }
265
266 void opengl_fill(struct _gfxdevice*dev, gfxline_t*line, gfxcolor_t*color)
267 {
268     double z;
269     dbg("fill %02x%02x%02x%02x", color->a, color->r, color->g, color->b);
270     internal_t*i = (internal_t*)dev->internal;
271
272     glDisable(GL_TEXTURE_2D);
273     glColor4f(color->r/255.0, color->g/255.0, color->b/255.0, color->a/255.0);
274     
275     i->currentz ++;
276     z = (i->currentz*ZSTEP);
277     tesselatePolygon(i->tesselator, z, line);
278
279     //tesselatePolygon(i->tesselator_line, z, line);
280 }
281
282 typedef struct _gfxhash
283 {
284     unsigned char d[16];
285 } gfxhash_t;
286
287 char gfxhash_compare(gfxhash_t*h1, gfxhash_t*h2)
288 {
289     return !memcmp(h1->d, h2->d, 16);
290 }
291
292 typedef struct _imgopengl
293 {
294     gfxhash_t hash;
295     GLuint texID;
296     int width, height;
297     unsigned char*data;
298     struct _imgopengl*next;
299 } imgopengl_t;
300
301 static imgopengl_t*img2texid = 0;
302
303 static gfxhash_t gfximage_hash(gfximage_t*img)
304 {
305     int t;
306     int size = img->width*img->height*4;
307     U8*data = (U8*)img->data;
308     gfxhash_t hash;
309     hash_md5(data, size, hash.d);
310     return hash;
311 }
312
313 static void delTextures()
314 {
315     imgopengl_t*i = img2texid;
316     while(i) {
317         imgopengl_t*next = i->next;
318         if(i->data) {
319             glDeleteTextures(1, &i->texID);
320             free(i->data);
321         }
322         memset(i, 0, sizeof(imgopengl_t));
323         free(i);
324         i = next;
325     }
326 }
327
328 static imgopengl_t*addTexture(gfximage_t*img)
329 {
330     gfxhash_t hash = gfximage_hash(img);
331     imgopengl_t*i = img2texid;
332     
333     int width_bits = 0;
334     int height_bits = 0;
335     while(1<<width_bits < img->width)
336         width_bits++;
337     while(1<<height_bits < img->height)
338         height_bits++;
339     int newwidth = 1<<width_bits;
340     int newheight = 1<<height_bits;
341
342     while(i) {
343         if(gfxhash_compare(&hash, &i->hash) && newwidth==i->width && newheight==i->height) {
344             return i;
345         }
346         i = i->next;
347     }
348     
349     GLuint texIDs[1];
350     glGenTextures(1, texIDs);
351
352     i = malloc(sizeof(imgopengl_t));
353     i->hash = hash;
354     i->texID = texIDs[0];
355     i->next = img2texid;
356     img2texid = i;
357
358     i->width = newwidth;
359     i->height = newheight;
360
361     unsigned char*data = malloc(newwidth*newheight*4);
362     i->data = data;
363     int x,y;
364     for(y=0;y<img->height;y++) {
365         for(x=0;x<img->width;x++) {
366             data[(y*newwidth+x)*4+0] = img->data[y*img->width+x].r;
367             data[(y*newwidth+x)*4+1] = img->data[y*img->width+x].g;
368             data[(y*newwidth+x)*4+2] = img->data[y*img->width+x].b;
369             data[(y*newwidth+x)*4+3] = img->data[y*img->width+x].a;
370         }
371         int lastx = img->width - 1;
372         for(;x<newwidth;x++) {
373             data[(y*newwidth+x)*4+0] = img->data[y*img->width+lastx].r;
374             data[(y*newwidth+x)*4+1] = img->data[y*img->width+lastx].g;
375             data[(y*newwidth+x)*4+2] = img->data[y*img->width+lastx].b;
376             data[(y*newwidth+x)*4+3] = img->data[y*img->width+lastx].a;
377         }
378     }
379     int lasty = img->height - 1;
380     for(;y<newheight;y++) {
381         for(x=0;x<newwidth;x++) {
382             data[(y*newwidth+x)*4+0] = img->data[lasty*img->width+x].r;
383             data[(y*newwidth+x)*4+1] = img->data[lasty*img->width+x].g;
384             data[(y*newwidth+x)*4+2] = img->data[lasty*img->width+x].b;
385             data[(y*newwidth+x)*4+3] = img->data[lasty*img->width+x].a;
386         }
387     }
388     
389     glEnable(GL_TEXTURE_2D);
390     glBindTexture(GL_TEXTURE_2D, i->texID);
391     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, i->width, i->height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
392     
393     return i;
394 };
395
396 void opengl_fillbitmap(struct _gfxdevice*dev, gfxline_t*line, gfximage_t*img, gfxmatrix_t*matrix, gfxcxform_t*cxform)
397 {
398     dbg("fillbitmap");
399     internal_t*i = (internal_t*)dev->internal;
400     char running = 0;
401     int len = 0;
402     double*xyz=0;
403     gfxline_t*l=0;
404     glColor4f(1.0,0,0.7,1.0);
405     
406     i->currentz ++;
407   
408     imgopengl_t* txt = addTexture(img);
409
410     gfxmatrix_t m2;
411     gfxmatrix_invert(matrix, &m2);
412     m2.m00 /= txt->width;
413     m2.m10 /= txt->width;
414     m2.tx /= txt->width;
415     m2.m01 /= txt->height;
416     m2.m11 /= txt->height;
417     m2.ty /= txt->height;
418
419     glEnable(GL_TEXTURE_2D);
420     glBindTexture(GL_TEXTURE_2D, txt->texID);
421     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
422     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
423     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
424     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
425     glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
426     
427     gluTessBeginPolygon(i->tesselator_tex, NULL);
428     l = line;
429     len = 0;
430     while(l) {
431         len++;
432         l = l->next;
433     }
434     xyz = malloc(sizeof(double)*5*len);
435     l = line;
436     len = 0;
437     while(l) {
438         if(l->type == gfx_moveTo) {
439             if(running) {
440                 running = 0;
441                 gluTessEndContour(i->tesselator_tex);
442             }
443         }
444         if(!running) {
445             running = 1;
446             gluTessBeginContour(i->tesselator_tex);
447         }
448
449         xyz[len*5+0] = l->x;
450         xyz[len*5+1] = l->y;
451         xyz[len*5+2] = (i->currentz*ZSTEP);
452         xyz[len*5+3] = 0;
453         xyz[len*5+4] = 0;
454         gfxmatrix_transform(&m2, /*src*/&xyz[len*5+0], /*dest*/&xyz[len*5+3]);
455
456         gluTessVertex(i->tesselator_tex, &xyz[len*5], &xyz[len*5]);
457         len++;
458
459         l=l->next;
460     }
461
462     if(running) {
463         running = 0;
464         gluTessEndContour(i->tesselator_tex);
465     }
466     gluTessEndPolygon(i->tesselator_tex);
467     free(xyz);
468     
469     glDisable(GL_TEXTURE_2D);
470 }
471
472 void opengl_fillgradient(struct _gfxdevice*dev, gfxline_t*line, gfxgradient_t*gradient, gfxgradienttype_t type, gfxmatrix_t*matrix)
473 {
474     dbg("fillgradient");
475 }
476
477 void opengl_addfont(gfxdevice_t*dev, gfxfont_t*font)
478 {
479     internal_t*i = (internal_t*)dev->internal;
480     
481     fontlist_t*last=0,*l = i->fontlist;
482     while(l) {
483         last = l;
484         if(!strcmp((char*)l->font->id, font->id)) {
485             return; // we already know this font
486         }
487         l = l->next;
488     }
489     l = (fontlist_t*)rfx_calloc(sizeof(fontlist_t));
490     l->font = font;
491     l->next = 0;
492     if(last) {
493         last->next = l;
494     } else {
495         i->fontlist = l;
496     }
497 }
498
499 void opengl_drawchar(gfxdevice_t*dev, gfxfont_t*font, int glyphnr, gfxcolor_t*color, gfxmatrix_t*matrix)
500 {
501     internal_t*i = (internal_t*)dev->internal;
502     if(!font)
503         return;
504
505     if(i->font && i->font->id && !strcmp(font->id, i->font->id)) {
506         // current font is correct
507     } else {
508         fontlist_t*l = i->fontlist;
509         i->font = 0;
510         while(l) {
511             if(!strcmp((char*)l->font->id, font->id)) {
512                 i->font = l->font;
513                 break;
514             }
515             l = l->next;
516         }
517         if(i->font == 0) {
518             opengl_addfont(dev, font);
519             i->font = font;
520             //fprintf(stderr, "Unknown font id: %s", font->id);
521             //return;
522         }
523     }
524
525     gfxglyph_t*glyph = &i->font->glyphs[glyphnr];
526     
527     gfxline_t*line2 = gfxline_clone(glyph->line);
528     gfxline_transform(line2, matrix);
529     opengl_fill(dev, line2, color);
530     gfxline_free(line2);
531     
532     i->currentz --;
533     
534     return;
535 }
536
537
538
539 void opengl_drawlink(struct _gfxdevice*dev, gfxline_t*line, const char*action)
540 {
541     dbg("link");
542 }
543
544 void opengl_endpage(struct _gfxdevice*dev)
545 {
546     dbg("endpage");
547 }
548
549 int opengl_result_save(struct _gfxresult*gfx, const char*filename)
550 {
551     dbg("result:save");
552     return 0;
553 }
554 void* opengl_result_get(struct _gfxresult*gfx, const char*name)
555 {
556     dbg("result:get");
557     return 0;
558 }
559 void opengl_result_destroy(struct _gfxresult*gfx)
560 {
561     dbg("result:destroy");
562     free(gfx);
563     delTextures();
564 }
565
566 gfxresult_t*opengl_finish(struct _gfxdevice*dev)
567 {
568     dbg("finish");
569     internal_t*i = (internal_t*)dev->internal;
570     gluDeleteTess(i->tesselator);i->tesselator=0;
571     gluDeleteTess(i->tesselator_tex);i->tesselator_tex=0;
572     gfxresult_t*result = (gfxresult_t*)malloc(sizeof(gfxresult_t));
573     memset(result, 0, sizeof(gfxresult_t));
574     result->save = opengl_result_save;
575     result->get = opengl_result_get;
576     result->destroy = opengl_result_destroy;
577     return result;
578 }
579
580 void gfxdevice_opengl_init(gfxdevice_t*dev)
581 {
582     dbg("init");
583     internal_t*i = (internal_t*)rfx_calloc(sizeof(internal_t));
584     memset(dev, 0, sizeof(gfxdevice_t));
585     
586     dev->name = "opengl";
587
588     dev->internal = i;
589     
590     dev->setparameter = opengl_setparameter;
591     dev->startpage = opengl_startpage;
592     dev->startclip = opengl_startclip;
593     dev->endclip = opengl_endclip;
594     dev->stroke = opengl_stroke;
595     dev->fill = opengl_fill;
596     dev->fillbitmap = opengl_fillbitmap;
597     dev->fillgradient = opengl_fillgradient;
598     dev->addfont = opengl_addfont;
599     dev->drawchar = opengl_drawchar;
600     dev->drawlink = opengl_drawlink;
601     dev->endpage = opengl_endpage;
602     dev->finish = opengl_finish;
603
604     i->tesselator = gluNewTess();
605     gluTessCallback(i->tesselator, GLU_TESS_ERROR, (callbackfunction_t)errorCallback);
606     gluTessCallback(i->tesselator, GLU_TESS_VERTEX, (callbackfunction_t)vertexCallback);
607     gluTessCallback(i->tesselator, GLU_TESS_BEGIN, (callbackfunction_t)beginCallback);
608     gluTessCallback(i->tesselator, GLU_TESS_END, (callbackfunction_t)endCallback);
609     gluTessCallback(i->tesselator, GLU_TESS_COMBINE, (callbackfunction_t)combineCallback);
610     
611     i->tesselator_line = gluNewTess();
612     gluTessCallback(i->tesselator_line, GLU_TESS_ERROR, (callbackfunction_t)errorCallback);
613     gluTessCallback(i->tesselator_line, GLU_TESS_VERTEX, (callbackfunction_t)vertexCallback);
614     gluTessCallback(i->tesselator_line, GLU_TESS_BEGIN, (callbackfunction_t)beginCallback);
615     gluTessCallback(i->tesselator_line, GLU_TESS_END, (callbackfunction_t)endCallback);
616     gluTessProperty(i->tesselator_line, GLU_TESS_BOUNDARY_ONLY, 1.0);
617     
618     i->tesselator_tex = gluNewTess();
619     gluTessCallback(i->tesselator_tex, GLU_TESS_ERROR, (callbackfunction_t)errorCallback);
620     gluTessCallback(i->tesselator_tex, GLU_TESS_VERTEX, (callbackfunction_t)vertexCallbackTex);
621     gluTessCallback(i->tesselator_tex, GLU_TESS_BEGIN, (callbackfunction_t)beginCallback);
622     gluTessCallback(i->tesselator_tex, GLU_TESS_END, (callbackfunction_t)endCallback);
623     gluTessCallback(i->tesselator_tex, GLU_TESS_COMBINE, (callbackfunction_t)combineCallbackTex);
624     
625     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
626 }