#include "vkpt.h"
#include "shader/vertex_buffer.h"
#include <float.h>

Functions
static void	create_render_pass ()

VkResult	vkpt_shadow_map_initialize ()

VkResult	vkpt_shadow_map_destroy ()

VkImageView	vkpt_shadow_map_get_view ()

VkResult	vkpt_shadow_map_create_pipelines ()

VkResult	vkpt_shadow_map_destroy_pipelines ()

VkResult	vkpt_shadow_map_render (VkCommandBuffer cmd_buf, float *view_projection_matrix, int num_static_verts, int num_dynamic_verts, int transparent_offset, int num_transparent_verts)

static void	sample_disk (float u, float v)

void	vkpt_shadow_map_setup (const sun_light_t light, const float bbox_min, const float bbox_max, float VP, float *depth_scale, qboolean random_sampling)

Variables
VkPipelineLayout	pipeline_layout_smap

VkRenderPass	render_pass_smap

VkPipeline	pipeline_smap

static VkFramebuffer	framebuffer_smap

static VkFramebuffer	framebuffer_smap2

static VkImage	img_smap

static VkImageView	imv_smap_depth

static VkImageView	imv_smap_depth2

static VkImageView	imv_smap_depth_array

static VkDeviceMemory	mem_smap

Function Documentation

◆ create_render_pass()

static void create_render_pass ( )

static

Definition at line 36 of file shadow_map.c.

 {
     LOG_FUNC();
     VkAttachmentDescription depth_attachment = {
         .format         = VK_FORMAT_D32_SFLOAT,
         .samples        = VK_SAMPLE_COUNT_1_BIT,
         .loadOp         = VK_ATTACHMENT_LOAD_OP_CLEAR,
         .storeOp        = VK_ATTACHMENT_STORE_OP_STORE,
         .stencilLoadOp  = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
         .stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
         .initialLayout  = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
         .finalLayout    = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
     };
  
     VkAttachmentReference depth_attachment_ref = {
         .attachment = 0, /* index in fragment shader */
         .layout     = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR,
     };
  
     VkSubpassDescription subpass = {
         .pipelineBindPoint    = VK_PIPELINE_BIND_POINT_GRAPHICS,
         .pDepthStencilAttachment = &depth_attachment_ref,
     };
  
     VkSubpassDependency dependencies[] = {
         {
             .srcSubpass    = VK_SUBPASS_EXTERNAL,
             .dstSubpass    = 0, /* index for own subpass */
             .srcStageMask  = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
             .srcAccessMask = 0, /* XXX verify */
             .dstStageMask  = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
             .dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT
                            | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
         },
     };
  
     VkRenderPassCreateInfo render_pass_info = {
         .sType           = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
         .attachmentCount = 1,
         .pAttachments    = &depth_attachment,
         .subpassCount    = 1,
         .pSubpasses      = &subpass,
         .dependencyCount = LENGTH(dependencies),
         .pDependencies   = dependencies,
     };
  
     _VK(vkCreateRenderPass(qvk.device, &render_pass_info, NULL, &render_pass_smap));
     ATTACH_LABEL_VARIABLE(render_pass_smap, RENDER_PASS);
 }

Referenced by vkpt_shadow_map_initialize().

◆ sample_disk()

static void sample_disk	(	float *	u,
		float *	v
	)

static

Definition at line 448 of file shadow_map.c.

 {
     float a = frand();
     float b = frand();
  
     float theta = 2.0 * M_PI * a;
     float r = sqrt(b);
  
     *u = r * cos(theta);
     *v = r * sin(theta);
 }

Referenced by get_sunlight(), sample_spherical_lights(), and vkpt_shadow_map_setup().

◆ vkpt_shadow_map_create_pipelines()

VkResult vkpt_shadow_map_create_pipelines ( )

