protected void SelectAction(bool isHit, RaycastHit hitInfo)
{
if (isHit == true) {
hitTr = hitInfo.transform;
if (isExtruding == false) {
if (selectionState == SelectionState.Vertex) {
hitPoint = hitTr.GetComponent<Point>();
if (hitPoint != null) {
hitPoint.SetPointEnabled(true);
}
}
if (selectionState == SelectionState.Face) {
hitPrimitiveObject = hitTr.GetComponent<PrimitiveObject>();
if (hitPrimitiveObject != null && hitPrimitiveObject.IsSelected == false) {
hitPrimitiveObject.SetColor(Color.red);
}
} else if (selectionState == SelectionState.Object) {
hitPrimitiveObject = hitTr.GetComponent<PrimitiveObject>();
if (hitPrimitiveObject != null && hitPrimitiveObject.IsSelected == false) {
hitPrimitiveObject.GetCompound().SetColor(Color.red);
}
}
}
}
}
//used to make a pick collidable primitives from an existing PrimitiveObject (i.e. the type returned by the PrimitiveFactory
public PickupCollidablePrimitiveObject(PrimitiveObject primitiveObject, ICollisionPrimitive collisionPrimitive,
ObjectManager objectManager, PickupParameters pickupParameters, EventDispatcher eventDispatcher)
: base(primitiveObject, collisionPrimitive, objectManager, eventDispatcher)
{
this.eventDispatcher = eventDispatcher;
this.pickupParameters = pickupParameters;
}
public void GetObject(PrimitiveObject pro)
{
int i = CurrObj;
for (int ii = 0; ii < TypesAndFields.Count; ii++)
{
Type type = IdentityType.Instance[TypesAndFields[ii][0]];
string name = TypesAndFields[ii][1];
NGISpread currspread = Spreads[name];
currspread.SliceCount = FInput.SliceCount;
NGISpread currvalues = (NGISpread)currspread[i];
if (pro.Fields.ContainsKey(name))
{
List <object> objl = pro[name];
currvalues.SliceCount = objl.Count;
for (int j = 0; j < currvalues.SliceCount; j++)
{
currvalues[j] = objl[j];
}
}
else
{
currvalues.SliceCount = 0;
}
}
}
public void SetObject(PrimitiveObject pro)
{
int i = CurrObj;
for (int ii = 0; ii < Spreads.Count; ii++)
{
string name = TypesAndFields[ii][1];
NGISpread currspread = (NGISpread)Spreads[name][i];
List <object> objl = pro[name];
if (currspread.SliceCount != objl.Count)
{
objl.Clear();
for (int j = 0; j < currspread.SliceCount; j++)
{
objl.Add(currspread[j]);
}
}
else
{
for (int j = 0; j < currspread.SliceCount; j++)
{
objl[j] = currspread[j];
}
}
}
}
public ChildObject()
{
_Title = TestRandomizer.GetString();
_Private = new PrimitiveObject();
Public = new PrimitiveObject();
_Null = null;
}
public void ExtrudeFace(PrimitiveObject face, float magnitude, bool isContinous)
{
Vector3 normal = face.GetNormal;
Vector3 normEps = normal * eps;
Vector3[] verticesFace = face.PrimMeshFilter.mesh.vertices;
int[] indiceSequence = new int[] { 0, 1, 3, 2, 0 };
if (extrFacesList == null)
{
extrFacesList = new List <PrimitiveObject>();
face.initPos = face.transform.position;
for (int i = 0; i < verticesFace.Length; i++)
{
Vector3[] vs1 = new Vector3[4] {
verticesFace[indiceSequence[i]] - normEps,
verticesFace[indiceSequence[i + 1]] - normEps,
verticesFace[indiceSequence[i]] + normEps,
verticesFace[indiceSequence[i + 1]] + normEps
};
PrimitiveObject newPo = PrimitiveObject.MakeRectangle(transform, vs1, (face.transform.position + face.initPos) * 0.5f + (verticesFace[indiceSequence[i]] + verticesFace[indiceSequence[i + 1]]) * 0.5f, true);
primObjectList.Add(newPo);
extrFacesList.Add(newPo);
}
}
if (extrFacesList != null)
{
face.MoveFaceTowardsNormal(magnitude, isContinous);
for (int i = 0; i < extrFacesList.Count; i++)
{
PrimitiveObject extrPo = extrFacesList[i];
extrPo.transform.position = (face.transform.position + face.initPos) * 0.5f + (verticesFace[indiceSequence[i]] + verticesFace[indiceSequence[i + 1]]) * 0.5f;
Vector3[] vertices = extrPo.PrimMeshFilter.mesh.vertices;
vertices[0] = face.initPos + verticesFace[indiceSequence[i]] - extrPo.transform.position - normEps;
vertices[1] = face.initPos + verticesFace[indiceSequence[i + 1]] - extrPo.transform.position - normEps;
vertices[2] = face.transform.position + verticesFace[indiceSequence[i]] - extrPo.transform.position + normEps;
vertices[3] = face.transform.position + verticesFace[indiceSequence[i + 1]] - extrPo.transform.position + normEps;
extrPo.PrimMeshFilter.mesh.vertices = vertices;
extrPo.PrimMeshFilter.mesh.RecalculateBounds();
for (int j = 0; j < vertices.Length; j++)
{
extrPo.PointList[j].transform.position = vertices[j] + extrPo.transform.position;
}
MeshCollider col = extrPo.GetComponent <MeshCollider>();
col.sharedMesh = extrPo.PrimMeshFilter.mesh;
}
}
}
public void CreateArray(int num)
{
objectArray = new PrimitiveObject[num];
for (int i = 0; i < num; i++)
{
objectArray[i] = new PrimitiveObject(i, i.ToString(), (float)i, i % 2 == 0 ? true : false);
}
}
private void ComparePrimitiveObject(PrimitiveObject oa, PrimitiveObject ob)
{
Assert.AreEqual(oa.Int, ob.Int);
Assert.AreEqual(oa.Long, ob.Long);
Assert.AreEqual(oa.Short, ob.Short);
Assert.AreEqual(oa.Bool, ob.Bool);
Assert.AreEqual(oa.String, ob.String);
}
public void TestSerializeFlat()
{
PrimitiveObject oo = new PrimitiveObject();
string xml = xstream.ToXml(oo);
PrimitiveObject ob = xstream.FromXml(xml) as PrimitiveObject;
Assert.IsNotNull(ob);
ComparePrimitiveObject(oo, ob);
}
public void SetColor(Color c)
{
for (int i = 0; i < primObjectList.Count; i++)
{
PrimitiveObject po = primObjectList[i];
po.SetColor(c);
}
}
public void RestoreColor()
{
for (int i = 0; i < primObjectList.Count; i++)
{
PrimitiveObject po = primObjectList[i];
po.RestoreColor();
}
}
public void spawnCylinder()
{
PrimitiveObject myCylinder = myObjFactory.getObject("Cylinder");
if (myObject)
{
dropObject();
}
myObject = myCylinder.getPrimitiveObj();
}
//// Spawn new primitive objects with preset properties and place in hand \\\\
public void spawnCube()
{
PrimitiveObject myCube = myObjFactory.getObject("Cube");
if (myObject)
{
dropObject();
}
myObject = myCube.getPrimitiveObj();
}
public void spawnSphere()
{
PrimitiveObject mySphere = myObjFactory.getObject("Sphere");
if (myObject)
{
dropObject();
}
myObject = mySphere.getPrimitiveObj();
}
public void spawnCapsule()
{
PrimitiveObject myCapsule = myObjFactory.getObject("Capsule");
if (myObject)
{
dropObject();
}
myObject = myCapsule.getPrimitiveObj();
}
public void SelectAll(bool select)
{
IsSelected = select;
for (int i = 0; i < primObjectList.Count; i++)
{
PrimitiveObject po = primObjectList[i];
po.IsSelected = select;
}
}
public void UpdateUniformlyCompoundbject(float magnitude)
{
float magnScale = 2f;
Magnitute = primObjectList[0].Magnitute;
for (int i = 0; i < primObjectList.Count; i++)
{
PrimitiveObject po = primObjectList[i];
po.UpdateUniformlyPrimitiveObject(magnScale * magnitude, initialShape == InitialShape.Cube);
}
}
public static PrimitiveObject MakeQuad(Transform parent, float size, Vector3 pos, QuadOrientation qo = QuadOrientation.up, bool hasCollider = true)
{
float halfSize = 0.5f * size;
Vector3[] vertices = new Vector3[4];
if (qo == QuadOrientation.up)
{
vertices[0] = new Vector3(-halfSize, 0, -halfSize);
vertices[1] = new Vector3(halfSize, 0, -halfSize);
vertices[2] = new Vector3(-halfSize, 0, halfSize);
vertices[3] = new Vector3(halfSize, 0, halfSize);
}
else if (qo == QuadOrientation.down)
{
vertices[0] = new Vector3(-halfSize, 0, -halfSize);
vertices[1] = new Vector3(-halfSize, 0, halfSize);
vertices[2] = new Vector3(halfSize, 0, -halfSize);
vertices[3] = new Vector3(halfSize, 0, halfSize);
}
else if (qo == QuadOrientation.left)
{
vertices[0] = new Vector3(0, -halfSize, -halfSize);
vertices[1] = new Vector3(0, halfSize, -halfSize);
vertices[2] = new Vector3(0, -halfSize, halfSize);
vertices[3] = new Vector3(0, halfSize, halfSize);
}
else if (qo == QuadOrientation.right)
{
vertices[0] = new Vector3(0, -halfSize, -halfSize);
vertices[1] = new Vector3(0, -halfSize, halfSize);
vertices[2] = new Vector3(0, halfSize, -halfSize);
vertices[3] = new Vector3(0, halfSize, halfSize);
}
else if (qo == QuadOrientation.front)
{
vertices[0] = new Vector3(-halfSize, -halfSize, 0);
vertices[1] = new Vector3(-halfSize, halfSize, 0);
vertices[2] = new Vector3(halfSize, -halfSize, 0);
vertices[3] = new Vector3(halfSize, halfSize, 0);
}
else if (qo == QuadOrientation.back)
{
vertices[0] = new Vector3(-halfSize, -halfSize, 0);
vertices[1] = new Vector3(halfSize, -halfSize, 0);
vertices[2] = new Vector3(-halfSize, halfSize, 0);
vertices[3] = new Vector3(halfSize, halfSize, 0);
}
PrimitiveObject po = MakeRectangle(parent, vertices, pos, hasCollider);
return(po);
}
public static PrimitiveObject MakeZStripe(Transform parent, float length, float width, Vector3 pos, bool hasCollider)
{
Vector3[] lineVertices = new Vector3[4];
lineVertices[0] = new Vector3(-width, 0, -length);
lineVertices[1] = new Vector3(-width, 0, length);
lineVertices[2] = new Vector3(width, 0, -length);
lineVertices[3] = new Vector3(width, 0, length);
PrimitiveObject po = MakeRectangle(parent, lineVertices, pos, hasCollider);
po.SetPointsActive(false);
return(po);
}
private void Start()
{
//CompoundObject.MakeCube(ModelParent, 2f);
Transform gridTr = GameObject.Find("Grid").transform;
float stripeWidth = 0.01f;
int numOfStripes = 20;
float stripeLength = numOfStripes * 0.5f;
for (int i = 0; i < numOfStripes; i++) {
PrimitiveObject.MakeXStripe(gridTr, stripeLength, stripeWidth, new Vector3(0, 0, i - 0.5f * numOfStripes), false);
PrimitiveObject po = PrimitiveObject.MakeXStripe(gridTr, stripeLength, stripeWidth, new Vector3(i - 0.5f * numOfStripes, 0, 0), false);
po.transform.Rotate(Vector3.up, 90f);
}
}
public override void OnEval()
{
this.SetSliceCount();
if (FAutoClear[0])
{
bool clear = false;
for (int i = 0; i < this.SliceCount; i++)
{
if (FConstruct[i])
{
clear = true;
}
}
if (clear)
{
fc = 0;
}
}
if (fc == 0)
{
FOutput.SliceCount = 0;
}
fc++;
bool empty = FOutput.SliceCount == 0;
for (int i = 0; i < this.SliceCount; i++)
{
this.CurrObj = i;
if (FConstruct[i] || (FSet[i] && empty))
{
PrimitiveObject ro = ConstructObject();
if (ro != null)
{
FOutput.Add(ro);
}
}
}
for (int i = 0; i < FOutput.SliceCount; i++)
{
this.CurrObj = i;
if (FSet[i])
{
SetObject(FOutput[i] as PrimitiveObject);
}
}
}
internal static void SelectReleaseFromAvailableBundles()
{
Logger.Log(String.Format(CultureInfo.InvariantCulture, "Select command started."), Logger.MessageLevel.Verbose, AppName);
MsgRelease = PrimitiveObject.GetReleases;
Console.WriteLine(PrintReleaseInfo());
Console.WriteLine("Select which releases you would like to target for uninstall. No action will be taken yet. This is only selection.\r\n");
Console.Write("Use a comma separated list if you want to target multiple releases. For a bundle to be uninstalled, it must be installed and in the package cache. ");
Console.Write("You can choose to uninstall a release you no longer have installed, but only MSIs associated will be uninstalled. The bundle uninstall will not be available.\r\n");
Console.WriteLine("i.e. 1, 2, 14, 8");
Console.Write("> ");
var userselect = Console.ReadLine();
PrimitiveObject.SelectedReleases(userselect);
PrimitiveObject.ReleaseOutput = PrimitiveObject.GetReleases;
Logger.Log(String.Format(CultureInfo.InvariantCulture, "Select command ended."), Logger.MessageLevel.Verbose, AppName);
}
public void SetObject(PrimitiveObject pro)
{
int i = CurrObj;
for (int ii = 0; ii < Spreads.Count; ii++)
{
Type type = IdentityType.Instance[TypesAndFields[ii][0]];
string name = TypesAndFields[ii][1];
NGISpread currspread = (NGISpread)Spreads[name][i];
if (pro.Fields.ContainsKey(name))
{
List <object> objl = pro[name];
if (currspread.SliceCount != objl.Count)
{
objl.Clear();
for (int j = 0; j < currspread.SliceCount; j++)
{
objl.Add(currspread[j]);
}
}
else
{
for (int j = 0; j < currspread.SliceCount; j++)
{
objl[j] = currspread[j];
}
}
}
else
{
if (FNotExist[0] == ManageNotExisting.Create)
{
List <object> objl = new List <object>();
for (int j = 0; j < currspread.SliceCount; j++)
{
objl.Add(currspread[j]);
}
pro.Add(name, objl);
}
}
}
}
static internal void SetupPrimitivesValues(bool debug, bool donotprocess)
{
// uti.bDebug = op.Debug; ip.DebugReporting = op.Debug;
PrimitiveObject.MachineArchitectureConfiguration = SystemSettings.Is64() ? ArchitectureConfiguration.x64 : ArchitectureConfiguration.x86;
PrimitiveObject.MachineOSVersion = SystemSettings.Version();
PrimitiveObject.Filters.Clear();
PrimitiveObject.UninstallActions.Clear();
VisualStudioSpecific.VSFilters(PrimitiveObject);
VisualStudioSpecific.VSUninstallActions(PrimitiveObject);
PrimitiveObject.DataFilesPath = path;
PrimitiveObject.DoNotExecuteProcess = donotprocess;
PrimitiveObject.DebugReporting = debug;
//Initialize
PrimitiveObject.Initialize();
}
public static CompoundObject MakeQuad(Transform parent, float size, string name = "")
{
GameObject go = new GameObject("Quad");
if (name != "")
{
go.name = name;
}
go.transform.SetParent(parent);
go.AddComponent <CompoundObject>();
CompoundObject co = go.GetComponent <CompoundObject>();
co.initialShape = InitialShape.Quad;
co.primObjectList.Add(PrimitiveObject.MakeQuad(go.transform, size, new Vector3(0, 0, 0), PrimitiveObject.QuadOrientation.up));
co.primObjectList.Add(PrimitiveObject.MakeQuad(go.transform, size, new Vector3(0, 0, 0), PrimitiveObject.QuadOrientation.down));
return(co);
}
protected void RestoreSelectionAction()
{
if (selectionState == SelectionState.Vertex) {
if (hitPoint != null) {
hitPoint.SetPointEnabled(false);
}
}
if (selectionState == SelectionState.Face) {
if (hitPrimitiveObject != null && hitPrimitiveObject.IsSelected == false) {
hitPrimitiveObject.RestoreColor();
}
} else if (selectionState == SelectionState.Object) {
if (hitPrimitiveObject != null && hitPrimitiveObject.GetCompound().IsSelected == false) {
hitPrimitiveObject.GetCompound().RestoreColor();
}
}
hitTr = null;
hitPrimitiveObject = null;
hitPoint = null;
}
public PrimitiveObject ConstructObject()
{
int i = CurrObj;
PrimitiveObject pro = new PrimitiveObject();
for (int ii = 0; ii < Spreads.Count; ii++)
{
List <object> objl = new List <object>();
string type = TypesAndFields[ii][0];
string name = TypesAndFields[ii][1];
NGISpread currspread = (NGISpread)Spreads[name][i];
objl.Clear();
for (int j = 0; j < currspread.SliceCount; j++)
{
objl.Add(currspread[j]);
}
pro.Fields.Add(TypesAndFields[ii][1], objl);
}
return(pro);
}
protected ModelerState SelectionActions(ModelerState modelerState)
{
if (Input.GetMouseButtonDown(0)) {
if (EventSystem.current.IsPointerOverGameObject() == false) {
if (selectedPrimitiveObject != null) {
selectedPrimitiveObject.GetCompound().SelectAll(false);
selectedPrimitiveObject = null;
}
}
switch (selectionState) {
case SelectionState.Object:
if (hitPrimitiveObject != null) {
if (selectedPrimitiveObject != null) {
selectedPrimitiveObject.GetCompound().SelectAll(false);
}
selectedPrimitiveObject = hitTr.GetComponent<PrimitiveObject>();
selectedPrimitiveObject.GetCompound().SelectAll(true);
}
break;
case SelectionState.Face:
if (hitPrimitiveObject != null) {
if (selectedPrimitiveObject != null) {
selectedPrimitiveObject.IsSelected = false;
}
selectedPrimitiveObject = hitTr.GetComponent<PrimitiveObject>();
selectedPrimitiveObject.IsSelected = true;
}
break;
case SelectionState.Edge:
break;
case SelectionState.Vertex:
break;
default:
break;
}
}
return modelerState;
}
static internal void SetupPrimitivesValues(bool debug, bool donotprocess)
{
// uti.bDebug = op.Debug; ip.DebugReporting = op.Debug;
PrimitiveObject.MachineArchitectureConfiguration = SystemSettings.Is64() ? ArchitectureConfiguration.x64 : ArchitectureConfiguration.x86;
PrimitiveObject.MachineOSVersion = SystemSettings.Version();
PrimitiveObject.Filters.Clear();
PrimitiveObject.UninstallActions.Clear();
VisualStudioSpecific.VSFilters(PrimitiveObject);
VisualStudioSpecific.VSUninstallActions(PrimitiveObject);
PrimitiveObject.DataFilesPath = path;
PrimitiveObject.DoNotExecuteProcess = donotprocess;
PrimitiveObject.DebugReporting = debug;
//Initialize
Console.WriteLine(Logger.Log("Set filters in Primitives object", Logger.MessageLevel.Information, AppName));
Console.WriteLine(Logger.Log("Initializing configuration... Please wait.", Logger.MessageLevel.Information, AppName));
Console.WriteLine(Logger.Log("-----------------------------------------------------------------------", Logger.MessageLevel.Information, AppName));
PrimitiveObject.Initialize();
Console.WriteLine(Logger.Log("Calling GetUsage for dialog prompt.", Logger.MessageLevel.Information, AppName));
Console.Clear();
}
public void Evaluate(int SpreadMax)
{
if (FInput.IsConnected)
{
FType.SliceCount = FInput.SliceCount;
FChildren.SliceCount = FInput.SliceCount;
for (int i = 0; i < FInput.SliceCount; i++)
{
if (FInput[i] is PrimitiveObject)
{
PrimitiveObject pro = FInput[i] as PrimitiveObject;
FChildren[i].SliceCount = pro.Fields.Count;
FType[i].SliceCount = pro.Fields.Count;
List <List <object> > otpl = pro.Fields.Values.ToList();
List <string> names = pro.Fields.Keys.ToList();
for (int j = 0; j < pro.Fields.Count; j++)
{
FChildren[i][j] = names[j];
FType[i][j] = otpl[j][0].GetType().ToString();
}
}
else
{
FChildren[i].SliceCount = 0;
FType[i].SliceCount = 0;
}
}
}
else
{
FType.SliceCount = 0;
FChildren.SliceCount = 0;
}
}