VulkanBoundsChecking.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cstdint>
#include <vector>
#include <SDL3/SDL.h>
#include <cassert>
 
namespace vex {

    inline bool validateVectorBounds(uint32_t index, size_t size, const char* name) {
        if (index >= size) {
            log(LogLevel::ERROR,
                        "VulkanBoundsChecking: %s index out of bounds (index: %u, size: %zu)",
                        name, index, size);
            return false;
        }
        return true;
    }

    inline bool validateVectorBounds(size_t index, size_t size, const char* name) {
        if (index >= size) {
            log(LogLevel::ERROR,
                        "VulkanBoundsChecking: %s index out of bounds (index: %zu, size: %zu)",
                        name, index, size);
            return false;
        }
        return true;
    }

    inline bool validateFrameIndex(uint32_t frameIndex, uint32_t maxFrames) {
        if (frameIndex >= maxFrames) {
            log(LogLevel::ERROR,
                        "VulkanBoundsChecking: Frame index %u exceeds MAX_FRAMES_IN_FLIGHT (%u)",
                        frameIndex, maxFrames);
            return false;
        }
        return true;
    }

    inline bool validateImageIndex(uint32_t imageIndex, size_t imageCount) {
        if (imageIndex >= imageCount) {
            log(LogLevel::ERROR,
                        "VulkanBoundsChecking: Image index %u exceeds swapchain image count (%zu)",
                        imageIndex, imageCount);
            return false;
        }
        return true;
    }

    template<typename T>
    inline T safeVectorAccess(const std::vector<T>& vec, size_t index, const char* name, T defaultValue) {
        if (index >= vec.size()) {
            log(LogLevel::ERROR,
                        "VulkanBoundsChecking: Safe access to %s failed (index: %zu, size: %zu)",
                        name, index, vec.size());
            return defaultValue;
        }
        return vec[index];
    }

    template<typename T>
    inline T* safeVectorAccessPtr(std::vector<T>& vec, size_t index, const char* name) {
        if (index >= vec.size()) {
            log(LogLevel::ERROR,
                        "VulkanBoundsChecking: Safe pointer access to %s failed (index: %zu, size: %zu)",
                        name, index, vec.size());
            return nullptr;
        }
        return &vec[index];
    }

    template<typename T>
    inline bool validateVectorSize(const std::vector<T>& vec, size_t expectedSize, const char* name) {
        if (vec.size() != expectedSize) {
            log(LogLevel::ERROR,
                        "VulkanBoundsChecking: %s size mismatch (expected: %zu, actual: %zu)",
                        name, expectedSize, vec.size());
            return false;
        }
        return true;
    }

    template<typename T>
    inline bool validateVectorMinSize(const std::vector<T>& vec, size_t minSize, const char* name) {
        if (vec.size() < minSize) {
            log(LogLevel::ERROR,
                        "VulkanBoundsChecking: %s size too small (minimum: %zu, actual: %zu)",
                        name, minSize, vec.size());
            return false;
        }
        return true;
    }

    inline bool validateFrameVectorConsistency(
        size_t size1, const char* name1,
        size_t size2, const char* name2,
        size_t size3, const char* name3) {
 
        bool valid = true;
 
        if (size1 != size2) {
            log(LogLevel::WARNING,
                       "VulkanBoundsChecking: %s size (%zu) != %s size (%zu)",
                       name1, size1, name2, size2);
            valid = false;
        }
 
        if (size1 != size3) {
            log(LogLevel::WARNING,
                       "VulkanBoundsChecking: %s size (%zu) != %s size (%zu)",
                       name1, size1, name3, size3);
            valid = false;
        }
 
        return valid;
    }

    template<typename T>
    inline bool validateNonNullHandles(const std::vector<T>& vec, const char* name) {
        for (size_t i = 0; i < vec.size(); ++i) {
            if (vec[i] == nullptr || vec[i] == VK_NULL_HANDLE) {
                log(LogLevel::ERROR,
                            "VulkanBoundsChecking: %s contains null/invalid handle at index %zu",
                            name, i);
                return false;
            }
        }
        return true;
    }

    inline void assertSyncObjectConsistency(
        size_t imageAvailSize,
        size_t renderFinishedSize,
        size_t fencesSize,
        size_t poolsSize,
        size_t buffersSize,
        uint32_t expectedSize) {
 
        assert(imageAvailSize == expectedSize &&
               "imageAvailableSemaphores size mismatch with MAX_FRAMES_IN_FLIGHT");
        assert(renderFinishedSize == expectedSize &&
               "renderFinishedSemaphores size mismatch with MAX_FRAMES_IN_FLIGHT");
        assert(fencesSize == expectedSize &&
               "inFlightFences size mismatch with MAX_FRAMES_IN_FLIGHT");
        assert(poolsSize == expectedSize &&
               "commandPools size mismatch with MAX_FRAMES_IN_FLIGHT");
        assert(buffersSize == expectedSize &&
               "commandBuffers size mismatch with MAX_FRAMES_IN_FLIGHT");
    }

    #define VEX_CHECK_FRAME_INDEX(index, maxFrames, funcName) \
        do { \
            if (!vex::validateFrameIndex(index, maxFrames)) { \
                log(LogLevel::ERROR, "%s: Aborting due to invalid frame index", funcName); \
                return; \
            } \
        } while(0)

    #define VEX_CHECK_FRAME_INDEX_BOOL(index, maxFrames, funcName) \
        do { \
            if (!vex::validateFrameIndex(index, maxFrames)) { \
                log(LogLevel::ERROR, "%s: Aborting due to invalid frame index", funcName); \
                return false; \
            } \
        } while(0)

    #define VEX_CHECK_IMAGE_INDEX(index, imageCount, funcName) \
        do { \
            if (!vex::validateImageIndex(index, imageCount)) { \
                log(LogLevel::ERROR, "%s: Aborting due to invalid image index", funcName); \
                return; \
            } \
        } while(0)

    #define VEX_CHECK_BOUNDS(index, size, name) \
        do { \
            if (!vex::validateVectorBounds(index, size, name)) { \
                log(LogLevel::ERROR, "Bounds check failed for %s", name); \
                return; \
            } \
        } while(0)

    #define VEX_CHECK_BOUNDS_BOOL(index, size, name) \
        do { \
            if (!vex::validateVectorBounds(index, size, name)) { \
                log(LogLevel::ERROR, "Bounds check failed for %s", name); \
                return false; \
            } \
        } while(0)
 
} // namespace vex
```
 
Now let me create a documentation file explaining the bounds checking system: