SkSL::GLSLCodeGenerator Class Reference

Inheritance diagram for SkSL::GLSLCodeGenerator:

Public Member Functions
	GLSLCodeGenerator (const Context *context, const ShaderCaps *caps, const Program *program, OutputStream *out)
bool	generateCode () override
Public Member Functions inherited from SkSL::CodeGenerator
	CodeGenerator (const Context *context, const ShaderCaps *caps, const Program *program, OutputStream *stream)
virtual	~CodeGenerator ()=default
OutputStream *	outputStream ()
void	setOutputStream (OutputStream *output)

Protected Types
using	Precedence = OperatorPrecedence
using	INHERITED = CodeGenerator

Protected Member Functions
void	write (std::string_view s)
void	writeLine (std::string_view s=std::string_view())
void	finishLine ()
void	writeHeader ()
bool	usesPrecisionModifiers () const
void	writeIdentifier (std::string_view identifier)
std::string	getTypeName (const Type &type)
void	writeStructDefinition (const StructDefinition &s)
void	writeType (const Type &type)
void	writeExtension (std::string_view name, bool require=true)
void	writeInterfaceBlock (const InterfaceBlock &intf)
void	writeFunctionDeclaration (const FunctionDeclaration &f)
void	writeFunctionPrototype (const FunctionPrototype &f)
void	writeFunction (const FunctionDefinition &f)
void	writeLayout (const Layout &layout)
void	writeModifiers (const Layout &layout, ModifierFlags flags, bool globalContext)
void	writeInputVars ()
void	writeVarInitializer (const Variable &var, const Expression &value)
const char *	getTypePrecision (const Type &type)
void	writeTypePrecision (const Type &type)
void	writeGlobalVarDeclaration (const GlobalVarDeclaration &e)
void	writeVarDeclaration (const VarDeclaration &var, bool global)
void	writeFragCoord ()
void	writeVariableReference (const VariableReference &ref)
void	writeExpression (const Expression &expr, Precedence parentPrecedence)
void	writeIntrinsicCall (const FunctionCall &c)
void	writeMinAbsHack (Expression &absExpr, Expression &otherExpr)
void	writeDeterminantHack (const Expression &mat)
void	writeInverseHack (const Expression &mat)
void	writeTransposeHack (const Expression &mat)
void	writeInverseSqrtHack (const Expression &x)
void	writeMatrixComparisonWorkaround (const BinaryExpression &x)
void	writeFunctionCall (const FunctionCall &c)
void	writeConstructorCompound (const ConstructorCompound &c, Precedence parentPrecedence)
void	writeConstructorDiagonalMatrix (const ConstructorDiagonalMatrix &c, Precedence parentPrecedence)
void	writeAnyConstructor (const AnyConstructor &c, Precedence parentPrecedence)
void	writeCastConstructor (const AnyConstructor &c, Precedence parentPrecedence)
void	writeFieldAccess (const FieldAccess &f)
void	writeSwizzle (const Swizzle &swizzle)
void	writeBinaryExpression (const BinaryExpression &b, Precedence parentPrecedence)
void	writeShortCircuitWorkaroundExpression (const BinaryExpression &b, Precedence parentPrecedence)
void	writeTernaryExpression (const TernaryExpression &t, Precedence parentPrecedence)
void	writeIndexExpression (const IndexExpression &expr)
void	writePrefixExpression (const PrefixExpression &p, Precedence parentPrecedence)
void	writePostfixExpression (const PostfixExpression &p, Precedence parentPrecedence)
void	writeLiteral (const Literal &l)
void	writeStatement (const Statement &s)
void	writeBlock (const Block &b)
void	writeIfStatement (const IfStatement &stmt)
void	writeForStatement (const ForStatement &f)
void	writeDoStatement (const DoStatement &d)
void	writeExpressionStatement (const ExpressionStatement &s)
void	writeSwitchStatement (const SwitchStatement &s)
void	writeReturnStatement (const ReturnStatement &r)
void	writeProgramElement (const ProgramElement &e)
bool	shouldRewriteVoidTypedFunctions (const FunctionDeclaration *func) const

Protected Attributes
StringStream	fExtensions
StringStream	fGlobals
StringStream	fExtraFunctions
std::string	fFunctionHeader
int	fVarCount = 0
int	fIndentation = 0
bool	fAtLineStart = false
const FunctionDeclaration *	fCurrentFunction = nullptr
bool	fFoundDerivatives = false
bool	fFoundExternalSamplerDecl = false
bool	fFoundRectSamplerDecl = false
bool	fSetupClockwise = false
bool	fSetupFragPosition = false
bool	fSetupFragCoordWorkaround = false
bool	fWrittenAbsEmulation = false
bool	fWrittenDeterminant2 = false
bool	fWrittenDeterminant3 = false
bool	fWrittenDeterminant4 = false
bool	fWrittenInverse2 = false
bool	fWrittenInverse3 = false
bool	fWrittenInverse4 = false
bool	fWrittenTranspose [3][3] = {}
Protected Attributes inherited from SkSL::CodeGenerator
const Program &	fProgram
Context	fContext
const ShaderCaps &	fCaps
OutputStream *	fOut

Additional Inherited Members
Static Protected Attributes inherited from SkSL::CodeGenerator
static constexpr float	kSharpenTexturesBias = -.475f

Detailed Description

Definition at line 82 of file SkSLGLSLCodeGenerator.cpp.

Member Typedef Documentation

INHERITED

using SkSL::GLSLCodeGenerator::INHERITED = CodeGenerator

protected

Definition at line 232 of file SkSLGLSLCodeGenerator.cpp.

Precedence

using SkSL::GLSLCodeGenerator::Precedence = OperatorPrecedence

protected

Definition at line 93 of file SkSLGLSLCodeGenerator.cpp.

Constructor & Destructor Documentation

GLSLCodeGenerator()

SkSL::GLSLCodeGenerator::GLSLCodeGenerator ( const Context *  context, const ShaderCaps *  caps, const Program *  program, OutputStream *  out  )

inline

Definition at line 84 of file SkSLGLSLCodeGenerator.cpp.

            : INHERITED(context, caps, program, out) {}

Member Function Documentation

finishLine()

void SkSL::GLSLCodeGenerator::finishLine ( )

protected

Definition at line 256 of file SkSLGLSLCodeGenerator.cpp.

                                   {
    if (!fAtLineStart) {
        this->writeLine();
    }
}

generateCode()

bool SkSL::GLSLCodeGenerator::generateCode ( )

overridevirtual

Implements SkSL::CodeGenerator.

Definition at line 1956 of file SkSLGLSLCodeGenerator.cpp.

                                     {
    this->writeHeader();
    OutputStream* rawOut = fOut;
    StringStream body;
    fOut = &body;
    // Write all the program elements except for functions.
    for (const ProgramElement* e : fProgram.elements()) {
        if (!e->is<FunctionDefinition>()) {
            this->writeProgramElement(*e);
        }
    }
    // Emit prototypes for every built-in function; these aren't always added in perfect order.
    for (const ProgramElement* e : fProgram.fSharedElements) {
        if (e->is<FunctionDefinition>()) {
            this->writeFunctionDeclaration(e->as<FunctionDefinition>().declaration());
            this->writeLine(";");
        }
    }
    // Write the functions last.
    // Why don't we write things in their original order? Because the Inliner likes to move function
    // bodies around. After inlining, code can inadvertently move upwards, above ProgramElements
    // that the code relies on.
    for (const ProgramElement* e : fProgram.elements()) {
        if (e->is<FunctionDefinition>()) {
            this->writeProgramElement(*e);
        }
    }
    fOut = rawOut;
 
    write_stringstream(fExtensions, *rawOut);
    this->writeInputVars();
    write_stringstream(fGlobals, *rawOut);
 
    if (!fCaps.fCanUseFragCoord) {
        Layout layout;
        if (ProgramConfig::IsVertex(fProgram.fConfig->fKind)) {
            this->writeModifiers(layout, ModifierFlag::kOut, /*globalContext=*/true);
            if (this->usesPrecisionModifiers()) {
                this->write("highp ");
            }
            this->write("vec4 sk_FragCoord_Workaround;\n");
        } else if (ProgramConfig::IsFragment(fProgram.fConfig->fKind)) {
            this->writeModifiers(layout, ModifierFlag::kIn, /*globalContext=*/true);
            if (this->usesPrecisionModifiers()) {
                this->write("highp ");
            }
            this->write("vec4 sk_FragCoord_Workaround;\n");
        }
    }
 
    if (this->usesPrecisionModifiers()) {
        const char* precision =
                fProgram.fConfig->fSettings.fForceHighPrecision ? "highp" : "mediump";
        this->write(String::printf("precision %s float;\n", precision));
        this->write(String::printf("precision %s sampler2D;\n", precision));
        if (fFoundExternalSamplerDecl && !fCaps.fNoDefaultPrecisionForExternalSamplers) {
            this->write(String::printf("precision %s samplerExternalOES;\n", precision));
        }
        if (fFoundRectSamplerDecl) {
            this->write(String::printf("precision %s sampler2DRect;\n", precision));
        }
    }
    write_stringstream(fExtraFunctions, *rawOut);
    write_stringstream(body, *rawOut);
    return fContext.fErrors->errorCount() == 0;
}

getTypeName()

std::string SkSL::GLSLCodeGenerator::getTypeName ( const Type &  type )

protected

