public D3DEngine(IAppWindow window, IContextState context, EngineNotificator notificator) :
base(window, context, new D3DViewport(), notificator)
{
Statics.Collision = new SDXCollision();
Graphics = new SynchronizedGraphics(window);
}
public override void Hide(IContextState context)
{
var en = context.GetEntityManager().GetEntity(Tag);
en.UpdateComponent(en.GetComponent <RenderableComponent>().Disable());
IsVisible = false;
}
public override void Show(IContextState context)
{
var en = context.GetEntityManager().GetEntity(Tag);
en.UpdateComponent(en.GetComponent <RenderableComponent>().Enable());
IsVisible = true;
}
public static VisualPolylineObject Create(IContextState context, ElementTag tag,
Vector3[] points, Vector4 color, bool isVisible = true)
{
var manager = context.GetEntityManager();
var indeces = new List <int>();
var pos = new List <Vector3>();
var prev = points[0];
for (var i = 0; i < points.Length; i++)
{
pos.Add(prev);
pos.Add(points[i]);
prev = points[i];
}
for (var i = 0; i < pos.Count; i++)
{
indeces.AddRange(new[] { i, i });
}
var geo = context.GetGeometryPool().AddGeometry(new ImmutableGeometryData(pos, indeces));
manager
.CreateEntity(tag)
.AddComponent(geo)
.AddComponent(TransformComponent.Identity())
.AddComponent(ColorComponent.CreateDiffuse(color))
.AddComponent(isVisible ? RenderableComponent.AsLineList() : RenderableComponent.AsLineList().Disable());
return(new VisualPolylineObject(tag));
}
public void RemoveVisualObject(IContextState context, ElementTag tag)
{
if (tags.Remove(tag))
{
Cleanup(tag, context);
}
}
static void _Create(IContextState context, IEnumerable <IFileGeometry3D> meshes,
FileInfo texture, string name, LoadedVisualObject visual)
{
List <ElementTag> t = new List <ElementTag>();
var details = new LoadedObjectDetails();
var baseTag = ElementTag.New();
var index = 0;
AxisAlignedBox fullBox = AxisAlignedBox.Zero;
foreach (var geo in meshes)
{
var tag = Create(context, baseTag.WithPrefix(geo.Name ?? index.ToString()),
new GeometryStructures <IFileGeometry3D>(geo), texture, out var box);
t.Add(tag);
fullBox = fullBox.Merge(box.Bounds);
details.VertexCount += geo.Positions.Count;
details.TriangleCount += (geo.Indices.Count / 3);
index++;
}
visual.tags.AddRange(t);
visual.Details = details;
var size = fullBox.Size();
visual.worldX = VisualPolylineObject.Create(context, baseTag.WithPrefix("WorldX"),
new[] { Vector3.Zero + Vector3.UnitX * size.X * -2f, Vector3.Zero + Vector3.UnitX * size.X * 2f }, V4Colors.Red, false);
visual.worldX.IsVisible = false;
visual.worldY = VisualPolylineObject.Create(context, baseTag.WithPrefix("WorldY"),
new[] { Vector3.Zero + Vector3.UnitY * size.Y * -2f, Vector3.Zero + Vector3.UnitY * size.Y * 2f }, V4Colors.Green, false);
visual.worldY.IsVisible = false;
visual.worldZ = VisualPolylineObject.Create(context, baseTag.WithPrefix("WorldZ"),
new[] { Vector3.Zero + Vector3.UnitZ * size.Z * -2f, Vector3.Zero + Vector3.UnitZ * size.Z * 2f }, V4Colors.Blue, false);
visual.worldZ.IsVisible = false;
}
public static GraphicEntity BuildTextured(IContextState context,
IReadOnlyCollection <Vector3> pos, IReadOnlyCollection <int> indexes, IReadOnlyCollection <Vector2> texCoor, FileInfo texture, CullMode cullMode)
{
if (texCoor == null)
{
throw new Exception("Geo must have TextCoor.");
}
var manager = context.GetEntityManager();
var en = manager.CreateEntity(new ElementTag("TexturedGeometry" + Guid.NewGuid()));
var material = MaterialColorComponent.CreateTransparent().ApplyAlpha(1);
var geo = context.GetGeometryPool()
.AddGeometry(new ImmutableGeometryData(
pos,
pos.ToList().CalculateNormals(indexes.ToList()).AsReadOnly(),
indexes,
texCoor));
en.AddComponent(TransformComponent.Identity())
.AddComponent(geo)
.AddComponent(material)
.AddComponent(new D3DTexturedMaterialSamplerComponent(texture))
.AddComponent(RenderableComponent.AsTriangleTexturedList(cullMode));
return(en);
}
public static RenderEngine Create(IRenderableWindow window,
IInputManager inputManager, IContextState context, EngineNotificator notificator)
{
GraphicsDeviceFactory.CreateOutputHandleDevice(window);
return(new RenderEngine(GraphicsDeviceFactory.CreateOutputHandleDevice(window),
window, inputManager, context, notificator));
}
public WireframeComponetViewModel(LoadedVisualObject visual, IContextState context)
{
this.visual = visual;
this.context = context;
IsTransparent = true;
TransparentCheckedCommand = new WpfActionCommand(OnTransparentChecked);
}
public void Release()
{
_entity.Release();
_behaviour = null;
_cancelationOperation = null;
IsActive = false;
}
public override void Cleanup(IContextState context)
{
foreach (var tag in tags)
{
Cleanup(tag, context);
}
tags.Clear();
}
protected EntityOctree(IContextState context, BoundingBox box, int MaximumChildren) : base(box, MaximumChildren)
{
_lock = new object();
this.context = context;
isActualStateDrawed = false;
loker = new object();
synchronizer = new SynchronizationContext <EntityOctree, IGraphicComponent>(this, loker);
}
public DefaultEngine(IAppWindow window, IContextState context, EngineNotificator notificator)
{
Context = context;
this.Window = window;
this.Notificator = notificator;
tokensource = new CancellationTokenSource();
token = tokensource.Token;
}
public IDisposable Execute(IContextState <IEnumerator> state,
IContext context)
{
var routine = state.Execute(context);
var dispose = routine.RunWithSubRoutines();
return(dispose);
}
public void ClearDrew(IContextState context)
{
foreach (var b in drawedDebug)
{
b.Cleanup(context);
}
drawedDebug.Clear();
}
public OctreeManager(IContextState context, AxisAlignedBox box, int MaximumChildren,
RenderLoopSynchronizationContext syncContext) : base(box, MaximumChildren)
{
this.context = context;
IsDrawingBoxesEnable = false;
loker = new object();
sync = new SynchronizationContextAdapter <OctreeManager, SyncData>(this, syncContext);
drawerTask = Task.CompletedTask;
}
/// <summary>
/// Default Constructor.
/// Creates a new instance of <see cref="IStateStorage"/> class.
/// </summary>
/// <param name="applicationState">An instance of <see cref="IApplicationState"/> that is used to store
/// application state data.</param>
/// <param name="localState">An instance of <see cref="IContextState"/> that is used to store local
/// state data.</param>
/// <param name="sessionState">An instance of <see cref="ISessionState"/> that is used to store session
/// state data.</param>
public StateStorageWrapper(
IApplicationState applicationState,
IContextState localState,
ISessionState sessionState)
{
_applicationState = applicationState;
_localState = localState;
_sessionState = sessionState;
}
public ManagerContainer(IManagerChangeNotify notify, IContextState context)
{
EntityOrder = new EntityOrderContainer();
this.SystemManager = new SystemManager(notify, context);
var encom = new EntityComponentManager(notify, EntityOrder);
this.ComponentManager = encom;
this.EntityManager = encom;
}
public void Initialize(IContextDataSource dataSource, IContextState <IEnumerator> behaviour)
{
Stop();
//register data context
//dataSource.Register(_entity);
//set current behaviour
_behaviour = behaviour;
}
public EngineCore(IAppWindow window, IContextState context, IViewport viewport, EngineNotificator notificator)
{
Context = context;
this.viewport = viewport;
this.Window = window;
this.notificator = notificator;
tokensource = new CancellationTokenSource();
token = tokensource.Token;
}
public override void Show(IContextState context)
{
var m = context.GetEntityManager();
foreach (var tag in tags)
{
Show(tag, m);
}
IsVisible = true;
}
public static LoadedVisualObject Create(IContextState context, IEnumerable <IFileGeometry3D> meshes,
FileInfo texture, string name)
{
var visual = new LoadedVisualObject(name);
visual.CullMode = SharpDX.Direct3D11.CullMode.Front;
_Create(context, meshes, texture, name, visual);
return(visual);
}
public override void Hide(IContextState context)
{
var m = context.GetEntityManager();
foreach (var tag in tags)
{
Hide(tag, m);
}
IsVisible = false;
}
public void HideBoundingBox(IContextState context)
{
if (boxComponent == null)
{
throw new InvalidOperationException();
}
Visual.HideBoundingBox(context);
ActiveComponents.Remove(boxComponent);
boxComponent = null;
}
public void ActivateStaticComponents(IContextState context)
{
if (cullComponent != null)
{
throw new InvalidOperationException();
}
cullComponent = new CullModesComponentViewModel(Visual, context);
ActiveComponents.Add(cullComponent);
}
protected override void SceneInitialization(IContextState context, RenderEngine engine, ElementTag camera)
{
var smanager = Context.GetSystemManager();
smanager.CreateSystem <DefaultInputSystem>();
smanager.CreateSystem <ZoomToAllObjectsSystem>();
smanager.CreateSystem <MovingSystem>();
smanager.CreateSystem <CollidingSystem>();
smanager.CreateSystem <DefaultOrthographicCameraSystem>();
smanager.CreateSystem <LightsSystem>();
// smanager.CreateSystem<MovementSystem>();
// smanager.CreateSystem<EmptyAnimationSystem>();
// smanager.CreateSystem<MeshAnimationSystem>();
// smanager.CreateSystem<StickOnHeightMapSystem>();
// smanager.CreateSystem<ObjectMovementSystem>();
// smanager.CreateSystem<Systems.TerrainGeneratorSystem>();
// smanager.CreateSystem<Physics.Engine.PhysicalSystem>();
smanager
.CreateSystem <RenderSystem>()
.Init(engine.Graphics)
// .CreateNested<SkyGradientColoringRenderTechnique>()
// .CreateNested<SkyPlaneWithParallaxRenderTechnique>()
// .CreateNested<TerrainRenderTechnique>()//
//.CreateNested<Toolkit.D3D.CameraViews.CameraViewsRenderTechnique<CustomRenderProperties>>()
//.CreateNested<OITTriangleColoredVertexRenderTechnique<ToolkitRenderProperties>>()
.CreateNested <TriangleColoredVertexRenderTechnique <ToolkitRenderProperties> >()
.CreateNested <TriangleTexturedVertexRenderTechnique <ToolkitRenderProperties> >()
.CreateNested <LineVertexRenderTechnique <ToolkitRenderProperties> >()
//.CreateNested<CudaTestTechniques<ToolkitRenderProperties>>()
.CreateNested <SpherePointRenderTechnique <ToolkitRenderProperties> >()
//.CreateNested<AminRenderTechniqueSystem>()
;
//smanager
// .CreateSystem<AminRenderSystem>()
// .Init(device);Context
var manager = Context.GetEntityManager();
cameraObject = CameraObject.UpdateOrthographic <RenderSystem>(camera, Context, Surface);
LightObject.CreateAmbientLight(manager, 0.2f); //0.05f
LightObject.CreateFollowCameraDirectLight(manager, System.Numerics.Vector3.UnitZ, 0.8f); //0.95f
CoordinateSystem = CoordinateSystemLinesGameObject.Create(context, false);
Loaded?.Invoke();
//VisualSphereObject.SphereGeo(Context, ElementTag.New($"Point"), new VisualSphereObject.Data {
// Center = new Vector3(10, 20, 10),
// Color = V4Colors.Yellow,
// Radius = 10
//});
}
public static GraphicEntity BuildColored(IContextState context,
IReadOnlyCollection <Vector3> pos, IReadOnlyCollection <int> indexes,
IReadOnlyCollection <Vector3> norm, Vector4 v4color, CullMode cullMode)
{
var mormals = norm ?? pos.ToList().CalculateNormals(indexes.ToList()).AsReadOnly();
return(BuildColored(context, ElementTag.New("TriangleColored"), new ImmutableGeometryData(
pos,
mormals,
indexes), v4color, cullMode));
}
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);
}
RenderEngine(GraphicsDevice device, IRenderableSurface surface,
IInputManager inputManager, IContextState context, EngineNotificator notificator)
: base(surface, inputManager, context, notificator)
{
Graphics = new SynchronizedGraphics(surface, device);
var includes = new System.Collections.Generic.Dictionary <string, IIncludeResourse>();
includes.Add("Common", new IncludeResourse("Common", "D3DLab.Toolkit._CommonShaders.Common.hlsl"));
Graphics.Device.Compilator.AddInclude(new D3DLab.SDX.Engine.Shader.D3DIncludeAdapter(includes));
}
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);
}
