Return single value from operation nodes when all of the inputs are single.

Author: kovacsv

Sources/BuiltInNodes/BI_BinaryOperationNodes.cpp

@@ -45,23 +45,25 @@ NE::ValueConstPtr BinaryOperationNode::Calculate (NE::EvaluationEnv& env) const
 		return nullptr;
 	}
 
-	NE::ListValuePtr resultListValue (new NE::ListValue ());
-	std::shared_ptr<ValueCombinationFeature> valueCombination = GetValueCombinationFeature (this);
-	bool isValid = valueCombination->CombineValues ({aValue, bValue}, [&] (const NE::ValueCombination& combination) {
-		double aDouble = NE::NumberValue::ToDouble (combination.GetValue (0));
-		double bDouble = NE::NumberValue::ToDouble (combination.GetValue (1));
-		double result = DoOperation (aDouble, bDouble);
-		if (std::isnan (result) || std::isinf (result)) {
-			return false;
+	if (NE::IsSingleValue (aValue) && NE::IsSingleValue (bValue)) {
+		NE::ValuePtr result = DoSingleOperation (aValue, bValue);
+		return result;
+	} else {
+		NE::ListValuePtr resultListValue (new NE::ListValue ());
+		std::shared_ptr<ValueCombinationFeature> valueCombination = GetValueCombinationFeature (this);
+		bool isValid = valueCombination->CombineValues ({ aValue, bValue }, [&] (const NE::ValueCombination& combination) {
+			NE::ValuePtr result = DoSingleOperation (combination.GetValue (0), combination.GetValue (1));
+			if (result == nullptr) {
+				return false;
+			}
+			resultListValue->Push (result);
+			return true;
+		});
+		if (!isValid) {
+			return nullptr;
 		}
-		resultListValue->Push (NE::ValuePtr (new NE::DoubleValue (result)));
-		return true;
-	});
-
-	if (!isValid) {
-		return nullptr;
+		return resultListValue;
 	}
-	return resultListValue;
 }
 
 void BinaryOperationNode::RegisterParameters (NUIE::NodeParameterList& parameterList) const
@@ -90,6 +92,17 @@ NE::Stream::Status BinaryOperationNode::Write (NE::OutputStream& outputStream) c
 	return outputStream.GetStatus ();
 }
 
+NE::ValuePtr BinaryOperationNode::DoSingleOperation (const NE::ValueConstPtr& aValue, const NE::ValueConstPtr& bValue) const
+{
+	double aDouble = NE::NumberValue::ToDouble (aValue);
+	double bDouble = NE::NumberValue::ToDouble (bValue);
+	double result = DoOperation (aDouble, bDouble);
+	if (std::isnan (result) || std::isinf (result)) {
+		return nullptr;
+	}
+	return NE::ValuePtr (new NE::DoubleValue (result));
+}
+
 AdditionNode::AdditionNode () :
 	BinaryOperationNode ()
 {

Sources/BuiltInNodes/BI_BinaryOperationNodes.hpp

@@ -27,6 +27,7 @@ class BinaryOperationNode : public BasicUINode
 	virtual NE::Stream::Status	Write (NE::OutputStream& outputStream) const override;
 
 private:
+	NE::ValuePtr				DoSingleOperation (const NE::ValueConstPtr& aValue, const NE::ValueConstPtr& bValue) const;
 	virtual double				DoOperation (double a, double b) const = 0;
 };
 

Sources/NodeEngine/NE_Value.cpp

@@ -188,6 +188,16 @@ void ValueToListValueAdapter::Enumerate (const std::function<void (const ValueCo
 	processor (val);
 }
 
+bool IsSingleValue (const ValueConstPtr& value)
+{
+	return Value::IsType<SingleValue> (value);
+}
+
+bool IsListValue (const ValueConstPtr& value)
+{
+	return Value::IsType<ListValue> (value);
+}
+
 ValueConstPtr CreateSingleValue (const ValueConstPtr& value)
 {
 	if (Value::IsType<SingleValue> (value)) {

Sources/NodeEngine/NE_Value.hpp

@@ -205,8 +205,12 @@ bool IsComplexType (const ValueConstPtr& val)
 	return false;
 }
 
+bool				IsSingleValue (const ValueConstPtr& value);
+bool				IsListValue (const ValueConstPtr& value);
+
 ValueConstPtr		CreateSingleValue (const ValueConstPtr& value);
 IListValueConstPtr	CreateListValue (const ValueConstPtr& value);
+
 void				FlatEnumerate (const ValueConstPtr& value, const std::function<void (const ValueConstPtr&)>& processor);
 ValueConstPtr		FlattenValue (const ValueConstPtr& value);
 

Sources/NodeEngineTest/BinaryOperationNodesTest.cpp

@@ -27,6 +27,26 @@ TEST (TestAdditionNode)
 	ASSERT (IsEqual (DoubleValue::Get (CreateSingleValue (val)), 3.0));
 }
 
+TEST (TestAdditionNodeWithList)
+{
+	TestUIEnvironment env;
+	NodeUIManager uiManager (env);
+
+	UINodePtr val1 = uiManager.AddNode (UINodePtr (new DoubleIncrementedNode (LocString (L"Value1"), Point (0, 0))), EmptyEvaluationEnv);
+	UINodePtr val2 = uiManager.AddNode (UINodePtr (new DoubleIncrementedNode (LocString (L"Value2"), Point (0, 0))), EmptyEvaluationEnv);
+	UINodePtr op = uiManager.AddNode (UINodePtr (new AdditionNode (LocString (L"Addition"), Point (0, 0))), EmptyEvaluationEnv);
+	uiManager.ConnectOutputSlotToInputSlot (val1->GetUIOutputSlot (SlotId ("out")), op->GetUIInputSlot (SlotId ("a")));
+	uiManager.ConnectOutputSlotToInputSlot (val2->GetUIOutputSlot (SlotId ("out")), op->GetUIInputSlot (SlotId ("b")));
+
+	ValueConstPtr val = op->Evaluate (EmptyEvaluationEnv);
+	ASSERT (Value::IsType<ListValue> (val));
+	std::vector<double> values;
+	FlatEnumerate (val, [&] (const ValueConstPtr& v) {
+		values.push_back (NumberValue::ToDouble (v));
+	});
+	ASSERT (values == std::vector<double> ({ 0.0, 2.0, 4.0, 6.0, 8.0, 10.0, 12.0, 14.0, 16.0, 18.0 }));
+}
+
 TEST (TestSubtractionNode)
 {
 	TestUIEnvironment env;

Sources/NodeEngineTest/ValueTest.cpp

@@ -87,6 +87,8 @@ TEST (ValueTest)
 {
 	IntValue intValue (5);
 	ValuePtr intValuePtr (new IntValue (6));
+	ASSERT (IsSingleValue (intValuePtr));
+	ASSERT (!IsListValue (intValuePtr));
 	ASSERT (Value::IsType<NumberValue> (&intValue));
 	ASSERT (Value::IsType<IntValue> (&intValue));
 	ASSERT (Value::IsType<IntValue> (intValuePtr));
@@ -100,6 +102,13 @@ TEST (ValueTest)
 	ASSERT (NumberValue::ToDouble (intValuePtr) == 6.0);
 }
 
+TEST (ListValueTest)
+{
+	ValuePtr listValue (new ListValue ());
+	ASSERT (!IsSingleValue (listValue));
+	ASSERT (IsListValue (listValue));
+}
+
 TEST (BooleanValueTest)
 {
 	BooleanValue val (true);