MulAvailable
This commit is contained in:
Nitload
@@ -1,43 +0,0 @@
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
// file="IImageProvider.cs"
|
||||
// Project: StgSharp
|
||||
// AuthorGroup: Nitload Space
|
||||
// Copyright (c) Nitload Space. All rights reserved.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the “Software”), to deal in the Software without restriction,
|
||||
// including without limitation the rights to use, copy, modify, merge,
|
||||
// publish, distribute, sublicense, and/or sell copies of the Software,
|
||||
// and to permit persons to whom the Software is furnished to do so,
|
||||
// subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and
|
||||
// this permission notice shall be included in all copies
|
||||
// or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED “AS IS”,
|
||||
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
// ARISING FROM, OUT OF OR IN CONNECTION WITH
|
||||
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
//
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Text;
|
||||
|
||||
namespace StgSharp.Graphics
|
||||
{
|
||||
public interface IImageProvider
|
||||
{
|
||||
|
||||
Image ProvideImage();
|
||||
|
||||
}
|
||||
}
|
||||
@@ -1,86 +0,0 @@
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
// file="ImageHelper.cs"
|
||||
// Project: StgSharp
|
||||
// AuthorGroup: Nitload Space
|
||||
// Copyright (c) Nitload Space. All rights reserved.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the “Software”), to deal in the Software without restriction,
|
||||
// including without limitation the rights to use, copy, modify, merge,
|
||||
// publish, distribute, sublicense, and/or sell copies of the Software,
|
||||
// and to permit persons to whom the Software is furnished to do so,
|
||||
// subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and
|
||||
// this permission notice shall be included in all copies
|
||||
// or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED “AS IS”,
|
||||
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
// ARISING FROM, OUT OF OR IN CONNECTION WITH
|
||||
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
//
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.ComponentModel;
|
||||
using System.Text;
|
||||
|
||||
namespace StgSharp.Graphics
|
||||
{
|
||||
public static class ImageHelper
|
||||
{
|
||||
|
||||
public static void Resize( Image i, int width, int height, ImageMovement move )
|
||||
{
|
||||
if( i == null ) {
|
||||
throw new ArgumentNullException( nameof( i ) );
|
||||
}
|
||||
if( i.Size == (width, height) ) {
|
||||
return;
|
||||
}
|
||||
if( !Enum.IsDefined( typeof( ImageMovement ), move ) ) {
|
||||
throw new InvalidEnumArgumentException( nameof( move ) );
|
||||
}
|
||||
byte[] oldData = i.Data;
|
||||
i.Data = new byte[width * height * i.PixelSize];
|
||||
i.Height = height;
|
||||
i.Width = width;
|
||||
i.PixelUpdateCount++;
|
||||
switch( move )
|
||||
{
|
||||
case ImageMovement.Discard:
|
||||
break;
|
||||
case ImageMovement.Top:
|
||||
break;
|
||||
default:
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
[Flags]
|
||||
public enum ImageMovement
|
||||
{
|
||||
#pragma warning disable CA1008
|
||||
Discard = 0,
|
||||
#pragma warning restore CA1008
|
||||
Top = 1,
|
||||
Bottom = 2,
|
||||
Left = 4,
|
||||
Right = 8,
|
||||
TopLeft = Top | Left,
|
||||
BottomLeft = Bottom | Left,
|
||||
TopRight = Top | Right,
|
||||
BottomRight = Bottom | Right,
|
||||
|
||||
}
|
||||
}
|
||||
@@ -1,89 +0,0 @@
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
// file="BufferObjectBase.cs"
|
||||
// Project: StgSharp
|
||||
// AuthorGroup: Nitload Space
|
||||
// Copyright (c) Nitload Space. All rights reserved.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the “Software”), to deal in the Software without restriction,
|
||||
// including without limitation the rights to use, copy, modify, merge,
|
||||
// publish, distribute, sublicense, and/or sell copies of the Software,
|
||||
// and to permit persons to whom the Software is furnished to do so,
|
||||
// subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and
|
||||
// this permission notice shall be included in all copies
|
||||
// or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED “AS IS”,
|
||||
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
// ARISING FROM, OUT OF OR IN CONNECTION WITH
|
||||
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
//
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
using StgSharp.Graphics.OpenGL;
|
||||
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Text;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace StgSharp.Graphics
|
||||
{
|
||||
/// <summary>
|
||||
/// Interface of all kinds OpenGL Buffer objects
|
||||
/// </summary>
|
||||
public abstract class BufferObjectBase : IDisposable
|
||||
{
|
||||
|
||||
protected GlHandle[] _bufferHandle;
|
||||
protected RenderStream binding;
|
||||
|
||||
/// <summary>
|
||||
/// Get the only handle to one of the Object instance
|
||||
/// </summary>
|
||||
/// <param _label="index">
|
||||
///
|
||||
/// </param>
|
||||
/// <returns>
|
||||
///
|
||||
/// </returns>
|
||||
public GlHandle this[ int index ] => _bufferHandle[ index ];
|
||||
|
||||
/// <summary>
|
||||
/// Bind a Buffer instance to OpenGL
|
||||
/// </summary>
|
||||
/// <param _label="index">
|
||||
/// Index of handle of the object in this instance to be bind
|
||||
/// </param>
|
||||
public abstract void Bind( int index );
|
||||
|
||||
public void Dispose()
|
||||
{
|
||||
Dispose( disposing: true );
|
||||
GC.SuppressFinalize( this );
|
||||
}
|
||||
|
||||
/// <inheritdoc />
|
||||
public override string ToString()
|
||||
{
|
||||
return $"This is a {GetType().FullName}, containing {_bufferHandle.Length} buffer handles: {_bufferHandle.ToString()}.";
|
||||
}
|
||||
|
||||
protected abstract void Dispose( bool disposing );
|
||||
|
||||
~BufferObjectBase()
|
||||
{
|
||||
Dispose( disposing: false );
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,336 @@
|
||||
//-----------------------------------------------------------------------
|
||||
// -----------------------------------------------------------------------
|
||||
// file="FrameworkConstant"
|
||||
// Project: StgSharp
|
||||
// AuthorGroup: Nitload
|
||||
// Copyright (c) Nitload. All rights reserved.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
// of this software and associated documentation files (the "Software"), to deal
|
||||
// in the Software without restriction, including without limitation the rights
|
||||
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
// copies of the Software, and to permit persons to whom the Software is
|
||||
// furnished to do so, subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be included in all
|
||||
// copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
// SOFTWARE.
|
||||
//
|
||||
// -----------------------------------------------------------------------
|
||||
// -----------------------------------------------------------------------
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Text;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace StgSharp.Graphics
|
||||
{
|
||||
public static class FrameworkConstant
|
||||
{
|
||||
|
||||
#region glfw
|
||||
|
||||
public const int VERSION_MAJOR = 3;
|
||||
public const int VERSION_MINOR = 3;
|
||||
public const int VERSION_REVISION = 8;
|
||||
public const int TRUE = 1;
|
||||
public const int FALSE = 0;
|
||||
public const int RELEASE = 0;
|
||||
public const int PRESS = 1;
|
||||
public const int REPEAT = 2;
|
||||
public const int HAT_CENTERED = 0;
|
||||
public const int HAT_UP = 1;
|
||||
public const int HAT_RIGHT = 2;
|
||||
public const int HAT_DOWN = 4;
|
||||
public const int HAT_LEFT = 8;
|
||||
public const int HAT_RIGHT_UP = HAT_RIGHT | HAT_UP;
|
||||
public const int HAT_RIGHT_DOWN = HAT_RIGHT | HAT_DOWN;
|
||||
public const int HAT_LEFT_UP = HAT_LEFT | HAT_UP;
|
||||
public const int HAT_LEFT_DOWN = HAT_LEFT | HAT_DOWN;
|
||||
public const int KEY_UNKNOWN = -1;
|
||||
public const int KEY_SPACE = 32;
|
||||
public const int KEY_APOSTROPHE = 39;
|
||||
public const int KEY_COMMA = 44;
|
||||
public const int KEY_MINUS = 45;
|
||||
public const int KEY_PERIOD = 46;
|
||||
public const int KEY_SLASH = 47;
|
||||
public const int KEY_0 = 48;
|
||||
public const int KEY_1 = 49;
|
||||
public const int KEY_2 = 50;
|
||||
public const int KEY_3 = 51;
|
||||
public const int KEY_4 = 52;
|
||||
public const int KEY_5 = 53;
|
||||
public const int KEY_6 = 54;
|
||||
public const int KEY_7 = 55;
|
||||
public const int KEY_8 = 56;
|
||||
public const int KEY_9 = 57;
|
||||
public const int KEY_SEMICOLON = 59;
|
||||
public const int KEY_EQUAL = 61;
|
||||
public const int KEY_A = 65;
|
||||
public const int KEY_B = 66;
|
||||
public const int KEY_C = 67;
|
||||
public const int KEY_D = 68;
|
||||
public const int KEY_E = 69;
|
||||
public const int KEY_F = 70;
|
||||
public const int KEY_G = 71;
|
||||
public const int KEY_H = 72;
|
||||
public const int KEY_I = 73;
|
||||
public const int KEY_J = 74;
|
||||
public const int KEY_K = 75;
|
||||
public const int KEY_L = 76;
|
||||
public const int KEY_M = 77;
|
||||
public const int KEY_N = 78;
|
||||
public const int KEY_O = 79;
|
||||
public const int KEY_P = 80;
|
||||
public const int KEY_Q = 81;
|
||||
public const int KEY_R = 82;
|
||||
public const int KEY_S = 83;
|
||||
public const int KEY_T = 84;
|
||||
public const int KEY_U = 85;
|
||||
public const int KEY_V = 86;
|
||||
public const int KEY_W = 87;
|
||||
public const int KEY_X = 88;
|
||||
public const int KEY_Y = 89;
|
||||
public const int KEY_Z = 90;
|
||||
public const int KEY_LEFT_BRACKET = 91;
|
||||
public const int KEY_BACKSLASH = 92;
|
||||
public const int KEY_RIGHT_BRACKET = 93;
|
||||
public const int KEY_GRAVE_ACCENT = 96;
|
||||
public const int KEY_WORLD_1 = 161;
|
||||
public const int KEY_WORLD_2 = 162;
|
||||
public const int KEY_ESCAPE = 256;
|
||||
public const int KEY_ENTER = 257;
|
||||
public const int KEY_TAB = 258;
|
||||
public const int KEY_BACKSPACE = 259;
|
||||
public const int KEY_INSERT = 260;
|
||||
public const int KEY_DELETE = 261;
|
||||
public const int KEY_RIGHT = 262;
|
||||
public const int KEY_LEFT = 263;
|
||||
public const int KEY_DOWN = 264;
|
||||
public const int KEY_UP = 265;
|
||||
public const int KEY_PAGE_UP = 266;
|
||||
public const int KEY_PAGE_DOWN = 267;
|
||||
public const int KEY_HOME = 268;
|
||||
public const int KEY_END = 269;
|
||||
public const int KEY_CAPS_LOCK = 280;
|
||||
public const int KEY_SCROLL_LOCK = 281;
|
||||
public const int KEY_NUM_LOCK = 282;
|
||||
public const int KEY_PRINT_SCREEN = 283;
|
||||
public const int KEY_PAUSE = 284;
|
||||
public const int KEY_F1 = 290;
|
||||
public const int KEY_F2 = 291;
|
||||
public const int KEY_F3 = 292;
|
||||
public const int KEY_F4 = 293;
|
||||
public const int KEY_F5 = 294;
|
||||
public const int KEY_F6 = 295;
|
||||
public const int KEY_F7 = 296;
|
||||
public const int KEY_F8 = 297;
|
||||
public const int KEY_F9 = 298;
|
||||
public const int KEY_F10 = 299;
|
||||
public const int KEY_F11 = 300;
|
||||
public const int KEY_F12 = 301;
|
||||
public const int KEY_F13 = 302;
|
||||
public const int KEY_F14 = 303;
|
||||
public const int KEY_F15 = 304;
|
||||
public const int KEY_F16 = 305;
|
||||
public const int KEY_F17 = 306;
|
||||
public const int KEY_F18 = 307;
|
||||
public const int KEY_F19 = 308;
|
||||
public const int KEY_F20 = 309;
|
||||
public const int KEY_F21 = 310;
|
||||
public const int KEY_F22 = 311;
|
||||
public const int KEY_F23 = 312;
|
||||
public const int KEY_F24 = 313;
|
||||
public const int KEY_F25 = 314;
|
||||
public const int KEY_KP_0 = 320;
|
||||
public const int KEY_KP_1 = 321;
|
||||
public const int KEY_KP_2 = 322;
|
||||
public const int KEY_KP_3 = 323;
|
||||
public const int KEY_KP_4 = 324;
|
||||
public const int KEY_KP_5 = 325;
|
||||
public const int KEY_KP_6 = 326;
|
||||
public const int KEY_KP_7 = 327;
|
||||
public const int KEY_KP_8 = 328;
|
||||
public const int KEY_KP_9 = 329;
|
||||
public const int KEY_KP_DECIMAL = 330;
|
||||
public const int KEY_KP_DIVIDE = 331;
|
||||
public const int KEY_KP_MULTIPLY = 332;
|
||||
public const int KEY_KP_SUBTRACT = 333;
|
||||
public const int KEY_KP_ADD = 334;
|
||||
public const int KEY_KP_ENTER = 335;
|
||||
public const int KEY_KP_EQUAL = 336;
|
||||
public const int KEY_LEFT_SHIFT = 340;
|
||||
public const int KEY_LEFT_CONTROL = 341;
|
||||
public const int KEY_LEFT_ALT = 342;
|
||||
public const int KEY_LEFT_SUPER = 343;
|
||||
public const int KEY_RIGHT_SHIFT = 344;
|
||||
public const int KEY_RIGHT_CONTROL = 345;
|
||||
public const int KEY_RIGHT_ALT = 346;
|
||||
public const int KEY_RIGHT_SUPER = 347;
|
||||
public const int KEY_MENU = 348;
|
||||
public const int KEY_LAST = KEY_MENU;
|
||||
public const int MOD_SHIFT = 0x0001;
|
||||
public const int MOD_CONTROL = 0x0002;
|
||||
public const int MOD_ALT = 0x0004;
|
||||
public const int MOD_SUPER = 0x0008;
|
||||
public const int MOD_CAPS_LOCK = 0x0010;
|
||||
public const int MOD_NUM_LOCK = 0x0020;
|
||||
public const int MOUSE_BUTTON_1 = 0;
|
||||
public const int MOUSE_BUTTON_2 = 1;
|
||||
public const int MOUSE_BUTTON_3 = 2;
|
||||
public const int MOUSE_BUTTON_4 = 3;
|
||||
public const int MOUSE_BUTTON_5 = 4;
|
||||
public const int MOUSE_BUTTON_6 = 5;
|
||||
public const int MOUSE_BUTTON_7 = 6;
|
||||
public const int MOUSE_BUTTON_8 = 7;
|
||||
public const int MOUSE_BUTTON_LAST = MOUSE_BUTTON_8;
|
||||
public const int MOUSE_BUTTON_LEFT = MOUSE_BUTTON_1;
|
||||
public const int MOUSE_BUTTON_RIGHT = MOUSE_BUTTON_2;
|
||||
public const int MOUSE_BUTTON_MIDDLE = MOUSE_BUTTON_3;
|
||||
public const int JOYSTICK_1 = 0;
|
||||
public const int JOYSTICK_2 = 1;
|
||||
public const int JOYSTICK_3 = 2;
|
||||
public const int JOYSTICK_4 = 3;
|
||||
public const int JOYSTICK_5 = 4;
|
||||
public const int JOYSTICK_6 = 5;
|
||||
public const int JOYSTICK_7 = 6;
|
||||
public const int JOYSTICK_8 = 7;
|
||||
public const int JOYSTICK_9 = 8;
|
||||
public const int JOYSTICK_10 = 9;
|
||||
public const int JOYSTICK_11 = 10;
|
||||
public const int JOYSTICK_12 = 11;
|
||||
public const int JOYSTICK_13 = 12;
|
||||
public const int JOYSTICK_14 = 13;
|
||||
public const int JOYSTICK_15 = 14;
|
||||
public const int JOYSTICK_16 = 15;
|
||||
public const int JOYSTICK_LAST = JOYSTICK_16;
|
||||
public const int GAMEPAD_BUTTON_A = 0;
|
||||
public const int GAMEPAD_BUTTON_B = 1;
|
||||
public const int GAMEPAD_BUTTON_X = 2;
|
||||
public const int GAMEPAD_BUTTON_Y = 3;
|
||||
public const int GAMEPAD_BUTTON_LEFT_BUMPER = 4;
|
||||
public const int GAMEPAD_BUTTON_RIGHT_BUMPER = 5;
|
||||
public const int GAMEPAD_BUTTON_BACK = 6;
|
||||
public const int GAMEPAD_BUTTON_START = 7;
|
||||
public const int GAMEPAD_BUTTON_GUIDE = 8;
|
||||
public const int GAMEPAD_BUTTON_LEFT_THUMB = 9;
|
||||
public const int GAMEPAD_BUTTON_RIGHT_THUMB = 10;
|
||||
public const int GAMEPAD_BUTTON_DPAD_UP = 11;
|
||||
public const int GAMEPAD_BUTTON_DPAD_RIGHT = 12;
|
||||
public const int GAMEPAD_BUTTON_DPAD_DOWN = 13;
|
||||
public const int GAMEPAD_BUTTON_DPAD_LEFT = 14;
|
||||
public const int GAMEPAD_BUTTON_LAST = GAMEPAD_BUTTON_DPAD_LEFT;
|
||||
public const int GAMEPAD_BUTTON_CROSS = GAMEPAD_BUTTON_A;
|
||||
public const int GAMEPAD_BUTTON_CIRCLE = GAMEPAD_BUTTON_B;
|
||||
public const int GAMEPAD_BUTTON_SQUARE = GAMEPAD_BUTTON_X;
|
||||
public const int GAMEPAD_BUTTON_TRIANGLE = GAMEPAD_BUTTON_Y;
|
||||
public const int GAMEPAD_AXIS_LEFT_X = 0;
|
||||
public const int GAMEPAD_AXIS_LEFT_Y = 1;
|
||||
public const int GAMEPAD_AXIS_RIGHT_X = 2;
|
||||
public const int GAMEPAD_AXIS_RIGHT_Y = 3;
|
||||
public const int GAMEPAD_AXIS_LEFT_TRIGGER = 4;
|
||||
public const int GAMEPAD_AXIS_RIGHT_TRIGGER = 5;
|
||||
public const int GAMEPAD_AXIS_LAST = GAMEPAD_AXIS_RIGHT_TRIGGER;
|
||||
public const int NO_ERROR = 0;
|
||||
public const int NOT_INITIALIZED = 0x00010001;
|
||||
public const int NO_CURRENT_CONTEXT = 0x00010002;
|
||||
public const int INVALID_ENUM = 0x00010003;
|
||||
public const int INVALID_VALUE = 0x00010004;
|
||||
public const int OUT_OF_MEMORY = 0x00010005;
|
||||
public const int API_UNAVAILABLE = 0x00010006;
|
||||
public const int VERSION_UNAVAILABLE = 0x00010007;
|
||||
public const int PLATFORM_ERROR = 0x00010008;
|
||||
public const int FORMAT_UNAVAILABLE = 0x00010009;
|
||||
public const int NO_WINDOW_CONTEXT = 0x0001000A;
|
||||
public const int FOCUSED = 0x00020001;
|
||||
public const int ICONIFIED = 0x00020002;
|
||||
public const int RESIZABLE = 0x00020003;
|
||||
public const int VISIBLE = 0x00020004;
|
||||
public const int DECORATED = 0x00020005;
|
||||
public const int AUTO_ICONIFY = 0x00020006;
|
||||
public const int FLOATING = 0x00020007;
|
||||
public const int MAXIMIZED = 0x00020008;
|
||||
public const int CENTER_CURSOR = 0x00020009;
|
||||
public const int TRANSPARENT_FRAMEBUFFER = 0x0002000A;
|
||||
public const int HOVERED = 0x0002000B;
|
||||
public const int FOCUS_ON_SHOW = 0x0002000C;
|
||||
public const int RED_BITS = 0x00021001;
|
||||
public const int GREEN_BITS = 0x00021002;
|
||||
public const int BLUE_BITS = 0x00021003;
|
||||
public const int ALPHA_BITS = 0x00021004;
|
||||
public const int DEPTH_BITS = 0x00021005;
|
||||
public const int STENCIL_BITS = 0x00021006;
|
||||
public const int ACCUM_RED_BITS = 0x00021007;
|
||||
public const int ACCUM_GREEN_BITS = 0x00021008;
|
||||
public const int ACCUM_BLUE_BITS = 0x00021009;
|
||||
public const int ACCUM_ALPHA_BITS = 0x0002100A;
|
||||
public const int AUX_BUFFERS = 0x0002100B;
|
||||
public const int STEREO = 0x0002100C;
|
||||
public const int SAMPLES = 0x0002100D;
|
||||
public const int SRGB_CAPABLE = 0x0002100E;
|
||||
public const int REFRESH_RATE = 0x0002100F;
|
||||
public const int DOUBLEBUFFER = 0x00021010;
|
||||
public const int CLIENT_API = 0x00022001;
|
||||
public const int CONTEXT_VERSION_MAJOR = 0x00022002;
|
||||
public const int CONTEXT_VERSION_MINOR = 0x00022003;
|
||||
public const int CONTEXT_REVISION = 0x00022004;
|
||||
public const int CONTEXT_ROBUSTNESS = 0x00022005;
|
||||
public const int OPENGL_FORWARD_COMPAT = 0x00022006;
|
||||
public const int OPENGL_DEBUG_CONTEXT = 0x00022007;
|
||||
public const int OPENGL_PROFILE = 0x00022008;
|
||||
public const int CONTEXT_RELEASE_BEHAVIOR = 0x00022009;
|
||||
public const int CONTEXT_NO_ERROR = 0x0002200A;
|
||||
public const int CONTEXT_CREATION_API = 0x0002200B;
|
||||
public const int SCALE_TO_MONITOR = 0x0002200C;
|
||||
public const int COCOA_RETINA_FRAMEBUFFER = 0x00023001;
|
||||
public const int COCOA_FRAME_NAME = 0x00023002;
|
||||
public const int COCOA_GRAPHICS_SWITCHING = 0x00023003;
|
||||
public const int X11_CLASS_NAME = 0x00024001;
|
||||
public const int X11_INSTANCE_NAME = 0x00024002;
|
||||
public const int NO_API = 0;
|
||||
public const int OPENGL_API = 0x00030001;
|
||||
public const int OPENGL_ES_API = 0x00030002;
|
||||
public const int NO_ROBUSTNESS = 0;
|
||||
public const int NO_RESET_NOTIFICATION = 0x00031001;
|
||||
public const int LOSE_CONTEXT_ON_RESET = 0x00031002;
|
||||
public const int OPENGL_ANY_PROFILE = 0;
|
||||
public const int OPENGL_CORE_PROFILE = 0x00032001;
|
||||
public const int OPENGL_COMPAT_PROFILE = 0x00032002;
|
||||
public const int CURSOR = 0x00033001;
|
||||
public const int STICKY_KEYS = 0x00033002;
|
||||
public const int STICKY_MOUSE_BUTTONS = 0x00033003;
|
||||
public const int LOCK_KEY_MODS = 0x00033004;
|
||||
public const int RAW_MOUSE_MOTION = 0x00033005;
|
||||
public const int CURSOR_NORMAL = 0x00034001;
|
||||
public const int CURSOR_HIDDEN = 0x00034002;
|
||||
public const int CURSOR_DISABLED = 0x00034003;
|
||||
public const int ANY_RELEASE_BEHAVIOR = 0;
|
||||
public const int RELEASE_BEHAVIOR_FLUSH = 0x00035001;
|
||||
public const int RELEASE_BEHAVIOR_NONE = 0x00035002;
|
||||
public const int NATIVE_CONTEXT_API = 0x00036001;
|
||||
public const int EGL_CONTEXT_API = 0x00036002;
|
||||
public const int OSMESA_CONTEXT_API = 0x00036003;
|
||||
public const int ARROW_CURSOR = 0x00036001;
|
||||
public const int IBEAM_CURSOR = 0x00036002;
|
||||
public const int CROSSHAIR_CURSOR = 0x00036003;
|
||||
public const int HAND_CURSOR = 0x00036004;
|
||||
public const int HRESIZE_CURSOR = 0x00036005;
|
||||
public const int VRESIZE_CURSOR = 0x00036006;
|
||||
public const int CONNECTED = 0x00040001;
|
||||
public const int DISCONNECTED = 0x00040002;
|
||||
public const int JOYSTICK_HAT_BUTTONS = 0x00050001;
|
||||
public const int COCOA_CHDIR_RESOURCES = 0x00051001;
|
||||
public const int COCOA_MENUBAR = 0x00051002;
|
||||
public const int DONT_CARE = -1;
|
||||
|
||||
#endregion
|
||||
}
|
||||
}
|
||||
@@ -1,46 +0,0 @@
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
// file="IGraphicAPIs.cs"
|
||||
// Project: StgSharp
|
||||
// AuthorGroup: Nitload Space
|
||||
// Copyright (c) Nitload Space. All rights reserved.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the “Software”), to deal in the Software without restriction,
|
||||
// including without limitation the rights to use, copy, modify, merge,
|
||||
// publish, distribute, sublicense, and/or sell copies of the Software,
|
||||
// and to permit persons to whom the Software is furnished to do so,
|
||||
// subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and
|
||||
// this permission notice shall be included in all copies
|
||||
// or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED “AS IS”,
|
||||
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
// ARISING FROM, OUT OF OR IN CONNECTION WITH
|
||||
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
//
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Text;
|
||||
|
||||
namespace StgSharp.Graphics
|
||||
{
|
||||
public interface IGraphicAPIs
|
||||
{
|
||||
|
||||
public IntPtr GraphicApiPackageHandle
|
||||
{
|
||||
get;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
@@ -1,210 +0,0 @@
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
// file="Image.cs"
|
||||
// Project: StgSharp
|
||||
// AuthorGroup: Nitload Space
|
||||
// Copyright (c) Nitload Space. All rights reserved.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the “Software”), to deal in the Software without restriction,
|
||||
// including without limitation the rights to use, copy, modify, merge,
|
||||
// publish, distribute, sublicense, and/or sell copies of the Software,
|
||||
// and to permit persons to whom the Software is furnished to do so,
|
||||
// subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and
|
||||
// this permission notice shall be included in all copies
|
||||
// or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED “AS IS”,
|
||||
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
// ARISING FROM, OUT OF OR IN CONNECTION WITH
|
||||
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
//
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
using StgSharp.Graphics.OpenGL;
|
||||
using StgSharp.Internal;
|
||||
using StgSharp.Math;
|
||||
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.IO;
|
||||
using System.Linq;
|
||||
using System.Reflection;
|
||||
using System.Runtime.CompilerServices;
|
||||
using System.Runtime.InteropServices;
|
||||
using System.Text;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace StgSharp.Graphics
|
||||
{
|
||||
public class Image : ISSDSerializable, IImageProvider
|
||||
{
|
||||
|
||||
private byte[] _data;
|
||||
private ImageInfo _rawInfo;
|
||||
private int _pixelUpdateCount = 0;
|
||||
|
||||
internal unsafe Image()
|
||||
{
|
||||
_rawInfo = new ImageInfo();
|
||||
}
|
||||
|
||||
internal Image( ImageInfo information )
|
||||
{
|
||||
_rawInfo = information;
|
||||
_data = Array.Empty<byte>();
|
||||
|
||||
//int length = _rawInfo.width * _rawInfo.height * _rawInfo.channel;
|
||||
}
|
||||
|
||||
public (int width, int height) Size
|
||||
{
|
||||
get => (_rawInfo.Width, _rawInfo.Height);
|
||||
}
|
||||
|
||||
public byte[] PixelBuffer
|
||||
{
|
||||
get
|
||||
{
|
||||
if( ( _data.Length == 0 ) || ( _data == null ) )
|
||||
{
|
||||
GetBytes();
|
||||
return _data!;
|
||||
}
|
||||
return _data;
|
||||
}
|
||||
}
|
||||
|
||||
public ImageChannel Channel => _rawInfo.Channel;
|
||||
|
||||
/// <summary>
|
||||
/// Hash code of time pixels updated last time.
|
||||
/// </summary>
|
||||
public int PixelUpdateCount
|
||||
{
|
||||
get => _pixelUpdateCount;
|
||||
internal set => _pixelUpdateCount = value;
|
||||
}
|
||||
|
||||
public int ChannelCount => _rawInfo.ChannelCount;
|
||||
|
||||
public int Height
|
||||
{
|
||||
get => _rawInfo.Height;
|
||||
internal set => _rawInfo.Height = value;
|
||||
}
|
||||
|
||||
public int Width
|
||||
{
|
||||
get => _rawInfo.Width;
|
||||
internal set => _rawInfo.Width = value;
|
||||
}
|
||||
|
||||
public int PixelSize => ImageInfo.GetPixelSize( _rawInfo.pixelLayout, _rawInfo.Channel );
|
||||
|
||||
public PixelChannelLayout PixelLayout
|
||||
{
|
||||
get => _rawInfo.pixelLayout;
|
||||
private set => _rawInfo.pixelLayout = value;
|
||||
}
|
||||
|
||||
public SerializableTypeCode SSDTypeCode => SerializableTypeCode.PixelImage;
|
||||
|
||||
internal ref byte[] Data
|
||||
{
|
||||
get => ref _data;
|
||||
}
|
||||
|
||||
public void FromBytes( byte[] stream ) { }
|
||||
|
||||
public static unsafe Image FromFile( string route, ImageLoader loader )
|
||||
{
|
||||
Image ret = new Image();
|
||||
fixed( ImageInfo* iptr = &ret._rawInfo ) {
|
||||
InternalIO.InternalLoadImage( route, iptr, loader );
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
public static Image FromMemory(
|
||||
(int width, int height) size,
|
||||
ImageChannel channel,
|
||||
byte[] stream )
|
||||
{
|
||||
ImageInfo _info = new ImageInfo
|
||||
{
|
||||
Height = size.height,
|
||||
Width = size.width,
|
||||
Channel = channel,
|
||||
StreamPtr = IntPtr.Zero
|
||||
};
|
||||
Image ret = new Image( _info );
|
||||
ret.PixelLayout = PixelChannelLayout.Byte;
|
||||
ret._data = stream;
|
||||
return ret;
|
||||
}
|
||||
|
||||
public static Image FromMemory(
|
||||
(int width, int height) size,
|
||||
ImageChannel channel,
|
||||
PixelChannelLayout layout,
|
||||
byte[] stream )
|
||||
{
|
||||
ImageInfo _info = new ImageInfo
|
||||
{
|
||||
Height = size.height,
|
||||
Width = size.width,
|
||||
Channel = channel,
|
||||
StreamPtr = IntPtr.Zero
|
||||
};
|
||||
Image ret = new Image( _info );
|
||||
ret.PixelLayout = layout;
|
||||
ret._data = stream;
|
||||
return ret;
|
||||
}
|
||||
|
||||
public unsafe byte[] GetBytes()
|
||||
{
|
||||
if( _data.Length == 0 )
|
||||
{
|
||||
int size = Width * Height * ImageInfo.GetPixelSize( PixelLayout, Channel );
|
||||
_data = new Span<byte>( ( byte* )_rawInfo.StreamPtr, size ).ToArray();
|
||||
fixed( ImageInfo* pptr = &_rawInfo ) {
|
||||
InternalIO.InternalUnloadImage( pptr );
|
||||
}
|
||||
_rawInfo.StreamPtr = IntPtr.Zero;
|
||||
}
|
||||
return _data;
|
||||
}
|
||||
|
||||
public Image ProvideImage() => this;
|
||||
|
||||
internal static Image FromMemory( ImageInfo info, byte[] data, int operationCount )
|
||||
{
|
||||
return new Image
|
||||
{
|
||||
_rawInfo = info,
|
||||
_data = data,
|
||||
_pixelUpdateCount = operationCount
|
||||
};
|
||||
}
|
||||
|
||||
byte[] ISSDSerializable.GetBytes()
|
||||
{
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
namespace StgSharp.Graphics.OpenGL
|
||||
{
|
||||
public static partial class GlHelper { }
|
||||
}
|
||||
@@ -1,141 +0,0 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Text;
|
||||
using System.Runtime.CompilerServices;
|
||||
using StgSharp.Graphics.OpenGL;
|
||||
using System.Runtime.InteropServices;
|
||||
|
||||
|
||||
namespace StgSharp.Graphics
|
||||
{
|
||||
[UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
|
||||
public delegate IntPtr ImageLoader(
|
||||
string name,
|
||||
ref int width,
|
||||
ref int height,
|
||||
ref int definedChannel,
|
||||
int desiredChannel);
|
||||
|
||||
|
||||
[StructLayout(LayoutKind.Sequential)]
|
||||
internal struct ImageInfo
|
||||
{
|
||||
|
||||
private ImageChannel channel;
|
||||
private int height;
|
||||
private int width;
|
||||
private IntPtr pixelPtr;
|
||||
internal PixelChannelLayout pixelLayout;
|
||||
|
||||
public ImageChannel Channel
|
||||
{
|
||||
get => channel;
|
||||
set { channel = value; }
|
||||
}
|
||||
|
||||
public int ChannelCount
|
||||
{
|
||||
get => GetChannelCount(channel);
|
||||
}
|
||||
|
||||
public int Height
|
||||
{
|
||||
get => height;
|
||||
set => height = value;
|
||||
}
|
||||
|
||||
public int StreamSize
|
||||
{
|
||||
get => width * height * GetPixelSize(
|
||||
pixelLayout, channel);
|
||||
}
|
||||
|
||||
public int Width
|
||||
{
|
||||
get => width;
|
||||
set => width = value;
|
||||
}
|
||||
|
||||
public IntPtr StreamPtr
|
||||
{
|
||||
get => pixelPtr;
|
||||
internal set => pixelPtr = value;
|
||||
}
|
||||
|
||||
public override int GetHashCode()
|
||||
{
|
||||
int hash = 17;
|
||||
hash = hash * 17 + width;
|
||||
hash = hash * 17 + height;
|
||||
hash = hash * 17 + (int)channel;
|
||||
return hash;
|
||||
}
|
||||
|
||||
public override string ToString()
|
||||
{
|
||||
return $"{channel}\t{width}\t{height}\t{(ulong)StreamPtr}";
|
||||
}
|
||||
|
||||
|
||||
internal static int GetChannelCount(ImageChannel channel)
|
||||
{
|
||||
return channel switch
|
||||
{
|
||||
ImageChannel.SingleColor => 1,
|
||||
ImageChannel.DoubleColor => 2,
|
||||
ImageChannel.TripleColor => 3,
|
||||
ImageChannel.WithAlphaChannel => 4,
|
||||
_ => throw new InvalidCastException(
|
||||
"Unknown color channel decoding setting.")
|
||||
};
|
||||
}
|
||||
|
||||
internal static int GetPixelSize(
|
||||
PixelChannelLayout layout,
|
||||
ImageChannel channel)
|
||||
{
|
||||
return layout switch
|
||||
{
|
||||
PixelChannelLayout.UByte => sizeof(byte) * GetChannelCount(
|
||||
channel),
|
||||
PixelChannelLayout.Byte => sizeof(byte) * GetChannelCount(
|
||||
channel),
|
||||
PixelChannelLayout.UShort => sizeof(short) * GetChannelCount(
|
||||
channel),
|
||||
PixelChannelLayout.Short => sizeof(short) * GetChannelCount(
|
||||
channel),
|
||||
PixelChannelLayout.UInt => sizeof(int) * GetChannelCount(
|
||||
channel),
|
||||
PixelChannelLayout.Int => sizeof(int) * GetChannelCount(
|
||||
channel),
|
||||
PixelChannelLayout.Float => sizeof(float) * GetChannelCount(
|
||||
channel),
|
||||
PixelChannelLayout.UByte332 => sizeof(byte),
|
||||
PixelChannelLayout.UByte233Rev => sizeof(byte),
|
||||
PixelChannelLayout.UShort565 => sizeof(short),
|
||||
PixelChannelLayout.UShort565Rev => sizeof(short),
|
||||
PixelChannelLayout.UShort4444 => sizeof(short),
|
||||
PixelChannelLayout.UShort4444Rev => sizeof(short),
|
||||
PixelChannelLayout.UShort5551 => sizeof(short),
|
||||
PixelChannelLayout.UShort1555Rev => sizeof(short),
|
||||
PixelChannelLayout.UInt8888 => sizeof(int),
|
||||
PixelChannelLayout.UInt8888Rev => sizeof(int),
|
||||
PixelChannelLayout.UInt1010102 => sizeof(int),
|
||||
PixelChannelLayout.UInt2101010Rev => sizeof(int),
|
||||
_ => throw new ArgumentException("Unknown layout type"),
|
||||
};
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
public enum ImageChannel : uint
|
||||
{
|
||||
|
||||
SingleColor = glConst.RED,
|
||||
DoubleColor = glConst.RG,
|
||||
TripleColor = glConst.RGB,
|
||||
WithAlphaChannel = glConst.RGBA,
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,162 +0,0 @@
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
// file="AutoTexture.cs"
|
||||
// Project: StgSharp
|
||||
// AuthorGroup: Nitload Space
|
||||
// Copyright (c) Nitload Space. All rights reserved.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the “Software”), to deal in the Software without restriction,
|
||||
// including without limitation the rights to use, copy, modify, merge,
|
||||
// publish, distribute, sublicense, and/or sell copies of the Software,
|
||||
// and to permit persons to whom the Software is furnished to do so,
|
||||
// subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and
|
||||
// this permission notice shall be included in all copies
|
||||
// or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED “AS IS”,
|
||||
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
// ARISING FROM, OUT OF OR IN CONNECTION WITH
|
||||
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
//
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
using StgSharp.Commom.Collections;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Diagnostics.CodeAnalysis;
|
||||
using System.Linq;
|
||||
using System.Runtime.CompilerServices;
|
||||
using System.Text;
|
||||
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace StgSharp.Graphics.OpenGL
|
||||
{
|
||||
/// <summary>
|
||||
/// A collection of a sets of OpenGL textures. The collection can automatically select one of
|
||||
/// the texture with minimum costs to upgrade pixels to Buffer. Usually <see
|
||||
/// cref="AutoTextureGL" /> is used for <see cref="IImageProvider" /> loading, but not for
|
||||
/// target of <see cref="OpenGLFunction.FrameBufferTexture2d(FrameBufferTarget, uint,
|
||||
/// Texture2DTarget, GlHandle, int)" />.
|
||||
/// </summary>
|
||||
public sealed class AutoTextureGL
|
||||
{
|
||||
|
||||
private TextureProperty[] propertyCache;
|
||||
private BidirectionalDictionary<Image, int> imageIndexMap = new BidirectionalDictionary<Image, int>(
|
||||
);
|
||||
private Dictionary<Image, int> imageUpdateIndex = new Dictionary<Image, int>();
|
||||
|
||||
private int _size, _currentIndex;
|
||||
private LinkedList<int> usedTextureIndex;
|
||||
private Queue<int> unusedTextureUnitIndex;
|
||||
private TextureGL texturePackage;
|
||||
|
||||
private TextureProperty _textureProperty;
|
||||
|
||||
private AutoTextureGL( TextureGL texture )
|
||||
{
|
||||
texturePackage = texture;
|
||||
_size = texture.Count;
|
||||
imageIndexMap = new BidirectionalDictionary<Image, int>();
|
||||
unusedTextureUnitIndex = new Queue<int>( Enumerable.Range( 0, _size ) );
|
||||
usedTextureIndex = new LinkedList<int>();
|
||||
propertyCache = new TextureProperty[_size];
|
||||
}
|
||||
|
||||
public AutoTextureGL( int textureObjectSize, [NotNull]glRender binding )
|
||||
{
|
||||
this._size = textureObjectSize;
|
||||
imageIndexMap = new BidirectionalDictionary<Image, int>();
|
||||
texturePackage = new TextureGL( textureObjectSize, binding );
|
||||
unusedTextureUnitIndex = new Queue<int>( Enumerable.Range( 0, _size ) );
|
||||
usedTextureIndex = new LinkedList<int>();
|
||||
propertyCache = new TextureProperty[_size];
|
||||
}
|
||||
|
||||
public TextureProperty DefaultTextureProperty
|
||||
{
|
||||
get => _textureProperty;
|
||||
set => _textureProperty = value;
|
||||
}
|
||||
|
||||
private OpenGLFunction GL
|
||||
{
|
||||
get => texturePackage.GL;
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public void SelectTextureAndBind( Image i )
|
||||
{
|
||||
TextureProperty property = _textureProperty;
|
||||
|
||||
SelectTextureAndBind( i, property );
|
||||
}
|
||||
|
||||
public void SelectTextureAndBind( [NotNull]Image i, TextureProperty property )
|
||||
{
|
||||
//usable texture with image match
|
||||
if( imageIndexMap.TryGetValue( i, out int index ) )
|
||||
{
|
||||
//prop setting match
|
||||
if( propertyCache[ index ] == property )
|
||||
{
|
||||
_currentIndex = index; //GL.Assert(true);
|
||||
texturePackage.Bind2D( index ); //GL.Assert(true);
|
||||
if( i.PixelUpdateCount != imageUpdateIndex[ i ] )
|
||||
{
|
||||
texturePackage.LoadTexture( index, i ); //GL.Assert(true);
|
||||
}
|
||||
} else
|
||||
{
|
||||
_currentIndex = index; //GL.Assert(true);
|
||||
texturePackage.Bind2D( index ); //GL.Assert(true);
|
||||
texturePackage.Set2dProperty( index, property ); //GL.Assert(true);
|
||||
if( i.PixelUpdateCount != imageUpdateIndex[ i ] )
|
||||
{
|
||||
texturePackage.LoadTexture( index, i ); //GL.Assert(true);
|
||||
}
|
||||
}
|
||||
} else
|
||||
{
|
||||
if( unusedTextureUnitIndex.TryDequeue( out int newIndex ) )
|
||||
{
|
||||
//has extra unused texture object
|
||||
imageIndexMap.Add( i, index );
|
||||
texturePackage.Bind2D( index );
|
||||
texturePackage.Set2dProperty( index, property );
|
||||
texturePackage.LoadTexture( index, i );
|
||||
usedTextureIndex.AddLast( newIndex );
|
||||
propertyCache[ newIndex ] = property;
|
||||
imageUpdateIndex[ i ] = i.PixelUpdateCount;
|
||||
} else
|
||||
{
|
||||
//recycle from current
|
||||
int reusedIndex = usedTextureIndex.First!.Value;
|
||||
usedTextureIndex.RemoveFirst();
|
||||
usedTextureIndex.AddLast( reusedIndex );
|
||||
imageIndexMap[ i ] = reusedIndex;
|
||||
propertyCache[ newIndex ] = property;
|
||||
imageUpdateIndex[ i ] = i.PixelUpdateCount;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static AutoTextureGL ToAuto( [NotNull]TextureGL texture )
|
||||
{
|
||||
if( texture.IndexOfCurrentTexture != -1 ) {
|
||||
throw new InvalidOperationException( "Texture to be converted has been editted." );
|
||||
}
|
||||
return new AutoTextureGL( texture );
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
@@ -1,86 +0,0 @@
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
// file="EBO.cs"
|
||||
// Project: StgSharp
|
||||
// AuthorGroup: Nitload Space
|
||||
// Copyright (c) Nitload Space. All rights reserved.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the “Software”), to deal in the Software without restriction,
|
||||
// including without limitation the rights to use, copy, modify, merge,
|
||||
// publish, distribute, sublicense, and/or sell copies of the Software,
|
||||
// and to permit persons to whom the Software is furnished to do so,
|
||||
// subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and
|
||||
// this permission notice shall be included in all copies
|
||||
// or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED “AS IS”,
|
||||
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
// ARISING FROM, OUT OF OR IN CONNECTION WITH
|
||||
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
//
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
using StgSharp.Graphics;
|
||||
using StgSharp.Graphics.OpenGL;
|
||||
using StgSharp.Internal.OpenGL;
|
||||
using StgSharp.Math;
|
||||
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Numerics;
|
||||
using System.Runtime.CompilerServices;
|
||||
using System.Runtime.InteropServices;
|
||||
using System.Text;
|
||||
|
||||
namespace StgSharp.Graphics.OpenGL
|
||||
{
|
||||
/// <summary>
|
||||
/// A collection of handle to Element Buffer Object in OpenglFunc. Each <see langword="uint"
|
||||
/// /> value indexed from instance of this class this is the only handle to one Element Buffer
|
||||
/// Object.
|
||||
/// </summary>
|
||||
public sealed unsafe class ElementBuffer : GlBufferObjectBase
|
||||
{
|
||||
|
||||
internal ElementBuffer( int n, glRender binding )
|
||||
: base( binding )
|
||||
{
|
||||
_bufferHandle = GL.GenBuffers( n );
|
||||
}
|
||||
|
||||
public override sealed void Bind( int index )
|
||||
{
|
||||
GL.BindBuffer( BufferType.ElementArrayBuffer, _bufferHandle[ index ] );
|
||||
}
|
||||
|
||||
public void SetValue<T>( int index, T[] bufferArray, BufferUsage usage )
|
||||
where T: struct, INumber<T>
|
||||
{
|
||||
GL.BindBuffer( BufferType.ElementArrayBuffer, _bufferHandle[ index ] );
|
||||
GL.SetBufferData<T>( BufferType.ElementArrayBuffer, bufferArray, usage );
|
||||
}
|
||||
|
||||
public void SetValue<T>( int index, ReadOnlySpan<T> bufferSpan, BufferUsage usage )
|
||||
where T: struct, INumber<T>
|
||||
{
|
||||
GL.BindBuffer( BufferType.ElementArrayBuffer, _bufferHandle[ index ] );
|
||||
GL.SetBufferData<T>( BufferType.ElementArrayBuffer, bufferSpan, usage );
|
||||
}
|
||||
|
||||
protected override sealed void Dispose( bool disposing )
|
||||
{
|
||||
if( disposing ) {
|
||||
GL.DeleteBuffers( _bufferHandle );
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
@@ -1,107 +0,0 @@
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
// file="FBO.cs"
|
||||
// Project: StgSharp
|
||||
// AuthorGroup: Nitload Space
|
||||
// Copyright (c) Nitload Space. All rights reserved.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the “Software”), to deal in the Software without restriction,
|
||||
// including without limitation the rights to use, copy, modify, merge,
|
||||
// publish, distribute, sublicense, and/or sell copies of the Software,
|
||||
// and to permit persons to whom the Software is furnished to do so,
|
||||
// subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and
|
||||
// this permission notice shall be included in all copies
|
||||
// or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED “AS IS”,
|
||||
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
// ARISING FROM, OUT OF OR IN CONNECTION WITH
|
||||
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
//
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
using StgSharp.Graphics.OpenGL;
|
||||
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Diagnostics;
|
||||
using System.Linq;
|
||||
using System.Runtime.CompilerServices;
|
||||
using System.Text;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace StgSharp.Graphics.OpenGL
|
||||
{
|
||||
#pragma warning disable CA1008
|
||||
#pragma warning disable CA1028
|
||||
public enum FrameBufferTarget : uint
|
||||
#pragma warning restore CA1028
|
||||
#pragma warning restore CA1008
|
||||
{
|
||||
|
||||
Read = glConst.READ_FRAMEBUFFER,
|
||||
All = glConst.FRAMEBUFFER,
|
||||
Draw = glConst.DRAW_FRAMEBUFFER,
|
||||
|
||||
}
|
||||
|
||||
public sealed class FrameBuffer : GlBufferObjectBase
|
||||
{
|
||||
|
||||
internal unsafe FrameBuffer( int count, glRender binding )
|
||||
: base( binding )
|
||||
{
|
||||
_bufferHandle = GL.GenFrameBuffers( count );
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Bind the frame Buffer object with _label frame Buffer to the frame Buffer target
|
||||
/// specified by target. <see langword="FrameBufferTarget.All" /> will be set as default
|
||||
/// target.
|
||||
/// </summary>
|
||||
/// <param _label="index">
|
||||
/// Index of object to be binded in handle set
|
||||
/// </param>
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public override unsafe void Bind( int index )
|
||||
{
|
||||
GL.BindFrameBuffer( FrameBufferTarget.All, _bufferHandle[ index ] );
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Bind the frame Buffer object with _label frame Buffer to the frame Buffer target
|
||||
/// specified by target. Target of this frame Buffer should be set manually.
|
||||
/// </summary>
|
||||
/// <param _label="target">
|
||||
/// The frame Buffer target of the binding operation.
|
||||
/// </param>
|
||||
/// <param _label="index">
|
||||
/// Index of object to be binded in handle set
|
||||
/// </param>
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public unsafe void Bind( FrameBufferTarget target, int index )
|
||||
{
|
||||
GL.BindFrameBuffer( target, _bufferHandle[ index ] );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public static void BindNull()
|
||||
{
|
||||
OpenGLFunction.CurrentGL.BindFrameBuffer( FrameBufferTarget.All, GlHandle.Zero );
|
||||
}
|
||||
|
||||
protected override void Dispose( bool disposing )
|
||||
{
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
@@ -1,53 +0,0 @@
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
// file="GLBufferObjectBase.cs"
|
||||
// Project: StgSharp
|
||||
// AuthorGroup: Nitload Space
|
||||
// Copyright (c) Nitload Space. All rights reserved.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the “Software”), to deal in the Software without restriction,
|
||||
// including without limitation the rights to use, copy, modify, merge,
|
||||
// publish, distribute, sublicense, and/or sell copies of the Software,
|
||||
// and to permit persons to whom the Software is furnished to do so,
|
||||
// subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and
|
||||
// this permission notice shall be included in all copies
|
||||
// or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED “AS IS”,
|
||||
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
// ARISING FROM, OUT OF OR IN CONNECTION WITH
|
||||
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
//
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
using StgSharp.Graphics.OpenGL;
|
||||
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Text;
|
||||
|
||||
namespace StgSharp.Graphics.OpenGL
|
||||
{
|
||||
public abstract class GlBufferObjectBase : BufferObjectBase
|
||||
{
|
||||
|
||||
private readonly glRender _contextBinding;
|
||||
|
||||
protected GlBufferObjectBase( glRender contextBinding )
|
||||
{
|
||||
binding = contextBinding;
|
||||
_contextBinding = contextBinding;
|
||||
}
|
||||
|
||||
protected OpenGLFunction GL => _contextBinding.GL;
|
||||
|
||||
}
|
||||
}
|
||||
@@ -1,71 +0,0 @@
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
// file="RBO.cs"
|
||||
// Project: StgSharp
|
||||
// AuthorGroup: Nitload Space
|
||||
// Copyright (c) Nitload Space. All rights reserved.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the “Software”), to deal in the Software without restriction,
|
||||
// including without limitation the rights to use, copy, modify, merge,
|
||||
// publish, distribute, sublicense, and/or sell copies of the Software,
|
||||
// and to permit persons to whom the Software is furnished to do so,
|
||||
// subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and
|
||||
// this permission notice shall be included in all copies
|
||||
// or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED “AS IS”,
|
||||
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
// ARISING FROM, OUT OF OR IN CONNECTION WITH
|
||||
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
//
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
using StgSharp.Graphics.OpenGL;
|
||||
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Security.Principal;
|
||||
using System.Text;
|
||||
|
||||
namespace StgSharp.Graphics.OpenGL
|
||||
{
|
||||
public sealed class RenderBuffer : GlBufferObjectBase
|
||||
{
|
||||
|
||||
public RenderBuffer( int count, glRender binding )
|
||||
: base( binding )
|
||||
{
|
||||
_bufferHandle = GL.GenRenderBuffer( count );
|
||||
}
|
||||
|
||||
public override void Bind( int index )
|
||||
{
|
||||
GL.BindRenderBuffer( this[ index ] );
|
||||
}
|
||||
|
||||
public void Store( RenderBufferInternalFormat format, (int width, int height) size )
|
||||
{
|
||||
if( ( size.width > binding.Width ) || ( size.height > binding.Height ) ) {
|
||||
World.LogWarning( "FrameBuffer is larger than current canvas binding" );
|
||||
}
|
||||
}
|
||||
|
||||
protected override void Dispose( bool disposing )
|
||||
{
|
||||
foreach( GlHandle item in _bufferHandle )
|
||||
{
|
||||
Console.WriteLine( "removing a render buffer" );
|
||||
GL.DeleteRenderBuffer( item );
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
@@ -1,287 +0,0 @@
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
// file="TextureGL.cs"
|
||||
// Project: StgSharp
|
||||
// AuthorGroup: Nitload Space
|
||||
// Copyright (c) Nitload Space. All rights reserved.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the “Software”), to deal in the Software without restriction,
|
||||
// including without limitation the rights to use, copy, modify, merge,
|
||||
// publish, distribute, sublicense, and/or sell copies of the Software,
|
||||
// and to permit persons to whom the Software is furnished to do so,
|
||||
// subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and
|
||||
// this permission notice shall be included in all copies
|
||||
// or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED “AS IS”,
|
||||
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
// ARISING FROM, OUT OF OR IN CONNECTION WITH
|
||||
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
//
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
using StgSharp.HighPerformance;
|
||||
|
||||
using System;
|
||||
using System.Diagnostics.CodeAnalysis;
|
||||
using System.Linq;
|
||||
using System.Runtime.CompilerServices;
|
||||
using System.Runtime.InteropServices;
|
||||
|
||||
namespace StgSharp.Graphics.OpenGL
|
||||
{
|
||||
public sealed unsafe class TextureGL
|
||||
{
|
||||
|
||||
private int currentEditingTextureIndex;
|
||||
|
||||
private OpenGLFunction _gl;
|
||||
internal GlHandle[] _textureHandle;
|
||||
|
||||
internal TextureGL( int count, glRender binding )
|
||||
{
|
||||
//sourceList = new Image[count];
|
||||
this._gl = binding.GL;
|
||||
_textureHandle = _gl.GenTextures( count );
|
||||
}
|
||||
|
||||
public GlHandle this[ int index ]
|
||||
{
|
||||
get => _textureHandle[ index ];
|
||||
}
|
||||
|
||||
public int Count
|
||||
{
|
||||
get => _textureHandle.Length;
|
||||
}
|
||||
|
||||
//internal Image[] sourceList;
|
||||
|
||||
public int IndexOfCurrentTexture
|
||||
{
|
||||
get => currentEditingTextureIndex;
|
||||
}
|
||||
|
||||
internal OpenGLFunction GL => _gl;
|
||||
|
||||
public void ActivateAs( TextureUnit unit )
|
||||
{
|
||||
_gl.ActiveTextureUnit( ( uint )unit );
|
||||
}
|
||||
|
||||
public void Bind2D( int index )
|
||||
{
|
||||
currentEditingTextureIndex = index;
|
||||
_gl.BindTexture( glConst.TEXTURE_2D, _textureHandle[ index ] );
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Load an <see cref="Image" /> to certain texture.
|
||||
/// </summary>
|
||||
/// <param _label="index">
|
||||
///
|
||||
/// </param>
|
||||
/// <param _label="i">
|
||||
///
|
||||
/// </param>
|
||||
public unsafe void LoadTexture( int index, Image i )
|
||||
{
|
||||
byte[] handle = i.PixelBuffer;
|
||||
_gl.TextureImage2d(
|
||||
Texture2DTarget.Texture2D, 0, i.Channel, ( uint )i.Width, ( uint )i.Height,
|
||||
i.Channel, i.PixelLayout, pixels: handle );
|
||||
_gl.GenerateMipmap( Texture2DTarget.Texture2D );
|
||||
}
|
||||
|
||||
#region texture setting
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public void Set2dFilterProperty(
|
||||
int index,
|
||||
TextureFilter onMinify,
|
||||
TextureFilter onMagnify )
|
||||
{
|
||||
#if DEBUG
|
||||
if( index != currentEditingTextureIndex )
|
||||
{
|
||||
throw new InvalidOperationException(
|
||||
"Texture to be editted is not the one being activated." );
|
||||
}
|
||||
#endif
|
||||
_gl.TextureParameter( glConst.TEXTURE_2D, glConst.TEXTURE_MIN_FILTER, ( int )onMinify );
|
||||
_gl.TextureParameter( glConst.TEXTURE_2D, glConst.TEXTURE_MAG_FILTER,
|
||||
( int )onMagnify );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public void Set2dWrapProperty(
|
||||
int index,
|
||||
TextureWrap onHorizontial,
|
||||
TextureWrap onVertical )
|
||||
{
|
||||
#if DEBUG
|
||||
if( index != currentEditingTextureIndex )
|
||||
{
|
||||
throw new InvalidOperationException(
|
||||
"Texture to be editted is not the one being activated." );
|
||||
}
|
||||
#endif
|
||||
_gl.TextureParameter( glConst.TEXTURE_2D, glConst.TEXTURE_WRAP_S,
|
||||
( int )onHorizontial );
|
||||
_gl.TextureParameter( glConst.TEXTURE_2D, glConst.TEXTURE_WRAP_T, ( int )onVertical );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public void Set2dProperty( int index, TextureProperty property )
|
||||
{
|
||||
Set2dFilterProperty( index, property.FilterOnMinify, property.FilterOnMagnify );
|
||||
Set2dWrapProperty( index, property.WrapOnHorizontial, property.WrapOnVertical );
|
||||
}
|
||||
|
||||
#endregion texture setting
|
||||
}
|
||||
|
||||
[StructLayout( LayoutKind.Explicit )]
|
||||
public struct TextureProperty
|
||||
{
|
||||
|
||||
[FieldOffset( 0 )] private M128 mask;
|
||||
[FieldOffset( 0 )] private TextureFilter mag;
|
||||
[FieldOffset( 4 )] private TextureFilter min;
|
||||
|
||||
[FieldOffset( 8 )] private TextureWrap hori;
|
||||
[FieldOffset( 12 )] private TextureWrap vert;
|
||||
|
||||
public TextureProperty(
|
||||
TextureFilter onMagnify,
|
||||
TextureFilter onMinify,
|
||||
TextureWrap onHorizontial,
|
||||
TextureWrap onVertical )
|
||||
{
|
||||
FilterOnMagnify = onMagnify;
|
||||
FilterOnMinify = onMinify;
|
||||
WrapOnHorizontial = onHorizontial;
|
||||
WrapOnVertical = onVertical;
|
||||
}
|
||||
|
||||
public TextureFilter FilterOnMagnify
|
||||
{
|
||||
get => mag;
|
||||
set => mag = value;
|
||||
}
|
||||
|
||||
public TextureFilter FilterOnMinify
|
||||
{
|
||||
get => min;
|
||||
set => min = value;
|
||||
}
|
||||
|
||||
public TextureWrap WrapOnHorizontial
|
||||
{
|
||||
get => hori;
|
||||
set => hori = value;
|
||||
}
|
||||
|
||||
public TextureWrap WrapOnVertical
|
||||
{
|
||||
get => vert;
|
||||
set => vert = value;
|
||||
}
|
||||
|
||||
public override bool Equals( [NotNullWhen( true )] object obj )
|
||||
{
|
||||
return base.Equals( obj );
|
||||
}
|
||||
|
||||
public override int GetHashCode()
|
||||
{
|
||||
return HashCode.Combine(
|
||||
FilterOnMagnify, FilterOnMagnify, WrapOnHorizontial, WrapOnVertical );
|
||||
}
|
||||
|
||||
public override string ToString()
|
||||
{
|
||||
return $"FilterOnMagnify:{FilterOnMagnify}, " + $"FilterOnMagnify:{FilterOnMagnify}, " + $"WrapOnHorizontial:{WrapOnHorizontial}, " + $"WrapOnVertical:{WrapOnVertical}";
|
||||
}
|
||||
|
||||
public static bool operator !=( TextureProperty left, TextureProperty right )
|
||||
{
|
||||
return left.mask != right.mask;
|
||||
}
|
||||
|
||||
public static bool operator ==( TextureProperty left, TextureProperty right )
|
||||
{
|
||||
return left.mask == right.mask;
|
||||
}
|
||||
|
||||
public static implicit operator TextureProperty(
|
||||
(
|
||||
TextureFilter onMagnify, TextureFilter onMinify,
|
||||
TextureWrap onHorizontial, TextureWrap onVertical
|
||||
) propertyValueTuple )
|
||||
{
|
||||
return new TextureProperty(
|
||||
propertyValueTuple.onMagnify, propertyValueTuple.onMinify,
|
||||
propertyValueTuple.onHorizontial, propertyValueTuple.onVertical );
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
#pragma warning disable CA1008
|
||||
public enum TextureFilter
|
||||
#pragma warning restore CA1008
|
||||
{
|
||||
|
||||
Nearest = glConst.NEAREST,
|
||||
Linear = glConst.LINEAR,
|
||||
NearestLinearMipmap = glConst.NEAREST_MIPMAP_LINEAR,
|
||||
LinearLinearMipmap = glConst.LINEAR_MIPMAP_LINEAR,
|
||||
NearestNearestMipmap = glConst.NEAREST_MIPMAP_NEAREST,
|
||||
LinearNearestMipmap = glConst.LINEAR_MIPMAP_NEAREST,
|
||||
|
||||
}
|
||||
|
||||
#pragma warning disable CA1008
|
||||
public enum TextureUnit
|
||||
#pragma warning restore CA1008
|
||||
{
|
||||
|
||||
Unit0 = glConst.TEXTURE0,
|
||||
Unit1 = glConst.TEXTURE1,
|
||||
Unit2 = glConst.TEXTURE2,
|
||||
Unit3 = glConst.TEXTURE3,
|
||||
Unit4 = glConst.TEXTURE4,
|
||||
Unit5 = glConst.TEXTURE5,
|
||||
Unit6 = glConst.TEXTURE6,
|
||||
Unit7 = glConst.TEXTURE7,
|
||||
Unit8 = glConst.TEXTURE8,
|
||||
Unit9 = glConst.TEXTURE9,
|
||||
Unit10 = glConst.TEXTURE10,
|
||||
Unit11 = glConst.TEXTURE11,
|
||||
Unit12 = glConst.TEXTURE12,
|
||||
Unit13 = glConst.TEXTURE13,
|
||||
Unit14 = glConst.TEXTURE14,
|
||||
Unit15 = glConst.TEXTURE15,
|
||||
|
||||
}
|
||||
|
||||
#pragma warning disable CA1008
|
||||
public enum TextureWrap
|
||||
#pragma warning restore CA1008
|
||||
{
|
||||
|
||||
Repeat = glConst.REPEAT,
|
||||
MirroredRepeat = glConst.MIRRORED_REPEAT,
|
||||
ClampToEdge = glConst.CLAMP_TO_EDGE,
|
||||
ClampToBorder = glConst.CLAMP_TO_BORDER,
|
||||
|
||||
}
|
||||
}
|
||||
@@ -1,80 +0,0 @@
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
// file="VAO.cs"
|
||||
// Project: StepVisualizer
|
||||
// AuthorGroup: Nitload Space
|
||||
// Copyright (c) Nitload Space. All rights reserved.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the “Software”), to deal in the Software without restriction,
|
||||
// including without limitation the rights to use, copy, modify, merge,
|
||||
// publish, distribute, sublicense, and/or sell copies of the Software,
|
||||
// and to permit persons to whom the Software is furnished to do so,
|
||||
// subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and
|
||||
// this permission notice shall be included in all copies
|
||||
// or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED “AS IS”,
|
||||
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
// ARISING FROM, OUT OF OR IN CONNECTION WITH
|
||||
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
//
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Runtime.CompilerServices;
|
||||
using System.Text;
|
||||
|
||||
namespace StgSharp.Graphics.OpenGL
|
||||
{
|
||||
public sealed unsafe class VertexArray : GlBufferObjectBase
|
||||
{
|
||||
|
||||
internal VertexArray( int n, glRender binding )
|
||||
: base( binding )
|
||||
{
|
||||
_bufferHandle = GL.GenVertexArrays( n );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public override sealed void Bind( int index )
|
||||
{
|
||||
GL.BindVertexArray( _bufferHandle[ index ] );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public static void BindNull()
|
||||
{
|
||||
OpenGLFunction.CurrentGL.BindVertexArray( GlHandle.Zero );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public void SetVertexAttribute(
|
||||
uint attributeIndex,
|
||||
int vertexLength,
|
||||
TypeCode dataType,
|
||||
bool isNomalized,
|
||||
uint stride,
|
||||
int pointer )
|
||||
{
|
||||
GL.SetVertexAttribute(
|
||||
attributeIndex, vertexLength, dataType, isNomalized, stride, pointer );
|
||||
}
|
||||
|
||||
protected override sealed void Dispose( bool disposing )
|
||||
{
|
||||
if( disposing ) {
|
||||
GL.DeleteVertexArrays( _bufferHandle );
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
@@ -1,185 +0,0 @@
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
// file="VBO.cs"
|
||||
// Project: StepVisualizer
|
||||
// AuthorGroup: Nitload Space
|
||||
// Copyright (c) Nitload Space. All rights reserved.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the “Software”), to deal in the Software without restriction,
|
||||
// including without limitation the rights to use, copy, modify, merge,
|
||||
// publish, distribute, sublicense, and/or sell copies of the Software,
|
||||
// and to permit persons to whom the Software is furnished to do so,
|
||||
// subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and
|
||||
// this permission notice shall be included in all copies
|
||||
// or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED “AS IS”,
|
||||
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
// ARISING FROM, OUT OF OR IN CONNECTION WITH
|
||||
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
//
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
using StgSharp.Math;
|
||||
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Net.Security;
|
||||
using System.Numerics;
|
||||
using System.Reflection;
|
||||
using System.Runtime.CompilerServices;
|
||||
using System.Runtime.InteropServices;
|
||||
using System.Text;
|
||||
|
||||
namespace StgSharp.Graphics.OpenGL
|
||||
{
|
||||
public sealed unsafe class VertexBuffer : GlBufferObjectBase
|
||||
{
|
||||
|
||||
internal VertexBuffer( int n, glRender binding )
|
||||
: base( binding )
|
||||
{
|
||||
_bufferHandle = GL.GenBuffers( n );
|
||||
}
|
||||
|
||||
public override sealed void Bind( int index )
|
||||
{
|
||||
GL.BindBuffer( BufferType.ArrayBuffer, _bufferHandle[ index ] );
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
///
|
||||
/// </summary>
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public void Unbind()
|
||||
{
|
||||
GL.BindBuffer( BufferType.ArrayBuffer, GlHandle.Zero );
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Set _data to current vertex Buffer object
|
||||
/// </summary>
|
||||
/// <typeparam _label="TItem">
|
||||
/// Type of bufferData
|
||||
/// </typeparam>
|
||||
/// <param _label="index">
|
||||
/// Index to find certain VBO in this instance
|
||||
/// </param>
|
||||
/// <param _label="bufferData">
|
||||
/// Data to write in
|
||||
/// </param>
|
||||
/// <param _label="usage">
|
||||
/// How OpenGL use these _data, defined by <see cref="BufferUsage" />
|
||||
/// </param>
|
||||
public void WriteMatrixData<T>( int index, T bufferData, BufferUsage usage )
|
||||
where T: struct, IMatrix<T>
|
||||
{
|
||||
GL.BindBuffer( BufferType.ArrayBuffer, _bufferHandle[ index ] );
|
||||
GL.SetBufferData( BufferType.ArrayBuffer, bufferData, usage );
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Set _data to current vertex Buffer object
|
||||
/// </summary>
|
||||
/// <typeparam _label="TItem">
|
||||
/// Type of bufferData
|
||||
/// </typeparam>
|
||||
/// <param _label="index">
|
||||
/// Index to find certain VBO in this instance
|
||||
/// </param>
|
||||
/// <param _label="bufferArray">
|
||||
/// Data to write in
|
||||
/// </param>
|
||||
/// <param _label="usage">
|
||||
/// How OpenGL use these _data, defined by <see cref="BufferUsage" />
|
||||
/// </param>
|
||||
public void WriteScalerData<T>( int index, T[] bufferArray, BufferUsage usage )
|
||||
where T: struct, INumber<T>
|
||||
{
|
||||
GL.BindBuffer( BufferType.ArrayBuffer, _bufferHandle[ index ] );
|
||||
GL.SetBufferData( BufferType.ArrayBuffer, bufferArray, usage );
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Set _data to current vertex Buffer object
|
||||
/// </summary>
|
||||
/// <typeparam _label="TItem">
|
||||
/// Type of bufferData
|
||||
/// </typeparam>
|
||||
/// <param _label="index">
|
||||
/// Index to find certain VBO in this instance
|
||||
/// </param>
|
||||
/// <param _label="scalerSpan">
|
||||
/// A <see cref="Span{T}" /> of _data to write in
|
||||
/// </param>
|
||||
/// <param _label="usage">
|
||||
/// How OpenGL use these _data, defined by <see cref="BufferUsage" />
|
||||
/// </param>
|
||||
public void WriteScalerData<T>( int index, ReadOnlySpan<T> scalerSpan, BufferUsage usage )
|
||||
where T: struct,INumber<T>
|
||||
{
|
||||
GL.BindBuffer( BufferType.ArrayBuffer, _bufferHandle[ index ] );
|
||||
GL.SetBufferData( BufferType.ArrayBuffer, scalerSpan, usage );
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Set data to current vertex Buffer object
|
||||
/// </summary>
|
||||
/// <typeparam _label="TItem">
|
||||
/// Type of bufferData
|
||||
/// </typeparam>
|
||||
/// <param _label="index">
|
||||
/// Index to find certain VBO in this instance
|
||||
/// </param>
|
||||
/// <param _label="vectorSpan">
|
||||
/// A <see cref="Span{T}" /> of data to write in
|
||||
/// </param>
|
||||
/// <param _label="usage">
|
||||
/// How OpenGL use these data, defined by <see cref="BufferUsage" />
|
||||
/// </param>
|
||||
public void WriteVectorData<T>( int index, ReadOnlySpan<T> vectorSpan, BufferUsage usage )
|
||||
where T: struct, IVector<T>
|
||||
{
|
||||
GL.BindBuffer( BufferType.ArrayBuffer, _bufferHandle[ index ] );
|
||||
GL.SetBufferVectorData( BufferType.ArrayBuffer, vectorSpan, usage );
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Set _data to current vertex Buffer object
|
||||
/// </summary>
|
||||
/// <typeparam _label="TItem">
|
||||
/// Type of bufferData
|
||||
/// </typeparam>
|
||||
/// <param _label="index">
|
||||
/// Index to find certain VBO in this instance
|
||||
/// </param>
|
||||
/// <param _label="vectorArray">
|
||||
/// A array of _data to write in
|
||||
/// </param>
|
||||
/// <param _label="usage">
|
||||
/// How OpenGL use these _data, defined by <see cref="BufferUsage" />
|
||||
/// </param>
|
||||
public void WriteVectorData<T>( int index, T[] vectorArray, BufferUsage usage )
|
||||
where T: struct, IVector<T>
|
||||
{
|
||||
GL.BindBuffer( BufferType.ArrayBuffer, _bufferHandle[ index ] );
|
||||
GL.SetBufferVectorData( BufferType.ArrayBuffer, vectorArray, usage );
|
||||
}
|
||||
|
||||
protected override sealed void Dispose( bool disposing )
|
||||
{
|
||||
if( disposing ) {
|
||||
GL.DeleteBuffers( _bufferHandle );
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
@@ -1,49 +0,0 @@
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
// file="GLfixed.cs"
|
||||
// Project: StgSharp
|
||||
// AuthorGroup: Nitload Space
|
||||
// Copyright (c) Nitload Space. All rights reserved.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the “Software”), to deal in the Software without restriction,
|
||||
// including without limitation the rights to use, copy, modify, merge,
|
||||
// publish, distribute, sublicense, and/or sell copies of the Software,
|
||||
// and to permit persons to whom the Software is furnished to do so,
|
||||
// subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and
|
||||
// this permission notice shall be included in all copies
|
||||
// or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED “AS IS”,
|
||||
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
// ARISING FROM, OUT OF OR IN CONNECTION WITH
|
||||
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
//
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Runtime.InteropServices;
|
||||
using System.Text;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace StgSharp.Internal
|
||||
{
|
||||
[StructLayout( LayoutKind.Explicit, Size = 8 )]
|
||||
public struct GLfixed
|
||||
{
|
||||
|
||||
[FieldOffset( 0 )] public int All;
|
||||
[FieldOffset( 0 )] public short Decimals;
|
||||
[FieldOffset( 4 )] public short Inertger;
|
||||
|
||||
}
|
||||
}
|
||||
@@ -1,68 +0,0 @@
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
// file="IglConvertable.cs"
|
||||
// Project: StgSharp
|
||||
// AuthorGroup: Nitload Space
|
||||
// Copyright (c) Nitload Space. All rights reserved.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the “Software”), to deal in the Software without restriction,
|
||||
// including without limitation the rights to use, copy, modify, merge,
|
||||
// publish, distribute, sublicense, and/or sell copies of the Software,
|
||||
// and to permit persons to whom the Software is furnished to do so,
|
||||
// subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and
|
||||
// this permission notice shall be included in all copies
|
||||
// or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED “AS IS”,
|
||||
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
// ARISING FROM, OUT OF OR IN CONNECTION WITH
|
||||
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
//
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
using StgSharp.Graphics.OpenGL;
|
||||
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Text;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace StgSharp.Graphics.ShaderEdit
|
||||
{
|
||||
public interface IglConvertable
|
||||
{
|
||||
|
||||
/// <summary>
|
||||
///
|
||||
/// </summary>
|
||||
public void DisplayGLtypeDefinition();
|
||||
|
||||
/// <summary>
|
||||
///
|
||||
/// </summary>
|
||||
public void GainAllUniforms( ShaderProgram source, params string[] uniformName );
|
||||
|
||||
/// <summary>
|
||||
///
|
||||
/// </summary>
|
||||
/// <returns>
|
||||
///
|
||||
/// </returns>
|
||||
public ShaderStruct GetConvertedGLtype();
|
||||
|
||||
/// <summary>
|
||||
///
|
||||
/// </summary>
|
||||
public void SetAllUniforms();
|
||||
|
||||
}
|
||||
}
|
||||
@@ -1,288 +0,0 @@
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
// file="Shader.cs"
|
||||
// Project: StgSharp
|
||||
// AuthorGroup: Nitload Space
|
||||
// Copyright (c) Nitload Space. All rights reserved.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the “Software”), to deal in the Software without restriction,
|
||||
// including without limitation the rights to use, copy, modify, merge,
|
||||
// publish, distribute, sublicense, and/or sell copies of the Software,
|
||||
// and to permit persons to whom the Software is furnished to do so,
|
||||
// subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and
|
||||
// this permission notice shall be included in all copies
|
||||
// or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED “AS IS”,
|
||||
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
// ARISING FROM, OUT OF OR IN CONNECTION WITH
|
||||
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
//
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
using StgSharp;
|
||||
using StgSharp.Internal;
|
||||
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Diagnostics.CodeAnalysis;
|
||||
using System.IO;
|
||||
using System.Runtime.CompilerServices;
|
||||
using System.Runtime.InteropServices;
|
||||
using System.Text;
|
||||
using System.Xml.Linq;
|
||||
|
||||
namespace StgSharp.Graphics.OpenGL
|
||||
{
|
||||
public abstract partial class glRender : RenderStream
|
||||
{
|
||||
|
||||
/// <summary>
|
||||
/// Create an instance of <see cref="Shader" /> program
|
||||
/// </summary>
|
||||
/// <returns>
|
||||
/// New instance of <see cref="Shader" /> instance.
|
||||
/// </returns>
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
protected override sealed ShaderProgram CreateShaderProgram()
|
||||
{
|
||||
return new ShaderProgram( this );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
protected override sealed Shader CreateShaderSegment( ShaderType type, int count )
|
||||
{
|
||||
return new Shader( GL.CreateShaderSet( count, type ), type, this );
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
public class Shader : ISSDSerializable
|
||||
{
|
||||
|
||||
private readonly OpenGLFunction GL;
|
||||
internal readonly GlHandle[] handle;
|
||||
public readonly ShaderType type;
|
||||
|
||||
internal unsafe Shader( GlHandle[] handle, ShaderType usage, glRender stream )
|
||||
{
|
||||
this.handle = handle;
|
||||
GL = stream.GL;
|
||||
type = usage;
|
||||
}
|
||||
|
||||
public SerializableTypeCode SSDTypeCode => SerializableTypeCode.Shader;
|
||||
|
||||
/// <summary>
|
||||
/// Attach one shader code to a shader program.
|
||||
/// </summary>
|
||||
/// <param _label="target">
|
||||
/// Shader program to attach
|
||||
/// </param>
|
||||
/// <param _label="index">
|
||||
/// Index of shader code in current shader code set.
|
||||
/// </param>
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public void AttachTo( int index, [NotNull]ShaderProgram target )
|
||||
{
|
||||
GL.AttachShader( target.handle, handle[ index ] );
|
||||
}
|
||||
|
||||
public void CheckStatus( int index, ShaderStatus status )
|
||||
{
|
||||
string log = GL.GetShaderStatus( this, index, ( int )status );
|
||||
if( !string.IsNullOrEmpty( log ) ) {
|
||||
throw new InvalidOperationException( $"{$"Shader Error \t{status}\n"}{log}" );
|
||||
}
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public unsafe void Compile( int index, ReadOnlySpan<byte> codeU8Stream )
|
||||
{
|
||||
GL.LoadShaderSource( handle[ index ], codeU8Stream );
|
||||
GL.CompileShader( handle[ index ] );
|
||||
CheckStatus( index, ShaderStatus.CompileStatus );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public unsafe void Compile( int index, byte[] codeStream )
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull( codeStream );
|
||||
GL.LoadShaderSource( handle[ index ], codeStream );
|
||||
GL.CompileShader( handle[ index ] );
|
||||
CheckStatus( index, ShaderStatus.CompileStatus );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public unsafe void Compile( int index, string codeStream )
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull( codeStream );
|
||||
GL.LoadShaderSource( handle[ index ], codeStream.AsSpan() );
|
||||
GL.CompileShader( handle[ index ] );
|
||||
CheckStatus( index, ShaderStatus.CompileStatus );
|
||||
}
|
||||
|
||||
public void FromBytes( byte[] stream )
|
||||
{
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
public static byte[] FromCodeFile( string fileRoute )
|
||||
{
|
||||
string str = File.ReadAllText( fileRoute );
|
||||
if( string.IsNullOrEmpty( str ) ) {
|
||||
throw new InvalidOperationException( $"Cannot load and GLSL code from {fileRoute}" );
|
||||
}
|
||||
return Encoding.UTF8.GetBytes( str );
|
||||
}
|
||||
|
||||
public byte[] GetBytes()
|
||||
{
|
||||
return Array.Empty<byte>();
|
||||
}
|
||||
|
||||
public byte[] GetBytes( out int length )
|
||||
{
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
public override string ToString()
|
||||
{
|
||||
return $"This is a {type} shader, its shader handles are {handle.ToString()}.";
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
public enum ShaderStatus : int
|
||||
{
|
||||
|
||||
CompileStatus = glConst.COMPILE_STATUS,
|
||||
|
||||
}
|
||||
|
||||
public class ShaderProgram
|
||||
{
|
||||
|
||||
private readonly OpenGLFunction GL;
|
||||
internal readonly GlHandle handle;
|
||||
|
||||
/// <summary>
|
||||
/// CustomizeInit a program with no shader attached.
|
||||
/// </summary>
|
||||
internal unsafe ShaderProgram( glRender binding )
|
||||
{
|
||||
GL = binding.GL;
|
||||
handle = GL.CreateProgram();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Get a uniform form current shader, the value type of the uniform should be provided.
|
||||
/// </summary>
|
||||
/// <param _label="name">
|
||||
/// ContextName of the Uniform in shader code
|
||||
/// </param>
|
||||
/// <returns>
|
||||
///
|
||||
/// </returns>
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public unsafe Uniform<T> GetUniform<T>( string name ) where T: struct
|
||||
{
|
||||
return new Uniform<T>( GL.GetUniformLocation( this.handle, name ) );
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Get a uniform form current shader, the value type of the uniform should be provided.
|
||||
/// </summary>
|
||||
/// <param _label="name">
|
||||
/// ContextName of the Uniform in shader code
|
||||
/// </param>
|
||||
/// <returns>
|
||||
///
|
||||
/// </returns>
|
||||
public unsafe Uniform<T, U> GetUniform<T, U>( string name ) where T: struct where U: struct
|
||||
{
|
||||
return new Uniform<T, U>( GL.GetUniformLocation( this.handle, name ) );
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Get a uniform form current shader, the value type of the uniform should be provided.
|
||||
/// </summary>
|
||||
/// <param _label="name">
|
||||
/// ContextName of the Uniform in shader code
|
||||
/// </param>
|
||||
/// <returns>
|
||||
///
|
||||
/// </returns>
|
||||
public unsafe Uniform<T, U, V> GetUniform<T, U, V>( string name ) where T: struct
|
||||
where U: struct
|
||||
where V: struct
|
||||
{
|
||||
return new Uniform<T, U, V>( GL.GetUniformLocation( this.handle, name ) );
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Get a uniform form current shader, the value type of the uniform should be provided.
|
||||
/// </summary>
|
||||
/// <param _label="name">
|
||||
/// ContextName of the Uniform in shader code
|
||||
/// </param>
|
||||
/// <returns>
|
||||
///
|
||||
/// </returns>
|
||||
public unsafe Uniform<T, U, V, W> GetUniform<T, U, V, W>( string name ) where T: struct
|
||||
where U: struct
|
||||
where V: struct
|
||||
where W: struct
|
||||
{
|
||||
return new Uniform<T, U, V, W>( GL.GetUniformLocation( this.handle, name ) );
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Link the shader to current viewPortDisplay.
|
||||
/// </summary>
|
||||
public unsafe void Link()
|
||||
{
|
||||
if( InternalIO.InternalLinkShaderProgram(
|
||||
( OpenglContext* )this.GL.ContextHandle, handle.Value ) ==
|
||||
0 )
|
||||
{
|
||||
IntPtr logPtr = InternalIO.InternalReadSSCLog();
|
||||
try
|
||||
{
|
||||
byte[] logByte = new byte[512];
|
||||
Marshal.Copy( logPtr, logByte, 0, 512 );
|
||||
string log = Encoding.UTF8.GetString( logByte );
|
||||
log = log.Replace( "\0", string.Empty );
|
||||
InternalIO.InternalWriteLog( log, LogType.Error );
|
||||
}
|
||||
catch( Exception ex )
|
||||
{
|
||||
InternalIO.InternalWriteLog( ex.Message, LogType.Error );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Let the current viewPortDisplay use this shader.
|
||||
/// </summary>
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public unsafe void Use()
|
||||
{
|
||||
GL.UseProgram( handle );
|
||||
}
|
||||
|
||||
~ShaderProgram()
|
||||
{
|
||||
//handle.Dispose();
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
@@ -1,205 +0,0 @@
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
// file="Uniform.cs"
|
||||
// Project: StepVisualizer
|
||||
// AuthorGroup: Nitload Space
|
||||
// Copyright (c) Nitload Space. All rights reserved.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the “Software”), to deal in the Software without restriction,
|
||||
// including without limitation the rights to use, copy, modify, merge,
|
||||
// publish, distribute, sublicense, and/or sell copies of the Software,
|
||||
// and to permit persons to whom the Software is furnished to do so,
|
||||
// subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and
|
||||
// this permission notice shall be included in all copies
|
||||
// or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED “AS IS”,
|
||||
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
// ARISING FROM, OUT OF OR IN CONNECTION WITH
|
||||
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
//
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
using StgSharp.Graphics;
|
||||
using StgSharp.Math;
|
||||
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Diagnostics.CodeAnalysis;
|
||||
using System.Linq;
|
||||
using System.Numerics;
|
||||
using System.Runtime.CompilerServices;
|
||||
using System.Runtime.InteropServices;
|
||||
using System.Text;
|
||||
|
||||
namespace StgSharp.Graphics.OpenGL
|
||||
{
|
||||
public class Uniform
|
||||
{
|
||||
|
||||
internal GlHandle id;
|
||||
|
||||
public GlHandle Handle
|
||||
{
|
||||
get => id;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
public sealed class Uniform<T> : Uniform where T: struct
|
||||
{
|
||||
|
||||
internal Uniform() { }
|
||||
|
||||
internal unsafe Uniform( GlHandle id )
|
||||
{
|
||||
this.id = id;
|
||||
}
|
||||
|
||||
internal static Uniform<T> FromHandle( GlHandle handle )
|
||||
{
|
||||
return new Uniform<T>
|
||||
{
|
||||
id = handle
|
||||
};
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
public sealed class Uniform<T, U> : Uniform where T: struct where U: struct
|
||||
{
|
||||
|
||||
internal Uniform() { }
|
||||
|
||||
internal unsafe Uniform( GlHandle id )
|
||||
{
|
||||
this.id = id;
|
||||
}
|
||||
|
||||
internal static Uniform<T, U> FromHandle( GlHandle handle )
|
||||
{
|
||||
return new Uniform<T, U>
|
||||
{
|
||||
id = handle
|
||||
};
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
public sealed class Uniform<T, U, V> : Uniform where T: struct where U: struct where V: struct
|
||||
{
|
||||
|
||||
internal Uniform() { }
|
||||
|
||||
internal unsafe Uniform( GlHandle id )
|
||||
{
|
||||
this.id = id;
|
||||
}
|
||||
|
||||
internal static Uniform<T, U, V> FromHandle( GlHandle handle )
|
||||
{
|
||||
return new Uniform<T, U, V>
|
||||
{
|
||||
id = handle
|
||||
};
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
public sealed class Uniform<T, U, V, W> : Uniform where T: struct where U: struct
|
||||
where V: struct
|
||||
where W: struct
|
||||
{
|
||||
|
||||
internal Uniform() { }
|
||||
|
||||
internal unsafe Uniform( GlHandle id )
|
||||
{
|
||||
this.id = id;
|
||||
}
|
||||
|
||||
internal static Uniform<T, U, V, W> FromHandle( GlHandle handle )
|
||||
{
|
||||
return new Uniform<T, U, V, W>
|
||||
{
|
||||
id = handle
|
||||
};
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
public unsafe partial class OpenGLFunction
|
||||
{
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public void SetUniformValue( [NotNull] Uniform<Matrix44> uniform, Matrix44 mat )
|
||||
{
|
||||
Matrix44 temp = mat;
|
||||
Context.glUniformMatrix4fv( uniform.id.SignedValue, 1, false, ( float* )&temp );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public void SetUniformValue(
|
||||
[NotNull]Uniform<float, float, float, float> uniform,
|
||||
Vec4 vec )
|
||||
{
|
||||
Vec4 temp = vec;
|
||||
Context.glUniform1fv( uniform.id.SignedValue, 4, &temp.reg );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public void SetUniformValue( [NotNull]Uniform<Vec4> uniform, Vec4 vec )
|
||||
{
|
||||
Vec4 temp = vec;
|
||||
Context.glUniform1fv( uniform.id.SignedValue, 4, &temp.reg );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public void SetUniformValue( [NotNull]Uniform<float> uniform, float v0 )
|
||||
{
|
||||
Context.glUniform1f( uniform.id.SignedValue, v0 );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public void SetUniformValue( [NotNull]Uniform<int> uniform, int i0 )
|
||||
{
|
||||
Context.glUniform1i( uniform.id.SignedValue, i0 );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public void SetUniformValue( [NotNull] Uniform<float, float> uniform, float v0, float v1 )
|
||||
{
|
||||
Context.glUniform2f( uniform.id.SignedValue, v0, v1 );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public void SetUniformValue(
|
||||
[NotNull] Uniform<float, float, float> uniform,
|
||||
float v0,
|
||||
float v1,
|
||||
float v2 )
|
||||
{
|
||||
Context.glUniform3f( uniform.id.SignedValue, v0, v1, v2 );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public void SetUniformValue(
|
||||
[NotNull] Uniform<float, float, float, float> uniform,
|
||||
float v0,
|
||||
float v1,
|
||||
float v2,
|
||||
float v3 )
|
||||
{
|
||||
Context.glUniform4f( uniform.id.SignedValue, v0, v1, v2, v3 );
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
@@ -1,44 +0,0 @@
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
// file="glAPICalling.cs"
|
||||
// Project: StgSharp
|
||||
// AuthorGroup: Nitload Space
|
||||
// Copyright (c) Nitload Space. All rights reserved.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the “Software”), to deal in the Software without restriction,
|
||||
// including without limitation the rights to use, copy, modify, merge,
|
||||
// publish, distribute, sublicense, and/or sell copies of the Software,
|
||||
// and to permit persons to whom the Software is furnished to do so,
|
||||
// subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and
|
||||
// this permission notice shall be included in all copies
|
||||
// or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED “AS IS”,
|
||||
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
// ARISING FROM, OUT OF OR IN CONNECTION WITH
|
||||
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
//
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Text;
|
||||
|
||||
namespace StgSharp.Graphics.OpenGL
|
||||
{
|
||||
[AttributeUsage( AttributeTargets.Method )]
|
||||
public sealed class OpenGLAPICallingAttribute : Attribute
|
||||
{
|
||||
|
||||
public OpenGLAPICallingAttribute() { }
|
||||
|
||||
}
|
||||
}
|
||||
+24
-27
@@ -1,33 +1,30 @@
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
// file="glApiManagerConst.cs"
|
||||
// Project: StgSharp
|
||||
// AuthorGroup: Nitload Space
|
||||
// Copyright (c) Nitload Space. All rights reserved.
|
||||
// -----------------------------------------------------------------------
|
||||
// file="glApiManagerConst"
|
||||
// Project: StgSharp
|
||||
// AuthorGroup: Nitload
|
||||
// Copyright (c) Nitload. All rights reserved.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the “Software”), to deal in the Software without restriction,
|
||||
// including without limitation the rights to use, copy, modify, merge,
|
||||
// publish, distribute, sublicense, and/or sell copies of the Software,
|
||||
// and to permit persons to whom the Software is furnished to do so,
|
||||
// subject to the following conditions:
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
// of this software and associated documentation files (the "Software"), to deal
|
||||
// in the Software without restriction, including without limitation the rights
|
||||
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
// copies of the Software, and to permit persons to whom the Software is
|
||||
// furnished to do so, subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be included in all
|
||||
// copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
// SOFTWARE.
|
||||
//
|
||||
// The above copyright notice and
|
||||
// this permission notice shall be included in all copies
|
||||
// or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED “AS IS”,
|
||||
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
// ARISING FROM, OUT OF OR IN CONNECTION WITH
|
||||
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
//
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
// -----------------------------------------------------------------------
|
||||
// -----------------------------------------------------------------------
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Text;
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -1,92 +0,0 @@
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
// file="glClampf.cs"
|
||||
// Project: StgSharp
|
||||
// AuthorGroup: Nitload Space
|
||||
// Copyright (c) Nitload Space. All rights reserved.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the “Software”), to deal in the Software without restriction,
|
||||
// including without limitation the rights to use, copy, modify, merge,
|
||||
// publish, distribute, sublicense, and/or sell copies of the Software,
|
||||
// and to permit persons to whom the Software is furnished to do so,
|
||||
// subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and
|
||||
// this permission notice shall be included in all copies
|
||||
// or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED “AS IS”,
|
||||
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
// ARISING FROM, OUT OF OR IN CONNECTION WITH
|
||||
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
//
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Runtime.InteropServices;
|
||||
using System.Text;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace StgSharp.Internal
|
||||
{
|
||||
/// <summary>
|
||||
/// OpenGL numeric type. An IEEE-754 floating-point value, clamped to the range [0,1].
|
||||
/// </summary>
|
||||
[StructLayout( LayoutKind.Sequential )]
|
||||
public struct GLclampf
|
||||
{
|
||||
|
||||
public float value;
|
||||
|
||||
public GLclampf( float a )
|
||||
{
|
||||
value = a;
|
||||
}
|
||||
|
||||
public static explicit operator float( GLclampf v )
|
||||
{
|
||||
return v.value;
|
||||
}
|
||||
|
||||
public static explicit operator GLclampf( float v )
|
||||
{
|
||||
return new GLclampf( v );
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// OpenGL numeric type. An IEEE-754 double precision floating-point value, clamped to the
|
||||
/// range [0,1].
|
||||
/// </summary>
|
||||
[StructLayout( LayoutKind.Sequential )]
|
||||
public struct GLclampd
|
||||
{
|
||||
|
||||
public double value;
|
||||
|
||||
public GLclampd( double a )
|
||||
{
|
||||
value = a;
|
||||
}
|
||||
|
||||
public static explicit operator double( GLclampd v )
|
||||
{
|
||||
return v.value;
|
||||
}
|
||||
|
||||
public static explicit operator GLclampd( double v )
|
||||
{
|
||||
return new GLclampd( v );
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -1,227 +0,0 @@
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
// file="glEnum.cs"
|
||||
// Project: StepVisualizer
|
||||
// AuthorGroup: Nitload Space
|
||||
// Copyright (c) Nitload Space. All rights reserved.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the “Software”), to deal in the Software without restriction,
|
||||
// including without limitation the rights to use, copy, modify, merge,
|
||||
// publish, distribute, sublicense, and/or sell copies of the Software,
|
||||
// and to permit persons to whom the Software is furnished to do so,
|
||||
// subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and
|
||||
// this permission notice shall be included in all copies
|
||||
// or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED “AS IS”,
|
||||
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
// ARISING FROM, OUT OF OR IN CONNECTION WITH
|
||||
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
//
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
using System.Runtime.CompilerServices;
|
||||
|
||||
namespace StgSharp.Graphics.OpenGL
|
||||
{
|
||||
public enum PixelChannelLayout
|
||||
{
|
||||
|
||||
UByte = glConst.UNSIGNED_BYTE,
|
||||
Byte = glConst.BYTE,
|
||||
UShort = glConst.UNSIGNED_SHORT,
|
||||
Short = glConst.SHORT,
|
||||
UInt = glConst.UNSIGNED_INT,
|
||||
Int = glConst.INT,
|
||||
Float = glConst.FLOAT,
|
||||
UByte332 = glConst.UNSIGNED_BYTE_3_3_2,
|
||||
UByte233Rev = glConst.UNSIGNED_BYTE_2_3_3_REV,
|
||||
UShort565 = glConst.UNSIGNED_SHORT_5_6_5,
|
||||
UShort565Rev = glConst.UNSIGNED_SHORT_5_6_5_REV,
|
||||
UShort4444 = glConst.UNSIGNED_SHORT_4_4_4_4,
|
||||
UShort4444Rev = glConst.UNSIGNED_SHORT_4_4_4_4_REV,
|
||||
UShort5551 = glConst.UNSIGNED_SHORT_5_5_5_1,
|
||||
UShort1555Rev = glConst.UNSIGNED_SHORT_1_5_5_5_REV,
|
||||
UInt8888 = glConst.UNSIGNED_INT_8_8_8_8,
|
||||
UInt8888Rev = glConst.UNSIGNED_INT_8_8_8_8_REV,
|
||||
UInt1010102 = glConst.UNSIGNED_INT_10_10_10_2,
|
||||
UInt2101010Rev = glConst.UNSIGNED_INT_2_10_10_10_REV
|
||||
|
||||
}
|
||||
|
||||
public enum FaceMode
|
||||
{
|
||||
|
||||
Point = glConst.POINT,
|
||||
Line = glConst.LINE,
|
||||
Fill = glConst.FILL
|
||||
|
||||
}
|
||||
|
||||
public enum FrameBufferStatus
|
||||
{
|
||||
|
||||
Complete = glConst.FRAMEBUFFER_COMPLETE, // GL_FRAMEBUFFER_COMPLETE
|
||||
IncompleteAttachment = glConst.FRAMEBUFFER_INCOMPLETE_ATTACHMENT, // GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT
|
||||
IncompleteMissingAttachment = glConst.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT, // GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT
|
||||
IncompleteDrawBuffer = glConst.FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER, // GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER
|
||||
IncompleteReadBuffer = glConst.FRAMEBUFFER_INCOMPLETE_READ_BUFFER, // GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER
|
||||
Unsupported = glConst.FRAMEBUFFER_UNSUPPORTED, // GL_FRAMEBUFFER_UNSUPPORTED
|
||||
IncompleteMultisample = glConst.FRAMEBUFFER_INCOMPLETE_MULTISAMPLE, // GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE
|
||||
IncompleteLayerTargets = glConst.FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS // GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS
|
||||
|
||||
}
|
||||
|
||||
public enum FrameBufferChannel
|
||||
{
|
||||
|
||||
STENCIL_INDEX = glConst.STENCIL_INDEX,
|
||||
DEPTH_COMPONENT = glConst.DEPTH_COMPONENT,
|
||||
DEPTH_STENCIL = glConst.DEPTH_STENCIL,
|
||||
RED = glConst.RED,
|
||||
GREEN = glConst.GREEN,
|
||||
BLUE = glConst.BLUE,
|
||||
RGB = glConst.RGB,
|
||||
BGR = glConst.BGR,
|
||||
RGBA = glConst.RGBA,
|
||||
BGRA = glConst.BGRA
|
||||
|
||||
}
|
||||
|
||||
public enum FrameBufferAttachment
|
||||
{
|
||||
|
||||
Color = glConst.COLOR_ATTACHMENT0,
|
||||
Depth = glConst.DEPTH_ATTACHMENT,
|
||||
Stencil = glConst.STENCIL_ATTACHMENT,
|
||||
DepthAndStencil = glConst.DEPTH_STENCIL_ATTACHMENT,
|
||||
|
||||
}
|
||||
|
||||
public enum Texture2DTarget
|
||||
{
|
||||
|
||||
Texture2D = glConst.TEXTURE_2D,
|
||||
ProxyTexture2D = glConst.PROXY_TEXTURE_2D,
|
||||
Texture1DArray = glConst.TEXTURE_1D_ARRAY,
|
||||
ProxyTexture1DArray = glConst.PROXY_TEXTURE_1D_ARRAY,
|
||||
TextureRectangle = glConst.TEXTURE_RECTANGLE,
|
||||
ProxyTextureRectangle = glConst.PROXY_TEXTURE_RECTANGLE,
|
||||
TextureCubeMapPositiveX = glConst.TEXTURE_CUBE_MAP_POSITIVE_X,
|
||||
TextureCubeMapNegativeX = glConst.TEXTURE_CUBE_MAP_NEGATIVE_X,
|
||||
TextureCubeMapPositiveY = glConst.TEXTURE_CUBE_MAP_POSITIVE_Y,
|
||||
TextureCubeMapNegativeY = glConst.TEXTURE_CUBE_MAP_NEGATIVE_Y,
|
||||
TextureCubeMapPositiveZ = glConst.TEXTURE_CUBE_MAP_POSITIVE_Z,
|
||||
TextureCubeMapNegativeZ = glConst.TEXTURE_CUBE_MAP_NEGATIVE_Z,
|
||||
ProxyTextureCubeMap = glConst.PROXY_TEXTURE_CUBE_MAP
|
||||
|
||||
}
|
||||
|
||||
public enum RenderBufferInternalFormat : uint
|
||||
{
|
||||
|
||||
RGBA8 = glConst.RGBA8,
|
||||
Depth24_Stencil8 = glConst.DEPTH24_STENCIL8,
|
||||
|
||||
}
|
||||
|
||||
public enum glOperation : uint
|
||||
{
|
||||
|
||||
StencilTest = glConst.STENCIL_TEST,
|
||||
DepthTest = glConst.DEPTH_TEST,
|
||||
PolygonOffsetFill = glConst.POLYGON_OFFSET_FILL,
|
||||
PolygonOffsetLine = glConst.POLYGON_OFFSET_LINE,
|
||||
PolygonOffsetPoint = glConst.POLYGON_OFFSET_POINT,
|
||||
|
||||
}
|
||||
|
||||
#pragma warning disable CA1008
|
||||
public enum ShaderType : int
|
||||
#pragma warning restore CA1008
|
||||
{
|
||||
|
||||
Fragment = glConst.FRAGMENT_SHADER,
|
||||
Vertex = glConst.VERTEX_SHADER,
|
||||
Compute = glConst.COMPUTE_SHADER,
|
||||
Geometry = glConst.GEOMETRY_SHADER,
|
||||
|
||||
}
|
||||
|
||||
#pragma warning disable CA1008
|
||||
public enum BufferType : int
|
||||
#pragma warning restore CA1008
|
||||
{
|
||||
|
||||
ArrayBuffer = glConst.ARRAY_BUFFER,
|
||||
ElementArrayBuffer = glConst.ELEMENT_ARRAY_BUFFER,
|
||||
AtomicCounterBuffer = glConst.ATOMIC_COUNTER_BUFFER,
|
||||
CopyHeadBuffer = glConst.COPY_READ_BUFFER,
|
||||
COPY_WRITE_BUFFER = glConst.COPY_WRITE_BUFFER,
|
||||
DISPATCH_INDIRECT_BUFFER = glConst.DISPATCH_INDIRECT_BUFFER,
|
||||
DRAW_INDIRECT_BUFFER = glConst.DRAW_INDIRECT_BUFFER,
|
||||
PIXEL_PACK_BUFFER = glConst.PIXEL_PACK_BUFFER,
|
||||
PIXEL_UNPACK_BUFFER = glConst.PIXEL_UNPACK_BUFFER,
|
||||
QUERY_BUFFER = glConst.QUERY_BUFFER,
|
||||
ShaderStorageBuffer = glConst.SHADER_STORAGE_BUFFER,
|
||||
TEXTURE_BUFFER = glConst.TEXTURE_BUFFER,
|
||||
TRANSFORM_FEEDBACK_BUFFER = glConst.TRANSFORM_FEEDBACK_BUFFER,
|
||||
UNIFORM_BUFFER = glConst.UNIFORM_BUFFER,
|
||||
|
||||
}
|
||||
|
||||
#pragma warning disable CA1008
|
||||
public enum BufferUsage : int
|
||||
#pragma warning restore CA1008
|
||||
{
|
||||
|
||||
StreamDraw = 0x88E0,
|
||||
StreamRead = 0x88E1,
|
||||
StreamCopy = 0x88E2,
|
||||
StaticDraw = 0x88E4,
|
||||
StaticRead = 0x88E5,
|
||||
StaticCopy = 0x88E6,
|
||||
DynamicDraw = 0x88E8,
|
||||
DynamicRead = 0x88E9,
|
||||
DynamicCopy = 0x88EA
|
||||
|
||||
}
|
||||
|
||||
public enum MaskBufferBit
|
||||
{
|
||||
|
||||
COLOR = glConst.COLOR_BUFFER_BIT,
|
||||
DEPTH = glConst.DEPTH_BUFFER_BIT,
|
||||
STENCIL = glConst.STENCIL_BUFFER_BIT,
|
||||
|
||||
}
|
||||
|
||||
public enum GeometryType : uint
|
||||
{
|
||||
|
||||
POINTS = 0x0000,
|
||||
LINES = 0x0001,
|
||||
LINE_LOOP = 0x0002,
|
||||
LINE_STRIP = 0x0003,
|
||||
TRIANGLES = 0x0004,
|
||||
TRIANGLE_STRIP = 0x0005,
|
||||
TRIANGLE_FAN = 0x0006
|
||||
|
||||
}
|
||||
|
||||
public enum TextureFiltering
|
||||
{
|
||||
|
||||
Nearest = 0x2600,
|
||||
Linear = 0x2601
|
||||
|
||||
}
|
||||
}
|
||||
@@ -1,104 +0,0 @@
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
// file="glException.cs"
|
||||
// Project: StgSharp
|
||||
// AuthorGroup: Nitload Space
|
||||
// Copyright (c) Nitload Space. All rights reserved.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the “Software”), to deal in the Software without restriction,
|
||||
// including without limitation the rights to use, copy, modify, merge,
|
||||
// publish, distribute, sublicense, and/or sell copies of the Software,
|
||||
// and to permit persons to whom the Software is furnished to do so,
|
||||
// subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and
|
||||
// this permission notice shall be included in all copies
|
||||
// or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED “AS IS”,
|
||||
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
// ARISING FROM, OUT OF OR IN CONNECTION WITH
|
||||
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
//
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Diagnostics;
|
||||
using System.IO;
|
||||
using System.Runtime.CompilerServices;
|
||||
using System.Runtime.Serialization;
|
||||
using System.Text;
|
||||
|
||||
namespace StgSharp.Graphics.OpenGL
|
||||
{
|
||||
public sealed class GlErrorOverflowException : Exception
|
||||
{
|
||||
|
||||
public GlErrorOverflowException( int errorCount, uint errorCode )
|
||||
: base(
|
||||
"Too many opengl error detected at certain position. " + $"The amount of errors exceeds {errorCount}. " + $"Code of the last error is {errorCode}" ) { }
|
||||
|
||||
}
|
||||
|
||||
public sealed class GlExecutionException : Exception
|
||||
{
|
||||
|
||||
public GlExecutionException( uint errorCode )
|
||||
: base( $"Critical OpenGL error: {errorCode}" ) { }
|
||||
|
||||
}
|
||||
|
||||
public sealed class GlArrayFormatException : Exception
|
||||
{
|
||||
|
||||
internal GlArrayFormatException( string message ) : base( message ) { }
|
||||
|
||||
internal GlArrayFormatException( SerializationInfo info, StreamingContext context )
|
||||
: base( info, context ) { }
|
||||
|
||||
internal GlArrayFormatException( string message, Exception innerException )
|
||||
: base( message, innerException ) { }
|
||||
|
||||
public GlArrayFormatException( PixelChannelLayout layout, string arrayname )
|
||||
: base( $"{arrayname} cannot be used as layout of {layout}" ) { }
|
||||
|
||||
}
|
||||
|
||||
public static partial class GlHelper
|
||||
{
|
||||
|
||||
public static bool CheckArrayFormat( this Array array, PixelChannelLayout layout )
|
||||
{
|
||||
return layout switch
|
||||
{
|
||||
PixelChannelLayout.Byte or PixelChannelLayout.UByte332 or PixelChannelLayout.UByte233Rev => ( array is byte[] ) ||
|
||||
( array is sbyte[] ),
|
||||
PixelChannelLayout.Short => array is short[],
|
||||
PixelChannelLayout.UShort => array is ushort[],
|
||||
PixelChannelLayout.Int => array is int[],
|
||||
PixelChannelLayout.Float => array is float[],
|
||||
PixelChannelLayout.UShort4444 => ( array is ushort[] ) || ( array is byte[] ),
|
||||
PixelChannelLayout.UByte => ( array is byte[] ) || ( array is sbyte[] ),
|
||||
PixelChannelLayout.UInt => array is uint[],
|
||||
PixelChannelLayout.UShort565 or
|
||||
PixelChannelLayout.UShort565Rev or
|
||||
PixelChannelLayout.UShort4444Rev or
|
||||
PixelChannelLayout.UShort5551 or
|
||||
PixelChannelLayout.UShort1555Rev => array is ushort[],
|
||||
PixelChannelLayout.UInt8888Rev or
|
||||
PixelChannelLayout.UInt1010102 or
|
||||
PixelChannelLayout.UInt2101010Rev => array is int[],
|
||||
PixelChannelLayout.UInt8888 => array is uint[] or byte[],
|
||||
_ => false,
|
||||
};
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
@@ -1,93 +0,0 @@
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
// file="glFucntionSourceManager.cs"
|
||||
// Project: StgSharp
|
||||
// AuthorGroup: Nitload Space
|
||||
// Copyright (c) Nitload Space. All rights reserved.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the ¡°Software¡±), to deal in the Software without restriction,
|
||||
// including without limitation the rights to use, copy, modify, merge,
|
||||
// publish, distribute, sublicense, and/or sell copies of the Software,
|
||||
// and to permit persons to whom the Software is furnished to do so,
|
||||
// subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and
|
||||
// this permission notice shall be included in all copies
|
||||
// or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED ¡°AS IS¡±,
|
||||
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
// ARISING FROM, OUT OF OR IN CONNECTION WITH
|
||||
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
//
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
using StgSharp;
|
||||
|
||||
using System;
|
||||
using System.Collections.Concurrent;
|
||||
using System.Collections.Generic;
|
||||
|
||||
namespace StgSharp.Graphics.OpenGL
|
||||
{
|
||||
public partial class OpenGLFunction
|
||||
{
|
||||
|
||||
private Lazy<int> textureUnitCountGetter;
|
||||
private Lazy<ConcurrentQueue<TextureUnit>> unusedTextureImageUintInitilizing;
|
||||
|
||||
public int TextureUnitCount
|
||||
{
|
||||
get => textureUnitCountGetter.Value;
|
||||
}
|
||||
|
||||
private ConcurrentQueue<TextureUnit> UnusedTextureImageUint
|
||||
{
|
||||
get => unusedTextureImageUintInitilizing.Value;
|
||||
}
|
||||
|
||||
internal void ReturnAvailableUnit( IEnumerable<TextureUnit> source )
|
||||
{
|
||||
int v = glConst.TEXTURE0 + TextureUnitCount;
|
||||
foreach( TextureUnit unit in source )
|
||||
{
|
||||
if( ( int )unit > v ) {
|
||||
throw new InvalidOperationException(
|
||||
"Source contains texture unit beyond context support." );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
internal int TryGetAvailableTextureUnit( int count, out IEnumerable<TextureUnit> result )
|
||||
{
|
||||
result = new Queue<TextureUnit>();
|
||||
for( int i = 0; i < count; i++ )
|
||||
{
|
||||
if( UnusedTextureImageUint.TryDequeue( out TextureUnit unit ) )
|
||||
{
|
||||
( result as Queue<TextureUnit> )!.Enqueue( unit );
|
||||
} else
|
||||
{
|
||||
return i;
|
||||
}
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
private ConcurrentQueue<TextureUnit> InitializeUnusedTextureImageUint()
|
||||
{
|
||||
ConcurrentQueue<TextureUnit> result = new ConcurrentQueue<TextureUnit>();
|
||||
for( int index = 0; index < TextureUnitCount; index++ ) {
|
||||
result.Enqueue( ( TextureUnit )( glConst.TEXTURE0 + index ) );
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
@@ -1,838 +0,0 @@
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
// file="glFunction.cs"
|
||||
// Project: StepVisualizer
|
||||
// AuthorGroup: Nitload Space
|
||||
// Copyright (c) Nitload Space. All rights reserved.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the “Software”), to deal in the Software without restriction,
|
||||
// including without limitation the rights to use, copy, modify, merge,
|
||||
// publish, distribute, sublicense, and/or sell copies of the Software,
|
||||
// and to permit persons to whom the Software is furnished to do so,
|
||||
// subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and
|
||||
// this permission notice shall be included in all copies
|
||||
// or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED “AS IS”,
|
||||
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
// ARISING FROM, OUT OF OR IN CONNECTION WITH
|
||||
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
//
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
using StgSharp.Graphics;
|
||||
using StgSharp.Internal;
|
||||
using StgSharp.Math;
|
||||
|
||||
using System;
|
||||
using System.Collections.Concurrent;
|
||||
using System.Collections.Generic;
|
||||
using System.Diagnostics;
|
||||
using System.Numerics;
|
||||
using System.Runtime.CompilerServices;
|
||||
using System.Runtime.ExceptionServices;
|
||||
using System.Runtime.InteropServices;
|
||||
using System.Text;
|
||||
using System.Threading;
|
||||
|
||||
namespace StgSharp.Graphics.OpenGL
|
||||
{
|
||||
public unsafe partial class OpenGLFunction
|
||||
{
|
||||
|
||||
private static Dictionary<IntPtr, OpenGLFunction> contextToGLMap = new Dictionary<IntPtr, OpenGLFunction>(
|
||||
);
|
||||
private static ThreadLocal<OpenGLFunction> _currentGL = new ThreadLocal<OpenGLFunction>();
|
||||
private OpenglContext* _context;
|
||||
|
||||
private Lazy<int> _attachmentColorRange;
|
||||
|
||||
private OpenGLFunction()
|
||||
{
|
||||
textureUnitCountGetter = new Lazy<int>(
|
||||
() => GetMaskInteger( glConst.MAX_TEXTURE_IMAGE_UNITS ) );
|
||||
unusedTextureImageUintInitilizing = new Lazy<ConcurrentQueue<TextureUnit>>(
|
||||
InitializeUnusedTextureImageUint );
|
||||
_attachmentColorRange = new Lazy<int>(
|
||||
() => {
|
||||
return GetMaskInteger( ( uint )glConst.MAX_COLOR_ATTACHMENTS );
|
||||
} );
|
||||
}
|
||||
|
||||
public int AttachmentColorRange
|
||||
{
|
||||
get => _attachmentColorRange.Value;
|
||||
}
|
||||
|
||||
public static OpenGLFunction CurrentGL
|
||||
{
|
||||
get { return _currentGL.Value; }
|
||||
internal set { _currentGL.Value = value; }
|
||||
}
|
||||
|
||||
internal IntPtr ContextHandle => ( IntPtr )_context;
|
||||
|
||||
protected ref OpenglContext Context
|
||||
{
|
||||
get
|
||||
{
|
||||
#if DEBUG
|
||||
if( ( IntPtr )_context == IntPtr.Zero )
|
||||
{
|
||||
throw new NullReferenceException();
|
||||
}
|
||||
#endif
|
||||
return ref ( *_context );
|
||||
}
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public void ActiveTextureUnit( uint type )
|
||||
{
|
||||
Context.glActiveTexture( type );
|
||||
}
|
||||
|
||||
[Conditional( "DEBUG" )]
|
||||
public void Assert( bool shouldReportWhenNormal )
|
||||
{
|
||||
uint code = Context.glGetError();
|
||||
if( code != glConst.NO_ERROR ) {
|
||||
throw new GlExecutionException( code );
|
||||
}
|
||||
if( shouldReportWhenNormal ) {
|
||||
Console.WriteLine( "OpenGL runs normally" );
|
||||
}
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public void AttachShader( GlHandle program, GlHandle shader )
|
||||
{
|
||||
Context.glAttachShader( program.Value, shader.Value );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public void BindBuffer( BufferType bufferType, GlHandle handle )
|
||||
{
|
||||
Context.glBindBuffer( ( uint )bufferType, handle.Value );
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Bind a frame Buffer to a frame Buffer target Same function as <see
|
||||
/// href="https://docs._gl/gl3/glBindFramebuffer"> glBindFramebuffer </see>.
|
||||
/// </summary>
|
||||
/// <param _label="target">
|
||||
/// The frame Buffer target of the binding operation.
|
||||
/// </param>
|
||||
/// <param _label="handle">
|
||||
/// The handle of the frame Buffer object to bind.
|
||||
/// </param>
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public void BindFrameBuffer( FrameBufferTarget target, GlHandle handle )
|
||||
{
|
||||
Context.glBindFramebuffer( ( uint )target, handle.Value );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public void BindRenderBuffer( GlHandle handle )
|
||||
{
|
||||
Context.glBindRenderbuffer( glConst.RENDERBUFFER, handle.Value );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public void BindTexture( uint type, GlHandle texture )
|
||||
{
|
||||
Context.glBindTexture( type, texture.Value );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public void BindVertexArray( GlHandle handle )
|
||||
{
|
||||
Context.glBindVertexArray( handle.Value );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public FrameBufferStatus CheckFrameBufferStatus( FrameBufferTarget target )
|
||||
{
|
||||
return ( FrameBufferStatus )Context.glCheckFramebufferStatus( ( uint )target );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public void Clear( MaskBufferBit mask )
|
||||
{
|
||||
Context.glClear( ( uint )mask );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public unsafe void ClearColor( float R, float G, float B, float A )
|
||||
{
|
||||
Context.glClearColor( R, G, B, A );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public void ClearError()
|
||||
{
|
||||
uint code = 0;
|
||||
for( int i = 0; i < 1024; i++ )
|
||||
{
|
||||
code = Context.glGetError();
|
||||
if( code == 0 ) {
|
||||
return;
|
||||
}
|
||||
|
||||
//Console.WriteLine(code);
|
||||
}
|
||||
foreach( ProcessThread thread in Process.GetCurrentProcess().Threads ) {
|
||||
Debugger.Break();
|
||||
}
|
||||
throw new GlErrorOverflowException( 1024, code );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public unsafe void ClearGraphicError()
|
||||
{
|
||||
while( Context.glGetError() != 0 ) { }
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public void CombineFrameBufferRenderBuffer(
|
||||
FrameBufferAttachment attachment,
|
||||
GlHandle rboHandle )
|
||||
{
|
||||
Context.glFramebufferRenderbuffer(
|
||||
glConst.FRAMEBUFFER, ( uint )attachment, glConst.RENDERBUFFER, rboHandle.Value );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public void CompileShader( GlHandle shaderhandle )
|
||||
{
|
||||
Context.glCompileShader( shaderhandle.Value );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public unsafe GlHandle CreateGraphicProgram()
|
||||
{
|
||||
return GlHandle.Alloc( Context.glCreateProgram() );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public GlHandle CreateProgram()
|
||||
{
|
||||
return GlHandle.Alloc( Context.glCreateProgram() );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public unsafe GlHandle[] CreateProgram( int count )
|
||||
{
|
||||
GlHandle[] h = new GlHandle[count];
|
||||
for( int i = 0; i < count; i++ ) {
|
||||
h.SetValue( i, Context.glCreateProgram() );
|
||||
}
|
||||
return h;
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public GlHandle[] CreateShaderSet( int count, ShaderType type )
|
||||
{
|
||||
GlHandle[] ret = new GlHandle[count];
|
||||
uint t = ( uint )type;
|
||||
for( int i = 0; i < count; i++ )
|
||||
{
|
||||
uint id = Context.glCreateShader( t );
|
||||
if( id == 0 )
|
||||
{
|
||||
uint error = Context.glGetError();
|
||||
throw new InvalidOperationException( $"Failed in creating shader: {error}" );
|
||||
}
|
||||
ret[ i ] = GlHandle.Alloc( id );
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public unsafe void DeleteBuffer( GlHandle handle )
|
||||
{
|
||||
Context.glDeleteBuffers( 1, ( uint* )&handle );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public unsafe void DeleteBuffers( GlHandle[] handle )
|
||||
{
|
||||
if( ( handle == null ) || ( handle.Length == 0 ) ) {
|
||||
throw new ArgumentNullException( nameof( handle ) );
|
||||
}
|
||||
fixed( GlHandle* hptr = handle )
|
||||
{
|
||||
uint* iptr = ( uint* )hptr;
|
||||
for( int i = 0; i < handle.Length; i++ ) {
|
||||
Context.glDeleteBuffers( 1, iptr + i );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Delete a render Buffer object Very simlilar function as <see
|
||||
/// href="https://docs.gl/gl3/glDeleteRenderbuffers"> glDeleteRenderbuffers </see>. The
|
||||
/// only deifference is that this mehtod can only delete one renderbuffer at the same
|
||||
/// time.
|
||||
/// </summary>
|
||||
/// <param _label="bufferHandle">
|
||||
/// Handle to Buffer to delete.
|
||||
/// </param>
|
||||
public unsafe void DeleteRenderBuffer( GlHandle bufferHandle )
|
||||
{
|
||||
Context.glDeleteRenderbuffers( 1, &bufferHandle.Value );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public unsafe void DeleteVertexArrays( GlHandle[] arrays )
|
||||
{
|
||||
fixed( GlHandle* hptr = arrays )
|
||||
{
|
||||
uint* iptr = ( uint* )hptr;
|
||||
for( int i = 0; i < arrays.Length; i++ ) {
|
||||
Context.glDeleteVertexArrays( 1, iptr + i );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void DepthMaskAccess( bool isWrite )
|
||||
{
|
||||
Context.glDepthMask( isWrite );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public void Disable( glOperation operation )
|
||||
{
|
||||
Context.glDisable( ( uint )operation );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public unsafe void DrawArrays( GeometryType mode, int first, uint count )
|
||||
{
|
||||
Context.glDrawArrays( ( uint )mode, first, count );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public unsafe void DrawElements( GeometryType mode, uint count, TypeCode type, IntPtr ptr )
|
||||
{
|
||||
uint a;
|
||||
a = type switch
|
||||
{
|
||||
TypeCode.UInt32 => glConst.UNSIGNED_INT,
|
||||
TypeCode.UInt16 => glConst.UNSIGNED_SHORT,
|
||||
TypeCode.Byte => glConst.UNSIGNED_BYTE,
|
||||
_ => throw new ArgumentException(
|
||||
$"{$"{$"Parameter error in parameter {nameof(type)} method DrawElements. "}"}{$"{$"Only {typeof(uint).Name},{typeof(ushort).Name},{typeof(byte).Name} types are supported."}"}" )
|
||||
};
|
||||
Context.glDrawElements( ( uint )mode, count, a, ( void* )ptr );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public void DrawElementsInstanced(
|
||||
GeometryType mode,
|
||||
uint count,
|
||||
TypeCode type,
|
||||
IntPtr ptr,
|
||||
uint amount )
|
||||
{
|
||||
uint a;
|
||||
switch( type )
|
||||
{
|
||||
case TypeCode.UInt32:
|
||||
a = glConst.UNSIGNED_INT;
|
||||
break;
|
||||
|
||||
case TypeCode.UInt16:
|
||||
a = glConst.UNSIGNED_SHORT;
|
||||
break;
|
||||
|
||||
case TypeCode.Byte:
|
||||
a = glConst.UNSIGNED_BYTE;
|
||||
break;
|
||||
default:
|
||||
InternalIO.InternalWriteLog(
|
||||
$"{$"Parameter error in parameter {nameof(type)} method DrawElements. "}{$"Only {typeof(uint).Name},{typeof(ushort).Name},{typeof(byte).Name} types are supported."}",
|
||||
LogType.Error );
|
||||
return;
|
||||
}
|
||||
Context.glDrawElementsInstanced( ( uint )mode, count, a, ( void* )ptr, amount );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public void Enable( glOperation operation )
|
||||
{
|
||||
Context.glEnable( ( uint )operation );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public void FrameBufferTexture2d(
|
||||
FrameBufferTarget target,
|
||||
uint attachment,
|
||||
Texture2DTarget texTarget,
|
||||
GlHandle textureHandle,
|
||||
int level )
|
||||
{
|
||||
Context.glFramebufferTexture2D(
|
||||
( uint )target, attachment, ( uint )texTarget, textureHandle.Value, level );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public unsafe GlHandle[] GenBuffers( int count )
|
||||
{
|
||||
GlHandle[] h = new GlHandle[count];
|
||||
fixed( GlHandle* hptr = h )
|
||||
{
|
||||
for( int i = 0; i < count; i++ ) {
|
||||
Context.glGenBuffers( count, ( ( uint* )hptr ) + i );
|
||||
}
|
||||
}
|
||||
return h;
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public void GenerateMipmap( Texture2DTarget target )
|
||||
{
|
||||
Context.glGenerateMipmap( ( uint )target );
|
||||
}
|
||||
|
||||
public unsafe GlHandle[] GenFrameBuffers( int count )
|
||||
{
|
||||
GlHandle[] h = new GlHandle[count];
|
||||
fixed( GlHandle* hptr = h ) {
|
||||
Context.glGenFramebuffers( 1, ( uint* )hptr );
|
||||
}
|
||||
return h;
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public unsafe GlHandle[] GenRenderBuffer( int count )
|
||||
{
|
||||
GlHandle[] h = new GlHandle[count];
|
||||
fixed( GlHandle* hptr = h ) {
|
||||
Context.glGenRenderbuffers( count, ( uint* )hptr );
|
||||
}
|
||||
return h;
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public unsafe GlHandle[] GenTextures( int count )
|
||||
{
|
||||
GlHandle[] h = new GlHandle[count];
|
||||
fixed( GlHandle* hptr = h ) {
|
||||
Context.glGenTextures( count, ( uint* )hptr );
|
||||
}
|
||||
return h;
|
||||
}
|
||||
|
||||
public unsafe GlHandle[] GenVertexArrays( int count )
|
||||
{
|
||||
GlHandle[] h = new GlHandle[count];
|
||||
fixed( GlHandle* hptr = h ) {
|
||||
Context.glGenVertexArrays( count, ( uint* )hptr );
|
||||
}
|
||||
return h;
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public uint GetError()
|
||||
{
|
||||
return Context.glGetError();
|
||||
}
|
||||
|
||||
public unsafe int GetMaskInteger( uint statusCode )
|
||||
{
|
||||
int ret = 0;
|
||||
Context.glGetIntegerv( statusCode, &ret );
|
||||
return ret;
|
||||
}
|
||||
|
||||
public string GetShaderStatus( Shader s, int index, int key )
|
||||
{
|
||||
IntPtr sptr = IntPtr.Zero;
|
||||
if( InternalIO.glCheckShaderStatus(
|
||||
ref Context, s.handle[ index ].Value, key, ref sptr ) ==
|
||||
0 ) {
|
||||
return Marshal.PtrToStringAnsi( sptr );
|
||||
}
|
||||
return string.Empty;
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public unsafe void GetTextureImage<T>(
|
||||
Texture2DTarget target,
|
||||
int level,
|
||||
ImageChannel channel,
|
||||
PixelChannelLayout channelLayout,
|
||||
T[] dataStream )
|
||||
where T: struct,INumber<T>
|
||||
{
|
||||
#pragma warning disable CS8500
|
||||
fixed( T* tptr = dataStream )
|
||||
{
|
||||
Context.glGetTexImage(
|
||||
( uint )target, level, ( uint )channel, ( uint )channelLayout, tptr );
|
||||
}
|
||||
#pragma warning restore CS8500
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public void GetTextureLevelProperty(
|
||||
uint textureTypeMask,
|
||||
int level,
|
||||
uint propertyMask,
|
||||
out int propertyValue )
|
||||
{
|
||||
fixed( int* iptr = &propertyValue ) {
|
||||
Context.glGetTexLevelParameteriv( textureTypeMask, level, propertyMask, iptr );
|
||||
}
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public unsafe GlHandle GetUniformLocation( GlHandle program, string name )
|
||||
{
|
||||
byte[] code = Encoding.UTF8.GetBytes( name );
|
||||
fixed( byte* ptr = code )
|
||||
{
|
||||
int ret = Context.glGetUniformLocation( program.Value, ptr );
|
||||
#if DEBUG
|
||||
if( ( ret == glConst.INVALID_OPERATION ) || ( ret == glConst.INVALID_VALUE ) )
|
||||
{
|
||||
throw new InvalidOperationException();
|
||||
}
|
||||
if( ret == -1 ) {
|
||||
throw new UniformEmptyReferenceException( nameof( program ), name );
|
||||
}
|
||||
#endif
|
||||
return GlHandle.SignedAlloc( ret );
|
||||
}
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public unsafe void LoadShaderSource( GlHandle shaderHandle, byte[] codeStream )
|
||||
{
|
||||
fixed( byte* streamPtr = codeStream ) {
|
||||
Context.glShaderSource( shaderHandle.Value, 1, &streamPtr, ( void* )0 );
|
||||
}
|
||||
}
|
||||
|
||||
public unsafe void LoadShaderSource( GlHandle shaderHandle, ReadOnlySpan<char> codeStream )
|
||||
{
|
||||
fixed( char* streamPtr = codeStream )
|
||||
{
|
||||
byte* bptr = ( byte* )streamPtr;
|
||||
Context.glShaderSource( shaderHandle.Value, 1, &bptr, ( void* )0 );
|
||||
}
|
||||
}
|
||||
|
||||
public unsafe void LoadShaderSource( GlHandle shaderHandle, ReadOnlySpan<byte> codeStream )
|
||||
{
|
||||
fixed( byte* streamPtr = codeStream )
|
||||
{
|
||||
byte* bptr = streamPtr;
|
||||
Context.glShaderSource( shaderHandle.Value, 1, &bptr, ( void* )0 );
|
||||
}
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public void PolygonMode( FaceMode mode )
|
||||
{
|
||||
Context.glPolygonMode( glConst.FRONT_AND_BACK, ( uint )mode );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public void PolygonOffset( float factor, float unit )
|
||||
{
|
||||
Context.glPolygonOffset( factor, unit );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public void ReadPixels(
|
||||
(int X, int Y) beginPosition,
|
||||
(int width, int height) size,
|
||||
FrameBufferChannel format,
|
||||
PixelChannelLayout dataType,
|
||||
ref byte[] stream )
|
||||
{
|
||||
fixed( byte* bptr = stream ) {
|
||||
Context.glReadPixels(
|
||||
beginPosition.X, beginPosition.Y, size.width, size.height, ( uint )format,
|
||||
( uint )dataType, bptr );
|
||||
}
|
||||
}
|
||||
|
||||
public void RereadImage(
|
||||
in Image i,
|
||||
(int X, int Y) beginPosition,
|
||||
FrameBufferChannel format,
|
||||
PixelChannelLayout dataType )
|
||||
{
|
||||
byte[] pixels = i.PixelBuffer;
|
||||
if( !pixels.CheckArrayFormat( dataType ) ) {
|
||||
throw new GlArrayFormatException( dataType, "i.PixelArray" );
|
||||
}
|
||||
fixed( byte* bptr = pixels ) {
|
||||
Context.glReadPixels(
|
||||
beginPosition.X, beginPosition.Y, i.Width, i.Height, ( uint )format,
|
||||
( uint )dataType, bptr );
|
||||
}
|
||||
i.PixelUpdateCount++;
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public unsafe void SetBufferData<T>(
|
||||
BufferType bufferType,
|
||||
T bufferData,
|
||||
BufferUsage usage )
|
||||
where T: struct
|
||||
{
|
||||
int size = Marshal.SizeOf<T>();
|
||||
#pragma warning disable CS8500
|
||||
T* p = &bufferData;
|
||||
#pragma warning restore CS8500
|
||||
Context.glBufferData( ( uint )bufferType, ( IntPtr )size, ( IntPtr )p, ( uint )usage );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public unsafe void SetBufferData<T>(
|
||||
BufferType bufferType,
|
||||
T[] bufferArray,
|
||||
BufferUsage usage )
|
||||
where T: struct,INumber<T>
|
||||
{
|
||||
int size = bufferArray.Length * Marshal.SizeOf( typeof( T ) );
|
||||
if( bufferArray == null ) {
|
||||
return;
|
||||
}
|
||||
#pragma warning disable CS8500
|
||||
fixed( void* bufferPtr = bufferArray )
|
||||
#pragma warning restore CS8500
|
||||
{
|
||||
Context.glBufferData(
|
||||
( uint )bufferType, ( IntPtr )size, ( IntPtr )bufferPtr, ( uint )usage );
|
||||
}
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public unsafe void SetBufferData<T>(
|
||||
BufferType bufferType,
|
||||
ReadOnlySpan<T> bufferSpan,
|
||||
BufferUsage usage )
|
||||
where T: struct,INumber<T>
|
||||
{
|
||||
int size = bufferSpan.Length * Marshal.SizeOf( typeof( T ) );
|
||||
if( bufferSpan == null ) {
|
||||
return;
|
||||
}
|
||||
#pragma warning disable CS8500
|
||||
fixed( void* bufferPtr = bufferSpan )
|
||||
#pragma warning restore CS8500
|
||||
{
|
||||
Context.glBufferData(
|
||||
( uint )bufferType, ( IntPtr )size, ( IntPtr )bufferPtr, ( uint )usage );
|
||||
}
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public unsafe void SetBufferData<T>(
|
||||
BufferType bufferType,
|
||||
Span<T> bufferArray,
|
||||
BufferUsage usage )
|
||||
where T: struct, INumber<T>
|
||||
{
|
||||
int size = bufferArray.Length * Marshal.SizeOf( typeof( T ) );
|
||||
if( bufferArray == null ) {
|
||||
return;
|
||||
}
|
||||
|
||||
#pragma warning disable CS8500
|
||||
fixed( void* bufferPtr = bufferArray )
|
||||
#pragma warning restore CS8500
|
||||
{
|
||||
Context.glBufferData(
|
||||
( uint )bufferType, ( IntPtr )size, ( IntPtr )bufferPtr, ( uint )usage );
|
||||
}
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public unsafe void SetBufferVectorData<T>(
|
||||
BufferType bufferType,
|
||||
ReadOnlySpan<T> bufferSpan,
|
||||
BufferUsage usage )
|
||||
where T: struct, IVector<T>
|
||||
{
|
||||
int size = bufferSpan.Length * Marshal.SizeOf( typeof( T ) );
|
||||
#pragma warning disable CS8500
|
||||
fixed( void* bufferPtr = bufferSpan )
|
||||
#pragma warning restore CS8500
|
||||
{
|
||||
Context.glBufferData(
|
||||
( uint )bufferType, ( IntPtr )size, ( IntPtr )bufferPtr, ( uint )usage );
|
||||
}
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public unsafe void SetBufferVectorData<T>(
|
||||
BufferType bufferType,
|
||||
T[] bufferArray,
|
||||
BufferUsage usage )
|
||||
where T: struct, IVector<T>
|
||||
{
|
||||
int size = bufferArray.Length * Marshal.SizeOf( typeof( T ) );
|
||||
if( bufferArray == null ) {
|
||||
return;
|
||||
}
|
||||
#pragma warning disable CS8500
|
||||
fixed( void* bufferPtr = bufferArray )
|
||||
#pragma warning restore CS8500
|
||||
{
|
||||
Context.glBufferData(
|
||||
( uint )bufferType, ( IntPtr )size, ( IntPtr )bufferPtr, ( uint )usage );
|
||||
}
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public unsafe void SetRenderBufferStorage(
|
||||
RenderBufferInternalFormat internalFormat,
|
||||
(int width, int height) size )
|
||||
{
|
||||
Context.glRenderbufferStorage(
|
||||
glConst.RENDERBUFFER, ( uint )internalFormat, size.width, size.height );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public unsafe void SetRenderBufferStorage(
|
||||
RenderBufferInternalFormat internalFormat,
|
||||
(uint width, uint height) size )
|
||||
{
|
||||
Context.glRenderbufferStorage(
|
||||
glConst.RENDERBUFFER, ( uint )internalFormat, ( int )size.width,
|
||||
( int )size.height );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public void SetVertexAttribute(
|
||||
uint index,
|
||||
int size,
|
||||
TypeCode t,
|
||||
bool normalized,
|
||||
uint stride,
|
||||
int pointer )
|
||||
{
|
||||
uint type = InternalIO.GLtype[ t ];
|
||||
Context.glVertexAttribPointer(
|
||||
index, size, type, normalized ? 1 : 0, stride, ( void* )pointer );
|
||||
Context.glEnableVertexAttribArray( index );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public void TextureImage2d<T>(
|
||||
Texture2DTarget target,
|
||||
int level,
|
||||
ImageChannel sourceChannel,
|
||||
uint width,
|
||||
uint height,
|
||||
ImageChannel targetChannel,
|
||||
PixelChannelLayout type,
|
||||
T[] pixels )
|
||||
where T: struct, INumber<T>
|
||||
{
|
||||
#pragma warning disable CS8500
|
||||
fixed( T* tptr = pixels )
|
||||
{
|
||||
T* ptr = ( ( pixels == null ) || ( pixels.Length == 0 ) ) ? ( T* )IntPtr.Zero : tptr;
|
||||
Context.glTexImage2D(
|
||||
( uint )target, level, ( uint )sourceChannel, width, height, 0,
|
||||
( uint )targetChannel, ( uint )type, tptr );
|
||||
}
|
||||
#pragma warning restore CS8500
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public void TextureImage2d<T>(
|
||||
Texture2DTarget target,
|
||||
int level,
|
||||
ImageChannel sourceChannel,
|
||||
uint width,
|
||||
uint height,
|
||||
ImageChannel targetChannel,
|
||||
PixelChannelLayout type,
|
||||
Span<T> pixelSpan )
|
||||
where T: struct, INumber<T>
|
||||
{
|
||||
#pragma warning disable CS8500
|
||||
fixed( T* tptr = pixelSpan )
|
||||
{
|
||||
Context.glTexImage2D(
|
||||
( uint )target, level, ( uint )sourceChannel, width, height, 0,
|
||||
( uint )targetChannel, ( uint )type, tptr );
|
||||
}
|
||||
#pragma warning restore CS8500
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public void TextureParameter( int target, uint pname, int param )
|
||||
{
|
||||
Context.glTexParameteri( ( uint )target, pname, param );
|
||||
}
|
||||
|
||||
public static bool TryGetFunctionPackage(
|
||||
IntPtr handle,
|
||||
out OpenGLFunction functionPackage )
|
||||
{
|
||||
return contextToGLMap.TryGetValue( handle, out functionPackage );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public void UseProgram( GlHandle program )
|
||||
{
|
||||
Context.glUseProgram( program.Value );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public void VertexAttributeDivisor( uint layoutIndex, uint divisor )
|
||||
{
|
||||
Context.glVertexAttribDivisor( layoutIndex, divisor );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public void Viewport( int x, int y, uint width, uint height )
|
||||
{
|
||||
Context.glViewport( x, y, width, height );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public void WaitAccomplishment()
|
||||
{
|
||||
Context.glFinish();
|
||||
}
|
||||
|
||||
internal static OpenGLFunction BuildGlFunctionPackage( IntPtr handle )
|
||||
{
|
||||
OpenGLFunction pack;
|
||||
if( contextToGLMap.TryGetValue( handle, out pack ) ) {
|
||||
return pack;
|
||||
}
|
||||
pack = new OpenGLFunction
|
||||
{
|
||||
_context = ( OpenglContext* )handle
|
||||
};
|
||||
contextToGLMap.Add( handle, pack );
|
||||
return pack;
|
||||
}
|
||||
|
||||
~OpenGLFunction()
|
||||
{
|
||||
contextToGLMap.Remove( ContextHandle );
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,72 +0,0 @@
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
// file="glHalfNV.cs"
|
||||
// Project: StepVisualizer
|
||||
// AuthorGroup: Nitload Space
|
||||
// Copyright (c) Nitload Space. All rights reserved.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the “Software”), to deal in the Software without restriction,
|
||||
// including without limitation the rights to use, copy, modify, merge,
|
||||
// publish, distribute, sublicense, and/or sell copies of the Software,
|
||||
// and to permit persons to whom the Software is furnished to do so,
|
||||
// subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and
|
||||
// this permission notice shall be included in all copies
|
||||
// or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED “AS IS”,
|
||||
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
// ARISING FROM, OUT OF OR IN CONNECTION WITH
|
||||
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
//
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Runtime.InteropServices;
|
||||
using System.Text;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace StgSharp.Graphics.OpenGL
|
||||
{
|
||||
[StructLayout( LayoutKind.Explicit, Size = 16 )]
|
||||
public struct glHalfNV
|
||||
{
|
||||
|
||||
[FieldOffset( 0 )] public short binary;
|
||||
|
||||
public glHalfNV( short bin )
|
||||
{
|
||||
binary = bin;
|
||||
}
|
||||
|
||||
public static glHalfNV FromInt16( short x )
|
||||
{
|
||||
return new glHalfNV( x );
|
||||
}
|
||||
|
||||
public static short ToInt16( glHalfNV half )
|
||||
{
|
||||
return half.binary;
|
||||
}
|
||||
|
||||
public static explicit operator glHalfNV( short x )
|
||||
{
|
||||
return new glHalfNV( x );
|
||||
}
|
||||
|
||||
public static explicit operator short( glHalfNV x )
|
||||
{
|
||||
return x.binary;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
@@ -1,79 +0,0 @@
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
// file="glHandle.cs"
|
||||
// Project: StepVisualizer
|
||||
// AuthorGroup: Nitload Space
|
||||
// Copyright (c) Nitload Space. All rights reserved.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the “Software”), to deal in the Software without restriction,
|
||||
// including without limitation the rights to use, copy, modify, merge,
|
||||
// publish, distribute, sublicense, and/or sell copies of the Software,
|
||||
// and to permit persons to whom the Software is furnished to do so,
|
||||
// subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and
|
||||
// this permission notice shall be included in all copies
|
||||
// or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED “AS IS”,
|
||||
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
// ARISING FROM, OUT OF OR IN CONNECTION WITH
|
||||
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
//
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Data.Common;
|
||||
using System.Linq;
|
||||
using System.Runtime.CompilerServices;
|
||||
using System.Runtime.InteropServices;
|
||||
using System.Runtime.Versioning;
|
||||
using System.Security.AccessControl;
|
||||
using System.Security.Cryptography;
|
||||
using System.Text;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace StgSharp.Graphics.OpenGL
|
||||
{
|
||||
[StructLayout( LayoutKind.Explicit, Size = 4 )]
|
||||
public struct GlHandle
|
||||
{
|
||||
|
||||
[FieldOffset( 0 )] internal int SignedValue;
|
||||
[FieldOffset( 0 )] internal uint Value;
|
||||
|
||||
public static GlHandle Zero
|
||||
{
|
||||
get => new GlHandle
|
||||
{
|
||||
Value = 0
|
||||
};
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public static GlHandle Alloc( uint value )
|
||||
{
|
||||
return new GlHandle
|
||||
{
|
||||
Value = value
|
||||
};
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public static GlHandle SignedAlloc( int value )
|
||||
{
|
||||
return new GlHandle
|
||||
{
|
||||
SignedValue = value
|
||||
};
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
@@ -1,123 +0,0 @@
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
// file="glRenderObjectGenrator.cs"
|
||||
// Project: StgSharp
|
||||
// AuthorGroup: Nitload Space
|
||||
// Copyright (c) Nitload Space. All rights reserved.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the “Software”), to deal in the Software without restriction,
|
||||
// including without limitation the rights to use, copy, modify, merge,
|
||||
// publish, distribute, sublicense, and/or sell copies of the Software,
|
||||
// and to permit persons to whom the Software is furnished to do so,
|
||||
// subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and
|
||||
// this permission notice shall be included in all copies
|
||||
// or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED “AS IS”,
|
||||
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
// ARISING FROM, OUT OF OR IN CONNECTION WITH
|
||||
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
//
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
using System;
|
||||
using System.Collections.Concurrent;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Runtime.CompilerServices;
|
||||
using System.Text;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace StgSharp.Graphics.OpenGL
|
||||
{
|
||||
public partial class glRender
|
||||
{
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
protected AutoTextureGL CreateAutoTexture( int count )
|
||||
{
|
||||
return new AutoTextureGL( count, this );
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Create a set of <see cref="ElementBuffer" />.
|
||||
/// </summary>
|
||||
/// <param _label="count">
|
||||
/// Amount of EBO to be created.
|
||||
/// </param>
|
||||
/// <returns>
|
||||
///
|
||||
/// </returns>
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
protected ElementBuffer CreateElementBuffer( int count )
|
||||
{
|
||||
return new ElementBuffer( count, this );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
protected FrameBuffer CreateFrameBuffer( int count )
|
||||
{
|
||||
return new FrameBuffer( count, this );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
protected RenderBuffer CreateRenderBuffer( int count )
|
||||
{
|
||||
return new RenderBuffer( count, this );
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Create a sets of <see cref="TextureGL" />
|
||||
/// </summary>
|
||||
/// <param _label="count">
|
||||
/// Amount of textures to be created.
|
||||
/// </param>
|
||||
/// <returns>
|
||||
///
|
||||
/// </returns>
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
protected TextureGL CreateTexture( int count )
|
||||
{
|
||||
return new TextureGL( count, this );
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Create a set of <see cref="VertexArray" />.
|
||||
/// </summary>
|
||||
/// <param _label="count">
|
||||
/// Amount of VAO to be created.
|
||||
/// </param>
|
||||
/// <returns>
|
||||
///
|
||||
/// </returns>
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
protected VertexArray CreateVertexArray( int count )
|
||||
{
|
||||
return new VertexArray( count, this );
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Create a set of <see cref="VertexBuffer" />.
|
||||
/// </summary>
|
||||
/// <param _label="count">
|
||||
/// Amount of Object to be created.
|
||||
/// </param>
|
||||
/// <returns>
|
||||
///
|
||||
/// </returns>
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
protected VertexBuffer CreateVertexBuffer( int count )
|
||||
{
|
||||
return new VertexBuffer( count, this );
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,46 @@
|
||||
//-----------------------------------------------------------------------
|
||||
// -----------------------------------------------------------------------
|
||||
// file="glRenderThreadSecurity"
|
||||
// Project: StgSharp
|
||||
// AuthorGroup: Nitload
|
||||
// Copyright (c) Nitload. All rights reserved.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
// of this software and associated documentation files (the "Software"), to deal
|
||||
// in the Software without restriction, including without limitation the rights
|
||||
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
// copies of the Software, and to permit persons to whom the Software is
|
||||
// furnished to do so, subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be included in all
|
||||
// copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
// SOFTWARE.
|
||||
//
|
||||
// -----------------------------------------------------------------------
|
||||
// -----------------------------------------------------------------------
|
||||
using System;
|
||||
using System.Collections.Concurrent;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Text;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace StgSharp.Graphics.OpenGL
|
||||
{
|
||||
public partial class glRender
|
||||
{
|
||||
|
||||
private static ConcurrentDictionary<Thread, glRender> threadLocalIndex
|
||||
= new();
|
||||
private readonly SynchronizationContext mainThreadContext = SynchronizationContext.Current;
|
||||
|
||||
}
|
||||
}
|
||||
@@ -1,189 +0,0 @@
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
// file="glRenderStream.cs"
|
||||
// Project: StepVisualizer
|
||||
// AuthorGroup: Nitload Space
|
||||
// Copyright (c) Nitload Space. All rights reserved.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the “Software”), to deal in the Software without restriction,
|
||||
// including without limitation the rights to use, copy, modify, merge,
|
||||
// publish, distribute, sublicense, and/or sell copies of the Software,
|
||||
// and to permit persons to whom the Software is furnished to do so,
|
||||
// subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and
|
||||
// this permission notice shall be included in all copies
|
||||
// or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED “AS IS”,
|
||||
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
// ARISING FROM, OUT OF OR IN CONNECTION WITH
|
||||
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
//
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
using StgSharp.Math;
|
||||
using StgSharp.Threading;
|
||||
|
||||
using System;
|
||||
using System.Collections.Concurrent;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Reflection;
|
||||
using System.Runtime.CompilerServices;
|
||||
using System.Runtime.InteropServices;
|
||||
using System.Text;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace StgSharp.Graphics.OpenGL
|
||||
{
|
||||
public abstract partial class glRender : RenderStream
|
||||
{
|
||||
|
||||
private protected static readonly ConcurrentDictionary<glRender, Thread> renderToThread
|
||||
= new ConcurrentDictionary<glRender, Thread>();
|
||||
|
||||
private OpenGLFunction _context;
|
||||
|
||||
protected internal OpenGLFunction GL
|
||||
{
|
||||
get { return _context; }
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Initialize an opengl context and load all opengl functions.
|
||||
/// </summary>
|
||||
public unsafe void InitializeContext()
|
||||
{
|
||||
if( ContextHandle == default )
|
||||
{
|
||||
ContextHandle = Marshal.AllocHGlobal( Marshal.SizeOf( typeof( OpenglContext ) ) );
|
||||
OpenglContext* contextID = ( OpenglContext* )ContextHandle;
|
||||
contextID->glGetString = ( delegate*<uint, IntPtr> )IntPtr.Zero;
|
||||
}
|
||||
if( GL == null ) {
|
||||
_context = OpenGLFunction.BuildGlFunctionPackage( ContextHandle );
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Initialize an OpenGl viewPortDisplay if current form has not been binded to any
|
||||
/// viewPortDisplay. and set the viewPortDisplay binded to current form as current OpenGL
|
||||
/// viewPortDisplay.
|
||||
/// </summary>
|
||||
/// <exception cref="Exception">
|
||||
/// Something goes wrong and World fails in creating a new OpenGL viewPortDisplay.
|
||||
/// </exception>
|
||||
public unsafe void MakeAsCurrentContext()
|
||||
{
|
||||
InternalIO.glfwMakeContextCurrent( CanvasHandle );
|
||||
OpenGLFunction.CurrentGL = this.GL;
|
||||
}
|
||||
|
||||
/// <inheritdoc />
|
||||
public override void RenderEnd()
|
||||
{
|
||||
if( !renderToThread.TryGetValue( this, out Thread t ) || t != Thread.CurrentThread ) {
|
||||
throw new InvalidOperationException(
|
||||
$"Current render has had been binded to thread {t!.ManagedThreadId}" );
|
||||
}
|
||||
SwapBuffers();
|
||||
renderToThread[ this ] = ThreadHelper.EmptyThread;
|
||||
InternalIO.glfwMakeContextCurrent( IntPtr.Zero );
|
||||
OpenGLFunction.CurrentGL = null;
|
||||
}
|
||||
|
||||
/// <inheritdoc />
|
||||
public override void RenderStart()
|
||||
{
|
||||
Thread current = Thread.CurrentThread;
|
||||
if( !renderToThread.TryGetValue( this, out Thread t ) || t == ThreadHelper.EmptyThread )
|
||||
{
|
||||
renderToThread[ this ] = current;
|
||||
MakeAsCurrentContext();
|
||||
return;
|
||||
}
|
||||
if( t != current ) {
|
||||
throw new InvalidOperationException(
|
||||
$"Current render has had been binded to thread {t!.ManagedThreadId}" );
|
||||
}
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public override void SetSizeLimit(
|
||||
int minWidth,
|
||||
int minHeight,
|
||||
int maxWidth,
|
||||
int maxHeight )
|
||||
{
|
||||
InternalIO.glfwSetWindowSizeLimits(
|
||||
this.CanvasHandle, minWidth, minHeight, maxWidth, maxHeight );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
internal override sealed void PlatformSpecifiedInitialize()
|
||||
{
|
||||
InitializeContext();
|
||||
MakeAsCurrentContext();
|
||||
glManager.LoadOpenGLApiTo( BindedViewPortContext.GraphicHandle );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
internal override sealed void Terminate()
|
||||
{
|
||||
CustomizeDeinit();
|
||||
}
|
||||
|
||||
protected override sealed Uniform<Matrix44> NativeCameraUniform(
|
||||
ShaderProgram source,
|
||||
string name )
|
||||
{
|
||||
NativeCamera.GainAllUniforms( source, name );
|
||||
return NativeCamera.convertedUniform;
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
protected override sealed void NativeCameraViewRange(
|
||||
Radius fieldOfRange,
|
||||
Vec2 offset,
|
||||
(float frontDepth, float backDepth) viewDepth )
|
||||
{
|
||||
NativeCamera.SetViewRange( fieldOfRange, this.Size, offset, viewDepth );
|
||||
}
|
||||
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
protected override sealed void NativeCameraViewTarget(
|
||||
Vec3 position,
|
||||
Vec3 direction,
|
||||
Vec3 up )
|
||||
{
|
||||
NativeCamera.SetViewDirection( position, direction, up );
|
||||
}
|
||||
|
||||
#region Key Control
|
||||
|
||||
protected KeyStatus CheckKey( KeyboardKey key )
|
||||
{
|
||||
return InternalIO.glfwGetKey( this.CanvasHandle, ( int )key );
|
||||
}
|
||||
|
||||
protected KeyStatus CheckKey( Mouse key )
|
||||
{
|
||||
return InternalIO.glfwGetKey( this.CanvasHandle, ( int )key );
|
||||
}
|
||||
|
||||
protected KeyStatus CheckKey( Joystick key )
|
||||
{
|
||||
return InternalIO.glfwGetKey( this.CanvasHandle, ( int )key );
|
||||
}
|
||||
|
||||
#endregion
|
||||
}
|
||||
}
|
||||
@@ -1,49 +0,0 @@
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
// file="glRenderThreadSecurity.cs"
|
||||
// Project: StgSharp
|
||||
// AuthorGroup: Nitload Space
|
||||
// Copyright (c) Nitload Space. All rights reserved.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the “Software”), to deal in the Software without restriction,
|
||||
// including without limitation the rights to use, copy, modify, merge,
|
||||
// publish, distribute, sublicense, and/or sell copies of the Software,
|
||||
// and to permit persons to whom the Software is furnished to do so,
|
||||
// subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and
|
||||
// this permission notice shall be included in all copies
|
||||
// or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED “AS IS”,
|
||||
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
// ARISING FROM, OUT OF OR IN CONNECTION WITH
|
||||
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
//
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
using System;
|
||||
using System.Collections.Concurrent;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Text;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace StgSharp.Graphics.OpenGL
|
||||
{
|
||||
public partial class glRender
|
||||
{
|
||||
|
||||
private static ConcurrentDictionary<Thread, glRender> threadLocalIndex
|
||||
= new ConcurrentDictionary<Thread, glRender>();
|
||||
private readonly SynchronizationContext mainThreadContext = SynchronizationContext.Current;
|
||||
|
||||
}
|
||||
}
|
||||
@@ -1,78 +0,0 @@
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
// file="glType.cs"
|
||||
// Project: StepVisualizer
|
||||
// AuthorGroup: Nitload Space
|
||||
// Copyright (c) Nitload Space. All rights reserved.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the “Software”), to deal in the Software without restriction,
|
||||
// including without limitation the rights to use, copy, modify, merge,
|
||||
// publish, distribute, sublicense, and/or sell copies of the Software,
|
||||
// and to permit persons to whom the Software is furnished to do so,
|
||||
// subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and
|
||||
// this permission notice shall be included in all copies
|
||||
// or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED “AS IS”,
|
||||
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
// ARISING FROM, OUT OF OR IN CONNECTION WITH
|
||||
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
//
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Collections.ObjectModel;
|
||||
using System.Runtime.InteropServices;
|
||||
using System.Text;
|
||||
|
||||
namespace StgSharp.Internal.OpenGL
|
||||
{
|
||||
internal delegate void GLVULKANPROCNV();
|
||||
|
||||
public unsafe struct glHandleARB
|
||||
{
|
||||
|
||||
private dynamic value;
|
||||
|
||||
public unsafe glHandleARB( dynamic value )
|
||||
{
|
||||
if( !RuntimeInformation.IsOSPlatform( OSPlatform.OSX ) )
|
||||
{
|
||||
if( value.GetType().Name != "Uint32" )
|
||||
{
|
||||
goto errorlog;
|
||||
}
|
||||
this.value = value;
|
||||
} else
|
||||
{
|
||||
if( value.GetType().Name != "IntPtr" )
|
||||
{
|
||||
goto errorlog;
|
||||
}
|
||||
this.value = value;
|
||||
}
|
||||
|
||||
errorlog:
|
||||
{
|
||||
InternalIO.InternalWriteLog(
|
||||
$"{value.GetType().Name} does not match definination of GLhandlARB on OS {Environment.OSVersion.Platform} ",
|
||||
LogType.Error );
|
||||
}
|
||||
}
|
||||
|
||||
public static implicit operator uint( glHandleARB value )
|
||||
{
|
||||
return ( uint )value;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
@@ -1,86 +0,0 @@
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
// file="Pixels.cs"
|
||||
// Project: StgSharp
|
||||
// AuthorGroup: Nitload Space
|
||||
// Copyright (c) Nitload Space. All rights reserved.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the “Software”), to deal in the Software without restriction,
|
||||
// including without limitation the rights to use, copy, modify, merge,
|
||||
// publish, distribute, sublicense, and/or sell copies of the Software,
|
||||
// and to permit persons to whom the Software is furnished to do so,
|
||||
// subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and
|
||||
// this permission notice shall be included in all copies
|
||||
// or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED “AS IS”,
|
||||
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
// ARISING FROM, OUT OF OR IN CONNECTION WITH
|
||||
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
//
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Runtime.InteropServices;
|
||||
using System.Text;
|
||||
|
||||
namespace StgSharp.Graphics
|
||||
{
|
||||
public interface IPixel
|
||||
{
|
||||
|
||||
public float Red { get; set; }
|
||||
|
||||
public float Green { get; set; }
|
||||
|
||||
public float Blue { get; set; }
|
||||
|
||||
public float Alpha { get; set; }
|
||||
|
||||
internal int Size { get; }
|
||||
|
||||
}
|
||||
|
||||
[StructLayout( LayoutKind.Explicit, Size = 32 )]
|
||||
public unsafe struct Pixel32RGBA : IPixel
|
||||
{
|
||||
|
||||
[FieldOffset( 0 )] private unsafe fixed byte data[ 4 ];
|
||||
|
||||
public int Size => 4;
|
||||
|
||||
float IPixel.Alpha
|
||||
{
|
||||
get => data[ 3 ] / 256 ;
|
||||
set => data[ 3 ] = ( byte )( value * 256 );
|
||||
}
|
||||
|
||||
float IPixel.Blue
|
||||
{
|
||||
get => data[ 2 ] / 256 ;
|
||||
set => data[ 2 ] = ( byte )( value * 256 );
|
||||
}
|
||||
|
||||
float IPixel.Green
|
||||
{
|
||||
get => data[ 1 ] / 256 ;
|
||||
set => data[ 1 ] = ( byte )( value * 256 );
|
||||
}
|
||||
|
||||
float IPixel.Red
|
||||
{
|
||||
get => data[ 0 ] / 256 ;
|
||||
set => data[ 0 ] = ( byte )( value * 256 );
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
@@ -1,94 +0,0 @@
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
// file="PlainGeometryMesh.cs"
|
||||
// Project: StgSharp
|
||||
// AuthorGroup: Nitload Space
|
||||
// Copyright (c) Nitload Space. All rights reserved.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the “Software”), to deal in the Software without restriction,
|
||||
// including without limitation the rights to use, copy, modify, merge,
|
||||
// publish, distribute, sublicense, and/or sell copies of the Software,
|
||||
// and to permit persons to whom the Software is furnished to do so,
|
||||
// subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and
|
||||
// this permission notice shall be included in all copies
|
||||
// or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED “AS IS”,
|
||||
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
// ARISING FROM, OUT OF OR IN CONNECTION WITH
|
||||
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
//
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
using StgSharp.Geometries;
|
||||
using StgSharp.Math;
|
||||
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Diagnostics.CodeAnalysis;
|
||||
using System.Linq;
|
||||
using System.Runtime.InteropServices;
|
||||
using System.Text;
|
||||
|
||||
namespace StgSharp.Graphics
|
||||
{
|
||||
public class PlainGeometryMesh
|
||||
{
|
||||
|
||||
private PlainGeometry _shape;
|
||||
private TextureProvider _texture;
|
||||
|
||||
public PlainGeometryMesh( [NotNull] PlainGeometry shape, [NotNull] TextureProvider texture )
|
||||
{
|
||||
if( shape.VertexCount > texture.TextureCoordinate.Length ) {
|
||||
throw new ArgumentException(
|
||||
paramName: nameof( texture ),
|
||||
message: "Amount of texture coordination is too less" );
|
||||
}
|
||||
_texture = texture;
|
||||
_shape = shape;
|
||||
}
|
||||
|
||||
//private Image _texture;
|
||||
|
||||
public PlainGeometryMesh( PlainGeometry shape, Image texture, Vec2[] texCoord )
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull( shape );
|
||||
ArgumentNullException.ThrowIfNull( texCoord );
|
||||
|
||||
if( shape.VertexCount > texCoord.Length ) {
|
||||
throw new ArgumentException(
|
||||
paramName: nameof( texCoord ),
|
||||
message: "Amount of texture coordination is too less" );
|
||||
}
|
||||
_texture = new TextureProvider( texture, texCoord );
|
||||
}
|
||||
|
||||
public Vec4[] VertexArray => _shape.VertexStream;
|
||||
|
||||
public Image TextureImage
|
||||
{
|
||||
get => _texture.ProvideImage();
|
||||
internal set => _texture.ReadImage( value );
|
||||
}
|
||||
|
||||
public ReadOnlySpan<int> MeshIndices => _shape.VertexIndices;
|
||||
|
||||
public ReadOnlySpan<Vec4> TextureCoord => MemoryMarshal.Cast<Vec2, Vec4>(
|
||||
_texture.TextureCoordinate );
|
||||
|
||||
public PlainGeometryMesh Resize( PlainGeometry newShape )
|
||||
{
|
||||
return new PlainGeometryMesh( newShape, _texture );
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
@@ -1,252 +0,0 @@
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
// file="RenderStream.cs"
|
||||
// Project: StepVisualizer
|
||||
// AuthorGroup: Nitload Space
|
||||
// Copyright (c) Nitload Space. All rights reserved.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the “Software”), to deal in the Software without restriction,
|
||||
// including without limitation the rights to use, copy, modify, merge,
|
||||
// publish, distribute, sublicense, and/or sell copies of the Software,
|
||||
// and to permit persons to whom the Software is furnished to do so,
|
||||
// subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and
|
||||
// this permission notice shall be included in all copies
|
||||
// or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED “AS IS”,
|
||||
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
// ARISING FROM, OUT OF OR IN CONNECTION WITH
|
||||
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
//
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
using StgSharp.Graphics.OpenGL;
|
||||
using StgSharp.Math;
|
||||
|
||||
using StgSharp.MVVM;
|
||||
using StgSharp.Timing;
|
||||
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.ComponentModel;
|
||||
using System.Diagnostics.CodeAnalysis;
|
||||
using System.Linq;
|
||||
using System.Runtime.CompilerServices;
|
||||
using System.Runtime.InteropServices;
|
||||
using System.Text;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace StgSharp.Graphics
|
||||
{
|
||||
public abstract class RenderStream
|
||||
{
|
||||
|
||||
private Camera nativeCamera;
|
||||
|
||||
private protected ViewPort primeArgs;
|
||||
internal TimeSpanProvider _timeProvider;
|
||||
|
||||
public (int width, int height) Size
|
||||
{
|
||||
get => (Width, Height);
|
||||
}
|
||||
|
||||
public abstract bool IsContextSharable { get; }
|
||||
|
||||
public int Height
|
||||
{
|
||||
get => primeArgs.Height;
|
||||
}
|
||||
|
||||
public int Width
|
||||
{
|
||||
get => primeArgs.Width;
|
||||
}
|
||||
|
||||
public IntPtr Monitor
|
||||
{
|
||||
get => primeArgs.Monitor;
|
||||
internal set => primeArgs.Monitor = value;
|
||||
}
|
||||
|
||||
public string Name
|
||||
{
|
||||
get => primeArgs.Name;
|
||||
}
|
||||
|
||||
public ViewPort BindedViewPortContext
|
||||
{
|
||||
get => primeArgs;
|
||||
internal set => primeArgs = value;
|
||||
}
|
||||
|
||||
internal IntPtr CanvasHandle
|
||||
{
|
||||
get => primeArgs.ViewPortHandle;
|
||||
}
|
||||
|
||||
internal IntPtr ContextHandle
|
||||
{
|
||||
get => primeArgs.GraphicHandle;
|
||||
private protected set => primeArgs.GraphicHandle = value;
|
||||
}
|
||||
|
||||
protected internal Camera NativeCamera
|
||||
{
|
||||
get => nativeCamera;
|
||||
internal set => nativeCamera = value;
|
||||
}
|
||||
|
||||
protected float FramePassed
|
||||
{
|
||||
get => _timeProvider.CurrentSpan;
|
||||
}
|
||||
|
||||
protected int PassedFrames
|
||||
{
|
||||
get => _timeProvider.CurrentSpan;
|
||||
}
|
||||
|
||||
protected float TimePassed
|
||||
{
|
||||
get => _timeProvider.CurrentSecond;
|
||||
}
|
||||
|
||||
protected TimeSpanProvider TimeProvider
|
||||
{
|
||||
get => _timeProvider;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Set the size limit of current form
|
||||
/// </summary>
|
||||
/// <param _label="minWidth">
|
||||
/// Minimum width of current form
|
||||
/// </param>
|
||||
/// <param _label="minHeight">
|
||||
/// Minimum height of current form
|
||||
/// </param>
|
||||
/// <param _label="maxWidth">
|
||||
/// Maximum width of current form
|
||||
/// </param>
|
||||
/// <param _label="maxHeight">
|
||||
/// Maximum height of current form
|
||||
/// </param>
|
||||
[MethodImpl( MethodImplOptions.AggressiveInlining )]
|
||||
public abstract void SetSizeLimit(
|
||||
int minWidth,
|
||||
int minHeight,
|
||||
int maxWidth,
|
||||
int maxHeight );
|
||||
|
||||
public static TTarget ShareContextFrom<TSource, TTarget>( [NotNull]TSource source )
|
||||
where TSource: RenderStream
|
||||
where TTarget: RenderStream, new()
|
||||
{
|
||||
TTarget target = new TTarget();
|
||||
target.Initialize( source.BindedViewPortContext, source._timeProvider );
|
||||
return target;
|
||||
}
|
||||
|
||||
/**/
|
||||
protected internal static void PollEvents()
|
||||
{
|
||||
InternalIO.glfwPollEvents();
|
||||
}
|
||||
|
||||
private protected void SwapBuffers()
|
||||
{
|
||||
InternalIO.glfwSwapBuffers( CanvasHandle );
|
||||
}
|
||||
|
||||
/**/
|
||||
|
||||
#region native camera operation
|
||||
|
||||
protected abstract void NativeCameraViewRange(
|
||||
Radius fieldOfRange,
|
||||
Vec2 offset,
|
||||
(float frontDepth, float backDepth) viewDepth );
|
||||
|
||||
protected abstract void NativeCameraViewTarget( Vec3 position, Vec3 direction, Vec3 up );
|
||||
|
||||
/// <summary>
|
||||
/// Get <see cref="Uniform{T}" />(TView is <see cref="Matrix44" />) uniform from a shader.
|
||||
/// This uniform will be used as projection matrix of this camera. Additionally, for
|
||||
/// multi- shader rendering, each shader requires a uniform, so do not ignore return
|
||||
/// value of this method.
|
||||
/// </summary>
|
||||
/// <param _label="source">
|
||||
/// Shader using this camera
|
||||
/// </param>
|
||||
/// <param _label="name">
|
||||
/// ContextName of projection camera named in shader
|
||||
/// </param>
|
||||
/// <returns>
|
||||
/// <see cref="Uniform{T}" />(TView is <see cref="Matrix44" />) representing projection
|
||||
/// matrix in shader program.
|
||||
/// </returns>
|
||||
protected abstract Uniform<Matrix44> NativeCameraUniform(
|
||||
ShaderProgram source,
|
||||
string name );
|
||||
|
||||
#endregion
|
||||
|
||||
#region internal operation
|
||||
|
||||
public void Initialize( ViewPort v, TimeSpanProvider timeProvider )
|
||||
{
|
||||
if( v == null ) {
|
||||
throw new ArgumentNullException( nameof( v ) );
|
||||
}
|
||||
primeArgs = v;
|
||||
this._timeProvider = timeProvider;
|
||||
nativeCamera = new Camera();
|
||||
PlatformSpecifiedInitialize();
|
||||
CustomizeInit();
|
||||
InternalIO.glfwMakeContextCurrent( IntPtr.Zero );
|
||||
}
|
||||
|
||||
internal abstract void PlatformSpecifiedInitialize();
|
||||
|
||||
internal abstract void Terminate();
|
||||
|
||||
#endregion
|
||||
|
||||
#region public operation
|
||||
|
||||
protected abstract void CustomizeDeinit();
|
||||
|
||||
protected abstract void CustomizeInit();
|
||||
|
||||
/// <summary>
|
||||
/// Marking the start of current render operations, and set this renser context as
|
||||
/// current.
|
||||
/// </summary>
|
||||
public abstract void RenderStart();
|
||||
|
||||
/// <summary>
|
||||
/// Marking the end of current render operations, and release the binding of this renser
|
||||
/// context to current, making it available for another thread as current.
|
||||
/// </summary>
|
||||
public abstract void RenderEnd();
|
||||
|
||||
#endregion
|
||||
|
||||
#region public resource generator
|
||||
|
||||
protected abstract Shader CreateShaderSegment( ShaderType type, int count );
|
||||
|
||||
protected abstract ShaderProgram CreateShaderProgram();
|
||||
|
||||
#endregion
|
||||
}
|
||||
}
|
||||
@@ -1,209 +0,0 @@
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
// file="ShaderGenerator.cs"
|
||||
// Project: StgSharp
|
||||
// AuthorGroup: Nitload Space
|
||||
// Copyright (c) Nitload Space. All rights reserved.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the “Software”), to deal in the Software without restriction,
|
||||
// including without limitation the rights to use, copy, modify, merge,
|
||||
// publish, distribute, sublicense, and/or sell copies of the Software,
|
||||
// and to permit persons to whom the Software is furnished to do so,
|
||||
// subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and
|
||||
// this permission notice shall be included in all copies
|
||||
// or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED “AS IS”,
|
||||
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
// ARISING FROM, OUT OF OR IN CONNECTION WITH
|
||||
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
//
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
using StgSharp.Graphics;
|
||||
using StgSharp.Graphics.OpenGL;
|
||||
using StgSharp.Math;
|
||||
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Runtime.Serialization;
|
||||
using System.Text;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace StgSharp.Graphics.ShaderEdit
|
||||
{
|
||||
public class ShaderGenerator
|
||||
{
|
||||
|
||||
private Dictionary<int, ShaderParameter> uniformDefine;
|
||||
private List<string> codeList;
|
||||
private List<ShaderFunction> usedShaderFunctions;
|
||||
|
||||
public Uniform<T> DefineUniform<T>( string name, int index ) where T: struct
|
||||
{
|
||||
ShaderParameter p = new ShaderParameter( name, ShaderParameter.TypeMarshal<T>() );
|
||||
uniformDefine.Add( index, p );
|
||||
|
||||
//return new Uniform<TView>();
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
public class ShaderFunction
|
||||
{
|
||||
|
||||
private List<string> codeList;
|
||||
private List<ShaderParameter> inputList;
|
||||
private ShaderParameter outPut;
|
||||
private string name;
|
||||
|
||||
public int ParameterCount => inputList.Count;
|
||||
|
||||
public void EmitCall(
|
||||
ShaderFunction function,
|
||||
ShaderParameter outPut,
|
||||
params ShaderParameter[] inputParams )
|
||||
{
|
||||
if( inputParams.Length != function.ParameterCount )
|
||||
{
|
||||
// Param list length not equal
|
||||
throw new ArgumentException(
|
||||
"Provided parameters does not match function's parameter list." );
|
||||
}
|
||||
if( !ShaderParameter.IsSameType( outPut, function.outPut ) )
|
||||
{
|
||||
// Type of returning value not equal
|
||||
throw new ArgumentException(
|
||||
"Provided parameters does not match function's parameter list." );
|
||||
}
|
||||
for( int i = 0; i < inputParams.Length; i++ )
|
||||
{
|
||||
if( !ShaderParameter.IsSameType( function.inputList[ i ], inputParams[ i ] ) )
|
||||
{
|
||||
// Input type not match
|
||||
throw new InvalidCastException(
|
||||
"Provided parameters does not match function's parameter list." );
|
||||
}
|
||||
}
|
||||
string codeLine = string.Empty; // adding a line like " outvalue = Func(input1, input2,...); "
|
||||
if( outPut != ShaderParameter.Void ) {
|
||||
codeLine += $"{outPut.name} = ";
|
||||
}
|
||||
codeLine += $"{function.name}(";
|
||||
foreach( ShaderParameter inputParam in inputParams ) {
|
||||
codeLine += inputParam.name;
|
||||
}
|
||||
codeLine += ");\n";
|
||||
codeList.Add( codeLine );
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
public class ShaderParameter
|
||||
{
|
||||
|
||||
public static readonly ShaderParameter Void = new ShaderParameter(
|
||||
string.Empty, InternalShaderType.Void );
|
||||
internal readonly bool isReadOnly;
|
||||
internal readonly InternalShaderType type;
|
||||
internal readonly string name;
|
||||
|
||||
public ShaderParameter( string name, InternalShaderType type )
|
||||
{
|
||||
this.name = name;
|
||||
this.type = type;
|
||||
isReadOnly = false;
|
||||
}
|
||||
|
||||
public static bool IsSameType( ShaderParameter param1, ShaderParameter param2 )
|
||||
{
|
||||
if( param1.type != InternalShaderType.Struct )
|
||||
{
|
||||
return param1.type == param2.type;
|
||||
} else
|
||||
{
|
||||
throw new Exception( "Struct is currently not supported." );
|
||||
}
|
||||
}
|
||||
|
||||
public static InternalShaderType TypeMarshal<T>() where T: struct
|
||||
{
|
||||
switch( Type.GetTypeCode( typeof( T ) ) )
|
||||
{
|
||||
case TypeCode.Single:
|
||||
return InternalShaderType.Float;
|
||||
case TypeCode.Double:
|
||||
return InternalShaderType.Double;
|
||||
case TypeCode.Int32:
|
||||
return InternalShaderType.Int;
|
||||
case TypeCode.UInt32:
|
||||
return InternalShaderType.UInt;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
switch( typeof( T ).Name )
|
||||
{
|
||||
case "vec4d":
|
||||
return InternalShaderType.Vector4;
|
||||
case "Matrix2x2":
|
||||
return InternalShaderType.Matrix2x2;
|
||||
case "Matrix2x3":
|
||||
return InternalShaderType.Matrix2x3;
|
||||
case "Matrix2x4":
|
||||
return InternalShaderType.Matrix2x4;
|
||||
case "Matrix3x2":
|
||||
return InternalShaderType.Matrix3x2;
|
||||
case "Matrix3x3":
|
||||
return InternalShaderType.Matrix3x3;
|
||||
case "Matrix3x4":
|
||||
return InternalShaderType.Matrix3x4;
|
||||
case "Matrix4x2":
|
||||
return InternalShaderType.Matrix4x2;
|
||||
case "Matrix4x3":
|
||||
return InternalShaderType.Matrix4x3;
|
||||
case "Matrix4x4":
|
||||
return InternalShaderType.Matrix4x4;
|
||||
default:
|
||||
throw new ArgumentException( "Not supported shader data type." );
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
public enum InternalShaderType
|
||||
{
|
||||
#pragma warning disable CS1591
|
||||
Struct,
|
||||
Void,
|
||||
Int,
|
||||
UInt,
|
||||
Float,
|
||||
Double,
|
||||
Vector2,
|
||||
Vector3,
|
||||
Vector4,
|
||||
VectorD2,
|
||||
VectorD3,
|
||||
VectorD4,
|
||||
Matrix2x2,
|
||||
Matrix2x3,
|
||||
Matrix2x4,
|
||||
Matrix3x2,
|
||||
Matrix3x3,
|
||||
Matrix3x4,
|
||||
Matrix4x2,
|
||||
Matrix4x3,
|
||||
Matrix4x4,
|
||||
#pragma warning restore CS1591
|
||||
}
|
||||
}
|
||||
@@ -1,98 +0,0 @@
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
// file="ShaderStruct.cs"
|
||||
// Project: StgSharp
|
||||
// AuthorGroup: Nitload Space
|
||||
// Copyright (c) Nitload Space. All rights reserved.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the “Software”), to deal in the Software without restriction,
|
||||
// including without limitation the rights to use, copy, modify, merge,
|
||||
// publish, distribute, sublicense, and/or sell copies of the Software,
|
||||
// and to permit persons to whom the Software is furnished to do so,
|
||||
// subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and
|
||||
// this permission notice shall be included in all copies
|
||||
// or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED “AS IS”,
|
||||
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
// ARISING FROM, OUT OF OR IN CONNECTION WITH
|
||||
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
//
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
using StgSharp.Graphics.OpenGL;
|
||||
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Text;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace StgSharp.Graphics.ShaderEdit
|
||||
{
|
||||
public class ShaderStructMember
|
||||
{
|
||||
|
||||
internal InternalShaderType type;
|
||||
internal object value;
|
||||
|
||||
}
|
||||
|
||||
public class ShaderStruct
|
||||
{
|
||||
|
||||
internal Dictionary<GlHandle, ShaderStructMember> uniformPair;
|
||||
|
||||
internal ShaderStruct() { }
|
||||
|
||||
public ShaderStruct( params (GlHandle, ShaderStructMember)[] uniformPairs )
|
||||
{
|
||||
uniformPair = new Dictionary<GlHandle, ShaderStructMember>();
|
||||
if( uniformPairs.Length == 0 ) {
|
||||
return;
|
||||
}
|
||||
|
||||
foreach( (GlHandle, ShaderStructMember) item in uniformPairs ) {
|
||||
uniformPair.Add( item.Item1, item.Item2 );
|
||||
}
|
||||
}
|
||||
|
||||
public unsafe void SetAllUniforms()
|
||||
{
|
||||
OpenglContext* gl = ( OpenglContext* )OpenGL.OpenGLFunction.CurrentGL.ContextHandle;
|
||||
foreach( KeyValuePair<GlHandle, ShaderStructMember> uniform in uniformPair )
|
||||
{
|
||||
int id = uniform.Key.SignedValue;
|
||||
ShaderStructMember s = uniform.Value;
|
||||
switch( s.type )
|
||||
{
|
||||
case InternalShaderType.Struct:
|
||||
throw new ArgumentException(
|
||||
"Incorrect type \"Struct\" defined in this self define type" );
|
||||
case InternalShaderType.Void:
|
||||
throw new ArgumentException(
|
||||
"Incorrect type \"Void\" defined in this self define type" );
|
||||
case InternalShaderType.Float:
|
||||
gl->glUniform1f( id, ( float )s.value );
|
||||
break;
|
||||
case InternalShaderType.Int:
|
||||
gl->glUniform1f( id, ( int )s.value );
|
||||
break;
|
||||
default:
|
||||
throw new NotImplementedException();
|
||||
throw new ArgumentException(
|
||||
"Incorrect type \"Unknown\" defined in this self define type" );
|
||||
}
|
||||
}
|
||||
}//------------------------------------ End of Class ---------------------------------------
|
||||
|
||||
}
|
||||
}
|
||||
@@ -1,67 +0,0 @@
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
// file="TexturePipeline.cs"
|
||||
// Project: StgSharp
|
||||
// AuthorGroup: Nitload Space
|
||||
// Copyright (c) Nitload Space. All rights reserved.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the “Software”), to deal in the Software without restriction,
|
||||
// including without limitation the rights to use, copy, modify, merge,
|
||||
// publish, distribute, sublicense, and/or sell copies of the Software,
|
||||
// and to permit persons to whom the Software is furnished to do so,
|
||||
// subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and
|
||||
// this permission notice shall be included in all copies
|
||||
// or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED “AS IS”,
|
||||
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
// ARISING FROM, OUT OF OR IN CONNECTION WITH
|
||||
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
//
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
using StgSharp.PipeLine;
|
||||
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Text;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace StgSharp.Graphics
|
||||
{
|
||||
public class TexturePipeline : IPipeLineConnectionPayload
|
||||
{
|
||||
|
||||
private Image _value;
|
||||
|
||||
public TexturePipeline( Image i )
|
||||
{
|
||||
_value = i;
|
||||
}
|
||||
|
||||
public object? ValueDefault => null;
|
||||
|
||||
public object Value
|
||||
{
|
||||
get => _value;
|
||||
set
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull( value );
|
||||
if( value is not Image image ) {
|
||||
throw new ArgumentException( "Value must be of type Image" );
|
||||
}
|
||||
_value = image;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
@@ -1,89 +0,0 @@
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
// file="TextureProvider.cs"
|
||||
// Project: StgSharp
|
||||
// AuthorGroup: Nitload Space
|
||||
// Copyright (c) Nitload Space. All rights reserved.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the “Software”), to deal in the Software without restriction,
|
||||
// including without limitation the rights to use, copy, modify, merge,
|
||||
// publish, distribute, sublicense, and/or sell copies of the Software,
|
||||
// and to permit persons to whom the Software is furnished to do so,
|
||||
// subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and
|
||||
// this permission notice shall be included in all copies
|
||||
// or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED “AS IS”,
|
||||
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
// ARISING FROM, OUT OF OR IN CONNECTION WITH
|
||||
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
//
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
using StgSharp.Math;
|
||||
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Diagnostics.CodeAnalysis;
|
||||
using System.Runtime.CompilerServices;
|
||||
using System.Text;
|
||||
|
||||
namespace StgSharp.Graphics
|
||||
{
|
||||
public class TextureProvider : IImageProvider
|
||||
{
|
||||
|
||||
private Vec2[] _texCoord;
|
||||
private Image _tex;
|
||||
|
||||
public TextureProvider( Image image, Vec2[] coord )
|
||||
{
|
||||
_tex = image;
|
||||
_texCoord = coord;
|
||||
}
|
||||
|
||||
public ref Vec2 this[ int index ]
|
||||
{
|
||||
get => ref _texCoord[ index ];
|
||||
}
|
||||
|
||||
public Span<Vec2> TextureCoordinate
|
||||
{
|
||||
get => new Span<Vec2>( _texCoord );
|
||||
}
|
||||
|
||||
public Image ProvideImage()
|
||||
{
|
||||
return _tex;
|
||||
}
|
||||
|
||||
public void ReadImage( IImageProvider provider )
|
||||
{
|
||||
_tex = provider.ProvideImage();
|
||||
}
|
||||
|
||||
public void UpdateFromImage( [NotNull]Image i )
|
||||
{
|
||||
if( i == _tex ) {
|
||||
return;
|
||||
}
|
||||
if( i.Size == _tex.Size )
|
||||
{
|
||||
_tex = i;
|
||||
} else
|
||||
{
|
||||
throw new ArgumentException(
|
||||
$"Size of {nameof(i)} does not equals to current image." );
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
@@ -1,51 +0,0 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Text;
|
||||
|
||||
namespace StgSharp.Graphics.Vulkan
|
||||
{
|
||||
|
||||
internal enum VkStructureType : uint
|
||||
{
|
||||
|
||||
VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000,
|
||||
VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000,
|
||||
VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000,
|
||||
VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000,
|
||||
VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK = 1000123000,
|
||||
VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT = 1000217000,
|
||||
VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF
|
||||
|
||||
}
|
||||
|
||||
internal enum VkResult
|
||||
{
|
||||
|
||||
VK_SUCCESS = 0,
|
||||
VK_NOT_READY = 1,
|
||||
VK_TIMEOUT = 2,
|
||||
VK_EVENT_SET = 3,
|
||||
VK_EVENT_RESET = 4,
|
||||
VK_INCOMPLETE = 5,
|
||||
VK_ERROR_OUT_OF_HOST_MEMORY = -1,
|
||||
VK_ERROR_OUT_OF_DEVICE_MEMORY = -2,
|
||||
VK_ERROR_INITIALIZATION_FAILED = -3,
|
||||
VK_ERROR_DEVICE_LOST = -4,
|
||||
VK_ERROR_MEMORY_MAP_FAILED = -5,
|
||||
VK_ERROR_LAYER_NOT_PRESENT = -6,
|
||||
VK_ERROR_EXTENSION_NOT_PRESENT = -7,
|
||||
VK_ERROR_FEATURE_NOT_PRESENT = -8,
|
||||
VK_ERROR_INCOMPATIBLE_DRIVER = -9,
|
||||
VK_ERROR_TOO_MANY_OBJECTS = -10,
|
||||
VK_ERROR_FORMAT_NOT_SUPPORTED = -11,
|
||||
VK_ERROR_SURFACE_LOST_KHR = -1000000000,
|
||||
VK_SUBOPTIMAL_KHR = 1000001003,
|
||||
VK_ERROR_OUT_OF_DATE_KHR = -1000001004,
|
||||
VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001,
|
||||
VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001,
|
||||
VK_ERROR_VALIDATION_FAILED_EXT = -1000011001,
|
||||
VK_RESULT_MAX_ENUM = 0x7FFFFFFF
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,51 +0,0 @@
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
// file="vkHandle.cs"
|
||||
// Project: StgSharp
|
||||
// AuthorGroup: Nitload Space
|
||||
// Copyright (c) Nitload Space. All rights reserved.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the “Software”), to deal in the Software without restriction,
|
||||
// including without limitation the rights to use, copy, modify, merge,
|
||||
// publish, distribute, sublicense, and/or sell copies of the Software,
|
||||
// and to permit persons to whom the Software is furnished to do so,
|
||||
// subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and
|
||||
// this permission notice shall be included in all copies
|
||||
// or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED “AS IS”,
|
||||
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
// ARISING FROM, OUT OF OR IN CONNECTION WITH
|
||||
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
//
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Runtime.InteropServices;
|
||||
using System.Security;
|
||||
using System.Text;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace StgSharp.Graphics.Vulkan
|
||||
{
|
||||
[StructLayout( LayoutKind.Explicit, Size = 8 )]
|
||||
public struct vkHandle
|
||||
{
|
||||
|
||||
[FieldOffset( 0 )] public int SignedHalfValue;
|
||||
[FieldOffset( 0 )] public IntPtr Handle;
|
||||
[FieldOffset( 0 )] public IntPtr UnsignedHandle;
|
||||
[FieldOffset( 0 )] public uint HalfValue;
|
||||
|
||||
}
|
||||
}
|
||||
@@ -1,103 +0,0 @@
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
// file="framework.cs"
|
||||
// Project: StgSharp
|
||||
// AuthorGroup: Nitload Space
|
||||
// Copyright (c) Nitload Space. All rights reserved.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the “Software”), to deal in the Software without restriction,
|
||||
// including without limitation the rights to use, copy, modify, merge,
|
||||
// publish, distribute, sublicense, and/or sell copies of the Software,
|
||||
// and to permit persons to whom the Software is furnished to do so,
|
||||
// subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and
|
||||
// this permission notice shall be included in all copies
|
||||
// or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED “AS IS”,
|
||||
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
// ARISING FROM, OUT OF OR IN CONNECTION WITH
|
||||
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
//
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
using StgSharp.Graphics;
|
||||
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Diagnostics;
|
||||
using System.Reflection;
|
||||
using System.Runtime.CompilerServices;
|
||||
using System.Runtime.InteropServices;
|
||||
using System.Text;
|
||||
|
||||
#if Windows
|
||||
// using Windows.Win32;
|
||||
#endif
|
||||
|
||||
namespace StgSharp.Graphics
|
||||
{
|
||||
/// <summary>
|
||||
/// Function handler to load an opengl function by searching its _label.
|
||||
/// </summary>
|
||||
/// <param _label="name">
|
||||
/// the _label of the Opengl function
|
||||
/// </param>
|
||||
/// <returns>
|
||||
/// An Intptr value representing the pointer to the function
|
||||
/// </returns>
|
||||
public delegate IntPtr glLoader( string name );
|
||||
|
||||
#region StgSharpDele
|
||||
|
||||
public unsafe delegate void FrameBufferSizeHandler( IntPtr window, int width, int height );
|
||||
|
||||
public unsafe delegate void FramePositionHandler( IntPtr window, float width, float height );
|
||||
|
||||
#endregion
|
||||
|
||||
|
||||
#region glDEBUG
|
||||
|
||||
internal unsafe delegate void GLDEBUGPROC(
|
||||
int source,
|
||||
int type,
|
||||
uint id,
|
||||
int severity,
|
||||
int length,
|
||||
sbyte* message,
|
||||
void* userParam );
|
||||
internal unsafe delegate void GLDEBUGPROCARB(
|
||||
int source,
|
||||
int type,
|
||||
uint id,
|
||||
int severity,
|
||||
int length,
|
||||
sbyte* message,
|
||||
void* userParam );
|
||||
internal unsafe delegate void GLDEBUGPROCKHR(
|
||||
int source,
|
||||
int type,
|
||||
uint id,
|
||||
int severity,
|
||||
int length,
|
||||
sbyte* message,
|
||||
void* userParam );
|
||||
internal unsafe delegate void GLDEBUGPROCAMD(
|
||||
uint id,
|
||||
int category,
|
||||
int severity,
|
||||
int length,
|
||||
sbyte* message,
|
||||
void* userParam );
|
||||
|
||||
#endregion
|
||||
|
||||
}
|
||||
@@ -1,79 +0,0 @@
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
// file="frameworkSyncContext.cs"
|
||||
// Project: StgSharp
|
||||
// AuthorGroup: Nitload Space
|
||||
// Copyright (c) Nitload Space. All rights reserved.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the “Software”), to deal in the Software without restriction,
|
||||
// including without limitation the rights to use, copy, modify, merge,
|
||||
// publish, distribute, sublicense, and/or sell copies of the Software,
|
||||
// and to permit persons to whom the Software is furnished to do so,
|
||||
// subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and
|
||||
// this permission notice shall be included in all copies
|
||||
// or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED “AS IS”,
|
||||
// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
// ARISING FROM, OUT OF OR IN CONNECTION WITH
|
||||
// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
//
|
||||
//-----------------------------------------------------------------------
|
||||
//-----------------------------------------------------------------------
|
||||
using System;
|
||||
using System.Collections.Concurrent;
|
||||
using System.Collections.Generic;
|
||||
using System.Diagnostics;
|
||||
using System.Linq;
|
||||
using System.Text;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace StgSharp.Threading
|
||||
{
|
||||
public class FrameworkSyncContext : SynchronizationContext
|
||||
{
|
||||
|
||||
private static readonly FrameworkSyncContext _mainThreadContext = new FrameworkSyncContext();
|
||||
|
||||
private readonly BlockingCollection<SendOrPostCallback> _syncContexts = new BlockingCollection<SendOrPostCallback>(
|
||||
);
|
||||
private readonly Thread _mainThread = Thread.CurrentThread;
|
||||
|
||||
public FrameworkSyncContext()
|
||||
{
|
||||
_syncContexts = new BlockingCollection<SendOrPostCallback>();
|
||||
_mainThread = Thread.CurrentThread;
|
||||
}
|
||||
|
||||
public static FrameworkSyncContext MainThreadContext
|
||||
{
|
||||
get => _mainThreadContext;
|
||||
}
|
||||
|
||||
public override void Post( SendOrPostCallback d, object state )
|
||||
{
|
||||
_syncContexts.Add( d );
|
||||
}
|
||||
|
||||
public override void Send( SendOrPostCallback d, object state )
|
||||
{
|
||||
if( Thread.CurrentThread == _mainThread )
|
||||
{
|
||||
d( state );
|
||||
} else
|
||||
{
|
||||
Post( d, state );
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user