Split (1)

train · 399k rows

language stringclasses 1 value	owner stringlengths 2 15	repo stringlengths 2 21	sha stringlengths 45 45	message stringlengths 7 36.3k	path stringlengths 1 199	patch stringlengths 15 102k	is_multipart bool 2 classes
Other	mrdoob	three.js	2b64f57cb1a75d156e7fdc0cf87207adb4cf38d0.json	add translation kr/threejs-offscreencanvas.md	threejs/lessons/kr/threejs-offscreencanvas.md	@@ -0,0 +1,1057 @@ +Title: Three.js OffscreenCanvas +Description: Three.js에서 웹 워커를 활용하는 법을 알아봅니다 +TOC: 웹 워커에서 OffscreenCanvas 사용하기 + +[`OffscreenCanvas`](https://developer.mozilla.org/ko/docs/Web/API/OffscreenCanvas)는 비교적 최근 도입된 브라우저 API로 아직 크로미움 기반 브라우저에서만 사용가능하지만, 갈수록 대부분의 브라우저에서 이 API를 사용할 수 있을 겁니다. `OffscreenCanvas`를 이용하면 [웹 워커(Web Worker)](https://developer.mozilla.org/ko/docs/Web/API/Web_Workers_API)에서 캔버스를 렌더링해 복잡한 3D 장면 등의 무거운 작업을 별도 프로세스에서 처리할 수 있습니다. 이러면 무거운 작업을 처리할 때 브라우저가 덜 버벅이도록 할 수 있죠. 또한 데이터도 워커에서 불러와 처리하므로 페이지 초기 로드 시 버벅임을 훨씬 줄일 수 있습니다. + +OffscreenCanvas의 문제점 중 하나는 웹 워커가 아직 ES 모듈(import, export 키워드 등)을 지원하지 않는다는 겁니다. 때문에 다른 예제와 달리 이 글에서는 클래스 스크립트 방식을 사용할 겁니다. + +사용법은 꽤나 직관적입니다. 먼저 [반응형 디자인에 관한 글](threejs-responsive.html)에서 썼던 예제를 가져오도록 하죠. + +이 사이트 대부분의 예제는 스크립트를 해당 HTML 파일에 인라인으로 작성했습니다. 반면에 워커는 일반적으로 별도의 스크립트 파일로 분리해 작성합니다. + +이 글에서는 `offscreencanvas-cubes.js`라는 별도 파일을 만들어 [반응형 디자인에서 가져온 예제](threejs-responsive.html)의 자바스크립트 코드를 전부 복사해 넣을 겁니다. 그런 다음 바꿔야할 부분을 바꿔보도록 하죠. + +하지만 여전히 HTML 파일에 약간의 자바스크립트 코드가 필요합니다. 캔버스 요소를 참조하고 `canvas.transferControlToOffscreen` 메서드를 호출해 캔버스의 제어권을 `offscreen`에 넘겨줍니다. + +```js +function main() { + const canvas = document.querySelector('#c'); + const offscreen = canvas.transferControlToOffscreen(); + + ... +``` + +그리고 `new Worker(워커 스크립트 경로)`로 워커를 생성한 뒤, 워커에 `offscreen` 객체를 넘깁니다. + +```js +function main() { + const canvas = document.querySelector('#c'); + const offscreen = canvas.transferControlToOffscreen(); + const worker = new Worker('offscreencanvas-cubes.js'); + worker.postMessage({ type: 'main', canvas: offscreen }, [ offscreen ]); +} +main(); +``` + +스크립트를 따로 써야 하는 이유는 워커 안에서는 `DOM`에 접근할 수 없기 때문입니다. HTML 요소를 참조하거나 DOM 요소의 이벤트를 받을 수도 없죠. 일반적으로 메시지 이벤트를 통해서만 다른 스크립트와 통신할 수 있습니다. + +워커에 메시지를 보내려면 [`worker.postMessage`](https://developer.mozilla.org/ko/docs/Web/API/Worker/postMessage)에 하나 또는 두 개의 인자를 넘겨주어 호출하면 됩니다. 첫 번째 인자는 워커에 전달할 객체로, 이 객체는 그대로 전달되지 않고 [복사됩니다](https://developer.mozilla.org/ko/docs/Web/API/Web_Workers_API/Structured_clone_algorithm). 두 번째 인자는 옵션으로 첫 번째 인자 중 그대로 전달하기 원하는 객체를 배열로 지정합니다. 여기에 지정한 객체는 복사되지 않죠. 그대로 워커에 전달되지만 객체를 보낸 스크립트에서는 더 이상 사용이 불가능해집니다. 이것도 모든 객체를 전달할 수 있는 게 아니라 특정 타입의 객체만을 전달할 수 있죠. 당연하게도 이 중에는 `OffscreenCanvas`도 있습니다. 정리하자면 `offscreen` 객체를 전달하고 나면 이 객체는 이 스크립트에서 더 이상 쓸모가 없어집니다. + +워커의 `message` 이벤트를 이용하면 메시지를 받을 수 있습니다. `postMessage`에서 넘긴 객체는 `event.data`에 담겨 리스너에 전달되죠. 아까 위 코드에서는 `type: 'main'` 속성을 객체에 선언해 워커에 넘겨줬습니다. 이 `type` 속성으로 워커 내에 다른 함수를 호출하도록 해봅시다. 이러면 메인 스크립트에서 워커 내의 함수를 호출하기가 훨씬 쉬워질 겁니다. + +```js +const handlers = { + main, +}; + +self.onmessage = function(e) { + const fn = handlers[e.data.type]; + if (!fn) { + throw new Error('no handler for type: ' + e.data.type); + } + fn(e.data); +}; +``` + +`type` 값을 통해 호출할 함수를 찾고, 함수가 있다면 메인 스크립트에서 넘어온 `data`를 인자로 넘겨 호출하도록 했습니다. + +이제 [반응형 디자인에 관한 글](threejs-responsive.html)에서 가져온 예제의 `main` 함수를 수정해야 합니다. + +물론 그전에 먼저 Three.js를 `offscreencanvas-cubes.js`에 불러와야겠죠. + +```js +importScripts('resources/threejs/r115/build/three.min.js'); +``` + +DOM에서 캔버스에 접근하는 대신 이벤트의 `data`에서 캔버스를 받습니다. + +```js +-function main() { +- const canvas = document.querySelector('#c'); ++function main(data) { ++ const { canvas } = data; + const renderer = new THREE.WebGLRenderer({ canvas }); + + ... + +``` + +워커에서는 DOM에 접근할 수 없다고 했었죠. 마찬가지로 DOM 속성인 `canvas.clientWidth`나 `canvas.clientHeight`에도 접근할 수 없습니다. `resizeRendererToDisplaySize`를 그대로 사용할 수 없는 것이죠. + +```js +function resizeRendererToDisplaySize(renderer) { + const canvas = renderer.domElement; + const width = canvas.clientWidth; + const height = canvas.clientHeight; + const needResize = canvas.width !== width \|\| canvas.height !== height; + if (needResize) { + renderer.setSize(width, height, false); + } + return needResize; +} +``` + +대신 캔버스 크기가 변경될 때마다 워커에 메시지를 보낼 겁니다. 워커에 전역 변수를 하나 생성해 여기에 width와 height 값을 지정하도록 하죠. + +```js +const state = { + width: 300, // 캔버스 기본값 + height: 150, // 캔버스 기본값 +}; +``` + +그리고 `size`라는 함수를 만들어 해당 값을 업데이트하도록 합니다. + +```js ++function size(data) { ++ state.width = data.width; ++ state.height = data.height; ++} + +const handlers = { + main, ++ size, +}; +``` + +`resizeRendererToDisplaySize`가 `state.width`와 `state.height`를 쓰도록 변경합니다. + +```js +function resizeRendererToDisplaySize(renderer) { + const canvas = renderer.domElement; +- const width = canvas.clientWidth; +- const height = canvas.clientHeight; ++ const width = state.width; ++ const height = state.height; + const needResize = canvas.width !== width \|\| canvas.height !== height; + if (needResize) { + renderer.setSize(width, height, false); + } + return needResize; +} +``` + +마찬가지로 종횡비를 계산하는 코드도 DOM 속성 대신 `state`를 쓰도록 변경합니다. + +```js +function render(time) { + time = 0.001; + + if (resizeRendererToDisplaySize(renderer)) { +- camera.aspect = canvas.clientWidth / canvas.clientHeight; ++ camera.aspect = state.width / state.height; + camera.updateProjectionMatrix(); + } + + ... +``` + +메인 스크립트로 돌아와 페이지 크기가 바뀔 때마다 워커의 `size` 함수를 실행하도록 합니다. + +```js +const worker = new Worker('offscreencanvas-picking.js'); +worker.postMessage({ type: 'main', canvas: offscreen }, [ offscreen ]); + ++function sendSize() { ++ worker.postMessage({ ++ type: 'size', ++ width: canvas.clientWidth, ++ height: canvas.clientHeight, ++ }); ++} ++ ++window.addEventListener('resize', sendSize); ++sendSize(); +``` + +또한 직접 호출해 최초에 한 번 값을 보내도록 합니다. + +여러분의 브라우저가 `OffscreenCanvas`를 완벽히 지원한다면 이제 문제 없이 작동할 겁니다. 그렇게 많이 바꾼 것이 없는데도 말이죠. 혹시 모르니 브라우저가 `OffscreenCanvas`를 지원하지 않을 경우 에러 메시지를 보여주도록 하겠습니다. 먼저 에러 메시지를 표시할 HTML을 작성합니다. + +```html +<body> + <canvas id="c"></canvas> ++ <div id="noOffscreenCanvas" style="display:none;"> ++ <div>no OffscreenCanvas support</div> ++ </div> +</body> +``` + +간단한 스타일도 넣어주도록 하죠. + +```css +#noOffscreenCanvas { + display: flex; + width: 100vw; + height: 100vh; + align-items: center; + justify-content: center; + background: red; + color: white; +} +``` + +그리고 캔버스 요소에 `transferControlToOffscreen` 메서드가 있는지 확인해 `OffscreenCanvas`의 지원 여부를 확인합니다. + +```js +function main() { + const canvas = document.querySelector('#c'); ++ if (!canvas.transferControlToOffscreen) { ++ canvas.style.display = 'none'; ++ document.querySelector('#noOffscreenCanvas').style.display = ''; ++ return; ++ } + const offscreen = canvas.transferControlToOffscreen(); + const worker = new Worker('offscreencanvas-picking.js'); + worker.postMessage({ type: 'main', canvas: offscreen }, [ offscreen ]); + + ... +``` + +브라우저가 `OffscreenCanvas`를 지원한다면 문제 없이 작동할 겁니다. + +{{{example url="../threejs-offscreencanvas.html" }}} + +하지만 현재 모든 브라우저가 `OffscreenCanvas`를 지원하는 것은 아닙니다. `OffscreenCanvas`를 지원할 경우에만 워커를 사용하도록 하고, 그렇지 않을 경우에는 기존처럼 메인 스크립트에서 렌더링을 처리하도록 하겠습니다. + +> OffscreenCanvas를 단순히 페이지를 반응형으로 만드는 데 사용하는 건 의미없어 보일 수 있습니다. 메인 스크립트에서 반응형을 처리할 때보다 워커에서 처리할 때 오히려 작업이 더 많이 들 수 있거든요. 하지만 메인 스크립트만 사용할 때보다 워커를 사용할 때 자원을 더 넉넉하게 활용할 수 있다는 건 분명합니다. 전적으로 여러분이 상황에 따라 결정할 문제라는 것이죠. + +먼저 Three.js 관련 코드를 분리해 워커 관련 코드와 그렇지 않은 코드로 나눠야 합니다. 같은 코드를 메인 스크립트와 워커에서 모두 쓸 수 있도록 말이죠. 아래와 같이 3개의 파일로 나뉠 겁니다. + +1. html 파일. + + `threejs-offscreencanvas-w-fallback.html` + +2. three.js 관련 자바스크립트 파일. + + `shared-cubes.js` + +3. 워커용 스크립트 + + `offscreencanvas-worker-cubes.js` + +`shared-cubes.js`와 `offscreencanvas-worker-cubes.js`는 단순히 이전 `offscreencanvas-cubes.js` 파일을 쪼갠 것입니다. 메인 HTML 파일에 `main`이라는 함수가 있어 `main` 함수만 `init`으로 바꿨죠. + +`offscreencanvas-worker-cubes.js`의 구조는 아주 단순합니다. + +```js +'use strict'; + +/ global importScripts, init, state / + +importScripts('resources/threejs/r115/build/three.min.js'); ++importScripts('shared-cubes.js'); + +function size(data) { + state.width = data.width; + state.height = data.height; +} + +const handlers = { +- main, ++ init, + size, +}; + +self.onmessage = function(e) { + const fn = handlers[e.data.type]; + if (!fn) { + throw new Error('no handler for type: ' + e.data.type); + } + fn(e.data); +}; +``` + +위 코드에서는 Three.js 관련 스크립트인 `shared-cubes.js`를 불러왔습니다. + +메인 페이지에서도 마찬가지로 Three.js와 `shared-cubes.js`를 추가합니다. + +```html +<script src="resources/threejs/r115/build/three.min.js"></script> +<script src="shared-cubes.js"><script> +``` + +이전에 추가했던 에러 메시지용 HTML과 CSS를 제거합니다. + +```html +<body> + <canvas id="c"></canvas> +- <div id="noOffscreenCanvas" style="display:none;"> +- <div>no OffscreenCanvas support</div> +- </div> +</body> +``` + +```css +-#noOffscreenCanvas { +- display: flex; +- width: 100vw; +- height: 100vh; +- align-items: center; +- justify-content: center; +- background: red; +- color: white; +-} +``` + +그리고 `OffscreenCanvas`의 지원 여부에 따라 다른 함수를 실행하도록 합니다. + +```js +function main() { + const canvas = document.querySelector('#c'); +- if (!canvas.transferControlToOffscreen) { +- canvas.style.display = 'none'; +- document.querySelector('#noOffscreenCanvas').style.display = ''; +- return; +- } +- const offscreen = canvas.transferControlToOffscreen(); +- const worker = new Worker('offscreencanvas-picking.js'); +- worker.postMessage({ type: 'main', canvas: offscreen }, [ offscreen ]); ++ if (canvas.transferControlToOffscreen) { ++ startWorker(canvas); ++ } else { ++ startMainPage(canvas); ++ } + ... +``` + +워커를 만들기 위해 사용했던 코드를 전부 `startWorker` 함수로 옮깁니다. + +```js +function startWorker(canvas) { + const offscreen = canvas.transferControlToOffscreen(); + const worker = new Worker('offscreencanvas-worker-cubes.js'); + worker.postMessage({type: 'init', canvas: offscreen}, [offscreen]); + + function sendSize() { + worker.postMessage({ + type: 'size', + width: canvas.clientWidth, + height: canvas.clientHeight, + }); + } + + window.addEventListener('resize', sendSize); + sendSize(); + + console.log('using OffscreenCanvas'); +} +``` + +워커를 사용할 수 없는 경우 다음과 같이 실행합니다. + +```js +function startMainPage(canvas) { + init({ canvas }); + + function sendSize() { + state.width = canvas.clientWidth; + state.height = canvas.clientHeight; + } + window.addEventListener('resize', sendSize); + sendSize(); + + console.log('using regular canvas'); +} +``` + +이제 `OffscreenCanvas를` 지원하는 경우에만 `OffscreenCanvas`를 사용하고, 지원하지 않는 경우에는 메인 스레드에서 직접 렌더링합니다. + +{{{example url="../threejs-offscreencanvas-w-fallback.html" }}} + +어떤가요? 생각했던 것보다 쉽지 않나요? 여기에 피킹(picking)을 추가해봅시다. [피킹에 관한 글](threejs-picking.html)의 `RayCaster` 예제에서 코드 일부를 가져오도록 하겠습니다. + +먼저 `shared-cube.js`의 코드를 `shared-picking.js`로 복사한 뒤, 피킹 예제에서 `PickHelper`를 가져옵니다. + +```js +class PickHelper { + constructor() { + this.raycaster = new THREE.Raycaster(); + this.pickedObject = null; + this.pickedObjectSavedColor = 0; + } + pick(normalizedPosition, scene, camera, time) { + // 이미 다른 물체를 피킹했다면 색을 복원합니다 + if (this.pickedObject) { + this.pickedObject.material.emissive.setHex(this.pickedObjectSavedColor); + this.pickedObject = undefined; + } + + // 절두체 안에 광선을 쏩니다 + this.raycaster.setFromCamera(normalizedPosition, camera); + // 광선과 교차하는 물체들을 배열로 만듭니다 + const intersectedObjects = this.raycaster.intersectObjects(scene.children); + if (intersectedObjects.length) { + // 첫 번째 물체가 제일 가까우므로 해당 물체를 고릅니다 + this.pickedObject = intersectedObjects[0].object; + // 기존 색을 저장해둡니다 + this.pickedObjectSavedColor = this.pickedObject.material.emissive.getHex(); + // emissive 색을 빨강/노랑으로 빛나게 만듭니다 + this.pickedObject.material.emissive.setHex((time 8) % 2 > 1 ? 0xFFFF00 : 0xFF0000); + } + } +} + +const pickPosition = { x: 0, y: 0 }; +const pickHelper = new PickHelper(); +``` + +`pickPosition`은 마우스 포인터의 좌표를 기록하는 역할입니다. 이벤트를 통해 해당 속성을 업데이트하도록 했었죠. + +```js +function getCanvasRelativePosition(event) { + const rect = canvas.getBoundingClientRect(); + return { + x: (event.clientX - rect.left) * canvas.width / rect.width, + y: (event.clientY - rect.top ) * canvas.height / rect.height, + }; +} + +function setPickPosition(event) { + const pos = getCanvasRelativePosition(event); + pickPosition.x = (pos.x / canvas.width ) * 2 - 1; + pickPosition.y = (pos.y / canvas.height) * -2 + 1; // Y축을 뒤집었음 +} +window.addEventListener('mousemove', setPickPosition); +``` + +워커는 포인터 좌표에 직접 접근할 수 없기에, 반응형 처리에 사용했던 코드처럼 포인터 좌표를 메시지로 보내야 합니다. 먼저 `size` 함수와 마찬가지로 `mouse` 함수를 만들어 `pickPosition`을 업데이트하도록 합니다. + +```js +function size(data) { + state.width = data.width; + state.height = data.height; +} + ++function mouse(data) { ++ pickPosition.x = data.x; ++ pickPosition.y = data.y; ++} + +const handlers = { + init, ++ mouse, + size, +}; + +self.onmessage = function(e) { + const fn = handlers[e.data.type]; + if (!fn) { + throw new Error('no handler for type: ' + e.data.type); + } + fn(e.data); +}; +``` + +그리고 메인 페이지에 분기 함수를 만들어 워커 또는 메인 페이지로 좌표 데이터를 보내도록 합니다. + +```js ++let sendMouse; + +function startWorker(canvas) { + const offscreen = canvas.transferControlToOffscreen(); + const worker = new Worker('offscreencanvas-worker-picking.js'); + worker.postMessage({ type: 'init', canvas: offscreen }, [ offscreen ]); + ++ sendMouse = (x, y) => { ++ worker.postMessage({ ++ type: 'mouse', ++ x, ++ y, ++ }); ++ }; + + function sendSize() { + worker.postMessage({ + type: 'size', + width: canvas.clientWidth, + height: canvas.clientHeight, + }); + } + + window.addEventListener('resize', sendSize); + sendSize(); + + console.log('using OffscreenCanvas'); /* eslint-disable-line no-console / +} + +function startMainPage(canvas) { + init({ canvas }); + ++ sendMouse = (x, y) => { ++ pickPosition.x = x; ++ pickPosition.y = y; ++ }; + + function sendSize() { + state.width = canvas.clientWidth; + state.height = canvas.clientHeight; + } + window.addEventListener('resize', sendSize); + sendSize(); + + console.log('using regular canvas'); / eslint-disable-line no-console / +} + +``` + +다음으로 마우스 이벤트 관련 코드를 메인 페이지로 옮긴 뒤 `sendMouse` 함수를 쓰도록 수정합니다. + +```js +function setPickPosition(event) { + const pos = getCanvasRelativePosition(event); +- pickPosition.x = (pos.x / canvas.clientWidth ) 2 - 1; +- pickPosition.y = (pos.y / canvas.clientHeight) * -2 + 1; // Y축을 뒤집었음 ++ sendMouse( ++ (pos.x / canvas.clientWidth ) * 2 - 1, ++ (pos.y / canvas.clientHeight) * -2 + 1); // Y축을 뒤집었음 +} + +function clearPickPosition() { + /** + * 마우스의 경우는 항상 위치가 있어 그다지 큰 + * 상관이 없지만, 터치 같은 경우 사용자가 손가락을 + * 떼면 피킹을 멈춰야 합니다. 지금은 일단 어떤 것도 + * 선택할 수 없는 값으로 지정해두었습니다 + */ +- pickPosition.x = -100000; +- pickPosition.y = -100000; ++ sendMouse(-100000, -100000); +} +window.addEventListener('mousemove', setPickPosition); +window.addEventListener('mouseout', clearPickPosition); +window.addEventListener('mouseleave', clearPickPosition); + +window.addEventListener('touchstart', (event) => { + event.preventDefault(); // 스크롤 이벤트 방지 + setPickPosition(event.touches[0]); +}, { passive: false }); + +window.addEventListener('touchmove', (event) => { + setPickPosition(event.touches[0]); +}); + +window.addEventListener('touchend', clearPickPosition); +``` + +이제 `OffscreenCanvas`에서도 피킹이 정상적으로 작동할 겁니다. + +{{{example url="../threejs-offscreencanvas-w-picking.html" }}} + +좀 더 욕심을 내 `OrbitControls`까지 추가해봅시다. `OrbitControls`는 DOM에 꽤 다양하게 접근하기에 처리해줘야 할 것이 좀 많습니다. 제대로 작동하려면 마우스 이벤트, 터치 이벤트, 키보드 이벤트를 모두 처리해줘야 하죠. + +여태까지는 전역 `state` 객체를 사용했지만, `OrbitControls`의 경우는 객체 속성이 너무 많아 그걸 전부 다 하드 코딩하는 건 너무 번거롭습니다. `OrbitControls`는 필요한 DOM 이벤트의 대부분을 인자로 받는 HTML 요소에 바인딩합니다. 이를 이용해 DOM 요소와 같은 구조의 객체를 넘겨준다면 어떨까요? `OrbitControls`에 필요한 기능만 살려서 말이죠. + +[`OrbitControls`의 소스 코드](https://github.com/gfxfundamentals/threejsfundamentals/blob/master/threejs/resources/threejs/r115/examples/js/controls/OrbitControls.js)를 분석해보니 아래의 이벤트만 지원하면 될 듯합니다. + + contextmenu +* mousedown +* mousemove +* mouseup +* touchstart +* touchmove +* touchend +* wheel +* keydown + +마우스 이벤트 중 `OrbitControls`가 사용하는 속성은 `ctrlKey`, `metaKey`, `shiftKey`, `button`, `clientX`, `clientY`, `pageX`, `pageY`이고, + +keydown 이벤트의 경우는 `ctrlKey`, `metaKey`, `shiftKey`, `keyCode` 속성, + +wheel 이벤트는 `deltaY` 속성만, + +터치 이벤트의 경우는 `touches` 속성의 `pageX`, `pageY` 속성이 필요하네요. + +이를 처리할 경유(proxy) 객체를 한 쌍 만들어봅시다. 한쪽은 메인 페이지에서 위 이벤트를 받아 필요한 속성을 워커에 넘겨주는 역할을 할 겁니다. 그리고 다른 한쪽은 워커 안에서 이 이벤트를 받아 `OrbitControls`에 넘겨줄 겁니다. 이벤트 객체가 DOM 이벤트와 같은 구조이기에 `OrbitControls`는 이 이벤트가 DOM 이벤트가 아니란 걸 눈치채지 못하겠죠. + +아래는 워커 안의 코드입니다. + +```js +class ElementProxyReceiver extends THREE.EventDispatcher { + constructor() { + super(); + } + handleEvent(data) { + this.dispatchEvent(data); + } +} +``` + +위 코드는 단순히 메시지를 받았을 때 그걸 다시 내보내는(dispatch) 역할을 합니다. 부모 클래스인 `EventDispatcher`는 DOM 요소처럼 `addEventListener`나 `removeEventListener` 메서드를 제공하기에 HTML 요소 대신 이 클래스의 인스턴스를 넘겨줘도 문제없이 작동할 겁니다. + +`ElementProxyReceiver`는 하나의 요소만 대신할 수 있습니다. 예제의 경우 하나만 필요하기는 하나 나중에 캔버스를 여러 개 사용할 수도 있으니 여러 `ElementProxyReceiver`를 관리하는 클래스를 만들겠습니다. + +```js +class ProxyManager { + constructor() { + this.targets = {}; + this.handleEvent = this.handleEvent.bind(this); + } + makeProxy(data) { + const { id } = data; + const proxy = new ElementProxyReceiver(); + this.targets[id] = proxy; + } + getProxy(id) { + return this.targets[id]; + } + handleEvent(data) { + this.targets[data.id].handleEvent(data.data); + } +} +``` + +`ProxyManager`의 인스턴스를 만들고 id값과 함께 `makeProxy` 메서드를 호출하면 해당 id에만 응답하는 `ElementProxyReceiver`가 생성됩니다. + +이제 이 클래스를 기존 워커 코드와 연동해봅시다. + +```js +const proxyManager = new ProxyManager(); + +function start(data) { + const proxy = proxyManager.getProxy(data.canvasId); + init({ + canvas: data.canvas, + inputElement: proxy, + }); +} + +function makeProxy(data) { + proxyManager.makeProxy(data); +} + +... + +const handlers = { +- init, +- mouse, ++ start, ++ makeProxy, ++ event: proxyManager.handleEvent, + size, +}; + +self.onmessage = function(e) { + const fn = handlers[e.data.type]; + if (!fn) { + throw new Error('no handler for type: ' + e.data.type); + } + fn(e.data); +}; +``` + +`OrbitControls` 모듈도 불러와야겠죠. + +```js +importScripts('resources/threejs/r115/build/three.min/js'); ++importScripts('resources/threejs/r115/examples/js/controls/OrbitControls.js'); +importScripts('shared-orbitcontrols.js'); +``` + +그리고 공통 Three.js 코드를 아래와 같이 수정합니다. + +```js +function init(data) { +- const { canvas } = data; ++ const { canvas, inputElement } = data; + const renderer = new THREE.WebGLRenderer({ canvas }); + ++ const controls = new OrbitControls(camera, inputElement); ++ controls.target.set(0, 0, 0); ++ controls.update(); +``` + +위 코드에서는 이전과 달리 `inputElement`로 경유 객체를 `OrbitControls`에 넘겨줬습니다. + +하는 김에 피킹 이벤트도 경유 객체를 사용하도록 바꿉니다. + +```js +function getCanvasRelativePosition(event) { +- const rect = canvas.getBoundingClientRect(); ++ const rect = inputElement.getBoundingClientRect(); + return { + x: event.clientX - rect.left, + y: event.clientY - rect.top, + }; +} + +function setPickPosition(event) { + const pos = getCanvasRelativePosition(event); +- sendMouse( +- (pos.x / canvas.clientWidth ) 2 - 1, +- (pos.y / canvas.clientHeight) * -2 + 1); // Y축을 뒤집었음 ++ pickPosition.x = (pos.x / inputElement.clientWidth ) * 2 - 1; ++ pickPosition.y = (pos.y / inputElement.clientHeight) * -2 + 1; // Y축을 뒤집었음 +} + +function clearPickPosition() { + /** + * 마우스의 경우는 항상 위치가 있어 그다지 큰 + * 상관이 없지만, 터치 같은 경우 사용자가 손가락을 + * 떼면 피킹을 멈춰야 합니다. 지금은 일단 어떤 것도 + * 선택할 수 없는 값으로 지정해두었습니다 + */ +- sendMouse(-100000, -100000); ++ pickPosition.x = -100000; ++ pickPosition.y = -100000; +} + +inputElement.addEventListener('mousemove', setPickPosition); +inputElement.addEventListener('mouseout', clearPickPosition); +inputElement.addEventListener('mouseleave', clearPickPosition); + +inputElement.addEventListener('touchstart', (event) => { + event.preventDefault(); // 스크롤 이벤트 방지 + setPickPosition(event.touches[0]); +}, { passive: false }); + +inputElement.addEventListener('touchmove', (event) => { + setPickPosition(event.touches[0]); +}); + +inputElement.addEventListener('touchend', clearPickPosition); +``` + +메인 페이지에서 위에 열거한 모든 이벤트가 워커로 메시지를 보내도록 합니다. + +```js +let nextProxyId = 0; +class ElementProxy { + constructor(element, worker, eventHandlers) { + this.id = nextProxyId++; + this.worker = worker; + const sendEvent = (data) => { + this.worker.postMessage({ + type: 'event', + id: this.id, + data, + }); + }; + + // id를 등록합니다. + worker.postMessage({ + type: 'makeProxy', + id: this.id, + }); + for (const [eventName, handler] of Object.entries(eventHandlers)) { + element.addEventListener(eventName, function(event) { + handler(event, sendEvent); + }); + } + } +} +``` + +`ElementProxy`는 이벤트를 우회할 요소(element)를 인자로 받습니다. 그리고 고유 id를 생성해 워커에 `makeProxy` 메시지로 id를 등록합니다. 그러면 아까 만들었듯 워커는 이 id에 새로운 `ElementProxyReceiver`를 생성하겠죠. + +다음으로 이벤트를 처리할 핸들러 맵(`eventHandlers`)을 만듭니다. 이러면 해당 이벤트가 발생했을 때만 워커에 메시지를 보낼 수 있죠. + +워커를 생성할 때 `ElementProxy`에 이 핸들러 맵을 넘겨 새 우회 요소를 생성합니다. + +```js +function startWorker(canvas) { + const offscreen = canvas.transferControlToOffscreen(); + const worker = new Worker('offscreencanvas-worker-orbitcontrols.js'); + ++ const eventHandlers = { ++ contextmenu: preventDefaultHandler, ++ mousedown: mouseEventHandler, ++ mousemove: mouseEventHandler, ++ mouseup: mouseEventHandler, ++ touchstart: touchEventHandler, ++ touchmove: touchEventHandler, ++ touchend: touchEventHandler, ++ wheel: wheelEventHandler, ++ keydown: filteredKeydownEventHandler, ++ }; ++ const proxy = new ElementProxy(canvas, worker, eventHandlers); + worker.postMessage({ + type: 'start', + canvas: offscreen, ++ canvasId: proxy.id, + }, [ offscreen ]); + console.log('using OffscreenCanvas'); / eslint-disable-line no-console / +} +``` + +핸들러 맵의 핸들러는 넘겨 받은 이벤트의 속성 중 넘겨 받은 키 배열에 해당하는 속성만 복사합니다. 그리고 `ElementProxy`에서 넘겨 받은 `sendEvent` 함수를 복사한 데이터와 함께 호출하죠. 그러면 `sendEvent` 함수는 해당하는 id와 데이터를 워커에 보냅니다. + +```js +const mouseEventHandler = makeSendPropertiesHandler([ + 'ctrlKey', + 'metaKey', + 'shiftKey', + 'button', + 'clientX', + 'clientY', + 'pageX', + 'pageY', +]); +const wheelEventHandlerImpl = makeSendPropertiesHandler([ + 'deltaX', + 'deltaY', +]); +const keydownEventHandler = makeSendPropertiesHandler([ + 'ctrlKey', + 'metaKey', + 'shiftKey', + 'keyCode', +]); + +function wheelEventHandler(event, sendFn) { + event.preventDefault(); + wheelEventHandlerImpl(event, sendFn); +} + +function preventDefaultHandler(event) { + event.preventDefault(); +} + +function copyProperties(src, properties, dst) { + for (const name of properties) { + dst[name] = src[name]; + } +} + +function makeSendPropertiesHandler(properties) { + return function sendProperties(event, sendFn) { + const data = { type: event.type }; + copyProperties(event, properties, data); + sendFn(data); + }; +} + +function touchEventHandler(event, sendFn) { + const touches = []; + const data = { type: event.type, touches }; + for (let i = 0; i < event.touches.length; ++i) { + const touch = event.touches[i]; + touches.push({ + pageX: touch.pageX, + pageY: touch.pageY, + }); + } + sendFn(data); +} + +// 키보드의 화살표 키 +const orbitKeys = { + '37': true, // 왼쪽 + '38': true, // 위쪽 + '39': true, // 오른쪽 + '40': true, // 아래쪽 +}; +function filteredKeydownEventHandler(event, sendFn) { + const { keyCode } = event; + if (orbitKeys[keyCode]) { + event.preventDefault(); + keydownEventHandler(event, sendFn); + } +} +``` + +거의 다 된 듯합니다. 하지만 실제로 예제를 실행해보니 아직 처리해줘야 할 것들이 몇 개 더 있네요. + +`OrbitControls`는 `element.focus` 메서드를 호출합니다. 이는 워커에서 그다지 쓸모가 없으니 빈 함수로 대체하겠습니다. + +```js +class ElementProxyReceiver extends THREE.EventDispatcher { + constructor() { + super(); + } + handleEvent(data) { + this.dispatchEvent(data); + } ++ focus() { ++ // 빈 함수(no-operation) ++ } +} +``` + +`event.preventDefault`와 `event.stopPropagation`도 사용합니다. 이는 이미 메인 페이지에서 처리했으니 이 역시 빈 함수로 대체합니다. + +```js ++function noop() { ++} + +class ElementProxyReceiver extends THREE.EventDispatcher { + constructor() { + super(); + } + handleEvent(data) { ++ data.preventDefault = noop; ++ data.stopPropagation = noop; + this.dispatchEvent(data); + } + focus() { + // 빈 함수(no-operation) + } +} +``` + +또 `clientWidth`와 `clientHeight`도 사용합니다. 이전에는 캔버스의 크기값을 따로 넘겨줬었는데, 경유 객체들이 이 값도 주고받도록 수정하겠습니다. + +워커의 경우 다음처럼 코드를 추가합니다. + +```js +class ElementProxyReceiver extends THREE.EventDispatcher { + constructor() { + super(); + } ++ get clientWidth() { ++ return this.width; ++ } ++ get clientHeight() { ++ return this.height; ++ } ++ getBoundingClientRect() { ++ return { ++ left: this.left, ++ top: this.top, ++ width: this.width, ++ height: this.height, ++ right: this.left + this.width, ++ bottom: this.top + this.height, ++ }; ++ } + handleEvent(data) { ++ if (data.type === 'size') { ++ this.left = data.left; ++ this.top = data.top; ++ this.width = data.width; ++ this.height = data.height; ++ return; ++ } + data.preventDefault = noop; + data.stopPropagation = noop; + this.dispatchEvent(data); + } + focus() { + // 빈 함수(no-operation) + } +} +``` + +이제 메인 페이지에서 캔버스의 크기와 위치 좌표를 넘겨줘야 합니다. 하나 언급하고 싶은 건 예제에서는 캔버스의 크기가 바뀌는 경우만 가정했지, 캔버스가 움직이는 경우는 가정하지 않았다는 점입니다. 캔버스가 움직이는 경우를 처리하려면 캔버스가 움직였을 때 `sendSize`를 호출하면 됩니다. + +```js +class ElementProxy { + constructor(element, worker, eventHandlers) { + this.id = nextProxyId++; + this.worker = worker; + const sendEvent = (data) => { + this.worker.postMessage({ + type: 'event', + id: this.id, + data, + }); + }; + + // id를 등록합니다. + worker.postMessage({ + type: 'makeProxy', + id: this.id, + }); ++ sendSize(); + for (const [eventName, handler] of Object.entries(eventHandlers)) { + element.addEventListener(eventName, function(event) { + handler(event, sendEvent); + }); + } + ++ function sendSize() { ++ const rect = element.getBoundingClientRect(); ++ sendEvent({ ++ type: 'size', ++ left: rect.left, ++ top: rect.top, ++ width: element.clientWidth, ++ height: element.clientHeight, ++ }); ++ } ++ ++ window.addEventListener('resize', sendSize); + } +} +``` + +이제 공통 Three.js 코드에서 `state` 전역 변수를 쓰지 않으니 삭제합니다. + +```js +-const state = { +- width: 300, // 캔버스 기본값 +- height: 150, // 캔버스 기본값 +-}; + +... + +function resizeRendererToDisplaySize(renderer) { + const canvas = renderer.domElement; +- const width = state.width; +- const height = state.height; ++ const width = inputElement.clientWidth; ++ const height = inputElement.clientHeight; + const needResize = canvas.width !== width \|\| canvas.height !== height; + if (needResize) { + renderer.setSize(width, height, false); + } + return needResize; +} + +function render(time) { + time = 0.001; + + if (resizeRendererToDisplaySize(renderer)) { +- camera.aspect = state.width / state.height; ++ camera.aspect = inputElement.clientWidth / inputElement.clientHeight; + camera.updateProjectionMatrix(); + } + + ... +``` + +`OrbitControls`는 키보드 이벤트를 감지하기 위해 `window`에 이벤트 리스너를 바인딩합니다. 이게 좋은 방식인지는 모르겠지만, 소스 코드를 직접 수정하지 않는 한 이 동작을 고칠 수는 없습니다. 워커에는 `window` 객체가 존재하지 않거든요. + +또 `document`의 `mousemove`와 `mouseup` 이벤트도 사용합니다. 이는 마우스가 창 밖으로 나간다든가 하는 경우에도 마우스의 움직임을 감지하기 위한 것이지만, `window`와 마찬가지로 워커에는 `document` 객체가 없습니다. + +거기다 `OrbitControls`에 넘겨준 요소가 `document`와 일치하는지의 여부도 검사합니다. + +이 문제는 간단한 편법(hack)을 써 해결할 수 있습니다. 다시 한 번 워커의 경유 객체를 이용하도록 하죠. + +```js +function start(data) { + const proxy = proxyManager.getProxy(data.canvasId); ++ self.window = proxy; // HACK! ++ self.document = { // HACK! ++ addEventListener: proxy.addEventListener.bind(proxy), ++ removeEventListener: proxy.removeEventListener.bind(proxy), ++ }; + init({ + canvas: data.canvas, + inputElement: proxy, + }); +} +``` + +이러면 `OrbitControls`가 에러를 던지지 않을 겁니다. + +예제가 복잡해 이해하기 어려웠을 수 있습니다. 동작을 요약하자면 `ElementProxy`가 메인 페이지의 DOM 이벤트를 워커의 `ElementProxyReceiver`에 넘기고, `ElementProxyReceiver`는 `HTMLElement`를 가장해 `OrbitControls`와 공통 코드에서 쓸 수 있는 대체 DOM 요소로 기능합니다. + +마지막으로 `OffscreenCanvas`를 지원하지 않는 경우의 예외 코드만 수정해주면 끝입니다. 간단히 `inputElement`에 캔버스 요소자체를 넘겨주기만 하면 되죠. + +```js +function startMainPage(canvas) { +- init({ canvas }); ++ init({ canvas, inputElement: canvas }); + console.log('using regular canvas'); +} +``` + +이제 `OffscreenCanvas`에서도 `OrbitControls`가 잘 작동합니다. + +{{{example url="../threejs-offscreencanvas-w-orbitcontrols.html" }}} + +아마 이 예제가 이 시리즈를 통틀어 가장 복잡한 예제일 겁니다. 각 예제마다 HTML 파일, 워커 파일, 공통 Three.js 코드 파일, 이렇게 파일 3개가 서로 연동되니 그럴만 하죠. + +이 글이 너무 어렵게 느껴지지 않았다면 좋겠습니다. 또한 Three.js에서 OffscreenCanvas와 웹 워커를 활용하는 좋은 예가 되었길 바랍니다.	false
Other	mrdoob	three.js	633dbb61bdfd242077b4c012fce7468c1e707c1a.json	add translation kr/threejs-rendering-on-demand.md add translation kr/threejs-transparency.md update translation kr/threejs-prerequisites.md add translation kr/threejs-multiple-scenes.md add translation kr/threejs-picking.md fix typo & add translation kr/threejs-post-processing.md add translation kr/threejs-post-processing-3dlut.md	threejs/lessons/kr/threejs-multiple-scenes.md	@@ -0,0 +1,696 @@ +Title: Three.js로 캔버스, 장면 여러 개 만들기 +Description: THREE.js로 다수의 장면을 렌더링해봅니다 +TOC: 다중 캔버스, 다중 장면 만들기 + +사람들이 자주 하는 질문 중 하나는 Three.js로 여러 개의 캔버스(canvas)를 렌더링하려면 +어떻게 해야 하나요?"입니다. 쇼핑몰 사이트나 3D 도표가 여러 개 있는 웹 페이지를 +제작한다고 해봅시다. 얼핏 그리 어려울 건 없어 보입니다. 그냥 도표가 들어갈 곳마다 +각각 캔버스를 만들고, 각 캔버스마다 `Renderer`를 생성하면 되지 않을까요? + +하지만 이 방법을 적용하자마자 문제가 생깁니다. + +1. 브라우저의 WebGL 컨텍스트(context)는 제한적이다. + + 일반적으로 약 8개가 최대입니다. 9번째 컨텍스트를 만들면 제일 처음에 만들었던 + 컨텍스트가 사라지죠. + +2. WebGL 자원은 컨텍스트끼리 공유할 수 없다. + + 10MB짜리 모델을 캔버스 두 개에서 사용하려면 모델을 각각 총 두 번 로드해야 하고, + 원래의 두 배인 20MB의 자원을 사용한다는 의미입니다. 컨텍스트끼리는 어떤 것도 공유할 + 수 없죠. 또한 초기화도 두 번, 쉐이더 컴파일도 두 번, 같은 동작은 모두 두 번씩 + 실행해야 합니다. 캔버스의 개수가 많아질수록 성능에 문제가 생기겠죠. + +그렇다면 어떻게 해야 할까요? + +방법 중 하나는 캔버스 하나로 화면 전체를 채우고, 각 "가상" 캔버스를 대신할 HTML 요소(element)를 +두는 겁니다. `Renderer`는 하나만 만들되 가상 캔버스에 각각 `Scene`을 만드는 거죠. 그리고 +가상 HTML 요소의 좌표를 계산해 요소가 화면에 보인다면 Three.js가 해당 장면(scene)을 가상 +요소의 좌표에 맞춰 렌더링하도록 합니다. + +이 방법은 캔버스를 하나만 사용하므로 위 1번과 2번 문제 모두 해결할 수 있습니다. 컨텍스트를 +하나만 사용하니 WebGL 컨텍스트 제한을 걱정할 일도 없고, 자원을 몇 배씩 더 사용할 일도 없죠. + +2개의 장면만 만들어 간단히 테스트를 해보겠습니다. 먼저 HTML을 작성합니다. + +```html +<canvas id="c"></canvas> +<p> + <span id="box" class="diagram left"></span> + I love boxes. Presents come in boxes. + When I find a new box I'm always excited to find out what's inside. +</p> +<p> + <span id="pyramid" class="diagram right"></span> + When I was a kid I dreamed of going on an expedition inside a pyramid + and finding a undiscovered tomb full of mummies and treasure. +</p> +``` + +다음으로 CSS를 작성합니다. + +```css +#c { + position: fixed; + left: 0; + top: 0; + width: 100vw; + height: 100vh; + display: block; + z-index: -1; +} +.diagram { + display: inline-block; + width: 5em; + height: 3em; + border: 1px solid black; +} +.left { + float: left; + margin-right: .25em; +} +.right { + float: right; + margin-left: .25em; +} +``` + +캔버스가 화면 전체를 채우도록 하고 `z-index`를 -1로 설정해 다른 요소 뒤로 가도록 했습니다. +가상 요소에 컨텐츠가 없어 크기가 0이니 별도의 width와 height도 지정해줬습니다. + +이제 각각의 카메라와 조명이 있는 장면 2개를 만듭니다. 하나에는 정육면체, 다른 하나에는 +다이아몬드 모양을 넣을 겁니다. + +```js +function makeScene(elem) { + const scene = new THREE.Scene(); + + const fov = 45; + const aspect = 2; // 캔버스 기본값 + const near = 0.1; + const far = 5; + const camera = new THREE.PerspectiveCamera(fov, aspect, near, far); + camera.position.z = 2; + camera.position.set(0, 1, 2); + camera.lookAt(0, 0, 0); + + { + const color = 0xFFFFFF; + const intensity = 1; + const light = new THREE.DirectionalLight(color, intensity); + light.position.set(-1, 2, 4); + scene.add(light); + } + + return { scene, camera, elem }; +} + +function setupScene1() { + const sceneInfo = makeScene(document.querySelector('#box')); + const geometry = new THREE.BoxBufferGeometry(1, 1, 1); + const material = new THREE.MeshPhongMaterial({color: 'red'}); + const mesh = new THREE.Mesh(geometry, material); + sceneInfo.scene.add(mesh); + sceneInfo.mesh = mesh; + return sceneInfo; +} + +function setupScene2() { + const sceneInfo = makeScene(document.querySelector('#pyramid')); + const radius = .8; + const widthSegments = 4; + const heightSegments = 2; + const geometry = new THREE.SphereBufferGeometry(radius, widthSegments, heightSegments); + const material = new THREE.MeshPhongMaterial({ + color: 'blue', + flatShading: true, + }); + const mesh = new THREE.Mesh(geometry, material); + sceneInfo.scene.add(mesh); + sceneInfo.mesh = mesh; + return sceneInfo; +} + +const sceneInfo1 = setupScene1(); +const sceneInfo2 = setupScene2(); +``` + +이제 각 요소가 화면에 보일 때만 장면을 렌더링할 함수를 만듭니다. `Renderer.setScissorTest`를 +호출해 가위(scissor) 테스트를 활성화하면 Three.js가 캔버스의 특정 부분만 렌더링하도록 +할 수 있습니다. 그리고 `Renderer.setScissor`로 가위를 설정한 뒤 `Renderer.setViewport`로 +장면의 좌표를 설정합니다. + +```js +function renderSceneInfo(sceneInfo) { + const { scene, camera, elem } = sceneInfo; + + // 해당 요소의 화면 대비 좌표를 가져옵니다 + const { left, right, top, bottom, width, height } = + elem.getBoundingClientRect(); + + const isOffscreen = + bottom < 0 \|\| + top > renderer.domElement.clientHeight \|\| + right < 0 \|\| + left > renderer.domElement.clientWidth; + + if (isOffscreen) { + return; + } + + camera.aspect = width / height; + camera.updateProjectionMatrix(); + + const positiveYUpBottom = canvasRect.height - bottom; + renderer.setScissor(left, positiveYUpBottom, width, height); + renderer.setViewport(left, positiveYUpBottom, width, height); + + renderer.render(scene, camera); +} +``` + +다음으로 `render` 함수 안에서 먼저 캔버스 전체를 비운 뒤 각 장면을 렌더링합니다. + +```js +function render(time) { + time = 0.001; + + resizeRendererToDisplaySize(renderer); + + renderer.setScissorTest(false); + renderer.clear(true, true); + renderer.setScissorTest(true); + + sceneInfo1.mesh.rotation.y = time .1; + sceneInfo2.mesh.rotation.y = time * .1; + + renderSceneInfo(sceneInfo1); + renderSceneInfo(sceneInfo2); + + requestAnimationFrame(render); +} +``` + +결과를 확인해볼까요? + +{{{example url="../threejs-multiple-scenes-v1.html" }}} + +첫 번째 `<span>` 요소가 있는 곳에는 빨간 정육면체가, 두 번째 `<span>` 요소가 있는 곳에는 +파란 다이아몬드가 보일 겁니다. + +## 동기화하기 + +위 코드는 나쁘지 않지만 작은 문제가 있습니다. 복잡한 장면 등 무슨 이유라도 렌더링하는 +데 시간이 오래 걸린다면, 장면의 좌표는 페이지의 다른 컨텐츠에 비해 더디게 내려올 겁니다. + +각 가상 요소에 테두리를 넣고 + +```css +.diagram { + display: inline-block; + width: 5em; + height: 3em; ++ border: 1px solid black; +} +``` + +각 장면에 배경색도 넣어줍니다. + +```js +const scene = new THREE.Scene(); ++scene.background = new THREE.Color('red'); +``` + +그런 다음 <a href="../threejs-multiple-scenes-v2.html" target="_blank">빠르게 스크롤을 위아래로 반복해보면</a> +문제가 보일겁니다. 아래는 스크롤 애니메이션 캡쳐본의 속도를 10배 낮춘 예시입니다. + +<div class="threejs_center"><img class="border" src="resources/images/multi-view-skew.gif"></div> + +추가로 처리해줘야 할 것이 있긴 하지만, 캔버스의 CSS를 `position: fixed`에서 `position: absolute`로 +바꿔 문제를 해결할 수 있습니다. + +```css +#c { +- position: fixed; ++ position: absolute; +``` + +그리고 페이지 스크롤에 상관 없이 캔버스가 항상 화면의 상단에 위치할 수 있도록 캔버스에 +transform 스타일을 지정해줍니다. + +```js +function render(time) { + ... + + const transform = `translateY(${ window.scrollY }px)`; + renderer.domElement.style.transform = transform; + +``` + +캔버스에 `position: fixed`를 적용하면 캔버스는 스크롤의 영향을 받지 않습니다. `position: absolute`를 +적용하면 렌더링하는 데 시간이 걸리더라도 일단 다른 페이지와 같이 스크롤이 되겠죠. 그리고 +렌더링하기 전에 캔버스를 다시 움직여 화면 전체에 맞춘 뒤 캔버스를 렌더링하는 겁니다. 이러면 +화면의 가장자리에 살짝 렌더링되지 않은 부분이 보일 수는 있어도 나머지 페이지에 있는 요소는 +버벅이지 않고 제자리에 있을 겁니다. 아래는 해당 코드를 적용한 화면의 캡쳐본을 아까와 마찬가지로 +10배 느리게 만든 것입니다. + +<div class="threejs_center"><img class="border" src="resources/images/multi-view-fixed.gif"></div> + +## 확장하기 쉽게 만들기 + +여러 장면을 구현했으니 이제 이 예제를 좀 더 확장하기 쉽게 만들어보겠습니다. + +먼저 기존처럼 캔버스 전체를 렌더링하는 `render` 함수를 두고, 각 장면에 해당하는 가상 요소, +해당 장면을 렌더링하는 함수로 이루어진 객체의 배열을 만듭니다. `render` 함수에서 가상 요소가 +화면에 보이는지 확인한 뒤, 가상 요소가 화면에 보인다면 상응하는 렌더링 함수를 호출합니다. 이러면 +확장성은 물론 각 장면의 렌더링 함수를 작성할 때도 전체를 신경쓸 필요가 없죠. + +아래는 전체를 담당하는 `render` 함수입니다. + +```js +const sceneElements = []; +function addScene(elem, fn) { + sceneElements.push({ elem, fn }); +} + +function render(time) { + time = 0.001; + + resizeRendererToDisplaySize(renderer); + + renderer.setScissorTest(false); + renderer.setClearColor(clearColor, 0); + renderer.clear(true, true); + renderer.setScissorTest(true); + + const transform = `translateY(${ window.scrollY }px)`; + renderer.domElement.style.transform = transform; + + for (const { elem, fn } of sceneElements) { + // 해당 요소의 화면 대비 좌표를 가져옵니다 + const rect = elem.getBoundingClientRect(); + const {left, right, top, bottom, width, height} = rect; + + const isOffscreen = + bottom < 0 \|\| + top > renderer.domElement.clientHeight \|\| + right < 0 \|\| + left > renderer.domElement.clientWidth; + + if (!isOffscreen) { + const positiveYUpBottom = renderer.domElement.clientHeight - bottom; + renderer.setScissor(left, positiveYUpBottom, width, height); + renderer.setViewport(left, positiveYUpBottom, width, height); + + fn(time, rect); + } + } + + requestAnimationFrame(render); +} +``` + +`render` 함수는 `elem`과 `fn` 속성의 객체로 이루어진 `sceneElements` 배열을 순회합니다. + +그리고 각 요소가 화면에 보이는지 확인하고, 화면에 보인다면 `fn`에 해당 장면이 들어가야할 +사각 좌표와 현재 시간값을 넘겨주어 호출합니다. + +이제 각 장면을 만들고 상응하는 요소와 렌더링 함수를 추가합니다. + +```js +{ + const elem = document.querySelector('#box'); + const { scene, camera } = makeScene(); + const geometry = new THREE.BoxBufferGeometry(1, 1, 1); + const material = new THREE.MeshPhongMaterial({ color: 'red' }); + const mesh = new THREE.Mesh(geometry, material); + scene.add(mesh); + addScene(elem, (time, rect) => { + camera.aspect = rect.width / rect.height; + camera.updateProjectionMatrix(); + mesh.rotation.y = time .1; + renderer.render(scene, camera); + }); +} + +{ + const elem = document.querySelector('#pyramid'); + const { scene, camera } = makeScene(); + const radius = .8; + const widthSegments = 4; + const heightSegments = 2; + const geometry = new THREE.SphereBufferGeometry(radius, widthSegments, heightSegments); + const material = new THREE.MeshPhongMaterial({ + color: 'blue', + flatShading: true, + }); + const mesh = new THREE.Mesh(geometry, material); + scene.add(mesh); + addScene(elem, (time, rect) => { + camera.aspect = rect.width / rect.height; + camera.updateProjectionMatrix(); + mesh.rotation.y = time * .1; + renderer.render(scene, camera); + }); +} +``` + +`sceneInfo1`, `sceneInfo2`는 더 이상 필요 없으니 제거합니다. 대신 각 mesh의 회전은 해당 +장면에서 처리해야 합니다. + +{{{example url="../threejs-multiple-scenes-generic.html" }}} + +## HTML Dataset 사용하기 + +HTML의 [dataset](https://developer.mozilla.org/ko/docs/Web/API/HTMLElement/dataset)을 +이용하면 좀 더 확장하기 쉬운 환경을 만들 수 있습니다. `id="..."` 대신 `data-diagram="..."`을 +이용해 데이터를 직접 HTML 요소에 지정하는 거죠. + +```html +<canvas id="c"></canvas> +<p> +- <span id="box" class="diagram left"></span> ++ <span data-diagram="box" class="left"></span> + I love boxes. Presents come in boxes. + When I find a new box I'm always excited to find out what's inside. +</p> +<p> +- <span id="pyramid" class="diagram left"></span> ++ <span data-diagram="pyramid" class="right"></span> + When I was a kid I dreamed of going on an expedition inside a pyramid + and finding a undiscovered tomb full of mummies and treasure. +</p> +``` + +요소의 id를 제거했으니 CSS 셀렉터도 다음처럼 바꾸어야 합니다. + +```css +-.diagram ++[data-diagram] { + display: inline-block; + width: 5em; + height: 3em; +} +``` + +또한 각 장면을 만드는 코드를 scene initialization functions라는 맵으로 만듭니다. +이 맵은 키값에 대응하는 장면 렌더링 함수를 반환할 겁니다. + +```js +const sceneInitFunctionsByName = { + 'box': () => { + const { scene, camera } = makeScene(); + const geometry = new THREE.BoxBufferGeometry(1, 1, 1); + const material = new THREE.MeshPhongMaterial({color: 'red'}); + const mesh = new THREE.Mesh(geometry, material); + scene.add(mesh); + return (time, rect) => { + mesh.rotation.y = time .1; + camera.aspect = rect.width / rect.height; + camera.updateProjectionMatrix(); + renderer.render(scene, camera); + }; + }, + 'pyramid': () => { + const { scene, camera } = makeScene(); + const radius = .8; + const widthSegments = 4; + const heightSegments = 2; + const geometry = new THREE.SphereBufferGeometry(radius, widthSegments, heightSegments); + const material = new THREE.MeshPhongMaterial({ + color: 'blue', + flatShading: true, + }); + const mesh = new THREE.Mesh(geometry, material); + scene.add(mesh); + return (time, rect) => { + mesh.rotation.y = time * .1; + camera.aspect = rect.width / rect.height; + camera.updateProjectionMatrix(); + renderer.render(scene, camera); + }; + }, +}; +``` + +그리고 `querySelectorAll`로 가상 요소를 전부 불러와 해당 요소에 상응하는 렌더링 함수를 +실행합니다. + +```js +document.querySelectorAll('[data-diagram]').forEach((elem) => { + const sceneName = elem.dataset.diagram; + const sceneInitFunction = sceneInitFunctionsByName[sceneName]; + const sceneRenderFunction = sceneInitFunction(elem); + addScene(elem, sceneRenderFunction); +}); +``` + +이제 코드를 확장하기가 한결 편해졌습니다. + +{{{examples url="../threejs-multiple-scenes-selector.html" }}} + +## 각 요소에 액션 추가하기 + +사용자 액션, 예를 들어 `TrackballControls`를 추가하는 건 아주 간단합니다. 먼저 스크립트를 +불러옵니다. + +```js +import { TrackballControls } from './resources/threejs/r115/examples/jsm/controls/TrackballControls.js'; +``` + +그리고 각 장면에 대응하는 요소에 `TrackballControls`를 추가합니다. + +```js +-function makeScene() { ++function makeScene(elem) { + const scene = new THREE.Scene(); + + const fov = 45; + const aspect = 2; // 캔버스 기본값 + const near = 0.1; + const far = 5; + const camera = new THREE.PerspectiveCamera(fov, aspect, near, far); + camera.position.set(0, 1, 2); + camera.lookAt(0, 0, 0); ++ scene.add(camera); + ++ const controls = new TrackballControls(camera, elem); ++ controls.noZoom = true; ++ controls.noPan = true; + + { + const color = 0xFFFFFF; + const intensity = 1; + const light = new THREE.DirectionalLight(color, intensity); + light.position.set(-1, 2, 4); +- scene.add(light); ++ camera.add(light); + } + +- return { scene, camera }; ++ return { scene, camera, controls }; +} +``` + +위 코드에서는 카메라를 장면에 추가하고, 카메라에 조명을 추가했습니다. 이러면 조명이 카메라를 +따라다니겠죠. `TrackballControls`는 카메라를 조정하기 때문에 이렇게 해야 빛이 계속 우리가 +바라보는 방향에서 나갑니다. + +또한 컨트롤을 렌더링 함수에서 업데이트해줘야 합니다. + +```js +const sceneInitFunctionsByName = { +- 'box': () => { +- const {scene, camera} = makeScene(); ++ 'box': (elem) => { ++ const { scene, camera, controls } = makeScene(elem); + const geometry = new THREE.BoxBufferGeometry(1, 1, 1); + const material = new THREE.MeshPhongMaterial({color: 'red'}); + const mesh = new THREE.Mesh(geometry, material); + scene.add(mesh); + return (time, rect) => { + mesh.rotation.y = time * .1; + camera.aspect = rect.width / rect.height; + camera.updateProjectionMatrix(); ++ controls.handleResize(); ++ controls.update(); + renderer.render(scene, camera); + }; + }, +- 'pyramid': () => { +- const { scene, camera } = makeScene(); ++ 'pyramid': (elem) => { ++ const { scene, camera, controls } = makeScene(elem); + const radius = .8; + const widthSegments = 4; + const heightSegments = 2; + const geometry = new THREE.SphereBufferGeometry(radius, widthSegments, heightSegments); + const material = new THREE.MeshPhongMaterial({ + color: 'blue', + flatShading: true, + }); + const mesh = new THREE.Mesh(geometry, material); + scene.add(mesh); + return (time, rect) => { + mesh.rotation.y = time * .1; + camera.aspect = rect.width / rect.height; + camera.updateProjectionMatrix(); ++ controls.handleResize(); ++ controls.update(); + renderer.render(scene, camera); + }; + }, +}; +``` + +이제 각 물체를 자유롭게 회전시킬 수 있습니다. + +{{{example url="../threejs-multiple-scenes-controls.html" }}} + +이 기법은 이 사이트 전체에 사용한 기법입니다. [원시 모델에 관한 글](threejs-primitives.html)과 +[재질에 관한 글](threejs-materials.html)에서 다양한 예시를 보여주기 위해 사용했죠. + +다른 방법으로는 화면 밖의 캔버스에서 장면을 렌더링해 각 요소에 2D 캔버스 형태로 넘겨주는 +방법이 있습니다. 이 방법의 장점은 각 영역을 어떻게 분리할지 고민하지 않아도 된다는 것이죠. +위에서 살펴본 방법은 캔버스를 화면 전체의 배경으로 써야 하지만, 이 방법은 일반 HTML 형태로 +사용할 수 있습니다. + +하지만 이 방법은 각 영역을 복사하는 것이기에 성능이 더 느립니다. 얼마나 느릴지는 브라우저와 +GPU 성능에 따라 다르죠. + +바꿔야 하는 건 생각보다 많지 않습니다. + +먼저 배경에서 캔버스 요소를 제거합니다. + +```html +<body> +- <canvas id="c"></canvas> + ... +</body> +``` + +CSS도 바꿔줍니다. + +```css +-#c { +- position: absolute; +- left: 0; +- top: 0; +- width: 100vw; +- height: 100vh; +- display: block; +- z-index: -1; +-} +canvas { + width: 100%; + height: 100%; + display: block; +} +[data-diagram] { + display: inline-block; + width: 5em; + height: 3em; +} +``` + +캔버스 요소가 부모에 꽉 차도록 변경했습니다. + +이제 자바스크립트를 변경해봅시다. 먼저 캔버스를 참조할 필요가 없으니 대신 캔버스 요소를 +새로 만듭니다. 또한 가위 테스트를 처음에 활성화합니다. + +```js +function main() { +- const canvas = document.querySelector('#c'); ++ const canvas = document.createElement('canvas'); + const renderer = new THREE.WebGLRenderer({canvas, alpha: true}); ++ renderer.setScissorTest(true); + + ... +``` + +다음으로 각 장면에 2D 렌더링 컨텍스트를 생성하고 장면에 대응하는 요소에 캔버스를 추가합니다. + +```js +const sceneElements = []; +function addScene(elem, fn) { ++ const ctx = document.createElement('canvas').getContext('2d'); ++ elem.appendChild(ctx.canvas); +- sceneElements.push({ elem, fn }); ++ sceneElements.push({ elem, ctx, fn }); +} +``` + +만약 렌더링 시 렌더링용 캔버스의 크기가 장면의 크기보다 작을 경우, 렌더링용 캔버스의 크기를 +키웁니다. 또한 2D 캔버스의 크기가 부모 요소와 다르다면 2D 캔버스의 크기를 조정합니다. 마지막으로 +가위와 화면을 설정하고, 해당 장면을 렌더링한 뒤, 요소의 캔버스로 렌더링 결과물을 복사합니다. + +```js +function render(time) { + time = 0.001; + +- resizeRendererToDisplaySize(renderer); +- +- renderer.setScissorTest(false); +- renderer.setClearColor(clearColor, 0); +- renderer.clear(true, true); +- renderer.setScissorTest(true); +- +- const transform = `translateY(${ window.scrollY }px)`; +- renderer.domElement.style.transform = transform; + +- for (const { elem, fn } of sceneElements) { ++ for (const { elem, fn, ctx } of sceneElements) { + // 해당 요소의 화면 대비 좌표를 가져옵니다 + const rect = elem.getBoundingClientRect(); + const { left, right, top, bottom, width, height } = rect; ++ const rendererCanvas = renderer.domElement; + + const isOffscreen = + bottom < 0 \|\| +- top > renderer.domElement.clientHeight \|\| ++ top > window.innerHeight \|\| + right < 0 \|\| +- left > renderer.domElement.clientWidth; ++ left > window.innerWidth; + + if (!isOffscreen) { +- const positiveYUpBottom = renderer.domElement.clientHeight - bottom; +- renderer.setScissor(left, positiveYUpBottom, width, height); +- renderer.setViewport(left, positiveYUpBottom, width, height); + ++ // 렌더링용 캔버스 크기 조정 ++ if (rendererCanvas.width < width \|\| rendererCanvas.height < height) { ++ renderer.setSize(width, height, false); ++ } ++ ++ // 2D 캔버스의 크기가 요소의 크기와 같도록 조정 ++ if (ctx.canvas.width !== width \|\| ctx.canvas.height !== height) { ++ ctx.canvas.width = width; ++ ctx.canvas.height = height; ++ } ++ ++ renderer.setScissor(0, 0, width, height); ++ renderer.setViewport(0, 0, width, height); + + fn(time, rect); + ++ // 렌더링된 장면을 2D 캔버스에 복사 ++ ctx.globalCompositeOperation = 'copy'; ++ ctx.drawImage( ++ rendererCanvas, ++ 0, rendererCanvas.height - height, width, height, // 원본 사각 좌표 ++ 0, 0, width, height); // 결과물 사각 좌표 + } + } + + requestAnimationFrame(render); +} +``` + +결과물은 위와 다르지 않습니다. + +{{{example url="../threejs-multiple-scenes-copy-canvas.html" }}} + +이 기법의 다른 장점은 [`OffscreenCanvas`](https://developer.mozilla.org/ko/docs/Web/API/OffscreenCanvas) +웹 워커를 이용해 이 기능을 별도 스레드에서 구현할 수 있다는 겁니다. 하지만 아쉽게도 +2020년 7월을 기준으로 `OffscreenCanvas`는 아직 크로미움 기반 브라우저에서만 지원합니다. \ No newline at end of file	true
Other	mrdoob	three.js	633dbb61bdfd242077b4c012fce7468c1e707c1a.json	add translation kr/threejs-rendering-on-demand.md add translation kr/threejs-transparency.md update translation kr/threejs-prerequisites.md add translation kr/threejs-multiple-scenes.md add translation kr/threejs-picking.md fix typo & add translation kr/threejs-post-processing.md add translation kr/threejs-post-processing-3dlut.md	threejs/lessons/kr/threejs-picking.md	@@ -0,0 +1,417 @@ +Title: Three.js 피킹(Picking) +Description: Three.js에서 마우스로 요소를 선택하는 법을 알아봅니다 +TOC: 물체를 마우스로 피킹하기 + +피킹(picking)이란 사용자가 클릭 또는 터치한 물체를 가려내는 작업을 말합니다. 피킹을 구현하는 방법은 수없이 많지만, 각자 단점이 있습니다. 이 글에서는 이 방법 중 흔히 사용하는 2가지 방법만 살펴보겠습니다. + +아마 피킹을 구현하는 가장 흔한 방법은 광선 투사(ray casting)일 겁니다. 광선 투사란 포인터(커서)에서 장면의 절두체로 광선을 쏴 광선이 닿는 물체를 감지하는 기법을 말하죠. 이론적으로 가장 간단한 방법입니다. + +먼저 포인터의 좌표를 구한 뒤, 이 좌표를 카메라의 시선과 방향에 따라 3D 좌표로 변환합니다. 그리고 near 면에서 far 면까지의 광선을 구해 이 광선이 장면 안 각 물체의 삼각형과 교차하는지 확인합니다. 만약 장면 안에 1000개의 삼각형을 가진 물체가 1000개 있다면 백만 개의 삼각형을 일일이 확인해야 하는 셈이죠. + +이를 최적화하려면 몇 가지 방법을 시도해볼 수 있습니다. 하나는 먼저 물체를 감싼 경계(bounding) 좌표가 광선과 교차하는지 확인하고, 교차하지 않는다면 해당 물체의 삼각형을 확인하지 않는 것이죠. + +Three.js에는 이런 작업을 대신해주는 `RayCaster` 클래스가 있습니다. + +한번 물체 100개가 있는 장면을 만들어 여기서 피킹을 구현해봅시다. 예제는 [반응형 디자인](threejs-responsive.html)에서 썼던 예제를 가져와 사용하겠습니다. + +우선 카메라를 별도 `Object3D`의 자식으로 추가해 카메라가 셀카봉처럼 장면 주위를 돌 수 있도록 합니다. + +```js +const fov = 60; +const aspect = 2; // 캔버스 기본값 +const near = 0.1; +const far = 200; +const camera = new THREE.PerspectiveCamera(fov, aspect, near, far); +camera.position.z = 30; + +const scene = new THREE.Scene(); ++scene.background = new THREE.Color('white'); + ++// 카메라를 봉(pole)에 추가합니다. ++// 이러면 봉을 회전시켜 카메라가 장면 주위를 돌도록 할 수 있습니다 ++const cameraPole = new THREE.Object3D(); ++scene.add(cameraPole); ++cameraPole.add(camera); +``` + +그리고 `render` 함수 안에서 카메라 봉을 돌립니다. + +```js +cameraPole.rotation.y = time .1; +``` + +또한 카메라에 조명을 추가해 조명이 카메라와 같이 움직이도록 합니다. + +```js +-scene.add(light); ++camera.add(light); +``` + +정육면체 100개의 위치, 방향, 크기를 무작위로 설정해 생성합니다. + +```js +const boxWidth = 1; +const boxHeight = 1; +const boxDepth = 1; +const geometry = new THREE.BoxGeometry(boxWidth, boxHeight, boxDepth); + +function rand(min, max) { + if (max === undefined) { + max = min; + min = 0; + } + return min + (max - min) * Math.random(); +} + +function randomColor() { + return `hsl(${ rand(360) \| 0 }, ${ rand(50, 100) \| 0 }%, 50%)`; +} + +const numObjects = 100; +for (let i = 0; i < numObjects; ++i) { + const material = new THREE.MeshPhongMaterial({ + color: randomColor(), + }); + + const cube = new THREE.Mesh(geometry, material); + scene.add(cube); + + cube.position.set(rand(-20, 20), rand(-20, 20), rand(-20, 20)); + cube.rotation.set(rand(Math.PI), rand(Math.PI), 0); + cube.scale.set(rand(3, 6), rand(3, 6), rand(3, 6)); +} +``` + +이제 피킹을 구현해봅시다. + +피킹을 관리할 간단한 클래스를 만들겠습니다. + +```js +class PickHelper { + constructor() { + this.raycaster = new THREE.Raycaster(); + this.pickedObject = null; + this.pickedObjectSavedColor = 0; + } + pick(normalizedPosition, scene, camera, time) { + // 이미 다른 물체를 피킹했다면 색을 복원합니다 + if (this.pickedObject) { + this.pickedObject.material.emissive.setHex(this.pickedObjectSavedColor); + this.pickedObject = undefined; + } + + // 절두체 안에 광선을 쏩니다 + this.raycaster.setFromCamera(normalizedPosition, camera); + // 광선과 교차하는 물체들을 배열로 만듭니다 + const intersectedObjects = this.raycaster.intersectObjects(scene.children); + if (intersectedObjects.length) { + // 첫 번째 물체가 제일 가까우므로 해당 물체를 고릅니다 + this.pickedObject = intersectedObjects[0].object; + // 기존 색을 저장해둡니다 + this.pickedObjectSavedColor = this.pickedObject.material.emissive.getHex(); + // emissive 색을 빨강/노랑으로 빛나게 만듭니다 + this.pickedObject.material.emissive.setHex((time * 8) % 2 > 1 ? 0xFFFF00 : 0xFF0000); + } + } +} +``` + +위 클래스는 먼저 `RayCaster` 인스턴스를 만들고 `pick` 메서드를 호출하면 장면에 광선을 쏠 수 있게 해줍니다. 그리고 광선에 맞는 요소가 있으면 해당 요소 중 가장 첫 번째 요소의 색을 변경합니다. + +사용자가 마우스를 눌렀을 때(down)만 이 함수가 작동하도록 할 수도 있지만, 예제에서는 마우스 포인터 아래의 있는 요소를 피킹하도록 하겠습니다. 이를 구현하려면 먼저 포인터를 추적해야 합니다. + +```js +const pickPosition = { x: 0, y: 0 }; +clearPickPosition(); + +... + +function getCanvasRelativePosition(event) { + const rect = canvas.getBoundingClientRect(); + return { + x: (event.clientX - rect.left) * canvas.width / rect.width, + y: (event.clientY - rect.top ) * canvas.height / rect.height, + }; +} + +function setPickPosition(event) { + const pos = getCanvasRelativePosition(event); + pickPosition.x = (pos.x / canvas.width ) * 2 - 1; + pickPosition.y = (pos.y / canvas.height) * -2 + 1; // Y 축을 뒤집었음 +} + +function clearPickPosition() { + /** + * 마우스의 경우는 항상 위치가 있어 그다지 큰 + * 상관이 없지만, 터치 같은 경우 사용자가 손가락을 + * 떼면 피킹을 멈춰야 합니다. 지금은 일단 어떤 것도 + * 선택할 수 없는 값으로 지정해두었습니다 + */ + pickPosition.x = -100000; + pickPosition.y = -100000; +} + +window.addEventListener('mousemove', setPickPosition); +window.addEventListener('mouseout', clearPickPosition); +window.addEventListener('mouseleave', clearPickPosition); +``` + +위 예제에서는 마우스의 좌표를 정규화(normalize)했습니다. 캔버스의 크기와 상관없이 왼쪽 끝이 -1, 오른쪽 끝이 +1인 벡터값이 필요하기 때문이죠. 마찬가지로 아래쪽 끝은 -1, 위쪽 끝은 +1입니다. + +모바일도 환경도 지원하기 위해 리스너를 더 추가하겠습니다. + +```js +window.addEventListener('touchstart', (event) => { + event.preventDefault(); // 스크롤 이벤트 방지 + setPickPosition(event.touches[0]); +}, { passive: false }); + +window.addEventListener('touchmove', (event) => { + setPickPosition(event.touches[0]); +}); + +window.addEventListener('touchend', clearPickPosition); +``` + +마지막으로 `render` 함수에서 `PickHelper`의 `pick` 메서드를 호출합니다. + +```js ++const pickHelper = new PickHelper(); + +function render(time) { + time = 0.001; // 초 단위로 변환 + + ... + ++ pickHelper.pick(pickPosition, scene, camera, time); + + renderer.render(scene, camera); + + ... +``` + +결과를 볼까요? + +{{{example url="../threejs-picking-raycaster.html" }}} + +딱히 문제는 없어 보입니다. 실제로 사용하는 경우도 대부분 문제 없이 잘 되겠지만, 이 방법에는 몇 가지 문제점이 있습니다. + +1. CPU의 자원을 사용한다 + + 자바스크립트 엔진은 각 요소를 돌며 광선이 요소의 경계 좌표 안에 교차하는지 확인합니다. 만약 교차할 경우, 해당 요소의 삼각형을 전부 돌며 광선과 교차하는 삼각형이 있는지 확인합니다. + + 이 방식의 장점은 자바스크립트가 교차하는 지점을 정확히 계산해 해당 데이터를 넘겨줄 수 있다는 점입니다. 예를 들어 교차가 발생한 지점에 특정 표시를 할 수 있겠죠. + + 대신 CPU가 할 일이 더 늘어난다는 점이 단점입니다. 요소가 가진 삼각형이 많을수록 더 느려지겠죠. + +2. 특이한 방식의 쉐이더나 변이를 감지하지 못한다 + + 만약 장면에서 geometry를 변형하는 쉐이더를 사용한다면, 자바스크립트는 이 변형을 감지하지 못하기에 잘못된 값을 내놓을 겁니다. 제가 테스트해본 결과 스킨이 적용된 요소에는 이 방법이 먹히지 않습니다. + +3. 요소의 투명한 구멍을 처리하지 못한다. + +예제를 하나 만들어보죠. 아래와 같은 텍스처를 정육면체에 적용해봅시다. + +<div class="threejs_center"><img class="checkerboard" src="../resources/images/frame.png"></div> + +그다지 추가할 건 많지 않습니다. + +```js ++const loader = new THREE.TextureLoader(); ++const texture = loader.load('resources/images/frame.png'); + +const numObjects = 100; +for (let i = 0; i < numObjects; ++i) { + const material = new THREE.MeshPhongMaterial({ + color: randomColor(), + +map: texture, + +transparent: true, + +side: THREE.DoubleSide, + +alphaTest: 0.1, + }); + + const cube = new THREE.Mesh(geometry, material); + scene.add(cube); + + ... +``` + +예제를 실행시키면 바로 문제가 보일 겁니다. + +{{{example url="../threejs-picking-raycaster-transparency.html" }}} + +정육면체의 빈 공간을 통해 무언가를 선택할 수가 없죠. + +<div class="threejs_center"><img src="resources/images/picking-transparent-issue.jpg" style="width: 635px;"></div> + +이는 자바스크립트가 텍스처나 재질을 보고 해당 요소가 투명한지 판단하기가 어렵기 때문입니다. + +이 문제를 해결하려면 GPU 기반 피킹을 구현해야 합니다. 이론적으로는 간단하지만 위에서 사용한 광선 투사법보다는 좀 더 복잡하죠. + +GPU 피킹을 구현하려면 각 요소를 별도의 화면에서 고유한 색상으로 렌더링해야 합니다. 그리고 포인터 아래에 있는 픽셀의 색을 가져와 해당 요소가 선택됐는지 확인하는 거죠. + +이러면 위에서 언급한 문제점 2, 3번이 해결됩니다. 1번, 성능의 경우는 상황에 따라 천차만별이죠. 눈에 보이는 화면을 위해 한 번, 피킹을 위해 한 번, 이렇게 매 요소를 총 두 번씩 렌더링해야 합니다. 더 복잡한 해결책을 쓰면 렌더링을 한 번만 할 수도 있지만, 이 글에서는 일단 더 간단한 방법을 사용하겠습니다. + +성능 최적화를 위해 시도할 수 있는 방법이 하나 있습니다. 어차피 픽셀을 하나만 읽을 것이니, 카메라를 픽셀 하나만 렌더링하도록 설정하는 것이죠. `PerspectiveCamera.setViewOffset` 메서드를 사용하면 카메라의 특정 부분만 렌더링하도록 할 수 있습니다. 이러면 성능 향상에 조금이나마 도움이 되겠죠. + +현재 Three.js에서 이 기법을 구현하려면 장면 2개를 사용해야 합니다. 하나는 기존 mesh를 그대로 쓰고, 나머지 하나는 피킹용 재질을 적용한 mesh를 쓸 겁니다. + +먼저 두 번째 장면을 추가하고 배경을 검정으로 지정합니다. + +```js +const scene = new THREE.Scene(); +scene.background = new THREE.Color('white'); +const pickingScene = new THREE.Scene(); +pickingScene.background = new THREE.Color(0); +``` + +각 정육면체를 장면에 추가할 때 `pickingScene`의 같은 위치에 "피킹용 정육면체"를 추가합니다. 그리고 각 피킹용 정육면체에는 id로 쓸 고유 색상값을 지정한 뒤, 이 id 색상값으로 재질을 만들어 추가합니다. id 색상값을 정육면체의 키값으로 매핑해 놓으면 나중에 상응하는 정육면체를 바로 불러올 수 있겠죠. + +```js +const idToObject = {}; ++const numObjects = 100; +for (let i = 0; i < numObjects; ++i) { ++ const id = i + 1; + const material = new THREE.MeshPhongMaterial({ + color: randomColor(), + map: texture, + transparent: true, + side: THREE.DoubleSide, + alphaTest: 0.1, + }); + + const cube = new THREE.Mesh(geometry, material); + scene.add(cube); ++ idToObject[id] = cube; + + cube.position.set(rand(-20, 20), rand(-20, 20), rand(-20, 20)); + cube.rotation.set(rand(Math.PI), rand(Math.PI), 0); + cube.scale.set(rand(3, 6), rand(3, 6), rand(3, 6)); + ++ const pickingMaterial = new THREE.MeshPhongMaterial({ ++ emissive: new THREE.Color(id), ++ color: new THREE.Color(0, 0, 0), ++ specular: new THREE.Color(0, 0, 0), ++ map: texture, ++ transparent: true, ++ side: THREE.DoubleSide, ++ alphaTest: 0.5, ++ blending: THREE.NoBlending, ++ }); ++ const pickingCube = new THREE.Mesh(geometry, pickingMaterial); ++ pickingScene.add(pickingCube); ++ pickingCube.position.copy(cube.position); ++ pickingCube.rotation.copy(cube.rotation); ++ pickingCube.scale.copy(cube.scale); +} +``` + +위 코드에서는 `MeshPhongMaterial`로 편법을 사용했습니다. `emissive` 속성을 id 색상값으로, `color`와 `specular` 속성을 0으로 설정하면 텍스처의 알파값이 `alphaTest`보다 큰 부분만 id 색상값으로 보이겠죠. 또 `blending` 속성을 `THREE.NoBlending`으로 설정해 id 색상값이 알파값의 영향을 받지 않도록 했습니다. + +제가 사용한 편법이 최적의 해결책은 아닙니다. 여러가지 옵션을 껐다고 해도 여전히 조명 관련 연산을 실행할 테니까요. 코드를 더 최적화하려면 `alphaTest` 값보다 높은 경우에만 id 색상을 렌더링하는 쉐이더를 직접 만들어야 합니다. + +광선 투사법을 쓸 때와 달리 픽셀을 하나만 사용하므로 위치값이 픽셀 하나만 가리키게 변경합니다. + +```js +function setPickPosition(event) { + const pos = getCanvasRelativePosition(event); +- pickPosition.x = (pos.x / canvas.clientWidth ) * 2 - 1; +- pickPosition.y = (pos.y / canvas.clientHeight) * -2 + 1; // Y 축을 뒤집었음 ++ pickPosition.x = pos.x; ++ pickPosition.y = pos.y; +} +``` + +`PickHelper` 클래스도 `GPUPickHelper`로 변경합니다. [렌더 타겟(render target)에 관한 글](threejs-rendertargets.html)에서 다룬 `WebGLRenderTarget`을 써 구현하되, 이번 렌더 타겟의 크기는 1x1, 1픽셀입니다. + +```js +-class PickHelper { ++class GPUPickHelper { + constructor() { +- this.raycaster = new THREE.Raycaster(); ++ // 1x1 픽셀 크기의 렌더 타겟을 생성합니다 ++ this.pickingTexture = new THREE.WebGLRenderTarget(1, 1); ++ this.pixelBuffer = new Uint8Array(4); + this.pickedObject = null; + this.pickedObjectSavedColor = 0; + } + pick(cssPosition, scene, camera, time) { ++ const {pickingTexture, pixelBuffer} = this; + + // 기존에 선택된 요소가 있는 경우 색을 복원합니다 + if (this.pickedObject) { + this.pickedObject.material.emissive.setHex(this.pickedObjectSavedColor); + this.pickedObject = undefined; + } + ++ // view offset을 마우스 포인터 아래 1픽셀로 설정합니다 ++ const pixelRatio = renderer.getPixelRatio(); ++ camera.setViewOffset( ++ renderer.getContext().drawingBufferWidth, // 전체 너비 ++ renderer.getContext().drawingBufferHeight, // 전체 높이 ++ cssPosition.x * pixelRatio \| 0, // 사각 x 좌표 ++ cssPosition.y * pixelRatio \| 0, // 사각 y 좌표 ++ 1, // 사각 좌표 width ++ 1, // 사각 좌표 height ++ ); ++ // 장면을 렌더링합니다 ++ renderer.setRenderTarget(pickingTexture) ++ renderer.render(scene, camera); ++ renderer.setRenderTarget(null); ++ ++ // view offset을 정상으로 돌려 원래의 화면을 렌더링하도록 합니다 ++ camera.clearViewOffset(); ++ // 픽셀을 감지합니다 ++ renderer.readRenderTargetPixels( ++ pickingTexture, ++ 0, // x ++ 0, // y ++ 1, // width ++ 1, // height ++ pixelBuffer); ++ ++ const id = ++ (pixelBuffer[0] << 16) \| ++ (pixelBuffer[1] << 8) \| ++ (pixelBuffer[2] ); + + // 절두체 안에 광선을 쏩니다 +- this.raycaster.setFromCamera(normalizedPosition, camera); + // 광선과 교차하는 물체들을 배열로 만듭니다 +- const intersectedObjects = this.raycaster.intersectObjects(scene.children); +- if (intersectedObjects.length) { + // 첫 번째 물체가 제일 가까우므로 해당 물체를 고릅니다 +- this.pickedObject = intersectedObjects[0].object; + ++ const intersectedObject = idToObject[id]; ++ if (intersectedObject) { + // 첫 번째 물체가 제일 가까우므로 해당 물체를 고릅니다 ++ this.pickedObject = intersectedObject; + // 기존 색을 저장해둡니다 + this.pickedObjectSavedColor = this.pickedObject.material.emissive.getHex(); + // emissive 색을 빨강/노랑으로 빛나게 만듭니다 + this.pickedObject.material.emissive.setHex((time * 8) % 2 > 1 ? 0xFFFF00 : 0xFF0000); + } + } +} +``` + +인스턴스를 만드는 쪽도 수정합니다. + +```js +-const pickHelper = new PickHelper(); ++const pickHelper = new GPUPickHelper(); +``` + +`pick` 메서드를 호출할 때 `scene` 대신 `pickScene`을 넘겨줍니다. + +```js +- pickHelper.pick(pickPosition, scene, camera, time); ++ pickHelper.pick(pickPosition, pickScene, camera, time); +``` + +이제 투명한 부분을 관통해 요소를 선택할 수 있습니다. + +{{{example url="../threejs-picking-gpu.html" }}} + +이 글이 피킹을 구현하는 데 도움이 되었으면 좋겠네요. 나중에 요소를 마우스로 조작하는 법에 대해서도 한 번 써보겠습니다. \ No newline at end of file	true
Other	mrdoob	three.js	633dbb61bdfd242077b4c012fce7468c1e707c1a.json	add translation kr/threejs-rendering-on-demand.md add translation kr/threejs-transparency.md update translation kr/threejs-prerequisites.md add translation kr/threejs-multiple-scenes.md add translation kr/threejs-picking.md fix typo & add translation kr/threejs-post-processing.md add translation kr/threejs-post-processing-3dlut.md	threejs/lessons/kr/threejs-post-processing-3dlut.md	@@ -0,0 +1,502 @@ +Title: 3DLUT로 후처리하기 +Description: Three.js에서 3DLUT로 후처리하는 법을 알아봅니다 +TOC: LUT 파일로 후처리 효과 적용하기 + +이전 글에서는 [후처리(Post processing)](threejs-post-processing.html)에 관해 알아보았습니다. 보통 후처리는 LUT 또는 3DLUT라고 부르기도 합니다. LUT는 룩업 테이블(Look-Up Table, 순람표)의 줄임말이고, 3DLUT는 3차원 룩업 테이블의 줄임말입니다. + +3DLUT는 2D 이미지를 특정한 색상 정육면체를 매핑한다고 생각하면 쉽습니다. 먼저 원본 이미지의 색상을 정육면체의 인덱스 값과 매칭시킵니다. 원본 이미지의 픽셀 하나당 해당 픽셀 색상의 빨강(red), 초록(green), 파랑(blue) 값을 이용해 정육면체의 특정 지점을 가리키는(look-up) 3D 벡터 인덱스를 만드는 것이죠. 이 인덱스를 통해 3DLUT에서 뽑아낸 값을 새로운 색으로 사용하는 겁니다. + +자바스크립트의 경우 아래처럼 구현할 수 있습니다. RGB 각 색상값을 0부터 255의 정수로 표현한 3차원 256x256x256 배열로 룩업 테이블을 구현하고, 이 룩업 테이블에서 RGB 색상값을 이용해 새로운 색상값을 선택하는 거죠. + +```js +const newColor = lut[origColor.red][origColor.green][origColor.blue] +``` + +물론 256x256x256 배열은 큰 배열입니다. [텍스처에 관한 글](threejs-textures.html)에서 배웠듯 텍스처는 크기에 상관 없이 0.0에서 1.0로 값을 지정합니다. + +8x8x8 정육면체를 예로 들어보죠. + +<div class="threejs_center"><img src="resources/images/3dlut-rgb.svg" class="noinvertdark" style="width: 500px"></div> + +먼저 0,0,0 부분을 검정색으로 채웁니다. 맞은편의 1,1,1 부분은 하얀색, 1,0,0 부분은 <span style="color:red;">빨강</span>, 0,1,0은 <span style="color:green;">초록</span>, 0,0,1은 <span style="color:blue;">파랑</span>으로 채웁니다. + +<div class="threejs_center"><img src="resources/images/3dlut-axis.svg" class="noinvertdark" style="width: 500px"></div> + +그리고 각 축을 따라 색을 채워넣습니다. + +<div class="threejs_center"><img src="resources/images/3dlut-edges.svg" class="noinvertdark" style="width: 500px"></div> + +빈 모서리를 2개 이상의 색상 채널을 사용하는 색으로 채웁니다(초록 + 빨강, 파랑 + 빨강 등). + +<div class="threejs_center"><img src="resources/images/3dlut-standard.svg" class="noinvertdark" style="width: 500px"></div> + +마지막으로 빈 공간을 채웁니다. 이 형태가 3DLUT 기본 구조입니다. 지금은 효과를 주기 전과 후의 차이가 없습니다. 색상값을 인덱스로 사용해 새로운 색상값을 선택하면, 정확히 같은 색상값이 나오기 때문이죠. + +<div class="threejs_center"><object type="image/svg+xml" data="resources/images/3dlut-standard-lookup.svg" class="noinvertdark" data-diagram="lookup" style="width: 600px"></object></div> + +이 정육면체를 호박색 쉐이드로 바꾸면 같은 인덱스를 참조하지만 전혀 다른 결과가 나옵니다. + +<div class="threejs_center"><object type="image/svg+xml" data="resources/images/3dlut-amber-lookup.svg" class="noinvertdark" data-diagram="lookup" style="width: 600px"></object></div> + +이 기법을 사용하면 룩업 테이블을 교체하는 것으로 많은 효과를 구현할 수 있습니다. 색상 계산 기반의 효과는 대부분 하나의 색상값만을 사용합니다. 색상, 대비, 채도, 컬러 캐스트(color cast), 틴트(tint), 밝기, 노출도, 레벨, 커브, 포스터화, 그림자, 강조, 등 거의 모든 효과를 색상값 계산을 기반으로 구현하죠. 또 이 모든 효과를 하나의 룩업 테이블로 합칠 수도 있습니다. + +룩업 테이블을 사용하려면 먼저 적용할 장면이 필요하니 간단한 장면을 하나 만들어보겠습니다. [glTF 불러오기](threejs-load-gltf.html)에서 배웠듯 glTF 파일을 불러와 사용하겠습니다. 예제에 사용할 모델은 [The Ice Wolves](https://sketchfab.com/sarath.irn.kat005)의 [작품](https://sketchfab.com/models/a1d315908e9f45e5a3bc618bdfd2e7ee)입니다. + +[배경과 하늘 상자](threejs-backgrounds.html)에서 배웠던 대로 배경도 추가하겠습니다. + +{{{example url="../threejs-postprocessing-3dlut-prep.html" }}} + +이제 장면을 구현했으니 3DLUT를 만들어야 합니다. 가장 간단한 3DLUT는 2x2x2 identity LUT로, 여기서 identity(동일한)은 아무런 변화도 없음을 의미합니다. 1을 곱하거나 아무것도 안 하는 경우와 같죠. LUT 안의 색상값을 사용한다고 해도 입력된 값과 정확히 같은 값을 반환할 테니까요. + +<div class="threejs_center"><img src="resources/images/3dlut-standard-2x2.svg" class="noinvertdark" style="width: 200px"></div> + +WebGL1은 3D 텍스쳐를 지원하지 않습니다. 따라서 3D 텍스처를 썰어 펼쳐 놓은 형태의 4x2짜리 2D 텍스처를 대신 사용하겠습니다. + +아래는 4x2 2D 텍스처로 identity LUT를 구현한 것입니다. + +```js +const makeIdentityLutTexture = function() { + const identityLUT = new Uint8Array([ + 0, 0, 0, 255, // black + 255, 0, 0, 255, // red + 0, 0, 255, 255, // blue + 255, 0, 255, 255, // magenta + 0, 255, 0, 255, // green + 255, 255, 0, 255, // yellow + 0, 255, 255, 255, // cyan + 255, 255, 255, 255, // white + ]); + + return function(filter) { + const texture = new THREE.DataTexture(identityLUT, 4, 2, THREE.RGBAFormat); + texture.minFilter = filter; + texture.magFilter = filter; + texture.needsUpdate = true; + texture.flipY = false; + return texture; + }; +}(); +``` + +필터가 들어간 것, 안 들어간 것 총 2개를 만들겠습니다. + +```js +const lutTextures = [ + { name: 'identity', size: 2, texture: makeIdentityLutTexture(THREE.LinearFilter) }, + { name: 'identity not filtered', size: 2, texture: makeIdentityLutTexture(THREE.NearestFilter) }, +]; +``` + +[후처리에 관한 글](threejs-post-processing.html)에서 작성했던 코드를 가져와 이 쉐이더들을 대신 쓰도록 합니다. + +```js +const lutShader = { + uniforms: { + tDiffuse: { value: null }, + lutMap: { value: null }, + lutMapSize: { value: 1, }, + }, + vertexShader: ` + varying vec2 vUv; + void main() { + vUv = uv; + gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 ); + } + `, + fragmentShader: ` + #include <common> + + #define FILTER_LUT true + + uniform sampler2D tDiffuse; + uniform sampler2D lutMap; + uniform float lutMapSize; + + varying vec2 vUv; + + vec4 sampleAs3DTexture(sampler2D tex, vec3 texCoord, float size) { + float sliceSize = 1.0 / size; // space of 1 slice + float slicePixelSize = sliceSize / size; // space of 1 pixel + float width = size - 1.0; + float sliceInnerSize = slicePixelSize * width; // space of size pixels + float zSlice0 = floor( texCoord.z * width); + float zSlice1 = min( zSlice0 + 1.0, width); + float xOffset = slicePixelSize * 0.5 + texCoord.x * sliceInnerSize; + float yRange = (texCoord.y * width + 0.5) / size; + float s0 = xOffset + (zSlice0 * sliceSize); + + #ifdef FILTER_LUT + + float s1 = xOffset + (zSlice1 * sliceSize); + vec4 slice0Color = texture2D(tex, vec2(s0, yRange)); + vec4 slice1Color = texture2D(tex, vec2(s1, yRange)); + float zOffset = mod(texCoord.z * width, 1.0); + return mix(slice0Color, slice1Color, zOffset); + + #else + + return texture2D(tex, vec2( s0, yRange)); + + #endif + } + + void main() { + vec4 originalColor = texture2D(tDiffuse, vUv); + gl_FragColor = sampleAs3DTexture(lutMap, originalColor.xyz, lutMapSize); + } + `, +}; + +const lutNearestShader = { + uniforms: Object.assign( {}, lutShader.uniforms ), + vertexShader: lutShader.vertexShader, + fragmentShader: lutShader.fragmentShader.replace('#define FILTER_LUT', '//'), +}; +``` + +fragment 쉐이더의 다음 코드는 + +```glsl +#define FILTER_LUT true +``` + +주석 처리했던 두 번째 쉐이더를 생성하기 위한 것입니다. + +그리고 각 쉐이더로 `Pass`를 만듭니다. + +```js +const effectLUT = new THREE.ShaderPass(lutShader); +effectLUT.renderToScreen = true; +const effectLUTNearest = new THREE.ShaderPass(lutNearestShader); +effectLUTNearest.renderToScreen = true; +``` + +기존에 배경과 glTF를 별도 장면으로 분리했으므로 각 장면의 `RenderPass`를 따로 생성합니다. + +```js +const renderModel = new THREE.RenderPass(scene, camera); +renderModel.clear = false; // 배경을 지우지 않도록 합니다 +const renderBG = new THREE.RenderPass(sceneBG, cameraBG); +``` + +다음으로 사용할 pass를 `EffectComposer`에 추가합니다. + +※ 편의상 `Pass` 인스턴스를 pass로 번역합니다. + +```js +const rtParameters = { + minFilter: THREE.LinearFilter, + magFilter: THREE.LinearFilter, + format: THREE.RGBFormat, +}; +const composer = new THREE.EffectComposer(renderer, new THREE.WebGLRenderTarget(1, 1, rtParameters)); + +composer.addPass(renderBG); +composer.addPass(renderModel); +composer.addPass(effectLUT); +composer.addPass(effectLUTNearest); +``` + +GUI를 만들어 LUT를 바꿀 수 있도록 합니다. + +```js +const lutNameIndexMap = {}; +lutTextures.forEach((info, ndx) => { + lutNameIndexMap[info.name] = ndx; +}); + +const lutSettings = { + lut: lutNameIndexMap.identity, +}; +const gui = new GUI({ width: 300 }); +gui.add(lutSettings, 'lut', lutNameIndexMap); +``` + +마지막으로 필터링 여부에 따라 효과가 바뀌도록 설정합니다. LUT가 선택한 텍스처를 사용하도록 하고, `EffectComposer`로 렌더링 합니다. + +```js +const lutInfo = lutTextures[lutSettings.lut]; + +const effect = lutInfo.filter ? effectLUT : effectLUTNearest; +effectLUT.enabled = lutInfo.filter; +effectLUTNearest.enabled = !lutInfo.filter; + +const lutTexture = lutInfo.texture; +effect.uniforms.lutMap.value = lutTexture; +effect.uniforms.lutMapSize.value = lutInfo.size; + +composer.render(delta); +``` + +identity 3DLUT를 선택했을 때는 아무런 변화가 없습니다. + +{{{example url="../threejs-postprocessing-3dlut-identity.html" }}} + +하지만 필터가 identity not filtered LUT를 선택하면 재미있는 결과가 나옵니다. + +<div class="threejs_center"><img src="resources/images/unfiltered-3dlut.jpg" style="width: 500px"></div> + +왜 이런 결과가 나온 걸까요? 필터링을 사용할 경우(linear), GPU는 선형적으로 색상값을 채워넣습니다. 필터링을 사용하지 않을 경우(nearest), 알아서 색상값을 채워넣지 않기에 3DLUT에서(근처의) 색상값이 있는 곳을 찾아 사용하는 것이죠. + +어느정도 이해했다면 더 다양한 3DLUT를 만들어봅시다. + +먼저 룩업 테이블의 해상도를 정하고 간단한 코드를 만들어 룩업 테이블 정육면체의 각 면을 만들겠습니다. + +```js +const ctx = document.querySelector('canvas').getContext('2d'); + +function drawColorCubeImage(ctx, size) { + const canvas = ctx.canvas; + canvas.width = size size; + canvas.height = size; + + for (let zz = 0; zz < size; ++zz) { + for (let yy = 0; yy < size; ++yy) { + for (let xx = 0; xx < size; ++xx) { + const r = Math.floor(xx / (size - 1) * 255); + const g = Math.floor(yy / (size - 1) * 255); + const b = Math.floor(zz / (size - 1) * 255); + ctx.fillStyle = `rgb(${ r },${ g },${ b })`; + ctx.fillRect(zz * size + xx, yy, 1, 1); + } + } + } + document.querySelector('#width').textContent = canvas.width; + document.querySelector('#height').textContent = canvas.height; +} + +drawColorCubeImage(ctx, 8); +``` + +캔버스 요소도 만듭니다. + +```html +<canvas></canvas> +``` + +이제 어떤 identity 3D 룩업 테이블이든 만들 수 있습니다. + +{{{example url="../3dlut-base-cube-maker.html" }}} + +해상도가 높을수록 더 세밀한 효과를 줄 수 있지만 정육면체형 데이터의 크기는 기하급수적으로 늘어납니다. 크기 8x8 정육면체는 2kb 정도지만 64x64 정육면체는 약 1mb나 되죠. 그러니 충분히 효과를 구현할 수 있는 만큼만 사용하는 게 좋습니다. + +사이즈를 16으로 설정하고 `Save...` 버튼을 클릭하면 아래와 같은 파일이 나옵니다. + +<div class="threejs_center"><img src="resources/images/identity-lut-s16.png"></div> + +그리고 LUT를 적용할 화면을 캡쳐해야 합니다. 이 경우에는 이전에 만든 장면에 아무런 효과를 주지 않은 화면이겠죠. 대게 위 예제를 오른쪽 클릭해 "다른 이름으로 저장..."을 클릭하면 되지만, OS에 따라 마우스 우클릭이 동작하지 않을 수 있습니다. 제 경우 OS에 내장된 스크린샷 기능을 이용해 화면을 캡쳐했습니다. + +※ Windows 10 RS5(레드스톤 5) 이상이라면 `Windows + Shift + S`를 눌러 화면을 캡쳐할 수 있습니다. 역주. + +<div class="threejs_center"><img src="resources/images/3dlut-screen-capture.jpg" style="width: 600px"></div> + +캡쳐본을 이미지 에디터에서 불러옵니다. 저는 포토샵을 사용해 샘플 이미지를 불러오고, 한쪽 귀퉁이에 3DLUT를 붙여 넣었습니다. + +> 참고: 제 경우 포토샵에서 캡쳐본 위에 lut 파일을 불러오려고 했을 때 이미지가 두 배 더 커졌습니다. 아마 DPI를 맞추거나 하는 이유 때문에 그런 거겠죠. lut 파일을 별도 탭에 불러와 캡쳐본 위에 복사 붙여 넣기 하니 정상적으로 불러와지더군요. + +<div class="threejs_center"><img src="resources/images/3dlut-photoshop-before.jpg" style="width: 600px"></div> + +그리고 이미지에 부여하고 싶은 색상 효과를 부여합니다. 포토샵의 경우 대부분의 효과는 이미지(Image)->조정(Adjustments) 메뉴에 있습니다. + +<div class="threejs_center"><img src="resources/images/3dlut-photoshop-after.jpg" style="width: 600px"></div> + +색상을 조정하면 3DLUT 이미지에도 같은 효과가 적용될 겁니다. + +자 그럼 이제 이걸 어떻게 쓸 수 있을까요? + +먼저 저는 3DLUT 이미지를 `3dlut-red-only-s16.png`라는 이름으로 저장했습니다. 메모리를 아끼려면 이미지를 LUT 부분만 잘라 16x256로 맞추는 것이 좋지만, 그냥 재미삼아 이미지를 불러온 이후 자르겠습니다. 이 방법의 장점은 귀찮게 이미지를 자르는 과정 없이 효과를 적용해보고 싶은 대로 바로바로 적용할 수 있다는 것이죠. 물론 대역폭을 낭비한다는 게 단점입니다. + +※ 포토샵 CC 이후 버젼을 사용한다면 레이어를 오른쪽 클릭해 `PNG로 빠르게 내보내기` 메뉴로 해당 그룹 또는 레이어만 .png 파일로 내보낼 수 있습니다. 이미지를 귀찮게 자르는 과정 없이 .png 파일을 바로 생성할 수 있죠. 역주. + +아래는 이미지를 불러오는 코드입니다. 실제 코드에서는 텍스처를 불러왔을 때 바로 사용할 수 있도록 identity lut를 먼저 만들었습니다. 그 다음 이미지를 불러와 3DLUT 부분만 캔버스에 복사하고, 캔버스에서 가져온 데이터를 텍스처에 지정합니다. 또한 텍스처가 바뀌었을 때 바로 적용하도록 `needsUpdate` 속성도 true로 설정합니다. + +```js +const makeLUTTexture = function() { + const imgLoader = new THREE.ImageLoader(); + const ctx = document.createElement('canvas').getContext('2d'); + + return function(info) { + const texture = makeIdentityLutTexture( + info.filter ? THREE.LinearFilter : THREE.NearestFilter); + + if (info.url) { + const lutSize = info.size; + + /** + * 크기를 2(identity LUT의 크기)로 설정합니다. 이 크기는 나중에 이미지를 + * 불러온 뒤 복원합니다. 이러면 lut를 사용하는 코드는 이미지의 적용 여부를 + * 신경쓰지 않아도 됩니다. + */ + info.size = 2; + + imgLoader.load(info.url, function(image) { + const width = lutSize lutSize; + const height = lutSize; + info.size = lutSize; + ctx.canvas.width = width; + ctx.canvas.height = height; + ctx.drawImage(image, 0, 0); + const imageData = ctx.getImageData(0, 0, width, height); + + texture.image.data = new Uint8Array(imageData.data.buffer); + texture.image.width = width; + texture.image.height = height; + texture.needsUpdate = true; + }); + } + + return texture; + }; +}(); +``` + +기존 코드가 LUT png 파일을 사용하도록 수정합니다. + +```js +const lutTextures = [ + { name: 'identity', size: 2, filter: true , }, + { name: 'identity no filter', size: 2, filter: false, }, ++ { name: 'custom', url: 'resources/images/lut/3dlut-red-only-s16.png' }, +]; + ++lutTextures.forEach((info) => { ++ // 사이즈값이 없다면 사이즈 정보를 파일 이름에서 가져옵니다. ++ if (!info.size) { ++ /** ++ * 파일 이름이 '-s<숫자>[n]' 이렇게 끝난다고 가정합니다. ++ * <숫자>는 3DLUT 정육면체의 크기입니다. ++ * [n]은 '필터링 없음' 또는 'nearest'를 의미합니다. ++ * ++ * 예시: ++ * 'foo-s16.png' = 크기:16, 필터: true ++ * 'bar-s8n.png' = 크기:8, 필터: false ++ */ ++ const m = /-s(\d+)(n)\.[^.]+$/.exec(info.url); ++ if (m) { ++ info.size = parseInt(m[1]); ++ info.filter = info.filter === undefined ? m[2] !== 'n' : info.filter; ++ } ++ } ++ ++ info.texture = makeLUTTexture(info); ++}); +``` + +위 코드가 LUT의 사이즈를 파일 이름에 인코딩한 예입니다. 이러면 png로 LUT를 바꾸기가 훨씬 쉽죠. + +그냥은 좀 심심하니 lut png 파일을 더 많이 만들어봅시다. + +```js +const lutTextures = [ + { name: 'identity', size: 2, filter: true , }, + { name: 'identity no filter', size: 2, filter: false, }, + { name: 'custom', url: 'resources/images/lut/3dlut-red-only-s16.png' }, ++ { name: 'monochrome', url: 'resources/images/lut/monochrome-s8.png' }, ++ { name: 'sepia', url: 'resources/images/lut/sepia-s8.png' }, ++ { name: 'saturated', url: 'resources/images/lut/saturated-s8.png', }, ++ { name: 'posterize', url: 'resources/images/lut/posterize-s8n.png', }, ++ { name: 'posterize-3-rgb', url: 'resources/images/lut/posterize-3-rgb-s8n.png', }, ++ { name: 'posterize-3-lab', url: 'resources/images/lut/posterize-3-lab-s8n.png', }, ++ { name: 'posterize-4-lab', url: 'resources/images/lut/posterize-4-lab-s8n.png', }, ++ { name: 'posterize-more', url: 'resources/images/lut/posterize-more-s8n.png', }, ++ { name: 'inverse', url: 'resources/images/lut/inverse-s8.png', }, ++ { name: 'color negative', url: 'resources/images/lut/color-negative-s8.png', }, ++ { name: 'high contrast', url: 'resources/images/lut/high-contrast-bw-s8.png', }, ++ { name: 'funky contrast', url: 'resources/images/lut/funky-contrast-s8.png', }, ++ { name: 'nightvision', url: 'resources/images/lut/nightvision-s8.png', }, ++ { name: 'thermal', url: 'resources/images/lut/thermal-s8.png', }, ++ { name: 'b/w', url: 'resources/images/lut/black-white-s8n.png', }, ++ { name: 'hue +60', url: 'resources/images/lut/hue-plus-60-s8.png', }, ++ { name: 'hue +180', url: 'resources/images/lut/hue-plus-180-s8.png', }, ++ { name: 'hue -60', url: 'resources/images/lut/hue-minus-60-s8.png', }, ++ { name: 'red to cyan', url: 'resources/images/lut/red-to-cyan-s8.png' }, ++ { name: 'blues', url: 'resources/images/lut/blues-s8.png' }, ++ { name: 'infrared', url: 'resources/images/lut/infrared-s8.png' }, ++ { name: 'radioactive', url: 'resources/images/lut/radioactive-s8.png' }, ++ { name: 'goolgey', url: 'resources/images/lut/googley-s8.png' }, ++ { name: 'bgy', url: 'resources/images/lut/bgy-s8.png' }, +]; +``` + +아래 예제에서 여러 lut를 시험해볼 수 있습니다. + +{{{example url="../threejs-postprocessing-3dlut.html" }}} + +추가로 한 가지 덧붙이겠습니다. 인터넷을 뒤져보니 Adobe에서 만든 표준 LUT 형식이 있더군요. [인터넷에서 검색](https://www.google.com/search?q=lut+files)해보면 이런 LUT 형식의 파일을 쉽게 찾을 수 있을 겁니다. + +이를 기반으로 간단하게 로더를 작성했습니다. 총 4가지 형식이 있다고는 하나, 제가 찾은 형식은 하나뿐이라 모든 형식에서 테스트하진 못했습니다. + +여기에 간단한 드래그-앤-드롭 라이브러리도 만들었습니다. 이 두 라이브러리를 이용해 여러분이 직접 LUT 파일을 적용할 수 있도록 말이죠. + +먼저 앞서 만든 두 라이브러리를 불러온 뒤 + +```js +import * as lutParser from './resources/lut-reader.js'; +import * as dragAndDrop from './resources/drag-and-drop.js'; +``` + +아래처럼 사용합니다. + +```js +dragAndDrop.setup({ msg: 'Drop LUT File here' }); +dragAndDrop.onDropFile(readLUTFile); + +function readLUTFile(file) { + const reader = new FileReader(); + reader.onload = (e) => { + const lut = lutParser.lutTo2D3Drgb8(lutParser.parse(e.target.result)); + const {size, data, name} = lut; + const texture = new THREE.DataTexture(data, size * size, size, THREE.RGBFormat); + texture.minFilter = THREE.LinearFilter; + texture.needsUpdate = true; + texture.flipY = false; + const lutTexture = { + name: (name && name.toLowerCase().trim() !== 'untitled') + ? name + : file.name, + size: size, + filter: true, + texture, + }; + lutTextures.push(lutTexture); + lutSettings.lut = lutTextures.length - 1; + updateGUI(); + }; + + reader.readAsText(file); +} +``` + +GUI가 새로 불러온 파일을 반영하도록 코드를 추가합니다. + +```js +const lutSettings = { + lut: lutNameIndexMap.thermal, +}; +const gui = new GUI({ width: 300 }); +gui.addFolder('Choose LUT or Drag&Drop LUT File(s)'); + +let lutGUI; +function updateGUI() { + makeLutNameIndexMap(); + if (lutGUI) { + gui.remove(lutGUI); + } + lutGUI = gui.add(lutSettings, 'lut', lutNameIndexMap); +} +updateGUI(); +``` + +이제 [Adobe LUT 파일](https://www.google.com/search?q=lut+files)을 다운해 아래 예제에 드래그-앤-드롭으로 불러올 수 있을 겁니다. + +{{{example url="../threejs-postprocessing-3dlut-w-loader.html" }}} + +다만 Adobe LUT는 온라인 환경에 최적화되지 않았습니다. 파일 용량이 꽤 큰 편이죠. 아래 예제를 사용하면 용량을 좀 더 줄일 수 있습니다. 드래그-앤-드롭으로 파일을 불러오고 크기를 선택한 뒤 "Save..." 버튼을 클릭하면 되죠. + +아래 예제는 단순히 위에서 썼던 예제를 조금 수정한 것입니다. glFT 파일 없이 배경만 렌더링한 것이죠. 배경 이미지는 아까 본 스크립트로 만든 identity lut 이미지입니다. 여기에 LUT 파일을 불러와 해당 LUT 파일을 PNG로 만드는 데 사용하는 것이죠. + +{{{example url="../threejs-postprocessing-adobe-lut-to-png-converter.html" }}} + +이 글에서는 쉐이더가 어떻게 작동하는지에 대해서는 아예 설명하지 않았습니다. 나중에 GLSL에 대해 더 다룰 기회가 있었으면 좋겠네요. 쉐이더의 작동 방식을 알고 싶다면 [후처리에 관한 글](threejs-post-processing.html)에 있는 링크 또는 [이 유튜브 영상](https://www.youtube.com/watch?v=rfQ8rKGTVlg#t=24m30s)을 참고하기 바랍니다. + +<script type="module" src="../resources/threejs-post-processing-3dlut.js"></script>	true
Other	mrdoob	three.js	633dbb61bdfd242077b4c012fce7468c1e707c1a.json	add translation kr/threejs-rendering-on-demand.md add translation kr/threejs-transparency.md update translation kr/threejs-prerequisites.md add translation kr/threejs-multiple-scenes.md add translation kr/threejs-picking.md fix typo & add translation kr/threejs-post-processing.md add translation kr/threejs-post-processing-3dlut.md	threejs/lessons/kr/threejs-post-processing.md	@@ -0,0 +1,254 @@ +Title: Three.js 후처리 +Description: Three.js로 후처리하는 법을 알아봅니다 +TOC: 후처리 + +후처리(post processing)란 보통 2D 이미지에 어떤 효과나 필터를 넣는 것을 의미합니다. Three.js는 다양한 mesh로 이루어진 장면을 2D 이미지로 렌더링하죠. 일반적으로 이 이미지는 바로 캔버스를 통해 브라우저 화면에 렌더링됩니다. 하지만 대신 이 이미지를 [렌더 타겟에 렌더링하고](threejs-rendertargets.html) 캔버스에 보내기 전 임의의 후처리 효과를 줄 수 있습니다. + +인스타그램 필터, 포토샵 필터 등이 후처리의 좋은 예이죠. + +Three.js에는 후처리를 순차적으로 처리해주는 모범 클래스가 있습니다. 일단 `EffectComposer`의 인스턴스를 만들고 여기에 `Pass` 객체(효과, 필터)들을 추가합니다. 그리고 `EffectComposer.render` 메서드를 호출하면 현재 장면을 [렌더 타겟](threejs-rendertargets.html)에 렌더링한 뒤 각 pass를 순서대로 적용합니다. + +※ 편의상 `Pass` 인스턴스를 pass로 번역합니다. + +이 pass는 비넷(vignette), 흐림(blur), 블룸(bloom), 필름 그레인(film grain) 효과 또는 hue, 채도(saturation), 대비(contrast) 조정 등의 후처리 효과로, 이 효과를 모두 적용한 결과물을 최종적으로 캔버스에 렌더링합니다. + +여기서 어느 정도 `EffectComposer`의 원리를 이해할 필요가 있습니다. `EffectComposer`는 두 개의 [렌더 타겟](threejs-rendertargets.html)을 사용합니다. 편의상 이 둘을 rtA, rtB라고 부르도록 하죠. + +`EffectComposer.addPass`를 각 pass를 적용할 순서대로 호출하고 `EffectComposer.render`를 호출하면 pass는 아래 그림과 같은 순서로 적용됩니다. + +<div class="threejs_center"><img src="resources/images/threejs-postprocessing.svg" style="width: 600px"></div> + +먼저 `RenderPass`에 넘긴 장면을 rtA에 렌더링합니다. 그리고 rtA를 다음 pass에 넘겨주면 해당 pass는 rtA에 pass를 적용한 결과를 rtB에 렌더링합니다. 그런 다음 rtB를 다음 pass로 넘겨 적용한 결과를 rtA에, rtA에 pass를 적용한 결과를 다시 rtB에, 이런 식으로 모든 pass가 끝날 때까지 계속 반복합니다. + +`Pass`에는 공통적으로 4가지 옵션이 있습니다. + +## `enabled` + +이 pass를 사용할지의 여부입니다. + +## `needsSwap` + +이 pass를 적용한 후 `rtA`와 `rtB`를 바꿀지의 여부입니다. + +## `clear` + +이 pass를 적용하기 전에 화면을 초기화할지의 여부입니다. + +## `renderToScreen` + +지정한 렌더 타겟이 아닌 캔버스에 렌더링할지의 여부입니다. 보통 `EffectComposer`에 추가하는 마지막 pass에 이 옵션을 true로 설정합니다. + +간단한 예제를 만들어봅시다. [반응형 디자인에 관한 글](threejs-responsive.html)에서 썼던 예제를 가져오겠습니다. + +추가로 먼저 `EffectComposer` 인스턴스를 생성합니다. + +```js +const composer = new EffectComposer(renderer); +``` + +다음으로 `RenderPass`를 첫 pass로 추가합니다. 이 pass는 넘겨 받은 장면을 첫 렌더 타겟에 렌더링할 겁니다. + +```js +composer.addPass(new RenderPass(scene, camera)); +``` + +다음으로 `BloomPass`를 추가합니다. `BloomPass`는 장면을 원래의 장면보다 작게 렌더링해 흐림(blur) 효과를 줍니다. 그리고 효과가 적용된 장면을 원래 장면에 덮어 씌우는 식으로 블룸 효과를 구현합니다. + +```js +const bloomPass = new BloomPass( + 1, // 강도 + 25, // 커널(kernel) 크기 + 4, // 시그마 ? + 256, // 렌더 타겟의 해상도를 낮춤 +); +composer.addPass(bloomPass); +``` + +마지막으로 원본 장면에 노이즈와 스캔라인(scanline)을 추가하는 `FilmPass`를 추가합니다. + +```js +const filmPass = new FilmPass( + 0.35, // 노이즈 강도 + 0.025, // 스캔라인 강도 + 648, // 스캔라인 개수 + false, // 흑백 +); +filmPass.renderToScreen = true; +composer.addPass(filmPass); +``` + +`filmPass`가 마지막 pass이기에 캔버스에 결과를 바로 렌더링하도록 `renderToScreen` 옵션을 true로 설정했습니다. 이 옵션을 설정하지 않으면 캔버스가 아닌 다음 렌더 타겟에 장면을 렌더링할 거예요. + +또 이 클래스들을 사용하기 위해 여러 스크립트를 불러와야 합니다. + +```js +import { EffectComposer } from './resources/threejs/r115/examples/jsm/postprocessing/EffectComposer.js'; +import { RenderPass } from './resources/threejs/r115/examples/jsm/postprocessing/RenderPass.js'; +import { BloomPass } from './resources/threejs/r115/examples/jsm/postprocessing/BloomPass.js'; +import { FilmPass } from './resources/threejs/r115/examples/jsm/postprocessing/FilmPass.js'; +``` + +대부분의 후처리에는 `EffectComposer.js`와 `RenderPass.js`가 필수입니다. + +이제 `WebGLRenderer.render` 대신 `EffectComposer.render`를 사용하고 `EffectComposer`가 결과물을 캔버스의 크기에 맞추도록 해야 합니다. + +```js +-function render(now) { +- time = 0.001; ++let then = 0; ++function render(now) { ++ now = 0.001; // 초 단위로 변환 ++ const deltaTime = now - then; ++ then = now; + + if (resizeRendererToDisplaySize(renderer)) { + const canvas = renderer.domElement; + camera.aspect = canvas.clientWidth / canvas.clientHeight; + camera.updateProjectionMatrix(); ++ composer.setSize(canvas.width, canvas.height); + } + + cubes.forEach((cube, ndx) => { + const speed = 1 + ndx * .1; +- const rot = time * speed; ++ const rot = now * speed; + cube.rotation.x = rot; + cube.rotation.y = rot; + }); + +- renderer.render(scene, camera); ++ composer.render(deltaTime); + + requestAnimationFrame(render); +} +``` + +`EffectComposer.render` 메서드는 인자로 마지막 프레임을 렌더링한 이후의 시간값인 `deltaTime`을 인자로 받습니다. pass에 애니메이션이 필요할 경우를 대비해 이 값을 넘겨주기 위해서이죠. 예제의 경우에는 `FilmPass`에 애니메이션이 있습니다. + +{{{example url="../threejs-postprocessing.html" }}} + +런타임에 효과의 속성을 변경할 때는 보통 uniform의 value 값을 바꿉니다. GUI를 추가해 이 속성을 조정할 수 있게 만들어보죠. 어떤 속성을 어떻게 조작할 수 있는지는 해당 효과의 소스 코드를 열어봐야 알 수 있습니다. + +[`BloomPass.js`](https://github.com/mrdoob/three.js/blob/master/examples/js/postprocessing/BloomPass.js)에서 +아래 코드를 찾았습니다. + +```js +this.copyUniforms[ "opacity" ].value = strength; +``` + +아래처럼 하면 강도를 런타임에 바꿀 수 있겠네요. + +```js +bloomPass.copyUniforms.opacity.value = someValue; +``` + +마찬가지로 [`FilmPass.js`](https://github.com/mrdoob/three.js/blob/master/examples/js/postprocessing/FilmPass.js)에서 +아래 코드를 찾았습니다. + +```js +if ( grayscale !== undefined ) this.uniforms.grayscale.value = grayscale; +if ( noiseIntensity !== undefined ) this.uniforms.nIntensity.value = noiseIntensity; +if ( scanlinesIntensity !== undefined ) this.uniforms.sIntensity.value = scanlinesIntensity; +if ( scanlinesCount !== undefined ) this.uniforms.sCount.value = scanlinesCount; +``` + +이제 어떻게 값을 지정해야 하는지 알았으니 이 값을 조작하는 GUI를 만들어봅시다. + +```js +import { GUI } from '../3rdparty/dat.gui.module.js'; +``` + +일단 모듈을 로드합니다. + +```js +const gui = new GUI(); +{ + const folder = gui.addFolder('BloomPass'); + folder.add(bloomPass.copyUniforms.opacity, 'value', 0, 2).name('strength'); + folder.open(); +} +{ + const folder = gui.addFolder('FilmPass'); + folder.add(filmPass.uniforms.grayscale, 'value').name('grayscale'); + folder.add(filmPass.uniforms.nIntensity, 'value', 0, 1).name('noise intensity'); + folder.add(filmPass.uniforms.sIntensity, 'value', 0, 1).name('scanline intensity'); + folder.add(filmPass.uniforms.sCount, 'value', 0, 1000).name('scanline count'); + folder.open(); +} +``` + +이제 각 설정을 조작할 수 있습니다. + +{{{example url="../threejs-postprocessing-gui.html" }}} + +여기까지 잘 따라왔다면 이제 효과를 직접 만들어볼 수 있습니다. + +후처리 효과는 쉐이더를 사용합니다. 쉐이더는 [GLSL (Graphics Library Shading Language)](https://www.khronos.org/files/opengles_shading_language.pdf)이라는 언어를 사용하죠. 언어가 방대해 이 글에서 전부 다루기는 어렵습니다. 기초부터 알아보고 싶다면 [이 글](https://webglfundamentals.org/webgl/lessons/ko/webgl-shaders-and-glsl.html)과 [쉐이더란 무엇인가(The Book of Shaders)](https://thebookofshaders.com/)를 읽어보기 바랍니다. + +직접 예제를 만들어보는 게 도움이 될 테니 간단한 GLSL 후처리 쉐이더를 만들어봅시다. 이미지에 특정 색을 혼합하는 쉐이더를 만들 겁니다. + +Three.js에는 후처리를 도와주는 `ShaderPass` 헬퍼 클래스가 있습니다. 인자로 vertex 쉐이더, fragment 쉐이더, 기본값으로 이루어진 객체를 받죠. 이 클래스는 이전 pass의 결과물에서 어떤 텍스처를 읽을지, 그리고 `EffectComposer`의 렌더 타겟과 캔버스 중 어디에 렌더링할지를 결정할 겁니다. + +아래는 이전 pass의 결과물에 특정 색을 혼합하는 간단한 후처리 쉐이더입니다. + +```js +const colorShader = { + uniforms: { + tDiffuse: { value: null }, + color: { value: new THREE.Color(0x88CCFF) }, + }, + vertexShader: ` + varying vec2 vUv; + void main() { + vUv = uv; + gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1); + } + `, + fragmentShader: ` + varying vec2 vUv; + uniform sampler2D tDiffuse; + uniform vec3 color; + void main() { + vec4 previousPassColor = texture2D(tDiffuse, vUv); + gl_FragColor = vec4( + previousPassColor.rgb * color, + previousPassColor.a); + } + `, +}; +``` + +위 코드에서 `tDiffuse`는 이전 pass의 결과물을 받아오기 위한 것으로 거의 모든 경우에 필수입니다. 그리고 그 바로 밑에 `color` 속성을 Three.js의 `Color`로 선언했습니다. + +다음으로 vertex 쉐이더를 작성해야 합니다. 위 코드에서 작성한 vertex 쉐이더는 후처리에서 거의 표준처럼 사용하는 코드로, 대부분의 경우 바꿀 필요가 없습니다. 뭔가 많이 설정한 경우(아까 언급한 링크 참조)가 아니라면 `uv`, `projectionMatrix`, `modelViewMatrix`, `position` 변수는 Three.js가 알아서 넣어줍니다. + +마지막으로 fragment 쉐이더를 생성합니다. 아래 코드로 이전 pass에서 넘겨준 결과물의 픽셀 색상값을 가져올 수 있습니다. + +```glsl +vec4 previousPassColor = texture2D(tDiffuse, vUv); +``` + +여기에 지정한 색상을 곱해 `gl_FragColor`에 결과를 저장합니다. + +```glsl +gl_FragColor = vec4( + previousPassColor.rgb * color, + previousPassColor.a); +``` + +추가로 간단한 GUI를 만들어 rgb의 각 색상값을 조정할 수 있도록 합니다. + +```js +const gui = new GUI(); +gui.add(colorPass.uniforms.color.value, 'r', 0, 4).name('red'); +gui.add(colorPass.uniforms.color.value, 'g', 0, 4).name('green'); +gui.add(colorPass.uniforms.color.value, 'b', 0, 4).name('blue'); +``` + +색을 혼합하는 간단한 후처리 쉐이더를 완성했습니다. + +{{{example url="../threejs-postprocessing-custom.html" }}} + +언급했듯 이 글에서 GLSL의 작성법과 사용자 지정 쉐이더를 만드는 법을 모두 다루기는 무리입니다. WebGL이 어떻게 동작하는지 알고 싶다면 [이 시리즈](https://webglfundamentals.org)를 참고하세요. [Three.js의 후처리 쉐이더 소스 코드](https://github.com/mrdoob/three.js/tree/master/examples/js/shaders)를 분석하는 것도 좋은 방법입니다. 상대적으로 복잡한 쉐이더도 있지만 작은 것부터 차근차근 살펴본다면 언젠가 전체를 이해할 수 있을 거예요. + +아쉽게도 Three.js의 후처리 효과 대부분은 공식 문서가 없어 [예제를 참고하거나](https://github.com/mrdoob/three.js/tree/master/examples) [후처리 효과의 소스 코드](https://github.com/mrdoob/three.js/tree/master/examples/js/postprocessing)를 직접 분석해야 합니다. 부디 이 글과 이 시리즈의 [렌더 타겟에 관한 글](threejs-rendertargets.html)이 좋은 출발점을 마련해주었으면 좋겠네요.	true
Other	mrdoob	three.js	633dbb61bdfd242077b4c012fce7468c1e707c1a.json	add translation kr/threejs-rendering-on-demand.md add translation kr/threejs-transparency.md update translation kr/threejs-prerequisites.md add translation kr/threejs-multiple-scenes.md add translation kr/threejs-picking.md fix typo & add translation kr/threejs-post-processing.md add translation kr/threejs-post-processing-3dlut.md	threejs/lessons/kr/threejs-prerequisites.md	@@ -148,12 +148,50 @@ ES5에서 배열에 [`forEach`](https://developer.mozilla.org/ko/docs/Web/JavaSc 기존 방법 - const width = dims.width; - const height = dims.height; +```js +const width = dims.width; +const height = dims.height; +``` + +새로운 방법 + +```js +const { width, height } = dims; +``` + +구조분해할당은 배열에도 적용할 수 있습니다. `const position = [1, 2, 3, 4]`. +이런 배열이 있다고 해보죠. + +기존 방법 + +```js +const x = position[2]; +const y = position[1]; +``` 새로운 방법 - const { width, height } = dims; +```js +const [ , y, x ] = position; +``` + +또한 매개변수에도 구조분해할당을 적용할 수 있습니다. + +```js +const dims = { width: 300, height: 150 }; +const position = [1, 2, 3, 4]; + +function distFromOrig([x, y]) { + return Math.sqrt(x * x + y * y); +} + +const dist = distFromOrig(position); // dist = 2.236... + +function area({ width, height }) { + return width * height; +} +const a = area(dims); // a = 45000 +``` ### 객체 선언 시 축약 문법 사용 @@ -193,7 +231,7 @@ ES5에서 배열에 [`forEach`](https://developer.mozilla.org/ko/docs/Web/JavaSc function log(className, ...args) { const elem = document.createElement('div'); elem.className = className; - elem.textContent = [...args].join(' '); + elem.textContent = args.join(' '); document.body.appendChild(elem); } ``` @@ -205,6 +243,22 @@ const position = [1, 2, 3]; somemesh.position.set(...position); ``` +배열을 얕은 복사할 때 사용할 수도 있고 + +```js +const copiedPositionArray = [...position]; +copiedPositionArray.push(4); // [1,2,3,4] +console.log(position); // [1,2,3] 기존 배열은 영향을 받지 않음 +``` + +객체를 합칠 때도 사용할 수 있죠. + +``` +const a = { abc: 123 }; +const b = { def: 456 }; +const c = { ...a, ...b }; // c = { abc: 123, def: 456 } +``` + ### `class` 사용하기 ES5 이하의 문법으로 클래스 스타일의 객체를 만드는 방법은 다른 개발자들에게 낯선 요소	true
Other	mrdoob	three.js	633dbb61bdfd242077b4c012fce7468c1e707c1a.json	add translation kr/threejs-rendering-on-demand.md add translation kr/threejs-transparency.md update translation kr/threejs-prerequisites.md add translation kr/threejs-multiple-scenes.md add translation kr/threejs-picking.md fix typo & add translation kr/threejs-post-processing.md add translation kr/threejs-post-processing-3dlut.md	threejs/lessons/kr/threejs-rendering-on-demand.md	@@ -0,0 +1,227 @@ +Title: 불필요한 렌더링 없애기 +Description: 불필요한 렌더링을 제거합니다 +TOC: 불필요한 렌더링 없애기 + +대부분의 개발자에게 이 주제는 너무 뻔할 수 있지만, 필요한 누군가를 위해 +글을 써보려 합니다. 대부분의 Three.js 예제는 렌더링 과정을 계속 반복합니다. +그러니까 아래와 같이 재귀적으로 `requestAnimationFrame` 함수를 사용한다는 +거죠. + +```js +function render() { + ... + requestAnimationFrame(render); +} +requestAnimationFrame(render); +``` + +계속 애니메이션이 있는 경우에야 별 상관이 없지만, 애니메이션이 없는 경우라면 +어떨까요? 이 경우 불필요한 렌더링을 반복하는 것은 연산 낭비일 뿐더러 사용 +환경이 모바일이라면 사용자의 배터리까지 낭비하는 셈입니다. + +처음 한 번만 렌더링하고, 그 후에 변화가 있을 때만 렌더링하는 것이 가장 정확한 +해결책일 겁니다. 여기서 변화란 텍스처나 모델의 로딩이 끝났을 때, 외부에서 +데이터를 받았을 때, 사용자가 카메라를 조정하거나, 설정을 바꾸거나, 인풋 값이 +변경된 경우 등 다양하겠죠. + +[반응형 디자인에 관한 글](threejs-responsive.html)에서 썼던 예제를 수정해 +필요에 따른 렌더링을 구현해봅시다. + +먼저 뭔가 변화를 일으킬 수 있는 요소가 필요하니 `OrbitControls`를 추가합니다. + +```js +import * as THREE from './resources/three/r115/build/three.module.js'; ++import { OrbitControls } from './resources/threejs/r115/examples/jsm/controls/OrbitControls.js'; + +... + +const fov = 75; +const aspect = 2; // canvas 기본값 +const near = 0.1; +const far = 5; +const camera = new THREE.PerspectiveCamera(fov, aspect, near, far); +camera.position.z = 2; + ++const controls = new OrbitControls(camera, canvas); ++controls.target.set(0, 0, 0); ++controls.update(); +``` + +정육면체에 애니메이션을 넣지 않을 것이니 이들을 참조할 필요가 없습니다. + +```js +-const cubes = [ +- makeInstance(geometry, 0x44aa88, 0), +- makeInstance(geometry, 0x8844aa, -2), +- makeInstance(geometry, 0xaa8844, 2), +-]; ++makeInstance(geometry, 0x44aa88, 0); ++makeInstance(geometry, 0x8844aa, -2); ++makeInstance(geometry, 0xaa8844, 2); +``` + +애니메이션과 `requestAnimationFrame` 관련 코드도 제거합니다. + +```js +-function render(time) { +- time = 0.001; ++function render() { + + if (resizeRendererToDisplaySize(renderer)) { + const canvas = renderer.domElement; + camera.aspect = canvas.clientWidth / canvas.clientHeight; + camera.updateProjectionMatrix(); + } + +- cubes.forEach((cube, ndx) => { +- const speed = 1 + ndx .1; +- const rot = time * speed; +- cube.rotation.x = rot; +- cube.rotation.y = rot; +- }); + + renderer.render(scene, camera); + +- requestAnimationFrame(render); +} + +-requestAnimationFrame(render); +``` + +그리고 `render` 함수를 직접 호출합니다. + +```js +render(); +``` + +이제 `OrbitControls`가 카메라 설정을 바꿀 때마다 직접 `render` 함수를 호출해야 +합니다. 뭔가 복잡할 것 같지만 다행히 `OrbitControls`에는 `change` 이벤트가 있습니다. + +```js +controls.addEventListener('change', render); +``` + +또한 창 크기가 바뀔 때의 동작도 직접 처리해야 합니다. `render` 함수를 계속 호출할 +때는 해당 동작을 자동으로 처리했지만, 지금은 `render` 함수를 수동으로 호출하므로 +창의 크기가 바뀔 때 `render` 함수를 호출하도록 하겠습니다. + +```js +window.addEventListener('resize', render); +``` + +이제 불필요한 렌더링을 반복하지 않습니다. + +{{{example url="../threejs-render-on-demand.html" }}} + +`OrbitControls`에는 관성(inertia) 옵션이 있습니다. `enableDamping` 속성을 ture로 +설정하면 동작이 좀 더 부드러워지죠. + +※ damping: 감쇠. + +```js +controls.enableDamping = true; +``` + +또한 `OrbitControls`가 부드러운 동작을 구현할 때 변경된 카메라 값을 계속 넘겨주도록 +`render` 함수 안에서 `controls.update` 메서드를 호출해야 합니다. 하지만 이렇게 하면 +`change` 이벤트가 발생했을 때 `render` 함수가 무한정 호출될 겁니다. controls가 `change` +이벤트를 보내면 `render` 함수가 호출되고, `render` 함수는 `controls.update` 메서드를 +호출해 다시 `change` 이벤트를 보내게 만들 테니까요. + +`requestAnimationFrame`이 직접 `render` 함수를 호출하게 하면 이 문제를 해결 할 수 +있습니다. 너무 많은 프레임을 막기 위해 변수 하나를 두어 요청한 프레임이 없을 경우에만 +프레임을 요청하도록 하면 되겠네요. + +```js ++let renderRequested = false; + +function render() { ++ renderRequested = false; + + if (resizeRendererToDisplaySize(renderer)) { + const canvas = renderer.domElement; + camera.aspect = canvas.clientWidth / canvas.clientHeight; + camera.updateProjectionMatrix(); + } + ++ controls.update(); + renderer.render(scene, camera); +} +render(); + ++function requestRenderIfNotRequested() { ++ if (!renderRequested) { ++ renderRequested = true; ++ requestAnimationFrame(render); ++ } ++} + +-controls.addEventListener('change', render); ++controls.addEventListener('change', requestRenderIfNotRequested); +``` + +창 크기 변화가 일어났을 때도 `requestRenderIfNotRequested`를 호출하도록 합니다. + +```js +-window.addEventListener('resize', render); ++window.addEventListener('resize', requestRenderIfNotRequested); +``` + +차이점을 느끼기 어려울지도 모르겠습니다. 화살표 키를 쓰거나 예제를 드래그해 보고 +다시 위 예제를 이리저리 돌려보세요. 차이점이 느껴질 거예요. 위 예제는 화살표 키를 +눌렀을 때 일정 거리만큼 순간이동하지만 아래의 예제는 약간 미끄러집니다. + +{{{example url="../threejs-render-on-demand-w-damping.html" }}} + +간단한 dat.GUI를 추가해 반복 렌더링 여부를 제어할 수 있도록 하겠습니다. + +```js +import * as THREE from './resources/three/r115/build/three.module.js'; +import { OrbitControls } from './resources/threejs/r115/examples/jsm/controls/OrbitControls.js'; ++import { GUI } from '../3rdparty/dat.gui.module.js'; +``` + +먼저 각 정육면체의 색과 x축 스케일을 조정하는 GUI를 추가합니다. [조명에 관한 글](threejs-lights.html)에서 +썼던 `ColorGUIHelper`를 가져와 쓰도록 하죠. + +먼저 GUI를 생성합니다. + +```js +const gui = new GUI(); +``` + +그리고 각 정육면체에 `material.color`, `cube.scale.x` 설정을 폴더로 묶어 +추가합니다. + +```js +function makeInstance(geometry, color, x) { + const material = new THREE.MeshPhongMaterial({color}); + + const cube = new THREE.Mesh(geometry, material); + scene.add(cube); + + cube.position.x = x; + ++ const folder = gui.addFolder(`Cube${ x }`); ++ folder.addColor(new ColorGUIHelper(material, 'color'), 'value') ++ .name('color') ++ .onChange(requestRenderIfNotRequested); ++ folder.add(cube.scale, 'x', .1, 1.5) ++ .name('scale x') ++ .onChange(requestRenderIfNotRequested); ++ folder.open(); + + return cube; +} +``` + +dat.GUI 컨트롤(control)의 `onChange` 메서드에 콜백 함수를 넘겨주면 GUI 값이 바뀔 +때마다 콜백 함수를 호출합니다. 예제의 경우에는 단순히 `requestRenderIfNotRequested` +함수를 넘겨주면 되죠. 그리고 `folder.open` 메서드를 호출해 폴더를 열어 둡니다. + +{{{example url="../threejs-render-on-demand-w-gui.html" }}} + +이 글이 불필요한 렌더링 제거에 대한 개념을 조금이라도 잡아주었길 바랍니다. 보통 +Three.js를 사용할 때는 이렇게 렌더링 루프를 제어할 일이 없습니다. 대게 게임 또는 +애니메이션이 들어간 3D 컨텐츠이기 때문이죠. 하지만 지도나, 3D 에디터, 3D 그래프, +상품 목록 등에서는 이런 기법이 필요할 수도 있습니다.	true
Other	mrdoob	three.js	633dbb61bdfd242077b4c012fce7468c1e707c1a.json	add translation kr/threejs-rendering-on-demand.md add translation kr/threejs-transparency.md update translation kr/threejs-prerequisites.md add translation kr/threejs-multiple-scenes.md add translation kr/threejs-picking.md fix typo & add translation kr/threejs-post-processing.md add translation kr/threejs-post-processing-3dlut.md	threejs/lessons/kr/threejs-transparency.md	@@ -0,0 +1,396 @@ +Title: Three.js 투명도 +Description: Three.js에서 투명도를 설정하는 법을 알아봅니다 +TOC: 물체의 투명도 설정하기 + +Three.js에서 투명도는 간단하지만 동시에 까다로운 주제입니다. + +먼저 쉬운 것부터 알아보죠. 예제로 정육면체 8개를 2x2x2 그리드에 맞춘 장면을 +만들어보겠습니다. + +[불필요한 렌더링 제거하기](threejs-rendering-on-demand.html)에서 썼던 +예제를 가져와 정육면체 3개를 8개로 수정합니다. 먼저 `makeInstance` 함수가 +x, y, z 값을 받도록 수정하겠습니다. + +```js +-function makeInstance(geometry, color) { ++function makeInstance(geometry, color, x, y, z) { + const material = new THREE.MeshPhongMaterial({color}); + + const cube = new THREE.Mesh(geometry, material); + scene.add(cube); + +- cube.position.x = x; ++ cube.position.set(x, y, z); + + return cube; +} +``` + +그리고 정육면체 8개를 만듭니다. + +```js ++function hsl(h, s, l) { ++ return (new THREE.Color()).setHSL(h, s, l); ++} + +-makeInstance(geometry, 0x44aa88, 0); +-makeInstance(geometry, 0x8844aa, -2); +-makeInstance(geometry, 0xaa8844, 2); + ++{ ++ const d = 0.8; ++ makeInstance(geometry, hsl(0 / 8, 1, .5), -d, -d, -d); ++ makeInstance(geometry, hsl(1 / 8, 1, .5), d, -d, -d); ++ makeInstance(geometry, hsl(2 / 8, 1, .5), -d, d, -d); ++ makeInstance(geometry, hsl(3 / 8, 1, .5), d, d, -d); ++ makeInstance(geometry, hsl(4 / 8, 1, .5), -d, -d, d); ++ makeInstance(geometry, hsl(5 / 8, 1, .5), d, -d, d); ++ makeInstance(geometry, hsl(6 / 8, 1, .5), -d, d, d); ++ makeInstance(geometry, hsl(7 / 8, 1, .5), d, d, d); ++} +``` + +카메라도 조정합니다. + +```js +const fov = 75; +const aspect = 2; // canvas 기본값 +const near = 0.1; +-const far = 5; ++const far = 25; +const camera = new THREE.PerspectiveCamera(fov, aspect, near, far); +-camera.position.z = 4; ++camera.position.z = 2; +``` + +배경색은 하얀색으로 바꿔주고 + +```js +const scene = new THREE.Scene(); ++scene.background = new THREE.Color('white'); +``` + +정육면체의 옆면도 빛을 받도록 조명을 하나 더 추가합니다. + +```js +-{ ++function addLight(...pos) { + const color = 0xFFFFFF; + const intensity = 1; + const light = new THREE.DirectionalLight(color, intensity); +- light.position.set(-1, 2, 4); ++ light.position.set(...pos); + scene.add(light); +} ++addLight(-1, 2, 4); ++addLight( 1, -1, -2); +``` + +정육면체를 투명하게 만들려면 [`transparent`](Material.transparent) 속성을 +켜고 [`opacity`](Material.opacity) 속성을 설정해줘야 합니다(CSS와 마찬가지로 +0은 완전히 투명함, 1은 완전히 불투명함을 의미). + +```js +function makeInstance(geometry, color, x, y, z) { +- const material = new THREE.MeshPhongMaterial({color}); ++ const material = new THREE.MeshPhongMaterial({ ++ color, ++ opacity: 0.5, ++ transparent: true, ++ }); + + const cube = new THREE.Mesh(geometry, material); + scene.add(cube); + + cube.position.set(x, y, z); + + return cube; +} +``` + +이제 8개의 반투명한 정육면체가 생겼습니다. + +{{{example url="../threejs-transparency.html"}}} + +예제를 드래그하면 화면을 회전시킬 수 있습니다. + +완벽한데요, 라고 생각했다면 좀 더 자세히 보세요. 정육면체의 뒷면이 하나도 +보이지 않습니다. + +<div class="threejs_center"><img src="resources/images/transparency-cubes-no-backs.png" style="width: 416px;"></div> +<div class="threejs_center">뒷면이 보이지 않는다</div> + +이전에 [재질(material)에 관해](threejs-materials.html) 배울 때 [`side`](Material.side) +속성에 대해 배웠었죠. 이 속성을 `THREE.DoubleSide`로 설정해 정육면체의 +양면이 모두 보이도록 해봅시다. + +```js +const material = new THREE.MeshPhongMaterial({ + color, + map: loader.load(url), + opacity: 0.5, + transparent: true, ++ side: THREE.DoubleSide, +}); +``` + +{{{example url="../threejs-transparency-doubleside.html" }}} + +예제를 돌려보세요. 뭔가 해결된 듯 하지만 자세히 보면 가끔 뒷면 또는 뒷면의 +일부가 보이지 않습니다. + +<div class="threejs_center"><img src="resources/images/transparency-cubes-some-backs.png" style="width: 368px;"></div> +<div class="threejs_center">정육면체의 왼쪽 뒷면이 보이지 않는다</div> + +이는 3D 요소를 렌더링하는 방식 때문입니다. WebGL은 각 geometry의 삼각형을 +한 번에 하나씩 렌더링합니다. 그리고 삼각형의 픽셀 하나를 렌더링할 때마다 +2개의 정보를 기록하는데, 하나는 해당 픽셀의 색이고 다른 하나는 픽셀의 +깊이(depth)입니다. 다음 삼각형을 그릴 때 해당 픽셀이 이미 그려진 픽셀보다 +깊이가 깊다면 해당 픽셀을 렌더링하지 않죠. + +이는 불투명한 물체에서는 문제가 되지 않았지만 투명한 물체에서는 문제가 됩니다. + +이 문제를 해결하려면 투명한 물체를 분류해 뒤에 있는 물체를 앞에 있는 물체보다 +먼저 렌더링해야 합니다. `Mesh` 같은 경우는 Three.js가 자동으로 이를 처리해주죠. +만약 그러지 않았다면 제일 첫 번째 예제에서 뒤에 있는 정육면체를 아예 볼 수 +없었을 겁니다. + +정육면체에는 한 면에 2개, 총 12개의 삼각형이 있습니다. 각 삼각형의 렌더링 순서는 +[geometry에 관한 글에서 봤던 것](threejs-custom-buffergeometry.html)과 같죠. +시선에 따라 카메라에서 가까운 삼각형을 먼저 렌더링할 겁니다. 앞면을 뒷면보다 먼저 +렌더링하니, 때때로 뒷면이 보이지 않을 수밖에 없죠. + +구체나 정육면체 등 볼록 물체(convex object)의 경우, 모든 물체를 한 번씩 더 렌더링해 +문제를 해결할 수 있습니다. 하나는 안쪽면 삼각형만 렌더링하고, 다른 하나는 바깥쪽 +삼각형만 렌더링하도록 만드는 것이죠. + +```js +function makeInstance(geometry, color, x, y, z) { ++ [THREE.BackSide, THREE.FrontSide].forEach((side) => { + const material = new THREE.MeshPhongMaterial({ + color, + opacity: 0.5, + transparent: true, ++ side, + }); + + const cube = new THREE.Mesh(geometry, material); + scene.add(cube); + + cube.position.set(x, y, z); ++ }); +} +``` + +어찌어찌 해결된 것처럼 보입니다. + +{{{example url="../threejs-transparency-doubleside-hack.html" }}} + +Three.js의 분류 기준은 고정적인 듯합니다. `side: THREE.BackSide` mesh를 먼저 +넣고, 그 다음 정확히 같은 위치에 `side: THREE.FrontSide` mesh를 넣었으니까요. + +이번에는 평면 2개를 교차로 배치해봅시다(정육면체 관련 코드를 전부 지운 뒤). +각 평면에는 다른 텍스처를 넣을 겁니다. + +```js +const planeWidth = 1; +const planeHeight = 1; +const geometry = new THREE.PlaneBufferGeometry(planeWidth, planeHeight); + +const loader = new THREE.TextureLoader(); + +function makeInstance(geometry, color, rotY, url) { + const texture = loader.load(url, render); + const material = new THREE.MeshPhongMaterial({ + color, + map: texture, + opacity: 0.5, + transparent: true, + side: THREE.DoubleSide, + }); + + const mesh = new THREE.Mesh(geometry, material); + scene.add(mesh); + + mesh.rotation.y = rotY; +} + +makeInstance(geometry, 'pink', 0, 'resources/images/happyface.png'); +makeInstance(geometry, 'lightblue', Math.PI * 0.5, 'resources/images/hmmmface.png'); +``` + +평면은 한 번에 한 면밖에 보지 못하니, `side: THREE.DoubleSide`로 설정했습니다. 또한 +텍스처를 전부 불러왔을 때 장면을 다시 렌더링하도록 `render` 함수를 `loader.load` +메서드에 넘겨줬습니다. 이는 [필요에 따른 렌더링](threejs-rendering-on-demand.html)을 +구현하기 위한 것이죠. + +{{{example url="../threejs-transparency-intersecting-planes.html"}}} + +아까와 비슷한 문제가 보입니다. + +<div class="threejs_center"><img src="resources/images/transparency-planes.png" style="width: 408px;"></div> +<div class="threejs_center">면의 반쪽이 사라졌다</div> + +평면을 둘로 쪼개 실제로는 교차하지 않게끔 만들면 문제를 해결할 수 있습니다. + +```js +function makeInstance(geometry, color, rotY, url) { ++ const base = new THREE.Object3D(); ++ scene.add(base); ++ base.rotation.y = rotY; + ++ [-1, 1].forEach((x) => { + const texture = loader.load(url, render); ++ texture.offset.x = x < 0 ? 0 : 0.5; ++ texture.repeat.x = .5; + const material = new THREE.MeshPhongMaterial({ + color, + map: texture, + opacity: 0.5, + transparent: true, + side: THREE.DoubleSide, + }); + + const mesh = new THREE.Mesh(geometry, material); +- scene.add(mesh); ++ base.add(mesh); + +- mesh.rotation.y = rotY; ++ mesh.position.x = x * .25; + }); +} +``` + +저걸 어떻게 구현할지는 여러분의 선택입니다. [블렌더(Blender)](https://blender.org) +같은 3D 에디터를 사용했다면 텍스처 좌표를 직접 수정했겠죠. 예제의 경우에는 +`PlaneBufferGeometry`를 썼습니다. [이전에 다뤘듯](threejs-textures.html) +이 geometry는 기본적으로 텍스처를 크기에 맞춰 늘립니다. [`texture.repeat`](Texture.repeat) +속성과 [`texture.offset`](Texture.offset) 속성을 조정해 각 면에 적절한 +텍스처를 입혀줄 수 있죠. + +위 코드에서는 `Object3D`를 만들어 두 평면의 부모로 지정했습니다. 이렇게 +하면 복잡한 계산 없이 간단하게 `Object3D`만 돌려서 두 평면 다 회전시킬 +수 있죠. + +{{{example url="../threejs-transparency-intersecting-planes-fixed.html"}}} + +이 방법은 교차점이 변하지 않는 정말 간단한 경우에만 가능합니다. + +텍스처가 들어간 요소는 알파 테스트(alpha test)를 활성화해 이를 해결할 수 +있죠. + +알파 테스트란 Three.js가 픽셀을 렌더링하지 않는 특정 알파 단계를 의미합니다. +만약 아무것도 그리지 않게 설정한다면 위와 같은 문제는 사라지겠죠. 상대적으로 +경계가 분명한 텍스처, 나뭇잎, 잔디 등의 경우 이는 꽤 잘 작동합니다. + +이번에도 2개의 면을 만들어 테스트해보도록 합시다. 아까는 텍스처가 전부 불투명했죠. +이번에는 각 면에는 각각 다른, 부분적으로 투명한 텍스처를 사용할 겁니다. + +<div class="spread"> + <div><img class="checkerboard" src="../resources/images/tree-01.png"></div> + <div><img class="checkerboard" src="../resources/images/tree-02.png"></div> +</div> + +아까 평면 2개를 교차해놓았던(반으로 가르기 전) 예제를 가져와 이 텍스처에 +[`alphaTest`](Material.alphaTest) 속성을 지정하겠습니다. + +```js +function makeInstance(geometry, color, rotY, url) { + const texture = loader.load(url, render); + const material = new THREE.MeshPhongMaterial({ + color, + map: texture, +- opacity: 0.5, + transparent: true, ++ alphaTest: 0.5, + side: THREE.DoubleSide, + }); + + const mesh = new THREE.Mesh(geometry, material); + scene.add(mesh); + + mesh.rotation.y = rotY; +} + +-makeInstance(geometry, 'pink', 0, 'resources/images/happyface.png'); +-makeInstance(geometry, 'lightblue', Math.PI * 0.5, 'resources/images/hmmmface.png'); ++makeInstance(geometry, 'white', 0, 'resources/images/tree-01.png'); ++makeInstance(geometry, 'white', Math.PI * 0.5, 'resources/images/tree-02.png'); +``` + +이대로 실행해도 되지만, 간단한 UI를 만들어 `alphaTest`와 `transparent` 속성을 +갖고 놀 수 있게 해보겠습니다. [씬 그래프에 관한 글](threejs-scenegraph.html)에서 +소개했던 dat.GUI를 써서요. + +먼저 dat.GUI에 지정할 헬퍼 클래스를 만들겠습니다. 이 헬퍼 클래스는 장면 안 모든 +재질을 해당 값으로 변경할 겁니다. + +```js +class AllMaterialPropertyGUIHelper { + constructor(prop, scene) { + this.prop = prop; + this.scene = scene; + } + get value() { + const { scene, prop } = this; + let v; + scene.traverse((obj) => { + if (obj.material && obj.material[prop] !== undefined) { + v = obj.material[prop]; + } + }); + return v; + } + set value(v) { + const { scene, prop } = this; + scene.traverse((obj) => { + if (obj.material && obj.material[prop] !== undefined) { + obj.material[prop] = v; + obj.material.needsUpdate = true; + } + }); + } +} +``` + +다음으로 GUI를 추가합니다. + +```js +const gui = new GUI(); +gui.add(new AllMaterialPropertyGUIHelper('alphaTest', scene), 'value', 0, 1) + .name('alphaTest') + .onChange(requestRenderIfNotRequested); +gui.add(new AllMaterialPropertyGUIHelper('transparent', scene), 'value') + .name('transparent') + .onChange(requestRenderIfNotRequested); +``` + +물론 dat.GUI 모듈도 불러와야죠. + +```js +import * as THREE from './resources/three/r115/build/three.module.js'; +import { OrbitControls } from './resources/threejs/r115/examples/jsm/controls/OrbitControls.js'; ++import { GUI } from '../3rdparty/dat.gui.module.js'; +``` + +{{{example url="../threejs-transparency-intersecting-planes-alphatest.html"}}} + +예제를 확대해보면 평면에 하얀 테두리가 보일 겁니다. + +<div class="threejs_center"><img src="resources/images/transparency-alphatest-issues.png" style="width: 532px;"></div> + +이는 앞서 봤던 예제와 같은 문제입니다. 하얀 테두리를 가진 요소가 먼저 그려져 +뒤에 있는 요소가 일부 가려진 것이죠. 완벽한 해결책은 없습니다. 그때그때 상황에 +따라 `alphaTest`나 `transparent` 옵션을 조정해서 상황에 맞는 해결책을 찾아야 +하죠. + +결국 이 글의 주제는 "완벽한 투명도는 구현하기 힘들다"가 되겠네요. 웬만한 방법에는 +모두 문제와, 타협점, 편법 등이 존재합니다. + +자동차의 경우를 예로 들어보죠. 자동차는 보통 4면에 유리창이 있습니다. 렌더링 순서를 +제대로 적용하려면 각각의 창문을 별도의 요소로 만들어야 합니다. 만약 하나의 요소라면 +Three.js가 렌더링 순서를 제대로 결정할 수 없겠죠. + +식물이나 잔디 등을 구현할 때는 일반적으로 알파 테스트를 사용합니다. + +어떤 방법을 사용할지는 전적으로 상황과 여러분의 판단에 달려 있죠.	true
Other	mrdoob	three.js	a0656c6b5a207629127a856da0fc4a6ef5dc0a0f.json	Fix mismatch info I should have sent pull request together, but I discovered this later. same as previous, `light` should be child of `camera` not `scene`.	threejs/threejs-multiple-scenes-copy-canvas.html	@@ -80,7 +80,7 @@ const intensity = 1; const light = new THREE.DirectionalLight(color, intensity); light.position.set(-1, 2, 4); - scene.add(light); + camera.add(light); } return {scene, camera, controls};	false
Other	mrdoob	three.js	c17cb2587d863518ca27074135dcffe4f94c2099.json	Fix mismatch info (#88) light should be added to `camera` not `scene`	threejs/threejs-multiple-scenes-controls.html	@@ -82,7 +82,7 @@ const intensity = 1; const light = new THREE.DirectionalLight(color, intensity); light.position.set(-1, 2, 4); - scene.add(light); + camera.add(light); } return {scene, camera, controls};	false
Other	mrdoob	three.js	ca306c07511a63a257d07f505e6a0a7ef4dbc5a6.json	Add version to glslang.	examples/jsm/libs/glslang.js	@@ -1,7 +1,7 @@ - +// 0.0.15 var Module = (function() { var _scriptDir = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : undefined; - + return ( function(Module) { Module = Module \|\| {};	false
Other	mrdoob	three.js	0f5de4f5da1014f81c00d309f93b1a1e709341e4.json	Fix ReDos in Color.js	src/math/Color.js	@@ -169,14 +169,14 @@ class Color { let color; const name = m[ 1 ]; - const components = m[ 2 ]; + const components = m[ 2 ].replace(/^\s/, ''); switch ( name ) { case 'rgb': case 'rgba': - if ( color = /^\s(\d+)\s,\s(\d+)\s,\s(\d+)\s(?:,\s(\d\.?\d+)\s)?$/.exec( components ) ) { + if ( color = /^(\d+)\s,\s(\d+)\s,\s(\d+)\s(?:,\s(\d\.?\d+)\s)?$/.exec( components ) ) { // rgb(255,0,0) rgba(255,0,0,0.5) this.r = Math.min( 255, parseInt( color[ 1 ], 10 ) ) / 255;	false
Other	mrdoob	three.js	341b2e863a97932dd9705947b2327f4aee159156.json	Handle empty cases in Sphere.union (#24701)	src/math/Sphere.js	@@ -195,6 +195,18 @@ class Sphere { union( sphere ) { + // handle empty sphere cases + if ( sphere.isEmpty() ) { + + return; + + } else if ( this.isEmpty() ) { + + this.copy( sphere ); + return; + + } + // from https://github.com/juj/MathGeoLib/blob/2940b99b99cfe575dd45103ef20f4019dee15b54/src/Geometry/Sphere.cpp#L759-L769 // To enclose another sphere into this sphere, we only need to enclose two points:	false
Other	mrdoob	three.js	fa6899ae485cda3f5fceef325acf8bb2d9fc592f.json	Minimize glActiveTexture calls (#24492) * Don't set activetexture for textures that won't be bound * Fix texture state update of a previously bound texture * Combine bindTexture and bindTextureToSlot into a single function	src/renderers/webgl/WebGLState.js	@@ -880,25 +880,40 @@ function WebGLState( gl, extensions, capabilities ) { } - function bindTexture( webglType, webglTexture ) { + function bindTexture( webglType, webglTexture, webglSlot ) { - if ( currentTextureSlot === null ) { + if ( webglSlot === undefined ) { - activeTexture(); + if ( currentTextureSlot === null ) { + + webglSlot = gl.TEXTURE0 + maxTextures - 1; + + } else { + + webglSlot = currentTextureSlot; + + } } - let boundTexture = currentBoundTextures[ currentTextureSlot ]; + let boundTexture = currentBoundTextures[ webglSlot ]; if ( boundTexture === undefined ) { boundTexture = { type: undefined, texture: undefined }; - currentBoundTextures[ currentTextureSlot ] = boundTexture; + currentBoundTextures[ webglSlot ] = boundTexture; } if ( boundTexture.type !== webglType \|\| boundTexture.texture !== webglTexture ) { + if ( currentTextureSlot !== webglSlot ) { + + gl.activeTexture( webglSlot ); + currentTextureSlot = webglSlot; + + } + gl.bindTexture( webglType, webglTexture \|\| emptyTextures[ webglType ] ); boundTexture.type = webglType;	true
Other	mrdoob	three.js	fa6899ae485cda3f5fceef325acf8bb2d9fc592f.json	Minimize glActiveTexture calls (#24492) * Don't set activetexture for textures that won't be bound * Fix texture state update of a previously bound texture * Combine bindTexture and bindTextureToSlot into a single function	src/renderers/webgl/WebGLTextures.js	@@ -460,8 +460,7 @@ function WebGLTextures( _gl, extensions, state, properties, capabilities, utils, } - state.activeTexture( _gl.TEXTURE0 + slot ); - state.bindTexture( _gl.TEXTURE_2D, textureProperties.__webglTexture ); + state.bindTexture( _gl.TEXTURE_2D, textureProperties.__webglTexture, _gl.TEXTURE0 + slot ); } @@ -476,8 +475,7 @@ function WebGLTextures( _gl, extensions, state, properties, capabilities, utils, } - state.activeTexture( _gl.TEXTURE0 + slot ); - state.bindTexture( _gl.TEXTURE_2D_ARRAY, textureProperties.__webglTexture ); + state.bindTexture( _gl.TEXTURE_2D_ARRAY, textureProperties.__webglTexture, _gl.TEXTURE0 + slot ); } @@ -492,8 +490,7 @@ function WebGLTextures( _gl, extensions, state, properties, capabilities, utils, } - state.activeTexture( _gl.TEXTURE0 + slot ); - state.bindTexture( _gl.TEXTURE_3D, textureProperties.__webglTexture ); + state.bindTexture( _gl.TEXTURE_3D, textureProperties.__webglTexture, _gl.TEXTURE0 + slot ); } @@ -508,8 +505,7 @@ function WebGLTextures( _gl, extensions, state, properties, capabilities, utils, } - state.activeTexture( _gl.TEXTURE0 + slot ); - state.bindTexture( _gl.TEXTURE_CUBE_MAP, textureProperties.__webglTexture ); + state.bindTexture( _gl.TEXTURE_CUBE_MAP, textureProperties.__webglTexture, _gl.TEXTURE0 + slot ); } @@ -681,13 +677,14 @@ function WebGLTextures( _gl, extensions, state, properties, capabilities, utils, const forceUpload = initTexture( textureProperties, texture ); const source = texture.source; - state.activeTexture( _gl.TEXTURE0 + slot ); - state.bindTexture( textureType, textureProperties.__webglTexture ); + state.bindTexture( textureType, textureProperties.__webglTexture, _gl.TEXTURE0 + slot ); const sourceProperties = properties.get( source ); if ( source.version !== sourceProperties.__version \|\| forceUpload === true ) { + state.activeTexture( _gl.TEXTURE0 + slot ); + _gl.pixelStorei( _gl.UNPACK_FLIP_Y_WEBGL, texture.flipY ); _gl.pixelStorei( _gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, texture.premultiplyAlpha ); _gl.pixelStorei( _gl.UNPACK_ALIGNMENT, texture.unpackAlignment ); @@ -1042,13 +1039,14 @@ function WebGLTextures( _gl, extensions, state, properties, capabilities, utils, const forceUpload = initTexture( textureProperties, texture ); const source = texture.source; - state.activeTexture( _gl.TEXTURE0 + slot ); - state.bindTexture( _gl.TEXTURE_CUBE_MAP, textureProperties.__webglTexture ); + state.bindTexture( _gl.TEXTURE_CUBE_MAP, textureProperties.__webglTexture, _gl.TEXTURE0 + slot ); const sourceProperties = properties.get( source ); if ( source.version !== sourceProperties.__version \|\| forceUpload === true ) { + state.activeTexture( _gl.TEXTURE0 + slot ); + _gl.pixelStorei( _gl.UNPACK_FLIP_Y_WEBGL, texture.flipY ); _gl.pixelStorei( _gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, texture.premultiplyAlpha ); _gl.pixelStorei( _gl.UNPACK_ALIGNMENT, texture.unpackAlignment );	true
Other	mrdoob	three.js	24f2d651f46ec3af5e63ea949fa93ac9eb81e5f2.json	Simplify calls to lookAt() (#24909) * Simplify calls to lookAt() * Clean up	examples/jsm/loaders/3DMLoader.js	@@ -15,7 +15,6 @@ import { PointLight, SpotLight, RectAreaLight, - Vector3, Sprite, SpriteMaterial, CanvasTexture, @@ -625,7 +624,7 @@ class Rhino3dmLoader extends Loader { light.position.set( geometry.location[ 0 ] - ( height / 2 ), geometry.location[ 1 ], geometry.location[ 2 ] - ( width / 2 ) ); light.height = height; light.width = width; - light.lookAt( new Vector3( geometry.direction[ 0 ], geometry.direction[ 1 ], geometry.direction[ 2 ] ) ); + light.lookAt( geometry.direction[ 0 ], geometry.direction[ 1 ], geometry.direction[ 2 ] ); break;	true
Other	mrdoob	three.js	24f2d651f46ec3af5e63ea949fa93ac9eb81e5f2.json	Simplify calls to lookAt() (#24909) * Simplify calls to lookAt() * Clean up	examples/webgl_animation_skinning_morph.html	@@ -71,7 +71,7 @@ camera = new THREE.PerspectiveCamera( 45, window.innerWidth / window.innerHeight, 0.25, 100 ); camera.position.set( - 5, 3, 10 ); - camera.lookAt( new THREE.Vector3( 0, 2, 0 ) ); + camera.lookAt( 0, 2, 0 ); scene = new THREE.Scene(); scene.background = new THREE.Color( 0xe0e0e0 );	true
Other	mrdoob	three.js	24f2d651f46ec3af5e63ea949fa93ac9eb81e5f2.json	Simplify calls to lookAt() (#24909) * Simplify calls to lookAt() * Clean up	src/cameras/CubeCamera.js	@@ -1,6 +1,5 @@ import { NoToneMapping } from '../constants.js'; import { Object3D } from '../core/Object3D.js'; -import { Vector3 } from '../math/Vector3.js'; import { PerspectiveCamera } from './PerspectiveCamera.js'; const fov = 90, aspect = 1; @@ -18,37 +17,37 @@ class CubeCamera extends Object3D { const cameraPX = new PerspectiveCamera( fov, aspect, near, far ); cameraPX.layers = this.layers; cameraPX.up.set( 0, - 1, 0 ); - cameraPX.lookAt( new Vector3( 1, 0, 0 ) ); + cameraPX.lookAt( 1, 0, 0 ); this.add( cameraPX ); const cameraNX = new PerspectiveCamera( fov, aspect, near, far ); cameraNX.layers = this.layers; cameraNX.up.set( 0, - 1, 0 ); - cameraNX.lookAt( new Vector3( - 1, 0, 0 ) ); + cameraNX.lookAt( - 1, 0, 0 ); this.add( cameraNX ); const cameraPY = new PerspectiveCamera( fov, aspect, near, far ); cameraPY.layers = this.layers; cameraPY.up.set( 0, 0, 1 ); - cameraPY.lookAt( new Vector3( 0, 1, 0 ) ); + cameraPY.lookAt( 0, 1, 0 ); this.add( cameraPY ); const cameraNY = new PerspectiveCamera( fov, aspect, near, far ); cameraNY.layers = this.layers; cameraNY.up.set( 0, 0, - 1 ); - cameraNY.lookAt( new Vector3( 0, - 1, 0 ) ); + cameraNY.lookAt( 0, - 1, 0 ); this.add( cameraNY ); const cameraPZ = new PerspectiveCamera( fov, aspect, near, far ); cameraPZ.layers = this.layers; cameraPZ.up.set( 0, - 1, 0 ); - cameraPZ.lookAt( new Vector3( 0, 0, 1 ) ); + cameraPZ.lookAt( 0, 0, 1 ); this.add( cameraPZ ); const cameraNZ = new PerspectiveCamera( fov, aspect, near, far ); cameraNZ.layers = this.layers; cameraNZ.up.set( 0, - 1, 0 ); - cameraNZ.lookAt( new Vector3( 0, 0, - 1 ) ); + cameraNZ.lookAt( 0, 0, - 1 ); this.add( cameraNZ ); }	true
Other	mrdoob	three.js	a13c6a3e106b1a3b2add618599175bd58f71259f.json	Introduce scene.backgroundIntensity (#24876)	docs/api/en/scenes/Scene.html	@@ -40,6 +40,11 @@ <h3>[property:Float backgroundBlurriness]</h3> Sets the blurriness of the background. Only influences environment maps assigned to [page:Scene.background]. Valid input is a float between 0 and 1. Default is 0. </p> + <h3>[property:Float backgroundIntensity]</h3> + <p> + Attenuates the color of the background. Only applies to background textures. Default is 1. + </p> + <h3>[property:Texture environment]</h3> <p> Sets the environment map for all physical materials in the scene.	true
Other	mrdoob	three.js	a13c6a3e106b1a3b2add618599175bd58f71259f.json	Introduce scene.backgroundIntensity (#24876)	src/renderers/shaders/ShaderLib.js	@@ -218,6 +218,7 @@ const ShaderLib = { uniforms: { uvTransform: { value: /@__PURE__/ new Matrix3() }, t2D: { value: null }, + backgroundIntensity: { value: 1 } }, vertexShader: ShaderChunk.background_vert, @@ -230,7 +231,8 @@ const ShaderLib = { uniforms: { envMap: { value: null }, flipEnvMap: { value: - 1 }, - backgroundBlurriness: { value: 0 } + backgroundBlurriness: { value: 0 }, + backgroundIntensity: { value: 1 } }, vertexShader: ShaderChunk.backgroundCube_vert,	true
Other	mrdoob	three.js	a13c6a3e106b1a3b2add618599175bd58f71259f.json	Introduce scene.backgroundIntensity (#24876)	src/renderers/shaders/ShaderLib/background.glsl.js	@@ -13,21 +13,26 @@ void main() { export const fragment = /* glsl /` uniform sampler2D t2D; +uniform float backgroundIntensity; varying vec2 vUv; void main() { - gl_FragColor = texture2D( t2D, vUv ); + vec4 texColor = texture2D( t2D, vUv ); #ifdef DECODE_VIDEO_TEXTURE // inline sRGB decode (TODO: Remove this code when https://crbug.com/1256340 is solved) - gl_FragColor = vec4( mix( pow( gl_FragColor.rgb 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), gl_FragColor.rgb * 0.0773993808, vec3( lessThanEqual( gl_FragColor.rgb, vec3( 0.04045 ) ) ) ), gl_FragColor.w ); + texColor = vec4( mix( pow( texColor.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), texColor.rgb * 0.0773993808, vec3( lessThanEqual( texColor.rgb, vec3( 0.04045 ) ) ) ), texColor.w ); #endif + texColor.rgb *= backgroundIntensity; + + gl_FragColor = texColor; + #include <tonemapping_fragment> #include <encodings_fragment>	true
Other	mrdoob	three.js	a13c6a3e106b1a3b2add618599175bd58f71259f.json	Introduce scene.backgroundIntensity (#24876)	src/renderers/shaders/ShaderLib/backgroundCube.glsl.js	@@ -29,6 +29,7 @@ export const fragment = /* glsl /` uniform float flipEnvMap; uniform float backgroundBlurriness; +uniform float backgroundIntensity; varying vec3 vWorldDirection; @@ -50,6 +51,8 @@ void main() { #endif + texColor.rgb = backgroundIntensity; + gl_FragColor = texColor; #include <tonemapping_fragment>	true
Other	mrdoob	three.js	a13c6a3e106b1a3b2add618599175bd58f71259f.json	Introduce scene.backgroundIntensity (#24876)	src/renderers/webgl/WebGLBackground.js	@@ -105,6 +105,7 @@ function WebGLBackground( renderer, cubemaps, cubeuvmaps, state, objects, alpha, boxMesh.material.uniforms.envMap.value = background; boxMesh.material.uniforms.flipEnvMap.value = ( background.isCubeTexture && background.isRenderTargetTexture === false ) ? - 1 : 1; boxMesh.material.uniforms.backgroundBlurriness.value = scene.backgroundBlurriness; + boxMesh.material.uniforms.backgroundIntensity.value = scene.backgroundIntensity; if ( currentBackground !== background \|\| currentBackgroundVersion !== background.version \|\| @@ -159,6 +160,7 @@ function WebGLBackground( renderer, cubemaps, cubeuvmaps, state, objects, alpha, } planeMesh.material.uniforms.t2D.value = background; + planeMesh.material.uniforms.backgroundIntensity.value = scene.backgroundIntensity; if ( background.matrixAutoUpdate === true ) {	true
Other	mrdoob	three.js	a13c6a3e106b1a3b2add618599175bd58f71259f.json	Introduce scene.backgroundIntensity (#24876)	src/scenes/Scene.js	@@ -15,6 +15,7 @@ class Scene extends Object3D { this.fog = null; this.backgroundBlurriness = 0; + this.backgroundIntensity = 1; this.overrideMaterial = null; @@ -35,6 +36,7 @@ class Scene extends Object3D { if ( source.fog !== null ) this.fog = source.fog.clone(); this.backgroundBlurriness = source.backgroundBlurriness; + this.backgroundIntensity = source.backgroundIntensity; if ( source.overrideMaterial !== null ) this.overrideMaterial = source.overrideMaterial.clone(); @@ -50,6 +52,7 @@ class Scene extends Object3D { if ( this.fog !== null ) data.object.fog = this.fog.toJSON(); if ( this.backgroundBlurriness > 0 ) data.backgroundBlurriness = this.backgroundBlurriness; + if ( this.backgroundIntensity !== 1 ) data.backgroundIntensity = this.backgroundIntensity; return data;	true
Other	mrdoob	three.js	065f2c3f1763c6bbf2b4d7398aa38b078116fe41.json	Fix typos in fundamentals.html (#24901) * Fix typo in en/fundamentals.html Word `be` was repeated. * Remove extra "a"	manual/en/fundamentals.html	@@ -176,7 +176,7 @@ <h1>Fundamentals</h1> <p><img src="../resources/frustum-3d.svg" width="500" class="threejs_center"></p> <p>The height of the near and far planes are determined by the field of view. The width of both planes is determined by the field of view and the aspect.</p> -<p>Anything inside the defined frustum will be be drawn. Anything outside +<p>Anything inside the defined frustum will be drawn. Anything outside will not.</p> <p>The camera defaults to looking down the -Z axis with +Y up. We'll put our cube at the origin so we need to move the camera back a little from the origin @@ -209,7 +209,7 @@ <h1>Fundamentals</h1> <pre class="prettyprint showlinemods notranslate lang-js" translate="no">const material = new THREE.MeshBasicMaterial({color: 0x44aa88}); </pre> <p>We then create a <a href="/docs/#api/en/objects/Mesh"><code class="notranslate" translate="no">Mesh</code></a>. A <a href="/docs/#api/en/objects/Mesh"><code class="notranslate" translate="no">Mesh</code></a> in three represents the combination -of a three things</p> +of three things</p> <ol> <li>A <code class="notranslate" translate="no">Geometry</code> (the shape of the object)</li> <li>A <a href="/docs/#api/en/materials/Material"><code class="notranslate" translate="no">Material</code></a> (how to draw the object, shiny or flat, what color, what texture(s) to apply. Etc.)</li> @@ -461,4 +461,4 @@ <h3>es6 modules, three.js, and folder structure</h3> -</body></html> \ No newline at end of file +</body></html>	false
Other	mrdoob	three.js	b361e9b2f4c3d9a574612972c9749477787f1685.json	Fix Chinese typos on page responsive.html (#24884) Co-authored-by: xiaoke <xiaoke@micous.com>	manual/zh/responsive.html	@@ -1,49 +1,53 @@ -<!DOCTYPE html><html lang="zh"><head> - <meta charset="utf-8"> - <title>响应式设计</title> - <meta name="viewport" content="width=device-width, user-scalable=no, minimum-scale=1.0, maximum-scale=1.0"> - <meta name="twitter:card" content="summary_large_image"> - <meta name="twitter:site" content="@threejs"> - <meta name="twitter:title" content="Three.js – 响应式设计"> - <meta property="og:image" content="https://threejs.org/files/share.png"> - <link rel="shortcut icon" href="/files/favicon_white.ico" media="(prefers-color-scheme: dark)"> - <link rel="shortcut icon" href="/files/favicon.ico" media="(prefers-color-scheme: light)"> - - <link rel="stylesheet" href="/manual/resources/lesson.css"> - <link rel="stylesheet" href="/manual/resources/lang.css"> -<!-- Import maps polyfill --> -<!-- Remove this when import maps will be widely supported --> -<script async src="https://unpkg.com/es-module-shims@1.3.6/dist/es-module-shims.js"></script> - -<script type="importmap"> +<!DOCTYPE html> +<html lang="zh"> + +<head> + <meta charset="utf-8"> + <title>响应式设计</title> + <meta name="viewport" content="width=device-width, user-scalable=no, minimum-scale=1.0, maximum-scale=1.0"> + <meta name="twitter:card" content="summary_large_image"> + <meta name="twitter:site" content="@threejs"> + <meta name="twitter:title" content="Three.js – 响应式设计"> + <meta property="og:image" content="https://threejs.org/files/share.png"> + <link rel="shortcut icon" href="/files/favicon_white.ico" media="(prefers-color-scheme: dark)"> + <link rel="shortcut icon" href="/files/favicon.ico" media="(prefers-color-scheme: light)"> + + <link rel="stylesheet" href="/manual/resources/lesson.css"> + <link rel="stylesheet" href="/manual/resources/lang.css"> + <!-- Import maps polyfill --> + <!-- Remove this when import maps will be widely supported --> + <script async src="https://unpkg.com/es-module-shims@1.3.6/dist/es-module-shims.js"></script> + + <script type="importmap"> { "imports": { "three": "../../build/three.module.js" } } </script> - <link rel="stylesheet" href="/manual/zh/lang.css"> - </head> - <body> - <div class="container"> - <div class="lesson-title"> - <h1>响应式设计</h1> - </div> - <div class="lesson"> - <div class="lesson-main"> - <p>这是three.js系列文章的第二篇。 -第一篇是<a href="fundamentals.html">关于基础</a>。 -如果你还没有阅读第一篇那你应该从第一篇开始。</p> -<p>本篇文章是关于如何让你的three.js应用自适应各种情况。 -网页的响应式是指让其在桌面、平板及手机等不同尺寸的屏幕上显示良好。</p> -<p>对three.js来说有更多的情况要考虑。例如，我们可能需要处理控件在左侧、右侧、顶部或底部的三维编辑器。本文的中间部分展示了另一个例子。</p> -<p>上一个例子中我们使用了一个没有设置样式和尺寸的。</p> -<pre class="prettyprint showlinemods notranslate lang-html" translate="no"><canvas id="c"></canvas> + <link rel="stylesheet" href="/manual/zh/lang.css"> +</head> + +<body> + <div class="container"> + <div class="lesson-title"> + <h1>响应式设计</h1> + </div> + <div class="lesson"> + <div class="lesson-main"> + <p>这是three.js系列文章的第二篇。 + 第一篇是<a href="fundamentals.html">关于基础</a>。 + 如果你还没有阅读第一篇那你应该从第一篇开始。</p> + <p>本篇文章是关于如何让你的three.js应用自适应各种情况。 + 网页的响应式是指让其在桌面、平板及手机等不同尺寸的屏幕上显示良好。</p> + <p>对three.js来说有更多的情况要考虑。例如，我们可能需要处理控件在左侧、右侧、顶部或底部的三维编辑器。本文的中间部分展示了另一个例子。</p> + <p>上一个例子中我们使用了一个没有设置样式和尺寸的。</p> + <pre class="prettyprint showlinemods notranslate lang-html" translate="no"><canvas id="c"></canvas> </pre> -<p>那个canvas默认300x150像素。</p> -<p>在web平台推荐使用CSS来设置物体的尺寸。</p> -<p>我们通过添加CSS来让canvas填充整个页面。</p> -<pre class="prettyprint showlinemods notranslate lang-html" translate="no"><style> + <p>那个canvas默认300x150像素。</p> + <p>在web平台推荐使用CSS来设置物体的尺寸。</p> + <p>我们通过添加CSS来让canvas填充整个页面。</p> + <pre class="prettyprint showlinemods notranslate lang-html" translate="no"><style> html, body { margin: 0; height: 100%; @@ -55,30 +59,36 @@ <h1>响应式设计</h1> } </style> </pre> -<p>HTML中的body默认有5个像素的margin值所以设置margin为0来移除margin值。 -设置html和body的高度为100%让他们充满整个窗口。不然的话他们的大小只会 -和填充他们的内容一样。</p> -<p>然后我们让<code class="notranslate" translate="no">id=c</code>的元素的尺寸是容器的100%这里是body标签。 </p> -<p>最后我们设置它的<code class="notranslate" translate="no">display</code>为<code class="notranslate" translate="no">block</code>。canvas的display默认为 -<code class="notranslate" translate="no">inline</code>。行内元素的末尾会有空格。 -通过设置canvas为块级元素就能消除这个空格。</p> -<p>这里是结果。</p> -<p></p><div translate="no" class="threejs_example_container notranslate"> - <div><iframe class="threejs_example notranslate" translate="no" style=" " src="/manual/examples/resources/editor.html?url=/manual/examples/responsive-no-resize.html"></iframe></div> - <a class="threejs_center" href="/manual/examples/responsive-no-resize.html" target="_blank">点击此处在新标签页中打开</a> -</div> - -<p></p> -<p>你可以看到canvas充满了整个页面，但是有两个问题。 -第一是我们的立方体被拉伸了。他们不是立方体了更像是个盒子，太高或者太宽。在新标签中打开它然后改变尺寸你就能看到立方体是怎么在宽高上被拉伸的。</p> -<p><img src="../resources/images/resize-incorrect-aspect.png" width="407" class="threejs_center nobg"></p> -<p>另一个问题是立方体看起来分辨率太低或者说块状化或者有点模糊。 -将窗口拉伸的非常大你就能看到问题。</p> -<p><img src="../resources/images/resize-low-res.png" class="threejs_center nobg"></p> -<p>我们先解决拉伸的问题。为此我们要将相机的宽高比设置为canvas的宽高比。 -我们可以通过canvas的<code class="notranslate" translate="no">clientWidth</code>和<code class="notranslate" translate="no">clientHeight</code>属性来实现。</p> -<p>我们需要将渲染循环变成这样。</p> -<pre class="prettyprint showlinemods notranslate lang-js" translate="no">function render(time) { + <p>HTML中的body默认有5个像素的margin值所以设置margin为0来移除margin值。 + 设置html和body的高度为100%让他们充满整个窗口。不然的话他们的大小只会 + 和填充他们的内容一样。</p> + <p>然后我们让<code class="notranslate" translate="no">id=c</code>的元素的尺寸是容器的100%这里是body标签。 </p> + <p>最后我们设置它的<code class="notranslate" translate="no">display</code>为<code class="notranslate" + translate="no">block</code>。canvas的display默认为 + <code class="notranslate" translate="no">inline</code>。行内元素的末尾会有空格。 + 通过设置canvas为块级元素就能消除这个空格。 + </p> + <p>这里是结果。</p> + <p></p> + <div translate="no" class="threejs_example_container notranslate"> + <div><iframe class="threejs_example notranslate" translate="no" style=" " + src="/manual/examples/resources/editor.html?url=/manual/examples/responsive-no-resize.html"></iframe> + </div> + <a class="threejs_center" href="/manual/examples/responsive-no-resize.html" target="_blank">点击此处在新标签页中打开</a> + </div> + + <p></p> + <p>你可以看到canvas充满了整个页面，但是有两个问题。 + 第一是我们的立方体被拉伸了。他们不是立方体了更像是个盒子，太高或者太宽。在新标签中打开它然后改变尺寸你就能看到立方体是怎么在宽高上被拉伸的。</p> + <p><img src="../resources/images/resize-incorrect-aspect.png" width="407" class="threejs_center nobg"></p> + <p>另一个问题是立方体看起来分辨率太低或者说块状化或者有点模糊。 + 将窗口拉伸的非常大你就能看到问题。</p> + <p><img src="../resources/images/resize-low-res.png" class="threejs_center nobg"></p> + <p>我们先解决拉伸的问题。为此我们要将相机的宽高比设置为canvas的宽高比。 + 我们可以通过canvas的<code class="notranslate" translate="no">clientWidth</code>和<code class="notranslate" + translate="no">clientHeight</code>属性来实现。</p> + <p>我们需要将渲染循环变成这样。</p> + <pre class="prettyprint showlinemods notranslate lang-js" translate="no">function render(time) { time = 0.001; + const canvas = renderer.domElement; @@ -87,30 +97,35 @@ <h1>响应式设计</h1> ... </pre> -<p>现在立方体应该不会变形了。</p> -<p></p><div translate="no" class="threejs_example_container notranslate"> - <div><iframe class="threejs_example notranslate" translate="no" style=" " src="/manual/examples/resources/editor.html?url=/manual/examples/responsive-update-camera.html"></iframe></div> - <a class="threejs_center" href="/manual/examples/responsive-update-camera.html" target="_blank">点击此处在新标签页中打开</a> -</div> - -<p></p> -<p>在新标签页中打开例子你应该能看到立方体的宽高不会再被拉伸了。 -他们都会保持正确的比例不管窗口的尺寸如何。</p> -<p><img src="../resources/images/resize-correct-aspect.png" width="407" class="threejs_center nobg"></p> -<p>我们现在来解决块状化的问题。</p> -<p>canvas元素有两个尺寸。一个是canvas在页面上的显示尺寸， -是我们用CSS来设置的。另一个尺寸是canvas本身像素的数量。这和图片一样。 -比如我们有一个128x64像素的图片然后我们可以通过CSS让它显示为 -400x200像素。</p> -<pre class="prettyprint showlinemods notranslate lang-html" translate="no"><img src="some128x64image.jpg" style="width:400px; height:200px"> + <p>现在立方体应该不会变形了。</p> + <p></p> + <div translate="no" class="threejs_example_container notranslate"> + <div><iframe class="threejs_example notranslate" translate="no" style=" " + src="/manual/examples/resources/editor.html?url=/manual/examples/responsive-update-camera.html"></iframe> + </div> + <a class="threejs_center" href="/manual/examples/responsive-update-camera.html" + target="_blank">点击此处在新标签页中打开</a> + </div> + + <p></p> + <p>在新标签页中打开例子你应该能看到立方体的宽高不会再被拉伸了。 + 他们都会保持正确的比例不管窗口的尺寸如何。</p> + <p><img src="../resources/images/resize-correct-aspect.png" width="407" class="threejs_center nobg"></p> + <p>我们现在来解决块状化的问题。</p> + <p>canvas元素有两个尺寸。一个是canvas在页面上的显示尺寸， + 是我们用CSS来设置的。另一个尺寸是canvas本身像素的数量。这和图片一样。 + 比如我们有一个128x64像素的图片然后我们可以通过CSS让它显示为 + 400x200像素。</p> + <pre class="prettyprint showlinemods notranslate lang-html" translate="no"><img src="some128x64image.jpg" style="width:400px; height:200px"> </pre> -<p>一个canvas的内部尺寸，它的分辨率，通常被叫做绘图缓冲区(drawingbuffer)尺寸。 -在three.js中我们可以通过调用<code class="notranslate" translate="no">renderer.setSize</code>来设置canvas的绘图缓冲区。 -我们应该选择什么尺寸? 最显而易见的是"和canvas的显示尺寸一样"。 -即可以直接用canvas的<code class="notranslate" translate="no">clientWidth</code>和<code class="notranslate" translate="no">clientHeight</code>属性。</p> -<p>我们写一个函数来检查渲染器的canvas尺寸是不是和canvas的显示尺寸不一样 -如果不一样就设置它。</p> -<pre class="prettyprint showlinemods notranslate lang-js" translate="no">function resizeRendererToDisplaySize(renderer) { + <p>一个canvas的内部尺寸，它的分辨率，通常被叫做绘图缓冲区(drawingbuffer)尺寸。 + 在three.js中我们可以通过调用<code class="notranslate" translate="no">renderer.setSize</code>来设置canvas的绘图缓冲区。 + 我们应该选择什么尺寸? 最显而易见的是"和canvas的显示尺寸一样"。 + 即可以直接用canvas的<code class="notranslate" translate="no">clientWidth</code>和<code class="notranslate" + translate="no">clientHeight</code>属性。</p> + <p>我们写一个函数来检查渲染器的canvas尺寸是不是和canvas的显示尺寸不一样 + 如果不一样就设置它。</p> + <pre class="prettyprint showlinemods notranslate lang-js" translate="no">function resizeRendererToDisplaySize(renderer) { const canvas = renderer.domElement; const width = canvas.clientWidth; const height = canvas.clientHeight; @@ -121,17 +136,18 @@ <h1>响应式设计</h1> return needResize; } </pre> -<p>注意我们检查了canvas是否真的需要调整大小。 -调整画布大小是canvas规范的一个有趣部分，如果它已经是我们想要的大小，最好不要设置相同的大小.</p> -<p>一旦我们知道了是否需要调整大小我们就调用<code class="notranslate" translate="no">renderer.setSize</code>然后 -传入新的宽高。在末尾传入<code class="notranslate" translate="no">false</code>很重要。 -<code class="notranslate" translate="no">render.setSize</code>默认会设置canvas的CSS尺寸但这并不是我们想要的。 -我们希望浏览器能继续工作就像其他使用CSS来定义尺寸的其他元素。我们不希望 -three.js使用canvas和其他元素不一样。</p> -<p>注意如果我们的canvas大小被调整了那函数会返回true。我们可以利用 -这个来检查是否有其他的东西应该更新。我们修改渲染循环 -来使用我们的新函数。</p> -<pre class="prettyprint showlinemods notranslate lang-js" translate="no">function render(time) { + <p>注意我们检查了canvas是否真的需要调整大小。 + 调整画布大小是canvas规范的一个有趣部分，如果它已经是我们想要的大小，最好不要设置相同的大小.</p> + <p>一旦我们知道了是否需要调整大小我们就调用<code class="notranslate" translate="no">renderer.setSize</code>然后 + 传入新的宽高。在末尾传入<code class="notranslate" translate="no">false</code>很重要。 + <code class="notranslate" translate="no">render.setSize</code>默认会设置canvas的CSS尺寸但这并不是我们想要的。 + 我们希望浏览器能继续工作就像其他使用CSS来定义尺寸的其他元素。我们不希望 + three.js使用canvas和其他元素不一样。 + </p> + <p>注意如果我们的canvas大小被调整了那函数会返回true。我们可以利用 + 这个来检查是否有其他的东西应该更新。我们修改渲染循环 + 来使用我们的新函数。</p> + <pre class="prettyprint showlinemods notranslate lang-js" translate="no">function render(time) { time = 0.001; + if (resizeRendererToDisplaySize(renderer)) { @@ -142,53 +158,64 @@ <h1>响应式设计</h1> ... </pre> -<p>因为只有canvas的显示尺寸变化时宽高比才变化所以我们 -只在<code class="notranslate" translate="no">resizeRendererToDisplaySize</code>函数返回<code class="notranslate" translate="no">true</code>时才设置摄像机的宽高比。</p> -<p></p><div translate="no" class="threejs_example_container notranslate"> - <div><iframe class="threejs_example notranslate" translate="no" style=" " src="/manual/examples/resources/editor.html?url=/manual/examples/responsive.html"></iframe></div> - <a class="threejs_center" href="/manual/examples/responsive.html" target="_blank">点击此处在新标签页中打开</a> -</div> - -<p></p> -<p>现在渲染的分辨率应该是和canvas的显示尺寸一样的。</p> -<p>为了说清楚让CSS处理调整尺寸我们将代码放进<a href="../examples/threejs-responsive.js">一个单独的js文件</a>。 -这里还有一些例子我们让CSS决定尺寸的大小并且注意我们并没有改变任何 -代码来让他们工作。</p> -<p>我们将立方体放在文字段落的中间。</p> -<p></p><div translate="no" class="threejs_example_container notranslate"> - <div><iframe class="threejs_example notranslate" translate="no" style=" " src="/manual/examples/resources/editor.html?url=/manual/examples/responsive-paragraph.html&startPane=html"></iframe></div> - <a class="threejs_center" href="/manual/examples/responsive-paragraph.html" target="_blank">点击此处在新标签页中打开</a> -</div> - -<p></p> -<p>这是我们在编辑器样式布局中使用的相同代码，右侧的控制区域可以调整大小。</p> -<p></p><div translate="no" class="threejs_example_container notranslate"> - <div><iframe class="threejs_example notranslate" translate="no" style=" " src="/manual/examples/resources/editor.html?url=/manual/examples/responsive-editor.html&startPane=html"></iframe></div> - <a class="threejs_center" href="/manual/examples/responsive-editor.html" target="_blank">点击此处在新标签页中打开</a> -</div> - -<p></p> -<p>重点注意我们的代码并没有改变，只有我们的HTML和CSS变了。</p> -<h2 id="-hd-dpi-">应对HD-DPI显示器</h2> -<p>HD-DPI代表每英寸高密度点显示器(视网膜显示器)。它指的是当今大多数的Mac和windows机器以及几乎所有的智能手机。</p> -<p>浏览器中的工作方式是不管屏幕的分辨率有多高使用CSS像素设置尺寸会被认为是一样的。 -同样的物理尺寸浏览器会渲染出字体的更多细节。</p> -<p>使用three.js有多种方法来应对HD-DPI。</p> -<p>第一种就是不做任何特别的事情。这可以说是最常见的。 -渲染三维图形需要大量的GPU处理能力。移动端的GPU能力比桌面端的要弱。至少截止到2018年, -手机都有非常高的分辨率显示器。 -目前最好的手机的HD-DPI比例为3x，意思是非高密度点显示器上的一个像素在高密度显示器上是9个像素。 -意味着需要9倍的渲染。</p> -<p>计算9倍的像素是个大工程所以如果保持代码不变我们将计算一个像素然后浏览器将以三倍大小绘制(3x3=9像素)。</p> -<p>对于大型的three.js应用来说上面就是你想要的否侧你的帧速率会很低。</p> -<p>尽管如此如果你确实想用设备的分辨率来渲染，three.js中有两种方法来实现。</p> -<p>一种是使用renderer.setPixelRatio来告诉three.js分辨率的倍数。 -访问浏览器从CSS像素到设备像素的倍数然后传给three.js。</p> -<pre class="prettyprint showlinemods notranslate notranslate" translate="no"> renderer.setPixelRatio(window.devicePixelRatio); -</pre><p>之后任何对<code class="notranslate" translate="no">renderer.setSize</code>的调用都会神奇地使用您请求的大小乘以您传入的像素比例. -<strong>强烈不建议这样</strong>。看下面。</p> -<p>另一种方法是在调整canvas的大小时自己处理。</p> -<pre class="prettyprint showlinemods notranslate lang-js" translate="no"> function resizeRendererToDisplaySize(renderer) { + <p>因为只有canvas的显示尺寸变化时宽高比才变化所以我们 + 只在<code class="notranslate" translate="no">resizeRendererToDisplaySize</code>函数返回<code class="notranslate" + translate="no">true</code>时才设置摄像机的宽高比。</p> + <p></p> + <div translate="no" class="threejs_example_container notranslate"> + <div><iframe class="threejs_example notranslate" translate="no" style=" " + src="/manual/examples/resources/editor.html?url=/manual/examples/responsive.html"></iframe></div> + <a class="threejs_center" href="/manual/examples/responsive.html" target="_blank">点击此处在新标签页中打开</a> + </div> + + <p></p> + <p>现在渲染的分辨率应该是和canvas的显示尺寸一样的。</p> + <p>为了说清楚让CSS处理调整尺寸我们将代码放进<a href="../examples/threejs-responsive.js">一个单独的js文件</a>。 + 这里还有一些例子我们让CSS决定尺寸的大小并且注意我们并没有改变任何 + 代码来让他们工作。</p> + <p>我们将立方体放在文字段落的中间。</p> + <p></p> + <div translate="no" class="threejs_example_container notranslate"> + <div><iframe class="threejs_example notranslate" translate="no" style=" " + src="/manual/examples/resources/editor.html?url=/manual/examples/responsive-paragraph.html&startPane=html"></iframe> + </div> + <a class="threejs_center" href="/manual/examples/responsive-paragraph.html" target="_blank">点击此处在新标签页中打开</a> + </div> + + <p></p> + <p>这是我们在编辑器样式布局中使用的相同代码，右侧的控制区域可以调整大小。</p> + <p></p> + <div translate="no" class="threejs_example_container notranslate"> + <div><iframe class="threejs_example notranslate" translate="no" style=" " + src="/manual/examples/resources/editor.html?url=/manual/examples/responsive-editor.html&startPane=html"></iframe> + </div> + <a class="threejs_center" href="/manual/examples/responsive-editor.html" target="_blank">点击此处在新标签页中打开</a> + </div> + + <p></p> + <p>重点注意我们的代码并没有改变，只有我们的HTML和CSS变了。</p> + <h2 id="-hd-dpi-">应对HD-DPI显示器</h2> + <p>HD-DPI代表每英寸高密度点显示器(视网膜显示器)。它指的是当今大多数的Mac和windows机器以及几乎所有的智能手机。</p> + <p>浏览器中的工作方式是不管屏幕的分辨率有多高使用CSS像素设置尺寸会被认为是一样的。 + 同样的物理尺寸浏览器会渲染出字体的更多细节。</p> + <p>使用three.js有多种方法来应对HD-DPI。</p> + <p>第一种就是不做任何特别的事情。这可以说是最常见的。 + 渲染三维图形需要大量的GPU处理能力。移动端的GPU能力比桌面端的要弱。至少截止到2018年, + 手机都有非常高的分辨率显示器。 + 目前最好的手机的HD-DPI比例为3x，意思是非高密度点显示器上的一个像素在高密度显示器上是9个像素。 + 意味着需要9倍的渲染。</p> + <p>计算9倍的像素是个大工程所以如果保持代码不变我们将计算一个像素然后浏览器将以三倍大小绘制(3x3=9像素)。</p> + <p>对于大型的three.js应用来说上面就是你想要的否侧你的帧速率会很低。</p> + <p>尽管如此如果你确实想用设备的分辨率来渲染，three.js中有两种方法来实现。</p> + <p>一种是使用renderer.setPixelRatio来告诉three.js分辨率的倍数。 + 访问浏览器从CSS像素到设备像素的倍数然后传给three.js。</p> + <pre class="prettyprint showlinemods notranslate notranslate" translate="no"> renderer.setPixelRatio(window.devicePixelRatio); +</pre> + <p>之后任何对<code class="notranslate" translate="no">renderer.setSize</code>的调用都会神奇地使用您请求的大小乘以您传入的像素比例. + <strong>强烈不建议这样</strong>。看下面。 + </p> + <p>另一种方法是在调整canvas的大小时自己处理。</p> + <pre class="prettyprint showlinemods notranslate lang-js" translate="no"> function resizeRendererToDisplaySize(renderer) { const canvas = renderer.domElement; const pixelRatio = window.devicePixelRatio; const width = canvas.clientWidth * pixelRatio \| 0; @@ -200,32 +227,37 @@ <h2 id="-hd-dpi-">应对HD-DPI显示器</h2> return needResize; } </pre> -<p>第二章方法从客观上来说更好。为什么？因为我拿到了我想要的。 -在使用three.js时有很多种情况下我们需要知道canvas的绘图缓冲区的确切尺寸。 -比如制作后期处理滤镜或者我们在操作着色器需要访问gl_FragCoord变量，如果我们截屏或者给GPU -读取像素，绘制到二维的canvas等等。 -通过我们自己处理我们会一直知道使用的尺寸是不是我们需要的。 -幕后并没有什么特殊的魔法发生。</p> -<p>这是一个使用上面代码的例子。</p> -<p></p><div translate="no" class="threejs_example_container notranslate"> - <div><iframe class="threejs_example notranslate" translate="no" style=" " src="/manual/examples/resources/editor.html?url=/manual/examples/responsive-hd-dpi.html"></iframe></div> - <a class="threejs_center" href="/manual/examples/responsive-hd-dpi.html" target="_blank">点击此处在新标签页中打开</a> -</div> - -<p></p> -<p>可能很难看出区别但是如果你有一个HD-DPI显示器 -和上面的例子做对比你就能发现边角更清晰。</p> -<p>这篇文章涵盖了一个非常基础但是很有必要的主题。接下来我们快速 -<a href="primitives.html">过一遍three.js提供的基本的东西 </a>.</p> - + <p>第二种方法从客观上来说更好。为什么？因为我拿到了我想要的。 + 在使用three.js时有很多种情况下我们需要知道canvas的绘图缓冲区的确切尺寸。 + 比如制作后期处理滤镜或者我们在操作着色器需要访问gl_FragCoord变量，如果我们截屏或者给GPU + 读取像素，绘制到二维的canvas等等。 + 通过我们自己处理我们会一直知道使用的尺寸是不是我们需要的。 + 幕后并没有什么特殊的魔法发生。</p> + <p>这是一个使用上面代码的例子。</p> + <p></p> + <div translate="no" class="threejs_example_container notranslate"> + <div><iframe class="threejs_example notranslate" translate="no" style=" " + src="/manual/examples/resources/editor.html?url=/manual/examples/responsive-hd-dpi.html"></iframe></div> + <a class="threejs_center" href="/manual/examples/responsive-hd-dpi.html" target="_blank">点击此处在新标签页中打开</a> </div> + + <p></p> + <p>可能很难看出区别但是如果你有一个HD-DPI显示器 + 和上面的例子做对比你就能发现边角更清晰。</p> + <p>这篇文章涵盖了一个非常基础但是很有必要的主题。接下来我们快速过一遍 + <a href="primitives.html">three.js提供的基本的东西 </a>. + </p> + </div> </div> - + </div> + <script src="/manual/resources/prettify.js"></script> <script src="/manual/resources/lesson.js"></script> -</body></html> \ No newline at end of file +</body> + +</html> \ No newline at end of file	false
Other	mrdoob	three.js	61807e80c5126cd664aa85bfcaf52f5f45933302.json	Add renderers italian version (#24882)	docs/api/it/renderers/WebGL1Renderer.html	@@ -0,0 +1,52 @@ +<!DOCTYPE html> +<html lang="it"> + <head> + <meta charset="utf-8" /> + <base href="../../../" /> + <script src="page.js"></script> + <link type="text/css" rel="stylesheet" href="page.css" /> + </head> + <body> + [page:WebGLRenderer] → + + <h1>[name]</h1> + + <p class="desc"> + Poiché la versione r118 [page:WebGLRenderer] utilizza automaticamente un contesto di rendering WebGL 2, quando viene aggiornato un progetto estistente a + => r118, l'applicazione potrebbe rompersi per due ragioni: + + <ul> + <li>Il codice dello shader personalizzato deve essere conforme a GLSL 3.0.</li> + <li>I controlli dell'estensione WebGL 1 devono essere cambiati.</li> + </ul> + + Se non hai tempo di cambiare il tuo codice ma vuoi ancora utilizzare l'ultima versione, puoi usare [name]. + Questa versione di renderer forzerà un contesto di rendering WebGL 1. + </p> + + <h2>Costruttore</h2> + + <h3>[name]( [param:Object parameters] )</h3> + <p> + Crea un nuovo [name]. + </p> + + <h2>Proprietà</h2> + <p>Vedi la classe base [page:WebGLRenderer] per le proprietà comuni.</p> + + <h3>[property:Boolean isWebGL1Renderer]</h3> + <p> + Flag di sola lettura per verificare se l'oggetto dato è di tipo [name]. + </p> + + + <h2>Metodi</h2> + <p>Vedi la classe base [page:WebGLRenderer] per i metodi comuni.</p> + + <h2>Source</h2> + + <p> + [link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js] + </p> + </body> +</html>	true
Other	mrdoob	three.js	61807e80c5126cd664aa85bfcaf52f5f45933302.json	Add renderers italian version (#24882)	docs/api/it/renderers/WebGL3DRenderTarget.html	@@ -0,0 +1,53 @@ +<!DOCTYPE html> +<html lang="it"> + <head> + <meta charset="utf-8" /> + <base href="../../../" /> + <script src="page.js"></script> + <link type="text/css" rel="stylesheet" href="page.css" /> + </head> + <body> + [page:WebGLRenderTarget] → + + <h1>[name]</h1> + + <p class="desc"> + Rappresenta un render target tridimensionale. + </p> + + <h2>Costruttore</h2> + + <h3>[name]( [param:Number width], [param:Number height], [param:Number depth] )</h3> + <p> + [page:Number width] - la lunghezza del render target, in pixel. Il valore predefinito è `1`.<br /> + [page:Number height] - l'altezza del render target, in pixel. Il valore predefinito è `1`.<br /> + [page:Number depth] - la profondità del render target. Il valore predefinito è `1`.<br /><br /> + + Crea un nuovo [name]. + </p> + + <h2>Proprietà</h2> + + <h3>Vedi [page:WebGLRenderTarget] per le proprietà ereditate</h3> + + <h3>[property:number depth]</h3> + <p> + La profondità del render target. + </p> + + <h3>[property:Data3DTexture texture]</h3> + <p> + La proprietà texture è sovrasctitta con un'istanza di [page:Data3DTexture]. + </p> + + <h2>Metodi</h2> + + <h3>Vedi [page:WebGLRenderTarget] per i metodi ereditati</h3> + + <h2>Source</h2> + + <p> + [link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js] + </p> + </body> +</html>	true
Other	mrdoob	three.js	61807e80c5126cd664aa85bfcaf52f5f45933302.json	Add renderers italian version (#24882)	docs/api/it/renderers/WebGLArrayRenderTarget.html	@@ -0,0 +1,59 @@ +<!DOCTYPE html> +<html lang="it"> + <head> + <meta charset="utf-8" /> + <base href="../../../" /> + <script src="page.js"></script> + <link type="text/css" rel="stylesheet" href="page.css" /> + </head> + <body> + [page:WebGLRenderTarget] → + + <h1>[name]</h1> + + <p class="desc"> + Questo tipo di render target rappresenta un array di texture. + </p> + + <h2>Esempi</h2> + + <p> + [example:webgl2_rendertarget_texture2darray WebGL 2 / render target / array]<br /> + </p> + + <h2>Costruttore</h2> + + <h3>[name]( [param:Number width], [param:Number height], [param:Number depth] )</h3> + <p> + [page:Number width] - la lunghezza del render target, in pixel. Il valore predefinito è `1`.<br /> + [page:Number height] - l'altezza del render target, in pixel. Il valore predefinito è `1`.<br /> + [page:Number depth] - la profondità del render target. Il valore predefinito è `1`.<br /><br /> + + Crea un nuovo [name]. + </p> + + <h2>Proprietà</h2> + + <h3>Vedi [page:WebGLRenderTarget] per le proprietà ereditate</h3> + + <h3>[property:number depth]</h3> + <p> + La profondità del render target. + </p> + + <h3>[property:DataArrayTexture texture]</h3> + <p> + La proprietà texture è sovrasctitta con un'istanza di [page:DataArrayTexture]. + </p> + + <h2>Metodi</h2> + + <h3>Vedi [page:WebGLRenderTarget] per i metodi ereditati</h3> + + <h2>Source</h2> + + <p> + [link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js] + </p> + </body> +</html>	true
Other	mrdoob	three.js	61807e80c5126cd664aa85bfcaf52f5f45933302.json	Add renderers italian version (#24882)	docs/api/it/renderers/WebGLCubeRenderTarget.html	@@ -0,0 +1,79 @@ +<!DOCTYPE html> +<html lang="it"> + <head> + <meta charset="utf-8" /> + <base href="../../../" /> + <script src="page.js"></script> + <link type="text/css" rel="stylesheet" href="page.css" /> + </head> + <body> + [page:WebGLRenderTarget] → + + <h1>[name]</h1> + + <p class="desc"> + Utilizzato da [page:CubeCamera] come suo [page:WebGLRenderTarget]. + </p> + + <h2>Esempi</h2> + + <p>Vedi [page:CubeCamera] per gli esempi.</p> + + + <h2>Costruttore</h2> + + + <h3>[name]([param:Number size], [param:Object options])</h3> + <p> + [page:Float size] - la dimensione, in pixel. Il valore predefinito è `1`.<br /> + options - (opzionale) oggetto che contiene i parametri della texture per un target texture auto generato + e i booleani depthBuffer/stencilBuffer. + + Per una spiegazione dei parametri della texture vedi [page:Texture Texture]. Le seguenti + sono opzioni valide:<br /><br /> + + [page:Constant wrapS] - Il valore predefinito è [page:Textures ClampToEdgeWrapping]. <br /> + [page:Constant wrapT] - Il valore predefinito è [page:Textures ClampToEdgeWrapping]. <br /> + [page:Constant magFilter] - Il valore predefinito è [page:Textures .LinearFilter]. <br /> + [page:Constant minFilter] - Il valore predefinito è [page:Textures LinearFilter]. <br /> + [page:Boolean generateMipmaps] - Il valore predefinito è `false`.<br /> + [page:Constant format] - Il valore predefinito è [page:Textures RGBAFormat]. <br /> + [page:Constant type] - Il valore predefinito è [page:Textures UnsignedByteType]. <br /> + [page:Number anisotropy] - Il valore predefinito è `1`. Vedi [page:Texture.anisotropy]<br /> + [page:Constant encoding] - Il valore predefinito è [page:Textures LinearEncoding]. <br /> + [page:Boolean depthBuffer] - Il valore predefinito è `true`.<br /> + [page:Boolean stencilBuffer] - Il valore predefinito è `false`.<br /><br /> + + Crea un nuovo [name] + </p> + + <h2>Proprietà</h2> + + <h3>Vedi [page:WebGLRenderTarget] per le proprietà ereditate</h3> + + <h2>Metodi</h2> + + <h3>Vedi [page:WebGLRenderTarget] per i metodi ereditati</h3> + + <h3>[method:this fromEquirectangularTexture]( [param:WebGLRenderer renderer], [param:Texture texture] )</h3> + <p> + [page:WebGLRenderer renderer] — il renderer.<br/> + [page:Texture texture] — la texture equirettangolare. + </p> + <p> + Utilizza questo metodo se vuoi convertire un panorama equirettangolare nel formato cubemap. + </p> + + <h3>[method:undefined clear]( [param:WebGLRenderer renderer], [param:Boolean color], [param:Boolean depth], [param:Boolean stencil] )</h3> + <p> + Chiama questo metodo per cancellare il colore, la profondità e/o i buffer stencil del render target. + Il buffer del colore è impostato al colore corrente del renderer. L'impostazione predefinita degli argomenti è `true`. + </p> + + <h2>Source</h2> + + <p> + [link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js] + </p> + </body> +</html>	true
Other	mrdoob	three.js	61807e80c5126cd664aa85bfcaf52f5f45933302.json	Add renderers italian version (#24882)	docs/api/it/renderers/WebGLMultipleRenderTargets.html	@@ -0,0 +1,67 @@ +<!DOCTYPE html> +<html lang="it"> + <head> + <meta charset="utf-8" /> + <base href="../../../" /> + <script src="page.js"></script> + <link type="text/css" rel="stylesheet" href="page.css" /> + </head> + <body> + [page:WebGLRenderTarget] → + + <h1>[name]</h1> + + <p class="desc"> + Un target di rendering speciale che consente a un fragment shader di scrivere su più texture. + Questo approccio è utile per le tecniche di rendering avanzate come la post-eleborazione o il rendering differito. + + Attenzione: [name] può solo essere utilizzato in un contesto di rendering WebGL 2. + </p> + + <h2>Esempi</h2> + + <p> + [example:webgl2_multiple_rendertargets webgl2 / multiple / rendertargets ] + </p> + + <h2>Costruttore</h2> + + + <h3>[name]([param:Number width], [param:Number height], [param:Number count], [param:Object options])</h3> + + <p> + [page:Number width] - La larghezza del target di rendering. Il valore predefinito è `1`.<br /> + [page:Number height] - L'altezza del target di rendering. Il valore predefinito è `1`.<br /> + [page:Number count] - Il numero di target di rendering. Il valore predefinito è `1`.<br /> + + options - (oggetto opzionale che contiene i parametri della texture per una texture target auto generata + e i booleani depthBuffer/stencilBuffer. Per una spiegazione dei parametri della texture consultare [page:Texture Texture]. + Per un elenco di opzioni valide, consultare [page:WebGLRenderTarget WebGLRenderTarget].)<br /><br /> + </p> + + <h2>Proprietà</h2> + + <h3>[property:Boolean isWebGLMultipleRenderTargets]</h3> + <p> + Flag di sola lettura per verificare se l'oggetto dato è di tipo [name]. + </p> + + <h3>[property:Array texture]</h3> + <p> + La proprietà texture viene sovrascritta in [name] e sostituita con un array. Questo array contiene i + riferimenti alla [page:WebGLRenderTarget.texture texture] dei rispettivi target di rendering. + </p> + + <p>Le proprietà [page:WebGLRenderTarget WebGLRenderTarget] sono disponibili su questa classe.</p> + + <h2>Metodi</h2> + + <p>I metodi [page:WebGLRenderTarget WebGLRenderTarget] sono disponibili su questa classe.</p> + + <h2>Source</h2> + + <p> + [link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js] + </p> + </body> +</html>	true
Other	mrdoob	three.js	61807e80c5126cd664aa85bfcaf52f5f45933302.json	Add renderers italian version (#24882)	docs/api/it/renderers/WebGLRenderTarget.html	@@ -0,0 +1,137 @@ +<!DOCTYPE html> +<html lang="it"> + <head> + <meta charset="utf-8" /> + <base href="../../../" /> + <script src="page.js"></script> + <link type="text/css" rel="stylesheet" href="page.css" /> + </head> + <body> + <h1>[name]</h1> + + <p class="desc"> + Un [link:https://webglfundamentals.org/webgl/lessons/webgl-render-to-texture.html render target] è un buffer + dove la scheda video disegna i pixel per una scena che viene renderizzata in background. + Viene utilizzata in diversi effetti, come applicare la post-elaborazione a un'immagine + renderizzata prima di visualizzarla sullo schermo. + </p> + + + <h2>Costruttore</h2> + + + <h3>[name]([param:Number width], [param:Number height], [param:Object options])</h3> + + <p> + [page:Float width] - La lunghezza del renderTarget. Il valore predefinito è `1`.<br /> + [page:Float height] - L'altezza del renderTarget. Il valore predefinito è `1`.<br /> + options - oggetto opzionale che contiene i parametri della texture per una texture target auto generata + e i booleani depthBuffer/stencilBuffer. + + Per una spiegazione dei parametri della texture vedi [page:Texture Texture]. Le seguenti + sono opzioni valide:<br /><br /> + + [page:Constant wrapS] - il valore predefinito è [page:Textures ClampToEdgeWrapping]. <br /> + [page:Constant wrapT] - il valore predefinito è [page:Textures ClampToEdgeWrapping]. <br /> + [page:Constant magFilter] - il valore predefinito è [page:Textures LinearFilter]. <br /> + [page:Constant minFilter] - il valore predefinito è [page:Textures LinearFilter]. <br /> + [page:Boolean generateMipmaps] - il valore predefinito è `false`.<br /> + [page:Constant format] - il valore predefinito è [page:Textures RGBAFormat]. <br /> + [page:Constant type] - il valore predefinito è [page:Textures UnsignedByteType]. <br /> + [page:Number anisotropy] - il valore predefinito è `1`. Vedi [page:Texture.anisotropy]<br /> + [page:Constant encoding] - il valore predefinito è [page:Textures LinearEncoding]. <br /> + [page:Boolean depthBuffer] - il valore predefinito è `true`. <br /> + [page:Boolean stencilBuffer] - il valore predefinito è `false`.<br /> + [page:Number samples] - il valore predefinito è 0.<br /><br /> + + Crea un nuovo [name] + </p> + + <h2>Proprietà</h2> + + <h3>[property:Boolean isWebGLRenderTarget]</h3> + <p> + Flag di sola lettura per verificare se l'oggetto dato è di tipo [name]. + </p> + + <h3>[property:number width]</h3> + <p> + La lunghezza del render target. + </p> + + <h3>[property:number height]</h3> + <p> + L'altezza del render target. + </p> + + <h3>[property:Vector4 scissor]</h3> + <p> + Un area rettangolare all'interno della viewport del render target. I frammenti che sono fuori dall'area verranno scartati. + </p> + + <h3>[property:Boolean scissorTest]</h3> + <p> + Indica se il test scissor è attivo o no. + </p> + + <h3>[property:Vector4 viewport]</h3> + <p> + Il viewport di questo render target. + </p> + + <h3>[property:Texture texture]</h3> + <p> + Questa istanza della texture contiene i pixel renderizzati. Utilizzalo come input per ulteriori informazioni. + </p> + + <h3>[property:Boolean depthBuffer]</h3> + <p> + Effettua il rendering al buffer di profondità. L'impostazione predefinita è `true`. + </p> + + <h3>[property:Boolean stencilBuffer]</h3> + <p> + Effettua il rendering al buffer stencil. Il valore predefinito è `false`. + </p> + + <h3>[property:DepthTexture depthTexture]</h3> + <p> + Se impostato, la profondità della scena verrà renderizzata su questa texture. Il valore predefinito è `null`. + </p> + + <h3>[property:Number samples]</h3> + <p> + Definisce il conteggio di campioni MSAA. Può essere utilizzato solo con WebGL 2. Il valore predefinito è `0`. + </p> + + <h2>Metodi</h2> + + <h3>[method:undefined setSize]( [param:Number width], [param:Number height] )</h3> + <p> + Imposta la dimensione del render target. + </p> + + <h3>[method:WebGLRenderTarget clone]()</h3> + <p> + Crea una copia di questo render target. + </p> + + <h3>[method:this copy]( [param:WebGLRenderTarget source] )</h3> + <p> + Adotta le impostazioni del render target dato. + </p> + + <h3>[method:undefined dispose]()</h3> + <p> + Libera le risorse relative alla GPU allocate a questa istanza. Chiama questo metodo ogni volta che questa istanza non viene più utilizzata nella tua app. + </p> + + <p>I metodi [page:EventDispatcher EventDispatcher] sono disponibili in questa classe.</p> + + <h2>Source</h2> + + <p> + [link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js] + </p> + </body> +</html>	true
Other	mrdoob	three.js	61807e80c5126cd664aa85bfcaf52f5f45933302.json	Add renderers italian version (#24882)	docs/api/it/renderers/WebGLRenderer.html	@@ -0,0 +1,520 @@ +<!DOCTYPE html> +<html lang="it"> + <head> + <meta charset="utf-8" /> + <base href="../../../" /> + <script src="page.js"></script> + <link type="text/css" rel="stylesheet" href="page.css" /> + </head> + <body> + <h1>[name]</h1> + + <p class="desc"> + Il WebGL rendering mostra le tue scene meravigliosamente realizzate utilizzando + [link:https://en.wikipedia.org/wiki/WebGL WebGL]. + </p> + + <h2>Costruttore</h2> + + <h3>[name]( [param:Object parameters] )</h3> + <p> + [page:Object parameters] - (opzionale) oggetto con proprietà che definiscono il comportamento del renderer. + Il costruttore inoltre non accetta alcun parametro. In tutti i casi, assumerà impostazioni predefinite + quando i parametri mancheranno. I seguenti sono parametri validi:<br /><br /> + + [page:DOMElement canvas] - Un [link:https://developer.mozilla.org/en-US/docs/Web/HTML/Element/canvas canvas] + dove il renderer disegna il suo output. + Questo corrisponde alla proprietà [page:WebGLRenderer.domElement domElement] di seguito. + Se non viene passato, un nuovo elemento canvas sarà creato.<br /> + + + [page:WebGLRenderingContext context] - Questo può essere utilizzato per collegare il renderer ad un + [link:https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext RenderingContext] esistente. + Il valore predefinito è `null`.<br /> + + [page:String precision] - Precisione dello shader. Può essere `"highp"`, `"mediump"` o `"lowp"`. + Il valore predefinito è `"highp"` se supportato dal dispositivo.<br /> + + [page:Boolean alpha] - controlla il valore predefinito di alfa. Quando impostato a `true`, il valore è `0`. Altrimenti è `1`. Il valore predefinito è `false`.<br /> + + [page:Boolean premultipliedAlpha] - Indica se il renderer presumerà che i colori abbiano + [link:https://en.wikipedia.org/wiki/Glossary_of_computer_graphics#Premultiplied_alpha premoltiplicato alfa]. + Il valore predefinito è `true`.<br /> + + [page:Boolean antialias] - Indica se eseguire l'antialiasing. Il valore predefinito è `false`.<br /> + + [page:Boolean stencil] - Indica se il buffer di disegno ha un + [link:https://en.wikipedia.org/wiki/Stencil_buffer buffer stencil] di almeno 8 bit. + Il valore predefinito è `true`.<br /> + + [page:Boolean preserveDrawingBuffer] - Indica se conservare i buffer finché non verranno cancellati + o sovrascritti manualmente. Il valore predefinito è `false`.<br /> + + [page:String powerPreference] - Fornisce un suggerimento allo user agent indicando quale configurazione della + GPU è adatta per questo contesto WebGL. Può essere `"high-performance"`, `"low-power"` o `"default"`. Il valore predefinito è `"default"`. + Vedi [link:https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.2 WebGL spec] per i dettagli.<br /> + + [page:Boolean failIfMajorPerformanceCaveat] - Indica se la creazione del renderer avrà esito negativo in caso di rilevamento + di prestazioni ridotte. Il valore predefinito è `false`. + Vedi [link:https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.2 WebGL spec] per i dettagli.<br /> + + [page:Boolean depth] - Indica se il buffer di disegno ha un + [link:https://en.wikipedia.org/wiki/Z-buffering buffer di depth] di almeno 16 bit. + Il valore predefinito è `true`.<br /> + + [page:Boolean logarithmicDepthBuffer] - Indica se usare un buffer di depth logaritmico. Potrebbe essere necessario utilizzare + questa opzione se si ha a che fare con enormi differenze di scala in una singola scena. Si noti che questa impostazione + utilizza gl_FragDepth, se disponibile, che disabilita l'ottimizzione [link:https://www.khronos.org/opengl/wiki/Early_Fragment_Test Early Fragment Test] + e può causare una riduzione delle prestazioni. + Il valore predefinito è `false`. Vedi l'esempio [example:webgl_camera_logarithmicdepthbuffer camera / logarithmicdepthbuffer]. + </p> + + <h2>Proprietà</h2> + + <h3>[property:Boolean autoClear]</h3> + <p>Definisce se il renderer deve cancellare automaticamente il suo output prima di eseguire il rendering di un frame.</p> + + + <h3>[property:Boolean autoClearColor]</h3> + <p> + Se [page:.autoClear autoClear] è `true`, definisce se il renderer deve cancellare il buffer del colore. + Il valore predefinito è `true`. + </p> + + + <h3>[property:Boolean autoClearDepth]</h3> + <p> + Se [page:.autoClear autoClear] è `true`, definisce se il renderer deve cancellare il buffer di depth. + Il valore predefinito è `true`. + </p> + + + <h3>[property:Boolean autoClearStencil]</h3> + <p> + Se [page:.autoClear autoClear] è `true`, definisce se il renderer deve cancellare il buffer dello stencil. + Il valore predefinito è `true`. + </p> + + <h3>[property:Object debug]</h3> + <p> + - [page:Boolean checkShaderErrors]: + Se è `true`, definisce se i programmi material shader devono essere controllati per errori + durante la compilazione e il processo di collegamento. + Può essere utile disabilitare questo controllo in produzione per aumentare le prestazioni. + È fortemente raccomandato mantenere questi controlli attivi durante lo sviluppo. + Se lo shader non si compila e non si collega - non funzionerà e il materiale associato non verrà visualizzato. + Il valore predefinito è `true`. + </p> + + <h3>[property:Object capabilities]</h3> + <p> + Un oggetto che contiene i dettagli sulle capacità del [link:https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext RenderingContext] corrente.<br /> + + - [page:Boolean floatFragmentTextures]: indica se il contesto supporta l'estensione [link:https://developer.mozilla.org/en-US/docs/Web/API/OES_texture_float OES_texture_float].<br /> + - [page:Boolean floatVertexTextures]: `true` se [page:Boolean floatFragmentTextures] e [page:Boolean vertexTextures] sono entrambi true.<br /> + - [page:Method getMaxAnisotropy](): Restituisce l'anisotropia massima disponibile.<br /> + - [page:Method getMaxPrecision](): Restituisce la precisione massima disponibile per gli shader vertex e fragment. <br /> + - [page:Boolean isWebGL2]: `true` se il contesto in uso è un oggetto WebGL2RenderingContext.<br /> + - [page:Boolean logarithmicDepthBuffer]: `true` se il [page:parameter logarithmicDepthBuffer] era impostato a true nel costruttore e + il contesto supporta l'estensione [link:https://developer.mozilla.org/en-US/docs/Web/API/EXT_frag_depth EXT_frag_depth].<br /> + - [page:Integer maxAttributes]: Il valore di `gl.MAX_VERTEX_ATTRIBS`.<br /> + - [page:Integer maxCubemapSize]: Il valore di `gl.MAX_CUBE_MAP_TEXTURE_SIZE`. + Altezza massima * larghezza delle texture della mappa del cubo che uno shader può utilizzare.<br /> + - [page:Integer maxFragmentUniforms]: Il valore di `gl.MAX_FRAGMENT_UNIFORM_VECTORS`. + Il numero di uniforms che possono essere utilizzate da un fragment shader.<br /> + - [page:Integer maxSamples]: Il valore di `gl.MAX_SAMPLES`. + Il numero massimo di campioni nel contesto dell'anti-aliasing multicampione (MSAA).<br /> + - [page:Integer maxTextureSize]: Il valore di `gl.MAX_TEXTURE_SIZE`. + Altezza massima * larghezza di una texture che uno shader utilizza.<br /> + - [page:Integer maxTextures]: Il valore di `gl.MAX_TEXTURE_IMAGE_UNITS`. + Il numero massimo di texture che possono essere utilizzate da uno shader.<br /> + - [page:Integer maxVaryings]: Il valore di `gl.MAX_VARYING_VECTORS`. + Il numero di vettori varying che possono essere utilizzati dagli shader.<br /> + - [page:Integer maxVertexTextures]: Il valore di `gl.MAX_VERTEX_TEXTURE_IMAGE_UNITS`. + Il numero di texture che possono essere utilizzate in un vertex shader.<br /> + - [page:Integer maxVertexUniforms]: Il valore di `gl.MAX_VERTEX_UNIFORM_VECTORS`. + Il numero massimo di uniforms che possono essere utilizzate in un vertex shader.<br /> + - [page:String precision]: La precisione dello shader attualmente utilizzata dal renderer.<br /> + - [page:Boolean vertexTextures]: `true` se [property:Integer maxVertexTextures] è maggiore di 0 (ad es. è possibile utilizzare vertex texture).<br /> + </p> + + <h3>[property:Array clippingPlanes]</h3> + <p> + L'utente definisce piani di taglio specificati come oggetti THREE.Plane nello spazio world. + Questi piani si applicano a livello globale. I punti nello spazio il cui prodotto scalare con il + piano è negativo vengono tagliati. + Il valore predefinito è []. + </p> + + <h3>[property:DOMElement domElement]</h3> + <p> + Un [link:https://developer.mozilla.org/en-US/docs/Web/HTML/Element/canvas canvas] dove il renderer disegna il suo output.<br /> + Questo viene automaticamente creato dal renderer nel costruttore (se non è già stato fornito); + devi solo aggiungerlo alla tua pagina in questo modo:<br /> + <code> + document.body.appendChild( renderer.domElement ); + </code> + </p> + + <h3>[property:Object extensions]</h3> + <p> + - [page:Object get]( [param:String extensionName] ): + Utilizzato per verificare se le varie estensioni sono supportate e restituisce un oggetto con i dettagli dell'estensione se disponibile. + Questo metodo può controllare per le seguenti estensioni:<br /> + + <ul> + <li>`WEBGL_depth_texture`</li> + <li>`EXT_texture_filter_anisotropic`</li> + <li>`WEBGL_compressed_texture_s3tc`</li> + <li>`WEBGL_compressed_texture_pvrtc`</li> + <li>`WEBGL_compressed_texture_etc1`</li> + </ul> + </p> + + <h3>[property:number outputEncoding]</h3> + <p>Definisce la codifica di output del renderer. Il valore predefinito è [page:Textures THREE.LinearEncoding].</p> + <p>Se il target render è stato impostato utilizzando [page:WebGLRenderer.setRenderTarget .setRenderTarget], + verrà invece utilizzato renderTarget.texture.encoding.</p> + <p>Vedi la pagina [page:Textures texture constants] per i dettagli su altri formati.</p> + + <h3>[property:Object info]</h3> + <p> + Un oggetto con una serie di informazioni statistiche sulla memoria della scheda grafica e sul processo di rendering. + Utile per il debug o solo per curiosità. L'oggetto contiene i seguenti campi:</p> + <p> + <ul> + <li>memory: + <ul> + <li>geometries</li> + <li>textures</li> + </ul> + </li> + <li>render: + <ul> + <li>calls</li> + <li>triangles</li> + <li>points</li> + <li>lines</li> + <li>frame</li> + </ul> + </li> + <li>programs + </li> + </ul> + </p> + <p> + Per impostazione predefinita questi dati vengono reimpostati ad ogni chiamata di rendering ma quando si + hanno più passaggi di rendering per frame (ad esempio quando si utilizza la post elaborazione) può essere + preferibile ripristinare con un modello personalizzato. + Inanzitutto, imposta `autoReset` a `false`. + <code> + renderer.info.autoReset = false; + </code> + Chiama `reset()` ogni volta che hai terminato di renderizzare ogni singolo frame. + <code> + renderer.info.reset(); + </code> + </p> + + <h3>[property:Boolean localClippingEnabled]</h3> + <p>Definisce se il render rispetta i piani di taglio a livello di oggetto. Il valore predefinito è `false`.</p> + + <h3>[property:Boolean physicallyCorrectLights]</h3> + <p> + Indica se utilizzare la modalità di illuminazione fisicamente corretta. Il valore predefinito è `false`. + Vedi l'esempio [example:webgl_lights_physical lights / physical]. + </p> + + <h3>[property:Object properties]</h3> + <p> + Utilizzato internamente dal renderer per mantenere traccia delle proprietà dei vari oggetti secondari. + </p> + + <h3>[property:WebGLRenderLists renderLists]</h3> + <p> + Utilizzato internamente per gestire l'ordine del rendering degli oggetti della scena. + </p> + + <h3>[property:WebGLShadowMap shadowMap]</h3> + <p> + Questo contiene il riferimento alla mappa delle ombre, se utilizzato.<br /> + - [page:Boolean enabled]: + Se impostato, utilizza le mappe delle ombre nella scena. Il valore predefinito è `false`.<br /> + - [page:Boolean autoUpdate]: + Abilita aggiornamenti automatici delle ombre nella scena. Il valore predefinito è `true`.<br /> + Se non hai bisogno di luci/ombre, puoi impostarlo su `false` quando viene creata un'istanza del renderer.<br /> + - [page:Boolean needsUpdate]: + Quando impostato a `true`, le mappe delle ombre nella scena verranno aggiornate nella prossima chiamata a `render`. Il valore predefinito è `false`.<br /> + Se hai disabilitato gli aggiornamenti automatici alle mappe della ombre (`shadowMap.autoUpdate = false`), + avrai bisogno di impostare questo a `true` e poi fare una chiamata a `render` per aggiornare le ombre nella tua scena.<br /> + - [page:Integer type]: + Definisce il tipo di mappa delle ombre (non filtrato, filtro di chiusura percentuale, filtro di chiusura percentuale con filtro + bilineare nello shader). + Le opzioni sono: + <ul> + <li>THREE.BasicShadowMap</li> + <li>THREE.PCFShadowMap (default)</li> + <li>THREE.PCFSoftShadowMap</li> + <li>THREE.VSMShadowMap</li> + </ul> + Vedi [page:Renderer Renderer constants] per i dettagli.<br /> + </p> + + <h3>[property:Boolean sortObjects]</h3> + <p> + Definisce se il renderer deve ordinare gli oggetti. Il valore predefinito è `true`.<br /><br /> + + Nota: L'ordinamento viene utilizzato per tentare di eseguire correttamente il rendering di oggetti + con un certo grado di trasparenza. Per definizione, l'ordinamento degli oggetti potrebbe non funzionare + in tutti i casi. A seconda delle esigenze dell'applicazione, potrebbe essere necessario disattivare + l'ordinamento e utilizzare altri metodi per gestire il rendering della trasparenza, ad es. + determinare manualmente l'ordine di rendering di ciascun oggetto. + </p> + + <h3>[property:Object state]</h3> + <p> + Contiene funzioni per settare varie proprietà dello stato [page:WebGLRenderer.context]. + </p> + + <h3>[property:Constant toneMapping]</h3> + <p> + Il valore predefinito è [page:Renderer NoToneMapping]. Vedi [page:Renderer Renderer constants] per altre scelte. + </p> + + <h3>[property:Number toneMappingExposure]</h3> + <p> + Livello della mappatura dei toni. Il valore predefinito è `1`. + </p> + + <h3>[property:WebXRManager xr]</h3> + <p> + Fornisce accesso all'[page:WebXRManager interfaccia] relativa al WebXR del renderer. + </p> + + <h2>Metodi</h2> + + <h3>[method:undefined clear]( [param:Boolean color], [param:Boolean depth], [param:Boolean stencil] )</h3> + <p> + Dice al renderer di cancellare il suo colore, il(i) buffer di disegno depth e stancil. + Questo metodo inizializza il buffer del colore al valore di color corrente.<br /> + Il valore predefinito degli argomenti è `true`. + </p> + + <h3>[method:undefined clearColor]( )</h3> + <p>Cancella il buffer di colore. Equivalente a chiamare [page:WebGLRenderer.clear .clear]( true, false, false ).</p> + + <h3>[method:undefined clearDepth]( )</h3> + <p>Cancella il buffer di profondità. Equivalente a chiamare [page:WebGLRenderer.clear .clear]( false, true, false ).</p> + + <h3>[method:undefined clearStencil]( )</h3> + <p>Cancella il buffer di stencil. Equivalente a chiamare [page:WebGLRenderer.clear .clear]( false, false, true ).</p> + + <h3>[method:undefined compile]( [param:Object3D scene], [param:Camera camera] )</h3> + <p>Compila tutti i materiali nella scena con la telecamera. Questo è utile per precompilare le ombre prima del primo rendering.</p> + + <h3>[method:undefined copyFramebufferToTexture]( [param:Vector2 position], [param:FramebufferTexture texture], [param:Number level] )</h3> + <p> + Copia i pixel dal WebGLFramebuffer corrente in una texture 2D. Abilita l'accesso a + [link:https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/copyTexImage2D WebGLRenderingContext.copyTexImage2D]. + </p> + + <h3>[method:undefined copyTextureToTexture]( [param:Vector2 position], [param:Texture srcTexture], [param:Texture dstTexture], [param:Number level] )</h3> + <p> + Copia tutti i pixel della texture in una texture esistente partendo dalla posizione data. Abilita l'accesso a + [link:https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/texSubImage2D WebGLRenderingContext.texSubImage2D]. + </p> + + <h3>[method:undefined copyTextureToTexture3D]( [param:Box3 sourceBox], [param:Vector3 position], [param:Texture srcTexture], [param:Texture dstTexture], [param:Number level] )</h3> + <p> + Copia i pixel della texture nei limiti '[page:Box3 sourceBox]' nella texture di destinazione partendo dalla posizione data. Abilita l'accesso a + [link:https://developer.mozilla.org/en-US/docs/Web/API/WebGL2RenderingContext/texSubImage3D WebGL2RenderingContext.texSubImage3D]. + </p> + + <h3>[method:undefined dispose]( )</h3> + <p> + Libera le risorse relative alla GPU allocata a questa istanza. Chiama questo metodo ogni volta che questa istanza non viene più utilizzata nella + tua applicazione. + </p> + + <h3>[method:undefined forceContextLoss]()</h3> + <p> + Simula la perdita del contesto WebGL. Questo richiede il supporto per le + estensioni [link:https://developer.mozilla.org/en-US/docs/Web/API/WEBGL_lose_context WEBGL_lose_context]. + </p> + + <h3>[method:undefined forceContextRestore]( )</h3> + <p> + Simula il ripristino del contesto WebGL. Questo richiede il supporto per le + estensioni [link:https://developer.mozilla.org/en-US/docs/Web/API/WEBGL_lose_context WEBGL_lose_context]. + </p> + + <h3>[method:Float getClearAlpha]()</h3> + <p>Restituisce un [page:Float float] con l'alfa corrente. Intervallo tra 0 e 1.</p> + + <h3>[method:Color getClearColor]( [param:Color target] )</h3> + <p>Restituisce un'istanza [page:Color THREE.Color] con l'alfa corrente.</p> + + <h3>[method:WebGL2RenderingContext getContext]()</h3> + <p>Restituisce il contesto WebGL corrente.</p> + + <h3>[method:WebGLContextAttributes getContextAttributes]()</h3> + <p>Restituisce un oggetto che descrive gli attributi impostati sul contesto WebGL quando è stato creato.</p> + + <h3>[method:Integer getActiveCubeFace]()</h3> + <p>Restituisce la faccia del cubo attiva corrente.</p> + + <h3>[method:Integer getActiveMipmapLevel]()</h3> + <p>Restituisce il livello mipmap attivo corrente.</p> + + <h3>[method:RenderTarget getRenderTarget]()</h3> + <p>Restituisce il [page:RenderTarget RenderTarget] correnti se ci sono; altrimenti restituisce `null`.</p> + + <h3>[method:Vector4 getCurrentViewport]( [param:Vector4 target] )</h3> + <p> + [page:Vector4 target] — il risultato verrà copiato in questo Vector4.<br /><br /> + + Restituisce il viewport corrente. + </p> + + <h3>[method:Vector2 getDrawingBufferSize]( [param:Vector2 target] )</h3> + <p> + [page:Vector2 target] — il risultato verrà copiato in questo Vector2.<br /><br /> + + Restituisce la lunghezza e l'altezza del buffer di disegno del renderer, in pixel. + </p> + + <h3>[method:number getPixelRatio]()</h3> + <p>Restituisce il pixel ratio del dispotivo corrente utilizzato.</p> + + <h3>[method:Vector4 getScissor]( [param:Vector4 target] )</h3> + <p> + [page:Vector4 target] — il risultato verrà copiato in questo Vector4.<br /><br /> + + Restituisce la regione scissor. + </p> + + <h3>[method:Boolean getScissorTest]()</h3> + <p>Restituisce `true` se scissor test è abilitato; altrimenti restituisce `false`.</p> + + <h3>[method:Vector2 getSize]( [param:Vector2 target] )</h3> + <p> + [page:Vector2 target] — il risultato verrà copiato in questo Vector2.<br /><br /> + + Restituisce la lunghezza e l'altezza del canvas di output del renderer, in pixel. + </p> + + <h3>[method:Vector4 getViewport]( [param:Vector4 target] )</h3> + <p> + [page:Vector4 target] — il risultato verrà copiato in questo Vector4.<br /><br /> + + Restituisce il viewport. + </p> + + <h3>[method:undefined initTexture]( [param:Texture texture] )</h3> + <p> + Inizializza la texture data. Utilizzato per precaricare una texture piuttosto che aspettare fino al primo rendering + (il quale può causare notevoli ritardi dovuti alla decodifica e al sovraccarico di caricamento della GPU). + </p> + + <h3>[method:undefined resetGLState]( )</h3> + <p>Reimposta lo stato GL al valore predefinito. Chiamato internamente se il contesto WebGL viene perso.</p> + + <h3>[method:undefined readRenderTargetPixels]( [param:WebGLRenderTarget renderTarget], [param:Float x], [param:Float y], [param:Float width], [param:Float height], [param:TypedArray buffer], [param:Integer activeCubeFaceIndex] )</h3> + <p>buffer - Uint8Array è l'unico tipo di destinazione supportato in tutti i casi, altri tipi dipendono dal renderTarget e dalla piattaforma. Vedi [link:https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.12 WebGL spec] per i dettagli.</p> + <p>Legge le informazioni dei pixel dal renderTarget nel buffer che gli hai passato. Questo è un wrapper attorno a [link:https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/readPixels WebGLRenderingContext.readPixels]().</p> + <p>Vedi l'esempio [example:webgl_interactive_cubes_gpu interactive / cubes / gpu].</p> + <p>Per leggere un [page:WebGLCubeRenderTarget WebGLCubeRenderTarget] utilizzare il parametro opzionale activeCubeFaceIndex per determinare quale faccia deve essere letta.</p> + + + <h3>[method:undefined render]( [param:Object3D scene], [param:Camera camera] )</h3> + <p> + Renderizza una [page:Scene scena] o un altro tipo di [page:Object3D oggetto] utilizzando una [page:Camera telecamera].<br /> + + Il rendering viene seguito su un set [page:WebGLRenderTarget renderTarget] specificato chiamando + [page:WebGLRenderer.setRenderTarget .setRenderTarget] o sul canvas come al solito.<br /> + + Per impostazione predefinita i buffer sono cancellati prima del rendering ma puoi prevenirlo imposstando la proprietà [page:WebGLRenderer.autoClear autoClear] a false. + Se vuoi prevenire solo certi buffer dall'essere cancellati puoi impostare le proprietà [page:WebGLRenderer.autoClearColor autoClearColor], [page:WebGLRenderer.autoClearStencil autoClearStencil] o + [page:WebGLRenderer.autoClearDepth autoClearDepth] a false. Per cancellare forzatamente uno o più buffer chiama [page:WebGLRenderer.clear .clear]. + </p> + + <h3>[method:undefined resetState]()</h3> + <p>Può essere utilizzato per reimpostare lo stato interno WebGL. Questo metodo è principalmente rilevante per applicazioni che condividono un singolo contesto WebGL tra multiple librerie WebGL.</p> + + <h3>[method:undefined setAnimationLoop]( [param:Function callback] )</h3> + <p>[page:Function callback] — La funzione cancellerà ogni frame disponibile. Se viene passato `null`, si interromperà qualsiasi animazione già in corso.</p> + <p>Una funzione incorporata che può essere utilizzata al posto di [link:https://developer.mozilla.org/en-US/docs/Web/API/window/requestAnimationFrame requestAnimationFrame]. + Questa funzione deve essere utilizza per oggetti WebXR.</p> + + <h3>[method:undefined setClearAlpha]( [param:Float alpha] )</h3> + <p>Imposta l'alfa. L'input valido è un float tra `0.0` e `1.0`.</p> + + <h3>[method:undefined setClearColor]( [param:Color color], [param:Float alpha] )</h3> + <p>Imposta il colore e l'opacità.</p> + + <h3>[method:undefined setPixelRatio]( [param:number value] )</h3> + <p>Imposta la pixel ratio del dispositivo. Questo viene utilizzato per il dispositivo HiDPI per evitare la sfocatura del canvas di output.</p> + + <h3>[method:undefined setRenderTarget]( [param:WebGLRenderTarget renderTarget], [param:Integer activeCubeFace], [param:Integer activeMipmapLevel] )</h3> + <p> + renderTarget -- Il [page:WebGLRenderTarget renderTarget] cha ha bisogno di essere attivato. Quando viene fornito `null`, il canvas invece viene impostato come target di rendering attivo.<br /> + activeCubeFace -- Specifica il lato attivo del cubo (PX 0, NX 1, PY 2, NY 3, PZ 4, NZ 5) di [page:WebGLCubeRenderTarget]. + Quando si passa un [page:WebGLArrayRenderTarget] o [page:WebGL3DRenderTarget] questo indica il livello z in cui eseguire il rendering (opzionale).<br /> + activeMipmapLevel -- Specifica il livello mipmap attivo (opzionale).<br /><br /> + Questo metodo imposta il renderTarget attivo. + </p> + + <h3>[method:undefined setScissor]( [param:Integer x], [param:Integer y], [param:Integer width], [param:Integer height] )<br /> + [method:undefined setScissor]( [param:Vector4 vector] )</h3> + + <p> + I parametri x, y, lunghezza, e altezza della regione di scissor.<br /> + Opzionale, un vettore component-4 che specifica i parametri della regione.<br /><br /> + + Imposta la regione di scissor da (x, y) a (x + width, y + height).<br /> + (x, y) indica l'angolo in basso a sinistra della regione di scissor. + </p> + + <h3>[method:undefined setScissorTest]( [param:Boolean boolean] )</h3> + <p> + Abilita o disabilita lo scissor test. Quando questo è abilitato, solo i pixel con l'area di + scissor definita saranno influenzati da ulteriori azioni del render. + </p> + + <h3>[method:undefined setOpaqueSort]( [param:Function method] )</h3> + <p> + Imposta la funzione di ordinamento opaco per la WebGLRenderLists. + Passa null per utilizzare la funzione predefinita painterSortStable. + </p> + + <h3>[method:undefined setTransparentSort]( [param:Function method] )</h3> + <p> + Imposta la funzione di ordinamento trasparente per la WebGLRenderLists. + Passa null per utilizzare la funzione predefinita reversePainterSortStable. + </p> + + <h3>[method:undefined setSize]( [param:Integer width], [param:Integer height], [param:Boolean updateStyle] )</h3> + <p> + Ridimensiona il canvas di output a (width, height) con la pixel ratio del device presa nell'account, + e inoltre imposta il viewport per adattarsi a quella dimensione, partendo da (0, 0). + Impostando [page:Boolean updateStyle] a false impedisce qualsiasi modifica di stile al canvas di output. + </p> + + <h3>[method:undefined setViewport]( [param:Integer x], [param:Integer y], [param:Integer width], [param:Integer height] )<br /> + [method:undefined setViewport]( [param:Vector4 vector] )</h3> + + <p> + I parametri x, y, lunghezza, e altezza del viewport.<br /> + Opzionale, un vettore component-4 che specifica i parametri del viewport.<br /><br /> + + Imposta il viewport per il rendering da (x, y) a (x + width, y + height).<br /> + (x, y) indica l'angolo in basso a sinistra della regione. + </p> + + <h2>Source</h2> + + <p> + [link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js] + </p> + </body> +</html>	true
Other	mrdoob	three.js	61807e80c5126cd664aa85bfcaf52f5f45933302.json	Add renderers italian version (#24882)	docs/api/it/renderers/shaders/ShaderChunk.html	@@ -0,0 +1,30 @@ +<!DOCTYPE html> +<html lang="it"> + <head> + <meta charset="utf-8" /> + <base href="../../../../" /> + <script src="page.js"></script> + <link type="text/css" rel="stylesheet" href="page.css" /> + </head> + <body> + <h1>[name]</h1> + + <p class="desc">Blocchi shader per la libreria Shader WebGL.</p> + + + + <h2>Proprietà</h2> + + + + <h2>Metodi</h2> + + + + <h2>Source</h2> + + <p> + [link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js] + </p> + </body> +</html>	true
Other	mrdoob	three.js	61807e80c5126cd664aa85bfcaf52f5f45933302.json	Add renderers italian version (#24882)	docs/api/it/renderers/shaders/ShaderLib.html	@@ -0,0 +1,29 @@ +<!DOCTYPE html> +<html lang="it"> + <head> + <meta charset="utf-8" /> + <base href="../../../../" /> + <script src="page.js"></script> + <link type="text/css" rel="stylesheet" href="page.css" /> + </head> + <body> + <h1>[name]</h1> + + <p class="desc">Libreria Shader WebGL per three.js.</p> + + + <h2>Proprietà</h2> + + + + <h2>Metodi</h2> + + + + <h2>Source</h2> + + <p> + [link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js] + </p> + </body> +</html>	true
Other	mrdoob	three.js	61807e80c5126cd664aa85bfcaf52f5f45933302.json	Add renderers italian version (#24882)	docs/api/it/renderers/shaders/UniformsLib.html	@@ -0,0 +1,30 @@ +<!DOCTYPE html> +<html lang="it"> + <head> + <meta charset="utf-8" /> + <base href="../../../../" /> + <script src="page.js"></script> + <link type="text/css" rel="stylesheet" href="page.css" /> + </head> + <body> + <h1>[name]</h1> + + <p class="desc">Libreria di uniformi per shared webgl condivisi.</p> + + + + <h2>Proprietà</h2> + + + + <h2>Metodi</h2> + + + + <h2>Source</h2> + + <p> + [link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js] + </p> + </body> +</html>	true
Other	mrdoob	three.js	61807e80c5126cd664aa85bfcaf52f5f45933302.json	Add renderers italian version (#24882)	docs/api/it/renderers/shaders/UniformsUtils.html	@@ -0,0 +1,41 @@ +<!DOCTYPE html> +<html lang="it"> + <head> + <meta charset="utf-8" /> + <base href="../../../../" /> + <script src="page.js"></script> + <link type="text/css" rel="stylesheet" href="page.css" /> + </head> + <body> + <h1>[name]</h1> + + <p class="desc"> + Fornisce funzioni di utilità per gestire le uniformi. + </p> + + <h2>Metodi</h2> + + <h3>[method:Object clone]( [param:Object src] )</h3> + <p> + src -- Un oggetto che rappresenta le definizioni delle uniformi.<br /><br /> + + Clona le definizioni delle uniformi date eseguendo una copia profonda. Questo significa che se + il [page:Uniform.value valore] di una uniforme si riferisce ad un oggetto come un [page:Vector3] + o una [page:Texture], la uniforme clonata farà riferimento a un nuovo oggetto di riferimento. + </p> + + <h3>[method:Object merge]( [param:Array uniforms] )</h3> + <p> + uniforms -- Un array di oggetti contente le definizioni della uniforme.<br /><br /> + + Unisce le definizioni della uniforme date nel singolo oggetto. Poiché il metodo + utilizza internamente [page:.clone](), esegue una copia profonda durante + la produzione delle definizioni della uniforme unita. + + <h2>Source</h2> + + <p> + [link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js] + </p> + </body> +</html>	true
Other	mrdoob	three.js	61807e80c5126cd664aa85bfcaf52f5f45933302.json	Add renderers italian version (#24882)	docs/api/it/renderers/webgl/WebGLProgram.html	@@ -0,0 +1,169 @@ +<!DOCTYPE html> +<html lang="it"> + <head> + <meta charset="utf-8" /> + <base href="../../../../" /> + <script src="page.js"></script> + <link type="text/css" rel="stylesheet" href="page.css" /> + </head> + <body> + <h1>[name]</h1> + + <p class="desc">Costruttore per il programma GLSL inviato agli shader vertex e fragment, comprese le uniformi e gli attributi.</p> + + <h2>Uniformi e attributi incorporati</h2> + + <h3>Vertex shader (incondizionato):</h3> + <div> + <code> + // = object.matrixWorld + uniform mat4 modelMatrix; + + // = camera.matrixWorldInverse * object.matrixWorld + uniform mat4 modelViewMatrix; + + // = camera.projectionMatrix + uniform mat4 projectionMatrix; + + // = camera.matrixWorldInverse + uniform mat4 viewMatrix; + + // = trasposizione inversa di modelViewMatrix + uniform mat3 normalMatrix; + + // = posizione della telecamera nello spazio world + uniform vec3 cameraPosition; + </code> + <code> + // attributi di vertice predefiniti forniti da Geometry e BufferGeometry + attribute vec3 position; + attribute vec3 normal; + attribute vec2 uv; + </code> + <p> + Si noti che è possibile quindi calcolare la posizione di un vertice nel vertex shader con: + <code> + gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 ); + </code> + o in alternativa + <code> + gl_Position = projectionMatrix * viewMatrix * modelMatrix * vec4( position, 1.0 ); + </code> + </p> + </div> + + <h3>Vertex shader (condizionale):</h3> + <div> + <code> + #if defined( USE_COLOR_ALPHA ) + // attributo del colore del vertice con alfa + attribute vec4 color; + #elif defined( USE_COLOR ) + // attributo del colore del vertice + attribute vec3 color; + #endif + </code> + <code> + #ifdef USE_MORPHTARGETS + + attribute vec3 morphTarget0; + attribute vec3 morphTarget1; + attribute vec3 morphTarget2; + attribute vec3 morphTarget3; + + #ifdef USE_MORPHNORMALS + + attribute vec3 morphNormal0; + attribute vec3 morphNormal1; + attribute vec3 morphNormal2; + attribute vec3 morphNormal3; + + #else + + attribute vec3 morphTarget4; + attribute vec3 morphTarget5; + attribute vec3 morphTarget6; + attribute vec3 morphTarget7; + + #endif + #endif + </code> + <code> + #ifdef USE_SKINNING + attribute vec4 skinIndex; + attribute vec4 skinWeight; + #endif + </code> + <code> + #ifdef USE_INSTANCING + // Si noti che modelViewMatrix non è impostato durante il rendering di un modello istanziato, + // ma può essere calcolato da viewMatrix * modelMatrix. + // + // Utilizzo di base: + // gl_Position = projectionMatrix * viewMatrix * modelMatrix * instanceMatrix * vec4(position, 1.0); + attribute mat4 instanceMatrix; + #endif + </code> + </div> + + <h3>Fragment shader:</h3> + <div> + <code> + uniform mat4 viewMatrix; + uniform vec3 cameraPosition; + </code> + </div> + + + <h2>Costruttore</h2> + + <h3>[name]( [param:WebGLRenderer renderer], [param:String cacheKey], [param:Object parameters] )</h3> + <p>Per i parametri vedere [page:WebGLRenderer WebGLRenderer].</p> + + <h2>Proprietà</h2> + + <h3>[property:String name]</h3> + <p>Il nome del rispettivo programma di shader.</p> + + <h3>[property:String id]</h3> + <p>L'identificativo di questa istanza.</p> + + <h3>[property:String cacheKey]</h3> + <p>Questa chiave consente la riutilizzabilità di un unico [name] per diversi materiali.</p> + + <h3>[property:Integer usedTimes]</h3> + <p>Quante volte questa istanza viene utilizzata per il rendering di elementi di rendering.</p> + + <h3>[property:Object program]</h3> + <p>L'attuale programma di shader.</p> + + <h3>[property:WebGLShader vertexShader]</h3> + <p>Il vertex shader.</p> + + <h3>[property:WebGLShader fragmentShader]</h3> + <p>Il fragment shader.</p> + + <h2>Metodi</h2> + + <h3>[method:Object getUniforms]()</h3> + <p> + Restituisce una mappa nome-valore di tutte le posizioni uniformi attive. + </p> + + <h3>[method:Object getAttributes]()</h3> + <p> + Restituisce una mappa nome-valore di tutte le posizioni degli attributi dei vertici attivi. + </p> + + <h3>[method:undefined destroy]()</h3> + <p> + Distrugge un'istanza di [name]. + </p> + + <h2>Source</h2> + + <p> + [link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js] + </p> + </body> +</html>	true
Other	mrdoob	three.js	61807e80c5126cd664aa85bfcaf52f5f45933302.json	Add renderers italian version (#24882)	docs/api/it/renderers/webxr/WebXRManager.html	@@ -0,0 +1,151 @@ +<!DOCTYPE html> +<html lang="it"> + <head> + <meta charset="utf-8" /> + <base href="../../../../" /> + <script src="page.js"></script> + <link type="text/css" rel="stylesheet" href="page.css" /> + </head> + <body> + + <h1>[name]</h1> + + <p class="desc"> + Questa classe rappresenta un'astrazione dell'API WebXR Device ed è utilizzata internamente da [page:WebGLRenderer]. + [name] inoltre fornisce un'interfaccia pubblica che permette agli utenti di abilitare e disabilitare XR ed + eseguire attività relative a XR come ad esempio il recupero dei controller. + </p> + + <h2>Proprietà</h2> + + <h3>[property:Boolean cameraAutoUpdate]</h3> + <p> + Indica se la telecamera XR del manager deve essere aggiornata automaticamente o no. Il valore predefinito è `true`. + </p> + + <h3>[property:Boolean enabled]</h3> + <p> + Questo flag notifica al renderer di essere pronto per il rendering XR. L'impostazione predefinita è `false`. + Impostalo a `true` se stai utilizzando XR nella tua applicazione. + </p> + + <h3>[property:Boolean isPresenting]</h3> + <p> + Indica se la presentazione XR è attiva o meno. Il valore predefinito è `false`. Questo flag è di sola + lettura e impostato automaticamente da [name]. + </p> + + <h2>Metodi</h2> + + <h3>[method:ArrayCamera getCamera]()</h3> + <p> + Restituisce un'istanza di [page:ArrayCamera] che rappresenta la telecamera XR sessione XR attiva. + Per ogni vista contiene un oggetto telecamera separato nella sua proprietà [page:ArrayCamera.cameras telecamere]. + </p> + <p> + Il `fov` della telecamera non viene utilizzato attualmente e non riflette il fov della telecamera XR. Se hai bisogno del fov a + livello di app, devi calcolare manualmente dalle matrici di proiezione della telecamera XR. + </p> + + <h3>[method:Group getController]( [param:Integer index] )</h3> + <p> + [page:Integer index] — L'indice del controller. <br /><br /> + + Restituisce un [page:Group gruppo] che rappresenta il cosidetto spazio target ray del controller XR. + Utilizza questo spazio per visualizzare gli oggetti 3D che supportano l'utente nel puntare attività come + l'intersezione dell'interfaccia utente. + </p> + + <h3>[method:Group getControllerGrip]( [param:Integer index] )</h3> + <p> + [page:Integer index] — L'indice del controller. <br /><br /> + + Restituisce un [page:Group gruppo] che rappresenta il cosidetto spazio `grip` del controller XR. + Utilizza questo spazio se l'utente terrà altri oggetti 3D come una spada laser. + </p> + + <p> + Nota: Se vuoi mostrare qualcosa nella mano dell'utente e offrire un raggio di puntamento allo stesso tempo, ti consigliamo di allegare + l'oggetto tenuto in mano al gruppo restituito da [page:.getControllerGrip]() e il raggio al gruppo restituito da [page:.getController](). + L'idea è quella di avere due gruppi diversi in due coordinate delle spazio diverse per lo stesso controller WebXR. + </p> + + <h3>[method:Float getFoveation]()</h3> + <p> + Restituisce la quantità di foveazione utilizzata dal compositore XR per il livello di proiezione. + </p> + + <h3>[method:Group getHand]( [param:Integer index] )</h3> + <p> + [page:Integer index] — L'indice del controller. <br /><br /> + + Restituisce un [page:Group gruppo] che rappresenta il cosidetto spazio `hand` o `joint` per il controller XR. + Utilizza questo spazio per visualizzare le mani dell'utente quando vengono utilizzati i controller non fisici. + </p> + + <h3>[method:String getReferenceSpace]()</h3> + <p> + Restituisce lo spazio di riferimento. + </p> + + <h3>[method:XRSession getSession]()</h3> + <p> + Restituisce l'oggetto `XRSession` il quale permette una maggiore gestione delle sessioni WebXR attive a livello di applicazione. + </p> + + <h3>[method:undefined setFoveation]( [param:Float foveation] )</h3> + <p> + [page:Float foveation] — Il foveazione da impostare.<br /><br /> + + Specifica la quantità di foveazione utilizzata dal compositore XR per il livello. Deve essere un valore tra `0` e `1`. + </p> + + <h3>[method:undefined setFramebufferScaleFactor]( [param:Float framebufferScaleFactor] )</h3> + <p> + [page:Float framebufferScaleFactor] — Il fattore di scala del framebuffer da impostare.<br /><br /> + + Specifica il fattore di ridimensionamento da utilizzare per determinare la dimensione del framebuffer durante il rendering + su un dispositivo XR. Il valore è relativo alla risoluzione del dispositivo XR predefinito. Il valore predefinito è `1`. + Un valore di `0.5` specificherebbe un framebuffer con il 50% della risoluzione nativa del display. + </p> + + <p> + Nota: Non è possibile modificare il fattore di scala del framebuffer durante la presentazione del contenuto. + </p> + + <h3>[method:undefined setReferenceSpace]( [param:XRReferenceSpace referenceSpace] )</h3> + <p> + [page:XRReferenceSpace referenceSpace] — Uno spazio personalizzato di riferimento.<br /><br /> + + Può essere utilizzato per configurare uno spazio personalizzato di riferimento il quale sovrascrive + lo spazio di riferimento predefinito. + </p> + + <h3>[method:undefined setReferenceSpaceType]( [param:String referenceSpaceType] )</h3> + <p> + [page:String referenceSpaceType] — Il tipo dello spazio di riferimento da impostare.<br /><br /> + + Può essere utilizzare per configurare una relazione spaziale con l'ambiente fisico dell'utente. A seconda di come l'utente + si muove nello spazio 3D, l'impostazione di uno spazio di riferimento appropriato può migliorare il tracciamento. + Il valore predefinito è `local-floor`. + Consultare l'[link:https://developer.mozilla.org/en-US/docs/Web/API/XRReferenceSpaceType MDN] per i possibli valori e i relativi casi d'uso. + </p> + + <h3>[method:undefined updateCamera]( [param:PerspectiveCamera camera] )</h3> + <p> + Aggiorna lo stato della telecamera XR. Utilizza questo metodo a livello di app, se imposti [page:.cameraAutoUpdate] a `false`. + Questo metodo richiede la telecamera non XR della scena come parametro. La trasformazione della telecamera passata viene automaticamente + regolata sulla posizione della telecamera XR quando si chiama questo metodo. + </p> + + <p> + Nota: Non è possibile modificare il tipo dello spazio di riferimento durante la presentazione del contenuto XR. + </p> + + <h2>Source</h2> + + <p> + [link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js] + </p> + </body> +</html>	true
Other	mrdoob	three.js	61807e80c5126cd664aa85bfcaf52f5f45933302.json	Add renderers italian version (#24882)	docs/list.json	@@ -1396,6 +1396,27 @@ "Skeleton": "api/it/objects/Skeleton", "SkinnedMesh": "api/it/objects/SkinnedMesh", "Sprite": "api/it/objects/Sprite" + }, + + "Renderers": { + "WebGLMultipleRenderTargets": "api/it/renderers/WebGLMultipleRenderTargets", + "WebGLRenderer": "api/it/renderers/WebGLRenderer", + "WebGL1Renderer": "api/it/renderers/WebGL1Renderer", + "WebGLRenderTarget": "api/it/renderers/WebGLRenderTarget", + "WebGL3DRenderTarget": "api/it/renderers/WebGL3DRenderTarget", + "WebGLArrayRenderTarget": "api/it/renderers/WebGLArrayRenderTarget", + "WebGLCubeRenderTarget": "api/it/renderers/WebGLCubeRenderTarget" + }, + + "Renderers / Shaders": { + "ShaderChunk": "api/it/renderers/shaders/ShaderChunk", + "ShaderLib": "api/it/renderers/shaders/ShaderLib", + "UniformsLib": "api/it/renderers/shaders/UniformsLib", + "UniformsUtils": "api/it/renderers/shaders/UniformsUtils" + }, + + "Renderers / WebXR": { + "WebXRManager": "api/it/renderers/webxr/WebXRManager" } } },	true
Other	mrdoob	three.js	2f2c19b280a596eada0adf67ff9e6d5bfcca03ac.json	Add Objects italian version (#24850)	docs/api/it/objects/Bone.html	@@ -0,0 +1,58 @@ +<!DOCTYPE html> +<html lang="it"> + <head> + <meta charset="utf-8" /> + <base href="../../../" /> + <script src="page.js"></script> + <link type="text/css" rel="stylesheet" href="page.css" /> + </head> + <body> + [page:Object3D] → + + <h1>[name]</h1> + + <p class="desc"> + Un osso che è parte di uno [page:Skeleton Scheletro]. Lo scheletro a sua volta viene + utilizzato da [page:SkinnedMesh]. Le ossa sono quasi identiche ad un [page:Object3D] vuoto. + </p> + + <h2>Codice di Esempio</h2> + + <code> + const root = new THREE.Bone(); + const child = new THREE.Bone(); + + root.add( child ); + child.position.y = 5; + </code> + + <h2>Costruttore</h2> + + <h3>[name]( )</h3> + <p> + Crea un nuovo [name]. + </p> + + <h2>Proprietà</h2> + <p>Vedi la classe base [page:Object3D] per le proprietà comuni.</p> + + <h3>[property:Boolean isBone]</h3> + <p> + Flag di sola lettura per verificare se l'oggetto dato è di tipo [name]. + </p> + + + <h3>[property:String type]</h3> + <p>Impostato su 'Bone', può essere utilizzato per trovare tutte le ossa in una scena.</p> + + + <h2>Metodi</h2> + <p>Vedi la classe base [page:Object3D] per i metodi comuni.</p> + + <h2>Source</h2> + + <p> + [link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js] + </p> + </body> +</html>	true
Other	mrdoob	three.js	2f2c19b280a596eada0adf67ff9e6d5bfcca03ac.json	Add Objects italian version (#24850)	docs/api/it/objects/Group.html	@@ -0,0 +1,65 @@ +<!DOCTYPE html> +<html lang="it"> + <head> + <meta charset="utf-8" /> + <base href="../../../" /> + <script src="page.js"></script> + <link type="text/css" rel="stylesheet" href="page.css" /> + </head> + <body> + [page:Object3D] → + + <h1>[name]</h1> + + <p class="desc"> + Questo è quasi identico ad un [page:Object3D Object3D]. + Il suo scopo è rendere sintatticamente più chiaro il lavoro con gruppi di oggetti. + </p> + + <h2>Codice di Esempio</h2> + + <code> + const geometry = new THREE.BoxGeometry( 1, 1, 1 ); + const material = new THREE.MeshBasicMaterial( {color: 0x00ff00} ); + + const cubeA = new THREE.Mesh( geometry, material ); + cubeA.position.set( 100, 100, 0 ); + + const cubeB = new THREE.Mesh( geometry, material ); + cubeB.position.set( -100, -100, 0 ); + + // Crea un gruppo e aggiunge due cubi + // Questi cubi possono essere ruotati / ridimensionati etc come gruppo + const group = new THREE.Group(); + group.add( cubeA ); + group.add( cubeB ); + + scene.add( group ); + </code> + + + <h2>Costruttore</h2> + + <h3>[name]( )</h3> + + <h2>Proprietà</h2> + <p>Vedi la classe base [page:Object3D] per le proprietà comuni.</p> + + <h3>[property:Boolean isGroup]</h3> + <p> + Flag di sola lettura per verificare se l'oggetto dato è di tipo [name]. + </p> + + <h3>[property:String type]</h3> + <p>Una stringa 'Group'. Non deve essere modificata.</p> + + <h2>Metodi</h2> + <p>Vedi la classe base [page:Object3D] per i metodi comuni.</p> + + <h2>Source</h2> + + <p> + [link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js] + </p> + </body> +</html>	true
Other	mrdoob	three.js	2f2c19b280a596eada0adf67ff9e6d5bfcca03ac.json	Add Objects italian version (#24850)	docs/api/it/objects/InstancedMesh.html	@@ -0,0 +1,133 @@ +<!DOCTYPE html> +<html lang="it"> + <head> + <meta charset="utf-8" /> + <base href="../../../" /> + <script src="page.js"></script> + <link type="text/css" rel="stylesheet" href="page.css" /> + </head> + <body> + [page:Mesh] → + + <h1>[name]</h1> + + <p class="desc"> + Una versione speciale di [page:Mesh] con il supporto per il rendering istanziato. Utilizza [name] + se devi renderizzare un grande numero di oggetti con la stessa geometria e materiale ma con + diverse trasformazioni world. L'utilizzo di [name] ti aiuterà a ridurre il numero di + chiamate di disegno e quindi migliorare le prestazioni complessive del rendering nell'applicazione. + </p> + + <h2>Esempi</h2> + + <p> + [example:webgl_instancing_dynamic WebGL / instancing / dynamic]<br /> + [example:webgl_instancing_performance WebGL / instancing / performance]<br /> + [example:webgl_instancing_scatter WebGL / instancing / scatter]<br /> + [example:webgl_instancing_raycast WebGL / instancing / raycast] + </p> + + <h2>Costruttore</h2> + <h3>[name]( [param:BufferGeometry geometry], [param:Material material], [param:Integer count] )</h3> + <p> + [page:BufferGeometry geometry] - un'istanza di [page:BufferGeometry].<br /> + [page:Material material] - un'istanza di [page:Material]. Il valore di default è un nuovo [page:MeshBasicMaterial].<br /> + [page:Integer count] - il numero di istanze.<br /> + </p> + + <h2>Proprietà</h2> + <p>Vedi la classe base [page:Mesh] per le proprietà comuni.</p> + + <h3>[property:Integer count]</h3> + <p> + Il numero di istanze. Il valore `count` passato nel costruttore rappresenta il numero + massimo di istanze di questa mesh. Puoi modificare il numero di istanze in fase di esecuzione ad un valore intero + nell'intervallo [0, count]. + </p> + <p> + Se hai bisogno di più istanze del valore count originale, devi creare una nuova [name]. + </p> + + <h3>[property:InstancedBufferAttribute instanceColor]</h3> + <p> + Rappresenta i colori di tutte le istanze. Il valore predefinito è `null`. + È necessario impostare il suo flag [page:BufferAttribute.needsUpdate needsUpdate] + a true se si modificano i dati di istanza tramite [page:.setColorAt](). + </p> + + <h3>[property:InstancedBufferAttribute instanceMatrix]</h3> + <p> + Rappresenta la trasformazione locale di tutte le istanze. + È necessario impostare il suo flag [page:BufferAttribute.needsUpdate needsUpdate] + a true se si modificano i dati di istanza tramite [page:.setMatrixAt](). + </p> + + <h3>[property:Boolean isInstancedMesh]</h3> + <p> + Flag di sola lettura per verificare se l'oggetto dato è di tipo [name]. + </p> + + <h2>Metodi</h2> + <p>Vedi la classe base [page:Mesh] per i metodi comuni.</p> + + <h3>[method:undefined dispose]()</h3> + <p> + Libera le risorse relative alla GPU allocate da questa istanza. + Chiama questo metodo ogni volta che questa istanza non è più utilizzata nella tua applicazione. + </p> + + <h3>[method:undefined getColorAt]( [param:Integer index], [param:Color color] )</h3> + <p> + [page:Integer index]: L'indice di un'istanza. I valori devono essere nell'intervallo [0, count]. + </p> + <p> + [page:Color color]: Il colore dell'oggetto sarà impostato al colore dell'istanza definita. + </p> + <p> + Ottieni il colore dell'istanza definita. + </p> + + <h3>[method:undefined getMatrixAt]( [param:Integer index], [param:Matrix4 matrix] )</h3> + <p> + [page:Integer index]: L'indice di un'istanza. I valori devono essere nell'intervallo [0, count]. + </p> + <p> + [page:Matrix4 matrix]: Questa matrice 4x4 sarà impostata alla matrice trasformazione locale dell'istanza definita. + </p> + <p> + Ottieni la matrice trasformazione locale dell'istanza definita. + </p> + + <h3>[method:undefined setColorAt]( [param:Integer index], [param:Color color] )</h3> + <p> + [page:Integer index]: L'indice di un'istanza. I valori devono essere nell'intervallo [0, count]. + </p> + <p> + [page:Color color]: Il colore di una singola istanza. + </p> + <p> + Imposta il colore dato all'istanza definita. + Assicurati di impostare [page:.instanceColor][page:BufferAttribute.needsUpdate .needsUpdate] + a true dopo l'aggiornamento di tutti i colori. + </p> + + <h3>[method:undefined setMatrixAt]( [param:Integer index], [param:Matrix4 matrix] )</h3> + <p> + [page:Integer index]: L'indice di un'istanza. I valori devono essere nell'intervallo [0, count]. + </p> + <p> + [page:Matrix4 matrix]: Una matrice 4x4 che rappresenta la trasformazione locale di una singola istanza. + </p> + <p> + Imposta la matrice trasformazione locale data all'istanza definita. + Assicurati di impostare [page:.instanceColor][page:BufferAttribute.needsUpdate .needsUpdate] + a true dopo l'aggiornamento di tutte le matrici. + </p> + + <h2>Source</h2> + + <p> + [link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js] + </p> + </body> +</html>	true
Other	mrdoob	three.js	2f2c19b280a596eada0adf67ff9e6d5bfcca03ac.json	Add Objects italian version (#24850)	docs/api/it/objects/LOD.html	@@ -0,0 +1,128 @@ +<!DOCTYPE html> +<html lang="it"> + <head> + <meta charset="utf-8" /> + <base href="../../../" /> + <script src="page.js"></script> + <link type="text/css" rel="stylesheet" href="page.css" /> + </head> + <body> + [page:Object3D] → + + <h1>[name]</h1> + + <p class="desc"> + Livello di Dettaglio - mostra mesh con più o meno geometria in base alla distanza dalla telecamera.<br /><br /> + + Ogni livello è associato ad un oggetto, e il rendering può essere commutato tra di loro alle distanze specificate. + In genere creeresti, per esempio, tre mesh, una per il lontano (dettaglio basse), una per la gamma media (medio dettaglio) + e una per i primi piani (alto dettaglio). + </p> + + <h2>Codice di Esempio</h2> + + <code> + const lod = new THREE.LOD(); + + // Crea sfere con 3 livelli di dettaglio e crea nuovi livelli LOD per loro + for( let i = 0; i < 3; i++ ) { + + const geometry = new THREE.IcosahedronGeometry( 10, 3 - i ) + + const mesh = new THREE.Mesh( geometry, material ); + + lod.addLevel( mesh, i * 75 ); + + } + + scene.add( lod ); + </code> + + <h2>Esempi</h2> + + <p> + [example:webgl_lod webgl / lod ] + </p> + + <h2>Costruttore</h2> + <h3>[name]( )</h3> + <p> + Crea un nuovo [name]. + </p> + + <h2>Proprietà</h2> + <p>Vedi la classe base [page:Object3D] per le proprietà comuni.</p> + + <h3>[property:Boolean autoUpdate]</h3> + <p> + Indica se l'oggetto LOD viene aggiornato automaticamente dal renderer per frame o no. + Se impostato a false, devi chiamare da solo [page:LOD.update]() nel ciclo di rendering. + Il valore predefinito è true. + </p> + + <h3>[property:Boolean isLOD]</h3> + <p> + Flag di sola lettura per verificare se l'oggetto dato è di tipo [name]. + </p> + + <h3>[property:Array levels]</h3> + <p> + Un array di oggetti [page:Object level].<br /><br /> + + Ogni livello è un oggetto con due proprietà:<br /> + [page:Object3D object] - L'[page:Object3D] da visualizzare a questo livello.<br /> + [page:Float distance] - La distanza alla quale visualizzare questo livello di dettaglio. + </p> + + <h2>Metodi</h2> + <p>Vedi la classe base [page:Object3D] per i metodi comuni.</p> + + <h3>[method:this addLevel]( [param:Object3D object], [param:Float distance] )</h3> + <p> + [page:Object3D object] - L'[page:Object3D] da visualizzare a questo livello.<br /> + [page:Float distance] - La distanza alla quale visualizzare questo livello di dettaglio.<br /><br /> + + Aggiunge una mesh che sarà visualizzata ad una certa distanza e maggiore. In genere, maggiore è + la distanza, minore è il dettaglio sulla mesh. + </p> + + <h3>[method:LOD clone]()</h3> + <p> + Restituisce un clone di questo oggetto LOD e degli oggetti specifici della distanza ad esso associati. + </p> + + + <h3>[method:Integer getCurrentLevel]()</h3> + <p> + Ottiene il livello LOD attivo attualmente. Come indice dell'array dei livelli. + </p> + + <h3>[method:Object3D getObjectForDistance]( [param:Float distance] )</h3> + <p> + Ottiene un riferimento al primo [page:Object3D] (mesh) che è maggiore della [page:Float distance]. + </p> + + <h3>[method:undefined raycast]( [param:Raycaster raycaster], [param:Array intersects] )</h3> + <p> + Ottiene le intersezioni tra un [page:Ray] lanciato a questo LOD. + [page:Raycaster.intersectObject] chiamerà questo metodo. + </p> + + <h3>[method:Object toJSON]( meta )</h3> + <p> + Crea una struttura JSON con i dettagli di questo oggetto LOD. + </p> + + <h3>[method:undefined update]( [param:Camera camera] )</h3> + <p> + Imposta la visibilità di ogni [page:Object3D oggetto] del [page:levels livello] in base + alla distanza dalla [page:Camera telecamera]. + </p> + + <h2>Source</h2> + + <p> + [link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js] + </p> + </body> +</html>	true
Other	mrdoob	three.js	2f2c19b280a596eada0adf67ff9e6d5bfcca03ac.json	Add Objects italian version (#24850)	docs/api/it/objects/Line.html	@@ -0,0 +1,110 @@ +<!DOCTYPE html> +<html lang="it"> + <head> + <meta charset="utf-8" /> + <base href="../../../" /> + <script src="page.js"></script> + <link type="text/css" rel="stylesheet" href="page.css" /> + </head> + <body> + [page:Object3D] → + + <h1>[name]</h1> + + <p class="desc"> + Una linea continua.<br /><br /> + + Questo è quasi lo stesso di [page:LineSegments]; l'unica differenza è che questo viene renderizzato utilizzando + [link:https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/drawElements gl.LINE_STRIP] + invece di [link:https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/drawElements gl.LINES] + + </p> + + <h2>Codice di Esempio</h2> + + <code> + const material = new THREE.LineBasicMaterial({ + color: 0x0000ff + }); + + const points = []; + points.push( new THREE.Vector3( - 10, 0, 0 ) ); + points.push( new THREE.Vector3( 0, 10, 0 ) ); + points.push( new THREE.Vector3( 10, 0, 0 ) ); + + const geometry = new THREE.BufferGeometry().setFromPoints( points ); + + const line = new THREE.Line( geometry, material ); + scene.add( line ); + </code> + + + <h2>Costruttore</h2> + + <h3>[name]( [param:BufferGeometry geometry], [param:Material material] )</h3> + + <p> + [page:BufferGeometry geometry] — vertici che rappresentano il segmento(i) di linea. Il valore predefinito è una nuova [page:BufferGeometry].<br /> + [page:Material material] — materiale per la linea. Il valore predefinito è una nuova [page:LineBasicMaterial].<br /> + </p> + + <h2>Proprietà</h2> + <p>Vedi la classe base [page:Object3D] per le proprietà comuni.</p> + + <h3>[property:BufferGeometry geometry]</h3> + <p>Vertici che rappresentano il segmento(i) di linea.</p> + + <h3>[property:Boolean isLine]</h3> + <p> + Flag di sola lettura per verificare se l'oggetto dato è di tipo [name]. + </p> + + <h3>[property:Material material]</h3> + <p>Materiale per la linea.</p> + + <h3>[property:Array morphTargetInfluences]</h3> + <p> + Un array di pesi solitamente da 0 a 1 che specifica la quantità di morph applicata. + Non definito per impostazione predefinita, ma reimpostato su un array vuoto da [page:.updateMorphTargets](). + </p> + + <h3>[property:Object morphTargetDictionary]</h3> + <p> + Un dizionario di morphTargets basato sulla proprietà morphTarget.name. + Non definito per impostazione predefinita, ma ricompilato [page:.updateMorphTargets](). + </p> + + <h2>Metodi</h2> + <p>Vedi la classe base [page:Object3D] per i metodi comuni.</p> + + <h3>[method:this computeLineDistances]()</h3> + <p> + Calcola un array di valori di distanza necessari per [page:LineDashedMaterial]. + Per ogni vertice nella geometria, il metodo calcola la lunghezza cumulativa dal punto + corrente fino all'inizio della linea. + </p> + + <h3>[method:undefined raycast]( [param:Raycaster raycaster], [param:Array intersects] )</h3> + <p> + Ottiene le intersezioni tra un [page:Ray] lanciato e questa linea. + [page:Raycaster.intersectObject] chiamerà questo metodo. + </p> + + <h3>[method:Line clone]()</h3> + <p> + Restituisce un clone di questo oggetto Line e i suoi discendenti. + </p> + + <h3>[method:undefined updateMorphTargets]()</h3> + <p> + Aggiorna i morphTargets in modo che non abbiano alcuna influenza sull'oggetto. + Reimposta le proprietà [page:.morphTargetInfluences] e [page:.morphTargetDictionary]. + </p> + + <h2>Source</h2> + + <p> + [link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js] + </p> + </body> +</html>	true
Other	mrdoob	three.js	2f2c19b280a596eada0adf67ff9e6d5bfcca03ac.json	Add Objects italian version (#24850)	docs/api/it/objects/LineLoop.html	@@ -0,0 +1,52 @@ +<!DOCTYPE html> +<html lang="it"> + <head> + <meta charset="utf-8" /> + <base href="../../../" /> + <script src="page.js"></script> + <link type="text/css" rel="stylesheet" href="page.css" /> + </head> + <body> + [page:Object3D] → [page:Line] → + + <h1>[name]</h1> + + <p class="desc"> + Una linea continua che si ricollega alla partenza.<br /><br /> + + Questo è quasi lo stesso di [page:Line]; l'unica differenza è che viene + renderizzato utilizzando + [link:https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/drawElements gl.LINE_LOOP] + invece di [link:https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/drawElements gl.LINE_STRIP], + il quale disegna una linea retta al vertice successivo, e ricollega l'ultimo vertice al primo. + </p> + + + <h2>Costruttore</h2> + + <h3>[name]( [param:BufferGeometry geometry], [param:Material material] )</h3> + + <p> + [page:BufferGeometry geometry] — Elenco di vertici che rappresentano i punti del ciclo della linea.<br /> + [page:Material material] — Materiale per la linea. Il valore predefinito è [page:LineBasicMaterial LineBasicMaterial]. + </p> + + <h2>Proprietà</h2> + <p>Vedi la classe base [page:Line] per le proprietà comuni.</p> + + <h3>[property:Boolean isLineLoop]</h3> + <p> + Flag di sola lettura per verificare se l'oggetto dato è di tipo [name]. + </p> + + + <h2>Metodi</h2> + <p>Vedi la classe base [page:Line] per i metodi comuni.</p> + + <h2>Source</h2> + + <p> + [link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js] + </p> + </body> +</html>	true
Other	mrdoob	three.js	2f2c19b280a596eada0adf67ff9e6d5bfcca03ac.json	Add Objects italian version (#24850)	docs/api/it/objects/LineSegments.html	@@ -0,0 +1,51 @@ +<!DOCTYPE html> +<html lang="it"> + <head> + <meta charset="utf-8" /> + <base href="../../../" /> + <script src="page.js"></script> + <link type="text/css" rel="stylesheet" href="page.css" /> + </head> + <body> + [page:Object3D] → [page:Line] → + + <h1>[name]</h1> + + <p class="desc"> + Una serie di linee tracciate tra coppie di vertici.<br /><br /> + + Questo è quasi lo stesso di [page:Line]; l'unica differenza è che viene + renderizzato utilizzando + [link:https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/drawElements gl.LINES] + invece di [link:https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/drawElements gl.LINE_STRIP]. + </p> + + + <h2>Costruttore</h2> + + <h3>[name]( [param:BufferGeometry geometry], [param:Material material] )</h3> + + <p> + [page:BufferGeometry geometry] — Coppia(e) di vertici che rappresentano ogni segmento(i) di linea.<br /> + [page:Material material] — Materiale per la linea. Il valore predefinito è [page:LineBasicMaterial LineBasicMaterial]. + </p> + + <h2>Proprietà</h2> + <p>Vedi la classe base [page:Line] per le proprietà comuni.</p> + + <h3>[property:Boolean isLineSegments]</h3> + <p> + Flag di sola lettura per verificare se l'oggetto dato è di tipo [name]. + </p> + + + <h2>Metodi</h2> + <p>Vedi la classe base [page:Line] per i metodi comuni.</p> + + <h2>Source</h2> + + <p> + [link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js] + </p> + </body> +</html>	true
Other	mrdoob	three.js	2f2c19b280a596eada0adf67ff9e6d5bfcca03ac.json	Add Objects italian version (#24850)	docs/api/it/objects/Mesh.html	@@ -0,0 +1,93 @@ +<!DOCTYPE html> +<html lang="it"> + <head> + <meta charset="utf-8" /> + <base href="../../../" /> + <script src="page.js"></script> + <link type="text/css" rel="stylesheet" href="page.css" /> + </head> + <body> + [page:Object3D] → + + <h1>[name]</h1> + + <p class="desc"> + Una classe che rappresenta oggetti basati su [link:https://en.wikipedia.org/wiki/Polygon_mesh mesh poligonali] triangolari. + Serve anche come base per altre classi come [page:SkinnedMesh]. + </p> + + <h2>Codice di Esempio</h2> + + <code> + const geometry = new THREE.BoxGeometry( 1, 1, 1 ); + const material = new THREE.MeshBasicMaterial( { color: 0xffff00 } ); + const mesh = new THREE.Mesh( geometry, material ); + scene.add( mesh ); + </code> + + <h2>Costruttore</h2> + + <h3>[name]( [param:BufferGeometry geometry], [param:Material material] )</h3> + <p> + [page:BufferGeometry geometry] — (opzionale) un'istanza di [page:BufferGeometry]. Il valore predefinito è una nuova [page:BufferGeometry].<br /> + [page:Material material] — (opzionale) un singolo o un array di [page:Material Material]. Il valore predefinito è una nuova [page:MeshBasicMaterial]. + </p> + + <h2>Proprietà</h2> + <p>Vedi la classe base [page:Object3D] per le proprietà comuni.</p> + + <h3>[property:BufferGeometry geometry]</h3> + <p> + Un'istanza di [page:BufferGeometry] (o classi derivate), che definisce la struttura dell'oggetto. + </p> + + <h3>[property:Boolean isMesh]</h3> + <p> + Flag di sola lettura per verificare se l'oggetto dato è di tipo [name]. + </p> + + <h3>[property:Material material]</h3> + <p> + Un'istanza di materiale derivata dalla classe base [page:Material] o un array di materiali, che definisce + l'aspetto dell'oggetto. Il valore predefinito è [page:MeshBasicMaterial]. + </p> + + <h3>[property:Array morphTargetInfluences]</h3> + <p> + Un array di pesi solitamente da 0 a 1 che specifica la quantità di morph applicata. + Non definito per impostazione predefinita, ma reimpostato su un array vuoto da [page:Mesh.updateMorphTargets updateMorphTargets]. + </p> + + <h3>[property:Object morphTargetDictionary]</h3> + <p> + Un dizionario di morphTargets basato sulla proprietà morphTarget.name. + Non definito per impostazione predefinita, ma ricompilato [page:Mesh.updateMorphTargets updateMorphTargets]. + </p> + + <h2>Metodi</h2> + <p>Vedi la classe base [page:Object3D] per i metodi comuni.</p> + + <h3>[method:Mesh clone]()</h3> + <p>Restituisce un clone di questo oggetto [name] e i suoi discendenti.</p> + + <h3>[method:undefined raycast]( [param:Raycaster raycaster], [param:Array intersects] )</h3> + <p> + Ottiene le intersezioni tra un raggio lanciato e questa mesh. + [page:Raycaster.intersectObject] chiamerà questo metodo, ma i risultati non saranno ordinati. + </p> + + <h3>[method:undefined updateMorphTargets]()</h3> + <p> + Aggiorna i morphTargets in modo che non abbiano influenza sull'oggetto. Reimposta le proprietà + [page:Mesh.morphTargetInfluences morphTargetInfluences] e + [page:Mesh.morphTargetDictionary morphTargetDictionary]. + </p> + + + <h2>Source</h2> + + <p> + [link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js] + </p> + </body> +</html>	true
Other	mrdoob	three.js	2f2c19b280a596eada0adf67ff9e6d5bfcca03ac.json	Add Objects italian version (#24850)	docs/api/it/objects/Points.html	@@ -0,0 +1,88 @@ +<!DOCTYPE html> +<html lang="it"> + <head> + <meta charset="utf-8" /> + <base href="../../../" /> + <script src="page.js"></script> + <link type="text/css" rel="stylesheet" href="page.css" /> + </head> + <body> + [page:Object3D] → + + <h1>[name]</h1> + + <p class="desc"> + Una classe per visualizzare punti. + I punti sono renderizzati dal [page:WebGLRenderer] utilizzando + [link:https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/drawElements gl.POINTS]. + </p> + + + <h2>Costruttore</h2> + + <h3>[name]( [param:BufferGeometry geometry], [param:Material material] )</h3> + <p> + [page:BufferGeometry geometry] — (opzionale) un'istanza di [page:BufferGeometry]. Il valore predefinito è una nuova [page:BufferGeometry].<br /> + [page:Material material] — (opzionale) un [page:Material Materiale]. Il valore predefinito è una nuova [page:PointsMaterial]. + </p> + + <h2>Proprietà</h2> + <p>Vedi la classe base [page:Object3D] per le proprietà comuni.</p> + + <h3>[property:BufferGeometry geometry]</h3> + <p> + Un'istanza di [page:BufferGeometry] (o classi derivate), che definisce la struttura dell'oggetto. + </p> + + <h3>[property:Boolean isPoints]</h3> + <p> + Flag di sola lettura per verificare se l'oggetto dato è di tipo [name]. + </p> + + <h3>[property:Material material]</h3> + <p> + Un'istanza di [page:Material], che definisce + l'aspetto dell'oggetto. Il valore predefinito è [page:PointsMaterial]. + </p> + + <h3>[property:Array morphTargetInfluences]</h3> + <p> + Un array di pesi solitamente da 0 a 1 che specifica la quantità di morph applicata. + Non definito per impostazione predefinita, ma reimpostato su un array vuoto da [page:Points.updateMorphTargets updateMorphTargets]. + </p> + + <h3>[property:Object morphTargetDictionary]</h3> + <p> + Un dizionario di morphTargets basato sulla proprietà morphTarget.name. + Non definito per impostazione predefinita, ma ricompilato [page:Points.updateMorphTargets updateMorphTargets]. + </p> + + <h2>Metodi</h2> + <p>Vedi la classe base [page:Object3D] per i metodi comuni.</p> + + <h3>[method:undefined raycast]( [param:Raycaster raycaster], [param:Array intersects] )</h3> + <p> + Ottiene le intersezioni tra un raggio lanciato e questo Points. + [page:Raycaster.intersectObject] chiamerà questo metodo, ma i risultati non saranno ordinati. + </p> + + <h3>[method:Points clone]()</h3> + <p> + Restituisce un clone di questo oggetto [name] e i suoi discendenti.</p> + </p> + + <h3>[method:undefined updateMorphTargets]()</h3> + <p> + Aggiorna i morphTargets in modo che non abbiano influenza sull'oggetto. Reimposta le proprietà + [page:Points.morphTargetInfluences morphTargetInfluences] e + [page:Points.morphTargetDictionary morphTargetDictionary]. + </p> + + <h2>Source</h2> + + <p> + [link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js] + </p> + + </body> +</html>	true
Other	mrdoob	three.js	2f2c19b280a596eada0adf67ff9e6d5bfcca03ac.json	Add Objects italian version (#24850)	docs/api/it/objects/Skeleton.html	@@ -0,0 +1,129 @@ +<!DOCTYPE html> +<html lang="it"> + <head> + <meta charset="utf-8" /> + <base href="../../../" /> + <script src="page.js"></script> + <link type="text/css" rel="stylesheet" href="page.css" /> + </head> + <body> + + <h1>[name]</h1> + + <p class="desc"> + Utilizza un array di [page:Bone ossa] per creare uno scheletro che può essere utilizzato da una + [page:SkinnedMesh]. + </p> + + <h2>Codice di Esempio</h2> + <code> + // Crea un semplice "braccio" + + const bones = []; + + const shoulder = new THREE.Bone(); + const elbow = new THREE.Bone(); + const hand = new THREE.Bone(); + + shoulder.add( elbow ); + elbow.add( hand ); + + bones.push( shoulder ); + bones.push( elbow ); + bones.push( hand ); + + shoulder.position.y = -5; + elbow.position.y = 0; + hand.position.y = 5; + + const armSkeleton = new THREE.Skeleton( bones ); + </code> + + <p> + Vedi la pagina [page:SkinnedMesh] per un esempio dell'utilizzo con [page:BufferGeometry]. + </p> + + <h2>Costruttore</h2> + + + <h3>[name]( [param:Array bones], [param:Array boneInverses] )</h3> + <p> + [page:Array bones] - L'array di [page:Bone ossa]. Il valore predefinito è un array vuoto.<br/> + [page:Array boneInverses] - (opzionale) Un array di [page:Matrix4 Matrix4].<br /><br /> + + Crea un nuovo [name]. + </p> + + + <h2>Proprietà</h2> + + <h3>[property:Array bones]</h3> + <p> + L'array di [page:Bone ossa]. Si noti che questa è una copia dell'array originale, non un riferimento, + quindi puoi modificare l'array originale senza che ci siano effetti su questo. + </p> + + <h3>[property:Array boneInverses]</h3> + <p> + Un array di [page:Matrix4 Matrix4] che rappresenta l'inverso della [page:Matrix4 matrixWorld] + delle singole ossa. + </p> + + <h3>[property:Float32Array boneMatrices]</h3> + <p> + Il buffer dell'array che contiene i dati dell'osso quando si utilizza una texture di vertice. + </p> + + <h3>[property:DataTexture boneTexture]</h3> + <p> + Il [page:DataTexture] che contiene i dati dell'osso quando si utilizza una texture di vertice. + </p> + + <h3>[property:Integer boneTextureSize]</h3> + <p> + La dimensione del [page:.boneTexture]. + </p> + + <h2>Metodi</h2> + + <h3>[method:Skeleton clone]()</h3> + <p> + Restituisce un clone di questo oggetto Skeleton. + </p> + + <h3>[method:undefined calculateInverses]()</h3> + <p>Genera l'array [page:.boneInverses boneInverses] se non viene fornito nel costruttore.</p> + + <h3>[method:this computeBoneTexture]()</h3> + <p>Calcola un'istanza di [page:DataTexture] in moda da passare i dati dell'osso in modo più efficiente allo shader. + La texture viene assegnata a [page:.boneTexture boneTexture].</p> + + <h3>[method:undefined pose]()</h3> + <p>Restituisce lo scheletro nella posa di base.</p> + + <h3>[method:undefined update]()</h3> + <p> + Aggiorna [page:Float32Array boneMatrices] e [page:DataTexture boneTexture] dopo che le ossa sono state modificate. + Questo viene chiamato automaticamente dal [page:WebGLRenderer] se lo scheletro viene utilizzato con una [page:SkinnedMesh]. + </p> + + <h3>[method:Bone getBoneByName]( [param:String name] )</h3> + <p> + name -- Stringa da abbinare alla proprietà .name di Bone. <br /><br /> + + Cerca nell'array osseo dello scheletro e restituisce il primo con un nome corrispondente.<br /> + </p> + + <h3>[method:undefined dispose]()</h3> + <p> + Libera le risorse relative alla GPU allocate da questa istanza. Chiama questo metodo ogni + volta che questa istanza non viene più utilizzata nella tua app. + </p> + + <h2>Source</h2> + + <p> + [link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js] + </p> + </body> +</html>	true
Other	mrdoob	three.js	2f2c19b280a596eada0adf67ff9e6d5bfcca03ac.json	Add Objects italian version (#24850)	docs/api/it/objects/SkinnedMesh.html	@@ -0,0 +1,174 @@ +<!DOCTYPE html> +<html lang="it"> + <head> + <meta charset="utf-8" /> + <base href="../../../" /> + <script src="page.js"></script> + <link type="text/css" rel="stylesheet" href="page.css" /> + </head> + <body> + [page:Object3D] → [page:Mesh] → + + <h1>[name]</h1> + + <p class="desc"> + Una mesh che ha uno [page:Skeleton scheletro] con [page:Bone ossa] che può essere + utilizzata per animare i vertici della geometria.<br /><br /> + + [name] può essere utilizzata solo con WebGL 2. Con WebGL 1 è necessario il supporto delle texture del vertice + e `OES_texture_float`. + </p> + + <iframe id="scene" src="scenes/bones-browser.html"></iframe> + + <script> + + // iOS iframe auto-resize workaround + + if ( /(iPad\|iPhone\|iPod)/g.test( navigator.userAgent ) ) { + + const scene = document.getElementById( 'scene' ); + + scene.style.width = getComputedStyle( scene ).width; + scene.style.height = getComputedStyle( scene ).height; + scene.setAttribute( 'scrolling', 'no' ); + + } + + </script> + + <h2>Codice di Esempio</h2> + + <code> + const geometry = new THREE.CylinderGeometry( 5, 5, 5, 5, 15, 5, 30 ); + + // crea manualmente gli indici della pelle e i pesi della pelle + // (tipicamente un loader leggerebbe questi dati da un modello 3D per te) + + const position = geometry.attributes.position; + + const vertex = new THREE.Vector3(); + + const skinIndices = []; + const skinWeights = []; + + for ( let i = 0; i < position.count; i ++ ) { + + vertex.fromBufferAttribute( position, i ); + + // calcola skinIndex e skinWeight in base ad alcuni dati di configurazione + + const y = ( vertex.y + sizing.halfHeight ); + + const skinIndex = Math.floor( y / sizing.segmentHeight ); + const skinWeight = ( y % sizing.segmentHeight ) / sizing.segmentHeight; + + skinIndices.push( skinIndex, skinIndex + 1, 0, 0 ); + skinWeights.push( 1 - skinWeight, skinWeight, 0, 0 ); + + } + + geometry.setAttribute( 'skinIndex', new THREE.Uint16BufferAttribute( skinIndices, 4 ) ); + geometry.setAttribute( 'skinWeight', new THREE.Float32BufferAttribute( skinWeights, 4 ) ); + + // crea skinned mesh e skeleton + + const mesh = new THREE.SkinnedMesh( geometry, material ); + const skeleton = new THREE.Skeleton( bones ); + + // vedi esempio da THREE.Skeleton + + const rootBone = skeleton.bones[ 0 ]; + mesh.add( rootBone ); + + // lega lo scheletro alla mesh + + mesh.bind( skeleton ); + + // muove le ossa e manipola il modello + + skeleton.bones[ 0 ].rotation.x = -0.1; + skeleton.bones[ 1 ].rotation.x = 0.2; + </code> + + <h2>Costruttore</h2> + <h3>[name]( [param:BufferGeometry geometry], [param:Material material] )</h3> + <p> + [page:BufferGeometry geometry] - un'istanza di [page:BufferGeometry].<br /> + [page:Material material] - (opzionale) un'istanza di [page:Material]. Il valore predefinito è un nuovo [page:MeshBasicMaterial]. + </p> + + <h2>Proprietà</h2> + <p>Vedi la classe base [page:Mesh] per le proprietà comuni.</p> + + <h3>[property:String bindMode]</h3> + <p> + O "attached" o "detached". "attached" utilizza la proprietà [page:SkinnedMesh.matrixWorld] + per la matrice di trasformazione delle ossa. "detached" utilizza [page:SkinnedMesh.bindMatrix]. Il valore predefinito è "attached". + </p> + + <h3>[property:Matrix4 bindMatrix]</h3> + <p> + La matrice di base che viene utilizzata per le trasformazioni ossee vincolate. + </p> + + <h3>[property:Matrix4 bindMatrixInverse]</h3> + <p> + La matrice di base che viene utilizzata per reimpostare le trasformazioni ossee vincolate. + </p> + + <h3>[property:Boolean isSkinnedMesh]</h3> + <p> + Flag di sola lettura per verificare se l'oggetto dato è di tipo [name]. + </p> + + <h3>[property:Skeleton skeleton]</h3> + <p> + [page:Skeleton] che rappresenta la gerarchia ossea della skinned mesh. + </p> + + <h2>Metodi</h2> + <p>Vedi la classe base [page:Mesh] per i metodi comuni.</p> + + <h3>[method:undefined bind]( [param:Skeleton skeleton], [param:Matrix4 bindMatrix] )</h3> + <p> + [page:Skeleton skeleton] - [page:Skeleton] creato da un albero di [page:Bone Bones].<br/> + [page:Matrix4 bindMatrix] - [page:Matrix4] che rappresenta la trasformazione base dello scheletro.<br /><br /> + + Lega uno scheletro alla skinned mesh. Il bindMatrix viene salvato nella proprietà .bindMatrix + e il .bindMatrixInverse viene calcolato. + </p> + + <h3>[method:SkinnedMesh clone]()</h3> + <p> + Questo metodo attualmente non clona correttamente un'istanza di [name]. Si prega di utilizzare [page:SkeletonUtils.clone]() nel frattempo. + </p> + + <h3>[method:undefined normalizeSkinWeights]()</h3> + <p> + Normalizza i pesi della skin. + </p> + + <h3>[method:undefined pose]()</h3> + <p> + Questo metodo imposta la skinned mesh nella posa di riposo (reimposta la posa). + </p> + + <h3>[method:Vector3 boneTransform]( [param:Integer index], [param:Vector3 target] )</h3> + <p> + Calcola la posizione del vertice in corrispondenza dell'indice specificato rispetto alle attuali trasformazioni ossee. + Il vettore target deve essere inizializzato con le coordinate del vertice prima della trasformazione: + <code> +const target = new THREE.Vector3(); +target.fromBufferAttribute( mesh.geometry.attributes.position, index ); +mesh.boneTransform( index, target ); + </code> + </p> + + <h2>Source</h2> + + <p> + [link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js] + </p> + </body> +</html>	true
Other	mrdoob	three.js	2f2c19b280a596eada0adf67ff9e6d5bfcca03ac.json	Add Objects italian version (#24850)	docs/api/it/objects/Sprite.html	@@ -0,0 +1,89 @@ +<!DOCTYPE html> +<html lang="it"> + <head> + <meta charset="utf-8" /> + <base href="../../../" /> + <script src="page.js"></script> + <link type="text/css" rel="stylesheet" href="page.css" /> + </head> + <body> + [page:Object3D] → + + <h1>[name]</h1> + + <p class="desc"> + Una sprite è un piano che è sempre rivolto verso la telecamera, generalmente con + una texture parzialmente trasparente applicata.<br /><br /> + + Le sprite non proiettano ombre, impostare <code>castShadow = true</code> non avrà alcun effetto. + </p> + + <h2>Codice di Esempio</h2> + + <code> + const map = new THREE.TextureLoader().load( 'sprite.png' ); + const material = new THREE.SpriteMaterial( { map: map } ); + + const sprite = new THREE.Sprite( material ); + scene.add( sprite ); + </code> + + <h2>Costruttore</h2> + + <h3>[name]( [param:Material material] )</h3> + <p> + [page:Material material] - (opzionale) un'istanza di [page:SpriteMaterial]. Il valore predefinito è una [page:SpriteMaterial] bianca.<br /><br /> + + Crea una nuova [name]. + </p> + + <h2>Proprietà</h2> + <p>Vedi la classe base [page:Object3D] per le proprietà comuni.</p> + + <h3>[property:Boolean isSprite]</h3> + <p> + Flag di sola lettura per verificare se l'oggetto dato è di tipo [name]. + </p> + + + <h3>[property:SpriteMaterial material]</h3> + <p> + Un'istanza di [page:SpriteMaterial], che definisce l'aspetto dell'oggetto. + Il valore predefinito è una [page:SpriteMaterial] bianca. + </p> + + + <h3>[property:Vector2 center]</h3> + <p> + Il punto di ancoraggio della sprite, e il punto attorno al quale ruota la sprite. Un valore di (0.5, 0.5) + corrisponde al punto medio della sprite. Un valore di (0, 0) corrisponde all'angolo inferiore sinistro della sprite. + Il valore predefinito è (0.5, 0.5). + </p> + + <h2>Metodi</h2> + <p>Vedi la classe base [page:Object3D] per i metodi comuni.</p> + + <h3>[method:Sprite clone]()</h3> + <p> + Restituisce un clone di questo oggetto Sprite e i suoi discendenti. + </p> + + <h3>[method:this copy]( [param:Sprite sprite] )</h3> + <p> + Copia le proprietà della sprite passata in questa. + </p> + + <h3>[method:undefined raycast]( [param:Raycaster raycaster], [param:Array intersects] )</h3> + <p> + Ottiene le intersezioni tra un raggio lanciato e questa sprite. [page:Raycaster.intersectObject]() chiamerà questo metodo. + Il raycaster deve essere inizializzato chiamando [page:Raycaster.setFromCamera]() prima di eseguire il raycast contro le sprite. + </p> + + + <h2>Source</h2> + + <p> + [link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js] + </p> + </body> +</html>	true
Other	mrdoob	three.js	2f2c19b280a596eada0adf67ff9e6d5bfcca03ac.json	Add Objects italian version (#24850)	docs/list.json	@@ -1381,6 +1381,21 @@ "DiscreteInterpolant": "api/it/math/interpolants/DiscreteInterpolant", "LinearInterpolant": "api/it/math/interpolants/LinearInterpolant", "QuaternionLinearInterpolant": "api/it/math/interpolants/QuaternionLinearInterpolant" + }, + + "Oggetti": { + "Bone": "api/it/objects/Bone", + "Group": "api/it/objects/Group", + "InstancedMesh": "api/it/objects/InstancedMesh", + "Line": "api/it/objects/Line", + "LineLoop": "api/it/objects/LineLoop", + "LineSegments": "api/it/objects/LineSegments", + "LOD": "api/it/objects/LOD", + "Mesh": "api/it/objects/Mesh", + "Points": "api/it/objects/Points", + "Skeleton": "api/it/objects/Skeleton", + "SkinnedMesh": "api/it/objects/SkinnedMesh", + "Sprite": "api/it/objects/Sprite" } } },	true
Other	mrdoob	three.js	d95e790fb089cf7ba34e1a83a2d3695c75748e58.json	improve mouse drag interaction (#24844)	examples/webgpu_equirectangular.html	@@ -72,8 +72,8 @@ controls = new OrbitControls( camera, renderer.domElement ); controls.autoRotate = true; - controls.minDistance = 2; - controls.maxDistance = 10; + controls.rotateSpeed = - 0.125; // negative, to track mouse pointer + controls.autoRotateSpeed = 1.0; window.addEventListener( 'resize', onWindowResize );	false
Other	mrdoob	three.js	305c488ad56bb21e49cbd0a8651f05b766979206.json	kill double `.normalize` (#22503)	src/extras/core/Curve.js	@@ -277,7 +277,6 @@ class Curve { const u = i / segments; tangents[ i ] = this.getTangentAt( u, new Vector3() ); - tangents[ i ].normalize(); }	false
Other	mrdoob	three.js	e30436d09281e940b7bcef9a957e2ee645438dc0.json	Specify the recursive flag (#22500)	examples/js/interactive/InteractiveGroup.js	@@ -24,7 +24,7 @@ _pointer.x = event.clientX / element.clientWidth * 2 - 1; _pointer.y = - ( event.clientY / element.clientHeight ) * 2 + 1; raycaster.setFromCamera( _pointer, camera ); - const intersects = raycaster.intersectObjects( scope.children ); + const intersects = raycaster.intersectObjects( scope.children, false ); if ( intersects.length > 0 ) { @@ -63,7 +63,7 @@ tempMatrix.identity().extractRotation( controller.matrixWorld ); raycaster.ray.origin.setFromMatrixPosition( controller.matrixWorld ); raycaster.ray.direction.set( 0, 0, - 1 ).applyMatrix4( tempMatrix ); - const intersections = raycaster.intersectObjects( scope.children ); + const intersections = raycaster.intersectObjects( scope.children, false ); if ( intersections.length > 0 ) {	true
Other	mrdoob	three.js	e30436d09281e940b7bcef9a957e2ee645438dc0.json	Specify the recursive flag (#22500)	examples/jsm/interactive/InteractiveGroup.js	@@ -32,7 +32,7 @@ class InteractiveGroup extends Group { raycaster.setFromCamera( _pointer, camera ); - const intersects = raycaster.intersectObjects( scope.children ); + const intersects = raycaster.intersectObjects( scope.children, false ); if ( intersects.length > 0 ) { @@ -77,7 +77,7 @@ class InteractiveGroup extends Group { raycaster.ray.origin.setFromMatrixPosition( controller.matrixWorld ); raycaster.ray.direction.set( 0, 0, - 1 ).applyMatrix4( tempMatrix ); - const intersections = raycaster.intersectObjects( scope.children ); + const intersections = raycaster.intersectObjects( scope.children, false ); if ( intersections.length > 0 ) {	true
Other	mrdoob	three.js	e30436d09281e940b7bcef9a957e2ee645438dc0.json	Specify the recursive flag (#22500)	examples/jsm/webxr/OculusHandPointerModel.js	@@ -343,7 +343,7 @@ class OculusHandPointerModel extends THREE.Object3D { if ( this.raycaster ) { - return this.raycaster.intersectObjects( objects ); + return this.raycaster.intersectObjects( objects, false ); } @@ -353,7 +353,7 @@ class OculusHandPointerModel extends THREE.Object3D { if ( this.raycaster && ! this.attached ) { - const intersections = this.raycaster.intersectObjects( objects ); + const intersections = this.raycaster.intersectObjects( objects, false ); const direction = new THREE.Vector3( 0, 0, - 1 ); if ( intersections.length > 0 ) {	true
Other	mrdoob	three.js	e30436d09281e940b7bcef9a957e2ee645438dc0.json	Specify the recursive flag (#22500)	examples/misc_controls_pointerlock.html	@@ -279,7 +279,7 @@ raycaster.ray.origin.copy( controls.getObject().position ); raycaster.ray.origin.y -= 10; - const intersections = raycaster.intersectObjects( objects ); + const intersections = raycaster.intersectObjects( objects, false ); const onObject = intersections.length > 0;	true
Other	mrdoob	three.js	e30436d09281e940b7bcef9a957e2ee645438dc0.json	Specify the recursive flag (#22500)	examples/webgl_camera_cinematic.html	@@ -188,7 +188,7 @@ raycaster.setFromCamera( mouse, camera ); - const intersects = raycaster.intersectObjects( scene.children ); + const intersects = raycaster.intersectObjects( scene.children, false ); if ( intersects.length > 0 ) {	true
Other	mrdoob	three.js	e30436d09281e940b7bcef9a957e2ee645438dc0.json	Specify the recursive flag (#22500)	examples/webgl_geometry_spline_editor.html	@@ -371,7 +371,7 @@ raycaster.setFromCamera( pointer, camera ); - const intersects = raycaster.intersectObjects( splineHelperObjects ); + const intersects = raycaster.intersectObjects( splineHelperObjects, false ); if ( intersects.length > 0 ) {	true
Other	mrdoob	three.js	e30436d09281e940b7bcef9a957e2ee645438dc0.json	Specify the recursive flag (#22500)	examples/webgl_interactive_cubes.html	@@ -135,7 +135,7 @@ raycaster.setFromCamera( pointer, camera ); - const intersects = raycaster.intersectObjects( scene.children ); + const intersects = raycaster.intersectObjects( scene.children, false ); if ( intersects.length > 0 ) {	true
Other	mrdoob	three.js	e30436d09281e940b7bcef9a957e2ee645438dc0.json	Specify the recursive flag (#22500)	examples/webgl_interactive_cubes_ortho.html	@@ -143,7 +143,7 @@ raycaster.setFromCamera( pointer, camera ); - const intersects = raycaster.intersectObjects( scene.children ); + const intersects = raycaster.intersectObjects( scene.children, false ); if ( intersects.length > 0 ) {	true
Other	mrdoob	three.js	e30436d09281e940b7bcef9a957e2ee645438dc0.json	Specify the recursive flag (#22500)	examples/webgl_interactive_raycasting_points.html	@@ -245,7 +245,7 @@ raycaster.setFromCamera( pointer, camera ); - const intersections = raycaster.intersectObjects( pointclouds ); + const intersections = raycaster.intersectObjects( pointclouds, false ); intersection = ( intersections.length ) > 0 ? intersections[ 0 ] : null; if ( toggle > 0.02 && intersection !== null ) {	true
Other	mrdoob	three.js	e30436d09281e940b7bcef9a957e2ee645438dc0.json	Specify the recursive flag (#22500)	examples/webgl_interactive_voxelpainter.html	@@ -117,7 +117,7 @@ raycaster.setFromCamera( pointer, camera ); - const intersects = raycaster.intersectObjects( objects ); + const intersects = raycaster.intersectObjects( objects, false ); if ( intersects.length > 0 ) { @@ -138,7 +138,7 @@ raycaster.setFromCamera( pointer, camera ); - const intersects = raycaster.intersectObjects( objects ); + const intersects = raycaster.intersectObjects( objects, false ); if ( intersects.length > 0 ) {	true
Other	mrdoob	three.js	e30436d09281e940b7bcef9a957e2ee645438dc0.json	Specify the recursive flag (#22500)	examples/webgl_loader_ifc.html	@@ -82,7 +82,7 @@ const raycaster = new THREE.Raycaster(); raycaster.setFromCamera( mouse, camera ); - const intersected = raycaster.intersectObjects( scene.children ); + const intersected = raycaster.intersectObjects( scene.children, false ); if ( intersected.length ) { const found = intersected[ 0 ];	true
Other	mrdoob	three.js	e30436d09281e940b7bcef9a957e2ee645438dc0.json	Specify the recursive flag (#22500)	examples/webgl_modifier_curve.html	@@ -179,7 +179,7 @@ rayCaster.setFromCamera( mouse, camera ); action = ACTION_NONE; - const intersects = rayCaster.intersectObjects( curveHandles ); + const intersects = rayCaster.intersectObjects( curveHandles, false ); if ( intersects.length ) { const target = intersects[ 0 ].object;	true
Other	mrdoob	three.js	e30436d09281e940b7bcef9a957e2ee645438dc0.json	Specify the recursive flag (#22500)	examples/webgl_modifier_curve_instanced.html	@@ -209,7 +209,7 @@ rayCaster.setFromCamera( mouse, camera ); action = ACTION_NONE; - const intersects = rayCaster.intersectObjects( curveHandles ); + const intersects = rayCaster.intersectObjects( curveHandles, false ); if ( intersects.length ) { const target = intersects[ 0 ].object;	true
Other	mrdoob	three.js	e30436d09281e940b7bcef9a957e2ee645438dc0.json	Specify the recursive flag (#22500)	examples/webgl_postprocessing_ssrr.html	@@ -243,7 +243,7 @@ raycaster.setFromCamera( mouse, camera ); - const intersect = raycaster.intersectObjects( objects )[ 0 ]; + const intersect = raycaster.intersectObjects( objects, false )[ 0 ]; if ( intersect ) {	true
Other	mrdoob	three.js	e30436d09281e940b7bcef9a957e2ee645438dc0.json	Specify the recursive flag (#22500)	examples/webgl_postprocessing_unreal_bloom_selective.html	@@ -184,7 +184,7 @@ mouse.y = - ( event.clientY / window.innerHeight ) * 2 + 1; raycaster.setFromCamera( mouse, camera ); - const intersects = raycaster.intersectObjects( scene.children ); + const intersects = raycaster.intersectObjects( scene.children, false ); if ( intersects.length > 0 ) { const object = intersects[ 0 ].object;	true
Other	mrdoob	three.js	e30436d09281e940b7bcef9a957e2ee645438dc0.json	Specify the recursive flag (#22500)	examples/webgl_raycast_texture.html	@@ -328,7 +328,7 @@ raycaster.setFromCamera( mouse, camera ); - return raycaster.intersectObjects( objects ); + return raycaster.intersectObjects( objects, false ); }	true
Other	mrdoob	three.js	e30436d09281e940b7bcef9a957e2ee645438dc0.json	Specify the recursive flag (#22500)	examples/webxr_vr_cubes.html	@@ -205,7 +205,7 @@ raycaster.ray.origin.setFromMatrixPosition( controller.matrixWorld ); raycaster.ray.direction.set( 0, 0, - 1 ).applyMatrix4( tempMatrix ); - const intersects = raycaster.intersectObjects( room.children ); + const intersects = raycaster.intersectObjects( room.children, false ); if ( intersects.length > 0 ) {	true
Other	mrdoob	three.js	e30436d09281e940b7bcef9a957e2ee645438dc0.json	Specify the recursive flag (#22500)	examples/webxr_vr_dragging.html	@@ -217,7 +217,7 @@ raycaster.ray.origin.setFromMatrixPosition( controller.matrixWorld ); raycaster.ray.direction.set( 0, 0, - 1 ).applyMatrix4( tempMatrix ); - return raycaster.intersectObjects( group.children ); + return raycaster.intersectObjects( group.children, false ); }	true
Other	mrdoob	three.js	c191406da786ee02f601b4e04228a62feec513d3.json	remove unnecessary import	examples/jsm/renderers/webgpu/WebGPUUniformsGroup.js	@@ -1,5 +1,4 @@ import WebGPUUniformBuffer from './WebGPUUniformBuffer.js'; -import { GPUBindingType } from './constants.js'; class WebGPUUniformsGroup extends WebGPUUniformBuffer {	false
Other	mrdoob	three.js	494b3421d4284bd83bdea1b1a56dd76753bb3178.json	Adopt importmaps in WebGPU examples	examples/jsm/renderers/webgpu/WebGPUBackground.js	@@ -1,5 +1,5 @@ import { GPULoadOp } from './constants.js'; -import { Color } from '../../../../build/three.module.js'; +import { Color } from 'three'; let _clearAlpha; const _clearColor = new Color();	true
Other	mrdoob	three.js	494b3421d4284bd83bdea1b1a56dd76753bb3178.json	Adopt importmaps in WebGPU examples	examples/jsm/renderers/webgpu/WebGPURenderPipelines.js	@@ -7,7 +7,7 @@ import { NoBlending, NormalBlending, AdditiveBlending, SubtractiveBlending, MultiplyBlending, CustomBlending, AddEquation, SubtractEquation, ReverseSubtractEquation, MinEquation, MaxEquation, ZeroFactor, OneFactor, SrcColorFactor, OneMinusSrcColorFactor, SrcAlphaFactor, OneMinusSrcAlphaFactor, DstAlphaFactor, OneMinusDstAlphaFactor, DstColorFactor, OneMinusDstColorFactor, SrcAlphaSaturateFactor -} from '../../../../build/three.module.js'; +} from 'three'; class WebGPURenderPipelines {	true
Other	mrdoob	three.js	494b3421d4284bd83bdea1b1a56dd76753bb3178.json	Adopt importmaps in WebGPU examples	examples/jsm/renderers/webgpu/WebGPURenderer.js	@@ -14,7 +14,7 @@ import WebGPUNodes from './nodes/WebGPUNodes.js'; import glslang from '../../libs/glslang.js'; -import { Frustum, Matrix4, Vector3, Color } from '../../../../build/three.module.js'; +import { Frustum, Matrix4, Vector3, Color } from 'three'; console.info( 'THREE.WebGPURenderer: Modified Matrix4.makePerspective() and Matrix4.makeOrtographic() to work with WebGPU, see https://github.com/mrdoob/three.js/issues/20276.' );	true
Other	mrdoob	three.js	494b3421d4284bd83bdea1b1a56dd76753bb3178.json	Adopt importmaps in WebGPU examples	examples/jsm/renderers/webgpu/WebGPUTextureRenderer.js	@@ -1,4 +1,4 @@ -import { WebGLRenderTarget } from '../../../../build/three.module.js'; +import { WebGLRenderTarget } from 'three'; class WebGPUTextureRenderer {	true
Other	mrdoob	three.js	494b3421d4284bd83bdea1b1a56dd76753bb3178.json	Adopt importmaps in WebGPU examples	examples/jsm/renderers/webgpu/WebGPUTextures.js	@@ -1,7 +1,7 @@ import { GPUTextureFormat, GPUAddressMode, GPUFilterMode, GPUTextureDimension } from './constants.js'; import { CubeTexture, Texture, NearestFilter, NearestMipmapNearestFilter, NearestMipmapLinearFilter, LinearFilter, RepeatWrapping, MirroredRepeatWrapping, RGBFormat, RGBAFormat, RedFormat, RGFormat, RGBA_S3TC_DXT1_Format, RGBA_S3TC_DXT3_Format, RGBA_S3TC_DXT5_Format, UnsignedByteType, FloatType, HalfFloatType, sRGBEncoding -} from '../../../../build/three.module.js'; +} from 'three'; import WebGPUTextureUtils from './WebGPUTextureUtils.js'; class WebGPUTextures {	true
Other	mrdoob	three.js	494b3421d4284bd83bdea1b1a56dd76753bb3178.json	Adopt importmaps in WebGPU examples	examples/jsm/renderers/webgpu/WebGPUUniform.js	@@ -1,4 +1,4 @@ -import { Color, Matrix3, Matrix4, Vector2, Vector3, Vector4 } from '../../../../build/three.module.js'; +import { Color, Matrix3, Matrix4, Vector2, Vector3, Vector4 } from 'three'; class WebGPUUniform {	true
Other	mrdoob	three.js	494b3421d4284bd83bdea1b1a56dd76753bb3178.json	Adopt importmaps in WebGPU examples	examples/webgpu_compute.html	@@ -10,9 +10,16 @@ <a href="https://threejs.org" target="_blank" rel="noopener">three.js</a> WebGPU - Compute<br/>(Chrome Canary with flag: --enable-unsafe-webgpu) </div> + <script type="importmap"> + { + "imports": { + "three": "../build/three.module.js" + } + } + </script> <script type="module"> - import * as THREE from '../build/three.module.js'; + import * as THREE from 'three'; import WebGPURenderer from './jsm/renderers/webgpu/WebGPURenderer.js'; import WebGPU from './jsm/renderers/webgpu/WebGPU.js';	true
Other	mrdoob	three.js	494b3421d4284bd83bdea1b1a56dd76753bb3178.json	Adopt importmaps in WebGPU examples	examples/webgpu_instance_uniform.html	@@ -11,9 +11,16 @@ <a href="https://threejs.org" target="_blank" rel="noopener">three.js</a> - webgpu materials </div> + <script type="importmap"> + { + "imports": { + "three": "../build/three.module.js" + } + } + </script> <script type="module"> - import * as THREE from '../build/three.module.js'; + import * as THREE from 'three'; import WebGPURenderer from './jsm/renderers/webgpu/WebGPURenderer.js'; import WebGPU from './jsm/renderers/webgpu/WebGPU.js';	true
Other	mrdoob	three.js	494b3421d4284bd83bdea1b1a56dd76753bb3178.json	Adopt importmaps in WebGPU examples	examples/webgpu_materials.html	@@ -11,9 +11,16 @@ <a href="https://threejs.org" target="_blank" rel="noopener">three.js</a> - webgpu materials </div> + <script type="importmap"> + { + "imports": { + "three": "../build/three.module.js" + } + } + </script> <script type="module"> - import * as THREE from '../build/three.module.js'; + import * as THREE from 'three'; import WebGPURenderer from './jsm/renderers/webgpu/WebGPURenderer.js'; import WebGPU from './jsm/renderers/webgpu/WebGPU.js';	true
Other	mrdoob	three.js	494b3421d4284bd83bdea1b1a56dd76753bb3178.json	Adopt importmaps in WebGPU examples	examples/webgpu_rtt.html	@@ -10,9 +10,16 @@ <a href="https://threejs.org" target="_blank" rel="noopener">three.js</a> WebGPU - RTT<br/>(Chrome Canary with flag: --enable-unsafe-webgpu) </div> + <script type="importmap"> + { + "imports": { + "three": "../build/three.module.js" + } + } + </script> <script type="module"> - import * as THREE from '../build/three.module.js'; + import * as THREE from 'three'; import WebGPURenderer from './jsm/renderers/webgpu/WebGPURenderer.js'; import WebGPUTextureRenderer from './jsm/renderers/webgpu/WebGPUTextureRenderer.js';	true
Other	mrdoob	three.js	494b3421d4284bd83bdea1b1a56dd76753bb3178.json	Adopt importmaps in WebGPU examples	examples/webgpu_sandbox.html	@@ -10,9 +10,16 @@ <a href="https://threejs.org" target="_blank" rel="noopener">three.js</a> WebGPU - sandbox<br/>(Chrome Canary with flag: --enable-unsafe-webgpu) </div> + <script type="importmap"> + { + "imports": { + "three": "../build/three.module.js" + } + } + </script> <script type="module"> - import * as THREE from '../build/three.module.js'; + import * as THREE from 'three'; import { DDSLoader } from './jsm/loaders/DDSLoader.js';	true
Other	mrdoob	three.js	c3f83169d60fbc4f3ca25fb83d04bffc84bdf9e5.json	use default value	examples/webgpu_instance_uniform.html	@@ -35,7 +35,7 @@ this.updateType = NodeUpdateType.Object; - this.inputNode = new ColorNode( new THREE.Color() ); + this.inputNode = new ColorNode(); }	false
Other	mrdoob	three.js	015a27c4b4d9759cc0f94e4f933d57c3f1df7454.json	add missing default value	examples/jsm/renderers/nodes/inputs/ColorNode.js	@@ -1,8 +1,9 @@ import InputNode from '../core/InputNode.js'; +import { Color } from '../../../../../build/three.module.js'; class ColorNode extends InputNode { - constructor( value ) { + constructor( value = new Color() ) { super( 'color' );	true
Other	mrdoob	three.js	015a27c4b4d9759cc0f94e4f933d57c3f1df7454.json	add missing default value	examples/jsm/renderers/nodes/inputs/Vector2Node.js	@@ -1,8 +1,9 @@ import InputNode from '../core/InputNode.js'; +import { Vector2 } from '../../../../../build/three.module.js'; class Vector2Node extends InputNode { - constructor( value ) { + constructor( value = new Vector2() ) { super( 'vec2' );	true
Other	mrdoob	three.js	59e8e47d2df52b9572b14e1bd7f616b1cb0809a7.json	compile node material per object	examples/jsm/renderers/webgpu/WebGPUBindings.js	@@ -24,12 +24,11 @@ class WebGPUBindings { if ( data === undefined ) { const pipeline = this.pipelines.get( object ); - const material = object.material; - - const nodeBuilder = this.nodes.get( material ); // each material defines an array of bindings (ubos, textures, samplers etc.) + const nodeBuilder = this.nodes.get( object ); + const bindings = nodeBuilder.getBindings(); // setup (static) binding layout and (dynamic) binding group	true
Other	mrdoob	three.js	59e8e47d2df52b9572b14e1bd7f616b1cb0809a7.json	compile node material per object	examples/jsm/renderers/webgpu/WebGPURenderPipelines.js	@@ -57,7 +57,7 @@ class WebGPURenderPipelines { // get shader - const nodeBuilder = this.nodes.get( material ); + const nodeBuilder = this.nodes.get( object ); // shader modules @@ -788,22 +788,15 @@ class WebGPURenderPipelines { function onMaterialDispose( event ) { const properties = this.properties; - const nodes = this.nodes; - const shaderModules = this.shaderModules; const material = event.target; const materialProperties = properties.get( material ); - const nodeBuilder = nodes.get( material ); material.removeEventListener( 'dispose', materialProperties.disposeCallback ); properties.remove( material ); - nodes.remove( material ); - shaderModules.vertex.delete( nodeBuilder.vertexShader ); - shaderModules.fragment.delete( nodeBuilder.fragmentShader ); - - // @TODO: still needed remove bindings and pipeline + // @TODO: still needed remove nodes, bindings and pipeline }	true
Other	mrdoob	three.js	59e8e47d2df52b9572b14e1bd7f616b1cb0809a7.json	compile node material per object	examples/jsm/renderers/webgpu/nodes/WebGPUNodes.js	@@ -13,25 +13,25 @@ class WebGPUNodes { } - get( material ) { + get( object ) { - let nodeBuilder = this.builders.get( material ); + let nodeBuilder = this.builders.get( object ); if ( nodeBuilder === undefined ) { - nodeBuilder = new WebGPUNodeBuilder( material, this.renderer ).build(); + nodeBuilder = new WebGPUNodeBuilder( object.material, this.renderer ).build(); - this.builders.set( material, nodeBuilder ); + this.builders.set( object, nodeBuilder ); } return nodeBuilder; } - remove( material ) { + remove( object ) { - this.builders.delete( material ); + this.builders.delete( object ); } @@ -45,7 +45,7 @@ class WebGPUNodes { const material = object.material; - const nodeBuilder = this.get( material ); + const nodeBuilder = this.get( object ); const nodeFrame = this.nodeFrame; nodeFrame.material = material;	true
Other	mrdoob	three.js	9d9b9fac2571c690ae81742c53769b0bc72cf06a.json	Add Chinese translation for tips article. (#23501)	manual/list.json	@@ -321,11 +321,11 @@ "按需渲染": "zh/rendering-on-demand", "调试JavaScript": "zh/debugging-javascript", "调试着色器": "zh/debugging-glsl", - "Taking a screenshot": "zh/tips#screenshot", - "Prevent the Canvas Being Cleared": "zh/tips#preservedrawingbuffer", - "Get Keyboard Input From a Canvas": "zh/tips#tabindex", - "Make the Canvas Transparent": "zh/tips#transparent-canvas", - "Use three.js as Background in HTML": "zh/tips#html-background" + "canvas截图": "zh/tips#screenshot", + "防止canvas被清空": "zh/tips#preservedrawingbuffer", + "从canvas获取键盘输入": "zh/tips#tabindex", + "透明化canvas": "zh/tips#transparent-canvas", + "在HTML中使用three.js动画背景": "zh/tips#html-background" }, "优化": { "大量对象的优化": "zh/optimize-lots-of-objects",	true
Other	mrdoob	three.js	9d9b9fac2571c690ae81742c53769b0bc72cf06a.json	Add Chinese translation for tips article. (#23501)	manual/zh/tips.html	@@ -1,6 +1,6 @@ -<!DOCTYPE html><html lang="zh"><head> +<!DOCTYPE html><html lang="en"><head> <meta charset="utf-8"> - <title>Tips</title> + <title>小技巧</title> <meta name="viewport" content="width=device-width, user-scalable=no, minimum-scale=1.0, maximum-scale=1.0"> <meta name="twitter:card" content="summary_large_image"> <meta name="twitter:site" content="@threejs"> @@ -22,7 +22,6 @@ } } </script> - <link rel="stylesheet" href="/manual/zh/lang.css"> </head> <body> <div class="container"> @@ -31,8 +30,305 @@ <h1>Tips</h1> </div> <div class="lesson"> <div class="lesson-main"> - <p>抱歉，还没有中文翻译哦。 <a href="https://github.com/mrdoob/three.js">欢迎加入翻译</a>! 😄</p> -<p><a href="/manual/en/tips.html">英文原文链接</a>.</p> + <p>本文中我们总结了一些在使用three.js过程中可能会遇到的但又看起来不需要各自列出一章的小问题。</p> +<hr> +<p><a id="screenshot" data-toc="Taking a screenshot"></a></p> +<h1 id="taking-a-screenshot-of-the-canvas">canvas截图</h1> +<p>在浏览器中存在两种有效的方式进行截图。 +旧的 +<a href="https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement/toDataURL"><code class="notranslate" translate="no">canvas.toDataURL</code></a> +与新的更好的 +<a href="https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement/toBlob"><code class="notranslate" translate="no">canvas.toBlob</code></a></p> +<p>所以你可能认为仅通过添加下列代码即可轻松实现截图功能</p> +<pre class="prettyprint showlinemods notranslate lang-html" translate="no"><canvas id="c"></canvas> ++<button id="screenshot" type="button">Save...</button> +</pre> +<pre class="prettyprint showlinemods notranslate lang-js" translate="no">const elem = document.querySelector('#screenshot'); +elem.addEventListener('click', () => { + canvas.toBlob((blob) => { + saveBlob(blob, `screencapture-${canvas.width}x${canvas.height}.png`); + }); +}); + +const saveBlob = (function() { + const a = document.createElement('a'); + document.body.appendChild(a); + a.style.display = 'none'; + return function saveData(blob, fileName) { + const url = window.URL.createObjectURL(blob); + a.href = url; + a.download = fileName; + a.click(); + }; +}()); +</pre> +<p>下面是来自介绍 <a href="responsive.html">响应式设计</a> +并添加了上述代码与一些放置按钮的CSS的例子。</p> +<p></p><div translate="no" class="threejs_example_container notranslate"> + <div><iframe class="threejs_example notranslate" translate="no" style=" " src="/manual/examples/resources/editor.html?url=/manual/examples/tips-screenshot-bad.html"></iframe></div> + <a class="threejs_center" href="/manual/examples/tips-screenshot-bad.html" target="_blank">点击此处在新标签页中打开</a> +</div> + +<p></p> +<p>当我尝试截图得到了如下图片</p> +<div class="threejs_center"><img src="../resources/images/screencapture-413x313.png"></div> + +<p>是的，就是一张纯黑的图片而已。</p> +<p>取决于你的浏览器与系统的不同这个例子也有可能会正常生效，但是一般情况下这个例子是无法正常生效的。</p> +<p>这个问题的出现是因为基于性能和兼容性的考量，默认情况下浏览器会在绘制完成后清除WebGL canvas的缓存。</p> +<p>解决方案是在你捕获截图前调用一次渲染代码。</p> +<p>在我们的代码里我们只要进行小幅度调整即可。首先，分离出我们的渲染代码</p> +<pre class="prettyprint showlinemods notranslate lang-js" translate="no">+const state = { ++ time: 0, ++}; + +-function render(time) { +- time = 0.001; ++function render() { + if (resizeRendererToDisplaySize(renderer)) { + const canvas = renderer.domElement; + camera.aspect = canvas.clientWidth / canvas.clientHeight; + camera.updateProjectionMatrix(); + } + + cubes.forEach((cube, ndx) => { + const speed = 1 + ndx .1; +- const rot = time * speed; ++ const rot = state.time * speed; + cube.rotation.x = rot; + cube.rotation.y = rot; + }); + + renderer.render(scene, camera); + +- requestAnimationFrame(render); +} + ++function animate(time) { ++ state.time = time * 0.001; ++ ++ render(); ++ ++ requestAnimationFrame(animate); ++} ++requestAnimationFrame(animate); +</pre> +<p>现在 <code class="notranslate" translate="no">render</code> 方法只与实际的渲染过程相关联了。我们可以在刚好要捕获canvas截图前调用它。</p> +<pre class="prettyprint showlinemods notranslate lang-js" translate="no">const elem = document.querySelector('#screenshot'); +elem.addEventListener('click', () => { ++ render(); + canvas.toBlob((blob) => { + saveBlob(blob, `screencapture-${canvas.width}x${canvas.height}.png`); + }); +}); +</pre> +<p>现在应该能正常生效了。</p> +<p></p><div translate="no" class="threejs_example_container notranslate"> + <div><iframe class="threejs_example notranslate" translate="no" style=" " src="/manual/examples/resources/editor.html?url=/manual/examples/tips-screenshot-good.html"></iframe></div> + <a class="threejs_center" href="/manual/examples/tips-screenshot-good.html" target="_blank">点击此处在新标签页中打开</a> +</div> + +<p></p><p>有关其他解决方案，请参阅下一项。</p> +<hr> + +<p><a id="preservedrawingbuffer" data-toc="Prevent the Canvas Being Cleared"></a></p> +<h1 id="preventing-the-canvas-being-cleared">防止canvas被清空</h1> +<p>如果你想要让用户使用动画对象进行绘图。你需要在创建 <a href="/docs/#api/zh/renderers/WebGLRenderer"><code class="notranslate" translate="no">WebGLRenderer</code></a> 的时候传入 <code class="notranslate" translate="no">preserveDrawingBuffer: true</code>。这将阻止浏览器清理canvas。类似的，你也需要告诉three.js不要自动清理canvas。</p> +<pre class="prettyprint showlinemods notranslate lang-js" translate="no">const canvas = document.querySelector('#c'); +-const renderer = new THREE.WebGLRenderer({canvas}); ++const renderer = new THREE.WebGLRenderer({ ++ canvas, ++ preserveDrawingBuffer: true, ++ alpha: true, ++}); ++renderer.autoClearColor = false; +</pre> +<p></p><div translate="no" class="threejs_example_container notranslate"> + <div><iframe class="threejs_example notranslate" translate="no" style=" " src="/manual/examples/resources/editor.html?url=/manual/examples/tips-preservedrawingbuffer.html"></iframe></div> + <a class="threejs_center" href="/manual/examples/tips-preservedrawingbuffer.html" target="_blank">点击此处在新标签页中打开</a> +</div> + +<p></p> +<p>需要注意的是如果你确实需要制作一个画图程序的话这并不能解决你的问题，因为浏览器仍然会改变分辨率的时候随时有可能清空canvas。我们目前的方案是让canvas的分辨率跟随显示大小的改变。而canvas的显示大小也在随着窗口大小变化。这包括了即便用户在另一个标签页中下载了一个文件，浏览器添加了一个状态栏的情况。也包括了用户转动手机时浏览器从纵向切换至横向布局的情况</p> +<p>如果你切实需要制作一个绘图的程序，你可以 +<a href="rendertargets.html">使用渲染目标的方式渲染到纹理上</a>。</p> +<hr> +<p><a id="tabindex" data-toc="Get Keyboard Input From a Canvas"></a></p> +<h1 id="getting-keyboard-input">获取键盘输入</h1> +<p>在这些教程中，我们通常会将事件监听器绑定到canvas上 <code class="notranslate" translate="no">canvas</code>。 +虽然许多事件都能生效，但是默认情况下键盘事件不会正常响应。</p> +<p>为了获取键盘事件，我们将canvas的 <a href="https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/tabIndex"><code class="notranslate" translate="no">tabindex</code></a> +属性设置为0或更高。如下。</p> +<pre class="prettyprint showlinemods notranslate lang-html" translate="no"><canvas tabindex="0"></canvas> +</pre> +<p>这将导致一个新的问题，任何设置了 <code class="notranslate" translate="no">tabindex</code> 的元素会在聚焦的时候突出显示。为了解决这个问题，我们在CSS中将它focus状态下的outline属性设置为none</p> +<pre class="prettyprint showlinemods notranslate lang-css" translate="no">canvas:focus { + outline:none; +} +</pre> +<p>这里为了演示使用了3个canvas</p> +<pre class="prettyprint showlinemods notranslate lang-html" translate="no"><canvas id="c1"></canvas> +<canvas id="c2" tabindex="0"></canvas> +<canvas id="c3" tabindex="1"></canvas> +</pre> +<p>并且只为最后一个canvas设置css </p> +<pre class="prettyprint showlinemods notranslate lang-css" translate="no">#c3:focus { + outline: none; +} +</pre> +<p>让我们用同样的事件监听器分别与它们相关联</p> +<pre class="prettyprint showlinemods notranslate lang-js" translate="no">document.querySelectorAll('canvas').forEach((canvas) => { + const ctx = canvas.getContext('2d'); + + function draw(str) { + ctx.clearRect(0, 0, canvas.width, canvas.height); + ctx.textAlign = 'center'; + ctx.textBaseline = 'middle'; + ctx.fillText(str, canvas.width / 2, canvas.height / 2); + } + draw(canvas.id); + + canvas.addEventListener('focus', () => { + draw('has focus press a key'); + }); + + canvas.addEventListener('blur', () => { + draw('lost focus'); + }); + + canvas.addEventListener('keydown', (e) => { + draw(`keyCode: ${e.keyCode}`); + }); +}); +</pre> +<p>请注意，你无法让第一个canvas接收到键盘输入。第二个canvas虽然能接收到输入但是被突出显示了。第三个canvas同时解决了这这两个问题。</p> +<p></p><div translate="no" class="threejs_example_container notranslate"> + <div><iframe class="threejs_example notranslate" translate="no" style=" " src="/manual/examples/resources/editor.html?url=/manual/examples/tips-tabindex.html"></iframe></div> + <a class="threejs_center" href="/manual/examples/tips-tabindex.html" target="_blank">点击此处在新标签页中打开</a> +</div> + +<p></p> +<hr> +<p><a id="transparent-canvas" data-toc="Make the Canvas Transparent"></a></p> +<h1 id="making-the-canvas-transparent">透明化canvas</h1> +<p>默认情况下THREE.js让canvas显示为不透明。如果你需要让canvas变得透明可以在创建 <a href="/docs/#api/zh/renderers/WebGLRenderer"><code class="notranslate" translate="no">WebGLRenderer</code></a> 的时候传入 <a href="/docs/#api/zh/renderers/WebGLRenderer#alpha"><code class="notranslate" translate="no">alpha:true</code></a></p> +<pre class="prettyprint showlinemods notranslate lang-js" translate="no">const canvas = document.querySelector('#c'); +-const renderer = new THREE.WebGLRenderer({canvas}); ++const renderer = new THREE.WebGLRenderer({ ++ canvas, ++ alpha: true, ++}); +</pre> +<p>你可能还想告诉它你的结果 <strong>不</strong> 使用 premultiplied alpha</p> +<pre class="prettyprint showlinemods notranslate lang-js" translate="no">const canvas = document.querySelector('#c'); +const renderer = new THREE.WebGLRenderer({ + canvas, + alpha: true, ++ premultipliedAlpha: false, +}); +</pre> +<p>Three.js 使用 +<a href="/docs/#api/zh/renderers/WebGLRenderer#premultipliedAlpha"><code class="notranslate" translate="no">premultipliedAlpha: true</code></a> 作为canvas的缺省值，但使用 <a href="/docs/#api/zh/materials/Material#premultipliedAlpha"><code class="notranslate" translate="no">premultipliedAlpha: false</code></a> 作为材质的缺省值。</p> +<p>如果你想要更好的理解premultiplied alpha的使用与否，这里有<a href="https://developer.nvidia.com/content/alpha-blending-pre-or-not-pre">一篇关于这个问题的好文章</a>。</p> +<p>不管怎样，让我们用透明canvas来设置一个简单的例子。</p> +<p>我们将上述配置应用到来自<a href="responsive.html">关于响应式设计的文章</a>里的例子。让我们也将材质变得更透明。</p> +<pre class="prettyprint showlinemods notranslate lang-js" translate="no">function makeInstance(geometry, color, x) { +- const material = new THREE.MeshPhongMaterial({color}); ++ const material = new THREE.MeshPhongMaterial({ ++ color, ++ opacity: 0.5, ++ }); + +... +</pre> +<p>并且添加一些HTML内容</p> +<pre class="prettyprint showlinemods notranslate lang-html" translate="no"><body> + <canvas id="c"></canvas> ++ <div id="content"> ++ <div> ++ <h1>Cubes-R-Us!</h1> ++ <p>We make the best cubes!</p> ++ </div> ++ </div> +</body> +</pre> +<p>还有一些将画布放置到前面的CSS</p> +<pre class="prettyprint showlinemods notranslate lang-css" translate="no">body { + margin: 0; +} +#c { + width: 100%; + height: 100%; + display: block; ++ position: fixed; ++ left: 0; ++ top: 0; ++ z-index: 2; ++ pointer-events: none; +} ++#content { ++ font-size: 7vw; ++ font-family: sans-serif; ++ text-align: center; ++ width: 100%; ++ height: 100%; ++ display: flex; ++ justify-content: center; ++ align-items: center; ++} +</pre> +<p>注意 <code class="notranslate" translate="no">pointer-events: none</code> 使得canvas不响应鼠标与触摸事件，以至于你能够选中下面的文字。</p> +<p></p><div translate="no" class="threejs_example_container notranslate"> + <div><iframe class="threejs_example notranslate" translate="no" style=" " src="/manual/examples/resources/editor.html?url=/manual/examples/tips-transparent-canvas.html"></iframe></div> + <a class="threejs_center" href="/manual/examples/tips-transparent-canvas.html" target="_blank">点击此处在新标签页中打开</a> +</div> + +<p></p> +<hr> +<p><a id="html-background" data-toc="Use three.js as Background in HTML"></a></p> +<h1 id="making-your-background-a-three-js-animation">使用three.js动画作为背景</h1> +<p>一个常见的问题是如何使用three.js动画作为网站的背景。</p> +<p>这有两种显而易见的方法。</p> +<ul> +<li>将canvas的CSS <code class="notranslate" translate="no">position</code> 属性如下设置为 <code class="notranslate" translate="no">fixed</code></li> +</ul> +<pre class="prettyprint showlinemods notranslate lang-css" translate="no">#c { + position: fixed; + left: 0; + top: 0; + ... +} +</pre> +<p>你可简单的在上一个的例子里使用这个解决方案。只需要将 <code class="notranslate" translate="no">z-index</code> 设为 -1 +就可以看到立方体们显示到文字后面。</p> +<p>这个解决方案存在一个小缺点，那就是你的Javascript必须集成在页面中。而且如果你的页面实现很复杂的话，你需要保证页面里的three.js可视化代码不与实现其他功能的代码相冲突。</p> +<ul> +<li>使用 <code class="notranslate" translate="no">iframe</code></li> +</ul> +<p>这种解决方案被应用在了 <a href="/">本站首页</a>.</p> +<p>在你的网页种只需要插入一个iframe，像这样</p> +<pre class="prettyprint showlinemods notranslate lang-html" translate="no"><iframe id="background" src="responsive.html"> +<div> + Your content goes here. +</div> +</pre> +<p>然后修改样式使其填满窗口，并且处于背景中。这几乎和我们之前用到的canvas样式代码一样。只不过因为iframe存在默认边框，我们需要额外将 <code class="notranslate" translate="no">border</code> 设为 <code class="notranslate" translate="no">none</code> 。</p> +<pre class="prettyprint showlinemods notranslate notranslate" translate="no">#background { + position: fixed; + width: 100%; + height: 100%; + left: 0; + top: 0; + z-index: -1; + border: none; + pointer-events: none; +} +</pre><p></p><div translate="no" class="threejs_example_container notranslate"> + <div><iframe class="threejs_example notranslate" translate="no" style=" " src="/manual/examples/resources/editor.html?url=/manual/examples/tips-html-background.html"></iframe></div> + <a class="threejs_center" href="/manual/examples/tips-html-background.html" target="_blank">点击此处在新标签页中打开</a> +</div> + +<p></p> </div> </div>	true
Other	mrdoob	three.js	48b05d3500acc084df50be9b4c90781ad9b8cb17.json	Remove WebGLMultisampleRenderTarget. (#23455) * Remove WebGLMultisampleRenderTarget. * THREE.Legacy.js: Add WebGLMultisampleRenderTarget. * Exampels: Clean up. * WebGLRenderer: Use multisampling when possible without reporting errors. * Update WebGLRenderer.js Co-authored-by: mrdoob <info@mrdoob.com>	docs/api/en/renderers/WebGLMultisampleRenderTarget.html	@@ -1,57 +0,0 @@ -<!DOCTYPE html> -<html lang="en"> - <head> - <meta charset="utf-8" /> - <base href="../../../" /> - <script src="page.js"></script> - <link type="text/css" rel="stylesheet" href="page.css" /> - </head> - <body> - [page:WebGLRenderTarget] → - - <h1>[name]</h1> - - <p class="desc"> - A special render target that can be used to utilize multi-sampled renderbuffers. - Heads up: [name] can only be used with a WebGL 2 rendering context. - </p> - - <h2>Examples</h2> - - <p> - [example:webgl2_multisampled_renderbuffers webgl2 / multisampled / renderbuffers ] - </p> - - <h2>Constructor</h2> - - - <h3>[name]([param:Number width], [param:Number height], [param:Object options])</h3> - - <p> - [page:Float width] - The width of the render target. <br /> - [page:Float height] - The height of the render target.<br /> - [page:Object options] - (optional) object that holds texture parameters for an auto-generated target - texture and depthBuffer/stencilBuffer booleans. - </p> - - <h2>Properties</h2> - - <h3>[property:number samples]</h3> - <p> - Specifies the number of samples to be used for the renderbuffer storage. However, the maximum supported - size for multisampling is platform dependent and defined via gl.MAX_SAMPLES. - </p> - - <p>[page:WebGLRenderTarget WebGLRenderTarget] properties are available on this class.</p> - - <h2>Methods</h2> - - <p>[page:WebGLRenderTarget WebGLRenderTarget] methods are available on this class.</p> - - <h2>Source</h2> - - <p> - [link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js] - </p> - </body> -</html>	true
Other	mrdoob	three.js	48b05d3500acc084df50be9b4c90781ad9b8cb17.json	Remove WebGLMultisampleRenderTarget. (#23455) * Remove WebGLMultisampleRenderTarget. * THREE.Legacy.js: Add WebGLMultisampleRenderTarget. * Exampels: Clean up. * WebGLRenderer: Use multisampling when possible without reporting errors. * Update WebGLRenderer.js Co-authored-by: mrdoob <info@mrdoob.com>	docs/api/en/renderers/WebGLRenderTarget.html	@@ -93,6 +93,10 @@ <h3>[property:DepthTexture depthTexture]</h3> If set, the scene depth will be rendered to this texture. Default is null. </p> + <h3>[property:Number samples]</h3> + <p> + Defines the count of MSAA samples. Can only be used with WebGL 2. Default is 0. + </p> <h2>Methods</h2>	true
Other	mrdoob	three.js	48b05d3500acc084df50be9b4c90781ad9b8cb17.json	Remove WebGLMultisampleRenderTarget. (#23455) * Remove WebGLMultisampleRenderTarget. * THREE.Legacy.js: Add WebGLMultisampleRenderTarget. * Exampels: Clean up. * WebGLRenderer: Use multisampling when possible without reporting errors. * Update WebGLRenderer.js Co-authored-by: mrdoob <info@mrdoob.com>	docs/api/zh/renderers/WebGLMultisampleRenderTarget.html	@@ -1,57 +0,0 @@ -<!DOCTYPE html> -<html lang="zh"> - <head> - <meta charset="utf-8" /> - <base href="../../../" /> - <script src="page.js"></script> - <link type="text/css" rel="stylesheet" href="page.css" /> - </head> - <body> - [page:WebGLRenderTarget] → - - <h1>[name]</h1> - - <p class="desc"> - A special render target that can be used to utilize multi-sampled renderbuffers. - Heads up: [name] can only be used with a WebGL 2 rendering context. - </p> - - <h2>Examples</h2> - - <p> - [example:webgl2_multisampled_renderbuffers webgl2 / multisampled / renderbuffers ] - </p> - - <h2>Constructor</h2> - - - <h3>[name]([param:Number width], [param:Number height], [param:Object options])</h3> - - <p> - [page:Float width] - The width of the render target. <br /> - [page:Float height] - The height of the render target.<br /> - [page:Object options] - (optional) object that holds texture parameters for an auto-generated target - texture and depthBuffer/stencilBuffer booleans. - </p> - - <h2>Properties</h2> - - <h3>[property:number samples]</h3> - <p> - Specifies the number of samples to be used for the renderbuffer storage. However, the maximum supported - size for multisampling is platform dependent and defined via gl.MAX_SAMPLES. - </p> - - <p>[page:WebGLRenderTarget WebGLRenderTarget] properties are available on this class.</p> - - <h2>Methods</h2> - - <p>[page:WebGLRenderTarget WebGLRenderTarget] methods are available on this class.</p> - - <h2>Source</h2> - - <p> - [link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js] - </p> - </body> -</html>	true
Other	mrdoob	three.js	48b05d3500acc084df50be9b4c90781ad9b8cb17.json	Remove WebGLMultisampleRenderTarget. (#23455) * Remove WebGLMultisampleRenderTarget. * THREE.Legacy.js: Add WebGLMultisampleRenderTarget. * Exampels: Clean up. * WebGLRenderer: Use multisampling when possible without reporting errors. * Update WebGLRenderer.js Co-authored-by: mrdoob <info@mrdoob.com>	docs/api/zh/renderers/WebGLRenderTarget.html	@@ -89,6 +89,10 @@ <h3>[property:DepthTexture depthTexture]</h3> 如果设置，那么场景的深度将会被渲染到此纹理上。默认为null </p> + <h3>[property:Number samples]</h3> + <p> + Defines the count of MSAA samples. Can only be used with WebGL 2. Default is 0. + </p> <h2>方法</h2>	true
Other	mrdoob	three.js	48b05d3500acc084df50be9b4c90781ad9b8cb17.json	Remove WebGLMultisampleRenderTarget. (#23455) * Remove WebGLMultisampleRenderTarget. * THREE.Legacy.js: Add WebGLMultisampleRenderTarget. * Exampels: Clean up. * WebGLRenderer: Use multisampling when possible without reporting errors. * Update WebGLRenderer.js Co-authored-by: mrdoob <info@mrdoob.com>	docs/list.json	@@ -283,7 +283,6 @@ "Renderers": { "WebGLMultipleRenderTargets": "api/en/renderers/WebGLMultipleRenderTargets", - "WebGLMultisampleRenderTarget": "api/en/renderers/WebGLMultisampleRenderTarget", "WebGLRenderer": "api/en/renderers/WebGLRenderer", "WebGL1Renderer": "api/en/renderers/WebGL1Renderer", "WebGLRenderTarget": "api/en/renderers/WebGLRenderTarget", @@ -783,7 +782,6 @@ "渲染器": { "WebGLMultipleRenderTargets": "api/zh/renderers/WebGLMultipleRenderTargets", - "WebGLMultisampleRenderTarget": "api/zh/renderers/WebGLMultisampleRenderTarget", "WebGLRenderer": "api/zh/renderers/WebGLRenderer", "WebGL1Renderer": "api/zh/renderers/WebGL1Renderer", "WebGLRenderTarget": "api/zh/renderers/WebGLRenderTarget",	true
Other	mrdoob	three.js	48b05d3500acc084df50be9b4c90781ad9b8cb17.json	Remove WebGLMultisampleRenderTarget. (#23455) * Remove WebGLMultisampleRenderTarget. * THREE.Legacy.js: Add WebGLMultisampleRenderTarget. * Exampels: Clean up. * WebGLRenderer: Use multisampling when possible without reporting errors. * Update WebGLRenderer.js Co-authored-by: mrdoob <info@mrdoob.com>	examples/jsm/objects/Reflector.js	@@ -8,8 +8,7 @@ import { UniformsUtils, Vector3, Vector4, - WebGLRenderTarget, - WebGLMultisampleRenderTarget + WebGLRenderTarget } from 'three'; class Reflector extends Mesh { @@ -27,7 +26,7 @@ class Reflector extends Mesh { const textureHeight = options.textureHeight \|\| 512; const clipBias = options.clipBias \|\| 0; const shader = options.shader \|\| Reflector.ReflectorShader; - const multisample = options.multisample \|\| 4; + const multisample = ( options.multisample !== undefined ) ? options.multisample : 4; // @@ -46,18 +45,7 @@ class Reflector extends Mesh { const textureMatrix = new Matrix4(); const virtualCamera = new PerspectiveCamera(); - let renderTarget; - - if ( multisample > 0 ) { - - renderTarget = new WebGLMultisampleRenderTarget( textureWidth, textureHeight ); - renderTarget.samples = multisample; - - } else { - - renderTarget = new WebGLRenderTarget( textureWidth, textureHeight ); - - } + const renderTarget = new WebGLRenderTarget( textureWidth, textureHeight, { samples: multisample } ); const material = new ShaderMaterial( { uniforms: UniformsUtils.clone( shader.uniforms ),	true
Other	mrdoob	three.js	48b05d3500acc084df50be9b4c90781ad9b8cb17.json	Remove WebGLMultisampleRenderTarget. (#23455) * Remove WebGLMultisampleRenderTarget. * THREE.Legacy.js: Add WebGLMultisampleRenderTarget. * Exampels: Clean up. * WebGLRenderer: Use multisampling when possible without reporting errors. * Update WebGLRenderer.js Co-authored-by: mrdoob <info@mrdoob.com>	examples/jsm/objects/Refractor.js	@@ -9,8 +9,7 @@ import { UniformsUtils, Vector3, Vector4, - WebGLRenderTarget, - WebGLMultisampleRenderTarget + WebGLRenderTarget } from 'three'; class Refractor extends Mesh { @@ -28,7 +27,7 @@ class Refractor extends Mesh { const textureHeight = options.textureHeight \|\| 512; const clipBias = options.clipBias \|\| 0; const shader = options.shader \|\| Refractor.RefractorShader; - const multisample = options.multisample \|\| 4; + const multisample = ( options.multisample !== undefined ) ? options.multisample : 4; // @@ -43,18 +42,7 @@ class Refractor extends Mesh { // render target - let renderTarget; - - if ( multisample > 0 ) { - - renderTarget = new WebGLMultisampleRenderTarget( textureWidth, textureHeight ); - renderTarget.samples = multisample; - - } else { - - renderTarget = new WebGLRenderTarget( textureWidth, textureHeight ); - - } + const renderTarget = new WebGLRenderTarget( textureWidth, textureHeight, { samples: multisample } ); // material	true

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.