csg_shape.cpp | Explore in Territory

/**************************************************************************/
/*  csg_shape.cpp                                                         */
/**************************************************************************/
/*                         This file is part of:                          */
/*                             GODOT ENGINE                               */
/*                        https://godotengine.org                         */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
/*                                                                        */
/* Permission is hereby granted, free of charge, to any person obtaining  */
/* a copy of this software and associated documentation files (the        */
/* "Software"), to deal in the Software without restriction, including    */
/* without limitation the rights to use, copy, modify, merge, publish,    */
/* distribute, sublicense, and/or sell copies of the Software, and to     */
/* permit persons to whom the Software is furnished to do so, subject to  */
/* the following conditions:                                              */
/*                                                                        */
/* The above copyright notice and this permission notice shall be         */
/* included in all copies or substantial portions of the Software.        */
/*                                                                        */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
/**************************************************************************/

#include "csg_shape.h"

#include "core/math/geometry_2d.h"

#include <manifold/manifold.h>

void CSGShape3D::set_use_collision(bool p_enable) { … }

bool CSGShape3D::is_using_collision() const { … }

void CSGShape3D::set_collision_layer(uint32_t p_layer) { … }

uint32_t CSGShape3D::get_collision_layer() const { … }

void CSGShape3D::set_collision_mask(uint32_t p_mask) { … }

uint32_t CSGShape3D::get_collision_mask() const { … }

void CSGShape3D::set_collision_layer_value(int p_layer_number, bool p_value) { … }

bool CSGShape3D::get_collision_layer_value(int p_layer_number) const { … }

void CSGShape3D::set_collision_mask_value(int p_layer_number, bool p_value) { … }

bool CSGShape3D::get_collision_mask_value(int p_layer_number) const { … }

void CSGShape3D::set_collision_priority(real_t p_priority) { … }

real_t CSGShape3D::get_collision_priority() const { … }

bool CSGShape3D::is_root_shape() const { … }

void CSGShape3D::set_snap(float p_snap) { … }

float CSGShape3D::get_snap() const { … }

void CSGShape3D::_make_dirty(bool p_parent_removing) { … }

enum ManifoldProperty { … };

static void _unpack_manifold(
		const manifold::Manifold &p_manifold,
		const HashMap<int32_t, Ref<Material>> &p_mesh_materials,
		CSGBrush *r_mesh_merge) { … }

static void _pack_manifold(
		const CSGBrush *const p_mesh_merge,
		manifold::Manifold &r_manifold,
		HashMap<int32_t, Ref<Material>> &p_mesh_materials,
		float p_snap) { … }

struct ManifoldOperation { … };

CSGBrush *CSGShape3D::_get_brush() { … }

int CSGShape3D::mikktGetNumFaces(const SMikkTSpaceContext *pContext) { … }

int CSGShape3D::mikktGetNumVerticesOfFace(const SMikkTSpaceContext *pContext, const int iFace) { … }

void CSGShape3D::mikktGetPosition(const SMikkTSpaceContext *pContext, float fvPosOut[], const int iFace, const int iVert) { … }

void CSGShape3D::mikktGetNormal(const SMikkTSpaceContext *pContext, float fvNormOut[], const int iFace, const int iVert) { … }

void CSGShape3D::mikktGetTexCoord(const SMikkTSpaceContext *pContext, float fvTexcOut[], const int iFace, const int iVert) { … }

void CSGShape3D::mikktSetTSpaceDefault(const SMikkTSpaceContext *pContext, const float fvTangent[], const float fvBiTangent[], const float fMagS, const float fMagT,
		const tbool bIsOrientationPreserving, const int iFace, const int iVert) { … }

void CSGShape3D::_update_shape() { … }

Vector<Vector3> CSGShape3D::_get_brush_collision_faces() { … }

void CSGShape3D::_update_collision_faces() { … }

Ref<ArrayMesh> CSGShape3D::bake_static_mesh() { … }

Ref<ConcavePolygonShape3D> CSGShape3D::bake_collision_shape() { … }

bool CSGShape3D::_is_debug_collision_shape_visible() { … }

void CSGShape3D::_update_debug_collision_shape() { … }

void CSGShape3D::_clear_debug_collision_shape() { … }

