2 Copyright (C) Intel Corp. 2006. All Rights Reserved.
3 Intel funded Tungsten Graphics (http://www.tungstengraphics.com) to
4 develop this 3D driver.
6 Permission is hereby granted, free of charge, to any person obtaining
7 a copy of this software and associated documentation files (the
8 "Software"), to deal in the Software without restriction, including
9 without limitation the rights to use, copy, modify, merge, publish,
10 distribute, sublicense, and/or sell copies of the Software, and to
11 permit persons to whom the Software is furnished to do so, subject to
12 the following conditions:
14 The above copyright notice and this permission notice (including the
15 next paragraph) shall be included in all copies or substantial
16 portions of the Software.
18 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
19 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
21 IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
22 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
23 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
24 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
26 **********************************************************************/
29 * Keith Whitwell <keith@tungstengraphics.com>
33 #include "brw_context.h"
35 #include "program_instruction.h"
39 /* Component is active if it may diverge from [0,0,0,1]. Undef values
40 * are promoted to [0,0,0,1] for the purposes of this analysis.
44 GLubyte active
[PROGRAM_OUTPUT
+1][128];
49 static void set_active_component( struct tracker
*t
,
55 case PROGRAM_TEMPORARY
:
58 t
->active
[file
][index
] |= active
;
65 static void set_active( struct tracker
*t
,
66 struct prog_dst_register dst
,
69 set_active_component( t
, dst
.File
, dst
.Index
, active
& dst
.WriteMask
);
73 static GLubyte
get_active_component( struct tracker
*t
,
81 return component
< 3 ? 0 : (1<<component
);
83 return component
== 3 ? 0 : (1<<component
);
86 case PROGRAM_TEMPORARY
:
89 return t
->active
[file
][index
] & (1<<component
);
91 return 1 << component
;
97 static GLubyte
get_active( struct tracker
*t
,
98 struct prog_src_register src
)
101 GLubyte active
= src
.NegateBase
; /* NOTE! */
106 for (i
= 0; i
< 4; i
++)
107 active
|= get_active_component(t
, src
.File
, src
.Index
, i
,
108 GET_SWZ(src
.Swizzle
, i
));
113 static GLubyte
get_output_size( struct tracker
*t
,
116 GLubyte active
= t
->active
[PROGRAM_OUTPUT
][idx
];
117 if (active
& (1<<3)) return 4;
118 if (active
& (1<<2)) return 3;
119 if (active
& (1<<1)) return 2;
120 if (active
& (1<<0)) return 1;
124 /* Note the potential copying that occurs in the setup program:
126 static void calc_sizes( struct tracker
*t
)
131 t
->active
[PROGRAM_OUTPUT
][VERT_RESULT_COL0
] |=
132 t
->active
[PROGRAM_OUTPUT
][VERT_RESULT_BFC0
];
134 t
->active
[PROGRAM_OUTPUT
][VERT_RESULT_COL1
] |=
135 t
->active
[PROGRAM_OUTPUT
][VERT_RESULT_BFC1
];
138 for (i
= 0; i
< FRAG_ATTRIB_MAX
; i
++) {
139 switch (get_output_size(t
, i
)) {
140 case 4: t
->size_masks
[4-1] |= 1<<i
;
141 case 3: t
->size_masks
[3-1] |= 1<<i
;
142 case 2: t
->size_masks
[2-1] |= 1<<i
;
143 case 1: t
->size_masks
[1-1] |= 1<<i
;
149 static GLubyte szflag
[4+1] = {
157 /* Pull a size out of the packed array:
159 static GLuint
get_input_size(struct brw_context
*brw
,
162 GLuint sizes_dword
= brw
->vb
.info
.sizes
[attr
/16];
163 GLuint sizes_bits
= (sizes_dword
>>((attr
%16)*2)) & 0x3;
164 return sizes_bits
+ 1;
165 /* return brw->vb.inputs[attr].glarray->Size; */
168 /* Calculate sizes of vertex program outputs. Size is the largest
169 * component index which might vary from [0,0,0,1]
171 static void calc_wm_input_sizes( struct brw_context
*brw
)
173 /* BRW_NEW_VERTEX_PROGRAM */
174 struct brw_vertex_program
*vp
=
175 (struct brw_vertex_program
*)brw
->vertex_program
;
176 /* BRW_NEW_INPUT_DIMENSIONS */
181 memset(&t
, 0, sizeof(t
));
184 if (brw
->attribs
.Light
->Model
.TwoSide
)
187 for (i
= 0; i
< VERT_ATTRIB_MAX
; i
++)
188 if (vp
->program
.Base
.InputsRead
& (1<<i
))
189 set_active_component(&t
, PROGRAM_INPUT
, i
,
190 szflag
[get_input_size(brw
, i
)]);
192 for (insn
= 0; insn
< vp
->program
.Base
.NumInstructions
; insn
++) {
193 struct prog_instruction
*inst
= &vp
->program
.Base
.Instructions
[insn
];
195 switch (inst
->Opcode
) {
200 set_active(&t
, inst
->DstReg
, get_active(&t
, inst
->SrcReg
[0]));
204 set_active(&t
, inst
->DstReg
, 0xf);
211 if (memcmp(brw
->wm
.input_size_masks
, t
.size_masks
, sizeof(t
.size_masks
)) != 0) {
212 memcpy(brw
->wm
.input_size_masks
, t
.size_masks
, sizeof(t
.size_masks
));
213 brw
->state
.dirty
.brw
|= BRW_NEW_WM_INPUT_DIMENSIONS
;
217 const struct brw_tracked_state brw_wm_input_sizes
= {
220 .brw
= BRW_NEW_VERTEX_PROGRAM
| BRW_NEW_INPUT_DIMENSIONS
,
223 .update
= calc_wm_input_sizes