コード例 #1
0
ファイル: View.cs プロジェクト: villermen/hatless-engine
 /// <summary>
 /// See individual fields for explanation on what they are and how to use them.
 /// </summary>
 public View(string id, Rectangle area, Rectangle viewport, bool active = true)
     : base(id)
 {
     GameArea = area;
     Viewport = viewport;
     Active = active;
 }
コード例 #2
0
ファイル: Polygon.cs プロジェクト: villermen/hatless-engine
        protected override void Recalculate()
        {
            float minX = float.PositiveInfinity, minY = float.PositiveInfinity, maxX = float.NegativeInfinity, maxY = float.NegativeInfinity;

            for (int i = 0; i < _basePoints.Length; i++)
            {
                Points[i] = _Position + _basePoints[i].RotateOverOrigin(Point.Zero, _Rotation) * _Size;

                if (Points[i].X < minX)
                    minX = Points[i].X;
                if (Points[i].Y < minY)
                    minY = Points[i].Y;
                if (Points[i].X > maxX)
                    maxX = Points[i].X;
                if (Points[i].Y > maxY)
                    maxY = Points[i].Y;

                if (i < _basePoints.Length - 1)
                    BoundLines[i] = new Line(Points[i], Points[i + 1]);
                else
                    BoundLines[i] = new Line(Points[i], Points[0]);

                PerpAxes[i] = BoundLines[i].GetPerpAxes()[0];
            }

            EnclosingRectangle = new Rectangle(minX, minY, maxX - minX, maxY - minY);

            Changed = false;
        }
コード例 #3
0
ファイル: Sprite.cs プロジェクト: villermen/hatless-engine
        /// <summary>
        /// Draw the sprite projected on a rectangle.
        /// </summary>
        public void Draw(ComplexRectangle rect, int frameIndex = 0, int depth = 0)
        {
            if (!Loaded)
                throw new NotLoadedException();

            Rectangle sourceRect = new Rectangle(GetIndexLocation(frameIndex), FrameSize);
            DrawX.DrawJobs.Add(new TextureDrawJob(depth, rect.GetEnclosingRectangle(), TextureHandle, sourceRect, rect));
        }
コード例 #4
0
        /// <summary>
        /// Texture job.
        /// </summary>
        public TextureDrawJob(int depth, Rectangle area, IntPtr texture, Rectangle sourceRect, ComplexRectangle destRect)
            : this()
        {
            Texture = texture;
            SourceRect = sourceRect;
            DestRect = destRect;

            Depth = depth;
            Area = area;
        }
コード例 #5
0
ファイル: QuadTree.cs プロジェクト: villermen/hatless-engine
        /// <summary>
        /// A teensy quadtree baby.
        /// </summary>
        private QuadTree(byte level, Rectangle bounds, List<PhysicalObject> objects)
        {
            byte level1 = level;
            Rectangle bounds1 = bounds;
            _center = bounds.Position + bounds.Size / 2f;
            Point childSize = bounds.Size / 2f;

            if (objects.Count > MaxObjects)
            {
                //decide in what childtree an object would fit and add it there
                List<PhysicalObject> childObjects0 = new List<PhysicalObject>();
                List<PhysicalObject> childObjects1 = new List<PhysicalObject>();
                List<PhysicalObject> childObjects2 = new List<PhysicalObject>();
                List<PhysicalObject> childObjects3 = new List<PhysicalObject>();

                foreach (PhysicalObject obj in objects)
                {
                    bool[] fits = FitObject(obj);
                    if (!fits[4])
                    {
                        if (fits[0])
                            childObjects0.Add(obj);
                        else if (fits[1])
                            childObjects1.Add(obj);
                        else if (fits[2])
                            childObjects2.Add(obj);
                        else
                            childObjects3.Add(obj);
                    }
                    else
                        _objects.Add(obj);
                }

                //create subtrees and add everything that fits inside of em
                _children[0] = new QuadTree((byte)(level1 + 1), new Rectangle(bounds1.Position, childSize), childObjects0);
                _children[1] = new QuadTree((byte)(level1 + 1), new Rectangle(new Point(_center.X, bounds1.Position.Y), childSize), childObjects1);
                _children[2] = new QuadTree((byte)(level1 + 1), new Rectangle(new Point(bounds1.Position.X, _center.Y), childSize), childObjects2);
                _children[3] = new QuadTree((byte)(level1 + 1), new Rectangle(_center, childSize), childObjects3);
            }
            else
                _objects = objects;
        }
