tsl-post-processing — правило для Claude Code
Правило tsl-post-processing для Claude Code описывает постобработку Three.js на TSL: эффекты подключаются к postProcessing.outputNode без цепочки проходов EffectComposer. Агент обращается к нему при написании кода сцены.
MIT ★ 4 719 обновлён 2026-10-24
.claude/rules/tsl-post-processing.mdЧто делает tsl-post-processing
Правило описывает постобработку на TSL (Three.js Shading Language) для WebGPU и WebGL. Эффекты не собираются в список проходов, а вешаются на postProcessing.outputNode. Внутри таблица сигнатур: bloom, dof, gaussianBlur, ssr, ssgi, ao, traa, fxaa, smaa, lut3D, film, motionBlur, chromaticAberration и остальные. Рядом готовые цепочки — цветокоррекция через hue и saturation, размытие по глубине с нодой из scenePass.getDepthNode().
Это markdown-файл правила, а не библиотека. Агент читает его как справку, когда пишет код сцены, поэтому сигнатуры эффектов и порядок вызовов берутся оттуда, а не из памяти модели. Есть раздел со сравнением старого EffectComposer и TSL-подхода и пять правил сборки. Одно стоит держать в голове: постобработка обходит встроенное сглаживание WebGL, поэтому fxaa или smaa ставят в конец цепочки, иначе края поедут лесенкой.
Там же совет по альтернативе — библиотека postprocessing из экосистемы Poimandres, её добавляют через npm install postprocessing. Для сцен на чистом WebGL без TSL этот путь ближе.
Какие задачи решает
- Собрать цепочку bloom и размытия по глубине на нодах TSL
- Перевести готовую сцену с
EffectComposerнаpostProcessing.outputNode - Вернуть сглаживание после включения постобработки
- Подобрать аргументы эффекта: что передавать в
dofилиanamorphic - Добавить цветокоррекцию через
lut3Dперед выводом кадра
Примеры запросов агенту
- Собери постобработку на TSL: bloom и размытие по глубине через
postProcessing.outputNode - Перепиши цепочку проходов со
EffectComposerна TSL-ноды, покажи разницу - Почему после постобработки пропало сглаживание? Добавь
fxaaв конец цепочки
Как установить tsl-post-processing
Вручную: положить файлы
.claude/rules/tsl-post-processing.mdПоле paths во frontmatter ограничивает файлы
AGENTS.md
Codex читает AGENTS.md: вставьте текст правила туда
Вручную: положить файлы
.cursor/rules/tsl-post-processing.mdcВо frontmatter: description, globs, alwaysApply
Вручную: положить файлы
.github/instructions/tsl-post-processing.instructions.mdПоле applyTo задаёт, к каким файлам применять
Вручную: положить файлы
.devin/rules/tsl-post-processing.mdВручную: положить файлы
.clinerules/tsl-post-processing.mdПо шагам, с командами для каждой платформы: AGENTS.md и CLAUDE.md: что это, кто читает и какой выбрать
Вопросы о tsl-post-processing
Как установить tsl-post-processing в Claude Code?
Положите файл правила по пути .claude/rules/tsl-post-processing.md в проект. Дальше Claude читает его как правило проекта.
Что делает tsl-post-processing?
Даёт агенту справку по эффектам TSL в Three.js: сигнатуры, примеры цепочек и порядок сборки. Пользуется ей при написании кода постобработки для WebGPU и WebGL.
Чем TSL-подход отличается от EffectComposer?
В EffectComposer проходы добавляются по одному и рендер идёт через composer.render(). В TSL вы собираете дерево нод и отдаёте его в postProcessing.outputNode.
Исходный текст
tsl-post-processing.md · MIT
# TSL Post-Processing
Modern post-processing using TSL (Three.js Shading Language) for WebGPU and WebGL.
## TSL Post-Processing Setup
```javascript
import { pass, bloom, gaussianBlur, grayscale } from 'three/tsl';
const scenePass = pass(scene, camera);
const beauty = scenePass.getTextureNode();
// Chain effects
postProcessing.outputNode = bloom(grayscale(beauty), 1, 0.4, 0.85);
```
## Available Effects
| Effect | Signature |
|--------|-----------|
| After Image | `afterImage(node, damp)` |
| Anamorphic Flare | `anamorphic(node, threshold, scale, samples)` |
| Bloom | `bloom(node, strength, radius, threshold)` |
| Box Blur | `boxBlur(textureNode, options)` |
| Chromatic Aberration | `chromaticAberration(node, strength, center, scale)` |
| Denoise | `denoise(node, depthNode, normalNode, camera)` |
| Depth of Field | `dof(node, viewZ, focusDistance, focalLength, bokehScale)` |
| Dot Screen | `dotScreen(node, angle, scale)` |
| Film Grain | `film(inputNode, intensity, uv)` |
| FXAA | `fxaa(node)` |
| Gaussian Blur | `gaussianBlur(node, direction, sigma, options)` |
| Grayscale | `grayscale(color)` |
| Hash Blur | `hashBlur(textureNode, blurAmount, options)` |
| LUT Grading | `lut3D(node, lut, size, intensity)` |
| Motion Blur | `motionBlur(inputNode, velocity, samples)` |
| Outline | `outline(scene, camera, params)` |
| RGB Shift | `rgbShift(node, amount, angle)` |
| Sepia | `sepia(color)` |
| SMAA | `smaa(node)` |
| Sobel | `sobel(node)` |
| SSR | `ssr(colorNode, depthNode, normalNode, metalness, roughness, camera)` |
| SSGI | `ssgi(beautyNode, depthNode, normalNode, camera)` |
| AO | `ao(depthNode, normalNode, camera)` |
| Transition | `transition(nodeA, nodeB, mixTexture, ratio, threshold, useTexture)` |
| TRAA | `traa(beautyNode, depthNode, velocityNode, camera)` |
## Common Patterns
### Bloom
```javascript
import { pass, bloom } from 'three/tsl';
const scenePass = pass(scene, camera);
const beauty = scenePass.getTextureNode();
postProcessing.outputNode = bloom(beauty, 1, 0.4, 0.85);
// Parameters: node, strength, radius, threshold
```
### Gaussian Blur
```javascript
import { gaussianBlur, pass } from 'three/tsl';
const scenePass = pass(scene, camera);
const beauty = scenePass.getTextureNode();
postProcessing.outputNode = gaussianBlur(beauty, 4);
// Parameters: node, sigma
```
### Color Grading Pipeline
```javascript
import { pass, grayscale, saturation, hue, bloom } from 'three/tsl';
const scenePass = pass(scene, camera);
const beauty = scenePass.getTextureNode();
// Chain multiple effects
const graded = saturation(hue(beauty, 0.1), 1.2);
const final = bloom(graded, 0.5, 0.4, 0.9);
postProcessing.outputNode = final;
```
### Depth of Field
```javascript
import { pass, dof } from 'three/tsl';
const scenePass = pass(scene, camera);
const beauty = scenePass.getTextureNode();
const depth = scenePass.getDepthNode();
postProcessing.outputNode = dof(
beauty,
depth,
5, // focusDistance
0.02, // focalLength
0.025 // bokehScale
);
```
## TSL vs EffectComposer
### EffectComposer (WebGL Traditional)
```javascript
import { EffectComposer } from 'three/addons/postprocessing/EffectComposer.js';
import { RenderPass } from 'three/addons/postprocessing/RenderPass.js';
import { UnrealBloomPass } from 'three/addons/postprocessing/UnrealBloomPass.js';
const composer = new EffectComposer(renderer);
composer.addPass(new RenderPass(scene, camera));
composer.addPass(new UnrealBloomPass(resolution, strength, radius, threshold));
// In render loop
composer.render();
```
### TSL Post-Processing (Modern)
```javascript
import { pass, bloom } from 'three/tsl';
const scenePass = pass(scene, camera);
const beauty = scenePass.getTextureNode();
postProcessing.outputNode = bloom(beauty, 1, 0.4, 0.85);
```
## Best Practices
1. **Tone Mapping**: When using postprocessing, set `renderer.toneMapping = NoToneMapping` and add tone mapping as last effect
2. **Precision**: Use `HalfFloatType` for high precision frame buffers
3. **Anti-Aliasing**: WebGL AA is bypassed with postprocessing; add FXAA/SMAA at the end
4. **Performance**: Combine multiple effects into single pass when possible
5. **Order**: RenderPass always first, AA always last
## Alternative: pmndrs/postprocessing
High-performance post-processing library from Poimandres ecosystem:
- Better performance than built-in EffectComposer
- Optimized effects
- Better selective bloom support
```bash
npm install postprocessing
```
## References
- [Three.js Examples - Post-Processing](https://threejs.org/examples/?q=postprocessing)
- [pmndrs/postprocessing](https://github.com/pmndrs/postprocessing)
© zebbern · MIT · zebbern/claude-code-guide