Real-valued vector usable by GPU. More...

#include <linear_mapping.h>

Inheritance diagram for Beatmup::GL::Vector:

Public Types
enum class	Format { TEXTURE , FIXED16 , FLOAT }
	Vector data format. More...

Public Types inherited from Beatmup::GL::TextureHandler
enum	TextureFormat { Rx8 , RGBx8 , RGBAx8 , Rx32f , RGBx32f , RGBAx32f , OES_Ext }
	Texture format, specifies how the texture should be interpreted on the shader side. More...

Public Member Functions
	Vector (Context &context, GraphicPipeline &gpu, const int size, const Format format)

	Vector (Context &context, GraphicPipeline &gpu, const int size, const Format format, const float *values, const bool remap=false)
	Creates a vector in GPU memory. More...

	~Vector ()

void	fetch (GraphicPipeline &gpu, std::vector< float > &output) const
	Grabs vector values back from GPU to user memory. More...

Format	getDataFormat () const

int	getSize () const
	Returns the length of the vector. More...

size_t	getMemorySize () const
	Returns memory size in bytes taken by the vector. More...

const int	getWidth () const
	Width of the texture in pixels. More...

const int	getHeight () const
	Height of the texture in pixels. More...

const int	getDepth () const
	Depth of the texture in pixels. More...

const TextureFormat	getTextureFormat () const
	Returns the texture format specifying how the shader must interpret the data. More...

float	getMappingScale () const
	Provides the scale factor applied to the vector values sent to GPU. More...

float	getMappingOffset () const
	Provides the constant offset added to the vector values sent to GPU. More...

Public Member Functions inherited from Beatmup::GL::TextureHandler
	~TextureHandler ()

float	getAspectRatio () const
	Aspect ratio of the texture. More...

float	getInvAspectRatio () const
	Inverse of the aspect ratio of the texture. More...

const bool	isFloatingPoint () const

const int	getNumberOfChannels () const
	Returns number of channels containing in the texture. More...

bool	hasValidHandle () const
	Returns `true` if the texture handle points to a valid texture. More...

Public Member Functions inherited from Beatmup::Object
virtual	~Object ()

Static Public Attributes
static const Format	DEFAULT_FORMAT = Vector::Format::FLOAT

Static Public Attributes inherited from Beatmup::GL::TextureHandler
static const int	TEXTURE_FORMAT_BYTES_PER_PIXEL []
	size of a texel in bytes for different texture formats More...

Private Member Functions
void	prepare (GraphicPipeline &gpu)
	Prepares (eventually uploads) texture data on GPU. More...

Private Attributes
Context &	context

const TextureFormat	texFormat
	texture format of the texture handler More...

const Format	format
	data format More...

const int	size
	number of samples in the vector More...

float	mapScale

float	mapOffset

Additional Inherited Members
Static Public Member Functions inherited from Beatmup::GL::TextureHandler
static const char *	textureFormatToString (const TextureFormat &)

Protected Member Functions inherited from Beatmup::GL::TextureHandler
	TextureHandler ()

void	invalidate (RecycleBin &)
	Forces disposing the texture data, e.g. More...

Protected Attributes inherited from Beatmup::GL::TextureHandler
handle_t	textureHandle

Detailed Description

Real-valued vector usable by GPU.

Definition at line 29 of file linear_mapping.h.

Member Enumeration Documentation

◆ Format

enum Beatmup::GL::Vector::Format

strong

Vector data format.

Enumerator
TEXTURE	8 bit per element covering [0, 1] range
FIXED16	16 bit per element
FLOAT	32 bit per element, floating point

Definition at line 34 of file linear_mapping.h.

                               {
                 TEXTURE,    //!< 8 bit per element covering [0, 1] range
                 FIXED16,    //!< 16 bit per element
                 FLOAT,      //!< 32 bit per element, floating point
             };

Constructor & Destructor Documentation

◆ Vector() [1/2]

Vector::Vector	(	Context &	context,
		GraphicPipeline &	gpu,
		const int	size,
		const Format	format
	)

