mxvk::VKAbstractModel Class Reference

Convenience wrapper that owns mesh, textures, descriptors, and pipeline state. More...

#include <mxvk/include/mxvk/mxvk_abstract_model.hpp>

Public Member Functions
void	cleanup (VK_Window *window)
	Destroy all owned Vulkan resources.
void	enableExtendedFragmentUniforms ()
	Use binding 1 for fragment uniforms and binding 2 for model transforms.
bool	isLoaded () const
	True once the model has been uploaded to GPU buffers.
void	load (VK_Window *window, const std::string &modelPath, const std::string &textureManifestPath, const std::string &textureBasePath, float scale=1.0f)
	Load mesh/texture resources and build Vulkan state.
void	load (VK_Window *window, MXModel &&model, const std::string &textureManifestPath, const std::string &textureBasePath, float scale=1.0f)
	Consume pre-parsed mesh data and build Vulkan state.
const MXModel &	model () const
	Access the underlying mesh object.
glm::vec3	modelAxisExtent () const
	Per-axis extent (max - min) of the source mesh's bounding box.
glm::vec3	modelCenterOffset () const
	Access the computed center offset used for normalization.
float	modelRenderScale () const
	Access the computed render scale used for normalization.
VKAbstractModel &	operator= (const VKAbstractModel &)=delete
VKAbstractModel &	operator= (VKAbstractModel &&)=delete
void	render (VkCommandBuffer cmd, uint32_t imageIndex, bool wireframe=false) const
	Record draw commands for this model.
void	renderWithExternalTexture (VkCommandBuffer cmd, uint32_t imageIndex, VkImageView textureView, const UniformBufferObject &ubo, bool wireframe=false)
	Render using a non-owning shader-readable image view as texture slot zero.
void	renderWithPushConstants (VkCommandBuffer cmd, uint32_t imageIndex, size_t textureIndex, const UniformBufferObject &ubo, bool wireframe=false)
	Record one draw using push constants for per-draw transforms and an explicit texture slot.
void	resize (VK_Window *window)
	Rebuild swapchain-dependent resources after resize.
void	setAlphaBlending (bool enabled)
	Enable or disable alpha blending for this model pipeline.
void	setBackfaceCulling (bool enabled)
	Enable or disable backface culling for this model pipeline.
void	setColorAttachmentFormat (VkFormat format)
	Override the dynamic-rendering color format for this model.
void	setFragmentPushConstants (const ModelFragmentPushConstants &constants)
	Set sprite-compatible push constants used by custom fragment shaders.
void	setShaders (VK_Window *window, const std::string &vertSpv, const std::string &fragSpv)
	Configure custom shader paths and rebuild pipelines.
void	updateFragmentUBO (uint32_t imageIndex, const ModelFragmentUniforms &uniforms)
	Update extended fragment uniforms for one swapchain image.
bool	updatePrimaryTexture (const void *pixels, int width, int height, int pitch=0)
	Upload raw RGBA pixels into the primary model texture.
void	updateUBO (uint32_t imageIndex, const UniformBufferObject &ubo)
	Update one per-frame UBO payload.
	VKAbstractModel ()=default
	VKAbstractModel (const VKAbstractModel &)=delete
	VKAbstractModel (VKAbstractModel &&)=delete
	~VKAbstractModel ()=default

Detailed Description

Convenience wrapper that owns mesh, textures, descriptors, and pipeline state.

This class is intended to be recorded from inside VK_Window::onRecordCustomRendering() so it participates in the same dynamic-rendering pass as sprites/text.

Definition at line 71 of file mxvk_abstract_model.hpp.

Constructor & Destructor Documentation

VKAbstractModel() [1/3]

mxvk::VKAbstractModel::VKAbstractModel ( )

default

~VKAbstractModel()

mxvk::VKAbstractModel::~VKAbstractModel ( )

default

VKAbstractModel() [2/3]

mxvk::VKAbstractModel::VKAbstractModel ( const VKAbstractModel & )

delete

VKAbstractModel() [3/3]

mxvk::VKAbstractModel::VKAbstractModel ( VKAbstractModel && )

delete

Member Function Documentation

cleanup()

void mxvk::VKAbstractModel::cleanup

(

VK_Window *

window

)

Destroy all owned Vulkan resources.

Parameters

window

Active MXVK window.

