Beatmup::GL::LinearMapping Class Reference

Evaluates expression A*x + b = y for a matrix A and vectors x and b using GPU. More...

#include <linear_mapping.h>

Inheritance diagram for Beatmup::GL::LinearMapping:

Classes
class	Matrix
	Real-valued matrix usable by GPU. More...

Public Member Functions
	LinearMapping (Context &context, bool forceFixed16=false)
	Instantiates LinearMapping. More...
	~LinearMapping ()
void	setMatrix (GraphicPipeline &gpu, const int width, const int height, const float *values)
void	setBias (GraphicPipeline &gpu, const int height, const float *values)
void	operator() (GraphicPipeline &gpu, TextureHandler &result, TextureHandler &input)

Protected Member Functions
void	prepare (GraphicPipeline &gpu, TextureHandler &output, TextureHandler &input, ProgramBank *bank=nullptr)
	Prepares the mapping for application (builds its GPU programs). More...
void	process (GraphicPipeline &gpu, TextureHandler &output, TextureHandler &input)

Private Attributes
Context &	context
Matrix *	buffer [2]
	intermediate buffers used at summation stage in a circular fashion More...
Matrix *	matrix
	the matrix ("A") More...
Vector *	bias
	optional bias vector ("b") More...
RenderingProgram *	multStage
	multiplication stage program: small pieces of the vector are multiplied by small pieces of the matrix More...
RenderingProgram *	sumStage
	summation stage program: the pieces are collected together (repeated multiple times) More...
RenderingProgram *	lastSumStage
	last summation stage program: adding bias and clamping output More...
ProgramBank *	programBank
	if not null, manages the programs More...
std::array< float, 4 >	multStageDelta
std::vector< std::array< float, SUM_STAGE_STEPS > >	sumStageDelta
Beatmup::Rectangle	multStageTexCoords
std::vector< Beatmup::Rectangle >	sumStageTexCoords
const int	leftPadding
	zero pixels added on the left side in the buffers to sum for whatever the input size is More...
const bool	forceFixed16Storage
	if true, 16 bit fixed-point storages are used even if floating point compute is supported by the GPU More...
bool	fixed16Input
	if true, the input vector x is stored using 16 bit fixed-point format (float or texture otherwise) More...
bool	fixed16Output
	if true, the output vector y is stored using 16 bit fixed-point format (float or texture otherwise) More...
bool	ready

Static Private Attributes
static const int	MULT_STAGE_STEPS = 2
	number of 4*4 blocks processed at the multiplication stage More...
static const int	SUM_STAGE_STEPS = 4
	number of vectors summed per shader at the summation stage More...

Detailed Description

Evaluates expression A*x + b = y for a matrix A and vectors x and b using GPU.

b is optional. x is of float/texture format. y might be in floating point, 16 bit fixed point or texture format.

Definition at line 114 of file linear_mapping.h.

Constructor & Destructor Documentation

LinearMapping()

LinearMapping::LinearMapping	(	Context &	context,
		bool	forceFixed16 = false
	)

Instantiates LinearMapping.

Parameters

context	A context instance
forceFixed16	Force 16 bit fixed-point storage.

Definition at line 550 of file linear_mapping.cpp.

                                                                       :
    context(context),
    buffer{ nullptr, nullptr }, matrix(nullptr), bias(nullptr),
    multStage(nullptr), sumStage(nullptr), lastSumStage(nullptr), programBank(nullptr),
    leftPadding(SUM_STAGE_STEPS), forceFixed16Storage(forceFixed16Storage), fixed16Input(false), fixed16Output(false), ready(false)
{}

~LinearMapping()

LinearMapping::~LinearMapping

(

)

