配置数据属性.
Inheritance: Attribute
        public DX11RendererNode(IPluginHost host, IIOFactory iofactory,IHDEHost hdehost)
        {
            InitializeComponent();
            this.FHost = host;
            this.hde = hdehost;

            //this.hde.BeforeComponentModeChange += new ComponentModeEventHandler(hde_BeforeComponentModeChange);

            this.Resize += DX11RendererNode_Resize;
            this.Load += new EventHandler(DX11RendererNode_Load);
            this.Click += new EventHandler(DX11RendererNode_Click);
            this.MouseEnter += new EventHandler(DX11RendererNode_MouseEnter);
            this.MouseLeave += new EventHandler(DX11RendererNode_MouseLeave);
            this.LostFocus += new EventHandler(DX11RendererNode_LostFocus);
            this.MouseWheel += new System.Windows.Forms.MouseEventHandler(DX11RendererNode_MouseWheel);
            this.BackColor = Color.Black;
            Touchdown += OnTouchDownHandler;
            Touchup += OnTouchUpHandler;
            TouchMove += OnTouchMoveHandler;

            this.depthmanager = new DepthBufferManager(host,iofactory);

            ConfigAttribute bbAttr = new ConfigAttribute("Back Buffer Format");
            bbAttr.IsSingle = true;
            bbAttr.EnumName = DX11EnumFormatHelper.NullDeviceFormats.GetEnumName(FormatSupport.BackBufferCast);
            bbAttr.DefaultEnumEntry = DX11EnumFormatHelper.NullDeviceFormats.GetAllowedFormats(FormatSupport.BackBufferCast)[0];

            this.FCfgBackBufferFormat = iofactory.CreateDiffSpread<EnumEntry>(bbAttr);
            this.FCfgBackBufferFormat[0] = new EnumEntry(DX11EnumFormatHelper.NullDeviceFormats.GetEnumName(FormatSupport.BackBufferCast), 0);
        }
        public DepthBufferManager(IPluginHost host, IIOFactory factory)
        {
            this.host = host;
            this.factory = factory;

            ConfigAttribute cattr = new ConfigAttribute("Depth Buffer Mode");
            cattr.IsSingle = true;
            pinmode = this.factory.CreateDiffSpread<eDepthBufferMode>(cattr);

            pinmode.Changed += Pinmode_Changed;

            this.currentmode = eDepthBufferMode.None;
        }
        public RenderTargetManager(IPluginHost host, IIOFactory iofactory)
        {
            this.host = host;
            this.iofactory = iofactory;

            ConfigAttribute cattr = new ConfigAttribute("Texture Input Mode");
            cattr.IsSingle = true;
            cattr.DefaultEnumEntry = "Manual";

            pinmode = this.iofactory.CreateIOContainer<IDiffSpread<eRenderFormatMode>>(cattr);
            pinmode.IOObject.Changed += Pinmode_Changed;

            this.currentmode = eRenderFormatMode.Manual;

            this.CreateFormat();
            this.CreateSize();
        }
        public DX11RendererNode2(IPluginHost host, IIOFactory iofactory)
        {
            this.ctrl = new Control();
            this.ctrl.Dock = DockStyle.Fill;
            this.ctrl.Resize += new EventHandler(ctrl_Resize);

            this.depthmanager = new DepthBufferManager(host, iofactory);

            ConfigAttribute bbAttr = new ConfigAttribute("Back Buffer Format");
            bbAttr.IsSingle = true;
            bbAttr.EnumName = DX11EnumFormatHelper.NullDeviceFormats.GetEnumName(FormatSupport.BackBufferCast);
            bbAttr.DefaultEnumEntry = DX11EnumFormatHelper.NullDeviceFormats.GetAllowedFormats(FormatSupport.BackBufferCast)[0];

            this.FCfgBackBufferFormat = iofactory.CreateDiffSpread<EnumEntry>(bbAttr);
            this.FCfgBackBufferFormat[0] = new EnumEntry(DX11EnumFormatHelper.NullDeviceFormats.GetEnumName(FormatSupport.BackBufferCast), 0);
            this.FCfgBackBufferFormat.Changed += new SpreadChangedEventHander<EnumEntry>(FCfgBackBufferFormat_Changed);
        }
        private void Pinmode_Changed(IDiffSpread<eDepthBufferMode> spread)
        {
            if (this.currentmode != spread[0])
            {

                if (this.currentmode == eDepthBufferMode.Standard)
                {
                    if (this.depthoutputpin != null)
                    {
                        //Destroy depth stencil
                        if (this.depthoutputpin.IOObject[0] != null)
                        {
                            this.depthoutputpin.IOObject[0].Dispose();
                        }

                        this.depthoutputpin.Dispose();
                        this.depthformatpin.Dispose();

                        this.depthformatpin = null;
                        this.depthoutputpin = null;
                    }
                }

                if (this.currentmode == eDepthBufferMode.ReadOnly)
                {
                    if (this.depthinputpin != null)
                    {
                        this.depthinputpin.Dispose();
                        this.depthinputpin = null;
                    }
                }

                this.currentmode = spread[0];
                if (this.currentmode == eDepthBufferMode.Standard)
                {
                    OutputAttribute oattr = new OutputAttribute("Depth Buffer");
                    oattr.IsSingle = true;

                    this.depthoutputpin = this.factory.CreateIOContainer<Pin<DX11Resource<DX11DepthStencil>>>(oattr);
                    this.depthoutputpin.IOObject[0] = new DX11Resource<DX11DepthStencil>();

                    ConfigAttribute dfAttr = new ConfigAttribute("Depth Buffer Format");
                    dfAttr.EnumName = DX11EnumFormatHelper.NullDeviceFormats.GetEnumName(FormatSupport.DepthStencil);
                    dfAttr.DefaultEnumEntry = DX11EnumFormatHelper.NullDeviceFormats.GetAllowedFormats(FormatSupport.DepthStencil)[0];
                    dfAttr.IsSingle = true;

                    this.depthformatpin = this.factory.CreateIOContainer<IDiffSpread<EnumEntry>>(dfAttr);
                    this.depthformatpin.IOObject[0] = new EnumEntry(dfAttr.EnumName, 1);

                    this.depthformatpin.IOObject.Changed += depthformatpin_Changed;
                }

                if (this.currentmode == eDepthBufferMode.ReadOnly)
                {
                    InputAttribute oattr = new InputAttribute("Depth Buffer");
                    oattr.IsSingle = true;

                    this.depthinputpin = this.factory.CreateIOContainer<Pin<DX11Resource<DX11DepthStencil>>>(oattr);
                }

                this.NeedReset = true;
            }
        }
