コード例 #1
0
        /// <summary>
        /// Initializes the object with default values.
        /// </summary>
        public CoreNodeManager(
            IServerInternal          server,
            ApplicationConfiguration configuration,
            ushort                   dynamicNamespaceIndex)
        {
            if (server == null)        throw new ArgumentNullException("server");
            if (configuration == null) throw new ArgumentNullException("configuration");
                  
            m_server                         = server;
            m_nodes                          = new NodeTable(server.NamespaceUris, server.ServerUris, server.TypeTree);
            m_monitoredItems                 = new Dictionary<uint,MonitoredItem>();
            m_defaultMinimumSamplingInterval = 1000;
            m_namespaceUris                  = new List<string>();
            m_dynamicNamespaceIndex          = dynamicNamespaceIndex; 
            
            #if LEGACY_CORENODEMANAGER
            m_eventSources = new Dictionary<object,IEventSource>();
            #endif

            // use namespace 1 if out of range.
            if (m_dynamicNamespaceIndex == 0 || m_dynamicNamespaceIndex >= server.NamespaceUris.Count)
            {
                m_dynamicNamespaceIndex = 1;
            }

            m_samplingGroupManager = new SamplingGroupManager(
                server, 
                this,
                (uint)configuration.ServerConfiguration.MaxNotificationQueueSize,
                configuration.ServerConfiguration.AvailableSamplingRates);
        }
コード例 #2
0
        /// <summary>
        /// Initializes the object with default values.
        /// </summary>
        public NodeCache(Session session)
        {
            if (session == null) throw new ArgumentNullException("session");

            m_session  = session;
            m_typeTree = new TypeTable(m_session.NamespaceUris);
            m_nodes    = new NodeTable(m_session.NamespaceUris, m_session.ServerUris, m_typeTree);
        }
コード例 #3
0
        /// <summary>
        /// Initializes the object with default values.
        /// </summary>
        public NodeCache(Session session)
        {
            if (session == null)
            {
                throw new ArgumentNullException(nameof(session));
            }

            m_session  = session;
            m_typeTree = new TypeTable(m_session.NamespaceUris);
            m_nodes    = new NodeTable(m_session.NamespaceUris, m_session.ServerUris, m_typeTree);
        }
コード例 #4
0
ファイル: CFC.cs プロジェクト: davejoshmike/CSharpCircuitry
 private static void UpsertIntoNodeTable(Node node)
 {
     if (NodeTable.ContainsKey(node.NodeId))
     {
         NodeTable[node.NodeId] = node;
     }
     else
     {
         NodeTable.Add(node.NodeId, node);
     }
 }
コード例 #5
0
        /* Non-Terminals Procedures */

        private NodeTable ParseTable()
        {
            tempTable = new List <List <Token> >();
            Match(TokenType.TableBegin);
            NodeTable tbl = new NodeTable {
                RowList = ParseRowList()
            };

            Match(TokenType.TableEnd);
            return(tbl);
        }
コード例 #6
0
ファイル: Astar.cs プロジェクト: Akneman93/Solvers
 public Astar(ISuccGenerator <ANode> successorNodesGenerator,
              IHCalculator <ANode> hValueCalculator)
 {
     comparer      = new FComparer(this);
     succGen       = successorNodesGenerator;
     hCalc         = hValueCalculator;
     Name          = "A*";
     timeAvaliable = 5000;
     openList      = new NodeTable <ANode>(Comparer);
     closedList    = new NodeTable <ANode>(Comparer);
 }
コード例 #7
0
ファイル: CFC.cs プロジェクト: davejoshmike/CSharpCircuitry
 /// <summary>
 /// Populates the Circuit, Node and Pin tables
 /// </summary>
 /// <param name="circuit"></param>
 public static void RegisterCircuit(Circuit circuit)
 {
     CircuitTable.Add(circuit.CircuitId, circuit);
     foreach (Node node in circuit.Nodes)
     {
         NodeTable.Add(node.NodeId, node);
         foreach (Pin pin in node.Pins)
         {
             PinTable.Add(pin.PinId, pin);
         }
     }
 }
