static ClientCrateIconHelper()
{
RenderingMaterialCrateIcon = RenderingMaterial.Create(
new EffectResource("Special/CrateIcon"));
RenderingMaterialCrateIcon.EffectParameters
.Set("MaskTexture", new TextureResource("FX/Special/CrateIconMask"));
}
public static void Setup(
IComponentSpriteRenderer renderer,
float power,
float pivotY,
bool canFlip = true)
{
var worldObject = renderer.SceneObject.AttachedWorldObject;
if (worldObject == null)
{
// blueprint - use default rendering
return;
}
var isRenderingFlipped = canFlip &&
PositionalRandom.Get(worldObject.TilePosition, 0, 3, seed: 9125835) == 0;
var phaseOffset = (byte)PositionalRandom.Get(worldObject.TilePosition, 0, 8, seed: 614392664);
var preset = new GrassAnimationPreset(power, pivotY, phaseOffset, isRenderingFlipped);
if (!Materials.TryGetValue(preset, out var material))
{
// no cached material found for the required preset - create and setup new material
Materials[preset] = material = RenderingMaterial.Create(EffectResource);
material.EffectParameters
.Set("Flip", isRenderingFlipped ? 1 : 0)
.Set("Power", power)
.Set("PivotY", pivotY)
.Set("PhaseOffset", phaseOffset);
}
renderer.RenderingMaterial = material;
}
public ClientBlueprintTilesRenderer(IClientSceneObject sceneObjectRoot)
{
this.sceneObjectRoot = sceneObjectRoot;
if (renderingMaterial is null)
{
renderingMaterial = RenderingMaterial.Create(new EffectResource("SolidColor"));
renderingMaterial.EffectParameters.Set(EffectParameters);
}
this.Reset();
}
public ClientBlueprintRenderer(IClientSceneObject sceneObjectRoot)
{
this.sceneObjectRoot = sceneObjectRoot;
this.SpriteRenderer = Api.Client.Rendering.CreateSpriteRenderer(
sceneObjectRoot,
TextureResource.NoTexture);
this.SpriteRenderer.RenderingMaterial =
RenderingMaterial.Create(new EffectResource("ConstructionPlacement"));
this.Reset();
}
public void Setup(
ApplyToolDelegate selectedCallback,
Func <List <Vector2Ushort>, bool> validateCallback,
bool isRepeatOnMove,
Action inputReleasedCallback = null)
{
this.selectedCallback = selectedCallback;
this.inputReleasedCallback = inputReleasedCallback;
this.validateCallback = validateCallback;
this.isRepeatOnMove = isRepeatOnMove;
this.material = RenderingMaterial.Create(new EffectResource("ConstructionBlueprint"));
this.material.EffectParameters.Set(EffectParametersDefault);
}
public EditorToolZoneRenderer(ClientZoneProvider zoneProvider)
{
this.material = RenderingMaterial.Create(new EffectResource("SolidColor"));
this.sceneObject = Api.Client.Scene.CreateSceneObject(
"EditorToolZones / Zone renderer - " + zoneProvider.ProtoZone.ShortId);
this.ZoneProvider = zoneProvider;
this.ZoneProvider.ZoneModified += this.ZoneModifiedHandler;
this.ZoneProvider.ZoneReset += this.ZoneResetHandler;
ClientComponentUpdateHelper.UpdateCallback += this.Update;
this.RebuildAllRenderers();
}
private static RenderingMaterial GetRenderingMaterial(Vector2Ushort size)
{
var outlineSize = (float)(0.02 * 256.0 / size.X);
if (RenderingMaterialLockedEntryByOutlineSize.TryGetValue(outlineSize, out var result))
{
return(result);
}
result = RenderingMaterial.Create(
new EffectResource("Special/CompletionistLockedEntryIcon"));
result.EffectParameters.Set("OutlineSize", outlineSize);
RenderingMaterialLockedEntryByOutlineSize[outlineSize] = result;
return(result);
}
public EditorToolZoneRenderer(ClientZoneProvider zoneProvider)
{
this.material = RenderingMaterial.Create(new EffectResource("LandClaimArea"));
this.material.EffectParameters.Set("SpriteTexture",
new TextureResource("FX/EditorZoneTile"));
this.sceneObject = Api.Client.Scene.CreateSceneObject(
"EditorToolZones / Zone renderer - " + zoneProvider.ProtoZone.ShortId);
this.ZoneProvider = zoneProvider;
this.ZoneProvider.ZoneModified += this.ZoneModifiedHandler;
this.ZoneProvider.ZoneReset += this.ZoneResetHandler;
ClientUpdateHelper.UpdateCallback += this.Update;
this.RebuildAllRenderers();
}
//public override async void ClientInitialize()
//{
// await CreateTestTexturePreviewer();
//}
private static async Task CreateTestTexturePreviewer()
{
var sourceTextureResource = new TextureResource("FX/SkinToneMaps/ImageToModify.png");
var lutTextureResource = new TextureResource3D("FX/SkinToneMaps/Lut1.png", depth: 24, isTransparent: false);
var lutTexture3D = await Client.Rendering.LoadTexture3D(lutTextureResource);
var textureSize = await Client.Rendering.GetTextureSize(sourceTextureResource);
var textureWidth = textureSize.X;
var textureHeight = textureSize.Y;
var renderingTag = nameof(BootstrapperSkinToneRemapping);
var renderingMaterial = RenderingMaterial.Create(new EffectResource("ColorLutRemap"));
renderingMaterial.EffectParameters.Set("TextureLut", lutTexture3D);
var sceneObjectCamera = Client.Scene.CreateSceneObject("Skin tone remapping camera");
var camera = Client.Rendering.CreateCamera(sceneObjectCamera,
renderingTag: renderingTag,
drawOrder: -10,
drawMode: CameraDrawMode.Auto);
var renderTarget = Client.Rendering.CreateRenderTexture(renderingTag, textureWidth, textureHeight);
camera.RenderTarget = renderTarget;
camera.ClearColor = Color.FromArgb(0, 0, 0, 0);
camera.SetOrthographicProjection(textureWidth, textureHeight);
Client.Rendering.CreateSpriteRenderer(sceneObjectCamera,
sourceTextureResource,
renderingTag: renderingTag,
// draw down
spritePivotPoint: (0, 1))
.RenderingMaterial = renderingMaterial;
var rectangle = new Rectangle
{
Width = textureWidth,
Height = textureHeight,
Fill = Api.Client.UI.CreateImageBrushForRenderTarget(camera.RenderTarget),
Stretch = Stretch.Uniform,
UseLayoutRounding = true
};
Panel.SetZIndex(rectangle, int.MaxValue);
Api.Client.UI.LayoutRootChildren.Add(rectangle);
}
static ObjectDecorationBannerFaction()
{
if (IsServer)
{
return;
}
RenderingMaterialEmblem = RenderingMaterial.Create(
new EffectResource("DrawWithMask"));
var maskTextureResource = new TextureResource(
GenerateTexturePath(typeof(ObjectDecorationBannerFaction)) + "_Mask",
qualityOffset: ClientFactionEmblemTextureProvider.SpriteQualityOffset);
RenderingMaterialEmblem.EffectParameters
.Set("MaskTextureArray", maskTextureResource);
}
public ClientBlueprintRenderer(
IClientSceneObject sceneObjectRoot,
bool isConstructionSite,
Vector2D centerOffset)
{
this.sceneObjectRoot = sceneObjectRoot;
this.IsConstructionSite = isConstructionSite;
this.textBlockCannotBuildReasonOffset = centerOffset + (0, TextBlockCannotBuildReasonOffsetY);
this.SpriteRenderer = Api.Client.Rendering.CreateSpriteRenderer(
sceneObjectRoot,
TextureResource.NoTexture);
this.SpriteRenderer.RenderingMaterial =
RenderingMaterial.Create(new EffectResource("ConstructionPlacement"));
this.Reset();
}
public static async Task <IRenderTarget2D> ApplyColorizerLut(
ProceduralTextureRequest request,
ITextureResource sourceTextureResource,
string lutTextureFilePath)
{
var lutTextureResource = new TextureResource3D(lutTextureFilePath, depth: 24, isTransparent: false);
var lutTexture3D = await Renderer.LoadTexture3D(lutTextureResource);
var textureSize = await Renderer.GetTextureSize(sourceTextureResource);
var textureWidth = textureSize.X;
var textureHeight = textureSize.Y;
var renderingMaterial = RenderingMaterial.Create(new EffectResource("ColorLutRemap"));
renderingMaterial.EffectParameters.Set("TextureLut", lutTexture3D);
var renderingTag = "Colorizer camera for procedural texture: " + request.TextureName;
var cameraObject = Api.Client.Scene.CreateSceneObject(renderingTag);
var camera = Renderer.CreateCamera(cameraObject,
renderingTag: renderingTag,
drawOrder: -10,
drawMode: CameraDrawMode.Manual);
var renderTarget = Renderer.CreateRenderTexture(renderingTag, textureWidth, textureHeight);
camera.RenderTarget = renderTarget;
camera.ClearColor = Color.FromArgb(0, 0, 0, 0);
camera.SetOrthographicProjection(textureWidth, textureHeight);
Renderer.CreateSpriteRenderer(cameraObject,
sourceTextureResource,
renderingTag: renderingTag,
// draw down
spritePivotPoint: (0, 1))
.RenderingMaterial = renderingMaterial;
await camera.DrawAsync();
cameraObject.Destroy();
request.ThrowIfCancelled();
return(renderTarget);
}
public void Setup(
IComponentSpriteRenderer spriteRenderer,
double amplitude,
double speed,
double verticalStartOffsetRelative)
{
this.spriteRenderer = spriteRenderer;
this.originalPositionOffset = spriteRenderer.PositionOffset;
this.originalMaterial = spriteRenderer.RenderingMaterial;
Client.Rendering.PreloadEffectAsync(EffectResource);
this.material = RenderingMaterial.Create(EffectResource);
this.material.EffectParameters
.Set("Amplitude", (float)amplitude)
.Set("Speed", (float)speed)
.Set("VerticalStartOffsetRelative", (float)verticalStartOffsetRelative);
this.RefreshMaterial();
}
protected override void PrepareProtoTile(Settings settings)
{
if (IsServer)
{
return;
}
// Please note: this is a texture used for the ground UNDER the water.
// The water sprite itself is assigned at ClientTileWaterHelper class.
settings.GroundTextures.Add(
new ProtoTileGroundTexture(
texture: this.UnderwaterGroundTextureAtlas,
blendMaskTexture: BlendMaskTextureSpraySmooth,
noiseSelector: null));
this.waterPrimaryMaterial = RenderingMaterial.Create(WaterEffectResource);
this.SetupMaterial(this.waterPrimaryMaterial);
this.allMaterials.Add(this.waterPrimaryMaterial);
}
public RenderingMaterial ClientGetWaterBlendMaterial(ClientTileBlendHelper.BlendLayer blendLayer)
{
var cacheKey = blendLayer.BlendSides;
if (this.cachedBlendMaskMaterials.TryGetValue(cacheKey, out var material))
{
return(material);
}
var masks = new List <TileMaskSet>();
ClientTileBlendHelper.CalculateMasks(blendLayer.BlendSides, masks);
masks = ClientTileBlendHelper.DetectMasksInnerCorners(masks);
Api.Assert(masks.Count > 0, "No masks?!");
var effect = EffectForMaskCounts[masks.Count - 1];
material = RenderingMaterial.Create(effect);
this.SetupMaterial(material);
var effectParameters = material.EffectParameters;
effectParameters.Set("MaskTextureArray", BlendMaskTextureAtlas);
for (var i = 0; i < masks.Count; i++)
{
var mask = masks[i];
var flip = (mask.IsFlipHorizontally ? 1f : 0,
mask.IsFlipVertically ? 1f : 0);
effectParameters.Set("Mask" + (i + 1) + "ArraySlice", mask.TextureMaskArraySlice)
.Set("Mask" + (i + 1) + "Flip", flip);
}
material.EffectResource = effect;
this.cachedBlendMaskMaterials[cacheKey] = material;
this.allMaterials.Add(material);
return(material);
}
public void Setup(
IComponentSpriteRenderer spriteRenderer,
ITextureResource[] framesTextureResources,
double frameDurationSeconds)
{
if (framesTextureResources is null ||
framesTextureResources.Length == 0)
{
throw new Exception("Incorrect sprite sheet");
}
this.spriteRenderer = spriteRenderer;
this.renderingMaterial = RenderingMaterial.Create(EffectResourceDrawBlendAnimation);
spriteRenderer.RenderingMaterial = this.renderingMaterial;
this.framesTextureResources = framesTextureResources;
this.frameDurationSeconds = frameDurationSeconds;
this.totalDurationSeconds = frameDurationSeconds * framesTextureResources.Length;
this.Reset();
this.Update(0f);
}
public static void ClientExplode(
Vector2D position,
ExplosionPreset explosionPreset,
float volume = 1.0f)
{
// add screen shakes
ClientComponentCameraScreenShakes.AddRandomShakes(
duration: explosionPreset.ScreenShakesDuration,
worldDistanceMin: explosionPreset.ScreenShakesWorldDistanceMin,
worldDistanceMax: explosionPreset.ScreenShakesWorldDistanceMax);
// play sound
var explosionSoundEmitter = Client.Audio.PlayOneShot(explosionPreset.SoundSet.GetSound(),
worldPosition: position,
volume: volume,
pitch: RandomHelper.Range(0.95f, 1.05f));
// extend explosion sound distance
explosionSoundEmitter.CustomMinDistance = (float)explosionPreset.LightWorldSize / 3;
explosionSoundEmitter.CustomMaxDistance = (float)explosionPreset.LightWorldSize;
// create explosion renderer
var explosionSpriteAnimationDuration = explosionPreset.SpriteAnimationDuration;
var explosionSceneObject = Client.Scene.CreateSceneObject("Temp explosion",
position);
explosionSceneObject.Destroy(delay: explosionSpriteAnimationDuration);
var explosionSpriteRenderer = Client.Rendering.CreateSpriteRenderer(
explosionSceneObject,
TextureResource.NoTexture,
drawOrder: DrawOrder.Explosion,
spritePivotPoint: (0.5, 0.5));
explosionSpriteRenderer.Color = explosionPreset.SpriteColorMultiplicative;
explosionSpriteRenderer.Size = explosionPreset.SpriteSize;
if (explosionPreset.SpriteColorAdditive.HasValue
// ReSharper disable once CompareOfFloatsByEqualityOperator
|| explosionPreset.SpriteBrightness != 1)
{
var renderingMaterial = RenderingMaterial.Create(EffectResourceAdditiveColorEffect);
renderingMaterial.EffectParameters
.Set("ColorAdditive", explosionPreset.SpriteColorAdditive ?? Colors.Black)
.Set("Brightness", explosionPreset.SpriteBrightness);
explosionSpriteRenderer.RenderingMaterial = renderingMaterial;
}
var isFlipped = 0
== PositionalRandom.Get(position.ToVector2Ushort(),
minInclusive: 0,
maxExclusive: 2,
seed: 893243289);
if (isFlipped)
{
explosionSpriteRenderer.DrawMode = DrawMode.FlipHorizontally;
}
ClientComponentOneShotSpriteSheetAnimationHelper.Setup(
explosionSpriteRenderer,
explosionPreset.SpriteAtlasResources.TakeByRandom(),
explosionSpriteAnimationDuration);
// add light source for the explosion
var explosionLight = ClientLighting.CreateLightSourceSpot(
explosionSceneObject,
explosionPreset.LightColor,
size: explosionPreset.LightWorldSize,
positionOffset: (0, 0),
spritePivotPoint: (0.5, 0.5));
ClientComponentOneShotLightAnimation.Setup(
explosionLight,
explosionPreset.LightDuration);
// add blast wave
var blastAnimationDuration = explosionPreset.BlastwaveAnimationDuration;
if (blastAnimationDuration > 0)
{
ClientTimersSystem.AddAction(
explosionPreset.BlastwaveDelay,
() =>
{
var blastSceneObject = Client.Scene.CreateSceneObject("Temp explosion",
position);
blastSceneObject.Destroy(delay: blastAnimationDuration);
var blastSpriteRenderer = Client.Rendering.CreateSpriteRenderer(
blastSceneObject,
new TextureResource("FX/ExplosionBlast"),
drawOrder: DrawOrder.Explosion - 1,
spritePivotPoint: (0.5, 0.5));
// animate blast wave
ClientComponentGenericAnimationHelper.Setup(
blastSceneObject,
blastAnimationDuration,
updateCallback: alpha =>
{
var blastwaveAlpha = (byte)(byte.MaxValue * (1 - alpha));
blastSpriteRenderer.Color = explosionPreset.BlastWaveColor
.WithAlpha(blastwaveAlpha);
var sizeX = MathHelper.Lerp(explosionPreset.BlastwaveSizeFrom.X,
explosionPreset.BlastwaveSizeTo.X,
alpha);
var sizeY = MathHelper.Lerp(explosionPreset.BlastwaveSizeFrom.Y,
explosionPreset.BlastwaveSizeTo.Y,
alpha);
blastSpriteRenderer.Size = new Size2F(sizeX, sizeY);
});
});
}
ClientGroundExplosionAnimationHelper.OnExplode(
delaySeconds: explosionSpriteAnimationDuration / 2,
position: position);
}
public static async Task <IRenderTarget2D> ApplyMaskToRenderTargetAsync(
ProceduralTextureRequest request,
IRenderTarget2D sourceRenderTarget,
TextureResource maskResource)
{
var textureWidth = (ushort)sourceRenderTarget.Width;
var textureHeight = (ushort)sourceRenderTarget.Height;
var maskSizeAbsolute = await Renderer.GetTextureSize(maskResource);
var maskScale = new Vector2F((float)(textureWidth / (double)maskSizeAbsolute.X),
(float)(textureHeight / (double)maskSizeAbsolute.Y));
var maskOffset = new Vector2F((float)((maskSizeAbsolute.X - textureWidth) / (2.0 * textureWidth)),
(float)((maskSizeAbsolute.Y - textureHeight) / (2.0 * textureHeight)));
/*Api.Logger.Dev(
* string.Format("Texture size: X={0} Y={1}"
+ "{2}Mask size: X={3} Y={4}"
+ "{2}Mask scale: X={5:F2} Y={6:F2}"
+ "{2}Mask offset: X={7:F2} Y={8:F2}",
+ textureWidth,
+ textureHeight,
+ Environment.NewLine,
+ maskSizeAbsolute.X,
+ maskSizeAbsolute.Y,
+ maskScale.X,
+ maskScale.Y,
+ maskOffset.X,
+ maskOffset.Y));*/
var renderingMaterial = RenderingMaterial.Create(new EffectResource("DrawWithMaskOffset"));
renderingMaterial.EffectParameters
.Set("MaskTextureArray", maskResource)
.Set("MaskScale", maskScale)
.Set("MaskOffset", maskOffset);
var renderingTag = "Mask camera for procedural texture: " + request.TextureName;
var cameraObject = Api.Client.Scene.CreateSceneObject(renderingTag);
var camera = Renderer.CreateCamera(cameraObject,
renderingTag: renderingTag,
drawOrder: -10,
drawMode: CameraDrawMode.Manual);
var renderTarget = Renderer.CreateRenderTexture(renderingTag, textureWidth, textureHeight);
camera.RenderTarget = renderTarget;
camera.ClearColor = Color.FromArgb(0, 0, 0, 0);
camera.SetOrthographicProjection(textureWidth, textureHeight);
Renderer.CreateSpriteRenderer(cameraObject,
sourceRenderTarget,
renderingTag: renderingTag,
// draw down
spritePivotPoint: (0, 1))
.RenderingMaterial = renderingMaterial;
await camera.DrawAsync();
cameraObject.Destroy();
request.ThrowIfCancelled();
return(renderTarget);
}