void CheckFunctionalityAvailability()
{
var audioAvailable = Settings.Audio.Enabled;
var videoAvailable = !(VideoViewModel.SelectedVideoSourceKind is NoVideoSourceProvider);
RecordCommand.RaiseCanExecuteChanged(audioAvailable || videoAvailable);
ScreenShotCommand.RaiseCanExecuteChanged(videoAvailable);
}
void CheckFunctionalityAvailability()
{
var audioAvailable = AudioViewModel.AudioSource.AudioAvailable;
var videoAvailable = VideoViewModel.SelectedVideoSourceKind != VideoSourceKind.NoVideo;
RecordCommand.RaiseCanExecuteChanged(audioAvailable || videoAvailable);
ScreenShotCommand.RaiseCanExecuteChanged(videoAvailable);
}
public ToolbarViewModel(Models models)
{
m_models = models;
PlayPauseCommand = new PlayPauseCommand(models);
ResetCommand = new ResetCommand(models);
SaveScreenShotCommand = new ScreenShotCommand(models);
ToggleCameraMovementCommand = new ActionCommand(() =>
models.Settings.AllowCameraMovement = !models.Settings.AllowCameraMovement);
EnterFreeFlightMode = new EnterFreeFlightMode(models);
OneIterationCommand = new PerformIterationsCommand(m_models, 1u);
NIterationsCommand = new PerformNIterationsCommand(m_models);
ContinuousSequenceRenderCommand = new RenderSequenceCommand(m_models, -1, true, false);
m_models.Renderer.PropertyChanged += RendererOnPropertyChanged;
m_models.Settings.PropertyChanged += SettingsOnPropertyChanged;
}
/* Performs one render loop iteration
* Blocks if no rendering, display update, or color picking is to be performed
*/
private void RenderLoop(object sender, EventArgs args)
{
m_models.Statusbar.UpdateMemory();
// Try to acquire the lock - if we're waiting, we're not rendering
if (m_shouldExit)
{
return;
}
m_models.Renderer.RenderLock.WaitOne();
// Check if we've been shut down
if (m_shouldExit)
{
return;
}
if (m_takeScreenshot)
{
string filename = ScreenShotCommand.ReplaceCommonFilenameTags(m_models, m_models.Settings.ScreenshotNamePattern);
if (m_denoisedScreenshot)
{
Core.render_save_denoised_radiance(Path.Combine(m_models.Settings.ScreenshotFolder, filename));
}
else
{
foreach (RenderTarget target in m_models.RenderTargetSelection.Targets)
{
if (target.Enabled)
{
Core.render_save_screenshot(Path.Combine(m_models.Settings.ScreenshotFolder, filename), target.Name, false);
}
if (target.VarianceEnabled)
{
Core.render_save_screenshot(Path.Combine(m_models.Settings.ScreenshotFolder, filename), target.Name, true);
}
}
}
m_takeScreenshot = false;
if (!m_models.Renderer.IsRendering || m_iterationsPerformed == 0)
{
m_models.Renderer.RenderLock.Reset();
}
}
else if (m_clearWorld)
{
// Only clear the world, do nothing else
Core.world_clear_all();
m_clearWorld = false;
m_models.Renderer.RenderLock.Reset();
m_auxiliaryIteration.Set();
}
else
{
if (!m_repaint)
{
UpdateRenderTargets();
if (m_models.Renderer.IsRendering)
{
if (m_incrementFrame)
{
m_incrementFrame = false;
// If we're at the end of the animation sequence we either loop or stop
if (m_models.World.AnimationFrameCurrent + 1u == m_models.World.AnimationFrameCount)
{
if (m_models.Renderer.LoopAnimation)
{
m_models.World.AnimationFrameCurrent = 0u;
m_iterationsPerformed = 0;
}
else
{
// If we stop, m_iterationsPerformed is our break condition further below
m_iterationsPerformed = m_models.Renderer.RemainingIterations;
m_wasLastAnimFrame = true;
}
}
else
{
++m_models.World.AnimationFrameCurrent;
m_iterationsPerformed = 0;
}
}
if (m_iterationsPerformed < m_models.Renderer.RemainingIterations || m_models.Renderer.RemainingIterations < 0)
{
// Update camera movements and enter the render DLL
if (m_models.Settings.AllowCameraMovement)
{
m_models.RendererCamera.MoveCamera();
}
m_models.Renderer.Iterate();
++m_iterationsPerformed;
}
else
{
if (m_models.Renderer.AnimationFrameComplete != null && !m_wasLastAnimFrame)
{
m_models.Renderer.AnimationFrameComplete();
}
// Check if we're animating
if (m_models.Renderer.RenderAnimation)
{
if (m_wasLastAnimFrame)
{
m_wasLastAnimFrame = false;
System.Windows.Application.Current.Dispatcher.Invoke(new Action(() => m_models.Renderer.IsRendering = false));
m_models.Renderer.RenderLock.Reset();
}
else
{
m_incrementFrame = true;
}
// Check if we need to reset the animation frame
/*if (m_models.Renderer.AnimationStart < m_models.World.AnimationFrameStart)
* {
* m_incrementFrame = true;
* } else
* {
* // Check if we should stop
* if(m_models.World.AnimationFrameCurrent > m_models.Renderer.AnimationEnd || m_wasLastAnimFrame)
* {
* m_wasLastAnimFrame = false;
* System.Windows.Application.Current.Dispatcher.Invoke(new Action(() => m_models.Renderer.IsRendering = false));
* m_models.Renderer.RenderLock.Reset();
* } else
* {
* m_incrementFrame = true;
* }
* }*/
}
else
{
// No more iterations left -> we're done
System.Windows.Application.Current.Dispatcher.Invoke(new Action(() => m_models.Renderer.IsRendering = false));
m_models.Renderer.RenderLock.Reset();
}
}
}
else
{
m_iterationsPerformed = 0;
m_models.Renderer.RenderLock.Reset();
}
// We release it to give the GUI a chance to block us (ie. rendering is supposed to pause/stop)
if (m_shouldExit)
{
return;
}
}
// Renew the display texture (we don't really care)
IntPtr targetTexture = IntPtr.Zero;
if (!Core.mufflon_get_target_image(m_renderTarget.Name, m_varianceTarget, out targetTexture))
{
throw new Exception(Core.core_get_dll_error());
}
m_models.Display.Repaint(!m_repaint);
if (m_repaint)
{
m_repaint = false;
if (!m_models.Renderer.IsRendering || m_iterationsPerformed == 0)
{
m_models.Renderer.RenderLock.Reset();
}
m_auxiliaryIteration.Set();
}
}
}