Definition at line 455 of file mxvk_abstract_model.cpp.

                                                         {
        if (targetWindow == nullptr || targetWindow->getDevice() == VK_NULL_HANDLE) {
            return;
        }
 
        logVKAbstractModelStep("teardown begin", true);
        windowPtr = targetWindow;
        destroyPipelines();
        destroyDescriptors();
        destroyTextures();
        obj.cleanup(windowPtr->getDevice());
        windowPtr = nullptr;
        logVKAbstractModelStep("teardown complete", true);
    }

enableExtendedFragmentUniforms()

void mxvk::VKAbstractModel::enableExtendedFragmentUniforms

(

)

Use binding 1 for fragment uniforms and binding 2 for model transforms.

Call before load().

Definition at line 215 of file mxvk_abstract_model.cpp.

                                                         {
        if (windowPtr != nullptr) {
            throw mxvk::Exception("VKAbstractModel::enableExtendedFragmentUniforms must be called before load");
        }
        extendedFragmentUniformsEnabled = true;
    }

isLoaded()

bool mxvk::VKAbstractModel::isLoaded ( ) const

inlinenodiscard

True once the model has been uploaded to GPU buffers.

Definition at line 187 of file mxvk_abstract_model.hpp.

{ return obj.indexCount() > 0 && vertexBufferReady(); }

load() [1/2]

void mxvk::VKAbstractModel::load	(	VK_Window *	window,
		const std::string &	modelPath,
		const std::string &	textureManifestPath,
		const std::string &	textureBasePath,
		float	scale = 1.0f )

Load mesh/texture resources and build Vulkan state.

Parameters

window	Active MXVK window.
modelPath	Path to .obj or .mxmod mesh file.
textureManifestPath	Optional texture manifest path (.tex or .mtl-like text).
textureBasePath	Optional base path for texture files in the manifest.
scale	Uniform mesh scale.

Definition at line 80 of file mxvk_abstract_model.cpp.

                                                                                                                                                                       {
        if (targetWindow == nullptr) {
            throw mxvk::Exception("VKAbstractModel::load requires a valid window");
        }
        if (modelPath.empty()) {
            throw mxvk::Exception("VKAbstractModel::load modelPath is empty");
        }
 
        logVKAbstractModelStep("creation begin: " + modelPath, true);
 
        windowPtr = targetWindow;
        if (!windowPtr->ensureRenderResources()) {
            throw mxvk::Exception("VKAbstractModel::load failed because render resources are not ready");
        }
 
        obj.load(modelPath, scale);
        obj.upload(windowPtr->getDevice(), windowPtr->getPhysicalDevice(), windowPtr->getCommandPool(), windowPtr->getGraphicsQueue());
        computeBoundsAndScale();
        logVKAbstractModelStep("mesh upload complete", true);
 
        textures.clear();
        if (!textureManifestPath.empty()) {
            loadTextures(textureManifestPath, textureBasePath);
        } else {
            loadTexturesFromMTL(textureBasePath.empty() ? std::filesystem::path(modelPath).parent_path().string() : textureBasePath);
        }
        if (textures.empty()) {
            createFallbackTexture();
            logVKAbstractModelStep("using fallback texture", true);
        }
        logVKAbstractModelStep("textures ready: " + std::to_string(textures.size()), true);
 
        createTextureSampler();
        createDescriptorSetLayout();
        createUniformBuffers();
        createDescriptorPool();
        createDescriptorSets();
        createPipelines();
        logVKAbstractModelStep("creation complete", true);
    }

load() [2/2]

void mxvk::VKAbstractModel::load	(	VK_Window *	window,
		MXModel &&	model,
		const std::string &	textureManifestPath,
		const std::string &	textureBasePath,
		float	scale = 1.0f )

Consume pre-parsed mesh data and build Vulkan state.

Parameters

window	Active MXVK window.
model	Pre-parsed CPU-side model data.
textureManifestPath	Optional texture manifest path (.tex or .mtl-like text).
textureBasePath	Optional base path for texture files in the manifest.
scale	Uniform mesh scale. Kept for API compatibility.

