Made build work again for SDL 1.2 and removed some warnings and SDL_gpu error messages.

+43 -52

SDL_gpu/GL_common/SDL_gpu_GL_common.inl

··· 250 250 static void FreeFormat(SDL_PixelFormat* format); 251 251 252 252 // To make these public, I need to move them into the renderer. But should they be? 253 - static float* GPU_GetModelView(void) 253 + /*static float* GPU_GetModelView(void) 254 254 { 255 255 #ifdef SDL_GPU_USE_INTERNAL_MATRICES 256 256 return _GPU_GetModelView(); ··· 270 270 glGetFloatv(GL_PROJECTION_MATRIX, A); 271 271 return A; 272 272 #endif 273 - } 273 + }*/ 274 274 275 275 276 276 static Uint8 isExtensionSupported(const char* extension_str) ··· 298 298 #endif 299 299 } 300 300 301 - static Uint8 checkExtension(const char* str) 302 - { 303 - if(!isExtensionSupported(str)) 304 - { 305 - GPU_LogError("GL error: %s is not supported.\n", str); 306 - return 0; 307 - } 308 - return 1; 309 - } 310 - 311 301 static void init_features(GPU_Renderer* renderer) 312 302 { 313 303 // NPOT textures ··· 539 529 { 540 530 renderer->FlushBlitBuffer(renderer); 541 531 cdata->last_color = color; 542 - glColor4f(color.r/255.01f, color.g/255.01f, color.b/255.01f, color.a/255.01f); 532 + glColor4f(color.r/255.01f, color.g/255.01f, color.b/255.01f, GET_ALPHA(color)/255.01f); 543 533 } 544 534 #endif 545 535 } ··· 747 737 SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8); 748 738 SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8); 749 739 SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8); 740 + 741 + renderer->requested_id = renderer_request; 750 742 751 743 #ifdef SDL_GPU_USE_SDL2 752 744 ··· 797 789 return NULL; 798 790 #endif 799 791 800 - // Update our renderer info from the current GL context. 801 - #ifdef GL_MAJOR_VERSION 802 - glGetIntegerv(GL_MAJOR_VERSION, &renderer->id.major_version); 803 - glGetIntegerv(GL_MINOR_VERSION, &renderer->id.minor_version); 804 - #else 805 - // GLES doesn't have GL_MAJOR_VERSION. Check via version string instead. 806 - const char* version_string = (const char*)glGetString(GL_VERSION); 807 - // OpenGL ES 2.0? 808 - if(sscanf(version_string, "OpenGL ES %d.%d", &renderer->id.major_version, &renderer->id.minor_version) <= 0) 809 - { 810 - // OpenGL ES-CM 1.1? OpenGL ES-CL 1.1? 811 - if(sscanf(version_string, "OpenGL ES-C%*c %d.%d", &renderer->id.major_version, &renderer->id.minor_version) <= 0) 812 - { 813 - renderer->id.major_version = SDL_GPU_GLES_MAJOR_VERSION; 814 - #if SDL_GPU_GLES_MAJOR_VERSION == 1 815 - renderer->id.minor_version = 1; 816 - #else 817 - renderer->id.minor_version = 0; 818 - #endif 819 - 820 - GPU_LogError("Failed to parse OpenGLES version string: %s\n Defaulting to version %d.%d.\n", version_string, renderer->id.major_version, renderer->id.minor_version); 821 - } 822 - } 823 - #endif 824 - 825 - // Did the wrong runtime library try to use a later versioned renderer? 826 - if(renderer->id.major_version < renderer_request.major_version) 827 - { 828 - GPU_LogError("GPU_Init failed: Renderer %s can not be run by the version %d.%d library that is linked.\n", GPU_GetRendererEnumString(renderer_request.id), renderer->id.major_version, renderer->id.minor_version); 829 - return NULL; 830 - } 831 - 832 792 return renderer->current_context_target; 833 793 } 834 794 ··· 960 920 return NULL; 961 921 } 962 922 #endif 923 + 924 + 925 + // Update our renderer info from the current GL context. 926 + #ifdef GL_MAJOR_VERSION 927 + glGetIntegerv(GL_MAJOR_VERSION, &renderer->id.major_version); 928 + glGetIntegerv(GL_MINOR_VERSION, &renderer->id.minor_version); 929 + #else 930 + // GLES doesn't have GL_MAJOR_VERSION. Check via version string instead. 931 + const char* version_string = (const char*)glGetString(GL_VERSION); 932 + // OpenGL ES 2.0? 933 + if(sscanf(version_string, "OpenGL ES %d.%d", &renderer->id.major_version, &renderer->id.minor_version) <= 0) 934 + { 935 + // OpenGL ES-CM 1.1? OpenGL ES-CL 1.1? 936 + if(sscanf(version_string, "OpenGL ES-C%*c %d.%d", &renderer->id.major_version, &renderer->id.minor_version) <= 0) 937 + { 938 + renderer->id.major_version = SDL_GPU_GLES_MAJOR_VERSION; 939 + #if SDL_GPU_GLES_MAJOR_VERSION == 1 940 + renderer->id.minor_version = 1; 941 + #else 942 + renderer->id.minor_version = 0; 943 + #endif 944 + 945 + GPU_LogError("Failed to parse OpenGLES version string: %s\n Defaulting to version %d.%d.\n", version_string, renderer->id.major_version, renderer->id.minor_version); 946 + } 947 + } 948 + #endif 949 + 950 + // Did the wrong runtime library try to use a later versioned renderer? 951 + if(renderer->id.major_version < renderer->requested_id.major_version) 952 + { 953 + #ifdef SDL_GPU_USE_GLES 954 + GPU_LogError("GPU_Init failed: Renderer %s can not be run by the version %d.%d library that is linked.\n", GPU_GetRendererEnumString(renderer->requested_id.id), renderer->id.major_version, renderer->id.minor_version); 955 + #endif 956 + return NULL; 957 + } 963 958 964 959 init_features(renderer); 965 960 ··· 1125 1120 if(screen == NULL) 1126 1121 return 0; 1127 1122 1128 - renderer->current_context_target->window_w = screen->w; 1129 - renderer->current_context_target->window_h = screen->h; 1123 + renderer->current_context_target->context->window_w = screen->w; 1124 + renderer->current_context_target->context->window_h = screen->h; 1130 1125 #endif 1131 1126 1132 1127 Uint16 virtualW = renderer->current_context_target->w; ··· 3253 3248 result.r = pixels[0]; 3254 3249 result.g = pixels[1]; 3255 3250 result.b = pixels[2]; 3256 - #ifdef SDL_GPU_USE_SDL2 3257 - result.a = pixels[3]; 3258 - #else 3259 - result.unused = pixels[3]; 3260 - #endif 3251 + GET_ALPHA(result) = pixels[3]; 3261 3252 } 3262 3253 3263 3254 return result;

