LLVMValueRef coord,
LLVMValueRef length,
LLVMValueRef length_f,
+ LLVMValueRef offset,
boolean is_pot,
unsigned wrap_mode,
LLVMValueRef *x0_out,
/* mul by size and subtract 0.5 */
coord = lp_build_mul(coord_bld, coord, length_f);
coord = lp_build_sub(coord_bld, coord, half);
+ if (offset) {
+ offset = lp_build_int_to_float(coord_bld, offset);
+ coord = lp_build_add(coord_bld, coord, offset);
+ }
/* convert to int, compute lerp weight */
lp_build_ifloor_fract(coord_bld, coord, &coord0, &weight);
coord1 = lp_build_add(int_coord_bld, coord0, int_coord_bld->one);
}
else {
LLVMValueRef mask;
+ if (offset) {
+ offset = lp_build_int_to_float(coord_bld, offset);
+ offset = lp_build_div(coord_bld, offset, length_f);
+ coord = lp_build_add(coord_bld, coord, offset);
+ }
lp_build_coord_repeat_npot_linear(bld, coord,
length, length_f,
&coord0, &weight);
/* scale coord to length */
coord = lp_build_mul(coord_bld, coord, length_f);
}
+ if (offset) {
+ offset = lp_build_int_to_float(coord_bld, offset);
+ coord = lp_build_add(coord_bld, coord, offset);
+ }
/* clamp to [0, length] */
coord = lp_build_clamp(coord_bld, coord, coord_bld->zero, length_f);
/* mul by tex size */
coord = lp_build_mul(coord_bld, coord, length_f);
}
+ if (offset) {
+ offset = lp_build_int_to_float(coord_bld, offset);
+ coord = lp_build_add(coord_bld, coord, offset);
+ }
+
/* clamp to length max */
coord = lp_build_min(coord_bld, coord, length_f);
/* subtract 0.5 */
/* scale coord to length */
coord = lp_build_mul(coord_bld, coord, length_f);
}
+ if (offset) {
+ offset = lp_build_int_to_float(coord_bld, offset);
+ coord = lp_build_add(coord_bld, coord, offset);
+ }
/* was: clamp to [-0.5, length + 0.5], then sub 0.5 */
/* can skip clamp (though might not work for very large coord values */
coord = lp_build_sub(coord_bld, coord, half);
/* scale coord to length */
coord = lp_build_mul(coord_bld, coord, length_f);
coord = lp_build_sub(coord_bld, coord, half);
+ if (offset) {
+ offset = lp_build_int_to_float(coord_bld, offset);
+ coord = lp_build_add(coord_bld, coord, offset);
+ }
/* convert to int, compute lerp weight */
lp_build_ifloor_fract(coord_bld, coord, &coord0, &weight);
break;
case PIPE_TEX_WRAP_MIRROR_CLAMP:
- coord = lp_build_abs(coord_bld, coord);
-
if (bld->static_sampler_state->normalized_coords) {
/* scale coord to length */
coord = lp_build_mul(coord_bld, coord, length_f);
}
+ if (offset) {
+ offset = lp_build_int_to_float(coord_bld, offset);
+ coord = lp_build_add(coord_bld, coord, offset);
+ }
+ coord = lp_build_abs(coord_bld, coord);
/* clamp to [0, length] */
coord = lp_build_min(coord_bld, coord, length_f);
case PIPE_TEX_WRAP_MIRROR_CLAMP_TO_EDGE:
{
- LLVMValueRef min, max;
struct lp_build_context abs_coord_bld = bld->coord_bld;
abs_coord_bld.type.sign = FALSE;
- coord = lp_build_abs(coord_bld, coord);
if (bld->static_sampler_state->normalized_coords) {
/* scale coord to length */
coord = lp_build_mul(coord_bld, coord, length_f);
}
+ if (offset) {
+ offset = lp_build_int_to_float(coord_bld, offset);
+ coord = lp_build_add(coord_bld, coord, offset);
+ }
+ coord = lp_build_abs(coord_bld, coord);
- /* clamp to [0.5, length - 0.5] */
- min = half;
- max = lp_build_sub(coord_bld, length_f, min);
- coord = lp_build_clamp(coord_bld, coord, min, max);
-
+ /* clamp to length max */
+ coord = lp_build_min(coord_bld, coord, length_f);
+ /* subtract 0.5 */
coord = lp_build_sub(coord_bld, coord, half);
+ /* clamp to [0, length - 0.5] */
+ coord = lp_build_max(coord_bld, coord, coord_bld->zero);
/* convert to int, compute lerp weight */
lp_build_ifloor_fract(&abs_coord_bld, coord, &coord0, &weight);
coord1 = lp_build_add(int_coord_bld, coord0, int_coord_bld->one);
+ /* coord1 = min(coord1, length-1) */
+ coord1 = lp_build_min(int_coord_bld, coord1, length_minus_one);
}
break;
case PIPE_TEX_WRAP_MIRROR_CLAMP_TO_BORDER:
{
- coord = lp_build_abs(coord_bld, coord);
-
if (bld->static_sampler_state->normalized_coords) {
/* scale coord to length */
coord = lp_build_mul(coord_bld, coord, length_f);
}
+ if (offset) {
+ offset = lp_build_int_to_float(coord_bld, offset);
+ coord = lp_build_add(coord_bld, coord, offset);
+ }
+ coord = lp_build_abs(coord_bld, coord);
/* was: clamp to [-0.5, length + 0.5] then sub 0.5 */
/* skip clamp - always positive, and other side
* Build LLVM code for texture wrap mode for nearest filtering.
* \param coord the incoming texcoord (nominally in [0,1])
* \param length the texture size along one dimension, as int vector
+ * \param length_f the texture size along one dimension, as float vector
+ * \param offset texel offset along one dimension (as int vector)
* \param is_pot if TRUE, length is a power of two
* \param wrap_mode one of PIPE_TEX_WRAP_x
*/
LLVMValueRef coord,
LLVMValueRef length,
LLVMValueRef length_f,
+ LLVMValueRef offset,
boolean is_pot,
unsigned wrap_mode)
{
if (is_pot) {
coord = lp_build_mul(coord_bld, coord, length_f);
icoord = lp_build_ifloor(coord_bld, coord);
+ if (offset) {
+ icoord = lp_build_add(int_coord_bld, icoord, offset);
+ }
icoord = LLVMBuildAnd(builder, icoord, length_minus_one, "");
}
else {
+ if (offset) {
+ offset = lp_build_int_to_float(coord_bld, offset);
+ offset = lp_build_div(coord_bld, offset, length_f);
+ coord = lp_build_add(coord_bld, coord, offset);
+ }
/* take fraction, unnormalize */
coord = lp_build_fract_safe(coord_bld, coord);
coord = lp_build_mul(coord_bld, coord, length_f);
/* floor */
/* use itrunc instead since we clamp to 0 anyway */
icoord = lp_build_itrunc(coord_bld, coord);
+ if (offset) {
+ icoord = lp_build_add(int_coord_bld, icoord, offset);
+ }
/* clamp to [0, length - 1]. */
icoord = lp_build_clamp(int_coord_bld, icoord, int_coord_bld->zero,
}
/* no clamp necessary, border masking will handle this */
icoord = lp_build_ifloor(coord_bld, coord);
+ if (offset) {
+ icoord = lp_build_add(int_coord_bld, icoord, offset);
+ }
break;
case PIPE_TEX_WRAP_MIRROR_REPEAT:
+ if (offset) {
+ offset = lp_build_int_to_float(coord_bld, offset);
+ offset = lp_build_div(coord_bld, offset, length_f);
+ coord = lp_build_add(coord_bld, coord, offset);
+ }
/* compute mirror function */
coord = lp_build_coord_mirror(bld, coord);
case PIPE_TEX_WRAP_MIRROR_CLAMP:
case PIPE_TEX_WRAP_MIRROR_CLAMP_TO_EDGE:
- coord = lp_build_abs(coord_bld, coord);
-
if (bld->static_sampler_state->normalized_coords) {
/* scale coord to length */
coord = lp_build_mul(coord_bld, coord, length_f);
}
+ if (offset) {
+ offset = lp_build_int_to_float(coord_bld, offset);
+ coord = lp_build_add(coord_bld, coord, offset);
+ }
+ coord = lp_build_abs(coord_bld, coord);
/* itrunc == ifloor here */
icoord = lp_build_itrunc(coord_bld, coord);
break;
case PIPE_TEX_WRAP_MIRROR_CLAMP_TO_BORDER:
- coord = lp_build_abs(coord_bld, coord);
-
if (bld->static_sampler_state->normalized_coords) {
/* scale coord to length */
coord = lp_build_mul(coord_bld, coord, length_f);
}
+ if (offset) {
+ offset = lp_build_int_to_float(coord_bld, offset);
+ coord = lp_build_add(coord_bld, coord, offset);
+ }
+ coord = lp_build_abs(coord_bld, coord);
/* itrunc == ifloor here */
icoord = lp_build_itrunc(coord_bld, coord);
LLVMValueRef s,
LLVMValueRef t,
LLVMValueRef r,
+ const LLVMValueRef *offsets,
LLVMValueRef colors_out[4])
{
const unsigned dims = bld->dims;
/*
* Compute integer texcoords.
*/
- x = lp_build_sample_wrap_nearest(bld, s, width_vec, flt_width_vec,
+ x = lp_build_sample_wrap_nearest(bld, s, width_vec, flt_width_vec, offsets[0],
bld->static_texture_state->pot_width,
bld->static_sampler_state->wrap_s);
lp_build_name(x, "tex.x.wrapped");
if (dims >= 2) {
- y = lp_build_sample_wrap_nearest(bld, t, height_vec, flt_height_vec,
+ y = lp_build_sample_wrap_nearest(bld, t, height_vec, flt_height_vec, offsets[1],
bld->static_texture_state->pot_height,
bld->static_sampler_state->wrap_t);
lp_build_name(y, "tex.y.wrapped");
if (dims == 3) {
- z = lp_build_sample_wrap_nearest(bld, r, depth_vec, flt_depth_vec,
+ z = lp_build_sample_wrap_nearest(bld, r, depth_vec, flt_depth_vec, offsets[2],
bld->static_texture_state->pot_depth,
bld->static_sampler_state->wrap_r);
lp_build_name(z, "tex.z.wrapped");
LLVMValueRef s,
LLVMValueRef t,
LLVMValueRef r,
+ const LLVMValueRef *offsets,
LLVMValueRef colors_out[4])
{
const unsigned dims = bld->dims;
/*
* Compute integer texcoords.
*/
- lp_build_sample_wrap_linear(bld, s, width_vec, flt_width_vec,
+ lp_build_sample_wrap_linear(bld, s, width_vec, flt_width_vec, offsets[0],
bld->static_texture_state->pot_width,
bld->static_sampler_state->wrap_s,
&x0, &x1, &s_fpart);
lp_build_name(x1, "tex.x1.wrapped");
if (dims >= 2) {
- lp_build_sample_wrap_linear(bld, t, height_vec, flt_height_vec,
+ lp_build_sample_wrap_linear(bld, t, height_vec, flt_height_vec, offsets[1],
bld->static_texture_state->pot_height,
bld->static_sampler_state->wrap_t,
&y0, &y1, &t_fpart);
lp_build_name(y1, "tex.y1.wrapped");
if (dims == 3) {
- lp_build_sample_wrap_linear(bld, r, depth_vec, flt_depth_vec,
+ lp_build_sample_wrap_linear(bld, r, depth_vec, flt_depth_vec, offsets[2],
bld->static_texture_state->pot_depth,
bld->static_sampler_state->wrap_r,
&z0, &z1, &r_fpart);
for (chan = 0; chan < 4; chan++) {
colors_out[chan] = lp_build_lerp(&bld->texel_bld, s_fpart,
neighbors[0][0][chan],
- neighbors[0][1][chan]);
+ neighbors[0][1][chan],
+ 0);
}
}
else {
neighbors[0][0][chan],
neighbors[0][1][chan],
neighbors[1][0][chan],
- neighbors[1][1][chan]);
+ neighbors[1][1][chan],
+ 0);
}
if (dims == 3) {
neighbors1[0][0][chan],
neighbors1[0][1][chan],
neighbors1[1][0][chan],
- neighbors1[1][1][chan]);
+ neighbors1[1][1][chan],
+ 0);
}
/* Linearly interpolate the two samples from the two 3D slices */
for (chan = 0; chan < 4; chan++) {
colors_out[chan] = lp_build_lerp(&bld->texel_bld,
r_fpart,
- colors0[chan], colors1[chan]);
+ colors0[chan], colors1[chan],
+ 0);
}
}
else {
LLVMValueRef s,
LLVMValueRef t,
LLVMValueRef r,
+ const LLVMValueRef *offsets,
LLVMValueRef ilevel0,
LLVMValueRef ilevel1,
LLVMValueRef lod_fpart,
lp_build_sample_image_nearest(bld, sampler_unit,
size0,
row_stride0_vec, img_stride0_vec,
- data_ptr0, mipoff0, s, t, r,
+ data_ptr0, mipoff0, s, t, r, offsets,
colors0);
}
else {
lp_build_sample_image_linear(bld, sampler_unit,
size0,
row_stride0_vec, img_stride0_vec,
- data_ptr0, mipoff0, s, t, r,
+ data_ptr0, mipoff0, s, t, r, offsets,
colors0);
}
if (mip_filter == PIPE_TEX_MIPFILTER_LINEAR) {
struct lp_build_if_state if_ctx;
LLVMValueRef need_lerp;
- unsigned num_quads = bld->coord_bld.type.length / 4;
/* need_lerp = lod_fpart > 0 */
- if (num_quads == 1) {
+ if (bld->num_lods == 1) {
need_lerp = LLVMBuildFCmp(builder, LLVMRealUGT,
- lod_fpart, bld->perquadf_bld.zero,
+ lod_fpart, bld->levelf_bld.zero,
"need_lerp");
}
else {
/*
- * We'll do mip filtering if any of the quads need it.
+ * We'll do mip filtering if any of the quads (or individual
+ * pixel in case of per-pixel lod) need it.
* It might be better to split the vectors here and only fetch/filter
* quads which need it.
*/
* negative values which would screw up filtering if not all
* lod_fpart values have same sign.
*/
- lod_fpart = lp_build_max(&bld->perquadf_bld, lod_fpart,
- bld->perquadf_bld.zero);
- need_lerp = lp_build_compare(bld->gallivm, bld->perquadf_bld.type,
+ lod_fpart = lp_build_max(&bld->levelf_bld, lod_fpart,
+ bld->levelf_bld.zero);
+ need_lerp = lp_build_compare(bld->gallivm, bld->levelf_bld.type,
PIPE_FUNC_GREATER,
- lod_fpart, bld->perquadf_bld.zero);
- need_lerp = lp_build_any_true_range(&bld->perquadi_bld, num_quads, need_lerp);
- }
+ lod_fpart, bld->levelf_bld.zero);
+ need_lerp = lp_build_any_true_range(&bld->leveli_bld, bld->num_lods, need_lerp);
+ }
lp_build_if(&if_ctx, bld->gallivm, need_lerp);
{
lp_build_sample_image_nearest(bld, sampler_unit,
size1,
row_stride1_vec, img_stride1_vec,
- data_ptr1, mipoff1, s, t, r,
+ data_ptr1, mipoff1, s, t, r, offsets,
colors1);
}
else {
lp_build_sample_image_linear(bld, sampler_unit,
size1,
row_stride1_vec, img_stride1_vec,
- data_ptr1, mipoff1, s, t, r,
+ data_ptr1, mipoff1, s, t, r, offsets,
colors1);
}
/* interpolate samples from the two mipmap levels */
- lod_fpart = lp_build_unpack_broadcast_aos_scalars(bld->gallivm,
- bld->perquadf_bld.type,
- bld->texel_bld.type,
- lod_fpart);
+ if (bld->num_lods != bld->coord_type.length)
+ lod_fpart = lp_build_unpack_broadcast_aos_scalars(bld->gallivm,
+ bld->levelf_bld.type,
+ bld->texel_bld.type,
+ lod_fpart);
for (chan = 0; chan < 4; chan++) {
colors0[chan] = lp_build_lerp(&bld->texel_bld, lod_fpart,
- colors0[chan], colors1[chan]);
+ colors0[chan], colors1[chan],
+ 0);
LLVMBuildStore(builder, colors0[chan], colors_out[chan]);
}
}
/**
- * Clamp layer coord to valid values.
+ * Build (per-coord) layer value.
+ * Either clamp layer to valid values or fill in optional out_of_bounds
+ * value and just return value unclamped.
*/
static LLVMValueRef
lp_build_layer_coord(struct lp_build_sample_context *bld,
unsigned texture_unit,
- LLVMValueRef layer)
+ LLVMValueRef layer,
+ LLVMValueRef *out_of_bounds)
{
- LLVMValueRef maxlayer;
+ LLVMValueRef num_layers;
+ struct lp_build_context *int_coord_bld = &bld->int_coord_bld;
- maxlayer = bld->dynamic_state->depth(bld->dynamic_state,
- bld->gallivm, texture_unit);
- maxlayer = lp_build_sub(&bld->int_bld, maxlayer, bld->int_bld.one);
- maxlayer = lp_build_broadcast_scalar(&bld->int_coord_bld, maxlayer);
- return lp_build_clamp(&bld->int_coord_bld, layer,
- bld->int_coord_bld.zero, maxlayer);
+ num_layers = bld->dynamic_state->depth(bld->dynamic_state,
+ bld->gallivm, texture_unit);
+ if (out_of_bounds) {
+ LLVMValueRef out1, out;
+ num_layers = lp_build_broadcast_scalar(int_coord_bld, num_layers);
+ out = lp_build_cmp(int_coord_bld, PIPE_FUNC_LESS, layer, int_coord_bld->zero);
+ out1 = lp_build_cmp(int_coord_bld, PIPE_FUNC_GEQUAL, layer, num_layers);
+ *out_of_bounds = lp_build_or(int_coord_bld, out, out1);
+ return layer;
+ }
+ else {
+ LLVMValueRef maxlayer;
+ maxlayer = lp_build_sub(&bld->int_bld, num_layers, bld->int_bld.one);
+ maxlayer = lp_build_broadcast_scalar(int_coord_bld, maxlayer);
+ return lp_build_clamp(int_coord_bld, layer, int_coord_bld->zero, maxlayer);
+ }
}
LLVMValueRef *s,
LLVMValueRef *t,
LLVMValueRef *r,
- const struct lp_derivatives *derivs,
+ const struct lp_derivatives *derivs, /* optional */
LLVMValueRef lod_bias, /* optional */
LLVMValueRef explicit_lod, /* optional */
LLVMValueRef *lod_ipart,
const unsigned min_filter = bld->static_sampler_state->min_img_filter;
const unsigned mag_filter = bld->static_sampler_state->mag_img_filter;
const unsigned target = bld->static_texture_state->target;
- LLVMValueRef first_level;
- struct lp_derivatives face_derivs;
+ LLVMValueRef first_level, cube_rho = NULL;
/*
printf("%s mip %d min %d mag %d\n", __FUNCTION__,
*/
/*
- * Choose cube face, recompute texcoords and derivatives for the chosen face.
+ * Choose cube face, recompute texcoords for the chosen face and
+ * compute rho here too (as it requires transform of derivatives).
*/
if (target == PIPE_TEXTURE_CUBE) {
LLVMValueRef face, face_s, face_t;
- lp_build_cube_lookup(bld, *s, *t, *r, &face, &face_s, &face_t);
+ boolean need_derivs;
+ need_derivs = ((min_filter != mag_filter ||
+ mip_filter != PIPE_TEX_MIPFILTER_NONE) &&
+ !bld->static_sampler_state->min_max_lod_equal &&
+ !explicit_lod);
+ lp_build_cube_lookup(bld, *s, *t, *r, derivs, &face, &face_s, &face_t,
+ &cube_rho, need_derivs);
*s = face_s; /* vec */
*t = face_t; /* vec */
/* use 'r' to indicate cube face */
*r = face; /* vec */
-
- /* recompute ddx, ddy using the new (s,t) face texcoords */
- face_derivs.ddx_ddy[0] = lp_build_packed_ddx_ddy_twocoord(&bld->coord_bld, *s, *t);
- face_derivs.ddx_ddy[1] = NULL;
- derivs = &face_derivs;
}
else if (target == PIPE_TEXTURE_1D_ARRAY) {
*r = lp_build_iround(&bld->coord_bld, *t);
- *r = lp_build_layer_coord(bld, texture_index, *r);
+ *r = lp_build_layer_coord(bld, texture_index, *r, NULL);
}
else if (target == PIPE_TEXTURE_2D_ARRAY) {
*r = lp_build_iround(&bld->coord_bld, *r);
- *r = lp_build_layer_coord(bld, texture_index, *r);
+ *r = lp_build_layer_coord(bld, texture_index, *r, NULL);
}
/*
* distinguish between minification/magnification with one mipmap level.
*/
lp_build_lod_selector(bld, texture_index, sampler_index,
+ *s, *t, *r, cube_rho,
derivs, lod_bias, explicit_lod,
mip_filter,
lod_ipart, lod_fpart);
} else {
- *lod_ipart = bld->perquadi_bld.zero;
+ *lod_ipart = bld->leveli_bld.zero;
}
/*
/* fall-through */
case PIPE_TEX_MIPFILTER_NONE:
/* always use mip level 0 */
- if (target == PIPE_TEXTURE_CUBE) {
+ if (HAVE_LLVM == 0x0207 && target == PIPE_TEXTURE_CUBE) {
/* XXX this is a work-around for an apparent bug in LLVM 2.7.
* We should be able to set ilevel0 = const(0) but that causes
* bad x86 code to be emitted.
- * XXX should probably disable that on other llvm versions.
*/
assert(*lod_ipart);
- lp_build_nearest_mip_level(bld, texture_index, *lod_ipart, ilevel0);
+ lp_build_nearest_mip_level(bld, texture_index, *lod_ipart, ilevel0, NULL);
}
else {
first_level = bld->dynamic_state->first_level(bld->dynamic_state,
bld->gallivm, texture_index);
- first_level = lp_build_broadcast_scalar(&bld->perquadi_bld, first_level);
+ first_level = lp_build_broadcast_scalar(&bld->leveli_bld, first_level);
*ilevel0 = first_level;
}
break;
case PIPE_TEX_MIPFILTER_NEAREST:
assert(*lod_ipart);
- lp_build_nearest_mip_level(bld, texture_index, *lod_ipart, ilevel0);
+ lp_build_nearest_mip_level(bld, texture_index, *lod_ipart, ilevel0, NULL);
break;
case PIPE_TEX_MIPFILTER_LINEAR:
assert(*lod_ipart);
LLVMValueRef s,
LLVMValueRef t,
LLVMValueRef r,
+ const LLVMValueRef *offsets,
LLVMValueRef lod_ipart,
LLVMValueRef lod_fpart,
LLVMValueRef ilevel0,
/* no need to distinguish between minification and magnification */
lp_build_sample_mipmap(bld, sampler_unit,
min_filter, mip_filter,
- s, t, r,
+ s, t, r, offsets,
ilevel0, ilevel1, lod_fpart,
texels);
}
/* Use the minification filter */
lp_build_sample_mipmap(bld, sampler_unit,
min_filter, mip_filter,
- s, t, r,
+ s, t, r, offsets,
ilevel0, ilevel1, lod_fpart,
texels);
}
/* Use the magnification filter */
lp_build_sample_mipmap(bld, sampler_unit,
mag_filter, PIPE_TEX_MIPFILTER_NONE,
- s, t, r,
+ s, t, r, offsets,
ilevel0, NULL, NULL,
texels);
}
const LLVMValueRef *offsets,
LLVMValueRef *colors_out)
{
- struct lp_build_context *perquadi_bld = &bld->perquadi_bld;
+ struct lp_build_context *perquadi_bld = &bld->leveli_bld;
struct lp_build_context *int_coord_bld = &bld->int_coord_bld;
unsigned dims = bld->dims, chan;
unsigned target = bld->static_texture_state->target;
+ boolean out_of_bound_ret_zero = TRUE;
LLVMValueRef size, ilevel;
LLVMValueRef row_stride_vec = NULL, img_stride_vec = NULL;
LLVMValueRef x = coords[0], y = coords[1], z = coords[2];
LLVMValueRef width, height, depth, i, j;
LLVMValueRef offset, out_of_bounds, out1;
- /* XXX just like ordinary sampling, we don't handle per-pixel lod (yet). */
+ out_of_bounds = int_coord_bld->zero;
+
if (explicit_lod && bld->static_texture_state->target != PIPE_BUFFER) {
- ilevel = lp_build_pack_aos_scalars(bld->gallivm, int_coord_bld->type,
- perquadi_bld->type, explicit_lod, 0);
- lp_build_nearest_mip_level(bld, texture_unit, ilevel, &ilevel);
+ if (bld->num_lods != int_coord_bld->type.length) {
+ ilevel = lp_build_pack_aos_scalars(bld->gallivm, int_coord_bld->type,
+ perquadi_bld->type, explicit_lod, 0);
+ }
+ else {
+ ilevel = explicit_lod;
+ }
+ lp_build_nearest_mip_level(bld, texture_unit, ilevel, &ilevel,
+ out_of_bound_ret_zero ? &out_of_bounds : NULL);
}
else {
- bld->num_lods = 1;
- ilevel = lp_build_const_int32(bld->gallivm, 0);
+ assert(bld->num_lods == 1);
+ if (bld->static_texture_state->target != PIPE_BUFFER) {
+ ilevel = bld->dynamic_state->first_level(bld->dynamic_state,
+ bld->gallivm, texture_unit);
+ }
+ else {
+ ilevel = lp_build_const_int32(bld->gallivm, 0);
+ }
}
lp_build_mipmap_level_sizes(bld, ilevel,
&size,
if (target == PIPE_TEXTURE_1D_ARRAY ||
target == PIPE_TEXTURE_2D_ARRAY) {
if (target == PIPE_TEXTURE_1D_ARRAY) {
- z = lp_build_layer_coord(bld, texture_unit, y);
+ z = y;
+ }
+ if (out_of_bound_ret_zero) {
+ z = lp_build_layer_coord(bld, texture_unit, z, &out1);
+ out_of_bounds = lp_build_or(int_coord_bld, out_of_bounds, out1);
}
else {
- z = lp_build_layer_coord(bld, texture_unit, z);
+ z = lp_build_layer_coord(bld, texture_unit, z, NULL);
}
}
/* This is a lot like border sampling */
if (offsets[0]) {
- /* XXX coords are really unsigned, offsets are signed */
+ /*
+ * coords are really unsigned, offsets are signed, but I don't think
+ * exceeding 31 bits is possible
+ */
x = lp_build_add(int_coord_bld, x, offsets[0]);
}
- out_of_bounds = lp_build_cmp(int_coord_bld, PIPE_FUNC_LESS, x, int_coord_bld->zero);
+ out1 = lp_build_cmp(int_coord_bld, PIPE_FUNC_LESS, x, int_coord_bld->zero);
+ out_of_bounds = lp_build_or(int_coord_bld, out_of_bounds, out1);
out1 = lp_build_cmp(int_coord_bld, PIPE_FUNC_GEQUAL, x, width);
out_of_bounds = lp_build_or(int_coord_bld, out_of_bounds, out1);
i, j,
colors_out);
- if (0) {
+ if (out_of_bound_ret_zero) {
/*
- * Not needed except for ARB_robust_buffer_access_behavior.
+ * Only needed for ARB_robust_buffer_access_behavior and d3d10.
* Could use min/max above instead of out-of-bounds comparisons
- * (in fact cast to unsigned and min only is sufficient)
* if we don't care about the result returned for out-of-bounds.
*/
for (chan = 0; chan < 4; chan++) {
LLVMBuilderRef builder = bld->gallivm->builder;
LLVMValueRef res, p;
const unsigned chan = 0;
+ unsigned chan_type;
+ const struct util_format_description *format_desc;
if (bld->static_sampler_state->compare_mode == PIPE_TEX_COMPARE_NONE)
return;
coord, tex);
}
- /* Clamp p coords to [0,1] */
- p = lp_build_clamp(&bld->coord_bld, p,
- bld->coord_bld.zero,
- bld->coord_bld.one);
+ /* Clamp p coords to [0,1] for fixed function depth texture format */
+ format_desc = util_format_description(bld->static_texture_state->format);
+ /* not entirely sure we couldn't end up with non-valid swizzle here */
+ chan_type = format_desc->swizzle[0] <= UTIL_FORMAT_SWIZZLE_W ?
+ format_desc->channel[format_desc->swizzle[0]].type :
+ UTIL_FORMAT_TYPE_FLOAT;
+ if (chan_type != UTIL_FORMAT_TYPE_FLOAT) {
+ p = lp_build_clamp(&bld->coord_bld, p,
+ bld->coord_bld.zero, bld->coord_bld.one);
+ }
+
+ /*
+ * technically this is not entirely correct for unorm depth as the ref value
+ * should be converted to the depth format (quantization!) and comparison
+ * then done in texture format.
+ */
/* result = (p FUNC texel) ? 1 : 0 */
- res = lp_build_cmp(texel_bld, bld->static_sampler_state->compare_func,
- p, texel[chan]);
+ /*
+ * honor d3d10 floating point rules here, which state that comparisons
+ * are ordered except NOT_EQUAL which is unordered.
+ */
+ if (bld->static_sampler_state->compare_func != PIPE_FUNC_NOTEQUAL) {
+ res = lp_build_cmp_ordered(texel_bld, bld->static_sampler_state->compare_func,
+ p, texel[chan]);
+ }
+ else {
+ res = lp_build_cmp(texel_bld, bld->static_sampler_state->compare_func,
+ p, texel[chan]);
+ }
res = lp_build_select(texel_bld, res, texel_bld->one, texel_bld->zero);
- /* XXX returning result for default GL_DEPTH_TEXTURE_MODE = GL_LUMINANCE */
+ /*
+ * returning result for default GL_DEPTH_TEXTURE_MODE = GL_LUMINANCE.
+ * This should be ok because sampler swizzle is applied on top of it.
+ */
texel[0] =
texel[1] =
texel[2] = res;
unsigned sampler_index,
const LLVMValueRef *coords,
const LLVMValueRef *offsets,
- const struct lp_derivatives *derivs,
+ const struct lp_derivatives *derivs, /* optional */
LLVMValueRef lod_bias, /* optional */
LLVMValueRef explicit_lod, /* optional */
+ boolean scalar_lod,
LLVMValueRef texel_out[4])
{
unsigned dims = texture_dims(static_texture_state->target);
struct lp_static_sampler_state derived_sampler_state = *static_sampler_state;
LLVMTypeRef i32t = LLVMInt32TypeInContext(gallivm->context);
LLVMBuilderRef builder = gallivm->builder;
- LLVMValueRef tex_width, tex_height, tex_depth;
+ LLVMValueRef tex_width;
LLVMValueRef s;
LLVMValueRef t;
LLVMValueRef r;
bld.float_size_in_type.length = dims > 1 ? 4 : 1;
bld.int_size_in_type = lp_int_type(bld.float_size_in_type);
bld.texel_type = type;
- bld.perquadf_type = type;
- /* we want native vector size to be able to use our intrinsics */
- bld.perquadf_type.length = type.length > 4 ? ((type.length + 15) / 16) * 4 : 1;
- bld.perquadi_type = lp_int_type(bld.perquadf_type);
/* always using the first channel hopefully should be safe,
* if not things WILL break in other places anyway.
bld.texel_type = lp_type_uint_vec(type.width, type.width * type.length);
}
}
+ else if (util_format_has_stencil(bld.format_desc) &&
+ !util_format_has_depth(bld.format_desc)) {
+ /* for stencil only formats, sample stencil (uint) */
+ bld.texel_type = lp_type_int_vec(type.width, type.width * type.length);
+ }
if (!static_texture_state->level_zero_only) {
derived_sampler_state.min_mip_filter = static_sampler_state->min_mip_filter;
debug_printf(" .min_mip_filter = %u\n", derived_sampler_state.min_mip_filter);
}
+ /*
+ * This is all a bit complicated different paths are chosen for performance
+ * reasons.
+ * Essentially, there can be 1 lod per element, 1 lod per quad or 1 lod for
+ * everything (the last two options are equivalent for 4-wide case).
+ * If there's per-quad lod but we split to 4-wide so we can use AoS, per-quad
+ * lod is calculated then the lod value extracted afterwards so making this
+ * case basically the same as far as lod handling is concerned for the
+ * further sample/filter code as the 1 lod for everything case.
+ * Different lod handling mostly shows up when building mipmap sizes
+ * (lp_build_mipmap_level_sizes() and friends) and also in filtering
+ * (getting the fractional part of the lod to the right texels).
+ */
+
/*
* There are other situations where at least the multiple int lods could be
* avoided like min and max lod being equal.
*/
- if ((is_fetch && explicit_lod && bld.static_texture_state->target != PIPE_BUFFER) ||
- (!is_fetch && mip_filter != PIPE_TEX_MIPFILTER_NONE)) {
+ if (explicit_lod && !scalar_lod &&
+ ((is_fetch && bld.static_texture_state->target != PIPE_BUFFER) ||
+ (!is_fetch && mip_filter != PIPE_TEX_MIPFILTER_NONE)))
+ bld.num_lods = type.length;
+ /* TODO: for true scalar_lod should only use 1 lod value */
+ else if ((is_fetch && explicit_lod && bld.static_texture_state->target != PIPE_BUFFER ) ||
+ (!is_fetch && mip_filter != PIPE_TEX_MIPFILTER_NONE)) {
bld.num_lods = num_quads;
}
else {
bld.num_lods = 1;
}
+ bld.levelf_type = type;
+ /* we want native vector size to be able to use our intrinsics */
+ if (bld.num_lods != type.length) {
+ bld.levelf_type.length = type.length > 4 ? ((type.length + 15) / 16) * 4 : 1;
+ }
+ bld.leveli_type = lp_int_type(bld.levelf_type);
bld.float_size_type = bld.float_size_in_type;
- bld.float_size_type.length = bld.num_lods > 1 ? type.length :
- bld.float_size_in_type.length;
+ /* Note: size vectors may not be native. They contain minified w/h/d/_ values,
+ * with per-element lod that is w0/h0/d0/_/w1/h1/d1_/... so up to 8x4f32 */
+ if (bld.num_lods > 1) {
+ bld.float_size_type.length = bld.num_lods == type.length ?
+ bld.num_lods * bld.float_size_in_type.length :
+ type.length;
+ }
bld.int_size_type = lp_int_type(bld.float_size_type);
lp_build_context_init(&bld.float_bld, gallivm, bld.float_type);
lp_build_context_init(&bld.int_size_bld, gallivm, bld.int_size_type);
lp_build_context_init(&bld.float_size_bld, gallivm, bld.float_size_type);
lp_build_context_init(&bld.texel_bld, gallivm, bld.texel_type);
- lp_build_context_init(&bld.perquadf_bld, gallivm, bld.perquadf_type);
- lp_build_context_init(&bld.perquadi_bld, gallivm, bld.perquadi_type);
+ lp_build_context_init(&bld.levelf_bld, gallivm, bld.levelf_type);
+ lp_build_context_init(&bld.leveli_bld, gallivm, bld.leveli_type);
/* Get the dynamic state */
tex_width = dynamic_state->width(dynamic_state, gallivm, texture_index);
- tex_height = dynamic_state->height(dynamic_state, gallivm, texture_index);
- tex_depth = dynamic_state->depth(dynamic_state, gallivm, texture_index);
bld.row_stride_array = dynamic_state->row_stride(dynamic_state, gallivm, texture_index);
bld.img_stride_array = dynamic_state->img_stride(dynamic_state, gallivm, texture_index);
bld.base_ptr = dynamic_state->base_ptr(dynamic_state, gallivm, texture_index);
bld.int_size = LLVMBuildInsertElement(builder, bld.int_size_in_bld.undef,
tex_width, LLVMConstInt(i32t, 0, 0), "");
if (dims >= 2) {
+ LLVMValueRef tex_height =
+ dynamic_state->height(dynamic_state, gallivm, texture_index);
bld.int_size = LLVMBuildInsertElement(builder, bld.int_size,
tex_height, LLVMConstInt(i32t, 1, 0), "");
if (dims >= 3) {
+ LLVMValueRef tex_depth =
+ dynamic_state->depth(dynamic_state, gallivm, texture_index);
bld.int_size = LLVMBuildInsertElement(builder, bld.int_size,
tex_depth, LLVMConstInt(i32t, 2, 0), "");
}
if (use_aos) {
/* do sampling/filtering with fixed pt arithmetic */
lp_build_sample_aos(&bld, sampler_index,
- s, t, r,
+ s, t, r, offsets,
lod_ipart, lod_fpart,
ilevel0, ilevel1,
texel_out);
else {
lp_build_sample_general(&bld, sampler_index,
- s, t, r,
+ s, t, r, offsets,
lod_ipart, lod_fpart,
ilevel0, ilevel1,
texel_out);
bld4.int_size_in_type = lp_int_type(bld4.float_size_in_type);
bld4.texel_type = bld.texel_type;
bld4.texel_type.length = 4;
- bld4.perquadf_type = type4;
+ bld4.levelf_type = type4;
/* we want native vector size to be able to use our intrinsics */
- bld4.perquadf_type.length = 1;
- bld4.perquadi_type = lp_int_type(bld4.perquadf_type);
+ bld4.levelf_type.length = 1;
+ bld4.leveli_type = lp_int_type(bld4.levelf_type);
+
+ if (explicit_lod && !scalar_lod &&
+ ((is_fetch && bld.static_texture_state->target != PIPE_BUFFER) ||
+ (!is_fetch && mip_filter != PIPE_TEX_MIPFILTER_NONE)))
+ bld4.num_lods = type4.length;
+ else
+ bld4.num_lods = 1;
- bld4.num_lods = 1;
- bld4.int_size_type = bld4.int_size_in_type;
+ bld4.levelf_type = type4;
+ /* we want native vector size to be able to use our intrinsics */
+ if (bld4.num_lods != type4.length) {
+ bld4.levelf_type.length = 1;
+ }
+ bld4.leveli_type = lp_int_type(bld4.levelf_type);
bld4.float_size_type = bld4.float_size_in_type;
+ if (bld4.num_lods > 1) {
+ bld4.float_size_type.length = bld4.num_lods == type4.length ?
+ bld4.num_lods * bld4.float_size_in_type.length :
+ type4.length;
+ }
+ bld4.int_size_type = lp_int_type(bld4.float_size_type);
lp_build_context_init(&bld4.float_bld, gallivm, bld4.float_type);
lp_build_context_init(&bld4.float_vec_bld, gallivm, type4);
lp_build_context_init(&bld4.int_size_bld, gallivm, bld4.int_size_type);
lp_build_context_init(&bld4.float_size_bld, gallivm, bld4.float_size_type);
lp_build_context_init(&bld4.texel_bld, gallivm, bld4.texel_type);
- lp_build_context_init(&bld4.perquadf_bld, gallivm, bld4.perquadf_type);
- lp_build_context_init(&bld4.perquadi_bld, gallivm, bld4.perquadi_type);
+ lp_build_context_init(&bld4.levelf_bld, gallivm, bld4.levelf_type);
+ lp_build_context_init(&bld4.leveli_bld, gallivm, bld4.leveli_type);
for (i = 0; i < num_quads; i++) {
LLVMValueRef s4, t4, r4;
- LLVMValueRef lod_iparts, lod_fparts = NULL;
- LLVMValueRef ilevel0s, ilevel1s = NULL;
- LLVMValueRef indexi = lp_build_const_int32(gallivm, i);
+ LLVMValueRef lod_ipart4, lod_fpart4 = NULL;
+ LLVMValueRef ilevel04, ilevel14 = NULL;
+ LLVMValueRef offsets4[4] = { NULL };
+ unsigned num_lods = bld4.num_lods;
s4 = lp_build_extract_range(gallivm, s, 4*i, 4);
t4 = lp_build_extract_range(gallivm, t, 4*i, 4);
r4 = lp_build_extract_range(gallivm, r, 4*i, 4);
- lod_iparts = LLVMBuildExtractElement(builder, lod_ipart, indexi, "");
- ilevel0s = LLVMBuildExtractElement(builder, ilevel0, indexi, "");
+
+ if (offsets[0]) {
+ offsets4[0] = lp_build_extract_range(gallivm, offsets[0], 4*i, 4);
+ if (dims > 1) {
+ offsets4[1] = lp_build_extract_range(gallivm, offsets[1], 4*i, 4);
+ if (dims > 2) {
+ offsets4[2] = lp_build_extract_range(gallivm, offsets[2], 4*i, 4);
+ }
+ }
+ }
+ lod_ipart4 = lp_build_extract_range(gallivm, lod_ipart, num_lods * i, num_lods);
+ ilevel04 = lp_build_extract_range(gallivm, ilevel0, num_lods * i, num_lods);
if (mip_filter == PIPE_TEX_MIPFILTER_LINEAR) {
- ilevel1s = LLVMBuildExtractElement(builder, ilevel1, indexi, "");
- lod_fparts = LLVMBuildExtractElement(builder, lod_fpart, indexi, "");
+ ilevel14 = lp_build_extract_range(gallivm, ilevel1, num_lods * i, num_lods);
+ lod_fpart4 = lp_build_extract_range(gallivm, lod_fpart, num_lods * i, num_lods);
}
if (use_aos) {
/* do sampling/filtering with fixed pt arithmetic */
lp_build_sample_aos(&bld4, sampler_index,
- s4, t4, r4,
- lod_iparts, lod_fparts,
- ilevel0s, ilevel1s,
+ s4, t4, r4, offsets4,
+ lod_ipart4, lod_fpart4,
+ ilevel04, ilevel14,
texelout4);
}
else {
lp_build_sample_general(&bld4, sampler_index,
- s4, t4, r4,
- lod_iparts, lod_fparts,
- ilevel0s, ilevel1s,
+ s4, t4, r4, offsets4,
+ lod_ipart4, lod_fpart4,
+ ilevel04, ilevel14,
texelout4);
}
for (j = 0; j < 4; j++) {
struct lp_sampler_dynamic_state *dynamic_state,
struct lp_type int_type,
unsigned texture_unit,
+ unsigned target,
boolean need_nr_mips,
+ boolean scalar_lod,
LLVMValueRef explicit_lod,
LLVMValueRef *sizes_out)
{
- LLVMValueRef lod;
- LLVMValueRef size;
+ LLVMValueRef lod, level, size;
LLVMValueRef first_level = NULL;
int dims, i;
boolean has_array;
+ unsigned num_lods = 1;
struct lp_build_context bld_int_vec;
- dims = texture_dims(static_state->target);
+ /*
+ * Do some sanity verification about bound texture and shader dcl target.
+ * Not entirely sure what's possible but assume array/non-array
+ * always compatible (probably not ok for OpenGL but d3d10 has no
+ * distinction of arrays at the resource level).
+ * Everything else looks bogus (though not entirely sure about rect/2d).
+ * Currently disabled because it causes assertion failures if there's
+ * nothing bound (or rather a dummy texture, not that this case would
+ * return the right values).
+ */
+ if (0 && static_state->target != target) {
+ if (static_state->target == PIPE_TEXTURE_1D)
+ assert(target == PIPE_TEXTURE_1D_ARRAY);
+ else if (static_state->target == PIPE_TEXTURE_1D_ARRAY)
+ assert(target == PIPE_TEXTURE_1D);
+ else if (static_state->target == PIPE_TEXTURE_2D)
+ assert(target == PIPE_TEXTURE_2D_ARRAY);
+ else if (static_state->target == PIPE_TEXTURE_2D_ARRAY)
+ assert(target == PIPE_TEXTURE_2D);
+ else if (static_state->target == PIPE_TEXTURE_CUBE)
+ assert(target == PIPE_TEXTURE_CUBE_ARRAY);
+ else if (static_state->target == PIPE_TEXTURE_CUBE_ARRAY)
+ assert(target == PIPE_TEXTURE_CUBE);
+ else
+ assert(0);
+ }
+
+ dims = texture_dims(target);
- switch (static_state->target) {
+ switch (target) {
case PIPE_TEXTURE_1D_ARRAY:
case PIPE_TEXTURE_2D_ARRAY:
has_array = TRUE;
lp_build_context_init(&bld_int_vec, gallivm, lp_type_int_vec(32, 128));
if (explicit_lod) {
+ /* FIXME: this needs to honor per-element lod */
lod = LLVMBuildExtractElement(gallivm->builder, explicit_lod, lp_build_const_int32(gallivm, 0), "");
first_level = dynamic_state->first_level(dynamic_state, gallivm, texture_unit);
- lod = lp_build_broadcast_scalar(&bld_int_vec,
- LLVMBuildAdd(gallivm->builder, lod, first_level, "lod"));
-
+ level = LLVMBuildAdd(gallivm->builder, lod, first_level, "level");
+ lod = lp_build_broadcast_scalar(&bld_int_vec, level);
} else {
lod = bld_int_vec.zero;
}
lp_build_const_int32(gallivm, dims), "");
/*
- * XXX for out-of-bounds lod, should set size to zero vector here
- * (for dx10-style only, i.e. need_nr_mips)
+ * d3d10 requires zero for x/y/z values (but not w, i.e. mip levels)
+ * if level is out of bounds (note this can't cover unbound texture
+ * here, which also requires returning zero).
*/
-
+ if (explicit_lod && need_nr_mips) {
+ LLVMValueRef last_level, out, out1;
+ struct lp_build_context leveli_bld;
+
+ /* everything is scalar for now */
+ lp_build_context_init(&leveli_bld, gallivm, lp_type_int_vec(32, 32));
+ last_level = dynamic_state->last_level(dynamic_state, gallivm, texture_unit);
+
+ out = lp_build_cmp(&leveli_bld, PIPE_FUNC_LESS, level, first_level);
+ out1 = lp_build_cmp(&leveli_bld, PIPE_FUNC_GREATER, level, last_level);
+ out = lp_build_or(&leveli_bld, out, out1);
+ if (num_lods == 1) {
+ out = lp_build_broadcast_scalar(&bld_int_vec, out);
+ }
+ else {
+ /* TODO */
+ assert(0);
+ }
+ size = lp_build_andnot(&bld_int_vec, size, out);
+ }
for (i = 0; i < dims + (has_array ? 1 : 0); i++) {
sizes_out[i] = lp_build_extract_broadcast(gallivm, bld_int_vec.type, int_type,
size,
projects / mesa.git / blobdiff