#include "mtypes.h"
#include "main/uniforms.h"
#include "main/macros.h"
+#include "main/samplerobj.h"
#include "program/program.h"
#include "program/prog_parameter.h"
#include "program/prog_cache.h"
}
else if (!(vertexProgram || vertexShader)) {
/* Fixed function vertex logic */
- /* _NEW_ARRAY */
+ /* _NEW_VARYING_VP_INPUTS */
GLbitfield64 varying_inputs = ctx->varying_vp_inputs;
/* These get generated in the setup routine regardless of the
const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[i];
const struct gl_texture_object *texObj = texUnit->_Current;
const struct gl_tex_env_combine_state *comb = texUnit->_CurrentCombine;
+ const struct gl_sampler_object *samp;
GLenum format;
if (!texUnit->_ReallyEnabled || !texUnit->Enabled)
continue;
+ samp = _mesa_get_samplerobj(ctx, i);
format = texObj->Image[0][texObj->BaseLevel]->_BaseFormat;
key->unit[i].enabled = 1;
translate_tex_src_bit(texUnit->_ReallyEnabled);
key->unit[i].shadow =
- ((texObj->Sampler.CompareMode == GL_COMPARE_R_TO_TEXTURE) &&
+ ((samp->CompareMode == GL_COMPARE_R_TO_TEXTURE) &&
((format == GL_DEPTH_COMPONENT) ||
(format == GL_DEPTH_STENCIL_EXT)));
};
static ir_rvalue *
-get_current_attrib(struct texenv_fragment_program *p, GLuint attrib)
+get_current_attrib(texenv_fragment_program *p, GLuint attrib)
{
ir_variable *current;
ir_rvalue *val;
}
static ir_rvalue *
-get_gl_Color(struct texenv_fragment_program *p)
+get_gl_Color(texenv_fragment_program *p)
{
if (p->state->inputs_available & FRAG_BIT_COL0) {
ir_variable *var = p->shader->symbols->get_variable("gl_Color");
}
static ir_rvalue *
-get_source(struct texenv_fragment_program *p,
+get_source(texenv_fragment_program *p,
GLuint src, GLuint unit)
{
ir_variable *var;
}
static ir_rvalue *
-emit_combine_source(struct texenv_fragment_program *p,
+emit_combine_source(texenv_fragment_program *p,
GLuint unit,
GLuint source,
GLuint operand)
}
static ir_rvalue *
-smear(struct texenv_fragment_program *p, ir_rvalue *val)
+smear(texenv_fragment_program *p, ir_rvalue *val)
{
if (!val->type->is_scalar())
return val;
}
static ir_rvalue *
-emit_combine(struct texenv_fragment_program *p,
+emit_combine(texenv_fragment_program *p,
GLuint unit,
GLuint nr,
GLuint mode,
* Generate instructions for one texture unit's env/combiner mode.
*/
static ir_rvalue *
-emit_texenv(struct texenv_fragment_program *p, GLuint unit)
+emit_texenv(texenv_fragment_program *p, GLuint unit)
{
const struct state_key *key = p->state;
GLboolean rgb_saturate, alpha_saturate;
else
alpha_saturate = GL_FALSE;
- ir_variable *temp_var = new(p->mem_ctx) ir_variable(glsl_type::vec4_type,
- "texenv_combine",
- ir_var_temporary);
- p->emit(temp_var);
-
+ ir_variable *temp_var = p->make_temp(glsl_type::vec4_type, "texenv_combine");
ir_dereference *deref;
ir_rvalue *val;
if (rgb_saturate)
val = saturate(val);
- deref = new(p->mem_ctx) ir_dereference_variable(temp_var);
- p->emit(new(p->mem_ctx) ir_assignment(deref, val));
+ p->emit(assign(temp_var, val));
}
else if (key->unit[unit].ModeRGB == MODE_DOT3_RGBA_EXT ||
key->unit[unit].ModeRGB == MODE_DOT3_RGBA) {
val = smear(p, val);
if (rgb_saturate)
val = saturate(val);
- deref = new(p->mem_ctx) ir_dereference_variable(temp_var);
- p->emit(new(p->mem_ctx) ir_assignment(deref, val));
+ p->emit(assign(temp_var, val));
}
else {
/* Need to do something to stop from re-emitting identical
val = swizzle_xyz(smear(p, val));
if (rgb_saturate)
val = saturate(val);
- deref = new(p->mem_ctx) ir_dereference_variable(temp_var);
- p->emit(new(p->mem_ctx) ir_assignment(deref, val, NULL, WRITEMASK_XYZ));
+ p->emit(assign(temp_var, val, WRITEMASK_XYZ));
val = emit_combine(p, unit,
key->unit[unit].NumArgsA,
val = swizzle_w(smear(p, val));
if (alpha_saturate)
val = saturate(val);
- deref = new(p->mem_ctx) ir_dereference_variable(temp_var);
- p->emit(new(p->mem_ctx) ir_assignment(deref, val, NULL, WRITEMASK_W));
+ p->emit(assign(temp_var, val, WRITEMASK_W));
}
deref = new(p->mem_ctx) ir_dereference_variable(temp_var);
}
else {
float const_data[4] = {
- 1 << rgb_shift,
- 1 << rgb_shift,
- 1 << rgb_shift,
- 1 << alpha_shift
+ float(1 << rgb_shift),
+ float(1 << rgb_shift),
+ float(1 << rgb_shift),
+ float(1 << alpha_shift)
};
shift = new(p->mem_ctx) ir_constant(glsl_type::vec4_type,
(ir_constant_data *)const_data);
/**
* Generate instruction for getting a texture source term.
*/
-static void load_texture( struct texenv_fragment_program *p, GLuint unit )
+static void load_texture( texenv_fragment_program *p, GLuint unit )
{
ir_dereference *deref;
}
if (!p->state->unit[unit].enabled) {
- p->src_texture[unit] = new(p->mem_ctx) ir_variable(glsl_type::vec4_type,
- "dummy_tex",
- ir_var_temporary);
+ p->src_texture[unit] = p->make_temp(glsl_type::vec4_type,
+ "dummy_tex");
p->emit(p->src_texture[unit]);
- deref = new(p->mem_ctx) ir_dereference_variable(p->src_texture[unit]);
- p->emit(new(p->mem_ctx) ir_assignment(deref,
- new(p->mem_ctx) ir_constant(0.0f)));
+ p->emit(assign(p->src_texture[unit], new(p->mem_ctx) ir_constant(0.0f)));
return ;
}
break;
}
- p->src_texture[unit] = new(p->mem_ctx) ir_variable(glsl_type::vec4_type,
- "tex",
- ir_var_temporary);
- p->emit(p->src_texture[unit]);
+ p->src_texture[unit] = p->make_temp(glsl_type::vec4_type,
+ "tex");
ir_texture *tex = new(p->mem_ctx) ir_texture(ir_tex);
sampler_name,
ir_var_uniform);
p->top_instructions->push_head(sampler);
+
+ /* Set the texture unit for this sampler. The linker will pick this value
+ * up and do-the-right-thing.
+ *
+ * NOTE: The cast to int is important. Without it, the constant will have
+ * type uint, and things later on may get confused.
+ */
+ sampler->constant_value = new(p->mem_ctx) ir_constant(int(unit));
+
deref = new(p->mem_ctx) ir_dereference_variable(sampler);
tex->set_sampler(deref, glsl_type::vec4_type);
texcoord = texcoord->clone(p->mem_ctx, NULL);
tex->projector = swizzle_w(texcoord);
- deref = new(p->mem_ctx) ir_dereference_variable(p->src_texture[unit]);
- p->emit(new(p->mem_ctx) ir_assignment(deref, tex));
+ p->emit(assign(p->src_texture[unit], tex));
}
static void
-load_texenv_source(struct texenv_fragment_program *p,
+load_texenv_source(texenv_fragment_program *p,
GLuint src, GLuint unit)
{
switch (src) {
* Generate instructions for loading all texture source terms.
*/
static GLboolean
-load_texunit_sources( struct texenv_fragment_program *p, GLuint unit )
+load_texunit_sources( texenv_fragment_program *p, GLuint unit )
{
const struct state_key *key = p->state;
GLuint i;
* Generate instructions for loading bump map textures.
*/
static void
-load_texunit_bumpmap( struct texenv_fragment_program *p, GLuint unit )
+load_texunit_bumpmap( texenv_fragment_program *p, GLuint unit )
{
const struct state_key *key = p->state;
GLuint bumpedUnitNr = key->unit[unit].OptRGB[1].Source - SRC_TEXTURE0;
* dest = Arg1 + (Arg0.xx * rotMat0) + (Arg0.yy * rotMat1)
* note only 2 coords are affected the rest are left unchanged (mul by 0)
*/
- ir_dereference *deref;
ir_rvalue *bump_x, *bump_y;
texcoord = smear(p, texcoord);
/* bump_texcoord = texcoord */
- ir_variable *bumped = new(p->mem_ctx) ir_variable(texcoord->type,
- "bump_texcoord",
- ir_var_temporary);
+ ir_variable *bumped = p->make_temp(texcoord->type, "bump_texcoord");
p->emit(bumped);
-
- deref = new(p->mem_ctx) ir_dereference_variable(bumped);
- p->emit(new(p->mem_ctx) ir_assignment(deref, texcoord));
+ p->emit(assign(bumped, texcoord));
/* bump_texcoord.xy += arg0.x * rotmat0 + arg0.y * rotmat1 */
bump = get_source(p, key->unit[unit].OptRGB[0].Source, unit);
bump_x = mul(swizzle_x(bump), rot_mat_0);
bump_y = mul(swizzle_y(bump->clone(p->mem_ctx, NULL)), rot_mat_1);
- ir_expression *expr;
-
- expr = add(swizzle_xy(bumped), add(bump_x, bump_y));
-
- deref = new(p->mem_ctx) ir_dereference_variable(bumped);
- p->emit(new(p->mem_ctx) ir_assignment(deref, expr, NULL, WRITEMASK_XY));
+ p->emit(assign(bumped, add(swizzle_xy(bumped), add(bump_x, bump_y)),
+ WRITEMASK_XY));
p->texcoord_tex[bumpedUnitNr] = bumped;
}
* GL_FOG_COORDINATE_EXT is set to GL_FRAGMENT_DEPTH_EXT.
*/
static ir_rvalue *
-emit_fog_instructions(struct texenv_fragment_program *p,
+emit_fog_instructions(texenv_fragment_program *p,
ir_rvalue *fragcolor)
{
struct state_key *key = p->state;
* only affect rgb so we're hanging on to the .a value of fragcolor
* this way.
*/
- ir_variable *fog_result = new(p->mem_ctx) ir_variable(glsl_type::vec4_type,
- "fog_result",
- ir_var_auto);
- p->emit(fog_result);
- temp = new(p->mem_ctx) ir_dereference_variable(fog_result);
- p->emit(new(p->mem_ctx) ir_assignment(temp, fragcolor));
+ ir_variable *fog_result = p->make_temp(glsl_type::vec4_type, "fog_result");
+ p->emit(assign(fog_result, fragcolor));
fragcolor = swizzle_xyz(fog_result);
params = p->shader->symbols->get_variable("gl_Fog");
f = new(p->mem_ctx) ir_dereference_variable(fogcoord);
- ir_variable *f_var = new(p->mem_ctx) ir_variable(glsl_type::float_type,
- "fog_factor", ir_var_auto);
- p->emit(f_var);
+ ir_variable *f_var = p->make_temp(glsl_type::float_type, "fog_factor");
switch (key->fog_mode) {
case FOG_LINEAR:
* can do this like FOG_EXP but with a squaring after the
* multiply by density.
*/
- ir_variable *temp_var = new(p->mem_ctx) ir_variable(glsl_type::float_type,
- "fog_temp",
- ir_var_auto);
- p->emit(temp_var);
-
- f = mul(f, swizzle_w(oparams));
-
- temp = new(p->mem_ctx) ir_dereference_variable(temp_var);
- p->emit(new(p->mem_ctx) ir_assignment(temp, f));
+ ir_variable *temp_var = p->make_temp(glsl_type::float_type, "fog_temp");
+ p->emit(assign(temp_var, mul(f, swizzle_w(oparams))));
f = mul(temp_var, temp_var);
f = new(p->mem_ctx) ir_expression(ir_unop_neg, f);
break;
}
- f = saturate(f);
-
- temp = new(p->mem_ctx) ir_dereference_variable(f_var);
- p->emit(new(p->mem_ctx) ir_assignment(temp, f));
+ p->emit(assign(f_var, saturate(f)));
f = sub(new(p->mem_ctx) ir_constant(1.0f), f_var);
temp = new(p->mem_ctx) ir_dereference_variable(params);
temp = new(p->mem_ctx) ir_dereference_record(temp, "color");
temp = mul(swizzle_xyz(temp), f);
- f = add(temp, mul(fragcolor, f_var));
-
- ir_dereference *deref = new(p->mem_ctx) ir_dereference_variable(fog_result);
- p->emit(new(p->mem_ctx) ir_assignment(deref, f, NULL, WRITEMASK_XYZ));
+ p->emit(assign(fog_result, add(temp, mul(fragcolor, f_var)), WRITEMASK_XYZ));
return new(p->mem_ctx) ir_dereference_variable(fog_result);
}
static void
-emit_instructions(struct texenv_fragment_program *p)
+emit_instructions(texenv_fragment_program *p)
{
struct state_key *key = p->state;
GLuint unit;
}
ir_rvalue *cf = get_source(p, SRC_PREVIOUS, 0);
- ir_dereference_variable *deref;
if (key->separate_specular) {
- ir_rvalue *tmp0;
- ir_variable *spec_result = new(p->mem_ctx) ir_variable(glsl_type::vec4_type,
- "specular_add",
- ir_var_temporary);
-
- p->emit(spec_result);
-
- deref = new(p->mem_ctx) ir_dereference_variable(spec_result);
- p->emit(new(p->mem_ctx) ir_assignment(deref, cf));
+ ir_variable *spec_result = p->make_temp(glsl_type::vec4_type,
+ "specular_add");
+ p->emit(assign(spec_result, cf));
ir_rvalue *secondary;
if (p->state->inputs_available & FRAG_BIT_COL1) {
secondary = swizzle_xyz(get_current_attrib(p, VERT_ATTRIB_COLOR1));
}
- tmp0 = add(swizzle_xyz(spec_result), secondary);
-
- deref = new(p->mem_ctx) ir_dereference_variable(spec_result);
- p->emit(new(p->mem_ctx) ir_assignment(deref, tmp0, NULL, WRITEMASK_XYZ));
+ p->emit(assign(spec_result, add(swizzle_xyz(spec_result), secondary),
+ WRITEMASK_XYZ));
cf = new(p->mem_ctx) ir_dereference_variable(spec_result);
}
ir_variable *frag_color = p->shader->symbols->get_variable("gl_FragColor");
assert(frag_color);
- deref = new(p->mem_ctx) ir_dereference_variable(frag_color);
- p->emit(new(p->mem_ctx) ir_assignment(deref, cf));
+ p->emit(assign(frag_color, cf));
}
/**
_mesa_associate_uniform_storage(ctx, p.shader_program, fp->Parameters);
- for (unsigned int i = 0; i < MAX_TEXTURE_UNITS; i++) {
- /* Enough space for 'sampler_999\0'.
- */
- char name[12];
-
- snprintf(name, sizeof(name), "sampler_%d", i);
-
- int loc = _mesa_get_uniform_location(ctx, p.shader_program, name);
- if (loc != -1) {
- unsigned base;
- unsigned idx;
-
- /* Avoid using _mesa_uniform() because it flags state
- * updates, so if we're generating this shader_program in a
- * state update, we end up recursing. Instead, just set the
- * value, which is picked up at re-link.
- */
- _mesa_uniform_split_location_offset(loc, &base, &idx);
- assert(idx == 0);
-
- struct gl_uniform_storage *const storage =
- &p.shader_program->UniformStorage[base];
-
- /* Update the storage, the SamplerUnits in the shader program, and
- * the SamplerUnits in the assembly shader.
- */
- storage->storage[idx].i = i;
- fp->SamplerUnits[storage->sampler] = i;
- p.shader_program->SamplerUnits[storage->sampler] = i;
- _mesa_propagate_uniforms_to_driver_storage(storage, 0, 1);
- }
- }
_mesa_update_shader_textures_used(p.shader_program, fp);
- (void) ctx->Driver.ProgramStringNotify(ctx, fp->Target, fp);
+ if (ctx->Driver.SamplerUniformChange)
+ ctx->Driver.SamplerUniformChange(ctx, fp->Target, fp);
if (!p.shader_program->LinkStatus)
_mesa_problem(ctx, "Failed to link fixed function fragment shader: %s\n",
projects / mesa.git / blobdiff