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

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

Скилл r3f-fundamentals помогает настраивать сцены React Three Fiber, управлять камерами, источниками света и циклом рендеринга через декларативный синтаксис JSX.

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

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

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

Скилл содержит базовые паттерны работы с React Three Fiber (@react-three/fiber). Он подсказывает агенту, как трансформировать императивный код Three.js в декларативные компоненты React, где вложенность JSX автоматически формирует дерево сцены, а удаление объектов из памяти происходит при размонтировании.

Внутри описаны параметры компонента Canvas: настройка WebGL-рендерера, диапазоны DPR, тени, режимы frameloop (always, demand, never) и работа с перспективными или ортографическими камерами. Также разобраны типовые источники освещения (ambientLight, directionalLight, pointLight, spotLight) с картами теней.

Для динамических сцен скилл даёт шаблоны работы с хуком useFrame: чтение времени из clock, дельты кадров и выставление приоритетов выполнения. Без пакета @react-three/fiber в проекте использовать эти шаблоны не получится.

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

  • Сконфигурировать компонент Canvas с адаптивным DPR и расчётом теней
  • Перевести императивное добавление объектов Three.js в декларативное дерево JSX
  • Настроить оптимизированный цикл рендеринга по требованию через frameloop demand
  • Организовать покадровую анимацию вращения или смещения мешей через useFrame
  • Собрать схему освещения сцены со спотами, направленным светом и мягкими тенями

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

  • Настрой сцену в Canvas с режимом frameloop demand и ручной инвалидацией кадров
  • Покажи, как связать направленный свет с картой теней и плоскостью-приёмником
  • Напиши компонент меша, который плавно вращается в хуке useFrame с учётом дельты времени

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

1Через Skills CLI (Vercel)

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

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

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

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

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

Вопросы о r3f-fundamentals

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

Выполните команду npx skills add Bbeierle12/Skill-MCP-Claude --skill r3f-fundamentals -a claude-code. Файл скилла сохранится в ~/.claude/skills/r3f-fundamentals/SKILL.md.

Что делает этот скилл?

Он задаёт контекст для генерации кода на React Three Fiber: конфигурацию холста Canvas, иерархию сцены через группы и меши, постановку света и управление камерой.

В каких случаях скилл советует использовать frameloop demand?

Для статичных трёхмерных сцен, где изображение обновляется только при изменении состояния компонентов или через вызов функции invalidate().

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

SKILL.md · MIT
---
name: r3f-fundamentals
description: React Three Fiber core setup, Canvas configuration, scene hierarchy, camera systems, lighting, render loop, and React integration patterns. Use when setting up a new R3F project, configuring the Canvas component, managing scene structure, or understanding the declarative Three.js-in-React paradigm. The foundational skill that all other R3F skills depend on.
---

# React Three Fiber Fundamentals

Declarative Three.js via React components. R3F maps Three.js objects to JSX elements with automatic disposal, reactive updates, and React lifecycle integration.

## Quick Start

```tsx
import { Canvas } from '@react-three/fiber';

function App() {
  return (
    <Canvas>
      <ambientLight intensity={0.5} />
      <pointLight position={[10, 10, 10]} />
      <mesh>
        <boxGeometry args={[1, 1, 1]} />
        <meshStandardMaterial color="hotpink" />
      </mesh>
    </Canvas>
  );
}
```

## Core Principle: Declarative Scene Graph

R3F converts Three.js imperative API to React's declarative model:

| Three.js (Imperative) | R3F (Declarative) |
|----------------------|-------------------|
| `new THREE.Mesh()` | `<mesh>` |
| `mesh.position.set(1, 2, 3)` | `<mesh position={[1, 2, 3]}>` |
| `scene.add(mesh)` | JSX nesting handles hierarchy |
| `mesh.geometry.dispose()` | Automatic on unmount |

## Canvas Configuration