Definition at line 289 of file SkSLGLSLCodeGenerator.cpp.

                                                        {
    const Type& type = raw.resolve().scalarTypeForLiteral();
    switch (type.typeKind()) {
        case Type::TypeKind::kVector: {
            const Type& component = type.componentType();
            std::string result;
            if (component.matches(*fContext.fTypes.fFloat) ||
                component.matches(*fContext.fTypes.fHalf)) {
                result = "vec";
            }
            else if (component.isSigned()) {
                result = "ivec";
            }
            else if (component.isUnsigned()) {
                result = "uvec";
            }
            else if (component.matches(*fContext.fTypes.fBool)) {
                result = "bvec";
            }
            else {
                SK_ABORT("unsupported vector type");
            }
            result += std::to_string(type.columns());
            return result;
        }
        case Type::TypeKind::kMatrix: {
            std::string result;
            const Type& component = type.componentType();
            if (component.matches(*fContext.fTypes.fFloat) ||
                component.matches(*fContext.fTypes.fHalf)) {
                result = "mat";
            }
            else {
                SK_ABORT("unsupported matrix type");
            }
            result += std::to_string(type.columns());
            if (type.columns() != type.rows()) {
                result += "x";
                result += std::to_string(type.rows());
            }
            return result;
        }
        case Type::TypeKind::kArray: {
            std::string baseTypeName = this->getTypeName(type.componentType());
            if (type.isUnsizedArray()) {
                return String::printf("%s[]", baseTypeName.c_str());
            }
            return String::printf("%s[%d]", baseTypeName.c_str(), type.columns());
        }
        case Type::TypeKind::kScalar: {
            if (type.matches(*fContext.fTypes.fHalf)) {
                return "float";
            }
            else if (type.matches(*fContext.fTypes.fShort)) {
                return "int";
            }
            else if (type.matches(*fContext.fTypes.fUShort)) {
                return "uint";
            }
 
            return std::string(type.name());
        }
        default:
            return std::string(type.name());
    }
}

getTypePrecision()

const char * SkSL::GLSLCodeGenerator::getTypePrecision ( const Type &  type )

protected

Definition at line 1494 of file SkSLGLSLCodeGenerator.cpp.

                                                                {
    if (this->usesPrecisionModifiers()) {
        switch (type.typeKind()) {
            case Type::TypeKind::kScalar:
                if (type.matches(*fContext.fTypes.fShort) ||
                    type.matches(*fContext.fTypes.fUShort) ||
                    type.matches(*fContext.fTypes.fHalf)) {
                    return fProgram.fConfig->fSettings.fForceHighPrecision ? "highp " : "mediump ";
                }
                if (type.matches(*fContext.fTypes.fFloat) ||
                    type.matches(*fContext.fTypes.fInt) ||
                    type.matches(*fContext.fTypes.fUInt)) {
                    return "highp ";
                }
                return "";
            case Type::TypeKind::kVector: // fall through
            case Type::TypeKind::kMatrix:
            case Type::TypeKind::kArray:
                return this->getTypePrecision(type.componentType());
            default:
                break;
        }
    }
    return "";
}

shouldRewriteVoidTypedFunctions()

bool SkSL::GLSLCodeGenerator::shouldRewriteVoidTypedFunctions ( const FunctionDeclaration *  func ) const

protected

Definition at line 1309 of file SkSLGLSLCodeGenerator.cpp.

                                                                                             {
    // We can change void-typed user functions to return a (meaningless) float so that sequence
    // expressions will work normally in WebGL2. (skbug.com/294893925)
    return  func &&
           !func->isMain() &&
            func->returnType().isVoid() &&
           !fCaps.fCanUseVoidInSequenceExpressions;
}

usesPrecisionModifiers()

bool SkSL::GLSLCodeGenerator::usesPrecisionModifiers ( ) const

protected

Definition at line 268 of file SkSLGLSLCodeGenerator.cpp.

                                                     {
    return fCaps.fUsesPrecisionModifiers;
}

write()

void SkSL::GLSLCodeGenerator::write ( std::string_view  s )

protected

Definition at line 235 of file SkSLGLSLCodeGenerator.cpp.

                                              {
    if (s.empty()) {
        return;
    }
#if defined(SK_DEBUG) || defined(SKSL_STANDALONE)
    if (fAtLineStart) {
        for (int i = 0; i < fIndentation; i++) {
            fOut->writeText("    ");
        }
    }
#endif
    fOut->write(s.data(), s.length());
    fAtLineStart = false;
}

writeAnyConstructor()

void SkSL::GLSLCodeGenerator::writeAnyConstructor ( const AnyConstructor &  c, Precedence  parentPrecedence  )

protected

Definition at line 1001 of file SkSLGLSLCodeGenerator.cpp.

                                                                                                {
    this->writeType(c.type());
    this->write("(");
    auto separator = SkSL::String::Separator();
    for (const auto& arg : c.argumentSpan()) {
        this->write(separator());
        this->writeExpression(*arg, Precedence::kSequence);
    }
    this->write(")");
}

writeBinaryExpression()

void SkSL::GLSLCodeGenerator::writeBinaryExpression ( const BinaryExpression &  b, Precedence  parentPrecedence  )

protected

Definition at line 1175 of file SkSLGLSLCodeGenerator.cpp.

                                                                           {
    const Expression& left = *b.left();
    const Expression& right = *b.right();
    Operator op = b.getOperator();
    if (fCaps.fUnfoldShortCircuitAsTernary && (op.kind() == Operator::Kind::LOGICALAND ||
                                               op.kind() == Operator::Kind::LOGICALOR)) {
        this->writeShortCircuitWorkaroundExpression(b, parentPrecedence);
        return;
    }
 
    if (fCaps.fRewriteMatrixComparisons && left.type().isMatrix() &&
        right.type().isMatrix() && op.isEquality()) {
        this->writeMatrixComparisonWorkaround(b);
        return;
    }
 
    Precedence precedence = op.getBinaryPrecedence();
    if (precedence >= parentPrecedence) {
        this->write("(");
    }
    const bool needsPositionWorkaround = ProgramConfig::IsVertex(fProgram.fConfig->fKind) &&
                                         op.isAssignment() &&
                                         is_sk_position(left) &&
                                         !Analysis::ContainsRTAdjust(right) &&
                                         !fCaps.fCanUseFragCoord;
    if (needsPositionWorkaround) {
        this->write("sk_FragCoord_Workaround = (");
    }
    this->writeExpression(left, precedence);
    this->write(op.operatorName());
 
    const bool isAssignmentToSampleMask = ProgramConfig::IsFragment(fProgram.fConfig->fKind) &&
                                          op.isAssignment() &&
                                          is_sk_samplemask(left);
    if (isAssignmentToSampleMask) {
        // GLSL defines the sample masks as signed ints; SkSL (and Metal/WebGPU) use unsigned ints.
        this->write("int(");
    }
    this->writeExpression(right, precedence);
    if (isAssignmentToSampleMask) {
        this->write(")");
    }
    if (needsPositionWorkaround) {
        this->write(")");
    }
    if (precedence >= parentPrecedence) {
        this->write(")");
    }
}

writeBlock()

void SkSL::GLSLCodeGenerator::writeBlock ( const Block &  b )

protected

Definition at line 1642 of file SkSLGLSLCodeGenerator.cpp.

                                                 {
    // Write scope markers if this block is a scope, or if the block is empty (since we need to emit
    // something here to make the code valid).
    bool isScope = b.isScope() || b.isEmpty();
    if (isScope) {
        this->writeLine("{");
        fIndentation++;
    }
    for (const std::unique_ptr<Statement>& stmt : b.children()) {
        if (!stmt->isEmpty()) {
            this->writeStatement(*stmt);
            this->finishLine();
        }
    }
    if (isScope) {
        fIndentation--;
        this->write("}");
    }
}

writeCastConstructor()

void SkSL::GLSLCodeGenerator::writeCastConstructor ( const AnyConstructor &  c, Precedence  parentPrecedence  )

protected

Definition at line 983 of file SkSLGLSLCodeGenerator.cpp.

                                                                                                 {
    const auto arguments = c.argumentSpan();
    SkASSERT(arguments.size() == 1);
 
    const Expression& argument = *arguments.front();
    if ((this->getTypeName(c.type()) == this->getTypeName(argument.type()) ||
         (argument.type().matches(*fContext.fTypes.fFloatLiteral)))) {
        // In cases like half(float), they're different types as far as SkSL is concerned but
        // the same type as far as GLSL is concerned. We avoid a redundant float(float) by just
        // writing out the inner expression here.
        this->writeExpression(argument, parentPrecedence);
        return;
    }
 
    // This cast should be emitted as-is.
    return this->writeAnyConstructor(c, parentPrecedence);
}

writeConstructorCompound()

void SkSL::GLSLCodeGenerator::writeConstructorCompound ( const ConstructorCompound &  c, Precedence  parentPrecedence  )

protected

Definition at line 946 of file SkSLGLSLCodeGenerator.cpp.

                                                                              {
    // If this is a 2x2 matrix constructor containing a single argument...
    if (c.type().isMatrix() && c.arguments().size() == 1) {
        // ... and that argument is a vec4...
        const Expression& expr = *c.arguments().front();
        if (expr.type().isVector() && expr.type().columns() == 4) {
            // ... let's rewrite the cast to dodge issues on very old GPUs. (skia:13559)
            if (Analysis::IsTrivialExpression(expr)) {
                this->writeType(c.type());
                this->write("(");
                this->writeExpression(expr, Precedence::kPostfix);
                this->write(".xy, ");
                this->writeExpression(expr, Precedence::kPostfix);
                this->write(".zw)");
            } else {
                std::string tempVec = "_tempVec" + std::to_string(fVarCount++);
                this->fFunctionHeader += std::string("    ") + this->getTypePrecision(expr.type()) +
                                         this->getTypeName(expr.type()) + " " + tempVec + ";\n";
                this->write("((");
                this->write(tempVec);
                this->write(" = ");
                this->writeExpression(expr, Precedence::kAssignment);
                this->write("), ");
                this->writeType(c.type());
                this->write("(");
                this->write(tempVec);
                this->write(".xy, ");
                this->write(tempVec);
                this->write(".zw))");
            }
            return;
        }
    }
    this->writeAnyConstructor(c, parentPrecedence);
}

writeConstructorDiagonalMatrix()

void SkSL::GLSLCodeGenerator::writeConstructorDiagonalMatrix ( const ConstructorDiagonalMatrix &  c, Precedence  parentPrecedence  )

protected

