6.相机

最新推荐文章于 2024-02-05 22:46:31 发布

sheerhr

最新推荐文章于 2024-02-05 22:46:31 发布

阅读量133

点赞数

分类专栏： three.js

本文链接：https://blog.csdn.net/qq_24871849/article/details/112424779

版权

three.js 专栏收录该内容

27 篇文章 0 订阅

订阅专栏

透视相机

距离相机越远的物体，会被渲染得越小

正投影相机

使用正投影相机的话，所有的物体渲染出来的尺寸都一样，对象和相机之间的距离不会影响渲染结果。
THREE.PerspectiveCamera（）接收以下参数。
透视相机参数
fov视角：
当视角越大时，中间的物体就会越小。

aspect
一般跟屏幕的长宽比是一致的，如果这个值过大，那么物体会被渲染得很宽，可以自己实验一下。

near
设置一个很小的值，如果很大，物体会看不全

far
设置一个较大的值，如果很小，那么物体会看不全，如果很大，那么又会影响渲染的效率，就像做菜，得掌控火候。

如下图所示

透视相机相当于点光源照射物体所看到的投影，所以才会产生近大远小的情况.

物体会被展示在近面和远面之间

正投影相机的属性

lookat()

一般来说，相机会指向场景的中心，但是我们也可以改变相机所看的位置。
camera.lookAt（new THREE.Vector3(x,y,z)）

相机指向的是一个点,相机本身也有一个位置，以此确定一条射线垂直于相机镜头。

相机本身也可以旋转。camera.up.x(y,z)指定的是相机快门指向的坐标位置，即确定相机的摆放样子。

<!DOCTYPE html>

<html>

<head>
    <title>Example 02.08 - Cameras</title>
    <script type="text/javascript" src="../libs/three.js"></script>

    <script type="text/javascript" src="../libs/stats.js"></script>
    <script type="text/javascript" src="../libs/dat.gui.js"></script>
    <style>
        body {
            /* set margin to 0 and overflow to hidden, to go fullscreen */
            margin: 0;
            overflow: hidden;
        }
    </style>
</head>
<body>

<div id="Stats-output">
</div>
<!-- Div which will hold the Output -->
<div id="WebGL-output">
</div>

<!-- Javascript code that runs our Three.js examples -->
<script type="text/javascript">

    // once everything is loaded, we run our Three.js stuff.
    function init() {

        var stats = initStats();

        // create a scene, that will hold all our elements such as objects, cameras and lights.
        var scene = new THREE.Scene();

        // create a camera, which defines where we're looking at.
        var camera = new THREE.PerspectiveCamera(45, window.innerWidth / window.innerHeight, 0.1, 1000);
        camera.position.x = 120;
        camera.position.y = 60;
        camera.position.z = 180;

        // create a render and set the size
        var renderer = new THREE.WebGLRenderer();

        renderer.setClearColor(new THREE.Color(0xEEEEEE, 1.0));
        renderer.setSize(window.innerWidth, window.innerHeight);

        // create the ground plane
        var planeGeometry = new THREE.PlaneGeometry(180, 180);
        var planeMaterial = new THREE.MeshLambertMaterial({color: 0xffffff});
        var plane = new THREE.Mesh(planeGeometry, planeMaterial);


        // rotate and position the plane
        plane.rotation.x = -0.5 * Math.PI;
        plane.position.x = 0;
        plane.position.y = 0;
        plane.position.z = 0;

        // add the plane to the scene
        scene.add(plane);

        var cubeGeometry = new THREE.BoxGeometry(4, 4, 4);
        var cubeMaterial = new THREE.MeshLambertMaterial({color: 0x00ee22});
        for (var j = 0; j < (planeGeometry.parameters.height / 5); j++) {
            for (var i = 0; i < planeGeometry.parameters.width / 5; i++) {
                var cube = new THREE.Mesh(cubeGeometry, cubeMaterial);

                cube.position.z = -((planeGeometry.parameters.height) / 2) + 2 + (j * 5);
                cube.position.x = -((planeGeometry.parameters.width) / 2) + 2 + (i * 5);
                cube.position.y = 2;

                scene.add(cube);
            }
        }

        var lookAtGeom = new THREE.SphereGeometry(2);
        var lookAtMesh = new THREE.Mesh(lookAtGeom, new THREE.MeshLambertMaterial({color: 0xff0000}));
        scene.add(lookAtMesh);


        var directionalLight = new THREE.DirectionalLight(0xffffff, 0.7);
        directionalLight.position.set(-20, 40, 60);
        scene.add(directionalLight);


        // add subtle ambient lighting
        var ambientLight = new THREE.AmbientLight(0x292929);
        scene.add(ambientLight);

        // add the output of the renderer to the html element
        document.getElementById("WebGL-output").appendChild(renderer.domElement);

        // call the render function
        var step = 0;

        var controls = new function () {
            this.perspective = "Perspective";
            this.switchCamera = function () {
                if (camera instanceof THREE.PerspectiveCamera) {
                    camera = new THREE.OrthographicCamera(window.innerWidth / -16, window.innerWidth / 16, window.innerHeight / 16, window.innerHeight / -16, -200, 500);
                    camera.position.x = 120;
                    camera.position.y = 60;
                    camera.position.z = 180;

                    camera.lookAt(scene.position);
                    this.perspective = "Orthographic";
                } else {
                    camera = new THREE.PerspectiveCamera(45, window.innerWidth / window.innerHeight, 0.1, 1000);
                    camera.position.x = 120;
                    camera.position.y = 60;
                    camera.position.z = 180;

                    camera.lookAt(scene.position);
                    this.perspective = "Perspective";
                }
            };
        };

        var gui = new dat.GUI();
        gui.add(controls, 'switchCamera');
        gui.add(controls, 'perspective').listen();

        // make sure that for the first time, the
        // camera is looking at the scene
        //   camera.lookAt(scene.position);
        render();


        var step = 0;

        function render() {

            stats.update();
            // render using requestAnimationFrame
            step += 0.02;
            if (camera instanceof THREE.Camera) {
                var x = 10 + ( 100 * (Math.sin(step)));
                camera.lookAt(new THREE.Vector3(x, 10, 0));
                lookAtMesh.position.copy(new THREE.Vector3(x, 10, 0));
            }

//        .position.x = 20+( 10*(Math.cos(step)));
            requestAnimationFrame(render);
            renderer.render(scene, camera);
        }

        function initStats() {

            var stats = new Stats();

            stats.setMode(0); // 0: fps, 1: ms

            // Align top-left
            stats.domElement.style.position = 'absolute';
            stats.domElement.style.left = '0px';
            stats.domElement.style.top = '0px';

            document.getElementById("Stats-output").appendChild(stats.domElement);

            return stats;
        }
    }
    window.onload = init


</script>
</body>
</html>

sheerhr

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
6.相机

透视相机距离相机越远的物体，会被渲染得越小正投影相机使用正投影相机的话，所有的物体渲染出来的尺寸都一样，对象和相机之间的距离不会影响渲染结果。THREE.PerspectiveCamera（）接收以下参数。fov视角：当视角越大时，中间的物体就会越小。aspect一般跟屏幕的长宽比是一致的，如果这个值过大，那么物体会被渲染得很宽，可以自己实验一下。near设置一个很小的值，如果很大，物体会看不全far设置一个较大的值，如果很小，那么物体会看不全，如果很大，那么又会影响渲染的效率，就
复制链接

扫一扫