```tsx
import { Canvas } from '@react-three/fiber';

<Canvas
  // Renderer settings
  gl={{ antialias: true, alpha: false, powerPreference: 'high-performance' }}
  dpr={[1, 2]}                    // Device pixel ratio range
  shadows                          // Enable shadow maps
  
  // Camera (default: PerspectiveCamera)
  camera={{ 
    fov: 75, 
    near: 0.1, 
    far: 1000, 
    position: [0, 0, 5] 
  }}
  
  // Or use orthographic
  orthographic
  camera={{ zoom: 50, position: [0, 0, 100] }}
  
  // Performance
  frameloop="demand"              // 'always' | 'demand' | 'never'
  performance={{ min: 0.5 }}      // Adaptive performance
  
  // Events
  onCreated={({ gl, scene, camera }) => {
    // Access Three.js objects after mount
  }}
  
  // Sizing
  style={{ width: '100vw', height: '100vh' }}
/>
```

### Frameloop Modes

| Mode | When to Use |
|------|-------------|
| `always` | Continuous animation (games, simulations) |
| `demand` | Static scenes, only re-render on state change |
| `never` | Manual control via `invalidate()` |

```tsx
// Demand mode with manual invalidation
import { useThree } from '@react-three/fiber';

function Controls() {
  const invalidate = useThree(state => state.invalidate);
  
  const handleDrag = () => {
    // Update state...
    invalidate(); // Request re-render
  };
}
```

## Scene Hierarchy

JSX nesting = Three.js parent-child relationships:

```tsx
<group position={[0, 2, 0]} rotation={[0, Math.PI / 4, 0]}>
  {/* Children inherit parent transforms */}
  <mesh position={[1, 0, 0]}>
    <sphereGeometry args={[0.5, 32, 32]} />
    <meshStandardMaterial color="blue" />
  </mesh>
  
  <mesh position={[-1, 0, 0]}>
    <boxGeometry args={[0.8, 0.8, 0.8]} />
    <meshStandardMaterial color="red" />
  </mesh>
</group>
```

### Common Container Components

```tsx
// Group: Transform container (no rendering)
<group position={[0, 0, 0]} />

// Object3D: Base class, rarely used directly
<object3D />

// Scene: Usually implicit (Canvas creates one)
<scene />
```

## Camera Systems

### Default Perspective Camera

```tsx
<Canvas camera={{ 
  fov: 75,              // Field of view (degrees)
  aspect: width/height, // Auto-calculated
  near: 0.1,            // Near clipping plane
  far: 1000,            // Far clipping plane
  position: [0, 5, 10]
}} />
```

### Custom Camera Component

```tsx
import { PerspectiveCamera } from '@react-three/drei';

function Scene() {
  return (
    <>
      <PerspectiveCamera 
        makeDefault           // Set as active camera
        fov={60} 
        position={[0, 2, 8]} 
      />
      {/* Scene contents */}
    </>
  );
}
```

### Camera Access

```tsx
import { useThree } from '@react-three/fiber';

function CameraController() {
  const { camera } = useThree();
  
  useEffect(() => {
    camera.lookAt(0, 0, 0);
  }, [camera]);
  
  return null;
}
```

## Lighting

### Light Types

```tsx
// Ambient: Uniform, directionless
<ambientLight intensity={0.4} color="#ffffff" />

// Directional: Sun-like, parallel rays
<directionalLight 
  position={[5, 10, 5]} 
  intensity={1} 
  castShadow 
/>

// Point: Radiates from position
<pointLight 
  position={[0, 5, 0]} 
  intensity={1} 
  distance={20}        // Range (0 = infinite)
  decay={2}            // Physical falloff
/>

// Spot: Cone-shaped
<spotLight 
  position={[0, 10, 0]} 
  angle={Math.PI / 6}  // Cone angle
  penumbra={0.5}       // Edge softness
  castShadow 
/>

// Hemisphere: Sky/ground gradient
<hemisphereLight 
  skyColor="#87ceeb" 
  groundColor="#362907" 
  intensity={0.6} 
/>
```

### Shadow Setup

```tsx
<Canvas shadows>
  <directionalLight
    castShadow
    position={[10, 10, 10]}
    shadow-mapSize={[2048, 2048]}
    shadow-camera-far={50}
    shadow-camera-left={-10}
    shadow-camera-right={10}
    shadow-camera-top={10}
    shadow-camera-bottom={-10}
  />
  
  <mesh castShadow>
    <boxGeometry />
    <meshStandardMaterial />
  </mesh>
  
  <mesh receiveShadow rotation={[-Math.PI / 2, 0, 0]} position={[0, -1, 0]}>
    <planeGeometry args={[20, 20]} />
    <meshStandardMaterial />
  </mesh>
</Canvas>
```

