[Gzz-commits] libvob/include/vob vobs/Irregu.hxx irregu/Irreg...

[Janne V. Kujala]

CVSROOT:        /cvsroot/libvob
Module name:    libvob
Changes by:     Janne V. Kujala <address@hidden>        03/04/09 08:25:20

Modified files:
        include/vob/vobs: Irregu.hxx 
Added files:
        include/vob/irregu: Irregu.hxx 

Log message:
        add commented-out IrregularEdge vob: Generator aborts with error code 
134 if uncommented

CVSWeb URLs:
http://savannah.gnu.org/cgi-bin/viewcvs/libvob/libvob/include/vob/irregu/Irregu.hxx?rev=1.1
http://savannah.gnu.org/cgi-bin/viewcvs/libvob/libvob/include/vob/vobs/Irregu.hxx.diff?tr1=1.1&tr2=1.2&r1=text&r2=text

Patches:
Index: libvob/include/vob/vobs/Irregu.hxx
diff -u libvob/include/vob/vobs/Irregu.hxx:1.1 
libvob/include/vob/vobs/Irregu.hxx:1.2
--- libvob/include/vob/vobs/Irregu.hxx:1.1      Thu Mar 27 04:44:08 2003
+++ libvob/include/vob/vobs/Irregu.hxx  Wed Apr  9 08:25:20 2003
@@ -10,6 +10,7 @@
 #include <vob/glerr.hxx>
 #include <vob/Debug.hxx>
 #include <vob/Transform.hxx>