Definition at line 928 of file SkSLGLSLCodeGenerator.cpp.

                                                                                    {
    if (c.type().columns() == 4 && c.type().rows() == 2) {
        // Due to a longstanding bug in glslang and Mesa, several GPU drivers generate diagonal 4x2
        // matrices incorrectly. (skia:12003, https://github.com/KhronosGroup/glslang/pull/2646)
        // We can work around this issue by multiplying a scalar by the identity matrix.
        // In practice, this doesn't come up naturally in real code and we don't know every affected
        // driver, so we just apply this workaround everywhere.
        this->write("(");
        this->writeType(c.type());
        this->write("(1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0) * ");
        this->writeExpression(*c.argument(), Precedence::kMultiplicative);
        this->write(")");
        return;
    }
    this->writeAnyConstructor(c, parentPrecedence);
}

writeDeterminantHack()

void SkSL::GLSLCodeGenerator::writeDeterminantHack ( const Expression &  mat )

protected

Definition at line 516 of file SkSLGLSLCodeGenerator.cpp.

                                                                  {
    const Type& type = mat.type();
    if (type.matches(*fContext.fTypes.fFloat2x2) ||
        type.matches(*fContext.fTypes.fHalf2x2)) {
        this->write("_determinant2(");
        if (!fWrittenDeterminant2) {
            fWrittenDeterminant2 = true;
            fExtraFunctions.writeText(kDeterminant2);
        }
    } else if (type.matches(*fContext.fTypes.fFloat3x3) ||
               type.matches(*fContext.fTypes.fHalf3x3)) {
        this->write("_determinant3(");
        if (!fWrittenDeterminant3) {
            fWrittenDeterminant3 = true;
            fExtraFunctions.writeText(kDeterminant3);
        }
    } else if (type.matches(*fContext.fTypes.fFloat4x4) ||
               type.matches(*fContext.fTypes.fHalf4x4)) {
        this->write("_determinant4(");
        if (!fWrittenDeterminant4) {
            fWrittenDeterminant4 = true;
            fExtraFunctions.writeText(kDeterminant4);
        }
    } else {
        SkDEBUGFAILF("no polyfill for determinant(%s)", type.description().c_str());
        this->write("determinant(");
    }
    this->writeExpression(mat, Precedence::kExpression);
    this->write(")");
}

writeDoStatement()

void SkSL::GLSLCodeGenerator::writeDoStatement ( const DoStatement &  d )

protected

Definition at line 1708 of file SkSLGLSLCodeGenerator.cpp.

                                                             {
    if (!fCaps.fRewriteDoWhileLoops) {
        this->write("do ");
        this->writeStatement(*d.statement());
        this->write(" while (");
        this->writeExpression(*d.test(), Precedence::kExpression);
        this->write(");");
        return;
    }
 
    // Otherwise, do the do while loop workaround, to rewrite loops of the form:
    //     do {
    //         CODE;
    //     } while (CONDITION)
    //
    // to loops of the form
    //     bool temp = false;
    //     while (true) {
    //         if (temp) {
    //             if (!CONDITION) {
    //                 break;
    //             }
    //         }
    //         temp = true;
    //         CODE;
    //     }
    std::string tmpVar = "_tmpLoopSeenOnce" + std::to_string(fVarCount++);
    this->write("bool ");
    this->write(tmpVar);
    this->writeLine(" = false;");
    this->writeLine("while (true) {");
    fIndentation++;
    this->write("if (");
    this->write(tmpVar);
    this->writeLine(") {");
    fIndentation++;
    this->write("if (!");
    this->writeExpression(*d.test(), Precedence::kPrefix);
    this->writeLine(") {");
    fIndentation++;
    this->writeLine("break;");
    fIndentation--;
    this->writeLine("}");
    fIndentation--;
    this->writeLine("}");
    this->write(tmpVar);
    this->writeLine(" = true;");
    this->writeStatement(*d.statement());
    this->finishLine();
    fIndentation--;
    this->write("}");
}

writeExpression()

void SkSL::GLSLCodeGenerator::writeExpression ( const Expression &  expr, Precedence  parentPrecedence  )

protected

Definition at line 382 of file SkSLGLSLCodeGenerator.cpp.

                                                                                           {
    switch (expr.kind()) {
        case Expression::Kind::kBinary:
            this->writeBinaryExpression(expr.as<BinaryExpression>(), parentPrecedence);
            break;
        case Expression::Kind::kConstructorDiagonalMatrix:
            this->writeConstructorDiagonalMatrix(expr.as<ConstructorDiagonalMatrix>(),
                                                 parentPrecedence);
            break;
        case Expression::Kind::kConstructorArrayCast:
            this->writeExpression(*expr.as<ConstructorArrayCast>().argument(), parentPrecedence);
            break;
        case Expression::Kind::kConstructorCompound:
            this->writeConstructorCompound(expr.as<ConstructorCompound>(), parentPrecedence);
            break;
        case Expression::Kind::kConstructorArray:
        case Expression::Kind::kConstructorMatrixResize:
        case Expression::Kind::kConstructorSplat:
        case Expression::Kind::kConstructorStruct:
            this->writeAnyConstructor(expr.asAnyConstructor(), parentPrecedence);
            break;
        case Expression::Kind::kConstructorScalarCast:
        case Expression::Kind::kConstructorCompoundCast:
            this->writeCastConstructor(expr.asAnyConstructor(), parentPrecedence);
            break;
        case Expression::Kind::kEmpty:
            this->write("false");
            break;
        case Expression::Kind::kFieldAccess:
            this->writeFieldAccess(expr.as<FieldAccess>());
            break;
        case Expression::Kind::kFunctionCall:
            this->writeFunctionCall(expr.as<FunctionCall>());
            break;
        case Expression::Kind::kLiteral:
            this->writeLiteral(expr.as<Literal>());
            break;
        case Expression::Kind::kPrefix:
            this->writePrefixExpression(expr.as<PrefixExpression>(), parentPrecedence);
            break;
        case Expression::Kind::kPostfix:
            this->writePostfixExpression(expr.as<PostfixExpression>(), parentPrecedence);
            break;
        case Expression::Kind::kSetting:
            this->writeExpression(*expr.as<Setting>().toLiteral(fCaps), parentPrecedence);
            break;
        case Expression::Kind::kSwizzle:
            this->writeSwizzle(expr.as<Swizzle>());
            break;
        case Expression::Kind::kVariableReference:
            this->writeVariableReference(expr.as<VariableReference>());
            break;
        case Expression::Kind::kTernary:
            this->writeTernaryExpression(expr.as<TernaryExpression>(), parentPrecedence);
            break;
        case Expression::Kind::kIndex:
            this->writeIndexExpression(expr.as<IndexExpression>());
            break;
        default:
            SkDEBUGFAILF("unsupported expression: %s", expr.description().c_str());
            break;
    }
}

writeExpressionStatement()

void SkSL::GLSLCodeGenerator::writeExpressionStatement ( const ExpressionStatement &  s )

protected

Definition at line 1761 of file SkSLGLSLCodeGenerator.cpp.

                                                                             {
    if (fProgram.fConfig->fSettings.fOptimize && !Analysis::HasSideEffects(*s.expression())) {
        // Don't emit dead expressions.
        return;
    }
    this->writeExpression(*s.expression(), Precedence::kStatement);
    this->write(";");
}

writeExtension()

void SkSL::GLSLCodeGenerator::writeExtension ( std::string_view  name, bool  require = true  )

protected

Definition at line 262 of file SkSLGLSLCodeGenerator.cpp.

                                                                        {
    fExtensions.writeText("#extension ");
    fExtensions.write(name.data(), name.length());
    fExtensions.writeText(require ? " : require\n" : " : enable\n");
}

writeFieldAccess()

void SkSL::GLSLCodeGenerator::writeFieldAccess ( const FieldAccess &  f )

protected

Definition at line 1128 of file SkSLGLSLCodeGenerator.cpp.

                                                             {
    if (f.ownerKind() == FieldAccess::OwnerKind::kDefault) {
        this->writeExpression(*f.base(), Precedence::kPostfix);
        this->write(".");
    }
    const Type& baseType = f.base()->type();
    int builtin = baseType.fields()[f.fieldIndex()].fLayout.fBuiltin;
    if (builtin == SK_POSITION_BUILTIN) {
        this->writeIdentifier("gl_Position");
    } else if (builtin == SK_POINTSIZE_BUILTIN) {
        this->writeIdentifier("gl_PointSize");
    } else {
        this->writeIdentifier(baseType.fields()[f.fieldIndex()].fName);
    }
}

writeForStatement()

void SkSL::GLSLCodeGenerator::writeForStatement ( const ForStatement &  f )

protected

Definition at line 1673 of file SkSLGLSLCodeGenerator.cpp.

                                                               {
    // Emit loops of the form 'for(;test;)' as 'while(test)', which is probably how they started
    if (!f.initializer() && f.test() && !f.next()) {
        this->write("while (");
        this->writeExpression(*f.test(), Precedence::kExpression);
        this->write(") ");
        this->writeStatement(*f.statement());
        return;
    }
 
    this->write("for (");
    if (f.initializer() && !f.initializer()->isEmpty()) {
        this->writeStatement(*f.initializer());
    } else {
        this->write("; ");
    }
    if (f.test()) {
        if (fCaps.fAddAndTrueToLoopCondition) {
            std::unique_ptr<Expression> and_true(new BinaryExpression(
                    Position(), f.test()->clone(), Operator::Kind::LOGICALAND,
                    Literal::MakeBool(fContext, Position(), /*value=*/true),
                    fContext.fTypes.fBool.get()));
            this->writeExpression(*and_true, Precedence::kExpression);
        } else {
            this->writeExpression(*f.test(), Precedence::kExpression);
        }
    }
    this->write("; ");
    if (f.next()) {
        this->writeExpression(*f.next(), Precedence::kExpression);
    }
    this->write(") ");
    this->writeStatement(*f.statement());
}

writeFragCoord()

void SkSL::GLSLCodeGenerator::writeFragCoord ( )

protected

