C# WorldRenderer.ScreenVector方法代码示例

        public void Render(WorldRenderer wr)
        {
            var vecLength = length.Length;
            if (vecLength == 0)
                return;

            if (shape == BeamRenderableShape.Flat)
            {
                var delta = length * width.Length / (2 * vecLength);
                var corner = new WVec(-delta.Y, delta.X, delta.Z);
                var a = wr.ScreenPosition(pos - corner);
                var b = wr.ScreenPosition(pos + corner);
                var c = wr.ScreenPosition(pos + corner + length);
                var d = wr.ScreenPosition(pos - corner + length);
                Game.Renderer.WorldRgbaColorRenderer.FillRect(a, b, c, d, color);
            }
            else
            {
                var start = wr.ScreenPosition(pos);
                var end = wr.ScreenPosition(pos + length);
                var screenWidth = wr.ScreenVector(new WVec(width, WDist.Zero, WDist.Zero))[0];
                Game.Renderer.WorldRgbaColorRenderer.DrawLine(start, end, screenWidth, color);
            }
        }

        public VoxelRenderProxy RenderAsync(
			WorldRenderer wr, IEnumerable<VoxelAnimation> voxels, WRot camera, float scale,
			float[] groundNormal, WRot lightSource, float[] lightAmbientColor, float[] lightDiffuseColor,
			PaletteReference color, PaletteReference normals, PaletteReference shadowPalette)
        {
            // Correct for inverted y-axis
            var scaleTransform = Util.ScaleMatrix(scale, scale, scale);

            // Correct for bogus light source definition
            var lightYaw = Util.MakeFloatMatrix(new WRot(WAngle.Zero, WAngle.Zero, -lightSource.Yaw).AsMatrix());
            var lightPitch = Util.MakeFloatMatrix(new WRot(WAngle.Zero, -lightSource.Pitch, WAngle.Zero).AsMatrix());
            var shadowTransform = Util.MatrixMultiply(lightPitch, lightYaw);

            var invShadowTransform = Util.MatrixInverse(shadowTransform);
            var cameraTransform = Util.MakeFloatMatrix(camera.AsMatrix());
            var invCameraTransform = Util.MatrixInverse(cameraTransform);
            if (invCameraTransform == null)
                throw new InvalidOperationException("Failed to invert the cameraTransform matrix during RenderAsync.");

            // Sprite rectangle
            var tl = new float2(float.MaxValue, float.MaxValue);
            var br = new float2(float.MinValue, float.MinValue);

            // Shadow sprite rectangle
            var stl = new float2(float.MaxValue, float.MaxValue);
            var sbr = new float2(float.MinValue, float.MinValue);

            foreach (var v in voxels)
            {
                // Convert screen offset back to world coords
                var offsetVec = Util.MatrixVectorMultiply(invCameraTransform, wr.ScreenVector(v.OffsetFunc()));
                var offsetTransform = Util.TranslationMatrix(offsetVec[0], offsetVec[1], offsetVec[2]);

                var worldTransform = v.RotationFunc().Aggregate(Util.IdentityMatrix(),
                    (x, y) => Util.MatrixMultiply(Util.MakeFloatMatrix(y.AsMatrix()), x));
                worldTransform = Util.MatrixMultiply(scaleTransform, worldTransform);
                worldTransform = Util.MatrixMultiply(offsetTransform, worldTransform);

                var bounds = v.Voxel.Bounds(v.FrameFunc());
                var worldBounds = Util.MatrixAABBMultiply(worldTransform, bounds);
                var screenBounds = Util.MatrixAABBMultiply(cameraTransform, worldBounds);
                var shadowBounds = Util.MatrixAABBMultiply(shadowTransform, worldBounds);

                // Aggregate bounds rects
                tl = float2.Min(tl, new float2(screenBounds[0], screenBounds[1]));
                br = float2.Max(br, new float2(screenBounds[3], screenBounds[4]));
                stl = float2.Min(stl, new float2(shadowBounds[0], shadowBounds[1]));
                sbr = float2.Max(sbr, new float2(shadowBounds[3], shadowBounds[4]));
            }

            // Inflate rects to ensure rendering is within bounds
            tl -= SpritePadding;
            br += SpritePadding;
            stl -= SpritePadding;
            sbr += SpritePadding;

            // Corners of the shadow quad, in shadow-space
            var corners = new float[][]
            {
                new[] { stl.X, stl.Y, 0, 1 },
                new[] { sbr.X, sbr.Y, 0, 1 },
                new[] { sbr.X, stl.Y, 0, 1 },
                new[] { stl.X, sbr.Y, 0, 1 }
            };

            var shadowScreenTransform = Util.MatrixMultiply(cameraTransform, invShadowTransform);
            var shadowGroundNormal = Util.MatrixVectorMultiply(shadowTransform, groundNormal);
            var screenCorners = new float3[4];
            for (var j = 0; j < 4; j++)
            {
                // Project to ground plane
                corners[j][2] = -(corners[j][1] * shadowGroundNormal[1] / shadowGroundNormal[2] +
                                  corners[j][0] * shadowGroundNormal[0] / shadowGroundNormal[2]);

                // Rotate to camera-space
                corners[j] = Util.MatrixVectorMultiply(shadowScreenTransform, corners[j]);
                screenCorners[j] = new float3(corners[j][0], corners[j][1], 0);
            }

            // Shadows are rendered at twice the resolution to reduce artifacts
            Size spriteSize, shadowSpriteSize;
            int2 spriteOffset, shadowSpriteOffset;
            CalculateSpriteGeometry(tl, br, 1, out spriteSize, out spriteOffset);
            CalculateSpriteGeometry(stl, sbr, 2, out shadowSpriteSize, out shadowSpriteOffset);

            var sprite = sheetBuilder.Allocate(spriteSize, 0, spriteOffset);
            var shadowSprite = sheetBuilder.Allocate(shadowSpriteSize, 0, shadowSpriteOffset);
            var sb = sprite.Bounds;
            var ssb = shadowSprite.Bounds;
            var spriteCenter = new float2(sb.Left + sb.Width / 2, sb.Top + sb.Height / 2);
            var shadowCenter = new float2(ssb.Left + ssb.Width / 2, ssb.Top + ssb.Height / 2);

            var translateMtx = Util.TranslationMatrix(spriteCenter.X - spriteOffset.X, renderer.SheetSize - (spriteCenter.Y - spriteOffset.Y), 0);
            var shadowTranslateMtx = Util.TranslationMatrix(shadowCenter.X - shadowSpriteOffset.X, renderer.SheetSize - (shadowCenter.Y - shadowSpriteOffset.Y), 0);
            var correctionTransform = Util.MatrixMultiply(translateMtx, FlipMtx);
            var shadowCorrectionTransform = Util.MatrixMultiply(shadowTranslateMtx, ShadowScaleFlipMtx);

            doRender.Add(Pair.New<Sheet, Action>(sprite.Sheet, () =>
            {
                foreach (var v in voxels)
//.........这里部分代码省略.........

            public void RenderDebugGeometry(WorldRenderer wr)
            {
                var pxOrigin = wr.ScreenPosition(voxel.pos);
                var groundZ = 0.5f * (pxOrigin.Y - wr.ScreenZPosition(voxel.pos, 0));
                var shadowOrigin = pxOrigin - groundZ * (new float2(renderProxy.ShadowDirection, 1));

                // Draw sprite rect
                var offset = pxOrigin + renderProxy.Sprite.Offset - 0.5f * renderProxy.Sprite.Size;
                Game.Renderer.WorldLineRenderer.DrawRect(offset, offset + renderProxy.Sprite.Size, Color.Red);

                // Draw transformed shadow sprite rect
                var c = Color.Purple;
                var psb = renderProxy.ProjectedShadowBounds;
                Game.Renderer.WorldLineRenderer.DrawLine(shadowOrigin + psb[1], shadowOrigin + psb[3], c);
                Game.Renderer.WorldLineRenderer.DrawLine(shadowOrigin + psb[3], shadowOrigin + psb[0], c);
                Game.Renderer.WorldLineRenderer.DrawLine(shadowOrigin + psb[0], shadowOrigin + psb[2], c);
                Game.Renderer.WorldLineRenderer.DrawLine(shadowOrigin + psb[2], shadowOrigin + psb[1], c);

                // Draw voxel bounding box
                var draw = voxel.voxels.Where(v => v.DisableFunc == null || !v.DisableFunc());
                var scaleTransform = Util.ScaleMatrix(voxel.scale, voxel.scale, voxel.scale);
                var cameraTransform = Util.MakeFloatMatrix(voxel.camera.AsMatrix());

                foreach (var v in draw)
                {
                    var bounds = v.Voxel.Bounds(v.FrameFunc());
                    var worldTransform = v.RotationFunc().Reverse().Aggregate(scaleTransform,
                        (x, y) => Util.MatrixMultiply(x, Util.MakeFloatMatrix(y.AsMatrix())));

                    var pxOffset = wr.ScreenVector(v.OffsetFunc());
                    var pxPos = pxOrigin + new float2(pxOffset[0], pxOffset[1]);
                    var screenTransform = Util.MatrixMultiply(cameraTransform, worldTransform);
                    DrawBoundsBox(pxPos, screenTransform, bounds, Color.Yellow);
                }
            }

            public Rectangle ScreenBounds(WorldRenderer wr)
            {
                var pxOrigin = wr.ScreenPosition(voxel.pos);
                var draw = voxel.voxels.Where(v => v.DisableFunc == null || !v.DisableFunc());
                var scaleTransform = Util.ScaleMatrix(voxel.scale, voxel.scale, voxel.scale);
                var cameraTransform = Util.MakeFloatMatrix(voxel.camera.AsMatrix());

                var minX = float.MaxValue;
                var minY = float.MaxValue;
                var maxX = float.MinValue;
                var maxY = float.MinValue;
                foreach (var v in draw)
                {
                    var bounds = v.Voxel.Bounds(v.FrameFunc());
                    var worldTransform = v.RotationFunc().Reverse().Aggregate(scaleTransform,
                        (x, y) => Util.MatrixMultiply(x, Util.MakeFloatMatrix(y.AsMatrix())));

                    var pxOffset = wr.ScreenVector(v.OffsetFunc());
                    var pxPos = pxOrigin + new float2(pxOffset[0], pxOffset[1]);
                    var screenTransform = Util.MatrixMultiply(cameraTransform, worldTransform);

                    for (var i = 0; i < 8; i++)
                    {
                        var vec = new float[] { bounds[CornerXIndex[i]], bounds[CornerYIndex[i]], bounds[CornerZIndex[i]], 1 };
                        var screen = Util.MatrixVectorMultiply(screenTransform, vec);
                        minX = Math.Min(minX, pxPos.X + screen[0]);
                        minY = Math.Min(minY, pxPos.Y + screen[1]);
                        maxX = Math.Max(maxX, pxPos.X + screen[0]);
                        maxY = Math.Max(maxY, pxPos.Y + screen[1]);
                    }
                }

                return Rectangle.FromLTRB((int)minX, (int)minY, (int)maxX, (int)maxY);
            }

        public void Render(WorldRenderer wr)
        {
            // Need at least 4 points to smooth the contrail over
            if (length - skip < 4)
                return;

            var screenWidth = wr.ScreenVector(new WVec(width, WDist.Zero, WDist.Zero))[0];
            var wcr = Game.Renderer.WorldRgbaColorRenderer;

            // Start of the first line segment is the tail of the list - don't smooth it.
            var curPos = trail[Index(next - skip - 1)];
            var curColor = color;
            for (var i = 0; i < length - skip - 4; i++)
            {
                var j = next - skip - i - 2;
                var nextPos = Average(trail[Index(j)], trail[Index(j - 1)], trail[Index(j - 2)], trail[Index(j - 3)]);
                var nextColor = Exts.ColorLerp(i * 1f / (length - 4), color, Color.Transparent);

                if (!world.FogObscures(curPos) && !world.FogObscures(nextPos))
                    wcr.DrawLine(wr.ScreenPosition(curPos), wr.ScreenPosition(nextPos), screenWidth, curColor, nextColor);

                curPos = nextPos;
                curColor = nextColor;
            }
        }