src/sksl/SkSLUtil.h

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

#ifndef SKSL_UTIL
#define SKSL_UTIL

#include <cstdarg>
#include <memory>
#include "stdlib.h"
#include "string.h"
#include "include/private/SkSLDefines.h"
#include "src/sksl/SkSLLexer.h"

#ifndef SKSL_STANDALONE
#include "include/core/SkTypes.h"
#include "include/private/GrTypesPriv.h"
#if SK_SUPPORT_GPU
#include "include/gpu/GrContextOptions.h"
#include "src/gpu/GrShaderCaps.h"
#endif // SK_SUPPORT_GPU
#endif // SKSL_STANDALONE

class GrShaderCaps;

namespace SkSL {

class Context;
class OutputStream;
class StringStream;
class Type;

#if defined(SKSL_STANDALONE) || !SK_SUPPORT_GPU

// we're being compiled standalone, so we don't have access to caps...
enum GrGLSLGeneration {
    k110_GrGLSLGeneration,
    k130_GrGLSLGeneration,
    k140_GrGLSLGeneration,
    k150_GrGLSLGeneration,
    k330_GrGLSLGeneration,
    k400_GrGLSLGeneration,
    k420_GrGLSLGeneration,
    k310es_GrGLSLGeneration,
    k320es_GrGLSLGeneration,
};

class StandaloneShaderCaps {
public:
    GrGLSLGeneration fGLSLGeneration = k400_GrGLSLGeneration;
    GrGLSLGeneration generation() const {
        return fGLSLGeneration;
    }

    bool fAtan2ImplementedAsAtanYOverX = false;
    bool atan2ImplementedAsAtanYOverX() const {
        return fAtan2ImplementedAsAtanYOverX;
    }

    bool fCanUseMinAndAbsTogether = true;
    bool canUseMinAndAbsTogether() const {
        return fCanUseMinAndAbsTogether;
    }

    bool fMustForceNegatedAtanParamToFloat = false;
    bool mustForceNegatedAtanParamToFloat() const {
        return fMustForceNegatedAtanParamToFloat;
    }

    bool fMustForceNegatedLdexpParamToMultiply = false;
    bool mustForceNegatedLdexpParamToMultiply() const {
        return fMustForceNegatedLdexpParamToMultiply;
    }

    bool fShaderDerivativeSupport = true;
    bool shaderDerivativeSupport() const {
        return fShaderDerivativeSupport;
    }

    bool fUsesPrecisionModifiers = false;
    bool usesPrecisionModifiers() const {
        return fUsesPrecisionModifiers;
    }

    bool mustDeclareFragmentShaderOutput() const {
        return fGLSLGeneration > k110_GrGLSLGeneration;
    }

    bool fFBFetchSupport = false;
    bool fbFetchSupport() const {
        return fFBFetchSupport;
    }

    bool fFBFetchNeedsCustomOutput = false;
    bool fbFetchNeedsCustomOutput() const {
        return fFBFetchNeedsCustomOutput;
    }

    bool fFlatInterpolationSupport = true;
    bool flatInterpolationSupport() const {
        return fFlatInterpolationSupport;
    }

    bool fNoperspectiveInterpolationSupport = true;
    bool noperspectiveInterpolationSupport() const {
        return fNoperspectiveInterpolationSupport;
    }

    bool fMultisampleInterpolationSupport = true;
    bool multisampleInterpolationSupport() const {
        return fMultisampleInterpolationSupport;
    }

    bool fSampleMaskSupport = true;
    bool sampleMaskSupport() const {
        return fSampleMaskSupport;
    }

    bool fExternalTextureSupport = true;
    bool externalTextureSupport() const {
        return fExternalTextureSupport;
    }

    bool fMustDoOpBetweenFloorAndAbs = false;
    bool mustDoOpBetweenFloorAndAbs() const {
        return fMustDoOpBetweenFloorAndAbs;
    }

