linear_mapping.cpp File Reference

#include "linear_mapping.h"
#include "../utils/fixed_point.h"
#include "../utils/string_builder.h"
#include "../gpu/bgl.h"
#include <cstring>

Go to the source code of this file.

Classes
class	Beatmup::GL::LinearMapping::Matrix
	Real-valued matrix usable by GPU. More...

Functions
static bool	useFixedPointStorage (bool forceFixed16Storage)
void	sampleVectorComponent (String &code, const char *declaration, const char *variable, const char *uniform, const char *coordinate, int delta=-1)
static void	declareGlsl16bitFixedPointFunctions (StringBuilder &code, const char *suffix, bool pack, bool unpackVec, bool unpackScalar, unsigned int packPrecision=8, unsigned int unpackPrecision=8)
	Generates GLSL code of float to 16-bit fixed point packing/unpacking functions. More...
static float	unpackFloatFrom16bit (const uint8_t lsb, const int msb)
	Converts 16-bit fixed-point number into a floating point number. More...
static void	packFloatTo16bit (const float value, uint8_t &lsb, uint8_t &msb)
	Packs a floating point value into a 16-bit fixed-point value. More...
static void	findMinMax (const float *values, const int count, float &minVal, float &maxVal)

Variables
static const char *	UNIFORM_MATRIX = "mtrx"
static const char *	UNIFORM_INPUT = "inp"
static const char *	UNIFORM_BIAS = "bias"
static const char *	UNIFORM_DELTA = "dt"
static const int	VECTOR_TEXTURE_DIMS = 2
static const int	VECTOR_MAIN_DIM = 1

Function Documentation

useFixedPointStorage()

static bool useFixedPointStorage ( bool  forceFixed16Storage )

inlinestatic

Definition at line 44 of file linear_mapping.cpp.

                                                                  {
#ifdef BEATMUP_OPENGLVERSION_GLES20
    return true;
#else
    return forceFixed16Storage;
#endif
}

sampleVectorComponent()

void sampleVectorComponent	(	String &	code,
		const char *	declaration,
		const char *	variable,
		const char *	uniform,
		const char *	coordinate,
		int	delta = -1
	)

Definition at line 62 of file linear_mapping.cpp.

                                                                                                                                                     {
    code.printf("%s %s = texture%dD(%s, vec%d(", declaration, variable, VECTOR_TEXTURE_DIMS, uniform, VECTOR_TEXTURE_DIMS);
    for (int i = 0; i < VECTOR_TEXTURE_DIMS; ++i) {
        if (i > 0)
            code(",");
        if (i == VECTOR_MAIN_DIM) {
            if (delta >= 0) {
                code.printf("%s + %s[%d]", coordinate, UNIFORM_DELTA, delta);
            }
            else {
                code(coordinate);
            }
        }
        else
            code("0");
    }
    code.line("));");
}

declareGlsl16bitFixedPointFunctions()

static void declareGlsl16bitFixedPointFunctions ( StringBuilder &  code, const char *  suffix, bool  pack, bool  unpackVec, bool  unpackScalar, unsigned int  packPrecision = 8, unsigned int  unpackPrecision = 8  )

inlinestatic

Generates GLSL code of float to 16-bit fixed point packing/unpacking functions.

Parameters

[in,out]	code	String builder containing the shader source code
[in]	suffix	A suffix to add to the function names
[in]	pack	If true, the packing function code is added
[in]	unpackVec	If true, the vector unpacking function code is added (producing a vec4 from two vec4)
[in]	unpackScalar	If true, the scalar unpacking function code is added (producing a float from two floats)
[in]	packPrecision	Number of bits storing the fractional part in the resulting packed value
[in]	unpackPrecision	Number of bits storing the fractional part in the input value to unpack

