Field3D
ProceduralField.h File Reference

Contains the ProceduralField class. More...

#include "Field.h"
#include "ns.h"

Go to the source code of this file.

Classes

class  ProceduralField< Data_T >
 

Macros

#define INSTANTIATE_FIELD_TYPES(FIELDCLASS)
 
#define REGISTER_FIELD_TYPES(FIELDCLASS)
 

Typedefs

typedef ProceduralField< V3dProceduralField3d
 
typedef ProceduralField< V3fProceduralField3f
 
typedef ProceduralField< V3hProceduralField3h
 
typedef ProceduralField< doubleProceduralFieldd
 
typedef ProceduralField< floatProceduralFieldf
 
typedef ProceduralField< halfProceduralFieldh
 

Functions

 FIELD3D_CLASSTYPE_TEMPL_INSTANTIATION (ProceduralField)
 

Detailed Description

Contains the ProceduralField class.

Definition in file ProceduralField.h.

Macro Definition Documentation

◆ REGISTER_FIELD_TYPES

#define REGISTER_FIELD_TYPES (   FIELDCLASS)
Value:
factory.registerField(FIELDCLASS<half>::create); \
factory.registerField(FIELDCLASS<float>::create); \
factory.registerField(FIELDCLASS<double>::create); \
factory.registerField(FIELDCLASS<V3h>::create); \
factory.registerField(FIELDCLASS<V3f>::create); \
factory.registerField(FIELDCLASS<V3d>::create)
#define FIELD3D_MTX_T
Definition StdMathLib.h:99

Definition at line 70 of file ProceduralField.h.

