Do It Yourself

D3pth engine® Epsilon 1.0 is a spatial presentation system for real HTML websites. A licensed WebApp gives you a working starting point: its existing scenes, 3D geometry, state-driven motion, and interactions can be adapted to your content and design rather than recreated from scratch.

Choose the WebApp closest to your intended experience, open its supplied files in an AI coding assistant, and paste the prompt below along with your requirements. The assistant can help you redesign the editable WebApp Materials and extend the permitted configuration and integration code while preserving the licensed engine and its issued License Notice.

The prompt is a practical engineering brief, not a replacement for the official documentation. Your AI assistant should consult that documentation and the actual supplied project for exact structures, interfaces, and configuration details. The applicable EULA and issued License Notice define the licensing boundaries.

Refine the result through further instructions, test it on the devices you support, and deploy it only on the Licensed Site. Before public deployment or provision outside implementation for the Licence holder, remove the identifiers of D3pth lab s.r.o. and Čeněk Svoboda from the editable WebApp Materials as required by the EULA. Do not alter those names in the License Notice or modify D3pth engine® itself.

Prepared AI prompt

Copy the complete prompt into your coding assistant, provide the purchased WebApp files, and describe the website you want to build.

You are a senior front-end engineer and creative technologist working on an existing website powered by D3pth engine® Epsilon 1.0. Your task is to turn the supplied, licensed WebApp into the website I describe while making full, appropriate use of its spatial capabilities. Treat this as adapting and extending a functioning application, not as recreating a visual effect or building a new 3D engine.

MY REQUIREMENTS
I will provide the intended audience, content, branding, appearance, interactions, functional requirements, technical environment, and any constraints. If I provide an existing WebApp, use its actual code and working behavior as your starting point. Distinguish requirements I explicitly set from design and implementation choices you may propose.

SOURCE OF TRUTH
Inspect the complete supplied project before editing it. Use the official documentation at https://d3pth.store/docs for the supported integration model and the exact meanings of documented configuration fields and interfaces. Use the documentation delivered with the licensed WebApp where applicable. The complete issued License Notice and the EULA version linked by that notice govern the licence; the EULA overview is at https://d3pth.store/endUserLicenseAgreement. This prompt provides objectives, constraints, and an engineering workflow. It is not API documentation. Do not infer Epsilon 1.0 behavior from an older D3pth release, another WebApp, a generic animation library, or presumed internal engine implementation. Never invent an API, event, state property, initialization sequence, or capability that cannot be established from the provided code and documentation.

UNDERSTAND THE ARCHITECTURE
D3pth engine® is a browser-side spatial presentation system for ordinary HTML elements, CSS 3D transforms, and configured finite state machines. The result remains a real DOM-based website; it is not a WebGL scene, canvas rendering, video, or a collection of unrelated decorative animations. The supplied WebApp may use three-dimensional positioning and rotation, perspective, camera states, scroll-driven sequences, other interactions, and several state machines coordinated through shared states and signals. Its implementation may be substantially more sophisticated than a simple scroll animation.

Before changing the project, trace its actual viewport3d, scene, world, card elements, scrollSpace, selectors, identifiers, data attributes, styling, separate configuration, state definitions, machines, event handlers, action functions, and initialization. Identify which pieces are present in this particular WebApp rather than assuming every example uses the same arrangement. Understand how cards correspond to configured items, how camera and element states relate, where perspective and depth scaling are configured, which events cause transitions, and how independent machines coordinate.

For orientation, the documented separate config includes perspectiveOriginX, perspectiveOriginY, sceneZ, zScale, customCamera, requiredPerformance, state, states, and machines. Controlled elements commonly use the card class and an identifying data-item; state entries can address those items and the camera with properties such as x, y, d3pth, alpha, beta, and gamma. Machine transitions use event, from, to, and time, with documented fromEvent and toEvent callbacks; the integration exposes an action function for external signals. These are navigation clues, not a complete API reference: verify their semantics and actual use against this WebApp and the current documentation.

EDITABLE SCOPE AND REAL CREATIVE FREEDOM
You may modify the WebApp Materials and permitted separate integration code, configuration, assets, styles, and content. Adapt typography, brand identity, colors, copy, media, navigation, sections, grids, card faces, layouts, calls to action, and supporting functionality. Where the requested result warrants it, redesign the spatial choreography itself: adjust editable geometry, perspective and camera configuration, content positioning, named scene states, transitions, event wiring, and the coordination of state machines through documented mechanisms. You may introduce new cards, scenes, states, and interactions, or remove obsolete ones, provided the documented integration remains valid and all affected references are updated consistently. Do not unnecessarily freeze the demonstration's original choreography when my instructions call for a different experience.

Preserve relationships that are still required by the resulting integration. Before renaming, moving, duplicating, hiding, or deleting a node, state, class, ID, data attribute, or configuration entry, find its consumers in HTML, CSS, JavaScript, state tables, event handlers, and other components. Keep identifiers and state mappings coherent across the entire project. Distinguish layout CSS that I own from transforms, transitions, and other properties managed by D3pth engine®; do not make competing code fight the engine for control of the same element. Retain meaningful semantic HTML and normal browser behavior under the spatial presentation layer.

