Drawing a grid plane

[appcodegen]

Hi all,

is there some kind of support for doing this (a 2D planar grid really, shown in my 3d scene, which could be used as a 'floor' or a 'wall' etc) already in VSG? I tried creating the grid lines using the Builder's 'createCylinder' function (with a scale transform), which probably could also leverage instancing, but this does not really look 'right' to me. Am I missing something or is that yet to be done?

One alternative I could think of would be to simply use a textured quad, but I'm wondering if there isn't a simple 'line drawing' functionality (which could be useful in other circumstances as well..)

Thank you

[robertosfield]

A texture quad would be one way to do it, vsg::Builder can be used to do this quite conveniently.

Or just create the the geometry yourself. I wouldn't do it with cylinders, but would be much more expensive than just uses a grid of lines.

[robertosfield]

If you fancy playing with fragment shaders, one approach you could take is render the ground plan as a quad and then in fragment shader compute whether to use the base colour or line colour based on texture coordinate. It should be possible to compute a fragment proximity to the line positions you want and set the blending between the two colours to give you anti-aliased lines or vary the line width dynamically so that as you get closer the line width doesn't change in scene space.

With such a procedural approach you should be able to get really high quality results, but than can be achieved using lines or other geometry, or using texturing.

[robertosfield]

Ben Golus has written up work he's done of grid shader - this is the type of thing I was thinking of:

The Best Darn Grid Shader (Yet)

[appcodegen]

Thank you very much for your answers. I'm afraid that this is way beyond my (current, I hope) skill level but will certainly be useful for others!

[WdsPjm]

