material.cpp | Explore in Territory

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

#include "core/config/engine.h"
#include "core/config/project_settings.h"
#include "core/error/error_macros.h"
#include "core/version.h"
#include "scene/main/scene_tree.h"

void Material::set_next_pass(const Ref<Material> &p_pass) { … }

Ref<Material> Material::get_next_pass() const { … }

void Material::set_render_priority(int p_priority) { … }

int Material::get_render_priority() const { … }

RID Material::get_rid() const { … }

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

void Material::_mark_ready() { … }

void Material::_mark_initialized(const Callable &p_add_to_dirty_list, const Callable &p_update_shader) { … }

void Material::inspect_native_shader_code() { … }

RID Material::get_shader_rid() const { … }
Shader::Mode Material::get_shader_mode() const { … }

bool Material::_can_do_next_pass() const { … }

bool Material::_can_use_render_priority() const { … }

Ref<Resource> Material::create_placeholder() const { … }

void Material::_bind_methods() { … }

Material::Material() { … }

Material::~Material() { … }

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

bool ShaderMaterial::_set(const StringName &p_name, const Variant &p_value) { … }

bool ShaderMaterial::_get(const StringName &p_name, Variant &r_ret) const { … }

void ShaderMaterial::_get_property_list(List<PropertyInfo> *p_list) const { … }

bool ShaderMaterial::_property_can_revert(const StringName &p_name) const { … }

bool ShaderMaterial::_property_get_revert(const StringName &p_name, Variant &r_property) const { … }

void ShaderMaterial::set_shader(const Ref<Shader> &p_shader) { … }

Ref<Shader> ShaderMaterial::get_shader() const { … }

void ShaderMaterial::set_shader_parameter(const StringName &p_param, const Variant &p_value) { … }

Variant ShaderMaterial::get_shader_parameter(const StringName &p_param) const { … }

void ShaderMaterial::_shader_changed() { … }

void ShaderMaterial::_bind_methods() { … }

#ifdef TOOLS_ENABLED
void ShaderMaterial::get_argument_options(const StringName &p_function, int p_idx, List<String> *r_options) const { … }
#endif

bool ShaderMaterial::_can_do_next_pass() const { … }

bool ShaderMaterial::_can_use_render_priority() const { … }

Shader::Mode ShaderMaterial::get_shader_mode() const { … }
RID ShaderMaterial::get_shader_rid() const { … }

ShaderMaterial::ShaderMaterial() { … }

ShaderMaterial::~ShaderMaterial() { … }

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

Mutex BaseMaterial3D::material_mutex;
SelfList<BaseMaterial3D>::List BaseMaterial3D::dirty_materials;
HashMap<BaseMaterial3D::MaterialKey, BaseMaterial3D::ShaderData, BaseMaterial3D::MaterialKey> BaseMaterial3D::shader_map;
BaseMaterial3D::ShaderNames *BaseMaterial3D::shader_names = …;

void BaseMaterial3D::init_shaders() { … }

HashMap<uint64_t, Ref<StandardMaterial3D>> BaseMaterial3D::materials_for_2d;

void BaseMaterial3D::finish_shaders() { … }

void BaseMaterial3D::_update_shader() { … }

void BaseMaterial3D::flush_changes() { … }

void BaseMaterial3D::_queue_shader_change() { … }

void BaseMaterial3D::set_albedo(const Color &p_albedo) { … }

Color BaseMaterial3D::get_albedo() const { … }

void BaseMaterial3D::set_specular(float p_specular) { … }

float BaseMaterial3D::get_specular() const { … }

void BaseMaterial3D::set_roughness(float p_roughness) { … }

float BaseMaterial3D::get_roughness() const { … }

void BaseMaterial3D::set_metallic(float p_metallic) { … }

float BaseMaterial3D::get_metallic() const { … }

void BaseMaterial3D::set_emission(const Color &p_emission) { … }

Color BaseMaterial3D::get_emission() const { … }

