blob: e840a4574cd6dfd3572a0000bd2500565cb19ad0 [file] [log] [blame]
/*
* Copyright 2015 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef GrGLSLVarying_DEFINED
#define GrGLSLVarying_DEFINED
#include "include/core/SkString.h"
#include "include/private/base/SkAssert.h"
#include "include/private/base/SkDebug.h"
#include "include/private/gpu/ganesh/GrTypesPriv.h"
#include "src/base/SkTBlockList.h"
#include "src/core/SkSLTypeShared.h"
#include "src/gpu/ganesh/GrShaderVar.h"
class GrGLSLProgramBuilder;
class GrGeometryProcessor;
#ifdef SK_DEBUG
static bool is_matrix(SkSLType type) {
switch (type) {
case SkSLType::kFloat2x2:
case SkSLType::kFloat3x3:
case SkSLType::kFloat4x4:
case SkSLType::kHalf2x2:
case SkSLType::kHalf3x3:
case SkSLType::kHalf4x4:
return true;
default:
return false;
}
}
#endif
class GrGLSLVarying {
public:
enum class Scope {
kVertToFrag,
kVertToGeo,
kGeoToFrag
};
GrGLSLVarying() = default;
GrGLSLVarying(SkSLType type, Scope scope = Scope::kVertToFrag)
: fType(type)
, fScope(scope) {
// Metal doesn't support varying matrices, so we disallow them everywhere for consistency
SkASSERT(!is_matrix(type));
}
void reset(SkSLType type, Scope scope = Scope::kVertToFrag) {
// Metal doesn't support varying matrices, so we disallow them everywhere for consistency
SkASSERT(!is_matrix(type));
*this = GrGLSLVarying();
fType = type;
fScope = scope;
}
SkSLType type() const { return fType; }
Scope scope() const { return fScope; }
bool isInVertexShader() const { return Scope::kGeoToFrag != fScope; }
bool isInFragmentShader() const { return Scope::kVertToGeo != fScope; }
const char* vsOut() const { SkASSERT(this->isInVertexShader()); return fVsOut; }
const char* fsIn() const { SkASSERT(this->isInFragmentShader()); return fFsIn; }
GrShaderVar vsOutVar() const {
SkASSERT(this->isInVertexShader());
return GrShaderVar(this->vsOut(), fType, GrShaderVar::TypeModifier::Out);
}
GrShaderVar fsInVar() const {
SkASSERT(this->isInFragmentShader());
return GrShaderVar(this->fsIn(), fType, GrShaderVar::TypeModifier::In);
}
private:
SkSLType fType = SkSLType::kVoid;
Scope fScope = Scope::kVertToFrag;
const char* fVsOut = nullptr;
const char* fFsIn = nullptr;
friend class GrGLSLVaryingHandler;
};
static const int kVaryingsPerBlock = 8;
class GrGLSLVaryingHandler {
public:
explicit GrGLSLVaryingHandler(GrGLSLProgramBuilder* program)
: fVaryings(kVaryingsPerBlock)
, fVertexInputs(kVaryingsPerBlock)
, fVertexOutputs(kVaryingsPerBlock)
, fFragInputs(kVaryingsPerBlock)
, fFragOutputs(kVaryingsPerBlock)
, fProgramBuilder(program)
, fDefaultInterpolationModifier(nullptr) {}
virtual ~GrGLSLVaryingHandler() {}
/**
* Notifies the varying handler that this shader will never emit geometry in perspective and
* therefore does not require perspective-correct interpolation. When supported, this allows
* varyings to use the "noperspective" keyword, which means the GPU can use cheaper math for
* interpolation.
*/
void setNoPerspective();
enum class Interpolation {
kInterpolated,
kCanBeFlat, // Use "flat" if it will be faster.
kMustBeFlat // Use "flat" even if it is known to be slow.
};
/**
* addVarying allows fine grained control for setting up varyings between stages. Calling this
* function will make sure all necessary decls are setup for the client. The client however is
* responsible for setting up all shader code (e.g "vOut = vIn;") If you just need to take an
* attribute and pass it through to an output value in a fragment shader, use
* addPassThroughAttribute.
* TODO convert most uses of addVarying to addPassThroughAttribute
*/
void addVarying(const char* name, GrGLSLVarying* varying,
Interpolation = Interpolation::kInterpolated);
/**
* The GP can use these calls to pass a vertex shader variable directly to 'output' in the
* fragment shader. Though this adds code to vertex and fragment stages, 'output' is expected to
* be defined in the fragment shader before the call is made.
* TODO it might be nicer behavior to have a flag to declare output inside these calls
*/
void addPassThroughAttribute(const GrShaderVar& vsVar,
const char* output,
Interpolation = Interpolation::kInterpolated);
void emitAttributes(const GrGeometryProcessor&);
// This should be called once all attributes and varyings have been added to the
// GrGLSLVaryingHanlder and before getting/adding any of the declarations to the shaders.
void finalize();
void getVertexDecls(SkString* inputDecls, SkString* outputDecls) const;
void getFragDecls(SkString* inputDecls, SkString* outputDecls) const;
protected:
struct VaryingInfo {
SkSLType fType;
bool fIsFlat;
SkString fVsOut;
GrShaderFlags fVisibility;
};
typedef SkTBlockList<VaryingInfo> VaryingList;
typedef SkTBlockList<GrShaderVar> VarArray;
VaryingList fVaryings;
VarArray fVertexInputs;
VarArray fVertexOutputs;
VarArray fFragInputs;
VarArray fFragOutputs;
// This is not owned by the class
GrGLSLProgramBuilder* fProgramBuilder;
private:
void addAttribute(const GrShaderVar& var);
virtual void onFinalize() = 0;
// helper function for get*Decls
void appendDecls(const VarArray& vars, SkString* out) const;
const char* fDefaultInterpolationModifier;
friend class GrGLSLProgramBuilder;
};
#endif