| /** |
| ** |
| ** Copyright 2011, The Android Open Source Project |
| ** |
| ** Licensed under the Apache License, Version 2.0 (the "License"); |
| ** you may not use this file except in compliance with the License. |
| ** You may obtain a copy of the License at |
| ** |
| ** http://www.apache.org/licenses/LICENSE-2.0 |
| ** |
| ** Unless required by applicable law or agreed to in writing, software |
| ** distributed under the License is distributed on an "AS IS" BASIS, |
| ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| ** See the License for the specific language governing permissions and |
| ** limitations under the License. |
| */ |
| |
| #include <stack> |
| |
| #include "src/pixelflinger2/pixelflinger2.h" |
| |
| #include <llvm/IRBuilder.h> |
| #include <llvm/Module.h> |
| |
| #include "src/pixelflinger2/llvm_helper.h" |
| |
| using namespace llvm; |
| |
| // texture data is int pointer to surface (will cast to short for 16bpp), index is linear texel index, |
| // format is GGLPixelFormat for surface, return type is <4 x i32> rgba |
| static Value * pointSample(IRBuilder<> & builder, Value * textureData, Value * index, const GGLPixelFormat format) |
| { |
| Value * texel = NULL; |
| switch (format) { |
| case GGL_PIXEL_FORMAT_RGBA_8888: |
| textureData = builder.CreateGEP(textureData, index); |
| texel = builder.CreateLoad(textureData, "texel"); |
| break; |
| case GGL_PIXEL_FORMAT_RGBX_8888: |
| textureData = builder.CreateGEP(textureData, index); |
| texel = builder.CreateLoad(textureData, "texel"); |
| texel = builder.CreateOr(texel, builder.getInt32(0xff000000)); |
| break; |
| case GGL_PIXEL_FORMAT_RGB_565: { |
| textureData = builder.CreateBitCast(textureData, PointerType::get(builder.getInt16Ty(), 0)); |
| textureData = builder.CreateGEP(textureData, index); |
| texel = builder.CreateLoad(textureData, "texel565"); |
| texel = builder.CreateZExt(texel, Type::getInt32Ty(builder.getContext())); |
| |
| Value * b = builder.CreateAnd(texel, builder.getInt32(0x1f)); |
| b = builder.CreateShl(b, builder.getInt32(3)); |
| b = builder.CreateOr(b, builder.CreateLShr(b, builder.getInt32(5))); |
| |
| Value * g = builder.CreateAnd(texel, builder.getInt32(0x7e0)); |
| g = builder.CreateShl(g, builder.getInt32(5)); |
| g = builder.CreateOr(g, builder.CreateLShr(g, builder.getInt32(6))); |
| g = builder.CreateAnd(g, builder.getInt32(0xff00)); |
| |
| Value * r = builder.CreateAnd(texel, builder.getInt32(0xF800)); |
| r = builder.CreateShl(r, builder.getInt32(8)); |
| r = builder.CreateOr(r, builder.CreateLShr(r, builder.getInt32(5))); |
| r = builder.CreateAnd(r, builder.getInt32(0xff0000)); |
| |
| texel = builder.CreateOr(r, builder.CreateOr(g, b)); |
| texel = builder.CreateOr(texel, builder.getInt32(0xff000000), name("texel")); |
| break; |
| } |
| case GGL_PIXEL_FORMAT_A_8: { |
| textureData = builder.CreateBitCast(textureData, PointerType::get(builder.getInt8Ty(),0)); |
| textureData = builder.CreateGEP(textureData, index); |
| texel = builder.CreateLoad(textureData, "texel_a8"); |
| texel = builder.CreateZExt(texel, builder.getInt32Ty()); |
| texel = builder.CreateShl(texel, builder.getInt32(24)); |
| break; |
| } |
| case GGL_PIXEL_FORMAT_L_8: { |
| textureData = builder.CreateBitCast(textureData, PointerType::get(builder.getInt8Ty(),0)); |
| textureData = builder.CreateGEP(textureData, index); |
| texel = builder.CreateLoad(textureData, "texel_l8"); |
| texel = builder.CreateZExt(texel, builder.getInt32Ty()); |
| texel = builder.CreateOr(texel, builder.CreateShl(texel, 8)); |
| texel = builder.CreateOr(texel, builder.CreateShl(texel, 8)); |
| texel = builder.CreateOr(texel, builder.getInt32(0xff000000)); |
| break; |
| } |
| case GGL_PIXEL_FORMAT_LA_88: { |
| textureData = builder.CreateBitCast(textureData, PointerType::get(builder.getInt16Ty(),0)); |
| textureData = builder.CreateGEP(textureData, index); |
| texel = builder.CreateLoad(textureData, "texel_la8"); |
| texel = builder.CreateZExt(texel, builder.getInt32Ty()); |
| Value * alpha = builder.CreateAnd(texel, builder.getInt32(0xff00)); |
| texel = builder.CreateAnd(texel, builder.getInt32(0xff)); |
| texel = builder.CreateOr(texel, builder.CreateShl(texel, 8)); |
| texel = builder.CreateOr(texel, builder.CreateShl(texel, 8)); |
| texel = builder.CreateOr(texel, builder.CreateShl(alpha, 16)); |
| break; |
| } |
| case GGL_PIXEL_FORMAT_UNKNOWN: // usually means texture not set yet |
| ALOGD("pf2: pointSample: unknown format, default to 0xffff00ff \n"); |
| texel = builder.getInt32(0xffff00ff); |
| break; |
| default: |
| assert(0); |
| break; |
| } |
| Value * channels = Constant::getNullValue(intVecType(builder)); |
| |
| // if (dstDesc && dstDesc->IsInt32Color()) { |
| // channels = builder.CreateInsertElement(channels, texel, builder.getInt32(0)); |
| // channels = builder.CreateBitCast(channels, floatVecType(builder)); |
| // return channels; |
| // } else if (!dstDesc || dstDesc->IsVectorType()) { |
| channels = builder.CreateInsertElement(channels, texel, builder.getInt32(0)); |
| channels = builder.CreateInsertElement(channels, texel, builder.getInt32(1)); |
| channels = builder.CreateInsertElement(channels, texel, builder.getInt32(2)); |
| channels = builder.CreateInsertElement(channels, texel, builder.getInt32(3)); |
| // if (dstDesc && dstDesc->IsVectorType(Fixed8)) { |
| // channels = builder.CreateLShr(channels, constIntVec(builder, 0, 8, 16, 24)); |
| // channels = builder.CreateAnd(channels, constIntVec(builder, 0xff, 0xff, 0xff, 0xff)); |
| // channels = builder.CreateBitCast(channels, floatVecType(builder)); |
| // } else if (dstDesc && dstDesc->IsVectorType(Fixed16)) { |
| // channels = builder.CreateShl(channels, constIntVec(builder, 8, 0, 0, 0)); |
| // channels = builder.CreateLShr(channels, constIntVec(builder, 0, 0, 8, 16)); |
| // channels = builder.CreateAnd(channels, constIntVec(builder, 0xff00, 0xff00, 0xff00, 0xff00)); |
| // channels = builder.CreateBitCast(channels, floatVecType(builder)); |
| // } else if (!dstDesc || dstDesc->IsVectorType(Float)) { // no analysis done in vertex shader, so use default float [0,1] output |
| channels = builder.CreateLShr(channels, constIntVec(builder, 0, 8, 16, 24)); |
| channels = builder.CreateAnd(channels, constIntVec(builder, 0xff, 0xff, 0xff, 0xff)); |
| // channels = builder.CreateUIToFP(channels, floatVecType(builder)); |
| // channels = builder.CreateFMul(channels, constFloatVec(builder, 1 / 255.0f, 1 / 255.0f, |
| // 1 / 255.0f, 1 / 255.0f)); |
| // } else |
| // assert(0); |
| // } else |
| // assert(0); |
| |
| return channels; |
| } |
| |
| static const unsigned SHIFT = 16; |
| |
| // w = width - 1, h = height - 1; similar to pointSample; returns <4 x i32> rgba |
| static Value * linearSample(IRBuilder<> & builder, Value * textureData, Value * indexOffset, |
| Value * x0, Value * y0, Value * xLerp, Value * yLerp, |
| Value * w, Value * h, Value * width, Value * height, |
| const GGLPixelFormat format/*, const RegDesc * dstDesc*/) |
| { |
| // TODO: linear filtering needs to be fixed for texcoord outside of [0,1] |
| Value * x1 = builder.CreateAdd(x0, builder.getInt32(1)); |
| x1 = minIntScalar(builder, x1, w); |
| Value * y1 = builder.CreateAdd(y0, builder.getInt32(1)); |
| y1 = minIntScalar(builder, y1, h); |
| |
| // RegDesc regDesc; |
| // regDesc.SetVectorType(Fixed8); |
| |
| Value * index = builder.CreateMul(y0, width); |
| index = builder.CreateAdd(index, x0); |
| index = builder.CreateAdd(index, indexOffset); |
| Value * s0 = pointSample(builder, textureData, index, format/*, ®Desc*/); |
| // s0 = builder.CreateBitCast(s0, intVecType(builder)); |
| |
| index = builder.CreateMul(y0, width); |
| index = builder.CreateAdd(index, x1); |
| index = builder.CreateAdd(index, indexOffset); |
| Value * s1 = pointSample(builder, textureData, index, format/*, ®Desc*/); |
| // s1 = builder.CreateBitCast(s1, intVecType(builder)); |
| |
| index = builder.CreateMul(y1, width); |
| index = builder.CreateAdd(index, x1); |
| index = builder.CreateAdd(index, indexOffset); |
| Value * s2 = pointSample(builder, textureData, index, format/*, ®Desc*/); |
| // s2 = builder.CreateBitCast(s2, intVecType(builder)); |
| |
| index = builder.CreateMul(y1, width); |
| index = builder.CreateAdd(index, x0); |
| index = builder.CreateAdd(index, indexOffset); |
| Value * s3 = pointSample(builder, textureData, index, format/*, ®Desc*/); |
| // s3 = builder.CreateBitCast(s3, intVecType(builder)); |
| |
| Value * xLerpVec = intVec(builder, xLerp, xLerp, xLerp, xLerp); |
| |
| Value * h0 = builder.CreateMul(builder.CreateSub(s1, s0), xLerpVec); |
| // arithmetic shift right, since it's the result of subtraction, which could be negative |
| h0 = builder.CreateAShr(h0, constIntVec(builder, SHIFT, SHIFT, SHIFT, SHIFT)); |
| h0 = builder.CreateAdd(h0, s0); |
| |
| Value * h1 = builder.CreateMul(builder.CreateSub(s2, s3), xLerpVec); |
| h1 = builder.CreateAShr(h1, constIntVec(builder, SHIFT, SHIFT, SHIFT, SHIFT)); |
| h1 = builder.CreateAdd(h1, s3); |
| |
| Value * sample = builder.CreateMul(builder.CreateSub(h1, h0), |
| intVec(builder, yLerp, yLerp, yLerp, yLerp)); |
| sample = builder.CreateAShr(sample, constIntVec(builder, SHIFT, SHIFT, SHIFT, SHIFT)); |
| sample = builder.CreateAdd(sample, h0); |
| |
| return sample; |
| // if (!dstDesc || dstDesc->IsVectorType(Float)) { |
| // sample = builder.CreateUIToFP(sample, floatVecType(builder)); |
| // return builder.CreateFMul(sample, constFloatVec(builder, 1 / 255.0f, 1 / 255.0f, |
| // 1 / 255.0f, 1 / 255.0f)); |
| // } else if (dstDesc && dstDesc->IsVectorType(Fixed16)) { |
| // sample = builder.CreateShl(sample, constIntVec(builder, 8, 8, 8, 8)); |
| // return builder.CreateBitCast(sample, floatVecType(builder)); |
| // } else if (dstDesc && dstDesc->IsVectorType(Fixed8)) |
| // return builder.CreateBitCast(sample, floatVecType(builder)); |
| // else if (dstDesc && dstDesc->IsInt32Color()) { |
| // sample = builder.CreateShl(sample, constIntVec(builder, 0, 8, 16, 24)); |
| // std::vector<llvm::Value*> samples = extractVector(sample); |
| // samples[0] = builder.CreateOr(samples[0], samples[1]); |
| // samples[0] = builder.CreateOr(samples[0], samples[2]); |
| // samples[0] = builder.CreateOr(samples[0], samples[3]); |
| // sample = builder.CreateInsertElement(sample, samples[0], builder.getInt32(0)); |
| // return builder.CreateBitCast(sample, floatVecType(builder)); |
| // } else |
| // assert(0); |
| } |
| |
| // dim is size - 1, since [0.0f,1.0f]->[0, size - 1] |
| static Value * texcoordWrap(IRBuilder<> & builder, const unsigned wrap, |
| /*const ChannelType type,*/ Value * r, Value * size, Value * dim, |
| Value ** texelLerp) |
| { |
| Type * intType = Type::getInt32Ty(builder.getContext()); |
| Value * tc = NULL; |
| Value * odd = NULL; |
| // if (Float == type) { |
| // convert float to fixed16 so that 16LSB are the remainder, and bit 16 is one |
| // mantissa is the amount between two texels, used for linear interpolation |
| tc = ConstantFP::get(builder.getContext(), APFloat(float(1 << SHIFT))); |
| tc = builder.CreateFMul(tc, r); |
| tc = builder.CreateFPToSI(tc, intType); |
| // } else if (Fixed16 == type) { |
| // assert(16 == SHIFT); |
| // tc = builder.CreateBitCast(r, Type::getInt32Ty(builder.getContext())); |
| // } else |
| // assert(0); |
| |
| odd = builder.CreateAnd(tc, builder.getInt32(1 << SHIFT), name("tc_odd")); |
| |
| if (0 == wrap || 2 == wrap) // just the mantissa for wrap and mirrored |
| tc = builder.CreateAnd(tc, builder.getInt32((1 << SHIFT) - 1)); |
| |
| tc = builder.CreateMul(tc, dim); |
| |
| *texelLerp = builder.CreateAnd(tc, builder.getInt32((1 << SHIFT) - 1)); |
| |
| tc = builder.CreateLShr(tc, builder.getInt32(SHIFT)); |
| |
| if (0 == wrap) // GL_REPEAT |
| { } else if (1 == wrap) { // GL_CLAMP_TO_EDGE |
| tc = maxIntScalar(builder, tc, builder.getInt32(0)); |
| tc = minIntScalar(builder, tc, dim); |
| } else if (2 == wrap) { // GL_MIRRORER_REPEAT |
| Value * tcPtr = builder.CreateAlloca(intType); |
| builder.CreateStore(tc, tcPtr); |
| odd = builder.CreateICmpNE(odd, builder.getInt32(0)); |
| |
| CondBranch condBranch(builder); |
| condBranch.ifCond(odd); |
| |
| tc = builder.CreateSub(dim, tc, name("tc_mirrored")); |
| builder.CreateStore(tc, tcPtr); |
| |
| condBranch.endif(); |
| |
| tc = builder.CreateLoad(tcPtr); |
| } else |
| assert(0); |
| |
| return tc; |
| } |
| |
| Value * tex2D(IRBuilder<> & builder, Value * in1, const unsigned sampler, |
| /*const RegDesc * in1Desc, const RegDesc * dstDesc,*/ |
| const GGLState * gglCtx) |
| { |
| Type * intType = builder.getInt32Ty(); |
| PointerType * intPointerType = PointerType::get(intType, 0); |
| |
| llvm::Module * module = builder.GetInsertBlock()->getParent()->getParent(); |
| std::vector<Value * > texcoords = extractVector(builder, in1); |
| |
| Value * textureDimensions = module->getGlobalVariable(_PF2_TEXTURE_DIMENSIONS_NAME_); |
| if (!textureDimensions) |
| textureDimensions = new GlobalVariable(*module, intType, true, |
| GlobalValue::ExternalLinkage, |
| NULL, _PF2_TEXTURE_DIMENSIONS_NAME_); |
| Value * textureWidth = builder.CreateConstInBoundsGEP1_32(textureDimensions, |
| sampler * 2); |
| textureWidth = builder.CreateLoad(textureWidth, name("textureWidth")); |
| Value * textureHeight = builder.CreateConstInBoundsGEP1_32(textureDimensions, |
| sampler * 2 + 1); |
| textureHeight = builder.CreateLoad(textureHeight, name("textureHeight")); |
| Value * textureW = builder.CreateSub(textureWidth, builder.getInt32(1)); |
| Value * textureH = builder.CreateSub(textureHeight, builder.getInt32(1)); |
| // ChannelType sType = Float, tType = Float; |
| // if (in1Desc) { |
| // sType = in1Desc->channels[0]; |
| // tType = in1Desc->channels[1]; |
| // } |
| |
| Value * xLerp = NULL, * yLerp = NULL; |
| Value * x = texcoordWrap(builder, gglCtx->textureState.textures[sampler].wrapS, |
| /*sType, */texcoords[0], textureWidth, textureW, &xLerp); |
| Value * y = texcoordWrap(builder, gglCtx->textureState.textures[sampler].wrapT, |
| /*tType, */texcoords[1], textureHeight, textureH, &yLerp); |
| |
| Value * index = builder.CreateMul(y, textureWidth); |
| index = builder.CreateAdd(index, x); |
| |
| Value * textureData = module->getGlobalVariable(_PF2_TEXTURE_DATA_NAME_); |
| if (!textureData) |
| textureData = new GlobalVariable(*module, intPointerType, |
| true, GlobalValue::ExternalLinkage, |
| NULL, _PF2_TEXTURE_DATA_NAME_); |
| |
| textureData = builder.CreateConstInBoundsGEP1_32(textureData, sampler); |
| textureData = builder.CreateLoad(textureData); |
| |
| if (0 == gglCtx->textureState.textures[sampler].minFilter && |
| 0 == gglCtx->textureState.textures[sampler].magFilter) { // GL_NEAREST |
| Value * ret = pointSample(builder, textureData, index, |
| gglCtx->textureState.textures[sampler].format/*, dstDesc*/); |
| return intColorVecToFloatColorVec(builder, ret); |
| } else if (1 == gglCtx->textureState.textures[sampler].minFilter && |
| 1 == gglCtx->textureState.textures[sampler].magFilter) { // GL_LINEAR |
| Value * ret = linearSample(builder, textureData, builder.getInt32(0), x, y, xLerp, yLerp, |
| textureW, textureH, textureWidth, textureHeight, |
| gglCtx->textureState.textures[sampler].format/*, dstDesc*/); |
| return intColorVecToFloatColorVec(builder, ret); |
| } else |
| assert(!"unsupported texture filter"); |
| return NULL; |
| } |
| |
| // only positive float; used in cube map since major axis is positive |
| static Value * FCmpGT(IRBuilder<> & builder, Value * lhs, Value * rhs) |
| { |
| Type * const intType = Type::getInt32Ty(builder.getContext()); |
| lhs = builder.CreateBitCast(lhs, intType); |
| rhs = builder.CreateBitCast(rhs, intType); |
| return builder.CreateICmpUGT(lhs, rhs); |
| } |
| |
| static Value * FPositive(IRBuilder<> & builder, Value * val) |
| { |
| // float cmp faster here |
| return builder.CreateFCmpOGE(val, Constant::getNullValue(builder.getFloatTy())); |
| //val = builder.CreateBitCast(val, Type::getInt32Ty(builder.getContext())); |
| //return builder.CreateICmpSGE(val, storage->constantInt(0)); |
| //val = builder.CreateAnd(val, storage->constantInt(0x80000000)); |
| //return builder.CreateICmpNE(val, storage->constantInt(0)); |
| } |
| |
| static Value * Fabs(IRBuilder<> & builder, Value * val) |
| { |
| val = builder.CreateBitCast(val, builder.getInt32Ty()); |
| val = builder.CreateAnd(val, builder.getInt32(~0x80000000)); |
| return builder.CreateBitCast(val, builder.getFloatTy()); |
| //return builder.CreateICmpSGE(val, storage->constantInt(0)); |
| } |
| |
| Value * texCube(IRBuilder<> & builder, Value * in1, const unsigned sampler, |
| /*const RegDesc * in1Desc, const RegDesc * dstDesc,*/ |
| const GGLState * gglCtx) |
| { |
| // if (in1Desc) // the major axis determination code is only float for now |
| // assert(in1Desc->IsVectorType(Float)); |
| |
| Type * const intType = builder.getInt32Ty(); |
| PointerType * const intPointerType = PointerType::get(intType, 0); |
| Type * const floatType = builder.getFloatTy(); |
| |
| Constant * const float1 = constFloat(builder, 1.0f); |
| Constant * const float0_5 = constFloat(builder, 0.5f); |
| |
| Module * module = builder.GetInsertBlock()->getParent()->getParent(); |
| std::vector<Value * > texcoords = extractVector(builder, in1); |
| |
| Value * textureDimensions = module->getGlobalVariable(_PF2_TEXTURE_DIMENSIONS_NAME_); |
| if (!textureDimensions) |
| textureDimensions = new GlobalVariable(*module, intType, true, |
| GlobalValue::ExternalLinkage, |
| NULL, _PF2_TEXTURE_DIMENSIONS_NAME_); |
| Value * textureWidth = builder.CreateConstInBoundsGEP1_32(textureDimensions, |
| sampler * 2); |
| textureWidth = builder.CreateLoad(textureWidth, name("textureWidth")); |
| Value * textureHeight = builder.CreateConstInBoundsGEP1_32(textureDimensions, |
| sampler * 2 + 1); |
| textureHeight = builder.CreateLoad(textureHeight, name("textureHeight")); |
| Value * textureW = builder.CreateSub(textureWidth, builder.getInt32(1)); |
| Value * textureH = builder.CreateSub(textureHeight, builder.getInt32(1)); |
| |
| Value * mx = Fabs(builder, texcoords[0]), * my = Fabs(builder, texcoords[1]); |
| Value * mz = Fabs(builder, texcoords[2]); |
| Value * sPtr = builder.CreateAlloca(floatType); |
| Value * tPtr = builder.CreateAlloca(floatType); |
| Value * maPtr = builder.CreateAlloca(floatType); |
| Value * facePtr = builder.CreateAlloca(intType); |
| |
| Value * mxGmyCmp = FCmpGT(builder, mx, my); |
| Value * mxGmzCmp = FCmpGT(builder, mx, mz); |
| |
| CondBranch condBranch(builder); |
| condBranch.ifCond(builder.CreateAnd(mxGmyCmp, mxGmzCmp)); // if (mx > my && mx > mz) |
| // m_storage->setCurrentBlock(currentBlock(), false); |
| { |
| condBranch.ifCond(FPositive(builder, texcoords[0])); |
| // m_storage->setCurrentBlock(currentBlock(), false); |
| { |
| builder.CreateStore(builder.CreateFNeg(texcoords[2]), sPtr); |
| builder.CreateStore(builder.CreateFNeg(texcoords[1]), tPtr); |
| builder.CreateStore(builder.getInt32(0), facePtr); |
| } |
| condBranch.elseop(); |
| // m_storage->setCurrentBlock(currentBlock(), false); |
| { |
| builder.CreateStore((texcoords[2]), sPtr); |
| builder.CreateStore(builder.CreateFNeg(texcoords[1]), tPtr); |
| builder.CreateStore(builder.getInt32(1), facePtr); |
| } |
| condBranch.endif(); // end if (x >= 0) |
| // m_storage->setCurrentBlock(currentBlock(), false); |
| |
| builder.CreateStore(mx, maPtr); |
| } |
| condBranch.elseop(); // !(mx > my && mx > mz) |
| // m_storage->setCurrentBlock(currentBlock(), false); |
| { |
| Value * myGmxCmp = FCmpGT(builder, my, mx); |
| Value * myGmzCmp = FCmpGT(builder, my, mz); |
| condBranch.ifCond(builder.CreateAnd(myGmxCmp, myGmzCmp)); // my > mx && my > mz |
| // m_storage->setCurrentBlock(currentBlock(), false); |
| { |
| condBranch.ifCond(FPositive(builder, texcoords[1])); |
| // m_storage->setCurrentBlock(currentBlock(), false); |
| { |
| builder.CreateStore((texcoords[0]), sPtr); |
| builder.CreateStore((texcoords[2]), tPtr); |
| builder.CreateStore(builder.getInt32(2), facePtr); |
| } |
| condBranch.elseop(); |
| // m_storage->setCurrentBlock(currentBlock(), false); |
| { |
| builder.CreateStore(texcoords[0], sPtr); |
| builder.CreateStore(builder.CreateFNeg(texcoords[2]), tPtr); |
| builder.CreateStore(builder.getInt32(3), facePtr); |
| } |
| condBranch.endif(); |
| // m_storage->setCurrentBlock(currentBlock(), false); |
| |
| builder.CreateStore(my, maPtr); |
| } |
| condBranch.elseop(); // !(my > mx && my > mz) |
| // m_storage->setCurrentBlock(currentBlock(), false); |
| { |
| //ifCond(builder.CreateFCmpOGE(texcoords[2], float0, name("zPositive"))); |
| condBranch.ifCond(FPositive(builder, texcoords[2])); |
| // m_storage->setCurrentBlock(currentBlock(), false); |
| { |
| builder.CreateStore((texcoords[0]), sPtr); |
| builder.CreateStore(builder.CreateFNeg(texcoords[1]), tPtr); |
| builder.CreateStore(builder.getInt32(4), facePtr); |
| } |
| condBranch.elseop(); |
| // m_storage->setCurrentBlock(currentBlock(), false); |
| { |
| builder.CreateStore(builder.CreateFNeg(texcoords[0]), sPtr); |
| builder.CreateStore(builder.CreateFNeg(texcoords[1]), tPtr); |
| builder.CreateStore(builder.getInt32(5), facePtr); |
| } |
| condBranch.endif(); // end if (x >= 0) |
| // m_storage->setCurrentBlock(currentBlock(), false); |
| |
| builder.CreateStore(mz, maPtr); |
| } |
| condBranch.endif(); |
| // m_storage->setCurrentBlock(currentBlock(), false); |
| } |
| condBranch.endif(); |
| // m_storage->setCurrentBlock(currentBlock(), false); |
| |
| |
| Value * s = builder.CreateLoad(sPtr); |
| Value * t = builder.CreateLoad(tPtr); |
| Value * ma = builder.CreateLoad(maPtr); |
| Value * face = builder.CreateLoad(facePtr); |
| |
| s = builder.CreateFDiv(s, ma); |
| s = builder.CreateFAdd(s, float1); |
| s = builder.CreateFMul(s, float0_5); |
| |
| t = builder.CreateFDiv(t, ma); |
| t = builder.CreateFAdd(t, float1); |
| t = builder.CreateFMul(t, float0_5); |
| |
| // ChannelType sType = Float, tType = Float; |
| Value * xLerp = NULL, * yLerp = NULL; |
| Value * x = texcoordWrap(builder, gglCtx->textureState.textures[sampler].wrapS, |
| /*sType, */s, textureWidth, textureW, &xLerp); |
| Value * y = texcoordWrap(builder, gglCtx->textureState.textures[sampler].wrapT, |
| /*tType, */t, textureHeight, textureH, &yLerp); |
| Value * indexOffset = builder.CreateMul(builder.CreateMul(textureHeight, textureWidth), face); |
| Value * index = builder.CreateAdd(builder.CreateMul(y, textureWidth), x); |
| |
| Value * textureData = module->getGlobalVariable(_PF2_TEXTURE_DATA_NAME_); |
| if (!textureData) |
| textureData = new GlobalVariable(*module, intPointerType, |
| true, GlobalValue::ExternalLinkage, |
| NULL, _PF2_TEXTURE_DATA_NAME_); |
| |
| textureData = builder.CreateConstInBoundsGEP1_32(textureData, sampler); |
| textureData = builder.CreateLoad(textureData); |
| |
| if (0 == gglCtx->textureState.textures[sampler].minFilter && |
| 0 == gglCtx->textureState.textures[sampler].magFilter) { // GL_NEAREST |
| textureData = pointSample(builder, textureData, builder.CreateAdd(indexOffset, index), |
| gglCtx->textureState.textures[sampler].format/*, dstDesc*/); |
| return intColorVecToFloatColorVec(builder, textureData); |
| |
| } else if (1 == gglCtx->textureState.textures[sampler].minFilter && |
| 1 == gglCtx->textureState.textures[sampler].magFilter) { // GL_LINEAR |
| textureData = linearSample(builder, textureData, indexOffset, x, y, xLerp, yLerp, |
| textureW, textureH, textureWidth, textureHeight, |
| gglCtx->textureState.textures[sampler].format/*, dstDesc*/); |
| return intColorVecToFloatColorVec(builder, textureData); |
| } else |
| assert(!"unsupported texture filter"); |
| return NULL; |
| } |
