awv3/dist/three/ringgeometry.js

⚡ AWV3 embedded CAD

'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.default = undefined;

var _assign = require('babel-runtime/core-js/object/assign');

var _assign2 = _interopRequireDefault(_assign);

var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of');

var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);

var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

var _createClass2 = require('babel-runtime/helpers/createClass');

var _createClass3 = _interopRequireDefault(_createClass2);

var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

var _inherits2 = require('babel-runtime/helpers/inherits');

var _inherits3 = _interopRequireDefault(_inherits2);

var _three = require('three');

var THREE = _interopRequireWildcard(_three);

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

//note: number of vertices is constant in order to use the same vertex buffer
var RingGeometry = function (_THREE$BufferGeometry) {
    (0, _inherits3.default)(RingGeometry, _THREE$BufferGeometry);

    function RingGeometry(segments) {
        (0, _classCallCheck3.default)(this, RingGeometry);

        var _this = (0, _possibleConstructorReturn3.default)(this, (RingGeometry.__proto__ || (0, _getPrototypeOf2.default)(RingGeometry)).call(this));

        _this.parameters = {
            thetaSegments: segments,
            innerRadius: 1.0,
            outerRadius: 2.0,
            thetaStart: 0.0,
            thetaLength: 2 * Math.PI
        };

        var vertsCount = (segments + 1) * 2;
        var facesCount = segments * 2;
        _this.setIndex(new THREE.BufferAttribute(new Uint32Array(facesCount * 3), 1));
        _this.addAttribute('position', new THREE.BufferAttribute(new Float32Array(vertsCount * 3), 3));
        _this.addAttribute('normal', new THREE.BufferAttribute(new Float32Array(vertsCount * 3), 3));
        _this.attributes.position.dynamic = true;

        var f = 0;
        for (var i = 0; i < segments; i++) {
            var _arr = [2 * i, 2 * i + 2, 2 * i + 3, 2 * i + 3, 2 * i + 1, 2 * i];

            for (var _i = 0; _i < _arr.length; _i++) {
                var idx = _arr[_i];
                _this.index.array[f++] = idx;
            }
        }var n = 0;
        for (var _i2 = 0; _i2 < vertsCount; _i2++) {
            var _arr2 = [0, 0, 1];

            for (var _i3 = 0; _i3 < _arr2.length; _i3++) {
                var crd = _arr2[_i3];
                _this.attributes.normal.array[n++] = crd;
            }
        }_this.updateParameters(_this.parameters);
        return _this;
    }

    (0, _createClass3.default)(RingGeometry, [{
        key: 'updateParameters',
        value: function updateParameters(newParams) {
            (0, _assign2.default)(this.parameters, newParams);
            var segments = this.parameters.thetaSegments;
            var vertexBuffer = this.attributes.position.array;
            for (var i = 0; i <= segments; i++) {
                var angle = this.parameters.thetaStart + this.parameters.thetaLength * i / segments;
                var cosA = Math.cos(angle),
                    sinA = Math.sin(angle);
                var innerPos = new THREE.Vector3(cosA, sinA, 0).multiplyScalar(this.parameters.innerRadius);
                var outerPos = new THREE.Vector3(cosA, sinA, 0).multiplyScalar(this.parameters.outerRadius);
                vertexBuffer[6 * i + 0] = innerPos.x;
                vertexBuffer[6 * i + 1] = innerPos.y;
                vertexBuffer[6 * i + 2] = innerPos.z;
                vertexBuffer[6 * i + 3] = outerPos.x;
                vertexBuffer[6 * i + 4] = outerPos.y;
                vertexBuffer[6 * i + 5] = outerPos.z;
            }
            this.attributes.position.needsUpdate = true;
            //Note: this update may be done faster:
            this.computeBoundingSphere();
        }
    }]);
    return RingGeometry;
}(THREE.BufferGeometry);

exports.default = RingGeometry;
;