Definition at line 558 of file linear_mapping.cpp.

                              {
    if (matrix) {
        matrix->invalidate(*context.getGpuRecycleBin());
        delete matrix;
    }
    if (buffer[0]) {
        buffer[0]->invalidate(*context.getGpuRecycleBin());
        delete buffer[0];
    }
    if (buffer[1]) {
        buffer[1]->invalidate(*context.getGpuRecycleBin());
        delete buffer[1];
    }
    if (!programBank)
        context.getGpuRecycleBin()->put({ multStage, sumStage, lastSumStage });
}

Member Function Documentation

prepare()

void LinearMapping::prepare ( GraphicPipeline &  gpu, TextureHandler &  output, TextureHandler &  input, ProgramBank *  bank = nullptr  )

protected

Prepares the mapping for application (builds its GPU programs).

Parameters

[in]	gpu	A GraphicPipeline instance
[in]	output	Texture handler representing the output vector y
[in]	input	Texture handler representing the output vector x
[in,out]	bank	A program bank to store the GPU programs and share with other mappings. May be null.

Definition at line 599 of file linear_mapping.cpp.

                                                                                                                  {
#ifdef BEATMUP_DEBUG
    DebugAssertion::check(input.getNumberOfChannels() == 4, "4-channel input texture handler expected");
    DebugAssertion::check(output.getNumberOfChannels() == 4, "4-channel output texture handler expected");
#endif
 
    const bool isPlainInput = (4 * input.getHeight() == matrix->getMatrixWidth());        // input samples are just r, g, b, a values in the texture
    const bool isPackedInput = (2 * input.getHeight() == matrix->getMatrixWidth());       // input samples are packed in (r, g) and (b, a) pairs
    const bool isPlainOutput = (4 * output.getHeight() == matrix->getMatrixHeight());
    const bool isPackedOutput = (2 * output.getHeight() == matrix->getMatrixHeight());
 
    InvalidArgument::check(isPlainInput || isPackedInput, "Input vector height does not match matrix width");
    InvalidArgument::check(isPlainOutput || isPackedOutput, "Output vector height does not match matrix height");
 
    if (ready && fixed16Input == isPackedInput && fixed16Output == isPackedOutput)
        // nothing to do, ready to go
        return;
 
    fixed16Input = isPackedInput;
    fixed16Output = isPackedOutput;
 
    if (!matrix)
        throw RuntimeError("No matrix");
 
    // removing old programs
    if (programBank) {
        if (multStage) programBank->release(gpu, multStage);
        if (sumStage) programBank->release(gpu, sumStage);
        if (lastSumStage) programBank->release(gpu, lastSumStage);
    }
    else {
        delete multStage;
        delete sumStage;
        delete lastSumStage;
    }
 
    // reseting state
    programBank = bank;
 
    static const unsigned int PRECISION_BOOST = 1;      // additional precision bits on intermediate stages (added to 8 fractional bits)
    const bool fixedPointStorage = useFixedPointStorage(forceFixed16Storage);
 
    // make multiplication stage program: this one multiplies small pieces of the matrix by small pieces of the input vector storing the results in a texture
    {
        String code(BEATMUP_SHADER_CODE(
            varying highp vec2 texCoord;
        ));
 
        code.printf("uniform sampler%dD %s;", VECTOR_TEXTURE_DIMS, UNIFORM_INPUT);
        code.printf("uniform sampler2D %s;", UNIFORM_MATRIX);
        code.printf("uniform highp float %s[%d];", UNIFORM_DELTA, multStageDelta.size());
        declareGlsl16bitFixedPointFunctions(code, "", fixedPointStorage, fixedPointStorage, false, 8 + PRECISION_BOOST);
        declareGlsl16bitFixedPointFunctions(code, "In", false, fixed16Input, false);
        code.nl();
        code.line("void main() {");
 
        // first block: sample the matrix
        if (!fixedPointStorage) {
            // read floating-point matrix
            code.printf("highp mat4 m = mat4("
                "texture2D(%s, texCoord),"
                "texture2D(%s, vec2(texCoord.x+%s[0], texCoord.y)),"
                "texture2D(%s, vec2(texCoord.x+%s[1], texCoord.y)),"
                "texture2D(%s, vec2(texCoord.x+%s[2], texCoord.y)));",
                UNIFORM_MATRIX,
                UNIFORM_MATRIX, UNIFORM_DELTA,
                UNIFORM_MATRIX, UNIFORM_DELTA,
                UNIFORM_MATRIX, UNIFORM_DELTA
            );
        }
        else {
            // read fixed-point packed matrix
            code.printf("highp vec4 m1 = unpack(texture2D(%s, texCoord), texture2D(%s, vec2(texCoord.x+%s[0], texCoord.y)));",
                UNIFORM_MATRIX, UNIFORM_MATRIX, UNIFORM_DELTA);
            code.printf("highp vec4 m2 = unpack(texture2D(%s, vec2(texCoord.x+%s[1], texCoord.y)), texture2D(%s, vec2(texCoord.x+%s[2], texCoord.y)));",
                UNIFORM_MATRIX, UNIFORM_DELTA, UNIFORM_MATRIX, UNIFORM_DELTA);
            code.printf("m1 = (m1 - %0.8f) * %0.8f;", matrix->getOffset(), 1 / matrix->getScale());
            code.printf("m2 = (m2 - %0.8f) * %0.8f;", matrix->getOffset(), 1 / matrix->getScale());
        }
 
        // sample the vector
        if (fixed16Input) {
            sampleVectorComponent(code, "lowp vec4", "vp1", UNIFORM_INPUT, "texCoord.x");
            sampleVectorComponent(code, "lowp vec4", "vp2", UNIFORM_INPUT, "texCoord.x", 1);
            // need to de-multiplex components: LMLM+LMLM to LLLL+MMMM
            code("highp vec4 v = unpackIn(vec4(vp1.xz, vp2.xz), vec4(vp1.yw, vp2.yw));");
        }
        else {
            sampleVectorComponent(code, "highp vec4", "v", UNIFORM_INPUT, "texCoord.x");
        }
 
        // compute the result
        if (fixedPointStorage)
            code.line("highp vec2 r = vec2(dot(m1, v), dot(m2, v));");
        else
            code.line("highp vec4 r = m * v;");
 
        // further blocks
        for (int blockIdx = 1; blockIdx < MULT_STAGE_STEPS; ++blockIdx) {
            // advance the texture coord
            if (blockIdx == 1)
                code.printf("highp float x = texCoord.x + %s[3];", UNIFORM_DELTA);
            else {
                code.printf("x += %s[3];", UNIFORM_DELTA);
            }
 
            // sample the matrix
            if (!fixedPointStorage)
                // read floating-point matrix
                code.printf("m = mat4("
                    "texture2D(%s, vec2(x, texCoord.y)),"
                    "texture2D(%s, vec2(x+%s[0], texCoord.y)),"
                    "texture2D(%s, vec2(x+%s[1], texCoord.y)),"
                    "texture2D(%s, vec2(x+%s[2], texCoord.y)));",
                    UNIFORM_MATRIX,
                    UNIFORM_MATRIX, UNIFORM_DELTA,
                    UNIFORM_MATRIX, UNIFORM_DELTA,
                    UNIFORM_MATRIX, UNIFORM_DELTA
                );
            else {
                // read fixed-point packed matrix
                code.printf("m1 = unpack(texture2D(%s, vec2(x, texCoord.y)), texture2D(%s, vec2(x+%s[0], texCoord.y)));",
                    UNIFORM_MATRIX, UNIFORM_MATRIX, UNIFORM_DELTA);
                code.printf("m2 = unpack(texture2D(%s, vec2(x+%s[1], texCoord.y)), texture2D(%s, vec2(x+%s[2], texCoord.y)));",
                    UNIFORM_MATRIX, UNIFORM_DELTA, UNIFORM_MATRIX, UNIFORM_DELTA);
                code.printf("m1 = (m1 - %0.8f) * %0.8f;", matrix->getOffset(), 1 / matrix->getScale());
                code.printf("m2 = (m2 - %0.8f) * %0.8f;", matrix->getOffset(), 1 / matrix->getScale());
            }
 
            // sample the vector
            if (fixed16Input) {
                sampleVectorComponent(code, "", "vp1", UNIFORM_INPUT, "x");
                sampleVectorComponent(code, "", "vp2", UNIFORM_INPUT, "x", 1);
                // need to demultiplex components: LMLM+LMLM to LLLL+MMMM
                code("v = unpackIn(vec4(vp1.xz, vp2.xz), vec4(vp1.yw, vp2.yw));");
            }
            else {
                sampleVectorComponent(code, "", "v", UNIFORM_INPUT, "x");
            }
 
            // compute the result
            if (fixedPointStorage)
                code.line("r += vec2(dot(m1, v), dot(m2, v));");
            else
                code.line("r += m * v;");
        }
 
        // store the result
        if (fixedPointStorage)
            code("gl_FragColor = vec4(pack(r.x), pack(r.y));");
        else
            code.line("gl_FragColor = r;");
 
        code("}");
 
        if (bank)
            multStage = (*bank)(gpu, code);
        else
            multStage = new RenderingProgram(gpu, FragmentShader(gpu, code, Extensions::BEATMUP_DIALECT));
    }
 
    // set up an intermediate buffer
    delete buffer[0];
    buffer[0] = new Matrix(gpu, matrix->getMatrixWidth() / (4 * MULT_STAGE_STEPS) + leftPadding, matrix->getMatrixHeight(), !fixedPointStorage);
 
    // compute multiplication stage delta and texture coordinates
    for (size_t i = 0; i < multStageDelta.size(); ++i)
        multStageDelta[i] = (float)(i + 1) / matrix->getWidth();
 
    multStageTexCoords = gpu.getTextureCoordinates(
        Rectangle(0, 0, matrix->getWidth() - 4 * MULT_STAGE_STEPS, matrix->getHeight() - 1),
        IntPoint(matrix->getWidth(), matrix->getHeight()),
        IntPoint(buffer[0]->getWidth() - leftPadding, buffer[0]->getHeight())
    );
 
    // determine the number of summation iterations
    sumStageDelta.clear();
    sumStageTexCoords.clear();
    bool isLastIteration = false;
    int outBufWidth = buffer[0]->getWidth() - leftPadding;
    const int bufHeightPix = buffer[0]->getHeight();
    while (!isLastIteration) {
        const int iterNum = (int)sumStageDelta.size();
        const int inBufIdx = iterNum % 2;       // intermediate buffer index being read at the current iteration
 
        // update meaningful output width
        const int inBufWidth = outBufWidth;
        outBufWidth = ceili(outBufWidth, SUM_STAGE_STEPS);
        isLastIteration = (outBufWidth == 1);
#ifdef BEATMUP_DEBUG
        DebugAssertion::check(outBufWidth > 0, "non-positive outBufWidth");
#endif
 
        // setup second intermediate buffer if not yet
        if (iterNum == 0 && !isLastIteration) {
            delete buffer[1];
            buffer[1] = new Matrix(gpu, outBufWidth + leftPadding, matrix->getMatrixHeight(), !fixedPointStorage);
        }
 
        // compute deltas
        sumStageDelta.push_back({});
        auto& deltas = sumStageDelta.back();
        for (size_t i = 0; i < deltas.size(); ++i)
            deltas[i] = (float)i / buffer[inBufIdx]->getWidth();
 
        // compute texture coords
        const int rem = inBufWidth - outBufWidth * SUM_STAGE_STEPS;
        const int ySamplesNum = (isLastIteration && fixedPointStorage && !fixed16Output) ? 2 : 1;
            // number of samples along Y dimension
 
        sumStageTexCoords.emplace_back(gpu.getTextureCoordinates(
            Rectangle(leftPadding + rem, 0, leftPadding + inBufWidth - SUM_STAGE_STEPS, bufHeightPix - ySamplesNum),
            IntPoint(buffer[inBufIdx]->getWidth(), bufHeightPix),
            IntPoint(outBufWidth, bufHeightPix / ySamplesNum)
        ));
 
        // deltas[0] is not used; use it here to pass y step
        deltas[0] = 1.0f / buffer[inBufIdx]->getHeight();
    }
 
    // make summation stage program
    {
        String code(BEATMUP_SHADER_CODE(
            varying highp vec2 texCoord;
        ));
 
        code.printf("uniform sampler2D %s;", UNIFORM_MATRIX);
        code.printf("uniform highp float %s[%d];", UNIFORM_DELTA, sumStageDelta[0].size());
        declareGlsl16bitFixedPointFunctions(code, "", fixedPointStorage, false, fixedPointStorage, 8 + PRECISION_BOOST, 8 + PRECISION_BOOST);
        code.nl();
        code.line("void main() {");
        if (!fixedPointStorage) {
            code("gl_FragColor = ");
            for (size_t i = 0; i < sumStageDelta[0].size(); ++i)
                if (i > 0)
                    code.printf(" + texture2D(%s, vec2(texCoord.x + %s[%u], texCoord.y))", UNIFORM_MATRIX, UNIFORM_DELTA, i);
                else
                    code.printf("texture2D(%s, texCoord)", UNIFORM_MATRIX);
            code.line(";");
        }
        else {
            for (size_t i = 0; i < sumStageDelta[0].size(); ++i) {
                if (i == 0) {
                    code.printf("lowp vec4 i = texture2D(%s, texCoord);", UNIFORM_MATRIX);
                    code.printf("highp vec2 s = ");
                }
                else {
                    code.printf("i = texture2D(%s, vec2(texCoord.x + %s[%u], texCoord.y));", UNIFORM_MATRIX, UNIFORM_DELTA, i);
                    code("s += ");
                }
                code("vec2(unpack(i[0], i[1]), unpack(i[2], i[3]));");
            }
            code("gl_FragColor = vec4(pack(s.x), pack(s.y));");
        }
        code("}");
 
        if (bank)
            sumStage = (*bank)(gpu, code);
        else
            sumStage = new RenderingProgram(gpu, FragmentShader(gpu, code, Extensions::BEATMUP_DIALECT));
    }
 
    // make last iteration summation stage program if needed
    if (fixedPointStorage || bias) {
        String code(BEATMUP_SHADER_CODE(
            varying highp vec2 texCoord;
        ));
 
        code.printf("uniform sampler2D %s;", UNIFORM_MATRIX);
        if (bias)
            code.printf("uniform sampler%dD %s;", VECTOR_TEXTURE_DIMS, UNIFORM_BIAS);
        code.printf("uniform highp float %s[%d];", UNIFORM_DELTA, sumStageDelta[0].size());
 
        // declare packing/unpacking routines
        declareGlsl16bitFixedPointFunctions(code, "", fixed16Output, false, true, 8, 8 + PRECISION_BOOST);
        if (bias)
            declareGlsl16bitFixedPointFunctions(code, "Bias", false, false, true);
 
        code.line("void main() {");
        if (bias)
            code.line("highp vec2 b;");
 
        // floating point case first
        if (!fixedPointStorage) {
            if (fixed16Output)
                throw ImplementationUnsupported("16 bit fixed point output is not supported in floating point computing mode");
 
            code("gl_FragColor = ");
            for (size_t i = 0; i < sumStageDelta[0].size(); ++i)
                if (i > 0)
                    code.printf(" + texture2D(%s, vec2(texCoord.x + %s[%u], texCoord.y))", UNIFORM_MATRIX, UNIFORM_DELTA, i);
                else
                    code.printf("texture2D(%s, texCoord)", UNIFORM_MATRIX);
 
            if (bias) {
                code.printf(" + texture%dD(%s, vec%d(", VECTOR_TEXTURE_DIMS, UNIFORM_BIAS, VECTOR_TEXTURE_DIMS);
                for (int i = 0; i < VECTOR_TEXTURE_DIMS; ++i) {
                    if (i > 0)
                        code(",");
                    code(i == VECTOR_MAIN_DIM ? "texCoord.y" : "0");
                }
                code("))");
            }
        }
 
        else {
            for (size_t i = 0; i < sumStageDelta[0].size(); ++i) {
                // sample input
                if (i == 0) {
                    code.printf("lowp vec4 i = texture2D(%s, texCoord);", UNIFORM_MATRIX);
                    if (!fixed16Output)
                        code.printf("lowp vec4 i2 = texture2D(%s, vec2(texCoord.x, texCoord.y + %s[0]));", UNIFORM_MATRIX, UNIFORM_DELTA);
                }
                else {
                    code.printf("i = texture2D(%s, vec2(texCoord.x + %s[%u], texCoord.y));", UNIFORM_MATRIX, UNIFORM_DELTA, i);
                    if (!fixed16Output)
                        code.printf("i2 = texture2D(%s, vec2(texCoord.x + %s[%u], texCoord.y + %s[0]));", UNIFORM_MATRIX, UNIFORM_DELTA, i, UNIFORM_DELTA);
                }
 
                // sum up
                code(i == 0 ? "highp vec2 s = " : "s += ");
                code.line("vec2(unpack(i[0], i[1]), unpack(i[2], i[3]));");
                if (!fixed16Output) {
                    code(i == 0 ? "highp vec2 s2 = " : "s2 += ");
                    code.line("vec2(unpack(i2[0], i2[1]), unpack(i2[2], i2[3]));");
                }
            }
 
            // add bias
            if (bias) {
                sampleVectorComponent(code, "", "i", UNIFORM_BIAS, "texCoord.y");
                if (!fixed16Output)
                    sampleVectorComponent(code, "", "i2", UNIFORM_BIAS, "texCoord.y", 0);
 
                code.line("b = vec2(unpackBias(i[0], i[1]), unpackBias(i[2], i[3]));");
                if (bias->getMappingScale() != 1 || bias->getMappingOffset() != 0)
                    code.printf("b = %0.8f * (b - %0.8f);", 1 / bias->getMappingScale(), bias->getMappingOffset());
                code.line("s += b;");
 
                if (!fixed16Output) {
                    code.line("b = vec2(unpackBias(i2[0], i2[1]), unpackBias(i2[2], i2[3]));");
                    if (bias->getMappingScale() != 1 || bias->getMappingOffset() != 0)
                        code.printf("b = %0.8f * (b - %0.8f);", 1 / bias->getMappingScale(), bias->getMappingOffset());
                    code.line("s2 += b;");
                }
            }
 
            code("gl_FragColor = ");
            if (fixed16Output)
                code("vec4(pack(s.x), pack(s.y))");
            else
                code("vec4(s, s2)");
        }
 
        code.line(";");
        code("}");
 
        if (bank)
            lastSumStage = (*bank)(gpu, code);
        else
            lastSumStage = new RenderingProgram(gpu, FragmentShader(gpu, code, Extensions::BEATMUP_DIALECT));
    }
    else
        lastSumStage = nullptr;
 
    ready = true;
}

