[lunarglass] r1108 committed - Glslang AST -> Top IR: Adapt to glslang's change 3.0 using pure enum-b...

[lunar...@googlecode.com]

Revision: 1108
Author: jo...@lunarg.com
Date: Wed Aug 19 19:49:03 2015 UTC
Log: Glslang AST -> Top IR: Adapt to glslang's change 3.0 using pure
enum-based built-in function calls.
https://code.google.com/p/lunarglass/source/detail?r=1108

Modified:
/trunk/Frontends/glslang/GlslangToTopVisitor.cpp
/trunk/test/baseResults/parallel.out
/trunk/test/newTexture.frag

=======================================
--- /trunk/Frontends/glslang/GlslangToTopVisitor.cpp Tue Aug 11 15:06:31
2015 UTC
+++ /trunk/Frontends/glslang/GlslangToTopVisitor.cpp Wed Aug 19 19:49:03
2015 UTC
@@ -100,10 +100,11 @@
void makeFunctions(const glslang::TIntermSequence&);
void handleFunctionEntry(const glslang::TIntermAggregate* node);
void translateArguments(const glslang::TIntermSequence&
glslangArguments, std::vector<llvm::Value*>& arguments);
- llvm::Value* handleBuiltinFunctionCall(const
glslang::TIntermAggregate*);
- llvm::Value* handleTexImageQuery(const glslang::TIntermAggregate*,
const std::vector<llvm::Value*>& arguments, gla::ESamplerType);
- llvm::Value* handleImageAccess(const glslang::TIntermAggregate*, const
std::vector<llvm::Value*>& arguments, gla::ESamplerType, int flags);
- llvm::Value* handleTextureAccess(const glslang::TIntermAggregate*,
const std::vector<llvm::Value*>& arguments, gla::ESamplerType, int flags);
+ void translateArguments(glslang::TIntermUnary&,
std::vector<llvm::Value*>& arguments);
+ llvm::Value* handleTextureCall(glslang::TIntermOperator*);
+ llvm::Value* handleTexImageQuery(const glslang::TIntermOperator*,
const glslang::TCrackedTextureOp&, const std::vector<llvm::Value*>&
arguments, gla::ESamplerType);
+ llvm::Value* handleImageAccess(const glslang::TIntermOperator*, const
glslang::TCrackedTextureOp&, const std::vector<llvm::Value*>& arguments,
gla::ESamplerType, int flags);
+ llvm::Value* handleTextureAccess(const glslang::TIntermOperator*,
const glslang::TCrackedTextureOp&, const std::vector<llvm::Value*>&
arguments, gla::ESamplerType, int flags);
llvm::Value* handleUserFunctionCall(const glslang::TIntermAggregate*);

llvm::Value* createBinaryOperation(glslang::TOperator op,
gla::EMdPrecision, llvm::Value* left, llvm::Value* right, bool isUnsigned,
bool reduceComparison = true);
@@ -837,6 +838,14 @@

