public static string TextureSize(CodeGenContext context, AstOperation operation) { AstTextureOperation texOp = (AstTextureOperation)operation; bool isBindless = (texOp.Flags & TextureFlags.Bindless) != 0; bool isIndexed = (texOp.Type & SamplerType.Indexed) != 0; string indexExpr = null; if (isIndexed) { indexExpr = GetSoureExpr(context, texOp.GetSource(0), VariableType.S32); } string samplerName = OperandManager.GetSamplerName(context.Config.Stage, texOp, indexExpr); int lodSrcIndex = isBindless || isIndexed ? 1 : 0; IAstNode lod = operation.GetSource(lodSrcIndex); string lodExpr = GetSoureExpr(context, lod, GetSrcVarType(operation.Inst, lodSrcIndex)); if (texOp.Index == 3) { return($"textureQueryLevels({samplerName})"); } else { return($"textureSize({samplerName}, {lodExpr}){GetMask(texOp.Index)}"); } }
public static string TextureSize(CodeGenContext context, AstOperation operation) { AstTextureOperation texOp = (AstTextureOperation)operation; bool isBindless = (texOp.Flags & TextureFlags.Bindless) != 0; string samplerName = OperandManager.GetSamplerName(context.Config.Type, texOp); IAstNode src0 = operation.GetSource(isBindless ? 1 : 0); string src0Expr = GetSoureExpr(context, src0, GetSrcVarType(operation.Inst, 0)); return($"textureSize({samplerName}, {src0Expr}){GetMask(texOp.ComponentMask)}"); }
public static string Lod(CodeGenContext context, AstOperation operation) { AstTextureOperation texOp = (AstTextureOperation)operation; int coordsCount = texOp.Type.GetDimensions(); bool isBindless = (texOp.Flags & TextureFlags.Bindless) != 0; bool isIndexed = (texOp.Type & SamplerType.Indexed) != 0; string indexExpr = null; if (isIndexed) { indexExpr = GetSoureExpr(context, texOp.GetSource(0), VariableType.S32); } string samplerName = OperandManager.GetSamplerName(context.Config.Stage, texOp, indexExpr); int coordsIndex = isBindless || isIndexed ? 1 : 0; string coordsExpr; if (coordsCount > 1) { string[] elems = new string[coordsCount]; for (int index = 0; index < coordsCount; index++) { elems[index] = GetSoureExpr(context, texOp.GetSource(coordsIndex + index), VariableType.F32); } coordsExpr = "vec" + coordsCount + "(" + string.Join(", ", elems) + ")"; } else { coordsExpr = GetSoureExpr(context, texOp.GetSource(coordsIndex), VariableType.F32); } return($"textureQueryLod({samplerName}, {coordsExpr}){GetMask(texOp.Index)}"); }
public static string TextureSample(CodeGenContext context, AstOperation operation) { AstTextureOperation texOp = (AstTextureOperation)operation; bool isBindless = (texOp.Flags & TextureFlags.Bindless) != 0; bool isGather = (texOp.Flags & TextureFlags.Gather) != 0; bool intCoords = (texOp.Flags & TextureFlags.IntCoords) != 0; bool hasLodBias = (texOp.Flags & TextureFlags.LodBias) != 0; bool hasLodLevel = (texOp.Flags & TextureFlags.LodLevel) != 0; bool hasOffset = (texOp.Flags & TextureFlags.Offset) != 0; bool hasOffsets = (texOp.Flags & TextureFlags.Offsets) != 0; bool isArray = (texOp.Type & TextureType.Array) != 0; bool isMultisample = (texOp.Type & TextureType.Multisample) != 0; bool isShadow = (texOp.Type & TextureType.Shadow) != 0; string texCall = intCoords ? "texelFetch" : "texture"; if (isGather) { texCall += "Gather"; } else if (hasLodLevel && !intCoords) { texCall += "Lod"; } if (hasOffset) { texCall += "Offset"; } else if (hasOffsets) { texCall += "Offsets"; } string samplerName = OperandManager.GetSamplerName(context.Config.Type, texOp); texCall += "(" + samplerName; int coordsCount = texOp.Type.GetCoordsCount(); int pCount = coordsCount; int arrayIndexElem = -1; if (isArray) { arrayIndexElem = pCount++; } //The sampler 1D shadow overload expects a //dummy value on the middle of the vector, who knows why... bool hasDummy1DShadowElem = texOp.Type == (TextureType.Texture1D | TextureType.Shadow); if (hasDummy1DShadowElem) { pCount++; } if (isShadow && !isGather) { pCount++; } //On textureGather*, the comparison value is //always specified as an extra argument. bool hasExtraCompareArg = isShadow && isGather; if (pCount == 5) { pCount = 4; hasExtraCompareArg = true; } int srcIndex = isBindless ? 1 : 0; string Src(VariableType type) { return(GetSoureExpr(context, texOp.GetSource(srcIndex++), type)); } void Append(string str) { texCall += ", " + str; } VariableType coordType = intCoords ? VariableType.S32 : VariableType.F32; string AssemblePVector(int count) { if (count > 1) { string[] elems = new string[count]; for (int index = 0; index < count; index++) { if (arrayIndexElem == index) { elems[index] = Src(VariableType.S32); if (!intCoords) { elems[index] = "float(" + elems[index] + ")"; } } else if (index == 1 && hasDummy1DShadowElem) { elems[index] = NumberFormatter.FormatFloat(0); } else { elems[index] = Src(coordType); } } string prefix = intCoords ? "i" : string.Empty; return(prefix + "vec" + count + "(" + string.Join(", ", elems) + ")"); } else { return(Src(coordType)); } } Append(AssemblePVector(pCount)); if (hasExtraCompareArg) { Append(Src(VariableType.F32)); } if (isMultisample) { Append(Src(VariableType.S32)); } else if (hasLodLevel) { Append(Src(coordType)); } string AssembleOffsetVector(int count) { if (count > 1) { string[] elems = new string[count]; for (int index = 0; index < count; index++) { elems[index] = Src(VariableType.S32); } return("ivec" + count + "(" + string.Join(", ", elems) + ")"); } else { return(Src(VariableType.S32)); } } if (hasOffset) { Append(AssembleOffsetVector(coordsCount)); } else if (hasOffsets) { texCall += $", ivec{coordsCount}[4]("; texCall += AssembleOffsetVector(coordsCount) + ", "; texCall += AssembleOffsetVector(coordsCount) + ", "; texCall += AssembleOffsetVector(coordsCount) + ", "; texCall += AssembleOffsetVector(coordsCount) + ")"; } if (hasLodBias) { Append(Src(VariableType.F32)); } //textureGather* optional extra component index, //not needed for shadow samplers. if (isGather && !isShadow) { Append(Src(VariableType.S32)); } texCall += ")" + (isGather || !isShadow ? GetMask(texOp.ComponentMask) : ""); return(texCall); }
public static string TextureSample(CodeGenContext context, AstOperation operation) { AstTextureOperation texOp = (AstTextureOperation)operation; bool isBindless = (texOp.Flags & TextureFlags.Bindless) != 0; bool isGather = (texOp.Flags & TextureFlags.Gather) != 0; bool hasDerivatives = (texOp.Flags & TextureFlags.Derivatives) != 0; bool intCoords = (texOp.Flags & TextureFlags.IntCoords) != 0; bool hasLodBias = (texOp.Flags & TextureFlags.LodBias) != 0; bool hasLodLevel = (texOp.Flags & TextureFlags.LodLevel) != 0; bool hasOffset = (texOp.Flags & TextureFlags.Offset) != 0; bool hasOffsets = (texOp.Flags & TextureFlags.Offsets) != 0; bool isArray = (texOp.Type & SamplerType.Array) != 0; bool isIndexed = (texOp.Type & SamplerType.Indexed) != 0; bool isMultisample = (texOp.Type & SamplerType.Multisample) != 0; bool isShadow = (texOp.Type & SamplerType.Shadow) != 0; // This combination is valid, but not available on GLSL. // For now, ignore the LOD level and do a normal sample. // TODO: How to implement it properly? if (hasLodLevel && isArray && isShadow) { hasLodLevel = false; } string texCall = intCoords ? "texelFetch" : "texture"; if (isGather) { texCall += "Gather"; } else if (hasDerivatives) { texCall += "Grad"; } else if (hasLodLevel && !intCoords) { texCall += "Lod"; } if (hasOffset) { texCall += "Offset"; } else if (hasOffsets) { texCall += "Offsets"; } int srcIndex = isBindless ? 1 : 0; string Src(VariableType type) { return(GetSoureExpr(context, texOp.GetSource(srcIndex++), type)); } string indexExpr = null; if (isIndexed) { indexExpr = Src(VariableType.S32); } string samplerName = OperandManager.GetSamplerName(context.Config.Stage, texOp, indexExpr); texCall += "(" + samplerName; int coordsCount = texOp.Type.GetDimensions(); int pCount = coordsCount; int arrayIndexElem = -1; if (isArray) { arrayIndexElem = pCount++; } // The sampler 1D shadow overload expects a // dummy value on the middle of the vector, who knows why... bool hasDummy1DShadowElem = texOp.Type == (SamplerType.Texture1D | SamplerType.Shadow); if (hasDummy1DShadowElem) { pCount++; } if (isShadow && !isGather) { pCount++; } // On textureGather*, the comparison value is // always specified as an extra argument. bool hasExtraCompareArg = isShadow && isGather; if (pCount == 5) { pCount = 4; hasExtraCompareArg = true; } void Append(string str) { texCall += ", " + str; } VariableType coordType = intCoords ? VariableType.S32 : VariableType.F32; string AssemblePVector(int count) { if (count > 1) { string[] elems = new string[count]; for (int index = 0; index < count; index++) { if (arrayIndexElem == index) { elems[index] = Src(VariableType.S32); if (!intCoords) { elems[index] = "float(" + elems[index] + ")"; } } else if (index == 1 && hasDummy1DShadowElem) { elems[index] = NumberFormatter.FormatFloat(0); } else { elems[index] = Src(coordType); } } string prefix = intCoords ? "i" : string.Empty; return(prefix + "vec" + count + "(" + string.Join(", ", elems) + ")"); } else { return(Src(coordType)); } } string ApplyScaling(string vector) { if (intCoords) { int index = context.FindTextureDescriptorIndex(texOp); if ((context.Config.Stage == ShaderStage.Fragment || context.Config.Stage == ShaderStage.Compute) && (texOp.Flags & TextureFlags.Bindless) == 0 && texOp.Type != SamplerType.Indexed && pCount == 2) { return("Helper_TexelFetchScale(" + vector + ", " + index + ")"); } else { // Resolution scaling cannot be applied to this texture right now. // Flag so that we know to blacklist scaling on related textures when binding them. TextureDescriptor descriptor = context.TextureDescriptors[index]; descriptor.Flags |= TextureUsageFlags.ResScaleUnsupported; context.TextureDescriptors[index] = descriptor; } } return(vector); } Append(ApplyScaling(AssemblePVector(pCount))); string AssembleDerivativesVector(int count) { if (count > 1) { string[] elems = new string[count]; for (int index = 0; index < count; index++) { elems[index] = Src(VariableType.F32); } return("vec" + count + "(" + string.Join(", ", elems) + ")"); } else { return(Src(VariableType.F32)); } } if (hasExtraCompareArg) { Append(Src(VariableType.F32)); } if (hasDerivatives) { Append(AssembleDerivativesVector(coordsCount)); // dPdx Append(AssembleDerivativesVector(coordsCount)); // dPdy } if (isMultisample) { Append(Src(VariableType.S32)); } else if (hasLodLevel) { Append(Src(coordType)); } string AssembleOffsetVector(int count) { if (count > 1) { string[] elems = new string[count]; for (int index = 0; index < count; index++) { elems[index] = Src(VariableType.S32); } return("ivec" + count + "(" + string.Join(", ", elems) + ")"); } else { return(Src(VariableType.S32)); } } if (hasOffset) { Append(AssembleOffsetVector(coordsCount)); } else if (hasOffsets) { texCall += $", ivec{coordsCount}[4]("; texCall += AssembleOffsetVector(coordsCount) + ", "; texCall += AssembleOffsetVector(coordsCount) + ", "; texCall += AssembleOffsetVector(coordsCount) + ", "; texCall += AssembleOffsetVector(coordsCount) + ")"; } if (hasLodBias) { Append(Src(VariableType.F32)); } // textureGather* optional extra component index, // not needed for shadow samplers. if (isGather && !isShadow) { Append(Src(VariableType.S32)); } texCall += ")" + (isGather || !isShadow ? GetMask(texOp.Index) : ""); return(texCall); }