private void CreateSpriteRendererAndAnimator(
out IComponentSpriteRenderer spriteRenderer,
out ClientComponentSpriteSheetAnimator componentAnimatorFlash,
byte atlasRow,
IProtoItemWeaponRanged protoWeapon,
TextureAtlasResource muzzleFlashTextureAtlas)
{
var animationFrameDurationSeconds = this.animationDuration
/ (double)muzzleFlashTextureAtlas.AtlasSize.ColumnsCount;
// create sprite renderer
spriteRenderer = Api.Client.Rendering.CreateSpriteRenderer(
this.SceneObject,
textureResource: TextureResource.NoTexture,
// draw in the same layer as the skeleton renderer
// (cannot do Default+1 here as it will produce wrong result over other objects)
drawOrder: DrawOrder.Default,
rotationAngleRad: 0,
// align sprite by left side and centered vertical
spritePivotPoint: (0, 0.5),
scale: (float)this.description.TextureScale);
// to ensure muzzleflash rendering over skeleton renderer we do this offset
// TODO: find a better way of prioritizing rendering of muzzle flash over skeleton renderer
spriteRenderer.DrawOrderOffsetY = -0.2;
// create animator for sprite renderer
componentAnimatorFlash = this.SceneObject.AddComponent <ClientComponentSpriteSheetAnimator>();
componentAnimatorFlash.Setup(
spriteRenderer,
ClientComponentSpriteSheetAnimator.CreateAnimationFrames(
muzzleFlashTextureAtlas,
onlySpecificRow: atlasRow),
animationFrameDurationSeconds);
}
private void CreateSpriteRendererAndAnimator(
out IComponentSpriteRenderer spriteRenderer,
out ClientComponentSpriteSheetAnimator componentAnimatorFlash,
byte atlasRow,
TextureAtlasResource muzzleFlashTextureAtlas)
{
var animationFrameDurationSeconds = this.animationDuration
/ (double)muzzleFlashTextureAtlas.AtlasSize.ColumnsCount;
// create sprite renderer
spriteRenderer = Api.Client.Rendering.CreateSpriteRenderer(
this.SceneObject,
textureResource: TextureResource.NoTexture,
// draw in the same layer as the skeleton renderer
// (cannot do Default+1 here as it will produce wrong result over other objects)
drawOrder: DrawOrder.Default,
rotationAngleRad: 0,
// align sprite by left side and centered vertical
spritePivotPoint: (0, 0.5),
scale: (float)this.description.TextureScale);
// create animator for sprite renderer
componentAnimatorFlash = this.SceneObject.AddComponent <ClientComponentSpriteSheetAnimator>();
componentAnimatorFlash.Setup(
spriteRenderer,
ClientComponentSpriteSheetAnimator.CreateAnimationFrames(
muzzleFlashTextureAtlas,
onlySpecificRow: atlasRow),
isLooped: false,
animationFrameDurationSeconds,
isManualUpdate: true);
}
public ObjectStove()
{
this.textureAtlasOvenActive = new TextureAtlasResource(
this.GenerateTexturePath() + "Fire",
columns: 4,
rows: 2,
isTransparent: false);
}
public ObjectOilRefinery()
{
this.textureAtlasOilPumpActive = new TextureAtlasResource(
this.GenerateTexturePath() + "Active",
columns: 2,
rows: 4,
isTransparent: false);
}
public ObjectPowerStorageLarge()
{
this.textureAtlasActive = new TextureAtlasResource(
this.GenerateTexturePath() + "Animation",
columns: 3,
rows: 2,
isTransparent: true);
}
public ObjectOilPump()
{
this.textureAtlasOilPumpActive = new TextureAtlasResource(
this.GenerateTexturePath() + "Active",
columns: 8,
rows: 2,
isTransparent: true);
}
public MuzzleFlashDescription Set(
Color?lightColor = null,
double?lightDurationSeconds = null,
double?lightPower = null,
Vector2D?lightRelativeToTextureScreenOffset = null,
double?textureAnimationDurationSeconds = null,
TextureAtlasResource textureAtlas = null,
double?textureScale = null,
Vector2D?textureScreenOffset = null,
double?textureOriginX = null)
{
if (lightColor.HasValue)
{
this.LightColor = lightColor.Value;
}
if (lightDurationSeconds is not null)
{
this.LightDurationSeconds = lightDurationSeconds.Value;
}
if (lightPower is not null)
{
this.LightPower = lightPower.Value;
}
if (lightRelativeToTextureScreenOffset is not null)
{
this.LightScreenOffsetRelativeToTexture = lightRelativeToTextureScreenOffset.Value;
}
if (textureAnimationDurationSeconds is not null)
{
this.TextureAnimationDurationSeconds = textureAnimationDurationSeconds.Value;
}
if (textureAtlas is not null)
{
this.TextureAtlas = textureAtlas;
}
if (textureScale is not null)
{
this.TextureScale = textureScale.Value;
}
if (textureScreenOffset is not null)
{
this.TextureScreenOffset = textureScreenOffset.Value;
}
if (textureOriginX is not null)
{
this.TextureOriginX = textureOriginX.Value;
}
return(this);
}
protected override ITextureResource PrepareDefaultTexture(Type thisType)
{
this.textureAtlasResource = new TextureAtlasResource(
this.TextureAtlasPath,
4,
rows: this.TextureVariantsCount,
isTransparent: true);
return(this.textureAtlasResource);
}
public ClientFarmPlotBlendHelper(IProtoObjectFarmPlot protoFarmPlot)
{
this.protoFarmPlot = protoFarmPlot;
this.maskTexture = this.protoFarmPlot.BlendMaskTextureAtlas;
// ReSharper disable once CanExtractXamlLocalizableStringCSharp
this.sceneObjectsName = this.protoFarmPlot.Name + "BlendRenderer";
Api.Client.World.WorldBoundsChanged += this.WorldBoundsChangedHandler;
}
protected override ITextureResource PrepareDefaultTexture(Type thisType)
{
this.textureAtlasActive = new TextureAtlasResource(
this.GenerateTexturePath() + "Active",
columns: 6,
rows: 2,
isTransparent: true);
return(base.PrepareDefaultTexture(thisType));
}
protected override ITextureResource PrepareDefaultTexture(Type thisType)
{
this.texturePrimaryAtlas = new TextureAtlasResource(
GenerateTexturePath(thisType),
5,
2,
isTransparent: true);
return(this.texturePrimaryAtlas);
}
protected override ITextureResource PrepareDefaultTexture(Type thisType)
{
var texturePath = GenerateTexturePath(thisType);
this.textureAtlasActiveAnimation = new TextureAtlasResource(texturePath + "Active",
columns: 4,
rows: 1,
isTransparent: true);
return(new TextureResource(texturePath));
}
public static void CreateCliffRenderer(
IClientSceneObject sceneObject,
ColumnRow textureRegion,
TextureAtlasResource cliffAtlas)
{
RenderingService.CreateSpriteRenderer(
sceneObject,
cliffAtlas.Chunk(textureRegion.Column, textureRegion.Row),
drawOrder: DrawOrder.GroundCliffs,
positionOffset: (0, 0));
}
public Task <IGeneratedTexture2D> GenerateProceduralTextureNonAtlas(
[NotNull] string textureName,
[NotNull] TextureAtlasResource wallSpriteAtlas,
ProceduralTextureRequest request)
{
return(this.GenerateProceduralTextureInternal(
textureName,
wallSpriteAtlas,
request,
isAtlas: false));
}
public ObjectCampfire()
{
this.textureAtlasCampfireActive = new TextureAtlasResource(
this.GenerateTexturePath() + "Fire",
columns: 4,
rows: 2,
isTransparent: true);
this.textureResourceCampfireBurned = new TextureResource(
this.GenerateTexturePath() + "Burned");
}
protected override ITextureResource PrepareDefaultTexture(Type thisType)
{
// prepare atlas for active mode
this.textureAtlasActive = new TextureAtlasResource(
this.GenerateTexturePath() + "Fire",
columns: 8,
rows: 1,
isTransparent: false);
// return base texture
return(base.PrepareDefaultTexture(thisType));
}
protected override void PrepareProtoStaticWorldObject()
{
base.PrepareProtoStaticWorldObject();
this.cachedBlendMaskTextureAtlas = new TextureAtlasResource(
this.BlendMaskTexture,
columns: 4,
rows: 1);
this.clientBlendHelper = IsClient
? new ClientFarmPlotBlendHelper(this)
: null;
}
public async Task <ITextureResource> GenerateProceduralTexture(
[NotNull] string textureName,
[NotNull] TextureAtlasResource sourceTextureAtlas,
ProceduralTextureRequest request)
{
var result = await this.GenerateProceduralTextureInternal(
textureName,
sourceTextureAtlas,
request,
isAtlas : true);
return((IGeneratedTexture2DAtlas)result);
}
public ProtoTileGroundTexture(
TextureResource texture,
ITextureResource blendMaskTexture,
INoiseSelector noiseSelector)
{
this.Texture = texture;
this.BlendMaskTexture = new TextureAtlasResource(
blendMaskTexture,
columns: 4,
rows: 1);
this.NoiseSelector = noiseSelector;
}
public ObjectLithiumOreExtractorAdvanced()
{
var texturePath = this.GenerateTexturePath();
this.textureAtlasActive1 = new TextureAtlasResource(
texturePath + "Active1",
columns: 8,
rows: 1,
isTransparent: true);
this.textureAtlasActive2 = new TextureAtlasResource(
texturePath + "Active2",
columns: 8,
rows: 1,
isTransparent: true);
}
public WeaponHitSparksPreset Add(
ObjectMaterial material,
double texturePivotY,
TextureAtlasResource texture,
Color?lightColor = null,
bool useScreenBlending = false,
bool allowRandomizedHitPointOffset = true)
{
var frames = ClientComponentSpriteSheetAnimator.CreateAnimationFrames(texture);
this.HitSparksPreset[material] = new HitSparksEntry(frames,
lightColor,
useScreenBlending,
texturePivotY,
allowRandomizedHitPointOffset);
return(this);
}
protected override ITextureResource PrepareDefaultTexture(Type thisType)
{
var texturePath = GenerateTexturePath(typeof(ObjectDepositGeothermalSpring));
this.textureAtlas1 = new TextureAtlasResource(
texturePath,
columns: 6,
rows: 1,
isTransparent: true);
this.textureAtlas2 = new TextureAtlasResource(
texturePath + "2",
columns: 6,
rows: 1,
isTransparent: true);
return(this.textureAtlas1);
}
protected sealed override void PrepareProtoStaticWorldObject()
{
base.PrepareProtoStaticWorldObject();
var texturePrimaryAtlasPath = this.TextureAtlasPrimaryPath;
this.TextureAtlasPrimary = new TextureAtlasResource(
texturePrimaryAtlasPath,
columns: 7,
rows: 3,
isTransparent: true);
this.TextureAtlasDestroyed = new TextureAtlasResource(
texturePrimaryAtlasPath + "Destroyed",
columns: 7,
rows: 3,
isTransparent: true);
this.PrepareProtoWall();
}
public WeaponHitSparksPreset SetDefault(
double texturePivotY,
TextureAtlasResource texture,
Color?lightColor = null,
bool useScreenBlending = false,
bool allowRandomizedHitPointOffset = true)
{
var frames = ClientComponentSpriteSheetAnimator.CreateAnimationFrames(texture);
foreach (var soundMaterial in AllSoundMaterials)
{
this.HitSparksPreset[soundMaterial] = new HitSparksEntry(frames,
lightColor,
useScreenBlending,
texturePivotY,
allowRandomizedHitPointOffset);
}
return(this);
}
public static ITextureAtlasResource CreateProceduralTexture(
[NotNull] string name,
[NotNull] TextureAtlasResource sourceTextureAtlas)
{
var proceduralTextureResource = new ProceduralTexture(
name,
isTransparent: true,
isUseCache: true,
generateTextureCallback:
request => Instance.GenerateProceduralTexture(name, sourceTextureAtlas, request),
dependsOn: new[] { sourceTextureAtlas });
var columnsCount = AtlasSize.ColumnsCount;
var rowsCount = AtlasSize.RowsCount;
return(new TextureAtlasResource(
proceduralTextureResource,
columnsCount,
rowsCount));
}
public ObjectLootGrass()
{
textureAtlas = new TextureAtlasResource(this.GenerateTexturePath(), 4, 1, true);
}
public static void CreateCliffsRenderersIfNeeded(
Tile tile,
IClientSceneObject sceneObject,
TextureAtlasResource cliffAtlas)
{
if (!tile.IsSlope &&
!tile.IsCliff)
{
return;
}
if (tile.IsSlope)
{
var isSlopeUp = tile.NeighborTileUp.Height > tile.Height;
if (isSlopeUp)
{
if (!tile.NeighborTileRight.IsSlope)
{
CreateCliffRenderer(sceneObject, CliffTextureRegion.SlopeBottomRight, cliffAtlas);
}
if (!tile.NeighborTileLeft.IsSlope)
{
CreateCliffRenderer(sceneObject, CliffTextureRegion.SlopeBottomLeft, cliffAtlas);
}
}
else // if slope down
{
if (!tile.NeighborTileRight.IsSlope)
{
CreateCliffRenderer(sceneObject, CliffTextureRegion.SlopeTopRight, cliffAtlas);
}
if (!tile.NeighborTileLeft.IsSlope)
{
CreateCliffRenderer(sceneObject, CliffTextureRegion.SlopeTopLeft, cliffAtlas);
}
}
return;
}
var height = tile.Height;
// create cliffs rendering if needed
var left = IsHigherTile(tile, height, -1, 0);
var up = IsHigherTile(tile, height, 0, 1);
var right = IsHigherTile(tile, height, 1, 0);
var down = IsHigherTile(tile, height, 0, -1);
if (left &&
up &&
right &&
down)
{
CreateCliffRenderer(sceneObject, CliffTextureRegion.FourSidesInnerCorner, cliffAtlas);
return;
}
var upLeft = IsHigherTile(tile, height, -1, 1);
var upRight = IsHigherTile(tile, height, 1, 1);
var downLeft = IsHigherTile(tile, height, -1, -1);
var downRight = IsHigherTile(tile, height, 1, -1);
if (down)
{
// down tile is higher height
if (!left &&
!right)
{
CreateCliffRenderer(sceneObject, CliffTextureRegion.TopCenter, cliffAtlas);
}
else if (left && right)
{
CreateCliffRenderer(sceneObject, CliffTextureRegion.TopLeftRightInnerCorner, cliffAtlas);
}
else if (right && !up)
{
CreateCliffRenderer(sceneObject, CliffTextureRegion.TopLeftInnerCorner, cliffAtlas);
}
else if (left && !up)
{
CreateCliffRenderer(sceneObject, CliffTextureRegion.TopRightInnerCorner, cliffAtlas);
}
}
if (up)
{
if (!left &&
!right)
{
CreateCliffRenderer(sceneObject, CliffTextureRegion.BottomCenter, cliffAtlas);
}
else if (left && right)
{
CreateCliffRenderer(sceneObject, CliffTextureRegion.BottomLeftRightInnerCorner, cliffAtlas);
}
else if (right && !down)
{
CreateCliffRenderer(sceneObject, CliffTextureRegion.BottomLeftInnerCorner, cliffAtlas);
}
else if (left && !down)
{
CreateCliffRenderer(sceneObject, CliffTextureRegion.BottomRightInnerCorner, cliffAtlas);
}
}
if (up && down)
{
if (left)
{
CreateCliffRenderer(sceneObject, CliffTextureRegion.TopBottomRightInnerCorner, cliffAtlas);
}
else if (right)
{
CreateCliffRenderer(sceneObject, CliffTextureRegion.TopBottomLeftInnerCorner, cliffAtlas);
}
}
if (!down)
{
if (left && !up)
{
CreateCliffRenderer(sceneObject, CliffTextureRegion.MiddleTiledRight, cliffAtlas);
}
if (right && !up)
{
CreateCliffRenderer(sceneObject, CliffTextureRegion.MiddleTiledLeft, cliffAtlas);
}
if (downLeft &&
downRight &&
!left &&
!right)
{
CreateCliffRenderer(sceneObject, CliffTextureRegion.TopRightCorner, cliffAtlas);
CreateCliffRenderer(sceneObject, CliffTextureRegion.TopLeftCorner, cliffAtlas);
}
else if (downLeft && !left)
{
CreateCliffRenderer(sceneObject, CliffTextureRegion.TopRightCorner, cliffAtlas);
}
else if (downRight && !right)
{
CreateCliffRenderer(sceneObject, CliffTextureRegion.TopLeftCorner, cliffAtlas);
}
}
if (!up)
{
if (upLeft &&
upRight &&
!left &&
!right)
{
CreateCliffRenderer(sceneObject, CliffTextureRegion.BottomRight, cliffAtlas);
CreateCliffRenderer(sceneObject, CliffTextureRegion.BottomLeft, cliffAtlas);
}
else if (upLeft && !left)
{
CreateCliffRenderer(sceneObject, CliffTextureRegion.BottomRight, cliffAtlas);
}
else if (upRight && !right)
{
CreateCliffRenderer(sceneObject, CliffTextureRegion.BottomLeft, cliffAtlas);
}
}
}
public MaterialCacheKey(TileBlendSides blendSides, TextureAtlasResource maskTextureAtlasResource)
{
this.BlendSides = blendSides;
this.MaskTextureAtlasResource = maskTextureAtlasResource;
}
private async Task <IGeneratedTexture2D> GenerateProceduralTextureInternal(
string textureName,
TextureAtlasResource sourceTextureAtlas,
ProceduralTextureRequest request,
bool isAtlas)
{
var renderingTag = string.Format("Procedural texture \"{0}\" camera \"{1}\"",
textureName,
sourceTextureAtlas.TextureResource);
var client = Api.Client;
var cameraObject = client.Scene.CreateSceneObject(renderingTag);
var camera = client.Rendering.CreateCamera(cameraObject,
renderingTag,
-10);
var wallChunkTypes = FloorChunkPresets;
var atlasSize = AtlasSize;
var textureWidth = this.AtlasTextureWidth;
var textureHeight = this.AtlasTextureHeight;
var rendering = Api.Client.Rendering;
var renderTexture = rendering.CreateRenderTexture(renderingTag, textureWidth, textureHeight);
camera.RenderTarget = renderTexture;
// TODO: we cannot use Colors.Transparent because RGB=FFFFFF in that case.
camera.ClearColor = Color.FromArgb(0, 0, 0, 0);
camera.SetOrthographicProjection(textureWidth, textureHeight);
camera.TextureFilter = TextureFilter.Point;
foreach (var variant in wallChunkTypes.Values)
{
if (variant.Layers == null)
{
// reusing layers from another chunk
continue;
}
var targetRow = variant.TargetRow;
var targetColumn = variant.TargetColumn;
if (targetRow >= atlasSize.RowsCount)
{
Api.Logger.Error(
$"Floor chunk target row is exceed rows count: {targetRow} >= {atlasSize.RowsCount}");
}
if (targetColumn >= atlasSize.ColumnsCount)
{
Api.Logger.Error(
$"Floor chunk target column is exceed columns count: {targetColumn} >= {atlasSize.ColumnsCount}");
}
foreach (var layer in variant.Layers)
{
rendering.CreateSpriteRenderer(
cameraObject,
sourceTextureAtlas.Chunk(layer.Column, layer.Row),
positionOffset: (this.TileTextureSize * targetColumn, -this.TileTextureSize * targetRow),
// draw down
spritePivotPoint: (0, 1),
renderingTag: renderingTag);
}
}
await camera.DrawAsync();
cameraObject.Destroy();
request.ThrowIfCancelled();
IGeneratedTexture2D generatedTexture;
if (isAtlas)
{
generatedTexture = await renderTexture.SaveToTextureAtlas(atlasSize, isTransparent : true);
//Api.Logger.Write($"Texture atlas generated: {renderingTag} atlas size: {atlasSize}");
}
else
{
generatedTexture = await renderTexture.SaveToTexture(isTransparent : true);
}
renderTexture.Dispose();
request.ThrowIfCancelled();
return(generatedTexture);
}
// helper method to create and setup the explosion preset
public static ExplosionPreset CreatePreset(
ProtoObjectCharredGround protoObjectCharredGround,
double serverDamageApplyDelay,
string soundSetPath,
double spriteAnimationDuration,
string spriteSetPath,
byte spriteAtlasColumns,
byte spriteAtlasRows,
Size2F spriteWorldSize,
double blastwaveDelay,
double blastwaveAnimationDuration,
Color blastWaveColor,
Size2F blastwaveWorldSizeFrom,
Size2F blastwaveWorldSizeTo,
double lightDuration,
double lightWorldSize,
Color lightColor,
double screenShakesDuration,
double screenShakesWorldDistanceMin,
double screenShakesWorldDistanceMax,
Color?spriteColorAdditive = null,
Color?spriteColorMultiplicative = null,
double spriteBrightness = 1,
DrawOrder spriteDrawOrder = DrawOrder.Explosion,
byte soundsCuesNumber = 17)
{
var sounds = new SoundResourceSet()
.Add(soundSetPath)
.ToReadOnly();
using var tempFilePaths = Api.Shared.FindFilesWithTrailingNumbers(
ContentPaths.Textures + spriteSetPath);
var filePaths = tempFilePaths.AsList();
if (filePaths.Count == 0)
{
Api.Logger.Error("The explosion preset is empty - no explosion textures found at "
+ spriteSetPath);
}
var spriteAtlasResources = new TextureAtlasResource[filePaths.Count];
for (var index = 0; index < filePaths.Count; index++)
{
var filePath = filePaths[index];
spriteAtlasResources[index] = new TextureAtlasResource(filePath,
spriteAtlasColumns,
spriteAtlasRows,
isTransparent: true);
}
return(new ExplosionPreset(protoObjectCharredGround,
serverDamageApplyDelay,
spriteAtlasResources,
sounds,
spriteColorAdditive,
spriteColorMultiplicative,
spriteBrightness,
spriteAnimationDuration,
spriteWorldSize * ScriptingConstants.TileSizeRealPixels,
spriteDrawOrder,
blastwaveDelay,
blastwaveAnimationDuration,
blastWaveColor,
blastwaveWorldSizeFrom * ScriptingConstants.TileSizeRealPixels,
blastwaveWorldSizeTo * ScriptingConstants.TileSizeRealPixels,
lightWorldSize,
lightDuration,
lightColor,
(float)screenShakesDuration,
(float)screenShakesWorldDistanceMin,
(float)screenShakesWorldDistanceMax,
soundsCuesNumber));
}
