Support Forum       G3D Web Page     
Public Types | Public Member Functions | Static Public Member Functions | Public Attributes | Protected Member Functions | Static Protected Member Functions | Protected Attributes | List of all members
G3D::Map2D< Storage, Compute > Class Template Reference

Map of values across a discrete 2D plane. More...

Inherits G3D::ReferenceCountedObject.

Public Types

typedef Compute ComputeType
 
typedef Storage StorageType
 
typedef Map2D< Storage, Compute > Type
 

Public Member Functions

Compute average () const
 Returns the average value of all elements of the map. More...
 
Compute bicubic (float x, float y, WrapMode wrap) const
 
Uses Catmull-Rom splines to interpolate between grid values. More...
 
Compute bicubic (float x, float y) const
 
Compute bicubic (const Vector2 &p, WrapMode wrap) const
 
Compute bicubic (const Vector2 &p) const
 
Compute bilinear (float x, float y, WrapMode wrap) const
 
Needs to access elements from (floor(x), floor(y)) to (floor(x) + 1, floor(y) + 1) and will use the wrap mode appropriately (possibly generating out of bounds errors). More...
 
Compute bilinear (float x, float y) const
 
Compute bilinear (const Vector2 &p) const
 
Compute bilinear (const Vector2 &p, WrapMode wrap) const
 
bool changed ()
 
Returns true if this map has been written to since the last call to setChanged(false). More...
 
virtual void crop (int newX, int newY, int newW, int newH)
 
Crops this map so that it only contains pixels between (x, y) and (x + w - 1, y + h - 1) inclusive. More...
 
virtual void crop (const Rect2D &rect)
 iRounds to the nearest x0 and y0. More...
 
const Storage & fastGet (int x, int y) const
 Unsafe access to the underlying data structure with no wrapping support; requires that (x, y) is in bounds. More...
 
void fastSet (int x, int y, const Storage &v)
 Unsafe access to the underlying data structure with no wrapping support; requires that (x, y) is in bounds. More...
 
virtual void flipHorizontal ()
 
virtual void flipVertical ()
 
const Storage & get (int x, int y, WrapMode wrap) const
 Get the value at (x, y). More...
 
const Storage & get (int x, int y) const
 
const Storage & get (const Vector2int16 &p) const
 
const Storage & get (const Vector2int16 &p, WrapMode wrap) const
 
Storage & get (int x, int y, WrapMode wrap)
 
Storage & get (int x, int y)
 
Storage & get (const Vector2int16 &p)
 
Array< Storage > & getArray ()
 Row-major array. More...
 
const Array< Storage > & getArray () const
 
Storage * getCArray ()
 Returns a pointer to the underlying row-major data. More...
 
const Storage * getCArray () const
 
int32 height () const
 Pixel height. More...
 
bool inBounds (int x, int y) const
 is (x, y) strictly within the image bounds, or will it trigger some kind of wrap mode More...
 
bool inBounds (const Vector2int16 &v) const
 is (x, y) strictly within the image bounds, or will it trigger some kind of wrap mode More...
 
void maybeFlipVertical (bool flip)
 flips if flip is true More...
 
Compute nearest (float x, float y, WrapMode wrap) const
 Returns the nearest neighbor. More...
 
Compute nearest (float x, float y) const
 
Compute nearest (const Vector2 &p) const
 
Rect2D rect2DBounds () const
 Rectangle from (0, 0) to (w, h) More...
 
void resize (uint32 newW, uint32 newH, uint32 newD=1)
 Resizes without clearing, leaving garbage. More...
 
void set (const Vector2int16 &p, const Storage &v)
 Sets the changed flag to true. More...
 
void set (int x, int y, const Storage &v, WrapMode wrap)
 Sets the changed flag to true. More...
 
void set (int x, int y, const Storage &v)
 
template<class T >
void set (const shared_ptr< Map2D< Storage, T > > &src)
 Copy values from src, which must have the same size. More...
 
void setAll (const Storage &v)
 
void setChanged (bool c)
 Set/unset the changed flag. More...
 
