core/player/PlayerIsoCamera.cs

The isometric view for a player. Creates an orthographic render camera plus a second camera that blits the final image, renders background, background depth, entity shadows, entity lighting and world text into render targets, and runs the composite, snow and waypoint compute shaders each frame. Also handles zoom, camera dragging, the mouse cursor and mapping between screen pixels and world positions.

ReflectionReflection
using Sandbox.Rendering;

public class PlayerIsoCamera : Component {
	[Property, ReadOnly] public BasePlayer Owner {get; set;}

	[Property, ReadOnly] public Vector2Int RenderSize {get; set;} = new(640,480);
	[Property, ReadOnly] public CameraComponent RenderCamera {get; set;}
	[Property, ReadOnly] public CameraComponent DrawCamera {get; set;}
	[Property, ReadOnly] public LightingRigs Lighting {get; set;}
	[Property, ReadOnly] public Vector2 DitherOffset {get; set;}
	[Property, ReadOnly] public Texture Background {get; set;}
	[Property, ReadOnly] public Texture BackgroundDepth {get; set;}
	[Property, ReadOnly] public Texture EntityShadow {get; set;}
	[Property, ReadOnly] public Texture EntityShadowDepth {get; set;}
	[Property, ReadOnly] public Texture EntityLighting {get; set;}
	[Property, ReadOnly] public Texture WorldText {get; set;}
	[Property, ReadOnly] public Texture Mask {get; set;}
	[Property, ReadOnly] public Texture Composite {get; set;}
	[Property, ReadOnly] public Texture Snow {get; set;}
	[Property, ReadOnly] public Texture Waypoint {get; set;}
	[Property, ReadOnly] public Texture WaypointMask {get; set;}
	[Property, ReadOnly] public Texture Final {get; set;}

	protected override void OnAwake() {
		LocalRotation = Rotation.FromYaw(60f) * Rotation.FromPitch(30f);
		LocalPosition = LocalRotation. Backward * 1024f;

		Lighting = Scene.CreateObject().Components.Create<LightingRigs>();

		Spawn.SetOwner(this);
		Spawn.Component(nameof(RenderCamera));
		RenderCamera.Orthographic = true;
		RenderCamera.BackgroundColor = Color.Black;
		RenderCamera.ZFar = 2048;
		Spawn.Component(nameof(DrawCamera));
		DrawCamera.RenderTags.Add("null");
		DrawCamera.BackgroundColor = Color.Black;
		DrawCamera.Priority = 1000;
		base.OnAwake();
	}

	public Vector2 PointToRenderPixels(Vector3 point) {
		var uv = RenderCamera.PointToScreenNormal(point);
		uv -= 0.5f;
		uv /= RenderSize / Screen.Size;
		uv += 0.5f;
		uv *= RenderSize;
		uv.x = uv.x.Floor();
		uv.y = uv.y.Floor();
		return uv;
	}

	public Vector3 MouseTarget() => ScreenPixelsToPoint(Mouse.Position);
	public Vector3 ScreenPixelsToPoint(Vector2 position) {
		var uv = position / Screen.Size;
		uv -= 0.5f;
		uv *= RenderSize / Screen.Size;
		uv.x *= Screen.Aspect;
		uv.x /= (float)RenderSize.x / RenderSize.y;
		uv += 0.5f;
		return new Plane(Vector3.Zero, Vector3.Up).Trace(RenderCamera.ScreenNormalToRay(uv)).Value;
	}

	private TimeUntil NextFullRender = 0;
	public void Update() {
		UpdateZoom();
		ResetTextures();
		Mouse.Visibility = MouseVisibility.Visible;
		if (Owner.Mouse.InteractMode == PlayerMouse.Mode.Move && Owner.Mouse.TargetLayer != PlayerMouse.Layer.Interface)
			Mouse.CursorType = "None";
		else if (Owner.Mouse.InteractMode == PlayerMouse.Mode.Shoot)
			Mouse.CursorType = "iso2_crosshair";
		else
			Mouse.CursorType = "iso2_pointer";
		UpdateMouseDrag();
		if (NextFullRender)
			FullRender();
		InterfaceRender();
	}

	[Property] public float ZoomScale {get; set;} = 0.25f;
	private void UpdateZoom() {
		if (Input.MouseWheel.y == 0)
			return;
		var startscale = ZoomScale;
		if (Input.MouseWheel.y > 0)
			ZoomScale /= 2f;
		else
			ZoomScale *= 2f;
		ZoomScale = ZoomScale.Clamp(0.25f, 0.5f);
		if (startscale != ZoomScale) {
			LastSize = Vector2.Zero;
			NextFullRender = 0f;
		}
	}