process()

void LinearMapping::process ( GraphicPipeline &  gpu, TextureHandler &  output, TextureHandler &  input  )

protected

Definition at line 968 of file linear_mapping.cpp.

                                                                                               {
    static const int MATRIX_UNIT = 1, INPUT_UNIT = 2, BIAS_UNIT = 3;
 
    // first stage: compute small 4*4 matrix-by-vector products
    multStage->enable(gpu);
    gpu.bindOutput(*buffer[0]);
 
    int outBufWidth = buffer[0]->getWidth() - leftPadding;
    glViewport(leftPadding, 0, outBufWidth, buffer[0]->getHeight());
 
    matrix->bind(gpu, MATRIX_UNIT);
    multStage->setInteger(UNIFORM_MATRIX, MATRIX_UNIT);
 
    gpu.bind(input, INPUT_UNIT, TextureParam::INTERP_NEAREST);
    multStage->setInteger(UNIFORM_INPUT, INPUT_UNIT);
 
    multStage->setFloatArray(UNIFORM_DELTA, multStageDelta.data(), multStageDelta.size());
    gpu.setTextureCoordinates(multStageTexCoords);
    multStage->blend();
 
    // stage 2: sum them up
    sumStage->enable(gpu);
    sumStage->setInteger(UNIFORM_MATRIX, MATRIX_UNIT);
    for (size_t i = 0; i + 1 < sumStageTexCoords.size(); ++i) {
        gpu.bindOutput(*buffer[(i + 1) % 2]);
        outBufWidth = ceili(outBufWidth, SUM_STAGE_STEPS);
        glViewport(leftPadding, 0, outBufWidth, buffer[0]->getHeight());
 
        buffer[i % 2]->bind(gpu, MATRIX_UNIT);
        sumStage->setFloatArray(UNIFORM_DELTA, sumStageDelta[i].data(), sumStageDelta[i].size());
        gpu.setTextureCoordinates(sumStageTexCoords[i]);
        sumStage->blend();
    }
 
    // stage 2, last iteration
    RenderingProgram* lastProgram = lastSumStage ? lastSumStage : sumStage;
    if (lastProgram != sumStage) {
        lastProgram->enable(gpu);
        lastProgram->setInteger(UNIFORM_MATRIX, MATRIX_UNIT);
    }
    gpu.bindOutput(output);
    glViewport(0, 0, output.getWidth(), output.getHeight());
 
    buffer[(sumStageTexCoords.size() - 1) % 2]->bind(gpu, MATRIX_UNIT);
    if (bias) {
        lastProgram->setInteger(UNIFORM_BIAS, BIAS_UNIT);
        gpu.bind(*bias, BIAS_UNIT, TextureParam::INTERP_NEAREST);
    }
 
    lastProgram->setFloatArray(UNIFORM_DELTA, sumStageDelta.back().data(), sumStageDelta.back().size());
    gpu.setTextureCoordinates(sumStageTexCoords.back());
    lastProgram->blend();
}

