Troispoils/map3drendering
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Wpf System test

Browse source
This commit is contained in:
Troispoils 2024-03-06 17:19:53 +01:00
parent af9c782c1e
commit 9ad4bc1c69
17 changed files with 746 additions and 12 deletions
Download patch file Download diff file Expand all files Collapse all files

17
LandblockExtraction/WorldMap/Types/Cell.cs Normal file
View file

@ -0,0 +1,17 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Numerics;
using System.Text;
using System.Threading.Tasks;
namespace LandblockExtraction.WorldMap.Types;
public class Cell {
public Vector3[,] position;
public Vector4[,] color;
public Cell() {
position = new Vector3[17, 17];
color = new Vector4[17, 17];
}
}

50
LandblockExtraction/WorldMap/Types/Land.cs Normal file
View file

@ -0,0 +1,50 @@
using LandblockExtraction.WorldMap.Types;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace LandblockExtraction.WorldMap;
public class Land {
public Cell cell;
public Land() {
cell = new Cell();
}
public float[] getVertices() {
List<float> vertices = new List<float>();
for(int y = 0; y < 10; y++) {
for(int x = 0; x < 10; x++) {
vertices.Add(cell.position[x, y].X);
vertices.Add(cell.position[x, y].Y);
vertices.Add(cell.position[x, y].Z);
vertices.Add(cell.color[x, y].X);
vertices.Add(cell.color[x, y].Y);
vertices.Add(cell.color[x, y].Z);
vertices.Add(cell.color[x, y].W);
}
}
return vertices.ToArray();
}
public int[] getIndices() {
List<int> indices = new List<int>();
for (int y = 0; y < 10 - 1; y++) {
for (int x = 0; x < 10 - 1; x++) {
var value = y * 10 + x;
indices.Add(value);
indices.Add(value + 1);
indices.Add(value + 10);
indices.Add(value + 10);
indices.Add(value + 11);
indices.Add(value + 1);
}
}
return indices.ToArray();
}
}

40
LandblockExtraction/WorldMap/WorldMap.cs Normal file
View file

@ -0,0 +1,40 @@
using LandblockExtraction.WorldMap.Types;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Numerics;
using System.Threading.Tasks;
namespace LandblockExtraction.WorldMap;
public class WorldMap {
public Land[,] lands;
public WorldMap() {
lands = new Land[10, 10];
CreatePlane();
}
public void CreatePlane() {
for(int i = 0; i < 10; i++) {
for(int j = 0; j < 10; j++) {
lands[j,i] = CreateCell(i, j);
}
}
}
private Land CreateCell(int i, int j) {
Land land = new Land();
for(int y = 0; y < 17; y++) {
for (int x = 0; x < 17; x++) {
float rand = new Random().Next(0, 254) / 255f;
Console.WriteLine(rand);
land.cell.position[x, y] = new Vector3(x + (j * 9), 0, y + (i * 9));
land.cell.color[x, y] = new Vector4(rand, rand, rand, 1f);
}
}
return land;
}
}

12
Map3DRendering.sln
View file

@ -3,14 +3,16 @@ Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio Version 17
VisualStudioVersion = 17.8.34330.188
MinimumVisualStudioVersion = 10.0.40219.1
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Map3DRendering", "Map3DRendering\Map3DRendering.csproj", "{B2ED409E-ACF9-4D6B-9632-6B9A7D0C3386}"
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Map3DRendering", "Map3DRendering\Map3DRendering.csproj", "{B2ED409E-ACF9-4D6B-9632-6B9A7D0C3386}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "LandblockExtraction", "LandblockExtraction\LandblockExtraction.csproj", "{CE966441-7638-4137-BD1A-A8ED612A4E81}"
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LandblockExtraction", "LandblockExtraction\LandblockExtraction.csproj", "{CE966441-7638-4137-BD1A-A8ED612A4E81}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Test_LandblockExtraction", "Test_LandblockExtraction\Test_LandblockExtraction.csproj", "{23CE2C14-661B-4544-A768-5475809641FC}"
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Test_LandblockExtraction", "Test_LandblockExtraction\Test_LandblockExtraction.csproj", "{23CE2C14-661B-4544-A768-5475809641FC}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "TestUnit", "TestUnit", "{9CEDBDBC-D718-4F94-A8C7-8A10835816E3}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WpfMapView2D", "WpfMapView2D\WpfMapView2D.csproj", "{8D0A4BB4-23C7-4259-A614-3E9C6B0C8781}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
@ -29,6 +31,10 @@ Global
{23CE2C14-661B-4544-A768-5475809641FC}.Debug|Any CPU.Build.0 = Debug|Any CPU
{23CE2C14-661B-4544-A768-5475809641FC}.Release|Any CPU.ActiveCfg = Release|Any CPU
{23CE2C14-661B-4544-A768-5475809641FC}.Release|Any CPU.Build.0 = Release|Any CPU
{8D0A4BB4-23C7-4259-A614-3E9C6B0C8781}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{8D0A4BB4-23C7-4259-A614-3E9C6B0C8781}.Debug|Any CPU.Build.0 = Debug|Any CPU
{8D0A4BB4-23C7-4259-A614-3E9C6B0C8781}.Release|Any CPU.ActiveCfg = Release|Any CPU
{8D0A4BB4-23C7-4259-A614-3E9C6B0C8781}.Release|Any CPU.Build.0 = Release|Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE

3
Map3DRendering/Map3DRendering.csproj
View file

@ -30,6 +30,9 @@
<None Update="Shaders\lighting.frag">
<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
</None>
<None Update="Shaders\shadertest.frag">
<CopyToOutputDirectory>Always</CopyToOutputDirectory>
</None>
<None Update="Shaders\shader.frag">
<CopyToOutputDirectory>Always</CopyToOutputDirectory>
</None>

13
Map3DRendering/Shaders/shadertest.frag Normal file
View file

@ -0,0 +1,13 @@
#version 330
out vec4 outputColor;
uniform vec3 viewPos;
uniform sampler2DArray texture0;
in vec4 Color;
void main()
{
outputColor = Color;
}

22
Map3DRendering/Window.cs
View file

