MasterPieceWindow Class Reference

Inheritance diagram for MasterPieceWindow:

Public Types
enum class	PresentModePreference { LowLatency , Vsync }

Public Member Functions
void	applyDifficulty ()
void	applyGravity ()
void	applyShaderEffectsToggle ()
VK_Sprite *	attachPostProcessingShader (const std::string &fragmentShaderPath, float p1=0.0f, float p2=0.0f, float p3=0.0f, float p4=0.0f)
	Attach a full-screen post-processing fragment shader.
std::vector< VK_Sprite * >	attachPostProcessingShaders (const std::vector< PostProcessingEffect > &effects)
bool	canMoveDown ()
bool	canMoveLeft ()
bool	canMoveRight ()
bool	canRotate ()
int	centerX (const char *text)
bool	checkGameOver ()
void	clearFlashedBlocks ()
void	clearTextQueue ()
	Clear all queued text draw calls for the current frame.
VulkanContext	context () const
VK_Sprite *	createSprite (const std::string &pngPath, const std::string &vertexShaderPath="", const std::string &fragmentShaderPath="")
	Create a sprite from a PNG file and register it with this window.
VK_Sprite *	createSprite (int width, int height, const std::string &vertexShaderPath="", const std::string &fragmentShaderPath="")
	Create a blank sprite texture and register it with this window.
VK_Sprite *	createSprite (SDL_Surface *surface, const std::string &vertexShaderPath="", const std::string &fragmentShaderPath="")
	Create a sprite from an SDL surface and register it with this window.
VK_Sprite3D *	createSprite3D (const std::string &pngPath, const std::string &vertexShaderPath="", const std::string &fragmentShaderPath="")
	Create a world-space billboard sprite from a PNG file.
VK_Sprite3D *	createSprite3D (SDL_Surface *surface, const std::string &vertexShaderPath="", const std::string &fragmentShaderPath="")
	Create a world-space billboard sprite from an SDL surface.
void	detachPostProcessingShader ()
	Detach the current post-processing shader and return to direct swapchain rendering.
void	drawblock (float scaleX, float scaleY)
void	drawGame ()
void	drawmatrix (float scaleX, float scaleY)
void	drawnext (float scaleX, float scaleY)
void	dropBlock ()
void	enablePostProcessing (VK_Sprite *sprite)
bool	ensureRenderResources ()
	Ensure deferred render resources are initialized.
void	event (SDL_Event &e) override
	Handle one SDL event.
bool	findMatches ()
void	gameKeypress (SDL_Keycode key)
int	getCharWidth ()
VkCommandPool	getCommandPool () const noexcept
	Get the command pool used for graphics/upload work.
VkFormat	getDepthFormat () const noexcept
	Get the depth format used for dynamic rendering attachments.
VkDevice	getDevice () const noexcept
	Get the Vulkan logical device handle.
VkQueue	getGraphicsQueue () const noexcept
	Get the graphics queue handle.
int	getMenuSpacing ()
VkPhysicalDevice	getPhysicalDevice () const noexcept
	Get the Vulkan physical device handle.
VkPipelineCache	getPipelineCache () const noexcept
	Get the persistent Vulkan pipeline cache used by framework pipelines.
SDL_Window *	getSDLWindow () const noexcept
	Get the underlying SDL window handle.
VkExtent2D	getSwapchainExtent () const noexcept
	Get the current swapchain extent.
VkFormat	getSwapchainFormat () const noexcept
	Get the swapchain color format.
size_t	getSwapchainImageCount () const noexcept
	Get the number of swapchain images currently allocated.
bool	getTextDimensions (const std::string &text, int &width, int &height)
	Measure text dimensions in pixels.
bool	getTextDimensions (const std::string &text, int &width, int &height, const Font &font)
bool	getTextDimensions (const std::string &text, int &width, int &height, TTF_Font *font)
void	goToScoresScreen ()
void	handleControllerButton (Uint8 button)
void	handleTextInput (const char *text)
void	initGfx ()
virtual bool	initVulkan (bool validiation)
	Initialize Vulkan state.
void	logic ()
void	loop ()
	Run the main event/render loop.
	MasterPieceWindow (const std::string &path, int wx, int wy, bool full, bool enable_vsync)
void	moveBlockDown ()
void	moveBlockLeft ()
void	moveBlockRight ()
virtual void	onPrepareFrameRendering (VkCommandBuffer cmd, uint32_t image_index)
	Record resource transitions that must happen before dynamic rendering begins.
bool	openGamepad (SDL_JoystickID id)
void	placeBlock ()
void	pollController ()
void	printText (const std::string &text, int x, int y, const SDL_Color &col)
	Queue a text string for rendering during the current frame.
void	printText (const std::string &text, int x, int y, const SDL_Color &col, const Font &font)
void	printText (const std::string &text, int x, int y, const SDL_Color &col, TTF_Font *font)
void	proc () override
	Execute one processing/update step.
void	release ()
	Release Vulkan and SDL resources.
virtual void	render ()
	Render one frame.
void	rotateBlock ()
void	saveSnapshot (const std::string &path)
	Save the most recently rendered window contents as a PNG file.
int	scaleY (int baseY)
bool	screenshotEnabled () const noexcept
	Check whether F10 screenshot capture is enabled.
void	setClearColor (float r, float g, float b, float a=1.0f)
	Set the per-frame color attachment clear color.
void	setEnableScreenshot (bool enabled) noexcept
	Enable or disable F10 screenshot capture.
void	setFont (const std::string &fontPath, int fontSize=24)
	Set the active text-render font.
void	setPostProcessingEnabled (bool enabled)
void	setPostProcessingShaderParams (float p1=0.0f, float p2=0.0f, float p3=0.0f, float p4=0.0f)
	Set the post-processing shader params passed as a vec4 push constant.
void	setPostProcessingShaderParams (size_t effectIndex, float p1=0.0f, float p2=0.0f, float p3=0.0f, float p4=0.0f)
void	setPostProcessingShaderTimeEnabled (bool enabled)
	Keep shader param 1 updated with elapsed render time in seconds.
void	setPostProcessingShaderTimeEnabled (size_t effectIndex, bool enabled)
void	showCursor (bool on)
void	spawnNewBlock ()
void	startFlash ()
void	trimMemory ()
	Return transient Vulkan command-pool allocations to the driver when supported.
void	tryOpenFirstGamepad ()
void	updateCredits ()
void	updateFontSize ()
void	updateGame ()
void	updateGameOver ()
void	updateIntro ()
void	updateOptions ()
void	updateScores ()
void	updateStart ()
bool	validationEnabled () const
	Check whether Vulkan validation layers are currently enabled.
virtual	~MasterPieceWindow ()

Static Public Member Functions
static VkBool32	debugCallback (VkDebugUtilsMessageSeverityFlagBitsEXT severity, VkDebugUtilsMessageTypeFlagsEXT type, const VkDebugUtilsMessengerCallbackDataEXT *callback_data, void *user_data)

Protected Member Functions
void	captureSnapshotPixels (std::vector< std::uint8_t > &rgba_pixels, uint32_t &width, uint32_t &height)
	Capture the most recently presented swapchain image as tightly packed RGBA8 pixels.
void	createDevice ()
	Create final device resources.
void	createLogicalDevice ()
	Create a logical Vulkan device from the selected physical device.
void	exit ()
	Request loop termination.
bool	initWindow (const std::string &title, int width, int height, SDL_WindowFlags flags)
	Initialize SDL window resources.
virtual void	onConfigureDepthStencilAttachments (VkRenderingAttachmentInfo &depth_attachment, VkRenderingAttachmentInfo &stencil_attachment, uint32_t image_index)
	Allow derived classes to customize depth/stencil attachments for the main dynamic rendering pass.
virtual void	onRecordCustomRendering (VkCommandBuffer cmd, uint32_t image_index)
	Optional hook for derived classes to record extra draw commands.
virtual void	onSwapchainAboutToRecreate ()
	Called right before swapchain-dependent resources are recreated.
virtual void	onSwapchainRecreated ()
	Called after swapchain and render resources are recreated.
void	pickDevice ()
	Pick a suitable Vulkan physical device.
void	renderStandaloneSprite (VK_Sprite &sprite, VkCommandBuffer cmd)
	Render one standalone sprite using the window's shared sprite pipeline.

Static Protected Member Functions
static VkShaderModule	createShaderModule (VkDevice device, const std::vector< char > &spv_bytes)
	Create a shader module from SPIR-V bytecode.
static std::vector< char >	loadSpv (const std::string &path)
	Load a SPIR-V file from disk.

Protected Attributes
bool	active = false
VkClearColorValue	clear_color {{0.0f, 0.0f, 0.0f, 1.0f}}
std::vector< VkCommandBuffer >	command_buffers {}
VkCommandPool	command_pool = VK_NULL_HANDLE
uint32_t	current_frame = 0
VkDebugUtilsMessengerEXT	debug_messenger = VK_NULL_HANDLE
VkFormat	depth_format = VK_FORMAT_UNDEFINED
std::vector< bool >	depth_image_initialized {}
std::vector< VkDeviceMemory >	depth_image_memories {}
std::vector< VkImageView >	depth_image_views {}
std::vector< VkImage >	depth_images {}
VkDevice	device = VK_NULL_HANDLE
bool	font_configured = false
std::string	font_path {}
int	font_size = 24
bool	force_swapchain_recreate = false
bool	fps_counter_enabled = false
Font	fps_counter_font {}
bool	fps_counter_font_ready = false
uint32_t	fps_counter_frame_count = 0
std::chrono::steady_clock::time_point	fps_counter_sample_time {}
std::string	fps_counter_text = "FPS: --"
bool	framebuffer_resized = false
VkQueue	graphics_queue = VK_NULL_HANDLE
uint32_t	graphics_queue_family = invalid_queue_index
std::array< VkSemaphore, max_frames_in_flight >	image_available {}
std::vector< VkFence >	image_fences {}
std::array< VkFence, max_frames_in_flight >	in_flight_fences {}
VkInstance	instance = VK_NULL_HANDLE
std::chrono::steady_clock::time_point	last_memory_trim_time = std::chrono::steady_clock::now()
uint32_t	last_presented_image_index = invalid_queue_index
uint64_t	last_resize_event_ms = 0
VK_Sprite *	owned_post_process_sprite = nullptr
std::vector< VK_Sprite * >	owned_post_process_sprites {}
VkPhysicalDevice	physical_device = VK_NULL_HANDLE
VkPipelineCache	pipeline_cache = VK_NULL_HANDLE
std::vector< std::array< float, 4 > >	post_process_effect_params {}
std::vector< std::chrono::steady_clock::time_point >	post_process_effect_start_times {}
std::vector< bool >	post_process_effect_time_enabled {}
bool	post_process_enabled = true
std::vector< std::vector< VkImage > >	post_process_images {}
std::vector< std::vector< bool > >	post_process_initialized {}
std::vector< std::vector< VkDeviceMemory > >	post_process_memories {}
std::array< float, 4 >	post_process_params {}
VK_Sprite *	post_process_sprite = nullptr
std::vector< VK_Sprite * >	post_process_sprites {}
std::chrono::steady_clock::time_point	post_process_start_time = std::chrono::steady_clock::now()
bool	post_process_time_enabled = false
std::vector< std::vector< VkImageView > >	post_process_views {}
PresentModePreference	present_mode_preference = PresentModePreference::LowLatency
VkQueue	present_queue = VK_NULL_HANDLE
uint32_t	present_queue_family = invalid_queue_index
std::vector< VkSemaphore >	render_finished {}
std::vector< VkSwapchainKHR >	retired_swapchains
bool	screenshot_enabled = defaultEnableScreenshot()
uint32_t	screenshot_index = 0
std::string	screenshot_prefix = defaultExecutableName()
std::condition_variable	screenshot_queue_cv
std::mutex	screenshot_queue_mutex
std::deque< ScreenshotSaveTask >	screenshot_save_queue
std::thread	screenshot_worker
bool	screenshot_worker_stop = false
bool	sdl_initialized = false
VkDescriptorSetLayout	sprite_descriptor_set_layout = VK_NULL_HANDLE
VkPipeline	sprite_pipeline = VK_NULL_HANDLE
VkPipelineLayout	sprite_pipeline_layout = VK_NULL_HANDLE
bool	sprite_state_dirty = false
std::vector< std::unique_ptr< VK_Sprite > >	sprites {}
std::vector< std::unique_ptr< VK_Sprite3D > >	sprites3d {}
VkSurfaceKHR	surface = VK_NULL_HANDLE
VkSwapchainKHR	swapchain = VK_NULL_HANDLE
VkExtent2D	swapchain_extent {}
VkFormat	swapchain_format = VK_FORMAT_UNDEFINED
std::vector< bool >	swapchain_image_initialized {}
std::vector< VkImageView >	swapchain_image_views {}
std::vector< VkImage >	swapchain_images {}
bool	swapchain_supports_transfer_src = false
VkDescriptorSetLayout	text_descriptor_set_layout = VK_NULL_HANDLE
VkPipeline	text_pipeline = VK_NULL_HANDLE
VkPipelineLayout	text_pipeline_layout = VK_NULL_HANDLE
std::unique_ptr< VK_Text >	text_renderer {}
bool	text_state_dirty = false
bool	validation_enabled = false
std::unique_ptr< SDL_Window, SDLWindowDeleter >	window {}

Static Protected Attributes
static constexpr std::chrono::seconds	MEMORY_TRIM_INTERVAL {30}
static constexpr uint64_t	resize_settle_delay_ms = 150

Detailed Description

Definition at line 222 of file acid.drop.cpp.

Member Enumeration Documentation

PresentModePreference

enum class mxvk::VK_Window::PresentModePreference

stronginherited

Enumerator
LowLatency
Vsync

Definition at line 39 of file mxvk.hpp.

                                         {
            LowLatency,
            Vsync
        };

Constructor & Destructor Documentation

MasterPieceWindow()

MasterPieceWindow::MasterPieceWindow ( const std::string & path, int wx, int wy, bool full, bool enable_vsync )

inline

Definition at line 261 of file acid.drop.cpp.

        : mxvk::VK_Window("-[ Acid Drop - Vulkan ]-", wx, wy, full, MXVK_VALIDATION, enable_vsync),
          current_path((path.empty() || path == ".") ? std::string(puzzle_ASSET_DIR) : path),
          w(wx),
          h(wy) {
        tryOpenFirstGamepad();
        updateFontSize();
        srand((unsigned int)time(0));
        lastTick = SDL_GetTicks();
    }

~MasterPieceWindow()

virtual MasterPieceWindow::~MasterPieceWindow ( )

inlinevirtual

Definition at line 272 of file acid.drop.cpp.

                                 {
        if (gamepad != nullptr) {
            SDL_CloseGamepad(gamepad);
            gamepad = nullptr;
        }
    }

Member Function Documentation

applyDifficulty()

void MasterPieceWindow::applyDifficulty ( )

inline

Definition at line 1062 of file acid.drop.cpp.

                           {
 
        int baseSpeeds[] = {30, 20, 10};
        matrix.Game.speed = baseSpeeds[difficultySetting];
    }

applyGravity()

void MasterPieceWindow::applyGravity ( )

inline

Definition at line 1018 of file acid.drop.cpp.

                        {
        bool moved;
        do {
            moved = false;
            for (int i = 0; i < GRID_WIDTH; i++) {
                for (int j = GRID_HEIGHT - 2; j >= 0; j--) {
                    if (matrix.grid[i][j] > 0 && matrix.grid[i][j + 1] == 0) {
 
                        matrix.grid[i][j + 1] = matrix.grid[i][j];
                        matrix.grid[i][j] = 0;
                        moved = true;
                    }
                }
            }
        } while (moved);
    }

applyShaderEffectsToggle()

void MasterPieceWindow::applyShaderEffectsToggle ( )

inline

Definition at line 348 of file acid.drop.cpp.

                                    {
        for (int i = 0; i < SHADER_LEVEL_COUNT; i++) {
            if (gamebg[i])
                gamebg[i]->setEffectsEnabled(shaderEffectsEnabled);
        }
        if (introScreen)
            introScreen->setEffectsEnabled(shaderEffectsEnabled);
        if (startScreen)
            startScreen->setEffectsEnabled(shaderEffectsEnabled);
        if (creditScreen)
            creditScreen->setEffectsEnabled(shaderEffectsEnabled);
        if (scoresBackground)
            scoresBackground->setEffectsEnabled(shaderEffectsEnabled);
        for (auto *block : grid_blocks) {
            if (block)
                block->setEffectsEnabled(shaderEffectsEnabled);
        }
    }

attachPostProcessingShader()

VK_Sprite * mxvk::VK_Window::attachPostProcessingShader ( const std::string & fragmentShaderPath, float p1 = 0.0f, float p2 = 0.0f, float p3 = 0.0f, float p4 = 0.0f )

inherited

Attach a full-screen post-processing fragment shader.

The window renders the normal scene into an offscreen color target, then draws that target through the supplied sprite-compatible fragment shader into the swapchain. Shader params are passed through the existing sprite push-constant vec4.

Parameters

fragmentShaderPath	Post-process fragment shader SPIR-V path.
p1	First shader parameter.
p2	Second shader parameter.
p3	Third shader parameter.
p4	Fourth shader parameter.

Returns

Non-owning pointer to the internal post-process sprite for advanced setup.

Definition at line 1154 of file mxvk.cpp.

                                                                                                                                {
        const std::vector<VK_Sprite *> sprites = attachPostProcessingShaders({PostProcessingEffect{fragmentShaderPath, {p1, p2, p3, p4}, false}});
        return sprites.empty() ? nullptr : sprites.front();
    }

attachPostProcessingShaders()

std::vector< VK_Sprite * > mxvk::VK_Window::attachPostProcessingShaders ( const std::vector< PostProcessingEffect > & effects )

inherited

Definition at line 1159 of file mxvk.cpp.

                                                                                                                {
        detachPostProcessingShader();
 
        std::vector<VK_Sprite *> attachedSprites;
        attachedSprites.reserve(effects.size());
        for (const PostProcessingEffect &effect : effects) {
            if (effect.fragmentShaderPath.empty()) {
                throw mxvk::Exception("Cannot attach post-processing shader with an empty fragment shader path");
            }
 
            VK_Sprite *sprite = createSprite(
                1,
                1,
                resolveRuntimeShaderPath("sprite.vert.spv", MXVK_SPRITE_SHADER_DIR),
                effect.fragmentShaderPath);
            const uint32_t black_pixel = 0xFF000000u;
            sprite->updateTexture(&black_pixel, 1, 1);
            sprite->setShaderParams(effect.params[0], effect.params[1], effect.params[2], effect.params[3]);
 
            attachedSprites.push_back(sprite);
            owned_post_process_sprites.push_back(sprite);
            post_process_sprites.push_back(sprite);
            post_process_effect_params.push_back(effect.params);
            post_process_effect_time_enabled.push_back(effect.timeEnabled);
            post_process_effect_start_times.push_back(std::chrono::steady_clock::now());
        }
 
        post_process_sprite = attachedSprites.empty() ? nullptr : attachedSprites.front();
        owned_post_process_sprite = post_process_sprite;
        post_process_params = post_process_effect_params.empty() ? std::array<float, 4>{} : post_process_effect_params.front();
        post_process_time_enabled = !post_process_effect_time_enabled.empty() && post_process_effect_time_enabled.front();
        post_process_start_time = post_process_effect_start_times.empty() ? std::chrono::steady_clock::now() : post_process_effect_start_times.front();
        if (device != VK_NULL_HANDLE && !swapchain_images.empty()) {
            createPostProcessTargets();
        }
        sprite_state_dirty = true;
        return attachedSprites;
    }

