youmuliu/stgsharp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add from giga-device, new branch added

Browse Source
This commit is contained in:
Nitload Youmu
2025-08-21 16:51:25 +08:00
commit 43bbc06bbb
1296 changed files with 264186 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
StgSharp.Common/MVVM/View/ViewBase.cs
+205
View File
@@ -0,0 +1,205 @@
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
// file="ViewBase.cs"
// Project: StepVisualizer
// AuthorGroup: Nitload Space
// Copyright (c) Nitload Space. All rights reserved.
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the “Software”), to deal in the Software without restriction,
// including without limitation the rights to use, copy, modify, merge,
// publish, distribute, sublicense, and/or sell copies of the Software,
// and to permit persons to whom the Software is furnished to do so,
// subject to the following conditions:
//
// The above copyright notice and
// this permission notice shall be included in all copies
// or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED “AS IS”,
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
// ARISING FROM, OUT OF OR IN CONNECTION WITH
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
using StgSharp.Graphics;
using StgSharp.Mathematics;
using StgSharp.MVVM.ViewModel;
using StgSharp.Timing;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Numerics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Security.Cryptography;
using System.Text;
using System.Threading;
namespace StgSharp.MVVM
{
/// <summary>
/// ViewBase is the base type for all view types, providing context binding and control
/// element binding. A complete view should contain one complete <see cref="ViewDesigner{T}"
/// />, <see cref="ViewRender{TView}" />, and <see cref="ViewResponder" />, which provide
/// layout descriptions of control elements, user responses, and rendering implementations in
/// the view. Data between instances of <see cref="ViewDesigner{T}" />, <see
/// cref="ViewRender{TView}" />, and <see cref="ViewResponder{T}" /> is shared through <see
/// cref="ViewBase" />.
/// </summary>
public abstract unsafe partial class ViewBase
{
private (int x, int y, int z) unitCubeSize;
private GetDataBindingEntryDelegate getDataBindingEntry;
private int usedFrame;
private IViewDesigner<ViewBase> _design;
private IViewRender<ViewBase> _render;
private IViewResponder<ViewBase> _responder;
private TimeSpanProvider time;
private ViewPort context;
private delegate bool GetDataBindingEntryDelegate( string name, out DataBindingEntry entry );
public DataBindingEntry this[ string name ]
{
get
{
if( getDataBindingEntry( name, out DataBindingEntry entry ) ) {
return entry;
}
if( TryGetObjectReference( name, out entry ) ) {
return entry;
}
throw new KeyNotFoundException();
}
}
public (int x, int y, int z) UnitCubeSize
{
get => unitCubeSize;
}
public bool Activated { get; internal set; }
public int Height
{
get => context.Height;
}
public int Width
{
get => context.Width;
}
public IntPtr Monitor => context.Monitor;
public IntPtr ViewHandle => context.ViewPortHandle;
public IViewDesigner<ViewBase> Designer
{
get => _design;
protected set => _design = value;
}
public string ContextName => context.Name;
public string SelfName { get; set; }
public ViewPort Port
{
get => context;
}
internal TimeSpanProvider TimeProvider
{
get => time;
}
protected internal IViewRender<ViewBase> Render
{
get => _render;
set => _render = value;
}
protected IViewResponder<ViewBase> Responder
{
get => _responder;
set => _responder = value;
}
public abstract void CustomizedInitialize( [NotNull]ViewModelBase viewModelBinding );
/// <summary>
/// Get the status of a certain key on the keyboard.
/// </summary>
/// <param _label="key">
///
/// </param>
/// <returns>
/// <see cref="KeyStatus" /> representing if a key is pressed or released.
/// </returns>
[MethodImpl( MethodImplOptions.AggressiveInlining )]
public KeyStatus GetKeyStatus( KeyboardKey key )
{
return InternalIO.glfwGetKey( context.ViewPortHandle, ( int )key );
}
public void InternalInitialize(
string name,
(int, int, int) cubeSize,
[NotNull]ViewModelBase viewModelBinding )
{
SelfName = name;
unitCubeSize = cubeSize;
getDataBindingEntry = viewModelBinding.TryGetObjectReference;
context = viewModelBinding.ViewPortBinding;
time = viewModelBinding.frameTimeProvider;
CustomizedInitialize( viewModelBinding );
}
public abstract bool TryGetObjectReference( string name, out DataBindingEntry entry );
public void Use()
{
if( usedFrame == 0 )
{
if( !ValidateInitialization() ) {
throw new InvalidOperationException(
"This view is not correctly initialized before rendering." );
}
}
Show();
usedFrame++;
}
public bool ValidateInitialization()
{
return ( _design != null ) &&
( _render != null ) &&
( getDataBindingEntry != null ) &&
( _responder != null ) &&
_design.ValidateInitializing() &&
_responder.ValidateInitializing() &&
_render.ValidateInitializing();
}
protected abstract void Show();
}
}
StgSharp.Common/MVVM/View/ViewDesigner.cs
+147
View File
@@ -0,0 +1,147 @@
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
// file="ViewDesigner.cs"
// Project: StepVisualizer
// AuthorGroup: Nitload Space
// Copyright (c) Nitload Space. All rights reserved.
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the “Software”), to deal in the Software without restriction,
// including without limitation the rights to use, copy, modify, merge,
// publish, distribute, sublicense, and/or sell copies of the Software,
// and to permit persons to whom the Software is furnished to do so,
// subject to the following conditions:
//
// The above copyright notice and
// this permission notice shall be included in all copies
// or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED “AS IS”,
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
// ARISING FROM, OUT OF OR IN CONNECTION WITH
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
using StgSharp.Controlling.UsrActivity;
using StgSharp.Controls;
using StgSharp.Geometries;
using StgSharp.Graphics;
using StgSharp.Mathematics;
using System;
using System.Collections.Generic;
using System.Net;
using System.Text;
namespace StgSharp.MVVM
{
public abstract partial class ViewBase
{
public interface IViewDesigner<out TView> where TView: ViewBase
{
abstract void CustomizedInitialize();
abstract void Initialize();
abstract bool ValidateInitializing();
}
/// <summary>
/// ViewDesigner provides descriptions of various controls in the view, binds the
/// controls to specific user actions and behaviors, and describes the layout and
/// interactions of each control.
/// </summary>
public abstract class ViewDesigner<TView> : IViewDesigner<TView> where TView: ViewBase
{
private KeyboardButtonGroup currentButtonGroup;
private List<ControllingItem> _controlList;
protected TView _binding;
public ViewDesigner( TView binding )
{
_binding = binding;
_controlList = new List<ControllingItem>();
}
protected TView Binding
{
get => _binding;
}
public CharacterLineIndexImage CreateCharacterLine(
int length,
char blankFilling,
PlainGeometryMesh tittle,
IEnumerable<(char, PlainGeometryMesh)> charList )
{
CharacterLineIndexImage ret = new CharacterLineIndexImage(
length, blankFilling, tittle, charList );
_controlList.Add( ret );
return ret;
}
public TriggerButton CreateKeyboardButton(
Rectangle bonding,
TextureProvider defaultAnimation,
bool isEnable )
{
TriggerButton ret = new TriggerButton();
ret.BoundingBox = bonding;
ret.Texture = defaultAnimation;
if( isEnable )
{
ret.IsDisabled = false;
ret.Enable();
} else
{
ret.IsDisabled = true;
ret.Disable();
}
currentButtonGroup.AddButton( ret );
return ret;
}
public TButtonGroup CreateKeyboardButtonGroup<TButtonGroup>(
IClickTrigger leftBidning,
IClickTrigger rightBinding,
IClickTrigger upBinding,
IClickTrigger downBinding,
IClickTrigger confirmBinding )
where TButtonGroup: KeyboardButtonGroup, new()
{
TButtonGroup ret = new TButtonGroup();
_controlList.Add( ret );
currentButtonGroup = ret;
_binding.Responder[ leftBidning ] = ret.MoveLeft;
_binding.Responder[ rightBinding ] = ret.MoveRight;
_binding.Responder[ upBinding ] = ret.MoveUp;
_binding.Responder[ downBinding ] = ret.MoveDown;
_binding.Responder[ confirmBinding ] = ret.Confirm;
return ret;
}
public abstract void CustomizedInitialize();
public void Initialize()
{
CustomizedInitialize();
}
public abstract bool ValidateInitializing();
}//---------------------------------- End of Class -----------------------------------------
}
}
StgSharp.Common/MVVM/View/ViewRender.cs
+134
View File
@@ -0,0 +1,134 @@
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
// file="ViewRender.cs"
// Project: StepVisualizer
// AuthorGroup: Nitload Space
// Copyright (c) Nitload Space. All rights reserved.
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the “Software”), to deal in the Software without restriction,
// including without limitation the rights to use, copy, modify, merge,
// publish, distribute, sublicense, and/or sell copies of the Software,
// and to permit persons to whom the Software is furnished to do so,
// subject to the following conditions:
//
// The above copyright notice and
// this permission notice shall be included in all copies
// or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED “AS IS”,
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
// ARISING FROM, OUT OF OR IN CONNECTION WITH
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
using StgSharp.Graphics;
using StgSharp.HighPerformance;
using System;
using System.Collections.Generic;
using System.Linq;
namespace StgSharp.MVVM
{
public abstract partial class ViewBase
{
protected internal interface IViewRender<out TView> where TView: ViewBase
{
RenderStream this[ DataLabel renderName ] { get; }
void CustomizedInitialize();
IEnumerator<ViewPort> GetEnumerator();
void Initialize();
bool ValidateInitializing();
}
protected abstract class ViewRender<TView> : IViewRender<TView> where TView: ViewBase
{
protected ViewRender( TView binding )
{
_binding = binding;
_render = new Dictionary<DataLabel, RenderStream>();
}
public RenderStream this[ DataLabel renderName ]
{
get => _render.TryGetValue( renderName, out RenderStream stream ) ?
stream : ( null! );
protected set
{
if( _render.ContainsKey( renderName ) )
{
_render[ renderName ] = value;
} else
{
_render.Add( renderName, value );
}
}
}
public TView Binding => _binding;
protected ViewPort ContextBinding => _binding.context;
protected ViewDesigner<TView> Design => ( _binding.Designer as ViewDesigner<TView> )!;
protected Dictionary<DataLabel, RenderStream> Render
{
get => _render;
}
protected ViewResponder<TView> Responder => ( _binding.Responder as ViewResponder<TView> )!;
public T CreateRenderStream<T>() where T: RenderStream, new()
{
T ret = new T();
ret.Initialize( _binding.context, Binding.TimeProvider );
return ret;
}
public T CreateRenderStream<T>( ViewPort vp ) where T: RenderStream, new()
{
T ret = new T();
ret.Initialize( vp, Binding.TimeProvider );
return ret;
}
public abstract void CustomizedInitialize();
public IEnumerator<ViewPort> GetEnumerator()
{
foreach( RenderStream item in Render.Values ) {
yield return item.BindedViewPortContext;
}
}
public void Initialize()
{
CustomizedInitialize();
}
public abstract bool ValidateInitializing();
#pragma warning disable CS8618
private Dictionary<DataLabel, RenderStream> _render;
private TView _binding;
#pragma warning restore CS8618
}
}
}
StgSharp.Common/MVVM/View/ViewResponder.cs
+138
View File
@@ -0,0 +1,138 @@
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
// file="ViewResponder.cs"
// Project: StgSharp
// AuthorGroup: Nitload Space
// Copyright (c) Nitload Space. All rights reserved.
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the “Software”), to deal in the Software without restriction,
// including without limitation the rights to use, copy, modify, merge,
// publish, distribute, sublicense, and/or sell copies of the Software,
// and to permit persons to whom the Software is furnished to do so,
// subject to the following conditions:
//
// The above copyright notice and
// this permission notice shall be included in all copies
// or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED “AS IS”,
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
// ARISING FROM, OUT OF OR IN CONNECTION WITH
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
using StgSharp.Controlling.UsrActivity;
using StgSharp.MVVM.ViewModel;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StgSharp.MVVM
{
public partial class ViewBase
{
protected interface IViewResponder<out TVIew> where TVIew: ViewBase
{
Action? this[ IClickTrigger trigger ] { get; set; }
void CustomizedInitialize( Func<IClickTrigger, string, Action> keyRegister );
void Initialize( MethodLookUpDelegate methodGetter );
void ProcessUserInput();
bool ValidateInitializing();
}
protected abstract class ViewResponder<TView> : IViewResponder<TView> where TView: ViewBase
{
private bool _isInitialized;
private Dictionary<IClickTrigger, Action> keyCallbackIndex;
private Dictionary<string, Action> nameToCallbackMap;
private TView _binding;
protected ViewResponder( TView binding )
{
keyCallbackIndex = new Dictionary<IClickTrigger, Action>();
nameToCallbackMap = new Dictionary<string, Action>();
_binding = binding;
}
#pragma warning disable CA1043
public Action? this[ IClickTrigger trigger ]
#pragma warning restore CA1043
{
get => keyCallbackIndex.TryGetValue( trigger, out Action callback ) ?
callback : null;
set
{
if( keyCallbackIndex.TryGetValue( trigger, out Action callback ) )
{
callback += value;
} else
{
keyCallbackIndex.Add(
trigger, value ?? throw new ArgumentNullException( nameof( value ) ) );
}
}
}
protected TView Binding => _binding;
public abstract void CustomizedInitialize(
Func<IClickTrigger, string, Action> keyRegister );
public void Initialize( MethodLookUpDelegate methodGetter )
{
if( _isInitialized ) {
return;
}
CustomizedInitialize(
( trigger, name ) => {
if( !nameToCallbackMap.TryGetValue( name, out Action ret ) )
{
if( methodGetter( name, out Action lookup ) )
{
this[ trigger ] = lookup;
} else
{
throw new InvalidOperationException(
$"Cannot find method named {name} in binded view model" );
}
}
return ret;
} );
}
public void ProcessUserInput()
{
foreach( KeyValuePair<IClickTrigger, Action> pair in keyCallbackIndex )
{
if( InternalIO.glfwGetKey( _binding.ViewHandle,
pair.Key.TargetKeyOrButtonID ) ==
pair.Key.TriggeredStatus ) {
pair.Value();
}
}
}
public abstract bool ValidateInitializing();
}
}
}