particle_process_material.cpp | Explore in Territory

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

#include "core/version.h"

Mutex ParticleProcessMaterial::material_mutex;
SelfList<ParticleProcessMaterial>::List ParticleProcessMaterial::dirty_materials;
HashMap<ParticleProcessMaterial::MaterialKey, ParticleProcessMaterial::ShaderData, ParticleProcessMaterial::MaterialKey> ParticleProcessMaterial::shader_map;
RBSet<String> ParticleProcessMaterial::min_max_properties;
ParticleProcessMaterial::ShaderNames *ParticleProcessMaterial::shader_names = …;

void ParticleProcessMaterial::init_shaders() { … }

void ParticleProcessMaterial::finish_shaders() { … }

void ParticleProcessMaterial::_update_shader() { … }

void ParticleProcessMaterial::flush_changes() { … }

void ParticleProcessMaterial::_queue_shader_change() { … }

bool ParticleProcessMaterial::has_min_max_property(const String &p_name) { … }

void ParticleProcessMaterial::set_direction(Vector3 p_direction) { … }

Vector3 ParticleProcessMaterial::get_direction() const { … }

void ParticleProcessMaterial::set_spread(float p_spread) { … }

float ParticleProcessMaterial::get_spread() const { … }

void ParticleProcessMaterial::set_flatness(float p_flatness) { … }

float ParticleProcessMaterial::get_flatness() const { … }

void ParticleProcessMaterial::set_velocity_pivot(const Vector3 &p_pivot) { … }

Vector3 ParticleProcessMaterial::get_velocity_pivot() { … }

void ParticleProcessMaterial::set_param(Parameter p_param, const Vector2 &p_value) { … }

Vector2 ParticleProcessMaterial::get_param(Parameter p_param) const { … }

void ParticleProcessMaterial::set_param_min(Parameter p_param, float p_value) { … }

float ParticleProcessMaterial::get_param_min(Parameter p_param) const { … }

void ParticleProcessMaterial::set_param_max(Parameter p_param, float p_value) { … }

float ParticleProcessMaterial::get_param_max(Parameter p_param) const { … }

static void _adjust_curve_range(const Ref<Texture2D> &p_texture, float p_min, float p_max) { … }

void ParticleProcessMaterial::set_param_texture(Parameter p_param, const Ref<Texture2D> &p_texture) { … }

Ref<Texture2D> ParticleProcessMaterial::get_param_texture(Parameter p_param) const { … }

void ParticleProcessMaterial::set_color(const Color &p_color) { … }

Color ParticleProcessMaterial::get_color() const { … }

void ParticleProcessMaterial::set_color_ramp(const Ref<Texture2D> &p_texture) { … }

Ref<Texture2D> ParticleProcessMaterial::get_color_ramp() const { … }

void ParticleProcessMaterial::set_color_initial_ramp(const Ref<Texture2D> &p_texture) { … }

Ref<Texture2D> ParticleProcessMaterial::get_color_initial_ramp() const { … }

void ParticleProcessMaterial::set_particle_flag(ParticleFlags p_particle_flag, bool p_enable) { … }

void ParticleProcessMaterial::set_alpha_curve(const Ref<Texture2D> &p_texture) { … }

Ref<Texture2D> ParticleProcessMaterial::get_alpha_curve() const { … }

void ParticleProcessMaterial::set_emission_curve(const Ref<Texture2D> &p_texture) { … }

Ref<Texture2D> ParticleProcessMaterial::get_emission_curve() const { … }

void ParticleProcessMaterial::set_velocity_limit_curve(const Ref<Texture2D> &p_texture) { … }

Ref<Texture2D> ParticleProcessMaterial::get_velocity_limit_curve() const { … }

bool ParticleProcessMaterial::get_particle_flag(ParticleFlags p_particle_flag) const { … }

void ParticleProcessMaterial::set_emission_shape(EmissionShape p_shape) { … }

void ParticleProcessMaterial::set_emission_sphere_radius(real_t p_radius) { … }

void ParticleProcessMaterial::set_emission_box_extents(Vector3 p_extents) { … }

void ParticleProcessMaterial::set_emission_point_texture(const Ref<Texture2D> &p_points) { … }

void ParticleProcessMaterial::set_emission_normal_texture(const Ref<Texture2D> &p_normals) { … }

void ParticleProcessMaterial::set_emission_color_texture(const Ref<Texture2D> &p_colors) { … }

void ParticleProcessMaterial::set_emission_point_count(int p_count) { … }

void ParticleProcessMaterial::set_emission_ring_axis(Vector3 p_axis) { … }

void ParticleProcessMaterial::set_emission_ring_height(real_t p_height) { … }

void ParticleProcessMaterial::set_emission_ring_radius(real_t p_radius) { … }

void ParticleProcessMaterial::set_emission_ring_inner_radius(real_t p_radius) { … }

void ParticleProcessMaterial::set_emission_ring_cone_angle(real_t p_angle) { … }

void ParticleProcessMaterial::set_inherit_velocity_ratio(double p_ratio) { … }