canMoveDown()

bool MasterPieceWindow::canMoveDown ( )

inline

Definition at line 786 of file acid.drop.cpp.

                       {
        int bx = matrix.block.x;
        int by = matrix.block.y;
 
        if (matrix.block.horizontal) {
 
            if (by + 1 >= GRID_HEIGHT)
                return false;
            for (int i = 0; i < 3; i++) {
                if (bx + i >= 0 && bx + i < GRID_WIDTH && matrix.grid[bx + i][by + 1] > 0)
                    return false;
            }
        } else {
 
            if (by + 3 >= GRID_HEIGHT)
                return false;
            if (matrix.grid[bx][by + 3] > 0)
                return false;
        }
 
        return true;
    }

canMoveLeft()

bool MasterPieceWindow::canMoveLeft ( )

inline

Definition at line 809 of file acid.drop.cpp.

                       {
        if (matrix.block.x <= 0)
            return false;
        int bx = matrix.block.x - 1;
        int by = matrix.block.y;
 
        if (matrix.block.horizontal) {
 
            if (by >= 0 && by < GRID_HEIGHT && matrix.grid[bx][by] > 0)
                return false;
        } else {
 
            if (by >= 0 && by < GRID_HEIGHT && matrix.grid[bx][by] > 0)
                return false;
            if (by + 1 >= 0 && by + 1 < GRID_HEIGHT && matrix.grid[bx][by + 1] > 0)
                return false;
            if (by + 2 >= 0 && by + 2 < GRID_HEIGHT && matrix.grid[bx][by + 2] > 0)
                return false;
        }
 
        return true;
    }

canMoveRight()

bool MasterPieceWindow::canMoveRight ( )

inline

Definition at line 832 of file acid.drop.cpp.

                        {
        int by = matrix.block.y;
 
        if (matrix.block.horizontal) {
 
            if (matrix.block.x + 3 >= GRID_WIDTH)
                return false;
            int bx = matrix.block.x + 3;
            if (by >= 0 && by < GRID_HEIGHT && matrix.grid[bx][by] > 0)
                return false;
        } else {
 
            if (matrix.block.x >= GRID_WIDTH - 1)
                return false;
            int bx = matrix.block.x + 1;
            if (by >= 0 && by < GRID_HEIGHT && matrix.grid[bx][by] > 0)
                return false;
            if (by + 1 >= 0 && by + 1 < GRID_HEIGHT && matrix.grid[bx][by + 1] > 0)
                return false;
            if (by + 2 >= 0 && by + 2 < GRID_HEIGHT && matrix.grid[bx][by + 2] > 0)
                return false;
        }
 
        return true;
    }

canRotate()

bool MasterPieceWindow::canRotate ( )

inline

Definition at line 1092 of file acid.drop.cpp.

                     {
        int bx = matrix.block.x;
        int by = matrix.block.y;
 
        if (matrix.block.horizontal) {
 
            if (by + 2 >= GRID_HEIGHT)
                return false;
 
            if (by + 1 < GRID_HEIGHT && matrix.grid[bx][by + 1] > 0)
                return false;
            if (by + 2 < GRID_HEIGHT && matrix.grid[bx][by + 2] > 0)
                return false;
        } else {
 
            if (bx + 2 >= GRID_WIDTH)
                return false;
 
            if (bx + 1 < GRID_WIDTH && by >= 0 && by < GRID_HEIGHT && matrix.grid[bx + 1][by] > 0)
                return false;
            if (bx + 2 < GRID_WIDTH && by >= 0 && by < GRID_HEIGHT && matrix.grid[bx + 2][by] > 0)
                return false;
        }
        return true;
    }

captureSnapshotPixels()

void mxvk::VK_Window::captureSnapshotPixels ( std::vector< std::uint8_t > & rgba_pixels, uint32_t & width, uint32_t & height )

protectedinherited

Capture the most recently presented swapchain image as tightly packed RGBA8 pixels.

This performs a synchronous GPU readback and may briefly stall rendering.

Definition at line 800 of file mxvk.cpp.

                                                                                                               {
        if (device == VK_NULL_HANDLE || command_pool == VK_NULL_HANDLE || graphics_queue == VK_NULL_HANDLE) {
            throw mxvk::Exception("captureSnapshotPixels called before Vulkan render resources are ready");
        }
        if (!swapchain_supports_transfer_src) {
            throw mxvk::Exception("captureSnapshotPixels requires swapchain transfer-source support");
        }
        if (last_presented_image_index == invalid_queue_index ||
            last_presented_image_index >= swapchain_images.size() ||
            last_presented_image_index >= image_fences.size()) {
            throw mxvk::Exception("captureSnapshotPixels called before a frame has been presented");
        }
        if (swapchain_extent.width == 0U || swapchain_extent.height == 0U) {
            throw mxvk::Exception("captureSnapshotPixels cannot capture an empty swapchain extent");
        }
 
        const bool format_is_bgra =
            swapchain_format == VK_FORMAT_B8G8R8A8_UNORM ||
            swapchain_format == VK_FORMAT_B8G8R8A8_SRGB;
        const bool format_is_rgba =
            swapchain_format == VK_FORMAT_R8G8B8A8_UNORM ||
            swapchain_format == VK_FORMAT_R8G8B8A8_SRGB;
        if (!format_is_bgra && !format_is_rgba) {
            throw mxvk::Exception(std::format("captureSnapshotPixels unsupported swapchain format: {}", static_cast<int>(swapchain_format)));
        }
 
        const VkDeviceSize row_bytes = static_cast<VkDeviceSize>(swapchain_extent.width) * 4U;
        const VkDeviceSize image_bytes = row_bytes * static_cast<VkDeviceSize>(swapchain_extent.height);
 
        VkBuffer readback_buffer = VK_NULL_HANDLE;
        VkDeviceMemory readback_memory = VK_NULL_HANDLE;
        VkCommandBuffer command_buffer = VK_NULL_HANDLE;
        VkFence copy_fence = VK_NULL_HANDLE;
 
        auto cleanup = [&]() {
            if (copy_fence != VK_NULL_HANDLE) {
                vkDestroyFence(device, copy_fence, nullptr);
            }
            if (command_buffer != VK_NULL_HANDLE) {
                vkFreeCommandBuffers(device, command_pool, 1, &command_buffer);
            }
            if (readback_buffer != VK_NULL_HANDLE) {
                vkDestroyBuffer(device, readback_buffer, nullptr);
            }
            if (readback_memory != VK_NULL_HANDLE) {
                vkFreeMemory(device, readback_memory, nullptr);
            }
        };
 
        try {
            VkBufferCreateInfo buffer_info{};
            buffer_info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
            buffer_info.size = image_bytes;
            buffer_info.usage = VK_BUFFER_USAGE_TRANSFER_DST_BIT;
            buffer_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
            if (vkCreateBuffer(device, &buffer_info, nullptr, &readback_buffer) != VK_SUCCESS) {
                throw mxvk::Exception("captureSnapshotPixels failed to create readback buffer");
            }
 
            VkMemoryRequirements memory_requirements{};
            vkGetBufferMemoryRequirements(device, readback_buffer, &memory_requirements);
 
            VkPhysicalDeviceMemoryProperties memory_properties{};
            vkGetPhysicalDeviceMemoryProperties(physical_device, &memory_properties);
            uint32_t memory_type_index = invalid_queue_index;
            constexpr VkMemoryPropertyFlags required_properties =
                VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
            for (uint32_t i = 0; i < memory_properties.memoryTypeCount; ++i) {
                const bool type_matches = (memory_requirements.memoryTypeBits & (1U << i)) != 0U;
                const bool properties_match =
                    (memory_properties.memoryTypes[i].propertyFlags & required_properties) == required_properties;
                if (type_matches && properties_match) {
                    memory_type_index = i;
                    break;
                }
            }
            if (memory_type_index == invalid_queue_index) {
                throw mxvk::Exception("captureSnapshotPixels failed to find host-visible coherent memory");
            }
 
            VkMemoryAllocateInfo allocation_info{};
            allocation_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
            allocation_info.allocationSize = memory_requirements.size;
            allocation_info.memoryTypeIndex = memory_type_index;
            if (vkAllocateMemory(device, &allocation_info, nullptr, &readback_memory) != VK_SUCCESS) {
                throw mxvk::Exception("captureSnapshotPixels failed to allocate readback memory");
            }
            if (vkBindBufferMemory(device, readback_buffer, readback_memory, 0) != VK_SUCCESS) {
                throw mxvk::Exception("captureSnapshotPixels failed to bind readback memory");
            }
 
            VkCommandBufferAllocateInfo command_buffer_info{};
            command_buffer_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
            command_buffer_info.commandPool = command_pool;
            command_buffer_info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
            command_buffer_info.commandBufferCount = 1;
            if (vkAllocateCommandBuffers(device, &command_buffer_info, &command_buffer) != VK_SUCCESS) {
                throw mxvk::Exception("captureSnapshotPixels failed to allocate command buffer");
            }
 
            VkFenceCreateInfo fence_info{};
            fence_info.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
            if (vkCreateFence(device, &fence_info, nullptr, &copy_fence) != VK_SUCCESS) {
                throw mxvk::Exception("captureSnapshotPixels failed to create copy fence");
            }
 
            VkFence source_fence = image_fences[last_presented_image_index];
            if (source_fence != VK_NULL_HANDLE) {
                const VkResult wait_result = vkWaitForFences(device, 1, &source_fence, VK_TRUE, UINT64_MAX);
                if (wait_result != VK_SUCCESS) {
                    throw mxvk::Exception(std::format("captureSnapshotPixels failed waiting for rendered frame: {}", static_cast<int>(wait_result)));
                }
            }
 
            const VkResult idle_result = vkDeviceWaitIdle(device);
            if (idle_result != VK_SUCCESS) {
                throw mxvk::Exception(std::format("captureSnapshotPixels failed waiting for device idle: {}", static_cast<int>(idle_result)));
            }
 
            VkCommandBufferBeginInfo begin_info{};
            begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
            begin_info.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
            if (vkBeginCommandBuffer(command_buffer, &begin_info) != VK_SUCCESS) {
                throw mxvk::Exception("captureSnapshotPixels failed to begin copy command buffer");
            }
 
            VkImageMemoryBarrier2 to_transfer_barrier{};
            to_transfer_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2;
            to_transfer_barrier.srcStageMask = VK_PIPELINE_STAGE_2_NONE;
            to_transfer_barrier.srcAccessMask = VK_ACCESS_2_NONE;
            to_transfer_barrier.dstStageMask = VK_PIPELINE_STAGE_2_TRANSFER_BIT;
            to_transfer_barrier.dstAccessMask = VK_ACCESS_2_TRANSFER_READ_BIT;
            to_transfer_barrier.oldLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
            to_transfer_barrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
            to_transfer_barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
            to_transfer_barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
            to_transfer_barrier.image = swapchain_images[last_presented_image_index];
            to_transfer_barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
            to_transfer_barrier.subresourceRange.baseMipLevel = 0;
            to_transfer_barrier.subresourceRange.levelCount = 1;
            to_transfer_barrier.subresourceRange.baseArrayLayer = 0;
            to_transfer_barrier.subresourceRange.layerCount = 1;
 
            VkDependencyInfo to_transfer_dependency{};
            to_transfer_dependency.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO;
            to_transfer_dependency.imageMemoryBarrierCount = 1;
            to_transfer_dependency.pImageMemoryBarriers = &to_transfer_barrier;
            vkCmdPipelineBarrier2(command_buffer, &to_transfer_dependency);
 
            VkBufferImageCopy copy_region{};
            copy_region.bufferOffset = 0;
            copy_region.bufferRowLength = 0;
            copy_region.bufferImageHeight = 0;
            copy_region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
            copy_region.imageSubresource.mipLevel = 0;
            copy_region.imageSubresource.baseArrayLayer = 0;
            copy_region.imageSubresource.layerCount = 1;
            copy_region.imageOffset = {0, 0, 0};
            copy_region.imageExtent = {swapchain_extent.width, swapchain_extent.height, 1};
            vkCmdCopyImageToBuffer(command_buffer,
                                   swapchain_images[last_presented_image_index],
                                   VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
                                   readback_buffer,
                                   1,
                                   &copy_region);
 
            VkImageMemoryBarrier2 to_present_barrier{};
            to_present_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2;
            to_present_barrier.srcStageMask = VK_PIPELINE_STAGE_2_TRANSFER_BIT;
            to_present_barrier.srcAccessMask = VK_ACCESS_2_TRANSFER_READ_BIT;
            to_present_barrier.dstStageMask = VK_PIPELINE_STAGE_2_NONE;
            to_present_barrier.dstAccessMask = VK_ACCESS_2_NONE;
            to_present_barrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
            to_present_barrier.newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
            to_present_barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
            to_present_barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
            to_present_barrier.image = swapchain_images[last_presented_image_index];
            to_present_barrier.subresourceRange = to_transfer_barrier.subresourceRange;
 
            VkDependencyInfo to_present_dependency{};
            to_present_dependency.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO;
            to_present_dependency.imageMemoryBarrierCount = 1;
            to_present_dependency.pImageMemoryBarriers = &to_present_barrier;
            vkCmdPipelineBarrier2(command_buffer, &to_present_dependency);
 
            if (vkEndCommandBuffer(command_buffer) != VK_SUCCESS) {
                throw mxvk::Exception("captureSnapshotPixels failed to end copy command buffer");
            }
 
            VkCommandBufferSubmitInfo command_submit_info{};
            command_submit_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO;
            command_submit_info.commandBuffer = command_buffer;
 
            VkSubmitInfo2 submit_info{};
            submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO_2;
            submit_info.commandBufferInfoCount = 1;
            submit_info.pCommandBufferInfos = &command_submit_info;
 
            const VkResult submit_result = vkQueueSubmit2(graphics_queue, 1, &submit_info, copy_fence);
            if (submit_result != VK_SUCCESS) {
                throw mxvk::Exception(std::format("captureSnapshotPixels failed to submit copy command: {}", static_cast<int>(submit_result)));
            }
            const VkResult copy_wait_result = vkWaitForFences(device, 1, &copy_fence, VK_TRUE, UINT64_MAX);
            if (copy_wait_result != VK_SUCCESS) {
                throw mxvk::Exception(std::format("captureSnapshotPixels failed waiting for copy: {}", static_cast<int>(copy_wait_result)));
            }
 
            void *mapped = nullptr;
            if (vkMapMemory(device, readback_memory, 0, image_bytes, 0, &mapped) != VK_SUCCESS) {
                throw mxvk::Exception("captureSnapshotPixels failed to map readback memory");
            }
 
            const auto *src = static_cast<const std::uint8_t *>(mapped);
            rgba_pixels.resize(static_cast<std::size_t>(image_bytes));
            for (std::size_t i = 0; i < rgba_pixels.size(); i += 4U) {
                if (format_is_bgra) {
                    rgba_pixels[i + 0U] = src[i + 2U];
                    rgba_pixels[i + 1U] = src[i + 1U];
                    rgba_pixels[i + 2U] = src[i + 0U];
                    rgba_pixels[i + 3U] = src[i + 3U];
                } else {
                    rgba_pixels[i + 0U] = src[i + 0U];
                    rgba_pixels[i + 1U] = src[i + 1U];
                    rgba_pixels[i + 2U] = src[i + 2U];
                    rgba_pixels[i + 3U] = src[i + 3U];
                }
            }
            vkUnmapMemory(device, readback_memory);
            width = swapchain_extent.width;
            height = swapchain_extent.height;
        } catch (...) {
            cleanup();
            throw;
        }
 
        cleanup();
    }

centerX()

int MasterPieceWindow::centerX ( const char * text )

inline

Definition at line 379 of file acid.drop.cpp.

                                  {
        int width, height;
        if (getTextDimensions(text, width, height)) {
            return w / 2 - width / 2;
        }
        return w / 2 - (int)(strlen(text) * getCharWidth() / 2);
    }

checkGameOver()

bool MasterPieceWindow::checkGameOver ( )

inline

Definition at line 1043 of file acid.drop.cpp.

                         {
 
        for (int i = 0; i < GRID_WIDTH; i++) {
            if (matrix.grid[i][1] > 0) {
                return true;
            }
        }
 
        for (int i = 0; i < GRID_WIDTH; i++) {
            for (int j = 0; j < GRID_HEIGHT; j++) {
                if (matrix.grid[i][j] == 0) {
                    return false;
                }
            }
        }
 
        return true;
    }

clearFlashedBlocks()

void MasterPieceWindow::clearFlashedBlocks ( )

inline

Definition at line 993 of file acid.drop.cpp.

                              {
        for (int i = 0; i < GRID_WIDTH; i++) {
            for (int j = 0; j < GRID_HEIGHT; j++) {
                if (flashGrid[i][j]) {
                    matrix.grid[i][j] = 0;
                    matrix.Game.addline();
                }
            }
        }
        matrix.Game.score += matchBonus;
        matchBonus = 0;
        int newLevel = matrix.Game.lines / SHADER_LEVEL_LINES;
        if (newLevel >= SHADER_LEVEL_COUNT)
            newLevel = SHADER_LEVEL_COUNT - 1;
        if (newLevel != shaderLevel) {
            shaderLevel = newLevel;
            std::cout << "level increased to: " << shaderLevel << std::endl;
        }
        memset(flashGrid, false, sizeof(flashGrid));
        spawnNewBlock();
        if (checkGameOver()) {
            currentScreen = SCREEN_GAMEOVER;
        }
    }

clearTextQueue()

void mxvk::VK_Window::clearTextQueue ( )

inherited

Clear all queued text draw calls for the current frame.

Definition at line 3063 of file mxvk.cpp.

                                   {
        if (text_renderer) {
            text_renderer->clearQueue();
        }
    }

context()

VulkanContext mxvk::VK_Window::context ( ) const

inherited

Definition at line 59 of file mxvk.cpp.

                                           {
        return VulkanContext{
            .device = getDevice(),
            .physical_device = getPhysicalDevice(),
            .graphics_queue = getGraphicsQueue(),
            .command_pool = getCommandPool(),
        };
    }

createDevice()

void mxvk::VK_Window::createDevice ( )

protectedinherited

Create final device resources.

Definition at line 1645 of file mxvk.cpp.

                                 {
        std::cout << "mxvk: entering createDevice\n";
        if (device == VK_NULL_HANDLE) {
            std::cout << "vk: skipping createDevice because logical device is null\n";
            return;
        }
 
        const bool sync_ready =
            std::ranges::all_of(image_available.begin(), image_available.end(), [](VkSemaphore semaphore) { return semaphore != VK_NULL_HANDLE; }) &&
            render_finished.size() == swapchain_images.size() &&
            std::ranges::all_of(render_finished.begin(), render_finished.end(), [](VkSemaphore semaphore) { return semaphore != VK_NULL_HANDLE; }) &&
            std::ranges::all_of(in_flight_fences.begin(), in_flight_fences.end(), [](VkFence fence) { return fence != VK_NULL_HANDLE; });
 
        if (swapchain != VK_NULL_HANDLE && command_pool != VK_NULL_HANDLE && !command_buffers.empty() &&
            sync_ready && image_fences.size() == swapchain_images.size()) {
            std::cout << "vk: createDevice skipped because render resources are already initialized\n";
            return;
        }
 
        std::cout << "vk: creating swapchain\n";
        if (!createSwapchain(VK_NULL_HANDLE)) {
            std::cout << "vk: createSwapchain failed\n";
            return;
        }
 
        std::cout << "vk: creating render resources\n";
        if (!createRenderResources()) {
            std::cout << "vk: createRenderResources failed\n";
            return;
        }
 
        std::cout << "vk: creating synchronization objects\n";
        if (!createSyncObjects()) {
            std::cout << "vk: createSyncObjects failed\n";
            return;
        }
 
        std::cout << "mxvk: createDevice complete\n";
    }

