public override bool ComputeVisibility(ISceneCamera camera)
{
this.camera = camera;
ComputeVisibility(this.quadTree);
return(true);
}
/// <summary>
/// Spocita viditelnost objektu. Na zaklade vypocte se objekt bude nebo nebude renderovat
/// </summary>
/// <remarks>Metoda je zavisla na spravne vypocitanych vzdalenostech od kamery!</remarks>
public virtual bool ComputeVisibility(ISceneCamera camera)
{
if (camera == null)
{
visible = true;
return(true);
}
ClipVolume cv = camera.GetClipVolume();
Plane[] p = new Plane[] { cv.pNear, cv.pFar, cv.pLeft, cv.pRight, cv.pTop, cv.pBottom };
Matrix boundingWorld = boundingMeshWorld[0];
float radius = GetSphereRadius() * scale;
Vector3 position = new Vector3();
position.TransformCoordinate(boundingWorld);
if (mesh == null)
{
for (int t = 0; t < p.Length; t++)
{
float dot = p[t].Dot(GetPosition()) + radius;
if (dot < 0)
{
visible = false;
return(false);
}
}
visible = true;
return(true);
}
if (distance <= radius)
{
visible = true;
return(visible);
}
for (int k = 0; k < p.Length; k++)
{
float dot = p[k].Dot(position);
if (dot + radius < 0)
{
visible = false;
return(visible);
}
}
visible = true;
return(visible);
}
public async Task Init(ISceneCamera camera)
{
this.camera = camera;
await camera?.InitAsync();
if (camera.ShouldRender)
{
SetupCameraPreview();
}
camera.FrameReady += faceTracker.ProcessFrame;
camera.FrameReady += poseTracker.ProcessFrame;
}
public bool ComputeVisibility(ISceneCamera camera)
{
if (camera == null)
{
this.visible = true;
return(true);
}
ClipVolume cv = camera.GetClipVolume();
Plane[] p = new Plane[] { cv.pNear, cv.pFar, cv.pLeft, cv.pRight, cv.pTop, cv.pBottom };
for (int k = 0; k < p.Length; k++)
{
if (p[k].Dot(this.boundingSphereCenter) + this.radius < 0)
{
this.visible = false;
return(this.visible);
}
}
this.visible = true;
return(this.visible);
}
public async Task SetCamera(ISceneCamera camera)
{
await SceneCameraManager.Inst.Init(camera);
}
/// <summary>
/// Metoda spocte vzdalenost od kamery a pokud je zapnute LOD, tak ho nastavi
/// </summary>
/// <returns>Vzdalenost od kamery</returns>
public virtual float ComputeDistanceFromCamera(ISceneCamera camera)
{
distance = Vector3.Length(GetPosition() - camera.GetVector3Position());
return(distance);
}
public override void OnRender(Vector2 offset, RectangleF updateRect)
{
if (_sceneCamera == null)
_sceneCamera = TorqueObjectDatabase.Instance.FindObject<ISceneCamera>();
// Stop rendering if we still don't have a camera or the guide is open.
if (_sceneCamera == null ||
_sceneCamera.SceneGraph == null ||
!TorqueEngineComponent.Instance.IsActive)
return;
#if DEBUG
Profiler.Instance.StartBlock("GUISceneview.OnRender");
#endif
if (GFXDevice.Instance != null)
{
postProcess = _postProcessor != null && TorqueEngineComponent.Instance.EnableBackBufferEffects;
mainRenderTarget = TorqueEngineComponent.Instance.CurrentRenderTarget;
if (postProcess)
{
if (_renderTarget == null || _renderTarget.IsDisposed)
_InitPostProcessing();
Assert.Fatal(_renderTarget != null && !_renderTarget.IsDisposed, "GUISceneView.OnRender - Invalid render target!");
TorqueEngineComponent.Instance.CurrentRenderTarget = _renderTarget;
GFXDevice.Instance.Device.SetRenderTarget(0, _renderTarget);
TorqueEngineComponent.Instance.ClearRenderTarget();
}
// make sure the scenegraph knows it's rendering from this camera
_sceneCamera.SceneGraph.Camera = _sceneCamera;
_sceneCamera.SceneGraph.PreRender(GFXDevice.Instance, _renderMask, _noRenderMask, updateRect.Width / updateRect.Height);
_sceneCamera.SceneGraph.Render(GFXDevice.Instance, _renderMask, _noRenderMask);
if (postProcess)
{
GFXDevice.Instance.Device.SetRenderTarget(0, mainRenderTarget);
TorqueEngineComponent.Instance.CurrentRenderTarget = mainRenderTarget;
texture = _renderTarget.GetTexture();
_postProcessor.Run(texture, Position, Size);
}
}
_RenderChildControls(offset, updateRect);
#if DEBUG
Profiler.Instance.EndBlock("GUISceneview.OnRender");
#endif
}