	private bool IsDragging = false;
	private Vector3 StartPosition;
	private Vector2 MouseStart;
	private Vector2 DitherStart;
	private void UpdateMouseDrag() {
		if (!IsDragging && Input.Pressed("drag_camera")) {
			IsDragging = true;
			StartPosition = Owner.WorldPosition;
			DitherStart = DitherOffset;
			MouseStart = Mouse.Position;
		}
		if (IsDragging && Input.Released("drag_camera"))
			IsDragging = false;
		if (IsDragging) {
			var mouse = ((Mouse.Position - MouseStart) * (RenderSize / Screen.Size)).SnapToGrid(1);
			var delta = ScreenPixelsToPoint(mouse) - ScreenPixelsToPoint(0);
			delta *= new Vector3(Screen.Size / RenderSize, 0f);
			Owner.WorldPosition = StartPosition - delta;
			DitherOffset = DitherStart - mouse;
			if (!mouse.IsNearZeroLength)
				FullRender();
		}
	}

	private Vector2 LastSize = Vector2.Zero;
	private void ResetTextures() {
		if (LastSize == Screen.Size)
			return;
		LastSize = Screen.Size;
		RenderSize = (Vector2Int)(Screen.Size * ZoomScale);

		Background?.Dispose();
		Background = Texture.CreateRenderTarget().WithSize(RenderSize).Create();
		BackgroundDepth?.Dispose();
		BackgroundDepth = Texture.CreateRenderTarget().WithSize(RenderSize).WithFormat(ImageFormat.RGBA32323232F).Create();
		EntityShadow?.Dispose();
		EntityShadow = Texture.CreateRenderTarget().WithSize(RenderSize).Create();
		EntityShadowDepth?.Dispose();
		EntityShadowDepth = Texture.CreateRenderTarget().WithSize(RenderSize).WithFormat(ImageFormat.RGBA32323232F).Create();
		EntityLighting?.Dispose();
		EntityLighting = Texture.CreateRenderTarget().WithSize(RenderSize).Create();
		Composite?.Dispose();
		Composite = Texture.CreateRenderTarget().WithUAVBinding().WithSize(RenderSize).Create();
		Snow?.Dispose();
		Snow = Texture.CreateRenderTarget().WithUAVBinding().WithSize(RenderSize).Create();
		Waypoint?.Dispose();
		Waypoint = Texture.CreateRenderTarget().WithSize(RenderSize).Create();
		WaypointMask?.Dispose();
		WaypointMask = Texture.CreateRenderTarget().WithSize(RenderSize).Create();
		Final?.Dispose();
		Final = Texture.CreateRenderTarget().WithUAVBinding().WithSize(RenderSize).Create();

		DrawCamera.ClearCommandLists();
		var cmds = new CommandList();
		cmds.Attributes.Set("Frame", Final);
		cmds.Attributes.Set("Interface", Owner.Inventory.Interface);
		cmds.Attributes.SetCombo("D_DRAW_INTERFACE", true);
		cmds.Blit(Material.FromShader(Shader.Load("shaders/post_draw.shader")));
		DrawCamera.AddCommandList(cmds, Stage.AfterPostProcess);
		FullRender();
	}

	private Vector2 LastEntityRenderOffset {get; set;}
	public void FullRender() {
		RenderCamera.OrthographicHeight = 1024 * (Screen.Height / 1024);
		RenderBackground();
		if (NextFullRender) {
			RenderShadows();
			RenderEntities();
			LastEntityRenderOffset = DitherOffset;
		}
		RenderWorldText();
		//RenderMask();
		DoComposite();
		if (NextFullRender)
			NextFullRender = 1f/8f;
	}

	private void RenderBackground() { //areas of static land behind the characters
		RenderCamera.RenderExcludeTags.Add("entity");
		RenderCamera.RenderExcludeTags.Add("flame");
		RenderCamera.RenderExcludeTags.Add("alpha_zero_depth_floor");
		RenderCamera.RenderExcludeTags.Add("iso_waypoint");
		TerrainSuperBlendController.Set(Scene, Scene.RenderAttributes);
		RenderCamera.RenderToTexture(Background);
		Scene.RenderAttributes.Clear();
		Scene.RenderAttributes.SetCombo("D_MANUAL_DEPTH", true);
		RenderCamera.RenderExcludeTags.Add("light");
		RenderCamera.RenderExcludeTags.Add("flame");
		//RenderCamera.RenderExcludeTags.Add("no_depth");
		RenderCamera.RenderToTexture(BackgroundDepth);
		Scene.RenderAttributes.SetCombo("D_MANUAL_DEPTH", false);
		RenderCamera.RenderExcludeTags.RemoveAll();
	}

