public T GetProperty <T>(string pPropName) { T ret = default(T); lock (Properties) { if (Properties.TryGetValue(pPropName, out PropertyDefnBase pbase)) { if (pbase.type == typeof(T)) { PropertyDefn <T> defn = pbase as PropertyDefn <T>; if (defn != null && defn.getter != null) { ret = defn.getter(); } } else { // The caller is asking for a different type than the native type. // Get the value and try to do a conversion to the requested type. // Probably wants to do a ToString(). try { ret = ParamBlock.ConvertTo <T>(pbase.val); } catch (Exception e) { BasilXContext.Instance.log.ErrorFormat("{0} GetProperty: exception fetching value for {1}: {2}", _logHeader, pPropName, e); ret = default(T); } } } } return(ret); }
// Set a parameter value public bool SetParameterValue(string pName, string pVal) { var ret = false; foreach (FieldInfo fi in this.GetType().GetFields()) { foreach (Attribute attr in Attribute.GetCustomAttributes(fi)) { ConfigParam cp = attr as ConfigParam; if (cp != null) { if (cp.name == pName) { fi.SetValue(this, ParamBlock.ConvertToObj(cp.valueType, pVal)); ret = true; break; } } } if (ret) { break; } } return(ret); }
public void Start(string[] args) { // A single parameter of '--help' outputs the invocation parameters if (args.Length > 0 && args[0] == "--help") { System.Console.Write(Invocation()); return; } // 'Params' initializes to default values. // Override default values with command line parameters. try { // Note that trailing parameters will be put into "Extras" parameter BasilTest.parms.MergeCommandLine(args, null, "Extras"); } catch (Exception e) { BasilTest.log.ErrorFormat("ERROR: bad parameters: " + e.Message); BasilTest.log.ErrorFormat(Invocation()); return; } if (BasilTest.parms.P <bool>("Verbose")) { BasilTest.log.SetVerbose(BasilTest.parms.P <bool>("Verbose")); } if (!BasilTest.parms.P <bool>("Quiet")) { System.Console.WriteLine("BasilTest v" + BasilTest.version + " built " + BasilTest.buildDate + " commit " + BasilTest.gitCommit ); } InitializeHostnameForExternalAccess(); // Create the parameter block for this type of layer ParamBlock ccParams = new ParamBlock(new Dictionary <string, object>() { { "ConnectionURL", BasilTest.parms.P <string>("ConnectionURL") }, { "IsSecure", BasilTest.parms.P <bool>("IsSecure").ToString() }, { "SecureConnectionURL", BasilTest.parms.P <string>("SecureConnectionURL") }, { "Certificate", BasilTest.parms.P <string>("Certificate") }, { "DisableNaglesAlgorithm", BasilTest.parms.P <bool>("DisableNablesAlgorithm").ToString() }, { "ExternalAccessHostname", HostnameForExternalAccess } }); var canceller = new CancellationTokenSource(); var TesterSpaceServer = new SpaceServerListener(ccParams, canceller, BasilTest.log, (pCanceller, pConnection, pParams) => { return(new SpaceServerTester(pCanceller, pConnection)); } ); while (!canceller.IsCancellationRequested) { Thread.Sleep(100); } }
// 停封/解封玩家账号 public OpRes blockPlayerAcc(string acc, bool block, GMUser user) { ParamBlock param = new ParamBlock(); param.m_param = acc; param.m_isBlock = block; OpRes res = user.doDyop(param, DyOpType.opTypeBlockAcc); return(res); }
protected void onUnBlockAcc(object sender, EventArgs e) { GMUser user = (GMUser)Session["user"]; ParamBlock param = new ParamBlock(); param.m_param = m_acc.Text; param.m_isBlock = false; OpRes res = user.doDyop(param, DyOpType.opTypeBlockAcc); m_res.InnerHtml = OpResMgr.getInstance().getResultString(res); }
protected void onBlockAccount(object sender, EventArgs e) { ParamBlock p = new ParamBlock(); p.m_isBlock = true; p.m_param = m_acc.Text; GMUser user = (GMUser)Session["user"]; DyOpMgr mgr = user.getSys <DyOpMgr>(SysType.sysTypeDyOp); OpRes res = mgr.doDyop(p, DyOpType.opTypeBlockAcc, user); m_res.InnerHtml = OpResMgr.getInstance().getResultString(res); genTable(m_result, user, mgr); }
protected void onUnBlockAccount(object sender, EventArgs e) { GMUser user = (GMUser)Session["user"]; ParamBlock p = new ParamBlock(); p.m_isBlock = false; p.m_param = m_accList; DyOpMgr mgr = user.getSys <DyOpMgr>(SysType.sysTypeDyOp); if (p.m_param != string.Empty) { OpRes res = mgr.doDyop(p, DyOpType.opTypeBlockAcc, user); m_res.InnerHtml = OpResMgr.getInstance().getResultString(res); } genTable(m_result, user, mgr); }
// Store the value for the parameter. // If we accept the value as a good value for the parameter, return 1 else 0. // A 'good value' is one that does not start with '-' or is not after a boolean parameter. // Return the number of parameters to advance the parameter line. That means, return // a zero of we didn't used the next parameter and a 1 if the next parameter // was used as a value so don't consider it the next parameter. private int AddCommandLineParameter(string pParm, string val) { // System.Console.WriteLine(String.Format("AddCommandLineParameter: parm={0}, val={1}", pParm, val)); int ret = 1; // start off assuming the next token is the value we're setting string parm = pParm.ToLower(); // Strip leading hyphens while (parm[0] == '-') { parm = parm.Substring(1); } // If the boolean parameter starts with "no", turn it off rather than on. string positiveAssertion = "true"; if (parm.Length > 2 && parm[0] == 'n' && parm[1] == 'o') { string maybeParm = parm.Substring(2); if (TryGetParameterInfo(parm, out ConfigParam bcp, out FieldInfo bfi)) { if (bcp.valueType == typeof(Boolean)) { // The parameter without the 'no' exists and is a boolean positiveAssertion = "false"; parm = maybeParm; } } } // If the next token starts with a parameter mark, it's not really a value if (val == null) { ret = 0; // the next token is not used here to set the value } else { if (val[0] == '-') { val = null; // don't use the next token as a value ret = 0; // the next token is not used here to set the value } } if (TryGetParameterInfo(parm, out ConfigParam cp, out FieldInfo fi)) { // If the parameter is a boolean type and the next value is not a parameter, // don't try to take up the next value. // This handles boolean flags. // If there is a value next (val != null) and that value is not the // values 'true' or 'false' or 't' or 'f', then ignore the next value // as not belonging to this flag. THis allows (and the logic above) // allows: // "--flag --otherFlag ...", // "--flag something ...", // "--flag true --otherFlag ...", // "--noflag --otherflag ...", // etc if (cp.valueType == typeof(Boolean)) { if (val != null) { string valL = val.ToLower(); if (valL != "true" && valL != "t" && valL != "false" && valL != "f") { // The value is not associated with this boolean so ignore it val = null; // don't use the val token ret = 0; // the next token is not used here to set the value } } if (val == null) { // If the value is assumed, use the value based on the optional 'no' val = positiveAssertion; } } // Set the named parameter to the passed value fi.SetValue(this, ParamBlock.ConvertToObj(cp.valueType, val)); }
/// <summary> /// Check to see if this action can happen now or has to be queued for later. /// </summary> /// <param name="rcontext"></param> /// <param name="cac"></param> /// <param name="p1"></param> /// <param name="p2"></param> /// <param name="p3"></param> /// <param name="p4"></param> /// <returns>true if the action was queued, false if the action should be done</returns> private bool QueueTilOnline(OMV.Simulator sim, CommActionCode cac, Object p1, Object p2, Object p3, Object p4) { bool ret = false; lock (m_waitTilOnline) { RegionContextBase rcontext = FindRegion(sim); if (rcontext != null && rcontext.State.isOnline) { // not queuing until later ret = false; } else { ParamBlock pb = new ParamBlock(sim, cac, p1, p2, p3, p4); m_waitTilOnline.Add(pb); // return that we queued the action ret = true; } } return ret; }
// If run from the command line, create instance and call 'Start' with args. // If run programmatically, create instance and call 'Start' with parameters. public async Task Start(CancellationToken cancelToken, string[] args) { var parms = new ConvoarParams(); var logger = new BLoggerNLog(parms.LogFilename, parms.LogToConsole, parms.LogToFiles); // var logger = new LoggerLog4Net(), // var logger = new LoggerConsole(), Globals = new GlobalContext() { log = logger, stats = new ConvoarStats(), parms = parms, }; // A single parameter of '--help' outputs the invocation parameters if (args.Length > 0 && args[0] == "--help") { System.Console.Write(Invocation()); return; } // 'ConvoarParams' initializes to default values. // Over ride default values with command line parameters. try { // Note that trailing parameters will be put into "InputOAR" parameter Globals.parms.MergeCommandLine(args, null, "InputOAR"); } catch (Exception e) { Globals.log.Error("ERROR: bad parameters: " + e.Message); Globals.log.Error(Invocation()); return; } if (Globals.parms.Verbose) { Globals.log.SetLogLevel(LogLevels.Debug); } if (!Globals.parms.Quiet) { System.Console.WriteLine("Convoar " + Globals.versionLong); System.Console.WriteLine(" using Herbal3d.CommonEntities " + org.herbal3d.cs.CommonEntities.VersionInfo.longVersion); System.Console.WriteLine(" using Herbal3d.CommonEntitiesConv " + org.herbal3d.cs.CommonEntitiesConv.VersionInfo.longVersion); System.Console.WriteLine(" using Herbal3d.CommonUtil " + org.herbal3d.cs.CommonUtil.VersionInfo.longVersion); } // Validate parameters if (String.IsNullOrEmpty(Globals.parms.InputOAR)) { Globals.log.Error("An input OAR file must be specified"); Globals.log.Error(Invocation()); return; } if (String.IsNullOrEmpty(Globals.parms.OutputDir)) { _outputDir = "./out"; Globals.log.Debug("Output directory defaulting to {0}", _outputDir); } // Base asset storage system -- 'MemAssetService' is in-memory storage using (MemAssetService memAssetService = new MemAssetService()) { // 'assetManager' is the asset cache and fetching code -- where all the mesh, // material, and instance information is stored for later processing. using (AssetManager assetManager = new AssetManager(memAssetService, Globals.log, Globals.parms.OutputDir)) { try { BScene bScene = await LoadOAR(memAssetService, assetManager); Globals.contextName = bScene.name; Globals.log.Debug("{0} Scene created. name={1}, instances={2}", _logHeader, bScene.name, bScene.instances.Count); Globals.log.Debug("{0} num assetFetcher.images={1}", _logHeader, assetManager.Assets.Images.Count); Globals.log.Debug("{0} num assetFetcher.materials={1}", _logHeader, assetManager.Assets.Materials.Count); Globals.log.Debug("{0} num assetFetcher.meshes={1}", _logHeader, assetManager.Assets.Meshes.Count); Globals.log.Debug("{0} num assetFetcher.renderables={1}", _logHeader, assetManager.Assets.Renderables.Count); if (ConvOAR.Globals.parms.TerrainOnly) { ConvOAR.Globals.log.Debug("{0} Clearing out scene so there's only terrain (TerrainOnly)", _logHeader); bScene.instances.Clear(); bScene.instances.Add(bScene.terrainInstance); } /* * // Perform any optimizations on the scene and its instances * if (Globals.parms.P<bool>("DoMeshSimplification")) { * // TODO: * } * if (Globals.parms.P<bool>("DoSceneOptimizations")) { * using (BSceneManipulation optimizer = new BSceneManipulation()) { * bScene = optimizer.OptimizeScene(bScene); * Globals.log.DebugFormat("{0} merged BScene. numInstances={1}", _logHeader, bScene.instances.Count); * } * } */ if (Globals.parms.MergeSharedMaterialMeshes) { // using (BSceneManipulation optimizer = new BSceneManipulation(Globals.log, Globals.parms)) { var manipParams = new ParamBlock(new Dictionary <string, object> { { "SeparateInstancedMeshes", false }, { "MergeSharedMaterialMeshes", false }, { "MeshShareThreshold", 5 } }); using (BSceneManipulation optimizer = new BSceneManipulation(Globals.log, manipParams)) { bScene = optimizer.RebuildSceneBasedOnSharedMeshes(bScene); Globals.log.Debug("{0} merged meshes in scene. numInstances={1}", _logHeader, bScene.instances.Count); } } // Output the transformed scene as Gltf version 2 GltfB gltf = new GltfB(bScene.name, Globals.log, new gltfParamsB() { inputOAR = Globals.parms.InputOAR, uriBase = Globals.parms.URIBase, verticesMaxForBuffer = Globals.parms.VerticesMaxForBuffer, gltfCopyright = Globals.parms.GltfCopyright, addUniqueCodes = Globals.parms.AddUniqueCodes, doubleSided = Globals.parms.DoubleSided, textureMaxSize = Globals.parms.TextureMaxSize, logBuilding = Globals.parms.LogBuilding, logGltfBuilding = Globals.parms.LogGltfBuilding, versionLong = Globals.versionLong }); try { gltf.LoadScene(bScene); Globals.log.Debug("{0} num Gltf.nodes={1}", _logHeader, gltf.nodes.Count); Globals.log.Debug("{0} num Gltf.meshes={1}", _logHeader, gltf.meshes.Count); Globals.log.Debug("{0} num Gltf.materials={1}", _logHeader, gltf.materials.Count); Globals.log.Debug("{0} num Gltf.images={1}", _logHeader, gltf.images.Count); Globals.log.Debug("{0} num Gltf.accessor={1}", _logHeader, gltf.accessors.Count); Globals.log.Debug("{0} num Gltf.buffers={1}", _logHeader, gltf.buffers.Count); Globals.log.Debug("{0} num Gltf.bufferViews={1}", _logHeader, gltf.bufferViews.Count); } catch (Exception e) { Globals.log.Error("{0} Exception loading GltfScene: {1}", _logHeader, e); } try { if (gltf.scenes.Count > 0) { string gltfFilename = gltf.GetFilename(gltf.IdentifyingString); using (var outm = new MemoryStream()) { using (var outt = new StreamWriter(outm)) { gltf.ToJSON(outt); } await assetManager.AssetStorage.Store(gltfFilename, outm.ToArray()); } gltf.WriteBinaryFiles(assetManager.AssetStorage); if (Globals.parms.ExportTextures) { gltf.WriteImages(assetManager.AssetStorage); } } else { Globals.log.Error("{0} Not writing out GLTF because no scenes", _logHeader); } } catch (Exception e) { Globals.log.Error("{0} Exception writing GltfScene: {1}", _logHeader, e); } /* * // Output all the instances in the scene as individual GLTF files * if (Globals.parms.P<bool>("ExportIndividualGltf")) { * bScene.instances.ForEach(instance => { * string instanceName = instance.handle.ToString(); * Gltf gltf = new Gltf(instanceName); * gltf.persist.baseDirectory = bScene.name; * // gltf.persist.baseDirectory = PersistRules.JoinFilePieces(bScene.name, instanceName); * GltfScene gltfScene = new GltfScene(gltf, instanceName); * gltf.defaultScene = gltfScene; * * Displayable rootDisp = instance.Representation; * GltfNode rootNode = GltfNode.GltfNodeFactory(gltf, gltfScene, rootDisp, assetFetcher); * rootNode.translation = instance.Position; * rootNode.rotation = instance.Rotation; * * gltf.BuildAccessorsAndBuffers(); * gltf.UpdateGltfv2ReferenceIndexes(); * * // After the building, get rid of the default scene name as we're not outputting a scene * gltf.defaultScene = null; * * PersistRules.ResolveAndCreateDir(gltf.persist.filename); * * using (StreamWriter outt = File.CreateText(gltf.persist.filename)) { * gltf.ToJSON(outt); * } * gltf.WriteBinaryFiles(); * * if (Globals.parms.P<bool>("ExportTextures")) { * gltf.WriteImages(); * } * }); * } */ } catch (Exception e) { Globals.log.Error("{0} Global exception converting scene: {1}", _logHeader, e); // A common error is not having all the DLLs for OpenSimulator. Print out what's missing. if (e is ReflectionTypeLoadException refE) { foreach (var ee in refE.LoaderExceptions) { Globals.log.Error("{0} reference exception: {1}", _logHeader, ee); } } } } } }