void setWrapMode (WrapMode m)
 
Vector2int16 size () const
 Dimensions in pixels. More...
 
size_t sizeInMemory () const
 Number of bytes occupied by the image data and this structure. More...
 
int32 width () const
 Pixel width. More...
 
WrapMode wrapMode () const
 

Static Public Member Functions

static shared_ptr< Map2D< Storage, Compute > > create (int w=0, int h=0, WrapMode wrap=WrapMode::ERROR, int d=1)
 
static float R (float x)
 

Public Attributes

std::mutex mutex
 
Although Map2D is not threadsafe (except for the setChanged() method), you can use this mutex to create your own threadsafe access to a Map2D. More...
 

Protected Member Functions

 Map2D (int w, int h, WrapMode wrap, int d=1)
 
const Storage & slowGet (int x, int y, WrapMode wrap)
 Handles the exceptional cases from get. More...
 

Static Protected Member Functions

template<class T , class ... ArgTypes>
static shared_ptr< T > createShared (ArgTypes &&... args)
 Like std::make_shared, but works for protected constructors. More...
 

Protected Attributes

uint32 d
 Depth, in pixels, defaults to 1. More...
 
Array< Storage > data
 
uint32 h
 Height, in pixels. More...
 
std::atomic_bool m_changed
 false if no mutating method has been invoked since the last call to setChanged(); More...
 
WrapMode m_wrapMode
 
uint32 w
 Width, in pixels. More...
 
Storage ZERO
 

Detailed Description

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
class G3D::Map2D< Storage, Compute >

Map of values across a discrete 2D plane.

Can be thought of as a generic class for 2D images, allowing flexibility as to pixel format and convenient methods. In fact, the "pixels" can be any values on a grid that can be sensibly interpolated–RGB colors, scalars, 4D vectors, and so on.

Other "image" classes in G3D:

G3D::Image - Supports file formats, fast, Color3uint8 and Color4uint8 formats. No interpolation.

G3D::shared_ptr<Texture> - Represents image on the graphics card (not directly readable on the CPU). Supports 2D, 3D, and a variety of interpolation methods, loads file formats.

G3D::Image3 - A subclass of Map2D<Color3> that supports image loading and saving and conversion to Texture.

G3D::Image4 - A subclass of Map2D<Color4> that supports image loading and saving and conversion to Texture.

G3D::Image3uint8 - A subclass of Map2D<Color3uint8> that supports image loading and saving and conversion to Texture.

G3D::Image4uint8 - A subclass of Map2D<Color4uint8> that supports image loading and saving and conversion to Texture.

There are two type parameters– the first (@ Storage) is the type used to store the "pixel" values efficiently and the second (Compute) is the type operated on by computation. The Compute::Compute(Storage&) constructor is used to convert between storage and computation types. Storage is often an integer version of Compute, for example Map2D<double, uint8>. By default, the computation type is:

   Storage       Computation
   uint8          float32
   uint16         float32
   uint32         float64
   uint64         float64
   int8           float32
   int16          float32
   int32          float64
   int64          float64
   float32        float64
   float64        float64
   Vector2        Vector2
   Vector2int16   Vector2
   Vector3        Vector3
   Vector3int16   Vector3
   Vector4        Vector4
   Color3         Color3
   Color3uint8    Color3
   Color4         Color4
   Color4uint8    Color4
  

Any other storage type defaults to itself as the computation type.

The computation type can be any that supports lerp, +, -, *, /, and an empty constructor.

Assign value:

im->set(x, y, 7); or im->get(x, y) = 7;

Read value:

int c = im(x, y);

Can also sample with nearest neighbor, bilinear, and bicubic interpolation.
Sampling follows OpenGL conventions, where pixel values represent grid points and (0.5, 0.5) is half-way between two vertical and two horizontal grid points.
To draw an image of dimensions w x h with nearest neighbor sampling, render pixels from [0, 0] to [w - 1, h - 1].

