protected virtual void Update()
{
if (context.Data == null)
{
return;
}
//transform.localScale = context.Data.displayData.scale * Vector3.one;
switch (context.Data.displayData.mode)
{
case MixCastData.SceneDisplayData.PlacementMode.Camera:
MixCastCamera target = MixCastCamera.FindCamera(context);
if (target != null)
{
transform.position = target.displayTransform.position;
transform.rotation = target.displayTransform.rotation;
}
break;
case MixCastData.SceneDisplayData.PlacementMode.World:
transform.localPosition = context.Data.displayData.position;
transform.localRotation = context.Data.displayData.rotation;
break;
case MixCastData.SceneDisplayData.PlacementMode.Headset:
break;
}
}
private void LateUpdate()
{
if (cam == null || cam.context.Data != context.Data || !cam.isActiveAndEnabled)
{
cam = MixCastCamera.FindCamera(context);
}
if (cam != null)
{
image.texture = cam.Output;
//Comment out to remove memory allocation in editor
//image.SetMaterialDirty();
if (image.texture != null)
{
if (fitter != null)
{
fitter.aspectRatio = (float)image.texture.width / image.texture.height;
}
}
}
else
{
image.texture = null;
}
}
protected override void RemoveCameras()
{
MixCastCamera cam = MixCastCamera.FindCamera(context);
if (cam != null)
{
MixCast.StreamingCameras.Remove(cam.context.Data);
}
}
protected override void OnEnable()
{
base.OnEnable();
// Force LibAvStuff's static constructor to run. This prevents the scenario where
// accessing a LibAV function for the first time from inside a thread crashes the app.
// This happens after enabling the "Begin recording on MixCast start" option.
RuntimeHelpers.RunClassConstructor(typeof(MixCastAV).TypeHandle);
MixCastCamera cam = MixCastCamera.FindCamera(context);
Assert.IsNotNull(cam);
if (SetEncoderDefaults(cam))
{
StartCoroutine(Run());
}
else
{
RemoveCameras();
}
}
void UpdateMesh(InputFeed feed)
{
MixCastCamera cam = MixCastCamera.FindCamera(feed.context);
if (cam == null)
{
return;
}
float playerDist = Mathf.Max(cam.gameCamera.nearClipPlane * (1f + NEAR_PLANE_PADDING), feed.CalculatePlayerDistance(cam.gameCamera));
float playerQuadHalfHeight = playerDist * Mathf.Tan(feed.context.Data.deviceFoV * 0.5f * Mathf.Deg2Rad);
float playerQuadHalfWidth = playerQuadHalfHeight * feed.context.Data.deviceFeedWidth / feed.context.Data.deviceFeedHeight;
vertBuffer[0] = new Vector3(-playerQuadHalfWidth, playerQuadHalfHeight, playerDist);
vertBuffer[1] = new Vector3(playerQuadHalfWidth, playerQuadHalfHeight, playerDist);
vertBuffer[2] = new Vector3(playerQuadHalfWidth, -playerQuadHalfHeight, playerDist);
vertBuffer[3] = new Vector3(-playerQuadHalfWidth, -playerQuadHalfHeight, playerDist);
projectionMesh.SetVertices(vertBuffer);
projectionMesh.RecalculateBounds();
projectionMesh.UploadMeshData(false);
}
void FillTrackingData(FrameDelayQueue <FramePlayerData> .Frame <FramePlayerData> frame)
{
MixCastCamera cam = MixCastCamera.FindCamera(context);
if (cam != null && cam.gameCamera != null)
{
frame.data.playerDist = cam.gameCamera.transform.TransformVector(Vector3.forward).magnitude *CalculatePlayerDistance(cam.gameCamera); //Scale distance by camera scale
}
frame.data.playerHeadPos = GetTrackingPosition(TrackedDeviceManager.DeviceRole.Head);
frame.data.playerBasePos = new Vector3(frame.data.playerHeadPos.x, 0, frame.data.playerHeadPos.z);
frame.data.playerLeftHandPos = GetTrackingPosition(TrackedDeviceManager.DeviceRole.LeftHand);
frame.data.playerRightHandPos = GetTrackingPosition(TrackedDeviceManager.DeviceRole.RightHand);
if (MixCastCameras.Instance.RoomTransform != null)
{
Transform roomTransform = MixCastCameras.Instance.RoomTransform;
frame.data.playerHeadPos = roomTransform.TransformPoint(frame.data.playerHeadPos);
frame.data.playerBasePos = roomTransform.TransformPoint(frame.data.playerBasePos);
frame.data.playerLeftHandPos = roomTransform.TransformPoint(frame.data.playerLeftHandPos);
frame.data.playerRightHandPos = roomTransform.TransformPoint(frame.data.playerRightHandPos);
}
}
private void Update()
{
if (feed == null || !feed.isActiveAndEnabled)
{
return;
}
Vector3 groundOrigin = Vector3.zero;
if (groundLayers == 0)
{
groundOrigin = Camera.main.transform.position;
groundOrigin.y = 0;
}
else
{
RaycastHit hitInfo;
if (UnityEngine.Physics.Raycast(Camera.main.transform.position, Vector3.down, out hitInfo, maxRayLength, groundLayers, QueryTriggerInteraction.Ignore))
{
groundOrigin = hitInfo.point;
}
else
{
groundOrigin = Camera.main.transform.position + Vector3.down * maxRayLength;
}
}
if (feed.blitMaterial != null && feed.blitMaterial.HasProperty(groundPositionParameter))
{
MixCastCamera cam = MixCastCamera.FindCamera(feed.context);
float output = 0;
if (cam.gameCamera.transform.InverseTransformPoint(groundOrigin).z > 0)
{
output = Mathf.Clamp01(cam.gameCamera.WorldToViewportPoint(groundOrigin).y);
}
feed.blitMaterial.SetFloat(groundPositionParameter, output);
}
}
protected IEnumerator Run()
{
MixCastCamera cam = MixCastCamera.FindCamera(context);
if (cam == null || cam.Output == null)
{
Debug.Log("No MixCast camera found");
}
if (encoderRunning == false)
{
StartEncoder(cam);
}
while (isActiveAndEnabled)
{
bool running = false;
if (_vidEnc != IntPtr.Zero && _vCfgEnc != IntPtr.Zero && _vTxfEnc != IntPtr.Zero &&
_audEnc != IntPtr.Zero && _aCfgEnc != IntPtr.Zero)
{
running = true;
}
if (!running)
{
yield return(null);
}
cam = MixCastCamera.FindCamera(context);
bool hasOutput = cam != null && cam.Output != null;
bool resized = hasOutput && (cam.Output.width != _lastWidth || cam.Output.height != _lastHeight);
if (resized || (!hasOutput && running))
{
StopEncoderAsync(_encoderInitLock);
}
if (resized || (hasOutput && !running))
{
StartEncoder(cam);
}
//Encoding time management
if (running)
{
float startTime = Time.unscaledTime;
float timeDiff = 0;
while (timeDiff < _frameDuration)
{
timeDiff = Time.unscaledTime - startTime + timeOvershot;
//it has reached the frame duration, break out and encode
if (timeDiff >= _frameDuration)
{
break;
}
yield return(null);
}
timeOvershot = timeDiff % _frameDuration;
int frameCount = Math.Max(1, (int)(timeDiff / _frameDuration));
SendMixCastOutput(cam, frameCount);
}
}
}
IEnumerator RunAsync()
{
MixCastCamera cam = MixCastCamera.FindCamera(context);
if (cam == null)
{
ScreenshotError();
yield break;
}
RenderTexture srcTex = RenderTexture.GetTemporary(cam.Output.width, cam.Output.height, 0);
Graphics.Blit(cam.Output, srcTex);
//Distribute encoding so only one texture encodes per frame (since not threadable)
encodeQueue.Add(this);
yield return(new WaitForEndOfFrame());
while (encodeQueue[0] != this)
{
if (encodeQueue[0] == null)
{
encodeQueue.RemoveAt(0); //mechanism so 2nd instance still doesn't trigger same frame
}
yield return(null); // waits for next frame; used to spread out function over multiple frames
}
//Reserve file
string finalFilename = MixCastFiles.GetAvailableFilename(filename);
yield return(null);
Texture2D tex = new Texture2D(cam.Output.width, cam.Output.height, TextureFormat.RGB24, false, QualitySettings.activeColorSpace == ColorSpace.Linear);
yield return(null);
RenderTexture.active = srcTex;
tex.ReadPixels(new Rect(0, 0, tex.width, tex.height), 0, 0);
RenderTexture.active = null;
yield return(null);
srcTex.Release();
srcTex = null;
yield return(null);
JPGEncoder encoder = new JPGEncoder(tex, 100, finalFilename);
yield return(null);
DestroyImmediate(tex);
while (!encoder.isDone)
{
yield return(null);
}
encodeQueue[0] = null; //Release encoding lock
EventCenter.HandleEvent(
EventCenter.Category.Saving,
EventCenter.Result.Success,
string.Format("{0} {1}", Text.Localization.Get("Info_Saved_Screenshot"), finalFilename.Replace("/", "\\")),
false
);
}
void CalculateCurrentLightsData(FrameLightingData lightingData)
{
MixCastCamera cam = MixCastCamera.FindCamera(feed.context);
if (cam == null || cam.gameCamera == null)
{
return;
}
float playerDist = feed.CalculatePlayerDistance(cam.gameCamera);
lightingData.directionalLightCount = 0;
if (MixCast.ProjectSettings.specifyLightsManually)
{
foreach (Light light in MixCastLight.ActiveDirectionalLights)
{
if ((light.cullingMask & (1 << layerNum)) > 0 && LightIsAffectingPlayer(light, cam.gameCamera, playerDist))
{
lightingData.directionalLightDirections[lightingData.directionalLightCount] = light.transform.forward;
lightingData.directionalLightColors[lightingData.directionalLightCount] = light.color * light.intensity * MixCast.ProjectSettings.directionalLightPower * 0.5f;
lightingData.directionalLightCount++;
if (lightingData.directionalLightCount == DIR_LIGHT_ARRAY_MAX)
{
break;
}
}
}
}
else
{
var directionalLights = Light.GetLights(LightType.Directional, layerNum);
for (int i = 0; i < directionalLights.Length && lightingData.directionalLightCount < DIR_LIGHT_ARRAY_MAX; i++)
{
if (LightIsAffectingPlayer(directionalLights[i], cam.gameCamera, playerDist))
{
lightingData.directionalLightDirections[lightingData.directionalLightCount] = directionalLights[i].transform.forward;
lightingData.directionalLightColors[lightingData.directionalLightCount] = directionalLights[i].color * directionalLights[i].intensity * MixCast.ProjectSettings.directionalLightPower * 0.5f;
lightingData.directionalLightCount++;
}
}
}
lightingData.pointLightCount = 0;
if (MixCast.ProjectSettings.specifyLightsManually)
{
foreach (Light light in MixCastLight.ActivePointLights)
{
if ((light.cullingMask & (1 << layerNum)) > 0 && LightIsAffectingPlayer(light, cam.gameCamera, playerDist))
{
lightingData.pointLightPositions[lightingData.pointLightCount] = light.transform.position;
lightingData.pointLightPositions[lightingData.pointLightCount].w = light.range;
lightingData.pointLightColors[lightingData.pointLightCount] = light.color * light.intensity * MixCast.ProjectSettings.pointLightPower * 0.5f;
lightingData.pointLightCount++;
if (lightingData.pointLightCount == POINT_LIGHT_ARRAY_MAX)
{
break;
}
}
}
}
else
{
var pointLights = Light.GetLights(LightType.Point, layerNum);
for (int i = 0; i < pointLights.Length && lightingData.pointLightCount < POINT_LIGHT_ARRAY_MAX; i++)
{
if (LightIsAffectingPlayer(pointLights[i], cam.gameCamera, playerDist))
{
lightingData.pointLightPositions[lightingData.pointLightCount] = pointLights[i].transform.position;
lightingData.pointLightPositions[lightingData.pointLightCount].w = pointLights[i].range;
lightingData.pointLightColors[lightingData.pointLightCount] = pointLights[i].color * pointLights[i].intensity * MixCast.ProjectSettings.pointLightPower * 0.5f;
lightingData.pointLightCount++;
}
}
}
//foundLights = Light.GetLights(LightType.Spot, layerNum);
//lightingData.spotLightCount = 0;
//for (int i = 0; i < foundLights.Length && lightingData.spotLightCount < SPOT_LIGHT_ARRAY_MAX; i++)
//{
// if (LightIsAffectingPlayer(foundLights[i], cam.gameCamera, playerDist))
// {
// lightingData.spotLightPositions[lightingData.spotLightCount] = foundLights[i].transform.position;
// lightingData.spotLightPositions[lightingData.spotLightCount].w = foundLights[i].range;
// lightingData.spotLightDirections[lightingData.spotLightCount] = foundLights[i].transform.forward;
// lightingData.spotLightDirections[lightingData.spotLightCount].w = foundLights[i].spotAngle * Mathf.Deg2Rad * 0.5f;
// lightingData.spotLightColors[lightingData.spotLightCount] = foundLights[i].color * foundLights[i].intensity * MixCast.ProjectSettings.spotLightPower * 0.5f;
// lightingData.spotLightCount++;
// }
//}
}