    bool fMustGuardDivisionEvenAfterExplicitZeroCheck = false;
    bool mustGuardDivisionEvenAfterExplicitZeroCheck() const {
        return fMustGuardDivisionEvenAfterExplicitZeroCheck;
    }

    bool fInBlendModesFailRandomlyForAllZeroVec = false;
    bool inBlendModesFailRandomlyForAllZeroVec() const {
        return fInBlendModesFailRandomlyForAllZeroVec;
    }

    bool fMustEnableAdvBlendEqs = false;
    bool mustEnableAdvBlendEqs() const {
        return fMustEnableAdvBlendEqs;
    }

    bool fCanUseAnyFunctionInShader = true;
    bool canUseAnyFunctionInShader() const {
        return fCanUseAnyFunctionInShader;
    }

    bool fNoDefaultPrecisionForExternalSamplers = false;
    bool noDefaultPrecisionForExternalSamplers() const {
        return fNoDefaultPrecisionForExternalSamplers;
    }

    bool fFloatIs32Bits = true;
    bool floatIs32Bits() const {
        return fFloatIs32Bits;
    }

    bool fIntegerSupport = false;
    bool integerSupport() const {
        return fIntegerSupport;
    }

    bool fNonsquareMatrixSupport = false;
    bool nonsquareMatrixSupport() const {
        return fNonsquareMatrixSupport;
    }

    bool fInverseHyperbolicSupport = false;
    bool inverseHyperbolicSupport() const {
        return fInverseHyperbolicSupport;
    }

    bool fBuiltinFMASupport = false;
    bool builtinFMASupport() const {
        return fBuiltinFMASupport;
    }

    bool fBuiltinDeterminantSupport = false;
    bool builtinDeterminantSupport() const {
        return fBuiltinDeterminantSupport;
    }

    bool fCanUseDoLoops = false;
    bool canUseDoLoops() const {
        // we define this to false in standalone so we don't use do loops while inlining in FP files
        // (which would then, being baked in, end up being used even in contexts where do loops are
        // not allowed)
        return fCanUseDoLoops;
    }

    bool fUseNodePools = true;
    bool useNodePools() const {
        return fUseNodePools;
    }

    const char* fShaderDerivativeExtensionString = nullptr;
    const char* shaderDerivativeExtensionString() const {
        return fShaderDerivativeExtensionString;
    }

    const char* fFragCoordConventionsExtensionString = nullptr;
    const char* fragCoordConventionsExtensionString() const {
        return fFragCoordConventionsExtensionString;
    }

    const char* fExternalTextureExtensionString = nullptr;
    const char* externalTextureExtensionString() const {
        return fExternalTextureExtensionString;
    }

    const char* fSecondExternalTextureExtensionString = nullptr;
    const char* secondExternalTextureExtensionString() const {
        return fSecondExternalTextureExtensionString;
    }

    const char* fVersionDeclString = "";
    const char* versionDeclString() const {
        return fVersionDeclString;
    }

    bool fCanUseFractForNegativeValues = true;
    bool canUseFractForNegativeValues() const {
        return fCanUseFractForNegativeValues;
    }

    bool fCanUseFragCoord = true;
    bool canUseFragCoord() const {
        return fCanUseFragCoord;
    }

    bool fIncompleteShortIntPrecision = false;
    bool incompleteShortIntPrecision() const {
        return fIncompleteShortIntPrecision;
    }

    bool fAddAndTrueToLoopCondition = false;
    bool addAndTrueToLoopCondition() const {
        return fAddAndTrueToLoopCondition;
    }

    bool fUnfoldShortCircuitAsTernary = false;
    bool unfoldShortCircuitAsTernary() const {
        return fUnfoldShortCircuitAsTernary;
    }

    bool fEmulateAbsIntFunction = false;
    bool emulateAbsIntFunction() const {
        return fEmulateAbsIntFunction;
    }