createLogicalDevice()

void mxvk::VK_Window::createLogicalDevice ( )

protectedinherited

Create a logical Vulkan device from the selected physical device.

Definition at line 1514 of file mxvk.cpp.

                                        {
        std::cout << "mxvk: entering createLogicalDevice\n";
        if (physical_device == VK_NULL_HANDLE) {
            std::cout << "vk: cannot create logical device without a selected physical device\n";
            return;
        }
 
        std::vector<uint32_t> queue_families{};
        queue_families.push_back(graphics_queue_family);
        if (present_queue_family != graphics_queue_family) {
            queue_families.push_back(present_queue_family);
        }
 
        constexpr float queue_priority = 1.0f;
        std::vector<VkDeviceQueueCreateInfo> queue_create_infos{};
        queue_create_infos.reserve(queue_families.size());
        for (const uint32_t family : queue_families) {
            VkDeviceQueueCreateInfo queue_create_info{};
            queue_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
            queue_create_info.queueFamilyIndex = family;
            queue_create_info.queueCount = 1;
            queue_create_info.pQueuePriorities = &queue_priority;
            queue_create_infos.push_back(queue_create_info);
        }
        uint32_t device_extension_count = 0;
        vkEnumerateDeviceExtensionProperties(physical_device, nullptr, &device_extension_count, nullptr);
        std::vector<VkExtensionProperties> device_extensions(device_extension_count);
        if (device_extension_count > 0U) {
            vkEnumerateDeviceExtensionProperties(physical_device, nullptr, &device_extension_count, device_extensions.data());
        }
 
        [[maybe_unused]] const auto has_device_extension = [&device_extensions](const char *extension_name) {
            return std::ranges::any_of(
                device_extensions,
                [extension_name](const VkExtensionProperties &ext) {
                    return std::strcmp(ext.extensionName, extension_name) == 0;
                });
        };
 
        std::vector<const char *> required_device_extensions = {VK_KHR_SWAPCHAIN_EXTENSION_NAME};
#if defined(MXVK_CUDA) && defined(__linux__)
        if (has_device_extension(VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME)) {
            if (has_device_extension(VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME)) {
                required_device_extensions.push_back(VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME);
            }
            required_device_extensions.push_back(VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME);
            std::cout << "vk: enabling external memory FD support for CUDA interop\n";
        } else {
            std::cout << "vk: external memory FD support unavailable; CUDA texture interop will fall back\n";
        }
#endif
 
#if defined(MXVK_USE_MOLTENVK)
        const bool has_portability_subset = std::ranges::any_of(
            device_extensions,
            [](const VkExtensionProperties &ext) {
                return std::strcmp(ext.extensionName, VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME) == 0;
            });
 
        if (has_portability_subset) {
            required_device_extensions.push_back(VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME);
        }
#endif
        VkPhysicalDeviceFeatures2 features2{};
        features2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
        VkPhysicalDeviceVulkan13Features supported_vulkan13_features{};
        supported_vulkan13_features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES;
        features2.pNext = &supported_vulkan13_features;
        vkGetPhysicalDeviceFeatures2(physical_device, &features2);
 
        std::cout << std::format(
            "vk: feature support - synchronization2={}, dynamicRendering={}, shaderFloat64={}, fillModeNonSolid={}, samplerAnisotropy={}\n",
            supported_vulkan13_features.synchronization2 == VK_TRUE ? "true" : "false",
            supported_vulkan13_features.dynamicRendering == VK_TRUE ? "true" : "false",
            features2.features.shaderFloat64 == VK_TRUE ? "true" : "false",
            features2.features.fillModeNonSolid == VK_TRUE ? "true" : "false",
            features2.features.samplerAnisotropy == VK_TRUE ? "true" : "false");
 
        if (supported_vulkan13_features.synchronization2 != VK_TRUE) {
            std::cout << "vk: synchronization2 is unsupported on selected physical device\n";
            return;
        }
        if (supported_vulkan13_features.dynamicRendering != VK_TRUE) {
            std::cout << "vk: dynamic rendering is unsupported on selected physical device\n";
            return;
        }
        VkPhysicalDeviceVulkan13Features vulkan13_features{};
        vulkan13_features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES;
        vulkan13_features.synchronization2 = VK_TRUE;
        vulkan13_features.dynamicRendering = VK_TRUE;
 
        VkPhysicalDeviceFeatures2 enabled_features2{};
        enabled_features2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
        enabled_features2.features.shaderFloat64 = features2.features.shaderFloat64;
        enabled_features2.features.fillModeNonSolid = features2.features.fillModeNonSolid;
        enabled_features2.features.samplerAnisotropy = features2.features.samplerAnisotropy;
 
        enabled_features2.pNext = &vulkan13_features;
 
        VkDeviceCreateInfo create_info{};
        create_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
        create_info.pNext = &enabled_features2;
        create_info.queueCreateInfoCount = static_cast<uint32_t>(queue_create_infos.size());
        create_info.pQueueCreateInfos = queue_create_infos.data();
        create_info.enabledExtensionCount = static_cast<uint32_t>(required_device_extensions.size());
        create_info.ppEnabledExtensionNames = required_device_extensions.data();
        create_info.enabledLayerCount = 0;
        create_info.ppEnabledLayerNames = nullptr;
        create_info.pEnabledFeatures = nullptr;
 
        std::cout << "vk: creating logical device\n";
        if (vkCreateDevice(physical_device, &create_info, nullptr, &device) != VK_SUCCESS) {
            std::cout << "vk: logical device creation failed\n";
            device = VK_NULL_HANDLE;
            return;
        }
 
        std::cout << "vk: loading device-level function pointers via volk\n";
        volkLoadDevice(device);
        if (vkQueueSubmit2 == nullptr || vkCmdBeginRendering == nullptr || vkCmdEndRendering == nullptr || vkCmdPipelineBarrier2 == nullptr) {
            std::cout << "vk: required dynamic rendering/synchronization function pointers are unavailable\n";
            vkDestroyDevice(device, nullptr);
            device = VK_NULL_HANDLE;
            return;
        }
        std::cout << "vk: retrieving graphics and present queues\n";
        vkGetDeviceQueue(device, graphics_queue_family, 0, &graphics_queue);
        vkGetDeviceQueue(device, present_queue_family, 0, &present_queue);
        std::cout << "mxvk: createLogicalDevice complete\n";
    }

createShaderModule()

VkShaderModule mxvk::VK_Window::createShaderModule ( VkDevice device, const std::vector< char > & spv_bytes )

staticprotectedinherited

Create a shader module from SPIR-V bytecode.

Parameters

device	Logical Vulkan device used to create the module.
spv_bytes	SPIR-V bytecode payload.

Returns

Created shader module handle.

Exceptions

mxvk::Exception

when inputs are invalid or module creation fails.

Definition at line 145 of file mxvk.cpp.

                                                                                                  {
        return mxvk::create_shader_module(device, spv_bytes);
    }

createSprite() [1/3]

VK_Sprite * mxvk::VK_Window::createSprite ( const std::string & pngPath, const std::string & vertexShaderPath = "", const std::string & fragmentShaderPath = "" )

inherited

Create a sprite from a PNG file and register it with this window.

Parameters

pngPath	Path to the PNG file.
vertexShaderPath	Optional custom vertex shader SPIR-V path.
fragmentShaderPath	Optional custom fragment shader SPIR-V path.

Returns

Non-owning pointer to the created sprite.

Definition at line 3477 of file mxvk.cpp.

                                                                                                                                       {
        if (device == VK_NULL_HANDLE) {
            throw mxvk::Exception("Cannot create sprite before Vulkan device initialization");
        }
        if (swapchain == VK_NULL_HANDLE || command_pool == VK_NULL_HANDLE) {
            createDevice();
        }
        if (swapchain == VK_NULL_HANDLE || command_pool == VK_NULL_HANDLE) {
            throw mxvk::Exception("Cannot create sprite before swapchain and command resources are available");
        }
 
        if (sprite_descriptor_set_layout == VK_NULL_HANDLE) {
            createSpriteDescriptorSetLayout();
        }
 
        auto sprite = std::make_unique<VK_Sprite>(device, physical_device, graphics_queue, command_pool);
        sprite->setPipelineCache(pipeline_cache);
        sprite->setDescriptorSetLayout(sprite_descriptor_set_layout);
        sprite->setColorAttachmentFormat(swapchain_format);
        sprite->setDepthAttachmentFormat(depth_format);
 
        if (!vertexShaderPath.empty()) {
            sprite->setVertexShaderPath(vertexShaderPath);
        }
 
        sprite->loadSprite(pngPath, fragmentShaderPath);
 
        VK_Sprite *const sprite_ptr = sprite.get();
        sprites.push_back(std::move(sprite));
        sprite_state_dirty = true;
        return sprite_ptr;
    }

createSprite() [2/3]

VK_Sprite * mxvk::VK_Window::createSprite ( int width, int height, const std::string & vertexShaderPath = "", const std::string & fragmentShaderPath = "" )

inherited

Create a blank sprite texture and register it with this window.

Parameters

width	Texture width in pixels.
height	Texture height in pixels.
vertexShaderPath	Optional custom vertex shader SPIR-V path.
fragmentShaderPath	Optional custom fragment shader SPIR-V path.

Returns

Non-owning pointer to the created sprite.

Definition at line 3546 of file mxvk.cpp.

                                                                                                                                    {
        if (width <= 0 || height <= 0) {
            throw mxvk::Exception("Sprite dimensions must be positive");
        }
        if (device == VK_NULL_HANDLE) {
            throw mxvk::Exception("Cannot create sprite before Vulkan device initialization");
        }
        if (swapchain == VK_NULL_HANDLE || command_pool == VK_NULL_HANDLE) {
            createDevice();
        }
        if (swapchain == VK_NULL_HANDLE || command_pool == VK_NULL_HANDLE) {
            throw mxvk::Exception("Cannot create sprite before swapchain and command resources are available");
        }
 
        if (sprite_descriptor_set_layout == VK_NULL_HANDLE) {
            createSpriteDescriptorSetLayout();
        }
 
        auto sprite = std::make_unique<VK_Sprite>(device, physical_device, graphics_queue, command_pool);
        sprite->setPipelineCache(pipeline_cache);
        sprite->setDescriptorSetLayout(sprite_descriptor_set_layout);
        sprite->setColorAttachmentFormat(swapchain_format);
        sprite->setDepthAttachmentFormat(depth_format);
 
        sprite->createEmptySprite(width, height, vertexShaderPath, fragmentShaderPath);
 
        VK_Sprite *const sprite_ptr = sprite.get();
        sprites.push_back(std::move(sprite));
        sprite_state_dirty = true;
        return sprite_ptr;
    }

createSprite() [3/3]

VK_Sprite * mxvk::VK_Window::createSprite ( SDL_Surface * surface, const std::string & vertexShaderPath = "", const std::string & fragmentShaderPath = "" )

inherited

Create a sprite from an SDL surface and register it with this window.

Parameters

surface	Source surface pointer.
vertexShaderPath	Optional custom vertex shader SPIR-V path.
fragmentShaderPath	Optional custom fragment shader SPIR-V path.

Returns

Non-owning pointer to the created sprite.

Definition at line 3510 of file mxvk.cpp.

                                                                                                                                   {
        if (surface == nullptr) {
            throw mxvk::Exception("Cannot create sprite from a null SDL surface");
        }
        if (device == VK_NULL_HANDLE) {
            throw mxvk::Exception("Cannot create sprite before Vulkan device initialization");
        }
        if (swapchain == VK_NULL_HANDLE || command_pool == VK_NULL_HANDLE) {
            createDevice();
        }
        if (swapchain == VK_NULL_HANDLE || command_pool == VK_NULL_HANDLE) {
            throw mxvk::Exception("Cannot create sprite before swapchain and command resources are available");
        }
 
        if (sprite_descriptor_set_layout == VK_NULL_HANDLE) {
            createSpriteDescriptorSetLayout();
        }
 
        auto sprite = std::make_unique<VK_Sprite>(device, physical_device, graphics_queue, command_pool);
        sprite->setPipelineCache(pipeline_cache);
        sprite->setDescriptorSetLayout(sprite_descriptor_set_layout);
        sprite->setColorAttachmentFormat(swapchain_format);
        sprite->setDepthAttachmentFormat(depth_format);
 
        if (!vertexShaderPath.empty()) {
            sprite->setVertexShaderPath(vertexShaderPath);
        }
 
        sprite->loadSprite(surface, fragmentShaderPath);
 
        VK_Sprite *const sprite_ptr = sprite.get();
        sprites.push_back(std::move(sprite));
        sprite_state_dirty = true;
        return sprite_ptr;
    }

createSprite3D() [1/2]

VK_Sprite3D * mxvk::VK_Window::createSprite3D ( const std::string & pngPath, const std::string & vertexShaderPath = "", const std::string & fragmentShaderPath = "" )

inherited

Create a world-space billboard sprite from a PNG file.

Parameters

pngPath	Path to the PNG file.
vertexShaderPath	Optional custom vertex shader SPIR-V path.
fragmentShaderPath	Optional custom fragment shader SPIR-V path.

Returns

Non-owning pointer to the created 3D sprite batch.

Definition at line 3578 of file mxvk.cpp.

                                                                                                                                           {
        if (device == VK_NULL_HANDLE) {
            throw mxvk::Exception("Cannot create 3D sprite before Vulkan device initialization");
        }
        if (swapchain == VK_NULL_HANDLE || command_pool == VK_NULL_HANDLE) {
            createDevice();
        }
        if (swapchain == VK_NULL_HANDLE || command_pool == VK_NULL_HANDLE) {
            throw mxvk::Exception("Cannot create 3D sprite before swapchain and command resources are available");
        }
 
        const std::string vertPath = vertexShaderPath.empty()
                                         ? resolveRuntimeShaderPath("sprite3d.vert.spv", MXVK_SPRITE3D_SHADER_DIR)
                                         : vertexShaderPath;
        const std::string fragPath = fragmentShaderPath.empty()
                                         ? resolveRuntimeShaderPath("sprite3d.frag.spv", MXVK_SPRITE3D_SHADER_DIR)
                                         : fragmentShaderPath;
 
        auto sprite = std::make_unique<VK_Sprite3D>();
        sprite->load(this, pngPath, vertPath, fragPath);
 
        VK_Sprite3D *const sprite_ptr = sprite.get();
        sprites3d.push_back(std::move(sprite));
        return sprite_ptr;
    }

createSprite3D() [2/2]

VK_Sprite3D * mxvk::VK_Window::createSprite3D ( SDL_Surface * surface, const std::string & vertexShaderPath = "", const std::string & fragmentShaderPath = "" )

inherited

Create a world-space billboard sprite from an SDL surface.

Parameters

surface	Source surface pointer.
vertexShaderPath	Optional custom vertex shader SPIR-V path.
fragmentShaderPath	Optional custom fragment shader SPIR-V path.

Returns

Non-owning pointer to the created 3D sprite batch.

Definition at line 3604 of file mxvk.cpp.

                                                                                                                                       {
        if (surface == nullptr) {
            throw mxvk::Exception("Cannot create 3D sprite from a null SDL surface");
        }
        if (device == VK_NULL_HANDLE) {
            throw mxvk::Exception("Cannot create 3D sprite before Vulkan device initialization");
        }
        if (swapchain == VK_NULL_HANDLE || command_pool == VK_NULL_HANDLE) {
            createDevice();
        }
        if (swapchain == VK_NULL_HANDLE || command_pool == VK_NULL_HANDLE) {
            throw mxvk::Exception("Cannot create 3D sprite before swapchain and command resources are available");
        }
 
        const std::string vertPath = vertexShaderPath.empty()
                                         ? resolveRuntimeShaderPath("sprite3d.vert.spv", MXVK_SPRITE3D_SHADER_DIR)
                                         : vertexShaderPath;
        const std::string fragPath = fragmentShaderPath.empty()
                                         ? resolveRuntimeShaderPath("sprite3d.frag.spv", MXVK_SPRITE3D_SHADER_DIR)
                                         : fragmentShaderPath;
 
        auto sprite = std::make_unique<VK_Sprite3D>();
        sprite->load(this, surface, vertPath, fragPath);
 
        VK_Sprite3D *const sprite_ptr = sprite.get();
        sprites3d.push_back(std::move(sprite));
        return sprite_ptr;
    }

debugCallback()

VkBool32 mxvk::VK_Window::debugCallback ( VkDebugUtilsMessageSeverityFlagBitsEXT severity, VkDebugUtilsMessageTypeFlagsEXT type, const VkDebugUtilsMessengerCallbackDataEXT * callback_data, void * user_data )

staticinherited

Definition at line 44 of file mxvk.cpp.

                                                                                                                                                                                                                                                               {
        const char *message = (callback_data != nullptr && callback_data->pMessage != nullptr)
                                  ? callback_data->pMessage
                                  : "Unknown Vulkan validation message";
 
        if ((severity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT) != 0U) {
            std::cerr << std::format("vk validation error: {}\n", message);
        } else if ((severity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT) != 0U) {
            std::cerr << std::format("vk validation warning: {}\n", message);
        } else {
            std::cout << std::format("vk validation: {}\n", message);
        }
        return VK_FALSE;
    }

detachPostProcessingShader()

void mxvk::VK_Window::detachPostProcessingShader ( )

inherited

Detach the current post-processing shader and return to direct swapchain rendering.

Definition at line 1198 of file mxvk.cpp.

                                               {
        if (device != VK_NULL_HANDLE && !post_process_sprites.empty()) {
            vkDeviceWaitIdle(device);
        }
 
        post_process_sprite = nullptr;
        destroyPostProcessTargets();
        post_process_time_enabled = false;
 
        if (!owned_post_process_sprites.empty()) {
            const std::vector<VK_Sprite *> sprites_to_remove = owned_post_process_sprites;
            sprites.erase(
                std::remove_if(
                    sprites.begin(),
                    sprites.end(),
                    [&sprites_to_remove](const std::unique_ptr<VK_Sprite> &sprite) {
                        return std::ranges::find(sprites_to_remove, sprite.get()) != sprites_to_remove.end();
                    }),
                sprites.end());
            sprite_state_dirty = true;
        }
        owned_post_process_sprite = nullptr;
        owned_post_process_sprites.clear();
        post_process_sprites.clear();
        post_process_effect_params.clear();
        post_process_effect_time_enabled.clear();
        post_process_effect_start_times.clear();
    }

drawblock()

void MasterPieceWindow::drawblock ( float scaleX, float scaleY )

inline

