mirror of
https://github.com/godotengine/godot.git
synced 2024-11-11 06:33:10 +00:00
Merge pull request #60803 from Chaosus/shader_hint_rename
Rename `hint_albedo`, `hint_white/black` in shaders
This commit is contained in:
Rémi Verschelde
GitHub
commit
1314e6cbcc
@ -27,7 +27,7 @@
|
||||
No hints are added to the uniform declaration.
|
||||
</constant>
|
||||
<constant name="TYPE_COLOR" value="1" enum="TextureType">
|
||||
Adds [code]hint_albedo[/code] as hint to the uniform declaration for proper sRGB to linear conversion.
|
||||
Adds [code]source_color[/code] as hint to the uniform declaration for proper sRGB to linear conversion.
|
||||
</constant>
|
||||
<constant name="TYPE_NORMAL_MAP" value="2" enum="TextureType">
|
||||
Adds [code]hint_normal[/code] as hint to the uniform declaration, which internally converts the texture for proper usage as normal map.
|
||||
|
||||
@ -981,7 +981,7 @@ void MaterialData::update_uniform_buffer(const HashMap<StringName, ShaderLanguag
|
||||
//value=E.value.default_value;
|
||||
} else {
|
||||
//zero because it was not provided
|
||||
if ((E.value.type == ShaderLanguage::TYPE_VEC3 || E.value.type == ShaderLanguage::TYPE_VEC4) && E.value.hint == ShaderLanguage::ShaderNode::Uniform::HINT_COLOR) {
|
||||
if ((E.value.type == ShaderLanguage::TYPE_VEC3 || E.value.type == ShaderLanguage::TYPE_VEC4) && E.value.hint == ShaderLanguage::ShaderNode::Uniform::HINT_SOURCE_COLOR) {
|
||||
//colors must be set as black, with alpha as 1.0
|
||||
_fill_std140_variant_ubo_value(E.value.type, E.value.array_size, Color(0, 0, 0, 1), data);
|
||||
} else {
|
||||
@ -1117,8 +1117,7 @@ void MaterialData::update_textures(const HashMap<StringName, Variant> &p_paramet
|
||||
case ShaderLanguage::TYPE_USAMPLER2D:
|
||||
case ShaderLanguage::TYPE_SAMPLER2D: {
|
||||
switch (p_texture_uniforms[i].hint) {
|
||||
case ShaderLanguage::ShaderNode::Uniform::HINT_BLACK:
|
||||
case ShaderLanguage::ShaderNode::Uniform::HINT_BLACK_ALBEDO: {
|
||||
case ShaderLanguage::ShaderNode::Uniform::HINT_DEFAULT_BLACK: {
|
||||
gl_texture = texture_storage->texture_gl_get_default(DEFAULT_GL_TEXTURE_BLACK);
|
||||
} break;
|
||||
case ShaderLanguage::ShaderNode::Uniform::HINT_ANISOTROPY: {
|
||||
@ -1138,8 +1137,7 @@ void MaterialData::update_textures(const HashMap<StringName, Variant> &p_paramet
|
||||
|
||||
case ShaderLanguage::TYPE_SAMPLERCUBE: {
|
||||
switch (p_texture_uniforms[i].hint) {
|
||||
case ShaderLanguage::ShaderNode::Uniform::HINT_BLACK:
|
||||
case ShaderLanguage::ShaderNode::Uniform::HINT_BLACK_ALBEDO: {
|
||||
case ShaderLanguage::ShaderNode::Uniform::HINT_DEFAULT_BLACK: {
|
||||
gl_texture = texture_storage->texture_gl_get_default(DEFAULT_GL_TEXTURE_CUBEMAP_BLACK);
|
||||
} break;
|
||||
default: {
|
||||
@ -1155,8 +1153,7 @@ void MaterialData::update_textures(const HashMap<StringName, Variant> &p_paramet
|
||||
case ShaderLanguage::TYPE_USAMPLER3D:
|
||||
case ShaderLanguage::TYPE_SAMPLER3D: {
|
||||
switch (p_texture_uniforms[i].hint) {
|
||||
case ShaderLanguage::ShaderNode::Uniform::HINT_BLACK:
|
||||
case ShaderLanguage::ShaderNode::Uniform::HINT_BLACK_ALBEDO: {
|
||||
case ShaderLanguage::ShaderNode::Uniform::HINT_DEFAULT_BLACK: {
|
||||
gl_texture = texture_storage->texture_gl_get_default(DEFAULT_GL_TEXTURE_3D_BLACK);
|
||||
} break;
|
||||
default: {
|
||||
@ -1187,7 +1184,7 @@ void MaterialData::update_textures(const HashMap<StringName, Variant> &p_paramet
|
||||
p_textures[k++] = gl_texture;
|
||||
}
|
||||
} else {
|
||||
//bool srgb = p_use_linear_color && (p_texture_uniforms[i].hint == ShaderLanguage::ShaderNode::Uniform::HINT_ALBEDO || p_texture_uniforms[i].hint == ShaderLanguage::ShaderNode::Uniform::HINT_BLACK_ALBEDO);
|
||||
//bool srgb = p_use_linear_color && p_texture_uniforms[i].hint == ShaderLanguage::ShaderNode::Uniform::HINT_SOURCE_COLOR;
|
||||
|
||||
for (int j = 0; j < textures.size(); j++) {
|
||||
Texture *tex = TextureStorage::get_singleton()->get_texture(textures[j]);
|
||||
|
||||
@ -821,7 +821,7 @@ Skeleton3DEditor::Skeleton3DEditor(EditorInspectorPluginSkeleton *e_plugin, Skel
|
||||
|
||||
shader_type spatial;
|
||||
render_mode unshaded, shadows_disabled, depth_draw_always;
|
||||
uniform sampler2D texture_albedo : hint_albedo;
|
||||
uniform sampler2D texture_albedo : source_color;
|
||||
uniform float point_size : hint_range(0,128) = 32;
|
||||
void vertex() {
|
||||
if (!OUTPUT_IS_SRGB) {
|
||||
|
||||
@ -148,11 +148,11 @@ void FogMaterial::_update_shader() {
|
||||
shader_type fog;
|
||||
|
||||
uniform float density : hint_range(0, 1, 0.0001) = 1.0;
|
||||
uniform vec4 albedo : hint_color = vec4(1.0);
|
||||
uniform vec4 emission : hint_color = vec4(0, 0, 0, 1);
|
||||
uniform vec4 albedo : source_color = vec4(1.0);
|
||||
uniform vec4 emission : source_color = vec4(0, 0, 0, 1);
|
||||
uniform float height_falloff = 0.0;
|
||||
uniform float edge_fade = 0.1;
|
||||
uniform sampler3D density_texture: hint_white;
|
||||
uniform sampler3D density_texture: hint_default_white;
|
||||
|
||||
|
||||
void fog() {
|
||||
|
||||
@ -631,8 +631,8 @@ void BaseMaterial3D::_update_shader() {
|
||||
|
||||
code += ";\n";
|
||||
|
||||
code += "uniform vec4 albedo : hint_color;\n";
|
||||
code += "uniform sampler2D texture_albedo : hint_albedo," + texfilter_str + ";\n";
|
||||
code += "uniform vec4 albedo : source_color;\n";
|
||||
code += "uniform sampler2D texture_albedo : source_color," + texfilter_str + ";\n";
|
||||
if (grow_enabled) {
|
||||
code += "uniform float grow;\n";
|
||||
}
|
||||
@ -669,7 +669,7 @@ void BaseMaterial3D::_update_shader() {
|
||||
//TODO ALL HINTS
|
||||
if (!orm) {
|
||||
code += "uniform float roughness : hint_range(0,1);\n";
|
||||
code += "uniform sampler2D texture_metallic : hint_white," + texfilter_str + ";\n";
|
||||
code += "uniform sampler2D texture_metallic : hint_default_white," + texfilter_str + ";\n";
|
||||
code += "uniform vec4 metallic_texture_channel;\n";
|
||||
switch (roughness_texture_channel) {
|
||||
case TEXTURE_CHANNEL_RED: {
|
||||
@ -704,8 +704,8 @@ void BaseMaterial3D::_update_shader() {
|
||||
}
|
||||
|
||||
if (features[FEATURE_EMISSION]) {
|
||||
code += "uniform sampler2D texture_emission : hint_black_albedo," + texfilter_str + ";\n";
|
||||
code += "uniform vec4 emission : hint_color;\n";
|
||||
code += "uniform sampler2D texture_emission : source_color, hint_default_black," + texfilter_str + ";\n";
|
||||
code += "uniform vec4 emission : source_color;\n";
|
||||
code += "uniform float emission_energy;\n";
|
||||
}
|
||||
|
||||
@ -722,48 +722,48 @@ void BaseMaterial3D::_update_shader() {
|
||||
if (features[FEATURE_RIM]) {
|
||||
code += "uniform float rim : hint_range(0,1);\n";
|
||||
code += "uniform float rim_tint : hint_range(0,1);\n";
|
||||
code += "uniform sampler2D texture_rim : hint_white," + texfilter_str + ";\n";
|
||||
code += "uniform sampler2D texture_rim : hint_default_white," + texfilter_str + ";\n";
|
||||
}
|
||||
if (features[FEATURE_CLEARCOAT]) {
|
||||
code += "uniform float clearcoat : hint_range(0,1);\n";
|
||||
code += "uniform float clearcoat_roughness : hint_range(0,1);\n";
|
||||
code += "uniform sampler2D texture_clearcoat : hint_white," + texfilter_str + ";\n";
|
||||
code += "uniform sampler2D texture_clearcoat : hint_default_white," + texfilter_str + ";\n";
|
||||
}
|
||||
if (features[FEATURE_ANISOTROPY]) {
|
||||
code += "uniform float anisotropy_ratio : hint_range(0,256);\n";
|
||||
code += "uniform sampler2D texture_flowmap : hint_anisotropy," + texfilter_str + ";\n";
|
||||
}
|
||||
if (features[FEATURE_AMBIENT_OCCLUSION]) {
|
||||
code += "uniform sampler2D texture_ambient_occlusion : hint_white, " + texfilter_str + ";\n";
|
||||
code += "uniform sampler2D texture_ambient_occlusion : hint_default_white, " + texfilter_str + ";\n";
|
||||
code += "uniform vec4 ao_texture_channel;\n";
|
||||
code += "uniform float ao_light_affect;\n";
|
||||
}
|
||||
|
||||
if (features[FEATURE_DETAIL]) {
|
||||
code += "uniform sampler2D texture_detail_albedo : hint_albedo," + texfilter_str + ";\n";
|
||||
code += "uniform sampler2D texture_detail_albedo : source_color," + texfilter_str + ";\n";
|
||||
code += "uniform sampler2D texture_detail_normal : hint_normal," + texfilter_str + ";\n";
|
||||
code += "uniform sampler2D texture_detail_mask : hint_white," + texfilter_str + ";\n";
|
||||
code += "uniform sampler2D texture_detail_mask : hint_default_white," + texfilter_str + ";\n";
|
||||
}
|
||||
|
||||
if (features[FEATURE_SUBSURFACE_SCATTERING]) {
|
||||
code += "uniform float subsurface_scattering_strength : hint_range(0,1);\n";
|
||||
code += "uniform sampler2D texture_subsurface_scattering : hint_white," + texfilter_str + ";\n";
|
||||
code += "uniform sampler2D texture_subsurface_scattering : hint_default_white," + texfilter_str + ";\n";
|
||||
}
|
||||
|
||||
if (features[FEATURE_SUBSURFACE_TRANSMITTANCE]) {
|
||||
code += "uniform vec4 transmittance_color : hint_color;\n";
|
||||
code += "uniform vec4 transmittance_color : source_color;\n";
|
||||
code += "uniform float transmittance_depth;\n";
|
||||
code += "uniform sampler2D texture_subsurface_transmittance : hint_white," + texfilter_str + ";\n";
|
||||
code += "uniform sampler2D texture_subsurface_transmittance : hint_default_white," + texfilter_str + ";\n";
|
||||
code += "uniform float transmittance_boost;\n";
|
||||
}
|
||||
|
||||
if (features[FEATURE_BACKLIGHT]) {
|
||||
code += "uniform vec4 backlight : hint_color;\n";
|
||||
code += "uniform sampler2D texture_backlight : hint_black," + texfilter_str + ";\n";
|
||||
code += "uniform vec4 backlight : source_color;\n";
|
||||
code += "uniform sampler2D texture_backlight : hint_default_black," + texfilter_str + ";\n";
|
||||
}
|
||||
|
||||
if (features[FEATURE_HEIGHT_MAPPING]) {
|
||||
code += "uniform sampler2D texture_heightmap : hint_black," + texfilter_str + ";\n";
|
||||
code += "uniform sampler2D texture_heightmap : hint_default_black," + texfilter_str + ";\n";
|
||||
code += "uniform float heightmap_scale;\n";
|
||||
code += "uniform int heightmap_min_layers;\n";
|
||||
code += "uniform int heightmap_max_layers;\n";
|
||||
|
||||
@ -197,14 +197,14 @@ void ParticlesMaterial::_update_shader() {
|
||||
code += "uniform vec3 emission_box_extents;\n";
|
||||
} break;
|
||||
case EMISSION_SHAPE_DIRECTED_POINTS: {
|
||||
code += "uniform sampler2D emission_texture_normal : hint_black;\n";
|
||||
code += "uniform sampler2D emission_texture_normal : hint_default_black;\n";
|
||||
[[fallthrough]];
|
||||
}
|
||||
case EMISSION_SHAPE_POINTS: {
|
||||
code += "uniform sampler2D emission_texture_points : hint_black;\n";
|
||||
code += "uniform sampler2D emission_texture_points : hint_default_black;\n";
|
||||
code += "uniform int emission_texture_point_count;\n";
|
||||
if (emission_color_texture.is_valid()) {
|
||||
code += "uniform sampler2D emission_texture_color : hint_white;\n";
|
||||
code += "uniform sampler2D emission_texture_color : hint_default_white;\n";
|
||||
}
|
||||
} break;
|
||||
case EMISSION_SHAPE_RING: {
|
||||
@ -228,7 +228,7 @@ void ParticlesMaterial::_update_shader() {
|
||||
code += "uniform bool sub_emitter_keep_velocity;\n";
|
||||
}
|
||||
|
||||
code += "uniform vec4 color_value : hint_color;\n";
|
||||
code += "uniform vec4 color_value : source_color;\n";
|
||||
|
||||
code += "uniform vec3 gravity;\n";
|
||||
|
||||
|
||||
@ -250,14 +250,14 @@ void ProceduralSkyMaterial::_update_shader() {
|
||||
|
||||
shader_type sky;
|
||||
|
||||
uniform vec4 sky_top_color : hint_color = vec4(0.385, 0.454, 0.55, 1.0);
|
||||
uniform vec4 sky_horizon_color : hint_color = vec4(0.646, 0.656, 0.67, 1.0);
|
||||
uniform vec4 sky_top_color : source_color = vec4(0.385, 0.454, 0.55, 1.0);
|
||||
uniform vec4 sky_horizon_color : source_color = vec4(0.646, 0.656, 0.67, 1.0);
|
||||
uniform float sky_curve : hint_range(0, 1) = 0.15;
|
||||
uniform float sky_energy = 1.0;
|
||||
uniform sampler2D sky_cover : hint_black_albedo;
|
||||
uniform vec4 sky_cover_modulate : hint_color = vec4(1.0, 1.0, 1.0, 1.0);
|
||||
uniform vec4 ground_bottom_color : hint_color = vec4(0.2, 0.169, 0.133, 1.0);
|
||||
uniform vec4 ground_horizon_color : hint_color = vec4(0.646, 0.656, 0.67, 1.0);
|
||||
uniform sampler2D sky_cover : source_color, hint_default_black;
|
||||
uniform vec4 sky_cover_modulate : source_color = vec4(1.0, 1.0, 1.0, 1.0);
|
||||
uniform vec4 ground_bottom_color : source_color = vec4(0.2, 0.169, 0.133, 1.0);
|
||||
uniform vec4 ground_horizon_color : source_color = vec4(0.646, 0.656, 0.67, 1.0);
|
||||
uniform float ground_curve : hint_range(0, 1) = 0.02;
|
||||
uniform float ground_energy = 1.0;
|
||||
uniform float sun_angle_max = 30.0;
|
||||
@ -434,7 +434,7 @@ void PanoramaSkyMaterial::_update_shader() {
|
||||
|
||||
shader_type sky;
|
||||
|
||||
uniform sampler2D source_panorama : %s, hint_black_albedo;
|
||||
uniform sampler2D source_panorama : %s, source_color, hint_default_black;
|
||||
|
||||
void sky() {
|
||||
COLOR = texture(source_panorama, SKY_COORDS).rgb;
|
||||
@ -646,18 +646,18 @@ void PhysicalSkyMaterial::_update_shader() {
|
||||
shader_type sky;
|
||||
|
||||
uniform float rayleigh : hint_range(0, 64) = 2.0;
|
||||
uniform vec4 rayleigh_color : hint_color = vec4(0.3, 0.405, 0.6, 1.0);
|
||||
uniform vec4 rayleigh_color : source_color = vec4(0.3, 0.405, 0.6, 1.0);
|
||||
uniform float mie : hint_range(0, 1) = 0.005;
|
||||
uniform float mie_eccentricity : hint_range(-1, 1) = 0.8;
|
||||
uniform vec4 mie_color : hint_color = vec4(0.69, 0.729, 0.812, 1.0);
|
||||
uniform vec4 mie_color : source_color = vec4(0.69, 0.729, 0.812, 1.0);
|
||||
|
||||
uniform float turbidity : hint_range(0, 1000) = 10.0;
|
||||
uniform float sun_disk_scale : hint_range(0, 360) = 1.0;
|
||||
uniform vec4 ground_color : hint_color = vec4(0.1, 0.07, 0.034, 1.0);
|
||||
uniform vec4 ground_color : source_color = vec4(0.1, 0.07, 0.034, 1.0);
|
||||
uniform float exposure : hint_range(0, 128) = 0.1;
|
||||
uniform float dither_strength : hint_range(0, 10) = 1.0;
|
||||
|
||||
uniform sampler2D night_sky : hint_black_albedo;
|
||||
uniform sampler2D night_sky : source_color, hint_default_black;
|
||||
|
||||
const vec3 UP = vec3( 0.0, 1.0, 0.0 );
|
||||
|
||||
|
||||
@ -700,7 +700,7 @@ String VisualShaderNodeTexture::generate_global(Shader::Mode p_mode, VisualShade
|
||||
case TYPE_DATA:
|
||||
break;
|
||||
case TYPE_COLOR:
|
||||
u += " : hint_albedo";
|
||||
u += " : source_color";
|
||||
break;
|
||||
case TYPE_NORMAL_MAP:
|
||||
u += " : hint_normal";
|
||||
@ -1463,7 +1463,7 @@ String VisualShaderNodeCubemap::generate_global(Shader::Mode p_mode, VisualShade
|
||||
case TYPE_DATA:
|
||||
break;
|
||||
case TYPE_COLOR:
|
||||
u += " : hint_albedo";
|
||||
u += " : source_color";
|
||||
break;
|
||||
case TYPE_NORMAL_MAP:
|
||||
u += " : hint_normal";
|
||||
@ -5113,7 +5113,7 @@ Color VisualShaderNodeColorUniform::get_default_value() const {
|
||||
}
|
||||
|
||||
String VisualShaderNodeColorUniform::generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const {
|
||||
String code = _get_qual_str() + "uniform vec4 " + get_uniform_name() + " : hint_color";
|
||||
String code = _get_qual_str() + "uniform vec4 " + get_uniform_name() + " : source_color";
|
||||
if (default_value_enabled) {
|
||||
code += vformat(" = vec4(%.6f, %.6f, %.6f, %.6f)", default_value.r, default_value.g, default_value.b, default_value.a);
|
||||
}
|
||||
@ -5567,6 +5567,110 @@ Vector<StringName> VisualShaderNodeTransformUniform::get_editable_properties() c
|
||||
VisualShaderNodeTransformUniform::VisualShaderNodeTransformUniform() {
|
||||
}
|
||||
|
||||
//////////////
|
||||
|
||||
String get_sampler_hint(VisualShaderNodeTextureUniform::TextureType p_texture_type, VisualShaderNodeTextureUniform::ColorDefault p_color_default, VisualShaderNodeTextureUniform::TextureFilter p_texture_filter, VisualShaderNodeTextureUniform::TextureRepeat p_texture_repeat) {
|
||||
String code;
|
||||
bool has_colon = false;
|
||||
|
||||
// type
|
||||
{
|
||||
String type_code;
|
||||
|
||||
switch (p_texture_type) {
|
||||
case VisualShaderNodeTextureUniform::TYPE_DATA:
|
||||
if (p_color_default == VisualShaderNodeTextureUniform::COLOR_DEFAULT_BLACK) {
|
||||
type_code = "hint_default_black";
|
||||
}
|
||||
break;
|
||||
case VisualShaderNodeTextureUniform::TYPE_COLOR:
|
||||
type_code = "source_color";
|
||||
if (p_color_default == VisualShaderNodeTextureUniform::COLOR_DEFAULT_BLACK) {
|
||||
type_code += ", hint_default_black";
|
||||
}
|
||||
break;
|
||||
case VisualShaderNodeTextureUniform::TYPE_NORMAL_MAP:
|
||||
type_code = "hint_normal";
|
||||
break;
|
||||
case VisualShaderNodeTextureUniform::TYPE_ANISOTROPY:
|
||||
type_code = "hint_anisotropy";
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
if (!type_code.is_empty()) {
|
||||
code += " : " + type_code;
|
||||
has_colon = true;
|
||||
}
|
||||
}
|
||||
|
||||
// filter
|
||||
{
|
||||
String filter_code;
|
||||
|
||||
switch (p_texture_filter) {
|
||||
case VisualShaderNodeTextureUniform::FILTER_NEAREST:
|
||||
filter_code = "filter_nearest";
|
||||
break;
|
||||
case VisualShaderNodeTextureUniform::FILTER_LINEAR:
|
||||
filter_code = "filter_linear";
|
||||
break;
|
||||
case VisualShaderNodeTextureUniform::FILTER_NEAREST_MIPMAP:
|
||||
filter_code = "filter_nearest_mipmap";
|
||||
break;
|
||||
case VisualShaderNodeTextureUniform::FILTER_LINEAR_MIPMAP:
|
||||
filter_code = "filter_linear_mipmap";
|
||||
break;
|
||||
case VisualShaderNodeTextureUniform::FILTER_NEAREST_MIPMAP_ANISOTROPIC:
|
||||
filter_code = "filter_nearest_mipmap_anisotropic";
|
||||
break;
|
||||
case VisualShaderNodeTextureUniform::FILTER_LINEAR_MIPMAP_ANISOTROPIC:
|
||||
filter_code = "filter_linear_mipmap_anisotropic";
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
if (!filter_code.is_empty()) {
|
||||
if (!has_colon) {
|
||||
code += " : ";
|
||||
has_colon = true;
|
||||
} else {
|
||||
code += ", ";
|
||||
}
|
||||
code += filter_code;
|
||||
}
|
||||
}
|
||||
|
||||
// repeat
|
||||
{
|
||||
String repeat_code;
|
||||
|
||||
switch (p_texture_repeat) {
|
||||
case VisualShaderNodeTextureUniform::REPEAT_ENABLED:
|
||||
repeat_code = "repeat_enable";
|
||||
break;
|
||||
case VisualShaderNodeTextureUniform::REPEAT_DISABLED:
|
||||
repeat_code = "repeat_disable";
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
if (!repeat_code.is_empty()) {
|
||||
if (!has_colon) {
|
||||
code += " : ";
|
||||
} else {
|
||||
code += ", ";
|
||||
}
|
||||
code += repeat_code;
|
||||
}
|
||||
}
|
||||
|
||||
return code;
|
||||
}
|
||||
|
||||
////////////// Texture Uniform
|
||||
|
||||
String VisualShaderNodeTextureUniform::get_caption() const {
|
||||
@ -5608,105 +5712,8 @@ String VisualShaderNodeTextureUniform::get_output_port_name(int p_port) const {
|
||||
}
|
||||
|
||||
String VisualShaderNodeTextureUniform::generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const {
|
||||
bool has_colon = false;
|
||||
String code = _get_qual_str() + "uniform sampler2D " + get_uniform_name();
|
||||
|
||||
// type
|
||||
{
|
||||
String type_code;
|
||||
|
||||
switch (texture_type) {
|
||||
case TYPE_DATA:
|
||||
if (color_default == COLOR_DEFAULT_BLACK) {
|
||||
type_code = "hint_black";
|
||||
}
|
||||
break;
|
||||
case TYPE_COLOR:
|
||||
if (color_default == COLOR_DEFAULT_BLACK) {
|
||||
type_code = "hint_black_albedo";
|
||||
} else {
|
||||
type_code = "hint_albedo";
|
||||
}
|
||||
break;
|
||||
case TYPE_NORMAL_MAP:
|
||||
type_code = "hint_normal";
|
||||
break;
|
||||
case TYPE_ANISOTROPY:
|
||||
type_code = "hint_anisotropy";
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
if (!type_code.is_empty()) {
|
||||
code += " : " + type_code;
|
||||
has_colon = true;
|
||||
}
|
||||
}
|
||||
|
||||
// filter
|
||||
{
|
||||
String filter_code;
|
||||
|
||||
switch (texture_filter) {
|
||||
case FILTER_NEAREST:
|
||||
filter_code = "filter_nearest";
|
||||
break;
|
||||
case FILTER_LINEAR:
|
||||
filter_code = "filter_linear";
|
||||
break;
|
||||
case FILTER_NEAREST_MIPMAP:
|
||||
filter_code = "filter_nearest_mipmap";
|
||||
break;
|
||||
case FILTER_LINEAR_MIPMAP:
|
||||
filter_code = "filter_linear_mipmap";
|
||||
break;
|
||||
case FILTER_NEAREST_MIPMAP_ANISOTROPIC:
|
||||
filter_code = "filter_nearest_mipmap_anisotropic";
|
||||
break;
|
||||
case FILTER_LINEAR_MIPMAP_ANISOTROPIC:
|
||||
filter_code = "filter_linear_mipmap_anisotropic";
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
if (!filter_code.is_empty()) {
|
||||
if (!has_colon) {
|
||||
code += " : ";
|
||||
has_colon = true;
|
||||
} else {
|
||||
code += ", ";
|
||||
}
|
||||
code += filter_code;
|
||||
}
|
||||
}
|
||||
|
||||
// repeat
|
||||
{
|
||||
String repeat_code;
|
||||
|
||||
switch (texture_repeat) {
|
||||
case REPEAT_ENABLED:
|
||||
repeat_code = "repeat_enable";
|
||||
break;
|
||||
case REPEAT_DISABLED:
|
||||
repeat_code = "repeat_disable";
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
if (!repeat_code.is_empty()) {
|
||||
if (!has_colon) {
|
||||
code += " : ";
|
||||
} else {
|
||||
code += ", ";
|
||||
}
|
||||
code += repeat_code;
|
||||
}
|
||||
}
|
||||
|
||||
code += get_sampler_hint(texture_type, color_default, texture_filter, texture_repeat);
|
||||
code += ";\n";
|
||||
return code;
|
||||
}
|
||||
@ -5986,33 +5993,8 @@ String VisualShaderNodeTexture2DArrayUniform::get_output_port_name(int p_port) c
|
||||
|
||||
String VisualShaderNodeTexture2DArrayUniform::generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const {
|
||||
String code = _get_qual_str() + "uniform sampler2DArray " + get_uniform_name();
|
||||
|
||||
switch (texture_type) {
|
||||
case TYPE_DATA:
|
||||
if (color_default == COLOR_DEFAULT_BLACK) {
|
||||
code += " : hint_black;\n";
|
||||
} else {
|
||||
code += ";\n";
|
||||
}
|
||||
break;
|
||||
case TYPE_COLOR:
|
||||
if (color_default == COLOR_DEFAULT_BLACK) {
|
||||
code += " : hint_black_albedo;\n";
|
||||
} else {
|
||||
code += " : hint_albedo;\n";
|
||||
}
|
||||
break;
|
||||
case TYPE_NORMAL_MAP:
|
||||
code += " : hint_normal;\n";
|
||||
break;
|
||||
case TYPE_ANISOTROPY:
|
||||
code += " : hint_anisotropy;\n";
|
||||
break;
|
||||
default:
|
||||
code += ";\n";
|
||||
break;
|
||||
}
|
||||
|
||||
code += get_sampler_hint(texture_type, color_default, texture_filter, texture_repeat);
|
||||
code += ";\n";
|
||||
return code;
|
||||
}
|
||||
|
||||
@ -6035,33 +6017,8 @@ String VisualShaderNodeTexture3DUniform::get_output_port_name(int p_port) const
|
||||
|
||||
String VisualShaderNodeTexture3DUniform::generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const {
|
||||
String code = _get_qual_str() + "uniform sampler3D " + get_uniform_name();
|
||||
|
||||
switch (texture_type) {
|
||||
case TYPE_DATA:
|
||||
if (color_default == COLOR_DEFAULT_BLACK) {
|
||||
code += " : hint_black;\n";
|
||||
} else {
|
||||
code += ";\n";
|
||||
}
|
||||
break;
|
||||
case TYPE_COLOR:
|
||||
if (color_default == COLOR_DEFAULT_BLACK) {
|
||||
code += " : hint_black_albedo;\n";
|
||||
} else {
|
||||
code += " : hint_albedo;\n";
|
||||
}
|
||||
break;
|
||||
case TYPE_NORMAL_MAP:
|
||||
code += " : hint_normal;\n";
|
||||
break;
|
||||
case TYPE_ANISOTROPY:
|
||||
code += " : hint_anisotropy;\n";
|
||||
break;
|
||||
default:
|
||||
code += ";\n";
|
||||
break;
|
||||
}
|
||||
|
||||
code += get_sampler_hint(texture_type, color_default, texture_filter, texture_repeat);
|
||||
code += ";\n";
|
||||
return code;
|
||||
}
|
||||
|
||||
@ -6084,33 +6041,8 @@ String VisualShaderNodeCubemapUniform::get_output_port_name(int p_port) const {
|
||||
|
||||
String VisualShaderNodeCubemapUniform::generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const {
|
||||
String code = _get_qual_str() + "uniform samplerCube " + get_uniform_name();
|
||||
|
||||
switch (texture_type) {
|
||||
case TYPE_DATA:
|
||||
if (color_default == COLOR_DEFAULT_BLACK) {
|
||||
code += " : hint_black;\n";
|
||||
} else {
|
||||
code += ";\n";
|
||||
}
|
||||
break;
|
||||
case TYPE_COLOR:
|
||||
if (color_default == COLOR_DEFAULT_BLACK) {
|
||||
code += " : hint_black_albedo;\n";
|
||||
} else {
|
||||
code += " : hint_albedo;\n";
|
||||
}
|
||||
break;
|
||||
case TYPE_NORMAL_MAP:
|
||||
code += " : hint_normal;\n";
|
||||
break;
|
||||
case TYPE_ANISOTROPY:
|
||||
code += " : hint_anisotropy;\n";
|
||||
break;
|
||||
default:
|
||||
code += ";\n";
|
||||
break;
|
||||
}
|
||||
|
||||
code += get_sampler_hint(texture_type, color_default, texture_filter, texture_repeat);
|
||||
code += ";\n";
|
||||
return code;
|
||||
}
|
||||
|
||||
|
||||
@ -955,7 +955,7 @@ void MaterialData::update_uniform_buffer(const HashMap<StringName, ShaderLanguag
|
||||
//value=E.value.default_value;
|
||||
} else {
|
||||
//zero because it was not provided
|
||||
if ((E.value.type == ShaderLanguage::TYPE_VEC3 || E.value.type == ShaderLanguage::TYPE_VEC4) && E.value.hint == ShaderLanguage::ShaderNode::Uniform::HINT_COLOR) {
|
||||
if ((E.value.type == ShaderLanguage::TYPE_VEC3 || E.value.type == ShaderLanguage::TYPE_VEC4) && E.value.hint == ShaderLanguage::ShaderNode::Uniform::HINT_SOURCE_COLOR) {
|
||||
//colors must be set as black, with alpha as 1.0
|
||||
_fill_std140_variant_ubo_value(E.value.type, E.value.array_size, Color(0, 0, 0, 1), data, p_use_linear_color);
|
||||
} else {
|
||||
@ -1090,8 +1090,7 @@ void MaterialData::update_textures(const HashMap<StringName, Variant> &p_paramet
|
||||
case ShaderLanguage::TYPE_USAMPLER2D:
|
||||
case ShaderLanguage::TYPE_SAMPLER2D: {
|
||||
switch (p_texture_uniforms[i].hint) {
|
||||
case ShaderLanguage::ShaderNode::Uniform::HINT_BLACK:
|
||||
case ShaderLanguage::ShaderNode::Uniform::HINT_BLACK_ALBEDO: {
|
||||
case ShaderLanguage::ShaderNode::Uniform::HINT_DEFAULT_BLACK: {
|
||||
rd_texture = texture_storage->texture_rd_get_default(DEFAULT_RD_TEXTURE_BLACK);
|
||||
} break;
|
||||
case ShaderLanguage::ShaderNode::Uniform::HINT_ANISOTROPY: {
|
||||
@ -1111,8 +1110,7 @@ void MaterialData::update_textures(const HashMap<StringName, Variant> &p_paramet
|
||||
|
||||
case ShaderLanguage::TYPE_SAMPLERCUBE: {
|
||||
switch (p_texture_uniforms[i].hint) {
|
||||
case ShaderLanguage::ShaderNode::Uniform::HINT_BLACK:
|
||||
case ShaderLanguage::ShaderNode::Uniform::HINT_BLACK_ALBEDO: {
|
||||
case ShaderLanguage::ShaderNode::Uniform::HINT_DEFAULT_BLACK: {
|
||||
rd_texture = texture_storage->texture_rd_get_default(DEFAULT_RD_TEXTURE_CUBEMAP_BLACK);
|
||||
} break;
|
||||
default: {
|
||||
@ -1152,7 +1150,7 @@ void MaterialData::update_textures(const HashMap<StringName, Variant> &p_paramet
|
||||
p_textures[k++] = rd_texture;
|
||||
}
|
||||
} else {
|
||||
bool srgb = p_use_linear_color && (p_texture_uniforms[i].hint == ShaderLanguage::ShaderNode::Uniform::HINT_ALBEDO || p_texture_uniforms[i].hint == ShaderLanguage::ShaderNode::Uniform::HINT_BLACK_ALBEDO);
|
||||
bool srgb = p_use_linear_color && p_texture_uniforms[i].hint == ShaderLanguage::ShaderNode::Uniform::HINT_SOURCE_COLOR;
|
||||
|
||||
for (int j = 0; j < textures.size(); j++) {
|
||||
Texture *tex = TextureStorage::get_singleton()->get_texture(textures[j]);
|
||||
|
||||
@ -190,13 +190,11 @@ const char *ShaderLanguage::token_names[TK_MAX] = {
|
||||
"OUT",
|
||||
"INOUT",
|
||||
"RENDER_MODE",
|
||||
"HINT_WHITE_TEXTURE",
|
||||
"HINT_BLACK_TEXTURE",
|
||||
"SOURCE_COLOR",
|
||||
"HINT_DEFAULT_WHITE_TEXTURE",
|
||||
"HINT_DEFAULT_BLACK_TEXTURE",
|
||||
"HINT_NORMAL_TEXTURE",
|
||||
"HINT_ANISOTROPY_TEXTURE",
|
||||
"HINT_ALBEDO_TEXTURE",
|
||||
"HINT_BLACK_ALBEDO_TEXTURE",
|
||||
"HINT_COLOR",
|
||||
"HINT_RANGE",
|
||||
"HINT_INSTANCE_INDEX",
|
||||
"FILTER_NEAREST",
|
||||
@ -344,17 +342,15 @@ const ShaderLanguage::KeyWord ShaderLanguage::keyword_list[] = {
|
||||
|
||||
// hints
|
||||
|
||||
{ TK_HINT_SOURCE_COLOR, "source_color", CF_UNSPECIFIED, {}, {} },
|
||||
{ TK_HINT_RANGE, "hint_range", CF_UNSPECIFIED, {}, {} },
|
||||
{ TK_HINT_COLOR, "hint_color", CF_UNSPECIFIED, {}, {} },
|
||||
{ TK_HINT_INSTANCE_INDEX, "instance_index", CF_UNSPECIFIED, {}, {} },
|
||||
|
||||
// sampler hints
|
||||
|
||||
{ TK_HINT_ALBEDO_TEXTURE, "hint_albedo", CF_UNSPECIFIED, {}, {} },
|
||||
{ TK_HINT_BLACK_ALBEDO_TEXTURE, "hint_black_albedo", CF_UNSPECIFIED, {}, {} },
|
||||
{ TK_HINT_NORMAL_TEXTURE, "hint_normal", CF_UNSPECIFIED, {}, {} },
|
||||
{ TK_HINT_WHITE_TEXTURE, "hint_white", CF_UNSPECIFIED, {}, {} },
|
||||
{ TK_HINT_BLACK_TEXTURE, "hint_black", CF_UNSPECIFIED, {}, {} },
|
||||
{ TK_HINT_DEFAULT_WHITE_TEXTURE, "hint_default_white", CF_UNSPECIFIED, {}, {} },
|
||||
{ TK_HINT_DEFAULT_BLACK_TEXTURE, "hint_default_black", CF_UNSPECIFIED, {}, {} },
|
||||
{ TK_HINT_ANISOTROPY_TEXTURE, "hint_anisotropy", CF_UNSPECIFIED, {}, {} },
|
||||
{ TK_HINT_ROUGHNESS_R, "hint_roughness_r", CF_UNSPECIFIED, {}, {} },
|
||||
{ TK_HINT_ROUGHNESS_G, "hint_roughness_g", CF_UNSPECIFIED, {}, {} },
|
||||
@ -3421,17 +3417,7 @@ bool ShaderLanguage::is_float_type(DataType p_type) {
|
||||
}
|
||||
}
|
||||
bool ShaderLanguage::is_sampler_type(DataType p_type) {
|
||||
return p_type == TYPE_SAMPLER2D ||
|
||||
p_type == TYPE_ISAMPLER2D ||
|
||||
p_type == TYPE_USAMPLER2D ||
|
||||
p_type == TYPE_SAMPLER2DARRAY ||
|
||||
p_type == TYPE_ISAMPLER2DARRAY ||
|
||||
p_type == TYPE_USAMPLER2DARRAY ||
|
||||
p_type == TYPE_SAMPLER3D ||
|
||||
p_type == TYPE_ISAMPLER3D ||
|
||||
p_type == TYPE_USAMPLER3D ||
|
||||
p_type == TYPE_SAMPLERCUBE ||
|
||||
p_type == TYPE_SAMPLERCUBEARRAY;
|
||||
return p_type > TYPE_MAT4 && p_type < TYPE_STRUCT;
|
||||
}
|
||||
|
||||
Variant ShaderLanguage::constant_value_to_variant(const Vector<ShaderLanguage::ConstantNode::Value> &p_value, DataType p_type, int p_array_size, ShaderLanguage::ShaderNode::Uniform::Hint p_hint) {
|
||||
@ -3618,7 +3604,7 @@ Variant ShaderLanguage::constant_value_to_variant(const Vector<ShaderLanguage::C
|
||||
if (array_size > 0) {
|
||||
array_size *= 3;
|
||||
|
||||
if (p_hint == ShaderLanguage::ShaderNode::Uniform::HINT_COLOR) {
|
||||
if (p_hint == ShaderLanguage::ShaderNode::Uniform::HINT_SOURCE_COLOR) {
|
||||
PackedColorArray array = PackedColorArray();
|
||||
for (int i = 0; i < array_size; i += 3) {
|
||||
array.push_back(Color(p_value[i].real, p_value[i + 1].real, p_value[i + 2].real));
|
||||
@ -3632,7 +3618,7 @@ Variant ShaderLanguage::constant_value_to_variant(const Vector<ShaderLanguage::C
|
||||
value = Variant(array);
|
||||
}
|
||||
} else {
|
||||
if (p_hint == ShaderLanguage::ShaderNode::Uniform::HINT_COLOR) {
|
||||
if (p_hint == ShaderLanguage::ShaderNode::Uniform::HINT_SOURCE_COLOR) {
|
||||
value = Variant(Color(p_value[0].real, p_value[1].real, p_value[2].real));
|
||||
} else {
|
||||
value = Variant(Vector3(p_value[0].real, p_value[1].real, p_value[2].real));
|
||||
@ -3643,7 +3629,7 @@ Variant ShaderLanguage::constant_value_to_variant(const Vector<ShaderLanguage::C
|
||||
if (array_size > 0) {
|
||||
array_size *= 4;
|
||||
|
||||
if (p_hint == ShaderLanguage::ShaderNode::Uniform::HINT_COLOR) {
|
||||
if (p_hint == ShaderLanguage::ShaderNode::Uniform::HINT_SOURCE_COLOR) {
|
||||
PackedColorArray array = PackedColorArray();
|
||||
for (int i = 0; i < array_size; i += 4) {
|
||||
array.push_back(Color(p_value[i].real, p_value[i + 1].real, p_value[i + 2].real, p_value[i + 3].real));
|
||||
@ -3660,7 +3646,7 @@ Variant ShaderLanguage::constant_value_to_variant(const Vector<ShaderLanguage::C
|
||||
value = Variant(array);
|
||||
}
|
||||
} else {
|
||||
if (p_hint == ShaderLanguage::ShaderNode::Uniform::HINT_COLOR) {
|
||||
if (p_hint == ShaderLanguage::ShaderNode::Uniform::HINT_SOURCE_COLOR) {
|
||||
value = Variant(Color(p_value[0].real, p_value[1].real, p_value[2].real, p_value[3].real));
|
||||
} else {
|
||||
value = Variant(Quaternion(p_value[0].real, p_value[1].real, p_value[2].real, p_value[3].real));
|
||||
@ -3842,14 +3828,14 @@ PropertyInfo ShaderLanguage::uniform_to_property_info(const ShaderNode::Uniform
|
||||
break;
|
||||
case ShaderLanguage::TYPE_VEC3:
|
||||
if (p_uniform.array_size > 0) {
|
||||
if (p_uniform.hint == ShaderLanguage::ShaderNode::Uniform::HINT_COLOR) {
|
||||
if (p_uniform.hint == ShaderLanguage::ShaderNode::Uniform::HINT_SOURCE_COLOR) {
|
||||
pi.hint = PROPERTY_HINT_COLOR_NO_ALPHA;
|
||||
pi.type = Variant::PACKED_COLOR_ARRAY;
|
||||
} else {
|
||||
pi.type = Variant::PACKED_VECTOR3_ARRAY;
|
||||
}
|
||||
} else {
|
||||
if (p_uniform.hint == ShaderLanguage::ShaderNode::Uniform::HINT_COLOR) {
|
||||
if (p_uniform.hint == ShaderLanguage::ShaderNode::Uniform::HINT_SOURCE_COLOR) {
|
||||
pi.hint = PROPERTY_HINT_COLOR_NO_ALPHA;
|
||||
pi.type = Variant::COLOR;
|
||||
} else {
|
||||
@ -3859,13 +3845,13 @@ PropertyInfo ShaderLanguage::uniform_to_property_info(const ShaderNode::Uniform
|
||||
break;
|
||||
case ShaderLanguage::TYPE_VEC4: {
|
||||
if (p_uniform.array_size > 0) {
|
||||
if (p_uniform.hint == ShaderLanguage::ShaderNode::Uniform::HINT_COLOR) {
|
||||
if (p_uniform.hint == ShaderLanguage::ShaderNode::Uniform::HINT_SOURCE_COLOR) {
|
||||
pi.type = Variant::PACKED_COLOR_ARRAY;
|
||||
} else {
|
||||
pi.type = Variant::PACKED_FLOAT32_ARRAY;
|
||||
}
|
||||
} else {
|
||||
if (p_uniform.hint == ShaderLanguage::ShaderNode::Uniform::HINT_COLOR) {
|
||||
if (p_uniform.hint == ShaderLanguage::ShaderNode::Uniform::HINT_SOURCE_COLOR) {
|
||||
pi.type = Variant::COLOR;
|
||||
} else {
|
||||
pi.type = Variant::QUATERNION;
|
||||
@ -8249,16 +8235,16 @@ Error ShaderLanguage::_parse_shader(const HashMap<StringName, FunctionInfo> &p_f
|
||||
}
|
||||
|
||||
if (uniform2.array_size > 0) {
|
||||
if (tk.type != TK_HINT_COLOR) {
|
||||
if (tk.type != TK_HINT_SOURCE_COLOR) {
|
||||
_set_error(RTR("This hint is not supported for uniform arrays."));
|
||||
return ERR_PARSE_ERROR;
|
||||
}
|
||||
}
|
||||
|
||||
if (tk.type == TK_HINT_WHITE_TEXTURE) {
|
||||
uniform2.hint = ShaderNode::Uniform::HINT_WHITE;
|
||||
} else if (tk.type == TK_HINT_BLACK_TEXTURE) {
|
||||
uniform2.hint = ShaderNode::Uniform::HINT_BLACK;
|
||||
if (tk.type == TK_HINT_DEFAULT_WHITE_TEXTURE) {
|
||||
uniform2.hint = ShaderNode::Uniform::HINT_DEFAULT_WHITE;
|
||||
} else if (tk.type == TK_HINT_DEFAULT_BLACK_TEXTURE) {
|
||||
uniform2.hint = ShaderNode::Uniform::HINT_DEFAULT_BLACK;
|
||||
} else if (tk.type == TK_HINT_NORMAL_TEXTURE) {
|
||||
uniform2.hint = ShaderNode::Uniform::HINT_NORMAL;
|
||||
} else if (tk.type == TK_HINT_ROUGHNESS_NORMAL_TEXTURE) {
|
||||
@ -8275,16 +8261,12 @@ Error ShaderLanguage::_parse_shader(const HashMap<StringName, FunctionInfo> &p_f
|
||||
uniform2.hint = ShaderNode::Uniform::HINT_ROUGHNESS_GRAY;
|
||||
} else if (tk.type == TK_HINT_ANISOTROPY_TEXTURE) {
|
||||
uniform2.hint = ShaderNode::Uniform::HINT_ANISOTROPY;
|
||||
} else if (tk.type == TK_HINT_ALBEDO_TEXTURE) {
|
||||
uniform2.hint = ShaderNode::Uniform::HINT_ALBEDO;
|
||||
} else if (tk.type == TK_HINT_BLACK_ALBEDO_TEXTURE) {
|
||||
uniform2.hint = ShaderNode::Uniform::HINT_BLACK_ALBEDO;
|
||||
} else if (tk.type == TK_HINT_COLOR) {
|
||||
if (type != TYPE_VEC3 && type != TYPE_VEC4) {
|
||||
_set_error(vformat(RTR("Color hint is for '%s' or '%s' only."), "vec3", "vec4"));
|
||||
} else if (tk.type == TK_HINT_SOURCE_COLOR) {
|
||||
if (type != TYPE_VEC3 && type != TYPE_VEC4 && type <= TYPE_MAT4) {
|
||||
_set_error(vformat(RTR("Source color hint is for '%s', '%s' or sampler types only."), "vec3", "vec4"));
|
||||
return ERR_PARSE_ERROR;
|
||||
}
|
||||
uniform2.hint = ShaderNode::Uniform::HINT_COLOR;
|
||||
uniform2.hint = ShaderNode::Uniform::HINT_SOURCE_COLOR;
|
||||
} else if (tk.type == TK_HINT_RANGE) {
|
||||
uniform2.hint = ShaderNode::Uniform::HINT_RANGE;
|
||||
if (type != TYPE_FLOAT && type != TYPE_INT) {
|
||||
@ -8418,7 +8400,12 @@ Error ShaderLanguage::_parse_shader(const HashMap<StringName, FunctionInfo> &p_f
|
||||
uniform2.repeat = REPEAT_ENABLE;
|
||||
}
|
||||
|
||||
if (uniform2.hint != ShaderNode::Uniform::HINT_RANGE && uniform2.hint != ShaderNode::Uniform::HINT_NONE && uniform2.hint != ShaderNode::Uniform::HINT_COLOR && type <= TYPE_MAT4) {
|
||||
if (uniform2.hint == ShaderNode::Uniform::HINT_SOURCE_COLOR) {
|
||||
if (type != TYPE_VEC3 && type != TYPE_VEC4 && !is_sampler_type(type)) {
|
||||
_set_error(vformat(RTR("This hint is only for '%s', '%s' or sampler types."), "vec3", "vec4"));
|
||||
return ERR_PARSE_ERROR;
|
||||
}
|
||||
} else if (uniform2.hint != ShaderNode::Uniform::HINT_RANGE && uniform2.hint != ShaderNode::Uniform::HINT_NONE && !is_sampler_type(type)) {
|
||||
_set_error(RTR("This hint is only for sampler types."));
|
||||
return ERR_PARSE_ERROR;
|
||||
}
|
||||
@ -9922,7 +9909,7 @@ Error ShaderLanguage::complete(const String &p_code, const ShaderCompileInfo &p_
|
||||
} break;
|
||||
case COMPLETION_HINT: {
|
||||
if (completion_base == DataType::TYPE_VEC3 || completion_base == DataType::TYPE_VEC4) {
|
||||
ScriptLanguage::CodeCompletionOption option("hint_color", ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
|
||||
ScriptLanguage::CodeCompletionOption option("source_color", ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
|
||||
r_options->push_back(option);
|
||||
} else if ((completion_base == DataType::TYPE_INT || completion_base == DataType::TYPE_FLOAT) && !completion_base_array) {
|
||||
ScriptLanguage::CodeCompletionOption option("hint_range", ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
|
||||
@ -9944,10 +9931,9 @@ Error ShaderLanguage::complete(const String &p_code, const ShaderCompileInfo &p_
|
||||
options.push_back("filter_nearest");
|
||||
options.push_back("filter_nearest_mipmap");
|
||||
options.push_back("filter_nearest_mipmap_anisotropic");
|
||||
options.push_back("hint_albedo");
|
||||
options.push_back("hint_anisotropy");
|
||||
options.push_back("hint_black");
|
||||
options.push_back("hint_black_albedo");
|
||||
options.push_back("hint_default_black");
|
||||
options.push_back("hint_default_white");
|
||||
options.push_back("hint_normal");
|
||||
options.push_back("hint_roughness_a");
|
||||
options.push_back("hint_roughness_b");
|
||||
@ -9955,7 +9941,7 @@ Error ShaderLanguage::complete(const String &p_code, const ShaderCompileInfo &p_
|
||||
options.push_back("hint_roughness_gray");
|
||||
options.push_back("hint_roughness_normal");
|
||||
options.push_back("hint_roughness_r");
|
||||
options.push_back("hint_white");
|
||||
options.push_back("source_color");
|
||||
options.push_back("repeat_enable");
|
||||
options.push_back("repeat_disable");
|
||||
}
|
||||
|
||||
@ -160,8 +160,8 @@ public:
|
||||
TK_ARG_OUT,
|
||||
TK_ARG_INOUT,
|
||||
TK_RENDER_MODE,
|
||||
TK_HINT_WHITE_TEXTURE,
|
||||
TK_HINT_BLACK_TEXTURE,
|
||||
TK_HINT_DEFAULT_WHITE_TEXTURE,
|
||||
TK_HINT_DEFAULT_BLACK_TEXTURE,
|
||||
TK_HINT_NORMAL_TEXTURE,
|
||||
TK_HINT_ROUGHNESS_NORMAL_TEXTURE,
|
||||
TK_HINT_ROUGHNESS_R,
|
||||
@ -170,9 +170,7 @@ public:
|
||||
TK_HINT_ROUGHNESS_A,
|
||||
TK_HINT_ROUGHNESS_GRAY,
|
||||
TK_HINT_ANISOTROPY_TEXTURE,
|
||||
TK_HINT_ALBEDO_TEXTURE,
|
||||
TK_HINT_BLACK_ALBEDO_TEXTURE,
|
||||
TK_HINT_COLOR,
|
||||
TK_HINT_SOURCE_COLOR,
|
||||
TK_HINT_RANGE,
|
||||
TK_HINT_INSTANCE_INDEX,
|
||||
TK_FILTER_NEAREST,
|
||||
@ -653,10 +651,8 @@ public:
|
||||
struct Uniform {
|
||||
enum Hint {
|
||||
HINT_NONE,
|
||||
HINT_COLOR,
|
||||
HINT_RANGE,
|
||||
HINT_ALBEDO,
|
||||
HINT_BLACK_ALBEDO,
|
||||
HINT_SOURCE_COLOR,
|
||||
HINT_NORMAL,
|
||||
HINT_ROUGHNESS_NORMAL,
|
||||
HINT_ROUGHNESS_R,
|
||||
@ -664,8 +660,8 @@ public:
|
||||
HINT_ROUGHNESS_B,
|
||||
HINT_ROUGHNESS_A,
|
||||
HINT_ROUGHNESS_GRAY,
|
||||
HINT_BLACK,
|
||||
HINT_WHITE,
|
||||
HINT_DEFAULT_BLACK,
|
||||
HINT_DEFAULT_WHITE,
|
||||
HINT_ANISOTROPY,
|
||||
HINT_MAX
|
||||
};
|
||||
|
||||
Loading…
Reference in New Issue
Block a user