コード例 #8
0
        public void Initialize()
        {
            NetworkNodeDecoder.Init();
            _timestamp             = new Timestamp();
            _logManager            = new OneLoggerLogManager(new SimpleConsoleLogger());
            _configurationProvider = new ConfigProvider();
            INetworkConfig networkConfig = _configurationProvider.GetConfig <INetworkConfig>();

            networkConfig.DbBasePath = Path.Combine(Path.GetTempPath(), "PeerManagerTests");
            networkConfig.IsActivePeerTimerEnabled      = false;
            networkConfig.IsDiscoveryNodesPersistenceOn = false;
            networkConfig.IsPeersPersistenceOn          = false;

            if (!Directory.Exists(networkConfig.DbBasePath))
            {
                Directory.CreateDirectory(networkConfig.DbBasePath);
            }

            var   syncManager  = Substitute.For <ISynchronizationManager>();
            Block genesisBlock = Build.A.Block.Genesis.TestObject;

            syncManager.Head.Returns(genesisBlock.Header);
            syncManager.Genesis.Returns(genesisBlock.Header);

            _nodeFactory = new NodeFactory(LimboLogs.Instance);
            _localPeer   = new TestRlpxPeer();
            var keyProvider = new PrivateKeyGenerator(new CryptoRandom());
            var key         = keyProvider.Generate().PublicKey;

            _synchronizationManager = Substitute.For <ISynchronizationManager>();

            IStatsConfig statsConfig = _configurationProvider.GetConfig <IStatsConfig>();
            var          nodeTable   = new NodeTable(_nodeFactory, Substitute.For <IKeyStore>(), new NodeDistanceCalculator(networkConfig), networkConfig, _logManager);

            nodeTable.Initialize(new NodeId(key));

            _discoveryManager = new DiscoveryManager(new NodeLifecycleManagerFactory(_nodeFactory, nodeTable, new DiscoveryMessageFactory(networkConfig, _timestamp), Substitute.For <IEvictionManager>(), new NodeStatsProvider(_configurationProvider.GetConfig <IStatsConfig>(), _nodeFactory, _logManager, true), networkConfig, _logManager), _nodeFactory, nodeTable, new NetworkStorage("test", networkConfig, _logManager, new PerfService(_logManager)), networkConfig, _logManager);
            _discoveryManager.MessageSender = Substitute.For <IMessageSender>();
            _transactionPool = NullTransactionPool.Instance;
            _blockTree       = Substitute.For <IBlockTree>();
            var app = new DiscoveryApp(new NodesLocator(nodeTable, _discoveryManager, _configurationProvider, _logManager), _discoveryManager, _nodeFactory, nodeTable, Substitute.For <IMessageSerializationService>(), new CryptoRandom(), Substitute.For <INetworkStorage>(), networkConfig, _logManager, new PerfService(_logManager));

            app.Initialize(key);

            var sessionLogger = new PeerSessionLogger(_logManager, _configurationProvider, new PerfService(_logManager));

            sessionLogger.Init(Path.GetTempPath());
            var networkStorage = new NetworkStorage("test", networkConfig, _logManager, new PerfService(_logManager));

            _peerManager = new PeerManager(_localPeer, app, _synchronizationManager, new NodeStatsProvider(statsConfig, _nodeFactory, _logManager, true), networkStorage, _nodeFactory, _configurationProvider, new PerfService(_logManager), _transactionPool, _logManager, sessionLogger);
            _peerManager.Init(true);
        }
コード例 #9
0
 public AWA(ISuccGenerator <ANode> successorNodesGenerator,
            IHCalculator <ANode> hValueCalculator,
            int W)
 {
     succGen       = successorNodesGenerator;
     hCalc         = hValueCalculator;
     w             = W;
     Name          = "AWA*";
     timeAvaliable = 5000;
     comparer      = new FComparer(this);
     openList      = new NodeTable <ANode>(Comparer);
     closedList    = new NodeTable <ANode>(Comparer);
 }
コード例 #10
0
 public AWinA(ISuccGenerator <ANode> successorNodesGenerator,
              IHCalculator <ANode> hValueCalculator)
 {
     comparer      = new FComparer(this);
     suspendList   = new NodeTable <ANode>(comparer);
     succGen       = successorNodesGenerator;
     hCalc         = hValueCalculator;
     currentLvl    = -1;
     winSize       = 0;
     Name          = "AWinA*";
     timeAvaliable = 5000;
     openList      = new NodeTable <ANode>(Comparer);
     closedList    = new NodeTable <ANode>(Comparer);
 }
コード例 #11
0
ファイル: LevelData.cs プロジェクト: CrashOveride95/sa_tools
        public static List <Item> ImportFromFile(string filePath, Device d3ddevice, EditorCamera camera, out bool errorFlag, out string errorMsg, EditorItemSelection selectionManager)
        {
            List <Item> createdItems = new List <Item>();

            if (!File.Exists(filePath))
            {
                errorFlag = true;
                errorMsg  = "File does not exist!";
                return(null);
            }

            DirectoryInfo filePathInfo = new DirectoryInfo(filePath);

            bool   importError    = false;
            string importErrorMsg = "";

            switch (filePathInfo.Extension)
            {
            case ".obj":
            case ".objf":
                Vector3   pos  = camera.Position + (-20 * camera.Look);
                LevelItem item = new LevelItem(d3ddevice, filePath, new Vertex(pos.X, pos.Y, pos.Z), new Rotation(), LevelItems.Count, selectionManager)
                {
                    Visible = true
                };

                createdItems.Add(item);
                break;

            case ".txt":
                NodeTable.ImportFromFile(d3ddevice, filePath, out importError, out importErrorMsg, selectionManager);
                break;

            default:
                errorFlag = true;
                errorMsg  = "Invalid file format!";
                return(null);
            }

            StateChanged();

            errorFlag = importError;
            errorMsg  = importErrorMsg;

            return(createdItems);
        }