119 : public Field<Data_T>
120{
121
122public:
123
124 // Typedefs ------------------------------------------------------------------
125
126 typedef boost::intrusive_ptr<ProceduralField> Ptr;
127
128 typedef ProceduralFieldLookup<Data_T> LinearInterp;
129 typedef ProceduralFieldLookup<Data_T> CubicInterp;
130
131 // RTTI replacement ----------------------------------------------------------
132
133 typedef ProceduralField<Data_T> class_type;
135
136 static const char *staticClassName()
137 {
138 return "ProceduralField";
139 }
140
141 static const char *staticClassType()
142 {
144 }
145
146 // Constructors --------------------------------------------------------------
147
149 virtual ~ProceduralField()
150 { /* Empty */ }
151
152 // To be implemented by subclasses -------------------------------------------
153
154 virtual Data_T lsSample(const V3d &lsP) const = 0;
155
156 // From FieldBase ------------------------------------------------------------
157
159
160 // From Field ----------------------------------------------------------------
161
164 virtual Data_T value(int i, int j, int k) const = 0;
165
166 // Main methods --------------------------------------------------------------
167
171 Data_T typedIntMetadata(const std::string &name,
172 const Data_T& defaultVal) const;
176 Data_T typedFloatMetadata(const std::string &name,
177 const Data_T& defaultVal) const;
178
179private:
180
181 // Static data members -------------------------------------------------------
182
183 static TemplatedFieldType<ProceduralField<Data_T> > ms_classType;
184
185 // Typedefs ------------------------------------------------------------------
186
187 typedef Field<Data_T> base;
188
189};
190
191//----------------------------------------------------------------------------//
192// Typedefs
193//----------------------------------------------------------------------------//
194
201
202//----------------------------------------------------------------------------//
203// Static member instantiation
204//----------------------------------------------------------------------------//
205
207
208//----------------------------------------------------------------------------//
209// Template specializations
210//----------------------------------------------------------------------------//
211
212template <>
213inline half
214ProceduralField<half>::typedIntMetadata(const std::string &name,
215 const half& defaultVal) const
216{
217 return metadata().intMetadata(name, static_cast<int>(defaultVal));
218}
219
220//----------------------------------------------------------------------------//
221
222template <>
223inline float
224ProceduralField<float>::typedIntMetadata(const std::string &name,
225 const float& defaultVal) const
226{
227 return metadata().intMetadata(name, static_cast<int>(defaultVal));
228}
229
230//----------------------------------------------------------------------------//
231
232template <>
233inline double
234ProceduralField<double>::typedIntMetadata(const std::string &name,
235 const double& defaultVal) const
236{
237 return metadata().intMetadata(name, static_cast<int>(defaultVal));
238}
239
240//----------------------------------------------------------------------------//
241
242template <>
243inline V3h
244ProceduralField<V3h>::typedIntMetadata(const std::string &name,
245 const V3h& defaultVal) const
246{
247 return V3h(metadata().vecIntMetadata(name, defaultVal));
248}
249
250//----------------------------------------------------------------------------//
251
252template <>
253inline V3f
254ProceduralField<V3f>::typedIntMetadata(const std::string &name,
255 const V3f& defaultVal) const
256{
257 return V3f(metadata().vecIntMetadata(name, defaultVal));
258}
259
260//----------------------------------------------------------------------------//
261
262template <>
263inline V3d
264ProceduralField<V3d>::typedIntMetadata(const std::string &name,
265 const V3d& defaultVal) const
266{
267 return V3d(metadata().vecIntMetadata(name, defaultVal));
268}
269
270//----------------------------------------------------------------------------//
271
272template <>
273inline half
274ProceduralField<half>::typedFloatMetadata(const std::string &name,
275 const half& defaultVal) const
276{
277 return metadata().floatMetadata(name, static_cast<float>(defaultVal));
278}
279
280//----------------------------------------------------------------------------//
281
282template <>
283inline float
284ProceduralField<float>::typedFloatMetadata(const std::string &name,
285 const float& defaultVal) const
286{
287 return metadata().floatMetadata(name, defaultVal);
288}
289
290//----------------------------------------------------------------------------//
291
292template <>
293inline double
294ProceduralField<double>::typedFloatMetadata(const std::string &name,
295 const double& defaultVal) const
296{
297 return metadata().floatMetadata(name, static_cast<float>(defaultVal));
298}
299
300//----------------------------------------------------------------------------//
301
302template <>
303inline V3h
304ProceduralField<V3h>::typedFloatMetadata(const std::string &name,
305 const V3h& defaultVal) const
306{
307 return V3h(metadata().vecFloatMetadata(name, defaultVal));
308}
309
310//----------------------------------------------------------------------------//
311
312template <>
313inline V3f
314ProceduralField<V3f>::typedFloatMetadata(const std::string &name,
315 const V3f& defaultVal) const
316{
317 return V3f(metadata().vecFloatMetadata(name, defaultVal));
318}
319
320//----------------------------------------------------------------------------//
321
322template <>
323inline V3d
324ProceduralField<V3d>::typedFloatMetadata(const std::string &name,
325 const V3d& defaultVal) const
326{
327 return V3d(metadata().vecFloatMetadata(name, defaultVal));
328}
329
330//----------------------------------------------------------------------------//
331
333
334//----------------------------------------------------------------------------//
335
336#endif // Include guard
337
#define FIELD3D_CLASSTYPE_TEMPL_INSTANTIATION(field)
Definition Field.h:479
#define FIELD3D_CLASSNAME_CLASSTYPE_IMPLEMENTATION
Definition Field.h:473
ProceduralField< V3f > ProceduralField3f
ProceduralField< half > ProceduralFieldh
ProceduralField< float > ProceduralFieldf
ProceduralField< V3h > ProceduralField3h
ProceduralField< V3d > ProceduralField3d
ProceduralField< double > ProceduralFieldd
#define DEFINE_FIELD_RTTI_ABSTRACT_CLASS
Definition RefCount.h:88
Imath::V3d V3d
Definition SpiMathLib.h:74
FIELD3D_NAMESPACE_OPENtypedef ::half half
Definition SpiMathLib.h:64
Imath::Vec3< half > V3h
Definition SpiMathLib.h:72
Imath::V3f V3f
Definition SpiMathLib.h:73
std::string name
Optional name of the field.
Definition Field.h:171
Definition Field.h:390
Data_T typedIntMetadata(const std::string &name, const Data_T &defaultVal) const
Calls either sampleIntMetadata() if the ProceduralField is scalar (half, float, or double),...
Data_T typedFloatMetadata(const std::string &name, const Data_T &defaultVal) const
Calls either sampleFloatMetadata() if the ProceduralField is scalar (half, float, or double),...
#define FIELD3D_NAMESPACE_HEADER_CLOSE
Definition ns.h:58
Used to return a string for the name of a templated field.
Definition Traits.h:283

◆ INSTANTIATE_FIELD_TYPES

#define INSTANTIATE_FIELD_TYPES (   FIELDCLASS)
Value:
template class FIELDCLASS<half>; \
template class FIELDCLASS<float>; \
template class FIELDCLASS<double>; \
template class FIELDCLASS<V3h>; \
template class FIELDCLASS<V3f>; \
template class FIELDCLASS<V3d>

Definition at line 78 of file ProceduralField.h.

Typedef Documentation

◆ ProceduralFieldh

◆ ProceduralFieldf

◆ ProceduralFieldd

◆ ProceduralField3h

◆ ProceduralField3f

◆ ProceduralField3d

Function Documentation

◆ FIELD3D_CLASSTYPE_TEMPL_INSTANTIATION()

FIELD3D_CLASSTYPE_TEMPL_INSTANTIATION ( ProceduralField  )