Definition at line 209 of file shadow_map.c.

 {
     LOG_FUNC();
  
     VkPipelineShaderStageCreateInfo shader_info[] = {
         SHADER_STAGE(QVK_MOD_SHADOW_MAP_VERT, VK_SHADER_STAGE_VERTEX_BIT)
     };
  
     VkVertexInputBindingDescription vertex_binding_desc = {
         .binding = 0,
         .stride = sizeof(float) * 3,
         .inputRate = VK_VERTEX_INPUT_RATE_VERTEX
     };
  
     VkVertexInputAttributeDescription vertex_attribute_desc = {
         .location = 0,
         .binding = 0,
         .format = VK_FORMAT_R32G32B32_SFLOAT,
         .offset = 0
     };
  
     VkPipelineVertexInputStateCreateInfo vertex_input_info = {
         .sType                           = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
         .vertexBindingDescriptionCount   = 1,
         .pVertexBindingDescriptions      = &vertex_binding_desc,
         .vertexAttributeDescriptionCount = 1,
         .pVertexAttributeDescriptions    = &vertex_attribute_desc,
     };
  
     VkPipelineInputAssemblyStateCreateInfo input_assembly_info = {
         .sType    = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
         .topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
     };
  
     VkViewport viewport = {
         .x        = 0.0f,
         .y        = 0.0f,
         .width    = (float)SHADOWMAP_SIZE,
         .height   = (float)SHADOWMAP_SIZE,
         .minDepth = 0.0f,
         .maxDepth = 1.0f,
     };
  
     VkRect2D scissor = {
         .offset = { 0, 0 },
         .extent = { SHADOWMAP_SIZE, SHADOWMAP_SIZE }
     };
  
     VkPipelineViewportStateCreateInfo viewport_state = {
         .sType         = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,
         .viewportCount = 1,
         .pViewports    = &viewport,
         .scissorCount  = 1,
         .pScissors     = &scissor,
     };
  
     VkPipelineRasterizationStateCreateInfo rasterizer_state = {
         .sType                   = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
         .polygonMode             = VK_POLYGON_MODE_FILL,
         .lineWidth               = 1.0f,
         .cullMode                = VK_CULL_MODE_FRONT_BIT,
         .frontFace               = VK_FRONT_FACE_CLOCKWISE,
     };
  
     VkPipelineMultisampleStateCreateInfo multisample_state = {
         .sType                 = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
         .sampleShadingEnable   = VK_FALSE,
         .rasterizationSamples  = VK_SAMPLE_COUNT_1_BIT,
         .minSampleShading      = 1.0f,
         .pSampleMask           = NULL,
         .alphaToCoverageEnable = VK_FALSE,
         .alphaToOneEnable      = VK_FALSE,
     };
  
     VkPipelineDepthStencilStateCreateInfo depth_stencil_state = {
         .sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,
         .depthTestEnable = VK_TRUE,
         .depthWriteEnable = VK_TRUE,
         .depthCompareOp = VK_COMPARE_OP_LESS,
     };
  
     VkDynamicState dynamic_states[] = {
         VK_DYNAMIC_STATE_VIEWPORT,
         VK_DYNAMIC_STATE_SCISSOR
     };
  
     VkPipelineDynamicStateCreateInfo dynamic_state_info = {
         .sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO,
         .dynamicStateCount = LENGTH(dynamic_states),
         .pDynamicStates = dynamic_states
     };
  
     VkGraphicsPipelineCreateInfo pipeline_info = {
         .sType      = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
         .stageCount = LENGTH(shader_info),
         .pStages    = shader_info,
  
         .pVertexInputState   = &vertex_input_info,
         .pInputAssemblyState = &input_assembly_info,
         .pViewportState      = &viewport_state,
         .pRasterizationState = &rasterizer_state,
         .pMultisampleState   = &multisample_state,
         .pDepthStencilState  = &depth_stencil_state,
         .pColorBlendState    = NULL,
         .pDynamicState       = &dynamic_state_info,
         
         .layout              = pipeline_layout_smap,
         .renderPass          = render_pass_smap,
         .subpass             = 0,
  
         .basePipelineHandle  = VK_NULL_HANDLE,
         .basePipelineIndex   = -1,
     };
  
     _VK(vkCreateGraphicsPipelines(qvk.device, VK_NULL_HANDLE, 1, &pipeline_info, NULL, &pipeline_smap));
     ATTACH_LABEL_VARIABLE(pipeline_smap, PIPELINE);
  
     VkImageView attachments[] = {
         imv_smap_depth
     };
  
     VkFramebufferCreateInfo fb_create_info = {
         .sType           = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
         .renderPass      = render_pass_smap,
         .attachmentCount = 1,
         .pAttachments    = attachments,
         .width           = SHADOWMAP_SIZE,
         .height          = SHADOWMAP_SIZE,
         .layers          = 1,
     };
  
     _VK(vkCreateFramebuffer(qvk.device, &fb_create_info, NULL, &framebuffer_smap));
     ATTACH_LABEL_VARIABLE(framebuffer_smap, FRAMEBUFFER);
  
     attachments[0] = imv_smap_depth2;
     _VK(vkCreateFramebuffer(qvk.device, &fb_create_info, NULL, &framebuffer_smap2));
     ATTACH_LABEL_VARIABLE(framebuffer_smap2, FRAMEBUFFER);
  
     return VK_SUCCESS;
 }