コード例 #12
0
        public NodeManager()
        {
            this.is_enable_discovery = Args.Instance.Node.Discovery.Enable ?? false;

            this.home_node = new Node(RefreshTask.GetNodeId(),
                                      Args.Instance.Node.Discovery.ExternalIP,
                                      Args.Instance.Node.ListenPort);

            foreach (string boot in Args.Instance.Seed.IpList)
            {
                this.boot_nodes.Add(Node.InstanceOf(boot));
            }

            Logger.Info(string.Format("home_node : {0}", this.home_node));
            Logger.Info(string.Format("boot_nodes : size= {0}", this.boot_nodes.Count));

            this.table = new NodeTable(this.home_node);
        }
コード例 #13
0
        public void TestNodeTraversal()
        {
            Circuit testCircuit = createTestCircuit01();

            RegisterCircuit(testCircuit);
            StepThroughCircuit(testCircuit.StartingNodeId);

            // Make sure every pin has been turned on by the NodeTraversal logic
            foreach (Node node in testCircuit.Nodes)
            {
                Assert.IsTrue(NodeTable.ContainsKey(node.NodeId));
                foreach (Pin pin in node.Pins)
                {
                    Assert.IsTrue(PinTable.ContainsKey(pin.PinId));
                    Assert.AreEqual(pin.State, StateEnum.ON);
                }
            }

            ClearAllTables();
        }
コード例 #14
0
        public Table Parse <T>(string fixtureHTML) where T : Fixture
        {
            this.Index  = -1;
            this.Tokens = (new Lexer()).Tokenize(fixtureHTML);
            NodeTable parseTree = ParseTable();

            PrintTree(parseTree);

            if (typeof(T) == typeof(ColumnFixture))
            {
                return(GenerateExampleTable());
            }
            else if (typeof(T) == typeof(ActionFixture))
            {
                return(GenerateActionTable());
            }
            else
            {
                throw new Exception("Invalid fixture Type");
            }
        }
コード例 #15
0
        public void Initialize()
        {
            _logger = new SimpleConsoleLogger();
            _configurationProvider            = new DiscoveryConfigurationProvider(new NetworkHelper(_logger));
            _configurationProvider.DbBasePath = Path.Combine(Path.GetTempPath(), "PeerManagerTests");
            _nodeFactory = new NodeFactory();
            _localPeer   = new TestRlpxPeer();
            var keyProvider = new PrivateKeyProvider(new CryptoRandom());
            var key         = keyProvider.PrivateKey.PublicKey;

            _synchronizationManager = Substitute.For <ISynchronizationManager>();

            var nodeTable = new NodeTable(_configurationProvider, _nodeFactory, Substitute.For <IKeyStore>(), _logger, new NodeDistanceCalculator(_configurationProvider));

            nodeTable.Initialize(key);

            _discoveryManager = new DiscoveryManager(_logger, _configurationProvider, new NodeLifecycleManagerFactory(_nodeFactory, nodeTable, _logger, _configurationProvider, new DiscoveryMessageFactory(_configurationProvider), Substitute.For <IEvictionManager>(), new NodeStatsProvider(_configurationProvider)), _nodeFactory, nodeTable, new DiscoveryStorage(_configurationProvider, _nodeFactory, _logger, new PerfService(_logger)));
            _discoveryManager.MessageSender = Substitute.For <IMessageSender>();

            _peerManager = new PeerManager(_localPeer, _discoveryManager, _logger, _configurationProvider, _synchronizationManager, new NodeStatsProvider(_configurationProvider), new PeerStorage(_configurationProvider, _nodeFactory, _logger, new PerfService(_logger)), new PerfService(_logger));
        }
