К основному содержанию
скилл CX Codex

shader-fundamentals — скилл для Claude Code: что делает и установка

Скилл shader-fundamentals объясняет основы GLSL: шейдеры вершин и фрагментов, типы данных, координаты и передачу значений. Нужен при создании и отладке эффектов.

MIT 173 установок ★ 9 обновлён 2026-10-25

Установить в Claude Code · Через Skills CLI (Vercel) Все способы и платформы ↓
npx skills add Bbeierle12/Skill-MCP-Claude --skill shader-fundamentals -a claude-code
Открыть на GitHub

Что делает shader-fundamentals

Скилл разбирает конвейер GLSL от данных вершин до пикселей. Он объясняет роль вершинного и фрагментного шейдеров, uniform, attribute и varying, встроенных переменных вроде gl_Position и gl_FragColor, а также матриц и координатных пространств.

Внутри есть примеры типов, векторов, swizzling, матриц, sampler-ов, математических функций, UV-координат и операций с цветом. Материал также показывает стандартное преобразование позиции через modelMatrix, viewMatrix и projectionMatrix, включая вариант для Three.js/R3F.

Как базовая справка скилл удобен для разбора GLSL-кода по шагам. В примерах используются attribute, varying и gl_FragColor, поэтому синтаксис нужно сверить с GLSL-версией вашего проекта.

Какие задачи решает

  • разобраться в этапах графического конвейера
  • передать данные из вершинного шейдера во фрагментный
  • преобразовать позицию через матрицы
  • выбрать тип GLSL для значения
  • найти ошибку в UV-координатах или цвете

Примеры запросов агенту

  • Объясни, как modelMatrix, viewMatrix и projectionMatrix преобразуют позицию в этом вершинном шейдере.
  • Проверь, правильно ли я передаю uv через varying и использую её во фрагментном шейдере.
  • Разбери этот GLSL-код и найди ошибку в типах, матрицах или встроенных переменных.

Как установить shader-fundamentals

1Через Skills CLI (Vercel)

npx skills add Bbeierle12/Skill-MCP-Claude --skill shader-fundamentals -a claude-code

2Вручную: положить файлы

~/.claude/skills/shader-fundamentals/SKILL.md

Папка скилла целиком; для одного проекта — .claude/skills/shader-fundamentals/

По шагам, с командами для каждой платформы: Как установить скилл в Claude Code: пять способов

Вопросы о shader-fundamentals

Как установить shader-fundamentals в Claude Code?

Выполните npx skills add Bbeierle12/Skill-MCP-Claude --skill shader-fundamentals -a claude-code, затем проверьте файл ~/.claude/skills/shader-fundamentals/SKILL.md.

Что делает shader-fundamentals?

Скилл объясняет основы GLSL: работу вершинных и фрагментных шейдеров, uniform, attribute, varying, типы данных, матрицы, координатные пространства и встроенные функции.

Какие темы по GLSL входят в скилл?

В него входят конвейер от вершинных данных до пикселей, преобразования через матрицы, UV-координаты, sampler-ы, операции с цветом и стандартные математические функции.

Исходный текст

SKILL.md · MIT
---
name: shader-fundamentals
description: GLSL shader fundamentals—vertex and fragment shaders, uniforms, varyings, attributes, coordinate systems, built-in variables, and data types. Use when writing custom shaders, understanding the graphics pipeline, or debugging shader code. The foundational skill for all shader work.
---

# Shader Fundamentals

GLSL (OpenGL Shading Language) runs on the GPU. Vertex shaders transform geometry; fragment shaders color pixels.

## Quick Start

```glsl
// Vertex Shader
uniform mat4 projectionMatrix;
uniform mat4 modelViewMatrix;

attribute vec3 position;
attribute vec2 uv;

varying vec2 vUv;

void main() {
  vUv = uv;
  gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
}

// Fragment Shader
uniform float uTime;
varying vec2 vUv;

void main() {
  vec3 color = vec3(vUv, sin(uTime) * 0.5 + 0.5);
  gl_FragColor = vec4(color, 1.0);
}
```

## Graphics Pipeline

```
Vertex Data → [Vertex Shader] → Primitives → Rasterization → [Fragment Shader] → Pixels
     ↑              ↑                                              ↑
 attributes    transforms                                    per-pixel color
```

| Stage | Runs Per | Purpose |
|-------|----------|---------|
| Vertex Shader | Vertex | Transform positions, pass data to fragment |
| Fragment Shader | Pixel | Calculate final color |

## Data Types

### Scalars

```glsl
bool b = true;
int i = 42;
float f = 3.14;
```

### Vectors

```glsl
vec2 v2 = vec2(1.0, 2.0);
vec3 v3 = vec3(1.0, 2.0, 3.0);
vec4 v4 = vec4(1.0, 2.0, 3.0, 4.0);

// Integer vectors
ivec2 iv2 = ivec2(1, 2);
ivec3 iv3 = ivec3(1, 2, 3);

// Boolean vectors
bvec2 bv2 = bvec2(true, false);
```

### Swizzling

```glsl
vec4 color = vec4(1.0, 0.5, 0.2, 1.0);

vec3 rgb = color.rgb;      // (1.0, 0.5, 0.2)
vec2 rg = color.rg;        // (1.0, 0.5)
float r = color.r;         // 1.0

// Reorder
vec3 bgr = color.bgr;      // (0.2, 0.5, 1.0)

// Duplicate
vec3 rrr = color.rrr;      // (1.0, 1.0, 1.0)

// Position aliases (xyzw = rgba = stpq)
vec3 pos = v4.xyz;
vec2 uv = v4.st;
```

### Matrices

```glsl
mat2 m2;  // 2x2
mat3 m3;  // 3x3
mat4 m4;  // 4x4

// Access columns
vec4 col0 = m4[0];

// Access element
float val = m4[1][2];  // column 1, row 2
```

### Samplers

```glsl
uniform sampler2D uTexture;      // 2D texture
uniform samplerCube uCubemap;    // Cube map

// Sample texture
vec4 texColor = texture2D(uTexture, vUv);
vec4 cubeColor = textureCube(uCubemap, direction);
```

## Variable Qualifiers

### Uniforms (CPU → GPU, constant per draw)

```glsl
// Set from JavaScript, same for all vertices/fragments
uniform float uTime;
uniform vec3 uColor;
uniform mat4 uModelMatrix;
uniform sampler2D uTexture;
```

### Attributes (Per-vertex data)

```glsl
// Only in vertex shader
attribute vec3 position;    // Built-in: vertex position
attribute vec3 normal;      // Built-in: vertex normal
attribute vec2 uv;          // Built-in: texture coordinates
attribute vec3 color;       // Built-in: vertex color

// Custom attributes
attribute float aScale;
attribute vec3 aOffset;
```

### Varyings (Vertex → Fragment, interpolated)

```glsl
// Vertex shader: write
varying vec2 vUv;
varying vec3 vNormal;

void main() {
  vUv = uv;
  vNormal = normal;
}

// Fragment shader: read (interpolated across triangle)
varying vec2 vUv;
varying vec3 vNormal;

void main() {
  // vUv is interpolated between triangle vertices
}
```

## Built-in Variables

### Vertex Shader

```glsl
// Output (must write)
vec4 gl_Position;       // Clip-space position

// Output (optional)
float gl_PointSize;     // Point sprite size (for gl.POINTS)
```

### Fragment Shader

```glsl
// Input
vec4 gl_FragCoord;      // Window-space position (pixel coordinates)
bool gl_FrontFacing;    // True if front face
vec2 gl_PointCoord;     // Point sprite coordinates [0,1]

// Output
vec4 gl_FragColor;      // Final pixel color
```

## Coordinate Spaces

```
Local/Object Space
      ↓ modelMatrix
World Space
      ↓ viewMatrix
View/Eye/Camera Space
      ↓ projectionMatrix
Clip Space (-1 to 1)
      ↓ perspective divide
NDC (Normalized Device Coordinates)
      ↓ viewport transform
Screen Space (pixels)
```

### Common Matrices (Three.js/R3F)

```glsl
uniform mat4 modelMatrix;       // Local → World
uniform mat4 viewMatrix;        // World → View
uniform mat4 projectionMatrix;  // View → Clip
uniform mat4 modelViewMatrix;   // Local → View (modelMatrix * viewMatrix)
uniform mat3 normalMatrix;      // For transforming normals

uniform vec3 cameraPosition;    // Camera world position
```