void CSGShape3D::_on_transform_changed() { … }

AABB CSGShape3D::get_aabb() const { … }

Vector<Vector3> CSGShape3D::get_brush_faces() { … }

void CSGShape3D::_notification(int p_what) { … }

void CSGShape3D::set_operation(Operation p_operation) { … }

CSGShape3D::Operation CSGShape3D::get_operation() const { … }

void CSGShape3D::set_calculate_tangents(bool p_calculate_tangents) { … }

bool CSGShape3D::is_calculating_tangents() const { … }

void CSGShape3D::_validate_property(PropertyInfo &p_property) const { … }

Array CSGShape3D::get_meshes() const { … }

void CSGShape3D::_bind_methods() { … }

CSGShape3D::CSGShape3D() { … }

CSGShape3D::~CSGShape3D() { … }

//////////////////////////////////

CSGBrush *CSGCombiner3D::_build_brush() { … }

CSGCombiner3D::CSGCombiner3D() { … }

/////////////////////

CSGBrush *CSGPrimitive3D::_create_brush_from_arrays(const Vector<Vector3> &p_vertices, const Vector<Vector2> &p_uv, const Vector<bool> &p_smooth, const Vector<Ref<Material>> &p_materials) { … }

void CSGPrimitive3D::_bind_methods() { … }

void CSGPrimitive3D::set_flip_faces(bool p_invert) { … }

bool CSGPrimitive3D::get_flip_faces() { … }

CSGPrimitive3D::CSGPrimitive3D() { … }

/////////////////////

CSGBrush *CSGMesh3D::_build_brush() { … }

void CSGMesh3D::_mesh_changed() { … }

void CSGMesh3D::set_material(const Ref<Material> &p_material) { … }

Ref<Material> CSGMesh3D::get_material() const { … }

void CSGMesh3D::_bind_methods() { … }

void CSGMesh3D::set_mesh(const Ref<Mesh> &p_mesh) { … }

Ref<Mesh> CSGMesh3D::get_mesh() { … }

////////////////////////////////

CSGBrush *CSGSphere3D::_build_brush() { … }

void CSGSphere3D::_bind_methods() { … }

void CSGSphere3D::set_radius(const float p_radius) { … }

float CSGSphere3D::get_radius() const { … }

void CSGSphere3D::set_radial_segments(const int p_radial_segments) { … }

int CSGSphere3D::get_radial_segments() const { … }

void CSGSphere3D::set_rings(const int p_rings) { … }

int CSGSphere3D::get_rings() const { … }

void CSGSphere3D::set_smooth_faces(const bool p_smooth_faces) { … }

bool CSGSphere3D::get_smooth_faces() const { … }

void CSGSphere3D::set_material(const Ref<Material> &p_material) { … }

Ref<Material> CSGSphere3D::get_material() const { … }

CSGSphere3D::CSGSphere3D() { … }

///////////////

CSGBrush *CSGBox3D::_build_brush() { … }

void CSGBox3D::_bind_methods() { … }

void CSGBox3D::set_size(const Vector3 &p_size) { … }

Vector3 CSGBox3D::get_size() const { … }

#ifndef DISABLE_DEPRECATED
// Kept for compatibility from 3.x to 4.0.
bool CSGBox3D::_set(const StringName &p_name, const Variant &p_value) { … }
#endif

void CSGBox3D::set_material(const Ref<Material> &p_material) { … }

Ref<Material> CSGBox3D::get_material() const { … }

///////////////

CSGBrush *CSGCylinder3D::_build_brush() { … }

void CSGCylinder3D::_bind_methods() { … }

void CSGCylinder3D::set_radius(const float p_radius) { … }

float CSGCylinder3D::get_radius() const { … }

void CSGCylinder3D::set_height(const float p_height) { … }

float CSGCylinder3D::get_height() const { … }

void CSGCylinder3D::set_sides(const int p_sides) { … }

int CSGCylinder3D::get_sides() const { … }

void CSGCylinder3D::set_cone(const bool p_cone) { … }

bool CSGCylinder3D::is_cone() const { … }

void CSGCylinder3D::set_smooth_faces(const bool p_smooth_faces) { … }

bool CSGCylinder3D::get_smooth_faces() const { … }

void CSGCylinder3D::set_material(const Ref<Material> &p_material) { … }

