Chapter 1 – Silhouette Banks and Class Matrices

Chapter 1: Silhouette Banks & Class Matrices

Created by Sarah Choi (prompt writer using ChatGPT)

Silhouette Banks & Class Matrices for Weapon Concept Artists

From brief → ideation → iteration → finals → handoff, designed equally for concept-phase artists and production-minded artists.

Why silhouette banks and class matrices matter

Silhouette banks and class matrices are the glue between freeform ideation and dependable production. A silhouette bank is a curated, reusable library of strong, readable outlines that encode intent: how a weapon class is recognized at a glance, how it fits a faction, and how it scales across variants. A class matrix is the living schema that maps silhouettes to gameplay roles, metrics, attachments, and manufacturing logic. Together, they prevent noisy one‑offs, accelerate iteration, and make your eventual package—orthos, callouts, and paintovers—trustworthy downstream.

In practice, the silhouette bank helps you answer “what shape grammar tells the player what this is?” while the class matrix helps you answer “how does this design behave across tiers, attachments, skins, and platform constraints?”

From brief to package at a glance

A typical pipeline runs:

Brief intake: clarify user fantasy, class mix, platform limits, style rules, and system constraints (camera distance, FOV, poly/tex budgets).
Silhouette ideation: explode options quickly to find readable class anchors; bucket them by role.
Matrix definition: map silhouettes to class variables (caliber family, magazine form, barrel regime, reload choreography, recoil silhouette, optic footprint, attachment lanes).
Iteration & convergence: test silhouettes against camera reads, animation blocks, level kit; prune and evolve via rounds.
Visual development: value keys, material breakups, faction reads; push toward hero/legendary signatures without sacrificing class readability.
Finals & package: orthographics, exploded views, callouts, skin hooks, LOD notes, archetype checklists, and naming/version control.
Handoff: a consumable package that lets modeling, tech art, rigging, VFX, and gameplay implement with minimal back‑and‑forth.

This article dives specifically into silhouette banks and class matrices at each stage so your designs stay legible and buildable.

STEP 1 — Decode the brief into silhouette intent

Before drawing, translate the brief into constraints that silhouette can express:

Gameplay role and power curve. A precision rifle wants long, aligned axes, a forward‑weighted muzzle regime, and minimal protrusions; a CQB shotgun prefers mass near hands, a short overall length, and a bold fore shape.

Faction doctrine and manufacturing story. A ritualistic empire might favor sacred symmetry and monolith slabs; a scrappy insurgent faction might broadcast kit‑bashed layers and mismatched magazines. Decide how these values manifest as profiles before you splash details.

Camera & distance reads. First‑person hand‑reads vs third‑person silhouette are not identical. List the primary read distances (e.g., 0.7 m FPV, 8–12 m ally glance, 25–40 m target ID) and what each must telegraph.

Attachment philosophy. Rails everywhere? Hidden systems? Proprietary dovetails? Your silhouette must reserve space and alignment cues for future attachments.

Write these as a short paragraph above your canvas. It becomes your silhouette acceptance test for the session.

STEP 2 — Build the first‑pass silhouette bank (quantity first)

Approach the first pass like a thumbnail storm with rules:

Time‑boxed bursts. 3–4 sprints of 15–20 silhouettes, 30–90 seconds each. Use hard black shapes only. No interiors, no details. If a shape needs interior lines to read as its class, it’s not strong enough yet.

Deliberate variation axes. For each class, pivot along 3–5 axes: overall proportion (OAL vs barrel vs stock), mass distribution (front vs rear bias), top line (flat/stepped/arching), undercarriage (clean vs busy), front signature (muzzle geometry, cowling), grip + trigger cluster (angle, spacing), magazine presence and angle, and silhouette‑obvious reload model (tube, box, cylinder, belt, cell).

Role‑based guardrails. Keep class anchors anchored: shotguns shouldn’t drift into slender DMR profiles; SMGs should not inherit long‑barrel rifle posture unless you’re exploring PDW crossovers intentionally.

Naming & grouping. Give each silhouette an atomic label (e.g., SG‑A12, SMG‑K07) and tag with class and variation axis. Group them on a single sheet by class so you can compare intra‑class readability.

At the end of the burst, you should have 60–120 silhouettes arranged by class buckets.

STEP 3 — Curate into a usable bank (quality pass)

Now you prune and tune.

Redundancy cull. Remove near‑duplicates; keep only the clearest versions of each posture. If two silhouettes compete, pick the one that solves more production constraints (e.g., better stock adjustability area, clean optic line).

Anchor, range, wildcards. For each class, keep: one Anchor (the clearest, most orthodox read), a Range pair (two silhouettes that stretch the class toward adjacent roles), and one Wildcard (spice that stays readable yet fresh). Anchors keep your matrix honest; Range + Wildcards keep the roster from feeling cloned.

Faction overlays. Duplicate selected silhouettes and apply faction transforms as pure shape operations: carved chamfers vs brutish blocks; ornamental crests vs utility ribs. Do not add detail—only change outline logic.