◆ vkpt_shadow_map_destroy()

VkResult vkpt_shadow_map_destroy ( )

Definition at line 182 of file shadow_map.c.

 {
     vkDestroyImageView(qvk.device, imv_smap_depth, NULL);
     imv_smap_depth = VK_NULL_HANDLE;
     vkDestroyImageView(qvk.device, imv_smap_depth2, NULL);
     imv_smap_depth2 = VK_NULL_HANDLE;
     vkDestroyImageView(qvk.device, imv_smap_depth_array, NULL);
     imv_smap_depth_array = VK_NULL_HANDLE;
     vkDestroyImage(qvk.device, img_smap, NULL);
     img_smap = VK_NULL_HANDLE;
     vkFreeMemory(qvk.device, mem_smap, NULL);
     mem_smap = VK_NULL_HANDLE;
  
     vkDestroyRenderPass(qvk.device, render_pass_smap, NULL);
     render_pass_smap = VK_NULL_HANDLE;
     vkDestroyPipelineLayout(qvk.device, pipeline_layout_smap, NULL);
     pipeline_layout_smap = VK_NULL_HANDLE;
  
     return VK_SUCCESS;
 }

◆ vkpt_shadow_map_destroy_pipelines()

VkResult vkpt_shadow_map_destroy_pipelines ( )

Definition at line 351 of file shadow_map.c.

 {
     LOG_FUNC();
     vkDestroyFramebuffer(qvk.device, framebuffer_smap, NULL);
     framebuffer_smap = VK_NULL_HANDLE;
     vkDestroyFramebuffer(qvk.device, framebuffer_smap2, NULL);
     framebuffer_smap2 = VK_NULL_HANDLE;
     vkDestroyPipeline(qvk.device, pipeline_smap, NULL);
     pipeline_smap = VK_NULL_HANDLE;
     return VK_SUCCESS;
 }

◆ vkpt_shadow_map_get_view()

VkImageView vkpt_shadow_map_get_view ( )

Definition at line 203 of file shadow_map.c.

 {
     return imv_smap_depth_array;
 }

Referenced by create_image_views().

◆ vkpt_shadow_map_initialize()

VkResult vkpt_shadow_map_initialize ( )

Definition at line 87 of file shadow_map.c.

 {
     create_render_pass();
  
     VkPushConstantRange push_constant_range = {
         .stageFlags = VK_SHADER_STAGE_VERTEX_BIT,
         .offset = 0,
         .size = sizeof(float) * 16,
     };
  
     CREATE_PIPELINE_LAYOUT(qvk.device, &pipeline_layout_smap,
         .pushConstantRangeCount = 1,
         .pPushConstantRanges = &push_constant_range,
     );
  
  
     VkImageCreateInfo img_info = {
         .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
         .extent = {
             .width = SHADOWMAP_SIZE,
             .height = SHADOWMAP_SIZE,
             .depth = 1,
         },
         .imageType = VK_IMAGE_TYPE_2D,
         .format = VK_FORMAT_D32_SFLOAT,
         .mipLevels = 1,
         .arrayLayers = 2,
         .samples = VK_SAMPLE_COUNT_1_BIT,
         .tiling = VK_IMAGE_TILING_OPTIMAL,
         .usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT
                | VK_IMAGE_USAGE_SAMPLED_BIT,
         .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
         .queueFamilyIndexCount = qvk.queue_idx_graphics,
         .initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
     };
  
     _VK(vkCreateImage(qvk.device, &img_info, NULL, &img_smap));
     ATTACH_LABEL_VARIABLE(img_smap, IMAGE);
  
     VkMemoryRequirements mem_req;
     vkGetImageMemoryRequirements(qvk.device, img_smap, &mem_req);
  
     _VK(allocate_gpu_memory(mem_req, &mem_smap));
  
     _VK(vkBindImageMemory(qvk.device, img_smap, mem_smap, 0));
  
     VkImageViewCreateInfo img_view_info = {
         .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
         .viewType = VK_IMAGE_VIEW_TYPE_2D,
         .format = VK_FORMAT_D32_SFLOAT,
         .image = img_smap,
         .subresourceRange = {
             .aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT,
             .baseMipLevel = 0,
             .levelCount = 1,
             .baseArrayLayer = 0,
             .layerCount = 1,
         },
         .components = {
             VK_COMPONENT_SWIZZLE_R,
             VK_COMPONENT_SWIZZLE_G,
             VK_COMPONENT_SWIZZLE_B,
             VK_COMPONENT_SWIZZLE_A,
         },
     };
     _VK(vkCreateImageView(qvk.device, &img_view_info, NULL, &imv_smap_depth));
     ATTACH_LABEL_VARIABLE(imv_smap_depth, IMAGE_VIEW);
  
     img_view_info.subresourceRange.baseArrayLayer = 1;
     _VK(vkCreateImageView(qvk.device, &img_view_info, NULL, &imv_smap_depth2));
     ATTACH_LABEL_VARIABLE(imv_smap_depth2, IMAGE_VIEW);
  
     img_view_info.viewType = VK_IMAGE_VIEW_TYPE_2D_ARRAY;
     img_view_info.subresourceRange.baseArrayLayer = 0;
     img_view_info.subresourceRange.layerCount = 2;
     _VK(vkCreateImageView(qvk.device, &img_view_info, NULL, &imv_smap_depth_array));
     ATTACH_LABEL_VARIABLE(imv_smap_depth_array, IMAGE_VIEW);
  
     VkCommandBuffer cmd_buf = vkpt_begin_command_buffer(&qvk.cmd_buffers_graphics);
  
     IMAGE_BARRIER(cmd_buf,
         .image = img_smap,
         .subresourceRange = { .aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT,.levelCount = 1,.layerCount = 2 },
         .srcAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
         .dstAccessMask = VK_ACCESS_SHADER_READ_BIT,
         .oldLayout = VK_IMAGE_LAYOUT_UNDEFINED,
         .newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
     );
  
     vkpt_submit_command_buffer_simple(cmd_buf, qvk.queue_graphics, qtrue);
  
     return VK_SUCCESS;
 }