void BaseMaterial3D::set_emission_energy_multiplier(float p_emission_energy_multiplier) { … }

float BaseMaterial3D::get_emission_energy_multiplier() const { … }

void BaseMaterial3D::set_emission_intensity(float p_emission_intensity) { … }

float BaseMaterial3D::get_emission_intensity() const { … }

void BaseMaterial3D::set_normal_scale(float p_normal_scale) { … }

float BaseMaterial3D::get_normal_scale() const { … }

void BaseMaterial3D::set_rim(float p_rim) { … }

float BaseMaterial3D::get_rim() const { … }

void BaseMaterial3D::set_rim_tint(float p_rim_tint) { … }

float BaseMaterial3D::get_rim_tint() const { … }

void BaseMaterial3D::set_ao_light_affect(float p_ao_light_affect) { … }

float BaseMaterial3D::get_ao_light_affect() const { … }

void BaseMaterial3D::set_clearcoat(float p_clearcoat) { … }

float BaseMaterial3D::get_clearcoat() const { … }

void BaseMaterial3D::set_clearcoat_roughness(float p_clearcoat_roughness) { … }

float BaseMaterial3D::get_clearcoat_roughness() const { … }

void BaseMaterial3D::set_anisotropy(float p_anisotropy) { … }

float BaseMaterial3D::get_anisotropy() const { … }

void BaseMaterial3D::set_heightmap_scale(float p_heightmap_scale) { … }

float BaseMaterial3D::get_heightmap_scale() const { … }

void BaseMaterial3D::set_subsurface_scattering_strength(float p_subsurface_scattering_strength) { … }

float BaseMaterial3D::get_subsurface_scattering_strength() const { … }

void BaseMaterial3D::set_transmittance_color(const Color &p_color) { … }

Color BaseMaterial3D::get_transmittance_color() const { … }

void BaseMaterial3D::set_transmittance_depth(float p_depth) { … }

float BaseMaterial3D::get_transmittance_depth() const { … }

void BaseMaterial3D::set_transmittance_boost(float p_boost) { … }

float BaseMaterial3D::get_transmittance_boost() const { … }

void BaseMaterial3D::set_backlight(const Color &p_backlight) { … }

Color BaseMaterial3D::get_backlight() const { … }

void BaseMaterial3D::set_refraction(float p_refraction) { … }

float BaseMaterial3D::get_refraction() const { … }

void BaseMaterial3D::set_detail_uv(DetailUV p_detail_uv) { … }

BaseMaterial3D::DetailUV BaseMaterial3D::get_detail_uv() const { … }

void BaseMaterial3D::set_blend_mode(BlendMode p_mode) { … }

BaseMaterial3D::BlendMode BaseMaterial3D::get_blend_mode() const { … }

void BaseMaterial3D::set_detail_blend_mode(BlendMode p_mode) { … }

BaseMaterial3D::BlendMode BaseMaterial3D::get_detail_blend_mode() const { … }

void BaseMaterial3D::set_transparency(Transparency p_transparency) { … }

BaseMaterial3D::Transparency BaseMaterial3D::get_transparency() const { … }

void BaseMaterial3D::set_alpha_antialiasing(AlphaAntiAliasing p_alpha_aa) { … }

BaseMaterial3D::AlphaAntiAliasing BaseMaterial3D::get_alpha_antialiasing() const { … }

void BaseMaterial3D::set_shading_mode(ShadingMode p_shading_mode) { … }

BaseMaterial3D::ShadingMode BaseMaterial3D::get_shading_mode() const { … }

void BaseMaterial3D::set_depth_draw_mode(DepthDrawMode p_mode) { … }

BaseMaterial3D::DepthDrawMode BaseMaterial3D::get_depth_draw_mode() const { … }

void BaseMaterial3D::set_cull_mode(CullMode p_mode) { … }

BaseMaterial3D::CullMode BaseMaterial3D::get_cull_mode() const { … }