    bool fRewriteDoWhileLoops = false;
    bool rewriteDoWhileLoops() const {
        return fRewriteDoWhileLoops;
    }

    bool fRewriteSwitchStatements = false;
    bool rewriteSwitchStatements() const {
        return fRewriteSwitchStatements;
    }

    bool fRemovePowWithConstantExponent = false;
    bool removePowWithConstantExponent() const {
        return fRemovePowWithConstantExponent;
    }

    const char* fFBFetchColorName = nullptr;
    const char* fbFetchColorName() const {
        return fFBFetchColorName;
    }

    bool fRewriteMatrixVectorMultiply = false;
    bool rewriteMatrixVectorMultiply() const {
        return fRewriteMatrixVectorMultiply;
    }

    bool fRewriteMatrixComparisons = false;
    bool rewriteMatrixComparisons() const {
        return fRewriteMatrixComparisons;
    }
};

using ShaderCapsClass = StandaloneShaderCaps;
using ShaderCapsPointer = std::shared_ptr<StandaloneShaderCaps>;
extern StandaloneShaderCaps standaloneCaps;

#else

using ShaderCapsClass = GrShaderCaps;
using ShaderCapsPointer = sk_sp<GrShaderCaps>;

#endif  // defined(SKSL_STANDALONE) || !SK_SUPPORT_GPU

// Various sets of caps for use in tests
class ShaderCapsFactory {
public:
    static ShaderCapsPointer Default() {
        ShaderCapsPointer result = MakeShaderCaps();
        result->fVersionDeclString = "#version 400";
        result->fShaderDerivativeSupport = true;
        result->fBuiltinDeterminantSupport = true;
        result->fCanUseDoLoops = true;
        return result;
    }

    static ShaderCapsPointer Standalone() {
        return MakeShaderCaps();
    }

    static ShaderCapsPointer AddAndTrueToLoopCondition() {
        ShaderCapsPointer result = MakeShaderCaps();
        result->fVersionDeclString = "#version 400";
        result->fAddAndTrueToLoopCondition = true;
        return result;
    }

    static ShaderCapsPointer BlendModesFailRandomlyForAllZeroVec() {
        ShaderCapsPointer result = MakeShaderCaps();
        result->fInBlendModesFailRandomlyForAllZeroVec = true;
        return result;
    }

    static ShaderCapsPointer CannotUseFractForNegativeValues() {
        ShaderCapsPointer result = MakeShaderCaps();
        result->fVersionDeclString = "#version 400";
        result->fCanUseFractForNegativeValues = false;
        return result;
    }

    static ShaderCapsPointer CannotUseFragCoord() {
        ShaderCapsPointer result = MakeShaderCaps();
        result->fVersionDeclString = "#version 400";
        result->fCanUseFragCoord = false;
        return result;
    }

    static ShaderCapsPointer CannotUseMinAndAbsTogether() {
        ShaderCapsPointer result = MakeShaderCaps();
        result->fVersionDeclString = "#version 400";
        result->fCanUseMinAndAbsTogether = false;
        return result;
    }

    static ShaderCapsPointer EmulateAbsIntFunction() {
        ShaderCapsPointer result = MakeShaderCaps();
        result->fVersionDeclString = "#version 400";
        result->fEmulateAbsIntFunction = true;
        return result;
    }

    static ShaderCapsPointer FramebufferFetchSupport() {
        ShaderCapsPointer result = MakeShaderCaps();
        result->fFBFetchSupport = true;
        result->fFBFetchColorName = "gl_LastFragData[0]";
        return result;
    }

    static ShaderCapsPointer IncompleteShortIntPrecision() {
        ShaderCapsPointer result = MakeShaderCaps();
        result->fVersionDeclString = "#version 310es";
        result->fUsesPrecisionModifiers = true;
        result->fIncompleteShortIntPrecision = true;
        return result;
    }

