/// <summary>
/// Initializes a new instance of geometric descriptor for a plane.
/// </summary>
public PlaneProceduralModel()
{
Normal = NormalDirection.UpY;
Size = new Vector2(1.0f);
Tessellation = new Int2(1);
UVScales = new Vector2(1);
}
/// <summary>
/// Upload a character's bitmap into the current cache.
/// </summary>
/// <param name="character">The character specifications corresponding to the bitmap</param>
public void UploadCharacterBitmap(CharacterSpecification character)
{
if(character.Bitmap == null)
throw new ArgumentNullException("character");
if(character.IsBitmapUploaded)
throw new InvalidOperationException("The character '"+character.Character+"' upload has been requested while its current glyph is valid.");
var targetSize = new Int2(character.Bitmap.Width, character.Bitmap.Rows);
if (!packer.Insert(targetSize.X, targetSize.Y, ref character.Glyph.Subrect))
{
// not enough space to place the new character -> remove less used characters and try again
RemoveLessUsedCharacters();
if (!packer.Insert(targetSize.X, targetSize.Y, ref character.Glyph.Subrect))
{
// memory is too fragmented in order to place the new character -> clear all the characters and restart.
ClearCache();
if (!packer.Insert(targetSize.X, targetSize.Y, ref character.Glyph.Subrect))
throw new InvalidOperationException("The rendered character is too big for the cache texture");
}
}
// updload the bitmap on the texture (if the size in the bitmap is not null)
if (character.Bitmap.Rows != 0 && character.Bitmap.Width != 0)
{
var dataBox = new DataBox(character.Bitmap.Buffer, character.Bitmap.Pitch, character.Bitmap.Pitch * character.Bitmap.Rows);
var region = new ResourceRegion(character.Glyph.Subrect.Left, character.Glyph.Subrect.Top, 0, character.Glyph.Subrect.Right, character.Glyph.Subrect.Bottom, 1);
system.GraphicsDevice.UpdateSubresource(cacheTextures[0], 0, dataBox, region);
}
// update the glyph data
character.IsBitmapUploaded = true;
character.Glyph.BitmapIndex = 0;
}
public static Int2[] getPath(Int2 current, Int2 final, GridSystem grid)
{
int width = grid.gridSizeX;
int height = grid.gridSizeZ;
if (width <= current._x || width <= final._x) {
return null;
}
if (height <= current._z || height <= final._z) {
return null;
}
if (grid[current._x, current._z] == null || grid[final._x,final._z] == null)
{
return null;
}
int[,] distanceGrid = new int[width, height];
for (int i = 0; i < width; i++) {
for (int j = 0; j < height; j++) {
distanceGrid[i,j] = -1;
}
}
distanceGrid [current._x, current._z] = 0;
Int2[] path = DFS (current, final, grid, distanceGrid);
Debug.Log ("Path");
for (int i = 0; i < path.Length; i++) {
Debug.Log (path[i]);
}
return path;
}
public bool RemoveBlock(int x, int y)
{
Int2 coord = new Int2(x, y);
if (blocks.ContainsKey(coord))
{
blocks.Remove(coord);
return true;
}
return false;
}
/// <summary>
/// Creates a default instance of packing attributes.
/// </summary>
public PackingAttributes()
{
Enabled = true;
PackingAlgorithm = TexturePackingMethod.Best;
AllowMultipacking = true;
AllowRotations = true;
AtlasMaximumSize = new Int2(2048);
BorderSize = 2;
}
protected override void DrawCore(RenderContext context)
{
var output = PrefilteredRadiance;
if(output == null || (output.Dimension != TextureDimension.Texture2D && output.Dimension != TextureDimension.TextureCube) || output.ArraySize != 6)
throw new NotSupportedException("Only array of 2D textures are currently supported as output");
var input = RadianceMap;
if(input == null || input.Dimension != TextureDimension.TextureCube)
throw new NotSupportedException("Only cubemaps are currently supported as input");
var roughness = 0f;
var faceCount = output.ArraySize;
var levelSize = new Int2(output.Width, output.Height);
var mipCount = MipmapGenerationCount == 0 ? output.MipLevels : MipmapGenerationCount;
for (int l = 0; l < mipCount; l++)
{
if (l == 0 && DoNotFilterHighestLevel && input.Width >= output.Width)
{
var inputLevel = MathUtil.Log2(input.Width / output.Width);
for (int f = 0; f < 6; f++)
{
var inputSubresource = inputLevel + f * input.MipLevels;
var outputSubresource = 0 + f * output.MipLevels;
GraphicsDevice.CopyRegion(input, inputSubresource, null, output, outputSubresource);
}
}
else
{
var outputView = output.ToTextureView(ViewType.MipBand, 0, l);
computeShader.ThreadGroupCounts = new Int3(levelSize.X, levelSize.Y, faceCount);
computeShader.ThreadNumbers = new Int3(SamplingsCount, 1, 1);
computeShader.Parameters.Set(RadiancePrefilteringGGXShaderKeys.Roughness, roughness);
computeShader.Parameters.Set(RadiancePrefilteringGGXShaderKeys.MipmapCount, input.MipLevels - 1);
computeShader.Parameters.Set(RadiancePrefilteringGGXShaderKeys.RadianceMap, input);
computeShader.Parameters.Set(RadiancePrefilteringGGXShaderKeys.RadianceMapSize, input.Width);
computeShader.Parameters.Set(RadiancePrefilteringGGXShaderKeys.FilteredRadiance, outputView);
computeShader.Parameters.Set(RadiancePrefilteringGGXParams.NbOfSamplings, SamplingsCount);
computeShader.Draw(context);
outputView.Dispose();
}
if (mipCount > 1)
{
roughness += 1f / (mipCount - 1);
levelSize /= 2;
}
}
}
/// <summary>
/// Draws to the specified cube at the specified position.
/// </summary>
/// <param name='position'>
/// Position (from bottom left).
/// </param>
/// <param name='cube'>
/// Cube.
/// </param>
public override void DrawTo(Int2 position, Cube cube)
{
base.DrawTo(position, cube);
switch (id)
{
case 0:
cube.FillRect(new Color(128,128,255), Cube.SCREEN_WIDTH/2, Cube.SCREEN_HEIGHT/2-10, 1, 20);
break;
case 1:
cube.FillRect(new Color(128,128,255), Cube.SCREEN_WIDTH/2-4, Cube.SCREEN_HEIGHT/2-10, 1, 20);
cube.FillRect(new Color(128,128,255), Cube.SCREEN_WIDTH/2+4, Cube.SCREEN_HEIGHT/2-10, 1, 20);
break;
}
}
public BackgroundSection(Sprite backgroundSprite, Vector3 screenVirtualResolution, float scrollSpeed, float depth, Vector2 startPos = default(Vector2))
{
screenResolution = new Int2((int)screenVirtualResolution.X, (int)screenVirtualResolution.Y);
screenCenter = new Vector2(screenVirtualResolution.X / 2, screenVirtualResolution.Y /2);
this.depth = depth;
firstQuadPos = startPos;
secondQuadPos = startPos;
ScrollSpeed = scrollSpeed;
ScrollPos = 0;
CreateBackground(backgroundSprite.Texture, backgroundSprite.Region);
}
public BeadSelectorDlg(FloatImg image, int ROI, Int2[] positions)
{
InitializeComponent();
if (!DesignMode)
{
dispImage = image.ToImage();
this.image = image;
pictureBox.Image = dispImage;
roiPositions = positions.ToList();
}
DialogResult = System.Windows.Forms.DialogResult.Cancel;
textBoxROI.Text = ROI.ToString();
}
void FixedUpdate() {
mousePos = Input.mousePosition;
foreach (var town in Towns)
{
Int2 mousePosInt = new Int2();
Tile.ScreenToMapPosition(mousePos, out mousePosInt);
if (Vector2.Distance(town.location.ToVector2(), mousePosInt.ToVector2()) < .32f)
{
selectedTownPos = Tile.MapToWorldPosition(town.location);
selectedTownName = town.name;
print(town.name);
}
}
}
// Update is called once per frame
void Update () {
// Calculate the tile the target is standing on
Int2 p = new Int2 ( Mathf.RoundToInt ((target.position.x - tileSize*0.5f) / tileSize), Mathf.RoundToInt ((target.position.z - tileSize*0.5f) / tileSize) );
// Clamp range
range = range < 1 ? 1 : range;
// Remove tiles which are out of range
bool changed = true;
while ( changed ) {
changed = false;
foreach (KeyValuePair<Int2,ProceduralTile> pair in tiles ) {
if ( Mathf.Abs (pair.Key.x-p.x) > range || Mathf.Abs (pair.Key.y-p.y) > range ) {
pair.Value.Destroy ();
tiles.Remove ( pair.Key );
changed = true;
break;
}
}
}
// Add tiles which have come in range
// and start calculating them
for ( int x = p.x-range; x <= p.x+range; x++ ) {
for ( int z = p.y-range; z <= p.y+range; z++ ) {
if ( !tiles.ContainsKey ( new Int2(x,z) ) ) {
ProceduralTile tile = new ProceduralTile ( this, x, z );
var generator = tile.Generate ();
// Tick it one step forward
generator.MoveNext ();
// Calculate the rest later
tileGenerationQueue.Enqueue (generator);
tiles.Add ( new Int2(x,z), tile );
}
}
}
// The ones directly adjacent to the current one
// should always be completely calculated
// make sure they are
for ( int x = p.x-1; x <= p.x+1; x++ ) {
for ( int z = p.y-1; z <= p.y+1; z++ ) {
tiles[new Int2(x,z)].ForceFinish();
}
}
}
public void SetUp()
{
var x = 50;
var y = 75;
var width = 100;
var height = 125;
_aabb = new AABB(x, y, width, height);
_top = y;
_left = x;
_right = x + width;
_bottom = y + height;
_topLeft = new Int2(_left, _top);
_topRight = new Int2(_right, _top);
_bottomLeft = new Int2(_left, _bottom);
_bottomRight = new Int2(_right, _bottom);
}
public static PlatformGroup Combine(PlatformGroup lhs, PlatformGroup rhs, Int2 playerIdx)
{
GameObject output = new GameObject("PlatformGroup");
PlatformGroup outputGroup = output.AddComponent<PlatformGroup>();
outputGroup.container = new HashSet<Platform>();
//outputGroup.OnGroupMoved += robot.replanPath;
//transfer ownership
outputGroup.container.UnionWith(lhs.container);
outputGroup.container.UnionWith(rhs.container);
//transfer childObjs
List<Transform> children = new List<Transform>();
for (int i = 0; i < lhs.gameObject.transform.childCount; i++)
children.Add(lhs.gameObject.transform.GetChild(i));
foreach (Transform child in children)
child.transform.parent = output.transform;
children.Clear();
for (int i = 0; i < rhs.gameObject.transform.childCount; i++)
children.Add(rhs.gameObject.transform.GetChild(i));
foreach (Transform child in children)
child.transform.parent = output.transform;
//Vector2 robotPos2d = new Vector2(robot.transform.position.x, robot.transform.position.z);
if (ReferenceEquals(lhs, gridSystem.ComputeGroup(playerIdx)) ||
ReferenceEquals(rhs, gridSystem.ComputeGroup(playerIdx)) ||
ReferenceEquals(lhs, gridSystem.ComputeGroup(gridSystem.goal)) ||
ReferenceEquals(rhs, gridSystem.ComputeGroup(gridSystem.goal)))
{
foreach (Transform child in output.transform)
child.gameObject.layer = Utility.ToLayerNumber(gridSystem.lockedPfLayer);//?
}
foreach (Platform pf in outputGroup.container)
pf.group = outputGroup;
lhs.container.Clear();
rhs.container.Clear();
Destroy(lhs.gameObject);
Destroy(rhs.gameObject);
return outputGroup;
}
/// <summary>
/// Initializes a new instance of the <see cref="CharacterBitmap"/> class from a data array.
/// </summary>
/// <param name="pixelMode">The data format of the bitmap data</param>
/// <param name="data">The bitmap data</param>
/// <param name="borderSize">The size of the border around the image</param>
/// <param name="width">The width of the bitmap </param>
/// <param name="rows">The height of the bitmap</param>
/// <param name="pitch">The pitch of the bitmap</param>
/// <param name="grayLevels">The number of gray levels of the bitmap</param>
public CharacterBitmap(IntPtr data, ref Int2 borderSize, int width, int rows, int pitch, int grayLevels, PixelMode pixelMode)
{
// add one empty border to each side of the bitmap
width += 2 * borderSize.X;
rows += 2 * borderSize.Y;
buffer = Utilities.AllocateMemory(width * rows, 1);
if (pixelMode == PixelMode.Mono)
CopyAndAddBordersFromMono(data, buffer, ref borderSize, width, rows, pitch);
else
CopyAndAddBordersFromGrays(data, buffer, ref borderSize, width, rows);
this.width = width;
this.rows = rows;
this.pitch = width;
this.grayLevels = grayLevels;
this.pixelMode = pixelMode;
}
public int[,] ExecuteAlgorithm(int numTiles, out List<Vector2> openPositions, out Vector3 playerSpawn)
{
openPositions = new List<Vector2>();
int[,] level = new int[numTiles * 2, numTiles * 2];
set2DArrayDefaults(level, 2);
int startingX = numTiles, startingY = numTiles;
Int2 current = new Int2(startingX, startingY);
Int2 directionLastMoved = new Int2(0, 0);
int numTilesPlaced = 0;
// For resizing the level
int leftX = current.x;
int rightX = current.x;
int topY = current.y;
int bottomY = current.y;
while (numTilesPlaced < numTiles)
{
leftX = current.x < leftX ? current.x : leftX;
rightX = current.x > rightX ? current.x : rightX;
topY = current.y > topY ? current.y : topY;
bottomY = current.y < bottomY ? current.y : bottomY;
if (level[current.x, current.y] == 2)
{
level[current.x, current.y] = 1;
numTilesPlaced++;
}
current += getRandomDirection(new int[] { 25, 25, 25, 25 });
}
playerSpawn = new Vector3((startingY - bottomY + 1) * LoadLevel.TileSize, (startingX - leftX + 1) * LoadLevel.TileSize, 0);
return cropLevel(level, leftX, rightX, topY, bottomY, openPositions);
}
public FieldPlane(Plane plane, Texture2D field, Int2 texSize, float timeSlice = 0, float invalidValue = float.MaxValue, RenderEffect effect = RenderEffect.DEFAULT, Colormap map = Colormap.Parula)
{
this._effect = _planeEffect;
this._vertexSizeBytes = 32;
this._numVertices = 6;
this.UsedMap = map;
this._width = texSize.X;
this._height = texSize.Y;
this._invalid = invalidValue;
// Setting up the vertex buffer.
GenerateGeometry(plane, texSize, timeSlice);
// Generating Textures from the fields.
_fieldTextures = new ShaderResourceView[1];
_fieldTextures[0] = new ShaderResourceView(_device, field);
this.SetRenderEffect(effect);
this._vertexLayout = new InputLayout(_device, _technique.GetPassByIndex(0).Description.Signature, new[] {
new InputElement("POSITION", 0, Format.R32G32B32A32_Float, 0, 0),
new InputElement("TEXTURE", 0, Format.R32G32B32A32_Float, 16, 0)
});
}
void setTiles(int[,] generatedLevel, Vector3 playerSpawn, GameObject player)
{
Int2 mapDimensions = new Int2(generatedLevel.GetLength(1), generatedLevel.GetLength(0));
// create level
Tile.NewLevel(mapDimensions, 0, TILE_SIZE, 0, LayerLock.None);
Tile.AddLayer(mapDimensions, 0, TILE_SIZE, 0, LayerLock.None);
// set sorting layers
Tile.SetLayerSorting(0, 0);
Tile.SetLayerSorting(1, 1);
// set collider layer so that walls can be detected by raycasting
Tile.SetColliderLayer(WALL_LAYER);
for (int row = 0; row < generatedLevel.GetLength(0); row++)
{
for (int col = 0; col < generatedLevel.GetLength(1); col++)
{
Int2 tileLocation = new Int2(col, row);
bool isWall = WALL_INDICES.Contains(generatedLevel[row, col]);
int tileIndex = generatedLevel[row, col];
int spriteTileLayerIndex = isWall ? 1 : 0;
Tile.SetTile(tileLocation, spriteTileLayerIndex, 0, tileIndex, false);
if (isWall && hasAdjacentFloor(generatedLevel, row, col))
{
Tile.SetCollider(tileLocation, 1, true);
}
}
}
StartCoroutine("ConfigureColliders");
player.GetComponent<Rigidbody2D>().position = playerSpawn;
}
private static unsafe void CopyAndAddBordersFromGrays(IntPtr data, IntPtr dataBytes, ref Int2 borderSize, int width, int rows)
{
var widthLessBorders = width - (borderSize.X << 1);
var rowsLessBorders = rows - (borderSize.Y << 1);
var resetBorderLineSize = width * borderSize.Y;
Utilities.ClearMemory(dataBytes, 0, resetBorderLineSize);
Utilities.ClearMemory(dataBytes + width * rows - resetBorderLineSize, 0, resetBorderLineSize); // set last border lines to null
var src = (byte*)data;
var dst = (byte*)dataBytes + resetBorderLineSize;
// set the middle of the image
for (int row = 0; row < rowsLessBorders; row++)
{
for (int c = 0; c < borderSize.X; c++)
{
*dst = 0;
++dst;
}
for (int c = 0; c < widthLessBorders; c++)
{
*dst = *src;
++dst;
++src;
}
for (int c = 0; c < borderSize.X; c++)
{
*dst = 0;
++dst;
}
}
}
public GridEntity Peek(Int2 u)
{
return(Peek(u.row, u.col));
}
public bool Contains(Int2 point)
{
return(point.x >= this.xMin && point.x < this.xMax && point.y >= this.yMin && point.y < this.yMax);
}
/// <summary>
/// Determine the output format of the texture depending on the platform and asset properties.
/// </summary>
/// <param name="parameters">The conversion request parameters</param>
/// <param name="imageSize">The texture output size</param>
/// <param name="inputImageFormat">The pixel format of the input image</param>
/// <returns>The pixel format to use as output</returns>
public static PixelFormat DetermineOutputFormat(ImportParameters parameters, Int2 imageSize, PixelFormat inputImageFormat)
{
var hint = parameters.TextureHint;
var alphaMode = parameters.DesiredAlpha;
// Default output format
var outputFormat = PixelFormat.R8G8B8A8_UNorm;
switch (parameters.DesiredFormat)
{
case TextureFormat.Compressed:
switch (parameters.Platform)
{
case PlatformType.Android:
if (inputImageFormat.IsHDR())
{
outputFormat = inputImageFormat;
}
else
{
switch (parameters.GraphicsProfile)
{
case GraphicsProfile.Level_9_1:
case GraphicsProfile.Level_9_2:
case GraphicsProfile.Level_9_3:
outputFormat = alphaMode == AlphaFormat.None && !parameters.IsSRgb ? PixelFormat.ETC1 : parameters.IsSRgb ? PixelFormat.R8G8B8A8_UNorm_SRgb : PixelFormat.R8G8B8A8_UNorm;
break;
case GraphicsProfile.Level_10_0:
case GraphicsProfile.Level_10_1:
case GraphicsProfile.Level_11_0:
case GraphicsProfile.Level_11_1:
case GraphicsProfile.Level_11_2:
// GLES3.0 starting from Level_10_0, this profile enables ETC2 compression on Android
outputFormat = alphaMode == AlphaFormat.None && !parameters.IsSRgb ? PixelFormat.ETC1 : parameters.IsSRgb ? PixelFormat.ETC2_RGBA_SRgb : PixelFormat.ETC2_RGBA;
break;
default:
throw new ArgumentOutOfRangeException("GraphicsProfile");
}
}
break;
case PlatformType.iOS:
// PVRTC works only for square POT textures
if (inputImageFormat.IsHDR())
{
outputFormat = inputImageFormat;
}
else if (SupportPVRTC(imageSize))
{
switch (alphaMode)
{
case AlphaFormat.None:
outputFormat = parameters.IsSRgb ? PixelFormat.PVRTC_4bpp_RGB_SRgb : PixelFormat.PVRTC_4bpp_RGB;
break;
case AlphaFormat.Mask:
// DXT1 handles 1-bit alpha channel
// TODO: Not sure about the equivalent here?
outputFormat = parameters.IsSRgb ? PixelFormat.PVRTC_4bpp_RGBA_SRgb : PixelFormat.PVRTC_4bpp_RGBA;
break;
case AlphaFormat.Explicit:
case AlphaFormat.Interpolated:
// DXT3 is good at sharp alpha transitions
// TODO: Not sure about the equivalent here?
outputFormat = parameters.IsSRgb ? PixelFormat.PVRTC_4bpp_RGBA_SRgb : PixelFormat.PVRTC_4bpp_RGBA;
break;
default:
throw new ArgumentOutOfRangeException();
}
}
else
{
outputFormat = parameters.IsSRgb ? PixelFormat.R8G8B8A8_UNorm_SRgb : PixelFormat.R8G8B8A8_UNorm;
}
break;
case PlatformType.Windows:
case PlatformType.WindowsPhone:
case PlatformType.WindowsStore:
case PlatformType.Windows10:
switch (parameters.GraphicsPlatform)
{
case GraphicsPlatform.Direct3D11:
// https://msdn.microsoft.com/en-us/library/windows/desktop/hh308955%28v=vs.85%29.aspx
// http://www.reedbeta.com/blog/2012/02/12/understanding-bcn-texture-compression-formats/
// ---------------------------------------------- ---------------------------------------------------- --- ---------------------------------
// Source data Minimum required data compression resolution Recommended format Minimum supported feature level
// ---------------------------------------------- ---------------------------------------------------- --- ---------------------------------
// Three-channel color with alpha channel Three color channels (5 bits:6 bits:5 bits), with 0 or 1 bit(s) of alpha BC1 Direct3D 9.1 (color maps, cutout color maps - 1 bit alpha, normal maps if memory is tight)
// Three-channel color with alpha channel Three color channels (5 bits:6 bits:5 bits), with 4 bits of alpha BC2 Direct3D 9.1 (idem)
// Three-channel color with alpha channel Three color channels (5 bits:6 bits:5 bits) with 8 bits of alpha BC3 Direct3D 9.1 (color maps with alpha, packing color and mono maps together)
// One-channel color One color channel (8 bits) BC4 Direct3D 10 (Height maps, gloss maps, font atlases, any gray scales image)
// Two-channel color Two color channels (8 bits:8 bits) BC5 Direct3D 10 (Tangent space normal maps)
// Three-channel high dynamic range (HDR) color Three color channels (16 bits:16 bits:16 bits) in "half" floating point* BC6H Direct3D 11 (HDR images)
// Three-channel color, alpha channel optional Three color channels (4 to 7 bits per channel) with 0 to 8 bits of alpha BC7 Direct3D 11 (High quality color maps, Color maps with full alpha)
switch (alphaMode)
{
case AlphaFormat.None:
case AlphaFormat.Mask:
// DXT1 handles 1-bit alpha channel
outputFormat = parameters.IsSRgb ? PixelFormat.BC1_UNorm_SRgb : PixelFormat.BC1_UNorm;
break;
case AlphaFormat.Explicit:
// DXT3 is good at sharp alpha transitions
outputFormat = parameters.IsSRgb ? PixelFormat.BC2_UNorm_SRgb : PixelFormat.BC2_UNorm;
break;
case AlphaFormat.Interpolated:
// DXT5 is good at alpha gradients
outputFormat = parameters.IsSRgb ? PixelFormat.BC3_UNorm_SRgb : PixelFormat.BC3_UNorm;
break;
default:
throw new ArgumentOutOfRangeException();
}
// Overrides the format when profile is >= 10.0
// Support some specific optimized formats based on the hint or input type
if (parameters.GraphicsProfile >= GraphicsProfile.Level_10_0)
{
if (hint == TextureHint.NormalMap)
{
outputFormat = PixelFormat.BC5_SNorm;
}
else if (hint == TextureHint.Grayscale)
{
outputFormat = PixelFormat.BC4_UNorm;
}
else if (inputImageFormat.IsHDR())
{
// BC6H is too slow to compile
//outputFormat = parameters.GraphicsProfile >= GraphicsProfile.Level_11_0 && alphaMode == AlphaFormat.None ? PixelFormat.BC6H_Uf16 : inputImageFormat;
outputFormat = inputImageFormat;
}
// TODO support the BC6/BC7 but they are so slow to compile that we can't use them right now
}
break;
case GraphicsPlatform.OpenGLES: // OpenGLES on Windows
if (inputImageFormat.IsHDR())
{
outputFormat = inputImageFormat;
}
else if (parameters.IsSRgb)
{
outputFormat = PixelFormat.R8G8B8A8_UNorm_SRgb;
}
else
{
switch (parameters.GraphicsProfile)
{
case GraphicsProfile.Level_9_1:
case GraphicsProfile.Level_9_2:
case GraphicsProfile.Level_9_3:
outputFormat = alphaMode == AlphaFormat.None ? PixelFormat.ETC1 : PixelFormat.R8G8B8A8_UNorm;
break;
case GraphicsProfile.Level_10_0:
case GraphicsProfile.Level_10_1:
case GraphicsProfile.Level_11_0:
case GraphicsProfile.Level_11_1:
case GraphicsProfile.Level_11_2:
// GLES3.0 starting from Level_10_0, this profile enables ETC2 compression on Android
outputFormat = alphaMode == AlphaFormat.None ? PixelFormat.ETC1 : PixelFormat.ETC2_RGBA;
break;
default:
throw new ArgumentOutOfRangeException("GraphicsProfile");
}
}
break;
default:
// OpenGL on Windows
// TODO: Need to handle OpenGL Desktop compression
outputFormat = parameters.IsSRgb ? PixelFormat.R8G8B8A8_UNorm_SRgb : PixelFormat.R8G8B8A8_UNorm;
break;
}
break;
case PlatformType.Linux:
// OpenGL on Linux
// TODO: Need to handle OpenGL Desktop compression
outputFormat = parameters.IsSRgb ? PixelFormat.R8G8B8A8_UNorm_SRgb : PixelFormat.R8G8B8A8_UNorm;
break;
default:
throw new NotSupportedException("Platform " + parameters.Platform + " is not supported by TextureTool");
}
break;
case TextureFormat.Color16Bits:
if (parameters.IsSRgb)
{
outputFormat = PixelFormat.R8G8B8A8_UNorm_SRgb;
}
else
{
if (alphaMode == AlphaFormat.None)
{
outputFormat = PixelFormat.B5G6R5_UNorm;
}
else if (alphaMode == AlphaFormat.Mask)
{
outputFormat = PixelFormat.B5G5R5A1_UNorm;
}
}
break;
case TextureFormat.Color32Bits:
if (parameters.IsSRgb)
{
outputFormat = PixelFormat.R8G8B8A8_UNorm_SRgb;
}
break;
case TextureFormat.AsIs:
outputFormat = inputImageFormat;
break;
default:
throw new ArgumentOutOfRangeException();
}
return(outputFormat);
}
public static Int2 AlignedDown(this Int2 s, int alignment)
{
int as1 = ~(alignment - 1);
return(new Int2(s.X & as1, s.Y & as1));
}
public IEnumerable <Actor> RenderableActorsInBox(Int2 a, Int2 b)
{
//return ActorsInBox(RectWithCorners(a, b));
return(partitionedRenderableActors.InBox(RectWithCorners(a, b)).Where(actorIsInWorld));
}
// 坐标检查
public bool IsValidCoord(Int2 coord)
{
return(coord.x >= 0 && coord.x < cellCountX && coord.y >= 0 && coord.y < cellCountY);
}
public Repeater(Int2 mainPosition, int rotation, Archetype archetype) : base(mainPosition, rotation, archetype)
{
InPorts = new[] { new Port(this, PortType.input, Int2.zero, Int2.left) };
OutPorts = new[] { new Port(this, PortType.output, Int2.zero, Int2.right) };
}
IEnumerator UpdateGraphCoroutine()
{
// Find the direction
// that we want to move the graph in
Vector3 dir = target.position - graph.center;
// Snap to a whole number of nodes
dir.x = Mathf.Round(dir.x / graph.nodeSize) * graph.nodeSize;
dir.z = Mathf.Round(dir.z / graph.nodeSize) * graph.nodeSize;
dir.y = 0;
// Nothing do to
if (dir == Vector3.zero)
{
yield break;
}
// Number of nodes to offset in each
// direction
Int2 offset = new Int2(-Mathf.RoundToInt(dir.x / graph.nodeSize), -Mathf.RoundToInt(dir.z / graph.nodeSize));
// Move the center
graph.center += dir;
graph.GenerateMatrix();
// Create a temporary buffer
// required for the calculations
if (tmp == null || tmp.Length != graph.nodes.Length)
{
tmp = new GridNode[graph.nodes.Length];
}
// Cache some variables for easier access
int width = graph.width;
int depth = graph.depth;
GridNode[] nodes = graph.nodes;
// Check if we have moved
// less than a whole graph
// width in any direction
if (Mathf.Abs(offset.x) <= width && Mathf.Abs(offset.y) <= depth)
{
// Offset each node by the #offset variable
// nodes which would end up outside the graph
// will wrap around to the other side of it
for (int z = 0; z < depth; z++)
{
int pz = z * width;
int tz = ((z + offset.y + depth) % depth) * width;
for (int x = 0; x < width; x++)
{
tmp[tz + ((x + offset.x + width) % width)] = nodes[pz + x];
}
}
yield return(null);
// Copy the nodes back to the graph
// and set the correct indices
for (int z = 0; z < depth; z++)
{
int pz = z * width;
for (int x = 0; x < width; x++)
{
GridNode node = tmp[pz + x];
node.NodeInGridIndex = pz + x;
nodes[pz + x] = node;
}
}
IntRect r = new IntRect(0, 0, offset.x, offset.y);
int minz = r.ymax;
int maxz = depth;
// If offset.x < 0, adjust the rect
if (r.xmin > r.xmax)
{
int tmp2 = r.xmax;
r.xmax = width + r.xmin;
r.xmin = width + tmp2;
}
// If offset.y < 0, adjust the rect
if (r.ymin > r.ymax)
{
int tmp2 = r.ymax;
r.ymax = depth + r.ymin;
r.ymin = depth + tmp2;
minz = 0;
maxz = r.ymin;
}
// Make sure erosion is taken into account
// Otherwise we would end up with ugly artifacts
r = r.Expand(graph.erodeIterations + 1);
// Makes sure the rect stays inside the grid
r = IntRect.Intersection(r, new IntRect(0, 0, width, depth));
yield return(null);
// Update all nodes along one edge of the graph
// With the same width as the rect
for (int z = r.ymin; z < r.ymax; z++)
{
for (int x = 0; x < width; x++)
{
graph.UpdateNodePositionCollision(nodes[z * width + x], x, z, false);
}
}
yield return(null);
// Update all nodes along the other edge of the graph
// With the same width as the rect
for (int z = minz; z < maxz; z++)
{
for (int x = r.xmin; x < r.xmax; x++)
{
graph.UpdateNodePositionCollision(nodes[z * width + x], x, z, false);
}
}
yield return(null);
// Calculate all connections for the nodes
// that might have changed
for (int z = r.ymin; z < r.ymax; z++)
{
for (int x = 0; x < width; x++)
{
graph.CalculateConnections(nodes, x, z, nodes[z * width + x]);
}
}
yield return(null);
// Calculate all connections for the nodes
// that might have changed
for (int z = minz; z < maxz; z++)
{
for (int x = r.xmin; x < r.xmax; x++)
{
graph.CalculateConnections(nodes, x, z, nodes[z * width + x]);
}
}
yield return(null);
// Calculate all connections for the nodes along the boundary
// of the graph, these always need to be updated
/** \todo Optimize to not traverse all nodes in the graph, only those at the edges */
for (int z = 0; z < depth; z++)
{
for (int x = 0; x < width; x++)
{
if (x == 0 || z == 0 || x >= width - 1 || z >= depth - 1)
{
graph.CalculateConnections(nodes, x, z, nodes[z * width + x]);
}
}
}
}
else
{
// Just update all nodes
for (int z = 0; z < depth; z++)
{
for (int x = 0; x < width; x++)
{
graph.UpdateNodePositionCollision(nodes[z * width + x], x, z, false);
}
}
// Recalculate the connections of all nodes
for (int z = 0; z < depth; z++)
{
for (int x = 0; x < width; x++)
{
graph.CalculateConnections(nodes, x, z, nodes[z * width + x]);
}
}
}
if (floodFill)
{
yield return(null);
// Make sure the areas for the graph
// have been recalculated
// not doing this can cause pathfinding to fail
AstarPath.active.QueueWorkItemFloodFill();
}
}
public void Uniform2(int location, Int2 value)
{
TKGL.Uniform2(location, value.X, value.Y);
}
public IEnumerable <ActorBoundsPair> ActorsInMouseBox(Int2 a, Int2 b)
{
return(ActorsInMouseBox(RectWithCorners(a, b)));
}
//public IEnumerable<FrozenActor> FrozenActorsInBox(Player p,Int2 a,Int2 b)
//{
// return FrozenActorsInBox(p, RectWithCorners(a, b));
//}
public IEnumerable <FrozenActor> RenderableFrozenActorsInBox(Player p, Int2 a, Int2 b)
{
if (p == null)
{
return(NoFrozenActors);
}
return(partitionedRenderableFrozenActors[p].InBox(RectWithCorners(a, b)).Where(frozenActorIsValid));
}
/// <summary>
///
/// </summary>
/// <param name="r"></param>
/// <returns></returns>
//public IEnumerable<Actor> ActorsInBox(Rectangle r)
//{
// return partitionedActors.InBox(r).Where(actorIsInWorld);
//}
static Rectangle RectWithCorners(Int2 a, Int2 b)
{
return(Rectangle.FromLTRB(Math.Min(a.X, b.X), Math.Min(a.Y, b.Y), Math.Max(a.X, b.X), Math.Max(a.Y, b.Y)));
}
/// <inheritdoc/>
public TPixel this[Int2 xy] => throw new InvalidExecutionContextException($"{typeof(ReadOnlyTexture2D<T,TPixel>)}[{typeof(Int2)}]");
/// <summary>
/// Returns true if the PVRTC can be used for the provided texture size.
/// </summary>
/// <param name="textureSize">the size of the texture</param>
/// <returns>true if PVRTC is supported</returns>
public static bool SupportPVRTC(Int2 textureSize)
{
return textureSize.X == textureSize.Y && MathUtil.IsPow2(textureSize.X);
}
public override Sprite GetSprite(Int2 localPosition) => repeaterSprite;
/// <summary>
/// Create a new thumbnail request from entity.
/// </summary>
/// <param name="thumbnailUrl">The Url of the thumbnail</param>
/// <param name="scene">The scene describing the thumbnail to draw</param>
/// <param name="provider">The provider to use for the request.</param>
/// <param name="thumbnailSize">The desired size of the thumbnail</param>
/// <param name="colorSpace">The color space.</param>
/// <param name="renderingMode">the rendering mode (hdr or ldr).</param>
/// <param name="logger">The logger</param>
/// <param name="logLevel">The dependency build status log level</param>
public ThumbnailBuildRequest(string thumbnailUrl, Scene scene, GraphicsCompositor graphicsCompositor, DatabaseFileProvider provider, Int2 thumbnailSize, ColorSpace colorSpace, RenderingMode renderingMode, ILogger logger, LogMessageType logLevel)
{
Logger = logger;
Url = thumbnailUrl;
Size = thumbnailSize;
Scene = scene;
GraphicsCompositor = graphicsCompositor;
FileProvider = provider;
DependencyBuildStatus = logLevel;
ColorSpace = colorSpace;
RenderingMode = renderingMode;
}
bool HasAnyValueInSingle(Int2 single)
{
return(single.x >= 0 && single.y >= 0);
}
public EditChunkMaterialAction(FlaxEngine.Terrain terrain, ref Int2 patchCoord, ref Int2 chunkCoord, MaterialBase toSet)
{
if (terrain == null)
{
throw new ArgumentException(nameof(terrain));
}
_terrainId = terrain.ID;
_patchCoord = patchCoord;
_chunkCoord = chunkCoord;
_beforeMaterial = terrain.GetChunkOverrideMaterial(ref patchCoord, ref chunkCoord)?.ID ?? Guid.Empty;
_afterMaterial = toSet?.ID ?? Guid.Empty;
}
public static ResultStatus ImportTextureImage(TextureTool textureTool, TexImage texImage, ImportParameters parameters, CancellationToken cancellationToken, Logger logger)
{
var assetManager = new AssetManager();
// Apply transformations
textureTool.Decompress(texImage, parameters.IsSRgb);
// Special case when the input texture is monochromatic but it is supposed to be a color and we are working in SRGB
// In that case, we need to transform it to a supported SRGB format (R8G8B8A8_UNorm_SRgb)
// TODO: As part of a conversion phase, this code may be moved to a dedicated method in this class at some point
if (parameters.TextureHint == TextureHint.Color && parameters.IsSRgb && (texImage.Format == PixelFormat.R8_UNorm || texImage.Format == PixelFormat.A8_UNorm))
{
textureTool.Convert(texImage, PixelFormat.R8G8B8A8_UNorm_SRgb);
}
if (cancellationToken.IsCancellationRequested) // abort the process if cancellation is demanded
return ResultStatus.Cancelled;
var fromSize = new Size2(texImage.Width, texImage.Height);
var targetSize = parameters.DesiredSize;
// Resize the image
if (parameters.IsSizeInPercentage)
{
targetSize = new Size2((int)(fromSize.Width * targetSize.Width / 100.0f), (int)(fromSize.Height * targetSize.Height / 100.0f));
}
// Find the target size
targetSize = FindBestTextureSize(parameters, targetSize, logger);
// Resize the image only if needed
if (targetSize != fromSize)
{
textureTool.Resize(texImage, targetSize.Width, targetSize.Height, Filter.Rescaling.Lanczos3);
}
if (cancellationToken.IsCancellationRequested) // abort the process if cancellation is demanded
return ResultStatus.Cancelled;
// texture size is now determined, we can cache it
var textureSize = new Int2(texImage.Width, texImage.Height);
// determine the alpha format of the texture when set to Auto
// Note: this has to be done before the ColorKey transformation in order to be able to take advantage of image file AlphaDepth information
if(parameters.DesiredAlpha == AlphaFormat.Auto)
{
var colorKey = parameters.ColorKeyEnabled? (Color?)parameters.ColorKeyColor : null;
var alphaLevel = textureTool.GetAlphaLevels(texImage, new Rectangle(0, 0, textureSize.X, textureSize.Y), colorKey, logger);
parameters.DesiredAlpha = alphaLevel.ToAlphaFormat();
}
// Apply the color key
if (parameters.ColorKeyEnabled)
textureTool.ColorKey(texImage, parameters.ColorKeyColor);
if (cancellationToken.IsCancellationRequested) // abort the process if cancellation is demanded
return ResultStatus.Cancelled;
// Pre-multiply alpha only for relevant formats
if (parameters.PremultiplyAlpha && texImage.Format.HasAlpha32Bits())
textureTool.PreMultiplyAlpha(texImage);
if (cancellationToken.IsCancellationRequested) // abort the process if cancellation is demanded
return ResultStatus.Cancelled;
// Generate mipmaps
if (parameters.GenerateMipmaps)
{
var boxFilteringIsSupported = !texImage.Format.IsSRgb() || (MathUtil.IsPow2(textureSize.X) && MathUtil.IsPow2(textureSize.Y));
textureTool.GenerateMipMaps(texImage, boxFilteringIsSupported? Filter.MipMapGeneration.Box: Filter.MipMapGeneration.Linear);
}
if (cancellationToken.IsCancellationRequested) // abort the process if cancellation is demanded
return ResultStatus.Cancelled;
// Convert/Compress to output format
// TODO: Change alphaFormat depending on actual image content (auto-detection)?
var outputFormat = DetermineOutputFormat(parameters, textureSize, texImage.Format);
textureTool.Compress(texImage, outputFormat, (TextureConverter.Requests.TextureQuality)parameters.TextureQuality);
if (cancellationToken.IsCancellationRequested) // abort the process if cancellation is demanded
return ResultStatus.Cancelled;
// Save the texture
using (var outputImage = textureTool.ConvertToParadoxImage(texImage))
{
if (cancellationToken.IsCancellationRequested) // abort the process if cancellation is demanded
return ResultStatus.Cancelled;
assetManager.Save(parameters.OutputUrl, outputImage.ToSerializableVersion());
logger.Info("Compression successful [{3}] to ({0}x{1},{2})", outputImage.Description.Width, outputImage.Description.Height, outputImage.Description.Format, parameters.OutputUrl);
}
return ResultStatus.Successful;
}
public IEnumerable <IEffect> RenderableEffectsInBox(Int2 a, Int2 b)
{
return(partitionedRenderableEffects.InBox(RectWithCorners(a, b)));
}
/// <summary>
/// Request a thumbnail build action to the preview game.
/// </summary>
/// <param name="thumbnailUrl">The url of the thumbnail on the storage</param>
/// <param name="scene">The scene to use to draw the thumbnail</param>
/// <param name="graphicsCompositor">The graphics compositor used to render the scene</param>
/// <param name="provider">The file provider to use when executing the build request.</param>
/// <param name="thumbnailSize">The size of the thumbnail to create</param>
/// <param name="colorSpace"></param>
/// <param name="renderingMode">the rendering mode (hdr or ldr).</param>
/// <param name="logger">The logger</param>
/// <param name="logLevel">The dependency build status log level</param>
/// <param name="postProcessThumbnail">The post-process code to customize thumbnail.</param>
/// <returns>A task on which the user can wait for the thumbnail completion</returns>
public ResultStatus BuildThumbnail(string thumbnailUrl, Scene scene, GraphicsCompositor graphicsCompositor, DatabaseFileProvider provider, Int2 thumbnailSize, ColorSpace colorSpace, RenderingMode renderingMode, ILogger logger, LogMessageType logLevel, PostProcessThumbnailDelegate postProcessThumbnail = null)
{
return(ProcessThumbnailRequests(new ThumbnailBuildRequest(thumbnailUrl, scene, graphicsCompositor, provider, thumbnailSize, colorSpace, renderingMode, logger, logLevel)
{
PostProcessThumbnail = postProcessThumbnail
}));
}
public abstract void CompleteRange(Int2 selection);
/// <inheritdoc />
protected override IntPtr GetData(ref Int2 patchCoord, object tag)
{
return(TerrainTools.GetSplatMapData(_terrain, ref patchCoord, (int)tag));
}
public void PickColorTest()
{
var pixelCoordinate1 = new Int2(4, 4);
var theoreticalColor1 = new Color(0, 255, 46, 255);
var pixelCoordinate2 = new Int2(3, 4);
var theoreticalColor2 = new Color(222, 76, 255, 255);
var images = new[] { "BgraSheet.dds", "RgbaSheet.dds" };
foreach (var image in images)
{
using (var texTool = new TextureTool())
using (var texImage = texTool.Load(Module.PathToInputImages + image))
{
var foundColor = texTool.PickColor(texImage, pixelCoordinate1);
Assert.AreEqual(theoreticalColor1, foundColor);
foundColor = texTool.PickColor(texImage, pixelCoordinate2);
Assert.AreEqual(theoreticalColor2, foundColor);
}
}
}
public static ResultStatus ImportTextureImage(TextureTool textureTool, TexImage texImage, ImportParameters parameters, CancellationToken cancellationToken, Logger logger)
{
var assetManager = new AssetManager();
// Apply transformations
textureTool.Decompress(texImage, parameters.IsSRgb);
// Special case when the input texture is monochromatic but it is supposed to be a color and we are working in SRGB
// In that case, we need to transform it to a supported SRGB format (R8G8B8A8_UNorm_SRgb)
// TODO: As part of a conversion phase, this code may be moved to a dedicated method in this class at some point
if (parameters.TextureHint == TextureHint.Color && parameters.IsSRgb && (texImage.Format == PixelFormat.R8_UNorm || texImage.Format == PixelFormat.A8_UNorm))
{
textureTool.Convert(texImage, PixelFormat.R8G8B8A8_UNorm_SRgb);
}
if (cancellationToken.IsCancellationRequested) // abort the process if cancellation is demanded
{
return(ResultStatus.Cancelled);
}
var fromSize = new Size2(texImage.Width, texImage.Height);
var targetSize = parameters.DesiredSize;
// Resize the image
if (parameters.IsSizeInPercentage)
{
targetSize = new Size2((int)(fromSize.Width * targetSize.Width / 100.0f), (int)(fromSize.Height * targetSize.Height / 100.0f));
}
// Find the target size
targetSize = FindBestTextureSize(parameters, targetSize, logger);
// Resize the image only if needed
if (targetSize != fromSize)
{
textureTool.Resize(texImage, targetSize.Width, targetSize.Height, Filter.Rescaling.Lanczos3);
}
if (cancellationToken.IsCancellationRequested) // abort the process if cancellation is demanded
{
return(ResultStatus.Cancelled);
}
// texture size is now determined, we can cache it
var textureSize = new Int2(texImage.Width, texImage.Height);
// determine the alpha format of the texture when set to Auto
// Note: this has to be done before the ColorKey transformation in order to be able to take advantage of image file AlphaDepth information
if (parameters.DesiredAlpha == AlphaFormat.Auto)
{
var colorKey = parameters.ColorKeyEnabled? (Color?)parameters.ColorKeyColor : null;
var alphaLevel = textureTool.GetAlphaLevels(texImage, new Rectangle(0, 0, textureSize.X, textureSize.Y), colorKey, logger);
parameters.DesiredAlpha = alphaLevel.ToAlphaFormat();
}
// Apply the color key
if (parameters.ColorKeyEnabled)
{
textureTool.ColorKey(texImage, parameters.ColorKeyColor);
}
if (cancellationToken.IsCancellationRequested) // abort the process if cancellation is demanded
{
return(ResultStatus.Cancelled);
}
// Pre-multiply alpha only for relevant formats
if (parameters.PremultiplyAlpha && texImage.Format.HasAlpha32Bits())
{
textureTool.PreMultiplyAlpha(texImage);
}
if (cancellationToken.IsCancellationRequested) // abort the process if cancellation is demanded
{
return(ResultStatus.Cancelled);
}
// Generate mipmaps
if (parameters.GenerateMipmaps)
{
var boxFilteringIsSupported = !texImage.Format.IsSRgb() || (MathUtil.IsPow2(textureSize.X) && MathUtil.IsPow2(textureSize.Y));
textureTool.GenerateMipMaps(texImage, boxFilteringIsSupported? Filter.MipMapGeneration.Box: Filter.MipMapGeneration.Linear);
}
if (cancellationToken.IsCancellationRequested) // abort the process if cancellation is demanded
{
return(ResultStatus.Cancelled);
}
// Convert/Compress to output format
// TODO: Change alphaFormat depending on actual image content (auto-detection)?
var outputFormat = DetermineOutputFormat(parameters, textureSize, texImage.Format);
textureTool.Compress(texImage, outputFormat, (TextureConverter.Requests.TextureQuality)parameters.TextureQuality);
if (cancellationToken.IsCancellationRequested) // abort the process if cancellation is demanded
{
return(ResultStatus.Cancelled);
}
// Save the texture
using (var outputImage = textureTool.ConvertToXenkoImage(texImage))
{
if (cancellationToken.IsCancellationRequested) // abort the process if cancellation is demanded
{
return(ResultStatus.Cancelled);
}
assetManager.Save(parameters.OutputUrl, outputImage.ToSerializableVersion());
logger.Verbose("Compression successful [{3}] to ({0}x{1},{2})", outputImage.Description.Width, outputImage.Description.Height, outputImage.Description.Format, parameters.OutputUrl);
}
return(ResultStatus.Successful);
}
/// <summary>
/// Pick the color under the specified pixel.
/// </summary>
/// <param name="texture">The texture</param>
/// <param name="pixel">The coordinate of the pixel</param>
public unsafe Color PickColor(TexImage texture, Int2 pixel)
{
if (texture == null) throw new ArgumentNullException(nameof(texture));
var format = texture.Format;
if (texture.Dimension != TexImage.TextureDimension.Texture2D || !(format.IsRGBAOrder() || format.IsBGRAOrder() || format.SizeInBytes() != 4))
throw new NotImplementedException();
// check that the pixel is inside the texture
var textureRegion = new Rectangle(0, 0, texture.Width, texture.Height);
if (!textureRegion.Contains(pixel))
throw new ArgumentException("The provided pixel coordinate is outside of the texture");
var ptr = (uint*)texture.Data;
var stride = texture.RowPitch / 4;
var pixelColorInt = ptr[stride*pixel.Y + pixel.X];
var pixelColor = format.IsRGBAOrder() ? Color.FromRgba(pixelColorInt) : Color.FromBgra(pixelColorInt);
return pixelColor;
}
/// <summary>
/// Initializes a new instance of geometric descriptor for a plane.
/// </summary>
public PlaneProceduralModel()
{
Normal = NormalDirection.UpY;
Size = new Vector2(1.0f);
Tessellation = new Int2(1);
}
internal void SetPosition(Int2 pos)
{
Position = pos;
}
public Block GetBlock(int x, int y)
{
Int2 coord = new Int2(x, y);
if (blocks.ContainsKey(coord)) return blocks[coord];
return null;
}
private static IEnumerable <Int2> GetValidMovesByDirection(Player currentPlayer, Piece piece, Int2 step)
{
for (var nextStep = piece.Coordinate + step;
IsValidTarget(currentPlayer, nextStep);
nextStep += step)
{
yield return(nextStep);
if (IsOccupiedByEnemy(currentPlayer, nextStep))
{
yield break;
}
}
}
protected override void DrawCore(RenderContext context)
{
var inputTexture = RadianceMap;
if (inputTexture == null)
return;
// Gets and checks the input texture
if (inputTexture.Dimension != TextureDimension.TextureCube)
throw new NotSupportedException("Only texture cube are currently supported as input of 'LambertianPrefilteringSH' effect.");
const int FirstPassBlockSize = 4;
const int FirstPassSumsCount = FirstPassBlockSize * FirstPassBlockSize;
var faceCount = inputTexture.Dimension == TextureDimension.TextureCube ? 6 : 1;
var inputSize = new Int2(inputTexture.Width, inputTexture.Height); // (Note: for cube maps width = height)
var coefficientsCount = harmonicalOrder * harmonicalOrder;
var sumsToPerfomRemaining = inputSize.X * inputSize.Y * faceCount / FirstPassSumsCount;
var partialSumBuffer = NewScopedTypedBuffer(coefficientsCount * sumsToPerfomRemaining, PixelFormat.R32G32B32A32_Float, true);
// Project the radiance on the SH basis and sum up the results along the 4x4 blocks
firstPassEffect.ThreadNumbers = new Int3(FirstPassBlockSize, FirstPassBlockSize, 1);
firstPassEffect.ThreadGroupCounts = new Int3(inputSize.X/FirstPassBlockSize, inputSize.Y/FirstPassBlockSize, faceCount);
firstPassEffect.Parameters.Set(LambertianPrefilteringSHParameters.BlockSize, FirstPassBlockSize);
firstPassEffect.Parameters.Set(SphericalHarmonicsParameters.HarmonicsOrder, harmonicalOrder);
firstPassEffect.Parameters.Set(LambertianPrefilteringSHPass1Keys.RadianceMap, inputTexture);
firstPassEffect.Parameters.Set(LambertianPrefilteringSHPass1Keys.OutputBuffer, partialSumBuffer);
firstPassEffect.Draw(context);
// Recursively applies the pass2 (sums the coefficients together) as long as needed. Swap input/output buffer at each iteration.
var secondPassInputBuffer = partialSumBuffer;
Buffer secondPassOutputBuffer = null;
while (sumsToPerfomRemaining % 2 == 0)
{
// we are limited in the number of summing threads by the group-shared memory size.
// determine the number of threads to use and update the number of sums remaining afterward.
var sumsCount = 1;
while (sumsCount < (1<<10) && sumsToPerfomRemaining % 2 == 0) // shader can perform only an 2^x number of sums.
{
sumsCount <<= 1;
sumsToPerfomRemaining >>= 1;
}
// determine the numbers of groups (limited to 65535 groups by dimensions)
var groupCountX = 1;
var groupCountY = sumsToPerfomRemaining;
while (groupCountX >= short.MaxValue)
{
groupCountX <<= 1;
groupCountY >>= 1;
}
// create the output buffer if not existing yet
if (secondPassOutputBuffer == null)
secondPassOutputBuffer = NewScopedTypedBuffer(coefficientsCount * sumsToPerfomRemaining, PixelFormat.R32G32B32A32_Float, true);
// draw pass 2
secondPassEffect.ThreadNumbers = new Int3(sumsCount, 1, 1);
secondPassEffect.ThreadGroupCounts = new Int3(groupCountX, groupCountY, coefficientsCount);
secondPassEffect.Parameters.Set(LambertianPrefilteringSHParameters.BlockSize, sumsCount);
secondPassEffect.Parameters.Set(SphericalHarmonicsParameters.HarmonicsOrder, harmonicalOrder);
secondPassEffect.Parameters.Set(LambertianPrefilteringSHPass2Keys.InputBuffer, secondPassInputBuffer);
secondPassEffect.Parameters.Set(LambertianPrefilteringSHPass2Keys.OutputBuffer, secondPassOutputBuffer);
secondPassEffect.Draw(context);
// swap second pass input/output buffers.
var swapTemp = secondPassOutputBuffer;
secondPassOutputBuffer = secondPassInputBuffer;
secondPassInputBuffer = swapTemp;
}
// create and initialize result SH
prefilteredLambertianSH = new SphericalHarmonics(HarmonicOrder);
// Get the data out of the final buffer
var sizeResult = coefficientsCount * sumsToPerfomRemaining * PixelFormat.R32G32B32A32_Float.SizeInBytes();
var stagedBuffer = NewScopedBuffer(new BufferDescription(sizeResult, BufferFlags.None, GraphicsResourceUsage.Staging));
GraphicsDevice.CopyRegion(secondPassInputBuffer, 0, new ResourceRegion(0, 0, 0, sizeResult, 1, 1), stagedBuffer, 0);
var finalsValues = stagedBuffer.GetData<Vector4>();
// performs last possible additions, normalize the result and store it in the SH
for (var c = 0; c < coefficientsCount; c++)
{
var coeff = Vector4.Zero;
for (var f = 0; f < sumsToPerfomRemaining; ++f)
{
coeff += finalsValues[coefficientsCount * f + c];
}
prefilteredLambertianSH.Coefficients[c] = 4 * MathUtil.Pi / coeff.W * new Color3(coeff.X, coeff.Y, coeff.Z);
}
}
private static bool IsInBoundary(Int2 targetCell) => targetCell.X >= 0 && targetCell.X < 8 && targetCell.Y >= 0 && targetCell.Y < 8;
/// <summary>
/// Determine the output format of the texture depending on the platform and asset properties.
/// </summary>
/// <param name="parameters">The conversion request parameters</param>
/// <param name="imageSize">The texture output size</param>
/// <param name="inputImageFormat">The pixel format of the input image</param>
/// <returns>The pixel format to use as output</returns>
public static PixelFormat DetermineOutputFormat(ImportParameters parameters, Int2 imageSize, PixelFormat inputImageFormat)
{
var hint = parameters.TextureHint;
var alphaMode = parameters.DesiredAlpha;
// Default output format
var outputFormat = PixelFormat.R8G8B8A8_UNorm;
switch (parameters.DesiredFormat)
{
case TextureFormat.Compressed:
switch (parameters.Platform)
{
case PlatformType.Android:
if (inputImageFormat.IsHDR())
{
outputFormat = inputImageFormat;
}
else
{
switch (parameters.GraphicsProfile)
{
case GraphicsProfile.Level_9_1:
case GraphicsProfile.Level_9_2:
case GraphicsProfile.Level_9_3:
outputFormat = alphaMode == AlphaFormat.None && !parameters.IsSRgb ? PixelFormat.ETC1 : parameters.IsSRgb ? PixelFormat.R8G8B8A8_UNorm_SRgb : PixelFormat.R8G8B8A8_UNorm;
break;
case GraphicsProfile.Level_10_0:
case GraphicsProfile.Level_10_1:
case GraphicsProfile.Level_11_0:
case GraphicsProfile.Level_11_1:
case GraphicsProfile.Level_11_2:
// GLES3.0 starting from Level_10_0, this profile enables ETC2 compression on Android
outputFormat = alphaMode == AlphaFormat.None && !parameters.IsSRgb ? PixelFormat.ETC1 : parameters.IsSRgb ? PixelFormat.ETC2_RGBA_SRgb : PixelFormat.ETC2_RGBA;
break;
default:
throw new ArgumentOutOfRangeException("GraphicsProfile");
}
}
break;
case PlatformType.iOS:
// PVRTC works only for square POT textures
if (inputImageFormat.IsHDR())
{
outputFormat = inputImageFormat;
}
else if (SupportPVRTC(imageSize))
{
switch (alphaMode)
{
case AlphaFormat.None:
outputFormat = parameters.IsSRgb ? PixelFormat.PVRTC_4bpp_RGB_SRgb : PixelFormat.PVRTC_4bpp_RGB;
break;
case AlphaFormat.Mask:
// DXT1 handles 1-bit alpha channel
// TODO: Not sure about the equivalent here?
outputFormat = parameters.IsSRgb ? PixelFormat.PVRTC_4bpp_RGBA_SRgb : PixelFormat.PVRTC_4bpp_RGBA;
break;
case AlphaFormat.Explicit:
case AlphaFormat.Interpolated:
// DXT3 is good at sharp alpha transitions
// TODO: Not sure about the equivalent here?
outputFormat = parameters.IsSRgb ? PixelFormat.PVRTC_4bpp_RGBA_SRgb : PixelFormat.PVRTC_4bpp_RGBA;
break;
default:
throw new ArgumentOutOfRangeException();
}
}
else
{
outputFormat = parameters.IsSRgb ? PixelFormat.R8G8B8A8_UNorm_SRgb : PixelFormat.R8G8B8A8_UNorm;
}
break;
case PlatformType.Windows:
case PlatformType.WindowsPhone:
case PlatformType.WindowsStore:
case PlatformType.Windows10:
switch (parameters.GraphicsPlatform)
{
case GraphicsPlatform.Direct3D11:
// https://msdn.microsoft.com/en-us/library/windows/desktop/hh308955%28v=vs.85%29.aspx
// http://www.reedbeta.com/blog/2012/02/12/understanding-bcn-texture-compression-formats/
// ---------------------------------------------- ---------------------------------------------------- --- ---------------------------------
// Source data Minimum required data compression resolution Recommended format Minimum supported feature level
// ---------------------------------------------- ---------------------------------------------------- --- ---------------------------------
// Three-channel color with alpha channel Three color channels (5 bits:6 bits:5 bits), with 0 or 1 bit(s) of alpha BC1 Direct3D 9.1 (color maps, cutout color maps - 1 bit alpha, normal maps if memory is tight)
// Three-channel color with alpha channel Three color channels (5 bits:6 bits:5 bits), with 4 bits of alpha BC2 Direct3D 9.1 (idem)
// Three-channel color with alpha channel Three color channels (5 bits:6 bits:5 bits) with 8 bits of alpha BC3 Direct3D 9.1 (color maps with alpha, packing color and mono maps together)
// One-channel color One color channel (8 bits) BC4 Direct3D 10 (Height maps, gloss maps, font atlases, any gray scales image)
// Two-channel color Two color channels (8 bits:8 bits) BC5 Direct3D 10 (Tangent space normal maps)
// Three-channel high dynamic range (HDR) color Three color channels (16 bits:16 bits:16 bits) in "half" floating point* BC6H Direct3D 11 (HDR images)
// Three-channel color, alpha channel optional Three color channels (4 to 7 bits per channel) with 0 to 8 bits of alpha BC7 Direct3D 11 (High quality color maps, Color maps with full alpha)
switch (alphaMode)
{
case AlphaFormat.None:
case AlphaFormat.Mask:
// DXT1 handles 1-bit alpha channel
outputFormat = parameters.IsSRgb ? PixelFormat.BC1_UNorm_SRgb : PixelFormat.BC1_UNorm;
break;
case AlphaFormat.Explicit:
// DXT3 is good at sharp alpha transitions
outputFormat = parameters.IsSRgb ? PixelFormat.BC2_UNorm_SRgb : PixelFormat.BC2_UNorm;
break;
case AlphaFormat.Interpolated:
// DXT5 is good at alpha gradients
outputFormat = parameters.IsSRgb ? PixelFormat.BC3_UNorm_SRgb : PixelFormat.BC3_UNorm;
break;
default:
throw new ArgumentOutOfRangeException();
}
// Overrides the format when profile is >= 10.0
// Support some specific optimized formats based on the hint or input type
if (parameters.GraphicsProfile >= GraphicsProfile.Level_10_0)
{
if (hint == TextureHint.NormalMap)
{
outputFormat = PixelFormat.BC5_SNorm;
}
else if (hint == TextureHint.Grayscale)
{
outputFormat = PixelFormat.BC4_UNorm;
}
else if (inputImageFormat.IsHDR())
{
// BC6H is too slow to compile
//outputFormat = parameters.GraphicsProfile >= GraphicsProfile.Level_11_0 && alphaMode == AlphaFormat.None ? PixelFormat.BC6H_Uf16 : inputImageFormat;
outputFormat = inputImageFormat;
}
// TODO support the BC6/BC7 but they are so slow to compile that we can't use them right now
}
break;
case GraphicsPlatform.OpenGLES: // OpenGLES on Windows
if (inputImageFormat.IsHDR())
{
outputFormat = inputImageFormat;
}
else if (parameters.IsSRgb)
{
outputFormat = PixelFormat.R8G8B8A8_UNorm_SRgb;
}
else
{
switch (parameters.GraphicsProfile)
{
case GraphicsProfile.Level_9_1:
case GraphicsProfile.Level_9_2:
case GraphicsProfile.Level_9_3:
outputFormat = alphaMode == AlphaFormat.None ? PixelFormat.ETC1 : PixelFormat.R8G8B8A8_UNorm;
break;
case GraphicsProfile.Level_10_0:
case GraphicsProfile.Level_10_1:
case GraphicsProfile.Level_11_0:
case GraphicsProfile.Level_11_1:
case GraphicsProfile.Level_11_2:
// GLES3.0 starting from Level_10_0, this profile enables ETC2 compression on Android
outputFormat = alphaMode == AlphaFormat.None ? PixelFormat.ETC1 : PixelFormat.ETC2_RGBA;
break;
default:
throw new ArgumentOutOfRangeException("GraphicsProfile");
}
}
break;
default:
// OpenGL on Windows
// TODO: Need to handle OpenGL Desktop compression
outputFormat = parameters.IsSRgb ? PixelFormat.R8G8B8A8_UNorm_SRgb : PixelFormat.R8G8B8A8_UNorm;
break;
}
break;
default:
throw new NotSupportedException("Platform " + parameters.Platform + " is not supported by TextureTool");
}
break;
case TextureFormat.Color16Bits:
if (parameters.IsSRgb)
{
outputFormat = PixelFormat.R8G8B8A8_UNorm_SRgb;
}
else
{
if (alphaMode == AlphaFormat.None)
{
outputFormat = PixelFormat.B5G6R5_UNorm;
}
else if (alphaMode == AlphaFormat.Mask)
{
outputFormat = PixelFormat.B5G5R5A1_UNorm;
}
}
break;
case TextureFormat.Color32Bits:
if (parameters.IsSRgb)
{
outputFormat = PixelFormat.R8G8B8A8_UNorm_SRgb;
}
break;
case TextureFormat.AsIs:
outputFormat = inputImageFormat;
break;
default:
throw new ArgumentOutOfRangeException();
}
return outputFormat;
}
private static bool IsOccupiedByEnemy(Player currentPlayer, Int2 targetCell)
=> currentPlayer.Enemy.Pieces.Any(p =>
p.Coordinate.X == targetCell.X && p.Coordinate.Y == targetCell.Y);
private void GenerateRooms(int maxRoomCount, Vector2 minRoomSize, Vector2 maxRoomSize)
{
List<Int2> doors = new List<Int2>();
for (int i = 0; i < maxRoomCount; i++)
{
int[,] room = CreateRoom(minRoomSize, maxRoomSize);
//Position is so that room can't go over map boundaries
Int2 positionForTheRoom = new Int2(Random.Range(0, map.GetLength(0) - (int)maxRoomSize.x),
Random.Range(0, map.GetLength(1) - (int)maxRoomSize.y));
for (int j = 0; j < room.GetLength(0); j++)
{
for (int k = 0; k < room.GetLength(1); k++)
{
map[positionForTheRoom.x + j, positionForTheRoom.y + k] = room[j, k];
}
}
}
}
private static bool IsOccupied(Player currentPlayer, Int2 targetCell) => IsOccupiedByEnemy(currentPlayer, targetCell) || IsOccupiedByOwner(currentPlayer, targetCell);
public abstract void Subrange(Int2 min, Int2 max, Int2 selection);
public bool CheckBounds(Int2 p)
{
return(host.grid.CheckBounds(p.row, p.col));
}
/** Async method for moving the graph */
IEnumerator UpdateGraphCoroutine () {
// Find the direction
// that we want to move the graph in.
// Calcuculate this in graph space (where a distance of one is the size of one node)
Vector3 dir = PointToGraphSpace(target.position) - PointToGraphSpace(graph.center);
// Snap to a whole number of nodes
dir.x = Mathf.Round(dir.x);
dir.z = Mathf.Round(dir.z);
dir.y = 0;
// Nothing do to
if ( dir == Vector3.zero ) yield break;
// Number of nodes to offset in each direction
Int2 offset = new Int2(-Mathf.RoundToInt(dir.x), -Mathf.RoundToInt(dir.z));
// Move the center (this is in world units, so we need to convert it back from graph space)
graph.center += graph.matrix.MultiplyVector (dir);
graph.GenerateMatrix ();
// Create a temporary buffer
// required for the calculations
if ( tmp == null || tmp.Length != graph.nodes.Length ) {
tmp = new GridNode[graph.nodes.Length];
}
// Cache some variables for easier access
int width = graph.width;
int depth = graph.depth;
GridNode[] nodes = graph.nodes;
// Check if we have moved
// less than a whole graph
// width in any direction
if ( Mathf.Abs(offset.x) <= width && Mathf.Abs(offset.y) <= depth ) {
// Offset each node by the #offset variable
// nodes which would end up outside the graph
// will wrap around to the other side of it
for ( int z=0; z < depth; z++ ) {
int pz = z*width;
int tz = ((z+offset.y + depth)%depth)*width;
for ( int x=0; x < width; x++ ) {
tmp[tz + ((x+offset.x + width) % width)] = nodes[pz + x];
}
}
yield return null;
// Copy the nodes back to the graph
// and set the correct indices
for ( int z=0; z < depth; z++ ) {
int pz = z*width;
for ( int x=0; x < width; x++ ) {
GridNode node = tmp[pz + x];
node.NodeInGridIndex = pz + x;
nodes[pz + x] = node;
}
}
IntRect r = new IntRect ( 0, 0, offset.x, offset.y );
int minz = r.ymax;
int maxz = depth;
// If offset.x < 0, adjust the rect
if ( r.xmin > r.xmax ) {
int tmp2 = r.xmax;
r.xmax = width + r.xmin;
r.xmin = width + tmp2;
}
// If offset.y < 0, adjust the rect
if ( r.ymin > r.ymax ) {
int tmp2 = r.ymax;
r.ymax = depth + r.ymin;
r.ymin = depth + tmp2;
minz = 0;
maxz = r.ymin;
}
// Make sure erosion is taken into account
// Otherwise we would end up with ugly artifacts
r = r.Expand ( graph.erodeIterations + 1 );
// Makes sure the rect stays inside the grid
r = IntRect.Intersection ( r, new IntRect ( 0, 0, width, depth ) );
yield return null;
// Update all nodes along one edge of the graph
// With the same width as the rect
for ( int z = r.ymin; z < r.ymax; z++ ) {
for ( int x = 0; x < width; x++ ) {
graph.UpdateNodePositionCollision ( nodes[z*width + x], x, z, false );
}
}
yield return null;
// Update all nodes along the other edge of the graph
// With the same width as the rect
for ( int z = minz; z < maxz; z++ ) {
for ( int x = r.xmin; x < r.xmax; x++ ) {
graph.UpdateNodePositionCollision ( nodes[z*width + x], x, z, false );
}
}
yield return null;
// Calculate all connections for the nodes
// that might have changed
for ( int z = r.ymin; z < r.ymax; z++ ) {
for ( int x = 0; x < width; x++ ) {
graph.CalculateConnections (nodes, x, z, nodes[z*width+x]);
}
}
yield return null;
// Calculate all connections for the nodes
// that might have changed
for ( int z = minz; z < maxz; z++ ) {
for ( int x = r.xmin; x < r.xmax; x++ ) {
graph.CalculateConnections (nodes, x, z, nodes[z*width+x]);
}
}
yield return null;
// Calculate all connections for the nodes along the boundary
// of the graph, these always need to be updated
/** \todo Optimize to not traverse all nodes in the graph, only those at the edges */
for ( int z = 0; z < depth; z++ ) {
for ( int x = 0; x < width; x++ ) {
if ( x == 0 || z == 0 || x >= width-1 || z >= depth-1 ) graph.CalculateConnections (nodes, x, z, nodes[z*width+x]);
}
}
} else {
// Just update all nodes
for ( int z = 0; z < depth; z++ ) {
for ( int x = 0; x < width; x++ ) {
graph.UpdateNodePositionCollision ( nodes[z*width + x], x, z, false );
}
}
// Recalculate the connections of all nodes
for ( int z = 0; z < depth; z++ ) {
for ( int x = 0; x < width; x++ ) {
graph.CalculateConnections (nodes, x, z, nodes[z*width+x]);
}
}
}
if ( floodFill ) {
yield return null;
// Make sure the areas for the graph
// have been recalculated
// not doing this can cause pathfinding to fail
AstarPath.active.QueueWorkItemFloodFill ();
}
}
public bool CanMove(Int2 delta)
{
return(CanMove(delta.x, delta.y));
}
/// <summary>
/// Find the region of the texture containing the sprite under the specified pixel.
/// </summary>
/// <param name="texture">The texture containing the sprite</param>
/// <param name="pixel">The coordinate of the pixel specifying the sprite</param>
/// <param name="separatorColor">The separator color that delimit the sprites. If null the <see cref="Color.Transparent"/> color is used</param>
/// <param name="separatorMask">The mask specifying which bits of the color should be checked. The bits are ordered as AABBGGRR.</param>
/// <returns></returns>
public unsafe Rectangle FindSpriteRegion(TexImage texture, Int2 pixel, Color? separatorColor = null, uint separatorMask = 0xff000000)
{
if (texture == null) throw new ArgumentNullException(nameof(texture));
var format = texture.Format;
if (texture.Dimension != TexImage.TextureDimension.Texture2D || !(format.IsRGBAOrder() || format.IsBGRAOrder() || format.SizeInBytes() != 4))
throw new NotImplementedException();
// adjust the separator color the mask depending on the color format.
var separator = (uint)(separatorColor ?? Color.Transparent).ToRgba();
if(texture.Format.IsBGRAOrder())
{
separator = RgbaToBgra(separator);
separatorMask = RgbaToBgra(separatorMask);
}
var maskedSeparator = separator & separatorMask;
var ptr = (uint*)texture.Data;
var stride = texture.RowPitch / 4;
// check for empty region (provided pixel is not valid)
var textureRegion = new Rectangle(0, 0, texture.Width, texture.Height);
if (!textureRegion.Contains(pixel) || (ptr[pixel.Y * stride + pixel.X] & separatorMask) == maskedSeparator)
return new Rectangle(pixel.X, pixel.Y, 0, 0);
// initialize the region with the provided pixel
var region = new Rectangle(pixel.X, pixel.Y, 1, 1);
var nextSearchOffsets = new[,]
{
{ new Int2(-1, -1), new Int2( 0, -1) },
{ new Int2( 1, -1), new Int2( 1, 0) },
{ new Int2( 1, 1), new Int2( 0, 1) },
{ new Int2(-1, 1), new Int2(-1, 0) }
};
var contourLeftEgde = pixel;
var rotationDirection = 0;
do
{
// Stage 1: Find an edge of the shape (look to the left of the provided pixel as long as possible)
var startEdge = contourLeftEgde;
var startEdgeDirection = EdgeDirection.Left;
for (int x = startEdge.X; x >= 0; --x)
{
if ((ptr[startEdge.Y * stride + x] & separatorMask) == maskedSeparator)
break;
startEdge.X = x;
}
// Stage 2: Determine the whole contour of the shape and update the region.
// Note: the found contour can correspond to an internal hole contour or the external shape contour.
var currentEdge = startEdge;
var currentEdgeDirection = startEdgeDirection;
do
{
var previousEdgeDirection = currentEdgeDirection;
var diagonalPixel = currentEdge + nextSearchOffsets[(int)currentEdgeDirection, 0];
var diagonalIsSeparator = !textureRegion.Contains(diagonalPixel) || (ptr[diagonalPixel.Y * stride + diagonalPixel.X] & separatorMask) == maskedSeparator;
var neighbourPixel = currentEdge + nextSearchOffsets[(int)currentEdgeDirection, 1];
var neighbourIsSeparator = !textureRegion.Contains(neighbourPixel) || (ptr[neighbourPixel.Y * stride + neighbourPixel.X] & separatorMask) == maskedSeparator;
// determine the next edge position
if (!diagonalIsSeparator)
{
currentEdge = diagonalPixel;
currentEdgeDirection = (EdgeDirection)(((int)currentEdgeDirection + 3) % 4);
}
else if (!neighbourIsSeparator)
{
currentEdge = neighbourPixel;
}
else
{
currentEdgeDirection = (EdgeDirection)(((int)currentEdgeDirection + 1) % 4);
}
// keep record of the point of the edge which is
if (currentEdge.X < contourLeftEgde.X)
contourLeftEgde = currentEdge;
// increase or decrease the rotation counter based on the sequence of edge direction
rotationDirection += RotationDirection(previousEdgeDirection, currentEdgeDirection);
// update the rectangle
region = Rectangle.Union(region, currentEdge);
}
while (currentEdge != startEdge || currentEdgeDirection != startEdgeDirection); // as long as we do not close the contour continue to explore
} // repeat the process as long as the edge found is not the shape external contour.
while (rotationDirection != 4);
return region;
}
public bool TryMove(Int2 delta)
{
return(TryMove(delta.row, delta.col));
}
