/[libvob]/libvob/include/vob/Primitives.hxx
ViewVC logotype

Diff of /libvob/include/vob/Primitives.hxx

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.12 by tjl, Mon Mar 10 16:02:05 2003 UTC revision 1.13 by tjl, Wed Mar 12 16:17:20 2003 UTC
# Line 109  namespace Primitives { Line 109  namespace Primitives {
109          void performGL() { }          void performGL() { }
110      };      };
111    
112        class PotentiallyGLPerformablePrimitiveTransform {
113        public:
114            bool canPerformGL() { return false; }
115            bool performGL() { return false; }
116        };
117    
118      class NonlinearPrimitiveTransform {      class NonlinearPrimitiveTransform {
119      public:      public:
120          float nonlinearity(ZPt p, float radius) { return 0; }          float nonlinearity(ZPt p, float radius) { return 0; }
# Line 231  namespace Primitives { Line 237  namespace Primitives {
237      {      {
238          const Transform *super;          const Transform *super;
239          Transform *inverse;          Transform *inverse;
240    
241          Primitive t;          Primitive t;
242    
243          // Dispatching by the tag classes of t:          // Dispatching by the tag classes of t:
244          // alternative versions for transforms with and without          // alternative versions for transforms with and without
245          // given features.          // given features.
246    
247          bool performGL(GLPerformablePrimitiveTransform &t) const {          bool performGL(const GLPerformablePrimitiveTransform *_) const {
248                if(!super->performGL()) return false;
249                t.performGL();
250                return true;
251            }
252            bool performGL(const PotentiallyGLPerformablePrimitiveTransform *_) const {
253              if(!super->performGL()) return false;              if(!super->performGL()) return false;
254              return t.performGL();              return t.performGL();
255          }          }
256          template<class T> bool performGL(T &t) const {          bool performGL(const void *_) const {
257              return false;              return false;
258          }          }
259    
260          bool canPerformGL(GLPerformablePrimitiveTransform &t) const {          bool canPerformGL(const GLPerformablePrimitiveTransform *_) const {
261              return super->canPerformGL();              return super->canPerformGL();
262          }          }
263          template<class T> bool canPerformGL(T &t) const {          bool canPerformGL(const PotentiallyGLPerformablePrimitiveTransform *_) const {
264                return t.canPerformGL() && super->canPerformGL() ;
265            }
266            bool canPerformGL(const void *_) const {
267              return false;              return false;
268          }          }
269    
270          float selfNonlinearity(NonlinearPrimitiveTransform &t,          float selfNonlinearity(const NonlinearPrimitiveTransform *_,
271                      const ZPt &p, float radius) const {                      const ZPt &p, float radius) const {
272              return t.nonlinearity(p, radius);              return t.nonlinearity(p, radius);
273          }          }
274          template<class T> float selfNonlinearity(T &t,          float selfNonlinearity(const void *_,
275                      const ZPt &p, float radius) const {                      const ZPt &p, float radius) const {
276              return 0;              return 0;
277          }          }
278    
279          int getNParams(void *t) const {          int getNParams(const void *_) const {
280              return 0;              return 0;
281          }          }
282          int getNParams(ParametrizedPrimitiveTransform *t) const {          int getNParams(const ParametrizedPrimitiveTransform *_) const {
283              return Primitive::NParams;              return Primitive::NParams;
284          }          }
285    
286          int getNDepends(DependentPrimitiveTransform &t) const {          int getNDepends(const DependentPrimitiveTransform *_) const {
287              return Primitive::NDepends;              return Primitive::NDepends;
288          }          }
289          template<class T> int getNDepends(T &t) const {          int getNDepends(const void *_) const {
290              return 1;              return 1;
291          }          }
292    
293          Pt getSqSize(const BoxPrimitiveTransform *t__) const {          Pt getSqSize(const BoxPrimitiveTransform *___) const {
294              return t.getSqSize();              return t.getSqSize();
295          }          }
296          Pt getSqSize(const void *t) const {          Pt getSqSize(const void *_) const {
297              return Pt(1,1);              return Pt(1,1);
298          }          }
299    
300          // Difficult: double switches: dependent, parametrized for setParams..          // Difficult: double switches: dependent, parametrized for setParams..
301          void setParams(DependentPrimitiveTransform *t__,          void setParams(const DependentPrimitiveTransform *___,
302                  const Transform **depends, float *p) {                  const Transform **depends, float *p) {
303              setDependentParams(&t, depends, p);              setDependentParams(&t, depends, p);
304          }          }
305          void setParams(void *__t,          void setParams(const void *__t,
306                  const Transform **depends, float *p) {                  const Transform **depends, float *p) {
307              setNondependentParams(&t, p);              setNondependentParams(&t, p);
308          }          }
309    
310          void setDependentParams(ParametrizedPrimitiveTransform *t__,          void setDependentParams(const ParametrizedPrimitiveTransform *___,
311                  const Transform **depends, float *p) {                  const Transform **depends, float *p) {
312              t.setParams(depends, p);              t.setParams(depends, p);
313          }          }
314          void setDependentParams(void *t__,          void setDependentParams(const void *___,
315                  const Transform **depends, float *p) {                  const Transform **depends, float *p) {
316              t.setParams(depends);              t.setParams(depends);
317          }          }
318    
319          void setNondependentParams(void *t__,          void setNondependentParams(const void *___,
320                   float *p) {                   float *p) {
321              // noop              // noop
322          }          }
323          void setNondependentParams(ParametrizedPrimitiveTransform *t__,          void setNondependentParams(const ParametrizedPrimitiveTransform *___,
324                   float *p) {                   float *p) {
325              t.setParams(p);              t.setParams(p);
326          }          }
# Line 324  namespace Primitives { Line 339  namespace Primitives {
339              return getNParams(&t);              return getNParams(&t);
340          }          }
341          virtual int getNDepends() {          virtual int getNDepends() {
342              return getNDepends(t);              return getNDepends(&t);
343          }          }
344    
345          virtual void setParams(const Transform **depends, float *p) {          virtual void setParams(const Transform **depends, float *p) {
# Line 345  namespace Primitives { Line 360  namespace Primitives {
360              super->vertex(mp);              super->vertex(mp);
361          }          }
362    
363          virtual bool performGL() const { return performGL(t); }          virtual bool performGL() const { return performGL(&t); }
364    
365          virtual bool canPerformGL() const { return canPerformGL(t); }          virtual bool canPerformGL() const { return canPerformGL(&t); }
366    
367          virtual float nonlinearity(const ZPt &p, float radius) const {          virtual float nonlinearity(const ZPt &p, float radius) const {
368              float s = selfNonlinearity(t, p, radius);              float s = selfNonlinearity(&t, p, radius);
369              ZPt mp;              ZPt mp;
370              t.tr(p, mp);              t.tr(p, mp);
371              float su = super->nonlinearity(mp, radius);              float su = super->nonlinearity(mp, radius);

Legend:
Removed from v.1.12  
changed lines
  Added in v.1.13

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26