Under the WrapMode::CLAMP wrap mode, the value of bilinear interpolation becomes constant outside [1, w - 2] horizontally. Nearest neighbor interpolation is constant outside [0, w - 1] and bicubic outside [3, w - 4]. The class does not offer quadratic interpolation because the interpolation filter could not center over a pixel.

In order to allow subclasses to mimic layered textures, Map2Ds can have an optional depth. Only the constructor and resize() handles depth in this class, to access anything but layer 0 subclasses must implement the functionality themselves.

Author
Morgan McGuire, http://casual-effects.com

Member Typedef Documentation

◆ ComputeType

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
typedef Compute G3D::Map2D< Storage, Compute >::ComputeType

◆ StorageType

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
typedef Storage G3D::Map2D< Storage, Compute >::StorageType

◆ Type

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
typedef Map2D<Storage, Compute> G3D::Map2D< Storage, Compute >::Type

Constructor & Destructor Documentation

◆ Map2D()

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
G3D::Map2D< Storage, Compute >::Map2D ( int  w,
int  h,
WrapMode  wrap,
int  d = 1 
)
inlineprotected

Member Function Documentation

◆ average()

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
Compute G3D::Map2D< Storage, Compute >::average ( ) const
inline

Returns the average value of all elements of the map.

◆ bicubic() [1/4]

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
Compute G3D::Map2D< Storage, Compute >::bicubic ( float  x,
float  y,
WrapMode  wrap 
) const
inline


Uses Catmull-Rom splines to interpolate between grid values.

Referenced by G3D::Map2D< Color1, Color1 >::bicubic().

◆ bicubic() [2/4]

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
Compute G3D::Map2D< Storage, Compute >::bicubic ( float  x,
float  y 
) const
inline

◆ bicubic() [3/4]

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
Compute G3D::Map2D< Storage, Compute >::bicubic ( const Vector2 p,
WrapMode  wrap 
) const
inline

◆ bicubic() [4/4]

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
Compute G3D::Map2D< Storage, Compute >::bicubic ( const Vector2 p) const
inline

◆ bilinear() [1/4]

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
Compute G3D::Map2D< Storage, Compute >::bilinear ( float  x,
float  y,
WrapMode  wrap 
) const
inline


Needs to access elements from (floor(x), floor(y)) to (floor(x) + 1, floor(y) + 1) and will use the wrap mode appropriately (possibly generating out of bounds errors).

Guaranteed to match nearest(x, y) at integers.

Referenced by G3D::Map2D< Color1, Color1 >::bilinear().

◆ bilinear() [2/4]

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
Compute G3D::Map2D< Storage, Compute >::bilinear ( float  x,
float  y 
) const
inline

◆ bilinear() [3/4]

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
Compute G3D::Map2D< Storage, Compute >::bilinear ( const Vector2 p) const
inline

◆ bilinear() [4/4]

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
Compute G3D::Map2D< Storage, Compute >::bilinear ( const Vector2 p,
WrapMode  wrap 
) const
inline

◆ changed()

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
bool G3D::Map2D< Storage, Compute >::changed ( )
inline


Returns true if this map has been written to since the last call to setChanged(false).

This is useful if you are caching a texture map other value that must be recomputed whenever this changes.

◆ create()

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
static shared_ptr< Map2D<Storage, Compute> > G3D::Map2D< Storage, Compute >::create ( int  w = 0,
int  h = 0,
WrapMode  wrap = WrapMode::ERROR,
int  d = 1 
)
inlinestatic

◆ createShared()

template<class T , class ... ArgTypes>
static shared_ptr<T> G3D::ReferenceCountedObject::createShared ( ArgTypes &&...  args)
inlinestaticprotectedinherited

Like std::make_shared, but works for protected constructors.

Call as createShared<myclass>.

◆ crop() [1/2]

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
virtual void G3D::Map2D< Storage, Compute >::crop ( int  newX,
int  newY,
int  newW,
int  newH 
)
inlinevirtual


Crops this map so that it only contains pixels between (x, y) and (x + w - 1, y + h - 1) inclusive.

◆ crop() [2/2]

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
virtual void G3D::Map2D< Storage, Compute >::crop ( const Rect2D rect)
inlinevirtual

