public override string Execute(IList <string> parameters)
{
int elementId;
int loadCaseNumber;
double loadValue;
double loadPosition;
try
{
elementId = int.Parse(parameters[0]);
loadCaseNumber = int.Parse(parameters[1]);
loadValue = double.Parse(parameters[2]);
loadPosition = double.Parse(parameters[3]);
}
catch
{
throw new ArgumentException("Failed to parse AssignConcentratedShearLoadXYPlaneToFrame command parameters.");
}
IFrameElement frameElement = base.dbctx.FrameElements[elementId];
ILoadCase loadCase = base.dbctx.LoadCases[loadCaseNumber];
double gCoefficient = (frameElement.MaterialProp.EModule * frameElement.SectionProp.MomentOfInertiaZ * frameElement.SectionProp.Mju)
/ (frameElement.SectionProp.Area * frameElement.MaterialProp.GModule);
IFrameLoad frameLoad = this.factory.CreateConcentratedShearLoadXYPlane(loadCase, frameElement.ElementLength, gCoefficient,
loadValue, loadPosition);
FrameService.AddLoad(frameElement, frameLoad);
return($"Concentrated shear frame load in XY plane with intensity {loadValue} and Load Case Numeber {loadCaseNumber} has been assigned to element with ID {frameElement.Number}.");
}
public ToneMapSystem(GraphicsDevice device, PostProcessTriangle postProcessTriangle, ToneMapAndFXAAEffect effect, FrameService frameService)
{
this.Device = device;
this.FrameService = frameService;
this.Effect = effect;
this.PostProcessTriangle = postProcessTriangle;
}
public ParticleSimulationSystem(GraphicsDevice device, FrameService frameService, PostProcessTriangle postProcessTriangle, ParticleSimulationEffect simulationEffect)
{
this.Device = device;
this.FrameService = frameService;
this.PostProcessTriangle = postProcessTriangle;
this.SimulationEffect = simulationEffect;
}
public override string Execute(IList <string> parameters)
{
int elementId;
int loadCaseNumber;
double loadValue;
double loadPosition;
try
{
elementId = int.Parse(parameters[0]);
loadCaseNumber = int.Parse(parameters[1]);
loadValue = double.Parse(parameters[2]);
loadPosition = double.Parse(parameters[3]);
}
catch
{
throw new ArgumentException("Failed to parse AssignConcentratedNormalLoadToFrame command parameters.");
}
IFrameElement frameElement = base.dbctx.FrameElements[elementId];
ILoadCase loadCase = base.dbctx.LoadCases[loadCaseNumber];
IFrameLoad frameLoad = this.factory.CreateConcentratedNormalLoad(loadCase, frameElement.ElementLength, 0.0,
loadValue, loadPosition);
FrameService.AddLoad(frameElement, frameLoad);
return($"Concentrated normal frame load with intensity {loadValue} and Load Case Numeber {loadCaseNumber} has been assigned to element with ID {frameElement.Number}.");
}
public override string Execute(IList <string> parameters)
{
int elementId;
int loadCaseNumber;
double loadAtStart;
double loadAtEnd;
double loadStartsAt;
double loadEndsAt;
try
{
elementId = int.Parse(parameters[0]);
loadCaseNumber = int.Parse(parameters[1]);
loadAtStart = double.Parse(parameters[2]);
loadAtEnd = double.Parse(parameters[3]);
loadStartsAt = double.Parse(parameters[4]);
loadEndsAt = double.Parse(parameters[5]);
}
catch
{
throw new ArgumentException("Failed to parse AssignDistributedMomentXZPlaneToFrame command parameters.");
}
IFrameElement frameElement = base.dbctx.FrameElements[elementId];
ILoadCase loadCase = base.dbctx.LoadCases[loadCaseNumber];
double gCoefficient = (frameElement.MaterialProp.EModule * frameElement.SectionProp.MomentOfInertiaY * frameElement.SectionProp.Mju)
/ (frameElement.SectionProp.Area * frameElement.MaterialProp.GModule);
IFrameLoad frameLoad = this.factory.CreateDistributedMomentXZPlane(loadCase, frameElement.ElementLength, gCoefficient,
loadAtStart, loadAtEnd, loadStartsAt, loadEndsAt);
FrameService.AddLoad(frameElement, frameLoad);
return($"Distributed moment frame load in XZ plane with intensities {loadAtStart} and {loadAtEnd} and Load Case Numeber {loadCaseNumber} has been assigned to element with ID {frameElement.Number}.");
}
public ParticipatingMediaSystem(GraphicsDevice device, ContentManager content, ShadowMapEffect shadowMapEffect, ParticipatingMediaEffect mediaEffect, ParticipatingMediaPostProcessEffect postProcessEffect, PostProcessTriangle postProcessTriangle, FrameService frameService)
{
this.Device = device;
this.Albedo = new Texture2D(device, 1, 1);
this.Albedo.SetData(new Color[] { Color.White });
this.MediaEffect = mediaEffect;
this.ShadowMapEffect = shadowMapEffect;
this.PostProcessEffect = postProcessEffect;
this.PostProcessTriangle = postProcessTriangle;
this.FrameService = frameService;
this.Noise = content.Load <Texture2D>("Textures/BlueNoise");
this.DitherPattern = content.Load <Texture2D>("Textures/DitherPattern");
this.FrontRasterizerState = new RasterizerState
{
CullMode = CullMode.CullCounterClockwiseFace,
DepthClipEnable = false
};
this.BackRasterizerState = new RasterizerState
{
CullMode = CullMode.CullClockwiseFace,
DepthClipEnable = false
};
}
public override string Execute(IList <string> parameters)
{
int elementId;
int loadCaseNumber;
double loadAtStart;
double loadAtEnd;
double loadStartsAt;
double loadEndsAt;
try
{
elementId = int.Parse(parameters[0]);
loadCaseNumber = int.Parse(parameters[1]);
loadAtStart = double.Parse(parameters[2]);
loadAtEnd = double.Parse(parameters[3]);
loadStartsAt = double.Parse(parameters[4]);
loadEndsAt = double.Parse(parameters[5]);
}
catch
{
throw new ArgumentException("Failed to parse AssignDistributedTorsionToFrame command parameters.");
}
IFrameElement frameElement = base.dbctx.FrameElements[elementId];
ILoadCase loadCase = base.dbctx.LoadCases[loadCaseNumber];
IFrameLoad frameLoad = this.factory.CreateDistributedTorsion(loadCase, frameElement.ElementLength, 0.0,
loadAtStart, loadAtEnd, loadStartsAt, loadEndsAt);
FrameService.AddLoad(frameElement, frameLoad);
return($"Distributed torsion with intensities {loadAtStart} and {loadAtEnd} and Load Case Numeber {loadCaseNumber} has been assigned to element with ID {frameElement.Number}.");
}
public SkyboxSystem(GraphicsDevice device, SkyboxEffect effect, FrameService frameService)
{
this.Device = device;
this.FrameService = frameService;
this.Effect = effect;
}
public SunlightSystem(GraphicsDevice device, PostProcessTriangle postProcessTriangle, SunlightEffect effect, FrameService frameService)
{
this.Device = device;
this.FrameService = frameService;
this.PostProcessTriangle = postProcessTriangle;
this.Effect = effect;
}
private void CreateSkyboxes(GraphicsDevice device, ContentStack content, FrameService frameService, CubeMapGenerator cubeMapGenerator, IrradianceMapGenerator irradianceMapGenerator, EnvironmentMapGenerator environmentMapGenerator)
{
var skyboxNames = new string[]
{
"Skyboxes/Circus/Circus_Backstage_3k",
"Skyboxes/Industrial/fin4_Bg",
"Skyboxes/Milkyway/Milkyway_small",
"Skyboxes/Grid/testgrid",
"Skyboxes/Loft/Newport_Loft_Ref"
};
foreach (var name in skyboxNames)
{
content.Push("generator");
var equiRect = content.Load <Texture2D>(name);
var albedo = cubeMapGenerator.Generate(equiRect);
var irradiance = irradianceMapGenerator.Generate(equiRect);
var environment = environmentMapGenerator.Generate(equiRect);
content.Pop();
content.Link(albedo);
content.Link(irradiance);
content.Link(environment);
this.Textures.Add(new SkyboxTextures(name, albedo, irradiance, environment));
}
frameService.Skybox = SkyboxGenerator.Generate(device, this.Textures[0].Albedo,
this.Textures[0].Irradiance,
this.Textures[0].Environment);
}
public GameLoop(
GraphicsDeviceManager graphics,
GraphicsDevice device,
OpaqueEffect effect,
PostProcessTriangle postProcessTriangle,
FrameService frameService,
MainWindow mainWindow,
SceneManager sceneManager,
GameWindow window,
RenderPipelineBuilder renderPipelineBuilder,
GameTimer gameTimer,
KeyboardController keyboard,
MouseController mouse,
CameraController cameraController)
{
this.Graphics = graphics;
this.Device = device;
this.Effect = effect;
this.PostProcessTriangle = postProcessTriangle;
this.FrameService = frameService;
this.MainWindow = mainWindow;
this.SceneManager = sceneManager;
this.Window = window;
this.GameTimer = gameTimer;
this.Keyboard = keyboard;
this.Mouse = mouse;
this.CameraController = cameraController;
this.RenderPipeline = renderPipelineBuilder.Build();
this.FrameCounter = new FrameCounter();
}
public override string Execute(IList <string> parameters)
{
int firstNodeId;
int secondNodeId;
try
{
firstNodeId = int.Parse(parameters[0]);
secondNodeId = int.Parse(parameters[1]);
}
catch
{
throw new ArgumentException("Failed to parse CreateFrameElement command parameters.");
}
Node firstNode = base.dbctx.Nodes[firstNodeId];
Node secondNode = base.dbctx.Nodes[secondNodeId];
IFrameElement frameElement = this.factory.CreateFrameElement(firstNode, secondNode);
frameElement.TransformationMatrix = FrameService.TransformationMatrix(frameElement);
this.dbctx.FrameElements.Add(frameElement);
frameElement.Number = base.dbctx.FrameElements.Count - 1;
return($"Frame Element with ID {frameElement.Number} was created.");
}
public SkyboxSceneService(GraphicsDevice device, ContentStack content, CubeMapGenerator cubeMapGenerator, IrradianceMapGenerator irradianceMapGenerator, EnvironmentMapGenerator environmentMapGenerator, FrameService frameService)
{
this.Textures = new List <SkyboxTextures>();
this.FrameService = frameService;
content.Push("skybox");
this.CreateSkyboxes(device, content, frameService, cubeMapGenerator, irradianceMapGenerator, environmentMapGenerator);
}
public void Setup()
{
_frameService = new FrameService();
var videoPath = TestContext.CurrentContext.TestDirectory + "\\test.avi";
_frameService.TryOpenFile(videoPath, out string error);
}
internal AquaCleanBaseClient(IBluetoothLeConnector bluetoothLeConnector)
{
this.bluetoothLeConnector = bluetoothLeConnector;
frameService = new FrameService();
frameFactory = new FrameFactory();
messageService = new MessageService();
// Build lookup
var type = typeof(IApiCall);
var types = AppDomain.CurrentDomain.GetAssemblies()
.SelectMany(s => s.GetTypes())
.Where(p => type.IsAssignableFrom(p));
contextLookup = types
.Select(t => new
{
Type = t,
Api = (ApiCallAttribute)t.GetCustomAttributes(typeof(ApiCallAttribute), false).FirstOrDefault()
}
)
.Where(t => t.Api != null)
.ToDictionary(t => t.Api, t => t.Type);
// Process received data from Bluetooth
bluetoothLeConnector.DataReceived += (sender, data) =>
{
frameService.ProcessData(data);
};
// Connection status has changed
bluetoothLeConnector.ConnectionStatusChanged += (sender, args) => {
this.ConnectionStatusChanged?.Invoke(this, new ConnectionStatusChangedEventArgs(args));
};
// Send Frame over Bluetooth
frameService.SendData += async(sender, data) =>
{
await bluetoothLeConnector.SendMessageAsync(data);
};
// Process complete transaction
frameService.TransactionComplete += (sender, data) =>
{
this.messageContext = messageService.ParseMessage(data);
var context = new ApiCallAttribute()
{
Context = messageContext.Context,
Procedure = messageContext.Procedure
};
if (contextLookup.ContainsKey(context))
{
var cc = contextLookup[context];
Debug.WriteLine("Result for " + cc.Name);
}
eventWaitHandle.Set();
};
}
public string Execute(IList <string> parameters)
{
foreach (var element in this.dbctx.FrameElements)
{
element.GlobalMatrix = FrameService.GenerateGlobalMatrix(element);
}
return($"Global stiffness matrices generatex.");
}
public ImageBasedLightSystem(GraphicsDevice device, BrdfLutGenerator brdfLutGenerator, PostProcessTriangle postProcessTriangle, ImageBasedLightEffect effect, FrameService frameService)
{
this.Device = device;
this.PostProcessTriangle = postProcessTriangle;
this.FrameService = frameService;
this.Effect = effect;
this.BrdfLutTexture = brdfLutGenerator.Generate();
}
public SceneManager(FrameService frameService, EntityAdministrator entities, ComponentAdministrator components, ContentStack content, IEnumerable <IScene> scenes)
{
this.Scenes = scenes.ToList();
this.FrameService = frameService;
this.Entities = entities;
this.Components = components;
this.Content = content;
this.nextScene = this.Scenes[0];
}
public override string Execute(IList <string> parameters)
{
int elementId;
int loadCaseNumber;
double loadAtStart;
double loadAtEnd;
double loadStartsAt;
double loadEndsAt;
try
{
elementId = int.Parse(parameters[0]);
loadCaseNumber = int.Parse(parameters[1]);
loadAtStart = double.Parse(parameters[2]);
loadAtEnd = double.Parse(parameters[3]);
loadStartsAt = double.Parse(parameters[4]);
loadEndsAt = double.Parse(parameters[5]);
}
catch
{
throw new ArgumentException("Failed to parse AssignDistributedMomentAroundGlobalYDirection command parameters.");
}
IFrameElement frameElement = base.dbctx.FrameElements[elementId];
ILoadCase loadCase = base.dbctx.LoadCases[loadCaseNumber];
double gCoefficientY = (frameElement.MaterialProp.EModule * frameElement.SectionProp.MomentOfInertiaY * frameElement.SectionProp.Mju)
/ (frameElement.SectionProp.Area * frameElement.MaterialProp.GModule);
double gCoefficientZ = (frameElement.MaterialProp.EModule * frameElement.SectionProp.MomentOfInertiaZ * frameElement.SectionProp.Mju)
/ (frameElement.SectionProp.Area * frameElement.MaterialProp.GModule);
Vector <double> startPointEntryLoad = Vector <double> .Build.SparseOfArray(new double[] { 0, loadAtStart, 0 });
Vector <double> endPointEntryLoad = Vector <double> .Build.SparseOfArray(new double[] { 0, loadAtEnd, 0 });
Vector <double> startPointLoadVector = FrameService.InclinedLoadVector(frameElement, startPointEntryLoad);
Vector <double> endPointLoadVector = FrameService.InclinedLoadVector(frameElement, endPointEntryLoad);
IFrameLoad frameMomentAroundLocalX = this.factory.CreateDistributedTorsion(loadCase, frameElement.ElementLength, 0.0,
startPointLoadVector[0], endPointLoadVector[0], loadStartsAt, loadEndsAt);
IFrameLoad frameMomentAroundLocalY = this.factory.CreateDistributedMomentXZPlane(loadCase, frameElement.ElementLength, gCoefficientY,
startPointLoadVector[1], endPointLoadVector[1], loadStartsAt, loadEndsAt);
IFrameLoad frameMomentAroundLocalZ = this.factory.CreateDistributedMomentXYPlane(loadCase, frameElement.ElementLength, gCoefficientZ,
startPointLoadVector[2], endPointLoadVector[2], loadStartsAt, loadEndsAt);
FrameService.AddLoad(frameElement, frameMomentAroundLocalX);
FrameService.AddLoad(frameElement, frameMomentAroundLocalY);
FrameService.AddLoad(frameElement, frameMomentAroundLocalZ);
return($"Distributed frame moment around global Y direction with intensities {loadAtStart} and {loadAtEnd} and Load Case Numeber {loadCaseNumber} has been assigned to element with ID {frameElement.Number}.");
}
public override string Execute(IList <string> parameters)
{
List <IFrameElement> frameElements = base.dbctx.FrameElements;
var result = new StringBuilder();
foreach (var frameElement in frameElements)
{
result.AppendLine(FrameService.AsString(frameElement));
}
return(result.ToString());
}
public CascadedShadowMapSystem(GraphicsDevice device, FrameService frameService)
{
this.Device = device;
this.FrameService = frameService;
this.Frustum = new Frustum();
this.RasterizerState = new RasterizerState
{
CullMode = CullMode.None,
DepthClipEnable = false
};
}
public SpotLightSystem(GraphicsDevice device, FrustumLightVolume volume, SpotLightEffect effect, FrameService frameService)
{
this.Device = device;
this.FrameService = frameService;
this.Volume = volume;
this.Effect = effect;
this.SpotLightRasterizer = new RasterizerState()
{
CullMode = CullMode.CullCounterClockwiseFace,
DepthClipEnable = false
};
}
public override string Execute(IList <string> parameters)
{
int elementId;
int loadCaseNumber;
double loadValue;
double loadPosition;
try
{
elementId = int.Parse(parameters[0]);
loadCaseNumber = int.Parse(parameters[1]);
loadValue = double.Parse(parameters[2]);
loadPosition = double.Parse(parameters[3]);
}
catch
{
throw new ArgumentException("Failed to parse AssignConcentratedLoadGlobalYDirection command parameters.");
}
IFrameElement frameElement = base.dbctx.FrameElements[elementId];
ILoadCase loadCase = base.dbctx.LoadCases[loadCaseNumber];
double gCoefficientY = (frameElement.MaterialProp.EModule * frameElement.SectionProp.MomentOfInertiaZ * frameElement.SectionProp.Mju)
/ (frameElement.SectionProp.Area * frameElement.MaterialProp.GModule);
double gCoefficientZ = (frameElement.MaterialProp.EModule * frameElement.SectionProp.MomentOfInertiaY * frameElement.SectionProp.Mju)
/ (frameElement.SectionProp.Area * frameElement.MaterialProp.GModule);
Vector <double> EntryLoad = Vector <double> .Build.SparseOfArray(new double[] { 0, loadValue, 0 });
Vector <double> LoadVector = FrameService.InclinedLoadVector(frameElement, EntryLoad);
IFrameLoad frameLoadLocalX = this.factory.CreateConcentratedNormalLoad(loadCase, frameElement.ElementLength, 0.0,
LoadVector[0], loadPosition);
IFrameLoad frameLoadLocalY = this.factory.CreateConcentratedShearLoadXYPlane(loadCase, frameElement.ElementLength, gCoefficientY,
LoadVector[1], loadPosition);
IFrameLoad frameLoadLocalZ = this.factory.CreateConcentratedShearLoadXZPlane(loadCase, frameElement.ElementLength, gCoefficientZ,
LoadVector[2], loadPosition);
FrameService.AddLoad(frameElement, frameLoadLocalX);
FrameService.AddLoad(frameElement, frameLoadLocalY);
FrameService.AddLoad(frameElement, frameLoadLocalZ);
return($"Concentrated frame load in global Y direction with intensity {loadValue} and Load Case Numeber {loadCaseNumber} has been assigned to element with ID {frameElement.Number}.");
}
public override string Execute(IList <string> parameters)
{
int frameId;
try
{
frameId = int.Parse(parameters[0]);
}
catch
{
throw new ArgumentException("Failed to parse ShowFrameElement command parameters.");
}
IFrameElement frameElement = base.dbctx.FrameElements[frameId];
string result = FrameService.AsString(frameElement);
return(result);
}
public PointLightSystem(GraphicsDevice device, SphereLightVolume volume, PointLightEffect effect, FrameService frameService)
{
this.Device = device;
this.FrameService = frameService;
this.Volume = volume;
this.Effect = effect;
this.InsideRasterizer = new RasterizerState()
{
CullMode = CullMode.CullClockwiseFace,
DepthClipEnable = false
};
this.OutsideRasterizer = new RasterizerState()
{
CullMode = CullMode.CullCounterClockwiseFace,
DepthClipEnable = false
};
}
public MainWindow(ILogger logger, ImGuiRenderer gui, SceneManager sceneManager, FrameService frameService, WindowService windowService, IEnumerable <IWindow> windows)
{
this.Gui = gui;
this.SceneManager = sceneManager;
this.FrameService = frameService;
this.WindowService = windowService;
this.Windows = windows.ToList();
this.OpenWindows = new Dictionary <string, bool>();
foreach (var window in this.Windows)
{
this.OpenWindows[window.Name] = false;
}
this.State = new PersistentState <EditorState>(logger, "EditorWindow.json");
this.Deserialize();
this.WindowService.OpenWindowEvent += (o, e) => this.OpenWindows[e.Name] = true;
}
public override string Execute(IList <string> parameters)
{
try
{
for (int i = 0; i < this.dbctx.LoadCases.Count; i++)
{
this.dbctx.ResultNodalDisplacementVectors.Add(i, this.dbctx.GlobalStiffnessMatrixWithSupports.Inverse() * this.dbctx.GlobalLoadVectors[i]);
this.dbctx.ResultNodalReactionVectors.Add(i, this.dbctx.GlobalStiffnessMatrix * this.dbctx.ResultNodalDisplacementVectors[i] - this.dbctx.GlobalLoadVectors[i]);
for (int j = 0; j < this.dbctx.FrameElements.Count; j++)
{
FrameService.InternalForces(this.dbctx.FrameElements[j], this.dbctx.ResultNodalDisplacementVectors[i], i);
}
}
}
catch (Exception)
{
throw new ArgumentException("System could not be solved, check the structure for mechanisms.");
}
return($"System solved for all load cases.");
}
public ClearBuffersSystem(GraphicsDevice graphicsDevice, FrameService frameService)
{
this.Device = graphicsDevice;
this.FrameService = frameService;
}
public BuffersWindow(Tool toolSelector, FrameService frameService)
{
this.ToolSelector = toolSelector;
this.FrameService = frameService;
}
static void Main(string[] args)
{
//initalize service.
IFrameService frameService = new FrameService();
IGameService gameService = new GameService(frameService);
Console.WriteLine("Thank for playing Kata Code Bowling!");
Console.WriteLine("Please hit 'enter' to start a bowling game or 'x' to exit Game");
var startGame = Console.ReadLine();
if (string.IsNullOrEmpty(startGame))
{
Console.WriteLine("We need players. Please enter the number of players.");
var numberOfPlayers = Int32.Parse(Console.ReadLine());
if (numberOfPlayers > 0)
{
for (int i = 0; i < numberOfPlayers; i++)
{
var fname = string.Empty;
var lname = string.Empty;
while (string.IsNullOrEmpty(fname) && string.IsNullOrEmpty(lname))
{
Console.WriteLine(string.Format("Please enter the first name of of player number {0}", i));
fname = Console.ReadLine();
Console.WriteLine(string.Format("Please enter the last name of of player number {0}", i));
lname = Console.ReadLine();
}
gameService.AddPlayer(fname, lname);
}
}
Console.WriteLine("{0} player(s) were added to the game.", gameService.GetPlayers().Count);
foreach (var player in gameService.GetPlayers())
{
Console.WriteLine(string.Format("{0}: has a score of {1}", player.ToString(), player.Score));
}
Console.ReadLine();
var selection = string.Empty;
while (string.IsNullOrEmpty(selection) && !selection.Equals("b") && !selection.Equals("e"))
{
Console.WriteLine("Please enter 'b' to start game or 'e' to end the game");
selection = Console.ReadLine();
}
if (selection.Equals("b"))
{
gameService.StartGame();
}
else
{
gameService.EndGame();
}
while (!gameService.HasGameEnded())
{
var frame = gameService.GetFrameNumber();
while (!gameService.HasFrameEnded(frame))
{
Console.WriteLine("To start Frame {0}, hit enter", frame);
var player = gameService.GetNextPlayer(frame);
Console.WriteLine("Player {0} will now bowl", player.ToString());
gameService.Bowl(player);
}
gameService.PrintScore();
}
Console.WriteLine("Game End!");
}
}
public ForcesSystem(FrameService frameService)
{
this.FrameService = frameService;
}