+2 -1

SDL_gpu/SDL_gpu.h

··· 268 268 { 269 269 /*! Struct identifier of the renderer. */ 270 270 GPU_RendererID id; 271 + GPU_RendererID requested_id; 271 272 272 273 int tier; 273 274 GPU_FeatureEnum enabled_features; ··· 598 599 // Renderer controls 599 600 600 601 /*! Returns the default GPU_RendererID for the current platform. */ 601 - GPU_RendererID GPU_GetDefaultRendererID(void); 602 + GPU_RendererID GPU_GetDefaultRendererID(void); 602 603 603 604 /*! Translates a GPU_RendererEnum into a string. */ 604 605 const char* GPU_GetRendererEnumString(GPU_RendererEnum id);

+77 -76

demos/shader-attributes/main.c

··· 1 - #include "SDL.h" 1 + #include "SDL.h" 2 2 #include "SDL_gpu.h" 3 3 #include "common.h" 4 - 4 + 5 5 6 6 GPU_ShaderBlock load_shaders(Uint32* v, Uint32* f, Uint32* p) 7 7 { ··· 34 34 if(!*p) 35 35 { 36 36 GPU_LogError("Failed to link shader program: %s\n", GPU_GetShaderMessage()); 37 - return; 37 + GPU_ShaderBlock b = {-1, -1, -1, -1}; 38 + return b; 38 39 } 39 40 40 41 GPU_ShaderBlock block = GPU_LoadShaderBlock(*p, "gpu_Vertex", "gpu_TexCoord", "gpu_Color", "modelViewProjection"); ··· 89 90 90 91 timeloc = GPU_GetUniformLocation(program, "time"); 91 92 } 92 - 93 - int main(int argc, char* argv[]) 94 - { 95 - printRenderers(); 96 - 97 - GPU_Target* screen = GPU_Init(800, 600, 0); 98 - if(screen == NULL) 99 - return -1; 93 + 94 + int main(int argc, char* argv[]) 95 + { 96 + printRenderers(); 97 + 98 + GPU_Target* screen = GPU_Init(800, 600, 0); 99 + if(screen == NULL) 100 + return -1; 101 + 102 + printCurrentRenderer(); 100 103 101 - printCurrentRenderer(); 102 - 103 - GPU_Image* image = GPU_LoadImage("data/happy_50x50.bmp"); 104 - if(image == NULL) 105 - return -1; 104 + GPU_Image* image = GPU_LoadImage("data/happy_50x50.bmp"); 105 + if(image == NULL) 106 + return -1; 106 107 107 108 Uint32 v, f, p; 108 109 GPU_ShaderBlock block = load_shaders(&v, &f, &p); 109 110 110 111 Uint8 shader_index = 1; 111 - set_shader(p, &block); 112 - 113 - float dt = 0.010f; 114 - 115 - Uint32 startTime = SDL_GetTicks(); 116 - long frameCount = 0; 117 - 118 - int maxSprites = 100; 119 - int numSprites = 0; 120 - 112 + set_shader(p, &block); 113 + 114 + float dt = 0.010f; 115 + 116 + Uint32 startTime = SDL_GetTicks(); 117 + long frameCount = 0; 118 + 119 + int maxSprites = 100; 120 + int numSprites = 0; 121 + 121 122 float positions[2*maxSprites]; 122 123 float colors[4*maxSprites]; 123 - float src_rects[4*maxSprites]; 124 + float src_rects[4*maxSprites]; 124 125 int i; 125 126 SDL_Color color = {255, 255, 255, 255}; 126 127 GPU_Rect src_rect = {0, 0, image->w, image->h}; 127 128 128 - add_sprite(positions, colors, src_rects, &numSprites, color, src_rect); 129 + add_sprite(positions, colors, src_rects, &numSprites, color, src_rect); 129 130 130 131 int mx, my; 131 - Uint32 mouse_state; 132 - 133 - Uint8 done = 0; 134 - SDL_Event event; 135 - while(!done) 136 - { 137 - while(SDL_PollEvent(&event)) 138 - { 139 - if(event.type == SDL_QUIT) 132 + Uint32 mouse_state; 133 + 134 + Uint8 done = 0; 135 + SDL_Event event; 136 + while(!done) 137 + { 138 + while(SDL_PollEvent(&event)) 139 + { 140 + if(event.type == SDL_QUIT) 140 141 done = 1; 141 142 else if(event.type == SDL_MOUSEBUTTONDOWN) 142 143 { ··· 158 159 } 159 160 } 160 161 } 161 - else if(event.type == SDL_KEYDOWN) 162 - { 163 - if(event.key.keysym.sym == SDLK_ESCAPE) 164 - done = 1; 165 - else if(event.key.keysym.sym == SDLK_EQUALS || event.key.keysym.sym == SDLK_PLUS) 166 - { 162 + else if(event.type == SDL_KEYDOWN) 163 + { 164 + if(event.key.keysym.sym == SDLK_ESCAPE) 165 + done = 1; 166 + else if(event.key.keysym.sym == SDLK_EQUALS || event.key.keysym.sym == SDLK_PLUS) 167 + { 167 168 if(numSprites < maxSprites) 168 - add_sprite(positions, colors, src_rects, &numSprites, color, src_rect); 169 - } 170 - else if(event.key.keysym.sym == SDLK_MINUS) 171 - { 172 - if(numSprites > 0) 173 - numSprites--; 174 - } 175 - else if(event.key.keysym.sym == SDLK_SPACE) 169 + add_sprite(positions, colors, src_rects, &numSprites, color, src_rect); 170 + } 171 + else if(event.key.keysym.sym == SDLK_MINUS) 172 + { 173 + if(numSprites > 0) 174 + numSprites--; 175 + } 176 + else if(event.key.keysym.sym == SDLK_SPACE) 176 177 { 177 178 shader_index++; 178 179 shader_index %= 2; 179 180 if(shader_index == 0) 180 181 set_shader(0, NULL); 181 182 else if(shader_index == 1) 182 - set_shader(p, &block); 183 - } 184 - } 183 + set_shader(p, &block); 184 + } 185 + } 185 186 } 186 187 187 188 mouse_state = SDL_GetMouseState(&mx, &my); ··· 204 205 src_rect.h = my/3 - src_rect.y; 205 206 } 206 207 } 207 - } 208 + } 208 209 209 210 GPU_SetUniformf(timeloc, SDL_GetTicks()/1000.0f); 210 - 211 - GPU_Clear(screen); 211 + 212 + GPU_Clear(screen); 212 213 213 - // TODO: Sprite batch 214 - for(i = 0; i < numSprites; i++) 214 + // TODO: Sprite batch 215 + for(i = 0; i < numSprites; i++) 215 216 { 216 217 GPU_Rect r = {src_rects[4*i], src_rects[4*i+1], src_rects[4*i+2], src_rects[4*i+3]}; 217 218 GPU_SetRGBA(image, colors[4*i], colors[4*i+1], colors[4*i+2], colors[4*i+3]); 218 - GPU_Blit(image, &r, screen, positions[2*i], positions[2*i+1]); 219 + GPU_Blit(image, &r, screen, positions[2*i], positions[2*i+1]); 219 220 } 220 221 221 222 set_shader(0, NULL); ··· 230 231 231 232 if(shader_index == 1) 232 233 set_shader(p, &block); 233 - 234 - 235 - GPU_Flip(screen); 236 - 237 - frameCount++; 238 - if(frameCount%500 == 0) 239 - printf("Average FPS: %.2f\n", 1000.0f*frameCount/(SDL_GetTicks() - startTime)); 240 - } 241 - 242 - printf("Average FPS: %.2f\n", 1000.0f*frameCount/(SDL_GetTicks() - startTime)); 243 - 234 + 235 + 236 + GPU_Flip(screen); 237 + 238 + frameCount++; 239 + if(frameCount%500 == 0) 240 + printf("Average FPS: %.2f\n", 1000.0f*frameCount/(SDL_GetTicks() - startTime)); 241 + } 242 + 243 + printf("Average FPS: %.2f\n", 1000.0f*frameCount/(SDL_GetTicks() - startTime)); 244 + 244 245 GPU_FreeImage(image); 245 246 246 247 free_shaders(v, f, p); 247 - 248 + 248 249 GPU_Quit(); 249 250 250 - return 0; 251 - } 252 - 253 - 251 + return 0; 252 + } 253 + 254 +

+117 -116

demos/shader/main.c

··· 1 - #include "SDL.h" 1 + #include "SDL.h" 2 2 #include "SDL_gpu.h" 3 3 #include "common.h" 4 - 4 + 5 5 6 6 GPU_ShaderBlock load_shaders(Uint32* v, Uint32* f, Uint32* p) 7 7 { ··· 34 34 if(!*p) 35 35 { 36 36 GPU_LogError("Failed to link shader program: %s\n", GPU_GetShaderMessage()); 37 - return; 37 + GPU_ShaderBlock b = {-1, -1, -1, -1}; 38 + return b; 38 39 } 39 40 40 41 GPU_ShaderBlock block = GPU_LoadShaderBlock(*p, "gpu_Vertex", "gpu_TexCoord", "gpu_Color", "modelViewProjection"); ··· 49 50 GPU_FreeShader(f); 50 51 GPU_FreeShaderProgram(p); 51 52 } 52 - 53 - int main(int argc, char* argv[]) 54 - { 55 - printRenderers(); 56 - 57 - GPU_Target* screen = GPU_Init(800, 600, 0); 58 - if(screen == NULL) 59 - return -1; 53 + 54 + int main(int argc, char* argv[]) 55 + { 56 + printRenderers(); 57 + 58 + GPU_Target* screen = GPU_Init(800, 600, 0); 59 + if(screen == NULL) 60 + return -1; 60 61 61 - printCurrentRenderer(); 62 - 63 - GPU_Image* image = GPU_LoadImage("data/test.bmp"); 64 - if(image == NULL) 65 - return -1; 62 + printCurrentRenderer(); 63 + 64 + GPU_Image* image = GPU_LoadImage("data/test.bmp"); 65 + if(image == NULL) 66 + return -1; 66 67 67 68 Uint32 v, f, p; 68 69 GPU_ShaderBlock block = load_shaders(&v, &f, &p); 69 70 int uloc = GPU_GetUniformLocation(p, "tex"); 70 71 GPU_SetUniformi(uloc, 0); 71 - int timeloc = GPU_GetUniformLocation(p, "time"); 72 - 73 - float dt = 0.010f; 74 - 75 - Uint32 startTime = SDL_GetTicks(); 76 - long frameCount = 0; 77 - 78 - int maxSprites = 50; 79 - int numSprites = 1; 80 - 81 - float x[maxSprites]; 82 - float y[maxSprites]; 83 - float velx[maxSprites]; 84 - float vely[maxSprites]; 85 - int i; 86 - for(i = 0; i < maxSprites; i++) 87 - { 88 - x[i] = rand()%screen->w; 89 - y[i] = rand()%screen->h; 90 - velx[i] = 10 + rand()%screen->w/10; 91 - vely[i] = 10 + rand()%screen->h/10; 92 - } 93 - 94 - 95 - Uint8 done = 0; 96 - SDL_Event event; 97 - while(!done) 98 - { 99 - while(SDL_PollEvent(&event)) 100 - { 101 - if(event.type == SDL_QUIT) 102 - done = 1; 103 - else if(event.type == SDL_KEYDOWN) 104 - { 105 - if(event.key.keysym.sym == SDLK_ESCAPE) 106 - done = 1; 107 - else if(event.key.keysym.sym == SDLK_EQUALS || event.key.keysym.sym == SDLK_PLUS) 108 - { 109 - if(numSprites < maxSprites) 110 - numSprites++; 111 - } 112 - else if(event.key.keysym.sym == SDLK_MINUS) 113 - { 114 - if(numSprites > 0) 115 - numSprites--; 116 - } 117 - else if(event.key.keysym.sym == SDLK_SPACE) 72 + int timeloc = GPU_GetUniformLocation(p, "time"); 73 + 74 + float dt = 0.010f; 75 + 76 + Uint32 startTime = SDL_GetTicks(); 77 + long frameCount = 0; 78 + 79 + int maxSprites = 50; 80 + int numSprites = 1; 81 + 82 + float x[maxSprites]; 83 + float y[maxSprites]; 84 + float velx[maxSprites]; 85 + float vely[maxSprites]; 86 + int i; 87 + for(i = 0; i < maxSprites; i++) 88 + { 89 + x[i] = rand()%screen->w; 90 + y[i] = rand()%screen->h; 91 + velx[i] = 10 + rand()%screen->w/10; 92 + vely[i] = 10 + rand()%screen->h/10; 93 + } 94 + 95 + 96 + Uint8 done = 0; 97 + SDL_Event event; 98 + while(!done) 99 + { 100 + while(SDL_PollEvent(&event)) 101 + { 102 + if(event.type == SDL_QUIT) 103 + done = 1; 104 + else if(event.type == SDL_KEYDOWN) 105 + { 106 + if(event.key.keysym.sym == SDLK_ESCAPE) 107 + done = 1; 108 + else if(event.key.keysym.sym == SDLK_EQUALS || event.key.keysym.sym == SDLK_PLUS) 109 + { 110 + if(numSprites < maxSprites) 111 + numSprites++; 112 + } 113 + else if(event.key.keysym.sym == SDLK_MINUS) 114 + { 115 + if(numSprites > 0) 116 + numSprites--; 117 + } 118 + else if(event.key.keysym.sym == SDLK_SPACE) 118 119 { 119 120 if(GPU_IsDefaultShaderProgram(screen->context->current_shader_program)) 120 121 GPU_ActivateShaderProgram(p, &block); ··· 124 125 125 126 uloc = GPU_GetUniformLocation(p, "tex"); 126 127 GPU_SetUniformi(uloc, 0); 127 - timeloc = GPU_GetUniformLocation(p, "time"); 128 - } 129 - } 130 - } 131 - 132 - for(i = 0; i < numSprites; i++) 133 - { 134 - x[i] += velx[i]*dt; 135 - y[i] += vely[i]*dt; 136 - if(x[i] < 0) 137 - { 138 - x[i] = 0; 139 - velx[i] = -velx[i]; 140 - } 141 - else if(x[i]> screen->w) 142 - { 143 - x[i] = screen->w; 144 - velx[i] = -velx[i]; 145 - } 146 - 147 - if(y[i] < 0) 148 - { 149 - y[i] = 0; 150 - vely[i] = -vely[i]; 151 - } 152 - else if(y[i]> screen->h) 153 - { 154 - y[i] = screen->h; 155 - vely[i] = -vely[i]; 156 - } 157 - } 128 + timeloc = GPU_GetUniformLocation(p, "time"); 129 + } 130 + } 131 + } 132 + 133 + for(i = 0; i < numSprites; i++) 134 + { 135 + x[i] += velx[i]*dt; 136 + y[i] += vely[i]*dt; 137 + if(x[i] < 0) 138 + { 139 + x[i] = 0; 140 + velx[i] = -velx[i]; 141 + } 142 + else if(x[i]> screen->w) 143 + { 144 + x[i] = screen->w; 145 + velx[i] = -velx[i]; 146 + } 147 + 148 + if(y[i] < 0) 149 + { 150 + y[i] = 0; 151 + vely[i] = -vely[i]; 152 + } 153 + else if(y[i]> screen->h) 154 + { 155 + y[i] = screen->h; 156 + vely[i] = -vely[i]; 157 + } 158 + } 158 159 159 160 GPU_SetUniformf(timeloc, SDL_GetTicks()/1000.0f); 160 - 161 - GPU_Clear(screen); 162 - 163 - for(i = 0; i < numSprites; i++) 164 - { 165 - GPU_Blit(image, NULL, screen, x[i], y[i]); 166 - } 167 - 168 - GPU_Flip(screen); 169 - 170 - frameCount++; 171 - if(frameCount%500 == 0) 172 - printf("Average FPS: %.2f\n", 1000.0f*frameCount/(SDL_GetTicks() - startTime)); 173 - } 174 - 175 - printf("Average FPS: %.2f\n", 1000.0f*frameCount/(SDL_GetTicks() - startTime)); 176 - 161 + 162 + GPU_Clear(screen); 163 + 164 + for(i = 0; i < numSprites; i++) 165 + { 166 + GPU_Blit(image, NULL, screen, x[i], y[i]); 167 + } 168 + 169 + GPU_Flip(screen); 170 + 171 + frameCount++; 172 + if(frameCount%500 == 0) 173 + printf("Average FPS: %.2f\n", 1000.0f*frameCount/(SDL_GetTicks() - startTime)); 174 + } 175 + 176 + printf("Average FPS: %.2f\n", 1000.0f*frameCount/(SDL_GetTicks() - startTime)); 177 + 177 178 GPU_FreeImage(image); 178 179 179 180 free_shaders(v, f, p); 180 - 181 + 181 182 GPU_Quit(); 182 183 183 - return 0; 184 - } 185 - 186 - 184 + return 0; 185 + } 186 + 187 +

Configure Feed

Configure Feed