Definition at line 671 of file acid.drop.cpp.

                                               {
        int c1 = matrix.block.color.c1;
        int c2 = matrix.block.color.c2;
        int c3 = matrix.block.color.c3;
 
        if (matrix.block.horizontal) {
 
            int screenY = STARTY + matrix.block.y * (BLOCK_HEIGHT + BLOCK_SPACING) + 10;
            for (int i = 0; i < 3; i++) {
                int color = (i == 0) ? c1 : (i == 1) ? c2
                                                     : c3;
                int bx = STARTX + (matrix.block.x + i) * (BLOCK_SIZE + BLOCK_SPACING);
                if (matrix.block.x + i >= 0 && matrix.block.x + i < GRID_WIDTH &&
                    color > 0 && color < BLOCK_COUNT && grid_blocks[color]) {
                    grid_blocks[color]->drawSpriteRect(
                        (int)(bx * scaleX), (int)(screenY * scaleY),
                        (int)(BLOCK_SIZE * scaleX), (int)(BLOCK_HEIGHT * scaleY));
                }
            }
        } else {
 
            int bx = STARTX + matrix.block.x * (BLOCK_SIZE + BLOCK_SPACING);
            int y0 = matrix.block.y;
            int y1 = matrix.block.y + 1;
            int y2 = matrix.block.y + 2;
 
            if (y0 >= 0 && c1 > 0 && c1 < BLOCK_COUNT && grid_blocks[c1]) {
                int screenY = STARTY + y0 * (BLOCK_HEIGHT + BLOCK_SPACING) + 10;
                grid_blocks[c1]->drawSpriteRect(
                    (int)(bx * scaleX), (int)(screenY * scaleY),
                    (int)(BLOCK_SIZE * scaleX), (int)(BLOCK_HEIGHT * scaleY));
            }
            if (y1 >= 0 && c2 > 0 && c2 < BLOCK_COUNT && grid_blocks[c2]) {
                int screenY = STARTY + y1 * (BLOCK_HEIGHT + BLOCK_SPACING) + 10;
                grid_blocks[c2]->drawSpriteRect(
                    (int)(bx * scaleX), (int)(screenY * scaleY),
                    (int)(BLOCK_SIZE * scaleX), (int)(BLOCK_HEIGHT * scaleY));
            }
            if (y2 >= 0 && c3 > 0 && c3 < BLOCK_COUNT && grid_blocks[c3]) {
                int screenY = STARTY + y2 * (BLOCK_HEIGHT + BLOCK_SPACING) + 10;
                grid_blocks[c3]->drawSpriteRect(
                    (int)(bx * scaleX), (int)(screenY * scaleY),
                    (int)(BLOCK_SIZE * scaleX), (int)(BLOCK_HEIGHT * scaleY));
            }
        }
    }

drawGame()

void MasterPieceWindow::drawGame ( )

inline

Definition at line 616 of file acid.drop.cpp.

                    {
        float scaleX = (float)w / 640.0f;
        float scaleY = (float)h / 480.0f;
        if (gamebg[shaderLevel]) {
            float time_f = static_cast<float>(SDL_GetTicks()) / 1000.0f;
            gamebg[shaderLevel]->setShaderParams(time_f, 0.0f, 0.0f, 0.0f);
            gamebg[shaderLevel]->drawSpriteRect(0, 0, w, h);
        }
        drawmatrix(scaleX, scaleY);
        drawblock(scaleX, scaleY);
        drawnext(scaleX, scaleY);
        std::ostringstream stream;
        stream << "Score:" << matrix.Game.score;
        printText(stream.str().c_str(), (int)(200 * scaleX), (int)(80 * scaleY) - (lastFontSize + (lastFontSize / 4)), {255, 255, 255, 255});
 
        stream.str("");
        stream << "Tabs:" << matrix.Game.lines;
        printText(stream.str().c_str(), (int)(310 * scaleX), (int)(80 * scaleY) - (lastFontSize + (lastFontSize / 4)), {255, 255, 255, 255});
 
        if (paused) {
            const char *pausedText = "PAUSED - Press P to Continue";
            int pausedWidth, pausedHeight;
            if (!getTextDimensions(pausedText, pausedWidth, pausedHeight)) {
                pausedWidth = static_cast<int>(std::strlen(pausedText)) * getCharWidth();
            }
            printText(pausedText, w / 2 - pausedWidth / 2, h / 2, {255, 255, 0, 255});
        }
    }

drawmatrix()

void MasterPieceWindow::drawmatrix ( float scaleX, float scaleY )

inline

Definition at line 645 of file acid.drop.cpp.

                                                {
        Uint32 now = SDL_GetTicks();
        bool showFlash = flashActive && ((now - flashStartTime) / 50 % 2 == 0);
 
        for (int i = 0; i < GRID_WIDTH; i++) {
            for (int j = 0; j < GRID_HEIGHT; j++) {
                int blockType = matrix.grid[i][j];
                if (blockType > 0 && blockType < BLOCK_COUNT &&
                    static_cast<size_t>(blockType) < grid_blocks.size()) {
                    int x = STARTX + i * (BLOCK_SIZE + BLOCK_SPACING);
                    int y = STARTY + j * (BLOCK_HEIGHT + BLOCK_SPACING) + 10;
 
                    if (flashActive && flashGrid[i][j] && !showFlash) {
                        continue;
                    }
 
                    if (grid_blocks[blockType]) {
                        grid_blocks[blockType]->drawSpriteRect(
                            (int)(x * scaleX), (int)(y * scaleY) + 10,
                            (int)(BLOCK_SIZE * scaleX), (int)(BLOCK_HEIGHT * scaleY));
                    }
                }
            }
        }
    }

drawnext()

void MasterPieceWindow::drawnext ( float scaleX, float scaleY )

inline

Definition at line 718 of file acid.drop.cpp.

                                              {
 
        int bx = NEXT_PANEL_X + 70;
        int by = NEXT_PANEL_Y + 15;
 
        int c1 = matrix.nextblock.color.c1;
        int c2 = matrix.nextblock.color.c2;
        int c3 = matrix.nextblock.color.c3;
 
        if (c1 > 0 && c1 < BLOCK_COUNT && grid_blocks[c1]) {
            grid_blocks[c1]->drawSpriteRect(
                (int)(bx * scaleX), (int)(by * scaleY),
                (int)(BLOCK_SIZE * scaleX), (int)(BLOCK_HEIGHT * scaleY));
        }
        if (c2 > 0 && c2 < BLOCK_COUNT && grid_blocks[c2]) {
            grid_blocks[c2]->drawSpriteRect(
                (int)(bx * scaleX), (int)((by + BLOCK_HEIGHT + BLOCK_SPACING) * scaleY),
                (int)(BLOCK_SIZE * scaleX), (int)(BLOCK_HEIGHT * scaleY));
        }
        if (c3 > 0 && c3 < BLOCK_COUNT && grid_blocks[c3]) {
            grid_blocks[c3]->drawSpriteRect(
                (int)(bx * scaleX), (int)((by + (BLOCK_HEIGHT + BLOCK_SPACING) * 2) * scaleY),
                (int)(BLOCK_SIZE * scaleX), (int)(BLOCK_HEIGHT * scaleY));
        }
    }

dropBlock()

void MasterPieceWindow::dropBlock ( )

inline

Definition at line 1086 of file acid.drop.cpp.

                     {
        while (canMoveDown()) {
            matrix.block.y++;
        }
    }

enablePostProcessing()

void mxvk::VK_Window::enablePostProcessing ( VK_Sprite * sprite )

inherited

Definition at line 1271 of file mxvk.cpp.

                                                          {
        if (owned_post_process_sprite != nullptr && sprite != owned_post_process_sprite) {
            std::vector<VK_Sprite *> sprites_to_remove = owned_post_process_sprites;
            if (sprites_to_remove.empty()) {
                sprites_to_remove.push_back(owned_post_process_sprite);
            }
            sprites.erase(
                std::remove_if(
                    sprites.begin(),
                    sprites.end(),
                    [&sprites_to_remove](const std::unique_ptr<VK_Sprite> &existing_sprite) {
                        return std::ranges::find(sprites_to_remove, existing_sprite.get()) != sprites_to_remove.end();
                    }),
                sprites.end());
            owned_post_process_sprite = nullptr;
            owned_post_process_sprites.clear();
            sprite_state_dirty = true;
        }
        post_process_sprite = sprite;
        post_process_sprites = sprite == nullptr ? std::vector<VK_Sprite *>{} : std::vector<VK_Sprite *>{sprite};
        post_process_effect_params.assign(post_process_sprites.size(), post_process_params);
        post_process_effect_time_enabled.assign(post_process_sprites.size(), post_process_time_enabled);
        post_process_effect_start_times.assign(post_process_sprites.size(), post_process_start_time);
        if (device != VK_NULL_HANDLE && !swapchain_images.empty()) {
            createPostProcessTargets();
        }
    }

ensureRenderResources()

bool mxvk::VK_Window::ensureRenderResources ( )

inherited

Ensure deferred render resources are initialized.

Returns

true when swapchain, command pool, and sync objects are ready.

Definition at line 1406 of file mxvk.cpp.

                                          {
        const auto sync_ready = [this]() {
            return std::ranges::all_of(image_available.begin(), image_available.end(), [](VkSemaphore semaphore) { return semaphore != VK_NULL_HANDLE; }) &&
                   render_finished.size() == swapchain_images.size() &&
                   std::ranges::all_of(render_finished.begin(), render_finished.end(), [](VkSemaphore semaphore) { return semaphore != VK_NULL_HANDLE; }) &&
                   std::ranges::all_of(in_flight_fences.begin(), in_flight_fences.end(), [](VkFence fence) { return fence != VK_NULL_HANDLE; });
        };
 
        if (device == VK_NULL_HANDLE) {
            return false;
        }
 
        if (swapchain == VK_NULL_HANDLE || command_pool == VK_NULL_HANDLE || command_buffers.empty() || !sync_ready() ||
            image_fences.size() != swapchain_images.size()) {
            createDevice();
        }
 
        return (swapchain != VK_NULL_HANDLE && command_pool != VK_NULL_HANDLE && !command_buffers.empty() && sync_ready() &&
                image_fences.size() == swapchain_images.size());
    }

event()

void MasterPieceWindow::event ( SDL_Event & e )

inlineoverridevirtual

Handle one SDL event.

Parameters

e	SDL event to process.

Reimplemented from mxvk::VK_Window.

Definition at line 1124 of file acid.drop.cpp.

                                      {
        if (e.type == SDL_EVENT_QUIT || (currentScreen == SCREEN_START && e.type == SDL_EVENT_KEY_DOWN && e.key.key == SDLK_ESCAPE)) {
            exit();
            return;
        }
 
        if (e.type == SDL_EVENT_KEY_DOWN) {
            gameKeypress(e.key.key);
        } else if (e.type == SDL_EVENT_TEXT_INPUT) {
            handleTextInput(e.text.text);
        }
 
        if (e.type == SDL_EVENT_GAMEPAD_ADDED) {
            openGamepad(e.gdevice.which);
        } else if (e.type == SDL_EVENT_GAMEPAD_REMOVED) {
            if (gamepad != nullptr && e.gdevice.which == gamepadId) {
                SDL_CloseGamepad(gamepad);
                gamepad = nullptr;
                gamepadId = 0;
            }
        } else if (e.type == SDL_EVENT_GAMEPAD_BUTTON_DOWN) {
            handleControllerButton(e.gbutton.button);
        }
    }

exit()

void mxvk::VK_Window::exit ( )

protectedinherited

Request loop termination.

Definition at line 1126 of file mxvk.cpp.

                         {
        active = false;
    }

findMatches()

bool MasterPieceWindow::findMatches ( )

inline

Definition at line 883 of file acid.drop.cpp.

                       {
 
        memset(flashGrid, false, sizeof(flashGrid));
        bool foundMatch = false;
        matchBonus = 0;
 
        for (int j = 0; j < GRID_HEIGHT; j++) {
            for (int i = 0; i < GRID_WIDTH; i++) {
                if (matrix.grid[i][j] > 0) {
                    int color = matrix.grid[i][j];
                    int count = 1;
 
                    while (i + count < GRID_WIDTH && matrix.grid[i + count][j] == color) {
                        count++;
                    }
                    if (count >= 3) {
                        for (int k = 0; k < count; k++) {
                            flashGrid[i + k][j] = true;
                        }
                        foundMatch = true;
 
                        if (count == 4)
                            matchBonus += 25;
                        else if (count >= 5)
                            matchBonus += 50;
                    }
                }
            }
        }
 
        for (int i = 0; i < GRID_WIDTH; i++) {
            for (int j = 0; j < GRID_HEIGHT; j++) {
                if (matrix.grid[i][j] > 0) {
                    int color = matrix.grid[i][j];
                    int count = 1;
 
                    while (j + count < GRID_HEIGHT && matrix.grid[i][j + count] == color) {
                        count++;
                    }
                    if (count >= 3) {
                        for (int k = 0; k < count; k++) {
                            flashGrid[i][j + k] = true;
                        }
                        foundMatch = true;
 
                        if (count == 4)
                            matchBonus += 25;
                        else if (count >= 5)
                            matchBonus += 50;
                    }
                }
            }
        }
 
        for (int i = 0; i < GRID_WIDTH; i++) {
            for (int j = 0; j < GRID_HEIGHT; j++) {
                if (matrix.grid[i][j] > 0) {
                    int color = matrix.grid[i][j];
                    int count = 1;
                    while (i + count < GRID_WIDTH && j + count < GRID_HEIGHT &&
                           matrix.grid[i + count][j + count] == color) {
                        count++;
                    }
                    if (count >= 3) {
                        for (int k = 0; k < count; k++) {
                            flashGrid[i + k][j + k] = true;
                        }
                        foundMatch = true;
 
                        if (count == 4)
                            matchBonus += 35;
                        else if (count >= 5)
                            matchBonus += 75;
                    }
                }
            }
        }
 
        for (int i = 0; i < GRID_WIDTH; i++) {
            for (int j = 0; j < GRID_HEIGHT; j++) {
                if (matrix.grid[i][j] > 0) {
                    int color = matrix.grid[i][j];
                    int count = 1;
                    while (i - count >= 0 && j + count < GRID_HEIGHT &&
                           matrix.grid[i - count][j + count] == color) {
                        count++;
                    }
                    if (count >= 3) {
                        for (int k = 0; k < count; k++) {
                            flashGrid[i - k][j + k] = true;
                        }
                        foundMatch = true;
 
                        if (count == 4)
                            matchBonus += 35;
                        else if (count >= 5)
                            matchBonus += 75;
                    }
                }
            }
        }
 
        return foundMatch;
    }

gameKeypress()

void MasterPieceWindow::gameKeypress ( SDL_Keycode key )

inline

Definition at line 1301 of file acid.drop.cpp.

                                       {
        switch (currentScreen) {
        case SCREEN_INTRO:
            if (key == SDLK_RETURN) {
                currentScreen = SCREEN_START;
            }
            break;
        case SCREEN_START:
            if (key == SDLK_UP) {
                cursorPos = (cursorPos - 1 + 5) % 5;
            } else if (key == SDLK_DOWN) {
                cursorPos = (cursorPos + 1) % 5;
            } else if (key == SDLK_RETURN) {
                if (cursorPos == 0) {
                    matrix.init_matrix();
                    shaderLevel = 0;
                    applyDifficulty();
                    matrix.block.x = GRID_WIDTH / 2;
                    matrix.block.y = 1;
                    matrix.block.horizontal = false;
                    currentScreen = SCREEN_GAME;
                } else if (cursorPos == 1) {
                    finalScore = 0;
                    enteringName = false;
                    currentScreen = SCREEN_SCORES;
                } else if (cursorPos == 2) {
                    currentScreen = SCREEN_OPTIONS;
                } else if (cursorPos == 3) {
                    currentScreen = SCREEN_CREDITS;
                } else if (cursorPos == 4) {
                    exit();
                }
            }
            break;
        case SCREEN_GAME:
            if (key == SDLK_LEFT) {
                moveBlockLeft();
            } else if (key == SDLK_RIGHT) {
                moveBlockRight();
            } else if (key == SDLK_DOWN) {
                moveBlockDown();
            } else if (key == SDLK_UP) {
                matrix.block.color.shiftcolor(true);
            } else if (key == SDLK_SPACE) {
                rotateBlock();
            } else if (key == SDLK_Z) {
                matrix.block.color.shiftcolor(false);
            } else if (key == SDLK_P) {
                paused = !paused;
            } else if (key == SDLK_L) {
                /*if (shaderLevel < SHADER_LEVEL_COUNT - 1) {
                    shaderLevel++;
                    std::cout << "level increased to: " << shaderLevel << std::endl;
                }*/
            } else if (key == SDLK_ESCAPE) {
                currentScreen = SCREEN_START;
            }
            break;
        case SCREEN_GAMEOVER:
            if (key == SDLK_RETURN) {
                goToScoresScreen();
            } else if (key == SDLK_ESCAPE) {
                currentScreen = SCREEN_START;
            }
            break;
        case SCREEN_OPTIONS:
            if (key == SDLK_UP) {
                optionsCursor = (optionsCursor - 1 + 3) % 3;
            } else if (key == SDLK_DOWN) {
                optionsCursor = (optionsCursor + 1) % 3;
            } else if (key == SDLK_LEFT) {
                if (optionsCursor == 0) {
                    difficultySetting = (difficultySetting - 1 + 3) % 3;
                } else if (optionsCursor == 1) {
                    shaderEffectsEnabled = !shaderEffectsEnabled;
                    applyShaderEffectsToggle();
                }
            } else if (key == SDLK_RIGHT) {
                if (optionsCursor == 0) {
                    difficultySetting = (difficultySetting + 1) % 3;
                } else if (optionsCursor == 1) {
                    shaderEffectsEnabled = !shaderEffectsEnabled;
                    applyShaderEffectsToggle();
                }
            } else if (key == SDLK_RETURN) {
                if (optionsCursor == 2) {
                    currentScreen = SCREEN_START;
                }
            }
            break;
        case SCREEN_CREDITS:
            if (key == SDLK_RETURN) {
                currentScreen = SCREEN_START;
            }
            break;
        case SCREEN_SCORES:
            if (enteringName) {
                if (key == SDLK_RETURN && !playerName.empty()) {
 
                    scores.addScore(playerName, finalScore);
                    enteringName = false;
                } else if (key == SDLK_BACKSPACE && !playerName.empty()) {
                    playerName.pop_back();
                } else if (key == SDLK_ESCAPE) {
                    enteringName = false;
                }
            } else {
                if (key == SDLK_RETURN || key == SDLK_ESCAPE) {
                    currentScreen = SCREEN_START;
                }
            }
            break;
        }
    }

getCharWidth()

int MasterPieceWindow::getCharWidth ( )

inline

Definition at line 367 of file acid.drop.cpp.

                       {
        return (int)(lastFontSize * 0.5f);
    }

getCommandPool()

VkCommandPool mxvk::VK_Window::getCommandPool ( ) const

inlinenodiscardnoexceptinherited

Get the command pool used for graphics/upload work.

Definition at line 177 of file mxvk.hpp.

{ return command_pool; }

getDepthFormat()

VkFormat mxvk::VK_Window::getDepthFormat ( ) const

inlinenodiscardnoexceptinherited

Get the depth format used for dynamic rendering attachments.

Definition at line 189 of file mxvk.hpp.

