init
This commit is contained in:
@@ -0,0 +1,41 @@
|
||||
# Copyright (c) 2021-2025 Holochip Corporation
|
||||
#
|
||||
# SPDX-License-Identifier: Apache-2.0
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 the "License";
|
||||
# you may not use this file except in compliance with the License.
|
||||
# You may obtain a copy of the License at
|
||||
#
|
||||
# http://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
#
|
||||
|
||||
get_filename_component(FOLDER_NAME ${CMAKE_CURRENT_LIST_DIR} NAME)
|
||||
get_filename_component(PARENT_DIR ${CMAKE_CURRENT_LIST_DIR} PATH)
|
||||
get_filename_component(CATEGORY_NAME ${PARENT_DIR} NAME)
|
||||
|
||||
add_sample_with_tags(
|
||||
ID ${FOLDER_NAME}
|
||||
CATEGORY ${CATEGORY_NAME}
|
||||
AUTHOR "Holochip Corporation"
|
||||
NAME "Ray tracing extended"
|
||||
DESCRIPTION "Extended example of Ray Tracing highlighting the Bottom and Top Level Acceleration Structure rebuild and AO."
|
||||
SHADER_FILES_GLSL
|
||||
"ray_tracing_extended/glsl/raygen.rgen"
|
||||
"ray_tracing_extended/glsl/miss.rmiss"
|
||||
"ray_tracing_extended/glsl/closesthit.rchit"
|
||||
GLSLC_ADDITIONAL_ARGUMENTS
|
||||
"--target-spv=spv1.4"
|
||||
SHADER_FILES_HLSL
|
||||
"ray_tracing_extended/hlsl/raygen.rgen.hlsl"
|
||||
"ray_tracing_extended/hlsl/miss.rmiss.hlsl"
|
||||
"ray_tracing_extended/hlsl/closesthit.rchit.hlsl"
|
||||
DXC_ADDITIONAL_ARGUMENTS
|
||||
"-fspv-extension=SPV_EXT_descriptor_indexing -fspv-extension=SPV_KHR_ray_query"
|
||||
)
|
||||
|
||||
@@ -0,0 +1,138 @@
|
||||
////
|
||||
- Copyright (c) 2019-2023, Holochip Corporation
|
||||
-
|
||||
- SPDX-License-Identifier: Apache-2.0
|
||||
-
|
||||
- Licensed under the Apache License, Version 2.0 the "License";
|
||||
- you may not use this file except in compliance with the License.
|
||||
- You may obtain a copy of the License at
|
||||
-
|
||||
- http://www.apache.org/licenses/LICENSE-2.0
|
||||
-
|
||||
- Unless required by applicable law or agreed to in writing, software
|
||||
- distributed under the License is distributed on an "AS IS" BASIS,
|
||||
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
- See the License for the specific language governing permissions and
|
||||
- limitations under the License.
|
||||
-
|
||||
////
|
||||
= Ray-tracing: Extended features and dynamic objects
|
||||
|
||||
ifdef::site-gen-antora[]
|
||||
TIP: The source for this sample can be found in the https://github.com/KhronosGroup/Vulkan-Samples/tree/main/samples/extensions/ray_tracing_extended[Khronos Vulkan samples github repository].
|
||||
endif::[]
|
||||
|
||||
|
||||
This code sample demonstrates how to incorporate animations into a ray-traced scene, and shows how to incorporate different types of changing objects within the acceleration structures.
|
||||
|
||||
== Acceleration structures
|
||||
|
||||
The ray tracing acceleration structures are separated into two types: bottom-level acceleration structures (BLAS) and top-level acceleration structures (TLAS).
|
||||
The BLAS contains information about each object's geometry within its own coordinate system and is built using the vertex and index data stored in a GPU buffer.
|
||||
In contrast, the TLAS contains information about each instance of the geometry and its transformation (i.e.
|
||||
scaling, rotation, translation, etc.).
|
||||
|
||||
Each object must be represented in the BLAS, but can have any number of instances, each with its own transformation.
|
||||
This allows objects to be replicated without creating an acceleration structure for each instance.
|
||||
|
||||
== Objects: Static, moving, and changing
|
||||
|
||||
There are three categories of objects to consider when building acceleration structures: static, moving, and changing geometry.
|
||||
Static geometry includes scene data.
|
||||
In this code sample, the Sponza scene has a single, non-moving instance.
|
||||
In contrast, dynamic objects can have a changing transformation, changing geometry, or both.
|
||||
An example of transformation-only dynamic objects in this code sample are given by the flame particle effect, which is achieved by adjusting only the location and rotation of a square billboard -- the internal geometry (and thus the billboard's BLAS) does not change.
|
||||
In contrast, the refraction effect is achieved by changing both the internal geometry each frame, and the rotation (so that it faces the viewer).
|
||||
|
||||
Vulkan offers methods of optimizing the acceleration structures for each type of geometry.
|
||||
The `VkAccelerationStructureBuildGeometryInfoKHR` struct has flags that can either toggle "fast trace", which optimizes run-time performance at the expense of build time, or "fast build", which optimizes build time.
|
||||
When constructing large, static objects such as the Sponza scene, for instance, the "fast trace" bit (`VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR`) is selected because the build will occur once and the model contains many points.
|
||||
When constructing dynamic objects such as the refraction model, which will need a BLAS update every frame, the "fast build" bit (`VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR`) is selected.
|
||||
|
||||
Further optimization methods can be used.
|
||||
For instance, the refraction model is updated every frame by the CPU and thus uses host-visible memory.
|
||||
However, because host-visible memory can incur a performance penalty, the Sponza and billboard models use a staging buffer to copy to device-exclusive memory.
|
||||
An alternative method would be to use a "compute shader" to generate the refraction model each frame, but that is outside the scope of this tutorial.
|
||||
|
||||
== Reference Object Data from a Closest-Hit Shader
|
||||
|
||||
Though the ray-tracing pipeline uses an acceleration structure to traverse the scene's geometry, the acceleration structures themselves do not store user-defined information about the geometry and instead give the developer the flexibility to define their own custom geometry information.
|
||||
This information can be encoded at the per-instance level, per-object level, or per-primitive level.
|
||||
|
||||
_Per-instance level:_ The top-level acceleration structure allows instance information to encode a custom ID ( per-instance level).
|
||||
|
||||
_Per-object level:_ In this code sample, this custom ID then references a struct at the per-object level containing the object ID , the index of the vertices in the vertex buffer, and the index of the (triangle) indices in the index buffer:
|
||||
|
||||
----
|
||||
struct SceneInstanceData
|
||||
{
|
||||
uint32_t vertex_index;
|
||||
uint32_t indices_index;
|
||||
uint32_t image_index;
|
||||
uint32_t object_type;
|
||||
};
|
||||
----
|
||||
|
||||
_Per-primitive level_ In this sample, each vertex is encoded with a per-vertex normal and texture coordinate, though other applications may wish to provide other information at the per-vertex level.
|
||||
To allow the bottom-level acceleration structure to reference geometry data with a custom-defined layout, the `VkAccelerationStructureGeometryKHR` provides the ability to set geometry offsets and strides (i.e.
|
||||
`vertexStride`).
|
||||
In the code below, the struct `acceleration_structure_geometry` of type `VkAccelerationStructureGeometryKHR` references the data layout provided by NewVertex, which encodes the normal and texture coordinate:
|
||||
|
||||
----
|
||||
acceleration_structure_geometry.geometry.triangles.vertexData = vertex_data_device_address;
|
||||
acceleration_structure_geometry.geometry.triangles.maxVertex = model_buffer.num_vertices;
|
||||
acceleration_structure_geometry.geometry.triangles.vertexStride = sizeof(NewVertex);
|
||||
acceleration_structure_geometry.geometry.triangles.indexType = VK_INDEX_TYPE_UINT32;
|
||||
acceleration_structure_geometry.geometry.triangles.indexData = index_data_device_address;
|
||||
acceleration_structure_geometry.geometry.triangles.transformData = transform_matrix_device_address;
|
||||
----
|
||||
|
||||
This technique allows the closest-hit shader to access pre-calculated vertex information.
|
||||
|
||||
== Texture Binding and Shaders
|
||||
|
||||
In a traditional raster pipeline, it is possible to render each object separately and bind its appropriate texture images during that pass.
|
||||
However, in a ray-tracing pipeline, each ray during a render pass could intersect with many objects within the scene, and thus all textures must be available to the shader.
|
||||
In this code sample, an array of textures (`Sampler2D[]`) is bound, and each object is associated with a given texture index.
|
||||
The texture ID information is stored in the object data.
|
||||
|
||||
== Ambient Occlusion and Ray-Traced Shadows
|
||||
|
||||
This code sample explores two different ways to calculate lighting: ray-traced shadows and ambient occlusion, both of which are updated each frame and are triggered when a primary ray intersects a scene object (i.e.
|
||||
an element of the Sponza scene).
|
||||
|
||||
Ray-traced shadows are calculated by performing a test: a ray is shot from the object point in the direction of the light.
|
||||
If the returned distance is less than the distance to the light source, then the object point is in a shadow.
|
||||
In pseudocode:
|
||||
|
||||
----
|
||||
direction = object_pt - light_pt
|
||||
dist = trace_ray(object_pt, direction)
|
||||
if (dist < distance(object_pt, light_pt)):
|
||||
color.rgb *= 0.2
|
||||
----
|
||||
|
||||
The ambient occlusion effect is used to simulate the light diminishing effect of clustered geometry.
|
||||
It's simulated by tracing rays distributed about a hemisphere centered at the intersection point with the object's normal.
|
||||
The light-diminishing effect is estimated using the distance to the nearest ray intersection.
|
||||
In some implementations, a hard threshold is used.
|
||||
In pseudocode:
|
||||
|
||||
----
|
||||
for theta,phi in angles:
|
||||
hard_threshold = 10.f
|
||||
direction = hemisphere_pt(object_pt, normal, theta, phi)
|
||||
dist = trace_ray(object_pt, direction)
|
||||
if (dist < hard_threshold):
|
||||
color.rgb *= 0.2
|
||||
----
|
||||
|
||||
The code sample in this tutorial instead linearly interpolates up to the hard_threshold:
|
||||
|
||||
----
|
||||
color.rgb *= min(dist, hard_threshold) / min_threshold
|
||||
----
|
||||
|
||||
There are further optimizations that can be used.
|
||||
One common technique is to reduce the number of generated ambient occlusion rays at each point, often shooting just a single ray.
|
||||
The resulting image can then be de-noised using a separate de-noising pass, though this technique is outside the scope of this tutorial.
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,288 @@
|
||||
/* Copyright (c) 2021-2025 Holochip Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 the "License";
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Basic example for hardware accelerated ray tracing using VK_KHR_ray_tracing_pipeline and VK_KHR_acceleration_structure
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#define USE_FRAMEWORK_ACCELERATION_STRUCTURE
|
||||
|
||||
#include "api_vulkan_sample.h"
|
||||
#include <core/acceleration_structure.h>
|
||||
|
||||
class RaytracingExtended : public ApiVulkanSample
|
||||
{
|
||||
public:
|
||||
VkPhysicalDeviceRayTracingPipelinePropertiesKHR ray_tracing_pipeline_properties{};
|
||||
VkPhysicalDeviceAccelerationStructureFeaturesKHR acceleration_structure_features{};
|
||||
|
||||
enum RenderMode : uint32_t
|
||||
{
|
||||
RENDER_DEFAULT = 0,
|
||||
RENDER_BARYCENTRIC = 1,
|
||||
RENDER_INSTANCE_ID = 2,
|
||||
RENDER_DISTANCE = 3,
|
||||
RENDER_GLOBAL_XYZ = 4,
|
||||
RENDER_SHADOW_MAP = 5,
|
||||
RENDER_AO = 6
|
||||
};
|
||||
|
||||
enum ObjectType : uint32_t
|
||||
{
|
||||
OBJECT_NORMAL, // has AO and ray traced shadows
|
||||
OBJECT_REFRACTION, // pass-through with IOR
|
||||
OBJECT_FLAME // emission surface; constant amplitude
|
||||
};
|
||||
|
||||
#ifndef USE_FRAMEWORK_ACCELERATION_STRUCTURE
|
||||
// Wraps all data required for an acceleration structure
|
||||
struct AccelerationStructureExtended
|
||||
{
|
||||
VkAccelerationStructureKHR handle = nullptr;
|
||||
uint64_t device_address = 0;
|
||||
std::unique_ptr<vkb::core::BufferC> buffer;
|
||||
};
|
||||
#endif
|
||||
|
||||
struct NewVertex;
|
||||
struct Model;
|
||||
|
||||
struct FlameParticle
|
||||
{
|
||||
glm::vec3 position;
|
||||
glm::vec3 velocity;
|
||||
float duration = 0.f;
|
||||
};
|
||||
|
||||
struct FlameParticleGenerator
|
||||
{
|
||||
FlameParticleGenerator() = default;
|
||||
|
||||
FlameParticleGenerator(glm::vec3 generator_origin, glm::vec3 generator_direction, float generator_radius, size_t n_particles) :
|
||||
origin(generator_origin), direction(generator_direction), radius(generator_radius), n_particles(n_particles), generator(std::chrono::system_clock::now().time_since_epoch().count())
|
||||
{
|
||||
using namespace glm;
|
||||
u = normalize(abs(dot(generator_direction, vec3(0, 0, 1))) > 0.9f ? cross(generator_direction, vec3(1, 0, 0)) : cross(generator_direction, vec3(0, 0, 1)));
|
||||
v = normalize(cross(generator_direction, u));
|
||||
|
||||
for (size_t i = 0; i < n_particles; ++i)
|
||||
{
|
||||
float starting_lifetime = generate_random() * lifetime;
|
||||
particles.emplace_back(generateParticle(starting_lifetime));
|
||||
}
|
||||
}
|
||||
~FlameParticleGenerator() = default;
|
||||
FlameParticle generateParticle(float _lifetime = 0.f) const
|
||||
{
|
||||
using namespace glm;
|
||||
const float theta = 2.f * 3.14159f * generate_random();
|
||||
const float R = radius * generate_random();
|
||||
const vec3 velocity_direction = generate_random_direction();
|
||||
|
||||
FlameParticle particle;
|
||||
particle.position = origin + R * (sin(theta) * u + cos(theta) * v);
|
||||
particle.velocity = generate_random() * 0.2f * velocity_direction;
|
||||
particle.duration = _lifetime;
|
||||
return particle;
|
||||
}
|
||||
glm::vec3 generate_random_direction() const
|
||||
{
|
||||
using namespace glm;
|
||||
return normalize(0.2f * generate_random() * u + 0.2f * generate_random() * v + 0.8f * direction * generate_random());
|
||||
}
|
||||
void update_particles(float time_delta)
|
||||
{
|
||||
particles.erase(std::remove_if(particles.begin(), particles.end(), [this, lifetime{this->lifetime}](const FlameParticle &particle) {
|
||||
return particle.duration > (generate_random() * lifetime);
|
||||
}),
|
||||
particles.end());
|
||||
|
||||
for (auto &&particle : particles)
|
||||
{
|
||||
particle.position += time_delta * particle.velocity;
|
||||
// particle.velocity = 0.75f * particle.velocity + 0.25f * generate_random_direction();
|
||||
particle.duration += time_delta;
|
||||
}
|
||||
|
||||
for (size_t i = particles.size(); i < n_particles; ++i)
|
||||
{
|
||||
particles.emplace_back(generateParticle(0.f));
|
||||
}
|
||||
}
|
||||
|
||||
float generate_random() const
|
||||
{
|
||||
std::uniform_real_distribution<float> distribution = std::uniform_real_distribution<float>(0, 1);
|
||||
return distribution(generator);
|
||||
}
|
||||
|
||||
mutable std::default_random_engine generator;
|
||||
std::vector<FlameParticle> particles;
|
||||
glm::vec3 origin = {0, 0, 0};
|
||||
glm::vec3 direction = {0, 0, 0};
|
||||
glm::vec3 u = {0, 0, 0}, v = {0, 0, 0};
|
||||
float lifetime = 5;
|
||||
float radius = 0.f;
|
||||
size_t n_particles = 0;
|
||||
};
|
||||
|
||||
FlameParticleGenerator flame_generator;
|
||||
|
||||
struct ModelBuffer
|
||||
{
|
||||
size_t vertex_offset = std::numeric_limits<size_t>::max(); // in bytes
|
||||
size_t index_offset = std::numeric_limits<size_t>::max(); // in bytes
|
||||
size_t num_vertices = std::numeric_limits<size_t>::max();
|
||||
size_t num_triangles = std::numeric_limits<size_t>::max();
|
||||
uint32_t texture_index = std::numeric_limits<uint32_t>::max();
|
||||
std::unique_ptr<vkb::core::BufferC> transform_matrix_buffer = nullptr;
|
||||
VkAccelerationStructureBuildSizesInfoKHR buildSize;
|
||||
VkAccelerationStructureGeometryKHR acceleration_structure_geometry;
|
||||
VkAccelerationStructureBuildRangeInfoKHR buildRangeInfo;
|
||||
#ifdef USE_FRAMEWORK_ACCELERATION_STRUCTURE
|
||||
std::unique_ptr<vkb::core::AccelerationStructure> bottom_level_acceleration_structure = nullptr;
|
||||
#else
|
||||
AccelerationStructureExtended bottom_level_acceleration_structure;
|
||||
#endif
|
||||
VkTransformMatrixKHR default_transform;
|
||||
uint32_t object_type = 0;
|
||||
bool is_static = true;
|
||||
uint64_t object_id = 0;
|
||||
};
|
||||
|
||||
struct SceneOptions
|
||||
{
|
||||
bool use_vertex_staging_buffer = true;
|
||||
} scene_options;
|
||||
size_t frame_count = 0;
|
||||
std::chrono::high_resolution_clock::time_point start = std::chrono::high_resolution_clock::now();
|
||||
|
||||
// fixed buffers
|
||||
std::unique_ptr<vkb::core::BufferC> vertex_buffer = nullptr;
|
||||
std::unique_ptr<vkb::core::BufferC> index_buffer = nullptr;
|
||||
std::unique_ptr<vkb::core::BufferC> dynamic_vertex_buffer = nullptr;
|
||||
std::unique_ptr<vkb::core::BufferC> dynamic_index_buffer = nullptr;
|
||||
std::unique_ptr<vkb::core::BufferC> instances_buffer = nullptr;
|
||||
|
||||
struct SceneLoadInfo
|
||||
{
|
||||
SceneLoadInfo() = default;
|
||||
SceneLoadInfo(const char *filename, glm::mat3x4 transform, uint32_t object_type) :
|
||||
filename(filename), transform(transform), object_type(object_type)
|
||||
{}
|
||||
const char *filename = "";
|
||||
glm::mat3x4 transform;
|
||||
uint32_t object_type = 0;
|
||||
};
|
||||
|
||||
struct RaytracingScene
|
||||
{
|
||||
RaytracingScene() = default;
|
||||
~RaytracingScene() = default;
|
||||
RaytracingScene(vkb::core::DeviceC &device, const std::vector<SceneLoadInfo> &scenesToLoad);
|
||||
std::vector<std::unique_ptr<vkb::sg::Scene>> scenes;
|
||||
std::vector<VkDescriptorImageInfo> imageInfos;
|
||||
std::vector<Model> models;
|
||||
std::vector<ModelBuffer> model_buffers;
|
||||
};
|
||||
|
||||
std::unique_ptr<RaytracingScene> raytracing_scene;
|
||||
Texture flame_texture;
|
||||
|
||||
#ifdef USE_FRAMEWORK_ACCELERATION_STRUCTURE
|
||||
std::unique_ptr<vkb::core::AccelerationStructure> top_level_acceleration_structure = nullptr;
|
||||
#else
|
||||
AccelerationStructureExtended top_level_acceleration_structure;
|
||||
#endif
|
||||
uint64_t instance_uid = std::numeric_limits<uint64_t>::max();
|
||||
uint32_t index_count;
|
||||
std::vector<VkRayTracingShaderGroupCreateInfoKHR> shader_groups{};
|
||||
|
||||
std::unique_ptr<vkb::core::BufferC> raygen_shader_binding_table;
|
||||
std::unique_ptr<vkb::core::BufferC> miss_shader_binding_table;
|
||||
std::unique_ptr<vkb::core::BufferC> hit_shader_binding_table;
|
||||
|
||||
struct StorageImage
|
||||
{
|
||||
VkDeviceMemory memory;
|
||||
VkImage image = VK_NULL_HANDLE;
|
||||
VkImageView view;
|
||||
VkFormat format;
|
||||
uint32_t width;
|
||||
uint32_t height;
|
||||
StorageImage() :
|
||||
memory(VK_NULL_HANDLE), image(VK_NULL_HANDLE), view(VK_NULL_HANDLE), format(), width(0), height(0)
|
||||
{}
|
||||
} storage_image;
|
||||
|
||||
struct UniformData
|
||||
{
|
||||
glm::mat4 view_inverse;
|
||||
glm::mat4 proj_inverse;
|
||||
} uniform_data;
|
||||
std::unique_ptr<vkb::core::BufferC> ubo;
|
||||
|
||||
struct SceneInstanceData
|
||||
{
|
||||
uint32_t vertex_index; // index of first data
|
||||
uint32_t indices_index;
|
||||
uint32_t image_index;
|
||||
uint32_t object_type; // controls how shader handles object / whether to load from buffer for static objects or dynamic objects
|
||||
};
|
||||
std::unique_ptr<vkb::core::BufferC> data_to_model_buffer;
|
||||
|
||||
std::vector<VkCommandBuffer> raytracing_command_buffers;
|
||||
VkPipeline pipeline;
|
||||
VkPipelineLayout pipeline_layout;
|
||||
VkDescriptorSet descriptor_set;
|
||||
VkDescriptorSetLayout descriptor_set_layout;
|
||||
using Triangle = std::array<uint32_t, 3>;
|
||||
uint32_t grid_size = 100;
|
||||
std::vector<NewVertex> refraction_model;
|
||||
std::vector<Triangle> refraction_indices;
|
||||
|
||||
RaytracingExtended();
|
||||
~RaytracingExtended() override;
|
||||
|
||||
void request_gpu_features(vkb::PhysicalDevice &gpu) override;
|
||||
uint64_t get_buffer_device_address(VkBuffer buffer);
|
||||
void create_storage_image();
|
||||
void create_static_object_buffers();
|
||||
void create_flame_model();
|
||||
void create_dynamic_object_buffers(float time);
|
||||
void create_bottom_level_acceleration_structure(bool is_update, bool print_time = true);
|
||||
VkTransformMatrixKHR calculate_rotation(glm::vec3 pt, float scale = 1.f, bool freeze_y = false);
|
||||
void create_top_level_acceleration_structure(bool print_time = true);
|
||||
#ifndef USE_FRAMEWORK_ACCELERATION_STRUCTURE
|
||||
void delete_acceleration_structure(AccelerationStructureExtended &acceleration_structure);
|
||||
#endif
|
||||
|
||||
void create_scene();
|
||||
void create_shader_binding_tables();
|
||||
void create_descriptor_sets();
|
||||
void create_ray_tracing_pipeline();
|
||||
void create_uniform_buffer();
|
||||
void build_command_buffers() override;
|
||||
void update_uniform_buffers();
|
||||
void draw();
|
||||
bool prepare(const vkb::ApplicationOptions &options) override;
|
||||
void render(float delta_time) override;
|
||||
};
|
||||
|
||||
std::unique_ptr<vkb::VulkanSampleC> create_ray_tracing_extended();
|
||||
Reference in New Issue
Block a user