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.

Made code intent more clear by switching to use GPU_TRUE and GPU_FALSE.

Jonathan Dearborn 151208d2 bc1aa4d7

+135 -134
+3 -2
include/SDL_gpu.h
··· 38 38 #define GPU_bool int 39 39 #endif 40 40 41 - static const GPU_bool GPU_FALSE = 0; 42 - static const GPU_bool GPU_TRUE = 1; 41 + #define GPU_FALSE 0 42 + #define GPU_TRUE 1 43 + 43 44 44 45 typedef struct GPU_Renderer GPU_Renderer; 45 46 typedef struct GPU_Target GPU_Target;
+28 -28
src/SDL_gpu.c
··· 67 67 static GPU_InitFlagEnum _gpu_preinit_flags = GPU_DEFAULT_INIT_FLAGS; 68 68 static GPU_InitFlagEnum _gpu_required_features = 0; 69 69 70 - static GPU_bool _gpu_initialized_SDL_core = 0; 71 - static GPU_bool _gpu_initialized_SDL = 0; 70 + static GPU_bool _gpu_initialized_SDL_core = GPU_FALSE; 71 + static GPU_bool _gpu_initialized_SDL = GPU_FALSE; 72 72 73 73 static int (*_gpu_print)(GPU_LogLevelEnum log_level, const char* format, va_list args) = &gpu_default_print; 74 74 ··· 105 105 GPU_bool GPU_GetCoordinateMode(void) 106 106 { 107 107 if(_gpu_current_renderer == NULL) 108 - return 0; 108 + return GPU_FALSE; 109 109 110 110 return _gpu_current_renderer->coordinate_mode; 111 111 } ··· 191 191 if(SDL_Init(SDL_INIT_VIDEO) < 0) 192 192 { 193 193 GPU_PushErrorCode("GPU_Init", GPU_ERROR_BACKEND_ERROR, "Failed to initialize SDL video subsystem"); 194 - return 0; 194 + return GPU_FALSE; 195 195 } 196 - _gpu_initialized_SDL_core = 1; 196 + _gpu_initialized_SDL_core = GPU_TRUE; 197 197 } 198 198 199 199 // SDL is definitely ready now, but we're going to init the video subsystem to be sure that SDL_gpu keeps it available until GPU_Quit(). 200 200 if(SDL_InitSubSystem(SDL_INIT_VIDEO) < 0) 201 201 { 202 202 GPU_PushErrorCode("GPU_Init", GPU_ERROR_BACKEND_ERROR, "Failed to initialize SDL video subsystem"); 203 - return 0; 203 + return GPU_FALSE; 204 204 } 205 - _gpu_initialized_SDL = 1; 205 + _gpu_initialized_SDL = GPU_TRUE; 206 206 } 207 - return 1; 207 + return GPU_TRUE; 208 208 } 209 209 210 210 void GPU_SetInitWindow(Uint32 windowID) ··· 472 472 GPU_bool GPU_IsFeatureEnabled(GPU_FeatureEnum feature) 473 473 { 474 474 if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 475 - return 0; 475 + return GPU_FALSE; 476 476 477 477 return ((_gpu_current_renderer->enabled_features & feature) == feature); 478 478 } ··· 507 507 GPU_bool GPU_SetFullscreen(GPU_bool enable_fullscreen, GPU_bool use_desktop_resolution) 508 508 { 509 509 if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 510 - return 0; 510 + return GPU_FALSE; 511 511 512 512 return _gpu_current_renderer->impl->SetFullscreen(_gpu_current_renderer, enable_fullscreen, use_desktop_resolution); 513 513 } ··· 517 517 #ifdef SDL_GPU_USE_SDL2 518 518 GPU_Target* target = GPU_GetContextTarget(); 519 519 if(target == NULL) 520 - return 0; 521 - return (GPU_bool)(SDL_GetWindowFlags(SDL_GetWindowFromID(target->context->windowID)) 522 - & (SDL_WINDOW_FULLSCREEN | SDL_WINDOW_FULLSCREEN_DESKTOP)); 520 + return GPU_FALSE; 521 + return (SDL_GetWindowFlags(SDL_GetWindowFromID(target->context->windowID)) 522 + & (SDL_WINDOW_FULLSCREEN | SDL_WINDOW_FULLSCREEN_DESKTOP)) != 0; 523 523 #else 524 524 SDL_Surface* surf = SDL_GetVideoSurface(); 525 525 if(surf == NULL) 526 - return 0; 527 - return (surf->flags & SDL_FULLSCREEN); 526 + return GPU_FALSE; 527 + return (surf->flags & SDL_FULLSCREEN) != 0; 528 528 #endif 529 529 } 530 530 531 531 GPU_bool GPU_SetWindowResolution(Uint16 w, Uint16 h) 532 532 { 533 533 if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL || w == 0 || h == 0) 534 - return 0; 534 + return GPU_FALSE; 535 535 536 536 return _gpu_current_renderer->impl->SetWindowResolution(_gpu_current_renderer, w, h); 537 537 } ··· 901 901 GPU_bool GPU_IsCameraEnabled(GPU_Target* target) 902 902 { 903 903 if (target == NULL) 904 - return 0; 904 + return GPU_FALSE; 905 905 return target->use_camera; 906 906 } 907 907 ··· 957 957 GPU_bool GPU_SaveImage(GPU_Image* image, const char* filename, GPU_FileFormatEnum format) 958 958 { 959 959 if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 960 - return 0; 960 + return GPU_FALSE; 961 961 962 962 return _gpu_current_renderer->impl->SaveImage(_gpu_current_renderer, image, filename, format); 963 963 } ··· 989 989 GPU_bool GPU_ReplaceImage(GPU_Image* image, SDL_Surface* surface, const GPU_Rect* surface_rect) 990 990 { 991 991 if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 992 - return 0; 992 + return GPU_FALSE; 993 993 994 994 return _gpu_current_renderer->impl->ReplaceImage(_gpu_current_renderer, image, surface, surface_rect); 995 995 } ··· 1144 1144 if(surface == NULL || filename == NULL || 1145 1145 surface->w < 1 || surface->h < 1) 1146 1146 { 1147 - return 0; 1147 + return GPU_FALSE; 1148 1148 } 1149 1149 1150 1150 ··· 1162 1162 else 1163 1163 { 1164 1164 GPU_PushErrorCode(__func__, GPU_ERROR_DATA_ERROR, "Could not detect output file format from file name"); 1165 - return 0; 1165 + return GPU_FALSE; 1166 1166 } 1167 1167 } 1168 1168 ··· 1179 1179 break; 1180 1180 default: 1181 1181 GPU_PushErrorCode(__func__, GPU_ERROR_DATA_ERROR, "Unsupported output file format"); 1182 - result = 0; 1182 + result = GPU_FALSE; 1183 1183 break; 1184 1184 } 1185 1185 ··· 1567 1567 if(target == NULL) 1568 1568 return; 1569 1569 1570 - target->use_color = 0; 1570 + target->use_color = GPU_FALSE; 1571 1571 target->color = c; 1572 1572 } 1573 1573 1574 1574 GPU_bool GPU_GetBlending(GPU_Image* image) 1575 1575 { 1576 1576 if(image == NULL) 1577 - return 0; 1577 + return GPU_FALSE; 1578 1578 1579 1579 return image->use_blending; 1580 1580 } ··· 1916 1916 { 1917 1917 if(free_rwops) 1918 1918 SDL_RWclose(shader_source); 1919 - return 0; 1919 + return GPU_FALSE; 1920 1920 } 1921 1921 1922 1922 return _gpu_current_renderer->impl->CompileShader_RW(_gpu_current_renderer, shader_type, shader_source, free_rwops); ··· 1953 1953 GPU_bool GPU_LinkShaderProgram(Uint32 program_object) 1954 1954 { 1955 1955 if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 1956 - return 0; 1956 + return GPU_FALSE; 1957 1957 1958 1958 return _gpu_current_renderer->impl->LinkShaderProgram(_gpu_current_renderer, program_object); 1959 1959 } ··· 2034 2034 GPU_Context* context; 2035 2035 2036 2036 if(_gpu_current_renderer == NULL || _gpu_current_renderer->current_context_target == NULL) 2037 - return 0; 2037 + return GPU_FALSE; 2038 2038 2039 2039 context = _gpu_current_renderer->current_context_target->context; 2040 2040 return (program_object == context->default_textured_shader_program || program_object == context->default_untextured_shader_program); ··· 2075 2075 GPU_AttributeFormat GPU_MakeAttributeFormat(int num_elems_per_vertex, GPU_TypeEnum type, GPU_bool normalize, int stride_bytes, int offset_bytes) 2076 2076 { 2077 2077 GPU_AttributeFormat f; 2078 - f.is_per_sprite = 0; 2078 + f.is_per_sprite = GPU_FALSE; 2079 2079 f.num_elems_per_value = num_elems_per_vertex; 2080 2080 f.type = type; 2081 2081 f.normalize = normalize;
+1 -1
src/SDL_gpu_renderer.c
··· 21 21 void (*freeFn)(GPU_Renderer*); 22 22 } GPU_RendererRegistration; 23 23 24 - static GPU_bool _gpu_renderer_register_is_initialized = 0; 24 + static GPU_bool _gpu_renderer_register_is_initialized = GPU_FALSE; 25 25 26 26 static GPU_Renderer* _gpu_renderer_map[GPU_MAX_ACTIVE_RENDERERS]; 27 27 static GPU_RendererRegistration _gpu_renderer_register[GPU_MAX_REGISTERED_RENDERERS];
+102 -102
src/renderer_GL_common.inl
··· 214 214 // Workaround for Intel HD glVertexAttrib() bug. 215 215 #ifdef SDL_GPU_USE_OPENGL 216 216 // FIXME: This should probably exist in context storage, as I expect it to be a problem across contexts. 217 - static GPU_bool apply_Intel_attrib_workaround = 0; 218 - static GPU_bool vendor_is_Intel = 0; 217 + static GPU_bool apply_Intel_attrib_workaround = GPU_FALSE; 218 + static GPU_bool vendor_is_Intel = GPU_FALSE; 219 219 #endif 220 220 221 221 ··· 239 239 unsigned long extNameLen; 240 240 241 241 if(p == NULL) 242 - return 0; 242 + return GPU_FALSE; 243 243 244 244 extNameLen = strlen(extension_str); 245 245 end = p + strlen(p); ··· 248 248 { 249 249 unsigned long n = strcspn(p, " "); 250 250 if((extNameLen == n) && (strncmp(extension_str, p, n) == 0)) 251 - return 1; 251 + return GPU_TRUE; 252 252 253 253 p += (n + 1); 254 254 } 255 - return 0; 255 + return GPU_FALSE; 256 256 #endif 257 257 } 258 258 ··· 464 464 extBindFramebuffer(renderer, handle); 465 465 ((GPU_CONTEXT_DATA*)renderer->current_context_target->context->data)->last_target = target; 466 466 } 467 - return 1; 467 + return GPU_TRUE; 468 468 } 469 469 else 470 470 { ··· 473 473 if(target != NULL) 474 474 { 475 475 ((GPU_CONTEXT_DATA*)renderer->current_context_target->context->data)->last_target = target; 476 - return 1; 476 + return GPU_TRUE; 477 477 } 478 - return 0; 478 + return GPU_FALSE; 479 479 } 480 480 } 481 481 ··· 527 527 float* new_buffer; 528 528 529 529 if(minimum_vertices_needed <= cdata->blit_buffer_max_num_vertices) 530 - return 1; 530 + return GPU_TRUE; 531 531 if(cdata->blit_buffer_max_num_vertices == GPU_BLIT_BUFFER_ABSOLUTE_MAX_VERTICES) 532 - return 0; 532 + return GPU_FALSE; 533 533 534 534 // Calculate new size (in vertices) 535 535 new_max_num_vertices = ((unsigned int)cdata->blit_buffer_max_num_vertices) * 2; ··· 563 563 #endif 564 564 #endif 565 565 566 - return 1; 566 + return GPU_TRUE; 567 567 } 568 568 569 569 static GPU_bool growIndexBuffer(GPU_CONTEXT_DATA* cdata, unsigned int minimum_vertices_needed) ··· 572 572 unsigned short* new_indices; 573 573 574 574 if(minimum_vertices_needed <= cdata->index_buffer_max_num_vertices) 575 - return 1; 575 + return GPU_TRUE; 576 576 if(cdata->index_buffer_max_num_vertices == GPU_INDEX_BUFFER_ABSOLUTE_MAX_VERTICES) 577 - return 0; 577 + return GPU_FALSE; 578 578 579 579 // Calculate new size (in vertices) 580 580 new_max_num_vertices = cdata->index_buffer_max_num_vertices * 2; ··· 606 606 #endif 607 607 #endif 608 608 609 - return 1; 609 + return GPU_TRUE; 610 610 } 611 611 612 612 ··· 1143 1143 #endif 1144 1144 1145 1145 GPU_PushErrorCode(__func__, GPU_ERROR_BACKEND_ERROR, "Failed to parse OpenGL version string: \"%s\"", version_string); 1146 - return 0; 1146 + return GPU_FALSE; 1147 1147 } 1148 - return 1; 1148 + return GPU_TRUE; 1149 1149 #else 1150 1150 // GLES doesn't have GL_MAJOR_VERSION. Check via version string instead. 1151 1151 version_string = (const char*)glGetString(GL_VERSION); ··· 1164 1164 #endif 1165 1165 1166 1166 GPU_PushErrorCode(__func__, GPU_ERROR_BACKEND_ERROR, "Failed to parse OpenGL ES version string: \"%s\"", version_string); 1167 - return 0; 1167 + return GPU_FALSE; 1168 1168 } 1169 1169 } 1170 - return 1; 1170 + return GPU_TRUE; 1171 1171 #endif 1172 1172 } 1173 1173 ··· 1183 1183 { 1184 1184 GPU_PushErrorCode(__func__, GPU_ERROR_BACKEND_ERROR, "Failed to parse GLSL version string: \"%s\"", version_string); 1185 1185 *version = SDL_GPU_GLSL_VERSION; 1186 - return 0; 1186 + return GPU_FALSE; 1187 1187 } 1188 1188 else 1189 1189 *version = major*100 + minor; ··· 1195 1195 { 1196 1196 GPU_PushErrorCode(__func__, GPU_ERROR_BACKEND_ERROR, "Failed to parse GLSL ES version string: \"%s\"", version_string); 1197 1197 *version = SDL_GPU_GLSL_VERSION; 1198 - return 0; 1198 + return GPU_FALSE; 1199 1199 } 1200 1200 else 1201 1201 *version = major*100 + minor; 1202 1202 } 1203 1203 #endif 1204 1204 #endif 1205 - return 1; 1205 + return GPU_TRUE; 1206 1206 } 1207 1207 1208 1208 static GPU_bool get_API_versions(GPU_Renderer* renderer) ··· 1233 1233 1234 1234 static GPU_Target* CreateTargetFromWindow(GPU_Renderer* renderer, Uint32 windowID, GPU_Target* target) 1235 1235 { 1236 - GPU_bool created = 0; // Make a new one or repurpose an existing target? 1236 + GPU_bool created = GPU_FALSE; // Make a new one or repurpose an existing target? 1237 1237 GPU_CONTEXT_DATA* cdata; 1238 1238 SDL_Window* window; 1239 1239 ··· 1249 1249 int blit_buffer_storage_size; 1250 1250 int index_buffer_storage_size; 1251 1251 1252 - created = 1; 1252 + created = GPU_TRUE; 1253 1253 target = (GPU_Target*)SDL_malloc(sizeof(GPU_Target)); 1254 1254 memset(target, 0, sizeof(GPU_Target)); 1255 1255 target->refcount = 1; 1256 - target->is_alias = 0; 1256 + target->is_alias = GPU_FALSE; 1257 1257 target->data = (GPU_TARGET_DATA*)SDL_malloc(sizeof(GPU_TARGET_DATA)); 1258 1258 memset(target->data, 0, sizeof(GPU_TARGET_DATA)); 1259 1259 ((GPU_TARGET_DATA*)target->data)->refcount = 1; ··· 1344 1344 target->base_w = target->context->drawable_w; 1345 1345 target->base_h = target->context->drawable_h; 1346 1346 1347 - target->use_clip_rect = 0; 1347 + target->use_clip_rect = GPU_FALSE; 1348 1348 target->clip_rect.x = 0; 1349 1349 target->clip_rect.y = 0; 1350 1350 target->clip_rect.w = target->w; 1351 1351 target->clip_rect.h = target->h; 1352 - target->use_color = 0; 1352 + target->use_color = GPU_FALSE; 1353 1353 1354 1354 target->viewport = GPU_MakeRect(0, 0, target->context->drawable_w, target->context->drawable_h); 1355 1355 target->camera = GPU_GetDefaultCamera(); 1356 - target->use_camera = 1; 1356 + target->use_camera = GPU_TRUE; 1357 1357 1358 1358 target->context->line_thickness = 1.0f; 1359 - target->context->use_texturing = 1; 1360 - target->context->shapes_use_blending = 1; 1359 + target->context->use_texturing = GPU_TRUE; 1360 + target->context->shapes_use_blending = GPU_TRUE; 1361 1361 target->context->shapes_blend_mode = GPU_GetBlendModeFromPreset(GPU_BLEND_NORMAL); 1362 1362 1363 1363 cdata->last_color = white; 1364 1364 1365 - cdata->last_use_texturing = 1; 1365 + cdata->last_use_texturing = GPU_TRUE; 1366 1366 cdata->last_shape = GL_TRIANGLES; 1367 1367 1368 - cdata->last_use_blending = 0; 1368 + cdata->last_use_blending = GPU_FALSE; 1369 1369 cdata->last_blend_mode = GPU_GetBlendModeFromPreset(GPU_BLEND_NORMAL); 1370 1370 1371 1371 cdata->last_viewport = target->viewport; 1372 1372 cdata->last_camera = target->camera; // Redundant due to applyTargetCamera(), below 1373 - cdata->last_camera_inverted = 0; 1373 + cdata->last_camera_inverted = GPU_FALSE; 1374 1374 1375 1375 #ifdef SDL_GPU_USE_OPENGL 1376 1376 glewExperimental = GL_TRUE; // Force GLEW to get exported functions instead of checking via extension string ··· 1379 1379 { 1380 1380 // Probably don't have the right GL version for this renderer 1381 1381 GPU_PushErrorCode("GPU_CreateTargetFromWindow", GPU_ERROR_BACKEND_ERROR, "Failed to initialize extensions for renderer %s.", renderer->id.name); 1382 - target->context->failed = 1; 1382 + target->context->failed = GPU_TRUE; 1383 1383 return NULL; 1384 1384 } 1385 1385 #endif ··· 1399 1399 if(renderer->id.major_version < renderer->requested_id.major_version) 1400 1400 { 1401 1401 GPU_PushErrorCode("GPU_CreateTargetFromWindow", GPU_ERROR_BACKEND_ERROR, "Renderer major version (%d) is incompatible with the available OpenGL runtime library version (%d).", renderer->requested_id.major_version, renderer->id.major_version); 1402 - target->context->failed = 1; 1402 + target->context->failed = GPU_TRUE; 1403 1403 return NULL; 1404 1404 } 1405 1405 ··· 1409 1409 if(!IsFeatureEnabled(renderer, required_features)) 1410 1410 { 1411 1411 GPU_PushErrorCode("GPU_CreateTargetFromWindow", GPU_ERROR_BACKEND_ERROR, "Renderer does not support required features."); 1412 - target->context->failed = 1; 1412 + target->context->failed = GPU_TRUE; 1413 1413 return NULL; 1414 1414 } 1415 1415 ··· 1500 1500 if(!v) 1501 1501 { 1502 1502 GPU_PushErrorCode("GPU_CreateTargetFromWindow", GPU_ERROR_BACKEND_ERROR, "Failed to load default textured vertex shader: %s.", GPU_GetShaderMessage()); 1503 - target->context->failed = 1; 1503 + target->context->failed = GPU_TRUE; 1504 1504 return NULL; 1505 1505 } 1506 1506 ··· 1509 1509 if(!f) 1510 1510 { 1511 1511 GPU_PushErrorCode("GPU_CreateTargetFromWindow", GPU_ERROR_BACKEND_ERROR, "Failed to load default textured fragment shader: %s.", GPU_GetShaderMessage()); 1512 - target->context->failed = 1; 1512 + target->context->failed = GPU_TRUE; 1513 1513 return NULL; 1514 1514 } 1515 1515 ··· 1521 1521 if(!p) 1522 1522 { 1523 1523 GPU_PushErrorCode("GPU_CreateTargetFromWindow", GPU_ERROR_BACKEND_ERROR, "Failed to link default textured shader program: %s.", GPU_GetShaderMessage()); 1524 - target->context->failed = 1; 1524 + target->context->failed = GPU_TRUE; 1525 1525 return NULL; 1526 1526 } 1527 1527 ··· 1537 1537 if(!v) 1538 1538 { 1539 1539 GPU_PushErrorCode("GPU_CreateTargetFromWindow", GPU_ERROR_BACKEND_ERROR, "Failed to load default untextured vertex shader: %s.", GPU_GetShaderMessage()); 1540 - target->context->failed = 1; 1540 + target->context->failed = GPU_TRUE; 1541 1541 return NULL; 1542 1542 } 1543 1543 ··· 1546 1546 if(!f) 1547 1547 { 1548 1548 GPU_PushErrorCode("GPU_CreateTargetFromWindow", GPU_ERROR_BACKEND_ERROR, "Failed to load default untextured fragment shader: %s.", GPU_GetShaderMessage()); 1549 - target->context->failed = 1; 1549 + target->context->failed = GPU_TRUE; 1550 1550 return NULL; 1551 1551 } 1552 1552 ··· 1558 1558 if(!p) 1559 1559 { 1560 1560 GPU_PushErrorCode("GPU_CreateTargetFromWindow", GPU_ERROR_BACKEND_ERROR, "Failed to link default untextured shader program: %s.", GPU_GetShaderMessage()); 1561 - target->context->failed = 1; 1561 + target->context->failed = GPU_TRUE; 1562 1562 return NULL; 1563 1563 } 1564 1564 ··· 1586 1586 glBufferData(GL_ARRAY_BUFFER, GPU_BLIT_BUFFER_STRIDE * cdata->blit_buffer_max_num_vertices, NULL, GL_STREAM_DRAW); 1587 1587 glBindBuffer(GL_ARRAY_BUFFER, cdata->blit_VBO[1]); 1588 1588 glBufferData(GL_ARRAY_BUFFER, GPU_BLIT_BUFFER_STRIDE * cdata->blit_buffer_max_num_vertices, NULL, GL_STREAM_DRAW); 1589 - cdata->blit_VBO_flop = 0; 1589 + cdata->blit_VBO_flop = GPU_FALSE; 1590 1590 1591 1591 glGenBuffers(1, &cdata->blit_IBO); 1592 1592 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cdata->blit_IBO); ··· 1621 1621 target->image->refcount++; 1622 1622 ((GPU_TARGET_DATA*)target->data)->refcount++; 1623 1623 result->refcount = 1; 1624 - result->is_alias = 1; 1624 + result->is_alias = GPU_TRUE; 1625 1625 1626 1626 return result; 1627 1627 } ··· 1756 1756 1757 1757 // Reset texturing state 1758 1758 context = renderer->current_context_target->context; 1759 - context->use_texturing = 1; 1760 - ((GPU_CONTEXT_DATA*)context->data)->last_use_texturing = 0; 1759 + context->use_texturing = GPU_TRUE; 1760 + ((GPU_CONTEXT_DATA*)context->data)->last_use_texturing = GPU_FALSE; 1761 1761 } 1762 1762 1763 1763 // Clear target (no state change) ··· 1775 1775 // Resets virtual resolution 1776 1776 target->w = target->base_w; 1777 1777 target->h = target->base_h; 1778 - target->using_virtual_resolution = 0; 1778 + target->using_virtual_resolution = GPU_FALSE; 1779 1779 1780 1780 // Resets viewport 1781 1781 target->viewport = GPU_MakeRect(0, 0, target->w, target->h); ··· 1802 1802 1803 1803 target->w = w; 1804 1804 target->h = h; 1805 - target->using_virtual_resolution = 1; 1805 + target->using_virtual_resolution = GPU_TRUE; 1806 1806 1807 1807 if(isCurrent) 1808 1808 applyTargetCamera(target); ··· 1822 1822 target->w = target->base_w; 1823 1823 target->h = target->base_h; 1824 1824 1825 - target->using_virtual_resolution = 0; 1825 + target->using_virtual_resolution = GPU_FALSE; 1826 1826 1827 1827 if(isCurrent) 1828 1828 applyTargetCamera(target); ··· 2055 2055 result->format = format; 2056 2056 result->num_layers = num_layers; 2057 2057 result->bytes_per_pixel = bytes_per_pixel; 2058 - result->has_mipmaps = 0; 2058 + result->has_mipmaps = GPU_FALSE; 2059 2059 2060 2060 result->anchor_x = renderer->default_image_anchor_x; 2061 2061 result->anchor_y = renderer->default_image_anchor_y; 2062 2062 2063 2063 result->color = white; 2064 - result->use_blending = 1; 2064 + result->use_blending = GPU_TRUE; 2065 2065 result->blend_mode = GPU_GetBlendModeFromPreset(GPU_BLEND_NORMAL); 2066 2066 result->filter_mode = GPU_FILTER_LINEAR; 2067 2067 result->snap_mode = GPU_SNAP_POSITION_AND_DIMENSIONS; ··· 2069 2069 result->wrap_mode_y = GPU_WRAP_NONE; 2070 2070 2071 2071 result->data = data; 2072 - result->is_alias = 0; 2072 + result->is_alias = GPU_FALSE; 2073 2073 data->handle = handle; 2074 - data->owns_handle = 1; 2074 + data->owns_handle = GPU_TRUE; 2075 2075 data->format = gl_format; 2076 2076 2077 - result->using_virtual_resolution = 0; 2077 + result->using_virtual_resolution = GPU_FALSE; 2078 2078 result->w = w; 2079 2079 result->h = h; 2080 2080 result->base_w = w; ··· 2108 2108 return NULL; 2109 2109 } 2110 2110 2111 - changeTexturing(renderer, 1); 2111 + changeTexturing(renderer, GPU_TRUE); 2112 2112 bindTexture(renderer, result); 2113 2113 2114 2114 internal_format = ((GPU_IMAGE_DATA*)(result->data))->format; ··· 2305 2305 result->format = format; 2306 2306 result->num_layers = num_layers; 2307 2307 result->bytes_per_pixel = bytes_per_pixel; 2308 - result->has_mipmaps = 0; 2308 + result->has_mipmaps = GPU_FALSE; 2309 2309 2310 2310 result->anchor_x = renderer->default_image_anchor_x; 2311 2311 result->anchor_y = renderer->default_image_anchor_y; 2312 2312 2313 2313 result->color = white; 2314 - result->use_blending = 1; 2314 + result->use_blending = GPU_TRUE; 2315 2315 result->blend_mode = GPU_GetBlendModeFromPreset(GPU_BLEND_NORMAL); 2316 2316 result->snap_mode = GPU_SNAP_POSITION_AND_DIMENSIONS; 2317 2317 result->filter_mode = filter_mode; ··· 2319 2319 result->wrap_mode_y = wrap_y; 2320 2320 2321 2321 result->data = data; 2322 - result->is_alias = 0; 2322 + result->is_alias = GPU_FALSE; 2323 2323 2324 - result->using_virtual_resolution = 0; 2324 + result->using_virtual_resolution = GPU_FALSE; 2325 2325 result->w = w; 2326 2326 result->h = h; 2327 2327 ··· 2350 2350 // Alias info 2351 2351 ((GPU_IMAGE_DATA*)image->data)->refcount++; 2352 2352 result->refcount = 1; 2353 - result->is_alias = 1; 2353 + result->is_alias = GPU_TRUE; 2354 2354 2355 2355 return result; 2356 2356 } ··· 2359 2359 static GPU_bool readTargetPixels(GPU_Renderer* renderer, GPU_Target* source, GLint format, GLubyte* pixels) 2360 2360 { 2361 2361 if(source == NULL) 2362 - return 0; 2362 + return GPU_FALSE; 2363 2363 2364 2364 if(isCurrentTarget(renderer, source)) 2365 2365 renderer->impl->FlushBlitBuffer(renderer); ··· 2367 2367 if(bindFramebuffer(renderer, source)) 2368 2368 { 2369 2369 glReadPixels(0, 0, source->base_w, source->base_h, format, GL_UNSIGNED_BYTE, pixels); 2370 - return 1; 2370 + return GPU_TRUE; 2371 2371 } 2372 - return 0; 2372 + return GPU_FALSE; 2373 2373 } 2374 2374 2375 2375 static GPU_bool readImagePixels(GPU_Renderer* renderer, GPU_Image* source, GLint format, GLubyte* pixels) ··· 2380 2380 #endif 2381 2381 2382 2382 if(source == NULL) 2383 - return 0; 2383 + return GPU_FALSE; 2384 2384 2385 2385 // No glGetTexImage() in OpenGLES 2386 2386 #ifdef SDL_GPU_USE_GLES 2387 2387 // Load up the target 2388 - created_target = 0; 2388 + created_target = GPU_FALSE; 2389 2389 if(source->target == NULL) 2390 2390 { 2391 2391 renderer->impl->LoadTarget(renderer, source); 2392 - created_target = 1; 2392 + created_target = GPU_TRUE; 2393 2393 } 2394 2394 // Get the data 2395 2395 // FIXME: This may use different dimensions than the OpenGL code... (base_w vs texture_w) ··· 2407 2407 // Rebind the last texture 2408 2408 if(((GPU_CONTEXT_DATA*)renderer->current_context_target->context->data)->last_image != NULL) 2409 2409 glBindTexture(GL_TEXTURE_2D, ((GPU_IMAGE_DATA*)(((GPU_CONTEXT_DATA*)renderer->current_context_target->context->data)->last_image)->data)->handle); 2410 - return 1; 2410 + return GPU_TRUE; 2411 2411 #endif 2412 2412 } 2413 2413 ··· 2478 2478 if(image == NULL || filename == NULL || 2479 2479 image->texture_w < 1 || image->texture_h < 1 || image->bytes_per_pixel < 1 || image->bytes_per_pixel > 4) 2480 2480 { 2481 - return 0; 2481 + return GPU_FALSE; 2482 2482 } 2483 2483 2484 2484 surface = renderer->impl->CopySurfaceFromImage(renderer, image); 2485 2485 2486 2486 if(surface == NULL) 2487 - return 0; 2487 + return GPU_FALSE; 2488 2488 2489 2489 result = GPU_SaveSurface(surface, filename, format); 2490 2490 ··· 3339 3339 if(image == NULL) 3340 3340 { 3341 3341 GPU_PushErrorCode("GPU_ReplaceImage", GPU_ERROR_NULL_ARGUMENT, "image"); 3342 - return 0; 3342 + return GPU_FALSE; 3343 3343 } 3344 3344 3345 3345 if(surface == NULL) 3346 3346 { 3347 3347 GPU_PushErrorCode("GPU_ReplaceImage", GPU_ERROR_NULL_ARGUMENT, "surface"); 3348 - return 0; 3348 + return GPU_FALSE; 3349 3349 } 3350 3350 3351 3351 data = (GPU_IMAGE_DATA*)image->data; ··· 3355 3355 if(newSurface == NULL) 3356 3356 { 3357 3357 GPU_PushErrorCode("GPU_ReplaceImage", GPU_ERROR_BACKEND_ERROR, "Failed to convert surface to proper pixel format."); 3358 - return 0; 3358 + return GPU_FALSE; 3359 3359 } 3360 3360 3361 3361 // Free the attached framebuffer ··· 3409 3409 if(sourceRect.w <= 0 || sourceRect.h <= 0) 3410 3410 { 3411 3411 GPU_PushErrorCode("GPU_ReplaceImage", GPU_ERROR_DATA_ERROR, "Clipped source rect has zero size."); 3412 - return 0; 3412 + return GPU_FALSE; 3413 3413 } 3414 3414 3415 3415 // Allocate new texture ··· 3418 3418 if(data->handle == 0) 3419 3419 { 3420 3420 GPU_PushErrorCode("GPU_ReplaceImage", GPU_ERROR_BACKEND_ERROR, "Failed to create a new texture handle."); 3421 - return 0; 3421 + return GPU_FALSE; 3422 3422 } 3423 3423 3424 3424 // Update image members ··· 3443 3443 image->texture_w = w; 3444 3444 image->texture_h = h; 3445 3445 3446 - image->has_mipmaps = 0; 3446 + image->has_mipmaps = GPU_FALSE; 3447 3447 3448 3448 3449 3449 // Upload surface pixel data ··· 3486 3486 if(tdata->handle == 0) 3487 3487 { 3488 3488 GPU_PushErrorCode("GPU_ReplaceImage", GPU_ERROR_BACKEND_ERROR, "Failed to create new framebuffer target."); 3489 - return 0; 3489 + return GPU_FALSE; 3490 3490 } 3491 3491 3492 3492 flushAndBindFramebuffer(renderer, tdata->handle); ··· 3498 3498 if(status != GL_FRAMEBUFFER_COMPLETE) 3499 3499 { 3500 3500 GPU_PushErrorCode("GPU_ReplaceImage", GPU_ERROR_BACKEND_ERROR, "Failed to recreate framebuffer target."); 3501 - return 0; 3501 + return GPU_FALSE; 3502 3502 } 3503 3503 3504 3504 if(!target->using_virtual_resolution) ··· 3513 3513 target->viewport = GPU_MakeRect(0, 0, target->w, target->h); 3514 3514 } 3515 3515 3516 - return 1; 3516 + return GPU_TRUE; 3517 3517 } 3518 3518 3519 3519 ··· 3701 3701 result->viewport = GPU_MakeRect(0, 0, result->w, result->h); 3702 3702 3703 3703 result->camera = GPU_GetDefaultCamera(); 3704 - result->use_camera = 1; 3704 + result->use_camera = GPU_TRUE; 3705 3705 3706 - result->use_clip_rect = 0; 3706 + result->use_clip_rect = GPU_FALSE; 3707 3707 result->clip_rect.x = 0; 3708 3708 result->clip_rect.y = 0; 3709 3709 result->clip_rect.w = result->w; 3710 3710 result->clip_rect.h = result->h; 3711 - result->use_color = 0; 3711 + result->use_color = GPU_FALSE; 3712 3712 3713 3713 image->target = result; 3714 3714 return result; ··· 4016 4016 dy2 += fractional; 4017 4017 } 4018 4018 4019 - if(renderer->coordinate_mode == 1) 4019 + if(renderer->coordinate_mode) 4020 4020 { 4021 4021 float temp = dy1; 4022 4022 dy1 = dy2; ··· 4424 4424 glEnableVertexAttribArray(a->attribute.location); 4425 4425 glVertexAttribPointer(a->attribute.location, a->attribute.format.num_elems_per_value, a->attribute.format.type, a->attribute.format.normalize, a->per_vertex_storage_stride_bytes, (void*)(intptr_t)a->per_vertex_storage_offset_bytes); 4426 4426 4427 - a->enabled = 1; 4427 + a->enabled = GPU_TRUE; 4428 4428 // Move the data along so we use the next values for the next flush 4429 4429 a->num_values -= num_values_used; 4430 4430 if(a->num_values <= 0) ··· 4444 4444 if(a->enabled) 4445 4445 { 4446 4446 glDisableVertexAttribArray(a->attribute.location); 4447 - a->enabled = 0; 4447 + a->enabled = GPU_FALSE; 4448 4448 } 4449 4449 } 4450 4450 } ··· 4549 4549 changeCamera(target); 4550 4550 4551 4551 if(using_texture) 4552 - changeTexturing(renderer, 1); 4552 + changeTexturing(renderer, GPU_TRUE); 4553 4553 4554 4554 setClipRect(renderer, target); 4555 4555 ··· 4723 4723 { 4724 4724 // Skip uploads if we have no attribute location 4725 4725 if(cdata->current_shader_block.position_loc < 0) 4726 - use_vertices = 0; 4726 + use_vertices = GPU_FALSE; 4727 4727 if(cdata->current_shader_block.texcoord_loc < 0) 4728 - use_texcoords = 0; 4728 + use_texcoords = GPU_FALSE; 4729 4729 if(cdata->current_shader_block.color_loc < 0) 4730 - use_colors = 0; 4730 + use_colors = GPU_FALSE; 4731 4731 4732 4732 // Update the vertex array object's buffers 4733 4733 #if !defined(SDL_GPU_NO_VAO) ··· 4816 4816 renderer->impl->FlushBlitBuffer(renderer); 4817 4817 bindTexture(renderer, image); 4818 4818 glGenerateMipmap(GL_TEXTURE_2D); 4819 - image->has_mipmaps = 1; 4819 + image->has_mipmaps = GPU_TRUE; 4820 4820 4821 4821 glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, &filter); 4822 4822 if(filter == GL_LINEAR) ··· 4838 4838 4839 4839 if(isCurrentTarget(renderer, target)) 4840 4840 renderer->impl->FlushBlitBuffer(renderer); 4841 - target->use_clip_rect = 1; 4841 + target->use_clip_rect = GPU_TRUE; 4842 4842 4843 4843 r = target->clip_rect; 4844 4844 ··· 4860 4860 if(isCurrentTarget(renderer, target)) 4861 4861 renderer->impl->FlushBlitBuffer(renderer); 4862 4862 // Leave the clip rect values intact so they can still be useful as storage 4863 - target->use_clip_rect = 0; 4863 + target->use_clip_rect = GPU_FALSE; 4864 4864 } 4865 4865 4866 4866 ··· 5345 5345 5346 5346 #ifdef SDL_GPU_USE_OPENGL 5347 5347 if(vendor_is_Intel) 5348 - apply_Intel_attrib_workaround = 1; 5348 + apply_Intel_attrib_workaround = GPU_TRUE; 5349 5349 #endif 5350 5350 } 5351 5351 ··· 5699 5699 int linked; 5700 5700 5701 5701 if(!IsFeatureEnabled(renderer, GPU_FEATURE_BASIC_SHADERS)) 5702 - return 0; 5702 + return GPU_FALSE; 5703 5703 5704 5704 glLinkProgram(program_object); 5705 5705 ··· 5710 5710 GPU_PushErrorCode("GPU_LinkShaderProgram", GPU_ERROR_BACKEND_ERROR, "Failed to link shader program"); 5711 5711 glGetProgramInfoLog(program_object, 256, NULL, shader_message); 5712 5712 glDeleteProgram(program_object); 5713 - return 0; 5713 + return GPU_FALSE; 5714 5714 } 5715 5715 5716 - return 1; 5716 + return GPU_TRUE; 5717 5717 5718 5718 #else 5719 5719 (void)renderer; 5720 5720 (void)program_object; 5721 - return 0; 5721 + return GPU_FALSE; 5722 5722 5723 5723 #endif 5724 5724 } ··· 6240 6240 #ifdef SDL_GPU_USE_OPENGL 6241 6241 if(apply_Intel_attrib_workaround && location == 0) 6242 6242 { 6243 - apply_Intel_attrib_workaround = 0; 6243 + apply_Intel_attrib_workaround = GPU_FALSE; 6244 6244 glBegin(GL_TRIANGLES); 6245 6245 glEnd(); 6246 6246 } ··· 6267 6267 #ifdef SDL_GPU_USE_OPENGL 6268 6268 if(apply_Intel_attrib_workaround && location == 0) 6269 6269 { 6270 - apply_Intel_attrib_workaround = 0; 6270 + apply_Intel_attrib_workaround = GPU_FALSE; 6271 6271 glBegin(GL_TRIANGLES); 6272 6272 glEnd(); 6273 6273 } ··· 6294 6294 #ifdef SDL_GPU_USE_OPENGL 6295 6295 if(apply_Intel_attrib_workaround && location == 0) 6296 6296 { 6297 - apply_Intel_attrib_workaround = 0; 6297 + apply_Intel_attrib_workaround = GPU_FALSE; 6298 6298 glBegin(GL_TRIANGLES); 6299 6299 glEnd(); 6300 6300 } ··· 6323 6323 #ifdef SDL_GPU_USE_OPENGL 6324 6324 if(apply_Intel_attrib_workaround && location == 0) 6325 6325 { 6326 - apply_Intel_attrib_workaround = 0; 6326 + apply_Intel_attrib_workaround = GPU_FALSE; 6327 6327 glBegin(GL_TRIANGLES); 6328 6328 glEnd(); 6329 6329 } ··· 6364 6364 #ifdef SDL_GPU_USE_OPENGL 6365 6365 if(apply_Intel_attrib_workaround && location == 0) 6366 6366 { 6367 - apply_Intel_attrib_workaround = 0; 6367 + apply_Intel_attrib_workaround = GPU_FALSE; 6368 6368 glBegin(GL_TRIANGLES); 6369 6369 glEnd(); 6370 6370 } ··· 6406 6406 #ifdef SDL_GPU_USE_OPENGL 6407 6407 if(apply_Intel_attrib_workaround && location == 0) 6408 6408 { 6409 - apply_Intel_attrib_workaround = 0; 6409 + apply_Intel_attrib_workaround = GPU_FALSE; 6410 6410 glBegin(GL_TRIANGLES); 6411 6411 glEnd(); 6412 6412 } ··· 6467 6467 a->per_vertex_storage_size = 0; 6468 6468 } 6469 6469 6470 - a->enabled = 0; 6470 + a->enabled = GPU_FALSE; 6471 6471 a->attribute = source; 6472 6472 6473 6473 if(!source.format.is_per_sprite)
+1 -1
src/renderer_shapes_GL_common.inl
··· 610 610 GPU_bool use_inner; 611 611 BEGIN_UNTEXTURED("GPU_SectorFilled", GL_TRIANGLES, 3 + (numSegments - 1) + 1, 3 + (numSegments - 1) * 3 + 3); 612 612 613 - use_inner = 0; // Switches between the radii for the next point 613 + use_inner = GPU_FALSE; // Switches between the radii for the next point 614 614 615 615 // First triangle 616 616 dx = inner_radius*cos(t*RADPERDEG);