|
|
#region License
|
|
|
/* FNA - XNA4 Reimplementation for Desktop Platforms
|
|
|
* Copyright 2009-2022 Ethan Lee and the MonoGame Team
|
|
|
*
|
|
|
* Released under the Microsoft Public License.
|
|
|
* See LICENSE for details.
|
|
|
*/
|
|
|
#endregion
|
|
|
|
|
|
#region Using Statements
|
|
|
using System;
|
|
|
using System.Collections.Generic;
|
|
|
using System.Runtime.InteropServices;
|
|
|
#endregion
|
|
|
|
|
|
namespace Microsoft.Xna.Framework.Graphics
|
|
|
{
|
|
|
public class Effect : GraphicsResource
|
|
|
{
|
|
|
#region Public Properties
|
|
|
|
|
|
private EffectTechnique INTERNAL_currentTechnique;
|
|
|
public EffectTechnique CurrentTechnique
|
|
|
{
|
|
|
get
|
|
|
{
|
|
|
return INTERNAL_currentTechnique;
|
|
|
}
|
|
|
set
|
|
|
{
|
|
|
FNA3D.FNA3D_SetEffectTechnique(
|
|
|
GraphicsDevice.GLDevice,
|
|
|
glEffect,
|
|
|
value.TechniquePointer
|
|
|
);
|
|
|
INTERNAL_currentTechnique = value;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
public EffectParameterCollection Parameters
|
|
|
{
|
|
|
get;
|
|
|
private set;
|
|
|
}
|
|
|
|
|
|
public EffectTechniqueCollection Techniques
|
|
|
{
|
|
|
get;
|
|
|
private set;
|
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
#region Internal FNA3D Variables
|
|
|
|
|
|
internal IntPtr glEffect;
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
#region Private Variables
|
|
|
|
|
|
private Dictionary<IntPtr, EffectParameter> samplerMap = new Dictionary<IntPtr, EffectParameter>(new IntPtrBoxlessComparer());
|
|
|
private class IntPtrBoxlessComparer : IEqualityComparer<IntPtr>
|
|
|
{
|
|
|
public bool Equals(IntPtr x, IntPtr y)
|
|
|
{
|
|
|
return x == y;
|
|
|
}
|
|
|
|
|
|
public int GetHashCode(IntPtr obj)
|
|
|
{
|
|
|
return obj.GetHashCode();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
private IntPtr stateChangesPtr;
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
#region Private Static Variables
|
|
|
|
|
|
private static readonly EffectParameterType[] XNAType = new EffectParameterType[]
|
|
|
{
|
|
|
EffectParameterType.Void, // MOJOSHADER_SYMTYPE_VOID
|
|
|
EffectParameterType.Bool, // MOJOSHADER_SYMTYPE_BOOL
|
|
|
EffectParameterType.Int32, // MOJOSHADER_SYMTYPE_INT
|
|
|
EffectParameterType.Single, // MOJOSHADER_SYMTYPE_FLOAT
|
|
|
EffectParameterType.String, // MOJOSHADER_SYMTYPE_STRING
|
|
|
EffectParameterType.Texture, // MOJOSHADER_SYMTYPE_TEXTURE
|
|
|
EffectParameterType.Texture1D, // MOJOSHADER_SYMTYPE_TEXTURE1D
|
|
|
EffectParameterType.Texture2D, // MOJOSHADER_SYMTYPE_TEXTURE2D
|
|
|
EffectParameterType.Texture3D, // MOJOSHADER_SYMTYPE_TEXTURE3D
|
|
|
EffectParameterType.TextureCube // MOJOSHADER_SYMTYPE_TEXTURECUBE
|
|
|
};
|
|
|
|
|
|
private static readonly EffectParameterClass[] XNAClass = new EffectParameterClass[]
|
|
|
{
|
|
|
EffectParameterClass.Scalar, // MOJOSHADER_SYMCLASS_SCALAR
|
|
|
EffectParameterClass.Vector, // MOJOSHADER_SYMCLASS_VECTOR
|
|
|
EffectParameterClass.Matrix, // MOJOSHADER_SYMCLASS_MATRIX_ROWS
|
|
|
EffectParameterClass.Matrix, // MOJOSHADER_SYMCLASS_MATRIX_COLUMNS
|
|
|
EffectParameterClass.Object, // MOJOSHADER_SYMCLASS_OBJECT
|
|
|
EffectParameterClass.Struct // MOJOSHADER_SYMCLASS_STRUCT
|
|
|
};
|
|
|
|
|
|
private static readonly Blend[] XNABlend = new Blend[]
|
|
|
{
|
|
|
(Blend) (-1), // NOPE
|
|
|
Blend.Zero, // MOJOSHADER_BLEND_ZERO
|
|
|
Blend.One, // MOJOSHADER_BLEND_ONE
|
|
|
Blend.SourceColor, // MOJOSHADER_BLEND_SRCCOLOR
|
|
|
Blend.InverseSourceColor, // MOJOSHADER_BLEND_INVSRCCOLOR
|
|
|
Blend.SourceAlpha, // MOJOSHADER_BLEND_SRCALPHA
|
|
|
Blend.InverseSourceAlpha, // MOJOSHADER_BLEND_INVSRCALPHA
|
|
|
Blend.DestinationAlpha, // MOJOSHADER_BLEND_DESTALPHA
|
|
|
Blend.InverseDestinationAlpha, // MOJOSHADER_BLEND_INVDESTALPHA
|
|
|
Blend.DestinationColor, // MOJOSHADER_BLEND_DESTCOLOR
|
|
|
Blend.InverseDestinationColor, // MOJOSHADER_BLEND_INVDESTCOLOR
|
|
|
Blend.SourceAlphaSaturation, // MOJOSHADER_BLEND_SRCALPHASAT
|
|
|
(Blend) (-1), // NOPE
|
|
|
(Blend) (-1), // NOPE
|
|
|
Blend.BlendFactor, // MOJOSHADER_BLEND_BLENDFACTOR
|
|
|
Blend.InverseBlendFactor // MOJOSHADER_BLEND_INVBLENDFACTOR
|
|
|
};
|
|
|
|
|
|
private static readonly BlendFunction[] XNABlendOp = new BlendFunction[]
|
|
|
{
|
|
|
(BlendFunction) (-1), // NOPE
|
|
|
BlendFunction.Add, // MOJOSHADER_BLENDOP_ADD
|
|
|
BlendFunction.Subtract, // MOJOSHADER_BLENDOP_SUBTRACT
|
|
|
BlendFunction.ReverseSubtract, // MOJOSHADER_BLENDOP_REVSUBTRACT
|
|
|
BlendFunction.Min, // MOJOSHADER_BLENDOP_MIN
|
|
|
BlendFunction.Max // MOJOSHADER_BLENDOP_MAX
|
|
|
};
|
|
|
|
|
|
private static readonly CompareFunction[] XNACompare = new CompareFunction[]
|
|
|
{
|
|
|
(CompareFunction) (-1), // NOPE
|
|
|
CompareFunction.Never, // MOJOSHADER_CMP_NEVER
|
|
|
CompareFunction.Less, // MOJOSHADER_CMP_LESS
|
|
|
CompareFunction.Equal, // MOJOSHADER_CMP_EQUAL
|
|
|
CompareFunction.LessEqual, // MOJOSHADER_CMP_LESSEQUAL
|
|
|
CompareFunction.Greater, // MOJOSHADER_CMP_GREATER
|
|
|
CompareFunction.NotEqual, // MOJOSHADER_CMP_NOTEQUAL
|
|
|
CompareFunction.GreaterEqual, // MOJOSHADER_CMP_GREATEREQUAL
|
|
|
CompareFunction.Always // MOJOSHADER_CMP_ALWAYS
|
|
|
};
|
|
|
|
|
|
private static readonly StencilOperation[] XNAStencilOp = new StencilOperation[]
|
|
|
{
|
|
|
(StencilOperation) (-1), // NOPE
|
|
|
StencilOperation.Keep, // MOJOSHADER_STENCILOP_KEEP
|
|
|
StencilOperation.Zero, // MOJOSHADER_STENCILOP_ZERO
|
|
|
StencilOperation.Replace, // MOJOSHADER_STENCILOP_REPLACE
|
|
|
StencilOperation.IncrementSaturation, // MOJOSHADER_STENCILOP_INCRSAT
|
|
|
StencilOperation.DecrementSaturation, // MOJOSHADER_STENCILOP_DECRSAT
|
|
|
StencilOperation.Invert, // MOJOSHADER_STENCILOP_INVERT
|
|
|
StencilOperation.Increment, // MOJOSHADER_STENCILOP_INCR
|
|
|
StencilOperation.Decrement // MOJOSHADER_STENCILOP_DECR
|
|
|
};
|
|
|
|
|
|
private static readonly TextureAddressMode[] XNAAddress = new TextureAddressMode[]
|
|
|
{
|
|
|
(TextureAddressMode) (-1), // NOPE
|
|
|
TextureAddressMode.Wrap, // MOJOSHADER_TADDRESS_WRAP
|
|
|
TextureAddressMode.Mirror, // MOJOSHADER_TADDRESS_MIRROR
|
|
|
TextureAddressMode.Clamp // MOJOSHADER_TADDRESS_CLAMP
|
|
|
};
|
|
|
|
|
|
private static readonly MOJOSHADER_textureFilterType[] XNAMag =
|
|
|
new MOJOSHADER_textureFilterType[]
|
|
|
{
|
|
|
MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_LINEAR, // TextureFilter.Linear
|
|
|
MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_POINT, // TextureFilter.Point
|
|
|
MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_ANISOTROPIC, // TextureFilter.Anisotropic
|
|
|
MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_LINEAR, // TextureFilter.LinearMipPoint
|
|
|
MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_POINT, // TextureFilter.PointMipLinear
|
|
|
MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_POINT, // TextureFilter.MinLinearMagPointMipLinear
|
|
|
MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_POINT, // TextureFilter.MinLinearMagPointMipPoint
|
|
|
MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_LINEAR, // TextureFilter.MinPointMagLinearMipLinear
|
|
|
MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_LINEAR // TextureFilter.MinPointMagLinearMipPoint
|
|
|
};
|
|
|
|
|
|
private static readonly MOJOSHADER_textureFilterType[] XNAMin =
|
|
|
new MOJOSHADER_textureFilterType[]
|
|
|
{
|
|
|
MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_LINEAR, // TextureFilter.Linear
|
|
|
MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_POINT, // TextureFilter.Point
|
|
|
MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_ANISOTROPIC, // TextureFilter.Anisotropic
|
|
|
MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_LINEAR, // TextureFilter.LinearMipPoint
|
|
|
MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_POINT, // TextureFilter.PointMipLinear
|
|
|
MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_LINEAR, // TextureFilter.MinLinearMagPointMipLinear
|
|
|
MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_LINEAR, // TextureFilter.MinLinearMagPointMipPoint
|
|
|
MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_POINT, // TextureFilter.MinPointMagLinearMipLinear
|
|
|
MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_POINT // TextureFilter.MinPointMagLinearMipPoint
|
|
|
};
|
|
|
|
|
|
private static readonly MOJOSHADER_textureFilterType[] XNAMip =
|
|
|
new MOJOSHADER_textureFilterType[]
|
|
|
{
|
|
|
MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_LINEAR, // TextureFilter.Linear
|
|
|
MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_POINT, // TextureFilter.Point
|
|
|
MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_ANISOTROPIC, // TextureFilter.Anisotropic
|
|
|
MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_POINT, // TextureFilter.LinearMipPoint
|
|
|
MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_LINEAR, // TextureFilter.PointMipLinear
|
|
|
MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_LINEAR, // TextureFilter.MinLinearMagPointMipLinear
|
|
|
MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_POINT, // TextureFilter.MinLinearMagPointMipPoint
|
|
|
MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_LINEAR, // TextureFilter.MinPointMagLinearMipLinear
|
|
|
MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_POINT // TextureFilter.MinPointMagLinearMipPoint
|
|
|
};
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
#region Public Constructor
|
|
|
|
|
|
public Effect(GraphicsDevice graphicsDevice, byte[] effectCode)
|
|
|
{
|
|
|
GraphicsDevice = graphicsDevice;
|
|
|
|
|
|
// Send the blob to the GLDevice to be parsed/compiled
|
|
|
IntPtr effectData;
|
|
|
FNA3D.FNA3D_CreateEffect(
|
|
|
graphicsDevice.GLDevice,
|
|
|
effectCode,
|
|
|
effectCode.Length,
|
|
|
out glEffect,
|
|
|
out effectData
|
|
|
);
|
|
|
|
|
|
// This is where it gets ugly...
|
|
|
INTERNAL_parseEffectStruct(effectData);
|
|
|
|
|
|
// The default technique is the first technique.
|
|
|
CurrentTechnique = Techniques[0];
|
|
|
|
|
|
// Use native memory for changes, .NET loves moving this around
|
|
|
unsafe
|
|
|
{
|
|
|
stateChangesPtr = Marshal.AllocHGlobal(
|
|
|
sizeof(MOJOSHADER_effectStateChanges)
|
|
|
);
|
|
|
MOJOSHADER_effectStateChanges *stateChanges =
|
|
|
(MOJOSHADER_effectStateChanges*) stateChangesPtr;
|
|
|
stateChanges->render_state_change_count = 0;
|
|
|
stateChanges->sampler_state_change_count = 0;
|
|
|
stateChanges->vertex_sampler_state_change_count = 0;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
#region Protected Constructor
|
|
|
|
|
|
protected Effect(Effect cloneSource)
|
|
|
{
|
|
|
GraphicsDevice = cloneSource.GraphicsDevice;
|
|
|
|
|
|
// Send the parsed data to be cloned and recompiled by MojoShader
|
|
|
IntPtr effectData;
|
|
|
FNA3D.FNA3D_CloneEffect(
|
|
|
GraphicsDevice.GLDevice,
|
|
|
cloneSource.glEffect,
|
|
|
out glEffect,
|
|
|
out effectData
|
|
|
);
|
|
|
|
|
|
// Double the ugly, double the fun!
|
|
|
INTERNAL_parseEffectStruct(effectData);
|
|
|
|
|
|
// Copy texture parameters, if applicable
|
|
|
for (int i = 0; i < cloneSource.Parameters.Count; i += 1)
|
|
|
{
|
|
|
Parameters[i].texture = cloneSource.Parameters[i].texture;
|
|
|
}
|
|
|
|
|
|
// The default technique is whatever the current technique was.
|
|
|
for (int i = 0; i < cloneSource.Techniques.Count; i += 1)
|
|
|
{
|
|
|
if (cloneSource.Techniques[i] == cloneSource.CurrentTechnique)
|
|
|
{
|
|
|
CurrentTechnique = Techniques[i];
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// Use native memory for changes, .NET loves moving this around
|
|
|
unsafe
|
|
|
{
|
|
|
stateChangesPtr = Marshal.AllocHGlobal(
|
|
|
sizeof(MOJOSHADER_effectStateChanges)
|
|
|
);
|
|
|
MOJOSHADER_effectStateChanges *stateChanges =
|
|
|
(MOJOSHADER_effectStateChanges*) stateChangesPtr;
|
|
|
stateChanges->render_state_change_count = 0;
|
|
|
stateChanges->sampler_state_change_count = 0;
|
|
|
stateChanges->vertex_sampler_state_change_count = 0;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
#region Public Methods
|
|
|
|
|
|
public virtual Effect Clone()
|
|
|
{
|
|
|
return new Effect(this);
|
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
#region Protected Methods
|
|
|
|
|
|
protected override void Dispose(bool disposing)
|
|
|
{
|
|
|
if (!IsDisposed)
|
|
|
{
|
|
|
if (glEffect != IntPtr.Zero)
|
|
|
{
|
|
|
FNA3D.FNA3D_AddDisposeEffect(
|
|
|
GraphicsDevice.GLDevice,
|
|
|
glEffect
|
|
|
);
|
|
|
}
|
|
|
if (stateChangesPtr != IntPtr.Zero)
|
|
|
{
|
|
|
Marshal.FreeHGlobal(stateChangesPtr);
|
|
|
stateChangesPtr = IntPtr.Zero;
|
|
|
}
|
|
|
}
|
|
|
base.Dispose(disposing);
|
|
|
}
|
|
|
|
|
|
protected internal virtual void OnApply()
|
|
|
{
|
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
#region Internal Methods
|
|
|
|
|
|
internal unsafe void INTERNAL_applyEffect(uint pass)
|
|
|
{
|
|
|
FNA3D.FNA3D_ApplyEffect(
|
|
|
GraphicsDevice.GLDevice,
|
|
|
glEffect,
|
|
|
pass,
|
|
|
stateChangesPtr
|
|
|
);
|
|
|
MOJOSHADER_effectStateChanges *stateChanges =
|
|
|
(MOJOSHADER_effectStateChanges*) stateChangesPtr;
|
|
|
if (stateChanges->render_state_change_count > 0)
|
|
|
{
|
|
|
PipelineCache pipelineCache = GraphicsDevice.PipelineCache;
|
|
|
pipelineCache.BeginApplyBlend();
|
|
|
pipelineCache.BeginApplyDepthStencil();
|
|
|
pipelineCache.BeginApplyRasterizer();
|
|
|
|
|
|
// Used to avoid redundant device state application
|
|
|
bool blendStateChanged = false;
|
|
|
bool depthStencilStateChanged = false;
|
|
|
bool rasterizerStateChanged = false;
|
|
|
|
|
|
MOJOSHADER_effectState* states = (MOJOSHADER_effectState*) stateChanges->render_state_changes;
|
|
|
for (int i = 0; i < stateChanges->render_state_change_count; i += 1)
|
|
|
{
|
|
|
MOJOSHADER_renderStateType type = states[i].type;
|
|
|
if ( type == MOJOSHADER_renderStateType.MOJOSHADER_RS_VERTEXSHADER ||
|
|
|
type == MOJOSHADER_renderStateType.MOJOSHADER_RS_PIXELSHADER )
|
|
|
{
|
|
|
// Skip shader states
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
if (type == MOJOSHADER_renderStateType.MOJOSHADER_RS_ZENABLE)
|
|
|
{
|
|
|
MOJOSHADER_zBufferType* val = (MOJOSHADER_zBufferType*) states[i].value.values;
|
|
|
pipelineCache.DepthBufferEnable =
|
|
|
(*val == MOJOSHADER_zBufferType.MOJOSHADER_ZB_TRUE);
|
|
|
depthStencilStateChanged = true;
|
|
|
}
|
|
|
else if (type == MOJOSHADER_renderStateType.MOJOSHADER_RS_FILLMODE)
|
|
|
{
|
|
|
MOJOSHADER_fillMode* val = (MOJOSHADER_fillMode*) states[i].value.values;
|
|
|
if (*val == MOJOSHADER_fillMode.MOJOSHADER_FILL_SOLID)
|
|
|
{
|
|
|
pipelineCache.FillMode = FillMode.Solid;
|
|
|
}
|
|
|
else if (*val == MOJOSHADER_fillMode.MOJOSHADER_FILL_WIREFRAME)
|
|
|
{
|
|
|
pipelineCache.FillMode = FillMode.WireFrame;
|
|
|
}
|
|
|
rasterizerStateChanged = true;
|
|
|
}
|
|
|
else if (type == MOJOSHADER_renderStateType.MOJOSHADER_RS_ZWRITEENABLE)
|
|
|
{
|
|
|
int* val = (int*) states[i].value.values;
|
|
|
pipelineCache.DepthBufferWriteEnable = (*val == 1);
|
|
|
depthStencilStateChanged = true;
|
|
|
}
|
|
|
else if (type == MOJOSHADER_renderStateType.MOJOSHADER_RS_SRCBLEND)
|
|
|
{
|
|
|
MOJOSHADER_blendMode* val = (MOJOSHADER_blendMode*) states[i].value.values;
|
|
|
pipelineCache.ColorSourceBlend = XNABlend[(int) *val];
|
|
|
if (!pipelineCache.SeparateAlphaBlend)
|
|
|
{
|
|
|
pipelineCache.AlphaSourceBlend = XNABlend[(int) *val];
|
|
|
}
|
|
|
blendStateChanged = true;
|
|
|
}
|
|
|
else if (type == MOJOSHADER_renderStateType.MOJOSHADER_RS_DESTBLEND)
|
|
|
{
|
|
|
MOJOSHADER_blendMode* val = (MOJOSHADER_blendMode*) states[i].value.values;
|
|
|
pipelineCache.ColorDestinationBlend = XNABlend[(int) *val];
|
|
|
if (!pipelineCache.SeparateAlphaBlend)
|
|
|
{
|
|
|
pipelineCache.AlphaDestinationBlend = XNABlend[(int) *val];
|
|
|
}
|
|
|
blendStateChanged = true;
|
|
|
}
|
|
|
else if (type == MOJOSHADER_renderStateType.MOJOSHADER_RS_CULLMODE)
|
|
|
{
|
|
|
MOJOSHADER_cullMode* val = (MOJOSHADER_cullMode*) states[i].value.values;
|
|
|
if (*val == MOJOSHADER_cullMode.MOJOSHADER_CULL_NONE)
|
|
|
{
|
|
|
pipelineCache.CullMode = CullMode.None;
|
|
|
}
|
|
|
else if (*val == MOJOSHADER_cullMode.MOJOSHADER_CULL_CW)
|
|
|
{
|
|
|
pipelineCache.CullMode = CullMode.CullClockwiseFace;
|
|
|
}
|
|
|
else if (*val == MOJOSHADER_cullMode.MOJOSHADER_CULL_CCW)
|
|
|
{
|
|
|
pipelineCache.CullMode = CullMode.CullCounterClockwiseFace;
|
|
|
}
|
|
|
rasterizerStateChanged = true;
|
|
|
}
|
|
|
else if (type == MOJOSHADER_renderStateType.MOJOSHADER_RS_ZFUNC)
|
|
|
{
|
|
|
MOJOSHADER_compareFunc* val = (MOJOSHADER_compareFunc*) states[i].value.values;
|
|
|
pipelineCache.DepthBufferFunction = XNACompare[(int) *val];
|
|
|
depthStencilStateChanged = true;
|
|
|
}
|
|
|
else if (type == MOJOSHADER_renderStateType.MOJOSHADER_RS_ALPHABLENDENABLE)
|
|
|
{
|
|
|
// FIXME: Assuming no other blend calls are made in the effect! -flibit
|
|
|
int* val = (int*) states[i].value.values;
|
|
|
if (*val == 0)
|
|
|
{
|
|
|
pipelineCache.ColorSourceBlend = Blend.One;
|
|
|
pipelineCache.ColorDestinationBlend = Blend.Zero;
|
|
|
pipelineCache.AlphaSourceBlend = Blend.One;
|
|
|
pipelineCache.AlphaDestinationBlend = Blend.Zero;
|
|
|
blendStateChanged = true;
|
|
|
}
|
|
|
}
|
|
|
else if (type == MOJOSHADER_renderStateType.MOJOSHADER_RS_STENCILENABLE)
|
|
|
{
|
|
|
int* val = (int*) states[i].value.values;
|
|
|
pipelineCache.StencilEnable = (*val == 1);
|
|
|
depthStencilStateChanged = true;
|
|
|
}
|
|
|
else if (type == MOJOSHADER_renderStateType.MOJOSHADER_RS_STENCILFAIL)
|
|
|
{
|
|
|
MOJOSHADER_stencilOp* val = (MOJOSHADER_stencilOp*) states[i].value.values;
|
|
|
pipelineCache.StencilFail = XNAStencilOp[(int) *val];
|
|
|
depthStencilStateChanged = true;
|
|
|
}
|
|
|
else if (type == MOJOSHADER_renderStateType.MOJOSHADER_RS_STENCILZFAIL)
|
|
|
{
|
|
|
MOJOSHADER_stencilOp* val = (MOJOSHADER_stencilOp*) states[i].value.values;
|
|
|
pipelineCache.StencilDepthBufferFail = XNAStencilOp[(int) *val];
|
|
|
depthStencilStateChanged = true;
|
|
|
}
|
|
|
else if (type == MOJOSHADER_renderStateType.MOJOSHADER_RS_STENCILPASS)
|
|
|
{
|
|
|
MOJOSHADER_stencilOp* val = (MOJOSHADER_stencilOp*) states[i].value.values;
|
|
|
pipelineCache.StencilPass = XNAStencilOp[(int) *val];
|
|
|
depthStencilStateChanged = true;
|
|
|
}
|
|
|
else if (type == MOJOSHADER_renderStateType.MOJOSHADER_RS_STENCILFUNC)
|
|
|
{
|
|
|
MOJOSHADER_compareFunc* val = (MOJOSHADER_compareFunc*) states[i].value.values;
|
|
|
pipelineCache.StencilFunction = XNACompare[(int) *val];
|
|
|
depthStencilStateChanged = true;
|
|
|
}
|
|
|
else if (type == MOJOSHADER_renderStateType.MOJOSHADER_RS_STENCILREF)
|
|
|
{
|
|
|
int* val = (int*) states[i].value.values;
|
|
|
pipelineCache.ReferenceStencil = *val;
|
|
|
depthStencilStateChanged = true;
|
|
|
}
|
|
|
else if (type == MOJOSHADER_renderStateType.MOJOSHADER_RS_STENCILMASK)
|
|
|
{
|
|
|
int* val = (int*) states[i].value.values;
|
|
|
pipelineCache.StencilMask = *val;
|
|
|
depthStencilStateChanged = true;
|
|
|
}
|
|
|
else if (type == MOJOSHADER_renderStateType.MOJOSHADER_RS_STENCILWRITEMASK)
|
|
|
{
|
|
|
int* val = (int*) states[i].value.values;
|
|
|
pipelineCache.StencilWriteMask = *val;
|
|
|
depthStencilStateChanged = true;
|
|
|
}
|
|
|
else if (type == MOJOSHADER_renderStateType.MOJOSHADER_RS_MULTISAMPLEANTIALIAS)
|
|
|
{
|
|
|
int* val = (int*) states[i].value.values;
|
|
|
pipelineCache.MultiSampleAntiAlias = (*val == 1);
|
|
|
rasterizerStateChanged = true;
|
|
|
}
|
|
|
else if (type == MOJOSHADER_renderStateType.MOJOSHADER_RS_MULTISAMPLEMASK)
|
|
|
{
|
|
|
int* val = (int*) states[i].value.values;
|
|
|
pipelineCache.MultiSampleMask = *val;
|
|
|
blendStateChanged = true;
|
|
|
}
|
|
|
else if (type == MOJOSHADER_renderStateType.MOJOSHADER_RS_COLORWRITEENABLE)
|
|
|
{
|
|
|
int* val = (int*) states[i].value.values;
|
|
|
pipelineCache.ColorWriteChannels = (ColorWriteChannels) (*val);
|
|
|
blendStateChanged = true;
|
|
|
}
|
|
|
else if (type == MOJOSHADER_renderStateType.MOJOSHADER_RS_BLENDOP)
|
|
|
{
|
|
|
MOJOSHADER_blendOp* val = (MOJOSHADER_blendOp*) states[i].value.values;
|
|
|
pipelineCache.ColorBlendFunction = XNABlendOp[(int) *val];
|
|
|
blendStateChanged = true;
|
|
|
}
|
|
|
else if (type == MOJOSHADER_renderStateType.MOJOSHADER_RS_SCISSORTESTENABLE)
|
|
|
{
|
|
|
int* val = (int*) states[i].value.values;
|
|
|
pipelineCache.ScissorTestEnable = (*val == 1);
|
|
|
rasterizerStateChanged = true;
|
|
|
}
|
|
|
else if (type == MOJOSHADER_renderStateType.MOJOSHADER_RS_SLOPESCALEDEPTHBIAS)
|
|
|
{
|
|
|
float* val = (float*) states[i].value.values;
|
|
|
pipelineCache.SlopeScaleDepthBias = *val;
|
|
|
rasterizerStateChanged = true;
|
|
|
}
|
|
|
else if (type == MOJOSHADER_renderStateType.MOJOSHADER_RS_TWOSIDEDSTENCILMODE)
|
|
|
{
|
|
|
int* val = (int*) states[i].value.values;
|
|
|
pipelineCache.TwoSidedStencilMode = (*val == 1);
|
|
|
depthStencilStateChanged = true;
|
|
|
}
|
|
|
else if (type == MOJOSHADER_renderStateType.MOJOSHADER_RS_CCW_STENCILFAIL)
|
|
|
{
|
|
|
MOJOSHADER_stencilOp* val = (MOJOSHADER_stencilOp*) states[i].value.values;
|
|
|
pipelineCache.CCWStencilFail = XNAStencilOp[(int) *val];
|
|
|
depthStencilStateChanged = true;
|
|
|
}
|
|
|
else if (type == MOJOSHADER_renderStateType.MOJOSHADER_RS_CCW_STENCILZFAIL)
|
|
|
{
|
|
|
MOJOSHADER_stencilOp* val = (MOJOSHADER_stencilOp*) states[i].value.values;
|
|
|
pipelineCache.CCWStencilDepthBufferFail = XNAStencilOp[(int) *val];
|
|
|
depthStencilStateChanged = true;
|
|
|
}
|
|
|
else if (type == MOJOSHADER_renderStateType.MOJOSHADER_RS_CCW_STENCILPASS)
|
|
|
{
|
|
|
MOJOSHADER_stencilOp* val = (MOJOSHADER_stencilOp*) states[i].value.values;
|
|
|
pipelineCache.CCWStencilPass = XNAStencilOp[(int) *val];
|
|
|
depthStencilStateChanged = true;
|
|
|
}
|
|
|
else if (type == MOJOSHADER_renderStateType.MOJOSHADER_RS_CCW_STENCILFUNC)
|
|
|
{
|
|
|
MOJOSHADER_compareFunc* val = (MOJOSHADER_compareFunc*) states[i].value.values;
|
|
|
pipelineCache.CCWStencilFunction = XNACompare[(int) *val];
|
|
|
depthStencilStateChanged = true;
|
|
|
}
|
|
|
else if (type == MOJOSHADER_renderStateType.MOJOSHADER_RS_COLORWRITEENABLE1)
|
|
|
{
|
|
|
int* val = (int*) states[i].value.values;
|
|
|
pipelineCache.ColorWriteChannels1 = (ColorWriteChannels) (*val);
|
|
|
blendStateChanged = true;
|
|
|
}
|
|
|
else if (type == MOJOSHADER_renderStateType.MOJOSHADER_RS_COLORWRITEENABLE2)
|
|
|
{
|
|
|
int* val = (int*) states[i].value.values;
|
|
|
pipelineCache.ColorWriteChannels2 = (ColorWriteChannels) (*val);
|
|
|
blendStateChanged = true;
|
|
|
}
|
|
|
else if (type == MOJOSHADER_renderStateType.MOJOSHADER_RS_COLORWRITEENABLE3)
|
|
|
{
|
|
|
int* val = (int*) states[i].value.values;
|
|
|
pipelineCache.ColorWriteChannels3 = (ColorWriteChannels) (*val);
|
|
|
blendStateChanged = true;
|
|
|
}
|
|
|
else if (type == MOJOSHADER_renderStateType.MOJOSHADER_RS_BLENDFACTOR)
|
|
|
{
|
|
|
// FIXME: RGBA? -flibit
|
|
|
int* val = (int*) states[i].value.values;
|
|
|
pipelineCache.BlendFactor = new Color(
|
|
|
(*val >> 24) & 0xFF,
|
|
|
(*val >> 16) & 0xFF,
|
|
|
(*val >> 8) & 0xFF,
|
|
|
*val & 0xFF
|
|
|
);
|
|
|
blendStateChanged = true;
|
|
|
}
|
|
|
else if (type == MOJOSHADER_renderStateType.MOJOSHADER_RS_DEPTHBIAS)
|
|
|
{
|
|
|
float* val = (float*) states[i].value.values;
|
|
|
pipelineCache.DepthBias = *val;
|
|
|
rasterizerStateChanged = true;
|
|
|
}
|
|
|
else if (type == MOJOSHADER_renderStateType.MOJOSHADER_RS_SEPARATEALPHABLENDENABLE)
|
|
|
{
|
|
|
int* val = (int*) states[i].value.values;
|
|
|
pipelineCache.SeparateAlphaBlend = (*val == 1);
|
|
|
// FIXME: Do we want to update the state for this...? -flibit
|
|
|
}
|
|
|
else if (type == MOJOSHADER_renderStateType.MOJOSHADER_RS_SRCBLENDALPHA)
|
|
|
{
|
|
|
MOJOSHADER_blendMode* val = (MOJOSHADER_blendMode*) states[i].value.values;
|
|
|
pipelineCache.AlphaSourceBlend = XNABlend[(int) *val];
|
|
|
blendStateChanged = true;
|
|
|
}
|
|
|
else if (type == MOJOSHADER_renderStateType.MOJOSHADER_RS_DESTBLENDALPHA)
|
|
|
{
|
|
|
MOJOSHADER_blendMode* val = (MOJOSHADER_blendMode*) states[i].value.values;
|
|
|
pipelineCache.AlphaDestinationBlend = XNABlend[(int) *val];
|
|
|
blendStateChanged = true;
|
|
|
}
|
|
|
else if (type == MOJOSHADER_renderStateType.MOJOSHADER_RS_BLENDOPALPHA)
|
|
|
{
|
|
|
MOJOSHADER_blendOp* val = (MOJOSHADER_blendOp*) states[i].value.values;
|
|
|
pipelineCache.AlphaBlendFunction = XNABlendOp[(int) *val];
|
|
|
blendStateChanged = true;
|
|
|
}
|
|
|
else if (type == (MOJOSHADER_renderStateType) 178)
|
|
|
{
|
|
|
/* Apparently this is "SetSampler"? */
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
throw new NotImplementedException("Unhandled render state! " + type);
|
|
|
}
|
|
|
}
|
|
|
if (blendStateChanged)
|
|
|
{
|
|
|
pipelineCache.EndApplyBlend();
|
|
|
}
|
|
|
if (depthStencilStateChanged)
|
|
|
{
|
|
|
pipelineCache.EndApplyDepthStencil();
|
|
|
}
|
|
|
if (rasterizerStateChanged)
|
|
|
{
|
|
|
pipelineCache.EndApplyRasterizer();
|
|
|
}
|
|
|
}
|
|
|
if (stateChanges->sampler_state_change_count > 0)
|
|
|
{
|
|
|
INTERNAL_updateSamplers(
|
|
|
stateChanges->sampler_state_change_count,
|
|
|
(MOJOSHADER_samplerStateRegister*) stateChanges->sampler_state_changes,
|
|
|
GraphicsDevice.Textures,
|
|
|
GraphicsDevice.SamplerStates
|
|
|
);
|
|
|
}
|
|
|
if (stateChanges->vertex_sampler_state_change_count > 0)
|
|
|
{
|
|
|
INTERNAL_updateSamplers(
|
|
|
stateChanges->vertex_sampler_state_change_count,
|
|
|
(MOJOSHADER_samplerStateRegister*) stateChanges->vertex_sampler_state_changes,
|
|
|
GraphicsDevice.VertexTextures,
|
|
|
GraphicsDevice.VertexSamplerStates
|
|
|
);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
private unsafe void INTERNAL_updateSamplers(
|
|
|
uint changeCount,
|
|
|
MOJOSHADER_samplerStateRegister* registers,
|
|
|
TextureCollection textures,
|
|
|
SamplerStateCollection samplers
|
|
|
) {
|
|
|
for (int i = 0; i < changeCount; i += 1)
|
|
|
{
|
|
|
if (registers[i].sampler_state_count == 0)
|
|
|
{
|
|
|
// Nothing to do
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
int register = (int) registers[i].sampler_register;
|
|
|
|
|
|
PipelineCache pipelineCache = GraphicsDevice.PipelineCache;
|
|
|
pipelineCache.BeginApplySampler(samplers, register);
|
|
|
|
|
|
// Used to prevent redundant sampler changes
|
|
|
bool samplerChanged = false;
|
|
|
bool filterChanged = false;
|
|
|
|
|
|
// Current sampler filter
|
|
|
TextureFilter filter = pipelineCache.Filter;
|
|
|
MOJOSHADER_textureFilterType magFilter = XNAMag[(int) filter];
|
|
|
MOJOSHADER_textureFilterType minFilter = XNAMin[(int) filter];
|
|
|
MOJOSHADER_textureFilterType mipFilter = XNAMip[(int) filter];
|
|
|
|
|
|
MOJOSHADER_effectSamplerState* states = (MOJOSHADER_effectSamplerState*) registers[i].sampler_states;
|
|
|
for (int j = 0; j < registers[i].sampler_state_count; j += 1)
|
|
|
{
|
|
|
MOJOSHADER_samplerStateType type = states[j].type;
|
|
|
if (type == MOJOSHADER_samplerStateType.MOJOSHADER_SAMP_TEXTURE)
|
|
|
{
|
|
|
EffectParameter texParam;
|
|
|
if (samplerMap.TryGetValue(registers[i].sampler_name, out texParam))
|
|
|
{
|
|
|
Texture texture = texParam.texture;
|
|
|
if (texture != null)
|
|
|
{
|
|
|
textures[register] = texture;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
else if (type == MOJOSHADER_samplerStateType.MOJOSHADER_SAMP_ADDRESSU)
|
|
|
{
|
|
|
MOJOSHADER_textureAddress* val = (MOJOSHADER_textureAddress*) states[j].value.values;
|
|
|
pipelineCache.AddressU = XNAAddress[(int) *val];
|
|
|
samplerChanged = true;
|
|
|
}
|
|
|
else if (type == MOJOSHADER_samplerStateType.MOJOSHADER_SAMP_ADDRESSV)
|
|
|
{
|
|
|
MOJOSHADER_textureAddress* val = (MOJOSHADER_textureAddress*) states[j].value.values;
|
|
|
pipelineCache.AddressV = XNAAddress[(int) *val];
|
|
|
samplerChanged = true;
|
|
|
}
|
|
|
else if (type == MOJOSHADER_samplerStateType.MOJOSHADER_SAMP_ADDRESSW)
|
|
|
{
|
|
|
MOJOSHADER_textureAddress* val = (MOJOSHADER_textureAddress*) states[j].value.values;
|
|
|
pipelineCache.AddressW = XNAAddress[(int) *val];
|
|
|
samplerChanged = true;
|
|
|
}
|
|
|
else if (type == MOJOSHADER_samplerStateType.MOJOSHADER_SAMP_MAGFILTER)
|
|
|
{
|
|
|
MOJOSHADER_textureFilterType* val = (MOJOSHADER_textureFilterType*) states[j].value.values;
|
|
|
magFilter = *val;
|
|
|
filterChanged = true;
|
|
|
}
|
|
|
else if (type == MOJOSHADER_samplerStateType.MOJOSHADER_SAMP_MINFILTER)
|
|
|
{
|
|
|
MOJOSHADER_textureFilterType* val = (MOJOSHADER_textureFilterType*) states[j].value.values;
|
|
|
minFilter = *val;
|
|
|
filterChanged = true;
|
|
|
}
|
|
|
else if (type == MOJOSHADER_samplerStateType.MOJOSHADER_SAMP_MIPFILTER)
|
|
|
{
|
|
|
MOJOSHADER_textureFilterType* val = (MOJOSHADER_textureFilterType*) states[j].value.values;
|
|
|
mipFilter = *val;
|
|
|
filterChanged = true;
|
|
|
}
|
|
|
else if (type == MOJOSHADER_samplerStateType.MOJOSHADER_SAMP_MIPMAPLODBIAS)
|
|
|
{
|
|
|
float* val = (float*) states[j].value.values;
|
|
|
pipelineCache.MipMapLODBias = *val;
|
|
|
samplerChanged = true;
|
|
|
}
|
|
|
else if (type == MOJOSHADER_samplerStateType.MOJOSHADER_SAMP_MAXMIPLEVEL)
|
|
|
{
|
|
|
int* val = (int*) states[j].value.values;
|
|
|
pipelineCache.MaxMipLevel = *val;
|
|
|
samplerChanged = true;
|
|
|
}
|
|
|
else if (type == MOJOSHADER_samplerStateType.MOJOSHADER_SAMP_MAXANISOTROPY)
|
|
|
{
|
|
|
int* val = (int*) states[j].value.values;
|
|
|
pipelineCache.MaxAnisotropy = *val;
|
|
|
samplerChanged = true;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
throw new NotImplementedException("Unhandled sampler state! " + type);
|
|
|
}
|
|
|
}
|
|
|
if (filterChanged)
|
|
|
{
|
|
|
if (magFilter == MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_POINT)
|
|
|
{
|
|
|
if (minFilter == MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_POINT)
|
|
|
{
|
|
|
if ( mipFilter == MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_NONE ||
|
|
|
mipFilter == MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_POINT )
|
|
|
{
|
|
|
pipelineCache.Filter = TextureFilter.Point;
|
|
|
}
|
|
|
else if ( mipFilter == MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_LINEAR ||
|
|
|
mipFilter == MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_ANISOTROPIC )
|
|
|
{
|
|
|
pipelineCache.Filter = TextureFilter.PointMipLinear;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
throw new NotImplementedException("Unhandled mipfilter type! " + mipFilter);
|
|
|
}
|
|
|
}
|
|
|
else if ( minFilter == MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_LINEAR ||
|
|
|
minFilter == MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_ANISOTROPIC )
|
|
|
{
|
|
|
if ( mipFilter == MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_NONE ||
|
|
|
mipFilter == MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_POINT )
|
|
|
{
|
|
|
pipelineCache.Filter = TextureFilter.MinLinearMagPointMipPoint;
|
|
|
}
|
|
|
else if ( mipFilter == MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_LINEAR ||
|
|
|
mipFilter == MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_ANISOTROPIC )
|
|
|
{
|
|
|
pipelineCache.Filter = TextureFilter.MinLinearMagPointMipLinear;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
throw new NotImplementedException("Unhandled mipfilter type! " + mipFilter);
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
throw new NotImplementedException("Unhandled minfilter type! " + minFilter);
|
|
|
}
|
|
|
}
|
|
|
else if ( magFilter == MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_LINEAR ||
|
|
|
magFilter == MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_ANISOTROPIC )
|
|
|
{
|
|
|
if (minFilter == MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_POINT)
|
|
|
{
|
|
|
if ( mipFilter == MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_NONE ||
|
|
|
mipFilter == MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_POINT )
|
|
|
{
|
|
|
pipelineCache.Filter = TextureFilter.MinPointMagLinearMipPoint;
|
|
|
}
|
|
|
else if ( mipFilter == MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_LINEAR ||
|
|
|
mipFilter == MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_ANISOTROPIC )
|
|
|
{
|
|
|
pipelineCache.Filter = TextureFilter.MinPointMagLinearMipLinear;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
throw new NotImplementedException("Unhandled mipfilter type! " + mipFilter);
|
|
|
}
|
|
|
}
|
|
|
else if ( minFilter == MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_LINEAR ||
|
|
|
minFilter == MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_ANISOTROPIC )
|
|
|
{
|
|
|
if ( mipFilter == MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_NONE ||
|
|
|
mipFilter == MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_POINT )
|
|
|
{
|
|
|
pipelineCache.Filter = TextureFilter.LinearMipPoint;
|
|
|
}
|
|
|
else if ( mipFilter == MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_LINEAR ||
|
|
|
mipFilter == MOJOSHADER_textureFilterType.MOJOSHADER_TEXTUREFILTER_ANISOTROPIC )
|
|
|
{
|
|
|
pipelineCache.Filter = TextureFilter.Linear;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
throw new NotImplementedException("Unhandled mipfilter type! " + mipFilter);
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
throw new NotImplementedException("Unhandled minfilter type! " + minFilter);
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
throw new NotImplementedException("Unhandled magfilter type! " + magFilter);
|
|
|
}
|
|
|
samplerChanged = true;
|
|
|
}
|
|
|
|
|
|
if (samplerChanged)
|
|
|
{
|
|
|
pipelineCache.EndApplySampler(samplers, register);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
#region Private Methods
|
|
|
|
|
|
private unsafe void INTERNAL_parseEffectStruct(IntPtr effectData)
|
|
|
{
|
|
|
MOJOSHADER_effect* effectPtr = (MOJOSHADER_effect*) effectData;
|
|
|
|
|
|
// Set up Parameters
|
|
|
MOJOSHADER_effectParam* paramPtr = (MOJOSHADER_effectParam*) effectPtr->parameters;
|
|
|
List<EffectParameter> parameters = new List<EffectParameter>();
|
|
|
for (int i = 0; i < effectPtr->param_count; i += 1)
|
|
|
{
|
|
|
MOJOSHADER_effectParam param = paramPtr[i];
|
|
|
if ( param.value.type.parameter_type == MOJOSHADER_symbolType.MOJOSHADER_SYMTYPE_VERTEXSHADER ||
|
|
|
param.value.type.parameter_type == MOJOSHADER_symbolType.MOJOSHADER_SYMTYPE_PIXELSHADER )
|
|
|
{
|
|
|
// Skip shader objects...
|
|
|
continue;
|
|
|
}
|
|
|
else if ( param.value.type.parameter_type >= MOJOSHADER_symbolType.MOJOSHADER_SYMTYPE_SAMPLER &&
|
|
|
param.value.type.parameter_type <= MOJOSHADER_symbolType.MOJOSHADER_SYMTYPE_SAMPLERCUBE )
|
|
|
{
|
|
|
string textureName = String.Empty;
|
|
|
MOJOSHADER_effectSamplerState* states = (MOJOSHADER_effectSamplerState*) param.value.values;
|
|
|
for (int j = 0; j < param.value.value_count; j += 1)
|
|
|
{
|
|
|
if ( states[j].value.type.parameter_type >= MOJOSHADER_symbolType.MOJOSHADER_SYMTYPE_TEXTURE &&
|
|
|
states[j].value.type.parameter_type <= MOJOSHADER_symbolType.MOJOSHADER_SYMTYPE_TEXTURECUBE )
|
|
|
{
|
|
|
MOJOSHADER_effectObject *objectPtr = (MOJOSHADER_effectObject*) effectPtr->objects;
|
|
|
int* index = (int*) states[j].value.values;
|
|
|
textureName = Marshal.PtrToStringAnsi(objectPtr[*index].mapping.name);
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
/* Because textures have to be declared before the sampler,
|
|
|
* we can assume that it will always be in the list by the
|
|
|
* time we get to this point.
|
|
|
* -flibit
|
|
|
*/
|
|
|
for (int j = 0; j < parameters.Count; j += 1)
|
|
|
{
|
|
|
if (textureName.Equals(parameters[j].Name))
|
|
|
{
|
|
|
samplerMap[param.value.name] = parameters[j];
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
EffectParameterCollection structMembers = null;
|
|
|
if (param.value.type.member_count > 0)
|
|
|
{
|
|
|
List<EffectParameter> memList = new List<EffectParameter>();
|
|
|
unsafe
|
|
|
{
|
|
|
MOJOSHADER_symbolStructMember* mem = (MOJOSHADER_symbolStructMember*) param.value.type.members;
|
|
|
IntPtr curOffset = IntPtr.Zero;
|
|
|
for (int j = 0; j < param.value.type.member_count; j += 1)
|
|
|
{
|
|
|
uint memSize = mem[j].info.rows * mem[j].info.columns;
|
|
|
if (mem[j].info.elements > 0)
|
|
|
{
|
|
|
memSize *= mem[j].info.elements;
|
|
|
}
|
|
|
memList.Add(new EffectParameter(
|
|
|
Marshal.PtrToStringAnsi(mem[j].name),
|
|
|
null,
|
|
|
(int) mem[j].info.rows,
|
|
|
(int) mem[j].info.columns,
|
|
|
(int) mem[j].info.elements,
|
|
|
XNAClass[(int) mem[j].info.parameter_class],
|
|
|
XNAType[(int) mem[j].info.parameter_type],
|
|
|
null, // FIXME: Nested structs! -flibit
|
|
|
null,
|
|
|
param.value.values + curOffset.ToInt32(),
|
|
|
memSize * 4
|
|
|
));
|
|
|
curOffset += (int) memSize * 4;
|
|
|
}
|
|
|
}
|
|
|
structMembers = new EffectParameterCollection(memList);
|
|
|
}
|
|
|
|
|
|
parameters.Add(new EffectParameter(
|
|
|
Marshal.PtrToStringAnsi(param.value.name),
|
|
|
Marshal.PtrToStringAnsi(param.value.semantic),
|
|
|
(int) param.value.type.rows,
|
|
|
(int) param.value.type.columns,
|
|
|
(int) param.value.type.elements,
|
|
|
XNAClass[(int) param.value.type.parameter_class],
|
|
|
XNAType[(int) param.value.type.parameter_type],
|
|
|
structMembers,
|
|
|
INTERNAL_readAnnotations(
|
|
|
param.annotations,
|
|
|
param.annotation_count
|
|
|
),
|
|
|
param.value.values,
|
|
|
param.value.value_count * sizeof(float)
|
|
|
));
|
|
|
}
|
|
|
Parameters = new EffectParameterCollection(parameters);
|
|
|
|
|
|
// Set up Techniques
|
|
|
MOJOSHADER_effectTechnique* techPtr = (MOJOSHADER_effectTechnique*) effectPtr->techniques;
|
|
|
List<EffectTechnique> techniques = new List<EffectTechnique>(effectPtr->technique_count);
|
|
|
for (int i = 0; i < techniques.Capacity; i += 1, techPtr += 1)
|
|
|
{
|
|
|
// Set up Passes
|
|
|
MOJOSHADER_effectPass* passPtr = (MOJOSHADER_effectPass*) techPtr->passes;
|
|
|
List<EffectPass> passes = new List<EffectPass>((int) techPtr->pass_count);
|
|
|
for (int j = 0; j < passes.Capacity; j += 1)
|
|
|
{
|
|
|
MOJOSHADER_effectPass pass = passPtr[j];
|
|
|
passes.Add(new EffectPass(
|
|
|
Marshal.PtrToStringAnsi(pass.name),
|
|
|
INTERNAL_readAnnotations(
|
|
|
pass.annotations,
|
|
|
pass.annotation_count
|
|
|
),
|
|
|
this,
|
|
|
(IntPtr) techPtr,
|
|
|
(uint) j
|
|
|
));
|
|
|
}
|
|
|
|
|
|
techniques.Add(new EffectTechnique(
|
|
|
Marshal.PtrToStringAnsi(techPtr->name),
|
|
|
(IntPtr) techPtr,
|
|
|
new EffectPassCollection(passes),
|
|
|
INTERNAL_readAnnotations(
|
|
|
techPtr->annotations,
|
|
|
techPtr->annotation_count
|
|
|
)
|
|
|
));
|
|
|
}
|
|
|
Techniques = new EffectTechniqueCollection(techniques);
|
|
|
}
|
|
|
|
|
|
private unsafe EffectAnnotationCollection INTERNAL_readAnnotations(
|
|
|
IntPtr rawAnnotations,
|
|
|
uint numAnnotations
|
|
|
) {
|
|
|
MOJOSHADER_effectAnnotation* annoPtr = (MOJOSHADER_effectAnnotation*) rawAnnotations;
|
|
|
List<EffectAnnotation> annotations = new List<EffectAnnotation>((int) numAnnotations);
|
|
|
for (int i = 0; i < numAnnotations; i += 1)
|
|
|
{
|
|
|
MOJOSHADER_effectAnnotation anno = annoPtr[i];
|
|
|
annotations.Add(new EffectAnnotation(
|
|
|
Marshal.PtrToStringAnsi(anno.name),
|
|
|
Marshal.PtrToStringAnsi(anno.semantic),
|
|
|
(int) anno.type.rows,
|
|
|
(int) anno.type.columns,
|
|
|
XNAClass[(int) anno.type.parameter_class],
|
|
|
XNAType[(int) anno.type.parameter_type],
|
|
|
anno.values
|
|
|
));
|
|
|
}
|
|
|
return new EffectAnnotationCollection(annotations);
|
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
#region MojoShader Interop
|
|
|
|
|
|
/* Shader Parse Interface */
|
|
|
|
|
|
private enum MOJOSHADER_symbolClass
|
|
|
{
|
|
|
MOJOSHADER_SYMCLASS_SCALAR = 0,
|
|
|
MOJOSHADER_SYMCLASS_VECTOR,
|
|
|
MOJOSHADER_SYMCLASS_MATRIX_ROWS,
|
|
|
MOJOSHADER_SYMCLASS_MATRIX_COLUMNS,
|
|
|
MOJOSHADER_SYMCLASS_OBJECT,
|
|
|
MOJOSHADER_SYMCLASS_STRUCT,
|
|
|
MOJOSHADER_SYMCLASS_TOTAL
|
|
|
}
|
|
|
|
|
|
private enum MOJOSHADER_symbolType
|
|
|
{
|
|
|
MOJOSHADER_SYMTYPE_VOID = 0,
|
|
|
MOJOSHADER_SYMTYPE_BOOL,
|
|
|
MOJOSHADER_SYMTYPE_INT,
|
|
|
MOJOSHADER_SYMTYPE_FLOAT,
|
|
|
MOJOSHADER_SYMTYPE_STRING,
|
|
|
MOJOSHADER_SYMTYPE_TEXTURE,
|
|
|
MOJOSHADER_SYMTYPE_TEXTURE1D,
|
|
|
MOJOSHADER_SYMTYPE_TEXTURE2D,
|
|
|
MOJOSHADER_SYMTYPE_TEXTURE3D,
|
|
|
MOJOSHADER_SYMTYPE_TEXTURECUBE,
|
|
|
MOJOSHADER_SYMTYPE_SAMPLER,
|
|
|
MOJOSHADER_SYMTYPE_SAMPLER1D,
|
|
|
MOJOSHADER_SYMTYPE_SAMPLER2D,
|
|
|
MOJOSHADER_SYMTYPE_SAMPLER3D,
|
|
|
MOJOSHADER_SYMTYPE_SAMPLERCUBE,
|
|
|
MOJOSHADER_SYMTYPE_PIXELSHADER,
|
|
|
MOJOSHADER_SYMTYPE_VERTEXSHADER,
|
|
|
MOJOSHADER_SYMTYPE_PIXELFRAGMENT,
|
|
|
MOJOSHADER_SYMTYPE_VERTEXFRAGMENT,
|
|
|
MOJOSHADER_SYMTYPE_UNSUPPORTED,
|
|
|
MOJOSHADER_SYMTYPE_TOTAL
|
|
|
}
|
|
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
|
private struct MOJOSHADER_symbolTypeInfo
|
|
|
{
|
|
|
public MOJOSHADER_symbolClass parameter_class;
|
|
|
public MOJOSHADER_symbolType parameter_type;
|
|
|
public uint rows;
|
|
|
public uint columns;
|
|
|
public uint elements;
|
|
|
public uint member_count;
|
|
|
public IntPtr members; // MOJOSHADER_symbolStructMember*
|
|
|
}
|
|
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
|
private struct MOJOSHADER_symbolStructMember
|
|
|
{
|
|
|
public IntPtr name; //const char*
|
|
|
public MOJOSHADER_symbolTypeInfo info;
|
|
|
}
|
|
|
|
|
|
/* MOJOSHADER_effectState types... */
|
|
|
|
|
|
private enum MOJOSHADER_renderStateType
|
|
|
{
|
|
|
MOJOSHADER_RS_ZENABLE,
|
|
|
MOJOSHADER_RS_FILLMODE,
|
|
|
MOJOSHADER_RS_SHADEMODE,
|
|
|
MOJOSHADER_RS_ZWRITEENABLE,
|
|
|
MOJOSHADER_RS_ALPHATESTENABLE,
|
|
|
MOJOSHADER_RS_LASTPIXEL,
|
|
|
MOJOSHADER_RS_SRCBLEND,
|
|
|
MOJOSHADER_RS_DESTBLEND,
|
|
|
MOJOSHADER_RS_CULLMODE,
|
|
|
MOJOSHADER_RS_ZFUNC,
|
|
|
MOJOSHADER_RS_ALPHAREF,
|
|
|
MOJOSHADER_RS_ALPHAFUNC,
|
|
|
MOJOSHADER_RS_DITHERENABLE,
|
|
|
MOJOSHADER_RS_ALPHABLENDENABLE,
|
|
|
MOJOSHADER_RS_FOGENABLE,
|
|
|
MOJOSHADER_RS_SPECULARENABLE,
|
|
|
MOJOSHADER_RS_FOGCOLOR,
|
|
|
MOJOSHADER_RS_FOGTABLEMODE,
|
|
|
MOJOSHADER_RS_FOGSTART,
|
|
|
MOJOSHADER_RS_FOGEND,
|
|
|
MOJOSHADER_RS_FOGDENSITY,
|
|
|
MOJOSHADER_RS_RANGEFOGENABLE,
|
|
|
MOJOSHADER_RS_STENCILENABLE,
|
|
|
MOJOSHADER_RS_STENCILFAIL,
|
|
|
MOJOSHADER_RS_STENCILZFAIL,
|
|
|
MOJOSHADER_RS_STENCILPASS,
|
|
|
MOJOSHADER_RS_STENCILFUNC,
|
|
|
MOJOSHADER_RS_STENCILREF,
|
|
|
MOJOSHADER_RS_STENCILMASK,
|
|
|
MOJOSHADER_RS_STENCILWRITEMASK,
|
|
|
MOJOSHADER_RS_TEXTUREFACTOR,
|
|
|
MOJOSHADER_RS_WRAP0,
|
|
|
MOJOSHADER_RS_WRAP1,
|
|
|
MOJOSHADER_RS_WRAP2,
|
|
|
MOJOSHADER_RS_WRAP3,
|
|
|
MOJOSHADER_RS_WRAP4,
|
|
|
MOJOSHADER_RS_WRAP5,
|
|
|
MOJOSHADER_RS_WRAP6,
|
|
|
MOJOSHADER_RS_WRAP7,
|
|
|
MOJOSHADER_RS_WRAP8,
|
|
|
MOJOSHADER_RS_WRAP9,
|
|
|
MOJOSHADER_RS_WRAP10,
|
|
|
MOJOSHADER_RS_WRAP11,
|
|
|
MOJOSHADER_RS_WRAP12,
|
|
|
MOJOSHADER_RS_WRAP13,
|
|
|
MOJOSHADER_RS_WRAP14,
|
|
|
MOJOSHADER_RS_WRAP15,
|
|
|
MOJOSHADER_RS_CLIPPING,
|
|
|
MOJOSHADER_RS_LIGHTING,
|
|
|
MOJOSHADER_RS_AMBIENT,
|
|
|
MOJOSHADER_RS_FOGVERTEXMODE,
|
|
|
MOJOSHADER_RS_COLORVERTEX,
|
|
|
MOJOSHADER_RS_LOCALVIEWER,
|
|
|
MOJOSHADER_RS_NORMALIZENORMALS,
|
|
|
MOJOSHADER_RS_DIFFUSEMATERIALSOURCE,
|
|
|
MOJOSHADER_RS_SPECULARMATERIALSOURCE,
|
|
|
MOJOSHADER_RS_AMBIENTMATERIALSOURCE,
|
|
|
MOJOSHADER_RS_EMISSIVEMATERIALSOURCE,
|
|
|
MOJOSHADER_RS_VERTEXBLEND,
|
|
|
MOJOSHADER_RS_CLIPPLANEENABLE,
|
|
|
MOJOSHADER_RS_POINTSIZE,
|
|
|
MOJOSHADER_RS_POINTSIZE_MIN,
|
|
|
MOJOSHADER_RS_POINTSPRITEENABLE,
|
|
|
MOJOSHADER_RS_POINTSCALEENABLE,
|
|
|
MOJOSHADER_RS_POINTSCALE_A,
|
|
|
MOJOSHADER_RS_POINTSCALE_B,
|
|
|
MOJOSHADER_RS_POINTSCALE_C,
|
|
|
MOJOSHADER_RS_MULTISAMPLEANTIALIAS,
|
|
|
MOJOSHADER_RS_MULTISAMPLEMASK,
|
|
|
MOJOSHADER_RS_PATCHEDGESTYLE,
|
|
|
MOJOSHADER_RS_DEBUGMONITORTOKEN,
|
|
|
MOJOSHADER_RS_POINTSIZE_MAX,
|
|
|
MOJOSHADER_RS_INDEXEDVERTEXBLENDENABLE,
|
|
|
MOJOSHADER_RS_COLORWRITEENABLE,
|
|
|
MOJOSHADER_RS_TWEENFACTOR,
|
|
|
MOJOSHADER_RS_BLENDOP,
|
|
|
MOJOSHADER_RS_POSITIONDEGREE,
|
|
|
MOJOSHADER_RS_NORMALDEGREE,
|
|
|
MOJOSHADER_RS_SCISSORTESTENABLE,
|
|
|
MOJOSHADER_RS_SLOPESCALEDEPTHBIAS,
|
|
|
MOJOSHADER_RS_ANTIALIASEDLINEENABLE,
|
|
|
MOJOSHADER_RS_MINTESSELLATIONLEVEL,
|
|
|
MOJOSHADER_RS_MAXTESSELLATIONLEVEL,
|
|
|
MOJOSHADER_RS_ADAPTIVETESS_X,
|
|
|
MOJOSHADER_RS_ADAPTIVETESS_Y,
|
|
|
MOJOSHADER_RS_ADAPTIVETESS_Z,
|
|
|
MOJOSHADER_RS_ADAPTIVETESS_W,
|
|
|
MOJOSHADER_RS_ENABLEADAPTIVETESSELLATION,
|
|
|
MOJOSHADER_RS_TWOSIDEDSTENCILMODE,
|
|
|
MOJOSHADER_RS_CCW_STENCILFAIL,
|
|
|
MOJOSHADER_RS_CCW_STENCILZFAIL,
|
|
|
MOJOSHADER_RS_CCW_STENCILPASS,
|
|
|
MOJOSHADER_RS_CCW_STENCILFUNC,
|
|
|
MOJOSHADER_RS_COLORWRITEENABLE1,
|
|
|
MOJOSHADER_RS_COLORWRITEENABLE2,
|
|
|
MOJOSHADER_RS_COLORWRITEENABLE3,
|
|
|
MOJOSHADER_RS_BLENDFACTOR,
|
|
|
MOJOSHADER_RS_SRGBWRITEENABLE,
|
|
|
MOJOSHADER_RS_DEPTHBIAS,
|
|
|
MOJOSHADER_RS_SEPARATEALPHABLENDENABLE,
|
|
|
MOJOSHADER_RS_SRCBLENDALPHA,
|
|
|
MOJOSHADER_RS_DESTBLENDALPHA,
|
|
|
MOJOSHADER_RS_BLENDOPALPHA,
|
|
|
MOJOSHADER_RS_VERTEXSHADER = 146,
|
|
|
MOJOSHADER_RS_PIXELSHADER = 147
|
|
|
}
|
|
|
|
|
|
private enum MOJOSHADER_zBufferType
|
|
|
{
|
|
|
MOJOSHADER_ZB_FALSE,
|
|
|
MOJOSHADER_ZB_TRUE,
|
|
|
MOJOSHADER_ZB_USEW
|
|
|
}
|
|
|
|
|
|
private enum MOJOSHADER_fillMode
|
|
|
{
|
|
|
MOJOSHADER_FILL_POINT = 1,
|
|
|
MOJOSHADER_FILL_WIREFRAME = 2,
|
|
|
MOJOSHADER_FILL_SOLID = 3
|
|
|
}
|
|
|
|
|
|
private enum MOJOSHADER_blendMode
|
|
|
{
|
|
|
MOJOSHADER_BLEND_ZERO = 1,
|
|
|
MOJOSHADER_BLEND_ONE = 2,
|
|
|
MOJOSHADER_BLEND_SRCCOLOR = 3,
|
|
|
MOJOSHADER_BLEND_INVSRCCOLOR = 4,
|
|
|
MOJOSHADER_BLEND_SRCALPHA = 5,
|
|
|
MOJOSHADER_BLEND_INVSRCALPHA = 6,
|
|
|
MOJOSHADER_BLEND_DESTALPHA = 7,
|
|
|
MOJOSHADER_BLEND_INVDESTALPHA = 8,
|
|
|
MOJOSHADER_BLEND_DESTCOLOR = 9,
|
|
|
MOJOSHADER_BLEND_INVDESTCOLOR = 10,
|
|
|
MOJOSHADER_BLEND_SRCALPHASAT = 11,
|
|
|
MOJOSHADER_BLEND_BOTHSRCALPHA = 12,
|
|
|
MOJOSHADER_BLEND_BOTHINVSRCALPHA = 13,
|
|
|
MOJOSHADER_BLEND_BLENDFACTOR = 14,
|
|
|
MOJOSHADER_BLEND_INVBLENDFACTOR = 15,
|
|
|
MOJOSHADER_BLEND_SRCCOLOR2 = 16,
|
|
|
MOJOSHADER_BLEND_INVSRCCOLOR2 = 17
|
|
|
}
|
|
|
|
|
|
private enum MOJOSHADER_cullMode
|
|
|
{
|
|
|
MOJOSHADER_CULL_NONE = 1,
|
|
|
MOJOSHADER_CULL_CW = 2,
|
|
|
MOJOSHADER_CULL_CCW = 3
|
|
|
}
|
|
|
|
|
|
private enum MOJOSHADER_compareFunc
|
|
|
{
|
|
|
MOJOSHADER_CMP_NEVER = 1,
|
|
|
MOJOSHADER_CMP_LESS = 2,
|
|
|
MOJOSHADER_CMP_EQUAL = 3,
|
|
|
MOJOSHADER_CMP_LESSEQUAL = 4,
|
|
|
MOJOSHADER_CMP_GREATER = 5,
|
|
|
MOJOSHADER_CMP_NOTEQUAL = 6,
|
|
|
MOJOSHADER_CMP_GREATEREQUAL = 7,
|
|
|
MOJOSHADER_CMP_ALWAYS = 8
|
|
|
}
|
|
|
|
|
|
private enum MOJOSHADER_stencilOp
|
|
|
{
|
|
|
MOJOSHADER_STENCILOP_KEEP = 1,
|
|
|
MOJOSHADER_STENCILOP_ZERO = 2,
|
|
|
MOJOSHADER_STENCILOP_REPLACE = 3,
|
|
|
MOJOSHADER_STENCILOP_INCRSAT = 4,
|
|
|
MOJOSHADER_STENCILOP_DECRSAT = 5,
|
|
|
MOJOSHADER_STENCILOP_INVERT = 6,
|
|
|
MOJOSHADER_STENCILOP_INCR = 7,
|
|
|
MOJOSHADER_STENCILOP_DECR = 8
|
|
|
}
|
|
|
|
|
|
private enum MOJOSHADER_blendOp
|
|
|
{
|
|
|
MOJOSHADER_BLENDOP_ADD = 1,
|
|
|
MOJOSHADER_BLENDOP_SUBTRACT = 2,
|
|
|
MOJOSHADER_BLENDOP_REVSUBTRACT = 3,
|
|
|
MOJOSHADER_BLENDOP_MIN = 4,
|
|
|
MOJOSHADER_BLENDOP_MAX = 5
|
|
|
}
|
|
|
|
|
|
/* MOJOSHADER_effectSamplerState types... */
|
|
|
|
|
|
private enum MOJOSHADER_samplerStateType
|
|
|
{
|
|
|
MOJOSHADER_SAMP_UNKNOWN0 = 0,
|
|
|
MOJOSHADER_SAMP_UNKNOWN1 = 1,
|
|
|
MOJOSHADER_SAMP_UNKNOWN2 = 2,
|
|
|
MOJOSHADER_SAMP_UNKNOWN3 = 3,
|
|
|
MOJOSHADER_SAMP_TEXTURE = 4,
|
|
|
MOJOSHADER_SAMP_ADDRESSU = 5,
|
|
|
MOJOSHADER_SAMP_ADDRESSV = 6,
|
|
|
MOJOSHADER_SAMP_ADDRESSW = 7,
|
|
|
MOJOSHADER_SAMP_BORDERCOLOR = 8,
|
|
|
MOJOSHADER_SAMP_MAGFILTER = 9,
|
|
|
MOJOSHADER_SAMP_MINFILTER = 10,
|
|
|
MOJOSHADER_SAMP_MIPFILTER = 11,
|
|
|
MOJOSHADER_SAMP_MIPMAPLODBIAS = 12,
|
|
|
MOJOSHADER_SAMP_MAXMIPLEVEL = 13,
|
|
|
MOJOSHADER_SAMP_MAXANISOTROPY = 14,
|
|
|
MOJOSHADER_SAMP_SRGBTEXTURE = 15,
|
|
|
MOJOSHADER_SAMP_ELEMENTINDEX = 16,
|
|
|
MOJOSHADER_SAMP_DMAPOFFSET = 17
|
|
|
}
|
|
|
|
|
|
private enum MOJOSHADER_textureAddress
|
|
|
{
|
|
|
MOJOSHADER_TADDRESS_WRAP = 1,
|
|
|
MOJOSHADER_TADDRESS_MIRROR = 2,
|
|
|
MOJOSHADER_TADDRESS_CLAMP = 3,
|
|
|
MOJOSHADER_TADDRESS_BORDER = 4,
|
|
|
MOJOSHADER_TADDRESS_MIRRORONCE = 5
|
|
|
}
|
|
|
|
|
|
private enum MOJOSHADER_textureFilterType
|
|
|
{
|
|
|
MOJOSHADER_TEXTUREFILTER_NONE,
|
|
|
MOJOSHADER_TEXTUREFILTER_POINT,
|
|
|
MOJOSHADER_TEXTUREFILTER_LINEAR,
|
|
|
MOJOSHADER_TEXTUREFILTER_ANISOTROPIC,
|
|
|
MOJOSHADER_TEXTUREFILTER_PYRAMIDALQUAD,
|
|
|
MOJOSHADER_TEXTUREFILTER_GAUSSIANQUAD,
|
|
|
MOJOSHADER_TEXTUREFILTER_CONVOLUTIONMONO
|
|
|
}
|
|
|
|
|
|
/* Effect value types... */
|
|
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
|
private struct MOJOSHADER_effectValue
|
|
|
{
|
|
|
public IntPtr name; // const char*
|
|
|
public IntPtr semantic; // const char*
|
|
|
public MOJOSHADER_symbolTypeInfo type;
|
|
|
public uint value_count;
|
|
|
public IntPtr values; // You know what, just look at the C header...
|
|
|
}
|
|
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
|
private struct MOJOSHADER_effectState
|
|
|
{
|
|
|
public MOJOSHADER_renderStateType type;
|
|
|
public MOJOSHADER_effectValue value;
|
|
|
}
|
|
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
|
private struct MOJOSHADER_effectSamplerState
|
|
|
{
|
|
|
public MOJOSHADER_samplerStateType type;
|
|
|
public MOJOSHADER_effectValue value;
|
|
|
}
|
|
|
|
|
|
/* typedef MOJOSHADER_effectValue MOJOSHADER_effectAnnotation; */
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
|
private struct MOJOSHADER_effectAnnotation
|
|
|
{
|
|
|
public IntPtr name; // const char*
|
|
|
public IntPtr semantic; // const char*
|
|
|
public MOJOSHADER_symbolTypeInfo type;
|
|
|
public uint value_count;
|
|
|
public IntPtr values; // You know what, just look at the C header...
|
|
|
}
|
|
|
|
|
|
/* Effect interface structures... */
|
|
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
|
private struct MOJOSHADER_effectParam
|
|
|
{
|
|
|
public MOJOSHADER_effectValue value;
|
|
|
public uint annotation_count;
|
|
|
public IntPtr annotations; // MOJOSHADER_effectAnnotations*
|
|
|
}
|
|
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
|
private struct MOJOSHADER_effectPass
|
|
|
{
|
|
|
public IntPtr name; // const char*
|
|
|
public uint state_count;
|
|
|
public IntPtr states; // MOJOSHADER_effectState*
|
|
|
public uint annotation_count;
|
|
|
public IntPtr annotations; // MOJOSHADER_effectAnnotations*
|
|
|
}
|
|
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
|
private struct MOJOSHADER_effectTechnique
|
|
|
{
|
|
|
public IntPtr name; // const char*
|
|
|
public uint pass_count;
|
|
|
public IntPtr passes; // MOJOSHADER_effectPass*
|
|
|
public uint annotation_count;
|
|
|
public IntPtr annotations; // MOJOSHADER_effectAnnotations*
|
|
|
}
|
|
|
|
|
|
/* Effect "objects"... */
|
|
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
|
private struct MOJOSHADER_effectShader
|
|
|
{
|
|
|
public MOJOSHADER_symbolType type;
|
|
|
public uint technique;
|
|
|
public uint pass;
|
|
|
public uint is_preshader;
|
|
|
public uint preshader_param_count;
|
|
|
public IntPtr preshader_params; // unsigned int*
|
|
|
public uint param_count;
|
|
|
public IntPtr parameters; // unsigned int*
|
|
|
public uint sampler_count;
|
|
|
public IntPtr samplers; // MOJOSHADER_samplerStateRegister*
|
|
|
public IntPtr shader; // *shader/*preshader union
|
|
|
}
|
|
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
|
private struct MOJOSHADER_effectSamplerMap
|
|
|
{
|
|
|
public MOJOSHADER_symbolType type;
|
|
|
public IntPtr name; // const char*
|
|
|
}
|
|
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
|
private struct MOJOSHADER_effectString
|
|
|
{
|
|
|
public MOJOSHADER_symbolType type;
|
|
|
public IntPtr stringvalue; // const char*
|
|
|
}
|
|
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
|
private struct MOJOSHADER_effectTexture
|
|
|
{
|
|
|
public MOJOSHADER_symbolType type;
|
|
|
}
|
|
|
|
|
|
[StructLayout(LayoutKind.Explicit)]
|
|
|
private struct MOJOSHADER_effectObject
|
|
|
{
|
|
|
[FieldOffset(0)]
|
|
|
public MOJOSHADER_symbolType type;
|
|
|
[FieldOffset(0)]
|
|
|
public MOJOSHADER_effectShader shader;
|
|
|
[FieldOffset(0)]
|
|
|
public MOJOSHADER_effectSamplerMap mapping;
|
|
|
[FieldOffset(0)]
|
|
|
public MOJOSHADER_effectString stringvalue;
|
|
|
[FieldOffset(0)]
|
|
|
public MOJOSHADER_effectTexture texture;
|
|
|
}
|
|
|
|
|
|
/* Effect state change types... */
|
|
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
|
private struct MOJOSHADER_samplerStateRegister
|
|
|
{
|
|
|
public IntPtr sampler_name; // const char*
|
|
|
public uint sampler_register;
|
|
|
public uint sampler_state_count;
|
|
|
public IntPtr sampler_states; // const MOJOSHADER_effectSamplerState*
|
|
|
}
|
|
|
|
|
|
// Needed by VideoPlayer...
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
|
internal struct MOJOSHADER_effectStateChanges
|
|
|
{
|
|
|
public uint render_state_change_count;
|
|
|
public IntPtr render_state_changes; // const MOJOSHADER_effectState*
|
|
|
public uint sampler_state_change_count;
|
|
|
public IntPtr sampler_state_changes; // const MOJOSHADER_samplerStateRegister*
|
|
|
public uint vertex_sampler_state_change_count;
|
|
|
public IntPtr vertex_sampler_state_changes; // const MOJOSHADER_samplerStateRegister*
|
|
|
}
|
|
|
|
|
|
/* Effect parsing interface... this is a partial struct! */
|
|
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
|
private struct MOJOSHADER_effect
|
|
|
{
|
|
|
public int error_count;
|
|
|
public IntPtr errors; // MOJOSHADER_error*
|
|
|
public int param_count;
|
|
|
public IntPtr parameters; // MOJOSHADER_effectParam* params, lolC#
|
|
|
public int technique_count;
|
|
|
public IntPtr techniques; // MOJOSHADER_effectTechnique*
|
|
|
public int object_count;
|
|
|
public IntPtr objects; // MOJOSHADER_effectObject*
|
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
}
|
|
|
}
|
|
|
|
