protected override void LoadContent()
{
Block.Initialize();
PhysicsMaterial.Initialize();
RenderingMaterial.Initialize();
RenderQueue.Initialize();
}
static ClientCrateIconHelper()
{
RenderingMaterialCrateIcon = RenderingMaterial.Create(
new EffectResource("Special/CrateIcon"));
RenderingMaterialCrateIcon.EffectParameters
.Set("MaskTexture", new TextureResource("FX/Special/CrateIconMask"));
}
private void AddFace(RenderingMaterial mat,
Vector3 pos1, Vector3 pos2, Vector3 pos3, Vector3 pos4,
Color color1, Color color2, Color color3, Color color4,
Vector3 normal)
{
Vector2 tex1, tex2, tex3, tex4;
mat.GetTexCoords(out tex1, out tex2, out tex3, out tex4);
var a = (byte)(255 * (1 - mat.Translucency));
color1.A = a;
color2.A = a;
color3.A = a;
color4.A = a;
var collector = _collectorManager.Get(mat.RenderQueue);
var scale = Tile.VoxelSize;
collector.AddQuad(
new VertexFormats.PosColorTexNormal(pos1 * scale, normal, color1, tex1),
new VertexFormats.PosColorTexNormal(pos2 * scale, normal, color2, tex2),
new VertexFormats.PosColorTexNormal(pos3 * scale, normal, color3, tex3),
new VertexFormats.PosColorTexNormal(pos4 * scale, normal, color4, tex4));
}
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;
}
static ProtoObjectLandClaim()
{
if (IsClient)
{
// prepare material and effect parameters
ClientBlueprintAreaRenderingMaterial = ClientLandClaimAreaRenderer.CreateRenderingMaterial();
}
}
public ClientLandClaimGroupRenderer(
RenderingMaterial material,
bool isGraceAreaRenderer,
Func <IComponentSpriteRenderer> callbackGetRendererFromCache,
Action <IComponentSpriteRenderer> callbackReturnRendererToCache)
{
this.material = material;
this.isGraceAreaRenderer = isGraceAreaRenderer;
this.callbackGetRendererFromCache = callbackGetRendererFromCache;
this.callbackReturnRendererToCache = callbackReturnRendererToCache;
}
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 ClientLandClaimAreaRenderer(
Color zoneColor,
DrawOrder drawOrder,
int inflateSize = 0)
{
this.drawOrder = drawOrder;
this.inflateSize = inflateSize;
this.material = CreateRenderingMaterial();
this.material.EffectParameters.Set("Color", zoneColor);
this.sceneObject = Api.Client.Scene.CreateSceneObject(
nameof(ClientLandClaimAreaRenderer) + " with color=" + zoneColor);
}
static ProtoObjectLandClaim()
{
if (IsClient)
{
// prepare material and effect parameters
ClientBlueprintAreaRenderingMaterial = ClientLandClaimGroupRenderer.CreateRenderingMaterial();
ClientBlueprintGraceAreaRenderingMaterial = ClientLandClaimGroupRenderer.CreateRenderingMaterial();
ClientBlueprintGraceAreaRenderingMaterial.EffectParameters.Set("Color", BlueprintAreaColorGrace);
ClientBlueprintRestrictedTileRenderingMaterial = ClientLandClaimGroupRenderer.CreateRenderingMaterial();
ClientBlueprintRestrictedTileRenderingMaterial.EffectParameters.Set("Color", BlueprintAreaColorRed);
}
}
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);
}
private void SetupMaterial(RenderingMaterial renderingMaterial)
{
renderingMaterial.EffectParameters
.Set("WaterTexture", this.WaterSufraceTexture)
.Set("WaterOpacity", this.WaterColor.A / (float)byte.MaxValue)
.Set("WaterColor",
// ReSharper disable once RedundantNameQualifier
new Vector3(
this.WaterColor.R / (float)byte.MaxValue,
this.WaterColor.G / (float)byte.MaxValue,
this.WaterColor.B / (float)byte.MaxValue))
.Set("ShoreMaskSpeed", this.ShoreMaskSpeed);
//.Set("WaterAmplitude", this.WaterAmplitude);
}
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);
}
static ProtoObjectLandClaimPlacementDisplayHelper()
{
if (Api.IsServer)
{
return;
}
// prepare material and effect parameters
ClientBlueprintRestrictedTileRenderingMaterial = ClientLandClaimGroupRenderer.CreateRenderingMaterial();
ClientBlueprintRestrictedTileRenderingMaterial.EffectParameters
.Set("SpriteTexture", new TextureResource("FX/WhiteCell"))
.Set("Color",
// red color
LandClaimZoneColors.ZoneColorNotOwnedByPlayer)
.Set("IsFlipped", true);
}
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();
}
public ClientLandClaimGroupsRendererManager(
Color zoneColor,
DrawOrder drawOrder,
bool isGraceAreaRenderer = false)
{
this.drawOrder = drawOrder;
this.isGraceAreaRenderer = isGraceAreaRenderer;
this.material = ClientLandClaimGroupRenderer.CreateRenderingMaterial();
this.material.EffectParameters.Set("Color", zoneColor);
this.sceneObject = Api.Client.Scene.CreateSceneObject(nameof(ClientLandClaimGroupsRendererManager)
+ " "
+ zoneColor);
this.callbackGetRendererFromCache = this.GetRendererFromCache;
this.callbackReturnRendererToCache = this.ReturnRendererToCache;
this.UpdateByTimer();
}
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);
}
void InitRenderer()
{
draftModeActive = !applicationIsPlaying && editorRenderDetail == EditorRenderDetail.Draft;
// Init materials
matDynamicOpaque = Instantiate <Material> (Resources.Load <Material> ("VoxelPlay/Materials/VP Voxel Dynamic Opaque"));
matDynamicCutout = Instantiate <Material> (Resources.Load <Material> ("VoxelPlay/Materials/VP Voxel Dynamic Cutout"));
Material matTerrainOpaque = Instantiate <Material> (RenderType.Opaque.GetDefaultMaterial(this));
Material matTerrainCutout = Instantiate <Material> (RenderType.Cutout.GetDefaultMaterial(this));
Material matTerrainOpNoAO = Instantiate <Material> (RenderType.OpaqueNoAO.GetDefaultMaterial(this));
Material matTerrainCloud = Instantiate <Material> (RenderType.Cloud.GetDefaultMaterial(this));
Material matTerrainWater = Instantiate <Material> (RenderType.Water.GetDefaultMaterial(this));
Material matTerrainCutxss = Instantiate <Material> (RenderType.CutoutCross.GetDefaultMaterial(this));
Material matTerrainTransp = Instantiate <Material> (RenderType.Transp6tex.GetDefaultMaterial(this));
Material matTerrainOpAnim = Instantiate <Material> (RenderType.OpaqueAnimated.GetDefaultMaterial(this));
// Init system arrays and structures
if (materialsDict == null)
{
materialsDict = new Dictionary <int, Material []> ();
}
else
{
materialsDict.Clear();
}
// Assign materials to rendering buffers
renderingMaterials = new RenderingMaterial [MAX_MATERIALS_PER_CHUNK];
renderingMaterials [INDICES_BUFFER_OPAQUE] = new RenderingMaterial {
material = matTerrainOpaque, usesTextureArray = true
};
renderingMaterials [INDICES_BUFFER_CUTOUT] = new RenderingMaterial {
material = matTerrainCutout, usesTextureArray = true
};
renderingMaterials [INDICES_BUFFER_CUTXSS] = new RenderingMaterial {
material = matTerrainCutxss, usesTextureArray = true
};
renderingMaterials [INDICES_BUFFER_WATER] = new RenderingMaterial {
material = matTerrainWater, usesTextureArray = true
};
renderingMaterials [INDICES_BUFFER_TRANSP] = new RenderingMaterial {
material = matTerrainTransp, usesTextureArray = true
};
renderingMaterials [INDICES_BUFFER_OPANIM] = new RenderingMaterial {
material = matTerrainOpAnim, usesTextureArray = true
};
renderingMaterials [INDICES_BUFFER_OPNOAO] = new RenderingMaterial {
material = matTerrainOpNoAO, usesTextureArray = true
};
renderingMaterials [INDICES_BUFFER_CLOUD] = new RenderingMaterial {
material = matTerrainCloud, usesTextureArray = true
};
if (materialIndices == null)
{
materialIndices = new Dictionary <Material, int> ();
}
else
{
materialIndices.Clear();
}
materialIndices [matTerrainOpaque] = INDICES_BUFFER_OPAQUE;
materialIndices [matTerrainCutout] = INDICES_BUFFER_CUTOUT;
materialIndices [matTerrainCutxss] = INDICES_BUFFER_CUTXSS;
materialIndices [matTerrainWater] = INDICES_BUFFER_WATER;
materialIndices [matTerrainTransp] = INDICES_BUFFER_TRANSP;
materialIndices [matTerrainOpAnim] = INDICES_BUFFER_OPANIM;
materialIndices [matTerrainOpNoAO] = INDICES_BUFFER_OPNOAO;
materialIndices [matTerrainCloud] = INDICES_BUFFER_CLOUD;
// Triangle opaque and cutout are always loaded because dynamic voxels requires them
lastBufferIndex = 7;
modelMeshColors = new List <Color32> (128);
Voxel.Empty.light = noLightValue;
InitTempVertices();
InitSeeThrough();
InitMeshingThreads();
if (delayedVoxelCustomRotations == null)
{
delayedVoxelCustomRotations = new Dictionary <Vector3, Vector3> ();
}
else
{
delayedVoxelCustomRotations.Clear();
}
if (useComputeBuffers)
{
instancedRenderer = new GPUInstancingIndirectRenderer(this);
}
else
{
instancedRenderer = new GPUInstancingRenderer(this);
}
VoxelPlayLightManager lightManager = currentCamera.GetComponent <VoxelPlayLightManager> ();
if (lightManager == null)
{
currentCamera.gameObject.AddComponent <VoxelPlayLightManager> ();
}
else
{
lightManager.enabled = true;
}
if (realisticWater)
{
currentCamera.depthTextureMode |= DepthTextureMode.Depth;
currentCamera.forceIntoRenderTexture = true;
}
//TODO: Creating Meshes
StartGenerationThreads();
}
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);
}
