コード例 #1
0
ファイル: DX11GraphBuilder.cs プロジェクト: vnmone/dx11-vvvv
        protected override bool ProcessAddedNode(INode2 node)
        {
            if (node.IsNodeAssignableFrom <N>() || node.IsNodeAssignableFrom <IDX11ResourceDataRetriever>())
            {
                DX11Node vn = new DX11Node(node.InternalCOMInterf);

                this.graph.Nodes.Add(vn);

                //If force updater, register event
                if (node.IsNodeAssignableFrom <IDX11ResourceDataRetriever>())
                {
                    IDX11ResourceDataRetriever updater = vn.Instance <IDX11ResourceDataRetriever>();
                    updater.RenderRequest += OnRenderRequest;
                }

                foreach (IPin2 p in node.Pins)
                {
                    this.ProcessAddedPin(p, true);
                }
                return(true);
            }

            return(false);
        }
コード例 #2
0
        private void ProcessNode(DX11Node node)
        {
            //Node already processed
            if (this.processed.Contains(node))
            {
                return;
            }

            //Node can block processing and do early graph cut
            if (node.IsAssignable <IDX11UpdateBlocker>())
            {
                if (!node.Instance <IDX11UpdateBlocker>().Enabled)
                {
                    //Add to processed list and early exit on branch.
                    this.processed.Add(node);
                    return;
                }
            }

            //Got to all parents recursively (eg: make sure all is updated)
            foreach (DX11InputPin ip in node.InputPins)
            {
                if (ip.IsConnected && (ip.ParentPin.IsFeedBackPin == false))
                {
                    this.ProcessNode(ip.ParentPin.ParentNode);
                }
            }

            //Call Update
            foreach (DX11InputPin ip in node.InputPins)
            {
                if (ip.IsConnected)
                {
                    DX11OutputPin parent = ip.ParentPin;

                    if (!this.thisframepins.Contains(parent))
                    {
                        DX11Node source = parent.ParentNode;

                        IDX11ResourceProvider provider = source.Instance <IDX11ResourceProvider>();

                        try
                        {
                            provider.Update(parent.PluginIO, this.context);

                            if (source.IsAssignable <IDX11MultiResourceProvider>())
                            {
                                if (this.DoNotDestroy == false)
                                {
                                    //Mark all output pins as processed
                                    foreach (DX11OutputPin outpin in source.OutputPins)
                                    {
                                        this.thisframepins.Add(outpin);
                                    }
                                }
                            }
                            else
                            {
                                if (this.DoNotDestroy == false)
                                {
                                    //Mark output pin as used this frame
                                    this.thisframepins.Add(parent);
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            this.logger.Log(LogType.Error, "Exception caused by node during update :" + node.HdeNode.GetNodePath(false));
                            this.logger.Log(ex);
                            this.logger.Log(LogType.Message, "Stack Trace");
                            this.logger.Log(LogType.Message, ex.StackTrace);
                        }

                        if (this.DoNotDestroy == false)
                        {
                            //Remove from old cache if applicable
                            if (this.lastframepins.Contains(parent))
                            {
                                this.lastframepins.Remove(parent);
                            }
                        }
                    }
                }
            }

            //Render if renderer
            if (node.IsAssignable <IDX11RendererProvider>())
            {
                try
                {
                    IDX11RendererProvider provider = node.Instance <IDX11RendererProvider>();
                    provider.Render(this.context);
                }
                catch (Exception ex)
                {
                    this.logger.Log(LogType.Error, "Exception caused by node during render :" + node.HdeNode.GetNodePath(false));
                    this.logger.Log(ex);
                    this.logger.Log(LogType.Message, "Stack Trace");
                    this.logger.Log(LogType.Message, ex.StackTrace);
                }
            }

            //Node fully processed
            this.processed.Add(node);
        }
コード例 #3
0
        private void ProcessNode(DX11Node node)
        {
            //Node already processed
            if (this.processed.Contains(node)) { return; }

            //Node can block processing and do early graph cut
            if (node.IsAssignable<IDX11UpdateBlocker>())
            {
                if (!node.Instance<IDX11UpdateBlocker>().Enabled)
                {
                    //Add to processed list and early exit on branch.
                    this.processed.Add(node);
                    return;
                }
            }

            //Got to all parents recursively (eg: make sure all is updated)
            foreach (DX11InputPin ip in node.InputPins)
            {
                if (ip.IsConnected && (ip.ParentPin.IsFeedBackPin == false))
                {
                    this.ProcessNode(ip.ParentPin.ParentNode);
                }
            }

            //Call Update
            foreach (DX11InputPin ip in node.InputPins)
            {
                if (ip.IsConnected)
                {
                    DX11OutputPin parent = ip.ParentPin;

                    if (!this.thisframepins.Contains(parent))
                    {
                        DX11Node source = parent.ParentNode;

                        IDX11ResourceProvider provider = source.Instance<IDX11ResourceProvider>();

                        try
                        {
                            provider.Update(parent.PluginIO, this.context);

                            if (source.IsAssignable<IDX11MultiResourceProvider>())
                            {
                                if (this.DoNotDestroy == false)
                                {
                                    //Mark all output pins as processed
                                    foreach (DX11OutputPin outpin in source.OutputPins)
                                    {
                                        this.thisframepins.Add(outpin);
                                    }
                                }
                            }
                            else
                            {
                                if (this.DoNotDestroy == false)
                                {
                                    //Mark output pin as used this frame
                                    this.thisframepins.Add(parent);
                                }
                            }

                        }
                        catch (Exception ex)
                        {
                            this.logger.Log(LogType.Error, "Exception caused by node during update :" + node.HdeNode.GetNodePath(false));
                            this.logger.Log(ex);
                            this.logger.Log(LogType.Message,"Stack Trace");
                            this.logger.Log(LogType.Message, ex.StackTrace);
                        }

                        if (this.DoNotDestroy == false)
                        {
                            //Remove from old cache if applicable
                            if (this.lastframepins.Contains(parent))
                            {
                                this.lastframepins.Remove(parent);
                            }
                        }
                    }
                }

            }

            //Render if renderer
            if (node.IsAssignable<IDX11RendererProvider>())
            {
                try
                {
                    IDX11RendererProvider provider = node.Instance<IDX11RendererProvider>();
                    provider.Render(this.context);
                }
                catch (Exception ex)
                {
                    this.logger.Log(LogType.Error, "Exception caused by node during render :" + node.HdeNode.GetNodePath(false));
                    this.logger.Log(ex);
                    this.logger.Log(LogType.Message, "Stack Trace");
                    this.logger.Log(LogType.Message, ex.StackTrace);
                }
            }

            //Node fully processed
            this.processed.Add(node);
        }