Skip to main content 홈 크리에이터 beko2210 firstbrain threejs-shaders
threejs-shaders Three.js shaders - GLSL, ShaderMaterial, uniforms, custom effects. Use when creating custom visual effects, modifying vertices, writing fragment shaders, or extending built-in materials.
설치로 이동 Skills Marketplace 커뮤니티가 만든 AI 스킬을 발견하고 탐색하세요.
Codex 또는 Claude로 설치 이 Prompt를 복사해 Codex, Claude 또는 다른 어시스턴트에 붙여 넣으면 Skill 페이지를 검토하고 설치를 진행할 수 있습니다.
직접 명령은 검토 Prompt를 거치지 않습니다. 실행하기 전에 소스를 확인하세요.
npx skills add https://github.com/BEKO2210/Firstbrain --skill threejs-shaders명령은 한 줄로 유지됩니다. 복사하기 전에 가로로 스크롤해 전체 내용을 확인하세요.
로컬 사본을 원하시나요? SkillsMP에서 현재 제공할 수 있는 파일을 다운로드하세요.
Zip 다운로드 다운로드 중... name threejs-shaders description Three.js shaders - GLSL, ShaderMaterial, uniforms, custom effects. Use when creating custom visual effects, modifying vertices, writing fragment shaders, or extending built-in materials. type skill created 2026-02-27T00:00:00.000Z domain design-creative category 3d-animation risk unknown source community tags ["skill","design-creative","3d-animation","threejs","shaders"]
Three.js Shaders
When to Use
You need custom shader logic in Three.js.
The task involves ShaderMaterial, uniforms, GLSL, vertex deformation, or fragment-based effects.
You are extending material behavior beyond what built-in materials provide.
Quick Start
import * as THREE from "three" ;
const material = new THREE .ShaderMaterial ({
uniforms : {
time : { value : 0 },
color : { value : new THREE .Color (0xff0000 ) },
},
vertexShader : `
void main() {
gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
}
` ,
fragmentShader : `
uniform vec3 color;
void main() {
gl_FragColor = vec4(color, 1.0);
}
` ,
});
material.uniforms .time .value = clock.getElapsedTime ();
ShaderMaterial vs RawShaderMaterial
ShaderMaterial
Three.js provides built-in uniforms and attributes.
const material = new THREE .ShaderMaterial ({
vertexShader : `
// Built-in uniforms available:
// uniform mat4 modelMatrix;
// uniform mat4 modelViewMatrix;
// uniform mat4 projectionMatrix;
// uniform mat4 viewMatrix;
// uniform mat3 normalMatrix;
// uniform vec3 cameraPosition;
// Built-in attributes available:
// attribute vec3 position;
// attribute vec3 normal;
// attribute vec2 uv;
void main() {
gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
}
` ,
: ,
});
fragmentShader
`
void main() {
gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
}
`
RawShaderMaterial Full control - you define everything.
const material = new THREE .RawShaderMaterial ({
uniforms : {
projectionMatrix : { value : camera.projectionMatrix },
modelViewMatrix : { value : new THREE .Matrix4 () },
},
vertexShader : `
precision highp float;
attribute vec3 position;
uniform mat4 projectionMatrix;
uniform mat4 modelViewMatrix;
void main() {
gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
}
` ,
fragmentShader : `
precision highp float;
void main() {
gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
}
` ,
});
Uniforms
Uniform Types const material = new THREE .ShaderMaterial ({
uniforms : {
floatValue : { value : 1.5 },
intValue : { value : 1 },
vec2Value : { value : new THREE .Vector2 (1 , 2 ) },
vec3Value : { value : new THREE .Vector3 (1 , 2 , 3 ) },
vec4Value : { value : new THREE .Vector4 (1 , 2 , 3 , 4 ) },
colorValue : { value : new THREE .Color (0xff0000 ) },
mat3Value : { value : new THREE .Matrix3 () },
mat4Value : { value : new THREE .Matrix4 () },
textureValue : { value : texture },
cubeTextureValue : { value : cubeTexture },
floatArray : { value : [1.0 , 2.0 , 3.0 ] },
vec3Array : {
value : [new THREE .Vector3 (1 , 0 , 0 ), new THREE .Vector3 (0 , 1 , 0 )],
},
},
});
GLSL Declarations // In shader
uniform float floatValue;
uniform int intValue;
uniform vec2 vec2Value;
uniform vec3 vec3Value;
uniform vec3 colorValue; // Color becomes vec3
uniform vec4 vec4Value;
uniform mat3 mat3Value;
uniform mat4 mat4Value;
uniform sampler2D textureValue;
uniform samplerCube cubeTextureValue;
uniform float floatArray[3];
uniform vec3 vec3Array[2];
Updating Uniforms
material.uniforms .time .value = clock.getElapsedTime ();
material.uniforms .position .value .set (x, y, z);
material.uniforms .color .value .setHSL (hue, 1 , 0.5 );
material.uniforms .matrix .value .copy (mesh.matrixWorld );
Varyings Pass data from vertex to fragment shader.
const material = new THREE .ShaderMaterial ({
vertexShader : `
varying vec2 vUv;
varying vec3 vNormal;
varying vec3 vPosition;
void main() {
vUv = uv;
vNormal = normalize(normalMatrix * normal);
vPosition = (modelViewMatrix * vec4(position, 1.0)).xyz;
gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
}
` ,
fragmentShader : `
varying vec2 vUv;
varying vec3 vNormal;
varying vec3 vPosition;
void main() {
// Use interpolated values
gl_FragColor = vec4(vNormal * 0.5 + 0.5, 1.0);
}
` ,
});
Common Shader Patterns
Texture Sampling const material = new THREE .ShaderMaterial ({
uniforms : {
map : { value : texture },
},
vertexShader : `
varying vec2 vUv;
void main() {
vUv = uv;
gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
}
` ,
fragmentShader : `
uniform sampler2D map;
varying vec2 vUv;
void main() {
vec4 texColor = texture2D(map, vUv);
gl_FragColor = texColor;
}
` ,
});
Vertex Displacement const material = new THREE .ShaderMaterial ({
uniforms : {
time : { value : 0 },
amplitude : { value : 0.5 },
},
vertexShader : `
uniform float time;
uniform float amplitude;
void main() {
vec3 pos = position;
// Wave displacement
pos.z += sin(pos.x * 5.0 + time) * amplitude;
pos.z += sin(pos.y * 5.0 + time) * amplitude;
gl_Position = projectionMatrix * modelViewMatrix * vec4(pos, 1.0);
}
` ,
fragmentShader : `
void main() {
gl_FragColor = vec4(0.5, 0.8, 1.0, 1.0);
}
` ,
});
Fresnel Effect const material = new THREE .ShaderMaterial ({
vertexShader : `
varying vec3 vNormal;
varying vec3 vWorldPosition;
void main() {
vNormal = normalize(normalMatrix * normal);
vWorldPosition = (modelMatrix * vec4(position, 1.0)).xyz;
gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
}
` ,
fragmentShader : `
varying vec3 vNormal;
varying vec3 vWorldPosition;
void main() {
// cameraPosition is auto-provided by ShaderMaterial
vec3 viewDirection = normalize(cameraPosition - vWorldPosition);
float fresnel = pow(1.0 - dot(viewDirection, vNormal), 3.0);
vec3 baseColor = vec3(0.0, 0.0, 0.5);
vec3 fresnelColor = vec3(0.5, 0.8, 1.0);
gl_FragColor = vec4(mix(baseColor, fresnelColor, fresnel), 1.0);
}
` ,
});
Noise-Based Effects // Simple noise function
float random(vec2 st) {
return fract(sin(dot(st.xy, vec2(12.9898, 78.233))) * 43758.5453);
}
// Value noise
float noise(vec2 st) {
vec2 i = floor(st);
vec2 f = fract(st);
float a = random(i);
float b = random(i + vec2(1.0, 0.0));
float c = random(i + vec2(0.0, 1.0));
float d = random(i + vec2(1.0, 1.0));
vec2 u = f * f * (3.0 - 2.0 * f);
return mix(a, b, u.x) + (c - a) * u.y * (1.0 - u.x) + (d - b) * u.x * u.y;
}
// Usage
float n = noise(vUv * 10.0 + time);
Gradient // Linear gradient
vec3 color = mix(colorA, colorB, vUv.y);
// Radial gradient
float dist = distance(vUv, vec2(0.5));
vec3 color = mix(centerColor, edgeColor, dist * 2.0);
// Smooth gradient with custom curve
float t = smoothstep(0.0, 1.0, vUv.y);
vec3 color = mix(colorA, colorB, t);
Rim Lighting const material = new THREE .ShaderMaterial ({
vertexShader : `
varying vec3 vNormal;
varying vec3 vViewPosition;
void main() {
vNormal = normalize(normalMatrix * normal);
vec4 mvPosition = modelViewMatrix * vec4(position, 1.0);
vViewPosition = mvPosition.xyz;
gl_Position = projectionMatrix * mvPosition;
}
` ,
fragmentShader : `
varying vec3 vNormal;
varying vec3 vViewPosition;
void main() {
vec3 viewDir = normalize(-vViewPosition);
float rim = 1.0 - max(0.0, dot(viewDir, vNormal));
rim = pow(rim, 4.0);
vec3 baseColor = vec3(0.2, 0.2, 0.8);
vec3 rimColor = vec3(1.0, 0.5, 0.0);
gl_FragColor = vec4(baseColor + rimColor * rim, 1.0);
}
` ,
});
Dissolve Effect uniform float progress;
uniform sampler2D noiseMap;
void main() {
float noise = texture2D(noiseMap, vUv).r;
if (noise < progress) {
discard;
}
// Edge glow
float edge = smoothstep(progress, progress + 0.1, noise);
vec3 edgeColor = vec3(1.0, 0.5, 0.0);
vec3 baseColor = vec3(0.5);
gl_FragColor = vec4(mix(edgeColor, baseColor, edge), 1.0);
}
Extending Built-in Materials
onBeforeCompile Modify existing material shaders.
const material = new THREE .MeshStandardMaterial ({ color : 0x00ff00 });
material.onBeforeCompile = (shader ) => {
shader.uniforms .time = { value : 0 };
material.userData .shader = shader;
shader.vertexShader = shader.vertexShader .replace (
"#include <begin_vertex>" ,
`
#include <begin_vertex>
transformed.y += sin(position.x * 10.0 + time) * 0.1;
` ,
);
shader.vertexShader = "uniform float time;\n" + shader.vertexShader ;
};
if (material.userData .shader ) {
material.userData .shader .uniforms .time .value = clock.getElapsedTime ();
}
Common Injection Points
"#include <begin_vertex>" ;
"#include <project_vertex>" ;
"#include <beginnormal_vertex>" ;
"#include <color_fragment>" ;
"#include <output_fragment>" ;
"#include <fog_fragment>" ;
GLSL Built-in Functions
Math Functions // Basic
abs(x), sign(x), floor(x), ceil(x), fract(x)
mod(x, y), min(x, y), max(x, y), clamp(x, min, max)
mix(a, b, t), step(edge, x), smoothstep(edge0, edge1, x)
// Trigonometry
sin(x), cos(x), tan(x)
asin(x), acos(x), atan(y, x), atan(x)
radians(degrees), degrees(radians)
// Exponential
pow(x, y), exp(x), log(x), exp2(x), log2(x)
sqrt(x), inversesqrt(x)
Vector Functions // Length and distance
length(v), distance(p0, p1), dot(x, y), cross(x, y)
// Normalization
normalize(v)
// Reflection and refraction
reflect(I, N), refract(I, N, eta)
// Component-wise
lessThan(x, y), lessThanEqual(x, y)
greaterThan(x, y), greaterThanEqual(x, y)
equal(x, y), notEqual(x, y)
any(bvec), all(bvec)
Texture Functions // GLSL 1.0 (default) - use texture2D/textureCube
texture2D(sampler, coord)
texture2D(sampler, coord, bias)
textureCube(sampler, coord)
// GLSL 3.0 (glslVersion: THREE.GLSL3) - use texture()
// texture(sampler, coord) replaces texture2D/textureCube
// Also use: out vec4 fragColor instead of gl_FragColor
// Texture size (GLSL 1.30+)
textureSize(sampler, lod)
Common Material Properties const material = new THREE .ShaderMaterial ({
uniforms : {
},
vertexShader : "/* ... */" ,
fragmentShader : "/* ... */" ,
transparent : true ,
opacity : 1.0 ,
side : THREE .DoubleSide ,
depthTest : true ,
depthWrite : true ,
blending : THREE .NormalBlending ,
wireframe : false ,
wireframeLinewidth : 1 ,
extensions : {
derivatives : true ,
fragDepth : true ,
drawBuffers : true ,
shaderTextureLOD : true ,
},
glslVersion : THREE .GLSL3 ,
});
Shader Includes
Using Three.js Shader Chunks import { ShaderChunk } from "three" ;
const fragmentShader = `
${ShaderChunk.common}
${ShaderChunk.packing}
uniform sampler2D depthTexture;
varying vec2 vUv;
void main() {
float depth = texture2D(depthTexture, vUv).r;
float linearDepth = perspectiveDepthToViewZ(depth, 0.1, 1000.0);
gl_FragColor = vec4(vec3(-linearDepth / 100.0), 1.0);
}
` ;
External Shader Files
import vertexShader from "./shaders/vertex.glsl" ;
import fragmentShader from "./shaders/fragment.glsl" ;
const material = new THREE .ShaderMaterial ({
vertexShader,
fragmentShader,
});
Instanced Shaders
const offsets = new Float32Array (instanceCount * 3 );
geometry.setAttribute ("offset" , new THREE .InstancedBufferAttribute (offsets, 3 ));
const material = new THREE .ShaderMaterial ({
vertexShader : `
attribute vec3 offset;
void main() {
vec3 pos = position + offset;
gl_Position = projectionMatrix * modelViewMatrix * vec4(pos, 1.0);
}
` ,
fragmentShader : `
void main() {
gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
}
` ,
});
Debugging Shaders
material.onBeforeCompile = (shader ) => {
console .log ("Vertex Shader:" , shader.vertexShader );
console .log ("Fragment Shader:" , shader.fragmentShader );
};
fragmentShader : `
void main() {
// Debug UV
gl_FragColor = vec4(vUv, 0.0, 1.0);
// Debug normals
gl_FragColor = vec4(vNormal * 0.5 + 0.5, 1.0);
// Debug position
gl_FragColor = vec4(vPosition * 0.1 + 0.5, 1.0);
}
` ;
renderer.debug .checkShaderErrors = true ;
Performance Tips
Minimize uniforms : Group related values into vectors
Avoid conditionals : Use mix/step instead of if/else
Precalculate : Move calculations to JS when possible
Use textures : For complex functions, use lookup tables
Limit overdraw : Avoid transparent objects when possible
// Instead of:
if (value > 0.5) {
color = colorA;
} else {
color = colorB;
}
// Use:
color = mix(colorB, colorA, step(0.5, value));
TSL (Three.js Shading Language) - Future Direction TSL is the new shader authoring system for Three.js, designed to work with both WebGL and WebGPU renderers. GLSL patterns above are WebGL-only and will not work with the WebGPU renderer.
TSL Quick Start import { MeshStandardNodeMaterial } from "three/addons/nodes/Nodes.js" ;
import {
uv, sin, timerLocal, vec4, color, positionLocal, normalLocal,
float, mul, add
} from "three/addons/nodes/Nodes.js" ;
const material = new MeshStandardNodeMaterial ();
const time = timerLocal ();
material.colorNode = color (sin (add (uv ().x , time)), uv ().y , 0.5 );
material.positionNode = add (
positionLocal,
mul (normalLocal, sin (add (positionLocal.x , time)).mul (0.1 ))
);
Key Differences from GLSL GLSL (WebGL only) TSL (WebGL + WebGPU) ShaderMaterialMeshStandardNodeMaterialString-based shaders JavaScript node graph onBeforeCompileNode composition Manual uniforms uniform() nodetexture2D()texture() nodegl_PositionpositionNodegl_FragColorcolorNode / outputNode
When to Use What
GLSL ShaderMaterial : Existing WebGL projects, maximum shader control, porting existing shaders
TSL NodeMaterial : New projects, WebGPU support needed, cross-renderer compatibility
See Also
threejs-materials - Built-in material types
threejs-postprocessing - Full-screen shader effects
threejs-textures - Texture sampling in shaders
Connections
Domain: [[Design & Kreativitaet]]
Kategorie: [[3D & Animation]]
Navigation: [[Skills Uebersicht]], [[Home]]