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); }