From acea7b2e728787a0d83bbf83c8c1f042d2c32e7e Mon Sep 17 00:00:00 2001 From: chai <215380520@qq.com> Date: Mon, 3 Jun 2024 10:15:45 +0800 Subject: + plugins project --- .../Effects/DefaultEffect.cs | 203 +++++++++++++++++++++ .../Effects/EffectResource.cs | 119 ++++++++++++ .../Effects/ITextureEffect.cs | 18 ++ .../Effects/MatrixChainEffect.cs | 155 ++++++++++++++++ .../Effects/Resources/DefaultEffect.dx11.mgfxo | Bin 0 -> 4829 bytes .../Effects/Resources/DefaultEffect.fx | 72 ++++++++ .../Effects/Resources/DefaultEffect.ogl.mgfxo | Bin 0 -> 4833 bytes .../Effects/Resources/Macros.fxh | 60 ++++++ .../Effects/Resources/RebuildEffects.bat | 15 ++ .../Effects/Resources/Structures.fxh | 51 ++++++ 10 files changed, 693 insertions(+) create mode 100644 Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/DefaultEffect.cs create mode 100644 Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/EffectResource.cs create mode 100644 Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/ITextureEffect.cs create mode 100644 Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/MatrixChainEffect.cs create mode 100644 Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/DefaultEffect.dx11.mgfxo create mode 100644 Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/DefaultEffect.fx create mode 100644 Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/DefaultEffect.ogl.mgfxo create mode 100644 Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/Macros.fxh create mode 100644 Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/RebuildEffects.bat create mode 100644 Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/Structures.fxh (limited to 'Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects') diff --git a/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/DefaultEffect.cs b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/DefaultEffect.cs new file mode 100644 index 0000000..df71e47 --- /dev/null +++ b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/DefaultEffect.cs @@ -0,0 +1,203 @@ +using System.Collections.Specialized; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Graphics; + +namespace MonoGame.Extended.Graphics.Effects +{ + /// + /// An that allows objects, within a 3D context, to be represented on a 2D monitor. + /// + /// + /// + public class DefaultEffect : MatrixChainEffect, ITextureEffect + { + /// + /// The bitmask for use with indicating wether has + /// changed in the last frame. + /// + protected static int DirtyTextureBitMask = BitVector32.CreateMask(UseDefaultProjectionBitMask); + + /// + /// The bitmask for use with indicating wether the underlying vertex shader and + /// fragment (pixel) shaders have changed to one of the pre-defined shaders in the last frame. + /// + protected static int DirtyShaderIndexBitMask = BitVector32.CreateMask(DirtyTextureBitMask); + + /// + /// The bitmask for use with indicating wether the material color has changed in + /// the last frame. + /// + public static int DirtyMaterialColorBitMask = BitVector32.CreateMask(DirtyShaderIndexBitMask); + + private Texture2D _texture; + private EffectParameter _textureParameter; + + private float _alpha = 1; + private Color _diffuseColor = Color.White; + private EffectParameter _diffuseColorParameter; + + private bool _textureEnabled; + private bool _vertexColorEnabled; + + /// + /// Gets or sets the material . + /// + /// + /// The material . + /// + public Texture2D Texture + { + get { return _texture; } + set + { + _texture = value; + Flags[DirtyTextureBitMask] = true; + } + } + + /// + /// Gets or sets the material color alpha. + /// + /// + /// + /// The alpha channel uses the premultiplied (associated) representation. This means that the RGB components of a + /// color represent + /// the color of the object of pixel, adjusted for its opacity by multiplication of . + /// + /// + public float Alpha + { + get { return _alpha; } + + set + { + _alpha = value; + Flags[DirtyMaterialColorBitMask] = true; + } + } + + /// + /// Gets or sets whether texturing is enabled. + /// + public bool TextureEnabled + { + get { return _textureEnabled; } + + set + { + if (_textureEnabled == value) + return; + _textureEnabled = value; + Flags[DirtyShaderIndexBitMask] = true; + } + } + + /// + /// Gets or sets whether vertex color is enabled. + /// + public bool VertexColorEnabled + { + get { return _vertexColorEnabled; } + + set + { + if (_vertexColorEnabled == value) + return; + _vertexColorEnabled = value; + Flags[DirtyShaderIndexBitMask] = true; + } + } + + /// + /// Initializes a new instance of the class. + /// + /// The graphics device. + public DefaultEffect(GraphicsDevice graphicsDevice) + : base(graphicsDevice, EffectResource.DefaultEffect.Bytecode) + { + Initialize(); + } + + /// + /// Initializes a new instance of the class. + /// + /// The graphics device. + /// The byte code of the shader program. + public DefaultEffect(GraphicsDevice graphicsDevice, byte[] byteCode) + : base(graphicsDevice, byteCode) + { + Initialize(); + } + + /// + /// Initializes a new instance of the class. + /// + /// The clone source. + public DefaultEffect(Effect cloneSource) + : base(cloneSource) + { + Initialize(); + } + + private void Initialize() + { + Flags[DirtyMaterialColorBitMask] = true; + _textureParameter = Parameters["Texture"]; + _diffuseColorParameter = Parameters["DiffuseColor"]; + } + + /// + /// Computes derived parameter values immediately before applying the effect. + /// + protected override void OnApply() + { + base.OnApply(); + + if (Flags[DirtyTextureBitMask]) + { + _textureParameter.SetValue(_texture); + Flags[DirtyTextureBitMask] = false; + } + + // ReSharper disable once InvertIf + if (Flags[DirtyMaterialColorBitMask]) + { + UpdateMaterialColor(); + Flags[DirtyMaterialColorBitMask] = false; + } + + // ReSharper disable once InvertIf + if (Flags[DirtyShaderIndexBitMask]) + { + var shaderIndex = 0; + + if (_textureEnabled) + shaderIndex += 1; + + if (_vertexColorEnabled) + shaderIndex += 2; + + Flags[DirtyShaderIndexBitMask] = false; + CurrentTechnique = Techniques[shaderIndex]; + } + } + + /// + /// Updates the material color parameters associated with this . + /// + protected virtual void UpdateMaterialColor() + { + var diffuseColorVector3 = _diffuseColor.ToVector3(); + + var diffuseColorVector4 = new Vector4() + { + X = diffuseColorVector3.X * Alpha, + Y = diffuseColorVector3.Y * Alpha, + Z = diffuseColorVector3.Z * Alpha, + W = Alpha, + }; + + _diffuseColorParameter.SetValue(diffuseColorVector4); + } + } +} \ No newline at end of file diff --git a/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/EffectResource.cs b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/EffectResource.cs new file mode 100644 index 0000000..43bd535 --- /dev/null +++ b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/EffectResource.cs @@ -0,0 +1,119 @@ +using System; +using System.Diagnostics; +using System.IO; +using System.Reflection; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Graphics; + +namespace MonoGame.Extended.Graphics.Effects +{ + /// + /// Reperesents the bytecode of an that is encapsulated inside a compiled assembly. + /// + /// + /// + /// Files that are encapsulated inside a compiled assembly are commonly known as Manifiest or embedded resources. + /// Since embedded resources are added to the assembly at compiled time, they can not be accidentally deleted or + /// misplaced. However, if the file needs to be changed, the assembly will need to be re-compiled with the changed + /// file. + /// + /// + /// To add an embedded resource file to an assembly, first add it to the project and then change the Build Action + /// in the Properties of the file to Embedded Resource. The next time the project is compiled, the + /// compiler will add the file to the assembly as an embedded resource. The compiler adds namespace(s) to the + /// embedded resource so it matches with the path of where the file was added to the project. + /// + /// + public class EffectResource + { + private static EffectResource _defaultEffect; + private static string _shaderExtension; + + /// + /// Gets the embedded into the MonoGame.Extended.Graphics library. + /// + public static EffectResource DefaultEffect => _defaultEffect ?? (_defaultEffect = new EffectResource($"MonoGame.Extended.Graphics.Effects.Resources.DefaultEffect.{_shaderExtension}.mgfxo")); + + static EffectResource() + { + DetermineShaderExtension(); + } + + private static void DetermineShaderExtension() + { + // use reflection to figure out if Shader.Profile is OpenGL (0) or DirectX (1), + // may need to be changed / fixed for future shader profiles + + var assembly = typeof(Game).GetTypeInfo().Assembly; + Debug.Assert(assembly != null); + + var shaderType = assembly.GetType("Microsoft.Xna.Framework.Graphics.Shader"); + Debug.Assert(shaderType != null); + var shaderTypeInfo = shaderType.GetTypeInfo(); + Debug.Assert(shaderTypeInfo != null); + + // https://github.com/MonoGame/MonoGame/blob/develop/MonoGame.Framework/Graphics/Shader/Shader.cs#L47 + var profileProperty = shaderTypeInfo.GetDeclaredProperty("Profile"); + var value = (int)profileProperty.GetValue(null); + + switch (value) + { + case 0: + // OpenGL + _shaderExtension = "ogl"; + break; + case 1: + // DirectX + _shaderExtension = "dx11"; + break; + default: + throw new InvalidOperationException("Unknown shader profile."); + } + } + + private readonly string _resourceName; + private volatile byte[] _bytecode; + private readonly Assembly _assembly; + + /// + /// Gets the bytecode of the file. + /// + /// + /// The bytecode of the file. + /// + public byte[] Bytecode + { + get + { + if (_bytecode != null) + return _bytecode; + + lock (this) + { + if (_bytecode != null) + return _bytecode; + + var stream = _assembly.GetManifestResourceStream(_resourceName); + using (var memoryStream = new MemoryStream()) + { + stream.CopyTo(memoryStream); + _bytecode = memoryStream.ToArray(); + } + } + + return _bytecode; + } + } + + /// + /// Initializes a new instance of the class. + /// + /// The name of the embedded resource. This must include the namespace(s). + /// The assembly which the embedded resource is apart of. + public EffectResource(string resourceName, Assembly assembly = null) + { + _resourceName = resourceName; + _assembly = assembly ?? typeof(EffectResource).GetTypeInfo().Assembly; + } + } +} \ No newline at end of file diff --git a/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/ITextureEffect.cs b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/ITextureEffect.cs new file mode 100644 index 0000000..ea2ef0b --- /dev/null +++ b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/ITextureEffect.cs @@ -0,0 +1,18 @@ +using Microsoft.Xna.Framework.Graphics; + +namespace MonoGame.Extended.Graphics.Effects +{ + /// + /// Defines an that uses a . + /// + public interface ITextureEffect + { + /// + /// Gets or sets the . + /// + /// + /// The . + /// + Texture2D Texture { get; set; } + } +} \ No newline at end of file diff --git a/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/MatrixChainEffect.cs b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/MatrixChainEffect.cs new file mode 100644 index 0000000..046479f --- /dev/null +++ b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/MatrixChainEffect.cs @@ -0,0 +1,155 @@ +using System.Collections.Specialized; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Graphics; + +namespace MonoGame.Extended.Graphics.Effects +{ + /// + /// An that uses the standard chain of matrix transformations to represent a 3D object on a 2D + /// monitor. + /// + /// + /// + public abstract class MatrixChainEffect : Effect, IMatrixChainEffect + { + /// + /// The bitmask for use with indicating wether , , or has changed in the last frame. + /// + protected static int DirtyWorldViewProjectionBitMask = BitVector32.CreateMask(); + + /// + /// The bitmask for use with indicating wether to use a default projection matrix or a custom projection matrix. + /// + protected static int UseDefaultProjectionBitMask = BitVector32.CreateMask(DirtyWorldViewProjectionBitMask); + + /// + /// The dirty flags associated with this . + /// + protected BitVector32 Flags; + + private Matrix _projection = Matrix.Identity; + private Matrix _view = Matrix.Identity; + private Matrix _world = Matrix.Identity; + private EffectParameter _matrixParameter; + + /// + /// Gets or sets the model-to-world . + /// + /// + /// The model-to-world . + /// + public Matrix World + { + get { return _world; } + set { SetWorld(ref value); } + } + + /// + /// Gets or sets the world-to-view . + /// + /// + /// The world-to-view . + /// + public Matrix View + { + get { return _view; } + set { SetView(ref value); } + } + + /// + /// Gets or sets the view-to-projection . + /// + /// + /// The view-to-projection . + /// + public Matrix Projection + { + get { return _projection; } + set { SetProjection(ref value); } + } + + /// + /// Initializes a new instance of the class. + /// + /// The graphics device. + /// The effect code. + protected MatrixChainEffect(GraphicsDevice graphicsDevice, byte[] byteCode) + : base(graphicsDevice, byteCode) + { + Initialize(); + } + + /// + /// Initializes a new instance of the class. + /// + /// The clone source. + protected MatrixChainEffect(Effect cloneSource) + : base(cloneSource) + { + Initialize(); + } + + private void Initialize() + { + Flags[UseDefaultProjectionBitMask] = true; + + _matrixParameter = Parameters["WorldViewProjection"]; + } + + /// + /// Sets the model-to-world . + /// + /// The model-to-world . + public void SetWorld(ref Matrix world) + { + _world = world; + Flags[DirtyWorldViewProjectionBitMask] = true; + } + + /// + /// Sets the world-to-view . + /// + /// The world-to-view . + public void SetView(ref Matrix view) + { + _view = view; + Flags[DirtyWorldViewProjectionBitMask] = true; + } + + /// + /// Sets the view-to-projection . + /// + /// The view-to-projection . + public void SetProjection(ref Matrix projection) + { + _projection = projection; + Flags[DirtyWorldViewProjectionBitMask] = true; + Flags[UseDefaultProjectionBitMask] = false; + } + + /// + /// Computes derived parameter values immediately before applying the effect. + /// + protected override void OnApply() + { + base.OnApply(); + + // ReSharper disable once InvertIf + if (Flags[DirtyWorldViewProjectionBitMask] || Flags[UseDefaultProjectionBitMask]) + { + if (Flags[UseDefaultProjectionBitMask]) + { + var viewport = GraphicsDevice.Viewport; + _projection = Matrix.CreateOrthographicOffCenter(0, viewport.Width, viewport.Height, 0, 0, -1); + } + + Matrix worldViewProjection; + Matrix.Multiply(ref _world, ref _view, out worldViewProjection); + Matrix.Multiply(ref worldViewProjection, ref _projection, out worldViewProjection); + _matrixParameter.SetValue(worldViewProjection); + + Flags[DirtyWorldViewProjectionBitMask] = false; + } + } + } +} \ No newline at end of file diff --git a/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/DefaultEffect.dx11.mgfxo b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/DefaultEffect.dx11.mgfxo new file mode 100644 index 0000000..b83b6ed Binary files /dev/null and b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/DefaultEffect.dx11.mgfxo differ diff --git a/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/DefaultEffect.fx b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/DefaultEffect.fx new file mode 100644 index 0000000..30a772d --- /dev/null +++ b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/DefaultEffect.fx @@ -0,0 +1,72 @@ +#include "Macros.fxh" +#include "Structures.fxh" + +DECLARE_TEXTURE(Texture, 0); + +BEGIN_CONSTANTS + +float4 DiffuseColor = float4(1, 1, 1, 1); + +MATRIX_CONSTANTS + +float4x4 WorldViewProjection _vs(c0) _cb(c0); + +END_CONSTANTS + +VertexShaderOutputPosition VertexShaderFunctionPosition(VertexShaderInputPosition input) +{ + VertexShaderOutputPosition output; + output.Position = mul(input.Position, WorldViewProjection); + return output; +} + +float4 PixelShaderFunctionPosition(VertexShaderOutputPosition input) : SV_Target0 +{ + return DiffuseColor; +} + +VertexShaderOutputPositionTexture VertexShaderFunctionPositionTexture(VertexShaderInputPositionTexture input) +{ + VertexShaderOutputPositionTexture output; + output.Position = mul(input.Position, WorldViewProjection); + output.TextureCoordinate = input.TextureCoordinate; + return output; +} + +float4 PixelShaderFunctionPositionTexture(VertexShaderOutputPositionTexture input) : SV_Target0 +{ + return SAMPLE_TEXTURE(Texture, input.TextureCoordinate) * DiffuseColor; +} + +VertexShaderOutputPositionColor VertexShaderFunctionPositionColor(VertexShaderInputPositionColor input) +{ + VertexShaderOutputPositionColor output; + output.Position = mul(input.Position, WorldViewProjection); + output.Color = input.Color; + return output; +} + +float4 PixelShaderFunctionPositionColor(VertexShaderOutputPositionColor input) : SV_Target0 +{ + return input.Color * DiffuseColor; +} + +VertexShaderOutputPositionColorTexture VertexShaderFunctionPositionColorTexture(VertexShaderInputPositionColorTexture input) +{ + VertexShaderOutputPositionColorTexture output; + output.Position = mul(input.Position, WorldViewProjection); + output.Color = input.Color; + output.TextureCoordinate = input.TextureCoordinate; + return output; +} + +float4 PixelShaderFunctionPositionColorTexture(VertexShaderOutputPositionColorTexture input) : SV_Target0 +{ + float4 textureColor = SAMPLE_TEXTURE(Texture, input.TextureCoordinate); + return textureColor * input.Color * DiffuseColor; +} + +TECHNIQUE(Position, VertexShaderFunctionPosition, PixelShaderFunctionPosition); +TECHNIQUE(PositionTexture, VertexShaderFunctionPositionTexture, PixelShaderFunctionPositionTexture); +TECHNIQUE(PositionColor, VertexShaderFunctionPositionColor, PixelShaderFunctionPositionColor); +TECHNIQUE(PositionColorTexture, VertexShaderFunctionPositionColorTexture, PixelShaderFunctionPositionColorTexture); \ No newline at end of file diff --git a/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/DefaultEffect.ogl.mgfxo b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/DefaultEffect.ogl.mgfxo new file mode 100644 index 0000000..4f51d2a Binary files /dev/null and b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/DefaultEffect.ogl.mgfxo differ diff --git a/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/Macros.fxh b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/Macros.fxh new file mode 100644 index 0000000..c253efe --- /dev/null +++ b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/Macros.fxh @@ -0,0 +1,60 @@ +//----------------------------------------------------------------------------- +// Macros.fxh +// +// Microsoft XNA Community Game Platform +// Copyright (C) Microsoft Corporation. All rights reserved. +//----------------------------------------------------------------------------- + +#if SM4 + +// Macros for targetting shader model 4.0 (DX11) + +#define TECHNIQUE(name, vsname, psname ) \ + technique name { pass { VertexShader = compile vs_4_0_level_9_1 vsname (); PixelShader = compile ps_4_0_level_9_1 psname(); } } + +#define BEGIN_CONSTANTS cbuffer Parameters : register(b0) { +#define MATRIX_CONSTANTS +#define END_CONSTANTS }; + +#define _vs(r) +#define _ps(r) +#define _cb(r) + +#define DECLARE_TEXTURE(Name, index) \ + Texture2D Name : register(t##index); \ + sampler Name##Sampler : register(s##index) + +#define DECLARE_CUBEMAP(Name, index) \ + TextureCube Name : register(t##index); \ + sampler Name##Sampler : register(s##index) + +#define SAMPLE_TEXTURE(Name, texCoord) Name.Sample(Name##Sampler, texCoord) +#define SAMPLE_CUBEMAP(Name, texCoord) Name.Sample(Name##Sampler, texCoord) + + +#else + +// Macros for targetting shader model 2.0 (DX9) + +#define TECHNIQUE(name, vsname, psname ) \ + technique name { pass { VertexShader = compile vs_2_0 vsname (); PixelShader = compile ps_2_0 psname(); } } + +#define BEGIN_CONSTANTS +#define MATRIX_CONSTANTS +#define END_CONSTANTS + +#define _vs(r) : register(vs, r) +#define _ps(r) : register(ps, r) +#define _cb(r) + +#define DECLARE_TEXTURE(Name, index) \ + sampler2D Name : register(s##index); + +#define DECLARE_CUBEMAP(Name, index) \ + samplerCUBE Name : register(s##index); + +#define SAMPLE_TEXTURE(Name, texCoord) tex2D(Name, texCoord) +#define SAMPLE_CUBEMAP(Name, texCoord) texCUBE(Name, texCoord) + + +#endif \ No newline at end of file diff --git a/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/RebuildEffects.bat b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/RebuildEffects.bat new file mode 100644 index 0000000..4fc7f21 --- /dev/null +++ b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/RebuildEffects.bat @@ -0,0 +1,15 @@ +setlocal + +SET TWOMGFX="mgfxc" + +@for /f %%f IN ('dir /b *.fx') do ( + + call %TWOMGFX% %%~nf.fx %%~nf.ogl.mgfxo /Profile:OpenGL + + call %TWOMGFX% %%~nf.fx %%~nf.dx11.mgfxo /Profile:DirectX_11 + +) + +endlocal + +pause \ No newline at end of file diff --git a/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/Structures.fxh b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/Structures.fxh new file mode 100644 index 0000000..d3af6a0 --- /dev/null +++ b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/Structures.fxh @@ -0,0 +1,51 @@ +// Vertex shader input structures. + +struct VertexShaderInputPosition +{ + float4 Position : SV_Position; +}; + +struct VertexShaderInputPositionColor +{ + float4 Position : SV_Position; + float4 Color : COLOR; +}; + +struct VertexShaderInputPositionTexture +{ + float4 Position : SV_Position; + float2 TextureCoordinate : TEXCOORD0; +}; + +struct VertexShaderInputPositionColorTexture +{ + float4 Position : SV_Position; + float4 Color : COLOR; + float2 TextureCoordinate : TEXCOORD0; +}; + +// Vertex shader output structures. + +struct VertexShaderOutputPosition +{ + float4 Position : SV_Position; +}; + +struct VertexShaderOutputPositionColor +{ + float4 Position : SV_Position; + float4 Color : COLOR0; +}; + +struct VertexShaderOutputPositionTexture +{ + float4 Position : SV_Position; + float2 TextureCoordinate : TEXCOORD0; +}; + +struct VertexShaderOutputPositionColorTexture +{ + float4 Position : SV_Position; + float4 Color : COLOR0; + float2 TextureCoordinate : TEXCOORD0; +}; -- cgit v1.1-26-g67d0