neintonine/smrendererv3
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Updated gitignore; Removed MigrationBackup and Legacy

Browse source
This commit is contained in:
Michel Fedde 2021-03-20 10:22:30 +01:00
parent a9c53a1e52
commit 261a3be02d
14 changed files with 1 additions and 1206 deletions
Download patch file Download diff file Expand all files Collapse all files

1
.gitignore vendored
View file

@ -13,6 +13,7 @@
# Dev-Added files
*.nuspec
*/*/nuget.exe
**/apireference/**
# User-specific files (MonoDevelop/Xamarin Studio)
*.userprefs

103
Legacy/Window/Contexts/DrawContext.cs
View file

@ -1,103 +0,0 @@
#region usings
using System.Collections.Generic;
using System.Dynamic;
using OpenTK;
using SM.Base.Drawing;
using SM.Base.Scene;
using SM.OGL.Mesh;
#endregion
namespace SM.Base.Contexts
{
/// <summary>
/// Contains important information for drawing.
/// </summary>
public struct DrawContext
{
/// <summary>
/// This says if it was forced to use the viewport camera.
/// </summary>
public bool ForceViewport;
/// <summary>
/// Contains the currently used render pipeline.
/// </summary>
public RenderPipeline ActivePipeline;
public GenericScene ActiveScene;
public IGenericWindow Window;
public GenericCamera UsedCamera =>
ForceViewport || ActiveScene._camera == null ? Window.ViewportCamera : ActiveScene._camera;
/// <summary>
/// The mesh.
/// </summary>
public GenericMesh Mesh;
/// <summary>
/// The material.
/// </summary>
public Material Material;
/// <summary>
/// The drawing instances.
/// <para>If there is only one, it's index 0</para>
/// </summary>
public IList<Instance> Instances;
/// <summary>
/// The current world scale.
/// </summary>
public Vector2 WorldScale;
/// <summary>
/// The last collection the context was passed though.
/// </summary>
public object LastPassthough;
/// <summary>
/// Returns the appropriate shader.
/// <para>
/// Returns the material shader, if available, otherwise it will take the default shader from the render
/// pipeline.
/// </para>
/// </summary>
public MaterialShader Shader => Material.CustomShader ?? ActivePipeline._defaultShader;
/// <summary>
/// Arguments for shaders
/// </summary>
public IDictionary<string, object> ShaderArguments;
/// <summary>
/// The current world matrix.
/// </summary>
public Matrix4 World;
/// <summary>
/// The current view matrix.
/// </summary>
public Matrix4 View;
/// <summary>
/// The current WorldView matrix.
/// </summary>
public Matrix4 WorldView;
/// <summary>
/// The master model matrix.
/// </summary>
public Matrix4 ModelMaster;
}
}

32
Legacy/Window/Contexts/UpdateContext.cs
View file

@ -1,32 +0,0 @@
#region usings
using OpenTK.Input;
using SM.Base.Scene;
#endregion
namespace SM.Base.Contexts
{
/// <summary>
/// The update context.
/// </summary>
public struct UpdateContext
{
/// <summary>
/// The delta time.
/// </summary>
public float Deltatime => SMRenderer.DefaultDeltatime.DeltaTime;
/// <summary>
/// The current keyboard state.
/// </summary>
public KeyboardState KeyboardState;
/// <summary>
/// The current mouse state.
/// </summary>
public MouseState MouseState;
public GenericScene CurrentScene;
}
}

48
Legacy/Window/GLWPFWindow2D.cs
View file

@ -1,48 +0,0 @@
using System;
using System.Windows.Media;
using OpenTK;
using OpenTK.Graphics.ES11;
using SM.Base;
using SM2D.Controls;
using SM2D.Pipelines;
using SM2D.Scene;
using SM2D.Shader;
namespace SM2D
{
public class GLWPFWindow2D : GenericWPFWindow<Scene.Scene, Camera>, IGLWindow2D
{
public GLWPFWindow2D()
{
Mouse = new Mouse2D(this);
}
public Vector2? Scaling { get; set; }
public Mouse2D Mouse { get; }
protected override void Init()
{
base.Init();
SMRenderer.DefaultMaterialShader = Default2DShader.MaterialShader;
//SetRenderPipeline(Default2DPipeline.Pipeline);
}
protected override void Rendering(TimeSpan delta)
{
GL.Disable(EnableCap.DepthTest);
base.Rendering(delta);
}
public override void SetWorldScale()
{
if (Scaling.HasValue)
{
if (Scaling.Value.X > 0 && Scaling.Value.Y > 0) WorldScale = Scaling.Value;
else if (Scaling.Value.X > 0) WorldScale = new Vector2(Scaling.Value.X, Scaling.Value.X / Aspect);
else if (Scaling.Value.Y > 0) WorldScale = new Vector2(Aspect * Scaling.Value.Y, Scaling.Value.Y);
}
}
}
}

65
Legacy/Window/GLWindow2D.cs
View file

@ -1,65 +0,0 @@
#region usings
using System;
using OpenTK;
using OpenTK.Graphics.OpenGL4;
using OpenTK.Input;
using SM.Base;
using SM2D.Controls;
using SM2D.Pipelines;
using SM2D.Scene;
using SM2D.Shader;
#endregion
namespace SM2D
{
public class GLWindow2D : GenericWindow<Scene.Scene, Camera>, IGLWindow2D
{
public GLWindow2D()
{
Mouse = new Mouse2D(this);
}
public Vector2? Scaling { get; set; }
public Mouse2D Mouse { get; }
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
GL.Enable(EnableCap.Blend);
GL.BlendFunc(BlendingFactor.SrcAlpha, BlendingFactor.OneMinusSrcAlpha);
}
protected override void OnLoaded()
{
base.OnLoaded();
SMRenderer.DefaultMaterialShader = Default2DShader.MaterialShader;
SetRenderPipeline(Default2DPipeline.Pipeline);
}
protected override void OnRenderFrame(FrameEventArgs e)
{
GL.Disable(EnableCap.DepthTest);
base.OnRenderFrame(e);
}
public override void SetWorldScale()
{
if (Scaling.HasValue)
{
if (Scaling.Value.X > 0 && Scaling.Value.Y > 0) WorldScale = Scaling.Value;
else if (Scaling.Value.X > 0) WorldScale = new Vector2(Scaling.Value.X, Scaling.Value.X / Aspect);
else if (Scaling.Value.Y > 0) WorldScale = new Vector2(Aspect * Scaling.Value.Y, Scaling.Value.Y);
}
}
protected override void OnMouseMove(MouseMoveEventArgs e)
{
base.OnMouseMove(e);
Mouse.MouseMoveEvent(e);
}
}
}

106
Legacy/Window/GenericWPFWindow.cs
View file

@ -1,106 +0,0 @@
using System;
using System.Drawing;
using System.Windows;
using System.Windows.Media;
using OpenTK;
using OpenTK.Wpf;
using SM.Base.Scene;
using SM.OGL;
namespace SM.Base
{
public class GenericWPFWindow : OpenTK.Wpf.GLWpfControl, IGenericWindow
{
protected GenericCamera _viewportCamera;
public bool Loading => !base.IsInitialized;
public float Aspect { get; set; }
public GenericCamera ViewportCamera => _viewportCamera;
public bool ForceViewportCamera { get; set; }
public int Width => (int) base.ActualWidth;
public int Height => (int) base.ActualHeight;
public Rectangle ClientRectangle => new Rectangle((int)base.RenderTransformOrigin.X, (int)RenderTransformOrigin.Y, Width, Height);
public Vector2 WorldScale { get; set; }
public GenericWPFWindow()
{
Ready += Init;
Render += Rendering;
}
protected virtual void Init()
{
GenericWindowCode.Load(this);
}
protected virtual void Rendering(TimeSpan delta)
{
}
protected override void OnRenderSizeChanged(SizeChangedInfo info)
{
base.OnRenderSizeChanged(info);
GenericWindowCode.Resize(this);
}
public void Start(bool renderContinuesly = false)
{
GLWpfControlSettings settings = new GLWpfControlSettings()
{
MajorVersion = GLSettings.ForcedVersion.MajorVersion,
MinorVersion = GLSettings.ForcedVersion.MinorVersion,
RenderContinuously = renderContinuesly
};
base.Start(settings);
}
public virtual void SetWorldScale()
{ }
}
public class GenericWPFWindow<TScene, TCamera> : GenericWPFWindow, IGenericWindow<TScene, TCamera>
where TScene : GenericScene, new()
where TCamera : GenericCamera, new()
{
private TScene _scene;
private RenderPipeline<TScene> _renderPipeline;
public TScene CurrentScene => _scene;
public RenderPipeline<TScene> RenderPipeline => _renderPipeline;
public GenericWPFWindow() : base()
{
_viewportCamera = new TCamera();
}
protected override void Rendering(TimeSpan delta)
{
base.Rendering(delta);
GenericWindowCode.Render(this, (float)delta.TotalSeconds);
}
protected override void OnRenderSizeChanged(SizeChangedInfo info)
{
base.OnRenderSizeChanged(info);
GenericWindowCode.Resize(this);
}
public void SetScene(TScene scene)
{
_scene = scene;
scene.Activate();
RenderPipeline?.SceneChanged(scene);
}
public void SetRenderPipeline(RenderPipeline<TScene> renderPipeline)
{
_renderPipeline = renderPipeline;
renderPipeline.Activate(this);
}
}
}

296
Legacy/Window/GenericWindow.cs
View file

@ -1,296 +0,0 @@
#region usings
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using OpenTK;
using OpenTK.Graphics;
using OpenTK.Graphics.OpenGL4;
using OpenTK.Input;
using SM.Base.Contexts;
using SM.Base.Drawing;
using SM.Base.Objects.Static;
using SM.Base.PostProcess;
using SM.Base.Scene;
using SM.Base.ShaderExtension;
using SM.Base.Time;
using SM.OGL;
using SM.OGL.Framebuffer;
using SM.Utility;
#endregion
namespace SM.Base
{
/// <summary>
/// The base window.
/// </summary>
public abstract class GenericWindow : GameWindow, IGenericWindow
{
protected GenericCamera _viewportCamera;
internal bool _loading = true;
internal List<Action> _actionsAfterLoading = new List<Action>();
public bool Loading => _loading;
/// <summary>
/// This tells you the current world scale.
/// </summary>
public Vector2 WorldScale { get; set; } = Vector2.Zero;
/// <summary>
/// This tells you the current aspect ratio of this window.
/// </summary>
public float Aspect { get; set; }
/// <summary>
/// If false, the window will not react on updates and will not render something.
/// <para>
/// Default: false
/// </para>
/// </summary>
public bool ReactWhileUnfocused = false;
public GenericCamera ViewportCamera => _viewportCamera;
public bool ForceViewportCamera { get; set; }
/// <inheritdoc />
protected GenericWindow() : this(1280, 720, "Generic OGL Title", GameWindowFlags.Default)
{
}
/// <summary>
/// Creates a window...
/// </summary>
protected GenericWindow(int width, int height, string title, GameWindowFlags flags, bool vSync = true) : base(width, height,
GraphicsMode.Default, title, flags, DisplayDevice.Default, GLSettings.ForcedVersion.MajorVersion,
GLSettings.ForcedVersion.MinorVersion, GraphicsContextFlags.Default)
{
VSync = vSync ? VSyncMode.On : VSyncMode.Off;
}
/// <inheritdoc />
protected override void OnLoad(EventArgs e)
{
GenericWindowCode.Load(this);
base.OnLoad(e);
}
/// <inheritdoc />
protected override void OnResize(EventArgs e)
{
base.OnResize(e);
GenericWindowCode.Resize(this);
if (_loading)
{
_loading = false;
OnLoaded();
_actionsAfterLoading.ForEach(a => a());
_actionsAfterLoading = null;
}
}
/// <summary>
/// This is triggered after all the window-loading has been done.
/// </summary>
protected virtual void OnLoaded()
{
}
/// <summary>
/// Sets the world scale.
/// </summary>
public virtual void SetWorldScale()
{
}
/// <inheritdoc />
protected override void OnUpdateFrame(FrameEventArgs e)
{
if (!ReactWhileUnfocused && !Focused) return;
base.OnUpdateFrame(e);
Deltatime.UpdateDelta = (float) e.Time;
var context = new UpdateContext
{
KeyboardState = Keyboard.GetState(),
MouseState = Mouse.GetState()
};
if (context.KeyboardState[Key.AltLeft] && context.KeyboardState[Key.F4]) Close();
Update(e, ref context);
}
/// <summary>
/// Updates the system.
/// </summary>
/// <param name="e"></param>
/// <param name="context"></param>
protected virtual void Update(FrameEventArgs e, ref UpdateContext context)
{
Stopwatch.PerformTicks(context);
}
/// <summary>
/// Grabs the cursor and make sure it doesn't leave the window.
/// </summary>
/// <param name="makeItInvisible">If true, it makes the cursor invisible.</param>
public void GrabCursor(bool makeItInvisible = true)
{
CursorGrabbed = true;
CursorVisible = !makeItInvisible;
}
/// <summary>
/// Ungrabs the cursor.
/// </summary>
public void UngrabCursor()
{
CursorGrabbed = false;
if (!CursorVisible) CursorVisible = true;
}
/// <summary>
/// Create a bitmap from the framebuffer.
/// </summary>
public Bitmap TakeScreenshot(Framebuffer framebuffer, ReadBufferMode readBuffer, int x, int y, int width, int height)
{
GL.GetInteger(GetPName.FramebufferBinding, out int prevFBId);
GL.GetInteger(GetPName.DrawFramebufferBinding, out int prevFBDrawId);
GL.GetInteger(GetPName.ReadFramebufferBinding, out int prevFBReadId);
Bitmap b = new Bitmap(width, height);
System.Drawing.Imaging.BitmapData bits = b.LockBits(new Rectangle(0, 0, width, height),
System.Drawing.Imaging.ImageLockMode.WriteOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
GL.BindFramebuffer(FramebufferTarget.ReadFramebuffer, framebuffer);
GL.ReadBuffer(readBuffer);
GL.ReadPixels(x, y, width, height, OpenTK.Graphics.OpenGL4.PixelFormat.Bgra, PixelType.UnsignedByte,
bits.Scan0);
b.UnlockBits(bits);
b.RotateFlip(RotateFlipType.RotateNoneFlipY);
GL.BindFramebuffer(FramebufferTarget.Framebuffer, prevFBId);
GL.BindFramebuffer(FramebufferTarget.DrawFramebuffer, prevFBDrawId);
GL.BindFramebuffer(FramebufferTarget.ReadFramebuffer, prevFBReadId);
return b;
}
}
/// <summary>
/// The base window.
/// </summary>
/// <typeparam name="TScene">The scene type</typeparam>
/// <typeparam name="TCamera">The camera type</typeparam>
public abstract class GenericWindow<TScene, TCamera> : GenericWindow, IGenericWindow<TScene, TCamera>
where TScene : GenericScene, new()
where TCamera : GenericCamera, new()
{
private RenderPipeline<TScene> _renderPipeline;
private TScene _scene;
/// <inheritdoc />
protected GenericWindow()
{
_viewportCamera = new TCamera();
}
/// <summary>
/// The viewport camera.
/// </summary>
public TCamera ViewportCamera {
get => (TCamera)_viewportCamera;
set => _viewportCamera = value;
}
/// <summary>
/// This forces the render to use the viewport camera.
/// </summary>
public bool ForceViewportCamera { get; set; } = false;
/// <summary>
/// The current scene.
/// </summary>
public TScene CurrentScene => _scene;
/// <summary>
/// Controls how a scene is rendered.
/// </summary>
public RenderPipeline<TScene> RenderPipeline => _renderPipeline;
/// <inheritdoc />
protected override void Update(FrameEventArgs e, ref UpdateContext context)
{
base.Update(e, ref context);
context.CurrentScene = CurrentScene;
CurrentScene?.Update(context);
}
/// <inheritdoc />
protected override void OnRenderFrame(FrameEventArgs e)
{
if (!ReactWhileUnfocused && !Focused) return;
base.OnRenderFrame(e);
GenericWindowCode.Render(this, (float)e.Time);
SwapBuffers();
GLDebugging.CheckGLErrors();
}
/// <inheritdoc />
protected override void OnResize(EventArgs e)
{
base.OnResize(e);
GenericWindowCode.Resize(this);
}
/// <summary>
/// Sets the scene.
/// </summary>
/// <param name="scene"></param>
public virtual void SetScene(TScene scene)
{
if (_loading)
{
_actionsAfterLoading.Add(() => SetScene(scene));
return;
}
_scene = scene;
scene.Activate();
RenderPipeline.SceneChanged(scene);
}
/// <summary>
/// Defines the render pipeline.
/// </summary>
/// <param name="pipeline"></param>
public void SetRenderPipeline(RenderPipeline<TScene> pipeline)
{
if (_loading)
{
_actionsAfterLoading.Add(() => SetRenderPipeline(pipeline));
return;
}
_renderPipeline = pipeline;
pipeline.Activate(this);
}
}
}

107
Legacy/Window/GenericWindowCode.cs
View file

@ -1,107 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using OpenTK;
using OpenTK.Graphics.OpenGL4;
using SM.Base.Contexts;
using SM.Base.Drawing;
using SM.Base.Objects.Static;
using SM.Base.PostProcess;
using SM.Base.Scene;
using SM.Base.ShaderExtension;
using SM.OGL;
using SM.Utility;
namespace SM.Base
{
public class GenericWindowCode
{
internal static void Load(IGenericWindow window)
{
SMRenderer.CurrentWindow = window;
GLSystem.INIT_SYSTEM();
GLSettings.ShaderPreProcessing = true;
var args = Environment.GetCommandLineArgs();
if (args.Contains("--advDebugging"))
{
SMRenderer.AdvancedDebugging = true;
GLSettings.InfoEveryUniform = true;
}
Log.Init();
Log.Write("#", ConsoleColor.Cyan, "----------------------",
"--- OpenGL Loading ---",
"----------------------------------",
$"--- {"DeviceVersion",14}: {GLSystem.DeviceVersion,-10} ---",
$"--- {"ForcedVersion",14}: {GLSettings.ForcedVersion,-10} ---",
$"--- {"ShadingVersion",14}: {GLSystem.ShadingVersion,-10} ---",
$"--- {"Debugging",14}: {GLSystem.Debugging,-10} ---",
$"--- {"AdvDebugging",14}: {SMRenderer.AdvancedDebugging,-10} ---",
"----------------------------------");
if (SMRenderer.AdvancedDebugging) Log.Write("Extension", ConsoleColor.DarkCyan, GLSystem.Extensions);
ExtensionManager.InitExtensions();
}
internal static void Resize(IGenericWindow window)
{
window.Aspect = (float) window.Width / window.Height;
window.WorldScale = new Vector2(window.Width, window.Height);
window.SetWorldScale();
GL.Viewport(window.ClientRectangle);
}
internal static void Resize<TScene, TCamera>(IGenericWindow<TScene, TCamera> window)
where TScene : GenericScene, new()
where TCamera : GenericCamera, new()
{
window.ViewportCamera.RecalculateWorld(window.WorldScale, window.Aspect);
window.RenderPipeline?.Resize();
PostProcessEffect.Model = Matrix4.CreateScale(window.WorldScale.X, -window.WorldScale.Y, 1);
PostProcessEffect.Mvp = PostProcessEffect.Model *
Matrix4.LookAt(0, 0, 1, 0, 0, 0, 0, 1, 0) *
GenericCamera.OrthographicWorld;
}
internal static void Render<TScene, TCamera>(IGenericWindow<TScene, TCamera> window, float deltatime)
where TScene : GenericScene, new()
where TCamera : GenericCamera, new()
{
if (window.CurrentScene == null) return;
SMRenderer.CurrentFrame++;
Deltatime.RenderDelta = deltatime;
var drawContext = new DrawContext
{
ForceViewport = window.ForceViewportCamera,
ActiveScene = window.CurrentScene,
Window = window,
Instances = new[]
{
new Instance
{ModelMatrix = Matrix4.Identity, TexturePosition = Vector2.Zero, TextureScale = Vector2.One}
},
Mesh = Plate.Object,
WorldScale = window.WorldScale,
LastPassthough = window,
ShaderArguments = new Dictionary<string, object>(),
World = window.ViewportCamera.World,
View = window.ViewportCamera.CalculateViewMatrix(),
ModelMaster = Matrix4.Identity
};
window.RenderPipeline?.Render(ref drawContext);
}
}
}

14
Legacy/Window/IGLWindow2D.cs
View file

@ -1,14 +0,0 @@
using OpenTK;
using SM.Base;
using SM2D.Controls;
using SM2D.Scene;
namespace SM2D
{
public interface IGLWindow2D : IGenericWindow<Scene.Scene, Camera>
{
Vector2? Scaling { get; set; }
Mouse2D Mouse { get; }
}
}

37
Legacy/Window/IGenericWindow.cs
View file

@ -1,37 +0,0 @@
using System.Drawing;
using System.Windows;
using OpenTK;
using SM.Base.Scene;
using SM.OGL.Framebuffer;
namespace SM.Base
{
public interface IGenericWindow : IFramebufferWindow
{
bool Loading { get; }
float Aspect { get; set; }
GenericCamera ViewportCamera { get; }
bool ForceViewportCamera { get; set; }
int Width { get; }
int Height { get; }
Rectangle ClientRectangle { get; }
Vector2 WorldScale { get; set; }
void SetWorldScale();
}
public interface IGenericWindow<TScene, TCamera> : IGenericWindow
where TScene : GenericScene, new()
where TCamera : GenericCamera, new()
{
TScene CurrentScene { get; }
RenderPipeline<TScene> RenderPipeline { get; }
void SetScene(TScene scene);
void SetRenderPipeline(RenderPipeline<TScene> renderPipeline);
}
}

150
Legacy/Window/RenderPipeline.cs
View file

@ -1,150 +0,0 @@
#region usings
using System.Collections.Generic;
using System.Threading;
using SM.Base.Contexts;
using SM.Base.Drawing;
using SM.Base.Scene;
using SM.OGL.Framebuffer;
#endregion
namespace SM.Base
{
/// <summary>
/// Definition of specific render options.
/// </summary>
public abstract class RenderPipeline
{
/// <summary>
/// If true, this pipeline was already once activated.
/// </summary>
public bool IsInitialized { get; private set; } = false;
/// <summary>
/// The window the pipeline is connected to.
/// </summary>
protected IGenericWindow _window { get; private set; }
/// <summary>
/// The framebuffers, that are used in this Pipeline.
/// </summary>
public virtual List<Framebuffer> Framebuffers { get; private set; }
/// <summary>
/// The default shader for the pipeline.
/// </summary>
protected internal virtual MaterialShader _defaultShader { get; set; }
public virtual Framebuffer MainFramebuffer { get; protected set; }= Framebuffer.Screen;
/// <summary>
/// Occurs, when the window is loading.
/// </summary>
protected internal virtual void Load()
{
}
/// <summary>
/// Occurs, when the window is resizing.
/// </summary>
protected internal virtual void Resize()
{
if (Framebuffers == null) return;
foreach (var framebuffer in Framebuffers)
framebuffer.Dispose();
Thread.Sleep(50);
foreach (Framebuffer framebuffer in Framebuffers)
{
framebuffer.Compile();
}
}
internal void Activate(IGenericWindow window)
{
_window = window;
if (!IsInitialized)
{
if (_defaultShader == null) _defaultShader = SMRenderer.DefaultMaterialShader;
Framebuffers = new List<Framebuffer>();
Initialization(window);
Framebuffers.Add(MainFramebuffer);
IsInitialized = true;
}
Activation(window);
}
/// <summary>
/// Occurs, when the pipeline was connected to a window.
/// </summary>
protected internal virtual void Activation(IGenericWindow window)
{
}
/// <summary>
/// Occurs, when the pipeline was connected to a window the first time.
/// </summary>
/// <param name="window"></param>
protected internal virtual void Initialization(IGenericWindow window)
{
}
/// <summary>
/// Occurs, when the window is unloading.
/// </summary>
protected internal virtual void Unload()
{
}
/// <summary>
/// Creates a framebuffer, that has specific (often) required settings already applied.
/// </summary>
/// <returns></returns>
public static Framebuffer CreateWindowFramebuffer()
{
Framebuffer framebuffer = new Framebuffer(window: SMRenderer.CurrentWindow);
framebuffer.Append("color", 0);
return framebuffer;
}
}
/// <summary>
/// Represents a render pipeline.
/// </summary>
/// <typeparam name="TScene">The scene type</typeparam>
public abstract class RenderPipeline<TScene> : RenderPipeline
where TScene : GenericScene
{
/// <summary>
/// The system to render stuff.
/// </summary>
internal void Render(ref DrawContext context)
{
context.ActivePipeline = this;
if (context.ActiveScene == null) return;
RenderProcess(ref context, (TScene)context.ActiveScene);
}
protected abstract void RenderProcess(ref DrawContext context, TScene scene);
/// <summary>
/// Event, that triggers, when the scene in the current window changes.
/// </summary>
/// <param name="scene"></param>
protected internal virtual void SceneChanged(TScene scene)
{
}
}
}

162
MigrationBackup/d4ed0f1f/SMRenderer/SM2D/NuGetUpgradeLog.html
View file

@ -1,162 +0,0 @@
<!DOCTYPE html>
<!-- saved from url=(0014)about:internet -->
<html xmlns:msxsl="urn:schemas-microsoft-com:xslt"><head><meta content="en-us" http-equiv="Content-Language" /><meta content="text/html; charset=utf-16" http-equiv="Content-Type" /><title _locID="NuGetUpgradeReportTitle">
NuGetMigrationLog
</title><style>
/* Body style, for the entire document */
body
{
background: #F3F3F4;
color: #1E1E1F;
font-family: "Segoe UI", Tahoma, Geneva, Verdana, sans-serif;
font-size: 12pt;
padding: 0;
margin: 0;
}
/* Header1 style, used for the main title */
h1
{
padding: 10px 0px 10px 10px;
font-size: 21pt;
background-color: #E2E2E2;
border-bottom: 1px #C1C1C2 solid;
color: #201F20;
margin: 0;
font-weight: normal;
}
/* Header2 style, used for "Overview" and other sections */
h2
{
font-size: 18pt;
font-weight: normal;
padding: 15px 0 5px 0;
margin: 0;
}
/* Header3 style, used for sub-sections, such as project name */
h3
{
font-weight: normal;
font-size: 15pt;
margin: 0;
padding: 15px 0 5px 0;
background-color: transparent;
}
.info-text
{
margin: 0px 0 0.75em 0;
}
/* Color all hyperlinks one color */
a
{
color: #1382CE;
}
/* Table styles */
table
{
border-spacing: 0 0;
border-collapse: collapse;
font-size: 11pt;
}
table th
{
background: #E7E7E8;
text-align: left;
text-decoration: none;
font-weight: normal;
padding: 3px 6px 3px 6px;
}
table td
{
vertical-align: top;
padding: 3px 6px 5px 5px;
margin: 0px;
border: 1px solid #E7E7E8;
background: #F7F7F8;
}
/* Local link is a style for hyperlinks that link to file:/// content, there are lots so color them as 'normal' text until the user mouse overs */
.localLink
{
color: #1E1E1F;
background: #EEEEED;
text-decoration: none;
}
.localLink:hover
{
color: #1382CE;
background: #FFFF99;
text-decoration: none;
}
.issueCell
{
width: 100%;
}
.packageIssue
{
margin-left: 25px;
}
/* Padding around the content after the h1 */
#content
{
padding: 0px 20px 20px 20px;
}
.issues table
{
width: 97%;
}
/* All Icons */
.IconSuccessEncoded, .IconInfoEncoded, .IconWarningEncoded, .IconErrorEncoded
{
min-width:18px;
min-height:18px;
background-repeat:no-repeat;
background-position:center;
}
.IconSuccessEncoded
{
background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAACXBIWXMAAA7EAAAOxAGVKw4bAAABcElEQVR4Xq2TsUsCURzHv15g8ZJcBWlyiYYgCIWcb9DFRRwMW5TA2c0/QEFwFkxxUQdxVlBwCYWOi6IhWgQhBLHJUCkhLr/BW8S7gvrAg+N+v8/v+x68Z8MGy+XSCyABQAXgBgHGALoASkIIDWSLeLBetdHryMjd5IxQPWT4rn1c/P7+xxp72Cs9m5SZ0Bq2vPnbPFafK2zDvmNHypdC0BPkLlQhxJsCAhQoZwdZU5mwxh720qGo8MzTxTTKZDPCx2HoVzp6lz0Q9tKhyx0kGs8Ny+TkWRKk8lCROwEduhyg9l/6lunOPSfmH3NUH6uQ0KHLAe7JYvJjevm+DAMGJHToKtigE+vwvIidxLamb8IBY9e+C5LiXREkfho3TSd06HJA13/oh6T51MTsfQbHrsMynQ5dDihFjiK8JJAU9AKIWTp76dCVN7HWHrajmUEGvyF9nkbAE6gLIS7kTUyuf2gscLoJrElZo/Mvj+nPz/kLTmfnEwP3tB0AAAAASUVORK5CYII=);
}
.IconInfoEncoded
{
background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAABHElEQVR4Xs2TsUoDQRRF7wwoziokjZUKadInhdhukR9YP8DMX1hYW+QvdsXa/QHBbcXC7W0CamWTQnclFutceIQJwwaWNLlwm5k5d94M76mmaeCrrmsLYOocY12FcxZFUeozCqKqqgYA8uevv1H6VuPxcwlfk5N92KHBxfFeCSAxxswlYAW/Xr989x/mv9gkhtyMDhcAxgzRsp7flj8B/HF1RsMXq+NZMkopaHe7lbKxQUEIGbKsYNoGn969060hZBkQex/W8oRQwsQaW2o3Ago2SVcJUzAgY3N0lTCZZm+zPS8HB51gMmS1DEYyOz9acKO1D8JWTlafKIMxdhvlfdyT94Vv5h7P8Ky7nQzACmhvKq3zk3PjW9asz9D/1oigecsioooAAAAASUVORK5CYII=);
}
.IconWarningEncoded
{
background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAAx0lEQVR4XpWSMQ7CMAxFf4xAyBMLCxMrO8dhaBcuwdCJS3RJBw7SA/QGTCxdWJgiQYWKXJWKIXHIlyw5lqr34tQgEOdcBsCOx5yZK3hCCKdYXneQkh4pEfqzLfu+wVDSyyzFoJjfz9NB+pAF+eizx2Vruts0k15mPgvS6GYvpVtQhB61IB/dk6AF6fS4Ben0uIX5odtFe8Q/eW1KvFeH4e8khT6+gm5B+t3juyDt7n0jpe+CANTd+oTUjN/U3yVaABnSUjFz/gFq44JaVSCXeQAAAABJRU5ErkJggg==);
}
.IconErrorEncoded
{
background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAABQElEQVR4XqWTvUoEQRCE6wYPZUA80AfwAQz23uCMjA7MDRQEIzPBVEyNTQUFIw00vcQTTMzuAh/AxEQQT8HF/3G/oGGnEUGuoNnd6qoZuqltyKEsyzVJq5I6rnUp6SjGeGhESikzzlc1eL7opfuVbrqbU1Zw9NCgtQMaZpY0eNnaaL2fHusvTK5vKu7sjSS1Y4y3QUA6K3e3Mau5UFDyMP7tYF9o8cAHZv68vipoIJg971PZIZ5HiwdvYGGvFVFHmGmZ2MxwmQYPXubPl9Up0tfoMQGetXd6mRbvhBw+boZ6WF7Mbv1+GsHRk0fQmPAH1GfmZirbCfDJ61tw3Px8/8pZsPAG4jlVhcPgZ7adwNWBB68lkRQWFiTgFlbnLY3DGGM7izIJIyT/jjIvEJw6fdJTc6krDzh6aMwMP9bvDH4ADSsa9uSWVJkAAAAASUVORK5CYII=);
}
</style></head><body><h1>
NuGet Migration Report - SMRenderer\SM2D</h1><div id="content"><h2 _locID="OverviewTitle">Overview</h2><div class="info-text">Migration to PackageReference was completed successfully. Please build and run your solution to verify that all packages are available.</div><div class="info-text">
If you run into any problems, have feedback, questions, or concerns, please
<a href="https://github.com/NuGet/Home/issues/">file an issue on the NuGet GitHub repository.</a></div><div class="info-text">
Changed files and this report have been backed up here:
<a href="C:\Users\user\source\repos\IedSoftworks\SMRendererV3\MigrationBackup\d4ed0f1f\SMRenderer\SM2D">C:\Users\user\source\repos\IedSoftworks\SMRendererV3\MigrationBackup\d4ed0f1f\SMRenderer\SM2D</a></div><div class="info-text"><a href="https://aka.ms/nuget-pc2pr-migrator-rollback">Help me rollback to packages.config</a></div><h2 _locID="PackagesTitle">Packages processed</h2><h3 _locID="IncludePackagesTitle">Top-level dependencies:</h3><div class="issues"><table><tr><th class="issueCell">Package Id</th><th>Version</th></tr><tr><td class="issueCell"><span>OpenTK</span></td><td><span>
v3.2.1</span></td></tr></table></div><p /><h3 _locID="IncludePackagesTitle">Transitive dependencies:</h3><div class="issues"><table><tr><th class="issueCell">Package Id</th><th>Version</th></tr><tr><td class="issueCell">
No transitive dependencies found.
</td><td /></tr></table></div><h2 _locID="IssuesTitle">Package compatibility issues</h2><div class="issues"><table><tr><th /><th class="issueCell" _locID="DescriptionTableHeader">Description</th></tr><tr><td class="IconInfoEncoded" /><td class="issueCell">
No issues were found.
</td></tr></table></div></div></body></html>

