utils.h | Explore in Territory

// Copyright 2020 The Manifold Authors, Jared Hoberock and Nathan Bell of
// NVIDIA Research
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#pragma once
#include <atomic>
#include <memory>
#include <mutex>
#include <unordered_map>

#include "./vec.h"
#include "manifold/common.h"

#ifndef MANIFOLD_PAR
#error "MANIFOLD_PAR must be defined to either 1 (parallel) or -1 (series)"
#else
#if (MANIFOLD_PAR != 1) && (MANIFOLD_PAR != -1)
#define XSTR …
#define STR …
#pragma message "Current value of MANIFOLD_PAR is: " XSTR(MANIFOLD_PAR)
#error "MANIFOLD_PAR must be defined to either 1 (parallel) or -1 (series)"
#endif
#endif

#include "./parallel.h"

#if __has_include(<tracy/Tracy.hpp>)
#include <tracy/Tracy.hpp>
#else
#define FrameMarkStart(x) …
#define FrameMarkEnd(x) …
// putting ZoneScoped in a function will instrument the function execution when
// TRACY_ENABLE is set, which allows the profiler to record more accurate
// timing.
#define ZoneScoped
#define ZoneScopedN(name) …
#endif

namespace manifold {

/**
 * Stand-in for C++23's operator""uz (P0330R8)[https://wg21.link/P0330R8].
 */
[[nodiscard]] constexpr std::size_t operator""_uz(
    unsigned long long n) noexcept { … }

constexpr double kPrecision = …;

inline int Next3(int i) { … }

inline int Prev3(int i) { … }

template <typename T, typename T1>
void Permute(Vec<T>& inOut, const Vec<T1>& new2Old) { … }

template <typename T, typename T1>
void Permute(std::vector<T>& inOut, const Vec<T1>& new2Old) { … }

template <typename T>
T AtomicAdd(T& target, T add) { … }

template <>
inline int AtomicAdd(int& target, int add) { … }

template <typename T>
class ConcurrentSharedPtr { … };

template <typename I = int, typename R = unsigned char>
struct UnionFind { … };

template <typename T>
struct Identity { … };

template <typename T>
struct Negate { … };

/**
 * Determines if the three points are wound counter-clockwise, clockwise, or
 * colinear within the specified tolerance.
 *
 * @param p0 First point
 * @param p1 Second point
 * @param p2 Third point
 * @param tol Tolerance value for colinearity
 * @return int, like Signum, this returns 1 for CCW, -1 for CW, and 0 if within
 * tol of colinear.
 */
inline int CCW(vec2 p0, vec2 p1, vec2 p2, double tol) { … }

inline mat4 Mat4(mat3x4 a) { … }
inline mat3 Mat3(mat2x3 a) { … }

}  // namespace manifold
godot/thirdparty/manifold/src/utils.h