コード例 #6
0
ファイル: Game.cs プロジェクト: villermen/hatless-engine
        private static void Draw()
        {
            //collect drawjobs
            foreach (GameObject obj in Resources.Objects)
            {
                if (!obj.Destroyed)
                    obj.Draw();
            }

            DrawX.DrawJobs = DrawX.DrawJobs.OrderBy(job => job.Depth).ToList();

            SDL.SDL_SetRenderDrawColor(RendererHandle, DrawX.BackgroundColor.R, DrawX.BackgroundColor.G, DrawX.BackgroundColor.B, DrawX.BackgroundColor.A);
            SDL.SDL_RenderClear(RendererHandle);

            foreach (View view in Resources.Get<View>())
            {
                if (!view.Active)
                    continue;

                Rectangle absoluteGameArea = view.GetAbsoluteGameArea();
                Rectangle absoluteViewport = view.GetAbsoluteViewport();

                Point scale = view.GetScale();

                SDL.SDL_RenderSetScale(RendererHandle, scale.X, scale.Y);

                //viewport is affected by scale for whatever reason, correct it
                Rectangle scaledViewport = new Rectangle(absoluteViewport);
                scaledViewport.Position /= scale;
                scaledViewport.Size /= scale;
                SDL.SDL_Rect sdlViewport = (SDL.SDL_Rect)scaledViewport;
                SDL.SDL_RenderSetViewport(RendererHandle, ref sdlViewport);

                //get all jobs that will draw inside this view
                foreach (IDrawJob job in DrawX.GetDrawJobsByArea(absoluteGameArea))
                {
                    Type jobType = job.GetType();

                    if (jobType == typeof(TextureDrawJob)) //draw a texture
                    {
                        TextureDrawJob textureDrawJob = (TextureDrawJob)job;
                        SDL.SDL_Rect sourceRect = (SDL.SDL_Rect)textureDrawJob.SourceRect;
                        SDL.SDL_Rect destRect = (SDL.SDL_Rect)new Rectangle(textureDrawJob.DestRect.Position - absoluteGameArea.Position - textureDrawJob.DestRect.Origin, textureDrawJob.DestRect.Size);

                        if (textureDrawJob.DestRect.Rotation == 0f)
                            SDL.SDL_RenderCopy(RendererHandle, textureDrawJob.Texture, ref sourceRect, ref destRect);
                        else
                        {
                            SDL.SDL_Point origin = (SDL.SDL_Point)textureDrawJob.DestRect.Origin;
                            SDL.SDL_RenderCopyEx(RendererHandle, textureDrawJob.Texture, ref sourceRect, ref destRect, textureDrawJob.DestRect.Rotation, ref origin, SDL.SDL_RendererFlip.SDL_FLIP_NONE);
                        }
                    }
                    else if (jobType == typeof(LineDrawJob)) //draw line(s)
                    {
                        LineDrawJob lineDrawJob = (LineDrawJob)job;

                        //transform all points according to view and cast em
                        SDL.SDL_Point[] sdlPoints = Array.ConvertAll(lineDrawJob.Points, point => (SDL.SDL_Point)(point - absoluteGameArea.Position));

                        SDL.SDL_SetRenderDrawColor(RendererHandle, lineDrawJob.Color.R, lineDrawJob.Color.G, lineDrawJob.Color.B, lineDrawJob.Color.A);
                        SDL.SDL_RenderDrawLines(RendererHandle, sdlPoints, lineDrawJob.PointCount);
                    }
                    else //draw filledrect
                    {
                        FilledRectDrawJob rectDrawJob = (FilledRectDrawJob)job;

                        SDL.SDL_Rect rect = (SDL.SDL_Rect)(rectDrawJob.Area - absoluteGameArea.Position);

                        SDL.SDL_SetRenderDrawColor(RendererHandle, rectDrawJob.Color.R, rectDrawJob.Color.G, rectDrawJob.Color.B, rectDrawJob.Color.A);
                        SDL.SDL_RenderFillRect(RendererHandle, ref rect);
                    }
                }
            }

            DrawX.DrawJobs.Clear();

            //threadpool should take care of actually swapping the frames (RenderPresent may wait for things like Fraps or VSync)
            RenderframeReady = true;
            ThreadPool.QueueUserWorkItem(PresentRender);
        }
