/// <summary> /// Initializes a new instance of this class. /// </summary> /// <param name="node">Node that was transformed.</param> /// <param name="originalBoundingBox">Nodes original bounding box.</param> /// <param name="originalTransformation">Nodes original transformation.</param> /// <param name="newBoundingBox">Nodes new bounding box.</param> /// <param name="newTransformation">Nodes new transformation.</param> public ResizeNodeUndoOperation(EntityNode node, Rectangle originalBoundingBox, Transformation originalTransformation, Rectangle newBoundingBox, Transformation newTransformation) { _node = node; _newBoundingBox = newBoundingBox; _newTransformation = newTransformation; _originalBoundingBox = originalBoundingBox; _originalTransformation = originalTransformation; }
/// <summary> /// Resets this node to the state it was in when it was created. /// </summary> public virtual void Reset() { if (_parent != null) _parent.RemoveChild(this); _transformation = new Transformation(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f); _transformationOffset = new Transformation(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f); }
/// <summary> /// Sets the rendering state so that all children of this /// camera are drawn correctly. /// </summary> /// <param name="position">Position where this entity's parent node was rendered.</param> public override void Render(Transformation transformation, CameraNode camera, int layer) { //Statistics.StoreInt("Nodes Rendered", Statistics.ReadInt("Nodes Rendered") + 1); Transformation relativeTransformation = CalculateRelativeTransformation(transformation); SetupRenderingState(relativeTransformation); GraphicsManager.ClearColor = _clearColor; GraphicsManager.Viewport = _viewport; GraphicsManager.ClearScene(); if (_backgroundImage != null) { GraphicsManager.ScaleFactor = new float[] { _zoom, _zoom, 1.0f }; GraphicsManager.TileImage(_backgroundImage, relativeTransformation.X, relativeTransformation.Y, relativeTransformation.Z); // Clear up the depth buffer so this image is always at the back. GraphicsManager.ClearDepthBuffer(); } // Set the audio listener position at this cameras current position. Audio.AudioManager.ListenerPosition = new Vector((-relativeTransformation.X) + (_viewport.Width / 2), -(relativeTransformation.Y) + (_viewport.Height / 2), 0.0f); RenderChildren(relativeTransformation, camera, layer); }
/// <summary> /// Gets the transformation of this entity relative to all the nodes above it. /// </summary> public Transformation CalculateTransformation() { ArrayList parentNodes = new ArrayList(); SceneNode parent = this.Parent; while (parent != null) { if ((parent as SceneNode) != null) parentNodes.Add(parent); parent = parent.Parent; } parentNodes.Reverse(); Transformation relativeTransformation = new Transformation(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f); foreach (SceneNode node in parentNodes) relativeTransformation = node.CalculateRelativeTransformation(relativeTransformation); return CalculateRelativeTransformation(relativeTransformation); }
/// <summary> /// Called when this node needs to be rendered. /// </summary> public virtual void Render(Transformation transformation, CameraNode camera, int layer) { RenderChildren(transformation, camera, layer); }
/// <summary> /// Sets the rendering state so that all children of this /// camera are drawn correctly. /// </summary> /// <param name="position">Position where this entity's parent node was rendered.</param> public override void Render(Transformation transformation, CameraNode camera, int layer) { Transformation relativeTransformation = CalculateRelativeTransformation(transformation); SetupRenderingState(relativeTransformation); // Are we currnetly rendering the layer this entity is on? if (layer != _depthLayer) { if (_visible == true) RenderChildren(relativeTransformation, camera, layer); return; } //Statistics.StoreInt("Nodes Rendered", Statistics.ReadInt("Nodes Rendered") + 1); // Render all the particles attached to this emitter. if (_visible == true || _forceVisibility == true) { GraphicsManager.PushRenderState(); foreach (ParticleNode particleNode in _particleList) particleNode.Render(transformation, camera, layer); GraphicsManager.PopRenderState(); } // Render the bounding box and sizing points if we have been asked to do so. if (_renderBoundingBox == true || _forceBoundingBoxVisibility == true) RenderBoundingBox(relativeTransformation, camera); if (_renderSizingPoints == true) RenderSizingPoints(relativeTransformation, camera); if (_renderEventLines == true) RenderEventLines(relativeTransformation, camera); if (_forceGlobalDebugVisibility == true) RenderDebug(relativeTransformation, camera); // Render all the children of this entity. RenderChildren(relativeTransformation, camera, layer); }
/// <summary> /// Renders this entity. /// </summary> /// <param name="position">Position where this entity's parent node was rendered.</param> public override void Render(Transformation transformation, CameraNode camera, int layer) { if (_image == null) return; //Statistics.StoreInt("Nodes Rendered", Statistics.ReadInt("Nodes Rendered") + 1); Transformation relativeTransformation = CalculateRelativeTransformation(transformation); relativeTransformation.Z = transformation.Z; SetupRenderingState(relativeTransformation); GraphicsManager.RenderImage(_image, relativeTransformation.X, relativeTransformation.Y, relativeTransformation.Z, _frame); }
/// <summary> /// Renders the event lines of this entity. /// </summary> /// <param name="transformation">Transformation to render event lines at.</param> protected virtual void RenderEventLines(Transformation transformation, CameraNode camera) { GraphicsManager.PushRenderState(); GraphicsManager.ClearRenderState(); GraphicsManager.DepthBufferEnabled = false; GraphicsManager.VertexColors.AllVertexs = _eventLineColor; foreach (SceneNode node in _eventNodes) { EntityNode entityNode = node as EntityNode; if (entityNode == null) continue; Transformation relativeTransformation = entityNode.CalculateTransformation(camera); int x1 = (int)(transformation.X + ((_boundingRectangle.Width * transformation.ScaleX) / 2)); int y1 = (int)(transformation.Y + ((_boundingRectangle.Height * transformation.ScaleY) / 2)); int x2 = (int)(relativeTransformation.X + ((entityNode._boundingRectangle.Width * relativeTransformation.ScaleX) / 2)); int y2 = (int)(relativeTransformation.Y + ((entityNode._boundingRectangle.Height * relativeTransformation.ScaleY) / 2)); GraphicsManager.RenderLine(x1, y1, transformation.Z, x2, y2, relativeTransformation.Z); } GraphicsManager.PopRenderState(); }
/// <summary> /// Renders the sizing points of this entity. /// </summary> /// <param name="transformation">Transformation to render sizing points at.</param> protected void RenderSizingPoints(Transformation transformation, CameraNode camera) { GraphicsManager.PushRenderState(); GraphicsManager.ClearRenderState(); GraphicsManager.DepthBufferEnabled = false; GraphicsManager.VertexColors.AllVertexs = _sizingPointsColor; int halfSize = _sizingPointsSize / 2; int x = (int)(transformation.X - halfSize); int y = (int)(transformation.Y - halfSize); int w = (int)(_boundingRectangle.Width * Math.Abs(transformation.ScaleX)); int h = (int)(_boundingRectangle.Height * Math.Abs(transformation.ScaleY)); GraphicsManager.RenderRectangle(x, y, transformation.Z, _sizingPointsSize, _sizingPointsSize, false); GraphicsManager.RenderRectangle(x + w, y, transformation.Z, _sizingPointsSize, _sizingPointsSize, false); GraphicsManager.RenderRectangle(x + (w / 2), y, transformation.Z, _sizingPointsSize, _sizingPointsSize, false); GraphicsManager.RenderRectangle(x + w, y + h, transformation.Z, _sizingPointsSize, _sizingPointsSize, false); GraphicsManager.RenderRectangle(x + w, y + (h / 2), transformation.Z, _sizingPointsSize, _sizingPointsSize, false); GraphicsManager.RenderRectangle(x, y + h, transformation.Z, _sizingPointsSize, _sizingPointsSize, false); GraphicsManager.RenderRectangle(x, y + (h / 2), transformation.Z, _sizingPointsSize, _sizingPointsSize, false); GraphicsManager.RenderRectangle(x + (w / 2), y + h, transformation.Z, _sizingPointsSize, _sizingPointsSize, false); GraphicsManager.PopRenderState(); }
/// <summary> /// Renders the collision box of this entity. /// </summary> /// <param name="transformation">Transformation to render collisionbox at.</param> protected void RenderCollisionBox(Transformation transformation, CameraNode camera) { if (_solid == false) return; GraphicsManager.PushRenderState(); GraphicsManager.ClearRenderState(); GraphicsManager.DepthBufferEnabled = false; GraphicsManager.VertexColors.AllVertexs = _collisionBoxColor; GraphicsManager.RenderRectangle(transformation.X + (_collisionRectangle.X * transformation.ScaleX), transformation.Y + (_collisionRectangle.Y * transformation.ScaleY), transformation.Z, Math.Abs(_collisionRectangle.Width * transformation.ScaleX), _collisionRectangle.Height * Math.Abs(transformation.ScaleY), false); GraphicsManager.PopRenderState(); }
/// <summary> /// Renders the debug information of this entity. /// </summary> /// <param name="transformation">Transformation to render debug information at.</param> protected void RenderDebug(Transformation transformation, CameraNode camera) { GraphicsManager.PushRenderState(); GraphicsManager.ClearRenderState(); GraphicsManager.DepthBufferEnabled = false; GraphicsManager.ScaleFactor = new float[3] { 1.0f, 1.0f, 1.0f }; float[] resolutionScale = GraphicsManager.ResolutionScale; GraphicsManager.ResolutionScale = new float[2] { 1.0f, 1.0f }; string debugText = "(" + transformation.X + "," + transformation.Y + "," + transformation.Z + ") (" + transformation.ScaleX + "," + transformation.ScaleY + "," + transformation.ScaleZ + ") (" + transformation.AngleX + "," + transformation.AngleY + "," + transformation.AngleZ + ")"; GraphicsManager.VertexColors.AllVertexs = unchecked((int)0xFF000000); GraphicsManager.RenderRectangle((transformation.X * resolutionScale[0]), (transformation.Y * resolutionScale[1]) - 30, transformation.Z, GraphicsManager.BitmapFont.TextWidth(debugText, false), GraphicsManager.BitmapFont.TextHeight(debugText, false)); GraphicsManager.VertexColors.AllVertexs = _debugInfoColor; GraphicsManager.RenderText(debugText, (transformation.X * resolutionScale[0]), (transformation.Y * resolutionScale[1]) - 30, transformation.Z); debugText = "[Solid:\"" + _solid + "\" Visible:\""+_visible+"\" Frame:\""+_frame+"\" Event:\""+_event+"\" Name:\""+_name+"\"]"; GraphicsManager.VertexColors.AllVertexs = unchecked((int)0xFF000000); GraphicsManager.RenderRectangle((transformation.X * resolutionScale[0]), (transformation.Y * resolutionScale[1]) - 15, transformation.Z, GraphicsManager.BitmapFont.TextWidth(debugText, false), GraphicsManager.BitmapFont.TextHeight(debugText, false)); GraphicsManager.VertexColors.AllVertexs = _debugInfoColor; GraphicsManager.RenderText(debugText, (transformation.X * resolutionScale[0]), (transformation.Y * resolutionScale[1]) - 15, transformation.Z); GraphicsManager.PopRenderState(); }
/// <summary> /// Renders the bounding box of this entity. /// </summary> /// <param name="transformation">Transformation to render bounding box at.</param> protected void RenderBoundingBox(Transformation transformation, CameraNode camera) { GraphicsManager.PushRenderState(); GraphicsManager.ClearRenderState(); GraphicsManager.DepthBufferEnabled = false; GraphicsManager.VertexColors.AllVertexs = _boundingBoxColor; GraphicsManager.RenderRectangle(transformation.X, transformation.Y, transformation.Z, Math.Abs(_boundingRectangle.Width * transformation.ScaleX), _boundingRectangle.Height * Math.Abs(transformation.ScaleY), false); GraphicsManager.PopRenderState(); }
/// <summary> /// Ininitalizes a new instance of this class with the given data. /// </summary> /// <param name="transformation">Transformation of this rectangle.</param> /// <param name="width">Width of this rectangle.</param> /// <param name="height">Height of this rectangle.</param> public CollisionRectangle(Transformation transformation, float width, float height) { _transformation = transformation; _width = width; _height = height; }
/// <summary> /// Called when the reset camera menu item is clicked. /// </summary> /// <param name="sender">Object that caused this event to be triggered.</param> /// <param name="e">Arguments explaining why this event occured.</param> private void resetCameraToolStripMenuItem_Click(object sender, EventArgs e) { _cameraTransformation = new Transformation(0, 0, 0, 0, 0, 0, 1, 1, 1); }
/// <summary> /// Initializes a new instance of this class. /// </summary> /// <param name="node">Node that was transformed.</param> /// <param name="originalTransformation">Nodes original transformation.</param> /// <param name="newTransformation">Nodes new transformation.</param> public TransformNodeUndoOperation(SceneNode node, Transformation originalTransformation, Transformation newTransformation) { _node = node; _newTransformation = newTransformation; _originalTransformation = originalTransformation; }
/// <summary> /// Sets up the rendering state so this entity is rendered correctly. /// </summary> /// <param name="relativeTransformation">Transformation used to set scale and rotation factors.</param> protected void SetupRenderingState(Transformation relativeTransformation) { GraphicsManager.VertexColors.AllVertexs = _color; if (GraphicsManager.BlendMode != _blendMode) GraphicsManager.BlendMode = _blendMode; if (GraphicsManager.ScaleFactor[0] != relativeTransformation.ScaleX || GraphicsManager.ScaleFactor[1] != relativeTransformation.ScaleY || GraphicsManager.ScaleFactor[2] != relativeTransformation.ScaleZ) { GraphicsManager.ScaleFactor[0] = relativeTransformation.ScaleX; GraphicsManager.ScaleFactor[1] = relativeTransformation.ScaleY; GraphicsManager.ScaleFactor[2] = relativeTransformation.ScaleZ; } if (GraphicsManager.RotationAngle[0] != relativeTransformation.AngleX || GraphicsManager.RotationAngle[1] != relativeTransformation.AngleY || GraphicsManager.RotationAngle[2] != relativeTransformation.AngleZ) { GraphicsManager.RotationAngle[0] = relativeTransformation.AngleX; GraphicsManager.RotationAngle[1] = relativeTransformation.AngleY; GraphicsManager.RotationAngle[2] = relativeTransformation.AngleZ; } if (_bitmapFont != null) GraphicsManager.BitmapFont = _bitmapFont; }
/// <summary> /// Updates the following entity associated with this process. /// </summary> /// <param name="deltaTime">Elapsed time since last frame.</param> public override void Run(float deltaTime) { //if (_entity.IsEnabled == false) return; // Work out the central points. Transformation entityTransform = _entity.CalculateTransformation(); // If its a camera then we need to invert the coordinates as it uses // slightly different ones from normal entities. if (_entity is CameraNode) { entityTransform.X = -entityTransform.X; entityTransform.Y = -entityTransform.Y; } // Are we at the correct place? If so why bother with the below code :P. if (entityTransform.X == _x && entityTransform.Y == _y) { Finish(ProcessResult.Success); return; } // If we can't move then finish. if (_gotPreviousTransformation == true) { if (_previousTransformation.X == entityTransform.X && _previousTransformation.Y == entityTransform.Y && _previousTransformation.Z == entityTransform.Z) { if (_previousTransformationTimer.DurationMillisecond > 500) // Half a second and no movement O_o, oh shiz we must have something in out way. { Finish(ProcessResult.Failed); return; } } else { _previousTransformationTimer.Restart(); _previousTransformation = entityTransform; } } else { _previousTransformation = entityTransform; _previousTransformationTimer.Restart(); _gotPreviousTransformation = true; } float entityTransformCenterX = entityTransform.X + ((_entity.BoundingRectangle.Width / 2) * entityTransform.ScaleX); float entityTransformCenterY = entityTransform.Y + ((_entity.BoundingRectangle.Height / 2) * entityTransform.ScaleY); float vectorX = entityTransformCenterX - _x; float vectorY = entityTransformCenterY - _y; float distance = (float)Math.Sqrt(vectorX * vectorX + vectorY * vectorY); vectorX /= distance; vectorY /= distance; float followSpeed = _followSpeed.Start + (((_followSpeed.Finish - _followSpeed.Start) / _originalDistance) * (_originalDistance - distance)); // Work out vector towards entity. float movementX = (vectorX * followSpeed) * deltaTime; float movementY = (vectorY * followSpeed) * deltaTime; _entity.Move(-movementX,-movementY, 0.0f); // Are we done yet? if (Math.Abs(Math.Round(distance)) <= Math.Max(1,_followSpeed.Finish) * 2)// || followSpeed == _followSpeed.Finish) { Finish(ProcessResult.Success); return; } }
/// <summary> /// Calculates this entitys relative transformation to another transformation. /// </summary> /// <param name="transformation">Transformation to calculate relative transformation from.</param> /// <returns>Transfromation relative to the given transfromation.</returns> public override Transformation CalculateRelativeTransformation(Transformation transformation) { //CollectiveTimer.Restart(); Transformation newTransform = new Transformation(); newTransform.AngleX = transformation.AngleX + _transformation.AngleX; newTransform.AngleY = transformation.AngleY + _transformation.AngleY; newTransform.AngleZ = transformation.AngleZ + _transformation.AngleZ; newTransform.ScaleX = transformation.ScaleX + (_transformation.ScaleX < 0.0f ? -_transformation.ScaleX : _transformation.ScaleX) - 1.0f; newTransform.ScaleY = transformation.ScaleY + (_transformation.ScaleY < 0.0f ? -_transformation.ScaleY : _transformation.ScaleY) - 1.0f; newTransform.ScaleZ = transformation.ScaleZ + (_transformation.ScaleZ < 0.0f ? -_transformation.ScaleZ : _transformation.ScaleZ) - 1.0f; if (_transformation.ScaleX < 0) newTransform.ScaleX = -newTransform.ScaleX; if (_transformation.ScaleY < 0) newTransform.ScaleY = -newTransform.ScaleY; if (_transformation.ScaleZ < 0) newTransform.ScaleZ = -newTransform.ScaleZ; newTransform.X = (float)Math.Truncate(transformation.X + ((_transformation.X + _transformationOffset.X) * transformation.ScaleX)); newTransform.Y = (float)Math.Truncate(transformation.Y + ((_transformation.Y + _transformationOffset.Y) * transformation.ScaleY)); // Work out the depth offset. float depthOffset = 0; switch (_depthMode) { case EntityDepthMode.AddXCoordinate: depthOffset = newTransform.X; break; case EntityDepthMode.AddYCoordinate: depthOffset = newTransform.Y; break; case EntityDepthMode.SubtractXCoordinate: depthOffset = -newTransform.X; break; case EntityDepthMode.SubtractYCoordinate: depthOffset = -newTransform.Y; break; case EntityDepthMode.AddCollisionBoxTop: depthOffset = (newTransform.Y + _collisionRectangle.Top); break; case EntityDepthMode.AddCollisionBoxBottom: depthOffset = (newTransform.Y + _collisionRectangle.Bottom); break; case EntityDepthMode.AddCollisionBoxLeft: depthOffset = (newTransform.X + _collisionRectangle.Left); break; case EntityDepthMode.AddCollisionBoxRight: depthOffset = (newTransform.X + _collisionRectangle.Right); break; case EntityDepthMode.SubtractCollisionBoxTop: depthOffset = -(newTransform.Y + _collisionRectangle.Top); break; case EntityDepthMode.SubtractCollisionBoxBottom: depthOffset = -(newTransform.Y + _collisionRectangle.Bottom); break; case EntityDepthMode.SubtractCollisionBoxLeft: depthOffset = -(newTransform.X + _collisionRectangle.Left); break; case EntityDepthMode.SubtractCollisionBoxRight: depthOffset = -(newTransform.X + _collisionRectangle.Right); break; case EntityDepthMode.AddBoundingBoxTop: depthOffset = (newTransform.Y + _boundingRectangle.Top); break; case EntityDepthMode.AddBoundingBoxBottom: depthOffset = (newTransform.Y + _boundingRectangle.Bottom); break; case EntityDepthMode.AddBoundingBoxLeft: depthOffset = (newTransform.X + _boundingRectangle.Left); break; case EntityDepthMode.AddBoundingBoxRight: depthOffset = (newTransform.X + _boundingRectangle.Right); break; case EntityDepthMode.SubtractBoundingBoxTop: depthOffset = -(newTransform.Y + _boundingRectangle.Top); break; case EntityDepthMode.SubtractBoundingBoxBottom: depthOffset = -(newTransform.Y + _boundingRectangle.Bottom); break; case EntityDepthMode.SubtractBoundingBoxLeft: depthOffset = -(newTransform.X + _boundingRectangle.Left); break; case EntityDepthMode.SubtractBoundingBoxRight: depthOffset = -(newTransform.X + _boundingRectangle.Right); break; } newTransform.Z = (transformation.Z) - (depthOffset + _transformation.Z + _transformationOffset.Z); //CollectiveCalls++; //CollectiveTime += CollectiveTimer.DurationMillisecond; return newTransform; }
/// <summary> /// Renders this tilemap segment at a relative position to its parent node. /// </summary> /// <param name="transformation">Transformation of parent node.</param> public override void Render(Transformation transformation, CameraNode camera, int layer) { if (_tileData == null) return; // Work out where and how we should be rendered. Transformation relativeTransformation = CalculateRelativeTransformation(transformation); SetupRenderingState(relativeTransformation); // Are we currnetly rendering the layer this entity is on? Or are we not visible. if (layer != _depthLayer || CanBeSeen(relativeTransformation) == false) { if (_visible == true) RenderChildren(relativeTransformation, camera, layer); return; } //Statistics.StoreInt("Nodes Rendered", Statistics.ReadInt("Nodes Rendered") + 1); // Work out if all the tiles are visible and what are not. int segmentLeft = (int)(-((relativeTransformation.X / _tileWidth) / relativeTransformation.ScaleX) - 1); int segmentTop = (int)(-((relativeTransformation.Y / _tileHeight) / relativeTransformation.ScaleY) - 1); int segmentRight = (int)(segmentLeft + ((GraphicsManager.Resolution[0] / _tileWidth) / relativeTransformation.ScaleX) + 2); int segmentBottom = (int)(segmentTop + ((GraphicsManager.Resolution[1] / _tileHeight) / relativeTransformation.ScaleY) + 2); // Cap all the segments off so we don't try to draw outside // the bounds of this array segment. segmentLeft = Math.Min(_width - 1, Math.Max(0, segmentLeft)); segmentTop = Math.Min(_height - 1, Math.Max(0, segmentTop)); segmentRight = Math.Min(_width, Math.Max(0, segmentRight)); segmentBottom = Math.Min(_height, Math.Max(0, segmentBottom)); if (_visible == true || _forceVisibility == true) { // Render normally if a prerendered version is not available. if (_preRenderedImage == null) { //System.Console.WriteLine("Rendered tilemap segment of " + (segmentRight - segmentLeft) + "x" + (segmentBottom - segmentTop) + " (real size: " + (_width + "," + _height) + " tiles:" + ((segmentRight - segmentLeft) * (segmentBottom - segmentTop)) + ")"); // Go through all the visible tiles and render them. for (int tileX = segmentLeft; tileX < segmentRight; tileX++) for (int tileY = segmentTop; tileY < segmentBottom; tileY++) { if (_tileData[tileX, tileY] == null || _tileData[tileX, tileY].IsVisible == false || _tileData[tileX, tileY].Tileset == null || _tileData[tileX, tileY].Frame < 0 || _tileData[tileX, tileY].Frame >= _tileData[tileX, tileY].Tileset.Image.FrameCount) continue; _tileData[tileX, tileY].Render(relativeTransformation, camera, layer); /* float tileScaleX = relativeTransformation.ScaleX + Math.Abs(_tileData[tileX, tileY].Transformation.ScaleX) - 1.0f; float tileScaleY = relativeTransformation.ScaleY + Math.Abs(_tileData[tileX, tileY].Transformation.ScaleY) - 1.0f; if (tileScaleX < 0) tileScaleX = -tileScaleX; if (tileScaleY < 0) tileScaleY = -tileScaleY; float tx = relativeTransformation.X + ((tileX * _tileWidth) * tileScaleX); float ty = relativeTransformation.Y + ((tileY * _tileHeight) * tileScaleY); GraphicsManager.VertexColors.AllVertexs = _tileData[tileX, tileY].Color; GraphicsManager.BlendMode = _tileData[tileX, tileY].BlendMode; GraphicsManager.ScaleFactor = new float[] { tileScaleX, tileScaleY }; GraphicsManager.RenderImage(_tileData[tileX, tileY].Tileset.Image, tx, ty, relativeTransformation.Z, _tileData[tileX, tileY].Frame); */} } // w00ties a prerender exists, time for a nice big speedup! else GraphicsManager.RenderImage(_preRenderedImage, relativeTransformation.X, relativeTransformation.Y, relativeTransformation.Z, 0); // If we have been asked to render a grid then do so. if (_renderGrid == true) { float width = (_width * _tileWidth) * Math.Abs(relativeTransformation.ScaleX); float height = (_height * _tileHeight) * Math.Abs(relativeTransformation.ScaleY); GraphicsManager.VertexColors.AllVertexs = _gridColor; for (int x = 0; x <= _width; x++) { float lX = (relativeTransformation.X + (x * (_tileWidth * Math.Abs(relativeTransformation.ScaleX)))); float lY = relativeTransformation.Y; GraphicsManager.RenderLine(lX, lY, relativeTransformation.Z, lX, lY + height, relativeTransformation.Z); } for (int y = 0; y <= _height; y++) { float lX = relativeTransformation.X; float lY = (relativeTransformation.Y + (y * (_tileHeight * Math.Abs(relativeTransformation.ScaleY)))); GraphicsManager.RenderLine(lX, lY, relativeTransformation.Z, lX + width, lY, relativeTransformation.Z); } } } // Render bits and pieces that are required. if (_renderCollisionBox == true || _forceCollisionBoxVisibility == true || _forceGlobalCollisionBoxVisibility) RenderCollisionBox(relativeTransformation, camera); if (_renderBoundingBox == true || _forceBoundingBoxVisibility == true || _forceGlobalBoundingBoxVisibility) RenderBoundingBox(relativeTransformation, camera); if (_renderSizingPoints == true) RenderSizingPoints(relativeTransformation, camera); if (_renderEventLines == true || _forceGlobalEventLineVisibility) RenderEventLines(relativeTransformation, camera); if (_forceGlobalDebugVisibility == true) RenderDebug(relativeTransformation, camera); // Render all the children of this entity. if (_visible == true) RenderChildren(relativeTransformation, camera, layer); }
/// <summary> /// Returns true if this entity is within the viewport of the current render target. /// </summary> /// <param name="transformation">Position this entity should be checked from.</param> /// <returns>True if this entity can be seen.</returns> public bool CanBeSeen(Transformation transformation) { return MathMethods.RectanglesOverlap((int)transformation.X, (int)transformation.Y, (int)(Width * Math.Abs(transformation.ScaleX)), (int)(Height * Math.Abs(transformation.ScaleY)), 0, 0, GraphicsManager.Resolution[0], GraphicsManager.Resolution[1]); }
/// <summary> /// Calculates this entitys relative transformation to another transformation. /// </summary> /// <param name="transformation">Transformation to calculate relative transformation from.</param> /// <returns>Transfromation relative to the given transfromation.</returns> public virtual Transformation CalculateRelativeTransformation(Transformation transformation) { Transformation newTransform = new Transformation(); newTransform.AngleX = transformation.AngleX + _transformation.AngleX; newTransform.AngleY = transformation.AngleY + _transformation.AngleY; newTransform.AngleZ = transformation.AngleZ + _transformation.AngleZ; newTransform.ScaleX = transformation.ScaleX + Math.Abs(_transformation.ScaleX) - 1.0f; newTransform.ScaleY = transformation.ScaleY + Math.Abs(_transformation.ScaleY) - 1.0f; newTransform.ScaleZ = transformation.ScaleY + Math.Abs(_transformation.ScaleZ) - 1.0f; if (_transformation.ScaleX < 0) newTransform.ScaleX = -newTransform.ScaleX; if (_transformation.ScaleY < 0) newTransform.ScaleY = -newTransform.ScaleY; if (_transformation.ScaleZ < 0) newTransform.ScaleY = -newTransform.ScaleZ; newTransform.X = (float)Math.Truncate(transformation.X + ((_transformation.X + _transformationOffset.X) * transformation.ScaleX)); newTransform.Y = (float)Math.Truncate(transformation.Y + ((_transformation.Y + _transformationOffset.Y) * transformation.ScaleY)); // Work out the depth offset. float depthOffset = 0; switch (_depthMode) { case EntityDepthMode.AddXCoordinate: depthOffset = newTransform.X; break; case EntityDepthMode.AddYCoordinate: depthOffset = newTransform.Y; break; case EntityDepthMode.SubtractXCoordinate: depthOffset = -newTransform.X; break; case EntityDepthMode.SubtractYCoordinate: depthOffset = -newTransform.Y; break; } //newTransform.Z = (transformation.Z + _transformation.Z + _transformationOffset.Z) - ((_depthLayer * 1000) + depthOffset); newTransform.Z = (transformation.Z + _transformation.Z + _transformationOffset.Z) - depthOffset; return newTransform; }
/// <summary> /// Called just before this polygon is put through collision processing. /// </summary> public void PreCollisionProcessing() { Transformation parentTransformation = _parent != null ? _parent.CalculateTransformation() : new Transformation(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f); Transformation transformation = new Transformation(parentTransformation.X + _transformation.X, parentTransformation.Y + _transformation.Y, parentTransformation.Z + _transformation.Z, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f); transformation.X += _collisionRectangle.X; transformation.Y += _collisionRectangle.Y; _collisionPolygon.Transformation = transformation; _collisionPolygon.Solid = _solid; if (_collisionPolygon is CollisionRectangle) { ((CollisionRectangle)_collisionPolygon).BoundingWidth = _collisionRectangle.Width; ((CollisionRectangle)_collisionPolygon).BoundingHeight = _collisionRectangle.Height; } }
/// <summary> /// Gets a bounding box that encircles both this node and its child nodes. /// </summary> /// <param name="transformation">Transformation of parent node.</param> public virtual RectangleF GetGlobalBoundingBox(Transformation transformation) { if (_persistent == true) return new RectangleF(0,0,0,0); Transformation relativeTransformation = CalculateRelativeTransformation(transformation); RectangleF box = new RectangleF(relativeTransformation.X, relativeTransformation.Y, Width * relativeTransformation.ScaleX, Height * relativeTransformation.ScaleY); foreach (SceneNode node in _childList) { RectangleF childBox = node.GetGlobalBoundingBox(relativeTransformation); if (childBox.X == 0 && childBox.Y == 0 && childBox.Width == 0 && childBox.Height == 0) continue; if (childBox.X < box.X) { box.Width += (box.X - childBox.X); box.X = childBox.X; } if (childBox.Y < box.Y) { box.Height += (box.Y - childBox.Y); box.Y = childBox.Y; } if (childBox.Right > box.Right) box.Width += (childBox.Right - box.Right); if (childBox.Bottom > box.Bottom) box.Height += (childBox.Bottom - box.Bottom); } return box; }
/// <summary> /// Renders this entity at a position releative to its parent. /// </summary> /// <param name="position">Position where this entity's parent node was rendered.</param> public override void Render(Transformation transformation, CameraNode camera, int layer) { // Setup rendering mode. //HighPreformanceTimer timer = new HighPreformanceTimer(); Transformation relativeTransformation = CalculateRelativeTransformation(transformation); SetupRenderingState(relativeTransformation); //if (timer.DurationMillisecond > 1.0f) // System.Console.WriteLine((_image != null ? _image.URL : this.ToString()) + " worked out transformation in " + timer.DurationMillisecond); //timer.Restart(); // Are we currnetly rendering the layer this entity is on? if (layer != _depthLayer) { if (_visible == true) RenderChildren(relativeTransformation, camera, layer); return; } if ((_visible == true || _forceVisibility == true) && (_renderMode == EntityRenderMode.TiledImage || CanBeSeen(relativeTransformation) == true)) { //Statistics.StoreInt("Nodes Rendered", Statistics.ReadInt("Nodes Rendered") + 1); Shader previousShader = null; if (_shader != null) { previousShader = GraphicsManager.Shader; GraphicsManager.Shader = _shader; } switch (_renderMode) { case EntityRenderMode.Image: if (_image == null) break; GraphicsManager.RenderImage(_image, relativeTransformation.X + (((_boundingRectangle.Width - _image.Width) * transformation.ScaleX) / 2), relativeTransformation.Y + (((_boundingRectangle.Height - _image.Height) * transformation.ScaleY) / 2), relativeTransformation.Z, _frame); break; case EntityRenderMode.ContainedImage: { if (_image == null) break; Rectangle originalViewport = GraphicsManager.Viewport; GraphicsManager.Viewport = new Rectangle((int)relativeTransformation.X, (int)relativeTransformation.Y, (int)(_boundingRectangle.Width * Math.Abs(relativeTransformation.ScaleX)), (int)(_boundingRectangle.Height * Math.Abs(relativeTransformation.ScaleY))); GraphicsManager.RenderImage(_image, relativeTransformation.X + (((_boundingRectangle.Width - _image.Width) * transformation.ScaleX) / 2), relativeTransformation.Y + (((_boundingRectangle.Height - _image.Height) * transformation.ScaleY) / 2), relativeTransformation.Z, _frame); GraphicsManager.Viewport = originalViewport; } break; case EntityRenderMode.TiledImage: if (_image == null) break; GraphicsManager.TileImage(_image, relativeTransformation.X, relativeTransformation.Y, relativeTransformation.Z, _frame); break; case EntityRenderMode.ContainedTiledImage: { if (_image == null) break; Rectangle originalViewport = GraphicsManager.Viewport; GraphicsManager.Viewport = new Rectangle((int)relativeTransformation.X, (int)relativeTransformation.Y, (int)(_boundingRectangle.Width * Math.Abs(relativeTransformation.ScaleX)), (int)(_boundingRectangle.Height * Math.Abs(relativeTransformation.ScaleY))); GraphicsManager.TileImage(_image, relativeTransformation.X, relativeTransformation.Y, relativeTransformation.Z, _frame); GraphicsManager.Viewport = originalViewport; } break; case EntityRenderMode.Oval: GraphicsManager.RenderOval(relativeTransformation.X + (_boundingRectangle.X * transformation.ScaleX), relativeTransformation.Y + (_boundingRectangle.Y * transformation.ScaleY), relativeTransformation.Z, _boundingRectangle.Width, _boundingRectangle.Height); break; case EntityRenderMode.HollowOval: GraphicsManager.RenderOval(relativeTransformation.X + (_boundingRectangle.X * transformation.ScaleX), relativeTransformation.Y + (_boundingRectangle.Y * transformation.ScaleY), relativeTransformation.Z, _boundingRectangle.Width, _boundingRectangle.Height, false); break; case EntityRenderMode.Pixel: GraphicsManager.RenderPixel(relativeTransformation.X + ((_boundingRectangle.Width * transformation.ScaleX) / 2), relativeTransformation.Y + ((_boundingRectangle.Height * transformation.ScaleX) / 2), relativeTransformation.Z); break; case EntityRenderMode.Rectangle: GraphicsManager.RenderRectangle(relativeTransformation.X + (_boundingRectangle.X * transformation.ScaleX), relativeTransformation.Y + (_boundingRectangle.Y * transformation.ScaleY), relativeTransformation.Z, _boundingRectangle.Width, _boundingRectangle.Height); break; case EntityRenderMode.HollowRectangle: GraphicsManager.RenderRectangle(relativeTransformation.X + (_boundingRectangle.X * transformation.ScaleX), relativeTransformation.Y + (_boundingRectangle.Y * transformation.ScaleY), relativeTransformation.Z, _boundingRectangle.Width, _boundingRectangle.Height, false); break; case EntityRenderMode.Text: GraphicsManager.RenderText(_text, relativeTransformation.X + (((_boundingRectangle.Width - GraphicsManager.TextWidth(_text, true)) * transformation.ScaleX) / 2), relativeTransformation.Y + (((_boundingRectangle.Height - GraphicsManager.TextHeight(_text, true)) * transformation.ScaleY) / 2), relativeTransformation.Z, true); break; case EntityRenderMode.Mesh: if (_mesh == null) break; GraphicsManager.RenderMesh(_mesh, relativeTransformation.X + (((_boundingRectangle.Width - _mesh.Width) * transformation.ScaleX) / 2), relativeTransformation.Y + (((_boundingRectangle.Height - _mesh.Height) * transformation.ScaleY) / 2), relativeTransformation.Z); break; } if (_shader != null) GraphicsManager.Shader = previousShader; } // Render bits and pieces that are required. if (_renderCollisionBox == true || _forceCollisionBoxVisibility == true || _forceGlobalCollisionBoxVisibility) RenderCollisionBox(relativeTransformation, camera); if (_renderBoundingBox == true || _forceBoundingBoxVisibility == true || _forceGlobalBoundingBoxVisibility) RenderBoundingBox(relativeTransformation, camera); if (_renderSizingPoints == true) RenderSizingPoints(relativeTransformation, camera); if (_renderEventLines == true || _forceGlobalEventLineVisibility) RenderEventLines(relativeTransformation, camera); if (_forceGlobalDebugVisibility == true) RenderDebug(relativeTransformation, camera); //if (timer.DurationMillisecond > 1.0f) // System.Console.WriteLine((_image != null ? _image.URL : this.ToString()) + " rendered in " + timer.DurationMillisecond); // Render all the children of this entity. if (_visible == true) RenderChildren(relativeTransformation, camera, layer); }
/// <summary> /// Renders all child nodes of this node. /// </summary> public void RenderChildren(Transformation transformation, CameraNode camera, int layer) { foreach (SceneNode child in _childList) { // Not on the same layer? Not got any children? Return. if (layer != child.DepthLayer && (child.Children.Count == 0)) continue; //HighPreformanceTimer timer = new HighPreformanceTimer(); GraphicsManager.PushRenderState(); child.Render(transformation, camera, layer); GraphicsManager.PopRenderState(); //if (timer.DurationMillisecond > 2) // System.Console.WriteLine(child.ToString() + " (" + ((child as EntityNode) != null ? (((EntityNode)child).Image != null ? ((EntityNode)child).Image.URL : "") + "," + ((EntityNode)child).RenderMode : "") + ") - Rendered in " + timer.DurationMillisecond); } }
/// <summary> /// Called when the selector tool is selected and an event has been recieved. /// </summary> /// <param name="firedEvent">Event that caused this update to be called.</param> public void UpdateSelector(Event firedEvent) { if (firedEvent.ID == "mouse_move" && InputManager.KeyDown(KeyCodes.LeftMouse)) { if (_toolMoving == true) { _toolMovementDimensions.Width = InputManager.MouseX - _toolMovementDimensions.X; _toolMovementDimensions.Height = InputManager.MouseY - _toolMovementDimensions.Y; } else if (_movingObject == true) { ArrayList groupsMoved = new ArrayList(); foreach (EntityNode iterationEntity in _selectedEntityList) { if (iterationEntity.Parent != null && iterationEntity.Parent as GroupNode != null && groupsMoved.Contains(iterationEntity.Parent) == true) continue; EntityNode entity = (iterationEntity.Parent != null && iterationEntity.Parent as GroupNode != null) ? (GroupNode)iterationEntity.Parent : iterationEntity; entity.Move(_xAxisLocked == true ? 0.0f : ((InputManager.MouseX - _moveObjectDimensions.X) / Editor.GlobalInstance.CameraNode.Zoom), _yAxisLocked == true ? 0.0f : ((InputManager.MouseY - _moveObjectDimensions.Y) / Editor.GlobalInstance.CameraNode.Zoom), 0.0f); if (iterationEntity.Parent != null && iterationEntity.Parent as GroupNode != null) groupsMoved.Add(iterationEntity.Parent); } _moveObjectDimensions.X = InputManager.MouseX; _moveObjectDimensions.Y = InputManager.MouseY; _mapChangedSinceSave = true; } else if (_sizingObject == true) { int movementX = _xAxisLocked == true ? 0 : (int)((InputManager.MouseX - _moveObjectDimensions.X) / Editor.GlobalInstance.CameraNode.Zoom), movementY = _yAxisLocked == true ? 0 : (int)((InputManager.MouseY - _moveObjectDimensions.Y) / Editor.GlobalInstance.CameraNode.Zoom); _objectToSize.BoundingRectangle = _objectSizeOriginalBoundingBox; _objectToSize.Transformation = _objectSizeOriginalTransformation; if ((_sizingDirection & SizingDirection.Top) != 0) { _objectToSize.Resize(_objectToSize.BoundingRectangle.Width, Math.Max(_objectToSize.BoundingRectangle.Height + -movementY,_gridHeight)); _objectToSize.Position(_objectToSize.Transformation.X, _objectToSize.Transformation.Y + -(_objectToSize.BoundingRectangle.Height - _objectSizeOriginalBoundingBox.Height), _objectToSize.Transformation.Z); } if ((_sizingDirection & SizingDirection.Left) != 0) { _objectToSize.Resize(Math.Max(_objectToSize.BoundingRectangle.Width + -movementX, _gridWidth), _objectToSize.BoundingRectangle.Height); _objectToSize.Position(_objectToSize.Transformation.X + -(_objectToSize.BoundingRectangle.Width - _objectSizeOriginalBoundingBox.Width), _objectToSize.Transformation.Y, _objectToSize.Transformation.Z); } if ((_sizingDirection & SizingDirection.Bottom) != 0) _objectToSize.Resize(_objectToSize.BoundingRectangle.Width, Math.Max(_objectToSize.BoundingRectangle.Height + movementY, _gridHeight)); if ((_sizingDirection & SizingDirection.Right) != 0) _objectToSize.Resize(Math.Max(_objectToSize.BoundingRectangle.Width + movementX, _gridWidth), _objectToSize.BoundingRectangle.Height); _mapChangedSinceSave = true; } } else if (firedEvent.ID == "key_pressed" && ((InputEventData)firedEvent.Data).KeyCode == KeyCodes.LeftMouse) { bool touchingSizingPoint = false; Rectangle mouseRectangle = new Rectangle(InputManager.MouseX, InputManager.MouseY, 1, 1); foreach (EntityNode node in _selectedEntityList) if (node.RectangleSizingPointsIntersect(mouseRectangle, Editor.GlobalInstance.CameraNode)) touchingSizingPoint = true; // Was last click in same spot? If so we want to select the new object. if (touchingSizingPoint == false && ((_toolMovementDimensions.X == InputManager.MouseX && _toolMovementDimensions.Y == InputManager.MouseY) || (_toolMovementDimensions.Width == 0 || _toolMovementDimensions.Height == 0))) { if (InputManager.KeyDown(KeyCodes.LeftControl)) { Rectangle intersectRectangle = new Rectangle(InputManager.MouseX, InputManager.MouseY, 1, 1); foreach (SceneNode node in Engine.Engine.GlobalInstance.Map.SceneGraph.EnumerateNodes()) { EntityNode entity = node as EntityNode; if (entity == null) continue; if (entity.RectangleBoundingBoxIntersect(intersectRectangle, Editor.GlobalInstance.CameraNode) == true) { if (_selectedEntityList.Contains(entity)) RemoveEntityFromSelection(entity); else AddEntityToSelection(entity); break; } } SyncronizeWindow(); } else { Rectangle intersectRectangle = new Rectangle(InputManager.MouseX, InputManager.MouseY, 1, 1); bool canSelect = (_selectedEntityList.Count == 0); EntityNode selectEntity = null, firstEntity = null; foreach (SceneNode node in Engine.Engine.GlobalInstance.Map.SceneGraph.EnumerateNodes()) { EntityNode entity = node as EntityNode; if (entity == null) continue; if (entity.RectangleBoundingBoxIntersect(intersectRectangle, Editor.GlobalInstance.CameraNode) == true) { if (canSelect == true) { selectEntity = entity; break; } else if (firstEntity != null) firstEntity = entity; if (_selectedEntityList.Contains(entity)) canSelect = true; } } if (selectEntity == null) selectEntity = firstEntity; ClearSelection(); if (selectEntity != null) { AddEntityToSelection(selectEntity); SyncronizeWindow(); } _movingObject = true; _moveObjectDimensions.X = InputManager.MouseX; _moveObjectDimensions.Y = InputManager.MouseY; } } else { ArrayList removeList = new ArrayList(); Rectangle intersectRectangle = new Rectangle(InputManager.MouseX, InputManager.MouseY, 1, 1); foreach (SceneNode node in Engine.Engine.GlobalInstance.Map.SceneGraph.EnumerateNodes()) { EntityNode entity = node as EntityNode; if (entity == null) continue; if (entity.RectangleBoundingBoxIntersect(intersectRectangle, Editor.GlobalInstance.CameraNode) == false && entity.RectangleSizingPointsIntersect(intersectRectangle, Editor.GlobalInstance.CameraNode) == false) removeList.Add(entity); } if (!InputManager.KeyDown(KeyCodes.LeftControl)) { foreach (EntityNode entity in removeList) RemoveEntityFromSelection(entity); } _movingObject = true; _moveObjectDimensions.X = InputManager.MouseX; _moveObjectDimensions.Y = InputManager.MouseY; } // Lets select an object or size one. foreach (EntityNode entity in _selectedEntityList) { Transformation transformation = entity.CalculateTransformation(Editor.GlobalInstance.CameraNode); int x = (int)(transformation.X - (entity.SizingPointsSize / 2)), y = (int)(transformation.Y - (entity.SizingPointsSize / 2)); int w = (int)(entity.BoundingRectangle.Width * Editor.GlobalInstance.CameraNode.Zoom), h = (int)(entity.BoundingRectangle.Height * Editor.GlobalInstance.CameraNode.Zoom); bool previousMoving = _movingObject; _movingObject = false; _sizingObject = true; _objectToSize = entity; _objectSizeOriginalBoundingBox = _objectToSize.BoundingRectangle; _objectSizeOriginalTransformation = _objectToSize.Transformation; if (mouseRectangle.IntersectsWith(new Rectangle(x, y, entity.SizingPointsSize, entity.SizingPointsSize))) { _sizingDirection = SizingDirection.Top | SizingDirection.Left; Cursor = Cursors.SizeNWSE; } else if (mouseRectangle.IntersectsWith(new Rectangle(x + w, y, entity.SizingPointsSize, entity.SizingPointsSize))) { _sizingDirection = SizingDirection.Top | SizingDirection.Right; Cursor = Cursors.SizeNESW; } else if (mouseRectangle.IntersectsWith(new Rectangle(x, y + h, entity.SizingPointsSize, entity.SizingPointsSize))) { _sizingDirection = SizingDirection.Bottom | SizingDirection.Left; Cursor = Cursors.SizeNESW; } else if (mouseRectangle.IntersectsWith(new Rectangle(x + w, y + h, entity.SizingPointsSize, entity.SizingPointsSize))) { _sizingDirection = SizingDirection.Bottom | SizingDirection.Right; Cursor = Cursors.SizeNWSE; } else if (mouseRectangle.IntersectsWith(new Rectangle(x + (w / 2), y, entity.SizingPointsSize, entity.SizingPointsSize))) { _sizingDirection = SizingDirection.Top; Cursor = Cursors.SizeNS; } else if (mouseRectangle.IntersectsWith(new Rectangle(x + (w / 2), y + h, entity.SizingPointsSize, entity.SizingPointsSize))) { _sizingDirection = SizingDirection.Bottom; Cursor = Cursors.SizeNS; } else if (mouseRectangle.IntersectsWith(new Rectangle(x, y + (h / 2), entity.SizingPointsSize, entity.SizingPointsSize))) { _sizingDirection = SizingDirection.Left; Cursor = Cursors.SizeWE; } else if (mouseRectangle.IntersectsWith(new Rectangle(x + w, y + (h / 2), entity.SizingPointsSize, entity.SizingPointsSize))) { _sizingDirection = SizingDirection.Right; Cursor = Cursors.SizeWE; } else { _sizingObject = false; _objectToSize = null; _movingObject = previousMoving; } } // If we are holding shift then we want to select multiple objects. if (InputManager.KeyDown(KeyCodes.LeftShift)) { _movingObject = false; _sizingObject = false; _toolMoving = true; } // Log the original transformations of the selected nodes. _originalEntityTransformations.Clear(); _originalEntityBoundingBoxs.Clear(); foreach (EntityNode entity in _selectedEntityList) { _originalEntityTransformations.Add(entity, entity.Transformation); _originalEntityBoundingBoxs.Add(entity, entity.BoundingRectangle); } _toolMovementDimensions.X = InputManager.MouseX; _toolMovementDimensions.Y = InputManager.MouseY; _toolMovementDimensions.Width = _selectedEntityList.Count > 0 ? 1 : 0; _toolMovementDimensions.Height = _selectedEntityList.Count > 0 ? 1 : 0; } else if (firedEvent.ID == "key_released" && ((InputEventData)firedEvent.Data).KeyCode == KeyCodes.LeftMouse) { if (_toolMoving == true) { _toolMoving = false; // Create a rectangle from which we can check intersection against. Rectangle intersectRectangle = new Rectangle(); // If we have a negative width then make it positive. if (_toolMovementDimensions.Width < 0) { intersectRectangle.X = _toolMovementDimensions.X + _toolMovementDimensions.Width; intersectRectangle.Width = Math.Abs(_toolMovementDimensions.Width); } else { intersectRectangle.X = _toolMovementDimensions.X; intersectRectangle.Width = _toolMovementDimensions.Width; } // If we have a negative height then make it positive. if (_toolMovementDimensions.Height < 0) { intersectRectangle.Y = _toolMovementDimensions.Y + _toolMovementDimensions.Height; intersectRectangle.Height = Math.Abs(_toolMovementDimensions.Height); } else { intersectRectangle.Y = _toolMovementDimensions.Y; intersectRectangle.Height = _toolMovementDimensions.Height; } // Unselect all the pervious entitys. ArrayList oldSelectionList = new ArrayList(); oldSelectionList.AddRange(_selectedEntityList); // Clear out old selection. if (InputManager.KeyDown(KeyCodes.LeftControl) == false) ClearSelection(); // Grab all the entitys within our selection rectangle and select them. bool canSelect = (oldSelectionList.Count == 0 || !(intersectRectangle.Width < 2 && intersectRectangle.Height < 2)); EntityNode selectEntity = null; foreach (SceneNode node in Engine.Engine.GlobalInstance.Map.SceneGraph.EnumerateNodes()) { EntityNode entity = node as EntityNode; if (entity == null) continue; if (entity.RectangleBoundingBoxIntersect(intersectRectangle, Editor.GlobalInstance.CameraNode) == true) { if (canSelect == true) { AddEntityToSelection(entity); if (intersectRectangle.Width < 2 && intersectRectangle.Height < 2) break; } else if (selectEntity == null) selectEntity = entity; if (oldSelectionList.Contains(entity)) canSelect = true; } } if (canSelect == false && selectEntity != null) AddEntityToSelection(selectEntity); } else if (_movingObject == true) { // Snap the objects to the grid. if (_snapToGrid == true) { foreach (EntityNode entity in _selectedEntityList) { entity.Position(((int)entity.Transformation.X / _gridWidth) * _gridWidth, ((int)entity.Transformation.Y / _gridHeight) * _gridHeight, entity.Transformation.Z); // Create a new transformation undo operation if transformation has changed. Transformation originalTransformation = (Transformation)_originalEntityTransformations[entity]; if (originalTransformation != entity.Transformation) PushUndoOperation(new TransformNodeUndoOperation(entity, originalTransformation, entity.Transformation)); } _originalEntityTransformations.Clear(); if (_entityPropertiesWindow != null && _entityPropertiesWindow.Entity != null) _entityPropertiesWindow.UpdateProperty("location", new Point((int)_entityPropertiesWindow.Entity.Transformation.X, (int)_entityPropertiesWindow.Entity.Transformation.Y)); } _movingObject = false; _mapChangedSinceSave = true; } else if (_sizingObject == true) { if (_snapToGrid == true) { _objectToSize.Position(((int)_objectToSize.Transformation.X / _gridWidth) * _gridWidth, ((int)_objectToSize.Transformation.Y / _gridHeight) * _gridHeight, _objectToSize.Transformation.Z); _objectToSize.BoundingRectangle = new Rectangle(_objectToSize.BoundingRectangle.X, _objectToSize.BoundingRectangle.Y, ((int)_objectToSize.BoundingRectangle.Width / _gridWidth) * _gridWidth, ((int)_objectToSize.BoundingRectangle.Height / _gridHeight) * _gridHeight); Rectangle newBoundingRectangle = _objectToSize.BoundingRectangle; if (newBoundingRectangle.Width < _gridWidth) newBoundingRectangle.Width = _gridWidth; if (newBoundingRectangle.Height < _gridHeight) newBoundingRectangle.Height = _gridHeight; _objectToSize.BoundingRectangle = newBoundingRectangle; // Create a new sizing undo operation if size has changed. Rectangle originalBoundingBox = (Rectangle)_originalEntityBoundingBoxs[_objectToSize]; if (!_objectToSize.BoundingRectangle.Equals(originalBoundingBox)) PushUndoOperation(new ResizeNodeUndoOperation(_objectToSize, originalBoundingBox, (Transformation)_originalEntityTransformations[_objectToSize], _objectToSize.BoundingRectangle, _objectToSize.Transformation)); } if (_entityPropertiesWindow != null && _entityPropertiesWindow.Entity != null) { _entityPropertiesWindow.UpdateProperty("bounding rectangle", new Rectangle(_entityPropertiesWindow.Entity.BoundingRectangle.X, _entityPropertiesWindow.Entity.BoundingRectangle.Y, _entityPropertiesWindow.Entity.BoundingRectangle.Width, _entityPropertiesWindow.Entity.BoundingRectangle.Height)); _entityPropertiesWindow.UpdateProperty("collision rectangle", new Rectangle(_entityPropertiesWindow.Entity.CollisionRectangle.X, _entityPropertiesWindow.Entity.CollisionRectangle.Y, _entityPropertiesWindow.Entity.CollisionRectangle.Width, _entityPropertiesWindow.Entity.CollisionRectangle.Height)); } Cursor = Cursors.Arrow; _sizingObject = false; _mapChangedSinceSave = true; } SyncronizeWindow(); } }
/// <summary> /// Renders this entity at a position releative to its parent. /// </summary> /// <param name="position">Position where this entity's parent node was rendered.</param> public override void Render(Transformation transformation, CameraNode camera, int layer) { if (layer == _depthLayer && _process != null && _process.Process != null && _renderFunction != null) _process.Process[0].InvokeFunction(_renderFunction, true, true, true); base.Render(transformation, camera, layer); }
/// <summary> /// Calculates this entitys relative transformation to another transformation. /// </summary> /// <param name="transformation">Transformation to calculate relative transformation from.</param> /// <returns>Transfromation relative to the given transfromation.</returns> public override Transformation CalculateRelativeTransformation(Transformation transformation) { Transformation newTransform = new Transformation(); newTransform.AngleX = transformation.AngleX + _transformation.AngleX; newTransform.AngleY = transformation.AngleY + _transformation.AngleY; newTransform.AngleZ = transformation.AngleZ + _transformation.AngleZ; newTransform.ScaleX = (transformation.ScaleX + (_transformation.ScaleX - 1.0f)) + (_zoom - 1.0f); newTransform.ScaleY = (transformation.ScaleY + (_transformation.ScaleY - 1.0f)) + (_zoom - 1.0f); newTransform.ScaleZ = (transformation.ScaleZ + (_transformation.ScaleZ - 1.0f)) + (_zoom - 1.0f); newTransform.X = (float)Math.Ceiling(((transformation.X - (_transformation.X + _transformationOffset.X)) * newTransform.ScaleX) + _viewport.X); newTransform.Y = (float)Math.Ceiling(((transformation.Y - (_transformation.Y + _transformationOffset.Y)) * newTransform.ScaleY) + _viewport.Y); newTransform.Z = transformation.Z + (_transformation.Z + _transformationOffset.Z); return newTransform; }