summaryrefslogtreecommitdiff
path: root/src/mesa
diff options
context:
space:
mode:
Diffstat (limited to 'src/mesa')
-rw-r--r--src/mesa/drivers/dri/r300/r300_fragprog.c738
-rw-r--r--src/mesa/drivers/dri/r300/r300_fragprog.h2
-rw-r--r--src/mesa/drivers/dri/r300/r300_state.c64
3 files changed, 402 insertions, 402 deletions
diff --git a/src/mesa/drivers/dri/r300/r300_fragprog.c b/src/mesa/drivers/dri/r300/r300_fragprog.c
index 53866414f9..556e3041ed 100644
--- a/src/mesa/drivers/dri/r300/r300_fragprog.c
+++ b/src/mesa/drivers/dri/r300/r300_fragprog.c
@@ -58,11 +58,11 @@
#define ERROR(fmt, args...) do { \
fprintf(stderr, "%s::%s(): " fmt "\n", \
__FILE__, __func__, ##args); \
- rp->error = GL_TRUE; \
+ fp->error = GL_TRUE; \
} while(0)
#define PFS_INVAL 0xFFFFFFFF
-#define COMPILE_STATE struct r300_pfs_compile_state *cs = rp->cs
+#define COMPILE_STATE struct r300_pfs_compile_state *cs = fp->cs
#define SWIZZLE_XYZ 0
#define SWIZZLE_XXX 1
@@ -76,7 +76,7 @@
#define SWIZZLE_000 9
#define SWIZZLE_HHH 10
-#define swizzle(r, x, y, z, w) do_swizzle(rp, r, \
+#define swizzle(r, x, y, z, w) do_swizzle(fp, r, \
((SWIZZLE_##x<<0)| \
(SWIZZLE_##y<<3)| \
(SWIZZLE_##z<<6)| \
@@ -301,15 +301,15 @@ static const GLuint pfs_zero = REG(REG_TYPE_CONST,
/*
* Common functions prototypes
*/
-static void dump_program(struct r300_fragment_program *rp);
-static void emit_arith(struct r300_fragment_program *rp, int op,
+static void dump_program(struct r300_fragment_program *fp);
+static void emit_arith(struct r300_fragment_program *fp, int op,
GLuint dest, int mask,
GLuint src0, GLuint src1, GLuint src2, int flags);
/**
* Get an R300 temporary that can be written to in the given slot.
*/
-static int get_hw_temp(struct r300_fragment_program *rp, int slot)
+static int get_hw_temp(struct r300_fragment_program *fp, int slot)
{
COMPILE_STATE;
int r;
@@ -339,8 +339,8 @@ static int get_hw_temp(struct r300_fragment_program *rp, int slot)
cs->hwtemps[r].vector_valid = 0;
cs->hwtemps[r].scalar_valid = 0;
- if (r > rp->max_temp_idx)
- rp->max_temp_idx = r;
+ if (r > fp->max_temp_idx)
+ fp->max_temp_idx = r;
return r;
}
@@ -348,7 +348,7 @@ static int get_hw_temp(struct r300_fragment_program *rp, int slot)
/**
* Get an R300 temporary that will act as a TEX destination register.
*/
-static int get_hw_temp_tex(struct r300_fragment_program *rp)
+static int get_hw_temp_tex(struct r300_fragment_program *fp)
{
COMPILE_STATE;
int r;
@@ -363,7 +363,7 @@ static int get_hw_temp_tex(struct r300_fragment_program *rp)
}
if (r >= PFS_NUM_TEMP_REGS)
- return get_hw_temp(rp, 0); /* Will cause an indirection */
+ return get_hw_temp(fp, 0); /* Will cause an indirection */
cs->hwtemps[r].reserved = cs->hwtemps[r].free;
cs->hwtemps[r].free = -1;
@@ -375,8 +375,8 @@ static int get_hw_temp_tex(struct r300_fragment_program *rp)
cs->hwtemps[r].vector_valid = cs->nrslots;
cs->hwtemps[r].scalar_valid = cs->nrslots;
- if (r > rp->max_temp_idx)
- rp->max_temp_idx = r;
+ if (r > fp->max_temp_idx)
+ fp->max_temp_idx = r;
return r;
}
@@ -384,7 +384,7 @@ static int get_hw_temp_tex(struct r300_fragment_program *rp)
/**
* Mark the given hardware register as free.
*/
-static void free_hw_temp(struct r300_fragment_program *rp, int idx)
+static void free_hw_temp(struct r300_fragment_program *fp, int idx)
{
COMPILE_STATE;
@@ -403,7 +403,7 @@ static void free_hw_temp(struct r300_fragment_program *rp, int idx)
/**
* Create a new Mesa temporary register.
*/
-static GLuint get_temp_reg(struct r300_fragment_program *rp)
+static GLuint get_temp_reg(struct r300_fragment_program *fp)
{
COMPILE_STATE;
GLuint r = undef;
@@ -429,7 +429,7 @@ static GLuint get_temp_reg(struct r300_fragment_program *rp)
* Create a new Mesa temporary register that will act as the destination
* register for a texture read.
*/
-static GLuint get_temp_reg_tex(struct r300_fragment_program *rp)
+static GLuint get_temp_reg_tex(struct r300_fragment_program *fp)
{
COMPILE_STATE;
GLuint r = undef;
@@ -443,7 +443,7 @@ static GLuint get_temp_reg_tex(struct r300_fragment_program *rp)
cs->temp_in_use |= (1 << --index);
cs->temps[index].refcount = 0xFFFFFFFF;
- cs->temps[index].reg = get_hw_temp_tex(rp);
+ cs->temps[index].reg = get_hw_temp_tex(fp);
REG_SET_TYPE(r, REG_TYPE_TEMP);
REG_SET_INDEX(r, index);
@@ -454,7 +454,7 @@ static GLuint get_temp_reg_tex(struct r300_fragment_program *rp)
/**
* Free a Mesa temporary and the associated R300 temporary.
*/
-static void free_temp(struct r300_fragment_program *rp, GLuint r)
+static void free_temp(struct r300_fragment_program *fp, GLuint r)
{
COMPILE_STATE;
GLuint index = REG_GET_INDEX(r);
@@ -463,11 +463,11 @@ static void free_temp(struct r300_fragment_program *rp, GLuint r)
return;
if (REG_GET_TYPE(r) == REG_TYPE_TEMP) {
- free_hw_temp(rp, cs->temps[index].reg);
+ free_hw_temp(fp, cs->temps[index].reg);
cs->temps[index].reg = -1;
cs->temp_in_use &= ~(1 << index);
} else if (REG_GET_TYPE(r) == REG_TYPE_INPUT) {
- free_hw_temp(rp, cs->inputs[index].reg);
+ free_hw_temp(fp, cs->inputs[index].reg);
cs->inputs[index].reg = -1;
}
}
@@ -481,25 +481,25 @@ static void free_temp(struct r300_fragment_program *rp, GLuint r)
* of the fragment program (actually, up until the next time the fragment
* program is translated).
*/
-static GLuint emit_const4fv(struct r300_fragment_program *rp,
+static GLuint emit_const4fv(struct r300_fragment_program *fp,
const GLfloat * cp)
{
GLuint reg = undef;
int index;
- for (index = 0; index < rp->const_nr; ++index) {
- if (rp->constant[index] == cp)
+ for (index = 0; index < fp->const_nr; ++index) {
+ if (fp->constant[index] == cp)
break;
}
- if (index >= rp->const_nr) {
+ if (index >= fp->const_nr) {
if (index >= PFS_NUM_CONST_REGS) {
ERROR("Out of hw constants!\n");
return reg;
}
- rp->const_nr++;
- rp->constant[index] = cp;
+ fp->const_nr++;
+ fp->constant[index] = cp;
}
REG_SET_TYPE(reg, REG_TYPE_CONST);
@@ -530,7 +530,7 @@ static inline GLuint absolute(GLuint r)
return r;
}
-static int swz_native(struct r300_fragment_program *rp,
+static int swz_native(struct r300_fragment_program *fp,
GLuint src, GLuint * r, GLuint arbneg)
{
/* Native swizzle, handle negation */
@@ -544,13 +544,13 @@ static int swz_native(struct r300_fragment_program *rp,
*r = src;
} else {
if (!REG_GET_VALID(*r))
- *r = get_temp_reg(rp);
+ *r = get_temp_reg(fp);
src |= REG_NEGV_MASK;
- emit_arith(rp,
+ emit_arith(fp,
PFS_OP_MAD,
*r, arbneg & 0x7, keep(src), pfs_one, pfs_zero, 0);
src = src & ~REG_NEGV_MASK;
- emit_arith(rp,
+ emit_arith(fp,
PFS_OP_MAD,
*r,
(arbneg ^ 0x7) | WRITEMASK_W,
@@ -560,7 +560,7 @@ static int swz_native(struct r300_fragment_program *rp,
return 3;
}
-static int swz_emit_partial(struct r300_fragment_program *rp,
+static int swz_emit_partial(struct r300_fragment_program *fp,
GLuint src,
GLuint * r, int mask, int mc, GLuint arbneg)
{
@@ -568,7 +568,7 @@ static int swz_emit_partial(struct r300_fragment_program *rp,
GLuint wmask = 0;
if (!REG_GET_VALID(*r))
- *r = get_temp_reg(rp);
+ *r = get_temp_reg(fp);
/* A partial match, VSWZ/mask define what parts of the
* desired swizzle we match
@@ -582,7 +582,7 @@ static int swz_emit_partial(struct r300_fragment_program *rp,
if (tmp) {
tmp = tmp ^ s_mask[mask].mask;
if (tmp) {
- emit_arith(rp,
+ emit_arith(fp,
PFS_OP_MAD,
*r,
arbneg & s_mask[mask].mask,
@@ -593,7 +593,7 @@ static int swz_emit_partial(struct r300_fragment_program *rp,
} else {
REG_SET_NO_USE(src, GL_FALSE);
}
- emit_arith(rp,
+ emit_arith(fp,
PFS_OP_MAD,
*r, tmp | wmask, src, pfs_one, pfs_zero, 0);
} else {
@@ -602,7 +602,7 @@ static int swz_emit_partial(struct r300_fragment_program *rp,
} else {
REG_SET_NO_USE(src, GL_FALSE);
}
- emit_arith(rp,
+ emit_arith(fp,
PFS_OP_MAD,
*r,
(arbneg & s_mask[mask].mask) | wmask,
@@ -614,7 +614,7 @@ static int swz_emit_partial(struct r300_fragment_program *rp,
} else {
REG_SET_NO_USE(src, GL_FALSE);
}
- emit_arith(rp, PFS_OP_MAD,
+ emit_arith(fp, PFS_OP_MAD,
*r,
s_mask[mask].mask | wmask,
src, pfs_one, pfs_zero, 0);
@@ -623,7 +623,7 @@ static int swz_emit_partial(struct r300_fragment_program *rp,
return s_mask[mask].count;
}
-static GLuint do_swizzle(struct r300_fragment_program *rp,
+static GLuint do_swizzle(struct r300_fragment_program *fp,
GLuint src, GLuint arbswz, GLuint arbneg)
{
GLuint r = undef;
@@ -636,8 +636,8 @@ static GLuint do_swizzle(struct r300_fragment_program *rp,
*/
#if 0
if (REG_GET_VSWZ(src) != SWIZZLE_XYZ || REG_GET_SSWZ(src) != SWIZZLE_W) {
- GLuint temp = get_temp_reg(rp);
- emit_arith(rp,
+ GLuint temp = get_temp_reg(fp);
+ emit_arith(fp,
PFS_OP_MAD,
temp, WRITEMASK_XYZW, src, pfs_one, pfs_zero, 0);
src = temp;
@@ -680,10 +680,10 @@ static GLuint do_swizzle(struct r300_fragment_program *rp,
if (chash == (arbswz & s_mask[c_mask].hash)) {
if (s_mask[c_mask].count == 3) {
- v_match += swz_native(rp,
+ v_match += swz_native(fp,
src, &r, arbneg);
} else {
- v_match += swz_emit_partial(rp,
+ v_match += swz_emit_partial(fp,
src,
&r,
c_mask,
@@ -708,7 +708,7 @@ static GLuint do_swizzle(struct r300_fragment_program *rp,
return r;
}
-static GLuint t_src(struct r300_fragment_program *rp,
+static GLuint t_src(struct r300_fragment_program *fp,
struct prog_src_register fpsrc)
{
GLuint r = undef;
@@ -725,19 +725,19 @@ static GLuint t_src(struct r300_fragment_program *rp,
REG_SET_TYPE(r, REG_TYPE_INPUT);
break;
case PROGRAM_LOCAL_PARAM:
- r = emit_const4fv(rp,
- rp->mesa_program.Base.LocalParams[fpsrc.
+ r = emit_const4fv(fp,
+ fp->mesa_program.Base.LocalParams[fpsrc.
Index]);
break;
case PROGRAM_ENV_PARAM:
- r = emit_const4fv(rp,
- rp->ctx->FragmentProgram.Parameters[fpsrc.
+ r = emit_const4fv(fp,
+ fp->ctx->FragmentProgram.Parameters[fpsrc.
Index]);
break;
case PROGRAM_STATE_VAR:
case PROGRAM_NAMED_PARAM:
- r = emit_const4fv(rp,
- rp->mesa_program.Base.Parameters->
+ r = emit_const4fv(fp,
+ fp->mesa_program.Base.Parameters->
ParameterValues[fpsrc.Index]);
break;
default:
@@ -747,11 +747,11 @@ static GLuint t_src(struct r300_fragment_program *rp,
/* no point swizzling ONE/ZERO/HALF constants... */
if (REG_GET_VSWZ(r) < SWIZZLE_111 || REG_GET_SSWZ(r) < SWIZZLE_ZERO)
- r = do_swizzle(rp, r, fpsrc.Swizzle, fpsrc.NegateBase);
+ r = do_swizzle(fp, r, fpsrc.Swizzle, fpsrc.NegateBase);
return r;
}
-static GLuint t_scalar_src(struct r300_fragment_program *rp,
+static GLuint t_scalar_src(struct r300_fragment_program *fp,
struct prog_src_register fpsrc)
{
struct prog_src_register src = fpsrc;
@@ -759,10 +759,10 @@ static GLuint t_scalar_src(struct r300_fragment_program *rp,
src.Swizzle = ((sc << 0) | (sc << 3) | (sc << 6) | (sc << 9));
- return t_src(rp, src);
+ return t_src(fp, src);
}
-static GLuint t_dst(struct r300_fragment_program *rp,
+static GLuint t_dst(struct r300_fragment_program *fp,
struct prog_dst_register dest)
{
GLuint r = undef;
@@ -791,7 +791,7 @@ static GLuint t_dst(struct r300_fragment_program *rp,
}
}
-static int t_hw_src(struct r300_fragment_program *rp, GLuint src, GLboolean tex)
+static int t_hw_src(struct r300_fragment_program *fp, GLuint src, GLboolean tex)
{
COMPILE_STATE;
int idx;
@@ -803,18 +803,18 @@ static int t_hw_src(struct r300_fragment_program *rp, GLuint src, GLboolean tex)
* hasn't been written to. Undefined results.
*/
if (cs->temps[index].reg == -1)
- cs->temps[index].reg = get_hw_temp(rp, cs->nrslots);
+ cs->temps[index].reg = get_hw_temp(fp, cs->nrslots);
idx = cs->temps[index].reg;
if (!REG_GET_NO_USE(src) && (--cs->temps[index].refcount == 0))
- free_temp(rp, src);
+ free_temp(fp, src);
break;
case REG_TYPE_INPUT:
idx = cs->inputs[index].reg;
if (!REG_GET_NO_USE(src) && (--cs->inputs[index].refcount == 0))
- free_hw_temp(rp, cs->inputs[index].reg);
+ free_hw_temp(fp, cs->inputs[index].reg);
break;
case REG_TYPE_CONST:
return (index | SRC_CONST);
@@ -829,7 +829,7 @@ static int t_hw_src(struct r300_fragment_program *rp, GLuint src, GLboolean tex)
return idx;
}
-static int t_hw_dst(struct r300_fragment_program *rp,
+static int t_hw_dst(struct r300_fragment_program *fp,
GLuint dest, GLboolean tex, int slot)
{
COMPILE_STATE;
@@ -841,15 +841,15 @@ static int t_hw_dst(struct r300_fragment_program *rp,
case REG_TYPE_TEMP:
if (cs->temps[REG_GET_INDEX(dest)].reg == -1) {
if (!tex) {
- cs->temps[index].reg = get_hw_temp(rp, slot);
+ cs->temps[index].reg = get_hw_temp(fp, slot);
} else {
- cs->temps[index].reg = get_hw_temp_tex(rp);
+ cs->temps[index].reg = get_hw_temp_tex(fp);
}
}
idx = cs->temps[index].reg;
if (!REG_GET_NO_USE(dest) && (--cs->temps[index].refcount == 0))
- free_temp(rp, dest);
+ free_temp(fp, dest);
cs->dest_in_node |= (1 << idx);
cs->used_in_node |= (1 << idx);
@@ -857,11 +857,11 @@ static int t_hw_dst(struct r300_fragment_program *rp,
case REG_TYPE_OUTPUT:
switch (index) {
case FRAG_RESULT_COLR:
- rp->node[rp->cur_node].flags |=
+ fp->node[fp->cur_node].flags |=
R300_PFS_NODE_OUTPUT_COLOR;
break;
case FRAG_RESULT_DEPR:
- rp->node[rp->cur_node].flags |=
+ fp->node[fp->cur_node].flags |=
R300_PFS_NODE_OUTPUT_DEPTH;
break;
}
@@ -875,7 +875,7 @@ static int t_hw_dst(struct r300_fragment_program *rp,
return idx;
}
-static void emit_nop(struct r300_fragment_program *rp)
+static void emit_nop(struct r300_fragment_program *fp)
{
COMPILE_STATE;
@@ -884,18 +884,18 @@ static void emit_nop(struct r300_fragment_program *rp)
return;
}
- rp->alu.inst[cs->nrslots].inst0 = NOP_INST0;
- rp->alu.inst[cs->nrslots].inst1 = NOP_INST1;
- rp->alu.inst[cs->nrslots].inst2 = NOP_INST2;
- rp->alu.inst[cs->nrslots].inst3 = NOP_INST3;
+ fp->alu.inst[cs->nrslots].inst0 = NOP_INST0;
+ fp->alu.inst[cs->nrslots].inst1 = NOP_INST1;
+ fp->alu.inst[cs->nrslots].inst2 = NOP_INST2;
+ fp->alu.inst[cs->nrslots].inst3 = NOP_INST3;
cs->nrslots++;
}
-static void emit_tex(struct r300_fragment_program *rp,
+static void emit_tex(struct r300_fragment_program *fp,
struct prog_instruction *fpi, int opcode)
{
COMPILE_STATE;
- GLuint coord = t_src(rp, fpi->SrcReg[0]);
+ GLuint coord = t_src(fp, fpi->SrcReg[0]);
GLuint dest = undef, rdest = undef;
GLuint din, uin;
int unit = fpi->TexSrcUnit;
@@ -925,49 +925,49 @@ static void emit_tex(struct r300_fragment_program *rp,
tokens[2] = unit;
factor_index =
- _mesa_add_state_reference(rp->mesa_program.Base.
+ _mesa_add_state_reference(fp->mesa_program.Base.
Parameters, tokens);
factorreg =
- emit_const4fv(rp,
- rp->mesa_program.Base.Parameters->
+ emit_const4fv(fp,
+ fp->mesa_program.Base.Parameters->
ParameterValues[factor_index]);
- tempreg = keep(get_temp_reg(rp));
+ tempreg = keep(get_temp_reg(fp));
- emit_arith(rp, PFS_OP_MAD, tempreg, WRITEMASK_XYZW,
+ emit_arith(fp, PFS_OP_MAD, tempreg, WRITEMASK_XYZW,
coord, factorreg, pfs_zero, 0);
/* Ensure correct node indirection */
uin = cs->used_in_node;
din = cs->dest_in_node;
- hwsrc = t_hw_src(rp, tempreg, GL_TRUE);
+ hwsrc = t_hw_src(fp, tempreg, GL_TRUE);
} else {
- hwsrc = t_hw_src(rp, coord, GL_TRUE);
+ hwsrc = t_hw_src(fp, coord, GL_TRUE);
}
- dest = t_dst(rp, fpi->DstReg);
+ dest = t_dst(fp, fpi->DstReg);
/* r300 doesn't seem to be able to do TEX->output reg */
if (REG_GET_TYPE(dest) == REG_TYPE_OUTPUT) {
rdest = dest;
- dest = get_temp_reg_tex(rp);
+ dest = get_temp_reg_tex(fp);
}
hwdest =
- t_hw_dst(rp, dest, GL_TRUE,
- rp->node[rp->cur_node].alu_offset);
+ t_hw_dst(fp, dest, GL_TRUE,
+ fp->node[fp->cur_node].alu_offset);
/* Use a temp that hasn't been used in this node, rather
* than causing an indirection
*/
if (uin & (1 << hwdest)) {
- free_hw_temp(rp, hwdest);
- hwdest = get_hw_temp_tex(rp);
+ free_hw_temp(fp, hwdest);
+ hwdest = get_hw_temp_tex(fp);
cs->temps[REG_GET_INDEX(dest)].reg = hwdest;
}
} else {
hwdest = 0;
unit = 0;
- hwsrc = t_hw_src(rp, coord, GL_TRUE);
+ hwsrc = t_hw_src(fp, coord, GL_TRUE);
}
/* Indirection if source has been written in this node, or if the
@@ -977,32 +977,32 @@ static void emit_tex(struct r300_fragment_program *rp,
(din & (1 << hwsrc))) || (uin & (1 << hwdest))) {
/* Finish off current node */
- if (rp->node[rp->cur_node].alu_offset == cs->nrslots)
- emit_nop(rp);
+ if (fp->node[fp->cur_node].alu_offset == cs->nrslots)
+ emit_nop(fp);
- rp->node[rp->cur_node].alu_end =
- cs->nrslots - rp->node[rp->cur_node].alu_offset - 1;
- assert(rp->node[rp->cur_node].alu_end >= 0);
+ fp->node[fp->cur_node].alu_end =
+ cs->nrslots - fp->node[fp->cur_node].alu_offset - 1;
+ assert(fp->node[fp->cur_node].alu_end >= 0);
- if (++rp->cur_node >= PFS_MAX_TEX_INDIRECT) {
+ if (++fp->cur_node >= PFS_MAX_TEX_INDIRECT) {
ERROR("too many levels of texture indirection\n");
return;
}
/* Start new node */
- rp->node[rp->cur_node].tex_offset = rp->tex.length;
- rp->node[rp->cur_node].alu_offset = cs->nrslots;
- rp->node[rp->cur_node].tex_end = -1;
- rp->node[rp->cur_node].alu_end = -1;
- rp->node[rp->cur_node].flags = 0;
+ fp->node[fp->cur_node].tex_offset = fp->tex.length;
+ fp->node[fp->cur_node].alu_offset = cs->nrslots;
+ fp->node[fp->cur_node].tex_end = -1;
+ fp->node[fp->cur_node].alu_end = -1;
+ fp->node[fp->cur_node].flags = 0;
cs->used_in_node = 0;
cs->dest_in_node = 0;
}
- if (rp->cur_node == 0)
- rp->first_node_has_tex = 1;
+ if (fp->cur_node == 0)
+ fp->first_node_has_tex = 1;
- rp->tex.inst[rp->tex.length++] = 0 | (hwsrc << R300_FPITX_SRC_SHIFT)
+ fp->tex.inst[fp->tex.length++] = 0 | (hwsrc << R300_FPITX_SRC_SHIFT)
| (hwdest << R300_FPITX_DST_SHIFT)
| (unit << R300_FPITX_IMAGE_SHIFT)
/* not entirely sure about this */
@@ -1012,25 +1012,25 @@ static void emit_tex(struct r300_fragment_program *rp,
if (REG_GET_TYPE(coord) != REG_TYPE_CONST)
cs->used_in_node |= (1 << hwsrc);
- rp->node[rp->cur_node].tex_end++;
+ fp->node[fp->cur_node].tex_end++;
/* Copy from temp to output if needed */
if (REG_GET_VALID(rdest)) {
- emit_arith(rp, PFS_OP_MAD, rdest, WRITEMASK_XYZW, dest,
+ emit_arith(fp, PFS_OP_MAD, rdest, WRITEMASK_XYZW, dest,
pfs_one, pfs_zero, 0);
- free_temp(rp, dest);
+ free_temp(fp, dest);
}
/* Free temp register */
if (tempreg != 0)
- free_temp(rp, tempreg);
+ free_temp(fp, tempreg);
}
/**
* Returns the first slot where we could possibly allow writing to dest,
* according to register allocation.
*/
-static int get_earliest_allowed_write(struct r300_fragment_program *rp,
+static int get_earliest_allowed_write(struct r300_fragment_program *fp,
GLuint dest, int mask)
{
COMPILE_STATE;
@@ -1080,7 +1080,7 @@ static int get_earliest_allowed_write(struct r300_fragment_program *rp,
*
* @return the index of the slot
*/
-static int find_and_prepare_slot(struct r300_fragment_program *rp,
+static int find_and_prepare_slot(struct r300_fragment_program *fp,
GLboolean emit_vop,
GLboolean emit_sop,
int argc, GLuint * src, GLuint dest, int mask)
@@ -1105,10 +1105,10 @@ static int find_and_prepare_slot(struct r300_fragment_program *rp,
if (emit_sop)
used |= SLOT_OP_SCALAR;
- pos = get_earliest_allowed_write(rp, dest, mask);
+ pos = get_earliest_allowed_write(fp, dest, mask);
- if (rp->node[rp->cur_node].alu_offset > pos)
- pos = rp->node[rp->cur_node].alu_offset;
+ if (fp->node[fp->cur_node].alu_offset > pos)
+ pos = fp->node[fp->cur_node].alu_offset;
for (i = 0; i < argc; ++i) {
if (!REG_GET_BUILTIN(src[i])) {
if (emit_vop)
@@ -1117,7 +1117,7 @@ static int find_and_prepare_slot(struct r300_fragment_program *rp,
used |= s_swiz[REG_GET_SSWZ(src[i])].flags << i;
}
- hwsrc[i] = t_hw_src(rp, src[i], GL_FALSE); /* Note: sideeffects wrt refcounting! */
+ hwsrc[i] = t_hw_src(fp, src[i], GL_FALSE); /* Note: sideeffects wrt refcounting! */
regnr = hwsrc[i] & 31;
if (REG_GET_TYPE(src[i]) == REG_TYPE_TEMP) {
@@ -1143,10 +1143,10 @@ static int find_and_prepare_slot(struct r300_fragment_program *rp,
return -1;
}
- rp->alu.inst[pos].inst0 = NOP_INST0;
- rp->alu.inst[pos].inst1 = NOP_INST1;
- rp->alu.inst[pos].inst2 = NOP_INST2;
- rp->alu.inst[pos].inst3 = NOP_INST3;
+ fp->alu.inst[pos].inst0 = NOP_INST0;
+ fp->alu.inst[pos].inst1 = NOP_INST1;
+ fp->alu.inst[pos].inst2 = NOP_INST2;
+ fp->alu.inst[pos].inst3 = NOP_INST3;
cs->nrslots++;
}
@@ -1223,14 +1223,14 @@ static int find_and_prepare_slot(struct r300_fragment_program *rp,
}
// Emit the source fetch code
- rp->alu.inst[pos].inst1 &= ~R300_FPI1_SRC_MASK;
- rp->alu.inst[pos].inst1 |=
+ fp->alu.inst[pos].inst1 &= ~R300_FPI1_SRC_MASK;
+ fp->alu.inst[pos].inst1 |=
((cs->slot[pos].vsrc[0] << R300_FPI1_SRC0C_SHIFT) |
(cs->slot[pos].vsrc[1] << R300_FPI1_SRC1C_SHIFT) |
(cs->slot[pos].vsrc[2] << R300_FPI1_SRC2C_SHIFT));
- rp->alu.inst[pos].inst3 &= ~R300_FPI3_SRC_MASK;
- rp->alu.inst[pos].inst3 |=
+ fp->alu.inst[pos].inst3 &= ~R300_FPI3_SRC_MASK;
+ fp->alu.inst[pos].inst3 |=
((cs->slot[pos].ssrc[0] << R300_FPI3_SRC0A_SHIFT) |
(cs->slot[pos].ssrc[1] << R300_FPI3_SRC1A_SHIFT) |
(cs->slot[pos].ssrc[2] << R300_FPI3_SRC2A_SHIFT));
@@ -1256,10 +1256,10 @@ static int find_and_prepare_slot(struct r300_fragment_program *rp,
}
}
- rp->alu.inst[pos].inst0 &=
+ fp->alu.inst[pos].inst0 &=
~(R300_FPI0_ARG0C_MASK | R300_FPI0_ARG1C_MASK |
R300_FPI0_ARG2C_MASK);
- rp->alu.inst[pos].inst0 |=
+ fp->alu.inst[pos].inst0 |=
(swz[0] << R300_FPI0_ARG0C_SHIFT) | (swz[1] <<
R300_FPI0_ARG1C_SHIFT)
| (swz[2] << R300_FPI0_ARG2C_SHIFT);
@@ -1285,10 +1285,10 @@ static int find_and_prepare_slot(struct r300_fragment_program *rp,
}
}
- rp->alu.inst[pos].inst2 &=
+ fp->alu.inst[pos].inst2 &=
~(R300_FPI2_ARG0A_MASK | R300_FPI2_ARG1A_MASK |
R300_FPI2_ARG2A_MASK);
- rp->alu.inst[pos].inst2 |=
+ fp->alu.inst[pos].inst2 |=
(swz[0] << R300_FPI2_ARG0A_SHIFT) | (swz[1] <<
R300_FPI2_ARG1A_SHIFT)
| (swz[2] << R300_FPI2_ARG2A_SHIFT);
@@ -1300,7 +1300,7 @@ static int find_and_prepare_slot(struct r300_fragment_program *rp,
/**
* Append an ALU instruction to the instruction list.
*/
-static void emit_arith(struct r300_fragment_program *rp,
+static void emit_arith(struct r300_fragment_program *fp,
int op,
GLuint dest,
int mask,
@@ -1334,12 +1334,12 @@ static void emit_arith(struct r300_fragment_program *rp,
emit_sop = GL_TRUE;
pos =
- find_and_prepare_slot(rp, emit_vop, emit_sop, argc, src, dest,
+ find_and_prepare_slot(fp, emit_vop, emit_sop, argc, src, dest,
mask);
if (pos < 0)
return;
- hwdest = t_hw_dst(rp, dest, GL_FALSE, pos); /* Note: Side effects wrt register allocation */
+ hwdest = t_hw_dst(fp, dest, GL_FALSE, pos); /* Note: Side effects wrt register allocation */
if (flags & PFS_FLAG_SAT) {
vop |= R300_FPI0_OUTC_SAT;
@@ -1348,19 +1348,19 @@ static void emit_arith(struct r300_fragment_program *rp,
/* Throw the pieces together and get FPI0/1 */
if (emit_vop) {
- rp->alu.inst[pos].inst0 |= vop;
+ fp->alu.inst[pos].inst0 |= vop;
- rp->alu.inst[pos].inst1 |= hwdest << R300_FPI1_DSTC_SHIFT;
+ fp->alu.inst[pos].inst1 |= hwdest << R300_FPI1_DSTC_SHIFT;
if (REG_GET_TYPE(dest) == REG_TYPE_OUTPUT) {
if (REG_GET_INDEX(dest) == FRAG_RESULT_COLR) {
- rp->alu.inst[pos].inst1 |=
+ fp->alu.inst[pos].inst1 |=
(mask & WRITEMASK_XYZ) <<
R300_FPI1_DSTC_OUTPUT_MASK_SHIFT;
} else
assert(0);
} else {
- rp->alu.inst[pos].inst1 |=
+ fp->alu.inst[pos].inst1 |=
(mask & WRITEMASK_XYZ) <<
R300_FPI1_DSTC_REG_MASK_SHIFT;
@@ -1370,22 +1370,22 @@ static void emit_arith(struct r300_fragment_program *rp,
/* And now FPI2/3 */
if (emit_sop) {
- rp->alu.inst[pos].inst2 |= sop;
+ fp->alu.inst[pos].inst2 |= sop;
if (mask & WRITEMASK_W) {
if (REG_GET_TYPE(dest) == REG_TYPE_OUTPUT) {
if (REG_GET_INDEX(dest) == FRAG_RESULT_COLR) {
- rp->alu.inst[pos].inst3 |=
+ fp->alu.inst[pos].inst3 |=
(hwdest << R300_FPI3_DSTA_SHIFT) |
R300_FPI3_DSTA_OUTPUT;
} else if (REG_GET_INDEX(dest) ==
FRAG_RESULT_DEPR) {
- rp->alu.inst[pos].inst3 |=
+ fp->alu.inst[pos].inst3 |=
R300_FPI3_DSTA_DEPTH;
} else
assert(0);
} else {
- rp->alu.inst[pos].inst3 |=
+ fp->alu.inst[pos].inst3 |=
(hwdest << R300_FPI3_DSTA_SHIFT) |
R300_FPI3_DSTA_REG;
@@ -1398,9 +1398,9 @@ static void emit_arith(struct r300_fragment_program *rp,
}
#if 0
-static GLuint get_attrib(struct r300_fragment_program *rp, GLuint attr)
+static GLuint get_attrib(struct r300_fragment_program *fp, GLuint attr)
{
- struct gl_fragment_program *mp = &rp->mesa_program;
+ struct gl_fragment_program *mp = &fp->mesa_program;
GLuint r = undef;
if (!(mp->Base.InputsRead & (1 << attr))) {
@@ -1455,7 +1455,7 @@ static GLfloat SinCosConsts[2][4] = {
static const GLfloat LitConst[4] =
{ 127.999999, 127.999999, 127.999999, -127.999999 };
-static void emit_lit(struct r300_fragment_program *rp,
+static void emit_lit(struct r300_fragment_program *fp,
GLuint dest, int mask, GLuint src, int flags)
{
COMPILE_STATE;
@@ -1463,7 +1463,7 @@ static void emit_lit(struct r300_fragment_program *rp,
int needTemporary;
GLuint temp;
- cnst = emit_const4fv(rp, LitConst);
+ cnst = emit_const4fv(fp, LitConst);
needTemporary = 0;
if ((mask & WRITEMASK_XYZW) != WRITEMASK_XYZW) {
@@ -1475,7 +1475,7 @@ static void emit_lit(struct r300_fragment_program *rp,
}
if (needTemporary) {
- temp = keep(get_temp_reg(rp));
+ temp = keep(get_temp_reg(fp));
} else {
temp = keep(dest);
}
@@ -1486,49 +1486,49 @@ static void emit_lit(struct r300_fragment_program *rp,
// so swizzling between the two parts can create fake dependencies.
// First slot
- emit_arith(rp, PFS_OP_MAX, temp, WRITEMASK_XY,
+ emit_arith(fp, PFS_OP_MAX, temp, WRITEMASK_XY,
keep(src), pfs_zero, undef, 0);
- emit_arith(rp, PFS_OP_MAX, temp, WRITEMASK_W, src, cnst, undef, 0);
+ emit_arith(fp, PFS_OP_MAX, temp, WRITEMASK_W, src, cnst, undef, 0);
// Second slot
- emit_arith(rp, PFS_OP_MIN, temp, WRITEMASK_Z,
+ emit_arith(fp, PFS_OP_MIN, temp, WRITEMASK_Z,
swizzle(temp, W, W, W, W), cnst, undef, 0);
- emit_arith(rp, PFS_OP_LG2, temp, WRITEMASK_W,
+ emit_arith(fp, PFS_OP_LG2, temp, WRITEMASK_W,
swizzle(temp, Y, Y, Y, Y), undef, undef, 0);
// Third slot
// If desired, we saturate the y result here.
// This does not affect the use as a condition variable in the CMP later
- emit_arith(rp, PFS_OP_MAD, temp, WRITEMASK_W,
+ emit_arith(fp, PFS_OP_MAD, temp, WRITEMASK_W,
temp, swizzle(temp, Z, Z, Z, Z), pfs_zero, 0);
- emit_arith(rp, PFS_OP_MAD, temp, WRITEMASK_Y,
+ emit_arith(fp, PFS_OP_MAD, temp, WRITEMASK_Y,
swizzle(temp, X, X, X, X), pfs_one, pfs_zero, flags);
// Fourth slot
- emit_arith(rp, PFS_OP_MAD, temp, WRITEMASK_X,
+ emit_arith(fp, PFS_OP_MAD, temp, WRITEMASK_X,
pfs_one, pfs_one, pfs_zero, 0);
- emit_arith(rp, PFS_OP_EX2, temp, WRITEMASK_W, temp, undef, undef, 0);
+ emit_arith(fp, PFS_OP_EX2, temp, WRITEMASK_W, temp, undef, undef, 0);
// Fifth slot
- emit_arith(rp, PFS_OP_CMP, temp, WRITEMASK_Z,
+ emit_arith(fp, PFS_OP_CMP, temp, WRITEMASK_Z,
pfs_zero, swizzle(temp, W, W, W, W),
negate(swizzle(temp, Y, Y, Y, Y)), flags);
- emit_arith(rp, PFS_OP_MAD, temp, WRITEMASK_W, pfs_one, pfs_one,
+ emit_arith(fp, PFS_OP_MAD, temp, WRITEMASK_W, pfs_one, pfs_one,
pfs_zero, 0);
if (needTemporary) {
- emit_arith(rp, PFS_OP_MAD, dest, mask,
+ emit_arith(fp, PFS_OP_MAD, dest, mask,
temp, pfs_one, pfs_zero, flags);
- free_temp(rp, temp);
+ free_temp(fp, temp);
} else {
// Decrease refcount of the destination
- t_hw_dst(rp, dest, GL_FALSE, cs->nrslots);
+ t_hw_dst(fp, dest, GL_FALSE, cs->nrslots);
}
}
-static GLboolean parse_program(struct r300_fragment_program *rp)
+static GLboolean parse_program(struct r300_fragment_program *fp)
{
- struct gl_fragment_program *mp = &rp->mesa_program;
+ struct gl_fragment_program *mp = &fp->mesa_program;
const struct prog_instruction *inst = mp->Base.Instructions;
struct prog_instruction *fpi;
GLuint src[3], dest, temp[2];
@@ -1547,30 +1547,30 @@ static GLboolean parse_program(struct r300_fragment_program *rp)
flags = 0;
if (fpi->Opcode != OPCODE_KIL) {
- dest = t_dst(rp, fpi->DstReg);
+ dest = t_dst(fp, fpi->DstReg);
mask = fpi->DstReg.WriteMask;
}
switch (fpi->Opcode) {
case OPCODE_ABS:
- src[0] = t_src(rp, fpi->SrcReg[0]);
- emit_arith(rp, PFS_OP_MAD, dest, mask,
+ src[0] = t_src(fp, fpi->SrcReg[0]);
+ emit_arith(fp, PFS_OP_MAD, dest, mask,
absolute(src[0]), pfs_one, pfs_zero, flags);
break;
case OPCODE_ADD:
- src[0] = t_src(rp, fpi->SrcReg[0]);
- src[1] = t_src(rp, fpi->SrcReg[1]);
- emit_arith(rp, PFS_OP_MAD, dest, mask,
+ src[0] = t_src(fp, fpi->SrcReg[0]);
+ src[1] = t_src(fp, fpi->SrcReg[1]);
+ emit_arith(fp, PFS_OP_MAD, dest, mask,
src[0], pfs_one, src[1], flags);
break;
case OPCODE_CMP:
- src[0] = t_src(rp, fpi->SrcReg[0]);
- src[1] = t_src(rp, fpi->SrcReg[1]);
- src[2] = t_src(rp, fpi->SrcReg[2]);
+ src[0] = t_src(fp, fpi->SrcReg[0]);
+ src[1] = t_src(fp, fpi->SrcReg[1]);
+ src[2] = t_src(fp, fpi->SrcReg[2]);
/* ARB_f_p - if src0.c < 0.0 ? src1.c : src2.c
* r300 - if src2.c < 0.0 ? src1.c : src0.c
*/
- emit_arith(rp, PFS_OP_CMP, dest, mask,
+ emit_arith(fp, PFS_OP_CMP, dest, mask,
src[2], src[1], src[0], flags);
break;
case OPCODE_COS:
@@ -1582,206 +1582,206 @@ static GLboolean parse_program(struct r300_fragment_program *rp)
* x = (x*2*PI)-PI
* result = sin(x)
*/
- temp[0] = get_temp_reg(rp);
- const_sin[0] = emit_const4fv(rp, SinCosConsts[0]);
- const_sin[1] = emit_const4fv(rp, SinCosConsts[1]);
- src[0] = t_scalar_src(rp, fpi->SrcReg[0]);
+ temp[0] = get_temp_reg(fp);
+ const_sin[0] = emit_const4fv(fp, SinCosConsts[0]);
+ const_sin[1] = emit_const4fv(fp, SinCosConsts[1]);
+ src[0] = t_scalar_src(fp, fpi->SrcReg[0]);
/* add 0.5*PI and do range reduction */
- emit_arith(rp, PFS_OP_MAD, temp[0], WRITEMASK_X,
+ emit_arith(fp, PFS_OP_MAD, temp[0], WRITEMASK_X,
swizzle(src[0], X, X, X, X),
swizzle(const_sin[1], Z, Z, Z, Z),
swizzle(const_sin[1], X, X, X, X), 0);
- emit_arith(rp, PFS_OP_FRC, temp[0], WRITEMASK_X,
+ emit_arith(fp, PFS_OP_FRC, temp[0], WRITEMASK_X,
swizzle(temp[0], X, X, X, X),
undef, undef, 0);
- emit_arith(rp, PFS_OP_MAD, temp[0], WRITEMASK_Z, swizzle(temp[0], X, X, X, X), swizzle(const_sin[1], W, W, W, W), //2*PI
+ emit_arith(fp, PFS_OP_MAD, temp[0], WRITEMASK_Z, swizzle(temp[0], X, X, X, X), swizzle(const_sin[1], W, W, W, W), //2*PI
negate(swizzle(const_sin[0], Z, Z, Z, Z)), //-PI
0);
/* SIN */
- emit_arith(rp, PFS_OP_MAD, temp[0],
+ emit_arith(fp, PFS_OP_MAD, temp[0],
WRITEMASK_X | WRITEMASK_Y, swizzle(temp[0],
Z, Z, Z,
Z),
const_sin[0], pfs_zero, 0);
- emit_arith(rp, PFS_OP_MAD, temp[0], WRITEMASK_X,
+ emit_arith(fp, PFS_OP_MAD, temp[0], WRITEMASK_X,
swizzle(temp[0], Y, Y, Y, Y),
absolute(swizzle(temp[0], Z, Z, Z, Z)),
swizzle(temp[0], X, X, X, X), 0);
- emit_arith(rp, PFS_OP_MAD, temp[0], WRITEMASK_Y,
+ emit_arith(fp, PFS_OP_MAD, temp[0], WRITEMASK_Y,
swizzle(temp[0], X, X, X, X),
absolute(swizzle(temp[0], X, X, X, X)),
negate(swizzle(temp[0], X, X, X, X)), 0);
- emit_arith(rp, PFS_OP_MAD, dest, mask,
+ emit_arith(fp, PFS_OP_MAD, dest, mask,
swizzle(temp[0], Y, Y, Y, Y),
swizzle(const_sin[0], W, W, W, W),
swizzle(temp[0], X, X, X, X), flags);
- free_temp(rp, temp[0]);
+ free_temp(fp, temp[0]);
break;
case OPCODE_DP3:
- src[0] = t_src(rp, fpi->SrcReg[0]);
- src[1] = t_src(rp, fpi->SrcReg[1]);
- emit_arith(rp, PFS_OP_DP3, dest, mask,
+ src[0] = t_src(fp, fpi->SrcReg[0]);
+ src[1] = t_src(fp, fpi->SrcReg[1]);
+ emit_arith(fp, PFS_OP_DP3, dest, mask,
src[0], src[1], undef, flags);
break;
case OPCODE_DP4:
- src[0] = t_src(rp, fpi->SrcReg[0]);
- src[1] = t_src(rp, fpi->SrcReg[1]);
- emit_arith(rp, PFS_OP_DP4, dest, mask,
+ src[0] = t_src(fp, fpi->SrcReg[0]);
+ src[1] = t_src(fp, fpi->SrcReg[1]);
+ emit_arith(fp, PFS_OP_DP4, dest, mask,
src[0], src[1], undef, flags);
break;
case OPCODE_DPH:
- src[0] = t_src(rp, fpi->SrcReg[0]);
- src[1] = t_src(rp, fpi->SrcReg[1]);
+ src[0] = t_src(fp, fpi->SrcReg[0]);
+ src[1] = t_src(fp, fpi->SrcReg[1]);
/* src0.xyz1 -> temp
* DP4 dest, temp, src1
*/
#if 0
- temp[0] = get_temp_reg(rp);
+ temp[0] = get_temp_reg(fp);
src[0].s_swz = SWIZZLE_ONE;
- emit_arith(rp, PFS_OP_MAD, temp[0], mask,
+ emit_arith(fp, PFS_OP_MAD, temp[0], mask,
src[0], pfs_one, pfs_zero, 0);
- emit_arith(rp, PFS_OP_DP4, dest, mask,
+ emit_arith(fp, PFS_OP_DP4, dest, mask,
temp[0], src[1], undef, flags);
- free_temp(rp, temp[0]);
+ free_temp(fp, temp[0]);
#else
- emit_arith(rp, PFS_OP_DP4, dest, mask,
+ emit_arith(fp, PFS_OP_DP4, dest, mask,
swizzle(src[0], X, Y, Z, ONE), src[1],
undef, flags);
#endif
break;
case OPCODE_DST:
- src[0] = t_src(rp, fpi->SrcReg[0]);
- src[1] = t_src(rp, fpi->SrcReg[1]);
+ src[0] = t_src(fp, fpi->SrcReg[0]);
+ src[1] = t_src(fp, fpi->SrcReg[1]);
/* dest.y = src0.y * src1.y */
if (mask & WRITEMASK_Y)
- emit_arith(rp, PFS_OP_MAD, dest, WRITEMASK_Y,
+ emit_arith(fp, PFS_OP_MAD, dest, WRITEMASK_Y,
keep(src[0]), keep(src[1]),
pfs_zero, flags);
/* dest.z = src0.z */
if (mask & WRITEMASK_Z)
- emit_arith(rp, PFS_OP_MAD, dest, WRITEMASK_Z,
+ emit_arith(fp, PFS_OP_MAD, dest, WRITEMASK_Z,
src[0], pfs_one, pfs_zero, flags);
/* result.x = 1.0
* result.w = src1.w */
if (mask & WRITEMASK_XW) {
REG_SET_VSWZ(src[1], SWIZZLE_111); /*Cheat */
- emit_arith(rp, PFS_OP_MAD, dest,
+ emit_arith(fp, PFS_OP_MAD, dest,
mask & WRITEMASK_XW,
src[1], pfs_one, pfs_zero, flags);
}
break;
case OPCODE_EX2:
- src[0] = t_scalar_src(rp, fpi->SrcReg[0]);
- emit_arith(rp, PFS_OP_EX2, dest, mask,
+ src[0] = t_scalar_src(fp, fpi->SrcReg[0]);
+ emit_arith(fp, PFS_OP_EX2, dest, mask,
src[0], undef, undef, flags);
break;
case OPCODE_FLR:
- src[0] = t_src(rp, fpi->SrcReg[0]);
- temp[0] = get_temp_reg(rp);
+ src[0] = t_src(fp, fpi->SrcReg[0]);
+ temp[0] = get_temp_reg(fp);
/* FRC temp, src0
* MAD dest, src0, 1.0, -temp
*/
- emit_arith(rp, PFS_OP_FRC, temp[0], mask,
+ emit_arith(fp, PFS_OP_FRC, temp[0], mask,
keep(src[0]), undef, undef, 0);
- emit_arith(rp, PFS_OP_MAD, dest, mask,
+ emit_arith(fp, PFS_OP_MAD, dest, mask,
src[0], pfs_one, negate(temp[0]), flags);
- free_temp(rp, temp[0]);
+ free_temp(fp, temp[0]);
break;
case OPCODE_FRC:
- src[0] = t_src(rp, fpi->SrcReg[0]);
- emit_arith(rp, PFS_OP_FRC, dest, mask,
+ src[0] = t_src(fp, fpi->SrcReg[0]);
+ emit_arith(fp, PFS_OP_FRC, dest, mask,
src[0], undef, undef, flags);
break;
case OPCODE_KIL:
- emit_tex(rp, fpi, R300_FPITX_OP_KIL);
+ emit_tex(fp, fpi, R300_FPITX_OP_KIL);
break;
case OPCODE_LG2:
- src[0] = t_scalar_src(rp, fpi->SrcReg[0]);
- emit_arith(rp, PFS_OP_LG2, dest, mask,
+ src[0] = t_scalar_src(fp, fpi->SrcReg[0]);
+ emit_arith(fp, PFS_OP_LG2, dest, mask,
src[0], undef, undef, flags);
break;
case OPCODE_LIT:
- src[0] = t_src(rp, fpi->SrcReg[0]);
- emit_lit(rp, dest, mask, src[0], flags);
+ src[0] = t_src(fp, fpi->SrcReg[0]);
+ emit_lit(fp, dest, mask, src[0], flags);
break;
case OPCODE_LRP:
- src[0] = t_src(rp, fpi->SrcReg[0]);
- src[1] = t_src(rp, fpi->SrcReg[1]);
- src[2] = t_src(rp, fpi->SrcReg[2]);
+ src[0] = t_src(fp, fpi->SrcReg[0]);
+ src[1] = t_src(fp, fpi->SrcReg[1]);
+ src[2] = t_src(fp, fpi->SrcReg[2]);
/* result = tmp0tmp1 + (1 - tmp0)tmp2
* = tmp0tmp1 + tmp2 + (-tmp0)tmp2
* MAD temp, -tmp0, tmp2, tmp2
* MAD result, tmp0, tmp1, temp
*/
- temp[0] = get_temp_reg(rp);
- emit_arith(rp, PFS_OP_MAD, temp[0], mask,
+ temp[0] = get_temp_reg(fp);
+ emit_arith(fp, PFS_OP_MAD, temp[0], mask,
negate(keep(src[0])), keep(src[2]), src[2],
0);
- emit_arith(rp, PFS_OP_MAD, dest, mask,
+ emit_arith(fp, PFS_OP_MAD, dest, mask,
src[0], src[1], temp[0], flags);
- free_temp(rp, temp[0]);
+ free_temp(fp, temp[0]);
break;
case OPCODE_MAD:
- src[0] = t_src(rp, fpi->SrcReg[0]);
- src[1] = t_src(rp, fpi->SrcReg[1]);
- src[2] = t_src(rp, fpi->SrcReg[2]);
- emit_arith(rp, PFS_OP_MAD, dest, mask,
+ src[0] = t_src(fp, fpi->SrcReg[0]);
+ src[1] = t_src(fp, fpi->SrcReg[1]);
+ src[2] = t_src(fp, fpi->SrcReg[2]);
+ emit_arith(fp, PFS_OP_MAD, dest, mask,
src[0], src[1], src[2], flags);
break;
case OPCODE_MAX:
- src[0] = t_src(rp, fpi->SrcReg[0]);
- src[1] = t_src(rp, fpi->SrcReg[1]);
- emit_arith(rp, PFS_OP_MAX, dest, mask,
+ src[0] = t_src(fp, fpi->SrcReg[0]);
+ src[1] = t_src(fp, fpi->SrcReg[1]);
+ emit_arith(fp, PFS_OP_MAX, dest, mask,
src[0], src[1], undef, flags);
break;
case OPCODE_MIN:
- src[0] = t_src(rp, fpi->SrcReg[0]);
- src[1] = t_src(rp, fpi->SrcReg[1]);
- emit_arith(rp, PFS_OP_MIN, dest, mask,
+ src[0] = t_src(fp, fpi->SrcReg[0]);
+ src[1] = t_src(fp, fpi->SrcReg[1]);
+ emit_arith(fp, PFS_OP_MIN, dest, mask,
src[0], src[1], undef, flags);
break;
case OPCODE_MOV:
case OPCODE_SWZ:
- src[0] = t_src(rp, fpi->SrcReg[0]);
- emit_arith(rp, PFS_OP_MAD, dest, mask,
+ src[0] = t_src(fp, fpi->SrcReg[0]);
+ emit_arith(fp, PFS_OP_MAD, dest, mask,
src[0], pfs_one, pfs_zero, flags);
break;
case OPCODE_MUL:
- src[0] = t_src(rp, fpi->SrcReg[0]);
- src[1] = t_src(rp, fpi->SrcReg[1]);
- emit_arith(rp, PFS_OP_MAD, dest, mask,
+ src[0] = t_src(fp, fpi->SrcReg[0]);
+ src[1] = t_src(fp, fpi->SrcReg[1]);
+ emit_arith(fp, PFS_OP_MAD, dest, mask,
src[0], src[1], pfs_zero, flags);
break;
case OPCODE_POW:
- src[0] = t_scalar_src(rp, fpi->SrcReg[0]);
- src[1] = t_scalar_src(rp, fpi->SrcReg[1]);
- temp[0] = get_temp_reg(rp);
- emit_arith(rp, PFS_OP_LG2, temp[0], WRITEMASK_W,
+ src[0] = t_scalar_src(fp, fpi->SrcReg[0]);
+ src[1] = t_scalar_src(fp, fpi->SrcReg[1]);
+ temp[0] = get_temp_reg(fp);
+ emit_arith(fp, PFS_OP_LG2, temp[0], WRITEMASK_W,
src[0], undef, undef, 0);
- emit_arith(rp, PFS_OP_MAD, temp[0], WRITEMASK_W,
+ emit_arith(fp, PFS_OP_MAD, temp[0], WRITEMASK_W,
temp[0], src[1], pfs_zero, 0);
- emit_arith(rp, PFS_OP_EX2, dest, fpi->DstReg.WriteMask,
+ emit_arith(fp, PFS_OP_EX2, dest, fpi->DstReg.WriteMask,
temp[0], undef, undef, 0);
- free_temp(rp, temp[0]);
+ free_temp(fp, temp[0]);
break;
case OPCODE_RCP:
- src[0] = t_scalar_src(rp, fpi->SrcReg[0]);
- emit_arith(rp, PFS_OP_RCP, dest, mask,
+ src[0] = t_scalar_src(fp, fpi->SrcReg[0]);
+ emit_arith(fp, PFS_OP_RCP, dest, mask,
src[0], undef, undef, flags);
break;
case OPCODE_RSQ:
- src[0] = t_scalar_src(rp, fpi->SrcReg[0]);
- emit_arith(rp, PFS_OP_RSQ, dest, mask,
+ src[0] = t_scalar_src(fp, fpi->SrcReg[0]);
+ emit_arith(fp, PFS_OP_RSQ, dest, mask,
absolute(src[0]), pfs_zero, pfs_zero, flags);
break;
case OPCODE_SCS:
@@ -1792,51 +1792,51 @@ static GLboolean parse_program(struct r300_fragment_program *rp)
* result.y = sin(x) (sin)
*
*/
- temp[0] = get_temp_reg(rp);
- temp[1] = get_temp_reg(rp);
- const_sin[0] = emit_const4fv(rp, SinCosConsts[0]);
- const_sin[1] = emit_const4fv(rp, SinCosConsts[1]);
- src[0] = t_scalar_src(rp, fpi->SrcReg[0]);
+ temp[0] = get_temp_reg(fp);
+ temp[1] = get_temp_reg(fp);
+ const_sin[0] = emit_const4fv(fp, SinCosConsts[0]);
+ const_sin[1] = emit_const4fv(fp, SinCosConsts[1]);
+ src[0] = t_scalar_src(fp, fpi->SrcReg[0]);
/* x = -abs(x)+0.5*PI */
- emit_arith(rp, PFS_OP_MAD, temp[0], WRITEMASK_Z, swizzle(const_sin[0], Z, Z, Z, Z), //PI
+ emit_arith(fp, PFS_OP_MAD, temp[0], WRITEMASK_Z, swizzle(const_sin[0], Z, Z, Z, Z), //PI
pfs_half,
negate(abs
(swizzle(keep(src[0]), X, X, X, X))),
0);
/* C*x (sin) */
- emit_arith(rp, PFS_OP_MAD, temp[0], WRITEMASK_W,
+ emit_arith(fp, PFS_OP_MAD, temp[0], WRITEMASK_W,
swizzle(const_sin[0], Y, Y, Y, Y),
swizzle(keep(src[0]), X, X, X, X),
pfs_zero, 0);
/* B*x, C*x (cos) */
- emit_arith(rp, PFS_OP_MAD, temp[0],
+ emit_arith(fp, PFS_OP_MAD, temp[0],
WRITEMASK_X | WRITEMASK_Y, swizzle(temp[0],
Z, Z, Z,
Z),
const_sin[0], pfs_zero, 0);
/* B*x (sin) */
- emit_arith(rp, PFS_OP_MAD, temp[1], WRITEMASK_W,
+ emit_arith(fp, PFS_OP_MAD, temp[1], WRITEMASK_W,
swizzle(const_sin[0], X, X, X, X),
keep(src[0]), pfs_zero, 0);
/* y = B*x + C*x*abs(x) (sin) */
- emit_arith(rp, PFS_OP_MAD, temp[1], WRITEMASK_Z,
+ emit_arith(fp, PFS_OP_MAD, temp[1], WRITEMASK_Z,
absolute(src[0]),
swizzle(temp[0], W, W, W, W),
swizzle(temp[1], W, W, W, W), 0);
/* y = B*x + C*x*abs(x) (cos) */
- emit_arith(rp, PFS_OP_MAD, temp[1], WRITEMASK_W,
+ emit_arith(fp, PFS_OP_MAD, temp[1], WRITEMASK_W,
swizzle(temp[0], Y, Y, Y, Y),
absolute(swizzle(temp[0], Z, Z, Z, Z)),
swizzle(temp[0], X, X, X, X), 0);
/* y*abs(y) - y (cos), y*abs(y) - y (sin) */
- emit_arith(rp, PFS_OP_MAD, temp[0],
+ emit_arith(fp, PFS_OP_MAD, temp[0],
WRITEMASK_X | WRITEMASK_Y, swizzle(temp[1],
W, Z, Y,
X),
@@ -1844,26 +1844,26 @@ static GLboolean parse_program(struct r300_fragment_program *rp)
negate(swizzle(temp[1], W, Z, Y, X)), 0);
/* dest.xy = mad(temp.xy, P, temp2.wz) */
- emit_arith(rp, PFS_OP_MAD, dest,
+ emit_arith(fp, PFS_OP_MAD, dest,
mask & (WRITEMASK_X | WRITEMASK_Y), temp[0],
swizzle(const_sin[0], W, W, W, W),
swizzle(temp[1], W, Z, Y, X), flags);
- free_temp(rp, temp[0]);
- free_temp(rp, temp[1]);
+ free_temp(fp, temp[0]);
+ free_temp(fp, temp[1]);
break;
case OPCODE_SGE:
- src[0] = t_src(rp, fpi->SrcReg[0]);
- src[1] = t_src(rp, fpi->SrcReg[1]);
- temp[0] = get_temp_reg(rp);
+ src[0] = t_src(fp, fpi->SrcReg[0]);
+ src[1] = t_src(fp, fpi->SrcReg[1]);
+ temp[0] = get_temp_reg(fp);
/* temp = src0 - src1
* dest.c = (temp.c < 0.0) ? 0 : 1
*/
- emit_arith(rp, PFS_OP_MAD, temp[0], mask,
+ emit_arith(fp, PFS_OP_MAD, temp[0], mask,
src[0], pfs_one, negate(src[1]), 0);
- emit_arith(rp, PFS_OP_CMP, dest, mask,
+ emit_arith(fp, PFS_OP_CMP, dest, mask,
pfs_one, pfs_zero, temp[0], 0);
- free_temp(rp, temp[0]);
+ free_temp(fp, temp[0]);
break;
case OPCODE_SIN:
/*
@@ -1873,85 +1873,85 @@ static GLboolean parse_program(struct r300_fragment_program *rp)
* itself squared.
*/
- temp[0] = get_temp_reg(rp);
- const_sin[0] = emit_const4fv(rp, SinCosConsts[0]);
- const_sin[1] = emit_const4fv(rp, SinCosConsts[1]);
- src[0] = t_scalar_src(rp, fpi->SrcReg[0]);
+ temp[0] = get_temp_reg(fp);
+ const_sin[0] = emit_const4fv(fp, SinCosConsts[0]);
+ const_sin[1] = emit_const4fv(fp, SinCosConsts[1]);
+ src[0] = t_scalar_src(fp, fpi->SrcReg[0]);
/* do range reduction */
- emit_arith(rp, PFS_OP_MAD, temp[0], WRITEMASK_X,
+ emit_arith(fp, PFS_OP_MAD, temp[0], WRITEMASK_X,
swizzle(keep(src[0]), X, X, X, X),
swizzle(const_sin[1], Z, Z, Z, Z),
pfs_half, 0);
- emit_arith(rp, PFS_OP_FRC, temp[0], WRITEMASK_X,
+ emit_arith(fp, PFS_OP_FRC, temp[0], WRITEMASK_X,
swizzle(temp[0], X, X, X, X),
undef, undef, 0);
- emit_arith(rp, PFS_OP_MAD, temp[0], WRITEMASK_Z, swizzle(temp[0], X, X, X, X), swizzle(const_sin[1], W, W, W, W), //2*PI
+ emit_arith(fp, PFS_OP_MAD, temp[0], WRITEMASK_Z, swizzle(temp[0], X, X, X, X), swizzle(const_sin[1], W, W, W, W), //2*PI
negate(swizzle(const_sin[0], Z, Z, Z, Z)), //PI
0);
/* SIN */
- emit_arith(rp, PFS_OP_MAD, temp[0],
+ emit_arith(fp, PFS_OP_MAD, temp[0],
WRITEMASK_X | WRITEMASK_Y, swizzle(temp[0],
Z, Z, Z,
Z),
const_sin[0], pfs_zero, 0);
- emit_arith(rp, PFS_OP_MAD, temp[0], WRITEMASK_X,
+ emit_arith(fp, PFS_OP_MAD, temp[0], WRITEMASK_X,
swizzle(temp[0], Y, Y, Y, Y),
absolute(swizzle(temp[0], Z, Z, Z, Z)),
swizzle(temp[0], X, X, X, X), 0);
- emit_arith(rp, PFS_OP_MAD, temp[0], WRITEMASK_Y,
+ emit_arith(fp, PFS_OP_MAD, temp[0], WRITEMASK_Y,
swizzle(temp[0], X, X, X, X),
absolute(swizzle(temp[0], X, X, X, X)),
negate(swizzle(temp[0], X, X, X, X)), 0);
- emit_arith(rp, PFS_OP_MAD, dest, mask,
+ emit_arith(fp, PFS_OP_MAD, dest, mask,
swizzle(temp[0], Y, Y, Y, Y),
swizzle(const_sin[0], W, W, W, W),
swizzle(temp[0], X, X, X, X), flags);
- free_temp(rp, temp[0]);
+ free_temp(fp, temp[0]);
break;
case OPCODE_SLT:
- src[0] = t_src(rp, fpi->SrcReg[0]);
- src[1] = t_src(rp, fpi->SrcReg[1]);
- temp[0] = get_temp_reg(rp);
+ src[0] = t_src(fp, fpi->SrcReg[0]);
+ src[1] = t_src(fp, fpi->SrcReg[1]);
+ temp[0] = get_temp_reg(fp);
/* temp = src0 - src1
* dest.c = (temp.c < 0.0) ? 1 : 0
*/
- emit_arith(rp, PFS_OP_MAD, temp[0], mask,
+ emit_arith(fp, PFS_OP_MAD, temp[0], mask,
src[0], pfs_one, negate(src[1]), 0);
- emit_arith(rp, PFS_OP_CMP, dest, mask,
+ emit_arith(fp, PFS_OP_CMP, dest, mask,
pfs_zero, pfs_one, temp[0], 0);
- free_temp(rp, temp[0]);
+ free_temp(fp, temp[0]);
break;
case OPCODE_SUB:
- src[0] = t_src(rp, fpi->SrcReg[0]);
- src[1] = t_src(rp, fpi->SrcReg[1]);
- emit_arith(rp, PFS_OP_MAD, dest, mask,
+ src[0] = t_src(fp, fpi->SrcReg[0]);
+ src[1] = t_src(fp, fpi->SrcReg[1]);
+ emit_arith(fp, PFS_OP_MAD, dest, mask,
src[0], pfs_one, negate(src[1]), flags);
break;
case OPCODE_TEX:
- emit_tex(rp, fpi, R300_FPITX_OP_TEX);
+ emit_tex(fp, fpi, R300_FPITX_OP_TEX);
break;
case OPCODE_TXB:
- emit_tex(rp, fpi, R300_FPITX_OP_TXB);
+ emit_tex(fp, fpi, R300_FPITX_OP_TXB);
break;
case OPCODE_TXP:
- emit_tex(rp, fpi, R300_FPITX_OP_TXP);
+ emit_tex(fp, fpi, R300_FPITX_OP_TXP);
break;
case OPCODE_XPD:{
- src[0] = t_src(rp, fpi->SrcReg[0]);
- src[1] = t_src(rp, fpi->SrcReg[1]);
- temp[0] = get_temp_reg(rp);
+ src[0] = t_src(fp, fpi->SrcReg[0]);
+ src[1] = t_src(fp, fpi->SrcReg[1]);
+ temp[0] = get_temp_reg(fp);
/* temp = src0.zxy * src1.yzx */
- emit_arith(rp, PFS_OP_MAD, temp[0],
+ emit_arith(fp, PFS_OP_MAD, temp[0],
WRITEMASK_XYZ, swizzle(keep(src[0]),
Z, X, Y, W),
swizzle(keep(src[1]), Y, Z, X, W),
@@ -1959,14 +1959,14 @@ static GLboolean parse_program(struct r300_fragment_program *rp)
/* dest.xyz = src0.yzx * src1.zxy - temp
* dest.w = undefined
* */
- emit_arith(rp, PFS_OP_MAD, dest,
+ emit_arith(fp, PFS_OP_MAD, dest,
mask & WRITEMASK_XYZ, swizzle(src[0],
Y, Z,
X, W),
swizzle(src[1], Z, X, Y, W),
negate(temp[0]), flags);
/* cleanup */
- free_temp(rp, temp[0]);
+ free_temp(fp, temp[0]);
break;
}
default:
@@ -1974,7 +1974,7 @@ static GLboolean parse_program(struct r300_fragment_program *rp)
break;
}
- if (rp->error)
+ if (fp->error)
return GL_FALSE;
}
@@ -2077,30 +2077,30 @@ static void insert_wpos(struct gl_program *prog)
/* - Init structures
* - Determine what hwregs each input corresponds to
*/
-static void init_program(r300ContextPtr r300, struct r300_fragment_program *rp)
+static void init_program(r300ContextPtr r300, struct r300_fragment_program *fp)
{
struct r300_pfs_compile_state *cs = NULL;
- struct gl_fragment_program *mp = &rp->mesa_program;
+ struct gl_fragment_program *mp = &fp->mesa_program;
struct prog_instruction *fpi;
GLuint InputsRead = mp->Base.InputsRead;
- GLuint temps_used = 0; /* for rp->temps[] */
+ GLuint temps_used = 0; /* for fp->temps[] */
int i, j;
/* New compile, reset tracking data */
- rp->optimization =
+ fp->optimization =
driQueryOptioni(&r300->radeon.optionCache, "fp_optimization");
- rp->translated = GL_FALSE;
- rp->error = GL_FALSE;
- rp->cs = cs = &(R300_CONTEXT(rp->ctx)->state.pfs_compile);
- rp->tex.length = 0;
- rp->cur_node = 0;
- rp->first_node_has_tex = 0;
- rp->const_nr = 0;
- rp->max_temp_idx = 0;
- rp->node[0].alu_end = -1;
- rp->node[0].tex_end = -1;
+ fp->translated = GL_FALSE;
+ fp->error = GL_FALSE;
+ fp->cs = cs = &(R300_CONTEXT(fp->ctx)->state.pfs_compile);
+ fp->tex.length = 0;
+ fp->cur_node = 0;
+ fp->first_node_has_tex = 0;
+ fp->const_nr = 0;
+ fp->max_temp_idx = 0;
+ fp->node[0].alu_end = -1;
+ fp->node[0].tex_end = -1;
- _mesa_memset(cs, 0, sizeof(*rp->cs));
+ _mesa_memset(cs, 0, sizeof(*fp->cs));
for (i = 0; i < PFS_MAX_ALU_INST; i++) {
for (j = 0; j < 3; j++) {
cs->slot[i].vsrc[j] = SRC_CONST;
@@ -2117,11 +2117,11 @@ static void init_program(r300ContextPtr r300, struct r300_fragment_program *rp)
*/
/* Texcoords come first */
- for (i = 0; i < rp->ctx->Const.MaxTextureUnits; i++) {
+ for (i = 0; i < fp->ctx->Const.MaxTextureUnits; i++) {
if (InputsRead & (FRAG_BIT_TEX0 << i)) {
cs->inputs[FRAG_ATTRIB_TEX0 + i].refcount = 0;
cs->inputs[FRAG_ATTRIB_TEX0 + i].reg =
- get_hw_temp(rp, 0);
+ get_hw_temp(fp, 0);
}
}
InputsRead &= ~FRAG_BITS_TEX_ANY;
@@ -2129,7 +2129,7 @@ static void init_program(r300ContextPtr r300, struct r300_fragment_program *rp)
/* fragment position treated as a texcoord */
if (InputsRead & FRAG_BIT_WPOS) {
cs->inputs[FRAG_ATTRIB_WPOS].refcount = 0;
- cs->inputs[FRAG_ATTRIB_WPOS].reg = get_hw_temp(rp, 0);
+ cs->inputs[FRAG_ATTRIB_WPOS].reg = get_hw_temp(fp, 0);
insert_wpos(&mp->Base);
}
InputsRead &= ~FRAG_BIT_WPOS;
@@ -2137,14 +2137,14 @@ static void init_program(r300ContextPtr r300, struct r300_fragment_program *rp)
/* Then primary colour */
if (InputsRead & FRAG_BIT_COL0) {
cs->inputs[FRAG_ATTRIB_COL0].refcount = 0;
- cs->inputs[FRAG_ATTRIB_COL0].reg = get_hw_temp(rp, 0);
+ cs->inputs[FRAG_ATTRIB_COL0].reg = get_hw_temp(fp, 0);
}
InputsRead &= ~FRAG_BIT_COL0;
/* Secondary color */
if (InputsRead & FRAG_BIT_COL1) {
cs->inputs[FRAG_ATTRIB_COL1].refcount = 0;
- cs->inputs[FRAG_ATTRIB_COL1].reg = get_hw_temp(rp, 0);
+ cs->inputs[FRAG_ATTRIB_COL1].reg = get_hw_temp(fp, 0);
}
InputsRead &= ~FRAG_BIT_COL1;
@@ -2200,53 +2200,53 @@ static void init_program(r300ContextPtr r300, struct r300_fragment_program *rp)
cs->temp_in_use = temps_used;
}
-static void update_params(struct r300_fragment_program *rp)
+static void update_params(struct r300_fragment_program *fp)
{
- struct gl_fragment_program *mp = &rp->mesa_program;
+ struct gl_fragment_program *mp = &fp->mesa_program;
/* Ask Mesa nicely to fill in ParameterValues for us */
if (mp->Base.Parameters)
- _mesa_load_state_parameters(rp->ctx, mp->Base.Parameters);
+ _mesa_load_state_parameters(fp->ctx, mp->Base.Parameters);
}
void r300TranslateFragmentShader(r300ContextPtr r300,
- struct r300_fragment_program *rp)
+ struct r300_fragment_program *fp)
{
struct r300_pfs_compile_state *cs = NULL;
- if (!rp->translated) {
+ if (!fp->translated) {
- init_program(r300, rp);
- cs = rp->cs;
+ init_program(r300, fp);
+ cs = fp->cs;
- if (parse_program(rp) == GL_FALSE) {
- dump_program(rp);
+ if (parse_program(fp) == GL_FALSE) {
+ dump_program(fp);
return;
}
/* Finish off */
- rp->node[rp->cur_node].alu_end =
- cs->nrslots - rp->node[rp->cur_node].alu_offset - 1;
- if (rp->node[rp->cur_node].tex_end < 0)
- rp->node[rp->cur_node].tex_end = 0;
- rp->alu_offset = 0;
- rp->alu_end = cs->nrslots - 1;
- rp->tex_offset = 0;
- rp->tex_end = rp->tex.length ? rp->tex.length - 1 : 0;
- assert(rp->node[rp->cur_node].alu_end >= 0);
- assert(rp->alu_end >= 0);
+ fp->node[fp->cur_node].alu_end =
+ cs->nrslots - fp->node[fp->cur_node].alu_offset - 1;
+ if (fp->node[fp->cur_node].tex_end < 0)
+ fp->node[fp->cur_node].tex_end = 0;
+ fp->alu_offset = 0;
+ fp->alu_end = cs->nrslots - 1;
+ fp->tex_offset = 0;
+ fp->tex_end = fp->tex.length ? fp->tex.length - 1 : 0;
+ assert(fp->node[fp->cur_node].alu_end >= 0);
+ assert(fp->alu_end >= 0);
- rp->translated = GL_TRUE;
+ fp->translated = GL_TRUE;
if (RADEON_DEBUG & DEBUG_PIXEL)
- dump_program(rp);
- r300UpdateStateParameters(rp->ctx, _NEW_PROGRAM);
+ dump_program(fp);
+ r300UpdateStateParameters(fp->ctx, _NEW_PROGRAM);
}
- update_params(rp);
+ update_params(fp);
}
/* just some random things... */
-static void dump_program(struct r300_fragment_program *rp)
+static void dump_program(struct r300_fragment_program *fp)
{
int n, i, j;
static int pc = 0;
@@ -2255,27 +2255,27 @@ static void dump_program(struct r300_fragment_program *rp)
fprintf(stderr, "Mesa program:\n");
fprintf(stderr, "-------------\n");
- _mesa_print_program(&rp->mesa_program.Base);
+ _mesa_print_program(&fp->mesa_program.Base);
fflush(stdout);
fprintf(stderr, "Hardware program\n");
fprintf(stderr, "----------------\n");
- for (n = 0; n < (rp->cur_node + 1); n++) {
+ for (n = 0; n < (fp->cur_node + 1); n++) {
fprintf(stderr, "NODE %d: alu_offset: %d, tex_offset: %d, "
"alu_end: %d, tex_end: %d\n", n,
- rp->node[n].alu_offset,
- rp->node[n].tex_offset,
- rp->node[n].alu_end, rp->node[n].tex_end);
+ fp->node[n].alu_offset,
+ fp->node[n].tex_offset,
+ fp->node[n].alu_end, fp->node[n].tex_end);
- if (rp->tex.length) {
+ if (fp->tex.length) {
fprintf(stderr, " TEX:\n");
- for (i = rp->node[n].tex_offset;
- i <= rp->node[n].tex_offset + rp->node[n].tex_end;
+ for (i = fp->node[n].tex_offset;
+ i <= fp->node[n].tex_offset + fp->node[n].tex_end;
++i) {
const char *instr;
- switch ((rp->tex.
+ switch ((fp->tex.
inst[i] >> R300_FPITX_OPCODE_SHIFT) &
15) {
case R300_FPITX_OP_TEX:
@@ -2297,22 +2297,22 @@ static void dump_program(struct r300_fragment_program *rp)
fprintf(stderr,
" %s t%i, %c%i, texture[%i] (%08x)\n",
instr,
- (rp->tex.
+ (fp->tex.
inst[i] >> R300_FPITX_DST_SHIFT) & 31,
- (rp->tex.
+ (fp->tex.
inst[i] & R300_FPITX_SRC_CONST) ? 'c' :
't',
- (rp->tex.
+ (fp->tex.
inst[i] >> R300_FPITX_SRC_SHIFT) & 31,
- (rp->tex.
+ (fp->tex.
inst[i] & R300_FPITX_IMAGE_MASK) >>
R300_FPITX_IMAGE_SHIFT,
- rp->tex.inst[i]);
+ fp->tex.inst[i]);
}
}
- for (i = rp->node[n].alu_offset;
- i <= rp->node[n].alu_offset + rp->node[n].alu_end; ++i) {
+ for (i = fp->node[n].alu_offset;
+ i <= fp->node[n].alu_offset + fp->node[n].alu_end; ++i) {
char srcc[3][10], dstc[20];
char srca[3][10], dsta[20];
char argc[3][20];
@@ -2320,8 +2320,8 @@ static void dump_program(struct r300_fragment_program *rp)
char flags[5], tmp[10];
for (j = 0; j < 3; ++j) {
- int regc = rp->alu.inst[i].inst1 >> (j * 6);
- int rega = rp->alu.inst[i].inst3 >> (j * 6);
+ int regc = fp->alu.inst[i].inst1 >> (j * 6);
+ int rega = fp->alu.inst[i].inst3 >> (j * 6);
sprintf(srcc[j], "%c%i",
(regc & 32) ? 'c' : 't', regc & 31);
@@ -2331,46 +2331,46 @@ static void dump_program(struct r300_fragment_program *rp)
dstc[0] = 0;
sprintf(flags, "%s%s%s",
- (rp->alu.inst[i].
+ (fp->alu.inst[i].
inst1 & R300_FPI1_DSTC_REG_X) ? "x" : "",
- (rp->alu.inst[i].
+ (fp->alu.inst[i].
inst1 & R300_FPI1_DSTC_REG_Y) ? "y" : "",
- (rp->alu.inst[i].
+ (fp->alu.inst[i].
inst1 & R300_FPI1_DSTC_REG_Z) ? "z" : "");
if (flags[0] != 0) {
sprintf(dstc, "t%i.%s ",
- (rp->alu.inst[i].
+ (fp->alu.inst[i].
inst1 >> R300_FPI1_DSTC_SHIFT) & 31,
flags);
}
sprintf(flags, "%s%s%s",
- (rp->alu.inst[i].
+ (fp->alu.inst[i].
inst1 & R300_FPI1_DSTC_OUTPUT_X) ? "x" : "",
- (rp->alu.inst[i].
+ (fp->alu.inst[i].
inst1 & R300_FPI1_DSTC_OUTPUT_Y) ? "y" : "",
- (rp->alu.inst[i].
+ (fp->alu.inst[i].
inst1 & R300_FPI1_DSTC_OUTPUT_Z) ? "z" : "");
if (flags[0] != 0) {
sprintf(tmp, "o%i.%s",
- (rp->alu.inst[i].
+ (fp->alu.inst[i].
inst1 >> R300_FPI1_DSTC_SHIFT) & 31,
flags);
strcat(dstc, tmp);
}
dsta[0] = 0;
- if (rp->alu.inst[i].inst3 & R300_FPI3_DSTA_REG) {
+ if (fp->alu.inst[i].inst3 & R300_FPI3_DSTA_REG) {
sprintf(dsta, "t%i.w ",
- (rp->alu.inst[i].
+ (fp->alu.inst[i].
inst3 >> R300_FPI3_DSTA_SHIFT) & 31);
}
- if (rp->alu.inst[i].inst3 & R300_FPI3_DSTA_OUTPUT) {
+ if (fp->alu.inst[i].inst3 & R300_FPI3_DSTA_OUTPUT) {
sprintf(tmp, "o%i.w ",
- (rp->alu.inst[i].
+ (fp->alu.inst[i].
inst3 >> R300_FPI3_DSTA_SHIFT) & 31);
strcat(dsta, tmp);
}
- if (rp->alu.inst[i].inst3 & R300_FPI3_DSTA_DEPTH) {
+ if (fp->alu.inst[i].inst3 & R300_FPI3_DSTA_DEPTH) {
strcat(dsta, "Z");
}
@@ -2378,12 +2378,12 @@ static void dump_program(struct r300_fragment_program *rp)
"%3i: xyz: %3s %3s %3s -> %-20s (%08x)\n"
" w: %3s %3s %3s -> %-20s (%08x)\n", i,
srcc[0], srcc[1], srcc[2], dstc,
- rp->alu.inst[i].inst1, srca[0], srca[1],
- srca[2], dsta, rp->alu.inst[i].inst3);
+ fp->alu.inst[i].inst1, srca[0], srca[1],
+ srca[2], dsta, fp->alu.inst[i].inst3);
for (j = 0; j < 3; ++j) {
- int regc = rp->alu.inst[i].inst0 >> (j * 7);
- int rega = rp->alu.inst[i].inst2 >> (j * 7);
+ int regc = fp->alu.inst[i].inst0 >> (j * 7);
+ int rega = fp->alu.inst[i].inst2 >> (j * 7);
int d;
char buf[20];
@@ -2465,8 +2465,8 @@ static void dump_program(struct r300_fragment_program *rp)
fprintf(stderr, " xyz: %8s %8s %8s op: %08x\n"
" w: %8s %8s %8s op: %08x\n",
argc[0], argc[1], argc[2],
- rp->alu.inst[i].inst0, arga[0], arga[1],
- arga[2], rp->alu.inst[i].inst2);
+ fp->alu.inst[i].inst0, arga[0], arga[1],
+ arga[2], fp->alu.inst[i].inst2);
}
}
}
diff --git a/src/mesa/drivers/dri/r300/r300_fragprog.h b/src/mesa/drivers/dri/r300/r300_fragprog.h
index b92312aef0..72fca77845 100644
--- a/src/mesa/drivers/dri/r300/r300_fragprog.h
+++ b/src/mesa/drivers/dri/r300/r300_fragprog.h
@@ -99,6 +99,6 @@ typedef struct r300_fragment_program_swizzle {
struct r300_fragment_program;
extern void r300TranslateFragmentShader(r300ContextPtr r300,
- struct r300_fragment_program *rp);
+ struct r300_fragment_program *fp);
#endif
diff --git a/src/mesa/drivers/dri/r300/r300_state.c b/src/mesa/drivers/dri/r300/r300_state.c
index 3b595d98fa..5689b4ac59 100644
--- a/src/mesa/drivers/dri/r300/r300_state.c
+++ b/src/mesa/drivers/dri/r300/r300_state.c
@@ -1287,7 +1287,7 @@ static void r300SetupTextures(GLcontext * ctx)
int hw_tmu = 0;
int last_hw_tmu = -1; /* -1 translates into no setup costs for fields */
int tmu_mappings[R300_MAX_TEXTURE_UNITS] = { -1, };
- struct r300_fragment_program *rp = (struct r300_fragment_program *)
+ struct r300_fragment_program *fp = (struct r300_fragment_program *)
(char *)ctx->FragmentProgram._Current;
R300_STATECHANGE(r300, txe);
@@ -1390,20 +1390,20 @@ static void r300SetupTextures(GLcontext * ctx)
r300->hw.tex.border_color.cmd[R300_TEX_CMD_0] =
cmdpacket0(R300_TX_BORDER_COLOR_0, last_hw_tmu + 1);
- if (!rp) /* should only happenen once, just after context is created */
+ if (!fp) /* should only happenen once, just after context is created */
return;
R300_STATECHANGE(r300, fpt);
- for (i = 0; i < rp->tex.length; i++) {
+ for (i = 0; i < fp->tex.length; i++) {
int unit;
int opcode;
unsigned long val;
- unit = rp->tex.inst[i] >> R300_FPITX_IMAGE_SHIFT;
+ unit = fp->tex.inst[i] >> R300_FPITX_IMAGE_SHIFT;
unit &= 15;
- val = rp->tex.inst[i];
+ val = fp->tex.inst[i];
val &= ~R300_FPITX_IMAGE_MASK;
opcode =
@@ -1425,7 +1425,7 @@ static void r300SetupTextures(GLcontext * ctx)
}
r300->hw.fpt.cmd[R300_FPT_CMD_0] =
- cmdpacket0(R300_PFS_TEXI_0, rp->tex.length);
+ cmdpacket0(R300_PFS_TEXI_0, fp->tex.length);
if (RADEON_DEBUG & DEBUG_STATE)
fprintf(stderr, "TX_ENABLE: %08x last_hw_tmu=%d\n",
@@ -1909,24 +1909,24 @@ static unsigned int r300PackFloat24(float f)
void r300SetupPixelShader(r300ContextPtr rmesa)
{
GLcontext *ctx = rmesa->radeon.glCtx;
- struct r300_fragment_program *rp = (struct r300_fragment_program *)
+ struct r300_fragment_program *fp = (struct r300_fragment_program *)
(char *)ctx->FragmentProgram._Current;
int i, k;
- if (!rp) /* should only happenen once, just after context is created */
+ if (!fp) /* should only happenen once, just after context is created */
return;
- r300TranslateFragmentShader(rmesa, rp);
- if (!rp->translated) {
+ r300TranslateFragmentShader(rmesa, fp);
+ if (!fp->translated) {
fprintf(stderr, "%s: No valid fragment shader, exiting\n",
__func__);
return;
}
#define OUTPUT_FIELD(st, reg, field) \
R300_STATECHANGE(rmesa, st); \
- for(i=0;i<=rp->alu_end;i++) \
- rmesa->hw.st.cmd[R300_FPI_INSTR_0+i]=rp->alu.inst[i].field;\
- rmesa->hw.st.cmd[R300_FPI_CMD_0]=cmdpacket0(reg, rp->alu_end+1);
+ for(i=0;i<=fp->alu_end;i++) \
+ rmesa->hw.st.cmd[R300_FPI_INSTR_0+i]=fp->alu.inst[i].field;\
+ rmesa->hw.st.cmd[R300_FPI_CMD_0]=cmdpacket0(reg, fp->alu_end+1);
OUTPUT_FIELD(fpi[0], R300_PFS_INSTR0_0, inst0);
OUTPUT_FIELD(fpi[1], R300_PFS_INSTR1_0, inst1);
@@ -1936,18 +1936,18 @@ void r300SetupPixelShader(r300ContextPtr rmesa)
R300_STATECHANGE(rmesa, fp);
/* I just want to say, the way these nodes are stored.. weird.. */
- for (i = 0, k = (4 - (rp->cur_node + 1)); i < 4; i++, k++) {
- if (i < (rp->cur_node + 1)) {
+ for (i = 0, k = (4 - (fp->cur_node + 1)); i < 4; i++, k++) {
+ if (i < (fp->cur_node + 1)) {
rmesa->hw.fp.cmd[R300_FP_NODE0 + k] =
- (rp->node[i].
+ (fp->node[i].
alu_offset << R300_PFS_NODE_ALU_OFFSET_SHIFT)
- | (rp->node[i].
+ | (fp->node[i].
alu_end << R300_PFS_NODE_ALU_END_SHIFT)
- | (rp->node[i].
+ | (fp->node[i].
tex_offset << R300_PFS_NODE_TEX_OFFSET_SHIFT)
- | (rp->node[i].
+ | (fp->node[i].
tex_end << R300_PFS_NODE_TEX_END_SHIFT)
- | rp->node[i].flags; /* ( (k==3) ? R300_PFS_NODE_LAST_NODE : 0); */
+ | fp->node[i].flags; /* ( (k==3) ? R300_PFS_NODE_LAST_NODE : 0); */
} else {
rmesa->hw.fp.cmd[R300_FP_NODE0 + (3 - i)] = 0;
}
@@ -1955,29 +1955,29 @@ void r300SetupPixelShader(r300ContextPtr rmesa)
/* PFS_CNTL_0 */
rmesa->hw.fp.cmd[R300_FP_CNTL0] =
- rp->cur_node | (rp->first_node_has_tex << 3);
+ fp->cur_node | (fp->first_node_has_tex << 3);
/* PFS_CNTL_1 */
- rmesa->hw.fp.cmd[R300_FP_CNTL1] = rp->max_temp_idx;
+ rmesa->hw.fp.cmd[R300_FP_CNTL1] = fp->max_temp_idx;
/* PFS_CNTL_2 */
rmesa->hw.fp.cmd[R300_FP_CNTL2] =
- (rp->alu_offset << R300_PFS_CNTL_ALU_OFFSET_SHIFT)
- | (rp->alu_end << R300_PFS_CNTL_ALU_END_SHIFT)
- | (rp->tex_offset << R300_PFS_CNTL_TEX_OFFSET_SHIFT)
- | (rp->tex_end << R300_PFS_CNTL_TEX_END_SHIFT);
+ (fp->alu_offset << R300_PFS_CNTL_ALU_OFFSET_SHIFT)
+ | (fp->alu_end << R300_PFS_CNTL_ALU_END_SHIFT)
+ | (fp->tex_offset << R300_PFS_CNTL_TEX_OFFSET_SHIFT)
+ | (fp->tex_end << R300_PFS_CNTL_TEX_END_SHIFT);
R300_STATECHANGE(rmesa, fpp);
- for (i = 0; i < rp->const_nr; i++) {
+ for (i = 0; i < fp->const_nr; i++) {
rmesa->hw.fpp.cmd[R300_FPP_PARAM_0 + 4 * i + 0] =
- r300PackFloat24(rp->constant[i][0]);
+ r300PackFloat24(fp->constant[i][0]);
rmesa->hw.fpp.cmd[R300_FPP_PARAM_0 + 4 * i + 1] =
- r300PackFloat24(rp->constant[i][1]);
+ r300PackFloat24(fp->constant[i][1]);
rmesa->hw.fpp.cmd[R300_FPP_PARAM_0 + 4 * i + 2] =
- r300PackFloat24(rp->constant[i][2]);
+ r300PackFloat24(fp->constant[i][2]);
rmesa->hw.fpp.cmd[R300_FPP_PARAM_0 + 4 * i + 3] =
- r300PackFloat24(rp->constant[i][3]);
+ r300PackFloat24(fp->constant[i][3]);
}
rmesa->hw.fpp.cmd[R300_FPP_CMD_0] =
- cmdpacket0(R300_PFS_PARAM_0_X, rp->const_nr * 4);
+ cmdpacket0(R300_PFS_PARAM_0_X, fp->const_nr * 4);
}
/**
generated by cgit v1.2.3 (git 2.51.0) at 2025-10-31 00:36:25 +0000