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

20.09.2020

Browse source 
+ Instance Drawing
+ Text and Font

~ Made "DrawBackground" forced Background for 2D

- DrawEmpty
This commit is contained in:
Michel Fedde 2020-09-20 18:29:09 +02:00
parent acccf5f0e7
commit c4a0847567
29 changed files with 365 additions and 85 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -4,7 +4,7 @@ using SM.OGL.Mesh;
namespace SM.Base.Scene
{
public class DrawingBasis : IShowItem
public abstract class DrawingBasis : IShowItem
{
protected Material _material = new Material();
protected Mesh _mesh = Plate.Object;
@ -22,10 +22,9 @@ namespace SM.Base.Scene
context.Mesh = _mesh;
}
}
public class DrawingBasis<TTransformation> : DrawingBasis
public abstract class DrawingBasis<TTransformation> : DrawingBasis
where TTransformation : GenericTransformation, new()
{
public TTransformation Transform = new TTransformation();
}
}

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

@ -7,6 +7,5 @@ namespace SM.Base.Scene
public interface IShader
{
void Draw(DrawContext context);
void DrawInstanced(DrawContext context, ICollection<Matrix4> instanceCollection);
}
}

11
SMCode/SM.Base/Drawing/Instance.cs Normal file
View file

@ -0,0 +1,11 @@
using OpenTK;
namespace SM.Base.Scene
{
public struct Instance
{
public Matrix4 ModelMatrix;
public Vector2 TexturePosition;
public Vector2 TextureScale;
}
}

2
SMCode/SM.Base/Drawing/Material.cs
View file

@ -7,7 +7,7 @@ namespace SM.Base.Scene
public class Material
{
public TextureBase Texture;
public Color4 Tint;
public Color4 Tint = Color4.White;
public IShader Shader = Shaders.Default;
}

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

@ -47,13 +47,19 @@
<ItemGroup>
<Compile Include="Drawing\DrawingBasis.cs" />
<Compile Include="Drawing\GenericTransformation.cs" />
<Compile Include="Drawing\Instance.cs" />
<Compile Include="Drawing\IShader.cs" />
<Compile Include="Drawing\IShowCollection.cs" />
<Compile Include="Drawing\IShowItem.cs" />
<Compile Include="Scene\IShowCollection.cs" />
<Compile Include="Scene\IShowItem.cs" />
<Compile Include="Drawing\Material.cs" />
<Compile Include="Scene\IBackgroundItem.cs" />
<Compile Include="Shader\InstanceShader.cs" />
<Compile Include="Shader\Shaders.cs" />
<Compile Include="Textures\Texture.cs" />
<Compile Include="Text\CharParameter.cs" />
<Compile Include="Text\Font.cs" />
<Compile Include="Text\FontCharStorage.cs" />
<Compile Include="Text\TextDrawingBasis.cs" />
<Compile Include="Types\Vector.cs" />
<Compile Include="Types\Vector2.cs" />
<Compile Include="Types\Vector3.cs" />

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