Definition at line 1012 of file SkSLGLSLCodeGenerator.cpp.

                                       {
    if (!fCaps.fCanUseFragCoord) {
        if (!fSetupFragCoordWorkaround) {
            const char* precision = this->usesPrecisionModifiers() ? "highp " : "";
            fFunctionHeader += precision;
            fFunctionHeader += "    float sk_FragCoord_InvW = 1. / sk_FragCoord_Workaround.w;\n";
            fFunctionHeader += precision;
            fFunctionHeader += "    vec4 sk_FragCoord_Resolved = "
                "vec4(sk_FragCoord_Workaround.xyz * sk_FragCoord_InvW, sk_FragCoord_InvW);\n";
            // Ensure that we get exact .5 values for x and y.
            fFunctionHeader += "    sk_FragCoord_Resolved.xy = floor(sk_FragCoord_Resolved.xy) + "
                               "vec2(.5);\n";
            fSetupFragCoordWorkaround = true;
        }
        this->writeIdentifier("sk_FragCoord_Resolved");
        return;
    }
 
    if (!fSetupFragPosition) {
        fFunctionHeader += this->usesPrecisionModifiers() ? "highp " : "";
        fFunctionHeader += "    vec4 sk_FragCoord = vec4("
                "gl_FragCoord.x, ";
        if (fProgram.fConfig->fSettings.fForceNoRTFlip) {
            fFunctionHeader += "gl_FragCoord.y, ";
        } else {
            fFunctionHeader += SKSL_RTFLIP_NAME ".x + " SKSL_RTFLIP_NAME ".y * gl_FragCoord.y, ";
        }
        fFunctionHeader +=
                "gl_FragCoord.z, "
                "gl_FragCoord.w);\n";
        fSetupFragPosition = true;
    }
    this->writeIdentifier("sk_FragCoord");
}

writeFunction()

void SkSL::GLSLCodeGenerator::writeFunction ( const FunctionDefinition &  f )

protected

Definition at line 1370 of file SkSLGLSLCodeGenerator.cpp.

                                                                 {
    fSetupFragPosition = false;
    fSetupFragCoordWorkaround = false;
    fSetupClockwise = false;
    fCurrentFunction = &f.declaration();
 
    this->writeFunctionDeclaration(f.declaration());
    this->writeLine(" {");
    fIndentation++;
 
    fFunctionHeader.clear();
    OutputStream* oldOut = fOut;
    StringStream buffer;
    fOut = &buffer;
    for (const std::unique_ptr<Statement>& stmt : f.body()->as<Block>().children()) {
        if (!stmt->isEmpty()) {
            this->writeStatement(*stmt);
            this->finishLine();
        }
    }
 
    if (this->shouldRewriteVoidTypedFunctions(&f.declaration())) {
        // If we can't use void in sequence expressions, we rewrite void-typed user functions to
        // return a (never-used) float in case they are used in a sequence expression.
        this->writeLine("return 0.0;");
    }
 
    fIndentation--;
    this->writeLine("}");
 
    fOut = oldOut;
    this->write(fFunctionHeader);
    this->write(buffer.str());
 
    fCurrentFunction = nullptr;
}

writeFunctionCall()

void SkSL::GLSLCodeGenerator::writeFunctionCall ( const FunctionCall &  c )

protected

Definition at line 671 of file SkSLGLSLCodeGenerator.cpp.

                                                               {
    const FunctionDeclaration& function = c.function();
    const ExpressionArray& arguments = c.arguments();
    bool isTextureFunctionWithBias = false;
    bool nameWritten = false;
    const char* closingParen = ")";
    switch (c.function().intrinsicKind()) {
        case k_abs_IntrinsicKind: {
            if (!fCaps.fEmulateAbsIntFunction)
                break;
            SkASSERT(arguments.size() == 1);
            if (!arguments[0]->type().matches(*fContext.fTypes.fInt)) {
                break;
            }
            // abs(int) on Intel OSX is incorrect, so emulate it:
            this->write("_absemulation");
            nameWritten = true;
            if (!fWrittenAbsEmulation) {
                fWrittenAbsEmulation = true;
                fExtraFunctions.writeText("int _absemulation(int x) { return x * sign(x); }\n");
            }
            break;
        }
        case k_atan_IntrinsicKind:
            if (fCaps.fMustForceNegatedAtanParamToFloat &&
                arguments.size() == 2 &&
                arguments[1]->is<PrefixExpression>()) {
                const PrefixExpression& p = arguments[1]->as<PrefixExpression>();
                if (p.getOperator().kind() == Operator::Kind::MINUS) {
                    this->write("atan(");
                    this->writeExpression(*arguments[0], Precedence::kSequence);
                    this->write(", -1.0 * ");
                    this->writeExpression(*p.operand(), Precedence::kMultiplicative);
                    this->write(")");
                    return;
                }
            }
            break;
        case k_ldexp_IntrinsicKind:
            if (fCaps.fMustForceNegatedLdexpParamToMultiply &&
                arguments.size() == 2 &&
                arguments[1]->is<PrefixExpression>()) {
                const PrefixExpression& p = arguments[1]->as<PrefixExpression>();
                if (p.getOperator().kind() == Operator::Kind::MINUS) {
                    this->write("ldexp(");
                    this->writeExpression(*arguments[0], Precedence::kSequence);
                    this->write(", ");
                    this->writeExpression(*p.operand(), Precedence::kMultiplicative);
                    this->write(" * -1)");
                    return;
                }
            }
            break;
        case k_dFdy_IntrinsicKind:
            // Flipping Y also negates the Y derivatives.
            closingParen = "))";
            this->write("(");
            if (!fProgram.fConfig->fSettings.fForceNoRTFlip) {
                this->write(SKSL_RTFLIP_NAME ".y * ");
            }
            this->write("dFdy");
            nameWritten = true;
            [[fallthrough]];
        case k_dFdx_IntrinsicKind:
        case k_fwidth_IntrinsicKind:
            if (!fFoundDerivatives &&
                fCaps.shaderDerivativeExtensionString()) {
                this->writeExtension(fCaps.shaderDerivativeExtensionString());
                fFoundDerivatives = true;
            }
            break;
        case k_determinant_IntrinsicKind:
            if (!fCaps.fBuiltinDeterminantSupport) {
                SkASSERT(arguments.size() == 1);
                this->writeDeterminantHack(*arguments[0]);
                return;
            }
            break;
        case k_fma_IntrinsicKind:
            if (!fCaps.fBuiltinFMASupport) {
                SkASSERT(arguments.size() == 3);
                this->write("((");
                this->writeExpression(*arguments[0], Precedence::kSequence);
                this->write(") * (");
                this->writeExpression(*arguments[1], Precedence::kSequence);
                this->write(") + (");
                this->writeExpression(*arguments[2], Precedence::kSequence);
                this->write("))");
                return;
            }
            break;
        case k_fract_IntrinsicKind:
            if (!fCaps.fCanUseFractForNegativeValues) {
                SkASSERT(arguments.size() == 1);
                this->write("(0.5 - sign(");
                this->writeExpression(*arguments[0], Precedence::kSequence);
                this->write(") * (0.5 - fract(abs(");
                this->writeExpression(*arguments[0], Precedence::kSequence);
                this->write("))))");
                return;
            }
            break;
        case k_inverse_IntrinsicKind:
            if (fCaps.fGLSLGeneration < SkSL::GLSLGeneration::k140) {
                SkASSERT(arguments.size() == 1);
                this->writeInverseHack(*arguments[0]);
                return;
            }
            break;
        case k_inversesqrt_IntrinsicKind:
            if (fCaps.fGLSLGeneration < SkSL::GLSLGeneration::k130) {
                SkASSERT(arguments.size() == 1);
                this->writeInverseSqrtHack(*arguments[0]);
                return;
            }
            break;
        case k_min_IntrinsicKind:
            if (!fCaps.fCanUseMinAndAbsTogether) {
                SkASSERT(arguments.size() == 2);
                if (is_abs(*arguments[0])) {
                    this->writeMinAbsHack(*arguments[0], *arguments[1]);
                    return;
                }
                if (is_abs(*arguments[1])) {
                    // note that this violates the GLSL left-to-right evaluation semantics.
                    // I doubt it will ever end up mattering, but it's worth calling out.
                    this->writeMinAbsHack(*arguments[1], *arguments[0]);
                    return;
                }
            }
            break;
        case k_pow_IntrinsicKind:
            if (!fCaps.fRemovePowWithConstantExponent) {
                break;
            }
            // pow(x, y) on some NVIDIA drivers causes crashes if y is a constant.
            // It's hard to tell what constitutes "constant" here, so just replace in all cases.
 
            // Change pow(x, y) into exp2(y * log2(x))
            this->write("exp2(");
            this->writeExpression(*arguments[1], Precedence::kMultiplicative);
            this->write(" * log2(");
            this->writeExpression(*arguments[0], Precedence::kSequence);
            this->write("))");
            return;
        case k_saturate_IntrinsicKind:
            SkASSERT(arguments.size() == 1);
            this->write("clamp(");
            this->writeExpression(*arguments[0], Precedence::kSequence);
            this->write(", 0.0, 1.0)");
            return;
        case k_sample_IntrinsicKind: {
            const char* dim = "";
            bool proj = false;
            const Type& arg0Type = arguments[0]->type();
            const Type& arg1Type = arguments[1]->type();
            switch (arg0Type.dimensions()) {
                case SpvDim1D:
                    dim = "1D";
                    isTextureFunctionWithBias = true;
                    if (arg1Type.matches(*fContext.fTypes.fFloat)) {
                        proj = false;
                    } else {
                        SkASSERT(arg1Type.matches(*fContext.fTypes.fFloat2));
                        proj = true;
                    }
                    break;
                case SpvDim2D:
                    dim = "2D";
                    if (!arg0Type.matches(*fContext.fTypes.fSamplerExternalOES)) {
                        isTextureFunctionWithBias = true;
                    }
                    if (arg1Type.matches(*fContext.fTypes.fFloat2)) {
                        proj = false;
                    } else {
                        SkASSERT(arg1Type.matches(*fContext.fTypes.fFloat3));
                        proj = true;
                    }
                    break;
                case SpvDim3D:
                    dim = "3D";
                    isTextureFunctionWithBias = true;
                    if (arg1Type.matches(*fContext.fTypes.fFloat3)) {
                        proj = false;
                    } else {
                        SkASSERT(arg1Type.matches(*fContext.fTypes.fFloat4));
                        proj = true;
                    }
                    break;
                case SpvDimCube:
                    dim = "Cube";
                    isTextureFunctionWithBias = true;
                    proj = false;
                    break;
                case SpvDimRect:
                    dim = "2DRect";
                    proj = false;
                    break;
                case SpvDimBuffer:
                    SkASSERT(false); // doesn't exist
                    dim = "Buffer";
                    proj = false;
                    break;
                case SpvDimSubpassData:
                    SkASSERT(false); // doesn't exist
                    dim = "SubpassData";
                    proj = false;
                    break;
            }
            this->write("texture");
            if (fCaps.fGLSLGeneration < SkSL::GLSLGeneration::k130) {
                this->write(dim);
            }
            if (proj) {
                this->write("Proj");
            }
            nameWritten = true;
            break;
        }
        case k_sampleGrad_IntrinsicKind: {
            SkASSERT(arguments.size() == 4);
            this->write("textureGrad");
            nameWritten = true;
            break;
        }
        case k_sampleLod_IntrinsicKind: {
            SkASSERT(arguments.size() == 3);
            this->write("textureLod");
            nameWritten = true;
            break;
        }
        case k_transpose_IntrinsicKind:
            if (fCaps.fGLSLGeneration < SkSL::GLSLGeneration::k130) {
                SkASSERT(arguments.size() == 1);
                this->writeTransposeHack(*arguments[0]);
                return;
            }
            break;
        default:
            break;
    }
 
    if (!nameWritten) {
        this->writeIdentifier(function.mangledName());
    }
    this->write("(");
    auto separator = SkSL::String::Separator();
    for (const auto& arg : arguments) {
        this->write(separator());
        this->writeExpression(*arg, Precedence::kSequence);
    }
    if (fProgram.fConfig->fSettings.fSharpenTextures && isTextureFunctionWithBias) {
        this->write(String::printf(", %g", kSharpenTexturesBias));
    }
    this->write(closingParen);
}

