public void Evaluate(int SpreadMax)
        {
            this.FOutValid.SliceCount  = 1;
            this.FStreamOut.SliceCount = 1;

            if (this.FRead[0])
            {
                this.FBufferIn.Sync();
                if (this.FBufferIn.IsConnected)
                {
                    if (this.RenderRequest != null)
                    {
                        this.RenderRequest(this, this.FHost);
                    }

                    if (this.AssignedContext == null)
                    {
                        this.FOutValid.SliceCount = 0; return;
                    }

                    var context = this.AssignedContext;

                    if (this.FBufferIn[0].Contains(this.AssignedContext))
                    {
                        var rawBuffer = this.FBufferIn[0][context];

                        if (this.lastBuffer != null)
                        {
                            if (rawBuffer.Buffer.Description.SizeInBytes != lastBuffer.Size)
                            {
                                this.lastStream.Dispose();
                                this.lastStream = null;
                                this.lastBuffer.Dispose();
                                this.lastBuffer = null;
                            }
                        }

                        if (this.lastBuffer == null)
                        {
                            this.lastBuffer = new DX11StagingRawBuffer(context.Device, rawBuffer.Buffer.Description.SizeInBytes);
                            this.lastStream = new MemoryStream(rawBuffer.Buffer.Description.SizeInBytes);
                        }
                        lastStream.Position = 0;
                        context.CurrentDeviceContext.CopyResource(rawBuffer.Buffer, this.lastBuffer.Buffer);

                        DataStream ds = this.lastBuffer.MapForRead(context.CurrentDeviceContext);
                        ds.CopyTo(lastStream);
                        lastStream.Position = 0;
                        this.lastBuffer.UnMap(context.CurrentDeviceContext);

                        FStreamOut[0] = lastStream;
                        FStreamOut.Flush(true);
                    }
                }
            }
        }
        public void Evaluate(int SpreadMax)
        {
            if (this.FInput.IsConnected)
            {
                if (this.RenderRequest != null)
                {
                    this.RenderRequest(this, this.FHost);
                }

                DX11RawBuffer b = this.FInput[0][this.AssignedContext];

                if (b != null)
                {
                    DX11StagingRawBuffer staging = new DX11StagingRawBuffer(this.AssignedContext.Device, b.Size);

                    this.AssignedContext.CurrentDeviceContext.CopyResource(b.Buffer, staging.Buffer);
                    int elem = b.Size / this.FInStride[0];
                    foreach (IIOContainer sp in this.outspreads)
                    {
                        ISpread s = (ISpread)sp.RawIOObject;
                        s.SliceCount = elem;
                    }

                    DataStream ds = staging.MapForRead(this.AssignedContext.CurrentDeviceContext);

                    for (int i = 0; i < elem; i++)
                    {
                        int cnt = 0;
                        foreach (string lay in layout)
                        {
                            switch (lay)
                            {
                            case "float":
                                ISpread <float> spr = (ISpread <float>) this.outspreads[cnt].RawIOObject;
                                spr[i] = ds.Read <float>();
                                break;

                            case "float2":
                                ISpread <Vector2> spr2 = (ISpread <Vector2>) this.outspreads[cnt].RawIOObject;
                                spr2[i] = ds.Read <Vector2>();
                                break;

                            case "float3":
                                ISpread <Vector3> spr3 = (ISpread <Vector3>) this.outspreads[cnt].RawIOObject;
                                spr3[i] = ds.Read <Vector3>();
                                break;

                            case "float4":
                                ISpread <Vector4> spr4 = (ISpread <Vector4>) this.outspreads[cnt].RawIOObject;
                                spr4[i] = ds.Read <Vector4>();
                                break;

                            case "float4x4":
                                ISpread <Matrix> sprm = (ISpread <Matrix>) this.outspreads[cnt].RawIOObject;
                                sprm[i] = ds.Read <Matrix>();
                                break;

                            case "int":
                                ISpread <int> spri = (ISpread <int>) this.outspreads[cnt].RawIOObject;
                                spri[i] = ds.Read <int>();
                                break;

                            case "uint":
                                ISpread <uint> sprui = (ISpread <uint>) this.outspreads[cnt].RawIOObject;
                                sprui[i] = ds.Read <uint>();
                                break;

                            case "uint2":
                                ISpread <Vector2> sprui2 = (ISpread <Vector2>) this.outspreads[cnt].RawIOObject;
                                uint ui1 = ds.Read <uint>();
                                uint ui2 = ds.Read <uint>();
                                sprui2[i] = new Vector2(ui1, ui2);
                                break;

                            case "uint3":
                                ISpread <Vector3> sprui3 = (ISpread <Vector3>) this.outspreads[cnt].RawIOObject;
                                uint ui31 = ds.Read <uint>();
                                uint ui32 = ds.Read <uint>();
                                uint ui33 = ds.Read <uint>();
                                sprui3[i] = new Vector3(ui31, ui32, ui33);
                                break;
                            }
                            cnt++;
                        }
                    }

                    staging.UnMap(this.AssignedContext.CurrentDeviceContext);

                    staging.Dispose();
                }
                else
                {
                    foreach (IIOContainer sp in this.outspreads)
                    {
                        ISpread s = (ISpread)sp.RawIOObject;
                        s.SliceCount = 0;
                    }
                }
            }
            else
            {
                foreach (IIOContainer sp in this.outspreads)
                {
                    ISpread s = (ISpread)sp.RawIOObject;
                    s.SliceCount = 0;
                }
            }
        }