Fix cast issues

Cesium3DTilesSelection/src/EllipsoidTilesetLoader.cpp

@@ -178,11 +178,9 @@ EllipsoidTilesetLoader::createGeometry(const Tile& tile) const {
   static constexpr uint16_t resolution = 24;
 
   std::vector<uint16_t> indices;
-  indices.reserve(
-      static_cast<size_type>(6 * (resolution - 1) * (resolution - 1)));
+  indices.reserve(static_cast<size_t>(6 * (resolution - 1) * (resolution - 1)));
 
-  std::vector<glm::vec3> vertices(
-      static_cast<size_type>(resolution * resolution));
+  std::vector<glm::vec3> vertices(static_cast<size_t>(resolution * resolution));
   std::vector<glm::vec3> normals(vertices.size());
 
   const Ellipsoid& ellipsoid = _projection.getEllipsoid();

Cesium3DTilesSelection/test/TestTilesetContentManager.cpp

@@ -127,8 +127,8 @@ CesiumGltf::Model createGlobeGrid(
   glm::dvec3 max = min;
 
   std::vector<glm::dvec3> positions;
-  indices.reserve(static_cast<size_type>(6 * (width - 1) * (height - 1)));
-  positions.reserve(static_cast<size_type>(width * height));
+  indices.reserve(static_cast<size_t>(6 * (width - 1) * (height - 1)));
+  positions.reserve(static_cast<size_t>(width * height));
   for (uint32_t y = 0; y < height; ++y) {
     for (uint32_t x = 0; x < width; ++x) {
       double longitude = beginPoint.longitude + x * dimension;

CesiumAsync/src/InternalTimegm.cpp

@@ -5,7 +5,6 @@
 
 #include "InternalTimegm.h"
 
-#include <cstddef>
 #include <cstdint>
 #include <ctime>
 

CesiumGeometry/src/QuadtreeRectangleAvailability.cpp

@@ -22,7 +22,7 @@ QuadtreeRectangleAvailability::QuadtreeRectangleAvailability(
     uint32_t maximumLevel) noexcept
     : _tilingScheme(tilingScheme),
       _maximumLevel(maximumLevel),
-      _rootNodes(static_cast<size_type>(
+      _rootNodes(static_cast<size_t>(
           this->_tilingScheme.getRootTilesX() *
           this->_tilingScheme.getRootTilesY())) {
   for (uint32_t j = 0; j < this->_tilingScheme.getRootTilesY(); ++j) {

CesiumGltf/src/Accessor.cpp

@@ -4,7 +4,6 @@
 
 #include <CesiumGltf/BufferView.h>
 
-#include <cstddef>
 #include <cstdint>
 #include <string>
 

CesiumGltfReader/test/TestGltfReader.cpp

@@ -747,7 +747,8 @@ TEST_CASE("GltfReader::loadGltf") {
     const CesiumGltf::Image& image = result.model->images[0];
     CHECK(image.pAsset->width == 2048);
     CHECK(image.pAsset->height == 2048);
-    CHECK(image.pAsset->pixelData.size() == static_cast<size_type>(2048 * 2048 * 4);
+    CHECK(
+        image.pAsset->pixelData.size() == static_cast<size_t>(2048 * 2048 * 4));
 
     CHECK(!result.model->buffers.empty());
     for (const CesiumGltf::Buffer& buffer : result.model->buffers) {

CesiumQuantizedMeshTerrain/src/QuantizedMeshLoader.cpp

@@ -340,7 +340,7 @@ static std::optional<QuantizedMeshView> parseQuantizedMesh(
 
       meshView.octEncodedNormalBuffer = std::span<const std::byte>(
           data.data() + readIndex,
-          static_cast<size_type>(vertexCount * 2));
+          static_cast<size_t>(vertexCount * 2));
     } else if (enableWaterMask && extensionID == 2) {
       // Water Mask
       if (extensionLength == 1) {
@@ -735,7 +735,7 @@ static std::vector<std::byte> generateNormals(
       sizeof(float));
   std::span<float> outputPositions(
       reinterpret_cast<float*>(outputPositionsBuffer.data()),
-      static_cast<size_type>((vertexCount + skirtVertexCount) * 3));
+      static_cast<size_t>((vertexCount + skirtVertexCount) * 3));
   size_t positionOutputIndex = 0;
 
   const glm::dvec3 center(

CesiumQuantizedMeshTerrain/test/TestQuantizedMeshContent.cpp

@@ -419,7 +419,7 @@ void checkGridMesh(
   int32_t v = 0;
 
   std::vector<glm::dvec2> uvs;
-  uvs.reserve(static_cast<size_type>(verticesWidth * verticesHeight));
+  uvs.reserve(static_cast<size_t>(verticesWidth * verticesHeight));
   uint32_t positionIdx = 0;
   uint32_t idx = 0;
   for (uint32_t y = 0; y < verticesHeight; ++y) {
@@ -596,7 +596,7 @@ static void checkGeneratedGridNormal(
     uint32_t verticesHeight) {
   uint32_t totalGridIndices = (verticesWidth - 1) * (verticesHeight - 1) * 6;
   std::vector<glm::vec3> expectedNormals(
-      static_cast<size_type>(verticesWidth * verticesHeight));
+      static_cast<size_t>(verticesWidth * verticesHeight));
   for (uint32_t i = 0; i < totalGridIndices; i += 3) {
     I id0 = indices[i];
     I id1 = indices[i + 1];
@@ -1031,7 +1031,7 @@ TEST_CASE("Test converting quantized mesh to gltf with skirt") {
     uint8_t x = 0, y = 0;
     octEncode(normal, x, y);
     std::vector<std::byte> octNormals(
-        static_cast<size_type>(verticesWidth * verticesHeight * 2));
+        static_cast<size_t>(verticesWidth * verticesHeight * 2));
     for (size_t i = 0; i < octNormals.size(); i += 2) {
       octNormals[i] = std::byte(x);
       octNormals[i + 1] = std::byte(y);
@@ -1073,7 +1073,8 @@ TEST_CASE("Test converting quantized mesh to gltf with skirt") {
 
     REQUIRE(
         static_cast<size_t>(normals.size()) ==
-        (static_cast<size_t>(verticesWidth * verticesHeight + totalSkirtVerticesCount));
+        (static_cast<size_t>(verticesWidth * verticesHeight) +
+         totalSkirtVerticesCount));
     for (int64_t i = 0; i < normals.size(); ++i) {
       REQUIRE(Math::equalsEpsilon(normals[i].x, normal.x, Math::Epsilon2));
       REQUIRE(Math::equalsEpsilon(normals[i].y, normal.y, Math::Epsilon2));
@@ -1119,7 +1120,7 @@ TEST_CASE("Test converting ill-formed quantized mesh") {
   uint8_t x = 0, y = 0;
   octEncode(normal, x, y);
   std::vector<std::byte> octNormals(
-      static_cast<size_type>(verticesWidth * verticesHeight * 2));
+      static_cast<size_t>(verticesWidth * verticesHeight * 2));
   for (size_t i = 0; i < octNormals.size(); i += 2) {
     octNormals[i] = std::byte(x);
     octNormals[i + 1] = std::byte(y);

CesiumRasterOverlays/test/TestQuadtreeRasterOverlayTileProvider.cpp

@@ -96,7 +96,7 @@ class TestTileProvider : public QuadtreeRasterOverlayTileProvider {
       result.pImage->bytesPerChannel = 1;
       result.pImage->channels = 4;
       result.pImage->pixelData.resize(
-          static_cast<size_type>(this->getWidth() * this->getHeight() * 4),
+          static_cast<size_t>(this->getWidth() * this->getHeight() * 4),
           std::byte(tileID.level));
     }