nexu-io/open-design / plugins/_official/examples/motion-future
motion-future
UnverifiedThe Future Is Already Here — motion design template. A 20-second electric-blue tech reel, rebuilt from the viral original: 3D cubes, a word tunnel, liquid chrome type, a FUTURE.EXE desktop, a countdown, glass objects and a chrome FUTURE hero, cut to 120 BPM.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 7.4 KB |
| assets/cover.jpg | binary | 161.8 KB |
| assets/gsap.min.js | script | 70.5 KB |
| assets/jetbrains-mono-OFL.txt | markdown | 4.3 KB |
| assets/jetbrains-mono-subset.ttf | binary | 89.8 KB |
| assets/soundtrack.mp3 | binary | 235.1 KB |
| assets/three-addons.js | script | 13.9 KB |
| assets/three.min.js | script | 654.2 KB |
| assets/three.min.js.gz | binary | 162.7 KB |
| assets/unbounded-OFL.txt | markdown | 4.3 KB |
| assets/unbounded-black-glyphs.js | script | 26.9 KB |
| assets/unbounded-subset.ttf | binary | 137.5 KB |
| example.html | other | 65.7 KB |
| open-design.json | config | 24.4 KB |
assets/three-addons.js
View on GitHub// three.js add-ons used by the film, unbundled and readable.
// Source: three.js r185, examples/jsm (MIT License, Copyright 2010-2025 three.js authors).
// They run against the page's global THREE (assets/three.min.js r160) and
// expose RoomEnvironment, FontLoader, Font and TextGeometry on window.THREEAddons.
window.THREEAddons = window.THREEAddons || {};
// ---- three.js r185 examples/jsm/environments/RoomEnvironment.js (MIT) ----
(function () {
const { BackSide, BoxGeometry, InstancedMesh, Mesh, MeshLambertMaterial, MeshStandardMaterial, PointLight, Scene, Object3D } = THREE;
/**
* This class represents a scene with a basic room setup that can be used as
* input for {@link PMREMGenerator#fromScene}. The resulting PMREM represents the room's
* lighting and can be used for Image Based Lighting by assigning it to {@link Scene#environment}
* or directly as an environment map to PBR materials.
*
* The implementation is based on the [EnvironmentScene](https://github.com/google/model-viewer/blob/master/packages/model-viewer/src/three-components/EnvironmentScene.ts)
* component from the `model-viewer` project.
*
* ```js
* const environment = new RoomEnvironment();
* const pmremGenerator = new THREE.PMREMGenerator( renderer );
*
* const envMap = pmremGenerator.fromScene( environment ).texture;
* scene.environment = envMap;
* ```
*
* @augments Scene
* @three_import import { RoomEnvironment } from 'three/addons/environments/RoomEnvironment.js';
*/
class RoomEnvironment extends Scene {
constructor() {
super();
this.name = 'RoomEnvironment';
this.position.y = - 3.5;
const geometry = new BoxGeometry();
geometry.deleteAttribute( 'uv' );
const roomMaterial = new MeshStandardMaterial( { side: BackSide } );
const boxMaterial = new MeshStandardMaterial();
const mainLight = new PointLight( 0xffffff, 900, 28, 2 );
mainLight.position.set( 0.418, 16.199, 0.300 );
this.add( mainLight );
const room = new Mesh( geometry, roomMaterial );
room.position.set( - 0.757, 13.219, 0.717 );
room.scale.set( 31.713, 28.305, 28.591 );
this.add( room );
const boxes = new InstancedMesh( geometry, boxMaterial, 6 );
const transform = new Object3D();
// box1
transform.position.set( - 10.906, 2.009, 1.846 );
transform.rotation.set( 0, - 0.195, 0 );
transform.scale.set( 2.328, 7.905, 4.651 );
transform.updateMatrix();
boxes.setMatrixAt( 0, transform.matrix );
// box2
transform.position.set( - 5.607, - 0.754, - 0.758 );
transform.rotation.set( 0, 0.994, 0 );
transform.scale.set( 1.970, 1.534, 3.955 );
transform.updateMatrix();
boxes.setMatrixAt( 1, transform.matrix );
// box3
transform.position.set( 6.167, 0.857, 7.803 );
transform.rotation.set( 0, 0.561, 0 );
transform.scale.set( 3.927, 6.285, 3.687 );
transform.updateMatrix();
boxes.setMatrixAt( 2, transform.matrix );
// box4
transform.position.set( - 2.017, 0.018, 6.124 );
transform.rotation.set( 0, 0.333, 0 );
transform.scale.set( 2.002, 4.566, 2.064 );
transform.updateMatrix();
boxes.setMatrixAt( 3, transform.matrix );
// box5
transform.position.set( 2.291, - 0.756, - 2.621 );
transform.rotation.set( 0, - 0.286, 0 );
transform.scale.set( 1.546, 1.552, 1.496 );
transform.updateMatrix();
boxes.setMatrixAt( 4, transform.matrix );
// box6
transform.position.set( - 2.193, - 0.369, - 5.547 );
transform.rotation.set( 0, 0.516, 0 );
transform.scale.set( 3.875, 3.487, 2.986 );
transform.updateMatrix();
boxes.setMatrixAt( 5, transform.matrix );
this.add( boxes );
// -x right
const light1 = new Mesh( geometry, createAreaLightMaterial( 50 ) );
light1.position.set( - 16.116, 14.37, 8.208 );
light1.scale.set( 0.1, 2.428, 2.739 );
this.add( light1 );
// -x left
const light2 = new Mesh( geometry, createAreaLightMaterial( 50 ) );
light2.position.set( - 16.109, 18.021, - 8.207 );
light2.scale.set( 0.1, 2.425, 2.751 );
this.add( light2 );
// +x
const light3 = new Mesh( geometry, createAreaLightMaterial( 17 ) );
light3.position.set( 14.904, 12.198, - 1.832 );
light3.scale.set( 0.15, 4.265, 6.331 );
this.add( light3 );
// +z
const light4 = new Mesh( geometry, createAreaLightMaterial( 43 ) );
light4.position.set( - 0.462, 8.89, 14.520 );
light4.scale.set( 4.38, 5.441, 0.088 );
this.add( light4 );
// -z
const light5 = new Mesh( geometry, createAreaLightMaterial( 20 ) );
light5.position.set( 3.235, 11.486, - 12.541 );
light5.scale.set( 2.5, 2.0, 0.1 );
this.add( light5 );
// +y
const light6 = new Mesh( geometry, createAreaLightMaterial( 100 ) );
light6.position.set( 0.0, 20.0, 0.0 );
light6.scale.set( 1.0, 0.1, 1.0 );
this.add( light6 );
}
/**
* Frees internal resources. This method should be called
* when the environment is no longer required.
*/
dispose() {
const resources = new Set();
this.traverse( ( object ) => {
if ( object.isMesh ) {
resources.add( object.geometry );
resources.add( object.material );
}
} );
for ( const resource of resources ) {
resource.dispose();
}
}
}
function createAreaLightMaterial( intensity ) {
// create an emissive-only material. see #31348
const material = new MeshLambertMaterial( {
color: 0x000000,
emissive: 0xffffff,
emissiveIntensity: intensity
} );
return material;
}
Object.assign(window.THREEAddons, { RoomEnvironment });
})();
// ---- three.js r185 examples/jsm/loaders/FontLoader.js (MIT) ----
(function () {
const { FileLoader, Loader, ShapePath } = THREE;
/**
* A loader for loading fonts.
*
* You can convert fonts online using [facetype.js](https://gero3.github.io/facetype.js/).
*
* ```js
* const loader = new FontLoader();
* const font = await loader.loadAsync( 'fonts/helvetiker_regular.typeface.json' );
* ```
*
* @augments Loader
* @three_import import { FontLoader } from 'three/addons/loaders/FontLoader.js';
*/
class FontLoader extends Loader {
/**
* Constructs a new font loader.
*
* @param {LoadingManager} [manager] - The loading manager.
*/
constructor( manager ) {
super( manager );
}
/**
* Starts loading from the given URL and passes the loaded font
* to the `onLoad()` callback.
*
* @param {string} url - The path/URL of the file to be loaded. This can also be a data URI.
* @param {function(Font)} onLoad - Executed when the loading process has been finished.
* @param {onProgressCallback} onProgress - Executed while the loading is in progress.
* @param {onErrorCallback} onError - Executed when errors occur.
*/
load( url, onLoad, onProgress, onError ) {
const scope = this;
const loader = new FileLoader( this.manager );
loader.setPath( this.path );
loader.setRequestHeader( this.requestHeader );
loader.setWithCredentials( this.withCredentials );
loader.load( url, function ( text ) {
const font = scope.parse( JSON.parse( text ) );
if ( onLoad ) onLoad( font );
}, onProgress, onError );
}
/**
* Parses the given font data and returns the resulting font.
*
* @param {Object} json - The raw font data as a JSON object.
* @return {Font} The font.
*/
parse( json ) {
return new Font( json );
}
}
/**
* Class representing a font.
*/
class Font {
/**
* Constructs a new font.
*
* @param {Object} data - The font data as JSON.
*/
constructor( data ) {
/**
* This flag can be used for type testing.
*
* @type {boolean}
* @readonly
* @default true
*/
this.isFont = true;
this.type = 'Font';
/**
* The font data as JSON.
*
* @type {Object}
*/
this.data = data;
}
/**
* Generates geometry shapes from the given text and size. The result of this method
* should be used with {@link ShapeGeometry} to generate the actual geometry data.
*
* @param {string} text - The text.
* @param {number} [size=100] - The text size.
* @param {string} [direction='ltr'] - Char direction: ltr(left to right), rtl(right to left) & tb(top bottom).
* @return {Array<Shape>} An array of shapes representing the text.
*/
generateShapes( text, size = 100, direction = 'ltr' ) {
const shapes = [];
const paths = createPaths( text, size, this.data, direction );
for ( let p = 0, pl = paths.length; p < pl; p ++ ) {
shapes.push( ...paths[ p ].toShapes() );
}
return shapes;
}
}
function createPaths( text, size, data, direction ) {
const chars = Array.from( text );
const scale = size / data.resolution;
const line_height = ( data.boundingBox.yMax - data.boundingBox.yMin + data.underlineThickness ) * scale;
const paths = [];
let offsetX = 0, offsetY = 0;
if ( direction == 'rtl' || direction == 'tb' ) {
chars.reverse();
}
for ( let i = 0; i < chars.length; i ++ ) {
const char = chars[ i ];
if ( char === '\n' ) {
offsetX = 0;
offsetY -= line_height;
} else {
const ret = createPath( char, scale, offsetX, offsetY, data );
if ( direction == 'tb' ) {
offsetX = 0;
offsetY += data.ascender * scale;
} else {
offsetX += ret.offsetX;
}
paths.push( ret.path );
}
}
return paths;
}
function createPath( char, scale, offsetX, offsetY, data ) {
const glyph = data.glyphs[ char ] || data.glyphs[ '?' ];
if ( ! glyph ) {
console.error( 'THREE.Font: character "' + char + '" does not exists in font family ' + data.familyName + '.' );
return;
}
const path = new ShapePath();
let x, y, cpx, cpy, cpx1, cpy1, cpx2, cpy2;
if ( glyph.o ) {
const outline = glyph._cachedOutline || ( glyph._cachedOutline = glyph.o.split( ' ' ) );
for ( let i = 0, l = outline.length; i < l; ) {
const action = outline[ i ++ ];
switch ( action ) {
case 'm': // moveTo
x = outline[ i ++ ] * scale + offsetX;
y = outline[ i ++ ] * scale + offsetY;
path.moveTo( x, y );
break;
case 'l': // lineTo
x = outline[ i ++ ] * scale + offsetX;
y = outline[ i ++ ] * scale + offsetY;
path.lineTo( x, y );
break;
case 'q': // quadraticCurveTo
cpx = outline[ i ++ ] * scale + offsetX;
cpy = outline[ i ++ ] * scale + offsetY;
cpx1 = outline[ i ++ ] * scale + offsetX;
cpy1 = outline[ i ++ ] * scale + offsetY;
path.quadraticCurveTo( cpx1, cpy1, cpx, cpy );
break;
case 'b': // bezierCurveTo
cpx = outline[ i ++ ] * scale + offsetX;
cpy = outline[ i ++ ] * scale + offsetY;
cpx1 = outline[ i ++ ] * scale + offsetX;
cpy1 = outline[ i ++ ] * scale + offsetY;
cpx2 = outline[ i ++ ] * scale + offsetX;
cpy2 = outline[ i ++ ] * scale + offsetY;
path.bezierCurveTo( cpx1, cpy1, cpx2, cpy2, cpx, cpy );
break;
}
}
}
return { offsetX: glyph.ha * scale, path: path };
}
Object.assign(window.THREEAddons, { FontLoader, Font });
})();
// ---- three.js r185 examples/jsm/geometries/TextGeometry.js (MIT) ----
(function () {
const { Font } = window.THREEAddons;
const { ExtrudeGeometry } = THREE;
/**
* A class for generating text as a single geometry. It is constructed by providing a string of text, and a set of
* parameters consisting of a loaded font and extrude settings.
*
* See the {@link FontLoader} page for additional details.
*
* `TextGeometry` uses [typeface.json](http://gero3.github.io/facetype.js/) generated fonts.
* Some existing fonts can be found located in `/examples/fonts`.
*
* ```js
* const loader = new FontLoader();
* const font = await loader.loadAsync( 'fonts/helvetiker_regular.typeface.json' );
* const geometry = new TextGeometry( 'Hello three.js!', {
* font: font,
* size: 80,
* depth: 5,
* curveSegments: 12
* } );
* ```
*
* @augments ExtrudeGeometry
* @three_import import { TextGeometry } from 'three/addons/geometries/TextGeometry.js';
*/
class TextGeometry extends ExtrudeGeometry {
/**
* Constructs a new text geometry.
*
* @param {string} text - The text that should be transformed into a geometry.
* @param {TextGeometry~Options} [parameters] - The text settings.
*/
constructor( text, parameters = {} ) {
const font = parameters.font;
if ( font === undefined ) {
super(); // generate default extrude geometry
} else {
const shapes = font.generateShapes( text, parameters.size, parameters.direction );
// defaults
if ( parameters.depth === undefined ) parameters.depth = 50;
if ( parameters.bevelThickness === undefined ) parameters.bevelThickness = 10;
if ( parameters.bevelSize === undefined ) parameters.bevelSize = 8;
if ( parameters.bevelEnabled === undefined ) parameters.bevelEnabled = false;
super( shapes, parameters );
}
this.type = 'TextGeometry';
}
toJSON() {
const data = super.toJSON();
return data;
}
static fromJSON( data ) {
const options = data.options;
options.font = new Font( options.font.data );
return new TextGeometry( options.text, options );
}
}
/**
* Represents the `options` type of the geometry's constructor.
*
* @typedef {Object} TextGeometry~Options
* @property {Font} [font] - The font.
* @property {number} [size=100] - The text size.
* @property {number} [depth=50] - Depth to extrude the shape.
* @property {number} [curveSegments=12] - Number of points on the curves.
* @property {number} [steps=1] - Number of points used for subdividing segments along the depth of the extruded spline.
* @property {boolean} [bevelEnabled=false] - Whether to beveling to the shape or not.
* @property {number} [bevelThickness=10] - How deep into the original shape the bevel goes.
* @property {number} [bevelSize=8] - Distance from the shape outline that the bevel extends.
* @property {number} [bevelOffset=0] - Distance from the shape outline that the bevel starts.
* @property {number} [bevelSegments=3] - Number of bevel layers.
* @property {string} [direction='ltr'] - Char direction: ltr(left to right), rtl(right to left) & tb(top bottom).
* @property {?Curve} [extrudePath=null] - A 3D spline path along which the shape should be extruded. Bevels not supported for path extrusion.
* @property {Object} [UVGenerator] - An object that provides UV generator functions for custom UV generation.
**/
Object.assign(window.THREEAddons, { TextGeometry });
})();
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| brainstormingobra/superpowersYou MUST use this before any creative work - creating features, building components, adding functionality, modifying behavior, or planning anything new, in software or out of it (a talk, a business, a renovation). | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| brand-guidelinesanthropics/skillsApplies Anthropic's official brand colors and typography to any sort of artifact that may benefit from having Anthropic's look-and-feel. Use it when brand colors or style guidelines, visual formatting, or company design standards apply. | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |
| frontend-designanthropics/skillsGuidance for distinctive, intentional visual design when building new UI or reshaping an existing one. Helps with aesthetic direction, typography, and making choices that don't read as templated defaults. | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |
| mcp-builderanthropics/skillsGuide for creating high-quality MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools. Use when building MCP servers to integrate external APIs or services, whether in Python (FastMCP) or Node/TypeScript (MCP SDK). | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |