SYMBOL INDEX (785 symbols across 115 files)

FILE: External/bvh/binned_sah_builder.hpp
  type bvh (line 11) | namespace bvh {
    class BinnedSahBuildTask (line 13) | class BinnedSahBuildTask
      type Bin (line 76) | struct Bin {
      method find_split (line 89) | std::pair<Scalar, size_t> find_split(int axis) {
      method BinnedSahBuildTask (line 119) | BinnedSahBuildTask(Builder& builder, const BoundingBox<Scalar>* bbox...
      method build (line 123) | std::optional<std::pair<WorkItem, WorkItem>> build(const WorkItem& i...
    class BinnedSahBuilder (line 20) | class BinnedSahBuilder : public TopDownBuilder, public SahBasedAlgorit...
      method BinnedSahBuilder (line 35) | BinnedSahBuilder(Bvh& bvh)
      method build (line 39) | void build(
    class BinnedSahBuildTask (line 70) | class BinnedSahBuildTask : public TopDownBuildTask {
      type Bin (line 76) | struct Bin {
      method find_split (line 89) | std::pair<Scalar, size_t> find_split(int axis) {
      method BinnedSahBuildTask (line 119) | BinnedSahBuildTask(Builder& builder, const BoundingBox<Scalar>* bbox...
      method build (line 123) | std::optional<std::pair<WorkItem, WorkItem>> build(const WorkItem& i...

FILE: External/bvh/bottom_up_algorithm.hpp
  type bvh (line 10) | namespace bvh {
    class BottomUpAlgorithm (line 16) | class BottomUpAlgorithm {
      method BottomUpAlgorithm (line 23) | BottomUpAlgorithm(Bvh& bvh)
      method traverse_in_parallel (line 48) | void traverse_in_parallel(

FILE: External/bvh/bounding_box.hpp
  type bvh (line 6) | namespace bvh {
    type BoundingBox (line 10) | struct BoundingBox {
      method BoundingBox (line 13) | BoundingBox() = default;
      method bvh_always_inline (line 17) | bvh_always_inline BoundingBox& shrink(const BoundingBox& bbox) {
      method bvh_always_inline (line 23) | bvh_always_inline BoundingBox& extend(const BoundingBox& bbox) {
      method bvh_always_inline (line 29) | bvh_always_inline BoundingBox& extend(const Vector3<Scalar>& v) {
      method diagonal (line 35) | diagonal() const {
      method center (line 39) | center() const {
      method bvh_always_inline (line 43) | bvh_always_inline Scalar half_area() const {
      method bvh_always_inline (line 48) | bvh_always_inline Scalar volume() const {
      method bvh_always_inline (line 53) | bvh_always_inline size_t largest_axis() const {
      method bvh_always_inline (line 61) | bvh_always_inline Scalar largest_extent() const {
      method bvh_always_inline (line 65) | bvh_always_inline bool is_contained_in(const BoundingBox& other) con...
      method full (line 72) | full() {
      method empty (line 78) | empty() {

FILE: External/bvh/bvh.hpp
  type bvh (line 11) | namespace bvh {
    type Bvh (line 19) | struct Bvh {
      type Node (line 25) | struct Node {
        method is_leaf (line 30) | bool is_leaf() const { return primitive_count != 0; }
        type BoundingBoxProxy (line 34) | struct BoundingBoxProxy {
          method BoundingBoxProxy (line 37) | BoundingBoxProxy(Node& node)
          method BoundingBoxProxy (line 41) | BoundingBoxProxy& operator = (const BoundingBox<Scalar>& bbox) {
          method to_bounding_box (line 57) | BoundingBox<Scalar> to_bounding_box() const {
          method Scalar (line 61) | Scalar half_area() const { return to_bounding_box().half_area(); }
          method BoundingBoxProxy (line 63) | BoundingBoxProxy& extend(const BoundingBox<Scalar>& bbox) {
          method BoundingBoxProxy (line 67) | BoundingBoxProxy& extend(const Vector3<Scalar>& vector) {
        method BoundingBoxProxy (line 72) | BoundingBoxProxy bounding_box_proxy() {
          method BoundingBoxProxy (line 37) | BoundingBoxProxy(Node& node)
          method BoundingBoxProxy (line 41) | BoundingBoxProxy& operator = (const BoundingBox<Scalar>& bbox) {
          method to_bounding_box (line 57) | BoundingBox<Scalar> to_bounding_box() const {
          method Scalar (line 61) | Scalar half_area() const { return to_bounding_box().half_area(); }
          method BoundingBoxProxy (line 63) | BoundingBoxProxy& extend(const BoundingBox<Scalar>& bbox) {
          method BoundingBoxProxy (line 67) | BoundingBoxProxy& extend(const Vector3<Scalar>& vector) {
        method BoundingBoxProxy (line 76) | const BoundingBoxProxy bounding_box_proxy() const {
          method BoundingBoxProxy (line 37) | BoundingBoxProxy(Node& node)
          method BoundingBoxProxy (line 41) | BoundingBoxProxy& operator = (const BoundingBox<Scalar>& bbox) {
          method to_bounding_box (line 57) | BoundingBox<Scalar> to_bounding_box() const {
          method Scalar (line 61) | Scalar half_area() const { return to_bounding_box().half_area(); }
          method BoundingBoxProxy (line 63) | BoundingBoxProxy& extend(const BoundingBox<Scalar>& bbox) {
          method BoundingBoxProxy (line 67) | BoundingBoxProxy& extend(const Vector3<Scalar>& vector) {
      method sibling (line 82) | static size_t sibling(size_t index) {
      method is_left_sibling (line 88) | static bool is_left_sibling(size_t index) {

FILE: External/bvh/heuristic_primitive_splitter.hpp
  type bvh (line 12) | namespace bvh {
    class HeuristicPrimitiveSplitter (line 18) | class HeuristicPrimitiveSplitter {
      method Scalar (line 25) | static Scalar compute_priority(const Primitive& primitive, const Bou...
      method split (line 35) | std::tuple<size_t, std::unique_ptr<BoundingBox<Scalar>[]>, std::uniq...
      method repair_bvh_leaves (line 139) | void repair_bvh_leaves(Bvh<Scalar>& bvh) {

FILE: External/bvh/hierarchy_refitter.hpp
  type bvh (line 8) | namespace bvh {
    class HierarchyRefitter (line 11) | class HierarchyRefitter : public BottomUpAlgorithm<Bvh> {
      method refit_in_parallel (line 18) | void refit_in_parallel(const UpdateLeaf& update_leaf) {
      method HierarchyRefitter (line 35) | HierarchyRefitter(Bvh& bvh)
      method refit (line 40) | void refit(const UpdateLeaf& update_leaf) {

FILE: External/bvh/leaf_collapser.hpp
  type bvh (line 12) | namespace bvh {
    class LeafCollapser (line 19) | class LeafCollapser : public SahBasedAlgorithm<Bvh>, public BottomUpAl...
      method LeafCollapser (line 31) | LeafCollapser(Bvh& bvh)
      method collapse (line 35) | void collapse() {

FILE: External/bvh/linear_bvh_builder.hpp
  type bvh (line 11) | namespace bvh {
    class LinearBvhBuilder (line 17) | class LinearBvhBuilder : public MortonCodeBasedBuilder<Bvh, Morton> {
      method merge (line 30) | std::pair<size_t, size_t> merge(
      method LinearBvhBuilder (line 114) | LinearBvhBuilder(Bvh& bvh)
      method build (line 118) | void build(

FILE: External/bvh/locally_ordered_clustering_builder.hpp
  type bvh (line 10) | namespace bvh {
    class LocallyOrderedClusteringBuilder (line 21) | class LocallyOrderedClusteringBuilder : public MortonCodeBasedBuilder<...
      method search_range (line 32) | std::pair<size_t, size_t> search_range(size_t i, size_t begin, size_...
      method cluster (line 38) | std::pair<size_t, size_t> cluster(
      method LocallyOrderedClusteringBuilder (line 182) | LocallyOrderedClusteringBuilder(Bvh& bvh)
      method build (line 186) | void build(

FILE: External/bvh/morton.hpp
  type bvh (line 10) | namespace bvh {
    function Morton (line 15) | Morton morton_split(Morton x) {
    function Morton (line 29) | Morton morton_encode(Morton x, Morton y, Morton z) {
    class MortonEncoder (line 36) | class MortonEncoder {
      method MortonEncoder (line 44) | MortonEncoder(const BoundingBox<Scalar>& bbox, size_t grid_dim = max...
      method Morton (line 53) | Morton encode(const Vector3<Scalar>& point) const {

FILE: External/bvh/morton_code_based_builder.hpp
  type bvh (line 14) | namespace bvh {
    class MortonCodeBasedBuilder (line 17) | class MortonCodeBasedBuilder {
      method SortedPairs (line 43) | SortedPairs sort_primitives_by_morton_code(

FILE: External/bvh/node_intersectors.hpp
  type bvh (line 11) | namespace bvh {
    type NodeIntersector (line 15) | struct NodeIntersector {
      method NodeIntersector (line 20) | NodeIntersector(const Ray<Scalar>& ray)
      method bvh_always_inline (line 29) | bvh_always_inline
  type RobustNodeIntersector (line 55) | struct RobustNodeIntersector : public NodeIntersector<Bvh, RobustNodeInt...
    method RobustNodeIntersector (line 62) | RobustNodeIntersector(const Ray<Scalar>& ray)
    method bvh_always_inline (line 73) | bvh_always_inline
  type FastNodeIntersector (line 83) | struct FastNodeIntersector : public NodeIntersector<Bvh, FastNodeInterse...
    method FastNodeIntersector (line 89) | FastNodeIntersector(const Ray<Scalar>& ray)
    method bvh_always_inline (line 97) | bvh_always_inline

FILE: External/bvh/node_layout_optimizer.hpp
  type bvh (line 10) | namespace bvh {
    class NodeLayoutOptimizer (line 17) | class NodeLayoutOptimizer {
      method NodeLayoutOptimizer (line 26) | NodeLayoutOptimizer(Bvh& bvh)
      method optimize (line 30) | void optimize() {

FILE: External/bvh/parallel_reinsertion_optimizer.hpp
  type bvh (line 10) | namespace bvh {
    class ParallelReinsertionOptimizer (line 17) | class ParallelReinsertionOptimizer :
      method ParallelReinsertionOptimizer (line 30) | ParallelReinsertionOptimizer(Bvh& bvh)
      method get_conflicts (line 35) | std::array<size_t, 6> get_conflicts(size_t in, size_t out) {
      method reinsert (line 48) | void reinsert(size_t in, size_t out) {
      method Insertion (line 74) | Insertion search(size_t in) {
      method optimize (line 140) | void optimize(size_t u = 9, Scalar threshold = 0.1) {

FILE: External/bvh/platform.hpp
  type bvh (line 22) | namespace bvh {
    function get_thread_count (line 25) | inline size_t get_thread_count() { return omp_get_num_threads(); }
    function get_thread_id (line 26) | inline size_t get_thread_id()    { return omp_get_thread_num(); }
    function assert_not_in_parallel (line 27) | inline void assert_not_in_parallel() { assert(omp_get_level() == 0); }
    function assert_in_parallel (line 28) | inline void assert_in_parallel() { assert(omp_get_level() > 0); }
    function get_thread_count (line 30) | inline constexpr size_t get_thread_count() { return 1; }
    function get_thread_id (line 31) | inline constexpr size_t get_thread_id()    { return 0; }
    function assert_not_in_parallel (line 32) | inline void assert_not_in_parallel() {}
    function assert_in_parallel (line 33) | inline void assert_in_parallel() {}

FILE: External/bvh/prefix_sum.hpp
  type bvh (line 10) | namespace bvh {
    class PrefixSum (line 16) | class PrefixSum {
      method sum_in_parallel (line 20) | void sum_in_parallel(const T* input, T* output, size_t count, F f = ...

FILE: External/bvh/primitive_intersectors.hpp
  type bvh (line 8) | namespace bvh {
    type PrimitiveIntersector (line 12) | struct PrimitiveIntersector {
      method PrimitiveIntersector (line 13) | PrimitiveIntersector(const Bvh& bvh, const Primitive* primitives)
      method primitive_at (line 17) | std::pair<const Primitive&, size_t> primitive_at(size_t index) const {
    type ClosestPrimitiveIntersector (line 33) | struct ClosestPrimitiveIntersector : public PrimitiveIntersector<Bvh, ...
      type Result (line 37) | struct Result {
        method Scalar (line 41) | Scalar distance() const { return intersection.distance(); }
      method ClosestPrimitiveIntersector (line 44) | ClosestPrimitiveIntersector(const Bvh& bvh, const Primitive* primiti...
      method intersect (line 48) | std::optional<Result> intersect(size_t index, const Ray<Scalar>& ray...
    type AnyPrimitiveIntersector (line 58) | struct AnyPrimitiveIntersector : public PrimitiveIntersector<Bvh, Prim...
      type Result (line 61) | struct Result {
        method Scalar (line 63) | Scalar distance() const { return t; }
      method AnyPrimitiveIntersector (line 66) | AnyPrimitiveIntersector(const Bvh& bvh, const Primitive* primitives)
      method intersect (line 70) | std::optional<Result> intersect(size_t index, const Ray<Scalar>& ray...

FILE: External/bvh/radix_sort.hpp
  type bvh (line 11) | namespace bvh {
    class RadixSort (line 15) | class RadixSort {
      method if (line 40) | if (per_thread_data_size < data_size) {
  function make_key (line 89) | static typename SizedIntegerType<sizeof(T) * CHAR_BIT>::Unsigned make_ke...

FILE: External/bvh/ray.hpp
  type bvh (line 6) | namespace bvh {
    type Ray (line 10) | struct Ray {
      method Ray (line 16) | Ray() = default;
      method Ray (line 17) | Ray(const Vector3<Scalar>& origin,

FILE: External/bvh/sah_based_algorithm.hpp
  type bvh (line 6) | namespace bvh {
    class SahBasedAlgorithm (line 9) | class SahBasedAlgorithm {
      method Scalar (line 21) | Scalar compute_cost(const Bvh& bvh) const {

FILE: External/bvh/single_ray_traverser.hpp
  type bvh (line 11) | namespace bvh {
    class SingleRayTraverser (line 15) | class SingleRayTraverser {
      type Stack (line 22) | struct Stack {
        method push (line 28) | void push(const Element& t) {
        method Element (line 33) | Element pop() {
        method empty (line 38) | bool empty() const { return size == 0; }
      method bvh_always_inline (line 42) | bvh_always_inline
      method bvh_always_inline (line 66) | bvh_always_inline
      type Statistics (line 132) | struct Statistics {
      method SingleRayTraverser (line 137) | SingleRayTraverser(const Bvh& bvh)
      method bvh_always_inline (line 143) | bvh_always_inline
      method bvh_always_inline (line 159) | bvh_always_inline

FILE: External/bvh/spatial_split_bvh_builder.hpp
  type bvh (line 13) | namespace bvh {
    class SpatialSplitBvhBuildTask (line 15) | class SpatialSplitBvhBuildTask
      type WorkItem (line 114) | struct WorkItem : public TopDownBuildTask::WorkItem {
        method WorkItem (line 118) | WorkItem() = default;
        method WorkItem (line 119) | WorkItem(
      type Reference (line 132) | struct Reference {
      type Bin (line 138) | struct Bin {
      type ObjectSplit (line 145) | struct ObjectSplit {
        method ObjectSplit (line 153) | ObjectSplit(
      type SpatialSplit (line 163) | struct SpatialSplit {
        method SpatialSplit (line 168) | SpatialSplit(
      method ObjectSplit (line 191) | ObjectSplit find_object_split(size_t begin, size_t end, bool is_sort...
        method ObjectSplit (line 153) | ObjectSplit(
      method allocate_children (line 223) | std::pair<WorkItem, WorkItem> allocate_children(
      method apply_object_split (line 276) | std::pair<WorkItem, WorkItem> apply_object_split(Bvh& bvh, const Obj...
      method run_binning_pass (line 296) | std::optional<std::pair<Scalar, Scalar>>
      method SpatialSplit (line 348) | SpatialSplit find_spatial_split(const BoundingBox<Scalar>& node_bbox...
        method SpatialSplit (line 168) | SpatialSplit(
      method apply_spatial_split (line 365) | std::pair<WorkItem, WorkItem> apply_spatial_split(Bvh& bvh, const Sp...
      method SpatialSplitBvhBuildTask (line 474) | SpatialSplitBvhBuildTask(
      method SpatialSplitBvhBuildTask (line 491) | SpatialSplitBvhBuildTask(const SpatialSplitBvhBuildTask& other)
      method build (line 504) | std::optional<std::pair<WorkItem, WorkItem>> build(const WorkItem& i...
    class SpatialSplitBvhBuilder (line 23) | class SpatialSplitBvhBuilder : public TopDownBuilder, public SahBasedA...
      method SpatialSplitBvhBuilder (line 44) | SpatialSplitBvhBuilder(Bvh& bvh)
      method build (line 48) | size_t build(
    class SpatialSplitBvhBuildTask (line 110) | class SpatialSplitBvhBuildTask : public TopDownBuildTask {
      type WorkItem (line 114) | struct WorkItem : public TopDownBuildTask::WorkItem {
        method WorkItem (line 118) | WorkItem() = default;
        method WorkItem (line 119) | WorkItem(
      type Reference (line 132) | struct Reference {
      type Bin (line 138) | struct Bin {
      type ObjectSplit (line 145) | struct ObjectSplit {
        method ObjectSplit (line 153) | ObjectSplit(
      type SpatialSplit (line 163) | struct SpatialSplit {
        method SpatialSplit (line 168) | SpatialSplit(
      method ObjectSplit (line 191) | ObjectSplit find_object_split(size_t begin, size_t end, bool is_sort...
        method ObjectSplit (line 153) | ObjectSplit(
      method allocate_children (line 223) | std::pair<WorkItem, WorkItem> allocate_children(
      method apply_object_split (line 276) | std::pair<WorkItem, WorkItem> apply_object_split(Bvh& bvh, const Obj...
      method run_binning_pass (line 296) | std::optional<std::pair<Scalar, Scalar>>
      method SpatialSplit (line 348) | SpatialSplit find_spatial_split(const BoundingBox<Scalar>& node_bbox...
        method SpatialSplit (line 168) | SpatialSplit(
      method apply_spatial_split (line 365) | std::pair<WorkItem, WorkItem> apply_spatial_split(Bvh& bvh, const Sp...
      method SpatialSplitBvhBuildTask (line 474) | SpatialSplitBvhBuildTask(
      method SpatialSplitBvhBuildTask (line 491) | SpatialSplitBvhBuildTask(const SpatialSplitBvhBuildTask& other)
      method build (line 504) | std::optional<std::pair<WorkItem, WorkItem>> build(const WorkItem& i...

FILE: External/bvh/sphere.hpp
  type bvh (line 10) | namespace bvh {
    type Sphere (line 14) | struct Sphere  {
      type Intersection (line 15) | struct Intersection {
        method Scalar (line 18) | Scalar distance() const { return t; }
      method Sphere (line 27) | Sphere() = default;
      method Sphere (line 28) | Sphere(const Vector3<Scalar>& origin, Scalar radius)
      method center (line 32) | Vector3<Scalar> center() const {
      method bounding_box (line 36) | BoundingBox<Scalar> bounding_box() const {
      method intersect (line 41) | std::optional<Intersection> intersect(const Ray<Scalar>& ray) const {

FILE: External/bvh/sweep_sah_builder.hpp
  type bvh (line 13) | namespace bvh {
    class SweepSahBuildTask (line 15) | class SweepSahBuildTask
      method find_split (line 130) | std::pair<Scalar, size_t> find_split(int axis, size_t begin, size_t ...
      method SweepSahBuildTask (line 151) | SweepSahBuildTask(
      method build (line 166) | std::optional<std::pair<WorkItem, WorkItem>> build(const WorkItem& i...
    class SweepSahBuilder (line 21) | class SweepSahBuilder : public TopDownBuilder, public SahBasedAlgorith...
      method SweepSahBuilder (line 39) | SweepSahBuilder(Bvh& bvh)
      method build (line 43) | void build(
    class SweepSahBuildTask (line 115) | class SweepSahBuildTask : public TopDownBuildTask {
      method find_split (line 130) | std::pair<Scalar, size_t> find_split(int axis, size_t begin, size_t ...
      method SweepSahBuildTask (line 151) | SweepSahBuildTask(
      method build (line 166) | std::optional<std::pair<WorkItem, WorkItem>> build(const WorkItem& i...

FILE: External/bvh/top_down_builder.hpp
  type bvh (line 7) | namespace bvh {
    class TopDownBuildTask (line 10) | class TopDownBuildTask {
      type WorkItem (line 12) | struct WorkItem {
        method WorkItem (line 18) | WorkItem() = default;
        method WorkItem (line 19) | WorkItem(size_t node_index, size_t begin, size_t end, size_t depth)
        method work_size (line 23) | size_t work_size() const { return end - begin; }
    class TopDownBuilder (line 28) | class TopDownBuilder {
      method run_task (line 47) | void run_task(BuildTask& task, Args&&... args) {

FILE: External/bvh/triangle.hpp
  type bvh (line 12) | namespace bvh {
    type Triangle (line 18) | struct Triangle {
      type Intersection (line 19) | struct Intersection {
        method Scalar (line 21) | Scalar distance() const { return t; }
      method Triangle (line 29) | Triangle() = default;
      method Triangle (line 30) | Triangle(const Vector3<Scalar>& p0, const Vector3<Scalar>& p1, const...
      method p1 (line 36) | Vector3<Scalar> p1() const { return p0 - e1; }
      method p2 (line 37) | Vector3<Scalar> p2() const { return p0 + e2; }
      method bounding_box (line 39) | BoundingBox<Scalar> bounding_box() const {
      method center (line 46) | Vector3<Scalar> center() const {
      method edge (line 50) | std::pair<Vector3<Scalar>, Vector3<Scalar>> edge(size_t i) const {
      method Scalar (line 56) | Scalar area() const {
      method split (line 60) | std::pair<BoundingBox<Scalar>, BoundingBox<Scalar>> split(size_t axi...
      method intersect (line 95) | std::optional<Intersection> intersect(const Ray<Scalar>& ray) const {

FILE: External/bvh/utilities.hpp
  type bvh (line 16) | namespace bvh {
    function To (line 20) | To as(From from) {
    function product_sign (line 28) | inline float product_sign(float x, float y) {
    function product_sign (line 33) | inline double product_sign(double x, double y) {
    function fast_multiply_add (line 43) | inline float fast_multiply_add(float x, float y, float z) {
    function fast_multiply_add (line 51) | inline double fast_multiply_add(double x, double y, double z) {
    function T (line 62) | const T& robust_min(const T& x, const T& y) {
    function T (line 69) | const T& robust_max(const T& x, const T& y) {
    function atomic_max (line 74) | void atomic_max(std::atomic<T>& x, T y) {
    type SizedIntegerType (line 81) | struct SizedIntegerType {
    type SizedIntegerType<64> (line 88) | struct SizedIntegerType<64> {
    type SizedIntegerType<32> (line 94) | struct SizedIntegerType<32> {
    type SizedIntegerType<16> (line 100) | struct SizedIntegerType<16> {
    function T (line 107) | T add_ulp_magnitude(T x, unsigned ulps) {
    function round_up_log2 (line 113) | inline constexpr size_t round_up_log2(size_t i, size_t p = 0) {
    function count_leading_zeros (line 120) | size_t count_leading_zeros(T value) {
    function permute_primitives (line 137) | std::unique_ptr<Primitive[]> permute_primitives(const Primitive* primi...
    function compute_bounding_boxes_and_centers (line 147) | std::pair<std::unique_ptr<BoundingBox<Scalar>[]>, std::unique_ptr<Vect...
    function compute_bounding_boxes_union (line 163) | BoundingBox<Scalar> compute_bounding_boxes_union(const BoundingBox<Sca...

FILE: External/bvh/vector.hpp
  type bvh (line 13) | namespace bvh {
    type Vector (line 15) | struct Vector
      method Vector (line 37) | Vector() = default;
      method bvh_always_inline (line 38) | bvh_always_inline explicit Vector(Scalar s) { std::fill(values, valu...
      method bvh_always_inline (line 41) | bvh_always_inline explicit Vector(const Vector<Scalar, M>& other) {
      method bvh_always_inline (line 46) | bvh_always_inline Vector(Scalar first, Scalar second, Args... args) {
      method bvh_always_inline (line 51) | bvh_always_inline Vector(F f) {
      method bvh_always_inline (line 57) | bvh_always_inline void set(Args... args) {
      method bvh_always_inline (line 61) | bvh_always_inline Vector operator - () const {
      method bvh_always_inline (line 65) | bvh_always_inline Vector inverse() const {
      method bvh_always_inline (line 69) | bvh_always_inline Vector safe_inverse() const {
      method bvh_always_inline (line 76) | bvh_always_inline Vector& operator += (const Vector& other) {
      method bvh_always_inline (line 80) | bvh_always_inline Vector& operator -= (const Vector& other) {
      method bvh_always_inline (line 84) | bvh_always_inline Vector& operator *= (const Vector& other) {
      method bvh_always_inline (line 88) | bvh_always_inline Scalar& operator [] (size_t i) { return values[i]; }
      method bvh_always_inline (line 89) | bvh_always_inline Scalar  operator [] (size_t i) const { return valu...
    type VectorSetter (line 19) | struct VectorSetter {
      method bvh_always_inline (line 21) | bvh_always_inline static void set(Vector<Scalar, N>& v, Scalar s, Ar...
    type VectorSetter<N, Scalar, N> (line 28) | struct VectorSetter<N, Scalar, N> {
      method bvh_always_inline (line 29) | bvh_always_inline static void set(Vector<Scalar, N>&) {}
    type Vector (line 34) | struct Vector {
      method Vector (line 37) | Vector() = default;
      method bvh_always_inline (line 38) | bvh_always_inline explicit Vector(Scalar s) { std::fill(values, valu...
      method bvh_always_inline (line 41) | bvh_always_inline explicit Vector(const Vector<Scalar, M>& other) {
      method bvh_always_inline (line 46) | bvh_always_inline Vector(Scalar first, Scalar second, Args... args) {
      method bvh_always_inline (line 51) | bvh_always_inline Vector(F f) {
      method bvh_always_inline (line 57) | bvh_always_inline void set(Args... args) {
      method bvh_always_inline (line 61) | bvh_always_inline Vector operator - () const {
      method bvh_always_inline (line 65) | bvh_always_inline Vector inverse() const {
      method bvh_always_inline (line 69) | bvh_always_inline Vector safe_inverse() const {
      method bvh_always_inline (line 76) | bvh_always_inline Vector& operator += (const Vector& other) {
      method bvh_always_inline (line 80) | bvh_always_inline Vector& operator -= (const Vector& other) {
      method bvh_always_inline (line 84) | bvh_always_inline Vector& operator *= (const Vector& other) {
      method bvh_always_inline (line 88) | bvh_always_inline Scalar& operator [] (size_t i) { return values[i]; }
      method bvh_always_inline (line 89) | bvh_always_inline Scalar  operator [] (size_t i) const { return valu...
    function bvh_always_inline (line 93) | bvh_always_inline
    function bvh_always_inline (line 99) | bvh_always_inline
    function bvh_always_inline (line 105) | bvh_always_inline
    function bvh_always_inline (line 111) | bvh_always_inline
    function bvh_always_inline (line 117) | bvh_always_inline
    function bvh_always_inline (line 123) | bvh_always_inline
    function bvh_always_inline (line 129) | bvh_always_inline
    function bvh_always_inline (line 135) | bvh_always_inline
    function bvh_always_inline (line 144) | bvh_always_inline
    function bvh_always_inline (line 150) | bvh_always_inline
    function bvh_always_inline (line 160) | bvh_always_inline

FILE: External/stb/stb_rect_pack.h
  type stbrp_context (line 81) | typedef struct stbrp_context stbrp_context;
  type stbrp_node (line 82) | typedef struct stbrp_node    stbrp_node;
  type stbrp_rect (line 83) | typedef struct stbrp_rect    stbrp_rect;
  type stbrp_coord (line 85) | typedef int            stbrp_coord;
  type stbrp_rect (line 115) | struct stbrp_rect
  type stbrp_node (line 175) | struct stbrp_node
  type stbrp_context (line 181) | struct stbrp_context
  function STBRP_DEF (line 229) | STBRP_DEF void stbrp_setup_heuristic(stbrp_context *context, int heuristic)
  function STBRP_DEF (line 241) | STBRP_DEF void stbrp_setup_allow_out_of_mem(stbrp_context *context, int ...
  function STBRP_DEF (line 261) | STBRP_DEF void stbrp_init_target(stbrp_context *context, int width, int ...
  function stbrp__skyline_find_min_y (line 287) | static int stbrp__skyline_find_min_y(stbrp_context *c, stbrp_node *first...
  type stbrp__findresult (line 337) | typedef struct
  function stbrp__findresult (line 343) | static stbrp__findresult stbrp__skyline_find_best_pos(stbrp_context *c, ...
  function stbrp__findresult (line 445) | static stbrp__findresult stbrp__skyline_pack_rectangle(stbrp_context *co...
  function rect_height_compare (line 524) | static int STBRP__CDECL rect_height_compare(const void *a, const void *b)
  function rect_original_order (line 535) | static int STBRP__CDECL rect_original_order(const void *a, const void *b)
  function STBRP_DEF (line 542) | STBRP_DEF int stbrp_pack_rects(stbrp_context *context, stbrp_rect *rects...

FILE: External/tsl/bhopscotch_map.h
  function namespace (line 39) | namespace tsl {
  function explicit (line 130) | explicit bhopscotch_map(size_type bucket_count,
  function iterator (line 218) | iterator begin() noexcept { return m_ht.begin(); }
  function iterator (line 222) | iterator end() noexcept { return m_ht.end(); }
  function clear (line 237) | void clear() noexcept { m_ht.clear(); }
  function iterator (line 256) | iterator insert(const_iterator hint, const value_type& value) {
  function iterator (line 265) | iterator insert(const_iterator hint, value_type&& value) {
  function insert (line 275) | void insert(std::initializer_list<value_type> ilist) {
  function iterator (line 355) | iterator erase(iterator pos) { return m_ht.erase(pos); }
  function iterator (line 356) | iterator erase(const_iterator pos) { return m_ht.erase(pos); }
  function iterator (line 357) | iterator erase(const_iterator first, const_iterator last) { return m_ht....
  function size_type (line 358) | size_type erase(const key_type& key) { return m_ht.erase(key); }
  function size_type (line 364) | size_type erase(const key_type& key, std::size_t precalculated_hash) {
  function precalculated_hash (line 385) | size_t precalculated_hash) { return m_ht.erase(key, precalculated_hash); }
  function swap (line 390) | void swap(bhopscotch_map& other) { other.m_ht.swap(m_ht); }
  function T (line 403) | const T& at(const Key& key) const { return m_ht.at(key); }
  function T (line 408) | const T& at(const Key& key, std::size_t precalculated_hash) const { retu...
  function size_type (line 452) | size_type count(const Key& key) const { return m_ht.count(key); }
  function size_type (line 458) | size_type count(const Key& key, std::size_t precalculated_hash) const { ...
  function iterator (line 482) | iterator find(const Key& key) { return m_ht.find(key); }
  function iterator (line 488) | iterator find(const Key& key, std::size_t precalculated_hash) { return m...
  function const_iterator (line 490) | const_iterator find(const Key& key) const { return m_ht.find(key); }
  function const_iterator (line 495) | const_iterator find(const Key& key, std::size_t precalculated_hash) cons...
  function precalculated_hash (line 514) | size_t precalculated_hash) { return m_ht.find(key, precalculated_hash); }
  function contains (line 533) | bool contains(const Key& key) const { return m_ht.contains(key); }
  function contains (line 539) | bool contains(const Key& key, std::size_t precalculated_hash) const {
  function max_load_factor (line 635) | void max_load_factor(float ml) { m_ht.max_load_factor(ml); }
  function rehash (line 637) | void rehash(size_type count_) { m_ht.rehash(count_); }
  function reserve (line 638) | void reserve(size_type count_) { m_ht.reserve(count_); }
  function iterator (line 655) | iterator mutable_iterator(const_iterator pos) {

FILE: External/tsl/bhopscotch_set.h
  function namespace (line 39) | namespace tsl {
  function explicit (line 113) | explicit bhopscotch_set(size_type bucket_count,
  function iterator (line 201) | iterator begin() noexcept { return m_ht.begin(); }
  function iterator (line 205) | iterator end() noexcept { return m_ht.end(); }
  function clear (line 220) | void clear() noexcept { m_ht.clear(); }
  function iterator (line 228) | iterator insert(const_iterator hint, const value_type& value) { return m...
  function iterator (line 229) | iterator insert(const_iterator hint, value_type&& value) { return m_ht.i...
  function insert (line 233) | void insert(std::initializer_list<value_type> ilist) { m_ht.insert(ilist...
  function iterator (line 264) | iterator erase(iterator pos) { return m_ht.erase(pos); }
  function iterator (line 265) | iterator erase(const_iterator pos) { return m_ht.erase(pos); }
  function iterator (line 266) | iterator erase(const_iterator first, const_iterator last) { return m_ht....
  function size_type (line 267) | size_type erase(const key_type& key) { return m_ht.erase(key); }
  function size_type (line 273) | size_type erase(const key_type& key, std::size_t precalculated_hash) {
  function precalculated_hash (line 294) | size_t precalculated_hash) { return m_ht.erase(key, precalculated_hash); }
  function swap (line 299) | void swap(bhopscotch_set& other) { other.m_ht.swap(m_ht); }
  function size_type (line 305) | size_type count(const Key& key) const { return m_ht.count(key); }
  function size_type (line 311) | size_type count(const Key& key, std::size_t precalculated_hash) const { ...
  function iterator (line 335) | iterator find(const Key& key) { return m_ht.find(key); }
  function iterator (line 341) | iterator find(const Key& key, std::size_t precalculated_hash) { return m...
  function const_iterator (line 343) | const_iterator find(const Key& key) const { return m_ht.find(key); }
  function const_iterator (line 348) | const_iterator find(const Key& key, std::size_t precalculated_hash) cons...
  function precalculated_hash (line 367) | size_t precalculated_hash) { return m_ht.find(key, precalculated_hash); }
  function contains (line 389) | bool contains(const Key& key) const { return m_ht.contains(key); }
  function contains (line 395) | bool contains(const Key& key, std::size_t precalculated_hash) const {
  function max_load_factor (line 491) | void max_load_factor(float ml) { m_ht.max_load_factor(ml); }
  function rehash (line 493) | void rehash(size_type count_) { m_ht.rehash(count_); }
  function reserve (line 494) | void reserve(size_type count_) { m_ht.reserve(count_); }
  function iterator (line 512) | iterator mutable_iterator(const_iterator pos) {

FILE: External/tsl/hopscotch_growth_policy.h
  function namespace (line 68) | namespace tsl {

FILE: External/tsl/hopscotch_hash.h
  function namespace (line 52) | namespace tsl {
  function set_hash (line 181) | void set_hash(truncated_hash_type /*hash*/) noexcept {
  function set_hash (line 201) | void set_hash(truncated_hash_type hash) noexcept {
  function m_neighborhood_infos (line 244) | hopscotch_bucket(const hopscotch_bucket& bucket)
  function set_overflow (line 295) | void set_overflow(bool has_overflow) noexcept {
  function toggle_neighbor_presence (line 312) | void toggle_neighbor_presence(std::size_t ineighbor) noexcept {
  function check_neighbor_presence (line 318) | bool check_neighbor_presence(std::size_t ineighbor) const noexcept {
  function value_type (line 332) | const value_type& value() const noexcept {
  function swap_value_into_empty_bucket (line 346) | void swap_value_into_empty_bucket(hopscotch_bucket& empty_bucket) {
  function remove_value (line 358) | void remove_value() noexcept {
  function clear (line 365) | void clear() noexcept {
  function truncated_hash_type (line 374) | static truncated_hash_type truncate_hash(std::size_t hash) noexcept {
  function destroy_value (line 388) | void destroy_value() noexcept {
  function pointer (line 552) | pointer operator->() const {
  function iterator (line 751) | iterator begin() noexcept {
  function const_iterator (line 760) | const_iterator begin() const noexcept {
  function iterator (line 773) | iterator end() noexcept {
  function const_iterator (line 777) | const_iterator end() const noexcept {
  function clear (line 804) | void clear() noexcept {
  function iterator (line 841) | iterator insert(const_iterator hint, value_type&& value) {
  function iterator (line 951) | iterator erase(iterator pos) {
  function iterator (line 955) | iterator erase(const_iterator pos) {
  function iterator (line 970) | iterator erase(const_iterator first, const_iterator last) {
  function hash (line 989) | size_t hash) {
  function swap (line 1011) | void swap(hopscotch_hash& other) {
  function typename (line 1042) | typename U::value_type& at(const K& key) const {
  function typename (line 1047) | typename U::value_type& at(const K& key, std::size_t hash) const {
  function hash (line 1096) | size_t hash) {
  function size_type (line 1162) | size_type max_bucket_count() const {
  function max_load_factor (line 1183) | void max_load_factor(float ml) {
  function rehash (line 1189) | void rehash(size_type count_) {
  function reserve (line 1194) | void reserve(size_type count_) {
  function iterator (line 1213) | iterator mutable_iterator(const_iterator pos) {
  function iterator_overflow (line 1351) | iterator_overflow mutable_overflow_iterator(const_iterator_overflow it) {
  function iterator_overflow (line 1355) | iterator_overflow mutable_overflow_iterator(const_iterator_overflow it) {
  function iterator_overflow (line 1361) | iterator_overflow erase_from_overflow(const_iterator_overflow pos, std::...
  function erase_from_bucket (line 1388) | void erase_from_bucket(hopscotch_bucket& bucket_for_value, std::size_t i...
  function it (line 1465) | auto it = insert_in_overflow(ibucket_for_hash, std::forward<Args>(value_...
  function swap_empty_bucket_closer (line 1562) | bool swap_empty_bucket_closer(std::size_t& ibucket_empty_in_out) {
  function typename (line 1611) | typename U::value_type* find_value_impl(const K& key, std::size_t hash,
  function hopscotch_bucket (line 1685) | hopscotch_bucket* find_in_buckets(const K& key, std::size_t hash, const ...
  function USE_STORED_HASH_ON_REHASH (line 1769) | bool USE_STORED_HASH_ON_REHASH(size_type /*bucket_count*/) {
  function USE_STORED_HASH_ON_REHASH (line 1774) | bool USE_STORED_HASH_ON_REHASH(size_type bucket_count) {
  function hopscotch_bucket (line 1788) | hopscotch_bucket* static_empty_bucket_ptr() {

FILE: External/tsl/hopscotch_map.h
  function namespace (line 39) | namespace tsl {
  function explicit (line 142) | explicit hopscotch_map(size_type bucket_count,
  function iterator (line 229) | iterator begin() noexcept { return m_ht.begin(); }
  function iterator (line 233) | iterator end() noexcept { return m_ht.end(); }
  function clear (line 248) | void clear() noexcept { m_ht.clear(); }
  function iterator (line 267) | iterator insert(const_iterator hint, const value_type& value) {
  function iterator (line 276) | iterator insert(const_iterator hint, value_type&& value) {
  function insert (line 286) | void insert(std::initializer_list<value_type> ilist) {
  function iterator (line 367) | iterator erase(iterator pos) { return m_ht.erase(pos); }
  function iterator (line 368) | iterator erase(const_iterator pos) { return m_ht.erase(pos); }
  function iterator (line 369) | iterator erase(const_iterator first, const_iterator last) { return m_ht....
  function size_type (line 370) | size_type erase(const key_type& key) { return m_ht.erase(key); }
  function size_type (line 376) | size_type erase(const key_type& key, std::size_t precalculated_hash) {
  function precalculated_hash (line 394) | size_t precalculated_hash) {
  function swap (line 401) | void swap(hopscotch_map& other) { other.m_ht.swap(m_ht); }
  function T (line 415) | const T& at(const Key& key) const { return m_ht.at(key); }
  function T (line 420) | const T& at(const Key& key, std::size_t precalculated_hash) const { retu...
  function size_type (line 461) | size_type count(const Key& key) const { return m_ht.count(key); }
  function size_type (line 467) | size_type count(const Key& key, std::size_t precalculated_hash) const {
  function iterator (line 490) | iterator find(const Key& key) { return m_ht.find(key); }
  function iterator (line 496) | iterator find(const Key& key, std::size_t precalculated_hash) { return m...
  function const_iterator (line 498) | const_iterator find(const Key& key) const { return m_ht.find(key); }
  function const_iterator (line 503) | const_iterator find(const Key& key, std::size_t precalculated_hash) const {
  function precalculated_hash (line 521) | size_t precalculated_hash) { return m_ht.find(key, precalculated_hash); }
  function contains (line 543) | bool contains(const Key& key) const { return m_ht.contains(key); }
  function contains (line 549) | bool contains(const Key& key, std::size_t precalculated_hash) const {
  function max_load_factor (line 641) | void max_load_factor(float ml) { m_ht.max_load_factor(ml); }
  function rehash (line 643) | void rehash(size_type count_) { m_ht.rehash(count_); }
  function reserve (line 644) | void reserve(size_type count_) { m_ht.reserve(count_); }
  function iterator (line 660) | iterator mutable_iterator(const_iterator pos) {

FILE: External/tsl/hopscotch_set.h
  function namespace (line 39) | namespace tsl {
  function explicit (line 126) | explicit hopscotch_set(size_type bucket_count,
  function iterator (line 213) | iterator begin() noexcept { return m_ht.begin(); }
  function iterator (line 217) | iterator end() noexcept { return m_ht.end(); }
  function clear (line 232) | void clear() noexcept { m_ht.clear(); }
  function iterator (line 240) | iterator insert(const_iterator hint, const value_type& value) { return m...
  function iterator (line 241) | iterator insert(const_iterator hint, value_type&& value) { return m_ht.i...
  function insert (line 245) | void insert(std::initializer_list<value_type> ilist) { m_ht.insert(ilist...
  function iterator (line 276) | iterator erase(iterator pos) { return m_ht.erase(pos); }
  function iterator (line 277) | iterator erase(const_iterator pos) { return m_ht.erase(pos); }
  function iterator (line 278) | iterator erase(const_iterator first, const_iterator last) { return m_ht....
  function size_type (line 279) | size_type erase(const key_type& key) { return m_ht.erase(key); }
  function size_type (line 285) | size_type erase(const key_type& key, std::size_t precalculated_hash) {
  function precalculated_hash (line 303) | size_t precalculated_hash) {
  function swap (line 310) | void swap(hopscotch_set& other) { other.m_ht.swap(m_ht); }
  function size_type (line 316) | size_type count(const Key& key) const { return m_ht.count(key); }
  function size_type (line 322) | size_type count(const Key& key, std::size_t precalculated_hash) const { ...
  function iterator (line 343) | iterator find(const Key& key) { return m_ht.find(key); }
  function iterator (line 349) | iterator find(const Key& key, std::size_t precalculated_hash) { return m...
  function const_iterator (line 351) | const_iterator find(const Key& key) const { return m_ht.find(key); }
  function const_iterator (line 356) | const_iterator find(const Key& key, std::size_t precalculated_hash) cons...
  function precalculated_hash (line 372) | size_t precalculated_hash) { return m_ht.find(key, precalculated_hash); }
  function contains (line 392) | bool contains(const Key& key) const { return m_ht.contains(key); }
  function contains (line 398) | bool contains(const Key& key, std::size_t precalculated_hash) const {
  function max_load_factor (line 489) | void max_load_factor(float ml) { m_ht.max_load_factor(ml); }
  function rehash (line 491) | void rehash(size_type count_) { m_ht.rehash(count_); }
  function reserve (line 492) | void reserve(size_type count_) { m_ht.reserve(count_); }
  function iterator (line 509) | iterator mutable_iterator(const_iterator pos) {

FILE: NEWorld.Base/Common/Console.cpp
  type LColorFunc (line 28) | namespace LColorFunc {
  type LColorFunc (line 115) | namespace LColorFunc {

FILE: NEWorld.Base/Common/Console.h
  function namespace (line 24) | namespace LColorFunc {
  function namespace (line 60) | namespace LColor {

FILE: NEWorld.Base/Common/Logger.cpp
  function convert (line 43) | std::string convert(int arg) {
  function getTimeString (line 56) | std::string getTimeString(const char dateSplit, const char midSplit, con...
  function setLogColor (line 69) | void setLogColor(const Logger::Level& level, std::stringstream& content) {
  function queryColorFunc (line 83) | LColorFunc::ColorFunc queryColorFunc(const char style) {
  function chConsumeStyled (line 96) | void chConsumeStyled(std::ostream& ostream, const char ch) {
  function transitStyleString (line 104) | auto transitStyleString(const std::string& str, Fn fn) {
  function lockedFlush (line 117) | void lockedFlush(std::ostream& stream, const std::string& string) {
  function flushConsole (line 123) | void flushConsole(const Logger::Level level, const std::string& string) {
  function flushFiles (line 131) | void flushFiles(const Logger::Level level, const std::string& string) {

FILE: NEWorld.Base/Common/Logger.h
  type class (line 28) | enum class

FILE: NEWorld.Base/Math/Vector2.h
  function noexcept (line 30) | const noexcept { return {X - r.X, Y - r.Y}; }

FILE: NEWorld.Base/Math/Vector3.h
  function noexcept (line 35) | const noexcept { return {X - r.X, Y - r.Y, Z - r.Z}; }

FILE: NEWorld.Base/Math/Vector4.h
  function noexcept (line 35) | const noexcept { return {X - r.X, Y - r.Y, Z - r.Z, W - r.W}; }

FILE: NEWorld.Base/System/FileSystem.h
  function namespace (line 5) | namespace NEWorld {
  function namespace (line 10) | namespace NEWorld {

FILE: NEWorld.Base/System/MessageBus.cpp
  function MessageBus (line 18) | MessageBus& MessageBus::Default() {

FILE: NEWorld.Base/System/MessageBus.h
  function class (line 11) | class MessageBus {

FILE: NEWorld.Game/Audio/Audio.h
  function namespace (line 3) | namespace NEWorld::Audio {

FILE: NEWorld.Game/AudioSystem.cpp
  type AudioSystem (line 3) | namespace AudioSystem {
    function Init (line 31) | void Init() {
    function Update (line 70) | void Update(ALfloat PlayerPos[3], bool BFall, bool BBlockClick, ALfloa...
    function ClickEvent (line 167) | void ClickEvent() {
    function UnInit (line 176) | void UnInit() {

FILE: NEWorld.Game/AudioSystem.h
  function namespace (line 5) | namespace AudioSystem {

FILE: NEWorld.Game/Command.h
  function class (line 6) | class Command {

FILE: NEWorld.Game/ControlContext.h
  function class (line 10) | class ControlContext {
  function KeyJustPressed (line 71) | [[nodiscard]] bool KeyJustPressed(int key) const noexcept {
  function ShouldDo (line 75) | [[nodiscard]] bool ShouldDo(Action action) {
  function MouseScrollCallback (line 86) | static void MouseScrollCallback(GLFWwindow*, double, double yOffset) {

FILE: NEWorld.Game/Frustum.h
  function class (line 3) | class Frustum {

FILE: NEWorld.Game/FunctionsKit.cpp
  function split (line 12) | std::vector<std::string> split(const std::string &str, const std::string...
  function MByteToWChar (line 27) | unsigned int MByteToWChar(wchar_t *dst, const char *src, unsigned int n) {
  function WCharToMByte (line 35) | unsigned int WCharToMByte(char *dst, const wchar_t *src, unsigned int n) {

FILE: NEWorld.Game/FunctionsKit.h
  function fastRand (line 15) | inline unsigned int fastRand() {
  function fastSrand (line 20) | inline void fastSrand(int seed) { g_seed = seed; }
  function std (line 24) | inline std::string boolstr(bool b) { return b ? "True" : "False"; }
  function rnd (line 26) | inline double rnd() { return static_cast<double>(fastRand()) / static_ca...
  function RoundInt (line 28) | inline int RoundInt(double d) { return static_cast<int>(lround(d)); }
  function Mutex_t (line 30) | inline Mutex_t MutexCreate() { return new std::mutex; }
  function MutexDestroy (line 32) | inline void MutexDestroy(Mutex_t _hMutex) { delete _hMutex; }
  function MutexLock (line 34) | inline void MutexLock(Mutex_t _hMutex) { _hMutex->lock(); }
  function MutexUnlock (line 36) | inline void MutexUnlock(Mutex_t _hMutex) { _hMutex->unlock(); }
  function wstrlen (line 42) | inline unsigned int wstrlen(const wchar_t *wstr) { return wcslen(wstr); }
  function SleepMs (line 44) | inline void SleepMs(unsigned int ms) { std::this_thread::sleep_for(std::...
  function timer (line 46) | inline double timer() {
  function DistanceSquare (line 52) | inline int DistanceSquare(int ix, int iy, int iz, int x, int y, int z) {

FILE: NEWorld.Game/GUI/GUI.cpp
  type GUI (line 10) | namespace GUI {
    function mapKey (line 11) | static Noesis::Key mapKey(int glfwKey) {
    function pushScene (line 181) | void pushScene(std::unique_ptr<Scene> scene) {
    function popScene (line 186) | void popScene() {
    function clearScenes (line 190) | void clearScenes() {
    function appStart (line 194) | void appStart() {

FILE: NEWorld.Game/GUI/GUI.h
  function namespace (line 11) | namespace GUI {

FILE: NEWorld.Game/GUI/InventorySlot.h
  function class (line 13) | class InventorySlot : public Noesis::UserControl

FILE: NEWorld.Game/GUI/Menus/MainMenu.cpp
  type Menus (line 18) | namespace Menus {
    class WorldModel (line 19) | class WorldModel : public NoesisApp::NotifyPropertyChangedBase
      method WorldModel (line 22) | WorldModel(std::string name) : mName(std::move(name)) {}
      method NS_IMPLEMENT_INLINE_REFLECTION (line 28) | NS_IMPLEMENT_INLINE_REFLECTION(WorldModel, NotifyPropertyChangedBase) {
    class GameMenuViewModel (line 33) | class GameMenuViewModel : public NoesisApp::NotifyPropertyChangedBase {
      method GameMenuViewModel (line 35) | GameMenuViewModel() {
      type State (line 42) | enum class State { MAIN_MENU, SETTINGS, SELECT_WORLD }
      method setState (line 52) | void setState(State state) noexcept {
      method getRenderDistance (line 76) | int getRenderDistance() const { return mRenderDistance; }
      method getRenderDistanceTick (line 77) | int getRenderDistanceTick() const noexcept { return mRenderDistanceT...
      method setRenderDistanceTick (line 78) | void setRenderDistanceTick(int renderDistanceTick) noexcept {
      method NS_IMPLEMENT_INLINE_REFLECTION (line 104) | NS_IMPLEMENT_INLINE_REFLECTION(GameMenuViewModel, NotifyPropertyChan...
    class MainMenu (line 120) | class MainMenu : public GUI::Scene {
      method MainMenu (line 122) | MainMenu() : Scene("MainMenu.xaml"){}
      method onViewBinding (line 126) | void onViewBinding() override {
      method onRender (line 159) | kls::coroutine::ValueAsync<void> onRender() override {
      method drawBackground (line 163) | void drawBackground() {
    function startMenu (line 253) | std::unique_ptr<GUI::Scene> startMenu() {

FILE: NEWorld.Game/GUI/Menus/Menus.h
  function namespace (line 4) | namespace Menus

FILE: NEWorld.Game/GUI/Noesis.h
  function namespace (line 5) | namespace GUI {

FILE: NEWorld.Game/GameSettings.h
  function class (line 6) | class GameSettings {

FILE: NEWorld.Game/GameView.cpp
  type NoesisApp (line 28) | namespace NoesisApp {
    class Window (line 29) | class Window
  class GameView (line 32) | class GameView
    type ItemMoveContext (line 112) | struct ItemMoveContext {
    method GameView (line 119) | GameView() : Scene("InGame.xaml", false), mViewModel(Noesis::MakePtr<G...
    method gameThread (line 121) | void gameThread() {
    method gameRender (line 163) | kls::coroutine::ValueAsync<void> gameRender() {
    method RenderEntities (line 346) | void RenderEntities() {
    method onRender (line 350) | kls::coroutine::ValueAsync<void> onRender() override {
    method drawBorder (line 356) | static void drawBorder(int x, int y, int z) {
    method debugInfo (line 403) | void debugInfo() const {
    method renderDestroy (line 448) | static void renderDestroy(float level, int x, int y, int z) {
    method saveScreenshot (line 512) | static void saveScreenshot(int x, int y, int w, int h, std::string fil...
    method createThumbnail (line 524) | void createThumbnail() {
    method onViewBinding (line 530) | void onViewBinding() override {
    method onLoad (line 591) | void onLoad() override {
    method onUpdate (line 625) | void onUpdate() override {
  class GameViewViewModel (line 37) | class GameViewViewModel : public NoesisApp::NotifyPropertyChangedBase {
    method setDebugInfo (line 43) | void setDebugInfo(std::string debugInfo) {
    method getGamePaused (line 50) | bool getGamePaused() const {
    method setGamePaused (line 54) | void setGamePaused(bool gamePaused) {
    method getBagOpen (line 61) | bool getBagOpen() const {
    method setBagOpen (line 65) | void setBagOpen(bool bagOpen) {
    method getHP (line 72) | double getHP() const { return mHealth; }
    method getHPMax (line 74) | double getHPMax() const { return mHealthMax; }
    method notifyHPChanges (line 76) | void notifyHPChanges(PlayerEntity *player) {
    method NS_IMPLEMENT_INLINE_REFLECTION (line 92) | NS_IMPLEMENT_INLINE_REFLECTION(GameViewViewModel, NotifyPropertyChange...
  class GameView (line 101) | class GameView : public virtual GUI::Scene, public Game {
    type ItemMoveContext (line 112) | struct ItemMoveContext {
    method GameView (line 119) | GameView() : Scene("InGame.xaml", false), mViewModel(Noesis::MakePtr<G...
    method gameThread (line 121) | void gameThread() {
    method gameRender (line 163) | kls::coroutine::ValueAsync<void> gameRender() {
    method RenderEntities (line 346) | void RenderEntities() {
    method onRender (line 350) | kls::coroutine::ValueAsync<void> onRender() override {
    method drawBorder (line 356) | static void drawBorder(int x, int y, int z) {
    method debugInfo (line 403) | void debugInfo() const {
    method renderDestroy (line 448) | static void renderDestroy(float level, int x, int y, int z) {
    method saveScreenshot (line 512) | static void saveScreenshot(int x, int y, int w, int h, std::string fil...
    method createThumbnail (line 524) | void createThumbnail() {
    method onViewBinding (line 530) | void onViewBinding() override {
    method onLoad (line 591) | void onLoad() override {
    method onUpdate (line 625) | void onUpdate() override {
  function pushGameView (line 680) | void pushGameView() { GUI::pushScene(std::make_unique<GameView>()); }

FILE: NEWorld.Game/Globalization.cpp
  type Globalization (line 7) | namespace Globalization {
    function LoadLang (line 14) | bool LoadLang(const std::string& lang) {
    function Load (line 30) | bool Load() {
    function GetStrbyid (line 48) | std::string GetStrbyid(int id) {
    function GetStrbyKey (line 52) | std::string GetStrbyKey(std::string key) {

FILE: NEWorld.Game/Globalization.h
  function namespace (line 5) | namespace Globalization {

FILE: NEWorld.Game/Items.cpp
  function loadItemsTextures (line 6) | void loadItemsTextures() {

FILE: NEWorld.Game/Items.h
  function class (line 5) | class ItemInfo {
  type BuiltInItems (line 13) | enum BuiltInItems {
  function isBlock (line 22) | inline bool isBlock(Item i) {
  function TextureID (line 26) | inline TextureID getItemTexture(Item i) {

FILE: NEWorld.Game/Menus.h
  function namespace (line 6) | namespace Menus {

FILE: NEWorld.Game/NEWorld.cpp
  function ApplicationBeforeLaunch (line 25) | void ApplicationBeforeLaunch() {
  function ApplicationAfterLaunch (line 35) | void ApplicationAfterLaunch() {
  function main (line 41) | int main() {
  function AppCleanUp (line 77) | void AppCleanUp() {

FILE: NEWorld.Game/Particles.cpp
  type Particles (line 7) | namespace Particles {
    function update (line 33) | void update(Particle &ptc) {
    function updateall (line 72) | void updateall() {
    function render (line 85) | void render(Renderer::BufferBuilder<> &builder, Particle &ptc) {
    function renderall (line 135) | void renderall(double xpos, double ypos, double zpos) {
    function throwParticle (line 157) | void throwParticle(Block pt, float x, float y, float z, float xs, floa...

FILE: NEWorld.Game/Particles.h
  function namespace (line 6) | namespace Particles {

FILE: NEWorld.Game/Renderer/BufferBuilder.h
  type class (line 12) | enum class

FILE: NEWorld.Game/Renderer/GL/Objects.h
  function namespace (line 7) | namespace Renderer {

FILE: NEWorld.Game/Renderer/GL/Pipeline.cpp
  function CollapseDefines (line 9) | auto CollapseDefines(const std::vector<std::string> &defines) noexcept {
  function PrintDebug (line 15) | void PrintDebug(GLuint program) {
  function Preprocess (line 33) | kls::temp::string Preprocess(std::string_view text, kls::temp::set<std::...
  function GLenum (line 56) | GLenum MapShaderTypes(Renderer::ShaderType type) noexcept {
  function CheckErrorShader (line 70) | void CheckErrorShader(GLuint res, const std::string &eMsg) {
  function CheckErrorProgram (line 83) | void CheckErrorProgram(GLuint res, const std::string &eMsg) {
  function GLuint (line 100) | GLuint FromFakePtr(Renderer::Internal::Object *ptr) noexcept {
  function MakeProgram (line 106) | auto MakeProgram(const kls::temp::unordered_map<Renderer::ShaderType, Re...
  function GLenum (line 124) | GLenum MapDataType(Renderer::DataType type) {
  function MakeVAO (line 138) | auto MakeVAO(const kls::temp::vector<Renderer::Internal::AttributeSpec> ...
  function ZipBinds (line 157) | auto ZipBinds(GLuint vao, const kls::temp::unordered_map<int, std::pair<...
  function GLenum (line 167) | GLenum CastTopology(Renderer::Topology topology) {
  function GLenum (line 187) | GLenum CastIndexType(Renderer::IndexType index) {
  class PipelineOGL (line 199) | class PipelineOGL : public Renderer::IPipeline {
    method PipelineOGL (line 201) | PipelineOGL(GLenum mode, std::vector<int> strides, GLuint vao, GLuint ...
    method Use (line 209) | void Use() override {
    method BindVertexBuffer (line 214) | void BindVertexBuffer(int bind, GLuint buffer, int offset) override {
    method BindIndexBuffer (line 218) | void BindIndexBuffer(GLuint buffer, Renderer::IndexType type) override {
    method Draw (line 223) | void Draw(int count, int first, int instance) override {
    method DrawIndexed (line 227) | void DrawIndexed(int count, int first, int instance) override {
    method SetUniform (line 234) | void SetUniform(GLint loc, float value) override {
    method SetUniform (line 238) | void SetUniform(GLint loc, int value) override {
    method SetUniform (line 242) | void SetUniform(GLint loc, float v0, float v1, float v2, float v3) ove...
    method SetUniform (line 246) | void SetUniform(GLint loc, float *value) override {
  function LoadFile (line 258) | kls::temp::string LoadFile(const std::string &path) {
  type Renderer (line 269) | namespace Renderer {
    function GLShader (line 270) | GLShader Compile(ShaderType type, std::string_view program, const std:...
    function GLShader (line 284) | GLShader CompileFile(ShaderType type, const std::string &path, const s...
    function Pipeline (line 289) | Pipeline PipelineBuilder::Build() {
    function GLuint (line 300) | GLuint GetDefaultQuadIndex() {

FILE: NEWorld.Game/Renderer/GL/Pipeline.h
  type class (line 8) | enum class
  type class (line 12) | enum class
  type class (line 16) | enum class
  function namespace (line 20) | namespace Internal {
  type IPipeline (line 38) | struct IPipeline {
  function Topology (line 58) | enum class Topology {

FILE: NEWorld.Game/Renderer/Renderer.cpp
  type Renderer (line 7) | namespace Renderer {
    type IndirectBaseVertex (line 56) | struct IndirectBaseVertex {
    function RenderBufferDirect (line 64) | void RenderBufferDirect(VBOID buffer, vtxCount vtxs) {
    function Pipeline (line 69) | Pipeline BuildPipeline(
    function initShaders (line 87) | void initShaders() {
    function destroyShaders (line 127) | void destroyShaders() {
    function BindPipeline (line 132) | void BindPipeline(int shaderID) {
    function EnableAdvancedShaders (line 137) | void EnableAdvancedShaders() {
    function EnableSimpleShaders (line 158) | void EnableSimpleShaders() {
    function EnableShaders (line 162) | void EnableShaders() {
    function DisableShaders (line 166) | void DisableShaders() {
    function StartShadowPass (line 171) | void StartShadowPass() {
    function EndShadowPass (line 179) | void EndShadowPass() {
    function Pipeline (line 189) | Pipeline &GetPipeline() {

FILE: NEWorld.Game/Renderer/Renderer.h
  function namespace (line 7) | namespace Renderer {

FILE: NEWorld.Game/Renderer/World/ChunkRenderer.cpp
  type WorldRenderer (line 8) | namespace WorldRenderer {
    class ChunkRenderContext (line 9) | class ChunkRenderContext {
      method ChunkRenderContext (line 13) | ChunkRenderContext(World::Chunk *chunk) {
      method Rebase (line 23) | void Rebase(int x, int y, int z) noexcept { mBase = (x + 1) * MX + (...
      method State (line 25) | auto State(int dx, int dy, int dz) noexcept { return mBStates[mBase ...
      method Brightness (line 27) | Brightness Lumin(int dx, int dy, int dz) noexcept { return mLumin[mB...
    type Face (line 35) | enum Face {
    function renderblock (line 40) | static void renderblock(Renderer::BufferBuilder<> &builder, ChunkRende...
    function RenderPrimitive_Depth (line 241) | static void RenderPrimitive_Depth(Renderer::BufferBuilder<> &builder, ...
    function RenderDepthModelEvaluate (line 265) | static kls::coroutine::ValueAsync<void> RenderDepthModelEvaluate(World...
    function RenderDepthModel (line 326) | static kls::coroutine::ValueAsync<void> RenderDepthModel(World::Chunk ...
    function BuildRenderEvaluate (line 333) | static kls::coroutine::ValueAsync<void> BuildRenderEvaluate(World::Chu...
    function RenderChunk (line 351) | static kls::coroutine::ValueAsync<void> RenderChunk(World::Chunk *c, C...

FILE: NEWorld.Game/Renderer/World/ChunkRenderer.h
  function namespace (line 8) | namespace WorldRenderer {

FILE: NEWorld.Game/Renderer/World/ShadowMaps.cpp
  type ShadowMaps (line 5) | namespace ShadowMaps {
    function BuildShadowMap (line 6) | void BuildShadowMap(
    function RenderShadowMap (line 40) | void RenderShadowMap(

FILE: NEWorld.Game/Renderer/World/ShadowMaps.h
  function namespace (line 5) | namespace ShadowMaps {

FILE: NEWorld.Game/Renderer/World/WorldRenderer.cpp
  type WorldRenderer (line 5) | namespace WorldRenderer {
    type SortEntry (line 17) | struct SortEntry {
    type SortCmp (line 22) | struct SortCmp {

FILE: NEWorld.Game/Renderer/World/WorldRenderer.h
  function namespace (line 8) | namespace WorldRenderer {

FILE: NEWorld.Game/Setup.cpp
  function splashScreen (line 13) | void splashScreen() {
  function createWindow (line 39) | void createWindow() {
  function message_callback (line 68) | void message_callback(GLenum source, GLenum type, GLuint id, GLenum seve...
  function setupScreen (line 124) | void setupScreen() {
  function setupNormalFog (line 169) | void setupNormalFog() {
  function loadTextures (line 178) | void loadTextures() {
  function WindowSizeFunc (line 205) | void WindowSizeFunc(GLFWwindow *win, int width, int height) {
  function MouseButtonFunc (line 214) | void MouseButtonFunc(GLFWwindow *, int button, int action, int) {
  function CharInputFunc (line 218) | void CharInputFunc(GLFWwindow *, unsigned int c) {

FILE: NEWorld.Game/Setup.h
  type GLFWwindow (line 3) | struct GLFWwindow

FILE: NEWorld.Game/Textures.cpp
  type Textures (line 10) | namespace Textures {
    function Init (line 12) | void Init() {
    function ubyte (line 18) | ubyte getTextureIndex(Block blockname, ubyte side) {
    function getTexcoordX (line 75) | double getTexcoordX(Item item, ubyte side) {
    function getTexcoordY (line 82) | double getTexcoordY(Item item, ubyte side) {
    function LoadRGBImage (line 89) | void LoadRGBImage(TEXTURE_RGB &tex, std::string Filename) {
    function LoadRGBAImage (line 117) | void LoadRGBAImage(TEXTURE_RGBA &tex, std::string Filename, std::strin...
    function TextureID (line 169) | TextureID LoadRGBTexture(std::string Filename) {
    function TextureID (line 181) | TextureID LoadFontTexture(std::string Filename) {
    function TextureID (line 215) | TextureID LoadRGBATexture(std::string Filename, std::string MkFilename) {
    function SaveRGBImage (line 227) | void SaveRGBImage(std::string filename, TEXTURE_RGB &image) {
    function Build2DMipmaps (line 246) | void Build2DMipmaps(GLenum format, int w, int h, int level, const ubyt...

FILE: NEWorld.Game/Textures.h
  function namespace (line 8) | namespace Textures {

FILE: NEWorld.Game/Tick.cpp
  function CreateTickPipeline (line 6) | std::shared_ptr<TickPipeline> CreateTickPipeline(std::vector<std::shared...

FILE: NEWorld.Game/Tick.h
  function PmrBase (line 7) | struct TickComponent: kls::PmrBase {
  function PmrBase (line 13) | struct TickPipeline: kls::PmrBase {

FILE: NEWorld.Game/Typedefs.h
  type ubyte (line 8) | typedef unsigned char ubyte;
  type blockprop (line 10) | typedef unsigned char blockprop;
  type Brightness (line 11) | typedef unsigned char Brightness;
  type TextureID (line 12) | typedef unsigned int TextureID;
  type Item (line 13) | typedef uint32_t Item;
  type VBOID (line 14) | typedef unsigned int VBOID;
  type vtxCount (line 15) | typedef int vtxCount;
  type chunkid (line 16) | typedef uint64_t chunkid;
  type onlineid (line 17) | typedef unsigned int onlineid;
  type std (line 19) | typedef std::mutex *Mutex_t;

FILE: NEWorld.Game/Universe/CommandHandler.h
  function class (line 10) | class CommandHandler {
  function registerCommands (line 20) | static void registerCommands() {

FILE: NEWorld.Game/Universe/Entity/Entity.cpp
  function Int3 (line 5) | Int3 Entity::getChunkPosition() const noexcept

FILE: NEWorld.Game/Universe/Entity/Entity.h
  type RenderProperties (line 7) | struct RenderProperties {
  function class (line 12) | class Entity {

FILE: NEWorld.Game/Universe/Entity/PlayerEntity.cpp
  function RenderProperties (line 26) | RenderProperties PlayerEntity::renderUpdate(const ControlContext& contro...

FILE: NEWorld.Game/Universe/Entity/PlayerEntity.h
  type ItemStack (line 7) | struct ItemStack {
  function GameMode (line 12) | enum class GameMode { Survival, Creative };

FILE: NEWorld.Game/Universe/Entity/bvh.cpp
  type AABBIntersector (line 9) | struct AABBIntersector : public bvh::PrimitiveIntersector<Bvh, Primitive...
    method AABBIntersector (line 10) | AABBIntersector(const Bvh& bvh, const Primitive* primitives)
    method intersect (line 15) | bool intersect(size_t index, const BoundingBox& box, bool is_leaf) {
  function aabb_intersect (line 25) | static void aabb_intersect(const Bvh& bvh, size_t index, AABBIntersector...

FILE: NEWorld.Game/Universe/Entity/bvh.h
  function Vector3 (line 17) | inline Vector3 toBvhVec(const Double3& v) { return {v.X, v.Y, v.Z}; }
  function class (line 19) | class EntityBVH {
  function namespace (line 31) | namespace AABB {

FILE: NEWorld.Game/Universe/Game.h
  function class (line 9) | class Game : public CommandHandler {
  function EntitiesMovement (line 91) | void EntitiesMovement() {
  function ProcessInteract (line 101) | void ProcessInteract(Double3 startPosition, double heading, double lookU...
  function saveGame (line 213) | static void saveGame() {
  function loadGame (line 222) | static bool loadGame() {

FILE: NEWorld.Game/Universe/World/BlockRegistry.cpp
  function TableExtract (line 15) | void TableExtract(const nlohmann::json& cfgTree) {
  function TableDump (line 32) | void TableDump(nlohmann::json& cfgTree) {

FILE: NEWorld.Game/Universe/World/BlockRegistry.h
  function class (line 6) | class BlockRegistry {

FILE: NEWorld.Game/Universe/World/Blocks.cpp
  type Blocks (line 5) | namespace Blocks {
    class Grass (line 44) | class Grass : public BlockType {
      method Grass (line 46) | Grass()
      method OnRandomTick (line 49) | void OnRandomTick(const Int3& position, Block) noexcept override {
    class Dirt (line 59) | class Dirt : public BlockType {
      method Dirt (line 61) | Dirt()
      method OnRandomTick (line 64) | void OnRandomTick(const Int3& position, Block) noexcept override {
    class Leaf (line 84) | class Leaf : public BlockType {
      method Leaf (line 86) | Leaf()
      method AfterBlockDestroy (line 89) | void AfterBlockDestroy(const Int3& position, Block) noexcept override {
    class Tnt (line 98) | class Tnt : public BlockType {
      method Tnt (line 100) | Tnt()
      method AfterBlockPlace (line 103) | void AfterBlockPlace(const Int3& position, Block) noexcept override {

FILE: NEWorld.Game/Universe/World/Blocks.h
  function namespace (line 9) | namespace Blocks {

FILE: NEWorld.Game/Universe/World/Chunk.cpp
  type World (line 4) | namespace World {
    function BoundingBox (line 9) | BoundingBox Chunk::getBaseAABB() {

FILE: NEWorld.Game/Universe/World/Chunk.h
  function namespace (line 14) | namespace World {

FILE: NEWorld.Game/Universe/World/ChunkPtrArray.cpp
  type World (line 4) | namespace World {

FILE: NEWorld.Game/Universe/World/ChunkPtrArray.h
  function namespace (line 5) | namespace World {

FILE: NEWorld.Game/Universe/World/Data/BitStorage.h
  function namespace (line 11) | namespace World::Data {
  function class (line 22) | class BitsDenseView {
  function Set (line 43) | void Set(const unsigned int index, const uint64_t val) noexcept {
  function Get (line 62) | [[nodiscard]] unsigned int Get(const unsigned int index) noexcept {
  function noexcept (line 115) | [[nodiscard]] auto Bits() const noexcept { return mBits; }
  function noexcept (line 117) | [[nodiscard]] auto Size() const noexcept { return mSize; }
  function noexcept (line 119) | [[nodiscard]] auto Raw() noexcept { return mData; }
  function noexcept (line 121) | [[nodiscard]] auto Raw() const noexcept { return mData; }
  function noexcept (line 123) | [[nodiscard]] auto RawSize() const noexcept { return mDataSize; }
  function class (line 131) | class BitsSparseView {
  function Set (line 148) | void Set(const unsigned int index, const int val) noexcept {
  function Get (line 161) | [[nodiscard]] int Get(const unsigned int index) const noexcept {
  function GetSet (line 173) | [[nodiscard]] int GetSet(const unsigned int index, const int val) noexce...
  function noexcept (line 185) | [[nodiscard]] auto Size() const noexcept { return mSize; }
  function noexcept (line 187) | [[nodiscard]] auto Raw() noexcept { return mData; }
  function noexcept (line 189) | [[nodiscard]] auto Raw() const noexcept { return mData; }
  function noexcept (line 191) | [[nodiscard]] auto MaxBits() const noexcept { return 8 * (1 << mFlag); }
  function noexcept (line 192) | [[nodiscard]] auto RawSize() const noexcept { return mSize << mFlag; }
  function T (line 205) | [[nodiscard]] const T &A(const unsigned int x) const noexcept { return r...
  function class (line 214) | class BitsDense : public BitsDenseView {
  function class (line 239) | class BitsSparse : public BitsSparseView {

FILE: NEWorld.Game/Universe/World/Data/ChunkStorage.cpp
  type World::Data (line 3) | namespace World::Data {

FILE: NEWorld.Game/Universe/World/Data/ChunkStorage.h
  function namespace (line 8) | namespace World {
  function namespace (line 17) | namespace World::Data {
  function class (line 198) | class ChunkStorage {

FILE: NEWorld.Game/Universe/World/OrderedArray.h
  function Iterator (line 21) | [[nodiscard]] Iterator end() noexcept { return mEnd; }
  function ConstIterator (line 22) | [[nodiscard]] ConstIterator end() const noexcept { return mEnd; }
  function Clear (line 39) | void Clear() noexcept { mEnd = begin(); }
  function noexcept (line 41) | [[nodiscard]] auto Count() const noexcept { return end() - begin(); }

FILE: NEWorld.Game/Universe/World/TerrainGen/Carve.cpp
  type World::TerrainGen (line 1) | namespace World::TerrainGen {

FILE: NEWorld.Game/Universe/World/TerrainGen/Generate.h
  function namespace (line 6) | namespace World::TerrainGen {

FILE: NEWorld.Game/Universe/World/TerrainGen/Heights.h
  function namespace (line 9) | namespace World::TerrainGen {

FILE: NEWorld.Game/Universe/World/TerrainGen/Noise.h
  function namespace (line 5) | namespace World::TerrainGen {

FILE: NEWorld.Game/Universe/World/World.cpp
  type World (line 9) | namespace World {
    function Init (line 28) | void Init() {
    function LowerChunkBound (line 43) | auto LowerChunkBound(chunkid cid) noexcept {
    function Chunk (line 49) | Chunk *AddChunk(Int3 vec) {
    function Chunk (line 69) | Chunk *GetChunk(Int3 vec) {
    function DeleteChunk (line 94) | void DeleteChunk(Int3 vec) {
    function getHitboxes (line 110) | std::vector<BoundingBox> getHitboxes(const BoundingBox& box) {
    function inWater (line 127) | bool inWater(const BoundingBox &box) {
    function updateblock (line 142) | void updateblock(int x, int y, int z, bool blockchanged, int depth) {
    function ChunkHintMatch (line 240) | bool ChunkHintMatch(const Int3 c, Chunk *const cptr) noexcept { return...
    function Block (line 242) | Block GetBlock(const Int3 v, Block mask, Chunk *const hint) {
    function Brightness (line 253) | Brightness GetBrightness(Int3 v, Chunk *const hint) {
    function Chunk (line 264) | Chunk *GetChunkNoneLazy(const Int3 c) noexcept {
    function SetBlock (line 268) | void SetBlock(Int3 v, Block block, Chunk *hint) {
    function SetBrightness (line 283) | void SetBrightness(Int3 v, Brightness brightness, Chunk *hint) {
    function chunkUpdated (line 296) | bool chunkUpdated(const Int3 vec) {
    function setChunkUpdated (line 302) | void setChunkUpdated(int x, int y, int z, bool value) {
    function sortChunkLoadUnloadList (line 310) | void sortChunkLoadUnloadList(Int3 pos) {
    function saveAllChunks (line 329) | void saveAllChunks() {
    function destroyAllChunks (line 332) | void destroyAllChunks() {
    function buildtree (line 351) | void buildtree(Int3 pos) {
    function explode (line 415) | void explode(int x, int y, int z, int r, Chunk *c) {
    function PutBlock (line 440) | void PutBlock(const Int3 v, Block block) {
    function PickBlock (line 448) | void PickBlock(const Int3 v) {

FILE: NEWorld.Game/Universe/World/World.h
  function namespace (line 12) | namespace World {

FILE: NoesisGUI/bin2h.py
  function bin2h (line 4) | def bin2h(filein, fileout):
  function main (line 24) | def main():