protected internal override void BeginRecording(RecordingSession session)
{
if (cbSettings.renderTexture == null)
{
throw new Exception("No Render Texture object provided as source");
}
OutputHeight = cbSettings.OutputHeight;
OutputWidth = cbSettings.OutputWidth;
OutputRenderTexture = cbSettings.renderTexture;
bool needToFlip = cbSettings.FlipFinalOutput; // whether or not the recorder settings have the flip box checked
var movieRecorderSettings = session.settings as MovieRecorderSettings;
if (movieRecorderSettings != null)
{
bool encoderAlreadyFlips = movieRecorderSettings.encodersRegistered[movieRecorderSettings.encoderSelected].PerformsVerticalFlip;
needToFlip = needToFlip ? encoderAlreadyFlips : !encoderAlreadyFlips;
}
if (needToFlip)
{
m_VFlipper = new TextureFlipper();
}
}
protected internal override void BeginRecording(RecordingSession session)
{
OutputWidth = scSettings.OutputWidth;
OutputHeight = scSettings.OutputHeight;
int w, h;
GameViewSize.GetGameRenderSize(out w, out h);
if (w != OutputWidth || h != OutputHeight)
{
var size = GameViewSize.SetCustomSize(OutputWidth, OutputHeight) ?? GameViewSize.AddSize(OutputWidth, OutputHeight);
if (GameViewSize.modifiedResolutionCount == 0)
{
GameViewSize.BackupCurrentSize();
}
else
{
if (size != GameViewSize.currentSize)
{
Debug.LogError("Requesting a resolution change while a recorder's input has already requested one! Undefined behaviour.");
}
}
GameViewSize.modifiedResolutionCount++;
m_ModifiedResolution = true;
GameViewSize.SelectSize(size);
}
#if !UNITY_2019_1_OR_NEWER
// Before 2019.1, we capture synchronously into a Texture2D, so we don't need to create
// a RenderTexture that is used for reading asynchronously.
return;
#else
m_CaptureTexture = new RenderTexture(OutputWidth, OutputHeight, 0, RenderTextureFormat.ARGB32)
{
wrapMode = TextureWrapMode.Repeat
};
m_CaptureTexture.Create();
var movieRecorderSettings = session.settings as MovieRecorderSettings;
bool needToFlip = scSettings.FlipFinalOutput;
if (movieRecorderSettings != null)
{
bool encoderAlreadyFlips = movieRecorderSettings.encodersRegistered[movieRecorderSettings.encoderSelected].PerformsVerticalFlip;
needToFlip &= encoderAlreadyFlips;
}
if (needToFlip)
{
m_VFlipper = new TextureFlipper(false);
m_VFlipper.Init(m_CaptureTexture);
OutputRenderTexture = m_VFlipper.workTexture;
}
else
{
OutputRenderTexture = m_CaptureTexture;
}
#endif
}
public override void BeginRecording(RecordingSession session)
{
superShader = Shader.Find("Hidden/Volund/BS4SuperShader");
accumulateShader = Shader.Find("Hidden/BeautyShot/Accumulate");
normalizeShader = Shader.Find("Hidden/BeautyShot/Normalize");
if (rtsSettings.m_FlipFinalOutput)
{
m_VFlipper = new TextureFlipper();
}
// Below here is considered 'void StartVertice()', but we run it for directly "various reasons".
if (rtsSettings.m_OutputSize > rtsSettings.m_RenderSize)
{
throw new UnityException("Upscaling is not supported! Output dimension must be smaller or equal to render dimension.");
}
// Calculate aspect and render/output sizes
// Clamp size to 16K, which is the min always supported size in d3d11
// Force output to divisible by two as x264 doesn't approve of odd image dimensions.
var aspect = AspectRatioHelper.GetRealAR(rtsSettings.m_AspectRatio);
m_renderHeight = (int)rtsSettings.m_RenderSize;
m_renderWidth = Mathf.Min(16 * 1024, Mathf.RoundToInt(m_renderHeight * aspect));
outputHeight = (int)rtsSettings.m_OutputSize;
outputWidth = Mathf.Min(16 * 1024, Mathf.RoundToInt(outputHeight * aspect));
if (rtsSettings.m_ForceEvenSize)
{
outputWidth = (outputWidth + 1) & ~1;
outputHeight = (outputHeight + 1) & ~1;
}
m_superMaterial = new Material(superShader);
m_superMaterial.hideFlags = HideFlags.DontSave;
m_accumulateMaterial = new Material(accumulateShader);
m_accumulateMaterial.hideFlags = HideFlags.DontSave;
m_normalizeMaterial = new Material(normalizeShader);
m_normalizeMaterial.hideFlags = HideFlags.DontSave;
m_renderRT = new RenderTexture(m_renderWidth, m_renderHeight, 24, RenderTextureFormat.DefaultHDR, RenderTextureReadWrite.Linear);
m_renderRT.wrapMode = TextureWrapMode.Clamp;
for (int i = 0; i < 2; ++i)
{
m_accumulateRTs[i] = new RenderTexture(m_renderWidth, m_renderHeight, 0, RenderTextureFormat.DefaultHDR, RenderTextureReadWrite.Linear);
m_accumulateRTs[i].wrapMode = TextureWrapMode.Clamp;
m_accumulateRTs[i].Create();
}
var rt = new RenderTexture(outputWidth, outputHeight, 0, RenderTextureFormat.DefaultHDR, RenderTextureReadWrite.Linear);
rt.Create();
outputRT = rt;
m_samples = new Vector2[(int)rtsSettings.m_SuperSampling];
GenerateSamplesMSAA(m_samples, rtsSettings.m_SuperSampling);
m_hookedCameras = new List <HookedCamera>();
}
public override void BeginRecording(RecordingSession session)
{
if (settings360.flipFinalOutput)
{
m_VFlipper = new TextureFlipper();
}
outputWidth = settings360.outputWidth;
outputHeight = settings360.outputHeight;
}
protected internal override void BeginRecording(RecordingSession session)
{
if (settings360.FlipFinalOutput)
{
m_VFlipper = new TextureFlipper();
}
OutputWidth = settings360.OutputWidth;
OutputHeight = settings360.OutputHeight;
}
public override void BeginRecording(RecordingSession session)
{
outputWidth = scSettings.outputWidth;
outputHeight = scSettings.outputHeight;
int w, h;
GameViewSize.GetGameRenderSize(out w, out h);
if (w != outputWidth || h != outputHeight)
{
var size = GameViewSize.SetCustomSize(outputWidth, outputHeight) ?? GameViewSize.AddSize(outputWidth, outputHeight);
if (GameViewSize.modifiedResolutionCount == 0)
{
GameViewSize.BackupCurrentSize();
}
else
{
if (size != GameViewSize.currentSize)
{
Debug.LogError("Requestion a resultion change while a recorder's input has already requested one! Undefined behaviour.");
}
}
GameViewSize.modifiedResolutionCount++;
m_ModifiedResolution = true;
GameViewSize.SelectSize(size);
}
#if !UNITY_2019_1_OR_NEWER
// Before 2019.1, we capture syncrhonously into a Texture2D, so we don't need to create
// a RenderTexture that is used for reading asynchronously.
return;
#else
m_CaptureTexture = new RenderTexture(outputWidth, outputHeight, 0, RenderTextureFormat.ARGB32)
{
wrapMode = TextureWrapMode.Repeat
};
m_CaptureTexture.Create();
if (scSettings.flipFinalOutput)
{
m_VFlipper = new TextureFlipper(false);
m_VFlipper.Init(m_CaptureTexture);
outputRT = m_VFlipper.workTexture;
}
else
{
outputRT = m_CaptureTexture;
}
#endif
}
protected internal override void BeginRecording(RecordingSession session)
{
if (cbSettings.renderTexture == null)
{
throw new Exception("No Render Texture object provided as source");
}
OutputHeight = cbSettings.OutputHeight;
OutputWidth = cbSettings.OutputWidth;
OutputRenderTexture = cbSettings.renderTexture;
if (cbSettings.FlipFinalOutput)
{
m_VFlipper = new TextureFlipper();
}
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
if (m_ModifiedResolution)
{
GameViewSize.modifiedResolutionCount--;
if (GameViewSize.modifiedResolutionCount == 0)
{
GameViewSize.RestoreSize();
}
}
}
m_VFlipper?.Dispose();
m_VFlipper = null;
base.Dispose(disposing);
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
if (m_ModifiedResolution)
{
if (GameViewSize.modifiedResolutionCount > 0)
{
GameViewSize.modifiedResolutionCount--; // don't allow negative if called twice
}
if (GameViewSize.modifiedResolutionCount == 0)
{
GameViewSize.RestoreSize();
}
}
}
m_VFlipper?.Dispose();
m_VFlipper = null;
base.Dispose(disposing);
}
public override void BeginRecording(RecordingSession session)
{
if (cbSettings.m_FlipFinalOutput)
{
m_VFlipper = new TextureFlipper();
}
m_quad = CreateFullscreenQuad();
switch (cbSettings.source)
{
case EImageSource.ActiveCameras:
case EImageSource.MainCamera:
case EImageSource.TaggedCamera:
{
int screenWidth = Screen.width;
int screenHeight = Screen.height;
#if UNITY_EDITOR
switch (cbSettings.m_OutputSize)
{
case EImageDimension.Window:
{
GameViewSize.GetGameRenderSize(out screenWidth, out screenHeight);
outputWidth = screenWidth;
outputHeight = screenHeight;
if (cbSettings.m_ForceEvenSize)
{
outputWidth = (outputWidth + 1) & ~1;
outputHeight = (outputHeight + 1) & ~1;
}
break;
}
default:
{
outputHeight = (int)cbSettings.m_OutputSize;
outputWidth = (int)(outputHeight * AspectRatioHelper.GetRealAR(cbSettings.m_AspectRatio));
if (cbSettings.m_ForceEvenSize)
{
outputWidth = (outputWidth + 1) & ~1;
outputHeight = (outputHeight + 1) & ~1;
}
var size = GameViewSize.SetCustomSize(outputWidth, outputHeight);
if (size == null)
{
size = GameViewSize.AddSize(outputWidth, outputHeight);
}
if (GameViewSize.m_ModifiedResolutionCount == 0)
{
GameViewSize.BackupCurrentSize();
}
else
{
if (size != GameViewSize.currentSize)
{
Debug.LogError("Requestion a resultion change while a recorder's input has already requested one! Undefined behaviour.");
}
}
GameViewSize.m_ModifiedResolutionCount++;
m_ModifiedResolution = true;
GameViewSize.SelectSize(size);
break;
}
}
#endif
break;
}
default:
throw new ArgumentOutOfRangeException();
}
if (cbSettings.m_CaptureUI)
{
var uiGO = new GameObject();
uiGO.name = "UICamera";
uiGO.transform.parent = session.m_RecorderGO.transform;
m_UICamera = uiGO.AddComponent <Camera>();
m_UICamera.cullingMask = 1 << 5;
m_UICamera.clearFlags = CameraClearFlags.Depth;
m_UICamera.renderingPath = RenderingPath.DeferredShading;
m_UICamera.targetTexture = outputRT;
m_UICamera.enabled = false;
}
}
public override void BeginRecording(RecordingSession session)
{
if (cbSettings.flipFinalOutput)
{
m_VFlipper = new TextureFlipper();
}
if (Options.useCameraCaptureCallbacks)
{
m_InputStrategy = new CaptureCallbackInputStrategy(cbSettings.allowTransparency);
}
else
{
m_InputStrategy = new CameraCommandBufferInputStrategy(cbSettings.allowTransparency);
}
switch (cbSettings.source)
{
case ImageSource.ActiveCamera:
case ImageSource.MainCamera:
case ImageSource.TaggedCamera:
{
outputWidth = cbSettings.outputWidth;
outputHeight = cbSettings.outputHeight;
if (cbSettings.outputImageHeight != ImageHeight.Window)
{
var size = GameViewSize.SetCustomSize(outputWidth, outputHeight);
if (size == null)
{
size = GameViewSize.AddSize(outputWidth, outputHeight);
}
if (GameViewSize.modifiedResolutionCount == 0)
{
GameViewSize.BackupCurrentSize();
}
else
{
if (size != GameViewSize.currentSize)
{
Debug.LogError("Requesting a resolution change while a recorder's input has already requested one! Undefined behaviour.");
}
}
GameViewSize.modifiedResolutionCount++;
m_ModifiedResolution = true;
GameViewSize.SelectSize(size);
}
break;
}
default:
throw new ArgumentOutOfRangeException();
}
if (cbSettings.captureUI)
{
var uiGO = new GameObject();
uiGO.name = "UICamera";
uiGO.transform.parent = session.recorderGameObject.transform;
m_UICamera = uiGO.AddComponent <Camera>();
m_UICamera.cullingMask = 1 << 5;
m_UICamera.clearFlags = CameraClearFlags.Depth;
m_UICamera.renderingPath = RenderingPath.DeferredShading;
m_UICamera.targetTexture = outputRT;
m_UICamera.enabled = false;
}
}
protected internal override void BeginRecording(RecordingSession session)
{
superShader = Shader.Find("Hidden/Volund/BS4SuperShader");
accumulateShader = Shader.Find("Hidden/BeautyShot/Accumulate");
normalizeShader = Shader.Find("Hidden/BeautyShot/Normalize");
var movieRecorderSettings = session.settings as MovieRecorderSettings;
bool needToFlip = rtsSettings.FlipFinalOutput;
if (movieRecorderSettings != null)
{
bool encoderAlreadyFlips = movieRecorderSettings.encodersRegistered[movieRecorderSettings.encoderSelected].PerformsVerticalFlip;
needToFlip = needToFlip ? encoderAlreadyFlips : !encoderAlreadyFlips;
}
if (needToFlip)
{
m_VFlipper = new TextureFlipper();
}
var h = rtsSettings.OutputHeight;
// Below here is considered 'void Start()', but we run it for directly "various reasons".
if (h > rtsSettings.RenderHeight)
{
throw new UnityException("Upscaling is not supported! Output dimension must be smaller or equal to render dimension.");
}
// Calculate aspect and render/output sizes
// Clamp size to 16K, which is the min always supported size in d3d11
// Force output to divisible by two as x264 doesn't approve of odd image dimensions.
//var aspect = rtsSettings.m_OutputAspect.GetAspect();
m_renderHeight = Mathf.Min(16 * 1024, Mathf.RoundToInt(rtsSettings.RenderHeight)); //rtsSettings.renderHeight; //m_RenderSize;
m_renderWidth = Mathf.Min(16 * 1024, Mathf.RoundToInt(rtsSettings.RenderWidth));
OutputHeight = h;
OutputWidth = rtsSettings.OutputWidth;
m_superMaterial = new Material(superShader)
{
hideFlags = HideFlags.DontSave
};
m_accumulateMaterial = new Material(accumulateShader)
{
hideFlags = HideFlags.DontSave
};
m_normalizeMaterial = new Material(normalizeShader)
{
hideFlags = HideFlags.DontSave
};
m_renderRT = new RenderTexture(m_renderWidth, m_renderHeight, 24, RenderTextureFormat.DefaultHDR,
RenderTextureReadWrite.Linear)
{
wrapMode = TextureWrapMode.Clamp
};
for (int i = 0; i < 2; ++i)
{
m_accumulateRTs[i] = new RenderTexture(m_renderWidth, m_renderHeight, 0, RenderTextureFormat.DefaultHDR, RenderTextureReadWrite.Linear)
{
wrapMode = TextureWrapMode.Clamp
};
m_accumulateRTs[i].Create();
}
var rt = new RenderTexture(OutputWidth, OutputHeight, 0, RenderTextureFormat.DefaultHDR, RenderTextureReadWrite.Linear);
rt.Create();
OutputRenderTexture = rt;
m_samples = new Vector2[(int)rtsSettings.SuperSampling];
GenerateSamplesMSAA(m_samples, rtsSettings.SuperSampling);
m_hookedCameras = new List <HookedCamera>();
}
