/*
* 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 "src/sksl/ir/SkSLType.h"
#include <cstdint>
#include <memory>
#include <string>
#include <vector>
// name of the uniform used to handle features that are sensitive to whether Y is flipped.
#define SKSL_RTFLIP_NAME
"u_skRTFlip"
namespace SkSL {
class Context;
class FunctionDeclaration;
class Pool;
class ProgramElement;
class ProgramUsage;
class SymbolTable;
struct ProgramConfig;
/** Represents a list the Uniforms contained within a Program. */
struct UniformInfo {
struct Uniform {
std::string fName;
SkSL::Type::NumberKind fKind;
int fColumns;
int fRows;
int fSlot;
};
std::vector<Uniform> fUniforms;
int fUniformSlotCount = 0;
};
/** A program's inputs and outputs. */
struct ProgramInterface {
enum RTFlip : uint8_t {
kRTFlip_None = 0b0000
'0000,
kRTFlip_FragCoord = 0b0000
'0001,
kRTFlip_Clockwise = 0b0000
'0010,
kRTFlip_Derivative = 0b0000
'0100,
};
uint8_t fRTFlipUniform = kRTFlip_None;
bool fUseLastFragColor =
false;
bool fOutputSecondaryColor =
false;
bool operator==(
const ProgramInterface& that)
const {
return fRTFlipUniform == that.fRTFlipUniform &&
fUseLastFragColor == that.fUseLastFragColor &&
fOutputSecondaryColor == that.fOutputSecondaryColor;
}
bool operator!=(
const ProgramInterface& that)
const {
return !(*
this == that); }
};
/** Represents a fully-digested program, ready for code generation. */
struct Program {
Program(std::unique_ptr<std::string> source,
std::unique_ptr<ProgramConfig> config,
std::shared_ptr<Context> context,
std::vector<std::unique_ptr<ProgramElement>> elements,
std::unique_ptr<SymbolTable> symbols,
std::unique_ptr<Pool> pool);
~Program();
class ElementsCollection {
public:
class iterator {
public:
const ProgramElement*
operator*() {
if (fShared != fSharedEnd) {
return *fShared;
}
else {
return fOwned->get();
}
}
iterator&
operator++() {
if (fShared != fSharedEnd) {
++fShared;
}
else {
++fOwned;
}
return *
this;
}
bool operator==(
const iterator& other)
const {
return fOwned == other.fOwned && fShared == other.fShared;
}
bool operator!=(
const iterator& other)
const {
return !(*
this == other);
}
private:
using Owned = std::vector<std::unique_ptr<ProgramElement>>::const_iterator;
using Shared = std::vector<
const ProgramElement*>::const_iterator;
friend class ElementsCollection;
iterator(Owned owned, Owned ownedEnd, Shared shared, Shared sharedEnd)
: fOwned(owned), fOwnedEnd(ownedEnd), fShared(shared), fSharedEnd(sharedEnd) {}
Owned fOwned;
Owned fOwnedEnd;
Shared fShared;
Shared fSharedEnd;
};
iterator begin()
const {
return iterator(fProgram.fOwnedElements.begin(), fProgram.fOwnedElements.end(),
fProgram.fSharedElements.begin(), fProgram.fSharedElements.end());
}
iterator end()
const {
return iterator(fProgram.fOwnedElements.end(), fProgram.fOwnedElements.end(),
fProgram.fSharedElements.end(), fProgram.fSharedElements.end());
}
private:
friend struct Program;
ElementsCollection(
const Program& program) : fProgram(program) {}
const Program& fProgram;
};
/**
* Iterates over *all* elements in this Program, both owned and shared (builtin). The iterator's
* value type is `const ProgramElement*`, so it's clear that you *must not* modify anything (as
* you might be mutating shared data).
*/
ElementsCollection elements()
const {
return ElementsCollection(*
this); }
/**
* Returns a function declaration with the given name; null is returned if the function doesn't
* exist or has no definition. If the function might have overloads, you can use nextOverload()
* to search for the function with the expected parameter list.
*/
const FunctionDeclaration* getFunction(
const char* functionName)
const;
std::string description()
const;
const ProgramUsage* usage()
const {
return fUsage.get(); }
std::unique_ptr<std::string> fSource;
std::unique_ptr<ProgramConfig> fConfig;
std::shared_ptr<Context> fContext;
std::unique_ptr<ProgramUsage> fUsage;
// it's important to keep fOwnedElements defined after (and thus destroyed before) fSymbols,
// because an IR element might access the symbol table during its destruction
std::unique_ptr<SymbolTable> fSymbols;
std::unique_ptr<Pool> fPool;
// Contains *only* elements owned exclusively by this program.
std::vector<std::unique_ptr<ProgramElement>> fOwnedElements;
// Contains *only* elements owned by a built-in module that are included in this program.
// Use elements() to iterate over the combined set of owned + shared elements.
std::vector<
const ProgramElement*> fSharedElements;
ProgramInterface fInterface;
using Interface = ProgramInterface;
};
}
// namespace SkSL
#endif
