Exemple #1
0
        private static IDX11Geometry AssignInstancedDrawer(DrawDescription desc, IDX11Geometry geometry)
        {
            var indexedGeometry = geometry as DX11IndexedGeometry;

            if (indexedGeometry != null)
            {
                if (!(indexedGeometry.Drawer is DX11InstancedIndexedDrawer))
                {
                    indexedGeometry = (DX11IndexedGeometry)indexedGeometry.ShallowCopy();
                    var drawer = new DX11InstancedIndexedDrawer();
                    drawer.InstanceCount         = desc.InstanceCount;
                    drawer.StartInstanceLocation = 0;
                    indexedGeometry.AssignDrawer(drawer);
                    geometry = indexedGeometry;
                }
            }
            else
            {
                var vertexGeometry = geometry as DX11VertexGeometry;
                if (vertexGeometry != null)
                {
                    if (!(vertexGeometry.Drawer is DX11InstancedVertexDrawer))
                    {
                        vertexGeometry = (DX11VertexGeometry)vertexGeometry.ShallowCopy();
                        var drawer = new DX11InstancedVertexDrawer();
                        drawer.InstanceCount         = desc.InstanceCount;
                        drawer.StartInstanceLocation = 0;
                        vertexGeometry.AssignDrawer(drawer);
                        geometry = vertexGeometry;
                    }
                }
            }

            return(geometry);
        }
        public override DX11VertexGeometry Convolute(DX11VertexGeometry input)
        {
            DX11VertexGeometry        result = (DX11VertexGeometry)input.ShallowCopy();
            DX11InstancedVertexDrawer d      = new DX11InstancedVertexDrawer();

            result.AssignDrawer(d);
            d.InstanceCount = this.InstanceCount;
            return(result);
        }
        public void Update(IPluginIO pin, DX11RenderContext context)
        {
            for (int i = 0; i < this.FOutGeom.SliceCount; i++)
            {
                DX11VertexGeometry geom = (DX11VertexGeometry)this.FInGeom[i][context].ShallowCopy();
                if (this.FInEnabled[i])
                {
                    DX11InstancedVertexDrawer d = new DX11InstancedVertexDrawer();
                    d.InstanceCount = this.FInCnt[i];

                    geom.AssignDrawer(d);
                }

                this.FOutGeom[i][context] = geom;
            }
        }
        public void Update(IPluginIO pin, DX11RenderContext context)
        {
            for (int i = 0; i < this.FOutGeom.SliceCount; i++)
            {
                IDX11Geometry g    = this.FInGeom[i][context];
                bool          done = false;
                if (g is DX11IndexedGeometry)
                {
                    DX11IndexedGeometry geom = (DX11IndexedGeometry)this.FInGeom[i][context].ShallowCopy();
                    if (this.FInEnabled[i])
                    {
                        DX11InstancedIndexedDrawer d = new DX11InstancedIndexedDrawer();
                        d.InstanceCount         = this.FInCnt[i];
                        d.StartInstanceLocation = this.FInSL[0];
                        geom.AssignDrawer(d);
                    }
                    this.FOutGeom[i][context] = geom;
                    done = true;
                }

                if (g is DX11VertexGeometry)
                {
                    DX11VertexGeometry geom = (DX11VertexGeometry)this.FInGeom[i][context].ShallowCopy();
                    if (this.FInEnabled[i])
                    {
                        DX11InstancedVertexDrawer d = new DX11InstancedVertexDrawer();
                        d.InstanceCount         = this.FInCnt[i];
                        d.StartInstanceLocation = this.FInSL[0];
                        geom.AssignDrawer(d);
                    }
                    this.FOutGeom[i][context] = geom;
                    done = true;
                }


                if (!done)
                {
                    this.FOutGeom[i][context] = g;
                }
            }
        }
        public override IDxGeometry Convolute(IDxGeometry input)
        {
            IDxGeometry result = input.ShallowCopy();

            if (result is DX11IndexedGeometry)
            {
                DX11IndexedGeometry        indexed = (DX11IndexedGeometry)result;
                DX11InstancedIndexedDrawer d       = new DX11InstancedIndexedDrawer();
                indexed.AssignDrawer(d);
                d.InstanceCount = this.InstanceCount;
                indexed.AssignDrawer(d);
            }

            if (result is DX11VertexGeometry)
            {
                DX11VertexGeometry        vertex = (DX11VertexGeometry)result;
                DX11InstancedVertexDrawer d      = new DX11InstancedVertexDrawer();
                vertex.AssignDrawer(d);
                d.InstanceCount = this.InstanceCount;
                vertex.AssignDrawer(d);
            }

            return(result);
        }