CEGUI Wiki - Crazy Eddie's GUI System (Open Source) - User contributions [en]

Vulkan Renderer Development

2016-06-22T14:22:37Z

Xxarthurxx: /* Links */

== Purpose of this document ==
* Provide relevant links to Vulkan documentation, Vulkan tutorials, Vulkan code snippets that we will use during development
* Make a list of specific points we need to take into account when developing the Vulkan renderer for CEGUI:
** What are the problems/restrictions we need to consider? What should we keep in mind?
** How can we maximize Vulkan performance?
** What are the restrictions? How could we get around them?
* Keep track of the state of the development

== References ==
===Links===

* Intel Vulkan Tutorial: https://software.intel.com/en-us/articles/api-without-secrets-introduction-to-vulkan-part-1
* QuickRef: https://www.khronos.org/registry/vulkan/specs/1.0/refguide/Vulkan-1.0-web.pdf
* Set of demos: https://github.com/SaschaWillems/Vulkan
* Good old triangle demo: https://github.com/SaschaWillems/Vulkan/blob/master/triangle/triangle.cpp
* Vulkan in 30 minutes https://renderdoc.org/vulkan-in-30-minutes.html

===Books===
* Not yet released, not sure if worth it: Vulkan Programming Guide by John M. Kessenich and Graham Sellers: https://www.amazon.co.uk/Vulkan-Programming-Guide-Official-Learning/dp/0134464540

== CEGUI Vulkan Renderer : Thoughts ==

=== General considerations ===

* As of now, CEGUI does not support any kind of internal threading.
* If we have separate command buffers for CEGUI and the rest of what the user's application uses, we can ensure that the states won't interfere with those of the regular rendering. (See enableExtraAttribs for more info..). This is a great advantage over OpenGL.
* Would any sort of threading for CEGUI's logic and rendering provide an advantage? In the end, the rendering would always have to wait for the logic to be processed but they could be started at separate times.

=== Points to achieve optimal performance with the CEGUI Vulkan Renderer ===
* Considering that Vulkan as one of its main benefits features threading support, we want to research whether this would be worth it for CEGUI default branch.
* As always, we need to keep batching low. Is there anything provided in Vulkan that allows us to batch things better? We used to make the VBOs as large as possible, which was a notable advantage even though we rendered the quads in separate draw calls. Can this be done better?

== ToDo ==

== State of development ==
Nvidia C++ Wrapper for Vulkan will be used. This Wrapper contains of a single header file. For CEGUI this means, that the single header needs to be namespaced in CEGUI and will be bundled with the Vulkan Renderer. For further building informations, please look into the repository:
* Repo link: https://github.com/nvpro-pipeline/vkcpp
* Vulkan registry: https://github.com/KhronosGroup/Vulkan-Docs/blob/1.0/src/spec/vk.xml

Vulkan Renderer Development

2016-06-20T15:49:35Z

Xxarthurxx: /* State of development */

== Purpose of this document ==
* Provide relevant links to Vulkan documentation, Vulkan tutorials, Vulkan code snippets that we will use during development
* Make a list of specific points we need to take into account when developing the Vulkan renderer for CEGUI:
** What are the problems/restrictions we need to consider? What should we keep in mind?
** How can we maximize Vulkan performance?
** What are the restrictions? How could we get around them?
* Keep track of the state of the development

== References ==
===Links===

*Intel Vulkan Tutorial: https://software.intel.com/en-us/articles/api-without-secrets-introduction-to-vulkan-part-1

===Books===
*Vulkan Programming Guide by John M. Kessenich and Graham Sellers: https://www.amazon.co.uk/Vulkan-Programming-Guide-Official-Learning/dp/0134464540

== CEGUI Vulkan Renderer : Thoughts ==

=== General considerations ===

* As of now, CEGUI does not support any kind of internal threading.
* If we have separate command buffers for CEGUI and the rest of what the user's application uses, we can ensure that the states won't interfere with those of the regular rendering. (See enableExtraAttribs for more info..). This is a great advantage over OpenGL.
* Would any sort of threading for CEGUI's logic and rendering provide an advantage? In the end, the rendering would always have to wait for the logic to be processed but they could be started at separate times.

