blob: cf16d1fd460da56a297cb997094f86bc3b20bcee [file] [log] [blame]
/*
* 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_PROGRAM
#define SKSL_PROGRAM
#include <vector>
#include <memory>
#include "src/sksl/ir/SkSLBoolLiteral.h"
#include "src/sksl/ir/SkSLExpression.h"
#include "src/sksl/ir/SkSLFloatLiteral.h"
#include "src/sksl/ir/SkSLIntLiteral.h"
#include "src/sksl/ir/SkSLModifiers.h"
#include "src/sksl/ir/SkSLProgramElement.h"
#include "src/sksl/ir/SkSLSymbolTable.h"
#ifdef SK_VULKAN
#include "src/gpu/vk/GrVkCaps.h"
#endif
// name of the render target width uniform
#define SKSL_RTWIDTH_NAME "u_skRTWidth"
// name of the render target height uniform
#define SKSL_RTHEIGHT_NAME "u_skRTHeight"
namespace SkSL {
class Context;
/**
* Represents a fully-digested program, ready for code generation.
*/
struct Program {
struct Settings {
struct Value {
Value(bool b)
: fKind(kBool_Kind)
, fValue(b) {}
Value(int i)
: fKind(kInt_Kind)
, fValue(i) {}
Value(unsigned int i)
: fKind(kInt_Kind)
, fValue(i) {}
Value(float f)
: fKind(kFloat_Kind)
, fValueF(f) {}
std::unique_ptr<Expression> literal(const Context& context, int offset) const {
switch (fKind) {
case Program::Settings::Value::kBool_Kind:
return std::unique_ptr<Expression>(new BoolLiteral(context,
offset,
fValue));
case Program::Settings::Value::kInt_Kind:
return std::unique_ptr<Expression>(new IntLiteral(context,
offset,
fValue));
case Program::Settings::Value::kFloat_Kind:
return std::unique_ptr<Expression>(new FloatLiteral(context,
offset,
fValueF));
default:
SkASSERT(false);
return nullptr;
}
}
enum {
kBool_Kind,
kInt_Kind,
kFloat_Kind,
} fKind;
union {
int fValue; // for kBool_Kind and kInt_Kind
float fValueF; // for kFloat_Kind
};
};
#if defined(SKSL_STANDALONE) || !SK_SUPPORT_GPU
const StandaloneShaderCaps* fCaps = &standaloneCaps;
#else
const GrShaderCaps* fCaps = nullptr;
#endif
// if false, sk_FragCoord is exactly the same as gl_FragCoord. If true, the y coordinate
// must be flipped.
bool fFlipY = false;
// if false, sk_FragCoord is exactly the same as gl_FragCoord. If true, the w coordinate
// must be inversed.
bool fInverseW = false;
// If true the destination fragment color is read sk_FragColor. It must be declared inout.
bool fFragColorIsInOut = false;
// if true, Setting objects (e.g. sk_Caps.fbFetchSupport) should be replaced with their
// constant equivalents during compilation
bool fReplaceSettings = true;
// if true, all halfs are forced to be floats
bool fForceHighPrecision = false;
// if true, add -0.5 bias to LOD of all texture lookups
bool fSharpenTextures = false;
// if the program needs to create an RTHeight uniform, this is its offset in the uniform
// buffer
int fRTHeightOffset = -1;
// if the program needs to create an RTHeight uniform and is creating spriv, this is the
// binding and set number of the uniform buffer.
int fRTHeightBinding = -1;
int fRTHeightSet = -1;
// If true, remove any uncalled functions other than main(). Note that a function which
// starts out being used may end up being uncalled after optimization.
bool fRemoveDeadFunctions = true;
std::unordered_map<String, Value> fArgs;
};
struct Inputs {
// if true, this program requires the render target width uniform to be defined
bool fRTWidth;
// if true, this program requires the render target height uniform to be defined
bool fRTHeight;
// if true, this program must be recompiled if the flipY setting changes. If false, the
// program will compile to the same code regardless of the flipY setting.
bool fFlipY;
void reset() {
fRTWidth = false;
fRTHeight = false;
fFlipY = false;
}
bool isEmpty() {
return !fRTWidth && !fRTHeight && !fFlipY;
}
};
class iterator {
public:
ProgramElement& operator*() {
if (fIter1 != fEnd1) {
return **fIter1;
}
return **fIter2;
}
iterator& operator++() {
if (fIter1 != fEnd1) {
++fIter1;
return *this;
}
++fIter2;
return *this;
}
bool operator==(const iterator& other) const {
return fIter1 == other.fIter1 && fIter2 == other.fIter2;
}
bool operator!=(const iterator& other) const {
return !(*this == other);
}
private:
using inner = std::vector<std::unique_ptr<ProgramElement>>::iterator;
iterator(inner begin1, inner end1, inner begin2, inner end2)
: fIter1(begin1)
, fEnd1(end1)
, fIter2(begin2)
, fEnd2(end2) {}
inner fIter1;
inner fEnd1;
inner fIter2;
inner fEnd2;
friend struct Program;
};
class const_iterator {
public:
const ProgramElement& operator*() {
if (fIter1 != fEnd1) {
return **fIter1;
}
return **fIter2;
}
const_iterator& operator++() {
if (fIter1 != fEnd1) {
++fIter1;
return *this;
}
++fIter2;
return *this;
}
bool operator==(const const_iterator& other) const {
return fIter1 == other.fIter1 && fIter2 == other.fIter2;
}
bool operator!=(const const_iterator& other) const {
return !(*this == other);
}
private:
using inner = std::vector<std::unique_ptr<ProgramElement>>::const_iterator;
const_iterator(inner begin1, inner end1, inner begin2, inner end2)
: fIter1(begin1)
, fEnd1(end1)
, fIter2(begin2)
, fEnd2(end2) {}
inner fIter1;
inner fEnd1;
inner fIter2;
inner fEnd2;
friend struct Program;
};
enum Kind {
kFragment_Kind,
kVertex_Kind,
kGeometry_Kind,
kFragmentProcessor_Kind,
kPipelineStage_Kind,
kGeneric_Kind,
};
Program(Kind kind,
std::unique_ptr<String> source,
Settings settings,
std::shared_ptr<Context> context,
std::vector<std::unique_ptr<ProgramElement>>* inheritedElements,
std::vector<std::unique_ptr<ProgramElement>> elements,
std::shared_ptr<SymbolTable> symbols,
Inputs inputs)
: fKind(kind)
, fSource(std::move(source))
, fSettings(settings)
, fContext(context)
, fSymbols(symbols)
, fInputs(inputs)
, fInheritedElements(inheritedElements)
, fElements(std::move(elements)) {}
iterator begin() {
if (fInheritedElements) {
return iterator(fInheritedElements->begin(), fInheritedElements->end(),
fElements.begin(), fElements.end());
}
return iterator(fElements.begin(), fElements.end(), fElements.end(), fElements.end());
}
iterator end() {
if (fInheritedElements) {
return iterator(fInheritedElements->end(), fInheritedElements->end(),
fElements.end(), fElements.end());
}
return iterator(fElements.end(), fElements.end(), fElements.end(), fElements.end());
}
const_iterator begin() const {
if (fInheritedElements) {
return const_iterator(fInheritedElements->begin(), fInheritedElements->end(),
fElements.begin(), fElements.end());
}
return const_iterator(fElements.begin(), fElements.end(), fElements.end(), fElements.end());
}
const_iterator end() const {
if (fInheritedElements) {
return const_iterator(fInheritedElements->end(), fInheritedElements->end(),
fElements.end(), fElements.end());
}
return const_iterator(fElements.end(), fElements.end(), fElements.end(), fElements.end());
}
Kind fKind;
std::unique_ptr<String> fSource;
Settings fSettings;
std::shared_ptr<Context> fContext;
// it's important to keep fElements defined after (and thus destroyed before) fSymbols,
// because destroying elements can modify reference counts in symbols
std::shared_ptr<SymbolTable> fSymbols;
Inputs fInputs;
bool fIsOptimized = false;
private:
std::vector<std::unique_ptr<ProgramElement>>* fInheritedElements;
std::vector<std::unique_ptr<ProgramElement>> fElements;
friend class Compiler;
};
} // namespace
#endif