protected override void Executing(ISceneSnapshot snapshot)
{
var emanager = ContextState.GetEntityManager();
foreach (var entity in emanager.GetEntities())
{
if (entity.TryGetComponent <MovingComponent>(out var moving))
{
if (moving.MovingMatrix.IsIdentity)
{
entity.RemoveComponent <MovingComponent>();
continue;
}
var transform = entity.GetComponent <TransformComponent>();
//dispose transform buffer to force update it in render technique
if (entity.TryGetComponent <D3DRenderComponent>(out var d3d))
{
d3d.TransformWorldBuffer.Dispose();
}
//
entity.UpdateComponent(transform.Multiply(moving.MovingMatrix));
entity.RemoveComponent <MovingComponent>();
}
}
}
public unsafe void RenderScene(ISceneSnapshot scene)
{
scene.AddReference();
_graphicsDevice.ImmediateContext.GetBackBufferViews(out var backBufferDepthStencilView, out var backBufferRenderTargetView);
var renderContext = _graphicsDevice.ImmediateContext; // : _graphicsDevice.CreateDeferredRenderContext();
renderContext.SetRasterizerConfiguration(RasterizerConfiguration.FillFrontBack);
renderContext.SetDepthConfiguration(DepthConfiguration.Enabled);
renderContext.SetConstantBuffer(0, _sceneBuffer, RenderStage.VertexDomainPixel);
renderContext.SetConstantBuffer(1, _batchBuffer, RenderStage.VertexDomainPixel);
renderContext.SetConstantBuffer(2, _textureDescriptorBuffer, RenderStage.VertexDomainPixel);
if (true)
{
RenderScene_Forward(renderContext, (SceneSnapshot)scene, backBufferDepthStencilView, backBufferRenderTargetView);
}
else
{
}
_graphicsDevice.ImmediateContext.SetRenderTargets(backBufferDepthStencilView, backBufferRenderTargetView);
_graphicsDevice.ImmediateContext.Present();
scene.ReleaseReference();
}
protected override void Executing(ISceneSnapshot snapshot)
{
Synchronize();
var registrator = new RenderTechniqueRegistrator <TToolkitFrameProperties>(nested);
try {
using (var frame = graphics.FrameBegin()) {
RenderFrame(frame, snapshot, registrator);
}
} catch (SharpDX.CompilationException cex) {
System.Diagnostics.Trace.WriteLine($"CompilationException[\n{cex.Message.Trim()}]");
} catch (SharpDX.SharpDXException shex) {
var reason = graphics.Device.D3DDevice.DeviceRemovedReason;
System.Diagnostics.Trace.WriteLine(shex.Message);
throw shex;
} catch (System.Runtime.InteropServices.SEHException seh) {
System.Diagnostics.Trace.WriteLine(seh.Message);
throw seh;
} catch (Exception ex) {
System.Diagnostics.Trace.WriteLine(ex.Message);
throw ex;
} finally {
registrator.Cleanup();
Pass = registrator.Techniques.SelectMany(x => x.GetPass()).ToArray();
}
}
//TODO: remake executer it looks bad :(
protected override void Executing(ISceneSnapshot ss)
{
var snapshot = (SceneSnapshot)ss;
var window = snapshot.Window;
var emanager = ContextState.GetEntityManager();
try {
foreach (var entity in emanager.GetEntities())
{
foreach (var com in entity.GetComponents <OrthographicCameraComponent>())
{
entity
.GetComponents <CameraMovementComponent>()
.DoFirst(movment => {
movment.Execute(CreateHandlerOrthographicHandler(com, snapshot));
});
com.UpdateViewMatrix();
com.UpdateProjectionMatrix(window.Width, window.Height);
snapshot.UpdateCamera(entity.Tag, com.GetState());
}
var isCamera = entity.GetComponents <PerspectiveCameraComponent>();
if (isCamera.Any())
{
var cameraCom = isCamera.Single();
foreach (var component in entity.GetComponents())
{
switch (component)
{
case CameraMovementComponent movment:
movment.Execute(CreateHandlerPerspectiveHandler(cameraCom, snapshot));
//entity.RemoveComponent(movment);
break;
case RayCollidedWithEntityComponent c:
//the case when camera is moved to position on some object mesh
MoveToPosition(cameraCom, c.IntersectionPositionWorld);
entity.RemoveComponent(c);
break;
//case MoveCameraToTargetComponent mvtt:
// MoveToPosition(cameraCom, mvtt.TargetPosition);
// entity.RemoveComponent(mvtt);
// break;
}
}
cameraCom.UpdateViewMatrix();
cameraCom.UpdateProjectionMatrix(window.Width, window.Height);
snapshot.UpdateCamera(entity.Tag, cameraCom.GetState());
}
}
} catch (Exception ex) {
ex.ToString();
throw ex;
}
}
protected override void Executing(ISceneSnapshot ss)
{
var snapshot = (SceneSnapshot)ss;
var emanager = ContextState.GetEntityManager();
foreach (var entity in emanager.GetEntities())
{
var coms = entity.GetComponents <ITerrainComponent>();
if (!coms.Any())
{
continue;
}
var conf = coms.OfType <TerrainConfigurationComponent>().Single();
if (conf.IsModified)
{
entity.RemoveComponents <TerrainGeneratorComponent>();
conf.IsModified = false;
var generator = new TerrainGeneratorComponent(conf.Width, conf.Height, conf);
generator.StartGeneratingAsync();
entity.AddComponent(generator);
continue;
}
var generating = coms.OfType <TerrainGeneratorComponent>().SingleOrDefault();
if (generating.IsNull())
{
continue;
}
if (generating.IsGenerated)
{
entity.RemoveComponent(generating);
var geo = entity.GetComponents <TerrainGeometryCellsComponent>();
if (geo.Any())
{
entity.RemoveComponent(geo.First());
}
var newgeo = new TerrainGeometryCellsComponent();
newgeo.MaxHeight = generating.MaxHeight;
newgeo.MinHeight = generating.MinHeight;
BuildGeometry(generating.HeightMap, conf, newgeo);
entity.AddComponent(newgeo);
conf.Texture = generating.Texture;
var box = BoundingBox.CreateFromVertices(newgeo.Positions.ToArray());
entity.UpdateComponent(TransformComponent.Create(Matrix4x4.CreateTranslation(-box.GetCenter())));
entity.GetComponent <IRenderableComponent>().CanRender = true;
BuildCellsAsync(newgeo, conf);
break;
}
}
}
protected virtual OrthographicCameraComponent HandleChangingRotateCenter(ISceneSnapshot snapshot,
OrthographicCameraComponent camera, ref CameraMovementComponent component)
{
var world = ContextState.GetEntityManager().GetEntity(snapshot.WorldTag);
if (world.TryGetComponents(
out CaptureTargetUnderMouseComponent capture,
out CollidedWithEntityByRayComponent collided))
{
var changed = OrthographicCameraComponent.Clone(camera);
changed.RotatePoint = collided.IntersectionPositionWorld;
var begin = snapshot.Viewport.Vector3ToScreen(changed.Position, camera.GetState(), snapshot.Surface);
var move = new Vector2(capture.ScreenPosition.X - begin.X, capture.ScreenPosition.Y - begin.Y);
var PanK = (changed.Width * changed.Scale) / snapshot.Surface.Size.Width;
var projectionMove = new Vector2(move.X * PanK, move.Y * PanK);
var left = Vector3.Cross(changed.UpDirection, changed.LookDirection).Normalized();
var up = Vector3.Cross(changed.LookDirection, left).Normalized();
var panVector = left * projectionMove.X + up * projectionMove.Y;
changed.Position += -panVector;
world.RemoveComponents <CaptureTargetUnderMouseComponent, CollidedWithEntityByRayComponent>();
camera = changed;
}
return(camera);
}
protected override void Executing(ISceneSnapshot snapshot)
{
var emanager = ContextState.GetEntityManager();
var camera = snapshot.Camera;
try {
foreach (var entity in emanager.GetEntities())
{
if (!entity.Has <LightComponent>())
{
continue;
}
var light = entity.GetComponent <LightComponent>();
var color = entity.GetComponent <ColorComponent>();
snapshot.UpdateLight(light.Index, new LightState {
Intensity = light.Intensity,
Position = light.Position,
Direction = light.Direction,
Color = color.Color,
Type = light.Type
});
}
} catch (Exception ex) {
ex.ToString();
throw ex;
}
}
public void Execute(ISceneSnapshot snapshot)
{
try {
stopwatch.Restart();
Executing(snapshot);
} finally {
stopwatch.Stop();
ExecutionTime = stopwatch.Elapsed;
}
}
public bool Execute(ISceneSnapshot snapshot, IContextState context)
{
var p1 = InputState.ButtonsStates[type].PointV2;
var manager = context.GetEntityManager();
var world = manager.GetEntity(snapshot.WorldTag);
world.UpdateComponent(CaptureTargetUnderMouseComponent.Create(p1));
return(true);
}
protected override void Executing(ISceneSnapshot ss)
{
var snapshot = (SceneSnapshot)ss;
var emanager = ContextState.GetEntityManager();
var time = snapshot.FrameRateTime;
foreach (var entity in emanager.GetEntities())
{
var has = entity.GetComponents <XZPlaneMovementComponent>();
if (has.Any())
{
var com = has.Single();
var first = com.TimeMovement == TimeSpan.Zero;
var delta = time - com.PrevTime;
com.PrevTime = time;
com.TimeMovement += time;
if (first)
{
continue;
}
var spent = com.TimeMovement;
var tr = entity.GetComponent <TransformComponent>();
var geoLocal = entity.GetComponent <IGeometryComponent>();
var orientation = entity.GetComponent <OrientationComponent>();
var directionWorld = Vector3.TransformNormal(orientation.FrontDirectionLocal, tr.MatrixWorld);
var movement = Matrix4x4.Identity;
if (spent > TimeSpan.FromSeconds(2))
{
com.TimeMovement = TimeSpan.Zero;
var centerWorld = Vector3.Transform(geoLocal.Box.GetCenter(), tr.MatrixWorld);
movement = Matrix4x4.CreateRotationY(10f.ToRad(), centerWorld);
directionWorld = Vector3.TransformNormal(orientation.FrontDirectionLocal, movement);
}
//S = V • t
var s = com.SpeedValue * ((float)delta.TotalMilliseconds / 1000.0f);
movement *= Matrix4x4.CreateTranslation(directionWorld * s);
entity.UpdateComponent(TransformComponent.Create(tr.MatrixWorld * movement));
snapshot.Notifier.NotifyChange(tr);
}
}
}
protected override void Executing(ISceneSnapshot snapshot)
{
var input = snapshot.InputSnapshot;
foreach (var cmd in input.Events)
{
if (cmd.Execute(snapshot, ContextState))
{
input.RemoveEvent(cmd);
}
}
}
public bool Execute(ISceneSnapshot snapshot, IContextState context)
{
var entity = context.GetEntityManager().GetEntity(snapshot.CurrentCameraTag);
if (entity.TryGetComponent <CameraMovementComponent>(out var com) &&
com.MovementType != CameraMovementComponent.MovementTypes.ChangeRotationCenter)
{
entity.RemoveComponent <CameraMovementComponent>();
}
return(true);
}
protected override void Executing(ISceneSnapshot snapshot)
{
var emanager = ContextState.GetEntityManager();
var ticks = (float)snapshot.FrameRateTime.TotalMilliseconds;
Synchronize();
var registrator = new RenderTechniqueRegistrator <ToolkitRenderProperties>(nested);
try {
using (var frame = graphics.FrameBegin()) {
foreach (var entity in emanager.GetEntities().OrderBy(x => x.GetOrderIndex <RenderSystem>()))
{
if (entity.Contains(typeof(RenderableComponent), typeof(TransformComponent)))
{
registrator.Register(entity);
}
}
if (!registrator.HasAny)
{
return;
}
prevCameraState = snapshot.Camera;
var lights = snapshot.Lights.Select(x => LightStructBuffer.From(x)).ToArray();
var gamebuff = GameStructBuffer.FromCameraState(prevCameraState, snapshot.Surface.Size);
frame.Graphics.UpdateDynamicBuffer(ref gamebuff, gameDataBuffer);
frame.Graphics.UpdateDynamicBuffer(lights, lightDataBuffer);
foreach (var str in registrator.Techniques)
{
if (str is IGraphicSystemContextDependent dependent)
{
dependent.ContextState = ContextState;
}
str.Render(frame.Graphics, new ToolkitRenderProperties(gameDataBuffer, lightDataBuffer, prevCameraState));
}
}
} catch (SharpDX.CompilationException cex) {
ContextState.Logger.Error(cex);
} catch (SharpDX.SharpDXException shex) {
ContextState.Logger.Error(shex);
throw shex;
} catch (Exception ex) {
ContextState.Logger.Error(ex.Message);
throw ex;
} finally {
registrator.Cleanup();
Pass = registrator.Techniques.SelectMany(x => x.GetPass()).ToArray();
}
}
protected override void Executing(ISceneSnapshot ss)
{
var snapshot = (SceneSnapshot)ss;
var emanager = ContextState.GetEntityManager();
foreach (var entity in emanager.GetEntities())
{
foreach (var com in entity.GetComponents <IAnimationComponent>())
{
com.Animate(entity, snapshot.FrameRateTime);
}
}
}
protected virtual OrthographicCameraComponent HandleZooming(ISceneSnapshot snapshot, OrthographicCameraComponent camera, CameraMovementComponent component)
{
var changed = OrthographicCameraComponent.Clone(camera);
float delta = component.Delta;
var nscale = camera.Scale - (delta * component.SpeedValue);
if (nscale > 0)
{
changed.Scale = nscale;
}
return(changed);
}
protected override void Executing(ISceneSnapshot ss)
{
var snapshot = (SceneSnapshot)ss;
var colliding = new Colliding(snapshot, ContextState);
var emanager = ContextState.GetEntityManager();
foreach (var ev in snapshot.InputSnapshot.Events)
{
switch (ev)
{
case CaptureTargetUnderMouseCameraCommand capture:
if (colliding.TryToColliding(capture.ScreenPosition, out var collidedWith))
{
var entity = emanager.GetEntity(collidedWith.With);
var has = entity.GetComponents <ManipulatableComponent>();
if (has.Any() && !entity.Has <CapturedToManipulateComponent>())
{
entity.AddComponent(new CapturedToManipulateComponent()
{
CapturePointWorld = collidedWith.IntersectionPositionWorld,
});
snapshot.InputSnapshot.RemoveEvent(ev);
}
}
break;
}
}
foreach (var entity in emanager.GetEntities())
{
foreach (var com in entity.GetComponents <ICollidableComponent>())
{
switch (com)
{
case CollidingWithScreenRayComponent byRay:
try {
if (colliding.TryToColliding(byRay.ScreenPosition, out var collidedWith))
{
entity.AddComponent(collidedWith);
}
} finally {
entity.RemoveComponent(byRay);
}
break;
}
}
}
}
protected override void Executing(ISceneSnapshot ss)
{
var snapshot = (SceneSnapshot)ss;
var emanager = ContextState.GetEntityManager();
var toProcess = new List <GraphicEntity>();
GraphicEntity source = null;
foreach (var entity in emanager.GetEntities())
{
if (entity.Has <IStickOnHeightMapComponent>())
{
toProcess.Add(entity);
}
var s = entity.GetComponents <IHeightMapSourceComponent>();
if (s.Any())
{
source = entity;
}
}
if (source.IsNull())
{
return;
}
foreach (var en in toProcess)
{
var com = en.GetComponent <IStickOnHeightMapComponent>();
var tr = en.GetComponent <TransformComponent>();
var rayLocal = new Ray(com.AttachPointLocal, com.AxisUpLocal);
var rayEnWorld = rayLocal.Transformed(tr.MatrixWorld);
//
var sourceTr = source.GetComponent <TransformComponent>();
var map = source.GetComponent <IHeightMapSourceComponent>();
var rayMapLocal = rayEnWorld.Transformed(sourceTr.MatrixWorld.Inverted());
var matrix = map.GetTransfromToMap(ref rayMapLocal);
if (!matrix.IsIdentity)
{
en.UpdateComponent(TransformComponent.Create(tr.MatrixWorld * matrix));
snapshot.Notifier.NotifyChange(tr);
}
}
}
protected override void Executing(ISceneSnapshot snapshot)
{
var emanager = ContextState.GetEntityManager();
var ticks = (float)snapshot.FrameRateTime.TotalMilliseconds;
Synchronize();
var registrator = new RenderTechniqueRegistrator <CustomRenderProperties>(nested);
try {
using (var frame = graphics.Device.FrameBegin()) {
foreach (var entity in emanager.GetEntities().OrderBy(x => x.GetOrderIndex <RenderSystem>()))
{
var renders = entity.GetComponents <IRenderableComponent>();
if (renders.Any() && renders.All(x => x.CanRender))
{
if (!entity.Has <IGeometryComponent>() || !entity.Has <TransformComponent>())
{
throw new Exception("There are not all necessary components in entity to render.");
}
registrator.Register(entity);
}
}
prevCameraState = snapshot.Camera;
var lights = snapshot.Lights.Select(x => LightStructBuffer.From(x)).ToArray();
var gamebuff = GameStructBuffer.FromCameraState(prevCameraState);
frame.Graphics.UpdateSubresource(ref gamebuff, gameDataBuffer, GameStructBuffer.RegisterResourceSlot);
frame.Graphics.UpdateDynamicBuffer(lights, lightDataBuffer, LightStructBuffer.RegisterResourceSlot);
foreach (var str in registrator.Techniques)
{
str.Render(frame.Graphics, new CustomRenderProperties(gameDataBuffer, lightDataBuffer, prevCameraState));
}
}
} catch (SharpDX.CompilationException cex) {
System.Diagnostics.Trace.WriteLine($"CompilationException[\n{cex.Message.Trim()}]");
} catch (SharpDX.SharpDXException shex) {
//var reason = frame.Graphics.D3DDevice.DeviceRemovedReason;
System.Diagnostics.Trace.WriteLine(shex.Message);
throw shex;
} catch (Exception ex) {
System.Diagnostics.Trace.WriteLine(ex.Message);
throw ex;
} finally {
registrator.Cleanup();
Pass = registrator.Techniques.Select(x => x.GetPass()).ToArray();
}
}
protected override void Executing(ISceneSnapshot snapshot)
{
var input = snapshot.InputSnapshot;
foreach (var en in ContextState.GetEntityManager().GetEntities())
{
foreach (var cmd in input.Events)
{
if (cmd.Execute(en))
{
input.RemoveEvent(cmd);
}
}
}
}
public bool Execute(ISceneSnapshot snapshot, IContextState context)
{
var entity = context.GetEntityManager().GetEntity(snapshot.CurrentCameraTag);
var state = entity.GetComponent <OrthographicCameraComponent>().GetState();
var delta = InputState.Delta;
var data = new MovementData {
End = InputState.CurrentPosition
};
entity.UpdateComponent(CameraMovementComponent.CreateZoom(state, data, delta, 0.001f));
return(true);
}
public void ExportSnapshot(ISceneSnapshot s)
{
var snapshot = (SceneSnapshot)s;
snapshot.Textures.Clear();
foreach (var tex in textures)
{
snapshot.Textures.TryAdd(tex);
}
snapshot.Materials.Clear();
foreach (var mat in materials)
{
snapshot.Materials.Add(mat);
}
snapshot.RenderJobBatches.Clear();
foreach (var batch in renderJobBatches)
{
snapshot.RenderJobBatches.Add(batch);
}
snapshot.SpotlightInfos.Clear();
foreach (var spotlightInfo in spotlightInfos)
{
snapshot.SpotlightInfos.Add(spotlightInfo);
}
snapshot.CameraEye = _cameraEye;
snapshot.ProjView = _projView;
snapshot.ProjViewInv = _projViewInv;
foreach (var batch in snapshot.RenderJobBatches)
{
if (batch.MaterialResourcesIndexOverride != -1)
{
foreach (var job in batch.Jobs)
{
if (job.MaterialResourcesIndex >= snapshot.Materials.Count)
{
throw new InvalidOperationException();
}
}
}
}
snapshot.Time = _time;
}
public bool Execute(ISceneSnapshot snapshot, IContextState context)
{
var p1 = InputState.ButtonsStates[GeneralMouseButtons.Left].PointV2;
var manager = context.GetEntityManager();
var camera = manager.GetEntity(snapshot.CurrentCameraTag);
var world = manager.GetEntity(snapshot.WorldTag);
world.UpdateComponent(CaptureTargetUnderMouseComponent.Create(p1));
camera.AddComponent(CameraMovementComponent.ChangeRotationCenter(
camera.GetComponent <OrthographicCameraComponent>().GetState(),
new MovementData {
Begin = p1
}));
return(true);
}
protected override void Executing(ISceneSnapshot snapshot)
{
var emanager = ContextState.GetEntityManager();
var world = emanager.GetEntity(snapshot.WorldTag);
if (!world.Contains <ZoomToAllCompponent>())
{
return;
}
var fullBox = new AxisAlignedBox();
foreach (var entity in emanager.GetEntities())
{
if (entity.TryGetComponents <GeometryBoundsComponent, TransformComponent, RenderableComponent>
(out var box, out var tr, out var renderable) && renderable.IsRenderable)
{
fullBox = fullBox.Merge(box.Bounds.Transform(tr.MatrixWorld));
}
}
var surface = snapshot.Surface.Size;
var aspectRatio = surface.Width / surface.Height;
var size = fullBox.Size();
var camera = ContextState.GetEntityManager().GetEntity(snapshot.CurrentCameraTag);
var com = OrthographicCameraComponent.Clone(camera.GetComponent <OrthographicCameraComponent>());
var move = Math.Max(Math.Abs(com.LookDirection.X * size.X),
Math.Max(Math.Abs(com.LookDirection.Y * size.Y), Math.Abs(com.LookDirection.Z * size.Z)));
com.Position = fullBox.Center + com.LookDirection * -move * 10;
com.RotatePoint = fullBox.Center;
com.Width = Math.Max(size.X, Math.Max(size.Y, size.Z)) * aspectRatio;
com.Scale = 1;
camera.UpdateComponent(com);
world.RemoveComponent <ZoomToAllCompponent>();
}
public bool Execute(ISceneSnapshot snapshot, IContextState context)
{
var entity = context.GetEntityManager().GetEntity(snapshot.CurrentCameraTag);
var state = entity.GetComponent <OrthographicCameraComponent>().GetState();
var p11 = InputState.ButtonsStates[GeneralMouseButtons.Right].PointV2;
var p2 = InputState.CurrentPosition;
var data = new MovementData {
Begin = p11, End = p2
};
//var any = entity.GetComponents<CameraMovementComponent>();
//if (any.Any()) {//get prev state... means manipulate is continuing
// state = any.Single().State;
//}
entity.UpdateComponent(CameraMovementComponent.CreateRotate(state, data, sensitivity));
return(true);
}
public bool Execute(ISceneSnapshot snapshot, IContextState context)
{
var entity = context.GetEntityManager().GetEntity(snapshot.CurrentCameraTag);
if (!entity.TryGetComponent(out OrthographicCameraComponent ccom))
{
return(false);
}
var p11 = InputState.ButtonsStates[GeneralMouseButtons.Right].PointV2;
var p2 = InputState.CurrentPosition;
var data = new MovementData {
Begin = p11, End = p2
};
var state = ccom.GetState();
entity.UpdateComponent(CameraMovementComponent.CreateRotate(state, data, sensitivity));
return(true);
}
protected virtual OrthographicCameraComponent HandlePanning(ISceneSnapshot snapshot, OrthographicCameraComponent camera, CameraMovementComponent component)
{
var state = component.State;
var data = component.MovementData;
var changed = OrthographicCameraComponent.Clone(camera);
var forward = state.LookDirection;
var left = Vector3.Cross(state.UpDirection, forward).Normalized();
var up = Vector3.Cross(forward, left).Normalized();
var move = new Vector2(data.End.X - data.Begin.X, data.End.Y - data.Begin.Y);
var PanK = (changed.Width * changed.Scale) / snapshot.Surface.Size.Width;
var projectionMove = new Vector2(move.X * PanK, move.Y * PanK);
var panVector = left * projectionMove.X + up * projectionMove.Y;
changed.Position = state.Position + panVector;
return(changed);
}
public bool Execute(ISceneSnapshot snapshot, IContextState context)
{
var entity = context.GetEntityManager().GetEntity(snapshot.CurrentCameraTag);
var p1 = InputState.ButtonsStates[GeneralMouseButtons.Right].PointV2;// InputState.PrevPosition;
var p2 = InputState.CurrentPosition;
var data = new MovementData {
Begin = p1, End = p2
};
var state = entity.GetComponent <OrthographicCameraComponent>().GetState();
if (entity.TryGetComponent <CameraMovementComponent>(out var movement))
{
//get prev state... means manipulate is continuing
state = movement.State;
}
entity.UpdateComponent(CameraMovementComponent.CreatePan(state, data));
return(true);
}
protected override void Executing(ISceneSnapshot ss)
{
var snapshot = (SceneSnapshot)ss;
var emanager = ContextState.GetEntityManager();
foreach (var entity in emanager.GetEntities())
{
var meshes = entity.GetComponents <CMOAnimateMeshComponent>();
if (meshes.Any())
{
var mesh = meshes.First();
var anim = entity.GetComponent <MeshAnimationComponent>();
if (mesh.Bones.IsNull())
{
continue;
}
CurrentAnimationTime += snapshot.FrameRateTime.TotalMilliseconds / 1000.0f;
var currentAnimation = mesh.Animations[anim.AnimationName];
anim.Bones = CalculateBonesMatrix(mesh, currentAnimation);
anim.IsModified = true;
var hasGeo = entity.GetComponents <AnimationHittableGeometryComponent>();
if (!hasGeo.Any())
{
entity.AddComponent(ConstructMesh(anim.Bones, mesh));
}
else if (hasGeo.First().Tree.IsBuilt&& !entity.Has <OrientationComponent>())
{
var c = new XZPlaneMovementComponent {
};
entity.AddComponents(CreateStickOnComponent(hasGeo.First()), c);
}
}
}
}
protected override void Executing(ISceneSnapshot snapshot)
{
var emanager = ContextState.GetEntityManager();
var cmanager = ContextState.GetComponentManager();
var world = emanager.GetEntity(snapshot.WorldTag);
if (!world.TryGetComponent <CaptureTargetUnderMouseComponent>(out var capture) || !capture.IsValid)
{
return;
}
if (!cmanager.TryGetComponent <OrthographicCameraComponent>(snapshot.CurrentCameraTag, out var camera) ||
!capture.IsValid)
{
return;
}
var prevCameraState = camera.GetState();
var geoPool = ContextState.GetGeometryPool();
var rayWorld = snapshot.Viewport.UnProject(capture.ScreenPosition, prevCameraState, snapshot.Surface);
var octree = ContextState.GetOctreeManager();
var priority = uint.MaxValue;
var closest = float.MaxValue;
var hit = Vector3.Zero;
var result = octree.GetColliding(ref rayWorld, enTag => {
var entity = emanager.GetEntity(enTag);
if (!entity.GetComponent <RenderableComponent>().IsRenderable)
{
return(false);
}
if (!entity.TryGetComponents <GeometryPoolComponent, TransformComponent, HittableComponent>(
out var geoId, out var transform, out var hittable) && geoId.IsValid && transform.IsValid)
{
return(false);
}
if (priority < hittable.PriorityIndex)
{
return(false); //ignore less priority objcts
}
if (priority > hittable.PriorityIndex)
{
closest = float.MaxValue; //not interesting distance because the priority is highest
priority = hittable.PriorityIndex;
}
var geo = geoPool.GetGeometry <GeometryStructures>(geoId);
if (!geo.IsBuilt)
{
return(false);
}
var toLocal = Matrix4x4.Identity;
var toWorld = Matrix4x4.Identity;
var rayLocal = rayWorld;
if (!transform.MatrixWorld.IsIdentity)
{
toWorld = transform.MatrixWorld;
toLocal = toWorld.Inverted();
rayLocal = rayLocal.Transformed(toLocal);//to local
}
var hits = geo.HitByLocal(rayLocal);
if (!hits.Any())
{
return(false);
}
var min = hits.Min(x => x.Distance);
if (closest < min)
{
return(false);
}
closest = min;
hit = hits.First(x => x.Distance == min).Point.TransformedCoordinate(toWorld);
return(true);
});
if (result.Any()) //important to update not add, to rewrite existed component
{
world.UpdateComponent(CollidedWithEntityByRayComponent.Create(result.Last(), hit));
}
else
{
//can't find any hitable object under mouse
world.RemoveComponent <CaptureTargetUnderMouseComponent>();
}
}
protected override void Executing(ISceneSnapshot snapshot)
{
var window = snapshot.Surface;
var emanager = ContextState.GetEntityManager();
var entity = emanager.GetEntity(snapshot.CurrentCameraTag);
if (!entity.TryGetComponent(out OrthographicCameraComponent camera))
{
Debug.WriteLine("Camera System: no camera in context");
return;
}
if (entity.TryGetComponent(out CameraMovementComponent movement) && movement.IsValid)
{
bool needUpdate;
bool needRemove;
camera = OrthographicCameraComponent.Clone(camera);
switch (movement.MovementType)
{
case CameraMovementComponent.MovementTypes.Rotate:
camera = HandleRotatingWithCursorReturningPosition(snapshot, camera, movement);
needUpdate = true;
needRemove = true;
break;
case CameraMovementComponent.MovementTypes.Zoom:
camera = HandleZooming(snapshot, camera, movement);
needUpdate = true;
needRemove = true;
break;
case CameraMovementComponent.MovementTypes.Pan:
camera = HandlePanning(snapshot, camera, movement);
needUpdate = true;
needRemove = false;
break;
case CameraMovementComponent.MovementTypes.ChangeRotationCenter:
camera = HandleChangingRotateCenter(snapshot, camera, ref movement);
needUpdate = true;
needRemove = true;
break;
default:
throw new Exception($"Type {movement.MovementType} is not supported.");
}
//entity.RemoveComponent(movement);
if (needUpdate)
{
entity.UpdateComponent(camera);
}
if (needRemove)
{
//need to remove zoom com. manually because WinForm pushs many mouse wheel commands for one user scroll
//also remove for all, there is no garantee to get mouse up
entity.RemoveComponent <CameraMovementComponent>();
}
}
camera.UpdateViewMatrix();
camera.UpdateProjectionMatrix(window.Size);
snapshot.UpdateCamera(entity.Tag, camera.GetState());
}