コード例 #16
0
        public async Task Initialize()
        {
            _logManager            = new OneLoggerLogManager(new SimpleConsoleLogger());
            _configurationProvider = new JsonConfigProvider();
            ((NetworkConfig)_configurationProvider.GetConfig <INetworkConfig>()).DbBasePath = Path.Combine(Path.GetTempPath(), "PeerManagerTests");
            if (!Directory.Exists(_configurationProvider.GetConfig <INetworkConfig>().DbBasePath))
            {
                Directory.CreateDirectory(_configurationProvider.GetConfig <INetworkConfig>().DbBasePath);
            }

            var serializationService = Build.A.SerializationService().WithEncryptionHandshake().WithP2P().WithEth().TestObject;

            var   syncManager  = Substitute.For <ISynchronizationManager>();
            Block genesisBlock = Build.A.Block.Genesis.TestObject;

            syncManager.Head.Returns(genesisBlock.Header);
            syncManager.Genesis.Returns(genesisBlock.Header);

            _nodeFactory = new NodeFactory();
            _localPeer   = new TestRlpxPeer();
            var keyProvider = new PrivateKeyProvider(new CryptoRandom());
            var key         = keyProvider.PrivateKey.PublicKey;

            _synchronizationManager = Substitute.For <ISynchronizationManager>();

            var nodeTable = new NodeTable(_nodeFactory, Substitute.For <IKeyStore>(), new NodeDistanceCalculator(_configurationProvider), _configurationProvider, _logManager);

            nodeTable.Initialize(new NodeId(key));

            INetworkConfig networkConfig = _configurationProvider.GetConfig <INetworkConfig>();
            IStatsConfig   statsConfig   = _configurationProvider.GetConfig <IStatsConfig>();

            _discoveryManager = new DiscoveryManager(new NodeLifecycleManagerFactory(_nodeFactory, nodeTable, new DiscoveryMessageFactory(_configurationProvider), Substitute.For <IEvictionManager>(), new NodeStatsProvider(_configurationProvider.GetConfig <IStatsConfig>(), _nodeFactory, _logManager), _configurationProvider, _logManager), _nodeFactory, nodeTable, new NetworkStorage("test", networkConfig, _logManager, new PerfService(_logManager)), _configurationProvider, _logManager);
            _discoveryManager.MessageSender = Substitute.For <IMessageSender>();

            var networkStorage = new NetworkStorage("test", networkConfig, _logManager, new PerfService(_logManager));

            _peerManager = new PeerManager(_localPeer, _discoveryManager, _synchronizationManager, new NodeStatsProvider(statsConfig, _nodeFactory, _logManager), networkStorage, _nodeFactory, _configurationProvider, new PerfService(_logManager), _logManager);
            _peerManager.Init(true);
        }
コード例 #17
0
        public void Setup()
        {
            NetworkConfig networkConfig = new NetworkConfig();

            networkConfig.ExternalIp = IPAddress.Broadcast.ToString();

            _masterNode = new Node(TestItem.PublicKeyA, IPAddress.Broadcast.ToString(), 30000, false);
            DiscoveryConfig config = new DiscoveryConfig()
            {
                DiscoveryNewCycleWaitTime = 1
            };
            NodeDistanceCalculator distanceCalculator = new NodeDistanceCalculator(config);

            _nodeTable = new NodeTable(
                distanceCalculator,
                config,
                networkConfig,
                LimboLogs.Instance);
            DiscoveryMessageFactory     messageFactory   = new DiscoveryMessageFactory(Timestamper.Default);
            EvictionManager             evictionManager  = new EvictionManager(_nodeTable, LimboLogs.Instance);
            ITimerFactory               timerFactory     = Substitute.For <ITimerFactory>();
            NodeStatsManager            nodeStatsManager = new NodeStatsManager(timerFactory, LimboLogs.Instance);
            NodeLifecycleManagerFactory managerFactory   =
                new NodeLifecycleManagerFactory(
                    _nodeTable,
                    messageFactory,
                    evictionManager,
                    nodeStatsManager,
                    config,
                    LimboLogs.Instance);
            DiscoveryManager manager = new DiscoveryManager(
                managerFactory,
                _nodeTable,
                new NetworkStorage(new MemDb(), LimboLogs.Instance),
                config,
                LimboLogs.Instance,
                new IPResolver(networkConfig, LimboLogs.Instance));

            _nodesLocator = new NodesLocator(_nodeTable, manager, config, LimboLogs.Instance);
        }
コード例 #18
0
 public override void Execute()
 {
     stopwatch.Restart();
     while (stopwatch.Elapsed.TotalMilliseconds < timeAvaliable && !stopped)
     {
         winA(timeAvaliable);
         if (suspendList.Count == 0 || stopwatch.Elapsed.TotalMilliseconds >= timeAvaliable)
         {
             if (suspendList.Count == 0)
             {
                 isOptimalFound = true;
             }
             stopwatch.Stop();
             return;
         }
         closedList.AddValues(openList);
         openList.Clear();
         openList    = suspendList;
         suspendList = new NodeTable <ANode>(comparer);
         winSize    += 1;
     }
     stopwatch.Stop();
 }