writeFunctionDeclaration()

void SkSL::GLSLCodeGenerator::writeFunctionDeclaration ( const FunctionDeclaration &  f )

protected

Definition at line 1318 of file SkSLGLSLCodeGenerator.cpp.

                                                                             {
    if (this->shouldRewriteVoidTypedFunctions(&f)) {
        this->write("float ");
    } else {
        this->writeTypePrecision(f.returnType());
        this->writeType(f.returnType());
        this->write(" ");
    }
    this->writeIdentifier(f.mangledName());
    this->write("(");
    auto separator = SkSL::String::Separator();
    for (size_t index = 0; index < f.parameters().size(); ++index) {
        const Variable* param = f.parameters()[index];
 
        // This is a workaround for our test files. They use the runtime effect signature, so main
        // takes a coords parameter. We detect these at IR generation time, and we omit them from
        // the declaration here, so the function is valid GLSL. (Well, valid as long as the
        // coordinates aren't actually referenced.)
        if (f.isMain() && param == f.getMainCoordsParameter()) {
            continue;
        }
        this->write(separator());
        ModifierFlags flags = param->modifierFlags();
        if (fCaps.fRemoveConstFromFunctionParameters) {
            flags &= ~ModifierFlag::kConst;
        }
        this->writeModifiers(param->layout(), flags, /*globalContext=*/false);
        std::vector<int> sizes;
        const Type* type = &param->type();
        if (type->isArray()) {
            sizes.push_back(type->columns());
            type = &type->componentType();
        }
        this->writeTypePrecision(*type);
        this->writeType(*type);
        this->write(" ");
        if (!param->name().empty()) {
            this->writeIdentifier(param->mangledName());
        } else {
            // By the spec, GLSL does not require function parameters to be named (see
            // `single_declaration` in the Shading Language Grammar), but some older versions of
            // GLSL report "formal parameter lacks a name" if a parameter is not named.
            this->write("_skAnonymousParam");
            this->write(std::to_string(index));
        }
        for (int s : sizes) {
            this->write("[" + std::to_string(s) + "]");
        }
    }
    this->write(")");
}

writeFunctionPrototype()

void SkSL::GLSLCodeGenerator::writeFunctionPrototype ( const FunctionPrototype &  f )

protected

Definition at line 1407 of file SkSLGLSLCodeGenerator.cpp.

                                                                         {
    this->writeFunctionDeclaration(f.declaration());
    this->writeLine(";");
}

writeGlobalVarDeclaration()

void SkSL::GLSLCodeGenerator::writeGlobalVarDeclaration ( const GlobalVarDeclaration &  e )

protected

Definition at line 1524 of file SkSLGLSLCodeGenerator.cpp.

                                                                               {
    const VarDeclaration& decl = e.as<GlobalVarDeclaration>().varDeclaration();
    switch (decl.var()->layout().fBuiltin) {
        case -1:
            // normal var
            this->writeVarDeclaration(decl, /*global=*/true);
            this->finishLine();
            break;
 
        case SK_FRAGCOLOR_BUILTIN:
            if (fCaps.mustDeclareFragmentShaderOutput()) {
                if (fProgram.fConfig->fSettings.fFragColorIsInOut) {
                    this->write("inout ");
                } else {
                    this->write("out ");
                }
                if (this->usesPrecisionModifiers()) {
                    this->write("mediump ");
                }
                this->writeLine("vec4 sk_FragColor;");
            }
            break;
 
        default:
            break;
    }
}

writeHeader()

void SkSL::GLSLCodeGenerator::writeHeader ( )

protected

Definition at line 1896 of file SkSLGLSLCodeGenerator.cpp.

                                    {
    if (fCaps.fVersionDeclString) {
        this->write(fCaps.fVersionDeclString);
        this->finishLine();
    }
}

writeIdentifier()

void SkSL::GLSLCodeGenerator::writeIdentifier ( std::string_view  identifier )

protected

Definition at line 272 of file SkSLGLSLCodeGenerator.cpp.

                                                                 {
    // GLSL forbids two underscores in a row.
    // If an identifier contains "__" or "_X", replace each "_" in the identifier with "_X".
    if (skstd::contains(identifier, "__") || skstd::contains(identifier, "_X")) {
        for (const char c : identifier) {
            if (c == '_') {
                this->write("_X");
            } else {
                this->write(std::string_view(&c, 1));
            }
        }
    } else {
        this->write(identifier);
    }
}

writeIfStatement()

void SkSL::GLSLCodeGenerator::writeIfStatement ( const IfStatement &  stmt )

protected

Definition at line 1662 of file SkSLGLSLCodeGenerator.cpp.

                                                                {
    this->write("if (");
    this->writeExpression(*stmt.test(), Precedence::kExpression);
    this->write(") ");
    this->writeStatement(*stmt.ifTrue());
    if (stmt.ifFalse()) {
        this->write(" else ");
        this->writeStatement(*stmt.ifFalse());
    }
}

writeIndexExpression()

void SkSL::GLSLCodeGenerator::writeIndexExpression ( const IndexExpression &  expr )

protected

Definition at line 1105 of file SkSLGLSLCodeGenerator.cpp.

                                                                        {
    this->writeExpression(*expr.base(), Precedence::kPostfix);
    this->write("[");
    this->writeExpression(*expr.index(), Precedence::kExpression);
    this->write("]");
}

writeInputVars()

void SkSL::GLSLCodeGenerator::writeInputVars ( )

protected

Definition at line 1941 of file SkSLGLSLCodeGenerator.cpp.

                                       {
    // If we are using sk_FragCoordWorkaround, we don't need to apply RTFlip to gl_FragCoord.
    uint8_t useRTFlipUniform = fProgram.fInterface.fRTFlipUniform;
    if (!fCaps.fCanUseFragCoord) {
        useRTFlipUniform &= ~Program::Interface::kRTFlip_FragCoord;
    }
 
    if (useRTFlipUniform != Program::Interface::kRTFlip_None) {
        const char* precision = this->usesPrecisionModifiers() ? "highp " : "";
        fGlobals.writeText("uniform ");
        fGlobals.writeText(precision);
        fGlobals.writeText("vec2 " SKSL_RTFLIP_NAME ";\n");
    }
}

writeInterfaceBlock()

void SkSL::GLSLCodeGenerator::writeInterfaceBlock ( const InterfaceBlock &  intf )

protected

Definition at line 1459 of file SkSLGLSLCodeGenerator.cpp.

                                                                      {
    if (intf.typeName() == "sk_PerVertex") {
        return;
    }
    const Type* structType = &intf.var()->type().componentType();
    this->writeModifiers(intf.var()->layout(), intf.var()->modifierFlags(), /*globalContext=*/true);
    this->writeType(*structType);
    this->writeLine(" {");
    fIndentation++;
    for (const auto& f : structType->fields()) {
        this->writeModifiers(f.fLayout, f.fModifierFlags, /*globalContext=*/false);
        this->writeTypePrecision(*f.fType);
        this->writeType(*f.fType);
        this->write(" ");
        this->writeIdentifier(f.fName);
        this->writeLine(";");
    }
    fIndentation--;
    this->write("}");
    if (!intf.instanceName().empty()) {
        this->write(" ");
        this->writeIdentifier(intf.instanceName());
        if (intf.arraySize() > 0) {
            this->write("[");
            this->write(std::to_string(intf.arraySize()));
            this->write("]");
        }
    }
    this->writeLine(";");
}

writeIntrinsicCall()

void SkSL::GLSLCodeGenerator::writeIntrinsicCall ( const FunctionCall &  c )

protected

writeInverseHack()

void SkSL::GLSLCodeGenerator::writeInverseHack ( const Expression &  mat )

protected

