svga_screen.c revision bb4c5d72d7c7cb1d9e7016e2c07c36875f30011a
1/********************************************************** 2 * Copyright 2008-2009 VMware, Inc. All rights reserved. 3 * 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: 11 * 12 * The above copyright notice and this permission notice shall be 13 * included in all copies or substantial portions of the Software. 14 * 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 22 * SOFTWARE. 23 * 24 **********************************************************/ 25 26#include "util/u_memory.h" 27#include "util/u_inlines.h" 28#include "util/u_string.h" 29#include "util/u_math.h" 30 31#include "svga_winsys.h" 32#include "svga_public.h" 33#include "svga_context.h" 34#include "svga_format.h" 35#include "svga_screen.h" 36#include "svga_resource_texture.h" 37#include "svga_resource.h" 38#include "svga_debug.h" 39 40#include "svga3d_shaderdefs.h" 41 42 43#ifdef DEBUG 44int SVGA_DEBUG = 0; 45 46static const struct debug_named_value svga_debug_flags[] = { 47 { "dma", DEBUG_DMA, NULL }, 48 { "tgsi", DEBUG_TGSI, NULL }, 49 { "pipe", DEBUG_PIPE, NULL }, 50 { "state", DEBUG_STATE, NULL }, 51 { "screen", DEBUG_SCREEN, NULL }, 52 { "tex", DEBUG_TEX, NULL }, 53 { "swtnl", DEBUG_SWTNL, NULL }, 54 { "const", DEBUG_CONSTS, NULL }, 55 { "viewport", DEBUG_VIEWPORT, NULL }, 56 { "views", DEBUG_VIEWS, NULL }, 57 { "perf", DEBUG_PERF, NULL }, 58 { "flush", DEBUG_FLUSH, NULL }, 59 { "sync", DEBUG_SYNC, NULL }, 60 { "cache", DEBUG_CACHE, NULL }, 61 DEBUG_NAMED_VALUE_END 62}; 63#endif 64 65static const char * 66svga_get_vendor( struct pipe_screen *pscreen ) 67{ 68 return "VMware, Inc."; 69} 70 71 72static const char * 73svga_get_name( struct pipe_screen *pscreen ) 74{ 75 const char *build = "", *llvm = "", *mutex = ""; 76 static char name[100]; 77#ifdef DEBUG 78 /* Only return internal details in the DEBUG version: 79 */ 80 build = "build: DEBUG;"; 81 mutex = "mutex: " PIPE_ATOMIC ";"; 82#ifdef HAVE_LLVM 83 llvm = "LLVM;"; 84#endif 85#else 86 build = "build: RELEASE;"; 87#endif 88 89 util_snprintf(name, sizeof(name), "SVGA3D; %s %s %s", build, mutex, llvm); 90 return name; 91} 92 93 94 95 96static float 97svga_get_paramf(struct pipe_screen *screen, enum pipe_capf param) 98{ 99 struct svga_screen *svgascreen = svga_screen(screen); 100 struct svga_winsys_screen *sws = svgascreen->sws; 101 SVGA3dDevCapResult result; 102 103 switch (param) { 104 case PIPE_CAPF_MAX_LINE_WIDTH: 105 /* fall-through */ 106 case PIPE_CAPF_MAX_LINE_WIDTH_AA: 107 return 7.0; 108 109 case PIPE_CAPF_MAX_POINT_WIDTH: 110 /* fall-through */ 111 case PIPE_CAPF_MAX_POINT_WIDTH_AA: 112 return svgascreen->maxPointSize; 113 114 case PIPE_CAPF_MAX_TEXTURE_ANISOTROPY: 115 if(!sws->get_cap(sws, SVGA3D_DEVCAP_MAX_TEXTURE_ANISOTROPY, &result)) 116 return 4.0; 117 return result.u; 118 119 case PIPE_CAPF_MAX_TEXTURE_LOD_BIAS: 120 return 15.0; 121 122 default: 123 debug_printf("Unexpected PIPE_CAPF_ query %u\n", param); 124 return 0; 125 } 126} 127 128 129static int 130svga_get_param(struct pipe_screen *screen, enum pipe_cap param) 131{ 132 struct svga_screen *svgascreen = svga_screen(screen); 133 struct svga_winsys_screen *sws = svgascreen->sws; 134 SVGA3dDevCapResult result; 135 136 switch (param) { 137 case PIPE_CAP_MAX_COMBINED_SAMPLERS: 138 return 16; 139 case PIPE_CAP_NPOT_TEXTURES: 140 return 1; 141 case PIPE_CAP_TWO_SIDED_STENCIL: 142 return 1; 143 case PIPE_CAP_MAX_DUAL_SOURCE_RENDER_TARGETS: 144 return 0; 145 case PIPE_CAP_ANISOTROPIC_FILTER: 146 return 1; 147 case PIPE_CAP_POINT_SPRITE: 148 return 1; 149 case PIPE_CAP_MAX_RENDER_TARGETS: 150 if(!sws->get_cap(sws, SVGA3D_DEVCAP_MAX_RENDER_TARGETS, &result)) 151 return 1; 152 if(!result.u) 153 return 1; 154 return MIN2(result.u, PIPE_MAX_COLOR_BUFS); 155 case PIPE_CAP_OCCLUSION_QUERY: 156 return 1; 157 case PIPE_CAP_TIMER_QUERY: 158 return 0; 159 case PIPE_CAP_TEXTURE_SHADOW_MAP: 160 return 1; 161 case PIPE_CAP_TEXTURE_SWIZZLE: 162 return 1; 163 case PIPE_CAP_USER_VERTEX_BUFFERS: 164 case PIPE_CAP_USER_INDEX_BUFFERS: 165 return 0; 166 case PIPE_CAP_USER_CONSTANT_BUFFERS: 167 return 1; 168 case PIPE_CAP_CONSTANT_BUFFER_OFFSET_ALIGNMENT: 169 return 16; 170 171 case PIPE_CAP_MAX_TEXTURE_2D_LEVELS: 172 { 173 unsigned levels = SVGA_MAX_TEXTURE_LEVELS; 174 if (sws->get_cap(sws, SVGA3D_DEVCAP_MAX_TEXTURE_WIDTH, &result)) 175 levels = MIN2(util_logbase2(result.u) + 1, levels); 176 else 177 levels = 12 /* 2048x2048 */; 178 if (sws->get_cap(sws, SVGA3D_DEVCAP_MAX_TEXTURE_HEIGHT, &result)) 179 levels = MIN2(util_logbase2(result.u) + 1, levels); 180 else 181 levels = 12 /* 2048x2048 */; 182 return levels; 183 } 184 185 case PIPE_CAP_MAX_TEXTURE_3D_LEVELS: 186 if (!sws->get_cap(sws, SVGA3D_DEVCAP_MAX_VOLUME_EXTENT, &result)) 187 return 8; /* max 128x128x128 */ 188 return MIN2(util_logbase2(result.u) + 1, SVGA_MAX_TEXTURE_LEVELS); 189 190 case PIPE_CAP_MAX_TEXTURE_CUBE_LEVELS: 191 /* 192 * No mechanism to query the host, and at least limited to 2048x2048 on 193 * certain hardware. 194 */ 195 return MIN2(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_2D_LEVELS), 196 12 /* 2048x2048 */); 197 198 case PIPE_CAP_BLEND_EQUATION_SEPARATE: /* req. for GL 1.5 */ 199 return 1; 200 201 case PIPE_CAP_TGSI_FS_COORD_ORIGIN_UPPER_LEFT: 202 case PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_HALF_INTEGER: 203 return 1; 204 case PIPE_CAP_TGSI_FS_COORD_ORIGIN_LOWER_LEFT: 205 case PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_INTEGER: 206 return 0; 207 208 case PIPE_CAP_DEPTHSTENCIL_CLEAR_SEPARATE: 209 return 1; 210 211 case PIPE_CAP_VERTEX_COLOR_UNCLAMPED: 212 return 1; /* The color outputs of vertex shaders are not clamped */ 213 case PIPE_CAP_VERTEX_COLOR_CLAMPED: 214 return 0; /* The driver can't clamp vertex colors */ 215 case PIPE_CAP_FRAGMENT_COLOR_CLAMPED: 216 return 0; /* The driver can't clamp fragment colors */ 217 218 /* Unsupported features */ 219 case PIPE_CAP_MIXED_COLORBUFFER_FORMATS: 220 case PIPE_CAP_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION: 221 case PIPE_CAP_TEXTURE_MIRROR_CLAMP: 222 case PIPE_CAP_SM3: 223 case PIPE_CAP_SHADER_STENCIL_EXPORT: 224 case PIPE_CAP_DEPTH_CLIP_DISABLE: 225 case PIPE_CAP_SEAMLESS_CUBE_MAP: 226 case PIPE_CAP_SEAMLESS_CUBE_MAP_PER_TEXTURE: 227 case PIPE_CAP_INDEP_BLEND_ENABLE: 228 case PIPE_CAP_INDEP_BLEND_FUNC: 229 case PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS: 230 case PIPE_CAP_PRIMITIVE_RESTART: 231 case PIPE_CAP_TGSI_INSTANCEID: 232 case PIPE_CAP_VERTEX_ELEMENT_INSTANCE_DIVISOR: 233 case PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS: 234 case PIPE_CAP_MIN_TEXEL_OFFSET: 235 case PIPE_CAP_MAX_TEXEL_OFFSET: 236 case PIPE_CAP_CONDITIONAL_RENDER: 237 case PIPE_CAP_TEXTURE_BARRIER: 238 case PIPE_CAP_MAX_STREAM_OUTPUT_SEPARATE_COMPONENTS: 239 case PIPE_CAP_MAX_STREAM_OUTPUT_INTERLEAVED_COMPONENTS: 240 case PIPE_CAP_STREAM_OUTPUT_PAUSE_RESUME: 241 case PIPE_CAP_TGSI_CAN_COMPACT_VARYINGS: 242 case PIPE_CAP_TGSI_CAN_COMPACT_CONSTANTS: 243 case PIPE_CAP_GLSL_FEATURE_LEVEL: 244 case PIPE_CAP_VERTEX_BUFFER_OFFSET_4BYTE_ALIGNED_ONLY: 245 case PIPE_CAP_VERTEX_BUFFER_STRIDE_4BYTE_ALIGNED_ONLY: 246 return 0; 247 case PIPE_CAP_VERTEX_ELEMENT_SRC_OFFSET_4BYTE_ALIGNED_ONLY: 248 return 1; 249 250 default: 251 debug_printf("Unexpected PIPE_CAP_ query %u\n", param); 252 return 0; 253 } 254} 255 256static int svga_get_shader_param(struct pipe_screen *screen, unsigned shader, enum pipe_shader_cap param) 257{ 258 struct svga_screen *svgascreen = svga_screen(screen); 259 struct svga_winsys_screen *sws = svgascreen->sws; 260 SVGA3dDevCapResult result; 261 262 switch (shader) 263 { 264 case PIPE_SHADER_FRAGMENT: 265 switch (param) 266 { 267 case PIPE_SHADER_CAP_MAX_INSTRUCTIONS: 268 case PIPE_SHADER_CAP_MAX_ALU_INSTRUCTIONS: 269 case PIPE_SHADER_CAP_MAX_TEX_INSTRUCTIONS: 270 case PIPE_SHADER_CAP_MAX_TEX_INDIRECTIONS: 271 return 512; 272 case PIPE_SHADER_CAP_MAX_CONTROL_FLOW_DEPTH: 273 return SVGA3D_MAX_NESTING_LEVEL; 274 case PIPE_SHADER_CAP_MAX_INPUTS: 275 return 10; 276 case PIPE_SHADER_CAP_MAX_CONSTS: 277 return 224; 278 case PIPE_SHADER_CAP_MAX_CONST_BUFFERS: 279 return 1; 280 case PIPE_SHADER_CAP_MAX_TEMPS: 281 if (!sws->get_cap(sws, SVGA3D_DEVCAP_MAX_FRAGMENT_SHADER_TEMPS, &result)) 282 return 32; 283 return MIN2(result.u, SVGA3D_TEMPREG_MAX); 284 case PIPE_SHADER_CAP_MAX_ADDRS: 285 case PIPE_SHADER_CAP_INDIRECT_INPUT_ADDR: 286 /* 287 * Although PS 3.0 has some addressing abilities it can only represent 288 * loops that can be statically determined and unrolled. Given we can 289 * only handle a subset of the cases that the state tracker already 290 * does it is better to defer loop unrolling to the state tracker. 291 */ 292 return 0; 293 case PIPE_SHADER_CAP_MAX_PREDS: 294 return 1; 295 case PIPE_SHADER_CAP_TGSI_CONT_SUPPORTED: 296 return 1; 297 case PIPE_SHADER_CAP_INDIRECT_OUTPUT_ADDR: 298 case PIPE_SHADER_CAP_INDIRECT_TEMP_ADDR: 299 case PIPE_SHADER_CAP_INDIRECT_CONST_ADDR: 300 return 0; 301 case PIPE_SHADER_CAP_SUBROUTINES: 302 return 0; 303 case PIPE_SHADER_CAP_INTEGERS: 304 return 0; 305 case PIPE_SHADER_CAP_MAX_TEXTURE_SAMPLERS: 306 return 16; 307 default: 308 debug_printf("Unexpected vertex shader query %u\n", param); 309 return 0; 310 } 311 break; 312 case PIPE_SHADER_VERTEX: 313 switch (param) 314 { 315 case PIPE_SHADER_CAP_MAX_INSTRUCTIONS: 316 case PIPE_SHADER_CAP_MAX_ALU_INSTRUCTIONS: 317 if (!sws->get_cap(sws, SVGA3D_DEVCAP_MAX_VERTEX_SHADER_INSTRUCTIONS, &result)) 318 return 512; 319 return result.u; 320 case PIPE_SHADER_CAP_MAX_TEX_INSTRUCTIONS: 321 case PIPE_SHADER_CAP_MAX_TEX_INDIRECTIONS: 322 /* XXX: until we have vertex texture support */ 323 return 0; 324 case PIPE_SHADER_CAP_MAX_CONTROL_FLOW_DEPTH: 325 return SVGA3D_MAX_NESTING_LEVEL; 326 case PIPE_SHADER_CAP_MAX_INPUTS: 327 return 16; 328 case PIPE_SHADER_CAP_MAX_CONSTS: 329 return 256; 330 case PIPE_SHADER_CAP_MAX_CONST_BUFFERS: 331 return 1; 332 case PIPE_SHADER_CAP_MAX_TEMPS: 333 if (!sws->get_cap(sws, SVGA3D_DEVCAP_MAX_VERTEX_SHADER_TEMPS, &result)) 334 return 32; 335 return MIN2(result.u, SVGA3D_TEMPREG_MAX); 336 case PIPE_SHADER_CAP_MAX_ADDRS: 337 return 1; 338 case PIPE_SHADER_CAP_MAX_PREDS: 339 return 1; 340 case PIPE_SHADER_CAP_TGSI_CONT_SUPPORTED: 341 return 1; 342 case PIPE_SHADER_CAP_INDIRECT_INPUT_ADDR: 343 case PIPE_SHADER_CAP_INDIRECT_OUTPUT_ADDR: 344 return 1; 345 case PIPE_SHADER_CAP_INDIRECT_TEMP_ADDR: 346 return 0; 347 case PIPE_SHADER_CAP_INDIRECT_CONST_ADDR: 348 return 1; 349 case PIPE_SHADER_CAP_SUBROUTINES: 350 return 0; 351 case PIPE_SHADER_CAP_INTEGERS: 352 return 0; 353 case PIPE_SHADER_CAP_MAX_TEXTURE_SAMPLERS: 354 return 0; 355 default: 356 debug_printf("Unexpected vertex shader query %u\n", param); 357 return 0; 358 } 359 break; 360 case PIPE_SHADER_GEOMETRY: 361 /* no support for geometry shaders at this time */ 362 return 0; 363 default: 364 debug_printf("Unexpected vertex shader query %u\n", param); 365 return 0; 366 } 367 return 0; 368} 369 370 371static boolean 372svga_is_format_supported( struct pipe_screen *screen, 373 enum pipe_format format, 374 enum pipe_texture_target target, 375 unsigned sample_count, 376 unsigned tex_usage) 377{ 378 struct svga_screen *ss = svga_screen(screen); 379 SVGA3dSurfaceFormat svga_format; 380 SVGA3dSurfaceFormatCaps caps; 381 SVGA3dSurfaceFormatCaps mask; 382 383 assert(tex_usage); 384 385 if (sample_count > 1) { 386 return FALSE; 387 } 388 389 svga_format = svga_translate_format(ss, format, tex_usage); 390 if (svga_format == SVGA3D_FORMAT_INVALID) { 391 return FALSE; 392 } 393 394 /* 395 * Override host capabilities, so that we end up with the same 396 * visuals for all virtual hardware implementations. 397 */ 398 399 if (tex_usage & PIPE_BIND_DISPLAY_TARGET) { 400 switch (svga_format) { 401 case SVGA3D_A8R8G8B8: 402 case SVGA3D_X8R8G8B8: 403 case SVGA3D_R5G6B5: 404 break; 405 406 /* Often unsupported/problematic. This means we end up with the same 407 * visuals for all virtual hardware implementations. 408 */ 409 case SVGA3D_A4R4G4B4: 410 case SVGA3D_A1R5G5B5: 411 return FALSE; 412 413 default: 414 return FALSE; 415 } 416 } 417 418 /* 419 * Query the host capabilities. 420 */ 421 422 svga_get_format_cap(ss, svga_format, &caps); 423 424 mask.value = 0; 425 if (tex_usage & PIPE_BIND_RENDER_TARGET) { 426 mask.offscreenRenderTarget = 1; 427 } 428 if (tex_usage & PIPE_BIND_DEPTH_STENCIL) { 429 mask.zStencil = 1; 430 } 431 if (tex_usage & PIPE_BIND_SAMPLER_VIEW) { 432 mask.texture = 1; 433 } 434 435 return (caps.value & mask.value) == mask.value; 436} 437 438 439static void 440svga_fence_reference(struct pipe_screen *screen, 441 struct pipe_fence_handle **ptr, 442 struct pipe_fence_handle *fence) 443{ 444 struct svga_winsys_screen *sws = svga_screen(screen)->sws; 445 sws->fence_reference(sws, ptr, fence); 446} 447 448 449static boolean 450svga_fence_signalled(struct pipe_screen *screen, 451 struct pipe_fence_handle *fence) 452{ 453 struct svga_winsys_screen *sws = svga_screen(screen)->sws; 454 return sws->fence_signalled(sws, fence, 0) == 0; 455} 456 457 458static boolean 459svga_fence_finish(struct pipe_screen *screen, 460 struct pipe_fence_handle *fence, 461 uint64_t timeout) 462{ 463 struct svga_winsys_screen *sws = svga_screen(screen)->sws; 464 465 SVGA_DBG(DEBUG_DMA|DEBUG_PERF, "%s fence_ptr %p\n", 466 __FUNCTION__, fence); 467 468 return sws->fence_finish(sws, fence, 0) == 0; 469} 470 471 472static void 473svga_destroy_screen( struct pipe_screen *screen ) 474{ 475 struct svga_screen *svgascreen = svga_screen(screen); 476 477 svga_screen_cache_cleanup(svgascreen); 478 479 pipe_mutex_destroy(svgascreen->swc_mutex); 480 pipe_mutex_destroy(svgascreen->tex_mutex); 481 482 svgascreen->sws->destroy(svgascreen->sws); 483 484 FREE(svgascreen); 485} 486 487 488/** 489 * Create a new svga_screen object 490 */ 491struct pipe_screen * 492svga_screen_create(struct svga_winsys_screen *sws) 493{ 494 struct svga_screen *svgascreen; 495 struct pipe_screen *screen; 496 SVGA3dDevCapResult result; 497 boolean use_vs30, use_ps30; 498 499#ifdef DEBUG 500 SVGA_DEBUG = debug_get_flags_option("SVGA_DEBUG", svga_debug_flags, 0 ); 501#endif 502 503 svgascreen = CALLOC_STRUCT(svga_screen); 504 if (!svgascreen) 505 goto error1; 506 507 svgascreen->debug.force_level_surface_view = 508 debug_get_bool_option("SVGA_FORCE_LEVEL_SURFACE_VIEW", FALSE); 509 svgascreen->debug.force_surface_view = 510 debug_get_bool_option("SVGA_FORCE_SURFACE_VIEW", FALSE); 511 svgascreen->debug.force_sampler_view = 512 debug_get_bool_option("SVGA_FORCE_SAMPLER_VIEW", FALSE); 513 svgascreen->debug.no_surface_view = 514 debug_get_bool_option("SVGA_NO_SURFACE_VIEW", FALSE); 515 svgascreen->debug.no_sampler_view = 516 debug_get_bool_option("SVGA_NO_SAMPLER_VIEW", FALSE); 517 518 screen = &svgascreen->screen; 519 520 screen->destroy = svga_destroy_screen; 521 screen->get_name = svga_get_name; 522 screen->get_vendor = svga_get_vendor; 523 screen->get_param = svga_get_param; 524 screen->get_shader_param = svga_get_shader_param; 525 screen->get_paramf = svga_get_paramf; 526 screen->is_format_supported = svga_is_format_supported; 527 screen->context_create = svga_context_create; 528 screen->fence_reference = svga_fence_reference; 529 screen->fence_signalled = svga_fence_signalled; 530 screen->fence_finish = svga_fence_finish; 531 svgascreen->sws = sws; 532 533 svga_init_screen_resource_functions(svgascreen); 534 535 if (sws->get_hw_version) { 536 svgascreen->hw_version = sws->get_hw_version(sws); 537 } else { 538 svgascreen->hw_version = SVGA3D_HWVERSION_WS65_B1; 539 } 540 541 use_ps30 = 542 sws->get_cap(sws, SVGA3D_DEVCAP_FRAGMENT_SHADER_VERSION, &result) && 543 result.u >= SVGA3DPSVERSION_30 ? TRUE : FALSE; 544 545 use_vs30 = 546 sws->get_cap(sws, SVGA3D_DEVCAP_VERTEX_SHADER_VERSION, &result) && 547 result.u >= SVGA3DVSVERSION_30 ? TRUE : FALSE; 548 549 /* we require Shader model 3.0 or later */ 550 if (!use_ps30 || !use_vs30) 551 goto error2; 552 553 /* 554 * The D16, D24X8, and D24S8 formats always do an implicit shadow compare 555 * when sampled from, where as the DF16, DF24, and D24S8_INT do not. So 556 * we prefer the later when available. 557 * 558 * This mimics hardware vendors extensions for D3D depth sampling. See also 559 * http://aras-p.info/texts/D3D9GPUHacks.html 560 */ 561 562 { 563 boolean has_df16, has_df24, has_d24s8_int; 564 SVGA3dSurfaceFormatCaps caps; 565 SVGA3dSurfaceFormatCaps mask; 566 mask.value = 0; 567 mask.zStencil = 1; 568 mask.texture = 1; 569 570 svgascreen->depth.z16 = SVGA3D_Z_D16; 571 svgascreen->depth.x8z24 = SVGA3D_Z_D24X8; 572 svgascreen->depth.s8z24 = SVGA3D_Z_D24S8; 573 574 svga_get_format_cap(svgascreen, SVGA3D_Z_DF16, &caps); 575 has_df16 = (caps.value & mask.value) == mask.value; 576 577 svga_get_format_cap(svgascreen, SVGA3D_Z_DF24, &caps); 578 has_df24 = (caps.value & mask.value) == mask.value; 579 580 svga_get_format_cap(svgascreen, SVGA3D_Z_D24S8_INT, &caps); 581 has_d24s8_int = (caps.value & mask.value) == mask.value; 582 583 /* XXX: We might want some other logic here. 584 * Like if we only have d24s8_int we should 585 * emulate the other formats with that. 586 */ 587 if (has_df16) { 588 svgascreen->depth.z16 = SVGA3D_Z_DF16; 589 } 590 if (has_df24) { 591 svgascreen->depth.x8z24 = SVGA3D_Z_DF24; 592 } 593 if (has_d24s8_int) { 594 svgascreen->depth.s8z24 = SVGA3D_Z_D24S8_INT; 595 } 596 } 597 598 if (!sws->get_cap(sws, SVGA3D_DEVCAP_MAX_POINT_SIZE, &result)) { 599 svgascreen->maxPointSize = 1.0F; 600 } else { 601 /* Keep this to a reasonable size to avoid failures in 602 * conform/pntaa.c: 603 */ 604 svgascreen->maxPointSize = MIN2(result.f, 80.0f); 605 } 606 607 pipe_mutex_init(svgascreen->tex_mutex); 608 pipe_mutex_init(svgascreen->swc_mutex); 609 610 svga_screen_cache_init(svgascreen); 611 612 return screen; 613error2: 614 FREE(svgascreen); 615error1: 616 return NULL; 617} 618 619struct svga_winsys_screen * 620svga_winsys_screen(struct pipe_screen *screen) 621{ 622 return svga_screen(screen)->sws; 623} 624 625#ifdef DEBUG 626struct svga_screen * 627svga_screen(struct pipe_screen *screen) 628{ 629 assert(screen); 630 assert(screen->destroy == svga_destroy_screen); 631 return (struct svga_screen *)screen; 632} 633#endif 634