| /* |
| * Copyright 2016 Google Inc. |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| #include "src/sksl/SkSLCPPCodeGenerator.h" |
| |
| #include "src/sksl/SkSLCPPUniformCTypes.h" |
| #include "src/sksl/SkSLCompiler.h" |
| #include "src/sksl/SkSLHCodeGenerator.h" |
| |
| #include <algorithm> |
| |
| namespace SkSL { |
| |
| static bool needs_uniform_var(const Variable& var) { |
| return (var.fModifiers.fFlags & Modifiers::kUniform_Flag) && |
| var.fType.kind() != Type::kSampler_Kind; |
| } |
| |
| CPPCodeGenerator::CPPCodeGenerator(const Context* context, const Program* program, |
| ErrorReporter* errors, String name, OutputStream* out) |
| : INHERITED(context, program, errors, out) |
| , fName(std::move(name)) |
| , fFullName(String::printf("Gr%s", fName.c_str())) |
| , fSectionAndParameterHelper(*program, *errors) { |
| fLineEnding = "\\n"; |
| } |
| |
| void CPPCodeGenerator::writef(const char* s, va_list va) { |
| static constexpr int BUFFER_SIZE = 1024; |
| va_list copy; |
| va_copy(copy, va); |
| char buffer[BUFFER_SIZE]; |
| int length = vsnprintf(buffer, BUFFER_SIZE, s, va); |
| if (length < BUFFER_SIZE) { |
| fOut->write(buffer, length); |
| } else { |
| std::unique_ptr<char[]> heap(new char[length + 1]); |
| vsprintf(heap.get(), s, copy); |
| fOut->write(heap.get(), length); |
| } |
| va_end(copy); |
| } |
| |
| void CPPCodeGenerator::writef(const char* s, ...) { |
| va_list va; |
| va_start(va, s); |
| this->writef(s, va); |
| va_end(va); |
| } |
| |
| void CPPCodeGenerator::writeHeader() { |
| } |
| |
| bool CPPCodeGenerator::usesPrecisionModifiers() const { |
| return false; |
| } |
| |
| String CPPCodeGenerator::getTypeName(const Type& type) { |
| return type.name(); |
| } |
| |
| void CPPCodeGenerator::writeBinaryExpression(const BinaryExpression& b, |
| Precedence parentPrecedence) { |
| if (b.fOperator == Token::PERCENT) { |
| // need to use "%%" instead of "%" b/c the code will be inside of a printf |
| Precedence precedence = GetBinaryPrecedence(b.fOperator); |
| if (precedence >= parentPrecedence) { |
| this->write("("); |
| } |
| this->writeExpression(*b.fLeft, precedence); |
| this->write(" %% "); |
| this->writeExpression(*b.fRight, precedence); |
| if (precedence >= parentPrecedence) { |
| this->write(")"); |
| } |
| } else if (b.fLeft->fKind == Expression::kNullLiteral_Kind || |
| b.fRight->fKind == Expression::kNullLiteral_Kind) { |
| const Variable* var; |
| if (b.fLeft->fKind != Expression::kNullLiteral_Kind) { |
| SkASSERT(b.fLeft->fKind == Expression::kVariableReference_Kind); |
| var = &((VariableReference&) *b.fLeft).fVariable; |
| } else { |
| SkASSERT(b.fRight->fKind == Expression::kVariableReference_Kind); |
| var = &((VariableReference&) *b.fRight).fVariable; |
| } |
| SkASSERT(var->fType.kind() == Type::kNullable_Kind && |
| var->fType.componentType() == *fContext.fFragmentProcessor_Type); |
| this->write("%s"); |
| const char* op; |
| switch (b.fOperator) { |
| case Token::EQEQ: |
| op = "<"; |
| break; |
| case Token::NEQ: |
| op = ">="; |
| break; |
| default: |
| SkASSERT(false); |
| } |
| fFormatArgs.push_back("_outer." + String(var->fName) + "_index " + op + " 0 ? \"true\" " |
| ": \"false\""); |
| } else { |
| INHERITED::writeBinaryExpression(b, parentPrecedence); |
| } |
| } |
| |
| void CPPCodeGenerator::writeIndexExpression(const IndexExpression& i) { |
| const Expression& base = *i.fBase; |
| if (base.fKind == Expression::kVariableReference_Kind) { |
| int builtin = ((VariableReference&) base).fVariable.fModifiers.fLayout.fBuiltin; |
| if (SK_TRANSFORMEDCOORDS2D_BUILTIN == builtin) { |
| this->write("%s"); |
| if (i.fIndex->fKind != Expression::kIntLiteral_Kind) { |
| fErrors.error(i.fIndex->fOffset, |
| "index into sk_TransformedCoords2D must be an integer literal"); |
| return; |
| } |
| int64_t index = ((IntLiteral&) *i.fIndex).fValue; |
| String name = "sk_TransformedCoords2D_" + to_string(index); |
| fFormatArgs.push_back(name + ".c_str()"); |
| if (fWrittenTransformedCoords.find(index) == fWrittenTransformedCoords.end()) { |
| addExtraEmitCodeLine("SkString " + name + |
| " = fragBuilder->ensureCoords2D(args.fTransformedCoords[" + |
| to_string(index) + "]);"); |
| fWrittenTransformedCoords.insert(index); |
| } |
| return; |
| } else if (SK_TEXTURESAMPLERS_BUILTIN == builtin) { |
| this->write("%s"); |
| if (i.fIndex->fKind != Expression::kIntLiteral_Kind) { |
| fErrors.error(i.fIndex->fOffset, |
| "index into sk_TextureSamplers must be an integer literal"); |
| return; |
| } |
| int64_t index = ((IntLiteral&) *i.fIndex).fValue; |
| fFormatArgs.push_back(" fragBuilder->getProgramBuilder()->samplerVariable(" |
| "args.fTexSamplers[" + to_string(index) + "])"); |
| return; |
| } |
| } |
| INHERITED::writeIndexExpression(i); |
| } |
| |
| static String default_value(const Type& type) { |
| if (type.fName == "bool") { |
| return "false"; |
| } |
| switch (type.kind()) { |
| case Type::kScalar_Kind: return "0"; |
| case Type::kVector_Kind: return type.name() + "(0)"; |
| case Type::kMatrix_Kind: return type.name() + "(1)"; |
| default: ABORT("unsupported default_value type\n"); |
| } |
| } |
| |
| static String default_value(const Variable& var) { |
| if (var.fModifiers.fLayout.fCType == SkSL::Layout::CType::kSkPMColor4f) { |
| return "{SK_FloatNaN, SK_FloatNaN, SK_FloatNaN, SK_FloatNaN}"; |
| } |
| return default_value(var.fType); |
| } |
| |
| static bool is_private(const Variable& var) { |
| return !(var.fModifiers.fFlags & Modifiers::kUniform_Flag) && |
| !(var.fModifiers.fFlags & Modifiers::kIn_Flag) && |
| var.fStorage == Variable::kGlobal_Storage && |
| var.fModifiers.fLayout.fBuiltin == -1; |
| } |
| |
| static bool is_uniform_in(const Variable& var) { |
| return (var.fModifiers.fFlags & Modifiers::kUniform_Flag) && |
| (var.fModifiers.fFlags & Modifiers::kIn_Flag) && |
| var.fType.kind() != Type::kSampler_Kind; |
| } |
| |
| void CPPCodeGenerator::writeRuntimeValue(const Type& type, const Layout& layout, |
| const String& cppCode) { |
| if (type.isFloat()) { |
| this->write("%f"); |
| fFormatArgs.push_back(cppCode); |
| } else if (type == *fContext.fInt_Type) { |
| this->write("%d"); |
| fFormatArgs.push_back(cppCode); |
| } else if (type == *fContext.fBool_Type) { |
| this->write("%s"); |
| fFormatArgs.push_back("(" + cppCode + " ? \"true\" : \"false\")"); |
| } else if (type == *fContext.fFloat2_Type || type == *fContext.fHalf2_Type) { |
| this->write(type.name() + "(%f, %f)"); |
| fFormatArgs.push_back(cppCode + ".fX"); |
| fFormatArgs.push_back(cppCode + ".fY"); |
| } else if (type == *fContext.fFloat4_Type || type == *fContext.fHalf4_Type) { |
| this->write(type.name() + "(%f, %f, %f, %f)"); |
| switch (layout.fCType) { |
| case Layout::CType::kSkPMColor: |
| fFormatArgs.push_back("SkGetPackedR32(" + cppCode + ") / 255.0"); |
| fFormatArgs.push_back("SkGetPackedG32(" + cppCode + ") / 255.0"); |
| fFormatArgs.push_back("SkGetPackedB32(" + cppCode + ") / 255.0"); |
| fFormatArgs.push_back("SkGetPackedA32(" + cppCode + ") / 255.0"); |
| break; |
| case Layout::CType::kSkPMColor4f: |
| fFormatArgs.push_back(cppCode + ".fR"); |
| fFormatArgs.push_back(cppCode + ".fG"); |
| fFormatArgs.push_back(cppCode + ".fB"); |
| fFormatArgs.push_back(cppCode + ".fA"); |
| break; |
| case Layout::CType::kSkVector4: |
| fFormatArgs.push_back(cppCode + ".fData[0]"); |
| fFormatArgs.push_back(cppCode + ".fData[1]"); |
| fFormatArgs.push_back(cppCode + ".fData[2]"); |
| fFormatArgs.push_back(cppCode + ".fData[3]"); |
| break; |
| case Layout::CType::kSkRect: // fall through |
| case Layout::CType::kDefault: |
| fFormatArgs.push_back(cppCode + ".left()"); |
| fFormatArgs.push_back(cppCode + ".top()"); |
| fFormatArgs.push_back(cppCode + ".right()"); |
| fFormatArgs.push_back(cppCode + ".bottom()"); |
| break; |
| default: |
| SkASSERT(false); |
| } |
| } else if (type.kind() == Type::kEnum_Kind) { |
| this->write("%d"); |
| fFormatArgs.push_back("(int) " + cppCode); |
| } else if (type == *fContext.fInt4_Type || |
| type == *fContext.fShort4_Type || |
| type == *fContext.fByte4_Type) { |
| this->write(type.name() + "(%d, %d, %d, %d)"); |
| fFormatArgs.push_back(cppCode + ".left()"); |
| fFormatArgs.push_back(cppCode + ".top()"); |
| fFormatArgs.push_back(cppCode + ".right()"); |
| fFormatArgs.push_back(cppCode + ".bottom()"); |
| } else { |
| printf("unsupported runtime value type '%s'\n", String(type.fName).c_str()); |
| SkASSERT(false); |
| } |
| } |
| |
| void CPPCodeGenerator::writeVarInitializer(const Variable& var, const Expression& value) { |
| if (is_private(var)) { |
| this->writeRuntimeValue(var.fType, var.fModifiers.fLayout, var.fName); |
| } else { |
| this->writeExpression(value, kTopLevel_Precedence); |
| } |
| } |
| |
| String CPPCodeGenerator::getSamplerHandle(const Variable& var) { |
| int samplerCount = 0; |
| for (const auto param : fSectionAndParameterHelper.getParameters()) { |
| if (&var == param) { |
| return "args.fTexSamplers[" + to_string(samplerCount) + "]"; |
| } |
| if (param->fType.kind() == Type::kSampler_Kind) { |
| ++samplerCount; |
| } |
| } |
| ABORT("should have found sampler in parameters\n"); |
| } |
| |
| void CPPCodeGenerator::writeIntLiteral(const IntLiteral& i) { |
| this->write(to_string((int32_t) i.fValue)); |
| } |
| |
| void CPPCodeGenerator::writeSwizzle(const Swizzle& swizzle) { |
| if (fCPPMode) { |
| SkASSERT(swizzle.fComponents.size() == 1); // no support for multiple swizzle components yet |
| this->writeExpression(*swizzle.fBase, kPostfix_Precedence); |
| switch (swizzle.fComponents[0]) { |
| case 0: this->write(".left()"); break; |
| case 1: this->write(".top()"); break; |
| case 2: this->write(".right()"); break; |
| case 3: this->write(".bottom()"); break; |
| } |
| } else { |
| INHERITED::writeSwizzle(swizzle); |
| } |
| } |
| |
| void CPPCodeGenerator::writeVariableReference(const VariableReference& ref) { |
| if (fCPPMode) { |
| this->write(ref.fVariable.fName); |
| return; |
| } |
| switch (ref.fVariable.fModifiers.fLayout.fBuiltin) { |
| case SK_INCOLOR_BUILTIN: |
| this->write("%s"); |
| // EmitArgs.fInputColor is automatically set to half4(1) if |
| // no input was specified |
| fFormatArgs.push_back(String("args.fInputColor")); |
| break; |
| case SK_OUTCOLOR_BUILTIN: |
| this->write("%s"); |
| fFormatArgs.push_back(String("args.fOutputColor")); |
| break; |
| case SK_WIDTH_BUILTIN: |
| this->write("sk_Width"); |
| break; |
| case SK_HEIGHT_BUILTIN: |
| this->write("sk_Height"); |
| break; |
| default: |
| if (ref.fVariable.fType.kind() == Type::kSampler_Kind) { |
| this->write("%s"); |
| fFormatArgs.push_back("fragBuilder->getProgramBuilder()->samplerVariable(" + |
| this->getSamplerHandle(ref.fVariable) + ")"); |
| return; |
| } |
| if (ref.fVariable.fModifiers.fFlags & Modifiers::kUniform_Flag) { |
| this->write("%s"); |
| String name = ref.fVariable.fName; |
| String var = String::printf("args.fUniformHandler->getUniformCStr(%sVar)", |
| HCodeGenerator::FieldName(name.c_str()).c_str()); |
| String code; |
| if (ref.fVariable.fModifiers.fLayout.fWhen.fLength) { |
| code = String::printf("%sVar.isValid() ? %s : \"%s\"", |
| HCodeGenerator::FieldName(name.c_str()).c_str(), |
| var.c_str(), |
| default_value(ref.fVariable.fType).c_str()); |
| } else { |
| code = var; |
| } |
| fFormatArgs.push_back(code); |
| } else if (SectionAndParameterHelper::IsParameter(ref.fVariable)) { |
| String name(ref.fVariable.fName); |
| this->writeRuntimeValue(ref.fVariable.fType, ref.fVariable.fModifiers.fLayout, |
| String::printf("_outer.%s", name.c_str()).c_str()); |
| } else { |
| this->write(ref.fVariable.fName); |
| } |
| } |
| } |
| |
| void CPPCodeGenerator::writeIfStatement(const IfStatement& s) { |
| if (s.fIsStatic) { |
| this->write("@"); |
| } |
| INHERITED::writeIfStatement(s); |
| } |
| |
| void CPPCodeGenerator::writeReturnStatement(const ReturnStatement& s) { |
| if (fInMain) { |
| fErrors.error(s.fOffset, "fragmentProcessor main() may not contain return statements"); |
| } |
| INHERITED::writeReturnStatement(s); |
| } |
| |
| void CPPCodeGenerator::writeSwitchStatement(const SwitchStatement& s) { |
| if (s.fIsStatic) { |
| this->write("@"); |
| } |
| INHERITED::writeSwitchStatement(s); |
| } |
| |
| void CPPCodeGenerator::writeFieldAccess(const FieldAccess& access) { |
| if (access.fBase->fType.name() == "fragmentProcessor") { |
| // Special field access on fragment processors are converted into function calls on |
| // GrFragmentProcessor's getters. |
| if (access.fBase->fKind != Expression::kVariableReference_Kind) { |
| fErrors.error(access.fBase->fOffset, "fragmentProcessor must be a reference\n"); |
| return; |
| } |
| |
| const Type::Field& field = fContext.fFragmentProcessor_Type->fields()[access.fFieldIndex]; |
| const Variable& var = ((const VariableReference&) *access.fBase).fVariable; |
| String cppAccess = String::printf("_outer.childProcessor(_outer.%s_index).%s()", |
| String(var.fName).c_str(), |
| String(field.fName).c_str()); |
| |
| if (fCPPMode) { |
| this->write(cppAccess.c_str()); |
| } else { |
| writeRuntimeValue(*field.fType, Layout(), cppAccess); |
| } |
| return; |
| } |
| INHERITED::writeFieldAccess(access); |
| } |
| |
| int CPPCodeGenerator::getChildFPIndex(const Variable& var) const { |
| int index = 0; |
| bool found = false; |
| for (const auto& p : fProgram) { |
| if (ProgramElement::kVar_Kind == p.fKind) { |
| const VarDeclarations& decls = (const VarDeclarations&) p; |
| for (const auto& raw : decls.fVars) { |
| const VarDeclaration& decl = (VarDeclaration&) *raw; |
| if (decl.fVar == &var) { |
| found = true; |
| } else if (decl.fVar->fType.nonnullable() == *fContext.fFragmentProcessor_Type) { |
| ++index; |
| } |
| } |
| } |
| if (found) { |
| break; |
| } |
| } |
| SkASSERT(found); |
| return index; |
| } |
| |
| void CPPCodeGenerator::writeFunctionCall(const FunctionCall& c) { |
| if (c.fFunction.fBuiltin && c.fFunction.fName == "process") { |
| // Sanity checks that are detected by function definition in sksl_fp.inc |
| SkASSERT(c.fArguments.size() == 1 || c.fArguments.size() == 2); |
| SkASSERT("fragmentProcessor" == c.fArguments[0]->fType.name() || |
| "fragmentProcessor?" == c.fArguments[0]->fType.name()); |
| |
| // Actually fail during compilation if arguments with valid types are |
| // provided that are not variable references, since process() is a |
| // special function that impacts code emission. |
| if (c.fArguments[0]->fKind != Expression::kVariableReference_Kind) { |
| fErrors.error(c.fArguments[0]->fOffset, |
| "process()'s fragmentProcessor argument must be a variable reference\n"); |
| return; |
| } |
| if (c.fArguments.size() > 1) { |
| // Second argument must also be a half4 expression |
| SkASSERT("half4" == c.fArguments[1]->fType.name()); |
| } |
| const Variable& child = ((const VariableReference&) *c.fArguments[0]).fVariable; |
| int index = getChildFPIndex(child); |
| |
| // Start a new extra emit code section so that the emitted child processor can depend on |
| // sksl variables defined in earlier sksl code. |
| this->newExtraEmitCodeBlock(); |
| |
| // Set to the empty string when no input color parameter should be emitted, which means this |
| // must be properly formatted with a prefixed comma when the parameter should be inserted |
| // into the emitChild() parameter list. |
| String inputArg; |
| if (c.fArguments.size() > 1) { |
| SkASSERT(c.fArguments.size() == 2); |
| // Use the emitChild() variant that accepts an input color, so convert the 2nd |
| // argument's expression into C++ code that produces sksl stored in an SkString. |
| String inputName = "_input" + to_string(index); |
| addExtraEmitCodeLine(convertSKSLExpressionToCPP(*c.fArguments[1], inputName)); |
| |
| // emitChild() needs a char* |
| inputArg = ", " + inputName + ".c_str()"; |
| } |
| |
| // Write the output handling after the possible input handling |
| String childName = "_child" + to_string(index); |
| addExtraEmitCodeLine("SkString " + childName + "(\"" + childName + "\");"); |
| if (c.fArguments[0]->fType.kind() == Type::kNullable_Kind) { |
| addExtraEmitCodeLine("if (_outer." + String(child.fName) + "_index >= 0) {\n "); |
| } |
| addExtraEmitCodeLine("this->emitChild(_outer." + String(child.fName) + "_index" + |
| inputArg + ", &" + childName + ", args);"); |
| if (c.fArguments[0]->fType.kind() == Type::kNullable_Kind) { |
| // Null FPs are not emitted, but their output can still be referenced in dependent |
| // expressions - thus we always declare the variable. |
| // Note: this is essentially dead code required to satisfy the compiler, because |
| // 'process' function calls should always be guarded at a higher level, in the .fp |
| // source. |
| addExtraEmitCodeLine( |
| "} else {" |
| " fragBuilder->codeAppendf(\"half4 %s;\", " + childName + ".c_str());" |
| "}"); |
| } |
| this->write("%s"); |
| fFormatArgs.push_back(childName + ".c_str()"); |
| return; |
| } |
| INHERITED::writeFunctionCall(c); |
| if (c.fFunction.fBuiltin && c.fFunction.fName == "texture") { |
| this->write(".%s"); |
| SkASSERT(c.fArguments.size() >= 1); |
| SkASSERT(c.fArguments[0]->fKind == Expression::kVariableReference_Kind); |
| String sampler = this->getSamplerHandle(((VariableReference&) *c.fArguments[0]).fVariable); |
| fFormatArgs.push_back("fragBuilder->getProgramBuilder()->samplerSwizzle(" + sampler + |
| ").c_str()"); |
| } |
| } |
| |
| void CPPCodeGenerator::writeFunction(const FunctionDefinition& f) { |
| if (f.fDeclaration.fName == "main") { |
| fFunctionHeader = ""; |
| OutputStream* oldOut = fOut; |
| StringStream buffer; |
| fOut = &buffer; |
| fInMain = true; |
| for (const auto& s : ((Block&) *f.fBody).fStatements) { |
| this->writeStatement(*s); |
| this->writeLine(); |
| } |
| fInMain = false; |
| |
| fOut = oldOut; |
| this->write(fFunctionHeader); |
| this->write(buffer.str()); |
| } else { |
| INHERITED::writeFunction(f); |
| } |
| } |
| |
| void CPPCodeGenerator::writeSetting(const Setting& s) { |
| static constexpr const char* kPrefix = "sk_Args."; |
| if (!strncmp(s.fName.c_str(), kPrefix, strlen(kPrefix))) { |
| const char* name = s.fName.c_str() + strlen(kPrefix); |
| this->writeRuntimeValue(s.fType, Layout(), HCodeGenerator::FieldName(name).c_str()); |
| } else { |
| this->write(s.fName.c_str()); |
| } |
| } |
| |
| bool CPPCodeGenerator::writeSection(const char* name, const char* prefix) { |
| const Section* s = fSectionAndParameterHelper.getSection(name); |
| if (s) { |
| this->writef("%s%s", prefix, s->fText.c_str()); |
| return true; |
| } |
| return false; |
| } |
| |
| void CPPCodeGenerator::writeProgramElement(const ProgramElement& p) { |
| if (p.fKind == ProgramElement::kSection_Kind) { |
| return; |
| } |
| if (p.fKind == ProgramElement::kVar_Kind) { |
| const VarDeclarations& decls = (const VarDeclarations&) p; |
| if (!decls.fVars.size()) { |
| return; |
| } |
| const Variable& var = *((VarDeclaration&) *decls.fVars[0]).fVar; |
| if (var.fModifiers.fFlags & (Modifiers::kIn_Flag | Modifiers::kUniform_Flag) || |
| -1 != var.fModifiers.fLayout.fBuiltin) { |
| return; |
| } |
| } |
| INHERITED::writeProgramElement(p); |
| } |
| |
| void CPPCodeGenerator::addUniform(const Variable& var) { |
| if (!needs_uniform_var(var)) { |
| return; |
| } |
| const char* type; |
| if (var.fType == *fContext.fFloat_Type) { |
| type = "kFloat_GrSLType"; |
| } else if (var.fType == *fContext.fHalf_Type) { |
| type = "kHalf_GrSLType"; |
| } else if (var.fType == *fContext.fFloat2_Type) { |
| type = "kFloat2_GrSLType"; |
| } else if (var.fType == *fContext.fHalf2_Type) { |
| type = "kHalf2_GrSLType"; |
| } else if (var.fType == *fContext.fFloat4_Type) { |
| type = "kFloat4_GrSLType"; |
| } else if (var.fType == *fContext.fHalf4_Type) { |
| type = "kHalf4_GrSLType"; |
| } else if (var.fType == *fContext.fFloat4x4_Type) { |
| type = "kFloat4x4_GrSLType"; |
| } else if (var.fType == *fContext.fHalf4x4_Type) { |
| type = "kHalf4x4_GrSLType"; |
| } else { |
| ABORT("unsupported uniform type: %s %s;\n", String(var.fType.fName).c_str(), |
| String(var.fName).c_str()); |
| } |
| if (var.fModifiers.fLayout.fWhen.fLength) { |
| this->writef(" if (%s) {\n ", String(var.fModifiers.fLayout.fWhen).c_str()); |
| } |
| String name(var.fName); |
| this->writef(" %sVar = args.fUniformHandler->addUniform(kFragment_GrShaderFlag, %s, " |
| "\"%s\");\n", HCodeGenerator::FieldName(name.c_str()).c_str(), type, |
| name.c_str()); |
| if (var.fModifiers.fLayout.fWhen.fLength) { |
| this->write(" }\n"); |
| } |
| } |
| |
| void CPPCodeGenerator::writeInputVars() { |
| } |
| |
| void CPPCodeGenerator::writePrivateVars() { |
| for (const auto& p : fProgram) { |
| if (ProgramElement::kVar_Kind == p.fKind) { |
| const VarDeclarations& decls = (const VarDeclarations&) p; |
| for (const auto& raw : decls.fVars) { |
| VarDeclaration& decl = (VarDeclaration&) *raw; |
| if (is_private(*decl.fVar)) { |
| if (decl.fVar->fType == *fContext.fFragmentProcessor_Type) { |
| fErrors.error(decl.fOffset, |
| "fragmentProcessor variables must be declared 'in'"); |
| return; |
| } |
| this->writef("%s %s = %s;\n", |
| HCodeGenerator::FieldType(fContext, decl.fVar->fType, |
| decl.fVar->fModifiers.fLayout).c_str(), |
| String(decl.fVar->fName).c_str(), |
| default_value(*decl.fVar).c_str()); |
| } else if (decl.fVar->fModifiers.fLayout.fFlags & Layout::kTracked_Flag) { |
| // An auto-tracked uniform in variable, so add a field to hold onto the prior |
| // state. Note that tracked variables must be uniform in's and that is validated |
| // before writePrivateVars() is called. |
| const UniformCTypeMapper* mapper = UniformCTypeMapper::Get(fContext, *decl.fVar); |
| SkASSERT(mapper && mapper->supportsTracking()); |
| |
| String name = HCodeGenerator::FieldName(String(decl.fVar->fName).c_str()); |
| // The member statement is different if the mapper reports a default value |
| if (mapper->defaultValue().size() > 0) { |
| this->writef("%s %sPrev = %s;\n", |
| Layout::CTypeToStr(mapper->ctype()), name.c_str(), |
| mapper->defaultValue().c_str()); |
| } else { |
| this->writef("%s %sPrev;\n", |
| Layout::CTypeToStr(mapper->ctype()), name.c_str()); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| void CPPCodeGenerator::writePrivateVarValues() { |
| for (const auto& p : fProgram) { |
| if (ProgramElement::kVar_Kind == p.fKind) { |
| const VarDeclarations& decls = (const VarDeclarations&) p; |
| for (const auto& raw : decls.fVars) { |
| VarDeclaration& decl = (VarDeclaration&) *raw; |
| if (is_private(*decl.fVar) && decl.fValue) { |
| this->writef("%s = ", String(decl.fVar->fName).c_str()); |
| fCPPMode = true; |
| this->writeExpression(*decl.fValue, kAssignment_Precedence); |
| fCPPMode = false; |
| this->write(";\n"); |
| } |
| } |
| } |
| } |
| } |
| |
| static bool is_accessible(const Variable& var) { |
| const Type& type = var.fType.nonnullable(); |
| return Type::kSampler_Kind != type.kind() && |
| Type::kOther_Kind != type.kind(); |
| } |
| |
| void CPPCodeGenerator::newExtraEmitCodeBlock() { |
| // This should only be called when emitting SKSL for emitCode(), which can be detected if the |
| // cpp buffer is not null, and the cpp buffer is not the current output. |
| SkASSERT(fCPPBuffer && fCPPBuffer != fOut); |
| |
| // Start a new block as an empty string |
| fExtraEmitCodeBlocks.push_back(""); |
| // Mark its location in the output buffer, uses ${\d} for the token since ${} will not occur in |
| // valid sksl and makes detection trivial. |
| this->writef("${%zu}", fExtraEmitCodeBlocks.size() - 1); |
| } |
| |
| void CPPCodeGenerator::addExtraEmitCodeLine(const String& toAppend) { |
| SkASSERT(fExtraEmitCodeBlocks.size() > 0); |
| String& currentBlock = fExtraEmitCodeBlocks[fExtraEmitCodeBlocks.size() - 1]; |
| // Automatically add indentation and newline |
| currentBlock += " " + toAppend + "\n"; |
| } |
| |
| void CPPCodeGenerator::flushEmittedCode() { |
| if (fCPPBuffer == nullptr) { |
| // Not actually within writeEmitCode() so nothing to flush |
| return; |
| } |
| |
| StringStream* skslBuffer = static_cast<StringStream*>(fOut); |
| |
| String sksl = skslBuffer->str(); |
| // Empty the accumulation buffer since its current contents are consumed. |
| skslBuffer->reset(); |
| |
| // Switch to the cpp buffer |
| fOut = fCPPBuffer; |
| |
| // Iterate through the sksl, keeping track of where the last statement ended (e.g. the latest |
| // encountered ';', '{', or '}'). If an extra emit code block token is encountered then the |
| // code from 0 to last statement end is sent to writeCodeAppend, the extra code block is |
| // appended to the cpp buffer, and then the sksl string is trimmed to start where the last |
| // statement left off (minus the encountered token). |
| size_t i = 0; |
| int flushPoint = -1; |
| int tokenStart = -1; |
| while (i < sksl.size()) { |
| if (tokenStart >= 0) { |
| // Looking for the end of the token |
| if (sksl[i] == '}') { |
| // Must append the sksl from 0 to flushPoint (inclusive) then the extra code |
| // accumulated in the block with index parsed from chars [tokenStart+2, i-1] |
| String toFlush = String(sksl.c_str(), flushPoint + 1); |
| // writeCodeAppend automatically removes the format args that it consumed, so |
| // fFormatArgs will be in a valid state for any future sksl |
| this->writeCodeAppend(toFlush); |
| |
| int codeBlock = stoi(String(sksl.c_str() + tokenStart + 2, i - tokenStart - 2)); |
| SkASSERT(codeBlock < (int) fExtraEmitCodeBlocks.size()); |
| if (fExtraEmitCodeBlocks[codeBlock].size() > 0) { |
| this->write(fExtraEmitCodeBlocks[codeBlock].c_str()); |
| } |
| |
| // Now reset the sksl buffer to start after the flush point, but remove the token. |
| String compacted = String(sksl.c_str() + flushPoint + 1, |
| tokenStart - flushPoint - 1); |
| if (i < sksl.size() - 1) { |
| compacted += String(sksl.c_str() + i + 1, sksl.size() - i - 1); |
| } |
| sksl = compacted; |
| |
| // And reset iteration |
| i = -1; |
| flushPoint = -1; |
| tokenStart = -1; |
| } |
| } else { |
| // Looking for the start of extra emit block tokens, and tracking when statements end |
| if (sksl[i] == ';' || sksl[i] == '{' || sksl[i] == '}') { |
| flushPoint = i; |
| } else if (i < sksl.size() - 1 && sksl[i] == '$' && sksl[i + 1] == '{') { |
| // found an extra emit code block token |
| tokenStart = i++; |
| } |
| } |
| i++; |
| } |
| |
| // Once we've gone through the sksl string to this point, there are no remaining extra emit |
| // code blocks to interleave, so append the remainder as usual. |
| this->writeCodeAppend(sksl); |
| |
| // After appending, switch back to the emptied sksl buffer and reset the extra code blocks |
| fOut = skslBuffer; |
| fExtraEmitCodeBlocks.clear(); |
| } |
| |
| void CPPCodeGenerator::writeCodeAppend(const String& code) { |
| // codeAppendf can only handle appending 1024 bytes at a time, so we need to break the string |
| // into chunks. Unfortunately we can't tell exactly how long the string is going to end up, |
| // because printf escape sequences get replaced by strings of unknown length, but keeping the |
| // format string below 512 bytes is probably safe. |
| static constexpr size_t maxChunkSize = 512; |
| size_t start = 0; |
| size_t index = 0; |
| size_t argStart = 0; |
| size_t argCount; |
| while (index < code.size()) { |
| argCount = 0; |
| this->write(" fragBuilder->codeAppendf(\""); |
| while (index < code.size() && index < start + maxChunkSize) { |
| if ('%' == code[index]) { |
| if (index == start + maxChunkSize - 1 || index == code.size() - 1) { |
| break; |
| } |
| if (code[index + 1] != '%') { |
| ++argCount; |
| } |
| } else if ('\\' == code[index] && index == start + maxChunkSize - 1) { |
| // avoid splitting an escape sequence that happens to fall across a chunk boundary |
| break; |
| } |
| ++index; |
| } |
| fOut->write(code.c_str() + start, index - start); |
| this->write("\""); |
| for (size_t i = argStart; i < argStart + argCount; ++i) { |
| this->writef(", %s", fFormatArgs[i].c_str()); |
| } |
| this->write(");\n"); |
| argStart += argCount; |
| start = index; |
| } |
| |
| // argStart is equal to the number of fFormatArgs that were consumed |
| // so they should be removed from the list |
| if (argStart > 0) { |
| fFormatArgs.erase(fFormatArgs.begin(), fFormatArgs.begin() + argStart); |
| } |
| } |
| |
| String CPPCodeGenerator::convertSKSLExpressionToCPP(const Expression& e, |
| const String& cppVar) { |
| // To do this conversion, we temporarily switch the sksl output stream |
| // to an empty stringstream and reset the format args to empty. |
| OutputStream* oldSKSL = fOut; |
| StringStream exprBuffer; |
| fOut = &exprBuffer; |
| |
| std::vector<String> oldArgs(fFormatArgs); |
| fFormatArgs.clear(); |
| |
| // Convert the argument expression into a format string and args |
| this->writeExpression(e, Precedence::kTopLevel_Precedence); |
| std::vector<String> newArgs(fFormatArgs); |
| String expr = exprBuffer.str(); |
| |
| // After generating, restore the original output stream and format args |
| fFormatArgs = oldArgs; |
| fOut = oldSKSL; |
| |
| // The sksl written to exprBuffer is not processed by flushEmittedCode(), so any extra emit code |
| // block tokens won't get handled. So we need to strip them from the expression and stick them |
| // to the end of the original sksl stream. |
| String exprFormat = ""; |
| int tokenStart = -1; |
| for (size_t i = 0; i < expr.size(); i++) { |
| if (tokenStart >= 0) { |
| if (expr[i] == '}') { |
| // End of the token, so append the token to fOut |
| fOut->write(expr.c_str() + tokenStart, i - tokenStart + 1); |
| tokenStart = -1; |
| } |
| } else { |
| if (i < expr.size() - 1 && expr[i] == '$' && expr[i + 1] == '{') { |
| tokenStart = i++; |
| } else { |
| exprFormat += expr[i]; |
| } |
| } |
| } |
| |
| // Now build the final C++ code snippet from the format string and args |
| String cppExpr; |
| if (newArgs.size() == 0) { |
| // This was a static expression, so we can simplify the input |
| // color declaration in the emitted code to just a static string |
| cppExpr = "SkString " + cppVar + "(\"" + exprFormat + "\");"; |
| } else { |
| // String formatting must occur dynamically, so have the C++ declaration |
| // use SkStringPrintf with the format args that were accumulated |
| // when the expression was written. |
| cppExpr = "SkString " + cppVar + " = SkStringPrintf(\"" + exprFormat + "\""; |
| for (size_t i = 0; i < newArgs.size(); i++) { |
| cppExpr += ", " + newArgs[i]; |
| } |
| cppExpr += ");"; |
| } |
| return cppExpr; |
| } |
| |
| bool CPPCodeGenerator::writeEmitCode(std::vector<const Variable*>& uniforms) { |
| this->write(" void emitCode(EmitArgs& args) override {\n" |
| " GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;\n"); |
| this->writef(" const %s& _outer = args.fFp.cast<%s>();\n" |
| " (void) _outer;\n", |
| fFullName.c_str(), fFullName.c_str()); |
| for (const auto& p : fProgram) { |
| if (ProgramElement::kVar_Kind == p.fKind) { |
| const VarDeclarations& decls = (const VarDeclarations&) p; |
| for (const auto& raw : decls.fVars) { |
| VarDeclaration& decl = (VarDeclaration&) *raw; |
| String nameString(decl.fVar->fName); |
| const char* name = nameString.c_str(); |
| if (SectionAndParameterHelper::IsParameter(*decl.fVar) && |
| is_accessible(*decl.fVar)) { |
| this->writef(" auto %s = _outer.%s;\n" |
| " (void) %s;\n", |
| name, name, name); |
| } |
| } |
| } |
| } |
| this->writePrivateVarValues(); |
| for (const auto u : uniforms) { |
| this->addUniform(*u); |
| } |
| this->writeSection(EMIT_CODE_SECTION); |
| |
| // Save original buffer as the CPP buffer for flushEmittedCode() |
| fCPPBuffer = fOut; |
| StringStream skslBuffer; |
| fOut = &skslBuffer; |
| |
| this->newExtraEmitCodeBlock(); |
| bool result = INHERITED::generateCode(); |
| this->flushEmittedCode(); |
| |
| // Then restore the original CPP buffer and close the function |
| fOut = fCPPBuffer; |
| fCPPBuffer = nullptr; |
| this->write(" }\n"); |
| return result; |
| } |
| |
| void CPPCodeGenerator::writeSetData(std::vector<const Variable*>& uniforms) { |
| const char* fullName = fFullName.c_str(); |
| const Section* section = fSectionAndParameterHelper.getSection(SET_DATA_SECTION); |
| const char* pdman = section ? section->fArgument.c_str() : "pdman"; |
| this->writef(" void onSetData(const GrGLSLProgramDataManager& %s, " |
| "const GrFragmentProcessor& _proc) override {\n", |
| pdman); |
| bool wroteProcessor = false; |
| for (const auto u : uniforms) { |
| if (is_uniform_in(*u)) { |
| if (!wroteProcessor) { |
| this->writef(" const %s& _outer = _proc.cast<%s>();\n", fullName, fullName); |
| wroteProcessor = true; |
| this->writef(" {\n"); |
| } |
| |
| const UniformCTypeMapper* mapper = UniformCTypeMapper::Get(fContext, *u); |
| SkASSERT(mapper); |
| |
| String nameString(u->fName); |
| const char* name = nameString.c_str(); |
| |
| // Switches for setData behavior in the generated code |
| bool conditionalUniform = u->fModifiers.fLayout.fWhen != ""; |
| bool isTracked = u->fModifiers.fLayout.fFlags & Layout::kTracked_Flag; |
| bool needsValueDeclaration = isTracked || !mapper->canInlineUniformValue(); |
| |
| String uniformName = HCodeGenerator::FieldName(name) + "Var"; |
| |
| String indent = " "; // 8 by default, 12 when nested for conditional uniforms |
| if (conditionalUniform) { |
| // Add a pre-check to make sure the uniform was emitted |
| // before trying to send any data to the GPU |
| this->writef(" if (%s.isValid()) {\n", uniformName.c_str()); |
| indent += " "; |
| } |
| |
| String valueVar = ""; |
| if (needsValueDeclaration) { |
| valueVar.appendf("%sValue", name); |
| // Use AccessType since that will match the return type of _outer's public API. |
| String valueType = HCodeGenerator::AccessType(fContext, u->fType, |
| u->fModifiers.fLayout); |
| this->writef("%s%s %s = _outer.%s;\n", |
| indent.c_str(), valueType.c_str(), valueVar.c_str(), name); |
| } else { |
| // Not tracked and the mapper only needs to use the value once |
| // so send it a safe expression instead of the variable name |
| valueVar.appendf("(_outer.%s)", name); |
| } |
| |
| if (isTracked) { |
| SkASSERT(mapper->supportsTracking()); |
| |
| String prevVar = HCodeGenerator::FieldName(name) + "Prev"; |
| this->writef("%sif (%s) {\n" |
| "%s %s;\n" |
| "%s %s;\n" |
| "%s}\n", indent.c_str(), |
| mapper->dirtyExpression(valueVar, prevVar).c_str(), indent.c_str(), |
| mapper->saveState(valueVar, prevVar).c_str(), indent.c_str(), |
| mapper->setUniform(pdman, uniformName, valueVar).c_str(), indent.c_str()); |
| } else { |
| this->writef("%s%s;\n", indent.c_str(), |
| mapper->setUniform(pdman, uniformName, valueVar).c_str()); |
| } |
| |
| if (conditionalUniform) { |
| // Close the earlier precheck block |
| this->writef(" }\n"); |
| } |
| } |
| } |
| if (wroteProcessor) { |
| this->writef(" }\n"); |
| } |
| if (section) { |
| int samplerIndex = 0; |
| for (const auto& p : fProgram) { |
| if (ProgramElement::kVar_Kind == p.fKind) { |
| const VarDeclarations& decls = (const VarDeclarations&) p; |
| for (const auto& raw : decls.fVars) { |
| VarDeclaration& decl = (VarDeclaration&) *raw; |
| String nameString(decl.fVar->fName); |
| const char* name = nameString.c_str(); |
| if (decl.fVar->fType.kind() == Type::kSampler_Kind) { |
| this->writef(" GrSurfaceProxy& %sProxy = " |
| "*_outer.textureSampler(%d).proxy();\n", |
| name, samplerIndex); |
| this->writef(" GrTexture& %s = *%sProxy.peekTexture();\n", |
| name, name); |
| this->writef(" (void) %s;\n", name); |
| ++samplerIndex; |
| } else if (needs_uniform_var(*decl.fVar)) { |
| this->writef(" UniformHandle& %s = %sVar;\n" |
| " (void) %s;\n", |
| name, HCodeGenerator::FieldName(name).c_str(), name); |
| } else if (SectionAndParameterHelper::IsParameter(*decl.fVar) && |
| decl.fVar->fType != *fContext.fFragmentProcessor_Type) { |
| if (!wroteProcessor) { |
| this->writef(" const %s& _outer = _proc.cast<%s>();\n", fullName, |
| fullName); |
| wroteProcessor = true; |
| } |
| this->writef(" auto %s = _outer.%s;\n" |
| " (void) %s;\n", |
| name, name, name); |
| } |
| } |
| } |
| } |
| this->writeSection(SET_DATA_SECTION); |
| } |
| this->write(" }\n"); |
| } |
| |
| void CPPCodeGenerator::writeOnTextureSampler() { |
| bool foundSampler = false; |
| for (const auto& param : fSectionAndParameterHelper.getParameters()) { |
| if (param->fType.kind() == Type::kSampler_Kind) { |
| if (!foundSampler) { |
| this->writef( |
| "const GrFragmentProcessor::TextureSampler& %s::onTextureSampler(int " |
| "index) const {\n", |
| fFullName.c_str()); |
| this->writef(" return IthTextureSampler(index, %s", |
| HCodeGenerator::FieldName(String(param->fName).c_str()).c_str()); |
| foundSampler = true; |
| } else { |
| this->writef(", %s", |
| HCodeGenerator::FieldName(String(param->fName).c_str()).c_str()); |
| } |
| } |
| } |
| if (foundSampler) { |
| this->write(");\n}\n"); |
| } |
| } |
| |
| void CPPCodeGenerator::writeClone() { |
| if (!this->writeSection(CLONE_SECTION)) { |
| if (fSectionAndParameterHelper.getSection(FIELDS_SECTION)) { |
| fErrors.error(0, "fragment processors with custom @fields must also have a custom" |
| "@clone"); |
| } |
| this->writef("%s::%s(const %s& src)\n" |
| ": INHERITED(k%s_ClassID, src.optimizationFlags())", fFullName.c_str(), |
| fFullName.c_str(), fFullName.c_str(), fFullName.c_str()); |
| const auto transforms = fSectionAndParameterHelper.getSections(COORD_TRANSFORM_SECTION); |
| for (size_t i = 0; i < transforms.size(); ++i) { |
| const Section& s = *transforms[i]; |
| String fieldName = HCodeGenerator::CoordTransformName(s.fArgument, i); |
| this->writef("\n, %s(src.%s)", fieldName.c_str(), fieldName.c_str()); |
| } |
| for (const auto& param : fSectionAndParameterHelper.getParameters()) { |
| String fieldName = HCodeGenerator::FieldName(String(param->fName).c_str()); |
| if (param->fType.nonnullable() == *fContext.fFragmentProcessor_Type) { |
| this->writef("\n, %s_index(src.%s_index)", |
| fieldName.c_str(), |
| fieldName.c_str()); |
| } else { |
| this->writef("\n, %s(src.%s)", |
| fieldName.c_str(), |
| fieldName.c_str()); |
| } |
| } |
| this->writef(" {\n"); |
| int samplerCount = 0; |
| for (const auto& param : fSectionAndParameterHelper.getParameters()) { |
| if (param->fType.kind() == Type::kSampler_Kind) { |
| ++samplerCount; |
| } else if (param->fType.nonnullable() == *fContext.fFragmentProcessor_Type) { |
| String fieldName = HCodeGenerator::FieldName(String(param->fName).c_str()); |
| if (param->fType.kind() == Type::kNullable_Kind) { |
| this->writef(" if (%s_index >= 0) {\n ", fieldName.c_str()); |
| } |
| this->writef(" this->registerChildProcessor(src.childProcessor(%s_index)." |
| "clone());\n", fieldName.c_str()); |
| if (param->fType.kind() == Type::kNullable_Kind) { |
| this->writef(" }\n"); |
| } |
| } |
| } |
| if (samplerCount) { |
| this->writef(" this->setTextureSamplerCnt(%d);", samplerCount); |
| } |
| for (size_t i = 0; i < transforms.size(); ++i) { |
| const Section& s = *transforms[i]; |
| String fieldName = HCodeGenerator::CoordTransformName(s.fArgument, i); |
| this->writef(" this->addCoordTransform(&%s);\n", fieldName.c_str()); |
| } |
| this->write("}\n"); |
| this->writef("std::unique_ptr<GrFragmentProcessor> %s::clone() const {\n", |
| fFullName.c_str()); |
| this->writef(" return std::unique_ptr<GrFragmentProcessor>(new %s(*this));\n", |
| fFullName.c_str()); |
| this->write("}\n"); |
| } |
| } |
| |
| void CPPCodeGenerator::writeTest() { |
| const Section* test = fSectionAndParameterHelper.getSection(TEST_CODE_SECTION); |
| if (test) { |
| this->writef( |
| "GR_DEFINE_FRAGMENT_PROCESSOR_TEST(%s);\n" |
| "#if GR_TEST_UTILS\n" |
| "std::unique_ptr<GrFragmentProcessor> %s::TestCreate(GrProcessorTestData* %s) {\n", |
| fFullName.c_str(), |
| fFullName.c_str(), |
| test->fArgument.c_str()); |
| this->writeSection(TEST_CODE_SECTION); |
| this->write("}\n" |
| "#endif\n"); |
| } |
| } |
| |
| void CPPCodeGenerator::writeGetKey() { |
| this->writef("void %s::onGetGLSLProcessorKey(const GrShaderCaps& caps, " |
| "GrProcessorKeyBuilder* b) const {\n", |
| fFullName.c_str()); |
| for (const auto& param : fSectionAndParameterHelper.getParameters()) { |
| String nameString(param->fName); |
| const char* name = nameString.c_str(); |
| if (param->fModifiers.fLayout.fKey != Layout::kNo_Key && |
| (param->fModifiers.fFlags & Modifiers::kUniform_Flag)) { |
| fErrors.error(param->fOffset, |
| "layout(key) may not be specified on uniforms"); |
| } |
| switch (param->fModifiers.fLayout.fKey) { |
| case Layout::kKey_Key: |
| if (param->fModifiers.fLayout.fWhen.fLength) { |
| this->writef("if (%s) {", String(param->fModifiers.fLayout.fWhen).c_str()); |
| } |
| if (param->fType == *fContext.fFloat4x4_Type) { |
| ABORT("no automatic key handling for float4x4\n"); |
| } else if (param->fType == *fContext.fFloat2_Type) { |
| this->writef(" b->add32(%s.fX);\n", |
| HCodeGenerator::FieldName(name).c_str()); |
| this->writef(" b->add32(%s.fY);\n", |
| HCodeGenerator::FieldName(name).c_str()); |
| } else if (param->fType == *fContext.fFloat4_Type) { |
| this->writef(" b->add32(%s.x());\n", |
| HCodeGenerator::FieldName(name).c_str()); |
| this->writef(" b->add32(%s.y());\n", |
| HCodeGenerator::FieldName(name).c_str()); |
| this->writef(" b->add32(%s.width());\n", |
| HCodeGenerator::FieldName(name).c_str()); |
| this->writef(" b->add32(%s.height());\n", |
| HCodeGenerator::FieldName(name).c_str()); |
| } else if (param->fType == *fContext.fHalf4_Type) { |
| this->writef(" uint16_t red = SkFloatToHalf(%s.fR);\n", |
| HCodeGenerator::FieldName(name).c_str()); |
| this->writef(" uint16_t green = SkFloatToHalf(%s.fG);\n", |
| HCodeGenerator::FieldName(name).c_str()); |
| this->writef(" uint16_t blue = SkFloatToHalf(%s.fB);\n", |
| HCodeGenerator::FieldName(name).c_str()); |
| this->writef(" uint16_t alpha = SkFloatToHalf(%s.fA);\n", |
| HCodeGenerator::FieldName(name).c_str()); |
| this->write(" b->add32(((uint32_t)red << 16) | green);\n"); |
| this->write(" b->add32(((uint32_t)blue << 16) | alpha);\n"); |
| } else { |
| this->writef(" b->add32((int32_t) %s);\n", |
| HCodeGenerator::FieldName(name).c_str()); |
| } |
| if (param->fModifiers.fLayout.fWhen.fLength) { |
| this->write("}"); |
| } |
| break; |
| case Layout::kIdentity_Key: |
| if (param->fType.kind() != Type::kMatrix_Kind) { |
| fErrors.error(param->fOffset, |
| "layout(key=identity) requires matrix type"); |
| } |
| this->writef(" b->add32(%s.isIdentity() ? 1 : 0);\n", |
| HCodeGenerator::FieldName(name).c_str()); |
| break; |
| case Layout::kNo_Key: |
| break; |
| } |
| } |
| this->write("}\n"); |
| } |
| |
| bool CPPCodeGenerator::generateCode() { |
| std::vector<const Variable*> uniforms; |
| for (const auto& p : fProgram) { |
| if (ProgramElement::kVar_Kind == p.fKind) { |
| const VarDeclarations& decls = (const VarDeclarations&) p; |
| for (const auto& raw : decls.fVars) { |
| VarDeclaration& decl = (VarDeclaration&) *raw; |
| if ((decl.fVar->fModifiers.fFlags & Modifiers::kUniform_Flag) && |
| decl.fVar->fType.kind() != Type::kSampler_Kind) { |
| uniforms.push_back(decl.fVar); |
| } |
| |
| if (is_uniform_in(*decl.fVar)) { |
| // Validate the "uniform in" declarations to make sure they are fully supported, |
| // instead of generating surprising C++ |
| const UniformCTypeMapper* mapper = |
| UniformCTypeMapper::Get(fContext, *decl.fVar); |
| if (mapper == nullptr) { |
| fErrors.error(decl.fOffset, String(decl.fVar->fName) |
| + "'s type is not supported for use as a 'uniform in'"); |
| return false; |
| } |
| if (decl.fVar->fModifiers.fLayout.fFlags & Layout::kTracked_Flag) { |
| if (!mapper->supportsTracking()) { |
| fErrors.error(decl.fOffset, String(decl.fVar->fName) |
| + "'s type does not support state tracking"); |
| return false; |
| } |
| } |
| |
| } else { |
| // If it's not a uniform_in, it's an error to be tracked |
| if (decl.fVar->fModifiers.fLayout.fFlags & Layout::kTracked_Flag) { |
| fErrors.error(decl.fOffset, "Non-'in uniforms' cannot be tracked"); |
| return false; |
| } |
| } |
| } |
| } |
| } |
| const char* baseName = fName.c_str(); |
| const char* fullName = fFullName.c_str(); |
| this->writef("%s\n", HCodeGenerator::GetHeader(fProgram, fErrors).c_str()); |
| this->writef(kFragmentProcessorHeader, fullName); |
| this->writef("#include \"%s.h\"\n\n", fullName); |
| this->writeSection(CPP_SECTION); |
| this->writef("#include \"include/gpu/GrTexture.h\"\n" |
| "#include \"src/gpu/glsl/GrGLSLFragmentProcessor.h\"\n" |
| "#include \"src/gpu/glsl/GrGLSLFragmentShaderBuilder.h\"\n" |
| "#include \"src/gpu/glsl/GrGLSLProgramBuilder.h\"\n" |
| "#include \"src/sksl/SkSLCPP.h\"\n" |
| "#include \"src/sksl/SkSLUtil.h\"\n" |
| "class GrGLSL%s : public GrGLSLFragmentProcessor {\n" |
| "public:\n" |
| " GrGLSL%s() {}\n", |
| baseName, baseName); |
| bool result = this->writeEmitCode(uniforms); |
| this->write("private:\n"); |
| this->writeSetData(uniforms); |
| this->writePrivateVars(); |
| for (const auto& u : uniforms) { |
| if (needs_uniform_var(*u) && !(u->fModifiers.fFlags & Modifiers::kIn_Flag)) { |
| this->writef(" UniformHandle %sVar;\n", |
| HCodeGenerator::FieldName(String(u->fName).c_str()).c_str()); |
| } |
| } |
| for (const auto& param : fSectionAndParameterHelper.getParameters()) { |
| if (needs_uniform_var(*param)) { |
| this->writef(" UniformHandle %sVar;\n", |
| HCodeGenerator::FieldName(String(param->fName).c_str()).c_str()); |
| } |
| } |
| this->writef("};\n" |
| "GrGLSLFragmentProcessor* %s::onCreateGLSLInstance() const {\n" |
| " return new GrGLSL%s();\n" |
| "}\n", |
| fullName, baseName); |
| this->writeGetKey(); |
| this->writef("bool %s::onIsEqual(const GrFragmentProcessor& other) const {\n" |
| " const %s& that = other.cast<%s>();\n" |
| " (void) that;\n", |
| fullName, fullName, fullName); |
| for (const auto& param : fSectionAndParameterHelper.getParameters()) { |
| if (param->fType.nonnullable() == *fContext.fFragmentProcessor_Type) { |
| continue; |
| } |
| String nameString(param->fName); |
| const char* name = nameString.c_str(); |
| this->writef(" if (%s != that.%s) return false;\n", |
| HCodeGenerator::FieldName(name).c_str(), |
| HCodeGenerator::FieldName(name).c_str()); |
| } |
| this->write(" return true;\n" |
| "}\n"); |
| this->writeClone(); |
| this->writeOnTextureSampler(); |
| this->writeTest(); |
| this->writeSection(CPP_END_SECTION); |
| |
| result &= 0 == fErrors.errorCount(); |
| return result; |
| } |
| |
| } // namespace |