{ return depth_format; }

getDevice()

VkDevice mxvk::VK_Window::getDevice ( ) const

inlinenodiscardnoexceptinherited

Get the Vulkan logical device handle.

Definition at line 168 of file mxvk.hpp.

{ return device; }

getGraphicsQueue()

VkQueue mxvk::VK_Window::getGraphicsQueue ( ) const

inlinenodiscardnoexceptinherited

Get the graphics queue handle.

Definition at line 174 of file mxvk.hpp.

{ return graphics_queue; }

getMenuSpacing()

int MasterPieceWindow::getMenuSpacing ( )

inline

Definition at line 371 of file acid.drop.cpp.

                         {
        return (int)(40.0f * ((float)h / 480.0f));
    }

getPhysicalDevice()

VkPhysicalDevice mxvk::VK_Window::getPhysicalDevice ( ) const

inlinenodiscardnoexceptinherited

Get the Vulkan physical device handle.

Definition at line 171 of file mxvk.hpp.

{ return physical_device; }

getPipelineCache()

VkPipelineCache mxvk::VK_Window::getPipelineCache ( ) const

inlinenodiscardnoexceptinherited

Get the persistent Vulkan pipeline cache used by framework pipelines.

Definition at line 180 of file mxvk.hpp.

{ return pipeline_cache; }

getSDLWindow()

SDL_Window * mxvk::VK_Window::getSDLWindow ( ) const

inlinenodiscardnoexceptinherited

Get the underlying SDL window handle.

Definition at line 165 of file mxvk.hpp.

{ return window.get(); }

getSwapchainExtent()

VkExtent2D mxvk::VK_Window::getSwapchainExtent ( ) const

inlinenodiscardnoexceptinherited

Get the current swapchain extent.

Definition at line 186 of file mxvk.hpp.

{ return swapchain_extent; }

getSwapchainFormat()

VkFormat mxvk::VK_Window::getSwapchainFormat ( ) const

inlinenodiscardnoexceptinherited

Get the swapchain color format.

Definition at line 183 of file mxvk.hpp.

{ return swapchain_format; }

getSwapchainImageCount()

size_t mxvk::VK_Window::getSwapchainImageCount ( ) const

inlinenodiscardnoexceptinherited

Get the number of swapchain images currently allocated.

Definition at line 192 of file mxvk.hpp.

{ return swapchain_images.size(); }

getTextDimensions() [1/3]

bool mxvk::VK_Window::getTextDimensions ( const std::string & text, int & width, int & height )

nodiscardinherited

Measure text dimensions in pixels.

Parameters

text	Text string to measure.
width	Output width in pixels.
height	Output height in pixels.

Returns

true when measurement succeeded.

Definition at line 3069 of file mxvk.cpp.

                                                                                    {
        if (!font_configured) {
            throw mxvk::Exception("getTextDimensions requires setFont() to be called first");
        }
 
        if (!text_renderer) {
            ensureTextRenderer();
        }
        if (!text_renderer) {
            width = 0;
            height = 0;
            return false;
        }
        return text_renderer->getTextDimensions(text, width, height);
    }

getTextDimensions() [2/3]

bool mxvk::VK_Window::getTextDimensions ( const std::string & text, int & width, int & height, const Font & font )

nodiscardinherited

Definition at line 3101 of file mxvk.cpp.

                                                                                                      {
        if (!font) {
            width = 0;
            height = 0;
            return false;
        }
 
        ensureTextRenderer(font.path(), font.size());
        if (!text_renderer) {
            width = 0;
            height = 0;
            return false;
        }
        return text_renderer->getTextDimensions(text, width, height, font);
    }

getTextDimensions() [3/3]

bool mxvk::VK_Window::getTextDimensions ( const std::string & text, int & width, int & height, TTF_Font * font )

nodiscardinherited

Definition at line 3085 of file mxvk.cpp.

                                                                                                    {
        if (font == nullptr) {
            width = 0;
            height = 0;
            return false;
        }
 
        ensureTextRenderer(resolveDefaultFontPath(), font_size);
        if (!text_renderer) {
            width = 0;
            height = 0;
            return false;
        }
        return text_renderer->getTextDimensions(text, width, height, font);
    }

goToScoresScreen()

void MasterPieceWindow::goToScoresScreen ( )

inline

Definition at line 483 of file acid.drop.cpp.

                            {
        finalScore = matrix.Game.score;
        playerName = "";
        enteringName = scores.qualifiesForHighScore(finalScore);
        currentScreen = SCREEN_SCORES;
    }

handleControllerButton()

void MasterPieceWindow::handleControllerButton ( Uint8 button )

inline

Definition at line 1149 of file acid.drop.cpp.

                                              {
        switch (currentScreen) {
        case SCREEN_INTRO:
            if (button == SDL_GAMEPAD_BUTTON_SOUTH || button == SDL_GAMEPAD_BUTTON_START) {
                currentScreen = SCREEN_START;
            }
            break;
        case SCREEN_START:
            if (button == SDL_GAMEPAD_BUTTON_DPAD_UP) {
                cursorPos = (cursorPos - 1 + 5) % 5;
            } else if (button == SDL_GAMEPAD_BUTTON_DPAD_DOWN) {
                cursorPos = (cursorPos + 1) % 5;
            } else if (button == SDL_GAMEPAD_BUTTON_SOUTH || button == SDL_GAMEPAD_BUTTON_START) {
                if (cursorPos == 0) {
                    matrix.init_matrix();
                    shaderLevel = 0;
                    applyDifficulty();
                    matrix.block.x = GRID_WIDTH / 2;
                    matrix.block.y = 1;
                    matrix.block.horizontal = false;
                    currentScreen = SCREEN_GAME;
                } else if (cursorPos == 1) {
                    finalScore = 0;
                    enteringName = false;
                    currentScreen = SCREEN_SCORES;
                } else if (cursorPos == 2) {
                    currentScreen = SCREEN_OPTIONS;
                } else if (cursorPos == 3) {
                    currentScreen = SCREEN_CREDITS;
                } else if (cursorPos == 4) {
                    exit();
                }
            } else if (button == SDL_GAMEPAD_BUTTON_EAST) {
                exit();
            }
            break;
        case SCREEN_GAME:
            if (button == SDL_GAMEPAD_BUTTON_DPAD_LEFT) {
                moveBlockLeft();
            } else if (button == SDL_GAMEPAD_BUTTON_DPAD_RIGHT) {
                moveBlockRight();
            } else if (button == SDL_GAMEPAD_BUTTON_DPAD_DOWN) {
                moveBlockDown();
            } else if (button == SDL_GAMEPAD_BUTTON_DPAD_UP) {
                matrix.block.color.shiftcolor(true);
            } else if (button == SDL_GAMEPAD_BUTTON_SOUTH) {
                rotateBlock();
            } else if (button == SDL_GAMEPAD_BUTTON_EAST) {
                matrix.block.color.shiftcolor(false);
            } else if (button == SDL_GAMEPAD_BUTTON_NORTH) {
                dropBlock();
            } else if (button == SDL_GAMEPAD_BUTTON_START) {
                paused = !paused;
            } else if (button == SDL_GAMEPAD_BUTTON_BACK) {
                currentScreen = SCREEN_START;
            }
            break;
        case SCREEN_GAMEOVER:
            if (button == SDL_GAMEPAD_BUTTON_SOUTH || button == SDL_GAMEPAD_BUTTON_START) {
                goToScoresScreen();
            } else if (button == SDL_GAMEPAD_BUTTON_EAST) {
                currentScreen = SCREEN_START;
            }
            break;
        case SCREEN_OPTIONS:
            if (button == SDL_GAMEPAD_BUTTON_DPAD_UP) {
                optionsCursor = (optionsCursor - 1 + 3) % 3;
            } else if (button == SDL_GAMEPAD_BUTTON_DPAD_DOWN) {
                optionsCursor = (optionsCursor + 1) % 3;
            } else if (button == SDL_GAMEPAD_BUTTON_DPAD_LEFT) {
                if (optionsCursor == 0)
                    difficultySetting = (difficultySetting - 1 + 3) % 3;
                if (optionsCursor == 1) {
                    shaderEffectsEnabled = !shaderEffectsEnabled;
                    applyShaderEffectsToggle();
                }
            } else if (button == SDL_GAMEPAD_BUTTON_DPAD_RIGHT) {
                if (optionsCursor == 0)
                    difficultySetting = (difficultySetting + 1) % 3;
                if (optionsCursor == 1) {
                    shaderEffectsEnabled = !shaderEffectsEnabled;
                    applyShaderEffectsToggle();
                }
            } else if (button == SDL_GAMEPAD_BUTTON_SOUTH || button == SDL_GAMEPAD_BUTTON_START) {
                if (optionsCursor == 2)
                    currentScreen = SCREEN_START;
            } else if (button == SDL_GAMEPAD_BUTTON_EAST) {
                currentScreen = SCREEN_START;
            }
            break;
        case SCREEN_CREDITS:
            if (button == SDL_GAMEPAD_BUTTON_SOUTH || button == SDL_GAMEPAD_BUTTON_EAST || button == SDL_GAMEPAD_BUTTON_START) {
                currentScreen = SCREEN_START;
            }
            break;
        case SCREEN_SCORES:
            if (!enteringName) {
                if (button == SDL_GAMEPAD_BUTTON_SOUTH || button == SDL_GAMEPAD_BUTTON_EAST || button == SDL_GAMEPAD_BUTTON_START) {
                    currentScreen = SCREEN_START;
                }
            } else if (enteringName) {
                if (button == SDL_GAMEPAD_BUTTON_BACK)
                    currentScreen = SCREEN_START;
            }
            break;
        }
    }

handleTextInput()

void MasterPieceWindow::handleTextInput ( const char * text )

inline

Definition at line 1416 of file acid.drop.cpp.

                                           {
        if (currentScreen == SCREEN_SCORES && enteringName) {
 
            if (playerName.length() < 15) {
                playerName += text;
            }
        }
    }

initGfx()

void MasterPieceWindow::initGfx ( )

inline

Definition at line 279 of file acid.drop.cpp.

                   {
        std::string vertShader = current_path + "/data/sprite_vert.spv";
        std::string fragShader = current_path + "/data/sprite_kaleidoscope.spv";
        const char *fragShaders[SHADER_LEVEL_COUNT] = {
            "sprite_kaleidoscope.spv",
            "sprite_kaleidoscope2.spv",
            "sprite_kaleidoscope3.spv",
            "sprite_kaleidoscope4.spv"};
        for (int i = 0; i < SHADER_LEVEL_COUNT; i++) {
            gamebg[i] = createSprite(current_path + "/data/gamebg.png", vertShader, current_path + "/data/" + fragShaders[i]);
        }
        introScreen = createSprite(current_path + "/data/intro.png", current_path + "/data/sprite_vert.spv", current_path + "/data/sprite_bubble.spv");
        startScreen = createSprite(current_path + "/data/universe.png", current_path + "/data/sprite_vert.spv", fragShader);
        creditScreen = createSprite(current_path + "/data/logo.png", current_path + "/data/sprite_vert.spv", current_path + "/data/sprite_time.spv");
        scoresBackground = createSprite(current_path + "/data/bg.png", current_path + "/data/sprite_vert.spv", current_path + "/data/sprite_time.spv");
 
        const char *blockFiles[] = {
            "block_black.png", "block_yellow.png", "block_orange.png", "block_ltblue.png",
            "block_dblue.png", "block_purple.png", "block_pink.png", "block_gray.png",
            "block_red.png", "block_green.png", "block_clear.png"};
        for (int i = 0; i < BLOCK_COUNT; i++) {
            grid_blocks.push_back(createSprite(current_path + "/data/" + blockFiles[i], current_path + "/data/sprite_vert.spv", current_path + "/data/sprite_frag.spv"));
        }
        applyShaderEffectsToggle();
    }

initVulkan()

bool mxvk::VK_Window::initVulkan ( bool validiation )

virtualinherited

Initialize Vulkan state.

Parameters

validiation

Enables validation-related behavior when true.

Returns

true on success, false otherwise.