setMatrix()

void LinearMapping::setMatrix	(	GraphicPipeline &	gpu,
		const int	width,
		const int	height,
		const float *	values
	)

Definition at line 576 of file linear_mapping.cpp.

                                                                                                          {
    if (bias)
        RuntimeError::check(bias->getSize() == height, "Matrix height does not match bias vector length");
    RuntimeError::check(width % (4 * MULT_STAGE_STEPS) == 0, "Matrix width is not a multiple of " + std::to_string(4 * MULT_STAGE_STEPS));
    if (matrix) {
        matrix->invalidate(*context.getGpuRecycleBin());
        delete matrix;
    }
    matrix = new Matrix(gpu, width, height, values, !useFixedPointStorage(forceFixed16Storage));
    ready = false;
}

setBias()

void LinearMapping::setBias	(	GraphicPipeline &	gpu,
		const int	height,
		const float *	values
	)

Definition at line 589 of file linear_mapping.cpp.

                                                                                       {
    if (matrix)
        RuntimeError::check(height == matrix->getMatrixHeight(), "Matrix height does not match bias vector length.");
    if (bias)
        delete bias;
    bias = new Vector(context, gpu, height, useFixedPointStorage(forceFixed16Storage) ? Vector::Format::FIXED16 : Vector::Format::FLOAT, values, true);
    ready = false;
}