## Render Loop (useFrame)

`useFrame` runs every frame (60fps target). This is where animation happens.

```tsx
import { useFrame, useThree } from '@react-three/fiber';
import { useRef } from 'react';

function RotatingBox() {
  const meshRef = useRef<THREE.Mesh>(null!);
  
  useFrame((state, delta) => {
    // state: R3F state (camera, scene, clock, etc.)
    // delta: Time since last frame (seconds)
    
    meshRef.current.rotation.x += delta;
    meshRef.current.rotation.y += delta * 0.5;
  });
  
  return (
    <mesh ref={meshRef}>
      <boxGeometry />
      <meshNormalMaterial />
    </mesh>
  );
}
```

### useFrame State Object

```tsx
useFrame((state) => {
  state.clock        // THREE.Clock
  state.clock.elapsedTime  // Total time (seconds)
  state.camera       // Active camera
  state.scene        // Scene object
  state.gl           // WebGLRenderer
  state.size         // { width, height }
  state.viewport     // { width, height, factor, distance }
  state.mouse        // Normalized mouse position [-1, 1]
  state.raycaster    // THREE.Raycaster
});
```

### Render Priority

```tsx
// Lower priority runs first, higher runs later
// Default is 0

useFrame(() => {
  // Update physics
}, -1);  // Runs before default

useFrame(() => {
  // Update visuals
}, 0);   // Default

useFrame(() => {
  // Post-processing / camera
}, 1);   // Runs after default
```

## Accessing Three.js Objects

### useThree Hook

```tsx
import { useThree } from '@react-three/fiber';

function SceneInfo() {
  const { 
    gl,           // WebGLRenderer
    scene,        // THREE.Scene
    camera,       // Active camera
    size,         // Canvas dimensions
    viewport,     // Viewport in Three.js units
    clock,        // THREE.Clock
    set,          // Update state
    get,          // Get current state
    invalidate,   // Request re-render (demand mode)
    advance,      // Advance one frame (never mode)
  } = useThree();
  
  return null;
}
```

### Refs for Direct Access

```tsx
import { useRef } from 'react';
import * as THREE from 'three';

function DirectAccess() {
  const meshRef = useRef<THREE.Mesh>(null!);
  const materialRef = useRef<THREE.MeshStandardMaterial>(null!);
  
  useEffect(() => {
    // Direct Three.js API access
    meshRef.current.geometry.computeBoundingBox();
    materialRef.current.needsUpdate = true;
  }, []);
  
  return (
    <mesh ref={meshRef}>
      <boxGeometry />
      <meshStandardMaterial ref={materialRef} />
    </mesh>
  );
}
```

## Events

R3F provides pointer events on meshes:

```tsx
<mesh
  onClick={(e) => console.log('click', e.point)}
  onContextMenu={(e) => console.log('right click')}
  onDoubleClick={(e) => console.log('double click')}
  onPointerOver={(e) => console.log('hover')}
  onPointerOut={(e) => console.log('unhover')}
  onPointerDown={(e) => console.log('down')}
  onPointerUp={(e) => console.log('up')}
  onPointerMove={(e) => console.log('move')}
>
  <boxGeometry />
  <meshStandardMaterial />
</mesh>
```

### Event Object

```tsx
onClick={(e) => {
  e.stopPropagation();    // Stop event bubbling
  e.point                 // THREE.Vector3 intersection point
  e.distance              // Distance from camera
  e.object                // Intersected object
  e.face                  // Intersected face
  e.faceIndex             // Face index
  e.uv                    // UV coordinates
  e.camera                // Camera used for raycasting
  e.delta                 // Distance from last event
}}
```

## Suspense & Loading

R3F integrates with React Suspense for async loading:

