protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
GetOption go = new GetOption();
go.AcceptNothing(true);
OptionToggle infoAtStartup = new OptionToggle(Properties.Settings.Default.InfoAtStartup, "Hide", "Show");
go.AddOptionToggle("ShowInfo", ref infoAtStartup);
go.SetCommandPrompt("Start first-person navigation");
GetResult res = go.Get();
while (res == GetResult.Option)
{
res = go.Get();
}
if (res != GetResult.Nothing)
{
return(Result.Cancel);
}
Properties.Settings.Default.InfoAtStartup = infoAtStartup.CurrentValue;
Properties.Settings.Default.Save();
Interceptor.StartWASD(infoAtStartup.CurrentValue);
return(Result.Success);
}
public GetAreaRectangle(double area, bool flip)
{
Area = new OptionDouble(area);
AddOptionDouble("Area", ref Area);
Flip = new OptionToggle(flip, "Right", "Left");
AddOptionToggle("Side", ref Flip);
}
private static void ReadOptions(OptionToggle toggleVerbose,
OptionDouble spotlightFactor, OptionDouble pointlightFactor, OptionDouble sunlightFactor,
OptionDouble arealightFactor, OptionDouble polishFactor)
{
RcCore.It.EngineSettings.Verbose = toggleVerbose.CurrentValue;
RcCore.It.EngineSettings.SpotlightFactor = (float)spotlightFactor.CurrentValue;
RcCore.It.EngineSettings.PointlightFactor = (float)pointlightFactor.CurrentValue;
RcCore.It.EngineSettings.SunlightFactor = (float)sunlightFactor.CurrentValue;
RcCore.It.EngineSettings.ArealightFactor = (float)arealightFactor.CurrentValue;
RcCore.It.EngineSettings.PolishFactor = (float)polishFactor.CurrentValue;
}
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
const ObjectType selFilter = ObjectType.PolysrfFilter | ObjectType.Extrusion;
bool value = false;
double preShrinkValue = ZERO_CM;
OptionToggle shrinkToDimensions = new OptionToggle(value, "Off", "On");
OptionDouble preShrink = new OptionDouble(preShrinkValue, 0.0, 1.0);
ObjRef boxObjRef = null;
GetObject go = new GetObject();
go.SetCommandPrompt("Select the box to net-ify");
go.AddOptionToggle("Constrain", ref shrinkToDimensions);
go.AddOptionDouble("PreShrink", ref preShrink, "Preshrink");
go.GeometryFilter = selFilter;
go.EnableClearObjectsOnEntry(true);
go.EnableUnselectObjectsOnExit(true);
// TODO: clean up this hot mess
for (;;)
{
GetResult getObjResult = go.Get();
if (getObjResult == GetResult.Object)
{
boxObjRef = go.Object(0);
boxObjRef.Object().Select(on: true, syncHighlight: true);
go.EnablePreSelect(false, true);
go.AcceptNothing(true);
continue;
}
else if (getObjResult == GetResult.Cancel)
{
return(Result.Cancel);
}
// Case where user presses enter
else if (getObjResult == GetResult.Nothing)
{
if (boxObjRef != null)
{
preShrinkValue = preShrink.CurrentValue;
if (preShrinkValue != ZERO_CM)
{
boxObjRef = shrinkBoxObj(boxObjRef, preShrinkValue);
}
drawNetFromObjRef(boxObjRef, doc, shrinkToDimensions.CurrentValue);
return(Result.Success);
}
}
}
}
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
var getNumber = new GetInteger();
getNumber.SetLowerLimit(0, false);
getNumber.SetUpperLimit(500, false);
getNumber.SetDefaultInteger(RcCore.It.EngineSettings.ThrottleMs);
getNumber.SetCommandPrompt("Set throttle (in ms)");
var toggleVerbose = new OptionToggle(RcCore.It.EngineSettings.Verbose, "No", "Yes");
var spotlightFactor = new OptionDouble(RcCore.It.EngineSettings.SpotlightFactor, 0.0, 1000000.0);
var pointlightFactor = new OptionDouble(RcCore.It.EngineSettings.PointlightFactor, 0.0, 1000000.0);
var sunlightFactor = new OptionDouble(RcCore.It.EngineSettings.SunlightFactor, 0.0, 1000000.0);
var arealightFactor = new OptionDouble(RcCore.It.EngineSettings.ArealightFactor, 0.0, 1000000.0);
var polishFactor = new OptionDouble(RcCore.It.EngineSettings.PolishFactor, 0.0, 1000000.0);
getNumber.AddOptionToggle("verbose", ref toggleVerbose);
getNumber.AddOptionDouble("spotlight_factor", ref spotlightFactor);
getNumber.AddOptionDouble("pointlight_factor", ref pointlightFactor);
getNumber.AddOptionDouble("sunlight_factor", ref sunlightFactor);
getNumber.AddOptionDouble("arealight_factor", ref arealightFactor);
getNumber.AddOptionDouble("polish_factor", ref polishFactor);
while (true)
{
var getRc = getNumber.Get();
if (getNumber.CommandResult() != Result.Success)
{
return(getNumber.CommandResult());
}
switch (getRc)
{
case GetResult.Nothing:
case GetResult.Number:
RcCore.It.EngineSettings.ThrottleMs = getNumber.Number();
ReadOptions(toggleVerbose, spotlightFactor, pointlightFactor, sunlightFactor, arealightFactor, polishFactor);
break;
case GetResult.Option:
ReadOptions(toggleVerbose, spotlightFactor, pointlightFactor, sunlightFactor, arealightFactor, polishFactor);
continue;
default:
continue;
}
break;
}
return(Result.Success);
}
/// <summary>
/// Initialize the values of the element
/// </summary>
/// <param name="absoluteTolerance">Absolute tolerance of the rhino document</param>
/// <param name="isScripted">Are we running from a non-dynamic environment?</param>
public void Initialize(double absoluteTolerance, bool isScripted)
{
EnableTransparentCommands(true);
_tolerance = new OptionDouble(absoluteTolerance / 10, RhinoMath.ZeroTolerance, double.MaxValue);
_dynamicPreviewToggle = new OptionToggle(!isScripted, "Disabled", "Enabled");
_evenOdd = new OptionToggle(true, "NonZero", "evenOdd");
AddOptionEnum("BooleanType", BooleanType.Difference);
AddOptionEnum("ProjectTo", ProjectToCplane.CPlane);
AddOptionDouble("Tolerance", ref _tolerance, "Tolerance");
AddOptionToggle("DynamicPreview", ref _dynamicPreviewToggle);
AddOptionToggle("FillingRule", ref _evenOdd);
AcceptNothing(true);
}
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
this.widthOpt = new OptionInteger(Properties.Settings.Default.Width);
this.heightOpt = new OptionInteger(Properties.Settings.Default.Height);
this.dpiOpt = new OptionInteger(Properties.Settings.Default.DPI);
this.ratioToggle = new OptionToggle(Properties.Settings.Default.KeepRatio, "Yes", "No");
this.gridAxesToggle = new OptionToggle(Properties.Settings.Default.GridAndAxes, "Hide", "Show");
this.portraitToggle = new OptionToggle(Properties.Settings.Default.Portrait, "Landscape", "Portrait");
GetOption go = new GetOption();
go.AcceptNothing(true);
int selectedResolution = Properties.Settings.Default.Resolution;
this.RestoreOptions(ref go, selectedResolution);
GetResult res = go.Get();
while (res == GetResult.Option)
{
if (go.Option().CurrentListOptionIndex >= 0)
{
selectedResolution = go.Option().CurrentListOptionIndex;
}
this.RestoreOptions(ref go, selectedResolution);
res = go.Get();
}
if (res != GetResult.Nothing)
{
return(Result.Cancel);
}
Properties.Settings.Default.Resolution = selectedResolution;
Properties.Settings.Default.Width = widthOpt.CurrentValue;
Properties.Settings.Default.Height = heightOpt.CurrentValue;
Properties.Settings.Default.KeepRatio = ratioToggle.CurrentValue;
Properties.Settings.Default.GridAndAxes = gridAxesToggle.CurrentValue;
Properties.Settings.Default.Portrait = portraitToggle.CurrentValue;
Properties.Settings.Default.Save();
RhinoHelpers.CustomScreenshot();
return(Result.Success);
}
public static void Main()
{
// SozCore.IngressPoint.AddRequiredTechComponent(typeof(TargetManager));
// .WriteLine("Assume added TargetManager as requried component");
// WeaponAimMod.src.WrappedDataHolder.unitGravity = Physics.gravity;
// WeaponAimMod.src.WrappedDataHolder.gravityMagnitude = Physics.gravity.magnitude;
// WeaponAimMod.src.WrappedDataHolder.unitGravity.Normalize();
HarmonyInstance.Create("flsoz.ttmm.weaponaim.mod").PatchAll(Assembly.GetExecutingAssembly());
// mod Config
Config = new ModConfig();
Config.BindConfig <WeaponAimSettings>(null, "PlayerLead"); // Using BindConfig will set UseRef as true, changing some methods to work with the RefList.
Config.BindConfig <WeaponAimSettings>(null, "EnemyLead"); // If 'Setting2' was loaded from the config.json, it will apply the variable to the field.
Config.BindConfig <WeaponAimSettings>(null, "SmartMissile"); // Using BindConfig will set UseRef as true, changing some methods to work with the RefList.
Config.BindConfig <WeaponAimSettings>(null, "PlayerMissileLead"); // If 'Setting2' was loaded from the config.json, it will apply the variable to the field.
Config.BindConfig <WeaponAimSettings>(null, "EnemyMissileLead"); // If 'Setting2' was loaded from the config.json, it will apply the variable to the field.
Config.BindConfig <WeaponAimSettings>(null, "BallisticMissile"); // If 'Setting2' was loaded from the config.json, it will apply the variable to the field.
// Config.BindConfig<WeaponAimSettings>(null, "AutoSetFuse"); // If 'Setting2' was loaded from the config.json, it will apply the variable to the field.
Config.BindConfig <WeaponAimSettings>(null, "OctantAim"); // If 'Setting2' was loaded from the config.json, it will apply the variable to the field.
// UI
PlayerLead = new OptionToggle("Player leading", ModName, WeaponAimSettings.PlayerLead);
PlayerLead.onValueSaved.AddListener(() => { WeaponAimSettings.PlayerLead = PlayerLead.SavedValue; Config.WriteConfigJsonFile(); });
EnemyLead = new OptionToggle("Enemy leading", ModName, WeaponAimSettings.EnemyLead);
EnemyLead.onValueSaved.AddListener(() => { WeaponAimSettings.EnemyLead = EnemyLead.SavedValue; Config.WriteConfigJsonFile(); });
EnemyMissileLead = new OptionToggle("Enemy-fired missile leading", ModName, WeaponAimSettings.EnemyMissileLead);
EnemyMissileLead.onValueSaved.AddListener(() => { WeaponAimSettings.EnemyMissileLead = EnemyMissileLead.SavedValue; Config.WriteConfigJsonFile(); });
PlayerMissileLead = new OptionToggle("Player-fired missile leading", ModName, WeaponAimSettings.PlayerMissileLead);
PlayerMissileLead.onValueSaved.AddListener(() => { WeaponAimSettings.PlayerMissileLead = PlayerMissileLead.SavedValue; Config.WriteConfigJsonFile(); });
SmartMissile = new OptionToggle("Smart missiles", ModName, WeaponAimSettings.SmartMissile);
SmartMissile.onValueSaved.AddListener(() => { WeaponAimSettings.SmartMissile = SmartMissile.SavedValue; Config.WriteConfigJsonFile(); });
BallisticMissile = new OptionToggle("Ballistic missiles", ModName, WeaponAimSettings.BallisticMissile);
BallisticMissile.onValueSaved.AddListener(() => { WeaponAimSettings.BallisticMissile = BallisticMissile.SavedValue; Config.WriteConfigJsonFile(); });
// AutoSetFuse = new OptionToggle("All weapons timed fuse", ModName, WeaponAimSettings.AutoSetFuse);
// AutoSetFuse.onValueSaved.AddListener(() => { WeaponAimSettings.AutoSetFuse = AutoSetFuse.SavedValue; Config.WriteConfigJsonFile(); });
OctantAim = new OptionToggle("Independent Targeting", ModName, WeaponAimSettings.OctantAim);
OctantAim.onValueSaved.AddListener(() => { WeaponAimSettings.OctantAim = OctantAim.SavedValue; Config.WriteConfigJsonFile(); });
}
/// <summary>
/// Initializes the specified absolute tolerance.
/// </summary>
/// <param name="absoluteTolerance">The absolute tolerance.</param>
/// <param name="isScripted">if set to <c>true</c> [is scripted].</param>
public void Initialize(double absoluteTolerance, bool isScripted)
{
EnableTransparentCommands(true);
_offsetDistance = new OptionDouble(10, absoluteTolerance, double.MaxValue);
_tolerance = new OptionDouble(absoluteTolerance / 10, RhinoMath.ZeroTolerance, double.MaxValue);
_arcTolerance = new OptionDouble(0.25, RhinoMath.ZeroTolerance, double.MaxValue);
_miter = new OptionDouble(1, RhinoMath.ZeroTolerance, double.MaxValue);
_dynamicPreviewToggle = new OptionToggle(!isScripted, "Disabled", "Enabled");
AddOptionDouble("Distance", ref _offsetDistance, "Distance");
AddOptionDouble("Tolerance", ref _tolerance, "Tolerance");
AddOptionEnum("Side", Side.Both);
AddOptionEnum("OpenFillet", Polyline3D.OpenFilletType.Butt);
AddOptionEnum("ClosedFillet", Polyline3D.ClosedFilletType.Square);
AddOptionDouble("Miter", ref _miter, "Miter");
AddOptionDouble("ArcTolerance", ref _arcTolerance, "ArcTolerance");
AddOptionEnum("ProjectTo", ProjectToCplane.CPlane);
AddOptionToggle("DynamicPreview", ref _dynamicPreviewToggle);
AcceptNothing(true);
}
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
// Get persistent settings (from Registry)
PersistentSettings settings = this.PlugIn.Settings;
bool save_settings = false;
bool enabled = settings.GetBool("enabled", true);
bool new_layer_visible_in_layout = settings.GetBool("new_layer_visible_in_layout", false);
GetOption go = new GetOption();
OptionToggle option_toggle_enabled = new OptionToggle(enabled, "off", "on");
OptionToggle option_toggle_newLayerLayoutVisible = new OptionToggle(new_layer_visible_in_layout, "off", "on");
go.AddOptionToggle("enabled", ref option_toggle_enabled);
go.AddOptionToggle("new_layer_visible_in_layout", ref option_toggle_newLayerLayoutVisible);
go.SetCommandPrompt("Safe Layout Settings");
Rhino.Input.GetResult get_rc = go.Get();
Result rc = go.CommandResult();
if (enabled != option_toggle_enabled.CurrentValue)
{
enabled = option_toggle_enabled.CurrentValue;
settings.SetBool("enabled", enabled);
save_settings = true;
}
if (new_layer_visible_in_layout != option_toggle_newLayerLayoutVisible.CurrentValue)
{
new_layer_visible_in_layout = option_toggle_newLayerLayoutVisible.CurrentValue;
settings.SetBool("new_layer_visible_in_layout", new_layer_visible_in_layout);
save_settings = true;
}
if (save_settings)
{
this.PlugIn.SaveSettings();
}
return(rc);
}
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
using (var go = new GetObject())
{
go.SetCommandPrompt("Please select closed objects for converting to Honeybee Room");
//Only Brep is accepted, because we need to save meta data to sub-surface as well.
//Extrusion doesn't have sub-surface.
//all extrusion will be converted to Brep.
go.GeometryFilter = ObjectType.Brep | ObjectType.Extrusion;
go.EnableClearObjectsOnEntry(false);
go.EnableUnselectObjectsOnExit(false);
go.DeselectAllBeforePostSelect = false;
//check if any brep has been converted to Room
var optionSkipExistingRoom_toggle = new OptionToggle(true, "No_RecreateAllRooms", "Yes");
while (true)
{
go.ClearCommandOptions();
go.AddOptionToggle("SkipExistingRoom", ref optionSkipExistingRoom_toggle);
var rc = go.GetMultiple(1, 0);
if (rc == GetResult.Option)
{
go.EnablePreSelect(false, true);
continue;
}
else if (rc != GetResult.Object)
{
return(Result.Cancel);
}
if (go.ObjectsWerePreselected)
{
go.EnablePreSelect(false, true);
continue;
}
break;
}
if (go.CommandResult() != Result.Success)
{
return(Result.Failure);
}
if (go.ObjectCount == 0)
{
return(Result.Nothing);
}
var ifSkip = optionSkipExistingRoom_toggle.CurrentValue;
//Getting objects
var solidBreps = go.Objects().Where(_ => _.Brep() != null).Where(_ => _.Brep().IsSolid);
var objectToConvert = solidBreps;
if (ifSkip)
{
objectToConvert = solidBreps.Where(_ => !_.IsRoom()).ToList();
}
ConvertToRoom(doc, objectToConvert);
doc.Views.Redraw();
var count = objectToConvert.Count();
var msg = count > 1 ? $"{count} Honeybee rooms were created successfully!" : $"{count} Honeybee room was created successfully!";
RhinoApp.WriteLine(msg);
return(Result.Success);
}
}
public void SetWallMode(int mode) => wallMode = (OptionToggle)mode;
/// <summary>
/// Command.RunCommand override
/// </summary>
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
Potrace.Clear();
// Prompt the user for the name of the image file to vectorize.
string path = GetImageFileName(mode);
if (string.IsNullOrEmpty(path))
{
return(Result.Cancel);
}
// Creates a bitmap from the specified file.
var bitmap = Image.FromFile(path) as Bitmap;
if (null == bitmap)
{
RhinoApp.WriteLine("The specified file cannot be identifed as a supported type.");
return(Result.Failure);
}
// Verify bitmap size
if (0 == bitmap.Width || 0 == bitmap.Height)
{
RhinoApp.WriteLine("Error reading the specified file.");
return(Result.Failure);
}
// Calculate scale factor so curves of a reasonable size are added to Rhino
var unit_scale = (doc.ModelUnitSystem != UnitSystem.Inches)
? RhinoMath.UnitScale(UnitSystem.Inches, doc.ModelUnitSystem)
: 1.0;
var scale = (double)(1.0 / bitmap.HorizontalResolution * unit_scale);
// I'm not convinced this is useful...
if (true)
{
var format = $"F{doc.DistanceDisplayPrecision}";
// Print image size in pixels
RhinoApp.WriteLine("Image size in pixels: {0} x {1}",
bitmap.Width,
bitmap.Height
);
// Print image size in inches
var width = (double)(bitmap.Width / bitmap.HorizontalResolution);
var height = (double)(bitmap.Height / bitmap.VerticalResolution);
RhinoApp.WriteLine("Image size in inches: {0} x {1}",
width.ToString(format, CultureInfo.InvariantCulture),
height.ToString(format, CultureInfo.InvariantCulture)
);
// Image size in in model units, if needed
if (doc.ModelUnitSystem != UnitSystem.Inches)
{
width = (double)(bitmap.Width / bitmap.HorizontalResolution * unit_scale);
height = (double)(bitmap.Height / bitmap.VerticalResolution * unit_scale);
RhinoApp.WriteLine("Image size in {0}: {1} x {2}",
doc.ModelUnitSystem.ToString().ToLower(),
width.ToString(format, CultureInfo.InvariantCulture),
height.ToString(format, CultureInfo.InvariantCulture)
);
}
}
// Convert the bitmap to an Eto bitmap
var eto_bitmap = ConvertBitmapToEto(bitmap);
if (null == eto_bitmap)
{
RhinoApp.WriteLine("Unable to convert image to Eto bitmap.");
return(Result.Failure);
}
// 12-Jan-2021 Dale Fugier
// This should prevent Eto.Drawing.BitmapData.GetPixels() from throwing an exception
if (!IsCompatibleBitmap(eto_bitmap))
{
RhinoApp.WriteLine("The image has an incompatible pixel format. Please select an image with 24 or 32 bits per pixel, or 8 bit indexed.");
return(Result.Failure);
}
// This bitmap is not needed anymore, so dispose of it
bitmap.Dispose();
// Gets the Potrace settings from the plug-in settings file
GetPotraceSettings();
// Create the conduit, which does most of the work
var conduit = new VectorizeConduit(
eto_bitmap,
scale,
doc.ModelAbsoluteTolerance,
m_select_output
? Rhino.ApplicationSettings.AppearanceSettings.SelectedObjectColor
: doc.Layers.CurrentLayer.Color
)
{
Enabled = true
};
if (mode == RunMode.Interactive)
{
// Show the interactive dialog box
var dialog = new VectorizeDialog(doc, conduit);
dialog.RestorePosition();
var result = dialog.ShowSemiModal(doc, RhinoEtoApp.MainWindow);
dialog.SavePosition();
if (result != Result.Success)
{
conduit.Enabled = false;
Potrace.Clear();
doc.Views.Redraw();
return(Result.Cancel);
}
}
else
{
// Show the command line options
var go = new GetOption();
go.SetCommandPrompt("Vectorization options. Press Enter when done");
go.AcceptNothing(true);
while (true)
{
conduit.TraceBitmap();
doc.Views.Redraw();
go.ClearCommandOptions();
// IgnoreArea
var turdsize_opt = new OptionInteger(Potrace.turdsize, 2, 100);
var turdsize_idx = go.AddOptionInteger("FilterSize", ref turdsize_opt, "Filter speckles of up to this size in pixels");
// TurnPolicy
var turnpolicy_idx = go.AddOptionEnumList("TurnPolicy", Potrace.turnpolicy);
// Optimizing
var curveoptimizing_opt = new OptionToggle(Potrace.curveoptimizing, "No", "Yes");
var curveoptimizing_idx = go.AddOptionToggle("Optimizing", ref curveoptimizing_opt);
// Tolerance
var opttolerance_opt = new OptionDouble(Potrace.opttolerance, 0.0, 1.0);
var opttolerance_idx = go.AddOptionDouble("Tolerance", ref opttolerance_opt, "Optimizing tolerance");
// CornerThreshold
var alphamax_opt = new OptionDouble(Potrace.alphamax, 0.0, 100.0);
var alphamax_idx = go.AddOptionDouble("CornerRounding", ref alphamax_opt, "Corner rounding threshold");
// Threshold
var threshold_opt = new OptionDouble(Potrace.Treshold, 0.0, 100.0);
var threshold_idx = go.AddOptionDouble("Threshold", ref threshold_opt, "Threshold");
// RestoreDefaults
var defaults_idx = go.AddOption("RestoreDefaults");
var res = go.Get();
if (res == GetResult.Option)
{
var option = go.Option();
if (null != option)
{
if (turdsize_idx == option.Index)
{
Potrace.turdsize = turdsize_opt.CurrentValue;
}
if (turnpolicy_idx == option.Index)
{
var list = Enum.GetValues(typeof(TurnPolicy)).Cast <TurnPolicy>().ToList();
Potrace.turnpolicy = list[option.CurrentListOptionIndex];
}
if (curveoptimizing_idx == option.Index)
{
Potrace.curveoptimizing = curveoptimizing_opt.CurrentValue;
}
if (opttolerance_idx == option.Index)
{
Potrace.opttolerance = opttolerance_opt.CurrentValue;
}
if (alphamax_idx == option.Index)
{
Potrace.alphamax = alphamax_opt.CurrentValue;
}
if (threshold_idx == option.Index)
{
Potrace.Treshold = threshold_opt.CurrentValue;
}
if (defaults_idx == option.Index)
{
Potrace.RestoreDefaults();
}
}
continue;
}
if (res != GetResult.Nothing)
{
conduit.Enabled = false;
doc.Views.Redraw();
Potrace.Clear();
return(Result.Cancel);
}
break;
}
}
// Group curves
var attributes = doc.CreateDefaultAttributes();
attributes.AddToGroup(doc.Groups.Add());
for (var i = 0; i < conduit.OutlineCurves.Count; i++)
{
var rhobj_id = doc.Objects.AddCurve(conduit.OutlineCurves[i], attributes);
if (m_select_output)
{
var rhobj = doc.Objects.Find(rhobj_id);
if (null != rhobj)
{
rhobj.Select(true);
}
}
}
conduit.Enabled = false;
Potrace.Clear();
doc.Views.Redraw();
// Set the Potrace settings to the plug -in settings file.
SetPotraceSettings();
return(Result.Success);
}
public static void Load()
{
config = new ModConfig();
foreach (FieldInfo f in typeof(MoreOptionsMod).GetFields(BindingFlags.Static | BindingFlags.NonPublic).Where(f => f.Name.EndsWith("Bool")))
{
config.BindConfig(null, f);
}
var harmony = new Harmony("exund.moreoptions");
harmony.PatchAll(Assembly.GetExecutingAssembly());
var modName = "More Options";
//doProcessFire = new OptionToggle("Process Fire", modName, doProcessFireBool);
var displayMuzzleFlashes = new OptionToggle("Muzzle Flashes", modName, displayMuzzleFlashesBool);
var displayBulletsCasing = new OptionToggle("Bullets Casing", modName, displayBulletsCasingBool);
var displaySmokeTrails = new OptionToggle("Smoke Trails", modName, displaySmokeTrailsBool);
var displayHoverEffects = new OptionToggle("Hover Effects", modName, displayHoverEffectsBool);
var displayRemoteChargersEffects = new OptionToggle("Remote Chargers Effects", modName, displayRemoteChargersEffectsBool);
var displayHolderBeams = new OptionToggle("Holder Beams", modName, displayHolderBeamsBool);
var displayThrustersEffects = new OptionToggle("Thrusters Effects", modName, displayThrustersEffectsBool);
var displayMissileSmoke = new OptionToggle("Missile Smoke", modName, displayMissileSmokeBool);
var displayProjectileExplosions = new OptionToggle("Projectile Explosions", modName, displayProjectileExplosionsBool);
var displayBlockExplosions = new OptionToggle("Block Explosions", modName, displayBlockExplosionsBool);
var displayAntennaGlow = new OptionToggle("Antenna Glow", modName, displayAntennaGlowBool);
var antigravMatSwap = new OptionToggle("Antigrav color pulse", modName, antigravMatSwapBool);
var displayBubbles = new OptionToggle("Bubbles (shield, healing)", modName, displayBubblesBool);
/*doProcessFire.onValueSaved.AddListener(() =>
* {
* doProcessFireBool = doProcessFire.SavedValue;
* });*/
displayMuzzleFlashes.onValueSaved.AddListener(() =>
{
displayMuzzleFlashesBool = displayMuzzleFlashes.SavedValue;
});
displayBulletsCasing.onValueSaved.AddListener(() =>
{
displayBulletsCasingBool = displayBulletsCasing.SavedValue;
});
displaySmokeTrails.onValueSaved.AddListener(() =>
{
displaySmokeTrailsBool = displaySmokeTrails.SavedValue;
});
displayHoverEffects.onValueSaved.AddListener(() =>
{
displayHoverEffectsBool = displayHoverEffects.SavedValue;
});
displayRemoteChargersEffects.onValueSaved.AddListener(() =>
{
displayRemoteChargersEffectsBool = displayRemoteChargersEffects.SavedValue;
});
displayHolderBeams.onValueSaved.AddListener(() =>
{
displayHolderBeamsBool = displayHolderBeams.SavedValue;
});
displayThrustersEffects.onValueSaved.AddListener(() =>
{
displayThrustersEffectsBool = displayThrustersEffects.SavedValue;
});
displayMissileSmoke.onValueSaved.AddListener(() =>
{
displayMissileSmokeBool = displayMissileSmoke.SavedValue;
});
displayProjectileExplosions.onValueSaved.AddListener(() =>
{
displayProjectileExplosionsBool = displayProjectileExplosions.SavedValue;
});
displayBlockExplosions.onValueSaved.AddListener(() =>
{
displayBlockExplosionsBool = displayBlockExplosions.SavedValue;
});
displayAntennaGlow.onValueSaved.AddListener(() =>
{
displayAntennaGlowBool = displayAntennaGlow.SavedValue;
});
antigravMatSwap.onValueSaved.AddListener(() =>
{
antigravMatSwapBool = antigravMatSwap.SavedValue;
});
displayBubbles.onValueSaved.AddListener(() =>
{
displayBubblesBool = displayBubbles.SavedValue;
});
NativeOptionsMod.onOptionsSaved.AddListener(() =>
{
config.WriteConfigJsonFile();
});
}
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
Result rc = Result.Nothing;
GetResult res = GetResult.Nothing;
// Select objects to rotate
TransformObjectList list = new TransformObjectList();
rc = SelectObjects("Select objects to transform", list);
if (rc != Result.Success)
{
return(rc);
}
OptionToggle opt_xset = new OptionToggle(true, "No", "Yes");
OptionToggle opt_yset = new OptionToggle(true, "No", "Yes");
OptionToggle opt_zset = new OptionToggle(true, "No", "Yes");
// Second reference point
GetSetPointTransform gx = new GetSetPointTransform(true, true, true);
gx.SetCommandPrompt("Location for points");
gx.AddTransformObjects(list);
for (;;)
{
gx.ClearCommandOptions();
gx.AddOptionToggle("XSet", ref opt_xset);
gx.AddOptionToggle("YSet", ref opt_yset);
gx.AddOptionToggle("ZSet", ref opt_zset);
res = gx.GetXform();
if (res == GetResult.Point)
{
RhinoView view = gx.View();
rc = (null != view) ? Result.Success : Result.Failure;
if (rc == Result.Success)
{
Transform xform = gx.CalculateTransform(view.ActiveViewport, gx.Point());
rc = (xform.IsValid) ? Result.Success : Result.Failure;
if (rc == Result.Success)
{
TransformObjects(list, xform, false, false);
doc.Views.Redraw();
}
}
}
else if (res == GetResult.Option)
{
gx.SetX = opt_xset.CurrentValue;
gx.SetY = opt_yset.CurrentValue;
gx.SetZ = opt_zset.CurrentValue;
continue;
}
else
{
rc = Result.Cancel;
}
break;
}
return(rc);
}
public static Result ExtractIsoCurve(RhinoDoc doc)
{
ObjRef obj_ref;
var rc = RhinoGet.GetOneObject("Select surface", false, ObjectType.Surface, out obj_ref);
if (rc != Result.Success || obj_ref == null)
{
return(rc);
}
var surface = obj_ref.Surface();
var gp = new GetPoint();
gp.SetCommandPrompt("Point on surface");
gp.Constrain(surface, false);
var option_toggle = new OptionToggle(false, "U", "V");
gp.AddOptionToggle("Direction", ref option_toggle);
Point3d point = Point3d.Unset;
while (true)
{
var grc = gp.Get();
if (grc == GetResult.Option)
{
continue;
}
else if (grc == GetResult.Point)
{
point = gp.Point();
break;
}
else
{
return(Result.Nothing);
}
}
if (point == Point3d.Unset)
{
return(Result.Nothing);
}
int direction = option_toggle.CurrentValue ? 1 : 0; // V : U
double u_parameter, v_parameter;
if (!surface.ClosestPoint(point, out u_parameter, out v_parameter))
{
return(Result.Failure);
}
var iso_curve = surface.IsoCurve(direction, direction == 1 ? u_parameter : v_parameter);
if (iso_curve == null)
{
return(Result.Failure);
}
doc.Objects.AddCurve(iso_curve);
doc.Views.Redraw();
return(Result.Success);
}
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
SearchMode sm = SearchMode.CurveLength;
Curve[] curves;
OptionToggle tog = new OptionToggle(false, "Hide", "Show");
OptionDouble tol = new OptionDouble(RhinoDoc.ActiveDoc.ModelAbsoluteTolerance, true, 0.0);
using (CurvesGetter getLines = new CurvesGetter("Select curves meeting at endpoints. Press Enter when done"))
{
for ( ; ;)
{
getLines.ClearCommandOptions();
getLines.EnableClearObjectsOnEntry(false);
int showInt = getLines.AddOptionToggle("Topology", ref tog);
int tolInt = getLines.AddOptionDouble("Tolerance", ref tol);
int modeInt = GetterExtension.AddEnumOptionList(getLines, sm);
if (getLines.Curves(1, 0, out curves))
{
break;
}
else
{
if (getLines.Result() == GetResult.Option)
{
if (getLines.Option().Index == modeInt)
{
sm = GetterExtension.RetrieveEnumOptionValue <SearchMode>
(getLines.Option().CurrentListOptionIndex);
}
continue;
}
else
{
RhinoApp.WriteLine("Less than three lines were selected");
return(Result.Cancel);
}
}
}
}
CurvesTopology crvTopology = new CurvesTopology(curves, tol.CurrentValue);
Guid[] ids = null;
if (tog.CurrentValue)
{
ids = CurvesTopologyPreview.Mark(crvTopology, Color.LightBlue, Color.LightCoral);
}
int walkFromIndex;
using (var getStart = new TrackingPointGetter("Select the start point of the walk on the curves", crvTopology))
{
if (getStart.GetPointOnTopology(out walkFromIndex) != Result.Success)
{
EndOperations(ids);
return(Result.Cancel);
}
}
Result wasSuccessful = Result.Cancel;
for (; ;)
{
int walkToIndex;
double[] distances;
using (var getEnd = new TrackingPointGetter("Select the end point", crvTopology, walkFromIndex, sm))
{
if (getEnd.GetPointOnTopology(out walkToIndex) != Result.Success)
{
break;
}
distances = getEnd.DistanceCache;
}
if (walkFromIndex == walkToIndex)
{
RhinoApp.WriteLine("Start and end points are equal");
EndOperations(ids);
return(Result.Nothing);
}
PathMethod pathSearch = PathMethod.FromMode(sm, crvTopology, distances);
int[] nIndices, eIndices;
bool[] eDirs;
double totLength;
Curve c =
pathSearch.Cross(walkFromIndex, walkToIndex, out nIndices, out eIndices, out eDirs, out totLength);
if (c != null && c.IsValid)
{
if (tog.CurrentValue)
{
RhinoApp.WriteLine("Vertices: {0}", FormatNumbers(nIndices));
RhinoApp.WriteLine("Edges: {0}", FormatNumbers(eIndices));
}
var a = RhinoDoc.ActiveDoc.CreateDefaultAttributes();
Guid g = RhinoDoc.ActiveDoc.Objects.AddCurve(c, a);
var obj = RhinoDoc.ActiveDoc.Objects.Find(g);
if (obj != null)
{
obj.Select(true);
wasSuccessful = Result.Success;
walkFromIndex = walkToIndex;
}
else
{
RhinoApp.WriteLine("An error occurred while adding the new polycurve.");
wasSuccessful = Result.Failure;
break;
}
}
else
{
RhinoApp.WriteLine("No path was found. Nodes are isolated.");
wasSuccessful = Result.Nothing;
}
}
EndOperations(ids);
return(wasSuccessful);
}
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
var ptPuffynessOption = new OptionToggle(m_PointPuffyness, "False", "True");
var ptOffsetOption = new OptionDouble(m_PuffynessOffset, 0.5, double.PositiveInfinity);
var ptBorderPuffynessOption = new OptionToggle(m_BorderPuffyness, "False", "True");
var borderOffsetOption = new OptionDouble(m_BorderOffset, 0.5, double.PositiveInfinity);
var go = new GetOption();
go.SetCommandPrompt("Get meshing properties");
go.AcceptNothing(true);
go.AcceptEnterWhenDone(true);
int ptPuffyOptionIndex = go.AddOptionToggle("PointPuffyness", ref ptPuffynessOption);
int offsetOptionIndex = go.AddOptionDouble("OffsetPtPuffy", ref ptOffsetOption);
int borderPuffyOptionIndex = go.AddOptionToggle("BorderPuffyness", ref ptBorderPuffynessOption);
int borderOffsetOptionIndex = go.AddOptionDouble("OffsetBorderPuffy", ref borderOffsetOption);
go.Get();
var result = go.Result();
while (result != GetResult.Nothing)
{
if (result == GetResult.Cancel)
{
return(Result.Cancel);
}
int optionIdx = go.OptionIndex();
if (optionIdx == ptPuffyOptionIndex)
{
m_PointPuffyness = ptPuffynessOption.CurrentValue;
}
else if (optionIdx == offsetOptionIndex)
{
m_PuffynessOffset = ptOffsetOption.CurrentValue;
}
else if (optionIdx == borderPuffyOptionIndex)
{
m_BorderPuffyness = ptBorderPuffynessOption.CurrentValue;
}
else if (optionIdx == borderOffsetOptionIndex)
{
m_BorderOffset = borderOffsetOption.CurrentValue;
}
result = go.Get();
}
ObjRef[] rhObjects;
var res = RhinoGet.GetMultipleObjects("Select planar curves and Weight points", false, Rhino.DocObjects.ObjectType.Curve | Rhino.DocObjects.ObjectType.Point, out rhObjects);
if (res == Result.Success)
{
// 1. subdive in sets: Closed curves, Opened Curves, weight points;
List <Curve> closed_crvs = new List <Curve>();
List <Curve> opened_crvs = new List <Curve>();
List <Point> weight_points = new List <Point>();
bool puffyness = m_PointPuffyness;
double offset = m_PuffynessOffset;
bool border_puffyness = m_BorderPuffyness;
double border_offset = m_BorderOffset;
foreach (var ref_obj in rhObjects)
{
RhinoObject obj = ref_obj.Object();
if (obj.Geometry is Curve)
{
var crv = obj.Geometry as Curve;
if (crv.IsPlanar())
{
if (crv.IsClosed)
{
closed_crvs.Add(crv);
}
else
{
opened_crvs.Add(crv);
}
}
}
else if (obj.Geometry is Point)
{
weight_points.Add(obj.Geometry as Point);
}
}
double space = 1;
// 2. Insert curves into mesh
AM_Region region = null;
Curve border_outer_crv = null;
Curve offset_outer_crv = null;
if (closed_crvs.Count > 0)
{
region = new AM_Region();
for (int i = 0; i < closed_crvs.Count; i++)
{
var crv = closed_crvs[i];
region.AddCurve(crv, space, false);
AreaMassProperties area = AreaMassProperties.Compute(crv, AM_Util.FLT_EPSILON);
if (area.Area > 0 && border_puffyness)
{
if (border_outer_crv == null)
{
border_outer_crv = crv;
}
var offset_Crvs = crv.Offset(Plane.WorldXY, -border_offset, AM_Util.FLT_EPSILON, CurveOffsetCornerStyle.None);
foreach (var c in offset_Crvs)
{
c.Reverse();
doc.Objects.AddCurve(c);
offset_outer_crv = c;
region.AddCurve(c, space, true);
}
}
}
}
else
{
// TODO
Debug.Assert(false);
return(Result.Failure);
}
for (int i = 0; i < weight_points.Count; i++)
{
var pt = weight_points[i];
region.AddWeigthPoint(pt, space / 2);
if (puffyness && offset > 0)
{
var circle = new ArcCurve(new Circle(pt.Location, offset));
var nurbs = circle.ToNurbsCurve();
region.AddCurve(nurbs, space / 2, true);
}
}
for (int i = 0; i < opened_crvs.Count; i++)
{
var crv = opened_crvs[i];
region.AddCurve(crv, space, false);
if (puffyness && offset > 0)
{
var n = Vector3d.CrossProduct(crv.TangentAtStart, Vector3d.ZAxis);
Curve[] offsetCrv = crv.Offset(crv.PointAtStart + offset * n, Vector3d.ZAxis, offset, AM_Util.FLT_EPSILON, CurveOffsetCornerStyle.Round);
foreach (var c in offsetCrv)
{
doc.Objects.AddCurve(c);
region.AddCurve(crv, space, false);
}
Curve[] offsetCrv2 = crv.Offset(crv.PointAtStart - offset * n, Vector3d.ZAxis, offset, AM_Util.FLT_EPSILON, CurveOffsetCornerStyle.Round);
foreach (var c in offsetCrv2)
{
doc.Objects.AddCurve(c);
region.AddCurve(crv, space, false);
}
}
}
// 3. Mesh della regione
if (region != null)
{
if (region.BuildMesh())
{
// Inserisce i punti del contorno
foreach (var loop in region.Loops)
{
for (int i = 0; i < loop.NumSegments; i++)
{
var points = loop.GetGeneratedPoints(i);
//if (points != null) {
// foreach (var p in points) {
// doc.Objects.AddPoint(new Point3d(p.X, p.Y, 0));
// }
//}
}
}
}
// Trasforma in Mesh di Rhino
var mesh = region.Mesh2D;
if (mesh != null)
{
Mesh rhino_mesh = new Mesh();
double t = 5;
for (int i = 0; i < mesh.ArrayVertexes.Count; i++)
{
mesh.ArrayVertexes[i].Z = t;
}
// PostProcessa il puffyness
if (puffyness)
{
for (int i = 0; i < region.ArrayInnerVertex.Count; i++)
{
var iv = region.ArrayInnerVertex[i];
if (iv.MeshVertex != null)
{
iv.MeshVertex.Z = (4 / 5d) * t;
}
// Ricerca i punti nell'intorno fino all'offset (molto grezza!)
for (int j = 0; j < mesh.ArrayVertexes.Count; j++)
{
var v = mesh.ArrayVertexes[j];
double d = (iv.MeshVertex.Coord - v.Coord).Length;
if (d < offset)
{
double r = d / offset;
AM_Util.EInterpolation interpolation = AM_Util.EInterpolation.Parabolic;
v.Z = AM_Util.Interpolation(interpolation, iv.MeshVertex.Z, t, r);
}
}
}
}
// Individua i punti all'interno della zona di transizione
List <int> transitionVts = new List <int>();
if (border_puffyness && border_offset > 0)
{
// Individua i vertici di partenza e utilizza u flag di lavoro
List <AM_Vertex> transitionStartVts = new List <AM_Vertex>();
for (int i = 0; i < mesh.ArrayVertexes.Count; i++)
{
var v = mesh.ArrayVertexes[i];
bool is_loop_vertex = (v.Flag & 0x1) > 0;
v.Flag &= ~0x02;
if (is_loop_vertex && BelongToBorder(v))
{
transitionStartVts.Add(v);
}
}
// Si usa 0x04 come flag di lavoro
for (int i = 0; i < mesh.ArrayWEdges.Count; i++)
{
var e = mesh.ArrayWEdges[i];
e.Edge().Flag &= ~0x04;
e.Edge().Symm().Flag &= ~0x04;
}
for (int i = 0; i < transitionStartVts.Count; i++)
{
var v = transitionStartVts[i];
AddTransitionVertexes(v, transitionVts);
}
if (offset_outer_crv != null)
{
foreach (var iv in transitionVts)
{
var v = mesh.ArrayVertexes[iv];
double par;
if (offset_outer_crv.ClosestPoint(AM_Util.To3d(v.Coord), out par, 2 * border_offset))
{
Point3d cp = offset_outer_crv.PointAt(par);
double r = ((cp - AM_Util.To3d(v.Coord)).Length) / border_offset;
double z = AM_Util.Interpolation(AM_Util.EInterpolation.Parabolic, 0.8 * t, t, 1 - r);
v.Z = z;
}
}
}
}
// Facce
int totVtx = mesh.ArrayVertexes.Count;
for (int iSide = 0; iSide < 2; iSide++)
{
for (int i = 0; i < mesh.ArrayVertexes.Count; i++)
{
var v = mesh.ArrayVertexes[i];
Point3d pt = v.Coord3d;
if (iSide == 1)
{
pt.Z = 0;
}
rhino_mesh.Vertices.Add(pt);
}
for (int i = 0; i < mesh.ArrayFaces.Count; i++)
{
var f = mesh.ArrayFaces[i];
int numEdges = f.NumEdges;
if (numEdges == 3)
{
int[] vtx = { f.Vertex(0).Index, f.Vertex(1).Index, f.Vertex(2).Index };
if (iSide == 1)
{
vtx = new int[] { f.Vertex(0).Index + totVtx, f.Vertex(2).Index + totVtx, f.Vertex(1).Index + totVtx };
}
rhino_mesh.Faces.AddFace(vtx[0], vtx[1], vtx[2]);
}
else if (numEdges == 4)
{
int[] vtx = { f.Vertex(0).Index, f.Vertex(1).Index, f.Vertex(2).Index, f.Vertex(3).Index };
if (iSide == 1)
{
vtx = new int[] { f.Vertex(0).Index + totVtx, f.Vertex(3).Index + totVtx, f.Vertex(2).Index + totVtx, f.Vertex(1).Index + totVtx };
}
rhino_mesh.Faces.AddFace(vtx[0], vtx[1], vtx[2], vtx[3]);
}
}
}
for (int iEdge = 0; iEdge < mesh.ArrayWEdges.Count; iEdge++)
{
var edge = mesh.ArrayWEdges[iEdge].Edge();
if (edge.CcwFace() == null || edge.CwFace() == null)
{
// E' uno spigolo di bordo
int[] vtx = { edge.Destination().Index, edge.Origin().Index,
edge.Origin().Index + totVtx, edge.Destination().Index + totVtx, };
rhino_mesh.Faces.AddFace(vtx[0], vtx[1], vtx[2], vtx[3]);
}
}
rhino_mesh.Normals.ComputeNormals();
rhino_mesh.Compact();
if (doc.Objects.AddMesh(rhino_mesh) != Guid.Empty)
{
doc.Views.Redraw();
return(Rhino.Commands.Result.Success);
}
}
}
return(Result.Success);
}
return(Result.Cancel);
}
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
// TODO: start here modifying the behaviour of your command.
// ---
//RhinoApp.WriteLine("The {0} command will add a line right now.", EnglishName);
GetObject getBreps = new GetObject();
getBreps.SetCommandPrompt("Pick the breps to create a PolyhedralFrame");
getBreps.GeometryFilter = Rhino.DocObjects.ObjectType.Brep;
// set up options
OptionDouble dblOptionCollapse = new Rhino.Input.Custom.OptionDouble(0.1, true, 0.0);
OptionDouble dblOptionPlanar = new Rhino.Input.Custom.OptionDouble(0.1, true, 0.0);
OptionToggle togOptionReplace = new OptionToggle(true, "Keep", "Replace");
getBreps.AddOptionDouble("PointCollapseLimit", ref dblOptionCollapse);
getBreps.AddOptionDouble("PlanarityMaxDeviation", ref dblOptionPlanar);
getBreps.AddOptionToggle("ReplaceGeo", ref togOptionReplace);
getBreps.AcceptNothing(false);
while (true)
{
var r = getBreps.GetMultiple(1, 0);
if (r == GetResult.Cancel)
{
return(getBreps.CommandResult());
}
else if (r == GetResult.Object)
{
break;
}
}
List <Guid> ids = new List <Guid>();
for (int i = 0; i < getBreps.ObjectCount; i++)
{
ids.Add(getBreps.Object(i).ObjectId);
}
var foam = new PFoam();
var deleteOriginal = false;
try
{
foam.ProcessBFaces(Util.DecomposeG(ids), dblOptionCollapse.CurrentValue, dblOptionPlanar.CurrentValue);
doc.Objects.UnselectAll();
if (foam.Faces.Count > 2)
{
foam.MakeCells();
Point3d newCentroid = foam.Centroid;
if (!togOptionReplace.CurrentValue)
{
Rhino.Input.RhinoGet.GetPoint("Place the PolyFrame", true, out newCentroid);
}
else
{
deleteOriginal = true;
}
//Rhino.RhinoDoc.ActiveDoc.Objects.Delete(ids, true);
foam.Offset(newCentroid - foam.Centroid);
foam.Show(true, true, false);
foam.ShowCells();
if (!foam.SaveToDocument())
{
foam.Hide();
return(Result.Cancel);
}
foam.Hide();
if (deleteOriginal)
{
Rhino.RhinoDoc.ActiveDoc.Objects.Delete(ids, true);
}
doc.Views.Redraw();
Rhino.RhinoApp.WriteLine($"Constructed a PolyFrame object with {foam.Cells.Count} cells, {foam.Faces.Count} half-faces, {foam.Edges.Count} half-edges and {foam.Vertices.Count} vertices.");
return(Result.Success);
}
else
{
Rhino.RhinoApp.WriteLine("Not enough faces!");
return(Result.Failure);
}
}
catch (Exception pfE)
{
RhinoApp.WriteLine(pfE.Message + " Press <Esc> to continue.");
foam.Hide();
return(Result.Failure);
}
}
/// <summary>
/// 设置河流模式
/// </summary>
/// <param name="mode"></param>
public void SetRiverMode(int mode)
{
riverMode = (OptionToggle)mode;
}
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
var primal = new PFoam();
var dual = new PFoam();
ContainerType container;
try
{
var guids = LoadData.LoadPrimalDual(out primal, out dual, out container);
if (dual.Cells.Count < 1)
{
RhinoApp.WriteLine("No dual data retrieved from the container!");
return(Result.Failure);
}
// Primal ( the perping geometry )
// load the foam from the geometry option to update from the geometry if any changes occured
// select the structure to be perped - if dual not present raise error
// show a set of options
// Max steps 10 000
// maximum deviation in degrees from dual direction
// Update dual data from geometry
// set edge legth constraint
// set point position constraint
var averageLen = primal.Edges.Select(x => x.GetLength()).Average();
var getOptions = new GetOption();
getOptions.SetDefaultString("enter");
getOptions.SetCommandPrompt("Set max number of steps and perping options");
var optionSteps = new OptionInteger(1000, true, 0);
var optionMaxDev = new OptionDouble(0.1, 0.0, 10.0);
var optionMinLen = new OptionDouble(averageLen / 4, true, averageLen / 100);
var optionSetEdge = new OptionToggle(false, "setE", "E_set");
var optionSetVert = new OptionToggle(false, "setV", "V_set");
var optionSetDualGeo = new OptionToggle(false, "setG", "G_set");
var storedSteps = 1000.0;
var storedMaxDev = 0.1;
var storedMinLen = averageLen / 4;
bool storedEdgeSet = false;
bool storedVertSet = false;
bool storedDualGeoSet = false;
getOptions.AddOptionInteger("MaxIterations", ref optionSteps);
getOptions.AddOptionDouble("MaxDeviation", ref optionMaxDev);
getOptions.AddOptionDouble("MinEdgeLenght", ref optionMinLen);
getOptions.AddOptionToggle("SetEdgeLen", ref optionSetEdge);
getOptions.AddOptionToggle("SetVertPos", ref optionSetVert);
getOptions.AddOptionToggle("UpdatePrimalGeo", ref optionSetDualGeo);
while (true)
{
var preres = getOptions.Get();
var res = getOptions.CommandResult();
//var numres = getOptions.
if (res == Result.Success)
{
if (optionSetEdge.CurrentValue != storedEdgeSet)
{
primal.PickEdges();
}
if (optionSetVert.CurrentValue != storedVertSet)
{
primal.PickVertex();
}
if (optionSetDualGeo.CurrentValue != storedDualGeoSet)
{
var updatedDual = new PFoam();
LoadData.LoadPrimalDual(out updatedDual, out PFoam notUsedPrimal, out ContainerType dummyContainer, false);
// get the container geometry from a dual from the document
// check to see if the id matches
// load the point geometry, centroids, meshes and update data in the dual
// transform the primal/dual getter into a method to reuse it more easily
if (updatedDual.Dual.Id == primal.Id)
{
dual = updatedDual;
Util.ConnectDuals(ref primal, ref updatedDual);
}
}
if (optionSetEdge.CurrentValue == storedEdgeSet &&
optionSetVert.CurrentValue == storedVertSet &&
optionSetDualGeo.CurrentValue == storedDualGeoSet &&
optionSteps.CurrentValue == storedSteps &&
optionMaxDev.CurrentValue == storedMaxDev &&
optionMinLen.CurrentValue == storedMinLen
)
{
break;
}
storedEdgeSet = optionSetEdge.CurrentValue;
storedVertSet = optionSetVert.CurrentValue;
storedDualGeoSet = optionSetDualGeo.CurrentValue;
storedSteps = optionSteps.CurrentValue;
storedMaxDev = optionMaxDev.CurrentValue;
storedMinLen = optionMinLen.CurrentValue;
}
else
{
return(Result.Cancel);
}
}
//Util.ConnectDuals(ref primal, ref dual);
foreach (var edge in primal.Edges)
{
edge.MinLength = optionMinLen.CurrentValue;
}
// delete the input objects
doc.Objects.Delete(guids, true);
primal.PerpSoft(optionSteps.CurrentValue, optionMaxDev.CurrentValue / 180 * Math.PI);
//primal.ParaPerp(optionSteps.CurrentValue, 0, optionMaxDev.CurrentValue / 180 * Math.PI, null, 1);
primal.Show(true, true, false);
var pepedPrimalJsonString = primal.SerializeJson();
if (!primal.SaveToDocument(container))
{
primal.Hide();
return(Result.Cancel);
}
primal.Hide();
return(Result.Success);
}
catch (PolyFrameworkException pfE)
{
RhinoApp.WriteLine(pfE.Message);
primal.Hide();
dual.Hide();
return(Result.Failure);
}
// TODO: complete command.
}
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
//look at this for a summary of all the GET commands.
// https://developer.rhino3d.com/api/RhinoCommon/html/T_Rhino_Input_Custom_GetBaseClass.htm.
/*System.Object
* Rhino.Input.Custom.GetBaseClass
* Rhino.Input.Custom.GetInteger
* Rhino.Input.Custom.GetNumber
* Rhino.Input.Custom.GetObject
* Rhino.Input.Custom.GetOption
* Rhino.Input.Custom.GetPoint
* Rhino.Input.Custom.GetString
*
* */
var gc = new GetObject();
gc.SetCommandPrompt("Select objects");
gc.GeometryFilter = ObjectType.AnyObject;
OptionInteger intOption = new OptionInteger(1, 1, 99);
OptionDouble dblOption = new OptionDouble(2.2, 0, 99);
OptionToggle boolOption = new OptionToggle(true, "off", "on");
gc.AddOptionInteger("Integer", ref intOption);
gc.AddOptionDouble("Double", ref dblOption);
gc.AddOptionToggle("Boolean", ref boolOption);
int listIndex = 0;
string[] listValues = new string[] { "Bran", "Bob", "Arya", "Sansa", "Rickon" };
int optList = gc.AddOptionList("List", listValues, listIndex);
while (true)
{
GetResult res = gc.GetMultiple(1, 0);
//we can check if the user selected something
if (gc.CommandResult() != Result.Success)
{
return(gc.CommandResult());
}
if (res == Rhino.Input.GetResult.Object)
{
RhinoApp.WriteLine("Command line option values are");
RhinoApp.WriteLine("Integer = {0}", intOption.CurrentValue);
RhinoApp.WriteLine("Double = {0}", dblOption.CurrentValue);
RhinoApp.WriteLine("Boolean = {0}", boolOption.CurrentValue);
RhinoApp.WriteLine("List = {0}", listValues[listIndex]);
}
else if (res == Rhino.Input.GetResult.Option)
{
if (gc.OptionIndex() == optList)
{
listIndex = gc.Option().CurrentListOptionIndex; //this updates the list option to whatever index the user has picked
}
continue;
}
break;
}
return(Result.Success);
}
public static void Load()
{
var harmony = HarmonyInstance.Create("exund.advancedbuilding");
harmony.PatchAll(Assembly.GetExecutingAssembly());
assetBundle = AssetBundle.LoadFromFile(asm_path + "Assets/advancedbuilding");
try
{
_holder = new GameObject();
_holder.AddComponent <AdvancedEditor>();
_holder.AddComponent <BlockPicker>();
if (Directory.Exists(PreciseSnapshotsFolder))
{
_holder.AddComponent <LoadWindow>();
}
UnityEngine.Object.DontDestroyOnLoad(_holder);
transformGizmo = Singleton.cameraTrans.gameObject.AddComponent <RuntimeGizmos.TransformGizmo>();
transformGizmo.enabled = false;
config.TryGetConfig <float>("position_step", ref AdvancedEditor.position_step);
config.TryGetConfig <float>("rotation_step", ref AdvancedEditor.rotation_step);
config.TryGetConfig <float>("scale_step", ref AdvancedEditor.scale_step);
config.TryGetConfig <bool>("open_inventory", ref BlockPicker.open_inventory);
config.TryGetConfig <bool>("global_filters", ref BlockPicker.global_filters);
var key = (int)BlockPicker.block_picker_key;
config.TryGetConfig <int>("block_picker_key", ref key);
BlockPicker.block_picker_key = (KeyCode)key;
config.TryGetConfig <bool>("clearOnCollapse", ref PaletteTextFilter.clearOnCollapse);
var key2 = (int)PhysicsInfo.centers_key;
config.TryGetConfig <int>("centers_key", ref key2);
PhysicsInfo.centers_key = (KeyCode)key2;
string modName = "Advanced Building";
OptionKey blockPickerKey = new OptionKey("Block Picker activation key", modName, BlockPicker.block_picker_key);
blockPickerKey.onValueSaved.AddListener(() =>
{
BlockPicker.block_picker_key = blockPickerKey.SavedValue;
config["block_picker_key"] = (int)BlockPicker.block_picker_key;
});
OptionToggle globalFilterToggle = new OptionToggle("Block Picker - Use global filters", modName, BlockPicker.global_filters);
globalFilterToggle.onValueSaved.AddListener(() =>
{
BlockPicker.global_filters = globalFilterToggle.SavedValue;
config["global_filters"] = BlockPicker.global_filters;
});
OptionToggle openInventoryToggle = new OptionToggle("Block Picker - Automatically open the inventory when picking a block", modName, BlockPicker.open_inventory);
openInventoryToggle.onValueSaved.AddListener(() =>
{
BlockPicker.open_inventory = openInventoryToggle.SavedValue;
config["open_inventory"] = BlockPicker.open_inventory;
});
OptionToggle clearOnCollapse = new OptionToggle("Block Search - Clear filter when closing inventory", modName, PaletteTextFilter.clearOnCollapse);
clearOnCollapse.onValueSaved.AddListener(() =>
{
PaletteTextFilter.clearOnCollapse = clearOnCollapse.SavedValue;
config["clearOnCollapse"] = PaletteTextFilter.clearOnCollapse;
});
OptionKey centersKey = new OptionKey("Open physics info menu (Ctrl + ?)", modName, PhysicsInfo.centers_key);
centersKey.onValueSaved.AddListener(() =>
{
PhysicsInfo.centers_key = centersKey.SavedValue;
config["centers_key"] = (int)PhysicsInfo.centers_key;
});
NativeOptionsMod.onOptionsSaved.AddListener(() =>
{
config.WriteConfigJsonFile();
});
new BlockPrefabBuilder(BlockTypes.GSOBlock_111, true)
.SetBlockID(7020)
.SetName("Reticule Research Hadamard Superposer")
.SetDescription("This block can register quantum fluctuations applied on the tech's blocks and stabilize them during the snapshot process.\n\n<b>Warning</b>: Can cause temporary quantum jumps if it enters in contact with zero-stasis gluons.\nUsed to activate Advanced Building.")
.SetFaction(FactionSubTypes.EXP)
.SetCategory(BlockCategories.Accessories)
.SetRarity(BlockRarity.Rare)
.SetPrice(58860)
.SetRecipe(new Dictionary <ChunkTypes, int> {
{ ChunkTypes.SeedAI, 5 }
})
.SetModel(GameObjectJSON.MeshFromFile(asm_path + "Assets/hadamard_superposer.obj"), true, GameObjectJSON.GetObjectFromGameResources <Material>("RR_Main"))
.SetIcon(GameObjectJSON.ImageFromFile(asm_path + "Assets/hadamard_superposer.png"))
.AddComponent <ModuleOffgridStore>()
.RegisterLater();
{
var ontop = new Material(assetBundle.LoadAsset <Shader>("OnTop"));
var go = new GameObject();
var mr = go.AddComponent <MeshRenderer>();
mr.material = ontop;
mr.material.mainTexture = GameObjectJSON.ImageFromFile(asm_path + "Assets/CO.png");
mr.material.mainTexture.filterMode = FilterMode.Point;
var mf = go.AddComponent <MeshFilter>();
mf.sharedMesh = mf.mesh = GameObjectJSON.MeshFromFile(asm_path + "Assets/CO.obj");
var line = new GameObject();
var lr = line.AddComponent <LineRenderer>();
lr.startWidth = 0.5f;
lr.endWidth = 0;
lr.SetPositions(new Vector3[] { Vector3.zero, Vector3.zero });
lr.useWorldSpace = true;
lr.material = ontop;
lr.material.color = lr.material.color.SetAlpha(1);
line.transform.SetParent(go.transform, false);
go.SetActive(false);
go.transform.SetParent(_holder.transform, false);
PhysicsInfo.COM = GameObject.Instantiate(go);
var commat = PhysicsInfo.COM.GetComponent <MeshRenderer>().material;
commat.color = Color.yellow;
commat.renderQueue = 1;
PhysicsInfo.COM.GetComponentInChildren <LineRenderer>().enabled = false;
PhysicsInfo.COT = GameObject.Instantiate(go);
PhysicsInfo.COT.transform.localScale *= 0.8f;
var cotmat = PhysicsInfo.COT.GetComponent <MeshRenderer>().material;
cotmat.color = Color.magenta;
cotmat.renderQueue = 3;
var COTlr = PhysicsInfo.COT.GetComponentInChildren <LineRenderer>();
COTlr.material.renderQueue = 2;
COTlr.startColor = COTlr.endColor = Color.magenta;
PhysicsInfo.COL = GameObject.Instantiate(go);
PhysicsInfo.COL.transform.localScale *= 0.64f;
var colmat = PhysicsInfo.COL.GetComponent <MeshRenderer>().material;
colmat.color = Color.cyan;
colmat.renderQueue = 5;
var COLlr = PhysicsInfo.COL.GetComponentInChildren <LineRenderer>();
COLlr.startColor = COLlr.endColor = Color.cyan;
COLlr.material.renderQueue = 4;
}
_holder.AddComponent <PhysicsInfo>();
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
// Command variables
var selectedObjects = new List <RhinoObject>();
string selectedSchema = "";
bool automatic = true;
bool directShape = false;
// Construct an objects getter
// This includes an option toggle for "Automatic" (true means automagic schema application, no directshapes)
var getObj = new GetObject();
getObj.SetCommandPrompt("Select geometry");
var toggleAutomatic = new OptionToggle(true, "Off", "On");
getObj.AddOptionToggle("Automatic", ref toggleAutomatic);
getObj.GroupSelect = true;
getObj.SubObjectSelect = false;
getObj.EnableClearObjectsOnEntry(false);
getObj.EnableUnselectObjectsOnExit(false);
getObj.DeselectAllBeforePostSelect = false;
// Get objects
for (; ;)
{
GetResult res = getObj.GetMultiple(1, 0);
if (res == GetResult.Option)
{
getObj.EnablePreSelect(false, true);
continue;
}
else if (res != GetResult.Object)
{
return(Result.Cancel);
}
if (getObj.ObjectsWerePreselected)
{
getObj.EnablePreSelect(false, true);
continue;
}
break;
}
selectedObjects = getObj.Objects().Select(o => o.Object()).ToList();
automatic = toggleAutomatic.CurrentValue;
// Construct an options getter if "Automatic" was set to "off"
if (!automatic)
{
// Construct an options getter for schema options
// This includes an option toggle for "DirectShape" (true will asign selected schema as the family)
// Also includes an option list of supported schemas
var getOpt = new GetOption();
getOpt.SetCommandPrompt("Select schema options. Press Enter when done");
var toggleDirectShape = new OptionToggle(false, "Off", "On");
var directShapeIndex = getOpt.AddOptionToggle("DirectShape", ref toggleDirectShape);
List <string> schemas = Enum.GetNames(typeof(SchemaObjectFilter.SupportedSchema)).ToList();
int schemaListOptionIndex = getOpt.AddOptionList("Schema", schemas, 0);
// Get options
while (getOpt.Get() == GetResult.Option)
{
if (getOpt.OptionIndex() == schemaListOptionIndex)
{
selectedSchema = schemas[getOpt.Option().CurrentListOptionIndex];
}
if (getOpt.OptionIndex() == directShapeIndex)
{
directShape = toggleDirectShape.CurrentValue;
}
}
}
// Apply schemas
if (automatic)
{
ApplySchemas(selectedObjects, doc);
}
else
{
ApplySchema(selectedObjects, selectedSchema, doc, directShape);
}
return(Result.Success);
}
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
var cs_option = new OptionToggle(m_use_cplane, "World", "CPlane");
var go = new GetObject();
go.SetCommandPrompt("Select objects for bounding box calculation");
go.GroupSelect = true;
go.SubObjectSelect = false;
for (;;)
{
go.ClearCommandOptions();
go.AddOptionToggle("CoordinateSystem", ref cs_option);
var res = go.GetMultiple(1, 0);
if (res == GetResult.Option)
{
continue;
}
else if (res != GetResult.Object)
{
return(Result.Cancel);
}
break;
}
var plane = go.View().ActiveViewport.ConstructionPlane();
m_use_cplane = cs_option.CurrentValue;
var world_to_plane = new Transform(1.0);
if (m_use_cplane)
{
world_to_plane = Transform.ChangeBasis(Plane.WorldXY, plane);
}
var bounding_box = new BoundingBox();
for (var i = 0; i < go.ObjectCount; i++)
{
var rhino_obj = go.Object(i).Object();
if (null != rhino_obj)
{
var box = rhino_obj.Geometry.GetBoundingBox(world_to_plane);
if (box.IsValid)
{
if (i == 0)
{
bounding_box = box;
}
else
{
bounding_box.Union(box);
}
}
}
}
if (!bounding_box.IsValid)
{
RhinoApp.WriteLine("BoundingBox failed. Unable to calculate bounding box.");
return(Result.Failure);
}
var box_corners = new Point3d[8];
box_corners[0] = bounding_box.Corner(false, false, false);
box_corners[1] = bounding_box.Corner(true, false, false);
box_corners[2] = bounding_box.Corner(true, true, false);
box_corners[3] = bounding_box.Corner(false, true, false);
box_corners[4] = bounding_box.Corner(false, false, true);
box_corners[5] = bounding_box.Corner(true, false, true);
box_corners[6] = bounding_box.Corner(true, true, true);
box_corners[7] = bounding_box.Corner(false, true, true);
if (m_use_cplane)
{
// Transform corners points from cplane coordinates
// to world coordinates if necessary.
var plane_to_world = Transform.ChangeBasis(plane, Plane.WorldXY);
for (var i = 0; i < 8; i++)
{
box_corners[i].Transform(plane_to_world);
}
}
Point3d[] rect;
var type = ClassifyBoundingBox(box_corners, out rect);
if (type == BoundingBoxClassification.Point)
{
RhinoApp.WriteLine("BoundingBox failed. The bounding box is a point.");
}
else if (type == BoundingBoxClassification.Line)
{
RhinoApp.WriteLine("BoundingBox failed. The bounding box is a line.");
}
else if (type == BoundingBoxClassification.Rectangle)
{
doc.Objects.AddPolyline(rect);
}
else //if (type == BoundingBoxClassification.Box)
{
var brep = Brep.CreateFromBox(box_corners);
doc.Objects.AddBrep(brep);
}
doc.Views.Redraw();
return(Result.Success);
}
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
var getNumber = new GetNumber();
getNumber.SetLowerLimit(2.0, false);
getNumber.SetUpperLimit(uint.MaxValue, false);
getNumber.SetDefaultInteger(RcCore.It.EngineSettings.Samples);
getNumber.SetCommandPrompt("Set render samples");
var showMaxPasses = new OptionToggle(RcCore.It.EngineSettings.ShowMaxPasses, "HideMaxPasses", "ShowMaxPasses");
var maxBounce = new OptionInteger(RcCore.It.EngineSettings.MaxBounce, 0, 500);
var tileX = new OptionInteger(RcCore.It.EngineSettings.TileX, 0, 10000);
var tileY = new OptionInteger(RcCore.It.EngineSettings.TileY, 0, 10000);
var maxDiffuseBounce = new OptionInteger(RcCore.It.EngineSettings.MaxDiffuseBounce, 0, 200);
var maxGlossyBounce = new OptionInteger(RcCore.It.EngineSettings.MaxGlossyBounce, 0, 200);
var maxTransmissionBounce = new OptionInteger(RcCore.It.EngineSettings.MaxTransmissionBounce, 0, 200);
var maxVolumeBounce = new OptionInteger(RcCore.It.EngineSettings.MaxVolumeBounce, 0, 200);
var noCaustics = new OptionToggle(RcCore.It.EngineSettings.NoCaustics, "Caustics", "NoCaustics");
var aaSamples = new OptionInteger(RcCore.It.EngineSettings.AaSamples, 1, 100);
var diffSamples = new OptionInteger(RcCore.It.EngineSettings.DiffuseSamples, 1, 100);
var glossySamples = new OptionInteger(RcCore.It.EngineSettings.GlossySamples, 1, 100);
var seed = new OptionInteger(RcCore.It.EngineSettings.Seed, 0, int.MaxValue);
var sensorWidth = new OptionDouble(RcCore.It.EngineSettings.SensorWidth, 10.0, 100.0);
var sensorHeight = new OptionDouble(RcCore.It.EngineSettings.SensorHeight, 10.0, 100.0);
var transparentMaxBounce = new OptionInteger(RcCore.It.EngineSettings.TransparentMaxBounce, 0, 200);
var filterGlossy = new OptionDouble(RcCore.It.EngineSettings.FilterGlossy, 0.0, 100.0);
var sampleClampDirect = new OptionDouble(RcCore.It.EngineSettings.SampleClampDirect, 0.0, 100.0);
var sampleClampIndirect = new OptionDouble(RcCore.It.EngineSettings.SampleClampIndirect, 0.0, 100.0);
var lightSamplingThreshold = new OptionDouble(RcCore.It.EngineSettings.LightSamplingThreshold, 0.0, 1.0);
var sampleAllLights = new OptionToggle(RcCore.It.EngineSettings.SampleAllLights, "no", "yes");
var sampleAllLightsIndirect = new OptionToggle(RcCore.It.EngineSettings.SampleAllLightsIndirect, "no", "yes");
getNumber.AddOptionToggle("show_max_passes", ref showMaxPasses);
getNumber.AddOptionInteger("max_bounces", ref maxBounce);
getNumber.AddOptionInteger("tile_x", ref tileX);
getNumber.AddOptionInteger("tile_y", ref tileY);
getNumber.AddOptionToggle("no_caustics", ref noCaustics);
getNumber.AddOptionInteger("max_diffuse_bounce", ref maxDiffuseBounce);
getNumber.AddOptionInteger("max_glossy_bounce", ref maxGlossyBounce);
getNumber.AddOptionInteger("max_transmission_bounce", ref maxTransmissionBounce);
getNumber.AddOptionInteger("max_volume_bounce", ref maxVolumeBounce);
getNumber.AddOptionInteger("transparent_max_bounce", ref transparentMaxBounce);
getNumber.AddOptionInteger("aa_samples", ref aaSamples);
getNumber.AddOptionInteger("diffuse_samples", ref diffSamples);
getNumber.AddOptionInteger("glossy_samples", ref glossySamples);
getNumber.AddOptionDouble("sensor_width", ref sensorWidth);
getNumber.AddOptionDouble("sensor_height", ref sensorHeight);
getNumber.AddOptionInteger("seed", ref seed, "Seed to use for sampling distribution");
getNumber.AddOptionDouble("filter_glossy", ref filterGlossy);
getNumber.AddOptionDouble("sample_clamp_direct", ref sampleClampDirect);
getNumber.AddOptionDouble("sample_clamp_indirect", ref sampleClampIndirect);
getNumber.AddOptionDouble("light_sampling_threshold", ref lightSamplingThreshold);
getNumber.AddOptionToggle("sample_all_lights", ref sampleAllLights);
getNumber.AddOptionToggle("sample_all_lights_indirect", ref sampleAllLightsIndirect);
while (true)
{
var getRc = getNumber.Get();
if (getNumber.CommandResult() != Result.Success)
{
return(getNumber.CommandResult());
}
switch (getRc)
{
case GetResult.Number:
RhinoApp.WriteLine($"We got: {getNumber.Number()}, {maxBounce.CurrentValue}");
RcCore.It.EngineSettings.Samples = (int)getNumber.Number();
RcCore.It.EngineSettings.ShowMaxPasses = showMaxPasses.CurrentValue;
RcCore.It.EngineSettings.Seed = seed.CurrentValue;
RcCore.It.EngineSettings.MaxBounce = maxBounce.CurrentValue;
RcCore.It.EngineSettings.TileX = tileX.CurrentValue;
RcCore.It.EngineSettings.TileY = tileY.CurrentValue;
RcCore.It.EngineSettings.NoCaustics = noCaustics.CurrentValue;
RcCore.It.EngineSettings.MaxDiffuseBounce = maxDiffuseBounce.CurrentValue;
RcCore.It.EngineSettings.MaxGlossyBounce = maxGlossyBounce.CurrentValue;
RcCore.It.EngineSettings.MaxTransmissionBounce = maxTransmissionBounce.CurrentValue;
RcCore.It.EngineSettings.MaxVolumeBounce = maxVolumeBounce.CurrentValue;
RcCore.It.EngineSettings.TransparentMaxBounce = transparentMaxBounce.CurrentValue;
RcCore.It.EngineSettings.AaSamples = aaSamples.CurrentValue;
RcCore.It.EngineSettings.DiffuseSamples = diffSamples.CurrentValue;
RcCore.It.EngineSettings.GlossySamples = glossySamples.CurrentValue;
RcCore.It.EngineSettings.SensorWidth = (float)sensorWidth.CurrentValue;
RcCore.It.EngineSettings.SensorHeight = (float)sensorHeight.CurrentValue;
RcCore.It.EngineSettings.FilterGlossy = (float)filterGlossy.CurrentValue;
RcCore.It.EngineSettings.SampleClampDirect = (float)sampleClampDirect.CurrentValue;
RcCore.It.EngineSettings.SampleClampIndirect = (float)sampleClampIndirect.CurrentValue;
RcCore.It.EngineSettings.LightSamplingThreshold = (float)lightSamplingThreshold.CurrentValue;
RcCore.It.EngineSettings.SampleAllLights = sampleAllLights.CurrentValue;
RcCore.It.EngineSettings.SampleAllLightsIndirect = sampleAllLightsIndirect.CurrentValue;
break;
case GetResult.Option:
continue;
}
break;
}
return(Result.Success);
}
protected override Result RunCommand(Rhino.RhinoDoc doc, RunMode mode)
{
var dirname = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
string[] pathComponent = new string[] { dirname.ToString(), @"common_paper_sizes.json" };
var jsonPath = Path.Combine(pathComponent);
GetPoint gp = new GetPoint();
string text = System.IO.File.ReadAllText(jsonPath);
gp.SetCommandPrompt("Set Origin of Paper Rectangle");
OptionToggle boolOption = new OptionToggle(false, "Off", "On");
gp.AddOptionToggle("Portrait", ref boolOption);
var listNames = new List <string>();
var listValues = new List <Point2d>();
List <Paper> papers = JsonConvert.DeserializeObject <List <Paper> >(text);
//foreach(var paper in papers)
//{
var count = 0;
foreach (var format in papers[0].formats)
{
var num = int.Parse(Regex.Match(format.name, @"\d+").Value);
if (num < 6 && !format.name.Contains("C"))
{
listNames.Add(format.name);
listValues.Add(new Point2d(format.size.mm[0], format.size.mm[1]));
count++;
}
}
//}
var listNamesArr = listNames.ToArray();
int listIndex = 0;
int opList = gp.AddOptionList("PaperType", listNamesArr, listIndex);
while (true)
{
// perform the get operation. This will prompt the user to input a point, but also
// allow for command line options defined above
Rhino.Input.GetResult get_rc = gp.Get();
if (gp.CommandResult() != Rhino.Commands.Result.Success)
{
return(gp.CommandResult());
}
if (get_rc == Rhino.Input.GetResult.Point)
{
var plane = doc.Views.ActiveView.ActiveViewport.GetConstructionPlane().Plane;
plane.Origin = gp.Point();
var item = listValues[listIndex];
var isPortrait = boolOption.CurrentValue;
var rect = new Rectangle3d(plane, isPortrait ? item.X : item.Y, isPortrait ? item.Y : item.X);
var attr = new Rhino.DocObjects.ObjectAttributes();
attr.Name = listNames[listIndex];
attr.LayerIndex = doc.Layers.CurrentLayerIndex;
doc.Objects.AddRectangle(rect, attr);
doc.Views.Redraw();
}
else if (get_rc == Rhino.Input.GetResult.Option)
{
if (gp.OptionIndex() == opList)
{
listIndex = gp.Option().CurrentListOptionIndex;
}
continue;
}
break;
}
return(Rhino.Commands.Result.Success);
}
public IList <PFVertex> PickVertex()
{
var innerVerts = Vertices.Where(x => !x.External);
var pickedVerts = new List <PFVertex>();
var doc = Rhino.RhinoDoc.ActiveDoc;
var vertexConduit = new DrawPFVertexConduit(innerVerts)
{
Enabled = true
};
doc.Views.Redraw();
var gVert = new GetPFVertex(innerVerts);
//var permOption = new OptionToggle(false, "temp", "perm");
gVert.AddSnapPoints(innerVerts.Select(x => x.Point).ToArray());
while (true)
{
gVert.SetCommandPrompt("select Vertex points. (<ESC> to exit");
//gVert.AddOptionToggle("Remember", ref permOption);
gVert.AcceptNothing(true);
gVert.AcceptString(true);
//gVert.SetCursor() // this we can change after switching to Rhino 6 - api
gVert.SetDefaultString($"({pickedVerts.Count}) vertices selected press <Enter> to accept");
gVert.Get(true);
doc.Views.Redraw();
var result = gVert.CommandResult();
var strResult = gVert.StringResult();
pickedVerts = new List <PFVertex>();
if (gVert.CommandResult() == Rhino.Commands.Result.Cancel)
{
break;
}
foreach (var vrt in innerVerts)
{
if (vrt.Picked)
{
pickedVerts.Add(vrt);
}
}
if (gVert.GotDefault())
{
// here use a pick mechanism to get the geometry
if (pickedVerts.Count > 0)
{
var outside = new OptionToggle(true, "true", "false");
var fixPoint = new OptionToggle(false, "constrain", "fix");
var getRefGeo = new GetObject();
getRefGeo.SetCommandPrompt("Pick the constrain object for the selected vertices");
getRefGeo.AddOptionToggle("Outside", ref outside);
getRefGeo.AddOptionToggle("Fixed", ref fixPoint);
getRefGeo.AcceptNothing(true);
getRefGeo.DisablePreSelect();
if (getRefGeo.Get() == Rhino.Input.GetResult.Object)
{
var geoGet = getRefGeo.Object(0);
var idGet = getRefGeo.Object(0).ObjectId;
SetVertexConstraints(pickedVerts, geoGet.Object(), 1, outside.CurrentValue);
}
else if (getRefGeo.Result() == Rhino.Input.GetResult.Nothing)
{
foreach (var vert in pickedVerts)
{
vert.RestrictPosition = null;
vert.RestrictSupport = null;
vert.SupportGuid = Guid.Empty;
}
}
else if (getRefGeo.Result() == Rhino.Input.GetResult.Option && fixPoint.CurrentValue == true)
{
foreach (var vert in pickedVerts)
{
vert.RestrictPosition = vert.ConstrainPoint;
vert.RestrictSupport = new Rhino.Geometry.Point(vert.Point); // this is what keeps the vertex in place
vert.InfluenceCoef = 100; // this is what makes it relatively immovable
vert.SupportGuid = Guid.Empty;
vert.Fixed = true; // this is just for serilization refference
}
}
doc.Objects.UnselectAll();
pickedVerts.ForEach(x => x.Picked = false);
doc.Views.Redraw();
}
else
{
break;
}
}
}
vertexConduit.Enabled = false;
doc.Views.Redraw();
return(pickedVerts);
}
/// <summary>
/// Getter method to load primal/dual from a geometry container from the Rhino Document
/// </summary>
/// <param name="primal">provided primal - need to check if it has data after the method ends</param>
/// <param name="dual">provided primal - just like primal check if it has cells </param>
public static IList <Guid> LoadPrimalDual(out PFoam primal, out PFoam dual, out ContainerType container, bool connect = true)
{
primal = new PFoam();
dual = new PFoam();
container = ContainerType.Edge;
GetObject getObj = new GetObject();
var togGeoUpdate = new OptionToggle(true, "no", "yes");
var togClearConstraints = new OptionToggle(false, "no", "yes");
//var togOptionReplace = new OptionToggle(true, "Keep", "Replace");
getObj.SetCommandPrompt("Pick the geometry container (group of lines, surfaces, polysurfaces or meshes)");
getObj.AddOptionToggle("UpdateGeo", ref togGeoUpdate);
getObj.AddOptionToggle("ClearConstraints", ref togClearConstraints);
//getObj.AddOptionToggle("ReplaceGeo", ref togOptionReplace);
getObj.GroupSelect = true;
getObj.GeometryFilter = Rhino.DocObjects.ObjectType.Brep | Rhino.DocObjects.ObjectType.Curve | Rhino.DocObjects.ObjectType.Mesh;
while (true)
{
var r = getObj.GetMultiple(1, 0);
if (r == GetResult.Cancel)
{
return(new List <Guid>());
}
else if (r == GetResult.Object)
{
break;
}
}
var guids = getObj.Objects().Select(x => x.ObjectId).ToList();
var geoObj = getObj.Objects().Select(x => x.Geometry());
if (geoObj.All(x => x.ObjectType == Rhino.DocObjects.ObjectType.Brep))
{
var brepInput = geoObj.Cast <Brep>().ToList();
if (brepInput.Any(x => x.Faces.Count > 1))
{
container = ContainerType.CellBrep;
}
else
{
container = ContainerType.FaceBrep;
}
primal = LoadData.LoadFromFaces(brepInput, out dual, togGeoUpdate.CurrentValue);
}
else if (geoObj.All(x => x.ObjectType == Rhino.DocObjects.ObjectType.Curve))
{
container = ContainerType.Edge;
var curveGeos = geoObj.Cast <Curve>().ToList();
primal = LoadData.LoadFromEdges(curveGeos, out dual, togGeoUpdate.CurrentValue);
}
else if (geoObj.All(x => x.ObjectType == Rhino.DocObjects.ObjectType.Mesh))
{
var meshGeos = geoObj.Cast <Mesh>().ToList();
if (meshGeos.Any(x => x.Ngons.Count > 1 ||
(x.Ngons.Count == 0 && x.Faces.Count > 1) ||
(x.Ngons.Count == 1 && x.Faces.Count > x.Ngons[0].FaceCount)))
{
container = ContainerType.CellMesh;
}
else
{
container = ContainerType.FaceMesh;
}
primal = LoadData.LoadFromMeshes(meshGeos, out dual, togGeoUpdate.CurrentValue);
}
else
{
Rhino.RhinoApp.WriteLine("Mixed data detected!");
return(new List <Guid>());
}
if (primal.Cells.Count < 1)
{
Rhino.RhinoApp.WriteLine("Error creating primal from provided data!");
return(new List <Guid>());
}
if (connect && dual.Cells.Count > 1 && primal.Dual.Id == dual.Id)
{
Util.ConnectDuals(ref primal, ref dual);
}
if (togClearConstraints.CurrentValue)
{
foreach (var vert in primal.Vertices)
{
vert.RestrictPosition = null;
vert.RestrictSupport = null;
vert.SupportGuid = Guid.Empty;
}
foreach (var edge in primal.Edges)
{
edge.TargetLength = double.NaN;
edge.MaxLength = double.MaxValue;
edge.MinLength = double.Epsilon;
}
foreach (var face in primal.Faces)
{
face.TargetArea = double.NaN;
}
}
Rhino.RhinoDoc.ActiveDoc.Objects.UnselectAll();
Rhino.RhinoDoc.ActiveDoc.Views.Redraw();
return(guids);
}
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
if (!(RhinoApp.GetPlugInObject("Grasshopper") is GH_RhinoScriptInterface Grasshopper))
{
return(Result.Cancel);
}
GetOption go = null;
while (true)
{
var port = new OptionInteger(Port, 1024, 65535);
var toggle = new OptionToggle(ShowEditor, "Hide", "Show");
var debugger = new OptionToggle(Debug, "Off", "On");
go = new GetOption();
go.SetCommandPrompt("Noah Server");
go.AddOption("Connect");
go.AddOption("Stop");
go.AddOption("Observer");
go.AddOptionInteger("Port", ref port);
go.AddOptionToggle("Editor", ref toggle);
go.AddOptionToggle("Debug", ref debugger);
go.AddOption("Workspace");
GetResult result = go.Get();
if (result != GetResult.Option)
{
break;
}
ShowEditor = toggle.CurrentValue;
Debug = debugger.CurrentValue;
string whereToGo = go.Option().EnglishName;
if (whereToGo == "Connect")
{
if (Port == 0)
{
RhinoApp.WriteLine("Please set Port you want to connect!");
continue;
}
if (WorkDir == null)
{
RhinoApp.WriteLine("Noah can not work without workspace!");
continue;
}
if (Client == null)
{
try
{
Grasshopper.DisableBanner();
if (!Grasshopper.IsEditorLoaded())
{
Grasshopper.LoadEditor();
}
Client = new NoahClient(Port, WorkDir);
Client.InfoEvent += Client_MessageEvent;
Client.ErrorEvent += Client_ErrorEvent;
Client.WarningEvent += Client_WarningEvent;
Client.DebugEvent += Client_DebugEvent;
}
catch (Exception ex)
{
RhinoApp.WriteLine("Error: " + ex.Message);
}
Client.Connect();
}
else
{
Client.Reconnect();
}
if (Debug)
{
try
{
if (Logger == null)
{
Panels.OpenPanel(LoggerPanel.PanelId);
}
Logger = Panels.GetPanel <LoggerPanel>(doc);
}
catch (Exception ex)
{
RhinoApp.WriteLine("Error: " + ex.Message);
}
}
if (ShowEditor)
{
Grasshopper.ShowEditor();
}
break;
}
if (whereToGo == "Stop")
{
if (Port == 0)
{
continue;
}
if (Client != null)
{
Client.Close();
}
break;
}
if (whereToGo == "Workspace")
{
RhinoGet.GetString("Noah Workspace", false, ref WorkDir);
}
if (whereToGo == "Observer")
{
if (Port == 0)
{
RhinoApp.WriteLine("Server connecting need a port!");
continue;
}
Process.Start("http://localhost:" + Port + "/data/center");
break;
}
if (whereToGo == "Port")
{
Port = port.CurrentValue;
RhinoApp.WriteLine("Port is set to " + Port.ToString());
continue;
}
}
return(Result.Nothing);
}
