ernie-renderer 0.2.0.dev150__tar.gz → 0.2.0.dev153__tar.gz

{ernie_renderer-0.2.0.dev150 → ernie_renderer-0.2.0.dev153}/CMakeLists.txt

@@ -15,7 +15,7 @@ project(
 )
 
 # Pre-release suffix such as .dev12, written by CI.
-set(ERNIE_VERSION_SUFFIX ".dev150" CACHE STRING "Pre-release suffix of Ernie's version")
+set(ERNIE_VERSION_SUFFIX ".dev153" CACHE STRING "Pre-release suffix of Ernie's version")
 set(ERNIE_VERSION "${PROJECT_VERSION}${ERNIE_VERSION_SUFFIX}")
 
 option(ERNIE_BUILD_TESTS "Build Ernie's tests" OFF)

{ernie_renderer-0.2.0.dev150 → ernie_renderer-0.2.0.dev153}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ernie-renderer
-Version: 0.2.0.dev150
+Version: 0.2.0.dev153
 Summary: Efficient Renderer for Natural and Interplanetary Environments: a physically based, spectral Vulkan ray tracer
 Author: Alex Maietta
 License-Expression: BSD-3-Clause

{ernie_renderer-0.2.0.dev150 → ernie_renderer-0.2.0.dev153}/benchmarks/render/batch_step.cpp

