maxmustermann/godot
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Changed TransformMult node to TransformOp in visual shaders

Browse source
This commit is contained in:
Yuri Roubinsky 2021-08-11 19:08:37 +03:00
parent 974cc68fb4
commit 9cf158019d
6 changed files with 128 additions and 68 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

32
doc/classes/VisualShaderNodeTransformMult.xml
View file

@ -1,32 +0,0 @@
<?xml version="1.0" encoding="UTF-8" ?>
<class name="VisualShaderNodeTransformMult" inherits="VisualShaderNode" version="4.0">
<brief_description>
Multiplies [Transform3D] by [Transform3D] within the visual shader graph.
</brief_description>
<description>
A multiplication operation on two transforms (4x4 matrices), with support for different multiplication operators.
</description>
<tutorials>
</tutorials>
<methods>
</methods>
<members>
<member name="operator" type="int" setter="set_operator" getter="get_operator" enum="VisualShaderNodeTransformMult.Operator" default="0">
The multiplication type to be performed on the transforms. See [enum Operator] for options.
</member>
</members>
<constants>
<constant name="OP_AxB" value="0" enum="Operator">
Multiplies transform [code]a[/code] by the transform [code]b[/code].
</constant>
<constant name="OP_BxA" value="1" enum="Operator">
Multiplies transform [code]b[/code] by the transform [code]a[/code].
</constant>
<constant name="OP_AxB_COMP" value="2" enum="Operator">
Performs a component-wise multiplication of transform [code]a[/code] by the transform [code]b[/code].
</constant>
<constant name="OP_BxA_COMP" value="3" enum="Operator">
Performs a component-wise multiplication of transform [code]b[/code] by the transform [code]a[/code].
</constant>
</constants>
</class>

50
doc/classes/VisualShaderNodeTransformOp.xml Normal file
View file

@ -0,0 +1,50 @@
<?xml version="1.0" encoding="UTF-8" ?>
<class name="VisualShaderNodeTransformOp" inherits="VisualShaderNode" version="4.0">
<brief_description>
A [Transform3D] operator to be used within the visual shader graph.
</brief_description>
<description>
Applies [member operator] to two transform (4x4 matrices) inputs.
</description>
<tutorials>
</tutorials>
<methods>
</methods>
<members>
<member name="operator" type="int" setter="set_operator" getter="get_operator" enum="VisualShaderNodeTransformOp.Operator" default="0">
The type of the operation to be performed on the transforms. See [enum Operator] for options.
</member>
</members>
<constants>
<constant name="OP_AxB" value="0" enum="Operator">
Multiplies transform [code]a[/code] by the transform [code]b[/code].
</constant>
<constant name="OP_BxA" value="1" enum="Operator">
Multiplies transform [code]b[/code] by the transform [code]a[/code].
</constant>
<constant name="OP_AxB_COMP" value="2" enum="Operator">
Performs a component-wise multiplication of transform [code]a[/code] by the transform [code]b[/code].
</constant>
<constant name="OP_BxA_COMP" value="3" enum="Operator">
Performs a component-wise multiplication of transform [code]b[/code] by the transform [code]a[/code].
</constant>
<constant name="OP_ADD" value="4" enum="Operator">
Adds two transforms.
</constant>
<constant name="OP_A_MINUS_B" value="5" enum="Operator">
Subtracts the transform [code]a[/code] from the transform [code]b[/code].
</constant>
<constant name="OP_B_MINUS_A" value="6" enum="Operator">
Subtracts the transform [code]b[/code] from the transform [code]a[/code].
</constant>
<constant name="OP_A_DIV_B" value="7" enum="Operator">
Divides the transform [code]a[/code] by the transform [code]b[/code].
</constant>
<constant name="OP_B_DIV_A" value="8" enum="Operator">
Divides the transform [code]b[/code] by the transform [code]a[/code].
</constant>
<constant name="OP_LIMITER" value="9" enum="Operator">
Represents the size of the [enum Operator] enum.
</constant>
</constants>
</class>

17
editor/plugins/visual_shader_editor_plugin.cpp
View file

