public bool Equals(ref ViewTransform rhs)
{
return((Scale == rhs.Scale) &&
(Position == rhs.Position) &&
(Projection == rhs.Projection) &&
(ModelView == rhs.ModelView));
}
private void ApplyViewTransformToMaterial(Material m, ref ViewTransform viewTransform)
{
var em = m as IEffectMaterial;
if (em == null)
{
return;
}
var e = em.Effect;
if (e == null)
{
return;
}
#if SDL2
if (em.Parameters.ViewportScale != null && em.Parameters.ViewportPosition != null)
{
// Only WorldSpace has these parameters -flibit
em.Parameters.ViewportScale.SetValue(viewTransform.Scale);
em.Parameters.ViewportPosition.SetValue(viewTransform.Position);
}
#else
em.Parameters.ViewportScale.SetValue(viewTransform.Scale);
em.Parameters.ViewportPosition.SetValue(viewTransform.Position);
#endif
em.Parameters.ProjectionMatrix.SetValue(viewTransform.Projection);
em.Parameters.ModelViewMatrix.SetValue(viewTransform.ModelView);
}
/// <summary>
/// Synchronously renders a complete frame to the specified render target.
/// Automatically sets up the device's viewport and the view transform of your materials and restores them afterwards.
/// </summary>
public bool SynchronousDrawToRenderTarget(RenderTarget2D renderTarget, DefaultMaterialSet materials, Action <Frame> drawBehavior)
{
if (renderTarget.IsDisposed)
{
return(false);
}
if (!SynchronousDrawsEnabled)
{
throw new InvalidOperationException("Synchronous draws not available inside of Game.Draw");
}
WaitForActiveDraw();
var oldDrawIsActive = Interlocked.Exchange(ref _SynchronousDrawIsActive, 1);
if (oldDrawIsActive != 0)
{
throw new InvalidOperationException("A synchronous draw is already in progress");
}
_SynchronousDrawFinishedSignal.Reset();
WaitForActiveDraw();
try {
using (var frame = Manager.CreateFrame()) {
materials.PushViewTransform(ViewTransform.CreateOrthographic(renderTarget.Width, renderTarget.Height));
ClearBatch.AddNew(frame, int.MinValue, materials.Clear, clearColor: Color.Transparent);
drawBehavior(frame);
PrepareNextFrame(frame, false);
var oldRenderTargets = Device.GetRenderTargets();
var oldViewport = Device.Viewport;
try {
Device.SetRenderTarget(renderTarget);
RenderManager.ResetDeviceState(Device);
Device.Viewport = new Viewport(0, 0, renderTarget.Width, renderTarget.Height);
RenderFrameToDraw(frame, false);
} finally {
Device.SetRenderTargets(oldRenderTargets);
materials.PopViewTransform();
Device.Viewport = oldViewport;
}
}
return(true);
} finally {
_SynchronousDrawFinishedSignal.Set();
Interlocked.Exchange(ref _SynchronousDrawIsActive, 0);
}
}
private void PendingDrawSetupHandler(DeviceManager dm, object _pd)
{
var pd = (PendingDraw)_pd;
if (!AutoRenderTarget.IsRenderTargetValid(pd.RenderTarget))
{
throw new ObjectDisposedException("Render target for pending draw was disposed between prepare and issue");
}
var vt = pd.ViewTransform ??
ViewTransform.CreateOrthographic(pd.RenderTarget.Width, pd.RenderTarget.Height);
pd.Materials.PushViewTransform(in vt);
dm.Device.Clear(Color.Transparent);
}
/// <summary>
/// Manually sets the view transform of all material(s) owned by this material set without changing the ViewTransform field.
/// </summary>
/// <param name="viewTransform">The view transform to apply.</param>
public void ApplyViewTransform(ref ViewTransform viewTransform)
{
if (
CurrentlyAppliedViewTransform.HasValue &&
CurrentlyAppliedViewTransform.Value.Equals(ref viewTransform)
)
{
// Already applied. Don't apply again.
return;
}
else
{
CurrentlyAppliedViewTransform = viewTransform;
}
ForEachMaterial(_ApplyViewTransformDelegate, ref viewTransform);
}
public void ApplyViewTransformToMaterial(Material m, ref ViewTransform viewTransform)
{
if (m.Effect == null)
{
return;
}
var ub = GetUniformBinding <ViewTransform>(m, "Viewport");
if (ub == null)
{
return;
}
ub.Value.Current = viewTransform;
// FIXME: WHY IS THIS NECESSARY?
// m.Flush();
}
private bool DoSynchronousDrawToRenderTarget(
RenderTarget2D renderTarget,
DefaultMaterialSet materials,
Delegate drawBehavior, object userData,
ref ViewTransform?viewTransform,
string description
)
{
var oldLazyState = materials.LazyViewTransformChanges;
try {
materials.LazyViewTransformChanges = false;
materials.ApplyViewTransform(materials.ViewTransform, true);
using (var frame = Manager.CreateFrame(this)) {
frame.ChangeRenderTargets = false;
frame.Label = description;
if (viewTransform.HasValue)
{
materials.PushViewTransform(in viewTransform);
}
else
{
materials.PushViewTransform(ViewTransform.CreateOrthographic(renderTarget.Width, renderTarget.Height));
}
try {
// FIXME: Should queued draws run here? They are probably meant to run in the next real frame
var singleBehavior = drawBehavior as Action <Frame>;
var multiBehavior = drawBehavior as PendingDrawHandler;
if (singleBehavior != null)
{
singleBehavior(frame);
}
else if (multiBehavior != null)
{
multiBehavior(frame, materials, userData);
}
else
{
throw new ArgumentException("Draw behavior was not of a compatible type");
}
RunBeforePrepareHandlers();
PrepareNextFrame(frame, false);
Manager.DeviceManager.SetRenderTarget(renderTarget);
RenderManager.ResetDeviceState(Device);
Device.Clear(Color.Transparent);
RenderFrameToDraw(frame, false);
// We don't have to push/pop anymore because the stacks are cleared at the end of a frame.
return(true);
} finally {
materials.PopViewTransform();
}
}
} finally {
materials.LazyViewTransformChanges = oldLazyState;
}
}
/// <summary>
/// Immediately changes the view transform of the material set, without waiting for a clear.
/// </summary>
public void PushViewTransform(ref ViewTransform viewTransform)
{
ViewTransformStack.Push(viewTransform);
ApplyViewTransform(ref viewTransform);
}
public DefaultMaterialSet(IServiceProvider serviceProvider)
{
_ApplyViewTransformDelegate = ApplyViewTransformToMaterial;
_ApplyTimeDelegate = ApplyTimeToMaterial;
TimeProvider = (ITimeProvider)serviceProvider.GetService(typeof(ITimeProvider))
?? new DotNetTimeProvider();
#if SDL2 // `Content/SquaredRender/` folder -flibit
BuiltInShaders = new ContentManager(serviceProvider, "Content/SquaredRender");
#else
BuiltInShaders = new ResourceContentManager(serviceProvider, Shaders.ResourceManager);
#endif
Clear = new Material(
null, null,
new Action <DeviceManager>[] { (dm) => ApplyShaderVariables() }
);
var bitmapShader = BuiltInShaders.Load <Effect>("SquaredBitmapShader");
var geometryShader = BuiltInShaders.Load <Effect>("SquaredGeometryShader");
ScreenSpaceBitmap = new Material(
bitmapShader,
"ScreenSpaceBitmapTechnique"
);
WorldSpaceBitmap = new Material(
bitmapShader,
"WorldSpaceBitmapTechnique"
);
ScreenSpaceShadowedBitmap = new Material(
bitmapShader,
"ScreenSpaceShadowedBitmapTechnique"
);
ScreenSpaceShadowedBitmap.Parameters.ShadowColor.SetValue(new Vector4(0, 0, 0, 1));
ScreenSpaceShadowedBitmap.Parameters.ShadowOffset.SetValue(new Vector2(2, 2));
WorldSpaceShadowedBitmap = new Material(
bitmapShader,
"WorldSpaceShadowedBitmapTechnique"
);
WorldSpaceShadowedBitmap.Parameters.ShadowColor.SetValue(new Vector4(0, 0, 0, 1));
WorldSpaceShadowedBitmap.Parameters.ShadowOffset.SetValue(new Vector2(2, 2));
ScreenSpaceBitmapWithDiscard = new Material(
bitmapShader,
"ScreenSpaceBitmapWithDiscardTechnique"
);
WorldSpaceBitmapWithDiscard = new Material(
bitmapShader,
"WorldSpaceBitmapWithDiscardTechnique"
);
ScreenSpaceGeometry = new Material(
geometryShader,
"ScreenSpaceUntextured"
);
WorldSpaceGeometry = new Material(
geometryShader,
"WorldSpaceUntextured"
);
var lightmapShader = BuiltInShaders.Load <Effect>("Lightmap");
ScreenSpaceLightmappedBitmap = new Material(
lightmapShader,
"ScreenSpaceLightmappedBitmap"
);
WorldSpaceLightmappedBitmap = new Material(
lightmapShader,
"WorldSpaceLightmappedBitmap"
);
var blurShader = BuiltInShaders.Load <Effect>("GaussianBlur");
ScreenSpaceHorizontalGaussianBlur5Tap = new Material(
blurShader,
"ScreenSpaceHorizontalGaussianBlur5Tap"
);
ScreenSpaceVerticalGaussianBlur5Tap = new Material(
blurShader,
"ScreenSpaceVerticalGaussianBlur5Tap"
);
WorldSpaceHorizontalGaussianBlur5Tap = new Material(
blurShader,
"WorldSpaceHorizontalGaussianBlur5Tap"
);
WorldSpaceVerticalGaussianBlur5Tap = new Material(
blurShader,
"WorldSpaceVerticalGaussianBlur5Tap"
);
var gds = serviceProvider.GetService(typeof(IGraphicsDeviceService)) as IGraphicsDeviceService;
if (gds != null)
{
ViewTransformStack.Push(ViewTransform.CreateOrthographic(
gds.GraphicsDevice.PresentationParameters.BackBufferWidth,
gds.GraphicsDevice.PresentationParameters.BackBufferHeight
));
}
else
{
ViewTransformStack.Push(ViewTransform.Default);
}
PreallocateBindings();
}
public DefaultMaterialSet(IServiceProvider serviceProvider)
{
_ApplyViewTransformDelegate = ApplyViewTransformToMaterial;
#if SDL2
BuiltInShaders = new ContentManager(serviceProvider, "Content/SquaredRender");
#elif !PSM
BuiltInShaders = new ResourceContentManager(serviceProvider, Shaders.ResourceManager);
#else
BuiltInShaders = new Squared.Render.PSM.PSMShaderManager(serviceProvider);
#endif
Clear = new DelegateMaterial(
new NullMaterial(),
new Action <DeviceManager>[] { (dm) => ApplyShaderVariables() },
null
);
#if PSM
ScreenSpaceBitmap = new EffectMaterial(BuiltInShaders.Load <Effect>("ScreenSpaceBitmap"));
WorldSpaceBitmap = new EffectMaterial(BuiltInShaders.Load <Effect>("WorldSpaceBitmap"));
ScreenSpaceGeometry = new EffectMaterial(BuiltInShaders.Load <Effect>("ScreenSpaceGeometry"));
WorldSpaceGeometry = new EffectMaterial(BuiltInShaders.Load <Effect>("WorldSpaceGeometry"));
#elif SDL2
ScreenSpaceBitmap = new EffectMaterial(
BuiltInShaders.Load <Effect>("ScreenSpaceBitmapTechnique"),
"ScreenSpaceBitmapTechnique"
);
WorldSpaceBitmap = new EffectMaterial(
BuiltInShaders.Load <Effect>("WorldSpaceBitmapTechnique"),
"WorldSpaceBitmapTechnique"
);
ScreenSpaceGeometry = new EffectMaterial(
BuiltInShaders.Load <Effect>("ScreenSpaceUntextured"),
"ScreenSpaceUntextured"
);
WorldSpaceGeometry = new EffectMaterial(
BuiltInShaders.Load <Effect>("WorldSpaceUntextured"),
"WorldSpaceUntextured"
);
#else
var bitmapShader = BuiltInShaders.Load <Effect>("SquaredBitmapShader");
var geometryShader = BuiltInShaders.Load <Effect>("SquaredGeometryShader");
ScreenSpaceBitmap = new EffectMaterial(
bitmapShader,
"ScreenSpaceBitmapTechnique"
);
WorldSpaceBitmap = new EffectMaterial(
bitmapShader,
"WorldSpaceBitmapTechnique"
);
ScreenSpaceBitmapWithDiscard = new EffectMaterial(
bitmapShader,
"ScreenSpaceBitmapWithDiscardTechnique"
);
WorldSpaceBitmapWithDiscard = new EffectMaterial(
bitmapShader,
"WorldSpaceBitmapWithDiscardTechnique"
);
ScreenSpaceGeometry = new EffectMaterial(
geometryShader,
"ScreenSpaceUntextured"
);
WorldSpaceGeometry = new EffectMaterial(
geometryShader,
"WorldSpaceUntextured"
);
#endif
#if SDL2
ScreenSpaceLightmappedBitmap = new EffectMaterial(
BuiltInShaders.Load <Effect>("ScreenSpaceLightmappedBitmap"),
"ScreenSpaceLightmappedBitmap"
);
WorldSpaceLightmappedBitmap = new EffectMaterial(
BuiltInShaders.Load <Effect>("WorldSpaceLightmappedBitmap"),
"WorldSpaceLightmappedBitmap"
);
#elif !PSM
var lightmapShader = BuiltInShaders.Load <Effect>("Lightmap");
ScreenSpaceLightmappedBitmap = new EffectMaterial(
lightmapShader,
"ScreenSpaceLightmappedBitmap"
);
WorldSpaceLightmappedBitmap = new EffectMaterial(
lightmapShader,
"WorldSpaceLightmappedBitmap"
);
var blurShader = BuiltInShaders.Load <Effect>("GaussianBlur");
ScreenSpaceHorizontalGaussianBlur5Tap = new EffectMaterial(
blurShader,
"ScreenSpaceHorizontalGaussianBlur5Tap"
);
ScreenSpaceVerticalGaussianBlur5Tap = new EffectMaterial(
blurShader,
"ScreenSpaceVerticalGaussianBlur5Tap"
);
WorldSpaceHorizontalGaussianBlur5Tap = new EffectMaterial(
blurShader,
"WorldSpaceHorizontalGaussianBlur5Tap"
);
WorldSpaceVerticalGaussianBlur5Tap = new EffectMaterial(
blurShader,
"WorldSpaceVerticalGaussianBlur5Tap"
);
#endif
var gds = serviceProvider.GetService(typeof(IGraphicsDeviceService)) as IGraphicsDeviceService;
if (gds != null)
{
ViewTransformStack.Push(ViewTransform.CreateOrthographic(
gds.GraphicsDevice.PresentationParameters.BackBufferWidth,
gds.GraphicsDevice.PresentationParameters.BackBufferHeight
));
}
else
{
ViewTransformStack.Push(ViewTransform.Default);
}
}
