Jump to content
  • Advertisement

Search the Community

Showing results for tags 'Vulkan' in content posted in Graphics and GPU Programming.



More search options

  • Search By Tags

    Type tags separated by commas.
  • Search By Author

Content Type


Categories

  • Audio
    • Music and Sound FX
  • Business
    • Business and Law
    • Career Development
    • Production and Management
  • Game Design
    • Game Design and Theory
    • Writing for Games
    • UX for Games
  • Industry
    • Interviews
    • Event Coverage
  • Programming
    • Artificial Intelligence
    • General and Gameplay Programming
    • Graphics and GPU Programming
    • Engines and Middleware
    • Math and Physics
    • Networking and Multiplayer
  • Visual Arts
  • Archive

Categories

  • Audio
  • Visual Arts
  • Programming
  • Writing

Categories

  • Game Dev Loadout
  • Game Dev Unchained

Categories

  • Game Developers Conference
    • GDC 2017
    • GDC 2018
  • Power-Up Digital Games Conference
    • PDGC I: Words of Wisdom
    • PDGC II: The Devs Strike Back
    • PDGC III: Syntax Error

Forums

  • Audio
    • Music and Sound FX
  • Business
    • Games Career Development
    • Production and Management
    • Games Business and Law
  • Game Design
    • Game Design and Theory
    • Writing for Games
  • Programming
    • Artificial Intelligence
    • Engines and Middleware
    • General and Gameplay Programming
    • Graphics and GPU Programming
    • Math and Physics
    • Networking and Multiplayer
  • Visual Arts
    • 2D and 3D Art
    • Art Critique and Feedback
  • Community
    • GameDev Challenges
    • GDNet+ Member Forum
    • GDNet Lounge
    • GDNet Comments, Suggestions, and Ideas
    • Coding Horrors
    • Your Announcements
    • Hobby Project Classifieds
    • Indie Showcase
    • Article Writing
  • Affiliates
    • NeHe Productions
    • AngelCode
  • Topical
    • Virtual and Augmented Reality
    • News
  • Workshops
    • C# Workshop
    • CPP Workshop
    • Freehand Drawing Workshop
    • Hands-On Interactive Game Development
    • SICP Workshop
    • XNA 4.0 Workshop
  • Archive
    • Topical
    • Affiliates
    • Contests
    • Technical
  • GameDev Challenges's Topics
  • For Beginners's Forum
  • Unreal Engine Users's Unreal Engine Group Forum
  • Unity Developers's Forum
  • Unity Developers's Asset Share

Calendars

  • Community Calendar
  • Games Industry Events
  • Game Jams
  • GameDev Challenges's Schedule

Blogs

There are no results to display.

There are no results to display.

Product Groups

  • Advertisements
  • GameDev Gear

Find results in...

Find results that contain...


Date Created

  • Start

    End


Last Updated

  • Start

    End


Filter by number of...

Joined

  • Start

    End


Group


About Me


Website


Role


Twitter


Github


Twitch


Steam