@ -10,7 +10,8 @@ namespace Map3DRendering {
private readonly Vector3 _lightPos = new Vector3(0x10, 0, 0x10);
private MapRender mapRender;
//private MapRender mapRender;
private WorldMapRender _render;
private AxesGizmo axesGizmo;
private Shader _shader;
@ -33,7 +34,8 @@ namespace Map3DRendering {
public Window(GameWindowSettings gameWindowSettings, NativeWindowSettings nativeWindowSettings)
: base(gameWindowSettings, nativeWindowSettings) {
mapRender = new MapRender();
//mapRender = new MapRender();
_render = new WorldMapRender();
GL.GetInteger(GetPName.MaxTextureImageUnits, out maxTextures);
}
@ -49,10 +51,11 @@ namespace Map3DRendering {
GL.GetInteger(GetPName.MaxTextureImageUnits, out maxTextureUnits);
Console.WriteLine($"Maximum number of texture units for fragment shaders: {maxTextureUnits}");
_shader = new Shader("Shaders/shader.vert", "Shaders/shader.frag");
_shader = new Shader("Shaders/shader.vert", "Shaders/shadertest.frag");
_shader.Use();
mapRender.OnLoad(_shader);
//mapRender.OnLoad(_shader);
_render.OnLoad(_shader);
var file = Directory.EnumerateFiles(@"./terrains");
_texture = Texture.LoadFromArray(file.ToArray());
@ -82,14 +85,15 @@ namespace Map3DRendering {
_shader.SetMatrix4("projection", _camera.GetProjectionMatrix());
//_shader.SetVector3("objectColor", new Vector3(0.5f, 0.5f, 0.5f));
_shader.SetVector3("lightColor", new Vector3(1.0f, 1.0f, 1.0f));
_shader.SetVector3("lightPos", _camera.Position);
//_shader.SetVector3("lightColor", new Vector3(1.0f, 1.0f, 1.0f));
//_shader.SetVector3("lightPos", _camera.Position);
GL.LineWidth(5.0f);
_shader.SetVector3("viewPos", _camera.Position);
mapRender.UpdateBlocks(_camera.Position, _shader);
mapRender.Render(_shader);
//_shader.SetVector3("viewPos", _camera.Position);
//mapRender.UpdateBlocks(_camera.Position, _shader);
//mapRender.Render(_shader);
_render.Render(_shader);
axesGizmo.Render(Size.X, Size.Y, _camera);

77
Map3DRendering/WorldMapRender.cs Normal file
View file

@ -0,0 +1,77 @@
using LandblockExtraction.AtlasMaker;
using LandblockExtraction.DatEngine;
using LandblockExtraction.LandBlockExtractor;
using LandblockExtraction.WorldMap;
using Map3DRendering.Common;
using OpenTK.Graphics.OpenGL4;
using OpenTK.Mathematics;
namespace Map3DRendering {
public class WorldMapRender {
private WorldMap worldMap;
private int[,] _vertexArrayObject;
private int[,] _vertexBufferObject;
private int[,] _elementBufferObject;
private int[,] _indiceLength;
public WorldMapRender() {
worldMap = new WorldMap();
_vertexArrayObject = new int[10, 10];
_vertexBufferObject = new int[10, 10];
_elementBufferObject = new int[10, 10];
_indiceLength = new int[10, 10];
}
public void OnLoad(Shader _shader) {
for(int i = 0; i < 10; i++) {
for(int j = 0; j < 10; j++) {
InitializeBlock(j, i, worldMap.lands[j, i], _shader);
}
}
}
private void InitializeBlock(int x, int y, Land block, Shader _shader) {
int lenghPacket = 7;
var vertices = block.getVertices();
var indices = block.getIndices();
_indiceLength[x, y] = indices.Length;
// Initialisez le VAO, VBO et EBO pour le bloc à (x, y)...
// Utilisez le code de votre méthode OnLoad originale pour configurer le VAO, VBO et EBO.
int tempVertexArray = GL.GenVertexArray();
GL.BindVertexArray(tempVertexArray);
_vertexArrayObject[x, y] = tempVertexArray;
int tmpVertexBuffer = GL.GenBuffer();
GL.BindBuffer(BufferTarget.ArrayBuffer, tmpVertexBuffer);
GL.BufferData(BufferTarget.ArrayBuffer, vertices.Length * sizeof(float), vertices, BufferUsageHint.StaticDraw);
_vertexBufferObject[x, y] = tmpVertexBuffer;
GL.VertexAttribPointer(0, 3, VertexAttribPointerType.Float, false, lenghPacket * sizeof(float), 0);
int tmpElementBuffer = GL.GenBuffer();
GL.BindBuffer(BufferTarget.ElementArrayBuffer, tmpElementBuffer);
GL.BufferData(BufferTarget.ElementArrayBuffer, indices.Length * sizeof(int), indices, BufferUsageHint.StaticDraw);
_elementBufferObject[x, y] = tmpElementBuffer;
var vertexLocation = _shader.GetAttribLocation("aPos");
GL.EnableVertexAttribArray(vertexLocation);
GL.VertexAttribPointer(vertexLocation, 3, VertexAttribPointerType.Float, false, lenghPacket * sizeof(float), 0);
var colorLocation = _shader.GetAttribLocation("aColor");
GL.EnableVertexAttribArray(colorLocation);
GL.VertexAttribPointer(colorLocation, 4, VertexAttribPointerType.Float, false, lenghPacket * sizeof(float), 3 * sizeof(float));
}
public void Render(Shader shader) {
for (int y = 0; y < 10; y++) {
for (int x = 0; x < 10; x++) {
var model = Matrix4.Identity;//CreateTranslation(x * BlockSize, 0, y * BlockSize); // Ajustez selon votre système de coordonnées
shader.SetMatrix4("model", model);
GL.BindVertexArray(_vertexArrayObject[x, y]);
GL.DrawElements(PrimitiveType.Triangles, _indiceLength[x, y], DrawElementsType.UnsignedInt, 0);
}
}
}
}
}

9
WpfMapView2D/App.xaml Normal file
View file

@ -0,0 +1,9 @@
<Application x:Class="WpfMapView2D.App"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:local="clr-namespace:WpfMapView2D"
StartupUri="MainWindow.xaml">
<Application.Resources>
</Application.Resources>
</Application>

11
WpfMapView2D/App.xaml.cs Normal file
View file

@ -0,0 +1,11 @@
using System.Configuration;
using System.Data;
using System.Windows;
namespace WpfMapView2D;
/// <summary>
/// Interaction logic for App.xaml
/// </summary>
public partial class App : Application {
}

10
WpfMapView2D/AssemblyInfo.cs Normal file
View file

@ -0,0 +1,10 @@
using System.Windows;
[assembly: ThemeInfo(
ResourceDictionaryLocation.None, //where theme specific resource dictionaries are located
//(used if a resource is not found in the page,
// or application resource dictionaries)
ResourceDictionaryLocation.SourceAssembly //where the generic resource dictionary is located
//(used if a resource is not found in the page,
// app, or any theme specific resource dictionaries)
)]

106
WpfMapView2D/Common/Camera.cs Normal file
View file

@ -0,0 +1,106 @@
using OpenTK.Mathematics;
namespace WpfMapView2D.Common {
// This is the camera class as it could be set up after the tutorials on the website.
// It is important to note there are a few ways you could have set up this camera.
// For example, you could have also managed the player input inside the camera class,
// and a lot of the properties could have been made into functions.
// TL;DR: This is just one of many ways in which we could have set up the camera.
// Check out the web version if you don't know why we are doing a specific thing or want to know more about the code.
public class Camera {
// Those vectors are directions pointing outwards from the camera to define how it rotated.
private Vector3 _front = -Vector3.UnitZ;
private Vector3 _up = Vector3.UnitY;
private Vector3 _right = Vector3.UnitX;
// Rotation around the X axis (radians)
private float _pitch;
// Rotation around the Y axis (radians)
private float _yaw = -MathHelper.PiOver2; // Without this, you would be started rotated 90 degrees right.
// The field of view of the camera (radians)
private float _fov = MathHelper.PiOver2;
public Camera(Vector3 position, float aspectRatio) {
Position = position;
AspectRatio = aspectRatio;
}
// The position of the camera
public Vector3 Position { get; set; }
// This is simply the aspect ratio of the viewport, used for the projection matrix.
public float AspectRatio { private get; set; }
public Vector3 Front => _front;
public Vector3 Up => _up;
public Vector3 Right => _right;
// We convert from degrees to radians as soon as the property is set to improve performance.
public float Pitch {
get => MathHelper.RadiansToDegrees(_pitch);
set {
// We clamp the pitch value between -89 and 89 to prevent the camera from going upside down, and a bunch
// of weird "bugs" when you are using euler angles for rotation.
// If you want to read more about this you can try researching a topic called gimbal lock
var angle = MathHelper.Clamp(value, -89f, 89f);
_pitch = MathHelper.DegreesToRadians(angle);
UpdateVectors();
}
}
// We convert from degrees to radians as soon as the property is set to improve performance.
public float Yaw {
get => MathHelper.RadiansToDegrees(_yaw);
set {
_yaw = MathHelper.DegreesToRadians(value);
UpdateVectors();
}
}
// The field of view (FOV) is the vertical angle of the camera view.
// This has been discussed more in depth in a previous tutorial,
// but in this tutorial, you have also learned how we can use this to simulate a zoom feature.
// We convert from degrees to radians as soon as the property is set to improve performance.
public float Fov {
get => MathHelper.RadiansToDegrees(_fov);
set {
var angle = MathHelper.Clamp(value, 1f, 90f);
_fov = MathHelper.DegreesToRadians(angle);
}
}
// Get the view matrix using the amazing LookAt function described more in depth on the web tutorials
public Matrix4 GetViewMatrix() {
return Matrix4.LookAt(Position, Position + _front, _up);
}
// Get the projection matrix using the same method we have used up until this point
public Matrix4 GetProjectionMatrix() {
return Matrix4.CreatePerspectiveFieldOfView(_fov, AspectRatio, 0.01f, 5000f);
}
// This function is going to update the direction vertices using some of the math learned in the web tutorials.
private void UpdateVectors() {
// First, the front matrix is calculated using some basic trigonometry.
_front.X = MathF.Cos(_pitch) * MathF.Cos(_yaw);
_front.Y = MathF.Sin(_pitch);
_front.Z = MathF.Cos(_pitch) * MathF.Sin(_yaw);
// We need to make sure the vectors are all normalized, as otherwise we would get some funky results.
_front = Vector3.Normalize(_front);
// Calculate both the right and the up vector using cross product.
// Note that we are calculating the right from the global up; this behaviour might
// not be what you need for all cameras so keep this in mind if you do not want a FPS camera.
_right = Vector3.Normalize(Vector3.Cross(_front, Vector3.UnitY));
_up = Vector3.Normalize(Vector3.Cross(_right, _front));
}
}
}

181
WpfMapView2D/Common/Shader.cs Normal file
View file

@ -0,0 +1,181 @@
using OpenTK.Graphics.OpenGL4;
using OpenTK.Mathematics;
using System.IO;
namespace WpfMapView2D.Common {
// A simple class meant to help create shaders.
public class Shader {
public readonly int Handle;
private readonly Dictionary<string, int> _uniformLocations;
// This is how you create a simple shader.
// Shaders are written in GLSL, which is a language very similar to C in its semantics.
// The GLSL source is compiled *at runtime*, so it can optimize itself for the graphics card it's currently being used on.
// A commented example of GLSL can be found in shader.vert.
public Shader(string vertPath, string fragPath) {
// There are several different types of shaders, but the only two you need for basic rendering are the vertex and fragment shaders.
// The vertex shader is responsible for moving around vertices, and uploading that data to the fragment shader.
// The vertex shader won't be too important here, but they'll be more important later.
// The fragment shader is responsible for then converting the vertices to "fragments", which represent all the data OpenGL needs to draw a pixel.
// The fragment shader is what we'll be using the most here.
// Load vertex shader and compile
var shaderSource = File.ReadAllText(vertPath);
// GL.CreateShader will create an empty shader (obviously). The ShaderType enum denotes which type of shader will be created.
var vertexShader = GL.CreateShader(ShaderType.VertexShader);
// Now, bind the GLSL source code
GL.ShaderSource(vertexShader, shaderSource);
// And then compile
CompileShader(vertexShader);
// We do the same for the fragment shader.
shaderSource = File.ReadAllText(fragPath);
var fragmentShader = GL.CreateShader(ShaderType.FragmentShader);
GL.ShaderSource(fragmentShader, shaderSource);
CompileShader(fragmentShader);
// These two shaders must then be merged into a shader program, which can then be used by OpenGL.
// To do this, create a program...
Handle = GL.CreateProgram();
// Attach both shaders...
GL.AttachShader(Handle, vertexShader);
GL.AttachShader(Handle, fragmentShader);
// And then link them together.
LinkProgram(Handle);
// When the shader program is linked, it no longer needs the individual shaders attached to it; the compiled code is copied into the shader program.
// Detach them, and then delete them.
GL.DetachShader(Handle, vertexShader);
GL.DetachShader(Handle, fragmentShader);
GL.DeleteShader(fragmentShader);
GL.DeleteShader(vertexShader);
// The shader is now ready to go, but first, we're going to cache all the shader uniform locations.
// Querying this from the shader is very slow, so we do it once on initialization and reuse those values
// later.
// First, we have to get the number of active uniforms in the shader.
GL.GetProgram(Handle, GetProgramParameterName.ActiveUniforms, out var numberOfUniforms);
// Next, allocate the dictionary to hold the locations.
_uniformLocations = new Dictionary<string, int>();
// Loop over all the uniforms,
for (var i = 0; i < numberOfUniforms; i++) {
// get the name of this uniform,
var key = GL.GetActiveUniform(Handle, i, out _, out _);
// get the location,
var location = GL.GetUniformLocation(Handle, key);
// and then add it to the dictionary.
_uniformLocations.Add(key, location);
}
}
private static void CompileShader(int shader) {
// Try to compile the shader
GL.CompileShader(shader);
// Check for compilation errors
GL.GetShader(shader, ShaderParameter.CompileStatus, out var code);
if (code != (int)All.True) {
// We can use `GL.GetShaderInfoLog(shader)` to get information about the error.
var infoLog = GL.GetShaderInfoLog(shader);
throw new Exception($"Error occurred whilst compiling Shader({shader}).\n\n{infoLog}");
}
}
private static void LinkProgram(int program) {
// We link the program
GL.LinkProgram(program);
// Check for linking errors
GL.GetProgram(program, GetProgramParameterName.LinkStatus, out var code);
if (code != (int)All.True) {
// We can use `GL.GetProgramInfoLog(program)` to get information about the error.
throw new Exception($"Error occurred whilst linking Program({program})");
}
}
// A wrapper function that enables the shader program.
public void Use() {
GL.UseProgram(Handle);
}
// The shader sources provided with this project use hardcoded layout(location)-s. If you want to do it dynamically,
// you can omit the layout(location=X) lines in the vertex shader, and use this in VertexAttribPointer instead of the hardcoded values.
public int GetAttribLocation(string attribName) {
return GL.GetAttribLocation(Handle, attribName);
}
// Uniform setters
// Uniforms are variables that can be set by user code, instead of reading them from the VBO.
// You use VBOs for vertex-related data, and uniforms for almost everything else.
// Setting a uniform is almost always the exact same, so I'll explain it here once, instead of in every method:
// 1. Bind the program you want to set the uniform on
// 2. Get a handle to the location of the uniform with GL.GetUniformLocation.
// 3. Use the appropriate GL.Uniform* function to set the uniform.
/// <summary>
/// Set a uniform int on this shader.
/// </summary>
/// <param name="name">The name of the uniform</param>
/// <param name="data">The data to set</param>
public void SetInt(string name, int data) {
GL.UseProgram(Handle);
GL.Uniform1(_uniformLocations[name], data);
}
/// <summary>
/// Set a uniform float on this shader.
/// </summary>
/// <param name="name">The name of the uniform</param>
/// <param name="data">The data to set</param>
public void SetFloat(string name, float data) {
GL.UseProgram(Handle);
GL.Uniform1(_uniformLocations[name], data);
}
/// <summary>
/// Set a uniform Matrix4 on this shader
/// </summary>
/// <param name="name">The name of the uniform</param>
/// <param name="data">The data to set</param>
/// <remarks>
/// <para>
/// The matrix is transposed before being sent to the shader.
/// </para>
/// </remarks>
public void SetMatrix4(string name, Matrix4 data) {
GL.UseProgram(Handle);
GL.UniformMatrix4(_uniformLocations[name], true, ref data);
}
/// <summary>
/// Set a uniform Vector3 on this shader.
/// </summary>
/// <param name="name">The name of the uniform</param>
/// <param name="data">The data to set</param>
public void SetVector2(string name, Vector2 data) {
GL.UseProgram(Handle);
GL.Uniform2(_uniformLocations[name], data);
}
public void SetVector3(string name, Vector3 data) {
GL.UseProgram(Handle);
GL.Uniform3(_uniformLocations[name], data);
}
public void SetVector4(string name, Vector4 data) {
GL.UseProgram(Handle);
GL.Uniform4(_uniformLocations[name], data);
}
}
}

129
WpfMapView2D/Common/Texture.cs Normal file
View file

@ -0,0 +1,129 @@
using OpenTK.Graphics.OpenGL4;
using StbImageSharp;
using System.IO;
namespace WpfMapView2D.Common {
// A helper class, much like Shader, meant to simplify loading textures.
public class Texture {
public readonly int Handle;
public static Texture LoadFromFile(string path) {
// Generate handle
int handle = GL.GenTexture();
// Bind the handle
GL.ActiveTexture(TextureUnit.Texture0);
GL.BindTexture(TextureTarget.Texture2D, handle);
// For this example, we're going to use .NET's built-in System.Drawing library to load textures.
// OpenGL has it's texture origin in the lower left corner instead of the top left corner,
// so we tell StbImageSharp to flip the image when loading.
StbImage.stbi_set_flip_vertically_on_load(1);
// Here we open a stream to the file and pass it to StbImageSharp to load.
using (Stream stream = File.OpenRead(path)) {
ImageResult image = ImageResult.FromStream(stream, ColorComponents.RedGreenBlueAlpha);
// Now that our pixels are prepared, it's time to generate a texture. We do this with GL.TexImage2D.
// Arguments:
// The type of texture we're generating. There are various different types of textures, but the only one we need right now is Texture2D.
// Level of detail. We can use this to start from a smaller mipmap (if we want), but we don't need to do that, so leave it at 0.
// Target format of the pixels. This is the format OpenGL will store our image with.
// Width of the image
// Height of the image.
// Border of the image. This must always be 0; it's a legacy parameter that Khronos never got rid of.
// The format of the pixels, explained above. Since we loaded the pixels as RGBA earlier, we need to use PixelFormat.Rgba.
// Data type of the pixels.
// And finally, the actual pixels.
GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, image.Width, image.Height, 0, PixelFormat.Rgba, PixelType.UnsignedByte, image.Data);
}
// Now that our texture is loaded, we can set a few settings to affect how the image appears on rendering.
// First, we set the min and mag filter. These are used for when the texture is scaled down and up, respectively.
// Here, we use Linear for both. This means that OpenGL will try to blend pixels, meaning that textures scaled too far will look blurred.
// You could also use (amongst other options) Nearest, which just grabs the nearest pixel, which makes the texture look pixelated if scaled too far.
// NOTE: The default settings for both of these are LinearMipmap. If you leave these as default but don't generate mipmaps,
// your image will fail to render at all (usually resulting in pure black instead).
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Linear);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear);
// Now, set the wrapping mode. S is for the X axis, and T is for the Y axis.
// We set this to Repeat so that textures will repeat when wrapped. Not demonstrated here since the texture coordinates exactly match
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int)TextureWrapMode.Repeat);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int)TextureWrapMode.Repeat);
// Next, generate mipmaps.
// Mipmaps are smaller copies of the texture, scaled down. Each mipmap level is half the size of the previous one
// Generated mipmaps go all the way down to just one pixel.
// OpenGL will automatically switch between mipmaps when an object gets sufficiently far away.
// This prevents moiré effects, as well as saving on texture bandwidth.
// Here you can see and read about the morié effect https://en.wikipedia.org/wiki/Moir%C3%A9_pattern
// Here is an example of mips in action https://en.wikipedia.org/wiki/File:Mipmap_Aliasing_Comparison.png
GL.GenerateMipmap(GenerateMipmapTarget.Texture2D);
return new Texture(handle);
}
public static Texture LoadFromArray(string[] paths) {
// Générer un identifiant de texture
int handle = GL.GenTexture();
// Activer la texture
GL.ActiveTexture(TextureUnit.Texture0);
GL.BindTexture(TextureTarget.Texture2DArray, handle);
// Ici, nous supposons que toutes les images ont les mêmes dimensions et le même format
// Charger la première image pour obtenir les dimensions
ImageResult firstImage = ImageResult.FromStream(File.OpenRead(paths[0]), ColorComponents.RedGreenBlueAlpha);
int width = firstImage.Width;
int height = firstImage.Height;
// Initialiser la texture 2D array sans lui passer de données pour l'instant
GL.TexImage3D(TextureTarget.Texture2DArray, 0, PixelInternalFormat.Rgba, width, height, paths.Length, 0, PixelFormat.Rgba, PixelType.UnsignedByte, IntPtr.Zero);
// Charger chaque texture dans l'array
for (int i = 0; i < paths.Length; i++) {
using (Stream stream = File.OpenRead(paths[i])) {
ImageResult image = ImageResult.FromStream(stream, ColorComponents.RedGreenBlueAlpha);
GL.TexSubImage3D(TextureTarget.Texture2DArray, 0, 0, 0, i, width, height, 1, PixelFormat.Rgba, PixelType.UnsignedByte, image.Data);
}
}
// Paramètres de texture
GL.TexParameter(TextureTarget.Texture2DArray, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Linear);
GL.TexParameter(TextureTarget.Texture2DArray, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear);
GL.TexParameter(TextureTarget.Texture2DArray, TextureParameterName.TextureWrapS, (int)TextureWrapMode.ClampToEdge);
GL.TexParameter(TextureTarget.Texture2DArray, TextureParameterName.TextureWrapT, (int)TextureWrapMode.ClampToEdge);
// Générer des mipmaps pour la texture array
GL.GenerateMipmap(GenerateMipmapTarget.Texture2DArray);
return new Texture(handle);
}
public Texture(int glHandle) {
Handle = glHandle;
}
// Activate texture
// Multiple textures can be bound, if your shader needs more than just one.
// If you want to do that, use GL.ActiveTexture to set which slot GL.BindTexture binds to.
// The OpenGL standard requires that there be at least 16, but there can be more depending on your graphics card.
public void Use(TextureUnit unit) {
GL.ActiveTexture(unit);
GL.BindTexture(TextureTarget.Texture2D, Handle);
}
public void UseArray(TextureUnit unit) {
GL.ActiveTexture(unit);
GL.BindTexture(TextureTarget.Texture2DArray, Handle);
}
public void Assign(int shader, int i) {
int location = GL.GetUniformLocation(shader, "textures[" + i.ToString() + "]");
GL.Uniform1(location, i);
}
}
}