Definition at line 121 of file mxvk_abstract_model.cpp.

                                                                                                                                                                             {
        if (targetWindow == nullptr) {
            throw mxvk::Exception("VKAbstractModel::load requires a valid window");
        }
 
        windowPtr = targetWindow;
        if (!windowPtr->ensureRenderResources()) {
            throw mxvk::Exception("VKAbstractModel::load failed because render resources are not ready");
        }
 
        obj = std::move(model);
        obj.upload(windowPtr->getDevice(), windowPtr->getPhysicalDevice(), windowPtr->getCommandPool(), windowPtr->getGraphicsQueue());
        computeBoundsAndScale();
        logVKAbstractModelStep("mesh upload complete (prepared)", true);
 
        textures.clear();
        if (!textureManifestPath.empty()) {
            loadTextures(textureManifestPath, textureBasePath);
        } else if (!obj.mtlLibPath().empty()) {
            loadTexturesFromMTL(textureBasePath.empty() ? std::filesystem::path(obj.mtlLibPath()).parent_path().string() : textureBasePath);
        } else {
            createFallbackTexture();
            logVKAbstractModelStep("using fallback texture", true);
        }
        if (textures.empty()) {
            createFallbackTexture();
            logVKAbstractModelStep("using fallback texture", true);
        }
        logVKAbstractModelStep("textures ready: " + std::to_string(textures.size()), true);
 
        createTextureSampler();
        createDescriptorSetLayout();
        createUniformBuffers();
        createDescriptorPool();
        createDescriptorSets();
        createPipelines();
        logVKAbstractModelStep("creation complete", true);
    }

model()

const MXModel & mxvk::VKAbstractModel::model ( ) const

inlinenodiscard

Access the underlying mesh object.

Definition at line 179 of file mxvk_abstract_model.hpp.

{ return obj; }

modelAxisExtent()

glm::vec3 mxvk::VKAbstractModel::modelAxisExtent ( ) const

inlinenodiscard

Per-axis extent (max - min) of the source mesh's bounding box.

Definition at line 185 of file mxvk_abstract_model.hpp.

{ return modelAxisExtentValue; }

modelCenterOffset()

glm::vec3 mxvk::VKAbstractModel::modelCenterOffset ( ) const

inlinenodiscard

Access the computed center offset used for normalization.

Definition at line 181 of file mxvk_abstract_model.hpp.

{ return modelCenterOffsetValue; }

modelRenderScale()

float mxvk::VKAbstractModel::modelRenderScale ( ) const

inlinenodiscard

Access the computed render scale used for normalization.

Definition at line 183 of file mxvk_abstract_model.hpp.

{ return modelRenderScaleValue; }

operator=() [1/2]

VKAbstractModel & mxvk::VKAbstractModel::operator= ( const VKAbstractModel & )

delete

operator=() [2/2]

VKAbstractModel & mxvk::VKAbstractModel::operator= ( VKAbstractModel && )

delete

render()

void mxvk::VKAbstractModel::render	(	VkCommandBuffer	cmd,
		uint32_t	imageIndex,
		bool	wireframe = false ) const

Record draw commands for this model.

Parameters

cmd	Active command buffer, inside a dynamic rendering scope.
imageIndex	Current swapchain image index.
wireframe	Render using the optional wireframe pipeline when available.

Definition at line 336 of file mxvk_abstract_model.cpp.

                                                                                               {
        if (cmd == VK_NULL_HANDLE || imageIndex >= uniformBuffers.size() || descriptorSets.empty()) {
            return;
        }
 
        const VkPipeline pipeline = (wireframe && pipelineWireframe != VK_NULL_HANDLE) ? pipelineWireframe : pipelineFill;
        if (pipeline == VK_NULL_HANDLE || pipelineLayout == VK_NULL_HANDLE) {
            return;
        }
 
        vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
        if (extendedFragmentUniformsEnabled) {
            vkCmdPushConstants(cmd, pipelineLayout, VK_SHADER_STAGE_FRAGMENT_BIT, 0, sizeof(ModelFragmentPushConstants), &fragmentPushConstants);
        }
 
        const size_t textureCount = std::max<size_t>(1, textures.size());
        for (size_t i = 0; i < obj.subMeshCount(); ++i) {
            const SubMesh &submesh = obj.subMesh(i);
            const size_t textureIndex = std::min<size_t>(submesh.textureIndex, textureCount - 1U);
            const size_t setIndex = static_cast<size_t>(imageIndex) * textureCount + textureIndex;
            if (setIndex >= descriptorSets.size()) {
                continue;
            }
 
            vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1, &descriptorSets[setIndex], 0, nullptr);
 
            obj.drawSubMesh(cmd, i);
        }
    }

renderWithExternalTexture()

void mxvk::VKAbstractModel::renderWithExternalTexture	(	VkCommandBuffer	cmd,
		uint32_t	imageIndex,
		VkImageView	textureView,
		const UniformBufferObject &	ubo,
		bool	wireframe = false )

Render using a non-owning shader-readable image view as texture slot zero.