82
MigrationBackup/d4ed0f1f/SMRenderer/SM2D/SM2D.csproj
View file

@ -1,82 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProjectGuid>{A4565538-625A-42C6-A330-DD4F1ABB3986}</ProjectGuid>
<OutputType>Library</OutputType>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>SM2D</RootNamespace>
<AssemblyName>SM2D</AssemblyName>
<TargetFrameworkVersion>v4.5.2</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
<Deterministic>true</Deterministic>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<OutputPath>bin\Debug\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<OutputPath>bin\Release\</OutputPath>
<DefineConstants>TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<ItemGroup>
<Reference Include="OpenTK, Version=3.2.1.0, Culture=neutral, PublicKeyToken=bad199fe84eb3df4, processorArchitecture=MSIL">
<HintPath>..\..\packages\OpenTK.3.2.1\lib\net20\OpenTK.dll</HintPath>
</Reference>
<Reference Include="System" />
<Reference Include="System.Core" />
<Reference Include="System.Drawing" />
</ItemGroup>
<ItemGroup>
<Compile Include="Controls\Mouse2D.cs" />
<Compile Include="Drawing\DrawBackground.cs" />
<Compile Include="Drawing\DrawBackgroundShader.cs" />
<Compile Include="Drawing\DrawColor.cs" />
<Compile Include="Drawing\DrawComplex.cs" />
<Compile Include="Drawing\DrawObject2D.cs" />
<Compile Include="Drawing\DrawParticles.cs" />
<Compile Include="Drawing\DrawPolygon.cs" />
<Compile Include="Drawing\DrawShader.cs" />
<Compile Include="Drawing\DrawText.cs" />
<Compile Include="Drawing\DrawTexture.cs" />
<Compile Include="GLWindow2D.cs" />
<Compile Include="Object\Polygon.cs" />
<Compile Include="Object\PolygonVertex.cs" />
<Compile Include="Pipelines\Adv2DPipeline.cs" />
<Compile Include="Pipelines\Basic2DPipeline.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
<Compile Include="Scene\Camera.cs" />
<Compile Include="Scene\I2DShowItem.cs" />
<Compile Include="Scene\ItemCollection.cs" />
<Compile Include="Scene\Scene.cs" />
<Compile Include="Shader\Default2DShader.cs" />
<Compile Include="Types\Transformation.cs" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\SM.Base\SM.Base.csproj">
<Project>{8e733844-4204-43e7-b3dc-3913cddabb0d}</Project>
<Name>SM.Base</Name>
</ProjectReference>
<ProjectReference Include="..\SM.OGL\SM.OGL.csproj">
<Project>{f604d684-bc1d-4819-88b5-8b5d03a17be0}</Project>
<Name>SM.OGL</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<None Include="OpenTK.dll.config" />
<None Include="packages.config" />
<EmbeddedResource Include="Shader\ShaderFiles\default.glsl" />
</ItemGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
</Project>

4
MigrationBackup/d4ed0f1f/SMRenderer/SM2D/packages.config
View file

@ -1,4 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<packages>
<package id="OpenTK" version="3.2.1" targetFramework="net452" />
</packages>