operator()()

void LinearMapping::operator()	(	GraphicPipeline &	gpu,
		TextureHandler &	result,
		TextureHandler &	input
	)

Definition at line 1023 of file linear_mapping.cpp.

                                                                                                  {
    gpu.switchMode(GraphicPipeline::Mode::INFERENCE);
    prepare(gpu, output, input);
    process(gpu, output, input);
}

Member Data Documentation

MULT_STAGE_STEPS

const int Beatmup::GL::LinearMapping::MULT_STAGE_STEPS = 2

staticprivate

number of 4*4 blocks processed at the multiplication stage

Definition at line 116 of file linear_mapping.h.

SUM_STAGE_STEPS

const int Beatmup::GL::LinearMapping::SUM_STAGE_STEPS = 4

staticprivate

number of vectors summed per shader at the summation stage

Definition at line 117 of file linear_mapping.h.

context

Context& Beatmup::GL::LinearMapping::context

private

Definition at line 120 of file linear_mapping.h.

buffer

Matrix* Beatmup::GL::LinearMapping::buffer[2]

private

intermediate buffers used at summation stage in a circular fashion

Definition at line 121 of file linear_mapping.h.

matrix

Matrix* Beatmup::GL::LinearMapping::matrix

private

the matrix ("A")

Definition at line 122 of file linear_mapping.h.

