blob: e9378a8887f103a674aee8ea88b86fcb2c86d1f2 [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 "GrAllocator.h"
#include "GrGeometryProcessor.h"
#include "GrShaderVar.h"
#include "GrTypesPriv.h"
#include "glsl/GrGLSLProgramDataManager.h"
class GrGLSLProgramBuilder;
class GrGLSLVarying {
public:
bool vsVarying() const { return kVertToFrag_Varying == fVarying ||
kVertToGeo_Varying == fVarying; }
bool fsVarying() const { return kVertToFrag_Varying == fVarying ||
kGeoToFrag_Varying == fVarying; }
const char* vsOut() const { return fVsOut; }
const char* gsIn() const { return fGsIn; }
const char* gsOut() const { return fGsOut; }
const char* fsIn() const { return fFsIn; }
GrSLType type() const { return fType; }
protected:
enum Varying {
kVertToFrag_Varying,
kVertToGeo_Varying,
kGeoToFrag_Varying,
};
GrGLSLVarying(GrSLType type, Varying varying)
: fVarying(varying), fType(type), fVsOut(nullptr), fGsIn(nullptr), fGsOut(nullptr),
fFsIn(nullptr) {}
Varying fVarying;
private:
GrSLType fType;
const char* fVsOut;
const char* fGsIn;
const char* fGsOut;
const char* fFsIn;
friend class GrGLSLVaryingHandler;
};
struct GrGLSLVertToFrag : public GrGLSLVarying {
GrGLSLVertToFrag(GrSLType type)
: GrGLSLVarying(type, kVertToFrag_Varying) {}
};
struct GrGLSLVertToGeo : public GrGLSLVarying {
GrGLSLVertToGeo(GrSLType type)
: GrGLSLVarying(type, kVertToGeo_Varying) {}
};
struct GrGLSLGeoToFrag : public GrGLSLVarying {
GrGLSLGeoToFrag(GrSLType type)
: GrGLSLVarying(type, kGeoToFrag_Varying) {}
};
static const int kVaryingsPerBlock = 8;
class GrGLSLVaryingHandler {
public:
explicit GrGLSLVaryingHandler(GrGLSLProgramBuilder* program)
: fVaryings(kVaryingsPerBlock)
, fVertexInputs(kVaryingsPerBlock)
, fVertexOutputs(kVaryingsPerBlock)
, fGeomInputs(kVaryingsPerBlock)
, fGeomOutputs(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();
/*
* addVarying allows fine grained control for setting up varyings between stages. Calling this
* functions 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,
GrSLPrecision precision = kDefault_GrSLPrecision) {
SkASSERT(GrSLTypeIsFloatType(varying->type())); // Integers must use addFlatVarying.
this->internalAddVarying(name, varying, precision, false /*flat*/);
}
/*
* addFlatVarying sets up a varying whose value is constant across every fragment. The graphics
* pipeline will pull its value from the final vertex of the draw primitive (provoking vertex).
* Flat interpolation is not always supported and the user must check the caps before using.
* TODO: Some platforms can change the provoking vertex. Should we be resetting this knob?
*/
void addFlatVarying(const char* name,
GrGLSLVarying* varying,
GrSLPrecision precision = kDefault_GrSLPrecision) {
this->internalAddVarying(name, varying, precision, true /*flat*/);
}
/*
* The GP can use these calls to pass an attribute through all shaders directly to 'output' in
* the fragment shader. Though these calls affect both the vertex shader and fragment shader,
* they expect 'output' to be defined in the fragment shader before the call is made. If there
* is a geometry shader, we will simply take the value of the varying from the first vertex and
* that will be set as the output varying for all emitted vertices.
* TODO it might be nicer behavior to have a flag to declare output inside these calls
*/
void addPassThroughAttribute(const GrGeometryProcessor::Attribute*, const char* output,
GrSLPrecision = kDefault_GrSLPrecision);
void addFlatPassThroughAttribute(const GrGeometryProcessor::Attribute*, const char* output,
GrSLPrecision = kDefault_GrSLPrecision);
void emitAttributes(const GrGeometryProcessor& gp);
// 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 getGeomDecls(SkString* inputDecls, SkString* outputDecls) const;
void getFragDecls(SkString* inputDecls, SkString* outputDecls) const;
protected:
struct VaryingInfo {
GrSLType fType;
GrSLPrecision fPrecision;
bool fIsFlat;
SkString fVsOut;
SkString fGsOut;
GrShaderFlags fVisibility;
};
typedef GrTAllocator<VaryingInfo> VaryingList;
typedef GrTAllocator<GrShaderVar> VarArray;
typedef GrGLSLProgramDataManager::VaryingHandle VaryingHandle;
VaryingList fVaryings;
VarArray fVertexInputs;
VarArray fVertexOutputs;
VarArray fGeomInputs;
VarArray fGeomOutputs;
VarArray fFragInputs;
VarArray fFragOutputs;
// This is not owned by the class
GrGLSLProgramBuilder* fProgramBuilder;
private:
void internalAddVarying(const char* name, GrGLSLVarying*, GrSLPrecision, bool flat);
void writePassThroughAttribute(const GrGeometryProcessor::Attribute*, const char* output,
const GrGLSLVarying&);
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