### Standard Vertex Transform

```glsl
void main() {
  // Full transform chain
  vec4 worldPosition = modelMatrix * vec4(position, 1.0);
  vec4 viewPosition = viewMatrix * worldPosition;
  vec4 clipPosition = projectionMatrix * viewPosition;
  gl_Position = clipPosition;
  
  // Or combined (more efficient)
  gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
}
```

## Built-in Functions

### Math

```glsl
// Trigonometry
sin(x), cos(x), tan(x)
asin(x), acos(x), atan(x)
atan(y, x)  // atan2

// Exponential
pow(x, y)   // x^y
exp(x)      // e^x
log(x)      // ln(x)
sqrt(x)     // √x
inversesqrt(x)  // 1/√x

// Common
abs(x)
sign(x)     // -1, 0, or 1
floor(x)
ceil(x)
fract(x)    // x - floor(x)
mod(x, y)   // x % y (floating point)
min(x, y)
max(x, y)
clamp(x, min, max)
mix(a, b, t)  // Linear interpolation: a*(1-t) + b*t
step(edge, x) // 0 if x < edge, else 1
smoothstep(e0, e1, x)  // Smooth Hermite interpolation
```

### Vector

```glsl
length(v)        // Vector magnitude
distance(a, b)   // length(a - b)
dot(a, b)        // Dot product
cross(a, b)      // Cross product (vec3 only)
normalize(v)     // Unit vector
reflect(I, N)    // Reflection vector
refract(I, N, eta)  // Refraction vector
faceforward(N, I, Nref)  // Flip normal if needed
```

## Common Patterns

### UV Coordinates

```glsl
// vUv ranges from (0,0) at bottom-left to (1,1) at top-right
varying vec2 vUv;

void main() {
  // Center UVs: -0.5 to 0.5
  vec2 centered = vUv - 0.5;
  
  // Aspect-corrected (assuming you pass uResolution)
  vec2 uv = vUv;
  uv.x *= uResolution.x / uResolution.y;
  
  // Tiling
  vec2 tiled = fract(vUv * 4.0);  // 4x4 tiles
  
  // Polar coordinates
  float angle = atan(centered.y, centered.x);
  float radius = length(centered);
}
```

### Color Operations

```glsl
// Grayscale (perceptual weights)
float gray = dot(color.rgb, vec3(0.299, 0.587, 0.114));

// Contrast
color = (color - 0.5) * contrast + 0.5;

// Brightness
color += brightness;

// Saturation
float gray = dot(color, vec3(0.299, 0.587, 0.114));
color = mix(vec3(gray), color, saturation);

// Gamma correction
color = pow(color, vec3(1.0 / 2.2));  // Linear to sRGB
color = pow(color, vec3(2.2));         // sRGB to linear
```

### Smooth Transitions

```glsl
// Hard edge
float mask = step(0.5, value);

// Soft edge
float mask = smoothstep(0.4, 0.6, value);

// Anti-aliased edge (screen-space)
float mask = smoothstep(-fwidth(value), fwidth(value), value);
```

## Debugging

### Visualize Values

```glsl
// Show UVs as color
gl_FragColor = vec4(vUv, 0.0, 1.0);

// Show normals
gl_FragColor = vec4(vNormal * 0.5 + 0.5, 1.0);

// Show depth
float depth = gl_FragCoord.z;
gl_FragColor = vec4(vec3(depth), 1.0);

// Show value range (red=negative, green=positive)
gl_FragColor = vec4(max(0.0, value), max(0.0, -value), 0.0, 1.0);
```

### Common Errors

| Issue | Likely Cause |
|-------|--------------|
| Black screen | gl_Position not set, or NaN values |
| Uniform not updating | Wrong name or type mismatch |
| Texture black | Texture not loaded, wrong UV |
| Flickering | Z-fighting, precision issues |
| Faceted look | Normals not interpolated |

## Precision

```glsl
// Declare precision (required in fragment shader for WebGL 1)
precision highp float;
precision mediump float;
precision lowp float;
```

| Precision | Range | Use Case |
|-----------|-------|----------|
| highp | ~10^38 | Positions, matrices |
| mediump | ~10^14 | UVs, colors |
| lowp | ~2 | Simple flags |