A while ago, based on this article [https://asliceofrendering.com/scene%20helper/2020/01/05/InfiniteGrid/], I implemented a grid plane. While it functions correctly, there are still some issues that I currently don't have the time to address. I'm sharing my code here in the hope that it can help others

                                                     cpp

#include
#include

#include "vsg/all.h"
#include "vsgXchange\all.h"

class ExtendedRasterizationState : public vsg::Inherit<vsg::RasterizationState, ExtendedRasterizationState>
{
public:
ExtendedRasterizationState() {}
ExtendedRasterizationState(const ExtendedRasterizationState& rs) :
Inherit(rs) {}

void apply(vsg::Context& context, VkGraphicsPipelineCreateInfo& pipelineInfo) const override
{

    VkPipelineVertexInputStateCreateInfo pipelineVertexInputStateCreateInfo{};
    pipelineVertexInputStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
    pipelineVertexInputStateCreateInfo.vertexAttributeDescriptionCount = 0;
    pipelineVertexInputStateCreateInfo.pVertexAttributeDescriptions = nullptr;
    pipelineVertexInputStateCreateInfo.vertexBindingDescriptionCount = 0;
    pipelineVertexInputStateCreateInfo.pVertexBindingDescriptions = nullptr;
    pipelineVertexInputStateCreateInfo.flags = 0;
    pipelineVertexInputStateCreateInfo.pNext = nullptr;

    // pipelineInfo.pDepthStencilState->depthTestEnable = VK_FALSE;

    // auto tmp = pipelineInfo;

    //  pipelineInfo.pVertexInputState = &pipelineVertexInputStateCreateInfo;

    // pipelineInfo.pVertexInputState = &pipelineVertexInputStateCreateInfo;

    // create and assign the VkPipelineRasterizationStateCreateInfo as usual using the base class that wil assign it to pipelineInfo.pRasterizationState
    RasterizationState::apply(context, pipelineInfo);

    /// setup extension feature (stippling) for attachment to pNext below
    auto rastLineStateCreateInfo = context.scratchMemory->allocate<VkPipelineRasterizationLineStateCreateInfoEXT>(1);
    rastLineStateCreateInfo->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT;
    rastLineStateCreateInfo->pNext = nullptr;
    rastLineStateCreateInfo->lineRasterizationMode = VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT;
    rastLineStateCreateInfo->stippledLineEnable = VK_TRUE;
    rastLineStateCreateInfo->lineStippleFactor = 4;
    rastLineStateCreateInfo->lineStipplePattern = 0b1111111100000000;

    // to assign rastLineStateCreateInfo to the pRasterizationState->pNext we have to cast away const first
    // this is safe as these objects haven't been passed to Vulkan yet
    auto pRasterizationState = const_cast<VkPipelineRasterizationStateCreateInfo*>(pipelineInfo.pRasterizationState);

    // pRasterizationState->pNext = rastLineStateCreateInfo;
}

protected:
virtual ~ExtendedRasterizationState() {}
};

int main(int argc, char** argv)
{
try
{
auto windowTraits = vsg::WindowTraits::create();
/// set up defaults and read command line arguments to override them
vsg::CommandLine arguments(&argc, argv);
windowTraits->debugLayer = true; // arguments.read({"--debug", "-d"});
windowTraits->apiDumpLayer = arguments.read({"--api", "-a"});
windowTraits->windowTitle = "vsgextendstate";

    //  auto requestFeatures = windowTraits->deviceFeatures = vsg::DeviceFeatures::create();

    windowTraits->vulkanVersion = VK_API_VERSION_1_3;
    // windowTraits->deviceExtensionNames.push_back(VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME);

    /// enable wideLines feature
    //  requestFeatures->get().wideLines = VK_TRUE;
    windowTraits->width = 300;
    windowTraits->height = 300;
    windowTraits->x = 900;
    windowTraits->y = 900;
    // create window now we have configured the windowTraits to set up the required features
    auto window = vsg::Window::create(windowTraits);
    if (!window)
    {
        std::cout << "Unable to create window" << std::endl;
        return 1;
    }

    auto sceneGraph = vsg::Group::create();
    vsg::Paths searchPaths = vsg::getEnvPaths("VSG_FILE_PATH");
    searchPaths.push_back("E:\\vsg\\20231225\\vsgExamples\\build\\bin\\Debug\\data");

    vsg::ref_ptr<vsg::ShaderStage> vertexShader = vsg::ShaderStage::read(VK_SHADER_STAGE_VERTEX_BIT, "main", vsg::findFile("shaders/grid.vert", searchPaths));
    vsg::ref_ptr<vsg::ShaderStage> fragmentShader = vsg::ShaderStage::read(VK_SHADER_STAGE_FRAGMENT_BIT, "main", vsg::findFile("shaders/grid.frag", searchPaths));

    auto shaderSet = vsg::ShaderSet::create(vsg::ShaderStages{vertexShader, fragmentShader});
    shaderSet->addPushConstantRange("pc", "", VK_SHADER_STAGE_VERTEX_BIT, 0, 128);
    shaderSet->addAttributeBinding("vertex", "", 0, VK_FORMAT_R32G32B32_SFLOAT, vsg::vec3Array::create(1));

    auto stateGroup = vsg::StateGroup::create();
    auto gpConf = vsg::GraphicsPipelineConfigurator::create(shaderSet);

    auto vertices = vsg::vec3Array::create({{1, 1, 0},
                                            {-1, -1, 0},
                                            {-1, 1, 0},
                                            {-1, -1, 0},
                                            {1, 1, 0},
                                            {1, -1, 0}});

    auto options = vsg::Options::create();
    // add vsgXchange's support for reading and writing 3rd party file formats
    options->add(vsgXchange::all::create());
    options->fileCache = vsg::getEnv("VSG_FILE_CACHE");
    options->paths = vsg::getEnvPaths("VSG_FILE_PATH");
    options->paths.push_back("E:\\vsg\\20231225\\vsgExamples\\build\\bin\\Debug\\data");
    vsg::Path filename = "E:\\vsg\\20231225\\vsgExamples\\build\\bin\\Debug\\data\\models\\deer.gltf";
    auto tmp = vsg::read_cast<vsg::Node>(filename, options);
    auto loaded_scene = vsg::MatrixTransform::create();

    loaded_scene->matrix = vsg::translate(vsg::dvec3(0.0, 0.0, 0.0)) * vsg::rotate(vsg::radians(90.0), 1.0, 0.0, 0.0) * vsg::translate(0.0, 0.0, 1.0);

    loaded_scene->addChild(tmp);

    stateGroup->addChild(loaded_scene);

    auto lookAt = vsg::LookAt::create(
        vsg::dvec3{0.0f, -5.f, -6.f},
        vsg::dvec3{0.f, 0.f, -1.f},
        vsg::dvec3{0.f, 0.f, 1.f});

    auto perspective = vsg::Perspective::create(45.0f, static_cast<double>(window->extent2D().width) / static_cast<double>(window->extent2D().height), 0.1, 120.5);

    auto viewportState = vsg::ViewportState::create(window->extent2D());
    auto camera = vsg::Camera::create(perspective, lookAt, viewportState);

    auto viewer = vsg::Viewer::create();

    viewer->addWindow(window);
    viewer->addEventHandler(vsg::CloseHandler::create(viewer));
    viewer->addEventHandler(vsg::Trackball::create(camera));
    window->clearColor() = VkClearColorValue{{0.1f, 0.1f, 0.1f, 1.0f}};
    auto commandGraph = vsg::createCommandGraphForView(window, camera, sceneGraph);
    viewer->assignRecordAndSubmitTaskAndPresentation({commandGraph});

    vsg::DataList vertexArrays;
    gpConf->assignArray(vertexArrays, "vertex", VK_VERTEX_INPUT_RATE_VERTEX, vertices);

    //  gpConf->assignDescriptor("ViewMat", tmpvec4);
    //  gpConf->assignDescriptor("PrjMat", tmpvec5);

    auto vertexDraw = vsg::VertexDraw::create();
    vertexDraw->assignArrays(vertexArrays);
    vertexDraw->vertexCount = vertices->width();
    vertexDraw->instanceCount = 1;
    stateGroup->addChild(vertexDraw);
    vertexDraw->vertexCount = 6;

    struct SetPipelineStates : public vsg::Visitor
    {
        void apply(vsg::Object& object) { object.traverse(*this); }
        void apply(vsg::RasterizationState& rs)
        {
            rs.cullMode = VK_CULL_MODE_NONE;
        }

        void apply(vsg::DepthStencilState& ds)
        {
            ds.depthTestEnable = VK_FALSE;
            ds.depthWriteEnable = VK_FALSE;
            ds.depthBoundsTestEnable = VK_FALSE;
        }
        void apply(vsg::ColorBlendState& cbs)
        {
            auto t = cbs.attachments.size();
            cbs.attachments[0].colorWriteMask = 0xf;
            cbs.attachments[0].blendEnable = VK_TRUE;

            cbs.attachments[0].colorBlendOp = VK_BLEND_OP_ADD;
            cbs.attachments[0].srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;
            cbs.attachments[0].dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
            cbs.attachments[0].alphaBlendOp = VK_BLEND_OP_ADD;
            cbs.attachments[0].srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE;
            cbs.attachments[0].dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO;
        }

    } sps;

    /// apply our custom RasterizationState to the GraphicsPipeline
    auto rs = ExtendedRasterizationState::create();
    gpConf->pipelineStates.push_back(rs);

    gpConf->accept(sps);
    gpConf->init();
    gpConf->copyTo(stateGroup);
    sceneGraph->addChild(stateGroup);

    viewer->compile();
    while (viewer->advanceToNextFrame())
    {
        viewer->handleEvents();
        viewer->update();
        viewer->recordAndSubmit();
        viewer->present();
    }
}
catch (const vsg::Exception& ve)
{
    // details of VkResult values: https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VkResult.html
    for (int i = 0; i < argc; ++i) std::cerr << argv[i] << " ";
    std::cerr << "\n[Exception] - " << ve.message << " result = " << ve.result << std::endl;
    return 1;
}

}

                                                                                 grid.vert

#version 450

#extension GL_EXT_debug_printf : enable

layout(push_constant) uniform PushConstants {

mat4 projectionMat;
mat4 modelViewMat;

}psh;

layout(set = 0, binding = 0) uniform PbrData{
mat4 inViewmat;
}mat;
//
layout(set = 0, binding =1) uniform prjMat{
mat4 inPrj;
}prj;

layout(location = 0) out vec3 nearPoint;
layout(location = 1) out vec3 farPoint;
layout(location = 2) out mat4 view;
layout(location = 6) out mat4 outprojection;

vec3 unprojectPoint(float x, float y, float z, mat4 viewProjectionInverse) {
vec4 clipSpacePos = vec4(x, y, z, 1.0);
vec4 eyeSpacePos = viewProjectionInverse * clipSpacePos;
return eyeSpacePos.xyz / eyeSpacePos.w;
}

vec3 gridPlane[6] = vec3[](
vec3(1, 1, 0), vec3(-1, -1, 0), vec3(-1, 1, 0),
vec3(-1, -1, 0), vec3(1, 1, 0), vec3(1, -1, 0)
);

void main() {

vec3 pos = gridPlane[gl_VertexIndex].xyz;


mat4 tmpMat =psh.modelViewMat ;





mat4 viewProjectionInverse = inverse(psh.projectionMat *tmpMat);
nearPoint =  unprojectPoint(pos.x, pos.y, 0.0, viewProjectionInverse);
farPoint = unprojectPoint(pos.x, pos.y, 1.0, viewProjectionInverse);
view = tmpMat;
outprojection = psh.projectionMat;


gl_Position =  vec4(pos, 1.0);

}

                                                                           grid.frag

#version 450
#extension GL_EXT_debug_printf : enable

layout(location = 0) in vec3 nearPoint;
layout(location = 1) in vec3 farPoint;
layout(location = 2) in mat4 view;
layout(location = 6) in mat4 projection;
layout(location = 0) out vec4 outColor;

vec4 grid(vec3 pos) {
vec2 coord = pos.xz;
vec2 derivative = fwidth(coord);
vec2 grid = abs(fract(coord - 0.5) - 0.5) / derivative;
float line = min(grid.x, grid.y);
float minimumz = min(derivative.y, 1);
float minimumx = min(derivative.x, 1);
vec4 color = vec4(0.5, 0.5, 1.0, 1.0 - min(line, 1.0));

if(abs(pos.x) < minimumx)
    color.y = 1;
if(abs(pos.z) < minimumz)
    color.x = 1;
return color;

}

float fadeFactor(vec3 pos) {
float z = (projection * view * vec4(pos.xyz, 1.0)).z;
// Empirical values are used to determine when to cut off the grid before moire patterns become visible.
return z * 6 - 0.5;
}

void main() {
float t = -nearPoint.y / (farPoint.y - nearPoint.y);
vec3 pos = nearPoint + t * (farPoint - nearPoint);

// Display only the lower plane
if(t < 1) {
    vec4 gridColor = grid(pos);
    outColor = vec4(gridColor.xyz, gridColor.w * fadeFactor(pos));
}
else
    outColor = vec4(0., 0., 0., 0.0);

//
// debugPrintfEXT ("fragshader %f", t);
// outColor = vec4(0.2, 0., 0., 1.0 * float(t > 1));
}