◆ vkpt_shadow_map_render()

VkResult vkpt_shadow_map_render	(	VkCommandBuffer	cmd_buf,
		float *	view_projection_matrix,
		int	num_static_verts,
		int	num_dynamic_verts,
		int	transparent_offset,
		int	num_transparent_verts
	)

Definition at line 364 of file shadow_map.c.

 {
     IMAGE_BARRIER(cmd_buf,
         .image = img_smap,
         .subresourceRange = { .aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT, .levelCount = 1, .layerCount = 2 },
         .srcAccessMask = VK_ACCESS_SHADER_READ_BIT,
         .dstAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
         .oldLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
         .newLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
     );
  
     VkClearValue clear_depth = { .depthStencil = { .depth = 1.f } };
     
     VkRenderPassBeginInfo render_pass_info = {
         .sType             = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
         .renderPass        = render_pass_smap,
         .framebuffer       = framebuffer_smap,
         .renderArea.offset = { 0, 0 },
         .renderArea.extent = { SHADOWMAP_SIZE, SHADOWMAP_SIZE },
         .clearValueCount   = 1,
         .pClearValues      = &clear_depth
     };
  
     vkCmdBeginRenderPass(cmd_buf, &render_pass_info, VK_SUBPASS_CONTENTS_INLINE);
     vkCmdBindPipeline(cmd_buf, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_smap);
  
     VkViewport viewport =
     {
         .width = (float)SHADOWMAP_SIZE,
         .height = (float)SHADOWMAP_SIZE,
         .minDepth = 0,
         .maxDepth = 1.0f,
     };
  
     vkCmdSetViewport(cmd_buf, 0, 1, &viewport);
  
     VkRect2D scissor =
     {
         .extent.width = SHADOWMAP_SIZE,
         .extent.height = SHADOWMAP_SIZE,
         .offset.x = 0,
         .offset.y = 0,
     };
  
     vkCmdSetScissor(cmd_buf, 0, 1, &scissor);
  
     vkCmdPushConstants(cmd_buf, pipeline_layout_smap, VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(float) * 16, view_projection_matrix);
  
     VkDeviceSize vertex_offset = offsetof(struct VertexBuffer, positions_bsp);
     vkCmdBindVertexBuffers(cmd_buf, 0, 1, &qvk.buf_vertex.buffer, &vertex_offset);
  
     vkCmdDraw(cmd_buf, num_static_verts, 1, 0, 0);
  
     vertex_offset = offsetof(struct VertexBuffer, positions_instanced);
     vkCmdBindVertexBuffers(cmd_buf, 0, 1, &qvk.buf_vertex.buffer, &vertex_offset);
  
     vkCmdDraw(cmd_buf, num_dynamic_verts, 1, 0, 0);
  
     vkCmdEndRenderPass(cmd_buf);
  
  
     render_pass_info.framebuffer = framebuffer_smap2;
     vkCmdBeginRenderPass(cmd_buf, &render_pass_info, VK_SUBPASS_CONTENTS_INLINE);
  
     vertex_offset = offsetof(struct VertexBuffer, positions_bsp);
     vkCmdBindVertexBuffers(cmd_buf, 0, 1, &qvk.buf_vertex.buffer, &vertex_offset);
  
     vkCmdDraw(cmd_buf, num_transparent_verts, 1, transparent_offset, 0);
  
     vkCmdEndRenderPass(cmd_buf);
  
  
     IMAGE_BARRIER(cmd_buf,
         .image = img_smap,
         .subresourceRange = { .aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT,.levelCount = 1,.layerCount = 2 },
         .srcAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
         .dstAccessMask = VK_ACCESS_SHADER_READ_BIT,
         .oldLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
         .newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
         );
  
     return VK_SUCCESS;
 }