	private void RenderShadows() {
		RenderCamera.RenderTags.Add("entity");
		RenderCamera.RenderTags.Add("entity_shadows");
		Lighting.EntityShadows.GameObject.Enabled = true;
		Scene.RenderAttributes.SetCombo("D_SHADOW_PASS", true);
		RenderCamera.RenderToTexture(EntityShadow);
		Scene.RenderAttributes.SetCombo("D_MANUAL_DEPTH", true);
		RenderCamera.RenderExcludeTags.Add("light");
		RenderCamera.RenderExcludeTags.Add("iso_waypoint");
		RenderCamera.RenderTags.Add("flame");
		RenderCamera.RenderToTexture(EntityShadowDepth);
		RenderCamera.RenderTags.RemoveAll();
		RenderCamera.RenderExcludeTags.RemoveAll();
		Lighting.EntityShadows.GameObject.Enabled = false;
		Scene.RenderAttributes.SetCombo("D_MANUAL_DEPTH", false);
		Scene.RenderAttributes.SetCombo("D_SHADOW_PASS", false);
	}

	private void RenderEntities() { //areas of static land behind the characters
		RenderCamera.RenderTags.Add("entity");
		RenderCamera.RenderTags.Add("flame");
		RenderCamera.RenderTags.Add("light_directional");
		RenderCamera.RenderToTexture(EntityLighting);
		RenderCamera.RenderTags.RemoveAll();
	}

	private void RenderWorldText() {
		WorldText?.Dispose();
		var tex = new Bitmap(RenderSize.x, RenderSize.y);
		foreach (var talker in Scene.GetAllComponents<NpcTalker>()) {
			if (!talker.Message.HasValue)
				continue;
			tex.SetPen(Color.Yellow, 1);
			var center = new Rect(PointToRenderPixels(talker.GetCaptionPosition()), 0);
			center = center.Grow(Graphics.MeasureText(center, talker.Message.Value).Width * 0.5f, 8);
			center.Top = center.Top.Floor();
			center.Left = center.Left.Floor();
			center.Width = MathF.Ceiling(center.Width);
			tex.DrawText(talker.Message.Value, center, TextFlag.Center);
		}
		WorldText = tex.ToTexture();
		tex.Dispose();
	}

	private void RenderMask() {
		Mask?.Dispose();
		var tex = new Bitmap(RenderSize.x, RenderSize.y);
		var any = false;
		foreach (var bounds in Scene.GetAllComponents<IsoCropBounds>()) {
			var bbox = bounds.BBox;
			if (!any)
				tex.Clear(Color.Black);
			any = true;
			tex.SetPen(Color.White,0);
			tex.SetFill(Color.White);
			var top = PointToRenderPixels(bounds.WorldPosition + WorldRotation.Left * bounds.Bounds.x * 0.5f + WorldRotation.Up * bounds.Bounds.y * 0.5f).Clamp(0f, RenderSize);
			var bot = PointToRenderPixels(bounds.WorldPosition + WorldRotation.Left *-bounds.Bounds.x * 0.5f + WorldRotation.Up *-bounds.Bounds.y * 0.5f).Clamp(0f, RenderSize) - top;
			if (bot.IsNearZeroLength)
				continue;
			tex.DrawRect(new(top,bot));
		}
		if (!any)
			tex.Clear(Color.White);
		Mask = tex.ToTexture();
		tex.Dispose();
	}

	private void DoComposite() { //combine world renders, not including ui
		var shader = new ComputeShader("shaders/cs_iso_composite_a.shader");
		shader.Attributes.Set("Background", Background);
		shader.Attributes.Set("BackgroundDepth", BackgroundDepth);
		shader.Attributes.Set("EntityShadow", EntityShadow);
		shader.Attributes.Set("EntityShadowDepth", EntityShadowDepth);
		shader.Attributes.Set("EntityLighting", EntityLighting);
		shader.Attributes.Set("WorldText", WorldText);
		shader.Attributes.Set("Mask", Mask);
		shader.Attributes.Set("Snow", Snow);
		shader.Attributes.Set("EntityOffset", DitherOffset - LastEntityRenderOffset);
		shader.Attributes.Set("DitherOffset", DitherOffset);
		shader.Attributes.Set("RenderSize", Composite.Size);
		shader.Attributes.Set("Result", Composite);
		shader.Dispatch(Composite.Width, Composite.Height, 1);
	}

	public void InterfaceRender() {
		RenderSnow();
		RenderWaypoint();
		DoFinalComposite();
	}

