void OnEnable()
{
m_camera = GetComponent <Camera>();
if (!CheckSupport())
{
enabled = false;
return;
}
if (WorkerThreads <= 0)
{
WorkerThreads = Mathf.Max(Environment.ProcessorCount / 2, 1); // half of CPU threads; non-busy idle
}
m_workerThreadPool = new AmplifyMotion.WorkerThreadPool();
m_workerThreadPool.InitializeAsyncUpdateThreads(WorkerThreads, SystemThreadPool);
m_starting = true;
if (!CreateMaterials())
{
Debug.LogError("[AmplifyMotion] Failed loading or compiling necessary shaders. Please try reinstalling Amplify Motion or contact [email protected]");
enabled = false;
return;
}
if (AutoRegisterObjs)
{
UpdateActiveObjects();
}
InitializeCameras();
UpdateRenderTextures(true);
m_linkedCameras.TryGetValue(m_camera, out m_baseCamera);
if (m_baseCamera == null)
{
Debug.LogError("[AmplifyMotion] Failed setting up Base Camera. Please contact [email protected]");
enabled = false;
return;
}
if (m_currentPostProcess != null)
{
m_currentPostProcess.enabled = true;
}
m_qualityLevel = QualityLevel;
}
internal override void RenderVectors(Camera camera, float scale, AmplifyMotion.Quality quality)
{
Profiler.BeginSample("Particle.Render");
if (m_initialized && !m_error && m_renderer.isVisible)
{
bool mask = (m_owner.Instance.CullingMask & (1 << m_obj.gameObject.layer)) != 0;
if (!mask || (mask && m_moved))
{
const float rcp255 = 1 / 255.0f;
int objectId = mask ? m_owner.Instance.GenerateObjectId(m_obj.gameObject) : 255;
Shader.SetGlobalFloat("_AM_OBJECT_ID", objectId * rcp255);
Shader.SetGlobalFloat("_AM_MOTION_SCALE", mask ? scale : 0);
int qualityPass = (quality == AmplifyMotion.Quality.Mobile) ? 0 : 2;
for (int i = 0; i < m_sharedMaterials.Length; i++)
{
MaterialDesc matDesc = m_sharedMaterials[i];
int pass = qualityPass + (matDesc.coverage ? 1 : 0);
if (matDesc.coverage)
{
m_owner.Instance.SolidVectorsMaterial.mainTexture = matDesc.material.mainTexture;
if (matDesc.cutoff)
{
m_owner.Instance.SolidVectorsMaterial.SetFloat("_Cutoff", matDesc.material.GetFloat("_Cutoff"));
}
}
var enumerator = m_particleDict.GetEnumerator();
while (enumerator.MoveNext())
{
KeyValuePair <uint, Particle> pair = enumerator.Current;
Matrix4x4 prevModelViewProj = m_owner.PrevViewProjMatrixRT * pair.Value.prevLocalToWorld;
Shader.SetGlobalMatrix("_AM_MATRIX_PREV_MVP", prevModelViewProj);
if (m_owner.Instance.SolidVectorsMaterial.SetPass(pass))
{
Graphics.DrawMeshNow(m_mesh, pair.Value.currLocalToWorld, i);
}
}
}
}
}
Profiler.EndSample();
}
void OnPostRender()
{
bool qualityChanged = (QualityLevel != m_qualityLevel);
if (qualityChanged)
{
CreateMaterials();
m_qualityLevel = QualityLevel;
}
UpdateRenderTextures(qualityChanged);
RenderBuffer prevColor = Graphics.activeColorBuffer;
RenderBuffer prevDepth = Graphics.activeDepthBuffer;
bool cameraMotion = (CameraMotionMult > float.Epsilon);
m_motionRT.DiscardContents();
Graphics.SetRenderTarget(m_motionRT);
GL.Clear(true, !cameraMotion || m_starting, Color.black);
Shader.SetGlobalFloat("_EFLOW_MIN_VELOCITY", MinVelocity);
Shader.SetGlobalFloat("_EFLOW_MAX_VELOCITY", MaxVelocity);
Shader.SetGlobalFloat("_EFLOW_RCP_TOTAL_VELOCITY", 1.0f / (MaxVelocity - MinVelocity));
float rcpDepthThreshold = (DepthThreshold > float.Epsilon) ? 1.0f / DepthThreshold : float.MaxValue;
Shader.SetGlobalVector("_EFLOW_DEPTH_THRESHOLD", new Vector2(DepthThreshold, rcpDepthThreshold));
m_motionScaleNorm = (m_deltaTime >= float.Epsilon) ? MotionScale * (1.0f / m_deltaTime) : 0;
m_fixedMotionScaleNorm = (m_fixedDeltaTime >= float.Epsilon) ? MotionScale * (1.0f / m_fixedDeltaTime) : 0;
float objectScale = !m_starting ? m_motionScaleNorm : 0;
float objectFixedScale = !m_starting ? m_fixedMotionScaleNorm : 0;
if (cameraMotion)
{
float cameraMotionScaleNorm = (m_deltaTime >= float.Epsilon) ? MotionScale * CameraMotionMult * (1.0f / m_deltaTime) : 0;
float cameraScale = !m_starting ? cameraMotionScaleNorm : 0;
RenderReprojectionVectors(m_motionRT, cameraScale);
}
ResetObjectId();
m_baseCamera.RenderVectors(objectScale, objectFixedScale, QualityLevel);
m_starting = false;
Graphics.SetRenderTarget(prevColor, prevDepth);
}
public void RenderVectors(CommandBuffer renderCB, float scale, float fixedScale, AmplifyMotion.Quality quality)
#endif
{
if (!m_initialized)
{
Initialize();
}
// For some reason Unity's own values weren't working correctly on Windows/OpenGL
float near = m_camera.nearClipPlane;
float far = m_camera.farClipPlane;
Vector4 zparam;
if (AmplifyMotionEffectBase.IsD3D)
{
zparam.x = 1.0f - far / near;
zparam.y = far / near;
}
else
{
// OpenGL
zparam.x = (1.0f - far / near) / 2.0f;
zparam.y = (1.0f + far / near) / 2.0f;
}
zparam.z = zparam.x / far;
zparam.w = zparam.y / far;
Shader.SetGlobalVector("_AM_ZBUFFER_PARAMS", zparam);
if (m_affectedObjectsChanged)
{
UpdateAffectedObjects();
}
for (int i = 0; i < m_affectedObjects.Length; i++)
{
// don't render objects excluded via camera culling mask
if ((m_camera.cullingMask & (1 << m_affectedObjects[i].gameObject.layer)) != 0)
{
#if UNITY_4
m_affectedObjects[i].OnRenderVectors(m_camera, m_affectedObjects[i].FixedStep ? fixedScale : scale, quality);
#else
m_affectedObjects[i].OnRenderVectors(m_camera, renderCB, m_affectedObjects[i].FixedStep ? fixedScale : scale, quality);
#endif
}
}
}
void OnEnable()
{
m_camera = GetComponent <Camera>();
if (!CheckSupport())
{
enabled = false;
return;
}
InitializeThreadPool();
m_starting = true;
if (!CreateMaterials())
{
Debug.LogError("[AmplifyMotion] Failed loading or compiling necessary shaders. Please try reinstalling Amplify Motion or contact [email protected]");
enabled = false;
return;
}
if (AutoRegisterObjs)
{
UpdateActiveObjects();
}
InitializeCameras();
InitializeCommandBuffers();
UpdateRenderTextures(true);
m_linkedCameras.TryGetValue(m_camera, out m_baseCamera);
if (m_baseCamera == null)
{
Debug.LogError("[AmplifyMotion] Failed setting up Base Camera. Please contact [email protected]");
enabled = false;
return;
}
if (m_currentPostProcess != null)
{
m_currentPostProcess.enabled = true;
}
m_qualityLevel = QualityLevel;
}
void OnEnable()
{
if (!CheckSupport())
{
enabled = false;
return;
}
if (workerThreads <= 0)
{
workerThreads = Mathf.Max(Environment.ProcessorCount / 2, 1); // half of CPU threads; non-busy idle
}
m_workerThreadPool = new AmplifyMotion.WorkerThreadPool();
m_workerThreadPool.InitializeAsyncUpdateThreads(workerThreads);
m_starting = true;
CreateMaterials();
if (AutoRegisterObjs)
{
UpdateActiveObjects();
}
InitializeCameras();
UpdateRenderTextures();
m_linkedCameras.TryGetValue(this.GetComponent <Camera>(), out m_baseCamera);
if (m_baseCamera == null)
{
Debug.LogError("[AmplifyMotion] Failed miserably during initialization. Disabling.");
enabled = false;
return;
}
if (m_currentPostProcess != null)
{
m_currentPostProcess.enabled = true;
}
m_qualityLevel = QualityLevel;
}
void UpdateRenderTextures()
{
Camera camera = GetComponent <Camera>();
int screenWidth = Mathf.FloorToInt(camera.pixelWidth + 0.5f);
int screenHeight = Mathf.FloorToInt(camera.pixelHeight + 0.5f);
if (QualityLevel == AmplifyMotion.Quality.Mobile)
{
screenWidth /= 2;
screenHeight /= 2;
}
if (m_width != screenWidth || m_height != screenHeight || QualityLevel != m_qualityLevel)
{
m_qualityLevel = QualityLevel;
m_width = screenWidth;
m_height = screenHeight;
DestroyRenderTextures();
}
RenderTextureFormat auxRGB = RenderTextureFormat.ARGB32;
RenderTextureReadWrite auxRW = RenderTextureReadWrite.Linear;
RenderTextureFormat colRGB = RenderTextureFormat.ARGB32;
RenderTextureReadWrite colRW = RenderTextureReadWrite.Default;
SafeCreateRenderTexture(ref m_motionRT, "Motion", 24, auxRGB, auxRW, FilterMode.Point);
SafeCreateRenderTexture(ref m_combinedRT, "Combined", 0, colRGB, colRW, FilterMode.Point);
if (QualityLevel == AmplifyMotion.Quality.Mobile)
{
SafeCreateRenderTexture(ref m_blurRT, "Blur", 0, colRGB, colRW, FilterMode.Bilinear);
}
if (m_dummyTex == null)
{
m_dummyTex = new Texture2D(4, 4, TextureFormat.ARGB32, false, true);
m_dummyTex.wrapMode = TextureWrapMode.Clamp;
m_dummyTex.hideFlags = HideFlags.DontSave;
}
}
internal override void RenderVectors(Camera camera, float scale, AmplifyMotion.Quality quality)
{
Profiler.BeginSample("Skinned.Render");
if (m_initialized && !m_error && m_renderer.isVisible)
{
WaitForAsyncUpdate();
m_clonedMesh.vertices = m_currVertices;
m_clonedMesh.normals = m_prevVertices;
const float rcp255 = 1 / 255.0f;
int objectId = m_mask ? m_owner.Instance.GenerateObjectId(m_obj.gameObject) : 255;
Shader.SetGlobalFloat("_EFLOW_OBJECT_ID", objectId * rcp255);
Shader.SetGlobalFloat("_EFLOW_MOTION_SCALE", m_mask ? scale : 0);
int qualityPass = (quality == AmplifyMotion.Quality.Mobile) ? 0 : 2;
for (int i = 0; i < m_sharedMaterials.Length; i++)
{
MaterialDesc matDesc = m_sharedMaterials[i];
int pass = qualityPass + (matDesc.coverage ? 1 : 0);
if (matDesc.coverage)
{
m_owner.Instance.SkinnedVectorsMaterial.mainTexture = matDesc.material.mainTexture;
if (matDesc.cutoff)
{
m_owner.Instance.SkinnedVectorsMaterial.SetFloat("_Cutoff", matDesc.material.GetFloat("_Cutoff"));
}
}
if (m_owner.Instance.SkinnedVectorsMaterial.SetPass(pass))
{
Graphics.DrawMeshNow(m_clonedMesh, m_obj.transform.localToWorldMatrix, i);
}
}
}
Profiler.EndSample();
}
void OnEnable()
{
if (!CheckSupport())
{
enabled = false;
return;
}
if (workerThreads <= 0)
{
workerThreads = Environment.ProcessorCount;
}
m_workerThreadPool = new AmplifyMotion.WorkerThreadPool();
m_workerThreadPool.InitializeAsyncUpdateThreads(workerThreads);
m_starting = true;
CreateMaterials();
if (AutoRegisterObjs)
{
UpdateActiveObjects();
}
InitializeCameras();
UpdateRenderTextures();
m_linkedCameras.TryGetValue(this.GetComponent <Camera>(), out m_baseCamera);
if (m_currentPostProcess != null)
{
m_currentPostProcess.enabled = true;
}
m_qualityLevel = QualityLevel;
}
public void RenderVectors(float scale, float fixedScale, AmplifyMotion.Quality quality)
internal override void RenderVectors(Camera camera, CommandBuffer renderCB, float scale, AmplifyMotion.Quality quality)
{
if (m_initialized && !m_error && m_renderer.isVisible)
{
Profiler.BeginSample("Skinned.Update");
if (!m_useFallback)
{
if (!m_useGPU)
{
WaitForAsyncUpdate();
}
}
Profiler.EndSample();
Profiler.BeginSample("Skinned.Render");
if (!m_useGPU)
{
if (!m_useFallback)
{
m_clonedMesh.vertices = m_currVertices;
}
m_clonedMesh.normals = m_prevVertices;
}
const float rcp255 = 1 / 255.0f;
bool mask = (m_owner.Instance.CullingMask & (1 << m_obj.gameObject.layer)) != 0;
int objectId = mask ? m_owner.Instance.GenerateObjectId(m_obj.gameObject) : 255;
Matrix4x4 prevModelViewProj;
if (m_obj.FixedStep)
{
prevModelViewProj = m_owner.PrevViewProjMatrixRT * m_currLocalToWorld;
}
else
{
prevModelViewProj = m_owner.PrevViewProjMatrixRT * m_prevLocalToWorld;
}
renderCB.SetGlobalMatrix("_AM_MATRIX_PREV_MVP", prevModelViewProj);
renderCB.SetGlobalFloat("_AM_OBJECT_ID", objectId * rcp255);
renderCB.SetGlobalFloat("_AM_MOTION_SCALE", mask ? scale : 0);
if (m_useGPU)
{
#if !UNITY_4
Vector4 vertexTexelSize = new Vector4(1.0f / m_gpuVertexTexWidth, 1.0f / m_gpuVertexTexHeight, m_gpuVertexTexWidth, m_gpuVertexTexHeight);
renderCB.SetGlobalVector("_AM_VERTEX_TEXEL_SIZE", vertexTexelSize);
renderCB.SetGlobalVector("_AM_VERTEX_TEXEL_HALFSIZE", vertexTexelSize * 0.5f);
renderCB.SetGlobalTexture("_AM_PREV_VERTEX_TEX", m_gpuPrevVertices);
renderCB.SetGlobalTexture("_AM_CURR_VERTEX_TEX", m_gpuCurrVertices);
#endif
}
int hardwarePass = m_useGPU ? 4 : 0;
int qualityPass = (quality == AmplifyMotion.Quality.Mobile) ? 0 : 2;
int basePass = hardwarePass + qualityPass;
for (int i = 0; i < m_sharedMaterials.Length; i++)
{
MaterialDesc matDesc = m_sharedMaterials[i];
int pass = basePass + (matDesc.coverage ? 1 : 0);
if (matDesc.coverage)
{
Texture mainTex = matDesc.material.mainTexture;
if (mainTex != null)
{
matDesc.propertyBlock.SetTexture("_MainTex", mainTex);
}
if (matDesc.cutoff)
{
matDesc.propertyBlock.SetFloat("_Cutoff", matDesc.material.GetFloat("_Cutoff"));
}
}
renderCB.DrawMesh(m_clonedMesh, m_currLocalToWorld, m_owner.Instance.SkinnedVectorsMaterial, i, pass, matDesc.propertyBlock);
}
Profiler.EndSample();
}
}
internal override void RenderVectors(Camera camera, CommandBuffer renderCB, float scale, AmplifyMotion.Quality quality)
{
if (m_initialized && !m_error && m_meshRenderer.isVisible)
{
Profiler.BeginSample("Solid.Render");
bool mask = (m_owner.Instance.CullingMask & (1 << m_obj.gameObject.layer)) != 0;
if (!mask || (mask && m_moved))
{
const float rcp255 = 1 / 255.0f;
int objectId = mask ? m_owner.Instance.GenerateObjectId(m_obj.gameObject) : 255;
float cameraMotionScale = mask ? m_owner.Instance.CameraMotionMult * scale : 0;
float objectMotionScale = mask ? m_owner.Instance.ObjectMotionMult * scale : 0;
renderCB.SetGlobalMatrix("_AM_MATRIX_PREV_M", ( Matrix4x4 )m_prevLocalToWorld);
renderCB.SetGlobalMatrix("_AM_MATRIX_CURR_M", ( Matrix4x4 )m_currLocalToWorld);
renderCB.SetGlobalVector("_AM_MOTION_PARAMS", new Vector4(cameraMotionScale, objectMotionScale, objectId * rcp255, 0));
int qualityPass = (quality == AmplifyMotion.Quality.Mobile) ? 0 : 2;
for (int i = 0; i < m_sharedMaterials.Length; i++)
{
MaterialDesc matDesc = m_sharedMaterials[i];
int pass = qualityPass + (matDesc.coverage ? 1 : 0);
if (matDesc.coverage)
{
Texture mainTex = matDesc.material.mainTexture;
if (mainTex != null)
{
matDesc.propertyBlock.SetTexture("_MainTex", mainTex);
}
if (matDesc.cutoff)
{
matDesc.propertyBlock.SetFloat("_Cutoff", matDesc.material.GetFloat("_Cutoff"));
}
}
renderCB.DrawMesh(m_mesh, m_transform.localToWorldMatrix, m_owner.Instance.SolidVectorsMaterial, i, pass, matDesc.propertyBlock);
}
}
Profiler.EndSample();
}
}
internal override void RenderVectors(Camera camera, float scale, AmplifyMotion.Quality quality)
{
Profiler.BeginSample("Cloth.Render");
if (m_initialized && !m_error && m_renderer.isVisible)
{
const float rcp255 = 1 / 255.0f;
bool mask = (m_owner.Instance.CullingMask & (1 << m_obj.gameObject.layer)) != 0;
int objectId = mask ? m_owner.Instance.GenerateObjectId(m_obj.gameObject) : 255;
Vector3[] clothVertices = m_cloth.vertices;
for (int i = 0; i < m_targetVertexCount; i++)
{
m_currVertices[i] = clothVertices[m_targetRemap[i]];
}
if (m_starting || !m_wasVisible)
{
Array.Copy(m_currVertices, m_prevVertices, m_targetVertexCount);
}
m_clonedMesh.vertices = m_currVertices;
m_clonedMesh.normals = m_prevVertices;
Matrix4x4 prevModelViewProj;
if (m_obj.FixedStep)
{
prevModelViewProj = m_owner.PrevViewProjMatrixRT * m_currLocalToWorld;
}
else
{
prevModelViewProj = m_owner.PrevViewProjMatrixRT * m_prevLocalToWorld;
}
Shader.SetGlobalMatrix("_EFLOW_MATRIX_PREV_MVP", prevModelViewProj);
Shader.SetGlobalFloat("_EFLOW_OBJECT_ID", objectId * rcp255);
Shader.SetGlobalFloat("_EFLOW_MOTION_SCALE", mask ? scale : 0);
int qualityPass = (quality == AmplifyMotion.Quality.Mobile) ? 0 : 2;
for (int i = 0; i < m_sharedMaterials.Length; i++)
{
MaterialDesc matDesc = m_sharedMaterials[i];
int pass = qualityPass + (matDesc.coverage ? 1 : 0);
if (matDesc.coverage)
{
m_owner.Instance.ClothVectorsMaterial.mainTexture = matDesc.material.mainTexture;
if (matDesc.cutoff)
{
m_owner.Instance.ClothVectorsMaterial.SetFloat("_Cutoff", matDesc.material.GetFloat("_Cutoff"));
}
}
if (m_owner.Instance.ClothVectorsMaterial.SetPass(pass))
{
#if UNITY_4
Graphics.DrawMeshNow(m_clonedMesh, Matrix4x4.identity, i);
#else
Graphics.DrawMeshNow(m_clonedMesh, Matrix4x4.TRS(m_obj.transform.position, m_obj.transform.rotation, Vector3.one), i);
#endif
}
}
}
Profiler.EndSample();
}
void OnPostRender()
{
bool qualityChanged = (QualityLevel != m_qualityLevel);
m_qualityLevel = QualityLevel;
UpdateRenderTextures(qualityChanged);
ResetObjectId();
bool cameraMotion = (CameraMotionMult > float.Epsilon);
bool clearColor = !cameraMotion || m_starting;
float rcpDepthThreshold = (DepthThreshold > float.Epsilon) ? 1.0f / DepthThreshold : float.MaxValue;
m_motionScaleNorm = (m_deltaTime >= float.Epsilon) ? MotionScale * (1.0f / m_deltaTime) : 0;
m_fixedMotionScaleNorm = (m_fixedDeltaTime >= float.Epsilon) ? MotionScale * (1.0f / m_fixedDeltaTime) : 0;
float objectScale = !m_starting ? m_motionScaleNorm : 0;
float objectFixedScale = !m_starting ? m_fixedMotionScaleNorm : 0;
Shader.SetGlobalFloat("_AM_MIN_VELOCITY", MinVelocity);
Shader.SetGlobalFloat("_AM_MAX_VELOCITY", MaxVelocity);
Shader.SetGlobalFloat("_AM_RCP_TOTAL_VELOCITY", 1.0f / (MaxVelocity - MinVelocity));
Shader.SetGlobalVector("_AM_DEPTH_THRESHOLD", new Vector2(DepthThreshold, rcpDepthThreshold));
// pre-render base camera
m_motionRT.DiscardContents();
m_baseCamera.PreRenderVectors(m_motionRT, clearColor, rcpDepthThreshold);
// pre-render overlay cameras
for (int i = 0; i < m_linkedCameraValues.Length; i++)
{
AmplifyMotionCamera cam = m_linkedCameraValues[i];
if (cam != null && cam.Overlay && cam.isActiveAndEnabled)
{
cam.PreRenderVectors(m_motionRT, clearColor, rcpDepthThreshold);
cam.RenderVectors(objectScale, objectFixedScale, QualityLevel);
}
}
if (cameraMotion)
{
float cameraMotionScaleNorm = (m_deltaTime >= float.Epsilon) ? MotionScale * CameraMotionMult * (1.0f / m_deltaTime) : 0;
float cameraScale = !m_starting ? cameraMotionScaleNorm : 0;
m_motionRT.DiscardContents();
m_baseCamera.RenderReprojectionVectors(m_motionRT, cameraScale);
}
// render base camera
m_baseCamera.RenderVectors(objectScale, objectFixedScale, QualityLevel);
// render overlay cameras
for (int i = 0; i < m_linkedCameraValues.Length; i++)
{
AmplifyMotionCamera cam = m_linkedCameraValues[i];
if (cam != null && cam.Overlay && cam.isActiveAndEnabled)
{
cam.RenderVectors(objectScale, objectFixedScale, QualityLevel);
}
}
m_starting = false;
}
internal void OnRenderVectors(Camera camera, CommandBuffer renderCB, float scale, AmplifyMotion.Quality quality)
{
AmplifyMotion.MotionState state;
if (m_states.TryGetValue(camera, out state))
{
if (!state.Error)
{
state.RenderVectors(camera, renderCB, scale, quality);
if (m_resetAtFrame > 0 && Time.frameCount >= m_resetAtFrame)
{
m_resetAtFrame = -1;
}
}
}
}
internal void OnRenderVectors(Camera camera, CommandBuffer renderCB, float scale, AmplifyMotion.Quality quality)
#endif
{
AmplifyMotion.MotionState state;
if (m_states.TryGetValue(camera, out state))
{
if (!state.Error)
{
#if UNITY_4
state.RenderVectors(camera, scale, quality);
#else
state.RenderVectors(camera, renderCB, scale, quality);
#endif
}
}
}
void OnPostRender()
{
bool qualityChanged = (QualityLevel != m_qualityLevel);
if (qualityChanged)
{
CreateMaterials();
m_qualityLevel = QualityLevel;
}
UpdateRenderTextures(qualityChanged);
ResetObjectId();
#if UNITY_4
RenderBuffer prevColor = Graphics.activeColorBuffer;
RenderBuffer prevDepth = Graphics.activeDepthBuffer;
#endif
bool cameraMotion = (CameraMotionMult > float.Epsilon);
bool clearColor = !cameraMotion || m_starting;
float rcpDepthThreshold = (DepthThreshold > float.Epsilon) ? 1.0f / DepthThreshold : float.MaxValue;
m_motionScaleNorm = (m_deltaTime >= float.Epsilon) ? MotionScale * (1.0f / m_deltaTime) : 0;
m_fixedMotionScaleNorm = (m_fixedDeltaTime >= float.Epsilon) ? MotionScale * (1.0f / m_fixedDeltaTime) : 0;
float objectScale = !m_starting ? m_motionScaleNorm : 0;
float objectFixedScale = !m_starting ? m_fixedMotionScaleNorm : 0;
DiscardContents(m_motionRT);
#if UNITY_4
Graphics.SetRenderTarget(m_motionRT);
GL.Clear(true, clearColor, Color.black);
Shader.SetGlobalFloat("_AM_MIN_VELOCITY", MinVelocity);
Shader.SetGlobalFloat("_AM_MAX_VELOCITY", MaxVelocity);
Shader.SetGlobalFloat("_AM_RCP_TOTAL_VELOCITY", 1.0f / (MaxVelocity - MinVelocity));
Shader.SetGlobalVector("_AM_DEPTH_THRESHOLD", new Vector2(DepthThreshold, rcpDepthThreshold));
#else
m_updateCB.Clear();
m_renderCB.Clear();
m_renderCB.SetGlobalFloat("_AM_MIN_VELOCITY", MinVelocity);
m_renderCB.SetGlobalFloat("_AM_MAX_VELOCITY", MaxVelocity);
m_renderCB.SetGlobalFloat("_AM_RCP_TOTAL_VELOCITY", 1.0f / (MaxVelocity - MinVelocity));
m_renderCB.SetGlobalVector("_AM_DEPTH_THRESHOLD", new Vector2(DepthThreshold, rcpDepthThreshold));
m_renderCB.SetRenderTarget(m_motionRT);
m_renderCB.ClearRenderTarget(true, clearColor, Color.black);
#endif
if (cameraMotion)
{
float cameraMotionScaleNorm = (m_deltaTime >= float.Epsilon) ? MotionScale * CameraMotionMult * (1.0f / m_deltaTime) : 0;
float cameraScale = !m_starting ? cameraMotionScaleNorm : 0;
#if UNITY_4
RenderReprojectionVectors(m_motionRT, cameraScale);
#else
RenderReprojectionVectors(m_renderCB, m_motionRT, cameraScale);
#endif
}
#if UNITY_4
m_baseCamera.RenderVectors(objectScale, objectFixedScale, QualityLevel);
#else
// base camera
m_baseCamera.RenderVectors(m_renderCB, objectScale, objectFixedScale, QualityLevel);
// overlay cameras
for (int i = 0; i < m_linkedCameraValues.Length; i++)
{
AmplifyMotionCamera cam = m_linkedCameraValues[i];
if (cam != null && cam.Overlay && cam.isActiveAndEnabled)
{
m_linkedCameraValues[i].RenderVectors(m_renderCB, objectScale, objectFixedScale, QualityLevel);
}
}
#endif
m_starting = false;
#if UNITY_4
Graphics.SetRenderTarget(prevColor, prevDepth);
#endif
}
void OnEnable()
{
m_camera = GetComponent<Camera>();
if ( !CheckSupport() )
{
enabled = false;
return;
}
if ( WorkerThreads <= 0 )
WorkerThreads = Mathf.Max( Environment.ProcessorCount / 2, 1 ); // half of CPU threads; non-busy idle
m_workerThreadPool = new AmplifyMotion.WorkerThreadPool();
m_workerThreadPool.InitializeAsyncUpdateThreads( WorkerThreads, SystemThreadPool );
m_starting = true;
if ( !CreateMaterials() )
{
Debug.LogError( "[AmplifyMotion] Failed loading or compiling necessary shaders. Please try reinstalling Amplify Motion or contact [email protected]" );
enabled = false;
return;
}
if ( AutoRegisterObjs )
UpdateActiveObjects();
InitializeCameras();
UpdateRenderTextures( true );
m_linkedCameras.TryGetValue( m_camera, out m_baseCamera );
if ( m_baseCamera == null )
{
Debug.LogError( "[AmplifyMotion] Failed setting up Base Camera. Please contact [email protected]" );
enabled = false;
return;
}
if ( m_currentPostProcess != null )
m_currentPostProcess.enabled = true;
m_qualityLevel = QualityLevel;
}
void OnPostRender()
{
bool qualityChanged = ( QualityLevel != m_qualityLevel );
if ( qualityChanged )
{
CreateMaterials();
m_qualityLevel = QualityLevel;
}
UpdateRenderTextures( qualityChanged );
RenderBuffer prevColor = Graphics.activeColorBuffer;
RenderBuffer prevDepth = Graphics.activeDepthBuffer;
bool cameraMotion = ( CameraMotionMult > float.Epsilon );
m_motionRT.DiscardContents();
Graphics.SetRenderTarget( m_motionRT );
GL.Clear( true, !cameraMotion || m_starting, Color.black );
Shader.SetGlobalFloat( "_EFLOW_MIN_VELOCITY", MinVelocity );
Shader.SetGlobalFloat( "_EFLOW_MAX_VELOCITY", MaxVelocity );
Shader.SetGlobalFloat( "_EFLOW_RCP_TOTAL_VELOCITY", 1.0f / ( MaxVelocity - MinVelocity ) );
float rcpDepthThreshold = ( DepthThreshold > float.Epsilon ) ? 1.0f / DepthThreshold : float.MaxValue;
Shader.SetGlobalVector( "_EFLOW_DEPTH_THRESHOLD", new Vector2( DepthThreshold, rcpDepthThreshold ) );
m_motionScaleNorm = ( m_deltaTime >= float.Epsilon ) ? MotionScale * ( 1.0f / m_deltaTime ) : 0;
m_fixedMotionScaleNorm = ( m_fixedDeltaTime >= float.Epsilon ) ? MotionScale * ( 1.0f / m_fixedDeltaTime ) : 0;
float objectScale = !m_starting ? m_motionScaleNorm : 0;
float objectFixedScale = !m_starting ? m_fixedMotionScaleNorm : 0;
if ( cameraMotion )
{
float cameraMotionScaleNorm = ( m_deltaTime >= float.Epsilon ) ? MotionScale * CameraMotionMult * ( 1.0f / m_deltaTime ) : 0;
float cameraScale = !m_starting ? cameraMotionScaleNorm : 0;
RenderReprojectionVectors( m_motionRT, cameraScale );
}
ResetObjectId();
m_baseCamera.RenderVectors( objectScale, objectFixedScale, QualityLevel );
m_starting = false;
Graphics.SetRenderTarget( prevColor, prevDepth );
}
void OnEnable()
{
m_camera = GetComponent<Camera>();
if ( !CheckSupport() )
{
enabled = false;
return;
}
InitializeThreadPool();
m_starting = true;
if ( !CreateMaterials() )
{
Debug.LogError( "[AmplifyMotion] Failed loading or compiling necessary shaders. Please try reinstalling Amplify Motion or contact [email protected]" );
enabled = false;
return;
}
if ( AutoRegisterObjs )
UpdateActiveObjects();
InitializeCameras();
InitializeCommandBuffers();
UpdateRenderTextures( true );
m_linkedCameras.TryGetValue( m_camera, out m_baseCamera );
if ( m_baseCamera == null )
{
Debug.LogError( "[AmplifyMotion] Failed setting up Base Camera. Please contact [email protected]" );
enabled = false;
return;
}
if ( m_currentPostProcess != null )
m_currentPostProcess.enabled = true;
m_qualityLevel = QualityLevel;
}
internal override void RenderVectors(Camera camera, CommandBuffer renderCB, float scale, AmplifyMotion.Quality quality)
{
if (m_initialized && !m_error && m_meshRenderer.isVisible)
{
Profiler.BeginSample("Solid.Render");
bool mask = (m_owner.Instance.CullingMask & (1 << m_obj.gameObject.layer)) != 0;
if (!mask || (mask && m_moved))
{
const float rcp255 = 1 / 255.0f;
int objectId = mask ? m_owner.Instance.GenerateObjectId(m_obj.gameObject) : 255;
Matrix4x4 prevModelViewProj;
if (m_obj.FixedStep)
{
prevModelViewProj = m_owner.PrevViewProjMatrixRT * ( Matrix4x4 )m_currLocalToWorld;
}
else
{
prevModelViewProj = m_owner.PrevViewProjMatrixRT * ( Matrix4x4 )m_prevLocalToWorld;
}
renderCB.SetGlobalMatrix("_AM_MATRIX_PREV_MVP", prevModelViewProj);
renderCB.SetGlobalFloat("_AM_OBJECT_ID", objectId * rcp255);
renderCB.SetGlobalFloat("_AM_MOTION_SCALE", mask ? scale : 0);
// TODO: cache property blocks
int qualityPass = (quality == AmplifyMotion.Quality.Mobile) ? 0 : 2;
for (int i = 0; i < m_sharedMaterials.Length; i++)
{
MaterialDesc matDesc = m_sharedMaterials[i];
int pass = qualityPass + (matDesc.coverage ? 1 : 0);
if (matDesc.coverage)
{
Texture mainTex = matDesc.material.mainTexture;
if (mainTex != null)
{
matDesc.propertyBlock.SetTexture("_MainTex", mainTex);
}
if (matDesc.cutoff)
{
matDesc.propertyBlock.SetFloat("_Cutoff", matDesc.material.GetFloat("_Cutoff"));
}
}
renderCB.DrawMesh(m_mesh, m_transform.localToWorldMatrix, m_owner.Instance.SolidVectorsMaterial, i, pass, matDesc.propertyBlock);
}
}
Profiler.EndSample();
}
}
internal virtual void RenderVectors(Camera camera, float scale, AmplifyMotion.Quality quality)
{
}
internal virtual void RenderVectors(Camera camera, CommandBuffer renderCB, float scale, AmplifyMotion.Quality quality)
{
}
internal override void RenderVectors(Camera camera, CommandBuffer renderCB, float scale, AmplifyMotion.Quality quality)
{
if (m_initialized && !m_error && m_renderer.isVisible)
{
Profiler.BeginSample("Cloth.Render");
const float rcp255 = 1 / 255.0f;
bool mask = (m_owner.Instance.CullingMask & (1 << m_obj.gameObject.layer)) != 0;
int objectId = mask ? m_owner.Instance.GenerateObjectId(m_obj.gameObject) : 255;
Vector3[] clothVertices = m_cloth.vertices;
for (int i = 0; i < m_targetVertexCount; i++)
{
m_currVertices[i] = clothVertices[m_targetRemap[i]];
}
if (m_starting || !m_wasVisible)
{
Array.Copy(m_currVertices, m_prevVertices, m_targetVertexCount);
}
m_clonedMesh.vertices = m_currVertices;
m_clonedMesh.normals = m_prevVertices;
Matrix4x4 prevModelViewProj;
if (m_obj.FixedStep)
{
prevModelViewProj = m_owner.PrevViewProjMatrixRT * ( Matrix4x4 )m_currLocalToWorld;
}
else
{
prevModelViewProj = m_owner.PrevViewProjMatrixRT * ( Matrix4x4 )m_prevLocalToWorld;
}
renderCB.SetGlobalMatrix("_AM_MATRIX_PREV_MVP", prevModelViewProj);
renderCB.SetGlobalFloat("_AM_OBJECT_ID", objectId * rcp255);
renderCB.SetGlobalFloat("_AM_MOTION_SCALE", mask ? scale : 0);
int qualityPass = (quality == AmplifyMotion.Quality.Mobile) ? 0 : 2;
for (int i = 0; i < m_sharedMaterials.Length; i++)
{
MaterialDesc matDesc = m_sharedMaterials[i];
int pass = qualityPass + (matDesc.coverage ? 1 : 0);
if (matDesc.coverage)
{
Texture mainTex = matDesc.material.mainTexture;
if (mainTex != null)
{
matDesc.propertyBlock.SetTexture("_MainTex", mainTex);
}
if (matDesc.cutoff)
{
matDesc.propertyBlock.SetFloat("_Cutoff", matDesc.material.GetFloat("_Cutoff"));
}
}
renderCB.DrawMesh(m_clonedMesh, m_currLocalToWorld, m_owner.Instance.ClothVectorsMaterial, i, pass, matDesc.propertyBlock);
}
Profiler.EndSample();
}
}
void OnPostRender()
{
bool qualityChanged = ( QualityLevel != m_qualityLevel );
if ( qualityChanged )
{
CreateMaterials();
m_qualityLevel = QualityLevel;
}
UpdateRenderTextures( qualityChanged );
ResetObjectId();
#if UNITY_4
RenderBuffer prevColor = Graphics.activeColorBuffer;
RenderBuffer prevDepth = Graphics.activeDepthBuffer;
#endif
bool cameraMotion = ( CameraMotionMult > float.Epsilon );
bool clearColor = !cameraMotion || m_starting;
float rcpDepthThreshold = ( DepthThreshold > float.Epsilon ) ? 1.0f / DepthThreshold : float.MaxValue;
m_motionScaleNorm = ( m_deltaTime >= float.Epsilon ) ? MotionScale * ( 1.0f / m_deltaTime ) : 0;
m_fixedMotionScaleNorm = ( m_fixedDeltaTime >= float.Epsilon ) ? MotionScale * ( 1.0f / m_fixedDeltaTime ) : 0;
float objectScale = !m_starting ? m_motionScaleNorm : 0;
float objectFixedScale = !m_starting ? m_fixedMotionScaleNorm : 0;
DiscardContents( m_motionRT );
#if UNITY_4
Graphics.SetRenderTarget( m_motionRT );
GL.Clear( true, clearColor, Color.black );
Shader.SetGlobalFloat( "_AM_MIN_VELOCITY", MinVelocity );
Shader.SetGlobalFloat( "_AM_MAX_VELOCITY", MaxVelocity );
Shader.SetGlobalFloat( "_AM_RCP_TOTAL_VELOCITY", 1.0f / ( MaxVelocity - MinVelocity ) );
Shader.SetGlobalVector( "_AM_DEPTH_THRESHOLD", new Vector2( DepthThreshold, rcpDepthThreshold ) );
#else
m_updateCB.Clear();
m_renderCB.Clear();
m_renderCB.SetGlobalFloat( "_AM_MIN_VELOCITY", MinVelocity );
m_renderCB.SetGlobalFloat( "_AM_MAX_VELOCITY", MaxVelocity );
m_renderCB.SetGlobalFloat( "_AM_RCP_TOTAL_VELOCITY", 1.0f / ( MaxVelocity - MinVelocity ) );
m_renderCB.SetGlobalVector( "_AM_DEPTH_THRESHOLD", new Vector2( DepthThreshold, rcpDepthThreshold ) );
m_renderCB.SetRenderTarget( m_motionRT );
m_renderCB.ClearRenderTarget( true, clearColor, Color.black );
#endif
if ( cameraMotion )
{
float cameraMotionScaleNorm = ( m_deltaTime >= float.Epsilon ) ? MotionScale * CameraMotionMult * ( 1.0f / m_deltaTime ) : 0;
float cameraScale = !m_starting ? cameraMotionScaleNorm : 0;
#if UNITY_4
RenderReprojectionVectors( m_motionRT, cameraScale );
#else
RenderReprojectionVectors( m_renderCB, m_motionRT, cameraScale );
#endif
}
#if UNITY_4
m_baseCamera.RenderVectors( objectScale, objectFixedScale, QualityLevel );
#else
// base camera
m_baseCamera.RenderVectors( m_renderCB, objectScale, objectFixedScale, QualityLevel );
// overlay cameras
for ( int i = 0; i < m_linkedCameraValues.Length; i++ )
{
AmplifyMotionCamera cam = m_linkedCameraValues[ i ];
if ( cam != null && cam.Overlay && cam.isActiveAndEnabled )
m_linkedCameraValues[ i ].RenderVectors( m_renderCB, objectScale, objectFixedScale, QualityLevel );
}
#endif
m_starting = false;
#if UNITY_4
Graphics.SetRenderTarget( prevColor, prevDepth );
#endif
}