コード例 #19
0
        private Task InitDiscovery(InitParams initParams)
        {
            _logger.Info("Initializing Discovery");

            if (initParams.DiscoveryPort.HasValue)
            {
                _configProvider.GetConfig <NetworkConfig>().MasterPort = initParams.DiscoveryPort.Value;
            }

            var privateKeyProvider      = new PrivateKeyProvider(_privateKey);
            var discoveryMessageFactory = new DiscoveryMessageFactory(_configProvider);
            var nodeIdResolver          = new NodeIdResolver(_signer);

            var msgSerializersProvider = new DiscoveryMsgSerializersProvider(_messageSerializationService, _signer, privateKeyProvider, discoveryMessageFactory, nodeIdResolver, _nodeFactory);

            msgSerializersProvider.RegisterDiscoverySerializers();

            var nodeDistanceCalculator = new NodeDistanceCalculator(_configProvider);
            var nodeTable = new NodeTable(_nodeFactory, _keyStore, nodeDistanceCalculator, _configProvider, _logManager);

            var evictionManager      = new EvictionManager(nodeTable, _logManager);
            var nodeLifeCycleFactory = new NodeLifecycleManagerFactory(_nodeFactory, nodeTable, discoveryMessageFactory, evictionManager, _nodeStatsProvider, _configProvider, _logManager);

            var discoveryStorage = new DiscoveryStorage(_configProvider, _nodeFactory, _logManager, _perfService);

            _discoveryManager = new DiscoveryManager(nodeLifeCycleFactory, _nodeFactory, nodeTable, discoveryStorage, _configProvider, _logManager);

            var nodesLocator = new NodesLocator(nodeTable, _discoveryManager, _configProvider, _logManager);

            _discoveryApp = new DiscoveryApp(nodesLocator, _discoveryManager, _nodeFactory, nodeTable, _messageSerializationService, _cryptoRandom, discoveryStorage, _configProvider, _logManager);
            _discoveryApp.Start(_privateKey.PublicKey);

            _logger.Info("Discovery initialization completed");

            return(Task.CompletedTask);
        }
コード例 #20
0
 public void A_node_table()
 {
     NodeTable = new NodeTable <T>();
 }
コード例 #21
0
ファイル: SparseGraph.cs プロジェクト: end1220/xlab
 public SparseGraph()
 {
     nodeTable     = new NodeTable();
     edgeListTable = new EdgeListTable();
     nodeIdCounter = 0;
 }
コード例 #22
0
        private void InitDiscovery()
        {
            if (!_initConfig.DiscoveryEnabled)
            {
                _discoveryApp = new NullDiscoveryApp();
                return;
            }

            INetworkConfig networkConfig = _configProvider.GetConfig <INetworkConfig>();

            networkConfig.MasterPort = _initConfig.DiscoveryPort;

            var privateKeyProvider      = new SameKeyGenerator(_nodeKey);
            var discoveryMessageFactory = new DiscoveryMessageFactory(networkConfig, _timestamp);
            var nodeIdResolver          = new NodeIdResolver(_ecdsa);

            IDiscoveryMsgSerializersProvider msgSerializersProvider = new DiscoveryMsgSerializersProvider(
                _messageSerializationService,
                _ecdsa,
                privateKeyProvider,
                discoveryMessageFactory,
                nodeIdResolver);

            msgSerializersProvider.RegisterDiscoverySerializers();

            var nodeDistanceCalculator = new NodeDistanceCalculator(networkConfig);

            var nodeTable = new NodeTable(
                _keyStore,
                nodeDistanceCalculator,
                networkConfig,
                _logManager);

            var evictionManager = new EvictionManager(
                nodeTable,
                _logManager);

            var nodeLifeCycleFactory = new NodeLifecycleManagerFactory(
                nodeTable,
                discoveryMessageFactory,
                evictionManager,
                _nodeStatsManager,
                networkConfig,
                _logManager);

            var discoveryStorage = new NetworkStorage(
                DiscoveryNodesDbPath,
                networkConfig,
                _logManager,
                _perfService);

            var discoveryManager = new DiscoveryManager(
                nodeLifeCycleFactory,
                nodeTable,
                discoveryStorage,
                networkConfig,
                _logManager);

            var nodesLocator = new NodesLocator(
                nodeTable,
                discoveryManager,
                _configProvider,
                _logManager);

            _discoveryApp = new DiscoveryApp(
                nodesLocator,
                discoveryManager,
                nodeTable,
                _messageSerializationService,
                _cryptoRandom,
                discoveryStorage,
                networkConfig,
                _logManager, _perfService);

            _discoveryApp.Initialize(_nodeKey.PublicKey);
        }
