/// <summary>
/// Function to load the logo for display in the application.
/// </summary>
/// <param name="graphics">The graphics interface to use.</param>
public static void LoadResources(GorgonGraphics graphics)
{
if (graphics == null)
{
throw new ArgumentNullException(nameof(graphics));
}
_factory = new GorgonFontFactory(graphics);
_statsFont = _factory.GetFont(new GorgonFontInfo("Segoe UI", 9, FontHeightMode.Points, "Segoe UI 9pt Bold Outlined")
{
AntiAliasingMode = FontAntiAliasMode.AntiAlias,
FontStyle = FontStyle.Bold,
OutlineColor1 = GorgonColor.Black,
OutlineColor2 = GorgonColor.Black,
OutlineSize = 2,
TextureWidth = 512,
TextureHeight = 256
});
using (var stream = new MemoryStream(Resources.Gorgon_Logo_Small))
{
var ddsCodec = new GorgonCodecDds();
_logo = GorgonTexture2DView.FromStream(graphics, stream, ddsCodec, options: new GorgonTexture2DLoadOptions
{
Name = "Gorgon Logo Texture",
Binding = TextureBinding.ShaderResource,
Usage = ResourceUsage.Immutable
});
}
}
/// <summary>
/// Initializes a new instance of the <see cref="WorldViewProjection"/> class.
/// </summary>
/// <param name="graphics">The graphics interface to use.</param>
public Light(GorgonGraphics graphics)
{
_lightData[0].Attenuation = 6.0f;
_lightData[0].LightColor = GorgonColor.White;
_lightData[0].LightPosition = Vector3.Zero;
_lightData[0].SpecularColor = GorgonColor.White;
_lightData[0].SpecularPower = 512.0f;
_buffer = graphics.Buffers.CreateConstantBuffer("LightBuffer",
new GorgonConstantBufferSettings
{
SizeInBytes = LightData.Size * _lightData.Length,
Usage = BufferUsage.Default
});
_lightStore = new GorgonDataStream(_buffer.SizeInBytes);
unsafe
{
DirectAccess.ZeroMemory(_lightStore.UnsafePointer, _buffer.SizeInBytes);
var data = (LightData *)_lightStore.UnsafePointer;
* data = _lightData[0];
}
_buffer.Update(_lightStore);
graphics.Shaders.PixelShader.ConstantBuffers[1] = _buffer;
}
/// <summary>
/// Initializes a new instance of the <see cref="GorgonBuffer" /> class.
/// </summary>
/// <param name="graphics">The <see cref="GorgonGraphics"/> object used to create and manipulate the buffer.</param>
/// <param name="info">Information used to create the buffer.</param>
/// <param name="initialData">[Optional] The initial data used to populate the buffer.</param>
/// <exception cref="ArgumentNullException">Thrown when the <paramref name="info"/> parameter is <b>null</b>.</exception>
/// <exception cref="ArgumentException">Thrown if the size of the buffer is less than 1 byte.</exception>
/// <exception cref="GorgonException">Thrown if the buffer is created with a usage of <see cref="ResourceUsage.Immutable"/>, but the <paramref name="initialData"/> parameter is <b>null</b>.
/// <para>-or-</para>
/// <para>A value on the <paramref name="info"/> parameter is incorrect.</para>
/// </exception>
public GorgonBuffer(GorgonGraphics graphics, IGorgonBufferInfo info, GorgonNativeBuffer <byte> initialData = null)
: base(graphics)
{
_info = new GorgonBufferInfo(info ?? throw new ArgumentNullException(nameof(info)));
Initialize(initialData);
}
/// <summary>
/// Function to create a <see cref="GorgonTexture2D"/> from a GDI+ bitmap.
/// </summary>
/// <param name="gdiBitmap">The GDI+ bitmap used to create the texture.</param>
/// <param name="graphics">The graphics interface used to create the texture.</param>
/// <param name="options">[Optional] Options used to further define the texture.</param>
/// <returns>A new <see cref="GorgonTexture2D"/> containing the data from the <paramref name="gdiBitmap"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when the <paramref name="gdiBitmap"/>, or the <paramref name="graphics"/> parameter is <b>null</b>.</exception>
/// <remarks>
/// <para>
/// A GDI+ bitmap is useful to holding image data in memory, but it cannot be sent to the GPU for use as a texture. This method allows an application to convert the GDI+ bitmap into a
/// <see cref="GorgonTexture2D"/>.
/// </para>
/// <para>
/// The resulting <see cref="GorgonTexture2D"/> will only contain a single mip level, and single array level. The only image type available will be 2D (i.e. image with a width and height). The GDI+
/// bitmap should have a 32bpp rgba format, or a 24bpp rgb format or else an exception will be thrown.
/// </para>
/// <para>
/// The optional <paramref name="options"/>parameter will define how Gorgon and shaders should handle the texture. The <see cref="GorgonTextureLoadOptions"/> type contains the following:
/// <list type="bullet">
/// <item>
/// <term>Binding</term>
/// <description>When defined, will indicate the <see cref="TextureBinding"/> that defines how the texture will be bound to the graphics pipeline. If it is omitted, then the binding will be
/// <see cref="TextureBinding.ShaderResource"/>.</description>
/// </item>
/// <item>
/// <term>Usage</term>
/// <description>When defined, will indicate the preferred usage for the texture. If it is omitted, then the usage will be set to <see cref="ResourceUsage.Default"/>.</description>
/// </item>
/// <item>
/// <term>Multisample info</term>
/// <description>When defined (i.e. not <b>null</b>), defines the multisampling to apply to the texture. If omitted, then the default is <see cref="GorgonMultisampleInfo.NoMultiSampling"/>.</description>
/// </item>
/// <item>
/// <term>ConvertToPremultipliedAlpha</term>
/// <description>Converts the image to premultiplied alpha before uploading the image data to the texture.</description>
/// </item>
/// </list>
/// </para>
/// </remarks>
public static GorgonTexture2D ToTexture2D(this Bitmap gdiBitmap,
GorgonGraphics graphics,
GorgonTexture2DLoadOptions options = null)
{
if (gdiBitmap == null)
{
throw new ArgumentNullException(nameof(gdiBitmap));
}
if (graphics == null)
{
throw new ArgumentNullException(nameof(graphics));
}
if (options == null)
{
options = _defaultLoadOptions;
}
if (string.IsNullOrEmpty(options.Name))
{
options.Name = GorgonGraphicsResource.GenerateName(GorgonTexture2D.NamePrefix);
}
using (IGorgonImage image = gdiBitmap.ToGorgonImage())
{
if (options.ConvertToPremultipliedAlpha)
{
image.ConvertToPremultipliedAlpha();
}
return(new GorgonTexture2D(graphics, image, options));
}
}
/// <summary>
/// Raises the <see cref="E:System.Windows.Forms.Form.Load" /> event.
/// </summary>
/// <param name="e">An <see cref="T:System.EventArgs" /> that contains the event data.</param>
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
Cursor.Current = Cursors.WaitCursor;
try
{
// Set up the graphics interface.
_graphics = new GorgonGraphics();
// Create our 2D renderer to display the image.
_2D = _graphics.Output.Create2DRenderer(this, 1280, 800);
// Center the window on the screen.
Screen currentMonitor = Screen.FromControl(this);
Location = new Point(currentMonitor.WorkingArea.Left + (currentMonitor.WorkingArea.Width / 2 - Width / 2),
currentMonitor.WorkingArea.Top + (currentMonitor.WorkingArea.Height / 2 - Height / 2));
// Load our base texture.
_image = _graphics.Textures.FromMemory <GorgonTexture2D>("SourceTexture",
Resources.SourceTexture,
new GorgonCodecDDS());
// Load the custom codec.
if (!LoadCodec())
{
GorgonDialogs.ErrorBox(this, "Unable to load the useless image codec plug-in.");
Gorgon.Quit();
return;
}
// Convert the image to our custom codec.
ConvertImage();
// Set up our idle time processing.
Gorgon.ApplicationIdleLoopMethod = () =>
{
_2D.Clear(Color.White);
// Draw to the window.
Draw();
// Render with a vsync interval of 2 (typically 30 FPS).
// We're not making an action game here.
_2D.Render(2);
return(true);
};
}
catch (Exception ex)
{
GorgonDialogs.ErrorBox(this, ex);
Gorgon.Quit();
}
finally
{
Cursor.Current = Cursors.Default;
}
}
/// <summary>
/// Function to initialize the application.
/// </summary>
private static void Initialize()
{
// Create our form and center on the primary monitor.
_mainForm = new formMain
{
ClientSize = new Size(640, 480),
};
_mainForm.Location = new Point(Screen.PrimaryScreen.WorkingArea.Width / 2 - _mainForm.Width / 2,
Screen.PrimaryScreen.WorkingArea.Height / 2 - _mainForm.Height / 2);
// Create the main graphics interface for SM 4.0.
// This is basically a Direct 3D 10 capable video device. This is here to illustrate how to
// force a feature level.
Graphics = new GorgonGraphics(DeviceFeatureLevel.SM4);
// Check to ensure that we can support the format required for our swap chain.
// If a video device can't support this format, then the odds are good it won't render anything, and thus
// this is here for illustration on how to determine if a format is OK for display purposes.
if (!Graphics.VideoDevice.SupportsDisplayFormat(BufferFormat.R8G8B8A8_UIntNormal))
{
GorgonDialogs.ErrorBox(_mainForm, "We should not see this error.");
return;
}
// Create a swap chain as our graphics output to the window.
_swap = Graphics.Output.CreateSwapChain("Main", new GorgonSwapChainSettings
{
Window = _mainForm, // Assign to our form.
});
}
/// <summary>
/// Function to retrieve the list of disposables for a given graphics instance.
/// </summary>
/// <param name="graphics">The graphics instance that owns the disposable resources.</param>
/// <returns>An enumerable containing the list of resources for the graphics instance.</returns>
public static IEnumerable <WeakReference <IDisposable> > GetDisposables(this GorgonGraphics graphics)
{
lock (_syncLock)
{
return(_disposables[graphics]);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Cube"/> class.
/// </summary>
/// <param name="graphics">The graphics object used to create the buffers needed by this object.</param>
/// <param name="inputLayout">The input layout describing how a vertex is laid out.</param>
public Cube(GorgonGraphics graphics, GorgonInputLayout inputLayout)
{
CubeVertex[] vertices =
{
new CubeVertex(new DX.Vector3(-0.5f, 0.5f, -0.5f), new DX.Vector3(0, 0, 0)),
new CubeVertex(new DX.Vector3(0.5f, 0.5f, -0.5f), new DX.Vector3(1.0f, 1.0f, 0)),
new CubeVertex(new DX.Vector3(0.5f, -0.5f, -0.5f), new DX.Vector3(0.0f, 1.0f, 0)),
new CubeVertex(new DX.Vector3(-0.5f, -0.5f, -0.5f), new DX.Vector3(1.0f, 0.0f, 0)),
new CubeVertex(new DX.Vector3(-0.5f, 0.5f, 0.5f), new DX.Vector3(0, 0, 0)),
new CubeVertex(new DX.Vector3(0.5f, 0.5f, 0.5f), new DX.Vector3(1.0f, 1.0f, 0)),
new CubeVertex(new DX.Vector3(0.5f, -0.5f, 0.5f), new DX.Vector3(0.0f, 1.0f, 0)),
new CubeVertex(new DX.Vector3(-0.5f, -0.5f, 0.5f), new DX.Vector3(1.0f, 0.0f, 0)),
};
ushort[] indices =
{
// Front face.
0, 1, 2,
2, 3, 0,
// Back face.
5, 4, 6,
4, 7, 6,
// Left face.
4, 0, 3,
3, 7, 4,
// Right face.
1, 5, 6,
6, 2, 1,
// Top face
4, 5, 1,
1, 0, 4,
// Bottom face
2, 6, 7,
7, 3, 2
};
// Create our index buffer and vertex buffer and populate with our cube data.
using (var indexPtr = GorgonNativeBuffer <ushort> .Pin(indices))
using (var vertexPtr = GorgonNativeBuffer <CubeVertex> .Pin(vertices))
{
IndexBuffer = new GorgonIndexBuffer(graphics,
new GorgonIndexBufferInfo("Volume Index Buffer")
{
Usage = ResourceUsage.Immutable,
IndexCount = indices.Length,
Use16BitIndices = true
},
indexPtr);
VertexBuffer = new GorgonVertexBufferBindings(inputLayout)
{
[0] = GorgonVertexBufferBinding.CreateVertexBuffer(graphics,
vertices.Length,
ResourceUsage.Immutable,
initialData: vertexPtr,
bufferName: "Volume Vertex Buffer")
};
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Triangle"/> class.
/// </summary>
/// <param name="graphics">The graphics interface.</param>
/// <param name="point1">The 1st point in the triangle.</param>
/// <param name="point2">The 2nd point in the triangle.</param>
/// <param name="point3">The 3rd point in the triangle.</param>
public Triangle(GorgonGraphics graphics, Vertex3D point1, Vertex3D point2, Vertex3D point3)
{
PrimitiveType = PrimitiveType.TriangleList;
VertexCount = 3;
IndexCount = 3;
TriangleCount = 1;
point1.Tangent = new Vector4(1.0f, 0, 0, 1.0f);
point2.Tangent = new Vector4(1.0f, 0, 0, 1.0f);
point3.Tangent = new Vector4(1.0f, 0, 0, 1.0f);
VertexBuffer = graphics.Buffers.CreateVertexBuffer("TriVB",
new[]
{
point1,
point2,
point3
}, BufferUsage.Immutable);
IndexBuffer = graphics.Buffers.CreateIndexBuffer("TriIB",
new[]
{
0,
1,
2
}, BufferUsage.Immutable);
}
/// <summary>
/// Function to dispose all IDisposable objects registered to the graphics interface.
/// </summary>
/// <param name="graphics">The graphics interface that holds all the IDisposable objects.</param>
public static void DisposeAll(this GorgonGraphics graphics)
{
lock (_syncLock)
{
if ((!_disposables.TryGetValue(graphics, out List <WeakReference <IDisposable> > disposables)) ||
(disposables == null))
{
return;
}
if (disposables.Count == 0)
{
_disposables.Remove(graphics);
return;
}
while (disposables.Count > 0)
{
if (!disposables[0].TryGetTarget(out IDisposable disposeRef))
{
disposables.RemoveAt(0);
continue;
}
disposeRef.Dispose();
}
disposables.Clear();
_disposables.Remove(graphics);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="WorldViewProjection"/> class.
/// </summary>
/// <param name="graphics">The graphics interface to use.</param>
public WorldViewProjection(GorgonGraphics graphics)
{
Matrix dummy = Matrix.Identity;
_projViewBuffer = graphics.Buffers.CreateConstantBuffer("WVPBuffer",
new GorgonConstantBufferSettings
{
SizeInBytes = DirectAccess.SizeOf <ViewProjectionData>(),
Usage = BufferUsage.Default
});
_viewProj = new ViewProjectionData
{
Projection = Matrix.Identity,
View = Matrix.Identity,
ViewProjection = Matrix.Identity
};
_projViewBuffer.Update(ref _viewProj);
_worldBuffer = graphics.Buffers.CreateConstantBuffer("WorldBuffer", ref dummy, BufferUsage.Default);
_camData.CameraLookAt = new Vector3(0, 0, -1.0f);
_camData.CameraUp = new Vector3(0, 1, 0);
_cameraBuffer = graphics.Buffers.CreateConstantBuffer("CameraBuffer", ref _camData, BufferUsage.Default);
graphics.Shaders.VertexShader.ConstantBuffers[0] = _projViewBuffer;
graphics.Shaders.VertexShader.ConstantBuffers[1] = _worldBuffer;
graphics.Shaders.PixelShader.ConstantBuffers[0] = _cameraBuffer;
}
/// <summary>
/// Function to create a <see cref="GorgonTexture1D"/> from a <see cref="GorgonImage"/>.
/// </summary>
/// <param name="image">The image used to create the texture.</param>
/// <param name="graphics">The graphics interface used to create the texture.</param>
/// <param name="options">[Optional] Options used to further define the texture.</param>
/// <returns>A new <see cref="GorgonTexture1D"/> containing the data from the <paramref name="image"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when the <paramref name="image"/>, or the <paramref name="graphics"/> parameter is <b>null</b>.</exception>
/// <remarks>
/// <para>
/// A <see cref="GorgonImage"/> is useful to holding image data in memory, but it cannot be sent to the GPU for use as a texture. This method allows an application to convert the
/// <see cref="GorgonImage"/> into a <see cref="GorgonTexture1D"/>.
/// </para>
/// <para>
/// If specified, the <paramref name="options"/>parameter will define how Gorgon and shaders should handle the texture. The <see cref="GorgonTextureLoadOptions"/> type contains the following:
/// <list type="bullet">
/// <item>
/// <term>Binding</term>
/// <description>When defined, will indicate the <see cref="TextureBinding"/> that defines how the texture will be bound to the graphics pipeline. If it is omitted, then the binding will be
/// <see cref="TextureBinding.ShaderResource"/>.</description>
/// </item>
/// <item>
/// <term>Usage</term>
/// <description>When defined, will indicate the preferred usage for the texture. If it is omitted, then the usage will be set to <see cref="ResourceUsage.Default"/>.</description>
/// </item>
/// <item>
/// <term>Multisample info</term>
/// <description>This is not available on 1D textures, and is ignored.</description>
/// </item>
/// </list>
/// </para>
/// </remarks>
public static GorgonTexture1D ToTexture1D(this IGorgonImage image,
GorgonGraphics graphics,
GorgonTextureLoadOptions options = null)
{
if (image == null)
{
throw new ArgumentNullException(nameof(image));
}
if (graphics == null)
{
throw new ArgumentNullException(nameof(graphics));
}
if (options == null)
{
options = _defaultLoadOptions;
}
if (string.IsNullOrEmpty(options.Name))
{
options.Name = GorgonGraphicsResource.GenerateName(GorgonTexture1D.NamePrefix);
}
return(new GorgonTexture1D(graphics, image, options));
}
/// <summary>
/// Function to initialize the example and prepare the required components.
/// </summary>
private static void Initialize()
{
// We will need to access the graphics device in order to use compute functionality, so we'll use the first usable device in the system.
// Find out which devices we have installed in the system.
IReadOnlyList <IGorgonVideoAdapterInfo> deviceList = GorgonGraphics.EnumerateAdapters();
Console.WriteLine("Enumerating video devices...");
IGorgonVideoAdapterInfo firstDevice = deviceList.FirstOrDefault(item => item.FeatureSet >= FeatureSet.Level_12_0);
// If a device with a feature set of at least 12.0 not found, then we cannot run this example. The compute engine requires a minimum
// of feature level 12.0 to run.
if (firstDevice == null)
{
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine("No Level 12.0 or better adapters found in the system. This example requires a FeatureLevel 12.0 or better adapter.");
Console.ResetColor();
return;
}
Console.WriteLine($"Using the '{firstDevice.Name}' video device.\n");
// We have to create a graphics interface to allow the compute engine to communicate with the GPU.
_graphics = new GorgonGraphics(firstDevice);
// We will also need to compile a compute shader so we can actually perform the work.
Console.WriteLine("Compiling the compute shader (SimpleCompute)...");
_computeShader = GorgonShaderFactory.Compile <GorgonComputeShader>(_graphics, Resources.ComputeShader, "SimpleCompute");
// Finally, the star of the show, the compute engine.
Console.WriteLine("Creating compute engine...");
_engine = new GorgonComputeEngine(_graphics);
}
/// <summary>
/// Function to set up the renderer.
/// </summary>
/// <param name="renderer">Renderer to use.</param>
public void SetupRenderer(Gorgon2D renderer)
{
if (DesignMode)
{
return;
}
try
{
Gorgon.ApplicationIdleLoopMethod = null;
if (_renderer != renderer)
{
CleanUpRenderer();
}
if (renderer == null)
{
return;
}
_renderer = renderer;
_graphics = renderer.Graphics;
if (_swapChain == null)
{
_swapChain = _graphics.Output.CreateSwapChain("ImageDisplay",
new GorgonSwapChainSettings
{
Window = panelTextureDisplay,
Format = BufferFormat.R8G8B8A8_UIntNormal
});
}
if (_lastState == null)
{
_lastState = renderer.Begin2D();
}
if (_defaultTexture == null)
{
_defaultTexture = _graphics.Textures.CreateTexture <GorgonTexture2D>("DefaultPattern", Resources.Pattern);
}
if (_clipper == null)
{
InitializeClipper(null, RectangleF.Empty);
}
_region = new RectangleF(0, 0, 1, 1);
_renderer.Target = _swapChain;
Gorgon.ApplicationIdleLoopMethod = Idle;
}
finally
{
ValidateCommands();
}
}
/// <summary>
/// Function to unregister a disposable object from a graphics interface.
/// </summary>
/// <param name="disposable">The disposable object to unregister.</param>
/// <param name="graphics">The graphics object that the IDisposable belonged to.</param>
public static void UnregisterDisposable(this IDisposable disposable, GorgonGraphics graphics)
{
if ((disposable == null) ||
(graphics == null))
{
return;
}
lock (_syncLock)
{
if (!_disposables.TryGetValue(graphics, out List <WeakReference <IDisposable> > disposables))
{
return;
}
if ((disposables == null) ||
(disposables.Count == 0))
{
_disposables.Remove(graphics);
return;
}
disposables.RemoveAll(weakRef =>
{
// Remove any dead references.
return(!weakRef.TryGetTarget(out IDisposable disposeRef) ? true : disposeRef == disposable);
});
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Gorgon2DStateRecall"/> class.
/// </summary>
/// <param name="renderer">The renderer that is creating this object.</param>
internal Gorgon2DStateRecall(Gorgon2D renderer)
{
Gorgon2D = renderer;
_graphics = renderer.Graphics;
Save();
}
/// <summary>
/// Initializes a new instance of the <see cref="BatchRenderer"/> class.
/// </summary>
/// <param name="graphics">The graphics interface that uses this renderer.</param>
public BatchRenderer(GorgonGraphics graphics)
{
Graphics = graphics;
SpriteTransformer = new SpriteTransformer();
TextSpriteTransformer = new TextSpriteTransformer();
CreateBuffers();
}
/// <summary>
/// Function to load a texture from a file.
/// </summary>
/// <param name="graphics">The graphics interface that will own the texture.</param>
/// <param name="filePath">The path to the file.</param>
/// <param name="codec">The codec that is used to decode the the data in the stream.</param>
/// <param name="options">[Optional] Options used to further define the texture.</param>
/// <returns>A new <see cref="GorgonTexture3DView"/></returns>
/// <exception cref="ArgumentNullException">Thrown when the <paramref name="graphics"/>, <paramref name="filePath"/>, or the <paramref name="codec"/> parameter is <b>null</b>.</exception>
/// <exception cref="ArgumentEmptyException">Thrown when the <paramref name="filePath"/> parameter is empty.</exception>
/// <remarks>
/// <para>
/// This will load an <see cref="IGorgonImage"/> from a file on disk and put it into a <see cref="GorgonTexture3D"/> object and return a <see cref="GorgonTexture3DView"/>.
/// </para>
/// <para>
/// If specified, the <paramref name="options"/>parameter will define how Gorgon and shaders should handle the texture. The <see cref="GorgonTextureLoadOptions"/> type contains the following:
/// <list type="bullet">
/// <item>
/// <term>Binding</term>
/// <description>When defined, will indicate the <see cref="TextureBinding"/> that defines how the texture will be bound to the graphics pipeline. If it is omitted, then the binding will be
/// <see cref="TextureBinding.ShaderResource"/>.</description>
/// </item>
/// <item>
/// <term>Usage</term>
/// <description>When defined, will indicate the preferred usage for the texture. If it is omitted, then the usage will be set to <see cref="ResourceUsage.Default"/>.</description>
/// </item>
/// <item>
/// <term>Multisample info</term>
/// <description>When defined (i.e. not <b>null</b>), defines the multisampling to apply to the texture. If omitted, then the default is <see cref="GorgonMultisampleInfo.NoMultiSampling"/>.</description>
/// </item>
/// </list>
/// </para>
/// <para>
/// Since the <see cref="GorgonTexture3D"/> created by this method is linked to the <see cref="GorgonTexture3DView"/> returned, disposal of either one will dispose of the other on your behalf. If
/// the user created a <see cref="GorgonTexture3DView"/> from the <see cref="GorgonTexture3D.GetShaderResourceView"/> method on the <see cref="GorgonTexture3D"/>, then it's assumed the user knows
/// what they are doing and will handle the disposal of the texture and view on their own.
/// </para>
/// </remarks>
public static GorgonTexture3DView FromFile(GorgonGraphics graphics, string filePath, IGorgonImageCodec codec, GorgonTextureLoadOptions options = null)
{
if (graphics == null)
{
throw new ArgumentNullException(nameof(graphics));
}
if (filePath == null)
{
throw new ArgumentNullException(nameof(filePath));
}
if (string.IsNullOrWhiteSpace(filePath))
{
throw new ArgumentEmptyException(nameof(filePath));
}
if (codec == null)
{
throw new ArgumentNullException(nameof(codec));
}
using (IGorgonImage image = codec.LoadFromFile(filePath))
{
GorgonTexture3D texture = image.ToTexture3D(graphics, options);
GorgonTexture3DView view = texture.GetShaderResourceView();
view.OwnsResource = true;
return(view);
}
}
/// <summary>
/// Function to clean up the renderer objects.
/// </summary>
private void CleanUpRenderer()
{
if (_renderer == null)
{
return;
}
if (_lastState != null)
{
_renderer.End2D(_lastState);
_lastState = null;
}
if (_texture != null)
{
_texture.Dispose();
_texture = null;
}
if (_defaultTexture != null)
{
_defaultTexture.Dispose();
_defaultTexture = null;
}
if (_swapChain != null)
{
_swapChain.Dispose();
_swapChain = null;
}
_clipper = null;
_graphics = null;
}
/// <summary>
/// Function to create a vertex buffer and its binding.
/// </summary>
/// <typeparam name="T">The type of data representing a vertex, must be an unmanaged value type.</typeparam>
/// <param name="graphics">The graphics interface that will create the buffer.</param>
/// <param name="vertexCount">The total number vertices that the buffer can hold.</param>
/// <param name="usage">[Optional] The intended usage for the buffer.</param>
/// <param name="binding">[Optional] The binding options for the buffer.</param>
/// <param name="initialData">[Optional] An initial set of vertex data to send to the buffer.</param>
/// <param name="bindingIndex">[Optional] The index, in vertices, inside the buffer where binding is to begin.</param>
/// <param name="bufferName">[Optional] A name for the buffer.</param>
/// <returns>A new <see cref="GorgonVertexBufferBinding"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when the <paramref name="graphics"/> parameter is <b>null</b>.</exception>
/// <remarks>
/// <para>
/// Use this to quickly create a vertex buffer and its binding based on a known vertex data type.
/// </para>
/// <para>
/// Be aware that the <see cref="VertexBuffer"/> created by this method must be disposed manually after it is no longer of any use.
/// </para>
/// </remarks>
/// <seealso cref="GorgonVertexBuffer"/>
public static GorgonVertexBufferBinding CreateVertexBuffer <T>(GorgonGraphics graphics,
int vertexCount,
ResourceUsage usage = ResourceUsage.Default,
VertexIndexBufferBinding binding = VertexIndexBufferBinding.None,
GorgonNativeBuffer <T> initialData = null,
int bindingIndex = 0,
string bufferName = null)
where T : unmanaged
{
if (graphics == null)
{
throw new ArgumentNullException(nameof(graphics));
}
int vertexSize = Unsafe.SizeOf <T>();
var buffer = new GorgonVertexBuffer(graphics,
new GorgonVertexBufferInfo(bufferName)
{
SizeInBytes = vertexCount * vertexSize,
Binding = binding,
Usage = usage
},
initialData?.Cast <byte>());
return(new GorgonVertexBufferBinding(buffer, vertexSize, bindingIndex * vertexSize));
}
/// <summary>Initializes a new instance of the <see cref="T:Gorgon.Editor.SpriteEditor.SpriteVertexOffsetRenderer"/> class.</summary>
/// <param name="sprite">The sprite view model.</param>
/// <param name="graphics">The graphics interface for the application.</param>
/// <param name="swapChain">The swap chain for the render area.</param>
/// <param name="renderer">The 2D renderer for the application.</param>
/// <param name="vertexEditor">The editor used to modify the sprite vertices.</param>
/// <param name="initialZoom">The initial zoom scale value.</param>
public SpriteVertexOffsetRenderer(ISpriteContent sprite, GorgonGraphics graphics, GorgonSwapChain swapChain, Gorgon2D renderer, ISpriteVertexEditService vertexEditor, float initialZoom)
: base(sprite, graphics, swapChain, renderer, initialZoom)
{
InitialTextureAlpha = 0;
_vertexEditor = vertexEditor;
_vertexEditor.RectToClient = r => ToClient(r).Truncate();
_vertexEditor.PointToClient = p => ToClient(p).Truncate();
_vertexEditor.PointFromClient = p => FromClient(p).Truncate();
_workingSprite = new GorgonSprite
{
Texture = sprite.Texture,
TextureRegion = sprite.TextureCoordinates,
TextureArrayIndex = TextureArrayIndex,
Size = sprite.Size,
Scale = DX.Vector2.One,
Anchor = DX.Vector2.Zero,
Color = GorgonColor.White,
Depth = 0.1f
};
UpdateWorkingSprite();
_vertexEditor.VerticesChanged += VertexEditor_VerticesChanged;
_vertexEditor.KeyboardIconClicked += VertexEditor_KeyboardIconClicked;
_vertexEditor.VertexSelected += VertexEditor_VertexSelected;
_camera = new Gorgon2DPerspectiveCamera(renderer, new DX.Size2F(swapChain.Width, swapChain.Height));
}
/// <summary>
/// Function to locate a graphics resource by its name.
/// </summary>
/// <typeparam name="T">The type of graphics resource to look up. Must inherit from <see cref="GorgonGraphicsResource"/>.</typeparam>
/// <param name="graphics">The graphics instance that was used to create the resource.</param>
/// <param name="name">The name of the resource to find.</param>
/// <param name="filterType">[Optional] The type of filter to apply.</param>
/// <param name="comparisonType">[Optional] The type of string comparison to use for name comparison.</param>
/// <returns>An enumerable containing the resources with names that match the filter type.</returns>
/// <exception cref="ArgumentNullException">Thrown when the <paramref name="graphics"/> parameter is <b>null</b>.</exception>
/// <remarks>
/// <para>
/// Each instance of the <seealso cref="GorgonGraphics"/> keeps a weak registration of each objected inheriting from <see cref="GorgonGraphicsResource"/> that was created during the lifetime of the
/// application. Using this registration an application can look up any previously created resource (assuming it's not been collected, or disposed) should it be necessary.
/// </para>
/// <para>
/// <note type="important">
/// Resource names are not required to be unique. Therefore, searching for the name may result in multiple items being returned in the enumerable.
/// </note>
/// </para>
/// </remarks>
/// <seealso cref="GorgonGraphicsResource"/>
public static IEnumerable <T> LocateResourcesByName <T>(this GorgonGraphics graphics,
string name,
LocateFilterType filterType = LocateFilterType.Equal,
StringComparison comparisonType = StringComparison.CurrentCultureIgnoreCase)
where T : GorgonGraphicsResource
{
if (graphics == null)
{
throw new ArgumentNullException(nameof(graphics));
}
if (string.IsNullOrWhiteSpace(name))
{
return(Enumerable.Empty <T>());
}
return(graphics.GetDisposables()
.Select(item =>
{
// If the object has been collected/disposed, then do nothing.
if ((!item.TryGetTarget(out IDisposable disposable)) ||
(!(disposable is T resource)) ||
(resource.IsDisposed))
{
return null;
}
return !NameComparison(name, resource.Name, filterType, comparisonType) ? null : resource;
})
.Where(item => item != null));
}
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
Visible = true;
ClientSize = new Size(1280, 720);
_graphics = new GorgonGraphics();
_swap = _graphics.Output.CreateSwapChain("Swap", new GorgonSwapChainSettings
{
BufferCount = 2,
IsWindowed = true,
Format = BufferFormat.R8G8B8A8_UIntNormal,
Width = 1280,
Height = 720,
Window = this
});
_font = _graphics.Fonts.CreateFont("FontTest", new GorgonFontSettings
{
FontFamilyName = "Segoe UI",
FontHeightMode = FontHeightMode.Pixels,
Size = 12.0f
});
_2d = _graphics.Output.Create2DRenderer(_swap);
_2d.Begin2D();
Gorgon.ApplicationIdleLoopMethod = Idle;
}
/// <summary>
/// Function to create a constant buffer and an associated view, initialized with the specified set of values.
/// </summary>
/// <typeparam name="T">The type of data to store in the buffer. Must be an unmanaged value type.</typeparam>
/// <param name="graphics">The graphics interface to use when creating the target.</param>
/// <param name="value">The array of values to store in the buffer.</param>
/// <param name="name">[Optional] The name of the buffer.</param>
/// <param name="usage">[Optional] The intended usage of the buffer.</param>
/// <param name="firstElement">[Optional] The index of the first constant within the buffer to view.</param>
/// <param name="elementCount">[Optional] The number of constants in the buffer to view.</param>
/// <returns>A new <see cref="GorgonConstantBufferView"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when the <paramref name="graphics"/> parameter is <b>null</b>.</exception>
/// <remarks>
/// <para>
/// This is a convenience method that will create a <see cref="GorgonConstantBuffer"/> and a <see cref="GorgonConstantBufferView"/> as a single object that can be used to pass constant information
/// to a shader. The buffer created will match the size of the type specified by <typeparamref name="T"/> (adjusted to the nearest 16 bytes), multiplied by the length of the array and it will also
/// upload the <paramref name="value"/> array specified into the buffer.
/// </para>
/// <para>
/// Since the <see cref="GorgonConstantBuffer"/> created by this method is linked to the <see cref="GorgonConstantBufferView"/> returned, disposal of either one will dispose of the other on your
/// behalf. If the user created a <see cref="GorgonConstantBufferView"/> from the <see cref="GorgonConstantBuffer.GetView"/> method on the <see cref="GorgonConstantBuffer"/>, then it's assumed the
/// user knows what they are doing and will handle the disposal of the buffer and view on their own.
/// </para>
/// <para>
/// The <paramref name="firstElement"/> parameter must be between 0 and <seealso cref="TotalElementCount"/> - 1. If it is not it will be constrained to those values to ensure there is no out of
/// bounds access to the buffer.
/// </para>
/// <para>
/// If the <paramref name="elementCount"/> parameter is omitted (or less than 1), then the remainder of the buffer is mapped to the view up to 256 elements (4096 constants, or 65536 bytes). If it
/// is provided, then the number of elements will be mapped to the view, up to a maximum of 256 elements. If the value exceeds 256, then it will be constrained to 256.
/// </para>
/// <para>
/// The <paramref name="usage"/> parameter defines where the GPU should place the resource for best performance.
/// </para>
/// <para>
/// A constant buffer constant is a single float4 value (4 floating point values).
/// </para>
/// </remarks>
/// <seealso cref="GorgonConstantBuffer"/>
public static GorgonConstantBufferView CreateConstantBuffer <T>(GorgonGraphics graphics, T[] value, string name = null, ResourceUsage usage = ResourceUsage.Default, int firstElement = 0, int elementCount = 0)
where T : unmanaged
{
if (graphics == null)
{
throw new ArgumentNullException(nameof(graphics));
}
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
var buffer = new GorgonConstantBuffer(graphics, new GorgonConstantBufferInfo(name)
{
Usage = usage,
SizeInBytes = Unsafe.SizeOf <T>() * value.Length
});
buffer.SetData(value);
GorgonConstantBufferView view = buffer.GetView(firstElement, elementCount);
view._ownsBuffer = true;
return(view);
}
public void TestInitialize()
{
_form = new TestForm();
_graphics = new GorgonGraphics();
_renderer = _graphics.Output.Create2DRenderer(_form.panelDisplay);
_screen = (GorgonSwapChain)_renderer.DefaultTarget;
}
/// <summary>Initializes a new instance of the <see cref="ExtractorService"/> class.</summary>
/// <param name="renderer">The application 2D renderer.</param>
/// <param name="fileManager">The file manager for the project files.</param>
/// <param name="defaultCodec">The default sprite codec.</param>
public ExtractorService(Gorgon2D renderer, IContentFileManager fileManager, IGorgonSpriteCodec defaultCodec)
{
_renderer = renderer;
_graphics = renderer.Graphics;
_fileManager = fileManager;
_defaultCodec = defaultCodec;
}
/// <summary>Initializes a new instance of the <see cref="PlanetLayer"/> class.</summary>
/// <param name="graphics">The graphics interface for the application.</param>
/// <param name="resources">The resources for the application.</param>
public PlanetLayer(GorgonGraphics graphics, ResourceManagement resources)
{
_graphics = graphics;
_resources = resources;
_stateBuilder = new GorgonPipelineStateBuilder(graphics);
_drawCallBuilder = new GorgonDrawIndexCallBuilder();
}
/// <summary>
/// Initializes a new instance of the <see cref="GorgonPipelineStateBuilder"/> class.
/// </summary>
/// <param name="graphics">The graphics object that will build the pipeline state.</param>
public GorgonPipelineStateBuilder(GorgonGraphics graphics)
{
Graphics = graphics ?? throw new ArgumentNullException(nameof(graphics));
_workState.RwBlendStates[0] = GorgonBlendState.Default;
_workState.RasterState = GorgonRasterState.Default;
_workState.DepthStencilState = GorgonDepthStencilState.Default;
_workState.PrimitiveType = Core.PrimitiveType.TriangleList;
}
/// <summary>Initializes a new instance of the <see cref="ResourceManagement"/> class.</summary>
/// <param name="renderer">The renderer for the application.</param>
/// <param name="plugIns>The plugin service used to load file system providers.</param>
public ResourceManagement(Gorgon2D renderer, IGorgonPlugInService plugIns)
{
_renderer = renderer;
_graphics = renderer.Graphics;
_plugIns = plugIns;
_spriteCodec = new GorgonV3SpriteBinaryCodec(renderer);
}
/// <summary>
/// Initializes a new instance of the <see cref="CameraController"/> class.
/// </summary>
/// <param name="graphics">The graphics interface used for the camera buffer data.</param>
public CameraController(GorgonGraphics graphics)
{
Graphics = graphics;
_cameraBuffer = GorgonConstantBufferView.CreateConstantBuffer(graphics,
ref _viewProjectionMatrix,
"Gorgon 2D Camera Constant Buffer",
ResourceUsage.Dynamic);
}
