?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
!B (Sandbox) (CE-21795) Importing models with multisubmaterials via fbx switches...
[CRYENGINE.git] / Code / CryEngine / CrySchematyc2 / Deprecated / DocGraphNodes / DocGraphNodes.cpp
blob31be44ca8d6d488b2843193f3519f14ca45b6b41
1 // Copyright 2001-2019 Crytek GmbH / Crytek Group. All rights reserved.
2
3 #include "StdAfx.h"
4 #include "DocGraphNodes.h"
5
6 #include <CrySchematyc2/ICompiler.h>
7 #include <CrySchematyc2/LibUtils.h>
8 #include <CrySchematyc2/Deprecated/DocUtils.h>
9 #include <CrySchematyc2/Deprecated/IGlobalFunction.h>
10
11 #include "AggregateTypeIdSerialize.h"
12 #include "Script/ScriptVariableDeclaration.h"
13
14 namespace Schematyc2
15 {
16 //////////////////////////////////////////////////////////////////////////
17 CDocGraphBeginNode::CDocGraphBeginNode(IScriptFile& file, IDocGraph& graph, const SGUID& guid, const SGUID& contextGUID, const SGUID& refGUID, Vec2 pos)
18 : CDocGraphNodeBase(file, graph, guid, "Begin", EScriptGraphNodeType::Begin, contextGUID, refGUID, pos)
19 {
20 Refresh(SScriptRefreshParams(EScriptRefreshReason::Other));
21 }
22
23 //////////////////////////////////////////////////////////////////////////
24 IAnyConstPtr CDocGraphBeginNode::GetCustomOutputDefault() const
25 {
26 return IAnyConstPtr();
27 }
28
29 //////////////////////////////////////////////////////////////////////////
30 size_t CDocGraphBeginNode::AddCustomOutput(const IAny& value)
31 {
32 return INVALID_INDEX;
33 }
34
35 //////////////////////////////////////////////////////////////////////////
36 void CDocGraphBeginNode::EnumerateOptionalOutputs(const ScriptGraphNodeOptionalOutputEnumerator& enumerator) {}
37
38 //////////////////////////////////////////////////////////////////////////
39 size_t CDocGraphBeginNode::AddOptionalOutput(const char* szName, EScriptGraphPortFlags flags, const CAggregateTypeId& typeId)
40 {
41 return INVALID_INDEX;
42 }
43
44 //////////////////////////////////////////////////////////////////////////
45 void CDocGraphBeginNode::RemoveOutput(size_t outputIdx) {}
46
47 //////////////////////////////////////////////////////////////////////////
48 void CDocGraphBeginNode::Refresh(const SScriptRefreshParams& params)
49 {
50 CRY_PROFILE_FUNCTION(PROFILE_LOADING_ONLY);
51 CDocGraphNodeBase::Refresh(params);
52 CDocGraphNodeBase::AddOutput("Out", EScriptGraphPortFlags::BeginSequence | EScriptGraphPortFlags::Execute);
53 const IDocGraph& graph = CDocGraphNodeBase::GetGraph();
54 const size_t graphInputCount = graph.GetInputCount();
55 m_outputValues.resize(EOutput::FirstParam + graphInputCount);
56 for(size_t graphInputIdx = 0; graphInputIdx < graphInputCount; ++ graphInputIdx)
57 {
58 IAnyConstPtr pGraphInputValue = graph.GetInputValue(graphInputIdx);
59 if(pGraphInputValue)
60 {
61 CDocGraphNodeBase::AddOutput(graph.GetInputName(graphInputIdx), EScriptGraphPortFlags::MultiLink, pGraphInputValue->GetTypeInfo().GetTypeId());
62 m_outputValues[EOutput::FirstParam + graphInputIdx] = pGraphInputValue->Clone();
63 }
64 }
65 }
66
67 //////////////////////////////////////////////////////////////////////////
68 void CDocGraphBeginNode::PreCompileSequence(IDocGraphSequencePreCompiler& preCompiler, size_t outputIdx) const
69 {
70 switch(outputIdx)
71 {
72 case EOutput::Out:
73 {
74 const IDocGraph& graph = CDocGraphNodeBase::GetGraph();
75 preCompiler.BindFunctionToGUID(graph.GetGUID());
76 for(size_t graphInputIdx = 0, graphInputCount = graph.GetInputCount(); graphInputIdx < graphInputCount; ++ graphInputIdx)
77 {
78 IAnyConstPtr pGraphInputValue = graph.GetInputValue(graphInputIdx);
79 CRY_ASSERT(pGraphInputValue);
80 if(pGraphInputValue)
81 {
82 preCompiler.AddFunctionInput(graph.GetInputName(graphInputIdx), nullptr, *pGraphInputValue);
83 }
84 }
85 if(graph.GetType() == EScriptGraphType::Condition)
86 {
87 preCompiler.AddFunctionOutput("Result", nullptr, MakeAny(bool(false)));
88 }
89 else
90 {
91 for(size_t graphOutputIdx = 0, graphOutputCount = graph.GetOutputCount(); graphOutputIdx < graphOutputCount; ++ graphOutputIdx)
92 {
93 IAnyConstPtr pGraphOutputValue = graph.GetOutputValue(graphOutputIdx);
94 CRY_ASSERT(pGraphOutputValue);
95 if(pGraphOutputValue)
96 {
97 preCompiler.AddFunctionOutput(graph.GetOutputName(graphOutputIdx), nullptr, *pGraphOutputValue);
98 }
99 }
100 }
101 break;
102 }
103 }
104 }
105
106 //////////////////////////////////////////////////////////////////////////
107 void CDocGraphBeginNode::LinkSequence(IDocGraphSequenceLinker& linker, size_t outputIdx, const LibFunctionId& functionId) const {}
108
109 //////////////////////////////////////////////////////////////////////////
110 void CDocGraphBeginNode::Compile(IDocGraphNodeCompiler& compiler, EDocGraphSequenceStep sequenceStep, size_t portIdx) const
111 {
112 switch(sequenceStep)
113 {
114 case EDocGraphSequenceStep::BeginInput:
115 {
116 BindOutputs(compiler);
117 break;
118 }
119 }
120 }
121
122 //////////////////////////////////////////////////////////////////////////
123 void CDocGraphBeginNode::BindOutputs(IDocGraphNodeCompiler& compiler) const
124 {
125 size_t stackPos = compiler.GetStackInputPos();
126 for(size_t outputIdx = EOutput::FirstParam, outputCount = CDocGraphNodeBase::GetOutputCount(); outputIdx < outputCount; ++ outputIdx)
127 {
128 stackPos += compiler.BindOutputToStack(*this, stackPos, outputIdx, *m_outputValues[outputIdx]);
129 }
130 }
131
132 //////////////////////////////////////////////////////////////////////////
133 CDocGraphBeginConstructorNode::CDocGraphBeginConstructorNode(IScriptFile& file, IDocGraph& graph, const SGUID& guid, const SGUID& contextGUID, const SGUID& refGUID, Vec2 pos)
134 : CDocGraphNodeBase(file, graph, guid, "Begin", EScriptGraphNodeType::BeginConstructor, contextGUID, refGUID, pos)
135 {
136 Refresh(SScriptRefreshParams(EScriptRefreshReason::Other));
137 }
138
139 //////////////////////////////////////////////////////////////////////////
140 IAnyConstPtr CDocGraphBeginConstructorNode::GetCustomOutputDefault() const
141 {
142 return IAnyConstPtr();
143 }
144
145 //////////////////////////////////////////////////////////////////////////
146 size_t CDocGraphBeginConstructorNode::AddCustomOutput(const IAny& value)
147 {
148 return INVALID_INDEX;
149 }
150
151 //////////////////////////////////////////////////////////////////////////
152 void CDocGraphBeginConstructorNode::EnumerateOptionalOutputs(const ScriptGraphNodeOptionalOutputEnumerator& enumerator) {}
153
154 //////////////////////////////////////////////////////////////////////////
155 size_t CDocGraphBeginConstructorNode::AddOptionalOutput(const char* szName, EScriptGraphPortFlags flags, const CAggregateTypeId& typeId)
156 {
157 return INVALID_INDEX;
158 }
159
160 //////////////////////////////////////////////////////////////////////////
161 void CDocGraphBeginConstructorNode::RemoveOutput(size_t outputIdx) {}
162
163 //////////////////////////////////////////////////////////////////////////
164 void CDocGraphBeginConstructorNode::Refresh(const SScriptRefreshParams& params)
165 {
166 CRY_PROFILE_FUNCTION(PROFILE_LOADING_ONLY);
167 CDocGraphNodeBase::Refresh(params);
168 CDocGraphNodeBase::AddOutput("Out", EScriptGraphPortFlags::BeginSequence | EScriptGraphPortFlags::Execute);
169 const IScriptFile& file = CDocGraphNodeBase::GetFile();
170 const SGUID contextGUID = CDocGraphNodeBase::GetGraph().GetContextGUID();
171 if(contextGUID)
172 {
173 if(ISignalConstPtr pSignal = gEnv->pSchematyc2->GetEnvRegistry().GetSignal(contextGUID))
174 {
175 const size_t signalInputCount = pSignal->GetInputCount();
176 m_outputValues.resize(EOutput::FirstParam + signalInputCount);
177 for(size_t signalInputIdx = 0; signalInputIdx < signalInputCount; ++ signalInputIdx)
178 {
179 IAnyConstPtr pSignalInputValue = pSignal->GetInputValue(signalInputIdx);
180 CRY_ASSERT(pSignalInputValue);
181 if(pSignalInputValue)
182 {
183 CDocGraphNodeBase::AddOutput(pSignal->GetInputName(signalInputIdx), EScriptGraphPortFlags::MultiLink, pSignalInputValue->GetTypeInfo().GetTypeId());
184 m_outputValues[EOutput::FirstParam + signalInputIdx] = pSignalInputValue->Clone();
185 }
186 }
187 }
188 else if(const IScriptSignal* pSignal = ScriptIncludeRecursionUtils::GetSignal(file, contextGUID).second)
189 {
190 const size_t signalInputCount = pSignal->GetInputCount();
191 m_outputValues.resize(EOutput::FirstParam + signalInputCount);
192 for(size_t signalInputIdx = 0; signalInputIdx < signalInputCount; ++ signalInputIdx)
193 {
194 IAnyConstPtr pSignalInputValue = pSignal->GetInputValue(signalInputIdx);
195 CRY_ASSERT(pSignalInputValue);
196 if(pSignalInputValue)
197 {
198 CDocGraphNodeBase::AddOutput(pSignal->GetInputName(signalInputIdx), EScriptGraphPortFlags::MultiLink, pSignalInputValue->GetTypeInfo().GetTypeId());
199 m_outputValues[EOutput::FirstParam + signalInputIdx] = pSignalInputValue->Clone();
200 }
201 }
202 }
203 }
204 }
205
206 //////////////////////////////////////////////////////////////////////////
207 void CDocGraphBeginConstructorNode::PreCompileSequence(IDocGraphSequencePreCompiler& preCompiler, size_t iActiveOutput) const
208 {
209 switch(iActiveOutput)
210 {
211 case EOutput::Out:
212 {
213 for(size_t outputIdx = EOutput::FirstParam, outputCount = CDocGraphNodeBase::GetOutputCount(); outputIdx < outputCount; ++ outputIdx)
214 {
215 preCompiler.AddFunctionInput(CDocGraphNodeBase::GetOutputName(outputIdx), nullptr, *m_outputValues[outputIdx]);
216 }
217 break;
218 }
219 }
220 }
221
222 //////////////////////////////////////////////////////////////////////////
223 void CDocGraphBeginConstructorNode::LinkSequence(IDocGraphSequenceLinker& linker, size_t outputIdx, const LibFunctionId& functionId) const
224 {
225 switch(outputIdx)
226 {
227 case EOutput::Out:
228 {
229 const IDocGraph& graph = CDocGraphNodeBase::GetGraph();
230 linker.CreateConstructor(graph.GetGUID(), functionId);
231 break;
232 }
233 }
234 }
235
236 //////////////////////////////////////////////////////////////////////////
237 void CDocGraphBeginConstructorNode::Compile(IDocGraphNodeCompiler& compiler, EDocGraphSequenceStep sequenceStep, size_t portIdx) const
238 {
239 switch(sequenceStep)
240 {
241 case EDocGraphSequenceStep::BeginInput:
242 {
243 BindOutputs(compiler);
244 break;
245 }
246 }
247 }
248
249 //////////////////////////////////////////////////////////////////////////
250 void CDocGraphBeginConstructorNode::BindOutputs(IDocGraphNodeCompiler& compiler) const
251 {
252 size_t stackPos = 0;
253 for(size_t outputIdx = EOutput::FirstParam, outputCount = CDocGraphNodeBase::GetOutputCount(); outputIdx < outputCount; ++ outputIdx)
254 {
255 stackPos += compiler.BindOutputToStack(*this, stackPos, outputIdx, *m_outputValues[outputIdx]);
256 }
257 }
258
259 //////////////////////////////////////////////////////////////////////////
260 CDocGraphBeginDestructorNode::CDocGraphBeginDestructorNode(IScriptFile& file, IDocGraph& graph, const SGUID& guid, const SGUID& contextGUID, const SGUID& refGUID, Vec2 pos)
261 : CDocGraphNodeBase(file, graph, guid, "Begin", EScriptGraphNodeType::BeginDestructor, contextGUID, refGUID, pos)
262 {
263 Refresh(SScriptRefreshParams(EScriptRefreshReason::Other));
264 }
265
266 //////////////////////////////////////////////////////////////////////////
267 IAnyConstPtr CDocGraphBeginDestructorNode::GetCustomOutputDefault() const
268 {
269 return IAnyConstPtr();
270 }
271
272 //////////////////////////////////////////////////////////////////////////
273 size_t CDocGraphBeginDestructorNode::AddCustomOutput(const IAny& value)
274 {
275 return INVALID_INDEX;
276 }
277
278 //////////////////////////////////////////////////////////////////////////
279 void CDocGraphBeginDestructorNode::EnumerateOptionalOutputs(const ScriptGraphNodeOptionalOutputEnumerator& enumerator) {}
280
281 //////////////////////////////////////////////////////////////////////////
282 size_t CDocGraphBeginDestructorNode::AddOptionalOutput(const char* szName, EScriptGraphPortFlags flags, const CAggregateTypeId& typeId)
283 {
284 return INVALID_INDEX;
285 }
286
287 //////////////////////////////////////////////////////////////////////////
288 void CDocGraphBeginDestructorNode::RemoveOutput(size_t outputIdx) {}
289
290 //////////////////////////////////////////////////////////////////////////
291 void CDocGraphBeginDestructorNode::Refresh(const SScriptRefreshParams& params)
292 {
293 CRY_PROFILE_FUNCTION(PROFILE_LOADING_ONLY);
294 CDocGraphNodeBase::Refresh(params);
295 CDocGraphNodeBase::AddOutput("Out", EScriptGraphPortFlags::BeginSequence | EScriptGraphPortFlags::Execute);
296 const IScriptFile& file = CDocGraphNodeBase::GetFile();
297 const SGUID contextGUID = CDocGraphNodeBase::GetGraph().GetContextGUID();
298 if(contextGUID)
299 {
300 if(ISignalConstPtr pSignal = gEnv->pSchematyc2->GetEnvRegistry().GetSignal(contextGUID))
301 {
302 const size_t signalInputCount = pSignal->GetInputCount();
303 m_outputValues.resize(EOutput::FirstParam + signalInputCount);
304 for(size_t signalInputIdx = 0; signalInputIdx < signalInputCount; ++ signalInputIdx)
305 {
306 IAnyConstPtr pSignalInputValue = pSignal->GetInputValue(signalInputIdx);
307 CRY_ASSERT(pSignalInputValue);
308 if(pSignalInputValue)
309 {
310 CDocGraphNodeBase::AddOutput(pSignal->GetInputName(signalInputIdx), EScriptGraphPortFlags::MultiLink, pSignalInputValue->GetTypeInfo().GetTypeId());
311 m_outputValues[EOutput::FirstParam + signalInputIdx] = pSignalInputValue->Clone();
312 }
313 }
314 }
315 else if(const IScriptSignal* pSignal = ScriptIncludeRecursionUtils::GetSignal(file, contextGUID).second)
316 {
317 const size_t signalInputCount = pSignal->GetInputCount();
318 m_outputValues.resize(EOutput::FirstParam + signalInputCount);
319 for(size_t signalInputIdx = 0; signalInputIdx < signalInputCount; ++ signalInputIdx)
320 {
321 IAnyConstPtr pSignalInputValue = pSignal->GetInputValue(signalInputIdx);
322 CRY_ASSERT(pSignalInputValue);
323 if(pSignalInputValue)
324 {
325 CDocGraphNodeBase::AddOutput(pSignal->GetInputName(signalInputIdx), EScriptGraphPortFlags::MultiLink, pSignalInputValue->GetTypeInfo().GetTypeId());
326 m_outputValues[EOutput::FirstParam + signalInputIdx] = pSignalInputValue->Clone();
327 }
328 }
329 }
330 }
331 }
332
333 //////////////////////////////////////////////////////////////////////////
334 void CDocGraphBeginDestructorNode::PreCompileSequence(IDocGraphSequencePreCompiler& preCompiler, size_t outputIdx) const
335 {
336 switch(outputIdx)
337 {
338 case EOutput::Out:
339 {
340 for(size_t outputIdx = EOutput::FirstParam, outputCount = CDocGraphNodeBase::GetOutputCount(); outputIdx < outputCount; ++ outputIdx)
341 {
342 preCompiler.AddFunctionInput(CDocGraphNodeBase::GetOutputName(outputIdx), nullptr, *m_outputValues[outputIdx]);
343 }
344 break;
345 }
346 }
347 }
348
349 //////////////////////////////////////////////////////////////////////////
350 void CDocGraphBeginDestructorNode::LinkSequence(IDocGraphSequenceLinker& linker, size_t outputIdx, const LibFunctionId& functionId) const
351 {
352 switch(outputIdx)
353 {
354 case EOutput::Out:
355 {
356 const IDocGraph& graph = CDocGraphNodeBase::GetGraph();
357 linker.CreateDestructor(graph.GetGUID(), functionId);
358 break;
359 }
360 }
361 }
362
363 //////////////////////////////////////////////////////////////////////////
364 void CDocGraphBeginDestructorNode::Compile(IDocGraphNodeCompiler& compiler, EDocGraphSequenceStep sequenceStep, size_t portIdx) const
365 {
366 switch(sequenceStep)
367 {
368 case EDocGraphSequenceStep::BeginInput:
369 {
370 BindOutputs(compiler);
371 break;
372 }
373 }
374 }
375
376 //////////////////////////////////////////////////////////////////////////
377 void CDocGraphBeginDestructorNode::BindOutputs(IDocGraphNodeCompiler& compiler) const
378 {
379 size_t stackPos = 0;
380 for(size_t outputIdx = EOutput::FirstParam, outputCount = CDocGraphNodeBase::GetOutputCount(); outputIdx < outputCount; ++ outputIdx)
381 {
382 stackPos += compiler.BindOutputToStack(*this, stackPos, outputIdx, *m_outputValues[outputIdx]);
383 }
384 }
385
386 //////////////////////////////////////////////////////////////////////////
387 CDocGraphBeginSignalReceiverNode::CDocGraphBeginSignalReceiverNode(IScriptFile& file, IDocGraph& graph, const SGUID& guid, const SGUID& contextGUID, const SGUID& refGUID, Vec2 pos)
388 : CDocGraphNodeBase(file, graph, guid, "Begin", EScriptGraphNodeType::BeginSignalReceiver, contextGUID, refGUID, pos)
389 {
390 Refresh(SScriptRefreshParams(EScriptRefreshReason::Other));
391 }
392
393 //////////////////////////////////////////////////////////////////////////
394 IAnyConstPtr CDocGraphBeginSignalReceiverNode::GetCustomOutputDefault() const
395 {
396 return IAnyConstPtr();
397 }
398
399 //////////////////////////////////////////////////////////////////////////
400 size_t CDocGraphBeginSignalReceiverNode::AddCustomOutput(const IAny& value)
401 {
402 return INVALID_INDEX;
403 }
404
405 //////////////////////////////////////////////////////////////////////////
406 void CDocGraphBeginSignalReceiverNode::EnumerateOptionalOutputs(const ScriptGraphNodeOptionalOutputEnumerator& enumerator) {}
407
408 //////////////////////////////////////////////////////////////////////////
409 size_t CDocGraphBeginSignalReceiverNode::AddOptionalOutput(const char* szName, EScriptGraphPortFlags flags, const CAggregateTypeId& typeId)
410 {
411 return INVALID_INDEX;
412 }
413
414 //////////////////////////////////////////////////////////////////////////
415 void CDocGraphBeginSignalReceiverNode::RemoveOutput(size_t outputIdx) {}
416
417 //////////////////////////////////////////////////////////////////////////
418 void CDocGraphBeginSignalReceiverNode::Refresh(const SScriptRefreshParams& params)
419 {
420 CRY_PROFILE_FUNCTION(PROFILE_LOADING_ONLY);
421 CDocGraphNodeBase::Refresh(params);
422 CDocGraphNodeBase::AddOutput("Out", EScriptGraphPortFlags::BeginSequence | EScriptGraphPortFlags::Execute);
423 const IScriptFile& file = CDocGraphNodeBase::GetFile();
424 const SGUID contextGUID = CDocGraphNodeBase::GetGraph().GetContextGUID();
425 if(ISignalConstPtr pSignal = gEnv->pSchematyc2->GetEnvRegistry().GetSignal(contextGUID))
426 {
427 const size_t signalInputCount = pSignal->GetInputCount();
428 m_outputValues.resize(EOutput::FirstParam + signalInputCount);
429 for(size_t signalInputIdx = 0; signalInputIdx < signalInputCount; ++ signalInputIdx)
430 {
431 IAnyConstPtr pSignalInputValue = pSignal->GetInputValue(signalInputIdx);
432 CRY_ASSERT(pSignalInputValue);
433 if(pSignalInputValue)
434 {
435 CDocGraphNodeBase::AddOutput(pSignal->GetInputName(signalInputIdx), EScriptGraphPortFlags::MultiLink, pSignalInputValue->GetTypeInfo().GetTypeId());
436 m_outputValues[EOutput::FirstParam + signalInputIdx] = pSignalInputValue->Clone();
437 }
438 }
439 }
440 else if(const IScriptSignal* pSignal = ScriptIncludeRecursionUtils::GetSignal(file, contextGUID).second)
441 {
442 const size_t signalInputCount = pSignal->GetInputCount();
443 m_outputValues.resize(EOutput::FirstParam + signalInputCount);
444 for(size_t signalInputIdx = 0; signalInputIdx < signalInputCount; ++ signalInputIdx)
445 {
446 IAnyConstPtr pSignalInputValue = pSignal->GetInputValue(signalInputIdx);
447 CRY_ASSERT(pSignalInputValue);
448 if(pSignalInputValue)
449 {
450 CDocGraphNodeBase::AddOutput(pSignal->GetInputName(signalInputIdx), EScriptGraphPortFlags::MultiLink, pSignalInputValue->GetTypeInfo().GetTypeId());
451 m_outputValues[EOutput::FirstParam + signalInputIdx] = pSignalInputValue->Clone();
452 }
453 }
454 }
455 }
456
457 //////////////////////////////////////////////////////////////////////////
458 void CDocGraphBeginSignalReceiverNode::PreCompileSequence(IDocGraphSequencePreCompiler& preCompiler, size_t outputIdx) const
459 {
460 switch(outputIdx)
461 {
462 case EOutput::Out:
463 {
464 for(size_t outputIdx = EOutput::FirstParam, outputCount = CDocGraphNodeBase::GetOutputCount(); outputIdx < outputCount; ++ outputIdx)
465 {
466 preCompiler.AddFunctionInput(CDocGraphNodeBase::GetOutputName(outputIdx), nullptr, *m_outputValues[outputIdx]);
467 }
468 break;
469 }
470 }
471 }
472
473 //////////////////////////////////////////////////////////////////////////
474 void CDocGraphBeginSignalReceiverNode::LinkSequence(IDocGraphSequenceLinker& linker, size_t outputIdx, const LibFunctionId& functionId) const
475 {
476 switch(outputIdx)
477 {
478 case EOutput::Out:
479 {
480 const IDocGraph& graph = CDocGraphNodeBase::GetGraph();
481 linker.CreateSignalReceiver(graph.GetGUID(), graph.GetContextGUID(), functionId);
482 break;
483 }
484 }
485 }
486
487 //////////////////////////////////////////////////////////////////////////
488 void CDocGraphBeginSignalReceiverNode::Compile(IDocGraphNodeCompiler& compiler, EDocGraphSequenceStep sequenceStep, size_t portIdx) const
489 {
490 switch(sequenceStep)
491 {
492 case EDocGraphSequenceStep::BeginInput:
493 {
494 BindOutputs(compiler);
495 break;
496 }
497 }
498 }
499
500 //////////////////////////////////////////////////////////////////////////
501 void CDocGraphBeginSignalReceiverNode::BindOutputs(IDocGraphNodeCompiler& compiler) const
502 {
503 size_t stackPos = 0;
504 for(size_t outputIdx = EOutput::FirstParam, outputCount = CDocGraphNodeBase::GetOutputCount(); outputIdx < outputCount; ++ outputIdx)
505 {
506 stackPos += compiler.BindOutputToStack(*this, stackPos, outputIdx, *m_outputValues[outputIdx]);
507 }
508 }
509
510 //////////////////////////////////////////////////////////////////////////
511 CDocGraphMakeEnumerationNode::CDocGraphMakeEnumerationNode(IScriptFile& file, IDocGraph& graph, const SGUID& guid, const SGUID& contextGUID, const SGUID& refGUID, Vec2 pos)
512 : CDocGraphNodeBase(file, graph, guid, "Make Enumeration", EScriptGraphNodeType::MakeEnumeration, contextGUID, refGUID, pos)
513 {
514 Refresh(SScriptRefreshParams(EScriptRefreshReason::Other));
515 }
516
517 //////////////////////////////////////////////////////////////////////////
518 IAnyConstPtr CDocGraphMakeEnumerationNode::GetCustomOutputDefault() const
519 {
520 return IAnyConstPtr();
521 }
522
523 //////////////////////////////////////////////////////////////////////////
524 size_t CDocGraphMakeEnumerationNode::AddCustomOutput(const IAny& value)
525 {
526 return INVALID_INDEX;
527 }
528
529 //////////////////////////////////////////////////////////////////////////
530 void CDocGraphMakeEnumerationNode::EnumerateOptionalOutputs(const ScriptGraphNodeOptionalOutputEnumerator& enumerator) {}
531
532 //////////////////////////////////////////////////////////////////////////
533 size_t CDocGraphMakeEnumerationNode::AddOptionalOutput(const char* szName, EScriptGraphPortFlags flags, const CAggregateTypeId& typeId)
534 {
535 return INVALID_INDEX;
536 }
537
538 //////////////////////////////////////////////////////////////////////////
539 void CDocGraphMakeEnumerationNode::RemoveOutput(size_t outputIdx) {}
540
541 //////////////////////////////////////////////////////////////////////////
542 void CDocGraphMakeEnumerationNode::Refresh(const SScriptRefreshParams& params)
543 {
544 CRY_PROFILE_FUNCTION(PROFILE_LOADING_ONLY);
545 CDocGraphNodeBase::Refresh(params);
546 if(m_pValue)
547 {
548 CDocGraphNodeBase::AddOutput("Value", EScriptGraphPortFlags::MultiLink | EScriptGraphPortFlags::Pull, m_pValue->GetTypeInfo().GetTypeId());
549 }
550 }
551
552 //////////////////////////////////////////////////////////////////////////
553 void CDocGraphMakeEnumerationNode::Serialize(Serialization::IArchive& archive)
554 {
555 CRY_PROFILE_FUNCTION(PROFILE_LOADING_ONLY);
556
557 CDocGraphNodeBase::Serialize(archive);
558
559 if(archive.isEdit())
560 {
561 TypeIds typeIds;
562 Serialization::StringList typeNames;
563 typeIds.reserve(64);
564 typeNames.reserve(64);
565 if(!m_typeId)
566 {
567 typeIds.push_back(CAggregateTypeId());
568 typeNames.push_back("");
569 }
570
571 STypeVisitor typeVisitor(typeIds, typeNames);
572 gEnv->pSchematyc2->GetEnvRegistry().VisitTypeDescs(EnvTypeDescVisitor::FromMemberFunction<STypeVisitor, &STypeVisitor::VisitEnvTypeDesc>(typeVisitor));
573 ScriptIncludeRecursionUtils::VisitEnumerations(CDocGraphNodeBase::GetFile(), ScriptIncludeRecursionUtils::EnumerationVisitor::FromMemberFunction<STypeVisitor, &STypeVisitor::VisitScriptEnumeration>(typeVisitor), SGUID(), true);
574
575 if(archive.isInput())
576 {
577 Serialization::StringListValue typeName(typeNames, 0);
578 archive(typeName, "typeName", "Type");
579 SetTypeId(typeIds[typeName.index()]);
580 }
581 else if(archive.isOutput())
582 {
583 TypeIds::iterator itTypeId = std::find(typeIds.begin(), typeIds.end(), m_typeId);
584 Serialization::StringListValue typeName(typeNames, itTypeId != typeIds.end() ? static_cast<int>(itTypeId - typeIds.begin()) : 0);
585 archive(typeName, "typeName", "Type");
586 }
587
588 if(m_pValue)
589 {
590 archive(*m_pValue, "value", "Value");
591 }
592 }
593 else
594 {
595 if(archive.isInput())
596 {
597 CAggregateTypeId typeId;
598 archive(typeId, "typeId");
599 SetTypeId(typeId);
600 }
601 else if(archive.isOutput())
602 {
603 archive(m_typeId, "typeId");
604 }
605
606 if(m_pValue)
607 {
608 archive(*m_pValue, "value");
609 }
610 }
611 }
612
613 //////////////////////////////////////////////////////////////////////////
614 void CDocGraphMakeEnumerationNode::PreCompileSequence(IDocGraphSequencePreCompiler& preCompiler, size_t outputIdx) const {}
615
616 //////////////////////////////////////////////////////////////////////////
617 void CDocGraphMakeEnumerationNode::LinkSequence(IDocGraphSequenceLinker& linker, size_t outputIdx, const LibFunctionId& functionId) const {}
618
619 //////////////////////////////////////////////////////////////////////////
620 void CDocGraphMakeEnumerationNode::Compile(IDocGraphNodeCompiler& compiler, EDocGraphSequenceStep sequenceStep, size_t portIdx) const
621 {
622 switch(sequenceStep)
623 {
624 case EDocGraphSequenceStep::PullOutput:
625 {
626 switch(portIdx)
627 {
628 case EOutput::Value:
629 {
630 CompileOutput(compiler);
631 break;
632 }
633 }
634 break;
635 }
636 }
637 }
638
639 //////////////////////////////////////////////////////////////////////////
640 CDocGraphMakeEnumerationNode::STypeVisitor::STypeVisitor(TypeIds& _typeIds, Serialization::StringList& _typeNames)
641 : typeIds(_typeIds)
642 , typeNames(_typeNames)
643 {}
644
645 //////////////////////////////////////////////////////////////////////////
646 EVisitStatus CDocGraphMakeEnumerationNode::STypeVisitor::VisitEnvTypeDesc(const IEnvTypeDesc& typeDesc)
647 {
648 if(typeDesc.GetCategory() == EEnvTypeCategory::Enumeration)
649 {
650 typeIds.push_back(typeDesc.GetTypeInfo().GetTypeId());
651 typeNames.push_back(typeDesc.GetName());
652 }
653 return EVisitStatus::Continue;
654 }
655
656 //////////////////////////////////////////////////////////////////////////
657 void CDocGraphMakeEnumerationNode::STypeVisitor::VisitScriptEnumeration(const IScriptFile& enumerationFile, const IScriptEnumeration& enumeration)
658 {
659 typeIds.push_back(enumeration.GetTypeId());
660 typeNames.push_back(enumeration.GetName());
661 }
662
663 //////////////////////////////////////////////////////////////////////////
664 void CDocGraphMakeEnumerationNode::SetTypeId(const CAggregateTypeId& typeId)
665 {
666 if(typeId != m_typeId)
667 {
668 m_typeId = typeId;
669 m_pValue = MakeScriptVariableValueShared(CDocGraphNodeBase::GetFile(), typeId);
670
671 CDocGraphNodeBase::GetGraph().RemoveLinks(CDocGraphNodeBase::GetGUID());
672 Refresh(SScriptRefreshParams(EScriptRefreshReason::Other));
673 }
674 }
675
676 //////////////////////////////////////////////////////////////////////////
677 void CDocGraphMakeEnumerationNode::CompileOutput(IDocGraphNodeCompiler& compiler) const
678 {
679 if(m_pValue)
680 {
681 const size_t stackPos = compiler.GetStackSize();
682 compiler.Push(*m_pValue, SGUID(), "");
683 compiler.BindOutputToStack(*this, stackPos, EOutput::Value, *m_pValue);
684 }
685 }
686
687 //////////////////////////////////////////////////////////////////////////
688 CDocGraphForLoopNode::CDocGraphForLoopNode(IScriptFile& file, IDocGraph& graph, const SGUID& guid, const SGUID& contextGUID, const SGUID& refGUID, Vec2 pos)
689 : CDocGraphNodeBase(file, graph, guid, "For Loop", EScriptGraphNodeType::ForLoop, contextGUID, refGUID, pos)
690 , m_begin(0)
691 , m_end(0)
692 {
693 Refresh(SScriptRefreshParams(EScriptRefreshReason::Other));
694 }
695
696 //////////////////////////////////////////////////////////////////////////
697 IAnyConstPtr CDocGraphForLoopNode::GetCustomOutputDefault() const
698 {
699 return IAnyConstPtr();
700 }
701
702 //////////////////////////////////////////////////////////////////////////
703 size_t CDocGraphForLoopNode::AddCustomOutput(const IAny& value)
704 {
705 return INVALID_INDEX;
706 }
707
708 //////////////////////////////////////////////////////////////////////////
709 void CDocGraphForLoopNode::EnumerateOptionalOutputs(const ScriptGraphNodeOptionalOutputEnumerator& enumerator) {}
710
711 //////////////////////////////////////////////////////////////////////////
712 size_t CDocGraphForLoopNode::AddOptionalOutput(const char* szName, EScriptGraphPortFlags flags, const CAggregateTypeId& typeId)
713 {
714 return INVALID_INDEX;
715 }
716
717 //////////////////////////////////////////////////////////////////////////
718 void CDocGraphForLoopNode::RemoveOutput(size_t outputIdx) {}
719
720 //////////////////////////////////////////////////////////////////////////
721 void CDocGraphForLoopNode::Refresh(const SScriptRefreshParams& params)
722 {
723 CRY_PROFILE_FUNCTION(PROFILE_LOADING_ONLY);
724 CDocGraphNodeBase::Refresh(params);
725 CDocGraphNodeBase::AddInput("In", EScriptGraphPortFlags::MultiLink | EScriptGraphPortFlags::Execute);
726 CDocGraphNodeBase::AddInput("Begin", EScriptGraphPortFlags::None, GetAggregateTypeId<int32>());
727 CDocGraphNodeBase::AddInput("End", EScriptGraphPortFlags::None, GetAggregateTypeId<int32>());
728 CDocGraphNodeBase::AddInput("Break", EScriptGraphPortFlags::EndSequence | EScriptGraphPortFlags::Execute);
729 CDocGraphNodeBase::AddOutput("Loop", EScriptGraphPortFlags::Execute);
730 CDocGraphNodeBase::AddOutput("End", EScriptGraphPortFlags::Execute);
731 CDocGraphNodeBase::AddOutput("Index", EScriptGraphPortFlags::MultiLink, GetAggregateTypeId<int32>());
732 }
733
734 //////////////////////////////////////////////////////////////////////////
735 void CDocGraphForLoopNode::Serialize(Serialization::IArchive& archive)
736 {
737 CRY_PROFILE_FUNCTION(PROFILE_LOADING_ONLY);
738 CDocGraphNodeBase::Serialize(archive);
739 archive(m_begin, "begin", "Begin");
740 archive(m_end, "end", "End");
741 }
742
743 //////////////////////////////////////////////////////////////////////////
744 void CDocGraphForLoopNode::PreCompileSequence(IDocGraphSequencePreCompiler& preCompiler, size_t outputIdx) const {}
745
746 //////////////////////////////////////////////////////////////////////////
747 void CDocGraphForLoopNode::LinkSequence(IDocGraphSequenceLinker& linker, size_t outputIdx, const LibFunctionId& functionId) const {}
748
749 //////////////////////////////////////////////////////////////////////////
750 void CDocGraphForLoopNode::Compile(IDocGraphNodeCompiler& compiler, EDocGraphSequenceStep sequenceStep, size_t portIdx) const
751 {
752 switch(sequenceStep)
753 {
754 case EDocGraphSequenceStep::BeginInput:
755 {
756 switch(portIdx)
757 {
758 case EInput::In:
759 {
760 CompileInputs(compiler);
761 break;
762 }
763 case EInput::Break:
764 {
765 CompileBreak(compiler);
766 break;
767 }
768 }
769 break;
770 }
771 case EDocGraphSequenceStep::BeginOutput:
772 {
773 switch(portIdx)
774 {
775 case EOutput::Loop:
776 {
777 CompileLoop(compiler);
778 break;
779 }
780 case EOutput::End:
781 {
782 CompileEnd(compiler);
783 break;
784 }
785 }
786 break;
787 }
788 }
789 }
790
791 //////////////////////////////////////////////////////////////////////////
792 void CDocGraphForLoopNode::CompileInputs(IDocGraphNodeCompiler& compiler) const
793 {
794 const size_t endStackPos = compiler.FindInputOnStack(*this, EInput::End);
795 if(endStackPos != INVALID_INDEX)
796 {
797 if(endStackPos != (compiler.GetStackSize() - 1))
798 {
799 compiler.Copy(endStackPos, INVALID_INDEX, MakeAny(m_end), CDocGraphNodeBase::GetGUID(), GetInputName(EInput::End));
800 }
801 }
802 else
803 {
804 compiler.Push(MakeAny(m_end), CDocGraphNodeBase::GetGUID(), GetInputName(EInput::End));
805 }
806 compiler.BindVariableToStack(*this, compiler.GetStackSize() - 1, EVariable::End);
807 compiler.CreateStackFrame(*this, EStackFrame::Body);
808 const size_t beginStackPos = compiler.FindInputOnStack(*this, EInput::Begin);
809 if(beginStackPos != INVALID_INDEX)
810 {
811 compiler.Copy(beginStackPos, INVALID_INDEX, MakeAny(m_begin), CDocGraphNodeBase::GetGUID(), GetInputName(EInput::Begin));
812 }
813 else
814 {
815 compiler.Push(MakeAny(m_begin), CDocGraphNodeBase::GetGUID(), GetInputName(EInput::Begin));
816 }
817 compiler.BindOutputToStack(*this, compiler.GetStackSize() - 1, EOutput::Index, MakeAny(int32()));
818 }
819
820 //////////////////////////////////////////////////////////////////////////
821 void CDocGraphForLoopNode::CompileBreak(IDocGraphNodeCompiler& compiler) const
822 {
823 compiler.Branch(*this, EMarker::End);
824 }
825
826 //////////////////////////////////////////////////////////////////////////
827 void CDocGraphForLoopNode::CompileLoop(IDocGraphNodeCompiler& compiler) const
828 {
829 compiler.CreateMarker(*this, EMarker::Begin);
830 compiler.CreateStackFrame(*this, EStackFrame::Loop);
831 compiler.LessThanInt32(compiler.FindOutputOnStack(*this, EOutput::Index), compiler.FindVariableOnStack(*this, EVariable::End));
832 compiler.BranchIfZero(*this, EMarker::End);
833 compiler.CollapseStackFrame(*this, EStackFrame::Loop);
834 }
835
836 //////////////////////////////////////////////////////////////////////////
837 void CDocGraphForLoopNode::CompileEnd(IDocGraphNodeCompiler& compiler) const
838 {
839 compiler.IncrementInt32(compiler.FindOutputOnStack(*this, EOutput::Index));
840 compiler.Branch(*this, EMarker::Begin);
841 compiler.CreateMarker(*this, EMarker::End);
842 compiler.CollapseStackFrame(*this, EStackFrame::Body);
843 compiler.BindOutputToStack(*this, compiler.GetStackSize() - 1, EOutput::Index, MakeAny(int32()));
844 }
845
846 //////////////////////////////////////////////////////////////////////////
847 CDocGraphProcessSignalNode::CDocGraphProcessSignalNode(IScriptFile& file, IDocGraph& graph, const SGUID& guid, const SGUID& contextGUID, const SGUID& refGUID, Vec2 pos)
848 : CDocGraphNodeBase(file, graph, guid, "Process Signal", EScriptGraphNodeType::ProcessSignal, contextGUID, refGUID, pos)
849 {
850 Refresh(SScriptRefreshParams(EScriptRefreshReason::Other));
851 }
852
853 //////////////////////////////////////////////////////////////////////////
854 IAnyConstPtr CDocGraphProcessSignalNode::GetCustomOutputDefault() const
855 {
856 return IAnyConstPtr();
857 }
858
859 //////////////////////////////////////////////////////////////////////////
860 size_t CDocGraphProcessSignalNode::AddCustomOutput(const IAny& value)
861 {
862 return INVALID_INDEX;
863 }
864
865 //////////////////////////////////////////////////////////////////////////
866 void CDocGraphProcessSignalNode::EnumerateOptionalOutputs(const ScriptGraphNodeOptionalOutputEnumerator& enumerator) {}
867
868 //////////////////////////////////////////////////////////////////////////
869 size_t CDocGraphProcessSignalNode::AddOptionalOutput(const char* szName, EScriptGraphPortFlags flags, const CAggregateTypeId& typeId)
870 {
871 return INVALID_INDEX;
872 }
873
874 //////////////////////////////////////////////////////////////////////////
875 void CDocGraphProcessSignalNode::RemoveOutput(size_t outputIdx) {}
876
877 //////////////////////////////////////////////////////////////////////////
878 void CDocGraphProcessSignalNode::Refresh(const SScriptRefreshParams& params)
879 {
880 CRY_PROFILE_FUNCTION(PROFILE_LOADING_ONLY);
881 CDocGraphNodeBase::Refresh(params);
882 CDocGraphNodeBase::AddInput("In", EScriptGraphPortFlags::MultiLink | EScriptGraphPortFlags::Execute);
883 CDocGraphNodeBase::AddOutput("Out", EScriptGraphPortFlags::Execute);
884 const IScriptFile& file = CDocGraphNodeBase::GetFile();
885 const SGUID refGUID = CDocGraphNodeBase::GetRefGUID();
886 stack_string name = "Process Signal: ";
887 const IScriptSignal* pSignal = ScriptIncludeRecursionUtils::GetSignal(file, refGUID).second;
888 if(pSignal)
889 {
890 name.append(pSignal->GetName());
891 const size_t signalInputCount = pSignal->GetInputCount();
892 m_inputValues.resize(EInput::FirstParam + signalInputCount);
893 for(size_t signalInputIdx = 0; signalInputIdx < signalInputCount; ++ signalInputIdx)
894 {
895 IAnyConstPtr pSignalInputValue = pSignal->GetInputValue(signalInputIdx);
896 CRY_ASSERT(pSignalInputValue);
897 if(pSignalInputValue)
898 {
899 CDocGraphNodeBase::AddInput(pSignal->GetInputName(signalInputIdx), EScriptGraphPortFlags::None, pSignalInputValue->GetTypeInfo().GetTypeId());
900 IAnyPtr& pInputValue = m_inputValues[EInput::FirstParam + signalInputIdx];
901 if(!pInputValue || (pInputValue->GetTypeInfo().GetTypeId() != pSignalInputValue->GetTypeInfo().GetTypeId()))
902 {
903 pInputValue = pSignalInputValue->Clone();
904 }
905 }
906 }
907 }
908 CDocGraphNodeBase::SetName(name.c_str());
909 }
910
911 //////////////////////////////////////////////////////////////////////////
912 void CDocGraphProcessSignalNode::Serialize(Serialization::IArchive& archive)
913 {
914 CRY_PROFILE_FUNCTION(PROFILE_LOADING_ONLY);
915 CDocGraphNodeBase::Serialize(archive);
916 for(size_t inputIdx = EInput::FirstParam, inputCount = CDocGraphNodeBase::GetInputCount(); inputIdx < inputCount; ++ inputIdx)
917 {
918 const char* szName = CDocGraphNodeBase::GetInputName(inputIdx);
919 archive(*m_inputValues[inputIdx], szName, szName);
920 }
921 }
922
923 //////////////////////////////////////////////////////////////////////////
924 void CDocGraphProcessSignalNode::PreCompileSequence(IDocGraphSequencePreCompiler& preCompiler, size_t outputIdx) const {}
925
926 //////////////////////////////////////////////////////////////////////////
927 void CDocGraphProcessSignalNode::LinkSequence(IDocGraphSequenceLinker& linker, size_t outputIdx, const LibFunctionId& functionId) const {}
928
929 //////////////////////////////////////////////////////////////////////////
930 void CDocGraphProcessSignalNode::Compile(IDocGraphNodeCompiler& compiler, EDocGraphSequenceStep sequenceStep, size_t portIdx) const
931 {
932 switch(sequenceStep)
933 {
934 case EDocGraphSequenceStep::BeginInput:
935 {
936 CompileInputs(compiler);
937 break;
938 }
939 }
940 }
941
942 //////////////////////////////////////////////////////////////////////////
943 void CDocGraphProcessSignalNode::CompileInputs(IDocGraphNodeCompiler& compiler) const
944 {
945 compiler.GetObject();
946 DocGraphNodeUtils::CopyInputsToStack(*this, EInput::FirstParam, m_inputValues, compiler);
947 compiler.SendSignal(CDocGraphNodeBase::GetRefGUID(), CDocGraphNodeBase::GetGUID());
948 }
949
950 //////////////////////////////////////////////////////////////////////////
951 CDocGraphBroadcastSignalNode::CDocGraphBroadcastSignalNode(IScriptFile& file, IDocGraph& graph, const SGUID& guid, const SGUID& contextGUID, const SGUID& refGUID, Vec2 pos)
952 : CDocGraphNodeBase(file, graph, guid, "Broadcast Signal", EScriptGraphNodeType::BroadcastSignal, contextGUID, refGUID, pos)
953 {
954 Refresh(SScriptRefreshParams(EScriptRefreshReason::Other));
955 }
956
957 //////////////////////////////////////////////////////////////////////////
958 IAnyConstPtr CDocGraphBroadcastSignalNode::GetCustomOutputDefault() const
959 {
960 return IAnyConstPtr();
961 }
962
963 //////////////////////////////////////////////////////////////////////////
964 size_t CDocGraphBroadcastSignalNode::AddCustomOutput(const IAny& value)
965 {
966 return INVALID_INDEX;
967 }
968
969 //////////////////////////////////////////////////////////////////////////
970 void CDocGraphBroadcastSignalNode::EnumerateOptionalOutputs(const ScriptGraphNodeOptionalOutputEnumerator& enumerator) {}
971
972 //////////////////////////////////////////////////////////////////////////
973 size_t CDocGraphBroadcastSignalNode::AddOptionalOutput(const char* szName, EScriptGraphPortFlags flags, const CAggregateTypeId& typeId)
974 {
975 return INVALID_INDEX;
976 }
977
978 //////////////////////////////////////////////////////////////////////////
979 void CDocGraphBroadcastSignalNode::RemoveOutput(size_t outputIdx) {}
980
981 //////////////////////////////////////////////////////////////////////////
982 void CDocGraphBroadcastSignalNode::Refresh(const SScriptRefreshParams& params)
983 {
984 CRY_PROFILE_FUNCTION(PROFILE_LOADING_ONLY);
985 CDocGraphNodeBase::Refresh(params);
986 CDocGraphNodeBase::AddInput("In", EScriptGraphPortFlags::MultiLink | EScriptGraphPortFlags::Execute);
987 CDocGraphNodeBase::AddOutput("Out", EScriptGraphPortFlags::Execute);
988 const IScriptFile& file = CDocGraphNodeBase::GetFile();
989 const SGUID refGUID = CDocGraphNodeBase::GetRefGUID();
990 stack_string name = "Broadcast Signal: ";
991 const IScriptSignal* pSignal = ScriptIncludeRecursionUtils::GetSignal(file, refGUID).second;
992 if(pSignal)
993 {
994 name.append(pSignal->GetName());
995 const size_t signalInputCount = pSignal->GetInputCount();
996 m_inputValues.resize(EInput::FirstParam + signalInputCount);
997 for(size_t signalInputIdx = 0; signalInputIdx < signalInputCount; ++ signalInputIdx)
998 {
999 IAnyConstPtr pSignalInputValue = pSignal->GetInputValue(signalInputIdx);
1000 CRY_ASSERT(pSignalInputValue);
1001 if(pSignalInputValue)
1002 {
1003 CDocGraphNodeBase::AddInput(pSignal->GetInputName(signalInputIdx), EScriptGraphPortFlags::None, pSignalInputValue->GetTypeInfo().GetTypeId());
1004 IAnyPtr& pInputValue = m_inputValues[EInput::FirstParam + signalInputIdx];
1005 if(!pInputValue || (pInputValue->GetTypeInfo().GetTypeId() != pSignalInputValue->GetTypeInfo().GetTypeId()))
1006 {
1007 pInputValue = pSignalInputValue->Clone();
1008 }
1009 }
1010 }
1011 }
1012 CDocGraphNodeBase::SetName(name.c_str());
1013 }
1014
1015 //////////////////////////////////////////////////////////////////////////
1016 void CDocGraphBroadcastSignalNode::Serialize(Serialization::IArchive& archive)
1017 {
1018 CRY_PROFILE_FUNCTION(PROFILE_LOADING_ONLY);
1019 CDocGraphNodeBase::Serialize(archive);
1020 for(size_t inputIdx = EInput::FirstParam, inputCount = CDocGraphNodeBase::GetInputCount(); inputIdx < inputCount; ++ inputIdx)
1021 {
1022 const char* szName = CDocGraphNodeBase::GetInputName(inputIdx);
1023 archive(*m_inputValues[inputIdx], szName, szName);
1024 }
1025 }
1026
1027 //////////////////////////////////////////////////////////////////////////
1028 void CDocGraphBroadcastSignalNode::PreCompileSequence(IDocGraphSequencePreCompiler& preCompiler, size_t outputIdx) const {}
1029
1030 //////////////////////////////////////////////////////////////////////////
1031 void CDocGraphBroadcastSignalNode::LinkSequence(IDocGraphSequenceLinker& linker, size_t outputIdx, const LibFunctionId& functionId) const {}
1032
1033 //////////////////////////////////////////////////////////////////////////
1034 void CDocGraphBroadcastSignalNode::Compile(IDocGraphNodeCompiler& compiler, EDocGraphSequenceStep sequenceStep, size_t portIdx) const
1035 {
1036 switch(sequenceStep)
1037 {
1038 case EDocGraphSequenceStep::BeginInput:
1039 {
1040 CompileInputs(compiler);
1041 break;
1042 }
1043 }
1044 }
1045
1046 //////////////////////////////////////////////////////////////////////////
1047 void CDocGraphBroadcastSignalNode::CompileInputs(IDocGraphNodeCompiler& compiler) const
1048 {
1049 DocGraphNodeUtils::CopyInputsToStack(*this, EInput::FirstParam, m_inputValues, compiler);
1050 compiler.BroadcastSignal(CDocGraphNodeBase::GetRefGUID(), CDocGraphNodeBase::GetGUID());
1051 }
1052
1053 //////////////////////////////////////////////////////////////////////////
1054 CDocGraphGetObjectNode::CDocGraphGetObjectNode(IScriptFile& file, IDocGraph& graph, const SGUID& guid, const SGUID& contextGUID, const SGUID& refGUID, Vec2 pos)
1055 : CDocGraphNodeBase(file, graph, guid, "Get Object", EScriptGraphNodeType::GetObject, contextGUID, refGUID, pos)
1056 {
1057 Refresh(SScriptRefreshParams(EScriptRefreshReason::Other));
1058 }
1059
1060 //////////////////////////////////////////////////////////////////////////
1061 IAnyConstPtr CDocGraphGetObjectNode::GetCustomOutputDefault() const
1062 {
1063 return IAnyConstPtr();
1064 }
1065
1066 //////////////////////////////////////////////////////////////////////////
1067 size_t CDocGraphGetObjectNode::AddCustomOutput(const IAny& value)
1068 {
1069 return INVALID_INDEX;
1070 }
1071
1072 //////////////////////////////////////////////////////////////////////////
1073 void CDocGraphGetObjectNode::EnumerateOptionalOutputs(const ScriptGraphNodeOptionalOutputEnumerator& enumerator) {}
1074
1075 //////////////////////////////////////////////////////////////////////////
1076 size_t CDocGraphGetObjectNode::AddOptionalOutput(const char* szName, EScriptGraphPortFlags flags, const CAggregateTypeId& typeId)
1077 {
1078 return INVALID_INDEX;
1079 }
1080
1081 //////////////////////////////////////////////////////////////////////////
1082 void CDocGraphGetObjectNode::RemoveOutput(size_t outputIdx) {}
1083
1084 //////////////////////////////////////////////////////////////////////////
1085 void CDocGraphGetObjectNode::Refresh(const SScriptRefreshParams& params)
1086 {
1087 CRY_PROFILE_FUNCTION(PROFILE_LOADING_ONLY);
1088 CDocGraphNodeBase::Refresh(params);
1089 CDocGraphNodeBase::AddOutput("Object", EScriptGraphPortFlags::MultiLink | EScriptGraphPortFlags::Pull, GetAggregateTypeId<ObjectId>());
1090 }
1091
1092 //////////////////////////////////////////////////////////////////////////
1093 void CDocGraphGetObjectNode::PreCompileSequence(IDocGraphSequencePreCompiler& preCompiler, size_t outputIdx) const {}
1094
1095 //////////////////////////////////////////////////////////////////////////
1096 void CDocGraphGetObjectNode::LinkSequence(IDocGraphSequenceLinker& linker, size_t outputIdx, const LibFunctionId& functionId) const {}
1097
1098 //////////////////////////////////////////////////////////////////////////
1099 void CDocGraphGetObjectNode::Compile(IDocGraphNodeCompiler& compiler, EDocGraphSequenceStep sequenceStep, size_t portIdx) const
1100 {
1101 switch(sequenceStep)
1102 {
1103 case EDocGraphSequenceStep::PullOutput:
1104 {
1105 switch(portIdx)
1106 {
1107 case EOutput::Object:
1108 {
1109 CompileOutput(compiler);
1110 break;
1111 }
1112 }
1113 break;
1114 }
1115 }
1116 }
1117
1118 //////////////////////////////////////////////////////////////////////////
1119 void CDocGraphGetObjectNode::CompileOutput(IDocGraphNodeCompiler& compiler) const
1120 {
1121 compiler.GetObject();
1122 compiler.BindOutputToStack(*this, compiler.GetStackSize() - 1, EOutput::Object, MakeAny(ObjectId()));
1123 }
1124
1125 //////////////////////////////////////////////////////////////////////////
1126 CDocGraphContainerClearNode::CDocGraphContainerClearNode(IScriptFile& file, IDocGraph& graph, const SGUID& guid, const SGUID& contextGUID, const SGUID& refGUID, Vec2 pos)
1127 : CDocGraphNodeBase(file, graph, guid, "Container Clear", EScriptGraphNodeType::ContainerClear, contextGUID, refGUID, pos)
1128 {
1129 Refresh(SScriptRefreshParams(EScriptRefreshReason::Other));
1130 }
1131
1132 //////////////////////////////////////////////////////////////////////////
1133 IAnyConstPtr CDocGraphContainerClearNode::GetCustomOutputDefault() const
1134 {
1135 return IAnyConstPtr();
1136 }
1137
1138 //////////////////////////////////////////////////////////////////////////
1139 size_t CDocGraphContainerClearNode::AddCustomOutput(const IAny& value)
1140 {
1141 return INVALID_INDEX;
1142 }
1143
1144 //////////////////////////////////////////////////////////////////////////
1145 void CDocGraphContainerClearNode::EnumerateOptionalOutputs(const ScriptGraphNodeOptionalOutputEnumerator& enumerator) {}
1146
1147 //////////////////////////////////////////////////////////////////////////
1148 size_t CDocGraphContainerClearNode::AddOptionalOutput(const char* szName, EScriptGraphPortFlags flags, const CAggregateTypeId& typeId)
1149 {
1150 return INVALID_INDEX;
1151 }
1152
1153 //////////////////////////////////////////////////////////////////////////
1154 void CDocGraphContainerClearNode::RemoveOutput(size_t outputIdx) {}
1155
1156 //////////////////////////////////////////////////////////////////////////
1157 void CDocGraphContainerClearNode::Refresh(const SScriptRefreshParams& params)
1158 {
1159 CRY_PROFILE_FUNCTION(PROFILE_LOADING_ONLY);
1160
1161 CDocGraphNodeBase::Refresh(params);
1162 CDocGraphNodeBase::AddInput("In", EScriptGraphPortFlags::MultiLink | EScriptGraphPortFlags::Execute);
1163 CDocGraphNodeBase::AddOutput("Out", EScriptGraphPortFlags::Execute);
1164
1165 stack_string name = "Container Clear: ";
1166 const IScriptContainer* pContainer = CDocGraphNodeBase::GetFile().GetContainer(CDocGraphNodeBase::GetRefGUID());
1167 if(pContainer)
1168 {
1169 name.append(pContainer->GetName());
1170 }
1171
1172 CDocGraphNodeBase::SetName(name.c_str());
1173 }
1174
1175 //////////////////////////////////////////////////////////////////////////
1176 void CDocGraphContainerClearNode::PreCompileSequence(IDocGraphSequencePreCompiler& preCompiler, size_t outputIdx) const {}
1177
1178 //////////////////////////////////////////////////////////////////////////
1179 void CDocGraphContainerClearNode::LinkSequence(IDocGraphSequenceLinker& linker, size_t outputIdx, const LibFunctionId& functionId) const {}
1180
1181 //////////////////////////////////////////////////////////////////////////
1182 void CDocGraphContainerClearNode::Compile(IDocGraphNodeCompiler& compiler, EDocGraphSequenceStep sequenceStep, size_t portIdx) const
1183 {
1184 switch(sequenceStep)
1185 {
1186 case EDocGraphSequenceStep::BeginInput:
1187 {
1188 CompileInputs(compiler);
1189 break;
1190 }
1191 }
1192 }
1193
1194 //////////////////////////////////////////////////////////////////////////
1195 void CDocGraphContainerClearNode::CompileInputs(IDocGraphNodeCompiler& compiler) const
1196 {
1197 compiler.ContainerClear(CDocGraphNodeBase::GetRefGUID());
1198 }
1199
1200 //////////////////////////////////////////////////////////////////////////
1201 CDocGraphContainerSizeNode::CDocGraphContainerSizeNode(IScriptFile& file, IDocGraph& graph, const SGUID& guid, const SGUID& contextGUID, const SGUID& refGUID, Vec2 pos)
1202 : CDocGraphNodeBase(file, graph, guid, "Container Size", EScriptGraphNodeType::ContainerSize, contextGUID, refGUID, pos)
1203 {
1204 Refresh(SScriptRefreshParams(EScriptRefreshReason::Other));
1205 }
1206
1207 //////////////////////////////////////////////////////////////////////////
1208 IAnyConstPtr CDocGraphContainerSizeNode::GetCustomOutputDefault() const
1209 {
1210 return IAnyConstPtr();
1211 }
1212
1213 //////////////////////////////////////////////////////////////////////////
1214 size_t CDocGraphContainerSizeNode::AddCustomOutput(const IAny& value)
1215 {
1216 return INVALID_INDEX;
1217 }
1218
1219 //////////////////////////////////////////////////////////////////////////
1220 void CDocGraphContainerSizeNode::EnumerateOptionalOutputs(const ScriptGraphNodeOptionalOutputEnumerator& enumerator) {}
1221
1222 //////////////////////////////////////////////////////////////////////////
1223 size_t CDocGraphContainerSizeNode::AddOptionalOutput(const char* szName, EScriptGraphPortFlags flags, const CAggregateTypeId& typeId)
1224 {
1225 return INVALID_INDEX;
1226 }
1227
1228 //////////////////////////////////////////////////////////////////////////
1229 void CDocGraphContainerSizeNode::RemoveOutput(size_t outputIdx) {}
1230
1231 //////////////////////////////////////////////////////////////////////////
1232 void CDocGraphContainerSizeNode::Refresh(const SScriptRefreshParams& params)
1233 {
1234 CRY_PROFILE_FUNCTION(PROFILE_LOADING_ONLY);
1235
1236 CDocGraphNodeBase::Refresh(params);
1237 CDocGraphNodeBase::AddOutput("Size", EScriptGraphPortFlags::MultiLink | EScriptGraphPortFlags::Pull, GetAggregateTypeId<int32>());
1238
1239 stack_string name = "Container Size: ";
1240 const IScriptContainer* pContainer = CDocGraphNodeBase::GetFile().GetContainer(CDocGraphNodeBase::GetRefGUID());
1241 if(pContainer)
1242 {
1243 name.append(pContainer->GetName());
1244 }
1245
1246 CDocGraphNodeBase::SetName(name.c_str());
1247 }
1248
1249 //////////////////////////////////////////////////////////////////////////
1250 void CDocGraphContainerSizeNode::PreCompileSequence(IDocGraphSequencePreCompiler& preCompiler, size_t outputIdx) const {}
1251
1252 //////////////////////////////////////////////////////////////////////////
1253 void CDocGraphContainerSizeNode::LinkSequence(IDocGraphSequenceLinker& linker, size_t outputIdx, const LibFunctionId& functionId) const {}
1254
1255 //////////////////////////////////////////////////////////////////////////
1256 void CDocGraphContainerSizeNode::Compile(IDocGraphNodeCompiler& compiler, EDocGraphSequenceStep sequenceStep, size_t portIdx) const
1257 {
1258 switch(sequenceStep)
1259 {
1260 case EDocGraphSequenceStep::PullOutput:
1261 {
1262 switch(portIdx)
1263 {
1264 case EOutput::Size:
1265 {
1266 CompileOutput(compiler);
1267 break;
1268 }
1269 }
1270 break;
1271 }
1272 }
1273 }
1274
1275 //////////////////////////////////////////////////////////////////////////
1276 void CDocGraphContainerSizeNode::CompileOutput(IDocGraphNodeCompiler& compiler) const
1277 {
1278 const IScriptContainer* pContainer = CDocGraphNodeBase::GetFile().GetContainer(CDocGraphNodeBase::GetRefGUID());
1279 if(pContainer)
1280 {
1281 const IEnvTypeDesc* pTypeDesc = gEnv->pSchematyc2->GetEnvRegistry().GetTypeDesc(pContainer->GetTypeGUID());
1282 if(pTypeDesc)
1283 {
1284 IAnyPtr pValue = pTypeDesc->Create();
1285 if(pValue)
1286 {
1287 compiler.ContainerSize(CDocGraphNodeBase::GetRefGUID(), *pValue);
1288 compiler.BindOutputToStack(*this, compiler.GetStackSize() - 1, EOutput::Size, MakeAny(int32()));
1289 }
1290 }
1291 }
1292 }
1293
1294 //////////////////////////////////////////////////////////////////////////
1295 CDocGraphContainerGetNode::CDocGraphContainerGetNode(IScriptFile& file, IDocGraph& graph, const SGUID& guid, const SGUID& contextGUID, const SGUID& refGUID, Vec2 pos)
1296 : CDocGraphNodeBase(file, graph, guid, "Container Get", EScriptGraphNodeType::ContainerGet, contextGUID, refGUID, pos)
1297 , m_index(0)
1298 {}
1299
1300 //////////////////////////////////////////////////////////////////////////
1301 IAnyConstPtr CDocGraphContainerGetNode::GetCustomOutputDefault() const
1302 {
1303 return IAnyConstPtr();
1304 }
1305
1306 //////////////////////////////////////////////////////////////////////////
1307 size_t CDocGraphContainerGetNode::AddCustomOutput(const IAny& value)
1308 {
1309 return INVALID_INDEX;
1310 }
1311
1312 //////////////////////////////////////////////////////////////////////////
1313 void CDocGraphContainerGetNode::EnumerateOptionalOutputs(const ScriptGraphNodeOptionalOutputEnumerator& enumerator) {}
1314
1315 //////////////////////////////////////////////////////////////////////////
1316 size_t CDocGraphContainerGetNode::AddOptionalOutput(const char* szName, EScriptGraphPortFlags flags, const CAggregateTypeId& typeId)
1317 {
1318 return INVALID_INDEX;
1319 }
1320
1321 //////////////////////////////////////////////////////////////////////////
1322 void CDocGraphContainerGetNode::RemoveOutput(size_t outputIdx) {}
1323
1324 //////////////////////////////////////////////////////////////////////////
1325 void CDocGraphContainerGetNode::Refresh(const SScriptRefreshParams& params)
1326 {
1327 CRY_PROFILE_FUNCTION(PROFILE_LOADING_ONLY);
1328
1329 CDocGraphNodeBase::Refresh(params);
1330 CDocGraphNodeBase::AddInput("In", EScriptGraphPortFlags::MultiLink | EScriptGraphPortFlags::Execute);
1331 CDocGraphNodeBase::AddInput("Index", EScriptGraphPortFlags::None, GetAggregateTypeId<int32>());
1332 CDocGraphNodeBase::AddOutput("True", EScriptGraphPortFlags::Execute);
1333 CDocGraphNodeBase::AddOutput("False", EScriptGraphPortFlags::Execute);
1334
1335 stack_string name = "Container Get: ";
1336 const IScriptContainer* pContainer = CDocGraphNodeBase::GetFile().GetContainer(CDocGraphNodeBase::GetRefGUID());
1337 if(pContainer)
1338 {
1339 const IEnvTypeDesc* pTypeDesc = gEnv->pSchematyc2->GetEnvRegistry().GetTypeDesc(pContainer->GetTypeGUID());
1340 if(pTypeDesc)
1341 {
1342 const CAggregateTypeId typeId = pTypeDesc->GetTypeInfo().GetTypeId();
1343 CDocGraphNodeBase::AddOutput("Value", EScriptGraphPortFlags::MultiLink, typeId);
1344 }
1345 name.append(pContainer->GetName());
1346 }
1347
1348 CDocGraphNodeBase::SetName(name.c_str());
1349 }
1350
1351 //////////////////////////////////////////////////////////////////////////
1352 void CDocGraphContainerGetNode::Serialize(Serialization::IArchive& archive)
1353 {
1354 CRY_PROFILE_FUNCTION(PROFILE_LOADING_ONLY);
1355 CDocGraphNodeBase::Serialize(archive);
1356 archive(m_index, "index", "Index");
1357 }
1358
1359 //////////////////////////////////////////////////////////////////////////
1360 void CDocGraphContainerGetNode::PreCompileSequence(IDocGraphSequencePreCompiler& preCompiler, size_t output) const {}
1361
1362 //////////////////////////////////////////////////////////////////////////
1363 void CDocGraphContainerGetNode::LinkSequence(IDocGraphSequenceLinker& linker, size_t output, const LibFunctionId& functionId) const {}
1364
1365 //////////////////////////////////////////////////////////////////////////
1366 void CDocGraphContainerGetNode::Compile(IDocGraphNodeCompiler& compiler, EDocGraphSequenceStep sequenceStep, size_t portIdx) const
1367 {
1368 switch(sequenceStep)
1369 {
1370 case EDocGraphSequenceStep::BeginInput:
1371 {
1372 CompileInputs(compiler);
1373 break;
1374 }
1375 case EDocGraphSequenceStep::BeginOutput:
1376 {
1377 switch(portIdx)
1378 {
1379 case EOutput::True:
1380 {
1381 CompileTrue(compiler);
1382 break;
1383 }
1384 case EOutput::False:
1385 {
1386 CompileFalse(compiler);
1387 break;
1388 }
1389 }
1390 break;
1391 }
1392 case EDocGraphSequenceStep::EndInput:
1393 {
1394 CompileEnd(compiler);
1395 break;
1396 }
1397 }
1398 }
1399
1400 //////////////////////////////////////////////////////////////////////////
1401 void CDocGraphContainerGetNode::CompileInputs(IDocGraphNodeCompiler& compiler) const
1402 {
1403 const IScriptContainer* pContainer = CDocGraphNodeBase::GetFile().GetContainer(CDocGraphNodeBase::GetRefGUID());
1404 if(pContainer)
1405 {
1406 const IEnvTypeDesc* pTypeDesc = gEnv->pSchematyc2->GetEnvRegistry().GetTypeDesc(pContainer->GetTypeGUID());
1407 if(pTypeDesc)
1408 {
1409 IAnyPtr pValue = pTypeDesc->Create();
1410 if(pValue)
1411 {
1412 const size_t stackPos = compiler.FindInputOnStack(*this, EInput::Index);
1413 if(stackPos != INVALID_INDEX)
1414 {
1415 compiler.Copy(stackPos, INVALID_INDEX, MakeAny(m_index), CDocGraphNodeBase::GetGUID(), GetInputName(EInput::Index));
1416 }
1417 else
1418 {
1419 compiler.Push(MakeAny(m_index), CDocGraphNodeBase::GetGUID(), GetInputName(EInput::Index));
1420 }
1421 compiler.AddOutputToStack(*this, EOutput::Value, *pValue);
1422 compiler.ContainerGet(CDocGraphNodeBase::GetRefGUID(), *pValue);
1423 }
1424 }
1425 }
1426 }
1427
1428 //////////////////////////////////////////////////////////////////////////
1429 void CDocGraphContainerGetNode::CompileTrue(IDocGraphNodeCompiler& compiler) const
1430 {
1431 compiler.BranchIfZero(*this, EMarker::False);
1432 compiler.Pop(1);
1433 compiler.CreateStackFrame(*this, EStackFrame::True);
1434 }
1435
1436 //////////////////////////////////////////////////////////////////////////
1437 void CDocGraphContainerGetNode::CompileFalse(IDocGraphNodeCompiler& compiler) const
1438 {
1439 const IScriptContainer* pContainer = CDocGraphNodeBase::GetFile().GetContainer(CDocGraphNodeBase::GetRefGUID());
1440 if(pContainer)
1441 {
1442 const IEnvTypeDesc* pTypeDesc = gEnv->pSchematyc2->GetEnvRegistry().GetTypeDesc(pContainer->GetTypeGUID());
1443 if(pTypeDesc)
1444 {
1445 IAnyPtr pValue = pTypeDesc->Create();
1446 if(pValue)
1447 {
1448 compiler.CollapseStackFrame(*this, EStackFrame::True);
1449 compiler.Branch(*this, EMarker::End);
1450 compiler.CreateMarker(*this, EMarker::False);
1451 compiler.Pop(1);
1452 compiler.Push(*pValue, SGUID(), "");
1453 compiler.CreateStackFrame(*this, EStackFrame::False);
1454 }
1455 }
1456 }
1457 }
1458
1459 //////////////////////////////////////////////////////////////////////////
1460 void CDocGraphContainerGetNode::CompileEnd(IDocGraphNodeCompiler& compiler) const
1461 {
1462 compiler.CollapseStackFrame(*this, EStackFrame::False);
1463 compiler.CreateMarker(*this, EMarker::End);
1464 }
1465
1466 //////////////////////////////////////////////////////////////////////////
1467 CDocGraphStartTimerNode::CDocGraphStartTimerNode(IScriptFile& file, IDocGraph& graph, const SGUID& guid, const SGUID& contextGUID, const SGUID& refGUID, Vec2 pos)
1468 : CDocGraphNodeBase(file, graph, guid, "Start Timer", EScriptGraphNodeType::StartTimer, contextGUID, refGUID, pos)
1469 {
1470 Refresh(SScriptRefreshParams(EScriptRefreshReason::Other));
1471 }
1472
1473 //////////////////////////////////////////////////////////////////////////
1474 IAnyConstPtr CDocGraphStartTimerNode::GetCustomOutputDefault() const
1475 {
1476 return IAnyConstPtr();
1477 }
1478
1479 //////////////////////////////////////////////////////////////////////////
1480 size_t CDocGraphStartTimerNode::AddCustomOutput(const IAny& value)
1481 {
1482 return INVALID_INDEX;
1483 }
1484
1485 //////////////////////////////////////////////////////////////////////////
1486 void CDocGraphStartTimerNode::EnumerateOptionalOutputs(const ScriptGraphNodeOptionalOutputEnumerator& enumerator) {}
1487
1488 //////////////////////////////////////////////////////////////////////////
1489 size_t CDocGraphStartTimerNode::AddOptionalOutput(const char* szName, EScriptGraphPortFlags flags, const CAggregateTypeId& typeId)
1490 {
1491 return INVALID_INDEX;
1492 }
1493
1494 //////////////////////////////////////////////////////////////////////////
1495 void CDocGraphStartTimerNode::RemoveOutput(size_t outputIdx) {}
1496
1497 //////////////////////////////////////////////////////////////////////////
1498 void CDocGraphStartTimerNode::Refresh(const SScriptRefreshParams& params)
1499 {
1500 CRY_PROFILE_FUNCTION(PROFILE_LOADING_ONLY);
1501 CDocGraphNodeBase::Refresh(params);
1502 const IScriptFile& file = CDocGraphNodeBase::GetFile();
1503 const SGUID refGUID = CDocGraphNodeBase::GetRefGUID();
1504 CDocGraphNodeBase::AddInput("In", EScriptGraphPortFlags::MultiLink | EScriptGraphPortFlags::Execute);
1505 CDocGraphNodeBase::AddOutput("Out", EScriptGraphPortFlags::Execute);
1506 stack_string name = "Start Timer: ";
1507 const IScriptTimer* pTimer = file.GetTimer(refGUID);
1508 if(pTimer)
1509 {
1510 name.append(pTimer->GetName());
1511 }
1512 CDocGraphNodeBase::SetName(name.c_str());
1513 }
1514
1515 //////////////////////////////////////////////////////////////////////////
1516 void CDocGraphStartTimerNode::PreCompileSequence(IDocGraphSequencePreCompiler& preCompiler, size_t outputIdx) const {}
1517
1518 //////////////////////////////////////////////////////////////////////////
1519 void CDocGraphStartTimerNode::LinkSequence(IDocGraphSequenceLinker& linker, size_t outputIdx, const LibFunctionId& functionId) const {}
1520
1521 //////////////////////////////////////////////////////////////////////////
1522 void CDocGraphStartTimerNode::Compile(IDocGraphNodeCompiler& compiler, EDocGraphSequenceStep sequenceStep, size_t portIdx) const
1523 {
1524 switch(sequenceStep)
1525 {
1526 case EDocGraphSequenceStep::BeginInput:
1527 {
1528 CompileInputs(compiler);
1529 break;
1530 }
1531 }
1532 }
1533
1534 //////////////////////////////////////////////////////////////////////////
1535 void CDocGraphStartTimerNode::CompileInputs(IDocGraphNodeCompiler& compiler) const
1536 {
1537 const IScriptTimer* pTimer = CDocGraphNodeBase::GetFile().GetTimer(CDocGraphNodeBase::GetRefGUID());
1538 CRY_ASSERT(pTimer);
1539 if(pTimer)
1540 {
1541 compiler.StartTimer(pTimer->GetGUID(), CDocGraphNodeBase::GetGUID());
1542 }
1543 }
1544
1545 //////////////////////////////////////////////////////////////////////////
1546 CDocGraphStopTimerNode::CDocGraphStopTimerNode(IScriptFile& file, IDocGraph& graph, const SGUID& guid, const SGUID& contextGUID, const SGUID& refGUID, Vec2 pos)
1547 : CDocGraphNodeBase(file, graph, guid, "Stop Timer", EScriptGraphNodeType::StopTimer, contextGUID, refGUID, pos)
1548 {
1549 Refresh(SScriptRefreshParams(EScriptRefreshReason::Other));
1550 }
1551
1552 //////////////////////////////////////////////////////////////////////////
1553 IAnyConstPtr CDocGraphStopTimerNode::GetCustomOutputDefault() const
1554 {
1555 return IAnyConstPtr();
1556 }
1557
1558 //////////////////////////////////////////////////////////////////////////
1559 size_t CDocGraphStopTimerNode::AddCustomOutput(const IAny& value)
1560 {
1561 return INVALID_INDEX;
1562 }
1563
1564 //////////////////////////////////////////////////////////////////////////
1565 void CDocGraphStopTimerNode::EnumerateOptionalOutputs(const ScriptGraphNodeOptionalOutputEnumerator& enumerator) {}
1566
1567 //////////////////////////////////////////////////////////////////////////
1568 size_t CDocGraphStopTimerNode::AddOptionalOutput(const char* szName, EScriptGraphPortFlags flags, const CAggregateTypeId& typeId)
1569 {
1570 return INVALID_INDEX;
1571 }
1572
1573 //////////////////////////////////////////////////////////////////////////
1574 void CDocGraphStopTimerNode::RemoveOutput(size_t outputIdx) {}
1575
1576 //////////////////////////////////////////////////////////////////////////
1577 void CDocGraphStopTimerNode::Refresh(const SScriptRefreshParams& params)
1578 {
1579 CRY_PROFILE_FUNCTION(PROFILE_LOADING_ONLY);
1580 CDocGraphNodeBase::Refresh(params);
1581 const IScriptFile& file = CDocGraphNodeBase::GetFile();
1582 const SGUID refGUID = CDocGraphNodeBase::GetRefGUID();
1583 CDocGraphNodeBase::AddInput("In", EScriptGraphPortFlags::MultiLink | EScriptGraphPortFlags::Execute);
1584 CDocGraphNodeBase::AddOutput("Out", EScriptGraphPortFlags::Execute);
1585 stack_string name = "Stop Timer: ";
1586 const IScriptTimer* pTimer = file.GetTimer(refGUID);
1587 if(pTimer)
1588 {
1589 name.append(pTimer->GetName());
1590 }
1591 CDocGraphNodeBase::SetName(name.c_str());
1592 }
1593
1594 //////////////////////////////////////////////////////////////////////////
1595 void CDocGraphStopTimerNode::PreCompileSequence(IDocGraphSequencePreCompiler& preCompiler, size_t outputIdx) const {}
1596
1597 //////////////////////////////////////////////////////////////////////////
1598 void CDocGraphStopTimerNode::LinkSequence(IDocGraphSequenceLinker& linker, size_t outputIdx, const LibFunctionId& functionId) const {}
1599
1600 //////////////////////////////////////////////////////////////////////////
1601 void CDocGraphStopTimerNode::Compile(IDocGraphNodeCompiler& compiler, EDocGraphSequenceStep sequenceStep, size_t portIdx) const
1602 {
1603 switch(sequenceStep)
1604 {
1605 case EDocGraphSequenceStep::BeginInput:
1606 {
1607 CompileInputs(compiler);
1608 break;
1609 }
1610 }
1611 }
1612
1613 //////////////////////////////////////////////////////////////////////////
1614 void CDocGraphStopTimerNode::CompileInputs(IDocGraphNodeCompiler& compiler) const
1615 {
1616 const IScriptTimer* pTimer = CDocGraphNodeBase::GetFile().GetTimer(CDocGraphNodeBase::GetRefGUID());
1617 CRY_ASSERT(pTimer);
1618 if(pTimer)
1619 {
1620 compiler.StopTimer(pTimer->GetGUID(), CDocGraphNodeBase::GetGUID());
1621 }
1622 }
1623
1624 //////////////////////////////////////////////////////////////////////////
1625 CDocGraphResetTimerNode::CDocGraphResetTimerNode(IScriptFile& file, IDocGraph& graph, const SGUID& guid, const SGUID& contextGUID, const SGUID& refGUID, Vec2 pos)
1626 : CDocGraphNodeBase(file, graph, guid, "Reset Timer", EScriptGraphNodeType::ResetTimer, contextGUID, refGUID, pos)
1627 {
1628 Refresh(SScriptRefreshParams(EScriptRefreshReason::Other));
1629 }
1630
1631 //////////////////////////////////////////////////////////////////////////
1632 IAnyConstPtr CDocGraphResetTimerNode::GetCustomOutputDefault() const
1633 {
1634 return IAnyConstPtr();
1635 }
1636
1637 //////////////////////////////////////////////////////////////////////////
1638 size_t CDocGraphResetTimerNode::AddCustomOutput(const IAny& value)
1639 {
1640 return INVALID_INDEX;
1641 }
1642
1643 //////////////////////////////////////////////////////////////////////////
1644 void CDocGraphResetTimerNode::EnumerateOptionalOutputs(const ScriptGraphNodeOptionalOutputEnumerator& enumerator) {}
1645
1646 //////////////////////////////////////////////////////////////////////////
1647 size_t CDocGraphResetTimerNode::AddOptionalOutput(const char* szName, EScriptGraphPortFlags flags, const CAggregateTypeId& typeId)
1648 {
1649 return INVALID_INDEX;
1650 }
1651
1652 //////////////////////////////////////////////////////////////////////////
1653 void CDocGraphResetTimerNode::RemoveOutput(size_t outputIdx) {}
1654
1655 //////////////////////////////////////////////////////////////////////////
1656 void CDocGraphResetTimerNode::Refresh(const SScriptRefreshParams& params)
1657 {
1658 CRY_PROFILE_FUNCTION(PROFILE_LOADING_ONLY);
1659 CDocGraphNodeBase::Refresh(params);
1660 const IScriptFile& file = CDocGraphNodeBase::GetFile();
1661 const SGUID refGUID = CDocGraphNodeBase::GetRefGUID();
1662 CDocGraphNodeBase::AddInput("In", EScriptGraphPortFlags::MultiLink | EScriptGraphPortFlags::Execute);
1663 CDocGraphNodeBase::AddOutput("Out", EScriptGraphPortFlags::Execute);
1664 stack_string name = "Reset Timer: ";
1665 const IScriptTimer* pTimer = file.GetTimer(refGUID);
1666 if(pTimer)
1667 {
1668 name.append(pTimer->GetName());
1669 }
1670 CDocGraphNodeBase::SetName(name.c_str());
1671 }
1672
1673 //////////////////////////////////////////////////////////////////////////
1674 void CDocGraphResetTimerNode::PreCompileSequence(IDocGraphSequencePreCompiler& preCompiler, size_t outputIdx) const {}
1675
1676 //////////////////////////////////////////////////////////////////////////
1677 void CDocGraphResetTimerNode::LinkSequence(IDocGraphSequenceLinker& linker, size_t outputIdx, const LibFunctionId& functionId) const {}
1678
1679 //////////////////////////////////////////////////////////////////////////
1680 void CDocGraphResetTimerNode::Compile(IDocGraphNodeCompiler& compiler, EDocGraphSequenceStep sequenceStep, size_t portIdx) const
1681 {
1682 switch(sequenceStep)
1683 {
1684 case EDocGraphSequenceStep::BeginInput:
1685 {
1686 CompileInputs(compiler);
1687 break;
1688 }
1689 }
1690 }
1691
1692 //////////////////////////////////////////////////////////////////////////
1693 void CDocGraphResetTimerNode::CompileInputs(IDocGraphNodeCompiler& compiler) const
1694 {
1695 const IScriptTimer* pTimer = CDocGraphNodeBase::GetFile().GetTimer(CDocGraphNodeBase::GetRefGUID());
1696 CRY_ASSERT(pTimer);
1697 if(pTimer)
1698 {
1699 compiler.ResetTimer(pTimer->GetGUID(), CDocGraphNodeBase::GetGUID());
1700 }
1701 }
1702
1703 //////////////////////////////////////////////////////////////////////////
1704 CDocGraphBeginStateNode::CDocGraphBeginStateNode(IScriptFile& file, IDocGraph& graph, const SGUID& guid, const SGUID& contextGUID, const SGUID& refGUID, Vec2 pos)
1705 : CDocGraphNodeBase(file, graph, guid, "Begin", EScriptGraphNodeType::BeginState, contextGUID, refGUID, pos)
1706 {
1707 CDocGraphNodeBase::AddOutput("Out", EScriptGraphPortFlags::BeginSequence | EScriptGraphPortFlags::Execute);
1708 }
1709
1710 //////////////////////////////////////////////////////////////////////////
1711 IAnyConstPtr CDocGraphBeginStateNode::GetCustomOutputDefault() const
1712 {
1713 return IAnyConstPtr();
1714 }
1715
1716 //////////////////////////////////////////////////////////////////////////
1717 size_t CDocGraphBeginStateNode::AddCustomOutput(const IAny& value)
1718 {
1719 return INVALID_INDEX;
1720 }
1721
1722 //////////////////////////////////////////////////////////////////////////
1723 void CDocGraphBeginStateNode::EnumerateOptionalOutputs(const ScriptGraphNodeOptionalOutputEnumerator& enumerator) {}
1724
1725 //////////////////////////////////////////////////////////////////////////
1726 size_t CDocGraphBeginStateNode::AddOptionalOutput(const char* szName, EScriptGraphPortFlags flags, const CAggregateTypeId& typeId)
1727 {
1728 return INVALID_INDEX;
1729 }
1730
1731 //////////////////////////////////////////////////////////////////////////
1732 void CDocGraphBeginStateNode::RemoveOutput(size_t outputIdx) {}
1733
1734 //////////////////////////////////////////////////////////////////////////
1735 void CDocGraphBeginStateNode::Refresh(const SScriptRefreshParams& params) {}
1736
1737 //////////////////////////////////////////////////////////////////////////
1738 void CDocGraphBeginStateNode::PreCompileSequence(IDocGraphSequencePreCompiler& preCompiler, size_t outputIdx) const
1739 {
1740 preCompiler.AddFunctionOutput("Result", nullptr, MakeAny(int32(ELibTransitionResult::Continue)));
1741 preCompiler.AddFunctionOutput("State", nullptr, MakeAny(int32(0)));
1742 }
1743
1744 //////////////////////////////////////////////////////////////////////////
1745 void CDocGraphBeginStateNode::LinkSequence(IDocGraphSequenceLinker& linker, size_t outputIdx, const LibFunctionId& functionId) const
1746 {
1747 if(ILibStateMachine* pLibStateMachine = linker.GetLibStateMachine())
1748 {
1749 pLibStateMachine->SetBeginFunction(functionId);
1750 }
1751 }
1752
1753 //////////////////////////////////////////////////////////////////////////
1754 void CDocGraphBeginStateNode::Compile(IDocGraphNodeCompiler& compiler, EDocGraphSequenceStep sequenceStep, size_t portIdx) const {}
1755
1756 //////////////////////////////////////////////////////////////////////////
1757 CDocGraphEndStateNode::CDocGraphEndStateNode(IScriptFile& file, IDocGraph& graph, const SGUID& guid, const SGUID& contextGUID, const SGUID& refGUID, Vec2 pos)
1758 : CDocGraphNodeBase(file, graph, guid, "End", EScriptGraphNodeType::EndState, contextGUID, refGUID, pos)
1759 {
1760 CDocGraphNodeBase::AddInput("Success", EScriptGraphPortFlags::MultiLink | EScriptGraphPortFlags::EndSequence | EScriptGraphPortFlags::Execute);
1761 CDocGraphNodeBase::AddInput("Failure", EScriptGraphPortFlags::MultiLink | EScriptGraphPortFlags::EndSequence | EScriptGraphPortFlags::Execute);
1762 }
1763
1764 //////////////////////////////////////////////////////////////////////////
1765 IAnyConstPtr CDocGraphEndStateNode::GetCustomOutputDefault() const
1766 {
1767 return IAnyConstPtr();
1768 }
1769
1770 //////////////////////////////////////////////////////////////////////////
1771 size_t CDocGraphEndStateNode::AddCustomOutput(const IAny& value)
1772 {
1773 return INVALID_INDEX;
1774 }
1775
1776 //////////////////////////////////////////////////////////////////////////
1777 void CDocGraphEndStateNode::EnumerateOptionalOutputs(const ScriptGraphNodeOptionalOutputEnumerator& enumerator) {}
1778
1779 //////////////////////////////////////////////////////////////////////////
1780 size_t CDocGraphEndStateNode::AddOptionalOutput(const char* szName, EScriptGraphPortFlags flags, const CAggregateTypeId& typeId)
1781 {
1782 return INVALID_INDEX;
1783 }
1784
1785 //////////////////////////////////////////////////////////////////////////
1786 void CDocGraphEndStateNode::RemoveOutput(size_t outputIdx) {}
1787
1788 //////////////////////////////////////////////////////////////////////////
1789 void CDocGraphEndStateNode::Refresh(const SScriptRefreshParams& params) {}
1790
1791 //////////////////////////////////////////////////////////////////////////
1792 void CDocGraphEndStateNode::PreCompileSequence(IDocGraphSequencePreCompiler& preCompiler, size_t outputIdx) const {}
1793
1794 //////////////////////////////////////////////////////////////////////////
1795 void CDocGraphEndStateNode::LinkSequence(IDocGraphSequenceLinker& linker, size_t outputIdx, const LibFunctionId& functionId) const {}
1796
1797 //////////////////////////////////////////////////////////////////////////
1798 void CDocGraphEndStateNode::Compile(IDocGraphNodeCompiler& compiler, EDocGraphSequenceStep sequenceStep, size_t portIdx) const
1799 {
1800 switch(sequenceStep)
1801 {
1802 case EDocGraphSequenceStep::BeginInput:
1803 {
1804 End(compiler, portIdx == EInput::Success);
1805 break;
1806 }
1807 }
1808 }
1809
1810 //////////////////////////////////////////////////////////////////////////
1811 void CDocGraphEndStateNode::End(IDocGraphNodeCompiler& compiler, bool bSuccess) const
1812 {
1813 compiler.Set(0, MakeAny(int32(bSuccess ? ELibTransitionResult::EndSuccess : ELibTransitionResult::EndFailure)), SGUID(), "");
1814 compiler.Set(1, MakeAny(int32(~0)), SGUID(), "");
1815 compiler.Return(CDocGraphNodeBase::GetGUID());
1816 }
1817
1818 //////////////////////////////////////////////////////////////////////////
1819 // Comment Node
1820 CDocGraphCommentNode::CDocGraphCommentNode(IScriptFile& file, IDocGraph& graph, const SGUID& guid, const SGUID& contextGUID, const SGUID& refGUID, Vec2 pos)
1821 : CDocGraphNodeBase(file, graph, guid, "Comment", EScriptGraphNodeType::Comment, contextGUID, refGUID, pos)
1822 {
1823 }
1824
1825 //////////////////////////////////////////////////////////////////////////
1826 const char* CDocGraphCommentNode::GetComment() const
1827 {
1828 return m_str.c_str();
1829 }
1830
1831 //////////////////////////////////////////////////////////////////////////
1832 IAnyConstPtr CDocGraphCommentNode::GetCustomOutputDefault() const
1833 {
1834 return IAnyConstPtr();
1835 }
1836
1837 //////////////////////////////////////////////////////////////////////////
1838 size_t CDocGraphCommentNode::AddCustomOutput(const IAny& value)
1839 {
1840 return INVALID_INDEX;
1841 }
1842
1843 //////////////////////////////////////////////////////////////////////////
1844 void CDocGraphCommentNode::EnumerateOptionalOutputs(const ScriptGraphNodeOptionalOutputEnumerator& enumerator) { }
1845
1846 //////////////////////////////////////////////////////////////////////////
1847 size_t CDocGraphCommentNode::AddOptionalOutput(const char* szName, EScriptGraphPortFlags flags, const CAggregateTypeId& typeId)
1848 {
1849 return INVALID_INDEX;
1850 }
1851
1852 //////////////////////////////////////////////////////////////////////////
1853 void CDocGraphCommentNode::RemoveOutput(size_t outputIdx) { }
1854
1855 //////////////////////////////////////////////////////////////////////////
1856 void CDocGraphCommentNode::PreCompileSequence(IDocGraphSequencePreCompiler& preCompiler, size_t outputIdx) const { }
1857
1858 //////////////////////////////////////////////////////////////////////////
1859 void CDocGraphCommentNode::LinkSequence(IDocGraphSequenceLinker& linker, size_t outputIdx, const LibFunctionId& functionId) const { }
1860
1861 //////////////////////////////////////////////////////////////////////////
1862 void CDocGraphCommentNode::Compile(IDocGraphNodeCompiler& compiler, EDocGraphSequenceStep sequenceStep, size_t portIdx) const { }
1863
1864 //////////////////////////////////////////////////////////////////////////
1865 void CDocGraphCommentNode::Serialize(Serialization::IArchive& archive)
1866 {
1867 CDocGraphNodeBase::Serialize(archive);
1868 archive(m_str, "str", "Comment Contents");
1869 }
1870 }
CRYENGINE is a powerful real-time game development platform created by Crytek.