2 * Mesa 3-D graphics library
5 * Copyright (C) 1999-2007 Brian Paul All Rights Reserved.
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
14 * The above copyright notice and this permission notice shall be included
15 * in all copies or substantial portions of the Software.
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
21 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
22 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 #include "main/glheader.h"
26 #include "main/colormac.h"
27 #include "main/context.h"
28 #include "shader/prog_instruction.h"
30 #include "s_fragprog.h"
35 * Apply texture object's swizzle (X/Y/Z/W/0/1) to incoming 'texel'
36 * and return results in 'colorOut'.
39 swizzle_texel(const GLfloat texel
[4], GLfloat colorOut
[4], GLuint swizzle
)
41 if (swizzle
== SWIZZLE_NOOP
) {
42 COPY_4V(colorOut
, texel
);
46 vector
[SWIZZLE_X
] = texel
[0];
47 vector
[SWIZZLE_Y
] = texel
[1];
48 vector
[SWIZZLE_Z
] = texel
[2];
49 vector
[SWIZZLE_W
] = texel
[3];
50 vector
[SWIZZLE_ZERO
] = 0.0F
;
51 vector
[SWIZZLE_ONE
] = 1.0F
;
52 colorOut
[0] = vector
[GET_SWZ(swizzle
, 0)];
53 colorOut
[1] = vector
[GET_SWZ(swizzle
, 1)];
54 colorOut
[2] = vector
[GET_SWZ(swizzle
, 2)];
55 colorOut
[3] = vector
[GET_SWZ(swizzle
, 3)];
61 * Fetch a texel with given lod.
62 * Called via machine->FetchTexelLod()
65 fetch_texel_lod( GLcontext
*ctx
, const GLfloat texcoord
[4], GLfloat lambda
,
66 GLuint unit
, GLfloat color
[4] )
68 const struct gl_texture_object
*texObj
= ctx
->Texture
.Unit
[unit
]._Current
;
71 SWcontext
*swrast
= SWRAST_CONTEXT(ctx
);
74 lambda
= CLAMP(lambda
, texObj
->MinLod
, texObj
->MaxLod
);
76 swrast
->TextureSample
[unit
](ctx
, texObj
, 1,
77 (const GLfloat (*)[4]) texcoord
,
79 swizzle_texel(rgba
, color
, texObj
->_Swizzle
);
82 ASSIGN_4V(color
, 0.0F
, 0.0F
, 0.0F
, 1.0F
);
88 * Fetch a texel with the given partial derivatives to compute a level
89 * of detail in the mipmap.
90 * Called via machine->FetchTexelDeriv()
91 * \param lodBias the lod bias which may be specified by a TXB instruction,
95 fetch_texel_deriv( GLcontext
*ctx
, const GLfloat texcoord
[4],
96 const GLfloat texdx
[4], const GLfloat texdy
[4],
97 GLfloat lodBias
, GLuint unit
, GLfloat color
[4] )
99 SWcontext
*swrast
= SWRAST_CONTEXT(ctx
);
100 const struct gl_texture_unit
*texUnit
= &ctx
->Texture
.Unit
[unit
];
101 const struct gl_texture_object
*texObj
= texUnit
->_Current
;
104 const struct gl_texture_image
*texImg
=
105 texObj
->Image
[0][texObj
->BaseLevel
];
106 const GLfloat texW
= (GLfloat
) texImg
->WidthScale
;
107 const GLfloat texH
= (GLfloat
) texImg
->HeightScale
;
111 lambda
= _swrast_compute_lambda(texdx
[0], texdy
[0], /* ds/dx, ds/dy */
112 texdx
[1], texdy
[1], /* dt/dx, dt/dy */
113 texdx
[3], texdy
[3], /* dq/dx, dq/dy */
115 texcoord
[0], texcoord
[1], texcoord
[3],
118 lambda
+= lodBias
+ texUnit
->LodBias
+ texObj
->LodBias
;
120 lambda
= CLAMP(lambda
, texObj
->MinLod
, texObj
->MaxLod
);
122 swrast
->TextureSample
[unit
](ctx
, texObj
, 1,
123 (const GLfloat (*)[4]) texcoord
,
125 swizzle_texel(rgba
, color
, texObj
->_Swizzle
);
128 ASSIGN_4V(color
, 0.0F
, 0.0F
, 0.0F
, 1.0F
);
134 * Initialize the virtual fragment program machine state prior to running
135 * fragment program on a fragment. This involves initializing the input
136 * registers, condition codes, etc.
137 * \param machine the virtual machine state to init
138 * \param program the fragment program we're about to run
139 * \param span the span of pixels we'll operate on
140 * \param col which element (column) of the span we'll operate on
143 init_machine(GLcontext
*ctx
, struct gl_program_machine
*machine
,
144 const struct gl_fragment_program
*program
,
145 const SWspan
*span
, GLuint col
)
147 GLfloat
*wpos
= span
->array
->attribs
[FRAG_ATTRIB_WPOS
][col
];
149 if (program
->Base
.Target
== GL_FRAGMENT_PROGRAM_NV
) {
150 /* Clear temporary registers (undefined for ARB_f_p) */
151 _mesa_bzero(machine
->Temporaries
,
152 MAX_PROGRAM_TEMPS
* 4 * sizeof(GLfloat
));
155 /* ARB_fragment_coord_conventions */
156 if (program
->OriginUpperLeft
)
157 wpos
[1] = ctx
->DrawBuffer
->Height
- 1 - wpos
[1];
158 if (!program
->PixelCenterInteger
) {
163 /* Setup pointer to input attributes */
164 machine
->Attribs
= span
->array
->attribs
;
166 machine
->DerivX
= (GLfloat (*)[4]) span
->attrStepX
;
167 machine
->DerivY
= (GLfloat (*)[4]) span
->attrStepY
;
168 machine
->NumDeriv
= FRAG_ATTRIB_MAX
;
170 machine
->Samplers
= program
->Base
.SamplerUnits
;
172 /* if running a GLSL program (not ARB_fragment_program) */
173 if (ctx
->Shader
.CurrentProgram
) {
174 /* Store front/back facing value */
175 machine
->Attribs
[FRAG_ATTRIB_FACE
][col
][0] = 1.0F
- span
->facing
;
178 machine
->CurElement
= col
;
180 /* init condition codes */
181 machine
->CondCodes
[0] = COND_EQ
;
182 machine
->CondCodes
[1] = COND_EQ
;
183 machine
->CondCodes
[2] = COND_EQ
;
184 machine
->CondCodes
[3] = COND_EQ
;
186 /* init call stack */
187 machine
->StackDepth
= 0;
189 machine
->FetchTexelLod
= fetch_texel_lod
;
190 machine
->FetchTexelDeriv
= fetch_texel_deriv
;
195 * Run fragment program on the pixels in span from 'start' to 'end' - 1.
198 run_program(GLcontext
*ctx
, SWspan
*span
, GLuint start
, GLuint end
)
200 SWcontext
*swrast
= SWRAST_CONTEXT(ctx
);
201 const struct gl_fragment_program
*program
= ctx
->FragmentProgram
._Current
;
202 const GLbitfield64 outputsWritten
= program
->Base
.OutputsWritten
;
203 struct gl_program_machine
*machine
= &swrast
->FragProgMachine
;
206 for (i
= start
; i
< end
; i
++) {
207 if (span
->array
->mask
[i
]) {
208 init_machine(ctx
, machine
, program
, span
, i
);
210 if (_mesa_execute_program(ctx
, &program
->Base
, machine
)) {
212 /* Store result color */
213 if (outputsWritten
& BITFIELD64_BIT(FRAG_RESULT_COLOR
)) {
214 COPY_4V(span
->array
->attribs
[FRAG_ATTRIB_COL0
][i
],
215 machine
->Outputs
[FRAG_RESULT_COLOR
]);
218 /* Multiple drawbuffers / render targets
219 * Note that colors beyond 0 and 1 will overwrite other
220 * attributes, such as FOGC, TEX0, TEX1, etc. That's OK.
223 for (buf
= 0; buf
< ctx
->DrawBuffer
->_NumColorDrawBuffers
; buf
++) {
224 if (outputsWritten
& BITFIELD64_BIT(FRAG_RESULT_DATA0
+ buf
)) {
225 COPY_4V(span
->array
->attribs
[FRAG_ATTRIB_COL0
+ buf
][i
],
226 machine
->Outputs
[FRAG_RESULT_DATA0
+ buf
]);
231 /* Store result depth/z */
232 if (outputsWritten
& BITFIELD64_BIT(FRAG_RESULT_DEPTH
)) {
233 const GLfloat depth
= machine
->Outputs
[FRAG_RESULT_DEPTH
][2];
235 span
->array
->z
[i
] = 0;
236 else if (depth
>= 1.0)
237 span
->array
->z
[i
] = ctx
->DrawBuffer
->_DepthMax
;
239 span
->array
->z
[i
] = IROUND(depth
* ctx
->DrawBuffer
->_DepthMaxF
);
243 /* killed fragment */
244 span
->array
->mask
[i
] = GL_FALSE
;
245 span
->writeAll
= GL_FALSE
;
253 * Execute the current fragment program for all the fragments
257 _swrast_exec_fragment_program( GLcontext
*ctx
, SWspan
*span
)
259 const struct gl_fragment_program
*program
= ctx
->FragmentProgram
._Current
;
261 /* incoming colors should be floats */
262 if (program
->Base
.InputsRead
& FRAG_BIT_COL0
) {
263 ASSERT(span
->array
->ChanType
== GL_FLOAT
);
266 run_program(ctx
, span
, 0, span
->end
);
268 if (program
->Base
.OutputsWritten
& BITFIELD64_BIT(FRAG_RESULT_COLOR
)) {
269 span
->interpMask
&= ~SPAN_RGBA
;
270 span
->arrayMask
|= SPAN_RGBA
;
273 if (program
->Base
.OutputsWritten
& BITFIELD64_BIT(FRAG_RESULT_DEPTH
)) {
274 span
->interpMask
&= ~SPAN_Z
;
275 span
->arrayMask
|= SPAN_Z
;