Definition at line 363 of file linear_mapping.cpp.

                                                                                           :
     context(context),
     texFormat(format == Format::FLOAT ? TextureHandler::TextureFormat::RGBAx32f : TextureHandler::TextureFormat::RGBAx8),
     format(format),
     size(size),
     mapScale(1), mapOffset(0)
 {
 #ifdef BEATMUP_OPENGLVERSION_GLES20
     if (format == Format::FLOAT)
         throw RuntimeError("Floating-point vectors are not supported in ES 2.0");
 #endif
     RuntimeError::check(size % 4 == 0, "Vector size must be a multiple of four.");
  
     // init texture handler
     glGenTextures(1, &textureHandle);
     glActiveTexture(GL_TEXTURE0);
     glBindTexture(GL_TEXTURE_2D, textureHandle);
  
 #ifdef BEATMUP_OPENGLVERSION_GLES20
     glTexImage2D(GL_TEXTURE_2D,
         0,
         BITMAP_INTERNALFORMATS[texFormat],
         getWidth(), getHeight(),
         0,
         BITMAP_PIXELFORMATS[texFormat],
         BITMAP_PIXELTYPES[texFormat],
         nullptr
     );
 #else
     glTexStorage2D(GL_TEXTURE_2D, 1, BITMAP_INTERNALFORMATS[texFormat], getWidth(), getHeight());
 #endif
 }

◆ Vector() [2/2]

Vector::Vector	(	Context &	context,
		GraphicPipeline &	gpu,
		const int	size,
		const Format	format,
		const float *	values,
		const bool	remap = `false`
	)

Creates a vector in GPU memory.

Parameters

[in]	context	A context
[in]	gpu	A graphic pipeline instance
[in]	size	Size of the vector (number of scalar dimensions)
[in]	format	Vector data format used to store the values in GPU memory
[in]	values	Vector elements values
[in]	remap	If `true` and a fixed-point data format is used, the stored values are remapped to fit the range of the coresponding fixed-point representation.

Definition at line 397 of file linear_mapping.cpp.

                                                                                                                            :
     context(context),
     texFormat(format == Format::FLOAT ? TextureHandler::TextureFormat::RGBAx32f : TextureHandler::TextureFormat::RGBAx8),
     format(format),
     size(size),
     mapScale(1), mapOffset(0)
 {
 #ifdef BEATMUP_OPENGLVERSION_GLES20
     if (format == Format::FLOAT)
         throw RuntimeError("Floating-point vectors are not supported in ES 2.0");
 #endif
     RuntimeError::check(size % 4 == 0, "Vector size must be a multiple of four.");
  
     glGenTextures(1, &textureHandle);
     glActiveTexture(GL_TEXTURE0);
     glBindTexture(GL_TEXTURE_2D, textureHandle);
  
     if (format != Format::FLOAT) {
         // remap
         if (remap) {
             float minVal, maxVal;
             findMinMax(values, size, minVal, maxVal);
             if (maxVal > minVal) {
                 if (format == Format::FIXED16) {
                     mapScale = (Fixed16<8>::max() - Fixed16<8>::min()) / (maxVal - minVal);
                     mapOffset = Fixed16<8>::min() - minVal * mapScale;
                 }
                 else if (format == Format::TEXTURE) {
                     mapScale = 1.0f / (maxVal - minVal);
                     mapOffset = - minVal * mapScale;
                 }
             }
         }
  
         // convert data from floating point
         std::vector<uint8_t> textureData(4 * getHeight());
         if (format == Format::FIXED16)
             for (int i = 0; i < size; ++i)
                 packFloatTo16bit(mapOffset + mapScale * values[i], textureData[2 * i], textureData[2 * i + 1]);
         else if (format == Format::TEXTURE)
             for (int i = 0; i < size; ++i) {
                 const float val = mapOffset + mapScale * values[i];
                 textureData[i] = val <= 0.0f ? 0 : val >= 1.0f ? 255 : (uint8_t)roundf_fast(val * 255);
             }
         else
             Insanity::insanity("Invalid vector data format");
  
 #ifdef BEATMUP_OPENGLVERSION_GLES20
         glTexImage2D(GL_TEXTURE_2D,
             0,
             BITMAP_INTERNALFORMATS[texFormat],
             getWidth(), getHeight(),
             0,
             BITMAP_PIXELFORMATS[texFormat],
             BITMAP_PIXELTYPES[texFormat],
             textureData.data()
         );
 #else
         glTexStorage2D(GL_TEXTURE_2D, 1, BITMAP_INTERNALFORMATS[texFormat], getWidth(), getHeight());
         glTexSubImage2D(GL_TEXTURE_2D,
             0, 0, 0, getWidth(), getHeight(),
             BITMAP_PIXELFORMATS[texFormat],
             BITMAP_PIXELTYPES[texFormat],
             textureData.data()
         );
 #endif
     }
  
     else {
 #ifndef BEATMUP_OPENGLVERSION_GLES20
         glTexStorage2D(GL_TEXTURE_2D, 1, BITMAP_INTERNALFORMATS[texFormat], getWidth(), getHeight());
         glTexSubImage2D(GL_TEXTURE_2D,
             0, 0, 0, getWidth(), getHeight(),
             BITMAP_PIXELFORMATS[texFormat],
             BITMAP_PIXELTYPES[texFormat],
             values
         );
 #endif
     }
 }