```tsx
import { Suspense } from 'react';
import { useLoader } from '@react-three/fiber';
import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader';

function Model() {
  const gltf = useLoader(GLTFLoader, '/model.glb');
  return <primitive object={gltf.scene} />;
}

function App() {
  return (
    <Canvas>
      <Suspense fallback={<LoadingSpinner />}>
        <Model />
      </Suspense>
    </Canvas>
  );
}

function LoadingSpinner() {
  const meshRef = useRef<THREE.Mesh>(null!);
  useFrame((_, delta) => {
    meshRef.current.rotation.z += delta * 2;
  });
  
  return (
    <mesh ref={meshRef}>
      <torusGeometry args={[1, 0.2, 16, 32]} />
      <meshBasicMaterial color="white" wireframe />
    </mesh>
  );
}
```

## Dependencies

```json
{
  "dependencies": {
    "@react-three/fiber": "^8.15.0",
    "three": "^0.160.0",
    "react": "^18.2.0",
    "react-dom": "^18.2.0"
  },
  "devDependencies": {
    "@types/three": "^0.160.0"
  }
}
```

## File Structure

```
r3f-fundamentals/
├── SKILL.md
├── references/
│   ├── canvas-props.md       # Complete Canvas prop reference
│   ├── hooks-api.md          # useThree, useFrame, useLoader
│   └── event-system.md       # Event handling deep-dive
└── scripts/
    ├── templates/
    │   ├── basic-scene.tsx   # Minimal starter
    │   ├── lit-scene.tsx     # With proper lighting
    │   └── interactive.tsx   # With events and animation
    └── utils/
        └── canvas-config.ts  # Preset configurations
```

## Reference

- `references/canvas-props.md` — Complete Canvas configuration options
- `references/hooks-api.md` — All R3F hooks with examples
- `references/event-system.md` — Pointer events and raycasting

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

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

Все скиллы по теме «Фронтенд и UI» →

Сначала — r3f-fundamentals от других авторов.

r3f-fundamentals EnzeD Скилл r3f-fundamentals учит агента строить сцены React Three Fiber: Canvas, типизированный JSX, хуки рендер-цикла и владение ресурсами. Для базовой архитектуры сцены, не для детальных материалов. CX Codex +1 2 400установок react-three-fiber Claude Design Skillstack Плагин для Claude ведёт разработку трёхмерных сцен на React Three Fiber: это рендерер Three.js, где объекты и свет описываются компонентами React. ★ 1 428звёзд репо r3f-best-practices three-agent-skills Скилл r3f-best-practices для Claude Code содержит 70+ правил для написания, ревью и ускорения кода на React Three Fiber. Помогает избегать частых перерисовок и работать со стеком Poimandres. CX Codex +1 1 700установок threejs-fundamentals calesthio Скилл threejs-fundamentals помогает собирать Three.js-сцены, настраивать камеры и рендерер, а также управлять иерархией объектов и трансформациями. CX Codex +1 1 200установок r3f-postprocessing EnzeD Скилл r3f-postprocessing для Claude Code разбирает постобработку в React Three Fiber: блум по выбранным объектам, глубину резкости, SSAO и управление цветом после рендера. CX Codex +1 2 300установок r3f-loaders EnzeD Скилл r3f-loaders помогает загружать и переиспользовать 3D-модели в React Three Fiber. Настраивает хуки, предзагрузку, клонирование объектов и показ заглушек. CX Codex +1 2 100установок threejs-r3f AThevon Скилл threejs-r3f для Claude Code помогает создавать 3D-сцены на Three.js и React Three Fiber. Даёт рекомендации по шейдерам, постобработке и производительности. CX Codex +1 1 000установок

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

Весь набор →
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установок shader-noise Скилл shader-noise для Claude Code даёт GLSL-функции процедурного шума для генерации текстур, ландшафтов, облаков и клеточных узоров в шейдерах. CX Codex +1 121установок form-ux-patterns Скилл form-ux-patterns для Claude Code помогает проектировать сложные формы: группировать поля, строить пошаговые сценарии и показывать условные поля. Охватывает оформление заказа и онбординг. CX Codex +1 120установок audio-reactive Скилл audio-reactive связывает частотный анализ звука с анимацией интерфейса, частицами и 3D-сценами. CX Codex +1 108установок postfx-effects Скилл postfx-effects для Claude Code собирает рецепты пост-эффектов для сцен на React Three Fiber: глубину резкости, виньетирование и ретро-стили. CX Codex +1 106установок

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

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