-.rsample.frag
+sample.frag
sample.vert
specExamples.frag
specExamples.vert
public:
POOL_ALLOCATOR_NEW_DELETE(GlobalPoolAllocator)
- void setIConst(int i) {iConst = i; type = EbtInt; }
- void setUConst(unsigned int u) {uConst = u; type = EbtUint; }
- void setFConst(float f) {fConst = f; type = EbtFloat; }
- void setDConst(double d) {dConst = d; type = EbtDouble; }
- void setBConst(bool b) {bConst = b; type = EbtBool; }
-
- int getIConst() { return iConst; }
- unsigned int getUConst() { return uConst; }
- float getFConst() { return fConst; }
- double getDConst() { return dConst; }
- bool getBConst() { return bConst; }
- int getIConst() const { return iConst; }
+ void setIConst(int i)
+ {
+ iConst = i;
+ type = EbtInt;
+ }
+
+ void setUConst(unsigned int u)
+ {
+ uConst = u;
+ type = EbtUint;
+ }
+
+ void setDConst(double d)
+ {
+ dConst = d;
+ type = EbtDouble;
+ }
+
+ void setBConst(bool b)
+ {
+ bConst = b;
+ type = EbtBool;
+ }
+
+ int getIConst() const { return iConst; }
unsigned int getUConst() const { return uConst; }
- float getFConst() const { return fConst; }
- double getDConst() const { return dConst; }
- bool getBConst() const { return bConst; }
+ double getDConst() const { return dConst; }
+ bool getBConst() const { return bConst; }
bool operator==(const int i) const
{
return false;
}
- bool operator==(const float f) const
- {
- if (f == fConst)
- return true;
-
- return false;
- }
-
bool operator==(const double d) const
{
if (d == dConst)
return true;
break;
- case EbtFloat:
- if (constant.fConst == fConst)
- return true;
-
- break;
case EbtDouble:
if (constant.dConst == dConst)
return true;
return true;
return false;
- case EbtFloat:
- if (fConst > constant.fConst)
- return true;
-
- return false;
case EbtDouble:
if (dConst > constant.dConst)
return true;
return true;
return false;
- case EbtFloat:
- if (fConst < constant.fConst)
- return true;
-
- return false;
case EbtDouble:
if (dConst < constant.dConst)
return true;
switch (type) {
case EbtInt: returnValue.setIConst(iConst + constant.iConst); break;
case EbtUint: returnValue.setUConst(uConst + constant.uConst); break;
- case EbtFloat: returnValue.setFConst(fConst + constant.fConst); break;
case EbtDouble: returnValue.setDConst(dConst + constant.dConst); break;
default: assert(false && "Default missing");
}
switch (type) {
case EbtInt: returnValue.setIConst(iConst - constant.iConst); break;
case EbtUint: returnValue.setUConst(uConst - constant.uConst); break;
- case EbtFloat: returnValue.setFConst(fConst - constant.fConst); break;
case EbtDouble: returnValue.setDConst(dConst - constant.dConst); break;
default: assert(false && "Default missing");
}
switch (type) {
case EbtInt: returnValue.setIConst(iConst * constant.iConst); break;
case EbtUint: returnValue.setUConst(uConst * constant.uConst); break;
- case EbtFloat: returnValue.setFConst(fConst * constant.fConst); break;
case EbtDouble: returnValue.setDConst(dConst * constant.dConst); break;
default: assert(false && "Default missing");
}
int iConst; // used for ivec, scalar ints
unsigned int uConst; // used for uvec, scalar uints
bool bConst; // used for bvec, scalar bools
- float fConst; // used for vec, mat, scalar floats
- double dConst; // used for dvec, dmat, scalar doubles
+ double dConst; // used for vec, dvec, mat, dmat, scalar floats and doubles
} ;
TBasicType type;
//POSSIBILITY OF SUCH DAMAGE.
//
-#include "float.h"
+//??#include "float.h"
#include "localintermediate.h"
namespace {
newConstArray = new constUnion[getMatrixRows() * node->getMatrixCols()];
for (int row = 0; row < getMatrixRows(); row++) {
for (int column = 0; column < node->getMatrixCols(); column++) {
- float sum = 0.0f;
+ double sum = 0.0f;
for (int i = 0; i < node->getMatrixRows(); i++)
- sum += unionArray[i * getMatrixRows() + row].getFConst() * rightUnionArray[column * node->getMatrixRows() + i].getFConst();
- newConstArray[column * getMatrixRows() + row].setFConst(sum);
+ sum += unionArray[i * getMatrixRows() + row].getDConst() * rightUnionArray[column * node->getMatrixRows() + i].getDConst();
+ newConstArray[column * getMatrixRows() + row].setDConst(sum);
}
}
returnType = TType(getType().getBasicType(), EvqConst, 0, getMatrixRows(), node->getMatrixCols());
switch (getType().getBasicType()) {
case EbtFloat:
if (rightUnionArray[i] == 0.0f) {
- newConstArray[i].setFConst(FLT_MAX);
+ newConstArray[i].setDConst(FLT_MAX); // TODO: double support
} else
- newConstArray[i].setFConst(unionArray[i].getFConst() / rightUnionArray[i].getFConst());
+ newConstArray[i].setDConst(unionArray[i].getDConst() / rightUnionArray[i].getDConst());
break;
case EbtInt:
case EOpMatrixTimesVector:
newConstArray = new constUnion[getMatrixRows()];
for (int i = 0; i < getMatrixRows(); i++) {
- float sum = 0.0f;
+ double sum = 0.0f;
for (int j = 0; j < node->getVectorSize(); j++) {
- sum += unionArray[j*getMatrixRows() + i].getFConst() * rightUnionArray[j].getFConst();
+ sum += unionArray[j*getMatrixRows() + i].getDConst() * rightUnionArray[j].getDConst();
}
- newConstArray[i].setFConst(sum);
+ newConstArray[i].setDConst(sum);
}
returnType = TType(getBasicType(), EvqConst, getMatrixRows());
case EOpVectorTimesMatrix:
newConstArray = new constUnion[node->getMatrixCols()];
for (int i = 0; i < node->getMatrixCols(); i++) {
- float sum = 0.0f;
+ double sum = 0.0f;
for (int j = 0; j < getVectorSize(); j++)
- sum += unionArray[j].getFConst() * rightUnionArray[i*node->getMatrixRows() + j].getFConst();
- newConstArray[i].setFConst(sum);
+ sum += unionArray[j].getDConst() * rightUnionArray[i*node->getMatrixRows() + j].getDConst();
+ newConstArray[i].setDConst(sum);
}
returnType = TType(getBasicType(), EvqConst, node->getMatrixCols());
{
double sum = 0;
for (int i = 0; i < objectSize; i++)
- sum += double(unionArray[i].getFConst()) * unionArray[i].getFConst();
+ sum += double(unionArray[i].getDConst()) * unionArray[i].getDConst();
double length = sqrt(sum);
if (op == EOpLength)
- newConstArray[0].setFConst(float(length));
+ newConstArray[0].setDConst(length);
else {
for (int i = 0; i < objectSize; i++)
- newConstArray[i].setFConst(float(unionArray[i].getFConst() / length));
+ newConstArray[i].setDConst(unionArray[i].getDConst() / length);
}
break;
}
break;
}
- // TODO: Functionality: constant folding: separate component-wise from non-component-wise
for (int i = 0; i < objectSize; i++) {
switch (op) {
case EOpNegative:
switch (getType().getBasicType()) {
- case EbtFloat: newConstArray[i].setFConst(-unionArray[i].getFConst()); break;
+ case EbtFloat: newConstArray[i].setDConst(-unionArray[i].getDConst()); break;
case EbtInt: newConstArray[i].setIConst(-unionArray[i].getIConst()); break;
case EbtUint: newConstArray[i].setUConst(static_cast<unsigned int>(-static_cast<int>(unionArray[i].getUConst()))); break;
default:
newConstArray[i] = ~unionArray[i];
break;
case EOpRadians:
- newConstArray[i].setFConst(static_cast<float>(unionArray[i].getFConst() * pi / 180.0));
+ newConstArray[i].setDConst(unionArray[i].getDConst() * pi / 180.0);
break;
case EOpDegrees:
- newConstArray[i].setFConst(static_cast<float>(unionArray[i].getFConst() * 180.0 / pi));
+ newConstArray[i].setDConst(unionArray[i].getDConst() * 180.0 / pi);
break;
case EOpSin:
- newConstArray[i].setFConst(sin(unionArray[i].getFConst()));
+ newConstArray[i].setDConst(sin(unionArray[i].getDConst()));
break;
case EOpCos:
- newConstArray[i].setFConst(cos(unionArray[i].getFConst()));
+ newConstArray[i].setDConst(cos(unionArray[i].getDConst()));
break;
case EOpTan:
- newConstArray[i].setFConst(tan(unionArray[i].getFConst()));
+ newConstArray[i].setDConst(tan(unionArray[i].getDConst()));
break;
case EOpAsin:
- newConstArray[i].setFConst(asin(unionArray[i].getFConst()));
+ newConstArray[i].setDConst(asin(unionArray[i].getDConst()));
break;
case EOpAcos:
- newConstArray[i].setFConst(acos(unionArray[i].getFConst()));
+ newConstArray[i].setDConst(acos(unionArray[i].getDConst()));
break;
case EOpAtan:
- newConstArray[i].setFConst(atan(unionArray[i].getFConst()));
+ newConstArray[i].setDConst(atan(unionArray[i].getDConst()));
break;
case EOpLength:
case EOpDPdy:
case EOpFwidth:
// The derivatives are all mandated to create a constant 0.
- newConstArray[i].setFConst(0.0f);
+ newConstArray[i].setDConst(0.0);
break;
// TODO: Functionality: constant folding: the rest of the ops have to be fleshed out
case EOpMax:
for (int i = 0; i < objectSize; i++) {
if (aggrNode->getOp() == EOpMax)
- newConstArray[i].setFConst(std::max(childConstUnions[0]->getFConst(), childConstUnions[1]->getFConst()));
+ newConstArray[i].setDConst(std::max(childConstUnions[0]->getDConst(), childConstUnions[1]->getDConst()));
else
- newConstArray[i].setFConst(std::min(childConstUnions[0]->getFConst(), childConstUnions[1]->getFConst()));
+ newConstArray[i].setDConst(std::min(childConstUnions[0]->getDConst(), childConstUnions[1]->getDConst()));
}
break;
case EbtFloat:
switch (node->getType().getBasicType()) {
case EbtInt:
- leftUnionArray[i].setFConst(static_cast<float>(rightUnionArray[i].getIConst()));
+ leftUnionArray[i].setDConst(static_cast<double>(rightUnionArray[i].getIConst()));
break;
case EbtUint:
- leftUnionArray[i].setFConst(static_cast<float>(rightUnionArray[i].getUConst()));
+ leftUnionArray[i].setDConst(static_cast<double>(rightUnionArray[i].getUConst()));
break;
case EbtBool:
- leftUnionArray[i].setFConst(static_cast<float>(rightUnionArray[i].getBConst()));
+ leftUnionArray[i].setDConst(static_cast<double>(rightUnionArray[i].getBConst()));
break;
case EbtFloat:
leftUnionArray[i] = rightUnionArray[i];
break;
case EbtDouble:
- leftUnionArray[i].setFConst(static_cast<float>(rightUnionArray[i].getBConst()));
+ leftUnionArray[i].setDConst(static_cast<double>(rightUnionArray[i].getBConst()));
break;
default:
infoSink.info.message(EPrefixInternalError, "Cannot promote", node->getLine());
case EbtDouble:
switch (node->getType().getBasicType()) {
case EbtInt:
- leftUnionArray[i].setDConst(static_cast<float>(rightUnionArray[i].getIConst()));
+ leftUnionArray[i].setDConst(static_cast<double>(rightUnionArray[i].getIConst()));
break;
case EbtUint:
- leftUnionArray[i].setDConst(static_cast<float>(rightUnionArray[i].getUConst()));
+ leftUnionArray[i].setDConst(static_cast<double>(rightUnionArray[i].getUConst()));
break;
case EbtBool:
- leftUnionArray[i].setDConst(static_cast<float>(rightUnionArray[i].getBConst()));
+ leftUnionArray[i].setDConst(static_cast<double>(rightUnionArray[i].getBConst()));
break;
case EbtFloat:
- leftUnionArray[i].setDConst(static_cast<float>(rightUnionArray[i].getFConst()));
- break;
case EbtDouble:
leftUnionArray[i] = rightUnionArray[i];
break;
leftUnionArray[i].setIConst(static_cast<int>(rightUnionArray[i].getBConst()));
break;
case EbtFloat:
- leftUnionArray[i].setIConst(static_cast<int>(rightUnionArray[i].getFConst()));
- break;
case EbtDouble:
leftUnionArray[i].setIConst(static_cast<int>(rightUnionArray[i].getDConst()));
break;
leftUnionArray[i].setUConst(static_cast<unsigned int>(rightUnionArray[i].getBConst()));
break;
case EbtFloat:
- leftUnionArray[i].setUConst(static_cast<unsigned int>(rightUnionArray[i].getFConst()));
- break;
case EbtDouble:
leftUnionArray[i].setUConst(static_cast<unsigned int>(rightUnionArray[i].getDConst()));
break;
leftUnionArray[i] = rightUnionArray[i];
break;
case EbtFloat:
- leftUnionArray[i].setBConst(rightUnionArray[i].getFConst() != 0.0f);
- break;
case EbtDouble:
- leftUnionArray[i].setBConst(rightUnionArray[i].getDConst() != 0.0f);
+ leftUnionArray[i].setBConst(rightUnionArray[i].getDConst() != 0.0);
break;
default:
infoSink.info.message(EPrefixInternalError, "Cannot promote", node->getLine());
0{D}+{U} { pyylval->lex.line = yylineno; parseContext.error(yylineno, "Invalid Octal number.", yytext, "", ""); parseContext.recover(); return 0;}\r
{D}+{U} { pyylval->lex.line = yylineno; pyylval->lex.u = strtoul(yytext, 0, 0); return UINTCONSTANT; }\r
\r
-{D}+{F} { pyylval->lex.line = yylineno; pyylval->lex.f = static_cast<float>(atof(yytext)); return FLOATCONSTANT; }\r
-{D}+{E}{F}? { pyylval->lex.line = yylineno; pyylval->lex.f = static_cast<float>(atof(yytext)); return FLOATCONSTANT; }\r
-{D}+"."{D}*({E})?{F}? { pyylval->lex.line = yylineno; pyylval->lex.f = static_cast<float>(atof(yytext)); return FLOATCONSTANT; }\r
-"."{D}+({E})?{F}? { pyylval->lex.line = yylineno; pyylval->lex.f = static_cast<float>(atof(yytext)); return FLOATCONSTANT; }\r
+{D}+{F} { pyylval->lex.line = yylineno; pyylval->lex.d = atof(yytext); return FLOATCONSTANT; }\r
+{D}+{E}{F}? { pyylval->lex.line = yylineno; pyylval->lex.d = atof(yytext); return FLOATCONSTANT; }\r
+{D}+"."{D}*({E})?{F}? { pyylval->lex.line = yylineno; pyylval->lex.d = atof(yytext); return FLOATCONSTANT; }\r
+"."{D}+({E})?{F}? { pyylval->lex.line = yylineno; pyylval->lex.d = atof(yytext); return FLOATCONSTANT; }\r
\r
{D}+{LF} { pyylval->lex.line = yylineno; pyylval->lex.d = atof(yytext); return DOUBLECONSTANT; }\r
{D}+{E}{LF} { pyylval->lex.line = yylineno; pyylval->lex.d = atof(yytext); return DOUBLECONSTANT; }\r
TSourceLoc line;\r
union {\r
TString *string;\r
- float f;\r
int i;\r
unsigned int u;\r
bool b;\r
}\r
| FLOATCONSTANT {\r
constUnion *unionArray = new constUnion[1];\r
- unionArray->setFConst($1.f);\r
+ unionArray->setDConst($1.d);\r
$$ = parseContext.intermediate.addConstantUnion(unionArray, TType(EbtFloat, EvqConst), $1.line);\r
}\r
| DOUBLECONSTANT {\r
\r
if ($$ == 0) {\r
constUnion *unionArray = new constUnion[1];\r
- unionArray->setFConst(0.0f);\r
+ unionArray->setDConst(0.0);\r
$$ = parseContext.intermediate.addConstantUnion(unionArray, TType(EbtFloat, EvqConst), $2.line);\r
} else {\r
TType newType($1->getType());\r
// error message was put out by PaFindFunction()\r
// Put on a dummy node for error recovery\r
constUnion *unionArray = new constUnion[1];\r
- unionArray->setFConst(0.0f);\r
+ unionArray->setDConst(0.0);\r
$$ = parseContext.intermediate.addConstantUnion(unionArray, TType(EbtFloat, EvqConst), $1.line);\r
parseContext.recover();\r
}\r
out.debug << "\n";
break;
case EbtFloat:
- {
- const int maxSize = 300;
- char buf[maxSize];
- snprintf(buf, maxSize, "%f (%s)", node->getUnionArrayPointer()[i].getFConst(), "const float");
-
- out.debug << buf << "\n";
- }
- break;
case EbtDouble:
{
const int maxSize = 300;
char buf[maxSize];
- snprintf(buf, maxSize, "%f (%s)", node->getUnionArrayPointer()[i].getDConst(), "const double");
+ snprintf(buf, maxSize, "%f", node->getUnionArrayPointer()[i].getDConst());
out.debug << buf << "\n";
}
if (index - i == 0 || (i - index) % (matrixRows + 1) == 0 )
leftUnionArray[i] = rightUnionArray[count];
else
- leftUnionArray[i].setFConst(0.0f);
+ leftUnionArray[i].setDConst(0.0);
(oit->index)++;