◆ ~Vector()

Vector::~Vector ( )

Definition at line 479 of file linear_mapping.cpp.

                 {
     invalidate(*context.getGpuRecycleBin());
 }

Member Function Documentation

◆ prepare()

void Vector::prepare ( GraphicPipeline & gpu )

privatevirtual

Prepares (eventually uploads) texture data on GPU.

Called only by the context managing thread.

Parameters

[in] gpu Graphic pipeline instance

Reimplemented from Beatmup::GL::TextureHandler.

Definition at line 484 of file linear_mapping.cpp.

                                          {
     glBindTexture(GL_TEXTURE_2D, textureHandle);
 }

◆ fetch()

void Vector::fetch	(	GraphicPipeline &	gpu,
		std::vector< float > &	output
	)		const

Grabs vector values back from GPU to user memory.

Parameters

[in]	gpu	A graphic pipeline instance
[in]	output	The output vector

Definition at line 489 of file linear_mapping.cpp.

                                                                        {
     output.resize(size);
     gpu.bindOutput(textureHandle);
  
     if (format == Format::FLOAT)
         glReadPixels(0, 0, getWidth(), getHeight(),
             GL_RGBA, GL_FLOAT,
             output.data()
         );
     else if (format == Format::FIXED16) {
         glReadPixels(0, 0, getWidth(), getHeight(),
             GL_RGBA, GL_UNSIGNED_BYTE,
             (void*)output.data()
         );
  
         // convert values to float; use the same buffer, scan in inverse order
         const uint8_t* ptr = (const uint8_t*)output.data() + 2 * size;
         const size_t lastNum = output.size() - 1;
         for (size_t i = 0; i <= lastNum; ++i) {
             ptr -= 2;
             output[lastNum - i] = unpackFloatFrom16bit(ptr[0], ptr[1]);
         }
     }
     else if (format == Format::TEXTURE) {
         glReadPixels(0, 0, getWidth(), getHeight(),
             GL_RGBA, GL_UNSIGNED_BYTE,
             (void*)output.data()
         );
  
         // convert values to float; use the same buffer, scan in inverse order
         const uint8_t* ptr = (const uint8_t*)output.data() + size;
         const size_t lastNum = output.size() - 1;
         for (size_t i = 0; i <= lastNum; ++i) {
             --ptr;
             output[lastNum - i] = *ptr / 255.0f;
         }
     }
     else
         Insanity::insanity("Unsupported vector format");
  
     // remap back if needed
     if (mapScale != 1 || mapOffset != 0)
         for (auto& _ : output)
             _ = (_ - mapOffset) / mapScale;
 }

◆ getDataFormat()

Format Beatmup::GL::Vector::getDataFormat ( ) const

inline

Definition at line 72 of file linear_mapping.h.

72 { return format; }

◆ getSize()

int Beatmup::GL::Vector::getSize ( ) const

inline

Returns the length of the vector.

Definition at line 77 of file linear_mapping.h.

77 { return size; }

◆ getMemorySize()

size_t Vector::getMemorySize ( ) const

Returns memory size in bytes taken by the vector.