+#include <vob/irregu/Irregu.hxx>
 
 namespace Vob {
 namespace Vobs {
@@ -274,6 +275,173 @@
 };
 
 VOB_DEFINED(IrregularQuad);
+
+/**
+ * coords1: paper => window
+ * coords2: frame => paper (assumed to be affine)
+ *
+ * shape: determines the frame shape; all shapes fit in [-1,1]^2
+ * setup: CallGL code that is run before calling Irregu::draw
+ * texscale, ..., flags: passed directly to Irregu::draw
+ */
+class IrregularEdge {
+public:
+    enum { NTrans = 2 };
+
+    int shape;
+    float texscale, linewidth, refsize, scale_pow;
+    float border0, border1, texslicing;
+    vector<float> const0, const1; int angles, multi, flags;
+    DisplayListID setup;
+    float dicefactor;
+
+    template<class F> void params(F &f) {
+       unicodecharvector const0, const1;
+       f(shape, texscale, linewidth, refsize, scale_pow,
+         border0, border1, texslicing,
+         const0, const1, angles, multi, flags,
+         setup, dicefactor);
+       this->const0 = getconstvec(const0);
+       this->const1 = getconstvec(const1);
+    }
+         
+    vector<float> getconstvec(unicodecharvector x) {
+       vector<float> v;
+       string s(x.begin(), x.end());
+       const char *p = s.c_str();
+       char *e;
+       float f;
+       while (f = strtod(p, &e), e > p) {
+           v.push_back(f);
+           p = e;
+       }
+       return v;
+    }
+
+    template<class T> void render(const T &coords1, const T &coords2) const {
+        DBG(dbg_irregularquad) << "IrregularEdge\\n";
+
+        // XXX: TODO: use coords1.nonlinearity()
+        int n = (int)(36 * dicefactor);
+        std::vector<ZPt> vert(n+1);
+        
+        switch (shape) {
+        case 1:
+        case 2:
+        case 3:
+        case 4:
+        case 5:
+        case 6:
+            n = 2 + shape;
+        default:
+        case 0: 
+            vert = Irregu::getEllipse(n, 2, 2);
+            break;
+        case 7: {
+            n = 4;
+            vert[0] = ZPt(+1, -1, 0);
+            vert[1] = ZPt(+1, +1, 0);
+            vert[2] = ZPt(-1, +1, 0);
+            vert[3] = ZPt(-1, -1, 0);
+            }
+            break;
+        case 8:
+        case 9:
+        case 10:
+        case 11: {
+            float xw = (coords2.transform(ZPt(1,0,0)) - 
coords2.transform(ZPt(0,0,0))).length();
+            float yw = (coords2.transform(ZPt(0,1,0)) - 
coords2.transform(ZPt(0,0,0))).length();
+
+            float poww = 2 + (shape - 8) * 3;
+            vert = Irregu::getEllipse(n, poww * pow(xw/120, 0.2), poww * 
pow(yw/120, 0.2));
+            }
+            break;
+        }
+
+        vert.resize(n + 1);
+        vert[n] = vert[0];
+        for (unsigned int i=0; i<vert.size(); i++) {
+            vert[i].x = 0.5*(vert[i].x+1);
+            vert[i].y = 0.5*(vert[i].y+1);
+        }
+        Irregu::transform(coords2, vert);
+
+        glCallList(setup);
+        GLERR;
+
+        // XXX: Kluge for 2D offset texture
+        if (flags & 65536) {
+            float xw = (coords2.transform(ZPt(1,0,0)) - 
coords2.transform(ZPt(0,0,0))).length();
+            float yw = (coords2.transform(ZPt(0,1,0)) - 
coords2.transform(ZPt(0,0,0))).length();
+            
+            float s = .5 * (border1 - border0);
+            float sx = s / xw;
+            float sy = s / yw;
+            ZPt vert[] = {
+              ZPt(+1 + sx, -1 - sy, 0),
+              ZPt(+1 + sx, +1 + sy, 0),
+              ZPt(-1 - sx, +1 + sy, 0),
+              ZPt(-1 - sx, -1 - sy, 0)
+            };
+            GLERR;
+            glActiveTexture(GL_TEXTURE1);
+            float mat[4] = { .25 * sx, 0, 0, .25 * sy };
+            glTexEnvfv(GL_TEXTURE_SHADER_NV, GL_OFFSET_TEXTURE_MATRIX_NV, mat);
+            GLERR;
+            glActiveTexture(GL_TEXTURE0);
+
+            int passes = 1;
+            if (flags & Irregu::SHIFTS) passes = 4;
+            if (flags & Irregu::SHIFTS8) passes = 8;
+
+            for (int pass = 0; pass < passes; pass++) {
+                if (passes > 1) {
+                    glPushMatrix();
+                    float t = linewidth * 0.707106781186547;
+                    switch (pass) {
+                        case 0: glTranslatef(-linewidth, 0, 0); break;
+                        case 1: glTranslatef(+linewidth, 0, 0); break;
+                        case 2: glTranslatef(0, -linewidth, 0); break;
+                        case 3: glTranslatef(0, +linewidth, 0); break;
+                        case 4: glTranslatef(-t, -t, 0); break;
+                        case 5: glTranslatef(-t, +t, 0); break;
+                        case 6: glTranslatef(+t, -t, 0); break;
+                        case 7: glTranslatef(+t, +t, 0); break;
+                    }
+                }
+                glBegin(GL_QUADS);
+                for (unsigned i = 0; i < 4; i++) {
+                    glMultiTexCoord2f(GL_TEXTURE1,
+                                      .5 + .25 * vert[i].x,
+                                      .5 + .25 * vert[i].y);
+                    ZPt tex = coords2.transform(vert[i]);
+                    glTexCoord4f(tex.x, tex.y, tex.z, texscale);
+                    coords1.vertex(tex);
+                }
+                glEnd();
+                GLERR;
+                if (passes > 1) glPopMatrix();
+            }
+            GLERR;
+            
+        } else {
+            std::vector<ZVec> norm = Irregu::computeNorms(vert, n);
+            Irregu::draw(coords1, vert, norm, texscale,
+                        linewidth, refsize, scale_pow,
+                        border0, border1, texslicing,
+                        &const0[0], &const1[0],
+                        angles, multi, flags);
+                        
+            GLERR;
+        }
+
+        glPopAttrib();
+        GLERR;
+        DBG(dbg_irregularquad) << "IrregularEdge done\\n";
+    }
+};
+
+//VOB_DEFINED(IrregularEdge);
 
 }
 }