## File Structure

```
shader-fundamentals/
├── SKILL.md
├── references/
│   ├── glsl-types.md         # Complete type reference
│   ├── builtin-functions.md  # All built-in functions
│   └── coordinate-spaces.md  # Transform pipeline
└── scripts/
    └── templates/
        ├── basic.glsl        # Starter template
        └── fullscreen.glsl   # Fullscreen quad shader
```

## Reference

- `references/glsl-types.md` — Complete data type reference
- `references/builtin-functions.md` — All GLSL built-in functions
- `references/coordinate-spaces.md` — Transform pipeline deep-dive

© Bbeierle12 · MIT · Bbeierle12/Skill-MCP-Claude

Похожие скиллы

Все скиллы по теме «Геймдев и 3D: Unity, Unreal, Godot, Blender» →
shader-programming gamedev-skills Скилл shader-programming для Claude Code и других платформ описывает кросс-платформенные шейдерные техники на GLSL и HLSL. Включается при проектировании математики эффектов или переносе шейдеров между движками. CX Codex +1 13 300установок shader-dev MiniMax-AI Скилл shader-dev для Claude Code содержит руководства по 36 техникам GLSL и генерирует шейдеры для ShaderToy и WebGL2. Техники охватывают процедурное 3D, рей-марчинг и визуальные эффекты в коде. CX Codex +1 2 800установок shader-glsl iart-ai Скилл shader-glsl помогает писать фрагментные шейдеры GLSL для генеративного фона, переходов между картинками и эффектов в Three.js. CX Codex +1 2 300установок web-shader-extractor lixiaolin94 Скилл web-shader-extractor для Claude Code и Codex извлекает и локально воспроизводит WebGL-, WebGPU-, Canvas- и шейдерные эффекты со страниц. Разбирает анимированные фоны и интерактивную 3D-графику. CX Codex +1 850установок shader-mobile zebbern Правило shader-mobile для Claude Code содержит приёмы оптимизации GLSL и Three.js шейдеров под мобильные GPU, помогающие избежать просадок FPS на смартфонах. CX Codex +1 ★ 4 719звёзд репо threejs-shaders calesthio Скилл threejs-shaders для Claude Code и Codex: писать вершинные и фрагментные шейдеры на GLSL, управлять uniforms и создавать кастомные визуальные эффекты в Three.js. CX Codex +1 1 200установок

Из того же набора19

Весь набор →
shader-effects Скилл shader-effects для Claude Code добавляет GLSL-примеры свечения, искажений, зерна, глитча и других эффектов для постобработки и стилизованного рендера. CX Codex +1 225установок frontend-dev-guidelines Скилл frontend-dev-guidelines для Claude Code задаёт правила React-разработки на TypeScript: структуру папок, загрузку данных, стили и тесты. Включается, когда агент пишет фронтенд-код. CX Codex +1 105установок d3js-visualization Скилл d3js-visualization для Claude Code учит агента создавать графики на D3.js: столбчатые, линейные и круговые диаграммы, тултипы и зум. CX Codex +1 189установок particles-gpu Скилл particles-gpu генерирует системы частиц на GPU через Three.js и React Three Fiber. Помогает рендерить эффекты от 10 тысяч до миллионов точек без просадки кадров. CX Codex +1 173установок gsap-sequencing Скилл gsap-sequencing для Claude Code помогает собирать сложные последовательности GSAP с метками, вложенными таймлайнами и колбэками для анимации интерфейса. CX Codex +1 163установок audio-analysis Скилл audio-analysis для Claude Code помогает разбирать аудиосигнал через Tone.js и Web Audio API. Подключается для визуализаций, поиска битов и реактивных аудиоэффектов. CX Codex +1 151установок software-architecture Скилл software-architecture для Claude Code разбирает код по слоям через SOLID и Clean Architecture, показывая, где класс берёт на себя лишнюю ответственность. CX Codex +1 150установок particles-physics Скилл particles-physics для Claude Code задаёт движение частиц через силы и поля. В анимациях можно использовать гравитацию, ветер, притяжение и турбулентность. CX Codex +1 134установок

Спонсоры проекта

Компании, которые помогают держать аналитику открытой