diff --git a/AlgebraicDataflowArchitectureModel/models/GameEngine.model b/AlgebraicDataflowArchitectureModel/models/GameEngine.model new file mode 100644 index 0000000..b8173e4 --- /dev/null +++ b/AlgebraicDataflowArchitectureModel/models/GameEngine.model @@ -0,0 +1,43 @@ +native channel SceneUpdateEvent { + out scene.time(time: Long, updateEvent(dt: Long)) = time + dt +} + +native channel KeyEvent(kno: Int) { + out scene.keys.{kno}.state(curState: Int, keyEvent(nextState)) = nextState +} + +native channel SceneUpdate { + in scene(curSc: Json, update(curSc, nextSc)) = nextSc +} + +native channel CameraPositionUpdate { + in scene.camera.transform.position(curPos: Json, updatePosition(x: Double, y: Double, z: Double)) = {"x": x, "y": y, "z": z} +} + +native channel CameraRotationUpdate { + in scene.camera.transform.rotation(curRot: Json, updateRotation(x: Double, y: Double, z: Double)) = {"x": x, "y": y, "z": z} +} + +native channel CameraScaleUpdate { + in scene.camera.transform.scale(curScale: Json, updateScale(x: Double, y: Double, z: Double)) = {"x": x, "y": y, "z": z} +} + +native channel CameraProjectionUpdate { + in scene.camera.projection(curProj: Json, updateProjection(curProj, nextProj)) = nextProj +} + +native channel EntityPositionUpdate(eid: Str) { + in scene.entities.{eid}.transform.position(curPos: Json, updatePosition(x: Double, y: Double, z: Double)) = {"x": x, "y": y, "z": z} +} + +native channel EntityRotationUpdate(eid: Str) { + in scene.entities.{eid}.transform.rotation(curRot: Json, updateRotation(x: Double, y: Double, z: Double)) = {"x": x, "y": y, "z": z} +} + +native channel EntityScaleUpdate(eid: Str) { + in scene.entities.{eid}.transform.scale(curScale: Json, updateScale(x: Double, y: Double, z: Double)) = {"x": x, "y": y, "z": z} +} + +native channel EntitySpriteUpdate(eid: Str) { + in scene.entities.{eid}.mesh(curMesh: Json, updateSprite(spritePath: Str)) = {"type": "sprite", "sprite": spritePath} +} diff --git a/AlgebraicDataflowArchitectureModel/src/simulator/interfaces/gameEngine/CameraPositionReceiver.java b/AlgebraicDataflowArchitectureModel/src/simulator/interfaces/gameEngine/CameraPositionReceiver.java new file mode 100644 index 0000000..75f465e --- /dev/null +++ b/AlgebraicDataflowArchitectureModel/src/simulator/interfaces/gameEngine/CameraPositionReceiver.java @@ -0,0 +1,31 @@ +package simulator.interfaces.gameEngine; + +import models.algebra.Expression; +import models.algebra.Term; +import simulator.Event; +import simulator.SystemState; +import simulator.interfaces.INativeReceiver; +import simulator.interfaces.gameEngine.GameEnginePresenter.Camera; + +public class CameraPositionReceiver implements INativeReceiver { + private Camera camera; + + public CameraPositionReceiver(Camera camera) { + this.camera = camera; + } + + @Override + public void onReceiveFromModel(Event event, SystemState nextSystemState) { + Expression message = event.getMessage(); + if (message instanceof Term) { + Expression xExp = ((Term) message).getChild(0); + Expression yExp = ((Term) message).getChild(1); + Expression zExp = ((Term) message).getChild(2); + Float x = Float.parseFloat(xExp.toString()); + Float y = Float.parseFloat(yExp.toString()); + Float z = Float.parseFloat(zExp.toString()); + camera.transform.setPosition(x, y, z); + } + } + +} diff --git a/AlgebraicDataflowArchitectureModel/src/simulator/interfaces/gameEngine/CameraProjectionReceiver.java b/AlgebraicDataflowArchitectureModel/src/simulator/interfaces/gameEngine/CameraProjectionReceiver.java new file mode 100644 index 0000000..f71c139 --- /dev/null +++ b/AlgebraicDataflowArchitectureModel/src/simulator/interfaces/gameEngine/CameraProjectionReceiver.java @@ -0,0 +1,24 @@ +package simulator.interfaces.gameEngine; + +import models.algebra.Expression; +import models.algebra.Term; +import simulator.Event; +import simulator.SystemState; +import simulator.interfaces.INativeReceiver; +import simulator.interfaces.gameEngine.GameEnginePresenter.Camera; + +public class CameraProjectionReceiver implements INativeReceiver { + private Camera camera; + + public CameraProjectionReceiver(Camera camera) { + this.camera = camera; + } + + @Override + public void onReceiveFromModel(Event event, SystemState nextSystemState) { + Expression message = event.getMessage(); + if (message instanceof Term) { + } + } + +} diff --git a/AlgebraicDataflowArchitectureModel/src/simulator/interfaces/gameEngine/CameraRotationReceiver.java b/AlgebraicDataflowArchitectureModel/src/simulator/interfaces/gameEngine/CameraRotationReceiver.java new file mode 100644 index 0000000..0aad202 --- /dev/null +++ b/AlgebraicDataflowArchitectureModel/src/simulator/interfaces/gameEngine/CameraRotationReceiver.java @@ -0,0 +1,31 @@ +package simulator.interfaces.gameEngine; + +import models.algebra.Expression; +import models.algebra.Term; +import simulator.Event; +import simulator.SystemState; +import simulator.interfaces.INativeReceiver; +import simulator.interfaces.gameEngine.GameEnginePresenter.Camera; + +public class CameraRotationReceiver implements INativeReceiver { + private Camera camera; + + public CameraRotationReceiver(Camera camera) { + this.camera = camera; + } + + @Override + public void onReceiveFromModel(Event event, SystemState nextSystemState) { + Expression message = event.getMessage(); + if (message instanceof Term) { + Expression xExp = ((Term) message).getChild(0); + Expression yExp = ((Term) message).getChild(1); + Expression zExp = ((Term) message).getChild(2); + Float x = Float.parseFloat(xExp.toString()); + Float y = Float.parseFloat(yExp.toString()); + Float z = Float.parseFloat(zExp.toString()); + camera.transform.setRotation(x, y, z); + } + } + +} diff --git a/AlgebraicDataflowArchitectureModel/src/simulator/interfaces/gameEngine/CameraScaleReceiver.java b/AlgebraicDataflowArchitectureModel/src/simulator/interfaces/gameEngine/CameraScaleReceiver.java new file mode 100644 index 0000000..95c7013 --- /dev/null +++ b/AlgebraicDataflowArchitectureModel/src/simulator/interfaces/gameEngine/CameraScaleReceiver.java @@ -0,0 +1,31 @@ +package simulator.interfaces.gameEngine; + +import models.algebra.Expression; +import models.algebra.Term; +import simulator.Event; +import simulator.SystemState; +import simulator.interfaces.INativeReceiver; +import simulator.interfaces.gameEngine.GameEnginePresenter.Camera; + +public class CameraScaleReceiver implements INativeReceiver { + private Camera camera; + + public CameraScaleReceiver(Camera camera) { + this.camera = camera; + } + + @Override + public void onReceiveFromModel(Event event, SystemState nextSystemState) { + Expression message = event.getMessage(); + if (message instanceof Term) { + Expression xExp = ((Term) message).getChild(0); + Expression yExp = ((Term) message).getChild(1); + Expression zExp = ((Term) message).getChild(2); + Float x = Float.parseFloat(xExp.toString()); + Float y = Float.parseFloat(yExp.toString()); + Float z = Float.parseFloat(zExp.toString()); + camera.transform.setScale(x, y, z); + } + } + +} diff --git a/AlgebraicDataflowArchitectureModel/src/simulator/interfaces/gameEngine/EntityPositionReceiver.java b/AlgebraicDataflowArchitectureModel/src/simulator/interfaces/gameEngine/EntityPositionReceiver.java new file mode 100644 index 0000000..513050d --- /dev/null +++ b/AlgebraicDataflowArchitectureModel/src/simulator/interfaces/gameEngine/EntityPositionReceiver.java @@ -0,0 +1,31 @@ +package simulator.interfaces.gameEngine; + +import models.algebra.Expression; +import models.algebra.Term; +import simulator.Event; +import simulator.SystemState; +import simulator.interfaces.INativeReceiver; +import simulator.interfaces.gameEngine.GameEnginePresenter.Entity; + +public class EntityPositionReceiver implements INativeReceiver { + private Entity entity; + + public EntityPositionReceiver(Entity entity) { + this.entity = entity; + } + + @Override + public void onReceiveFromModel(Event event, SystemState nextSystemState) { + Expression message = event.getMessage(); + if (message instanceof Term) { + Expression xExp = ((Term) message).getChild(0); + Expression yExp = ((Term) message).getChild(1); + Expression zExp = ((Term) message).getChild(2); + Float x = Float.parseFloat(xExp.toString()); + Float y = Float.parseFloat(yExp.toString()); + Float z = Float.parseFloat(zExp.toString()); + entity.transform.setPosition(x, y, z); + } + } + +} diff --git a/AlgebraicDataflowArchitectureModel/src/simulator/interfaces/gameEngine/EntityRotationReceiver.java b/AlgebraicDataflowArchitectureModel/src/simulator/interfaces/gameEngine/EntityRotationReceiver.java new file mode 100644 index 0000000..5a8d2b2 --- /dev/null +++ b/AlgebraicDataflowArchitectureModel/src/simulator/interfaces/gameEngine/EntityRotationReceiver.java @@ -0,0 +1,31 @@ +package simulator.interfaces.gameEngine; + +import models.algebra.Expression; +import models.algebra.Term; +import simulator.Event; +import simulator.SystemState; +import simulator.interfaces.INativeReceiver; +import simulator.interfaces.gameEngine.GameEnginePresenter.Entity; + +public class EntityRotationReceiver implements INativeReceiver { + private Entity entity; + + public EntityRotationReceiver(Entity entity) { + this.entity = entity; + } + + @Override + public void onReceiveFromModel(Event event, SystemState nextSystemState) { + Expression message = event.getMessage(); + if (message instanceof Term) { + Expression xExp = ((Term) message).getChild(0); + Expression yExp = ((Term) message).getChild(1); + Expression zExp = ((Term) message).getChild(2); + Float x = Float.parseFloat(xExp.toString()); + Float y = Float.parseFloat(yExp.toString()); + Float z = Float.parseFloat(zExp.toString()); + entity.transform.setRotation(x, y, z); + } + } + +} diff --git a/AlgebraicDataflowArchitectureModel/src/simulator/interfaces/gameEngine/EntityScaleReceiver.java b/AlgebraicDataflowArchitectureModel/src/simulator/interfaces/gameEngine/EntityScaleReceiver.java new file mode 100644 index 0000000..31786dd --- /dev/null +++ b/AlgebraicDataflowArchitectureModel/src/simulator/interfaces/gameEngine/EntityScaleReceiver.java @@ -0,0 +1,31 @@ +package simulator.interfaces.gameEngine; + +import models.algebra.Expression; +import models.algebra.Term; +import simulator.Event; +import simulator.SystemState; +import simulator.interfaces.INativeReceiver; +import simulator.interfaces.gameEngine.GameEnginePresenter.Entity; + +public class EntityScaleReceiver implements INativeReceiver { + private Entity entity; + + public EntityScaleReceiver(Entity entity) { + this.entity = entity; + } + + @Override + public void onReceiveFromModel(Event event, SystemState nextSystemState) { + Expression message = event.getMessage(); + if (message instanceof Term) { + Expression xExp = ((Term) message).getChild(0); + Expression yExp = ((Term) message).getChild(1); + Expression zExp = ((Term) message).getChild(2); + Float x = Float.parseFloat(xExp.toString()); + Float y = Float.parseFloat(yExp.toString()); + Float z = Float.parseFloat(zExp.toString()); + entity.transform.setScale(x, y, z); + } + } + +} diff --git a/AlgebraicDataflowArchitectureModel/src/simulator/interfaces/gameEngine/GameEnginePresenter.java b/AlgebraicDataflowArchitectureModel/src/simulator/interfaces/gameEngine/GameEnginePresenter.java new file mode 100644 index 0000000..af4fc10 --- /dev/null +++ b/AlgebraicDataflowArchitectureModel/src/simulator/interfaces/gameEngine/GameEnginePresenter.java @@ -0,0 +1,296 @@ +package simulator.interfaces.gameEngine; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import models.algebra.Expression; +import models.algebra.Term; +import models.dataConstraintModel.JsonTerm; +import models.dataConstraintModel.MapTerm; +import models.dataFlowModel.DataTransferChannel; +import simulator.Event; +import simulator.Resource; +import simulator.Simulator; +import simulator.SystemState; +import simulator.interfaces.INativeReceiver; + +public class GameEnginePresenter implements INativeReceiver { + public final String sceneUpdateChannelName = "SceneUpdate"; + public final String cameraPositionUpdateChannelName = "CameraPositionUpdate"; + public final String cameraRotationUpdateChannelName = "CameraRotationUpdate"; + public final String cameraScaleUpdateChannelName = "CameraScaleUpdate"; + public final String cameraProjectionUpdateChannelName = "CameraProjectionUpdate"; + public final String entityPositionUpdateChannelName = "EntityPositionUpdate"; + public final String entityRotationUpdateChannelName = "EntityRotationUpdate"; + public final String entityScaleUpdateChannelName = "EntityScaleUpdate"; + public final String spriteUpdateChannelName = "SpriteUpdate"; + + public final String sceneUpdateEventChannelName = "SceneUpdateEvent"; + public final String keyEventChannelName = "KeyEvent"; + + protected Scene scene; + protected Simulator simulator; + + protected DataTransferChannel sceneUpdateChannel; + protected DataTransferChannel cameraPositionUpdateChannel; + protected DataTransferChannel cameraRotationUpdateChannel; + protected DataTransferChannel cameraScaleUpdateChannel; + protected DataTransferChannel cameraProjectionUpdateChannel; + protected DataTransferChannel entityPositionUpdateChannel; + protected DataTransferChannel entityRotationUpdateChannel; + protected DataTransferChannel entityScaleUpdateChannel; + protected DataTransferChannel spriteUpdateChannel; + + protected DataTransferChannel sceneUpdateEventChannel; + protected DataTransferChannel keyEventChannel; + + protected Map> channelAndResourcesForEntityReceiving = new HashMap<>(); + protected Map channelAndResourcesForCameraReceiving = new HashMap<>(); + + public GameEnginePresenter(Scene scene, Simulator simulator) { + this.scene = scene; + this.simulator = simulator; + + sceneUpdateChannel = (DataTransferChannel) simulator.getModel().getChannel(sceneUpdateChannelName); + cameraPositionUpdateChannel = (DataTransferChannel) simulator.getModel().getChannel(cameraPositionUpdateChannelName); + cameraRotationUpdateChannel = (DataTransferChannel) simulator.getModel().getChannel(cameraRotationUpdateChannelName); + cameraScaleUpdateChannel = (DataTransferChannel) simulator.getModel().getChannel(cameraScaleUpdateChannelName); + cameraProjectionUpdateChannel = (DataTransferChannel) simulator.getModel().getChannel(cameraProjectionUpdateChannelName); + entityPositionUpdateChannel = (DataTransferChannel) simulator.getModel().getChannel(entityPositionUpdateChannelName); + entityRotationUpdateChannel = (DataTransferChannel) simulator.getModel().getChannel(entityRotationUpdateChannelName); + entityScaleUpdateChannel = (DataTransferChannel) simulator.getModel().getChannel(entityScaleUpdateChannelName); + spriteUpdateChannel = (DataTransferChannel) simulator.getModel().getChannel(spriteUpdateChannelName); + + sceneUpdateEventChannel = (DataTransferChannel) simulator.getModel().getInputChannel(sceneUpdateEventChannelName); + keyEventChannel = (DataTransferChannel) simulator.getModel().getInputChannel(keyEventChannelName); + simulator.addNativeReceiver(this, sceneUpdateChannel); + } + + @Override + public void onReceiveFromModel(Event event, SystemState nextSystemState) { + Expression message = event.getMessage(); + if (message instanceof Term && ((Term) message).getChildren().size() >= 2) { + Expression curScExp = ((Term) message).getChild(0); + Expression nextScExp = ((Term) message).getChild(1); + if (curScExp instanceof JsonTerm && nextScExp instanceof JsonTerm) { + JsonTerm curSc = (JsonTerm) curScExp; + JsonTerm nextSc = (JsonTerm) nextScExp; + Resource sceneResource = nextSystemState.getResource(event.getInputResource().getResourceIdentifier()); + Expression cameraExp = nextSc.get("camera"); + if (cameraExp != null && cameraExp instanceof JsonTerm) { + // Connect camera and model. + JsonTerm camera = (JsonTerm) cameraExp; + Resource cameraResource = sceneResource.getChildrenMap().get("camera"); + Camera cameraObj = scene.getCamera(); + Resource cameraTransformResource = cameraResource.getChildrenMap().get("transform"); + Resource cameraProjectionResource = cameraResource.getChildrenMap().get("projection"); + Resource cameraPositionResource = cameraTransformResource.getChildrenMap().get("position"); + Resource cameraRotationResource = cameraTransformResource.getChildrenMap().get("rotation"); + Resource cameraScaleResource = cameraTransformResource.getChildrenMap().get("scale"); + + if (channelAndResourcesForCameraReceiving.get(cameraPositionUpdateChannel) == null) { + CameraPositionReceiver nativePositionReceiver = new CameraPositionReceiver(cameraObj); + simulator.addNativeReceiver(nativePositionReceiver, cameraPositionUpdateChannel, cameraPositionResource); + channelAndResourcesForCameraReceiving.put(cameraPositionUpdateChannel, cameraPositionResource); + } + + if (channelAndResourcesForCameraReceiving.get(cameraRotationUpdateChannel) == null) { + CameraRotationReceiver nativeRotationReceiver = new CameraRotationReceiver(cameraObj); + simulator.addNativeReceiver(nativeRotationReceiver, cameraRotationUpdateChannel, cameraRotationResource); + channelAndResourcesForCameraReceiving.put(cameraRotationUpdateChannel, cameraRotationResource); + } + + if (channelAndResourcesForCameraReceiving.get(cameraScaleUpdateChannel) == null) { + CameraScaleReceiver nativeScaleReceiver = new CameraScaleReceiver(cameraObj); + simulator.addNativeReceiver(nativeScaleReceiver, cameraScaleUpdateChannel, cameraScaleResource); + channelAndResourcesForCameraReceiving.put(cameraScaleUpdateChannel, cameraScaleResource); + } + + if (channelAndResourcesForCameraReceiving.get(cameraProjectionUpdateChannel) == null) { + CameraProjectionReceiver nativeProjectionReceiver = new CameraProjectionReceiver(cameraObj); + simulator.addNativeReceiver(nativeProjectionReceiver, cameraProjectionUpdateChannel, cameraProjectionResource); + channelAndResourcesForCameraReceiving.put(cameraProjectionUpdateChannel, cameraProjectionResource); + } + } + Expression oldEntities = curSc.get("entities"); + Expression newEntities = nextSc.get("entities"); + Set oldEidSet = new HashSet<>(((MapTerm) oldEntities).keySet()); + Set newEidSet = new HashSet<>(((MapTerm) newEntities).keySet()); + oldEidSet.removeAll(((MapTerm) newEntities).keySet()); + newEidSet.removeAll(((MapTerm) oldEntities).keySet()); + if (!oldEidSet.isEmpty() || !newEidSet.isEmpty()) { + // If the set of scene entities is changed. + + // Remove old entities and their native receivers. + for (String oldEid: oldEidSet) { + scene.removeEntity(oldEid); + } + for (DataTransferChannel channel: channelAndResourcesForEntityReceiving.keySet()) { + Map widToResource = channelAndResourcesForEntityReceiving.get(channel); + for (String oldEid: oldEidSet) { + Resource resource = widToResource.remove(oldEid); + if (resource != null) { + simulator.removeNativeReceiver(channel, resource); + } + } + } + + // Add new entities. + Resource entitiesResource = sceneResource.getChildrenMap().get("entities"); + for (String newEid: newEidSet) { + Expression entityExp = ((MapTerm) newEntities).get(newEid); + if (entityExp instanceof JsonTerm) { + JsonTerm entity = (JsonTerm) entityExp; + Resource entityResource = entitiesResource.getChildrenMap().get(newEid); + Expression transformExp = entity.get("\"transform\""); + Expression meshExp = entity.get("\"mesh\""); + if (transformExp instanceof JsonTerm && meshExp instanceof JsonTerm) { + JsonTerm transform = (JsonTerm) transformExp; + JsonTerm mesh = (JsonTerm) meshExp; + Resource transformResource = entityResource.getChildrenMap().get("transform"); + Resource meshResource = entityResource.getChildrenMap().get("mesh"); + Expression positionExp = transform.get("\"position\""); + Expression rotationExp = transform.get("\"rotation\""); + Expression scaleExp = transform.get("\"scale\""); + Resource positionResource = transformResource.getChildrenMap().get("position"); + Resource rotationResource = transformResource.getChildrenMap().get("rotation"); + Resource scaleResource = transformResource.getChildrenMap().get("scale"); + if (positionExp instanceof JsonTerm + && rotationExp instanceof JsonTerm + && scaleExp instanceof JsonTerm) { + JsonTerm position = (JsonTerm) positionExp; + JsonTerm rotation = (JsonTerm) rotationExp; + JsonTerm scale = (JsonTerm) scaleExp; + GameObject gameObj = new GameObject(); + gameObj.transform.setPosition(Float.parseFloat(position.get("x").toString()), + Float.parseFloat(position.get("y").toString()), + Float.parseFloat(position.get("z").toString())); + gameObj.transform.setRotation(Float.parseFloat(rotation.get("x").toString()), + Float.parseFloat(rotation.get("y").toString()), + Float.parseFloat(rotation.get("z").toString())); + gameObj.transform.setScale(Float.parseFloat(scale.get("x").toString()), + Float.parseFloat(scale.get("y").toString()), + Float.parseFloat(scale.get("z").toString())); + Expression type = mesh.get("\"type\""); + if (type.toString().equals("\"sprite\"")) { + String texturePath = mesh.get("\"type\"").toString(); + Mesh meshObj = new Mesh(gameObj, Mesh.MeshType.SPRITE, texturePath); + gameObj.addComponent(meshObj); + + SpriteReceiver nativeSpriteReceiver = new SpriteReceiver(meshObj); + simulator.addNativeReceiver(nativeSpriteReceiver, spriteUpdateChannel, meshResource); + Map resources = channelAndResourcesForEntityReceiving.get(spriteUpdateChannel); + if (resources == null) { + resources = new HashMap<>(); + channelAndResourcesForEntityReceiving.put(spriteUpdateChannel, resources); + } + resources.put(newEid, meshResource); + } + scene.addEntity(newEid, gameObj); + + // Connect game entity and model. + EntityPositionReceiver nativePositionReceiver = new EntityPositionReceiver(gameObj); + simulator.addNativeReceiver(nativePositionReceiver, entityPositionUpdateChannel, positionResource); + Map resources = channelAndResourcesForEntityReceiving.get(entityPositionUpdateChannel); + if (resources == null) { + resources = new HashMap<>(); + channelAndResourcesForEntityReceiving.put(entityPositionUpdateChannel, resources); + } + resources.put(newEid, positionResource); + + EntityRotationReceiver nativeRotationReceiver = new EntityRotationReceiver(gameObj); + simulator.addNativeReceiver(nativeRotationReceiver, entityRotationUpdateChannel, rotationResource); + resources = channelAndResourcesForEntityReceiving.get(entityRotationUpdateChannel); + if (resources == null) { + resources = new HashMap<>(); + channelAndResourcesForEntityReceiving.put(entityRotationUpdateChannel, resources); + } + resources.put(newEid, rotationResource); + + EntityScaleReceiver nativeScaleReceiver = new EntityScaleReceiver(gameObj); + simulator.addNativeReceiver(nativeScaleReceiver, entityScaleUpdateChannel, scaleResource); + resources = channelAndResourcesForEntityReceiving.get(entityScaleUpdateChannel); + if (resources == null) { + resources = new HashMap<>(); + channelAndResourcesForEntityReceiving.put(entityScaleUpdateChannel, resources); + } + resources.put(newEid, scaleResource); + } + } + } + } + } + } + } + } + + public static class Entity { + public Transform transform = new Transform(); + } + + public static class Camera extends Entity { + } + + public static class GameObject extends Entity { + private final List gameComponents = new ArrayList<>(); + + public void addComponent(GameComponent component) { + this.gameComponents.add(component); + } + } + + public static abstract class GameComponent { + } + + public static class Mesh extends GameComponent { + public enum MeshType { + SPRITE, CUBE + } + private MeshType type; + private GameObject parent; + + public Mesh(GameObject parent, MeshType type, String texturePath) { + this.parent = parent; + } + + public void setTexturePath(String texturePath) { + } + } + + public static class Transform { + public void setPosition(float x, float y, float z) { + } + public void setRotation(float x, float y, float z) { + } + public void setScale(float x, float y, float z) { + } + } + + public static class Scene { + private Camera camera; + private HashMap entities = new HashMap<>(); + + public Camera getCamera() { + return camera; + } + + public void setCamera(Camera camera) { + this.camera = camera; + } + + public Entity getEntity(String eid) { + return entities.get(eid); + } + + public void addEntity(String eid, Entity entity) { + entities.put(eid, entity); + } + + public void removeEntity(String eid) { + entities.remove(eid); + } + } +} diff --git a/AlgebraicDataflowArchitectureModel/src/simulator/interfaces/gameEngine/SpriteReceiver.java b/AlgebraicDataflowArchitectureModel/src/simulator/interfaces/gameEngine/SpriteReceiver.java new file mode 100644 index 0000000..b2c2241 --- /dev/null +++ b/AlgebraicDataflowArchitectureModel/src/simulator/interfaces/gameEngine/SpriteReceiver.java @@ -0,0 +1,27 @@ +package simulator.interfaces.gameEngine; + +import models.algebra.Expression; +import models.algebra.Term; +import simulator.Event; +import simulator.SystemState; +import simulator.interfaces.INativeReceiver; +import simulator.interfaces.gameEngine.GameEnginePresenter.Entity; +import simulator.interfaces.gameEngine.GameEnginePresenter.Mesh; + +public class SpriteReceiver implements INativeReceiver { + private Mesh mesh; + + public SpriteReceiver(Mesh mesh) { + this.mesh = mesh; + } + + @Override + public void onReceiveFromModel(Event event, SystemState nextSystemState) { + Expression message = event.getMessage(); + if (message instanceof Term) { + Expression exp = ((Term) message).getChild(0); + mesh.setTexturePath(exp.toString()); + } + } + +}