public void EndPassRestore(IGLEffect effect)
{
ForceToMainThread(() =>
{
GLDevice.EndPassRestore(effect);
}); // End ForceToMainThread
}
public void BeginPassRestore(IGLEffect effect, IntPtr stateChanges)
{
ForceToMainThread(() =>
{
GLDevice.BeginPassRestore(effect, stateChanges);
}); // End ForceToMainThread
}
public IGLEffect CloneEffect(IGLEffect effect)
{
IGLEffect result = null;
ForceToMainThread(() =>
{
result = GLDevice.CloneEffect(effect);
}); // End ForceToMainThread
return(result);
}
public IGLEffect CreateEffect(byte[] effectCode)
{
IGLEffect result = null;
ForceToMainThread(() =>
{
result = GLDevice.CreateEffect(effectCode);
}); // End ForceToMainThread
return(result);
}
public void ApplyEffect(
IGLEffect effect,
IntPtr technique,
uint pass,
IntPtr stateChanges
)
{
ForceToMainThread(() =>
{
GLDevice.ApplyEffect(
effect,
technique,
pass,
stateChanges
);
}); // End ForceToMainThread
}
protected Effect(Effect cloneSource)
{
GraphicsDevice = cloneSource.GraphicsDevice;
// Send the parsed data to be cloned and recompiled by MojoShader
glEffect = GraphicsDevice.GLDevice.CloneEffect(
cloneSource.glEffect
);
// Double the ugly, double the fun!
INTERNAL_parseEffectStruct();
// 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];
}
}
// Pin the state changes so .NET doesn't move it around
stateChanges = new MojoShader.MOJOSHADER_effectStateChanges();
stateChanges.render_state_change_count = 0;
stateChanges.sampler_state_change_count = 0;
stateChanges.vertex_sampler_state_change_count = 0;
stateChangesHandle = GCHandle.Alloc(stateChanges, GCHandleType.Pinned);
}
public Effect(GraphicsDevice graphicsDevice, byte[] effectCode)
{
GraphicsDevice = graphicsDevice;
// Send the blob to the GLDevice to be parsed/compiled
glEffect = graphicsDevice.GLDevice.CreateEffect(effectCode);
// This is where it gets ugly...
INTERNAL_parseEffectStruct();
// The default technique is the first technique.
CurrentTechnique = Techniques[0];
// Pin the state changes so .NET doesn't move it around
stateChanges = new MojoShader.MOJOSHADER_effectStateChanges();
stateChanges.render_state_change_count = 0;
stateChanges.sampler_state_change_count = 0;
stateChanges.vertex_sampler_state_change_count = 0;
stateChangesHandle = GCHandle.Alloc(stateChanges, GCHandleType.Pinned);
}
public void EndPassRestore(IGLEffect effect)
{
IntPtr glEffectData = (effect as OpenGLEffect).GLEffectData;
MojoShader.MOJOSHADER_glEffectEndPass(glEffectData);
MojoShader.MOJOSHADER_glEffectEnd(glEffectData);
effectApplied = true;
}
public void BeginPassRestore(
IGLEffect effect,
ref MojoShader.MOJOSHADER_effectStateChanges changes
) {
IntPtr glEffectData = (effect as OpenGLEffect).GLEffectData;
uint whatever;
MojoShader.MOJOSHADER_glEffectBegin(
glEffectData,
out whatever,
1,
ref changes
);
MojoShader.MOJOSHADER_glEffectBeginPass(
glEffectData,
0
);
effectApplied = true;
}
public void ApplyEffect(
IGLEffect effect,
IntPtr technique,
uint pass,
ref MojoShader.MOJOSHADER_effectStateChanges stateChanges
) {
effectApplied = true;
IntPtr glEffectData = (effect as OpenGLEffect).GLEffectData;
if (glEffectData == currentEffect)
{
if (technique == currentTechnique && pass == currentPass)
{
MojoShader.MOJOSHADER_glEffectCommitChanges(currentEffect);
return;
}
MojoShader.MOJOSHADER_glEffectEndPass(currentEffect);
MojoShader.MOJOSHADER_glEffectBeginPass(currentEffect, pass);
currentTechnique = technique;
currentPass = pass;
return;
}
else if (currentEffect != IntPtr.Zero)
{
MojoShader.MOJOSHADER_glEffectEndPass(currentEffect);
MojoShader.MOJOSHADER_glEffectEnd(currentEffect);
}
uint whatever;
MojoShader.MOJOSHADER_glEffectBegin(
glEffectData,
out whatever,
0,
ref stateChanges
);
MojoShader.MOJOSHADER_glEffectBeginPass(
glEffectData,
pass
);
currentEffect = glEffectData;
currentTechnique = technique;
currentPass = pass;
}
public IGLEffect CloneEffect(IGLEffect cloneSource)
{
IntPtr effect = IntPtr.Zero;
IntPtr glEffect = IntPtr.Zero;
#if !DISABLE_THREADING
ForceToMainThread(() => {
#endif
effect = MojoShader.MOJOSHADER_cloneEffect(cloneSource.EffectData);
glEffect = MojoShader.MOJOSHADER_glCompileEffect(effect);
if (glEffect == IntPtr.Zero)
{
throw new InvalidOperationException(
MojoShader.MOJOSHADER_glGetError()
);
}
#if !DISABLE_THREADING
});
#endif
return new OpenGLEffect(effect, glEffect);
}
private void DeleteEffect(IGLEffect effect)
{
IntPtr glEffectData = (effect as OpenGLEffect).GLEffectData;
if (glEffectData == currentEffect)
{
MojoShader.MOJOSHADER_glEffectEndPass(currentEffect);
MojoShader.MOJOSHADER_glEffectEnd(currentEffect);
currentEffect = IntPtr.Zero;
currentTechnique = IntPtr.Zero;
currentPass = 0;
}
MojoShader.MOJOSHADER_glDeleteEffect(glEffectData);
MojoShader.MOJOSHADER_freeEffect(effect.EffectData);
}
public void AddDisposeEffect(IGLEffect effect)
{
if (IsOnMainThread())
{
DeleteEffect(effect);
}
else
{
GCEffects.Enqueue(effect);
}
}
public void AddDisposeEffect(IGLEffect effect)
{
GCEffects.Enqueue(effect);
}
protected Effect(Effect cloneSource)
{
GraphicsDevice = cloneSource.GraphicsDevice;
// Send the parsed data to be cloned and recompiled by MojoShader
glEffect = GraphicsDevice.GLDevice.CloneEffect(
cloneSource.glEffect
);
// Double the ugly, double the fun!
INTERNAL_parseEffectStruct();
// 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];
}
}
}
public Effect(GraphicsDevice graphicsDevice, byte[] effectCode)
{
GraphicsDevice = graphicsDevice;
// Send the blob to the GLDevice to be parsed/compiled
glEffect = graphicsDevice.GLDevice.CreateEffect(effectCode);
// This is where it gets ugly...
INTERNAL_parseEffectStruct();
// The default technique is the first technique.
CurrentTechnique = Techniques[0];
}
