public void Update(IPluginIO pin, DX11RenderContext context)
        {
            if (this.FInvalidate || this.FEmpty)
            {
                for (int i = 0; i < this.scenes.Count; i++)
                {
                    if (scenes[i] != null)
                    {
                        AssimpScene scene = scenes[i];

                        for (int j = 0; j < scene.MeshCount; j++)
                        {
                            AssimpMesh assimpmesh = scene.Meshes[j];

                            List<int> inds = assimpmesh.Indices;

                            if (inds.Count > 0 && assimpmesh.VerticesCount > 0)
                            {
                                var indexstream = new DataStream(inds.Count * 4, true, true);
                                indexstream.WriteRange(inds.ToArray());
                                indexstream.Position = 0;

                                DX11IndexOnlyGeometry geom = new DX11IndexOnlyGeometry(context);
                                geom.IndexBuffer = new DX11IndexBuffer(context, indexstream, false, true);
                                geom.InputLayout = assimpmesh.GetInputElements().ToArray();
                                geom.Topology = PrimitiveTopology.TriangleList;
                                geom.HasBoundingBox = true;
                                geom.BoundingBox = assimpmesh.BoundingBox;

                                DX11DynamicStructuredBuffer<Vector3> p =
                                    new DX11DynamicStructuredBuffer<Vector3>(context, assimpmesh.PositionPointer, assimpmesh.VerticesCount);

                                DX11DynamicStructuredBuffer<Vector3> n =
                                    new DX11DynamicStructuredBuffer<Vector3>(context, assimpmesh.NormalsPointer, assimpmesh.VerticesCount);

                                if (assimpmesh.UvChannelCount > 0)
                                {

                                    DX11DynamicStructuredBuffer<Vector3> u =
                                    new DX11DynamicStructuredBuffer<Vector3>(context, assimpmesh.GetUvPointer(0), assimpmesh.VerticesCount);

                                    this.FOutUvs[i][j][context] = u;
                                }

                                DX11RawBuffer rb = new DX11RawBuffer(context, geom.IndexBuffer.Buffer);

                                this.FOutPosition[i][j][context] = p;
                                this.FOutNormals[i][j][context] = n;
                                this.FOutGeom[i][j][context] = geom;
                                this.FOutIndices[i][j][context] = rb;
                            }

                        }
                    }
                }
                this.FInvalidate = false;
                this.FEmpty = false;
            }
        }
        public void Update(IPluginIO pin, DX11RenderContext context)
        {
            if (this.ibo == null)
            {
                uint[] faceIndices = faceModel.TriangleIndices.ToArray();

                fixed (uint* uPtr = &faceIndices[0])
                {
                    DataStream ds = new DataStream(new IntPtr(uPtr), faceIndices.Length * 4, true, true);
                    this.ibo = new DX11IndexBuffer(context, ds, false, false);
                }

                this.FOutGeom[0][context] = new DX11IndexOnlyGeometry(context);
                this.FOutGeom[0][context].IndexBuffer = this.ibo;
            }

            if (this.faceVertexBuffer == null)
            {
                this.faceVertexBuffer = new DX11DynamicStructuredBuffer<Vector3>(context, (int)FaceModel.VertexCount);
                this.FOutFaceVertices[0][context] = this.faceVertexBuffer;

                this.faceUVBuffer = new DX11DynamicStructuredBuffer<Vector2>(context, (int)FaceModel.VertexCount);
                this.FOutFaceUV[0][context] = this.faceUVBuffer;
            }

            if (this.FInvalidate)
            {
                fixed (CameraSpacePoint* cPtr = &this.cameraPoints[0])
                {
                    this.faceVertexBuffer.WriteData(new IntPtr(cPtr));
                }
                fixed (ColorSpacePoint* cPtr = &this.colorPoints[0])
                {
                    this.faceUVBuffer.WriteData(new IntPtr(cPtr));
                }

                this.FInvalidate = false;
            }
        }
Example #3
0
        private void BindBuffers(DX11RenderContext context)
        {
            if (this.worldbuffer != null)
            {
                if (this.worldbuffer.ElementCount != this.FInWorld.SliceCount)
                {
                    this.worldbuffer.Dispose(); this.worldbuffer = null;
                }
            }

            if (this.colorbuffer != null)
            {
                if (this.colorbuffer.ElementCount != this.FInColor.SliceCount)
                {
                    this.colorbuffer.Dispose(); this.colorbuffer = null;
                }
            }

            if (this.FInTexture.PluginIO.IsConnected)
            {
                if (this.uvbuffer != null)
                {
                    if (this.uvbuffer.ElementCount != this.FInTexTransform.SliceCount)
                    {
                        this.uvbuffer.Dispose(); this.uvbuffer = null;
                    }
                }
                if (this.uvbuffer == null) { this.uvbuffer = new DX11DynamicStructuredBuffer<Matrix>(context, this.FInTexTransform.SliceCount); }

                quadshader.SetBySemantic("TEXTUREMATRIXCOUNT", this.uvbuffer.ElementCount);
                quadshader.SetBySemantic("TEXTUREMATRIXBUFFER", this.uvbuffer.SRV);

                this.uvbuffer.WriteData(this.FInTexTransform.ToArray());
            }

            if (this.worldbuffer == null) { this.worldbuffer = new DX11DynamicStructuredBuffer<Matrix>(context, this.FInWorld.SliceCount); }
            if (this.colorbuffer == null) { this.colorbuffer = new DX11DynamicStructuredBuffer<Color4>(context, this.FInColor.SliceCount); }

            this.worldbuffer.WriteData(this.FInWorld.ToArray());
            this.colorbuffer.WriteData(this.FInColor.ToArray());

            quadshader.SetBySemantic("WORLDBUFFER", this.worldbuffer.SRV);
            quadshader.SetBySemantic("COLORBUFFER", this.colorbuffer.SRV);

            quadshader.SetBySemantic("WORLDCOUNT", this.worldbuffer.ElementCount);
            quadshader.SetBySemantic("COLORCOUNT", this.colorbuffer.ElementCount);
        }
