59dc41175d
This reverts commit be34882042.
Reason for revert: Test failures and shader compilation issues on Android.
Original change's description:
> Initial OpenGL Image support.
>
> This change along with recently landed changes is enough to make the new unit test work and not much else. imageLoad is support but not stores or any other image functions (atomics). Barriers in the shading language or the GL API are not yet hooked up.
>
> GOLD_TRYBOT_URL= https://gold.skia.org/search?issue=4182
>
> Change-Id: I5958b7c89e40ae5ee05f7bbaca3b3738162fe5ce
> Reviewed-on: https://skia-review.googlesource.com/4182
> Reviewed-by: Greg Daniel <egdaniel@google.com>
> Reviewed-by: Chris Dalton <csmartdalton@google.com>
> Commit-Queue: Brian Salomon <bsalomon@google.com>
>
TBR=egdaniel@google.com,bsalomon@google.com,csmartdalton@google.com,reviews@skia.org
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
Change-Id: I29a2502c296ae39ed9a999957800414ae46e6f0f
Reviewed-on: https://skia-review.googlesource.com/5129
Commit-Queue: Brian Salomon <bsalomon@google.com>
Reviewed-by: Brian Salomon <bsalomon@google.com>
344 lines
10 KiB
C++
344 lines
10 KiB
C++
/*
|
|
* 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 GrShaderVar_DEFINED
|
|
#define GrShaderVar_DEFINED
|
|
|
|
#include "SkString.h"
|
|
#include "GrTypesPriv.h"
|
|
|
|
class GrGLSLCaps;
|
|
|
|
#define USE_UNIFORM_FLOAT_ARRAYS true
|
|
|
|
/**
|
|
* Represents a variable in a shader
|
|
*/
|
|
class GrShaderVar {
|
|
public:
|
|
enum TypeModifier {
|
|
kNone_TypeModifier,
|
|
kOut_TypeModifier,
|
|
kIn_TypeModifier,
|
|
kInOut_TypeModifier,
|
|
kUniform_TypeModifier,
|
|
};
|
|
|
|
/**
|
|
* Values for array count that have special meaning. We allow 1-sized arrays.git
|
|
*/
|
|
enum {
|
|
kNonArray = 0, // not an array
|
|
kUnsizedArray = -1, // an unsized array (declared with [])
|
|
};
|
|
|
|
/**
|
|
* Defaults to a non-arry float with no precision specifier, type modifier, or layout qualifier.
|
|
*/
|
|
GrShaderVar()
|
|
: fType(kFloat_GrSLType)
|
|
, fTypeModifier(kNone_TypeModifier)
|
|
, fCount(kNonArray)
|
|
, fPrecision(kDefault_GrSLPrecision)
|
|
, fUseUniformFloatArrays(USE_UNIFORM_FLOAT_ARRAYS) {
|
|
}
|
|
|
|
GrShaderVar(const SkString& name, GrSLType type, int arrayCount = kNonArray,
|
|
GrSLPrecision precision = kDefault_GrSLPrecision)
|
|
: fType(type)
|
|
, fTypeModifier(kNone_TypeModifier)
|
|
, fCount(arrayCount)
|
|
, fPrecision(precision)
|
|
, fUseUniformFloatArrays(USE_UNIFORM_FLOAT_ARRAYS)
|
|
, fName(name) {
|
|
SkASSERT(kVoid_GrSLType != type);
|
|
fUseUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS;
|
|
}
|
|
|
|
GrShaderVar(const char* name, GrSLType type, int arrayCount = kNonArray,
|
|
GrSLPrecision precision = kDefault_GrSLPrecision)
|
|
: fType(type)
|
|
, fTypeModifier(kNone_TypeModifier)
|
|
, fCount(arrayCount)
|
|
, fPrecision(precision)
|
|
, fUseUniformFloatArrays(USE_UNIFORM_FLOAT_ARRAYS)
|
|
, fName(name) {
|
|
SkASSERT(kVoid_GrSLType != type);
|
|
fUseUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS;
|
|
}
|
|
|
|
GrShaderVar(const char* name, GrSLType type, TypeModifier typeModifier,
|
|
GrSLPrecision precision = kDefault_GrSLPrecision)
|
|
: fType(type)
|
|
, fTypeModifier(typeModifier)
|
|
, fCount(kNonArray)
|
|
, fPrecision(precision)
|
|
, fUseUniformFloatArrays(USE_UNIFORM_FLOAT_ARRAYS)
|
|
, fName(name) {
|
|
SkASSERT(kVoid_GrSLType != type);
|
|
}
|
|
|
|
GrShaderVar(const char* name, GrSLType type, TypeModifier typeModifier,
|
|
int arrayCount, GrSLPrecision precision = kDefault_GrSLPrecision)
|
|
: fType(type)
|
|
, fTypeModifier(typeModifier)
|
|
, fCount(arrayCount)
|
|
, fPrecision(precision)
|
|
, fUseUniformFloatArrays(USE_UNIFORM_FLOAT_ARRAYS)
|
|
, fName(name) {
|
|
SkASSERT(kVoid_GrSLType != type);
|
|
}
|
|
|
|
GrShaderVar(const GrShaderVar& that)
|
|
: fType(that.fType)
|
|
, fTypeModifier(that.fTypeModifier)
|
|
, fCount(that.fCount)
|
|
, fPrecision(that.fPrecision)
|
|
, fUseUniformFloatArrays(USE_UNIFORM_FLOAT_ARRAYS)
|
|
, fName(that.fName)
|
|
, fLayoutQualifier(that.fLayoutQualifier)
|
|
, fExtraModifiers(that.fExtraModifiers) {
|
|
SkASSERT(kVoid_GrSLType != that.getType());
|
|
}
|
|
|
|
/**
|
|
* Sets as a non-array.
|
|
*/
|
|
void set(GrSLType type,
|
|
const SkString& name,
|
|
TypeModifier typeModifier = kNone_TypeModifier,
|
|
GrSLPrecision precision = kDefault_GrSLPrecision,
|
|
const char* layoutQualifier = nullptr,
|
|
const char* extraModifiers = nullptr,
|
|
bool useUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS) {
|
|
SkASSERT(kVoid_GrSLType != type);
|
|
SkASSERT(kDefault_GrSLPrecision == precision || GrSLTypeAcceptsPrecision(type));
|
|
fType = type;
|
|
fTypeModifier = typeModifier;
|
|
fName = name;
|
|
fCount = kNonArray;
|
|
fPrecision = precision;
|
|
fLayoutQualifier = layoutQualifier;
|
|
if (extraModifiers) {
|
|
fExtraModifiers.printf("%s ", extraModifiers);
|
|
}
|
|
fUseUniformFloatArrays = useUniformFloatArrays;
|
|
}
|
|
|
|
/**
|
|
* Sets as a non-array.
|
|
*/
|
|
void set(GrSLType type,
|
|
const char* name,
|
|
TypeModifier typeModifier = kNone_TypeModifier,
|
|
GrSLPrecision precision = kDefault_GrSLPrecision,
|
|
const char* layoutQualifier = nullptr,
|
|
const char* extraModifiers = nullptr,
|
|
bool useUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS) {
|
|
SkASSERT(kVoid_GrSLType != type);
|
|
SkASSERT(kDefault_GrSLPrecision == precision || GrSLTypeAcceptsPrecision(type));
|
|
fType = type;
|
|
fTypeModifier = typeModifier;
|
|
fName = name;
|
|
fCount = kNonArray;
|
|
fPrecision = precision;
|
|
fLayoutQualifier = layoutQualifier;
|
|
if (extraModifiers) {
|
|
fExtraModifiers.printf("%s ", extraModifiers);
|
|
}
|
|
fUseUniformFloatArrays = useUniformFloatArrays;
|
|
}
|
|
|
|
/**
|
|
* Set all var options
|
|
*/
|
|
void set(GrSLType type,
|
|
const SkString& name,
|
|
int count,
|
|
TypeModifier typeModifier,
|
|
GrSLPrecision precision = kDefault_GrSLPrecision,
|
|
const char* layoutQualifier = nullptr,
|
|
const char* extraModifiers = nullptr,
|
|
bool useUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS) {
|
|
SkASSERT(kVoid_GrSLType != type);
|
|
SkASSERT(kDefault_GrSLPrecision == precision || GrSLTypeAcceptsPrecision(type));
|
|
fType = type;
|
|
fTypeModifier = typeModifier;
|
|
fName = name;
|
|
fCount = count;
|
|
fPrecision = precision;
|
|
fLayoutQualifier = layoutQualifier;
|
|
if (extraModifiers) {
|
|
fExtraModifiers.printf("%s ", extraModifiers);
|
|
}
|
|
fUseUniformFloatArrays = useUniformFloatArrays;
|
|
}
|
|
|
|
/**
|
|
* Set all var options
|
|
*/
|
|
void set(GrSLType type,
|
|
const char* name,
|
|
int count,
|
|
TypeModifier typeModifier,
|
|
GrSLPrecision precision = kDefault_GrSLPrecision,
|
|
const char* layoutQualifier = nullptr,
|
|
const char* extraModifiers = nullptr,
|
|
bool useUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS) {
|
|
SkASSERT(kVoid_GrSLType != type);
|
|
SkASSERT(kDefault_GrSLPrecision == precision || GrSLTypeAcceptsPrecision(type));
|
|
fType = type;
|
|
fTypeModifier = typeModifier;
|
|
fName = name;
|
|
fCount = count;
|
|
fPrecision = precision;
|
|
fLayoutQualifier = layoutQualifier;
|
|
if (extraModifiers) {
|
|
fExtraModifiers.printf("%s ", extraModifiers);
|
|
}
|
|
fUseUniformFloatArrays = useUniformFloatArrays;
|
|
}
|
|
|
|
/**
|
|
* Is the var an array.
|
|
*/
|
|
bool isArray() const { return kNonArray != fCount; }
|
|
/**
|
|
* Is this an unsized array, (i.e. declared with []).
|
|
*/
|
|
bool isUnsizedArray() const { return kUnsizedArray == fCount; }
|
|
/**
|
|
* Get the array length of the var.
|
|
*/
|
|
int getArrayCount() const { return fCount; }
|
|
/**
|
|
* Set the array length of the var
|
|
*/
|
|
void setArrayCount(int count) { fCount = count; }
|
|
/**
|
|
* Set to be a non-array.
|
|
*/
|
|
void setNonArray() { fCount = kNonArray; }
|
|
/**
|
|
* Set to be an unsized array.
|
|
*/
|
|
void setUnsizedArray() { fCount = kUnsizedArray; }
|
|
|
|
/**
|
|
* Access the var name as a writable string
|
|
*/
|
|
SkString* accessName() { return &fName; }
|
|
/**
|
|
* Set the var name
|
|
*/
|
|
void setName(const SkString& n) { fName = n; }
|
|
void setName(const char* n) { fName = n; }
|
|
|
|
/**
|
|
* Get the var name.
|
|
*/
|
|
const SkString& getName() const { return fName; }
|
|
|
|
/**
|
|
* Shortcut for this->getName().c_str();
|
|
*/
|
|
const char* c_str() const { return this->getName().c_str(); }
|
|
|
|
/**
|
|
* Get the type of the var
|
|
*/
|
|
GrSLType getType() const { return fType; }
|
|
/**
|
|
* Set the type of the var
|
|
*/
|
|
void setType(GrSLType type) { fType = type; }
|
|
|
|
TypeModifier getTypeModifier() const { return fTypeModifier; }
|
|
void setTypeModifier(TypeModifier type) { fTypeModifier = type; }
|
|
|
|
/**
|
|
* Get the precision of the var
|
|
*/
|
|
GrSLPrecision getPrecision() const { return fPrecision; }
|
|
|
|
/**
|
|
* Set the precision of the var
|
|
*/
|
|
void setPrecision(GrSLPrecision p) { fPrecision = p; }
|
|
|
|
/**
|
|
* Appends to the layout qualifier
|
|
*/
|
|
void addLayoutQualifier(const char* layoutQualifier) {
|
|
if (!layoutQualifier || !strlen(layoutQualifier)) {
|
|
return;
|
|
}
|
|
if (fLayoutQualifier.isEmpty()) {
|
|
fLayoutQualifier = layoutQualifier;
|
|
} else {
|
|
fLayoutQualifier.appendf(", %s", layoutQualifier);
|
|
}
|
|
}
|
|
|
|
void addModifier(const char* modifier) {
|
|
if (modifier) {
|
|
fExtraModifiers.appendf("%s ", modifier);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Write a declaration of this variable to out.
|
|
*/
|
|
void appendDecl(const GrGLSLCaps* glslCaps, SkString* out) const;
|
|
|
|
void appendArrayAccess(int index, SkString* out) const {
|
|
out->appendf("%s[%d]%s",
|
|
this->getName().c_str(),
|
|
index,
|
|
fUseUniformFloatArrays ? "" : ".x");
|
|
}
|
|
|
|
void appendArrayAccess(const char* indexName, SkString* out) const {
|
|
out->appendf("%s[%s]%s",
|
|
this->getName().c_str(),
|
|
indexName,
|
|
fUseUniformFloatArrays ? "" : ".x");
|
|
}
|
|
|
|
private:
|
|
static const char* TypeModifierString(TypeModifier t) {
|
|
switch (t) {
|
|
case kNone_TypeModifier:
|
|
return "";
|
|
case kIn_TypeModifier:
|
|
return "in";
|
|
case kInOut_TypeModifier:
|
|
return "inout";
|
|
case kOut_TypeModifier:
|
|
return "out";
|
|
case kUniform_TypeModifier:
|
|
return "uniform";
|
|
}
|
|
SkFAIL("Unknown shader variable type modifier.");
|
|
return ""; // suppress warning
|
|
}
|
|
|
|
GrSLType fType;
|
|
TypeModifier fTypeModifier;
|
|
int fCount;
|
|
GrSLPrecision fPrecision;
|
|
/// Work around driver bugs on some hardware that don't correctly
|
|
/// support uniform float []
|
|
bool fUseUniformFloatArrays;
|
|
|
|
SkString fName;
|
|
SkString fLayoutQualifier;
|
|
SkString fExtraModifiers;
|
|
};
|
|
|
|
#endif
|