TANMAY NEEMA
I'm a Technical Artist and programmer with deep experience in both Unity and Unreal Engine, focused on tool development, pipeline optimization, and bridging the gap between art and code.
I specialize in building custom procedural tools and designer-friendly systems that speed up production without sacrificing visual quality — always eager to learn new languages or rendering techniques as the team requires.
Before you scroll further —
A QUICK LOOK AT MY WORK
ABOUT ME
Skills & Experience
Experience
Lead Programmer & Technical Artist
Aaji vs Mumbai: The Last Chai
Gameplay Programmer & Technical Artist
Hoppity-hop
Gameplay Programmer & Technical Artist
Lumin
Education
B.Design, Game Design and Development
Artemisia College of Arts & Design, Indore
Activities
IGDC 2025 Showcase — Exhibitor
"Best Groups" selection for Lumin
Programmer
Programmed and shipped a fully playable game in 48 hours as part of a cross-disciplinary team
Technical Skills
Custom Editor Tools
Procedural
Generation
AI Implementation
Game Optimization
VFX & Particle Systems
Rigging & Animation
Shader Development
Core Arsenal
SECONDARY SKILLS
Soft Skills
Multi-Project Management
Cross-Disciplinary Thinking
PROBLEM SOLVER
PROJECTS
Selected Work
Games
Aaji vs Mumbai: The Last Chai
3rd place in the college's game dev competition — still in development, but trusted with IGDC 2026 selection and sponsorship anyway. A wave-based 3D FPP zombie shooter set in Mumbai.
A cozy yet chaotic 3D FPP bullet-hell where a fierce Aaji defends Mumbai's last remaining tea stall from hordes of chai-crazed zombies.
Game Overview
Mumbai has been overtaken. A severe shortage has turned the populace into mindless "chai-holics," and they have consumed almost every tea shop in the city. All that stands between them and the last remaining tapri is Aaji—a small but fierce woman armed with pure jugaad combat skills. Players must survive waves of undisciplined tea drinkers and eventually face patient zero: her husband, Azoba.
This project blends a cozy, humorous aesthetic with the precision of a bullet-hell shooter, making the chaos both approachable and mechanically satisfying.
A Walk Through Mumbai's Streets
The game is still in development, so this is an environment walkthrough rather than gameplay — a look at the streets Aaji will be defending.
Pipeline & Technical Art
- Pipeline Optimization (Auto Material Generator): To speed up environment creation, I built a custom editor script that automates material generation. By utilizing strict naming conventions, developers can simply right-click a texture and automatically generate and map the corresponding material, completely removing a repetitive manual step from the art pipeline.
- VFX & Combat Feedback: Developed performant particle systems and visual effects for Aaji's jugaad weaponry and enemy impacts. Focused on clear visual hierarchy to ensure hit-states and chaotic bullet-hell projectile patterns remain readable to the player without dropping frame rate.
Systems Architecture & Gameplay Programming
- Wave & Enemy AI Systems: Engineered a fully functional wave-spawning manager and custom enemy AI. Structured the underlying logic using SOLID principles and modular design patterns to ensure the hordes of chai-zombies remained performant and the codebase stayed scalable.
- Dynamic Loot & Progression: Programmed a randomized loot spawning system to reward the player during intense bullet-hell segments, keeping the gameplay loop engaging and balanced.
- Narrative Systems: Built a robust, lightweight dialogue system to deliver the game's humor and drive the story forward between combat waves.
// Tanmay: drop a screenshot of your WaveManager
// or enemy state machine code here.
Custom Editor Tool
To manage the complexity of scene hierarchies and procedural asset placement in this game, I engineered a comprehensive, professional-grade custom editor tool.
Read the Deep-Dive: Custom Editor ToolHoppity-Hop
🥇 1st place in the college's game dev competition, selected for IGDC 2026 — built enemy AI and NPC behaviors for seamless player interaction, alongside a responsive 3D HUD and a scalable dialogue system, in Unreal Engine 5.7.
A 3D third-person platformer where a Mage Bunny uses Magic Cards to planet-hop, explore, and restore balance across a Sci-Fi/Fantasy universe.
Game Overview
In Hoppity-Hop, the core binding energy between planets is disrupting, scattering core magic cards across the universe. Players control a Mage Bunny who must platform and fight off enemies to restore balance. The gameplay features "Magic Card" abilities—such as borrowing powers, crafting shields, and throwing cards—to navigate a stylized world inspired by classic 3D platformers.
This project is still in active development — the screenshots and footage below are from a current in-progress build, not a finished release.
Full Gameplay Walkthrough
Captured from a current work-in-progress build — expect placeholder art, missing polish, and features still being wired up.
Technical Art & Custom Tooling
- Procedural Book Stacking Tool: To streamline environment dressing, I engineered a custom editor tool that automatically stacks books with randomized meshes and rotations. This provided the art team with a modular, highly customizable solution that eliminated tedious manual placement while maintaining an organic, lived-in aesthetic for the game's levels.
- Dynamic 3D HUD: Developed a responsive, 3D user interface that physically reacts to the player's movement and mouse position. This enhanced immersion by blending traditional UI elements seamlessly into the stylized sci-fi/fantasy environment.
- VFX with Niagara: Implemented and continuously iterated upon dynamic visual effects using Unreal Engine's Niagara system. These effects provided crucial combat feedback and emphasized the power of the player's Magic Card abilities.
Systems Architecture & AI
- Chess-Themed Enemy AI: Programmed robust AI behaviors for distinct enemy archetypes, including pack-hunting Pawns, dashing Knights, long-range Bishops, and heavy tank Rooks. Built dynamic state machines (Investigation, Engaged, Patrol) that trigger based on Line of Sight and player proximity.
- NPC Dialogue & Behavior: Created an interactive dialogue and behavior system for NPCs to smoothly guide the player through the game's sci-fi and steampunk wastelands.
- Minigame Integration: Built a flexible system for "Wurtz' Mini Game Station". Players can spend collected Floppy Disks to access different 2D minigames across various zones.
- Console Optimization: Managed performance profiling and optimization to ensure stable frame rates for console hardware, keeping the fast-paced action-adventure platforming smooth.
Lumin
Selected for IGDC 2025 — an interactive pan/zoom camera and photo-capture mechanic tied into a custom UI journal and quest system, with hand-authored prototype shaders.
A compelling 2D narrative side-scroller where players navigate a post-apocalyptic world using dynamic AI conversations and photography to piece together a mysterious cryo-disaster.
Game Overview
LUMIN casts players as Aquilo, a young man whose standard college commute turns into an impossible, decades-long journey. Following a mysterious cryo-disaster, Aquilo awakens from deep sleep in a desolate, unfamiliar world.
The core of the game is driven by conversational mechanics and clue-gathering. Players must actively engage with NPCs to uncover historical lore, unlock new areas, and ultimately find a way to save the world.
Technical Art & UI Systems
- Photography & Quest System: Engineered an interactive 2D camera system featuring dynamic pan and zoom functionality. Players capture specific environmental targets to trigger quest rewards. These photos are seamlessly stored in a custom-built, interactive page-flipping Journal UI.
- 2D Animation Integration: Acted as the sole animation integrator for the project. Configured all 2D state machines to ensure smooth, responsive character movement and expressive narrative animations.
- Pre-Production Shading: Authored prototype shaders during the pre-production phase to test and establish the visual targets for the game's desolate, post-apocalyptic aesthetic.
Systems Architecture & AI
- Dynamic AI Interaction: Integrated AI-generated dialogue and voice implementation for NPCs. This ensures conversations are unique and responsive, requiring players to actively extract critical clues from unpredictable dialogue trees to progress the mission system.
- Modular Minigame Architecture: Programmed multiple distinct minigames to vary the narrative pacing. Built these systems using a modular C# architecture, allowing them to be easily and cleanly hooked into the main core gameplay loop without bloating the codebase.
Editor Tools
Visual Node System
Custom, visual sequence-based node system similar to Shader Graph that drives core wave mechanics — gives designers full modular control to script, tweak, and override variables per wave without touching code.
A fully custom node-based wave sequencing tool built from scratch in the Unity Editor — level designers wire up an entire game sequence like a blueprint graph instead of digging through hundreds of nested inspector fields.
Full Tool Walkthrough
Wiring A Sequence Like A Blueprint
Every wave, delay, event, and branch is a node on the canvas — the full flow of a level is readable at a glance instead of buried in inspector arrays.
How The System Works
11 Node Types, Blueprint UX
Wave, Timed Wave, Enemy Group, Split Flow, Event, Reroute, and more — drag into empty space to open a searchable creation menu, the same UX as Unreal's Blueprint editor. Double-click any wire to drop in a Reroute node for cable management.
Cycle & Orphan Detection
The compiler runs a depth-first search before saving and blocks the operation if it finds an infinite loop, pointing at the exact node responsible. Wave nodes that were built but never connected to Start get flagged too, so nothing is silently lost.
Domain Reload Survival
The canvas — every node position and wire — persists across Unity script recompiles, which would normally wipe an Editor window's state clean.
Weighted Spawns & Pooling
Each spawn is chosen through a weighted random draw against per-group Spawn Weight values, not a round-robin. Enemies are acquired from a pre-warmed object pool that auto-expands if it runs dry mid-wave.
Boss Wave Events
Boss-mode waves automatically fire named graph events through a decoupled UnityEvent broadcaster — any listener in the scene can react with music changes, UI overlays, or cutscenes without being wired directly to the graph.
Split Flow Branching
Branches the sequence into two parallel timelines that run as separate coroutines simultaneously — both branches have to finish before the sequence continues past the split.
Editor Asset → Compiled Runtime Data
Save & Compile saves the editor layout into an Editor-only SequenceGraphAsset, then walks the graph from Start and compiles it into a flat, polymorphic RuntimeSequenceData asset via [SerializeReference] — the only thing that ships in the build. WaveManager just points at that compiled asset and runs it as a coroutine chain.
Built With
17 C# scripts · ~5,000 lines of code · zero third-party dependencies · designed, architected, and implemented solo.
Procedural Spline-Based Footpath System
A data-driven Unity Editor tool that turns a hand-drawn spline into fully mitered, terrain-conforming path or road geometry — live, in the editor, with zero manual mesh placement.
A data-driven, in-editor procedural generation system that turns a hand-drawn spline into fully mitered, terrain-conforming path or road geometry — live, in the Unity editor, with zero manual mesh placement.
Full Tool Walkthrough
A Full Street, Built From One Spline
The same tool that generates a single path also tiled out this entire market street — sidewalk, curb, and road all mitered through every corner without a single hand-placed piece.
Why This Needed A Tool
Hand-placing path, road, or walkway meshes along terrain is slow and fragile:
- Every corner needs a bespoke piece, or you get visible gaps and z-fighting where straight segments meet at an angle.
- Terrain or route changes mean starting over — every piece has to be moved, rotated, and re-fit by hand.
- Widening a path into a plaza or road means retiling everything from scratch.
I built a system where a level designer draws a spline, assigns a prefab "kit," and the tool handles placement, corner mitering, mesh deformation, and terrain fitting automatically — while staying fully live and editable in the Scene view.
Draw A Spline, Get A Finished Path
The system walks the spline, places anchor points at every knot, and decides what belongs where — start/end caps, straight segments, or corners — each correctly oriented, deformed, and joined with no gaps.
Auto-Mitered Corners
Arbitrary turn angles are handled automatically — obtuse and acute joints treated differently — plus manual per-corner overrides (padding, skew, inner/outer swap) for cases where the math needs an artist's touch.
True Mesh Deformation
A custom deformer bends each prefab's actual vertices along the spline's curvature per-segment, so corners and curves read as one continuous surface, not straight pieces glued at angles.
Data-Driven Variation
A ScriptableObject config lets designers swap entire visual "kits" — start caps, corners, weighted-random middle pieces — without touching code, including alternating style sequences down a single path.
Lane Expansion
A single-width path can be expanded sideways into a multi-lane plaza or road, with shoulder geometry sheared into place using the corner's bisector direction — seamless through turns, not just on straights.
Terrain Conforming
The spline can be resampled against the terrain via raycasting to hug elevation changes, with the original hand-authored spline cached and fully restorable afterward.
Bake For Shipping
Procedural lane geometry can be frozen into static meshes for runtime performance, without destroying the live mesh data mid-bake.
Live, Non-Destructive Editing
Built with ExecuteAlways and a change-signature system, so the entire path regenerates instantly as the spline or settings change in the editor — without regenerating needlessly every frame.
Where The Real Work Was
Corner Mitering Math
Getting a corner piece to look correct at any arbitrary angle — not just 90° — meant classifying turns as obtuse vs. acute and driving the miter geometry off the actual bisector angle, with a manual override system for the edge cases automated logic can't fully satisfy.
A Subtle Spline Tangent Bug
Unity's spline tangent evaluation snaps unexpectedly exactly at sharp knots, which showed up as visibly broken rotation on mitered pieces at hard corners. The fix was a tiny epsilon offset that nudges the evaluation just off the exact knot position — small change, real debugging to isolate.
Diamond-Skew Lane Expansion
Expanding a path into multiple lanes through a curve isn't a simple offset — I derived the shoulder geometry by skewing the "right" vector at each anchor along the corner's bisector and shearing scale into a diamond shape, so lane fillers stay seamless through turns.
Avoiding Runaway Regeneration
A naive OnValidate-driven procedural tool regenerates every frame it's touched, tanking editor performance on anything but the smallest paths. I built a signature-hashing system that fingerprints the spline's knots and settings, so regeneration only fires when something actually changed.
Bake Without Losing Data
Freezing dynamic lane geometry into static meshes for shipping risked deleting the mesh data mid-destroy. I added a preserve flag so the bake step can safely detach the procedural component without wiping the mesh it just generated.
Built With
More Than A Spline-Follower
This is a full authoring pipeline: data-driven configuration, real mesh deformation math, editor tooling built for how designers actually work, and the kind of edge-case debugging — tangent snapping, regeneration loops, bake safety — that only shows up once a tool gets used for real. It's the difference between a script that works in a demo and a tool a team can actually ship a level with.
Vegetation Scatter Tool
A custom Unity Editor extension for painting trees, bushes, and rocks directly into a scene — brush-based placement, slope-aware rules, and full Undo support, written from scratch in C#.
A custom Unity Editor extension for painting trees, bushes, and rocks directly into a scene, built with the same brush-based workflow you'd find in engines like Unreal — but written from scratch in C#.
Full Tool Walkthrough
Palette System
Build a reusable palette asset by dragging prefabs in directly, or tag prefabs in your project and let the tool auto-scan and pull them in. Each entry shows a live thumbnail, poly count, and its own placement rules.
Three Placement Modes
Single
Click to place one weighted-random prefab at a time.
Brush
Paint across terrain with adjustable radius and density, spacing-aware so instances don't stack or overlap.
Eraser
Clear placed instances by radius — either just the types currently selected in the palette, or everything at once.
Slope-Aware Placement
Every prefab can be given a max slope angle, so a fern won't spawn halfway up a cliff face just because the brush passed over it. Separately, prefabs can align their rotation to the surface normal, so vegetation sits naturally on uneven ground instead of always standing straight up.
The two settings are independent, so you can mix "never spawns on steep ground" with "always spawns straight" or any combination.
Editable & Undo-Friendly
Everything Stays Editable
Placed vegetation isn't baked into a custom data layer — it's real GameObjects, organized into the Hierarchy by prefab type. Click one, move it, delete it, same as anything else in your scene.
Full Undo Support
Every brush stroke and erase pass is grouped, so one Ctrl+Z undoes the whole stroke instead of one instance at a time.
A Forest, Painted By Hand
Why I Built This
I'm currently the sole programmer on my team, and a lot of that work comes down to building tools other people on the team actually have to use. I wanted a project that forced me to think about that end of things properly — not just "does the placement math work," but does the window hold up under real use, is the palette something an artist would actually want to touch, does Undo behave the way people expect it to. This tool was my way of practicing that, aimed at technical art tooling roles specifically.
Wire Placement System
A custom Unity Editor toolset for rapidly placing, tuning, and optimizing procedural utility wires in open-world scenes — click-to-connect placement, physically-inspired sag, and a one-click bake/unbake pipeline.
An in-house Unity Editor extension that turns hand-placing hundreds of sagging power lines, telephone wires, and bunting into a click-to-connect workflow — with live physically-plausible sag and a one-click bake step for runtime performance.
Full Tool Walkthrough
A Real Production Problem
Hand-placing hundreds of sagging power lines, telephone wires, and bunting/flag decorations between poles and buildings is slow, repetitive, and easy to get visually wrong. This tool turns that into a click-to-connect workflow directly in the Scene View — with live physically-plausible sag, gravity-aware curve alignment, and a one-click bake step that collapses hundreds of individual wire meshes into a handful of optimized static meshes for runtime performance.
It's a full editor-side pipeline, backed by proper Undo support so it fits naturally into a real level-design workflow:
Click-to-Place Workflow
- Instant connection: click any wire anchor point in the Scene View, then click a second point to spawn a connected wire — no manual dragging of prefabs or eyeballing positions.
- Interface-driven, not hardcoded: any object can offer connection points by implementing a single
IWireConnectionHostinterface, so poles, buildings, or custom props are all discoverable automatically.
Physically-Inspired Wire Curves
- Quadratic Bezier curves with adjustable sag, rendered as either a lightweight
LineRendereror a fully procedural cylindrical mesh. - Auto gravity alignment: the curve's low point automatically biases toward the lower anchor based on height difference, mimicking how a real wire hangs — with designer-tunable weight and clamping so it never looks unnatural.
- Manual override: custom Scene View handles let you drag to skew the curve center or adjust sag, with exact algebraic positioning — the sag handle sits precisely on the visible curve, not an approximation.
Bunting / Flag Decoration
An optional add-on component that scatters pennant flags along any wire using true arc-length spacing — not naive Bezier-parameter spacing, which bunches decorations unnaturally at the curve's ends.
Supports multiple flag prefabs with cycling or randomized color selection, adjustable density, scale, and orientation — and rebuilds live as the underlying wire changes shape.
Scene-Wide Management Tool
- Bulk operations from a dockable Editor window: push global render/material/thickness settings to every wire, re-roll randomized sag across the scene, save/load reusable Wire Presets as ScriptableObjects, and manage bunting flags scene-wide.
- Live preview: dragging a slider shows the change instantly in-scene before committing, with a clean Apply / Revert flow.
- Scene View Overlay mirrors the tool's core stats and placement toggle, so designers rarely need to leave the viewport.
Performance: Bake / Unbake Pipeline
One click combines all editable wire meshes in a folder into a single optimized static mesh asset, dramatically cutting draw calls and object count for shipping scenes. Fully reversible: baked chunks retain references to their original wire objects, so "Unbake" restores every wire — fully editable again — and cleans up the generated mesh asset from disk.
Validation & Production-Ready Support
Validation Tooling
One-click scan across the entire scene — including inactive wires inside baked chunks — for any wire missing a start or end anchor, surfaced as a clear, actionable list.
Full Undo / Redo
Every operation is covered, including multi-step actions grouped so a single Ctrl+Z reverts a whole bake or bulk-apply rather than leaving the scene half-changed.
Custom Inspectors
Every component — Wire, WireBunting, BakedWireChunk — gets a custom inspector, so designers never touch raw serialized fields without tooltips, warnings, and one-click actions.
Under The Hood
Editor Scripting
Custom EditorWindow, SceneView.duringSceneGui handles, a UnityEditor.Overlays.Overlay for the Scene View toolbar, and multiple CustomEditor inspectors.
Procedural Geometry
Hand-rolled Bezier curve evaluation and cylindrical mesh generation (vertices, normals, UVs, triangles) with pooled buffers that only reallocate when topology settings change — no per-frame garbage in edit mode.
Dirty-Checking
Wires only rebuild geometry when an anchor actually moves, keeping edit-mode performance smooth even with hundreds of wires in a scene.
Interface-Driven Extensibility
IWireConnectionHost means the placement tool has zero knowledge of "poles" as a concept — any component can opt in, no reflection required.
Mesh Baking
Via Mesh.CombineMeshes with generated .asset files, safely tracked and cleaned up through the unbake pipeline. Wire configurations themselves are saved and loaded as ScriptableObject-based presets, reusable across scenes or projects.
Built For Real Production Use
This is a full editor-side pipeline — place, tune, decorate, validate, bake, unbake — all backed by proper Undo support, so it fits naturally into a real level-design workflow rather than being a one-off script that only works in a demo scene.
Shaders & VFX
Water Spray Shader & VFX
A customizable water-trail shader built in Shader Graph for Unity's Particle System — time-based UV panning drives the fluid motion, depth-fade softens intersections with the ground, vertex color hooks into per-particle color/alpha, and normal mapping gives the flat trail real volumetric lighting.
A customizable water-trail shader built in Unity Shader Graph, designed to integrate directly with Unity's Particle System for dynamic fluid attacks and environmental effects — performant, artist-friendly, and built to blend seamlessly into any scene.
Full Shader Walkthrough
Alternate Splash Variant
A second pass on the same shader with different tiling, panning speed, and splash texture tuning — same node graph, different feel.
How The Shader Works
Dynamic Flow via UV Panning
A Panner setup driven by Time continuously scrolls the UVs on the splash and trail textures, giving the water constant, realistic fluid motion instead of a static texture.
Soft Intersections (Depth Fade)
Comparing Scene Depth against Screen Position, scaled by an exposed Fade Distance parameter, softens the alpha wherever the water meets opaque geometry like the floor — no harsh clipping lines.
Particle System Integration
The main texture and opacity outputs are multiplied against a Vertex Color node, letting Unity's Particle System directly drive the stream's color and fade its alpha out over each particle's lifetime.
Surface Volume & Lighting
Rather than a flat unlit texture, a sampled normal map is routed through an exposed Normal Strength parameter, catching scene lighting and giving the 2D water trail real volumetric feel.
Artist-Friendly Modularity
Key parameters — Fade Distance, Normal Strength, Tiling — are all exposed on the material, so other artists or designers on a team can tune the shader without ever opening the node graph. Alpha clipping thresholds keep droplet silhouettes crisp, and emissive multipliers help the VFX pop under different lighting.
Built With
Interactive Energy Shield & Dissolve VFX
A modular sci-fi energy shield built in Shader Graph — procedural twirl and zoom give it a swirling energy flow, vertex displacement lets it dent and ripple in real time as characters pass through it, and a noise-driven dissolve handles clean activate/deactivate transitions.
A real-time, modular sci-fi energy shield built in Unity Shader Graph — combining procedural texture generation, vertex manipulation, and spatial distance-based logic into a reactive forcefield that dents and ripples as characters pass through it.
Full Shader Walkthrough
Modular Shader Graph Architecture
The material is organized into clean, independent functional blocks rather than one tangled graph — each one isolated enough to tweak or reuse on its own.
Twirl & Zoom Sub-Networks
Procedurally warps and animates texture coordinates over time using rotational matrices and scaling factors, giving the shield its swirling, organic energy flow.
Vertex Displacement Network
Manipulates the mesh's vertex positions along their normals, driven by custom curves and strength parameters to deform the geometry dynamically.
Fresnel Rim Lighting
Calculates view-angle intensity to keep the outer edges of the sphere glowing brightly, so the shield stays readable against any world background.
Dissolve Mechanism
A noise texture piped into a step/smoothstep function handles organic transitions when the shield activates or deactivates, dissolving from the center outward with glowing edge fringes.
Real-Time Spatial Interaction
Rather than a simple on/off state, the shader calculates the proximity of objects relative to the shield's surface and shell thickness in real time. When a character enters or exits the boundary, that intersection intensity scales a vertex displacement offset — denting, rippling, or stretching the geometry exactly where the interaction happens.
The system also distinguishes direction: entering from the outside versus exiting from the inside dynamically flips or scales the displacement multiplier, so the visual response feels physically grounded regardless of which way a character is moving through it.
Isolating The Twirl's Center
Masking The Twirl's Center
A radial mask isolates and softens the very center of the twirl distortion, keeping the swirl from pinching or warping unnaturally at its origin point.
Built With
Retro CRT Post-Processing Shader
A full-screen URP post-process shader that emulates a vintage CRT monitor — rolling scanlines, multi-tap chromatic aberration for analog signal bleed, and a global color tint, all built as a single Full-Screen Pass over the final frame.
A custom full-screen pass shader in Unity URP that replicates the distinct visual character of vintage CRT displays — dynamic scanlines and analog color fringing layered over the final frame to sell a retro mood for 2D environments.
Full Shader Walkthrough
How The Effect Is Built
Dynamic Scanline Generation
A procedural Checkerboard node, scaled via an exposed Number of Lines parameter, generates the scanlines. A panner driven by Time and Scan Line Speed feeds its UV offset, so the lines roll smoothly down the screen.
Multi-Tap Chromatic Aberration
Samples the URP Sample Buffer multiple times at offset UV coordinates. Each offset sample is tinted with a distinct HDR color channel — red, yellow, blue, magenta — then blended together to simulate analog signal bleed and lens fringing.
Full-Screen Buffer Integration
Operates directly as a URP Full-Screen Pass, capturing the final frame render texture and manipulating pixels post-composition just before it's presented to the screen.
Global Color Grading & Tinting
An overall base color tint is multiplied into the final output, establishing a cohesive retro atmosphere and color palette across the entire viewport.
Built With
Line density, scan speed, tint colors, and offset thresholds are all exposed as parameters, giving designers quick iteration control over the final retro look.
GET IN TOUCH
Contact Me
Hey you!
I'm open to joining a team or jumping into a collab. If you've got an idea and need someone who can bring it to life,
just reach out.
Nothing happen? Email me directly — jaggi1250@gmail.com
No projects match that tag yet.