コード例 #23
0
        public static List <Item> ImportFromFile(string filePath, EditorCamera camera, out bool errorFlag, out string errorMsg, EditorItemSelection selectionManager, OnScreenDisplay osd, bool multiple = false)
        {
            List <Item> createdItems = new List <Item>();

            if (!File.Exists(filePath))
            {
                errorFlag = true;
                errorMsg  = "File does not exist!";
                return(null);
            }

            DirectoryInfo filePathInfo = new DirectoryInfo(filePath);

            bool    importError    = false;
            string  importErrorMsg = "";
            Vector3 pos            = camera.Position + (-20 * camera.Look);

            switch (filePathInfo.Extension)
            {
            case ".sa1mdl":
                ModelFile  mf   = new ModelFile(filePath);
                NJS_OBJECT objm = mf.Model;
                osd.ClearMessageList();
                osd.AddMessage("Importing models, please wait...", 3000);
                osd.ClearMessageList();
                createdItems.AddRange(ImportFromHierarchy(objm, selectionManager, osd, multiple));
                osd.AddMessage("Stage import complete!", 100);
                break;

            case ".obj":
            case ".objf":
                LevelItem item = new LevelItem(filePath, new Vertex(pos.X, pos.Y, pos.Z), new Rotation(), levelItems.Count, selectionManager)
                {
                    Visible = true
                };

                createdItems.Add(item);
                break;

            case ".txt":
                NodeTable.ImportFromFile(filePath, out importError, out importErrorMsg, selectionManager);
                break;

            case ".dae":
            case ".fbx":
                Assimp.AssimpContext context = new Assimp.AssimpContext();
                Assimp.Configs.FBXPreservePivotsConfig conf = new Assimp.Configs.FBXPreservePivotsConfig(false);
                context.SetConfig(conf);
                Assimp.Scene scene = context.ImportFile(filePath, Assimp.PostProcessSteps.Triangulate);
                for (int i = 0; i < scene.RootNode.ChildCount; i++)
                {
                    osd.ClearMessageList();
                    osd.AddMessage("Importing model " + i.ToString() + " of " + scene.RootNode.ChildCount.ToString() + "...", 3000);
                    Assimp.Node        child  = scene.RootNode.Children[i];
                    List <Assimp.Mesh> meshes = new List <Assimp.Mesh>();
                    foreach (int j in child.MeshIndices)
                    {
                        meshes.Add(scene.Meshes[j]);
                    }
                    bool isVisible = true;
                    for (int j = 0; j < child.MeshCount; j++)
                    {
                        if (scene.Materials[meshes[j].MaterialIndex].Name.Contains("Collision"))
                        {
                            isVisible = false;
                            break;
                        }
                    }
                    ModelFormat mfmt = ModelFormat.Basic;
                    if (isVisible)
                    {
                        switch (geo.Format)
                        {
                        case LandTableFormat.SA2:
                            mfmt = ModelFormat.Chunk;
                            break;

                        case LandTableFormat.SA2B:
                            mfmt = ModelFormat.GC;
                            break;
                        }
                    }
                    NJS_OBJECT obj = AssimpStuff.AssimpImport(scene, child, mfmt, TextureBitmaps[leveltexs].Select(a => a.Name).ToArray(), !multiple);
                    {
                        //sa2 collision patch
                        if (obj.Attach.GetType() == typeof(BasicAttach))
                        {
                            BasicAttach ba = obj.Attach as BasicAttach;
                            foreach (NJS_MATERIAL mats in ba.Material)
                            {
                                mats.DoubleSided = true;
                            }
                        }
                        //cant check for transparent texture so i gotta force alpha for now, temporary
                        else if (obj.Attach.GetType() == typeof(ChunkAttach))
                        {
                            ChunkAttach ca = obj.Attach as ChunkAttach;
                            foreach (PolyChunk polys in ca.Poly)
                            {
                                if (polys.GetType() == typeof(PolyChunkMaterial))
                                {
                                    PolyChunkMaterial mat = polys as PolyChunkMaterial;
                                    mat.SourceAlpha      = AlphaInstruction.SourceAlpha;
                                    mat.DestinationAlpha = AlphaInstruction.InverseSourceAlpha;
                                }
                                else if (polys.GetType() == typeof(PolyChunkStrip))
                                {
                                    PolyChunkStrip str = polys as PolyChunkStrip;
                                    //str.UseAlpha = true;
                                }
                            }
                        }
                    }
                    obj.Attach.ProcessVertexData();
                    LevelItem newLevelItem = new LevelItem(obj.Attach, new Vertex(obj.Position.X + pos.X, obj.Position.Y + pos.Y, obj.Position.Z + pos.Z), obj.Rotation, levelItems.Count, selectionManager)
                    {
                        Visible = isVisible
                    };
                    createdItems.Add(newLevelItem);
                }
                osd.ClearMessageList();
                osd.AddMessage("Stage import complete!", 100);
                break;

            default:
                errorFlag = true;
                errorMsg  = "Invalid file format!";
                return(null);
            }

            StateChanged();

            errorFlag = importError;
            errorMsg  = importErrorMsg;

            return(createdItems);
        }
