์๋ฅผ ๋ค์ด, ํ๋ฉด์ ํ ์ง์ (x, y)์ '3d'์ง์ ์ผ๋ก ํฌ์ํ๋ ๋ฐฉ๋ฒ์ด ์๋ค๋ ๊ฒ์ ์์์ต๋๋ค. ๊ทธ๋ฌ๋ ๋๋ ๊ทธ๊ฒ์ ๋ค์ ๋ฒ์ญํ๋ ๋ฐฉ๋ฒ์ ์ ์ ์์ต๋๋ค. ๋จ์ ๊ฐ์ฌํฉ๋๋ค.
์๋ง๋ ํ๋ก์ ํฐ๋ฅผ ์ฌ์ฉํ๊ณ ์์ง๋ง MrDoob์ ๋ถ๋ช ํ ์ด๊ฒ์ ๋ํด ๋ ๋ง์ด ์๊ณ ์์ต๋๋ค. :)
์์, ์ด์ฉ๋ฉด ์ฐ๋ฆฌ๊ฐํด์ผ object3d.screen
๋ ๊ฒ์ด๋ผ๊ณ Vector2
๋ชจ๋ ๋ ๋๋ง์ ์
๋ฐ์ดํธ?
ํด๋น object3D.screen Vector๊ฐ ๋ชจ๋ object3D์ object3D.position์ 2D๋ก ๋ณํํ๋ ๋ฐ๋ง ์ฌ์ฉ๋๋ ๊ฒฝ์ฐ object3D.screen ๊ฐ์ด ๋๋ฌด ์์ง ์์๊น์? ๋ด ๋ง์ : x, y, z ์์น์์๋ ๋ชจ๋ ๋ฉ์์ ๋ชจ๋ ์ x, y, z๋ฅผ 2D ์ขํ๋ก ๋ณํํ๋ ๊ฒ์ด ๋ ์ ์ฉ ํ ๊ฒ์ด๋ผ๊ณ ์๊ฐํฉ๋๋ค.
์ฆ, ๋ชจ๋ ๋ฌผ์ฒด์ ๋ชจ๋ 3D ์์น๋ฅผ ๋ฏธ๋ฆฌ ๊ณ์ฐํ ์๋ ์์ต๋๋ค.
์๋ฅผ ๋ค์ด Vector3 (์ฅ๋ฉด์ ํ ์ง์ ์ ๋ํ๋) ๋๋ Vector3์ ๊ฐ์ฒด (Vector3๊ฐ ๊ฐ์ฒด์ ํ ์ง์ ์ ๋ํ๋)๋ฅผ ์ทจํ๋ THREE.3dto2d()
ํจ์๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด ์ ์ฉํฉ๋๋ค.
๊ทธ๋ฐ ๋ค์์ด ํจ์๋ ์ฅ๋ฉด์์ 3D ์์น๋ฅผ ๊ณ์ฐํฉ๋๋ค.
๋ง์ง๋ง์ผ๋ก ์นด๋ฉ๋ผ, ์์น, ํ์ , projectionMatrix ๋ฑ์ ๊ฐ์ ธ ์์ ์ ์ ๋ค์ 2D๋ก ๋ณํํฉ๋๋ค.
์นด๋ฉ๋ผ๋ ํจ์์ ๋งค๊ฐ ๋ณ์ ์ฌ์ผํ๋ค๊ณ ์๊ฐํฉ๋๋ค.
๊ธ์ ... Projector.projectScene
์ด๋ฏธ ๊ทธ๋ ๊ฒํ๊ณ ์์ต๋๋ค;)
๋ด, ๋๋ ๊ทธ๊ฒ์ด ํ๋ก์ ํฐ ๋ผ๋ ๊ฒ์ ์๊ณ ์์๋ค ... ;-)
๊ทธ๊ฒ์ ์ฌ์ฉํ ์๊ฐ ์์ต๋๊น?
ํ ... ์์ง ...์ด ํจ์๋ Renderer์ ํจ๊ป ์ฌ์ฉํ๋๋ก ์ค๊ณ๋์์ต๋๋ค. ์๋ ๊ฐ์ฒด์ ๊ด๊ณ์์ด ๋ ๋๋ง ํ ์์ ๋ชฉ๋ก์ ๋ฐํํฉ๋๋ค. ์๋ ๊ฐ์ฒด์ ๋ํ ๋งํฌ๋ฅผ ๋ฃ์ด์ผ ํ ์๋ ์์ต๋๋ค. ๊ทธ๋ฌ๋ฉด ... ์, ์ข ๋ ์๊ฐํ ํ์๊ฐ ์์ต๋๋ค.
๋๋ ํ์ฌ ํด์ผ์ด์ง๋ง ๋์ ์ค์๋ง์ (๋ค์ ์ฃผ) ๋ ์ฆ ํ๋ ์ด ๋ฐ๋ชจ (๋๋ ๋ฌด์ธ๊ฐ)๋ฅผ ํ ๊ฒ์ ๋๋ค.
๋ฌผ๋ก ์ ๋๋ค. ์ฆ๊ฑฐ์ด ํด๊ฐ ๋ณด๋ด์๊ณ ์๋ก์ด ๋ฐ๋ชจ๋ฅผ ๊ธฐ๋ํ๊ฒ ์ต๋๋ค! :-)
ํ , ์ด๊ฒ์ ์ ์๊ฒ ํจ๊ณผ๊ฐ ์์๋๋ฐ (r32), r35์์๋ ๋ ์ด์ ์๋ํ์ง ์์ต๋๋ค ..
toScreenXY: function(position, camera, jqdiv) {
// converts 3D position to screen coords
var pos = position.clone();
projScreenMat = new THREE.Matrix4();
projScreenMat.multiply( camera.projectionMatrix, camera.matrix);
projScreenMat.multiplyVector3(pos);
return { x: (pos.x+1)*jqdiv.width()/2 + jqdiv.offset().left,
y:(-pos.y+1)*jqdiv.height()/2 +jqdiv.offset().top };
},
projScreenMat.multiplyVector3(pos);
์ดํ์ ์์น๋๋ณด๊ธฐ์ ์ค์ฌ์์ -1๊ณผ 1 ((0,0) ์ฌ์ด๋ก ์ ํ๋์์ต๋๋ค.) ์ด์์ง๋ง ์ด์ ๋ ์๊ธฐ์น ์๊ฒ ๋ฌ๋ผ์ง๋ ๊ฒ ๊ฐ์ต๋๋ค ..
์, camera.matrix
๋ฅผ ์ง๊ธ camera.matrixWorldInverse
๋ก ๋ฐ๊ฟ์ผํฉ๋๋ค.
์ด๊ฒ์ ์๋ํ์ญ์์ค :
toScreenXY: function ( position, camera, jqdiv ) {
var pos = position.clone();
projScreenMat = new THREE.Matrix4();
projScreenMat.multiply( camera.projectionMatrix, camera.matrixWorldInverse );
projScreenMat.multiplyVector3( pos );
return { x: ( pos.x + 1 ) * jqdiv.width() / 2 + jqdiv.offset().left,
y: ( - pos.y + 1) * jqdiv.height() / 2 + jqdiv.offset().top };
}
๊ทธ๋, ๋งคํธ๋ฆญ์ค ๋ณ๊ฒฝ์ ๋ํด ๋ชฐ๋์ต๋๋ค. ์ด ํ๋ก์ ์ ๊ธฐ๋ฅ์ด alivedise์ ์ง๋ฌธ์ ๋ตํ๊ธฐ๋ฅผ ๋ฐ๋๋๋ค.
3D Cube์ ๋ํด ์ ์ง๋ฌธ์ํ๋ ๊ฒ์ด ์ฌ๋ฐ๋ฅธ ์ค๋ ๋๋ผ๊ณ ์๊ฐํฉ๋๋ค. ํด๋ฆญ ๊ฐ๋ฅํ๋ฉด์ผ๋ก ์บ๋ฒ์ค์ ํ๋ธ๋ฅผ ๊ทธ๋ ธ์ต๋๋ค. ํ๋ธ๋ X ์ถ๊ณผ Y ์ถ์์ ์์ ๋กญ๊ฒ ํ์ ํฉ๋๋ค. ๋ด๊ฐ ์ํ๋ ๊ฒ์ ์ฌ์ฉ์๊ฐ ๋ง์ฐ์ค๋ฅผ ๋์ ๋ ๊ฐ์ฅ ์๋ฉด์ ์ป๊ณ ์๋์ผ๋ก ํ์ ํ์ฌ ์์ ํ ๋ณด์ด๊ฒ ๋ง๋๋ ๊ฒ์ ๋๋ค. ์ด ๋งฅ๋ฝ์์ ์ด๋ค ๋์์ด๋ผ๋ ๋งค์ฐ ๊ฐ์ฌ ํ ๊ฒ์ ๋๋ค.
๊ฐ์ฌํฉ๋๋ค.
@ imrantariq2011 :์ด ๋ฌธ์ ์๋ ๊ด๋ จ์ด ์์ต๋๋ค. ์ ๋ฌธ์ ๋ฅผ ์ด์ด๋ ๋ ๊น์? ๊ฐ์ฌ.
ํ ์ค์ฒ ๋งคํ์ ์ํด ์ฃผ์ด์ง ์ผ๊ตด์ ๋ํ ๊ฐ ์ ์ ์ ๋ํ x, y ํ๋ฉด ์ขํ๋ฅผ ์ป์ ์ ์๊ธฐ๋ฅผ ์ํฉ๋๋ค.
์์ (toScreenXY : ํจ์)๋ฅผ ์ฌ์ฉํ์ฌ ์ด๋ป๊ฒ ํ ์ ์๋์ง ๋ณผ ์ ์์ง๋ง ๋จผ์ ์ฃผ์ด์ง ์ผ๊ตด์ ๋ํด ๋ณํ ๋ (ํฌ๊ธฐ ์กฐ์ , ์ด๋ ๋ฐ ํ์ ๋) ์ ์ ์ธ๊ณ๊ฐ ํ์ํฉ๋๋ค. Projector.projectScene์ ์ดํด๋ณด๋ฉด์ ์๊ฐ์ ๋ณด๋๊ณ ์์ ๋ชฉํ๋ฅผ ๋ฌ์ฑํ๋ ๋ ๊ฐ๋จํ ๋ฐฉ๋ฒ์ด ์๋์ง ๊ถ๊ธํฉ๋๋ค. object.matrixWorld.getPosition ()์ด ์ผ๊ตด ์ ์ ์ด ์๋ ๊ฐ์ฒด์ ์ค์ฌ์ ์ป์ ์ ์์ต๋๋ค.
์, ์์ ์ฝ๋๋ ๋ค์ ์ค ํ๋์
๋๋ค. .projectScene()
์์ฒด์์ ์ฝ๋ ๋นํธ๋ฅผ ์ถ์ถํ๋ ๊ฒ์ด ๊ฐ์ฅ ์ข์ผ๋ฉด ๋ง์ ํฌ์ธํธ๋ฅผ ํฌ์ํด์ผํ๋ ๊ฒฝ์ฐ.
์ฌ๊ธฐ์ ์ค๋ ์ฌ๋๋ค์ ์ด๊ฒ์ ๋ํด ์๊ณ ์ถ์ด ํ ๊ฒ์ ๋๋ค :
๋๋ ์ด๊ฒ์ ์ฌ์ฉํ๋ค.
toScreenXY (pos3D) ํจ์
{
var projector = new THREE.Projector ();
var v = projector.projectVector (pos3D, ์นด๋ฉ๋ผ);
var percX = (vx + 1) / 2;
var percY = (-vy + 1) / 2;
var left = percX * window.innerWidth;
var top = percY * window.innerHeight;
return new THREE.Vector2 (left, top);
}
2014 ๋ 8 ์ 1 ์ผ ๊ธ์์ผ ์ค์ 11:24์ Artem Fitiskin [email protected] ์ ๋ค์๊ณผ ๊ฐ์ด ์ผ์ต๋๋ค.
toScreenXY๋ฅผ ์ฌ์ฉํ ๋ ๋๋ ๋งค์ฐ ํฐ ๊ฐ์น๋ฅผ ์ป์ต๋๋ค.
console.log (pos) : // x : -1474.1436403989792, y : -730.829023361206, z : 3.0004000663757324
jqdiv์ ๊ณฑํ๋ฉด ํจ์๋ ๋งค์ฐ ํฐ x์ y๋ฅผ ๋ฐํํฉ๋๋ค.
๋ด๊ฐ ๋ญ ์๋ชปํ๊ณ ์๋?
โ
์ด ์ด๋ฉ์ผ์ ์ง์ ๋ต์ฅํ๊ฑฐ๋ GitHub์์ ํ์ธํ์ธ์.
๋ฟก ๋นต๋จ
์ง์นจ์ ๋ช ์๋๋๋ก ๋์๋ง ์์ฒญ์ stackoverflow๋ก ์ ๋ฌ ๋์ด์ผํฉ๋๋ค. ์ด ๊ฒ์ํ์ ๋ฒ๊ทธ ๋ฐ ๊ธฐ๋ฅ ์์ฒญ์์ํ ๊ฒ์ ๋๋ค.
๊ด์ฐฎ์์ ... ๋๋ธ ์จ๊ฐ ์ง์ ์ฝ๋๋ฅผ ์ ๋ ฅ ํ์ผ๋ ์ด๋ป๊ฒ ๋๋์?
@arieljake # 1979
์ ๊ทธ๋ ์ด๋ ํ์๋ ๋๊ตฐ๊ฐ๊ฐ ์ฌ์ ํ ์ด๊ฒ์ ํ์๋กํ๋ค๋ฉด ...
function screenXY(obj){
var vector = obj.clone();
var windowWidth = window.innerWidth;
var minWidth = 1280;
if(windowWidth < minWidth) {
windowWidth = minWidth;
}
var widthHalf = (windowWidth/2);
var heightHalf = (window.innerHeight/2);
vector.project(camera);
vector.x = ( vector.x * widthHalf ) + widthHalf;
vector.y = - ( vector.y * heightHalf ) + heightHalf;
vector.z = 0;
return vector;
};
์ข์, ์์ฃผ ์ค๋๋ ๋ฌธ์ ์ด์ง๋ง ์์ ์ฝ๋์์ ์๋ํ์ง ์๋ ์ค์ฒฉ ๊ฐ์ฒด๊ฐ ์์ต๋๋ค.
์ ๊ฒฝ์ฐ๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค. ๋ ๋๋ง ํ ์ค์ฒฉ ๋ ๊ฐ์ฒด์ ๋ํ ์ค์ x-and-y (๋ฐ z) ์์น๋ฅผ ์ํ๊ธฐ ๋๋ฌธ์ ์์ ์๋ฅผ ์ ์ฉํ์ต๋๋ค.
์ฐธ๊ณ :
scene.updateMatrixWorld();
๊ณผ
parent.updateMatrixWorld();
```js
function nestedObjecttoScreenXYZ (obj, camera, width, height)
{
var vector = new THREE.Vector3 ();
vector.setFromMatrixPosition (obj.matrixWorld);
var widthHalf = (๋๋น / 2);
var heightHalf = (๋์ด / 2);
vector.project (์นด๋ฉ๋ผ);
vector.x = (vector.x * widthHalf) + widthHalf;
vector.y =-(vector.y * heightHalf) + heightHalf;
๋ฆฌํด ๋ฒกํฐ;
};
typical call:
```js
var screenpos=NestedObjecttoScreenXY(object,camera,renderer.domElement.width,renderer.domElement.height,true);
๋๊ตฐ๊ฐ ๊ฐ์ ๋ฌธ์ ์ ๋ถ๋ช ํ ๊ฒฝ์ฐ๋ฅผ ๋๋นํด.
๊ฐ์ฅ ์ ์ฉํ ๋๊ธ
์ ๊ทธ๋ ์ด๋ ํ์๋ ๋๊ตฐ๊ฐ๊ฐ ์ฌ์ ํ ์ด๊ฒ์ ํ์๋กํ๋ค๋ฉด ...