=== Improving CEGUI with the Vulkan Renderer ===
* Considering that Vulkan as one of its main benefits features threading support, we want to research whether this would be worth it for CEGUI default branch or if this even would have any benefits.
* As always, we need to keep batching low. Is there anything provided in Vulkan that allows us to batch things better? We used to make the VBOs as large as possible, which was a notable advantage even though we rendered the quads in separate draw calls. Can this be done better?

== ToDo ==

== State of development ==
Nvidia C++ Wrapper for Vulkan will be used. This Wrapper contains of a single header file. For CEGUI this means, that the single header needs to be namespaced in CEGUI and will be bundled with the Vulkan Renderer. For further building informations, please look into the repository:

- Repo link: https://github.com/nvpro-pipeline/vkcpp

- Vulkan registry: https://github.com/KhronosGroup/Vulkan-Docs/blob/1.0/src/spec/vk.xml

----
[[User:Xxarthurxx|Xxarthurxx]] ([[User talk:Xxarthurxx|talk]]) 15:49, 20 June 2016 (UTC)

Vulkan Renderer Development

2016-06-20T15:43:36Z

Xxarthurxx: /* Books */

== Purpose of this document ==
* Provide relevant links to Vulkan documentation, Vulkan tutorials, Vulkan code snippets that we will use during development
* Make a list of specific points we need to take into account when developing the Vulkan renderer for CEGUI:
** What are the problems/restrictions we need to consider? What should we keep in mind?
** How can we maximize Vulkan performance?
** What are the restrictions? How could we get around them?
* Keep track of the state of the development

== References ==
===Links===

*Intel Vulkan Tutorial: https://software.intel.com/en-us/articles/api-without-secrets-introduction-to-vulkan-part-1

===Books===
*Vulkan Programming Guide by John M. Kessenich and Graham Sellers: https://www.amazon.co.uk/Vulkan-Programming-Guide-Official-Learning/dp/0134464540

== CEGUI Vulkan Renderer : Thoughts ==

=== General considerations ===

* As of now, CEGUI does not support any kind of internal threading.
* If we have separate command buffers for CEGUI and the rest of what the user's application uses, we can ensure that the states won't interfere with those of the regular rendering. (See enableExtraAttribs for more info..). This is a great advantage over OpenGL.
* Would any sort of threading for CEGUI's logic and rendering provide an advantage? In the end, the rendering would always have to wait for the logic to be processed but they could be started at separate times.

=== Improving CEGUI with the Vulkan Renderer ===
* Considering that Vulkan as one of its main benefits features threading support, we want to research whether this would be worth it for CEGUI default branch or if this even would have any benefits.
* As always, we need to keep batching low. Is there anything provided in Vulkan that allows us to batch things better? We used to make the VBOs as large as possible, which was a notable advantage even though we rendered the quads in separate draw calls. Can this be done better?

== ToDo ==

== State of development ==
* We will use the Nvidia C++ Wrapper for Vulkan by creating the header file based on the Vulkan registry. This header needs to be namespaced in CEGUI and will be bundled with the Vulkan Renderer.
** Repo: https://github.com/nvpro-pipeline/vkcpp
** Vulkan registriy: https://github.com/KhronosGroup/Vulkan-Docs/blob/1.0/src/spec/vk.xml

Vulkan Renderer Development

2016-06-20T15:42:59Z

Xxarthurxx: /* Links */

== Purpose of this document ==
* Provide relevant links to Vulkan documentation, Vulkan tutorials, Vulkan code snippets that we will use during development
* Make a list of specific points we need to take into account when developing the Vulkan renderer for CEGUI:
** What are the problems/restrictions we need to consider? What should we keep in mind?
** How can we maximize Vulkan performance?
** What are the restrictions? How could we get around them?
* Keep track of the state of the development

== References ==
===Links===