Definition at line 610 of file SkSLGLSLCodeGenerator.cpp.

                                                              {
    const Type& type = mat.type();
    if (type.matches(*fContext.fTypes.fFloat2x2) || type.matches(*fContext.fTypes.fHalf2x2)) {
        this->write("_inverse2(");
        if (!fWrittenInverse2) {
            fWrittenInverse2 = true;
            fExtraFunctions.writeText(kInverse2);
        }
    } else if (type.matches(*fContext.fTypes.fFloat3x3) ||
               type.matches(*fContext.fTypes.fHalf3x3)) {
        this->write("_inverse3(");
        if (!fWrittenInverse3) {
            fWrittenInverse3 = true;
            fExtraFunctions.writeText(kInverse3);
        }
    } else if (type.matches(*fContext.fTypes.fFloat4x4) ||
               type.matches(*fContext.fTypes.fHalf4x4)) {
        this->write("_inverse4(");
        if (!fWrittenInverse4) {
            fWrittenInverse4 = true;
            fExtraFunctions.writeText(kInverse4);
        }
    } else {
        SkDEBUGFAILF("no polyfill for inverse(%s)", type.description().c_str());
        this->write("inverse(");
    }
    this->writeExpression(mat, Precedence::kExpression);
    this->write(")");
}

writeInverseSqrtHack()

void SkSL::GLSLCodeGenerator::writeInverseSqrtHack ( const Expression &  x )

protected

Definition at line 468 of file SkSLGLSLCodeGenerator.cpp.

                                                                {
    this->write("(1.0 / sqrt(");
    this->writeExpression(x, Precedence::kExpression);
    this->write("))");
}

writeLayout()

void SkSL::GLSLCodeGenerator::writeLayout ( const Layout &  layout )

protected

writeLine()

void SkSL::GLSLCodeGenerator::writeLine ( std::string_view  s = std::string_view() )

protected

Definition at line 250 of file SkSLGLSLCodeGenerator.cpp.

                                                  {
    this->write(s);
    fOut->writeText("\n");
    fAtLineStart = true;
}

writeLiteral()

void SkSL::GLSLCodeGenerator::writeLiteral ( const Literal &  l )

protected

Definition at line 1294 of file SkSLGLSLCodeGenerator.cpp.

                                                     {
    const Type& type = l.type();
    if (type.isInteger()) {
        if (type.matches(*fContext.fTypes.fUInt)) {
            this->write(std::to_string(l.intValue() & 0xffffffff) + "u");
        } else if (type.matches(*fContext.fTypes.fUShort)) {
            this->write(std::to_string(l.intValue() & 0xffff) + "u");
        } else {
            this->write(std::to_string(l.intValue()));
        }
        return;
    }
    this->write(l.description(OperatorPrecedence::kExpression));
}

writeMatrixComparisonWorkaround()

void SkSL::GLSLCodeGenerator::writeMatrixComparisonWorkaround ( const BinaryExpression &  x )

protected

Definition at line 1150 of file SkSLGLSLCodeGenerator.cpp.

                                                                                 {
    const Expression& left = *b.left();
    const Expression& right = *b.right();
    Operator op = b.getOperator();
 
    SkASSERT(op.kind() == Operator::Kind::EQEQ || op.kind() == Operator::Kind::NEQ);
    SkASSERT(left.type().isMatrix());
    SkASSERT(right.type().isMatrix());
 
    std::string tempMatrix1 = "_tempMatrix" + std::to_string(fVarCount++);
    std::string tempMatrix2 = "_tempMatrix" + std::to_string(fVarCount++);
 
    this->fFunctionHeader += std::string("    ") + this->getTypePrecision(left.type()) +
                             this->getTypeName(left.type()) + " " + tempMatrix1 + ";\n    " +
                             this->getTypePrecision(right.type()) +
                             this->getTypeName(right.type()) + " " + tempMatrix2 + ";\n";
    this->write("((" + tempMatrix1 + " = ");
    this->writeExpression(left, Precedence::kAssignment);
    this->write("), (" + tempMatrix2 + " = ");
    this->writeExpression(right, Precedence::kAssignment);
    this->write("), (" + tempMatrix1);
    this->write(op.operatorName());
    this->write(tempMatrix2 + "))");
}

writeMinAbsHack()

void SkSL::GLSLCodeGenerator::writeMinAbsHack ( Expression &  absExpr, Expression &  otherExpr  )

protected

Definition at line 453 of file SkSLGLSLCodeGenerator.cpp.

                                                                                  {
    SkASSERT(!fCaps.fCanUseMinAndAbsTogether);
    std::string tmpVar1 = "minAbsHackVar" + std::to_string(fVarCount++);
    std::string tmpVar2 = "minAbsHackVar" + std::to_string(fVarCount++);
    this->fFunctionHeader += std::string("    ") + this->getTypePrecision(absExpr.type()) +
                             this->getTypeName(absExpr.type()) + " " + tmpVar1 + ";\n";
    this->fFunctionHeader += std::string("    ") + this->getTypePrecision(otherExpr.type()) +
                             this->getTypeName(otherExpr.type()) + " " + tmpVar2 + ";\n";
    this->write("((" + tmpVar1 + " = ");
    this->writeExpression(absExpr, Precedence::kAssignment);
    this->write(") < (" + tmpVar2 + " = ");
    this->writeExpression(otherExpr, Precedence::kAssignment);
    this->write(") ? " + tmpVar1 + " : " + tmpVar2 + ")");
}

writeModifiers()

void SkSL::GLSLCodeGenerator::writeModifiers ( const Layout &  layout, ModifierFlags  flags, bool  globalContext  )

protected

Definition at line 1412 of file SkSLGLSLCodeGenerator.cpp.

                                                           {
    this->write(layout.paddedDescription());
 
    // For GLSL 4.1 and below, qualifier-order matters! These are written out in Modifier-bit order.
    if (flags & ModifierFlag::kFlat) {
        this->write("flat ");
    }
    if (flags & ModifierFlag::kNoPerspective) {
        this->write("noperspective ");
    }
 
    if (flags.isConst()) {
        this->write("const ");
    }
    if (flags.isUniform()) {
        this->write("uniform ");
    }
    if ((flags & ModifierFlag::kIn) && (flags & ModifierFlag::kOut)) {
        this->write("inout ");
    } else if (flags & ModifierFlag::kIn) {
        if (globalContext && fCaps.fGLSLGeneration < SkSL::GLSLGeneration::k130) {
            this->write(ProgramConfig::IsVertex(fProgram.fConfig->fKind) ? "attribute "
                                                                         : "varying ");
        } else {
            this->write("in ");
        }
    } else if (flags & ModifierFlag::kOut) {
        if (globalContext && fCaps.fGLSLGeneration < SkSL::GLSLGeneration::k130) {
            this->write("varying ");
        } else {
            this->write("out ");
        }
    }
 
    if (flags.isReadOnly()) {
        this->write("readonly ");
    }
    if (flags.isWriteOnly()) {
        this->write("writeonly ");
    }
    if (flags.isBuffer()) {
        this->write("buffer ");
    }
}

writePostfixExpression()

void SkSL::GLSLCodeGenerator::writePostfixExpression ( const PostfixExpression &  p, Precedence  parentPrecedence  )

protected

Definition at line 1282 of file SkSLGLSLCodeGenerator.cpp.

                                                                            {
    if (Precedence::kPostfix >= parentPrecedence) {
        this->write("(");
    }
    this->writeExpression(*p.operand(), Precedence::kPostfix);
    this->write(p.getOperator().tightOperatorName());
    if (Precedence::kPostfix >= parentPrecedence) {
        this->write(")");
    }
}

writePrefixExpression()

void SkSL::GLSLCodeGenerator::writePrefixExpression ( const PrefixExpression &  p, Precedence  parentPrecedence  )

protected

Definition at line 1270 of file SkSLGLSLCodeGenerator.cpp.

                                                                           {
    if (Precedence::kPrefix >= parentPrecedence) {
        this->write("(");
    }
    this->write(p.getOperator().tightOperatorName());
    this->writeExpression(*p.operand(), Precedence::kPrefix);
    if (Precedence::kPrefix >= parentPrecedence) {
        this->write(")");
    }
}

writeProgramElement()

void SkSL::GLSLCodeGenerator::writeProgramElement ( const ProgramElement &  e )

protected

Definition at line 1903 of file SkSLGLSLCodeGenerator.cpp.

                                                                   {
    switch (e.kind()) {
        case ProgramElement::Kind::kExtension:
            this->writeExtension(e.as<Extension>().name());
            break;
 
        case ProgramElement::Kind::kGlobalVar:
            this->writeGlobalVarDeclaration(e.as<GlobalVarDeclaration>());
            break;
 
        case ProgramElement::Kind::kInterfaceBlock:
            this->writeInterfaceBlock(e.as<InterfaceBlock>());
            break;
 
        case ProgramElement::Kind::kFunction:
            this->writeFunction(e.as<FunctionDefinition>());
            break;
 
        case ProgramElement::Kind::kFunctionPrototype:
            this->writeFunctionPrototype(e.as<FunctionPrototype>());
            break;
 
        case ProgramElement::Kind::kModifiers: {
            const ModifiersDeclaration& d = e.as<ModifiersDeclaration>();
            this->writeModifiers(d.layout(), d.modifierFlags(), /*globalContext=*/true);
            this->writeLine(";");
            break;
        }
        case ProgramElement::Kind::kStructDefinition:
            this->writeStructDefinition(e.as<StructDefinition>());
            break;
 
        default:
            SkDEBUGFAILF("unsupported program element %s\n", e.description().c_str());
            break;
    }
}

writeReturnStatement()

void SkSL::GLSLCodeGenerator::writeReturnStatement ( const ReturnStatement &  r )

protected

Definition at line 1881 of file SkSLGLSLCodeGenerator.cpp.

                                                                     {
    SkASSERT(fCurrentFunction);
 
    this->write("return");
    if (r.expression()) {
        this->write(" ");
        this->writeExpression(*r.expression(), Precedence::kExpression);
    } else if (this->shouldRewriteVoidTypedFunctions(fCurrentFunction)) {
        // We need to rewrite `return` statements to say `return 0.0` since we are converting
        // void-typed functions to return floats instead.
        this->write(" 0.0");
    }
    this->write(";");
}

