mirror of
https://github.com/godotengine/godot.git
synced 2024-11-22 04:06:14 +00:00
Remove SCREEN_TEXTURE, DEPTH_TEXTURE, and NORMAL_ROUGHNESS_TEXTURE
in favour of texture hints
This commit is contained in:
clayjohn
parent
d93b66ad4d
commit
faea9f5c10
@ -227,6 +227,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
|
||||
- More information in the [progress report](https://godotengine.org/article/improvements-shaders-visual-shaders-godot-4).
|
||||
- [Add Billboard mode to visual shaders.](https://github.com/godotengine/godot/pull/49157)
|
||||
- [The constants `PI`, `TAU` and `E` are now available in the shader language.](https://github.com/godotengine/godot/pull/48837)
|
||||
- Uniform hints to control textures (`repeat_enabled`, `repeat_disabled`, `filter_linear`, `filter_nearest`, `hint_screen_texture`, etc.).
|
||||
|
||||
#### Miscellaneous
|
||||
|
||||
@ -401,6 +402,10 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
|
||||
- [Removed support for 16× MSAA due to driver bugs and low performance.](https://github.com/godotengine/godot/pull/49063)
|
||||
- For high-quality offline rendering, using supersampling together with 8× MSAA is a better option anyway.
|
||||
|
||||
#### Shaders
|
||||
|
||||
- Removed `SCREEN_TEXTURE` and `DEPTH_TEXTURE` in favour of uniform hints `hint_screen_texture` and `hint_depth_texture`.
|
||||
|
||||
### Fixed
|
||||
|
||||
#### Core
|
||||
|
||||
@ -1,10 +1,10 @@
|
||||
<?xml version="1.0" encoding="UTF-8" ?>
|
||||
<class name="BackBufferCopy" inherits="Node2D" version="4.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../class.xsd">
|
||||
<brief_description>
|
||||
Copies a region of the screen (or the whole screen) to a buffer so it can be accessed in your shader scripts through the [code]texture(SCREEN_TEXTURE, ...)[/code] function.
|
||||
Copies a region of the screen (or the whole screen) to a buffer so it can be accessed in your shader scripts using the screen texture (i.e. a uniform sampler with ``hint_screen_texture``).
|
||||
</brief_description>
|
||||
<description>
|
||||
Node for back-buffering the currently-displayed screen. The region defined in the [BackBufferCopy] node is buffered with the content of the screen it covers, or the entire screen according to the copy mode set. Use the [code]texture(SCREEN_TEXTURE, ...)[/code] function in your shader scripts to access the buffer.
|
||||
Node for back-buffering the currently-displayed screen. The region defined in the [BackBufferCopy] node is buffered with the content of the screen it covers, or the entire screen according to the copy mode set. Use the screen texture in your shader scripts to access the buffer.
|
||||
[b]Note:[/b] Since this node inherits from [Node2D] (and not [Control]), anchors and margins won't apply to child [Control]-derived nodes. This can be problematic when resizing the window. To avoid this, add [Control]-derived nodes as [i]siblings[/i] to the [BackBufferCopy] node instead of adding them as children.
|
||||
</description>
|
||||
<tutorials>
|
||||
|
||||
@ -9,8 +9,10 @@
|
||||
[codeblock]
|
||||
shader_type canvas_item;
|
||||
|
||||
uniform sampler2D screen_texture : hint_screen_texture, repeat_disable, filter_nearest;
|
||||
|
||||
void fragment() {
|
||||
vec4 c = textureLod(SCREEN_TEXTURE, SCREEN_UV, 0.0);
|
||||
vec4 c = textureLod(screen_texture, SCREEN_UV, 0.0);
|
||||
|
||||
if (c.a > 0.0001) {
|
||||
c.rgb /= c.a;
|
||||
|
||||
@ -3336,7 +3336,7 @@
|
||||
<param index="0" name="viewport" type="RID" />
|
||||
<param index="1" name="enabled" type="bool" />
|
||||
<description>
|
||||
If [code]true[/code], render the contents of the viewport directly to screen. This allows a low-level optimization where you can skip drawing a viewport to the root viewport. While this optimization can result in a significant increase in speed (especially on older devices), it comes at a cost of usability. When this is enabled, you cannot read from the viewport or from the [code]SCREEN_TEXTURE[/code]. You also lose the benefit of certain window settings, such as the various stretch modes. Another consequence to be aware of is that in 2D the rendering happens in window coordinates, so if you have a viewport that is double the size of the window, and you set this, then only the portion that fits within the window will be drawn, no automatic scaling is possible, even if your game scene is significantly larger than the window size.
|
||||
If [code]true[/code], render the contents of the viewport directly to screen. This allows a low-level optimization where you can skip drawing a viewport to the root viewport. While this optimization can result in a significant increase in speed (especially on older devices), it comes at a cost of usability. When this is enabled, you cannot read from the viewport or from the screen_texture. You also lose the benefit of certain window settings, such as the various stretch modes. Another consequence to be aware of is that in 2D the rendering happens in window coordinates, so if you have a viewport that is double the size of the window, and you set this, then only the portion that fits within the window will be drawn, no automatic scaling is possible, even if your game scene is significantly larger than the window size.
|
||||
</description>
|
||||
</method>
|
||||
<method name="viewport_set_scaling_3d_mode">
|
||||
|
||||
@ -33,12 +33,18 @@
|
||||
Use the texture from this shader's normal map built-in.
|
||||
</constant>
|
||||
<constant name="SOURCE_DEPTH" value="4" enum="Source">
|
||||
Use the depth texture available for this shader.
|
||||
Use the depth texture captured during the depth prepass. Only available when the depth prepass is used (i.e. in spatial shaders and in the forward_plus or gl_compatibility renderers).
|
||||
</constant>
|
||||
<constant name="SOURCE_PORT" value="5" enum="Source">
|
||||
Use the texture provided in the input port for this function.
|
||||
</constant>
|
||||
<constant name="SOURCE_MAX" value="6" enum="Source">
|
||||
<constant name="SOURCE_3D_NORMAL" value="6" enum="Source">
|
||||
Use the normal buffer captured during the depth prepass. Only available when the normal-roughness buffer is available (i.e. in spatial shaders and in the forward_plus renderer).
|
||||
</constant>
|
||||
<constant name="SOURCE_ROUGHNESS" value="7" enum="Source">
|
||||
Use the roughness buffer captured during the depth prepass. Only available when the normal-roughness buffer is available (i.e. in spatial shaders and in the forward_plus renderer).
|
||||
</constant>
|
||||
<constant name="SOURCE_MAX" value="8" enum="Source">
|
||||
Represents the size of the [enum Source] enum.
|
||||
</constant>
|
||||
<constant name="TYPE_DATA" value="0" enum="TextureType">
|
||||
|
||||
@ -18,6 +18,9 @@
|
||||
<member name="texture_repeat" type="int" setter="set_texture_repeat" getter="get_texture_repeat" enum="VisualShaderNodeTextureParameter.TextureRepeat" default="0">
|
||||
Sets the texture repeating mode. See [enum TextureRepeat] for options.
|
||||
</member>
|
||||
<member name="texture_source" type="int" setter="set_texture_source" getter="get_texture_source" enum="VisualShaderNodeTextureParameter.TextureSource" default="0">
|
||||
Sets the texture source mode. Used for reading from the screen, depth, or normal_roughness texture. see [enum TextureSource] for options.
|
||||
</member>
|
||||
<member name="texture_type" type="int" setter="set_texture_type" getter="get_texture_type" enum="VisualShaderNodeTextureParameter.TextureType" default="0">
|
||||
Defines the type of data provided by the source texture. See [enum TextureType] for options.
|
||||
</member>
|
||||
@ -88,5 +91,20 @@
|
||||
<constant name="REPEAT_MAX" value="3" enum="TextureRepeat">
|
||||
Represents the size of the [enum TextureRepeat] enum.
|
||||
</constant>
|
||||
<constant name="SOURCE_NONE" value="0" enum="TextureSource">
|
||||
The texture source is not specified in the shader.
|
||||
</constant>
|
||||
<constant name="SOURCE_SCREEN" value="1" enum="TextureSource">
|
||||
The texture source is the screen texture which captures all opaque objects drawn this frame.
|
||||
</constant>
|
||||
<constant name="SOURCE_DEPTH" value="2" enum="TextureSource">
|
||||
The texture source is the depth texture from the depth prepass.
|
||||
</constant>
|
||||
<constant name="SOURCE_NORMAL_ROUGHNESS" value="3" enum="TextureSource">
|
||||
The texture source is the normal-roughness buffer from the depth prepass.
|
||||
</constant>
|
||||
<constant name="SOURCE_MAX" value="4" enum="TextureSource">
|
||||
Represents the size of the [enum TextureSource] enum.
|
||||
</constant>
|
||||
</constants>
|
||||
</class>
|
||||
|
||||
@ -2654,8 +2654,10 @@ RasterizerCanvasGLES3::RasterizerCanvasGLES3() {
|
||||
|
||||
shader_type canvas_item;
|
||||
|
||||
uniform sampler2D screen_texture : hint_screen_texture, repeat_disable, filter_nearest;
|
||||
|
||||
void fragment() {
|
||||
vec4 c = textureLod(SCREEN_TEXTURE, SCREEN_UV, 0.0);
|
||||
vec4 c = textureLod(screen_texture, SCREEN_UV, 0.0);
|
||||
|
||||
if (c.a > 0.0001) {
|
||||
c.rgb /= c.a;
|
||||
@ -2679,8 +2681,10 @@ void fragment() {
|
||||
|
||||
shader_type canvas_item;
|
||||
|
||||
uniform sampler2D screen_texture : hint_screen_texture, repeat_disable, filter_nearest;
|
||||
|
||||
void fragment() {
|
||||
vec4 c = textureLod(SCREEN_TEXTURE, SCREEN_UV, 0.0);
|
||||
vec4 c = textureLod(screen_texture, SCREEN_UV, 0.0);
|
||||
COLOR.rgb = c.rgb;
|
||||
}
|
||||
)");
|
||||
|
||||
@ -277,7 +277,7 @@ flat in uvec4 varying_G;
|
||||
uniform sampler2D atlas_texture; //texunit:-2
|
||||
uniform sampler2D shadow_atlas_texture; //texunit:-3
|
||||
#endif // DISABLE_LIGHTING
|
||||
uniform sampler2D screen_texture; //texunit:-4
|
||||
uniform sampler2D color_buffer; //texunit:-4
|
||||
uniform sampler2D sdf_texture; //texunit:-5
|
||||
uniform sampler2D normal_texture; //texunit:-6
|
||||
uniform sampler2D specular_texture; //texunit:-7
|
||||
|
||||
@ -564,10 +564,10 @@ uniform highp samplerCubeShadow positional_shadow; // texunit:-4
|
||||
|
||||
#ifdef USE_MULTIVIEW
|
||||
uniform highp sampler2DArray depth_buffer; // texunit:-6
|
||||
uniform highp sampler2DArray screen_texture; // texunit:-5
|
||||
uniform highp sampler2DArray color_buffer; // texunit:-5
|
||||
#else
|
||||
uniform highp sampler2D depth_buffer; // texunit:-6
|
||||
uniform highp sampler2D screen_texture; // texunit:-5
|
||||
uniform highp sampler2D color_buffer; // texunit:-5
|
||||
#endif
|
||||
|
||||
uniform highp mat4 world_transform;
|
||||
|
||||
@ -1515,7 +1515,6 @@ MaterialStorage::MaterialStorage() {
|
||||
actions.renames["SPECULAR_SHININESS_TEXTURE"] = "specular_texture";
|
||||
actions.renames["SPECULAR_SHININESS"] = "specular_shininess";
|
||||
actions.renames["SCREEN_UV"] = "screen_uv";
|
||||
actions.renames["SCREEN_TEXTURE"] = "screen_texture";
|
||||
actions.renames["SCREEN_PIXEL_SIZE"] = "screen_pixel_size";
|
||||
actions.renames["FRAGCOORD"] = "gl_FragCoord";
|
||||
actions.renames["POINT_COORD"] = "gl_PointCoord";
|
||||
@ -1536,7 +1535,6 @@ MaterialStorage::MaterialStorage() {
|
||||
actions.renames["screen_uv_to_sdf"] = "screen_uv_to_sdf";
|
||||
|
||||
actions.usage_defines["COLOR"] = "#define COLOR_USED\n";
|
||||
actions.usage_defines["SCREEN_TEXTURE"] = "#define SCREEN_TEXTURE_USED\n";
|
||||
actions.usage_defines["SCREEN_UV"] = "#define SCREEN_UV_USED\n";
|
||||
actions.usage_defines["SCREEN_PIXEL_SIZE"] = "@SCREEN_UV";
|
||||
actions.usage_defines["NORMAL"] = "#define NORMAL_USED\n";
|
||||
@ -1617,9 +1615,6 @@ MaterialStorage::MaterialStorage() {
|
||||
actions.renames["POINT_COORD"] = "gl_PointCoord";
|
||||
actions.renames["INSTANCE_CUSTOM"] = "instance_custom";
|
||||
actions.renames["SCREEN_UV"] = "screen_uv";
|
||||
//actions.renames["SCREEN_TEXTURE"] = "color_buffer"; //Not implemented in 3D yet.
|
||||
//actions.renames["DEPTH_TEXTURE"] = "depth_buffer"; // Not implemented in 3D yet.
|
||||
//actions.renames["NORMAL_ROUGHNESS_TEXTURE"] = "normal_roughness_buffer"; // Not implemented in 3D yet
|
||||
actions.renames["DEPTH"] = "gl_FragDepth";
|
||||
actions.renames["OUTPUT_IS_SRGB"] = "true";
|
||||
actions.renames["FOG"] = "fog";
|
||||
@ -1684,7 +1679,6 @@ MaterialStorage::MaterialStorage() {
|
||||
actions.usage_defines["SSS_STRENGTH"] = "#define ENABLE_SSS\n";
|
||||
actions.usage_defines["SSS_TRANSMITTANCE_DEPTH"] = "#define ENABLE_TRANSMITTANCE\n";
|
||||
actions.usage_defines["BACKLIGHT"] = "#define LIGHT_BACKLIGHT_USED\n";
|
||||
actions.usage_defines["SCREEN_TEXTURE"] = "#define SCREEN_TEXTURE_USED\n";
|
||||
actions.usage_defines["SCREEN_UV"] = "#define SCREEN_UV_USED\n";
|
||||
|
||||
actions.usage_defines["DIFFUSE_LIGHT"] = "#define USE_LIGHT_SHADER_CODE\n";
|
||||
@ -2960,7 +2954,6 @@ void CanvasShaderData::set_code(const String &p_code) {
|
||||
actions.render_mode_values["blend_premul_alpha"] = Pair<int *, int>(&blend_modei, BLEND_MODE_PMALPHA);
|
||||
actions.render_mode_values["blend_disabled"] = Pair<int *, int>(&blend_modei, BLEND_MODE_DISABLED);
|
||||
|
||||
actions.usage_flag_pointers["SCREEN_TEXTURE"] = &uses_screen_texture;
|
||||
actions.usage_flag_pointers["texture_sdf"] = &uses_sdf;
|
||||
actions.usage_flag_pointers["TIME"] = &uses_time;
|
||||
|
||||
@ -2974,6 +2967,7 @@ void CanvasShaderData::set_code(const String &p_code) {
|
||||
|
||||
blend_mode = BlendMode(blend_modei);
|
||||
uses_screen_texture_mipmaps = gen_code.uses_screen_texture_mipmaps;
|
||||
uses_screen_texture = gen_code.uses_screen_texture;
|
||||
|
||||
#if 0
|
||||
print_line("**compiling shader:");
|
||||
@ -3309,9 +3303,6 @@ void SceneShaderData::set_code(const String &p_code) {
|
||||
actions.usage_flag_pointers["SSS_STRENGTH"] = &uses_sss;
|
||||
actions.usage_flag_pointers["SSS_TRANSMITTANCE_DEPTH"] = &uses_transmittance;
|
||||
|
||||
actions.usage_flag_pointers["SCREEN_TEXTURE"] = &uses_screen_texture;
|
||||
actions.usage_flag_pointers["DEPTH_TEXTURE"] = &uses_depth_texture;
|
||||
actions.usage_flag_pointers["NORMAL_TEXTURE"] = &uses_normal_texture;
|
||||
actions.usage_flag_pointers["DISCARD"] = &uses_discard;
|
||||
actions.usage_flag_pointers["TIME"] = &uses_time;
|
||||
actions.usage_flag_pointers["ROUGHNESS"] = &uses_roughness;
|
||||
@ -3364,6 +3355,9 @@ void SceneShaderData::set_code(const String &p_code) {
|
||||
vertex_input_mask |= uses_bones << 9;
|
||||
vertex_input_mask |= uses_weights << 10;
|
||||
uses_screen_texture_mipmaps = gen_code.uses_screen_texture_mipmaps;
|
||||
uses_screen_texture = gen_code.uses_screen_texture;
|
||||
uses_depth_texture = gen_code.uses_depth_texture;
|
||||
uses_normal_texture = gen_code.uses_normal_roughness_texture;
|
||||
uses_vertex_time = gen_code.uses_vertex_time;
|
||||
uses_fragment_time = gen_code.uses_fragment_time;
|
||||
|
||||
|
||||
@ -5441,11 +5441,9 @@ VisualShaderEditor::VisualShaderEditor() {
|
||||
|
||||
add_options.push_back(AddOption("Binormal", "Input/Fragment", "VisualShaderNodeInput", vformat(input_param_for_vertex_and_fragment_shader_modes, "binormal", "BINORMAL"), { "binormal" }, VisualShaderNode::PORT_TYPE_VECTOR_3D, TYPE_FLAGS_FRAGMENT, Shader::MODE_SPATIAL));
|
||||
add_options.push_back(AddOption("Color", "Input/Fragment", "VisualShaderNodeInput", vformat(input_param_for_vertex_and_fragment_shader_modes, "color", "COLOR"), { "color" }, VisualShaderNode::PORT_TYPE_VECTOR_4D, TYPE_FLAGS_FRAGMENT, Shader::MODE_SPATIAL));
|
||||
add_options.push_back(AddOption("DepthTexture", "Input/Fragment", "VisualShaderNodeInput", vformat(input_param_for_fragment_shader_mode, "depth_texture", "DEPTH_TEXTURE"), { "depth_texture" }, VisualShaderNode::PORT_TYPE_SAMPLER, TYPE_FLAGS_FRAGMENT, Shader::MODE_SPATIAL));
|
||||
add_options.push_back(AddOption("FragCoord", "Input/Fragment", "VisualShaderNodeInput", vformat(input_param_for_fragment_and_light_shader_modes, "fragcoord", "FRAGCOORD"), { "fragcoord" }, VisualShaderNode::PORT_TYPE_VECTOR_4D, TYPE_FLAGS_FRAGMENT, Shader::MODE_SPATIAL));
|
||||
add_options.push_back(AddOption("FrontFacing", "Input/Fragment", "VisualShaderNodeInput", vformat(input_param_for_fragment_shader_mode, "front_facing", "FRONT_FACING"), { "front_facing" }, VisualShaderNode::PORT_TYPE_BOOLEAN, TYPE_FLAGS_FRAGMENT, Shader::MODE_SPATIAL));
|
||||
add_options.push_back(AddOption("PointCoord", "Input/Fragment", "VisualShaderNodeInput", vformat(input_param_for_fragment_shader_mode, "point_coord", "POINT_COORD"), { "point_coord" }, VisualShaderNode::PORT_TYPE_VECTOR_2D, TYPE_FLAGS_FRAGMENT, Shader::MODE_SPATIAL));
|
||||
add_options.push_back(AddOption("ScreenTexture", "Input/Fragment", "VisualShaderNodeInput", vformat(input_param_for_fragment_shader_mode, "screen_texture", "SCREEN_TEXTURE"), { "screen_texture" }, VisualShaderNode::PORT_TYPE_SAMPLER, TYPE_FLAGS_FRAGMENT, Shader::MODE_SPATIAL));
|
||||
add_options.push_back(AddOption("ScreenUV", "Input/Fragment", "VisualShaderNodeInput", vformat(input_param_for_fragment_shader_mode, "screen_uv", "SCREEN_UV"), { "screen_uv" }, VisualShaderNode::PORT_TYPE_VECTOR_2D, TYPE_FLAGS_FRAGMENT, Shader::MODE_SPATIAL));
|
||||
add_options.push_back(AddOption("Tangent", "Input/Fragment", "VisualShaderNodeInput", vformat(input_param_for_vertex_and_fragment_shader_modes, "tangent", "TANGENT"), { "tangent" }, VisualShaderNode::PORT_TYPE_VECTOR_3D, TYPE_FLAGS_FRAGMENT, Shader::MODE_SPATIAL));
|
||||
add_options.push_back(AddOption("Vertex", "Input/Fragment", "VisualShaderNodeInput", vformat(input_param_for_vertex_and_fragment_shader_modes, "vertex", "VERTEX"), { "vertex" }, VisualShaderNode::PORT_TYPE_VECTOR_3D, TYPE_FLAGS_FRAGMENT, Shader::MODE_SPATIAL));
|
||||
@ -5488,7 +5486,6 @@ VisualShaderEditor::VisualShaderEditor() {
|
||||
add_options.push_back(AddOption("NormalTexture", "Input/Fragment", "VisualShaderNodeInput", vformat(input_param_for_fragment_shader_mode, "normal_texture", "NORMAL_TEXTURE"), { "normal_texture" }, VisualShaderNode::PORT_TYPE_SAMPLER, TYPE_FLAGS_FRAGMENT, Shader::MODE_CANVAS_ITEM));
|
||||
add_options.push_back(AddOption("PointCoord", "Input/Fragment", "VisualShaderNodeInput", vformat(input_param_for_fragment_and_light_shader_modes, "point_coord", "POINT_COORD"), { "point_coord" }, VisualShaderNode::PORT_TYPE_VECTOR_2D, TYPE_FLAGS_FRAGMENT, Shader::MODE_CANVAS_ITEM));
|
||||
add_options.push_back(AddOption("ScreenPixelSize", "Input/Fragment", "VisualShaderNodeInput", vformat(input_param_for_fragment_shader_mode, "screen_pixel_size", "SCREEN_PIXEL_SIZE"), { "screen_pixel_size" }, VisualShaderNode::PORT_TYPE_VECTOR_2D, TYPE_FLAGS_FRAGMENT, Shader::MODE_CANVAS_ITEM));
|
||||
add_options.push_back(AddOption("ScreenTexture", "Input/Fragment", "VisualShaderNodeInput", vformat(input_param_for_fragment_shader_mode, "screen_texture", "SCREEN_TEXTURE"), { "screen_texture" }, VisualShaderNode::PORT_TYPE_SAMPLER, TYPE_FLAGS_FRAGMENT, Shader::MODE_CANVAS_ITEM));
|
||||
add_options.push_back(AddOption("ScreenUV", "Input/Fragment", "VisualShaderNodeInput", vformat(input_param_for_fragment_and_light_shader_modes, "screen_uv", "SCREEN_UV"), { "screen_uv" }, VisualShaderNode::PORT_TYPE_VECTOR_2D, TYPE_FLAGS_FRAGMENT, Shader::MODE_CANVAS_ITEM));
|
||||
add_options.push_back(AddOption("SpecularShininess", "Input/Fragment", "VisualShaderNodeInput", vformat(input_param_for_fragment_and_light_shader_modes, "specular_shininess", "SPECULAR_SHININESS"), { "specular_shininess" }, VisualShaderNode::PORT_TYPE_VECTOR_4D, TYPE_FLAGS_FRAGMENT, Shader::MODE_CANVAS_ITEM));
|
||||
add_options.push_back(AddOption("SpecularShininessTexture", "Input/Fragment", "VisualShaderNodeInput", vformat(input_param_for_fragment_shader_mode, "specular_shininess_texture", "SPECULAR_SHININESS_TEXTURE"), { "specular_shininess_texture" }, VisualShaderNode::PORT_TYPE_SAMPLER, TYPE_FLAGS_FRAGMENT, Shader::MODE_CANVAS_ITEM));
|
||||
@ -5692,7 +5689,7 @@ VisualShaderEditor::VisualShaderEditor() {
|
||||
add_options.push_back(AddOption("CurveTexture", "Textures/Functions", "VisualShaderNodeCurveTexture", TTR("Perform the curve texture lookup."), {}, VisualShaderNode::PORT_TYPE_SCALAR));
|
||||
curve_xyz_node_option_idx = add_options.size();
|
||||
add_options.push_back(AddOption("CurveXYZTexture", "Textures/Functions", "VisualShaderNodeCurveXYZTexture", TTR("Perform the three components curve texture lookup."), {}, VisualShaderNode::PORT_TYPE_VECTOR_3D));
|
||||
add_options.push_back(AddOption("LinearSceneDepth", "Textures/Functions", "VisualShaderNodeLinearSceneDepth", TTR("Returns the depth value of the DEPTH_TEXTURE node in a linear space."), {}, VisualShaderNode::PORT_TYPE_SCALAR, TYPE_FLAGS_FRAGMENT, Shader::MODE_SPATIAL));
|
||||
add_options.push_back(AddOption("LinearSceneDepth", "Textures/Functions", "VisualShaderNodeLinearSceneDepth", TTR("Returns the depth value obtained from the depth prepass in a linear space."), {}, VisualShaderNode::PORT_TYPE_SCALAR, TYPE_FLAGS_FRAGMENT, Shader::MODE_SPATIAL));
|
||||
texture2d_node_option_idx = add_options.size();
|
||||
add_options.push_back(AddOption("Texture2D", "Textures/Functions", "VisualShaderNodeTexture", TTR("Perform the 2D texture lookup."), {}, VisualShaderNode::PORT_TYPE_VECTOR_4D));
|
||||
texture2d_array_node_option_idx = add_options.size();
|
||||
|
||||
@ -791,6 +791,14 @@ void BaseMaterial3D::_update_shader() {
|
||||
code += "uniform vec4 refraction_texture_channel;\n";
|
||||
}
|
||||
|
||||
if (features[FEATURE_REFRACTION]) {
|
||||
code += "uniform sampler2D screen_texture : hint_screen_texture, repeat_disable, filter_linear_mipmap;";
|
||||
}
|
||||
|
||||
if (proximity_fade_enabled) {
|
||||
code += "uniform sampler2D depth_texture : hint_depth_texture, repeat_disable, filter_nearest;";
|
||||
}
|
||||
|
||||
if (features[FEATURE_NORMAL_MAPPING]) {
|
||||
code += "uniform sampler2D texture_normal : hint_roughness_normal," + texfilter_str + ";\n";
|
||||
code += "uniform float normal_scale : hint_range(-16,16);\n";
|
||||
@ -1228,7 +1236,7 @@ void BaseMaterial3D::_update_shader() {
|
||||
code += " vec2 ref_ofs = SCREEN_UV - ref_normal.xy * dot(texture(texture_refraction,base_uv),refraction_texture_channel) * refraction;\n";
|
||||
}
|
||||
code += " float ref_amount = 1.0 - albedo.a * albedo_tex.a;\n";
|
||||
code += " EMISSION += textureLod(SCREEN_TEXTURE,ref_ofs,ROUGHNESS * 8.0).rgb * ref_amount;\n";
|
||||
code += " EMISSION += textureLod(screen_texture,ref_ofs,ROUGHNESS * 8.0).rgb * ref_amount;\n";
|
||||
code += " ALBEDO *= 1.0 - ref_amount;\n";
|
||||
code += " ALPHA = 1.0;\n";
|
||||
|
||||
@ -1246,7 +1254,7 @@ void BaseMaterial3D::_update_shader() {
|
||||
}
|
||||
|
||||
if (proximity_fade_enabled) {
|
||||
code += " float depth_tex = textureLod(DEPTH_TEXTURE,SCREEN_UV,0.0).r;\n";
|
||||
code += " float depth_tex = textureLod(depth_texture,SCREEN_UV,0.0).r;\n";
|
||||
code += " vec4 world_pos = INV_PROJECTION_MATRIX * vec4(SCREEN_UV*2.0-1.0,depth_tex,1.0);\n";
|
||||
code += " world_pos.xyz/=world_pos.w;\n";
|
||||
code += " ALPHA*=clamp(1.0-smoothstep(world_pos.z+proximity_fade_distance,world_pos.z,VERTEX.z),0.0,1.0);\n";
|
||||
|
||||
@ -2734,9 +2734,6 @@ const VisualShaderNodeInput::Port VisualShaderNodeInput::ports[] = {
|
||||
{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR_2D, "viewport_size", "VIEWPORT_SIZE" },
|
||||
{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_BOOLEAN, "output_is_srgb", "OUTPUT_IS_SRGB" },
|
||||
{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_BOOLEAN, "front_facing", "FRONT_FACING" },
|
||||
{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SAMPLER, "screen_texture", "SCREEN_TEXTURE" },
|
||||
{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SAMPLER, "normal_roughness_texture", "NORMAL_ROUGHNESS_TEXTURE" },
|
||||
{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SAMPLER, "depth_texture", "DEPTH_TEXTURE" },
|
||||
{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SCALAR_INT, "view_index", "VIEW_INDEX" },
|
||||
{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SCALAR_INT, "view_mono_left", "VIEW_MONO_LEFT" },
|
||||
{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SCALAR_INT, "view_right", "VIEW_RIGHT" },
|
||||
@ -2799,7 +2796,6 @@ const VisualShaderNodeInput::Port VisualShaderNodeInput::ports[] = {
|
||||
{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_BOOLEAN, "at_light_pass", "AT_LIGHT_PASS" },
|
||||
{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SAMPLER, "texture", "TEXTURE" },
|
||||
{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SAMPLER, "normal_texture", "NORMAL_TEXTURE" },
|
||||
{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SAMPLER, "screen_texture", "SCREEN_TEXTURE" },
|
||||
{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR_4D, "specular_shininess", "SPECULAR_SHININESS" },
|
||||
{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SAMPLER, "specular_shininess_texture", "SPECULAR_SHININESS_TEXTURE" },
|
||||
{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR_2D, "vertex", "VERTEX" },
|
||||
|
||||
@ -771,6 +771,23 @@ String VisualShaderNodeTexture::generate_global(Shader::Mode p_mode, VisualShade
|
||||
break;
|
||||
}
|
||||
return u + ";\n";
|
||||
} else if (source == SOURCE_SCREEN && (p_mode == Shader::MODE_SPATIAL || p_mode == Shader::MODE_CANVAS_ITEM) && p_type == VisualShader::TYPE_FRAGMENT) {
|
||||
String u = "uniform sampler2D " + make_unique_id(p_type, p_id, "screen_tex");
|
||||
return u + " : hint_screen_texture;\n";
|
||||
} else if (source == SOURCE_DEPTH || source == SOURCE_3D_NORMAL || source == SOURCE_ROUGHNESS) {
|
||||
String sampler_name = "";
|
||||
String hint = " : ";
|
||||
if (source == SOURCE_DEPTH) {
|
||||
sampler_name = "depth_tex";
|
||||
hint += "hint_depth_texture;\n";
|
||||
} else if (source == SOURCE_3D_NORMAL) {
|
||||
sampler_name = "screen_normal_tex";
|
||||
hint += "hint_normal_roughness_texture;\n";
|
||||
} else if (source == SOURCE_ROUGHNESS) {
|
||||
sampler_name = "screen_roughness_tex";
|
||||
hint += "hint_normal_roughness_texture;\n";
|
||||
}
|
||||
return "uniform sampler2D " + make_unique_id(p_type, p_id, sampler_name) + hint;
|
||||
}
|
||||
|
||||
return String();
|
||||
@ -824,17 +841,18 @@ String VisualShaderNodeTexture::generate_code(Shader::Mode p_mode, VisualShader:
|
||||
}
|
||||
|
||||
if (source == SOURCE_SCREEN && (p_mode == Shader::MODE_SPATIAL || p_mode == Shader::MODE_CANVAS_ITEM) && p_type == VisualShader::TYPE_FRAGMENT) {
|
||||
String id = make_unique_id(p_type, p_id, "screen_tex");
|
||||
if (p_input_vars[0].is_empty() || p_for_preview) { // Use UV by default.
|
||||
if (p_input_vars[1].is_empty()) {
|
||||
code += " " + p_output_vars[0] + " = textureLod(SCREEN_TEXTURE, " + default_uv + ", 0.0);\n";
|
||||
code += " " + p_output_vars[0] + " = textureLod(" + id + ", " + default_uv + ", 0.0);\n";
|
||||
} else {
|
||||
code += " " + p_output_vars[0] + " = textureLod(SCREEN_TEXTURE, " + default_uv + ", " + p_input_vars[1] + ");\n";
|
||||
code += " " + p_output_vars[0] + " = textureLod(" + id + ", " + default_uv + ", " + p_input_vars[1] + ");\n";
|
||||
}
|
||||
} else if (p_input_vars[1].is_empty()) {
|
||||
//no lod
|
||||
code += " " + p_output_vars[0] + " = textureLod(SCREEN_TEXTURE, " + p_input_vars[0] + ", 0.0);\n";
|
||||
code += " " + p_output_vars[0] + " = textureLod(" + id + ", " + p_input_vars[0] + ", 0.0);\n";
|
||||
} else {
|
||||
code += " " + p_output_vars[0] + " = textureLod(SCREEN_TEXTURE, " + p_input_vars[0] + ", " + p_input_vars[1] + ");\n";
|
||||
code += " " + p_output_vars[0] + " = textureLod(" + id + ", " + p_input_vars[0] + ", " + p_input_vars[1] + ");\n";
|
||||
}
|
||||
return code;
|
||||
}
|
||||
@ -871,23 +889,58 @@ String VisualShaderNodeTexture::generate_code(Shader::Mode p_mode, VisualShader:
|
||||
return code;
|
||||
}
|
||||
|
||||
if (source == SOURCE_DEPTH) {
|
||||
if (source == SOURCE_DEPTH || source == SOURCE_ROUGHNESS) {
|
||||
if (!p_for_preview && p_mode == Shader::MODE_SPATIAL && p_type == VisualShader::TYPE_FRAGMENT) {
|
||||
String var_name = "";
|
||||
String sampler_name = "";
|
||||
|
||||
if (source == SOURCE_DEPTH) {
|
||||
var_name = "_depth";
|
||||
sampler_name = "depth_tex";
|
||||
} else if (source == SOURCE_ROUGHNESS) {
|
||||
var_name = "_screen_roughness";
|
||||
sampler_name = "screen_roughness_tex";
|
||||
}
|
||||
|
||||
String id = make_unique_id(p_type, p_id, sampler_name);
|
||||
code += " {\n";
|
||||
if (p_input_vars[0].is_empty()) { // Use UV by default.
|
||||
if (p_input_vars[1].is_empty()) {
|
||||
code += " float _depth = texture(DEPTH_TEXTURE, " + default_uv + ").r;\n";
|
||||
code += " float " + var_name + " = texture(" + id + ", " + default_uv + ").r;\n";
|
||||
} else {
|
||||
code += " float _depth = textureLod(DEPTH_TEXTURE, " + default_uv + ", " + p_input_vars[1] + ").r;\n";
|
||||
code += " float " + var_name + " = textureLod(" + id + ", " + default_uv + ", " + p_input_vars[1] + ").r;\n";
|
||||
}
|
||||
} else if (p_input_vars[1].is_empty()) {
|
||||
//no lod
|
||||
code += " float _depth = texture(DEPTH_TEXTURE, " + p_input_vars[0] + ".xy).r;\n";
|
||||
code += " float " + var_name + " = texture(" + id + ", " + p_input_vars[0] + ".xy).r;\n";
|
||||
} else {
|
||||
code += " float _depth = textureLod(DEPTH_TEXTURE, " + p_input_vars[0] + ".xy, " + p_input_vars[1] + ").r;\n";
|
||||
code += " float " + var_name + " = textureLod(" + id + ", " + p_input_vars[0] + ".xy, " + p_input_vars[1] + ").r;\n";
|
||||
}
|
||||
|
||||
code += " " + p_output_vars[0] + " = vec4(_depth, _depth, _depth, 1.0);\n";
|
||||
code += " " + p_output_vars[0] + " = vec4(" + var_name + ", " + var_name + ", " + var_name + ", 1.0);\n";
|
||||
code += " }\n";
|
||||
return code;
|
||||
}
|
||||
}
|
||||
|
||||
if (source == SOURCE_3D_NORMAL) {
|
||||
if (!p_for_preview && p_mode == Shader::MODE_SPATIAL && p_type == VisualShader::TYPE_FRAGMENT) {
|
||||
String id = make_unique_id(p_type, p_id, "screen_normal_tex");
|
||||
code += " {\n";
|
||||
if (p_input_vars[0].is_empty()) { // Use UV by default.
|
||||
if (p_input_vars[1].is_empty()) {
|
||||
code += " vec3 _screen_normal = texture(" + id + ", " + default_uv + ").xyz;\n";
|
||||
} else {
|
||||
code += " vec3 _screen_normal = textureLod(" + id + ", " + default_uv + ", " + p_input_vars[1] + ").xyz;\n";
|
||||
}
|
||||
} else if (p_input_vars[1].is_empty()) {
|
||||
//no lod
|
||||
code += " vec3 _screen_normal = texture(" + id + ", " + p_input_vars[0] + ".xy).xyz;\n";
|
||||
} else {
|
||||
code += " vec3 _screen_normal = textureLod(" + id + ", " + p_input_vars[0] + ".xy, " + p_input_vars[1] + ").xyz;\n";
|
||||
}
|
||||
|
||||
code += " " + p_output_vars[0] + " = vec4(_screen_normal, 1.0);\n";
|
||||
code += " }\n";
|
||||
return code;
|
||||
}
|
||||
@ -921,6 +974,12 @@ void VisualShaderNodeTexture::set_source(Source p_source) {
|
||||
case SOURCE_PORT:
|
||||
simple_decl = false;
|
||||
break;
|
||||
case SOURCE_3D_NORMAL:
|
||||
simple_decl = false;
|
||||
break;
|
||||
case SOURCE_ROUGHNESS:
|
||||
simple_decl = false;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
@ -990,8 +1049,8 @@ String VisualShaderNodeTexture::get_warning(Shader::Mode p_mode, VisualShader::T
|
||||
return String(); // all good
|
||||
}
|
||||
|
||||
if (source == SOURCE_DEPTH && p_mode == Shader::MODE_SPATIAL && p_type == VisualShader::TYPE_FRAGMENT) {
|
||||
if (get_output_port_for_preview() == 0) { // DEPTH_TEXTURE is not supported in preview(canvas_item) shader
|
||||
if ((source == SOURCE_DEPTH || source == SOURCE_3D_NORMAL || source == SOURCE_ROUGHNESS) && p_mode == Shader::MODE_SPATIAL && p_type == VisualShader::TYPE_FRAGMENT) {
|
||||
if (get_output_port_for_preview() == 0) { // DEPTH_TEXTURE and NORMAL_ROUGHNESS_TEXTURE are not supported in preview(canvas_item) shader
|
||||
return RTR("Invalid source for preview.");
|
||||
}
|
||||
return String(); // all good
|
||||
@ -1010,7 +1069,7 @@ void VisualShaderNodeTexture::_bind_methods() {
|
||||
ClassDB::bind_method(D_METHOD("set_texture_type", "value"), &VisualShaderNodeTexture::set_texture_type);
|
||||
ClassDB::bind_method(D_METHOD("get_texture_type"), &VisualShaderNodeTexture::get_texture_type);
|
||||
|
||||
ADD_PROPERTY(PropertyInfo(Variant::INT, "source", PROPERTY_HINT_ENUM, "Texture,Screen,Texture2D,NormalMap2D,Depth,SamplerPort"), "set_source", "get_source");
|
||||
ADD_PROPERTY(PropertyInfo(Variant::INT, "source", PROPERTY_HINT_ENUM, "Texture,Screen,Texture2D,NormalMap2D,Depth,SamplerPort,ScreenNormal,Roughness"), "set_source", "get_source");
|
||||
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D"), "set_texture", "get_texture");
|
||||
ADD_PROPERTY(PropertyInfo(Variant::INT, "texture_type", PROPERTY_HINT_ENUM, "Data,Color,Normal Map"), "set_texture_type", "get_texture_type");
|
||||
|
||||
@ -1020,6 +1079,8 @@ void VisualShaderNodeTexture::_bind_methods() {
|
||||
BIND_ENUM_CONSTANT(SOURCE_2D_NORMAL);
|
||||
BIND_ENUM_CONSTANT(SOURCE_DEPTH);
|
||||
BIND_ENUM_CONSTANT(SOURCE_PORT);
|
||||
BIND_ENUM_CONSTANT(SOURCE_3D_NORMAL);
|
||||
BIND_ENUM_CONSTANT(SOURCE_ROUGHNESS);
|
||||
BIND_ENUM_CONSTANT(SOURCE_MAX);
|
||||
|
||||
BIND_ENUM_CONSTANT(TYPE_DATA);
|
||||
@ -1702,11 +1763,15 @@ bool VisualShaderNodeLinearSceneDepth::has_output_port_preview(int p_port) const
|
||||
return false;
|
||||
}
|
||||
|
||||
String VisualShaderNodeLinearSceneDepth::generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const {
|
||||
return "uniform sampler2D " + make_unique_id(p_type, p_id, "depth_tex") + " : hint_depth_texture;\n";
|
||||
}
|
||||
|
||||
String VisualShaderNodeLinearSceneDepth::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
|
||||
String code;
|
||||
code += " {\n";
|
||||
|
||||
code += " float __log_depth = textureLod(DEPTH_TEXTURE, SCREEN_UV, 0.0).x;\n";
|
||||
code += " float __log_depth = textureLod(" + make_unique_id(p_type, p_id, "depth_tex") + ", SCREEN_UV, 0.0).x;\n";
|
||||
code += " vec3 __depth_ndc = vec3(SCREEN_UV * 2.0 - 1.0, __log_depth);\n";
|
||||
code += " vec4 __depth_view = INV_PROJECTION_MATRIX * vec4(__depth_ndc, 1.0);\n";
|
||||
code += " __depth_view.xyz /= __depth_view.w;\n";
|
||||
@ -6101,7 +6166,7 @@ VisualShaderNodeTransformParameter::VisualShaderNodeTransformParameter() {
|
||||
|
||||
//////////////
|
||||
|
||||
String get_sampler_hint(VisualShaderNodeTextureParameter::TextureType p_texture_type, VisualShaderNodeTextureParameter::ColorDefault p_color_default, VisualShaderNodeTextureParameter::TextureFilter p_texture_filter, VisualShaderNodeTextureParameter::TextureRepeat p_texture_repeat) {
|
||||
String get_sampler_hint(VisualShaderNodeTextureParameter::TextureType p_texture_type, VisualShaderNodeTextureParameter::ColorDefault p_color_default, VisualShaderNodeTextureParameter::TextureFilter p_texture_filter, VisualShaderNodeTextureParameter::TextureRepeat p_texture_repeat, VisualShaderNodeTextureParameter::TextureSource p_texture_source) {
|
||||
String code;
|
||||
bool has_colon = false;
|
||||
|
||||
@ -6204,6 +6269,33 @@ String get_sampler_hint(VisualShaderNodeTextureParameter::TextureType p_texture_
|
||||
}
|
||||
}
|
||||
|
||||
{
|
||||
String source_code;
|
||||
|
||||
switch (p_texture_source) {
|
||||
case VisualShaderNodeTextureParameter::SOURCE_SCREEN:
|
||||
source_code = "hint_screen_texture";
|
||||
break;
|
||||
case VisualShaderNodeTextureParameter::SOURCE_DEPTH:
|
||||
source_code = "hint_depth_texture";
|
||||
break;
|
||||
case VisualShaderNodeTextureParameter::SOURCE_NORMAL_ROUGHNESS:
|
||||
source_code = "hint_normal_roughness_texture";
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
if (!source_code.is_empty()) {
|
||||
if (!has_colon) {
|
||||
code += " : ";
|
||||
} else {
|
||||
code += ", ";
|
||||
}
|
||||
code += source_code;
|
||||
}
|
||||
}
|
||||
|
||||
return code;
|
||||
}
|
||||
|
||||
@ -6290,6 +6382,19 @@ VisualShaderNodeTextureParameter::TextureRepeat VisualShaderNodeTextureParameter
|
||||
return texture_repeat;
|
||||
}
|
||||
|
||||
void VisualShaderNodeTextureParameter::set_texture_source(TextureSource p_source) {
|
||||
ERR_FAIL_INDEX(int(p_source), int(SOURCE_MAX));
|
||||
if (texture_source == p_source) {
|
||||
return;
|
||||
}
|
||||
texture_source = p_source;
|
||||
emit_changed();
|
||||
}
|
||||
|
||||
VisualShaderNodeTextureParameter::TextureSource VisualShaderNodeTextureParameter::get_texture_source() const {
|
||||
return texture_source;
|
||||
}
|
||||
|
||||
Vector<StringName> VisualShaderNodeTextureParameter::get_editable_properties() const {
|
||||
Vector<StringName> props = VisualShaderNodeParameter::get_editable_properties();
|
||||
props.push_back("texture_type");
|
||||
@ -6298,6 +6403,7 @@ Vector<StringName> VisualShaderNodeTextureParameter::get_editable_properties() c
|
||||
}
|
||||
props.push_back("texture_filter");
|
||||
props.push_back("texture_repeat");
|
||||
props.push_back("texture_source");
|
||||
return props;
|
||||
}
|
||||
|
||||
@ -6311,6 +6417,7 @@ HashMap<StringName, String> VisualShaderNodeTextureParameter::get_editable_prope
|
||||
names.insert("color_default", RTR("Default Color"));
|
||||
names.insert("texture_filter", RTR("Filter"));
|
||||
names.insert("texture_repeat", RTR("Repeat"));
|
||||
names.insert("texture_source", RTR("Source"));
|
||||
return names;
|
||||
}
|
||||
|
||||
@ -6318,19 +6425,23 @@ void VisualShaderNodeTextureParameter::_bind_methods() {
|
||||
ClassDB::bind_method(D_METHOD("set_texture_type", "type"), &VisualShaderNodeTextureParameter::set_texture_type);
|
||||
ClassDB::bind_method(D_METHOD("get_texture_type"), &VisualShaderNodeTextureParameter::get_texture_type);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("set_color_default", "type"), &VisualShaderNodeTextureParameter::set_color_default);
|
||||
ClassDB::bind_method(D_METHOD("set_color_default", "color"), &VisualShaderNodeTextureParameter::set_color_default);
|
||||
ClassDB::bind_method(D_METHOD("get_color_default"), &VisualShaderNodeTextureParameter::get_color_default);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("set_texture_filter", "filter"), &VisualShaderNodeTextureParameter::set_texture_filter);
|
||||
ClassDB::bind_method(D_METHOD("get_texture_filter"), &VisualShaderNodeTextureParameter::get_texture_filter);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("set_texture_repeat", "type"), &VisualShaderNodeTextureParameter::set_texture_repeat);
|
||||
ClassDB::bind_method(D_METHOD("set_texture_repeat", "repeat"), &VisualShaderNodeTextureParameter::set_texture_repeat);
|
||||
ClassDB::bind_method(D_METHOD("get_texture_repeat"), &VisualShaderNodeTextureParameter::get_texture_repeat);
|
||||
|
||||
ClassDB::bind_method(D_METHOD("set_texture_source", "source"), &VisualShaderNodeTextureParameter::set_texture_source);
|
||||
ClassDB::bind_method(D_METHOD("get_texture_source"), &VisualShaderNodeTextureParameter::get_texture_source);
|
||||
|
||||
ADD_PROPERTY(PropertyInfo(Variant::INT, "texture_type", PROPERTY_HINT_ENUM, "Data,Color,Normal Map,Anisotropic"), "set_texture_type", "get_texture_type");
|
||||
ADD_PROPERTY(PropertyInfo(Variant::INT, "color_default", PROPERTY_HINT_ENUM, "White,Black,Transparent"), "set_color_default", "get_color_default");
|
||||
ADD_PROPERTY(PropertyInfo(Variant::INT, "texture_filter", PROPERTY_HINT_ENUM, "Default,Nearest,Linear,Nearest Mipmap,Linear Mipmap,Nearest Mipmap Anisotropic,Linear Mipmap Anisotropic"), "set_texture_filter", "get_texture_filter");
|
||||
ADD_PROPERTY(PropertyInfo(Variant::INT, "texture_repeat", PROPERTY_HINT_ENUM, "Default,Enabled,Disabled"), "set_texture_repeat", "get_texture_repeat");
|
||||
ADD_PROPERTY(PropertyInfo(Variant::INT, "texture_source", PROPERTY_HINT_ENUM, "None,Screen,Depth,NormalRoughness"), "set_texture_source", "get_texture_source");
|
||||
|
||||
BIND_ENUM_CONSTANT(TYPE_DATA);
|
||||
BIND_ENUM_CONSTANT(TYPE_COLOR);
|
||||
@ -6356,6 +6467,12 @@ void VisualShaderNodeTextureParameter::_bind_methods() {
|
||||
BIND_ENUM_CONSTANT(REPEAT_ENABLED);
|
||||
BIND_ENUM_CONSTANT(REPEAT_DISABLED);
|
||||
BIND_ENUM_CONSTANT(REPEAT_MAX);
|
||||
|
||||
BIND_ENUM_CONSTANT(SOURCE_NONE);
|
||||
BIND_ENUM_CONSTANT(SOURCE_SCREEN);
|
||||
BIND_ENUM_CONSTANT(SOURCE_DEPTH);
|
||||
BIND_ENUM_CONSTANT(SOURCE_NORMAL_ROUGHNESS);
|
||||
BIND_ENUM_CONSTANT(SOURCE_MAX);
|
||||
}
|
||||
|
||||
bool VisualShaderNodeTextureParameter::is_qualifier_supported(Qualifier p_qual) const {
|
||||
@ -6396,7 +6513,7 @@ String VisualShaderNodeTexture2DParameter::get_output_port_name(int p_port) cons
|
||||
|
||||
String VisualShaderNodeTexture2DParameter::generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const {
|
||||
String code = _get_qual_str() + "uniform sampler2D " + get_parameter_name();
|
||||
code += get_sampler_hint(texture_type, color_default, texture_filter, texture_repeat);
|
||||
code += get_sampler_hint(texture_type, color_default, texture_filter, texture_repeat, texture_source);
|
||||
code += ";\n";
|
||||
return code;
|
||||
}
|
||||
@ -6496,7 +6613,7 @@ String VisualShaderNodeTextureParameterTriplanar::generate_global_per_func(Shade
|
||||
|
||||
String VisualShaderNodeTextureParameterTriplanar::generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const {
|
||||
String code = _get_qual_str() + "uniform sampler2D " + get_parameter_name();
|
||||
code += get_sampler_hint(texture_type, color_default, texture_filter, texture_repeat);
|
||||
code += get_sampler_hint(texture_type, color_default, texture_filter, texture_repeat, texture_source);
|
||||
code += ";\n";
|
||||
return code;
|
||||
}
|
||||
@ -6542,7 +6659,7 @@ String VisualShaderNodeTexture2DArrayParameter::get_output_port_name(int p_port)
|
||||
|
||||
String VisualShaderNodeTexture2DArrayParameter::generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const {
|
||||
String code = _get_qual_str() + "uniform sampler2DArray " + get_parameter_name();
|
||||
code += get_sampler_hint(texture_type, color_default, texture_filter, texture_repeat);
|
||||
code += get_sampler_hint(texture_type, color_default, texture_filter, texture_repeat, texture_source);
|
||||
code += ";\n";
|
||||
return code;
|
||||
}
|
||||
@ -6562,7 +6679,7 @@ String VisualShaderNodeTexture3DParameter::get_output_port_name(int p_port) cons
|
||||
|
||||
String VisualShaderNodeTexture3DParameter::generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const {
|
||||
String code = _get_qual_str() + "uniform sampler3D " + get_parameter_name();
|
||||
code += get_sampler_hint(texture_type, color_default, texture_filter, texture_repeat);
|
||||
code += get_sampler_hint(texture_type, color_default, texture_filter, texture_repeat, texture_source);
|
||||
code += ";\n";
|
||||
return code;
|
||||
}
|
||||
@ -6582,7 +6699,7 @@ String VisualShaderNodeCubemapParameter::get_output_port_name(int p_port) const
|
||||
|
||||
String VisualShaderNodeCubemapParameter::generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const {
|
||||
String code = _get_qual_str() + "uniform samplerCube " + get_parameter_name();
|
||||
code += get_sampler_hint(texture_type, color_default, texture_filter, texture_repeat);
|
||||
code += get_sampler_hint(texture_type, color_default, texture_filter, texture_repeat, texture_source);
|
||||
code += ";\n";
|
||||
return code;
|
||||
}
|
||||
|
||||
@ -385,6 +385,8 @@ public:
|
||||
SOURCE_2D_NORMAL,
|
||||
SOURCE_DEPTH,
|
||||
SOURCE_PORT,
|
||||
SOURCE_3D_NORMAL,
|
||||
SOURCE_ROUGHNESS,
|
||||
SOURCE_MAX,
|
||||
};
|
||||
|
||||
@ -668,6 +670,7 @@ public:
|
||||
virtual String get_output_port_name(int p_port) const override;
|
||||
virtual bool has_output_port_preview(int p_port) const override;
|
||||
|
||||
virtual String generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const override;
|
||||
virtual String generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview = false) const override;
|
||||
|
||||
VisualShaderNodeLinearSceneDepth();
|
||||
@ -2362,11 +2365,20 @@ public:
|
||||
REPEAT_MAX,
|
||||
};
|
||||
|
||||
enum TextureSource {
|
||||
SOURCE_NONE,
|
||||
SOURCE_SCREEN,
|
||||
SOURCE_DEPTH,
|
||||
SOURCE_NORMAL_ROUGHNESS,
|
||||
SOURCE_MAX,
|
||||
};
|
||||
|
||||
protected:
|
||||
TextureType texture_type = TYPE_DATA;
|
||||
ColorDefault color_default = COLOR_DEFAULT_WHITE;
|
||||
TextureFilter texture_filter = FILTER_DEFAULT;
|
||||
TextureRepeat texture_repeat = REPEAT_DEFAULT;
|
||||
TextureSource texture_source = SOURCE_NONE;
|
||||
|
||||
protected:
|
||||
static void _bind_methods();
|
||||
@ -2398,6 +2410,9 @@ public:
|
||||
void set_texture_repeat(TextureRepeat p_repeat);
|
||||
TextureRepeat get_texture_repeat() const;
|
||||
|
||||
void set_texture_source(TextureSource p_source);
|
||||
TextureSource get_texture_source() const;
|
||||
|
||||
bool is_qualifier_supported(Qualifier p_qual) const override;
|
||||
bool is_convertible_to_constant() const override;
|
||||
|
||||
@ -2408,6 +2423,7 @@ VARIANT_ENUM_CAST(VisualShaderNodeTextureParameter::TextureType)
|
||||
VARIANT_ENUM_CAST(VisualShaderNodeTextureParameter::ColorDefault)
|
||||
VARIANT_ENUM_CAST(VisualShaderNodeTextureParameter::TextureFilter)
|
||||
VARIANT_ENUM_CAST(VisualShaderNodeTextureParameter::TextureRepeat)
|
||||
VARIANT_ENUM_CAST(VisualShaderNodeTextureParameter::TextureSource)
|
||||
|
||||
///////////////////////////////////////
|
||||
|
||||
|
||||
@ -44,7 +44,6 @@ void SceneShaderForwardClustered::ShaderData::set_code(const String &p_code) {
|
||||
valid = false;
|
||||
ubo_size = 0;
|
||||
uniforms.clear();
|
||||
uses_screen_texture = false;
|
||||
|
||||
if (code.is_empty()) {
|
||||
return; //just invalid, but no error
|
||||
@ -73,9 +72,6 @@ void SceneShaderForwardClustered::ShaderData::set_code(const String &p_code) {
|
||||
uses_position = false;
|
||||
uses_sss = false;
|
||||
uses_transmittance = false;
|
||||
uses_screen_texture = false;
|
||||
uses_depth_texture = false;
|
||||
uses_normal_texture = false;
|
||||
uses_time = false;
|
||||
writes_modelview_or_projection = false;
|
||||
uses_world_coordinates = false;
|
||||
@ -120,9 +116,6 @@ void SceneShaderForwardClustered::ShaderData::set_code(const String &p_code) {
|
||||
actions.usage_flag_pointers["SSS_STRENGTH"] = &uses_sss;
|
||||
actions.usage_flag_pointers["SSS_TRANSMITTANCE_DEPTH"] = &uses_transmittance;
|
||||
|
||||
actions.usage_flag_pointers["SCREEN_TEXTURE"] = &uses_screen_texture;
|
||||
actions.usage_flag_pointers["DEPTH_TEXTURE"] = &uses_depth_texture;
|
||||
actions.usage_flag_pointers["NORMAL_ROUGHNESS_TEXTURE"] = &uses_normal_texture;
|
||||
actions.usage_flag_pointers["DISCARD"] = &uses_discard;
|
||||
actions.usage_flag_pointers["TIME"] = &uses_time;
|
||||
actions.usage_flag_pointers["ROUGHNESS"] = &uses_roughness;
|
||||
@ -151,6 +144,9 @@ void SceneShaderForwardClustered::ShaderData::set_code(const String &p_code) {
|
||||
depth_test = DepthTest(depth_testi);
|
||||
cull_mode = Cull(cull_modei);
|
||||
uses_screen_texture_mipmaps = gen_code.uses_screen_texture_mipmaps;
|
||||
uses_screen_texture = gen_code.uses_screen_texture;
|
||||
uses_depth_texture = gen_code.uses_depth_texture;
|
||||
uses_normal_texture = gen_code.uses_normal_roughness_texture;
|
||||
uses_vertex_time = gen_code.uses_vertex_time;
|
||||
uses_fragment_time = gen_code.uses_fragment_time;
|
||||
|
||||
@ -607,9 +603,6 @@ void SceneShaderForwardClustered::init(const String p_defines) {
|
||||
actions.renames["POINT_COORD"] = "gl_PointCoord";
|
||||
actions.renames["INSTANCE_CUSTOM"] = "instance_custom";
|
||||
actions.renames["SCREEN_UV"] = "screen_uv";
|
||||
actions.renames["SCREEN_TEXTURE"] = "color_buffer";
|
||||
actions.renames["DEPTH_TEXTURE"] = "depth_buffer";
|
||||
actions.renames["NORMAL_ROUGHNESS_TEXTURE"] = "normal_roughness_buffer";
|
||||
actions.renames["DEPTH"] = "gl_FragDepth";
|
||||
actions.renames["OUTPUT_IS_SRGB"] = "true";
|
||||
actions.renames["FOG"] = "fog";
|
||||
@ -674,7 +667,6 @@ void SceneShaderForwardClustered::init(const String p_defines) {
|
||||
actions.usage_defines["SSS_STRENGTH"] = "#define ENABLE_SSS\n";
|
||||
actions.usage_defines["SSS_TRANSMITTANCE_DEPTH"] = "#define ENABLE_TRANSMITTANCE\n";
|
||||
actions.usage_defines["BACKLIGHT"] = "#define LIGHT_BACKLIGHT_USED\n";
|
||||
actions.usage_defines["SCREEN_TEXTURE"] = "#define SCREEN_TEXTURE_USED\n";
|
||||
actions.usage_defines["SCREEN_UV"] = "#define SCREEN_UV_USED\n";
|
||||
|
||||
actions.usage_defines["DIFFUSE_LIGHT"] = "#define USE_LIGHT_SHADER_CODE\n";
|
||||
@ -707,10 +699,6 @@ void SceneShaderForwardClustered::init(const String p_defines) {
|
||||
|
||||
actions.render_mode_defines["specular_schlick_ggx"] = "#define SPECULAR_SCHLICK_GGX\n";
|
||||
|
||||
actions.custom_samplers["SCREEN_TEXTURE"] = "material_samplers[3]"; // linear filter with mipmaps
|
||||
actions.custom_samplers["DEPTH_TEXTURE"] = "material_samplers[3]";
|
||||
actions.custom_samplers["NORMAL_ROUGHNESS_TEXTURE"] = "material_samplers[1]"; // linear filter
|
||||
|
||||
actions.render_mode_defines["specular_toon"] = "#define SPECULAR_TOON\n";
|
||||
actions.render_mode_defines["specular_disabled"] = "#define SPECULAR_DISABLED\n";
|
||||
actions.render_mode_defines["shadows_disabled"] = "#define SHADOWS_DISABLED\n";
|
||||
|
||||
@ -46,7 +46,6 @@ void SceneShaderForwardMobile::ShaderData::set_code(const String &p_code) {
|
||||
valid = false;
|
||||
ubo_size = 0;
|
||||
uniforms.clear();
|
||||
uses_screen_texture = false;
|
||||
|
||||
if (code.is_empty()) {
|
||||
return; //just invalid, but no error
|
||||
@ -74,9 +73,6 @@ void SceneShaderForwardMobile::ShaderData::set_code(const String &p_code) {
|
||||
uses_vertex = false;
|
||||
uses_sss = false;
|
||||
uses_transmittance = false;
|
||||
uses_screen_texture = false;
|
||||
uses_depth_texture = false;
|
||||
uses_normal_texture = false;
|
||||
uses_time = false;
|
||||
writes_modelview_or_projection = false;
|
||||
uses_world_coordinates = false;
|
||||
@ -121,9 +117,6 @@ void SceneShaderForwardMobile::ShaderData::set_code(const String &p_code) {
|
||||
// actions.usage_flag_pointers["SSS_STRENGTH"] = &uses_sss;
|
||||
// actions.usage_flag_pointers["SSS_TRANSMITTANCE_DEPTH"] = &uses_transmittance;
|
||||
|
||||
actions.usage_flag_pointers["SCREEN_TEXTURE"] = &uses_screen_texture;
|
||||
actions.usage_flag_pointers["DEPTH_TEXTURE"] = &uses_depth_texture;
|
||||
actions.usage_flag_pointers["NORMAL_ROUGHNESS_TEXTURE"] = &uses_normal_texture;
|
||||
actions.usage_flag_pointers["DISCARD"] = &uses_discard;
|
||||
actions.usage_flag_pointers["TIME"] = &uses_time;
|
||||
actions.usage_flag_pointers["ROUGHNESS"] = &uses_roughness;
|
||||
@ -152,6 +145,10 @@ void SceneShaderForwardMobile::ShaderData::set_code(const String &p_code) {
|
||||
depth_test = DepthTest(depth_testi);
|
||||
uses_vertex_time = gen_code.uses_vertex_time;
|
||||
uses_fragment_time = gen_code.uses_fragment_time;
|
||||
uses_screen_texture_mipmaps = gen_code.uses_screen_texture_mipmaps;
|
||||
uses_screen_texture = gen_code.uses_screen_texture;
|
||||
uses_depth_texture = gen_code.uses_depth_texture;
|
||||
uses_normal_texture = gen_code.uses_normal_roughness_texture;
|
||||
|
||||
#if 0
|
||||
print_line("**compiling shader:");
|
||||
@ -498,9 +495,6 @@ void SceneShaderForwardMobile::init(const String p_defines) {
|
||||
actions.renames["POINT_COORD"] = "gl_PointCoord";
|
||||
actions.renames["INSTANCE_CUSTOM"] = "instance_custom";
|
||||
actions.renames["SCREEN_UV"] = "screen_uv";
|
||||
actions.renames["SCREEN_TEXTURE"] = "color_buffer";
|
||||
actions.renames["DEPTH_TEXTURE"] = "depth_buffer";
|
||||
actions.renames["NORMAL_ROUGHNESS_TEXTURE"] = "normal_roughness_buffer";
|
||||
actions.renames["DEPTH"] = "gl_FragDepth";
|
||||
actions.renames["OUTPUT_IS_SRGB"] = "true";
|
||||
actions.renames["FOG"] = "fog";
|
||||
@ -565,7 +559,6 @@ void SceneShaderForwardMobile::init(const String p_defines) {
|
||||
actions.usage_defines["SSS_STRENGTH"] = "#define ENABLE_SSS\n";
|
||||
actions.usage_defines["SSS_TRANSMITTANCE_DEPTH"] = "#define ENABLE_TRANSMITTANCE\n";
|
||||
actions.usage_defines["BACKLIGHT"] = "#define LIGHT_BACKLIGHT_USED\n";
|
||||
actions.usage_defines["SCREEN_TEXTURE"] = "#define SCREEN_TEXTURE_USED\n";
|
||||
actions.usage_defines["SCREEN_UV"] = "#define SCREEN_UV_USED\n";
|
||||
|
||||
actions.usage_defines["DIFFUSE_LIGHT"] = "#define USE_LIGHT_SHADER_CODE\n";
|
||||
|
||||
@ -128,6 +128,7 @@ public:
|
||||
bool uses_screen_texture = false;
|
||||
bool uses_depth_texture = false;
|
||||
bool uses_normal_texture = false;
|
||||
bool uses_screen_texture_mipmaps = false;
|
||||
bool uses_time = false;
|
||||
bool uses_vertex_time = false;
|
||||
bool uses_fragment_time = false;
|
||||
|
||||
@ -2036,7 +2036,6 @@ void RendererCanvasRenderRD::CanvasShaderData::set_code(const String &p_code) {
|
||||
actions.render_mode_values["blend_premul_alpha"] = Pair<int *, int>(&blend_mode, BLEND_MODE_PMALPHA);
|
||||
actions.render_mode_values["blend_disabled"] = Pair<int *, int>(&blend_mode, BLEND_MODE_DISABLED);
|
||||
|
||||
actions.usage_flag_pointers["SCREEN_TEXTURE"] = &uses_screen_texture;
|
||||
actions.usage_flag_pointers["texture_sdf"] = &uses_sdf;
|
||||
actions.usage_flag_pointers["TIME"] = &uses_time;
|
||||
|
||||
@ -2048,6 +2047,7 @@ void RendererCanvasRenderRD::CanvasShaderData::set_code(const String &p_code) {
|
||||
ERR_FAIL_COND_MSG(err != OK, "Shader compilation failed.");
|
||||
|
||||
uses_screen_texture_mipmaps = gen_code.uses_screen_texture_mipmaps;
|
||||
uses_screen_texture = gen_code.uses_screen_texture;
|
||||
|
||||
if (version.is_null()) {
|
||||
version = canvas_singleton->shader.canvas_shader.version_create();
|
||||
@ -2425,7 +2425,6 @@ RendererCanvasRenderRD::RendererCanvasRenderRD() {
|
||||
actions.renames["SPECULAR_SHININESS_TEXTURE"] = "specular_texture";
|
||||
actions.renames["SPECULAR_SHININESS"] = "specular_shininess";
|
||||
actions.renames["SCREEN_UV"] = "screen_uv";
|
||||
actions.renames["SCREEN_TEXTURE"] = "screen_texture";
|
||||
actions.renames["SCREEN_PIXEL_SIZE"] = "canvas_data.screen_pixel_size";
|
||||
actions.renames["FRAGCOORD"] = "gl_FragCoord";
|
||||
actions.renames["POINT_COORD"] = "gl_PointCoord";
|
||||
@ -2446,7 +2445,6 @@ RendererCanvasRenderRD::RendererCanvasRenderRD() {
|
||||
actions.renames["screen_uv_to_sdf"] = "screen_uv_to_sdf";
|
||||
|
||||
actions.usage_defines["COLOR"] = "#define COLOR_USED\n";
|
||||
actions.usage_defines["SCREEN_TEXTURE"] = "#define SCREEN_TEXTURE_USED\n";
|
||||
actions.usage_defines["SCREEN_UV"] = "#define SCREEN_UV_USED\n";
|
||||
actions.usage_defines["SCREEN_PIXEL_SIZE"] = "@SCREEN_UV";
|
||||
actions.usage_defines["NORMAL"] = "#define NORMAL_USED\n";
|
||||
@ -2461,7 +2459,6 @@ RendererCanvasRenderRD::RendererCanvasRenderRD() {
|
||||
actions.custom_samplers["TEXTURE"] = "texture_sampler";
|
||||
actions.custom_samplers["NORMAL_TEXTURE"] = "texture_sampler";
|
||||
actions.custom_samplers["SPECULAR_SHININESS_TEXTURE"] = "texture_sampler";
|
||||
actions.custom_samplers["SCREEN_TEXTURE"] = "material_samplers[3]"; //mipmap and filter for screen texture
|
||||
actions.sampler_array_name = "material_samplers";
|
||||
actions.base_texture_binding_index = 1;
|
||||
actions.texture_layout_set = MATERIAL_UNIFORM_SET;
|
||||
@ -2634,8 +2631,10 @@ RendererCanvasRenderRD::RendererCanvasRenderRD() {
|
||||
|
||||
shader_type canvas_item;
|
||||
|
||||
uniform sampler2D screen_texture : hint_screen_texture, repeat_disable, filter_nearest;
|
||||
|
||||
void fragment() {
|
||||
vec4 c = textureLod(SCREEN_TEXTURE, SCREEN_UV, 0.0);
|
||||
vec4 c = textureLod(screen_texture, SCREEN_UV, 0.0);
|
||||
|
||||
if (c.a > 0.0001) {
|
||||
c.rgb /= c.a;
|
||||
@ -2659,8 +2658,10 @@ void fragment() {
|
||||
|
||||
shader_type canvas_item;
|
||||
|
||||
uniform sampler2D screen_texture : hint_screen_texture, repeat_disable, filter_nearest;
|
||||
|
||||
void fragment() {
|
||||
vec4 c = textureLod(SCREEN_TEXTURE, SCREEN_UV, 0.0);
|
||||
vec4 c = textureLod(screen_texture, SCREEN_UV, 0.0);
|
||||
COLOR.rgb = c.rgb;
|
||||
}
|
||||
)");
|
||||
|
||||
@ -137,7 +137,7 @@ layout(set = 0, binding = 4) uniform texture2D shadow_atlas_texture;
|
||||
|
||||
layout(set = 0, binding = 5) uniform sampler shadow_sampler;
|
||||
|
||||
layout(set = 0, binding = 6) uniform texture2D screen_texture;
|
||||
layout(set = 0, binding = 6) uniform texture2D color_buffer;
|
||||
layout(set = 0, binding = 7) uniform texture2D sdf_texture;
|
||||
|
||||
layout(set = 0, binding = 8) uniform sampler material_samplers[12];
|
||||
|
||||
@ -909,9 +909,6 @@ String ShaderCompiler::_dump_node_code(const SL::Node *p_node, int p_level, Gene
|
||||
|
||||
if (p_default_actions.renames.has(vnode->name)) {
|
||||
code = p_default_actions.renames[vnode->name];
|
||||
if (vnode->name == "SCREEN_TEXTURE") {
|
||||
r_gen_code.uses_screen_texture_mipmaps = true;
|
||||
}
|
||||
} else {
|
||||
if (shader->uniforms.has(vnode->name)) {
|
||||
//its a uniform!
|
||||
@ -919,29 +916,22 @@ String ShaderCompiler::_dump_node_code(const SL::Node *p_node, int p_level, Gene
|
||||
if (u.texture_order >= 0) {
|
||||
StringName name = vnode->name;
|
||||
if (u.hint == ShaderLanguage::ShaderNode::Uniform::HINT_SCREEN_TEXTURE) {
|
||||
name = "SCREEN_TEXTURE";
|
||||
name = "color_buffer";
|
||||
if (u.filter >= ShaderLanguage::FILTER_NEAREST_MIPMAP) {
|
||||
r_gen_code.uses_screen_texture_mipmaps = true;
|
||||
}
|
||||
r_gen_code.uses_screen_texture = true;
|
||||
} else if (u.hint == ShaderLanguage::ShaderNode::Uniform::HINT_NORMAL_ROUGHNESS_TEXTURE) {
|
||||
name = "NORMAL_ROUGHNESS_TEXTURE";
|
||||
name = "normal_roughness_buffer";
|
||||
r_gen_code.uses_normal_roughness_texture = true;
|
||||
} else if (u.hint == ShaderLanguage::ShaderNode::Uniform::HINT_DEPTH_TEXTURE) {
|
||||
name = "DEPTH_TEXTURE";
|
||||
name = "depth_buffer";
|
||||
r_gen_code.uses_depth_texture = true;
|
||||
} else {
|
||||
name = _mkid(vnode->name); //texture, use as is
|
||||
}
|
||||
|
||||
if (p_default_actions.renames.has(name)) {
|
||||
code = p_default_actions.renames[name];
|
||||
} else {
|
||||
code = name;
|
||||
}
|
||||
|
||||
if (p_actions.usage_flag_pointers.has(name) && !used_flag_pointers.has(name)) {
|
||||
*p_actions.usage_flag_pointers[name] = true;
|
||||
used_flag_pointers.insert(name);
|
||||
}
|
||||
|
||||
code = name;
|
||||
} else {
|
||||
//a scalar or vector
|
||||
if (u.scope == ShaderLanguage::ShaderNode::Uniform::SCOPE_GLOBAL) {
|
||||
@ -1251,16 +1241,20 @@ String ShaderCompiler::_dump_node_code(const SL::Node *p_node, int p_level, Gene
|
||||
}
|
||||
|
||||
if (correct_texture_uniform) {
|
||||
//TODO Needs to detect screen_texture hint as well
|
||||
is_screen_texture = (texture_uniform == "SCREEN_TEXTURE");
|
||||
|
||||
String sampler_name;
|
||||
bool is_normal_roughness_texture = false;
|
||||
|
||||
if (actions.custom_samplers.has(texture_uniform)) {
|
||||
sampler_name = actions.custom_samplers[texture_uniform];
|
||||
} else {
|
||||
if (shader->uniforms.has(texture_uniform)) {
|
||||
sampler_name = _get_sampler_name(shader->uniforms[texture_uniform].filter, shader->uniforms[texture_uniform].repeat);
|
||||
const ShaderLanguage::ShaderNode::Uniform &u = shader->uniforms[texture_uniform];
|
||||
if (u.hint == ShaderLanguage::ShaderNode::Uniform::HINT_SCREEN_TEXTURE) {
|
||||
is_screen_texture = true;
|
||||
} else if (u.hint == ShaderLanguage::ShaderNode::Uniform::HINT_NORMAL_ROUGHNESS_TEXTURE) {
|
||||
is_normal_roughness_texture = true;
|
||||
}
|
||||
sampler_name = _get_sampler_name(u.filter, u.repeat);
|
||||
} else {
|
||||
bool found = false;
|
||||
|
||||
@ -1287,7 +1281,7 @@ String ShaderCompiler::_dump_node_code(const SL::Node *p_node, int p_level, Gene
|
||||
}
|
||||
|
||||
String data_type_name = "";
|
||||
if (texture_uniform == "NORMAL_ROUGHNESS_TEXTURE") {
|
||||
if (is_normal_roughness_texture) {
|
||||
data_type_name = "multiviewSampler";
|
||||
normal_roughness_texture_used = true;
|
||||
} else {
|
||||
@ -1515,6 +1509,9 @@ Error ShaderCompiler::compile(RS::ShaderMode p_mode, const String &p_code, Ident
|
||||
r_gen_code.uses_vertex_time = false;
|
||||
r_gen_code.uses_global_textures = false;
|
||||
r_gen_code.uses_screen_texture_mipmaps = false;
|
||||
r_gen_code.uses_screen_texture = false;
|
||||
r_gen_code.uses_depth_texture = false;
|
||||
r_gen_code.uses_normal_roughness_texture = false;
|
||||
|
||||
used_name_defines.clear();
|
||||
used_rmode_defines.clear();
|
||||
|
||||
@ -81,6 +81,9 @@ public:
|
||||
bool uses_fragment_time;
|
||||
bool uses_vertex_time;
|
||||
bool uses_screen_texture_mipmaps;
|
||||
bool uses_screen_texture;
|
||||
bool uses_depth_texture;
|
||||
bool uses_normal_roughness_texture;
|
||||
};
|
||||
|
||||
struct DefaultIdentifierActions {
|
||||
|
||||
@ -5399,6 +5399,12 @@ ShaderLanguage::Node *ShaderLanguage::_parse_expression(BlockNode *p_block, cons
|
||||
}
|
||||
} else {
|
||||
if (!_find_identifier(p_block, false, p_function_info, identifier, &data_type, &ident_type, &is_const, &array_size, &struct_name)) {
|
||||
if (identifier == "SCREEN_TEXTURE" || identifier == "DEPTH_TEXTURE" || identifier == "NORMAL_ROUGHNESS_TEXTURE") {
|
||||
String name = String(identifier);
|
||||
String name_lower = name.to_lower();
|
||||
_set_error(vformat(RTR("%s has been removed in favor of using hint_%s with a uniform.\nTo continue with minimal code changes add 'uniform sampler2D %s : hint_%s, filter_linear_mipmaps;' near the top of your shader."), name, name_lower, name, name_lower));
|
||||
return nullptr;
|
||||
}
|
||||
_set_error(vformat(RTR("Unknown identifier in expression: '%s'."), String(identifier)));
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
@ -138,9 +138,6 @@ ShaderTypes::ShaderTypes() {
|
||||
shader_modes[RS::SHADER_SPATIAL].functions["fragment"].built_ins["AO"] = ShaderLanguage::TYPE_FLOAT;
|
||||
shader_modes[RS::SHADER_SPATIAL].functions["fragment"].built_ins["AO_LIGHT_AFFECT"] = ShaderLanguage::TYPE_FLOAT;
|
||||
shader_modes[RS::SHADER_SPATIAL].functions["fragment"].built_ins["EMISSION"] = ShaderLanguage::TYPE_VEC3;
|
||||
shader_modes[RS::SHADER_SPATIAL].functions["fragment"].built_ins["SCREEN_TEXTURE"] = constt(ShaderLanguage::TYPE_SAMPLER2D);
|
||||
shader_modes[RS::SHADER_SPATIAL].functions["fragment"].built_ins["NORMAL_ROUGHNESS_TEXTURE"] = constt(ShaderLanguage::TYPE_SAMPLER2D);
|
||||
shader_modes[RS::SHADER_SPATIAL].functions["fragment"].built_ins["DEPTH_TEXTURE"] = constt(ShaderLanguage::TYPE_SAMPLER2D);
|
||||
shader_modes[RS::SHADER_SPATIAL].functions["fragment"].built_ins["DEPTH"] = ShaderLanguage::TYPE_FLOAT;
|
||||
shader_modes[RS::SHADER_SPATIAL].functions["fragment"].built_ins["SCREEN_UV"] = constt(ShaderLanguage::TYPE_VEC2);
|
||||
shader_modes[RS::SHADER_SPATIAL].functions["fragment"].built_ins["POINT_COORD"] = constt(ShaderLanguage::TYPE_VEC2);
|
||||
@ -267,7 +264,6 @@ ShaderTypes::ShaderTypes() {
|
||||
shader_modes[RS::SHADER_CANVAS_ITEM].functions["fragment"].built_ins["SCREEN_PIXEL_SIZE"] = constt(ShaderLanguage::TYPE_VEC2);
|
||||
shader_modes[RS::SHADER_CANVAS_ITEM].functions["fragment"].built_ins["POINT_COORD"] = constt(ShaderLanguage::TYPE_VEC2);
|
||||
shader_modes[RS::SHADER_CANVAS_ITEM].functions["fragment"].built_ins["AT_LIGHT_PASS"] = constt(ShaderLanguage::TYPE_BOOL);
|
||||
shader_modes[RS::SHADER_CANVAS_ITEM].functions["fragment"].built_ins["SCREEN_TEXTURE"] = constt(ShaderLanguage::TYPE_SAMPLER2D);
|
||||
shader_modes[RS::SHADER_CANVAS_ITEM].functions["fragment"].can_discard = true;
|
||||
shader_modes[RS::SHADER_CANVAS_ITEM].functions["fragment"].main_function = true;
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user