Implement signals

skelatool64/main.cpp

@@ -161,6 +161,8 @@ int main(int argc, char *argv[]) {
 
             auto triggerOutput = generateTriggers(scene, fileDef, settings, *roomOutput, signals, nodesByGroup);
 
+            auto signalsOutput = generateSignals(nodesByGroup);
+
             std::cout << "Generating level definitions" << std::endl;
             generateLevel(
                 scene,
@@ -169,7 +171,9 @@ int main(int argc, char *argv[]) {
                 *staticOutput, 
                 *collisionOutput,
                 *triggerOutput,
-                *roomOutput
+                *roomOutput,
+                *signalsOutput,
+                signals
             );
 
             nodesByGroup.PrintUnusedTypes();

skelatool64/src/definition_generator/LevelGenerator.cpp

@@ -402,7 +402,9 @@ void generateLevel(
         const StaticGeneratorOutput& staticOutput,
         const CollisionGeneratorOutput& collisionOutput,
         const TriggerGeneratorOutput& triggerOutput,
-        const RoomGeneratorOutput& roomOutput
+        const RoomGeneratorOutput& roomOutput,
+        const SignalsOutput& signalsOutput,
+        Signals& signals
 ) {    
     std::unique_ptr<StructureDataChunk> levelDef(new StructureDataChunk());
 
@@ -427,5 +429,7 @@ void generateLevel(
     generateDoorsDefinition(scene, fileDefinition, *levelDef, roomOutput, settings);
     generateButtonsDefinition(fileDefinition, *levelDef, triggerOutput.buttons);
 
+    generateSignalsDefinition(fileDefinition, *levelDef, signalsOutput, signals);
+
     fileDefinition.AddDefinition(std::unique_ptr<FileDefinition>(new DataFileDefinition("struct LevelDefinition", fileDefinition.GetUniqueName("level"), false, "_geo", std::move(levelDef))));
 }

skelatool64/src/definition_generator/LevelGenerator.h

@@ -15,7 +15,9 @@ void generateLevel(
         const StaticGeneratorOutput& staticOutput,
         const CollisionGeneratorOutput& collisionOutput,
         const TriggerGeneratorOutput& triggerOutput,
-        const RoomGeneratorOutput& roomOutput
+        const RoomGeneratorOutput& roomOutput,
+        const SignalsOutput& signalsOutput,
+        Signals& signals
 );
 
 #endif

skelatool64/src/definition_generator/Signals.cpp

@@ -99,7 +99,7 @@ std::unique_ptr<DataChunk> generateChunkForSignal(const SignalOperation& signal,
     return result;
 };
 
-std::unique_ptr<DataChunk> generateSignals(const std::vector<SignalOperation>& operations, Signals& signals) {
+std::unique_ptr<DataChunk> generateSignalData(const std::vector<SignalOperation>& operations, Signals& signals) {
     int timerCount = 0;
 
     std::unique_ptr<StructureDataChunk> result(new StructureDataChunk());
@@ -110,4 +110,82 @@ std::unique_ptr<DataChunk> generateSignals(const std::vector<SignalOperation>& o
     }
 
     return result;
+}
+
+
+std::shared_ptr<SignalsOutput> generateSignals(NodeGroups& nodeGroups) {
+    std::vector<SignalOperation> operations;
+    
+    for (auto& nodeInfo : nodeGroups.NodesForType("@and")) {
+        if (nodeInfo.arguments.size() <= 1) {
+            continue;
+        }
+
+        SignalOperation operation;
+        operation.type = SignalOperationType::And;
+        operation.outputName = nodeInfo.arguments[0];
+        operation.inputNames.assign(nodeInfo.arguments.begin() + 1, nodeInfo.arguments.end());
+
+        operations.push_back(operation);
+    }
+
+    for (auto& nodeInfo : nodeGroups.NodesForType("@or")) {
+        if (nodeInfo.arguments.size() <= 1) {
+            continue;
+        }
+
+        SignalOperation operation;
+        operation.type = SignalOperationType::Or;
+        operation.outputName = nodeInfo.arguments[0];
+        operation.inputNames.assign(nodeInfo.arguments.begin() + 1, nodeInfo.arguments.end());
+
+        operations.push_back(operation);
+    }
+
+    for (auto& nodeInfo : nodeGroups.NodesForType("@not")) {
+        if (nodeInfo.arguments.size() <= 1) {
+            continue;
+        }
+
+        SignalOperation operation;
+        operation.type = SignalOperationType::Not;
+        operation.outputName = nodeInfo.arguments[0];
+        operation.inputNames.push_back(nodeInfo.arguments[1]);
+
+        operations.push_back(operation);
+    }
+
+    for (auto& nodeInfo : nodeGroups.NodesForType("@timer")) {
+        if (nodeInfo.arguments.size() <= 2) {
+            continue;
+        }
+
+        SignalOperation operation;
+        operation.type = SignalOperationType::Timer;
+        operation.outputName = nodeInfo.arguments[0];
+        operation.inputNames.push_back(nodeInfo.arguments[1]);
+
+        operation.operand.duration = std::atof(nodeInfo.arguments[2].c_str());
+
+        operations.push_back(operation);
+    }
+
+    std::shared_ptr<SignalsOutput> result(new SignalsOutput());
+
+    result->signalOperations = orderSignals(operations);
+
+    return result;      
+}
+
+void generateSignalsDefinition(CFileDefinition& fileDefinition, StructureDataChunk& levelDef, const SignalsOutput& signalsOutput, Signals& signals) {
+    std::string signalsName = fileDefinition.AddDataDefinition(
+        "signal_operations", 
+        "struct SignalOperator", 
+        true, 
+        "_geo", 
+        std::move(generateSignalData(signalsOutput.signalOperations, signals))
+    );
+
+    levelDef.AddPrimitive("signalOperators", signalsName);
+    levelDef.AddPrimitive("signalOperatorCount", signalsOutput.signalOperations.size());
 }

skelatool64/src/definition_generator/Signals.h

@@ -33,6 +33,14 @@ private:
     std::map<std::string, int> signalNameToIndex;
 };
 
+struct SignalsOutput {
+    std::vector<SignalOperation> signalOperations;    
+};
+
+std::shared_ptr<SignalsOutput> generateSignals(NodeGroups& nodeGroups);
+
 std::vector<SignalOperation> orderSignals(const std::vector<SignalOperation>& signals);
 
+void generateSignalsDefinition(CFileDefinition& fileDefinition, StructureDataChunk& levelDef, const SignalsOutput& signalsOutput, Signals& signals);
+
 #endif

skelatool64/src/definition_generator/TriggerGenerator.cpp

@@ -186,6 +186,7 @@ std::shared_ptr<TriggerGeneratorOutput> generateTriggers(const aiScene* scene, C
 
         (baseTransform * nodeInfo.node->mTransformation).DecomposeNoScaling(rot, button.position);
         
+        button.roomIndex = roomOutput.RoomForNode(nodeInfo.node);
         button.signalIndex = nodeInfo.arguments.size() ? signals.SignalIndexForName(nodeInfo.arguments[0]) : -1;
 
         output->buttons.push_back(button);
@@ -201,6 +202,7 @@ void generateButtonsDefinition(CFileDefinition& fileDefinition, StructureDataChu
         std::unique_ptr<StructureDataChunk> singleButton(new StructureDataChunk());
 
         singleButton->Add(std::unique_ptr<StructureDataChunk>(new StructureDataChunk(ref.position)));
+        singleButton->AddPrimitive(ref.roomIndex);
         singleButton->AddPrimitive(ref.signalIndex);
 
         buttonData->Add(std::move(singleButton));

skelatool64/src/definition_generator/TriggerGenerator.h

@@ -15,6 +15,7 @@ struct Trigger {
 
 struct Button {
     aiVector3D position;
+    int roomIndex;
     int signalIndex;
 };
 

src/levels/level_definition.h

@@ -72,6 +72,7 @@ struct DoorDefinition {
 
 struct ButtonDefinition {
     struct Vector3 location;
+    short roomIndex;
     short signalIndex;
 };
 

src/scene/button.c

@@ -53,22 +53,22 @@ void buttonRender(void* data, struct RenderScene* renderScene) {
     renderSceneAdd(renderScene, button_gfx, matrix, button_material_index, &button->rigidBody.transform.position, armature);
 }
 
-void buttonInit(struct Button* button, struct Vector3* at, int roomIndex, int signalIndex) {
+void buttonInit(struct Button* button, struct ButtonDefinition* definition) {
     collisionObjectInit(&button->collisionObject, &gButtonCollider, &button->rigidBody, 1.0f);
     rigitBodyMarkKinematic(&button->rigidBody);
     collisionSceneAddDynamicObject(&button->collisionObject);
 
-    button->rigidBody.transform.position = *at;
+    button->rigidBody.transform.position = definition->location;
     quatIdent(&button->rigidBody.transform.rotation);
     button->rigidBody.transform.scale = gOneVec;
-    button->rigidBody.currentRoom = roomIndex;
+    button->rigidBody.currentRoom = definition->roomIndex;
 
     collisionObjectUpdateBB(&button->collisionObject);
 
     button->dynamicId = dynamicSceneAdd(button, buttonRender, &button->rigidBody.transform, 0.84f);
-    button->signalIndex = signalIndex;
+    button->signalIndex = definition->signalIndex;
 
-    button->originalPos = *at;
+    button->originalPos = definition->location;
 }
 
 void buttonUpdate(struct Button* button) {

src/scene/button.h

@@ -3,6 +3,7 @@
 
 #include "../physics/collision_object.h"
 #include "signals.h"
+#include "../levels/level_definition.h"
 
 struct Button {
     struct CollisionObject collisionObject;
@@ -12,7 +13,7 @@ struct Button {
     struct Vector3 originalPos;
 };
 
-void buttonInit(struct Button* button, struct Vector3* at, int roomIndex, int signalIndex);
+void buttonInit(struct Button* button, struct ButtonDefinition* definition);
 void buttonUpdate(struct Button* button);
 
 #endif

src/scene/door.c

@@ -28,16 +28,18 @@ void doorRender(void* data, struct RenderScene* renderScene) {
     renderSceneAdd(renderScene, door_01_gfx, matrix, door_01_material_index, &door->rigidBody.transform.position, armature);
 }
 
-void doorInit(struct Door* door, struct Transform* at, int roomA, int roomB, int doorwayIndex, int signalIndex) {
+void doorInit(struct Door* door, struct DoorDefinition* doorDefinition, int roomA, int roomB) {
     // collisionObjectInit(&cube->collisionObject, &gCubeCollider, &cube->rigidBody, 1.0f);
     // collisionSceneAddDynamicObject(&cube->collisionObject);
 
     // cube->collisionObject.body->flags |= RigidBodyFlagsGrabbable;
 
-    door->rigidBody.transform = *at;
+    door->rigidBody.transform.position = doorDefinition->location;
+    door->rigidBody.transform.rotation = doorDefinition->rotation;
+    door->rigidBody.transform.scale = gOneVec;
 
     door->dynamicId = dynamicSceneAdd(door, doorRender, &door->rigidBody.transform, 1.7f);
-    door->signalIndex = signalIndex;
+    door->signalIndex = doorDefinition->signalIndex;
     door->openAmount = 0.0f;
 }
 

src/scene/door.h

@@ -2,6 +2,7 @@
 #define __DOOR_H__
 
 #include "../physics/collision_object.h"
+#include "../levels/level_definition.h"
 
 struct Door {
     struct CollisionObject collisionObject;
@@ -11,7 +12,7 @@ struct Door {
     float openAmount;
 };
 
-void doorInit(struct Door* door, struct Transform* at, int roomA, int roomB, int doorwayIndex, int signalIndex);
+void doorInit(struct Door* door, struct DoorDefinition* doorDefinition, int roomA, int roomB);
 void doorUpdate(struct Door* door);
 
 #endif

src/scene/scene.c

@@ -56,13 +56,12 @@ void sceneInit(struct Scene* scene) {
         scene->cubes[i].rigidBody.angularVelocity = gOneVec;
     }
 
-    scene->buttonCount = 1;
+    scene->buttonCount = gCurrentLevel->buttonCount;
     scene->buttons = malloc(sizeof(struct Button) * scene->buttonCount);
-    struct Vector3 buttonPos;
-    buttonPos.x = 5.0f;
-    buttonPos.y = 0.0f;
-    buttonPos.z = 3.0f;
-    buttonInit(&scene->buttons[0], &buttonPos, 1, 0);
+
+    for (int i = 0; i < scene->buttonCount; ++i) {
+        buttonInit(&scene->buttons[i], &gCurrentLevel->buttons[i]);
+    }
 
     scene->decorCount = 0;
     scene->decor = malloc(sizeof(struct DecorObject*) * scene->decorCount);
@@ -81,14 +80,8 @@ void sceneInit(struct Scene* scene) {
     scene->doorCount = gCurrentLevel->doorCount;
     scene->doors = malloc(sizeof(struct Door) * scene->doorCount);
     for (int i = 0; i < scene->doorCount; ++i) {
-        struct Transform doorTransform;
-        doorTransform.position = gCurrentLevel->doors[i].location;
-        doorTransform.rotation = gCurrentLevel->doors[i].rotation;
-        doorTransform.scale = gOneVec;
-        doorInit(&scene->doors[i], &doorTransform, 0, 0, gCurrentLevel->doors[i].doorwayIndex, gCurrentLevel->doors[i].signalIndex);
+        doorInit(&scene->doors[i], &gCurrentLevel->doors[i], 0, 0);
     }
-
-    // scene->player.grabbing = &scene->cubes[0].rigidBody;
 }
 
 void sceneRenderWithProperties(void* data, struct RenderProps* properties, struct RenderState* renderState) {