@ -8,7 +8,7 @@ namespace SM.Base.Scene
where TCamera : GenericCamera, new()
{
public IShowItem Background;
protected IBackgroundItem _background;
public List<IShowItem> HUD { get; } = new List<IShowItem>();
public List<IShowItem> Objects { get; } = new List<IShowItem>();
public TCamera Camera { get; set; }
@ -21,7 +21,7 @@ namespace SM.Base.Scene
DrawContext backgroundDrawContext = context;
backgroundDrawContext.View = BackgroundCamera.CalculateViewMatrix();
Background?.Draw(backgroundDrawContext);
_background?.Draw(backgroundDrawContext);
for(int i = 0; i < Objects.Count; i++)
Objects[i].Draw(context);

7
SMCode/SM.Base/Scene/IBackgroundItem.cs Normal file
View file

@ -0,0 +1,7 @@
namespace SM.Base.Scene
{
public interface IBackgroundItem : IShowItem
{
}
}

0
SMCode/SM.Base/Drawing/IShowCollection.cs → SMCode/SM.Base/Scene/IShowCollection.cs
View file

0
SMCode/SM.Base/Drawing/IShowItem.cs → SMCode/SM.Base/Scene/IShowItem.cs
View file

9
SMCode/SM.Base/Shader/Files/default.vert
View file

@ -1,14 +1,17 @@
#version 330
#define maxInstances 32
layout(location = 0) in vec3 aPos;
layout(location = 1) in vec2 aTex;
uniform mat4 MVP;
uniform mat4 ModelMatrix;
uniform mat4 ModelMatrix[maxInstances];
uniform vec2 TextureOffset[maxInstances];
uniform vec2 TextureScale[maxInstances];
out vec2 vTexture;
void main() {
vTexture = aTex;
vTexture = aTex * TextureScale[gl_InstanceID] + TextureOffset[gl_InstanceID];
gl_Position = MVP * ModelMatrix * vec4(aPos, 1);
gl_Position = MVP * ModelMatrix[gl_InstanceID] * vec4(aPos, 1);
}

19
SMCode/SM.Base/Shader/InstanceShader.cs
View file

@ -13,26 +13,25 @@ namespace SM.Base.Shader
{
protected override bool AutoCompile { get; } = true;
public Action<UniformCollection, DrawContext> SetUniform;
public Action<UniformCollection, DrawContext, int> SetUniformVertex;
public Action<UniformCollection, DrawContext> SetUniformFragment;
public InstanceShader(string vertex, string fragment, Action<UniformCollection, DrawContext> setUniform) : base(new ShaderFileCollection(vertex, fragment))
public InstanceShader(string vertex, string fragment) : base(new ShaderFileCollection(vertex, fragment))
{
SetUniform = setUniform;
}
public void Draw(DrawContext context)
{
GL.UseProgram(this);
SetUniform.Invoke(Uniforms, context);
Uniforms["MVP"].SetMatrix4(context.View * context.World);
DrawObject(context.Mesh, true);
for (int i = 0; i < context.Instances.Length; i++) SetUniformVertex?.Invoke(Uniforms, context, i);
SetUniformFragment?.Invoke(Uniforms, context);
DrawObject(context.Mesh, context.Instances.Length, true);
GL.UseProgram(0);
}
public void DrawInstanced(DrawContext context, ICollection<Matrix4> instanceCollection)
{
throw new NotImplementedException();
}
}
}

18
SMCode/SM.Base/Shader/Shaders.cs
View file

@ -1,5 +1,6 @@
using System.IO;
using System.Reflection;
using OpenTK.Graphics.OpenGL4;
using SM.OGL.Shaders;
namespace SM.Base.Shader
@ -7,13 +8,20 @@ namespace SM.Base.Shader
public class Shaders
{
public static InstanceShader Default = new InstanceShader(new StreamReader(Assembly.GetExecutingAssembly().GetManifestResourceStream("SM.Base.Shader.Files.default.vert")).ReadToEnd(),
new StreamReader(Assembly.GetExecutingAssembly().GetManifestResourceStream("SM.Base.Shader.Files.default.frag")).ReadToEnd(),
((u, context) =>
new StreamReader(Assembly.GetExecutingAssembly().GetManifestResourceStream("SM.Base.Shader.Files.default.frag")).ReadToEnd())
{
SetUniformFragment = (u, context) =>
{
u["MVP"].SetMatrix4(context.View * context.World);
u["ModelMatrix"].SetMatrix4(context.ModelMatrix);
u["Tint"].SetUniform4(context.Material.Tint);
u["Texture"].SetTexture(context.Material.Texture, 0, u["UseTexture"]);
}));
},
SetUniformVertex = (u, context, i) =>
{
GL.UniformMatrix4(u["ModelMatrix"] + i, false, ref context.Instances[i].ModelMatrix);
GL.Uniform2(u["TextureOffset"] + i, context.Instances[i].TexturePosition);
GL.Uniform2(u["TextureScale"] + i, context.Instances[i].TextureScale);
}
};
}
}

16
SMCode/SM.Base/Text/CharParameter.cs Normal file
View file

@ -0,0 +1,16 @@
using System;
using System.Configuration.Assemblies;
using OpenTK;
namespace SM.Data.Fonts
{
[Serializable]
public class CharParameter
{
public int X;
public float Width;
public float RelativeX;
public float RelativeWidth;
}
}

95
SMCode/SM.Base/Text/Font.cs Normal file
View file