writeShortCircuitWorkaroundExpression()

void SkSL::GLSLCodeGenerator::writeShortCircuitWorkaroundExpression ( const BinaryExpression &  b, Precedence  parentPrecedence  )

protected

Definition at line 1226 of file SkSLGLSLCodeGenerator.cpp.

                                                                                           {
    if (Precedence::kTernary >= parentPrecedence) {
        this->write("(");
    }
 
    // Transform:
    // a && b  =>   a ? b : false
    // a || b  =>   a ? true : b
    this->writeExpression(*b.left(), Precedence::kTernary);
    this->write(" ? ");
    if (b.getOperator().kind() == Operator::Kind::LOGICALAND) {
        this->writeExpression(*b.right(), Precedence::kTernary);
    } else {
        Literal boolTrue(Position(), /*value=*/1, fContext.fTypes.fBool.get());
        this->writeLiteral(boolTrue);
    }
    this->write(" : ");
    if (b.getOperator().kind() == Operator::Kind::LOGICALAND) {
        Literal boolFalse(Position(), /*value=*/0, fContext.fTypes.fBool.get());
        this->writeLiteral(boolFalse);
    } else {
        this->writeExpression(*b.right(), Precedence::kTernary);
    }
    if (Precedence::kTernary >= parentPrecedence) {
        this->write(")");
    }
}

writeStatement()

void SkSL::GLSLCodeGenerator::writeStatement ( const Statement &  s )

protected

Definition at line 1598 of file SkSLGLSLCodeGenerator.cpp.

                                                         {
    switch (s.kind()) {
        case Statement::Kind::kBlock:
            this->writeBlock(s.as<Block>());
            break;
        case Statement::Kind::kExpression:
            this->writeExpressionStatement(s.as<ExpressionStatement>());
            break;
        case Statement::Kind::kReturn:
            this->writeReturnStatement(s.as<ReturnStatement>());
            break;
        case Statement::Kind::kVarDeclaration:
            this->writeVarDeclaration(s.as<VarDeclaration>(), /*global=*/false);
            break;
        case Statement::Kind::kIf:
            this->writeIfStatement(s.as<IfStatement>());
            break;
        case Statement::Kind::kFor:
            this->writeForStatement(s.as<ForStatement>());
            break;
        case Statement::Kind::kDo:
            this->writeDoStatement(s.as<DoStatement>());
            break;
        case Statement::Kind::kSwitch:
            this->writeSwitchStatement(s.as<SwitchStatement>());
            break;
        case Statement::Kind::kBreak:
            this->write("break;");
            break;
        case Statement::Kind::kContinue:
            this->write("continue;");
            break;
        case Statement::Kind::kDiscard:
            this->write("discard;");
            break;
        case Statement::Kind::kNop:
            this->write(";");
            break;
        default:
            SkDEBUGFAILF("unsupported statement: %s", s.description().c_str());
            break;
    }
}

writeStructDefinition()

void SkSL::GLSLCodeGenerator::writeStructDefinition ( const StructDefinition &  s )

protected

Definition at line 356 of file SkSLGLSLCodeGenerator.cpp.

                                                                       {
    const Type& type = s.type();
    this->write("struct ");
    this->writeIdentifier(type.name());
    this->writeLine(" {");
    fIndentation++;
    for (const auto& f : type.fields()) {
        this->writeModifiers(f.fLayout, f.fModifierFlags, /*globalContext=*/false);
        this->writeTypePrecision(*f.fType);
        const Type& baseType = f.fType->isArray() ? f.fType->componentType() : *f.fType;
        this->writeType(baseType);
        this->write(" ");
        this->writeIdentifier(f.fName);
        if (f.fType->isArray()) {
            this->write("[" + std::to_string(f.fType->columns()) + "]");
        }
        this->writeLine(";");
    }
    fIndentation--;
    this->writeLine("};");
}

writeSwitchStatement()

void SkSL::GLSLCodeGenerator::writeSwitchStatement ( const SwitchStatement &  s )

protected

Definition at line 1770 of file SkSLGLSLCodeGenerator.cpp.

                                                                     {
    if (fCaps.fRewriteSwitchStatements) {
        std::string fallthroughVar = "_tmpSwitchFallthrough" + std::to_string(fVarCount++);
        std::string valueVar = "_tmpSwitchValue" + std::to_string(fVarCount++);
        std::string loopVar = "_tmpSwitchLoop" + std::to_string(fVarCount++);
        this->write("int ");
        this->write(valueVar);
        this->write(" = ");
        this->writeExpression(*s.value(), Precedence::kAssignment);
        this->write(", ");
        this->write(fallthroughVar);
        this->writeLine(" = 0;");
        this->write("for (int ");
        this->write(loopVar);
        this->write(" = 0; ");
        this->write(loopVar);
        this->write(" < 1; ");
        this->write(loopVar);
        this->writeLine("++) {");
        fIndentation++;
 
        bool firstCase = true;
        for (const std::unique_ptr<Statement>& stmt : s.cases()) {
            const SwitchCase& c = stmt->as<SwitchCase>();
            if (!c.isDefault()) {
                this->write("if ((");
                if (firstCase) {
                    firstCase = false;
                } else {
                    this->write(fallthroughVar);
                    this->write(" > 0) || (");
                }
                this->write(valueVar);
                this->write(" == ");
                this->write(std::to_string(c.value()));
                this->writeLine(")) {");
                fIndentation++;
 
                // We write the entire case-block statement here, and then set `switchFallthrough`
                // to 1. If the case-block had a break statement in it, we break out of the outer
                // for-loop entirely, meaning the `switchFallthrough` assignment never occurs, nor
                // does any code after it inside the switch. We've forbidden `continue` statements
                // inside switch case-blocks entirely, so we don't need to consider their effect on
                // control flow; see the Finalizer in FunctionDefinition::Convert.
                this->writeStatement(*c.statement());
                this->finishLine();
                this->write(fallthroughVar);
                this->write(" = 1;");
                this->writeLine();
 
                fIndentation--;
                this->writeLine("}");
            } else {
                // This is the default case. Since it's always last, we can just dump in the code.
                this->writeStatement(*c.statement());
                this->finishLine();
            }
        }
 
        fIndentation--;
        this->writeLine("}");
        return;
    }
 
    this->write("switch (");
    this->writeExpression(*s.value(), Precedence::kExpression);
    this->writeLine(") {");
    fIndentation++;
    // If a switch contains only a `default` case and nothing else, this confuses some drivers and
    // can lead to a crash. Adding a real case before the default seems to work around the bug,
    // and doesn't change the meaning of the switch. (skia:12465)
    if (s.cases().size() == 1 && s.cases().front()->as<SwitchCase>().isDefault()) {
        this->writeLine("case 0:");
    }
 
    // The GLSL spec insists that the last case in a switch statement must have an associated
    // statement. In practice, the Apple GLSL compiler crashes if that statement is a no-op, such as
    // a semicolon or an empty brace pair. (This is filed as FB11992149.) It also crashes if we put
    // two `break` statements in a row. To work around this while honoring the rules of the
    // standard, we inject an extra break if and only if the last switch-case block is empty.
    bool foundEmptyCase = false;
 
    for (const std::unique_ptr<Statement>& stmt : s.cases()) {
        const SwitchCase& c = stmt->as<SwitchCase>();
        if (c.isDefault()) {
            this->writeLine("default:");
        } else {
            this->write("case ");
            this->write(std::to_string(c.value()));
            this->writeLine(":");
        }
        if (c.statement()->isEmpty()) {
            foundEmptyCase = true;
        } else {
            foundEmptyCase = false;
            fIndentation++;
            this->writeStatement(*c.statement());
            this->finishLine();
            fIndentation--;
        }
    }
    if (foundEmptyCase) {
        fIndentation++;
        this->writeLine("break;");
        fIndentation--;
    }
    fIndentation--;
    this->finishLine();
    this->write("}");
}

writeSwizzle()

void SkSL::GLSLCodeGenerator::writeSwizzle ( const Swizzle &  swizzle )

protected

Definition at line 1144 of file SkSLGLSLCodeGenerator.cpp.

                                                           {
    this->writeExpression(*swizzle.base(), Precedence::kPostfix);
    this->write(".");
    this->write(Swizzle::MaskString(swizzle.components()));
}

writeTernaryExpression()

void SkSL::GLSLCodeGenerator::writeTernaryExpression ( const TernaryExpression &  t, Precedence  parentPrecedence  )

protected

Definition at line 1255 of file SkSLGLSLCodeGenerator.cpp.

                                                                            {
    if (Precedence::kTernary >= parentPrecedence) {
        this->write("(");
    }
    this->writeExpression(*t.test(), Precedence::kTernary);
    this->write(" ? ");
    this->writeExpression(*t.ifTrue(), Precedence::kTernary);
    this->write(" : ");
    this->writeExpression(*t.ifFalse(), Precedence::kTernary);
    if (Precedence::kTernary >= parentPrecedence) {
        this->write(")");
    }
}

writeTransposeHack()

void SkSL::GLSLCodeGenerator::writeTransposeHack ( const Expression &  mat )

protected

Definition at line 640 of file SkSLGLSLCodeGenerator.cpp.

                                                                {
    const Type& type = mat.type();
    int c = type.columns();
    int r = type.rows();
    std::string name = "transpose" + std::to_string(c) + std::to_string(r);
 
    SkASSERT(c >= 2 && c <= 4);
    SkASSERT(r >= 2 && r <= 4);
    bool* writtenThisTranspose = &fWrittenTranspose[c - 2][r - 2];
    if (!*writtenThisTranspose) {
        *writtenThisTranspose = true;
        std::string typeName = this->getTypeName(type);
        const Type& base = type.componentType();
        std::string transposed =  this->getTypeName(base.toCompound(fContext, r, c));
        fExtraFunctions.writeText((transposed + " " + name + "(" + typeName + " m) { return " +
                                   transposed + "(").c_str());
        auto separator = SkSL::String::Separator();
        for (int row = 0; row < r; ++row) {
            for (int column = 0; column < c; ++column) {
                fExtraFunctions.writeText(separator().c_str());
                fExtraFunctions.writeText(("m[" + std::to_string(column) + "][" +
                                           std::to_string(row) + "]").c_str());
            }
        }
        fExtraFunctions.writeText("); }\n");
    }
    this->write(name + "(");
    this->writeExpression(mat, Precedence::kExpression);
    this->write(")");
}

