TexturedMapTileRenderer.cs 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418
  1. /*
  2. * Copyright (c) Contributors, http://opensimulator.org/
  3. * See CONTRIBUTORS.TXT for a full list of copyright holders.
  4. *
  5. * Redistribution and use in source and binary forms, with or without
  6. * modification, are permitted provided that the following conditions are met:
  7. * * Redistributions of source code must retain the above copyright
  8. * notice, this list of conditions and the following disclaimer.
  9. * * Redistributions in binary form must reproduce the above copyright
  10. * notice, this list of conditions and the following disclaimer in the
  11. * documentation and/or other materials provided with the distribution.
  12. * * Neither the name of the OpenSimulator Project nor the
  13. * names of its contributors may be used to endorse or promote products
  14. * derived from this software without specific prior written permission.
  15. *
  16. * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
  17. * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  18. * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  19. * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
  20. * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  21. * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  22. * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  23. * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24. * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  25. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26. */
  27. using System;
  28. using System.Collections.Generic;
  29. using System.Drawing;
  30. using System.Reflection;
  31. using log4net;
  32. using Nini.Config;
  33. using OpenMetaverse;
  34. using OpenMetaverse.Imaging;
  35. using OpenSim.Framework;
  36. using OpenSim.Region.Framework.Scenes;
  37. namespace OpenSim.Region.CoreModules.World.LegacyMap
  38. {
  39. // Hue, Saturation, Value; used for color-interpolation
  40. struct HSV {
  41. private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
  42. public float h;
  43. public float s;
  44. public float v;
  45. public HSV(float h, float s, float v)
  46. {
  47. this.h = h;
  48. this.s = s;
  49. this.v = v;
  50. }
  51. // (for info about algorithm, see http://en.wikipedia.org/wiki/HSL_and_HSV)
  52. public HSV(Color c)
  53. {
  54. float r = c.R / 255f;
  55. float g = c.G / 255f;
  56. float b = c.B / 255f;
  57. float max = Math.Max(Math.Max(r, g), b);
  58. float min = Math.Min(Math.Min(r, g), b);
  59. float diff = max - min;
  60. if (max == min) h = 0f;
  61. else if (max == r) h = (g - b) / diff * 60f;
  62. else if (max == g) h = (b - r) / diff * 60f + 120f;
  63. else h = (r - g) / diff * 60f + 240f;
  64. if (h < 0f) h += 360f;
  65. if (max == 0f) s = 0f;
  66. else s = diff / max;
  67. v = max;
  68. }
  69. // (for info about algorithm, see http://en.wikipedia.org/wiki/HSL_and_HSV)
  70. public Color toColor()
  71. {
  72. if (s < 0f) m_log.Debug("S < 0: " + s);
  73. else if (s > 1f) m_log.Debug("S > 1: " + s);
  74. if (v < 0f) m_log.Debug("V < 0: " + v);
  75. else if (v > 1f) m_log.Debug("V > 1: " + v);
  76. float f = h / 60f;
  77. int sector = (int)f % 6;
  78. f = f - (int)f;
  79. int pi = (int)(v * (1f - s) * 255f);
  80. int qi = (int)(v * (1f - s * f) * 255f);
  81. int ti = (int)(v * (1f - (1f - f) * s) * 255f);
  82. int vi = (int)(v * 255f);
  83. if (pi < 0) pi = 0;
  84. if (pi > 255) pi = 255;
  85. if (qi < 0) qi = 0;
  86. if (qi > 255) qi = 255;
  87. if (ti < 0) ti = 0;
  88. if (ti > 255) ti = 255;
  89. if (vi < 0) vi = 0;
  90. if (vi > 255) vi = 255;
  91. switch (sector)
  92. {
  93. case 0:
  94. return Color.FromArgb(vi, ti, pi);
  95. case 1:
  96. return Color.FromArgb(qi, vi, pi);
  97. case 2:
  98. return Color.FromArgb(pi, vi, ti);
  99. case 3:
  100. return Color.FromArgb(pi, qi, vi);
  101. case 4:
  102. return Color.FromArgb(ti, pi, vi);
  103. default:
  104. return Color.FromArgb(vi, pi, qi);
  105. }
  106. }
  107. }
  108. public class TexturedMapTileRenderer : IMapTileTerrainRenderer
  109. {
  110. #region Constants
  111. private static readonly ILog m_log =
  112. LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
  113. // some hardcoded terrain UUIDs that work with SL 1.20 (the four default textures and "Blank").
  114. // The color-values were choosen because they "look right" (at least to me) ;-)
  115. private static readonly UUID defaultTerrainTexture1 = new UUID("0bc58228-74a0-7e83-89bc-5c23464bcec5");
  116. private static readonly Color defaultColor1 = Color.FromArgb(165, 137, 118);
  117. private static readonly UUID defaultTerrainTexture2 = new UUID("63338ede-0037-c4fd-855b-015d77112fc8");
  118. private static readonly Color defaultColor2 = Color.FromArgb(69, 89, 49);
  119. private static readonly UUID defaultTerrainTexture3 = new UUID("303cd381-8560-7579-23f1-f0a880799740");
  120. private static readonly Color defaultColor3 = Color.FromArgb(162, 154, 141);
  121. private static readonly UUID defaultTerrainTexture4 = new UUID("53a2f406-4895-1d13-d541-d2e3b86bc19c");
  122. private static readonly Color defaultColor4 = Color.FromArgb(200, 200, 200);
  123. private static readonly Color WATER_COLOR = Color.FromArgb(29, 71, 95);
  124. #endregion
  125. private Scene m_scene;
  126. // private IConfigSource m_config; // not used currently
  127. // mapping from texture UUIDs to averaged color. This will contain 5-9 values, in general; new values are only
  128. // added when the terrain textures are changed in the estate dialog and a new map is generated (and will stay in
  129. // that map until the region-server restarts. This could be considered a memory-leak, but it's a *very* small one.
  130. // TODO does it make sense to use a "real" cache and regenerate missing entries on fetch?
  131. private Dictionary<UUID, Color> m_mapping;
  132. public void Initialise(Scene scene, IConfigSource source)
  133. {
  134. m_scene = scene;
  135. // m_config = source; // not used currently
  136. m_mapping = new Dictionary<UUID,Color>();
  137. m_mapping.Add(defaultTerrainTexture1, defaultColor1);
  138. m_mapping.Add(defaultTerrainTexture2, defaultColor2);
  139. m_mapping.Add(defaultTerrainTexture3, defaultColor3);
  140. m_mapping.Add(defaultTerrainTexture4, defaultColor4);
  141. m_mapping.Add(Util.BLANK_TEXTURE_UUID, Color.White);
  142. }
  143. #region Helpers
  144. // This fetches the texture from the asset server synchroneously. That should be ok, as we
  145. // call map-creation only in those places:
  146. // - on start: We can wait here until the asset server returns the texture
  147. // TODO (- on "map" command: We are in the command-line thread, we will wait for completion anyway)
  148. // TODO (- on "automatic" update after some change: We are called from the mapUpdateTimer here and
  149. // will wait anyway)
  150. private Bitmap fetchTexture(UUID id)
  151. {
  152. AssetBase asset = m_scene.AssetService.Get(id.ToString());
  153. m_log.DebugFormat("[TexturedMapTileRenderer]: Fetched texture {0}, found: {1}", id, asset != null);
  154. if (asset == null) return null;
  155. ManagedImage managedImage;
  156. Image image;
  157. try
  158. {
  159. if (OpenJPEG.DecodeToImage(asset.Data, out managedImage, out image))
  160. return new Bitmap(image);
  161. else
  162. return null;
  163. }
  164. catch (DllNotFoundException)
  165. {
  166. m_log.ErrorFormat("[TexturedMapTileRenderer]: OpenJpeg is not installed correctly on this system. Asset Data is empty for {0}", id);
  167. }
  168. catch (IndexOutOfRangeException)
  169. {
  170. m_log.ErrorFormat("[TexturedMapTileRenderer]: OpenJpeg was unable to encode this. Asset Data is empty for {0}", id);
  171. }
  172. catch (Exception)
  173. {
  174. m_log.ErrorFormat("[TexturedMapTileRenderer]: OpenJpeg was unable to encode this. Asset Data is empty for {0}", id);
  175. }
  176. return null;
  177. }
  178. // Compute the average color of a texture.
  179. private Color computeAverageColor(Bitmap bmp)
  180. {
  181. // we have 256 x 256 pixel, each with 256 possible color-values per
  182. // color-channel, so 2^24 is the maximum value we can get, adding everything.
  183. // int is be big enough for that.
  184. int r = 0, g = 0, b = 0;
  185. for (int y = 0; y < bmp.Height; ++y)
  186. {
  187. for (int x = 0; x < bmp.Width; ++x)
  188. {
  189. Color c = bmp.GetPixel(x, y);
  190. r += (int)c.R & 0xff;
  191. g += (int)c.G & 0xff;
  192. b += (int)c.B & 0xff;
  193. }
  194. }
  195. int pixels = bmp.Width * bmp.Height;
  196. return Color.FromArgb(r / pixels, g / pixels, b / pixels);
  197. }
  198. // return either the average color of the texture, or the defaultColor if the texturID is invalid
  199. // or the texture couldn't be found
  200. private Color computeAverageColor(UUID textureID, Color defaultColor) {
  201. if (textureID == UUID.Zero) return defaultColor; // not set
  202. if (m_mapping.ContainsKey(textureID)) return m_mapping[textureID]; // one of the predefined textures
  203. Bitmap bmp = fetchTexture(textureID);
  204. Color color = bmp == null ? defaultColor : computeAverageColor(bmp);
  205. // store it for future reference
  206. m_mapping[textureID] = color;
  207. return color;
  208. }
  209. // S-curve: f(x) = 3x² - 2x³:
  210. // f(0) = 0, f(0.5) = 0.5, f(1) = 1,
  211. // f'(x) = 0 at x = 0 and x = 1; f'(0.5) = 1.5,
  212. // f''(0.5) = 0, f''(x) != 0 for x != 0.5
  213. private float S(float v) {
  214. return (v * v * (3f - 2f * v));
  215. }
  216. // interpolate two colors in HSV space and return the resulting color
  217. private HSV interpolateHSV(ref HSV c1, ref HSV c2, float ratio) {
  218. if (ratio <= 0f) return c1;
  219. if (ratio >= 1f) return c2;
  220. // make sure we are on the same side on the hue-circle for interpolation
  221. // We change the hue of the parameters here, but we don't change the color
  222. // represented by that value
  223. if (c1.h - c2.h > 180f) c1.h -= 360f;
  224. else if (c2.h - c1.h > 180f) c1.h += 360f;
  225. return new HSV(c1.h * (1f - ratio) + c2.h * ratio,
  226. c1.s * (1f - ratio) + c2.s * ratio,
  227. c1.v * (1f - ratio) + c2.v * ratio);
  228. }
  229. // the heigthfield might have some jumps in values. Rendered land is smooth, though,
  230. // as a slope is rendered at that place. So average 4 neighbour values to emulate that.
  231. private float getHeight(double[,] hm, int x, int y) {
  232. if (x < ((int)Constants.RegionSize - 1) && y < ((int)Constants.RegionSize - 1))
  233. return (float)(hm[x, y] * .444 + (hm[x + 1, y] + hm[x, y + 1]) * .222 + hm[x + 1, y +1] * .112);
  234. else
  235. return (float)hm[x, y];
  236. }
  237. #endregion
  238. public void TerrainToBitmap(Bitmap mapbmp)
  239. {
  240. int tc = Environment.TickCount;
  241. m_log.Info("[MAPTILE]: Generating Maptile Step 1: Terrain");
  242. // These textures should be in the AssetCache anyway, as every client conneting to this
  243. // region needs them. Except on start, when the map is recreated (before anyone connected),
  244. // and on change of the estate settings (textures and terrain values), when the map should
  245. // be recreated.
  246. RegionSettings settings = m_scene.RegionInfo.RegionSettings;
  247. // the four terrain colors as HSVs for interpolation
  248. HSV hsv1 = new HSV(computeAverageColor(settings.TerrainTexture1, defaultColor1));
  249. HSV hsv2 = new HSV(computeAverageColor(settings.TerrainTexture2, defaultColor2));
  250. HSV hsv3 = new HSV(computeAverageColor(settings.TerrainTexture3, defaultColor3));
  251. HSV hsv4 = new HSV(computeAverageColor(settings.TerrainTexture4, defaultColor4));
  252. float levelNElow = (float)settings.Elevation1NE;
  253. float levelNEhigh = (float)settings.Elevation2NE;
  254. float levelNWlow = (float)settings.Elevation1NW;
  255. float levelNWhigh = (float)settings.Elevation2NW;
  256. float levelSElow = (float)settings.Elevation1SE;
  257. float levelSEhigh = (float)settings.Elevation2SE;
  258. float levelSWlow = (float)settings.Elevation1SW;
  259. float levelSWhigh = (float)settings.Elevation2SW;
  260. float waterHeight = (float)settings.WaterHeight;
  261. double[,] hm = m_scene.Heightmap.GetDoubles();
  262. for (int x = 0; x < (int)Constants.RegionSize; x++)
  263. {
  264. float columnRatio = x / ((float)Constants.RegionSize - 1); // 0 - 1, for interpolation
  265. for (int y = 0; y < (int)Constants.RegionSize; y++)
  266. {
  267. float rowRatio = y / ((float)Constants.RegionSize - 1); // 0 - 1, for interpolation
  268. // Y flip the cordinates for the bitmap: hf origin is lower left, bm origin is upper left
  269. int yr = ((int)Constants.RegionSize - 1) - y;
  270. float heightvalue = getHeight(hm, x, y);
  271. if (Single.IsInfinity(heightvalue) || Single.IsNaN(heightvalue))
  272. heightvalue = 0;
  273. if (heightvalue > waterHeight)
  274. {
  275. // add a bit noise for breaking up those flat colors:
  276. // - a large-scale noise, for the "patches" (using an doubled s-curve for sharper contrast)
  277. // - a small-scale noise, for bringing in some small scale variation
  278. //float bigNoise = (float)TerrainUtil.InterpolatedNoise(x / 8.0, y / 8.0) * .5f + .5f; // map to 0.0 - 1.0
  279. //float smallNoise = (float)TerrainUtil.InterpolatedNoise(x + 33, y + 43) * .5f + .5f;
  280. //float hmod = heightvalue + smallNoise * 3f + S(S(bigNoise)) * 10f;
  281. float hmod =
  282. heightvalue +
  283. (float)TerrainUtil.InterpolatedNoise(x + 33, y + 43) * 1.5f + 1.5f + // 0 - 3
  284. S(S((float)TerrainUtil.InterpolatedNoise(x / 8.0, y / 8.0) * .5f + .5f)) * 10f; // 0 - 10
  285. // find the low/high values for this point (interpolated bilinearily)
  286. // (and remember, x=0,y=0 is SW)
  287. float low = levelSWlow * (1f - rowRatio) * (1f - columnRatio) +
  288. levelSElow * (1f - rowRatio) * columnRatio +
  289. levelNWlow * rowRatio * (1f - columnRatio) +
  290. levelNElow * rowRatio * columnRatio;
  291. float high = levelSWhigh * (1f - rowRatio) * (1f - columnRatio) +
  292. levelSEhigh * (1f - rowRatio) * columnRatio +
  293. levelNWhigh * rowRatio * (1f - columnRatio) +
  294. levelNEhigh * rowRatio * columnRatio;
  295. if (high < low)
  296. {
  297. // someone tried to fool us. High value should be higher than low every time
  298. float tmp = high;
  299. high = low;
  300. low = tmp;
  301. }
  302. HSV hsv;
  303. if (hmod <= low) hsv = hsv1; // too low
  304. else if (hmod >= high) hsv = hsv4; // too high
  305. else
  306. {
  307. // HSV-interpolate along the colors
  308. // first, rescale h to 0.0 - 1.0
  309. hmod = (hmod - low) / (high - low);
  310. // now we have to split: 0.00 => color1, 0.33 => color2, 0.67 => color3, 1.00 => color4
  311. if (hmod < 1f/3f) hsv = interpolateHSV(ref hsv1, ref hsv2, hmod * 3f);
  312. else if (hmod < 2f/3f) hsv = interpolateHSV(ref hsv2, ref hsv3, (hmod * 3f) - 1f);
  313. else hsv = interpolateHSV(ref hsv3, ref hsv4, (hmod * 3f) - 2f);
  314. }
  315. // Shade the terrain for shadows
  316. if (x < ((int)Constants.RegionSize - 1) && y < ((int)Constants.RegionSize - 1))
  317. {
  318. float hfvaluecompare = getHeight(hm, x + 1, y + 1); // light from north-east => look at land height there
  319. if (Single.IsInfinity(hfvaluecompare) || Single.IsNaN(hfvaluecompare))
  320. hfvaluecompare = 0f;
  321. float hfdiff = heightvalue - hfvaluecompare; // => positive if NE is lower, negative if here is lower
  322. hfdiff *= 0.06f; // some random factor so "it looks good"
  323. if (hfdiff > 0.02f)
  324. {
  325. float highlightfactor = 0.18f;
  326. // NE is lower than here
  327. // We have to desaturate and lighten the land at the same time
  328. hsv.s = (hsv.s - (hfdiff * highlightfactor) > 0f) ? hsv.s - (hfdiff * highlightfactor) : 0f;
  329. hsv.v = (hsv.v + (hfdiff * highlightfactor) < 1f) ? hsv.v + (hfdiff * highlightfactor) : 1f;
  330. }
  331. else if (hfdiff < -0.02f)
  332. {
  333. // here is lower than NE:
  334. // We have to desaturate and blacken the land at the same time
  335. hsv.s = (hsv.s + hfdiff > 0f) ? hsv.s + hfdiff : 0f;
  336. hsv.v = (hsv.v + hfdiff > 0f) ? hsv.v + hfdiff : 0f;
  337. }
  338. }
  339. mapbmp.SetPixel(x, yr, hsv.toColor());
  340. }
  341. else
  342. {
  343. // We're under the water level with the terrain, so paint water instead of land
  344. heightvalue = waterHeight - heightvalue;
  345. if (Single.IsInfinity(heightvalue) || Single.IsNaN(heightvalue))
  346. heightvalue = 0f;
  347. else if (heightvalue > 19f)
  348. heightvalue = 19f;
  349. else if (heightvalue < 0f)
  350. heightvalue = 0f;
  351. heightvalue = 100f - (heightvalue * 100f) / 19f; // 0 - 19 => 100 - 0
  352. mapbmp.SetPixel(x, yr, WATER_COLOR);
  353. }
  354. }
  355. }
  356. m_log.Info("[MAPTILE]: Generating Maptile Step 1: Done in " + (Environment.TickCount - tc) + " ms");
  357. }
  358. }
  359. }