void BaseMaterial3D::set_diffuse_mode(DiffuseMode p_mode) { … }

BaseMaterial3D::DiffuseMode BaseMaterial3D::get_diffuse_mode() const { … }

void BaseMaterial3D::set_specular_mode(SpecularMode p_mode) { … }

BaseMaterial3D::SpecularMode BaseMaterial3D::get_specular_mode() const { … }

void BaseMaterial3D::set_flag(Flags p_flag, bool p_enabled) { … }

bool BaseMaterial3D::get_flag(Flags p_flag) const { … }

void BaseMaterial3D::set_feature(Feature p_feature, bool p_enabled) { … }

bool BaseMaterial3D::get_feature(Feature p_feature) const { … }

void BaseMaterial3D::set_texture(TextureParam p_param, const Ref<Texture2D> &p_texture) { … }

Ref<Texture2D> BaseMaterial3D::get_texture(TextureParam p_param) const { … }

Ref<Texture2D> BaseMaterial3D::get_texture_by_name(const StringName &p_name) const { … }

void BaseMaterial3D::set_texture_filter(TextureFilter p_filter) { … }

BaseMaterial3D::TextureFilter BaseMaterial3D::get_texture_filter() const { … }

void BaseMaterial3D::_validate_feature(const String &text, Feature feature, PropertyInfo &property) const { … }

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

void BaseMaterial3D::set_point_size(float p_point_size) { … }

float BaseMaterial3D::get_point_size() const { … }

void BaseMaterial3D::set_uv1_scale(const Vector3 &p_scale) { … }

Vector3 BaseMaterial3D::get_uv1_scale() const { … }

void BaseMaterial3D::set_uv1_offset(const Vector3 &p_offset) { … }

Vector3 BaseMaterial3D::get_uv1_offset() const { … }

void BaseMaterial3D::set_uv1_triplanar_blend_sharpness(float p_sharpness) { … }

float BaseMaterial3D::get_uv1_triplanar_blend_sharpness() const { … }

void BaseMaterial3D::set_uv2_scale(const Vector3 &p_scale) { … }

Vector3 BaseMaterial3D::get_uv2_scale() const { … }

void BaseMaterial3D::set_uv2_offset(const Vector3 &p_offset) { … }

Vector3 BaseMaterial3D::get_uv2_offset() const { … }

void BaseMaterial3D::set_uv2_triplanar_blend_sharpness(float p_sharpness) { … }

float BaseMaterial3D::get_uv2_triplanar_blend_sharpness() const { … }

void BaseMaterial3D::set_billboard_mode(BillboardMode p_mode) { … }

BaseMaterial3D::BillboardMode BaseMaterial3D::get_billboard_mode() const { … }

void BaseMaterial3D::set_particles_anim_h_frames(int p_frames) { … }

int BaseMaterial3D::get_particles_anim_h_frames() const { … }

void BaseMaterial3D::set_particles_anim_v_frames(int p_frames) { … }

int BaseMaterial3D::get_particles_anim_v_frames() const { … }

void BaseMaterial3D::set_particles_anim_loop(bool p_loop) { … }

bool BaseMaterial3D::get_particles_anim_loop() const { … }

void BaseMaterial3D::set_heightmap_deep_parallax(bool p_enable) { … }

bool BaseMaterial3D::is_heightmap_deep_parallax_enabled() const { … }

void BaseMaterial3D::set_heightmap_deep_parallax_min_layers(int p_layer) { … }

int BaseMaterial3D::get_heightmap_deep_parallax_min_layers() const { … }

void BaseMaterial3D::set_heightmap_deep_parallax_max_layers(int p_layer) { … }

int BaseMaterial3D::get_heightmap_deep_parallax_max_layers() const { … }

void BaseMaterial3D::set_heightmap_deep_parallax_flip_tangent(bool p_flip) { … }

bool BaseMaterial3D::get_heightmap_deep_parallax_flip_tangent() const { … }

void BaseMaterial3D::set_heightmap_deep_parallax_flip_binormal(bool p_flip) { … }

