/** TOM: why do a separate this from the normal dispose-method? */
//public void CleanUp()
//{
// Utilities.DisposeObj(ref _D3DImageContainer);
//}
#endregion
#region rendering geometry
public void RenderGeometry(OperatorPartContext context, Action <OperatorPartContext, int> evaluateMeshOrScene)
{
SetupContextForGeometry(context);
LastContext = context; // Make context accessible to read last camera position
if (RenderConfig.ShowGridAndGizmos)
{
// Check the selected operators for attributes that can be show as Gizmo
var selectedOps = (from selectable in App.Current.MainWindow.CompositionView.CompositionGraphView.SelectionHandler.SelectedElements
select selectable as OperatorWidget
into opWidget
where opWidget != null && opWidget.Operator.Outputs.Any()
select opWidget.Operator).ToArray();
RenderConfig.TransformGizmo.SetupEvalCallbackForSelectedTransformOperators(selectedOps, context);
// Override DebugSetting with ShowGizmo-Setting
var previousDebugSetting = GetDebugSettingFromContextVariables(context);
context.Variables[OperatorPartContext.DEBUG_VARIABLE_NAME] = 1;
context.Variables[GIZMO_PART_VARIBALE_NAME] = RenderConfig.TransformGizmo.IndexOfGizmoPartBelowMouse;
evaluateMeshOrScene(context, RenderConfig.ShownOutputIndex);
// Render Grid and Gizmos
_sceneGridOperator.Outputs[0].Eval(context);
RenderConfig.TransformGizmo.RenderTransformGizmo(context);
// Reset DebugSetting
if (previousDebugSetting != null)
{
context.Variables[OperatorPartContext.DEBUG_VARIABLE_NAME] = previousDebugSetting.Value;
}
else
{
context.Variables.Remove(OperatorPartContext.DEBUG_VARIABLE_NAME);
}
}
else
{
evaluateMeshOrScene(context, RenderConfig.ShownOutputIndex);
}
// With gamma correction we need an additional pass gamma correcting the RT Texture to the shared texture
if (RenderConfig.RenderWithGammaCorrection)
{
SetupContextForRenderingImage(context, withGammaCorrection: true);
_renderer.RenderToScreen(_sceneRenderTargetTexture, context);
}
_gpuSyncer.Sync(D3D11Device.ImmediateContext);
}
private void EvaluateOperator(OperatorPartContext context, int outputIdx, bool renderMesh)
{
if (renderMesh)
{
Mesh mesh = Operator.Outputs[outputIdx].Eval(context).Mesh;
context.Renderer.SetupEffect(context);
context.Renderer.Render(mesh, context);
}
else
{
// scene renders itself
Operator.Outputs[outputIdx].Eval(context);
}
}
public virtual void RenderToScreen(Texture2D image, OperatorPartContext context)
{
var subContext = new OperatorPartContext(context)
{
Effect = ScreenRenderEffect,
DepthStencilView = null,
CameraProjection = Matrix.OrthoLH(1, 1, -100, 100),
WorldToCamera = Matrix.LookAtLH(new Vector3(0, 0, -5), new Vector3(0, 0, 0), new Vector3(0, 1, 0)),
InputLayout = ScreenQuadInputLayout
};
var shaderResourceViewDescription = new ShaderResourceViewDescription();
if (image.Description.ArraySize > 1)
{
shaderResourceViewDescription.Format = image.Description.Format;
shaderResourceViewDescription.Dimension = ShaderResourceViewDimension.Texture2DArray;
shaderResourceViewDescription.Texture2DArray = new ShaderResourceViewDescription.Texture2DArrayResource
{
ArraySize = image.Description.ArraySize,
FirstArraySlice = 0,
MipLevels = image.Description.MipLevels,
MostDetailedMip = 0
};
}
else if (image.Description.Format == Format.R32_Typeless)
{
shaderResourceViewDescription.Format = Format.R32_Float;
shaderResourceViewDescription.Dimension = ShaderResourceViewDimension.Texture2D;
shaderResourceViewDescription.Texture2D.MipLevels = 1;
}
else
{
shaderResourceViewDescription.Format = image.Description.Format;
shaderResourceViewDescription.Dimension = ShaderResourceViewDimension.Texture2D;
shaderResourceViewDescription.Texture2D = new ShaderResourceViewDescription.Texture2DResource
{
MipLevels = image.Description.MipLevels,
MostDetailedMip = 0
};
}
using (var shaderResourceView = new ShaderResourceView(context.D3DDevice, image, shaderResourceViewDescription))
{
subContext.Texture0 = shaderResourceView;
SetupBaseEffectParameters(subContext);
Render(_screenQuadMesh, subContext);
}
}
public void PropertyStasher_pushModifyAndPopViewportAndObjectTWorld_bothAreRestored()
{
var context = new OperatorPartContext();
var viewport = new SharpDX.ViewportF(0, 0, 320, 200);
context.Viewport = viewport;
using (new PropertyStasher <OperatorPartContext>(context, "Viewport", "ObjectTWorld")) {
context.Viewport = new SharpDX.ViewportF(0, 0, 640, 480);
context.ObjectTWorld = SharpDX.Matrix.OrthoLH(1.0f, 1.0f, 0.1f, 1.0f);
}
Assert.AreEqual(SharpDX.Matrix.Identity, context.ObjectTWorld);
Assert.AreEqual(viewport, context.Viewport);
}
public virtual string GetCode(int idx)
{
if (idx < OperatorPart.Connections.Count)
{
var context = new OperatorPartContext()
{
Time = 0.0f
};
return(OperatorPart.Connections[idx].Eval(context).Text);
}
else
{
return("");
}
}
public void RenderValuePlot(OperatorPartContext context, RenderViewConfiguration renderConfig)
{
SetupContextForGeometry(context);
renderConfig.Operator.Outputs[renderConfig.ShownOutputIndex].Eval(context);
context.Variables[OperatorPartContext.PLOT_FLOAT_VALUE] = context.Value;
var invalidator = new OperatorPart.InvalidateInvalidatables();
_plotValueOperator.Outputs[0].TraverseWithFunction(null, invalidator);
_plotValueOperator.Outputs[0].Eval(context);
_gpuSyncer.Sync(D3D11Device.ImmediateContext);
}
public virtual void Render(Mesh mesh, OperatorPartContext context, int techniqueIdx)
{
if (context.DepthStencilView != null && context.RenderTargetViews != null)
{
context.D3DDevice.ImmediateContext.OutputMerger.SetTargets(context.DepthStencilView, context.RenderTargetViews);
}
else if (context.DepthStencilView != null && context.RenderTargetView != null)
{
context.D3DDevice.ImmediateContext.OutputMerger.SetTargets(context.DepthStencilView, context.RenderTargetView);
}
else if (context.RenderTargetView != null)
{
context.D3DDevice.ImmediateContext.OutputMerger.SetTargets(context.RenderTargetView);
}
else if (context.DepthStencilView != null)
{
context.D3DDevice.ImmediateContext.OutputMerger.SetTargets(context.DepthStencilView, (RenderTargetView)null);
}
if (context.BlendState != null)
{
context.D3DDevice.ImmediateContext.OutputMerger.BlendState = context.BlendState;
context.D3DDevice.ImmediateContext.OutputMerger.BlendFactor = context.BlendFactor;
}
if (context.DepthStencilState != null)
{
context.D3DDevice.ImmediateContext.OutputMerger.DepthStencilState = context.DepthStencilState;
}
if (context.RasterizerState != null)
{
context.D3DDevice.ImmediateContext.Rasterizer.State = context.RasterizerState;
}
context.D3DDevice.ImmediateContext.Rasterizer.SetViewport(context.Viewport);
context.D3DDevice.ImmediateContext.InputAssembler.InputLayout = context.InputLayout;
context.D3DDevice.ImmediateContext.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleList;
context.D3DDevice.ImmediateContext.InputAssembler.SetVertexBuffers(0, new VertexBufferBinding(mesh.Vertices, mesh.AttributesSize, 0));
var technique = context.Effect.GetTechniqueByIndex(techniqueIdx);
for (int i = 0; i < technique.Description.PassCount; ++i)
{
technique.GetPassByIndex(i).Apply(context.D3DDevice.ImmediateContext);
context.D3DDevice.ImmediateContext.Draw(mesh.NumTriangles * 3, 0);
}
}
private void CreateContextSettingsWithAspectRatio()
{
_D3DImageContainer.SetBackBufferSharpDX(_sharedTexture);
var contextSettings = new ContextSettings();
contextSettings.DisplayMode = new SharpDX.Direct3D9.DisplayMode()
{
Width = RenderConfig.Width,
Height = RenderConfig.Height,
RefreshRate = 60,
Format = D3DImageSharpDX.TranslateFormat(_sharedTexture)
};
contextSettings.AspectRatio = contextSettings.DisplayMode.AspectRatio;
_defaultContext = OperatorPartContext.createDefault(contextSettings);
}
protected void SetupPbrSphereLightsStructuredBufferForEffect(OperatorPartContext context, string effectVariableName, ref Buffer sphereLightsBuffer, ref ShaderResourceView sphereLightsSRV)
{
var sphereLightVariable = context.Effect.GetVariableByName(effectVariableName).AsShaderResource();
if (sphereLightVariable != null)
{
var sphereLights = (List <IPbrSphereLight>)context.Objects[OperatorPartContext.PBR_SPHERE_LIGHT_CONTAINER_ID];
bool success = SetupStructuredBuffer(context.D3DDevice, sphereLights.ToArray(), pl => new PbrSphereLightBufferLayout(pl),
ref sphereLightsBuffer, ref sphereLightsSRV);
sphereLightVariable.SetResource(success ? sphereLightsSRV : null);
}
else
{
Logger.Warn("Found no PBR sphere light effect variable '{0}'.", effectVariableName);
}
}
private void SetupContextForRenderingGeometry(OperatorPartContext context, bool withGammaCorrection)
{
context.D3DDevice = D3D11Device;
context.Effect = _renderer.SceneDefaultEffect;
context.InputLayout = _renderer.SceneDefaultInputLayout;
context.RenderTargetView = withGammaCorrection
? _sceneRenderTargetTextureRenderView
: _sharedTextureRenderView;
context.DepthStencilView = _renderTargetDepthView;
context.DepthStencilState = _renderer.DefaultDepthStencilState;
context.BlendState = _renderer.DefaultBlendState;
context.BlendFactor = _renderer.DefaultBlendFactor;
context.RasterizerState = _renderer.DefaultRasterizerState;
context.SamplerState = _renderer.DefaultSamplerState;
context.Viewport = new Viewport(0, 0, RenderConfig.Width, RenderConfig.Height, 0.0f, 1.0f);
context.Texture0 = _texture;
}
public void SetupContextForRenderingImage(OperatorPartContext context, bool withGammaCorrection)
{
context.Effect = withGammaCorrection
? _renderer.ScreenRenderGammaCorrectionEffect
: _renderer.ScreenRenderEffect;
context.D3DDevice = D3D11Device;
context.InputLayout = _renderer.ScreenQuadInputLayout;
context.RenderTargetView = _sharedTextureRenderView;
context.DepthStencilView = null;
context.DepthStencilState = _renderer.DefaultDepthStencilState;
context.BlendState = _renderer.DisabledBlendState; // DefaultBlendState;
context.BlendFactor = _renderer.DefaultBlendFactor;
context.RasterizerState = _renderer.DefaultRasterizerState;
context.SamplerState = _renderer.DefaultSamplerState;
context.Viewport = new Viewport(0, 0, RenderConfig.Width, RenderConfig.Height, 0.0f, 1.0f);
context.Texture0 = _texture;
}
private void SetupContextForGeometry(OperatorPartContext context)
{
SetupContextForRenderingGeometry(context, RenderConfig.RenderWithGammaCorrection);
RenderConfig.CameraSetup.GetViewDirections(out Vector3 viewDir, out Vector3 sideDir, out Vector3 upDir);
var worldToCamera = Matrix.LookAtLH(RenderConfig.CameraSetup.Position, RenderConfig.CameraSetup.Target, upDir);
// Find a nice balance between small and large objects (probably skyspheres)
var zoomLength = (RenderConfig.CameraSetup.Position - RenderConfig.CameraSetup.Target).Length();
var farClipping = (zoomLength * 2) + 5000;
var nearClipping = zoomLength / 100;
SetupContextForRenderingCamToBuffer(context, RenderConfig.Operator, _renderer, worldToCamera, nearClipping, farClipping);
RenderConfig.CameraSetup.LastWorldToCamera = context.WorldToCamera;
RenderConfig.CameraSetup.LastCameraProjection = context.CameraProjection;
}
public void PropertyStasher_modifyCascadedProperty_isRestoredToInitialValue()
{
var context = new OperatorPartContext();
var viewport = new SharpDX.ViewportF(0, 0, 320, 200);
context.Viewport = viewport;
using (new PropertyStasher <OperatorPartContext>(context, "Viewport")) {
var viewport2 = new SharpDX.Viewport(0, 0, 640, 480);
context.Viewport = viewport2;
using (new PropertyStasher <OperatorPartContext>(context, "Viewport")) {
context.Viewport = new SharpDX.Viewport(0, 0, 1024, 768);
}
Assert.AreEqual(viewport2, context.Viewport);
}
Assert.AreEqual(viewport, context.Viewport);
}
private void SetupRendering()
{
XSceneImage.Source = _D3DImageContainer;
_renderSetup = new D3DRenderSetup((int)XGrid.ActualWidth, (int)XGrid.ActualHeight);
_D3DImageContainer.SetBackBufferSharpDX(_renderSetup.SharedTexture);
var contextSettings = new ContextSettings();
contextSettings.DisplayMode = new SharpDX.Direct3D9.DisplayMode()
{
Width = _renderSetup.WindowWidth,
Height = _renderSetup.WindowHeight,
RefreshRate = 60,
Format = D3DImageSharpDX.TranslateFormat(_renderSetup.SharedTexture)
};
contextSettings.AspectRatio = contextSettings.DisplayMode.AspectRatio;
_defaultContext = OperatorPartContext.createDefault(contextSettings);
}
private OperatorPartContext GetNewContext(float t = 0.0f)
{
var context = new OperatorPartContext(_defaultContext, t);
context.D3DDevice = D3DDevice.Device;
context.Effect = _renderer.SceneDefaultEffect;
context.InputLayout = _renderer.SceneDefaultInputLayout;
context.RenderTargetView = _renderTargetView;
context.DepthStencilView = _renderTargetDepthView;
context.DepthStencilState = _renderer.DefaultDepthStencilState;
context.BlendState = _renderer.DefaultBlendState;
context.BlendFactor = _renderer.DefaultBlendFactor;
context.RasterizerState = _renderer.DefaultRasterizerState;
context.SamplerState = _renderer.DefaultSamplerState;
context.Viewport = _viewport;
context.Texture0 = _texture;
return(context);
}
void PickFileButton_Click(object sender, RoutedEventArgs e)
{
var defaultPath = ".\\assets";
var tmpContext = new OperatorPartContext();
var startPath = ValueHolder.Eval(tmpContext).Text;
var dialogTitle = "Select file";
var pickedFilePath = UIHelper.PickFileWithDialog(defaultPath, startPath, dialogTitle);
if (pickedFilePath != "")
{
if (_updateValueCommand == null)
{
XTextEdit_EditingStarted();
}
XTextEdit.XTextEdit.Text = pickedFilePath;
XTextEdit_EditingCompleted();
}
}
public void RenderCubemapAsSphere(Texture2D cubeMapImage, OperatorPartContext context)
{
// Set cubemap to context
var texture = new ShaderResourceView(context.D3DDevice, cubeMapImage);
if (texture == null)
{
return;
}
context.SkySphereSRV = texture;
Action <OperatorPartContext, int> lambdaForMeshes = (OperatorPartContext context2, int outputIdx) =>
{
_cubemapSphereOperator.Outputs[0].Eval(context);
};
RenderGeometry(context, lambdaForMeshes);
}
private Matrix ObjectToWorldWithGizmo(OperatorPartContext context)
{
Matrix transformIncludingOpTransform = Matrix.Identity;
Vector3 orgScale;
Quaternion orgRotate;
Vector3 orgTranslate;
_originalObjectToWorld.Decompose(out orgScale, out orgRotate, out orgTranslate);
Matrix transformWithNormalizedScale = Matrix.Transformation(Vector3.Zero, Quaternion.Zero, Vector3.One, Vector3.Zero,
orgRotate,
orgTranslate);
var translate = _translateInputs.EvaluateOrDefault(context, Vector3.Zero);
var rotate = _rotateInputs.EvaluateOrDefault(context, Vector3.Zero);
var pivot = _pivotInputs.EvaluateOrDefault(context, Vector3.Zero);
var tmpMatrix = context.ObjectTWorld * _gizmoToParent;
var scaleFactor = Vector4.Transform(tmpMatrix.Row4, context.WorldToCamera).Z / 20f;
Quaternion rotationByOp = Quaternion.RotationYawPitchRoll(MathUtil.DegreesToRadians(rotate.Y),
MathUtil.DegreesToRadians(rotate.X),
MathUtil.DegreesToRadians(rotate.Z));
_gizmoToParent = Matrix.Transformation(Vector3.Zero,
Quaternion.Zero,
new Vector3(scaleFactor),
Vector3.Zero,
rotationByOp,
translate);
_translateXParam.Value = translate.X;
_translateYParam.Value = translate.Y;
_translateZParam.Value = translate.Z;
transformIncludingOpTransform = _gizmoToParent * Matrix.Translation(pivot.X, pivot.Y, pivot.Z) *
transformWithNormalizedScale;
return(transformIncludingOpTransform);
}
private void UpdateShownContent()
{
if (!IsVisible || _curveOp == null)
{
return;
}
var context = new OperatorPartContext(_defaultContext, (float)App.Current.Model.GlobalTime);
if (Math.Abs(context.Time - _previousTime) > Constants.Epsilon)
{
var invalidator = new OperatorPart.InvalidateInvalidatables();
_curveOp.Outputs[0].TraverseWithFunctionUseSpecificBehavior(null, invalidator);
_previousTime = context.Time;
}
_curveOp.Outputs[0].Eval(context);
XCurveEditor.UpdateEditBox();
}
public void RenderImage(Texture2D image, OperatorPartContext context)
{
RenderConfig.CameraSetup.GetViewDirections(out Vector3 viewDir, out Vector3 sideDir, out Vector3 upDir);
var worldToCamera = Matrix.LookAtLH(RenderConfig.CameraSetup.Position, RenderConfig.CameraSetup.Target, upDir);
SetupContextForRenderingCamToBuffer(context, RenderConfig.Operator, _renderer, worldToCamera);
_imageBackgroundOperator.Outputs[0].Eval(context);
context.Image = null;
if (RenderConfig.PreferredCubeMapSideIndex > -1)
{
context.Variables[OperatorPartContext.PREFERRED_CUBEMAP_SIDE_INDEX] = RenderConfig.PreferredCubeMapSideIndex;
context.Effect = _renderer.ScreenQuadCubeMapSideEffect;
}
_renderer.SetupBaseEffectParameters(context);
_renderer.RenderToScreen(image, context);
_gpuSyncer.Sync(D3D11Device.ImmediateContext);
}
public void SetupBaseEffectParameters(OperatorPartContext context)
{
// context.D3DDevice.ImmediateContext.ClearState();
var effect = context.Effect;
var v = effect.GetVariableByName("objectToWorldMatrix").AsMatrix();
if (v != null && v.IsValid)
{
v.SetMatrix(context.ObjectTWorld);
// cynic: hack until all used effects have the objectToWorldMatrix parameter
v = effect.GetVariableByName("worldToCameraMatrix").AsMatrix();
v.SetMatrix(context.WorldToCamera);
}
else
{
v = effect.GetVariableByName("worldToCameraMatrix").AsMatrix();
v.SetMatrix(context.ObjectTWorld * context.WorldToCamera);
}
v = effect.GetVariableByName("cameraToObjectMatrix").AsMatrix();
if (v != null && v.IsValid)
{
var cameraToObject = Matrix.Invert(context.ObjectTWorld * context.WorldToCamera);
v.SetMatrix(cameraToObject);
}
v = effect.GetVariableByName("projMatrix").AsMatrix();
v.SetMatrix(context.CameraProjection);
v = effect.GetVariableByName("textureMatrix").AsMatrix();
if (v != null && v.IsValid)
{
v.SetMatrix(context.TextureMatrix);
}
var v2 = effect.GetVariableByName("txDiffuse").AsShaderResource();
v2.SetResource(context.Texture0);
}
private List <ICommand> SetupSingleAnimation(OperatorPart opPart, double keyframeTime)
{
var context = new OperatorPartContext()
{
Time = (float)keyframeTime
};
float currentValue = opPart.Eval(context).Value;
// this command is needed to restore the original value correctly when undoing this, for doing it it's redundant
var setValueCommand = new SetFloatValueCommand(opPart, currentValue);
var compOp = opPart.Parent.Parent;
var addCurveOpCommand = new AddOperatorCommand(compOp, CurveID, 100, 100, 100, false);
var curveOpInstanceId = addCurveOpCommand.AddedInstanceID;
var addTimeOpCommand = new AddOperatorCommand(compOp, CurrentTimeID, 100, 100, 100, false);
var curveMetaOp = MetaManager.Instance.GetMetaOperator(CurveID);
var timeMetaOp = MetaManager.Instance.GetMetaOperator(CurrentTimeID);
var timeToCurve = new MetaConnection(addTimeOpCommand.AddedInstanceID, timeMetaOp.Outputs[0].ID,
addCurveOpCommand.AddedInstanceID, curveMetaOp.Inputs[0].ID);
var connectionTimeToCurveCommand = new InsertConnectionCommand(compOp.Definition, timeToCurve, 0);
var curveToCurrent = new MetaConnection(addCurveOpCommand.AddedInstanceID, curveMetaOp.Outputs[0].ID,
opPart.Parent.ID, opPart.ID);
var connectionCurveToCurrentCommand = new InsertConnectionCommand(compOp.Definition, curveToCurrent, 0);
var addKeyframeCommand = new AddOrUpdateKeyframeCommand(keyframeTime, currentValue, compOp, curveOpInstanceId, curveMetaOp.Inputs[0].ID);
return(new List <ICommand>()
{
setValueCommand,
addCurveOpCommand,
addTimeOpCommand,
connectionTimeToCurveCommand,
connectionCurveToCurrentCommand,
addKeyframeCommand
});
}
public static void SetupConstBufferForCS <T>(OperatorPartContext context, T bufferData, ref Buffer buffer, int slot) where T : struct
{
using (var data = new DataStream(Marshal.SizeOf(typeof(T)), true, true))
{
data.Write(bufferData);
data.Position = 0;
if (buffer == null)
{
var bufferDesc = new BufferDescription
{
Usage = ResourceUsage.Default,
SizeInBytes = Marshal.SizeOf(typeof(T)),
BindFlags = BindFlags.ConstantBuffer
};
buffer = new Buffer(context.D3DDevice, data, bufferDesc);
}
else
{
context.D3DDevice.ImmediateContext.UpdateSubresource(new DataBox(data.DataPointer, 0, 0), buffer, 0);
}
context.D3DDevice.ImmediateContext.ComputeShader.SetConstantBuffer(slot, buffer);
}
}
public bool SetupEvalCallbackForSelectedTransformOperators(Operator[] selectedOperators, OperatorPartContext context)
{
_transformGizmoTargetOp = null;
_transformGizmoTargetValueFunction = null;
if (selectedOperators.Length != 1)
{
return(false);
}
var op = selectedOperators.First();
if (op.InternalParts.Count > 0 && op.InternalParts[0].Func is ICameraProvider)
{
return(false);
}
_translateInputs = FindVec3Inputs(op, new String[] { "Center", "Position", "Translate", "Translation", "Move" });
_pivotInputs = FindVec3Inputs(op, "Pivot");
_rotateInputs = FindVec3Inputs(op, "Rotate");
_scaleInputs = FindVec3Inputs(op, "Scale");
if (!_translateInputs.Valid)
{
return(false);
}
_context = context;
_transformGizmoTargetOp = op;
_transformGizmoTargetValueFunction = op.Outputs[0].Func as Utilities.ValueFunction;
_transformGizmoTargetValueFunction.EvaluatedEvent += GizmoValueFunc_EvaluatedEvent; // SetupContextForRenderingCamToBuffer Evaluation Callback
_translateXParam.Input = _translateInputs.X;
_translateYParam.Input = _translateInputs.Y;
_translateZParam.Input = _translateInputs.Z;
return(true);
}
public static void SetupContextForRenderingCamToBuffer(OperatorPartContext context, Operator op, DefaultRenderer renderer, Matrix worldToCamera, float nearClipping = 0.01f, float farClipping = 10000)
{
context.D3DDevice.ImmediateContext.OutputMerger.SetTargets(context.DepthStencilView, context.RenderTargetView);
context.D3DDevice.ImmediateContext.Rasterizer.SetViewport(context.Viewport);
if (context.DepthStencilView != null)
{
context.D3DDevice.ImmediateContext.ClearDepthStencilView(context.DepthStencilView, DepthStencilClearFlags.Depth | DepthStencilClearFlags.Stencil, 1.0f, 0);
}
context.D3DDevice.ImmediateContext.ClearRenderTargetView(context.RenderTargetView, new Color4(0.4f, 0.4f, 0.4f, 1.0f));
context.D3DDevice.ImmediateContext.InputAssembler.InputLayout = context.InputLayout;
if (op == null)
{
return;
}
ICameraProvider camOp = null;
if (op.InternalParts.Count > 0)
{
camOp = op.InternalParts[0].Func as ICameraProvider;
}
if (camOp == null)
{
context.WorldToCamera = worldToCamera;
float aspect = context.Viewport.Width / context.Viewport.Height;
context.CameraProjection = Matrix.PerspectiveFovLH(3.1415f / 4.0f, aspect, nearClipping, farClipping);
}
else
{
context.WorldToCamera = camOp.GetLastWorldToCamera();
context.CameraProjection = camOp.GetLastCameraToView();
}
}
public virtual void Render(Mesh mesh, OperatorPartContext context)
{
Render(mesh, context, 0);
}
public virtual void SetupEffect(OperatorPartContext context)
{
SetupBaseEffectParameters(context);
}
public Vector3 EvaluateOrDefault(OperatorPartContext context, Vector3 fallBack)
{
return(Valid ? new Vector3(X.Eval(context).Value, Y.Eval(context).Value, Z.Eval(context).Value)
: fallBack);
}
public float RenderFrame()
{
try
{
if (!_skipExistingFiles || !File.Exists(buildFileName(_currentTime)))
{
D3DDevice.Device.ImmediateContext.ClearDepthStencilView(_renderTargetDepthView,
DepthStencilClearFlags.Depth | DepthStencilClearFlags.Stencil, 1.0f, 0);
D3DDevice.Device.ImmediateContext.ClearRenderTargetView(_renderTargetView, new SharpDX.Color4(0, 0, 0, 0));
D3DDevice.Device.ImmediateContext.InputAssembler.InputLayout = _renderer.SceneDefaultInputLayout;
foreach (var opPartFunction in _timeAccessorOpPartFunctions)
{
opPartFunction.OperatorPart.EmitChangedEvent();
}
var context = new OperatorPartContext(_defaultContext, (float)_currentTime)
{
D3DDevice = D3DDevice.Device,
Effect = _renderer.SceneDefaultEffect,
InputLayout = _renderer.SceneDefaultInputLayout,
RenderTargetView = _renderTargetView,
DepthStencilView = _renderTargetDepthView,
DepthStencilState = _renderer.DefaultDepthStencilState,
BlendState = _renderer.DefaultBlendState,
BlendFactor = _renderer.DefaultBlendFactor,
RasterizerState = _renderer.DefaultRasterizerState,
SamplerState = _renderer.DefaultSamplerState,
Viewport = _viewport,
Texture0 = _texture
};
if (_outputOpPart.Parent.FunctionType == FunctionType.Scene)
{
_outputOpPart.Eval(context);
_gpuSyncer.Sync(D3DDevice.Device.ImmediateContext);
}
else if (_outputOpPart.Type == FunctionType.Image)
{
var image = _outputOpPart.Eval(new OperatorPartContext(context)).Image;
if (image != null)
{
_renderer.SetupBaseEffectParameters(context);
_renderer.RenderToScreen(image, context);
}
_gpuSyncer.Sync(D3DDevice.Device.ImmediateContext);
}
var format = ImageFileFormat.Png;
if (_fileExtension == "bmp")
{
format = ImageFileFormat.Bmp;
}
else if (_fileExtension == "jpg")
{
format = ImageFileFormat.Jpg;
}
else if (_fileExtension == "dds")
{
format = ImageFileFormat.Dds;
}
Texture2D.ToFile(D3DDevice.Device.ImmediateContext, _renderTargetResource.Texture, format, buildFileName(_currentTime));
}
_currentTime += _frameTime;
double progress = (_currentTime - _startTime) / (_endTime - _startTime);
return((float)progress);
}
catch (Exception ex)
{
Logger.Error("Error rendering image sequence at {0}: {1}", _currentTime, ex);
}
return(0);
}
public void RenderContent()
{
if (RenderConfig.Operator == null || RenderConfig.Operator.Outputs.Count <= 0)
{
return;
}
D3DDevice.BeginFrame();
try
{
var context = new OperatorPartContext(
_defaultContext,
(float)(App.Current.Model.GlobalTime + RenderConfig.TimeScrubOffset));
var invalidator = new OperatorPart.InvalidateInvalidatables();
RenderConfig.Operator.Outputs[RenderConfig.ShownOutputIndex].TraverseWithFunctionUseSpecificBehavior(null, invalidator);
var evaluationType = RenderConfig.Operator.Outputs[RenderConfig.ShownOutputIndex].Type;
switch (evaluationType)
{
case FunctionType.Float:
RenderValuePlot(context, RenderConfig);
break;
case FunctionType.Scene:
Action <OperatorPartContext, int> lambdaForScenes = (OperatorPartContext context2, int outputIdx) =>
{
RenderConfig.Operator.Outputs[outputIdx].Eval(context);
};
RenderGeometry(
context,
lambdaForScenes);
break;
case FunctionType.Mesh:
{
Action <OperatorPartContext, int> lambdaForMeshes = (OperatorPartContext context2, int outputIdx) =>
{
var mesh = RenderConfig.Operator.Outputs[outputIdx].Eval(context2).Mesh;
context2.Renderer.SetupEffect(context2);
context2.Renderer.Render(mesh, context2);
};
RenderGeometry(
context,
lambdaForMeshes);
break;
}
case FunctionType.Image:
SetupContextForRenderingImage(
context,
RenderConfig.RenderWithGammaCorrection);
var image = RenderConfig.Operator.Outputs[RenderConfig.ShownOutputIndex].Eval(new OperatorPartContext(context)).Image;
if (image == null)
{
break;
}
RenderedImageIsACubemap = image.Description.ArraySize > 1;
var cubeMapSide = RenderedImageIsACubemap ? RenderConfig.PreferredCubeMapSideIndex : -1;
if (cubeMapSide == 6)
{
RenderCubemapAsSphere(image, context);
}
else
{
RenderImage(image, context);
}
break;
}
_D3DImageContainer.InvalidateD3DImage();
}
catch (Exception exception)
{
Logger.Error(exception.ToString());
}
D3DDevice.EndFrame();
}