Metric sanity. Rough‑check critical clears (mag change room, stock extension, trigger reach) using simple boxes and arcs. If the silhouette cannot house plausible mechanics, fix it now.

The curated bank might shrink to 24–40 high‑value silhouettes—enough to cover classes and provide expansion room.

STEP 4 — Construct the class matrix (the schema)

Your class matrix connects silhouettes to the variables everyone else cares about. Build it as a living, single‑source schema that other teams can read.

Key domains to encode in the matrix:

1) Readability variables. Primary read distance; dominant line (horizontal/diagonal/vertical); front signature; grip cluster signature; silhouette asymmetries; attachment shadow shapes; reload silhouette (e.g., break‑action, cylinder swing, box drop, cell swap).

2) Mechanical plausibility. Action family (blowback, gas, recoil, pump, lever, break, coil/rail, mag‑tech), magazine location/orientation, ejection ideology, bolt carrier/net travel, charging handle clearance, heat path and vent zones.

3) Camera & animation hooks. Hand placement windows, wrap zones, sling anchor planes, charge/reload arcs, safety/selector reachable arcs, optic eyebox line, muzzle climb depiction.

4) Content scalability. Tiering (Common → Rare → Epic → Legendary → Mythic), skin anchor planes, modular hardpoints, destructible bits, LOD break strategy, decal/livery lanes.

5) Production constraints. Budget targets (tris, draw calls), texture sets and texel density, rigging notes (bone requirements), collision/hit proxy notes, platform flags (Switch vs high‑end PC), photogrammetry kit‑bashing viability.

6) Nomenclature & governance. Stable IDs, variant suffix rules, versioning semantics, retired silhouettes, and dependency mapping (which skins depend on which hardpoint topology).

Practically, you’ll author this matrix in a spreadsheet or design bible, but its purpose is to keep shape decisions tied to build decisions.

STEP 5 — Test silhouettes against the matrix (feedback loop)

Run each selected silhouette through a fast loop:

Read tests. Shrink to small sizes at 3–4 distances (thumbnail grid), flip horizontally, and overlay against common backgrounds (dark, mid, light). If the class collapses, either simplify the outline or adjust posture. A shotgun must still read as a shotgun at 48 px tall.

Animation dry‑fit. Use proxy hands and a skeleton to test charge, reload, fire, and inspect. Look for silhouette breaks when the bolt cycles, the cylinder swings, or the cell swaps. If the hero beat of the reload is invisible in silhouette, re‑compose the cluster.

Attachment impact. Drop in 3–4 common attachments per class and assess silhouette damage. If an optic or suppressor erases the class anchor, pre‑integrate a counter‑shape (e.g., stepped shroud) so the read survives.

Faction A/B. Apply two faction overlays to ensure manufacturing story can coexist with gameplay clarity.

Log issues directly in the matrix next to the silhouette ID, not in a separate document. Keep shape and evidence together.

STEP 6 — Iterate toward convergence (banks evolve)

Iteration is where silhouette banks earn their keep.

Shape surgery, not detail band‑aids. Fix reads by changing mass ratios, axes, and contour rhythm, not by adding screws. Production will thank you later.

Limit simultaneous freedoms. When testing a new variant, change one to two axes at a time (e.g., magazine location and top line) while freezing others (stock posture, muzzle signature). This keeps class drift traceable.

Pitfall triad: drift, noise, clone‑feel.

Drift happens when silhouettes chase novelty and lose class. Counter with anchors and quick A/B against the class sheet.
Noise happens when you try to say “everything” in the outline. Counter by prioritizing two read messages.
Clone‑feel happens when anchors are over‑reused. Counter with Range + Wildcards and faction overlays.

Bank hygiene. Retire silhouettes that repeatedly fail tests; archive them with tags explaining why. Future you (and teammates) will avoid old traps.

STEP 7 — Visual development without losing the read

As you graduate silhouettes into value keys and material passes, protect the class anchor.

Value scaffolding first. Establish 3–4 major value blocks that reinforce the outline logic (e.g., dark receiver mass, mid stock, light barrel shroud). This keeps the interior from fighting the silhouette.

Material breakups as shape echo. Vent cuts, ribs, and fasteners should underline mass flows, not scramble them. If the silhouette reads front‑heavy, echo that with forward visual density.

Faction motif discipline. Ornament should trace silhouette logic. A ceremonial crest can crown a front signature; don’t smear filigree where it muddies the read.

Skin readiness. Identify planes for future liveries and stickers early; ensure they don’t depend on micro‑greebles to look good. Your class matrix should point to these planes.

STEP 8 — Finals & package built on the matrix

Your final package is easier when silhouettes and matrix have done the heavy lifting.

Orthographics. Front, side, top, and bottom at consistent scales with clear centerlines and datum references. Include silhouette overlays at small size in the corner for class verification.