Ref<Material> CSGCylinder3D::get_material() const { … }

CSGCylinder3D::CSGCylinder3D() { … }

///////////////

CSGBrush *CSGTorus3D::_build_brush() { … }

void CSGTorus3D::_bind_methods() { … }

void CSGTorus3D::set_inner_radius(const float p_inner_radius) { … }

float CSGTorus3D::get_inner_radius() const { … }

void CSGTorus3D::set_outer_radius(const float p_outer_radius) { … }

float CSGTorus3D::get_outer_radius() const { … }

void CSGTorus3D::set_sides(const int p_sides) { … }

int CSGTorus3D::get_sides() const { … }

void CSGTorus3D::set_ring_sides(const int p_ring_sides) { … }

int CSGTorus3D::get_ring_sides() const { … }

void CSGTorus3D::set_smooth_faces(const bool p_smooth_faces) { … }

bool CSGTorus3D::get_smooth_faces() const { … }

void CSGTorus3D::set_material(const Ref<Material> &p_material) { … }

Ref<Material> CSGTorus3D::get_material() const { … }

CSGTorus3D::CSGTorus3D() { … }

///////////////

CSGBrush *CSGPolygon3D::_build_brush() { … }

void CSGPolygon3D::_notification(int p_what) { … }

void CSGPolygon3D::_validate_property(PropertyInfo &p_property) const { … }

void CSGPolygon3D::_path_changed() { … }

void CSGPolygon3D::_path_exited() { … }

void CSGPolygon3D::_bind_methods() { … }

void CSGPolygon3D::set_polygon(const Vector<Vector2> &p_polygon) { … }

Vector<Vector2> CSGPolygon3D::get_polygon() const { … }

void CSGPolygon3D::set_mode(Mode p_mode) { … }

CSGPolygon3D::Mode CSGPolygon3D::get_mode() const { … }

void CSGPolygon3D::set_depth(const float p_depth) { … }

float CSGPolygon3D::get_depth() const { … }

void CSGPolygon3D::set_path_continuous_u(bool p_enable) { … }

bool CSGPolygon3D::is_path_continuous_u() const { … }

void CSGPolygon3D::set_path_u_distance(real_t p_path_u_distance) { … }

real_t CSGPolygon3D::get_path_u_distance() const { … }

void CSGPolygon3D::set_spin_degrees(const float p_spin_degrees) { … }

float CSGPolygon3D::get_spin_degrees() const { … }

void CSGPolygon3D::set_spin_sides(int p_spin_sides) { … }

int CSGPolygon3D::get_spin_sides() const { … }

void CSGPolygon3D::set_path_node(const NodePath &p_path) { … }

NodePath CSGPolygon3D::get_path_node() const { … }

void CSGPolygon3D::set_path_interval_type(PathIntervalType p_interval_type) { … }

CSGPolygon3D::PathIntervalType CSGPolygon3D::get_path_interval_type() const { … }

void CSGPolygon3D::set_path_interval(float p_interval) { … }

float CSGPolygon3D::get_path_interval() const { … }

void CSGPolygon3D::set_path_simplify_angle(float p_angle) { … }

float CSGPolygon3D::get_path_simplify_angle() const { … }

void CSGPolygon3D::set_path_rotation(PathRotation p_rotation) { … }

CSGPolygon3D::PathRotation CSGPolygon3D::get_path_rotation() const { … }

void CSGPolygon3D::set_path_local(bool p_enable) { … }

bool CSGPolygon3D::is_path_local() const { … }

void CSGPolygon3D::set_path_joined(bool p_enable) { … }

bool CSGPolygon3D::is_path_joined() const { … }

void CSGPolygon3D::set_smooth_faces(const bool p_smooth_faces) { … }

bool CSGPolygon3D::get_smooth_faces() const { … }

void CSGPolygon3D::set_material(const Ref<Material> &p_material) { … }

Ref<Material> CSGPolygon3D::get_material() const { … }

bool CSGPolygon3D::_is_editable_3d_polygon() const { … }

bool CSGPolygon3D::_has_editable_3d_polygon_no_depth() const { … }

CSGPolygon3D::CSGPolygon3D() { … }
godot/modules/csg/csg_shape.cpp