@ -0,0 +1,95 @@
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Text;
using System.Security.Policy;
using OpenTK;
using OpenTK.Graphics.OpenGL4;
using OpenTK.Input;
using SM.Data.Fonts;
using SM.OGL.Texture;
namespace SM.Base.Text
{
public class Font : TextureBase
{
public Dictionary<char, CharParameter> Positions = new Dictionary<char, CharParameter>();
public override TextureMinFilter Filter { get; set; } = TextureMinFilter.Linear;
public override TextureWrapMode WrapMode { get; set; } = TextureWrapMode.ClampToEdge;
public FontFamily FontFamily;
public FontStyle FontStyle = FontStyle.Regular;
public float FontSize = 12;
public ICollection<char> CharSet = FontCharStorage.SimpleUTF8;
public int Width { get; private set; }
public int Height { get; private set; }
public Bitmap Texture { get; private set; }
public Font(string path)
{
PrivateFontCollection pfc = new PrivateFontCollection();
pfc.AddFontFile(path);
FontFamily = pfc.Families[0];
}
public Font(FontFamily font)
{
FontFamily = font;
}
public void RegenerateTexture()
{
Bitmap map = new Bitmap(1000,20);
Width = 0;
Height = 0;
using (System.Drawing.Font f = new System.Drawing.Font(FontFamily, FontSize, FontStyle))
{
using (Graphics g = Graphics.FromImage(map))
{
g.Clear(Color.Transparent);
foreach (char c in CharSet)
{
string s = c.ToString();
SizeF size = g.MeasureString(s, f);
try
{
Positions.Add(c, new CharParameter() { Width = size.Width, X = Width });
}
catch
{
// ignored
}
if (Height < size.Height) Height = (int)size.Height;
Width += (int)size.Width;
}
}
map = new Bitmap(Width, Height);
using (Graphics g = Graphics.FromImage(map))
{
foreach (KeyValuePair<char, CharParameter> keyValuePair in Positions)
{
keyValuePair.Value.RelativeX = (keyValuePair.Value.X + 0.00001f) / Width;
keyValuePair.Value.RelativeWidth = (keyValuePair.Value.Width) / Width;
g.DrawString(keyValuePair.Key.ToString(), f, Brushes.White, keyValuePair.Value.X, 0);
}
}
}
Texture = map;
_id = SM.Base.Textures.Texture.GenerateTexture(map, Filter, WrapMode);
}
protected override void Compile()
{
base.Compile();
RegenerateTexture();
}
}
}

14
SMCode/SM.Base/Text/FontCharStorage.cs Normal file
View file

