Free Electron
SurfaceBase.h
Go to the documentation of this file.
1 /* Copyright (C) 2003-2021 Free Electron Organization
2  Any use of this software requires a license. If a valid license
3  was not distributed with this file, visit freeelectron.org. */
4 
5 /** @file */
6 
7 #ifndef __surface_SurfaceBase_h__
8 #define __surface_SurfaceBase_h__
9 
10 namespace fe
11 {
12 namespace ext
13 {
14 
15 /**************************************************************************//**
16  @brief Trivial Point Origin Surface
17 
18  @ingroup surface
19 *//***************************************************************************/
20 class FE_DL_EXPORT SurfaceBase: virtual public RecordableI,
21  virtual public SurfaceI,
22  virtual public DrawableI,
23  public CastableAs<SurfaceBase>
24 {
25  public:
26 
27  class Impact:
28  virtual public ImpactI,
29  virtual public DrawableI,
30  public CastableAs<Impact>
31  {
32  public:
33  Impact(void)
34  {
35 #if FE_COUNTED_STORE_TRACKER
36  setName("SurfaceBase::Impact");
37 #endif
38  setIdentity(m_transform);
39  }
40  virtual ~Impact(void) {}
41 
42  //* As DrawableI
43  virtual void draw(sp<DrawI> a_spDrawI,
44  const fe::Color* a_pColor)
45  {
46  const_cast<const SurfaceBase::Impact*>(this)
47  ->draw(a_spDrawI,a_pColor);
48  }
49  virtual void draw(sp<DrawI> a_spDrawI,
50  const fe::Color* a_pColor) const
51  {
52  SpatialTransform identity;
53  setIdentity(identity);
54  draw(identity,a_spDrawI,a_pColor);
55  }
56  virtual void draw(const SpatialTransform& a_transform,
57  sp<DrawI> a_spDrawI,
58  const fe::Color* a_pColor)
59  {
60  const_cast<const SurfaceBase::Impact*>(this)
61  ->draw(a_transform,a_spDrawI,
62  a_pColor);
63  }
64  virtual void draw(const SpatialTransform& a_transform,
65  sp<DrawI> a_spDrawI,
66  const fe::Color* a_pColor) const
67  {
68  draw(a_transform,a_spDrawI,
69  a_pColor,sp<DrawBufferI>(NULL),
70  sp<PartitionI>(NULL));
71  }
72  virtual void draw(const SpatialTransform& a_transform,
73  sp<DrawI> a_spDrawI,
74  const fe::Color* a_pColor,
75  sp<DrawBufferI> a_spDrawBuffer,
76  sp<PartitionI> a_spPartition)
77  {
78  const_cast<const SurfaceBase::Impact*>(this)
79  ->draw(a_transform,a_spDrawI,
80  a_pColor,a_spDrawBuffer,
81  a_spPartition);
82  }
83  virtual void draw(const SpatialTransform& a_transform,
84  sp<DrawI> a_spDrawI,
85  const fe::Color* a_pColor,
86  sp<DrawBufferI> a_spDrawBuffer,
87  sp<PartitionI> a_spPartition) const {}
88 
89  void setSurface(const SurfaceI* a_pSurface)
90  { m_hpSurface=
91  hp<SurfaceI>(const_cast<SurfaceI*>(
92  a_pSurface)); }
93 
94  void setTransform(SpatialTransform a_transform)
95  { m_transform=a_transform; }
96 
97  virtual SpatialVector location(void) const
98  { return rotateVector(m_transform,
99  m_location); }
100  SpatialVector locationLocal(void) const
101  { return m_location; }
102  void setLocationLocal(SpatialVector a_location)
103  { m_location=a_location; }
104 
105  virtual Color diffuse(void) const
106  { return m_diffuse; }
107  virtual void setDiffuse(Color a_diffuse)
108  { m_diffuse=a_diffuse; }
109 
110  virtual Real radius(void) const
111  { return m_radius; }
112  void setRadius(Real a_radius)
113  { m_radius=a_radius; }
114 
115  virtual SpatialVector origin(void) const
116  { return m_origin; }
117  void setOrigin(SpatialVector a_origin)
118  { m_origin=a_origin; }
119 
120  virtual SpatialVector direction(void) const
121  { return m_direction; }
122  void setDirection(SpatialVector a_direction)
123  { m_direction=a_direction; }
124 
125  virtual Real distance(void) const
126  { return m_distance; }
127  void setDistance(Real a_distance)
128  { m_distance=a_distance; }
129 
130  virtual I32 pointIndex0(void) const { return -1; }
131  virtual I32 face(void) { return -1; }
132  virtual I32 triangleIndex(void) { return -1; }
133  virtual I32 primitiveIndex(void) { return -1; }
134  virtual I32 partitionIndex(void) { return -1; }
135  virtual SpatialBary barycenter(void)
136  { return SpatialBary(0.0,0.0); }
137 
138  virtual Vector2 uv(void)
139  { return Vector2(0.0,0.0); }
140  virtual SpatialVector du(void)
141  { return SpatialVector(0.0,0.0,0.0); }
142  virtual SpatialVector dv(void)
143  { return SpatialVector(0.0,0.0,0.0); }
144 
145  protected:
146 
147  hp<SurfaceI> m_hpSurface;
148  SpatialTransform m_transform;
149  Color m_diffuse;
150  SpatialVector m_location;
151  Real m_radius;
152  SpatialVector m_origin;
153  SpatialVector m_direction;
154  Real m_distance;
155  };
156 
157  SurfaceBase(void):
158  m_cached(FALSE),
159  m_sampleMethod(e_linear),
160  m_restrictions(e_unrestricted) {}
161 virtual ~SurfaceBase(void) {}
162 
163  //* As Protectable
164 virtual void protect(void)
165  {
166 // feLog("SurfaceBase::protect checkCache\n");
167  checkCache();
168 // feLog("SurfaceBase::protect"
169 // " Protectable::protect\n");
170  Protectable::protect();
171 // feLog("SurfaceBase::protect done\n");
172  }
173 
174  //* As SurfaceI
175 virtual void bind(Instance a_instance) {}
176 
177 virtual SpatialVector center(void) { return SpatialVector(0,0,0); }
178 virtual SpatialVector center(void) const { return SpatialVector(0,0,0); }
179 
180 virtual Real radius(void) { return Real(0); }
181 virtual Real radius(void) const { return Real(0); }
182 
183 virtual Color diffuse(void) const
184  { return Color(1,1,1,1); }
185 
186 virtual void setSampleMethod(SampleMethod a_sampleMethod)
187  { m_sampleMethod=a_sampleMethod; }
188 
189 virtual void setNodeName(String a_nodeName)
190  { m_nodeName=a_nodeName; }
191 virtual String nodeName(void) const
192  { return m_nodeName; }
193 
194 virtual void setRestrictions(Restrictions a_restrictions)
195  { m_restrictions=a_restrictions; }
196 virtual Restrictions restrictions(void) const
197  { return m_restrictions; }
198 
199 virtual void setRefinement(U32 a_refinement) {}
200 
201 virtual void setAccuracy(SurfaceI::Accuracy a_accuracy) {}
202 
203 virtual void setSearchable(BWORD a_searchable) {}
204 
205 virtual void setSearch(String a_searchName) {}
206 
207 virtual void setTriangulation(Triangulation a_triangulation) {}
208 
209 virtual I32 triangleCount(void) { return -1; }
210 
211 virtual SpatialTransform sample(Vector2 a_uv)
212  {
213  checkCache();
214  prepareForUVSearch();
215  return const_cast<const SurfaceBase*>(this)->
216  sample(a_uv);
217  }
218 virtual SpatialTransform sample(Vector2 a_uv) const
219  { return SpatialTransform::identity(); }
220 
221 virtual SpatialTransform sample(I32 a_triangleIndex,SpatialBary a_barycenter)
222  {
223  checkCache();
224  return const_cast<const SurfaceBase*>(this)->
225  sample(a_triangleIndex,a_barycenter);
226  }
227 virtual SpatialTransform sample(I32 a_triangleIndex,
228  SpatialBary a_barycenter) const
229  { return sample(a_triangleIndex,a_barycenter,
230  SpatialVector(0.0,0.0,0.0)); }
231 virtual SpatialTransform sample(I32 a_triangleIndex,SpatialBary a_barycenter,
232  SpatialVector a_tangent) const
233  { return SpatialTransform::identity(); }
234 
235 virtual sp<ImpactI> sampleImpact(I32 a_triangleIndex,
236  SpatialBary a_barycenter)
237  {
238  checkCache();
239  return const_cast<const SurfaceBase*>(this)->
240  sampleImpact(a_triangleIndex,
241  a_barycenter);
242  }
243 virtual sp<ImpactI> sampleImpact(I32 a_triangleIndex,
244  SpatialBary a_barycenter) const
245  { return sampleImpact(a_triangleIndex,
246  a_barycenter,
247  SpatialVector(0.0,0.0,0.0)); }
248 virtual sp<ImpactI> sampleImpact(I32 a_triangleIndex,
249  SpatialBary a_barycenter,
250  SpatialVector a_tangent) const
251  { return sp<ImpactI>(NULL); }
252 
253 virtual SpatialVector samplePoint(const SpatialTransform& a_transform,
254  Vector2 a_uv)
255  {
256  checkCache();
257  prepareForUVSearch();
258  return const_cast<const SurfaceBase*>(this)->
259  samplePoint(a_transform,a_uv);
260  }
261 virtual SpatialVector samplePoint(Vector2 a_uv)
262  {
263  checkCache();
264  prepareForUVSearch();
265  return const_cast<const SurfaceBase*>(this)->
266  samplePoint(a_uv);
267  }
268 
269 virtual SpatialVector samplePoint(const SpatialTransform& a_transform,
270  Vector2 a_uv) const
271  { return transformVector(a_transform,
272  sample(a_uv).translation()); }
273 virtual SpatialVector samplePoint(Vector2 a_uv) const
274  { return sample(a_uv).translation(); }
275 
276 virtual SpatialVector sampleNormal(const SpatialTransform& a_transform,
277  Vector2 a_uv)
278  {
279  checkCache();
280  prepareForUVSearch();
281  return const_cast<const SurfaceBase*>(this)->
282  sampleNormal(a_transform,a_uv);
283  }
284 virtual SpatialVector sampleNormal(Vector2 a_uv)
285  {
286  checkCache();
287  prepareForUVSearch();
288  return const_cast<const SurfaceBase*>(this)->
289  sampleNormal(a_uv);
290  }
291 
292 virtual SpatialVector sampleNormal(const SpatialTransform& a_transform,
293  Vector2 a_uv) const
294  { return rotateVector(a_transform,
295  sample(a_uv).up()); }
296 virtual SpatialVector sampleNormal(Vector2 a_uv) const
297  { return sample(a_uv).up(); }
298 
299 virtual void prepareForSample(void) { checkCache(); }
300 virtual void prepareForSearch(void) {}
301 virtual void prepareForUVSearch(void) {}
302 
303 virtual Containment containment(const SpatialVector& a_origin)
304  {
305  checkCache();
306  prepareForSearch();
307  return const_cast<const SurfaceBase*>(this)->
308  containment(a_origin);
309  }
310 virtual Containment containment(const SpatialVector& a_origin) const;
311 
312 virtual sp<ImpactI> nearestPoint(const SpatialTransform& a_transform,
313  const SpatialVector& a_origin,
314  Real a_maxDistance)
315  {
316  checkCache();
317  prepareForSearch();
318  return const_cast<const SurfaceBase*>(this)->
319  nearestPoint(a_transform,a_origin,
320  a_maxDistance);
321  }
322 virtual sp<ImpactI> nearestPoint(const SpatialVector& a_origin,
323  Real a_maxDistance,BWORD a_anyHit)
324  {
325  checkCache();
326  prepareForSearch();
327  return const_cast<const SurfaceBase*>(this)->
328  nearestPoint(a_origin,a_maxDistance,
329  a_anyHit);
330  }
331 virtual sp<ImpactI> nearestPoint(const SpatialVector& a_origin,
332  Real a_maxDistance)
333  {
334  checkCache();
335  prepareForSearch();
336  return const_cast<const SurfaceBase*>(this)->
337  nearestPoint(a_origin,a_maxDistance);
338  }
339 virtual sp<ImpactI> nearestPoint(const SpatialVector& a_origin)
340  {
341  const Real maxDistance= -1.0;
342  return nearestPoint(a_origin,maxDistance);
343  }
344 virtual sp<ImpactI> nearestPoint(const Vector2& a_uv)
345  {
346  checkCache();
347  prepareForUVSearch();
348  return const_cast<const SurfaceBase*>(this)->
349  nearestPoint(a_uv);
350  }
351 
352 virtual sp<ImpactI> nearestPoint(const SpatialTransform& a_transform,
353  const SpatialVector& a_origin,
354  Real a_maxDistance) const
355  {
356  const SpatialVector invOrigin=
357  inverseTransformVector(
358  a_transform,a_origin);
359  sp<Impact> spImpact=nearestPoint(invOrigin,
360  a_maxDistance);
361  if(spImpact.isValid())
362  {
363  spImpact->setTransform(a_transform);
364  }
365  return spImpact;
366  }
367 virtual sp<ImpactI> nearestPoint(const SpatialVector& a_origin,
368  Real a_maxDistance,BWORD a_anyHit) const
369  { return nearestPoint(a_origin,a_maxDistance); }
370 virtual sp<ImpactI> nearestPoint(const SpatialVector& a_origin,
371  Real a_maxDistance) const
372  { return sp<ImpactI>(NULL); }
373 virtual sp<ImpactI> nearestPoint(const SpatialVector& a_origin) const
374  { return nearestPoint(a_origin,-1.0,FALSE); }
375 
376 virtual sp<ImpactI> nearestPoint(const Vector2& a_uv) const
377  { return sp<ImpactI>(NULL); }
378 
379 virtual Array< sp<SurfaceI::ImpactI> >
380  nearestPoints(const Vector2& a_uv,
381  Real a_maxDistance,U32 a_hitLimit)
382  {
383  checkCache();
384  prepareForUVSearch();
385  return const_cast<const SurfaceBase*>(this)->
386  nearestPoints(a_uv,a_maxDistance,
387  a_hitLimit);
388  }
389 virtual Array< sp<SurfaceI::ImpactI> >
390  nearestPoints(const Vector2& a_uv,
391  Real a_maxDistance,U32 a_hitLimit) const
392  {
393  //* default implementation is single point
394  Array< sp<SurfaceI::ImpactI> >
395  impactArray;
396  sp<SurfaceI::ImpactI> spImpact=
397  nearestPoint(a_uv,a_maxDistance);
398  if(spImpact.isValid())
399  {
400  impactArray.resize(1);
401  impactArray[0]=spImpact;
402  }
403  return impactArray;
404  }
405 
406 virtual Array< sp<SurfaceI::ImpactI> >
407  nearestPoints(const SpatialVector& a_origin,
408  Real a_maxDistance,U32 a_hitLimit)
409  {
410  return nearestPoints(a_origin,
411  a_maxDistance,a_hitLimit,
412  sp<PartitionI>(NULL));
413  }
414 virtual Array< sp<SurfaceI::ImpactI> >
415  nearestPoints(const SpatialVector& a_origin,
416  Real a_maxDistance,U32 a_hitLimit) const
417  {
418  return nearestPoints(a_origin,
419  a_maxDistance,a_hitLimit,
420  sp<PartitionI>(NULL));
421  }
422 
423 virtual Array< sp<SurfaceI::ImpactI> >
424  nearestPoints(const SpatialVector& a_origin,
425  Real a_maxDistance,U32 a_hitLimit,
426  sp<PartitionI> a_spPartition)
427  {
428  checkCache();
429  prepareForSearch();
430  return const_cast<const SurfaceBase*>(this)->
431  nearestPoints(a_origin,a_maxDistance,
432  a_hitLimit,a_spPartition);
433  }
434 virtual Array< sp<SurfaceI::ImpactI> >
435  nearestPoints(const SpatialVector& a_origin,
436  Real a_maxDistance,U32 a_hitLimit,
437  sp<PartitionI> a_spPartition) const
438  {
439  //* default implementation is single point
440  Array< sp<SurfaceI::ImpactI> >
441  impactArray;
442  sp<SurfaceI::ImpactI> spImpact=
443  nearestPoint(a_origin,a_maxDistance);
444  if(spImpact.isValid())
445  {
446  impactArray.resize(1);
447  impactArray[0]=spImpact;
448  }
449  return impactArray;
450  }
451 
452 virtual sp<ImpactI> rayImpact(const SpatialTransform& a_transform,
453  const SpatialVector& a_origin,
454  const SpatialVector& a_direction,
455  Real a_maxDistance,BWORD a_anyHit)
456  {
457  checkCache();
458  prepareForSearch();
459  return const_cast<const SurfaceBase*>(this)->
460  rayImpact(a_transform,
461  a_origin,a_direction,
462  a_maxDistance,a_anyHit);
463  }
464 
465 virtual sp<ImpactI> rayImpact(const SpatialTransform& a_transform,
466  const SpatialVector& a_origin,
467  const SpatialVector& a_direction,
468  Real a_maxDistance,BWORD a_anyHit) const
469  {
470  const SpatialVector invOrigin=
471  inverseTransformVector(
472  a_transform,a_origin);
473  const SpatialVector invDirection=
474  inverseRotateVector(
475  a_transform,a_direction);
476  sp<Impact> spImpact=rayImpact(
477  invOrigin,invDirection,
478  a_maxDistance,a_anyHit);
479  if(spImpact.isValid())
480  {
481  spImpact->setTransform(a_transform);
482  }
483  return spImpact;
484  }
485 
486 virtual sp<ImpactI> rayImpact(const SpatialVector& a_origin,
487  const SpatialVector& a_direction,
488  Real a_maxDistance,BWORD a_anyHit)
489  {
490  checkCache();
491  prepareForSearch();
492  return const_cast<const SurfaceBase*>(this)->
493  rayImpact(a_origin,a_direction,
494  a_maxDistance,a_anyHit);
495  }
496 
497 virtual sp<ImpactI> rayImpact(const SpatialVector& a_origin,
498  const SpatialVector& a_direction,
499  Real a_maxDistance,BWORD a_anyHit) const
500  { return sp<ImpactI>(NULL); }
501 
502 virtual sp<ImpactI> rayImpact(const SpatialVector& a_origin,
503  const SpatialVector& a_direction,
504  Real a_maxDistance)
505  {
506  checkCache();
507  prepareForSearch();
508  return const_cast<const SurfaceBase*>(this)->
509  rayImpact(a_origin,a_direction,
510  a_maxDistance,FALSE);
511  }
512 
513 virtual sp<ImpactI> rayImpact(const SpatialVector& a_origin,
514  const SpatialVector& a_direction,
515  Real a_maxDistance) const
516  { return rayImpact(a_origin,a_direction,
517  a_maxDistance,FALSE); }
518 
519 virtual Array< sp<SurfaceI::ImpactI> >
520  rayImpacts(const SpatialVector& a_origin,
521  const SpatialVector& a_direction,
522  Real a_maxDistance,U32 a_hitLimit)
523  {
524  checkCache();
525  prepareForSearch();
526  return const_cast<const SurfaceBase*>(this)->
527  rayImpacts(a_origin,a_direction,
528  a_maxDistance,a_hitLimit);
529  }
530 virtual Array< sp<SurfaceI::ImpactI> >
531  rayImpacts(const SpatialVector& a_origin,
532  const SpatialVector& a_direction,
533  Real a_maxDistance,U32 a_hitLimit) const
534  {
535  //* default implementation is single point
536  Array< sp<SurfaceI::ImpactI> >
537  impactArray;
538  sp<SurfaceI::ImpactI> spImpact=rayImpact(
539  a_origin,a_direction,
540  a_maxDistance,FALSE);
541  if(spImpact.isValid())
542  {
543  impactArray.resize(1);
544  impactArray[0]=spImpact;
545  }
546  return impactArray;
547  }
548 
549 virtual sp<ImpactI> coneImpact(const SpatialVector& a_origin,
550  const SpatialVector& a_direction,
551  Real a_maxDistance,Real a_coneAngle,
552  sp<DrawI> a_spDrawI);
553 virtual sp<ImpactI> coneImpact(const SpatialTransform& a_transform,
554  const SpatialVector& a_origin,
555  const SpatialVector& a_direction,
556  Real a_maxDistance,Real a_coneAngle,
557  sp<DrawI> a_spDrawI);
558 
559 virtual sp<ImpactI> capsuleImpact(const SpatialVector& a_origin,
560  const SpatialVector& a_direction,
561  Real a_maxDistance,Real a_radius,
562  BWORD a_anyHit,sp<DrawI> a_spDrawI,
563  sp<ImpactI> a_spLastImpact);
564 virtual sp<ImpactI> capsuleImpact(const SpatialTransform& a_transform,
565  const SpatialVector& a_origin,
566  const SpatialVector& a_direction,
567  Real a_maxDistance,Real a_radius,
568  BWORD a_anyHit,sp<DrawI> a_spDrawI,
569  sp<ImpactI> a_spLastImpact);
570 
571 virtual sp<GaugeI> gauge(void) { return sp<GaugeI>(NULL); }
572 
573 virtual void partitionWith(String a_attributeName) {}
574 virtual U32 partitionCount(void) const { return 0; }
575 virtual String partitionName(U32 a_index) const { return ""; }
576 virtual Vector4 partitionSphere(U32 a_index) const
577  { Vector4 sphere=center();
578  sphere[3]=radius();
579  return sphere; }
580 virtual I32 setPartitionFilter(String a_filterString)
581  { return setPartitionFilter(a_filterString,
582  PartitionI::e_matchRegex); }
583 virtual I32 setPartitionFilter(String a_filterString,
584  PartitionI::FilterMethod a_filterMethod)
585  { return 0; }
586 virtual sp<PartitionI> createPartition(void)
587  { return sp<PartitionI>(NULL); }
588 
589  //* As DrawableI
590 virtual void draw(sp<DrawI> a_spDrawI,const fe::Color* a_pColor)
591  {
592  checkCache();
593  const_cast<const SurfaceBase*>(this)->draw(
594  a_spDrawI,a_pColor);
595  }
596 virtual void draw(sp<DrawI> a_spDrawI,
597  const fe::Color* a_pColor) const
598  {
599  SpatialTransform identity;
600  setIdentity(identity);
601  draw(identity,a_spDrawI,a_pColor);
602  }
603 virtual void draw(const SpatialTransform& a_transform,
604  sp<DrawI> a_spDrawI,
605  const fe::Color* a_pColor)
606  {
607  checkCache();
608  const_cast<const SurfaceBase*>(this)->
609  draw(a_transform,a_spDrawI,a_pColor);
610  }
611 virtual void draw(const SpatialTransform& a_transform,
612  sp<DrawI> a_spDrawI,
613  const fe::Color* a_pColor) const
614  {
615  draw(a_transform,a_spDrawI,
616  a_pColor,sp<DrawBufferI>(NULL),
617  sp<PartitionI>(NULL));
618  }
619 virtual void draw(const SpatialTransform& a_transform,
620  sp<DrawI> a_spDrawI,
621  const fe::Color* a_pColor,
622  sp<DrawBufferI> a_spDrawBuffer,
623  sp<PartitionI> a_spPartition)
624  {
625  checkCache();
626  const_cast<const SurfaceBase*>(this)->
627  draw(a_transform,a_spDrawI,
628  a_pColor,a_spDrawBuffer,a_spPartition);
629  }
630 virtual void draw(const SpatialTransform& a_transform,
631  sp<DrawI> a_spDrawI,
632  const fe::Color* a_pColor,
633  sp<DrawBufferI> a_spDrawBuffer,
634  sp<PartitionI> a_spPartition) const {}
635 
636  //* as RecordableI
637 virtual void bind(Record& rRecord) {}
638 
639  protected:
640 
641  sp<ImpactI> shootRay(const SpatialVector& a_origin,
642  const SpatialVector& a_direction,
643  Real a_maxDistance,BWORD a_anyHit,
644  sp<ImpactI> a_spLastImpact);
645  sp<ImpactI> tubeImpact(const SpatialVector& a_origin,
646  const SpatialVector& a_direction,
647  Real a_maxDistance,
648  Real a_radius0,Real a_radius1,
649  BWORD a_anyHit,
650  sp<DrawI> a_spDrawI,
651  sp<ImpactI> a_spLastImpact);
652 
653 virtual void cache(void) {}
654 virtual void checkCache(void)
655  {
656  if(!m_cached)
657  {
658  m_cached=TRUE;
659  cache();
660  }
661  }
662 
663 static void drawHit(sp<DrawI> a_spDrawI,SpatialVector a_center,
664  Real a_radius,Color a_color);
665 
666  BWORD m_cached;
667  SampleMethod m_sampleMethod;
668  String m_nodeName;
669  Restrictions m_restrictions;
670 };
671 
672 } /* namespace ext */
673 } /* namespace fe */
674 
675 #endif /* __surface_SurfaceBase_h__ */
676 
fe::ext::DrawableI
Visualizable object using a DrawI.
Definition: DrawableI.h:20
fe::ext::SurfaceBase::draw
virtual void draw(sp< DrawI > a_spDrawI, const fe::Color *a_pColor)
Draw with current settings.
Definition: SurfaceBase.h:590
fe::ext::SurfaceBase::diffuse
virtual Color diffuse(void) const
Return the diffuse color.
Definition: SurfaceBase.h:183
fe::ext::SurfaceBase::setTriangulation
virtual void setTriangulation(Triangulation a_triangulation)
Set how 4+ vertex polygons break down.
Definition: SurfaceBase.h:207
fe::ext::SurfaceI
Spatial boundary.
Definition: SurfaceI.h:20
fe::ext::SurfaceBase::setRefinement
virtual void setRefinement(U32 a_refinement)
Set limitation of surface improvement, such as subdivision.
Definition: SurfaceBase.h:199
fe::Instance
Smart pointer used with types represented by BaseType.
Definition: Instance.h:28
fe
kernel
Definition: namespace.dox:3
fe::Color
Special vector for color (RGBA)
Definition: Color.h:21
fe::ext::SurfaceBase::bind
virtual void bind(Instance a_instance)
associate with model data
Definition: SurfaceBase.h:175
fe::hp
Safe handle for shared pointer.
Definition: Handled.h:61
fe::String
Automatically reference-counted string container.
Definition: String.h:128
fe::ext::SurfaceI::ImpactI
results of a surface intersection
Definition: SurfaceI.h:60
fe::ext::SurfaceBase
Trivial Point Origin Surface.
Definition: SurfaceBase.h:20
fe::ext::RecordableI
Generic binding to a serializable state.
Definition: RecordableI.h:20
fe::ext::SurfaceBase::setSearch
virtual void setSearch(String a_searchName)
Set component to use for searching.
Definition: SurfaceBase.h:205
fe::Array
Wrapper for std::vector.
Definition: Array.h:21
fe::RecordSB
Reference to an instance of a Layout.
Definition: RecordSB.h:35
fe::ext::SurfaceBase::triangleCount
virtual I32 triangleCount(void)
Number of barycentric elements.
Definition: SurfaceBase.h:209
fe::ext::SurfaceBase::setAccuracy
virtual void setAccuracy(SurfaceI::Accuracy a_accuracy)
Set what primitive to search down to.
Definition: SurfaceBase.h:201
fe::ext::SurfaceBase::setSearchable
virtual void setSearchable(BWORD a_searchable)
Set whether this surface may be searched.
Definition: SurfaceBase.h:203
fe::CastableAs
Per-class participation non-RTTI fallback dynamic casting mechanism.
Definition: Castable.h:192
Generated by   doxygen 1.8.13