コード例 #24
0
        /// <summary>
        /// Imports the nodes from a dictionary of NodeState objects.
        /// </summary>
        internal void ImportNodes(ISystemContext context, IEnumerable<NodeState> predefinedNodes, bool isInternal)
        {
            NodeTable nodesToExport = new NodeTable(Server.NamespaceUris, Server.ServerUris, Server.TypeTree);

            foreach (NodeState node in predefinedNodes)
            {
                node.Export(context, nodesToExport);
            }

            lock (Server.CoreNodeManager.DataLock)
            {
                foreach (ILocalNode nodeToExport in nodesToExport)
                {
                    Server.CoreNodeManager.AttachNode(nodeToExport, isInternal);
                }
            }
        }
コード例 #25
0
        private void InitDiscovery()
        {
            if (_ctx.NodeStatsManager == null)
            {
                throw new StepDependencyException(nameof(_ctx.NodeStatsManager));
            }
            if (_ctx.Timestamper == null)
            {
                throw new StepDependencyException(nameof(_ctx.Timestamper));
            }
            if (_ctx.NodeKey == null)
            {
                throw new StepDependencyException(nameof(_ctx.NodeKey));
            }
            if (_ctx.CryptoRandom == null)
            {
                throw new StepDependencyException(nameof(_ctx.CryptoRandom));
            }

            if (!_ctx.Config <IInitConfig>().DiscoveryEnabled)
            {
                _ctx.DiscoveryApp = new NullDiscoveryApp();
                return;
            }

            IDiscoveryConfig discoveryConfig = _ctx.Config <IDiscoveryConfig>();

            SameKeyGenerator        privateKeyProvider      = new SameKeyGenerator(_ctx.NodeKey.Unprotect());
            DiscoveryMessageFactory discoveryMessageFactory = new DiscoveryMessageFactory(_ctx.Timestamper);
            NodeIdResolver          nodeIdResolver          = new NodeIdResolver(_ctx.EthereumEcdsa);
            IPResolver ipResolver = new IPResolver(_networkConfig, _ctx.LogManager);

            IDiscoveryMsgSerializersProvider msgSerializersProvider = new DiscoveryMsgSerializersProvider(
                _ctx._messageSerializationService,
                _ctx.EthereumEcdsa,
                privateKeyProvider,
                discoveryMessageFactory,
                nodeIdResolver);

            msgSerializersProvider.RegisterDiscoverySerializers();

            NodeDistanceCalculator nodeDistanceCalculator = new NodeDistanceCalculator(discoveryConfig);

            NodeTable       nodeTable       = new NodeTable(nodeDistanceCalculator, discoveryConfig, _networkConfig, _ctx.LogManager);
            EvictionManager evictionManager = new EvictionManager(nodeTable, _ctx.LogManager);

            NodeLifecycleManagerFactory nodeLifeCycleFactory = new NodeLifecycleManagerFactory(
                nodeTable,
                discoveryMessageFactory,
                evictionManager,
                _ctx.NodeStatsManager,
                discoveryConfig,
                _ctx.LogManager);

            SimpleFilePublicKeyDb discoveryDb      = new SimpleFilePublicKeyDb("DiscoveryDB", DiscoveryNodesDbPath.GetApplicationResourcePath(_ctx.Config <IInitConfig>().BaseDbPath), _ctx.LogManager);
            NetworkStorage        discoveryStorage = new NetworkStorage(
                discoveryDb,
                _ctx.LogManager);

            DiscoveryManager discoveryManager = new DiscoveryManager(
                nodeLifeCycleFactory,
                nodeTable,
                discoveryStorage,
                discoveryConfig,
                _ctx.LogManager,
                ipResolver
                );

            NodesLocator nodesLocator = new NodesLocator(
                nodeTable,
                discoveryManager,
                discoveryConfig,
                _ctx.LogManager);

            _ctx.DiscoveryApp = new DiscoveryApp(
                nodesLocator,
                discoveryManager,
                nodeTable,
                _ctx._messageSerializationService,
                _ctx.CryptoRandom,
                discoveryStorage,
                _networkConfig,
                discoveryConfig,
                _ctx.Timestamper,
                _ctx.LogManager);

            _ctx.DiscoveryApp.Initialize(_ctx.NodeKey.PublicKey);
        }