Beispiel #6
0
 public ActionResult SaveConfigurationAttribute(int id = 0, string value = null, int configtypeid = 0)
 {
     ConfigAttribute attribute = new ConfigAttribute();
     string error = "";
     try {
         attribute = new ACES().SaveConfigurationAttr(id, value, configtypeid);
     } catch (Exception e) {
         error = e.Message;
         if (id == 0) {
             return RedirectToAction("AddConfigurationAttribute", new { error = error });
         } else {
             return RedirectToAction("EditConfigurationAttribute", new { id = id, error = error });
         }
     }
     return RedirectToAction("ConfigAttributes");
 }
 public ScannedConfigRegistion(AttributeAndTypeInfo info)
 {
     this.configAttribute = (ConfigAttribute)info.Attribute;
     this.objectType      = info.Type;
 }
Beispiel #8
0
 public void Configure(IConfigSectionNode fromNode)
 {
     m_ScriptRunner.Configure(fromNode[ScriptRunner.CONFIG_SCRIPT_RUNNER_SECTION]);
     ConfigAttribute.Apply(this, fromNode);
     DoConfigure(fromNode);
 }
 protected CryptoMessageAlgorithm(ICryptoManagerImplementation director, IConfigSectionNode config) : base(director)
 {
     ConfigAttribute.Apply(this, config.NonEmpty("{0}.ctor(config=null|!Exists)".Args(GetType().Name)));
 }
Beispiel #10
0
 public void Configure(IConfigSectionNode node)
 {
     EnsureNotCompiled();
     ConfigAttribute.Apply(this, node);
 }
Beispiel #11
0
 protected override void DoConfigure(Environment.IConfigSectionNode node)
 {
     base.DoConfigure(node);
     ConfigAttribute.Apply(m_DataStore, node);
 }
Beispiel #12
0
 public LatencyInstrumentationFilter(WorkHandler handler, IConfigSectionNode confNode) : base(handler, confNode)
 {
     ConfigAttribute.Apply(this, confNode);
 }
            public GameStartContextEditing(Type type)
            {
                this.type = type;

                foreach(var f in type.GetFields())
                {
                    if(f.IsPublic)
                    {
                        fields.Add(new CustomField(f));
                    }
                }

                var attr = type.GetCustomAttributes(typeof(ConfigAttribute), true);
                foreach(var a in attr)
                {
                    var at = a as ConfigAttribute;
                    this.attribute = at;
                }
            }
        public DX11TextureSpreadRendererNode(IPluginHost FHost, IIOFactory iofactory)
        {
            string ename = DX11EnumFormatHelper.NullDeviceFormats.GetEnumName(FormatSupport.RenderTarget);

            InputAttribute tattr = new InputAttribute("Target Format");
            tattr.EnumName = ename;
            tattr.DefaultEnumEntry = "R8G8B8A8_UNorm";

            ConfigAttribute dfAttr = new ConfigAttribute("Depth Buffer Format");
            dfAttr.EnumName = DX11EnumFormatHelper.NullDeviceFormats.GetEnumName(FormatSupport.DepthStencil);
            dfAttr.DefaultEnumEntry = "D32_Float";
            dfAttr.IsSingle = true;

            this.depthformatpin = iofactory.CreateDiffSpread<EnumEntry>(dfAttr);
            this.depthformatpin[0] = new EnumEntry(dfAttr.EnumName, 1);

            this.FInFormat = iofactory.CreateDiffSpread<EnumEntry>(tattr);
        }