godotengine/godot
1
0
Fork 0
mirror of https://github.com/godotengine/godot.git synced 2026-01-05 19:31:35 +00:00
Code 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

22
modules/bullet/space_bullet.cpp
View File

@@ -878,7 +878,7 @@ void SpaceBullet::update_gravity() {
static ImmediateGeometry *motionVec(NULL);
static ImmediateGeometry *normalLine(NULL);
static Ref<SpatialMaterial> red_mat;
static Ref<Material3D> red_mat;
static Ref<SpatialMaterial> blue_mat;
#endif
@@ -895,21 +895,21 @@ bool SpaceBullet::test_body_motion(RigidBodyBullet *p_body, const Transform &p_f
motionVec->set_as_toplevel(true);
normalLine->set_as_toplevel(true);
red_mat = Ref<SpatialMaterial>(memnew(SpatialMaterial));
red_mat->set_flag(SpatialMaterial::FLAG_UNSHADED, true);
red_mat = Ref<Material3D>(memnew(SpatialMaterial));
red_mat->set_flag(Material3D::FLAG_UNSHADED, true);
red_mat->set_line_width(20.0);
red_mat->set_feature(SpatialMaterial::FEATURE_TRANSPARENT, true);
red_mat->set_flag(SpatialMaterial::FLAG_ALBEDO_FROM_VERTEX_COLOR, true);
red_mat->set_flag(SpatialMaterial::FLAG_SRGB_VERTEX_COLOR, true);
red_mat->set_feature(Material3D::FEATURE_TRANSPARENT, true);
red_mat->set_flag(Material3D::FLAG_ALBEDO_FROM_VERTEX_COLOR, true);
red_mat->set_flag(Material3D::FLAG_SRGB_VERTEX_COLOR, true);
red_mat->set_albedo(Color(1, 0, 0, 1));
motionVec->set_material_override(red_mat);
blue_mat = Ref<SpatialMaterial>(memnew(SpatialMaterial));
blue_mat->set_flag(SpatialMaterial::FLAG_UNSHADED, true);
blue_mat = Ref<Material3D>(memnew(SpatialMaterial));
blue_mat->set_flag(Material3D::FLAG_UNSHADED, true);
blue_mat->set_line_width(20.0);
blue_mat->set_feature(SpatialMaterial::FEATURE_TRANSPARENT, true);
blue_mat->set_flag(SpatialMaterial::FLAG_ALBEDO_FROM_VERTEX_COLOR, true);
blue_mat->set_flag(SpatialMaterial::FLAG_SRGB_VERTEX_COLOR, true);
blue_mat->set_feature(Material3D::FEATURE_TRANSPARENT, true);
blue_mat->set_flag(Material3D::FLAG_ALBEDO_FROM_VERTEX_COLOR, true);
blue_mat->set_flag(Material3D::FLAG_SRGB_VERTEX_COLOR, true);
blue_mat->set_albedo(Color(0, 0, 1, 1));
normalLine->set_material_override(blue_mat);
}

12
modules/csg/csg_shape.cpp
View File

@@ -961,7 +961,7 @@ void CSGMesh::_bind_methods() {
ClassDB::bind_method(D_METHOD("get_material"), &CSGMesh::get_material);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "mesh", PROPERTY_HINT_RESOURCE_TYPE, "Mesh"), "set_mesh", "get_mesh");
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");
}
void CSGMesh::set_mesh(const Ref<Mesh> &p_mesh) {
@@ -1128,7 +1128,7 @@ void CSGSphere::_bind_methods() {
ADD_PROPERTY(PropertyInfo(Variant::INT, "radial_segments", PROPERTY_HINT_RANGE, "1,100,1"), "set_radial_segments", "get_radial_segments");
ADD_PROPERTY(PropertyInfo(Variant::INT, "rings", PROPERTY_HINT_RANGE, "1,100,1"), "set_rings", "get_rings");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "smooth_faces"), "set_smooth_faces", "get_smooth_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");
}
void CSGSphere::set_radius(const float p_radius) {
@@ -1307,7 +1307,7 @@ void CSGBox::_bind_methods() {
ADD_PROPERTY(PropertyInfo(Variant::REAL, "width", PROPERTY_HINT_EXP_RANGE, "0.001,1000.0,0.001,or_greater"), "set_width", "get_width");
ADD_PROPERTY(PropertyInfo(Variant::REAL, "height", PROPERTY_HINT_EXP_RANGE, "0.001,1000.0,0.001,or_greater"), "set_height", "get_height");
ADD_PROPERTY(PropertyInfo(Variant::REAL, "depth", PROPERTY_HINT_EXP_RANGE, "0.001,1000.0,0.001,or_greater"), "set_depth", "get_depth");
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");
}
void CSGBox::set_width(const float p_width) {
@@ -1521,7 +1521,7 @@ void CSGCylinder::_bind_methods() {
ADD_PROPERTY(PropertyInfo(Variant::INT, "sides", PROPERTY_HINT_RANGE, "3,64,1"), "set_sides", "get_sides");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "cone"), "set_cone", "is_cone");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "smooth_faces"), "set_smooth_faces", "get_smooth_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");
}
void CSGCylinder::set_radius(const float p_radius) {
@@ -1748,7 +1748,7 @@ void CSGTorus::_bind_methods() {
ADD_PROPERTY(PropertyInfo(Variant::INT, "sides", PROPERTY_HINT_RANGE, "3,64,1"), "set_sides", "get_sides");
ADD_PROPERTY(PropertyInfo(Variant::INT, "ring_sides", PROPERTY_HINT_RANGE, "3,64,1"), "set_ring_sides", "get_ring_sides");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "smooth_faces"), "set_smooth_faces", "get_smooth_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");
}
void CSGTorus::set_inner_radius(const float p_inner_radius) {
@@ -2266,7 +2266,7 @@ void CSGPolygon::_bind_methods() {
ADD_PROPERTY(PropertyInfo(Variant::REAL, "path_u_distance", PROPERTY_HINT_RANGE, "0.0,10.0,0.01,or_greater"), "set_path_u_distance", "get_path_u_distance");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "path_joined"), "set_path_joined", "is_path_joined");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "smooth_faces"), "set_smooth_faces", "get_smooth_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");
BIND_ENUM_CONSTANT(MODE_DEPTH);
BIND_ENUM_CONSTANT(MODE_SPIN);

91
modules/fbx/data/fbx_material.cpp
View File