Example #4
0
        public void Update(IPluginIO pin, DX11RenderContext context)
        {
            if (!this.FTextureOutput[0].Contains(context))
            {
                this.FTextureOutput[0][context] = new DX11DynamicTexture2D(context, this.width, this.height, SlimDX.DXGI.Format.R8G8B8A8_UNorm);
                this.FPCOut[0][context] = new DX11DynamicStructuredBuffer<float>(context, 640 * 480 * 6);

            }

            if (this.FInvalidate)
            {
                fixed (int* f = &this.pic[0])
                {
                    IntPtr ptr = new IntPtr(f);
                    this.FTextureOutput[0][context].WriteData(ptr, this.width * this.height * 4);
                }

                /*fixed (float* f = &this.piccloud[0])
                {*
                    IntPtr ptr = new IntPtr(f);*/

                    DX11DynamicStructuredBuffer<float> db = (DX11DynamicStructuredBuffer<float>)this.FPCOut[0][context];
                    db.WriteData(this.piccloud);
                //}

                this.FInvalidate = false;
            }

            if (this.FInVoxels[0])
            {
                if (this.FOutVoxels[0].Contains(context))
                {
                    this.FOutVoxels[0].Dispose(context);
                }

                short[] data = new short[this.VoxelResolutionX * this.VoxelResolutionY * this.VoxelResolutionZ];

                this.colorVolume.ExportVolumeBlock(0, 0, 0, this.VoxelResolutionX, this.VoxelResolutionY, this.VoxelResolutionZ, 1, data);

                DX11DynamicStructuredBuffer<int> b = new DX11DynamicStructuredBuffer<int>(context, this.VoxelResolutionX * this.VoxelResolutionY * this.VoxelResolutionZ);

                int[] idata = new int[this.VoxelResolutionX * this.VoxelResolutionY * this.VoxelResolutionZ];

                for (int i = 0; i < this.VoxelResolutionX * this.VoxelResolutionY * this.VoxelResolutionZ; i++)
                {
                    idata[i] = data[i];
                }

                b.WriteData(idata);

                this.FOutVoxels[0][context] = b;
            }

            if (this.FInExport[0])
            {
                if (this.FGeomOut[0].Contains(context))
                {
                    this.FGeomOut[0].Dispose(context);
                }

                if (this.colorVolume != null)
                {
                    ColorMesh m = this.colorVolume.CalculateMesh(this.FInGeomVoxelStep[0]);

                    DX11IndexedGeometry geom = new DX11IndexedGeometry(context);

                    ReadOnlyCollection<int> inds = m.GetTriangleIndexes();

                    DataStream ds = new DataStream(inds.Count*4,true,true);
                    ds.WriteRange<int>(inds.ToArray());
                    ds.Position = 0;

                    DX11IndexBuffer ibo = new DX11IndexBuffer(context, ds, false, true);

                    ReadOnlyCollection<Microsoft.Kinect.Toolkit.Fusion.Vector3> pos = m.GetVertices();
                    ReadOnlyCollection<Microsoft.Kinect.Toolkit.Fusion.Vector3> norm = m.GetNormals();
                    ReadOnlyCollection<int> col = m.GetColors();

                    DataStream dsv = new DataStream(Pos3Norm3Vertex.VertexSize * pos.Count,true,true);

                    SlimDX.Vector3 bmin = new SlimDX.Vector3(float.MaxValue, float.MaxValue, float.MaxValue);
                    SlimDX.Vector3 bmax = new SlimDX.Vector3(float.MinValue, float.MinValue, float.MinValue);

                    for (int i = 0; i < pos.Count; i++)
                    {
                        Microsoft.Kinect.Toolkit.Fusion.Vector3 p = pos[i];
                        Microsoft.Kinect.Toolkit.Fusion.Vector3 n = norm[i];

                        dsv.Write<Microsoft.Kinect.Toolkit.Fusion.Vector3>(p);
                        dsv.Write<Microsoft.Kinect.Toolkit.Fusion.Vector3>(n);
                        dsv.Write<int>(col[i]);

                        if (p.X < bmin.X) { bmin.X = p.X; }
                        if (p.Y < bmin.Y) { bmin.Y = p.Y; }
                        if (p.Z < bmin.Z) { bmin.Z = p.Z; }

                        if (p.X > bmax.X) { bmax.X = p.X; }
                        if (p.Y > bmax.Y) { bmax.Y = p.Y; }
                        if (p.Z > bmax.Z) { bmax.Z = p.Z; }
                    }

                    geom.IndexBuffer = ibo;
                    geom.HasBoundingBox = true;
                    geom.InputLayout = FusionColoredVertex.Layout;
                    geom.Topology = SlimDX.Direct3D11.PrimitiveTopology.TriangleList;
                    geom.VertexSize = FusionColoredVertex.VertexSize;
                    geom.VertexBuffer = BufferHelper.CreateVertexBuffer(context, dsv, false, true);
                    geom.VerticesCount = pos.Count;
                    geom.BoundingBox = new BoundingBox(bmin, bmax);

                    this.FGeomOut[0][context] = geom;

                    m.Dispose();
                }
            }
        }