Definition at line 318 of file mxvk.cpp.

                                               {
        std::cout << std::format("mxvk: entering initVulkan (validation={})\n", validiation);
        validation_enabled = validiation;
 
        if (window == nullptr) {
            std::cerr << "mxvk: Cannot initialize Vulkan without an SDL window\n";
            return false;
        }
 
        if (instance != VK_NULL_HANDLE) {
            std::cout << "vk: instance already initialized; skipping initVulkan\n";
            return true;
        }
 
        std::cout << "vk: initializing volk loader\n";
        if (volkInitialize() != VK_SUCCESS) {
            std::cerr << "mxvk: Failed to initialize volk\n";
            return false;
        }
 
        unsigned int extension_count = 0;
        std::cout << "SDL3: querying Vulkan instance extensions required by SDL\n";
        const char *const *extensions = SDL_Vulkan_GetInstanceExtensions(&extension_count);
        if (extensions == nullptr || extension_count == 0U) {
            std::cerr << std::format("mxvk: Failed to get Vulkan instance extensions: {}\n", SDL_GetError());
            return false;
        }
        std::cout << std::format("vk: SDL provided {} required instance extension(s)\n", extension_count);
 
        std::vector<const char *> enabled_extensions(extensions, extensions + extension_count);
 
#if defined(MXVK_USE_MOLTENVK)
        const auto append_instance_extension_if_missing = [&enabled_extensions](const char *extension_name) {
            const bool exists = std::ranges::any_of(
                enabled_extensions,
                [extension_name](const char *existing) { return std::strcmp(existing, extension_name) == 0; });
            if (!exists) {
                enabled_extensions.push_back(extension_name);
            }
        };
        append_instance_extension_if_missing(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
        append_instance_extension_if_missing(VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME);
#endif
 
        std::vector<const char *> enabled_layers{};
        VkDebugUtilsMessengerCreateInfoEXT debug_create_info{};
        if (validation_enabled) {
            if (!hasValidationLayerSupport()) {
                if (shouldLogMissingValidationLayer()) {
                    std::cerr << std::format(
                        "mxvk: validation layer '{}' is not available; continuing without validation\n",
                        validation_layer_name);
                }
                validation_enabled = false;
            } else {
                enabled_layers.push_back(validation_layer_name);
                enabled_extensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
                const std::optional<VkDebugUtilsMessengerCreateInfoEXT> maybe_debug_create_info =
                    makeDebugMessengerCreateInfo();
                if (!maybe_debug_create_info.has_value()) {
                    std::cerr << "mxvk: failed to construct debug messenger create info\n";
                    validation_enabled = false;
                    enabled_layers.clear();
                } else {
                    debug_create_info = maybe_debug_create_info.value();
                }
            }
        }
 
        VkApplicationInfo app_info{};
        app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
        app_info.pApplicationName = "mxvk";
        app_info.applicationVersion = VK_MAKE_VERSION(0, 1, 0);
        app_info.pEngineName = "mxvk";
        app_info.engineVersion = VK_MAKE_VERSION(MXVK_VERSION_CODE_MAJOR, MXVK_VERSION_CODE_MINOR, MXVK_VERSION_CODE_PATCH);
        app_info.apiVersion = VK_API_VERSION_1_4;
 
        VkInstanceCreateInfo create_info{};
        create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
        create_info.pApplicationInfo = &app_info;
        create_info.enabledExtensionCount = extension_count;
        create_info.ppEnabledExtensionNames = enabled_extensions.data();
        create_info.enabledLayerCount = static_cast<uint32_t>(enabled_layers.size());
        create_info.ppEnabledLayerNames = enabled_layers.empty() ? nullptr : enabled_layers.data();
        create_info.pNext = validation_enabled ? &debug_create_info : nullptr;
 
        create_info.enabledExtensionCount = static_cast<uint32_t>(enabled_extensions.size());
#if defined(MXVK_USE_MOLTENVK)
        create_info.flags |= VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR;
#endif
 
        std::cout << "vk: creating Vulkan instance\n";
        if (vkCreateInstance(&create_info, nullptr, &instance) != VK_SUCCESS) {
            std::cerr << "mxvk: Failed to create Vulkan instance\n";
            instance = VK_NULL_HANDLE;
            return false;
        }
 
        std::cout << "vk: loading Vulkan instance function pointers via volk\n";
        volkLoadInstance(instance);
 
        setupDebugMessenger();
 
        uint32_t instanceVersion = 0;
        if (vkEnumerateInstanceVersion != nullptr) {
            vkEnumerateInstanceVersion(&instanceVersion);
        }
        std::cout << "vk: Vulkan instance version: "
                  << VK_VERSION_MAJOR(instanceVersion) << "."
                  << VK_VERSION_MINOR(instanceVersion) << "."
                  << VK_VERSION_PATCH(instanceVersion) << "\n";
        std::cout << "mxvk: engine version: "
                  << MXVK_VERSION_CODE_MAJOR << "."
                  << MXVK_VERSION_CODE_MINOR << "."
                  << MXVK_VERSION_CODE_PATCH << "\n";
 
        std::cout << "SDL3: creating Vulkan presentation surface from SDL window\n";
        if (!SDL_Vulkan_CreateSurface(window.get(), instance, nullptr, &surface)) {
            std::cerr << std::format("mxvk: Failed to create Vulkan surface: {}\n", SDL_GetError());
            cleanupDebugMessenger();
            vkDestroyInstance(instance, nullptr);
            instance = VK_NULL_HANDLE;
            surface = VK_NULL_HANDLE;
            return false;
        }
 
        std::cout << "mxvk: selecting suitable physical device\n";
        pickDevice();
        if (physical_device == VK_NULL_HANDLE) {
            std::cerr << "mxvk: Failed to find a Vulkan physical device with present support\n";
            return false;
        }
 
        std::cout << "mxvk: creating logical device and queues\n";
        createLogicalDevice();
        if (device == VK_NULL_HANDLE) {
            std::cerr << "mxvk: Failed to create Vulkan logical device\n";
            return false;
        }
        createPipelineCache();
 
        std::cout << "mxvk: deferring swapchain/render/sync resource creation until first frame\n";
 
        std::cout << "mxvk: initVulkan complete\n";
        return true;
    }

initWindow()

bool mxvk::VK_Window::initWindow ( const std::string & title, int width, int height, SDL_WindowFlags flags )

protectedinherited

Initialize SDL window resources.

Parameters

title	Window title string.
width	Window width in pixels.
height	Window height in pixels.
flags	Additional SDL window creation flags.

Returns

true on success, false otherwise.

Definition at line 1059 of file mxvk.cpp.

                                                                                                   {
        std::cout << std::format("mxvk: entering initWindow (title='{}', width={}, height={})\n", title, width, height);
        if (width <= 0 || height <= 0) {
            std::cerr << "mxvk: Window dimensions must be positive\n";
            return false;
        }
 
        if (!sdl_initialized) {
            constexpr SDL_InitFlags sdlInitFlags = SDL_INIT_VIDEO | SDL_INIT_GAMEPAD;
            std::cout << "SDL3: initializing video/gamepad subsystems\n";
            if (!SDL_Init(sdlInitFlags)) {
                std::cerr << "mxvk: Error on SDL init: " << SDL_GetError() << "\n";
                return false;
            }
            sdl_initialized = true;
            SDL_SetGamepadEventsEnabled(true);
            SDL_SetJoystickEventsEnabled(true);
            std::cout << "SDL3: video/gamepad subsystems initialized\n";
        }
 
        const bool fullscreen = (flags & SDL_WINDOW_FULLSCREEN) != 0;
        const SDL_DisplayMode *fullscreen_mode = nullptr;
        if (fullscreen) {
            const SDL_DisplayID display = SDL_GetPrimaryDisplay();
            fullscreen_mode = display != 0 ? SDL_GetCurrentDisplayMode(display) : nullptr;
            if (fullscreen_mode != nullptr && fullscreen_mode->w > 0 && fullscreen_mode->h > 0) {
                width = fullscreen_mode->w;
                height = fullscreen_mode->h;
                std::cout << std::format("SDL3: using current display mode for fullscreen window: {}x{}\n", width, height);
            }
        }
 
        std::cout << "SDL3: creating SDL window with Vulkan capability\n";
        SDL_Window *raw_window = SDL_CreateWindow(title.c_str(), width, height, flags);
        if (raw_window == nullptr) {
            std::cerr << std::format("Error creating window: {}\n", SDL_GetError());
            std::cout << "SDL3: rolling back SDL video/gamepad subsystems after window creation failure\n";
            SDL_QuitSubSystem(SDL_INIT_VIDEO | SDL_INIT_GAMEPAD);
            sdl_initialized = false;
            return false;
        }
 
        window.reset(raw_window);
        if (fullscreen && fullscreen_mode != nullptr && !SDL_SetWindowFullscreenMode(window.get(), fullscreen_mode)) {
            std::cerr << std::format("mxvk: SDL_SetWindowFullscreenMode failed: {}\n", SDL_GetError());
        }
        std::cout << "SDL3: showing created window\n";
        SDL_ShowWindow(window.get());
        if (fullscreen && !SDL_SyncWindow(window.get())) {
            std::cerr << std::format("mxvk: SDL_SyncWindow failed after fullscreen show: {}\n", SDL_GetError());
        }
        if (fullscreen) {
            for (int attempt = 0; attempt < 50; ++attempt) {
                int pixel_width = 0;
                int pixel_height = 0;
                SDL_GetWindowSizeInPixels(window.get(), &pixel_width, &pixel_height);
                if (pixel_width == width && pixel_height == height) {
                    break;
                }
                SDL_PumpEvents();
                SDL_Delay(10);
            }
        }
        std::cout << "mxvk: initWindow complete\n";
        return true;
    }

loadSpv()

std::vector< char > mxvk::VK_Window::loadSpv ( const std::string & path )

staticprotectedinherited

Load a SPIR-V file from disk.

Parameters

path	Absolute or relative path to a .spv file.

Returns

Raw bytes loaded from file.

Exceptions

mxvk::Exception

when the file cannot be opened, is empty, or is not 4-byte aligned.

Definition at line 141 of file mxvk.cpp.

                                                            {
        return mxvk::load_spv(path);
    }

logic()

void MasterPieceWindow::logic ( )

inline

Definition at line 744 of file acid.drop.cpp.

                 {
        static Uint32 lastMove = 0;
        Uint32 now = SDL_GetTicks();
 
        if (flashActive) {
            if (now - flashStartTime >= FLASH_DURATION) {
 
                clearFlashedBlocks();
                flashActive = false;
                applyGravity();
 
                if (findMatches()) {
                    startFlash();
                }
            }
            return;
        }
 
        if (now - lastMove > (Uint32)(matrix.Game.speed * 50)) {
            lastMove = now;
 
            if (canMoveDown()) {
                matrix.block.y++;
            } else {
 
                placeBlock();
                applyGravity();
 
                if (findMatches()) {
                    startFlash();
                } else {
 
                    spawnNewBlock();
 
                    if (checkGameOver()) {
                        currentScreen = SCREEN_GAMEOVER;
                    }
                }
            }
        }
    }

loop()

void mxvk::VK_Window::loop ( )

inherited

Run the main event/render loop.

Definition at line 600 of file mxvk.cpp.

                         {
        SDL_Event e;
        active = true;
        while (active) {
            while (SDL_PollEvent(&e)) {
                switch (e.type) {
                case SDL_EVENT_QUIT:
                    active = false;
                    break;
                case SDL_EVENT_WINDOW_PIXEL_SIZE_CHANGED:
                    if (window != nullptr) {
                        framebuffer_resized = true;
                        last_resize_event_ms = SDL_GetTicks();
                        force_swapchain_recreate = false;
                    }
                    break;
                case SDL_EVENT_KEY_DOWN:
                    if ((e.key.key == SDLK_F12 || e.key.scancode == SDL_SCANCODE_F12) && !e.key.repeat) {
                        toggleFpsCounter();
                    }
                    if (screenshot_enabled &&
                        (e.key.key == SDLK_F10 || e.key.scancode == SDL_SCANCODE_F10) &&
                        !e.key.repeat) {
                        try {
                            saveScreenshot();
                        } catch (const mxvk::Exception &ex) {
                            std::cerr << std::format("mxvk: screenshot failed: {}\n", ex.text());
                        } catch (const std::exception &ex) {
                            std::cerr << std::format("mxvk: screenshot failed: {}\n", ex.what());
                        }
                        continue;
                    }
                    break;
                default:
                    break;
                }
                event(e);
            }
            if (framebuffer_resized) {
                const uint64_t now_ms = SDL_GetTicks();
                if (!force_swapchain_recreate &&
                    last_resize_event_ms != 0 &&
                    (now_ms - last_resize_event_ms) < resize_settle_delay_ms) {
                    proc();
                    render();
                    SDL_Delay(1);
                    continue;
                }
                recreateSwapchain();
            }
            proc();
            render();
            maybeTrimMemory();
        }
    }

moveBlockDown()

void MasterPieceWindow::moveBlockDown ( )

inline

Definition at line 1080 of file acid.drop.cpp.

                         {
        if (canMoveDown()) {
            matrix.block.y++;
        }
    }

moveBlockLeft()

void MasterPieceWindow::moveBlockLeft ( )

inline

Definition at line 1068 of file acid.drop.cpp.

                         {
        if (canMoveLeft()) {
            matrix.block.x--;
        }
    }

moveBlockRight()

void MasterPieceWindow::moveBlockRight ( )

inline

Definition at line 1074 of file acid.drop.cpp.

                          {
        if (canMoveRight()) {
            matrix.block.x++;
        }
    }

onConfigureDepthStencilAttachments()

void mxvk::VK_Window::onConfigureDepthStencilAttachments ( VkRenderingAttachmentInfo & depth_attachment, VkRenderingAttachmentInfo & stencil_attachment, uint32_t image_index )

protectedvirtualinherited

Allow derived classes to customize depth/stencil attachments for the main dynamic rendering pass.

Override this when custom rendering needs hardware stencil testing or a custom depth/stencil image. The callback is invoked immediately before vkCmdBeginRendering.

Reimplemented in example::StencilWindow.

Definition at line 1138 of file mxvk.cpp.

                                                                                              {}

onPrepareFrameRendering()

void mxvk::VK_Window::onPrepareFrameRendering ( VkCommandBuffer cmd, uint32_t image_index )

virtualinherited

Record resource transitions that must happen before dynamic rendering begins.

This callback is invoked after the command buffer begins recording and before vkCmdBeginRendering. Override this for resources that need per-frame image transitions or uploads before they are sampled by custom rendering.

Parameters

cmd	Active command buffer in recording state, outside a rendering scope.
image_index	Current swapchain image index.

Reimplemented in defender::DefenderWindow, example::StencilWindow, and example::WaterWindow.

Definition at line 1134 of file mxvk.cpp.

{}

onRecordCustomRendering()

void mxvk::VK_Window::onRecordCustomRendering ( VkCommandBuffer cmd, uint32_t image_index )

protectedvirtualinherited

Optional hook for derived classes to record extra draw commands.

This callback is invoked inside the dynamic-rendering scope started by the window, after viewport/scissor are configured and before rendering ends.

Parameters

cmd	Active command buffer in recording state.
image_index	Current swapchain image index.

Reimplemented in anonymous_namespace{breakout.cpp}::BreakoutWindow, anonymous_namespace{pong.cpp}::PongWindow, anonymous_namespace{puzzle_drop.cpp}::PuzzleDropWindow, anonymous_namespace{tetris.cpp}::TetrisWindow, ComputeWindow, defender::DefenderWindow, demo::PoolWindow, example::BinaryMatrixWindow, example::DarkWindow, example::ExampleWindow, example::ExampleWindow, example::ExampleWindow, example::FireworksWindow, example::FractalWindow, example::GlitchCubeWindow, example::ModelWindow, example::ModelWindow, example::MoonWindow, example::OpenCVModelWindow, example::PlanetWindow, example::PointSpriteWindow, example::StarfieldWindow, example::StarshipWindow, example::StaticWindow, example::StencilWindow, example::WaterWindow, space::Asteroids3DWindow, space::Asteroids3DWindow, viewer::ModelViewerWindow, walk::WalkWindow, and walk::WalkWindow.

Definition at line 1136 of file mxvk.cpp.

{}

onSwapchainAboutToRecreate()

void mxvk::VK_Window::onSwapchainAboutToRecreate ( )

protectedvirtualinherited

Called right before swapchain-dependent resources are recreated.

Derived classes can release swapchain-dependent resources here.

Reimplemented in anonymous_namespace{pong.cpp}::PongWindow, example::ExampleWindow, example::FractalWindow, example::PlanetWindow, example::StaticWindow, example::StencilWindow, and example::WaterWindow.

Definition at line 1130 of file mxvk.cpp.

{}

onSwapchainRecreated()

void mxvk::VK_Window::onSwapchainRecreated ( )

protectedvirtualinherited

Called after swapchain and render resources are recreated.

Derived classes can rebuild swapchain-dependent resources here.

Reimplemented in anonymous_namespace{breakout.cpp}::BreakoutWindow, anonymous_namespace{pong.cpp}::PongWindow, anonymous_namespace{puzzle_drop.cpp}::PuzzleDropWindow, anonymous_namespace{tetris.cpp}::TetrisWindow, ComputeWindow, defender::DefenderWindow, demo::PoolWindow, example::BinaryMatrixWindow, example::DarkWindow, example::ExampleWindow, example::ExampleWindow, example::ExampleWindow, example::FireworksWindow, example::FractalWindow, example::GlitchCubeWindow, example::MatrixWindow, example::ModelWindow, example::ModelWindow, example::MoonWindow, example::OpenCVModelWindow, example::PlanetWindow, example::PointSpriteWindow, example::StarfieldWindow, example::StarshipWindow, space::Asteroids3DWindow, space::Asteroids3DWindow, surface::SurfaceWindow, surface::SurfaceWindow, viewer::ModelViewerWindow, walk::WalkWindow, and walk::WalkWindow.

Definition at line 1132 of file mxvk.cpp.

{}

openGamepad()

bool MasterPieceWindow::openGamepad ( SDL_JoystickID id )

inline

Definition at line 315 of file acid.drop.cpp.

                                        {
        if (gamepad != nullptr && gamepadId == id) {
            return true;
        }
        if (gamepad != nullptr) {
            SDL_CloseGamepad(gamepad);
            gamepad = nullptr;
            gamepadId = 0;
        }
        gamepad = SDL_OpenGamepad(id);
        if (gamepad == nullptr) {
            return false;
        }
        gamepadId = id;
        return true;
    }

pickDevice()

void mxvk::VK_Window::pickDevice ( )

protectedinherited

Pick a suitable Vulkan physical device.

Definition at line 1427 of file mxvk.cpp.

                               {
        std::cout << "mxvk: entering pickDevice\n";
        if (instance == VK_NULL_HANDLE || surface == VK_NULL_HANDLE) {
            std::cout << "vk: cannot pick device because instance or surface is missing\n";
            return;
        }
 
        uint32_t device_count = 0;
        std::cout << "vk: enumerating physical devices\n";
        vkEnumeratePhysicalDevices(instance, &device_count, nullptr);
        if (device_count == 0U) {
            std::cout << "vk: no physical devices found\n";
            return;
        }
        std::cout << std::format("vk: found {} physical device(s)\n", device_count);
 
        std::vector<VkPhysicalDevice> devices(device_count);
        vkEnumeratePhysicalDevices(instance, &device_count, devices.data());
 
        for (const VkPhysicalDevice candidate : devices) {
            std::cout << "vk: evaluating candidate physical device\n";
            uint32_t queue_family_count = 0;
            vkGetPhysicalDeviceQueueFamilyProperties(candidate, &queue_family_count, nullptr);
            std::vector<VkQueueFamilyProperties> queue_families(queue_family_count);
            vkGetPhysicalDeviceQueueFamilyProperties(candidate, &queue_family_count, queue_families.data());
 
            uint32_t candidate_graphics = invalid_queue_index;
            uint32_t candidate_present = invalid_queue_index;
 
            for (uint32_t i = 0; i < queue_family_count; ++i) {
                if ((queue_families[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) != 0U) {
                    candidate_graphics = i;
                }
 
                VkBool32 present_support = VK_FALSE;
                vkGetPhysicalDeviceSurfaceSupportKHR(candidate, i, surface, &present_support);
                if (present_support == VK_TRUE) {
                    candidate_present = i;
                }
            }
 
            if (candidate_graphics == invalid_queue_index || candidate_present == invalid_queue_index) {
                std::cout << "vk: candidate rejected due to missing graphics/present queue support\n";
                continue;
            }
 
            const SwapchainSupport swapchain_support = querySwapchainSupport(candidate, surface);
            if (swapchain_support.formats.empty() || swapchain_support.present_modes.empty()) {
                std::cout << "vk: candidate rejected due to incomplete swapchain support\n";
                continue;
            }
 
            VkPhysicalDeviceProperties properties{};
            vkGetPhysicalDeviceProperties(candidate, &properties);
 
            const char *device_type = "unknown";
            switch (properties.deviceType) {
            case VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU:
                device_type = "integrated";
                break;
            case VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU:
                device_type = "discrete";
                break;
            case VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU:
                device_type = "virtual";
                break;
            case VK_PHYSICAL_DEVICE_TYPE_CPU:
                device_type = "cpu";
                break;
            default:
                break;
            }
 
            physical_device = candidate;
            graphics_queue_family = candidate_graphics;
            present_queue_family = candidate_present;
            std::cout << std::format(
                "vk: selected GPU='{}' type={} vendor=0x{:04x} device=0x{:04x}\n",
                properties.deviceName,
                device_type,
                properties.vendorID,
                properties.deviceID);
            return;
        }
 
        std::cout << "vk: no suitable physical device selected\n";
    }

placeBlock()

void MasterPieceWindow::placeBlock ( )

inline

Definition at line 858 of file acid.drop.cpp.

                      {
        int bx = matrix.block.x;
        int by = matrix.block.y;
 
        if (matrix.block.horizontal) {
 
            if (by >= 0 && by < GRID_HEIGHT) {
                if (bx >= 0 && bx < GRID_WIDTH)
                    matrix.grid[bx][by] = matrix.block.color.c1;
                if (bx + 1 >= 0 && bx + 1 < GRID_WIDTH)
                    matrix.grid[bx + 1][by] = matrix.block.color.c2;
                if (bx + 2 >= 0 && bx + 2 < GRID_WIDTH)
                    matrix.grid[bx + 2][by] = matrix.block.color.c3;
            }
        } else {
 
            if (by >= 0 && by < GRID_HEIGHT)
                matrix.grid[bx][by] = matrix.block.color.c1;
            if (by + 1 >= 0 && by + 1 < GRID_HEIGHT)
                matrix.grid[bx][by + 1] = matrix.block.color.c2;
            if (by + 2 >= 0 && by + 2 < GRID_HEIGHT)
                matrix.grid[bx][by + 2] = matrix.block.color.c3;
        }
    }

pollController()

void MasterPieceWindow::pollController ( )

inline

Definition at line 1257 of file acid.drop.cpp.

                          {
        if (gamepad == nullptr)
            return;
        Uint32 now = SDL_GetTicks();
 
        if (currentScreen == SCREEN_GAME && !paused) {
            Sint16 lx = SDL_GetGamepadAxis(gamepad, SDL_GAMEPAD_AXIS_LEFTX);
            Sint16 ly = SDL_GetGamepadAxis(gamepad, SDL_GAMEPAD_AXIS_LEFTY);
 
            if (lx < -JOYSTICK_DEAD_ZONE) {
                if (now - joyRepeatLeft > JOY_REPEAT_DELAY) {
                    moveBlockLeft();
                    joyRepeatLeft = now;
                }
            } else {
                joyRepeatLeft = 0;
            }
            if (lx > JOYSTICK_DEAD_ZONE) {
                if (now - joyRepeatRight > JOY_REPEAT_DELAY) {
                    moveBlockRight();
                    joyRepeatRight = now;
                }
            } else {
                joyRepeatRight = 0;
            }
            if (ly > JOYSTICK_DEAD_ZONE) {
                if (now - joyRepeatDown > JOY_REPEAT_DELAY) {
                    moveBlockDown();
                    joyRepeatDown = now;
                }
            } else {
                joyRepeatDown = 0;
            }
            if (ly < -JOYSTICK_DEAD_ZONE) {
                if (now - joyRepeatUp > JOY_REPEAT_DELAY) {
                    matrix.block.color.shiftcolor(true);
                    joyRepeatUp = now;
                }
            } else {
                joyRepeatUp = 0;
            }
        }
    }

printText() [1/3]

void mxvk::VK_Window::printText ( const std::string & text, int x, int y, const SDL_Color & col )

inherited

Queue a text string for rendering during the current frame.

Parameters

text	UTF-8 text.
x	Pixel X coordinate.
y	Pixel Y coordinate.
col	Text color.

Definition at line 3018 of file mxvk.cpp.

                                                                                       {
        if (text.empty()) {
            return;
        }
 
        if (!font_configured) {
            throw mxvk::Exception("printText requires setFont() to be called first");
        }
 
        ensureTextRenderer();
        text_renderer->printTextG_Solid(text, x, y, col);
    }

printText() [2/3]

void mxvk::VK_Window::printText ( const std::string & text, int x, int y, const SDL_Color & col, const Font & font )

inherited

Definition at line 3047 of file mxvk.cpp.

                                                                                                         {
        if (text.empty()) {
            return;
        }
 
        if (!font) {
            throw mxvk::Exception("printText requires a valid mxvk::Font");
        }
 
        ensureTextRenderer(font.path(), font.size());
        if (!text_renderer) {
            throw mxvk::Exception("printText with an explicit font could not initialize the text renderer");
        }
        text_renderer->printTextG_Solid(text, x, y, col, font);
    }

printText() [3/3]

void mxvk::VK_Window::printText ( const std::string & text, int x, int y, const SDL_Color & col, TTF_Font * font )

inherited

Definition at line 3031 of file mxvk.cpp.

                                                                                                       {
        if (text.empty()) {
            return;
        }
 
        if (font == nullptr) {
            throw mxvk::Exception("printText requires a non-null TTF_Font");
        }
 
        ensureTextRenderer(resolveDefaultFontPath(), font_size);
        if (!text_renderer) {
            throw mxvk::Exception("printText with an explicit font could not initialize the text renderer");
        }
        text_renderer->printTextG_Solid(text, x, y, col, font);
    }

proc()

void MasterPieceWindow::proc ( )

inlineoverridevirtual

Execute one processing/update step.

Reimplemented from mxvk::VK_Window.

Definition at line 387 of file acid.drop.cpp.

                         {
        if (window != nullptr) {
            SDL_GetWindowSizeInPixels(window.get(), &w, &h);
        }
        if (startScreen == nullptr) {
            initGfx();
        }
        pollController();
        switch (currentScreen) {
        case SCREEN_INTRO:
            updateIntro();
            break;
        case SCREEN_START:
            updateStart();
            break;
        case SCREEN_GAME:
            updateGame();
            break;
        case SCREEN_GAMEOVER:
            updateGameOver();
            break;
        case SCREEN_OPTIONS:
            updateOptions();
            break;
        case SCREEN_CREDITS:
            updateCredits();
            break;
        case SCREEN_SCORES:
            updateScores();
            break;
        }
    }

release()

void mxvk::VK_Window::release ( )

inherited

Release Vulkan and SDL resources.

Safe to call multiple times.

Definition at line 218 of file mxvk.cpp.

                            {
        std::cout << "mxvk: starting resource teardown\n";
        stopScreenshotWorker();
 
        if (device != VK_NULL_HANDLE) {
            std::cout << "vk: waiting for device idle before teardown\n";
            vkDeviceWaitIdle(device);
        }
 
        post_process_sprite = nullptr;
        owned_post_process_sprite = nullptr;
        post_process_sprites.clear();
        owned_post_process_sprites.clear();
        post_process_effect_params.clear();
        post_process_effect_time_enabled.clear();
        post_process_effect_start_times.clear();
 
        if (!sprites.empty()) {
            std::cout << std::format("vk: releasing {} sprite(s)\n", sprites.size());
            sprites.clear();
        }
        if (!sprites3d.empty()) {
            std::cout << std::format("vk: releasing {} 3D sprite batch(es)\n", sprites3d.size());
            sprites3d.clear();
        }
        sprite_state_dirty = false;
        destroySpritePipeline();
        if (sprite_descriptor_set_layout != VK_NULL_HANDLE && device != VK_NULL_HANDLE) {
            vkDestroyDescriptorSetLayout(device, sprite_descriptor_set_layout, nullptr);
            sprite_descriptor_set_layout = VK_NULL_HANDLE;
        }
 
        if (text_renderer) {
            text_renderer.reset();
        }
        text_state_dirty = false;
        destroyTextPipeline();
        if (text_descriptor_set_layout != VK_NULL_HANDLE && device != VK_NULL_HANDLE) {
            vkDestroyDescriptorSetLayout(device, text_descriptor_set_layout, nullptr);
            text_descriptor_set_layout = VK_NULL_HANDLE;
        }
 
        cleanupSyncObjects();
 
        if (!retired_swapchains.empty()) {
            for (VkSwapchainKHR retired : retired_swapchains) {
                vkDestroySwapchainKHR(device, retired, nullptr);
            }
            retired_swapchains.clear();
        }
        std::cout << "vk: tearing down swapchain-dependent resources\n";
        cleanupSwapchain(true);
 
        if (command_pool != VK_NULL_HANDLE && device != VK_NULL_HANDLE) {
            std::cout << "vk: destroying command pool\n";
            vkDestroyCommandPool(device, command_pool, nullptr);
            command_pool = VK_NULL_HANDLE;
        }
 
        if (device != VK_NULL_HANDLE) {
            savePipelineCache();
            destroyPipelineCache();
            std::cout << "vk: destroying logical device\n";
            vkDestroyDevice(device, nullptr);
            device = VK_NULL_HANDLE;
            graphics_queue = VK_NULL_HANDLE;
            present_queue = VK_NULL_HANDLE;
        }
 
        graphics_queue_family = invalid_queue_index;
        present_queue_family = invalid_queue_index;
        physical_device = VK_NULL_HANDLE;
 
        if (surface != VK_NULL_HANDLE && instance != VK_NULL_HANDLE) {
            std::cout << "vk: destroying presentation surface\n";
            vkDestroySurfaceKHR(instance, surface, nullptr);
            surface = VK_NULL_HANDLE;
        }
 
        cleanupDebugMessenger();
 
        if (instance != VK_NULL_HANDLE) {
            std::cout << "vk: destroying Vulkan instance\n";
            vkDestroyInstance(instance, nullptr);
            instance = VK_NULL_HANDLE;
        }
 
        std::cout << "SDL3: destroying SDL window handle\n";
        window.reset();
 
        if (sdl_initialized) {
            std::cout << "SDL3: shutting down SDL video/gamepad subsystems\n";
            SDL_QuitSubSystem(SDL_INIT_VIDEO | SDL_INIT_GAMEPAD);
            sdl_initialized = false;
        }
 
        active = false;
        std::cout << "mxvk: resource teardown complete\n";
    }

render()

void mxvk::VK_Window::render ( )

virtualinherited

Render one frame.

Reimplemented in example::FractalWindow, and viewer::ModelViewerWindow.

Definition at line 778 of file mxvk.cpp.

                           {
        drawFrame();
    }

renderStandaloneSprite()

void mxvk::VK_Window::renderStandaloneSprite ( VK_Sprite & sprite, VkCommandBuffer cmd )

protectedinherited

Render one standalone sprite using the window's shared sprite pipeline.

This is intended for derived classes that want to draw a sprite before or after their own scene content without registering it in the window-managed sprite list.

Definition at line 1142 of file mxvk.cpp.

                                                                                 {
        if (device == VK_NULL_HANDLE || swapchain_extent.width == 0U || swapchain_extent.height == 0U) {
            return;
        }
 
        if (sprite_pipeline == VK_NULL_HANDLE) {
            return;
        }
        vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, sprite_pipeline);
        sprite.renderSprites(cmd, sprite_pipeline_layout, swapchain_extent.width, swapchain_extent.height);
    }

rotateBlock()

void MasterPieceWindow::rotateBlock ( )

inline

Definition at line 1118 of file acid.drop.cpp.

                       {
        if (canRotate()) {
            matrix.block.horizontal = !matrix.block.horizontal;
        }
    }

saveSnapshot()

void mxvk::VK_Window::saveSnapshot ( const std::string & path )

inherited

Save the most recently rendered window contents as a PNG file.

Parameters

path	Destination PNG path.

This performs a synchronous GPU readback and may briefly stall rendering.

Definition at line 782 of file mxvk.cpp.

                                                      {
        if (path.empty()) {
            throw mxvk::Exception("saveSnapshot requires a non-empty output path");
        }
 
        std::vector<std::uint8_t> rgba{};
        uint32_t width = 0;
        uint32_t height = 0;
        captureSnapshotPixels(rgba, width, height);
 
        if (!mxvk::SavePNG_RGBA(path.c_str(),
                                rgba.data(),
                                static_cast<int>(width),
                                static_cast<int>(height))) {
            throw mxvk::Exception("saveSnapshot failed to write PNG: " + path);
        }
    }

scaleY()

int MasterPieceWindow::scaleY ( int baseY )

inline

Definition at line 375 of file acid.drop.cpp.

                          {
        return (int)(baseY * ((float)h / 480.0f));
    }

screenshotEnabled()

bool mxvk::VK_Window::screenshotEnabled ( ) const

inlinenodiscardnoexceptinherited

Check whether F10 screenshot capture is enabled.

Definition at line 162 of file mxvk.hpp.

{ return screenshot_enabled; }

setClearColor()

void mxvk::VK_Window::setClearColor ( float r, float g, float b, float a = 1.0f )

inherited

Set the per-frame color attachment clear color.

Parameters

r	Red channel [0, 1].
g	Green channel [0, 1].
b	Blue channel [0, 1].
a	Alpha channel [0, 1].

Definition at line 593 of file mxvk.cpp.

                                                                    {
        clear_color.float32[0] = std::clamp(r, 0.0f, 1.0f);
        clear_color.float32[1] = std::clamp(g, 0.0f, 1.0f);
        clear_color.float32[2] = std::clamp(b, 0.0f, 1.0f);
        clear_color.float32[3] = std::clamp(a, 0.0f, 1.0f);
    }

setEnableScreenshot()

void mxvk::VK_Window::setEnableScreenshot ( bool enabled )

inlinenoexceptinherited

Enable or disable F10 screenshot capture.

Definition at line 159 of file mxvk.hpp.

{ screenshot_enabled = enabled; }

setFont()

void mxvk::VK_Window::setFont ( const std::string & fontPath, int fontSize = 24 )

inherited

Set the active text-render font.

Parameters

fontPath	Path to a TTF font file.
fontSize	Font point size.

Definition at line 2991 of file mxvk.cpp.

                                                                   {
        if (fontPath.empty() || fontSize <= 0) {
            throw mxvk::Exception("setFont requires a non-empty path and positive font size");
        }
 
        font_path = fontPath;
        font_size = fontSize;
        font_configured = true;
 
        if (device == VK_NULL_HANDLE) {
            throw mxvk::Exception("Cannot set font before Vulkan device initialization");
        }
        if (swapchain == VK_NULL_HANDLE || command_pool == VK_NULL_HANDLE) {
            createDevice();
        }
        if (swapchain == VK_NULL_HANDLE || command_pool == VK_NULL_HANDLE) {
            throw mxvk::Exception("Cannot initialize text renderer before swapchain and command resources are available");
        }
 
        if (!text_renderer) {
            ensureTextRenderer();
        } else {
            text_renderer->setFont(font_path, font_size);
        }
        text_state_dirty = true;
    }

setPostProcessingEnabled()

void mxvk::VK_Window::setPostProcessingEnabled ( bool enabled )

inlineinherited

Definition at line 284 of file mxvk.hpp.

{ post_process_enabled = enabled; }

setPostProcessingShaderParams() [1/2]

void mxvk::VK_Window::setPostProcessingShaderParams ( float p1 = 0.0f, float p2 = 0.0f, float p3 = 0.0f, float p4 = 0.0f )

inherited

Set the post-processing shader params passed as a vec4 push constant.

Definition at line 1227 of file mxvk.cpp.

                                                                                        {
        post_process_params = {p1, p2, p3, p4};
        if (post_process_sprites.empty()) {
            return;
        }
        setPostProcessingShaderParams(0, p1, p2, p3, p4);
    }

setPostProcessingShaderParams() [2/2]

void mxvk::VK_Window::setPostProcessingShaderParams ( size_t effectIndex, float p1 = 0.0f, float p2 = 0.0f, float p3 = 0.0f, float p4 = 0.0f )

inherited

Definition at line 1235 of file mxvk.cpp.

                                                                                                            {
        if (effectIndex >= post_process_sprites.size()) {
            return;
        }
        post_process_params = {p1, p2, p3, p4};
        if (effectIndex < post_process_effect_params.size()) {
            post_process_effect_params[effectIndex] = post_process_params;
        }
        if (post_process_sprites[effectIndex] != nullptr) {
            post_process_sprites[effectIndex]->setShaderParams(p1, p2, p3, p4);
        }
    }

setPostProcessingShaderTimeEnabled() [1/2]

void mxvk::VK_Window::setPostProcessingShaderTimeEnabled ( bool enabled )

inherited

Keep shader param 1 updated with elapsed render time in seconds.

Definition at line 1248 of file mxvk.cpp.

                                                                   {
        post_process_time_enabled = enabled;
        post_process_start_time = std::chrono::steady_clock::now();
        if (post_process_sprites.empty()) {
            return;
        }
        setPostProcessingShaderTimeEnabled(0, enabled);
    }

setPostProcessingShaderTimeEnabled() [2/2]

void mxvk::VK_Window::setPostProcessingShaderTimeEnabled ( size_t effectIndex, bool enabled )

inherited

Definition at line 1257 of file mxvk.cpp.

                                                                                       {
        if (effectIndex >= post_process_sprites.size()) {
            return;
        }
        post_process_time_enabled = enabled;
        post_process_start_time = std::chrono::steady_clock::now();
        if (effectIndex < post_process_effect_time_enabled.size()) {
            post_process_effect_time_enabled[effectIndex] = enabled;
        }
        if (effectIndex < post_process_effect_start_times.size()) {
            post_process_effect_start_times[effectIndex] = post_process_start_time;
        }
    }

showCursor()

void mxvk::VK_Window::showCursor ( bool on )

inherited

Definition at line 3633 of file mxvk.cpp.

                                      {
        if (on)
            SDL_ShowCursor();
        else
            SDL_HideCursor();
    }

spawnNewBlock()

void MasterPieceWindow::spawnNewBlock ( )

inline

Definition at line 1035 of file acid.drop.cpp.

                         {
        matrix.block.color = matrix.nextblock.color;
        matrix.nextblock.color.randcolor();
        matrix.block.x = GRID_WIDTH / 2;
        matrix.block.y = 1;
        matrix.block.horizontal = false;
    }

startFlash()

void MasterPieceWindow::startFlash ( )

inline

Definition at line 988 of file acid.drop.cpp.

                      {
        flashActive = true;
        flashStartTime = SDL_GetTicks();
    }

trimMemory()

void mxvk::VK_Window::trimMemory ( )

inherited

Return transient Vulkan command-pool allocations to the driver when supported.

MXVK currently uses direct Vulkan memory allocations rather than VMA, so VMA defragmentation is not applicable. This hook schedules the available Vulkan memory maintenance operation and is safe to call during idle/loading points.

Definition at line 1041 of file mxvk.cpp.

                               {
        if (device == VK_NULL_HANDLE || command_pool == VK_NULL_HANDLE || vkTrimCommandPool == nullptr) {
            return;
        }
 
        vkTrimCommandPool(device, command_pool, 0);
    }

tryOpenFirstGamepad()

void MasterPieceWindow::tryOpenFirstGamepad ( )

inline

Definition at line 332 of file acid.drop.cpp.

                               {
        if (gamepad != nullptr) {
            return;
        }
        int count = 0;
        SDL_JoystickID *ids = SDL_GetGamepads(&count);
        if (ids == nullptr || count <= 0) {
            if (ids != nullptr) {
                SDL_free(ids);
            }
            return;
        }
        openGamepad(ids[0]);
        SDL_free(ids);
    }

updateCredits()

void MasterPieceWindow::updateCredits ( )

inline

Definition at line 542 of file acid.drop.cpp.

                         {
        if (creditScreen) {
            float time_f = static_cast<float>(SDL_GetTicks()) / 1000.0f;
            creditScreen->setShaderParams(time_f, 0.0f, 0.0f, 0.0f);
            creditScreen->drawSpriteRect(0, 0, w, h);
        }
 
        const char *credReturn = "Press Return to return";
        printText(credReturn, centerX(credReturn), scaleY(360), {255, 255, 0, 255});
    }

updateFontSize()

void MasterPieceWindow::updateFontSize ( )

inline

Definition at line 305 of file acid.drop.cpp.

                          {
        int fontSize = (int)(20.0f * ((float)h / 480.0f));
        fontSize = std::max(16, std::min(128, fontSize));
        if (fontSize != lastFontSize) {
            lastFontSize = fontSize;
            setFont(current_path + "/data/font.ttf", fontSize);
            clearTextQueue();
        }
    }

updateGame()

void MasterPieceWindow::updateGame ( )

inline

Definition at line 452 of file acid.drop.cpp.

                      {
        if (!paused) {
            logic();
        }
        drawGame();
    }

updateGameOver()

void MasterPieceWindow::updateGameOver ( )

inline

Definition at line 459 of file acid.drop.cpp.

                          {
        if (gamebg[shaderLevel]) {
            float time_f = static_cast<float>(SDL_GetTicks()) / 1000.0f;
            gamebg[shaderLevel]->setShaderParams(time_f, 0.0f, 0.0f, 0.0f);
            gamebg[shaderLevel]->drawSpriteRect(0, 0, w, h);
        }
 
        const char *gameOverText = "GAME OVER!";
        printText(gameOverText, centerX(gameOverText), h / 2 - 80, {255, 0, 0, 255});
 
        std::ostringstream stream;
        stream << "Final Score: " << matrix.Game.score;
        std::string scoreStr = stream.str();
        printText(scoreStr.c_str(), centerX(scoreStr.c_str()), h / 2 - 20, {255, 255, 255, 255});
 
        stream.str("");
        stream << "Tabs: " << matrix.Game.lines;
        std::string linesStr = stream.str();
        printText(linesStr.c_str(), centerX(linesStr.c_str()), h / 2 + 40, {255, 255, 255, 255});
 
        const char *returnText = "Press ENTER to view High Scores";
        printText(returnText, centerX(returnText), h / 2 + 120, {255, 255, 0, 255});
    }

updateIntro()

void MasterPieceWindow::updateIntro ( )

inline

Definition at line 420 of file acid.drop.cpp.

                       {
        if (introScreen) {
            float time_f = static_cast<float>(SDL_GetTicks()) / 1000.0f;
            introScreen->setShaderParams(time_f, 1.0f, 0.8f, 1.2f);
            introScreen->drawSpriteRect(0, 0, w, h);
        }
        Uint32 currentTick = SDL_GetTicks();
        if (currentTick - lastTick > 5000) {
            currentScreen = SCREEN_START;
            lastTick = currentTick;
        }
    }

updateOptions()

void MasterPieceWindow::updateOptions ( )

inline

Definition at line 490 of file acid.drop.cpp.

                         {
        if (startScreen) {
            float time_f = static_cast<float>(SDL_GetTicks()) / 1000.0f;
            startScreen->setShaderParams(time_f, 0.0f, 0.0f, 0.0f);
            startScreen->drawSpriteRect(0, 0, w, h);
        }
 
        int titleY = scaleY(100);
        int optStartY = scaleY(180);
        int spacing = getMenuSpacing();
 
        const char *optTitle = "OPTIONS";
        printText(optTitle, centerX(optTitle), titleY, {255, 255, 0, 255});
 
        const char *difficultyLabels[] = {"Easy", "Normal", "Hard"};
        std::string diffText = std::string("< Difficulty: ") + difficultyLabels[difficultySetting] + " >";
        SDL_Color diffColor = (optionsCursor == 0) ? SDL_Color{255, 255, 0, 255} : SDL_Color{255, 255, 255, 255};
        printText(diffText.c_str(), centerX(diffText.c_str()), optStartY, diffColor);
        if (optionsCursor == 0) {
            int diffWidth, diffHeight;
            if (!getTextDimensions(diffText.c_str(), diffWidth, diffHeight)) {
                diffWidth = static_cast<int>(diffText.size()) * getCharWidth();
            }
            printText(">>", w / 2 - diffWidth / 2 - scaleY(30), optStartY, {255, 255, 0, 255});
        }
 
        std::string fxText = std::string("< Shader Effects: ") + (shaderEffectsEnabled ? "On" : "Off") + " >";
        SDL_Color fxColor = (optionsCursor == 1) ? SDL_Color{255, 255, 0, 255} : SDL_Color{255, 255, 255, 255};
        printText(fxText.c_str(), centerX(fxText.c_str()), optStartY + spacing, fxColor);
        if (optionsCursor == 1) {
            int fxWidth, fxHeight;
            if (!getTextDimensions(fxText.c_str(), fxWidth, fxHeight)) {
                fxWidth = static_cast<int>(fxText.size()) * getCharWidth();
            }
            printText(">>", w / 2 - fxWidth / 2 - scaleY(30), optStartY + spacing, {255, 255, 0, 255});
        }
 
        const char *backText = "Back";
        SDL_Color backColor = (optionsCursor == 2) ? SDL_Color{255, 255, 0, 255} : SDL_Color{255, 255, 255, 255};
        printText(backText, centerX(backText), optStartY + spacing * 2, backColor);
        if (optionsCursor == 2) {
            int backWidth, backHeight;
            if (!getTextDimensions(backText, backWidth, backHeight)) {
                backWidth = static_cast<int>(std::strlen(backText)) * getCharWidth();
            }
            printText(">>", w / 2 - backWidth / 2 - scaleY(30), optStartY + spacing * 2, {255, 255, 0, 255});
        }
 
        const char *instructions = "UP/DOWN: Select  LEFT/RIGHT: Change  ENTER: Confirm";
        printText(instructions, centerX(instructions), scaleY(350), {200, 200, 200, 255});
    }

updateScores()

void MasterPieceWindow::updateScores ( )

inline

Definition at line 553 of file acid.drop.cpp.

                        {
 
        if (scoresBackground) {
            float time_f = static_cast<float>(SDL_GetTicks()) / 1000.0f;
            scoresBackground->setShaderParams(time_f, 0.0f, 0.0f, 0.0f);
            scoresBackground->drawSpriteRect(0, 0, w, h);
        }
 
        int titleY = scaleY(40);
        int listStartY = scaleY(90);
        int lineHeight = scaleY(32);
 
        const char *title = "HIGH SCORES";
        printText(title, centerX(title), titleY, {255, 255, 0, 255});
 
        const auto &scoreList = scores.getScores();
        for (size_t i = 0; i < scoreList.size() && i < 10; ++i) {
            std::ostringstream stream;
            stream << (i + 1) << ". " << scoreList[i].name << "  " << scoreList[i].score;
            std::string scoreStr = stream.str();
 
            SDL_Color color = {255, 0, 150, 255};
 
            if (enteringName && finalScore > 0) {
 
                int rank = 0;
                for (size_t j = 0; j < scoreList.size(); ++j) {
                    if (finalScore > scoreList[j].score) {
                        rank = j;
                        break;
                    }
                    rank = j + 1;
                }
                if ((int)i == rank) {
                    color = {0, 255, 0, 255};
                }
            }
 
            printText(scoreStr.c_str(), scaleY(100), listStartY + (int)i * lineHeight, color);
        }
 
        if (enteringName) {
            int entryY = scaleY(420);
 
            std::ostringstream stream;
            stream << "Your Score: " << finalScore;
            std::string yourScore = stream.str();
            printText(yourScore.c_str(), centerX(yourScore.c_str()), entryY - lineHeight * 2, {255, 255, 0, 255});
 
            const char *prompt = "Enter your name:";
            printText(prompt, centerX(prompt), entryY - lineHeight, {255, 255, 255, 255});
 
            std::string displayName = playerName + "_";
            printText(displayName.c_str(), centerX(displayName.c_str()), entryY, {0, 255, 255, 255});
 
            const char *instructions = "Type name, ENTER to confirm, BACKSPACE to delete or Escape/Back";
            printText(instructions, centerX(instructions), entryY + lineHeight, {200, 0, 150, 255});
        } else {
            const char *returnText = "Press ENTER to return to menu";
            printText(returnText, centerX(returnText), scaleY(440), {255, 0, 0, 255});
        }
    }

updateStart()

void MasterPieceWindow::updateStart ( )

inline

Definition at line 433 of file acid.drop.cpp.

                       {
        if (startScreen) {
            float time_f = static_cast<float>(SDL_GetTicks()) / 1000.0f;
            startScreen->setShaderParams(time_f, 0.0f, 0.0f, 0.0f);
            startScreen->drawSpriteRect(0, 0, w, h);
        }
        int titleY = scaleY(100);
        int menuStartY = scaleY(180);
        int spacing = getMenuSpacing();
        const char *title = "Liquid Acid Drop";
        printText(title, centerX(title), titleY, {255, 255, 0, 255});
        const char *menuItems[] = {"New Game", "High Scores", "Options", "Credits", "Quit"};
        for (int i = 0; i < 5; i++) {
            SDL_Color col = (i == cursorPos) ? SDL_Color{255, 255, 0, 255} : SDL_Color{255, 255, 255, 255};
            printText(menuItems[i], centerX(menuItems[i]), menuStartY + i * spacing, col);
        }
        printText(">>", centerX(menuItems[cursorPos]) - scaleY(30), menuStartY + cursorPos * spacing, {255, 255, 0, 255});
    }

validationEnabled()

bool mxvk::VK_Window::validationEnabled ( ) const

nodiscardinherited

Check whether Vulkan validation layers are currently enabled.

Returns

true if validation layers are enabled, false otherwise.

Definition at line 2911 of file mxvk.cpp.

                                            {
        return validation_enabled;
    }

Member Data Documentation

active

bool mxvk::VK_Window::active = false

protectedinherited

Definition at line 516 of file mxvk.hpp.

clear_color

VkClearColorValue mxvk::VK_Window::clear_color {{0.0f, 0.0f, 0.0f, 1.0f}}

protectedinherited

Definition at line 576 of file mxvk.hpp.

{{0.0f, 0.0f, 0.0f, 1.0f}};

command_buffers

std::vector<VkCommandBuffer> mxvk::VK_Window::command_buffers {}

protectedinherited

Definition at line 505 of file mxvk.hpp.

{};

command_pool

VkCommandPool mxvk::VK_Window::command_pool = VK_NULL_HANDLE

protectedinherited

Definition at line 504 of file mxvk.hpp.

current_frame

uint32_t mxvk::VK_Window::current_frame = 0

protectedinherited

Definition at line 511 of file mxvk.hpp.

debug_messenger

VkDebugUtilsMessengerEXT mxvk::VK_Window::debug_messenger = VK_NULL_HANDLE

protectedinherited

Definition at line 482 of file mxvk.hpp.

depth_format

VkFormat mxvk::VK_Window::depth_format = VK_FORMAT_UNDEFINED

protectedinherited

Definition at line 494 of file mxvk.hpp.

depth_image_initialized

std::vector<bool> mxvk::VK_Window::depth_image_initialized {}

protectedinherited

Definition at line 502 of file mxvk.hpp.

{};

depth_image_memories

std::vector<VkDeviceMemory> mxvk::VK_Window::depth_image_memories {}

protectedinherited

Definition at line 500 of file mxvk.hpp.

{};

depth_image_views

std::vector<VkImageView> mxvk::VK_Window::depth_image_views {}

protectedinherited

Definition at line 501 of file mxvk.hpp.

{};

depth_images

std::vector<VkImage> mxvk::VK_Window::depth_images {}

protectedinherited

Definition at line 499 of file mxvk.hpp.

{};

device

VkDevice mxvk::VK_Window::device = VK_NULL_HANDLE

protectedinherited

Definition at line 485 of file mxvk.hpp.

font_configured

bool mxvk::VK_Window::font_configured = false

protectedinherited

Definition at line 567 of file mxvk.hpp.

font_path

std::string mxvk::VK_Window::font_path {}

protectedinherited

Definition at line 568 of file mxvk.hpp.

{};

font_size

int mxvk::VK_Window::font_size = 24

protectedinherited

Definition at line 569 of file mxvk.hpp.

force_swapchain_recreate

bool mxvk::VK_Window::force_swapchain_recreate = false

protectedinherited

Definition at line 534 of file mxvk.hpp.

fps_counter_enabled

bool mxvk::VK_Window::fps_counter_enabled = false

protectedinherited

Definition at line 570 of file mxvk.hpp.

fps_counter_font

Font mxvk::VK_Window::fps_counter_font {}

protectedinherited

Definition at line 572 of file mxvk.hpp.

{};

fps_counter_font_ready

bool mxvk::VK_Window::fps_counter_font_ready = false

protectedinherited

Definition at line 571 of file mxvk.hpp.

fps_counter_frame_count

uint32_t mxvk::VK_Window::fps_counter_frame_count = 0

protectedinherited

Definition at line 574 of file mxvk.hpp.

fps_counter_sample_time

std::chrono::steady_clock::time_point mxvk::VK_Window::fps_counter_sample_time {}

protectedinherited

Definition at line 573 of file mxvk.hpp.

{};

fps_counter_text

std::string mxvk::VK_Window::fps_counter_text = "FPS: --"

protectedinherited

Definition at line 575 of file mxvk.hpp.

framebuffer_resized

bool mxvk::VK_Window::framebuffer_resized = false

protectedinherited

Definition at line 533 of file mxvk.hpp.

graphics_queue

VkQueue mxvk::VK_Window::graphics_queue = VK_NULL_HANDLE

protectedinherited

Definition at line 488 of file mxvk.hpp.

graphics_queue_family

uint32_t mxvk::VK_Window::graphics_queue_family = invalid_queue_index

protectedinherited

Definition at line 486 of file mxvk.hpp.

image_available

std::array<VkSemaphore, max_frames_in_flight> mxvk::VK_Window::image_available {}

protectedinherited

Definition at line 507 of file mxvk.hpp.

{};

image_fences

std::vector<VkFence> mxvk::VK_Window::image_fences {}

protectedinherited

Definition at line 510 of file mxvk.hpp.

{};

in_flight_fences

std::array<VkFence, max_frames_in_flight> mxvk::VK_Window::in_flight_fences {}

protectedinherited

Definition at line 509 of file mxvk.hpp.

{};

instance

VkInstance mxvk::VK_Window::instance = VK_NULL_HANDLE

protectedinherited

Definition at line 481 of file mxvk.hpp.

last_memory_trim_time

std::chrono::steady_clock::time_point mxvk::VK_Window::last_memory_trim_time = std::chrono::steady_clock::now()

protectedinherited

Definition at line 537 of file mxvk.hpp.

last_presented_image_index

uint32_t mxvk::VK_Window::last_presented_image_index = invalid_queue_index

protectedinherited

Definition at line 512 of file mxvk.hpp.

last_resize_event_ms

uint64_t mxvk::VK_Window::last_resize_event_ms = 0

protectedinherited

Definition at line 535 of file mxvk.hpp.

MEMORY_TRIM_INTERVAL

std::chrono::seconds mxvk::VK_Window::MEMORY_TRIM_INTERVAL {30}

staticconstexprprotectedinherited

Definition at line 538 of file mxvk.hpp.

{30};

owned_post_process_sprite

VK_Sprite* mxvk::VK_Window::owned_post_process_sprite = nullptr

protectedinherited

Definition at line 547 of file mxvk.hpp.

owned_post_process_sprites

std::vector<VK_Sprite *> mxvk::VK_Window::owned_post_process_sprites {}

protectedinherited

Definition at line 553 of file mxvk.hpp.

{};

physical_device

VkPhysicalDevice mxvk::VK_Window::physical_device = VK_NULL_HANDLE

protectedinherited

Definition at line 484 of file mxvk.hpp.

pipeline_cache

VkPipelineCache mxvk::VK_Window::pipeline_cache = VK_NULL_HANDLE

protectedinherited

Definition at line 490 of file mxvk.hpp.

post_process_effect_params

std::vector<std::array<float, 4> > mxvk::VK_Window::post_process_effect_params {}

protectedinherited

Definition at line 554 of file mxvk.hpp.

{};

post_process_effect_start_times

std::vector<std::chrono::steady_clock::time_point> mxvk::VK_Window::post_process_effect_start_times {}

protectedinherited

Definition at line 556 of file mxvk.hpp.

{};

post_process_effect_time_enabled

std::vector<bool> mxvk::VK_Window::post_process_effect_time_enabled {}

protectedinherited

Definition at line 555 of file mxvk.hpp.

{};

post_process_enabled

bool mxvk::VK_Window::post_process_enabled = true

protectedinherited

Definition at line 548 of file mxvk.hpp.

post_process_images

std::vector<std::vector<VkImage> > mxvk::VK_Window::post_process_images {}

protectedinherited

Definition at line 557 of file mxvk.hpp.

{};

post_process_initialized

std::vector<std::vector<bool> > mxvk::VK_Window::post_process_initialized {}

protectedinherited

Definition at line 560 of file mxvk.hpp.

{};

post_process_memories

std::vector<std::vector<VkDeviceMemory> > mxvk::VK_Window::post_process_memories {}

protectedinherited

Definition at line 558 of file mxvk.hpp.

{};

post_process_params

std::array<float, 4> mxvk::VK_Window::post_process_params {}

protectedinherited

Definition at line 550 of file mxvk.hpp.

{};

post_process_sprite

VK_Sprite* mxvk::VK_Window::post_process_sprite = nullptr

protectedinherited

Definition at line 546 of file mxvk.hpp.

post_process_sprites

std::vector<VK_Sprite *> mxvk::VK_Window::post_process_sprites {}

protectedinherited

Definition at line 552 of file mxvk.hpp.

{};

post_process_start_time

std::chrono::steady_clock::time_point mxvk::VK_Window::post_process_start_time = std::chrono::steady_clock::now()

protectedinherited

Definition at line 551 of file mxvk.hpp.

post_process_time_enabled

bool mxvk::VK_Window::post_process_time_enabled = false

protectedinherited

Definition at line 549 of file mxvk.hpp.

post_process_views

std::vector<std::vector<VkImageView> > mxvk::VK_Window::post_process_views {}

protectedinherited

Definition at line 559 of file mxvk.hpp.

{};

present_mode_preference

PresentModePreference mxvk::VK_Window::present_mode_preference = PresentModePreference::LowLatency

protectedinherited

Definition at line 532 of file mxvk.hpp.

present_queue

VkQueue mxvk::VK_Window::present_queue = VK_NULL_HANDLE

protectedinherited

Definition at line 489 of file mxvk.hpp.

present_queue_family

uint32_t mxvk::VK_Window::present_queue_family = invalid_queue_index

protectedinherited

Definition at line 487 of file mxvk.hpp.

render_finished

std::vector<VkSemaphore> mxvk::VK_Window::render_finished {}

protectedinherited

Definition at line 508 of file mxvk.hpp.

{};

resize_settle_delay_ms

uint64_t mxvk::VK_Window::resize_settle_delay_ms = 150

staticconstexprprotectedinherited

Definition at line 536 of file mxvk.hpp.

retired_swapchains

std::vector<VkSwapchainKHR> mxvk::VK_Window::retired_swapchains

protectedinherited

Definition at line 577 of file mxvk.hpp.

screenshot_enabled

bool mxvk::VK_Window::screenshot_enabled = defaultEnableScreenshot()

protectedinherited

Definition at line 517 of file mxvk.hpp.

screenshot_index

uint32_t mxvk::VK_Window::screenshot_index = 0

protectedinherited

Definition at line 519 of file mxvk.hpp.

screenshot_prefix

std::string mxvk::VK_Window::screenshot_prefix = defaultExecutableName()

protectedinherited

Definition at line 518 of file mxvk.hpp.

screenshot_queue_cv

std::condition_variable mxvk::VK_Window::screenshot_queue_cv

protectedinherited

Definition at line 527 of file mxvk.hpp.

screenshot_queue_mutex

std::mutex mxvk::VK_Window::screenshot_queue_mutex

protectedinherited

Definition at line 526 of file mxvk.hpp.

screenshot_save_queue

std::deque<ScreenshotSaveTask> mxvk::VK_Window::screenshot_save_queue

protectedinherited

Definition at line 528 of file mxvk.hpp.

screenshot_worker

std::thread mxvk::VK_Window::screenshot_worker

protectedinherited

Definition at line 529 of file mxvk.hpp.

screenshot_worker_stop

bool mxvk::VK_Window::screenshot_worker_stop = false

protectedinherited

Definition at line 530 of file mxvk.hpp.

sdl_initialized

bool mxvk::VK_Window::sdl_initialized = false

protectedinherited

Definition at line 515 of file mxvk.hpp.

sprite_descriptor_set_layout

VkDescriptorSetLayout mxvk::VK_Window::sprite_descriptor_set_layout = VK_NULL_HANDLE

protectedinherited

Definition at line 542 of file mxvk.hpp.

sprite_pipeline

VkPipeline mxvk::VK_Window::sprite_pipeline = VK_NULL_HANDLE

protectedinherited

Definition at line 544 of file mxvk.hpp.

sprite_pipeline_layout

VkPipelineLayout mxvk::VK_Window::sprite_pipeline_layout = VK_NULL_HANDLE

protectedinherited

Definition at line 543 of file mxvk.hpp.

sprite_state_dirty

bool mxvk::VK_Window::sprite_state_dirty = false

protectedinherited

Definition at line 545 of file mxvk.hpp.

sprites

std::vector<std::unique_ptr<VK_Sprite> > mxvk::VK_Window::sprites {}

protectedinherited

Definition at line 540 of file mxvk.hpp.

{};

sprites3d

std::vector<std::unique_ptr<VK_Sprite3D> > mxvk::VK_Window::sprites3d {}

protectedinherited

Definition at line 541 of file mxvk.hpp.

{};

surface

VkSurfaceKHR mxvk::VK_Window::surface = VK_NULL_HANDLE

protectedinherited

Definition at line 483 of file mxvk.hpp.

swapchain

VkSwapchainKHR mxvk::VK_Window::swapchain = VK_NULL_HANDLE

protectedinherited

Definition at line 492 of file mxvk.hpp.

swapchain_extent

VkExtent2D mxvk::VK_Window::swapchain_extent {}

protectedinherited

Definition at line 495 of file mxvk.hpp.

{};

swapchain_format

VkFormat mxvk::VK_Window::swapchain_format = VK_FORMAT_UNDEFINED

protectedinherited

Definition at line 493 of file mxvk.hpp.

swapchain_image_initialized

std::vector<bool> mxvk::VK_Window::swapchain_image_initialized {}

protectedinherited

Definition at line 498 of file mxvk.hpp.

{};

swapchain_image_views

std::vector<VkImageView> mxvk::VK_Window::swapchain_image_views {}

protectedinherited

Definition at line 497 of file mxvk.hpp.

{};

swapchain_images

std::vector<VkImage> mxvk::VK_Window::swapchain_images {}

protectedinherited

Definition at line 496 of file mxvk.hpp.

{};

swapchain_supports_transfer_src

bool mxvk::VK_Window::swapchain_supports_transfer_src = false

protectedinherited

Definition at line 513 of file mxvk.hpp.

text_descriptor_set_layout

VkDescriptorSetLayout mxvk::VK_Window::text_descriptor_set_layout = VK_NULL_HANDLE

protectedinherited

Definition at line 563 of file mxvk.hpp.

text_pipeline

VkPipeline mxvk::VK_Window::text_pipeline = VK_NULL_HANDLE

protectedinherited

Definition at line 565 of file mxvk.hpp.

text_pipeline_layout

VkPipelineLayout mxvk::VK_Window::text_pipeline_layout = VK_NULL_HANDLE

protectedinherited

Definition at line 564 of file mxvk.hpp.

text_renderer

std::unique_ptr<VK_Text> mxvk::VK_Window::text_renderer {}

protectedinherited

Definition at line 562 of file mxvk.hpp.

{};

text_state_dirty

bool mxvk::VK_Window::text_state_dirty = false

protectedinherited

Definition at line 566 of file mxvk.hpp.

validation_enabled

bool mxvk::VK_Window::validation_enabled = false

protectedinherited

Definition at line 531 of file mxvk.hpp.

window

std::unique_ptr<SDL_Window, SDLWindowDeleter> mxvk::VK_Window::window {}

protectedinherited

Definition at line 480 of file mxvk.hpp.

{};

---

The documentation for this class was generated from the following file:

• examples/puzzle/acid.drop.cpp