csg_tree.cpp | Explore in Territory

// Copyright 2022 The Manifold Authors.
//
// 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.

#if (MANIFOLD_PAR == 1) && __has_include(<tbb/concurrent_priority_queue.h>)
#include <tbb/tbb.h>
#define TBB_PREVIEW_CONCURRENT_ORDERED_CONTAINERS …
#include <tbb/concurrent_priority_queue.h>
#endif

#include <algorithm>
#include <variant>

#include "./boolean3.h"
#include "./csg_tree.h"
#include "./impl.h"
#include "./mesh_fixes.h"
#include "./parallel.h"

constexpr int kParallelThreshold = …;

namespace {
usingnamespacemanifold;
struct Transform4x3 { … };

struct UpdateHalfedge { … };

struct UpdateTriProp { … };

struct UpdateMeshIDs { … };

struct CheckOverlap { … };

SharedImpl;
struct GetImplPtr { … };

struct MeshCompare { … };

}  // namespace
namespace manifold {

std::shared_ptr<CsgNode> CsgNode::Boolean(
    const std::shared_ptr<CsgNode> &second, OpType op) { … }

std::shared_ptr<CsgNode> CsgNode::Translate(const vec3 &t) const { … }

std::shared_ptr<CsgNode> CsgNode::Scale(const vec3 &v) const { … }

std::shared_ptr<CsgNode> CsgNode::Rotate(double xDegrees, double yDegrees,
                                         double zDegrees) const { … }

CsgLeafNode::CsgLeafNode() : … { … }

CsgLeafNode::CsgLeafNode(std::shared_ptr<const Manifold::Impl> pImpl_)
    : … { … }

CsgLeafNode::CsgLeafNode(std::shared_ptr<const Manifold::Impl> pImpl_,
                         mat3x4 transform_)
    : … { … }

std::shared_ptr<const Manifold::Impl> CsgLeafNode::GetImpl() const { … }

mat3x4 CsgLeafNode::GetTransform() const { … }

std::shared_ptr<CsgLeafNode> CsgLeafNode::ToLeafNode() const { … }

std::shared_ptr<CsgNode> CsgLeafNode::Transform(const mat3x4 &m) const { … }

CsgNodeType CsgLeafNode::GetNodeType() const { … }

/**
 * Efficient union of a set of pairwise disjoint meshes.
 */
Manifold::Impl CsgLeafNode::Compose(
    const std::vector<std::shared_ptr<CsgLeafNode>> &nodes) { … }

CsgOpNode::CsgOpNode() { … }

CsgOpNode::CsgOpNode(const std::vector<std::shared_ptr<CsgNode>> &children,
                     OpType op)
    : … { … }

CsgOpNode::CsgOpNode(std::vector<std::shared_ptr<CsgNode>> &&children,
                     OpType op)
    : … { … }

std::shared_ptr<CsgNode> CsgOpNode::Boolean(
    const std::shared_ptr<CsgNode> &second, OpType op) { … }

std::shared_ptr<CsgNode> CsgOpNode::Transform(const mat3x4 &m) const { … }

std::shared_ptr<CsgLeafNode> CsgOpNode::ToLeafNode() const { … }

/**
 * Efficient boolean operation on a set of nodes utilizing commutativity of the
 * operation. Only supports union and intersection.
 */
std::shared_ptr<Manifold::Impl> CsgOpNode::BatchBoolean(
    OpType operation,
    std::vector<std::shared_ptr<const Manifold::Impl>> &results) { … }

/**
 * Efficient union operation on a set of nodes by doing Compose as much as
 * possible.
 * Note: Due to some unknown issues with `Compose`, we are now doing
 * `BatchBoolean` instead of using `Compose` for non-intersecting manifolds.
 */
void CsgOpNode::BatchUnion() const { … }

/**
 * Flatten the children to a list of leaf nodes and return them.
 * If forceToLeafNodes is true, the list will be guaranteed to be a list of leaf
 * nodes (i.e. no ops). Otherwise, the list may contain ops. Note that this
 * function will not apply the transform to children, as they may be shared with
 * other nodes.
 */
std::vector<std::shared_ptr<CsgNode>> &CsgOpNode::GetChildren(
    bool forceToLeafNodes) const { … }

void CsgOpNode::SetOp(OpType op) { … }

bool CsgOpNode::IsOp(OpType op) { … }

mat3x4 CsgOpNode::GetTransform() const { … }

}  // namespace manifold
godot/thirdparty/manifold/src/csg_tree.cpp
