C# RenderManager类代码示例

        public static void Render(RenderManager.CameraInfo cameraInfo, AngleMeasurement angle)
        {
            if (angle.HideOverlay)
                return;

            var renderManager = RenderManager.instance;

            var centreAngle = Vector3.Angle(Vector3.right, angle.AngleNormal);

            if (Vector3.Cross(Vector3.right, angle.AngleNormal).y > 0f)
                centreAngle = -centreAngle;

            var arcs = BezierUtil.CreateArc(angle.Position, GetAngleDistance(angle.Flags),
                centreAngle - angle.AngleSize*.5f,
                centreAngle + angle.AngleSize*.5f);

            for (var i = 0; i < arcs.Count; i++) {

                var isFirst = i == 0;
                var isLast = i == arcs.Count - 1;

                renderManager.OverlayEffect.DrawBezier(cameraInfo, GetAngleColor(angle.Flags), arcs[i], .7f, 0f, 0f,
                    angle.Position.y - 20f,
                    angle.Position.y + 20f, false, true);

            }
        }

        public Camera(IDataReader state, RenderManager renderManager)
            : base(state)
        {
            addInterface(typeof(ICamera));
            m_renderManager = renderManager;

            m_renderTargetId = new XnaScrapId(state);
            IRenderTarget renderTarget = m_renderManager.getRenderTarget(m_renderTargetId);
            if (renderTarget != null)
            {
                renderTarget.Cameras.Add(this);
            }
            m_fovy = state.ReadSingle();
            m_near = state.ReadSingle();
            m_far = state.ReadSingle();
            m_aspect = state.ReadSingle();

            float f = m_fovy * (float)Math.PI / 180.0f;

            m_projection = Matrix.CreatePerspectiveFieldOfView(f, m_aspect, m_near, m_far);

            m_viewport = new _Viewport(state);

            m_renderManager.Cameras.Add(new XnaScrapId("ImplementCameraNamingYouJerk!"), this);
        }

        public override void Draw(RenderManager renderMgr, Camera camera)
        {
            int xStart = (int)((camera.Center.X - camera.Size.X * 0.5f) / TileWidth);
            int xEnd = (int)(1 + (camera.Center.X + camera.Size.X * 0.5f) / TileWidth);

            var yStart = (int)((camera.Center.Y - camera.Size.Y * 0.5f) / TileHeight);
            var yEnd = (int)(1 + (camera.Center.Y + camera.Size.Y * 0.5f) / TileHeight); ;

            if (xStart < 0)
                xStart = 0;
            if (xEnd > MapWidth - 1)
                xEnd = MapWidth - 1;
            if (yStart < 0)
                yStart = 0;
            if (yEnd > MapHeight - 1)
                yEnd = MapHeight - 1;

            for (var i = xStart; i < xEnd; i++)
            {
                for (var j = yStart; j < yEnd; j++)
                {
                    if (Tiles[i, j].Texture == null)
                        continue;

                    var position = new Vector2f(
                                    TileWidth * i + TileWidth * 0.5f,
                                    TileHeight * j + TileHeight * 0.5f);

                    renderMgr.DrawSprite(Tiles[i, j].Texture, Tiles[i, j].SubImageRect, position + WorldPosition, TileWidth, TileHeight, false, false, Tint, ZIndex);

                }
            }
        }

        public override void RenderGeometry(RenderManager.CameraInfo cameraInfo) {
            base.RenderGeometry(cameraInfo);

            if (isHoveringSegment) {
                m_toolController.RenderCollidingNotifications(cameraInfo, 0, 0);
            }
        }

        public void Draw(RenderManager renderMgr)
        {
            IntRect subImageRect = new IntRect(0, 0, (int) texture.Size.X, (int) texture.Size.Y);
            Vector2f centerPos = new Vector2f(box.Left + box.Width * 0.5f, box.Top + box.Height * 0.5f);

            renderMgr.DrawSprite(texture, subImageRect, centerPos, box.Width, box.Height, false, false, new Color(255, 255, 255, 255), 10000);
        }

 public static void RenderInstance(ref Building b, RenderManager.CameraInfo cameraInfo, ushort buildingID,
     int layerMask)
 {
     if ((b.m_flags & (Building.Flags.Created | Building.Flags.Deleted | Building.Flags.Hidden)) != Building.Flags.Created)
         return;
     BuildingInfo info = b.Info;
     //begin mod
     if (info == null)
     {
         return;
     }
     var ai = info.m_buildingAI;
     if ((layerMask & 1 << info.m_prefabDataLayer) == 0 && !(ai is PlayerBuildingAI || ai is DecorationBuildingAI/* || ai is DummyBuildingAI*/)) //TODO(earalov): do we need to uncomment that?
         //end mod
         return;
     Vector3 point = b.m_position;
     float radius = info.m_renderSize + (float)b.m_baseHeight * 0.5f;
     point.y += (float)(((double)info.m_size.y - (double)b.m_baseHeight) * 0.5);
     if (!cameraInfo.Intersect(point, radius))
         return;
     RenderManager instance = Singleton<RenderManager>.instance;
     uint instanceIndex;
     if (!instance.RequireInstance((uint)buildingID, 1U, out instanceIndex))
         return;
     RenderInstance(ref b, cameraInfo, buildingID, layerMask, info, ref instance.m_instances[(uint)instanceIndex]);
 }

 public GameManagerImpl(Game game)
     : base(game)
 {
     rendererManager = new RenderManager(this);
     collisionManager = new CollisionManager(this);
     logicManager = new LogicManager(this);
 }

        public Quad(int startX,int endX, int startZ, int endZ, Base.Content.Terrain.Terrain terrain, RenderManager renderer)
        {
            _bounds = new QuadBounds
            {
                MinX = startX / terrain.PointsPerMeter,
                MaxX = endX / terrain.PointsPerMeter,
                MinZ = startZ / terrain.PointsPerMeter,
                MaxZ = endZ / terrain.PointsPerMeter,
                MinY = terrain.Height[0],
                MaxY = terrain.Height[0]
            };
            HorizontalCenter = new Vector2(Bounds.MinX + (Bounds.MaxX - Bounds.MinX) / 2, Bounds.MinZ + (Bounds.MaxZ - Bounds.MinZ) / 2);

            int verticesX = endX - startX + 1;
            int verticesZ = endZ - startZ + 1;

            var dataStream = new DataStream(32 * verticesX * verticesZ, true, true);

            for (int i = 0; i < verticesX; i++)
            {
                for (int j = 0; j < verticesZ; j++)
                {
                    //Position
                    int xindex = Math.Min(i + startX, terrain.PointsX - 1);//Clamp to arraybounds if neccessary
                    int zindex = Math.Min(j + startZ, terrain.PointsZ - 1);//(Quadsize needs to be consistent for sharing IndexBuffers)
                    float x = xindex / terrain.PointsPerMeter;
                    float z = zindex / terrain.PointsPerMeter;
                    float y = terrain.Height[xindex * terrain.PointsZ + zindex];
                    dataStream.Write(new Vector3(x, y, z));

                    //Normal
                    float deltax = (terrain.Height[(xindex < terrain.PointsX - 1 ? xindex + 1 : xindex) * terrain.PointsZ + zindex]
                        - terrain.Height[(xindex != 0 ? xindex - 1 : xindex) * terrain.PointsZ + zindex]);

                    float deltaz = (terrain.Height[xindex * terrain.PointsZ + (zindex < terrain.PointsZ - 1 ? zindex + 1 : zindex)]
                        - terrain.Height[xindex * terrain.PointsZ + (zindex != 0 ? zindex - 1 : zindex)]);
                    if (xindex == 0 || xindex == terrain.PointsX - 1)
                        deltax *= 2;
                    if (zindex == 0 || zindex == terrain.PointsZ - 1)
                        deltaz *= 2;
                    var normal = new Vector3(-deltax, 2 / terrain.PointsPerMeter, deltaz);
                    normal.Normalize();
                    dataStream.Write(normal);

                    //TextureCoordinates
                    dataStream.Write(new Vector2(x / terrain.PointsX, z / terrain.PointsZ));

                    //Boundingbox-Params
                    if (y < _bounds.MinY)
                        _bounds.MinY = y;
                    if (y > _bounds.MaxY)
                        _bounds.MaxY = y;
                }
            }

            dataStream.Position = 0;
            VBuffer = new Buffer(renderer.D3DDevice, dataStream, 32 * verticesX * verticesZ, ResourceUsage.Default, BindFlags.VertexBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0);
            VertexBuffer = new VertexBufferBinding(VBuffer, 32, 0);
            dataStream.Dispose();
        }

        public RenderComponent(RenderManager renderMgr, GameObject parent)
            : base(parent)
        {
            Manager = renderMgr;

            Tint = new Color(255, 255, 255, 255);
        }

        protected override void Initialize () {
            base.Initialize();

            RenderManager = new RenderManager(GraphicsDevice);

            GraphicsDevice.DeviceResetting += new EventHandler<EventArgs>(OnDeviceResetting);
            GraphicsDevice.DeviceReset += new EventHandler<EventArgs>(OnDeviceReset);
        }

        protected override void OnLoad(EventArgs e)
        {
            InputManager.Initialize(this.Mouse);

            this.renderer = new RenderManager();

            this.game = new GameManager(this);
        }

 public RectRenderComponent(float width, float height, Color color, RenderManager renderMgr, GameObject parent)
     : base(renderMgr, parent)
 {
     WorldWidth = width;
     WorldHeight = height;
     RectShape = new RectangleShape(new SFML.Window.Vector2f(width, height));
     RectShape.FillColor = color;
     ZIndex = int.MaxValue - 10000;
 }

 public override void Draw(RenderManager renderMgr, Camera camera)
 {
     if (DebugDraw)
     {
         WorldPosition = Parent.Position;
         RectShape.Position = Parent.Position - new Vector2f(RectShape.Size.X * 0.5f, RectShape.Size.Y * 0.5f);
         renderMgr.Target.Draw(RectShape);
     }
 }

        public void SetWorldPosition(RenderManager.CameraInfo camera, Vector3 worldPos)
        {
            var uiView = GetUIView();

            var vector3_1 = Camera.main.WorldToScreenPoint(worldPos) / uiView.inputScale;
            var vector3_3 = uiView.ScreenPointToGUI(vector3_1) - new Vector2(size.x * 0.5f, size.y * 0.5f);// + new Vector2(vector3_2.x, vector3_2.y);

            relativePosition = vector3_3;
        }

        /// <summary>
        /// Constructs a render coordinator.
        /// </summary>
        /// <param name="manager">The render manager responsible for creating frames and dispatching them to the graphics device.</param>
        /// <param name="synchronousBeginDraw">The function responsible for synchronously beginning a rendering operation. This will be invoked on the rendering thread.</param>
        /// <param name="synchronousEndDraw">The function responsible for synchronously ending a rendering operation and presenting it to the screen. This will be invoked on the rendering thread.</param>
        public RenderCoordinator(RenderManager manager, Func<bool> synchronousBeginDraw, Action synchronousEndDraw)
        {
            Manager = manager;

            _SyncBeginDraw = synchronousBeginDraw;
            _SyncEndDraw = synchronousEndDraw;

            CoreInitialize();
        }