MayaFlux 0.3.0
Digital-First Multimedia Processing Framework
Loading...
Searching...
No Matches
TextureLoom.cpp
Go to the documentation of this file.
1#include "TextureLoom.hpp"
2
3#include "MayaFlux/Core/Backends/Graphics/Vulkan/BackendResoureManager.hpp"
4#include "MayaFlux/Core/Backends/Graphics/Vulkan/VKImage.hpp"
5#include "MayaFlux/Core/Backends/Graphics/Vulkan/VulkanBackend.hpp"
6#include "MayaFlux/Journal/Archivist.hpp"
7
8namespace MayaFlux::Portal::Graphics {
9
10bool TextureLoom::s_initialized = false;
11
12bool TextureLoom::initialize(const std::shared_ptr<Core::VulkanBackend>& backend)
13{
14 if (s_initialized) {
15 MF_WARN(Journal::Component::Portal, Journal::Context::ImageProcessing,
16 "TextureLoom already initialized (static flag)");
17 return true;
18 }
19
20 if (!backend) {
21 MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
22 "Cannot initialize TextureLoom with null backend");
23 return false;
24 }
25
26 if (m_backend) {
27 MF_WARN(Journal::Component::Portal, Journal::Context::ImageProcessing,
28 "TextureLoom already initialized");
29 return true;
30 }
31
32 m_backend = backend;
33 m_resource_manager = &m_backend->get_resource_manager();
34 s_initialized = true;
35
36 MF_INFO(Journal::Component::Portal, Journal::Context::ImageProcessing,
37 "TextureLoom initialized");
38 return true;
39}
40
41void TextureLoom::shutdown()
42{
43 if (!s_initialized) {
44 return;
45 }
46
47 if (!m_backend) {
48 return;
49 }
50
51 MF_INFO(Journal::Component::Portal, Journal::Context::ImageProcessing,
52 "Shutting down TextureLoom...");
53
54 for (auto& texture : m_textures) {
55 if (texture && texture->is_initialized()) {
56 m_resource_manager->cleanup_image(texture);
57 }
58 }
59 m_textures.clear();
60 m_sampler_cache.clear();
61 m_resource_manager = nullptr;
62 m_backend = nullptr;
63
64 s_initialized = false;
65
66 MF_INFO(Journal::Component::Portal, Journal::Context::ImageProcessing,
67 "TextureLoom shutdown complete");
68}
69
70//==============================================================================
71// Texture Creation
72//==============================================================================
73
74std::shared_ptr<Core::VKImage> TextureLoom::create_2d(
75 uint32_t width, uint32_t height,
76 ImageFormat format, const void* data, uint32_t mip_levels)
77{
78 if (!is_initialized()) {
79 MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
80 "TextureLoom not initialized");
81 return nullptr;
82 }
83
84 auto vk_format = to_vulkan_format(format);
85 auto image = std::make_shared<Core::VKImage>(
86 width, height, 1, vk_format,
87 Core::VKImage::Usage::TEXTURE_2D,
88 Core::VKImage::Type::TYPE_2D,
89 mip_levels, 1,
90 Kakshya::DataModality::IMAGE_COLOR);
91
92 m_resource_manager->initialize_image(image);
93
94 if (!image->is_initialized()) {
95 MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
96 "Failed to initialize VKImage");
97 return nullptr;
98 }
99
100 if (data) {
101 size_t data_size = calculate_image_size(width, height, 1, format);
102 upload_data(image, data, data_size);
103 } else {
104 m_resource_manager->transition_image_layout(
105 image->get_image(),
106 vk::ImageLayout::eUndefined,
107 vk::ImageLayout::eShaderReadOnlyOptimal,
108 mip_levels, 1, vk::ImageAspectFlagBits::eColor);
109 image->set_current_layout(vk::ImageLayout::eShaderReadOnlyOptimal);
110 }
111
112 m_textures.push_back(image);
113 MF_INFO(Journal::Component::Portal, Journal::Context::ImageProcessing,
114 "Created 2D texture: {}x{}, format: {}, mips: {}",
115 width, height, vk::to_string(vk_format), mip_levels);
116 return image;
117}
118
119std::shared_ptr<Core::VKImage> TextureLoom::create_3d(
120 uint32_t width, uint32_t height, uint32_t depth,
121 ImageFormat format, const void* data)
122{
123 if (!is_initialized()) {
124 MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
125 "TextureLoom not initialized");
126 return nullptr;
127 }
128
129 auto vk_format = to_vulkan_format(format);
130 auto image = std::make_shared<Core::VKImage>(
131 width, height, depth, vk_format,
132 Core::VKImage::Usage::TEXTURE_2D,
133 Core::VKImage::Type::TYPE_3D,
134 1, 1, Kakshya::DataModality::VOLUMETRIC_3D);
135
136 m_resource_manager->initialize_image(image);
137
138 if (!image->is_initialized()) {
139 MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
140 "Failed to initialize 3D VKImage");
141 return nullptr;
142 }
143
144 if (data) {
145 size_t data_size = calculate_image_size(width, height, depth, format);
146 upload_data(image, data, data_size);
147 } else {
148 m_resource_manager->transition_image_layout(
149 image->get_image(),
150 vk::ImageLayout::eUndefined,
151 vk::ImageLayout::eShaderReadOnlyOptimal,
152 1, 1, vk::ImageAspectFlagBits::eColor);
153 image->set_current_layout(vk::ImageLayout::eShaderReadOnlyOptimal);
154 }
155
156 m_textures.push_back(image);
157 MF_INFO(Journal::Component::Portal, Journal::Context::ImageProcessing,
158 "Created 3D texture: {}x{}x{}, format: {}",
159 width, height, depth, vk::to_string(vk_format));
160 return image;
161}
162
163std::shared_ptr<Core::VKImage> TextureLoom::create_cubemap(
164 uint32_t size, ImageFormat format, const void* data)
165{
166 if (!is_initialized()) {
167 MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
168 "TextureLoom not initialized");
169 return nullptr;
170 }
171
172 auto vk_format = to_vulkan_format(format);
173 auto image = std::make_shared<Core::VKImage>(
174 size, size, 1, vk_format,
175 Core::VKImage::Usage::TEXTURE_2D,
176 Core::VKImage::Type::TYPE_CUBE,
177 1, 6, Kakshya::DataModality::IMAGE_COLOR);
178
179 m_resource_manager->initialize_image(image);
180
181 if (!image->is_initialized()) {
182 MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
183 "Failed to initialize cubemap VKImage");
184 return nullptr;
185 }
186
187 if (data) {
188 size_t face_size = calculate_image_size(size, size, 1, format);
189 size_t total_size = face_size * 6;
190 upload_data(image, data, total_size);
191 } else {
192 m_resource_manager->transition_image_layout(
193 image->get_image(),
194 vk::ImageLayout::eUndefined,
195 vk::ImageLayout::eShaderReadOnlyOptimal,
196 1, 6, vk::ImageAspectFlagBits::eColor);
197 image->set_current_layout(vk::ImageLayout::eShaderReadOnlyOptimal);
198 }
199
200 m_textures.push_back(image);
201 MF_INFO(Journal::Component::Portal, Journal::Context::ImageProcessing,
202 "Created cubemap: {}x{}, format: {}", size, size, vk::to_string(vk_format));
203 return image;
204}
205
206std::shared_ptr<Core::VKImage> TextureLoom::create_render_target(
207 uint32_t width, uint32_t height, ImageFormat format)
208{
209 if (!is_initialized()) {
210 MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
211 "TextureLoom not initialized");
212 return nullptr;
213 }
214
215 auto vk_format = to_vulkan_format(format);
216 auto image = std::make_shared<Core::VKImage>(
217 width, height, 1, vk_format,
218 Core::VKImage::Usage::RENDER_TARGET,
219 Core::VKImage::Type::TYPE_2D,
220 1, 1, Kakshya::DataModality::IMAGE_COLOR);
221
222 m_resource_manager->initialize_image(image);
223
224 if (!image->is_initialized()) {
225 MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
226 "Failed to initialize render target VKImage");
227 return nullptr;
228 }
229
230 m_resource_manager->transition_image_layout(
231 image->get_image(),
232 vk::ImageLayout::eUndefined,
233 vk::ImageLayout::eColorAttachmentOptimal,
234 1, 1, vk::ImageAspectFlagBits::eColor);
235 image->set_current_layout(vk::ImageLayout::eColorAttachmentOptimal);
236
237 m_textures.push_back(image);
238 MF_INFO(Journal::Component::Portal, Journal::Context::ImageProcessing,
239 "Created render target: {}x{}, format: {}",
240 width, height, vk::to_string(vk_format));
241 return image;
242}
243
244std::shared_ptr<Core::VKImage> TextureLoom::create_depth_buffer(
245 uint32_t width, uint32_t height, bool with_stencil)
246{
247 if (!is_initialized()) {
248 MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
249 "TextureLoom not initialized");
250 return nullptr;
251 }
252
253 vk::Format vk_format = with_stencil
254 ? vk::Format::eD24UnormS8Uint
255 : vk::Format::eD32Sfloat;
256
257 auto image = std::make_shared<Core::VKImage>(
258 width, height, 1, vk_format,
259 Core::VKImage::Usage::DEPTH_STENCIL,
260 Core::VKImage::Type::TYPE_2D,
261 1, 1, Kakshya::DataModality::IMAGE_2D);
262
263 m_resource_manager->initialize_image(image);
264
265 if (!image->is_initialized()) {
266 MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
267 "Failed to initialize depth buffer VKImage");
268 return nullptr;
269 }
270
271 vk::ImageAspectFlags aspect = with_stencil
272 ? (vk::ImageAspectFlagBits::eDepth | vk::ImageAspectFlagBits::eStencil)
273 : vk::ImageAspectFlagBits::eDepth;
274
275 m_resource_manager->transition_image_layout(
276 image->get_image(),
277 vk::ImageLayout::eUndefined,
278 vk::ImageLayout::eDepthStencilAttachmentOptimal,
279 1, 1, aspect);
280 image->set_current_layout(vk::ImageLayout::eDepthStencilAttachmentOptimal);
281
282 m_textures.push_back(image);
283 MF_INFO(Journal::Component::Portal, Journal::Context::ImageProcessing,
284 "Created depth buffer: {}x{}, format: {}, stencil: {}",
285 width, height, vk::to_string(vk_format), with_stencil);
286 return image;
287}
288
289std::shared_ptr<Core::VKImage> TextureLoom::create_storage_image(
290 uint32_t width, uint32_t height, ImageFormat format)
291{
292 if (!is_initialized()) {
293 MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
294 "TextureLoom not initialized");
295 return nullptr;
296 }
297
298 auto vk_format = to_vulkan_format(format);
299 auto image = std::make_shared<Core::VKImage>(
300 width, height, 1, vk_format,
301 Core::VKImage::Usage::STORAGE,
302 Core::VKImage::Type::TYPE_2D,
303 1, 1, Kakshya::DataModality::IMAGE_COLOR);
304
305 m_resource_manager->initialize_image(image);
306
307 if (!image->is_initialized()) {
308 MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
309 "Failed to initialize storage image VKImage");
310 return nullptr;
311 }
312
313 m_resource_manager->transition_image_layout(
314 image->get_image(),
315 vk::ImageLayout::eUndefined,
316 vk::ImageLayout::eGeneral,
317 1, 1, vk::ImageAspectFlagBits::eColor);
318 image->set_current_layout(vk::ImageLayout::eGeneral);
319
320 m_textures.push_back(image);
321 MF_INFO(Journal::Component::Portal, Journal::Context::ImageProcessing,
322 "Created storage image: {}x{}, format: {}",
323 width, height, vk::to_string(vk_format));
324 return image;
325}
326
327//==============================================================================
328// Data Upload/Download
329//==============================================================================
330
331void TextureLoom::upload_data(
332 const std::shared_ptr<Core::VKImage>& image, const void* data, size_t size)
333{
334 if (!is_initialized() || !image || !data) {
335 MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
336 "Invalid parameters for upload_data");
337 return;
338 }
339
340 m_resource_manager->upload_image_data(image, data, size);
341}
342
343void TextureLoom::upload_data(
344 const std::shared_ptr<Core::VKImage>& image,
345 const void* data,
346 size_t size,
347 const std::shared_ptr<Buffers::VKBuffer>& staging)
348{
349 if (!is_initialized() || !image || !data || !staging) {
350 MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
351 "Invalid parameters for upload_data_streaming");
352 return;
353 }
354
355 m_resource_manager->upload_image_data_with_staging(image, data, size, staging);
356}
357
358void TextureLoom::download_data(
359 const std::shared_ptr<Core::VKImage>& image, void* data, size_t size)
360{
361 if (!is_initialized() || !image || !data) {
362 MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
363 "Invalid parameters for download_data");
364 return;
365 }
366
367 m_resource_manager->download_image_data(image, data, size);
368}
369
370//==============================================================================
371// Sampler Management
372//==============================================================================
373
374vk::Sampler TextureLoom::get_or_create_sampler(const SamplerConfig& config)
375{
376 if (!is_initialized()) {
377 MF_ERROR(Journal::Component::Portal, Journal::Context::ImageProcessing,
378 "TextureLoom not initialized");
379 return nullptr;
380 }
381
382 size_t hash = hash_sampler_config(config);
383 auto it = m_sampler_cache.find(hash);
384 if (it != m_sampler_cache.end()) {
385 return it->second;
386 }
387
388 vk::Sampler sampler = create_sampler(config);
389 m_sampler_cache[hash] = sampler;
390 return sampler;
391}
392
393vk::Sampler TextureLoom::get_default_sampler()
394{
395 SamplerConfig config;
396 return get_or_create_sampler(config);
397}
398
408
409vk::Sampler TextureLoom::create_sampler(const SamplerConfig& config)
410{
411 return m_resource_manager->create_sampler(
412 static_cast<vk::Filter>(config.mag_filter),
413 static_cast<vk::SamplerAddressMode>(config.address_mode_u),
414 config.max_anisotropy);
415}
416
417size_t TextureLoom::hash_sampler_config(const SamplerConfig& config)
418{
419 size_t hash = 0;
420 hash ^= std::hash<int> {}(static_cast<int>(config.mag_filter)) << 0;
421 hash ^= std::hash<int> {}(static_cast<int>(config.min_filter)) << 4;
422 hash ^= std::hash<int> {}(static_cast<int>(config.address_mode_u)) << 8;
423 hash ^= std::hash<int> {}(static_cast<int>(config.address_mode_v)) << 12;
424 hash ^= std::hash<int> {}(static_cast<int>(config.address_mode_w)) << 16;
425 hash ^= std::hash<float> {}(config.max_anisotropy) << 20;
426 hash ^= std::hash<bool> {}(config.enable_mipmaps) << 24;
427 return hash;
428}
429
430//==============================================================================
431// Utilities
432//==============================================================================
433
434vk::Format TextureLoom::to_vulkan_format(ImageFormat format)
435{
436 switch (format) {
437 case ImageFormat::R8:
438 return vk::Format::eR8Unorm;
439 case ImageFormat::RG8:
440 return vk::Format::eR8G8Unorm;
441 case ImageFormat::RGB8:
442 return vk::Format::eR8G8B8Unorm;
443 case ImageFormat::RGBA8:
444 return vk::Format::eR8G8B8A8Unorm;
445 case ImageFormat::RGBA8_SRGB:
446 return vk::Format::eR8G8B8A8Srgb;
447 case ImageFormat::R16F:
448 return vk::Format::eR16Sfloat;
449 case ImageFormat::RG16F:
450 return vk::Format::eR16G16Sfloat;
451 case ImageFormat::RGBA16F:
452 return vk::Format::eR16G16B16A16Sfloat;
453 case ImageFormat::R32F:
454 return vk::Format::eR32Sfloat;
455 case ImageFormat::RG32F:
456 return vk::Format::eR32G32Sfloat;
457 case ImageFormat::RGBA32F:
458 return vk::Format::eR32G32B32A32Sfloat;
459 case ImageFormat::DEPTH16:
460 return vk::Format::eD16Unorm;
461 case ImageFormat::DEPTH24:
462 return vk::Format::eX8D24UnormPack32;
463 case ImageFormat::DEPTH32F:
464 return vk::Format::eD32Sfloat;
465 case ImageFormat::DEPTH24_STENCIL8:
466 return vk::Format::eD24UnormS8Uint;
467 default:
468 return vk::Format::eR8G8B8A8Unorm;
469 }
470}
471
472size_t TextureLoom::get_bytes_per_pixel(ImageFormat format)
473{
474 switch (format) {
475 case ImageFormat::R8:
476 return 1;
477 case ImageFormat::RG8:
478 return 2;
479 case ImageFormat::RGB8:
480 return 3;
481 case ImageFormat::RGBA8:
482 case ImageFormat::RGBA8_SRGB:
483 return 4;
484 case ImageFormat::R16F:
485 return 2;
486 case ImageFormat::RG16F:
487 return 4;
488 case ImageFormat::RGBA16F:
489 return 8;
490 case ImageFormat::R32F:
491 return 4;
492 case ImageFormat::RG32F:
493 return 8;
494 case ImageFormat::RGBA32F:
495 return 16;
496 case ImageFormat::DEPTH16:
497 return 2;
498 case ImageFormat::DEPTH24:
499 case ImageFormat::DEPTH32F:
500 case ImageFormat::DEPTH24_STENCIL8:
501 default:
502 return 4;
503 }
504}
505
506size_t TextureLoom::calculate_image_size(
507 uint32_t width, uint32_t height, uint32_t depth, ImageFormat format)
508{
509 return static_cast<size_t>(width) * height * depth * get_bytes_per_pixel(format);
510}
511
512} // namespace MayaFlux::Portal::Graphics
MF_INFO
#define MF_INFO(comp, ctx,...)
Definition Archivist.hpp:374
MF_ERROR
#define MF_ERROR(comp, ctx,...)
Definition Archivist.hpp:382
MF_WARN
#define MF_WARN(comp, ctx,...)
Definition Archivist.hpp:378
MayaFlux::Core::BackendResourceManager::cleanup_image
void cleanup_image(const std::shared_ptr< VKImage > &image)
Cleanup a VKImage (destroy view, image, and free memory)
Definition BackendResoureManager.cpp:408
MayaFlux::Core::BackendResourceManager::initialize_image
void initialize_image(const std::shared_ptr< VKImage > &image)
Initialize a VKImage (allocate VkImage, memory, and create image view)
Definition BackendResoureManager.cpp:237
MayaFlux::Core::BackendResourceManager::create_sampler
vk::Sampler create_sampler(vk::Filter filter=vk::Filter::eLinear, vk::SamplerAddressMode address_mode=vk::SamplerAddressMode::eRepeat, float max_anisotropy=0.0F)
Create sampler.
Definition BackendResoureManager.cpp:786
MayaFlux::Core::BackendResourceManager::download_image_data
void download_image_data(std::shared_ptr< VKImage > image, void *data, size_t size, vk::ImageLayout restore_layout=vk::ImageLayout::eShaderReadOnlyOptimal, vk::PipelineStageFlags restore_stage=vk::PipelineStageFlagBits::eFragmentShader)
Download data from an image into a caller-supplied buffer.
Definition BackendResoureManager.cpp:693
MayaFlux::Core::BackendResourceManager::transition_image_layout
void transition_image_layout(vk::Image image, vk::ImageLayout old_layout, vk::ImageLayout new_layout, uint32_t mip_levels=1, uint32_t array_layers=1, vk::ImageAspectFlags aspect_flags=vk::ImageAspectFlagBits::eColor)
Transition image layout using a pipeline barrier.
Definition BackendResoureManager.cpp:432
MayaFlux::Core::BackendResourceManager::upload_image_data_with_staging
void upload_image_data_with_staging(std::shared_ptr< VKImage > image, const void *data, size_t size, const std::shared_ptr< Buffers::VKBuffer > &staging)
Upload image data using a caller-supplied persistent staging buffer.
Definition BackendResoureManager.cpp:608
MayaFlux::Core::BackendResourceManager::upload_image_data
void upload_image_data(std::shared_ptr< VKImage > image, const void *data, size_t size)
Upload data to an image (creates staging buffer internally)
Definition BackendResoureManager.cpp:510
MayaFlux::Core::VKImage::Usage::RENDER_TARGET
@ RENDER_TARGET
Color attachment for rendering.
MayaFlux::Core::VKImage::Usage::STORAGE
@ STORAGE
Storage image (compute shader read/write)
MayaFlux::Core::VKImage::Usage::TEXTURE_2D
@ TEXTURE_2D
Sampled texture (shader read)
MayaFlux::Core::VKImage::Usage::DEPTH_STENCIL
@ DEPTH_STENCIL
Depth/stencil attachment.
MayaFlux::Portal::Graphics::TextureLoom::create_render_target
std::shared_ptr< Core::VKImage > create_render_target(uint32_t width, uint32_t height, ImageFormat format=ImageFormat::RGBA8)
Create a render target (color attachment)
Definition TextureLoom.cpp:206
MayaFlux::Portal::Graphics::TextureLoom::create_depth_buffer
std::shared_ptr< Core::VKImage > create_depth_buffer(uint32_t width, uint32_t height, bool with_stencil=false)
Create a depth buffer.
Definition TextureLoom.cpp:244
MayaFlux::Portal::Graphics::TextureLoom::get_bytes_per_pixel
static size_t get_bytes_per_pixel(ImageFormat format)
Get bytes per pixel for a format.
Definition TextureLoom.cpp:472
MayaFlux::Portal::Graphics::TextureLoom::get_nearest_sampler
vk::Sampler get_nearest_sampler()
Get a default nearest sampler (for pixel-perfect sampling)
Definition TextureLoom.cpp:399
MayaFlux::Portal::Graphics::TextureLoom::calculate_image_size
static size_t calculate_image_size(uint32_t width, uint32_t height, uint32_t depth, ImageFormat format)
Calculate image data size.
Definition TextureLoom.cpp:506
MayaFlux::Portal::Graphics::TextureLoom::to_vulkan_format
static vk::Format to_vulkan_format(ImageFormat format)
Convert Portal ImageFormat to Vulkan format.
Definition TextureLoom.cpp:434
MayaFlux::Portal::Graphics::TextureLoom::create_storage_image
std::shared_ptr< Core::VKImage > create_storage_image(uint32_t width, uint32_t height, ImageFormat format=ImageFormat::RGBA8)
Create a storage image (compute shader read/write)
Definition TextureLoom.cpp:289
MayaFlux::Portal::Graphics::TextureLoom::upload_data
void upload_data(const std::shared_ptr< Core::VKImage > &image, const void *data, size_t size)
Upload pixel data to an existing texture.
Definition TextureLoom.cpp:331
MayaFlux::Portal::Graphics::TextureLoom::initialize
bool initialize(const std::shared_ptr< Core::VulkanBackend > &backend)
Initialize texture manager.
Definition TextureLoom.cpp:12
MayaFlux::Portal::Graphics::TextureLoom::get_or_create_sampler
vk::Sampler get_or_create_sampler(const SamplerConfig &config)
Get or create a sampler with the given configuration.
Definition TextureLoom.cpp:374
MayaFlux::Portal::Graphics::TextureLoom::download_data
void download_data(const std::shared_ptr< Core::VKImage > &image, void *data, size_t size)
Download pixel data from a texture.
Definition TextureLoom.cpp:358
MayaFlux::Portal::Graphics::TextureLoom::m_backend
std::shared_ptr< Core::VulkanBackend > m_backend
Definition TextureLoom.hpp:297
MayaFlux::Portal::Graphics::TextureLoom::create_3d
std::shared_ptr< Core::VKImage > create_3d(uint32_t width, uint32_t height, uint32_t depth, ImageFormat format=ImageFormat::RGBA8, const void *data=nullptr)
Create a 3D texture (volumetric)
Definition TextureLoom.cpp:119
MayaFlux::Portal::Graphics::TextureLoom::create_sampler
vk::Sampler create_sampler(const SamplerConfig &config)
Definition TextureLoom.cpp:409
MayaFlux::Portal::Graphics::TextureLoom::shutdown
void shutdown()
Shutdown and cleanup all textures.
Definition TextureLoom.cpp:41
MayaFlux::Portal::Graphics::TextureLoom::m_resource_manager
Core::BackendResourceManager * m_resource_manager
Definition TextureLoom.hpp:298
MayaFlux::Portal::Graphics::TextureLoom::create_2d
std::shared_ptr< Core::VKImage > create_2d(uint32_t width, uint32_t height, ImageFormat format=ImageFormat::RGBA8, const void *data=nullptr, uint32_t mip_levels=1)
Create a 2D texture.
Definition TextureLoom.cpp:74
MayaFlux::Portal::Graphics::TextureLoom::hash_sampler_config
static size_t hash_sampler_config(const SamplerConfig &config)
Definition TextureLoom.cpp:417
MayaFlux::Portal::Graphics::TextureLoom::m_textures
std::vector< std::shared_ptr< Core::VKImage > > m_textures
Definition TextureLoom.hpp:301
MayaFlux::Portal::Graphics::TextureLoom::create_cubemap
std::shared_ptr< Core::VKImage > create_cubemap(uint32_t size, ImageFormat format=ImageFormat::RGBA8, const void *data=nullptr)
Create a cubemap texture.
Definition TextureLoom.cpp:163
MayaFlux::Portal::Graphics::TextureLoom::get_default_sampler
vk::Sampler get_default_sampler()
Get a default linear sampler (for convenience)
Definition TextureLoom.cpp:393
MayaFlux::Portal::Graphics::TextureLoom::m_sampler_cache
std::unordered_map< size_t, vk::Sampler > m_sampler_cache
Definition TextureLoom.hpp:304
MayaFlux::Portal::Graphics::TextureLoom::is_initialized
bool is_initialized() const
Check if manager is initialized.
Definition TextureLoom.hpp:106
MayaFlux::Journal::Context::ImageProcessing
@ ImageProcessing
Image processing tasks (filters, transformations)
MayaFlux::Journal::Component::Portal
@ Portal
High-level user-facing API layer.
MayaFlux::Kakshya::DataModality::VOLUMETRIC_3D
@ VOLUMETRIC_3D
3D volumetric data
MayaFlux::Kakshya::DataModality::IMAGE_COLOR
@ IMAGE_COLOR
2D RGB/RGBA image
MayaFlux::Kakshya::DataModality::IMAGE_2D
@ IMAGE_2D
2D image (grayscale or single channel)
MayaFlux::Portal::Graphics::FilterMode::NEAREST
@ NEAREST
Nearest neighbor (pixelated)
MayaFlux::Portal::Graphics::ImageFormat
ImageFormat
User-friendly image format enum.
Definition GraphicsUtils.hpp:140
MayaFlux::Portal::Graphics::ImageFormat::DEPTH24_STENCIL8
@ DEPTH24_STENCIL8
24-bit depth + 8-bit stencil
MayaFlux::Portal::Graphics::ImageFormat::RGBA32F
@ RGBA32F
Four channel 32-bit float.
MayaFlux::Portal::Graphics::ImageFormat::R16F
@ R16F
Single channel 16-bit float.
MayaFlux::Portal::Graphics::ImageFormat::RGBA16F
@ RGBA16F
Four channel 16-bit float.
MayaFlux::Portal::Graphics::ImageFormat::RG32F
@ RG32F
Two channel 32-bit float.
MayaFlux::Portal::Graphics::ImageFormat::R32F
@ R32F
Single channel 32-bit float.
MayaFlux::Portal::Graphics::ImageFormat::RG16F
@ RG16F
Two channel 16-bit float.
MayaFlux::Portal::Graphics::ImageFormat::RGBA8_SRGB
@ RGBA8_SRGB
Four channel 8-bit sRGB.