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; } |
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 |
} |
} |
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) { |
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); |