基于three.js动态绘制多边形和圆

一、功能分析

在最近的项目中,需要实现在three.js场景中动态绘制多边形和圆形的功能,接下来对该功能进行分析:

  1. 开启绘制动画,进行单击和双击事件绑定。
  2. 绘制多边形:单击后绘制当前的顶点,鼠标拖动时绘制出移动的线段,再次单击后将两个顶点通过线段链接起来。双击后停止绘制,生成多边形的面,并进行颜色填充。
  3. 绘制圆:单击后选择当前点为圆的中心点,鼠标拖动时根据当前鼠标距离中心点的距离作为半径绘制圆,鼠标双击后停止动态绘制,将鼠标当前点与中心点距离作为半径生成圆。
  4. 清空功能:将已绘制的图形全部清空。

二、实现

1. 场景添加

let container,scene,camera,renderer,type,pointArr = [];
function initScene(){
    container = document.getElementById('container');
    renderer = new THREE.WebGLRenderer({antialias: true}); //antialias:true 启用抗锯齿渲染
    renderer.setSize(container.offsetWidth, container.offsetHeight);
    container.appendChild(renderer.domElement);
    scene = new THREE.Scene();
    camera = new THREE.PerspectiveCamera(45, container.offsetWidth / container.offsetHeight, 1, 500);
    camera.position.set(0, 0, 100);
    let light = new THREE.DirectionalLight(0xffffff, 1.5);

    light.position.set(0,0,1);
    scene.add(light);
   
    window.addEventListener( 'resize', onWindowResize, false );
    
    addDrawPlane();
    bindBtnEvent();
    run();
}
function onWindowResize() {
    camera.aspect = window.innerWidth / window.innerHeight;
    camera.updateProjectionMatrix();
    renderer.setSize( window.innerWidth, window.innerHeight );
    render();
}
function render() {
    renderer.render( scene, camera );
}
function run() {
    render();
    requestAnimationFrame(run);
}
//绑定操作按钮事件
function bindBtnEvent(){
    let clearBtn = document.getElementById('clearBtn');
    let activeBtn = document.getElementById('activeBtn');
    let deactiveBtn = document.getElementById('deactiveBtn');
    let activeCircleBtn = document.getElementById('activeCircleBtn');
    activeBtn.addEventListener('click', startDrawPolygon, false);
    activeCircleBtn.addEventListener('click', startDrawCircle, false);
    clearBtn.addEventListener('click', clear, false);
}

2. 创建绘制面板

在three.js中,需要创建一个平面模型来与当前选择的点进行相交取点,确定点位矢量。

function addDrawPlane(){
    let geometry = new THREE.Geometry();
    let arr = [[-40, 40, 0],[-40, -40, 0], [40, -40, 0],[40, 40, 0]]

    for(let i = 0; i < arr.length; i++) {
        let tmp = arr[i];
        geometry.vertices.push(new THREE.Vector3(tmp[0],tmp[1],tmp[2]));
    }

    let normal = new THREE.Vector3(0,0,1);//此处是一个法向量,与需要XY面垂直。
    for(let index = 1; index < arr.length-1;index++){
        geometry.faces.push(new THREE.Face3(index, index+1, 0, normal))
    }
    let material = new THREE.MeshLambertMaterial({
        color: 0x778899,
        side: THREE.DoubleSide
    });

    let mesh = new THREE.Mesh(geometry, material);
    mesh.userData.name = 'plane';
    scene.add(mesh);
}

3.获取鼠标点击位置与绘制面板的相交点

Raycaster类用来协助光线投射,用于鼠标拾取(计算鼠标所在的3d空间中的对象)等。获取相交点的思路是:首先将像素坐标转为二维矢量坐标,然后创建Raycaster对象,根据相机和鼠标位置更新拾取光线,计算场景下的子对象与该射线的相交对象,获得相交对象数组,遍历数组后查询是否存在于绘制面板相交的对象,如果有,则返回该相交对象的点位。

function getIntersect(viewerPoint) {
    let raycaster = new THREE.Raycaster();
    let screen = new THREE.Vector2(
        2 * viewerPoint.x / container.offsetWidth - 1,
        -2 * viewerPoint.y / container.offsetHeight + 1
    );
    //根据相机和鼠标位置更新拾取光线
    raycaster.setFromCamera(screen, camera);
    //计算与拾取光线相交的对象,此时传入的参数为场景下所有的子对象。
    let intersects = raycaster.intersectObjects(scene.children);
   
    if (intersects.length >= 1) {
        var selectedItem = intersects.find((item) => {
            //如果相交的对象里包含name为'plane'的对象,则返回改对象。
            if (item.object.userData && item.object.userData.name == 'plane') {
              return item;
            }
        });
        if(selectedItem) {
            return selectedItem.point;
        } else {
            return null;
        }
    } else {
        return null;
    }
}

4. 绑定绘制事件

function startDrawPolygon(event){
    type = 'area';
    container.addEventListener( 'click', onClickHandler, false );
    container.addEventListener( 'dblclick', stopDraw, false );
}
function onClickHandler(event){
    container.removeEventListener('mousemove', null, false);
    let vector = getIntersect({x: event.x, y: event.y});
    if(vector){
        //如果存在相交点,则加入pointArr数组
        pointArr.push(vector);
    }
    if(type ==='area'){
        drawPoint(); //绘制点击过的点位
        container.addEventListener('mousemove', drawRay, false);//开启跟随鼠标移动的线段的绘制
        drawLine();//完成两个点之间的线段链接
    } else {
        generateCircle(vector);
        container.removeEventListener('click', onClickHandler, false);
        container.addEventListener('mousemove', onMousemoveHandler, false);
    }
}
//绘制跟随鼠标移动发出的射线
function drawRay(event){
    let currentPoint = {x: event.clientX, y: event.clientY};
    let currentVector = getIntersect(currentPoint);
    if(!currentVector) {
        return
    }
    let movingLineGeometry = scene.getObjectByName('movingRay');
    if(!movingLineGeometry) {
        let movingLineGeometry = new THREE.Geometry();
        let material = new THREE.MeshBasicMaterial({
            color: 0x8a2be2,
            side: THREE.DoubleSide
        });
    
        let movingLine = new THREE.Line(movingLineGeometry, material);
        movingLine.userData.name = 'movingRay';
        scene.add(movingLine);
    }
    movingLineGeometry.vertices = [];
    movingLineGeometry.vertices.push(pointArr[pointArr.length - 1]);
    movingLineGeometry.vertices.push(currentVector);
    movingLineGeometry.verticesNeedUpdate = true;
}

