private void UpdateForAxisAlignedCube(Vector3 wpos)
{
reticleCubical.EnableRenderer(true);
reticleCubical.SetPositionAndSize(wpos, Vector3.one * BrushSize);
if (clicking && Terrain.OperationsManager.IsReadyToComputeAsync)
{
Terrain.OperationsManager
.Add(AxisAlignedCube.CreateFromUnityWorld(Terrain, dig, wpos, BrushSize * Vector3.one, voxelType), true)
.PerformAll(asyncOperations);
}
}
public void CopyCurrentAxisAlignedCubes()
{
foreach (AxisAlignedCube cube in CurrentShapeCollection.AxisAlignedCubes)
{
AxisAlignedCube newCube = cube.Clone <AxisAlignedCube>();
ShapeManager.AddAxisAlignedCube(newCube);
EditorData.ShapeCollection.AxisAlignedCubes.Add(newCube);
FlatRedBall.Utilities.StringFunctions.MakeNameUnique <AxisAlignedCube>(newCube, EditorData.AxisAlignedCubes);
}
}
public void SelectAxisAlignedCube(AxisAlignedCube axisAlignedCube)
{
CurrentShapeCollection.AxisAlignedCubes.Clear();
GuiData.ShapeCollectionPropertyGrid.CurrentAxisAlignedCube = axisAlignedCube;
if (axisAlignedCube != null)
{
bool isNewWindow;
PropertyGrid propertyGrid = (PropertyGrid)GuiManager.ObjectDisplayManager.GetObjectDisplayerForObject(axisAlignedCube, GuiData.ShapeCollectionPropertyGrid, null, out isNewWindow);
if (isNewWindow)
{
propertyGrid.SetMemberChangeEvent("Name", GuiData.MakeAxisAlignedCubeNameUnique);
}
CurrentShapeCollection.AxisAlignedCubes.Add(axisAlignedCube);
SelectPolygon(null);
SelectCircle(null);
SelectAxisAlignedRectangle(null);
SelectSphere(null);
}
}
public void AddAxisAlignedCube()
{
AxisAlignedCube cube = new AxisAlignedCube();
ShapeManager.AddAxisAlignedCube(cube);
cube.Color = EditorProperties.AxisAlignedCubeColor;
cube.X = SpriteManager.Camera.X;
cube.Y = SpriteManager.Camera.Y;
float scale = (float)Math.Abs(
18 / SpriteManager.Camera.PixelsPerUnitAt(0));
cube.ScaleX = scale;
cube.ScaleY = scale;
cube.ScaleZ = scale;
EditorData.ShapeCollection.AxisAlignedCubes.Add(cube);
cube.Name = "Cube" + EditorData.AxisAlignedCubes.Count;
StringFunctions.MakeNameUnique <AxisAlignedCube>(cube, EditorData.AxisAlignedCubes);
}
public void Remove(AxisAlignedCube cube)
{
this.mCubes.Remove(cube);
cube.mLayerBelongingTo = null;
}
public static void MakeAxisAlignedCubeNameUnique(Window callingWindow)
{
AxisAlignedCube cube = ((PropertyGrid <AxisAlignedCube>)callingWindow.Parent).SelectedObject;
StringFunctions.MakeNameUnique <AxisAlignedCube>(cube, EditorData.ShapeCollection.AxisAlignedCubes);
}
private void Update()
{
if (Terrain.IsLoaded == true)
{
float yRot = Input.GetAxis("Mouse X");
float xRot = Input.GetAxis("Mouse Y");
float xInput = Input.GetAxisRaw("Horizontal");
float zInput = Input.GetAxisRaw("Vertical");
Vector3 xMovement = transform.right * xInput;
Vector3 yMovement = transform.forward * zInput;
Vector3 Rotation = new Vector3(0, yRot, 0) * LookSpeed;
Vector3 CameraRotation = new Vector3(-xRot, 0, 0) * LookSpeed;
Vector3 Movement = (xMovement + yMovement).normalized * Speed;
if (Controller.isGrounded != true)
{
GravityVelocity.y -= GravitationalConstant * Time.deltaTime;
}
else if (Jumped == true)
{
GravityVelocity.y += JumpHeight;
Jumped = false;
}
else
{
GravityVelocity.y = -1f;
}
UImanager.Debugtext2.text = "VerticalVelocity: " + GravityVelocity.y.ToString();
Rotate(Rotation, CameraRotation);
Move(Movement, GravityVelocity);
}
if (Controller.isGrounded == true)
{
UImanager.DebugText1.text = "Grounded: True";
if (Input.GetKeyDown(KeyCode.Space))
{
Jump();
}
}
else
{
UImanager.DebugText1.text = "Grounded: False";
}
if (Input.GetKey(KeyCode.LeftShift))
{
Speed = RunSpeed;
}
if (Input.GetKeyUp(KeyCode.LeftShift))
{
Speed = WalkSpeed;
}
if (Input.GetMouseButtonDown(0))
{
Debug.Log("Button Clicked");
RaycastHit Hit;
Ray Ray = Camera.ScreenPointToRay(Input.mousePosition);
Physics.Raycast(Ray, out Hit, 5f, Terrain.Params.ChunkLayerMask);
var Position = Hit.point + Hit.normal * 0.01f;
Vector3 Size = new Vector3(1, 1, 1);
if (Terrain.OperationsManager.IsReadyToComputeAsync)
{
Debug.Log("Added Operation");
Terrain.OperationsManager.Add(AxisAlignedCube.CreateFromUnityWorld(Terrain, true, Position, Size, type), true).PerformAll(true);
}
}
if (Input.GetMouseButtonDown(1))
{
Debug.Log("Button Clicked");
RaycastHit Hit;
Ray Ray = Camera.ScreenPointToRay(Input.mousePosition);
Physics.Raycast(Ray, out Hit, 5f, Terrain.Params.ChunkLayerMask);
var Position = Hit.point + Hit.normal * 0.01f;
Vector3 Size = new Vector3(1, 1, 1);
if (Terrain.OperationsManager.IsReadyToComputeAsync)
{
Debug.Log("Added Operation");
Terrain.OperationsManager.Add(AxisAlignedCube.CreateFromUnityWorld(Terrain, false, Position, Size, type), true).PerformAll(true);
}
}
}
/// <summary>
/// Creates a runtime object and adds the LoadedFile to the element.
/// </summary>
/// <param name="objectToLoad"></param>
/// <param name="container"></param>
/// <param name="elementRuntime"></param>
/// <param name="objectType"></param>
/// <param name="objectJustLoaded"></param>
/// <param name="newElementRuntime"></param>
/// <param name="toAddTo"></param>
/// <param name="layerToAddTo"></param>
/// <param name="rfs"></param>
/// <param name="pullsFromEntireNamedObject"></param>
/// <returns></returns>
private static LoadedFile CreateRuntimeObjectForNamedObject(NamedObjectSave objectToLoad,
IElement container, ElementRuntime elementRuntime, string objectType,
LoadedFile objectJustLoaded,
ElementRuntime newElementRuntime,
object toAddTo,
Layer layerToAddTo, ReferencedFileSave rfs, bool pullsFromEntireNamedObject)
{
var fileName = ElementRuntime.ContentDirectory + objectToLoad.SourceFile;
bool shouldClone = rfs != null && (rfs.IsSharedStatic && !(container is ScreenSave)) && !pullsFromEntireNamedObject;
LoadedFile toReturn = null;
// This could have a ( in the name in a file like .scnx, so use the last (
//int indexOfType = objectToLoad.SourceName.IndexOf("(");
int indexOfType = objectToLoad.SourceName.LastIndexOf("(");
string objectName = objectToLoad.SourceName.Substring(0, indexOfType - 1);
switch (objectType)
{
case "Scene":
{
Scene scene = objectJustLoaded.RuntimeObject as Scene;
foreach (Text text in scene.Texts)
{
text.AdjustPositionForPixelPerfectDrawing = true;
if (ObjectFinder.Self.GlueProject.UsesTranslation)
{
text.DisplayText = LocalizationManager.Translate(text.DisplayText);
}
}
if (shouldClone)
{
scene = scene.Clone();
elementRuntime.EntireScenes.Add(objectToLoad.SourceFile, scene);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = scene;
loadedFile.FilePath = objectToLoad.SourceFile;
loadedFile.ReferencedFileSave = rfs;
toReturn = loadedFile;
newElementRuntime.ReferencedFileRuntimeList.Add(loadedFile);
scene.AddToManagers(layerToAddTo);
}
}
break;
case "Sprite":
{
Sprite loadedSprite = null;
Scene scene = objectJustLoaded.RuntimeObject as Scene;
if (scene != null)
{
loadedSprite = scene.Sprites.FindByName(objectName);
}
if (loadedSprite == null)
{
System.Windows.Forms.MessageBox.Show("There is a missing Sprite called\n\n" + objectName + "\n\n" +
"in the object\n\n" + elementRuntime.Name + "\n\n" +
"This probably happened if someone changed the name of a Sprite in a .scnx file but didn't update " +
"the associated object in Glue", "Missing Sprite");
}
else
{
if (shouldClone)
{
loadedSprite = loadedSprite.Clone();
(toAddTo as Scene).Sprites.Add(loadedSprite);
SpriteManager.AddToLayer(loadedSprite, layerToAddTo);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = loadedSprite;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
}
break;
case "SpriteFrame":
{
Scene scene = objectJustLoaded.RuntimeObject as Scene;
SpriteFrame loadedSpriteFrame = scene.SpriteFrames.FindByName(objectName);
if (loadedSpriteFrame != null)
{
if (shouldClone)
{
loadedSpriteFrame = loadedSpriteFrame.Clone();
(toAddTo as Scene).SpriteFrames.Add(loadedSpriteFrame);
SpriteManager.AddToLayer(loadedSpriteFrame, layerToAddTo);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = loadedSpriteFrame;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
}
break;
case "SpriteGrid":
{
Scene scene = objectJustLoaded.RuntimeObject as Scene;
SpriteGrid spriteGrid = null;
for (int i = 0; i < scene.SpriteGrids.Count; i++)
{
if (scene.SpriteGrids[i].Name == objectName)
{
spriteGrid = scene.SpriteGrids[i];
break;
}
}
if (spriteGrid != null)
{
if (shouldClone)
{
spriteGrid = spriteGrid.Clone();
(toAddTo as Scene).SpriteGrids.Add(spriteGrid);
spriteGrid.Layer = layerToAddTo;
spriteGrid.PopulateGrid();
spriteGrid.RefreshPaint();
spriteGrid.Manage();
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = spriteGrid;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
}
break;
case "Text":
{
Scene scene = objectJustLoaded.RuntimeObject as Scene;
Text loadedText = scene.Texts.FindByName(objectName);
if (loadedText != null)
{
if (shouldClone)
{
loadedText = loadedText.Clone();
(toAddTo as Scene).Texts.Add(loadedText);
TextManager.AddToLayer(loadedText, layerToAddTo);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = loadedText;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
loadedText.AdjustPositionForPixelPerfectDrawing = true;
if (LocalizationManager.HasDatabase)
{
loadedText.DisplayText = LocalizationManager.Translate(loadedText.DisplayText);
}
}
}
break;
case "ShapeCollection":
{
ShapeCollection shapeCollection = objectJustLoaded.RuntimeObject as ShapeCollection;
if (shouldClone)
{
shapeCollection = shapeCollection.Clone();
elementRuntime.EntireShapeCollections.Add(objectToLoad.SourceFile, shapeCollection);
newElementRuntime.ReferencedFileRuntimeList.LoadedShapeCollections.Add(shapeCollection);
shapeCollection.AddToManagers(layerToAddTo);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = shapeCollection;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
// Most cases are handled below in an AttachTo method, but
// ShapeCollection isn't a PositionedObject so we have to do it manually here
if (objectToLoad.AttachToContainer)
{
shapeCollection.AttachTo(elementRuntime, true);
}
}
break;
case "AxisAlignedCube":
{
ShapeCollection shapeCollection = objectJustLoaded.RuntimeObject as ShapeCollection;
AxisAlignedCube loadedAxisAlignedCube = shapeCollection.AxisAlignedCubes.FindByName(objectName);
if (shouldClone)
{
loadedAxisAlignedCube = loadedAxisAlignedCube.Clone();
(toAddTo as ShapeCollection).AxisAlignedCubes.Add(loadedAxisAlignedCube);
ShapeManager.AddToLayer(loadedAxisAlignedCube, layerToAddTo);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = loadedAxisAlignedCube;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
break;
case "AxisAlignedRectangle":
{
ShapeCollection shapeCollection = objectJustLoaded.RuntimeObject as ShapeCollection;
AxisAlignedRectangle loadedAxisAlignedRectangle = shapeCollection.AxisAlignedRectangles.FindByName(objectName);
if (shouldClone)
{
loadedAxisAlignedRectangle = loadedAxisAlignedRectangle.Clone();
(toAddTo as ShapeCollection).AxisAlignedRectangles.Add(loadedAxisAlignedRectangle);
ShapeManager.AddToLayer(loadedAxisAlignedRectangle, layerToAddTo);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = loadedAxisAlignedRectangle;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
break;
case "Circle":
{
ShapeCollection shapeCollection = objectJustLoaded.RuntimeObject as ShapeCollection;
Circle loadedCircle = shapeCollection.Circles.FindByName(objectName);
if (shouldClone)
{
loadedCircle = loadedCircle.Clone();
(toAddTo as ShapeCollection).Circles.Add(loadedCircle);
ShapeManager.AddToLayer(loadedCircle, layerToAddTo);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = loadedCircle;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
break;
case "Polygon":
{
ShapeCollection shapeCollection = objectJustLoaded.RuntimeObject as ShapeCollection;
Polygon loadedPolygon = shapeCollection.Polygons.FindByName(objectName);
if (shouldClone)
{
loadedPolygon = loadedPolygon.Clone();
(toAddTo as ShapeCollection).Polygons.Add(loadedPolygon);
ShapeManager.AddToLayer(loadedPolygon, layerToAddTo);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = loadedPolygon;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
break;
case "Sphere":
{
ShapeCollection shapeCollection = objectJustLoaded.RuntimeObject as ShapeCollection;
Sphere loadedSphere = shapeCollection.Spheres.FindByName(objectName);
if (shouldClone)
{
loadedSphere = loadedSphere.Clone();
(toAddTo as ShapeCollection).Spheres.Add(loadedSphere);
ShapeManager.AddToLayer(loadedSphere, layerToAddTo);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = loadedSphere;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
break;
case "Capsule2D":
{
ShapeCollection shapeCollection = objectJustLoaded.RuntimeObject as ShapeCollection;
Capsule2D loadedCapsule2D = shapeCollection.Capsule2Ds.FindByName(objectName);
if (shouldClone)
{
loadedCapsule2D = loadedCapsule2D.Clone();
(toAddTo as ShapeCollection).Capsule2Ds.Add(loadedCapsule2D);
ShapeManager.AddToLayer(loadedCapsule2D, layerToAddTo);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = loadedCapsule2D;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
break;
case "Emitter":
{
EmitterList emitterList = objectJustLoaded.RuntimeObject as EmitterList;
Emitter loadedEmitter = emitterList.FindByName(objectName);
if (shouldClone && loadedEmitter != null)
{
loadedEmitter = loadedEmitter.Clone();
(toAddTo as EmitterList).Add(loadedEmitter);
SpriteManager.AddEmitter(loadedEmitter, layerToAddTo);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = loadedEmitter;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
break;
case "EmitterList":
{
EmitterList emitterList = objectJustLoaded.RuntimeObject as EmitterList;
if (shouldClone && emitterList != null)
{
emitterList = emitterList.Clone();
foreach (var item in emitterList)
{
SpriteManager.AddEmitter(item);
}
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = emitterList;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
break;
case "NodeNetwork":
{
NodeNetwork nodeNetwork = objectJustLoaded.RuntimeObject as NodeNetwork;
if (shouldClone)
{
nodeNetwork = nodeNetwork.Clone();
elementRuntime.EntireNodeNetworks.Add(objectToLoad.SourceFile, nodeNetwork);
newElementRuntime.ReferencedFileRuntimeList.LoadedNodeNetworks.Add(nodeNetwork);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = nodeNetwork;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
break;
case "SplineList":
{
SplineList splineList = objectJustLoaded.RuntimeObject as SplineList;
if (shouldClone)
{
splineList = splineList.Clone();
elementRuntime.EntireSplineLists.Add(splineList.Name, splineList);
foreach (var spline in splineList)
{
spline.CalculateVelocities();
spline.CalculateAccelerations();
}
splineList.AddToManagers();
splineList[0].UpdateShapes();
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = splineList;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
break;
case "Spline":
{
SplineList splineList = objectJustLoaded.RuntimeObject as SplineList;
Spline spline = splineList.FirstOrDefault(item => item.Name == objectName);
if (shouldClone && spline != null)
{
spline = spline.Clone();
(toAddTo as SplineList).Add(spline);
// Eventually support layers?
//ShapeManager.AddToLayer(spline, layerToAddTo);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = spline;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
spline.CalculateVelocities();
spline.CalculateAccelerations();
}
break;
}
if (toReturn == null)
{
foreach (var manager in ReferencedFileRuntimeList.FileManagers)
{
var objectFromFile = manager.TryGetObjectFromFile(elementRuntime.ReferencedFileRuntimeList.LoadedRfses, rfs, objectType, objectName);
if (objectFromFile != null)
{
var runtimeObject = objectFromFile;
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = runtimeObject;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
break;
}
}
}
if (toReturn != null && objectToLoad.AttachToContainer)
{
if (toReturn.RuntimeObject is PositionedObject)
{
// If the object is already attached to something, that means it
// came from a file, so we don't want to re-attach it.
PositionedObject asPositionedObject = toReturn.RuntimeObject as PositionedObject;
if (asPositionedObject.Parent == null)
{
asPositionedObject.AttachTo(elementRuntime, true);
}
}
else if (toReturn.RuntimeObject is Scene)
{
((Scene)toReturn.RuntimeObject).AttachAllDetachedTo(elementRuntime, true);
}
else if (toReturn.RuntimeObject is ShapeCollection)
{
((ShapeCollection)toReturn.RuntimeObject).AttachAllDetachedTo(elementRuntime, true);
}
}
return(toReturn);
}
public void SelectAxisAlignedCube(AxisAlignedCube axisAlignedCube)
{
CurrentShapeCollection.AxisAlignedCubes.Clear();
GuiData.ShapeCollectionPropertyGrid.CurrentAxisAlignedCube = axisAlignedCube;
if (axisAlignedCube != null)
{
bool isNewWindow;
PropertyGrid propertyGrid = (PropertyGrid)GuiManager.ObjectDisplayManager.GetObjectDisplayerForObject(axisAlignedCube, GuiData.ShapeCollectionPropertyGrid, null, out isNewWindow);
if (isNewWindow)
{
propertyGrid.SetMemberChangeEvent("Name", GuiData.MakeAxisAlignedCubeNameUnique);
}
CurrentShapeCollection.AxisAlignedCubes.Add(axisAlignedCube);
SelectPolygon(null);
SelectCircle(null);
SelectAxisAlignedRectangle(null);
SelectSphere(null);
}
}
public void AddAxisAlignedCube()
{
AxisAlignedCube cube = new AxisAlignedCube();
ShapeManager.AddAxisAlignedCube(cube);
cube.Color = EditorProperties.AxisAlignedCubeColor;
cube.X = SpriteManager.Camera.X;
cube.Y = SpriteManager.Camera.Y;
float scale = (float)Math.Abs(
18 / SpriteManager.Camera.PixelsPerUnitAt(0));
cube.ScaleX = scale;
cube.ScaleY = scale;
cube.ScaleZ = scale;
EditorData.ShapeCollection.AxisAlignedCubes.Add(cube);
cube.Name = "Cube" + EditorData.AxisAlignedCubes.Count;
StringFunctions.MakeNameUnique<AxisAlignedCube>(cube, EditorData.AxisAlignedCubes);
}
protected virtual IOperation CreateOperationFromEditor(Vector3 worldPosition, TerrainToolEditor editor)
{
var voxelType = EditorUtils.GetVoxelTypeFromIndex(VoxelTypeIndex, editor.Terrain.VoxelTypeSet);
return(AxisAlignedCube.CreateFromUnityWorld(editor.Terrain, Dig, worldPosition, Size, voxelType));
}
public void UpdateToEmitter(Emitter currentEmitter)
{
#region Update All Visibility
if (currentEmitter == null)
{
if (mCurrentVisibleRepresentation != null)
{
MakeAllInvisible();
mCurrentVisibleRepresentation = null;
}
}
else
{
object shapeThatShouldBeVisible = mVisibleRepresentations[currentEmitter.AreaEmission];
if (shapeThatShouldBeVisible != ((object)mCurrentVisibleRepresentation))
{
MakeAllInvisible();
object visibleRepresentation = mVisibleRepresentations[currentEmitter.AreaEmission];
LateBinder.GetInstance(visibleRepresentation.GetType()).SetValue(visibleRepresentation, "Visible", true);
mCurrentVisibleRepresentation = mVisibleRepresentations[currentEmitter.AreaEmission] as PositionedObject;
}
}
#endregion
#region Update the current Shape's properties
if (mCurrentVisibleRepresentation != null)
{
switch (currentEmitter.AreaEmission)
{
case Emitter.AreaEmissionType.Point:
// We do nothing here since we're not showing anything
break;
case Emitter.AreaEmissionType.Cube:
AxisAlignedCube asAxisAlignedCube = mCurrentVisibleRepresentation as AxisAlignedCube;
asAxisAlignedCube.ScaleX = currentEmitter.ScaleX;
asAxisAlignedCube.ScaleY = currentEmitter.ScaleY;
asAxisAlignedCube.ScaleZ = currentEmitter.ScaleZ;
asAxisAlignedCube.Position = currentEmitter.Position;
break;
case Emitter.AreaEmissionType.Rectangle:
AxisAlignedRectangle asAxisAlignedRectangle = mCurrentVisibleRepresentation as AxisAlignedRectangle;
asAxisAlignedRectangle.ScaleX = currentEmitter.ScaleX;
asAxisAlignedRectangle.ScaleY = currentEmitter.ScaleY;
asAxisAlignedRectangle.Position = currentEmitter.Position;
break;
}
}
#endregion
}