public Texture Render()
{
var OldTarget = Source.targetTexture;
Source.targetTexture = Target;
Source.Render();
Source.targetTexture = OldTarget;
OnTargetChanged.Invoke(Target);
return(Target);
}
void Update()
{
if (Decoder == null)
{
return;
}
var NewFrameNumber = Decoder.GetNextFrame(ref Planes, ref PlaneFormats);
if (!NewFrameNumber.HasValue)
{
return;
}
if (EnableDebug)
{
Debug.Log(this.name + " decoded frame " + NewFrameNumber.Value + ". Planes x" + Planes.Count);
}
OnDepthTextureUpdated.Invoke(Planes[0]);
// update material
if (CloudMaterial != null && LastPacketMeta != null)
{
UpdateMaterial(CloudMaterial, LastPacketMeta, Planes[0]);
}
}
void Update()
{
try
{
var renderer = Renderer as GarboDev.Renderer;
var FrameArray = renderer.GetFrame();
var PixelsArray = Frame2D.GetPixels();
unsafe
{
fixed(uint *Frame = &FrameArray[0])
{
fixed(Color *Pixels = &PixelsArray[0])
{
ThreadedCopy(Frame, Pixels, Frame2D.width, Frame2D.height, FrameArray.Length, PixelsArray.Length);
}
}
}
Frame2D.SetPixels(PixelsArray);
Frame2D.Apply();
if (FrameTarget != null)
{
Graphics.Blit(Frame2D, FrameTarget);
}
OnTextureUpdated.Invoke(Frame2D);
}
catch
{
}
}
void Update()
{
if (Webcam == null)
{
try
{
ListDevices();
if (WebcamWidth > 0 && WebcamHeight > 0)
{
Webcam = new WebCamTexture(WebcamName, WebcamWidth, WebcamHeight);
}
else
{
Webcam = new WebCamTexture(WebcamName);
}
Webcam.Play();
if (!Webcam.isPlaying)
{
throw new System.Exception("No webcam");
}
}
catch {
Webcam = null;
}
}
if (Webcam != null && Webcam.didUpdateThisFrame)
{
WebcamWidth = Webcam.width;
WebcamHeight = Webcam.height;
OnNewFrameTexture.Invoke(Webcam as Texture);
OnNewFrameWebCamTexture.Invoke(Webcam);
}
}
static void UpdateTexture(ref Texture2D RamTexture, UnityEvent_Texture Event, byte[] Ram, ComponentSize Size, int Width = 256)
{
var DataLength = Ram.Length / (int)Size;
var Height = DataLength / Width;
if (!Mathf.IsPowerOfTwo(Height))
{
Height = Mathf.NextPowerOfTwo(Height);
}
if (RamTexture == null || RamTexture.width != Width || RamTexture.height != Height)
{
RamTexture = null;
}
if (RamTexture == null)
{
var Format = Size == ComponentSize.Eight ? TextureFormat.R8 : TextureFormat.RG16;
RamTexture = new Texture2D(Width, Height, Format, false);
RamTexture.filterMode = FilterMode.Point;
RamTexture.wrapMode = TextureWrapMode.Clamp;
}
var PixelData = GetTextureSizedBytes(RamTexture, Ram);
RamTexture.LoadRawTextureData(PixelData);
RamTexture.Apply();
Event.Invoke(RamTexture);
}
void Update()
{
for (int i = 0; i < IterationsPerFrame; i++)
{
Iteration();
}
BestHitOutput.Apply(false, false);
OnHitOutput.Invoke(BestHitOutput);
}
public void OnPixels(float[] Bytes, Vector2 Size, int ChannelCount)
{
// convert to colours
var Colours = new Color[(int)Size.x * (int)Size.y];
Output = new Texture2D((int)Size.x, (int)Size.y, OutputFormat, false);
OnError.Invoke("" + Colours.Length + " pixels");
var TargetColours = Output.GetPixels();
if (Colours.Length != TargetColours.Length)
{
OnError.Invoke("Colour length(" + Colours.Length + ") mis match to texture (" + TargetColours.Length + ")");
}
try
{
for (int p = 0; p < Colours.Length; p++)
{
var i = (p * ChannelCount);
i %= ChannelCount * (int)Size.x * MaxRowsToRead;
if (ReadBackwards)
{
i = Bytes.Length - 4 - i;
}
Colours[p].r = Bytes[i + 0];
Colours[p].g = Bytes[i + 1];
Colours[p].b = Bytes[i + 2];
Colours[p].a = Bytes[i + 3];
if (ForceAlphaOne)
{
Colours[p].a = 1;
}
}
}
catch (System.Exception e)
{
OnError.Invoke(e.Message);
}
/*
* var ColourBytes = new byte[Colours.Length * 4 * 4];
* Buffer.BlockCopy(floats, 0, bytes, 0, bytes.Length);
* texture.LoadRawTextureData(bytes);
* texture.Apply();
* Output.LoadRawTextureData(
*/
Output.SetPixels(Colours, 0);
Output.Apply();
OnOutputChanged.Invoke(Output);
}
public void Generate1DTexture()
{
if (Target == null)
{
Target = new Texture2D(TargetWidth, 16, TargetFormat, false);
Target.filterMode = FilterMode.Point;
}
var w = Target.width;
var Colour = new Color(0, 0, 0);
float Range = Mathf.Max(1, w - 1);
var CurveTimeMin = Curve.keys [0].time;
var CurveTimeMax = Curve.keys [Curve.length - 1].time;
var Pixels = Target.GetPixels();
for (int x = 0; x < w; x++)
{
var xf = x / Range;
var Time = Mathf.Lerp(CurveTimeMin, CurveTimeMax, xf);
var Value = Curve.Evaluate(Time);
// todo; scale value to min/max of curve? maybe neccessary for non-float textures
Colour.r = Value;
Colour.g = Value;
Colour.b = Value;
for (int y = 0; y < Target.height; y++)
{
Pixels [x + y * w] = Colour;
}
}
Target.SetPixels(Pixels);
Target.Apply();
OnGenerated.Invoke(Target);
}
void OnEnable()
{
// invoke event, but only generate texture if required
OnGenerated.Invoke(GetTexture());
}
void BlitFrame()
{
Graphics.Blit(null, RenderedFrame, FrameRenderer);
OnTextureUpdated.Invoke(RenderedFrame);
}
void Update()
{
var OutputImage = ProcessImage();
OnChanged.Invoke(OutputImage);
}
