Code/CryEngine/CrySchematyc2/Deprecated/VMOps.h

   1 // Copyright 2001-2019 Crytek GmbH / Crytek Group. All rights reserved.
   2
   3 #pragma once
   4
   5 #include <CrySchematyc2/GUID.h> // #SchematycTODO : Remove this include?
   6
   7 namespace Schematyc2
   8 {
   9         struct SVMOp
  10         {
  11                 enum EOpCode
  12                 {
  13                         PUSH = 0,                                                                                                                       // Push value onto top of stack.
  14                         SET,                                                                                                                                    // Set value at given position on stack.
  15                         COPY,                                                                                                                                   // Copy value on stack.
  16                         POP,                                                                                                                                    // Pop value from top of stack.
  17                         COLLAPSE,                                                                                                                       // Collapse stack to a specified size.
  18                         LOAD,                                                                                                                                   // Load variable to top of stack.
  19                         STORE,                                                                                                                          // Store value at top of stack in variable.
  20                         CONTAINER_ADD,                                                                                          // Add value at top of stack in container.
  21                         CONTAINER_REMOVE_BY_INDEX,                                              // Remove index at top of stack from container.
  22                         CONTAINER_REMOVE_BY_VALUE,                                              // Remove value at top of stack from container.
  23                         CONTAINER_CLEAR,                                                                                        // Clear container.
  24                         CONTAINER_SIZE,                                                                                         // Copy size of container to top of stack.
  25                         CONTAINER_GET,                                                                                          // Copy element at given index from container to top of stack.
  26                         CONTAINER_SET,                                                                                          // Set value to container. Container index and value are at top of stack.
  27                         CONTAINER_FIND_BY_VALUE,                                                // Find value's index in container by value at top of stack.
  28                         COMPARE,                                                                                                                        // Compare two values on stack.
  29                         INCREMENT_INT32,                                                                                        // Increment int32.
  30                         LESS_THAN_INT32,                                                                                        // Compare two int32s.
  31                         GREATER_THAN_INT32,                                                                             // Compare two int32s.
  32                         BRANCH,                                                                                                                         // Branch to another location.
  33                         BRANCH_IF_ZERO,                                                                                         // Branch to another location if the value at the top of the stack is zero.
  34                         BRANCH_IF_NOT_ZERO,                                                                             // Branch to another location if the value at the top of the stack is not zero.
  35                         GET_OBJECT,                                                                                                             // Copy object id to stack.
  36                         START_TIMER,                                                                                                    // Start a timer.
  37                         STOP_TIMER,                                                                                                             // Stop a timer.
  38                         RESET_TIMER,                                                                                                    // Reset a timer.
  39                         SEND_SIGNAL,                                                                                                    // Send a signal.
  40                         BROADCAST_SIGNAL,                                                                                       // Broadcast a signal.
  41                         CALL_GLOBAL_FUNCTION,                                                                   // Call a global function.
  42                         CALL_ENV_ABSTRACT_INTERFACE_FUNCTION,   // Call an environment abstract interface function.
  43                         CALL_LIB_ABSTRACT_INTERFACE_FUNCTION,   // Call a library abstract interface function.
  44                         CALL_COMPONENT_MEMBER_FUNCTION,                         // Call a component function.
  45                         CALL_ACTION_MEMBER_FUNCTION,                                    // Call a action function.
  46                         CALL_LIB_FUNCTION,                                                                              // Call a library function.
  47                         RETURN                                                                                                                          // Exit the current function.
  48                 };
  49
  50                 inline SVMOp(SVMOp::EOpCode _opCode, size_t _size)
  51                         : opCode(_opCode)
  52                         , size(_size)
  53                 {}
  54
  55                 SVMOp::EOpCode  opCode;
  56                 size_t                                  size;
  57         };
  58
  59         struct SVMPushOp : public SVMOp
  60         {
  61                 inline SVMPushOp(size_t _iConstValue)
  62                         : SVMOp(SVMOp::PUSH, sizeof(*this))
  63                         , iConstValue(_iConstValue)
  64                 {}
  65
  66                 size_t  iConstValue;
  67         };
  68
  69         struct SVMSetOp : public SVMOp
  70         {
  71                 inline SVMSetOp(size_t _pos, size_t _iConstValue)
  72                         : SVMOp(SVMOp::SET, sizeof(*this))
  73                         , pos(_pos)
  74                         , iConstValue(_iConstValue)
  75                 {}
  76
  77                 size_t  pos;
  78                 size_t  iConstValue;
  79         };
  80
  81         struct SVMCopyOp : public SVMOp
  82         {
  83                 inline SVMCopyOp(size_t _srcPos, size_t _dstPos)
  84                         : SVMOp(SVMOp::COPY, sizeof(*this))
  85                         , srcPos(_srcPos)
  86                         , dstPos(_dstPos)
  87                 {}
  88
  89                 size_t  srcPos;
  90                 size_t  dstPos;
  91         };
  92
  93         struct SVMPopOp : public SVMOp
  94         {
  95                 inline SVMPopOp(size_t _count)
  96                         : SVMOp(SVMOp::POP, sizeof(*this))
  97                         , count(_count)
  98                 {}
  99
 100                 size_t  count;
 101         };
 102
 103         struct SVMCollapseOp : public SVMOp
 104         {
 105                 inline SVMCollapseOp(size_t _pos)
 106                         : SVMOp(SVMOp::COLLAPSE, sizeof(*this))
 107                         , pos(_pos)
 108                 {}
 109
 110                 size_t  pos;
 111         };
 112
 113         struct SVMLoadOp : public SVMOp
 114         {
 115                 inline SVMLoadOp(size_t _pos, size_t _count)
 116                         : SVMOp(SVMOp::LOAD, sizeof(*this))
 117                         , pos(_pos)
 118                         , count(_count)
 119                 {}
 120
 121                 size_t  pos;
 122                 size_t  count;
 123         };
 124
 125         struct SVMStoreOp : public SVMOp
 126         {
 127                 inline SVMStoreOp(size_t _pos, size_t _count)
 128                         : SVMOp(SVMOp::STORE, sizeof(*this))
 129                         , pos(_pos)
 130                         , count(_count)
 131                 {}
 132
 133                 size_t  pos;
 134                 size_t  count;
 135         };
 136
 137         struct SVMContainerAddOp : public SVMOp
 138         {
 139                 inline SVMContainerAddOp(size_t _iContainer, size_t _count)
 140                         : SVMOp(SVMOp::CONTAINER_ADD, sizeof(*this))
 141                         , iContainer(_iContainer)
 142                         , count(_count)
 143                 {}
 144
 145                 size_t  iContainer;
 146                 size_t  count;
 147         };
 148
 149         struct SVMContainerRemoveByIndexOp : public SVMOp
 150         {
 151                 inline SVMContainerRemoveByIndexOp(size_t _iContainer, size_t _count)
 152                         : SVMOp(SVMOp::CONTAINER_REMOVE_BY_INDEX, sizeof(*this))
 153                         , iContainer(_iContainer)
 154                         , count(_count)
 155                 {}
 156
 157                 size_t  iContainer;
 158                 size_t  count;
 159         };
 160
 161         struct SVMContainerRemoveByValueOp : public SVMOp
 162         {
 163                 inline SVMContainerRemoveByValueOp(size_t _iContainer, size_t _count)
 164                         : SVMOp(SVMOp::CONTAINER_REMOVE_BY_VALUE, sizeof(*this))
 165                         , iContainer(_iContainer)
 166                         , count(_count)
 167                 {}
 168
 169                 size_t  iContainer;
 170                 size_t  count;
 171         };
 172
 173         struct SVMContainerClearOp : public SVMOp
 174         {
 175                 inline SVMContainerClearOp(size_t _iContainer)
 176                         : SVMOp(SVMOp::CONTAINER_CLEAR, sizeof(*this))
 177                         , iContainer(_iContainer)
 178                 {}
 179
 180                 size_t  iContainer;
 181         };
 182
 183         struct SVMContainerSizeOp : public SVMOp
 184         {
 185                 inline SVMContainerSizeOp(size_t _iContainer, size_t _divisor)
 186                         : SVMOp(SVMOp::CONTAINER_SIZE, sizeof(*this))
 187                         , iContainer(_iContainer)
 188                         , divisor(_divisor)
 189                 {}
 190
 191                 size_t  iContainer;
 192                 size_t  divisor;
 193         };
 194
 195         struct SVMContainerGetOp : public SVMOp
 196         {
 197                 inline SVMContainerGetOp(size_t _iContainer, size_t _count)
 198                         : SVMOp(SVMOp::CONTAINER_GET, sizeof(*this))
 199                         , iContainer(_iContainer)
 200                         , count(_count)
 201                 {}
 202
 203                 size_t  iContainer;
 204                 size_t  count;
 205         };
 206
 207         struct SVMContainerSetOp : public SVMOp
 208         {
 209                 inline SVMContainerSetOp(size_t _iContainer, size_t _count)
 210                         : SVMOp(SVMOp::CONTAINER_SET, sizeof(*this))
 211                         , iContainer(_iContainer)
 212                         , count(_count)
 213                 {}
 214
 215                 size_t  iContainer;
 216                 size_t  count;
 217         };
 218
 219         struct SVMContainerFindByValueOp : public SVMOp
 220         {
 221                 inline SVMContainerFindByValueOp(size_t _iContainer, size_t _count)
 222                         : SVMOp(SVMOp::CONTAINER_FIND_BY_VALUE, sizeof(*this))
 223                         , iContainer(_iContainer)
 224                         , count(_count)
 225                 {}
 226
 227                 size_t  iContainer;
 228                 size_t  count;
 229         };
 230
 231         struct SVMCompareOp : public SVMOp
 232         {
 233                 inline SVMCompareOp(size_t _lhsPos, size_t _rhsPos, size_t _count)
 234                         : SVMOp(SVMOp::COMPARE, sizeof(*this))
 235                         , lhsPos(_lhsPos)
 236                         , rhsPos(_rhsPos)
 237                         , count(_count)
 238                 {}
 239
 240                 size_t  lhsPos;
 241                 size_t  rhsPos;
 242                 size_t  count;
 243         };
 244
 245         struct SVMIncrementInt32Op : public SVMOp
 246         {
 247                 inline SVMIncrementInt32Op(size_t _pos)
 248                         : SVMOp(SVMOp::INCREMENT_INT32, sizeof(*this))
 249                         , pos(_pos)
 250                 {}
 251
 252                 size_t  pos;
 253         };
 254
 255         struct SVMLessThanInt32Op : public SVMOp
 256         {
 257                 inline SVMLessThanInt32Op(size_t _lhsPos, size_t _rhsPos)
 258                         : SVMOp(SVMOp::LESS_THAN_INT32, sizeof(*this))
 259                         , lhsPos(_lhsPos)
 260                         , rhsPos(_rhsPos)
 261                 {}
 262
 263                 size_t  lhsPos;
 264                 size_t  rhsPos;
 265         };
 266
 267         struct SVMGreaterThanInt32Op : public SVMOp
 268         {
 269                 inline SVMGreaterThanInt32Op(size_t _lhsPos, size_t _rhsPos)
 270                         : SVMOp(SVMOp::GREATER_THAN_INT32, sizeof(*this))
 271                         , lhsPos(_lhsPos)
 272                         , rhsPos(_rhsPos)
 273                 {}
 274
 275                 size_t  lhsPos;
 276                 size_t  rhsPos;
 277         };
 278
 279         struct SVMBranchOp : public SVMOp
 280         {
 281                 inline SVMBranchOp(size_t _pos)
 282                         : SVMOp(SVMOp::BRANCH, sizeof(*this))
 283                         , pos(_pos)
 284                 {}
 285
 286                 size_t pos;
 287         };
 288
 289         struct SVMBranchIfZeroOp : public SVMOp
 290         {
 291                 inline SVMBranchIfZeroOp(size_t _pos)
 292                         : SVMOp(SVMOp::BRANCH_IF_ZERO, sizeof(*this))
 293                         , pos(_pos)
 294                 {}
 295
 296                 size_t pos;
 297         };
 298
 299         struct SVMBranchIfNotZeroOp : public SVMOp
 300         {
 301                 inline SVMBranchIfNotZeroOp(size_t _pos)
 302                         : SVMOp(SVMOp::BRANCH_IF_NOT_ZERO, sizeof(*this))
 303                         , pos(_pos)
 304                 {}
 305
 306                 size_t pos;
 307         };
 308
 309         struct SVMGetObjectOp : public SVMOp
 310         {
 311                 inline SVMGetObjectOp()
 312                         : SVMOp(SVMOp::GET_OBJECT, sizeof(*this))
 313                 {}
 314         };
 315
 316         struct SVMSendSignalOp : public SVMOp
 317         {
 318                 inline SVMSendSignalOp(const SGUID& _guid)
 319                         : SVMOp(SVMOp::SEND_SIGNAL, sizeof(*this))
 320                         , guid(_guid)
 321                 {}
 322
 323                 SGUID guid;
 324         };
 325
 326         struct SVMBroadcastSignalOp : public SVMOp
 327         {
 328                 inline SVMBroadcastSignalOp(const SGUID& _guid)
 329                         : SVMOp(SVMOp::BROADCAST_SIGNAL, sizeof(*this))
 330                         , guid(_guid)
 331                 {}
 332
 333                 SGUID guid;
 334         };
 335
 336         struct SVMCallGlobalFunctionOp : public SVMOp
 337         {
 338                 inline SVMCallGlobalFunctionOp(const uint32 _iGlobalFunction)
 339                         : SVMOp(SVMOp::CALL_GLOBAL_FUNCTION, sizeof(*this))
 340                         , iGlobalFunction(_iGlobalFunction)
 341                 {}
 342
 343                 uint32  iGlobalFunction;
 344         };
 345
 346         struct SVMCallEnvAbstractInterfaceFunctionOp : public SVMOp
 347         {
 348                 inline SVMCallEnvAbstractInterfaceFunctionOp(const SGUID& _abstractInterfaceGUID, const SGUID& _functionGUID)
 349                         : SVMOp(SVMOp::CALL_ENV_ABSTRACT_INTERFACE_FUNCTION, sizeof(*this))
 350                         , abstractInterfaceGUID(_abstractInterfaceGUID)
 351                         , functionGUID(_functionGUID)
 352                 {}
 353
 354                 const SGUID     abstractInterfaceGUID;
 355                 const SGUID     functionGUID;
 356         };
 357
 358         struct SVMCallLibAbstractInterfaceFunctionOp : public SVMOp
 359         {
 360                 inline SVMCallLibAbstractInterfaceFunctionOp(const SGUID& _abstractInterfaceGUID, const SGUID& _functionGUID)
 361                         : SVMOp(SVMOp::CALL_LIB_ABSTRACT_INTERFACE_FUNCTION, sizeof(*this))
 362                         , abstractInterfaceGUID(_abstractInterfaceGUID)
 363                         , functionGUID(_functionGUID)
 364                 {}
 365
 366                 const SGUID     abstractInterfaceGUID;
 367                 const SGUID     functionGUID;
 368         };
 369
 370         struct SVMCallComponentMemberFunctionOp : public SVMOp
 371         {
 372                 inline SVMCallComponentMemberFunctionOp(const uint32 _iComponentMemberFunction)
 373                         : SVMOp(SVMOp::CALL_COMPONENT_MEMBER_FUNCTION, sizeof(*this))
 374                         , iComponentMemberFunction(_iComponentMemberFunction)
 375                 {}
 376
 377                 uint32 iComponentMemberFunction;
 378         };
 379
 380         struct SVMCallActionMemberFunctionOp : public SVMOp
 381         {
 382                 inline SVMCallActionMemberFunctionOp(const uint32 _iActionMemberFunction)
 383                         : SVMOp(SVMOp::CALL_ACTION_MEMBER_FUNCTION, sizeof(*this))
 384                         , iActionMemberFunction(_iActionMemberFunction)
 385                 {}
 386
 387                 uint32 iActionMemberFunction;
 388         };
 389
 390         struct SVMCallLibFunctionOp : public SVMOp
 391         {
 392                 inline SVMCallLibFunctionOp(const LibFunctionId& _functionId)
 393                         : SVMOp(SVMOp::CALL_LIB_FUNCTION, sizeof(*this))
 394                         , functionId(_functionId)
 395                 {}
 396
 397                 LibFunctionId functionId;
 398         };
 399
 400         struct SVMStartTimerOp : public SVMOp
 401         {
 402                 inline SVMStartTimerOp(const SGUID& _guid)
 403                         : SVMOp(SVMOp::START_TIMER, sizeof(*this))
 404                         , guid(_guid)
 405                 {}
 406
 407                 SGUID guid;
 408         };
 409
 410         struct SVMStopTimerOp : public SVMOp
 411         {
 412                 inline SVMStopTimerOp(const SGUID& _guid)
 413                         : SVMOp(SVMOp::STOP_TIMER, sizeof(*this))
 414                         , guid(_guid)
 415                 {}
 416
 417                 SGUID guid;
 418         };
 419
 420         struct SVMResetTimerOp : public SVMOp
 421         {
 422                 inline SVMResetTimerOp(const SGUID& _guid)
 423                         : SVMOp(SVMOp::RESET_TIMER, sizeof(*this))
 424                         , guid(_guid)
 425                 {}
 426
 427                 SGUID guid;
 428         };
 429
 430         struct SVMReturnOp : public SVMOp
 431         {
 432                 inline SVMReturnOp()
 433                         : SVMOp(SVMOp::RETURN, sizeof(*this))
 434                 {}
 435         };
 436 }