1 /* 2 * Copyright 2017 Valve Corporation. 3 * 4 * Permission is hereby granted, free of charge, to any person obtaining a 5 * copy of this software and associated documentation files (the "Software"), 6 * to deal in the Software without restriction, including without limitation 7 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 8 * and/or sell copies of the Software, and to permit persons to whom the 9 * Software is furnished to do so, subject to the following conditions: 10 * 11 * The above copyright notice and this permission notice (including the next 12 * paragraph) shall be included in all copies or substantial portions of the 13 * Software. 14 * 15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 21 * DEALINGS IN THE SOFTWARE. 22 */ 23 24 #include "glheader.h" 25 #include "context.h" 26 #include "enums.h" 27 #include "imports.h" 28 #include "hash.h" 29 #include "mtypes.h" 30 #include "shaderimage.h" 31 #include "teximage.h" 32 #include "texobj.h" 33 #include "texturebindless.h" 34 35 #include "util/hash_table.h" 36 37 /** 38 * Return the gl_texture_handle_object for a given 64-bit handle. 39 */ 40 static struct gl_texture_handle_object * 41 lookup_texture_handle(struct gl_context *ctx, GLuint64 id) 42 { 43 struct gl_texture_handle_object *texHandleObj; 44 45 mtx_lock(&ctx->Shared->HandlesMutex); 46 texHandleObj = (struct gl_texture_handle_object *) 47 _mesa_hash_table_u64_search(ctx->Shared->TextureHandles, id); 48 mtx_unlock(&ctx->Shared->HandlesMutex); 49 50 return texHandleObj; 51 } 52 53 /** 54 * Return the gl_image_handle_object for a given 64-bit handle. 55 */ 56 static struct gl_image_handle_object * 57 lookup_image_handle(struct gl_context *ctx, GLuint64 id) 58 { 59 struct gl_image_handle_object *imgHandleObj; 60 61 mtx_lock(&ctx->Shared->HandlesMutex); 62 imgHandleObj = (struct gl_image_handle_object *) 63 _mesa_hash_table_u64_search(ctx->Shared->ImageHandles, id); 64 mtx_unlock(&ctx->Shared->HandlesMutex); 65 66 return imgHandleObj; 67 } 68 69 /** 70 * Delete a texture handle in the shared state. 71 */ 72 static void 73 delete_texture_handle(struct gl_context *ctx, GLuint64 id) 74 { 75 mtx_lock(&ctx->Shared->HandlesMutex); 76 _mesa_hash_table_u64_remove(ctx->Shared->TextureHandles, id); 77 mtx_unlock(&ctx->Shared->HandlesMutex); 78 79 ctx->Driver.DeleteTextureHandle(ctx, id); 80 } 81 82 /** 83 * Delete an image handle in the shared state. 84 */ 85 static void 86 delete_image_handle(struct gl_context *ctx, GLuint64 id) 87 { 88 mtx_lock(&ctx->Shared->HandlesMutex); 89 _mesa_hash_table_u64_remove(ctx->Shared->ImageHandles, id); 90 mtx_unlock(&ctx->Shared->HandlesMutex); 91 92 ctx->Driver.DeleteImageHandle(ctx, id); 93 } 94 95 /** 96 * Return TRUE if the texture handle is resident in the current context. 97 */ 98 static inline bool 99 is_texture_handle_resident(struct gl_context *ctx, GLuint64 handle) 100 { 101 return _mesa_hash_table_u64_search(ctx->ResidentTextureHandles, 102 handle) != NULL; 103 } 104 105 /** 106 * Return TRUE if the image handle is resident in the current context. 107 */ 108 static inline bool 109 is_image_handle_resident(struct gl_context *ctx, GLuint64 handle) 110 { 111 return _mesa_hash_table_u64_search(ctx->ResidentImageHandles, 112 handle) != NULL; 113 } 114 115 /** 116 * Make a texture handle resident/non-resident in the current context. 117 */ 118 static void 119 make_texture_handle_resident(struct gl_context *ctx, 120 struct gl_texture_handle_object *texHandleObj, 121 bool resident) 122 { 123 struct gl_sampler_object *sampObj = NULL; 124 struct gl_texture_object *texObj = NULL; 125 GLuint64 handle = texHandleObj->handle; 126 127 if (resident) { 128 assert(!is_texture_handle_resident(ctx, handle)); 129 130 _mesa_hash_table_u64_insert(ctx->ResidentTextureHandles, handle, 131 texHandleObj); 132 133 ctx->Driver.MakeTextureHandleResident(ctx, handle, GL_TRUE); 134 135 /* Reference the texture object (and the separate sampler if needed) to 136 * be sure it won't be deleted until it is not bound anywhere and there 137 * are no handles using the object that are resident in any context. 138 */ 139 _mesa_reference_texobj(&texObj, texHandleObj->texObj); 140 if (texHandleObj->sampObj) 141 _mesa_reference_sampler_object(ctx, &sampObj, texHandleObj->sampObj); 142 } else { 143 assert(is_texture_handle_resident(ctx, handle)); 144 145 _mesa_hash_table_u64_remove(ctx->ResidentTextureHandles, handle); 146 147 ctx->Driver.MakeTextureHandleResident(ctx, handle, GL_FALSE); 148 149 /* Unreference the texture object but keep the pointer intact, if 150 * refcount hits zero, the texture and all handles will be deleted. 151 */ 152 texObj = texHandleObj->texObj; 153 _mesa_reference_texobj(&texObj, NULL); 154 155 /* Unreference the separate sampler object but keep the pointer intact, 156 * if refcount hits zero, the sampler and all handles will be deleted. 157 */ 158 if (texHandleObj->sampObj) { 159 sampObj = texHandleObj->sampObj; 160 _mesa_reference_sampler_object(ctx, &sampObj, NULL); 161 } 162 } 163 } 164 165 /** 166 * Make an image handle resident/non-resident in the current context. 167 */ 168 static void 169 make_image_handle_resident(struct gl_context *ctx, 170 struct gl_image_handle_object *imgHandleObj, 171 GLenum access, bool resident) 172 { 173 struct gl_texture_object *texObj = NULL; 174 GLuint64 handle = imgHandleObj->handle; 175 176 if (resident) { 177 assert(!is_image_handle_resident(ctx, handle)); 178 179 _mesa_hash_table_u64_insert(ctx->ResidentImageHandles, handle, 180 imgHandleObj); 181 182 ctx->Driver.MakeImageHandleResident(ctx, handle, access, GL_TRUE); 183 184 /* Reference the texture object to be sure it won't be deleted until it 185 * is not bound anywhere and there are no handles using the object that 186 * are resident in any context. 187 */ 188 _mesa_reference_texobj(&texObj, imgHandleObj->imgObj.TexObj); 189 } else { 190 assert(is_image_handle_resident(ctx, handle)); 191 192 _mesa_hash_table_u64_remove(ctx->ResidentImageHandles, handle); 193 194 ctx->Driver.MakeImageHandleResident(ctx, handle, access, GL_FALSE); 195 196 /* Unreference the texture object but keep the pointer intact, if 197 * refcount hits zero, the texture and all handles will be deleted. 198 */ 199 texObj = imgHandleObj->imgObj.TexObj; 200 _mesa_reference_texobj(&texObj, NULL); 201 } 202 } 203 204 static struct gl_texture_handle_object * 205 find_texhandleobj(struct gl_texture_object *texObj, 206 struct gl_sampler_object *sampObj) 207 { 208 util_dynarray_foreach(&texObj->SamplerHandles, 209 struct gl_texture_handle_object *, texHandleObj) { 210 if ((*texHandleObj)->sampObj == sampObj) 211 return *texHandleObj; 212 } 213 return NULL; 214 } 215 216 static GLuint64 217 get_texture_handle(struct gl_context *ctx, struct gl_texture_object *texObj, 218 struct gl_sampler_object *sampObj) 219 { 220 bool separate_sampler = &texObj->Sampler != sampObj; 221 struct gl_texture_handle_object *texHandleObj; 222 GLuint64 handle; 223 224 /* The ARB_bindless_texture spec says: 225 * 226 * "The handle for each texture or texture/sampler pair is unique; the same 227 * handle will be returned if GetTextureHandleARB is called multiple times 228 * for the same texture or if GetTextureSamplerHandleARB is called multiple 229 * times for the same texture/sampler pair." 230 */ 231 mtx_lock(&ctx->Shared->HandlesMutex); 232 texHandleObj = find_texhandleobj(texObj, separate_sampler ? sampObj : NULL); 233 if (texHandleObj) { 234 mtx_unlock(&ctx->Shared->HandlesMutex); 235 return texHandleObj->handle; 236 } 237 238 /* Request a new texture handle from the driver. */ 239 handle = ctx->Driver.NewTextureHandle(ctx, texObj, sampObj); 240 if (!handle) { 241 mtx_unlock(&ctx->Shared->HandlesMutex); 242 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glGetTexture*HandleARB()"); 243 return 0; 244 } 245 246 texHandleObj = CALLOC_STRUCT(gl_texture_handle_object); 247 if (!texHandleObj) { 248 mtx_unlock(&ctx->Shared->HandlesMutex); 249 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glGetTexture*HandleARB()"); 250 return 0; 251 } 252 253 /* Store the handle into the texture object. */ 254 texHandleObj->texObj = texObj; 255 texHandleObj->sampObj = separate_sampler ? sampObj : NULL; 256 texHandleObj->handle = handle; 257 util_dynarray_append(&texObj->SamplerHandles, 258 struct gl_texture_handle_object *, texHandleObj); 259 260 if (separate_sampler) { 261 /* Store the handle into the separate sampler if needed. */ 262 util_dynarray_append(&sampObj->Handles, 263 struct gl_texture_handle_object *, texHandleObj); 264 } 265 266 /* When referenced by one or more handles, texture objects are immutable. */ 267 texObj->HandleAllocated = true; 268 if (texObj->Target == GL_TEXTURE_BUFFER) 269 texObj->BufferObject->HandleAllocated = true; 270 sampObj->HandleAllocated = true; 271 272 /* Store the handle in the shared state for all contexts. */ 273 _mesa_hash_table_u64_insert(ctx->Shared->TextureHandles, handle, 274 texHandleObj); 275 mtx_unlock(&ctx->Shared->HandlesMutex); 276 277 return handle; 278 } 279 280 static struct gl_image_handle_object * 281 find_imghandleobj(struct gl_texture_object *texObj, GLint level, 282 GLboolean layered, GLint layer, GLenum format) 283 { 284 util_dynarray_foreach(&texObj->ImageHandles, 285 struct gl_image_handle_object *, imgHandleObj) { 286 struct gl_image_unit *u = &(*imgHandleObj)->imgObj; 287 288 if (u->TexObj == texObj && u->Level == level && u->Layered == layered && 289 u->Layer == layer && u->Format == format) 290 return *imgHandleObj; 291 } 292 return NULL; 293 } 294 295 static GLuint64 296 get_image_handle(struct gl_context *ctx, struct gl_texture_object *texObj, 297 GLint level, GLboolean layered, GLint layer, GLenum format) 298 { 299 struct gl_image_handle_object *imgHandleObj; 300 struct gl_image_unit imgObj; 301 GLuint64 handle; 302 303 /* The ARB_bindless_texture spec says: 304 * 305 * "The handle returned for each combination of <texture>, <level>, 306 * <layered>, <layer>, and <format> is unique; the same handle will be 307 * returned if GetImageHandleARB is called multiple times with the same 308 * parameters." 309 */ 310 mtx_lock(&ctx->Shared->HandlesMutex); 311 imgHandleObj = find_imghandleobj(texObj, level, layered, layer, format); 312 if (imgHandleObj) { 313 mtx_unlock(&ctx->Shared->HandlesMutex); 314 return imgHandleObj->handle; 315 } 316 317 imgObj.TexObj = texObj; /* weak reference */ 318 imgObj.Level = level; 319 imgObj.Access = GL_READ_WRITE; 320 imgObj.Format = format; 321 imgObj._ActualFormat = _mesa_get_shader_image_format(format); 322 323 if (_mesa_tex_target_is_layered(texObj->Target)) { 324 imgObj.Layered = layered; 325 imgObj.Layer = layer; 326 imgObj._Layer = (imgObj.Layered ? 0 : imgObj.Layer); 327 } else { 328 imgObj.Layered = GL_FALSE; 329 imgObj.Layer = 0; 330 imgObj._Layer = 0; 331 } 332 333 /* Request a new image handle from the driver. */ 334 handle = ctx->Driver.NewImageHandle(ctx, &imgObj); 335 if (!handle) { 336 mtx_unlock(&ctx->Shared->HandlesMutex); 337 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glGetImageHandleARB()"); 338 return 0; 339 } 340 341 imgHandleObj = CALLOC_STRUCT(gl_image_handle_object); 342 if (!imgHandleObj) { 343 mtx_unlock(&ctx->Shared->HandlesMutex); 344 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glGetImageHandleARB()"); 345 return 0; 346 } 347 348 /* Store the handle into the texture object. */ 349 memcpy(&imgHandleObj->imgObj, &imgObj, sizeof(struct gl_image_unit)); 350 imgHandleObj->handle = handle; 351 util_dynarray_append(&texObj->ImageHandles, 352 struct gl_image_handle_object *, imgHandleObj); 353 354 /* When referenced by one or more handles, texture objects are immutable. */ 355 texObj->HandleAllocated = true; 356 if (texObj->Target == GL_TEXTURE_BUFFER) 357 texObj->BufferObject->HandleAllocated = true; 358 texObj->Sampler.HandleAllocated = true; 359 360 /* Store the handle in the shared state for all contexts. */ 361 _mesa_hash_table_u64_insert(ctx->Shared->ImageHandles, handle, imgHandleObj); 362 mtx_unlock(&ctx->Shared->HandlesMutex); 363 364 return handle; 365 } 366 367 /** 368 * Init/free per-context resident handles. 369 */ 370 void 371 _mesa_init_resident_handles(struct gl_context *ctx) 372 { 373 ctx->ResidentTextureHandles = _mesa_hash_table_u64_create(NULL); 374 ctx->ResidentImageHandles = _mesa_hash_table_u64_create(NULL); 375 } 376 377 void 378 _mesa_free_resident_handles(struct gl_context *ctx) 379 { 380 _mesa_hash_table_u64_destroy(ctx->ResidentTextureHandles, NULL); 381 _mesa_hash_table_u64_destroy(ctx->ResidentImageHandles, NULL); 382 } 383 384 /** 385 * Init/free shared allocated handles. 386 */ 387 void 388 _mesa_init_shared_handles(struct gl_shared_state *shared) 389 { 390 shared->TextureHandles = _mesa_hash_table_u64_create(NULL); 391 shared->ImageHandles = _mesa_hash_table_u64_create(NULL); 392 mtx_init(&shared->HandlesMutex, mtx_recursive); 393 } 394 395 void 396 _mesa_free_shared_handles(struct gl_shared_state *shared) 397 { 398 if (shared->TextureHandles) 399 _mesa_hash_table_u64_destroy(shared->TextureHandles, NULL); 400 401 if (shared->ImageHandles) 402 _mesa_hash_table_u64_destroy(shared->ImageHandles, NULL); 403 404 mtx_destroy(&shared->HandlesMutex); 405 } 406 407 /** 408 * Init/free texture/image handles per-texture object. 409 */ 410 void 411 _mesa_init_texture_handles(struct gl_texture_object *texObj) 412 { 413 util_dynarray_init(&texObj->SamplerHandles, NULL); 414 util_dynarray_init(&texObj->ImageHandles, NULL); 415 } 416 417 void 418 _mesa_make_texture_handles_non_resident(struct gl_context *ctx, 419 struct gl_texture_object *texObj) 420 { 421 mtx_lock(&ctx->Shared->HandlesMutex); 422 423 /* Texture handles */ 424 util_dynarray_foreach(&texObj->SamplerHandles, 425 struct gl_texture_handle_object *, texHandleObj) { 426 if (is_texture_handle_resident(ctx, (*texHandleObj)->handle)) 427 make_texture_handle_resident(ctx, *texHandleObj, false); 428 } 429 430 /* Image handles */ 431 util_dynarray_foreach(&texObj->ImageHandles, 432 struct gl_image_handle_object *, imgHandleObj) { 433 if (is_image_handle_resident(ctx, (*imgHandleObj)->handle)) 434 make_image_handle_resident(ctx, *imgHandleObj, GL_READ_ONLY, false); 435 } 436 437 mtx_unlock(&ctx->Shared->HandlesMutex); 438 } 439 440 void 441 _mesa_delete_texture_handles(struct gl_context *ctx, 442 struct gl_texture_object *texObj) 443 { 444 /* Texture handles */ 445 util_dynarray_foreach(&texObj->SamplerHandles, 446 struct gl_texture_handle_object *, texHandleObj) { 447 struct gl_sampler_object *sampObj = (*texHandleObj)->sampObj; 448 449 if (sampObj) { 450 /* Delete the handle in the separate sampler object. */ 451 util_dynarray_delete_unordered(&sampObj->Handles, 452 struct gl_texture_handle_object *, 453 *texHandleObj); 454 } 455 delete_texture_handle(ctx, (*texHandleObj)->handle); 456 free(*texHandleObj); 457 } 458 util_dynarray_fini(&texObj->SamplerHandles); 459 460 /* Image handles */ 461 util_dynarray_foreach(&texObj->ImageHandles, 462 struct gl_image_handle_object *, imgHandleObj) { 463 delete_image_handle(ctx, (*imgHandleObj)->handle); 464 free(*imgHandleObj); 465 } 466 util_dynarray_fini(&texObj->ImageHandles); 467 } 468 469 /** 470 * Init/free texture handles per-sampler object. 471 */ 472 void 473 _mesa_init_sampler_handles(struct gl_sampler_object *sampObj) 474 { 475 util_dynarray_init(&sampObj->Handles, NULL); 476 } 477 478 void 479 _mesa_delete_sampler_handles(struct gl_context *ctx, 480 struct gl_sampler_object *sampObj) 481 { 482 util_dynarray_foreach(&sampObj->Handles, 483 struct gl_texture_handle_object *, texHandleObj) { 484 struct gl_texture_object *texObj = (*texHandleObj)->texObj; 485 486 /* Delete the handle in the texture object. */ 487 util_dynarray_delete_unordered(&texObj->SamplerHandles, 488 struct gl_texture_handle_object *, 489 *texHandleObj); 490 491 delete_texture_handle(ctx, (*texHandleObj)->handle); 492 free(*texHandleObj); 493 } 494 util_dynarray_fini(&sampObj->Handles); 495 } 496 497 static GLboolean 498 is_sampler_border_color_valid(struct gl_sampler_object *samp) 499 { 500 static const GLfloat valid_float_border_colors[4][4] = { 501 { 0.0, 0.0, 0.0, 0.0 }, 502 { 0.0, 0.0, 0.0, 1.0 }, 503 { 1.0, 1.0, 1.0, 0.0 }, 504 { 1.0, 1.0, 1.0, 1.0 }, 505 }; 506 static const GLint valid_integer_border_colors[4][4] = { 507 { 0, 0, 0, 0 }, 508 { 0, 0, 0, 1 }, 509 { 1, 1, 1, 0 }, 510 { 1, 1, 1, 1 }, 511 }; 512 size_t size = sizeof(samp->BorderColor.ui); 513 514 /* The ARB_bindless_texture spec says: 515 * 516 * "The error INVALID_OPERATION is generated if the border color (taken from 517 * the embedded sampler for GetTextureHandleARB or from the <sampler> for 518 * GetTextureSamplerHandleARB) is not one of the following allowed values. 519 * If the texture's base internal format is signed or unsigned integer, 520 * allowed values are (0,0,0,0), (0,0,0,1), (1,1,1,0), and (1,1,1,1). If 521 * the base internal format is not integer, allowed values are 522 * (0.0,0.0,0.0,0.0), (0.0,0.0,0.0,1.0), (1.0,1.0,1.0,0.0), and 523 * (1.0,1.0,1.0,1.0)." 524 */ 525 if (!memcmp(samp->BorderColor.f, valid_float_border_colors[0], size) || 526 !memcmp(samp->BorderColor.f, valid_float_border_colors[1], size) || 527 !memcmp(samp->BorderColor.f, valid_float_border_colors[2], size) || 528 !memcmp(samp->BorderColor.f, valid_float_border_colors[3], size)) 529 return GL_TRUE; 530 531 if (!memcmp(samp->BorderColor.ui, valid_integer_border_colors[0], size) || 532 !memcmp(samp->BorderColor.ui, valid_integer_border_colors[1], size) || 533 !memcmp(samp->BorderColor.ui, valid_integer_border_colors[2], size) || 534 !memcmp(samp->BorderColor.ui, valid_integer_border_colors[3], size)) 535 return GL_TRUE; 536 537 return GL_FALSE; 538 } 539 540 GLuint64 GLAPIENTRY 541 _mesa_GetTextureHandleARB_no_error(GLuint texture) 542 { 543 struct gl_texture_object *texObj; 544 545 GET_CURRENT_CONTEXT(ctx); 546 547 texObj = _mesa_lookup_texture(ctx, texture); 548 if (!_mesa_is_texture_complete(texObj, &texObj->Sampler)) 549 _mesa_test_texobj_completeness(ctx, texObj); 550 551 return get_texture_handle(ctx, texObj, &texObj->Sampler); 552 } 553 554 GLuint64 GLAPIENTRY 555 _mesa_GetTextureHandleARB(GLuint texture) 556 { 557 struct gl_texture_object *texObj = NULL; 558 559 GET_CURRENT_CONTEXT(ctx); 560 561 if (!_mesa_has_ARB_bindless_texture(ctx)) { 562 _mesa_error(ctx, GL_INVALID_OPERATION, 563 "glGetTextureHandleARB(unsupported)"); 564 return 0; 565 } 566 567 /* The ARB_bindless_texture spec says: 568 * 569 * "The error INVALID_VALUE is generated by GetTextureHandleARB or 570 * GetTextureSamplerHandleARB if <texture> is zero or not the name of an 571 * existing texture object." 572 */ 573 if (texture > 0) 574 texObj = _mesa_lookup_texture(ctx, texture); 575 576 if (!texObj) { 577 _mesa_error(ctx, GL_INVALID_VALUE, "glGetTextureHandleARB(texture)"); 578 return 0; 579 } 580 581 /* The ARB_bindless_texture spec says: 582 * 583 * "The error INVALID_OPERATION is generated by GetTextureHandleARB or 584 * GetTextureSamplerHandleARB if the texture object specified by <texture> 585 * is not complete." 586 */ 587 if (!_mesa_is_texture_complete(texObj, &texObj->Sampler)) { 588 _mesa_test_texobj_completeness(ctx, texObj); 589 if (!_mesa_is_texture_complete(texObj, &texObj->Sampler)) { 590 _mesa_error(ctx, GL_INVALID_OPERATION, 591 "glGetTextureHandleARB(incomplete texture)"); 592 return 0; 593 } 594 } 595 596 if (!is_sampler_border_color_valid(&texObj->Sampler)) { 597 _mesa_error(ctx, GL_INVALID_OPERATION, 598 "glGetTextureHandleARB(invalid border color)"); 599 return 0; 600 } 601 602 return get_texture_handle(ctx, texObj, &texObj->Sampler); 603 } 604 605 GLuint64 GLAPIENTRY 606 _mesa_GetTextureSamplerHandleARB_no_error(GLuint texture, GLuint sampler) 607 { 608 struct gl_texture_object *texObj; 609 struct gl_sampler_object *sampObj; 610 611 GET_CURRENT_CONTEXT(ctx); 612 613 texObj = _mesa_lookup_texture(ctx, texture); 614 sampObj = _mesa_lookup_samplerobj(ctx, sampler); 615 616 if (!_mesa_is_texture_complete(texObj, sampObj)) 617 _mesa_test_texobj_completeness(ctx, texObj); 618 619 return get_texture_handle(ctx, texObj, sampObj); 620 } 621 622 GLuint64 GLAPIENTRY 623 _mesa_GetTextureSamplerHandleARB(GLuint texture, GLuint sampler) 624 { 625 struct gl_texture_object *texObj = NULL; 626 struct gl_sampler_object *sampObj; 627 628 GET_CURRENT_CONTEXT(ctx); 629 630 if (!_mesa_has_ARB_bindless_texture(ctx)) { 631 _mesa_error(ctx, GL_INVALID_OPERATION, 632 "glGetTextureSamplerHandleARB(unsupported)"); 633 return 0; 634 } 635 636 /* The ARB_bindless_texture spec says: 637 * 638 * "The error INVALID_VALUE is generated by GetTextureHandleARB or 639 * GetTextureSamplerHandleARB if <texture> is zero or not the name of an 640 * existing texture object." 641 */ 642 if (texture > 0) 643 texObj = _mesa_lookup_texture(ctx, texture); 644 645 if (!texObj) { 646 _mesa_error(ctx, GL_INVALID_VALUE, 647 "glGetTextureSamplerHandleARB(texture)"); 648 return 0; 649 } 650 651 /* The ARB_bindless_texture spec says: 652 * 653 * "The error INVALID_VALUE is generated by GetTextureSamplerHandleARB if 654 * <sampler> is zero or is not the name of an existing sampler object." 655 */ 656 sampObj = _mesa_lookup_samplerobj(ctx, sampler); 657 if (!sampObj) { 658 _mesa_error(ctx, GL_INVALID_VALUE, 659 "glGetTextureSamplerHandleARB(sampler)"); 660 return 0; 661 } 662 663 /* The ARB_bindless_texture spec says: 664 * 665 * "The error INVALID_OPERATION is generated by GetTextureHandleARB or 666 * GetTextureSamplerHandleARB if the texture object specified by <texture> 667 * is not complete." 668 */ 669 if (!_mesa_is_texture_complete(texObj, sampObj)) { 670 _mesa_test_texobj_completeness(ctx, texObj); 671 if (!_mesa_is_texture_complete(texObj, sampObj)) { 672 _mesa_error(ctx, GL_INVALID_OPERATION, 673 "glGetTextureSamplerHandleARB(incomplete texture)"); 674 return 0; 675 } 676 } 677 678 if (!is_sampler_border_color_valid(sampObj)) { 679 _mesa_error(ctx, GL_INVALID_OPERATION, 680 "glGetTextureSamplerHandleARB(invalid border color)"); 681 return 0; 682 } 683 684 return get_texture_handle(ctx, texObj, sampObj); 685 } 686 687 void GLAPIENTRY 688 _mesa_MakeTextureHandleResidentARB_no_error(GLuint64 handle) 689 { 690 struct gl_texture_handle_object *texHandleObj; 691 692 GET_CURRENT_CONTEXT(ctx); 693 694 texHandleObj = lookup_texture_handle(ctx, handle); 695 make_texture_handle_resident(ctx, texHandleObj, true); 696 } 697 698 void GLAPIENTRY 699 _mesa_MakeTextureHandleResidentARB(GLuint64 handle) 700 { 701 struct gl_texture_handle_object *texHandleObj; 702 703 GET_CURRENT_CONTEXT(ctx); 704 705 if (!_mesa_has_ARB_bindless_texture(ctx)) { 706 _mesa_error(ctx, GL_INVALID_OPERATION, 707 "glMakeTextureHandleResidentARB(unsupported)"); 708 return; 709 } 710 711 /* The ARB_bindless_texture spec says: 712 * 713 * "The error INVALID_OPERATION is generated by MakeTextureHandleResidentARB 714 * if <handle> is not a valid texture handle, or if <handle> is already 715 * resident in the current GL context." 716 */ 717 texHandleObj = lookup_texture_handle(ctx, handle); 718 if (!texHandleObj) { 719 _mesa_error(ctx, GL_INVALID_OPERATION, 720 "glMakeTextureHandleResidentARB(handle)"); 721 return; 722 } 723 724 if (is_texture_handle_resident(ctx, handle)) { 725 _mesa_error(ctx, GL_INVALID_OPERATION, 726 "glMakeTextureHandleResidentARB(already resident)"); 727 return; 728 } 729 730 make_texture_handle_resident(ctx, texHandleObj, true); 731 } 732 733 void GLAPIENTRY 734 _mesa_MakeTextureHandleNonResidentARB_no_error(GLuint64 handle) 735 { 736 struct gl_texture_handle_object *texHandleObj; 737 738 GET_CURRENT_CONTEXT(ctx); 739 740 texHandleObj = lookup_texture_handle(ctx, handle); 741 make_texture_handle_resident(ctx, texHandleObj, false); 742 } 743 744 void GLAPIENTRY 745 _mesa_MakeTextureHandleNonResidentARB(GLuint64 handle) 746 { 747 struct gl_texture_handle_object *texHandleObj; 748 749 GET_CURRENT_CONTEXT(ctx); 750 751 if (!_mesa_has_ARB_bindless_texture(ctx)) { 752 _mesa_error(ctx, GL_INVALID_OPERATION, 753 "glMakeTextureHandleNonResidentARB(unsupported)"); 754 return; 755 } 756 757 /* The ARB_bindless_texture spec says: 758 * 759 * "The error INVALID_OPERATION is generated by 760 * MakeTextureHandleNonResidentARB if <handle> is not a valid texture 761 * handle, or if <handle> is not resident in the current GL context." 762 */ 763 texHandleObj = lookup_texture_handle(ctx, handle); 764 if (!texHandleObj) { 765 _mesa_error(ctx, GL_INVALID_OPERATION, 766 "glMakeTextureHandleNonResidentARB(handle)"); 767 return; 768 } 769 770 if (!is_texture_handle_resident(ctx, handle)) { 771 _mesa_error(ctx, GL_INVALID_OPERATION, 772 "glMakeTextureHandleNonResidentARB(not resident)"); 773 return; 774 } 775 776 make_texture_handle_resident(ctx, texHandleObj, false); 777 } 778 779 GLuint64 GLAPIENTRY 780 _mesa_GetImageHandleARB_no_error(GLuint texture, GLint level, GLboolean layered, 781 GLint layer, GLenum format) 782 { 783 struct gl_texture_object *texObj; 784 785 GET_CURRENT_CONTEXT(ctx); 786 787 texObj = _mesa_lookup_texture(ctx, texture); 788 if (!_mesa_is_texture_complete(texObj, &texObj->Sampler)) 789 _mesa_test_texobj_completeness(ctx, texObj); 790 791 return get_image_handle(ctx, texObj, level, layered, layer, format); 792 } 793 794 GLuint64 GLAPIENTRY 795 _mesa_GetImageHandleARB(GLuint texture, GLint level, GLboolean layered, 796 GLint layer, GLenum format) 797 { 798 struct gl_texture_object *texObj = NULL; 799 800 GET_CURRENT_CONTEXT(ctx); 801 802 if (!_mesa_has_ARB_bindless_texture(ctx) || 803 !_mesa_has_ARB_shader_image_load_store(ctx)) { 804 _mesa_error(ctx, GL_INVALID_OPERATION, 805 "glGetImageHandleARB(unsupported)"); 806 return 0; 807 } 808 809 /* The ARB_bindless_texture spec says: 810 * 811 * "The error INVALID_VALUE is generated by GetImageHandleARB if <texture> 812 * is zero or not the name of an existing texture object, if the image for 813 * <level> does not existing in <texture>, or if <layered> is FALSE and 814 * <layer> is greater than or equal to the number of layers in the image at 815 * <level>." 816 */ 817 if (texture > 0) 818 texObj = _mesa_lookup_texture(ctx, texture); 819 820 if (!texObj) { 821 _mesa_error(ctx, GL_INVALID_VALUE, "glGetImageHandleARB(texture)"); 822 return 0; 823 } 824 825 if (level < 0 || level >= _mesa_max_texture_levels(ctx, texObj->Target)) { 826 _mesa_error(ctx, GL_INVALID_VALUE, "glGetImageHandleARB(level)"); 827 return 0; 828 } 829 830 if (!layered && layer > _mesa_get_texture_layers(texObj, level)) { 831 _mesa_error(ctx, GL_INVALID_VALUE, "glGetImageHandleARB(layer)"); 832 return 0; 833 } 834 835 if (!_mesa_is_shader_image_format_supported(ctx, format)) { 836 _mesa_error(ctx, GL_INVALID_VALUE, "glGetImageHandleARB(format)"); 837 return 0; 838 } 839 840 /* The ARB_bindless_texture spec says: 841 * 842 * "The error INVALID_OPERATION is generated by GetImageHandleARB if the 843 * texture object <texture> is not complete or if <layered> is TRUE and 844 * <texture> is not a three-dimensional, one-dimensional array, two 845 * dimensional array, cube map, or cube map array texture." 846 */ 847 if (!_mesa_is_texture_complete(texObj, &texObj->Sampler)) { 848 _mesa_test_texobj_completeness(ctx, texObj); 849 if (!_mesa_is_texture_complete(texObj, &texObj->Sampler)) { 850 _mesa_error(ctx, GL_INVALID_OPERATION, 851 "glGetImageHandleARB(incomplete texture)"); 852 return 0; 853 } 854 } 855 856 if (layered && !_mesa_tex_target_is_layered(texObj->Target)) { 857 _mesa_error(ctx, GL_INVALID_OPERATION, 858 "glGetImageHandleARB(not layered)"); 859 return 0; 860 } 861 862 return get_image_handle(ctx, texObj, level, layered, layer, format); 863 } 864 865 void GLAPIENTRY 866 _mesa_MakeImageHandleResidentARB_no_error(GLuint64 handle, GLenum access) 867 { 868 struct gl_image_handle_object *imgHandleObj; 869 870 GET_CURRENT_CONTEXT(ctx); 871 872 imgHandleObj = lookup_image_handle(ctx, handle); 873 make_image_handle_resident(ctx, imgHandleObj, access, true); 874 } 875 876 void GLAPIENTRY 877 _mesa_MakeImageHandleResidentARB(GLuint64 handle, GLenum access) 878 { 879 struct gl_image_handle_object *imgHandleObj; 880 881 GET_CURRENT_CONTEXT(ctx); 882 883 if (!_mesa_has_ARB_bindless_texture(ctx) || 884 !_mesa_has_ARB_shader_image_load_store(ctx)) { 885 _mesa_error(ctx, GL_INVALID_OPERATION, 886 "glMakeImageHandleResidentARB(unsupported)"); 887 return; 888 } 889 890 if (access != GL_READ_ONLY && 891 access != GL_WRITE_ONLY && 892 access != GL_READ_WRITE) { 893 _mesa_error(ctx, GL_INVALID_ENUM, 894 "glMakeImageHandleResidentARB(access)"); 895 return; 896 } 897 898 /* The ARB_bindless_texture spec says: 899 * 900 * "The error INVALID_OPERATION is generated by MakeImageHandleResidentARB 901 * if <handle> is not a valid image handle, or if <handle> is already 902 * resident in the current GL context." 903 */ 904 imgHandleObj = lookup_image_handle(ctx, handle); 905 if (!imgHandleObj) { 906 _mesa_error(ctx, GL_INVALID_OPERATION, 907 "glMakeImageHandleResidentARB(handle)"); 908 return; 909 } 910 911 if (is_image_handle_resident(ctx, handle)) { 912 _mesa_error(ctx, GL_INVALID_OPERATION, 913 "glMakeImageHandleResidentARB(already resident)"); 914 return; 915 } 916 917 make_image_handle_resident(ctx, imgHandleObj, access, true); 918 } 919 920 void GLAPIENTRY 921 _mesa_MakeImageHandleNonResidentARB_no_error(GLuint64 handle) 922 { 923 struct gl_image_handle_object *imgHandleObj; 924 925 GET_CURRENT_CONTEXT(ctx); 926 927 imgHandleObj = lookup_image_handle(ctx, handle); 928 make_image_handle_resident(ctx, imgHandleObj, GL_READ_ONLY, false); 929 } 930 931 void GLAPIENTRY 932 _mesa_MakeImageHandleNonResidentARB(GLuint64 handle) 933 { 934 struct gl_image_handle_object *imgHandleObj; 935 936 GET_CURRENT_CONTEXT(ctx); 937 938 if (!_mesa_has_ARB_bindless_texture(ctx) || 939 !_mesa_has_ARB_shader_image_load_store(ctx)) { 940 _mesa_error(ctx, GL_INVALID_OPERATION, 941 "glMakeImageHandleNonResidentARB(unsupported)"); 942 return; 943 } 944 945 /* The ARB_bindless_texture spec says: 946 * 947 * "The error INVALID_OPERATION is generated by 948 * MakeImageHandleNonResidentARB if <handle> is not a valid image handle, 949 * or if <handle> is not resident in the current GL context." 950 */ 951 imgHandleObj = lookup_image_handle(ctx, handle); 952 if (!imgHandleObj) { 953 _mesa_error(ctx, GL_INVALID_OPERATION, 954 "glMakeImageHandleNonResidentARB(handle)"); 955 return; 956 } 957 958 if (!is_image_handle_resident(ctx, handle)) { 959 _mesa_error(ctx, GL_INVALID_OPERATION, 960 "glMakeImageHandleNonResidentARB(not resident)"); 961 return; 962 } 963 964 make_image_handle_resident(ctx, imgHandleObj, GL_READ_ONLY, false); 965 } 966 967 GLboolean GLAPIENTRY 968 _mesa_IsTextureHandleResidentARB_no_error(GLuint64 handle) 969 { 970 GET_CURRENT_CONTEXT(ctx); 971 return is_texture_handle_resident(ctx, handle); 972 } 973 974 GLboolean GLAPIENTRY 975 _mesa_IsTextureHandleResidentARB(GLuint64 handle) 976 { 977 GET_CURRENT_CONTEXT(ctx); 978 979 if (!_mesa_has_ARB_bindless_texture(ctx)) { 980 _mesa_error(ctx, GL_INVALID_OPERATION, 981 "glIsTextureHandleResidentARB(unsupported)"); 982 return GL_FALSE; 983 } 984 985 /* The ARB_bindless_texture spec says: 986 * 987 * "The error INVALID_OPERATION will be generated by 988 * IsTextureHandleResidentARB and IsImageHandleResidentARB if <handle> is 989 * not a valid texture or image handle, respectively." 990 */ 991 if (!lookup_texture_handle(ctx, handle)) { 992 _mesa_error(ctx, GL_INVALID_OPERATION, 993 "glIsTextureHandleResidentARB(handle)"); 994 return GL_FALSE; 995 } 996 997 return is_texture_handle_resident(ctx, handle); 998 } 999 1000 GLboolean GLAPIENTRY 1001 _mesa_IsImageHandleResidentARB_no_error(GLuint64 handle) 1002 { 1003 GET_CURRENT_CONTEXT(ctx); 1004 return is_image_handle_resident(ctx, handle); 1005 } 1006 1007 GLboolean GLAPIENTRY 1008 _mesa_IsImageHandleResidentARB(GLuint64 handle) 1009 { 1010 GET_CURRENT_CONTEXT(ctx); 1011 1012 if (!_mesa_has_ARB_bindless_texture(ctx) || 1013 !_mesa_has_ARB_shader_image_load_store(ctx)) { 1014 _mesa_error(ctx, GL_INVALID_OPERATION, 1015 "glIsImageHandleResidentARB(unsupported)"); 1016 return GL_FALSE; 1017 } 1018 1019 /* The ARB_bindless_texture spec says: 1020 * 1021 * "The error INVALID_OPERATION will be generated by 1022 * IsTextureHandleResidentARB and IsImageHandleResidentARB if <handle> is 1023 * not a valid texture or image handle, respectively." 1024 */ 1025 if (!lookup_image_handle(ctx, handle)) { 1026 _mesa_error(ctx, GL_INVALID_OPERATION, 1027 "glIsImageHandleResidentARB(handle)"); 1028 return GL_FALSE; 1029 } 1030 1031 return is_image_handle_resident(ctx, handle); 1032 } 1033
