protected override void Update(GameTime gameTime)
        {
            // Allows the game to exit
            if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
            {
                this.Exit();
            }

            KeyboardState keys             = Keyboard.GetState();
            JVector       moveVector       = JVector.Zero;
            float         amountOfMovement = 0.05f;

            if (keys.IsKeyDown(Keys.Right))
            {
                moveVector.X += amountOfMovement;
            }
            if (keys.IsKeyDown(Keys.Left))
            {
                moveVector.X -= amountOfMovement;
            }
            if (keys.IsKeyDown(Keys.Down))
            {
                moveVector.Y -= amountOfMovement;
            }
            if (keys.IsKeyDown(Keys.Up))
            {
                moveVector.Y += amountOfMovement;
            }

            body1.Position += moveVector;

            body1.Orientation += 0.001f;
            body2.Orientation -= 0.001f;

            float   o1   = body1.Orientation;
            float   o2   = body2.Orientation;
            JVector pos1 = body1.Position;
            JVector pos2 = body2.Position;

            sw.Start();
            hit = Collision.Detect(DebugDrawer, body1.Shape, body2.Shape, ref o1, ref o2, ref pos1, ref pos2, out point, out normal, out penetration, out iterations);
            sw.Stop();

            ticks = sw.ElapsedTicks;
            sw.Reset();

            DebugDrawer.DrawPoint(point);
            DebugDrawer.Color = Color.Red;
            DebugDrawer.DrawLine(point, point + JVector.Normalize(normal) * penetration);

            DebugDrawer.Color = Color.Black;
            DebugDrawer.DrawLine(JVector.Up, JVector.Down);
            DebugDrawer.DrawLine(JVector.Left, JVector.Right);

            body1.DebugDraw(DebugDrawer);
            body2.DebugDraw(DebugDrawer);

            if (hit)
            {
                var oldPosition = body1.Position;

                body1.Position -= normal * penetration;
                body1.DebugDraw(DebugDrawer);
                body1.Position = oldPosition;
            }

            base.Update(gameTime);
        }
コード例 #2
0
        private void RenderPass(Program program)
        {
            if (Model.RenderModel == null)
            {
                return;
            }
            if (program.Name != "system")
            {
                using (program.Use())
                {
                    var extents = Model.RenderModel.compressionInfo[0].ToExtentsMatrix();
                    program.SetAttribute("objectExtents", extents);
                    program.SetAttribute("colour", Selected ? Color.Yellow.ToFloatRgba() : Color.LightCoral.ToFloatRgba());
                    foreach (var region in Model.RenderModel.regions)
                    {
                        var section_index = region.permutations[0].l6SectionIndexHollywood;
                        var mesh          = sectionBuffers[section_index];
                        using (mesh.Bind())
                        {
                            GL.UseProgram(program.ID);
                            foreach (var part in mesh.Parts)
                            {
                                GL.DrawElements(PrimitiveType.TriangleStrip, part.stripLength, DrawElementsType.UnsignedShort,
                                                (IntPtr)(part.stripStartIndex * 2)); OpenGL.ReportError();
                            }
                        }
                    }
                }
            }
            if (program.Name == "system")
            {
                using (program.Use())
                    using (OpenGL.Disable(EnableCap.DepthTest))
                    {
                        foreach (var markerGroup in Model.RenderModel.markerGroups)
                        {
                            foreach (var marker in markerGroup.markers)
                            {
                                var nodeIndex   = marker.nodeIndex;
                                var translation = marker.translation;
                                var rotation    = marker.rotation;
                                var scale       = marker.scale;

                                var worldMatrix = this.Nodes.GetWorldMatrix(nodeIndex);

                                program[Uniforms.WorldMatrix] = worldMatrix;

                                if (selectedObjects.Contains(marker))
                                {
                                    GL.VertexAttrib3(1, Color.Black.ToFloatRgba());
                                    DebugDrawer.DrawPoint(translation, 7);
                                    GL.VertexAttrib3(1, Color.Tomato.ToFloatRgba());
                                    DebugDrawer.DrawPoint(translation, 4);
                                }
                                else
                                {
                                    GL.VertexAttrib3(1, Color.White.ToFloatRgba());
                                    DebugDrawer.DrawPoint(translation, 7);
                                    GL.VertexAttrib3(1, Color.SkyBlue.ToFloatRgba());
                                    DebugDrawer.DrawPoint(translation, 3);
                                }

                                DebugDrawer.DrawPoint(translation, 5);
                            }
                        }
                    }
            }
        }
コード例 #3
0
    private static unsafe void DrawTests(int threadIndex, float3 start, float3 end, NativeString512 text, DrawingMethods methods, NativeArray <float3> polygon)
    {
        float3 offset = Vector3.up * 0.05f + Vector3.left * 0.05f;
        float3 center = (start + (end - start) / 2);

        if (methods.Sphere)
        {
            DebugDrawer.DrawSphere(start, 0.75f, UnityColors.GhostDodgerBlue);
        }

        if (methods.RectangleWithOutline)
        {
            var size   = 0.25f;
            var points = stackalloc[]
            {
                center + offset + new float3(0, 0, 0),
                center + offset + new float3(0, size, 0),
                center + offset + new float3(0, size, size),
                center + offset + new float3(0, 0, size)
            };

            DebugDrawer.DrawSolidRectangleWithOutline(points, UnityColors.LightYellow, UnityColors.Yellow);
        }

        if (methods.Polygon)
        {
            DebugDrawer.DrawAAConvexPolygon(polygon, center + (float3)Vector3.down * 0.25f, UnityColors.GhostDodgerBlue);
        }

        if (methods.Line)
        {
            DebugDrawer.DrawLine(start + offset, end + offset);
        }

        if (methods.Ray)
        {
            DebugDrawer.DrawRay(center, Vector3.up, UnityColors.MediumBlue);
        }

        if (methods.Cone)
        {
            DebugDrawer.DrawCone(center + (float3)Vector3.up * 0.5f, Vector3.up, UnityColors.DarkKhaki, 22.5f);
        }

        if (methods.Circle)
        {
            DebugDrawer.DrawCircle(center, Vector3.up, 0.25f, UnityColors.AliceBlue);
        }

        if (methods.DottedLine)
        {
            DebugDrawer.DrawDottedLine(start, end, Color.yellow);
        }

        if (methods.WireCube)
        {
            DebugDrawer.DrawWireCube(end, Vector3.one / 2, Color.yellow);
        }

        if (methods.DottedWireCube)
        {
            DebugDrawer.DrawDottedWireCube(end, Vector3.one, Color.black);
        }

        if (methods.Label)
        {
            DebugDrawer.DrawLabel(center + (float3)Vector3.down * 0.25f, text);
        }

        if (methods.Arrow)
        {
            DebugDrawer.DrawArrow(start + (float3)Vector3.up * 0.5f, Vector3.up, Color.blue);
        }

        if (methods.Log)
        {
            DebugDrawer.Log(threadIndex, text);
        }

        if (methods.LogWarning)
        {
            DebugDrawer.LogWarning(text);
        }

        if (methods.LogError)
        {
            DebugDrawer.LogError(text);
        }

        if (methods.Point)
        {
            DebugDrawer.DrawPoint(center + (float3)Vector3.forward, UnityColors.Lavender, 0.25f);
        }
    }
}