writeType()

void SkSL::GLSLCodeGenerator::writeType ( const Type &  type )

protected

Definition at line 378 of file SkSLGLSLCodeGenerator.cpp.

                                                  {
    this->writeIdentifier(this->getTypeName(type));
}

writeTypePrecision()

void SkSL::GLSLCodeGenerator::writeTypePrecision ( const Type &  type )

protected

Definition at line 1520 of file SkSLGLSLCodeGenerator.cpp.

                                                           {
    this->write(this->getTypePrecision(type));
}

writeVarDeclaration()

void SkSL::GLSLCodeGenerator::writeVarDeclaration ( const VarDeclaration &  var, bool  global  )

protected

Definition at line 1552 of file SkSLGLSLCodeGenerator.cpp.

                                                                                   {
    const Variable* var = decl.var();
    this->writeModifiers(var->layout(), var->modifierFlags(), global);
 
    if (global && !var->modifierFlags().isUniform()) {
        if (decl.baseType().typeKind() == Type::TypeKind::kSampler ||
            decl.baseType().typeKind() == Type::TypeKind::kSeparateSampler ||
            decl.baseType().typeKind() == Type::TypeKind::kTexture) {
            // We don't require the `uniform` modifier on textures/samplers, but GLSL does.
            this->write("uniform ");
        }
    }
 
    this->writeTypePrecision(decl.baseType());
    this->writeType(decl.baseType());
    this->write(" ");
    this->writeIdentifier(var->mangledName());
    if (decl.arraySize() > 0) {
        this->write("[");
        this->write(std::to_string(decl.arraySize()));
        this->write("]");
    }
    if (decl.value()) {
        this->write(" = ");
        this->writeVarInitializer(*var, *decl.value());
    }
    if (!fFoundExternalSamplerDecl &&
        var->type().matches(*fContext.fTypes.fSamplerExternalOES)) {
        if (!fCaps.fExternalTextureSupport) {
            fContext.fErrors->error(decl.position(), "external texture support is not enabled");
        } else {
            if (fCaps.externalTextureExtensionString()) {
                this->writeExtension(fCaps.externalTextureExtensionString());
            }
            if (fCaps.secondExternalTextureExtensionString()) {
                this->writeExtension(fCaps.secondExternalTextureExtensionString());
            }
            fFoundExternalSamplerDecl = true;
        }
    }
    if (!fFoundRectSamplerDecl && var->type().matches(*fContext.fTypes.fSampler2DRect)) {
        fFoundRectSamplerDecl = true;
    }
    this->write(";");
}

writeVariableReference()

void SkSL::GLSLCodeGenerator::writeVariableReference ( const VariableReference &  ref )

protected

Definition at line 1047 of file SkSLGLSLCodeGenerator.cpp.

                                                                           {
    switch (ref.variable()->layout().fBuiltin) {
        case SK_FRAGCOLOR_BUILTIN:
            if (fCaps.mustDeclareFragmentShaderOutput()) {
                this->writeIdentifier("sk_FragColor");
            } else {
                this->writeIdentifier("gl_FragColor");
            }
            break;
        case SK_SECONDARYFRAGCOLOR_BUILTIN:
            if (fCaps.fDualSourceBlendingSupport) {
                this->writeIdentifier("gl_SecondaryFragColorEXT");
            } else {
                fContext.fErrors->error(ref.position(), "'sk_SecondaryFragColor' not supported");
            }
            break;
        case SK_FRAGCOORD_BUILTIN:
            this->writeFragCoord();
            break;
        case SK_CLOCKWISE_BUILTIN:
            if (!fSetupClockwise) {
                fFunctionHeader += "    bool sk_Clockwise = gl_FrontFacing;\n";
                if (!fProgram.fConfig->fSettings.fForceNoRTFlip) {
                    fFunctionHeader += "    if (" SKSL_RTFLIP_NAME ".y < 0.0) {\n"
                                       "        sk_Clockwise = !sk_Clockwise;\n"
                                       "    }\n";
                }
                fSetupClockwise = true;
            }
            this->writeIdentifier("sk_Clockwise");
            break;
        case SK_VERTEXID_BUILTIN:
            this->writeIdentifier("gl_VertexID");
            break;
        case SK_INSTANCEID_BUILTIN:
            this->writeIdentifier("gl_InstanceID");
            break;
        case SK_LASTFRAGCOLOR_BUILTIN:
            if (fCaps.fFBFetchColorName) {
                this->write(fCaps.fFBFetchColorName);
            } else {
                fContext.fErrors->error(ref.position(), "'sk_LastFragColor' not supported");
            }
            break;
        case SK_SAMPLEMASKIN_BUILTIN:
            // GLSL defines gl_SampleMaskIn as an array of ints. SkSL defines it as a scalar uint.
            this->writeIdentifier("uint(gl_SampleMaskIn[0])");
            break;
        case SK_SAMPLEMASK_BUILTIN:
            // GLSL defines gl_SampleMask as an array of ints. SkSL defines it as a scalar uint.
            this->writeIdentifier("gl_SampleMask[0]");
            break;
        default:
            this->writeIdentifier(ref.variable()->mangledName());
            break;
    }
}

writeVarInitializer()

void SkSL::GLSLCodeGenerator::writeVarInitializer ( const Variable &  var, const Expression &  value  )

protected

Definition at line 1490 of file SkSLGLSLCodeGenerator.cpp.

                                                                                        {
    this->writeExpression(value, Precedence::kExpression);
}

Member Data Documentation

fAtLineStart

bool SkSL::GLSLCodeGenerator::fAtLineStart = false

protected

Definition at line 215 of file SkSLGLSLCodeGenerator.cpp.

fCurrentFunction

const FunctionDeclaration* SkSL::GLSLCodeGenerator::fCurrentFunction = nullptr

protected

Definition at line 216 of file SkSLGLSLCodeGenerator.cpp.

fExtensions

StringStream SkSL::GLSLCodeGenerator::fExtensions

protected

Definition at line 209 of file SkSLGLSLCodeGenerator.cpp.

fExtraFunctions

StringStream SkSL::GLSLCodeGenerator::fExtraFunctions

protected

Definition at line 211 of file SkSLGLSLCodeGenerator.cpp.

fFoundDerivatives

bool SkSL::GLSLCodeGenerator::fFoundDerivatives = false

protected

Definition at line 219 of file SkSLGLSLCodeGenerator.cpp.

fFoundExternalSamplerDecl

bool SkSL::GLSLCodeGenerator::fFoundExternalSamplerDecl = false

protected

Definition at line 220 of file SkSLGLSLCodeGenerator.cpp.

fFoundRectSamplerDecl

bool SkSL::GLSLCodeGenerator::fFoundRectSamplerDecl = false

protected

Definition at line 221 of file SkSLGLSLCodeGenerator.cpp.

fFunctionHeader

std::string SkSL::GLSLCodeGenerator::fFunctionHeader

protected

Definition at line 212 of file SkSLGLSLCodeGenerator.cpp.

fGlobals

StringStream SkSL::GLSLCodeGenerator::fGlobals

protected

Definition at line 210 of file SkSLGLSLCodeGenerator.cpp.

fIndentation

int SkSL::GLSLCodeGenerator::fIndentation = 0

protected

Definition at line 214 of file SkSLGLSLCodeGenerator.cpp.

fSetupClockwise

bool SkSL::GLSLCodeGenerator::fSetupClockwise = false

protected

Definition at line 222 of file SkSLGLSLCodeGenerator.cpp.

fSetupFragCoordWorkaround

bool SkSL::GLSLCodeGenerator::fSetupFragCoordWorkaround = false

protected

Definition at line 224 of file SkSLGLSLCodeGenerator.cpp.

fSetupFragPosition

bool SkSL::GLSLCodeGenerator::fSetupFragPosition = false

protected

Definition at line 223 of file SkSLGLSLCodeGenerator.cpp.

fVarCount

int SkSL::GLSLCodeGenerator::fVarCount = 0

protected

Definition at line 213 of file SkSLGLSLCodeGenerator.cpp.

fWrittenAbsEmulation

bool SkSL::GLSLCodeGenerator::fWrittenAbsEmulation = false

protected

Definition at line 227 of file SkSLGLSLCodeGenerator.cpp.

fWrittenDeterminant2

bool SkSL::GLSLCodeGenerator::fWrittenDeterminant2 = false

protected

Definition at line 228 of file SkSLGLSLCodeGenerator.cpp.

fWrittenDeterminant3

bool SkSL::GLSLCodeGenerator::fWrittenDeterminant3 = false

protected

Definition at line 228 of file SkSLGLSLCodeGenerator.cpp.

fWrittenDeterminant4

bool SkSL::GLSLCodeGenerator::fWrittenDeterminant4 = false

protected

Definition at line 228 of file SkSLGLSLCodeGenerator.cpp.

fWrittenInverse2

bool SkSL::GLSLCodeGenerator::fWrittenInverse2 = false

protected

Definition at line 229 of file SkSLGLSLCodeGenerator.cpp.

fWrittenInverse3

bool SkSL::GLSLCodeGenerator::fWrittenInverse3 = false

protected

Definition at line 229 of file SkSLGLSLCodeGenerator.cpp.

fWrittenInverse4

bool SkSL::GLSLCodeGenerator::fWrittenInverse4 = false

protected

Definition at line 229 of file SkSLGLSLCodeGenerator.cpp.

fWrittenTranspose

bool SkSL::GLSLCodeGenerator::fWrittenTranspose[3][3] = {}

protected

Definition at line 230 of file SkSLGLSLCodeGenerator.cpp.

{};

---

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

• third_party/skia/src/sksl/codegen/SkSLGLSLCodeGenerator.cpp