@@ -25,11 +25,10 @@ namespace ernie::bench {
 namespace {
 
 constexpr int kShapesPerWorld = 8;
-constexpr glm::uvec2 kSize{64, 64};
 
 /// @brief A scene of `worlds` worlds side by side, each with shapes scattered in front of its
-/// camera, and the products rendering every camera's colour and depth.
-void BuildWorlds(Scene& scene, int worlds) {
+/// camera, and the products rendering every camera's colour and depth at `size` pixels.
+void BuildWorlds(Scene& scene, int worlds, glm::uvec2 size) {
     GroundPlane::Define(scene, "/Ground");
     const std::vector<Path> vars{Path("/Render/Vars/Colour"), Path("/Render/Vars/Depth")};
     RenderVar::Define(scene, vars[0]).SetSourceName(std::string(render_vars::kLdrColor));
@@ -58,13 +57,13 @@ void BuildWorlds(Scene& scene, int worlds) {
         products.emplace_back("/Render/View" + std::to_string(world));
         RenderProduct::Define(scene, products.back())
             .SetCamera(camera)
-            .SetResolution(glm::dvec2(kSize))
+            .SetResolution(glm::dvec2(size))
             .SetOrderedVars(vars);
     }
     RenderSettings::Define(scene, "/Render/Settings").SetProducts(products);
 }
 
-Timing StepWorlds(int worlds, double targetMs) {
+Timing StepWorlds(int worlds, glm::uvec2 size, double targetMs) {
     std::unique_ptr<Renderer> renderer;
     try {
         renderer = std::make_unique<Renderer>();
@@ -73,7 +72,7 @@ Timing StepWorlds(int worlds, double targetMs) {
         return {0.0, targetMs};
     }
     Scene scene;
-    BuildWorlds(scene, worlds);
+    BuildWorlds(scene, worlds, size);
     // The first step builds every bottom level; later ones rebuild only the top levels.
     renderer->Step(scene);
     renderer->Context().WaitIdle();
@@ -84,8 +83,10 @@ Timing StepWorlds(int worlds, double targetMs) {
                                   renderer->Step(scene);
                                   renderer->Context().WaitIdle();
                               });
-    std::printf("  %d views of %u x %u: %.0f views a second, %.2f ms submitting, on %s\n", worlds,
-                kSize.x, kSize.y, 1000.0 * worlds / ms, host,
+    const double pixels = static_cast<double>(worlds) * size.x * size.y;
+    std::printf("  %d views of %u x %u: %.0f views, %.2f gigapixels a second, %.2f ms submitting, "
+                "on %s\n",
+                worlds, size.x, size.y, 1000.0 * worlds / ms, pixels / ms / 1e6, host,
                 renderer->Context().Info().name.c_str());
     if (std::getenv("ERNIE_BENCH_PROFILE") != nullptr) {
         profiler::SetEnabled(true);
@@ -105,10 +106,17 @@ Timing StepWorlds(int worlds, double targetMs) {
     return {ms, targetMs};
 }
 
-const bool kBatch1k =
-    Register("render.batch_step.1024_worlds_64x64", [] { return StepWorlds(1024, 5.0); });
-const bool kBatch4k =
-    Register("render.batch_step.4096_worlds_64x64", [] { return StepWorlds(4096, 20.0); });
+/// Registers a step of `worlds` views of `side` x `side` pixels.
+bool RegisterBatch(int worlds, std::uint32_t side, double targetMs) {
+    return Register("render.batch_step." + std::to_string(worlds) + "_worlds_" +
+                        std::to_string(side) + "x" + std::to_string(side),
+                    [=] { return StepWorlds(worlds, glm::uvec2(side), targetMs); });
+}
+
+// Madrona's benchmark resolutions, then beyond, at 1024 worlds; and many worlds at 64 x 64.
+const bool kBatches = RegisterBatch(1024, 64, 5.0) && RegisterBatch(1024, 128, 15.0) &&
+                      RegisterBatch(1024, 256, 50.0) && RegisterBatch(1024, 512, 200.0) &&
+                      RegisterBatch(4096, 64, 20.0);
 
 }  // namespace
 }  // namespace ernie::bench

{ernie_renderer-0.2.0.dev150 → ernie_renderer-0.2.0.dev153}/cmake/third_party/dear_imgui.cmake

@@ -19,13 +19,18 @@ add_library(
     "${dear_imgui_SOURCE_DIR}/imgui_draw.cpp"
     "${dear_imgui_SOURCE_DIR}/imgui_tables.cpp"
     "${dear_imgui_SOURCE_DIR}/imgui_widgets.cpp"
+    # Text fields over std::string.
+    "${dear_imgui_SOURCE_DIR}/misc/cpp/imgui_stdlib.cpp"
     # Vulkan functions come from volk, as in the device layer.
     "${dear_imgui_SOURCE_DIR}/backends/imgui_impl_vulkan.cpp"
 )
 target_include_directories(
     ernie_imgui
     SYSTEM
-    PUBLIC "${dear_imgui_SOURCE_DIR}" "${dear_imgui_SOURCE_DIR}/backends"
+    PUBLIC
+        "${dear_imgui_SOURCE_DIR}"
+        "${dear_imgui_SOURCE_DIR}/backends"
+        "${dear_imgui_SOURCE_DIR}/misc/cpp"
 )
 target_compile_definitions(ernie_imgui PUBLIC IMGUI_IMPL_VULKAN_USE_VOLK)
 target_link_libraries(ernie_imgui PUBLIC ernie_volk)

{ernie_renderer-0.2.0.dev150 → ernie_renderer-0.2.0.dev153}/ernie/app/CMakeLists.txt

@@ -3,7 +3,7 @@ include("${PROJECT_SOURCE_DIR}/cmake/third_party/glfw.cmake")
 include("${PROJECT_SOURCE_DIR}/cmake/third_party/dear_imgui.cmake")
 
 # The viewer: its window, panels and frame loop, a library so tests drive it without a window.
-add_library(ernie_viewer STATIC imgui_backend.cpp ui.cpp viewer.cpp)
+add_library(ernie_viewer STATIC create.cpp imgui_backend.cpp ui.cpp viewer.cpp)
 target_link_libraries(
     ernie_viewer
     PUBLIC ernie_static ernie_imgui ernie_volk ernie_vma

ernie_renderer-0.2.0.dev153/ernie/app/create.cpp

@@ -0,0 +1,157 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file create.cpp
+/// @brief The Create menu's types and the defaults each new prim is authored with.
+#include "ernie/app/create.h"
+
+#include "ernie/scene/schema/camera.h"
+#include "ernie/scene/schema/geom.h"
+#include "ernie/scene/schema/lux.h"
+#include "ernie/scene/schema/mesh.h"
+#include "ernie/scene/schema/planet.h"
+#include "ernie/scene/schema/render.h"
+#include "ernie/scene/schema/shade.h"
+#include "ernie/scene/tokens.h"
+#include "ernie/scene/xform.h"
+
+#include <glm/gtc/matrix_transform.hpp>
+
+#include <array>
+#include <cmath>
+#include <stdexcept>
+#include <string>
+
+namespace ernie::app {
+namespace {
+
+constexpr std::array kTypes{
+    CreatableType{Xform::kName, "Xform", "Organize", "Xform", "/World"},
+    CreatableType{Scope::kName, "Scope", "Organize", "Scope", "/World"},
+    CreatableType{Cube::kName, "Cube", "Geometry", "Cube", "/World"},
+    CreatableType{Sphere::kName, "Sphere", "Geometry", "Sphere", "/World"},
+    CreatableType{Cylinder::kName, "Cylinder", "Geometry", "Cylinder", "/World"},
+    CreatableType{Cone::kName, "Cone", "Geometry", "Cone", "/World"},
+    CreatableType{Capsule::kName, "Capsule", "Geometry", "Capsule", "/World"},
+    CreatableType{Plane::kName, "Plane", "Geometry", "Plane", "/World"},
+    CreatableType{Mesh::kName, "Mesh (Quad)", "Geometry", "Mesh", "/World"},
+    CreatableType{GroundPlane::kName, "Ground Plane", "Geometry", "Ground", "/World"},
+    CreatableType{DistantLight::kName, "Distant Light", "Lights", "Sun", "/World"},
+    CreatableType{SphereLight::kName, "Sphere Light", "Lights", "SphereLight", "/World"},
+    CreatableType{RectLight::kName, "Rect Light", "Lights", "RectLight", "/World"},
+    CreatableType{DiskLight::kName, "Disk Light", "Lights", "DiskLight", "/World"},
+    CreatableType{CylinderLight::kName, "Cylinder Light", "Lights", "CylinderLight", "/World"},
+    CreatableType{DomeLight::kName, "Dome Light", "Lights", "Dome", "/World"},
+    CreatableType{Camera::kName, "Camera from View", "Cameras", "Camera", "/World"},
+    CreatableType{Material::kName, "Material", "Shading", "Material", "/Looks"},
+    CreatableType{RenderSettings::kName, "Render Settings", "Render", "Settings", "/Render"},
+    CreatableType{RenderProduct::kName, "Render Product", "Render", "Product", "/Render"},
+    CreatableType{RenderVar::kName, "Render Var", "Render", "Var", "/Render/Vars"},
+};
+
+/// @brief Places the prim at world `at`, scaled by `scale`, under its parent.
+void Place(Scene& scene, const Path& path, const CreateContext& context, const glm::dvec3& at,
+           double scale) {
+    const glm::dmat4 world = glm::scale(glm::translate(glm::dmat4(1.0), at), glm::dvec3(scale));
+    scene.Set(path, tokens::kTransform, glm::inverse(context.parentWorld) * world);
+}
+
+/// @brief Places a light three view scales above the target, facing down at it.
+void PlaceAbove(Scene& scene, const Path& path, const CreateContext& context) {
+    const glm::dvec3 eye = context.target + glm::dvec3(0.0, 0.0, 3.0 * context.scale);
+    scene.Set(path, tokens::kTransform,
+              glm::inverse(context.parentWorld) *
+                  LookAtTransform(eye, context.target, {0.0, 1.0, 0.0}));
+}
+
+void AuthorQuad(Scene& scene, const Path& path) {
+    const std::array<float, 12> points{-1, -1, 0, 1, -1, 0, 1, 1, 0, -1, 1, 0};
+    const std::array<std::int32_t, 1> counts{4};
+    const std::array<std::int32_t, 4> indices{0, 1, 2, 3};
+    scene.Write(scene.Require(path), Mesh::kPoints,
+                Tensor::Copy<float>(std::span<const float>(points), {4, 3}));
+    scene.Write(scene.Require(path), Mesh::kFaceVertexCounts,
+                Tensor::Copy<std::int32_t>(std::span<const std::int32_t>(counts), {1}));
+    scene.Write(scene.Require(path), Mesh::kFaceVertexIndices,
+                Tensor::Copy<std::int32_t>(std::span<const std::int32_t>(indices), {4}));
+}
+
+/// @brief Sizes an area light to the view's scale.
+void SizeAreaLight(Scene& scene, const Path& path, std::string_view type, double s) {
+    if (type == SphereLight::kName) {
+        SphereLight(scene, path).SetRadius(0.1 * s);
+    } else if (type == RectLight::kName) {
+        RectLight(scene, path).SetWidth(s).SetHeight(s);
+    } else if (type == DiskLight::kName) {
+        DiskLight(scene, path).SetRadius(0.5 * s);
+    } else if (type == CylinderLight::kName) {
+        CylinderLight(scene, path).SetLength(s).SetRadius(0.05 * s);
+    }
+}
+
+/// @brief Gives a camera the view's pose and field of view, on its default film.
+void AuthorCameraFromView(Scene& scene, const Path& path, const CreateContext& context) {
+    Camera camera(scene, path);
+    const double aperture = camera.GetVerticalAperture();
+    camera.SetFocalLength(0.5 * aperture / std::tan(0.5 * context.verticalFov));
+    scene.Set(path, tokens::kTransform, glm::inverse(context.parentWorld) * context.view);
+}
+
+}  // namespace
+
+std::span<const CreatableType> CreatableTypes() {
+    return kTypes;
+}
+
+const CreatableType* FindCreatable(std::string_view type) {
+    for (const CreatableType& creatable : kTypes) {
+        if (creatable.type == type) {
+            return &creatable;
+        }
+    }
+    return nullptr;
+}
+
+void AuthorDefaultPrim(Scene& scene, const Path& path, std::string_view type,
+                       const CreateContext& context) {
+    if (FindCreatable(type) == nullptr) {
+        throw std::invalid_argument("The viewer cannot create a '" + std::string(type) + "'");
+    }
+    scene.Define(path, type);
+    const double s = context.scale;
+    const bool areaLight = type == SphereLight::kName || type == RectLight::kName ||
+                           type == DiskLight::kName || type == CylinderLight::kName;
+    if (type == Mesh::kName) {
+        AuthorQuad(scene, path);
+    }
+    if (type == Cube::kName || type == Sphere::kName || type == Cylinder::kName ||
+        type == Cone::kName || type == Capsule::kName || type == Plane::kName ||
+        type == Mesh::kName) {
+        Place(scene, path, context, context.target, s);
+        scene.Set(path, Gprim::kDisplayColor, glm::dvec3(0.7));
+    } else if (type == Xform::kName) {
+        Place(scene, path, context, context.target, 1.0);
+    } else if (type == GroundPlane::kName) {
+        Place(scene, path, context, glm::dvec3(0.0, 0.0, context.target.z), 1.0);
+    } else if (type == DistantLight::kName) {
+        scene.Set(path, tokens::kTransform, DistantLightTransform({0.4, -0.5, 0.75}));
+    } else if (areaLight) {
+        PlaceAbove(scene, path, context);
+        SizeAreaLight(scene, path, type, s);
+    } else if (type == Camera::kName) {
+        AuthorCameraFromView(scene, path, context);
+    } else if ((type == RenderSettings::kName || type == RenderProduct::kName) &&
+               !context.camera.IsEmpty()) {
+        scene.Set(path, RenderSettingsBase::kCamera, context.camera);
+    } else if (type == RenderVar::kName) {
+        RenderVar(scene, path).SetSourceName(std::string(render_vars::kLdrColor));
+    }
+}
+
+Path FreeChildPath(const Scene& scene, const Path& parent, std::string_view name) {
+    Path path = parent.Child(name);
+    for (int number = 1; scene.Find(path); ++number) {
+        path = parent.Child(std::string(name) + std::to_string(number));
+    }
+    return path;
+}
+
+}  // namespace ernie::app

ernie_renderer-0.2.0.dev153/ernie/app/create.h

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file create.h
+/// @brief The viewer's Create menu: the prim types it makes, and the defaults that make each show.
+#pragma once
+
+#include "ernie/scene/path.h"
+#include "ernie/scene/scene.h"
+
+#include <glm/mat4x4.hpp>
+#include <glm/vec3.hpp>
+
+#include <span>
+#include <string_view>
+
+namespace ernie::app {
+
+/// @brief A prim type the Create menu makes.
+struct CreatableType {
+    std::string_view type;
+    const char* label;
+    /// The menu's section: Organize, Geometry, Lights, Cameras, Shading or Render.
+    const char* group;
+    /// The name a new prim takes, numbered when taken.
+    const char* name;
+    /// Where it goes unless an Xform or Scope is selected.
+    const char* parent;
+};
+
+/// @return Every type the Create menu offers, section by section.
+std::span<const CreatableType> CreatableTypes();
+
+/// @return The type's Create menu entry, or null.
+const CreatableType* FindCreatable(std::string_view type);
+
+/// @brief Where a new prim goes and what it starts from: the view.
+struct CreateContext {
+    /// The point the view looks at, where geometry goes.
+    glm::dvec3 target{0.0};
+    /// Metres a default size, from the view's distance, so new prims show at any scale.
+    double scale = 1.0;
+    /// The new prim's parent's world transform.
+    glm::dmat4 parentWorld{1.0};
+    /// The view's camera to world and vertical field of view, for a camera from the view.
+    glm::dmat4 view{1.0};
+    double verticalFov = 0.785398;
+    /// The camera new render settings and products look through; empty for none.
+    Path camera;
+};
+
+/// @brief Defines a prim with defaults that make it show: geometry at the view's target and
+/// scale, lights above it shining down, a camera with the view's pose, render prims through the
+/// view's camera.
+/// @param scene A scratch scene, its prims copied in as one undo step (`EditHistory::Add`).
+/// @throws std::invalid_argument for a type `CreatableTypes` does not list.
+void AuthorDefaultPrim(Scene& scene, const Path& path, std::string_view type,
+                       const CreateContext& context);
+
+/// @return A child path of `parent` named `name`, numbered from 1 after it when taken.
+Path FreeChildPath(const Scene& scene, const Path& parent, std::string_view name);
+
+}  // namespace ernie::app