Definition at line 92 of file linear_mapping.cpp.

                                                                                                                                                                                                                {
    if (pack) {
        code.printf("lowp vec2 pack%s(highp float v) {", suffix);
        if (packPrecision != 8)
            code.printf("v *= %0.1f;", packPrecision > 8 ? (float)(1 << (packPrecision - 8)) : 1.0f / (1 << (packPrecision - 8)));
        code.line(
            "  return vec2((256.0 / 255.0) * fract(v), (1.0 / 255.0) * floor(v) + (128.0 / 255.0));"
            "}"
        );
    }
    const float
        scaleMsb = unpackPrecision > 8 ? 1.0f / (1 << (unpackPrecision - 8)) : (float)(1 << (unpackPrecision - 8)),
        scaleLsb = 255.0f * scaleMsb;
    if (unpackVec)
        code.printf(
            "highp vec4 unpack%s(lowp vec4 lsb, lowp vec4 msb) {"
            "  return lsb * (%0.5f / 256.0) + floor(255.0 * msb - 127.5) * %0.5f;"
            "}",
            suffix, scaleLsb, scaleMsb
        );
    if (unpackScalar)
        code.printf(
            "highp float unpack%s(lowp float lsb, lowp float msb) {"
            "  return lsb * (%0.5f / 256.0) + floor(255.0 * msb - 127.5) * %0.5f;"
            "}",
            suffix, scaleLsb, scaleMsb
        );
}

unpackFloatFrom16bit()

static float unpackFloatFrom16bit ( const uint8_t  lsb, const int  msb  )

inlinestatic

Converts 16-bit fixed-point number into a floating point number.

Parameters

[in]	lsb	The least significant byte of the input fixed-point value
[in]	msb	The most significant byte of the input fixed-point value

Returns

the floating-point value.

Definition at line 128 of file linear_mapping.cpp.

                                                                           {
    return (float)Fixed16<8>::interpret( ((msb - 128) << 8) + lsb );
}

packFloatTo16bit()

static void packFloatTo16bit ( const float  value, uint8_t &  lsb, uint8_t &  msb  )

inlinestatic

Packs a floating point value into a 16-bit fixed-point value.

The resulting representation matches the formulas in unpackFloatFrom16bit(..) and packFloatTo16bit(..) A biased clamping-friendly formulation is used: "0.0" on input produces the most significant channel value of "0.5".

Parameters

[in]	value	The input value to pack
[in]	lsb	The least significant byte in the output fixed-point value
[in]	msb	The most significant byte in the output fixed-point value

Definition at line 141 of file linear_mapping.cpp.

                                                                                   {
    union {
        Fixed16<8> val;
        uint16_t bytes;
    } ptr{ value };
    lsb = ptr.bytes & 0xff;
    msb = (ptr.bytes >> 8) + 128;
}

findMinMax()

static void findMinMax ( const float *  values, const int  count, float &  minVal, float &  maxVal  )

inlinestatic

Definition at line 151 of file linear_mapping.cpp.

                                                                                                  {
    minVal = maxVal = values[0];
    for (int i = 1; i < count; ++i) {
        minVal = std::min(minVal, values[i]);
        maxVal = std::max(maxVal, values[i]);
    }
}

Variable Documentation

UNIFORM_MATRIX

const char* UNIFORM_MATRIX = "mtrx"

static

Definition at line 34 of file linear_mapping.cpp.

UNIFORM_INPUT

const char* UNIFORM_INPUT = "inp"

static

Definition at line 35 of file linear_mapping.cpp.

UNIFORM_BIAS

const char* UNIFORM_BIAS = "bias"

static

Definition at line 36 of file linear_mapping.cpp.

UNIFORM_DELTA

const char* UNIFORM_DELTA = "dt"

static

Definition at line 37 of file linear_mapping.cpp.

VECTOR_TEXTURE_DIMS

const int VECTOR_TEXTURE_DIMS = 2

static

Definition at line 40 of file linear_mapping.cpp.

VECTOR_MAIN_DIM

const int VECTOR_MAIN_DIM = 1

static

Definition at line 41 of file linear_mapping.cpp.