Ignore:
Timestamp:
Aug 7, 2022, 3:02:24 PM (2 years ago)
Author:
alloc
Message:

Major refactoring/cleanup

Location:
binary-improvements2/MapRendering
Files:
2 added
9 deleted
1 edited
8 moved

Legend:

Unmodified
Added
Removed

  • binary-improvements2/MapRendering/MapRendering.csproj

    r390 r391  
    1616    <DebugType>none</DebugType>
    1717    <Optimize>true</Optimize>
    18     <OutputPath>..\bin\Mods\Allocs_WebAndMapRendering\</OutputPath>
     18    <OutputPath>..\bin\Mods\TFP_MapRendering\</OutputPath>
    1919    <ErrorReport>prompt</ErrorReport>
    2020    <WarningLevel>4</WarningLevel>
    … …  
    2323  </PropertyGroup>
    2424  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release_Profiler|AnyCPU' ">
    25     <OutputPath>..\bin\Mods\Allocs_WebAndMapRendering\</OutputPath>
     25    <OutputPath>..\bin\Mods\TFP_MapRendering\</OutputPath>
    2626    <DefineConstants>ENABLE_PROFILER</DefineConstants>
    2727    <Optimize>true</Optimize>
    … …  
    3232  </PropertyGroup>
    3333  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
    34     <OutputPath>..\bin\Mods\Allocs_WebAndMapRendering\</OutputPath>
     34    <OutputPath>..\bin\Mods\TFP_MapRendering\</OutputPath>
    3535    <DebugType>full</DebugType>
    3636    <DebugSymbols>true</DebugSymbols>
    … …  
    7979  </ItemGroup>
    8080  <ItemGroup>
    81     <Compile Include="AssemblyInfo.cs" />
    82     <Compile Include="Commands\Exception.cs" />
    83     <Compile Include="MapRendering\MapRendering.cs" />
    84     <Compile Include="MapRendering\MapRenderBlockBuffer.cs" />
    85     <Compile Include="MapRendering\Constants.cs" />
    86     <Compile Include="Commands\RenderMap.cs" />
    87     <Compile Include="Commands\EnableRendering.cs" />
    88     <Compile Include="API.cs" />
    89     <Compile Include="Web\API\AbsRestApi.cs" />
    90     <Compile Include="Web\API\GetAnimalsLocation.cs" />
    91     <Compile Include="Web\API\GetHostileLocation.cs" />
    92     <Compile Include="Web\API\GetWebMods.cs" />
    93     <Compile Include="Web\API\Null.cs" />
    94     <Compile Include="Web\Handlers\RewriteHandler.cs" />
    95     <Compile Include="Web\RequestContext.cs" />
    96     <Compile Include="Web\SSE\EventLog.cs" />
    97     <Compile Include="Web\SSE\SseHandler.cs" />
    98     <Compile Include="Web\SSE\EventBase.cs" />
    99     <Compile Include="Web\Web.cs" />
    100     <Compile Include="Web\MimeType.cs" />
    101     <Compile Include="Web\API\GetPlayersOnline.cs" />
    102     <Compile Include="Web\API\AbsWebAPI.cs" />
    103     <Compile Include="Web\API\GetPlayersLocation.cs" />
    104     <Compile Include="Web\API\GetPlayerInventory.cs" />
    105     <Compile Include="Web\API\GetLandClaims.cs" />
    106     <Compile Include="Commands\webstat.cs" />
    107     <Compile Include="Web\API\GetStats.cs" />
    108     <Compile Include="Web\WebConnection.cs" />
    109     <Compile Include="Web\OpenID.cs" />
    110     <Compile Include="Web\ConnectionHandler.cs" />
    111     <Compile Include="Web\WebMod.cs" />
    112     <Compile Include="Web\WebPermissions.cs" />
    113     <Compile Include="Web\Handlers\ApiHandler.cs" />
    114     <Compile Include="Web\Handlers\ItemIconHandler.cs" />
    115     <Compile Include="Web\Handlers\AbsHandler.cs" />
    116     <Compile Include="Web\Handlers\SimpleRedirectHandler.cs" />
    117     <Compile Include="Web\Handlers\StaticHandler.cs" />
    118     <Compile Include="Web\Handlers\SessionHandler.cs" />
    119     <Compile Include="Web\API\ExecuteConsoleCommand.cs" />
    120     <Compile Include="Commands\ReloadWebPermissions.cs" />
    121     <Compile Include="Web\Handlers\UserStatusHandler.cs" />
    122     <Compile Include="Commands\WebTokens.cs" />
    123     <Compile Include="Commands\WebPermissionsCmd.cs" />
    124     <Compile Include="Web\LogBuffer.cs" />
    125     <Compile Include="Web\API\GetLog.cs" />
    126     <Compile Include="Web\API\GetWebUIUpdates.cs" />
    127     <Compile Include="Web\API\GetServerInfo.cs" />
    128     <Compile Include="Web\API\GetPlayerList.cs" />
    129     <Compile Include="Web\WebCommandResult.cs" />
    130     <Compile Include="Web\API\GetAllowedCommands.cs" />
    131     <Compile Include="Commands\EnableOpenIDDebug.cs" />
    132     <Compile Include="Web\API\GetPlayerInventories.cs" />
    133     <Compile Include="Web\WebUtils.cs" />
     81    <Compile Include="src\Constants.cs" />
     82    <Compile Include="src\MapRenderBlockBuffer.cs" />
     83    <Compile Include="src\MapRenderer.cs" />
     84    <Compile Include="src\ModApi.cs" />
     85    <Compile Include="src\AssemblyInfo.cs" />
     86    <Compile Include="src\Commands\EnableRendering.cs" />
     87    <Compile Include="src\Commands\RenderMap.cs" />
    13488  </ItemGroup>
    13589  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
    … …  
    14094      <Private>False</Private>
    14195    </ProjectReference>
    142     <ProjectReference Include="..\SpaceWizards.HttpListener\SpaceWizards.HttpListener.csproj">
    143       <Project>{e273d042-57f9-4e2e-8268-5053527e5287}</Project>
    144       <Name>SpaceWizards.HttpListener</Name>
    145     </ProjectReference>
    14696  </ItemGroup>
    14797  <ItemGroup>
    … …  
    14999      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    150100    </None>
    151     <None Include="steam-intermediate.cer">
    152       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    153     </None>
    154     <None Include="steam-rootca.cer">
    155       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    156     </None>
    157101  </ItemGroup>
    158102</Project>

  • binary-improvements2/MapRendering/ModInfo.xml

    r370 r391  
    22<xml>
    33        <ModInfo>
    4                 <Name value="Allocs MapRendering and Webinterface" />
     4                <Name value="TFP_MapRendering" />
    55                <Description value="Render the game map to image map tiles as it is uncovered" />
    6                 <Author value="Christian 'Alloc' Illy" />
    7                 <Version value="39" />
    8                 <Website value="http://7dtd.illy.bz" />
     6                <Author value="The Fun Pimps LLC" />
     7                <Version value="1" />
     8                <Website value="" />
    99        </ModInfo>
    1010</xml>

  • binary-improvements2/MapRendering/src/AssemblyInfo.cs

    r390 r391  
    77[assembly: AssemblyDescription ("")]
    88[assembly: AssemblyConfiguration ("")]
    9 [assembly: AssemblyCompany ("")]
     9[assembly: AssemblyCompany ("The Fun Pimps LLC")]
    1010[assembly: AssemblyProduct ("")]
    11 [assembly: AssemblyCopyright ("ci")]
     11[assembly: AssemblyCopyright ("The Fun Pimps LLC")]
    1212[assembly: AssemblyTrademark ("")]
    1313[assembly: AssemblyCulture ("")]

  • binary-improvements2/MapRendering/src/Commands/EnableRendering.cs

    r390 r391  
    11using System.Collections.Generic;
     2using JetBrains.Annotations;
    23
    3 namespace AllocsFixes.CustomCommands {
     4namespace MapRendering.Commands {
     5        [UsedImplicitly]
    46        public class EnableRendering : ConsoleCmdAbstract {
    57                public override string GetDescription () {
    … …  
    1315                public override void Execute (List<string> _params, CommandSenderInfo _senderInfo) {
    1416                        if (_params.Count != 1) {
    15                                 SdtdConsole.Instance.Output ("Current state: " + MapRendering.MapRendering.renderingEnabled);
     17                                SdtdConsole.Instance.Output ("Current state: " + MapRenderer.renderingEnabled);
    1618                                return;
    1719                        }
    1820
    19                         MapRendering.MapRendering.renderingEnabled = _params [0].Equals ("1");
     21                        MapRenderer.renderingEnabled = _params [0].Equals ("1");
    2022                        SdtdConsole.Instance.Output ("Set live map rendering to " + _params [0].Equals ("1"));
    2123                }

  • binary-improvements2/MapRendering/src/Commands/RenderMap.cs

    r390 r391  
    11using System.Collections.Generic;
     2using JetBrains.Annotations;
    23
    3 namespace AllocsFixes.CustomCommands {
     4namespace MapRendering.Commands {
     5        [UsedImplicitly]
    46        public class RenderMap : ConsoleCmdAbstract {
    57                public override string GetDescription () {
    … …  
    1214
    1315                public override void Execute (List<string> _params, CommandSenderInfo _senderInfo) {
    14                         MapRendering.MapRendering.Instance.RenderFullMap ();
     16                        MapRenderer.Instance.RenderFullMap ();
    1517
    1618                        SdtdConsole.Instance.Output ("Render map done");

  • binary-improvements2/MapRendering/src/Constants.cs

    r390 r391  
    11using UnityEngine;
    22
    3 namespace AllocsFixes.MapRendering {
    4         public class Constants {
    5                 public static readonly TextureFormat DEFAULT_TEX_FORMAT = TextureFormat.ARGB32;
    6                 public static int MAP_BLOCK_SIZE = 128;
    7                 public const int MAP_CHUNK_SIZE = 16;
    8                 public const int MAP_REGION_SIZE = 512;
    9                 public static int ZOOMLEVELS = 5;
    10                 public static string MAP_DIRECTORY = string.Empty;
     3namespace MapRendering {
     4        public static class Constants {
     5                public static readonly TextureFormat DefaultTextureFormat = TextureFormat.ARGB32;
     6                public static int MapBlockSize = 128;
     7                public const int MapChunkSize = 16;
     8                public const int MapRegionSize = 512;
     9                public static int Zoomlevels = 5;
     10                public static string MapDirectory = string.Empty;
    1111
    12                 public static int MAP_BLOCK_TO_CHUNK_DIV {
    13                         get { return MAP_BLOCK_SIZE / MAP_CHUNK_SIZE; }
    14                 }
     12                public static int MAP_BLOCK_TO_CHUNK_DIV => MapBlockSize / MapChunkSize;
    1513
    16                 public static int MAP_REGION_TO_CHUNK_DIV {
    17                         get { return MAP_REGION_SIZE / MAP_CHUNK_SIZE; }
    18                 }
     14                public static int MAP_REGION_TO_CHUNK_DIV => MapRegionSize / MapChunkSize;
    1915        }
    2016}

  • binary-improvements2/MapRendering/src/MapRenderBlockBuffer.cs

    r390 r391  
    66using UnityEngine.Profiling;
    77
    8 namespace AllocsFixes.MapRendering {
     8namespace MapRendering {
    99        public class MapRenderBlockBuffer {
    10                 private readonly Texture2D blockMap = new Texture2D (Constants.MAP_BLOCK_SIZE, Constants.MAP_BLOCK_SIZE, Constants.DEFAULT_TEX_FORMAT, false);
     10                private readonly Texture2D blockMap = new Texture2D (Constants.MapBlockSize, Constants.MapBlockSize, Constants.DefaultTextureFormat, false);
    1111                private readonly MapTileCache cache;
    1212                private readonly NativeArray<int> emptyImageData;
    13                 private readonly Texture2D zoomBuffer = new Texture2D (Constants.MAP_BLOCK_SIZE / 2, Constants.MAP_BLOCK_SIZE / 2, Constants.DEFAULT_TEX_FORMAT, false);
     13                private readonly Texture2D zoomBuffer = new Texture2D (Constants.MapBlockSize / 2, Constants.MapBlockSize / 2, Constants.DefaultTextureFormat, false);
    1414                private readonly int zoomLevel;
    1515                private readonly string folderBase;
    1616               
    17                 private Vector2i currentBlockMapPos = new Vector2i (Int32.MinValue, Int32.MinValue);
     17                private Vector2i currentBlockMapPos = new Vector2i (int.MinValue, int.MinValue);
    1818                private string currentBlockMapFolder = string.Empty;
    1919
    … …  
    2121                        zoomLevel = _level;
    2222                        cache = _cache;
    23                         folderBase = Constants.MAP_DIRECTORY + "/" + zoomLevel + "/";
     23                        folderBase = Constants.MapDirectory + "/" + zoomLevel + "/";
    2424
    2525                        {
    2626                                // Initialize empty tile data
    2727                                Color nullColor = new Color (0, 0, 0, 0);
    28                                 for (int x = 0; x < Constants.MAP_BLOCK_SIZE; x++) {
    29                                         for (int y = 0; y < Constants.MAP_BLOCK_SIZE; y++) {
     28                                for (int x = 0; x < Constants.MapBlockSize; x++) {
     29                                        for (int y = 0; y < Constants.MapBlockSize; y++) {
    3030                                                blockMap.SetPixel (x, y, nullColor);
    3131                                        }
    … …  
    3939                }
    4040
    41                 public TextureFormat FormatSelf {
    42                         get { return blockMap.format; }
    43                 }
     41                public TextureFormat FormatSelf => blockMap.format;
    4442
    4543                public void ResetBlock () {
    4644                        currentBlockMapFolder = string.Empty;
    47                         currentBlockMapPos = new Vector2i (Int32.MinValue, Int32.MinValue);
     45                        currentBlockMapPos = new Vector2i (int.MinValue, int.MinValue);
    4846                        cache.ResetTile (zoomLevel);
    4947                }
    … …  
    9492
    9593                public void SetPart (Vector2i _offset, int _partSize, Color32[] _pixels) {
    96                         if (_offset.x + _partSize > Constants.MAP_BLOCK_SIZE || _offset.y + _partSize > Constants.MAP_BLOCK_SIZE) {
    97                                 Log.Error (string.Format ("MapBlockBuffer[{0}].SetPart ({1}, {2}, {3}) has blockMap.size ({4}/{5})",
    98                                         zoomLevel, _offset, _partSize, _pixels.Length, Constants.MAP_BLOCK_SIZE, Constants.MAP_BLOCK_SIZE));
     94                        if (_offset.x + _partSize > Constants.MapBlockSize || _offset.y + _partSize > Constants.MapBlockSize) {
     95                                Log.Error (
     96                                        $"MapBlockBuffer[{zoomLevel}].SetPart ({_offset}, {_partSize}, {_pixels.Length}) has blockMap.size ({Constants.MapBlockSize}/{Constants.MapBlockSize})");
    9997                                return;
    10098                        }
    … …  
    107105                public Color32[] GetHalfScaled () {
    108106                        Profiler.BeginSample ("HalfScaled.ResizeBuffer");
    109                         zoomBuffer.Resize (Constants.MAP_BLOCK_SIZE, Constants.MAP_BLOCK_SIZE);
     107                        zoomBuffer.Resize (Constants.MapBlockSize, Constants.MapBlockSize);
    110108                        Profiler.EndSample ();
    111109
    … …  
    125123
    126124                        Profiler.BeginSample ("HalfScaled.Scale");
    127                         TextureScale.Point (zoomBuffer, Constants.MAP_BLOCK_SIZE / 2, Constants.MAP_BLOCK_SIZE / 2);
     125                        TextureScale.Point (zoomBuffer, Constants.MapBlockSize / 2, Constants.MapBlockSize / 2);
    128126                        Profiler.EndSample ();
    129127
    … …  
    136134
    137135                public void SetPartNative (Vector2i _offset, int _partSize, NativeArray<int> _pixels) {
    138                         if (_offset.x + _partSize > Constants.MAP_BLOCK_SIZE || _offset.y + _partSize > Constants.MAP_BLOCK_SIZE) {
    139                                 Log.Error (string.Format ("MapBlockBuffer[{0}].SetPart ({1}, {2}, {3}) has blockMap.size ({4}/{5})",
    140                                         zoomLevel, _offset, _partSize, _pixels.Length, Constants.MAP_BLOCK_SIZE, Constants.MAP_BLOCK_SIZE));
     136                        if (_offset.x + _partSize > Constants.MapBlockSize || _offset.y + _partSize > Constants.MapBlockSize) {
     137                                Log.Error (
     138                                        $"MapBlockBuffer[{zoomLevel}].SetPart ({_offset}, {_partSize}, {_pixels.Length}) has blockMap.size ({Constants.MapBlockSize}/{Constants.MapBlockSize})");
    141139                                return;
    142140                        }
    … …  
    157155                public NativeArray<int> GetHalfScaledNative () {
    158156                        Profiler.BeginSample ("HalfScaledNative.ResizeBuffer");
    159                         if (zoomBuffer.format != blockMap.format || zoomBuffer.height != Constants.MAP_BLOCK_SIZE / 2 || zoomBuffer.width != Constants.MAP_BLOCK_SIZE / 2) {
    160                                 zoomBuffer.Resize (Constants.MAP_BLOCK_SIZE / 2, Constants.MAP_BLOCK_SIZE / 2, blockMap.format, false);
     157                        if (zoomBuffer.format != blockMap.format || zoomBuffer.height != Constants.MapBlockSize / 2 || zoomBuffer.width != Constants.MapBlockSize / 2) {
     158                                zoomBuffer.Resize (Constants.MapBlockSize / 2, Constants.MapBlockSize / 2, blockMap.format, false);
    161159                        }
    162160                        Profiler.EndSample ();
    … …  
    178176                        int newHeight = _targetTex.height;
    179177                       
    180                         float ratioX = ((float) oldWidth) / newWidth;
    181                         float ratioY = ((float) oldHeight) / newHeight;
    182 
    183                         for (var y = 0; y < newHeight; y++) {
    184                                 var oldLineStart = (int) (ratioY * y) * oldWidth;
    185                                 var newLineStart = y * newWidth;
    186                                 for (var x = 0; x < newWidth; x++) {
     178                        float ratioX = (float) oldWidth / newWidth;
     179                        float ratioY = (float) oldHeight / newHeight;
     180
     181                        for (int y = 0; y < newHeight; y++) {
     182                                int oldLineStart = (int) (ratioY * y) * oldWidth;
     183                                int newLineStart = y * newWidth;
     184                                for (int x = 0; x < newWidth; x++) {
    187185                                        targetData [newLineStart + x] = srcData [(int) (oldLineStart + ratioX * x)];
    188186                                }
    … …  
    198196
    199197                        Profiler.BeginSample ("LoadImage");
    200                         if (array != null && blockMap.LoadImage (array) && blockMap.height == Constants.MAP_BLOCK_SIZE &&
    201                             blockMap.width == Constants.MAP_BLOCK_SIZE) {
     198                        if (array != null && blockMap.LoadImage (array) && blockMap.height == Constants.MapBlockSize &&
     199                            blockMap.width == Constants.MapBlockSize) {
    202200                                Profiler.EndSample ();
    203201
    … …  
    211209                        }
    212210
    213                         if (blockMap.format != Constants.DEFAULT_TEX_FORMAT || blockMap.height != Constants.MAP_BLOCK_SIZE ||
    214                             blockMap.width != Constants.MAP_BLOCK_SIZE) {
    215                                 blockMap.Resize (Constants.MAP_BLOCK_SIZE, Constants.MAP_BLOCK_SIZE, Constants.DEFAULT_TEX_FORMAT,
     211                        if (blockMap.format != Constants.DefaultTextureFormat || blockMap.height != Constants.MapBlockSize ||
     212                            blockMap.width != Constants.MapBlockSize) {
     213                                blockMap.Resize (Constants.MapBlockSize, Constants.MapBlockSize, Constants.DefaultTextureFormat,
    216214                                        false);
    217215                        }

  • binary-improvements2/MapRendering/src/MapRenderer.cs

    r390 r391  
    1111using Object = UnityEngine.Object;
    1212
    13 namespace AllocsFixes.MapRendering {
    14         public class MapRendering {
    15                 private static MapRendering instance;
     13namespace MapRendering {
     14        public class MapRenderer {
     15                private static MapRenderer instance;
    1616
    1717                private static readonly object lockObject = new object ();
    1818                public static bool renderingEnabled = true;
    19                 private readonly MapTileCache cache = new MapTileCache (Constants.MAP_BLOCK_SIZE);
     19                private readonly MapTileCache cache = new MapTileCache (Constants.MapBlockSize);
    2020                private readonly Dictionary<Vector2i, Color32[]> dirtyChunks = new Dictionary<Vector2i, Color32[]> ();
    2121                private readonly MicroStopwatch msw = new MicroStopwatch ();
    … …  
    2626                private bool shutdown;
    2727
    28                 private MapRendering () {
    29                         Constants.MAP_DIRECTORY = GameIO.GetSaveGameDir () + "/map";
     28                private MapRenderer () {
     29                        Constants.MapDirectory = GameIO.GetSaveGameDir () + "/map";
    3030
    3131                        lock (lockObject) {
    … …  
    3535                        }
    3636
    37                         cache.SetZoomCount (Constants.ZOOMLEVELS);
    38 
    39                         zoomLevelBuffers = new MapRenderBlockBuffer[Constants.ZOOMLEVELS];
    40                         for (int i = 0; i < Constants.ZOOMLEVELS; i++) {
     37                        cache.SetZoomCount (Constants.Zoomlevels);
     38
     39                        zoomLevelBuffers = new MapRenderBlockBuffer[Constants.Zoomlevels];
     40                        for (int i = 0; i < Constants.Zoomlevels; i++) {
    4141                                zoomLevelBuffers [i] = new MapRenderBlockBuffer (i, cache);
    4242                        }
    … …  
    4545                }
    4646
    47                 public static MapRendering Instance {
    48                         get {
    49                                 if (instance == null) {
    50                                         instance = new MapRendering ();
    51                                 }
    52 
    53                                 return instance;
    54                         }
    55                 }
     47                public static MapRenderer Instance => instance ??= new MapRenderer ();
    5648
    5749                public static MapTileCache GetTileCache () {
    … …  
    7769                                ThreadPool.UnsafeQueueUserWorkItem (_o => {
    7870                                        try {
    79                                                 if (!Instance.renderingFullMap) {
    80                                                         lock (lockObject) {
    81                                                                 Chunk c = (Chunk) _o;
    82                                                                 Vector3i cPos = c.GetWorldPos ();
    83                                                                 Vector2i cPos2 = new Vector2i (cPos.x / Constants.MAP_CHUNK_SIZE,
    84                                                                         cPos.z / Constants.MAP_CHUNK_SIZE);
    85 
    86                                                                 ushort[] mapColors = c.GetMapColors ();
    87                                                                 if (mapColors != null) {
    88                                                                         Color32[] realColors =
    89                                                                                 new Color32[Constants.MAP_CHUNK_SIZE * Constants.MAP_CHUNK_SIZE];
    90                                                                         for (int i_colors = 0; i_colors < mapColors.Length; i_colors++) {
    91                                                                                 realColors [i_colors] = shortColorToColor32 (mapColors [i_colors]);
    92                                                                         }
    93 
    94                                                                         Instance.dirtyChunks [cPos2] = realColors;
    95 
    96                                                                         //Log.Out ("Add Dirty: " + cPos2);
    97                                                                 }
     71                                                if (Instance.renderingFullMap) {
     72                                                        return;
     73                                                }
     74
     75                                                lock (lockObject) {
     76                                                        Chunk c = (Chunk) _o;
     77                                                        Vector3i cPos = c.GetWorldPos ();
     78                                                        Vector2i cPos2 = new Vector2i (cPos.x / Constants.MapChunkSize,
     79                                                                cPos.z / Constants.MapChunkSize);
     80
     81                                                        ushort[] mapColors = c.GetMapColors ();
     82                                                        if (mapColors == null) {
     83                                                                return;
    9884                                                        }
     85
     86                                                        Color32[] realColors =
     87                                                                new Color32[Constants.MapChunkSize * Constants.MapChunkSize];
     88                                                        for (int iColors = 0; iColors < mapColors.Length; iColors++) {
     89                                                                realColors [iColors] = shortColorToColor32 (mapColors [iColors]);
     90                                                        }
     91
     92                                                        Instance.dirtyChunks [cPos2] = realColors;
     93
     94                                                        //Log.Out ("Add Dirty: " + cPos2);
    9995                                                }
    10096                                        } catch (Exception e) {
    … …  
    112108                        Texture2D fullMapTexture = null;
    113109
    114                         Vector2i minChunk, maxChunk;
    115                         Vector2i minPos, maxPos;
    116                         int widthChunks, heightChunks, widthPix, heightPix;
    117                         getWorldExtent (rfm, out minChunk, out maxChunk, out minPos, out maxPos, out widthChunks, out heightChunks,
    118                                 out widthPix, out heightPix);
    119 
    120                         Log.Out (string.Format (
    121                                 "RenderMap: min: {0}, max: {1}, minPos: {2}, maxPos: {3}, w/h: {4}/{5}, wP/hP: {6}/{7}",
    122                                 minChunk.ToString (), maxChunk.ToString (),
    123                                 minPos.ToString (), maxPos.ToString (),
    124                                 widthChunks, heightChunks,
    125                                 widthPix, heightPix)
     110                        getWorldExtent (rfm, out Vector2i minChunk, out Vector2i maxChunk, out Vector2i minPos, out Vector2i maxPos, out int widthChunks, out int heightChunks,
     111                                out int widthPix, out int heightPix);
     112
     113                        Log.Out (
     114                                $"RenderMap: min: {minChunk.ToString ()}, max: {maxChunk.ToString ()}, minPos: {minPos.ToString ()}, maxPos: {maxPos.ToString ()}, w/h: {widthChunks}/{heightChunks}, wP/hP: {widthPix}/{heightPix}"
    126115                        );
    127116
    128117                        lock (lockObject) {
    129                                 for (int i = 0; i < Constants.ZOOMLEVELS; i++) {
     118                                for (int i = 0; i < Constants.Zoomlevels; i++) {
    130119                                        zoomLevelBuffers [i].ResetBlock ();
    131120                                }
    132121
    133                                 if (Directory.Exists (Constants.MAP_DIRECTORY)) {
    134                                         Directory.Delete (Constants.MAP_DIRECTORY, true);
     122                                if (Directory.Exists (Constants.MapDirectory)) {
     123                                        Directory.Delete (Constants.MapDirectory, true);
    135124                                }
    136125
    … …  
    143132                                }
    144133
    145                                 Vector2i curFullMapPos = default (Vector2i);
    146                                 Vector2i curChunkPos = default (Vector2i);
    147                                 for (curFullMapPos.x = 0; curFullMapPos.x < widthPix; curFullMapPos.x += Constants.MAP_CHUNK_SIZE) {
     134                                Vector2i curFullMapPos = default;
     135                                Vector2i curChunkPos = default;
     136                                for (curFullMapPos.x = 0; curFullMapPos.x < widthPix; curFullMapPos.x += Constants.MapChunkSize) {
    148137                                        for (curFullMapPos.y = 0;
    149138                                                curFullMapPos.y < heightPix;
    150                                                 curFullMapPos.y += Constants.MAP_CHUNK_SIZE) {
    151                                                 curChunkPos.x = curFullMapPos.x / Constants.MAP_CHUNK_SIZE + minChunk.x;
    152                                                 curChunkPos.y = curFullMapPos.y / Constants.MAP_CHUNK_SIZE + minChunk.y;
     139                                                curFullMapPos.y += Constants.MapChunkSize) {
     140                                                curChunkPos.x = curFullMapPos.x / Constants.MapChunkSize + minChunk.x;
     141                                                curChunkPos.y = curFullMapPos.y / Constants.MapChunkSize + minChunk.y;
    153142
    154143                                                try {
    … …  
    159148                                                                if (mapColors != null) {
    160149                                                                        Color32[] realColors =
    161                                                                                 new Color32[Constants.MAP_CHUNK_SIZE * Constants.MAP_CHUNK_SIZE];
    162                                                                         for (int i_colors = 0; i_colors < mapColors.Length; i_colors++) {
    163                                                                                 realColors [i_colors] = shortColorToColor32 (mapColors [i_colors]);
     150                                                                                new Color32[Constants.MapChunkSize * Constants.MapChunkSize];
     151                                                                        for (int iColors = 0; iColors < mapColors.Length; iColors++) {
     152                                                                                realColors [iColors] = shortColorToColor32 (mapColors [iColors]);
    164153                                                                        }
    165154
    … …  
    167156                                                                        if (fullMapTexture != null) {
    168157                                                                                fullMapTexture.SetPixels32 (curFullMapPos.x, curFullMapPos.y,
    169                                                                                         Constants.MAP_CHUNK_SIZE, Constants.MAP_CHUNK_SIZE, realColors);
     158                                                                                        Constants.MapChunkSize, Constants.MapChunkSize, realColors);
    170159                                                                        }
    171160                                                                }
    … …  
    180169                                        }
    181170
    182                                         Log.Out (string.Format ("RenderMap: {0}/{1} ({2}%)", curFullMapPos.x, widthPix,
    183                                                 (int) ((float) curFullMapPos.x / widthPix * 100)));
     171                                        Log.Out ($"RenderMap: {curFullMapPos.x}/{widthPix} ({(int)((float)curFullMapPos.x / widthPix * 100)}%)");
    184172                                }
    185173                        }
    … …  
    189177                        if (fullMapTexture != null) {
    190178                                byte[] array = fullMapTexture.EncodeToPNG ();
    191                                 File.WriteAllBytes (Constants.MAP_DIRECTORY + "/map.png", array);
     179                                File.WriteAllBytes (Constants.MapDirectory + "/map.png", array);
    192180                                Object.Destroy (fullMapTexture);
    193181                        }
    … …  
    200188
    201189                private void SaveAllBlockMaps () {
    202                         for (int i = 0; i < Constants.ZOOMLEVELS; i++) {
     190                        for (int i = 0; i < Constants.Zoomlevels; i++) {
    203191                                zoomLevelBuffers [i].SaveBlock ();
    204192                        }
    … …  
    246234                        //Log.Out ("Start Dirty: " + chunkPos);
    247235
    248                         getBlockNumber (chunkPos, out Vector2i block, out _, Constants.MAP_BLOCK_TO_CHUNK_DIV, Constants.MAP_CHUNK_SIZE);
    249 
    250                         zoomLevelBuffers [Constants.ZOOMLEVELS - 1].LoadBlock (block);
     236                        getBlockNumber (chunkPos, out Vector2i block, out _, Constants.MAP_BLOCK_TO_CHUNK_DIV, Constants.MapChunkSize);
     237
     238                        zoomLevelBuffers [Constants.Zoomlevels - 1].LoadBlock (block);
    251239                        Profiler.EndSample ();
    252240
    253241                        Profiler.BeginSample ("RenderDirtyChunks.Work");
    254242                        // Write all chunks that are in the same image tile of the highest zoom level
    255                         Vector2i v_block, v_blockOffset;
    256243                        foreach (Vector2i v in chunksToRender) {
    257                                 getBlockNumber (v, out v_block, out v_blockOffset, Constants.MAP_BLOCK_TO_CHUNK_DIV,
    258                                         Constants.MAP_CHUNK_SIZE);
    259                                 if (v_block.Equals (block)) {
    260                                         //Log.Out ("Dirty: " + v + " render: true");
    261                                         chunksRendered.Add (v);
    262                                         if (dirtyChunks [v].Length != Constants.MAP_CHUNK_SIZE * Constants.MAP_CHUNK_SIZE) {
    263                                                 Log.Error (string.Format ("Rendering chunk has incorrect data size of {0} instead of {1}",
    264                                                         dirtyChunks [v].Length, Constants.MAP_CHUNK_SIZE * Constants.MAP_CHUNK_SIZE));
    265                                         }
    266 
    267                                         zoomLevelBuffers [Constants.ZOOMLEVELS - 1]
    268                                                 .SetPart (v_blockOffset, Constants.MAP_CHUNK_SIZE, dirtyChunks [v]);
    269                                 }
     244                                getBlockNumber (v, out Vector2i vBlock, out Vector2i vBlockOffset, Constants.MAP_BLOCK_TO_CHUNK_DIV,
     245                                        Constants.MapChunkSize);
     246                                if (!vBlock.Equals (block)) {
     247                                        continue;
     248                                }
     249
     250                                //Log.Out ("Dirty: " + v + " render: true");
     251                                chunksRendered.Add (v);
     252                                if (dirtyChunks [v].Length != Constants.MapChunkSize * Constants.MapChunkSize) {
     253                                        Log.Error (
     254                                                $"Rendering chunk has incorrect data size of {dirtyChunks [v].Length} instead of {Constants.MapChunkSize * Constants.MapChunkSize}");
     255                                }
     256
     257                                zoomLevelBuffers [Constants.Zoomlevels - 1]
     258                                        .SetPart (vBlockOffset, Constants.MapChunkSize, dirtyChunks [v]);
    270259                        }
    271260                        Profiler.EndSample ();
    … …  
    285274                private void RenderZoomLevel (Vector2i _innerBlock) {
    286275                        Profiler.BeginSample ("RenderZoomLevel");
    287                         int level = Constants.ZOOMLEVELS - 1;
     276                        int level = Constants.Zoomlevels - 1;
    288277                        while (level > 0) {
    289                                 Vector2i block, blockOffset;
    290                                 getBlockNumber (_innerBlock, out block, out blockOffset, 2, Constants.MAP_BLOCK_SIZE / 2);
     278                                getBlockNumber (_innerBlock, out Vector2i block, out Vector2i blockOffset, 2, Constants.MapBlockSize / 2);
    291279
    292280                                zoomLevelBuffers [level - 1].LoadBlock (block);
    … …  
    296284                                     zoomLevelBuffers [level].FormatSelf == TextureFormat.RGBA32) &&
    297285                                    zoomLevelBuffers [level].FormatSelf == zoomLevelBuffers [level - 1].FormatSelf) {
    298                                         zoomLevelBuffers [level - 1].SetPartNative (blockOffset, Constants.MAP_BLOCK_SIZE / 2, zoomLevelBuffers [level].GetHalfScaledNative ());
     286                                        zoomLevelBuffers [level - 1].SetPartNative (blockOffset, Constants.MapBlockSize / 2, zoomLevelBuffers [level].GetHalfScaledNative ());
    299287                                } else {
    300                                         zoomLevelBuffers [level - 1].SetPart (blockOffset, Constants.MAP_BLOCK_SIZE / 2, zoomLevelBuffers [level].GetHalfScaled ());
     288                                        zoomLevelBuffers [level - 1].SetPart (blockOffset, Constants.MapBlockSize / 2, zoomLevelBuffers [level].GetHalfScaled ());
    301289                                }
    302290                                Profiler.EndSample ();
    … …  
    310298                private void getBlockNumber (Vector2i _innerPos, out Vector2i _block, out Vector2i _blockOffset, int _scaleFactor,
    311299                        int _offsetSize) {
    312                         _block = default (Vector2i);
    313                         _blockOffset = default (Vector2i);
     300                        _block = default;
     301                        _blockOffset = default;
    314302                        _block.x = (_innerPos.x + 16777216) / _scaleFactor - 16777216 / _scaleFactor;
    315303                        _block.y = (_innerPos.y + 16777216) / _scaleFactor - 16777216 / _scaleFactor;
    … …  
    319307
    320308                private void WriteMapInfo () {
    321                         JSONObject mapInfo = new JSONObject ();
    322                         mapInfo.Add ("blockSize", new JSONNumber (Constants.MAP_BLOCK_SIZE));
    323                         mapInfo.Add ("maxZoom", new JSONNumber (Constants.ZOOMLEVELS - 1));
    324 
    325                         Directory.CreateDirectory (Constants.MAP_DIRECTORY);
    326                         File.WriteAllText (Constants.MAP_DIRECTORY + "/mapinfo.json", mapInfo.ToString (), Encoding.UTF8);
     309                        JsonObject mapInfo = new JsonObject ();
     310                        mapInfo.Add ("blockSize", new JsonNumber (Constants.MapBlockSize));
     311                        mapInfo.Add ("maxZoom", new JsonNumber (Constants.Zoomlevels - 1));
     312
     313                        Directory.CreateDirectory (Constants.MapDirectory);
     314                        File.WriteAllText (Constants.MapDirectory + "/mapinfo.json", mapInfo.ToString (), Encoding.UTF8);
    327315                }
    328316
    329317                private bool LoadMapInfo () {
    330                         if (!File.Exists (Constants.MAP_DIRECTORY + "/mapinfo.json")) {
     318                        if (!File.Exists (Constants.MapDirectory + "/mapinfo.json")) {
    331319                                return false;
    332320                        }
    333321
    334                         string json = File.ReadAllText (Constants.MAP_DIRECTORY + "/mapinfo.json", Encoding.UTF8);
     322                        string json = File.ReadAllText (Constants.MapDirectory + "/mapinfo.json", Encoding.UTF8);
    335323                        try {
    336                                 JSONNode node = Parser.Parse (json);
    337                                 if (node is JSONObject) {
    338                                         JSONObject jo = (JSONObject) node;
     324                                JsonNode node = Parser.Parse (json);
     325                                if (node is JsonObject jo) {
    339326                                        if (jo.ContainsKey ("blockSize")) {
    340                                                 Constants.MAP_BLOCK_SIZE = ((JSONNumber) jo ["blockSize"]).GetInt ();
     327                                                Constants.MapBlockSize = ((JsonNumber) jo ["blockSize"]).GetInt ();
    341328                                        }
    342329
    343330                                        if (jo.ContainsKey ("maxZoom")) {
    344                                                 Constants.ZOOMLEVELS = ((JSONNumber) jo ["maxZoom"]).GetInt () + 1;
     331                                                Constants.Zoomlevels = ((JsonNumber) jo ["maxZoom"]).GetInt () + 1;
    345332                                        }
    346333
    347334                                        return true;
    348335                                }
    349                         } catch (MalformedJSONException e) {
     336                        } catch (MalformedJsonException e) {
    350337                                Log.Out ("Exception in LoadMapInfo: " + e);
    351338                        } catch (InvalidCastException e) {
    … …  
    360347                        out int _widthChunks, out int _heightChunks,
    361348                        out int _widthPix, out int _heightPix) {
    362                         _minChunk = default (Vector2i);
    363                         _maxChunk = default (Vector2i);
    364                         _minPos = default (Vector2i);
    365                         _maxPos = default (Vector2i);
     349                        _minChunk = default;
     350                        _maxChunk = default;
     351                        _minPos = default;
     352                        _maxPos = default;
    366353
    367354                        long[] keys = _rfm.GetAllChunkKeys ();
    … …  
    397384                        _maxChunk.y = maxY;
    398385
    399                         _minPos.x = minX * Constants.MAP_CHUNK_SIZE;
    400                         _minPos.y = minY * Constants.MAP_CHUNK_SIZE;
    401 
    402                         _maxPos.x = maxX * Constants.MAP_CHUNK_SIZE;
    403                         _maxPos.y = maxY * Constants.MAP_CHUNK_SIZE;
     386                        _minPos.x = minX * Constants.MapChunkSize;
     387                        _minPos.y = minY * Constants.MapChunkSize;
     388
     389                        _maxPos.x = maxX * Constants.MapChunkSize;
     390                        _maxPos.y = maxY * Constants.MapChunkSize;
    404391
    405392                        _widthChunks = maxX - minX + 1;
    406393                        _heightChunks = maxY - minY + 1;
    407394
    408                         _widthPix = _widthChunks * Constants.MAP_CHUNK_SIZE;
    409                         _heightPix = _heightChunks * Constants.MAP_CHUNK_SIZE;
     395                        _widthPix = _widthChunks * Constants.MapChunkSize;
     396                        _heightPix = _heightChunks * Constants.MapChunkSize;
    410397                }
    411398

  • binary-improvements2/MapRendering/src/ModApi.cs

    r390 r391  
    1 using AllocsFixes.NetConnections.Servers.Web;
    2 using AllocsFixes.NetConnections.Servers.Web.Handlers;
     1using JetBrains.Annotations;
    32
    4 namespace AllocsFixes {
    5         public class API : IModApi {
    6                 private Web webInstance;
    7                 private Mod modInstance;
    8                
     3namespace MapRendering {
     4        [UsedImplicitly]
     5        public class ModApi : IModApi {
    96                public void InitMod (Mod _modInstance) {
    10                         ModEvents.GameStartDone.RegisterHandler (GameStartDone);
    117                        ModEvents.GameShutdown.RegisterHandler (GameShutdown);
    128                        ModEvents.CalcChunkColorsDone.RegisterHandler (CalcChunkColorsDone);
    13                         modInstance = _modInstance;
    14                 }
    15 
    16                 private void GameStartDone () {
    17                         // ReSharper disable once ObjectCreationAsStatement
    18                         if (!ConnectionManager.Instance.IsServer) {
    19                                 return;
    20                         }
    21                        
    22                         webInstance = new Web (modInstance.Path);
    23                         LogBuffer.Init ();
    24 
    25                         if (ItemIconHandler.Instance != null) {
    26                                 ItemIconHandler.Instance.LoadIcons ();
    27                         }
    289                }
    2910
    3011                private void GameShutdown () {
    31                         webInstance?.Shutdown ();
    32                         MapRendering.MapRendering.Shutdown ();
     12                        MapRenderer.Shutdown ();
    3313                }
    3414
    3515                private void CalcChunkColorsDone (Chunk _chunk) {
    36                         MapRendering.MapRendering.RenderSingleChunk (_chunk);
     16                        MapRenderer.RenderSingleChunk (_chunk);
    3717                }
    3818        }
Note: See TracChangeset for help on using the changeset viewer.