protected override ITextureResource PrepareDefaultTexture(Type thisType)
{
var texturePath = GenerateTexturePath(thisType);
this.TextureResourceObjectBroken = new TextureResource(texturePath + "Broken");
return(new TextureResource(texturePath));
}
public WeaponFireTracePreset(
string traceTexturePath,
IReadOnlyWeaponHitSparksPreset hitSparksPreset,
double traceSpeed,
ushort traceSpriteWidthPixels,
int traceStartOffsetPixels,
double traceStartScaleSpeedExponent = 1.0,
double traceEndFadeOutExponent = 1.0,
bool useScreenBlending = false,
bool?drawHitSparksAsLight = null)
{
this.TraceTexture = traceTexturePath is not null
? new TextureResource(traceTexturePath, isTransparent: true)
: null;
this.TraceSpeed = traceSpeed;
this.HitSparksPreset = hitSparksPreset;
this.TraceStartScaleSpeedExponent = traceStartScaleSpeedExponent;
this.TraceEndFadeOutExponent = traceEndFadeOutExponent;
this.TraceWorldLength = traceSpriteWidthPixels / 256.0;
this.TraceStartWorldOffset = traceStartOffsetPixels / 256.0;
this.TraceMinDistance = this.TraceWorldLength * 0.5;
this.UseScreenBlending = useScreenBlending;
this.DrawHitSparksAsLight = drawHitSparksAsLight ?? this.HasTrace;
}
public ObjectSafeArmored()
{
var texturePath = this.GenerateTexturePath();
this.textureResourceBase = new TextureResource(texturePath + "Base");
this.textureResourceSafe = new TextureResource(texturePath);
}
public static HUDNotificationControl Create(
string title,
string message,
Brush brushBackground,
Brush brushForeground,
ITextureResource icon,
Action onClick,
bool autoHide,
SoundResource soundToPlay)
{
var iconBrush = icon != null
? Api.Client.UI.GetTextureBrush(icon)
: null;
return(new HUDNotificationControl()
{
ViewModel = new ViewModelHUDNotificationControl(
title,
message,
brushBackground,
brushForeground,
iconBrush,
onClick),
IsAutoHide = autoHide,
soundToPlay = soundToPlay
});
}
public ObjectWell()
{
var texturePath = this.GenerateTexturePath();
this.textureResourceBack = new TextureResource(texturePath + "Back");
this.textureResourceFront = new TextureResource(texturePath + "Front");
}
public static HUDNotificationControl ClientShowNotification(
string title,
string message = null,
NotificationColor color = NotificationColor.Neutral,
ITextureResource icon = null,
Action onClick = null,
bool autoHide = true,
bool playSound = true)
{
Api.ValidateIsClient();
var(brushBackground, brushBorder) = GetBrush(color);
var soundToPlay = playSound
? GetSound(color)
: null;
return(HUDNotificationsPanelControl.Show(
title,
message,
brushBackground,
brushBorder,
icon,
onClick,
autoHide,
soundToPlay));
}
protected override ITextureResource ClientCreateIcon()
{
ITextureResource[] textureResources;
if (this.IsHorizontalDoorOnly ?? true)
{
textureResources = new ITextureResource[]
{
// closed door
this.TextureBaseHorizontal,
// horizontal base
this.AtlasTextureHorizontal.Chunk(0, 0)
};
}
else
{
// vertical door
textureResources = new ITextureResource[]
{
// closed door
this.AtlasTextureVertical.Chunk(0, 0),
// vertical base
this.AtlasTextureVertical.Chunk((byte)(this.AtlasTextureVertical.AtlasSize.ColumnsCount - 1), 0)
};
}
return(new ProceduralTexture(
"Composed " + this.Id,
generateTextureCallback: request => ClientComposeIcon(request, textureResources),
isTransparent: true,
isUseCache: true,
dependsOn: textureResources));
}
protected override ITextureResource ClientCreateIcon()
{
if (this.IsHorizontalDoorOnly ?? true)
{
var textureResources = new ITextureResource[]
{
// closed door
this.TextureBaseHorizontal,
// horizontal base
this.AtlasTextureHorizontal.Chunk(0, 0)
};
return(new ProceduralTexture(
"Composed " + this.Id,
generateTextureCallback: request => ClientComposeHorizontalDoor(request, textureResources),
isTransparent: true,
isUseCache: true,
dependsOn: textureResources));
}
// vertical door
var atlas = this.AtlasTextureVertical;
var columnChunk = (byte)(atlas.AtlasSize.ColumnsCount - 1);
return(ClientProceduralTextureHelper.CreateComposedTexture(
"Composed vertical door blueprint " + this.Id,
isTransparent: true,
isUseCache: true,
textureResources: new ITextureResource[]
{
atlas.Chunk(columnChunk, 0), // door base
atlas.Chunk((byte)(columnChunk - 1), 0), // door front part
atlas.Chunk(0, 0) // door back part (closed)
}));
}
public ObjectDisplayCaseLarge()
{
var texturePath = this.GenerateTexturePath();
this.textureResourceFront = new TextureResource(texturePath + "Front");
this.textureResourceBack = new TextureResource(texturePath + "Back");
}
static BaseEditorTool()
{
TextureFilterAll = new TextureResource("Editor/DefaultFilterIcon");
DefaultFiltersReadOnlyList =
new List <EditorToolItemFilter>
{
new("All", TextureFilterAll)
}.AsReadOnly();
protected override ITextureResource PrepareDefaultTexture(Type thisType)
{
var folderPath = SharedGetRelativeFolderPath(thisType, typeof(ProtoObjectProp));
var spritePath = $"StaticObjects/Props/{folderPath}/{thisType.Name}";
this.frontTexture = new TextureResource(spritePath + "Front");
return(new TextureResource(spritePath));
}
private IHudNotificationControl ShowInternal(
string title,
string message,
Brush brushBackground,
Brush brushBorder,
ITextureResource icon,
Action onClick,
bool autoHide,
SoundResource soundToPlay,
bool writeToLog)
{
if (writeToLog)
{
Api.Logger.Important(
string.Format(
"Showing notification:{0}Title: {1}{0}Message: {2}",
Environment.NewLine,
title,
message));
}
var notificationControl = HudNotificationControl.Create(
title,
message,
brushBackground,
brushBorder,
icon,
onClick,
autoHide,
soundToPlay);
var instance = this;
if (notificationControl.IsAutoHide)
{
instance.HideSimilarNotifications(notificationControl);
}
instance.stackPanelChildren.Add(notificationControl);
if (notificationControl.IsAutoHide)
{
// hide the notification control after delay
ClientTimersSystem.AddAction(
NotificationHideDelaySeconds,
() =>
{
if (notificationControl.IsAutoHide) // still configured as auto hide
{
notificationControl.Hide(quick: false);
}
});
}
instance.HideOldNotificationsIfTooManyDisplayed();
return(notificationControl);
}
public static void Create(
Vector2D sourcePosition,
Vector2D targetPosition,
double traceStartWorldOffset,
ITextureResource texture,
double beamWidth,
Vector2D originOffset,
double duration,
bool endsWithHit,
double fadeInDistance,
double fadeOutDistanceHit,
double fadeOutDistanceNoHit,
BlendMode blendMode)
{
var deltaPos = targetPosition - sourcePosition;
var length = deltaPos.Length;
var fadeInFraction = fadeInDistance / length;
var fadeOutFraction = endsWithHit
? fadeOutDistanceHit / length
: fadeOutDistanceNoHit / length;
if (fadeInFraction > 0.333 ||
fadeOutFraction > 0.333)
{
// no sense in displaying such a short beam
return;
}
var sceneObject = Client.Scene.CreateSceneObject(nameof(ComponentWeaponEnergyBeam));
var component = sceneObject.AddComponent <ComponentWeaponEnergyBeam>();
ComponentWeaponTrace.CalculateAngleAndDirection(deltaPos,
out var angleRad,
out var normalizedRay);
// offset start position of the ray
sourcePosition += normalizedRay * traceStartWorldOffset;
sceneObject.Position = sourcePosition;
component.beamOriginOffset = originOffset;
component.beamWidth = beamWidth;
component.primaryRendererDefaultPositionOffset = Vector2D.Zero;
component.spriteRendererLine.TextureResource = texture;
component.targetPosition = targetPosition;
component.duration = duration;
component.renderingMaterial
.EffectParameters
.Set("Length", (float)length)
.Set("FadeInFraction", (float)fadeInFraction)
.Set("FadeOutFraction", (float)fadeOutFraction);
component.spriteRendererLine.BlendMode = blendMode;
component.Update(0);
}
public TextureResourceWithOffset(
ITextureResource textureResource,
Vector2D? offset = null,
Vector2D? pivotPoint = null)
{
this.TextureResource = textureResource;
this.Offset = offset;
this.PivotPoint = pivotPoint;
}
public ComposeLayer(string path, sbyte spriteQualityOffset)
{
this.TextureResource = path is not null
? new TextureResource(
path.Substring(ContentPaths.Textures.Length),
isProvidesMagentaPixelPosition: true,
qualityOffset: spriteQualityOffset)
: null;
this.PivotPos = default;
}
public ViewModelFeaturesSlideshowEntry(
string title,
string description,
ITextureResource textureResource,
bool isAutoDisposeFields = true) : base(isAutoDisposeFields)
{
this.Title = title;
this.Description = description;
this.Image = Api.Client.UI.GetTextureBrush(textureResource);
}
public static bool AreEqual(ITextureResource left, ITextureResource right)
{
if (left is null && right is null)
{
return(true);
}
if (left is null || right is null)
{
return(false);
}
return(left.GetHashCode() == right.GetHashCode());
}
public static async Task <ITextureResource> CreateIconForLockedEntry(
ProceduralTextureRequest request,
ITextureResource originalIcon)
{
var size = await Rendering.GetTextureSize(originalIcon);
var originalIconSize = size;
// expand size a bit to fit the outline
var paddingFraction = 0.0;
var padding = (int)Math.Round(size.X * paddingFraction, MidpointRounding.AwayFromZero);
size = new Vector2Ushort((ushort)(size.X + padding),
(ushort)(size.Y + padding));
request.ThrowIfCancelled();
// create camera and render texture
var renderingTag = request.TextureName;
var renderTexture = Rendering.CreateRenderTexture(renderingTag,
size.X,
size.Y);
var cameraObject = Api.Client.Scene.CreateSceneObject(renderingTag);
var camera = Rendering.CreateCamera(cameraObject,
renderingTag,
drawOrder: -100);
camera.RenderTarget = renderTexture;
camera.SetOrthographicProjection(size.X, size.Y);
var spriteRenderer = Rendering.CreateSpriteRenderer(
cameraObject,
originalIcon,
// draw at the center
positionOffset: (size.X / 2, -size.Y / 2),
spritePivotPoint: (0.5, 0.5),
renderingTag: renderingTag,
scale: 1 + paddingFraction);
spriteRenderer.RenderingMaterial = GetRenderingMaterial(originalIconSize);
await camera.DrawAsync();
cameraObject.Destroy();
request.ThrowIfCancelled();
var generatedTexture = await renderTexture.SaveToTexture(isTransparent : true);
renderTexture.Dispose();
request.ThrowIfCancelled();
return(generatedTexture);
}
//public ITextureResource[] FramesTextureResources => this.framesTextureResources;
/// <summary>
/// Generate textures from atlas.
/// </summary>
/// <param name="textureAtlasResource">Texture atlas.</param>
/// <param name="columns">(optional)</param>
/// <param name="rowsCount">(optional)</param>
/// <param name="autoInverse">
/// (optional) Enable this if you want to append reverse animation. Please note - first and last
/// frame will be displayed twice.
/// </param>
/// <returns></returns>
public static ITextureResource[] CreateAnimationFrames(
ITextureAtlasResource textureAtlasResource,
byte?columns = null,
byte?rowsCount = null,
byte?onlySpecificRow = null,
bool autoInverse = false)
{
var atlasColumnsCount = columns ?? textureAtlasResource.AtlasSize.ColumnsCount;
var atlasRowsCount = rowsCount ?? textureAtlasResource.AtlasSize.RowsCount;
int chunksCount;
if (onlySpecificRow.HasValue)
{
chunksCount = atlasColumnsCount;
}
else
{
chunksCount = atlasColumnsCount * atlasRowsCount;
}
var result = new ITextureResource[chunksCount * (autoInverse ? 2 : 1)];
if (onlySpecificRow.HasValue)
{
var row = onlySpecificRow.Value;
for (byte column = 0; column < atlasColumnsCount; column++)
{
result[column] = textureAtlasResource.Chunk(column, row);
}
}
else
{
for (byte row = 0; row < atlasRowsCount; row++)
{
for (byte column = 0; column < atlasColumnsCount; column++)
{
result[row * atlasColumnsCount + column] = textureAtlasResource.Chunk(column, row);
}
}
}
if (autoInverse)
{
for (var i = 0; i < chunksCount; i++)
{
result[chunksCount + i] = result[chunksCount - i - 1];
}
}
return(result);
}
protected IComponentSpriteRenderer ClientAddRenderer(
IStaticWorldObject worldObject,
ITextureResource textureResource,
Vector2D positionOffset)
{
var renderer = Client.Rendering.CreateSpriteRenderer(worldObject,
textureResource);
this.ClientSetupRenderer(renderer);
renderer.PositionOffset += positionOffset;
renderer.DrawOrderOffsetY -= positionOffset.Y;
renderer.RenderingMaterial = RenderingMaterials.DefaultDrawEffectWithTransparentBorder;
return(renderer);
}
public static async Task <ITextureResource> CreateIcon(
ITextureResource texture,
ProceduralTextureRequest request)
{
var textureSize = await Rendering.GetTextureSize(texture);
request.ThrowIfCancelled();
if (!ClampTextureSize(ref textureSize, out var scale) &&
texture is TextureResource)
{
// can use original texture as icon for itself
return(texture);
}
// create camera and render texture
var renderingTag = request.TextureName;
var renderTexture = Rendering.CreateRenderTexture(renderingTag,
textureSize.X,
textureSize.Y);
var cameraObject = Api.Client.Scene.CreateSceneObject(renderingTag);
var camera = Rendering.CreateCamera(cameraObject,
renderingTag,
drawOrder: -100);
camera.RenderTarget = renderTexture;
camera.SetOrthographicProjection(textureSize.X, textureSize.Y);
// create and prepare renderer for icon (attach it to camera object)
Rendering.CreateSpriteRenderer(
cameraObject,
texture,
positionOffset: (0, 0),
// draw down
spritePivotPoint: (0, 1),
renderingTag: renderingTag,
scale: scale);
await camera.DrawAsync();
cameraObject.Destroy();
request.ThrowIfCancelled();
var generatedTexture = await renderTexture.SaveToTexture(isTransparent : true);
renderTexture.Dispose();
request.ThrowIfCancelled();
return(generatedTexture);
}
public ProtoTileGroundTexture(
TextureResource texture,
ITextureResource blendMaskTexture,
INoiseSelector noiseSelector)
{
this.Texture = texture;
this.BlendMaskTexture = new TextureAtlasResource(
blendMaskTexture,
columns: 4,
rows: 1);
this.NoiseSelector = noiseSelector;
}
protected override void PrepareQuest(QuestsList prerequisites, TasksList tasks, HintsList hints)
{
ITextureResource icon = null;
if (IsClient)
{
icon = Api.GetProtoEntity <ObjectSandTyrantRemains>().Icon;
}
tasks
.Add(TaskDestroy.Require <ObjectSandTyrantRemains>(count: 1).WithIcon(icon));
prerequisites
.Add <QuestDesertPrincessRemains>();
}
public static IComponentSpriteRenderer CreateOcclusionRenderer(
IWorldObject worldObject,
ITextureResource textureResource,
Vector2D?positionOffset = null,
bool extractMaskFromColor = false)
{
var result = Rendering.CreateSpriteRenderer(
worldObject,
textureResource,
drawOrder: DrawOrder.Occlusion,
positionOffset: positionOffset,
renderingTag: RenderingTag);
SetupComponent(result, extractMaskFromColor);
return(result);
}
private static async Task <ITextureResource> GenerateIcon(
ProceduralTextureRequest request,
ITextureResource originalIcon)
{
Vector2Ushort size = (128, 128);
// expand size a bit to fit the outline
request.ThrowIfCancelled();
// create camera and render texture
var renderingTag = request.TextureName;
var renderTexture = Rendering.CreateRenderTexture(renderingTag,
size.X,
size.Y);
var cameraObject = Api.Client.Scene.CreateSceneObject(renderingTag);
var camera = Rendering.CreateCamera(cameraObject,
renderingTag,
drawOrder: -100);
camera.RenderTarget = renderTexture;
camera.SetOrthographicProjection(size.X, size.Y);
var spriteRenderer = Rendering.CreateSpriteRenderer(
cameraObject,
originalIcon,
// draw at the center
positionOffset: (size.X / 2, -size.Y / 2),
spritePivotPoint: (0.5, 0.5),
renderingTag: renderingTag,
// as most icons are 256x256 and we need a 128x128 icon scale it this way
scale: 0.5);
spriteRenderer.RenderingMaterial = RenderingMaterialCrateIcon;
await camera.DrawAsync();
cameraObject.Destroy();
request.ThrowIfCancelled();
var generatedTexture = await renderTexture.SaveToTexture(isTransparent : true);
renderTexture.Dispose();
request.ThrowIfCancelled();
return(generatedTexture);
}
protected override void PrepareQuest(QuestsList prerequisites, TasksList tasks, HintsList hints)
{
ITextureResource icon = null;
if (IsClient)
{
icon = Api.GetProtoEntity <ObjectPragmiumKingRemains>().Icon;
}
tasks
.Add(TaskDestroy.Require <ObjectPragmiumKingRemains>(count: 1).WithIcon(icon));
prerequisites
.Add <QuestPragmiumQueenRemains>()
.Add <QuestSandTyrantRemains>()
.Add <QuestCookMoreFoodStage4>()
.Add <QuestMineMoreMineralsStage4>();
}
protected override void PrepareQuest(QuestsList prerequisites, TasksList tasks, HintsList hints)
{
ITextureResource iconGrass = null,
iconTwigs = null,
iconStone = null;
if (IsClient)
{
iconGrass = Api.GetProtoEntity <ObjectLootGrass>().Icon;
iconTwigs = Api.GetProtoEntity <ObjectLootTwigs>().Icon;
iconStone = Api.GetProtoEntity <ObjectLootStone>().Icon;
}
tasks
.Add(TaskHaveItem.Require <ItemFibers>(count: 10).WithIcon(iconGrass))
.Add(TaskHaveItem.Require <ItemTwigs>(count: 10).WithIcon(iconTwigs))
.Add(TaskHaveItem.Require <ItemStone>(count: 10).WithIcon(iconStone));
}
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);
}
private HUDNotificationControl ShowInternal(
string title,
string message,
Brush brushBackground,
Brush brushBorder,
ITextureResource icon,
Action onClick,
bool autoHide,
SoundResource soundToPlay)
{
Api.Logger.Important(
string.Format(
"Showing notification:{0}Title: {1}{0}Message: {2}",
Environment.NewLine,
title,
message));
var notificationControl = HUDNotificationControl.Create(
title,
message,
brushBackground,
brushBorder,
icon,
onClick,
autoHide,
soundToPlay);
this.HideSimilarNotifications(notificationControl);
this.stackPanelChildren.Add(notificationControl);
if (notificationControl.IsAutoHide)
{
// hide the notification control after delay
ClientComponentTimersManager.AddAction(
NotificationHideDelaySeconds,
() => notificationControl.Hide(quick: false));
}
this.HideOldNotificationsIfTooManyDisplayed();
return(notificationControl);
}
public static HUDNotificationControl Show(
string title,
string message,
Brush brushBackground,
Brush brushBorder,
ITextureResource icon,
Action onClick,
bool autoHide,
SoundResource soundToPlay)
{
return(instance.ShowInternal(title,
message,
brushBackground,
brushBorder,
icon,
onClick,
autoHide,
soundToPlay));
}