	private TimeUntil SnowUpdateTime {get; set;}
	private Vector2 LastDitherOffset {get; set;}
	private GpuBuffer<Vector4> SnowPositionBuffer {get; set;}
	private void RenderSnow() {
		if (SnowPositionBuffer == null)
			SnowPositionBuffer = new(2048);
		if (SnowUpdateTime || DitherOffset != LastDitherOffset) {
			var update = new ComputeShader("shaders/cs_snow_update.shader");
			update.Attributes.Set("PositionBuffer", SnowPositionBuffer);
			update.Attributes.Set("DeltaTime", SnowUpdateTime.Passed);
			update.Attributes.Set("TimeNow", Time.Now);
			update.Attributes.Set("DitherOffset", DitherOffset);
			update.Attributes.Set("MoveDelta", (DitherOffset - LastDitherOffset) / Snow.Size);
			update.Attributes.Set("Update", (bool)SnowUpdateTime);
			update.Dispatch(SnowPositionBuffer.ElementCount, 1, 1);
			LastDitherOffset = DitherOffset;
			if (SnowUpdateTime)
				SnowUpdateTime = 1f/20f;
		}
		var shader = new ComputeShader("shaders/cs_snow_draw.shader");
		shader.Attributes.Set("PositionBuffer", SnowPositionBuffer);
		shader.Attributes.Set("BufferSize", SnowPositionBuffer.ElementCount);
		shader.Attributes.Set("RenderSize", Snow.Size);
		shader.Attributes.Set("ZoomScale", ZoomScale);
		shader.Attributes.Set("Result", Snow);
		shader.Dispatch(Snow.Width, Snow.Height, 1);
	}

	private void RenderWaypoint() {
		RenderCamera.BackgroundColor = Color.Transparent;
		RenderCamera.RenderTags.Add("light_directional");
		if (Owner.Mouse.InteractMode == PlayerMouse.Mode.Move && Owner.Mouse.TargetLayer != PlayerMouse.Layer.Interface && !Input.Down("drag_camera"))
			RenderCamera.RenderTags.Add("iso_waypoint");
		RenderCamera.RenderToTexture(Waypoint);
		RenderCamera.RenderTags.RemoveAll();
		RenderCamera.RenderExcludeTags.Add("no_depth");
		RenderCamera.RenderExcludeTags.Add("iso_waypoint");
		RenderCamera.RenderExcludeTags.Add("ground");
		RenderCamera.RenderExcludeTags.Add("dynamic");
		RenderCamera.RenderExcludeTags.Add("flame");
		Scene.RenderAttributes.SetCombo("D_MANUAL_DEPTH", true);
		RenderCamera.RenderToTexture(WaypointMask);
		Scene.RenderAttributes.SetCombo("D_MANUAL_DEPTH", false);
		RenderCamera.RenderExcludeTags.RemoveAll();
		RenderCamera.BackgroundColor = Color.Black;
	}

	[Property, Range(-1,1)] public float Fade {get; set;}
	private void DoFinalComposite() { //combine world renders, not including ui
		var shader = new ComputeShader("shaders/cs_iso_composite_b.shader");
		shader.Attributes.Set("Composite", Composite);
		shader.Attributes.Set("Snow", Snow);
		shader.Attributes.Set("Waypoint", Waypoint);
		shader.Attributes.Set("WaypointMask", WaypointMask);
		shader.Attributes.Set("EntityShadow", EntityShadow);
		shader.Attributes.Set("EntityOffset", DitherOffset - LastEntityRenderOffset);
		shader.Attributes.Set("BackgroundDepth", BackgroundDepth);
		shader.Attributes.Set("Freeze", Owner.Inventory.Temperature.Remap(-20,0,1,0).SnapToGrid(0.05f));
		shader.Attributes.Set("FreezeOverlay", Texture.Load("materials/interface/freeze.vtex"));
		shader.Attributes.Set("Fade", Fade);
		shader.Attributes.Set("RenderSize", Final.Size);
		shader.Attributes.Set("Result", Final);
		shader.Dispatch(Final.Width, Final.Height, 1);
	}
}

public class IsoCropBounds : Component {
	[Property] public Vector2 Bounds {get; set;}
	public BBox BBox => new(new Vector3(100, Bounds.x, Bounds.y) *-0.5f, new Vector3(100, Bounds.x, Bounds.y) * 0.5f);
	protected override void DrawGizmos() {
		Gizmo.Transform = Gizmo.Transform.WithRotation(Rotation.FromYaw(60f) * Rotation.FromPitch(30f));
		Vector3 vec = 0.5f;
		vec.x = 1000;
		vec.y *= Bounds.x;
		vec.z *= Bounds.y;
		Gizmo.Draw.Color = Color.Black;
		Gizmo.Draw.LineThickness = 5;
		Gizmo.Draw.LineBBox(new(-vec, vec));
		base.DrawGizmos();
	}
}