示例#1
0
        public void ResizeBumpMappingInfos(int width, int height)
        {
            int requiredBumpMappingWidth  = Math.Max(BumpMappingWidth, width);
            int requiredBumpMappingHeight = Math.Max(BumpMappingHeight, height);

            if (BumpMappingWidth < requiredBumpMappingWidth ||
                BumpMappingHeight < requiredBumpMappingHeight)
            {
                var newBumpMappingInfos = new BumpMappingLevel[requiredBumpMappingWidth, requiredBumpMappingHeight];
                for (int y = 0; y < requiredBumpMappingHeight; ++y)
                {
                    for (int x = 0; x < requiredBumpMappingWidth; ++x)
                    {
                        newBumpMappingInfos[x, y] = BumpMappingLevel.None;
                    }
                }
                for (int y = 0; y < BumpMappingHeight; ++y)
                {
                    for (int x = 0; x < BumpMappingWidth; ++x)
                    {
                        newBumpMappingInfos[x, y] = _bumpMappingLevel[x, y];
                    }
                }
                _bumpMappingLevel = newBumpMappingInfos;
            }
        }
示例#2
0
            protected override void OnPaintSelection(PaintEventArgs e)
            {
                var texture = VisibleTexture;

                // Determine relevant area
                Vector2 start = FromVisualCoord(new PointF());
                Vector2 end   = FromVisualCoord(new PointF() + ClientSize);

                start = Vector2.Min(texture.Image.Size, Vector2.Max(new Vector2(0), start));
                end   = Vector2.Min(texture.Image.Size, Vector2.Max(new Vector2(0), end));
                int bumpTileStartX = (int)Math.Floor(start.X / LevelTexture.BumpMappingGranularity);
                int bumpTileStartY = (int)Math.Floor(start.Y / LevelTexture.BumpMappingGranularity);
                int bumpTileEndX   = (int)Math.Ceiling(end.X / LevelTexture.BumpMappingGranularity);
                int bumpTileEndY   = (int)Math.Ceiling(end.Y / LevelTexture.BumpMappingGranularity);

                // Draw bumpmaps
                using (Font bumpFont = new Font(Font.FontFamily, _bumpStringSize * _bumpProportion * LevelTexture.BumpMappingGranularity * Math.Min(100, ViewScale)))
                    for (int y = bumpTileStartY; y <= bumpTileEndY; ++y)
                    {
                        for (int x = bumpTileStartX; x <= bumpTileEndX; ++x)
                        {
                            if (x < 0 || x >= texture.BumpMappingWidth || y < 0 || y >= texture.BumpMappingHeight)
                            {
                                continue;
                            }

                            BumpMappingLevel bump = texture.GetBumpMapLevel(x, y);

                            Vector2 tileStartTexCoord = new Vector2(x, y) * LevelTexture.BumpMappingGranularity;
                            PointF  tileStart         = ToVisualCoord(tileStartTexCoord);
                            PointF  tileEnd           = ToVisualCoord(tileStartTexCoord + new Vector2(LevelTexture.BumpMappingGranularity));
                            PointF  descStart         = new PointF(tileStart.X, tileStart.Y * _bumpProportion + tileEnd.Y * (1 - _bumpProportion));

                            RectangleF descArea = RectangleF.FromLTRB(descStart.X, descStart.Y, tileEnd.X, tileEnd.Y);
                            e.Graphics.FillRectangle(_bumpBrushes[(int)bump], descArea);
                            if (ViewScale > 6)
                            {
                                e.Graphics.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAliasGridFit;
                            }
                            e.Graphics.DrawString(bump.ToString(), bumpFont, Brushes.Black, descArea, new StringFormat(StringFormatFlags.NoWrap)
                            {
                                Alignment = StringAlignment.Center, LineAlignment = StringAlignment.Center
                            });

                            RectangleF tileArea = RectangleF.FromLTRB(tileStart.X, tileStart.Y, tileEnd.X, tileEnd.Y);
                            e.Graphics.DrawRectangle(Pens.White, tileArea);
                        }
                    }

                // Fill covered tiles
                Vector2 p0 = SelectedTexture.TexCoord0 / LevelTexture.FootStepSoundGranularity;
                Vector2 p1 = SelectedTexture.TexCoord1 / LevelTexture.FootStepSoundGranularity;
                Vector2 p2 = SelectedTexture.TexCoord2 / LevelTexture.FootStepSoundGranularity;
                Vector2 p3 = SelectedTexture.TexCoord3 / LevelTexture.FootStepSoundGranularity;

                int xMin = (int)Math.Min(Math.Min(Math.Min(p0.X, p1.X), p2.X), p3.X);
                int xMax = (int)Math.Max(Math.Max(Math.Max(p0.X, p1.X), p2.X), p3.X);
                int yMin = (int)Math.Min(Math.Min(Math.Min(p0.Y, p1.Y), p2.Y), p3.Y);
                int yMax = (int)Math.Max(Math.Max(Math.Max(p0.Y, p1.Y), p2.Y), p3.Y);

                PointF     selStart = ToVisualCoord(new Vector2(xMin, yMin) * LevelTexture.FootStepSoundGranularity);
                PointF     selEnd   = ToVisualCoord(new Vector2(xMax, yMax) * LevelTexture.FootStepSoundGranularity);
                RectangleF selArea  = RectangleF.FromLTRB(selStart.X, selStart.Y, selEnd.X, selEnd.Y);

                e.Graphics.FillRectangle(_coverBrush, selArea);
                base.OnPaintSelection(e);
            }
示例#3
0
 public void SetBumpMappingLevel(int x, int y, BumpMappingLevel info)
 {
     _bumpMappingLevel[x, y] = info;
 }