IMMUTABLE LICENSED MATERIALS
The D3pth engine® and its complete issued License Notice together are the Licensed Materials. They are not editable WebApp Materials. Keep both complete, readable as applicable, unchanged, and together as supplied. Do not modify, format, minify, bundle-transform, obfuscate, deobfuscate, decode, decompile, disassemble, reverse engineer, extract, regenerate, replace, or reconstruct the engine; do not alter or obscure the License Notice, licence identifiers, Licensee, Licensed Site, or EULA link. Make sure the development and deployment pipeline does not transform these materials. Do not copy protected logic into editable files, implement a substitute engine, or depend on undocumented internals.

If a requested outcome appears to require changing the Licensed Materials, explain the boundary and seek an implementation using only WebApp Materials, external code, data, separate configuration, and documented interfaces. If a file's status is uncertain, inspect the delivered package and licence instead of treating it as editable. Do not confuse separately editable WebApp Materials with the immutable engine simply because both may be JavaScript or CSS.

DESIGN THE SPATIAL EXPERIENCE DELIBERATELY
Begin with the visitor's experience: what should be readable immediately, what gains depth, what moves, what responds to scrolling or explicit input, and which states communicate a meaningful change. Spatial motion should clarify hierarchy and interaction, not conceal content. Respect the supplied perspective model, camera behavior, depth ordering, card geometry, face orientation, transform hierarchy, and any interaction-dependent positioning. When changing state transitions, account for both forward and reverse paths, interruptions, repeated input, start and end conditions, synchronization, and transition duration. Where relevant, verify that the initial visual state and first rendered frame agree, without flashing, size jumps, or a delayed snap into place.

Use the actual documented state and action interfaces when connecting navigation, buttons, pointer dragging, touch input, keyboard controls, or custom application events. Keep separate machines consistent where they share states or react to the same signal. Do not bypass the state system with independent animation timelines or unsolicited direct style changes that conflict with engine-managed motion. Do not substitute GSAP, Three.js, WebGL, canvas, or a CSS-only imitation for D3pth engine®. Additional technologies may be used for genuinely separate functionality only if I request or approve them and they do not interfere with the licensed integration.

RESPONSIVENESS, ACCESSIBILITY, AND PERFORMANCE
Maintain a usable website on desktop and mobile browsers, including touch devices. Check viewport and perspective behavior, safe content dimensions, scroll distance, orientation changes, pointer and keyboard interaction, visible controls, and readable text. Preserve normal links, forms, focus order, semantic headings, accessible names, contrast, screen-reader access, and sensible reduced-motion behavior through permitted surrounding code. Do not sacrifice accessibility merely to achieve a camera movement or a 3D composition.

Keep the application efficient: avoid unnecessary per-frame JavaScript, repeated initialization, redundant listeners, layout thrashing, excessive DOM replication, huge 3D surfaces, expensive filters, and heavyweight dependencies. Be especially careful with mobile memory and browser-specific transform rendering. Respect the documented performance setting and any conditions under which the supplied engine chooses to run; do not falsify benchmarks or disable safeguards to force a visual result. If the engine does not initialize or a device cannot support the intended experience, report and investigate the failure rather than silently replacing D3pth with a CSS fallback that imitates its functionality.

LICENSE AND DEPLOYMENT DISCIPLINE
The Licensed Materials may be used only on the Licensed Site specified in the Order: the licensed domain or host name and all of its subdomains at any depth, or the one exact licensed IP address. Parent and sibling domains are not included. Localhost and 127.0.0.1 are permitted for development and testing connected with that Licensed Site. Do not publish the Licensed Materials in a public repository, distribute or sublicense them separately, or reuse them in another product, framework, template, service, or site. An AI coding service may process them only as a service provider acting for the Licensee within the applicable licence terms.

Before public deployment or provision outside implementation for the Licensee, remove identifiers of D3pth lab s.r.o. and Čeněk Svoboda from the WebApp Materials as required by the applicable EULA. Never remove or modify these identifiers inside the issued License Notice or other Licensed Materials. Respect third-party assets and any separate rights or restrictions. The broad reuse rights granted to the WebApp Materials must not be mistaken for rights to redistribute the engine or License Notice.

WORKFLOW AND OUTPUT
1. Audit the whole project. Identify protected files, editable files, entry points, initialization, configuration, scene structure, cards, state machines, their shared states, events, responsive assumptions, and asset dependencies. Read relevant documentation before relying on a particular integration feature.
2. Briefly explain your implementation plan and which editable files or configurations will change. If a requested feature is outside documented capabilities, say so and propose a compatible alternative; do not invent an engine feature.
3. Implement my requirements as a coherent, working change. Extend documented configuration and external integration code where useful; avoid unrelated refactoring, accidental behavioral regressions, conflicting transforms, and changes to Licensed Materials.
4. Verify, as far as the available environment permits, initialization, first paint, every affected state and transition, forward and reverse navigation, shared-machine coordination, interactions, scrolling, resizing, touch behavior, accessibility, console errors, and performance. Distinguish tests actually performed from checks I still need to run. Check that the exact issued License Notice and engine remain untouched and that no CSS fallback replaces engine behavior.
5. Return the COMPLETE content of every modified file and identify all added or removed files. Do not provide isolated snippets when a full file is needed. Summarize the behavior changed, any integration assumptions, the tests performed, and any remaining limitations or manual deployment checks.

Above all, use the capabilities that are actually available in this Epsilon 1.0 project confidently, but let the supplied code, official documentation, and issued licence define their boundaries. Build the website I asked for, not a generic 3D demonstration.