bool BaseMaterial3D::get_heightmap_deep_parallax_flip_binormal() const { … }

void BaseMaterial3D::set_grow_enabled(bool p_enable) { … }

bool BaseMaterial3D::is_grow_enabled() const { … }

void BaseMaterial3D::set_alpha_scissor_threshold(float p_threshold) { … }

float BaseMaterial3D::get_alpha_scissor_threshold() const { … }

void BaseMaterial3D::set_alpha_hash_scale(float p_scale) { … }

float BaseMaterial3D::get_alpha_hash_scale() const { … }

void BaseMaterial3D::set_alpha_antialiasing_edge(float p_edge) { … }

float BaseMaterial3D::get_alpha_antialiasing_edge() const { … }

void BaseMaterial3D::set_grow(float p_grow) { … }

float BaseMaterial3D::get_grow() const { … }

static Plane _get_texture_mask(BaseMaterial3D::TextureChannel p_channel) { … }

void BaseMaterial3D::set_metallic_texture_channel(TextureChannel p_channel) { … }

BaseMaterial3D::TextureChannel BaseMaterial3D::get_metallic_texture_channel() const { … }

void BaseMaterial3D::set_roughness_texture_channel(TextureChannel p_channel) { … }

BaseMaterial3D::TextureChannel BaseMaterial3D::get_roughness_texture_channel() const { … }

void BaseMaterial3D::set_ao_texture_channel(TextureChannel p_channel) { … }

BaseMaterial3D::TextureChannel BaseMaterial3D::get_ao_texture_channel() const { … }

void BaseMaterial3D::set_refraction_texture_channel(TextureChannel p_channel) { … }

BaseMaterial3D::TextureChannel BaseMaterial3D::get_refraction_texture_channel() const { … }

Ref<Material> BaseMaterial3D::get_material_for_2d(bool p_shaded, Transparency p_transparency, bool p_double_sided, bool p_billboard, bool p_billboard_y, bool p_msdf, bool p_no_depth, bool p_fixed_size, TextureFilter p_filter, AlphaAntiAliasing p_alpha_antialiasing_mode, RID *r_shader_rid) { … }

void BaseMaterial3D::set_on_top_of_alpha() { … }

void BaseMaterial3D::set_proximity_fade_enabled(bool p_enable) { … }

bool BaseMaterial3D::is_proximity_fade_enabled() const { … }

void BaseMaterial3D::set_proximity_fade_distance(float p_distance) { … }

float BaseMaterial3D::get_proximity_fade_distance() const { … }

void BaseMaterial3D::set_msdf_pixel_range(float p_range) { … }

float BaseMaterial3D::get_msdf_pixel_range() const { … }

void BaseMaterial3D::set_msdf_outline_size(float p_size) { … }

float BaseMaterial3D::get_msdf_outline_size() const { … }

void BaseMaterial3D::set_distance_fade(DistanceFadeMode p_mode) { … }

BaseMaterial3D::DistanceFadeMode BaseMaterial3D::get_distance_fade() const { … }

void BaseMaterial3D::set_distance_fade_max_distance(float p_distance) { … }

float BaseMaterial3D::get_distance_fade_max_distance() const { … }

void BaseMaterial3D::set_distance_fade_min_distance(float p_distance) { … }

float BaseMaterial3D::get_distance_fade_min_distance() const { … }

void BaseMaterial3D::set_emission_operator(EmissionOperator p_op) { … }

BaseMaterial3D::EmissionOperator BaseMaterial3D::get_emission_operator() const { … }

RID BaseMaterial3D::get_shader_rid() const { … }

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

void BaseMaterial3D::_bind_methods() { … }

BaseMaterial3D::BaseMaterial3D(bool p_orm) : … { … }

BaseMaterial3D::~BaseMaterial3D() { … }

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

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

#endif // DISABLE_DEPRECATED

///////////////////////
godot/scene/resources/material.cpp
