alice.mosphere.at / sdl-gpu
this repo has no description
0
fork

Configure Feed

Select the types of activity you want to include in your feed.

Merge branch 'appveyor-prep'

Jonathan Dearborn 3304ceb3 130bb258

+223 -62
+28 -19
.appveyor.yml
··· 1 + # If this file isn't being read correctly by Appveyor, make sure the Github connection is correct/reset. 1 2 environment: 2 3 P: "c:/projects/libs" 3 - # ACCOUNT: 4 - # secure: 5 4 6 5 branches: 7 6 only: 8 - - master 7 + - appveyor-prep 8 + 9 + version: '{build}' 9 10 10 - os: Visual Studio 2015 11 + image: 12 + - Visual Studio 2019 11 13 12 14 init: 13 15 - git config --global core.autocrlf input 14 - 16 + - echo %APPVEYOR_BUILD_WORKER_IMAGE% 17 + - if "%APPVEYOR_BUILD_WORKER_IMAGE%"=="Visual Studio 2019" ( set generator="Visual Studio 16 2019" ) 18 + - echo %generator% 15 19 16 20 17 21 shallow_clone: true ··· 20 24 install: 21 25 - mkdir c:\projects\libs 22 26 # Download SDL. 23 - - ps: Start-FileDownload 'https://www.libsdl.org/release/SDL2-devel-2.0.5-VC.zip' 'c:/projects/libs/SDL.zip' 27 + - ps: Start-FileDownload 'https://www.libsdl.org/release/SDL2-devel-2.0.12-VC.zip' 'c:/projects/libs/SDL.zip' 24 28 25 29 # Extract it, put it in the right place, and rename it. 26 - - cd c:\projects\libs && 7z x SDL.zip && ren SDL2-2.0.5 SDL2 && cd c:\projects\SDL_gpu 30 + - cd c:\projects\libs && 7z x SDL.zip && ren SDL2-2.0.12 SDL2 && cd c:\projects\SDL_gpu 27 31 28 32 29 33 platform: 30 - - x86 34 + - Win32 31 35 - x64 32 36 33 37 configuration: 34 38 - Debug 35 39 - Release 36 40 37 - build: 38 - project: build\INSTALL.vcxproj 39 - 40 - # scripts to run before build 41 41 before_build: 42 - - echo Running cmake... 43 42 - cd c:\projects\SDL_gpu 43 + - set /p project_version=<version.txt 44 + - set zip_name=SDL_gpu-%project_version%-VS-%platform%-%configuration%.zip 45 + - echo "Building %zip_name%" 46 + - echo "Platform %platform%" 47 + - echo "generator %generator%" 48 + - echo Running cmake... 44 49 - mkdir build 45 50 - cd build 46 - - cmake -G "Visual Studio 14 2015" -DCMAKE_INSTALL_PREFIX=c:\projects\libs\SDL2 -DSDL_gpu_BUILD_DEMOS=ON -DSDL_gpu_BUILD_TESTS=ON -DSDL_gpu_BUILD_TOOLS=ON -DSDL_gpu_BUILD_SHARED=ON -DSDL_gpu_BUILD_STATIC=ON .. 51 + - if "%configuration%"=="Debug" ( set build_tests=ON ) 52 + - if "%configuration%"=="Debug" ( set build_demos=OFF ) 53 + - if "%configuration%"=="Release" ( set build_tests=OFF ) 54 + - if "%configuration%"=="Release" ( set build_demos=ON ) 55 + - cmd: cmake -G %generator% -A %platform% -DCMAKE_INSTALL_PREFIX=c:\projects\libs\SDL2 -DSDL_gpu_BUILD_DEMOS=%build_demos% -DSDL_gpu_BUILD_TESTS=%build_tests% -DSDL_gpu_BUILD_TOOLS=%build_demos% -DSDL_gpu_BUILD_SHARED=ON -DSDL_gpu_BUILD_STATIC=ON .. 47 56 48 - # scripts to run after build 49 57 after_build: 50 - - cd c:\projects\SDL_gpu\build 51 - - 7z a c:\projects\SDL_gpu\SDL_gpu.zip * -tzip 58 + - cd c:\projects\SDL_gpu\build\SDL_gpu-VS 59 + # - cmd: cmake -P cmake_install.cmake 60 + - 7z a c:\projects\SDL_gpu\%zip_name% * -tzip 52 61 - cd c:\projects\SDL_gpu 53 62 54 63 artifacts: 55 - - path: SDL_gpu.zip 56 - name: SDL_gpu.zip 64 + - path: "%zip_name%" 65 + name: "%zip_name%" 57 66 58 67 deploy_script: 59 68 - cd c:\projects\SDL_gpu
+34 -2
CMakeLists.txt
··· 1 - cmake_minimum_required(VERSION 2.6) 1 + cmake_minimum_required(VERSION 3.0) 2 2 3 3 project(SDL_gpu) 4 4 5 + file(READ ${CMAKE_CURRENT_SOURCE_DIR}/version.txt VERSION_FILE_CONTENTS) 5 6 7 + if((NOT DEFINED VERSION_MAJOR OR NOT DEFINED VERSION_MINOR OR NOT DEFINED VERSION_BUGFIX) AND VERSION_FILE_CONTENTS STREQUAL "") 8 + message(ERROR "Missing version.txt, VERSION_MAJOR, VERSION_MINOR, and VERSION_BUGFIX.") 9 + message(FATAL_ERROR "Failed to read version.txt and cannot proceed without a version number for SDL_gpu.") 10 + endif() 11 + 12 + if(NOT DEFINED VERSION_MAJOR) 13 + string(REGEX MATCH "^[0-9]+" VERSION_MAJOR ${VERSION_FILE_CONTENTS}) 14 + endif() 15 + if(NOT DEFINED VERSION_MINOR) 16 + string(REGEX MATCH "[.][0-9]+[.]" VERSION_MINOR ${VERSION_FILE_CONTENTS}) 17 + # Chop off the dots 18 + string(LENGTH ${VERSION_MINOR} VERSION_MINOR_LENGTH) 19 + math(EXPR VERSION_MINOR_LENGTH_MINUS_2 "${VERSION_MINOR_LENGTH}-2") 20 + string(SUBSTRING ${VERSION_MINOR} 1 ${VERSION_MINOR_LENGTH_MINUS_2} VERSION_MINOR) 21 + endif() 22 + if(NOT DEFINED VERSION_BUGFIX) 23 + string(REGEX MATCH "[0-9]+$" VERSION_BUGFIX ${VERSION_FILE_CONTENTS}) 24 + endif() 25 + 26 + set(SDL_gpu_VERSION "${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_BUGFIX}") 27 + 28 + message("Writing version header for v${SDL_gpu_VERSION}") 29 + string(CONCAT VERSION_HEADER_CONTENTS "#ifndef _SDL_GPU_VERSION_H__ 30 + #define _SDL_GPU_VERSION_H__ 31 + 32 + #define SDL_GPU_VERSION_MAJOR ${VERSION_MAJOR} 33 + #define SDL_GPU_VERSION_MINOR ${VERSION_MINOR} 34 + #define SDL_GPU_VERSION_PATCH ${VERSION_BUGFIX} 35 + 36 + #endif") 37 + file(WRITE ${CMAKE_CURRENT_SOURCE_DIR}/include/SDL_gpu_version.h ${VERSION_HEADER_CONTENTS}) 6 38 7 39 set(SDL_gpu_INSTALL_BY_DEFAULT ON) 8 40 set(SDL_gpu_DEFAULT_BUILD_SHARED ON) ··· 92 124 option(SDL_gpu_BUILD_SHARED "Build SDL_gpu shared libraries" ${SDL_gpu_DEFAULT_BUILD_SHARED}) 93 125 option(SDL_gpu_BUILD_STATIC "Build SDL_gpu static libraries" ${SDL_gpu_DEFAULT_BUILD_STATIC}) 94 126 95 - set(SDL_gpu_VERSION 0.11.0) 127 + set(SDL_gpu_VERSION ${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_BUGFIX}) 96 128 97 129 if (SDL_gpu_USE_SDL1) 98 130 set(SDL_gpu_LIBRARY SDL_gpu)
+102 -33
include/SDL_gpu.h
··· 12 12 extern "C" { 13 13 #endif 14 14 15 - // Compile-time versions 16 - #define SDL_GPU_VERSION_MAJOR 0 17 - #define SDL_GPU_VERSION_MINOR 11 18 - #define SDL_GPU_VERSION_PATCH 0 15 + // Compile-time version info 16 + #include "SDL_gpu_version.h" 19 17 20 18 /* Auto-detect if we're using the SDL2 API by the headers available. */ 21 19 #if SDL_VERSION_ATLEAST(2,0,0) ··· 59 57 #define GPU_bool int 60 58 #endif 61 59 60 + #if defined(_MSC_VER) || (defined(__INTEL_COMPILER) && defined(_WIN32)) 61 + #if defined(_M_X64) 62 + #define SDL_GPU_BITNESS 64 63 + #else 64 + #define SDL_GPU_BITNESS 32 65 + #endif 66 + #define SDL_GPU_LONG_SIZE 4 67 + #elif defined(__clang__) || defined(__INTEL_COMPILER) || defined(__GNUC__) 68 + #if defined(__x86_64) 69 + #define SDL_GPU_BITNESS 64 70 + #else 71 + #define SDL_GPU_BITNESS 32 72 + #endif 73 + #if __LONG_MAX__ == 2147483647L 74 + #define SDL_GPU_LONG_SIZE 4 75 + #else 76 + #define SDL_GPU_LONG_SIZE 8 77 + #endif 78 + #endif 79 + 80 + // Struct padding for 32 or 64 bit alignment 81 + #if SDL_GPU_BITNESS == 32 82 + #define GPU_PAD_1_TO_32 char _padding[1]; 83 + #define GPU_PAD_2_TO_32 char _padding[2]; 84 + #define GPU_PAD_3_TO_32 char _padding[3]; 85 + #define GPU_PAD_1_TO_64 char _padding[1]; 86 + #define GPU_PAD_2_TO_64 char _padding[2]; 87 + #define GPU_PAD_3_TO_64 char _padding[3]; 88 + #define GPU_PAD_4_TO_64 89 + #define GPU_PAD_5_TO_64 char _padding[1]; 90 + #define GPU_PAD_6_TO_64 char _padding[2]; 91 + #define GPU_PAD_7_TO_64 char _padding[3]; 92 + #elif SDL_GPU_BITNESS == 64 93 + #define GPU_PAD_1_TO_32 char _padding[1]; 94 + #define GPU_PAD_2_TO_32 char _padding[2]; 95 + #define GPU_PAD_3_TO_32 char _padding[3]; 96 + #define GPU_PAD_1_TO_64 char _padding[1]; 97 + #define GPU_PAD_2_TO_64 char _padding[2]; 98 + #define GPU_PAD_3_TO_64 char _padding[3]; 99 + #define GPU_PAD_4_TO_64 char _padding[4]; 100 + #define GPU_PAD_5_TO_64 char _padding[5]; 101 + #define GPU_PAD_6_TO_64 char _padding[6]; 102 + #define GPU_PAD_7_TO_64 char _padding[7]; 103 + #endif 104 + 62 105 #define GPU_FALSE 0 63 106 #define GPU_TRUE 1 64 107 ··· 122 165 GPU_RendererEnum renderer; 123 166 int major_version; 124 167 int minor_version; 168 + 169 + GPU_PAD_4_TO_64 125 170 } GPU_RendererID; 126 171 127 172 ··· 285 330 struct GPU_Renderer* renderer; 286 331 GPU_Target* context_target; 287 332 GPU_Target* target; 333 + void* data; 334 + 288 335 Uint16 w, h; 289 - GPU_bool using_virtual_resolution; 290 336 GPU_FormatEnum format; 291 337 int num_layers; 292 338 int bytes_per_pixel; 293 339 Uint16 base_w, base_h; // Original image dimensions 294 340 Uint16 texture_w, texture_h; // Underlying texture dimensions 295 - GPU_bool has_mipmaps; 296 341 297 342 float anchor_x; // Normalized coords for the point at which the image is blitted. Default is (0.5, 0.5), that is, the image is drawn centered. 298 343 float anchor_y; // These are interpreted according to GPU_SetCoordinateMode() and range from (0.0 - 1.0) normally. 299 344 300 345 SDL_Color color; 301 - GPU_bool use_blending; 302 346 GPU_BlendMode blend_mode; 303 347 GPU_FilterEnum filter_mode; 304 348 GPU_SnapEnum snap_mode; 305 349 GPU_WrapEnum wrap_mode_x; 306 350 GPU_WrapEnum wrap_mode_y; 307 351 308 - void* data; 309 352 int refcount; 353 + 354 + GPU_bool using_virtual_resolution; 355 + GPU_bool has_mipmaps; 356 + GPU_bool use_blending; 310 357 GPU_bool is_alias; 311 358 } GPU_Image; 312 359 ··· 330 377 float angle; 331 378 float zoom_x, zoom_y; 332 379 float z_near, z_far; // z clipping planes 333 - bool use_centered_origin; // move rotation/scaling origin to the center of the camera's view 380 + GPU_bool use_centered_origin; // move rotation/scaling origin to the center of the camera's view 381 + 382 + GPU_PAD_7_TO_64 334 383 } GPU_Camera; 335 384 336 385 ··· 373 422 { 374 423 /*! SDL_GLContext */ 375 424 void* context; 376 - GPU_bool failed; 425 + 426 + /*! Last target used */ 427 + GPU_Target* active_target; 428 + 429 + GPU_ShaderBlock current_shader_block; 430 + GPU_ShaderBlock default_textured_shader_block; 431 + GPU_ShaderBlock default_untextured_shader_block; 432 + 377 433 378 434 /*! SDL window ID */ 379 435 Uint32 windowID; ··· 391 447 int stored_window_h; 392 448 393 449 394 - /*! Last target used */ 395 - GPU_Target* active_target; 396 450 397 451 /*! Internal state */ 398 452 Uint32 current_shader_program; 399 453 Uint32 default_textured_shader_program; 400 454 Uint32 default_untextured_shader_program; 401 455 402 - GPU_ShaderBlock current_shader_block; 403 - GPU_ShaderBlock default_textured_shader_block; 404 - GPU_ShaderBlock default_untextured_shader_block; 405 - 406 - GPU_bool shapes_use_blending; 407 456 GPU_BlendMode shapes_blend_mode; 408 457 float line_thickness; 409 - GPU_bool use_texturing; 410 458 411 459 int refcount; 412 460 413 461 void* data; 462 + 463 + GPU_bool failed; 464 + GPU_bool use_texturing; 465 + GPU_bool shapes_use_blending; 466 + 467 + GPU_PAD_5_TO_64 414 468 } GPU_Context; 415 469 416 470 ··· 431 485 GPU_Image* image; 432 486 void* data; 433 487 Uint16 w, h; 434 - GPU_bool using_virtual_resolution; 435 488 Uint16 base_w, base_h; // The true dimensions of the underlying image or window 436 - GPU_bool use_clip_rect; 437 489 GPU_Rect clip_rect; 438 - GPU_bool use_color; 439 490 SDL_Color color; 440 491 441 492 GPU_Rect viewport; ··· 447 498 GPU_MatrixStack model_matrix; 448 499 449 500 GPU_Camera camera; 501 + 502 + GPU_bool using_virtual_resolution; 503 + GPU_bool use_clip_rect; 504 + GPU_bool use_color; 450 505 GPU_bool use_camera; 451 506 452 507 453 - GPU_bool use_depth_test; 454 - GPU_bool use_depth_write; 455 508 GPU_ComparisonEnum depth_function; 456 509 457 510 /*! Renderer context data. NULL if the target does not represent a window or rendering context. */ 458 511 GPU_Context* context; 459 512 int refcount; 513 + 514 + GPU_bool use_depth_test; 515 + GPU_bool use_depth_write; 460 516 GPU_bool is_alias; 517 + 518 + GPU_PAD_1_TO_64 461 519 }; 462 520 463 521 /*! \ingroup Initialization ··· 616 674 /*! \ingroup ShaderInterface */ 617 675 typedef struct GPU_AttributeFormat 618 676 { 619 - GPU_bool is_per_sprite; // Per-sprite values are expanded to 4 vertices 620 677 int num_elems_per_value; 621 678 GPU_TypeEnum type; // GPU_TYPE_FLOAT, GPU_TYPE_INT, GPU_TYPE_UNSIGNED_INT, etc. 622 - GPU_bool normalize; 623 679 int stride_bytes; // Number of bytes between two vertex specifications 624 680 int offset_bytes; // Number of bytes to skip at the beginning of 'values' 681 + GPU_bool is_per_sprite; // Per-sprite values are expanded to 4 vertices 682 + GPU_bool normalize; 683 + 684 + GPU_PAD_2_TO_32 625 685 } GPU_AttributeFormat; 626 686 627 687 /*! \ingroup ShaderInterface */ 628 688 typedef struct GPU_Attribute 629 689 { 630 - int location; 631 690 void* values; // Expect 4 values for each sprite 632 691 GPU_AttributeFormat format; 692 + int location; 693 + 694 + GPU_PAD_4_TO_64 633 695 } GPU_Attribute; 634 696 635 697 /*! \ingroup ShaderInterface */ 636 698 typedef struct GPU_AttributeSource 637 699 { 638 - GPU_bool enabled; 639 - int num_values; 640 700 void* next_value; 701 + void* per_vertex_storage; // Could point to the attribute's values or to allocated storage 702 + 703 + int num_values; 641 704 // Automatic storage format 642 705 int per_vertex_storage_stride_bytes; 643 706 int per_vertex_storage_offset_bytes; 644 707 int per_vertex_storage_size; // Over 0 means that the per-vertex storage has been automatically allocated 645 - void* per_vertex_storage; // Could point to the attribute's values or to allocated storage 646 708 GPU_Attribute attribute; 709 + GPU_bool enabled; 710 + 711 + GPU_PAD_7_TO_64 647 712 } GPU_AttributeSource; 648 713 649 714 ··· 666 731 typedef struct GPU_ErrorObject 667 732 { 668 733 char* function; 669 - GPU_ErrorEnum error; 670 734 char* details; 735 + GPU_ErrorEnum error; 736 + 737 + GPU_PAD_4_TO_64 671 738 } GPU_ErrorObject; 672 739 673 740 ··· 716 783 /*! Current display target */ 717 784 GPU_Target* current_context_target; 718 785 719 - /*! 0 for inverted, 1 for mathematical */ 720 - GPU_bool coordinate_mode; 721 - 722 786 /*! Default is (0.5, 0.5) - images draw centered. */ 723 787 float default_image_anchor_x; 724 788 float default_image_anchor_y; 725 789 726 790 struct GPU_RendererImpl* impl; 791 + 792 + /*! 0 for inverted, 1 for mathematical */ 793 + GPU_bool coordinate_mode; 794 + 795 + GPU_PAD_7_TO_64 727 796 }; 728 797 729 798
+8
include/SDL_gpu_version.h
··· 1 + #ifndef _SDL_GPU_VERSION_H__ 2 + #define _SDL_GPU_VERSION_H__ 3 + 4 + #define SDL_GPU_VERSION_MAJOR 0 5 + #define SDL_GPU_VERSION_MINOR 12 6 + #define SDL_GPU_VERSION_PATCH 0 7 + 8 + #endif
+3 -3
src/CMakeLists.txt
··· 76 76 endif(WIN32) 77 77 78 78 if(MSVC) 79 - set(OUTPUT_DIR SDL_gpu-VS-${SDL_gpu_VERSION}) 79 + set(OUTPUT_DIR SDL_gpu-VS) 80 80 elseif(MINGW) 81 - set(OUTPUT_DIR SDL_gpu-MINGW-${SDL_gpu_VERSION}) 81 + set(OUTPUT_DIR SDL_gpu-MINGW) 82 82 else() 83 - set(OUTPUT_DIR SDL_gpu-${SDL_gpu_VERSION}) 83 + set(OUTPUT_DIR SDL_gpu) 84 84 endif() 85 85 86 86 if(APPLE)
+6 -1
src/SDL_gpu.c
··· 15 15 #pragma warning(push) 16 16 // Visual Studio wants to complain about while(0) 17 17 #pragma warning(disable: 4127) 18 + 19 + // Disable warning: selection for inlining 20 + #pragma warning(disable: 4514 4711) 21 + // Disable warning: Spectre mitigation 22 + #pragma warning(disable: 5045) 18 23 #endif 19 24 20 25 #include "stb_image.h" ··· 783 788 GPU_ErrorObject GPU_PopErrorCode(void) 784 789 { 785 790 unsigned int i; 786 - GPU_ErrorObject result = {NULL, GPU_ERROR_NONE, NULL}; 791 + GPU_ErrorObject result = {NULL, NULL, GPU_ERROR_NONE}; 787 792 788 793 gpu_init_error_queue(); 789 794
+7 -2
src/SDL_gpu_matrix.c
··· 4 4 5 5 #ifdef _MSC_VER 6 6 #define __func__ __FUNCTION__ 7 + // Disable warning: selection for inlining 8 + #pragma warning(disable: 4514 4711) 9 + // Disable warning: Spectre mitigation 10 + #pragma warning(disable: 5045) 7 11 #endif 12 + 8 13 9 14 #ifndef PI 10 15 #define PI 3.1415926f ··· 89 94 90 95 void GPU_CopyMatrixStack(const GPU_MatrixStack* source, GPU_MatrixStack* dest) 91 96 { 92 - int i; 97 + unsigned int i; 93 98 unsigned int matrix_size = sizeof(float) * 16; 94 99 if (source == NULL || dest == NULL) 95 100 return; ··· 106 111 107 112 void GPU_ClearMatrixStack(GPU_MatrixStack* stack) 108 113 { 109 - int i; 114 + unsigned int i; 110 115 for (i = 0; i < stack->storage_size; ++i) 111 116 { 112 117 SDL_free(stack->matrix[i]);
+4
src/SDL_gpu_renderer.c
··· 6 6 #include <strings.h> 7 7 #else 8 8 #define __func__ __FUNCTION__ 9 + // Disable warning: selection for inlining 10 + #pragma warning(disable: 4514 4711) 11 + // Disable warning: Spectre mitigation 12 + #pragma warning(disable: 5045) 9 13 #endif 10 14 11 15 #define GPU_MAX_ACTIVE_RENDERERS 20
+7
src/SDL_gpu_shapes.c
··· 2 2 #include "SDL_gpu_RendererImpl.h" 3 3 #include <string.h> 4 4 5 + #ifdef _MSC_VER 6 + // Disable warning: selection for inlining 7 + #pragma warning(disable: 4514 4711) 8 + // Disable warning: Spectre mitigation 9 + #pragma warning(disable: 5045) 10 + #endif 11 + 5 12 #define CHECK_RENDERER() \ 6 13 GPU_Renderer* renderer = GPU_GetCurrentRenderer(); \ 7 14 if(renderer == NULL) \
+23 -2
src/renderer_GL_common.inl
··· 1 1 /* This is an implementation file to be included after certain #defines have been set. 2 2 See a particular renderer's *.c file for specifics. */ 3 3 4 + #ifdef _MSC_VER 5 + // Disable warning: selection for inlining 6 + #pragma warning(disable: 4514 4711 4710) 7 + // Disable warning: Spectre mitigation 8 + #pragma warning(disable: 5045) 9 + #endif 10 + 4 11 #if !defined(GLAPIENTRY) 5 12 #if defined(GL_APIENTRY) 6 13 #define GLAPIENTRY GL_APIENTRY ··· 18 25 19 26 // Check for C99 support 20 27 // We'll use it for intptr_t which is used to suppress warnings about converting an int to a ptr for GL calls. 21 - #if __STDC_VERSION__ >= 199901L 28 + #if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L 22 29 #include <stdint.h> 23 30 #else 24 31 #define intptr_t long ··· 393 400 #else 394 401 static void GLAPIENTRY glBindFramebufferNOOP(GLenum target, GLuint framebuffer) 395 402 { 403 + (void)target; 404 + (void)framebuffer; 396 405 GPU_LogError("%s: Unsupported operation\n", __func__); 397 406 } 398 407 static GLenum GLAPIENTRY glCheckFramebufferStatusNOOP(GLenum target) 399 408 { 409 + (void)target; 400 410 GPU_LogError("%s: Unsupported operation\n", __func__); 401 411 return 0; 402 412 } 403 413 static void GLAPIENTRY glDeleteFramebuffersNOOP(GLsizei n, const GLuint* framebuffers) 404 414 { 415 + (void)n; 416 + (void)framebuffers; 405 417 GPU_LogError("%s: Unsupported operation\n", __func__); 406 418 } 407 419 static void GLAPIENTRY glFramebufferTexture2DNOOP(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) 408 420 { 421 + (void)target; 422 + (void)attachment; 423 + (void)textarget; 424 + (void)texture; 425 + (void)level; 409 426 GPU_LogError("%s: Unsupported operation\n", __func__); 410 427 } 411 428 static void GLAPIENTRY glGenFramebuffersNOOP(GLsizei n, GLuint *ids) 412 429 { 430 + (void)n; 431 + (void)ids; 413 432 GPU_LogError("%s: Unsupported operation\n", __func__); 414 433 } 415 434 static void GLAPIENTRY glGenerateMipmapNOOP(GLenum target) 416 435 { 436 + (void)target; 417 437 GPU_LogError("%s: Unsupported operation\n", __func__); 418 438 } 419 439 ··· 5522 5542 { 5523 5543 GPU_CONTEXT_DATA* cdata = (GPU_CONTEXT_DATA*)context->data; 5524 5544 (void)renderer; 5545 + (void)num_vertices; 5525 5546 #ifdef SDL_GPU_USE_ARRAY_PIPELINE 5526 5547 glEnableClientState(GL_VERTEX_ARRAY); 5527 5548 glEnableClientState(GL_TEXTURE_COORD_ARRAY); ··· 5627 5648 { 5628 5649 GPU_CONTEXT_DATA* cdata = (GPU_CONTEXT_DATA*)context->data; 5629 5650 (void)renderer; 5630 - 5651 + (void)num_vertices; 5631 5652 #ifdef SDL_GPU_USE_ARRAY_PIPELINE 5632 5653 glEnableClientState(GL_VERTEX_ARRAY); 5633 5654 glEnableClientState(GL_COLOR_ARRAY);
+1
version.txt
··· 1 + 0.12.0