Found 157 results

  1. The latest release of Diligent Engine combines a number of recent updates (Vulkan on iOS, GLTF2.0 support, shadows), significantly improves performance of OpenGL backend, updates API, adds integration with Dear Imgui and implements new samples and tutorials. Some of the new features in this release: GLTF2.0 support (loader, PBR renderer and sample viewer) Shadowing Component and Shadows Sample Integration with Dear Imgui library and Dear Imgui demo Tutorial13 - Shadow Map Tutorial14 - Compute Shader Tutorial15 - Multiple Windows Check it out on GitHub.
  2. Home: https://www.khronos.org/vulkan/ SDK: http://lunarg.com/vulkan-sdk/ AMD drivers: http://gpuopen.com/gaming-product/vulkan/ (Note that Vulkan support is now part of AMD’s official drivers, so simply getting the latest drivers for your card should give you Vulkan support.) NVIDIA drivers: https://developer.nvidia.com/vulkan-driver (Note that Vulkan support is now part of NVIDIA’s official drivers, so simply getting the latest drivers for your card should give you Vulkan support.) Intel drivers: http://blogs.intel.com/evangelists/2016/02/16/intel-open-source-graphics-drivers-now-support-vulkan/ Quick reference: https://www.khronos.org/registry/vulkan/specs/1.0/refguide/Vulkan-1.0-web.pdf References: https://www.khronos.org/registry/vulkan/specs/1.0/apispec.html https://matthewwellings.com/blog/the-new-vulkan-coordinate-system/ GLSL-to-SPIR-V: https://github.com/KhronosGroup/glslang Sample code: https://github.com/LunarG/VulkanSamples https://github.com/SaschaWillems/Vulkan https://github.com/nvpro-samples https://github.com/nvpro-samples/gl_vk_chopper https://github.com/nvpro-samples/gl_vk_threaded_cadscene https://github.com/nvpro-samples/gl_vk_bk3dthreaded https://github.com/nvpro-samples/gl_vk_supersampled https://github.com/McNopper/Vulkan https://github.com/GPUOpen-LibrariesAndSDKs/HelloVulkan C++: https://github.com/nvpro-pipeline/vkcpp https://developer.nvidia.com/open-source-vulkan-c-api Getting started: https://vulkan-tutorial.com/ https://renderdoc.org/vulkan-in-30-minutes.html https://www.khronos.org/news/events/vulkan-webinar https://developer.nvidia.com/engaging-voyage-vulkan https://developer.nvidia.com/vulkan-shader-resource-binding https://developer.nvidia.com/vulkan-memory-management https://developer.nvidia.com/opengl-vulkan https://github.com/vinjn/awesome-vulkan Videos: https://www.youtube.com/playlist?list=PLYO7XTAX41FPg08uM_bgPE9HLgDAyzDaZ Utilities: https://github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator (AMD Memory allocator.) https://github.com/GPUOpen-LibrariesAndSDKs/Anvil (AMD Miniature Vulkan engine/framework.) L. Spiro
  3. Hello, brace yourselves for yet another bloom question. So I've got this bloom stuff going on where: 1. I'm downsampling the brightness of the image 1/2 of the previous with 1/2, 1/4, 1/8, and 1/16 a. Along the way, I'm filtering out stray bright pixels using the following shader: #version 430 #extension GL_ARB_separate_shader_objects : enable #extension GL_ARB_shading_language_420pack : enable #extension GL_ARB_compute_shader : enable #extension GL_GOOGLE_include_directive : enable #define NO_NORMAL_TANGENT #include "Common/Globals.glsl" layout (set = 0, binding = 0) uniform sampler2D hiRes; layout (set = 0, binding = 1, rgba16) uniform image2D loRes; // Size of lo res texture // Parameters passed from engine: // bloomThreshold = 0.0f // invOutputSz = inverse sz of loResImage. layout (push_constant) uniform PushConst { vec4 invOutputSz; vec4 bloomThreshold; } screen; // Implemented from Jason Stanard's algorithms. Credits to MiniEngine: // https://github.com/microsoft/DirectX-Graphics-Samples/blob/master/MiniEngine/Core/Shaders/BloomExtractAndDownsampleLdrCS.hlsl float ColorRGBtoLuma(vec3 c) { return dot(c, vec3(0.212671, 0.715160, 0.072169)); } layout (local_size_x = 8, local_size_y = 8, local_size_z = 1) in; void main() { vec2 offset = screen.invOutputSz.xy * 0.25; ivec2 iPixCoord = ivec2(gl_GlobalInvocationID.x, gl_GlobalInvocationID.y); // Inverting to get one pixel sz. vec2 tx = (vec2(iPixCoord) + 0.5) * screen.invOutputSz.xy; vec3 c0 = texture(hiRes, tx + vec2(-offset.x, -offset.y)).rgb; vec3 c1 = texture(hiRes, tx + vec2( offset.x, -offset.y)).rgb; vec3 c2 = texture(hiRes, tx + vec2(-offset.x, offset.y)).rgb; vec3 c3 = texture(hiRes, tx + vec2( offset.x, offset.y)).rgb; const float kEpsilon = 0.0001; float threshold = screen.bloomThreshold.x; float luma0 = ColorRGBtoLuma(c0); float luma1 = ColorRGBtoLuma(c1); float luma2 = ColorRGBtoLuma(c2); float luma3 = ColorRGBtoLuma(c3); // Apply bloom strength threshold. c0 *= max(kEpsilon, luma0 - threshold) / (luma0 + kEpsilon); c1 *= max(kEpsilon, luma1 - threshold) / (luma1 + kEpsilon); c2 *= max(kEpsilon, luma2 - threshold) / (luma2 + kEpsilon); c3 *= max(kEpsilon, luma3 - threshold) / (luma3 + kEpsilon); const float kShimmerInvStr = 1.0; float w0 = 1.0 / (luma0 + kShimmerInvStr); float w1 = 1.0 / (luma1 + kShimmerInvStr); float w2 = 1.0 / (luma2 + kShimmerInvStr); float w3 = 1.0 / (luma3 + kShimmerInvStr); float wSum = w0 + w1 + w2 + w3; vec3 o = (c0 * w0 + c1 * w1 + c2 * w2 + c3 * w3) / wSum; vec4 res = vec4(o.rgb, 1.0); imageStore(loRes, iPixCoord, res); } 2. Blurring each resulting image horizontally and vertically with gaussian blur algorithm as so: #version 430 #extension GL_ARB_separate_shader_objects : enable #extension GL_ARB_shading_language_420pack : enable layout (location = 0) out vec4 outColor; in FRAG_IN { vec2 uv; } frag_in; // The surface we are blurring. layout (set = 0, binding = 0) uniform sampler2D sceneSurface; // Push constants to determine direction of blur. //Parameters passed from engine where -> Value (per image): //Blur.scale = 1.0f (1/16), 1.5f (1/8), 1.6 (1/4), 1.6 (1/2). layout (push_constant) uniform Consts { int horizontal; float strength; float scale; } Blur; void main() { // Gaussian weights float weight[5]; weight[0] = 70.0 / 256.0; weight[1] = 56.0 / 256.0; weight[2] = 28.0 / 256.0; weight[3] = 8.0 / 256.0; weight[4] = 1.0 / 256.0; vec2 offset = 1.0 / textureSize(sceneSurface, 0) * Blur.scale; vec3 blurColor = texture(sceneSurface, frag_in.uv).rgb * weight[0]; // TODO(): Perform blur. May want to do a linear sample instead? // <-------- coefficients ---------> for horizontal. if (Blur.horizontal == 1) { for (int i = 1; i < 5; ++i) { blurColor += texture(sceneSurface, frag_in.uv + vec2(offset.x * i, 0.0)).rgb * weight[i] * Blur.strength; blurColor += texture(sceneSurface, frag_in.uv - vec2(offset.x * i, 0.0)).rgb * weight[i] * Blur.strength; } } else { for (int i = 1; i < 5; ++i) { blurColor += texture(sceneSurface, frag_in.uv + vec2(0.0, offset.y * i)).rgb * weight[i] * Blur.strength; blurColor += texture(sceneSurface, frag_in.uv - vec2(0.0, offset.y * i)).rgb * weight[i] * Blur.strength; } } outColor = vec4(blurColor, 1.0); } 3. Finally, accumulating each result back up the chain. ex. 1/16 back to 1/8. Then repeating this process for 1/8 to 1/4, 1/4 to 1/2, and 1/2 to full image, while repeating 2 and 3 in the process. a. Code for accumulation: #version 430 #extension GL_ARB_separate_shader_objects : enable #extension GL_ARB_shading_language_420pack : enable #extension GL_ARB_compute_shader : enable #extension GL_GOOGLE_include_directive : enable #define NO_NORMAL_TANGENT #include "Common/Globals.glsl" layout (set = 0, binding = 0) uniform sampler2D loRes; layout (set = 0, binding = 1, rgba16) uniform image2D hiRes; // sz is the (width, height) of the hiRes image. layout (push_constant) uniform PushConst { ivec4 sz; } screen; layout (local_size_x = 8, local_size_y = 8, local_size_z = 1) in; void main() { ivec2 iPixCoord = ivec2(gl_GlobalInvocationID.x, gl_GlobalInvocationID.y); vec2 tx = (vec2(iPixCoord) / vec2(screen.sz.xy)); vec3 lo = texture(loRes, tx).rgb; vec3 hi = imageLoad(hiRes, iPixCoord).rgb; vec4 res = vec4(hi + lo, 1); imageStore(hiRes, iPixCoord, res); } And the result of this process is as so: https://gph.is/g/ZyznzwW Although the problem is that I am trying to control the effect to get a slightly wider spread on the brightness as the reference below: Although when trying to spread the effect with the Blur.scale value (say 3.1) on all passes I get decent results, but because of stray or tiny clusters of pixels, it ends up with artifacts: https://imgur.com/a/hSoOfhP Where it looks more like dithering. I'm guessing it has to do with my gaussian blur pass scaling, since looking at renderdoc, each pass creates this weird pattern: https://imgur.com/a/wrN6NzL I've been looking at links like this one: Which looks a little like what I'm doing, while not doing so much as the energy conservation and HDR that is expected (I'm not really looking for super realism, just some way to control the value of the effect.) I am a noob when it comes to this kind of stuff, but was hoping to seek advice from the people who have an idea on how to mitigate this issue? All advice is welcomed, experienced or not
  4. hello I try to use uint as vertex attribute. like layout(location = 0) in vec3 a_Vertex; layout(location = 1) in uint a_Color; layout(location = 0) out vec4 color; void main() { vec4 col = unpackUnorm4x8(a_Color); color = col; //cb.color; *** sending on draw for line just 2 vertex with struct { vec3 position; uint32 color }; Drawing just line. The strange situation is next. color is always red or gradation of red. looks like extracts only red color. I thought it may related to data align, but my data is too small.vertex is 16 byte, 32byte is line data. does anyone have/had similar problem? or any suggestion? GPU is GTX 750ti. OS win 8.1, Ubuntu 18.04 lts. thanks.
  5. Hi, I am writing my own engine on C# using .Net core 3 and I wrapped macOS window to output my triangle demo there and it actually render, BUT.... I receive only ~140 FPS. I investigate a little and found out that calls to vkCmdEndRenderPass(), vkEndCommandBuffer() and vkQueueSubmit() takes toooo long and I have no idea why, but this is not the end. Most interesting thing start when I swipe to another virtual screen on my mac and right after that FPS becomes ~5000 (which is actually it should be always) And when I come back to screen where my window renders, FPS again becomes 120-140. I use MoltenVK and Vulkan SDK version 1.1.121 and I dont have such strange behaviour on windows. Obviously this is not normal. Does somebody knows why this can happen and how to fix that?
  6. Diligent Engine now implements some shadow rendering BKMs: - Cascaded shadow maps with cascade stabilization - PCF - Variance shadow maps - Two and four-component exponential variance shadow maps - Optimized fixed-size or world-sized filter kernels - Best cascade search based on projection into light space - Filtering across cascades - Various artifact removal techniques The main goal is to create a plug-and-play shadowing component that can be easily integrated into applications. The component consists of a shadow map manager and few shader functions. A Shadows sample demonstrates how to integrate Diligent shadows into an application. Check it out on GitHub: https://github.com/DiligentGraphics/DiligentEngine#high-level-rendering-components-1 I am planning to add exponential shadow maps and moment shadow maps later. Are there any state-of-the-art shadowing techniques that I should also take a look at? Credits: Variance Shadow Maps Shadow sample update by MJP Shadow Explorer sample from Intel Cascaded Shadow Maps technical article by Microsoft
  7. Hello, I am trying to find out how to download Vulkan SDK 1.1.110. Maybe I don't understand it correctly but Khronos released Vulkan headers for version 1.1.115 but latest SDK on LunarG is 1.1.108 which was released last month. But there are some programs like the Vulkan caps viewer by Sascha Willems which use Vulkan header 1.1.110. Vulkan headers GitHub repo: https://github.com/KhronosGroup/Vulkan-Headers So does this mean that the headers for version 1.1.110 will only work when LunarG releases Vulkan SDK 1.1.110 or am I missing something?
  8. Anyone had success in naming their vulkan objects via the extension VK_EXT_debug_utils? The extension is reported successfully, but when I have a call to vkSetDebugUtilsObjectNameEXT() function, the build cannot find the symbol for it. There is absolutely no documentation about whether I need to do anything specific for this: https://www.khronos.org/registry/vulkan/specs/1.1-extensions/man/html/vkSetDebugUtilsObjectNameEXT.html
  9. I cannot seem to eliminate some Vulkan debug layer errors regarding to incorrect texture layout (but the textures seem to work fine in practice). The debug layer is complaining that textures should be in VK_IMAGE_LAYOUT_GENERAL, but they are in VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL I am uploading texture data via vkCmdCopyBufferToImage using the copy queue, but later in the frame I will use those textures on the graphics queue. The textures are created with VK_IMAGE_LAYOUT_UNDEFINED initial layout, so before issuing vkCmdCopyBufferToImage , I transition them to VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, by inserting a barrier like this: VkImageMemoryBarrier barrier = {}; barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; barrier.image = (VkImage)pTexture2D->resource; barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; barrier.subresourceRange.baseArrayLayer = 0; barrier.subresourceRange.layerCount = pDesc->ArraySize; barrier.subresourceRange.baseMipLevel = 0; barrier.subresourceRange.levelCount = pDesc->MipLevels; barrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED; barrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; barrier.srcAccessMask = 0; barrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; vkCmdPipelineBarrier( copyCommandBuffer, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &barrier ); The src and dst queue families are ignored, because The following command using the texture is still executed on the copy queue: vkCmdCopyBufferToImage(copyCommandBuffer, textureUploader->resource, (VkImage)pTexture2D->resource, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, (uint32_t)copyRegions.size(), copyRegions.data()); Then I want to transition the texture from transferrable resource to VK_IMAGE_LAYOUT_GENERAL, to be used by the graphics pipeline, so I want to also transfer ownership to the graphics queue family with the barrier: barrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; barrier.newLayout = VK_IMAGE_LAYOUT_GENERAL; barrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT; barrier.srcQueueFamilyIndex = queueIndices.copyFamily; barrier.dstQueueFamilyIndex = queueIndices.graphicsFamily; vkCmdPipelineBarrier( copyCommandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, 0, nullptr, 0, nullptr, 1, &barrier ); The texture that I create like this will be either sampled by shaders, or used as read-write texture from compute shaders. Did I miss something, or can I not transfer image layout like this between queues?