bool TGlslangToTopTraverser::visitUnary(glslang::TVisit /* visit */,
glslang::TIntermUnary* node)
{
+ // try texturing first
+ llvm::Value* result = handleTextureCall(node);
+ if (result != nullptr) {
+ glaBuilder->clearAccessChain();
+ glaBuilder->setAccessChainRValue(result);
+ return false;
+ }
+
glaBuilder->clearAccessChain();
node->getOperand()->traverse(this);
llvm::Value* operand =
glaBuilder->accessChainLoad(GetMdPrecision(node->getOperand()->getType()));
@@ -844,7 +853,7 @@
gla::EMdPrecision precision = GetMdPrecision(node->getType());

// it could be a conversion
- llvm::Value* result = createConversion(node->getOp(), precision,
convertGlslangToGlaType(node->getType()), operand);
+ result = createConversion(node->getOp(), precision,
convertGlslangToGlaType(node->getType()), operand);

// if not, then possibly an operation
if (! result)
@@ -903,7 +912,14 @@

bool TGlslangToTopTraverser::visitAggregate(glslang::TVisit visit,
glslang::TIntermAggregate* node)
{
- llvm::Value* result;
+ // try texturing first
+ llvm::Value* result = handleTextureCall(node);
+ if (result != nullptr) {
+ glaBuilder->clearAccessChain();
+ glaBuilder->setAccessChainRValue(result);
+ return false;
+ }
+
glslang::TOperator binOp = glslang::EOpNull;
bool reduceComparison = true;
bool isMatrix = false;
@@ -976,8 +992,6 @@
{
if (node->isUserDefined())
result = handleUserFunctionCall(node);
- else
- result = handleBuiltinFunctionCall(node);

if (! result) {
gla::UnsupportedFunctionality("glslang function call");
@@ -1144,6 +1158,23 @@
}
return false;

+ case glslang::EOpFtransform:
+ {
+ // TODO: back-end functionality: if this needs to support
decomposition, need to simulate
+ // access to the external gl_Vertex and
gl_ModelViewProjectionMatrix.
+ // For now, pass in dummy arguments, which are thrown away
anyway
+ // if ftransform is consumed by the backend without
decomposition.
+ llvm::Value* vertex =
glaBuilder->createVariable(gla::Builder::ESQGlobal, 0,
llvm::VectorType::get(gla::GetFloatType(context), 4),
+
0, 0, "gl_Vertex_sim");
+ llvm::Value* matrix =
glaBuilder->createVariable(gla::Builder::ESQGlobal, 0,
llvm::VectorType::get(gla::GetFloatType(context), 4),
+
0, 0, "gl_ModelViewProjectionMatrix_sim");
+
+ result =
glaBuilder->createIntrinsicCall(GetMdPrecision(node->getType()),
llvm::Intrinsic::gla_fFixedTransform, glaBuilder->createLoad(vertex),
glaBuilder->createLoad(matrix));
+ glaBuilder->clearAccessChain();
+ glaBuilder->setAccessChainRValue(result);
+ }
+ return false;
+
case glslang::EOpEmitVertex:
case glslang::EOpEndPrimitive:
case glslang::EOpBarrier:
@@ -1640,68 +1671,70 @@
}
}

-llvm::Value* TGlslangToTopTraverser::handleBuiltinFunctionCall(const
glslang::TIntermAggregate* node)
+void TGlslangToTopTraverser::translateArguments(glslang::TIntermUnary&
glslangArgument, std::vector<llvm::Value*>& arguments)
{
+ glaBuilder->clearAccessChain();
+ glslangArgument.getOperand()->traverse(this);
+
arguments.push_back(glaBuilder->accessChainLoad(GetMdPrecision(glslangArgument.getAsTyped()->getType())));
+}
+
+llvm::Value*
TGlslangToTopTraverser::handleTextureCall(glslang::TIntermOperator* node)
+{
+ if (! node->isImage() && ! node->isTexture())
+ return nullptr;
+
std::vector<llvm::Value*> arguments;
- translateArguments(node->getSequence(), arguments);
+ if (node->getAsAggregate())
+ translateArguments(node->getAsAggregate()->getSequence(),
arguments);
+ else
+ translateArguments(*node->getAsUnaryNode(), arguments);

- if (node->getName() == "ftransform(") {
- // TODO: back-end functionality: if this needs to support
decomposition, need to simulate
- // access to the external gl_Vertex and
gl_ModelViewProjectionMatrix.
- // For now, pass in dummy arguments, which are thrown away anyway
- // if ftransform is consumed by the backend without decomposition.
- llvm::Value* vertex =
glaBuilder->createVariable(gla::Builder::ESQGlobal, 0,
llvm::VectorType::get(gla::GetFloatType(context), 4),
- 0,
0, "gl_Vertex_sim");
- llvm::Value* matrix =
glaBuilder->createVariable(gla::Builder::ESQGlobal, 0,
llvm::VectorType::get(gla::GetFloatType(context), 4),
- 0,
0, "gl_ModelViewProjectionMatrix_sim");
+ const glslang::TSampler sampler = node->getAsAggregate() ?
node->getAsAggregate()->getSequence()[0]->getAsTyped()->getType().getSampler()
+ :
node->getAsUnaryNode()->getOperand()->getAsTyped()->getType().getSampler();

- return
glaBuilder->createIntrinsicCall(GetMdPrecision(node->getType()),
llvm::Intrinsic::gla_fFixedTransform, glaBuilder->createLoad(vertex),
glaBuilder->createLoad(matrix));
+ gla::ESamplerType samplerType;
+ switch (sampler.dim) {
+ case glslang::Esd1D: samplerType = gla::ESampler1D; break;
+ case glslang::Esd2D: samplerType = gla::ESampler2D; break;
+ case glslang::Esd3D: samplerType = gla::ESampler3D; break;
+ case glslang::EsdCube: samplerType = gla::ESamplerCube; break;
+ case glslang::EsdRect: samplerType = gla::ESampler2DRect; break;
+ case glslang::EsdBuffer: samplerType = gla::ESamplerBuffer; break;
+ default:
+ gla::UnsupportedFunctionality("sampler type");
+ break;
}
+ if (sampler.ms)
+ samplerType = gla::ESampler2DMS;

- if (node->getName().substr(0, 7) == "texture" ||
node->getName().substr(0, 5) == "texel" || node->getName().substr(0, 6)
== "shadow" ||
- node->getName().substr(0, 5) == "image") {
- const glslang::TSampler& sampler =
node->getSequence()[0]->getAsTyped()->getType().getSampler();
- gla::ESamplerType samplerType;
- switch (sampler.dim) {
- case glslang::Esd1D: samplerType = gla::ESampler1D;
break;
- case glslang::Esd2D: samplerType = gla::ESampler2D;
break;
- case glslang::Esd3D: samplerType = gla::ESampler3D;
break;
- case glslang::EsdCube: samplerType = gla::ESamplerCube;
break;
- case glslang::EsdRect: samplerType = gla::ESampler2DRect;
break;
- case glslang::EsdBuffer: samplerType = gla::ESamplerBuffer;
break;
- default:
- gla::UnsupportedFunctionality("sampler type");
- break;
- }
- if (sampler.ms)
- samplerType = gla::ESampler2DMS;
+ glslang::TCrackedTextureOp cracked;
+ node->crackTexture(cracked);

- if (node->getName().find("Size", 0) != std::string::npos ||
- node->getName().find("Query", 0) != std::string::npos)
- return handleTexImageQuery(node, arguments, samplerType);
+ if (cracked.query || node->getOp() == glslang::EOpImageQuerySize ||
node->getOp() == glslang::EOpImageQuerySamples)
+ return handleTexImageQuery(node, cracked, arguments, samplerType);

- int texFlags = 0;
+ int texFlags = 0;

- if (sampler.arrayed)
- texFlags |= gla::ETFArrayed;
+ if (sampler.arrayed)
+ texFlags |= gla::ETFArrayed;

- if (sampler.shadow)
- texFlags |= gla::ETFShadow;
+ if (sampler.shadow)
+ texFlags |= gla::ETFShadow;

- if (sampler.image)
- return handleImageAccess(node, arguments, samplerType,
texFlags);
- else
- return handleTextureAccess(node, arguments, samplerType,
texFlags);
- }
-
- return 0;
+ if (sampler.image)
+ return handleImageAccess(node, cracked, arguments, samplerType,
texFlags);
+ else
+ return handleTextureAccess(node, cracked, arguments, samplerType,
texFlags);
}

-llvm::Value* TGlslangToTopTraverser::handleTexImageQuery(const
glslang::TIntermAggregate* node, const std::vector<llvm::Value*>&
arguments, gla::ESamplerType samplerType)
+llvm::Value* TGlslangToTopTraverser::handleTexImageQuery(const
glslang::TIntermOperator* node, const glslang::TCrackedTextureOp& cracked,
const std::vector<llvm::Value*>& arguments, gla::ESamplerType samplerType)
{
gla::EMdPrecision precision = GetMdPrecision(node->getType());

- if (node->getName().find("Size", 0) != std::string::npos) {
+ switch (node->getOp()) {
+ case glslang::EOpTextureQuerySize:
+ case glslang::EOpImageQuerySize:
+ {
llvm::Value* lastArg;
llvm::Intrinsic::ID intrinsicID;

@@ -1720,52 +1753,47 @@
MakeIntConstant(context,
samplerType),
arguments[0], lastArg,
leftName);
}
-
- if (node->getName().find("Query", 0) != std::string::npos) {
- if (node->getName().find("Lod", 0) != std::string::npos) {
- gla::UnsupportedFunctionality("textureQueryLod");
- return glaBuilder->createTextureQueryCall(precision,
-
llvm::Intrinsic::gla_fQueryTextureLod,
-
convertGlslangToGlaType(node->getType()),
-
MakeIntConstant(context, samplerType),
- arguments[0],
arguments[1], leftName);
- } else if (node->getName().find("Levels", 0) != std::string::npos)
- gla::UnsupportedFunctionality("textureQueryLevels");
+ case glslang::EOpTextureQueryLod:
+ {
+ gla::UnsupportedFunctionality("textureQueryLod");
+ return glaBuilder->createTextureQueryCall(precision,
+
llvm::Intrinsic::gla_fQueryTextureLod,
+
convertGlslangToGlaType(node->getType()),
+
MakeIntConstant(context, samplerType),
+ arguments[0],
arguments[1], leftName);
}
-
- return 0;
+ case glslang::EOpTextureQueryLevels:
+ gla::UnsupportedFunctionality("textureQueryLevels");
+ return nullptr;
+ default:
+ gla::UnsupportedFunctionality("texture/image query");
+ return nullptr;
+ }
}

-llvm::Value* TGlslangToTopTraverser::handleImageAccess(const
glslang::TIntermAggregate* node, const std::vector<llvm::Value*>&
arguments, gla::ESamplerType samplerType, int texFlags)
+llvm::Value* TGlslangToTopTraverser::handleImageAccess(const
glslang::TIntermOperator* node, const glslang::TCrackedTextureOp& cracked,
const std::vector<llvm::Value*>& arguments, gla::ESamplerType samplerType,
int texFlags)
{
// set the arguments
gla::Builder::TextureParameters params = {};
params.ETPSampler = arguments[0];
params.ETPCoords = arguments[1];

- gla::EImageOp imageOp;
- if (node->getName().find("Load", 0) != std::string::npos)
- imageOp = gla::EImageLoad;
- else if (node->getName().find("Store", 0) != std::string::npos)
- imageOp = gla::EImageStore;
- else if (node->getName().find("AtomicAdd", 0) != std::string::npos)
- imageOp = gla::EImageAtomicAdd;
- else if (node->getName().find("AtomicMin", 0) != std::string::npos)
- imageOp = gla::EImageAtomicMin;
- else if (node->getName().find("AtomicMax", 0) != std::string::npos)
- imageOp = gla::EImageAtomicMax;
- else if (node->getName().find("AtomicAnd", 0) != std::string::npos)
- imageOp = gla::EImageAtomicAnd;
- else if (node->getName().find("AtomicOr", 0) != std::string::npos)
- imageOp = gla::EImageAtomicOr;
- else if (node->getName().find("AtomicXor", 0) != std::string::npos)
- imageOp = gla::EImageAtomicXor;
- else if (node->getName().find("AtomicExchange", 0) !=
std::string::npos)
- imageOp = gla::EImageAtomicExchange;
- else if (node->getName().find("AtomicCompSwap", 0) !=
std::string::npos)
- imageOp = gla::EImageAtomicCompSwap;
- else
+ gla::EImageOp imageOp = gla::EImageNoop;
+ switch (node->getOp()) {
+ case glslang::EOpImageLoad: imageOp =
gla::EImageLoad; break;
+ case glslang::EOpImageStore: imageOp =
gla::EImageStore; break;
+ case glslang::EOpImageAtomicAdd: imageOp =
gla::EImageAtomicAdd; break;
+ case glslang::EOpImageAtomicMin: imageOp =
gla::EImageAtomicMin; break;
+ case glslang::EOpImageAtomicMax: imageOp =
gla::EImageAtomicMax; break;
+ case glslang::EOpImageAtomicAnd: imageOp =
gla::EImageAtomicAnd; break;
+ case glslang::EOpImageAtomicOr: imageOp =
gla::EImageAtomicOr; break;
+ case glslang::EOpImageAtomicXor: imageOp =
gla::EImageAtomicXor; break;
+ case glslang::EOpImageAtomicExchange: imageOp =
gla::EImageAtomicExchange; break;
+ case glslang::EOpImageAtomicCompSwap: imageOp =
gla::EImageAtomicCompSwap; break;
+ default:
gla::UnsupportedFunctionality("image access");
+ break;
+ }

texFlags |= (imageOp << gla::ImageOpShift);

@@ -1775,23 +1803,24 @@
return glaBuilder->createImageCall(GetMdPrecision(node->getType()),
convertGlslangToGlaType(node->getType()), samplerType, texFlags, params,
leftName);
}

-llvm::Value* TGlslangToTopTraverser::handleTextureAccess(const
glslang::TIntermAggregate* node, const std::vector<llvm::Value*>&
arguments, gla::ESamplerType samplerType, int texFlags)
+llvm::Value* TGlslangToTopTraverser::handleTextureAccess(const
glslang::TIntermOperator* node, const glslang::TCrackedTextureOp& cracked,
+ const
std::vector<llvm::Value*>& arguments, gla::ESamplerType samplerType, int
texFlags)
{
- if (node->getName().find("Lod", 0) != std::string::npos) {
+ if (cracked.lod) {
texFlags |= gla::ETFLod;
texFlags |= gla::ETFBiasLodArg;
}

- if (node->getName().find("Proj", 0) != std::string::npos)
+ if (cracked.proj)
texFlags |= gla::ETFProjected;

- if (node->getName().find("Offset", 0) != std::string::npos) {
+ if (cracked.offset || cracked.offsets) {
texFlags |= gla::ETFOffsetArg;
- if (node->getName().find("Offsets", 0) != std::string::npos)
+ if (cracked.offsets)
texFlags |= gla::ETFOffsets;
}

- if (node->getName().find("Fetch", 0) != std::string::npos) {
+ if (cracked.fetch) {
texFlags |= gla::ETFFetch;
switch (samplerType) {
case gla::ESampler1D:
@@ -1807,7 +1836,7 @@
}
}

- if (node->getName().find("Gather", 0) != std::string::npos) {
+ if (cracked.gather) {
texFlags |= gla::ETFGather;
if (texFlags & gla::ETFShadow)
texFlags |= gla::ETFRefZArg;
@@ -1820,7 +1849,7 @@
++nonBiasArgCount;
if (texFlags & gla::ETFBiasLodArg)
++nonBiasArgCount;
- if (node->getName().find("Grad", 0) != std::string::npos)
+ if (cracked.grad)
nonBiasArgCount += 2;

if ((int)arguments.size() > nonBiasArgCount) {
@@ -1847,7 +1876,7 @@
params.ETPBiasLod = arguments[2];
++extraArgs;
}
- if (node->getName().find("Grad", 0) != std::string::npos) {
+ if (cracked.grad) {
params.ETPGradX = arguments[2 + extraArgs];
params.ETPGradY = arguments[3 + extraArgs];
extraArgs += 2;
=======================================
--- /trunk/test/baseResults/parallel.out Mon May 25 23:12:49 2015 UTC
+++ /trunk/test/baseResults/parallel.out Wed Aug 19 19:49:03 2015 UTC
@@ -976,57 +976,57 @@
H_xgwibs.y = H_7jsn5f;
vec4 H_8sp3bo1 = texelFetch(s3D, ic3D, ic1D);
vec4 H_yfqtjc1 = H_8sp3bo1 + H_xgwibs;
- vec4 H_w1booj = texelFetchOffset(s2D, ic2D, C_4, ic2D);
- vec4 H_o77xck1 = H_w1booj + H_yfqtjc1;
+ vec4 H_a1zaet1 = texelFetchOffset(s2D, ic2D, C_4, C_ivec2p3p);
+ vec4 H_7ix0at = H_a1zaet1 + H_yfqtjc1;
float H_cyjcmi = textureLodOffset(s2DShadow, c3D, c1D, C_ivec2p3p);
- float H_0q4wej1 = H_cyjcmi + H_o77xck1.y;
- vec4 H_mbhnl21 = H_o77xck1;
- H_mbhnl21.y = H_0q4wej1;
+ float H_3tflqe = H_7ix0at.y + H_cyjcmi;
+ vec4 H_pq410t = H_7ix0at;
+ H_pq410t.y = H_3tflqe;
vec4 H_rng2f5 = textureProjLodOffset(s2D, c3D, c1D, C_ivec2p3p);
- vec4 H_8f7hu8 = H_mbhnl21 + H_rng2f5;
+ vec4 H_iqtbne = H_pq410t + H_rng2f5;
vec4 H_lr92sb = textureGrad(sCube, c3D, c3D, c3D);
- vec4 H_64fhq61 = H_8f7hu8 + H_lr92sb;
+ vec4 H_dgvkcv1 = H_iqtbne + H_lr92sb;
float H_b9nber = textureGradOffset(s2DArrayShadow, c4D, c2D, c2D,
C_ivec2p3p);
- float H_oxgvt11 = H_64fhq61.x + H_b9nber;
- vec4 H_iv0jvn = H_64fhq61;
- H_iv0jvn.x = H_oxgvt11;
+ float H_81k9l71 = H_b9nber + H_dgvkcv1.x;
+ vec4 H_ymwngo1 = H_dgvkcv1;
+ H_ymwngo1.x = H_81k9l71;
vec4 H_pkmpj3 = textureProjGrad(s3D, c4D, c3D, c3D);
- vec4 H_u1hknb1 = H_iv0jvn + H_pkmpj3;
+ vec4 H_94aric = H_pkmpj3 + H_ymwngo1;
vec4 H_ot18mt = textureProjGradOffset(s2D, c3D, c2D, c2D, C_ivec2p3p);
- vec4 H_vx78251 = H_ot18mt + H_u1hknb1;
+ vec4 H_z33pv4 = H_94aric + H_ot18mt;
ivec4 iv = texture(is2D, c2D);
vec4 H_drjgdg1 = vec4(iv);
- vec4 H_qxtwxg1 = H_drjgdg1 + H_vx78251;
+ vec4 H_xzujaj1 = H_drjgdg1 + H_z33pv4;
ivec4 iv1 = textureProjOffset(is2D, c4D, C_ivec2p3p);
vec4 H_4tvuqr1 = vec4(iv1);
- vec4 H_n7us35 = H_4tvuqr1 + H_qxtwxg1;
+ vec4 H_2cupxp1 = H_4tvuqr1 + H_xzujaj1;
ivec4 iv2 = textureProjLod(is2D, c3D, c1D);
vec4 H_ria08s = vec4(iv2);
- vec4 H_qilkce = H_n7us35 + H_ria08s;
+ vec4 H_8hutux = H_2cupxp1 + H_ria08s;
ivec4 iv3 = textureProjGrad(is2D, c3D, c2D, c2D);
vec4 H_ydpzyj1 = vec4(iv3);
- vec4 H_6knan71 = H_qilkce + H_ydpzyj1;
+ vec4 H_t4ycgo = H_8hutux + H_ydpzyj1;
ivec4 iv4 = texture(is3D, c3D, C_4d2);
vec4 H_5pjwgk = vec4(iv4);
- vec4 H_ujhcnu1 = H_5pjwgk + H_6knan71;
+ vec4 H_ohv12v1 = H_5pjwgk + H_t4ycgo;
ivec4 iv5 = textureLod(isCube, c3D, c1D);
vec4 H_46elgu = vec4(iv5);
- vec4 H_r3pnvg1 = H_46elgu + H_ujhcnu1;
+ vec4 H_s06q0l1 = H_46elgu + H_ohv12v1;
ivec4 iv6 = texelFetch(is2DArray, ic3D, ic1D);
vec4 H_3hnokl = vec4(iv6);
- vec4 H_kije5n1 = H_3hnokl + H_r3pnvg1;
+ vec4 H_cj211n1 = H_3hnokl + H_s06q0l1;
ivec4 iv7 = texelFetch(is2Dms, ic2D, ic1D);
ivec4 iv8 = iv6 + iv7;
vec4 H_5u886m1 = vec4(iv8);
- vec4 H_hltepg1 = H_5u886m1 + H_kije5n1;
+ vec4 H_ufgwlp1 = H_5u886m1 + H_cj211n1;
vec4 H_u4lqa3 = texelFetch(sb, ic1D);
- vec4 H_rgdtlr1 = H_hltepg1 + H_u4lqa3;
+ vec4 H_0knssg = H_u4lqa3 + H_ufgwlp1;
vec4 H_77ufv6 = texelFetch(sr, ic2D);
- vec4 H_jis6ku1 = H_77ufv6 + H_rgdtlr1;
+ vec4 H_rldrmf1 = H_0knssg + H_77ufv6;
ivec2 iv9 = textureSize(sCubeShadow, C_2);
vec2 H_iunhai1 = vec2(iv9);
vec4 H_duim3t = vec4(H_iunhai1.x, H_iunhai1.y, C_0d0, C_0d0);
- vec4 FragData1 = H_duim3t + H_jis6ku1;
+ vec4 FragData1 = H_duim3t + H_rldrmf1;
FragData = FragData1;

}
=======================================
--- /trunk/test/newTexture.frag Sat May 23 02:49:49 2015 UTC
+++ /trunk/test/newTexture.frag Wed Aug 19 19:49:03 2015 UTC
@@ -40,7 +40,7 @@
v += textureLod(s2DArray, c3D, 1.2);
v.y += textureOffset(s2DShadow, c3D, ivec2(3), c1D);
v += texelFetch(s3D, ic3D, ic1D);
- v += texelFetchOffset(s2D, ic2D, 4, ic2D);
+ v += texelFetchOffset(s2D, ic2D, 4, ivec2(3));
v.y += textureLodOffset(s2DShadow, c3D, c1D, ivec2(3));
v += textureProjLodOffset(s2D, c3D, c1D, ivec2(3));
v += textureGrad(sCube, c3D, c3D, c3D);