[Mesa-dev] [PATCH 2/7] st/mesa: implement GL_ATI_fragment_shader
Miklós Máté
mtmkls at gmail.com
Thu Feb 25 15:20:11 UTC 2016
On 02/25/2016 02:37 AM, Brian Paul wrote:
> I think this patch could be broken up a bit...
Yes, I agree that this is very long, but I couldn't decide on how to
split it up.
>
> On 02/24/2016 04:35 PM, Miklós Máté wrote:
>> v2: fix arithmetic for special opcodes,
>> fix fog state, cleanup
>> v3: simplify handling of special opcodes,
>> fix rebinding with different textargets or fog equation,
>> lots of formatting fixes
>>
>> Signed-off-by: Miklós Máté <mtmkls at gmail.com>
>> ---
>> src/mesa/Makefile.sources | 1 +
>> src/mesa/main/atifragshader.h | 1 +
>> src/mesa/main/texstate.c | 18 +
>> src/mesa/main/texstate.h | 3 +
>> src/mesa/program/program.h | 2 +
>> src/mesa/state_tracker/st_atifs_to_tgsi.c | 726
>> ++++++++++++++++++++++++++++++
>> src/mesa/state_tracker/st_atifs_to_tgsi.h | 65 +++
>> src/mesa/state_tracker/st_atom_constbuf.c | 16 +
>> src/mesa/state_tracker/st_atom_shader.c | 27 +-
>> src/mesa/state_tracker/st_cb_drawpixels.c | 1 +
>> src/mesa/state_tracker/st_cb_program.c | 36 +-
>> src/mesa/state_tracker/st_program.c | 30 +-
>> src/mesa/state_tracker/st_program.h | 7 +
>> 13 files changed, 930 insertions(+), 3 deletions(-)
>> create mode 100644 src/mesa/state_tracker/st_atifs_to_tgsi.c
>> create mode 100644 src/mesa/state_tracker/st_atifs_to_tgsi.h
>>
>> diff --git a/src/mesa/Makefile.sources b/src/mesa/Makefile.sources
>> index a6c12c6..54601a9 100644
>> --- a/src/mesa/Makefile.sources
>> +++ b/src/mesa/Makefile.sources
>> @@ -395,6 +395,7 @@ VBO_FILES = \
>> vbo/vbo_split_inplace.c
>>
>> STATETRACKER_FILES = \
>> + state_tracker/st_atifs_to_tgsi.c \
>> state_tracker/st_atom_array.c \
>> state_tracker/st_atom_atomicbuf.c \
>> state_tracker/st_atom_blend.c \
>> diff --git a/src/mesa/main/atifragshader.h
>> b/src/mesa/main/atifragshader.h
>> index 5901134..0e32795 100644
>> --- a/src/mesa/main/atifragshader.h
>> +++ b/src/mesa/main/atifragshader.h
>> @@ -16,6 +16,7 @@ struct gl_context;
>> #define MAX_NUM_INSTRUCTIONS_PER_PASS_ATI 8
>> #define MAX_NUM_PASSES_ATI 2
>> #define MAX_NUM_FRAGMENT_REGISTERS_ATI 6
>> +#define MAX_NUM_FRAGMENT_CONSTANTS_ATI 8
>>
>> struct ati_fs_opcode_st
>> {
>> diff --git a/src/mesa/main/texstate.c b/src/mesa/main/texstate.c
>> index 9ee5c69..1f7aa4a 100644
>> --- a/src/mesa/main/texstate.c
>> +++ b/src/mesa/main/texstate.c
>> @@ -57,6 +57,24 @@ static const struct gl_tex_env_combine_state
>> default_combine_state = {
>> };
>>
>>
>> +/**
>> + * Return the the currently active target index of the given texture
>> unit,
>> + * fall back to 2D if nothing is current.
>> + */
>> +gl_texture_index
>> +_mesa_get_texture_target_index(struct gl_context *ctx, const
>> unsigned unit)
>> +{
>> + struct gl_texture_object *texObj = _mesa_get_tex_unit(ctx,
>> unit)->_Current;
>> +
>> + if (texObj) {
>> + return _mesa_tex_target_to_index(ctx, texObj->Target);
>> + } else {
>> + /* fallback for missing texture */
>> + return TEXTURE_2D_INDEX;
>> + }
>> +
>
> Extraneous blank line.
>
>
>> +}
>> +
>>
>> /**
>> * Used by glXCopyContext to copy texture state from one context to
>> another.
>> diff --git a/src/mesa/main/texstate.h b/src/mesa/main/texstate.h
>> index 52fe602..f7100bf 100644
>> --- a/src/mesa/main/texstate.h
>> +++ b/src/mesa/main/texstate.h
>> @@ -63,6 +63,9 @@ _mesa_max_tex_unit(struct gl_context *ctx)
>> ctx->Const.MaxTextureCoordUnits);
>> }
>>
>> +gl_texture_index
>> +_mesa_get_texture_target_index(struct gl_context *ctx, const
>> unsigned unit);
>> +
>>
>> extern void
>> _mesa_copy_texture_state( const struct gl_context *src, struct
>> gl_context *dst );
>
>
> Adding this new _mesa_get_texture_target_index() function could be a
> separate patch (if it's needed, see below).
OK, I'll put it into a separate patch. BTW is this function in the right
place?
>
>
>> diff --git a/src/mesa/program/program.h b/src/mesa/program/program.h
>> index 24e0597..09e6928 100644
>> --- a/src/mesa/program/program.h
>> +++ b/src/mesa/program/program.h
>> @@ -172,6 +172,8 @@ _mesa_program_enum_to_shader_stage(GLenum v)
>> return MESA_SHADER_VERTEX;
>> case GL_FRAGMENT_PROGRAM_ARB:
>> return MESA_SHADER_FRAGMENT;
>> + case GL_FRAGMENT_SHADER_ATI:
>> + return MESA_SHADER_FRAGMENT;
>> case GL_GEOMETRY_PROGRAM_NV:
>> return MESA_SHADER_GEOMETRY;
>> case GL_TESS_CONTROL_PROGRAM_NV:
>
> That could be separate too.
OK.
>
>
>> diff --git a/src/mesa/state_tracker/st_atifs_to_tgsi.c
>> b/src/mesa/state_tracker/st_atifs_to_tgsi.c
>> new file mode 100644
>> index 0000000..6c2d2f2
>> --- /dev/null
>> +++ b/src/mesa/state_tracker/st_atifs_to_tgsi.c
>> @@ -0,0 +1,726 @@
>> +/*
>> + * Copyright (C) 2016 Miklós Máté
>> + *
>> + * Permission is hereby granted, free of charge, to any person
>> obtaining a
>> + * copy of this software and associated documentation files (the
>> "Software"),
>> + * to deal in the Software without restriction, including without
>> limitation
>> + * the rights to use, copy, modify, merge, publish, distribute,
>> sublicense,
>> + * and/or sell copies of the Software, and to permit persons to whom
>> the
>> + * Software is furnished to do so, subject to the following conditions:
>> + *
>> + * The above copyright notice and this permission notice shall be
>> included in
>> + * all copies or substantial portions of the Software.
>> + *
>> + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
>> EXPRESS OR
>> + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
>> MERCHANTABILITY,
>> + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO
>> EVENT SHALL
>> + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
>> + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
>> OTHERWISE,
>> + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
>> USE OR
>> + * OTHER DEALINGS IN THE SOFTWARE.
>> + */
>> +
>> +#include "main/mtypes.h"
>> +#include "main/atifragshader.h"
>> +#include "main/texstate.h"
>> +#include "main/errors.h"
>> +#include "program/prog_parameter.h"
>> +
>> +#include "tgsi/tgsi_transform.h"
>> +#include "tgsi/tgsi_ureg.h"
>> +#include "util/u_math.h"
>> +
>> +#include "st_program.h"
>> +#include "st_atifs_to_tgsi.h"
>> +
>> +/**
>> + * Intermediate state used during shader translation.
>> + */
>> +struct st_translate {
>> + struct ureg_program *ureg;
>> + struct gl_context *ctx;
>> + struct ati_fragment_shader *atifs;
>> +
>> + struct ureg_dst temps[MAX_PROGRAM_TEMPS];
>> + struct ureg_src *constants;
>> + struct ureg_dst outputs[PIPE_MAX_SHADER_OUTPUTS];
>> + struct ureg_src inputs[PIPE_MAX_SHADER_INPUTS];
>> + struct ureg_src samplers[PIPE_MAX_SAMPLERS];
>> +
>> + const GLuint *inputMapping;
>> + const GLuint *outputMapping;
>> +
>> + unsigned current_pass;
>> +
>> + bool
>> regs_written[MAX_NUM_PASSES_ATI][MAX_NUM_FRAGMENT_REGISTERS_ATI];
>> +
>> + boolean error;
>> +};
>> +
>> +struct instruction_desc {
>> + unsigned TGSI_opcode;
>> + const char *name;
>> + unsigned char arg_count;
>> +};
>> +
>> +static const struct instruction_desc inst_desc[] = {
>> + {TGSI_OPCODE_MOV, "MOV", 1},
>> + {TGSI_OPCODE_NOP, "UND", 0}, /* unused */
>> + {TGSI_OPCODE_ADD, "ADD", 2},
>> + {TGSI_OPCODE_MUL, "MUL", 2},
>> + {TGSI_OPCODE_SUB, "SUB", 2},
>> + {TGSI_OPCODE_DP3, "DOT3", 2},
>> + {TGSI_OPCODE_DP4, "DOT4", 2},
>> + {TGSI_OPCODE_MAD, "MAD", 3},
>> + {TGSI_OPCODE_LRP, "LERP", 3},
>> + {TGSI_OPCODE_NOP, "CND", 3},
>> + {TGSI_OPCODE_NOP, "CND0", 3},
>> + {TGSI_OPCODE_NOP, "DOT2_ADD", 3}
>> +};
>> +
>> +static struct ureg_dst
>> +get_temp(struct st_translate *t, unsigned index)
>> +{
>> + if (ureg_dst_is_undef(t->temps[index]))
>> + t->temps[index] = ureg_DECL_temporary(t->ureg);
>> + return t->temps[index];
>> +}
>> +
>> +static struct ureg_src
>> +apply_swizzle(struct st_translate *t,
>> + struct ureg_src src, GLuint swizzle)
>> +{
>> + if (swizzle == GL_SWIZZLE_STR_ATI) {
>> + return src;
>> + } else if (swizzle == GL_SWIZZLE_STQ_ATI) {
>> + return ureg_swizzle(src,
>> + TGSI_SWIZZLE_X,
>> + TGSI_SWIZZLE_Y,
>> + TGSI_SWIZZLE_W,
>> + TGSI_SWIZZLE_Z);
>> + } else {
>> + struct ureg_dst tmp[2];
>> + struct ureg_src imm[3];
>> +
>> + tmp[0] = get_temp(t, MAX_NUM_FRAGMENT_REGISTERS_ATI);
>> + tmp[1] = get_temp(t, MAX_NUM_FRAGMENT_REGISTERS_ATI+1);
>> + imm[0] = src;
>> + imm[1] = ureg_imm4f(t->ureg, 1.0, 1.0, 0.0, 0.0);
>> + imm[2] = ureg_imm4f(t->ureg, 0.0, 0.0, 1.0, 1.0);
>> + ureg_insn(t->ureg, TGSI_OPCODE_MAD, &tmp[0], 1, imm, 3);
>> +
>> + if (swizzle == GL_SWIZZLE_STR_DR_ATI) {
>> + imm[0] = ureg_scalar(src, TGSI_SWIZZLE_Z);
>> + } else {
>> + imm[0] = ureg_scalar(src, TGSI_SWIZZLE_W);
>> + }
>> + ureg_insn(t->ureg, TGSI_OPCODE_RCP, &tmp[1], 1, &imm[0], 1);
>> +
>> + imm[0] = ureg_src(tmp[0]);
>> + imm[1] = ureg_src(tmp[1]);
>> + ureg_insn(t->ureg, TGSI_OPCODE_MUL, &tmp[0], 1, imm, 2);
>> +
>> + return ureg_src(tmp[0]);
>> + }
>> +}
>> +
>> +/**
>> + * Map mesa texture target to TGSI texture target.
>> + * Copied from st_mesa_to_tgsi.c
>> + */
>> +static unsigned
>> +translate_texture_target(GLuint textarget)
>> +{
>> + /* the shadow part is omitted */
>> + switch( textarget ) {
>> + case TEXTURE_2D_MULTISAMPLE_INDEX: return TGSI_TEXTURE_2D_MSAA;
>> + case TEXTURE_2D_MULTISAMPLE_ARRAY_INDEX: return
>> TGSI_TEXTURE_2D_ARRAY_MSAA;
>> + case TEXTURE_BUFFER_INDEX: return TGSI_TEXTURE_BUFFER;
>> + case TEXTURE_1D_INDEX: return TGSI_TEXTURE_1D;
>> + case TEXTURE_2D_INDEX: return TGSI_TEXTURE_2D;
>> + case TEXTURE_3D_INDEX: return TGSI_TEXTURE_3D;
>> + case TEXTURE_CUBE_INDEX: return TGSI_TEXTURE_CUBE;
>> + case TEXTURE_CUBE_ARRAY_INDEX: return TGSI_TEXTURE_CUBE_ARRAY;
>> + case TEXTURE_RECT_INDEX: return TGSI_TEXTURE_RECT;
>> + case TEXTURE_1D_ARRAY_INDEX: return TGSI_TEXTURE_1D_ARRAY;
>> + case TEXTURE_2D_ARRAY_INDEX: return TGSI_TEXTURE_2D_ARRAY;
>> + case TEXTURE_EXTERNAL_INDEX: return TGSI_TEXTURE_2D;
>> + default:
>> + debug_assert( 0 );
>> + return TGSI_TEXTURE_1D;
>> + }
>> +}
>> +
>> +static struct ureg_src
>> +get_source(struct st_translate *t, GLuint src_type)
>> +{
>> + if (src_type >= GL_REG_0_ATI && src_type <= GL_REG_5_ATI) {
>> + if (t->regs_written[t->current_pass][src_type - GL_REG_0_ATI]) {
>> + return ureg_src(get_temp(t, src_type - GL_REG_0_ATI));
>> + } else {
>> + return ureg_imm1f(t->ureg, 0.0);
>> + }
>> + } else if (src_type >= GL_CON_0_ATI && src_type <= GL_CON_7_ATI) {
>> + return t->constants[src_type - GL_CON_0_ATI];
>> + } else if (src_type == GL_ZERO) {
>> + return ureg_imm1f(t->ureg, 0.0);
>> + } else if (src_type == GL_ONE) {
>> + return ureg_imm1f(t->ureg, 1.0);
>> + } else if (src_type == GL_PRIMARY_COLOR_ARB) {
>> + return t->inputs[t->inputMapping[VARYING_SLOT_COL0]];
>> + } else if (src_type == GL_SECONDARY_INTERPOLATOR_ATI) {
>> + return t->inputs[t->inputMapping[VARYING_SLOT_COL1]];
>> + } else {
>> + /* frontend prevents this */
>> + unreachable("unknown source");
>> + }
>> +}
>> +
>> +static struct ureg_src
>> +prepare_argument(struct st_translate *t, const unsigned argId,
>> + const struct atifragshader_src_register *srcReg)
>> +{
>> + struct ureg_src src = get_source(t, srcReg->Index);
>> + struct ureg_dst arg = get_temp(t, MAX_NUM_FRAGMENT_REGISTERS_ATI
>> + argId);
>> +
>> + switch (srcReg->argRep) {
>> + case GL_NONE:
>> + break;
>> + case GL_RED:
>> + src = ureg_scalar(src, TGSI_SWIZZLE_X);
>> + break;
>> + case GL_GREEN:
>> + src = ureg_scalar(src, TGSI_SWIZZLE_Y);
>> + break;
>> + case GL_BLUE:
>> + src = ureg_scalar(src, TGSI_SWIZZLE_Z);
>> + break;
>> + case GL_ALPHA:
>> + src = ureg_scalar(src, TGSI_SWIZZLE_W);
>> + break;
>> + }
>> + ureg_insn(t->ureg, TGSI_OPCODE_MOV, &arg, 1, &src, 1);
>> +
>> + if (srcReg->argMod & GL_COMP_BIT_ATI) {
>> + struct ureg_src modsrc[2];
>> + modsrc[0] = ureg_imm1f(t->ureg, 1.0);
>> + modsrc[1] = ureg_src(arg);
>> +
>> + ureg_insn(t->ureg, TGSI_OPCODE_SUB, &arg, 1, modsrc, 2);
>> + }
>> + if (srcReg->argMod & GL_BIAS_BIT_ATI) {
>> + struct ureg_src modsrc[2];
>> + modsrc[0] = ureg_src(arg);
>> + modsrc[1] = ureg_imm1f(t->ureg, 0.5);
>> +
>> + ureg_insn(t->ureg, TGSI_OPCODE_SUB, &arg, 1, modsrc, 2);
>> + }
>> + if (srcReg->argMod & GL_2X_BIT_ATI) {
>> + struct ureg_src modsrc[2];
>> + modsrc[0] = ureg_src(arg);
>> + modsrc[1] = ureg_src(arg);
>> +
>> + ureg_insn(t->ureg, TGSI_OPCODE_ADD, &arg, 1, modsrc, 2);
>> + }
>> + if (srcReg->argMod & GL_NEGATE_BIT_ATI) {
>> + struct ureg_src modsrc[2];
>> + modsrc[0] = ureg_src(arg);
>> + modsrc[1] = ureg_imm1f(t->ureg, -1.0);
>> +
>> + ureg_insn(t->ureg, TGSI_OPCODE_MUL, &arg, 1, modsrc, 2);
>> + }
>> + return ureg_src(arg);
>> +}
>> +
>> +/* These instructions need special treatment */
>> +static void
>> +emit_special_inst(struct st_translate *t, const struct
>> instruction_desc *desc,
>> + struct ureg_dst *dst, struct ureg_src *args,
>> unsigned argcount)
>> +{
>> + struct ureg_dst tmp[1];
>> + struct ureg_src src[3];
>> +
>> + if (!strcmp(desc->name, "CND")) {
>> + tmp[0] = get_temp(t, MAX_NUM_FRAGMENT_REGISTERS_ATI + 2); /*
>> re-purpose a3 */
>> + src[0] = ureg_imm1f(t->ureg, 0.5f);
>> + src[1] = args[2];
>> + ureg_insn(t->ureg, TGSI_OPCODE_SUB, tmp, 1, src, 2);
>> + src[0] = ureg_src(tmp[0]);
>> + src[1] = args[0];
>> + src[2] = args[1];
>> + ureg_insn(t->ureg, TGSI_OPCODE_CMP, dst, 1, src, 3);
>> + } else if (!strcmp(desc->name, "CND0")) {
>> + src[0] = args[2];
>> + src[1] = args[1];
>> + src[2] = args[0];
>> + ureg_insn(t->ureg, TGSI_OPCODE_CMP, dst, 1, src, 3);
>> + } else if (!strcmp(desc->name, "DOT2_ADD")) {
>> + /* note: DP2A is not implemented in most pipe drivers */
>> + tmp[0] = get_temp(t, MAX_NUM_FRAGMENT_REGISTERS_ATI); /*
>> re-purpose a1 */
>> + src[0] = args[0];
>> + src[1] = args[1];
>> + ureg_insn(t->ureg, TGSI_OPCODE_DP2, tmp, 1, src, 2);
>> + src[0] = ureg_src(tmp[0]);
>> + src[1] = ureg_scalar(args[2], TGSI_SWIZZLE_Z);
>> + ureg_insn(t->ureg, TGSI_OPCODE_ADD, dst, 1, src, 2);
>> + }
>> +}
>> +
>> +static void
>> +emit_arith_inst(struct st_translate *t,
>> + const struct instruction_desc *desc,
>> + struct ureg_dst *dst, struct ureg_src *args,
>> unsigned argcount)
>> +{
>> + if (desc->TGSI_opcode == TGSI_OPCODE_NOP) {
>> + return emit_special_inst(t, desc, dst, args, argcount);
>> + }
>> +
>> + ureg_insn(t->ureg, desc->TGSI_opcode, dst, 1, args, argcount);
>> +}
>> +
>> +static void
>> +emit_dstmod(struct st_translate *t,
>> + struct ureg_dst dst, GLuint dstMod)
>> +{
>> + float imm;
>> + struct ureg_src src[3];
>> + GLuint scale = dstMod & ~GL_SATURATE_BIT_ATI;
>> +
>> + if (dstMod == GL_NONE) {
>> + return;
>> + }
>> +
>> + switch (scale) {
>> + case GL_2X_BIT_ATI:
>> + imm = 2.0f;
>> + break;
>> + case GL_4X_BIT_ATI:
>> + imm = 4.0f;
>> + break;
>> + case GL_8X_BIT_ATI:
>> + imm = 8.0f;
>> + break;
>> + case GL_HALF_BIT_ATI:
>> + imm = 0.5f;
>> + break;
>> + case GL_QUARTER_BIT_ATI:
>> + imm = 0.25f;
>> + break;
>> + case GL_EIGHTH_BIT_ATI:
>> + imm = 0.125f;
>> + break;
>> + default:
>> + imm = 1.0f;
>> + }
>> +
>> + src[0] = ureg_src(dst);
>> + src[1] = ureg_imm1f(t->ureg, imm);
>> + if (dstMod & GL_SATURATE_BIT_ATI) {
>> + dst = ureg_saturate(dst);
>> + }
>> + ureg_insn(t->ureg, TGSI_OPCODE_MUL, &dst, 1, src, 2);
>> +}
>> +
>> +/**
>> + * Compile one setup instruction to TGSI instructions.
>> + */
>> +static void
>> +compile_setupinst(struct st_translate *t,
>> + const unsigned r,
>> + const struct atifs_setupinst *texinst)
>> +{
>> + struct ureg_dst dst[1];
>> + struct ureg_src src[2];
>> +
>> + if (!texinst->Opcode)
>> + return;
>> +
>> + dst[0] = get_temp(t, r);
>> +
>> + GLuint pass_tex = texinst->src;
>> +
>> + if (pass_tex >= GL_TEXTURE0_ARB && pass_tex <= GL_TEXTURE7_ARB) {
>> + unsigned attr = pass_tex - GL_TEXTURE0_ARB + VARYING_SLOT_TEX0;
>> +
>> + src[0] = t->inputs[t->inputMapping[attr]];
>> + } else if (pass_tex >= GL_REG_0_ATI && pass_tex <= GL_REG_5_ATI) {
>> + unsigned reg = pass_tex - GL_REG_0_ATI;
>> +
>> + /* the frontend already validated that REG is only allowed in
>> second pass */
>> + if (t->regs_written[0][reg]) {
>> + src[0] = ureg_src(t->temps[reg]);
>> + } else {
>> + src[0] = ureg_imm1f(t->ureg, 0.0);
>> + }
>> + }
>> + src[0] = apply_swizzle(t, src[0], texinst->swizzle);
>> +
>> + if (texinst->Opcode == ATI_FRAGMENT_SHADER_SAMPLE_OP) {
>> + /* use the current texture target for the sample operation
>> + * note: this implementation doesn't support re-using an ATI_fs
>> + * with different texture targets
>> + */
>> + gl_texture_index index =
>> _mesa_get_texture_target_index(t->ctx, r);
>> + unsigned target = translate_texture_target(index);
>
> So, the result of compiling the shader happens to depend upon the
> currently active texture for unit 'r'? That seems funny/fragile.
>
> I've never really looked too closely at ATI_fragment_shader so I don't
> know.
Yes, the shader code doesn't supply the texture target, it has to be
deduced in the draw call, and a separate variant has to be created if
the shader is re-used with different texture targets. AFAICT the r200
driver avoids this by translating the shader on every draw call.
>
>
>
>> +
>> + /* by default texture and sampler indexes are the same */
>> + src[1] = t->samplers[r];
>> + ureg_tex_insn(t->ureg, TGSI_OPCODE_TEX, dst, 1, target,
>> + NULL, 0, src, 2);
>> + } else if (texinst->Opcode == ATI_FRAGMENT_SHADER_PASS_OP) {
>> + ureg_insn(t->ureg, TGSI_OPCODE_MOV, dst, 1, src, 1);
>> + }
>> +
>> + t->regs_written[t->current_pass][r] = true;
>> +}
>> +
>> +/**
>> + * Compile one arithmetic operation COLOR&ALPHA pair into TGSI
>> instructions.
>> + */
>> +static void
>> +compile_instruction(struct st_translate *t,
>> + const struct atifs_instruction *inst)
>> +{
>> + unsigned optype;
>> +
>> + for (optype = 0; optype < 2; optype++) { /* color, alpha */
>> + const struct instruction_desc *desc;
>> + struct ureg_dst dst[1];
>> + struct ureg_src args[3]; /* arguments for the main operation */
>> + unsigned arg;
>> + unsigned dstreg = inst->DstReg[optype].Index - GL_REG_0_ATI;
>> +
>> + if (!inst->Opcode[optype])
>> + continue;
>> +
>> + desc = &inst_desc[inst->Opcode[optype] - GL_MOV_ATI];
>> +
>> + /* prepare the arguments */
>> + for (arg = 0; arg < desc->arg_count; arg++) {
>> + if (arg >= inst->ArgCount[optype]) {
>> + _mesa_warning(t->ctx, "Using 0 for missing argument %d
>> of %s\n",
>> + arg, desc->name);
>> + args[arg] = ureg_imm1f(t->ureg, 0.0);
>> + } else {
>> + args[arg] = prepare_argument(t, arg,
>> + &inst->SrcReg[optype][arg]);
>> + }
>> + }
>> +
>> + /* prepare dst */
>> + dst[0] = get_temp(t, dstreg);
>> +
>> + if (optype) {
>> + dst[0] = ureg_writemask(dst[0], TGSI_WRITEMASK_W);
>> + } else {
>> + GLuint dstMask = inst->DstReg[optype].dstMask;
>> + if (dstMask == GL_NONE) {
>> + dst[0] = ureg_writemask(dst[0], TGSI_WRITEMASK_XYZ);
>> + } else {
>> + dst[0] = ureg_writemask(dst[0], dstMask); /* the enum
>> values match */
>> + }
>> + }
>> +
>> + /* emit the main instruction */
>> + emit_arith_inst(t, desc, dst, args, arg);
>> +
>> + emit_dstmod(t, *dst, inst->DstReg[optype].dstMod);
>> +
>> + t->regs_written[t->current_pass][dstreg] = true;
>> + }
>> +}
>> +
>> +static void
>> +apply_fog(struct st_translate *t)
>> +{
>> + struct gl_fog_attrib *fog = &t->ctx->Fog;
>> + struct ureg_src oparams = t->constants[8];
>> + struct ureg_src fogcolor = t->constants[9];
>> + /* this is a single float in the X coordinate */
>> + struct ureg_src fogcoord =
>> t->inputs[t->inputMapping[VARYING_SLOT_FOGC]];
>> +
>> + struct ureg_dst dst[1];
>> + struct ureg_src src[3];
>> +
>> + /* compute the 1 component fog factor f */
>> + if (fog->Mode == GL_LINEAR) {
>> + /* formula: f = (end - z) / (end - start)
>> + * with optimized parameters: f = MAD(fogcoord, oparams.x,
>> oparams.y)
>> + */
>> + dst[0] = get_temp(t, MAX_NUM_FRAGMENT_REGISTERS_ATI);
>> + src[0] = fogcoord;
>> + src[1] = ureg_scalar(oparams, TGSI_SWIZZLE_X);
>> + src[2] = ureg_scalar(oparams, TGSI_SWIZZLE_Y);
>> +
>> + ureg_insn(t->ureg, TGSI_OPCODE_MAD, dst, 1, src, 3);
>> + } else if (fog->Mode == GL_EXP) {
>> + /* formula: f = exp(-dens * z)
>> + * with optimized parameters:
>> + * f = MUL(fogcoord, oparams.z); f= EX2(-f)
>> + */
>> + dst[0] = get_temp(t, MAX_NUM_FRAGMENT_REGISTERS_ATI);
>> + src[0] = fogcoord;
>> + src[1] = ureg_scalar(oparams, TGSI_SWIZZLE_Z);
>> + ureg_insn(t->ureg, TGSI_OPCODE_MUL, dst, 1, src, 2);
>> + dst[0] = get_temp(t, MAX_NUM_FRAGMENT_REGISTERS_ATI);
>> + src[0] = ureg_negate(ureg_src(dst[0]));
>> + ureg_insn(t->ureg, TGSI_OPCODE_EX2, dst, 1, src, 1);
>> + } else if (fog->Mode == GL_EXP2) {
>> + /* formula: f = exp(-(dens * z)^2)
>> + * with optimized parameters:
>> + * f = MUL(fogcoord, oparams.w); f=MUL(f, f); f= EX2(-f)
>> + */
>> + dst[0] = get_temp(t, MAX_NUM_FRAGMENT_REGISTERS_ATI);
>> + src[0] = fogcoord;
>> + src[1] = ureg_scalar(oparams, TGSI_SWIZZLE_W);
>> + ureg_insn(t->ureg, TGSI_OPCODE_MUL, dst, 1, src, 2);
>> + dst[0] = get_temp(t, MAX_NUM_FRAGMENT_REGISTERS_ATI);
>> + src[0] = ureg_src(dst[0]);
>> + ureg_insn(t->ureg, TGSI_OPCODE_MUL, dst, 1, src, 2);
>> + dst[0] = get_temp(t, MAX_NUM_FRAGMENT_REGISTERS_ATI);
>> + src[0] = ureg_negate(ureg_src(dst[0]));
>> + ureg_insn(t->ureg, TGSI_OPCODE_EX2, dst, 1, src, 1);
>> + }
>> +
>> + dst[0] = get_temp(t, MAX_NUM_FRAGMENT_REGISTERS_ATI);
>> + src[0] = ureg_src(dst[0]);
>> + src[1] = ureg_imm1f(t->ureg, 0.0f);
>> + src[2] = ureg_imm1f(t->ureg, 1.0f);
>> + ureg_insn(t->ureg, TGSI_OPCODE_CLAMP, dst, 1, src, 3);
>> +
>> + dst[0] = t->temps[0];
>> + src[0] = ureg_swizzle(ureg_src(get_temp(t,
>> MAX_NUM_FRAGMENT_REGISTERS_ATI)),
>> + TGSI_SWIZZLE_X,
>> + TGSI_SWIZZLE_X,
>> + TGSI_SWIZZLE_X,
>> + TGSI_SWIZZLE_Y);
>> + src[1] = ureg_src(t->temps[0]);
>> + src[2] = fogcolor;
>> + ureg_insn(t->ureg, TGSI_OPCODE_LRP, dst, 1, src, 3);
>> +}
>> +
>> +static void
>> +finalize_shader(struct st_translate *t, unsigned numPasses)
>> +{
>> + struct ureg_dst dst[1] = { { 0 } };
>> + struct ureg_src src[1] = { { 0 } };
>> +
>> + if (t->regs_written[numPasses-1][0]) {
>> + if (t->ctx->Fog.Enabled) {
>> + apply_fog(t);
>> + }
>> +
>> + /* copy the result into the OUT slot */
>> + dst[0] = t->outputs[t->outputMapping[FRAG_RESULT_COLOR]];
>> + src[0] = ureg_src(t->temps[0]);
>> + ureg_insn(t->ureg, TGSI_OPCODE_MOV, dst, 1, src, 1);
>> + }
>> +
>> + /* signal the end of the program */
>> + ureg_insn(t->ureg, TGSI_OPCODE_END, dst, 0, src, 0);
>> +}
>> +
>> +/**
>> + * Called when a new variant is needed, we need to translate
>> + * the ATI fragment shader to TGSI
>> + */
>> +enum pipe_error
>> +st_translate_atifs_program(
>> + struct gl_context *ctx,
>> + struct ureg_program *ureg,
>> + struct ati_fragment_shader *atifs,
>> + struct gl_program *program,
>> + GLuint numInputs,
>> + const GLuint inputMapping[],
>> + const ubyte inputSemanticName[],
>> + const ubyte inputSemanticIndex[],
>> + const GLuint interpMode[],
>> + GLuint numOutputs,
>> + const GLuint outputMapping[],
>> + const ubyte outputSemanticName[],
>> + const ubyte outputSemanticIndex[])
>> +{
>> + enum pipe_error ret = PIPE_OK;
>> +
>> + unsigned pass, i, r;
>> +
>> + struct st_translate translate, *t;
>> + t = &translate;
>> + memset(t, 0, sizeof *t);
>> +
>> + t->inputMapping = inputMapping;
>> + t->outputMapping = outputMapping;
>> + t->ureg = ureg;
>> + t->ctx = ctx;
>> + t->atifs = atifs;
>> +
>> + /*
>> + * Declare input attributes.
>> + */
>> + for (i = 0; i < numInputs; i++) {
>> + t->inputs[i] = ureg_DECL_fs_input(ureg,
>> + inputSemanticName[i],
>> + inputSemanticIndex[i],
>> + interpMode[i]);
>> + }
>> +
>> + /*
>> + * Declare output attributes:
>> + * we always have numOutputs=1 and it's FRAG_RESULT_COLOR
>> + */
>> + t->outputs[0] = ureg_DECL_output( ureg,
>> + TGSI_SEMANTIC_COLOR,
>> + outputSemanticIndex[0] );
>> +
>> + /* Emit constants and immediates. Mesa uses a single index space
>> + * for these, so we put all the translated regs in t->constants.
>> + */
>> + if (program->Parameters) {
>> + t->constants = calloc( program->Parameters->NumParameters,
>> + sizeof t->constants[0] );
>> + if (t->constants == NULL) {
>> + ret = PIPE_ERROR_OUT_OF_MEMORY;
>> + goto out;
>> + }
>> +
>> + for (i = 0; i < program->Parameters->NumParameters; i++) {
>> + switch (program->Parameters->Parameters[i].Type) {
>> + case PROGRAM_STATE_VAR:
>> + case PROGRAM_UNIFORM:
>> + t->constants[i] = ureg_DECL_constant( ureg, i );
>> + break;
>> +
>> + case PROGRAM_CONSTANT:
>> + t->constants[i] =
>> + ureg_DECL_immediate( ureg,
>> + (const
>> float*)program->Parameters->ParameterValues[i],
>> + 4 );
>> + break;
>> + default:
>> + break;
>> + }
>> + }
>> + }
>> +
>> + /* texture samplers */
>> + for (i = 0; i <
>> ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits; i++) {
>> + if (program->SamplersUsed & (1 << i)) {
>> + t->samplers[i] = ureg_DECL_sampler( ureg, i );
>> +
>> + /* fix texture targets that are not 2D * /
>> + / * note: this implementation doesn't support re-using an
>> ATI_fs
>> + * with different texture targets
>> + */
>> + gl_texture_index index =
>> _mesa_get_texture_target_index(ctx, i);
>> + if (index != TEXTURE_2D_INDEX) {
>> + program->TexturesUsed[i] &= ~TEXTURE_2D_BIT;
>> + program->TexturesUsed[i] |= (1 << index);
>> + }
>> + }
>> + }
>> +
>> + /* emit instructions */
>> + for (pass = 0; pass < atifs->NumPasses; pass++) {
>> + t->current_pass = pass;
>> + for (r = 0; r < MAX_NUM_FRAGMENT_REGISTERS_ATI; r++) {
>> + struct atifs_setupinst *texinst = &atifs->SetupInst[pass][r];
>> + compile_setupinst(t, r, texinst);
>> + }
>> + for (i = 0; i < atifs->numArithInstr[pass]; i++) {
>> + struct atifs_instruction *inst =
>> &atifs->Instructions[pass][i];
>> + compile_instruction(t, inst);
>> + }
>> + }
>> +
>> + finalize_shader(t, atifs->NumPasses);
>> +
>> +out:
>> + free(t->constants);
>> +
>> + if (t->error) {
>> + debug_printf("%s: translate error flag set\n", __func__);
>> + }
>> +
>> + return ret;
>> +}
>> +
>> +/**
>> + * Called in ProgramStringNotify, we need to fill the metadata of the
>> + * gl_program attached to the ati_fragment_shader
>> + */
>> +void
>> +st_init_atifs_prog(struct gl_context *ctx, struct gl_program *prog)
>> +{
>> + /* we know this is st_fragment_program, because of
>> st_new_ati_fs() */
>> + struct st_fragment_program *stfp = (struct st_fragment_program *)
>> prog;
>> + struct ati_fragment_shader *atifs = stfp->ati_fs;
>> +
>> + unsigned pass, i, r, optype, arg;
>> +
>> + static const gl_state_index fog_params_state[STATE_LENGTH] =
>> + {STATE_INTERNAL, STATE_FOG_PARAMS_OPTIMIZED, 0, 0, 0};
>> + static const gl_state_index fog_color[STATE_LENGTH] =
>> + {STATE_FOG_COLOR, 0, 0, 0, 0};
>> +
>> + prog->InputsRead = 0;
>> + prog->OutputsWritten = BITFIELD64_BIT(FRAG_RESULT_COLOR);
>> + prog->SamplersUsed = 0;
>> + prog->Parameters = _mesa_new_parameter_list();
>> +
>> + /* fill in InputsRead, SamplersUsed, TexturesUsed */
>> + for (pass = 0; pass < atifs->NumPasses; pass++) {
>> + for (r = 0; r < MAX_NUM_FRAGMENT_REGISTERS_ATI; r++) {
>> + struct atifs_setupinst *texinst = &atifs->SetupInst[pass][r];
>> + GLuint pass_tex = texinst->src;
>> +
>> + if (texinst->Opcode == ATI_FRAGMENT_SHADER_SAMPLE_OP) {
>> + /* mark which texcoords are used */
>> + prog->InputsRead |= BITFIELD64_BIT(VARYING_SLOT_TEX0 +
>> pass_tex - GL_TEXTURE0_ARB);
>> + /* by default there is 1:1 mapping between samplers and
>> textures */
>> + prog->SamplersUsed |= (1 << r);
>> + /* the target is unknown here, it will be fixed in the
>> draw call */
>> + prog->TexturesUsed[r] = TEXTURE_2D_BIT;
>> + } else if (texinst->Opcode == ATI_FRAGMENT_SHADER_PASS_OP) {
>> + if (pass_tex >= GL_TEXTURE0_ARB && pass_tex <=
>> GL_TEXTURE7_ARB) {
>> + prog->InputsRead |= BITFIELD64_BIT(VARYING_SLOT_TEX0
>> + pass_tex - GL_TEXTURE0_ARB);
>> + }
>> + }
>> + }
>> + }
>> + for (pass = 0; pass < atifs->NumPasses; pass++) {
>> + for (i = 0; i < atifs->numArithInstr[pass]; i++) {
>> + struct atifs_instruction *inst =
>> &atifs->Instructions[pass][i];
>> +
>> + for (optype = 0; optype < 2; optype++) { /* color, alpha */
>> + if (inst->Opcode[optype]) {
>> + for (arg = 0; arg < inst->ArgCount[optype]; arg++) {
>> + GLint index = inst->SrcReg[optype][arg].Index;
>> + if (index == GL_PRIMARY_COLOR_EXT) {
>> + prog->InputsRead |=
>> BITFIELD64_BIT(VARYING_SLOT_COL0);
>> + } else if (index == GL_SECONDARY_INTERPOLATOR_ATI) {
>> + /* note: ATI_fragment_shader.txt never
>> specifies what
>> + * GL_SECONDARY_INTERPOLATOR_ATI is, swrast uses
>> + * VARYING_SLOT_COL1 for this input */
>> + prog->InputsRead |=
>> BITFIELD64_BIT(VARYING_SLOT_COL1);
>> + }
>> + }
>> + }
>> + }
>> + }
>> + }
>> + /* We may need fog */
>> + prog->InputsRead |= BITFIELD64_BIT(VARYING_SLOT_FOGC);
>> +
>> + /* we always have the ATI_fs constants, and the fog params */
>> + for (i = 0; i < MAX_NUM_FRAGMENT_CONSTANTS_ATI; i++) {
>> + _mesa_add_parameter(prog->Parameters, PROGRAM_UNIFORM,
>> + NULL, 4, GL_FLOAT, NULL, NULL);
>> + }
>> + _mesa_add_state_reference(prog->Parameters, fog_params_state);
>> + _mesa_add_state_reference(prog->Parameters, fog_color);
>> +
>> + prog->NumInstructions = 0;
>> + prog->NumTemporaries = MAX_NUM_FRAGMENT_REGISTERS_ATI + 3; /* 3
>> input temps for arith ops */
>> + prog->NumParameters = MAX_NUM_FRAGMENT_CONSTANTS_ATI + 2; /* 2
>> state variables for fog */
>> +}
>> +
>> diff --git a/src/mesa/state_tracker/st_atifs_to_tgsi.h
>> b/src/mesa/state_tracker/st_atifs_to_tgsi.h
>> new file mode 100644
>> index 0000000..0ed4195
>> --- /dev/null
>> +++ b/src/mesa/state_tracker/st_atifs_to_tgsi.h
>> @@ -0,0 +1,65 @@
>> +/*
>> + * Copyright (C) 2016 Miklós Máté
>> + *
>> + * Permission is hereby granted, free of charge, to any person
>> obtaining a
>> + * copy of this software and associated documentation files (the
>> "Software"),
>> + * to deal in the Software without restriction, including without
>> limitation
>> + * the rights to use, copy, modify, merge, publish, distribute,
>> sublicense,
>> + * and/or sell copies of the Software, and to permit persons to whom
>> the
>> + * Software is furnished to do so, subject to the following conditions:
>> + *
>> + * The above copyright notice and this permission notice shall be
>> included in
>> + * all copies or substantial portions of the Software.
>> + *
>> + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
>> EXPRESS OR
>> + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
>> MERCHANTABILITY,
>> + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO
>> EVENT SHALL
>> + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
>> + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
>> OTHERWISE,
>> + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
>> USE OR
>> + * OTHER DEALINGS IN THE SOFTWARE.
>> + */
>> +
>> +#ifndef ST_ATIFS_TO_TGSI_H
>> +#define ST_ATIFS_TO_TGSI_H
>> +
>> +#if defined __cplusplus
>> +extern "C" {
>> +#endif
>> +
>> +#include "main/glheader.h"
>> +
>> +#include "pipe/p_compiler.h"
>> +#include "pipe/p_defines.h"
>> +
>> +struct gl_context;
>> +struct gl_program;
>> +struct tgsi_token;
>> +struct ureg_program;
>> +
>> +enum pipe_error
>> +st_translate_atifs_program(
>> + struct gl_context *ctx,
>> + struct ureg_program *ureg,
>> + struct ati_fragment_shader *atifs,
>> + struct gl_program *program,
>> + GLuint numInputs,
>> + const GLuint inputMapping[],
>> + const ubyte inputSemanticName[],
>> + const ubyte inputSemanticIndex[],
>> + const GLuint interpMode[],
>> + GLuint numOutputs,
>> + const GLuint outputMapping[],
>> + const ubyte outputSemanticName[],
>> + const ubyte outputSemanticIndex[]);
>> +
>> +
>> +void
>> +st_init_atifs_prog(struct gl_context *ctx, struct gl_program *prog);
>> +
>> +
>> +#if defined __cplusplus
>> +} /* extern "C" */
>> +#endif
>> +
>> +#endif /* ST_ATIFS_TO_TGSI_H */
>> diff --git a/src/mesa/state_tracker/st_atom_constbuf.c
>> b/src/mesa/state_tracker/st_atom_constbuf.c
>> index 407dfd3..3279462 100644
>> --- a/src/mesa/state_tracker/st_atom_constbuf.c
>> +++ b/src/mesa/state_tracker/st_atom_constbuf.c
>> @@ -34,6 +34,7 @@
>> #include "main/imports.h"
>> #include "program/prog_parameter.h"
>> #include "program/prog_print.h"
>> +#include "main/atifragshader.h"
>>
>> #include "pipe/p_context.h"
>> #include "pipe/p_defines.h"
>> @@ -64,6 +65,21 @@ void st_upload_constants( struct st_context *st,
>> shader_type == PIPE_SHADER_TESS_EVAL ||
>> shader_type == PIPE_SHADER_COMPUTE);
>>
>> + /* update the ATI constants before rendering */
>> + struct ati_fragment_shader *ati_fs = st->fp->ati_fs;
>> + if (shader_type == PIPE_SHADER_FRAGMENT && ati_fs) {
>> + unsigned c;
>> +
>> + for (c = 0; c < MAX_NUM_FRAGMENT_CONSTANTS_ATI; c++) {
>> + if (ati_fs->LocalConstDef & (1 << c))
>> + memcpy(params->ParameterValues[c],
>> + ati_fs->Constants[c], sizeof(GLfloat) * 4);
>> + else
>> + memcpy(params->ParameterValues[c],
>> + st->ctx->ATIFragmentShader.GlobalConstants[c], sizeof(GLfloat) * 4);
>> + }
>> + }
>> +
>> /* update constants */
>> if (params && params->NumParameters) {
>> struct pipe_constant_buffer cb;
>> diff --git a/src/mesa/state_tracker/st_atom_shader.c
>> b/src/mesa/state_tracker/st_atom_shader.c
>> index a88f035..53f3c4e 100644
>> --- a/src/mesa/state_tracker/st_atom_shader.c
>> +++ b/src/mesa/state_tracker/st_atom_shader.c
>> @@ -37,6 +37,8 @@
>>
>> #include "main/imports.h"
>> #include "main/mtypes.h"
>> +#include "main/texstate.h"
>> +#include "main/atifragshader.h"
>> #include "program/program.h"
>>
>> #include "pipe/p_context.h"
>> @@ -49,6 +51,17 @@
>> #include "st_program.h"
>>
>>
>> +static GLuint
>> +translate_fog_mode(GLenum mode)
>> +{
>> + switch (mode) {
>> + case GL_LINEAR: return 1;
>> + case GL_EXP: return 2;
>> + case GL_EXP2: return 3;
>> + default: return 0;
>
> We usually put the return statements on the next line.
>
> Maybe put a comment on that function too.
Actually, I wonder if this even has to be a function, because it's only
used in one place (a few lines below).
>
>
>> + }
>> +}
>> +
>> /**
>> * Update fragment program state/atom. This involves translating the
>> * Mesa fragment program into a gallium fragment program and
>> binding it.
>> @@ -81,6 +94,18 @@ update_fp( struct st_context *st )
>> SYSTEM_BIT_SAMPLE_POS)) &&
>> _mesa_get_min_invocations_per_fragment(st->ctx, &stfp->Base,
>> true) > 1;
>>
>> + if (stfp->ati_fs) {
>> + unsigned u;
>> +
>> + if (st->ctx->Fog.Enabled) {
>> + key.fog = translate_fog_mode(st->ctx->Fog.Mode);
>> + }
>> +
>> + for (u = 0; u < MAX_NUM_FRAGMENT_REGISTERS_ATI; u++) {
>> + key.texture_target_indices[u] =
>> _mesa_get_texture_target_index(st->ctx, u);
>> + }
>> + }
>> +
>> st->fp_variant = st_get_fp_variant(st, stfp, &key);
>>
>> st_reference_fragprog(st, &st->fp, stfp);
>> @@ -93,7 +118,7 @@ update_fp( struct st_context *st )
>> const struct st_tracked_state st_update_fp = {
>> "st_update_fp", /* name */
>> { /* dirty */
>> - _NEW_BUFFERS | _NEW_MULTISAMPLE, /* mesa */
>> + _NEW_BUFFERS | _NEW_MULTISAMPLE | _NEW_FOG, /* mesa */
>> ST_NEW_FRAGMENT_PROGRAM /* st */
>> },
>> update_fp /* update */
>> diff --git a/src/mesa/state_tracker/st_cb_drawpixels.c
>> b/src/mesa/state_tracker/st_cb_drawpixels.c
>> index 51d4ae5..93744a9 100644
>> --- a/src/mesa/state_tracker/st_cb_drawpixels.c
>> +++ b/src/mesa/state_tracker/st_cb_drawpixels.c
>> @@ -1292,6 +1292,7 @@ blit_copy_pixels(struct gl_context *ctx, GLint
>> srcx, GLint srcy,
>> !ctx->FragmentProgram.Enabled &&
>> !ctx->VertexProgram.Enabled &&
>> !ctx->_Shader->CurrentProgram[MESA_SHADER_FRAGMENT] &&
>> + !ctx->ATIFragmentShader._Enabled &&
>> ctx->DrawBuffer->_NumColorDrawBuffers == 1 &&
>> !ctx->Query.CondRenderQuery &&
>> !ctx->Query.CurrentOcclusionObject) {
>> diff --git a/src/mesa/state_tracker/st_cb_program.c
>> b/src/mesa/state_tracker/st_cb_program.c
>> index 27cc0f3..8e86013 100644
>> --- a/src/mesa/state_tracker/st_cb_program.c
>> +++ b/src/mesa/state_tracker/st_cb_program.c
>> @@ -35,6 +35,7 @@
>> #include "main/enums.h"
>> #include "main/shaderapi.h"
>> #include "program/prog_instruction.h"
>> +#include "program/prog_parameter.h"
>> #include "program/program.h"
>>
>> #include "cso_cache/cso_context.h"
>> @@ -46,6 +47,7 @@
>> #include "st_mesa_to_tgsi.h"
>> #include "st_cb_program.h"
>> #include "st_glsl_to_tgsi.h"
>> +#include "st_atifs_to_tgsi.h"
>>
>>
>>
>> @@ -302,6 +304,22 @@ st_program_string_notify( struct gl_context *ctx,
>> if (st->cp == stcp)
>> st->dirty_cp.st |= ST_NEW_COMPUTE_PROGRAM;
>> }
>> + else if (target == GL_FRAGMENT_SHADER_ATI) {
>> + assert(prog);
>> +
>> + struct st_fragment_program *stfp = (struct st_fragment_program
>> *) prog;
>> + assert(stfp->ati_fs);
>> + assert(stfp->ati_fs->Program == prog);
>> +
>> + st_init_atifs_prog(ctx, prog);
>> +
>> + st_release_fp_variants(st, stfp);
>> +
>> + /* deliberately no translate here */
>> +
>> + if (st->fp == stfp)
>> + st->dirty.st |= ST_NEW_FRAGMENT_PROGRAM;
>> + }
>>
>> if (ST_DEBUG & DEBUG_PRECOMPILE ||
>> st->shader_has_one_variant[stage])
>> @@ -310,6 +328,21 @@ st_program_string_notify( struct gl_context *ctx,
>> return GL_TRUE;
>> }
>>
>> +/**
>> + * Called via ctx->Driver.NewATIfs()
>> + * Called in glEndFragmentShaderATI()
>> + */
>> +static struct gl_program *
>> +st_new_ati_fs( struct gl_context *ctx,
>> + struct ati_fragment_shader *curProg)
>
> Remove space after '('. Indent second line further, or put both
> params on line line.
Awww, I thought I fixed all formatting issues. I'll check everything again.
MM
>
>
>> +{
>> + struct gl_program *prog = ctx->Driver.NewProgram(ctx,
>> GL_FRAGMENT_PROGRAM_ARB,
>> + curProg->Id);
>> + struct st_fragment_program *stfp = (struct st_fragment_program
>> *)prog;
>> + stfp->ati_fs = curProg;
>> + return prog;
>> +}
>> +
>>
>> /**
>> * Plug in the program and shader-related device driver functions.
>> @@ -322,6 +355,7 @@ st_init_program_functions(struct
>> dd_function_table *functions)
>> functions->NewProgram = st_new_program;
>> functions->DeleteProgram = st_delete_program;
>> functions->ProgramStringNotify = st_program_string_notify;
>> -
>> + functions->NewATIfs = st_new_ati_fs;
>> +
>> functions->LinkShader = st_link_shader;
>> }
>> diff --git a/src/mesa/state_tracker/st_program.c
>> b/src/mesa/state_tracker/st_program.c
>> index 2e21d02..715423d 100644
>> --- a/src/mesa/state_tracker/st_program.c
>> +++ b/src/mesa/state_tracker/st_program.c
>> @@ -53,6 +53,7 @@
>> #include "st_context.h"
>> #include "st_program.h"
>> #include "st_mesa_to_tgsi.h"
>> +#include "st_atifs_to_tgsi.h"
>> #include "cso_cache/cso_context.h"
>>
>>
>> @@ -815,7 +816,23 @@ st_translate_fragment_program(struct st_context
>> *st,
>>
>> free_glsl_to_tgsi_visitor(stfp->glsl_to_tgsi);
>> stfp->glsl_to_tgsi = NULL;
>> - } else
>> + } else if (stfp->ati_fs)
>> + st_translate_atifs_program(st->ctx,
>> + ureg,
>> + stfp->ati_fs,
>> + &stfp->Base.Base,
>> + /* inputs */
>> + fs_num_inputs,
>> + inputMapping,
>> + input_semantic_name,
>> + input_semantic_index,
>> + interpMode,
>> + /* outputs */
>> + fs_num_outputs,
>> + outputMapping,
>> + fs_output_semantic_name,
>> + fs_output_semantic_index);
>> + else
>> st_translate_mesa_program(st->ctx,
>> TGSI_PROCESSOR_FRAGMENT,
>> ureg,
>> @@ -849,6 +866,12 @@ st_create_fp_variant(struct st_context *st,
>> if (!variant)
>> return NULL;
>>
>> + if (stfp->ati_fs) {
>> + /* this is in the draw call, because we denied to precompile */
>> + if (!st_translate_fragment_program(st, stfp))
>> + return NULL;
>> + }
>> +
>> tgsi.tokens = stfp->tgsi.tokens;
>>
>> assert(!(key->bitmap && key->drawpixels));
>> @@ -1722,6 +1745,11 @@ st_precompile_shader_variant(struct st_context
>> *st,
>> struct st_fragment_program *p = (struct st_fragment_program
>> *)prog;
>> struct st_fp_variant_key key;
>>
>> + if (p->ati_fs) {
>> + /* deny precompile */
>> + return;
>> + }
>> +
>> memset(&key, 0, sizeof(key));
>> key.st = st->has_shareable_shaders ? NULL : st;
>> st_get_fp_variant(st, p, &key);
>> diff --git a/src/mesa/state_tracker/st_program.h
>> b/src/mesa/state_tracker/st_program.h
>> index 028fba9..756da36 100644
>> --- a/src/mesa/state_tracker/st_program.h
>> +++ b/src/mesa/state_tracker/st_program.h
>> @@ -65,6 +65,12 @@ struct st_fp_variant_key
>>
>> /** for ARB_sample_shading */
>> GLuint persample_shading:1;
>> +
>> + /** needed for ATI_fragment_shader */
>> + GLuint fog:2;
>> +
>> + /** needed for ATI_fragment_shader */
>> + char texture_target_indices[6];
>> };
>>
>>
>> @@ -99,6 +105,7 @@ struct st_fragment_program
>> struct gl_fragment_program Base;
>> struct pipe_shader_state tgsi;
>> struct glsl_to_tgsi_visitor* glsl_to_tgsi;
>> + struct ati_fragment_shader *ati_fs;
>>
>> struct st_fp_variant *variants;
>> };
>>
>
More information about the mesa-dev
mailing list