5. 绘制点

开启绘制多边形后,每次点击时,需要先将原有的点模型对象从场景中移除,然后,创建geometry,并把最新的顶点加入到geometry的vertices中,然后创建点模型对象,添加到场景中。

function drawPoint(event){
    //判断是否已经存在点模型,如果存在则先删除
    if(scene.getObjectByName('pointsField')) {
       scene.remove(scene.getObjectByName('pointsField'));
    }
    let pointsGeometry = new THREE.Geometry();
    pointArr.map(item => {
        pointsGeometry.vertices.push(item);
    });
    let pointMaterial = new THREE.PointsMaterial({color: 0xffa500, size: 1});
    let pointsField = new THREE.Points(pointsGeometry, pointMaterial);
    pointsField.userData.name = 'pointsField';
    
    scene.add(pointsField);

6. 绘制两点之间的连接线

function drawLine(){
    if(scene.getObjectByName('lineField')) {
        scene.remove(scene.getObjectByName('lineField'));
    }
    let lineGeometry = new THREE.Geometry();
    for(let i = 0; i < pointArr.length; i++) {
        let tmp = pointArr[i];
        lineGeometry.vertices.push(tmp);
    }

    let material = new THREE.MeshBasicMaterial({
        color: 0x00bfff,
        side: THREE.DoubleSide
    });

    let line = new THREE.Line(lineGeometry, material);
    line.userData.name = 'lineField';
    scene.add(line);
}

7.生成多边形

本案例将采用shapeGeometry来进行多边形绘制。

function generatePolygon(){
    let shape = new THREE.Shape();
    shape.moveTo(pointArr[0].x, pointArr[0].y);//将初始点移动到第一个点位置
    for(let i = 1; i < pointArr.length;i++) {
        shape.lineTo(pointArr[i].x, pointArr[i].y);//绘制线
    }
    shape.autoClose = true;//自动闭合
    let planeMeshGeometry = new THREE.ShapeBufferGeometry( shape );
    let material = new THREE.MeshBasicMaterial({
        color: 0xffa500,
        side: THREE.DoubleSide,
        transparent: true,
        opacity: 0.5
    });
    let planeMesh = new THREE.Mesh(planeMeshGeometry, material);
    let points = shape.getPoints();//获取shape的所有点
    let geometryPoints = new THREE.BufferGeometry().setFromPoints( points );//根据点创建geometry
    let frame = new THREE.Line( geometryPoints, new THREE.LineBasicMaterial( { color:  0x00bfff} ) );//创建线模型

    let group = new THREE.Group();
    group.add(planeMesh);
    group.add(frame);
    scene.add(group);
    pointArr = [];
}

8.生成圆

绘制圆需要半径和圆心点位,通过CircleGeometry绘制圆,并把圆的位置放在origin坐标点位置。

function generateCircle(distance,origin){
    if(scene.getObjectByName('circle')){
        scene.remove(scene.getObjectByName('circle'));
    }
    circleGeometry = new THREE.CircleGeometry( distance, 32 );

    let material = new THREE.MeshBasicMaterial( { 
        color: 0xffff00,
        side: THREE.DoubleSide,
        transparent: true,
        opacity: 0.5
    });
    let circle = new THREE.Mesh( circleGeometry, material );
    circle.userData.name = 'circle';
    circle.position.x = origin.x;
    circle.position.y = origin.y;
    circle.position.z = origin.z;
    scene.add( circle );
}

9.优化

在应用上面的方法绘制多边形时,双击会触发单击事件,因此可以通过setTimeout来区分是单击还是双击事件。

let timeout = null;
function onClickHandler(event){
    container.removeEventListener('mousemove', drawRay, false);
   if(timeout) {
       clearTimeout(timeout);
    }
    timeout = window.setTimeout(function(){
        let vector = getIntersect({x: event.x, y: event.y});
        if(vector){
            //如果存在相交点,则加入pointArr数组
           pointArr.push(vector);
       }
        if(type ==='area'){
            drawPoint(); //绘制点击过的点位
            container.addEventListener('mousemove', drawRay, false);//开启跟随鼠标移动的线段的绘制
            drawLine();//完成两个点之间的线段链接
        } else {
            generateCircle(vector);
            container.removeEventListener('click', onClickHandler, false);
             container.addEventListener('mousemove', onMousemoveHandler, false);
        }
     }, 200);
}

三、总结

动态绘制多边形的功能的本质是通过鼠标事件绑定和解绑来进行不同的图形绘制。在绘制多边形时,单击后将绘制点云,再进行mousemove事件添加来进行绘制移动射线,然后在下次单击时将两两点进行连接,鼠标双击后调用绘制多边形的函数来绘制最终形成的多边形。绘制圆时,鼠标单击选中圆心位置,再监听鼠标移动来获取移动位置距离圆心的距离,该距离作为圆的半径来生成圆形。

评论

暂无评论