1 /**********************************************************
2 * Copyright 2008-2009 VMware, Inc. All rights reserved.
4 * Permission is hereby granted, free of charge, to any person
5 * obtaining a copy of this software and associated documentation
6 * files (the "Software"), to deal in the Software without
7 * restriction, including without limitation the rights to use, copy,
8 * modify, merge, publish, distribute, sublicense, and/or sell copies
9 * of the Software, and to permit persons to whom the Software is
10 * furnished to do so, subject to the following conditions:
12 * The above copyright notice and this permission notice shall be
13 * included in all copies or substantial portions of the Software.
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
16 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
17 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
18 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
19 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
20 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
21 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
24 **********************************************************/
26 #include "util/u_inlines.h"
27 #include "pipe/p_defines.h"
28 #include "util/u_math.h"
30 #include "svga_context.h"
31 #include "svga_state.h"
33 #include "svga_debug.h"
36 /***********************************************************************
37 * Hardware state update
41 static int emit_framebuffer( struct svga_context *svga,
44 const struct pipe_framebuffer_state *curr = &svga->curr.framebuffer;
45 struct pipe_framebuffer_state *hw = &svga->state.hw_clear.framebuffer;
46 boolean reemit = svga->rebind.rendertargets;
51 * We need to reemit non-null surface bindings, even when they are not
52 * dirty, to ensure that the resources are paged in.
55 for(i = 0; i < PIPE_MAX_COLOR_BUFS; ++i) {
56 if (curr->cbufs[i] != hw->cbufs[i] ||
57 (reemit && hw->cbufs[i])) {
58 if (svga->curr.nr_fbs++ > 8)
59 return PIPE_ERROR_OUT_OF_MEMORY;
61 ret = SVGA3D_SetRenderTarget(svga->swc, SVGA3D_RT_COLOR0 + i, curr->cbufs[i]);
65 pipe_surface_reference(&hw->cbufs[i], curr->cbufs[i]);
70 if (curr->zsbuf != hw->zsbuf ||
71 (reemit && hw->zsbuf)) {
72 ret = SVGA3D_SetRenderTarget(svga->swc, SVGA3D_RT_DEPTH, curr->zsbuf);
77 curr->zsbuf->format == PIPE_FORMAT_S8_USCALED_Z24_UNORM) {
78 ret = SVGA3D_SetRenderTarget(svga->swc, SVGA3D_RT_STENCIL, curr->zsbuf);
83 ret = SVGA3D_SetRenderTarget(svga->swc, SVGA3D_RT_STENCIL, NULL);
88 pipe_surface_reference(&hw->zsbuf, curr->zsbuf);
91 svga->rebind.rendertargets = FALSE;
98 * Rebind rendertargets.
100 * Similar to emit_framebuffer, but without any state checking/update.
102 * Called at the beginning of every new command buffer to ensure that
103 * non-dirty rendertargets are properly paged-in.
106 svga_reemit_framebuffer_bindings(struct svga_context *svga)
108 struct pipe_framebuffer_state *hw = &svga->state.hw_clear.framebuffer;
112 assert(svga->rebind.rendertargets);
114 for (i = 0; i < MIN2(PIPE_MAX_COLOR_BUFS, 8); ++i) {
116 ret = SVGA3D_SetRenderTarget(svga->swc, SVGA3D_RT_COLOR0 + i, hw->cbufs[i]);
117 if (ret != PIPE_OK) {
124 ret = SVGA3D_SetRenderTarget(svga->swc, SVGA3D_RT_DEPTH, hw->zsbuf);
125 if (ret != PIPE_OK) {
130 hw->zsbuf->format == PIPE_FORMAT_S8_USCALED_Z24_UNORM) {
131 ret = SVGA3D_SetRenderTarget(svga->swc, SVGA3D_RT_STENCIL, hw->zsbuf);
132 if (ret != PIPE_OK) {
137 ret = SVGA3D_SetRenderTarget(svga->swc, SVGA3D_RT_STENCIL, NULL);
138 if (ret != PIPE_OK) {
144 svga->rebind.rendertargets = FALSE;
150 struct svga_tracked_state svga_hw_framebuffer =
152 "hw framebuffer state",
153 SVGA_NEW_FRAME_BUFFER,
160 /***********************************************************************
163 static int emit_viewport( struct svga_context *svga,
166 const struct pipe_viewport_state *viewport = &svga->curr.viewport;
167 struct svga_prescale prescale;
169 /* Not sure if this state is relevant with POSITIONT. Probably
170 * not, but setting to 0,1 avoids some state pingponging.
172 float range_min = 0.0;
173 float range_max = 1.0;
175 boolean degenerate = FALSE;
178 float fb_width = svga->curr.framebuffer.width;
179 float fb_height = svga->curr.framebuffer.height;
181 float fx = viewport->scale[0] * -1.0 + viewport->translate[0];
182 float fy = flip * viewport->scale[1] * -1.0 + viewport->translate[1];
183 float fw = viewport->scale[0] * 2;
184 float fh = flip * viewport->scale[1] * 2;
186 memset( &prescale, 0, sizeof(prescale) );
188 /* Examine gallium viewport transformation and produce a screen
189 * rectangle and possibly vertex shader pre-transformation to
190 * get the same results.
193 SVGA_DBG(DEBUG_VIEWPORT,
194 "\ninitial %f,%f %fx%f\n",
200 prescale.scale[0] = 1.0;
201 prescale.scale[1] = 1.0;
202 prescale.scale[2] = 1.0;
203 prescale.scale[3] = 1.0;
204 prescale.translate[0] = 0;
205 prescale.translate[1] = 0;
206 prescale.translate[2] = 0;
207 prescale.translate[3] = 0;
208 prescale.enabled = TRUE;
213 prescale.scale[0] *= -1.0;
214 prescale.translate[0] += -fw;
216 fx = viewport->scale[0] * 1.0 + viewport->translate[0];
220 prescale.scale[1] *= -1.0;
221 prescale.translate[1] += -fh;
223 fy = flip * viewport->scale[1] * 1.0 + viewport->translate[1];
227 prescale.translate[0] += fx;
228 prescale.scale[0] *= fw / (fw + fx);
234 prescale.translate[1] += fy;
235 prescale.scale[1] *= fh / (fh + fy);
240 if (fx + fw > fb_width) {
241 prescale.scale[0] *= fw / (fb_width - fx);
242 prescale.translate[0] -= fx * (fw / (fb_width - fx));
243 prescale.translate[0] += fx;
248 if (fy + fh > fb_height) {
249 prescale.scale[1] *= fh / (fb_height - fy);
250 prescale.translate[1] -= fy * (fh / (fb_height - fy));
251 prescale.translate[1] += fy;
255 if (fw < 0 || fh < 0) {
256 fw = fh = fx = fy = 0;
262 /* D3D viewport is integer space. Convert fx,fy,etc. to
265 * TODO: adjust pretranslate correct for any subpixel error
266 * introduced converting to integers.
273 SVGA_DBG(DEBUG_VIEWPORT,
274 "viewport error %f,%f %fx%f\n",
275 fabs((float)rect.x - fx),
276 fabs((float)rect.y - fy),
277 fabs((float)rect.w - fw),
278 fabs((float)rect.h - fh));
280 SVGA_DBG(DEBUG_VIEWPORT,
281 "viewport %d,%d %dx%d\n",
288 /* Finally, to get GL rasterization rules, need to tweak the
289 * screen-space coordinates slightly relative to D3D which is
290 * what hardware implements natively.
292 if (svga->curr.rast->templ.gl_rasterization_rules) {
293 float adjust_x = 0.0;
294 float adjust_y = 0.0;
296 switch (svga->curr.reduced_prim) {
297 case PIPE_PRIM_LINES:
301 case PIPE_PRIM_POINTS:
302 case PIPE_PRIM_TRIANGLES:
308 prescale.translate[0] += adjust_x;
309 prescale.translate[1] += adjust_y;
310 prescale.translate[2] = 0.5; /* D3D clip space */
311 prescale.scale[2] = 0.5; /* D3D clip space */
315 range_min = viewport->scale[2] * -1.0 + viewport->translate[2];
316 range_max = viewport->scale[2] * 1.0 + viewport->translate[2];
318 /* D3D (and by implication SVGA) doesn't like dealing with zmax
319 * less than zmin. Detect that case, flip the depth range and
320 * invert our z-scale factor to achieve the same effect.
322 if (range_min > range_max) {
324 range_tmp = range_min;
325 range_min = range_max;
326 range_max = range_tmp;
327 prescale.scale[2] = -prescale.scale[2];
330 if (prescale.enabled) {
335 SVGA_DBG(DEBUG_VIEWPORT,
336 "prescale %f,%f %fx%f\n",
337 prescale.translate[0],
338 prescale.translate[1],
342 H[0] = (float)rect.w / 2.0;
343 H[1] = -(float)rect.h / 2.0;
344 J[0] = (float)rect.x + (float)rect.w / 2.0;
345 J[1] = (float)rect.y + (float)rect.h / 2.0;
347 SVGA_DBG(DEBUG_VIEWPORT,
355 /* Adjust prescale to take into account the fact that it is
356 * going to be applied prior to the perspective divide and
357 * viewport transformation.
359 * Vwin = H(Vc/Vc.w) + J
361 * We want to tweak Vwin with scale and translation from above,
366 * But we can only modify the values at Vc. Plugging all the
367 * above together, and rearranging, eventually we get:
369 * Vwin' = H(Vc'/Vc'.w) + J
372 * K = (T + (S-1)J) / H
374 * Overwrite prescale.translate with values for K:
376 for (i = 0; i < 2; i++) {
377 prescale.translate[i] = ((prescale.translate[i] +
378 (prescale.scale[i] - 1.0) * J[i]) / H[i]);
381 SVGA_DBG(DEBUG_VIEWPORT,
382 "clipspace %f,%f %fx%f\n",
383 prescale.translate[0],
384 prescale.translate[1],
395 prescale.enabled = FALSE;
398 if (memcmp(&rect, &svga->state.hw_clear.viewport, sizeof(rect)) != 0) {
399 ret = SVGA3D_SetViewport(svga->swc, &rect);
403 memcpy(&svga->state.hw_clear.viewport, &rect, sizeof(rect));
404 assert(sizeof(rect) == sizeof(svga->state.hw_clear.viewport));
407 if (svga->state.hw_clear.depthrange.zmin != range_min ||
408 svga->state.hw_clear.depthrange.zmax != range_max)
410 ret = SVGA3D_SetZRange(svga->swc, range_min, range_max );
414 svga->state.hw_clear.depthrange.zmin = range_min;
415 svga->state.hw_clear.depthrange.zmax = range_max;
418 if (memcmp(&prescale, &svga->state.hw_clear.prescale, sizeof prescale) != 0) {
419 svga->dirty |= SVGA_NEW_PRESCALE;
420 svga->state.hw_clear.prescale = prescale;
427 struct svga_tracked_state svga_hw_viewport =
430 ( SVGA_NEW_FRAME_BUFFER |
433 SVGA_NEW_REDUCED_PRIMITIVE ),
438 /***********************************************************************
441 static int emit_scissor_rect( struct svga_context *svga,
444 const struct pipe_scissor_state *scissor = &svga->curr.scissor;
447 rect.x = scissor->minx;
448 rect.y = scissor->miny;
449 rect.w = scissor->maxx - scissor->minx; /* + 1 ?? */
450 rect.h = scissor->maxy - scissor->miny; /* + 1 ?? */
452 return SVGA3D_SetScissorRect(svga->swc, &rect);
456 struct svga_tracked_state svga_hw_scissor =
464 /***********************************************************************
468 static int emit_clip_planes( struct svga_context *svga,
474 /* TODO: just emit directly from svga_set_clip_state()?
476 for (i = 0; i < svga->curr.clip.nr; i++) {
477 /* need to express the plane in D3D-style coordinate space.
478 * GL coords get converted to D3D coords with the matrix:
483 * Apply that matrix to our plane equation, and invert Y.
485 float a = svga->curr.clip.ucp[i][0];
486 float b = svga->curr.clip.ucp[i][1];
487 float c = svga->curr.clip.ucp[i][2];
488 float d = svga->curr.clip.ucp[i][3];
496 ret = SVGA3D_SetClipPlane(svga->swc, i, plane);
505 struct svga_tracked_state svga_hw_clip_planes =