src/sksl/SkSLSampleMatrix.h

/*
 * Copyright 2020 Google LLC
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

#ifndef SkSLSampleMatrix_DEFINED
#define SkSLSampleMatrix_DEFINED

#include "src/sksl/SkSLDefines.h"
#include "src/sksl/SkSLString.h"

class GrFragmentProcessor;

namespace SkSL {

struct Expression;
struct Program;
struct Variable;

/**
 * Represents the matrix applied to a fragment processor by its parent's sample(child, matrix) call.
 */
struct SampleMatrix {
    enum class Kind {
        // No sample(child, matrix) call affects the FP.
        kNone,
        // The FP is sampled with a matrix whose value is fixed and based only on constants or
        // uniforms, and thus the transform can be hoisted to the vertex shader (assuming that
        // its parent can also be hoisted, i.e. not sampled explicitly).
        kConstantOrUniform,
        // The FP is sampled with a non-constant/uniform value, or sampled multiple times, and
        // thus the transform cannot be hoisted to the vertex shader.
        kVariable,
        // The FP is sampled with a constant or uniform value, *and* also inherits a variable
        // transform from an ancestor. The transform cannot be hoisted to the vertex shader, and
        // both matrices need to be applied.
        kMixed,
    };

    // Make a SampleMatrix with kNone for its kind. Will not have an expression or have perspective.
    SampleMatrix()
            : fOwner(nullptr)
            , fKind(Kind::kNone) {}

    static SampleMatrix MakeConstUniform(String expression) {
        return SampleMatrix(Kind::kConstantOrUniform, expression);
    }

    static SampleMatrix MakeVariable() {
        return SampleMatrix(Kind::kVariable, "");
    }

    static SampleMatrix Make(const Program& program, const Variable& fp);

    SampleMatrix merge(const SampleMatrix& other);

    bool operator==(const SampleMatrix& other) const {
        return fKind == other.fKind && fExpression == other.fExpression && fOwner == other.fOwner;
    }

#ifdef SK_DEBUG
    String description() {
        switch (fKind) {
            case Kind::kNone:
                return "SampleMatrix<None>";
            case Kind::kConstantOrUniform:
                return "SampleMatrix<ConstantOrUniform(" + fExpression + ")>";
            case Kind::kVariable:
                return "SampleMatrix<Variable>";
            case Kind::kMixed:
                return "SampleMatrix<Mixed(" + fExpression + ")>";
        }
    }
#endif

    // TODO(michaelludwig): fOwner and fBase are going away; owner is filled in automatically when
    // a matrix-sampled FP is registered as a child.
    GrFragmentProcessor* fOwner;
    Kind fKind;
    // The constant or uniform expression representing the matrix (will be the empty string when
    // kind == kNone or kVariable)
    String fExpression;
    const GrFragmentProcessor* fBase = nullptr;

private:
    SampleMatrix(Kind kind, String expression)
            : fOwner(nullptr)
            , fKind(kind)
            , fExpression(expression) {}
};

} // namespace

#endif