Referenced by R_RenderFrame_RTX().

◆ vkpt_shadow_map_setup()

void vkpt_shadow_map_setup	(	const sun_light_t *	light,
		const float *	bbox_min,
		const float *	bbox_max,
		float *	VP,
		float *	depth_scale,
		qboolean	random_sampling
	)

Definition at line 460 of file shadow_map.c.

 {
     vec3_t up_dir = { 0.0f, 0.0f, 1.0f };
     if (light->direction[2] >= 0.99f)
         VectorSet(up_dir, 1.f, 0.f, 0.f);
  
     vec3_t look_dir;
     VectorScale(light->direction, -1.f, look_dir);
     VectorNormalize(look_dir);
     vec3_t left_dir;
     CrossProduct(up_dir, look_dir, left_dir);
     VectorNormalize(left_dir);
     CrossProduct(look_dir, left_dir, up_dir);
     VectorNormalize(up_dir);
  
     if (random_sampling)
     {
         float u, v;
         sample_disk(&u, &v);
         
         VectorMA(look_dir, u * light->angular_size_rad * 0.5f, left_dir, look_dir);
         VectorMA(look_dir, v * light->angular_size_rad * 0.5f, up_dir, look_dir);
  
         VectorNormalize(look_dir);
  
         CrossProduct(up_dir, look_dir, left_dir);
         VectorNormalize(left_dir);
         CrossProduct(look_dir, left_dir, up_dir);
         VectorNormalize(up_dir);
     }
  
     float view_matrix[16] = {
         left_dir[0], up_dir[0], look_dir[0], 0.f,
         left_dir[1], up_dir[1], look_dir[1], 0.f,
         left_dir[2], up_dir[2], look_dir[2], 0.f,
         0.f, 0.f, 0.f, 1.f
     };
  
     vec3_t view_aabb_min = { FLT_MAX, FLT_MAX, FLT_MAX };
     vec3_t view_aabb_max = { -FLT_MAX, -FLT_MAX, -FLT_MAX };
  
     for (int i = 0; i < 8; i++)
     {
         float corner[4];
         corner[0] = (i & 1) ? bbox_max[0] : bbox_min[0];
         corner[1] = (i & 2) ? bbox_max[1] : bbox_min[1];
         corner[2] = (i & 4) ? bbox_max[2] : bbox_min[2];
         corner[3] = 1.f;
  
         float view_corner[4];
         mult_matrix_vector(view_corner, view_matrix, corner);
  
         view_aabb_min[0] = min(view_aabb_min[0], view_corner[0]);
         view_aabb_min[1] = min(view_aabb_min[1], view_corner[1]);
         view_aabb_min[2] = min(view_aabb_min[2], view_corner[2]);
         view_aabb_max[0] = max(view_aabb_max[0], view_corner[0]);
         view_aabb_max[1] = max(view_aabb_max[1], view_corner[1]);
         view_aabb_max[2] = max(view_aabb_max[2], view_corner[2]);
     }
  
     vec3_t diagonal;
     VectorSubtract(view_aabb_max, view_aabb_min, diagonal);
  
     float maxXY = max(diagonal[0], diagonal[1]);
     vec3_t diff;
     diff[0] = (maxXY - diagonal[0]) * 0.5f;
     diff[1] = (maxXY - diagonal[1]) * 0.5f;
     diff[2] = 0.f;
     VectorSubtract(view_aabb_min, diff, view_aabb_min);
     VectorAdd(view_aabb_max, diff, view_aabb_max);
  
     float projection_matrix[16];
     create_orthographic_matrix(projection_matrix, view_aabb_min[0], view_aabb_max[0], view_aabb_min[1], view_aabb_max[1], view_aabb_min[2], view_aabb_max[2]);
     mult_matrix_matrix(VP, projection_matrix, view_matrix);
  
     *depth_scale = view_aabb_max[2] - view_aabb_min[2];
 }