iRounds to the nearest x0 and y0.

◆ fastGet()

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
const Storage& G3D::Map2D< Storage, Compute >::fastGet ( int  x,
int  y 
) const
inline

Unsafe access to the underlying data structure with no wrapping support; requires that (x, y) is in bounds.

Referenced by G3D::Map2D< Color1, Color1 >::slowGet().

◆ fastSet()

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
void G3D::Map2D< Storage, Compute >::fastSet ( int  x,
int  y,
const Storage &  v 
)
inline

Unsafe access to the underlying data structure with no wrapping support; requires that (x, y) is in bounds.

◆ flipHorizontal()

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
virtual void G3D::Map2D< Storage, Compute >::flipHorizontal ( )
inlinevirtual

◆ flipVertical()

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
virtual void G3D::Map2D< Storage, Compute >::flipVertical ( )
inlinevirtual

◆ get() [1/7]

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
const Storage& G3D::Map2D< Storage, Compute >::get ( int  x,
int  y,
WrapMode  wrap 
) const
inline

Get the value at (x, y).

Note that the type of image->get(x, y) is the storage type, not the computation type. If the constructor promoting Storage to Compute rescales values (as, for example Color3(Color3uint8&) does), this will not match the value returned by Map2D::nearest.

◆ get() [2/7]

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
const Storage& G3D::Map2D< Storage, Compute >::get ( int  x,
int  y 
) const
inline

◆ get() [3/7]

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
const Storage& G3D::Map2D< Storage, Compute >::get ( const Vector2int16 p) const
inline

◆ get() [4/7]

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
const Storage& G3D::Map2D< Storage, Compute >::get ( const Vector2int16 p,
WrapMode  wrap 
) const
inline

◆ get() [5/7]

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
Storage& G3D::Map2D< Storage, Compute >::get ( int  x,
int  y,
WrapMode  wrap 
)
inline

◆ get() [6/7]

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
Storage& G3D::Map2D< Storage, Compute >::get ( int  x,
int  y 
)
inline

◆ get() [7/7]

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
Storage& G3D::Map2D< Storage, Compute >::get ( const Vector2int16 p)
inline

◆ getArray() [1/2]

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
Array<Storage>& G3D::Map2D< Storage, Compute >::getArray ( )
inline

Row-major array.

You should call setChanged(true) if you mutate the array.

◆ getArray() [2/2]

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
const Array<Storage>& G3D::Map2D< Storage, Compute >::getArray ( ) const
inline

◆ getCArray() [1/2]

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
Storage* G3D::Map2D< Storage, Compute >::getCArray ( )
inline

Returns a pointer to the underlying row-major data.

There is no padding at the end of the row. Be careful–this will be reallocated during a resize. You should call setChanged(true) if you mutate the array.

◆ getCArray() [2/2]

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
const Storage* G3D::Map2D< Storage, Compute >::getCArray ( ) const
inline

◆ height()

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
int32 G3D::Map2D< Storage, Compute >::height ( ) const
inline

Pixel height.

Referenced by G3D::Map2D< Color1, Color1 >::set().

◆ inBounds() [1/2]

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
bool G3D::Map2D< Storage, Compute >::inBounds ( int  x,
int  y 
) const
inline

is (x, y) strictly within the image bounds, or will it trigger some kind of wrap mode

◆ inBounds() [2/2]

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
bool G3D::Map2D< Storage, Compute >::inBounds ( const Vector2int16 v) const
inline

is (x, y) strictly within the image bounds, or will it trigger some kind of wrap mode

◆ maybeFlipVertical()

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
void G3D::Map2D< Storage, Compute >::maybeFlipVertical ( bool  flip)
inline

flips if flip is true

◆ nearest() [1/3]

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
Compute G3D::Map2D< Storage, Compute >::nearest ( float  x,
float  y,
WrapMode  wrap 
) const
inline

Returns the nearest neighbor.

Pixel values are considered to be at the upper left corner, so image->nearest(x, y) == image(x, y)

