| /* | |
| * Copyright 2023 Rive | |
| */ | |
| #include "draw_shader_vulkan.hpp" | |
| #include "rive/renderer/vulkan/vkutil.hpp" | |
| #include "rive/renderer/vulkan/vulkan_context.hpp" | |
| #include "shaders/constants.glsl" | |
| namespace rive::gpu | |
| { | |
| namespace spirv_embedded | |
| { | |
| // Draw setup shaders. | |
| #include "generated/shaders/spirv/color_ramp.vert.h" | |
| #include "generated/shaders/spirv/color_ramp.frag.h" | |
| #include "generated/shaders/spirv/tessellate.vert.h" | |
| #include "generated/shaders/spirv/tessellate.frag.h" | |
| #include "generated/shaders/spirv/render_atlas.vert.h" | |
| #include "generated/shaders/spirv/render_atlas_fill.frag.h" | |
| #include "generated/shaders/spirv/render_atlas_stroke.frag.h" | |
| // InterlockMode::rasterOrdering shaders. | |
| #include "generated/shaders/spirv/draw_path.vert.h" | |
| #include "generated/shaders/spirv/draw_path.frag.h" | |
| #include "generated/shaders/spirv/draw_interior_triangles.vert.h" | |
| #include "generated/shaders/spirv/draw_interior_triangles.frag.h" | |
| #include "generated/shaders/spirv/draw_atlas_blit.vert.h" | |
| #include "generated/shaders/spirv/draw_atlas_blit.frag.h" | |
| #include "generated/shaders/spirv/draw_image_mesh.vert.h" | |
| #include "generated/shaders/spirv/draw_image_mesh.frag.h" | |
| // InterlockMode::atomics shaders. | |
| #include "generated/shaders/spirv/atomic_draw_path.vert.h" | |
| #include "generated/shaders/spirv/atomic_draw_path.frag.h" | |
| #include "generated/shaders/spirv/atomic_draw_path.fixedcolor_frag.h" | |
| #include "generated/shaders/spirv/atomic_draw_interior_triangles.vert.h" | |
| #include "generated/shaders/spirv/atomic_draw_interior_triangles.frag.h" | |
| #include "generated/shaders/spirv/atomic_draw_interior_triangles.fixedcolor_frag.h" | |
| #include "generated/shaders/spirv/atomic_draw_atlas_blit.vert.h" | |
| #include "generated/shaders/spirv/atomic_draw_atlas_blit.frag.h" | |
| #include "generated/shaders/spirv/atomic_draw_atlas_blit.fixedcolor_frag.h" | |
| #include "generated/shaders/spirv/atomic_draw_image_rect.vert.h" | |
| #include "generated/shaders/spirv/atomic_draw_image_rect.frag.h" | |
| #include "generated/shaders/spirv/atomic_draw_image_rect.fixedcolor_frag.h" | |
| #include "generated/shaders/spirv/atomic_draw_image_mesh.vert.h" | |
| #include "generated/shaders/spirv/atomic_draw_image_mesh.frag.h" | |
| #include "generated/shaders/spirv/atomic_draw_image_mesh.fixedcolor_frag.h" | |
| #include "generated/shaders/spirv/atomic_resolve.vert.h" | |
| #include "generated/shaders/spirv/atomic_resolve.frag.h" | |
| #include "generated/shaders/spirv/atomic_resolve.fixedcolor_frag.h" | |
| #include "generated/shaders/spirv/atomic_resolve_coalesced.vert.h" | |
| #include "generated/shaders/spirv/atomic_resolve_coalesced.frag.h" | |
| // InterlockMode::clockwiseAtomic shaders. | |
| #include "generated/shaders/spirv/draw_clockwise_path.vert.h" | |
| #include "generated/shaders/spirv/draw_clockwise_path.frag.h" | |
| #include "generated/shaders/spirv/draw_clockwise_interior_triangles.vert.h" | |
| #include "generated/shaders/spirv/draw_clockwise_interior_triangles.frag.h" | |
| #include "generated/shaders/spirv/draw_clockwise_atlas_blit.vert.h" | |
| #include "generated/shaders/spirv/draw_clockwise_atlas_blit.frag.h" | |
| #include "generated/shaders/spirv/draw_clockwise_image_mesh.vert.h" | |
| #include "generated/shaders/spirv/draw_clockwise_image_mesh.frag.h" | |
| // InterlockMode::msaa shaders. | |
| #include "generated/shaders/spirv/draw_msaa_path.vert.h" | |
| #include "generated/shaders/spirv/draw_msaa_path.frag.h" | |
| #include "generated/shaders/spirv/draw_msaa_path.fixedcolor_frag.h" | |
| #include "generated/shaders/spirv/draw_msaa_stencil.vert.h" | |
| #include "generated/shaders/spirv/draw_msaa_stencil.frag.h" | |
| #include "generated/shaders/spirv/draw_msaa_stencil.fixedcolor_frag.h" | |
| #include "generated/shaders/spirv/draw_msaa_atlas_blit.vert.h" | |
| #include "generated/shaders/spirv/draw_msaa_atlas_blit.frag.h" | |
| #include "generated/shaders/spirv/draw_msaa_atlas_blit.fixedcolor_frag.h" | |
| #include "generated/shaders/spirv/draw_msaa_image_mesh.vert.h" | |
| #include "generated/shaders/spirv/draw_msaa_image_mesh.frag.h" | |
| #include "generated/shaders/spirv/draw_msaa_image_mesh.fixedcolor_frag.h" | |
| }; // namespace spirv_embedded | |
| namespace spirv | |
| { | |
| // Draw setup shaders. | |
| rive::Span<const uint32_t> color_ramp_vert = | |
| rive::make_span(spirv_embedded::color_ramp_vert); | |
| rive::Span<const uint32_t> color_ramp_frag = | |
| rive::make_span(spirv_embedded::color_ramp_frag); | |
| rive::Span<const uint32_t> tessellate_vert = | |
| rive::make_span(spirv_embedded::tessellate_vert); | |
| rive::Span<const uint32_t> tessellate_frag = | |
| rive::make_span(spirv_embedded::tessellate_frag); | |
| rive::Span<const uint32_t> render_atlas_vert = | |
| rive::make_span(spirv_embedded::render_atlas_vert); | |
| rive::Span<const uint32_t> render_atlas_fill_frag = | |
| rive::make_span(spirv_embedded::render_atlas_fill_frag); | |
| rive::Span<const uint32_t> render_atlas_stroke_frag = | |
| rive::make_span(spirv_embedded::render_atlas_stroke_frag); | |
| // InterlockMode::rasterOrdering shaders. | |
| rive::Span<const uint32_t> draw_path_vert = | |
| rive::make_span(spirv_embedded::draw_path_vert); | |
| rive::Span<const uint32_t> draw_path_frag = | |
| rive::make_span(spirv_embedded::draw_path_frag); | |
| rive::Span<const uint32_t> draw_interior_triangles_vert = | |
| rive::make_span(spirv_embedded::draw_interior_triangles_vert); | |
| rive::Span<const uint32_t> draw_interior_triangles_frag = | |
| rive::make_span(spirv_embedded::draw_interior_triangles_frag); | |
| rive::Span<const uint32_t> draw_atlas_blit_vert = | |
| rive::make_span(spirv_embedded::draw_atlas_blit_vert); | |
| rive::Span<const uint32_t> draw_atlas_blit_frag = | |
| rive::make_span(spirv_embedded::draw_atlas_blit_frag); | |
| rive::Span<const uint32_t> draw_image_mesh_vert = | |
| rive::make_span(spirv_embedded::draw_image_mesh_vert); | |
| rive::Span<const uint32_t> draw_image_mesh_frag = | |
| rive::make_span(spirv_embedded::draw_image_mesh_frag); | |
| // InterlockMode::atomics shaders. | |
| rive::Span<const uint32_t> atomic_draw_path_vert = | |
| rive::make_span(spirv_embedded::atomic_draw_path_vert); | |
| rive::Span<const uint32_t> atomic_draw_path_frag = | |
| rive::make_span(spirv_embedded::atomic_draw_path_frag); | |
| rive::Span<const uint32_t> atomic_draw_path_fixedcolor_frag = rive::make_span( | |
| spirv_embedded::atomic_draw_path_fixedcolor_frag, | |
| std::size(spirv_embedded::atomic_draw_path_fixedcolor_frag)); | |
| rive::Span<const uint32_t> atomic_draw_interior_triangles_vert = | |
| rive::make_span(spirv_embedded::atomic_draw_interior_triangles_vert); | |
| rive::Span<const uint32_t> atomic_draw_interior_triangles_frag = | |
| rive::make_span(spirv_embedded::atomic_draw_interior_triangles_frag); | |
| rive::Span<const uint32_t> atomic_draw_interior_triangles_fixedcolor_frag = | |
| rive::make_span( | |
| spirv_embedded::atomic_draw_interior_triangles_fixedcolor_frag); | |
| rive::Span<const uint32_t> atomic_draw_atlas_blit_vert = | |
| rive::make_span(spirv_embedded::atomic_draw_atlas_blit_vert); | |
| rive::Span<const uint32_t> atomic_draw_atlas_blit_frag = | |
| rive::make_span(spirv_embedded::atomic_draw_atlas_blit_frag); | |
| rive::Span<const uint32_t> atomic_draw_atlas_blit_fixedcolor_frag = | |
| rive::make_span(spirv_embedded::atomic_draw_atlas_blit_fixedcolor_frag); | |
| rive::Span<const uint32_t> atomic_draw_image_rect_vert = | |
| rive::make_span(spirv_embedded::atomic_draw_image_rect_vert); | |
| rive::Span<const uint32_t> atomic_draw_image_rect_frag = | |
| rive::make_span(spirv_embedded::atomic_draw_image_rect_frag); | |
| rive::Span<const uint32_t> atomic_draw_image_rect_fixedcolor_frag = | |
| rive::make_span(spirv_embedded::atomic_draw_image_rect_fixedcolor_frag); | |
| rive::Span<const uint32_t> atomic_draw_image_mesh_vert = | |
| rive::make_span(spirv_embedded::atomic_draw_image_mesh_vert); | |
| rive::Span<const uint32_t> atomic_draw_image_mesh_frag = | |
| rive::make_span(spirv_embedded::atomic_draw_image_mesh_frag); | |
| rive::Span<const uint32_t> atomic_draw_image_mesh_fixedcolor_frag = | |
| rive::make_span(spirv_embedded::atomic_draw_image_mesh_fixedcolor_frag); | |
| rive::Span<const uint32_t> atomic_resolve_vert = | |
| rive::make_span(spirv_embedded::atomic_resolve_vert); | |
| rive::Span<const uint32_t> atomic_resolve_frag = | |
| rive::make_span(spirv_embedded::atomic_resolve_frag); | |
| rive::Span<const uint32_t> atomic_resolve_fixedcolor_frag = | |
| rive::make_span(spirv_embedded::atomic_resolve_fixedcolor_frag, | |
| std::size(spirv_embedded::atomic_resolve_fixedcolor_frag)); | |
| rive::Span<const uint32_t> atomic_resolve_coalesced_vert = | |
| rive::make_span(spirv_embedded::atomic_resolve_coalesced_vert); | |
| rive::Span<const uint32_t> atomic_resolve_coalesced_frag = | |
| rive::make_span(spirv_embedded::atomic_resolve_coalesced_frag); | |
| // InterlockMode::clockwiseAtomic shaders. | |
| rive::Span<const uint32_t> draw_clockwise_path_vert = | |
| rive::make_span(spirv_embedded::draw_clockwise_path_vert); | |
| rive::Span<const uint32_t> draw_clockwise_path_frag = | |
| rive::make_span(spirv_embedded::draw_clockwise_path_frag); | |
| rive::Span<const uint32_t> draw_clockwise_interior_triangles_vert = | |
| rive::make_span(spirv_embedded::draw_clockwise_interior_triangles_vert); | |
| rive::Span<const uint32_t> draw_clockwise_interior_triangles_frag = | |
| rive::make_span(spirv_embedded::draw_clockwise_interior_triangles_frag); | |
| rive::Span<const uint32_t> draw_clockwise_atlas_blit_vert = | |
| rive::make_span(spirv_embedded::draw_clockwise_atlas_blit_vert); | |
| rive::Span<const uint32_t> draw_clockwise_atlas_blit_frag = | |
| rive::make_span(spirv_embedded::draw_clockwise_atlas_blit_frag); | |
| rive::Span<const uint32_t> draw_clockwise_image_mesh_vert = | |
| rive::make_span(spirv_embedded::draw_clockwise_image_mesh_vert); | |
| rive::Span<const uint32_t> draw_clockwise_image_mesh_frag = | |
| rive::make_span(spirv_embedded::draw_clockwise_image_mesh_frag); | |
| // InterlockMode::msaa shaders. | |
| rive::Span<const uint32_t> draw_msaa_path_vert = | |
| rive::make_span(spirv_embedded::draw_msaa_path_vert); | |
| rive::Span<const uint32_t> draw_msaa_path_frag = | |
| rive::make_span(spirv_embedded::draw_msaa_path_frag); | |
| rive::Span<const uint32_t> draw_msaa_path_fixedcolor_frag = | |
| rive::make_span(spirv_embedded::draw_msaa_path_fixedcolor_frag); | |
| rive::Span<const uint32_t> draw_msaa_stencil_vert = | |
| rive::make_span(spirv_embedded::draw_msaa_stencil_vert); | |
| rive::Span<const uint32_t> draw_msaa_stencil_frag = | |
| rive::make_span(spirv_embedded::draw_msaa_stencil_frag); | |
| rive::Span<const uint32_t> draw_msaa_stencil_fixedcolor_frag = | |
| rive::make_span(spirv_embedded::draw_msaa_stencil_fixedcolor_frag); | |
| rive::Span<const uint32_t> draw_msaa_atlas_blit_vert = | |
| rive::make_span(spirv_embedded::draw_msaa_atlas_blit_vert); | |
| rive::Span<const uint32_t> draw_msaa_atlas_blit_frag = | |
| rive::make_span(spirv_embedded::draw_msaa_atlas_blit_frag); | |
| rive::Span<const uint32_t> draw_msaa_atlas_blit_fixedcolor_frag = | |
| rive::make_span(spirv_embedded::draw_msaa_atlas_blit_fixedcolor_frag); | |
| rive::Span<const uint32_t> draw_msaa_image_mesh_vert = | |
| rive::make_span(spirv_embedded::draw_msaa_image_mesh_vert); | |
| rive::Span<const uint32_t> draw_msaa_image_mesh_frag = | |
| rive::make_span(spirv_embedded::draw_msaa_image_mesh_frag); | |
| rive::Span<const uint32_t> draw_msaa_image_mesh_fixedcolor_frag = | |
| rive::make_span(spirv_embedded::draw_msaa_image_mesh_fixedcolor_frag); | |
| void hotload_shaders(rive::Span<const uint32_t> spirvData) | |
| { | |
| size_t spirvIndex = 0; | |
| auto readNextBytecodeSpan = [spirvData, | |
| &spirvIndex]() -> rive::Span<const uint32_t> { | |
| size_t insnCount = spirvData[spirvIndex++]; | |
| const uint32_t* insnData = spirvData.data() + spirvIndex; | |
| spirvIndex += insnCount; | |
| return rive::make_span(insnData, insnCount); | |
| }; | |
| spirv::color_ramp_vert = readNextBytecodeSpan(); | |
| spirv::color_ramp_frag = readNextBytecodeSpan(); | |
| spirv::tessellate_vert = readNextBytecodeSpan(); | |
| spirv::tessellate_frag = readNextBytecodeSpan(); | |
| spirv::render_atlas_vert = readNextBytecodeSpan(); | |
| spirv::render_atlas_fill_frag = readNextBytecodeSpan(); | |
| spirv::render_atlas_stroke_frag = readNextBytecodeSpan(); | |
| spirv::draw_path_vert = readNextBytecodeSpan(); | |
| spirv::draw_path_frag = readNextBytecodeSpan(); | |
| spirv::draw_interior_triangles_vert = readNextBytecodeSpan(); | |
| spirv::draw_interior_triangles_frag = readNextBytecodeSpan(); | |
| spirv::draw_atlas_blit_vert = readNextBytecodeSpan(); | |
| spirv::draw_atlas_blit_frag = readNextBytecodeSpan(); | |
| spirv::draw_image_mesh_vert = readNextBytecodeSpan(); | |
| spirv::draw_image_mesh_frag = readNextBytecodeSpan(); | |
| spirv::atomic_draw_path_vert = readNextBytecodeSpan(); | |
| spirv::atomic_draw_path_frag = readNextBytecodeSpan(); | |
| spirv::atomic_draw_path_fixedcolor_frag = readNextBytecodeSpan(); | |
| spirv::atomic_draw_interior_triangles_vert = readNextBytecodeSpan(); | |
| spirv::atomic_draw_interior_triangles_frag = readNextBytecodeSpan(); | |
| spirv::atomic_draw_interior_triangles_fixedcolor_frag = | |
| readNextBytecodeSpan(); | |
| spirv::atomic_draw_atlas_blit_vert = readNextBytecodeSpan(); | |
| spirv::atomic_draw_atlas_blit_frag = readNextBytecodeSpan(); | |
| spirv::atomic_draw_atlas_blit_fixedcolor_frag = readNextBytecodeSpan(); | |
| spirv::atomic_draw_image_rect_vert = readNextBytecodeSpan(); | |
| spirv::atomic_draw_image_rect_frag = readNextBytecodeSpan(); | |
| spirv::atomic_draw_image_rect_fixedcolor_frag = readNextBytecodeSpan(); | |
| spirv::atomic_draw_image_mesh_vert = readNextBytecodeSpan(); | |
| spirv::atomic_draw_image_mesh_frag = readNextBytecodeSpan(); | |
| spirv::atomic_draw_image_mesh_fixedcolor_frag = readNextBytecodeSpan(); | |
| spirv::atomic_resolve_vert = readNextBytecodeSpan(); | |
| spirv::atomic_resolve_frag = readNextBytecodeSpan(); | |
| spirv::atomic_resolve_fixedcolor_frag = readNextBytecodeSpan(); | |
| spirv::atomic_resolve_coalesced_vert = readNextBytecodeSpan(); | |
| spirv::atomic_resolve_coalesced_frag = readNextBytecodeSpan(); | |
| spirv::draw_clockwise_path_vert = readNextBytecodeSpan(); | |
| spirv::draw_clockwise_path_frag = readNextBytecodeSpan(); | |
| spirv::draw_clockwise_interior_triangles_vert = readNextBytecodeSpan(); | |
| spirv::draw_clockwise_interior_triangles_frag = readNextBytecodeSpan(); | |
| spirv::draw_clockwise_atlas_blit_vert = readNextBytecodeSpan(); | |
| spirv::draw_clockwise_atlas_blit_frag = readNextBytecodeSpan(); | |
| spirv::draw_clockwise_image_mesh_vert = readNextBytecodeSpan(); | |
| spirv::draw_clockwise_image_mesh_frag = readNextBytecodeSpan(); | |
| spirv::draw_msaa_path_vert = readNextBytecodeSpan(); | |
| spirv::draw_msaa_path_frag = readNextBytecodeSpan(); | |
| spirv::draw_msaa_path_fixedcolor_frag = readNextBytecodeSpan(); | |
| spirv::draw_msaa_stencil_vert = readNextBytecodeSpan(); | |
| spirv::draw_msaa_stencil_frag = readNextBytecodeSpan(); | |
| spirv::draw_msaa_stencil_fixedcolor_frag = readNextBytecodeSpan(); | |
| spirv::draw_msaa_atlas_blit_vert = readNextBytecodeSpan(); | |
| spirv::draw_msaa_atlas_blit_frag = readNextBytecodeSpan(); | |
| spirv::draw_msaa_atlas_blit_fixedcolor_frag = readNextBytecodeSpan(); | |
| spirv::draw_msaa_image_mesh_vert = readNextBytecodeSpan(); | |
| spirv::draw_msaa_image_mesh_frag = readNextBytecodeSpan(); | |
| spirv::draw_msaa_image_mesh_fixedcolor_frag = readNextBytecodeSpan(); | |
| } | |
| }; // namespace spirv | |
| DrawShaderVulkan::DrawShaderVulkan(VulkanContext* vk, | |
| gpu::DrawType drawType, | |
| gpu::InterlockMode interlockMode, | |
| gpu::ShaderFeatures shaderFeatures, | |
| gpu::ShaderMiscFlags shaderMiscFlags) : | |
| m_vk(ref_rcp(vk)) | |
| { | |
| VkShaderModuleCreateInfo vsInfo = { | |
| .sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO}; | |
| VkShaderModuleCreateInfo fsInfo = { | |
| .sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO}; | |
| const bool fixedFunctionColorOutput = | |
| shaderMiscFlags & gpu::ShaderMiscFlags::fixedFunctionColorOutput; | |
| switch (interlockMode) | |
| { | |
| case gpu::InterlockMode::rasterOrdering: | |
| { | |
| switch (drawType) | |
| { | |
| case DrawType::midpointFanPatches: | |
| case DrawType::midpointFanCenterAAPatches: | |
| case DrawType::outerCurvePatches: | |
| vkutil::set_shader_code(vsInfo, spirv::draw_path_vert); | |
| vkutil::set_shader_code(fsInfo, spirv::draw_path_frag); | |
| break; | |
| case DrawType::interiorTriangulation: | |
| vkutil::set_shader_code( | |
| vsInfo, | |
| spirv::draw_interior_triangles_vert); | |
| vkutil::set_shader_code( | |
| fsInfo, | |
| spirv::draw_interior_triangles_frag); | |
| break; | |
| case DrawType::atlasBlit: | |
| vkutil::set_shader_code(vsInfo, | |
| spirv::draw_atlas_blit_vert); | |
| vkutil::set_shader_code(fsInfo, | |
| spirv::draw_atlas_blit_frag); | |
| break; | |
| case DrawType::imageMesh: | |
| vkutil::set_shader_code(vsInfo, | |
| spirv::draw_image_mesh_vert); | |
| vkutil::set_shader_code(fsInfo, | |
| spirv::draw_image_mesh_frag); | |
| break; | |
| case DrawType::imageRect: | |
| case DrawType::atomicResolve: | |
| case DrawType::atomicInitialize: | |
| case DrawType::msaaStrokes: | |
| case DrawType::msaaMidpointFanBorrowedCoverage: | |
| case DrawType::msaaMidpointFans: | |
| case DrawType::msaaMidpointFanStencilReset: | |
| case DrawType::msaaMidpointFanPathsStencil: | |
| case DrawType::msaaMidpointFanPathsCover: | |
| case DrawType::msaaOuterCubics: | |
| case DrawType::msaaStencilClipReset: | |
| RIVE_UNREACHABLE(); | |
| } | |
| break; | |
| } | |
| case gpu::InterlockMode::atomics: | |
| { | |
| switch (drawType) | |
| { | |
| case DrawType::midpointFanPatches: | |
| case DrawType::midpointFanCenterAAPatches: | |
| case DrawType::outerCurvePatches: | |
| vkutil::set_shader_code(vsInfo, | |
| spirv::atomic_draw_path_vert); | |
| vkutil::set_shader_code_if_then_else( | |
| fsInfo, | |
| fixedFunctionColorOutput, | |
| spirv::atomic_draw_path_fixedcolor_frag, | |
| spirv::atomic_draw_path_frag); | |
| break; | |
| case DrawType::interiorTriangulation: | |
| vkutil::set_shader_code( | |
| vsInfo, | |
| spirv::atomic_draw_interior_triangles_vert); | |
| vkutil::set_shader_code_if_then_else( | |
| fsInfo, | |
| fixedFunctionColorOutput, | |
| spirv::atomic_draw_interior_triangles_fixedcolor_frag, | |
| spirv::atomic_draw_interior_triangles_frag); | |
| break; | |
| case DrawType::atlasBlit: | |
| vkutil::set_shader_code(vsInfo, | |
| spirv::atomic_draw_atlas_blit_vert); | |
| vkutil::set_shader_code_if_then_else( | |
| fsInfo, | |
| fixedFunctionColorOutput, | |
| spirv::atomic_draw_atlas_blit_fixedcolor_frag, | |
| spirv::atomic_draw_atlas_blit_frag); | |
| break; | |
| case DrawType::imageRect: | |
| vkutil::set_shader_code(vsInfo, | |
| spirv::atomic_draw_image_rect_vert); | |
| vkutil::set_shader_code_if_then_else( | |
| fsInfo, | |
| fixedFunctionColorOutput, | |
| spirv::atomic_draw_image_rect_fixedcolor_frag, | |
| spirv::atomic_draw_image_rect_frag); | |
| break; | |
| case DrawType::imageMesh: | |
| vkutil::set_shader_code(vsInfo, | |
| spirv::atomic_draw_image_mesh_vert); | |
| vkutil::set_shader_code_if_then_else( | |
| fsInfo, | |
| fixedFunctionColorOutput, | |
| spirv::atomic_draw_image_mesh_fixedcolor_frag, | |
| spirv::atomic_draw_image_mesh_frag); | |
| break; | |
| case DrawType::atomicResolve: | |
| if (shaderMiscFlags & | |
| gpu::ShaderMiscFlags::coalescedResolveAndTransfer) | |
| { | |
| vkutil::set_shader_code( | |
| vsInfo, | |
| spirv::atomic_resolve_coalesced_vert); | |
| vkutil::set_shader_code( | |
| fsInfo, | |
| spirv::atomic_resolve_coalesced_frag); | |
| } | |
| else | |
| { | |
| vkutil::set_shader_code(vsInfo, | |
| spirv::atomic_resolve_vert); | |
| vkutil::set_shader_code_if_then_else( | |
| fsInfo, | |
| fixedFunctionColorOutput, | |
| spirv::atomic_resolve_fixedcolor_frag, | |
| spirv::atomic_resolve_frag); | |
| } | |
| break; | |
| case DrawType::atomicInitialize: | |
| case DrawType::msaaStrokes: | |
| case DrawType::msaaMidpointFanBorrowedCoverage: | |
| case DrawType::msaaMidpointFans: | |
| case DrawType::msaaMidpointFanStencilReset: | |
| case DrawType::msaaMidpointFanPathsStencil: | |
| case DrawType::msaaMidpointFanPathsCover: | |
| case DrawType::msaaOuterCubics: | |
| case DrawType::msaaStencilClipReset: | |
| RIVE_UNREACHABLE(); | |
| } | |
| break; | |
| } | |
| case gpu::InterlockMode::clockwiseAtomic: | |
| { | |
| switch (drawType) | |
| { | |
| case DrawType::midpointFanPatches: | |
| case DrawType::midpointFanCenterAAPatches: | |
| case DrawType::outerCurvePatches: | |
| vkutil::set_shader_code(vsInfo, | |
| spirv::draw_clockwise_path_vert); | |
| vkutil::set_shader_code(fsInfo, | |
| spirv::draw_clockwise_path_frag); | |
| break; | |
| case DrawType::interiorTriangulation: | |
| vkutil::set_shader_code( | |
| vsInfo, | |
| spirv::draw_clockwise_interior_triangles_vert); | |
| vkutil::set_shader_code( | |
| fsInfo, | |
| spirv::draw_clockwise_interior_triangles_frag); | |
| break; | |
| case DrawType::atlasBlit: | |
| vkutil::set_shader_code( | |
| vsInfo, | |
| spirv::draw_clockwise_atlas_blit_vert); | |
| vkutil::set_shader_code( | |
| fsInfo, | |
| spirv::draw_clockwise_atlas_blit_frag); | |
| break; | |
| case DrawType::imageMesh: | |
| vkutil::set_shader_code( | |
| vsInfo, | |
| spirv::draw_clockwise_image_mesh_vert); | |
| vkutil::set_shader_code( | |
| fsInfo, | |
| spirv::draw_clockwise_image_mesh_frag); | |
| break; | |
| case DrawType::imageRect: | |
| case DrawType::atomicResolve: | |
| case DrawType::atomicInitialize: | |
| case DrawType::msaaStrokes: | |
| case DrawType::msaaMidpointFanBorrowedCoverage: | |
| case DrawType::msaaMidpointFans: | |
| case DrawType::msaaMidpointFanStencilReset: | |
| case DrawType::msaaMidpointFanPathsStencil: | |
| case DrawType::msaaMidpointFanPathsCover: | |
| case DrawType::msaaOuterCubics: | |
| case DrawType::msaaStencilClipReset: | |
| RIVE_UNREACHABLE(); | |
| } | |
| break; | |
| } | |
| case gpu::InterlockMode::msaa: | |
| { | |
| switch (drawType) | |
| { | |
| case DrawType::midpointFanPatches: | |
| case DrawType::midpointFanCenterAAPatches: | |
| case DrawType::outerCurvePatches: | |
| RIVE_UNREACHABLE(); | |
| case DrawType::msaaOuterCubics: | |
| case DrawType::msaaStrokes: | |
| case DrawType::msaaMidpointFanBorrowedCoverage: | |
| case DrawType::msaaMidpointFans: | |
| case DrawType::msaaMidpointFanStencilReset: | |
| case DrawType::msaaMidpointFanPathsStencil: | |
| case DrawType::msaaMidpointFanPathsCover: | |
| vkutil::set_shader_code(vsInfo, spirv::draw_msaa_path_vert); | |
| vkutil::set_shader_code_if_then_else( | |
| fsInfo, | |
| fixedFunctionColorOutput, | |
| spirv::draw_msaa_path_fixedcolor_frag, | |
| spirv::draw_msaa_path_frag); | |
| break; | |
| case DrawType::msaaStencilClipReset: | |
| vkutil::set_shader_code(vsInfo, | |
| spirv::draw_msaa_stencil_vert); | |
| vkutil::set_shader_code(fsInfo, | |
| spirv::draw_msaa_stencil_frag); | |
| break; | |
| case DrawType::interiorTriangulation: | |
| // Interior triangulation is not yet implemented for MSAA. | |
| RIVE_UNREACHABLE(); | |
| break; | |
| case DrawType::atlasBlit: | |
| vkutil::set_shader_code(vsInfo, | |
| spirv::draw_msaa_atlas_blit_vert); | |
| vkutil::set_shader_code_if_then_else( | |
| fsInfo, | |
| fixedFunctionColorOutput, | |
| spirv::draw_msaa_atlas_blit_fixedcolor_frag, | |
| spirv::draw_msaa_atlas_blit_frag); | |
| break; | |
| case DrawType::imageMesh: | |
| vkutil::set_shader_code(vsInfo, | |
| spirv::draw_msaa_image_mesh_vert); | |
| vkutil::set_shader_code_if_then_else( | |
| fsInfo, | |
| fixedFunctionColorOutput, | |
| spirv::draw_msaa_image_mesh_fixedcolor_frag, | |
| spirv::draw_msaa_image_mesh_frag); | |
| break; | |
| case DrawType::imageRect: | |
| case DrawType::atomicResolve: | |
| case DrawType::atomicInitialize: | |
| RIVE_UNREACHABLE(); | |
| } | |
| break; | |
| } | |
| } | |
| VK_CHECK(m_vk->CreateShaderModule(m_vk->device, | |
| &vsInfo, | |
| nullptr, | |
| &m_vertexModule)); | |
| VK_CHECK(m_vk->CreateShaderModule(m_vk->device, | |
| &fsInfo, | |
| nullptr, | |
| &m_fragmentModule)); | |
| } | |
| DrawShaderVulkan::~DrawShaderVulkan() | |
| { | |
| m_vk->DestroyShaderModule(m_vk->device, m_vertexModule, nullptr); | |
| m_vk->DestroyShaderModule(m_vk->device, m_fragmentModule, nullptr); | |
| } | |
| } // namespace rive::gpu |