*Intel Vulkan Tutorial: https://software.intel.com/en-us/articles/api-without-secrets-introduction-to-vulkan-part-1

===Books===
Vulkan Programming Guide by John M. Kessenich and Graham Sellers:
https://www.amazon.co.uk/Vulkan-Programming-Guide-Official-Learning/dp/0134464540

== CEGUI Vulkan Renderer : Thoughts ==

=== General considerations ===

* As of now, CEGUI does not support any kind of internal threading.
* If we have separate command buffers for CEGUI and the rest of what the user's application uses, we can ensure that the states won't interfere with those of the regular rendering. (See enableExtraAttribs for more info..). This is a great advantage over OpenGL.
* Would any sort of threading for CEGUI's logic and rendering provide an advantage? In the end, the rendering would always have to wait for the logic to be processed but they could be started at separate times.

=== Improving CEGUI with the Vulkan Renderer ===
* Considering that Vulkan as one of its main benefits features threading support, we want to research whether this would be worth it for CEGUI default branch or if this even would have any benefits.
* As always, we need to keep batching low. Is there anything provided in Vulkan that allows us to batch things better? We used to make the VBOs as large as possible, which was a notable advantage even though we rendered the quads in separate draw calls. Can this be done better?

== ToDo ==

== State of development ==
* We will use the Nvidia C++ Wrapper for Vulkan by creating the header file based on the Vulkan registry. This header needs to be namespaced in CEGUI and will be bundled with the Vulkan Renderer.
** Repo: https://github.com/nvpro-pipeline/vkcpp
** Vulkan registriy: https://github.com/KhronosGroup/Vulkan-Docs/blob/1.0/src/spec/vk.xml

Vulkan Renderer Development

2016-06-20T15:42:48Z

Xxarthurxx: /* Books */

== Purpose of this document ==
* Provide relevant links to Vulkan documentation, Vulkan tutorials, Vulkan code snippets that we will use during development
* Make a list of specific points we need to take into account when developing the Vulkan renderer for CEGUI:
** What are the problems/restrictions we need to consider? What should we keep in mind?
** How can we maximize Vulkan performance?
** What are the restrictions? How could we get around them?
* Keep track of the state of the development

== References ==
===Links===

**Intel Vulkan Tutorial: https://software.intel.com/en-us/articles/api-without-secrets-introduction-to-vulkan-part-1

===Books===
Vulkan Programming Guide by John M. Kessenich and Graham Sellers:
https://www.amazon.co.uk/Vulkan-Programming-Guide-Official-Learning/dp/0134464540

== CEGUI Vulkan Renderer : Thoughts ==

=== General considerations ===

* As of now, CEGUI does not support any kind of internal threading.
* If we have separate command buffers for CEGUI and the rest of what the user's application uses, we can ensure that the states won't interfere with those of the regular rendering. (See enableExtraAttribs for more info..). This is a great advantage over OpenGL.
* Would any sort of threading for CEGUI's logic and rendering provide an advantage? In the end, the rendering would always have to wait for the logic to be processed but they could be started at separate times.

=== Improving CEGUI with the Vulkan Renderer ===
* Considering that Vulkan as one of its main benefits features threading support, we want to research whether this would be worth it for CEGUI default branch or if this even would have any benefits.
* As always, we need to keep batching low. Is there anything provided in Vulkan that allows us to batch things better? We used to make the VBOs as large as possible, which was a notable advantage even though we rendered the quads in separate draw calls. Can this be done better?

== ToDo ==

== State of development ==
* We will use the Nvidia C++ Wrapper for Vulkan by creating the header file based on the Vulkan registry. This header needs to be namespaced in CEGUI and will be bundled with the Vulkan Renderer.
** Repo: https://github.com/nvpro-pipeline/vkcpp
** Vulkan registriy: https://github.com/KhronosGroup/Vulkan-Docs/blob/1.0/src/spec/vk.xml

Vulkan Renderer Development

2016-06-20T13:32:53Z

Xxarthurxx: /* Maximising the CEGUI Vulkan Renderer performance */

