godot/scene/3d/gpu_particles_collision_3d.cpp

/**************************************************************************/
/*  gpu_particles_collision_3d.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 "gpu_particles_collision_3d.h"

#include "core/object/worker_thread_pool.h"
#include "mesh_instance_3d.h"
#include "scene/3d/camera_3d.h"
#include "scene/main/viewport.h"

void GPUParticlesCollision3D::set_cull_mask(uint32_t p_cull_mask) {}

uint32_t GPUParticlesCollision3D::get_cull_mask() const {}

void GPUParticlesCollision3D::_bind_methods() {}

GPUParticlesCollision3D::GPUParticlesCollision3D(RS::ParticlesCollisionType p_type) {}

GPUParticlesCollision3D::~GPUParticlesCollision3D() {}

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

void GPUParticlesCollisionSphere3D::_bind_methods() {}

void GPUParticlesCollisionSphere3D::set_radius(real_t p_radius) {}

real_t GPUParticlesCollisionSphere3D::get_radius() const {}

AABB GPUParticlesCollisionSphere3D::get_aabb() const {}

GPUParticlesCollisionSphere3D::GPUParticlesCollisionSphere3D() :{}

GPUParticlesCollisionSphere3D::~GPUParticlesCollisionSphere3D() {}

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

void GPUParticlesCollisionBox3D::_bind_methods() {}

#ifndef DISABLE_DEPRECATED
bool GPUParticlesCollisionBox3D::_set(const StringName &p_name, const Variant &p_value) {}

bool GPUParticlesCollisionBox3D::_get(const StringName &p_name, Variant &r_property) const {}
#endif // DISABLE_DEPRECATED

void GPUParticlesCollisionBox3D::set_size(const Vector3 &p_size) {}

Vector3 GPUParticlesCollisionBox3D::get_size() const {}

AABB GPUParticlesCollisionBox3D::get_aabb() const {}

GPUParticlesCollisionBox3D::GPUParticlesCollisionBox3D() :{}

GPUParticlesCollisionBox3D::~GPUParticlesCollisionBox3D() {}

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

void GPUParticlesCollisionSDF3D::_find_meshes(const AABB &p_aabb, Node *p_at_node, List<PlotMesh> &plot_meshes) {}

uint32_t GPUParticlesCollisionSDF3D::_create_bvh(LocalVector<BVH> &bvh_tree, FacePos *p_faces, uint32_t p_face_count, const Face3 *p_triangles, float p_thickness) {}

static _FORCE_INLINE_ real_t Vector3_dot2(const Vector3 &p_vec3) {}

void GPUParticlesCollisionSDF3D::_find_closest_distance(const Vector3 &p_pos, const BVH *p_bvh, uint32_t p_bvh_cell, const Face3 *p_triangles, float p_thickness, float &r_closest_distance) {}

void GPUParticlesCollisionSDF3D::_compute_sdf_z(uint32_t p_z, ComputeSDFParams *params) {}

void GPUParticlesCollisionSDF3D::_compute_sdf(ComputeSDFParams *params) {}

Vector3i GPUParticlesCollisionSDF3D::get_estimated_cell_size() const {}

Ref<Image> GPUParticlesCollisionSDF3D::bake() {}

PackedStringArray GPUParticlesCollisionSDF3D::get_configuration_warnings() const {}

void GPUParticlesCollisionSDF3D::_bind_methods() {}

#ifndef DISABLE_DEPRECATED
bool GPUParticlesCollisionSDF3D::_set(const StringName &p_name, const Variant &p_value) {}

bool GPUParticlesCollisionSDF3D::_get(const StringName &p_name, Variant &r_property) const {}
#endif // DISABLE_DEPRECATED

void GPUParticlesCollisionSDF3D::set_thickness(float p_thickness) {}

float GPUParticlesCollisionSDF3D::get_thickness() const {}

void GPUParticlesCollisionSDF3D::set_size(const Vector3 &p_size) {}

Vector3 GPUParticlesCollisionSDF3D::get_size() const {}

void GPUParticlesCollisionSDF3D::set_resolution(Resolution p_resolution) {}

GPUParticlesCollisionSDF3D::Resolution GPUParticlesCollisionSDF3D::get_resolution() const {}

void GPUParticlesCollisionSDF3D::set_bake_mask(uint32_t p_mask) {}

uint32_t GPUParticlesCollisionSDF3D::get_bake_mask() const {}

void GPUParticlesCollisionSDF3D::set_bake_mask_value(int p_layer_number, bool p_value) {}

bool GPUParticlesCollisionSDF3D::get_bake_mask_value(int p_layer_number) const {}

void GPUParticlesCollisionSDF3D::set_texture(const Ref<Texture3D> &p_texture) {}

Ref<Texture3D> GPUParticlesCollisionSDF3D::get_texture() const {}

AABB GPUParticlesCollisionSDF3D::get_aabb() const {}

GPUParticlesCollisionSDF3D::BakeBeginFunc GPUParticlesCollisionSDF3D::bake_begin_function =;
GPUParticlesCollisionSDF3D::BakeStepFunc GPUParticlesCollisionSDF3D::bake_step_function =;
GPUParticlesCollisionSDF3D::BakeEndFunc GPUParticlesCollisionSDF3D::bake_end_function =;

GPUParticlesCollisionSDF3D::GPUParticlesCollisionSDF3D() :{}

GPUParticlesCollisionSDF3D::~GPUParticlesCollisionSDF3D() {}

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

void GPUParticlesCollisionHeightField3D::_notification(int p_what) {}

void GPUParticlesCollisionHeightField3D::_bind_methods() {}

#ifndef DISABLE_DEPRECATED
bool GPUParticlesCollisionHeightField3D::_set(const StringName &p_name, const Variant &p_value) {}

bool GPUParticlesCollisionHeightField3D::_get(const StringName &p_name, Variant &r_property) const {}
#endif // DISABLE_DEPRECATED

void GPUParticlesCollisionHeightField3D::set_size(const Vector3 &p_size) {}

Vector3 GPUParticlesCollisionHeightField3D::get_size() const {}

void GPUParticlesCollisionHeightField3D::set_resolution(Resolution p_resolution) {}

GPUParticlesCollisionHeightField3D::Resolution GPUParticlesCollisionHeightField3D::get_resolution() const {}

void GPUParticlesCollisionHeightField3D::set_update_mode(UpdateMode p_update_mode) {}

GPUParticlesCollisionHeightField3D::UpdateMode GPUParticlesCollisionHeightField3D::get_update_mode() const {}

void GPUParticlesCollisionHeightField3D::set_follow_camera_enabled(bool p_enabled) {}

bool GPUParticlesCollisionHeightField3D::is_follow_camera_enabled() const {}

AABB GPUParticlesCollisionHeightField3D::get_aabb() const {}

GPUParticlesCollisionHeightField3D::GPUParticlesCollisionHeightField3D() :{}

GPUParticlesCollisionHeightField3D::~GPUParticlesCollisionHeightField3D() {}

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

void GPUParticlesAttractor3D::set_cull_mask(uint32_t p_cull_mask) {}

uint32_t GPUParticlesAttractor3D::get_cull_mask() const {}

void GPUParticlesAttractor3D::set_strength(real_t p_strength) {}

real_t GPUParticlesAttractor3D::get_strength() const {}

void GPUParticlesAttractor3D::set_attenuation(real_t p_attenuation) {}

real_t GPUParticlesAttractor3D::get_attenuation() const {}

void GPUParticlesAttractor3D::set_directionality(real_t p_directionality) {}

real_t GPUParticlesAttractor3D::get_directionality() const {}

void GPUParticlesAttractor3D::_bind_methods() {}

GPUParticlesAttractor3D::GPUParticlesAttractor3D(RS::ParticlesCollisionType p_type) {}
GPUParticlesAttractor3D::~GPUParticlesAttractor3D() {}

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

void GPUParticlesAttractorSphere3D::_bind_methods() {}

void GPUParticlesAttractorSphere3D::set_radius(real_t p_radius) {}

real_t GPUParticlesAttractorSphere3D::get_radius() const {}

AABB GPUParticlesAttractorSphere3D::get_aabb() const {}

GPUParticlesAttractorSphere3D::GPUParticlesAttractorSphere3D() :{}

GPUParticlesAttractorSphere3D::~GPUParticlesAttractorSphere3D() {}

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

void GPUParticlesAttractorBox3D::_bind_methods() {}

#ifndef DISABLE_DEPRECATED
bool GPUParticlesAttractorBox3D::_set(const StringName &p_name, const Variant &p_value) {}

bool GPUParticlesAttractorBox3D::_get(const StringName &p_name, Variant &r_property) const {}
#endif // DISABLE_DEPRECATED

void GPUParticlesAttractorBox3D::set_size(const Vector3 &p_size) {}

Vector3 GPUParticlesAttractorBox3D::get_size() const {}

AABB GPUParticlesAttractorBox3D::get_aabb() const {}

GPUParticlesAttractorBox3D::GPUParticlesAttractorBox3D() :{}

GPUParticlesAttractorBox3D::~GPUParticlesAttractorBox3D() {}

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

void GPUParticlesAttractorVectorField3D::_bind_methods() {}

#ifndef DISABLE_DEPRECATED
bool GPUParticlesAttractorVectorField3D::_set(const StringName &p_name, const Variant &p_value) {}

bool GPUParticlesAttractorVectorField3D::_get(const StringName &p_name, Variant &r_property) const {}
#endif // DISABLE_DEPRECATED

void GPUParticlesAttractorVectorField3D::set_size(const Vector3 &p_size) {}

Vector3 GPUParticlesAttractorVectorField3D::get_size() const {}

void GPUParticlesAttractorVectorField3D::set_texture(const Ref<Texture3D> &p_texture) {}

Ref<Texture3D> GPUParticlesAttractorVectorField3D::get_texture() const {}

AABB GPUParticlesAttractorVectorField3D::get_aabb() const {}

GPUParticlesAttractorVectorField3D::GPUParticlesAttractorVectorField3D() :{}

GPUParticlesAttractorVectorField3D::~GPUParticlesAttractorVectorField3D() {}