// // Created by martin on 04.02.22. // #include "ozz/base/io/archive.h" #include "ozz/base/io/stream.h" #include "ozz/base/log.h" #include "AnimGraph/AnimGraph.h" #include "AnimGraph/AnimGraphEditor.h" #include "AnimGraph/AnimGraphResource.h" #include "catch.hpp" bool load_skeleton (ozz::animation::Skeleton& skeleton, const char* filename) { assert(filename); ozz::io::File file(filename, "rb"); if (!file.opened()) { ozz::log::Err() << "Failed to open skeleton file " << filename << "." << std::endl; return false; } ozz::io::IArchive archive(&file); if (!archive.TestTag()) { ozz::log::Err() << "Failed to load skeleton instance from file " << filename << "." << std::endl; return false; } // Once the tag is validated, reading cannot fail. archive >> skeleton; return true; } TEST_CASE("BasicGraph", "[AnimGraphResource]") { AnimGraphResource graph_resource; graph_resource.clear(); graph_resource.m_name = "WalkRunBlendGraph"; // Prepare graph inputs and outputs size_t walk_node_index = graph_resource.addNode(AnimNodeResourceFactory("AnimSampler")); size_t run_node_index = graph_resource.addNode(AnimNodeResourceFactory("AnimSampler")); size_t blend_node_index = graph_resource.addNode(AnimNodeResourceFactory("Blend2")); AnimNodeResource& walk_node = graph_resource.m_nodes[walk_node_index]; walk_node.m_name = "WalkAnim"; walk_node.m_socket_accessor->SetPropertyValue("Filename", "data/walk.anim.ozz"); AnimNodeResource& run_node = graph_resource.m_nodes[run_node_index]; run_node.m_socket_accessor->SetPropertyValue("Filename", "data/run.anim.ozz"); run_node.m_name = "RunAnim"; AnimNodeResource& blend_node = graph_resource.m_nodes[blend_node_index]; blend_node.m_name = "BlendWalkRun"; AnimNodeResource& graph_node = graph_resource.m_nodes[0]; graph_node.m_socket_accessor->RegisterInput("GraphOutput", nullptr); REQUIRE(graph_node.m_socket_accessor->m_inputs.size() == 1); REQUIRE(blend_node.m_socket_accessor->GetInputIndex("Input0") == 0); REQUIRE(blend_node.m_socket_accessor->GetInputIndex("Input1") == 1); graph_resource.connectSockets(walk_node, "Output", blend_node, "Input0"); graph_resource.connectSockets(run_node, "Output", blend_node, "Input1"); graph_resource.connectSockets( blend_node, "Output", graph_resource.getGraphOutputNode(), "GraphOutput"); graph_resource.saveToFile("WalkGraph.animgraph.json"); AnimGraphResource graph_resource_loaded; graph_resource_loaded.loadFromFile("WalkGraph.animgraph.json"); AnimGraph graph = graph_resource_loaded.createInstance(); AnimGraphContext graph_context; graph_context.m_graph = &graph; ozz::animation::Skeleton skeleton; REQUIRE(load_skeleton(skeleton, "data/skeleton.ozz")); graph_context.m_skeleton = &skeleton; REQUIRE(graph.init(graph_context)); REQUIRE(graph.m_nodes.size() == 5); REQUIRE(graph.m_nodes[0]->m_node_type_name == "BlendTree"); REQUIRE(graph.m_nodes[1]->m_node_type_name == "BlendTree"); REQUIRE(graph.m_nodes[2]->m_node_type_name == "AnimSampler"); REQUIRE(graph.m_nodes[3]->m_node_type_name == "AnimSampler"); REQUIRE(graph.m_nodes[4]->m_node_type_name == "Blend2"); // connections within the graph AnimSamplerNode* anim_sampler_walk = dynamic_cast(graph.m_nodes[2]); AnimSamplerNode* anim_sampler_run = dynamic_cast(graph.m_nodes[3]); Blend2Node* blend2_instance = dynamic_cast(graph.m_nodes[4]); // check node input dependencies size_t anim_sampler_index0 = anim_sampler_walk->m_index; size_t anim_sampler_index1 = anim_sampler_run->m_index; size_t blend_index = blend2_instance->m_index; REQUIRE(graph.m_node_input_connections[blend_index].size() == 2); CHECK( graph.m_node_input_connections[blend_index][0].m_source_node == anim_sampler_walk); CHECK( graph.m_node_input_connections[blend_index][1].m_source_node == anim_sampler_run); REQUIRE(graph.m_node_output_connections[anim_sampler_index0].size() == 1); CHECK( graph.m_node_output_connections[anim_sampler_index0][0].m_target_node == blend2_instance); REQUIRE(graph.m_node_output_connections[anim_sampler_index1].size() == 1); CHECK( graph.m_node_output_connections[anim_sampler_index1][0].m_target_node == blend2_instance); // Ensure animation sampler nodes use the correct files REQUIRE(anim_sampler_walk->m_filename == "data/walk.anim.ozz"); REQUIRE(anim_sampler_walk->m_animation != nullptr); REQUIRE(anim_sampler_run->m_filename == "data/run.anim.ozz"); REQUIRE(anim_sampler_run->m_animation != nullptr); WHEN("Emulating Graph Evaluation") { CHECK(graph.m_anim_data_allocator.size() == 0); graph.prepareNodeEval(graph_context, walk_node_index); graph.finishNodeEval(walk_node_index); CHECK(graph.m_anim_data_allocator.m_num_allocations == 1); CHECK(graph.m_anim_data_allocator.size() == 0); graph.prepareNodeEval(graph_context, run_node_index); graph.finishNodeEval(run_node_index); CHECK(graph.m_anim_data_allocator.m_num_allocations == 2); CHECK(graph.m_anim_data_allocator.size() == 0); graph.prepareNodeEval(graph_context, blend_node_index); CHECK(blend2_instance->i_input0 == anim_sampler_walk->o_output); CHECK(blend2_instance->i_input1 == anim_sampler_run->o_output); CHECK(graph.m_anim_data_allocator.m_num_allocations == 3); CHECK(graph.m_anim_data_allocator.size() == 0); graph.finishNodeEval(blend_node_index); CHECK(anim_sampler_walk->o_output == nullptr); CHECK(anim_sampler_run->o_output == nullptr); CHECK(graph.m_anim_data_allocator.m_num_allocations == 3); CHECK(graph.m_anim_data_allocator.size() == 2); // Evaluate output node. graph.evalOutputNode(); graph.finishNodeEval(0); const Socket* graph_output_socket = graph.getOutputSocket("GraphOutput"); AnimData* graph_output = static_cast(graph_output_socket->m_reference.ptr); CHECK(graph_output->m_local_matrices.size() == graph_context.m_skeleton->num_soa_joints()); CHECK(graph.m_anim_data_allocator.m_num_allocations == 3); CHECK(graph.m_anim_data_allocator.size() == 3); CHECK(blend2_instance->o_output == nullptr); } graph_context.freeAnimations(); } TEST_CASE("InputAttributeConversion", "[AnimGraphResource]") { int node_id = 3321; int input_index = 221; int output_index = 125; int parsed_node_id; int parsed_input_index; int parsed_output_index; int attribute_id = GenerateInputAttributeId(node_id, input_index); SplitInputAttributeId(attribute_id, &parsed_node_id, &parsed_input_index); CHECK(node_id == parsed_node_id); CHECK(input_index == parsed_input_index); attribute_id = GenerateOutputAttributeId(node_id, output_index); SplitOutputAttributeId(attribute_id, &parsed_node_id, &parsed_output_index); CHECK(node_id == parsed_node_id); CHECK(output_index == parsed_output_index); } TEST_CASE("ResourceSaveLoadMathGraphInputs", "[AnimGraphResource]") { AnimGraphResource graph_resource_origin; graph_resource_origin.clear(); graph_resource_origin.m_name = "TestInputOutputGraph"; size_t float_to_vec3_node_index = graph_resource_origin.addNode( AnimNodeResourceFactory("MathFloatToVec3Node")); AnimNodeResource& graph_output_node = graph_resource_origin.getGraphOutputNode(); graph_output_node.m_socket_accessor->RegisterInput( "GraphFloatOutput", nullptr); graph_output_node.m_socket_accessor->RegisterInput( "GraphVec3Output", nullptr); AnimNodeResource& graph_input_node = graph_resource_origin.getGraphInputNode(); graph_input_node.m_socket_accessor->RegisterOutput( "GraphFloatInput", nullptr); // Prepare graph inputs and outputs AnimNodeResource& float_to_vec3_node = graph_resource_origin.m_nodes[float_to_vec3_node_index]; REQUIRE(graph_resource_origin.connectSockets( graph_input_node, "GraphFloatInput", graph_output_node, "GraphFloatOutput")); REQUIRE(graph_resource_origin.connectSockets( graph_input_node, "GraphFloatInput", float_to_vec3_node, "Input0")); REQUIRE(graph_resource_origin.connectSockets( graph_input_node, "GraphFloatInput", float_to_vec3_node, "Input1")); REQUIRE(graph_resource_origin.connectSockets( graph_input_node, "GraphFloatInput", float_to_vec3_node, "Input2")); REQUIRE(graph_resource_origin.connectSockets( float_to_vec3_node, "Output", graph_output_node, "GraphVec3Output")); WHEN("Saving and loading graph resource") { const char* filename = "ResourceSaveLoadGraphInputs.json"; graph_resource_origin.saveToFile(filename); AnimGraphResource graph_resource_loaded; graph_resource_loaded.loadFromFile(filename); const AnimNodeResource& graph_loaded_output_node = graph_resource_loaded.m_nodes[0]; const AnimNodeResource& graph_loaded_input_node = graph_resource_loaded.m_nodes[1]; THEN("Graph inputs and outputs must be in loaded resource as well.") { REQUIRE( graph_output_node.m_socket_accessor->m_inputs.size() == graph_loaded_output_node.m_socket_accessor->m_inputs.size()); REQUIRE( graph_input_node.m_socket_accessor->m_outputs.size() == graph_loaded_input_node.m_socket_accessor->m_outputs.size()); REQUIRE( graph_loaded_input_node.m_socket_accessor->FindOutputSocket( "GraphFloatInput") != nullptr); REQUIRE( graph_loaded_output_node.m_socket_accessor->FindInputSocket( "GraphFloatOutput") != nullptr); REQUIRE( graph_loaded_output_node.m_socket_accessor->FindInputSocket( "GraphVec3Output") != nullptr); WHEN("Instantiating an AnimGraph") { AnimGraph anim_graph = graph_resource_loaded.createInstance(); REQUIRE(anim_graph.getInputSocket("GraphFloatInput") != nullptr); REQUIRE( anim_graph.getInputPtr("GraphFloatInput") == anim_graph.m_input_buffer); float* graph_float_input = nullptr; graph_float_input = static_cast(anim_graph.getInputPtr("GraphFloatInput")); *graph_float_input = 123.456f; AND_WHEN("Evaluating Graph") { AnimGraphContext context; context.m_graph = &anim_graph; anim_graph.updateTime(0.f); anim_graph.evaluate(context); Socket* float_output_socket = anim_graph.getOutputSocket("GraphFloatOutput"); Socket* vec3_output_socket = anim_graph.getOutputSocket("GraphVec3Output"); Vec3& vec3_output = *static_cast(vec3_output_socket->m_reference.ptr); THEN("output vector components equal the graph input vaulues") { CHECK(vec3_output[0] == *graph_float_input); CHECK(vec3_output[1] == *graph_float_input); CHECK(vec3_output[2] == *graph_float_input); } context.freeAnimations(); } } } } } TEST_CASE("SimpleMathEvaluations", "[AnimGraphResource]") { AnimGraphResource graph_resource_origin; graph_resource_origin.clear(); graph_resource_origin.m_name = "TestInputOutputGraph"; size_t math_add0_node_index = graph_resource_origin.addNode(AnimNodeResourceFactory("MathAddNode")); size_t math_add1_node_index = graph_resource_origin.addNode(AnimNodeResourceFactory("MathAddNode")); AnimNodeResource& graph_output_node = graph_resource_origin.getGraphOutputNode(); graph_output_node.m_socket_accessor->RegisterInput( "GraphFloat0Output", nullptr); graph_output_node.m_socket_accessor->RegisterInput( "GraphFloat1Output", nullptr); graph_output_node.m_socket_accessor->RegisterInput( "GraphFloat2Output", nullptr); AnimNodeResource& graph_input_node = graph_resource_origin.getGraphInputNode(); graph_input_node.m_socket_accessor->RegisterOutput( "GraphFloatInput", nullptr); // Prepare graph inputs and outputs AnimNodeResource& math_add0_node = graph_resource_origin.m_nodes[math_add0_node_index]; AnimNodeResource& math_add1_node = graph_resource_origin.m_nodes[math_add1_node_index]; // direct output REQUIRE(graph_resource_origin.connectSockets( graph_input_node, "GraphFloatInput", graph_output_node, "GraphFloat0Output")); // add0 node REQUIRE(graph_resource_origin.connectSockets( graph_input_node, "GraphFloatInput", math_add0_node, "Input0")); REQUIRE(graph_resource_origin.connectSockets( graph_input_node, "GraphFloatInput", math_add0_node, "Input1")); REQUIRE(graph_resource_origin.connectSockets( math_add0_node, "Output", graph_output_node, "GraphFloat1Output")); // add1 node REQUIRE(graph_resource_origin.connectSockets( math_add0_node, "Output", math_add1_node, "Input0")); REQUIRE(graph_resource_origin.connectSockets( graph_input_node, "GraphFloatInput", math_add1_node, "Input1")); REQUIRE(graph_resource_origin.connectSockets( math_add1_node, "Output", graph_output_node, "GraphFloat2Output")); WHEN("Saving and loading graph resource") { const char* filename = "ResourceSaveLoadGraphInputs.json"; graph_resource_origin.saveToFile(filename); AnimGraphResource graph_resource_loaded; graph_resource_loaded.loadFromFile(filename); const AnimNodeResource& graph_loaded_output_node = graph_resource_loaded.m_nodes[0]; const AnimNodeResource& graph_loaded_input_node = graph_resource_loaded.m_nodes[1]; WHEN("Instantiating an AnimGraph") { AnimGraph anim_graph = graph_resource_loaded.createInstance(); REQUIRE(anim_graph.getInputSocket("GraphFloatInput") != nullptr); REQUIRE( anim_graph.getInputPtr("GraphFloatInput") == anim_graph.m_input_buffer); float* graph_float_input = nullptr; graph_float_input = static_cast(anim_graph.getInputPtr("GraphFloatInput")); *graph_float_input = 123.456f; AND_WHEN("Evaluating Graph") { AnimGraphContext context; context.m_graph = &anim_graph; anim_graph.updateTime(0.f); anim_graph.evaluate(context); Socket* float0_output_socket = anim_graph.getOutputSocket("GraphFloat0Output"); Socket* float1_output_socket = anim_graph.getOutputSocket("GraphFloat1Output"); Socket* float2_output_socket = anim_graph.getOutputSocket("GraphFloat2Output"); REQUIRE(float0_output_socket != nullptr); REQUIRE(float1_output_socket != nullptr); REQUIRE(float2_output_socket != nullptr); float& float0_output = *static_cast(float0_output_socket->m_reference.ptr); float& float1_output = *static_cast(float1_output_socket->m_reference.ptr); float& float2_output = *static_cast(float2_output_socket->m_reference.ptr); THEN("output vector components equal the graph input vaulues") { CHECK(float0_output == Approx(*graph_float_input)); CHECK(float1_output == Approx(*graph_float_input * 2.)); CHECK(float2_output == Approx(*graph_float_input * 3.)); } context.freeAnimations(); } } } } /* WHEN("Connecting input to output and instantiating the graph") { AnimNodeResource& graph_output_node = graph_resource_origin.m_nodes[0]; AnimNodeResource& graph_input_node = graph_resource_origin.m_nodes[1]; REQUIRE(graph_resource_origin.connectSockets( graph_input_node, "GraphAnimInput", graph_output_node, "GraphOutput")); AnimGraph anim_graph = graph_resource_origin.createInstance(); void* graph_anim_input_ptr = anim_graph.getInput("GraphAnimInput"); void* graph_output_ptr = anim_graph.getOutput("GraphOutput"); REQUIRE(graph_anim_input_ptr == graph_output_ptr); REQUIRE(graph_output_ptr == anim_graph.m_output_buffer); REQUIRE( anim_graph.getInput("GraphAnimInput") == anim_graph.getOutput("GraphOutput")); } } TEST_CASE("GraphInputOutputConnectivity", "[AnimGraphResource]") { AnimGraphResource graph_resource; graph_resource.clear(); graph_resource.m_name = "TestGraphInputOutputConnectivity"; AnimNodeResource& graph_output_node = graph_resource.m_nodes[0]; graph_output_node.m_socket_accessor->RegisterInput( "GraphFloatOutput", nullptr); graph_output_node.m_socket_accessor->RegisterInput( "GraphAnimOutput", nullptr); AnimNodeResource& graph_input_node = graph_resource.m_nodes[1]; graph_input_node.m_socket_accessor->RegisterOutput( "GraphFloatInput", nullptr); graph_input_node.m_socket_accessor->RegisterOutput( "SpeedScaleInput", nullptr); graph_input_node.m_socket_accessor->RegisterOutput( "GraphAnimInput0", nullptr); graph_input_node.m_socket_accessor->RegisterOutput( "GraphAnimInput1", nullptr); WHEN("Connecting float input with float output") { REQUIRE(graph_resource.connectSockets( graph_resource.getGraphInputNode(), "GraphFloatInput", graph_resource.getGraphOutputNode(), "GraphFloatOutput")); AnimGraph anim_graph = graph_resource.createInstance(); THEN("Writing to the input pointer changes the value of the output.") { float* float_input_ptr = (float*)anim_graph.getInput("GraphFloatInput"); REQUIRE(float_input_ptr != nullptr); *float_input_ptr = 23.123f; float* float_output_ptr = (float*)anim_graph.getOutput("GraphFloatOutput"); REQUIRE(float_output_ptr != nullptr); CHECK(*float_output_ptr == Approx(23.123f)); } } WHEN("Connecting adding a Blend2 node") { size_t blend2_node_index = graph_resource.addNode(AnimNodeResourceFactory("Blend2")); AnimNodeResource& blend2_node_resource = graph_resource.m_nodes[blend2_node_index]; REQUIRE(graph_resource.connectSockets( graph_resource.getGraphInputNode(), "GraphFloatInput", blend2_node_resource, "Weight")); THEN("Connected float input points to the blend weight.") { AnimGraph anim_graph = graph_resource.createInstance(); Blend2Node* blend2_node = dynamic_cast(anim_graph.m_nodes[blend2_node_index]); REQUIRE( *anim_graph.m_socket_accessor->m_outputs[0].m_reference.ptr_ptr == blend2_node->i_blend_weight); float* float_input_ptr = (float*)anim_graph.getInput("GraphFloatInput"); REQUIRE(float_input_ptr == blend2_node->i_blend_weight); } WHEN( "Connecting AnimData inputs to blend2 node and blend2 output to graph " "output.") { REQUIRE(graph_resource.connectSockets( graph_resource.getGraphInputNode(), "GraphAnimInput0", blend2_node_resource, "Input0")); REQUIRE(graph_resource.connectSockets( graph_resource.getGraphInputNode(), "GraphAnimInput1", blend2_node_resource, "Input1")); REQUIRE(graph_resource.connectSockets( blend2_node_resource, "Output", graph_resource.getGraphOutputNode(), "GraphAnimOutput")); THEN( "AnimData from output gets blended and result is written to " "Output.") { AnimGraph anim_graph = graph_resource.createInstance(); Blend2Node* blend2_node = dynamic_cast(anim_graph.m_nodes[blend2_node_index]); AnimData* graph_input0 = (AnimData*)anim_graph.getInput("GraphAnimInput0"); REQUIRE(graph_input0 == blend2_node->i_input0); REQUIRE( anim_graph.m_nodes[1] == anim_graph.getAnimNodeForInput(blend2_node_index, "Input0")); AnimData* graph_input1 = (AnimData*)anim_graph.getInput("GraphAnimInput1"); REQUIRE(graph_input1 == blend2_node->i_input1); REQUIRE( anim_graph.m_nodes[1] == anim_graph.getAnimNodeForInput(blend2_node_index, "Input1")); AnimData* graph_output = (AnimData*)anim_graph.getOutput("GraphAnimOutput"); REQUIRE(graph_output == blend2_node->o_output); REQUIRE( anim_graph.m_nodes[blend2_node_index] == anim_graph.getAnimNodeForInput(0, "GraphAnimOutput")); } } } WHEN("Adding AnimSampler Nodes") { size_t blend2_node_index = graph_resource.addNode(AnimNodeResourceFactory("Blend2")); size_t sampler_node_index = graph_resource.addNode(AnimNodeResourceFactory("AnimSampler")); size_t speed_scale_node_index = graph_resource.addNode(AnimNodeResourceFactory("SpeedScale")); AnimNodeResource& blend2_node_resource = graph_resource.m_nodes[blend2_node_index]; AnimNodeResource& sampler_node_resource = graph_resource.m_nodes[sampler_node_index]; AnimNodeResource& speed_scale_node_resource = graph_resource.m_nodes[speed_scale_node_index]; REQUIRE(graph_resource.connectSockets( graph_resource.getGraphInputNode(), "GraphFloatInput", blend2_node_resource, "Weight")); REQUIRE(graph_resource.connectSockets( graph_resource.getGraphInputNode(), "SpeedScaleInput", speed_scale_node_resource, "SpeedScale")); REQUIRE(graph_resource.connectSockets( graph_resource.getGraphInputNode(), "GraphAnimInput0", blend2_node_resource, "Input0")); REQUIRE(graph_resource.connectSockets( sampler_node_resource, "Output", speed_scale_node_resource, "Input")); REQUIRE(graph_resource.connectSockets( speed_scale_node_resource, "Output", blend2_node_resource, "Input1")); REQUIRE(graph_resource.connectSockets( blend2_node_resource, "Output", graph_resource.getGraphOutputNode(), "GraphAnimOutput")); THEN("Data flow and node ordering must be correct.") { AnimGraph anim_graph = graph_resource.createInstance(); Blend2Node* blend2_node = dynamic_cast(anim_graph.m_nodes[blend2_node_index]); SpeedScaleNode* speed_scale_node = dynamic_cast( anim_graph.m_nodes[speed_scale_node_index]); AnimSamplerNode* sampler_node = dynamic_cast( anim_graph.m_nodes[sampler_node_index]); // // check connectivity // AnimData* graph_input0 = (AnimData*)anim_graph.getInput("GraphAnimInput0"); REQUIRE(graph_input0 == blend2_node->i_input0); REQUIRE( anim_graph.m_nodes[1] == anim_graph.getAnimNodeForInput(blend2_node_index, "Input0")); AnimData* graph_input1 = (AnimData*)anim_graph.getInput("GraphAnimInput1"); REQUIRE(graph_input1 == nullptr); REQUIRE(sampler_node->o_output == speed_scale_node->i_input); REQUIRE( sampler_node == anim_graph.getAnimNodeForInput(speed_scale_node_index, "Input")); REQUIRE(speed_scale_node->o_output == blend2_node->i_input1); REQUIRE( speed_scale_node == anim_graph.getAnimNodeForInput(blend2_node_index, "Input1")); AnimData* graph_output = (AnimData*)anim_graph.getOutput("GraphAnimOutput"); REQUIRE(graph_output == blend2_node->o_output); REQUIRE( anim_graph.m_nodes[blend2_node_index] == anim_graph.getAnimNodeForInput(0, "GraphAnimOutput")); // // check ordering // REQUIRE( anim_graph.getNodeEvalOrderIndex(blend2_node) < anim_graph.getNodeEvalOrderIndex(sampler_node)); REQUIRE( anim_graph.getNodeEvalOrderIndex(blend2_node) < anim_graph.getNodeEvalOrderIndex(speed_scale_node)); REQUIRE( anim_graph.getNodeEvalOrderIndex(speed_scale_node) < anim_graph.getNodeEvalOrderIndex(sampler_node)); } WHEN("Instantiating graph") { AnimGraph anim_graph = graph_resource.createInstance(); float* blend_weight_input = reinterpret_cast(anim_graph.getInput("GraphFloatInput")); Blend2Node* blend2_node = dynamic_cast(anim_graph.m_nodes[blend2_node_index]); SpeedScaleNode* speed_scale_node = dynamic_cast( anim_graph.m_nodes[speed_scale_node_index]); AnimSamplerNode* sampler_node = dynamic_cast( anim_graph.m_nodes[sampler_node_index]); WHEN("Setting weight to 0. and marking nodes active.") { *blend_weight_input = 0.; anim_graph.markActiveNodes(); THEN("Speed scale and sampler node are inactive") { REQUIRE(anim_graph.checkIsNodeActive(speed_scale_node) == false); REQUIRE(anim_graph.checkIsNodeActive(sampler_node) == false); } } WHEN("Setting weight to 0. and marking nodes active") { *blend_weight_input = 0.1; anim_graph.markActiveNodes(); THEN("Speed scale and sampler nodes are active") { REQUIRE(anim_graph.checkIsNodeActive(speed_scale_node) == true); REQUIRE(anim_graph.checkIsNodeActive(sampler_node) == true); } } WHEN("Setting weight to 1. and marking nodes active") { *blend_weight_input = 1.0; anim_graph.markActiveNodes(); THEN("Speed scale and sampler nodes are active") { REQUIRE(anim_graph.checkIsNodeActive(speed_scale_node) == true); REQUIRE(anim_graph.checkIsNodeActive(sampler_node) == true); } } WHEN("Updating time with dt = 0.3f and speed scale = 1.0f") { float* speed_scale_input = reinterpret_cast(anim_graph.getInput("SpeedScaleInput")); *blend_weight_input = 0.1; *speed_scale_input = 1.0f; anim_graph.markActiveNodes(); anim_graph.updateTime(0.3f); THEN ("Anim sampler node time now must be 0.3f") { REQUIRE(sampler_node->m_time_now == Approx(0.3f)); } } WHEN("Updating time with dt = 0.3f and speed scale = 1.3f") { float* speed_scale_input = reinterpret_cast(anim_graph.getInput("SpeedScaleInput")); *blend_weight_input = 0.1; *speed_scale_input = 1.3f; anim_graph.markActiveNodes(); anim_graph.updateTime(0.3f); THEN ("Anim sampler node time now must be 0.39f") { REQUIRE(sampler_node->m_time_now == Approx(0.39f)); } } } } } */