Exploded / cutaway. Focus on the action path and reload choreography. Label only parts that matter for rigging, animation, and damage states. Use callouts to connect silhouette claims with mechanical plausibility (e.g., “bolt travel 62 mm—clearance reserved under top cover”).

Callouts & spec. Include hand placements, charge arcs, optic eye line, ejection arc, muzzle thread regime, hardpoint coordinates, and attachment envelopes. Cross‑reference to matrix IDs.

LOD & proxy guidance. Describe which silhouette planes must be preserved at each LOD and what geometry may be sacrificed without losing class.

Version control & naming. Stamp the stable silhouette ID (e.g., AR‑A03‑AN for Anchor, AR‑B11‑WC for Wildcard). This ID travels with skins and variants.

Review checklist. End your package with a short checklist: class read at distance, animation beats visible, attachment compatibility, faction alignment, metric sanity, skin lanes verified.

For concept‑side artists: what to optimize

Speed to coverage. Use the bank to hit coverage across all classes fast, then deepen a few with Range + Wildcards.

Story through outline. Convey faction, era, and doctrine through major shapes; let materials support, not lead.

Fail fast with proof. Attach thumbnail read tests and animation dry‑fits early. It’s easier to adjust a silhouette than to unwind a finished render.

Pitch consistency. When presenting, show anchors together as a board, then show the speculative range; buyers see stability first, novelty second.

For production‑side artists: what to demand

Traceability. Every final concept should link directly to a bank silhouette ID and a matrix row. If it doesn’t, ask for it.

Metric clarity. Orthos must show key clearances and action travel, not just pretty views. If missing, flag with the matrix domain (e.g., “Mechanical plausibility → bolt travel”).

Attachment lanes locked. Request hardpoint coordinates and envelopes that match the silhouette promise. Avoid discovering that an optic collides with a charging handle at rigging time.

LOD preservation notes. Ensure the package states which silhouette planes are sacred at low poly—front signature, top line, and grip cluster profiles are usually non‑negotiable.

Indie vs AAA: adapting scope without losing rigor

Indie constraints. Smaller teams lean on fewer classes and more reuse. Keep the bank compact—one Anchor and one Range per class may be enough. Encode modularity in the matrix tightly so attachments deliver variety without re‑authoring silhouettes.

AAA breadth. Bigger rosters demand stronger governance: more classes, seasonal variants, cross‑studio outsourcing. Expand the matrix into a proper design system with dashboards: retired silhouettes, dependency trees, and global style health checks.

Outsourcing harmonization. Send the bank and matrix as part of your vendor kit. Include distance read targets, silhouette do’s/don’ts, and pass/fail thumbnails so external teams land in the same visual language.

Common failure modes and how to correct them

1) “Everything is a rectangle.” When all rifles share the same top line and barrel posture, micro differences vanish. Re‑diversify via mass distribution and front signatures; re‑anchor class edges.

2) Attachment chaos. If accessories obliterate class reads, you didn’t plan attachment shadows. Add counter‑shapes in the silhouette (shrouds, steps, offsets) so optics and cans nest predictably.

3) Faction sticker‑slap. If faction is purely decals, not shape, it will fail in silhouette. Re‑shape the slab logic, noses, and stocks to tell faction first, color second.

4) Animation invisibility. If reload choreography is hidden by overlapping masses, re‑compose the grip cluster and reload window so the beat lives in clear negative space.

5) Style drift over time. Banks that grow without governance blur the language. Institute quarterly culls and anchor refreshes; keep a style cop board comparing anchors across seasons.

Practical daily rituals for healthy banks and matrices

Morning 30‑shape warmup. Pick one class, generate 30 micro‑variants. Tag 3 keepers; archive the rest with reasons.

Weekly read review. As a team, print the current anchors at postage‑stamp size; vote blind on class ID. Any anchor below 90% recognition needs surgery.

Matrix hygiene hour. Update IDs, retire fails, and annotate attachment conflicts. Treat the matrix like production code.

Quarterly anchor audit. Compare anchors against shipped content and telemetry (if available). Refresh anchors when the meta or style guide evolves.

Handoff that actually works

When you hand off, imagine you won’t be reachable. The package must answer the big questions without you:

What class is this and how will the player know? Show the anchor silhouette at small sizes next to the orthos.

How does it move? Provide the reload, charge, and inspect arcs with hands overlaid.

How does it scale? List attachment lanes, tier skins, and LOD vows.

What is sacred vs flexible? Use a short “sacred planes” paragraph; everything else is negotiable.

Where do I find the truth? Link the silhouette ID to the class matrix row (or include it in the package PDF) so any downstream artist can reconcile inconsistencies.

Closing: signature weapons begin as signature silhouettes

Hero props don’t emerge from detail—they emerge from silhouette convictions that survive distance, skins, and seasons. A disciplined silhouette bank gives you the creative range to chase mythic signatures without losing class literacy. A rigorous class matrix gives production the map to build, reuse, and ship. Set these two pillars early, maintain them like code, and every step—from ideation to iteration to finals and handoff—stays aligned, legible, and fast.