Definition at line 401 of file mxvk_abstract_model.cpp.

                                                                                                                                                                     {
        if (cmd == VK_NULL_HANDLE || textureView == VK_NULL_HANDLE || imageIndex >= uniformBuffers.size() || descriptorSets.empty()) {
            return;
        }
 
        const VkPipeline pipeline = (wireframe && pipelineWireframe != VK_NULL_HANDLE) ? pipelineWireframe : pipelineFill;
        if (pipeline == VK_NULL_HANDLE || pipelineLayout == VK_NULL_HANDLE) {
            return;
        }
 
        const size_t textureCount = std::max<size_t>(1, textures.size());
        const size_t setIndex = static_cast<size_t>(imageIndex) * textureCount;
        if (setIndex >= descriptorSets.size()) {
            return;
        }
        updateTextureDescriptor(descriptorSets[setIndex], textureView);
 
        vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
        updateUBO(imageIndex, ubo);
        if (!extendedFragmentUniformsEnabled) {
            const ModelPushConstants pushConstants{
                .model = ubo.model,
                .fx = ubo.fx,
            };
            vkCmdPushConstants(cmd, pipelineLayout, VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(ModelPushConstants), &pushConstants);
        }
        if (extendedFragmentUniformsEnabled) {
            vkCmdPushConstants(cmd, pipelineLayout, VK_SHADER_STAGE_FRAGMENT_BIT, 0, sizeof(ModelFragmentPushConstants), &fragmentPushConstants);
        }
        vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1, &descriptorSets[setIndex], 0, nullptr);
        obj.draw(cmd);
    }

renderWithPushConstants()

void mxvk::VKAbstractModel::renderWithPushConstants	(	VkCommandBuffer	cmd,
		uint32_t	imageIndex,
		size_t	textureIndex,
		const UniformBufferObject &	ubo,
		bool	wireframe = false )

Record one draw using push constants for per-draw transforms and an explicit texture slot.

Parameters

cmd	Active command buffer, inside a dynamic rendering scope.
imageIndex	Current swapchain image index.
textureIndex	Texture slot to bind for all submeshes in this draw.
ubo	Transform/effect payload copied into vertex-stage push constants.
wireframe	Render using the optional wireframe pipeline when available.

Definition at line 366 of file mxvk_abstract_model.cpp.

                                                                                                                                                               {
        if (cmd == VK_NULL_HANDLE || imageIndex >= uniformBuffers.size() || descriptorSets.empty()) {
            return;
        }
 
        const VkPipeline pipeline = (wireframe && pipelineWireframe != VK_NULL_HANDLE) ? pipelineWireframe : pipelineFill;
        if (pipeline == VK_NULL_HANDLE || pipelineLayout == VK_NULL_HANDLE) {
            return;
        }
 
        const size_t textureCount = std::max<size_t>(1, textures.size());
        textureIndex = std::min(textureIndex, textureCount - 1U);
        const size_t setIndex = static_cast<size_t>(imageIndex) * textureCount + textureIndex;
        if (setIndex >= descriptorSets.size()) {
            return;
        }
        updateTextureDescriptor(descriptorSets[setIndex], textures[textureIndex].view);
 
        vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
        updateUBO(imageIndex, ubo);
        if (!extendedFragmentUniformsEnabled) {
            const ModelPushConstants pushConstants{
                .model = ubo.model,
                .fx = ubo.fx,
            };
            vkCmdPushConstants(cmd, pipelineLayout, VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(ModelPushConstants), &pushConstants);
        }
        if (extendedFragmentUniformsEnabled) {
            vkCmdPushConstants(cmd, pipelineLayout, VK_SHADER_STAGE_FRAGMENT_BIT, 0, sizeof(ModelFragmentPushConstants), &fragmentPushConstants);
        }
        vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1, &descriptorSets[setIndex], 0, nullptr);
 
        obj.draw(cmd);
    }

resize()

void mxvk::VKAbstractModel::resize

(

VK_Window *

window

)

Rebuild swapchain-dependent resources after resize.

Parameters

window

Active MXVK window.

Definition at line 434 of file mxvk_abstract_model.cpp.

                                                        {
        if (targetWindow == nullptr || targetWindow->getDevice() == VK_NULL_HANDLE) {
            return;
        }
        if (!isLoaded()) {
            return;
        }
 
        logVKAbstractModelStep("resize begin", true);
        windowPtr = targetWindow;
        destroyPipelines();
        destroyDescriptors();
 
        createDescriptorSetLayout();
        createUniformBuffers();
        createDescriptorPool();
        createDescriptorSets();
        createPipelines();
        logVKAbstractModelStep("resize complete", true);
    }

