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

Fixed Merge

Browse source
This commit is contained in:
Michel Fedde 2021-03-22 13:20:59 +01:00
commit bb030f588b
65 changed files with 917 additions and 1427 deletions
Download patch file Download diff file Expand all files Collapse all files

6
.gitignore vendored
View file

@ -10,6 +10,11 @@
*.userosscache *.userosscache
*.sln.docstates *.sln.docstates
# Dev-Added files
*.nuspec
*/*/nuget.exe
**/apireference/**
# User-specific files (MonoDevelop/Xamarin Studio) # User-specific files (MonoDevelop/Xamarin Studio)
*.userprefs *.userprefs
@ -26,6 +31,7 @@ bld/
[Bb]in/ [Bb]in/
[Oo]bj/ [Oo]bj/
[Ll]og/ [Ll]og/
build/*
# Visual Studio 2015/2017 cache/options directory # Visual Studio 2015/2017 cache/options directory
.vs/ .vs/

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>

22
SMCode/SM.Base/Controls/Mouse.cs
View file

@ -28,6 +28,18 @@ namespace SM.Base.Controls
/// </summary> /// </summary>
public static Vector2 InScreenNormalized { get; private set; } public static Vector2 InScreenNormalized { get; private set; }
/// <summary>
/// This returns true, if the left mouse button was pressed.
/// <para>Its pretty much: IsDown(MouseButton.Left, true)</para>
/// </summary>
public static bool LeftClick => IsDown(MouseButton.Left, true);
/// <summary>
/// This returns true, if the right mouse button was pressed.
/// <para>Its pretty much: IsDown(MouseButton.Right, true)</para>
/// </summary>
public static bool RightClick => IsDown(MouseButton.Right, true);
/// <summary> /// <summary>
/// The event to update the values. /// The event to update the values.
/// </summary> /// </summary>
@ -53,11 +65,21 @@ namespace SM.Base.Controls
_mouseState = OpenTK.Input.Mouse.GetState(); _mouseState = OpenTK.Input.Mouse.GetState();
} }
/// <summary>
/// Checks if the mouse is pressed.
/// </summary>
/// <param name="button"></param>
/// <param name="once">If true, it will not get called, when it was pressed in the last update.</param>
public static bool IsDown(MouseButton button, bool once = false) public static bool IsDown(MouseButton button, bool once = false)
{ {
return _mouseState?[button] == true && !(once && _lastButtonsPressed.Contains(button)); return _mouseState?[button] == true && !(once && _lastButtonsPressed.Contains(button));
} }
/// <summary>
/// Checks if the mouse is not pressed.
/// </summary>
/// <param name="button"></param>
/// <param name="once">If true, it will not get called, when it was not pressed in the last update.</param>
public static bool IsUp(MouseButton button, bool once = false) public static bool IsUp(MouseButton button, bool once = false)
{ {
return _mouseState?[button] == false && !(once && !_lastButtonsPressed.Contains(button)); return _mouseState?[button] == false && !(once && !_lastButtonsPressed.Contains(button));

1
SMCode/SM.Base/Drawing/DrawingBasis.cs
View file

@ -55,6 +55,7 @@ namespace SM.Base.Drawing
/// </summary> /// </summary>
public bool Active { get; set; } = true; public bool Active { get; set; } = true;
/// <inheritdoc />
public bool RenderActive { get; set; } = true; public bool RenderActive { get; set; } = true;
/// <inheritdoc /> /// <inheritdoc />

9
SMCode/SM.Base/SM.Base.csproj
View file

@ -34,19 +34,10 @@
<LangVersion>latest</LangVersion> <LangVersion>latest</LangVersion>
</PropertyGroup> </PropertyGroup>
<ItemGroup> <ItemGroup>
<Reference Include="GLWpfControl, Version=3.2.3.0, Culture=neutral, processorArchitecture=MSIL">
<HintPath>..\..\packages\OpenTK.GLWpfControl.3.2.3\lib\net452\GLWpfControl.dll</HintPath>
</Reference>
<Reference Include="OpenTK, Version=3.3.1.0, Culture=neutral, PublicKeyToken=bad199fe84eb3df4, processorArchitecture=MSIL"> <Reference Include="OpenTK, Version=3.3.1.0, Culture=neutral, PublicKeyToken=bad199fe84eb3df4, processorArchitecture=MSIL">
<HintPath>..\..\packages\OpenTK.3.3.1\lib\net20\OpenTK.dll</HintPath> <HintPath>..\..\packages\OpenTK.3.3.1\lib\net20\OpenTK.dll</HintPath>
</Reference> </Reference>
<Reference Include="PresentationCore" /> <Reference Include="PresentationCore" />
<Reference Include="SharpDX, Version=4.2.0.0, Culture=neutral, PublicKeyToken=b4dcf0f35e5521f1, processorArchitecture=MSIL">
<HintPath>..\..\packages\SharpDX.4.2.0\lib\net45\SharpDX.dll</HintPath>
</Reference>
<Reference Include="SharpDX.XInput, Version=4.2.0.0, Culture=neutral, PublicKeyToken=b4dcf0f35e5521f1, processorArchitecture=MSIL">
<HintPath>..\..\packages\SharpDX.XInput.4.2.0\lib\net45\SharpDX.XInput.dll</HintPath>
</Reference>
<Reference Include="System" /> <Reference Include="System" />
<Reference Include="System.Core" /> <Reference Include="System.Core" />
<Reference Include="System.Drawing" /> <Reference Include="System.Drawing" />

5
SMCode/SM.Base/SMRenderer.cs
View file

@ -43,6 +43,11 @@ namespace SM.Base
/// </summary> /// </summary>
public static MaterialShader DefaultMaterialShader; public static MaterialShader DefaultMaterialShader;
/// <summary>
/// The default render pipeline.
/// </summary>
public static RenderPipeline DefaultRenderPipeline;
/// <summary> /// <summary>
/// Shows more information onto the log system. /// Shows more information onto the log system.
/// </summary> /// </summary>

17
SMCode/SM.Base/Scene/GenericItemCollection.cs
View file

@ -15,8 +15,8 @@ namespace SM.Base.Scene
/// </summary> /// </summary>
public abstract class GenericItemCollection : List<IShowItem>, IShowItem, IShowCollection, IScriptable, IFixedScriptable public abstract class GenericItemCollection : List<IShowItem>, IShowItem, IShowCollection, IScriptable, IFixedScriptable
{ {
private List<IScriptable> _scriptableObjects = new List<IScriptable>(); private readonly List<IScriptable> _scriptableObjects = new List<IScriptable>();
private List<IFixedScriptable> _fixedScriptables = new List<IFixedScriptable>(); private readonly List<IFixedScriptable> _fixedScriptables = new List<IFixedScriptable>();
/// <summary> /// <summary>
/// Currently active script objects. /// Currently active script objects.
@ -45,6 +45,7 @@ namespace SM.Base.Scene
/// <inheritdoc /> /// <inheritdoc />
public bool RenderActive { get; set; } = true; public bool RenderActive { get; set; } = true;
/// <inheritdoc />
public virtual void FixedUpdate(FixedUpdateContext context) public virtual void FixedUpdate(FixedUpdateContext context)
{ {
if (!Active || !UpdateActive) return; if (!Active || !UpdateActive) return;
@ -126,6 +127,11 @@ namespace SM.Base.Scene
if (item is IFixedScriptable fs) _fixedScriptables.Add(fs); if (item is IFixedScriptable fs) _fixedScriptables.Add(fs);
} }
/// <summary>
/// Removes an object from the drawing list.
/// <para>If the object is a scriptable object, it will remove the object from that list as well.</para>
/// </summary>
/// <param name="items"></param>
public void Remove(params IShowItem[] items) public void Remove(params IShowItem[] items)
{ {
foreach (var item in items) foreach (var item in items)
@ -161,6 +167,12 @@ namespace SM.Base.Scene
if (item is IFixedScriptable fs) _fixedScriptables.Remove(fs); if (item is IFixedScriptable fs) _fixedScriptables.Remove(fs);
} }
/// <summary>
/// Returns all objects in the drawing list.
/// <para>Not reclusive.</para>
/// </summary>
/// <param name="includeCollections">If true, it will add collections as well.</param>
/// <returns></returns>
public ICollection<IShowItem> GetAllItems(bool includeCollections = false) public ICollection<IShowItem> GetAllItems(bool includeCollections = false)
{ {
List<IShowItem> items = new List<IShowItem>(); List<IShowItem> items = new List<IShowItem>();
@ -224,7 +236,6 @@ namespace SM.Base.Scene
/// <summary> /// <summary>
/// Contains a list of show items with transformation. /// Contains a list of show items with transformation.
/// </summary> /// </summary>
/// <typeparam name="TItem">The type of show items.</typeparam>
/// <typeparam name="TTransformation">The type of transformation.</typeparam> /// <typeparam name="TTransformation">The type of transformation.</typeparam>
public abstract class GenericItemCollection<TTransformation> : GenericItemCollection, public abstract class GenericItemCollection<TTransformation> : GenericItemCollection,
IShowTransformItem<TTransformation> IShowTransformItem<TTransformation>

18
SMCode/SM.Base/Scene/GenericScene.cs
View file

@ -213,18 +213,24 @@ namespace SM.Base.Scene
/// A generic scene that imports different functions. /// A generic scene that imports different functions.
/// </summary> /// </summary>
/// <typeparam name="TCamera">The type of cameras.</typeparam> /// <typeparam name="TCamera">The type of cameras.</typeparam>
/// <typeparam name="TItem">The type of show items.</typeparam>
/// <typeparam name="TCollection">The type for collections</typeparam> /// <typeparam name="TCollection">The type for collections</typeparam>
public abstract class GenericScene<TCamera, TCollection> : GenericScene public abstract class GenericScene<TCamera, TCollection> : GenericScene
where TCamera : GenericCamera, new() where TCamera : GenericCamera, new()
where TCollection : GenericItemCollection, new() where TCollection : GenericItemCollection, new()
{ {
/// <summary>
/// Objects inside the scene, but as the collection type.
/// </summary>
public new TCollection Objects public new TCollection Objects
{ {
get => (TCollection) base.Objects; get => (TCollection) base.Objects;
set => base.Objects = value; set => base.Objects = value;
} }
/// <summary>
/// HUD-Objects inside the scene, but as the collection type.
/// </summary>
public new TCollection HUD public new TCollection HUD
{ {
get get
@ -235,18 +241,28 @@ namespace SM.Base.Scene
set => base.HUD = value; set => base.HUD = value;
} }
/// <summary>
/// The active camera, that is used if the context doesn't force the viewport camera.
/// <para>If none set, it automaticly uses the viewport camera.</para>
/// </summary>
public new TCamera Camera public new TCamera Camera
{ {
get => (TCamera) base.Camera; get => (TCamera) base.Camera;
set => base.Camera = value; set => base.Camera = value;
} }
/// <summary>
/// A camera to control the HUD.
/// </summary>
public new TCamera HUDCamera public new TCamera HUDCamera
{ {
get => (TCamera) base.HUDCamera; get => (TCamera) base.HUDCamera;
set => base.HUDCamera = value; set => base.HUDCamera = value;
} }
/// <summary>
/// A camera to control the background.
/// </summary>
public new TCamera BackgroundCamera public new TCamera BackgroundCamera
{ {
get => (TCamera) base.BackgroundCamera; get => (TCamera) base.BackgroundCamera;

17
SMCode/SM.Base/Scene/IShowItem.cs
View file

@ -55,19 +55,36 @@ namespace SM.Base.Scene
void OnRemoved(object sender); void OnRemoved(object sender);
} }
/// <summary>
/// Interface to implement transformation.
/// </summary>
/// <typeparam name="TTransform"></typeparam>
public interface ITransformItem<TTransform> public interface ITransformItem<TTransform>
where TTransform : GenericTransformation where TTransform : GenericTransformation
{ {
/// <summary>
/// Controls the transformation of the object.
/// </summary>
TTransform Transform { get; set; } TTransform Transform { get; set; }
} }
/// <summary>
/// Merges <see cref="IShowItem"/> and <see cref="ITransformItem{TTransform}"/>.
/// </summary>
/// <typeparam name="TTransform"></typeparam>
public interface IShowTransformItem<TTransform> : IShowItem, ITransformItem<TTransform> public interface IShowTransformItem<TTransform> : IShowItem, ITransformItem<TTransform>
where TTransform : GenericTransformation where TTransform : GenericTransformation
{ {
} }
/// <summary>
/// Interface to implement models in the object.
/// </summary>
public interface IModelItem public interface IModelItem
{ {
/// <summary>
/// The mesh the rendering should use.
/// </summary>
GenericMesh Mesh { get; set; } GenericMesh Mesh { get; set; }
} }
} }

14
SMCode/SM.Base/Types/CVector1.cs
View file

@ -96,7 +96,6 @@ namespace SM.Base.Types
/// <summary> /// <summary>
/// Conversion from <see cref="float" /> to One-dimensional Vector. /// Conversion from <see cref="float" /> to One-dimensional Vector.
/// </summary> /// </summary>
/// <param name="f"></param>
/// <returns></returns> /// <returns></returns>
//public static implicit operator CVector1(float f) => new CVector1(f); //public static implicit operator CVector1(float f) => new CVector1(f);
protected virtual float GetLengthProcess() protected virtual float GetLengthProcess()
@ -104,14 +103,27 @@ namespace SM.Base.Types
return X * X; return X * X;
} }
/// <summary>
/// Normalizes the vector.
/// </summary>
/// <param name="length"></param>
protected virtual void NormalizationProcess(float length) protected virtual void NormalizationProcess(float length)
{ {
X *= length; X *= length;
} }
/// <summary>
/// This triggers the <see cref="Changed"/> event.
/// </summary>
protected void TriggerChanged() protected void TriggerChanged()
{ {
Changed?.Invoke(); Changed?.Invoke();
} }
/// <inheritdoc />
public override string ToString()
{
return X.ToString();
}
} }
} }

9
SMCode/SM.Base/Types/CVector2.cs
View file

@ -46,6 +46,12 @@ namespace SM.Base.Types
Y *= length; Y *= length;
} }
/// <inheritdoc />
public override string ToString()
{
return "{"+X+"; "+Y+"}";
}
/// <summary> /// <summary>
/// Sets each component to the same value /// Sets each component to the same value
/// </summary> /// </summary>
@ -58,7 +64,6 @@ namespace SM.Base.Types
/// <summary> /// <summary>
/// Sets each component to the <see cref="Vector2" /> counter-part. /// Sets each component to the <see cref="Vector2" /> counter-part.
/// </summary> /// </summary>
/// <param name="vector"></param>
public void Set(Vector2 vector, bool triggerChanged = true) public void Set(Vector2 vector, bool triggerChanged = true)
{ {
Set(vector.X, vector.Y, triggerChanged); Set(vector.X, vector.Y, triggerChanged);
@ -67,8 +72,6 @@ namespace SM.Base.Types
/// <summary> /// <summary>
/// Sets the a own value to each component. /// Sets the a own value to each component.
/// </summary> /// </summary>
/// <param name="x"></param>
/// <param name="y"></param>
public void Set(float x, float y, bool triggerChanged = true) public void Set(float x, float y, bool triggerChanged = true)
{ {
Y = y; Y = y;

6
SMCode/SM.Base/Types/CVector3.cs
View file

@ -46,6 +46,12 @@ namespace SM.Base.Types
Z *= length; Z *= length;
} }
/// <inheritdoc />
public override string ToString()
{
return "{" + X + "; " + Y + "}";
}
/// <inheritdoc /> /// <inheritdoc />
public override void Set(float uniform, bool triggerChanged = true) public override void Set(float uniform, bool triggerChanged = true)
{ {

12
SMCode/SM.Base/Window/Contexts/UpdateContext.cs
View file

@ -6,12 +6,24 @@ using SM.Base.Scene;
namespace SM.Base.Window namespace SM.Base.Window
{ {
/// <summary>
/// A context that gets send when a window want to update the scene.
/// </summary>
public struct UpdateContext public struct UpdateContext
{ {
/// <summary>
/// The window what triggered the updated.
/// </summary>
public IGenericWindow Window; public IGenericWindow Window;
/// <summary>
/// A current update delta time. Equivalent to <see cref="SMRenderer.DefaultDeltatime"/>.
/// </summary>
public float Deltatime => SMRenderer.DefaultDeltatime.DeltaTime; public float Deltatime => SMRenderer.DefaultDeltatime.DeltaTime;
/// <summary>
/// The scene that gets updated.
/// </summary>
public GenericScene Scene; public GenericScene Scene;
} }
} }

241
SMCode/SM.Base/Window/GLWindow.cs
View file

@ -3,6 +3,7 @@
using System; using System;
using System.ComponentModel; using System.ComponentModel;
using System.Diagnostics; using System.Diagnostics;
using System.Drawing.Text;
using System.Threading; using System.Threading;
using System.Windows.Forms; using System.Windows.Forms;
using OpenTK; using OpenTK;
@ -18,58 +19,105 @@ using Mouse = SM.Base.Controls.Mouse;
namespace SM.Base.Window namespace SM.Base.Window
{ {
/// <summary>
/// This provides the main entry, by executing the window.
/// </summary>
public class GLWindow : GameWindow, IGenericWindow public class GLWindow : GameWindow, IGenericWindow
{ {
private Vector2 _flagWindowPos;
private Vector2 _flagWindowSize; private Vector2 _flagWindowSize;
private Thread _fixedUpdateThread; private Thread _fixedUpdateThread;
private WindowFlags _windowFlags;
public WindowFlags WindowFlags; private DisplayResolution _normalResolution;
private DisplayResolution _fullscreenResolution;
/// <inheritdoc />
public bool Loading { get; private set; } = true;
/// <inheritdoc />
public float AspectRatio { get; set; }
/// <inheritdoc />
public GenericCamera ViewportCamera { get; set; }
/// <inheritdoc />
public bool ForceViewportCamera { get; set; }
/// <inheritdoc />
public bool DrawWhileUnfocused { get; set; } = true;
/// <inheritdoc />
public bool UpdateWhileUnfocused { get; set; } = false;
/// <inheritdoc />
public Vector2 WindowSize { get; set; }
/// <inheritdoc />
public ISetup AppliedSetup { get; private set; }
/// <inheritdoc />
public new event Action<IGenericWindow> Resize;
/// <inheritdoc />
public new event Action<IGenericWindow> Load;
/// <inheritdoc />
public GenericScene CurrentScene { get; private set; }
/// <inheritdoc />
public RenderPipeline CurrentRenderPipeline { get; private set; }
/// <summary>
/// Gets/Sets the current window flag.
/// </summary>
public WindowFlags WindowFlags
{
get => _windowFlags;
set
{
if (_windowFlags != value)
{
WindowFlags oldV = _windowFlags;
_windowFlags = value;
ChangeWindowFlag(value, oldV);
}
}
}
/// <summary>
/// Loads the window with default values.
/// <para>Width: 1280px; Height: 720px; Title: Generic OpenGL Title; WindowFlag: Window</para>
/// </summary>
public GLWindow() : this(1280, 720, "Generic OpenGL Title", WindowFlags.Window) public GLWindow() : this(1280, 720, "Generic OpenGL Title", WindowFlags.Window)
{ {
} }
/// <summary>
/// Loads the window with custom values.
/// </summary>
/// <param name="width"></param>
/// <param name="height"></param>
/// <param name="title"></param>
/// <param name="flags"></param>
/// <param name="vSync"></param>
public GLWindow(int width, int height, string title, WindowFlags flags, VSyncMode vSync = VSyncMode.On) : public GLWindow(int width, int height, string title, WindowFlags flags, VSyncMode vSync = VSyncMode.On) :
base(width, height, default, title, (GameWindowFlags) flags, DisplayDevice.Default, base(width, height, default, title, GameWindowFlags.Default, DisplayDevice.Default,
GLSettings.ForcedVersion.MajorVersion, GLSettings.ForcedVersion.MinorVersion, GLSettings.ForcedVersion.MajorVersion, GLSettings.ForcedVersion.MinorVersion,
GraphicsContextFlags.Default) GraphicsContextFlags.Default)
{ {
VSync = vSync; VSync = vSync;
_flagWindowSize = new Vector2(width, height); WindowFlags = flags;
ChangeWindowFlag(flags); FocusedChanged += GLWindow_FocusedChanged;
_normalResolution = _fullscreenResolution = DisplayDevice.Default.SelectResolution(DisplayDevice.Default.Width, DisplayDevice.Default.Height, DisplayDevice.Default.BitsPerPixel, DisplayDevice.Default.RefreshRate);
} }
public bool Loading { get; private set; } = true;
public float AspectRatio { get; set; }
public GenericCamera ViewportCamera { get; set; }
public bool ForceViewportCamera { get; set; }
public bool DrawWhileUnfocused { get; set; } = true;
public bool UpdateWhileUnfocused { get; set; } = false;
public Vector2 WindowSize { get; set; }
public ISetup AppliedSetup { get; private set; }
public new event Action<IGenericWindow> Resize;
public new event Action<IGenericWindow> Load;
public GenericScene CurrentScene { get; private set; }
public RenderPipeline CurrentRenderPipeline { get; private set; }
public void TriggerLoad()
{
Load?.Invoke(this);
}
public void TriggerResize()
{
Resize?.Invoke(this);
}
/// <summary>
/// A event that gets executed when the window is done loading.
/// </summary>
public event Action<IGenericWindow> Loaded; public event Action<IGenericWindow> Loaded;
/// <inheritdoc />
protected override void OnLoad(EventArgs e) protected override void OnLoad(EventArgs e)
{ {
WindowCode.Load(this); WindowCode.Load(this);
@ -78,14 +126,13 @@ namespace SM.Base.Window
base.OnLoad(e); base.OnLoad(e);
} }
/// <inheritdoc />
protected override void OnResize(EventArgs e) protected override void OnResize(EventArgs e)
{ {
base.OnResize(e); base.OnResize(e);
WindowCode.Resize(this); WindowCode.Resize(this);
if (WindowFlags == WindowFlags.Window) _flagWindowSize = WindowSize;
if (Loading) if (Loading)
{ {
Loading = false; Loading = false;
@ -94,6 +141,7 @@ namespace SM.Base.Window
} }
} }
/// <inheritdoc />
protected override void OnUpdateFrame(FrameEventArgs e) protected override void OnUpdateFrame(FrameEventArgs e)
{ {
if (!Focused && !UpdateWhileUnfocused) return; if (!Focused && !UpdateWhileUnfocused) return;
@ -104,6 +152,7 @@ namespace SM.Base.Window
} }
/// <inheritdoc />
protected override void OnRenderFrame(FrameEventArgs e) protected override void OnRenderFrame(FrameEventArgs e)
{ {
base.OnRenderFrame(e); base.OnRenderFrame(e);
@ -115,23 +164,40 @@ namespace SM.Base.Window
GLDebugging.CheckGLErrors(); GLDebugging.CheckGLErrors();
} }
/// <inheritdoc />
protected override void OnMouseMove(MouseMoveEventArgs e) protected override void OnMouseMove(MouseMoveEventArgs e)
{ {
base.OnMouseMove(e); base.OnMouseMove(e);
Mouse.MouseMoveEvent(e, this); Mouse.MouseMoveEvent(e, this);
} }
/// <inheritdoc />
public void TriggerLoad()
{
Load?.Invoke(this);
}
/// <inheritdoc />
public void TriggerResize()
{
Resize?.Invoke(this);
}
/// <inheritdoc />
public void Update(UpdateContext context) public void Update(UpdateContext context)
{ {
} }
/// <inheritdoc />
public void ApplySetup(ISetup setup) public void ApplySetup(ISetup setup)
{ {
AppliedSetup = setup; AppliedSetup = setup;
setup.Applied(this); setup.Applied(this);
} }
/// <inheritdoc />
public void SetScene(GenericScene scene) public void SetScene(GenericScene scene)
{ {
if (Loading) if (Loading)
@ -144,6 +210,7 @@ namespace SM.Base.Window
CurrentScene = scene; CurrentScene = scene;
} }
/// <inheritdoc />
public void SetRenderPipeline(RenderPipeline renderPipeline) public void SetRenderPipeline(RenderPipeline renderPipeline)
{ {
if (Loading) if (Loading)
@ -156,34 +223,23 @@ namespace SM.Base.Window
CurrentRenderPipeline = renderPipeline; CurrentRenderPipeline = renderPipeline;
} }
public void ChangeWindowFlag(WindowFlags newFlag) /// <summary>
/// Changes the resolution in fullscreen mode.
/// <para>Can be executed before changing to fullscreen, but with no effect until changed.</para>
/// </summary>
/// <param name="resolution">The resolution you get from <see cref="DisplayDevice.AvailableResolutions"/> or <see cref="DisplayDevice.SelectResolution"/></param>
public void ChangeFullscreenResolution(DisplayResolution resolution)
{ {
WindowFlags = newFlag; _fullscreenResolution = resolution;
switch (newFlag) if (_windowFlags == WindowFlags.ExclusiveFullscreen) ApplyFullscreenResolution();
{
case WindowFlags.Window:
Width = (int) _flagWindowSize.X;
Height = (int) _flagWindowSize.Y;
WindowBorder = WindowBorder.Resizable;
break;
case WindowFlags.BorderlessWindow:
WindowBorder = WindowBorder.Hidden;
X = Screen.PrimaryScreen.Bounds.Left;
Y = Screen.PrimaryScreen.Bounds.Top;
Width = Screen.PrimaryScreen.Bounds.Width;
Height = Screen.PrimaryScreen.Bounds.Height;
break;
case WindowFlags.ExclusiveFullscreen:
break;
default:
throw new ArgumentOutOfRangeException(nameof(newFlag), newFlag, null);
}
} }
/// <summary>
/// Starts the fixed update loop.
/// <para>Need to get executed before <see cref="IFixedScriptable"/> can be used.</para>
/// </summary>
/// <param name="updatesPerSecond"></param>
public void RunFixedUpdate(float updatesPerSecond) public void RunFixedUpdate(float updatesPerSecond)
{ {
Deltatime.FixedUpdateDelta = 1 / (float)updatesPerSecond; Deltatime.FixedUpdateDelta = 1 / (float)updatesPerSecond;
@ -208,5 +264,76 @@ namespace SM.Base.Window
Thread.Sleep(waitTime); Thread.Sleep(waitTime);
} }
} }
private void GLWindow_FocusedChanged(object sender, EventArgs e)
{
if (_windowFlags == WindowFlags.ExclusiveFullscreen)
{
if (!Focused)
{
DisplayDevice.Default.ChangeResolution(_normalResolution);
WindowState = WindowState.Minimized;
}
else
{
ApplyFullscreenResolution();
}
}
}
private void ChangeWindowFlag(WindowFlags newFlag, WindowFlags oldFlag)
{
if (oldFlag == WindowFlags.Window)
{
_flagWindowSize = WindowSize;
_flagWindowPos = new Vector2(X, Y);
}
switch (newFlag)
{
case WindowFlags.Window:
DisplayDevice.Default.ChangeResolution(_normalResolution);
WindowState = WindowState.Normal;
Width = (int)_flagWindowSize.X;
Height = (int)_flagWindowSize.Y;
X = (int) _flagWindowPos.X;
Y = (int) _flagWindowPos.Y;
WindowBorder = WindowBorder.Resizable;
break;
case WindowFlags.BorderlessWindow:
DisplayDevice.Default.ChangeResolution(_normalResolution);
WindowState = WindowState.Maximized;
WindowBorder = WindowBorder.Hidden;
X = Screen.PrimaryScreen.Bounds.Left;
Y = Screen.PrimaryScreen.Bounds.Top;
Width = Screen.PrimaryScreen.Bounds.Width;
Height = Screen.PrimaryScreen.Bounds.Height;
break;
case WindowFlags.ExclusiveFullscreen:
WindowState = WindowState.Fullscreen;
ApplyFullscreenResolution();
break;
default:
throw new ArgumentOutOfRangeException(nameof(newFlag), newFlag, null);
}
}
private void ApplyFullscreenResolution()
{
DisplayDevice.Default.ChangeResolution(_fullscreenResolution);
Width = _fullscreenResolution.Width;
Height = _fullscreenResolution.Height;
}
} }
} }

67
SMCode/SM.Base/Window/IGenericWindow.cs
View file

@ -10,39 +10,106 @@ using SM.OGL.Framebuffer;
namespace SM.Base.Window namespace SM.Base.Window
{ {
/// <summary>
/// This interface sets ground functions for windows.
/// </summary>
public interface IGenericWindow : IFramebufferWindow public interface IGenericWindow : IFramebufferWindow
{ {
/// <summary>
/// If true, the window is currently loading.
/// </summary>
bool Loading { get; } bool Loading { get; }
/// <summary>
/// Holds the aspect ratio of the window.
/// </summary>
float AspectRatio { get; set; } float AspectRatio { get; set; }
/// <summary>
/// The viewport camera is used, when no camera is found in the scene.
/// </summary>
GenericCamera ViewportCamera { get; set; } GenericCamera ViewportCamera { get; set; }
/// <summary>
/// Turning this to true, will force the window to render in the viewport camera.
/// </summary>
bool ForceViewportCamera { get; set; } bool ForceViewportCamera { get; set; }
/// <summary>
/// Turning this to false will not allow drawing while the window is not in focus.
/// </summary>
bool DrawWhileUnfocused { get; set; } bool DrawWhileUnfocused { get; set; }
/// <summary>
/// Turning this to false will not allow updating while the window is not in focus.
/// </summary>
bool UpdateWhileUnfocused { get; set; } bool UpdateWhileUnfocused { get; set; }
/// <summary>
/// Contains the window size.
/// </summary>
Vector2 WindowSize { get; set; } Vector2 WindowSize { get; set; }
/// <summary>
/// The rectangle the window is using.
/// </summary>
Rectangle ClientRectangle { get; } Rectangle ClientRectangle { get; }
/// <summary>
/// The setup that was applied to the window.
/// </summary>
ISetup AppliedSetup { get; } ISetup AppliedSetup { get; }
/// <summary>
/// The scene that is currently used.
/// </summary>
GenericScene CurrentScene { get; } GenericScene CurrentScene { get; }
/// <summary>
/// The render pipeline that is currently used.
/// </summary>
RenderPipeline CurrentRenderPipeline { get; } RenderPipeline CurrentRenderPipeline { get; }
/// <summary>
/// An event, when the window resizes.
/// </summary>
event Action<IGenericWindow> Resize; event Action<IGenericWindow> Resize;
/// <summary>
/// An event, when the window is loading.
/// </summary>
event Action<IGenericWindow> Load; event Action<IGenericWindow> Load;
/// <summary>
/// This gets executed, when the window should update something.
/// </summary>
/// <param name="context">The context of the update.</param>
void Update(UpdateContext context); void Update(UpdateContext context);
/// <summary>
/// This applies a setup to the window.
/// </summary>
/// <param name="setup"></param>
void ApplySetup(ISetup setup); void ApplySetup(ISetup setup);
/// <summary>
/// This sets a scene for the window to use.
/// </summary>
/// <param name="scene"></param>
void SetScene(GenericScene scene); void SetScene(GenericScene scene);
/// <summary>
/// This sets a render pipeline, from where the scene gets rendered.
/// </summary>
/// <param name="renderPipeline"></param>
void SetRenderPipeline(RenderPipeline renderPipeline); void SetRenderPipeline(RenderPipeline renderPipeline);
/// <summary>
/// This triggeres the <see cref="Load"/> event.
/// </summary>
void TriggerLoad(); void TriggerLoad();
/// <summary>
/// This triggeres the <see cref="Resize"/> event.
/// </summary>
void TriggerResize(); void TriggerResize();
/// <summary>
/// This closes the window.
/// </summary>
void Close(); void Close();
} }
} }

5
SMCode/SM.Base/Window/RenderPipeline.cs
View file

@ -53,9 +53,10 @@ namespace SM.Base.Window
/// <inheritdoc/> /// <inheritdoc/>
public virtual void Initialization() public virtual void Initialization()
{ {
if (MainFramebuffer != null) {
Framebuffers.Add(MainFramebuffer);
MainFramebuffer.Name = GetType().Name + ".MainFramebuffer"; MainFramebuffer.Name = GetType().Name + ".MainFramebuffer";
}
if (MainFramebuffer != null) Framebuffers.Add(MainFramebuffer);
DefaultShader ??= SMRenderer.DefaultMaterialShader; DefaultShader ??= SMRenderer.DefaultMaterialShader;
} }

1
SMCode/SM.Base/Window/WindowCode.cs
View file

@ -93,6 +93,7 @@ namespace SM.Base.Window
internal static void Render(IGenericWindow window, float deltatime) internal static void Render(IGenericWindow window, float deltatime)
{ {
if (window.CurrentScene == null) return; if (window.CurrentScene == null) return;
if (window.CurrentRenderPipeline == null) window.SetRenderPipeline(SMRenderer.DefaultRenderPipeline);
SMRenderer.CurrentFrame++; SMRenderer.CurrentFrame++;

4
SMCode/SM.Base/packages.config
View file

@ -1,8 +1,4 @@
<?xml version="1.0" encoding="utf-8"?> <?xml version="1.0" encoding="utf-8"?>
<packages> <packages>
<package id="OpenTK" version="3.3.1" targetFramework="net452" /> <package id="OpenTK" version="3.3.1" targetFramework="net452" />
<package id="OpenTK.GLWpfControl" version="3.2.3" targetFramework="net452" />
<package id="SharpDX" version="4.2.0" targetFramework="net452" />
<package id="SharpDX.XInput" version="4.2.0" targetFramework="net452" />
</packages> </packages>

8
SMCode/SM.OGL/Framebuffer/ColorAttachment.cs
View file

@ -14,7 +14,7 @@ namespace SM.OGL.Framebuffer
/// </summary> /// </summary>
public class ColorAttachment : TextureBase public class ColorAttachment : TextureBase
{ {
private int _multisamples; private readonly int _multisamples;
/// <summary> /// <summary>
/// The ID the attachment was given. /// The ID the attachment was given.
@ -50,6 +50,12 @@ namespace SM.OGL.Framebuffer
public ColorAttachment(int attachmentId) : this(attachmentId, PixelInformation.RGBA_LDR) public ColorAttachment(int attachmentId) : this(attachmentId, PixelInformation.RGBA_LDR)
{ } { }
/// <summary>
/// Creates a color attachment with a specific id, specific pixel informations and multisamples.
/// </summary>
/// <param name="attachmentID"></param>
/// <param name="pixelInformation"></param>
/// <param name="multisamples"></param>
public ColorAttachment(int attachmentID, PixelInformation pixelInformation, int multisamples = 0) public ColorAttachment(int attachmentID, PixelInformation pixelInformation, int multisamples = 0)
{ {
AttachmentID = attachmentID; AttachmentID = attachmentID;

18
SMCode/SM.OGL/Framebuffer/Framebuffer.cs
View file

@ -15,6 +15,7 @@ namespace SM.OGL.Framebuffer
/// </summary> /// </summary>
public class Framebuffer : GLObject public class Framebuffer : GLObject
{ {
/// <inheritdoc />
protected override bool AutoCompile { get; set; } = true; protected override bool AutoCompile { get; set; } = true;
public static IFramebufferWindow ScreenWindow; public static IFramebufferWindow ScreenWindow;
@ -30,8 +31,8 @@ namespace SM.OGL.Framebuffer
_windowScale = 1, _windowScale = 1,
}; };
private IFramebufferWindow _window; private readonly IFramebufferWindow _window;
private float _windowScale; private readonly float _windowScale;
/// <inheritdoc /> /// <inheritdoc />
public override ObjectLabelIdentifier TypeIdentifier { get; } = ObjectLabelIdentifier.Framebuffer; public override ObjectLabelIdentifier TypeIdentifier { get; } = ObjectLabelIdentifier.Framebuffer;
@ -46,7 +47,9 @@ namespace SM.OGL.Framebuffer
/// </summary> /// </summary>
public Dictionary<string, ColorAttachment> ColorAttachments { get; private set; } = public Dictionary<string, ColorAttachment> ColorAttachments { get; private set; } =
new Dictionary<string, ColorAttachment>(); new Dictionary<string, ColorAttachment>();
/// <summary>
/// Contains the current renderbuffer attachments of the framebuffer.
/// </summary>
public Dictionary<RenderbufferAttachment, int> RenderbufferAttachments { get; } = new Dictionary<RenderbufferAttachment, int>(); public Dictionary<RenderbufferAttachment, int> RenderbufferAttachments { get; } = new Dictionary<RenderbufferAttachment, int>();
/// <summary> /// <summary>
@ -143,6 +146,10 @@ namespace SM.OGL.Framebuffer
ColorAttachments.Add(key, value); ColorAttachments.Add(key, value);
} }
/// <summary>
/// Appends a renderbuffer attachment to the framebuffer.
/// </summary>
/// <param name="attachment"></param>
public void AppendRenderbuffer(RenderbufferAttachment attachment) public void AppendRenderbuffer(RenderbufferAttachment attachment)
{ {
RenderbufferAttachments.Add(attachment, -1); RenderbufferAttachments.Add(attachment, -1);
@ -185,6 +192,11 @@ namespace SM.OGL.Framebuffer
GL.Clear(clear); GL.Clear(clear);
} }
/// <summary>
/// Returns a <see cref="Framebuffer"/> handle of the current framebuffer.
/// </summary>
/// <param name="target"></param>
/// <returns></returns>
public static Framebuffer GetCurrentlyActive(FramebufferTarget target = FramebufferTarget.Framebuffer) public static Framebuffer GetCurrentlyActive(FramebufferTarget target = FramebufferTarget.Framebuffer)
{ {
Framebuffer buffer = new Framebuffer() Framebuffer buffer = new Framebuffer()

6
SMCode/SM.OGL/Framebuffer/IFramebufferWindow.cs
View file

@ -5,7 +5,13 @@
/// </summary> /// </summary>
public interface IFramebufferWindow public interface IFramebufferWindow
{ {
/// <summary>
/// The width of the window.
/// </summary>
int Width { get; } int Width { get; }
/// <summary>
/// The height of the window.
/// </summary>
int Height { get; } int Height { get; }
} }
} }

25
SMCode/SM.OGL/GLObject.cs
View file

@ -14,20 +14,30 @@ namespace SM.OGL
/// </summary> /// </summary>
public abstract class GLObject public abstract class GLObject
{ {
private static List<GLObject> _disposableObjects = new List<GLObject>(); private static readonly List<GLObject> _disposableObjects = new List<GLObject>();
private string _name = ""; private string _name = "";
protected bool ReportAsNotCompiled;
/// <summary> /// <summary>
/// Contains the OpenGL ID /// Contains the OpenGL ID
/// </summary> /// </summary>
protected int _id = -1; protected int _id = -1;
/// <summary>
/// This can mark the object to never report as compiled, even when it was.
/// <para>You can still figure out, if it was compiled by checking <see cref="_id"/>. If not -1, its compiled.</para>
/// <para>Default: false</para>
/// </summary>
protected bool ReportAsNotCompiled;
/// <summary>
/// This can prevent the object to compile.
/// <para>Default: true</para>
/// </summary>
protected bool CanCompile = true; protected bool CanCompile = true;
/// <summary> /// <summary>
/// If true, the system will call "Compile()", when "ID" is tried to get, but the id is still -1. /// If true, the system will call "Compile()", when "ID" is tried to get, but the id is still -1.
/// <para>Default: false</para>
/// </summary> /// </summary>
protected virtual bool AutoCompile { get; set; } = false; protected virtual bool AutoCompile { get; set; } = false;
@ -36,6 +46,10 @@ namespace SM.OGL
/// </summary> /// </summary>
public bool WasCompiled => _id > 0 && !ReportAsNotCompiled; public bool WasCompiled => _id > 0 && !ReportAsNotCompiled;
/// <summary>
/// Names the object
/// <para>If <see cref="GLSystem.Debugging"/> is true, then it will also name the object in the system.</para>
/// </summary>
public string Name public string Name
{ {
get => _name; get => _name;
@ -111,11 +125,15 @@ namespace SM.OGL
Compile(); Compile();
} }
/// <inheritdoc />
public override string ToString() public override string ToString()
{ {
return $"{GetType().Name} {(string.IsNullOrEmpty(_name) ? "" : $"\"{_name}\" ")}[{_id}]"; return $"{GetType().Name} {(string.IsNullOrEmpty(_name) ? "" : $"\"{_name}\" ")}[{_id}]";
} }
/// <summary>
/// This disposes the current objects, that where marked by the garbage collector.
/// </summary>
public static void DisposeMarkedObjects() public static void DisposeMarkedObjects()
{ {
foreach (GLObject o in _disposableObjects) foreach (GLObject o in _disposableObjects)
@ -134,6 +152,9 @@ namespace SM.OGL
return glo.ID; return glo.ID;
} }
/// <summary>
/// If the garbage collector is trying to remove this object, it will add the object to a list, what get removed when <see cref="DisposeMarkedObjects"/> is called.
/// </summary>
~GLObject() ~GLObject()
{ {
if (WasCompiled) _disposableObjects.Add(this); if (WasCompiled) _disposableObjects.Add(this);

42
SMCode/SM.OGL/Mesh/BoundingBox.cs
View file

@ -49,21 +49,59 @@ namespace SM.OGL.Mesh
/// <returns></returns> /// <returns></returns>
public Vector3 this[bool x, bool y, bool z] => Get(x,y,z); public Vector3 this[bool x, bool y, bool z] => Get(x,y,z);
/// <summary>
/// Equivalent to <see cref="this"/>.
/// <para>Returns specific configurations of corners</para>
/// </summary>
/// <param name="x">If true, it takes the X-value of maximum, otherwise the minimum.</param>
/// <param name="y">If true, it takes the Y-value of maximum, otherwise the minimum.</param>
/// <param name="z">If true, it takes the Z-value of maximum, otherwise the minimum.</param>
/// <returns></returns>
public Vector3 Get(bool x, bool y, bool z) public Vector3 Get(bool x, bool y, bool z)
{ {
return new Vector3(x ? Max.X : Min.X, y ? Max.Y : Min.Y, z ? Max.Z : Min.Z); return new Vector3(x ? Max.X : Min.X, y ? Max.Y : Min.Y, z ? Max.Z : Min.Z);
} }
/// <summary>
/// Returns the configuration of the two furthest away corners.
/// </summary>
/// <param name="xyz">If true, it will take the maximum, otherwise the minimum.</param>
/// <returns></returns>
public Vector3 Get(bool xyz) => Get(xyz, xyz, xyz); public Vector3 Get(bool xyz) => Get(xyz, xyz, xyz);
/// <summary>
/// Returns the configuration of one corner and applies a transformation to it.
/// <para>If the transformation causes the points to shift to no being in the right location is NOT checked!</para>
/// <para>For that use <see cref="GetBounds"/></para>
/// </summary>
/// <param name="transformation">The transformation</param>
/// <param name="x">If true, it takes the X-value of maximum, otherwise the minimum.</param>
/// <param name="y">If true, it takes the Y-value of maximum, otherwise the minimum.</param>
/// <param name="z">If true, it takes the Z-value of maximum, otherwise the minimum.</param>
/// <returns></returns>
public Vector3 Get(Matrix4 transformation, bool x, bool y, bool z) public Vector3 Get(Matrix4 transformation, bool x, bool y, bool z)
{ {
Vector3 get = Get(x, y, z); Vector3 get = Get(x, y, z);
return (new Vector4(get, 1) * transformation).Xyz; return (new Vector4(get, 1) * transformation).Xyz;
} }
/// <summary>
/// Returns the configuration of the two furthest away corners.
/// <para>If the transformation causes the points to shift to no being in the right location is NOT checked!</para>
/// <para>For that use <see cref="GetBounds"/></para>
/// </summary>
/// <param name="transformation">The transformation</param>
/// <param name="xyz">If true, it will take the maximum, otherwise the minimum.</param>
/// <returns></returns>
public Vector3 Get(Matrix4 transformation, bool xyz) => Get(transformation, xyz, xyz, xyz); public Vector3 Get(Matrix4 transformation, bool xyz) => Get(transformation, xyz, xyz, xyz);
/// <summary>
/// Returns the bounds of the bounding box while applying a transformation.
/// <para>This takes care of min and max locations.</para>
/// </summary>
/// <param name="transformation"></param>
/// <param name="min"></param>
/// <param name="max"></param>
public void GetBounds(Matrix4 transformation, out Vector3 min, out Vector3 max) public void GetBounds(Matrix4 transformation, out Vector3 min, out Vector3 max)
{ {
min = Get(transformation, false); min = Get(transformation, false);
@ -79,6 +117,10 @@ namespace SM.OGL.Mesh
} }
} }
/// <summary>
/// Updates the bounding box to the mesh provided.
/// </summary>
/// <param name="mesh"></param>
public void Update(GenericMesh mesh) public void Update(GenericMesh mesh)
{ {
int pos = 0; int pos = 0;

9
SMCode/SM.OGL/Mesh/GenericMesh.cs
View file

@ -14,8 +14,6 @@ namespace SM.OGL.Mesh
{ {
private bool _boundingBoxUpdated = false; private bool _boundingBoxUpdated = false;
public static int LastID { get; internal set; } = -1;
/// <inheritdoc /> /// <inheritdoc />
protected override bool AutoCompile { get; set; } = true; protected override bool AutoCompile { get; set; } = true;
@ -71,12 +69,18 @@ namespace SM.OGL.Mesh
}; };
} }
/// <summary>
/// Updates the object bounding box.
/// </summary>
public void UpdateBoundingBox() public void UpdateBoundingBox()
{ {
BoundingBox.Update(this); BoundingBox.Update(this);
_boundingBoxUpdated = true; _boundingBoxUpdated = true;
} }
/// <summary>
/// Activates the object to be rendered.
/// </summary>
public void Activate() public void Activate()
{ {
GL.BindVertexArray(ID); GL.BindVertexArray(ID);
@ -99,6 +103,7 @@ namespace SM.OGL.Mesh
GL.BindVertexArray(0); GL.BindVertexArray(0);
} }
/// <inheritdoc />
public override void Dispose() public override void Dispose()
{ {
GL.DeleteVertexArray(_id); GL.DeleteVertexArray(_id);

6
SMCode/SM.OGL/Mesh/MeshAttribute.cs
View file

@ -18,6 +18,12 @@
/// </summary> /// </summary>
public VBO ConnectedVBO; public VBO ConnectedVBO;
/// <summary>
/// Creates a attribute for a mesh.
/// </summary>
/// <param name="index"></param>
/// <param name="name"></param>
/// <param name="buffer"></param>
public MeshAttribute(int index, string name, VBO buffer) public MeshAttribute(int index, string name, VBO buffer)
{ {
Index = index; Index = index;

5
SMCode/SM.OGL/Mesh/MeshAttributeList.cs
View file

@ -49,6 +49,11 @@ namespace SM.OGL.Mesh
Add(new MeshAttribute(id, name, vbo)); Add(new MeshAttribute(id, name, vbo));
} }
/// <summary>
/// Checks if the attribute list has the attribute name.
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public bool Has(string name) public bool Has(string name)
{ {
VBO attribute = this[name]; VBO attribute = this[name];

8
SMCode/SM.OGL/Mesh/VBO.cs
View file

@ -139,6 +139,10 @@ namespace SM.OGL.Mesh
Add(vector.X, vector.Y, z, w); Add(vector.X, vector.Y, z, w);
} }
/// <summary>
/// Adds a array of vector2s.
/// </summary>
/// <param name="vectors"></param>
public void Add(params Vector2[] vectors) public void Add(params Vector2[] vectors)
{ {
foreach (Vector2 vector in vectors) foreach (Vector2 vector in vectors)
@ -163,6 +167,10 @@ namespace SM.OGL.Mesh
Add(vector.X, vector.Y, vector.Z, w); Add(vector.X, vector.Y, vector.Z, w);
} }
/// <summary>
/// Adds a array of Vector3s.
/// </summary>
/// <param name="vectors"></param>
public void Add(params Vector3[] vectors) public void Add(params Vector3[] vectors)
{ {
foreach (Vector3 vector in vectors) foreach (Vector3 vector in vectors)

20
SMCode/SM.OGL/Shaders/GenericShader.cs
View file

@ -70,6 +70,11 @@ namespace SM.OGL.Shaders
ShaderFileFiles = new ShaderFileCollection(vertex,fragment, geometry); ShaderFileFiles = new ShaderFileCollection(vertex,fragment, geometry);
} }
/// <summary>
/// Creates a shader out of a vertex and an fragment shader.
/// </summary>
/// <param name="vertex"></param>
/// <param name="fragment"></param>
protected GenericShader(string vertex, string fragment) : this(new ShaderFileCollection(vertex, fragment)){} protected GenericShader(string vertex, string fragment) : this(new ShaderFileCollection(vertex, fragment)){}
/// <inheritdoc /> /// <inheritdoc />
@ -81,6 +86,10 @@ namespace SM.OGL.Shaders
/// <inheritdoc /> /// <inheritdoc />
public override ObjectLabelIdentifier TypeIdentifier { get; } = ObjectLabelIdentifier.Program; public override ObjectLabelIdentifier TypeIdentifier { get; } = ObjectLabelIdentifier.Program;
/// <summary>
/// Updates the shader files and recompiles the shader.
/// </summary>
/// <param name="newShaderFiles"></param>
public void Update(ShaderFileCollection newShaderFiles) public void Update(ShaderFileCollection newShaderFiles)
{ {
ShaderFileFiles = newShaderFiles; ShaderFileFiles = newShaderFiles;
@ -104,6 +113,9 @@ namespace SM.OGL.Shaders
GLDebugging.CheckGLErrors($"A error occured at shader creation for '{GetType()}': %code%"); GLDebugging.CheckGLErrors($"A error occured at shader creation for '{GetType()}': %code%");
} }
/// <summary>
/// Activates the shader
/// </summary>
public void Activate() public void Activate()
{ {
GL.UseProgram(ID); GL.UseProgram(ID);
@ -115,6 +127,7 @@ namespace SM.OGL.Shaders
Load(); Load();
} }
/// <inheritdoc />
public override void Dispose() public override void Dispose()
{ {
GL.DeleteProgram(this); GL.DeleteProgram(this);
@ -136,14 +149,15 @@ namespace SM.OGL.Shaders
/// <summary> /// <summary>
/// Draws the mesh while forcing a primitive type instead of using the mesh type. /// Draws the mesh while forcing a primitive type instead of using the mesh type.
/// </summary> /// </summary>
/// <param name="modelType">The type, as what the object should be rendered.</param>
/// <param name="mesh">The mesh.</param> /// <param name="mesh">The mesh.</param>
/// <param name="amount">The amounts for instancing.</param> /// <param name="amount">The amounts for instancing.</param>
public static void DrawObject(PrimitiveType forcedType, GenericMesh mesh, int amount = 1) public static void DrawObject(PrimitiveType modelType, GenericMesh mesh, int amount = 1)
{ {
if (mesh.Indices != null) if (mesh.Indices != null)
GL.DrawElementsInstanced(forcedType, 0, DrawElementsType.UnsignedInt, mesh.Indices, amount); GL.DrawElementsInstanced(modelType, 0, DrawElementsType.UnsignedInt, mesh.Indices, amount);
else else
GL.DrawArraysInstanced(forcedType, 0, mesh.Vertex.Count / mesh.Vertex.PointerSize, amount); GL.DrawArraysInstanced(modelType, 0, mesh.Vertex.Count / mesh.Vertex.PointerSize, amount);
} }
/// <summary> /// <summary>

31
SMCode/SM.OGL/Shaders/UniformArray.cs
View file

@ -2,28 +2,51 @@
namespace SM.OGL.Shaders namespace SM.OGL.Shaders
{ {
/// <summary>
/// This class controls uniform array structures.
/// </summary>
public class UniformArray : IUniform public class UniformArray : IUniform
{ {
private Dictionary<int, Dictionary<string, Uniform>> storedUniforms = new Dictionary<int, Dictionary<string, Uniform>>(); private readonly Dictionary<int, Dictionary<string, Uniform>> storedUniforms = new Dictionary<int, Dictionary<string, Uniform>>();
internal List<string> uniformNames = new List<string>(); internal List<string> UniformNames = new List<string>();
/// <inheritdoc />
public int Location { get; internal set; } public int Location { get; internal set; }
/// <summary>
/// The name of the uniform.
/// </summary>
public string Name { get; internal set; } public string Name { get; internal set; }
/// <summary>
/// The uniform collection the uniform is from.
/// </summary>
public UniformCollection Parent { get; internal set; } public UniformCollection Parent { get; internal set; }
/// <summary>
/// The shader the uniform is from.
/// </summary>
public GenericShader ParentShader { get; internal set; } public GenericShader ParentShader { get; internal set; }
/// <summary>
/// The length of the array.
/// </summary>
public int Length => storedUniforms.Count; public int Length => storedUniforms.Count;
/// <summary>
/// Returns a dictionary to control the current index inside the array.
/// </summary>
public Dictionary<string, Uniform> this[int index] => Get(index); public Dictionary<string, Uniform> this[int index] => Get(index);
/// <summary>
/// Equivalent to <see cref="this"/>
/// <para>Returns a dictionary to control the current index inside the array.</para>
/// </summary>
public Dictionary<string, Uniform> Get(int index) public Dictionary<string, Uniform> Get(int index)
{ {
if (!storedUniforms.ContainsKey(index)) if (!storedUniforms.ContainsKey(index))
{ {
Dictionary<string, Uniform> dic = storedUniforms[index] = new Dictionary<string, Uniform>(); Dictionary<string, Uniform> dic = storedUniforms[index] = new Dictionary<string, Uniform>();
for (int i = 0; i < uniformNames.Count; i++) for (int i = 0; i < UniformNames.Count; i++)
{ {
dic.Add(uniformNames[i], new Uniform(Name + $"[{index}]." + uniformNames[i], ParentShader, Parent)); dic.Add(UniformNames[i], new Uniform(Name + $"[{index}]." + UniformNames[i], ParentShader, Parent));
} }
} }

42
SMCode/SM.OGL/Shaders/UniformCollection.cs
View file

@ -8,14 +8,34 @@ using OpenTK.Graphics.OpenGL4;
namespace SM.OGL.Shaders namespace SM.OGL.Shaders
{ {
/// <summary>
/// Collects and provied the uniforms of a shader.
/// </summary>
public class UniformCollection : Dictionary<string, IUniform> public class UniformCollection : Dictionary<string, IUniform>
{ {
public int NextTexture = 0;
internal string KeyString = ""; internal string KeyString = "";
/// <summary>
/// The next uniform-position for textures.
/// </summary>
public int NextTexture = 0;
/// <summary>
/// The shader this collections is connected to.
/// </summary>
public GenericShader ParentShader { get; internal set; } public GenericShader ParentShader { get; internal set; }
/// <summary>
///
/// </summary>
/// <param name="key"></param>
public new Uniform this[string key] => Get(key); public new Uniform this[string key] => Get(key);
/// <summary>
/// Equivalent to <see cref="this"/>
/// <para>Gets the uniform with the provied key.</para>
/// <para>If it can't find it, it will create a warning and a uniform with the location of -1.</para>
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public Uniform Get(string key) public Uniform Get(string key)
{ {
try try
@ -31,18 +51,22 @@ namespace SM.OGL.Shaders
} }
} }
/// <summary>
/// Gets a array.
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
/// <exception cref="KeyNotFoundException">If the key wasn't found, it will throw a exception</exception>
public UniformArray GetArray(string key) public UniformArray GetArray(string key)
{ {
try if (ContainsKey(key))
{
return (UniformArray) base[key]; return (UniformArray) base[key];
} else throw new KeyNotFoundException("UniformArray '"+key+"' wasn't found");
catch (KeyNotFoundException)
{
throw new Exception("UniformArray '"+key+"' wasn't found");
}
} }
/// <summary>
/// Adds a uniform to the collection.
/// </summary>
public void Add(string key, int location) public void Add(string key, int location)
{ {
base.Add(key, new Uniform(location, this)); base.Add(key, new Uniform(location, this));
@ -101,7 +125,7 @@ namespace SM.OGL.Shaders
} }
if (keySplits[1] == "0") if (keySplits[1] == "0")
array.uniformNames.Add(keySplits[2].Substring(1)); array.UniformNames.Add(keySplits[2].Substring(1));
} }
else else
{ {

48
SMCode/SM2D/Controls/Mouse2D.cs
View file

@ -8,8 +8,14 @@ using SM2D.Types;
namespace SM2D.Controls namespace SM2D.Controls
{ {
/// <summary>
/// Contains special methods for the mouse.
/// </summary>
public class Mouse2D public class Mouse2D
{ {
/// <summary>
/// Returns the current position of the mouse inside the world.
/// </summary>
public static Vector2 InWorld(Vector2 worldScale) public static Vector2 InWorld(Vector2 worldScale)
{ {
var res = worldScale; var res = worldScale;
@ -17,28 +23,63 @@ namespace SM2D.Controls
return Mouse.InScreenNormalized * res - res / 2; return Mouse.InScreenNormalized * res - res / 2;
} }
/// <summary>
/// Returns the current position of the mouse inside the world.
/// </summary>
public static Vector2 InWorld(Camera cam) public static Vector2 InWorld(Camera cam)
{ {
return InWorld(cam.WorldScale) + cam.Position; return InWorld(cam.WorldScale) + cam.Position;
} }
/// <summary>
/// Returns the current position of the mouse inside the world.
/// </summary>
public static Vector2 InWorld(Vector2 worldScale, Vector2 position) public static Vector2 InWorld(Vector2 worldScale, Vector2 position)
{ {
return InWorld(worldScale) + position; return InWorld(worldScale) + position;
} }
/// <summary>
/// Checks if the mouse is over an object.
/// </summary>
/// <param name="mousePos">The position in the world. See <see cref="InWorld(Camera)"/></param>
/// <param name="checkingObjects"></param>
/// <typeparam name="TObject"></typeparam>
public static bool MouseOver<TObject>(Vector2 mousePos, params TObject[] checkingObjects) public static bool MouseOver<TObject>(Vector2 mousePos, params TObject[] checkingObjects)
where TObject : IModelItem, ITransformItem<Transformation> where TObject : IModelItem, ITransformItem<Transformation>
=> MouseOver(mousePos, out _, checkingObjects); => MouseOver(mousePos, out _, checkingObjects);
/// <summary>
/// Checks if the mouse is over an object.
/// </summary>
/// <param name="mousePos">The position in the world. See <see cref="InWorld(Camera)"/></param>
/// <param name="checkingObjects"></param>
/// <typeparam name="TObject"></typeparam>
/// <returns></returns>
public static bool MouseOver<TObject>(Vector2 mousePos, ICollection<TObject> checkingObjects) public static bool MouseOver<TObject>(Vector2 mousePos, ICollection<TObject> checkingObjects)
where TObject : IModelItem, ITransformItem<Transformation> where TObject : IModelItem, ITransformItem<Transformation>
=> MouseOver<TObject>(mousePos, out _, checkingObjects); => MouseOver<TObject>(mousePos, out _, checkingObjects);
/// <summary>
/// Checks if the mouse is over an object and returns the object that was clicked on.
/// </summary>
/// <param name="mousePos">The position in the world. See <see cref="InWorld(Camera)"/></param>
/// <param name="clicked"></param>
/// <param name="checkingObjects"></param>
/// <typeparam name="TObject"></typeparam>
/// <returns></returns>
public static bool MouseOver<TObject>(Vector2 mousePos, out TObject clicked, params TObject[] checkingObjects) public static bool MouseOver<TObject>(Vector2 mousePos, out TObject clicked, params TObject[] checkingObjects)
where TObject : IModelItem, ITransformItem<Transformation> where TObject : IModelItem, ITransformItem<Transformation>
=> MouseOver<TObject>(mousePos, out clicked, (ICollection<TObject>)checkingObjects); => MouseOver<TObject>(mousePos, out clicked, (ICollection<TObject>)checkingObjects);
/// <summary>
/// Checks if the mouse is over an object and returns the object that was clicked on.
/// </summary>
/// <param name="mousePos">The position in the world. See <see cref="InWorld(Camera)"/></param>
/// <param name="clickedObj"></param>
/// <param name="checkingObjects"></param>
/// <typeparam name="TObject"></typeparam>
/// <returns></returns>
public static bool MouseOver<TObject>(Vector2 mousePos, out TObject clickedObj, ICollection<TObject> checkingObjects) public static bool MouseOver<TObject>(Vector2 mousePos, out TObject clickedObj, ICollection<TObject> checkingObjects)
where TObject : IModelItem, ITransformItem<Transformation> where TObject : IModelItem, ITransformItem<Transformation>
{ {
@ -70,6 +111,13 @@ namespace SM2D.Controls
return success; return success;
} }
/// <summary>
/// Checks if the mouse is over an object and returns the object that was clicked on.
/// </summary>
/// <param name="mousePos">The position in the world. See <see cref="InWorld(Camera)"/></param>
/// <param name="boundingBox"></param>
/// <param name="transform"></param>
/// <returns></returns>
public static bool MouseOver(Vector2 mousePos, BoundingBox boundingBox, Transformation transform) public static bool MouseOver(Vector2 mousePos, BoundingBox boundingBox, Transformation transform)
{ {
Matrix4 worldPos = transform.InWorldSpace; Matrix4 worldPos = transform.InWorldSpace;

26
SMCode/SM2D/Drawing/DrawBackground.cs
View file

@ -14,14 +14,23 @@ using SM2D.Scene;
namespace SM2D.Drawing namespace SM2D.Drawing
{ {
/// <summary>
/// Allows easy access to draw something on the background.
/// </summary>
public class DrawBackground : DrawingBasis, IBackgroundItem public class DrawBackground : DrawingBasis, IBackgroundItem
{ {
/// <summary>
/// Sets the color or tint (in case a texture is set).
/// </summary>
public Color4 Color public Color4 Color
{ {
get => Material.Tint; get => Material.Tint;
set => Material.Tint = value; set => Material.Tint = value;
} }
/// <summary>
/// Sets the texture of the background.
/// </summary>
public TextureBase Texture public TextureBase Texture
{ {
get => Material.Texture; get => Material.Texture;
@ -32,18 +41,34 @@ namespace SM2D.Drawing
} }
} }
/// <summary>
/// Creates a black background.
/// </summary>
public DrawBackground() : this(Color4.Black) {} public DrawBackground() : this(Color4.Black) {}
/// <summary>
/// Creates a background with a color.
/// </summary>
/// <param name="color"></param>
public DrawBackground(Color4 color) public DrawBackground(Color4 color)
{ {
Color = color; Color = color;
} }
/// <summary>
/// Creates a background with a texture.
/// </summary>
/// <param name="texture"></param>
public DrawBackground(Bitmap texture) public DrawBackground(Bitmap texture)
{ {
Texture = (Texture) texture; Texture = (Texture) texture;
} }
/// <summary>
/// Creates a background with a texture and a tint.
/// </summary>
/// <param name="texture"></param>
/// <param name="tint"></param>
public DrawBackground(Bitmap texture, Color4 tint) public DrawBackground(Bitmap texture, Color4 tint)
{ {
Color = tint; Color = tint;
@ -51,6 +76,7 @@ namespace SM2D.Drawing
} }
/// <inheritdoc />
protected override void DrawContext(ref DrawContext context) protected override void DrawContext(ref DrawContext context)
{ {
base.DrawContext(ref context); base.DrawContext(ref context);

44
SMCode/SM2D/Drawing/DrawObject2D.cs
View file

@ -10,46 +10,72 @@ using SM2D.Types;
namespace SM2D.Drawing namespace SM2D.Drawing
{ {
/// <inheritdoc />
public class DrawObject2D : DrawingBasis<Transformation> public class DrawObject2D : DrawingBasis<Transformation>
{ {
/// <summary>
/// The texture the object should use.
/// </summary>
public Texture Texture public Texture Texture
{ {
get => (Texture) Material.Texture; get => (Texture) Material.Texture;
set => Material.Texture = value; set => Material.Texture = value;
} }
/// <summary>
/// The color or tint the object should use.
/// </summary>
public Color4 Color public Color4 Color
{ {
get => Material.Tint; get => Material.Tint;
set => Material.Tint = value; set => Material.Tint = value;
} }
/// <inheritdoc />
protected override void DrawContext(ref DrawContext context) protected override void DrawContext(ref DrawContext context)
{ {
base.DrawContext(ref context); base.DrawContext(ref context);
context.Shader.Draw(context); context.Shader.Draw(context);
} }
public void SetShader(MaterialShader shader) => Material.CustomShader = shader; /// <summary>
/// Applies a polygon to the object.
/// </summary>
/// <param name="vertices"></param>
/// <returns></returns>
public Polygon ApplyPolygon(ICollection<Vector2> vertices)
{
Polygon polygon = new Polygon(vertices);
Mesh = polygon;
return polygon;
}
public Polygon ApplyPolygon(ICollection<Vector2> vertices, bool centerUVs = false) /// <summary>
{ /// Applies a polygon to the object.
Polygon polygon = new Polygon(vertices); /// </summary>
Mesh = polygon; /// <param name="vertices"></param>
return polygon; /// <returns></returns>
} public Polygon ApplyPolygon(ICollection<PolygonVertex> vertices)
public Polygon ApplyPolygon(ICollection<PolygonVertex> vertices, bool centerUVs = false)
{ {
Polygon polygon = new Polygon(vertices); Polygon polygon = new Polygon(vertices);
Mesh = polygon; Mesh = polygon;
return polygon; return polygon;
} }
/// <summary>
/// Applies a polygon to the object.
/// </summary>
public void ApplyPolygon(Polygon polygon) public void ApplyPolygon(Polygon polygon)
{ {
Mesh = polygon; Mesh = polygon;
} }
public Polygon ApplyCircle(int segments = 32, bool centerUVs = false) /// <summary>
/// This applies a circle.
/// </summary>
/// <param name="segments"></param>
/// <returns></returns>
public Polygon ApplyCircle(int segments = 32)
{ {
Polygon pol = Polygon.GenerateCircle(segments); Polygon pol = Polygon.GenerateCircle(segments);
Mesh = pol; Mesh = pol;

7
SMCode/SM2D/Drawing/DrawParticles.cs
View file

@ -6,14 +6,20 @@ using SM2D.Types;
namespace SM2D.Drawing namespace SM2D.Drawing
{ {
/// <summary>
/// Creates particles.
/// </summary>
public class DrawParticles : ParticleDrawingBasis<Transformation, Vector2> public class DrawParticles : ParticleDrawingBasis<Transformation, Vector2>
{ {
/// <inheritdoc />
public override Func<Vector2, ParticleContext, Vector2> MovementCalculation { get; set; } = ParticleMovement.Default2D; public override Func<Vector2, ParticleContext, Vector2> MovementCalculation { get; set; } = ParticleMovement.Default2D;
/// <inheritdoc />
public DrawParticles(TimeSpan duration) : base(duration) public DrawParticles(TimeSpan duration) : base(duration)
{ {
} }
/// <inheritdoc />
protected override ParticleStruct<Vector2> CreateObject(int index) protected override ParticleStruct<Vector2> CreateObject(int index)
{ {
return new ParticleStruct<Vector2>() return new ParticleStruct<Vector2>()
@ -24,6 +30,7 @@ namespace SM2D.Drawing
}; };
} }
/// <inheritdoc />
protected override Matrix4 CreateMatrix(ParticleStruct<Vector2> Struct, Vector2 direction) protected override Matrix4 CreateMatrix(ParticleStruct<Vector2> Struct, Vector2 direction)
{ {
return Struct.Matrix * Matrix4.CreateTranslation(direction.X, direction.Y, 0); return Struct.Matrix * Matrix4.CreateTranslation(direction.X, direction.Y, 0);

7
SMCode/SM2D/Drawing/DrawText.cs
View file

@ -9,14 +9,21 @@ using SM2D.Types;
namespace SM2D.Drawing namespace SM2D.Drawing
{ {
/// <summary>
/// Draws a text to the world.
/// </summary>
public class DrawText : TextDrawingBasis<Transformation> public class DrawText : TextDrawingBasis<Transformation>
{ {
/// <summary>
/// Creates a text object.
/// </summary>
public DrawText(Font font, string text) : base(font) public DrawText(Font font, string text) : base(font)
{ {
_text = text; _text = text;
Transform.Size = new CVector2(1); Transform.Size = new CVector2(1);
} }
/// <inheritdoc />
protected override void DrawContext(ref DrawContext context) protected override void DrawContext(ref DrawContext context)
{ {
base.DrawContext(ref context); base.DrawContext(ref context);

26
SMCode/SM2D/Object/PolyLine.cs
View file

@ -5,15 +5,36 @@ using SM.OGL.Mesh;
namespace SM2D.Object namespace SM2D.Object
{ {
/// <summary>
/// Allows different type of lines.
/// </summary>
public enum PolyLineType public enum PolyLineType
{ {
/// <summary>
/// Those lines are not connected to each other.
/// <para>Every two points starts a new line.</para>
/// </summary>
NotConnected = 1, NotConnected = 1,
/// <summary>
/// Those lines are connected with each other, but don't connect the start and the end.
/// </summary>
Connected = 3, Connected = 3,
/// <summary>
/// Those lines are connected and they connect start and end.
/// </summary>
ConnectedLoop = 2 ConnectedLoop = 2
} }
/// <summary>
/// Creates new poly line.
/// </summary>
public class PolyLine : Polygon, ILineMesh public class PolyLine : Polygon, ILineMesh
{ {
/// <summary>
/// Creates a new polyline by using <see cref="Vector2"/>.
/// </summary>
/// <param name="vertices"></param>
/// <param name="lineType"></param>
public PolyLine(ICollection<Vector2> vertices, PolyLineType lineType = PolyLineType.NotConnected) : base(vertices) public PolyLine(ICollection<Vector2> vertices, PolyLineType lineType = PolyLineType.NotConnected) : base(vertices)
{ {
UVs.Active = false; UVs.Active = false;
@ -21,6 +42,11 @@ namespace SM2D.Object
PrimitiveType = (PrimitiveType)lineType; PrimitiveType = (PrimitiveType)lineType;
} }
/// <summary>
/// Creates a new polyline by using <see cref="PolygonVertex"/>.
/// </summary>
/// <param name="vertices"></param>
/// <param name="lineType"></param>
public PolyLine(ICollection<PolygonVertex> vertices, PolyLineType lineType = PolyLineType.NotConnected) : base(vertices) public PolyLine(ICollection<PolygonVertex> vertices, PolyLineType lineType = PolyLineType.NotConnected) : base(vertices)
{ {
UVs.Active = false; UVs.Active = false;

38
SMCode/SM2D/Object/Polygon.cs
View file

@ -11,8 +11,27 @@ using SM.OGL.Mesh;
namespace SM2D.Object namespace SM2D.Object
{ {
/// <summary>
/// Creates a polygon.
/// </summary>
public class Polygon : Mesh public class Polygon : Mesh
{ {
/// <inheritdoc />
public override VBO Vertex { get; protected set; } = new VBO();
/// <inheritdoc />
public override VBO UVs { get; protected set; } = new VBO(pointerSize: 2);
/// <inheritdoc />
public override VBO Color { get; protected set; } = new VBO(pointerSize: 4);
/// <inheritdoc />
public override PrimitiveType PrimitiveType { get; protected set; } = PrimitiveType.TriangleFan;
/// <summary>
/// Creates a polygon with <see cref="Vector2"/>s.
/// </summary>
/// <param name="vertices"></param>
public Polygon(ICollection<Vector2> vertices) : base(PrimitiveType.TriangleFan) public Polygon(ICollection<Vector2> vertices) : base(PrimitiveType.TriangleFan)
{ {
Color.Active = false; Color.Active = false;
@ -27,25 +46,23 @@ namespace SM2D.Object
if (UVs.Active) foreach (var vertex in vertices) AddUV(vertex); if (UVs.Active) foreach (var vertex in vertices) AddUV(vertex);
} }
/// <summary>
/// Creates a polygon with <see cref="PolygonVertex"/>, what allows colors hard coded.
/// </summary>
/// <param name="vertices"></param>
public Polygon(ICollection<PolygonVertex> vertices) : base(PrimitiveType.TriangleFan) public Polygon(ICollection<PolygonVertex> vertices) : base(PrimitiveType.TriangleFan)
{ {
foreach (var polygonVertex in vertices) foreach (var polygonVertex in vertices)
{ {
Color.Add(polygonVertex.Color); Color.Add(polygonVertex.Color);
Vertex.Add(polygonVertex.Vertex, 0); Vertex.Add(polygonVertex.Position, 0);
} }
UpdateBoundingBox(); UpdateBoundingBox();
if (UVs.Active) foreach (var vertex in vertices) AddUV(vertex.Vertex); if (UVs.Active) foreach (var vertex in vertices) AddUV(vertex.Position);
} }
public override VBO Vertex { get; protected set; } = new VBO();
public override VBO UVs { get; protected set; } = new VBO(pointerSize: 2);
public override VBO Color { get; protected set; } = new VBO(pointerSize: 4);
public override PrimitiveType PrimitiveType { get; protected set; } = PrimitiveType.TriangleFan;
private void AddUV(Vector2 vertex) private void AddUV(Vector2 vertex)
{ {
var uv = Vector2.Divide(vertex - BoundingBox.Min.Xy, BoundingBox.Max.Xy - BoundingBox.Min.Xy); var uv = Vector2.Divide(vertex - BoundingBox.Min.Xy, BoundingBox.Max.Xy - BoundingBox.Min.Xy);
@ -53,6 +70,11 @@ namespace SM2D.Object
UVs.Add(uv); UVs.Add(uv);
} }
/// <summary>
/// Creates a circle.
/// </summary>
/// <param name="secments"></param>
/// <returns></returns>
public static Polygon GenerateCircle(int secments = 32) public static Polygon GenerateCircle(int secments = 32)
{ {
var vertices = new List<Vector2> {Vector2.Zero}; var vertices = new List<Vector2> {Vector2.Zero};

25
SMCode/SM2D/Object/PolygonVertex.cs
View file

@ -7,17 +7,36 @@ using OpenTK.Graphics;
namespace SM2D.Object namespace SM2D.Object
{ {
/// <summary>
/// Allows storing more information inside a vertex.
/// </summary>
public struct PolygonVertex public struct PolygonVertex
{ {
public Vector2 Vertex; /// <summary>
/// The position in the polygon.
/// </summary>
public Vector2 Position;
/// <summary>
/// The color of the vertex.
/// </summary>
public Color4 Color; public Color4 Color;
public PolygonVertex(Vector2 vertex = default, Color4 color = default) /// <summary>
/// Creates a polygon vertex.
/// </summary>
/// <param name="position"></param>
/// <param name="color"></param>
public PolygonVertex(Vector2 position = default, Color4 color = default)
{ {
Vertex = vertex; Position = position;
Color = color; Color = color;
} }
/// <summary>
/// Automaticly translates Vector2s to PolygonVertex
/// </summary>
/// <param name="vec"></param>
/// <returns></returns>
public static implicit operator PolygonVertex(Vector2 vec) => new PolygonVertex(vec, Color4.White); public static implicit operator PolygonVertex(Vector2 vec) => new PolygonVertex(vec, Color4.White);
} }
} }

18
SMCode/SM2D/Pipelines/Basic2DPipeline.cs
View file

@ -1,18 +1,32 @@
using SM.Base.Shaders; using OpenTK.Graphics.OpenGL4;
using SM.Base.Shaders;
using SM.Base.Window; using SM.Base.Window;
using SM.OGL.Framebuffer;
using SM2D.Shader; using SM2D.Shader;
namespace SM2D.Pipelines namespace SM2D.Pipelines
{ {
/// <summary>
/// This implements the most basic render pipeline.
/// </summary>
public class Basic2DPipeline : RenderPipeline public class Basic2DPipeline : RenderPipeline
{ {
public static Basic2DPipeline Pipeline = new Basic2DPipeline(); /// <summary>
/// The access to the pipeline.
/// </summary>
public static Basic2DPipeline Pipeline =
new Basic2DPipeline();
/// <inheritdoc />
public override MaterialShader DefaultShader { get; protected set; } = ShaderCollection.Instanced; public override MaterialShader DefaultShader { get; protected set; } = ShaderCollection.Instanced;
private Basic2DPipeline() {}
/// <inheritdoc />
protected override void RenderProcess(ref DrawContext context) protected override void RenderProcess(ref DrawContext context)
{ {
Framebuffer.Screen.Activate(FramebufferTarget.Framebuffer, ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
context.Scene?.Draw(context); context.Scene?.Draw(context);
} }
} }

3
SMCode/SM2D/Properties/AssemblyInfo.cs
View file

@ -35,5 +35,4 @@ using System.Runtime.InteropServices;
// You can specify all the values or you can default the Build and Revision Numbers // You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below: // by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")] // [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")] [assembly: AssemblyVersion("1.0.1.1")]
[assembly: AssemblyFileVersion("1.0.0.0")]

9
SMCode/SM2D/SM2D.csproj
View file

@ -1,6 +1,5 @@
<?xml version="1.0" encoding="utf-8"?> <?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> <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> <PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
@ -8,7 +7,7 @@
<OutputType>Library</OutputType> <OutputType>Library</OutputType>
<AppDesignerFolder>Properties</AppDesignerFolder> <AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>SM2D</RootNamespace> <RootNamespace>SM2D</RootNamespace>
<AssemblyName>SM2D</AssemblyName> <AssemblyName>SMRenderer2D</AssemblyName>
<TargetFrameworkVersion>v4.5.2</TargetFrameworkVersion> <TargetFrameworkVersion>v4.5.2</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment> <FileAlignment>512</FileAlignment>
<Deterministic>true</Deterministic> <Deterministic>true</Deterministic>
@ -21,6 +20,7 @@
<DefineConstants>DEBUG;TRACE</DefineConstants> <DefineConstants>DEBUG;TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport> <ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel> <WarningLevel>4</WarningLevel>
<DocumentationFile>bin\Debug\SMRenderer2D.xml</DocumentationFile>
</PropertyGroup> </PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType> <DebugType>pdbonly</DebugType>
@ -47,13 +47,11 @@
<Compile Include="Pipelines\Basic2DPipeline.cs" /> <Compile Include="Pipelines\Basic2DPipeline.cs" />
<Compile Include="Properties\AssemblyInfo.cs" /> <Compile Include="Properties\AssemblyInfo.cs" />
<Compile Include="Scene\Camera.cs" /> <Compile Include="Scene\Camera.cs" />
<Compile Include="Scene\I2DShowItem.cs" />
<Compile Include="Scene\ItemCollection.cs" /> <Compile Include="Scene\ItemCollection.cs" />
<Compile Include="Scene\Scene.cs" /> <Compile Include="Scene\Scene.cs" />
<Compile Include="Shader\ShaderCollection.cs" /> <Compile Include="Shader\ShaderCollection.cs" />
<Compile Include="Types\Transformation.cs" /> <Compile Include="Types\Transformation.cs" />
<Compile Include="Window\Window2DSetup.cs" /> <Compile Include="Window\Window2DSetup.cs" />
<Compile Include="Window\I2DSetup.cs" />
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<ProjectReference Include="..\SM.Base\SM.Base.csproj"> <ProjectReference Include="..\SM.Base\SM.Base.csproj">
@ -69,9 +67,6 @@
<PackageReference Include="OpenTK"> <PackageReference Include="OpenTK">
<Version>3.3.1</Version> <Version>3.3.1</Version>
</PackageReference> </PackageReference>
<PackageReference Include="OpenTK.GLWpfControl">
<Version>3.2.3</Version>
</PackageReference>
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<EmbeddedResource Include="Shader\ShaderFiles\basic.glsl" /> <EmbeddedResource Include="Shader\ShaderFiles\basic.glsl" />

28
SMCode/SM2D/Scene/Camera.cs
View file

@ -10,6 +10,7 @@ using SM.Base.Window;
namespace SM2D.Scene namespace SM2D.Scene
{ {
/// <inheritdoc />
public class Camera : GenericCamera public class Camera : GenericCamera
{ {
internal static int ResizeCounter = 0; internal static int ResizeCounter = 0;
@ -19,6 +20,14 @@ namespace SM2D.Scene
private bool _updateWorldScale = false; private bool _updateWorldScale = false;
private Vector2? _requestedWorldScale = null; private Vector2? _requestedWorldScale = null;
/// <summary>
/// This vector allows to request a world scale.
/// <para>Following cases are possible. ("not set" means 0)</para>
/// <para>None is set: It takes the window size.</para>
/// <para>X is set: Y get calculated by the aspect ratio of the window.</para>
/// <para>Y is set: X get calculated by the aspect ratio of the window.</para>
/// <para>Both are set: Now the system try to keep a (invisible) rectangle in view, by increasing the width or height of the view, if needed.</para>
/// </summary>
public Vector2? RequestedWorldScale public Vector2? RequestedWorldScale
{ {
get => _requestedWorldScale; get => _requestedWorldScale;
@ -29,18 +38,32 @@ namespace SM2D.Scene
} }
} }
/// <summary>
/// The world scale that got calculated.
/// </summary>
public Vector2 WorldScale { get; private set; } = Vector2.Zero; public Vector2 WorldScale { get; private set; } = Vector2.Zero;
/// <summary>
/// A event that gets triggered, when the world scale changed.
/// <para>Possible causes: Window resizes, <see cref="RequestedWorldScale"/> changed</para>
/// </summary>
public event Action<Camera> WorldScaleChanged; public event Action<Camera> WorldScaleChanged;
/// <summary>
/// The position of the camera.
/// </summary>
public CVector2 Position = new CVector2(0); public CVector2 Position = new CVector2(0);
/// <inheritdoc />
public override bool Orthographic { get; } = true; public override bool Orthographic { get; } = true;
/// <inheritdoc />
protected override Matrix4 ViewCalculation(IGenericWindow window) protected override Matrix4 ViewCalculation(IGenericWindow window)
{ {
return Matrix4.LookAt(Position.X, Position.Y, Distance, Position.X, Position.Y, 0f, 0, 1, 0); return Matrix4.LookAt(Position.X, Position.Y, Distance, Position.X, Position.Y, 0f, 0, 1, 0);
} }
/// <inheritdoc />
protected override bool WorldCalculation(IGenericWindow window, out Matrix4 world) protected override bool WorldCalculation(IGenericWindow window, out Matrix4 world)
{ {
world = Matrix4.Identity; world = Matrix4.Identity;
@ -57,6 +80,11 @@ namespace SM2D.Scene
return false; return false;
} }
/// <summary>
/// This calculates the world scale.
/// <para>Usually gets called, by the camera itself, but if you need the world scale for additional calculations, you can execute it by yourself.</para>
/// </summary>
/// <param name="window"></param>
public void CalculateWorldScale(IGenericWindow window) public void CalculateWorldScale(IGenericWindow window)
{ {
if (RequestedWorldScale.HasValue) if (RequestedWorldScale.HasValue)

13
SMCode/SM2D/Scene/I2DShowItem.cs
View file

@ -1,13 +0,0 @@
#region usings
using SM.Base.Scene;
#endregion
namespace SM2D.Scene
{
public interface I2DShowItem : IShowItem
{
int ZIndex { get; set; }
}
}

8
SMCode/SM2D/Scene/ItemCollection.cs
View file

@ -2,23 +2,19 @@
using SM.Base.Scene; using SM.Base.Scene;
using SM.Base.Types; using SM.Base.Types;
using SM.Base.Window;
using SM2D.Types; using SM2D.Types;
#endregion #endregion
namespace SM2D.Scene namespace SM2D.Scene
{ {
/// <inheritdoc />
public class ItemCollection : GenericItemCollection<Transformation> public class ItemCollection : GenericItemCollection<Transformation>
{ {
/// <inheritdoc />
public ItemCollection() public ItemCollection()
{ {
Transform.Size = new CVector2(1); Transform.Size = new CVector2(1);
} }
public override void Draw(DrawContext context)
{
base.Draw(context);
}
} }
} }

19
SMCode/SM2D/Scene/Scene.cs
View file

@ -11,17 +11,25 @@ using SM2D.Drawing;
namespace SM2D.Scene namespace SM2D.Scene
{ {
/// <summary>
/// The scene allows connecting different objects to render together.
/// </summary>
public class Scene : GenericScene<Camera, ItemCollection> public class Scene : GenericScene<Camera, ItemCollection>
{ {
private static DrawObject2D _axisHelper; private static readonly DrawObject2D _axisHelper;
/// <summary>
/// This determent how large the axishelper should be.
/// </summary>
public float AxisHelperSize = 100; public float AxisHelperSize = 100;
static Scene() static Scene()
{ {
_axisHelper = new DrawObject2D(); _axisHelper = new DrawObject2D {Mesh = AxisHelper.Object};
_axisHelper.Mesh = AxisHelper.Object;
} }
/// <summary>
/// This creates a new scene.
/// </summary>
public Scene() public Scene()
{ {
_Background = new DrawBackground(Color4.Black); _Background = new DrawBackground(Color4.Black);
@ -32,12 +40,16 @@ namespace SM2D.Scene
} }
/// <summary>
/// Gets/Sets the background.
/// </summary>
public DrawBackground Background public DrawBackground Background
{ {
get => (DrawBackground) _Background; get => (DrawBackground) _Background;
set => _Background = value; set => _Background = value;
} }
/// <inheritdoc />
public override void DrawHUD(DrawContext context) public override void DrawHUD(DrawContext context)
{ {
context.ModelMatrix *= Matrix4.CreateTranslation(0,0,1); context.ModelMatrix *= Matrix4.CreateTranslation(0,0,1);
@ -45,6 +57,7 @@ namespace SM2D.Scene
base.DrawHUD(context); base.DrawHUD(context);
} }
/// <inheritdoc />
public override void DrawDebug(DrawContext context) public override void DrawDebug(DrawContext context)
{ {
if (ShowAxisHelper) if (ShowAxisHelper)

8
SMCode/SM2D/Shader/ShaderCollection.cs
View file

@ -5,9 +5,15 @@ using SM.OGL.Shaders;
namespace SM2D.Shader namespace SM2D.Shader
{ {
public class ShaderCollection class ShaderCollection
{ {
/// <summary>
/// The most basic shader, that renders only one thing and only allows colors and one texture.
/// </summary>
public static SimpleShader Basic = new SimpleShader("basic", AssemblyUtility.ReadAssemblyFile("SM2D.Shader.ShaderFiles.basic.glsl"), SetUniforms); public static SimpleShader Basic = new SimpleShader("basic", AssemblyUtility.ReadAssemblyFile("SM2D.Shader.ShaderFiles.basic.glsl"), SetUniforms);
/// <summary>
/// The same fragment shader as <see cref="Basic"/>, but allows to be instanced and used in (f.E.) text.
/// </summary>
public static SimpleShader Instanced = new SimpleShader("instanced", AssemblyUtility.ReadAssemblyFile("SM2D.Shader.ShaderFiles.basic.glsl"), SetUniforms); public static SimpleShader Instanced = new SimpleShader("instanced", AssemblyUtility.ReadAssemblyFile("SM2D.Shader.ShaderFiles.basic.glsl"), SetUniforms);
static void SetUniforms(UniformCollection uniforms, DrawContext context) static void SetUniforms(UniformCollection uniforms, DrawContext context)

1
SMCode/SM2D/Shader/ShaderFiles/basic.glsl
View file

@ -11,5 +11,4 @@ layout(location = 0) out vec4 color;
void main() { void main() {
color = v_Color * Tint; color = v_Color * Tint;
if (UseTexture) color *= texture(Texture, v_TexCoords); if (UseTexture) color *= texture(Texture, v_TexCoords);
color *= 1.2;
} }

46
SMCode/SM2D/Types/Transformation.cs
View file

@ -10,22 +10,46 @@ using SM.Base.Utility;
namespace SM2D.Types namespace SM2D.Types
{ {
/// <inheritdoc />
public class Transformation : GenericTransformation public class Transformation : GenericTransformation
{ {
public static int ZIndexPercision = 300; /// <summary>
/// The precision of the Z-Index.
/// <para>High values can result into "z-fighting" and cliping.</para>
/// </summary>
public static int ZIndexPercision = 100;
/// <summary>
/// The transformations translation.
/// </summary>
public CVector2 Position { get; set; } = new CVector2(0); public CVector2 Position { get; set; } = new CVector2(0);
/// <summary>
/// The scaling.
/// </summary>
public CVector2 Size { get; set; } = new CVector2(50); public CVector2 Size { get; set; } = new CVector2(50);
/// <summary>
/// The rotation.
/// </summary>
public CVector1 Rotation { get; set; } = new CVector1(0); public CVector1 Rotation { get; set; } = new CVector1(0);
/// <summary>
/// If true, the object get rotated on the X-Axis by 180°.
/// </summary>
public bool HorizontalFlip { get; set; } = false; public bool HorizontalFlip { get; set; } = false;
/// <summary>
/// If true, the object get rotated on the Y-Axis by 180°.
/// </summary>
public bool VerticalFlip { get; set; } = false; public bool VerticalFlip { get; set; } = false;
/// <summary>
/// The ZIndex.
/// </summary>
public CVector1 ZIndex { get; set; } = new CVector1(0); public CVector1 ZIndex { get; set; } = new CVector1(0);
/// <inheritdoc />
protected override Matrix4 RequestMatrix() protected override Matrix4 RequestMatrix()
{ {
float z = 1 / (float) ZIndexPercision * ZIndex; float z = 1 / (float) ZIndexPercision * ZIndex;
@ -37,11 +61,18 @@ namespace SM2D.Types
Matrix4.CreateTranslation(Position.X, Position.Y, z); Matrix4.CreateTranslation(Position.X, Position.Y, z);
} }
public void TurnTo(Vector2 v) /// <summary>
/// Rotates the object, so it SHOULD turn toward the position.
/// </summary>
public void TurnTo(Vector2 turnposition)
{ {
Rotation.Set(RotationUtility.TurnTowards(Position, v)); Rotation.Set(RotationUtility.TurnTowards(Position, turnposition));
} }
/// <summary>
/// Returns the vector the object is looking.
/// </summary>
/// <returns></returns>
public Vector2 LookAtVector() public Vector2 LookAtVector()
{ {
if (_modelMatrix.Determinant < 0.0001) return new Vector2(0); if (_modelMatrix.Determinant < 0.0001) return new Vector2(0);
@ -51,11 +82,20 @@ namespace SM2D.Types
return vec.Xy; return vec.Xy;
} }
/// <summary>
/// The object scale gets set to the same as the resolution of the texture.
/// </summary>
/// <param name="texture"></param>
public void ApplyTextureSize(Texture texture) public void ApplyTextureSize(Texture texture)
{ {
Size.Set(texture.Width, texture.Height); Size.Set(texture.Width, texture.Height);
} }
/// <summary>
/// The object scale gets set to the same aspect ratio as the texture and then it will set the width..
/// </summary>
/// <param name="texture"></param>
/// <param name="width"></param>
public void ApplyTextureSize(Texture texture, float width) public void ApplyTextureSize(Texture texture, float width)
{ {
Size.Set(width, width / texture.Aspect); Size.Set(width, width / texture.Aspect);

10
SMCode/SM2D/Window/I2DSetup.cs
View file

@ -1,10 +0,0 @@
using OpenTK;
using SM.Base.Window;
namespace SM2D
{
public interface I2DSetup : ISetup
{
Vector2? WorldScale { get; set; }
}
}

14
SMCode/SM2D/Window/Window2DSetup.cs
View file

@ -2,32 +2,38 @@
using OpenTK.Graphics.OpenGL4; using OpenTK.Graphics.OpenGL4;
using SM.Base; using SM.Base;
using SM.Base.Window; using SM.Base.Window;
using SM2D.Pipelines;
using SM2D.Scene; using SM2D.Scene;
using SM2D.Shader; using SM2D.Shader;
namespace SM2D namespace SM2D
{ {
public struct Window2DSetup : I2DSetup /// <summary>
/// Sets up a 2D window.
/// </summary>
public struct Window2DSetup : ISetup
{ {
public Vector2? WorldScale { get; set; } /// <inheritdoc />
public void Applied(IGenericWindow window) public void Applied(IGenericWindow window)
{ {
window.ViewportCamera = new Camera(); window.ViewportCamera = new Camera();
SMRenderer.DefaultMaterialShader = ShaderCollection.Instanced; SMRenderer.DefaultMaterialShader = ShaderCollection.Instanced;
SMRenderer.DefaultRenderPipeline = Basic2DPipeline.Pipeline;
} }
/// <inheritdoc />
public void Load(IGenericWindow window) public void Load(IGenericWindow window)
{ {
(window.ViewportCamera as Camera).RequestedWorldScale = WorldScale;
GL.Enable(EnableCap.DepthTest); GL.Enable(EnableCap.DepthTest);
} }
/// <inheritdoc />
public void Loaded(IGenericWindow window) public void Loaded(IGenericWindow window)
{ {
} }
/// <inheritdoc />
public void Resize(IGenericWindow window) public void Resize(IGenericWindow window)
{ {
Camera.ResizeCounter++; Camera.ResizeCounter++;

53
SM_TEST/Program.cs
View file

@ -1,11 +1,13 @@
using OpenTK; using System;
using System.Diagnostics;
using OpenTK;
using OpenTK.Graphics; using OpenTK.Graphics;
using OpenTK.Input; using OpenTK.Input;
using SM.Base; using SM.Base;
using SM.Base.Window; using SM.Base.Window;
using SM.Game.Controls;
using SM2D; using SM2D;
using SM2D.Drawing; using SM2D.Drawing;
using SM2D.Pipelines;
using SM2D.Scene; using SM2D.Scene;
using Font = SM.Base.Drawing.Text.Font; using Font = SM.Base.Drawing.Text.Font;
using Vector2 = OpenTK.Vector2; using Vector2 = OpenTK.Vector2;
@ -19,48 +21,29 @@ namespace SM_TEST
private static GLWindow window; private static GLWindow window;
static void Main(string[] args) static void Main(string[] args)
{ {
font = new Font(@"C:\Windows\Fonts\Arial.ttf") window = new GLWindow();
{ window.ApplySetup(new Window2DSetup());
FontSize = 32
};
Log.SetLogFile(compressionFolder:"logs");
window = new GLWindow {VSync = VSyncMode.Off};
window.ApplySetup(new Window2DSetup() {WorldScale = new Vector2(0,1000)});
window.SetRenderPipeline(new TestRenderPipeline());
window.SetScene(scene = new Scene()); window.SetScene(scene = new Scene());
window.RunFixedUpdate(60); scene.Objects.Add(new DrawObject2D());
window.Load += WindowOnLoad; window.UpdateFrame += WindowOnUpdateFrame;
window.RenderFrame += WindowOnUpdateFrame;
window.Run(); window.Run();
Debug.WriteLine("Window Closed");
} }
private static DrawParticles particles;
private static void WindowOnUpdateFrame(object sender, FrameEventArgs e) private static void WindowOnUpdateFrame(object sender, FrameEventArgs e)
{ {
if (Keyboard.GetState()[Key.R]) if (SM.Base.Controls.Keyboard.IsDown(Key.F, true))
particles.Trigger(); {
//particles.Paused = Keyboard.GetState()[Key.P]; window.WindowFlags = WindowFlags.ExclusiveFullscreen;
window.ChangeFullscreenResolution(DisplayDevice.Default.SelectResolution(1280,720, DisplayDevice.Default.BitsPerPixel, DisplayDevice.Default.RefreshRate));
}
if (SM.Base.Controls.Keyboard.IsDown(Key.W, true)) window.WindowFlags = WindowFlags.Window;
if (SM.Base.Controls.Keyboard.IsDown(Key.B, true)) window.WindowFlags = WindowFlags.BorderlessWindow;
GameControllerState s1 = new GameController(0).GetState();
GameControllerState s2 = new GameController(1).GetState();
} }
private static void WindowOnLoad(IGenericWindow window) private static void WindowOnLoad(IGenericWindow window)
{ { }
scene.ShowAxisHelper = true;
//scene.Background.Color = Color4.White;
DrawObject2D box = new DrawObject2D();
scene.Objects.Add(box);
DrawText text = new DrawText(font, "Test Text");
text.Transform.Position.Set(50, 0);
text.Transform.Size.Set(2);
scene.HUD.Add(text);
//particles.Trigger();
}
} }
} }

13
SM_TEST/SM_TEST.csproj
View file

@ -36,12 +36,6 @@
<Reference Include="OpenTK, Version=3.3.1.0, Culture=neutral, PublicKeyToken=bad199fe84eb3df4, processorArchitecture=MSIL"> <Reference Include="OpenTK, Version=3.3.1.0, Culture=neutral, PublicKeyToken=bad199fe84eb3df4, processorArchitecture=MSIL">
<HintPath>..\packages\OpenTK.3.3.1\lib\net20\OpenTK.dll</HintPath> <HintPath>..\packages\OpenTK.3.3.1\lib\net20\OpenTK.dll</HintPath>
</Reference> </Reference>
<Reference Include="SharpDX, Version=4.2.0.0, Culture=neutral, PublicKeyToken=b4dcf0f35e5521f1, processorArchitecture=MSIL">
<HintPath>..\packages\SharpDX.4.2.0\lib\net45\SharpDX.dll</HintPath>
</Reference>
<Reference Include="SharpDX.XInput, Version=4.2.0.0, Culture=neutral, PublicKeyToken=b4dcf0f35e5521f1, processorArchitecture=MSIL">
<HintPath>..\packages\SharpDX.XInput.4.2.0\lib\net45\SharpDX.XInput.dll</HintPath>
</Reference>
<Reference Include="System" /> <Reference Include="System" />
<Reference Include="System.Core" /> <Reference Include="System.Core" />
<Reference Include="System.Drawing" /> <Reference Include="System.Drawing" />
@ -56,6 +50,9 @@
<None Include="OpenTK.dll.config" /> <None Include="OpenTK.dll.config" />
<None Include="packages.config" /> <None Include="packages.config" />
</ItemGroup> </ItemGroup>
<ItemGroup>
<WCFMetadata Include="Connected Services\" />
</ItemGroup>
<ItemGroup> <ItemGroup>
<ProjectReference Include="..\SMCode\SM.Base\SM.Base.csproj"> <ProjectReference Include="..\SMCode\SM.Base\SM.Base.csproj">
<Project>{8e733844-4204-43e7-b3dc-3913cddabb0d}</Project> <Project>{8e733844-4204-43e7-b3dc-3913cddabb0d}</Project>
@ -69,10 +66,6 @@
<Project>{a4565538-625a-42c6-a330-dd4f1abb3986}</Project> <Project>{a4565538-625a-42c6-a330-dd4f1abb3986}</Project>
<Name>SM2D</Name> <Name>SM2D</Name>
</ProjectReference> </ProjectReference>
<ProjectReference Include="..\SMOptionals\SM.Game\SM.Game.csproj">
<Project>{079bab31-3dc4-40da-90c7-efaa8517c647}</Project>
<Name>SM.Game</Name>
</ProjectReference>
</ItemGroup> </ItemGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" /> <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
</Project> </Project>

2
SM_TEST/TestRenderPipeline.cs
View file

@ -18,7 +18,7 @@ namespace SM_TEST
_postBuffer = CreateWindowFramebuffer(0, false, PixelInformation.RGBA_HDR); _postBuffer = CreateWindowFramebuffer(0, false, PixelInformation.RGBA_HDR);
Framebuffers.Add(_postBuffer); Framebuffers.Add(_postBuffer);
_bloom = new BloomEffect(MainFramebuffer, hdr: true, .5f) _bloom = new BloomEffect(MainFramebuffer, hdr: true, .75f)
{ {
Threshold = .5f, Threshold = .5f,
}; };