@@ -184,7 +184,7 @@ FBXMaterial::MaterialInfo FBXMaterial::extract_material_info(const FBXDocParser:
const String texture_name = absoulte_fbx_file_path.get_file();
print_verbose("Getting FBX mapping mode for " + String(fbx_mapping_name.c_str()));
const SpatialMaterial::TextureParam mapping_mode = fbx_texture_mapping_desc.at(fbx_mapping_name);
const Material3D::TextureParam mapping_mode = fbx_texture_mapping_desc.at(fbx_mapping_name);
print_verbose("Set FBX mapping mode to " + get_texture_param_name(mapping_mode));
TextureFileMapping file_mapping;
file_mapping.map_mode = mapping_mode;
@@ -194,42 +194,43 @@ FBXMaterial::MaterialInfo FBXMaterial::extract_material_info(const FBXDocParser:
// Make sure to active the various features.
switch (mapping_mode) {
case SpatialMaterial::TextureParam::TEXTURE_ALBEDO:
case SpatialMaterial::TextureParam::TEXTURE_METALLIC:
case SpatialMaterial::TextureParam::TEXTURE_ROUGHNESS:
case SpatialMaterial::TextureParam::TEXTURE_FLOWMAP:
case SpatialMaterial::TextureParam::TEXTURE_REFRACTION:
case SpatialMaterial::TextureParam::TEXTURE_MAX:
case Material3D::TextureParam::TEXTURE_ALBEDO:
case Material3D::TextureParam::TEXTURE_METALLIC:
case Material3D::TextureParam::TEXTURE_ROUGHNESS:
case Material3D::TextureParam::TEXTURE_ORM:
case Material3D::TextureParam::TEXTURE_FLOWMAP:
case Material3D::TextureParam::TEXTURE_REFRACTION:
case Material3D::TextureParam::TEXTURE_MAX:
// No features required.
break;
case SpatialMaterial::TextureParam::TEXTURE_EMISSION:
mat_info.features.push_back(SpatialMaterial::Feature::FEATURE_EMISSION);
case Material3D::TextureParam::TEXTURE_EMISSION:
mat_info.features.push_back(Material3D::Feature::FEATURE_EMISSION);
break;
case SpatialMaterial::TextureParam::TEXTURE_NORMAL:
mat_info.features.push_back(SpatialMaterial::Feature::FEATURE_NORMAL_MAPPING);
case Material3D::TextureParam::TEXTURE_NORMAL:
mat_info.features.push_back(Material3D::Feature::FEATURE_NORMAL_MAPPING);
break;
case SpatialMaterial::TextureParam::TEXTURE_RIM:
mat_info.features.push_back(SpatialMaterial::Feature::FEATURE_RIM);
case Material3D::TextureParam::TEXTURE_RIM:
mat_info.features.push_back(Material3D::Feature::FEATURE_RIM);
break;
case SpatialMaterial::TextureParam::TEXTURE_CLEARCOAT:
mat_info.features.push_back(SpatialMaterial::Feature::FEATURE_CLEARCOAT);
case Material3D::TextureParam::TEXTURE_CLEARCOAT:
mat_info.features.push_back(Material3D::Feature::FEATURE_CLEARCOAT);
break;
case SpatialMaterial::TextureParam::TEXTURE_AMBIENT_OCCLUSION:
mat_info.features.push_back(SpatialMaterial::Feature::FEATURE_AMBIENT_OCCLUSION);
case Material3D::TextureParam::TEXTURE_AMBIENT_OCCLUSION:
mat_info.features.push_back(Material3D::Feature::FEATURE_AMBIENT_OCCLUSION);
break;
case SpatialMaterial::TextureParam::TEXTURE_DEPTH:
mat_info.features.push_back(SpatialMaterial::Feature::FEATURE_DEPTH_MAPPING);
case Material3D::TextureParam::TEXTURE_DEPTH:
mat_info.features.push_back(Material3D::Feature::FEATURE_DEPTH_MAPPING);
break;
case SpatialMaterial::TextureParam::TEXTURE_SUBSURFACE_SCATTERING:
mat_info.features.push_back(SpatialMaterial::Feature::FEATURE_SUBSURACE_SCATTERING);
case Material3D::TextureParam::TEXTURE_SUBSURFACE_SCATTERING:
mat_info.features.push_back(Material3D::Feature::FEATURE_SUBSURACE_SCATTERING);
break;
case SpatialMaterial::TextureParam::TEXTURE_TRANSMISSION:
mat_info.features.push_back(SpatialMaterial::Feature::FEATURE_TRANSMISSION);
case Material3D::TextureParam::TEXTURE_TRANSMISSION:
mat_info.features.push_back(Material3D::Feature::FEATURE_TRANSMISSION);
break;
case SpatialMaterial::TextureParam::TEXTURE_DETAIL_ALBEDO:
case SpatialMaterial::TextureParam::TEXTURE_DETAIL_MASK:
case SpatialMaterial::TextureParam::TEXTURE_DETAIL_NORMAL:
mat_info.features.push_back(SpatialMaterial::Feature::FEATURE_DETAIL);
case Material3D::TextureParam::TEXTURE_DETAIL_ALBEDO:
case Material3D::TextureParam::TEXTURE_DETAIL_MASK:
case Material3D::TextureParam::TEXTURE_DETAIL_NORMAL:
mat_info.features.push_back(Material3D::Feature::FEATURE_DETAIL);
break;
}
}
@@ -247,12 +248,12 @@ T extract_from_prop(FBXDocParser::PropertyPtr prop, const T &p_default, const st
return val->Value();
}
Ref<SpatialMaterial> FBXMaterial::import_material(ImportState &state) {
Ref<Material3D> FBXMaterial::import_material(ImportState &state) {
ERR_FAIL_COND_V(material == nullptr, nullptr);
const String p_fbx_current_directory = state.path;
Ref<SpatialMaterial> spatial_material;
Ref<Material3D> spatial_material;
// read the material file
// is material two sided
@@ -364,8 +365,8 @@ Ref<SpatialMaterial> FBXMaterial::import_material(ImportState &state) {
Color c = spatial_material->get_albedo();
c.a = opacity;
spatial_material->set_albedo(c);
material_info.features.push_back(SpatialMaterial::Feature::FEATURE_TRANSPARENT);
spatial_material->set_depth_draw_mode(SpatialMaterial::DEPTH_DRAW_ALPHA_OPAQUE_PREPASS);
material_info.features.push_back(Material3D::Feature::FEATURE_TRANSPARENT);
spatial_material->set_depth_draw_mode(Material3D::DEPTH_DRAW_ALPHA_OPAQUE_PREPASS);
}
} else if (vector_value) {
print_error("unsupported transparent desc type vector!");
@@ -410,7 +411,7 @@ Ref<SpatialMaterial> FBXMaterial::import_material(ImportState &state) {
} break;
case PROPERTY_DESC_COAT: {
if (real_value) {
material_info.features.push_back(SpatialMaterial::Feature::FEATURE_CLEARCOAT);
material_info.features.push_back(Material3D::Feature::FEATURE_CLEARCOAT);
print_verbose("clearcoat real value: " + rtos(real_value->Value()));
spatial_material->set_clearcoat(MIN(1.0f, real_value->Value()));
} else {
@@ -423,7 +424,7 @@ Ref<SpatialMaterial> FBXMaterial::import_material(ImportState &state) {
print_verbose("clearcoat real value: " + rtos(real_value->Value()));
spatial_material->set_clearcoat_gloss(1.0 - real_value->Value());
material_info.features.push_back(SpatialMaterial::Feature::FEATURE_CLEARCOAT);
material_info.features.push_back(Material3D::Feature::FEATURE_CLEARCOAT);
} else {
print_error("unsupported value type for clearcoat gloss");
}
@@ -432,7 +433,7 @@ Ref<SpatialMaterial> FBXMaterial::import_material(ImportState &state) {
if (real_value && Math::is_equal_approx(real_value->Value(), 0.0f)) {
print_verbose("Emissive real value: " + rtos(real_value->Value()));
spatial_material->set_emission_energy(real_value->Value());
material_info.features.push_back(SpatialMaterial::Feature::FEATURE_EMISSION);
material_info.features.push_back(Material3D::Feature::FEATURE_EMISSION);
} else if (vector_value && !vector_value->Value().is_equal_approx(Vector3(0, 0, 0))) {
const Vector3 &color = vector_value->Value();
Color c;
@@ -440,7 +441,7 @@ Ref<SpatialMaterial> FBXMaterial::import_material(ImportState &state) {
c[1] = color[1];
c[2] = color[2];
spatial_material->set_emission(c);
material_info.features.push_back(SpatialMaterial::Feature::FEATURE_EMISSION);
material_info.features.push_back(Material3D::Feature::FEATURE_EMISSION);
}
} break;
case PROPERTY_DESC_EMISSIVE_COLOR: {
@@ -548,31 +549,31 @@ Ref<SpatialMaterial> FBXMaterial::import_material(ImportState &state) {
}
switch (mapping.map_mode) {
case SpatialMaterial::TextureParam::TEXTURE_METALLIC:
case Material3D::TextureParam::TEXTURE_METALLIC:
if (mapping.name.to_lower().find("ser") >= 0) {
// SER shader.
spatial_material->set_metallic_texture_channel(SpatialMaterial::TextureChannel::TEXTURE_CHANNEL_RED);
spatial_material->set_metallic_texture_channel(Material3D::TextureChannel::TEXTURE_CHANNEL_RED);
} else {
// Use grayscale as default.
spatial_material->set_metallic_texture_channel(SpatialMaterial::TextureChannel::TEXTURE_CHANNEL_GRAYSCALE);
spatial_material->set_metallic_texture_channel(Material3D::TextureChannel::TEXTURE_CHANNEL_GRAYSCALE);
}
break;
case SpatialMaterial::TextureParam::TEXTURE_ROUGHNESS:
case Material3D::TextureParam::TEXTURE_ROUGHNESS:
if (mapping.name.to_lower().find("ser") >= 0) {
// SER shader.
spatial_material->set_roughness_texture_channel(SpatialMaterial::TextureChannel::TEXTURE_CHANNEL_BLUE);
spatial_material->set_roughness_texture_channel(Material3D::TextureChannel::TEXTURE_CHANNEL_BLUE);
} else {
// Use grayscale as default.
spatial_material->set_roughness_texture_channel(SpatialMaterial::TextureChannel::TEXTURE_CHANNEL_GRAYSCALE);
spatial_material->set_roughness_texture_channel(Material3D::TextureChannel::TEXTURE_CHANNEL_GRAYSCALE);
}
break;
case SpatialMaterial::TextureParam::TEXTURE_AMBIENT_OCCLUSION:
case Material3D::TextureParam::TEXTURE_AMBIENT_OCCLUSION:
// Use grayscale as default.
spatial_material->set_ao_texture_channel(SpatialMaterial::TextureChannel::TEXTURE_CHANNEL_GRAYSCALE);
spatial_material->set_ao_texture_channel(Material3D::TextureChannel::TEXTURE_CHANNEL_GRAYSCALE);
break;
case SpatialMaterial::TextureParam::TEXTURE_REFRACTION:
case Material3D::TextureParam::TEXTURE_REFRACTION:
// Use grayscale as default.
spatial_material->set_refraction_texture_channel(SpatialMaterial::TextureChannel::TEXTURE_CHANNEL_GRAYSCALE);
spatial_material->set_refraction_texture_channel(Material3D::TextureChannel::TEXTURE_CHANNEL_GRAYSCALE);
break;
default:
// Nothing to do.

140
modules/fbx/data/fbx_material.h
View File

@@ -71,41 +71,41 @@ struct FBXMaterial : public Reference {
};
/* Returns the string representation of the TextureParam enum */
static String get_texture_param_name(SpatialMaterial::TextureParam param) {
static String get_texture_param_name(Material3D::TextureParam param) {
switch (param) {
case SpatialMaterial::TEXTURE_ALBEDO:
case Material3D::TEXTURE_ALBEDO:
return "TEXTURE_ALBEDO";
case SpatialMaterial::TEXTURE_METALLIC:
case Material3D::TEXTURE_METALLIC:
return "TEXTURE_METALLIC";
case SpatialMaterial::TEXTURE_ROUGHNESS:
case Material3D::TEXTURE_ROUGHNESS:
return "TEXTURE_ROUGHNESS";
case SpatialMaterial::TEXTURE_EMISSION:
case Material3D::TEXTURE_EMISSION:
return "TEXTURE_EMISSION";
case SpatialMaterial::TEXTURE_NORMAL:
case Material3D::TEXTURE_NORMAL:
return "TEXTURE_NORMAL";
case SpatialMaterial::TEXTURE_RIM:
case Material3D::TEXTURE_RIM:
return "TEXTURE_RIM";
case SpatialMaterial::TEXTURE_CLEARCOAT:
case Material3D::TEXTURE_CLEARCOAT:
return "TEXTURE_CLEARCOAT";
case SpatialMaterial::TEXTURE_FLOWMAP:
case Material3D::TEXTURE_FLOWMAP:
return "TEXTURE_FLOWMAP";
case SpatialMaterial::TEXTURE_AMBIENT_OCCLUSION:
case Material3D::TEXTURE_AMBIENT_OCCLUSION:
return "TEXTURE_AMBIENT_OCCLUSION";
case SpatialMaterial::TEXTURE_DEPTH:
case Material3D::TEXTURE_DEPTH:
return "TEXTURE_DEPTH";
case SpatialMaterial::TEXTURE_SUBSURFACE_SCATTERING:
case Material3D::TEXTURE_SUBSURFACE_SCATTERING:
return "TEXTURE_SUBSURFACE_SCATTERING";
case SpatialMaterial::TEXTURE_TRANSMISSION:
case Material3D::TEXTURE_TRANSMISSION:
return "TEXTURE_TRANSMISSION";
case SpatialMaterial::TEXTURE_REFRACTION:
case Material3D::TEXTURE_REFRACTION:
return "TEXTURE_REFRACTION";
case SpatialMaterial::TEXTURE_DETAIL_MASK:
case Material3D::TEXTURE_DETAIL_MASK:
return "TEXTURE_DETAIL_MASK";
case SpatialMaterial::TEXTURE_DETAIL_ALBEDO:
case Material3D::TEXTURE_DETAIL_ALBEDO:
return "TEXTURE_DETAIL_ALBEDO";
case SpatialMaterial::TEXTURE_DETAIL_NORMAL:
case Material3D::TEXTURE_DETAIL_NORMAL:
return "TEXTURE_DETAIL_NORMAL";
case SpatialMaterial::TEXTURE_MAX:
case Material3D::TEXTURE_MAX:
return "TEXTURE_MAX";
default:
return "broken horribly";
@@ -113,69 +113,69 @@ struct FBXMaterial : public Reference {
};
// TODO make this static?
const std::map<std::string, SpatialMaterial::Feature> fbx_feature_mapping_desc = {
const std::map<std::string, Material3D::Feature> fbx_feature_mapping_desc = {
/* Transparent */
{ "TransparentColor", SpatialMaterial::Feature::FEATURE_TRANSPARENT },
{ "Maya|opacity", SpatialMaterial::Feature::FEATURE_TRANSPARENT }
{ "TransparentColor", Material3D::Feature::FEATURE_TRANSPARENT },
{ "Maya|opacity", Material3D::Feature::FEATURE_TRANSPARENT }
};
// TODO make this static?
const std::map<std::string, SpatialMaterial::TextureParam> fbx_texture_mapping_desc = {
const std::map<std::string, Material3D::TextureParam> fbx_texture_mapping_desc = {
/* Diffuse */
{ "Maya|base", SpatialMaterial::TextureParam::TEXTURE_ALBEDO },
{ "DiffuseColor", SpatialMaterial::TextureParam::TEXTURE_ALBEDO },
{ "Maya|DiffuseTexture", SpatialMaterial::TextureParam::TEXTURE_ALBEDO },
{ "Maya|baseColor", SpatialMaterial::TextureParam::TEXTURE_ALBEDO },
{ "Maya|baseColor|file", SpatialMaterial::TextureParam::TEXTURE_ALBEDO },
{ "3dsMax|Parameters|base_color_map", SpatialMaterial::TextureParam::TEXTURE_ALBEDO },
{ "Maya|TEX_color_map|file", SpatialMaterial::TextureParam::TEXTURE_ALBEDO },
{ "Maya|TEX_color_map", SpatialMaterial::TextureParam::TEXTURE_ALBEDO },
{ "Maya|base", Material3D::TextureParam::TEXTURE_ALBEDO },
{ "DiffuseColor", Material3D::TextureParam::TEXTURE_ALBEDO },
{ "Maya|DiffuseTexture", Material3D::TextureParam::TEXTURE_ALBEDO },
{ "Maya|baseColor", Material3D::TextureParam::TEXTURE_ALBEDO },
{ "Maya|baseColor|file", Material3D::TextureParam::TEXTURE_ALBEDO },
{ "3dsMax|Parameters|base_color_map", Material3D::TextureParam::TEXTURE_ALBEDO },
{ "Maya|TEX_color_map|file", Material3D::TextureParam::TEXTURE_ALBEDO },
{ "Maya|TEX_color_map", Material3D::TextureParam::TEXTURE_ALBEDO },
/* Emission */
{ "EmissiveColor", SpatialMaterial::TextureParam::TEXTURE_EMISSION },
{ "EmissiveFactor", SpatialMaterial::TextureParam::TEXTURE_EMISSION },
{ "Maya|emissionColor", SpatialMaterial::TextureParam::TEXTURE_EMISSION },
{ "Maya|emissionColor|file", SpatialMaterial::TextureParam::TEXTURE_EMISSION },
{ "3dsMax|Parameters|emission_map", SpatialMaterial::TextureParam::TEXTURE_EMISSION },
{ "Maya|TEX_emissive_map", SpatialMaterial::TextureParam::TEXTURE_EMISSION },
{ "Maya|TEX_emissive_map|file", SpatialMaterial::TextureParam::TEXTURE_EMISSION },
{ "EmissiveColor", Material3D::TextureParam::TEXTURE_EMISSION },
{ "EmissiveFactor", Material3D::TextureParam::TEXTURE_EMISSION },
{ "Maya|emissionColor", Material3D::TextureParam::TEXTURE_EMISSION },
{ "Maya|emissionColor|file", Material3D::TextureParam::TEXTURE_EMISSION },
{ "3dsMax|Parameters|emission_map", Material3D::TextureParam::TEXTURE_EMISSION },
{ "Maya|TEX_emissive_map", Material3D::TextureParam::TEXTURE_EMISSION },
{ "Maya|TEX_emissive_map|file", Material3D::TextureParam::TEXTURE_EMISSION },
/* Metallic */
{ "Maya|metalness", SpatialMaterial::TextureParam::TEXTURE_METALLIC },
{ "Maya|metalness|file", SpatialMaterial::TextureParam::TEXTURE_METALLIC },
{ "3dsMax|Parameters|metalness_map", SpatialMaterial::TextureParam::TEXTURE_METALLIC },
{ "Maya|TEX_metallic_map", SpatialMaterial::TextureParam::TEXTURE_METALLIC },
{ "Maya|TEX_metallic_map|file", SpatialMaterial::TextureParam::TEXTURE_METALLIC },
{ "SpecularColor", SpatialMaterial::TextureParam::TEXTURE_METALLIC },
{ "Maya|specularColor", SpatialMaterial::TextureParam::TEXTURE_METALLIC },
{ "Maya|SpecularTexture", SpatialMaterial::TextureParam::TEXTURE_METALLIC },
{ "Maya|SpecularTexture|file", SpatialMaterial::TextureParam::TEXTURE_METALLIC },
{ "Maya|metalness", Material3D::TextureParam::TEXTURE_METALLIC },
{ "Maya|metalness|file", Material3D::TextureParam::TEXTURE_METALLIC },
{ "3dsMax|Parameters|metalness_map", Material3D::TextureParam::TEXTURE_METALLIC },
{ "Maya|TEX_metallic_map", Material3D::TextureParam::TEXTURE_METALLIC },
{ "Maya|TEX_metallic_map|file", Material3D::TextureParam::TEXTURE_METALLIC },
{ "SpecularColor", Material3D::TextureParam::TEXTURE_METALLIC },
{ "Maya|specularColor", Material3D::TextureParam::TEXTURE_METALLIC },
{ "Maya|SpecularTexture", Material3D::TextureParam::TEXTURE_METALLIC },
{ "Maya|SpecularTexture|file", Material3D::TextureParam::TEXTURE_METALLIC },
/* Roughness */
// Arnold Roughness Map
{ "Maya|specularRoughness", SpatialMaterial::TextureParam::TEXTURE_ROUGHNESS },
{ "Maya|specularRoughness", Material3D::TextureParam::TEXTURE_ROUGHNESS },
{ "3dsMax|Parameters|roughness_map", SpatialMaterial::TextureParam::TEXTURE_ROUGHNESS },
{ "Maya|TEX_roughness_map", SpatialMaterial::TextureParam::TEXTURE_ROUGHNESS },
{ "Maya|TEX_roughness_map|file", SpatialMaterial::TextureParam::TEXTURE_ROUGHNESS },
{ "3dsMax|Parameters|roughness_map", Material3D::TextureParam::TEXTURE_ROUGHNESS },
{ "Maya|TEX_roughness_map", Material3D::TextureParam::TEXTURE_ROUGHNESS },
{ "Maya|TEX_roughness_map|file", Material3D::TextureParam::TEXTURE_ROUGHNESS },
/* Normal */
{ "NormalMap", SpatialMaterial::TextureParam::TEXTURE_NORMAL },
//{ "Bump", SpatialMaterial::TextureParam::TEXTURE_NORMAL },
//{ "3dsMax|Parameters|bump_map", SpatialMaterial::TextureParam::TEXTURE_NORMAL },
{ "Maya|NormalTexture", SpatialMaterial::TextureParam::TEXTURE_NORMAL },
//{ "Maya|normalCamera", SpatialMaterial::TextureParam::TEXTURE_NORMAL },
//{ "Maya|normalCamera|file", SpatialMaterial::TextureParam::TEXTURE_NORMAL },
{ "Maya|TEX_normal_map", SpatialMaterial::TextureParam::TEXTURE_NORMAL },
{ "Maya|TEX_normal_map|file", SpatialMaterial::TextureParam::TEXTURE_NORMAL },
{ "NormalMap", Material3D::TextureParam::TEXTURE_NORMAL },
//{ "Bump", Material3D::TextureParam::TEXTURE_NORMAL },
//{ "3dsMax|Parameters|bump_map", Material3D::TextureParam::TEXTURE_NORMAL },
{ "Maya|NormalTexture", Material3D::TextureParam::TEXTURE_NORMAL },
//{ "Maya|normalCamera", Material3D::TextureParam::TEXTURE_NORMAL },
//{ "Maya|normalCamera|file", Material3D::TextureParam::TEXTURE_NORMAL },
{ "Maya|TEX_normal_map", Material3D::TextureParam::TEXTURE_NORMAL },
{ "Maya|TEX_normal_map|file", Material3D::TextureParam::TEXTURE_NORMAL },
/* AO */
{ "Maya|TEX_ao_map", SpatialMaterial::TextureParam::TEXTURE_AMBIENT_OCCLUSION },
{ "Maya|TEX_ao_map|file", SpatialMaterial::TextureParam::TEXTURE_AMBIENT_OCCLUSION },
{ "Maya|TEX_ao_map", Material3D::TextureParam::TEXTURE_AMBIENT_OCCLUSION },
{ "Maya|TEX_ao_map|file", Material3D::TextureParam::TEXTURE_AMBIENT_OCCLUSION },
//{ "Maya|diffuseRoughness", SpatialMaterial::TextureParam::UNSUPPORTED },
//{ "Maya|diffuseRoughness|file", SpatialMaterial::TextureParam::UNSUPPORTED },
//{ "ShininessExponent", SpatialMaterial::TextureParam::UNSUPPORTED },
//{ "ReflectionFactor", SpatialMaterial::TextureParam::UNSUPPORTED },
//{ "TransparentColor",SpatialMaterial::TextureParam::TEXTURE_CHANNEL_ALPHA },
//{ "TransparencyFactor",SpatialMaterial::TextureParam::TEXTURE_CHANNEL_ALPHA }
//{ "Maya|diffuseRoughness", Material3D::TextureParam::UNSUPPORTED },
//{ "Maya|diffuseRoughness|file", Material3D::TextureParam::UNSUPPORTED },
//{ "ShininessExponent", Material3D::TextureParam::UNSUPPORTED },
//{ "ReflectionFactor", Material3D::TextureParam::UNSUPPORTED },
//{ "TransparentColor",Material3D::TextureParam::TEXTURE_CHANNEL_ALPHA },
//{ "TransparencyFactor",Material3D::TextureParam::TEXTURE_CHANNEL_ALPHA }
};
// TODO make this static?
@@ -261,7 +261,7 @@ struct FBXMaterial : public Reference {
};
struct TextureFileMapping {
SpatialMaterial::TextureParam map_mode = SpatialMaterial::TEXTURE_ALBEDO;
Material3D::TextureParam map_mode = Material3D::TEXTURE_ALBEDO;
String name = String();
const FBXDocParser::Texture *texture = nullptr;
};
@@ -269,7 +269,7 @@ struct FBXMaterial : public Reference {
/* storing the texture properties like color */
template <class T>
struct TexturePropertyMapping : Reference {
SpatialMaterial::TextureParam map_mode = SpatialMaterial::TextureParam::TEXTURE_ALBEDO;
Material3D::TextureParam map_mode = Material3D::TextureParam::TEXTURE_ALBEDO;
const T property = T();
};
@@ -283,12 +283,12 @@ struct FBXMaterial : public Reference {
struct MaterialInfo {
Vector<TextureFileMapping> textures;
Vector<SpatialMaterial::Feature> features;
Vector<Material3D::Feature> features;
};
/// Extracts the material information.
MaterialInfo extract_material_info(const FBXDocParser::Material *material) const;
Ref<SpatialMaterial> import_material(ImportState &state);
Ref<Material3D> import_material(ImportState &state);
};
#endif // FBX_MATERIAL_H

2
modules/fbx/data/fbx_mesh_data.cpp
View File

@@ -110,7 +110,7 @@ struct SurfaceData {
Ref<SurfaceTool> surface_tool;
OrderedHashMap<Vertex, int> lookup_table; // proposed fix is to replace lookup_table[vertex_id] to give the position of the vertices_map[int] index.
LocalVector<Vertex> vertices_map; // this must be ordered the same as insertion <-- slow to do find() operation.
Ref<SpatialMaterial> material;
Ref<Material3D> material;
HashMap<PolygonId, Vector<DataIndex>> surface_polygon_vertex;
Array morphs;
};

2
modules/fbx/data/import_state.h
View File

@@ -67,7 +67,7 @@ struct ImportState {
bool is_blender_fbx = false;
Map<StringName, Ref<Texture>> cached_image_searches;
Map<uint64_t, Ref<SpatialMaterial>> cached_materials;
Map<uint64_t, Ref<Material3D>> cached_materials;
String path = String();
Spatial *root_owner = nullptr;

2
modules/fbx/editor_scene_importer_fbx.cpp
View File

@@ -530,7 +530,7 @@ Spatial *EditorSceneImporterFBX::_generate_scene(
material.instance();
material->set_imported_material(mat);
Ref<SpatialMaterial> godot_material = material->import_material(state);
Ref<Material3D> godot_material = material->import_material(state);
state.cached_materials.insert(material_id, godot_material);
}

138
modules/gltf/gltf_document.cpp
View File

@@ -2587,7 +2587,7 @@ Error GLTFDocument::_serialize_meshes(Ref<GLTFState> p_state) {
if (surface_i < instance_materials.size()) {
v = instance_materials.get(surface_i);
}
Ref<SpatialMaterial> mat = v;
Ref<Material3D> mat = v;
if (!mat.is_valid()) {
mat = import_mesh->surface_get_material(surface_i);
}
@@ -2919,20 +2919,20 @@ Error GLTFDocument::_parse_meshes(Ref<GLTFState> p_state) {
//just add it
Ref<SpatialMaterial> mat;
Ref<Material3D> mat;
if (p.has("material")) {
const int material = p["material"];
ERR_FAIL_INDEX_V(material, p_state->materials.size(), ERR_FILE_CORRUPT);
Ref<SpatialMaterial> mat3d = p_state->materials[material];
Ref<Material3D> mat3d = p_state->materials[material];
if (has_vertex_color) {
mat3d->set_flag(SpatialMaterial::FLAG_ALBEDO_FROM_VERTEX_COLOR, true);
mat3d->set_flag(Material3D::FLAG_ALBEDO_FROM_VERTEX_COLOR, true);
}
mat = mat3d;
} else if (has_vertex_color) {
Ref<SpatialMaterial> mat3d;
Ref<Material3D> mat3d;
mat3d.instance();
mat3d->set_flag(SpatialMaterial::FLAG_ALBEDO_FROM_VERTEX_COLOR, true);
mat3d->set_flag(Material3D::FLAG_ALBEDO_FROM_VERTEX_COLOR, true);
mat = mat3d;
}
int32_t mat_idx = import_mesh->get_surface_count();
@@ -3377,7 +3377,7 @@ Error GLTFDocument::_serialize_materials(Ref<GLTFState> p_state) {
for (int32_t i = 0; i < p_state->materials.size(); i++) {
Dictionary d;
Ref<SpatialMaterial> material = p_state->materials[i];
Ref<Material3D> material = p_state->materials[i];
if (material.is_null()) {
materials.push_back(d);
continue;
@@ -3398,7 +3398,7 @@ Error GLTFDocument::_serialize_materials(Ref<GLTFState> p_state) {
}
{
Dictionary bct;
Ref<Texture> albedo_texture = material->get_texture(SpatialMaterial::TEXTURE_ALBEDO);
Ref<Texture> albedo_texture = material->get_texture(Material3D::TEXTURE_ALBEDO);
GLTFTextureIndex gltf_texture_index = -1;
if (albedo_texture.is_valid() && albedo_texture->get_data().is_valid()) {
@@ -3418,17 +3418,17 @@ Error GLTFDocument::_serialize_materials(Ref<GLTFState> p_state) {
mr["metallicFactor"] = material->get_metallic();
mr["roughnessFactor"] = material->get_roughness();
bool has_roughness = material->get_texture(SpatialMaterial::TEXTURE_ROUGHNESS).is_valid() && material->get_texture(SpatialMaterial::TEXTURE_ROUGHNESS)->get_data().is_valid();
bool has_ao = material->get_feature(SpatialMaterial::FEATURE_AMBIENT_OCCLUSION) && material->get_texture(SpatialMaterial::TEXTURE_AMBIENT_OCCLUSION).is_valid();
bool has_metalness = material->get_texture(SpatialMaterial::TEXTURE_METALLIC).is_valid() && material->get_texture(SpatialMaterial::TEXTURE_METALLIC)->get_data().is_valid();
bool has_roughness = material->get_texture(Material3D::TEXTURE_ROUGHNESS).is_valid() && material->get_texture(Material3D::TEXTURE_ROUGHNESS)->get_data().is_valid();
bool has_ao = material->get_feature(Material3D::FEATURE_AMBIENT_OCCLUSION) && material->get_texture(Material3D::TEXTURE_AMBIENT_OCCLUSION).is_valid();
bool has_metalness = material->get_texture(Material3D::TEXTURE_METALLIC).is_valid() && material->get_texture(Material3D::TEXTURE_METALLIC)->get_data().is_valid();
if (has_ao || has_roughness || has_metalness) {
Dictionary mrt;
Ref<Texture> roughness_texture = material->get_texture(SpatialMaterial::TEXTURE_ROUGHNESS);
SpatialMaterial::TextureChannel roughness_channel = material->get_roughness_texture_channel();
Ref<Texture> metallic_texture = material->get_texture(SpatialMaterial::TEXTURE_METALLIC);
SpatialMaterial::TextureChannel metalness_channel = material->get_metallic_texture_channel();
Ref<Texture> ao_texture = material->get_texture(SpatialMaterial::TEXTURE_AMBIENT_OCCLUSION);
SpatialMaterial::TextureChannel ao_channel = material->get_ao_texture_channel();
Ref<Texture> roughness_texture = material->get_texture(Material3D::TEXTURE_ROUGHNESS);
Material3D::TextureChannel roughness_channel = material->get_roughness_texture_channel();
Ref<Texture> metallic_texture = material->get_texture(Material3D::TEXTURE_METALLIC);
Material3D::TextureChannel metalness_channel = material->get_metallic_texture_channel();
Ref<Texture> ao_texture = material->get_texture(Material3D::TEXTURE_AMBIENT_OCCLUSION);
Material3D::TextureChannel ao_channel = material->get_ao_texture_channel();
Ref<ImageTexture> orm_texture;
orm_texture.instance();
Ref<Image> orm_image;
@@ -3474,7 +3474,7 @@ Error GLTFDocument::_serialize_materials(Ref<GLTFState> p_state) {
metallness_image->decompress();
}
}
Ref<Texture> albedo_texture = material->get_texture(SpatialMaterial::TEXTURE_ALBEDO);
Ref<Texture> albedo_texture = material->get_texture(Material3D::TEXTURE_ALBEDO);
if (albedo_texture.is_valid() && albedo_texture->get_data().is_valid()) {
height = albedo_texture->get_height();
width = albedo_texture->get_width();
@@ -3495,39 +3495,39 @@ Error GLTFDocument::_serialize_materials(Ref<GLTFState> p_state) {
Color c = Color(1.0f, 1.0f, 1.0f);
if (has_ao) {
ao_image->lock();
if (SpatialMaterial::TextureChannel::TEXTURE_CHANNEL_RED == ao_channel) {
if (Material3D::TextureChannel::TEXTURE_CHANNEL_RED == ao_channel) {
c.r = ao_image->get_pixel(w, h).r;
} else if (SpatialMaterial::TextureChannel::TEXTURE_CHANNEL_GREEN == ao_channel) {
} else if (Material3D::TextureChannel::TEXTURE_CHANNEL_GREEN == ao_channel) {
c.r = ao_image->get_pixel(w, h).g;
} else if (SpatialMaterial::TextureChannel::TEXTURE_CHANNEL_BLUE == ao_channel) {
} else if (Material3D::TextureChannel::TEXTURE_CHANNEL_BLUE == ao_channel) {
c.r = ao_image->get_pixel(w, h).b;
} else if (SpatialMaterial::TextureChannel::TEXTURE_CHANNEL_ALPHA == ao_channel) {
} else if (Material3D::TextureChannel::TEXTURE_CHANNEL_ALPHA == ao_channel) {
c.r = ao_image->get_pixel(w, h).a;
}
ao_image->lock();
}
if (has_roughness) {
roughness_image->lock();
if (SpatialMaterial::TextureChannel::TEXTURE_CHANNEL_RED == roughness_channel) {
if (Material3D::TextureChannel::TEXTURE_CHANNEL_RED == roughness_channel) {
c.g = roughness_image->get_pixel(w, h).r;
} else if (SpatialMaterial::TextureChannel::TEXTURE_CHANNEL_GREEN == roughness_channel) {
} else if (Material3D::TextureChannel::TEXTURE_CHANNEL_GREEN == roughness_channel) {
c.g = roughness_image->get_pixel(w, h).g;
} else if (SpatialMaterial::TextureChannel::TEXTURE_CHANNEL_BLUE == roughness_channel) {
} else if (Material3D::TextureChannel::TEXTURE_CHANNEL_BLUE == roughness_channel) {
c.g = roughness_image->get_pixel(w, h).b;
} else if (SpatialMaterial::TextureChannel::TEXTURE_CHANNEL_ALPHA == roughness_channel) {
} else if (Material3D::TextureChannel::TEXTURE_CHANNEL_ALPHA == roughness_channel) {
c.g = roughness_image->get_pixel(w, h).a;
}
roughness_image->unlock();
}
if (has_metalness) {
metallness_image->lock();
if (SpatialMaterial::TextureChannel::TEXTURE_CHANNEL_RED == metalness_channel) {
if (Material3D::TextureChannel::TEXTURE_CHANNEL_RED == metalness_channel) {
c.b = metallness_image->get_pixel(w, h).r;
} else if (SpatialMaterial::TextureChannel::TEXTURE_CHANNEL_GREEN == metalness_channel) {
} else if (Material3D::TextureChannel::TEXTURE_CHANNEL_GREEN == metalness_channel) {
c.b = metallness_image->get_pixel(w, h).g;
} else if (SpatialMaterial::TextureChannel::TEXTURE_CHANNEL_BLUE == metalness_channel) {
} else if (Material3D::TextureChannel::TEXTURE_CHANNEL_BLUE == metalness_channel) {
c.b = metallness_image->get_pixel(w, h).b;
} else if (SpatialMaterial::TextureChannel::TEXTURE_CHANNEL_ALPHA == metalness_channel) {
} else if (Material3D::TextureChannel::TEXTURE_CHANNEL_ALPHA == metalness_channel) {
c.b = metallness_image->get_pixel(w, h).a;
}
metallness_image->unlock();
@@ -3561,12 +3561,12 @@ Error GLTFDocument::_serialize_materials(Ref<GLTFState> p_state) {
d["pbrMetallicRoughness"] = mr;
}
if (material->get_feature(SpatialMaterial::FEATURE_NORMAL_MAPPING)) {
if (material->get_feature(Material3D::FEATURE_NORMAL_MAPPING)) {
Dictionary nt;
Ref<ImageTexture> tex;
tex.instance();
{
Ref<Texture> normal_texture = material->get_texture(SpatialMaterial::TEXTURE_NORMAL);
Ref<Texture> normal_texture = material->get_texture(Material3D::TEXTURE_NORMAL);
if (normal_texture.is_valid()) {
// Code for uncompressing RG normal maps
Ref<Image> img = normal_texture->get_data();
@@ -3606,7 +3606,7 @@ Error GLTFDocument::_serialize_materials(Ref<GLTFState> p_state) {
}
}
if (material->get_feature(SpatialMaterial::FEATURE_EMISSION)) {
if (material->get_feature(Material3D::FEATURE_EMISSION)) {
const Color c = material->get_emission().to_srgb();
Array arr;
arr.push_back(c.r);
@@ -3614,9 +3614,9 @@ Error GLTFDocument::_serialize_materials(Ref<GLTFState> p_state) {
arr.push_back(c.b);
d["emissiveFactor"] = arr;
}
if (material->get_feature(SpatialMaterial::FEATURE_EMISSION)) {
if (material->get_feature(Material3D::FEATURE_EMISSION)) {
Dictionary et;
Ref<Texture> emission_texture = material->get_texture(SpatialMaterial::TEXTURE_EMISSION);
Ref<Texture> emission_texture = material->get_texture(Material3D::TEXTURE_EMISSION);
GLTFTextureIndex gltf_texture_index = -1;
if (emission_texture.is_valid() && emission_texture->get_data().is_valid()) {
emission_texture->set_name(material->get_name() + "_emission");
@@ -3628,12 +3628,12 @@ Error GLTFDocument::_serialize_materials(Ref<GLTFState> p_state) {
d["emissiveTexture"] = et;
}
}
const bool ds = material->get_cull_mode() == SpatialMaterial::CULL_DISABLED;
const bool ds = material->get_cull_mode() == Material3D::CULL_DISABLED;
if (ds) {
d["doubleSided"] = ds;
}
if (material->get_feature(SpatialMaterial::FEATURE_TRANSPARENT)) {
if (material->get_flag(SpatialMaterial::FLAG_USE_ALPHA_SCISSOR)) {
if (material->get_feature(Material3D::FEATURE_TRANSPARENT)) {
if (material->get_flag(Material3D::FLAG_USE_ALPHA_SCISSOR)) {
d["alphaMode"] = "MASK";
d["alphaCutoff"] = material->get_alpha_scissor_threshold();
} else {
@@ -3642,7 +3642,7 @@ Error GLTFDocument::_serialize_materials(Ref<GLTFState> p_state) {
}
Dictionary extensions;
if (material->get_flag(SpatialMaterial::FLAG_UNSHADED)) {
if (material->get_flag(Material3D::FLAG_UNSHADED)) {
Dictionary mat_unlit;
extensions["KHR_materials_unlit"] = mat_unlit;
p_state->add_used_extension("KHR_materials_unlit");
@@ -3669,7 +3669,7 @@ Error GLTFDocument::_parse_materials(Ref<GLTFState> p_state) {
for (GLTFMaterialIndex i = 0; i < materials.size(); i++) {
const Dictionary &d = materials[i];
Ref<SpatialMaterial> material;
Ref<Material3D> material;
material.instance();
if (d.has("name") && !String(d["name"]).empty()) {
material->set_name(d["name"]);
@@ -3677,14 +3677,14 @@ Error GLTFDocument::_parse_materials(Ref<GLTFState> p_state) {
material->set_name(vformat("material_%s", itos(i)));
}
material->set_flag(SpatialMaterial::FLAG_ALBEDO_FROM_VERTEX_COLOR, true);
material->set_flag(Material3D::FLAG_ALBEDO_FROM_VERTEX_COLOR, true);
Dictionary pbr_spec_gloss_extensions;
if (d.has("extensions")) {
pbr_spec_gloss_extensions = d["extensions"];
}
if (pbr_spec_gloss_extensions.has("KHR_materials_unlit")) {
material->set_flag(SpatialMaterial::FLAG_UNSHADED, true);
material->set_flag(Material3D::FLAG_UNSHADED, true);
}
if (pbr_spec_gloss_extensions.has("KHR_materials_pbrSpecularGlossiness")) {
@@ -3699,7 +3699,7 @@ Error GLTFDocument::_parse_materials(Ref<GLTFState> p_state) {
Ref<Texture> diffuse_texture = _get_texture(p_state, diffuse_texture_dict["index"]);
if (diffuse_texture.is_valid()) {
spec_gloss->diffuse_img = diffuse_texture->get_data();
material->set_texture(SpatialMaterial::TEXTURE_ALBEDO, diffuse_texture);
material->set_texture(Material3D::TEXTURE_ALBEDO, diffuse_texture);
}
}
}
@@ -3744,7 +3744,7 @@ Error GLTFDocument::_parse_materials(Ref<GLTFState> p_state) {
if (mr.has("baseColorTexture")) {
const Dictionary &bct = mr["baseColorTexture"];
if (bct.has("index")) {
material->set_texture(SpatialMaterial::TEXTURE_ALBEDO, _get_texture(p_state, bct["index"]));
material->set_texture(Material3D::TEXTURE_ALBEDO, _get_texture(p_state, bct["index"]));
}
if (!mr.has("baseColorFactor")) {
material->set_albedo(Color(1, 1, 1));
@@ -3768,10 +3768,10 @@ Error GLTFDocument::_parse_materials(Ref<GLTFState> p_state) {
const Dictionary &bct = mr["metallicRoughnessTexture"];
if (bct.has("index")) {
const Ref<Texture> t = _get_texture(p_state, bct["index"]);
material->set_texture(SpatialMaterial::TEXTURE_METALLIC, t);
material->set_metallic_texture_channel(SpatialMaterial::TEXTURE_CHANNEL_BLUE);
material->set_texture(SpatialMaterial::TEXTURE_ROUGHNESS, t);
material->set_roughness_texture_channel(SpatialMaterial::TEXTURE_CHANNEL_GREEN);
material->set_texture(Material3D::TEXTURE_METALLIC, t);
material->set_metallic_texture_channel(Material3D::TEXTURE_CHANNEL_BLUE);
material->set_texture(Material3D::TEXTURE_ROUGHNESS, t);
material->set_roughness_texture_channel(Material3D::TEXTURE_CHANNEL_GREEN);
if (!mr.has("metallicFactor")) {
material->set_metallic(1);
}
@@ -3785,8 +3785,8 @@ Error GLTFDocument::_parse_materials(Ref<GLTFState> p_state) {
if (d.has("normalTexture")) {
const Dictionary &bct = d["normalTexture"];
if (bct.has("index")) {
material->set_texture(SpatialMaterial::TEXTURE_NORMAL, _get_texture(p_state, bct["index"]));
material->set_feature(SpatialMaterial::FEATURE_NORMAL_MAPPING, true);
material->set_texture(Material3D::TEXTURE_NORMAL, _get_texture(p_state, bct["index"]));
material->set_feature(Material3D::FEATURE_NORMAL_MAPPING, true);
}
if (bct.has("scale")) {
material->set_normal_scale(bct["scale"]);
@@ -3795,9 +3795,9 @@ Error GLTFDocument::_parse_materials(Ref<GLTFState> p_state) {
if (d.has("occlusionTexture")) {
const Dictionary &bct = d["occlusionTexture"];
if (bct.has("index")) {
material->set_texture(SpatialMaterial::TEXTURE_AMBIENT_OCCLUSION, _get_texture(p_state, bct["index"]));
material->set_ao_texture_channel(SpatialMaterial::TEXTURE_CHANNEL_RED);
material->set_feature(SpatialMaterial::FEATURE_AMBIENT_OCCLUSION, true);
material->set_texture(Material3D::TEXTURE_AMBIENT_OCCLUSION, _get_texture(p_state, bct["index"]));
material->set_ao_texture_channel(Material3D::TEXTURE_CHANNEL_RED);
material->set_feature(Material3D::FEATURE_AMBIENT_OCCLUSION, true);
}
}
@@ -3805,7 +3805,7 @@ Error GLTFDocument::_parse_materials(Ref<GLTFState> p_state) {
const Array &arr = d["emissiveFactor"];
ERR_FAIL_COND_V(arr.size() != 3, ERR_PARSE_ERROR);
const Color c = Color(arr[0], arr[1], arr[2]).to_srgb();
material->set_feature(SpatialMaterial::FEATURE_EMISSION, true);
material->set_feature(Material3D::FEATURE_EMISSION, true);
material->set_emission(c);
}
@@ -3813,8 +3813,8 @@ Error GLTFDocument::_parse_materials(Ref<GLTFState> p_state) {
if (d.has("emissiveTexture")) {
const Dictionary &bct = d["emissiveTexture"];
if (bct.has("index")) {
material->set_texture(SpatialMaterial::TEXTURE_EMISSION, _get_texture(p_state, bct["index"]));
material->set_feature(SpatialMaterial::FEATURE_EMISSION, true);
material->set_texture(Material3D::TEXTURE_EMISSION, _get_texture(p_state, bct["index"]));
material->set_feature(Material3D::FEATURE_EMISSION, true);
material->set_emission(Color(0, 0, 0));
}
}
@@ -3822,17 +3822,17 @@ Error GLTFDocument::_parse_materials(Ref<GLTFState> p_state) {
if (d.has("doubleSided")) {
const bool ds = d["doubleSided"];
if (ds) {
material->set_cull_mode(SpatialMaterial::CULL_DISABLED);
material->set_cull_mode(Material3D::CULL_DISABLED);
}
}
if (d.has("alphaMode")) {
const String &am = d["alphaMode"];
if (am == "BLEND") {
material->set_feature(SpatialMaterial::FEATURE_TRANSPARENT, true);
material->set_depth_draw_mode(SpatialMaterial::DEPTH_DRAW_ALPHA_OPAQUE_PREPASS);
material->set_feature(Material3D::FEATURE_TRANSPARENT, true);
material->set_depth_draw_mode(Material3D::DEPTH_DRAW_ALPHA_OPAQUE_PREPASS);
} else if (am == "MASK") {
material->set_flag(SpatialMaterial::FLAG_USE_ALPHA_SCISSOR, true);
material->set_flag(Material3D::FLAG_USE_ALPHA_SCISSOR, true);
if (d.has("alphaCutoff")) {
material->set_alpha_scissor_threshold(d["alphaCutoff"]);
} else {
@@ -3848,7 +3848,7 @@ Error GLTFDocument::_parse_materials(Ref<GLTFState> p_state) {
return OK;
}
void GLTFDocument::_set_texture_transform_uv1(const Dictionary &p_dict, Ref<SpatialMaterial> p_material) {
void GLTFDocument::_set_texture_transform_uv1(const Dictionary &p_dict, Ref<Material3D> p_material) {
if (p_dict.has("extensions")) {
const Dictionary &extensions = p_dict["extensions"];
if (extensions.has("KHR_texture_transform")) {
@@ -3868,7 +3868,7 @@ void GLTFDocument::_set_texture_transform_uv1(const Dictionary &p_dict, Ref<Spat
}
}
void GLTFDocument::spec_gloss_to_rough_metal(Ref<GLTFSpecGloss> r_spec_gloss, Ref<SpatialMaterial> p_material) {
void GLTFDocument::spec_gloss_to_rough_metal(Ref<GLTFSpecGloss> r_spec_gloss, Ref<Material3D> p_material) {
if (r_spec_gloss->spec_gloss_img.is_null()) {
return;
}
@@ -3922,18 +3922,18 @@ void GLTFDocument::spec_gloss_to_rough_metal(Ref<GLTFSpecGloss> r_spec_gloss, Re
Ref<ImageTexture> diffuse_image_texture;
diffuse_image_texture.instance();
diffuse_image_texture->create_from_image(r_spec_gloss->diffuse_img);
p_material->set_texture(SpatialMaterial::TEXTURE_ALBEDO, diffuse_image_texture);
p_material->set_texture(Material3D::TEXTURE_ALBEDO, diffuse_image_texture);
Ref<ImageTexture> rm_image_texture;
rm_image_texture.instance();
rm_image_texture->create_from_image(rm_img);
if (has_roughness) {
p_material->set_texture(SpatialMaterial::TEXTURE_ROUGHNESS, rm_image_texture);
p_material->set_roughness_texture_channel(SpatialMaterial::TEXTURE_CHANNEL_GREEN);
p_material->set_texture(Material3D::TEXTURE_ROUGHNESS, rm_image_texture);
p_material->set_roughness_texture_channel(Material3D::TEXTURE_CHANNEL_GREEN);
}
if (has_metal) {
p_material->set_texture(SpatialMaterial::TEXTURE_METALLIC, rm_image_texture);
p_material->set_metallic_texture_channel(SpatialMaterial::TEXTURE_CHANNEL_BLUE);
p_material->set_texture(Material3D::TEXTURE_METALLIC, rm_image_texture);
p_material->set_metallic_texture_channel(Material3D::TEXTURE_CHANNEL_BLUE);
}
}
@@ -6859,7 +6859,7 @@ Dictionary _serialize_texture_transform_uv(Vector2 p_offset, Vector2 p_scale) {
return extension;
}
Dictionary GLTFDocument::_serialize_texture_transform_uv1(Ref<SpatialMaterial> p_material) {
Dictionary GLTFDocument::_serialize_texture_transform_uv1(Ref<Material3D> p_material) {
if (p_material.is_valid()) {
Vector3 offset = p_material->get_uv1_offset();
Vector3 scale = p_material->get_uv1_scale();
@@ -6868,7 +6868,7 @@ Dictionary GLTFDocument::_serialize_texture_transform_uv1(Ref<SpatialMaterial> p
return Dictionary();
}
Dictionary GLTFDocument::_serialize_texture_transform_uv2(Ref<SpatialMaterial> p_material) {
Dictionary GLTFDocument::_serialize_texture_transform_uv2(Ref<Material3D> p_material) {
if (p_material.is_valid()) {
Vector3 offset = p_material->get_uv2_offset();
Vector3 scale = p_material->get_uv2_scale();

8
modules/gltf/gltf_document.h
View File

@@ -171,9 +171,9 @@ private:
Error _parse_textures(Ref<GLTFState> p_state);
Error _parse_texture_samplers(Ref<GLTFState> p_state);
Error _parse_materials(Ref<GLTFState> p_state);
void _set_texture_transform_uv1(const Dictionary &p_dict, Ref<SpatialMaterial> p_material);
void _set_texture_transform_uv1(const Dictionary &p_dict, Ref<Material3D> p_material);
void spec_gloss_to_rough_metal(Ref<GLTFSpecGloss> r_spec_gloss,
Ref<SpatialMaterial> p_material);
Ref<Material3D> p_material);
static void spec_gloss_to_metal_base_color(const Color &p_specular_factor,
const Color &p_diffuse,
Color &r_base_color,
@@ -283,8 +283,8 @@ private:
GLTFNodeIndex p_node_i);
Error _encode_buffer_bins(Ref<GLTFState> p_state, const String &p_path);
Error _encode_buffer_glb(Ref<GLTFState> p_state, const String &p_path);
Dictionary _serialize_texture_transform_uv1(Ref<SpatialMaterial> p_material);
Dictionary _serialize_texture_transform_uv2(Ref<SpatialMaterial> p_material);
Dictionary _serialize_texture_transform_uv1(Ref<Material3D> p_material);
Dictionary _serialize_texture_transform_uv2(Ref<Material3D> p_material);
Error _serialize_version(Ref<GLTFState> p_state);
Error _serialize_file(Ref<GLTFState> p_state, const String p_path);
Error _serialize_gltf_extensions(Ref<GLTFState> p_state) const;

18
modules/gridmap/grid_map_editor_plugin.cpp
View File

@@ -1421,8 +1421,8 @@ GridMapEditor::GridMapEditor(EditorNode *p_editor) {
inner_mat.instance();
inner_mat->set_albedo(Color(0.7, 0.7, 1.0, 0.2));
inner_mat->set_flag(SpatialMaterial::FLAG_UNSHADED, true);
inner_mat->set_feature(SpatialMaterial::FEATURE_TRANSPARENT, true);
inner_mat->set_flag(Material3D::FLAG_UNSHADED, true);
inner_mat->set_feature(Material3D::FEATURE_TRANSPARENT, true);
d[VS::ARRAY_VERTEX] = triangles;
VisualServer::get_singleton()->mesh_add_surface_from_arrays(selection_mesh, VS::PRIMITIVE_TRIANGLES, d);
@@ -1431,14 +1431,14 @@ GridMapEditor::GridMapEditor(EditorNode *p_editor) {
outer_mat.instance();
outer_mat->set_albedo(Color(0.7, 0.7, 1.0, 0.8));
outer_mat->set_on_top_of_alpha();
outer_mat->set_flag(SpatialMaterial::FLAG_UNSHADED, true);
outer_mat->set_flag(Material3D::FLAG_UNSHADED, true);
outer_mat->set_line_width(3.0);
outer_mat->set_feature(SpatialMaterial::FEATURE_TRANSPARENT, true);
outer_mat->set_feature(Material3D::FEATURE_TRANSPARENT, true);
selection_floor_mat.instance();
selection_floor_mat->set_albedo(Color(0.80, 0.80, 1.0, 1));
selection_floor_mat->set_on_top_of_alpha();
selection_floor_mat->set_flag(SpatialMaterial::FLAG_UNSHADED, true);
selection_floor_mat->set_flag(Material3D::FLAG_UNSHADED, true);
selection_floor_mat->set_line_width(3.0);
d[VS::ARRAY_VERTEX] = lines;
@@ -1466,10 +1466,10 @@ GridMapEditor::GridMapEditor(EditorNode *p_editor) {
accumulated_floor_delta = 0.0;
indicator_mat.instance();
indicator_mat->set_flag(SpatialMaterial::FLAG_UNSHADED, true);
indicator_mat->set_feature(SpatialMaterial::FEATURE_TRANSPARENT, true);
indicator_mat->set_flag(SpatialMaterial::FLAG_SRGB_VERTEX_COLOR, true);
indicator_mat->set_flag(SpatialMaterial::FLAG_ALBEDO_FROM_VERTEX_COLOR, true);
indicator_mat->set_flag(Material3D::FLAG_UNSHADED, true);
indicator_mat->set_feature(Material3D::FEATURE_TRANSPARENT, true);
indicator_mat->set_flag(Material3D::FLAG_SRGB_VERTEX_COLOR, true);
indicator_mat->set_flag(Material3D::FLAG_ALBEDO_FROM_VERTEX_COLOR, true);
indicator_mat->set_albedo(Color(0.8, 0.5, 0.1));
}

8
modules/gridmap/grid_map_editor_plugin.h
View File

@@ -124,10 +124,10 @@ class GridMapEditor : public VBoxContainer {
List<ClipboardItem> clipboard_items;
Ref<SpatialMaterial> indicator_mat;
Ref<SpatialMaterial> inner_mat;
Ref<SpatialMaterial> outer_mat;
Ref<SpatialMaterial> selection_floor_mat;
Ref<Material3D> indicator_mat;
Ref<Material3D> inner_mat;
Ref<Material3D> outer_mat;
Ref<Material3D> selection_floor_mat;
bool updating;