setAlphaBlending()

void mxvk::VKAbstractModel::setAlphaBlending

(

bool

enabled

)

Enable or disable alpha blending for this model pipeline.

Parameters

enabled

True to blend fragment alpha and avoid depth writes.

Definition at line 183 of file mxvk_abstract_model.cpp.

                                                       {
        if (alphaBlendingEnabled == enabled) {
            return;
        }
 
        alphaBlendingEnabled = enabled;
        if (windowPtr != nullptr) {
            createPipelines();
        }
    }

setBackfaceCulling()

void mxvk::VKAbstractModel::setBackfaceCulling

(

bool

enabled

)

Enable or disable backface culling for this model pipeline.

Parameters

enabled

True to cull backfaces, false to disable culling.

Definition at line 172 of file mxvk_abstract_model.cpp.

                                                         {
        if (backfaceCullingEnabled == enabled) {
            return;
        }
 
        backfaceCullingEnabled = enabled;
        if (windowPtr != nullptr) {
            createPipelines();
        }
    }

setColorAttachmentFormat()

void mxvk::VKAbstractModel::setColorAttachmentFormat

(

VkFormat

format

)

Override the dynamic-rendering color format for this model.

Definition at line 194 of file mxvk_abstract_model.cpp.

                                                                  {
        if (colorAttachmentFormat == format) {
            return;
        }
        colorAttachmentFormat = format;
        if (windowPtr != nullptr) {
            createPipelines();
        }
    }

setFragmentPushConstants()

void mxvk::VKAbstractModel::setFragmentPushConstants

(

const ModelFragmentPushConstants &

constants

)

Set sprite-compatible push constants used by custom fragment shaders.

Definition at line 229 of file mxvk_abstract_model.cpp.

{ fragmentPushConstants = constants; }

setShaders()

void mxvk::VKAbstractModel::setShaders	(	VK_Window *	window,
		const std::string &	vertSpv,
		const std::string &	fragSpv )

Configure custom shader paths and rebuild pipelines.

Parameters

window	Active MXVK window.
vertSpv	Vertex shader SPIR-V path.
fragSpv	Fragment shader SPIR-V path.

Definition at line 160 of file mxvk_abstract_model.cpp.

                                                                                                                {
        if (targetWindow == nullptr) {
            throw mxvk::Exception("VKAbstractModel::setShaders requires a valid window");
        }
 
        windowPtr = targetWindow;
        vertexShaderPath = vertSpv;
        fragmentShaderPath = fragSpv;
        logVKAbstractModelStep("setShaders", true);
        createPipelines();
    }

updateFragmentUBO()

void mxvk::VKAbstractModel::updateFragmentUBO	(	uint32_t	imageIndex,
		const ModelFragmentUniforms &	uniforms )

Update extended fragment uniforms for one swapchain image.

Definition at line 222 of file mxvk_abstract_model.cpp.

                                                                                                      {
        if (imageIndex >= fragmentUniformBuffersMapped.size() || fragmentUniformBuffersMapped[imageIndex] == nullptr) {
            return;
        }
        std::memcpy(fragmentUniformBuffersMapped[imageIndex], &uniforms, sizeof(ModelFragmentUniforms));
    }

updatePrimaryTexture()

bool mxvk::VKAbstractModel::updatePrimaryTexture ( const void * pixels, int width, int height, int pitch = 0 )

nodiscard

Upload raw RGBA pixels into the primary model texture.

Parameters

pixels	Pointer to RGBA8 pixel data.
width	Texture width in pixels.
height	Texture height in pixels.
pitch	Bytes per input row. When 0, defaults to width * 4.

Returns

True when the upload succeeds, false for invalid inputs or unavailable resources.