    static ShaderCapsPointer MustForceNegatedAtanParamToFloat() {
        ShaderCapsPointer result = MakeShaderCaps();
        result->fVersionDeclString = "#version 400";
        result->fMustForceNegatedAtanParamToFloat = true;
        return result;
    }

    static ShaderCapsPointer MustForceNegatedLdexpParamToMultiply() {
        ShaderCapsPointer result = MakeShaderCaps();
        result->fVersionDeclString = "#version 400";
        result->fMustForceNegatedLdexpParamToMultiply = true;
        return result;
    }

    static ShaderCapsPointer MustGuardDivisionEvenAfterExplicitZeroCheck() {
        ShaderCapsPointer result = MakeShaderCaps();
        result->fMustGuardDivisionEvenAfterExplicitZeroCheck = true;
        return result;
    }

    static ShaderCapsPointer RemovePowWithConstantExponent() {
        ShaderCapsPointer result = MakeShaderCaps();
        result->fVersionDeclString = "#version 400";
        result->fRemovePowWithConstantExponent = true;
        return result;
    }

    static ShaderCapsPointer RewriteDoWhileLoops() {
        ShaderCapsPointer result = MakeShaderCaps();
        result->fVersionDeclString = "#version 400";
        result->fRewriteDoWhileLoops = true;
        return result;
    }

    static ShaderCapsPointer RewriteMatrixComparisons() {
        ShaderCapsPointer result = MakeShaderCaps();
        result->fRewriteMatrixComparisons = true;
        result->fUsesPrecisionModifiers = true;
        return result;
    }

    static ShaderCapsPointer RewriteMatrixVectorMultiply() {
        ShaderCapsPointer result = MakeShaderCaps();
        result->fVersionDeclString = "#version 400";
        result->fRewriteMatrixVectorMultiply = true;
        return result;
    }

    static ShaderCapsPointer RewriteSwitchStatements() {
        ShaderCapsPointer result = MakeShaderCaps();
        result->fVersionDeclString = "#version 400";
        result->fRewriteSwitchStatements = true;
        return result;
    }

    static ShaderCapsPointer SampleMaskSupport() {
        ShaderCapsPointer result = Default();
        result->fSampleMaskSupport = true;
        return result;
    }

    static ShaderCapsPointer ShaderDerivativeExtensionString() {
        ShaderCapsPointer result = MakeShaderCaps();
        result->fVersionDeclString = "#version 400";
        result->fShaderDerivativeSupport = true;
        result->fShaderDerivativeExtensionString = "GL_OES_standard_derivatives";
        result->fUsesPrecisionModifiers = true;
        return result;
    }

    static ShaderCapsPointer UnfoldShortCircuitAsTernary() {
        ShaderCapsPointer result = MakeShaderCaps();
        result->fVersionDeclString = "#version 400";
        result->fUnfoldShortCircuitAsTernary = true;
        return result;
    }

    static ShaderCapsPointer UsesPrecisionModifiers() {
        ShaderCapsPointer result = MakeShaderCaps();
        result->fVersionDeclString = "#version 400";
        result->fUsesPrecisionModifiers = true;
        return result;
    }

    static ShaderCapsPointer Version110() {
        ShaderCapsPointer result = MakeShaderCaps();
        result->fVersionDeclString = "#version 110";
        result->fGLSLGeneration = GrGLSLGeneration::k110_GrGLSLGeneration;
        return result;
    }

    static ShaderCapsPointer Version450Core() {
        ShaderCapsPointer result = MakeShaderCaps();
        result->fVersionDeclString = "#version 450 core";
        return result;
    }

private:
    static ShaderCapsPointer MakeShaderCaps();
};

#if !defined(SKSL_STANDALONE)
bool type_to_grsltype(const Context& context, const Type& type, GrSLType* outType);
#endif

void write_stringstream(const StringStream& d, OutputStream& out);

}  // namespace SkSL

#endif  // SKSL_UTIL