public void GivenTheResourceHasATextureLayerCalled(string shaderName, string textureName)
{
ShaderResource s1 = ScenarioContext.Current.Get<ShaderResource>(shaderName);
TextureLayer t1 = new TextureLayer();
t1.TextureName = textureName;
s1.ShaderTextureLayerList.Add(t1);
ScenarioContext.Current.Set<TextureLayer>(t1, textureName);
}
public void addTexture(
Texture texture,
Offset offset,
float width,
float height,
bool freeze)
{
if (this._currentLayer == null)
{
return;
}
var layer = new TextureLayer();
layer.offset = offset;
layer.size = new Size(width, height);
layer.texture = texture;
layer.freeze = freeze;
this._currentLayer.add(layer);
}
public void AddTexture(
double dx,
double dy,
double width,
double height,
Int64 textureId,
bool freeze)
{
if (current_layer_ == null)
{
return;
}
var layer = new TextureLayer();
layer.set_offset(new SKPoint((float)dx, (float)dy));
layer.set_size(new SKSize((float)width, (float)height));
layer.set_texture_id((ulong)textureId);
layer.set_freeze(freeze);
current_layer_.Add(layer);
}
private void LinearEraser(int u, int v, float distance, float radius, float alpha, TextureLayer layer)
{
LinearBrush(u, v, distance, radius, -alpha, layer);
}
/// <summary>
///
/// </summary>
/// <param name="position"></param>
/// <param name="radius"></param>
/// <param name="layer"></param>
/// <param name="magnitude"></param>
/// <param name="modifyTexel"></param>
private void ModifyTexels(Vector3 position, float radius, float alpha, TextureLayer layer, string detailTextureName, Vector2 uVOffset, Vector2 uVScale, Brush modifyTexel, bool isFeathered, bool isBlock)
{
radius *= NUM_SIDE_VERTICES * NUM_SIDE_TEXELS_PER_QUAD;
float radiusSquared = radius * radius;
Vector2 position2D = new Vector2(position.X, position.Z) * NUM_SIDE_VERTICES * NUM_SIDE_TEXELS_PER_QUAD;
int minZ = (int)Math.Max(0, position2D.Y - radius), maxZ = (int)Math.Min(NUM_SIDE_VERTICES * NUM_SIDE_TEXELS_PER_QUAD - 1, position2D.Y + radius);
int minX = (int)Math.Max(0, position2D.X - radius), maxX = (int)Math.Min(NUM_SIDE_VERTICES * NUM_SIDE_TEXELS_PER_QUAD - 1, position2D.X + radius);
for (int vIndex = minZ; vIndex <= maxZ; ++vIndex)
{
for (int uIndex = minX; uIndex <= maxX; ++uIndex)
{
Vector2 displacement = new Vector2(uIndex, vIndex) - position2D;
float distanceSquared = displacement.LengthSquared();
if (isBlock || distanceSquared < radiusSquared)
{
int intRadius = (int)radius;
modifyTexel(uIndex, vIndex, distanceSquared, radiusSquared, alpha, layer);
SetTextureName(layer, detailTextureName, uVOffset, uVScale);
}
}
}
mDirtyTexture = true;
}
public void PaintTerrain(Vector3 position, float radius, float alpha, TextureLayer layer, string detailTextureName, Vector2 uVOffset, Vector2 uVScale, bool isFeathered, bool isBlock)
{
if (!isFeathered)
{
PaintSolidBrush(position, radius, alpha, layer, detailTextureName, uVOffset, uVScale, isFeathered, isBlock);
}
else
{
PaintLinearBrush(position, radius, alpha, layer, detailTextureName, uVOffset, uVScale, isFeathered, isBlock);
}
}
private void CompositeBrushColor(ref Color result, TextureLayer layer, float alpha)
{
float newColor = 255.0f * alpha;
switch (layer)
{
case TextureLayer.ALPHA:
result.A = (byte)Math.Max(Math.Min(result.A + newColor, 255), 0);
break;
case TextureLayer.RED:
result.R = (byte)Math.Max(Math.Min(result.R + newColor, 255), 0);
break;
case TextureLayer.GREEN:
result.G = (byte)Math.Max(Math.Min(result.G + newColor, 255), 0);
break;
case TextureLayer.BLUE:
result.B = (byte)Math.Max(Math.Min(result.B + newColor, 255), 0);
break;
case TextureLayer.BACKGROUND:
break;
}
}
private void SolidEraser(int u, int v, float distance, float radius, float alpha, TextureLayer layer)
{
SolidBrush(u, v, distance, radius, -alpha, layer);
}
public void PaintLinearBrush(Vector2 position, float radius, float alpha, TextureLayer layer, string detailTextureName, Vector2 uVSOffset, Vector2 uVScale)
{
Brush lerpModifier = LinearBrush;
ModifyTexels(position, radius, alpha, layer, detailTextureName, uVSOffset, uVScale, lerpModifier);
}
/// <summary>
///
/// </summary>
/// <param name="u"></param>
/// <param name="v"></param>
/// <param name="distance"></param>
/// <param name="radiusTextureLayer"></param>
private void SolidBrush(int u, int v, float distance, float radius, float alpha, TextureLayer layer)
{
CompositeBrushColor(ref mTexels[u + v * mWidth], layer, alpha);
}
private void SmoothBrush(int u, int v, float distance, float radius, float alpha, TextureLayer layer)
{
float aSum = 0.0f, rSum = 0.0f, gSum = 0.0f, bSum = 0.0f;
int count = 0;
for (int row = Math.Max(0, v - 1); row <= Math.Min(NUM_SIDE_VERTICES * NUM_SIDE_TEXELS_PER_QUAD - 1, v + 1); ++row)
{
for (int col = Math.Max(0, u - 1); col <= Math.Min(NUM_SIDE_VERTICES * NUM_SIDE_TEXELS_PER_QUAD - 1, u + 1); ++col)
{
++count;
Color neighborColor = mTexels[col + row * NUM_SIDE_VERTICES * NUM_SIDE_TEXELS_PER_QUAD];
aSum += neighborColor.A;
rSum += neighborColor.R;
gSum += neighborColor.G;
bSum += neighborColor.B;
}
}
mTexels[u + v * NUM_SIDE_VERTICES * NUM_SIDE_TEXELS_PER_QUAD].A = (byte)(aSum / count);
mTexels[u + v * NUM_SIDE_VERTICES * NUM_SIDE_TEXELS_PER_QUAD].R = (byte)(rSum / count);
mTexels[u + v * NUM_SIDE_VERTICES * NUM_SIDE_TEXELS_PER_QUAD].G = (byte)(gSum / count);
mTexels[u + v * NUM_SIDE_VERTICES * NUM_SIDE_TEXELS_PER_QUAD].B = (byte)(bSum / count);
}
private void QuadraticBrush(int u, int v, float distance, float radius, float alpha, TextureLayer layer)
{
float InterpolateWeight = (float)Math.Pow(distance / radius, 2);
CompositeBrushColor(ref mTexels[u + v * mWidth], layer, (1.0f - alpha) * alpha);
}
/// <summary>
///
/// </summary>
/// <param name="u"></param>
/// <param name="v"></param>
/// <param name="layer"></param>
/// <param name="detailTextureName"></param>
private void SetTextureName(int u, int v, TextureLayer layer, string detailTextureName, Vector2 uVOffset, Vector2 uVScale)
{
if (detailTextureName != null)
{
int chunkRowIndex = v / mChunkHeight;
int chunkColIndex = u / mChunkWidth;
mDetailTextureNames[chunkRowIndex, chunkColIndex, (int)layer] = detailTextureName;
mDetailTextureUVOffset[chunkRowIndex, chunkColIndex, (int)layer] = uVOffset;
mDetailTextureUVScale[chunkRowIndex, chunkColIndex, (int)layer] = uVScale;
}
}
/// <summary>
///
/// </summary>
/// <param name="position"></param>
/// <param name="radius"></param>
/// <param name="layer"></param>
/// <param name="magnitude"></param>
/// <param name="modifyTexel"></param>
private void ModifyTexels(Vector2 position, float radius, float alpha, TextureLayer layer, string detailTextureName, Vector2 uVOffset, Vector2 uVScale, Brush modifyTexel)
{
radius = radius / 100.0f * mHeight;
float radiusSquared = radius * radius;
//position.X = (position.X / Utils.WorldScale.X + 50.0f) / 100.0f * mWidth;
//position.Y = (position.Y / Utils.WorldScale.Z + 50.0f) / 100.0f * mHeight;
int minZ = (int)Math.Max(0, position.Y - radius), maxZ = (int)Math.Min(mHeight - 1, position.Y + radius);
int minX = (int)Math.Max(0, position.X - radius), maxX = (int)Math.Min(mWidth - 1, position.X + radius);
for (int vIndex = minZ; vIndex <= maxZ; ++vIndex)
{
for (int uIndex = minX; uIndex <= maxX; ++uIndex)
{
Vector2 displacement = new Vector2(uIndex, vIndex) - position;
float distanceSquared = displacement.LengthSquared();
if (mIsBlock || distanceSquared < radiusSquared)
{
int intRadius = (int)radius;
modifyTexel(uIndex, vIndex, distanceSquared, radiusSquared, alpha, layer);
SetTextureName(uIndex, vIndex, layer, detailTextureName, uVOffset, uVScale);
WriteDirtyBit(uIndex, vIndex);
}
}
}
UpdateTextureBuffers();
}
/// <summary>
///
/// </summary>
/// <param name="u"></param>
/// <param name="v"></param>
/// <param name="distance"></param>
/// <param name="radius"></param>
/// <param name="layer"></param>
private void LinearBrush(int u, int v, float distance, float radius, float alpha, TextureLayer layer)
{
float InterpolateWeight = distance / radius;
CompositeBrushColor(ref mTexels[u + v * mWidth], layer, (1.0f - alpha) * alpha);
}
public void PaintQuadraticBrush(Vector2 position, float radius, float alpha, TextureLayer layer, string detailTextureName, Vector2 uVSOffset, Vector2 uVScale)
{
Brush quadModifier = QuadraticBrush;
ModifyTexels(position, radius, alpha, layer, detailTextureName, uVSOffset, uVScale, quadModifier);
}
private void QuadraticBrush(int u, int v, float distance, float radius, float alpha, TextureLayer layer)
{
float InterpolateWeight = (float)Math.Pow(distance / radius, 2);
CompositeBrushColor(ref mTexels[u + v * NUM_SIDE_VERTICES * NUM_SIDE_TEXELS_PER_QUAD], layer, (1.0f - alpha) * alpha);
}
public ActionParameters(Vector2 position, float radius, float alpha, TextureLayer layer)
{
Position = position;
Radius = radius;
Alpha = alpha;
Layer = layer;
}
/// <summary>
///
/// </summary>
/// <param name="u"></param>
/// <param name="v"></param>
/// <param name="layer"></param>
/// <param name="detailTextureName"></param>
private void SetTextureName(TextureLayer layer, string detailTextureName, Vector2 uVOffset, Vector2 uVScale)
{
if (detailTextureName != null)
{
mDetailTextureNames[(int)layer] = detailTextureName;
mDetailTextureUVOffset[(int)layer] = uVOffset;
mDetailTextureUVScale[(int)layer] = uVScale;
}
}
public void EraseSolidBrush(Vector2 position, float radius, float alpha, TextureLayer layer, string detailTextureName, Vector2 uVSOffset, Vector2 uVScale)
{
Brush solidModifier = SolidEraser;
ModifyTexels(position, radius, alpha, layer, detailTextureName, uVSOffset, uVScale, solidModifier);
}
/// <summary>
///
/// </summary>
/// <param name="u"></param>
/// <param name="v"></param>
/// <param name="distance"></param>
/// <param name="radiusTextureLayer"></param>
private void SolidBrush(int u, int v, float distance, float radius, float alpha, TextureLayer layer)
{
CompositeBrushColor(ref mTexels[u + v * NUM_SIDE_VERTICES * NUM_SIDE_TEXELS_PER_QUAD], layer, alpha);
}
/// <summary>
///
/// </summary>
/// <param name="position"></param>
/// <param name="radius"></param>
/// <param name="layer"></param>
/// <param name="detailTextureName"></param>
public void PaintSolidBrush(Vector3 position, float radius, float alpha, TextureLayer layer, string detailTextureName, Vector2 uVSOffset, Vector2 uVScale, bool isFeathered, bool isBlock)
{
Brush solidModifier = SolidBrush;
ModifyTexels(position, radius, alpha, layer, detailTextureName, uVSOffset, uVScale, solidModifier, isFeathered, isBlock);
}
public void EraseLinearBrush(Vector3 position, float radius, float alpha, TextureLayer layer, string detailTextureName, Vector2 uVSOffset, Vector2 uVScale, bool isFeathered, bool isBlock)
{
Brush lerpModifier = LinearEraser;
ModifyTexels(position, radius, alpha, layer, detailTextureName, uVSOffset, uVScale, lerpModifier, isFeathered, isBlock);
}
public void EraseTerrain(Vector2 position, float radius, float alpha, TextureLayer layer, string detailTextureName, Vector2 uVOffset, Vector2 uVScale)
{
if (!mIsFeathered)
{
EraseSolidBrush(position, radius, alpha, layer, detailTextureName, uVOffset, uVScale);
}
else
{
EraseLinearBrush(position, radius, alpha, layer, detailTextureName, uVOffset, uVScale);
}
}