== Purpose of this document ==
* Provide relevant links to Vulkan documentation, Vulkan tutorials, Vulkan code snippets that we will use during development
* Make a list of specific points we need to take into account when developing the Vulkan renderer for CEGUI:
** What are the problems/restrictions we need to consider? What should we keep in mind?
** How can we maximize Vulkan performance?
** What are the restrictions? How could we get around them?
* Keep track of the state of the development

== References ==
===Links===

**Intel Vulkan Tutorial: https://software.intel.com/en-us/articles/api-without-secrets-introduction-to-vulkan-part-1

===Books===
Currently there aren't any books about Vulkan.

== CEGUI Vulkan Renderer : Thoughts ==

=== General considerations ===

* As of now, CEGUI does not support any kind of internal threading.
* If we have separate command buffers for CEGUI and the rest of what the user's application uses, we can ensure that the states won't interfere with those of the regular rendering. (See enableExtraAttribs for more info..). This is a great advantage over OpenGL.
* Would any sort of threading for CEGUI's logic and rendering provide an advantage? In the end, the rendering would always have to wait for the logic to be processed but they could be started at separate times.

=== Improving CEGUI with the Vulkan Renderer ===
* Considering that Vulkan as one of its main benefits features threading support, we want to research whether this would be worth it for CEGUI default branch or if this even would have any benefits.
* As always, we need to keep batching low. Is there anything provided in Vulkan that allows us to batch things better? We used to make the VBOs as large as possible, which was a notable advantage even though we rendered the quads in separate draw calls. Can this be done better?

== ToDo ==

== State of development ==
* We will use the Nvidia C++ Wrapper for Vulkan by creating the header file based on the Vulkan registry. This header needs to be namespaced in CEGUI and will be bundled with the Vulkan Renderer.
** Repo: https://github.com/nvpro-pipeline/vkcpp
** Vulkan registriy: https://github.com/KhronosGroup/Vulkan-Docs/blob/1.0/src/spec/vk.xml

Vulkan Renderer Development

2016-06-20T13:28:15Z

Xxarthurxx: Added Links

== Purpose of this document ==
* Provide relevant links to Vulkan documentation, Vulkan tutorials, Vulkan code snippets that we will use during development
* Make a list of specific points we need to take into account when developing the Vulkan renderer for CEGUI:
** What are the problems/restrictions we need to consider? What should we keep in mind?
** How can we maximize Vulkan performance?
** What are the restrictions? How could we get around them?
* Keep track of the state of the development

== References ==
===Links===

**Intel Vulkan Tutorial: https://software.intel.com/en-us/articles/api-without-secrets-introduction-to-vulkan-part-1

===Books===
Currently there aren't any books about Vulkan.

== CEGUI Vulkan Renderer : Thoughts ==

=== General considerations ===

* As of now, CEGUI does not support any kind of internal threading.
* If we have separate command buffers for CEGUI and the rest of what the user's application uses, we can ensure that the states won't interfere with those of the regular rendering. (See enableExtraAttribs for more info..). This is a great advantage over OpenGL.
* Would any sort of threading for CEGUI's logic and rendering provide an advantage? In the end, the rendering would always have to wait for the logic to be processed but they could be started at separate times.

=== Maximising the CEGUI Vulkan Renderer performance ===
* Considering that Vulkan as one of its main benefits features threading support, we might want to consider if this would be worth it for CEGUI default branch or if this even would have any benefits.
* As always, we need to keep batching low. Is there anything provided in Vulkan that allows us to batch things better? We used to make the VBOs as large as possible, which was a notable advantage even though we rendered the quads in separate draw calls. Can this be done better?

== ToDo ==

== State of development ==
* We will use the Nvidia C++ Wrapper for Vulkan by creating the header file based on the Vulkan registry. This header needs to be namespaced in CEGUI and will be bundled with the Vulkan Renderer.
** Repo: https://github.com/nvpro-pipeline/vkcpp
** Vulkan registriy: https://github.com/KhronosGroup/Vulkan-Docs/blob/1.0/src/spec/vk.xml