seedlingattempt/godot
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add ORMSpatialMaterial

Browse Source
This commit is contained in:
Ansraer
2024-02-08 20:10:26 +01:00
parent cc4492f9b9
commit b9cbffd957
59 changed files with 1568 additions and 1444 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
scene/3d/baked_lightmap.cpp
View File

@ -451,7 +451,7 @@ void BakedLightmap::_find_meshes_and_lights(Node *p_at_node, Vector<MeshesFound>
void BakedLightmap::_get_material_images(const MeshesFound &p_found_mesh, Lightmapper::MeshData &r_mesh_data, Vector<Ref<Texture>> &r_albedo_textures, Vector<Ref<Texture>> &r_emission_textures) {
for (int i = 0; i < p_found_mesh.mesh->get_surface_count(); ++i) {
Ref<SpatialMaterial> mat = p_found_mesh.overrides[i];
Ref<Material3D> mat = p_found_mesh.overrides[i];
if (mat.is_null()) {
mat = p_found_mesh.mesh->surface_get_material(i);
@ -466,7 +466,7 @@ void BakedLightmap::_get_material_images(const MeshesFound &p_found_mesh, Lightm
Color emission_mul = Color(1, 1, 1, 1);
if (mat.is_valid()) {
albedo_texture = mat->get_texture(SpatialMaterial::TEXTURE_ALBEDO);
albedo_texture = mat->get_texture(Material3D::TEXTURE_ALBEDO);
if (albedo_texture.is_valid()) {
albedo_mul = mat->get_albedo();
@ -475,11 +475,11 @@ void BakedLightmap::_get_material_images(const MeshesFound &p_found_mesh, Lightm
albedo_add = mat->get_albedo();
}
emission_texture = mat->get_texture(SpatialMaterial::TEXTURE_EMISSION);
emission_texture = mat->get_texture(Material3D::TEXTURE_EMISSION);
Color emission_color = mat->get_emission();
float emission_energy = mat->get_emission_energy();
if (mat->get_emission_operator() == SpatialMaterial::EMISSION_OP_ADD) {
if (mat->get_emission_operator() == Material3D::EMISSION_OP_ADD) {
emission_mul = Color(1, 1, 1) * emission_energy;
emission_add = emission_color * emission_energy;
} else {

8
scene/3d/cpu_particles.cpp
View File

@ -209,14 +209,14 @@ String CPUParticles::get_configuration_warning() const {
mesh_found = true;
for (int j = 0; j < get_mesh()->get_surface_count(); j++) {
anim_material_found = Object::cast_to<ShaderMaterial>(get_mesh()->surface_get_material(j).ptr()) != nullptr;
SpatialMaterial *spat = Object::cast_to<SpatialMaterial>(get_mesh()->surface_get_material(j).ptr());
anim_material_found = anim_material_found || (spat && spat->get_billboard_mode() == SpatialMaterial::BILLBOARD_PARTICLES);
Material3D *spat = Object::cast_to<Material3D>(get_mesh()->surface_get_material(j).ptr());
anim_material_found = anim_material_found || (spat && spat->get_billboard_mode() == Material3D::BILLBOARD_PARTICLES);
}
}
anim_material_found = anim_material_found || Object::cast_to<ShaderMaterial>(get_material_override().ptr()) != nullptr;
SpatialMaterial *spat = Object::cast_to<SpatialMaterial>(get_material_override().ptr());
anim_material_found = anim_material_found || (spat && spat->get_billboard_mode() == SpatialMaterial::BILLBOARD_PARTICLES);
Material3D *spat = Object::cast_to<Material3D>(get_material_override().ptr());
anim_material_found = anim_material_found || (spat && spat->get_billboard_mode() == Material3D::BILLBOARD_PARTICLES);
if (!mesh_found) {
if (warnings != String()) {

8
scene/3d/label_3d.cpp
View File

@ -539,7 +539,7 @@ float Label3D::_generate_glyph_surfaces(const Ref<Font> &p_font, CharType p_char
if (!surfaces.has(key)) {
SurfaceData surf;
surf.material = RID_PRIME(VisualServer::get_singleton()->material_create());
// Set defaults for material, names need to match up those in SpatialMaterial
// Set defaults for material, names need to match up those in Material3D
VS::get_singleton()->material_set_param(surf.material, "albedo", Color(1, 1, 1, 1));
VS::get_singleton()->material_set_param(surf.material, "specular", 0.5);
VS::get_singleton()->material_set_param(surf.material, "metallic", 0.0);
@ -550,7 +550,7 @@ float Label3D::_generate_glyph_surfaces(const Ref<Font> &p_font, CharType p_char
VS::get_singleton()->material_set_param(surf.material, "uv2_scale", Vector3(1, 1, 1));
VS::get_singleton()->material_set_param(surf.material, "alpha_scissor_threshold", alpha_scissor_threshold);
RID shader_rid = SpatialMaterial::get_material_rid_for_2d(get_draw_flag(FLAG_SHADED), true, get_draw_flag(FLAG_DOUBLE_SIDED), get_alpha_cut_mode() == ALPHA_CUT_DISCARD, get_alpha_cut_mode() == ALPHA_CUT_OPAQUE_PREPASS, get_billboard_mode() == SpatialMaterial::BILLBOARD_ENABLED, get_billboard_mode() == SpatialMaterial::BILLBOARD_FIXED_Y, get_draw_flag(FLAG_DISABLE_DEPTH_TEST), get_draw_flag(FLAG_FIXED_SIZE), p_font->is_distance_field_hint());
RID shader_rid = Material3D::get_material_rid_for_2d(get_draw_flag(FLAG_SHADED), true, get_draw_flag(FLAG_DOUBLE_SIDED), get_alpha_cut_mode() == ALPHA_CUT_DISCARD, get_alpha_cut_mode() == ALPHA_CUT_OPAQUE_PREPASS, get_billboard_mode() == Material3D::BILLBOARD_ENABLED, get_billboard_mode() == Material3D::BILLBOARD_FIXED_Y, get_draw_flag(FLAG_DISABLE_DEPTH_TEST), get_draw_flag(FLAG_FIXED_SIZE), p_font->is_distance_field_hint());
VS::get_singleton()->material_set_shader(surf.material, VS::get_singleton()->material_get_shader(shader_rid));
VS::get_singleton()->material_set_param(surf.material, "texture_albedo", tex);
@ -1003,7 +1003,7 @@ bool Label3D::get_draw_flag(DrawFlags p_flag) const {
return flags[p_flag];
}
void Label3D::set_billboard_mode(SpatialMaterial::BillboardMode p_mode) {
void Label3D::set_billboard_mode(Material3D::BillboardMode p_mode) {
ERR_FAIL_INDEX(p_mode, 3);
if (billboard_mode != p_mode) {
billboard_mode = p_mode;
@ -1011,7 +1011,7 @@ void Label3D::set_billboard_mode(SpatialMaterial::BillboardMode p_mode) {
}
}
SpatialMaterial::BillboardMode Label3D::get_billboard_mode() const {
Material3D::BillboardMode Label3D::get_billboard_mode() const {
return billboard_mode;
}

6
scene/3d/label_3d.h
View File

@ -158,7 +158,7 @@ private:
float line_spacing = 0.f;
RID base_material;
SpatialMaterial::BillboardMode billboard_mode = SpatialMaterial::BILLBOARD_DISABLED;
Material3D::BillboardMode billboard_mode = Material3D::BILLBOARD_DISABLED;
bool pending_update = false;
@ -232,8 +232,8 @@ public:
void set_alpha_scissor_threshold(float p_threshold);
float get_alpha_scissor_threshold() const;
void set_billboard_mode(SpatialMaterial::BillboardMode p_mode);
SpatialMaterial::BillboardMode get_billboard_mode() const;
void set_billboard_mode(Material3D::BillboardMode p_mode);
Material3D::BillboardMode get_billboard_mode() const;
virtual AABB get_aabb() const;
Ref<TriangleMesh> generate_triangle_mesh() const;

16
scene/3d/mesh_instance.cpp
View File

@ -104,7 +104,7 @@ void MeshInstance::_get_property_list(List<PropertyInfo> *p_list) const {
if (mesh.is_valid()) {
for (int i = 0; i < mesh->get_surface_count(); i++) {
p_list->push_back(PropertyInfo(Variant::OBJECT, vformat("%s/%d", PNAME("material"), i), PROPERTY_HINT_RESOURCE_TYPE, "ShaderMaterial,SpatialMaterial"));
p_list->push_back(PropertyInfo(Variant::OBJECT, vformat("%s/%d", PNAME("material"), i), PROPERTY_HINT_RESOURCE_TYPE, "ShaderMaterial,SpatialMaterial,ORMSpatialMaterial"));
}
}
}
@ -277,11 +277,11 @@ void MeshInstance::_initialize_skinning(bool p_force_reset, bool p_call_attach_s
Ref<Material> mat = get_active_material(surface_index);
if (mat.is_valid()) {
Ref<SpatialMaterial> spatial_mat = mat;
Ref<Material3D> spatial_mat = mat;
if (spatial_mat.is_valid()) {
// Spatial material, check from material settings.
surface_data.transform_tangents = spatial_mat->get_feature(SpatialMaterial::FEATURE_NORMAL_MAPPING);
surface_data.ensure_correct_normals = spatial_mat->get_flag(SpatialMaterial::FLAG_ENSURE_CORRECT_NORMALS);
surface_data.transform_tangents = spatial_mat->get_feature(Material3D::FEATURE_NORMAL_MAPPING);
surface_data.ensure_correct_normals = spatial_mat->get_flag(Material3D::FLAG_ENSURE_CORRECT_NORMALS);
} else {
// Custom shader, must check for compiled flags.
surface_data.transform_tangents = VSG::storage->material_uses_tangents(mat->get_rid());
@ -822,12 +822,12 @@ void MeshInstance::create_debug_tangents() {
}
if (lines.size()) {
Ref<SpatialMaterial> sm;
Ref<Material3D> sm;
sm.instance();
sm->set_flag(SpatialMaterial::FLAG_UNSHADED, true);
sm->set_flag(SpatialMaterial::FLAG_SRGB_VERTEX_COLOR, true);
sm->set_flag(SpatialMaterial::FLAG_ALBEDO_FROM_VERTEX_COLOR, true);
sm->set_flag(Material3D::FLAG_UNSHADED, true);
sm->set_flag(Material3D::FLAG_SRGB_VERTEX_COLOR, true);
sm->set_flag(Material3D::FLAG_ALBEDO_FROM_VERTEX_COLOR, true);
Ref<ArrayMesh> am;
am.instance();

8
scene/3d/particles.cpp
View File

@ -257,8 +257,8 @@ String Particles::get_configuration_warning() const {
meshes_found = true;
for (int j = 0; j < draw_passes[i]->get_surface_count(); j++) {
anim_material_found = Object::cast_to<ShaderMaterial>(draw_passes[i]->surface_get_material(j).ptr()) != nullptr;
SpatialMaterial *spat = Object::cast_to<SpatialMaterial>(draw_passes[i]->surface_get_material(j).ptr());
anim_material_found = anim_material_found || (spat && spat->get_billboard_mode() == SpatialMaterial::BILLBOARD_PARTICLES);
Material3D *spat = Object::cast_to<Material3D>(draw_passes[i]->surface_get_material(j).ptr());
anim_material_found = anim_material_found || (spat && spat->get_billboard_mode() == Material3D::BILLBOARD_PARTICLES);
}
if (anim_material_found) {
break;
@ -267,8 +267,8 @@ String Particles::get_configuration_warning() const {
}
anim_material_found = anim_material_found || Object::cast_to<ShaderMaterial>(get_material_override().ptr()) != nullptr;
SpatialMaterial *spat = Object::cast_to<SpatialMaterial>(get_material_override().ptr());
anim_material_found = anim_material_found || (spat && spat->get_billboard_mode() == SpatialMaterial::BILLBOARD_PARTICLES);
Material3D *spat = Object::cast_to<Material3D>(get_material_override().ptr());
anim_material_found = anim_material_found || (spat && spat->get_billboard_mode() == Material3D::BILLBOARD_PARTICLES);
if (!meshes_found) {
if (warnings != String()) {

12
scene/3d/ray_cast.cpp
View File

@ -392,7 +392,7 @@ void RayCast::set_debug_shape_custom_color(const Color &p_color) {
}
}
Ref<SpatialMaterial> RayCast::get_debug_material() {
Ref<Material3D> RayCast::get_debug_material() {
_update_debug_shape_material();
return debug_material;
}
@ -421,13 +421,13 @@ void RayCast::_create_debug_shape() {
void RayCast::_update_debug_shape_material(bool p_check_collision) {
if (!debug_material.is_valid()) {
Ref<SpatialMaterial> material = memnew(SpatialMaterial);
Ref<Material3D> material = memnew(Material3D);
debug_material = material;
material->set_flag(SpatialMaterial::FLAG_UNSHADED, true);
material->set_feature(SpatialMaterial::FEATURE_TRANSPARENT, true);
material->set_flag(Material3D::FLAG_UNSHADED, true);
material->set_feature(Material3D::FEATURE_TRANSPARENT, true);
// Use double-sided rendering so that the RayCast can be seen if the camera is inside.
material->set_cull_mode(SpatialMaterial::CULL_DISABLED);
material->set_cull_mode(Material3D::CULL_DISABLED);
}
Color color = debug_shape_custom_color;
@ -446,7 +446,7 @@ void RayCast::_update_debug_shape_material(bool p_check_collision) {
}
}
Ref<SpatialMaterial> material = static_cast<Ref<SpatialMaterial>>(debug_material);
Ref<Material3D> material = static_cast<Ref<Material3D>>(debug_material);
material->set_albedo(color);
}

2
scene/3d/ray_cast.h
View File

@ -98,7 +98,7 @@ public:
const Vector<Vector3> &get_debug_shape_vertices() const;
const Vector<Vector3> &get_debug_line_vertices() const;
Ref<SpatialMaterial> get_debug_material();
Ref<Material3D> get_debug_material();
int get_debug_shape_thickness() const;
void set_debug_shape_thickness(const int p_debug_thickness);

12
scene/3d/shape_cast.cpp
View File

@ -516,7 +516,7 @@ void ShapeCast::set_debug_shape_custom_color(const Color &p_color) {
}
}
Ref<SpatialMaterial> ShapeCast::get_debug_material() {
Ref<Material3D> ShapeCast::get_debug_material() {
_update_debug_shape_material();
return debug_material;
}
@ -539,13 +539,13 @@ void ShapeCast::_create_debug_shape() {
void ShapeCast::_update_debug_shape_material(bool p_check_collision) {
if (!debug_material.is_valid()) {
Ref<SpatialMaterial> material = memnew(SpatialMaterial);
Ref<Material3D> material = memnew(Material3D);
debug_material = material;
material->set_flag(SpatialMaterial::FLAG_UNSHADED, true);
material->set_feature(SpatialMaterial::FEATURE_TRANSPARENT, true);
material->set_flag(Material3D::FLAG_UNSHADED, true);
material->set_feature(Material3D::FEATURE_TRANSPARENT, true);
// Use double-sided rendering so that the RayCast can be seen if the camera is inside.
material->set_cull_mode(SpatialMaterial::CULL_DISABLED);
material->set_cull_mode(Material3D::CULL_DISABLED);
}
Color color = debug_shape_custom_color;
@ -564,7 +564,7 @@ void ShapeCast::_update_debug_shape_material(bool p_check_collision) {
}
}
Ref<SpatialMaterial> material = static_cast<Ref<SpatialMaterial>>(debug_material);
Ref<Material3D> material = static_cast<Ref<Material3D>>(debug_material);
material->set_albedo(color);
}

2
scene/3d/shape_cast.h
View File

@ -116,7 +116,7 @@ public:
const Vector<Vector3> &get_debug_shape_vertices() const;
const Vector<Vector3> &get_debug_line_vertices() const;
Ref<SpatialMaterial> get_debug_material();
Ref<Material3D> get_debug_material();
int get_collision_count() const;
Object *get_collider(int p_idx) const;

8
scene/3d/sprite_3d.cpp
View File

@ -231,7 +231,7 @@ void SpriteBase3D::draw_texture_rect(Ref<Texture> p_texture, Rect2 p_dst_rect, R
VS::get_singleton()->mesh_set_custom_aabb(mesh, aabb);
set_aabb(aabb);
RID mat = SpatialMaterial::get_material_rid_for_2d(get_draw_flag(FLAG_SHADED), get_draw_flag(FLAG_TRANSPARENT), get_draw_flag(FLAG_DOUBLE_SIDED), get_alpha_cut_mode() == ALPHA_CUT_DISCARD, get_alpha_cut_mode() == ALPHA_CUT_OPAQUE_PREPASS, get_billboard_mode() == SpatialMaterial::BILLBOARD_ENABLED, get_billboard_mode() == SpatialMaterial::BILLBOARD_FIXED_Y, get_draw_flag(FLAG_DISABLE_DEPTH_TEST), get_draw_flag(FLAG_FIXED_SIZE));
RID mat = Material3D::get_material_rid_for_2d(get_draw_flag(FLAG_SHADED), get_draw_flag(FLAG_TRANSPARENT), get_draw_flag(FLAG_DOUBLE_SIDED), get_alpha_cut_mode() == ALPHA_CUT_DISCARD, get_alpha_cut_mode() == ALPHA_CUT_OPAQUE_PREPASS, get_billboard_mode() == Material3D::BILLBOARD_ENABLED, get_billboard_mode() == Material3D::BILLBOARD_FIXED_Y, get_draw_flag(FLAG_DISABLE_DEPTH_TEST), get_draw_flag(FLAG_FIXED_SIZE));
VS::get_singleton()->material_set_shader(get_material(), VS::get_singleton()->material_get_shader(mat));
VS::get_singleton()->material_set_param(get_material(), "texture_albedo", p_texture->get_rid());
if (get_alpha_cut_mode() == ALPHA_CUT_DISABLED) {
@ -428,13 +428,13 @@ SpriteBase3D::AlphaCutMode SpriteBase3D::get_alpha_cut_mode() const {
return alpha_cut;
}
void SpriteBase3D::set_billboard_mode(SpatialMaterial::BillboardMode p_mode) {
void SpriteBase3D::set_billboard_mode(Material3D::BillboardMode p_mode) {
ERR_FAIL_INDEX(p_mode, 3);
billboard_mode = p_mode;
_queue_update();
}
SpatialMaterial::BillboardMode SpriteBase3D::get_billboard_mode() const {
Material3D::BillboardMode SpriteBase3D::get_billboard_mode() const {
return billboard_mode;
}
@ -524,7 +524,7 @@ SpriteBase3D::SpriteBase3D() {
}
alpha_cut = ALPHA_CUT_DISABLED;
billboard_mode = SpatialMaterial::BILLBOARD_DISABLED;
billboard_mode = Material3D::BILLBOARD_DISABLED;
axis = Vector3::AXIS_Z;
pixel_size = 0.01;
modulate = Color(1, 1, 1, 1);

6
scene/3d/sprite_3d.h
View File

@ -83,7 +83,7 @@ private:
bool flags[FLAG_MAX];
AlphaCutMode alpha_cut;
SpatialMaterial::BillboardMode billboard_mode;
Material3D::BillboardMode billboard_mode;
bool pending_update;
void _im_update();
@ -139,8 +139,8 @@ public:
void set_alpha_cut_mode(AlphaCutMode p_mode);
AlphaCutMode get_alpha_cut_mode() const;
void set_billboard_mode(SpatialMaterial::BillboardMode p_mode);
SpatialMaterial::BillboardMode get_billboard_mode() const;
void set_billboard_mode(Material3D::BillboardMode p_mode);
Material3D::BillboardMode get_billboard_mode() const;
virtual Rect2 get_item_rect() const = 0;

4
scene/3d/visual_instance.cpp
View File

@ -387,8 +387,8 @@ void GeometryInstance::_bind_methods() {
ClassDB::bind_method(D_METHOD("get_aabb"), &GeometryInstance::get_aabb);
ADD_GROUP("Geometry", "");
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "material_override", PROPERTY_HINT_RESOURCE_TYPE, "ShaderMaterial,SpatialMaterial"), "set_material_override", "get_material_override");
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "material_overlay", PROPERTY_HINT_RESOURCE_TYPE, "ShaderMaterial,SpatialMaterial"), "set_material_overlay", "get_material_overlay");
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "material_override", PROPERTY_HINT_RESOURCE_TYPE, "ShaderMaterial,SpatialMaterial,ORMSpatialMaterial"), "set_material_override", "get_material_override");
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "material_overlay", PROPERTY_HINT_RESOURCE_TYPE, "ShaderMaterial,SpatialMaterial,ORMSpatialMaterial"), "set_material_overlay", "get_material_overlay");
ADD_PROPERTY(PropertyInfo(Variant::INT, "cast_shadow", PROPERTY_HINT_ENUM, "Off,On,Double-Sided,Shadows Only"), "set_cast_shadows_setting", "get_cast_shadows_setting");
ADD_PROPERTY(PropertyInfo(Variant::REAL, "extra_cull_margin", PROPERTY_HINT_RANGE, "0,16384,0.01"), "set_extra_cull_margin", "get_extra_cull_margin");

18
scene/3d/voxel_light_baker.cpp
View File

@ -526,7 +526,7 @@ Vector<Color> VoxelLightBaker::_get_bake_texture(Ref<Image> p_image, const Color
VoxelLightBaker::MaterialCache VoxelLightBaker::_get_material_cache(Ref<Material> p_material) {
//this way of obtaining materials is inaccurate and also does not support some compressed formats very well
Ref<SpatialMaterial> mat = p_material;
Ref<Material3D> mat = p_material;
Ref<Material> material = mat; //hack for now
@ -539,7 +539,7 @@ VoxelLightBaker::MaterialCache VoxelLightBaker::_get_material_cache(Ref<Material
Ref<Image> empty;
if (mat.is_valid()) {
Ref<Texture> albedo_tex = mat->get_texture(SpatialMaterial::TEXTURE_ALBEDO);
Ref<Texture> albedo_tex = mat->get_texture(Material3D::TEXTURE_ALBEDO);
Ref<Image> img_albedo;
if (albedo_tex.is_valid()) {
@ -549,8 +549,8 @@ VoxelLightBaker::MaterialCache VoxelLightBaker::_get_material_cache(Ref<Material
mc.albedo = _get_bake_texture(img_albedo, Color(1, 1, 1), mat->get_albedo()); // no albedo texture, color is additive
}
if (mat->get_feature(SpatialMaterial::FEATURE_EMISSION)) {
Ref<Texture> emission_tex = mat->get_texture(SpatialMaterial::TEXTURE_EMISSION);
if (mat->get_feature(Material3D::FEATURE_EMISSION)) {
Ref<Texture> emission_tex = mat->get_texture(Material3D::TEXTURE_EMISSION);
Color emission_col = mat->get_emission();
float emission_energy = mat->get_emission_energy();
@ -561,7 +561,7 @@ VoxelLightBaker::MaterialCache VoxelLightBaker::_get_material_cache(Ref<Material
img_emission = emission_tex->get_data();
}
if (mat->get_emission_operator() == SpatialMaterial::EMISSION_OP_ADD) {
if (mat->get_emission_operator() == Material3D::EMISSION_OP_ADD) {
mc.emission = _get_bake_texture(img_emission, Color(1, 1, 1) * emission_energy, emission_col * emission_energy);
} else {
mc.emission = _get_bake_texture(img_emission, emission_col * emission_energy, Color(0, 0, 0));
@ -1507,11 +1507,11 @@ Ref<MultiMesh> VoxelLightBaker::create_debug_multimesh(DebugMode p_mode) {
}
{
Ref<SpatialMaterial> fsm;
Ref<Material3D> fsm;
fsm.instance();
fsm->set_flag(SpatialMaterial::FLAG_SRGB_VERTEX_COLOR, true);
fsm->set_flag(SpatialMaterial::FLAG_ALBEDO_FROM_VERTEX_COLOR, true);
fsm->set_flag(SpatialMaterial::FLAG_UNSHADED, true);
fsm->set_flag(Material3D::FLAG_SRGB_VERTEX_COLOR, true);
fsm->set_flag(Material3D::FLAG_ALBEDO_FROM_VERTEX_COLOR, true);
fsm->set_flag(Material3D::FLAG_UNSHADED, true);
fsm->set_albedo(Color(1, 1, 1, 1));
mesh->surface_set_material(0, fsm);

2
scene/animation/root_motion_view.cpp
View File

@ -77,7 +77,7 @@ bool RootMotionView::get_zero_y() const {
void RootMotionView::_notification(int p_what) {
if (p_what == NOTIFICATION_ENTER_TREE) {
VS::get_singleton()->immediate_set_material(immediate, SpatialMaterial::get_material_rid_for_2d(false, true, false, false, false));
VS::get_singleton()->immediate_set_material(immediate, Material3D::get_material_rid_for_2d(false, true, false, false, false));
first = true;
}

40
scene/main/scene_tree.cpp
View File

@ -935,11 +935,11 @@ Ref<Material> SceneTree::get_debug_navigation_material() {
return navigation_material;
}
Ref<SpatialMaterial> line_material = Ref<SpatialMaterial>(memnew(SpatialMaterial));
line_material->set_flag(SpatialMaterial::FLAG_UNSHADED, true);
line_material->set_feature(SpatialMaterial::FEATURE_TRANSPARENT, true);
line_material->set_flag(SpatialMaterial::FLAG_SRGB_VERTEX_COLOR, true);
line_material->set_flag(SpatialMaterial::FLAG_ALBEDO_FROM_VERTEX_COLOR, true);
Ref<Material3D> line_material = Ref<Material3D>(memnew(SpatialMaterial));
line_material->set_flag(Material3D::FLAG_UNSHADED, true);
line_material->set_feature(Material3D::FEATURE_TRANSPARENT, true);
line_material->set_flag(Material3D::FLAG_SRGB_VERTEX_COLOR, true);
line_material->set_flag(Material3D::FLAG_ALBEDO_FROM_VERTEX_COLOR, true);
line_material->set_albedo(get_debug_navigation_color());
navigation_material = line_material;
@ -952,11 +952,11 @@ Ref<Material> SceneTree::get_debug_navigation_disabled_material() {
return navigation_disabled_material;
}
Ref<SpatialMaterial> line_material = Ref<SpatialMaterial>(memnew(SpatialMaterial));
line_material->set_flag(SpatialMaterial::FLAG_UNSHADED, true);
line_material->set_feature(SpatialMaterial::FEATURE_TRANSPARENT, true);
line_material->set_flag(SpatialMaterial::FLAG_SRGB_VERTEX_COLOR, true);
line_material->set_flag(SpatialMaterial::FLAG_ALBEDO_FROM_VERTEX_COLOR, true);
Ref<Material3D> line_material = Ref<Material3D>(memnew(SpatialMaterial));
line_material->set_flag(Material3D::FLAG_UNSHADED, true);
line_material->set_feature(Material3D::FEATURE_TRANSPARENT, true);
line_material->set_flag(Material3D::FLAG_SRGB_VERTEX_COLOR, true);
line_material->set_flag(Material3D::FLAG_ALBEDO_FROM_VERTEX_COLOR, true);
line_material->set_albedo(get_debug_navigation_disabled_color());
navigation_disabled_material = line_material;
@ -968,11 +968,11 @@ Ref<Material> SceneTree::get_debug_collision_material() {
return collision_material;
}
Ref<SpatialMaterial> line_material = Ref<SpatialMaterial>(memnew(SpatialMaterial));
line_material->set_flag(SpatialMaterial::FLAG_UNSHADED, true);
line_material->set_feature(SpatialMaterial::FEATURE_TRANSPARENT, true);
line_material->set_flag(SpatialMaterial::FLAG_SRGB_VERTEX_COLOR, true);
line_material->set_flag(SpatialMaterial::FLAG_ALBEDO_FROM_VERTEX_COLOR, true);
Ref<Material3D> line_material = Ref<Material3D>(memnew(SpatialMaterial));
line_material->set_flag(Material3D::FLAG_UNSHADED, true);
line_material->set_feature(Material3D::FEATURE_TRANSPARENT, true);
line_material->set_flag(Material3D::FLAG_SRGB_VERTEX_COLOR, true);
line_material->set_flag(Material3D::FLAG_ALBEDO_FROM_VERTEX_COLOR, true);
line_material->set_albedo(get_debug_collisions_color());
collision_material = line_material;
@ -987,11 +987,11 @@ Ref<ArrayMesh> SceneTree::get_debug_contact_mesh() {
debug_contact_mesh = Ref<ArrayMesh>(memnew(ArrayMesh));
Ref<SpatialMaterial> mat = Ref<SpatialMaterial>(memnew(SpatialMaterial));
mat->set_flag(SpatialMaterial::FLAG_UNSHADED, true);
mat->set_feature(SpatialMaterial::FEATURE_TRANSPARENT, true);
mat->set_flag(SpatialMaterial::FLAG_SRGB_VERTEX_COLOR, true);
mat->set_flag(SpatialMaterial::FLAG_ALBEDO_FROM_VERTEX_COLOR, true);
Ref<Material3D> mat = Ref<Material3D>(memnew(SpatialMaterial));
mat->set_flag(Material3D::FLAG_UNSHADED, true);
mat->set_feature(Material3D::FEATURE_TRANSPARENT, true);
mat->set_flag(Material3D::FLAG_SRGB_VERTEX_COLOR, true);
mat->set_flag(Material3D::FLAG_ALBEDO_FROM_VERTEX_COLOR, true);
mat->set_albedo(get_debug_collision_contact_color());
Vector3 diamond[6] = {

8
scene/register_scene_types.cpp
View File

@ -670,9 +670,11 @@ void register_scene_types() {
ClassDB::register_class<TorusMesh>();
ClassDB::register_class<PointMesh>();
ClassDB::register_virtual_class<Material>();
ClassDB::register_virtual_class<Material3D>();
ClassDB::register_class<SpatialMaterial>();
SceneTree::add_idle_callback(SpatialMaterial::flush_changes);
SpatialMaterial::init_shaders();
ClassDB::register_class<ORMSpatialMaterial>();
SceneTree::add_idle_callback(Material3D::flush_changes);
Material3D::init_shaders();
ClassDB::register_class<MeshLibrary>();
@ -875,7 +877,7 @@ void unregister_scene_types() {
//SpatialMaterial is not initialised when 3D is disabled, so it shouldn't be cleaned up either
#ifndef _3D_DISABLED
SpatialMaterial::finish_shaders();
Material3D::finish_shaders();
#endif // _3D_DISABLED
ParticlesMaterial::finish_shaders();

672
scene/resources/material.cpp
View File

File diff suppressed because it is too large Load Diff

58
scene/resources/material.h
View File

@ -104,8 +104,8 @@ public:
~ShaderMaterial();
};
class SpatialMaterial : public Material {
GDCLASS(SpatialMaterial, Material);
class Material3D : public Material {
GDCLASS(Material3D, Material);
public:
enum TextureParam {
@ -125,6 +125,7 @@ public:
TEXTURE_DETAIL_MASK,
TEXTURE_DETAIL_ALBEDO,
TEXTURE_DETAIL_NORMAL,
TEXTURE_ORM,
TEXTURE_MAX
};
@ -364,15 +365,16 @@ private:
};
static Mutex material_mutex;
static SelfList<SpatialMaterial>::List *dirty_materials;
static SelfList<Material3D>::List *dirty_materials;
static ShaderNames *shader_names;
SelfList<SpatialMaterial> element;
SelfList<Material3D> element;
void _update_shader();
_FORCE_INLINE_ void _queue_shader_change();
_FORCE_INLINE_ bool _is_shader_dirty() const;
bool orm;
bool is_initialized = false;
Color albedo;
float specular;
@ -447,7 +449,7 @@ private:
_FORCE_INLINE_ void _validate_feature(const String &text, Feature feature, PropertyInfo &property) const;
static HashMap<uint64_t, Ref<SpatialMaterial>> materials_for_2d; //used by Sprite3D and other stuff
static HashMap<uint64_t, Ref<Material3D>> materials_for_2d; //used by Sprite3D and other stuff
void _validate_high_end(const String &text, PropertyInfo &property) const;
@ -641,24 +643,38 @@ public:
virtual Shader::Mode get_shader_mode() const;
SpatialMaterial();
virtual ~SpatialMaterial();
Material3D(bool p_orm = false);
virtual ~Material3D();
};
VARIANT_ENUM_CAST(SpatialMaterial::TextureParam)
VARIANT_ENUM_CAST(SpatialMaterial::DetailUV)
VARIANT_ENUM_CAST(SpatialMaterial::Feature)
VARIANT_ENUM_CAST(SpatialMaterial::BlendMode)
VARIANT_ENUM_CAST(SpatialMaterial::DepthDrawMode)
VARIANT_ENUM_CAST(SpatialMaterial::CullMode)
VARIANT_ENUM_CAST(SpatialMaterial::Flags)
VARIANT_ENUM_CAST(SpatialMaterial::DiffuseMode)
VARIANT_ENUM_CAST(SpatialMaterial::SpecularMode)
VARIANT_ENUM_CAST(SpatialMaterial::BillboardMode)
VARIANT_ENUM_CAST(SpatialMaterial::TextureChannel)
VARIANT_ENUM_CAST(SpatialMaterial::EmissionOperator)
VARIANT_ENUM_CAST(SpatialMaterial::DistanceFadeMode)
VARIANT_ENUM_CAST(SpatialMaterial::AsyncMode)
class SpatialMaterial : public Material3D {
GDCLASS(SpatialMaterial, Material3D)
public:
SpatialMaterial() :
Material3D(false) {}
};
class ORMSpatialMaterial : public Material3D {
GDCLASS(ORMSpatialMaterial, Material3D)
public:
ORMSpatialMaterial() :
Material3D(true) {}
};
VARIANT_ENUM_CAST(Material3D::TextureParam)
VARIANT_ENUM_CAST(Material3D::DetailUV)
VARIANT_ENUM_CAST(Material3D::Feature)
VARIANT_ENUM_CAST(Material3D::BlendMode)
VARIANT_ENUM_CAST(Material3D::DepthDrawMode)
VARIANT_ENUM_CAST(Material3D::CullMode)
VARIANT_ENUM_CAST(Material3D::Flags)
VARIANT_ENUM_CAST(Material3D::DiffuseMode)
VARIANT_ENUM_CAST(Material3D::SpecularMode)
VARIANT_ENUM_CAST(Material3D::BillboardMode)
VARIANT_ENUM_CAST(Material3D::TextureChannel)
VARIANT_ENUM_CAST(Material3D::EmissionOperator)
VARIANT_ENUM_CAST(Material3D::DistanceFadeMode)
VARIANT_ENUM_CAST(Material3D::AsyncMode)
//////////////////////

2
scene/resources/mesh.cpp
View File

@ -876,7 +876,7 @@ void ArrayMesh::_get_property_list(List<PropertyInfo> *p_list) const {
if (surfaces[i].is_2d) {
p_list->push_back(PropertyInfo(Variant::OBJECT, "surface_" + itos(i + 1) + "/material", PROPERTY_HINT_RESOURCE_TYPE, "ShaderMaterial,CanvasItemMaterial", PROPERTY_USAGE_EDITOR));
} else {
p_list->push_back(PropertyInfo(Variant::OBJECT, "surface_" + itos(i + 1) + "/material", PROPERTY_HINT_RESOURCE_TYPE, "ShaderMaterial,SpatialMaterial", PROPERTY_USAGE_EDITOR));
p_list->push_back(PropertyInfo(Variant::OBJECT, "surface_" + itos(i + 1) + "/material", PROPERTY_HINT_RESOURCE_TYPE, "ShaderMaterial,SpatialMaterial,ORMSpatialMaterial", PROPERTY_USAGE_EDITOR));
}
}
}

2
scene/resources/primitive_meshes.cpp
View File

@ -213,7 +213,7 @@ void PrimitiveMesh::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_flip_faces", "flip_faces"), &PrimitiveMesh::set_flip_faces);
ClassDB::bind_method(D_METHOD("get_flip_faces"), &PrimitiveMesh::get_flip_faces);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "material", PROPERTY_HINT_RESOURCE_TYPE, "SpatialMaterial,ShaderMaterial"), "set_material", "get_material");
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "material", PROPERTY_HINT_RESOURCE_TYPE, "SpatialMaterial,ORMSpatialMaterial,ShaderMaterial"), "set_material", "get_material");
ADD_PROPERTY(PropertyInfo(Variant::AABB, "custom_aabb", PROPERTY_HINT_NONE, ""), "set_custom_aabb", "get_custom_aabb");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "flip_faces"), "set_flip_faces", "get_flip_faces");
}