@ -0,0 +1,14 @@
namespace SM.Data.Fonts
{
public class FontCharStorage
{
public static readonly char[] SimpleUTF8 = new char[]
{
'!', '"', '#', '$', '%', '&', '\'', '(', ')', '*', '+', ',', '-', '.', '/', '0', '1', '2', '3', '4', '5', '6',
'7', '8', '9', ':', ';', '<', '=', '>', '?', '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K',
'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '[', '\\', ']', '^', '_', '`',
'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u',
'v', 'w', 'x', 'y', 'z', '{', '|', '}', '~'
};
}
}

83
SMCode/SM.Base/Text/TextDrawingBasis.cs Normal file
View file

@ -0,0 +1,83 @@
using System;
using OpenTK;
using OpenTK.Graphics;
using SM.Base.Contexts;
using SM.Base.Scene;
using SM.Data.Fonts;
namespace SM.Base.Text
{
public abstract class TextDrawingBasis<TTransform> : DrawingBasis<TTransform>
where TTransform : GenericTransformation, new()
{
protected Instance[] _modelMatrixs;
protected string _text;
public Font Font
{
get => (Font) _material.Texture;
set
{
_material.Texture = value;
GenerateMatrixes();
}
}
public string Text
{
get => _text;
set
{
_text = value;
GenerateMatrixes();
}
}
public Color4 Color
{
get => _material.Tint;
set => _material.Tint = value;
}
protected TextDrawingBasis(Font font)
{
_material.Texture = font;
}
public override void Draw(DrawContext context)
{
base.Draw(context);
if (_modelMatrixs == null) GenerateMatrixes();
}
public void GenerateMatrixes()
{
if (!Font.WasCompiled) Font.RegenerateTexture();
_modelMatrixs = new Instance[_text.Length];
float x = 0;
for (var i = 0; i < _text.Length; i++)
{
CharParameter parameter;
try
{
parameter = Font.Positions[_text[i]];
}
catch
{
throw new Exception("Font doesn't contain '"+_text[i]+"'");
}
Matrix4 matrix = Matrix4.CreateScale(parameter.Width, Font.Height, 1) * Matrix4.CreateTranslation(x, 0, 0);
_modelMatrixs[i] = new Instance
{
ModelMatrix = matrix,
TexturePosition = new Vector2(parameter.RelativeX, 0),
TextureScale = new Vector2(parameter.RelativeWidth, 1)
};
x += parameter.Width;
}
}
}
}

32
SMCode/SM.Base/Textures/Texture.cs
View file

@ -9,6 +9,7 @@ namespace SM.Base.Textures
public class Texture : TextureBase
{
public Bitmap Map;
public bool AutoDispose = false;
public Texture(Bitmap map) : this(map, TextureMinFilter.Linear, TextureWrapMode.Repeat) {}
@ -23,29 +24,38 @@ namespace SM.Base.Textures
{
base.Compile();
_id = GL.GenTexture();
GL.BindTexture(TextureTarget.Texture2D, _id);
_id = GenerateTexture(Map, Filter, WrapMode, AutoDispose);
}
BitmapData data = Map.LockBits(new Rectangle(0, 0, Map.Width, Map.Height), ImageLockMode.ReadOnly,
Map.PixelFormat);
public static int GenerateTexture(Bitmap map, TextureMinFilter filter, TextureWrapMode wrapMode, bool dispose = false)
{
int id = GL.GenTexture();
GL.BindTexture(TextureTarget.Texture2D, id);
bool transparenz = Map.PixelFormat == PixelFormat.Format32bppArgb;
BitmapData data = map.LockBits(new Rectangle(0, 0, map.Width, map.Height), ImageLockMode.ReadOnly,
map.PixelFormat);
GL.TexImage2D(TextureTarget.Texture2D, 0,
bool transparenz = map.PixelFormat == PixelFormat.Format32bppArgb;
GL.TexImage2D(TextureTarget.Texture2D, 0,
transparenz ? PixelInternalFormat.Rgba : PixelInternalFormat.Rgb,
data.Width, data.Height, 0,
transparenz ? OpenTK.Graphics.OpenGL4.PixelFormat.Bgra : OpenTK.Graphics.OpenGL4.PixelFormat.Bgr,
PixelType.UnsignedByte, data.Scan0);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)Filter);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)Filter);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int) WrapMode);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int) WrapMode);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)filter);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)filter);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int)wrapMode);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int)wrapMode);
GL.GenerateMipmap(GenerateMipmapTarget.Texture2D);
GL.BindTexture(TextureTarget.Texture2D, 0);
Map.UnlockBits(data);
map.UnlockBits(data);
if (dispose) map.Dispose();
return id;
}
public static implicit operator Texture(Bitmap map) => new Texture(map);

6
SMCode/SM.Base/Window/Contexts/DrawContext.cs
View file

@ -1,4 +1,5 @@
using OpenTK;
using System.Collections.Generic;
using OpenTK;
using SM.Base.Scene;
using SM.OGL.Mesh;
@ -7,10 +8,11 @@ namespace SM.Base.Contexts
public struct DrawContext
{
public bool ForceViewport;
public bool Instancing;
public Matrix4 World;
public Matrix4 View;
public Matrix4 ModelMatrix;
public Instance[] Instances;
public Mesh Mesh;
public Material Material;

2
SMCode/SM.Base/Window/GenericWindow.cs
View file

@ -39,7 +39,7 @@ namespace SM.Base
{
World = _viewportCamera.World,
View = _viewportCamera.CalculateViewMatrix(),
ModelMatrix = Matrix4.Identity,
Instances = new[] { new Instance {ModelMatrix = Matrix4.Identity, TexturePosition = Vector2.Zero, TextureScale = Vector2.One } },
Mesh = Plate.Object,
ForceViewport = ForceViewportCamera,
WorldScale = WorldScale