Definition at line 231 of file mxvk_abstract_model.cpp.

                                                                                                   {
        if (windowPtr == nullptr || windowPtr->getDevice() == VK_NULL_HANDLE) {
            return false;
        }
        if (pixels == nullptr || width <= 0 || height <= 0) {
            return false;
        }
 
        const uint32_t uploadWidth = static_cast<uint32_t>(width);
        const uint32_t uploadHeight = static_cast<uint32_t>(height);
        const uint32_t srcRowBytes = static_cast<uint32_t>(pitch > 0 ? pitch : width * 4);
        const uint32_t tightRowBytes = uploadWidth * 4U;
        if (srcRowBytes < tightRowBytes) {
            return false;
        }
 
        if (textures.empty()) {
            createFallbackTexture();
            createDescriptorSets();
        }
 
        TextureEntry &texture = textures[0];
        if (texture.image == VK_NULL_HANDLE || texture.memory == VK_NULL_HANDLE || texture.view == VK_NULL_HANDLE) {
            return false;
        }
 
        bool recreatedTexture = false;
        if (texture.width != uploadWidth || texture.height != uploadHeight) {
            vkDeviceWaitIdle(windowPtr->getDevice());
 
#ifdef MXVK_CUDA
            destroyTextureCudaInterop(texture);
#endif
            if (texture.view != VK_NULL_HANDLE) {
                vkDestroyImageView(windowPtr->getDevice(), texture.view, nullptr);
            }
            if (texture.image != VK_NULL_HANDLE) {
                vkDestroyImage(windowPtr->getDevice(), texture.image, nullptr);
            }
            if (texture.memory != VK_NULL_HANDLE) {
                vkFreeMemory(windowPtr->getDevice(), texture.memory, nullptr);
            }
 
            texture.view = VK_NULL_HANDLE;
            texture.image = VK_NULL_HANDLE;
            texture.memory = VK_NULL_HANDLE;
 
            createTextureImage(uploadWidth, uploadHeight, texture);
 
            texture.view = createImageView(texture.image, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_ASPECT_COLOR_BIT);
            texture.width = uploadWidth;
            texture.height = uploadHeight;
            recreatedTexture = true;
 
            createDescriptorSets();
        }
 
#ifdef MXVK_CUDA
        if (updatePrimaryTextureCudaHost(texture, pixels, uploadWidth, uploadHeight, srcRowBytes)) {
            return true;
        }
#endif
 
        const VkDeviceSize stagingSize = static_cast<VkDeviceSize>(tightRowBytes) * uploadHeight;
        VkBuffer stagingBuffer = VK_NULL_HANDLE;
        VkDeviceMemory stagingMemory = VK_NULL_HANDLE;
        createBuffer(stagingSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, stagingBuffer, stagingMemory);
 
        void *mapped = nullptr;
        const VkResult mapResult = vkMapMemory(windowPtr->getDevice(), stagingMemory, 0, stagingSize, 0, &mapped);
        if (mapResult != VK_SUCCESS || mapped == nullptr) {
            vkDestroyBuffer(windowPtr->getDevice(), stagingBuffer, nullptr);
            vkFreeMemory(windowPtr->getDevice(), stagingMemory, nullptr);
            return false;
        }
 
        if (srcRowBytes == tightRowBytes) {
            std::memcpy(mapped, pixels, static_cast<size_t>(stagingSize));
        } else {
            const auto *src = static_cast<const uint8_t *>(pixels);
            auto *dst = static_cast<uint8_t *>(mapped);
            for (uint32_t y = 0; y < uploadHeight; ++y) {
                const size_t srcOffset = static_cast<size_t>(y) * srcRowBytes;
                const size_t dstOffset = static_cast<size_t>(y) * tightRowBytes;
                std::memcpy(dst + dstOffset, src + srcOffset, tightRowBytes);
            }
        }
        vkUnmapMemory(windowPtr->getDevice(), stagingMemory);
 
        if (recreatedTexture) {
            transitionImageLayout(texture.image, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
        } else {
            transitionImageLayout(texture.image, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
        }
        copyBufferToImage(stagingBuffer, texture.image, uploadWidth, uploadHeight);
        transitionImageLayout(texture.image, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
#ifdef MXVK_CUDA
        texture.cudaImageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
#endif
 
        vkDestroyBuffer(windowPtr->getDevice(), stagingBuffer, nullptr);
        vkFreeMemory(windowPtr->getDevice(), stagingMemory, nullptr);
        return true;
    }

updateUBO()

void mxvk::VKAbstractModel::updateUBO	(	uint32_t	imageIndex,
		const UniformBufferObject &	ubo )

Update one per-frame UBO payload.

Parameters

imageIndex	Swapchain image index.
ubo	New transform values.

Definition at line 204 of file mxvk_abstract_model.cpp.

                                                                                       {
        if (imageIndex >= uniformBuffersMapped.size()) {
            return;
        }
        if (uniformBuffersMapped[imageIndex] == nullptr) {
            return;
        }
 
        std::memcpy(uniformBuffersMapped[imageIndex], &ubo, sizeof(UniformBufferObject));
    }

---

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

• mxvk/include/mxvk/mxvk_abstract_model.hpp
• mxvk/src/mxvk_abstract_model.cpp