bias

Vector* Beatmup::GL::LinearMapping::bias

private

optional bias vector ("b")

Definition at line 123 of file linear_mapping.h.

multStage

RenderingProgram* Beatmup::GL::LinearMapping::multStage

private

multiplication stage program: small pieces of the vector are multiplied by small pieces of the matrix

Definition at line 124 of file linear_mapping.h.

sumStage

RenderingProgram* Beatmup::GL::LinearMapping::sumStage

private

summation stage program: the pieces are collected together (repeated multiple times)

Definition at line 125 of file linear_mapping.h.

lastSumStage

RenderingProgram* Beatmup::GL::LinearMapping::lastSumStage

private

last summation stage program: adding bias and clamping output

Definition at line 126 of file linear_mapping.h.

programBank

ProgramBank* Beatmup::GL::LinearMapping::programBank

private

if not null, manages the programs

Definition at line 127 of file linear_mapping.h.

multStageDelta

std::array<float, 4> Beatmup::GL::LinearMapping::multStageDelta

private

Definition at line 128 of file linear_mapping.h.

sumStageDelta

std::vector<std::array<float, SUM_STAGE_STEPS> > Beatmup::GL::LinearMapping::sumStageDelta

private

Definition at line 129 of file linear_mapping.h.

multStageTexCoords

