public Parameter Build()
{
string parameterName = _swaggerParameter.Name;
SwaggerParameter unwrappedParameter = _swaggerParameter;
if (_swaggerParameter.Reference != null)
{
unwrappedParameter = Modeler.Unwrap(_swaggerParameter);
}
if (unwrappedParameter.Schema != null && unwrappedParameter.Schema.Reference != null)
{
parameterName = unwrappedParameter.Schema.Reference.StripDefinitionPath();
}
if (parameterName == null)
{
parameterName = unwrappedParameter.Name;
}
IModelType parameterType = BuildServiceType(parameterName);
var parameter = New <Parameter>(new
{
Name = unwrappedParameter.Name,
SerializedName = unwrappedParameter.Name,
ModelType = parameterType,
Location = (Core.Model.ParameterLocation)Enum.Parse(typeof(Core.Model.ParameterLocation), unwrappedParameter.In.ToString())
});
parameter.IsRequired = parameter.IsRequired || parameter.Location == Core.Model.ParameterLocation.Path;
PopulateParameter(parameter, unwrappedParameter);
if (_swaggerParameter.Reference != null)
{
var clientProperty = Modeler.CodeModel.Properties.FirstOrDefault(p => p.SerializedName.Value == unwrappedParameter.Name);
parameter.ClientProperty = clientProperty;
}
return(parameter);
}
public async Task CanRebuildABox()
{
await CreatePartDoc(async (modelDoc, yielder) =>
{
var box = Modeler.CreateBox(Vector3.Zero, Vector3.UnitZ, 0.5, 0.5, 0.5);
var faces = box.GetFaces().CastArray <IFace2>();
var sheets = faces
.Select
(face =>
{
var faceParams = BSplineFace.Create(face)
.TransformSurfaceControlPoints
(ctrlPts => ctrlPts.Select(v => new Vector4(v.X + 2, v.Y, v.Z, v.W)));
return(faceParams.ToSheetBody().__Value__());
})
.ToArray();
using (box.DisplayUndoable(modelDoc)) {
await PauseTestExecution();
};
//foreach (var sheet in sheets)
//{
// yielder(sheet.DisplayUndoable(modelDoc));
//}
var error = (int)swSheetSewingError_e.swSewingOk;
var body = Modeler
.CreateBodiesFromSheets2(sheets, (int)swSheetSewingOption_e.swSewToSolid, 1e-5, ref error)
.CastArray <IBody2>();
body.Should().NotBeEmpty();
yielder(body.DisplayUndoable(modelDoc));
await PauseTestExecution();
});
}
public void ForwardAndBackArcSplineConversionShouldWork()
{
CreatePartDoc(modelDoc =>
{
var trimCurve = (ICurve)Modeler.CreateTrimmedArc
(Vector3.Zero
, Vector3.UnitZ, 10 * Vector3.UnitX
, -10 * Vector3.UnitX
);
var parameters = trimCurve.ToBSpline3D(false);
var swCurve = parameters.ToCurve();
var parameters2 = swCurve.ToBSpline3D(false);
parameters2.Should().Be(parameters);
//#####################################
var d0 = swCurve.CreateWireBody().DisplayUndoable(modelDoc, Color.Blue);
var d1 = trimCurve.CreateWireBody().DisplayUndoable(modelDoc, Color.Red);
return(new CompositeDisposable(d0, d1));
});
}
public async Task GetTrimCurves2ForADiscShouldReturnASingleNonPeriodicClosedTrimCurve()
{
await CreatePartDoc(async (modelDoc, yielder) =>
{
var disc0 = Modeler.CreateCirclularSheet
(center: Vector3.Zero
, vNormal: Vector3.UnitZ
, vRef: Vector3.UnitX
, radius: 2
);
// Display the original sheet. Visually verify it is ok.
// Press "Continue Test Execution" button within solidworks
// to continue the test after visual inspection of the sheet
using (disc0.DisplayUndoable(modelDoc))
await PauseTestExecution(pause: false);
// The sheet should only have one face. Extract it
var faces = disc0.GetFaces().CastArray <IFace2>();
faces.Length.Should().Be(1);
var face = faces[0];
// Convert the solidworks face to a bspline face
var bsplineFace = BSplineFace.Create(face);
bsplineFace.TrimLoops.Count.Should().Be(1);
bsplineFace.TrimLoops[0].Count.Should().Be(1);
// The curve is a clamped closed curve. It is not "Solidworks periodic"
bsplineFace.TrimLoops[0][0].KnotVectorU.Take(3).ShouldBeEquivalentTo(new[] { 0, 0, 0 });
bsplineFace.TrimLoops[0][0].KnotVectorU.TakeLast(3).ShouldBeEquivalentTo(new[] { 1, 1, 1 });
var controlPoints00 = bsplineFace.TrimLoops[0][0].ControlPoints;
controlPoints00.First()
.Should().Be(controlPoints00.Last());
// This is not solidworks periodic so this property should be false
bsplineFace.TrimLoops[0][0].IsClosed.Should().BeTrue();
});
}
public void InterpolateCurveShouldWork()
{
CreatePartDoc(modelDoc =>
{
var points = new[]
{
new Vector3(1.306213E-17, -0.02393888, -0.03204574),
new Vector3(0, 3.469447E-18, 0.04),
new Vector3(0.4619068, 0.03750812, 0.01389752),
new Vector3(0.5, 0.0386182, -0.01042281),
new Vector3(1, 0.03395086, -0.0211504),
new Vector3(1, -0.01454161, 0.03726314),
new Vector3(0.4766606, 0.03750812, 0.01389752),
}
.ToList();
var curve = Modeler.InterpolatePointsToCurve(points, 1e-2, true, false);
var wB = curve.CreateWireBody();
var d = wB.DisplayUndoable(modelDoc, Color.Blue);
return(new CompositeDisposable(d));
});
}
internal static MemoryFileSystem GenerateCodeInto(this string inputFile, MemoryFileSystem fileSystem)
{
fileSystem.Copy(Path.Combine("Resource", inputFile));
var settings = new Settings
{
Modeler = "Swagger",
CodeGenerator = "CSharp",
FileSystem = fileSystem,
OutputDirectory = "GeneratedCode",
Input = inputFile,
};
var codeGenerator = new CSharpCodeGenerator(settings);
Modeler modeler = ExtensionsLoader.GetModeler(settings);
var sc = modeler.Build();
codeGenerator.NormalizeClientModel(sc);
codeGenerator.Generate(sc).GetAwaiter().GetResult();
return(fileSystem);
}
public async Task CanRebuildACirclularSheet()
{
await CreatePartDoc(async (modelDoc, yielder) =>
{
var disc0 = Modeler.CreateCirclularSheet
(center: Vector3.Zero
, vNormal: Vector3.UnitZ
, vRef: Vector3.UnitX
, radius: 2
);
// Display the original sheet. Visually verify it is ok.
// Press "Continue Test Execution" button within solidworks
// to continue the test after visual inspection of the sheet
using (disc0.DisplayUndoable(modelDoc))
await PauseTestExecution();
// The sheet should only have one face. Extract it
var faces = disc0.GetFaces().CastArray <IFace2>();
faces.Length.Should().Be(1);
var face = faces[0];
// Convert the solidworks face to a bspline face
var bsplineFace = BSplineFace.Create(face);
// Convert the bspline face back to a sheet body
var disc1 = bsplineFace.ToSheetBody().__Value__();
// Display the recovered sheet. Visually verify it is ok
// Press "Continue Test Execution" button within solidworks
// to continue the test after visual inspection of the sheet
using (disc1.DisplayUndoable(modelDoc))
await PauseTestExecution();
await PauseTestExecution();
});
}
public void LinspaceForVector3ShouldWork()
{
CreatePartDoc(modelDoc =>
{
var v0 = new Vector3(0, 0, 0);
var v1 = new Vector3(1, 0, 0);
var intV = Sequences.LinSpace(v0, v1, 5).ToList();
var interpolated = intV
.Buffer(2, 1)
.Where(p => p.Count == 2)
.Select(ps =>
{
var edge = new Edge3(ps[0], ps[1]);
var limitedLine = Modeler.CreateTrimmedLine(edge);
var wB = limitedLine.CreateWireBody();
return(wB.DisplayUndoable(modelDoc, Color.Blue));
})
.ToCompositeDisposable();
return(new CompositeDisposable(interpolated));
});
}
public void CanRoundTripAFace()
{
CreatePartDoc((modelDoc, yielder) =>
{
var box = Modeler.CreateBox(Vector3.Zero, Vector3.UnitZ, 0.5, 0.6, 0.7);
var faces = box.GetFaces().CastArray <IFace2>();
var face = faces[0];
var surface1 = ((Surface)face.GetSurface());
var surfaceParams = surface1
.GetBSplineSurfaceParams(1e-5)
.WithCtrlPts(ctrlPts => ctrlPts.Select(v => new Vector4(v.X, v.Y, v.Z, v.W)));
var surface2 = surfaceParams.ToSurface();
var curves = GetCurvesForTrimming(face, c => c);
var trimmedSheet = (IBody2)surface2.CreateTrimmedSheet4(curves, true);
trimmedSheet.Should().NotBe(null);
yielder(box.DisplayUndoable(modelDoc));
yielder(trimmedSheet.DisplayUndoable(modelDoc, Color.Blue));
});
}
/*bool firstRotPoint;
MathPoint startPoint;
MathPoint endPoint;
*/
/// <summary>
/// Constructor
/// </summary>
/// <param name="att">The attachment to be used</param>
/// <param name="swApp">The Solidworks App</param>
public AttachmentPMPage(DirectionalAttachment att, SldWorks swApp)
{
currentAttachment = att;
this.swApp = swApp;
modelDoc = swApp.ActiveDoc;
swModeler = swApp.GetModeler();
SetupPage();
}
public Parameter Build()
{
string parameterName = _swaggerParameter.Name;
SwaggerParameter unwrappedParameter = _swaggerParameter;
if (_swaggerParameter.Reference != null)
{
unwrappedParameter = Modeler.Unwrap(_swaggerParameter);
}
if (unwrappedParameter.Schema != null && unwrappedParameter.Schema.Reference != null)
{
parameterName = unwrappedParameter.Schema.Reference.StripComponentsSchemaPath();
}
if (parameterName == null)
{
parameterName = unwrappedParameter.Name;
}
var isRequired = unwrappedParameter.IsRequired || unwrappedParameter.In == AutoRest.Modeler.Model.ParameterLocation.Path;
unwrappedParameter.IsRequired = isRequired;
if (unwrappedParameter.Extensions.ContainsKey("x-ms-enum") && !unwrappedParameter.Schema.Extensions.ContainsKey("x-ms-enum"))
{
unwrappedParameter.Schema.Extensions["x-ms-enum"] = unwrappedParameter.Extensions["x-ms-enum"];
}
if (unwrappedParameter.Extensions.ContainsKey("x-ms-header-collection-prefix") && unwrappedParameter.Schema.AdditionalProperties == null)
{
unwrappedParameter.Schema.Type = DataType.Object;
unwrappedParameter.Schema.AdditionalProperties = new Schema
{
Type = DataType.String
};
}
IModelType parameterType = BuildServiceType(parameterName, isRequired);
var parameter = New <Parameter>(new
{
Name = unwrappedParameter.Name,
SerializedName = unwrappedParameter.Name,
ModelType = parameterType,
Location = (Core.Model.ParameterLocation)Enum.Parse(typeof(Core.Model.ParameterLocation), unwrappedParameter.In.ToString())
});
// translate allowReserved back to what "code-model-v1"-gen generators expect
if (unwrappedParameter.AllowReserved.HasValue && !parameter.Extensions.ContainsKey("x-ms-skip-url-encoding"))
{
parameter.Extensions["x-ms-skip-url-encoding"] = unwrappedParameter.AllowReserved.Value;
}
PopulateParameter(parameter, unwrappedParameter);
parameter.DeprecationMessage = unwrappedParameter.GetDeprecationMessage(EntityType.Parameter);
if (_swaggerParameter.Reference != null)
{
var clientProperty = Modeler.CodeModel.Properties.FirstOrDefault(p => p.SerializedName == unwrappedParameter.Name);
parameter.ClientProperty = clientProperty;
}
return(parameter);
}
public Parameter Build()
{
string parameterName = _swaggerParameter.Name;
SwaggerParameter unwrappedParameter = _swaggerParameter;
if (_swaggerParameter.Reference != null)
{
unwrappedParameter = Modeler.Unwrap(_swaggerParameter);
}
if (unwrappedParameter.Schema != null && unwrappedParameter.Schema.Reference != null)
{
parameterName = unwrappedParameter.Schema.Reference.StripDefinitionPath();
}
if (parameterName == null)
{
parameterName = unwrappedParameter.Name;
}
IType parameterType = BuildServiceType(parameterName);
var parameter = new Parameter
{
Name = unwrappedParameter.Name,
SerializedName = unwrappedParameter.Name,
Type = parameterType,
IsRequired = unwrappedParameter.IsRequired,
DefaultValue = unwrappedParameter.Default,
Location = (Generator.ClientModel.ParameterLocation)Enum.Parse(typeof(Generator.ClientModel.ParameterLocation), unwrappedParameter.In.ToString())
};
parameter.IsRequired = parameter.IsRequired || parameter.Location == Generator.ClientModel.ParameterLocation.Path;
SetConstraints(parameter.Constraints, unwrappedParameter);
parameter.CollectionFormat = unwrappedParameter.CollectionFormat;
parameter.Documentation = unwrappedParameter.Description;
if (_swaggerParameter.Reference != null)
{
var clientProperty = Modeler.ServiceClient.Properties.First(p => p.Name == unwrappedParameter.Name);
parameter.ClientProperty = clientProperty;
}
var enumType = parameterType as EnumType;
if (enumType != null)
{
if (parameter.Documentation == null)
{
parameter.Documentation = string.Empty;
}
else
{
parameter.Documentation = parameter.Documentation.TrimEnd('.') + ". ";
}
parameter.Documentation += "Possible values for this parameter include: " +
string.Join(", ", enumType.Values.Select(v =>
string.Format(CultureInfo.InvariantCulture,
"'{0}'", v.Name)));
}
unwrappedParameter.Extensions.ForEach(e => parameter.Extensions[e.Key] = e.Value);
return(parameter);
}
protected FieldModel(Modeler modeler, SchemaEntityTypeProperty property, string propertyTypeKeyword, IList <SqlTypeParameter> propertyTypeArguments)
: base(modeler, property, propertyTypeKeyword, propertyTypeArguments)
{
FieldType = typeof(T);
}
protected override void Command()
{
try
{
Body2 CorpsBase = null;
String MateriauCorpsBase = "";
if (MdlBase.eSelect_RecupererTypeObjet() == e_swSelectType.swSelFACES)
{
var face = MdlBase.eSelect_RecupererObjet <Face2>();
CorpsBase = face.GetBody();
}
else if (MdlBase.eSelect_RecupererTypeObjet() == e_swSelectType.swSelSOLIDBODIES)
{
CorpsBase = MdlBase.eSelect_RecupererObjet <Body2>();
}
if (CorpsBase == null)
{
System.Windows.Forms.MessageBox.Show("Erreur de corps selectionné");
return;
}
MateriauCorpsBase = CorpsBase.eGetMateriauCorpsOuPiece(MdlBase.ePartDoc(), MdlBase.eNomConfigActive());
System.Windows.Forms.OpenFileDialog pDialogue = new System.Windows.Forms.OpenFileDialog
{
Filter = "Fichier texte (*.data)|*.data|Tout les fichiers (*.*)|*.*",
Multiselect = false,
InitialDirectory = Path.GetDirectoryName(Path.Combine(MdlBase.GetPathName(), "Pieces", "Corps")),
RestoreDirectory = true
};
String Chemin = "";
if (pDialogue.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
Chemin = pDialogue.FileName;
}
else
{
System.Windows.Forms.MessageBox.Show("Erreur de chemin");
return;
}
Body2 CorpsCharge = null;
String MateriauCorpsCharge = "";
String NoCorps = "";
Byte[] Tab = File.ReadAllBytes(Chemin);
using (MemoryStream ms = new MemoryStream(Tab))
{
ManagedIStream MgIs = new ManagedIStream(ms);
Modeler mdlr = (Modeler)App.Sw.GetModeler();
CorpsCharge = (Body2)mdlr.Restore(MgIs);
}
if (CorpsCharge == null)
{
System.Windows.Forms.MessageBox.Show("Erreur de corps chargé");
return;
}
NoCorps = Path.GetFileNameWithoutExtension(Chemin).Substring(1);
System.Windows.Forms.MessageBox.Show("NoCorps : " + NoCorps);
var cheminNomenclature = Path.Combine(Path.GetDirectoryName(Path.GetDirectoryName(Chemin)), "Nomenclature.txt");
System.Windows.Forms.MessageBox.Show("Chemin Nomenclature : " + cheminNomenclature);
using (var sr = new StreamReader(cheminNomenclature, Encoding.GetEncoding(1252)))
{
// On lit la première ligne contenant l'entête des colonnes
String ligne = sr.ReadLine();
if (ligne.IsRef())
{
while ((ligne = sr.ReadLine()) != null)
{
if (!String.IsNullOrWhiteSpace(ligne))
{
var tab = ligne.Split(new char[] { '\t' });
if (NoCorps == tab[0])
{
MateriauCorpsCharge = tab[4];
break;
}
}
}
}
}
if (String.IsNullOrWhiteSpace(MateriauCorpsCharge))
{
System.Windows.Forms.MessageBox.Show("Erreur de materiau corps chargé");
return;
}
var Result = "Est different";
if (MateriauCorpsCharge == MateriauCorpsBase)
{
Result = "Est semblable";
}
System.Windows.Forms.MessageBox.Show("Materiau : " + MateriauCorpsCharge + " " + MateriauCorpsBase + " " + Result);
Result = "Est different";
if (CorpsBase.eComparerGeometrie(CorpsCharge) == Sw.Comparaison_e.Semblable)
{
Result = "Est semblable";
}
System.Windows.Forms.MessageBox.Show("Corps : " + Result);
}
catch (Exception e)
{
this.LogMethode(new Object[] { e });
}
}
internal void Build(ProcessArgumentBuilder builder)
{
if (InputFile == null)
{
throw new ArgumentNullException(nameof(InputFile));
}
if (Generator != CodeGenerator.None || GeneratorSettings != null)
{
if (GeneratorSettings == null)
{
builder.AppendSwitch(ArgumentNames.Generator, Generator.ToGeneratorName());
}
else
{
builder.AppendSwitch(ArgumentNames.Generator,
Generator == CodeGenerator.None
? GeneratorSettings.Generator.ToGeneratorName()
: Generator.ToGeneratorName());
builder.Append(string.Join(" ",
GeneratorSettings.GetArguments()
.Select(
p =>
$"{(p.Key.StartsWith(ArgumentNames.Separator) ? string.Empty : ArgumentNames.Separator)}{p.Key} {p.Value}")));
}
}
if (Namespace.IsNotEmpty())
{
builder.AppendSwitch(ArgumentNames.Namespace, Namespace.Quote());
}
if (OutputDirectory != null)
{
builder.AppendSwitch(ArgumentNames.OutputDir, OutputDirectory.FullPath.Quote());
}
if (Modeler.IsNotEmpty())
{
builder.AppendSwitch(ArgumentNames.Modeler, Modeler);
}
if (ClientName.IsNotEmpty())
{
builder.AppendSwitch(ArgumentNames.ClientName, ClientName);
}
if (PayloadFlattenThreshold.HasValue)
{
builder.AppendSwitch(ArgumentNames.Threshold, PayloadFlattenThreshold.Value.ToString());
}
if (HeaderComment.IsNotEmpty())
{
builder.AppendSwitch(ArgumentNames.Header, HeaderComment.Quote());
}
if (AddCredentials)
{
builder.AppendSwitch(ArgumentNames.Credentials, "true");
}
if (OutputFileName.IsNotEmpty())
{
builder.AppendSwitch(ArgumentNames.OutputFile, OutputFileName.Quote());
}
if (Verbose)
{
builder.AppendSwitch(ArgumentNames.Verbose, "true");
}
builder.AppendSwitch(ArgumentNames.InputFile, InputFile.FullPath.Quote());
}
void Start () {
game = FindObjectOfType(typeof(Done_GameController)) as Done_GameController;
player = FindObjectOfType(typeof(Player)) as Player;
modeler = FindObjectOfType(typeof(Modeler)) as Modeler;
/*
* Adiquirindo os script para efetuar a modificaçao por "Onda".
*/
velocidadeAsteroide_1 = asteroide1.GetComponent<Done_Mover>();
velocidadeAsteroide_2 = asteroide2.GetComponent<Done_Mover>();
velocidadeAsteroide_3 = asteroide3.GetComponent<Done_Mover>();
velocidadeNaveRoxa = naveRoxa.GetComponent<Done_Mover>();
armasNaveRoxa = naveRoxa.GetComponent<Done_WeaponController>();
evazaoNaveRoxa = naveRoxa.GetComponent<Done_EvasiveManeuver>();
velocidadeNaveVermelha = naveVermelha.GetComponent<Done_Mover> ();
armasNaveVermelha = naveVermelha.GetComponent<Done_WeaponController>();
evazaoNaveVermelha = naveVermelha.GetComponent<Done_EvasiveManeuver>();
/*velocidadeNaveBranca = naveBranca.GetComponent<Done_Mover>();
armasNaveBranca = naveBranca.GetComponent<Done_WeaponController>();
evazaoNaveBranca = naveBranca.GetComponent<Done_EvasiveManeuver>();*/
InitialStatusMobs();
localSpawnWait = game.spawnWait;
}
public ByteFieldModel(Modeler modeler, SchemaEntityTypeProperty property, string propertyTypeKeyword, IList <SqlTypeParameter> propertyTypeArguments) : base(modeler, property, propertyTypeKeyword, propertyTypeArguments)
{
}