ParticleProcessMaterial::EmissionShape ParticleProcessMaterial::get_emission_shape() const { … }

real_t ParticleProcessMaterial::get_emission_sphere_radius() const { … }

Vector3 ParticleProcessMaterial::get_emission_box_extents() const { … }

Ref<Texture2D> ParticleProcessMaterial::get_emission_point_texture() const { … }

Ref<Texture2D> ParticleProcessMaterial::get_emission_normal_texture() const { … }

Ref<Texture2D> ParticleProcessMaterial::get_emission_color_texture() const { … }

int ParticleProcessMaterial::get_emission_point_count() const { … }

Vector3 ParticleProcessMaterial::get_emission_ring_axis() const { … }

real_t ParticleProcessMaterial::get_emission_ring_height() const { … }

real_t ParticleProcessMaterial::get_emission_ring_radius() const { … }

real_t ParticleProcessMaterial::get_emission_ring_inner_radius() const { … }

real_t ParticleProcessMaterial::get_emission_ring_cone_angle() const { … }

void ParticleProcessMaterial::set_emission_shape_offset(const Vector3 &p_emission_shape_offset) { … }

Vector3 ParticleProcessMaterial::get_emission_shape_offset() const { … }

void ParticleProcessMaterial::set_emission_shape_scale(const Vector3 &p_emission_shape_scale) { … }

Vector3 ParticleProcessMaterial::get_emission_shape_scale() const { … }

double ParticleProcessMaterial::get_inherit_velocity_ratio() { … }

void ParticleProcessMaterial::set_turbulence_enabled(const bool p_turbulence_enabled) { … }

bool ParticleProcessMaterial::get_turbulence_enabled() const { … }

void ParticleProcessMaterial::set_turbulence_noise_strength(float p_turbulence_noise_strength) { … }

float ParticleProcessMaterial::get_turbulence_noise_strength() const { … }

void ParticleProcessMaterial::set_turbulence_noise_scale(float p_turbulence_noise_scale) { … }

float ParticleProcessMaterial::get_turbulence_noise_scale() const { … }

void ParticleProcessMaterial::set_turbulence_noise_speed_random(float p_turbulence_noise_speed_random) { … }

float ParticleProcessMaterial::get_turbulence_noise_speed_random() const { … }

void ParticleProcessMaterial::set_turbulence_noise_speed(const Vector3 &p_turbulence_noise_speed) { … }

Vector3 ParticleProcessMaterial::get_turbulence_noise_speed() const { … }

void ParticleProcessMaterial::set_gravity(const Vector3 &p_gravity) { … }

Vector3 ParticleProcessMaterial::get_gravity() const { … }

void ParticleProcessMaterial::set_lifetime_randomness(double p_lifetime) { … }

double ParticleProcessMaterial::get_lifetime_randomness() const { … }

RID ParticleProcessMaterial::get_shader_rid() const { … }

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

void ParticleProcessMaterial::set_sub_emitter_mode(SubEmitterMode p_sub_emitter_mode) { … }

ParticleProcessMaterial::SubEmitterMode ParticleProcessMaterial::get_sub_emitter_mode() const { … }

void ParticleProcessMaterial::set_sub_emitter_frequency(double p_frequency) { … }

double ParticleProcessMaterial::get_sub_emitter_frequency() const { … }

void ParticleProcessMaterial::set_sub_emitter_amount_at_end(int p_amount) { … }

int ParticleProcessMaterial::get_sub_emitter_amount_at_end() const { … }

void ParticleProcessMaterial::set_sub_emitter_amount_at_collision(int p_amount) { … }

int ParticleProcessMaterial::get_sub_emitter_amount_at_collision() const { … }

void ParticleProcessMaterial::set_sub_emitter_keep_velocity(bool p_enable) { … }
bool ParticleProcessMaterial::get_sub_emitter_keep_velocity() const { … }

void ParticleProcessMaterial::set_attractor_interaction_enabled(bool p_enable) { … }

bool ParticleProcessMaterial::is_attractor_interaction_enabled() const { … }

void ParticleProcessMaterial::set_collision_mode(CollisionMode p_collision_mode) { … }

ParticleProcessMaterial::CollisionMode ParticleProcessMaterial::get_collision_mode() const { … }

void ParticleProcessMaterial::set_collision_use_scale(bool p_scale) { … }

bool ParticleProcessMaterial::is_collision_using_scale() const { … }

void ParticleProcessMaterial::set_collision_friction(float p_friction) { … }

float ParticleProcessMaterial::get_collision_friction() const { … }

void ParticleProcessMaterial::set_collision_bounce(float p_bounce) { … }

float ParticleProcessMaterial::get_collision_bounce() const { … }

Shader::Mode ParticleProcessMaterial::get_shader_mode() const { … }

void ParticleProcessMaterial::_bind_methods() { … }

ParticleProcessMaterial::ParticleProcessMaterial() : … { … }

ParticleProcessMaterial::~ParticleProcessMaterial() { … }
godot/scene/resources/particle_process_material.cpp
