From 6cf124db66f2e6986b2fb9e18e47d9cba2799fec Mon Sep 17 00:00:00 2001 From: Vittorio Romeo Date: Fri, 19 Nov 2021 01:15:57 +0000 Subject: [PATCH] Fix remaining warnings - Fixes in examples - Fixes across all the modules --- cmake/CompilerWarnings.cmake | 43 +++- examples/island/Island.cpp | 23 +- examples/tennis/Tennis.cpp | 22 +- examples/voip/Server.cpp | 8 +- examples/vulkan/Vulkan.cpp | 18 +- extlibs/headers/glad/include/glad/gl.h | 262 ++++++++++++++++++++++ src/SFML/Audio/SoundFileReaderWav.cpp | 16 +- src/SFML/Audio/SoundFileWriterOgg.cpp | 2 +- src/SFML/Graphics/Font.cpp | 18 +- src/SFML/Graphics/Shader.cpp | 11 +- src/SFML/Graphics/Texture.cpp | 3 +- src/SFML/Graphics/VertexBuffer.cpp | 2 +- src/SFML/Main/CMakeLists.txt | 2 +- src/SFML/Main/MainAndroid.cpp | 23 +- src/SFML/Main/MainWin32.cpp | 3 + src/SFML/Network/Ftp.cpp | 2 +- src/SFML/Network/IpAddress.cpp | 4 +- src/SFML/Network/TcpSocket.cpp | 15 +- src/SFML/Network/Win32/SocketImpl.cpp | 2 +- src/SFML/System/Unix/SleepImpl.cpp | 4 +- src/SFML/System/Win32/ClockImpl.cpp | 4 +- src/SFML/System/Win32/SleepImpl.cpp | 2 +- src/SFML/Window/GlContext.cpp | 16 +- src/SFML/Window/Unix/WindowImplX11.cpp | 33 ++- src/SFML/Window/Win32/CursorImpl.cpp | 8 +- src/SFML/Window/Win32/JoystickImpl.cpp | 28 +-- src/SFML/Window/Win32/VideoModeImpl.cpp | 2 +- src/SFML/Window/Win32/VulkanImplWin32.cpp | 2 +- src/SFML/Window/Win32/WglContext.cpp | 14 +- src/SFML/Window/Win32/WindowImplWin32.cpp | 24 +- 30 files changed, 476 insertions(+), 140 deletions(-) diff --git a/cmake/CompilerWarnings.cmake b/cmake/CompilerWarnings.cmake index 05b0334c..b6c95bb6 100644 --- a/cmake/CompilerWarnings.cmake +++ b/cmake/CompilerWarnings.cmake @@ -31,37 +31,60 @@ function(set_file_warnings) # Disables, remove when appropriate /wd4996 # disable warnings about deprecated functions + /wd4068 # disable warnings about unknown pragmas (e.g. #pragma GCC) + /wd4505 # disable warnings about unused functions that might be platform-specific + /wd4800 # disable warnings regarding implicit conversions to bool ) - set(CLANG_WARNINGS + # some warnings are not supported on older NDK versions used for CI + if (ANDROID) + set(NON_ANDROID_CLANG_AND_GCC_WARNINGS "") + set(NON_ANDROID_GCC_WARNINGS "") + else() + set(NON_ANDROID_CLANG_AND_GCC_WARNINGS + -Wnull-dereference # warn if a null dereference is detected + -Wold-style-cast # warn for c-style casts + -Wpedantic # warn if non-standard C++ is used + ) + + set(NON_ANDROID_GCC_WARNINGS + -Wmisleading-indentation # warn if indentation implies blocks where blocks do not exist + -Wduplicated-cond # warn if if / else chain has duplicated conditions + ) + endif() + + set(CLANG_AND_GCC_WARNINGS -Wall -Wextra # reasonable and standard -Wshadow # warn the user if a variable declaration shadows one from a parent context -Wnon-virtual-dtor # warn the user if a class with virtual functions has a non-virtual destructor. This helps catch hard to track down memory errors - -Wold-style-cast # warn for c-style casts -Wcast-align # warn for potential performance problem casts -Wunused # warn on anything being unused -Woverloaded-virtual # warn if you overload (not override) a virtual function - -Wpedantic # warn if non-standard C++ is used -Wconversion # warn on type conversions that may lose data -Wsign-conversion # warn on sign conversions - -Wnull-dereference # warn if a null dereference is detected -Wdouble-promotion # warn if float is implicit promoted to double -Wformat=2 # warn on security issues around functions that format output (ie printf) - # -Wimplicit-fallthrough # warn when a missing break causes control flow to continue at the next case in a switch statement. Disabled until better compiler support for explicit fallthrough is available. + # -Wimplicit-fallthrough # warn when a missing break causes control flow to continue at the next case in a switch statement (disabled until better compiler support for explicit fallthrough is available) + ${NON_ANDROID_CLANG_AND_GCC_WARNINGS} + ) + + + set(CLANG_WARNINGS + ${CLANG_AND_GCC_WARNINGS} + -Wno-unknown-warning-option # do not warn on GCC-specific warning diagnostic pragmas ) if(WARNINGS_AS_ERRORS) - set(CLANG_WARNINGS ${CLANG_WARNINGS} -Werror) + set(CLANG_AND_GCC_WARNINGS ${CLANG_AND_GCC_WARNINGS} -Werror) set(MSVC_WARNINGS ${MSVC_WARNINGS} /WX) endif() set(GCC_WARNINGS - ${CLANG_WARNINGS} - -Wmisleading-indentation # warn if indentation implies blocks where blocks do not exist - -Wduplicated-cond # warn if if / else chain has duplicated conditions + ${CLANG_AND_GCC_WARNINGS} + ${NON_ANDROID_GCC_WARNINGS} -Wlogical-op # warn about logical operations being used where bitwise were probably wanted - -Wuseless-cast # warn if you perform a cast to the same type + # -Wuseless-cast # warn if you perform a cast to the same type (disabled because it is not portable as some typedefs might vary between platforms) ) # Don't enable -Wduplicated-branches for GCC < 8.1 since it will lead to false positives diff --git a/examples/island/Island.cpp b/examples/island/Island.cpp index d0165f10..1ec46cb3 100644 --- a/examples/island/Island.cpp +++ b/examples/island/Island.cpp @@ -322,16 +322,23 @@ float getMoisture(unsigned int x, unsigned int y) /// Get the lowlands terrain color for the given moisture. /// //////////////////////////////////////////////////////////// +sf::Color colorFromFloats(float r, float g, float b) +{ + return sf::Color(static_cast(r), + static_cast(g), + static_cast(b)); +} + sf::Color getLowlandsTerrainColor(float moisture) { sf::Color color = - moisture < 0.27f ? sf::Color(240, 240, 180) : - moisture < 0.3f ? sf::Color(240 - static_cast(240 * (moisture - 0.27f) / 0.03f), 240 - static_cast(40 * (moisture - 0.27f) / 0.03f), 180 - static_cast(180 * (moisture - 0.27f) / 0.03f)) : - moisture < 0.4f ? sf::Color(0, 200, 0) : - moisture < 0.48f ? sf::Color(0, 200 - static_cast(40 * (moisture - 0.4f) / 0.08f), 0) : - moisture < 0.6f ? sf::Color(0, 160, 0) : - moisture < 0.7f ? sf::Color(static_cast(34 * (moisture - 0.6f) / 0.1f), 160 - static_cast(60 * (moisture - 0.6f) / 0.1f), static_cast(34 * (moisture - 0.6f) / 0.1f)) : - sf::Color(34, 100, 34); + moisture < 0.27f ? colorFromFloats(240, 240, 180) : + moisture < 0.3f ? colorFromFloats(240 - (240 * (moisture - 0.27f) / 0.03f), 240 - (40 * (moisture - 0.27f) / 0.03f), 180 - (180 * (moisture - 0.27f) / 0.03f)) : + moisture < 0.4f ? colorFromFloats(0, 200, 0) : + moisture < 0.48f ? colorFromFloats(0, 200 - (40 * (moisture - 0.4f) / 0.08f), 0) : + moisture < 0.6f ? colorFromFloats(0, 160, 0) : + moisture < 0.7f ? colorFromFloats((34 * (moisture - 0.6f) / 0.1f), 160 - (60 * (moisture - 0.6f) / 0.1f), (34 * (moisture - 0.6f) / 0.1f)) : + colorFromFloats(34, 100, 34); return color; } @@ -348,7 +355,7 @@ sf::Color getHighlandsTerrainColor(float elevation, float moisture) sf::Color color = moisture < 0.6f ? sf::Color(112, 128, 144) : - sf::Color(112 + static_cast(110 * (moisture - 0.6f) / 0.4f), 128 + static_cast(56 * (moisture - 0.6f) / 0.4f), 144 - static_cast(9 * (moisture - 0.6f) / 0.4f)); + colorFromFloats(112 + (110 * (moisture - 0.6f) / 0.4f), 128 + (56 * (moisture - 0.6f) / 0.4f), 144 - (9 * (moisture - 0.6f) / 0.4f)); float factor = std::min((elevation - 0.4f) / 0.1f, 1.f); diff --git a/examples/tennis/Tennis.cpp b/examples/tennis/Tennis.cpp index ca4e2847..bc80bf5e 100644 --- a/examples/tennis/Tennis.cpp +++ b/examples/tennis/Tennis.cpp @@ -33,13 +33,13 @@ int main() // Define some constants const float pi = 3.14159f; - const int gameWidth = 800; - const int gameHeight = 600; + const float gameWidth = 800; + const float gameHeight = 600; sf::Vector2f paddleSize(25, 100); float ballRadius = 10.f; // Create the window of the application - sf::RenderWindow window(sf::VideoMode(gameWidth, gameHeight, 32), "SFML Tennis", + sf::RenderWindow window(sf::VideoMode(static_cast(gameWidth), static_cast(gameHeight), 32), "SFML Tennis", sf::Style::Titlebar | sf::Style::Close); window.setVerticalSyncEnabled(true); @@ -134,26 +134,26 @@ int main() clock.restart(); // Reset the position of the paddles and ball - leftPaddle.setPosition(10 + paddleSize.x / 2, gameHeight / 2); - rightPaddle.setPosition(gameWidth - 10 - paddleSize.x / 2, gameHeight / 2); - ball.setPosition(gameWidth / 2, gameHeight / 2); + leftPaddle.setPosition(10.f + paddleSize.x / 2.f, gameHeight / 2.f); + rightPaddle.setPosition(gameWidth - 10.f - paddleSize.x / 2.f, gameHeight / 2.f); + ball.setPosition(gameWidth / 2.f, gameHeight / 2.f); // Reset the ball angle do { // Make sure the ball initial angle is not too much vertical - ballAngle = static_cast(std::rand() % 360) * 2 * pi / 360; + ballAngle = static_cast(std::rand() % 360) * 2.f * pi / 360.f; } while (std::abs(std::cos(ballAngle)) < 0.7f); } } - + // Window size changed, adjust view appropriately if (event.type == sf::Event::Resized) { sf::View view; view.setSize(gameWidth, gameHeight); - view.setCenter(gameWidth/2.f, gameHeight/2.f); + view.setCenter(gameWidth / 2.f, gameHeight /2.f); window.setView(view); } } @@ -173,7 +173,7 @@ int main() { leftPaddle.move(0.f, paddleSpeed * deltaTime); } - + if (sf::Touch::isDown(0)) { sf::Vector2i pos = sf::Touch::getPosition(0); @@ -209,7 +209,7 @@ int main() #else const std::string inputString = "Press space to restart or\nescape to exit."; #endif - + // Check collisions between the ball and the screen if (ball.getPosition().x - ballRadius < 0.f) { diff --git a/examples/voip/Server.cpp b/examples/voip/Server.cpp index e0e1ee45..12f0f979 100644 --- a/examples/voip/Server.cpp +++ b/examples/voip/Server.cpp @@ -4,6 +4,7 @@ //////////////////////////////////////////////////////////// #include #include +#include #include #include #include @@ -126,14 +127,15 @@ private: if (id == serverAudioData) { // Extract audio samples from the packet, and append it to our samples buffer - const sf::Int16* samples = reinterpret_cast(static_cast(packet.getData()) + 1); - std::size_t sampleCount = (packet.getDataSize() - 1) / sizeof(sf::Int16); + std::size_t sampleCount = (packet.getDataSize() - 1) / sizeof(sf::Int16); // Don't forget that the other thread can access the sample array at any time // (so we protect any operation on it with the mutex) { sf::Lock lock(m_mutex); - std::copy(samples, samples + sampleCount, std::back_inserter(m_samples)); + std::size_t oldSize = m_samples.size(); + m_samples.resize(oldSize + sampleCount); + std::memcpy(&(m_samples[oldSize]), static_cast(packet.getData()) + 1, sampleCount * sizeof(sf::Int16)); } } else if (id == serverEndOfStream) diff --git a/examples/vulkan/Vulkan.cpp b/examples/vulkan/Vulkan.cpp index 72ad3df5..ade2d14f 100644 --- a/examples/vulkan/Vulkan.cpp +++ b/examples/vulkan/Vulkan.cpp @@ -894,7 +894,7 @@ public: return; } - std::vector buffer(static_cast(file.getSize())); + std::vector buffer(static_cast(file.getSize()) / sizeof(uint32_t)); if (file.read(&buffer[0], file.getSize()) != file.getSize()) { @@ -902,8 +902,8 @@ public: return; } - shaderModuleCreateInfo.codeSize = buffer.size(); - shaderModuleCreateInfo.pCode = reinterpret_cast(&buffer[0]); + shaderModuleCreateInfo.codeSize = buffer.size() * sizeof(uint32_t); + shaderModuleCreateInfo.pCode = &buffer[0]; if (vkCreateShaderModule(device, &shaderModuleCreateInfo, 0, &vertexShaderModule) != VK_SUCCESS) { @@ -922,7 +922,7 @@ public: return; } - std::vector buffer(static_cast(file.getSize())); + std::vector buffer(static_cast(file.getSize()) / sizeof(uint32_t)); if (file.read(&buffer[0], file.getSize()) != file.getSize()) { @@ -930,8 +930,8 @@ public: return; } - shaderModuleCreateInfo.codeSize = buffer.size(); - shaderModuleCreateInfo.pCode = reinterpret_cast(&buffer[0]); + shaderModuleCreateInfo.codeSize = buffer.size() * sizeof(uint32_t); + shaderModuleCreateInfo.pCode = &buffer[0]; if (vkCreateShaderModule(device, &shaderModuleCreateInfo, 0, &fragmentShaderModule) != VK_SUCCESS) { @@ -1277,7 +1277,7 @@ public: for (; memoryType < memoryProperties.memoryTypeCount; memoryType++) { - if ((memoryRequirements.memoryTypeBits & (1 << memoryType)) && + if ((memoryRequirements.memoryTypeBits & static_cast(1 << memoryType)) && ((memoryProperties.memoryTypes[memoryType].propertyFlags & properties) == properties)) break; } @@ -1599,7 +1599,7 @@ public: for (; memoryType < memoryProperties.memoryTypeCount; memoryType++) { - if ((memoryRequirements.memoryTypeBits & (1 << memoryType)) && + if ((memoryRequirements.memoryTypeBits & static_cast(1 << memoryType)) && ((memoryProperties.memoryTypes[memoryType].propertyFlags & properties) == properties)) break; } @@ -1777,7 +1777,7 @@ public: } // Copy the image data into the buffer - std::memcpy(ptr, imageData.getPixelsPtr(), imageSize); + std::memcpy(ptr, imageData.getPixelsPtr(), static_cast(imageSize)); // Unmap the buffer vkUnmapMemory(device, stagingBufferMemory); diff --git a/extlibs/headers/glad/include/glad/gl.h b/extlibs/headers/glad/include/glad/gl.h index 9394a0a4..6d568509 100644 --- a/extlibs/headers/glad/include/glad/gl.h +++ b/extlibs/headers/glad/include/glad/gl.h @@ -10128,6 +10128,153 @@ static void sf_glad_gl_load_GL_VERSION_4_6( GLADuserptrloadfunc load, void* user sf_glad_glPolygonOffsetClamp = (PFNGLPOLYGONOFFSETCLAMPPROC) load(userptr, "glPolygonOffsetClamp"); sf_glad_glSpecializeShader = (PFNGLSPECIALIZESHADERPROC) load(userptr, "glSpecializeShader"); } +static void sf_glad_gl_load_GL_VERSION_ES_CM_1_0( GLADuserptrloadfunc load, void* userptr) { + if(!SF_GLAD_GL_VERSION_ES_CM_1_0) return; + sf_glad_glActiveTexture = (PFNGLACTIVETEXTUREPROC) load(userptr, "glActiveTexture"); + sf_glad_glAlphaFunc = (PFNGLALPHAFUNCPROC) load(userptr, "glAlphaFunc"); + sf_glad_glAlphaFuncx = (PFNGLALPHAFUNCXPROC) load(userptr, "glAlphaFuncx"); + sf_glad_glBindBuffer = (PFNGLBINDBUFFERPROC) load(userptr, "glBindBuffer"); + sf_glad_glBindTexture = (PFNGLBINDTEXTUREPROC) load(userptr, "glBindTexture"); + sf_glad_glBlendFunc = (PFNGLBLENDFUNCPROC) load(userptr, "glBlendFunc"); + sf_glad_glBufferData = (PFNGLBUFFERDATAPROC) load(userptr, "glBufferData"); + sf_glad_glBufferSubData = (PFNGLBUFFERSUBDATAPROC) load(userptr, "glBufferSubData"); + sf_glad_glClear = (PFNGLCLEARPROC) load(userptr, "glClear"); + sf_glad_glClearColor = (PFNGLCLEARCOLORPROC) load(userptr, "glClearColor"); + sf_glad_glClearColorx = (PFNGLCLEARCOLORXPROC) load(userptr, "glClearColorx"); + sf_glad_glClearDepthf = (PFNGLCLEARDEPTHFPROC) load(userptr, "glClearDepthf"); + sf_glad_glClearDepthx = (PFNGLCLEARDEPTHXPROC) load(userptr, "glClearDepthx"); + sf_glad_glClearStencil = (PFNGLCLEARSTENCILPROC) load(userptr, "glClearStencil"); + sf_glad_glClientActiveTexture = (PFNGLCLIENTACTIVETEXTUREPROC) load(userptr, "glClientActiveTexture"); + sf_glad_glClipPlanef = (PFNGLCLIPPLANEFPROC) load(userptr, "glClipPlanef"); + sf_glad_glClipPlanex = (PFNGLCLIPPLANEXPROC) load(userptr, "glClipPlanex"); + sf_glad_glColor4f = (PFNGLCOLOR4FPROC) load(userptr, "glColor4f"); + sf_glad_glColor4ub = (PFNGLCOLOR4UBPROC) load(userptr, "glColor4ub"); + sf_glad_glColor4x = (PFNGLCOLOR4XPROC) load(userptr, "glColor4x"); + sf_glad_glColorMask = (PFNGLCOLORMASKPROC) load(userptr, "glColorMask"); + sf_glad_glColorPointer = (PFNGLCOLORPOINTERPROC) load(userptr, "glColorPointer"); + sf_glad_glCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC) load(userptr, "glCompressedTexImage2D"); + sf_glad_glCompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC) load(userptr, "glCompressedTexSubImage2D"); + sf_glad_glCopyTexImage2D = (PFNGLCOPYTEXIMAGE2DPROC) load(userptr, "glCopyTexImage2D"); + sf_glad_glCopyTexSubImage2D = (PFNGLCOPYTEXSUBIMAGE2DPROC) load(userptr, "glCopyTexSubImage2D"); + sf_glad_glCullFace = (PFNGLCULLFACEPROC) load(userptr, "glCullFace"); + sf_glad_glDeleteBuffers = (PFNGLDELETEBUFFERSPROC) load(userptr, "glDeleteBuffers"); + sf_glad_glDeleteTextures = (PFNGLDELETETEXTURESPROC) load(userptr, "glDeleteTextures"); + sf_glad_glDepthFunc = (PFNGLDEPTHFUNCPROC) load(userptr, "glDepthFunc"); + sf_glad_glDepthMask = (PFNGLDEPTHMASKPROC) load(userptr, "glDepthMask"); + sf_glad_glDepthRangef = (PFNGLDEPTHRANGEFPROC) load(userptr, "glDepthRangef"); + sf_glad_glDepthRangex = (PFNGLDEPTHRANGEXPROC) load(userptr, "glDepthRangex"); + sf_glad_glDisable = (PFNGLDISABLEPROC) load(userptr, "glDisable"); + sf_glad_glDisableClientState = (PFNGLDISABLECLIENTSTATEPROC) load(userptr, "glDisableClientState"); + sf_glad_glDrawArrays = (PFNGLDRAWARRAYSPROC) load(userptr, "glDrawArrays"); + sf_glad_glDrawElements = (PFNGLDRAWELEMENTSPROC) load(userptr, "glDrawElements"); + sf_glad_glEnable = (PFNGLENABLEPROC) load(userptr, "glEnable"); + sf_glad_glEnableClientState = (PFNGLENABLECLIENTSTATEPROC) load(userptr, "glEnableClientState"); + sf_glad_glFinish = (PFNGLFINISHPROC) load(userptr, "glFinish"); + sf_glad_glFlush = (PFNGLFLUSHPROC) load(userptr, "glFlush"); + sf_glad_glFogf = (PFNGLFOGFPROC) load(userptr, "glFogf"); + sf_glad_glFogfv = (PFNGLFOGFVPROC) load(userptr, "glFogfv"); + sf_glad_glFogx = (PFNGLFOGXPROC) load(userptr, "glFogx"); + sf_glad_glFogxv = (PFNGLFOGXVPROC) load(userptr, "glFogxv"); + sf_glad_glFrontFace = (PFNGLFRONTFACEPROC) load(userptr, "glFrontFace"); + sf_glad_glFrustumf = (PFNGLFRUSTUMFPROC) load(userptr, "glFrustumf"); + sf_glad_glFrustumx = (PFNGLFRUSTUMXPROC) load(userptr, "glFrustumx"); + sf_glad_glGenBuffers = (PFNGLGENBUFFERSPROC) load(userptr, "glGenBuffers"); + sf_glad_glGenTextures = (PFNGLGENTEXTURESPROC) load(userptr, "glGenTextures"); + sf_glad_glGetBooleanv = (PFNGLGETBOOLEANVPROC) load(userptr, "glGetBooleanv"); + sf_glad_glGetBufferParameteriv = (PFNGLGETBUFFERPARAMETERIVPROC) load(userptr, "glGetBufferParameteriv"); + sf_glad_glGetClipPlanef = (PFNGLGETCLIPPLANEFPROC) load(userptr, "glGetClipPlanef"); + sf_glad_glGetClipPlanex = (PFNGLGETCLIPPLANEXPROC) load(userptr, "glGetClipPlanex"); + sf_glad_glGetError = (PFNGLGETERRORPROC) load(userptr, "glGetError"); + sf_glad_glGetFixedv = (PFNGLGETFIXEDVPROC) load(userptr, "glGetFixedv"); + sf_glad_glGetFloatv = (PFNGLGETFLOATVPROC) load(userptr, "glGetFloatv"); + sf_glad_glGetIntegerv = (PFNGLGETINTEGERVPROC) load(userptr, "glGetIntegerv"); + sf_glad_glGetLightfv = (PFNGLGETLIGHTFVPROC) load(userptr, "glGetLightfv"); + sf_glad_glGetLightxv = (PFNGLGETLIGHTXVPROC) load(userptr, "glGetLightxv"); + sf_glad_glGetMaterialfv = (PFNGLGETMATERIALFVPROC) load(userptr, "glGetMaterialfv"); + sf_glad_glGetMaterialxv = (PFNGLGETMATERIALXVPROC) load(userptr, "glGetMaterialxv"); + sf_glad_glGetPointerv = (PFNGLGETPOINTERVPROC) load(userptr, "glGetPointerv"); + sf_glad_glGetString = (PFNGLGETSTRINGPROC) load(userptr, "glGetString"); + sf_glad_glGetTexEnvfv = (PFNGLGETTEXENVFVPROC) load(userptr, "glGetTexEnvfv"); + sf_glad_glGetTexEnviv = (PFNGLGETTEXENVIVPROC) load(userptr, "glGetTexEnviv"); + sf_glad_glGetTexEnvxv = (PFNGLGETTEXENVXVPROC) load(userptr, "glGetTexEnvxv"); + sf_glad_glGetTexParameterfv = (PFNGLGETTEXPARAMETERFVPROC) load(userptr, "glGetTexParameterfv"); + sf_glad_glGetTexParameteriv = (PFNGLGETTEXPARAMETERIVPROC) load(userptr, "glGetTexParameteriv"); + sf_glad_glGetTexParameterxv = (PFNGLGETTEXPARAMETERXVPROC) load(userptr, "glGetTexParameterxv"); + sf_glad_glHint = (PFNGLHINTPROC) load(userptr, "glHint"); + sf_glad_glIsBuffer = (PFNGLISBUFFERPROC) load(userptr, "glIsBuffer"); + sf_glad_glIsEnabled = (PFNGLISENABLEDPROC) load(userptr, "glIsEnabled"); + sf_glad_glIsTexture = (PFNGLISTEXTUREPROC) load(userptr, "glIsTexture"); + sf_glad_glLightModelf = (PFNGLLIGHTMODELFPROC) load(userptr, "glLightModelf"); + sf_glad_glLightModelfv = (PFNGLLIGHTMODELFVPROC) load(userptr, "glLightModelfv"); + sf_glad_glLightModelx = (PFNGLLIGHTMODELXPROC) load(userptr, "glLightModelx"); + sf_glad_glLightModelxv = (PFNGLLIGHTMODELXVPROC) load(userptr, "glLightModelxv"); + sf_glad_glLightf = (PFNGLLIGHTFPROC) load(userptr, "glLightf"); + sf_glad_glLightfv = (PFNGLLIGHTFVPROC) load(userptr, "glLightfv"); + sf_glad_glLightx = (PFNGLLIGHTXPROC) load(userptr, "glLightx"); + sf_glad_glLightxv = (PFNGLLIGHTXVPROC) load(userptr, "glLightxv"); + sf_glad_glLineWidth = (PFNGLLINEWIDTHPROC) load(userptr, "glLineWidth"); + sf_glad_glLineWidthx = (PFNGLLINEWIDTHXPROC) load(userptr, "glLineWidthx"); + sf_glad_glLoadIdentity = (PFNGLLOADIDENTITYPROC) load(userptr, "glLoadIdentity"); + sf_glad_glLoadMatrixf = (PFNGLLOADMATRIXFPROC) load(userptr, "glLoadMatrixf"); + sf_glad_glLoadMatrixx = (PFNGLLOADMATRIXXPROC) load(userptr, "glLoadMatrixx"); + sf_glad_glLogicOp = (PFNGLLOGICOPPROC) load(userptr, "glLogicOp"); + sf_glad_glMaterialf = (PFNGLMATERIALFPROC) load(userptr, "glMaterialf"); + sf_glad_glMaterialfv = (PFNGLMATERIALFVPROC) load(userptr, "glMaterialfv"); + sf_glad_glMaterialx = (PFNGLMATERIALXPROC) load(userptr, "glMaterialx"); + sf_glad_glMaterialxv = (PFNGLMATERIALXVPROC) load(userptr, "glMaterialxv"); + sf_glad_glMatrixMode = (PFNGLMATRIXMODEPROC) load(userptr, "glMatrixMode"); + sf_glad_glMultMatrixf = (PFNGLMULTMATRIXFPROC) load(userptr, "glMultMatrixf"); + sf_glad_glMultMatrixx = (PFNGLMULTMATRIXXPROC) load(userptr, "glMultMatrixx"); + sf_glad_glMultiTexCoord4f = (PFNGLMULTITEXCOORD4FPROC) load(userptr, "glMultiTexCoord4f"); + sf_glad_glMultiTexCoord4x = (PFNGLMULTITEXCOORD4XPROC) load(userptr, "glMultiTexCoord4x"); + sf_glad_glNormal3f = (PFNGLNORMAL3FPROC) load(userptr, "glNormal3f"); + sf_glad_glNormal3x = (PFNGLNORMAL3XPROC) load(userptr, "glNormal3x"); + sf_glad_glNormalPointer = (PFNGLNORMALPOINTERPROC) load(userptr, "glNormalPointer"); + sf_glad_glOrthof = (PFNGLORTHOFPROC) load(userptr, "glOrthof"); + sf_glad_glOrthox = (PFNGLORTHOXPROC) load(userptr, "glOrthox"); + sf_glad_glPixelStorei = (PFNGLPIXELSTOREIPROC) load(userptr, "glPixelStorei"); + sf_glad_glPointParameterf = (PFNGLPOINTPARAMETERFPROC) load(userptr, "glPointParameterf"); + sf_glad_glPointParameterfv = (PFNGLPOINTPARAMETERFVPROC) load(userptr, "glPointParameterfv"); + sf_glad_glPointParameterx = (PFNGLPOINTPARAMETERXPROC) load(userptr, "glPointParameterx"); + sf_glad_glPointParameterxv = (PFNGLPOINTPARAMETERXVPROC) load(userptr, "glPointParameterxv"); + sf_glad_glPointSize = (PFNGLPOINTSIZEPROC) load(userptr, "glPointSize"); + sf_glad_glPointSizex = (PFNGLPOINTSIZEXPROC) load(userptr, "glPointSizex"); + sf_glad_glPolygonOffset = (PFNGLPOLYGONOFFSETPROC) load(userptr, "glPolygonOffset"); + sf_glad_glPolygonOffsetx = (PFNGLPOLYGONOFFSETXPROC) load(userptr, "glPolygonOffsetx"); + sf_glad_glPopMatrix = (PFNGLPOPMATRIXPROC) load(userptr, "glPopMatrix"); + sf_glad_glPushMatrix = (PFNGLPUSHMATRIXPROC) load(userptr, "glPushMatrix"); + sf_glad_glReadPixels = (PFNGLREADPIXELSPROC) load(userptr, "glReadPixels"); + sf_glad_glRotatef = (PFNGLROTATEFPROC) load(userptr, "glRotatef"); + sf_glad_glRotatex = (PFNGLROTATEXPROC) load(userptr, "glRotatex"); + sf_glad_glSampleCoverage = (PFNGLSAMPLECOVERAGEPROC) load(userptr, "glSampleCoverage"); + sf_glad_glSampleCoveragex = (PFNGLSAMPLECOVERAGEXPROC) load(userptr, "glSampleCoveragex"); + sf_glad_glScalef = (PFNGLSCALEFPROC) load(userptr, "glScalef"); + sf_glad_glScalex = (PFNGLSCALEXPROC) load(userptr, "glScalex"); + sf_glad_glScissor = (PFNGLSCISSORPROC) load(userptr, "glScissor"); + sf_glad_glShadeModel = (PFNGLSHADEMODELPROC) load(userptr, "glShadeModel"); + sf_glad_glStencilFunc = (PFNGLSTENCILFUNCPROC) load(userptr, "glStencilFunc"); + sf_glad_glStencilMask = (PFNGLSTENCILMASKPROC) load(userptr, "glStencilMask"); + sf_glad_glStencilOp = (PFNGLSTENCILOPPROC) load(userptr, "glStencilOp"); + sf_glad_glTexCoordPointer = (PFNGLTEXCOORDPOINTERPROC) load(userptr, "glTexCoordPointer"); + sf_glad_glTexEnvf = (PFNGLTEXENVFPROC) load(userptr, "glTexEnvf"); + sf_glad_glTexEnvfv = (PFNGLTEXENVFVPROC) load(userptr, "glTexEnvfv"); + sf_glad_glTexEnvi = (PFNGLTEXENVIPROC) load(userptr, "glTexEnvi"); + sf_glad_glTexEnviv = (PFNGLTEXENVIVPROC) load(userptr, "glTexEnviv"); + sf_glad_glTexEnvx = (PFNGLTEXENVXPROC) load(userptr, "glTexEnvx"); + sf_glad_glTexEnvxv = (PFNGLTEXENVXVPROC) load(userptr, "glTexEnvxv"); + sf_glad_glTexImage2D = (PFNGLTEXIMAGE2DPROC) load(userptr, "glTexImage2D"); + sf_glad_glTexParameterf = (PFNGLTEXPARAMETERFPROC) load(userptr, "glTexParameterf"); + sf_glad_glTexParameterfv = (PFNGLTEXPARAMETERFVPROC) load(userptr, "glTexParameterfv"); + sf_glad_glTexParameteri = (PFNGLTEXPARAMETERIPROC) load(userptr, "glTexParameteri"); + sf_glad_glTexParameteriv = (PFNGLTEXPARAMETERIVPROC) load(userptr, "glTexParameteriv"); + sf_glad_glTexParameterx = (PFNGLTEXPARAMETERXPROC) load(userptr, "glTexParameterx"); + sf_glad_glTexParameterxv = (PFNGLTEXPARAMETERXVPROC) load(userptr, "glTexParameterxv"); + sf_glad_glTexSubImage2D = (PFNGLTEXSUBIMAGE2DPROC) load(userptr, "glTexSubImage2D"); + sf_glad_glTranslatef = (PFNGLTRANSLATEFPROC) load(userptr, "glTranslatef"); + sf_glad_glTranslatex = (PFNGLTRANSLATEXPROC) load(userptr, "glTranslatex"); + sf_glad_glVertexPointer = (PFNGLVERTEXPOINTERPROC) load(userptr, "glVertexPointer"); + sf_glad_glViewport = (PFNGLVIEWPORTPROC) load(userptr, "glViewport"); +} static void sf_glad_gl_load_GL_ARB_ES2_compatibility( GLADuserptrloadfunc load, void* userptr) { if(!SF_GLAD_GL_ARB_ES2_compatibility) return; sf_glad_glClearDepthf = (PFNGLCLEARDEPTHFPROC) load(userptr, "glClearDepthf"); @@ -11147,6 +11294,36 @@ static void sf_glad_gl_load_GL_OES_single_precision( GLADuserptrloadfunc load, v sf_glad_glGetClipPlanefOES = (PFNGLGETCLIPPLANEFOESPROC) load(userptr, "glGetClipPlanefOES"); sf_glad_glOrthofOES = (PFNGLORTHOFOESPROC) load(userptr, "glOrthofOES"); } +static void sf_glad_gl_load_GL_OES_blend_equation_separate( GLADuserptrloadfunc load, void* userptr) { + if(!SF_GLAD_GL_OES_blend_equation_separate) return; + sf_glad_glBlendEquationSeparateOES = (PFNGLBLENDEQUATIONSEPARATEOESPROC) load(userptr, "glBlendEquationSeparateOES"); +} +static void sf_glad_gl_load_GL_OES_blend_func_separate( GLADuserptrloadfunc load, void* userptr) { + if(!SF_GLAD_GL_OES_blend_func_separate) return; + sf_glad_glBlendFuncSeparateOES = (PFNGLBLENDFUNCSEPARATEOESPROC) load(userptr, "glBlendFuncSeparateOES"); +} +static void sf_glad_gl_load_GL_OES_blend_subtract( GLADuserptrloadfunc load, void* userptr) { + if(!SF_GLAD_GL_OES_blend_subtract) return; + sf_glad_glBlendEquationOES = (PFNGLBLENDEQUATIONOESPROC) load(userptr, "glBlendEquationOES"); +} +static void sf_glad_gl_load_GL_OES_framebuffer_object( GLADuserptrloadfunc load, void* userptr) { + if(!SF_GLAD_GL_OES_framebuffer_object) return; + sf_glad_glBindFramebufferOES = (PFNGLBINDFRAMEBUFFEROESPROC) load(userptr, "glBindFramebufferOES"); + sf_glad_glBindRenderbufferOES = (PFNGLBINDRENDERBUFFEROESPROC) load(userptr, "glBindRenderbufferOES"); + sf_glad_glCheckFramebufferStatusOES = (PFNGLCHECKFRAMEBUFFERSTATUSOESPROC) load(userptr, "glCheckFramebufferStatusOES"); + sf_glad_glDeleteFramebuffersOES = (PFNGLDELETEFRAMEBUFFERSOESPROC) load(userptr, "glDeleteFramebuffersOES"); + sf_glad_glDeleteRenderbuffersOES = (PFNGLDELETERENDERBUFFERSOESPROC) load(userptr, "glDeleteRenderbuffersOES"); + sf_glad_glFramebufferRenderbufferOES = (PFNGLFRAMEBUFFERRENDERBUFFEROESPROC) load(userptr, "glFramebufferRenderbufferOES"); + sf_glad_glFramebufferTexture2DOES = (PFNGLFRAMEBUFFERTEXTURE2DOESPROC) load(userptr, "glFramebufferTexture2DOES"); + sf_glad_glGenFramebuffersOES = (PFNGLGENFRAMEBUFFERSOESPROC) load(userptr, "glGenFramebuffersOES"); + sf_glad_glGenRenderbuffersOES = (PFNGLGENRENDERBUFFERSOESPROC) load(userptr, "glGenRenderbuffersOES"); + sf_glad_glGenerateMipmapOES = (PFNGLGENERATEMIPMAPOESPROC) load(userptr, "glGenerateMipmapOES"); + sf_glad_glGetFramebufferAttachmentParameterivOES = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVOESPROC) load(userptr, "glGetFramebufferAttachmentParameterivOES"); + sf_glad_glGetRenderbufferParameterivOES = (PFNGLGETRENDERBUFFERPARAMETERIVOESPROC) load(userptr, "glGetRenderbufferParameterivOES"); + sf_glad_glIsFramebufferOES = (PFNGLISFRAMEBUFFEROESPROC) load(userptr, "glIsFramebufferOES"); + sf_glad_glIsRenderbufferOES = (PFNGLISRENDERBUFFEROESPROC) load(userptr, "glIsRenderbufferOES"); + sf_glad_glRenderbufferStorageOES = (PFNGLRENDERBUFFERSTORAGEOESPROC) load(userptr, "glRenderbufferStorageOES"); +} static void sf_glad_gl_resolve_aliases(void) { @@ -11978,6 +12155,91 @@ static int gladLoadGL( GLADloadfunc load) { return gladLoadGLUserPtr( sf_glad_gl_get_proc_from_userptr, GLAD_GNUC_EXTENSION (void*) load); } +static int sf_glad_gl_find_extensions_gles1( int version) { + const char *exts = NULL; + unsigned int num_exts_i = 0; + char **exts_i = NULL; + if (!sf_glad_gl_get_extensions(version, &exts, &num_exts_i, &exts_i)) return 0; + + SF_GLAD_GL_EXT_blend_minmax = sf_glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_EXT_blend_minmax"); + SF_GLAD_GL_KHR_debug = sf_glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_KHR_debug"); + SF_GLAD_GL_OES_single_precision = sf_glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_OES_single_precision"); + SF_GLAD_GL_EXT_sRGB = sf_glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_EXT_sRGB"); + SF_GLAD_GL_OES_blend_equation_separate = sf_glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_OES_blend_equation_separate"); + SF_GLAD_GL_OES_blend_func_separate = sf_glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_OES_blend_func_separate"); + SF_GLAD_GL_OES_blend_subtract = sf_glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_OES_blend_subtract"); + SF_GLAD_GL_OES_depth24 = sf_glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_OES_depth24"); + SF_GLAD_GL_OES_depth32 = sf_glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_OES_depth32"); + SF_GLAD_GL_OES_framebuffer_object = sf_glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_OES_framebuffer_object"); + SF_GLAD_GL_OES_packed_depth_stencil = sf_glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_OES_packed_depth_stencil"); + SF_GLAD_GL_OES_texture_npot = sf_glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_OES_texture_npot"); + + sf_glad_gl_free_extensions(exts_i, num_exts_i); + + return 1; +} + +static int sf_glad_gl_find_core_gles1(void) { + int i, major, minor; + const char* version; + const char* prefixes[] = { + "OpenGL ES-CM ", + "OpenGL ES-CL ", + "OpenGL ES ", + NULL + }; + version = (const char*) sf_glad_glGetString(GL_VERSION); + if (!version) return 0; + for (i = 0; prefixes[i]; i++) { + const size_t length = strlen(prefixes[i]); + if (strncmp(version, prefixes[i], length) == 0) { + version += length; + break; + } + } + + GLAD_IMPL_UTIL_SSCANF(version, "%d.%d", &major, &minor); + + SF_GLAD_GL_VERSION_ES_CM_1_0 = (major == 1 && minor >= 0) || major > 1; + + return GLAD_MAKE_VERSION(major, minor); +} + +static int gladLoadGLES1UserPtr( GLADuserptrloadfunc load, void *userptr) { + int version; + + sf_glad_glGetString = (PFNGLGETSTRINGPROC) load(userptr, "glGetString"); + if(sf_glad_glGetString == NULL) return 0; + if(sf_glad_glGetString(GL_VERSION) == NULL) return 0; + version = sf_glad_gl_find_core_gles1(); + + sf_glad_gl_load_GL_VERSION_ES_CM_1_0(load, userptr); + + if (!sf_glad_gl_find_extensions_gles1(version)) return 0; + sf_glad_gl_load_GL_EXT_blend_minmax(load, userptr); + sf_glad_gl_load_GL_KHR_debug(load, userptr); + sf_glad_gl_load_GL_OES_single_precision(load, userptr); + sf_glad_gl_load_GL_OES_blend_equation_separate(load, userptr); + sf_glad_gl_load_GL_OES_blend_func_separate(load, userptr); + sf_glad_gl_load_GL_OES_blend_subtract(load, userptr); + sf_glad_gl_load_GL_OES_framebuffer_object(load, userptr); + + + sf_glad_gl_resolve_aliases(); + + return version; +} + + +static int gladLoadGLES1( GLADloadfunc load) { + return gladLoadGLES1UserPtr( sf_glad_gl_get_proc_from_userptr, GLAD_GNUC_EXTENSION (void*) load); +} + + + + + + #ifdef __cplusplus } #endif diff --git a/src/SFML/Audio/SoundFileReaderWav.cpp b/src/SFML/Audio/SoundFileReaderWav.cpp index f67b7440..28dfc4e4 100644 --- a/src/SFML/Audio/SoundFileReaderWav.cpp +++ b/src/SFML/Audio/SoundFileReaderWav.cpp @@ -41,13 +41,13 @@ namespace bool decode(sf::InputStream& stream, sf::Uint8& value) { - return stream.read(&value, sizeof(value)) == sizeof(value); + return static_cast(stream.read(&value, sizeof(value))) == sizeof(value); } bool decode(sf::InputStream& stream, sf::Int16& value) { unsigned char bytes[sizeof(value)]; - if (stream.read(bytes, sizeof(bytes)) != sizeof(bytes)) + if (static_cast(stream.read(bytes, static_cast(sizeof(bytes)))) != sizeof(bytes)) return false; value = static_cast(bytes[0] | (bytes[1] << 8)); @@ -58,7 +58,7 @@ namespace bool decode(sf::InputStream& stream, sf::Uint16& value) { unsigned char bytes[sizeof(value)]; - if (stream.read(bytes, sizeof(bytes)) != sizeof(bytes)) + if (static_cast(stream.read(bytes, static_cast(sizeof(bytes)))) != sizeof(bytes)) return false; value = static_cast(bytes[0] | (bytes[1] << 8)); @@ -69,7 +69,7 @@ namespace bool decode24bit(sf::InputStream& stream, sf::Uint32& value) { unsigned char bytes[3]; - if (stream.read(bytes, sizeof(bytes)) != sizeof(bytes)) + if (static_cast(stream.read(bytes, static_cast(sizeof(bytes)))) != sizeof(bytes)) return false; value = static_cast(bytes[0] | (bytes[1] << 8) | (bytes[2] << 16)); @@ -80,7 +80,7 @@ namespace bool decode(sf::InputStream& stream, sf::Uint32& value) { unsigned char bytes[sizeof(value)]; - if (stream.read(bytes, sizeof(bytes)) != sizeof(bytes)) + if (static_cast(stream.read(bytes, static_cast(sizeof(bytes)))) != sizeof(bytes)) return false; value = static_cast(bytes[0] | (bytes[1] << 8) | (bytes[2] << 16) | (bytes[3] << 24)); @@ -225,7 +225,7 @@ bool SoundFileReaderWav::parseHeader(Info& info) // If we are here, it means that the first part of the header // (the format) has already been checked char mainChunk[mainChunkSize]; - if (m_stream->read(mainChunk, sizeof(mainChunk)) != sizeof(mainChunk)) + if (static_cast(m_stream->read(mainChunk, static_cast(sizeof(mainChunk)))) != sizeof(mainChunk)) return false; // Parse all the sub-chunks @@ -234,7 +234,7 @@ bool SoundFileReaderWav::parseHeader(Info& info) { // Parse the sub-chunk id and size char subChunkId[4]; - if (m_stream->read(subChunkId, sizeof(subChunkId)) != sizeof(subChunkId)) + if (static_cast(m_stream->read(subChunkId, static_cast(sizeof(subChunkId)))) != sizeof(subChunkId)) return false; Uint32 subChunkSize = 0; if (!decode(*m_stream, subChunkSize)) @@ -307,7 +307,7 @@ bool SoundFileReaderWav::parseHeader(Info& info) // Subformat char subformat[16]; - if (m_stream->read(subformat, sizeof(subformat)) != sizeof(subformat)) + if (static_cast(m_stream->read(subformat, static_cast(sizeof(subformat)))) != sizeof(subformat)) return false; if (std::memcmp(subformat, waveSubformatPcm, sizeof(subformat)) != 0) diff --git a/src/SFML/Audio/SoundFileWriterOgg.cpp b/src/SFML/Audio/SoundFileWriterOgg.cpp index 4f2daba6..4ecc4656 100644 --- a/src/SFML/Audio/SoundFileWriterOgg.cpp +++ b/src/SFML/Audio/SoundFileWriterOgg.cpp @@ -85,7 +85,7 @@ bool SoundFileWriterOgg::open(const std::string& filename, unsigned int sampleRa // Setup the encoder: VBR, automatic bitrate management // Quality is in range [-1 .. 1], 0.4 gives ~128 kbps for a 44 KHz stereo sound - int status = vorbis_encode_init_vbr(&m_vorbis, channelCount, sampleRate, 0.4f); + int status = vorbis_encode_init_vbr(&m_vorbis, static_cast(channelCount), static_cast(sampleRate), 0.4f); if (status < 0) { err() << "Failed to write ogg/vorbis file \"" << filename << "\" (unsupported bitrate)" << std::endl; diff --git a/src/SFML/Graphics/Font.cpp b/src/SFML/Graphics/Font.cpp index 27cd90e2..40c17a3c 100644 --- a/src/SFML/Graphics/Font.cpp +++ b/src/SFML/Graphics/Font.cpp @@ -131,7 +131,7 @@ Font::~Font() #ifdef SFML_SYSTEM_ANDROID if (m_stream) - delete (priv::ResourceStream*)m_stream; + delete static_cast(m_stream); #endif } @@ -195,10 +195,10 @@ bool Font::loadFromFile(const std::string& filename) #else if (m_stream) - delete (priv::ResourceStream*)m_stream; + delete static_cast(m_stream); m_stream = new priv::ResourceStream(filename); - return loadFromStream(*(priv::ResourceStream*)m_stream); + return loadFromStream(*static_cast(m_stream)); #endif } @@ -659,16 +659,16 @@ Glyph Font::loadGlyph(Uint32 codePoint, unsigned int characterSize, bool bold, f // Make sure the texture data is positioned in the center // of the allocated texture rectangle - glyph.textureRect.left += static_cast(padding); - glyph.textureRect.top += static_cast(padding); + glyph.textureRect.left += static_cast(padding); + glyph.textureRect.top += static_cast(padding); glyph.textureRect.width -= static_cast(2 * padding); glyph.textureRect.height -= static_cast(2 * padding); // Compute the glyph's bounding box - glyph.bounds.left = bitmapGlyph->left; - glyph.bounds.top = -bitmapGlyph->top; - glyph.bounds.width = bitmap.width; - glyph.bounds.height = bitmap.rows; + glyph.bounds.left = static_cast( bitmapGlyph->left); + glyph.bounds.top = static_cast(-bitmapGlyph->top); + glyph.bounds.width = static_cast( bitmap.width); + glyph.bounds.height = static_cast( bitmap.rows); // Resize the pixel buffer to the new size and fill it with transparent white pixels m_pixelBuffer.resize(width * height * 4); diff --git a/src/SFML/Graphics/Shader.cpp b/src/SFML/Graphics/Shader.cpp index e5b26593..90856b00 100644 --- a/src/SFML/Graphics/Shader.cpp +++ b/src/SFML/Graphics/Shader.cpp @@ -68,14 +68,14 @@ namespace } // Retrieve the maximum number of texture units available - GLint getMaxTextureUnits() + std::size_t getMaxTextureUnits() { // TODO: Remove this lock when it becomes unnecessary in C++11 sf::Lock lock(maxTextureUnitsMutex); static GLint maxUnits = checkMaxTextureUnits(); - return maxUnits; + return static_cast(maxUnits); } // Read the contents of a file into an array of char @@ -85,12 +85,12 @@ namespace if (file) { file.seekg(0, std::ios_base::end); - std::streamsize size = file.tellg(); + std::ifstream::pos_type size = file.tellg(); if (size > 0) { file.seekg(0, std::ios_base::beg); buffer.resize(static_cast(size)); - file.read(&buffer[0], size); + file.read(&buffer[0], static_cast(size)); } buffer.push_back('\0'); return true; @@ -556,8 +556,7 @@ void Shader::setUniform(const std::string& name, const Texture& texture) if (it == m_textures.end()) { // New entry, make sure there are enough texture units - GLint maxUnits = getMaxTextureUnits(); - if (m_textures.size() + 1 >= static_cast(maxUnits)) + if (m_textures.size() + 1 >= getMaxTextureUnits()) { err() << "Impossible to use texture \"" << name << "\" for shader: all available texture units are used" << std::endl; return; diff --git a/src/SFML/Graphics/Texture.cpp b/src/SFML/Graphics/Texture.cpp index bf546ccf..f462f263 100644 --- a/src/SFML/Graphics/Texture.cpp +++ b/src/SFML/Graphics/Texture.cpp @@ -36,6 +36,7 @@ #include #include #include +#include namespace @@ -378,7 +379,7 @@ Image Texture::copyToImage() const if (m_pixelsFlipped) { src += srcPitch * (m_size.y - 1); - srcPitch = -srcPitch; + srcPitch = UINT_MAX - srcPitch + 1; } for (unsigned int i = 0; i < m_size.y; ++i) diff --git a/src/SFML/Graphics/VertexBuffer.cpp b/src/SFML/Graphics/VertexBuffer.cpp index d70fef1b..3c09716c 100644 --- a/src/SFML/Graphics/VertexBuffer.cpp +++ b/src/SFML/Graphics/VertexBuffer.cpp @@ -195,7 +195,7 @@ bool VertexBuffer::update(const Vertex* vertices, std::size_t vertexCount, unsig m_size = vertexCount; } - glCheck(GLEXT_glBufferSubData(GLEXT_GL_ARRAY_BUFFER, sizeof(Vertex) * offset, static_cast(sizeof(Vertex) * vertexCount), vertices)); + glCheck(GLEXT_glBufferSubData(GLEXT_GL_ARRAY_BUFFER, static_cast(sizeof(Vertex) * offset), static_cast(sizeof(Vertex) * vertexCount), vertices)); glCheck(GLEXT_glBindBuffer(GLEXT_GL_ARRAY_BUFFER, 0)); diff --git a/src/SFML/Main/CMakeLists.txt b/src/SFML/Main/CMakeLists.txt index 9344ada1..babd2b32 100644 --- a/src/SFML/Main/CMakeLists.txt +++ b/src/SFML/Main/CMakeLists.txt @@ -18,7 +18,7 @@ sfml_add_library(sfml-main STATIC SOURCES ${SRC}) if(SFML_OS_ANDROID) # glad sources - target_include_directories(sfml-main PRIVATE "${PROJECT_SOURCE_DIR}/extlibs/headers/glad/include") + target_include_directories(sfml-main SYSTEM PRIVATE "${PROJECT_SOURCE_DIR}/extlibs/headers/glad/include") endif() # overwrite sfml-main suffix for backward compatibility with FindSFML.cmake diff --git a/src/SFML/Main/MainAndroid.cpp b/src/SFML/Main/MainAndroid.cpp index f217493b..9fbd586a 100644 --- a/src/SFML/Main/MainAndroid.cpp +++ b/src/SFML/Main/MainAndroid.cpp @@ -161,7 +161,6 @@ void goToFullscreenMode(ANativeActivity* activity) AWINDOW_FLAG_FULLSCREEN); // Hide the navigation bar - JavaVM* lJavaVM = activity->vm; JNIEnv* lJNIEnv = activity->env; jobject objectActivity = activity->clazz; @@ -216,7 +215,6 @@ void getScreenSizeInPixels(ANativeActivity* activity, int* width, int* height) // DisplayMetrics dm = new DisplayMetrics(); // getWindowManager().getDefaultDisplay().getMetrics(dm); - JavaVM* lJavaVM = activity->vm; JNIEnv* lJNIEnv = activity->env; jobject objectActivity = activity->clazz; @@ -248,6 +246,7 @@ void getScreenSizeInPixels(ANativeActivity* activity, int* width, int* height) //////////////////////////////////////////////////////////// static void onStart(ANativeActivity* activity) { + (void) activity; } @@ -287,6 +286,7 @@ static void onPause(ANativeActivity* activity) //////////////////////////////////////////////////////////// static void onStop(ANativeActivity* activity) { + (void) activity; } @@ -339,6 +339,8 @@ static void onDestroy(ANativeActivity* activity) //////////////////////////////////////////////////////////// static void onNativeWindowCreated(ANativeActivity* activity, ANativeWindow* window) { + (void) window; + sf::priv::ActivityStates* states = sf::priv::retrieveStates(activity); sf::Lock lock(states->mutex); @@ -364,6 +366,8 @@ static void onNativeWindowCreated(ANativeActivity* activity, ANativeWindow* wind //////////////////////////////////////////////////////////// static void onNativeWindowDestroyed(ANativeActivity* activity, ANativeWindow* window) { + (void) window; + sf::priv::ActivityStates* states = sf::priv::retrieveStates(activity); sf::Lock lock(states->mutex); @@ -389,12 +393,16 @@ static void onNativeWindowDestroyed(ANativeActivity* activity, ANativeWindow* wi //////////////////////////////////////////////////////////// static void onNativeWindowRedrawNeeded(ANativeActivity* activity, ANativeWindow* window) { + (void) activity; + (void) window; } //////////////////////////////////////////////////////////// static void onNativeWindowResized(ANativeActivity* activity, ANativeWindow* window) { + (void) activity; + (void) window; } @@ -435,12 +443,16 @@ static void onInputQueueDestroyed(ANativeActivity* activity, AInputQueue* queue) //////////////////////////////////////////////////////////// static void onWindowFocusChanged(ANativeActivity* activity, int focused) { + (void) activity; + (void) focused; } //////////////////////////////////////////////////////////// static void onContentRectChanged(ANativeActivity* activity, const ARect* rect) { + (void) rect; + // Retrieve our activity states from the activity instance sf::priv::ActivityStates* states = sf::priv::retrieveStates(activity); sf::Lock lock(states->mutex); @@ -450,8 +462,8 @@ static void onContentRectChanged(ANativeActivity* activity, const ARect* rect) // Send an event to warn people about the window move/resize sf::Event event; event.type = sf::Event::Resized; - event.size.width = ANativeWindow_getWidth(states->window); - event.size.height = ANativeWindow_getHeight(states->window); + event.size.width = static_cast(ANativeWindow_getWidth(states->window)); + event.size.height = static_cast(ANativeWindow_getHeight(states->window)); states->forwardEvent(event); } @@ -461,12 +473,14 @@ static void onContentRectChanged(ANativeActivity* activity, const ARect* rect) //////////////////////////////////////////////////////////// static void onConfigurationChanged(ANativeActivity* activity) { + (void) activity; } //////////////////////////////////////////////////////////// static void* onSaveInstanceState(ANativeActivity* activity, size_t* outLen) { + (void) activity; *outLen = 0; return NULL; @@ -476,6 +490,7 @@ static void* onSaveInstanceState(ANativeActivity* activity, size_t* outLen) //////////////////////////////////////////////////////////// static void onLowMemory(ANativeActivity* activity) { + (void) activity; } diff --git a/src/SFML/Main/MainWin32.cpp b/src/SFML/Main/MainWin32.cpp index 93a9a528..3e76a7ff 100644 --- a/src/SFML/Main/MainWin32.cpp +++ b/src/SFML/Main/MainWin32.cpp @@ -46,7 +46,10 @@ extern int main(int argc, char* argv[]); //////////////////////////////////////////////////////////// int WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, INT) { + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wpedantic" return main(__argc, __argv); + #pragma GCC diagnostic pop } #endif // SFML_SYSTEM_WINDOWS diff --git a/src/SFML/Network/Ftp.cpp b/src/SFML/Network/Ftp.cpp index 598891db..c76f2f29 100644 --- a/src/SFML/Network/Ftp.cpp +++ b/src/SFML/Network/Ftp.cpp @@ -549,7 +549,7 @@ Ftp::Response Ftp::DataChannel::open(Ftp::TransferMode mode) // Extract the current number while (isdigit(str[index])) { - data[i] = static_cast(data[i] * 10) + static_cast(str[index] - '0'); + data[i] = static_cast(static_cast(data[i] * 10) + static_cast(str[index] - '0')); index++; } diff --git a/src/SFML/Network/IpAddress.cpp b/src/SFML/Network/IpAddress.cpp index 2c6bc6b2..0130c637 100644 --- a/src/SFML/Network/IpAddress.cpp +++ b/src/SFML/Network/IpAddress.cpp @@ -198,7 +198,9 @@ void IpAddress::resolve(const std::string& address) { if (result) { - ip = reinterpret_cast(result->ai_addr)->sin_addr.s_addr; + sockaddr_in sin; + std::memcpy(&sin, result->ai_addr, sizeof(*result->ai_addr)); + ip = sin.sin_addr.s_addr; freeaddrinfo(result); m_address = ip; m_valid = true; diff --git a/src/SFML/Network/TcpSocket.cpp b/src/SFML/Network/TcpSocket.cpp index 7181df0e..02ed063b 100644 --- a/src/SFML/Network/TcpSocket.cpp +++ b/src/SFML/Network/TcpSocket.cpp @@ -178,7 +178,7 @@ Socket::Status TcpSocket::connect(const IpAddress& remoteAddress, unsigned short time.tv_usec = static_cast(timeout.asMicroseconds() % 1000000); // Wait for something to write on our socket (which means that the connection request has returned) - if (select(getHandle() + 1, NULL, &selector, NULL, &time) > 0) + if (select(static_cast(getHandle() + 1), NULL, &selector, NULL, &time) > 0) { // At this point the connection may have been either accepted or refused. // To know whether it's a success or a failure, we must check the address of the connected peer @@ -242,13 +242,13 @@ Socket::Status TcpSocket::send(const void* data, std::size_t size, std::size_t& } // Loop until every byte has been sent - ssize_t result = 0; + int result = 0; for (sent = 0; sent < size; sent += static_cast(result)) { #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wuseless-cast" // Send a chunk of data - result = ::send(getHandle(), static_cast(data) + sent, static_cast(size - sent), flags); + result = static_cast(::send(getHandle(), static_cast(data) + sent, static_cast(size - sent), flags)); #pragma GCC diagnostic pop // Check for errors @@ -326,16 +326,25 @@ Socket::Status TcpSocket::send(Packet& packet) std::vector blockToSend(sizeof(packetSize) + size); // Copy the packet size and data into the block to send + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wnull-dereference" // False positive. std::memcpy(&blockToSend[0], &packetSize, sizeof(packetSize)); + #pragma GCC diagnostic pop if (size > 0) std::memcpy(&blockToSend[0] + sizeof(packetSize), data, size); + // These warnings are ignored here for portability, as even on Windows the + // signature of `send` might change depending on whether Win32 or MinGW is + // being used. #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wuseless-cast" + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wsign-conversion" // Send the data block std::size_t sent; Status status = send(&blockToSend[0] + packet.m_sendPos, static_cast(blockToSend.size() - packet.m_sendPos), sent); #pragma GCC diagnostic pop + #pragma GCC diagnostic pop // In the case of a partial send, record the location to resume from if (status == Partial) diff --git a/src/SFML/Network/Win32/SocketImpl.cpp b/src/SFML/Network/Win32/SocketImpl.cpp index cd2580ab..e639ef2d 100644 --- a/src/SFML/Network/Win32/SocketImpl.cpp +++ b/src/SFML/Network/Win32/SocketImpl.cpp @@ -64,7 +64,7 @@ void SocketImpl::close(SocketHandle sock) void SocketImpl::setBlocking(SocketHandle sock, bool block) { u_long blocking = block ? 0 : 1; - ioctlsocket(sock, FIONBIO, &blocking); + ioctlsocket(sock, static_cast(FIONBIO), &blocking); } diff --git a/src/SFML/System/Unix/SleepImpl.cpp b/src/SFML/System/Unix/SleepImpl.cpp index 6bed85de..474778d4 100644 --- a/src/SFML/System/Unix/SleepImpl.cpp +++ b/src/SFML/System/Unix/SleepImpl.cpp @@ -41,8 +41,8 @@ void sleepImpl(Time time) // Construct the time to wait timespec ti; - ti.tv_nsec = (usecs % 1000000) * 1000; - ti.tv_sec = usecs / 1000000; + ti.tv_nsec = static_cast((usecs % 1000000) * 1000); + ti.tv_sec = static_cast(usecs / 1000000); // Wait... // If nanosleep returns -1, we check errno. If it is EINTR diff --git a/src/SFML/System/Win32/ClockImpl.cpp b/src/SFML/System/Win32/ClockImpl.cpp index 2f69ece6..3d28d7ea 100644 --- a/src/SFML/System/Win32/ClockImpl.cpp +++ b/src/SFML/System/Win32/ClockImpl.cpp @@ -56,7 +56,7 @@ Time ClockImpl::getCurrentTime() { // Calculate inverse of frequency multiplied by 1000000 to prevent overflow in final calculation // Frequency is constant across the program lifetime - static double inverse = 1000000.0 / getFrequency().QuadPart; + static double inverse = 1000000.0 / static_cast(getFrequency().QuadPart); // Detect if we are on Windows XP or older static bool oldWindows = isWindowsXpOrOlder(); @@ -80,7 +80,7 @@ Time ClockImpl::getCurrentTime() } // Return the current time as microseconds - return sf::microseconds(static_cast(time.QuadPart * inverse)); + return sf::microseconds(static_cast(static_cast(time.QuadPart) * inverse)); } } // namespace priv diff --git a/src/SFML/System/Win32/SleepImpl.cpp b/src/SFML/System/Win32/SleepImpl.cpp index e0697c22..056f1c5f 100644 --- a/src/SFML/System/Win32/SleepImpl.cpp +++ b/src/SFML/System/Win32/SleepImpl.cpp @@ -44,7 +44,7 @@ void sleepImpl(Time time) timeBeginPeriod(tc.wPeriodMin); // Wait... - ::Sleep(time.asMilliseconds()); + ::Sleep(static_cast(time.asMilliseconds())); // Reset the timer resolution back to the system default timeEndPeriod(tc.wPeriodMin); diff --git a/src/SFML/Window/GlContext.cpp b/src/SFML/Window/GlContext.cpp index 9ed2315e..9074d31a 100644 --- a/src/SFML/Window/GlContext.cpp +++ b/src/SFML/Window/GlContext.cpp @@ -291,14 +291,14 @@ namespace { std::size_t prefixLength = std::strlen(prefix); - if ((std::strlen(version) >= (prefixLength + 3)) && - (std::strncmp(version, prefix, prefixLength) == 0) && - std::isdigit(version[prefixLength]) && - (version[prefixLength + 1] == '.') && - std::isdigit(version[prefixLength + 2])) - { - major = static_cast(version[prefixLength] - '0'); - minor = static_cast(version[prefixLength + 2] - '0'); + if ((std::strlen(version) >= (prefixLength + 3)) && + (std::strncmp(version, prefix, prefixLength) == 0) && + std::isdigit(version[prefixLength]) && + (version[prefixLength + 1] == '.') && + std::isdigit(version[prefixLength + 2])) + { + major = static_cast(version[prefixLength] - '0'); + minor = static_cast(version[prefixLength + 2] - '0'); return true; } diff --git a/src/SFML/Window/Unix/WindowImplX11.cpp b/src/SFML/Window/Unix/WindowImplX11.cpp index f46d9df7..569f5f15 100644 --- a/src/SFML/Window/Unix/WindowImplX11.cpp +++ b/src/SFML/Window/Unix/WindowImplX11.cpp @@ -48,6 +48,7 @@ #include #include #include +#include #ifdef SFML_OPENGL_ES #include @@ -81,10 +82,10 @@ namespace static const unsigned int maxTrialsCount = 5; - // Predicate we use to find key repeat events in processEvent - struct KeyRepeatFinder - { - KeyRepeatFinder(unsigned int initalKeycode, Time initialTime) : keycode(initalKeycode), time(initialTime) {} + // Predicate we use to find key repeat events in processEvent + struct KeyRepeatFinder + { + KeyRepeatFinder(unsigned int initalKeycode, Time initialTime) : keycode(initalKeycode), time(initialTime) {} // Predicate operator that checks event type, keycode and timestamp bool operator()(const XEvent& event) @@ -117,11 +118,11 @@ namespace std::size_t offset = 0; ssize_t result = 0; - while ((result = read(file, &buffer[offset], 256)) > 0) - { - buffer.resize(buffer.size() + static_cast(result), 0); - offset += static_cast(result); - } + while ((result = read(file, &buffer[offset], 256)) > 0) + { + buffer.resize(buffer.size() + static_cast(result), 0); + offset += static_cast(result); + } ::close(file); @@ -184,7 +185,10 @@ namespace return false; } + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wcast-align" ::Window rootWindow = *reinterpret_cast< ::Window* >(data); + #pragma GCC diagnostic pop XFree(data); @@ -216,7 +220,10 @@ namespace return false; } + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wcast-align" ::Window childWindow = *reinterpret_cast< ::Window* >(data); + #pragma GCC diagnostic pop XFree(data); @@ -335,7 +342,10 @@ namespace { gotFrameExtents = true; - long* extents = reinterpret_cast(data); + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wcast-align" + long* extents = reinterpret_cast(data); + #pragma GCC diagnostic pop xFrameExtent = extents[0]; // Left. yFrameExtent = extents[2]; // Top. @@ -1056,8 +1066,11 @@ void WindowImplX11::setIcon(unsigned int width, unsigned int height, const Uint8 std::vector icccmIconPixels(2 + width * height, 0); unsigned long* ptr = &icccmIconPixels[0]; + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wnull-dereference" // False positive. *ptr++ = width; *ptr++ = height; + #pragma GCC diagnostic pop for (std::size_t i = 0; i < width * height; ++i) { diff --git a/src/SFML/Window/Win32/CursorImpl.cpp b/src/SFML/Window/Win32/CursorImpl.cpp index 98f5a1cc..725447d6 100755 --- a/src/SFML/Window/Win32/CursorImpl.cpp +++ b/src/SFML/Window/Win32/CursorImpl.cpp @@ -60,8 +60,8 @@ bool CursorImpl::loadFromPixels(const Uint8* pixels, Vector2u size, Vector2u hot std::memset(&bitmapHeader, 0, sizeof(BITMAPV5HEADER)); bitmapHeader.bV5Size = sizeof(BITMAPV5HEADER); - bitmapHeader.bV5Width = size.x; - bitmapHeader.bV5Height = -static_cast(size.y); // Negative indicates origin is in upper-left corner + bitmapHeader.bV5Width = static_cast(size.x); + bitmapHeader.bV5Height = -static_cast(size.y); // Negative indicates origin is in upper-left corner bitmapHeader.bV5Planes = 1; bitmapHeader.bV5BitCount = 32; bitmapHeader.bV5Compression = BI_BITFIELDS; @@ -94,11 +94,11 @@ bool CursorImpl::loadFromPixels(const Uint8* pixels, Vector2u size, Vector2u hot Uint32* bitmapOffset = bitmapData; for (std::size_t remaining = size.x * size.y; remaining > 0; --remaining, pixels += 4) { - *bitmapOffset++ = (pixels[3] << 24) | (pixels[0] << 16) | (pixels[1] << 8) | pixels[2]; + *bitmapOffset++ = static_cast((pixels[3] << 24) | (pixels[0] << 16) | (pixels[1] << 8) | pixels[2]); } // Create a dummy mask bitmap (it won't be used) - HBITMAP mask = CreateBitmap(size.x, size.y, 1, 1, NULL); + HBITMAP mask = CreateBitmap(static_cast(size.x), static_cast(size.y), 1, 1, NULL); if (!mask) { diff --git a/src/SFML/Window/Win32/JoystickImpl.cpp b/src/SFML/Window/Win32/JoystickImpl.cpp index 84985d49..8918cc9b 100644 --- a/src/SFML/Window/Win32/JoystickImpl.cpp +++ b/src/SFML/Window/Win32/JoystickImpl.cpp @@ -152,7 +152,7 @@ namespace if (result != ERROR_SUCCESS) { - sf::err() << "Unable to open registry for joystick at index " << index << ": " << getErrorString(result) << std::endl; + sf::err() << "Unable to open registry for joystick at index " << index << ": " << getErrorString(static_cast(result)) << std::endl; return joystickDescription; } } @@ -172,7 +172,7 @@ namespace if (result != ERROR_SUCCESS) { - sf::err() << "Unable to query registry key for joystick at index " << index << ": " << getErrorString(result) << std::endl; + sf::err() << "Unable to query registry key for joystick at index " << index << ": " << getErrorString(static_cast(result)) << std::endl; return joystickDescription; } @@ -184,7 +184,7 @@ namespace if (result != ERROR_SUCCESS) { - sf::err() << "Unable to open registry key for joystick at index " << index << ": " << getErrorString(result) << std::endl; + sf::err() << "Unable to open registry key for joystick at index " << index << ": " << getErrorString(static_cast(result)) << std::endl; return joystickDescription; } @@ -195,7 +195,7 @@ namespace if (result != ERROR_SUCCESS) { - sf::err() << "Unable to query name for joystick at index " << index << ": " << getErrorString(result) << std::endl; + sf::err() << "Unable to query name for joystick at index " << index << ": " << getErrorString(static_cast(result)) << std::endl; return joystickDescription; } @@ -365,17 +365,17 @@ JoystickState JoystickImpl::update() state.connected = true; // Axes - state.axes[Joystick::X] = (pos.dwXpos - (m_caps.wXmax + m_caps.wXmin) / 2.f) * 200.f / (m_caps.wXmax - m_caps.wXmin); - state.axes[Joystick::Y] = (pos.dwYpos - (m_caps.wYmax + m_caps.wYmin) / 2.f) * 200.f / (m_caps.wYmax - m_caps.wYmin); - state.axes[Joystick::Z] = (pos.dwZpos - (m_caps.wZmax + m_caps.wZmin) / 2.f) * 200.f / (m_caps.wZmax - m_caps.wZmin); - state.axes[Joystick::R] = (pos.dwRpos - (m_caps.wRmax + m_caps.wRmin) / 2.f) * 200.f / (m_caps.wRmax - m_caps.wRmin); - state.axes[Joystick::U] = (pos.dwUpos - (m_caps.wUmax + m_caps.wUmin) / 2.f) * 200.f / (m_caps.wUmax - m_caps.wUmin); - state.axes[Joystick::V] = (pos.dwVpos - (m_caps.wVmax + m_caps.wVmin) / 2.f) * 200.f / (m_caps.wVmax - m_caps.wVmin); + state.axes[Joystick::X] = (static_cast(pos.dwXpos) - static_cast(m_caps.wXmax + m_caps.wXmin) / 2.f) * 200.f / static_cast(m_caps.wXmax - m_caps.wXmin); + state.axes[Joystick::Y] = (static_cast(pos.dwYpos) - static_cast(m_caps.wYmax + m_caps.wYmin) / 2.f) * 200.f / static_cast(m_caps.wYmax - m_caps.wYmin); + state.axes[Joystick::Z] = (static_cast(pos.dwZpos) - static_cast(m_caps.wZmax + m_caps.wZmin) / 2.f) * 200.f / static_cast(m_caps.wZmax - m_caps.wZmin); + state.axes[Joystick::R] = (static_cast(pos.dwRpos) - static_cast(m_caps.wRmax + m_caps.wRmin) / 2.f) * 200.f / static_cast(m_caps.wRmax - m_caps.wRmin); + state.axes[Joystick::U] = (static_cast(pos.dwUpos) - static_cast(m_caps.wUmax + m_caps.wUmin) / 2.f) * 200.f / static_cast(m_caps.wUmax - m_caps.wUmin); + state.axes[Joystick::V] = (static_cast(pos.dwVpos) - static_cast(m_caps.wVmax + m_caps.wVmin) / 2.f) * 200.f / static_cast(m_caps.wVmax - m_caps.wVmin); // Special case for POV, it is given as an angle if (pos.dwPOV != 0xFFFF) { - float angle = pos.dwPOV / 18000.f * 3.141592654f; + float angle = static_cast(pos.dwPOV) / 18000.f * 3.141592654f; state.axes[Joystick::PovX] = std::sin(angle) * 100; state.axes[Joystick::PovY] = std::cos(angle) * 100; } @@ -387,7 +387,7 @@ JoystickState JoystickImpl::update() // Buttons for (unsigned int i = 0; i < Joystick::ButtonCount; ++i) - state.buttons[i] = (pos.dwButtons & (1 << i)) != 0; + state.buttons[i] = (pos.dwButtons & (1u << i)) != 0; } return state; @@ -404,7 +404,7 @@ void JoystickImpl::initializeDInput() { // Try to get the address of the DirectInput8Create entry point typedef HRESULT(WINAPI *DirectInput8CreateFunc)(HINSTANCE, DWORD, REFIID, LPVOID*, LPUNKNOWN); - DirectInput8CreateFunc directInput8Create = reinterpret_cast(GetProcAddress(dinput8dll, "DirectInput8Create")); + DirectInput8CreateFunc directInput8Create = reinterpret_cast(reinterpret_cast(GetProcAddress(dinput8dll, "DirectInput8Create"))); if (directInput8Create) { @@ -643,7 +643,7 @@ bool JoystickImpl::openDInput(unsigned int index) for (int i = 0; i < 4; ++i) { data[8 * 4 + i].pguid = &guids::GUID_POV; - data[8 * 4 + i].dwOfs = static_cast(DIJOFS_POV(i)); + data[8 * 4 + i].dwOfs = static_cast(DIJOFS_POV(static_cast(i))); data[8 * 4 + i].dwType = povType; data[8 * 4 + i].dwFlags = 0; } diff --git a/src/SFML/Window/Win32/VideoModeImpl.cpp b/src/SFML/Window/Win32/VideoModeImpl.cpp index 22385b12..2facb871 100644 --- a/src/SFML/Window/Win32/VideoModeImpl.cpp +++ b/src/SFML/Window/Win32/VideoModeImpl.cpp @@ -43,7 +43,7 @@ std::vector VideoModeImpl::getFullscreenModes() DEVMODE win32Mode; win32Mode.dmSize = sizeof(win32Mode); win32Mode.dmDriverExtra = 0; - for (int count = 0; EnumDisplaySettings(NULL, count, &win32Mode); ++count) + for (int count = 0; EnumDisplaySettings(NULL, static_cast(count), &win32Mode); ++count) { // Convert to sf::VideoMode VideoMode mode(win32Mode.dmPelsWidth, win32Mode.dmPelsHeight, win32Mode.dmBitsPerPel); diff --git a/src/SFML/Window/Win32/VulkanImplWin32.cpp b/src/SFML/Window/Win32/VulkanImplWin32.cpp index d6b1f602..d2eb2a40 100644 --- a/src/SFML/Window/Win32/VulkanImplWin32.cpp +++ b/src/SFML/Window/Win32/VulkanImplWin32.cpp @@ -91,7 +91,7 @@ namespace template bool loadEntryPoint(T& entryPoint, const char* name) { - entryPoint = reinterpret_cast(GetProcAddress(library, name)); + entryPoint = reinterpret_cast(reinterpret_cast(GetProcAddress(library, name))); return (entryPoint != NULL); } diff --git a/src/SFML/Window/Win32/WglContext.cpp b/src/SFML/Window/Win32/WglContext.cpp index 09d306d6..9191503c 100644 --- a/src/SFML/Window/Win32/WglContext.cpp +++ b/src/SFML/Window/Win32/WglContext.cpp @@ -480,8 +480,8 @@ void WglContext::updateSettingsFromPixelFormat() if (wglGetPixelFormatAttribivARB(m_deviceContext, format, PFD_MAIN_PLANE, 2, attributes, values) == TRUE) { - m_settings.depthBits = values[0]; - m_settings.stencilBits = values[1]; + m_settings.depthBits = static_cast(values[0]); + m_settings.stencilBits = static_cast(values[1]); } else { @@ -497,7 +497,7 @@ void WglContext::updateSettingsFromPixelFormat() if (wglGetPixelFormatAttribivARB(m_deviceContext, format, PFD_MAIN_PLANE, 2, sampleAttributes, sampleValues) == TRUE) { - m_settings.antialiasingLevel = sampleValues[0] ? sampleValues[1] : 0; + m_settings.antialiasingLevel = static_cast(sampleValues[0] ? sampleValues[1] : 0); } else { @@ -551,7 +551,7 @@ void WglContext::createSurface(WglContext* shared, unsigned int width, unsigned { int attributes[] = {0, 0}; - m_pbuffer = wglCreatePbufferARB(shared->m_deviceContext, bestFormat, width, height, attributes); + m_pbuffer = wglCreatePbufferARB(shared->m_deviceContext, bestFormat, static_cast(width), static_cast(height), attributes); if (m_pbuffer) { @@ -580,7 +580,7 @@ void WglContext::createSurface(WglContext* shared, unsigned int width, unsigned // with other contexts and thus wglShareLists would always fail // Create the hidden window - m_window = CreateWindowA("STATIC", "", WS_POPUP | WS_DISABLED, 0, 0, width, height, NULL, NULL, GetModuleHandle(NULL), NULL); + m_window = CreateWindowA("STATIC", "", WS_POPUP | WS_DISABLED, 0, 0, static_cast(width), static_cast(height), NULL, NULL, GetModuleHandle(NULL), NULL); ShowWindow(m_window, SW_HIDE); m_deviceContext = GetDC(m_window); @@ -633,9 +633,9 @@ void WglContext::createContext(WglContext* shared) if ((m_settings.majorVersion > 1) || ((m_settings.majorVersion == 1) && (m_settings.minorVersion > 1))) { attributes.push_back(WGL_CONTEXT_MAJOR_VERSION_ARB); - attributes.push_back(m_settings.majorVersion); + attributes.push_back(static_cast(m_settings.majorVersion)); attributes.push_back(WGL_CONTEXT_MINOR_VERSION_ARB); - attributes.push_back(m_settings.minorVersion); + attributes.push_back(static_cast(m_settings.minorVersion)); } // Check if setting the profile is supported diff --git a/src/SFML/Window/Win32/WindowImplWin32.cpp b/src/SFML/Window/Win32/WindowImplWin32.cpp index b489cea3..b2815c85 100755 --- a/src/SFML/Window/Win32/WindowImplWin32.cpp +++ b/src/SFML/Window/Win32/WindowImplWin32.cpp @@ -86,7 +86,7 @@ namespace }; typedef HRESULT (WINAPI* SetProcessDpiAwarenessFuncType)(ProcessDpiAwareness); - SetProcessDpiAwarenessFuncType SetProcessDpiAwarenessFunc = reinterpret_cast(GetProcAddress(shCoreDll, "SetProcessDpiAwareness")); + SetProcessDpiAwarenessFuncType SetProcessDpiAwarenessFunc = reinterpret_cast(reinterpret_cast(GetProcAddress(shCoreDll, "SetProcessDpiAwareness"))); if (SetProcessDpiAwarenessFunc) { @@ -114,7 +114,7 @@ namespace if (user32Dll) { typedef BOOL (WINAPI* SetProcessDPIAwareFuncType)(void); - SetProcessDPIAwareFuncType SetProcessDPIAwareFunc = reinterpret_cast(GetProcAddress(user32Dll, "SetProcessDPIAware")); + SetProcessDPIAwareFuncType SetProcessDPIAwareFunc = reinterpret_cast(reinterpret_cast(GetProcAddress(user32Dll, "SetProcessDPIAware"))); if (SetProcessDPIAwareFunc) { @@ -190,8 +190,8 @@ m_cursorGrabbed (m_fullscreen) HDC screenDC = GetDC(NULL); int left = (GetDeviceCaps(screenDC, HORZRES) - static_cast(mode.width)) / 2; int top = (GetDeviceCaps(screenDC, VERTRES) - static_cast(mode.height)) / 2; - int width = mode.width; - int height = mode.height; + int width = static_cast(mode.width); + int height = static_cast(mode.height); ReleaseDC(NULL, screenDC); // Choose the window style according to the Style parameter @@ -333,7 +333,7 @@ Vector2u WindowImplWin32::getSize() const RECT rect; GetClientRect(m_handle, &rect); - return Vector2u(rect.right - rect.left, rect.bottom - rect.top); + return Vector2u(static_cast(rect.right - rect.left), static_cast(rect.bottom - rect.top)); } @@ -343,7 +343,7 @@ void WindowImplWin32::setSize(const Vector2u& size) // SetWindowPos wants the total size of the window (including title bar and borders), // so we have to compute it RECT rectangle = {0, 0, static_cast(size.x), static_cast(size.y)}; - AdjustWindowRect(&rectangle, GetWindowLongPtr(m_handle, GWL_STYLE), false); + AdjustWindowRect(&rectangle, static_cast(GetWindowLongPtr(m_handle, GWL_STYLE)), false); int width = rectangle.right - rectangle.left; int height = rectangle.bottom - rectangle.top; @@ -376,13 +376,13 @@ void WindowImplWin32::setIcon(unsigned int width, unsigned int height, const Uin } // Create the icon from the pixel array - m_icon = CreateIcon(GetModuleHandleW(NULL), width, height, 1, 32, NULL, &iconPixels[0]); + m_icon = CreateIcon(GetModuleHandleW(NULL), static_cast(width), static_cast(height), 1, 32, NULL, &iconPixels[0]); // Set it as both big and small icon of the window if (m_icon) { - SendMessageW(m_handle, WM_SETICON, ICON_BIG, (LPARAM)m_icon); - SendMessageW(m_handle, WM_SETICON, ICON_SMALL, (LPARAM)m_icon); + SendMessageW(m_handle, WM_SETICON, ICON_BIG, reinterpret_cast(m_icon)); + SendMessageW(m_handle, WM_SETICON, ICON_SMALL, reinterpret_cast(m_icon)); } else { @@ -500,11 +500,11 @@ void WindowImplWin32::switchToFullscreen(const VideoMode& mode) } // Make the window flags compatible with fullscreen mode - SetWindowLongPtr(m_handle, GWL_STYLE, WS_POPUP | WS_CLIPCHILDREN | WS_CLIPSIBLINGS); + SetWindowLongPtr(m_handle, GWL_STYLE, static_cast(WS_POPUP) | static_cast(WS_CLIPCHILDREN) | static_cast(WS_CLIPSIBLINGS)); SetWindowLongPtr(m_handle, GWL_EXSTYLE, WS_EX_APPWINDOW); // Resize the window so that it fits the entire screen - SetWindowPos(m_handle, HWND_TOP, 0, 0, mode.width, mode.height, SWP_FRAMECHANGED); + SetWindowPos(m_handle, HWND_TOP, 0, 0, static_cast(mode.width), static_cast(mode.height), SWP_FRAMECHANGED); ShowWindow(m_handle, SW_SHOW); // Set "this" as the current fullscreen window @@ -1131,7 +1131,7 @@ LRESULT CALLBACK WindowImplWin32::globalOnEvent(HWND handle, UINT message, WPARA if (message == WM_CREATE) { // Get WindowImplWin32 instance (it was passed as the last argument of CreateWindow) - LONG_PTR window = (LONG_PTR)reinterpret_cast(lParam)->lpCreateParams; + LONG_PTR window = reinterpret_cast(reinterpret_cast(lParam)->lpCreateParams); // Set as the "user data" parameter of the window SetWindowLongPtrW(handle, GWLP_USERDATA, window);