/// <summary>
/// Loads all resources of the object.
/// </summary>
/// <param name="device">Current graphics device.</param>
/// <param name="resourceDictionary">Current resource dicionary.</param>
public override void LoadResources(EngineDevice device, ResourceDictionary resourceDictionary)
{
m_localResources.AddObject(
resourceDictionary.GetResourceAndEnsureLoaded <GeometryResource>(m_resGeometryKey),
device.DeviceIndex,
false);
}
/// <summary>
/// Applies all current render parameters.
/// </summary>
/// <param name="renderState">The render state on which to apply.</param>
internal void UpdateAndApplyRenderParameters(RenderState renderState)
{
// Get or create RenderParamters object on object level
ObjectRenderParameters renderParameters = m_renderParameters[renderState.DeviceIndex];
if (renderParameters == null)
{
renderParameters = renderState.CurrentResources.GetResourceAndEnsureLoaded <ObjectRenderParameters>(
KEY_SCENE_RENDER_PARAMETERS,
() => new ObjectRenderParameters());
m_renderParameters.AddObject(renderParameters, renderState.DeviceIndex);
}
if (renderParameters.NeedsRefresh)
{
// Create constant buffer structure
CBPerObject cbPerObject = new CBPerObject();
cbPerObject.AccentuationFactor = m_accentuationFactor;
cbPerObject.Color = m_color.ToVector4();
cbPerObject.Opacity = m_opacity;
cbPerObject.World = Matrix4x4.Transpose(m_transform);
cbPerObject.BorderPart = m_borderPart;
cbPerObject.BorderMultiplyer = m_borderMultiplyer;
cbPerObject.ObjectScaling = m_scaling;//Vector3.TransformCoordinate(m_scaling, Matrix.RotationY(-m_rotation.Y));
// Update constant buffer
renderParameters.UpdateValues(renderState, cbPerObject);
renderParameters.NeedsRefresh = false;
}
renderParameters.Apply(renderState);
}
/// <summary>
/// Loads all resources of the object.
/// </summary>
/// <param name="device">Current graphics device.</param>
/// <param name="resourceDictionary">Current resource dicionary.</param>
public override void LoadResources(EngineDevice device, ResourceDictionary resourceDictionary)
{
m_localResources.AddObject(
resourceDictionary.GetResourceAndEnsureLoaded <LineRenderResources>(
LineRenderResources.RESOURCE_KEY,
() => new LineRenderResources()),
device.DeviceIndex);
}
/// <summary>
/// Loads all resources of the object.
/// </summary>
public override void LoadResources(EngineDevice device, ResourceDictionary resourceDictionary)
{
TexturePainterHelper newHelper = new TexturePainterHelper(m_resTexture);
m_texturePainterHelpers.AddObject(
newHelper,
device.DeviceIndex);
newHelper.LoadResources(resourceDictionary);
}
/// <summary>
/// Registers the given view on this layer.
/// </summary>
internal void RegisterView(int viewIndex, ViewInformation viewInformation, ResourceDictionary resourceDictionary)
{
ViewRelatedSceneLayerSubset newLayerViewSubset = new ViewRelatedSceneLayerSubset(this, viewInformation, resourceDictionary, viewIndex);
m_viewSubsets.AddObject(
newLayerViewSubset,
viewIndex);
newLayerViewSubset.RegisterObjectRange(m_sceneObjects.ToArray());
}
/// <summary>
/// Registers the given view on this layer.
/// </summary>
internal void RegisterView(int viewIndex, ViewInformation viewInformation, ResourceDictionary resourceDictionary)
{
var newLayerViewSubset = new ViewRelatedSceneLayerSubset(this, viewInformation, resourceDictionary, viewIndex);
_viewSubsets.AddObject(
newLayerViewSubset,
viewIndex);
newLayerViewSubset.RegisterObjectRange(this.ObjectsInternal);
}
/// <summary>
/// Gets the data object used for visibility checking.
/// </summary>
/// <param name="viewInfo">The VisibilityCheckData for this object for the given view.</param>
internal VisibilityCheckData GetVisibilityCheckData(ViewInformation viewInfo)
{
VisibilityCheckData checkData = m_visibilityData[viewInfo.ViewIndex];
if (checkData == null)
{
checkData = m_visibilityData.AddObject(
new VisibilityCheckData(),
viewInfo.ViewIndex);
}
return(checkData);
}
/// <summary>
/// Registers the given view on this scene object.
/// This method is meant to be called by RenderLoop class.
/// </summary>
/// <param name="viewInformation">The view to register.</param>
internal void RegisterView(ViewInformation viewInformation)
{
viewInformation.EnsureNotNull(nameof(viewInformation));
bool isFirstView = m_registeredViews.Count == 0;
InitializeResourceDictionaries(true);
// Register device on this scene if not done before
// -> This registration is forever, no deregister is made!
EngineDevice givenDevice = viewInformation.Device;
if (!m_registeredResourceDicts.HasObjectAt(givenDevice.DeviceIndex))
{
throw new SeeingSharpGraphicsException("ResourceDictionary of device " + givenDevice.AdapterDescription + " not loaded in this scene!");
}
// Check for already done registration of this view
// If there is any, then caller made an error
if (m_registeredViews.Contains(viewInformation))
{
throw new SeeingSharpGraphicsException("The given view is already registered on this scene!");
}
// Register this view on this scene and on all layers
int viewIndex = m_registeredViews.AddObject(viewInformation);
foreach (SceneLayer actLayer in m_sceneLayers)
{
actLayer.RegisterView(viewIndex, viewInformation, m_registeredResourceDicts[givenDevice.DeviceIndex]);
}
viewInformation.ViewIndex = viewIndex;
// Mark this scene for deletion if we don't have any other view registered
if (isFirstView)
{
GraphicsCore.Current.MainLoop.DeregisterSceneForUnload(this);
}
}
/// <summary>
/// Initializes this scene object.
/// </summary>
/// <param name="throwExceptionIfUnable"></param>
private void InitializeResourceDictionaries(bool throwExceptionIfUnable)
{
if (m_initialized)
{
return;
}
GraphicsCore.Touch();
if (!GraphicsCore.IsInitialized)
{
return;
}
// Create all ResourceDictionary objects
foreach (EngineDevice actDevice in GraphicsCore.Current.LoadedDevices)
{
m_registeredResourceDicts.AddObject(
new ResourceDictionary(actDevice),
actDevice.DeviceIndex);
}
m_initialized = true;
}
/// <summary>
/// Renders the scene to the given context.
/// </summary>
/// <param name="renderState">The current render state.</param>
internal void Render(RenderState renderState)
{
// Get current resource dictionary
ResourceDictionary resources = m_registeredResourceDicts[renderState.DeviceIndex];
if (resources == null)
{
throw new SeeingSharpGraphicsException("Unable to render scene: Resource dictionary for current device not found!");
}
// Apply default states on the device
DefaultResources defaultResource = resources.DefaultResources;
D3D11.DeviceContext deviceContext = renderState.Device.DeviceImmediateContextD3D11;
deviceContext.OutputMerger.BlendState = defaultResource.DefaultBlendState;
deviceContext.OutputMerger.DepthStencilState = defaultResource.DepthStencilStateDefault;
// Set initial rasterizer state
if (renderState.ViewInformation.ViewConfiguration.WireframeEnabled)
{
deviceContext.Rasterizer.State = defaultResource.RasterStateWireframe;
}
else
{
deviceContext.Rasterizer.State = defaultResource.RasterStateDefault;
}
// Get or create RenderParamters object on scene level
SceneRenderParameters renderParameters = m_renderParameters[renderState.DeviceIndex];
if (renderParameters == null)
{
renderParameters = resources.GetResourceAndEnsureLoaded <SceneRenderParameters>(
KEY_SCENE_RENDER_PARAMETERS,
() => new SceneRenderParameters());
m_renderParameters.AddObject(renderParameters, renderState.DeviceIndex);
}
// Update current view index
renderState.ViewIndex = m_registeredViews.IndexOf(renderState.ViewInformation);
// Update render parameters
renderParameters.UpdateValues(renderState, m_perFrameData);
using (renderState.PushScene(this, resources))
{
renderParameters.Apply(renderState);
//Prepare rendering on each layer
foreach (SceneLayer actLayer in m_sceneLayers)
{
actLayer.PrepareRendering(renderState);
}
//Render all layers in current order
foreach (SceneLayer actLayer in m_sceneLayers)
{
if (actLayer.CountObjects > 0)
{
actLayer.Render(renderState);
}
}
}
}