Definition at line 536 of file linear_mapping.cpp.

                                    {
     switch (format) {
         case Format::FLOAT:
             return sizeof(float) * (size_t)size;
         case Format::FIXED16:
             return 2 * (size_t)size;
         case Format::TEXTURE:
             return (size_t)size;
     }
     Insanity::insanity("Unsupported vector format");
     return 0;
 }

◆ getWidth()

const int Beatmup::GL::Vector::getWidth ( ) const

inlinevirtual

Width of the texture in pixels.

Implements Beatmup::GL::TextureHandler.

Definition at line 85 of file linear_mapping.h.

85 { return 1; }

◆ getHeight()

const int Beatmup::GL::Vector::getHeight ( ) const

inlinevirtual

Height of the texture in pixels.

Implements Beatmup::GL::TextureHandler.

Definition at line 86 of file linear_mapping.h.

86 { return format == Format::FIXED16 ? size / 2 : size / 4; }

◆ getDepth()

const int Beatmup::GL::Vector::getDepth ( ) const

inlinevirtual

Depth of the texture in pixels.

Implements Beatmup::GL::TextureHandler.

Definition at line 87 of file linear_mapping.h.

87 { return 1; }

◆ getTextureFormat()

const TextureFormat Beatmup::GL::Vector::getTextureFormat ( ) const

inlinevirtual

Returns the texture format specifying how the shader must interpret the data.

Implements Beatmup::GL::TextureHandler.

Definition at line 88 of file linear_mapping.h.

88 { return texFormat; }

◆ getMappingScale()

float Beatmup::GL::Vector::getMappingScale ( ) const

inline

Provides the scale factor applied to the vector values sent to GPU.

The scale factor is applied if remapping is enabled in the constructor and a fixed-point representation is used. The vector values are remapped to match the dynamics range of the fixed point representation: [gpu texture values] = a * [original values] + b

Returns: the scale factor a.

Definition at line 96 of file linear_mapping.h.

96 { return mapScale; }

◆ getMappingOffset()

float Beatmup::GL::Vector::getMappingOffset ( ) const

inline

Provides the constant offset added to the vector values sent to GPU.

The offset is added if remapping is enabled in the constructor and a fixed-point representation is used. The vector values are remapped to match the dynamics range of the fixed point representation: [gpu texture values] = a * [original values] + b

Returns: the offset value b.

Definition at line 104 of file linear_mapping.h.

104 { return mapOffset; }

Member Data Documentation

◆ context

Context& Beatmup::GL::Vector::context

private

Definition at line 40 of file linear_mapping.h.

◆ texFormat

const TextureFormat Beatmup::GL::Vector::texFormat

private

texture format of the texture handler

Definition at line 41 of file linear_mapping.h.

◆ format

const Format Beatmup::GL::Vector::format

private

data format

Definition at line 42 of file linear_mapping.h.

◆ size

const int Beatmup::GL::Vector::size

private

number of samples in the vector

Definition at line 43 of file linear_mapping.h.

◆ mapScale

float Beatmup::GL::Vector::mapScale

private

Definition at line 44 of file linear_mapping.h.

◆ mapOffset

float Beatmup::GL::Vector::mapOffset

private

Definition at line 44 of file linear_mapping.h.

◆ DEFAULT_FORMAT

const Vector::Format Vector::DEFAULT_FORMAT = Vector::Format::FLOAT

static

Definition at line 48 of file linear_mapping.h.

The documentation for this class was generated from the following files:

core/gpu/linear_mapping.h
core/gpu/linear_mapping.cpp

Public Types

Public Member Functions

Static Public Attributes

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ Format

Constructor & Destructor Documentation

◆ Vector() [1/2]

◆ Vector() [2/2]

◆ ~Vector()

Member Function Documentation

◆ prepare()

◆ fetch()

◆ getDataFormat()

◆ getSize()

◆ getMemorySize()

◆ getWidth()

◆ getHeight()

◆ getDepth()

◆ getTextureFormat()

◆ getMappingScale()

◆ getMappingOffset()

Member Data Documentation

◆ context

◆ texFormat

◆ format

◆ size

◆ mapScale

◆ mapOffset

◆ DEFAULT_FORMAT