protected override void OnPaintBackground(System.Windows.Forms.PaintEventArgs pevent)
{
PaintStandardBackground(pevent);
SmoothingMode smoothingMode = pevent.Graphics.SmoothingMode;
pevent.Graphics.SmoothingMode = SmoothingMode.AntiAlias;
using (Brush brush = new SolidBrush(BackgroundColor))
{
if (ShapeType == ShapeType.Star || ShapeType == ShapeType.Octagon)
{
PointF[] pts = GetPolygonPoints(7, DisplayRectangle);
pevent.Graphics.FillPolygon(brush, pts);
}
else if (ShapeType == ShapeType.Circle)
{
pevent.Graphics.FillEllipse(brush, DisplayRectangle);
}
else if (ShapeType == ShapeType.RoundedRectangle)
{
FillRoundedRectangle(pevent.Graphics, DisplayRectangle, 30, brush);
}
}
pevent.Graphics.SmoothingMode = smoothingMode;
if (Focused || Pressed)
{
GraphicsUtilities.DrawOutline(this, pevent.Graphics);
}
}
//TODO: Fix the dependency on the specific ordering of vertex vectors then face vectors.
// Constructs Vector3 for at each Vertex and at the center of each Face. Returns an array which contains
// the Vertex vectors followed by the Face vectors.
private static Vector3[] CreateVertexArray(IPolyhedron surface)
{
var vertexVectors = surface.Vertices.Select(vertex => GraphicsUtilities.Vector3(vertex.Position));
var faceVectors = surface.Faces.Select(face => GraphicsUtilities.Vector3(face.SphericalCenter()));
return(vertexVectors.Concat(faceVectors).ToArray());
}
public void Capture(ScriptableRenderContext context, Action <int, NativeArray <T>, RenderTexture> imageReadCallback)
{
if (!GraphicsUtilities.SupportsAsyncReadback())
{
RenderTexture.active = m_Source;
if (m_CpuTexture == null)
{
m_CpuTexture = new Texture2D(m_Source.width, m_Source.height, m_Source.graphicsFormat, TextureCreationFlags.None);
}
m_CpuTexture.ReadPixels(new Rect(
Vector2.zero,
new Vector2(m_Source.width, m_Source.height)),
0, 0);
RenderTexture.active = null;
var data = m_CpuTexture.GetRawTextureData <T>();
imageReadCallback(Time.frameCount, data, m_Source);
}
else
{
var commandBuffer = CommandBufferPool.Get("RenderTextureReader");
var frameCount = Time.frameCount;
commandBuffer.RequestAsyncReadback(m_Source, r => OnGpuReadback(r, frameCount, imageReadCallback));
context.ExecuteCommandBuffer(commandBuffer);
context.Submit();
CommandBufferPool.Release(commandBuffer);
}
}
public IEnumerator CaptureTestsRedux_Async_Motion_Orientation()
{
if (!GraphicsUtilities.SupportsAsyncReadback())
{
Assert.Ignore();
}
return(CaptureTestsRedux_Parametric(true, false, false, Channel.Motion));
}
//TODO: Seeing as this information isn't needed update-to-update, should it really be stored?
// Updates the _vertexVelocities array using the new velocity field.
private void UpdateVertexVelocities(VectorField <Vertex> velocityField)
{
for (int i = 0; i < _vertexVelocities.Length; i++)
{
// Convert from a MathNet.Iridium vector to a Unity vector.
_vertexVelocities[i] = GraphicsUtilities.Vector3(velocityField[i]);
}
}
public IEnumerator CaptureTestsRedux_AsyncBatched_Depth_Orientation_short16()
{
if (!GraphicsUtilities.SupportsAsyncReadback())
{
Assert.Ignore();
}
return(CaptureTestsRedux_Parametric(true, true, false, Channel.Depth, 16));
}
public IEnumerator CaptureTestsRedux_AsyncBatchedRT_Color_Orientation()
{
if (!GraphicsUtilities.SupportsAsyncReadback())
{
Assert.Ignore();
}
return(CaptureTestsRedux_Parametric(true, true, true, Channel.Color));
}
public DisplayFact(Individual ind, string surname, string forenames, Fact fact)
{
Ind = ind;
Surname = surname;
Forenames = forenames;
Fact = fact;
IgnoreFact = false;
#if __PC__
Icon = GraphicsUtilities.ResizeImageToCurrentScale(FactImage.ErrorIcon(fact.FactErrorLevel).Icon);
#endif
}
private void RenderDepthScatter(Texture source, RenderTexture target)
{
Water water = (!this._HasWaterOverride) ? this._LocalWaterCamera.ContainingWater : this._WaterOverride;
this._ImeMaterial.CopyPropertiesFromMaterial(water.Materials.SurfaceMaterial);
this._ImeMaterial.SetTexture("_UnderwaterAbsorptionGradient", water.Materials.UnderwaterAbsorptionColorByDepth);
this._ImeMaterial.SetFloat("_UnderwaterLightFadeScale", water.Materials.UnderwaterLightFadeScale);
this._ImeMaterial.SetMatrix("UNITY_MATRIX_VP_INVERSE", Matrix4x4.Inverse(this._LocalCamera.projectionMatrix * this._LocalCamera.worldToCameraMatrix));
MaterialPropertyBlock propertyBlock = water.Renderer.PropertyBlock;
GraphicsUtilities.Blit(source, target, this._ImeMaterial, 1, propertyBlock);
}
/// <summary>
/// Creates a new <see cref="RenderTextureReader{T}"/> for the given <see cref="RenderTexture"/>, <see cref="Camera"/>, and image readback callback
/// </summary>
/// <param name="source">The <see cref="RenderTexture"/> to read from.</param>
/// <param name="cameraRenderingToSource">The <see cref="Camera"/> which renders to the given renderTexture. This is used to determine when to read from the texture.</param>
/// <param name="imageReadCallback">The callback to call after reading the texture</param>
public RenderTextureReader(RenderTexture source, Camera cameraRenderingToSource, Action <int, NativeArray <T>, RenderTexture> imageReadCallback)
{
this.m_Source = source;
this.m_ImageReadCallback = imageReadCallback;
this.m_CameraRenderingToSource = cameraRenderingToSource;
m_NextFrameToCapture = Time.frameCount;
if (!GraphicsUtilities.SupportsAsyncReadback())
{
m_CpuTexture = new Texture2D(m_Source.width, m_Source.height, m_Source.graphicsFormat, TextureCreationFlags.None);
}
RenderPipelineManager.endFrameRendering += OnEndFrameRendering;
}
void OnEndFrameRendering(ScriptableRenderContext context, Camera[] cameras)
{
#if UNITY_EDITOR
if (UnityEditor.EditorApplication.isPaused)
{
return;
}
#endif
if (!cameras.Contains(m_CameraRenderingToSource))
{
return;
}
if (m_NextFrameToCapture > Time.frameCount)
{
return;
}
m_NextFrameToCapture = Time.frameCount + 1;
if (!GraphicsUtilities.SupportsAsyncReadback())
{
RenderTexture.active = m_Source;
if (m_CpuTexture == null)
{
m_CpuTexture = new Texture2D(m_Source.width, m_Source.height, m_Source.graphicsFormat, TextureCreationFlags.None);
}
m_CpuTexture.ReadPixels(new Rect(
Vector2.zero,
new Vector2(m_Source.width, m_Source.height)),
0, 0);
RenderTexture.active = null;
var data = m_CpuTexture.GetRawTextureData <T>();
m_ImageReadCallback(Time.frameCount, data, m_Source);
return;
}
else
{
var commandBuffer = CommandBufferPool.Get("RenderTextureReader");
var frameCount = Time.frameCount;
commandBuffer.RequestAsyncReadback(m_Source, r => OnGpuReadback(r, frameCount));
context.ExecuteCommandBuffer(commandBuffer);
context.Submit();
CommandBufferPool.Release(commandBuffer);
}
}
private void SpawnWindWavesParticlesTiled(Transform origin)
{
Vector3 position = origin.position;
float num = 400f / (float)this._BlankOutput.width;
this._SprayTiledGeneratorMaterial.CopyPropertiesFromMaterial(this._Water.Materials.SurfaceMaterial);
this._SprayTiledGeneratorMaterial.SetVector("_SurfaceOffset", new Vector3(this._Water.SurfaceOffset.x, this._Water.transform.position.y, this._Water.SurfaceOffset.y));
this._SprayTiledGeneratorMaterial.SetVector("_Params", new Vector4(this._SpawnThreshold * 0.25835f, this._SkipRatioPrecomp, 0f, this._Scale * 0.455f));
this._SprayTiledGeneratorMaterial.SetVector("_Coordinates", new Vector4(position.x - 200f + UnityEngine.Random.value * num, position.z - 200f + UnityEngine.Random.value * num, 400f, 400f));
if (this._Overlays == null)
{
this._SprayTiledGeneratorMaterial.SetTexture("_LocalNormalMap", this.GetBlankWhiteTex());
}
Graphics.SetRandomWriteTarget(1, this._ParticlesA);
GraphicsUtilities.Blit(null, this._BlankOutput, this._SprayTiledGeneratorMaterial, 0, this._Water.Renderer.PropertyBlock);
Graphics.ClearRandomWriteTargets();
}
private static GameObject DrawLongitude(float radius, float azimuth)
{
var azimuths = AnglesInRange(0, Mathf.PI, NumberOfPointsPerLongitude);
var vertices =
azimuths.Select(
colatitude => radius * GraphicsUtilities.Vector3(colatitude, azimuth, 1))
.ToArray();
var longitudeObject =
CreateLineObject(
"Longitude " + Mathf.Rad2Deg * azimuth,
vertices,
"Materials/LatLongGrid/Boundaries");
return(longitudeObject);
}
public IEnumerator CaptureTest_CaptureColorUsingNonAsyncMethod()
{
const int kDimension = 64;
const int kLength = kDimension * kDimension;
var color = kTestColor;
var data = new Color32[kLength];
for (var i = 0; i < data.Length; ++i)
{
data[i] = color;
}
var texture = new Texture2D(kDimension, kDimension, GraphicsFormat.R8G8B8A8_UNorm, TextureCreationFlags.None);
texture.SetPixels32(data);
texture.Apply();
var rt = new RenderTexture(kDimension, kDimension, 0, GraphicsFormat.R8G8B8A8_UNorm);
rt.useMipMap = false;
rt.autoGenerateMips = false;
Graphics.Blit(texture, rt);
var request = Manager.Instance.CreateRequest <AsyncRequest <object> >();
Func <AsyncRequest <object>, AsyncRequest <object> .Result> functor = (AsyncRequest <object> r) =>
{
var colorBuffer = GraphicsUtilities.GetPixelsSlow(rt as RenderTexture);
Debug.Assert(EnsureColorsCloseTo(kTestColor, colorBuffer, 0) == 0, "colorBuffer differs from expected output");
return(AsyncRequest <object> .Result.Completed);
};
request.Enqueue(functor);
request.Execute(AsyncRequest.ExecutionContext.EndOfFrame);
while (!request.completed)
{
yield return(null);
}
Debug.Assert(request.error == false, "Request had an error");
}
public IEnumerator CaptureTest_CaptureColorAndDepthParametric(int depthBpp, GraphicsFormat renderTextureFormat, Action <AsyncRequest <CaptureCamera.CaptureState> > validator)
{
Debug.Assert(GraphicsUtilities.SupportsRenderTextureFormat(renderTextureFormat), "GraphicsFormat not supported");
var camera = SetupCameraTestWithMaterial(depthBpp, renderTextureFormat, new Vector3(0, 0, 1.0f));
var request = CaptureCamera.Capture(camera, colorFunctor: AsyncRequest <CaptureCamera.CaptureState> .DontCare, depthFunctor: AsyncRequest <CaptureCamera.CaptureState> .DontCare, depthFormat: GraphicsUtilities.DepthFormatForDepth(depthBpp));
camera.Render();
while (!request.completed)
{
yield return(null);
}
Debug.Assert(request.error == false, "Capture request had an error");
validator.Invoke(request);
}
/// <summary>
/// Updates the camera's radial and orbital position in response to user input.
/// </summary>
public void Update()
{
// If the rotate key is depressed, update the _azimuth and _colatitude fields.
if (Input.GetKey(_options.RotateKey))
{
UpdateAzimuthAndColatitude();
}
// If the zoom key is depressed, update the _radius field.
if (Input.GetKey(_options.ZoomKey))
{
UpdateRadius();
}
// Update the camera's transform to match the _azimuth, _colatitude & _radius fields
var position = GraphicsUtilities.Vector3(_colatitude, _azimuth, _radius);
var localEast = Vector3.Cross(position, new Vector3(0, 0, 1));
var localNorth = Vector3.Cross(localEast, position);
_cameraTransform.rotation = Quaternion.LookRotation(-position, localNorth);
_cameraTransform.position = position;
}
private void RenderDistortions(Texture source, RenderTexture target)
{
Water water = (!this._HasWaterOverride) ? this._LocalWaterCamera.ContainingWater : this._WaterOverride;
float underwaterDistortionsIntensity = water.Materials.UnderwaterDistortionsIntensity;
if (underwaterDistortionsIntensity > 0f)
{
int width = Camera.current.pixelWidth >> 2;
int height = Camera.current.pixelHeight >> 2;
TemporaryRenderTexture temporary = RenderTexturesCache.GetTemporary(width, height, 0, RenderTextureFormat.ARGB32, true, false, false);
this.RenderDistortionMap(temporary);
temporary.Texture.filterMode = FilterMode.Bilinear;
this._ImeMaterial.SetTexture("_DistortionTex", temporary);
this._ImeMaterial.SetFloat("_DistortionIntensity", underwaterDistortionsIntensity);
GraphicsUtilities.Blit(source, target, this._ImeMaterial, 2, water.Renderer.PropertyBlock);
temporary.Dispose();
}
else
{
Graphics.Blit(source, target);
}
}
// Draw a label at the specified position
private static GameObject DrawLabel(float scaleFactor, float colatitude, float azimuth)
{
var text = String.Format("{0,3:N0} {1,3:N0}", Mathf.Rad2Deg * colatitude, Mathf.Rad2Deg * azimuth);
var labelObject = new GameObject("Label " + text);
var normal = GraphicsUtilities.Vector3(colatitude, azimuth, 1);
var localEast = Vector3.Cross(normal, new Vector3(0, 0, 1));
var localNorth = Vector3.Cross(localEast, normal);
labelObject.transform.position = scaleFactor * normal;
labelObject.transform.rotation = Quaternion.LookRotation(-normal, localNorth);
var textMesh = labelObject.AddComponent <TextMesh>();
textMesh.text = text;
textMesh.font = Resources.Load("Materials/LatLongGrid/ARIAL", typeof(Font)) as Font;
textMesh.renderer.material = Resources.Load("Materials/LatLongGrid/OneSidedMaterial", typeof(Material)) as Material;
textMesh.characterSize = scaleFactor * 0.005f;
textMesh.anchor = TextAnchor.UpperCenter;
return(labelObject);
}
// Returns the positions of each vertex in the given geometry.
private static Vector3[] GetVertexPositions(IPolyhedron surface)
{
return(surface.Vertices.Select(vertex => GraphicsUtilities.Vector3(vertex.Position)).ToArray());
}
// Select the Vertex of a Face that's closest to the given vector.
private Vertex FindClosestVertex(Face face, Vector3 target)
{
var sortedVertices = face.Vertices.OrderBy(vertex => (GraphicsUtilities.Vector3(vertex.Position) - target).magnitude);
return(sortedVertices.First());
}
