kidrigger
/
Blaze
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Blaze/Blaze/Source/ModelLoader.cpp

808 lines
30 KiB
C++
Raw Blame History

#include "ModelLoader.h"
#include <algorithm>
#include <memory_resource>
#include <string_view>
#include <DirectXMath.h>
#include <SDL3/SDL_log.h>
#include <cgltf.h>
#include <stb_image.h>
#include "EntityManager.h"
#include "Frame.h"
#include "GlobalMemory.h"
#include "MacroUtils.h"
namespace Blaze
{
std::optional<TextureID> LoadTexture(
RenderDevice* render_device, VkSampler sampler, cgltf_image const& image, bool const linear )
{
byte* data;
if ( image.buffer_view->data )
{
data = static_cast<byte*>( image.buffer_view->data );
}
else
{
data = static_cast<byte*>( image.buffer_view->buffer->data ) + image.buffer_view->offset;
}
size_t size = image.buffer_view->size;
uint32_t width;
uint32_t height;
uint32_t num_channels = 4;
stbi_uc* texture_data;
{
int w;
int h;
int nc;
int n_req_channels = static_cast<int>( num_channels );
texture_data = stbi_load_from_memory(
reinterpret_cast<stbi_uc const*>( data ), static_cast<int>( size ), &w, &h, &nc, n_req_channels );
ASSERT( nc <= n_req_channels );
if ( not texture_data )
{
return std::nullopt;
}
width = static_cast<uint32_t>( w );
height = static_cast<uint32_t>( h );
}
TextureID texture = render_device->textureManager->CreateTexture(
{ width, height, 1 }, sampler, linear ? VK_FORMAT_R8G8B8A8_UNORM : VK_FORMAT_R8G8B8A8_SRGB );
if ( not texture )
{
return std::nullopt;
}
VkImage texture_image = render_device->textureManager->FetchImage( texture ).value();
// Staging Buffer Create
VkBuffer staging_buffer;
VmaAllocation staging_allocation;
{
VkBufferCreateInfo const staging_buffer_create_info = {
.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
.pNext = nullptr,
.flags = 0,
.size = static_cast<VkDeviceSize>( width ) * height * num_channels * sizeof( texture_data[0] ),
.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
.sharingMode = VK_SHARING_MODE_EXCLUSIVE,
.queueFamilyIndexCount = 0,
.pQueueFamilyIndices = nullptr,
};
VmaAllocationCreateInfo constexpr staging_allocation_create_info = {
.flags = VMA_ALLOCATION_CREATE_MAPPED_BIT | VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT,
.usage = VMA_MEMORY_USAGE_AUTO,
.requiredFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
.preferredFlags = 0,
.memoryTypeBits = 0,
.pool = nullptr,
.pUserData = nullptr,
.priority = 1.0f,
};
VmaAllocationInfo allocation_info;
VK_CHECK( vmaCreateBuffer(
render_device->gpuAllocator,
&staging_buffer_create_info,
&staging_allocation_create_info,
&staging_buffer,
&staging_allocation,
&allocation_info ) );
if ( allocation_info.pMappedData )
{
memcpy( allocation_info.pMappedData, texture_data, staging_buffer_create_info.size );
}
}
// All data is copied to stagingBuffer, don't need this.
stbi_image_free( texture_data );
// Staging -> Texture transfer
{
Frame& frame_in_use = render_device->frames[render_device->frameIndex];
// This should just pass.
VK_CHECK( vkWaitForFences( render_device->device, 1, &frame_in_use.frameReadyToReuse, VK_TRUE, INT64_MAX ) );
// Reset Frame
VK_CHECK( vkResetFences( render_device->device, 1, &frame_in_use.frameReadyToReuse ) );
VK_CHECK( vkResetCommandPool( render_device->device, frame_in_use.commandPool, 0 ) );
VkCommandBufferBeginInfo constexpr begin_info = {
.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
.pNext = nullptr,
.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
.pInheritanceInfo = nullptr,
};
uint32_t mip_levels = TextureManager::CalculateRequiredMipLevels( width, height, 1 );
VkImageSubresourceRange const subresource_range = {
.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
.baseMipLevel = 0,
.levelCount = mip_levels,
.baseArrayLayer = 0,
.layerCount = 1,
};
VkImageMemoryBarrier2 const creation_to_transfer_image_barrier = {
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,
.pNext = nullptr,
.srcStageMask = VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT,
.srcAccessMask = VK_ACCESS_2_NONE,
.dstStageMask = VK_PIPELINE_STAGE_2_COPY_BIT,
.dstAccessMask = VK_ACCESS_2_TRANSFER_WRITE_BIT,
.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED,
.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.image = render_device->textureManager->FetchImage( texture ).value(),
.subresourceRange = subresource_range,
};
VkDependencyInfo const creation_to_transfer_dependency = {
.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
.pNext = nullptr,
.dependencyFlags = 0,
.memoryBarrierCount = 0,
.pMemoryBarriers = nullptr,
.bufferMemoryBarrierCount = 0,
.pBufferMemoryBarriers = nullptr,
.imageMemoryBarrierCount = 1,
.pImageMemoryBarriers = &creation_to_transfer_image_barrier,
};
VkImageSubresourceRange all_but_last_mip_subresource = {
.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
.baseMipLevel = 0,
.levelCount = mip_levels - 1,
.baseArrayLayer = 0,
.layerCount = 1,
};
VkImageSubresourceRange last_mip_subresource = {
.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
.baseMipLevel = mip_levels - 1,
.levelCount = 1,
.baseArrayLayer = 0,
.layerCount = 1,
};
VkImageMemoryBarrier2 transfer_to_ready_image_barriers[] = {
{
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,
.pNext = nullptr,
.srcStageMask = VK_PIPELINE_STAGE_2_TRANSFER_BIT,
.srcAccessMask = VK_ACCESS_2_TRANSFER_WRITE_BIT,
.dstStageMask = VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT,
.dstAccessMask = VK_ACCESS_2_SHADER_SAMPLED_READ_BIT,
.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.image = texture_image,
.subresourceRange = all_but_last_mip_subresource,
},
{
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,
.pNext = nullptr,
.srcStageMask = VK_PIPELINE_STAGE_2_TRANSFER_BIT,
.srcAccessMask = VK_ACCESS_2_TRANSFER_WRITE_BIT,
.dstStageMask = VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT,
.dstAccessMask = VK_ACCESS_2_SHADER_SAMPLED_READ_BIT,
.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.image = texture_image,
.subresourceRange = last_mip_subresource,
}
};
VkDependencyInfo const transfer_to_ready_dependency = {
.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
.pNext = nullptr,
.dependencyFlags = 0,
.memoryBarrierCount = 0,
.pMemoryBarriers = nullptr,
.bufferMemoryBarrierCount = 0,
.pBufferMemoryBarriers = nullptr,
.imageMemoryBarrierCount = _countof( transfer_to_ready_image_barriers ),
.pImageMemoryBarriers = transfer_to_ready_image_barriers,
};
constexpr VkImageSubresourceRange mip_level_subresource = {
.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
.baseMipLevel = 0,
.levelCount = 1,
.baseArrayLayer = 0,
.layerCount = 1,
};
VkImageMemoryBarrier2 prepare_next_mip_level_barriers[] = {
// prepareNextMipLevelSrcImageBarrier
{
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,
.pNext = nullptr,
.srcStageMask = VK_PIPELINE_STAGE_2_TRANSFER_BIT,
.srcAccessMask = VK_ACCESS_2_TRANSFER_WRITE_BIT,
.dstStageMask = VK_PIPELINE_STAGE_2_TRANSFER_BIT,
.dstAccessMask = VK_ACCESS_2_TRANSFER_READ_BIT,
.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
.newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.image = texture_image,
.subresourceRange = mip_level_subresource,
},
// prepareNextMipLevelDstImageBarrier
{
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,
.pNext = nullptr,
.srcStageMask = VK_PIPELINE_STAGE_2_COPY_BIT,
.srcAccessMask = VK_ACCESS_2_TRANSFER_WRITE_BIT,
.dstStageMask = VK_PIPELINE_STAGE_2_BLIT_BIT,
.dstAccessMask = VK_ACCESS_2_TRANSFER_WRITE_BIT,
.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED,
.newLayout = VK_IMAGE_LAYOUT_UNDEFINED,
.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.image = texture_image,
.subresourceRange = mip_level_subresource,
},
};
VkDependencyInfo const prepare_next_mip_level_dependency = {
.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
.pNext = nullptr,
.dependencyFlags = 0,
.memoryBarrierCount = 0,
.pMemoryBarriers = nullptr,
.bufferMemoryBarrierCount = 0,
.pBufferMemoryBarriers = nullptr,
.imageMemoryBarrierCount = _countof( prepare_next_mip_level_barriers ),
.pImageMemoryBarriers = prepare_next_mip_level_barriers,
};
vkBeginCommandBuffer( frame_in_use.commandBuffer, &begin_info );
{
VkImageSubresourceLayers image_subresource_layers = {
.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
.mipLevel = 0,
.baseArrayLayer = 0,
.layerCount = 1,
};
// TODO: Ensure `bufferRowLength` and `bufferImageHeight` are not required.
VkBufferImageCopy copy_region = {
.bufferOffset = 0,
.bufferRowLength = 0,
.bufferImageHeight = 0,
.imageSubresource = image_subresource_layers,
.imageOffset = {0, 0, 0},
.imageExtent = {width, height, 1}
};
// Start
vkCmdPipelineBarrier2( frame_in_use.commandBuffer, &creation_to_transfer_dependency );
// Staging -> Image L0
vkCmdCopyBufferToImage(
frame_in_use.commandBuffer,
staging_buffer,
texture_image,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
1,
&copy_region );
prepare_next_mip_level_barriers[0].subresourceRange.baseMipLevel = 0;
prepare_next_mip_level_barriers[1].subresourceRange.baseMipLevel = 1;
int32_t mip_src_width = static_cast<int32_t>( width );
int32_t mip_src_height = static_cast<int32_t>( height );
int32_t mip_dst_width = std::max( mip_src_width / 2, 1 );
int32_t mip_dst_height = std::max( mip_src_height / 2, 1 );
VkImageSubresourceLayers constexpr mip_subresource_layers = {
.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
.mipLevel = 0,
.baseArrayLayer = 0,
.layerCount = 1,
};
VkImageBlit2 image_blit = {
.sType = VK_STRUCTURE_TYPE_IMAGE_BLIT_2,
.pNext = nullptr,
.srcSubresource = mip_subresource_layers,
.srcOffsets = {{ 0, 0, 0 }, { mip_src_width, mip_src_height, 1 }},
.dstSubresource = mip_subresource_layers,
.dstOffsets = {{ 0, 0, 0 }, { mip_dst_width, mip_dst_height, 1 }},
};
image_blit.srcSubresource.mipLevel = 0;
image_blit.dstSubresource.mipLevel = 1;
image_blit.srcOffsets[1].x = mip_src_width;
image_blit.srcOffsets[1].y = mip_src_height;
image_blit.dstOffsets[1].x = mip_dst_width;
image_blit.dstOffsets[1].y = mip_dst_height;
VkBlitImageInfo2 blit_info = {
.sType = VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2,
.pNext = nullptr,
.srcImage = texture_image,
.srcImageLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
.dstImage = texture_image,
.dstImageLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
.regionCount = 1,
.pRegions = &image_blit,
.filter = VK_FILTER_LINEAR,
};
// MipMapping
for ( uint32_t dst_mip_level = 1; dst_mip_level < mip_levels; ++dst_mip_level )
{
vkCmdPipelineBarrier2( frame_in_use.commandBuffer, &prepare_next_mip_level_dependency );
vkCmdBlitImage2( frame_in_use.commandBuffer, &blit_info );
// Prep for NEXT iteration
mip_src_width = mip_dst_width;
mip_src_height = mip_dst_height;
mip_dst_width = std::max( mip_src_width / 2, 1 );
mip_dst_height = std::max( mip_src_height / 2, 1 );
image_blit.srcSubresource.mipLevel = dst_mip_level;
image_blit.dstSubresource.mipLevel = dst_mip_level + 1;
image_blit.srcOffsets[1].x = mip_src_width;
image_blit.srcOffsets[1].y = mip_src_height;
image_blit.dstOffsets[1].x = mip_dst_width;
image_blit.dstOffsets[1].y = mip_dst_height;
// Prep current mip level as source
prepare_next_mip_level_barriers[0].subresourceRange.baseMipLevel = dst_mip_level;
prepare_next_mip_level_barriers[1].subresourceRange.baseMipLevel = dst_mip_level + 1;
}
// End
vkCmdPipelineBarrier2( frame_in_use.commandBuffer, &transfer_to_ready_dependency );
}
vkEndCommandBuffer( frame_in_use.commandBuffer );
VkSubmitInfo submit_info = {
.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
.pNext = nullptr,
.waitSemaphoreCount = 0,
.pWaitSemaphores = nullptr,
.pWaitDstStageMask = nullptr,
.commandBufferCount = 1,
.pCommandBuffers = &frame_in_use.commandBuffer,
.signalSemaphoreCount = 0,
.pSignalSemaphores = nullptr,
};
VK_CHECK( vkQueueSubmit( render_device->directQueue, 1, &submit_info, frame_in_use.frameReadyToReuse ) );
// Do not reset this. Else, the frame will never be available to the main loop.
VK_CHECK( vkWaitForFences( render_device->device, 1, &frame_in_use.frameReadyToReuse, VK_TRUE, UINT64_MAX ) );
render_device->frameIndex = ( render_device->frameIndex + 1 ) % render_device->GetNumFrames();
}
vmaDestroyBuffer( render_device->gpuAllocator, staging_buffer, staging_allocation );
return texture;
}
// TODO: Cache materials while loading.
uint32_t ProcessMaterial( RenderDevice* render_device, Model* model, cgltf_material const& material )
{
ASSERT( material.has_pbr_metallic_roughness );
auto const base_color_factor = DirectX::XMFLOAT4{ material.pbr_metallic_roughness.base_color_factor };
auto const emissive_factor = DirectX::XMFLOAT4{
material.emissive_factor[0],
material.emissive_factor[1],
material.emissive_factor[2],
std::max( material.emissive_strength.emissive_strength, 1.0f ),
};
VkSampler sampler = nullptr;
TextureID base_color_texture;
TextureID normal_texture;
TextureID metal_rough_texture;
TextureID emissive_texture;
VkSamplerCreateInfo constexpr sampler_create_info = {
.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
.pNext = nullptr,
.flags = 0,
.magFilter = VK_FILTER_LINEAR,
.minFilter = VK_FILTER_LINEAR,
.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR,
.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT,
.addressModeV = VK_SAMPLER_ADDRESS_MODE_REPEAT,
.addressModeW = VK_SAMPLER_ADDRESS_MODE_REPEAT,
.mipLodBias = 0.0,
.anisotropyEnable = true,
.maxAnisotropy = 1.0f,
.compareEnable = false,
.compareOp = VK_COMPARE_OP_NEVER,
.minLod = 0.0f,
.maxLod = VK_LOD_CLAMP_NONE,
.borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK,
.unnormalizedCoordinates = false,
};
VK_CHECK( vkCreateSampler( render_device->device, &sampler_create_info, nullptr, &sampler ) );
if ( material.pbr_metallic_roughness.base_color_texture.texture )
{
cgltf_image const* base_color_image = material.pbr_metallic_roughness.base_color_texture.texture->image;
auto const base_color_texture_opt = LoadTexture( render_device, sampler, *base_color_image, false );
if ( not base_color_texture_opt )
{
vkDestroySampler( render_device->device, Take( sampler ), nullptr );
return UINT32_MAX;
}
base_color_texture = base_color_texture_opt.value();
}
if ( material.pbr_metallic_roughness.metallic_roughness_texture.texture )
{
cgltf_image const* metal_rough_image = material.pbr_metallic_roughness.metallic_roughness_texture.texture->image;
auto const metal_rough_texture_opt = LoadTexture( render_device, sampler, *metal_rough_image, true );
if ( not metal_rough_texture_opt )
{
vkDestroySampler( render_device->device, Take( sampler ), nullptr );
render_device->textureManager->FreeTexture( &base_color_texture );
return UINT32_MAX;
}
metal_rough_texture = metal_rough_texture_opt.value();
}
if ( material.normal_texture.texture )
{
cgltf_image const* normal_image = material.normal_texture.texture->image;
auto const normal_texture_opt = LoadTexture( render_device, sampler, *normal_image, true );
if ( not normal_texture_opt )
{
vkDestroySampler( render_device->device, Take( sampler ), nullptr );
render_device->textureManager->FreeTexture( &metal_rough_texture );
render_device->textureManager->FreeTexture( &base_color_texture );
return UINT32_MAX;
}
normal_texture = normal_texture_opt.value();
}
if ( material.emissive_texture.texture )
{
cgltf_image const* emissive_image = material.emissive_texture.texture->image;
auto const emissive_texture_opt = LoadTexture( render_device, sampler, *emissive_image, true );
if ( not emissive_texture_opt )
{
vkDestroySampler( render_device->device, Take( sampler ), nullptr );
render_device->textureManager->FreeTexture( &base_color_texture );
render_device->textureManager->FreeTexture( &normal_texture );
render_device->textureManager->FreeTexture( &metal_rough_texture );
return UINT32_MAX;
}
emissive_texture = emissive_texture_opt.value();
}
float const metallic = material.pbr_metallic_roughness.metallic_factor;
float const roughness = material.pbr_metallic_roughness.roughness_factor;
uint32_t const material_idx = static_cast<uint32_t>( model->materials.size() );
model->materials.push_back( {
sampler,
base_color_factor,
emissive_factor,
base_color_texture,
normal_texture,
metal_rough_texture,
emissive_texture,
roughness,
metallic,
} );
return material_idx;
}
void LoadAttribute(
std::vector<Vertex>* vertices,
int32_t const vertex_start,
std::vector<float>* scratch,
cgltf_attribute const& position_attr,
size_t const stride,
size_t const offset,
size_t const components )
{
size_t const float_count = cgltf_accessor_unpack_floats( position_attr.data, nullptr, 0 );
ASSERT( float_count % components == 0 );
scratch->resize( float_count );
cgltf_accessor_unpack_floats( position_attr.data, scratch->data(), scratch->size() );
// Guaranteed to have space for these vertices.
vertices->resize( vertex_start + float_count / components );
byte* write_ptr = reinterpret_cast<byte*>( vertices->data() + vertex_start ) + offset;
float const* read_ptr = scratch->data();
for ( size_t i = vertex_start; i < vertices->size(); ++i )
{
memcpy( write_ptr, read_ptr, components * sizeof( float ) );
read_ptr += components;
write_ptr += stride;
}
scratch->clear();
}
ModelMesh ProcessMesh(
RenderDevice* render_device,
Model* model,
std::vector<Vertex>* vertices,
std::vector<uint32_t>* indices,
cgltf_mesh const& mesh )
{
using namespace std::string_view_literals;
uint32_t const primitive_start = static_cast<uint32_t>( model->primitives.size() );
uint32_t const primitive_count = static_cast<uint32_t>( mesh.primitives_count );
cgltf_primitive const* primitives = mesh.primitives;
for ( uint32_t primitive_index = 0; primitive_index < mesh.primitives_count; ++primitive_index )
{
// VertexStart is per-primitive
int32_t const vertex_start = static_cast<int32_t>( vertices->size() );
cgltf_primitive const& primitive = primitives[primitive_index];
ASSERT( primitive.type == cgltf_primitive_type_triangles );
// Index Buffer
size_t const index_start = indices->size();
size_t const index_count = cgltf_accessor_unpack_indices( primitive.indices, nullptr, sizeof indices->at( 0 ), 0 );
ASSERT( index_count > 0 );
indices->resize( index_start + index_count );
cgltf_accessor_unpack_indices(
primitive.indices, indices->data() + index_start, sizeof indices->at( 0 ), index_count );
// Material
uint32_t material_idx = UINT32_MAX;
if ( primitive.material )
{
material_idx = ProcessMaterial( render_device, model, *primitive.material );
}
model->primitives.push_back( Primitive{
.indexStart = static_cast<uint32_t>( index_start ),
.indexCount = static_cast<uint32_t>( index_count ),
.material = material_idx,
.vertexOffset = vertex_start,
} );
std::vector<float> scratch;
cgltf_attribute const* attributes = primitive.attributes;
for ( uint32_t attrib_index = 0; attrib_index < primitive.attributes_count; ++attrib_index )
{
if ( "POSITION"sv == attributes[attrib_index].name )
{
cgltf_attribute const& position_attr = attributes[attrib_index];
ASSERT( position_attr.data->component_type == cgltf_component_type_r_32f );
ASSERT( position_attr.data->type == cgltf_type_vec3 );
size_t constexpr stride = sizeof( Vertex );
size_t constexpr offset = offsetof( Vertex, position );
size_t constexpr components = 3;
LoadAttribute( vertices, vertex_start, &scratch, position_attr, stride, offset, components );
}
if ( "NORMAL"sv == attributes[attrib_index].name )
{
cgltf_attribute const& normal_attr = attributes[attrib_index];
ASSERT( normal_attr.data->component_type == cgltf_component_type_r_32f );
ASSERT( normal_attr.data->type == cgltf_type_vec3 );
size_t constexpr stride = sizeof( Vertex );
size_t constexpr offset = offsetof( Vertex, normal );
size_t constexpr components = 3;
LoadAttribute( vertices, vertex_start, &scratch, normal_attr, stride, offset, components );
}
if ( "TANGENT"sv == attributes[attrib_index].name )
{
cgltf_attribute const& tangent_attr = attributes[attrib_index];
ASSERT( tangent_attr.data->component_type == cgltf_component_type_r_32f );
ASSERT( tangent_attr.data->type == cgltf_type_vec4 );
size_t constexpr stride = sizeof( Vertex );
size_t constexpr offset = offsetof( Vertex, tangent );
size_t constexpr components = 4;
LoadAttribute( vertices, vertex_start, &scratch, tangent_attr, stride, offset, components );
}
if ( "TEXCOORD_0"sv == attributes[attrib_index].name )
{
cgltf_attribute const& tex_coord_attr = attributes[attrib_index];
ASSERT( tex_coord_attr.data->component_type == cgltf_component_type_r_32f );
ASSERT( tex_coord_attr.data->type == cgltf_type_vec2 );
size_t constexpr stride = sizeof( Vertex );
size_t constexpr offset = offsetof( Vertex, texCoord0 );
size_t constexpr components = 2;
LoadAttribute( vertices, vertex_start, &scratch, tex_coord_attr, stride, offset, components );
}
if ( "TEXCOORD_1"sv == attributes[attrib_index].name )
{
cgltf_attribute const& tex_coord_attr = attributes[attrib_index];
ASSERT( tex_coord_attr.data->component_type == cgltf_component_type_r_32f );
ASSERT( tex_coord_attr.data->type == cgltf_type_vec2 );
size_t constexpr stride = sizeof( Vertex );
size_t constexpr offset = offsetof( Vertex, texCoord1 );
size_t constexpr components = 2;
LoadAttribute( vertices, vertex_start, &scratch, tex_coord_attr, stride, offset, components );
}
if ( "COLOR_0"sv == attributes[attrib_index].name )
{
cgltf_attribute const& color_attr = attributes[attrib_index];
ASSERT( color_attr.data->component_type == cgltf_component_type_r_32f );
size_t constexpr stride = sizeof( Vertex );
size_t constexpr offset = offsetof( Vertex, texCoord1 );
size_t components = 3;
switch ( color_attr.data->type )
{
case cgltf_type_vec3:
components = 3;
break;
case cgltf_type_vec4:
components = 4;
break;
default:
UNREACHABLE;
}
LoadAttribute( vertices, vertex_start, &scratch, color_attr, stride, offset, components );
}
// TODO: Grab other attributes.
}
}
return { primitive_start, primitive_count };
}
Entity* ProcessNode(
RenderDevice* render_device,
EntityManager* entity_manager,
Model* model,
std::vector<Vertex>* vertices,
std::vector<uint32_t>* indices,
cgltf_node const& node )
{
DirectX::XMVECTOR translation;
DirectX::XMVECTOR rotation;
DirectX::XMVECTOR scale;
if ( node.has_matrix )
{
auto const mat = DirectX::XMMATRIX{ node.matrix };
ASSERT( DirectX::XMMatrixDecompose( &scale, &rotation, &translation, mat ) );
}
else
{
translation = node.has_translation
? DirectX::XMVectorSet( node.translation[0], node.translation[1], node.translation[2], 1.0f )
: DirectX::XMVectorZero();
rotation = node.has_rotation
? DirectX::XMVectorSet( node.rotation[0], node.rotation[1], node.rotation[2], node.rotation[3] )
: DirectX::XMQuaternionIdentity();
scale = node.has_scale ? DirectX::XMVectorSet( node.scale[0], node.scale[1], node.scale[2], 1.0f )
: DirectX::XMVectorSplatOne();
}
Entity* entity = entity_manager->CreateEntity( {
.translation = translation,
.rotation = rotation,
.scale = scale,
} );
if ( node.mesh )
{
entity->modelMesh = ProcessMesh( render_device, model, vertices, indices, *node.mesh );
}
for ( uint32_t child_idx = 0; child_idx < node.children_count; ++child_idx )
{
entity->AddChild(
ProcessNode( render_device, entity_manager, model, vertices, indices, *node.children[child_idx] ) );
}
return entity;
}
Entity* LoadModel( Blaze::RenderDevice* render_device, EntityManager* entity_manager, char const* filename )
{
cgltf_data* gltf_model = nullptr;
cgltf_options options = {};
cgltf_result result = cgltf_parse_file( &options, filename, &gltf_model );
if ( result != cgltf_result_success )
{
SDL_LogError( SDL_LOG_CATEGORY_APPLICATION, "%s failed to load", filename );
cgltf_free( gltf_model );
return nullptr;
}
result = cgltf_validate( gltf_model );
if ( result != cgltf_result_success )
{
SDL_LogError( SDL_LOG_CATEGORY_APPLICATION, "%s is invalid.", filename );
cgltf_free( gltf_model );
return nullptr;
}
result = cgltf_load_buffers( &options, gltf_model, filename );
if ( result != cgltf_result_success )
{
SDL_LogError( SDL_LOG_CATEGORY_APPLICATION, "%s buffers failed to load.", filename );
cgltf_free( gltf_model );
return nullptr;
}
Entity* entity = entity_manager->CreateEntity( {
.translation = DirectX::XMVectorZero(),
.rotation = DirectX::XMQuaternionIdentity(),
.scale = DirectX::XMVectorSplatOne(),
} );
// Output data
std::vector<Vertex> vertices;
std::vector<uint32_t> indices;
cgltf_scene const* current_scene = gltf_model->scene;
for ( uint32_t node_idx = 0; node_idx < current_scene->nodes_count; ++node_idx )
{
entity->AddChild( ProcessNode(
render_device, entity_manager, &entity->model, &vertices, &indices, *current_scene->nodes[node_idx] ) );
}
entity->model.vertexBuffer = render_device->bufferManager->CreateVertexBuffer( vertices.size() * sizeof vertices[0] );
if ( not entity->model.vertexBuffer ) return nullptr;
render_device->bufferManager->WriteToBuffer( entity->model.vertexBuffer, vertices );
entity->model.indexBuffer = render_device->bufferManager->CreateIndexBuffer( indices.size() * sizeof indices[0] );
if ( not entity->model.indexBuffer ) return nullptr;
render_device->bufferManager->WriteToBuffer( entity->model.indexBuffer, std::span{ indices } );
cgltf_free( gltf_model );
return entity;
}
} // namespace Blaze
Reference in New Issue View Git Blame Copy Permalink