@ -2172,6 +2172,16 @@ void VisualShaderEditor::_setup_node(VisualShaderNode *p_node, int p_op_idx) {
}
}
// TRANSFORM_OP
{
VisualShaderNodeTransformOp *matOp = Object::cast_to<VisualShaderNodeTransformOp>(p_node);
if (matOp) {
matOp->set_operator((VisualShaderNodeTransformOp::Operator)p_op_idx);
return;
}
}
// TRANSFORM_FUNC
{
VisualShaderNodeTransformFunc *matFunc = Object::cast_to<VisualShaderNodeTransformFunc>(p_node);
@ -4450,6 +4460,7 @@ VisualShaderEditor::VisualShaderEditor() {
// TRANSFORM
add_options.push_back(AddOption("TransformFunc", "Transform", "Common", "VisualShaderNodeTransformFunc", TTR("Transform function."), -1, VisualShaderNode::PORT_TYPE_TRANSFORM));
add_options.push_back(AddOption("TransformOp", "Transform", "Common", "VisualShaderNodeTransformOp", TTR("Transform operator."), -1, VisualShaderNode::PORT_TYPE_TRANSFORM));
add_options.push_back(AddOption("OuterProduct", "Transform", "Composition", "VisualShaderNodeOuterProduct", TTR("Calculate the outer product of a pair of vectors.\n\nOuterProduct treats the first parameter 'c' as a column vector (matrix with one column) and the second parameter 'r' as a row vector (matrix with one row) and does a linear algebraic matrix multiply 'c * r', yielding a matrix whose number of rows is the number of components in 'c' and whose number of columns is the number of components in 'r'."), -1, VisualShaderNode::PORT_TYPE_TRANSFORM));
add_options.push_back(AddOption("TransformCompose", "Transform", "Composition", "VisualShaderNodeTransformCompose", TTR("Composes transform from four vectors."), -1, VisualShaderNode::PORT_TYPE_TRANSFORM));
@ -4460,7 +4471,11 @@ VisualShaderEditor::VisualShaderEditor() {
add_options.push_back(AddOption("Inverse", "Transform", "Functions", "VisualShaderNodeTransformFunc", TTR("Calculates the inverse of a transform."), VisualShaderNodeTransformFunc::FUNC_INVERSE, VisualShaderNode::PORT_TYPE_TRANSFORM));
add_options.push_back(AddOption("Transpose", "Transform", "Functions", "VisualShaderNodeTransformFunc", TTR("Calculates the transpose of a transform."), VisualShaderNodeTransformFunc::FUNC_TRANSPOSE, VisualShaderNode::PORT_TYPE_TRANSFORM));
add_options.push_back(AddOption("TransformMult", "Transform", "Operators", "VisualShaderNodeTransformMult", TTR("Multiplies transform by transform."), -1, VisualShaderNode::PORT_TYPE_TRANSFORM));
add_options.push_back(AddOption("Add", "Transform", "Operators", "VisualShaderNodeTransformOp", TTR("Sums two transforms."), VisualShaderNodeTransformOp::OP_ADD, VisualShaderNode::PORT_TYPE_TRANSFORM));
add_options.push_back(AddOption("Divide", "Transform", "Operators", "VisualShaderNodeTransformOp", TTR("Divides two transforms."), VisualShaderNodeTransformOp::OP_A_DIV_B, VisualShaderNode::PORT_TYPE_TRANSFORM));
add_options.push_back(AddOption("Multiply", "Transform", "Operators", "VisualShaderNodeTransformOp", TTR("Multiplies two transforms."), VisualShaderNodeTransformOp::OP_AxB, VisualShaderNode::PORT_TYPE_TRANSFORM));
add_options.push_back(AddOption("MultiplyComp", "Transform", "Operators", "VisualShaderNodeTransformOp", TTR("Performs per-component multiplication of two transforms."), VisualShaderNodeTransformOp::OP_AxB_COMP, VisualShaderNode::PORT_TYPE_TRANSFORM));
add_options.push_back(AddOption("Subtract", "Transform", "Operators", "VisualShaderNodeTransformOp", TTR("Subtracts two transforms."), VisualShaderNodeTransformOp::OP_A_MINUS_B, VisualShaderNode::PORT_TYPE_TRANSFORM));
add_options.push_back(AddOption("TransformVectorMult", "Transform", "Operators", "VisualShaderNodeTransformVecMult", TTR("Multiplies vector by transform."), -1, VisualShaderNode::PORT_TYPE_VECTOR));
add_options.push_back(AddOption("TransformConstant", "Transform", "Variables", "VisualShaderNodeTransformConstant", TTR("Transform constant."), -1, VisualShaderNode::PORT_TYPE_TRANSFORM));

3
scene/register_scene_types.cpp
View file

@ -557,7 +557,7 @@ void register_scene_types() {
GDREGISTER_CLASS(VisualShaderNodeIntOp);
GDREGISTER_CLASS(VisualShaderNodeVectorOp);
GDREGISTER_CLASS(VisualShaderNodeColorOp);
GDREGISTER_CLASS(VisualShaderNodeTransformMult);
GDREGISTER_CLASS(VisualShaderNodeTransformOp);
GDREGISTER_CLASS(VisualShaderNodeTransformVecMult);
GDREGISTER_CLASS(VisualShaderNodeFloatFunc);
GDREGISTER_CLASS(VisualShaderNodeIntFunc);
@ -983,6 +983,7 @@ void register_scene_types() {
ClassDB::add_compatibility_class("VisualShaderNodeVectorScalarSmoothStep", "VisualShaderNodeSmoothStep");
ClassDB::add_compatibility_class("VisualShaderNodeVectorScalarStep", "VisualShaderNodeStep");
ClassDB::add_compatibility_class("VisualShaderNodeScalarSwitch", "VisualShaderNodeSwitch");
ClassDB::add_compatibility_class("VisualShaderNodeScalarTransformMult", "VisualShaderNodeTransformOp");
ClassDB::add_compatibility_class("World", "World3D");
ClassDB::add_compatibility_class("StreamTexture", "StreamTexture2D");
ClassDB::add_compatibility_class("Light2D", "PointLight2D");

72
scene/resources/visual_shader_nodes.cpp
View file

@ -1915,76 +1915,96 @@ VisualShaderNodeColorOp::VisualShaderNodeColorOp() {
set_input_port_default_value(1, Vector3());
}
////////////// Transform Mult
////////////// Transform Op
String VisualShaderNodeTransformMult::get_caption() const {
return "TransformMult";
String VisualShaderNodeTransformOp::get_caption() const {
return "TransformOp";
}
int VisualShaderNodeTransformMult::get_input_port_count() const {
int VisualShaderNodeTransformOp::get_input_port_count() const {
return 2;
}
VisualShaderNodeTransformMult::PortType VisualShaderNodeTransformMult::get_input_port_type(int p_port) const {
VisualShaderNodeTransformOp::PortType VisualShaderNodeTransformOp::get_input_port_type(int p_port) const {
return PORT_TYPE_TRANSFORM;
}
String VisualShaderNodeTransformMult::get_input_port_name(int p_port) const {
String VisualShaderNodeTransformOp::get_input_port_name(int p_port) const {
return p_port == 0 ? "a" : "b";
}
int VisualShaderNodeTransformMult::get_output_port_count() const {
int VisualShaderNodeTransformOp::get_output_port_count() const {
return 1;
}
VisualShaderNodeTransformMult::PortType VisualShaderNodeTransformMult::get_output_port_type(int p_port) const {
VisualShaderNodeTransformOp::PortType VisualShaderNodeTransformOp::get_output_port_type(int p_port) const {
return PORT_TYPE_TRANSFORM;
}
String VisualShaderNodeTransformMult::get_output_port_name(int p_port) const {
String VisualShaderNodeTransformOp::get_output_port_name(int p_port) const {
return "mult"; //no output port means the editor will be used as port
}
String VisualShaderNodeTransformMult::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 {
if (op == OP_AxB) {
return " " + p_output_vars[0] + " = " + p_input_vars[0] + " * " + p_input_vars[1] + ";\n";
} else if (op == OP_BxA) {
return " " + p_output_vars[0] + " = " + p_input_vars[1] + " * " + p_input_vars[0] + ";\n";
} else if (op == OP_AxB_COMP) {
return " " + p_output_vars[0] + " = matrixCompMult(" + p_input_vars[0] + ", " + p_input_vars[1] + ");\n";
} else {
return " " + p_output_vars[0] + " = matrixCompMult(" + p_input_vars[1] + ", " + p_input_vars[0] + ");\n";
String VisualShaderNodeTransformOp::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 {
switch (op) {
case OP_AxB:
return " " + p_output_vars[0] + " = " + p_input_vars[0] + " * " + p_input_vars[1] + ";\n";
case OP_BxA:
return " " + p_output_vars[0] + " = " + p_input_vars[1] + " * " + p_input_vars[0] + ";\n";
case OP_AxB_COMP:
return " " + p_output_vars[0] + " = matrixCompMult(" + p_input_vars[0] + ", " + p_input_vars[1] + ");\n";
case OP_BxA_COMP:
return " " + p_output_vars[0] + " = matrixCompMult(" + p_input_vars[1] + ", " + p_input_vars[0] + ");\n";
case OP_ADD:
return " " + p_output_vars[0] + " = " + p_input_vars[0] + " + " + p_input_vars[1] + ";\n";
case OP_A_MINUS_B:
return " " + p_output_vars[0] + " = " + p_input_vars[0] + " - " + p_input_vars[1] + ";\n";
case OP_B_MINUS_A:
return " " + p_output_vars[0] + " = " + p_input_vars[1] + " - " + p_input_vars[0] + ";\n";
case OP_A_DIV_B:
return " " + p_output_vars[0] + " = " + p_input_vars[0] + " / " + p_input_vars[1] + ";\n";
case OP_B_DIV_A:
return " " + p_output_vars[0] + " = " + p_input_vars[1] + " / " + p_input_vars[0] + ";\n";
default:
return "";
}
}
void VisualShaderNodeTransformMult::set_operator(Operator p_op) {
void VisualShaderNodeTransformOp::set_operator(Operator p_op) {
ERR_FAIL_INDEX(int(p_op), int(OP_LIMITER));
op = p_op;
emit_changed();
}
VisualShaderNodeTransformMult::Operator VisualShaderNodeTransformMult::get_operator() const {
VisualShaderNodeTransformOp::Operator VisualShaderNodeTransformOp::get_operator() const {
return op;
}
Vector<StringName> VisualShaderNodeTransformMult::get_editable_properties() const {
Vector<StringName> VisualShaderNodeTransformOp::get_editable_properties() const {
Vector<StringName> props;
props.push_back("operator");
return props;
}
void VisualShaderNodeTransformMult::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_operator", "op"), &VisualShaderNodeTransformMult::set_operator);
ClassDB::bind_method(D_METHOD("get_operator"), &VisualShaderNodeTransformMult::get_operator);
void VisualShaderNodeTransformOp::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_operator", "op"), &VisualShaderNodeTransformOp::set_operator);
ClassDB::bind_method(D_METHOD("get_operator"), &VisualShaderNodeTransformOp::get_operator);
ADD_PROPERTY(PropertyInfo(Variant::INT, "operator", PROPERTY_HINT_ENUM, "A x B,B x A,A x B(per component),B x A(per component)"), "set_operator", "get_operator");
ADD_PROPERTY(PropertyInfo(Variant::INT, "operator", PROPERTY_HINT_ENUM, "A x B,B x A,A x B(per component),B x A(per component),A + B,A - B,B - A,A / B,B / A"), "set_operator", "get_operator");
BIND_ENUM_CONSTANT(OP_AxB);
BIND_ENUM_CONSTANT(OP_BxA);
BIND_ENUM_CONSTANT(OP_AxB_COMP);
BIND_ENUM_CONSTANT(OP_BxA_COMP);
BIND_ENUM_CONSTANT(OP_ADD);
BIND_ENUM_CONSTANT(OP_A_MINUS_B);
BIND_ENUM_CONSTANT(OP_B_MINUS_A);
BIND_ENUM_CONSTANT(OP_A_DIV_B);
BIND_ENUM_CONSTANT(OP_B_DIV_A);
BIND_ENUM_CONSTANT(OP_LIMITER);
}
VisualShaderNodeTransformMult::VisualShaderNodeTransformMult() {
VisualShaderNodeTransformOp::VisualShaderNodeTransformOp() {
set_input_port_default_value(0, Transform3D());
set_input_port_default_value(1, Transform3D());
}

22
scene/resources/visual_shader_nodes.h
View file

@ -696,19 +696,25 @@ public:
VARIANT_ENUM_CAST(VisualShaderNodeColorOp::Operator)
///////////////////////////////////////
/// TRANSFORM-TRANSFORM MULTIPLICATION
///////////////////////////////////////
////////////////////////////////
/// TRANSFORM-TRANSFORM OPERATOR
////////////////////////////////
class VisualShaderNodeTransformMult : public VisualShaderNode {
GDCLASS(VisualShaderNodeTransformMult, VisualShaderNode);
class VisualShaderNodeTransformOp : public VisualShaderNode {
GDCLASS(VisualShaderNodeTransformOp, VisualShaderNode);
public:
enum Operator {
OP_AxB,
OP_BxA,
OP_AxB_COMP,
OP_BxA_COMP
OP_BxA_COMP,
OP_ADD,
OP_A_MINUS_B,
OP_B_MINUS_A,
OP_A_DIV_B,
OP_B_DIV_A,
OP_LIMITER,
};
protected:
@ -734,10 +740,10 @@ public:
virtual Vector<StringName> get_editable_properties() const override;
VisualShaderNodeTransformMult();
VisualShaderNodeTransformOp();
};
VARIANT_ENUM_CAST(VisualShaderNodeTransformMult::Operator)
VARIANT_ENUM_CAST(VisualShaderNodeTransformOp::Operator)
///////////////////////////////////////
/// TRANSFORM-VECTOR MULTIPLICATION