Referenced by G3D::Map2D< Color1, Color1 >::nearest().

◆ nearest() [2/3]

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
Compute G3D::Map2D< Storage, Compute >::nearest ( float  x,
float  y 
) const
inline

◆ nearest() [3/3]

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
Compute G3D::Map2D< Storage, Compute >::nearest ( const Vector2 p) const
inline

◆ R()

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
static float G3D::Map2D< Storage, Compute >::R ( float  x)
inlinestatic

◆ rect2DBounds()

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
Rect2D G3D::Map2D< Storage, Compute >::rect2DBounds ( ) const
inline

Rectangle from (0, 0) to (w, h)

◆ resize()

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
void G3D::Map2D< Storage, Compute >::resize ( uint32  newW,
uint32  newH,
uint32  newD = 1 
)
inline

Resizes without clearing, leaving garbage.

Referenced by G3D::Map2D< Color1, Color1 >::Map2D().

◆ set() [1/4]

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
void G3D::Map2D< Storage, Compute >::set ( const Vector2int16 p,
const Storage &  v 
)
inline

Sets the changed flag to true.

◆ set() [2/4]

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
void G3D::Map2D< Storage, Compute >::set ( int  x,
int  y,
const Storage &  v,
WrapMode  wrap 
)
inline

Sets the changed flag to true.

◆ set() [3/4]

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
void G3D::Map2D< Storage, Compute >::set ( int  x,
int  y,
const Storage &  v 
)
inline

◆ set() [4/4]

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
template<class T >
void G3D::Map2D< Storage, Compute >::set ( const shared_ptr< Map2D< Storage, T > > &  src)
inline

Copy values from src, which must have the same size.

◆ setAll()

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
void G3D::Map2D< Storage, Compute >::setAll ( const Storage &  v)
inline

◆ setChanged()

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
void G3D::Map2D< Storage, Compute >::setChanged ( bool  c)
inline

◆ setWrapMode()

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
void G3D::Map2D< Storage, Compute >::setWrapMode ( WrapMode  m)
inline

◆ size()

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
Vector2int16 G3D::Map2D< Storage, Compute >::size ( ) const
inline

Dimensions in pixels.

◆ sizeInMemory()

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
size_t G3D::Map2D< Storage, Compute >::sizeInMemory ( ) const
inline

Number of bytes occupied by the image data and this structure.

◆ slowGet()

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
const Storage& G3D::Map2D< Storage, Compute >::slowGet ( int  x,
int  y,
WrapMode  wrap 
)
inlineprotected

Handles the exceptional cases from get.

◆ width()

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
int32 G3D::Map2D< Storage, Compute >::width ( ) const
inline

Pixel width.

Referenced by G3D::Map2D< Color1, Color1 >::set().

◆ wrapMode()

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
WrapMode G3D::Map2D< Storage, Compute >::wrapMode ( ) const
inline

Member Data Documentation

◆ d

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
uint32 G3D::Map2D< Storage, Compute >::d
protected

◆ data

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
Array<Storage> G3D::Map2D< Storage, Compute >::data
protected

◆ h

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
uint32 G3D::Map2D< Storage, Compute >::h
protected

◆ m_changed

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
std::atomic_bool G3D::Map2D< Storage, Compute >::m_changed
protected

false if no mutating method has been invoked since the last call to setChanged();

◆ m_wrapMode

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
WrapMode G3D::Map2D< Storage, Compute >::m_wrapMode
protected

◆ mutex

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
std::mutex G3D::Map2D< Storage, Compute >::mutex


Although Map2D is not threadsafe (except for the setChanged() method), you can use this mutex to create your own threadsafe access to a Map2D.

Not used by the default implementation.

◆ w

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
uint32 G3D::Map2D< Storage, Compute >::w
protected

◆ ZERO

template<typename Storage, typename Compute = typename G3D::_internal::_GetComputeType<Storage>::Type>
Storage G3D::Map2D< Storage, Compute >::ZERO
protected

documentation generated on Wed Nov 24 2021 08:01:57 using doxygen 1.8.15