コード例 #26
0
ファイル: EthereumRunner.cs プロジェクト: vicnaum/nethermind
        private void InitDiscovery()
        {
            if (!_initConfig.DiscoveryEnabled)
            {
                _discoveryApp = new NullDiscoveryApp();
                return;
            }

            IDiscoveryConfig discoveryConfig = _configProvider.GetConfig <IDiscoveryConfig>();

            var privateKeyProvider      = new SameKeyGenerator(_nodeKey);
            var discoveryMessageFactory = new DiscoveryMessageFactory(_timestamper);
            var nodeIdResolver          = new NodeIdResolver(_ethereumEcdsa);

            IDiscoveryMsgSerializersProvider msgSerializersProvider = new DiscoveryMsgSerializersProvider(
                _messageSerializationService,
                _ethereumEcdsa,
                privateKeyProvider,
                discoveryMessageFactory,
                nodeIdResolver);

            msgSerializersProvider.RegisterDiscoverySerializers();

            var nodeDistanceCalculator = new NodeDistanceCalculator(discoveryConfig);

            var nodeTable       = new NodeTable(nodeDistanceCalculator, discoveryConfig, _networkConfig, _logManager);
            var evictionManager = new EvictionManager(nodeTable, _logManager);

            var nodeLifeCycleFactory = new NodeLifecycleManagerFactory(
                nodeTable,
                discoveryMessageFactory,
                evictionManager,
                _nodeStatsManager,
                discoveryConfig,
                _logManager);

            var discoveryDb      = new SimpleFilePublicKeyDb("DiscoveryDB", Path.Combine(_initConfig.BaseDbPath, DiscoveryNodesDbPath), _logManager);
            var discoveryStorage = new NetworkStorage(
                discoveryDb,
                _logManager);

            var discoveryManager = new DiscoveryManager(
                nodeLifeCycleFactory,
                nodeTable,
                discoveryStorage,
                discoveryConfig,
                _logManager);

            var nodesLocator = new NodesLocator(
                nodeTable,
                discoveryManager,
                discoveryConfig,
                _logManager);

            _discoveryApp = new DiscoveryApp(
                nodesLocator,
                discoveryManager,
                nodeTable,
                _messageSerializationService,
                _cryptoRandom,
                discoveryStorage,
                _networkConfig,
                discoveryConfig,
                _timestamper,
                _logManager, _perfService);

            _discoveryApp.Initialize(_nodeKey.PublicKey);
        }
コード例 #27
0
        private void InitDiscovery()
        {
            _configProvider.GetConfig <INetworkConfig>().MasterPort = _initConfig.DiscoveryPort;

            var privateKeyProvider      = new PrivateKeyProvider(_privateKey);
            var discoveryMessageFactory = new DiscoveryMessageFactory(_configProvider);
            var nodeIdResolver          = new NodeIdResolver(_signer);

            IDiscoveryMsgSerializersProvider msgSerializersProvider = new DiscoveryMsgSerializersProvider(
                _messageSerializationService,
                _signer,
                privateKeyProvider,
                discoveryMessageFactory,
                nodeIdResolver,
                _nodeFactory);

            msgSerializersProvider.RegisterDiscoverySerializers();

            var nodeDistanceCalculator = new NodeDistanceCalculator(_configProvider);

            var nodeTable = new NodeTable(
                _nodeFactory,
                _keyStore,
                nodeDistanceCalculator,
                _configProvider,
                _logManager);

            var evictionManager = new EvictionManager(
                nodeTable,
                _logManager);

            var nodeLifeCycleFactory = new NodeLifecycleManagerFactory(
                _nodeFactory,
                nodeTable,
                discoveryMessageFactory,
                evictionManager,
                _nodeStatsProvider,
                _configProvider,
                _logManager);

            var discoveryStorage = new NetworkStorage(
                DiscoveryNodesDbPath,
                _configProvider.GetConfig <INetworkConfig>(),
                _logManager,
                _perfService);

            _discoveryManager = new DiscoveryManager(
                nodeLifeCycleFactory,
                _nodeFactory,
                nodeTable,
                discoveryStorage,
                _configProvider,
                _logManager);

            var nodesLocator = new NodesLocator(
                nodeTable,
                _discoveryManager,
                _configProvider,
                _logManager);

            _discoveryApp = new DiscoveryApp(
                nodesLocator,
                _discoveryManager,
                _nodeFactory,
                nodeTable,
                _messageSerializationService,
                _cryptoRandom,
                discoveryStorage,
                _configProvider,
                _logManager, _perfService);

            _discoveryApp.Initialize(_privateKey.PublicKey);
        }