Beatmup::Rectangle Beatmup::GL::LinearMapping::multStageTexCoords

private

Definition at line 130 of file linear_mapping.h.

sumStageTexCoords

std::vector<Beatmup::Rectangle> Beatmup::GL::LinearMapping::sumStageTexCoords

private

Definition at line 131 of file linear_mapping.h.

leftPadding

const int Beatmup::GL::LinearMapping::leftPadding

private

zero pixels added on the left side in the buffers to sum for whatever the input size is

Definition at line 132 of file linear_mapping.h.

forceFixed16Storage

const bool Beatmup::GL::LinearMapping::forceFixed16Storage

private

if true, 16 bit fixed-point storages are used even if floating point compute is supported by the GPU

Definition at line 133 of file linear_mapping.h.

fixed16Input

bool Beatmup::GL::LinearMapping::fixed16Input

private

if true, the input vector x is stored using 16 bit fixed-point format (float or texture otherwise)

Definition at line 134 of file linear_mapping.h.

fixed16Output

bool Beatmup::GL::LinearMapping::fixed16Output

private

if true, the output vector y is stored using 16 bit fixed-point format (float or texture otherwise)

Definition at line 135 of file linear_mapping.h.

ready

bool Beatmup::GL::LinearMapping::ready

private

Definition at line 136 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