20
WpfMapView2D/MainWindow.xaml Normal file
View file

@ -0,0 +1,20 @@
<Window x:Class="WpfMapView2D.MainWindow"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
xmlns:glWpfControl="clr-namespace:OpenTK.Wpf;assembly=GLWpfControl"
xmlns:local="clr-namespace:WpfMapView2D"
mc:Ignorable="d"
Title="MainWindow" Height="450" Width="800">
<Grid>
<Grid Margin="0,0,0,20">
<glWpfControl:GLWpfControl
x:Name="OpenTkControl"
Render="OpenTkControl_OnRender" MouseLeftButtonDown="OpenTkControl_MouseLeftButtonDown"
/>
</Grid>
<StatusBar Name="statusBarData" Height="20" VerticalAlignment="Bottom"/>
</Grid>
</Window>

42
WpfMapView2D/MainWindow.xaml.cs Normal file
View file

@ -0,0 +1,42 @@
using OpenTK.Graphics.OpenGL4;
using OpenTK.Mathematics;
using OpenTK.Wpf;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using WpfMapView2D.Common;
namespace WpfMapView2D;
/// <summary>
/// Interaction logic for MainWindow.xaml
/// </summary>
public partial class MainWindow : Window {
public Camera _camera;
public MainWindow() {
InitializeComponent();
var settings = new GLWpfControlSettings {
MajorVersion = 4,
MinorVersion = 0
};
_camera = new Camera(Vector3.UnitY * 300, (float)this.Width / (float)this.Height);
_camera.Fov = 60;
OpenTkControl.Start(settings);
}
private void OpenTkControl_OnRender(TimeSpan delta) {
GL.ClearColor(Color4.Blue);
GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
}
private void OpenTkControl_MouseLeftButtonDown(object sender, MouseButtonEventArgs e) {
}
}

16
WpfMapView2D/WpfMapView2D.csproj Normal file
View file

@ -0,0 +1,16 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>WinExe</OutputType>
<TargetFramework>net7.0-windows</TargetFramework>
<Nullable>enable</Nullable>
<ImplicitUsings>enable</ImplicitUsings>
<UseWPF>true</UseWPF>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="OpenTK.GLWpfControl" Version="4.2.3" />
<PackageReference Include="StbImageSharp" Version="2.27.13" />
</ItemGroup>
</Project>