Eve is an open-source, cross-platform (Windows, Linux), simple and optimized graphics framework built to simplify Vulkan usage. Eve lets easily draw objects on the screen without losing performance and customization. Eve has a demo in the releases with a precompiled executable (Windows). You can use Eve by cloning this repository, more info on how to use Eve below.
Eve offers a demo, it is in the releases already precompiled for Windows. Linux users need to compile the code to get an executable. If you just want to try the executable on Windows you can directly install it, to compile the code (action needed for Linux users) all the below requirements must be met. You can find the releases and the Eve demo here
Eve's demo source code and executable are in the releases, check the source code if you want to learn more about on how to use Eve. More info on how to use them in the releases.
- OS: Windows, Linux
- Compiler and support for C++20
- CMake (3.28+)
- GPU drivers supporting Vulkan 1.2+
- Vulkan SDK (1.2+) (You can download it here)
To use Eve you need to clone this repository in your PC. You can directly copy the this repository or get the source code from releases which offers smaller download sizes.
Example (CMake Fetch Content):
cmake_minimum_required(VERSION 3.28)
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
project(YourProject LANGUAGES C CXX)
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)
include(FetchContent)
FetchContent_Declare(
Eve
GIT_REPOSITORY https://github.com/SonoUnBot09/Eve
GIT_TAG v1.0.0
)
FetchContent_MakeAvailable(Eve)
add_executable(YourProject
main.cpp
)
target_link_libraries(YourProject PRIVATE Eve)
To see how you can use Eve go here. To directly see how you can initialize Eve go here.
- Render Graph: Automatically inserts barriers where necessary; it employs memory aliasing and resource pooling to enhance performance.
- Custom ECS: A Unity DOTS-style ECS approach that utilizes archetypes and minimizes CPU cache misses to enhance performance.
- Material System: Allows properties to be set simply by using their names as defined in the shader
- Input System: A simple and efficient Input System that lets intercept keyboard and mouse inputs.
- Immediate UI Support: A small wrapper around ImGui that makes it extremely simple and fast to use for creating basic UIs.
- Compute Shaders: Compute support is included to enhance general performance and parallelize task on the GPU.
- Mesh System: A simple and fully customizable Mesh System which lets handle Meshes and their buffers.
Some Eve methods to understand a little bit how to use the engine. If you want to go deeper and understand better how to use Eve go here.
// Register the transform component
ComponentsRegistry::RegisterComponent<Transform>();
EntityCommandInfo entityCommandInfo{};
// Initialize a transform
Transform transform
{
{static_cast<float>(x),static_cast<float>(y),static_cast<float>(z)},
glm::quat(1.0, 0.0f, 0.0f, 0.0f),
{1,1,1}
};
// Adds the transform component to the entity command info
entityCommandInfo.AddComponent<Transform>(transform);
// Create an entity with the transform component
EntityManager::ScheduleCreationCommand(&entityCommandInfo, systemId);
// Get the the archtype
Type componentsRequired = ComponentsRegistry::GetComponentMask<Transform, Camera>();
QueryInfo queryInfo
{
componentsRequired,
true
};
// Searching through all the archtypes
QueryResult& queryResult = EntityManager::GetTables(queryInfo);
// Get the first archtype found
Table& table = queryResult.GetTable(0);
// Get each component types
Type cameraComponentType = ComponentsRegistry::GetComponentBit<Camera>();
Type transformComponentType = ComponentsRegistry::GetComponentBit<Transform>();
// Get the transform and the entity component from the first entity
Transform& transform = table.GetComponent<Transform>(0, transformComponentType);
Camera& camera = table.GetComponent<Camera>(0, cameraComponentType);
// Create a cube mesh
MeshHandle mesh = Graphics::CreateCubeMesh();
// Get window size
glm::ivec2 windowSize = Window::GetWindowSize();
TransientTextureInfo2D colorInfo
{
.Width = static_cast<uint32_t>(windowSize.x),
.Height = static_cast<uint32_t>(windowSize.y),
.Format = Format::FORMAT_R8G8B8A8_SRGB
};
// Create a transient color texture with the window size (managed by the Render Graph)
TransientTextureHandle colorTexture = Graphics::RequestTransientTexture2D(colorInfo);
// Draw call
pass.Draw(gfxMesh.IndicesCount, transforms.data(), material, camera.renderView, &drawParams);
// Set the texture to be presented on the screen
Graphics::SetPresentTexture2D(colorTexture);