コード例 #7
0
        protected override void Recalculate()
        {
            Points[0] = new Point(_Position.X - _origin.X, _Position.Y - _origin.Y).RotateOverOrigin(_Position, _Rotation);
            Points[1] = new Point(_Position.X - _origin.X + _Size.X, _Position.Y - _origin.Y).RotateOverOrigin(_Position, _Rotation);
            Points[2] = new Point(_Position.X - _origin.X + _Size.X, _Position.Y - _origin.Y + _Size.Y).RotateOverOrigin(_Position, _Rotation);
            Points[3] = new Point(_Position.X - _origin.X, _Position.Y - _origin.Y + _Size.Y).RotateOverOrigin(_Position, _Rotation);

            PerpAxes[0] = new Point((-Points[1].Y + Points[0].Y) / _Size.X, (Points[1].X - Points[0].X) / _Size.X);
            PerpAxes[1] = new Point((-Points[2].Y + Points[1].Y) / _Size.Y, (Points[2].X - Points[1].X) / _Size.Y);
            PerpAxes[2] = PerpAxes[0];
            PerpAxes[3] = PerpAxes[1];

            float minX = float.PositiveInfinity, minY = float.PositiveInfinity, maxX = float.NegativeInfinity, maxY = float.NegativeInfinity;
            foreach (Point p in Points)
            {
                if (p.X < minX)
                    minX = p.X;
                if (p.Y < minY)
                    minY = p.Y;
                if (p.X > maxX)
                    maxX = p.X;
                if (p.Y > maxY)
                    maxY = p.Y;
            }
            EnclosingRectangle = new Rectangle(minX, minY, maxX - minX, maxY - minY);

            BoundLines =  new Line[]
            {
                new Line(Points[0], Points[1]),
                new Line(Points[1], Points[2]),
                new Line(Points[2], Points[3]),
                new Line(Points[3], Points[0])
            };

            Changed = false;
        }
コード例 #8
0
ファイル: Rectangle.cs プロジェクト: villermen/hatless-engine
 public Rectangle(Rectangle rect)
     : this(rect._Position, rect._Size)
 {
 }
コード例 #9
0
ファイル: QuadTree.cs プロジェクト: villermen/hatless-engine
 /// <summary>
 /// The mother of all quadtrees.
 /// </summary>
 public QuadTree(Rectangle bounds)
     : this(0, bounds, Resources.PhysicalObjects)
 {
 }
コード例 #10
0
        /// <summary>
        /// Sets the area the bounds could maximally cover with the current SpeedVelocity (any direction).
        /// Rectangle on x and y axes.
        /// </summary>
        internal void UpdateCoverableArea()
        {
            float minX = float.PositiveInfinity;
            float minY = float.PositiveInfinity;
            float maxX = float.NegativeInfinity;
            float maxY = float.NegativeInfinity;
            float speed = SpeedVelocity;

            foreach (Point pnt in Bounds.GetPoints())
            {
                if (pnt.X < minX)
                    minX = pnt.X;
                if (pnt.X > maxX)
                    maxX = pnt.X;
                if (pnt.Y < minY)
                    minY = pnt.Y;
                if (pnt.Y > maxY)
                    maxY = pnt.Y;
            }

            CoverableArea = new Rectangle(minX - speed, minY - speed, maxX - minX + speed, maxY - minY + speed);
        }
コード例 #11
0
ファイル: Line.cs プロジェクト: villermen/hatless-engine
        protected override void Recalculate()
        {
            Points[0] = _Position;
            Points[1] = _Position + _Size;

            PerpAxes[0] = new Point((-Point2.Y + Point1.Y) / Length, (Point2.X - Point1.X) / Length);

            float minX = float.PositiveInfinity, minY = float.PositiveInfinity, maxX = float.NegativeInfinity, maxY = float.NegativeInfinity;
            foreach (Point p in Points)
            {
                if (p.X < minX)
                    minX = p.X;
                if (p.Y < minY)
                    minY = p.Y;
                if (p.X > maxX)
                    maxX = p.X;
                if (p.Y > maxY)
                    maxY = p.Y;
            }
            EnclosingRectangle = new Rectangle(minX, minY, maxX - minX, maxY - minY);

            Changed = false;
        }
コード例 #12
0
ファイル: DrawX.cs プロジェクト: villermen/hatless-engine
 internal static List<IDrawJob> GetDrawJobsByArea(Rectangle area)
 {
     return DrawJobs.FindAll(j => j.Area.IntersectsWith(area));
 }
コード例 #13
0
ファイル: DrawX.cs プロジェクト: villermen/hatless-engine
 public static void DrawFilledRect(Rectangle rect, Color color, int depth = 0)
 {
     DrawJobs.Add(new FilledRectDrawJob(depth, rect, color));
 }