/**
* @module mono
*/
mono = {}
/**
* 数据对象
* @class mono.Data
* @constructor
*
*/
mono.Data = function() {}
mono.Data.prototype = new mono.PropertyChangeDispatcher
/**
* 获取数据对象的名称
* @method getName
* @return {String} 名称
*/
mono.Data.prototype.getName = function() {}
/**
* 获取数据对象的检索ID值
* @method getId
* @return {String} ID
*/
mono.Data.prototype.getId = function() {}
/**
* 设置组的检索ID值
* @method setGroupId
* @param {String} groupId 组的ID值
*/
mono.Data.prototype.setGroupId = function(groupId) {}
/**
* 获取组的检索ID值
* @method getGroupId
* @return {String} 组的检索ID值
*/
mono.Data.prototype.getGroupId = function() {}
/**
* 判断数据对象是否有孩子对象,有则返回true,没有则返回false
* @method hasChildren
* @return {boolean} 数据对象是否有孩子成员,有则为true,反之为false
*/
mono.Data.prototype.hasChildren = function() {}
/**
* 获取当前数据对象的孩子对象集合
* @method getChildren
* @return {List} 数据对象的孩子对象集合
*/
mono.Data.prototype.getChildren = function() {}
/**
* 判断数据对象是否是element的子成员,是则返回true,不是则返回false
* @method isDescendantOf
* @param {Object} element
* @return {boolean} 数据对象是element的子成员则为true,反之为false
*/
mono.Data.prototype.isDescendantOf = function(element) {}
/**
* 获取当前数据对象的父亲对象
* @method getParent
* @return {Object} 父亲对象
*/
mono.Data.prototype.getParent = function() {}
/**
* 设置当前数据对象的父亲对象
* @method setParent
* @param {Object} parent 要设置的父亲对象
*/
mono.Data.prototype.setParent = function(parent) {}
/**
* 为当前数据对象增加子对象
* @method addChild
* @param {Object} child 子对象
* @param {int} index 子对象的位置
* @return {boolean} 子对象增加成功则为true,反之为false
*/
mono.Data.prototype.addChild = function(child, index) {}
/**
* 删除当前数据对象的子对象
* @method removeChild
* @param {Object} child 要删除的子对象
* @return {boolean} 子对象删除成功则为true,反之则为false
*/
mono.Data.prototype.removeChild = function(child) {}
/**
* 设置自定义的属性
* @method setClient
* @param {String} clientProp 自定义的属性名
* @param value 自定义属性的内容
*/
mono.Data.prototype.setClient = function(clientProp, value) {}
/**
* 获取自定义的属性
* @method getClient
* @param {String} clientProp 自定义的属性名
* @return {Object} 自定义属性的内容
*/
mono.Data.prototype.getClient = function(clientProp) {}
/**
* 网元类
* @class mono.Element
* @constructor
*/
mono.Element = function() {}
mono.Element.prototype = new mono.Data
/**
* 判断网元是否可见状态
* @method isVisible
* @return {boolean}
*/
mono.Element.prototype.isVisible = function() {}
/**
* 判断网元是否被选中
* @method isSelectable
* @return {boolean}
*/
mono.Element.prototype.isSelected = function() {}
/**
* 判断网元是否可以被选择的状态
* @method isSelectable
* @return {boolean}
*/
mono.Element.prototype.isSelectable = function() {}
/**
* 判断网元是否可以编辑的状态
* @method isEditable
* @return {boolean}
*/
mono.Element.prototype.isEditable = function() {}
/**
* 判断网元是否为固定尺度
* @method isSizeFixed
* @return {boolean}
*/
mono.Element.prototype.isSizeFixed = function() {}
/**
* 获取网元的告警状态对象,告警状态对象是用于存放网元上的所有告警信息
* @method getAlarmState
* @return {mono.AlarmBox} 告警容器
*/
mono.Element.prototype.getAlarmState = function() {}
/**
* 获取默认的实例对象
* @method getDedaultInstance
* @return {Obejct} 实例对象
*/
mono.Element.prototype.getDefaultInstance = function() {}
/**
* 判断网元的某个样式与之前的样式是否相等
* @method isStyleEquals
* @param {String} style 网元的样式
* @param {String} oldValue 样式的原值
* @param {String} value 样式的当前值
* @return {boolean} 相等则为true,反之为false
*/
mono.Element.prototype.isStyleEquals = function(style, oldValue, value) {}
/**
* 设置网元的样式
* @method setStyle
* @param {String} styleProp 网元的样式名
* @param {String} value 网元样式名对应的样式值
*/
mono.Element.prototype.setStyle = function(styleProp, value) {}
/**
* 获取网元的样式
* @method getStyle
* @param {String} styleProp 网元的样式名
* @param clone 克隆
* @param returnDefaultIfNull 如果为空则返回默认样式
* @return {String} 样式
*/
mono.Element.prototype.getStyle = function(styleProp, clone, returnDefaultIfNull) {}
/**
* 获取指定对象的克隆对象
* @method getCloneObject
* @param {Object} object 欲克隆的对象
* @return {Object} object克隆的对象
*/
mono.Element.prototype.getCloneObject = function(object) {}
/**
* 根据标号获取网元的面
* 对网元对象的面做出标号,对于像cube之类的面做了标号,比如right:0,left:1
* @method getSideIndexMapping
*/
mono.Element.prototype.getSideIndexMapping = function() {}
/**
* 获取网元的默认样式
* @method getDefaultStyle
* @param {String} styleProp 欲获取的样式名
* @param {Object} clone 克隆对象
* @return {String} 样式名对应的样式
*/
mono.Element.prototype.getDefaultStyle = function(styleProp, clone) {}
/**
* 判断是否是面样式
* @method isSideStyle
* @param {String} styleProp 样式名称
* @return {boolean} 是则为true,反之为false
*/
mono.Element.prototype.isSideStyle = function(styleProp) {}
/**
* 设置up方向,默认情况下为{0,1,0}
* @method setUp
* @param {int} x x轴坐标
* @param {int} y y轴坐标
* @param {int} z z轴坐标
*/
mono.Element.prototype.setUp = function(x, y, z) {}
/**
* 获取up方向
* @method getUp
* @return {mono.Vec3} up方向
*/
mono.Element.prototype.getUp = function() {}
/**
* 设置网元的位置
* @method setPosition
* @param {int} x x轴坐标
* @param {int} y y轴坐标
* @param {int} z z轴坐标
*/
mono.Element.prototype.setPosition = function(x, y, z) {}
/**
* 获取网元的位置坐标信息
* @method getPosition
* @return {mono.Vec3} 网元的位置信息
*/
mono.Element.prototype.getPosition = function() {}
/**
* 设置网元的x轴坐标
* @method setPositionX
* @param {int} x x轴坐标
*/
mono.Element.prototype.setPositionX = function(x) {}
/**
* 设置网元的x轴坐标
* @method getPositionX
* @return {int} x轴坐标
*/
mono.Element.prototype.getPositionX = function() {}
/**
* 设置网元的y轴坐标
* @method setPositionY
* @param {int} y y轴坐标
*/
mono.Element.prototype.setPositionY = function(y) {}
/**
* 获取网元的y轴坐标
* @method getPositionY
* @return {int} y y轴坐标
*/
mono.Element.prototype.getPositionY = function() {}
/**
* 设置网元的z轴坐标
* @method setPositionZ
* @param {int} z z轴坐标
*/
mono.Element.prototype.setPositionZ = function(z) {}
/**
* 获取网元的z轴坐标
* @method getPostionZ
* @return {int} z轴坐标
*/
mono.Element.prototype.getPositionZ = function() {}
/**
* 设置网元分别在x轴,y轴,z轴上的缩放比例,默认为(1,1,1)
* scale用于描述原型对象相对于本地坐标系,在x、y、z轴向上的缩放比例,1表示100%无缩放,2表示缩放为200%,
* @method setScale
* @param {float} x x轴缩放比例
* @param {float} y y轴缩放比例
* @param {float} z z轴缩放比例
*/
mono.Element.prototype.setScale = function(x, y, z) {}
/**
* 获取网元的缩放比例
* @method getScale
* @return {mono.Vec3} 网元的缩放比例
*/
mono.Element.prototype.getScale = function() {}
/**
* 设置网元在x轴方向上的缩放比例
* @method setScaleX
* @param {float} x x轴缩放比例
*/
mono.Element.prototype.setScaleX = function(x) {}
/**
* 获取网元在x轴方向上的缩放比例
* @method getScaleX
* @return {float} x轴缩放比例
*/
mono.Element.prototype.getScaleX = function() {}
/**
* 设置网元在y轴方向上的缩放比例
* @method setScaleY
* @param {float} y y轴缩放比例
*/
mono.Element.prototype.setScaleY = function(y) {}
/**
* 获取网元在y轴方向上的缩放比例
* @method getScaleY
* @return {float} y轴缩放比例
*/
mono.Element.prototype.getScaleY = function() {}
/**
* 设置网元在x轴方向上的缩放比例
* @method setScaleZ
* @param {float} z z轴缩放比例
*/
mono.Element.prototype.setScaleZ = function(z) {}
/**
* 获取网元在z轴方向上的缩放比例
* @method getScaleZ
* @return {float} z轴缩放比例
*/
mono.Element.prototype.getScaleZ = function() {}
/**
* 设置网元在x,y,z轴方向上的旋转角度
* @method setRotation
* @param {float}x x轴弧度
* @param {float}y y轴弧度
* @param {float}z z轴弧度
*/
mono.Element.prototype.setRotation = function(x, y, z) {}
/**
* 获取网元的旋转角度
* @method getRotation
* @return {mono.Vec3} 旋转角度
*/
mono.Element.prototype.getRotation = function() {}
/**
* 设置网元在x轴方向上的旋转角度
* @method setRotationX
* @param {float} x x轴方向旋转弧度
*/
mono.Element.prototype.setRotationX = function(x) {}
/**
* 获取网元在x轴方向的旋转角度
* @method getRotationX
* @return {float} x轴方向的旋转弧度
*/
mono.Element.prototype.getRotationX = function() {}
/**
* 设置网元在y轴方向的旋转角度
* @method setRotationY
* @param {float} y y轴方向的旋转弧度
*/
mono.Element.prototype.setRotationY = function(y) {}
/**
* 获取网元在y轴方向的旋转角度
* @method getRotationY
* @return {float} y轴方向的旋转弧度
*/
mono.Element.prototype.getRotationY = function() {}
/**
* 设置网元在z轴方向的旋转角度
* @method setRotationZ
* @param {float} z z轴方向的旋转弧度
*/
mono.Element.prototype.setRotationZ = function(z) {}
/**
* 获取网元在z轴方向的旋转角度
* @method getRotationZ
* @return {float} z轴方向的旋转弧度
*/
mono.Element.prototype.getRotationZ = function() {}
/**
* 通过矩阵来实现变换
* @method applyMatrix
* @param {mono.Mat4} matrix 矩阵
*/
mono.Element.prototype.applyMatrix = function(matrix) {}
/**
* 将网元沿着轴线axis方向移动
* @method translate
* @param {int} distance 移动的距离
* @param {String} axis 移动的轴线
*/
mono.Element.prototype.translate = function(distance, axis) {}
/**
* 沿着x轴方向移动distance距离
* @method translateX
* @param {int} distance 移动的距离
*/
mono.Element.prototype.translateX = function(distance) {}
/**
* 沿着y轴方向移动distance距离
* @method translateY
* @param {int} distance 移动的距离
*/
mono.Element.prototype.translateY = function(distance) {}
/**
* 沿着z轴方向移动distance距离
* @method translateZ
* @param {int} distance 移动的距离
*/
mono.Element.prototype.translateZ = function(distance) {}
/**
* 沿着轴线旋转angle角度
* @method rotateFromAxis
* @param {String} axisDir 轴线名称
* @param {int} axisPosition 轴线位置
* @param {float} angle 旋转的角度
*/
mono.Element.prototype.rotateFromAxis = function(axisDir, axisPosition, angle) {}
/**
* 获取当前网元相对于other对象的相对变换
* @method getRalativeTransform
* @param {TGL.Element} other
*/
mono.Element.prototype.getRelativeTransform = function(other) {}
/**
* 本地坐标系到世界坐标系变换
* @method localToWorld
* @param {mono.Vec3} vector
*/
mono.Element.prototype.localToWorld = function(vector) {}
/**
* 获取网元的前方方向
* @method frontDirection
* @return {mono.Vec3} 前方方向向量
*/
mono.Element.prototype.frontDirection = function(){}
/**
* 世界坐标系到本地坐标系变换
* @method worldToLocal
* @param {mono.Vec3} vector
*/
mono.Element.prototype.worldToLocal = function(vector) {}
/**
* lookAt矩阵
* @method lookAt
* @param {mono.Vec3} vector Camera的位置
* @param {mono,Vec3} up Camera的up方向
*/
mono.Element.prototype.lookAt = function(vector, up) {}
/**
* 迭代器
* @method iterator
* @param {function} callback 回调函数
*/
mono.Element.prototype.iterator = function(callback) {}
/**
* 根据名称获取孩子对象
* @method getChildByName
* @param {String} name 欲获取孩子对象的名称
* @param {boolean} recursive 是否递归查询孩子对象
*/
mono.Element.prototype.getChildByName = function(name, recursive) {}
/**
* 获取网元的子节点
* @method getDescendants
* @param array 子节点存放的数组
* @return array
*/
mono.Element.prototype.getDescendants = function(array) {}
/**
* 克隆网元
* @method clone
* @param object 欲克隆的对象
* @param withGeometry 形状
* @return {Object} 克隆出来的对象
*/
mono.Element.prototype.clone = function(object, withGeometry) {}
/**
* 基本3D物体的父类,其继承于mono.Element类
* @class mono.Node
* @constructor
*/
mono.Node = function() {}
mono.Node.prototype = new mono.Element
/**
* 获取节点的顶点
* @method getVertices
* @return {mono.Vec3} 顶点的坐标
*/
mono.Node.prototype.getVertices = new function(){}
/**
* 获取节点的表面
* @method getFaces
* @return 表面
*/
mono.Node.prototype.getFaces = new function(){}
/**
* 获取孩子的顶点信息
* @method getVerticesWithChildren
* @param {mono.Mat4} matrix 4*4矩阵
* @param {mono.Vec3} vertices 孩子的顶点信息
* @return {mono.Vec3} 孩子的顶点信息
*/
mono.Node.prototype.getVerticesWithChildren = function(matrix, vertices) {}
/**
* 获取孩子的边界框
* @method getBoundingBoxWithChildren
* @param siblings
* @return {mono.BoundingBox} 边界框对象
*/
mono.Node.prototype.getBoundingBoxWithChildren = function(siblings) {}
/**
* 获取边界框
* @method getBoundingBox
* @return {mono.BoundingBox} 边界框
*/
mono.Node.prototype.getBoundingBox = function() {}
/**
* 开始批处理
* @method startBatch
*/
mono.Node.prototype.startBatch = function() {}
/**
* 结束批处理
* @method endBatch
*/
mono.Node.prototype.endBatch = function() {}
/**
* 根据节点的面获取该面所对应的标号
* @method getIndexSideMapping
* @return {int} 标号
*/
mono.Node.prototype.getIndexSideMapping = function() {}
/**
* 根据标号获取节点所对应的面
* @method getSideIndexMapping
* @return 面
*/
mono.Node.prototype.getSideIndexMapping = function() {}
/**
* 实体类,继承于mono.Node类
* @class mono.Entity
* @constructor
* @param {mono.ArrayMaterial} materialSize 材料的尺寸
*/
mono.Entity = function(materialSize) {}
mono.Entity.prototype = new mono.Node
/**
* 设置更新标志
* @method setUpdateFlags
* @param {boolean} flag 标志
*/
mono.Entity.prototype.setUpdateFlags = function(flag) {}
/**
* 设置材料尺寸
* @method setMaterialSize
* @param {mono.ArrayMaterial} materialSize
*/
mono.Entity.prototype.setMaterialSize = function(materialSize){}
/**
* 立方体
* @class mono.Cube
* @constructor
*/
mono.Cube = function() {}
mono.Cube.prototype = new mono.Entity
/**
* 获取立方体的宽度
* @method getWidth
* @return {int} 宽度
*/
mono.Cube.prototype.getWidth = new function() {}
/**
* 获取立方体的高度
* @method getHeight
* @return {int} 高度
*/
mono.Cube.prototype.getHeight = new function() {}
/**
* 获取立方体的深度
* @method getDepth
* @return {int} 深度
*/
mono.Cube.prototype.getDepth = new function() {}
/**
* 根据标号获取立方体的面
* @method getSideIndexMapping
* return {int} 标号
*/
mono.Cube.prototype.getSideIndexMapping = function() {}
/**
* 球体
* @class mono.Sphere
* @constructor
*/
mono.Sphere = function() {}
mono.Sphere.prototype = new mono.Entity
/**
* 获取球体的半径
* @method getRadius
* @return {float} 半径
*/
mono.Sphere.prototype.getRadius = new function() {}
/**
* 获取球体的横向切片数量,默认值22
* @method getSegmentsW
* @return {int} 横向切片的数量
*/
mono.Sphere.prototype.getSegmentsW = new function() {}
/**
* 获取球体的纵向切片数量,默认值15
* @method getSegmentsH
* @return {int} 纵向切片的数量
*/
mono.Sphere.prototype.getSegmentsH = new function() {}
/**
* 设置球体的横向切片数量,默认值22
* @method setWidthSegments
* @param {int} segmentsW 切片数量
*/
mono.Sphere.prototype.setWidthSegments = function(segmentsW){}
/**
* 设置球体的纵向切片数量,默认值22
* @method setHeightSegments
* @param {int} segmentsH 切片数量
*/
mono.Sphere.prototype.setHeightSegments = function(segmentsH){}
/**
* 平面
* @class mono.Plane
* @constructor
*/
mono.Plane = function() {}
mono.Plane.prototype = new mono.Entity
/**
* 克隆
* @method clone
* @return {TGL.Plane} 克隆的对象
*/
mono.Plane.prototype.clone = function() {}
/**
* 圆柱体
* @class mono.Cylinder
* @constructor
*/
mono.Cylinder = function() {}
mono.Cylinder.prototype = new mono.Entity
/**
* 获取圆柱顶端的半径
* @method getRadiusTop
* @return {float} 半径
*/
mono.Cylinder.prototype.getRadiusTop = new function() {}
/**
* 获取圆柱底端的半径
* @method getRadiusBottom
* @return {float} 半径
*/
mono.Cylinder.prototype.getRadiusBottom = new function() {}
/**
* 获取圆柱的高度
* @method getHeight
* @return {int} 高度
*/
mono.Cylinder.prototype.getHeight = new function() {}
/**
* 获取圆柱体的环绕切片数量
* @method getSegmentsR
* @return {int} 切片数量
*/
mono.Cylinder.prototype.getSegmentsR = new function() {}
/**
* 获取圆柱体的纵向切片数量
* @method getSegmentsH
* @return 切片数量
*/
mono.Cylinder.prototype.getSegmentsH = new function() {}
/**
* 获取圆柱体上面是否开口状态
* @method getOpenTop
* @return {boolean} 开口状态
*/
mono.Cylinder.prototype.getOpenTop = new function() {}
/**
* 获取圆柱体下面是否开口状态
* @method getOpenBottom
* @return {boolean} 开口状态
*/
mono.Cylinder.prototype.getOpenBottom = new function() {}
/**
* 获取圆柱体的圆弧长度
* @method getArcLength
* @return {float} 弧长
*/
mono.Cylinder.prototype.getArcLength = new function() {}
/**
* 获取圆柱体圆弧的起始位置
* @method getArcStart
* @return {mono.Vec3} 起始位置
*/
mono.Cylinder.prototype.getArcStart = new function() {}
/**
* 判断圆柱体上面是否为开口状态
* @method isOpenTop
* @return {boolean} 开口状态
*/
mono.Cylinder.prototype.isOpenTop = new function() {}
/**
* 判断圆柱体下面是否为开口状态
* @method isOpenBottom
* @return {boolean} 开口状态
*/
mono.Cylinder.prototype.isOpenBottom = new function() {}
/**
* 根据标号获取圆柱体的面
* @method getSideIndexMapping
* @return {Object} 圆柱体对应编号的面
*/
mono.Cylinder.prototype.getSideIndexMapping = function() {}
/**
* 球形
* @class mono.Circle
* @constructor
*/
mono.Circle = function() {}
mono.Circle.prototype = new mono.Entity
/**
* 克隆
* @method clone
* @return {mono.Circle} 克隆的对象
*/
mono.Circle.prototype.clone = function() {}
/**
* 圆环
* @class mono.Torus
* @constructor
*/
mono.Torus = function() {}
mono.Torus.prototype = new mono.Entity
/**
* 获取圆环的半径尺寸
* @method getRadius
* @return {float} 圆环的半径
*/
mono.Torus.prototype.getRadius = new function() {}
/**
* 获取圆环的横切面圆弧的半径尺寸
* @method getTude
* @return {float} 半径
*/
mono.Torus.prototype.getTube = new function() {}
/**
* 获取圆环的分片数量,默认值8
* @method getSegmentsR
* @return {int} 分片数量
*/
mono.Torus.prototype.getSegmentsR = new function() {}
/**
* 获取圆环横切面圆弧的分片数量,默认值6
* @method getSegmentsT
* @return {int} 分片数量
*/
mono.Torus.prototype.getSegmentsT = new function() {}
/**
* 获取弧度
* @method getArc
* @return {float} 弧度
*/
mono.Torus.prototype.getArc = new function() {}
/**
* 箭头
* @class mono.Arrow
* @constructor
*/
mono.Arrow = function() {}
mono.Arrow.prototype = new mono.Entity
/**
* 缓冲节点
* @class mono.BufferNode
* @constructor
*/
mono.BufferNode = function() {}
mono.BufferNode.prototype = new mono.Node
/**
* 通过矩阵来实现变换
* @method applyMatrix
* @param {mono.Mat4} matrix 矩阵
*/
mono.BufferNode.prototype.applyMatrix = function(matrix) {}
/**
* 正常化法线
* @method normalizeNormals
*/
mono.BufferNode.prototype.normalizeNormals = function() {}
/**
* 克隆
* @method clone
* @return {mono.BufferNode} 克隆的对象
*/
mono.BufferNode.prototype.clone = function() {}
/**
* Particle(粒子)对象
* @class mono.Particle
* @constructor
* @param {Array} vertices 顶点
* @param {Array} colors 颜色
* @param {String} material 材质
*/
mono.Particle = function(vertices,colors, material) {}
mono.Particle.prototype = new mono.Node
/**
* 对象克隆
* @method clone
* @param {mono.Element} element 被克隆的对象
*/
mono.Particle.prototype.clone = function(element) {}
/**
* 线条
* @class mono.Line
* @constructor
* @param {Array} vertices 顶点
* @param {Array} colors 颜色
* @param {String} material 材质
* @param {Object} type 类型
*/
mono.Line = function (vertices,colors,material, type) {}
mono.Line.prototype = new mono.Node()
/**
* 对象克隆
* @method clone
* @param {mono} element 被克隆的对象
*/
mono.Line.prototype.clone = function(element) {}
/**
* Path(路径)对象
* @class mono.Path
* @constructor
* @param {Array} points 点的集合
*/
mono.Path = function(points) {}
mono.Path.prototype = new mono.CurvePath() {}
/**
* 创建直线并连接所有的点
* @method fromPoints
* @param {Array} vectors mono.Vec3类型的数组
*/
mono.Path.prototype.fromPoints = function(vectors)
/**
* 让路径反向
* @method reverse
* @return {mono.Path}返回反向后的Path对象
*/
mono.Path.prototype.reverse = function() {}
/**
* 移动到一个坐标点
* method moveTo
* @param {Number} x x坐标
* @param {Number} y y坐标
* @param {Number} z z坐标
* @return {mono.Path} 返回Path对象
*/
mono.Path.prototype.moveTo = function(x, y, z) {}
/**
* 移动到某个位置
* @method lineTo
* @param {Number} x x坐标
* @param {Number} y y坐标
* @param {Number} z z坐标
*/
mono.Path.prototype.lineTo = function(x, y, z) {}
/**
* 在当前的路径中增加一个二次方贝塞尔控制点
* @method curveTo
* @param {Number} aCPx 贝塞尔控制点的x坐标
* @param {Number} aCPy 贝塞尔控制点的y坐标
* @param {Number} aCPz 贝塞尔控制点的z坐标
* @param {Number} aX 结束点的x坐标
* @param {Number} aY 结束点的y坐标
* @param {Number} aZ 结束点的z坐标
*/
mono.Path.prototype.curveTo = function(aCPx, aCPy, aCPz, aX, aY, aZ) {}
/**
* 判断当前的路径是否是顺时针
* @method isClockwise
* @return {Boolean} 如果为顺时针返回true,如果为逆时针返回false
*/
mono.Path.prototype.isClockwise = function() {}
/**
* 在当前的路径中增加一个三次方贝塞尔控制点
* @method bCurveTo
* @param {Number} aCP1x 第一个贝塞尔控制点的x坐标
* @param {Number} aCP1y 第一个贝塞尔控制点的y坐标
* @param {Number} aCP1z 第一个贝塞尔控制点的z坐标
* @param {Number} aCP2x 第二个贝塞尔控制点的x坐标
* @param {Number} aCP2y 第二个贝塞尔控制点的y坐标
* @param {Number} aCP2z 第二个贝塞尔控制点的z坐标
* @param {Number} aX 结束点的x坐标
* @param {Number} aY 结束点的y坐标
* @param {Number} aZ 结束点的z坐标
*/
mono.Path.prototype.bCurveTo = function(aCP1x, aCP1y, aCP1z, aCP2x, aCP2y, aCP2z, aX, aY, aZ) {}
/**
* Path中点的连接方式,如[’moveTo', 'lineTo', 'quadraticCurveTo']
* @method toArray
* @return {Array} 路径中点的连接方式
*/
mono.Path.prototype.toArray = function() {}
/**
* 把mono.Path转换为shape
* @method toShapes
* @param {Boolean} isCCW 如果为true,按顺时针转换,如果为false,按逆时针转换
*/
mono.Path.prototype.toShapes = function(isCCW) {}
/**
* PathNode对象
* @class mono.PathNode
* @constructor
* @param {mono.Path} path mono.Path对象
* @param {Number} segments 切片数
* @param {Number} radius 圆管的半径
* @param {Number} segmentsR 圆管的切片数
* @param {String} startCap 起始端线帽的样式
* @param {String} endCap 结束端线帽的样式
* @param {mono.Shape} shape Shape对象
* @param {Number} arc 弧度数
* @param {Number} arcStart 起始弧度
* @param {Number} cutSurface 切面类型 ,可以取值为'none','plain','center'
*/
mono.PathNode = function(path, segments, radius, segmentsR, startCap, endCap, shape, arc, arcStart, cutSurface) {}
mono.PathNode.prototype = new mono.Entity
/**
* 调整路径
* @method adjustPath
* @param {mono.Path} path Path对象
* @param {Number} radius 半径
* @param {Number} times 次数
*/
mono.PathNode.prototype.adjustPath = function(path, radius, times) {}
/**
* 返回mono.Path对象
* @method getPath
* return {mono.Path} Path对象
*/
mono.PathNode.prototype.getPath = function() {}
/**
* 设置路径
* @method setPath
* @param {mono.Path} path Path对象
*/
mono.PathNode.prototype.setPath = function(path) {}
/**
* 获取切片数
* @method getSegments
* @ return {Number} 切片数
*/
mono.PathNode.prototype.getSegments = function() {}
/**
* 设置切片数
* @method setSegments
* @param {Number} segments 切片数
*/
mono.PathNode.prototype.setSegments = function(segments) {}
/**
* 获取半径(圆管的半径)
* @method getRadius
* @return {Number} 半径
*/
mono.PathNode.prototype.getRadius = function() {}
/**
* 设置半径(圆管的半径)
* @method setRadius
* @param {Number} radius 半径
*/
mono.PathNode.prototype.setRadius = function(radius) {}
/**
* 圆管的切片数
* @method getSegmentsR
* @return {Number} 切片数
*/
mono.PathNode.prototype.getSegmentsR = function() {}
/**
* 设置圆管的切片数
* @method setSegmentsR
* @param {Number} segmentsR 切片数
*/
mono.PathNode.prototype.setSegmentsR = function(segmentsR) {}
/**
* 获取起始端线帽的样式
* @method getStartCap
* @return {String} 线帽样式
*/
mono.PathNode.prototype.getStartCap = function() {}
/**
* 设置起始端线帽的样式
* @method setStartCap
* @param {String} startCap 线帽样式
*/
mono.PathNode.prototype.setStartCap = function(startCap) {}
/**
* 获取结束端线帽的样式
* @method getEndCap
*/
mono.PathNode.prototype.getEndCap = function() {}
/**
* 设置结束端线帽的样式
* @method setEndCap
* @param {String} endCap 线帽样式
*/
mono.PathNode.prototype.setEndCap = function(endCap) {}
/**
* 获取Shape对象
* @method getShape
* @return {mono.Shape} Shape对象
*/
mono.PathNode.prototype.getShape = function() {}
/**
* 设置Shape对象
* @method setShape
* @param {mono.Shape} shape Shape对象
*/
mono.PathNode.prototype.setShape = function(shape) {}
/**
* 获取起始端线帽的数量
* @method getStartCapSize
* @return {Number} 线帽的数量
*/
mono.PathNode.prototype.getStartCapSize = function() {}
/**
* 设置起始端线帽的数量
* @method setStartCapSize
* @param {Number} startCapSize 线帽的数量
*/
mono.PathNode.prototype.setStartCapSize = function(startCapSize) {}
/**
* 获取结束端线帽的数量
* @method getEndCapSize
* @return {Number} 线帽的数量
*/
mono.PathNode.prototype.getEndCapSize = function() {}
/**
* 设置结束端线帽的数量
* @method setEndCapSize
* @param {Number} endCapSize
*/
mono.PathNode.prototype.setEndCapSize = function(endCapSize) {}
/**
* 获取线帽的切片数
* @method getSegmentsCap
* @return {Number} 线帽的切片数
*/
mono.PathNode.prototype.getSegmentsCap = function() {}
/**
* 设置线帽的切片数
* @method setSegmentsCap
* @param {Number} segmentsCap 切片数
*/
mono.PathNode.prototype.setSegmentsCap = function(segmentsCap) {}
/**
* 获取弧度
* @method getArc
* @return {Number} 弧度
*/
mono.PathNode.prototype.getArc = function() {}
/**
* 设置弧度
* @method setArc
* @param {Number} arc 弧度
*/
mono.PathNode.prototype.setArc = function(arc) {}
/**
* 获取起始弧度
* @method getArcStart
* @return {Number} 弧度
*/
mono.PathNode.prototype.getArcStart = function() {}
/**
* 设置起始弧度
* @method setArcStart
* @param {Number} arcStart 起始弧度
*/
mono.PathNode.prototype.setArcStart = function(arcStart) {}
/**
* 获取切面的类型
* @method getCutSurface
* @return {String} 切面的类型
*/
mono.PathNode.prototype.getCutSurface = function() {}
/**
* 设置切面的类型
* @method setCutSurface
* @param {String} cutSurface 切面的类型
*/
mono.PathNode.prototype.setCutSurface = function(cutSurface) {}
/**
* PathCube对象
* @class mono.PathCube
* @constructor
* @param {mono.Path} path Path对象
* @param {Number} width 宽度
* @param {Number} height 高度
* @param {Number} curveSegements 曲线的切片数
* @param {Number} repeat 重复次数
*/
mono.PathCube = function(path, width, height, curveSegements, repeat) {}
mono.PathCube.prototype = new mono.Entity
/**
* 获取PathCube.SideIndexMapping对象
* @method getSideIndexMapping
* @return {mono.PathCube.SideIndexMapping} PathCube.SideIndexMapping对象
*/
mono.PathCube.prototype.getSideIndexMapping = function() {}
/**
* 克隆点
* @method clonePoints
* @param {Array} points
* @return {Array} 返回克隆后的点
*/
mono.PathCube.prototype.clonePoints = function(points) {}
/**
* ShapeNode对象
* @class mono.ShapeNode
* @constructor
* @param {Array}or{mono.Path} shapes 形状
* @param {Number} curveSegments 曲线的切片数
* @param {Number} amount ShapeNode的厚度
* @param {Boolean} vertical 是否竖直方向
* @param {Number} repeat 重复次数
* @param {Object} zMinusHalfAmount
*/
mono.ShapeNode = function(shapes, curveSegments, amount, vertical, repeat, zMinusHalfAmount) {}
mono.ShapeNode.prototype = new mono.Entity
/**
* 获取Shape对象数组
* @method getShapes
* @return [Array] 形状
*/
mono.ShapeNode.prototype.getShapes = function() {}
/**
* 设置形状
* @method setShapes
* @param {Array} shapes Shape对象数组
*/
mono.ShapeNode.prototype.setShapes = function(shapes) {}
/**
* 获取曲线的切片数
* @method getCurveSegments
* @return {Number} 切片数
*/
mono.ShapeNode.prototype.getCurveSegments = function() {}
/**
* 设置曲线的切片数
* @method setCurveSegments
* @param {Number} curveSegments 曲线的切片数
*/
mono.ShapeNode.prototype.setCurveSegments = function(curveSegments) {}
/**
* ShapeNode的厚度
* @method getAmount
* @return {Number} 厚度
*/
mono.ShapeNode.prototype.getAmount = function() {}
/**
* 设置ShapeNode厚度
* @method setAmount
* @param {Number} amount 厚度
*/
mono.ShapeNode.prototype.setAmount = function(amount) {}
/**
* 是否竖直方向
* @method isVertical
* @return {Boolean} 如果是竖直方向,返回true,否则返回false
*/
mono.ShapeNode.prototype.isVertical = function() {}
/**
* 设置是否竖直
* @method setVertical
* @param {Boolean} vertical 如果为true,竖直,如果为false,则水平
*/
mono.ShapeNode.prototype.setVertical = function(vertical) {}
/**
* @method addShapes
* @param {Array} shapes Shape对象数组
* @param {Object} options 格式为{curveSegments : curveSegments, amount : amount,vertical : vertical, zMinusHalfAmount : zMinusHalfAmount, repeat : repeat || 20}
*/
mono.ShapeNode.prototype.addShapes = function(shapes, options) {}
/**
*
* @method addShape
* @param {mono.Shape} shape Shape对象
* @param {Object} options options 格式为{curveSegments : curveSegments, amount : amount,vertical : vertical, zMinusHalfAmount : zMinusHalfAmount, repeat : repeat || 20,}
* @param {Object} scope 作用域,为空时指的是window
*/
mono.ShapeNode.prototype.addShape = function(shape, options, scope) {}
/**
* TextNode(文本)对象
* @class mono.TextNode
* @constructor
* @param {String} text 文本内容
* @param {Number} size 字号
* @param {Number} height 字体宽度
* @param {String} font 字体
* @param {String} weight 字体的weight
* @param {String} style 字体的样式
* @param {Number} curveSegments 曲线的切片数
* @param {Boolean} bevelEnabled 能否倾斜
*/
mono.TextNode = function (text, size,height,font,weight,style,curveSegments,bevelEnabled) {}
mono.TextNode.prototype = new mono.ShapeNode
/**
* 获取文本内容
* @method getText
* @return {String} 文本内容
*/
mono.TextNode.prototype.getText = function() {}
/**
* 设置文本内容
* @method setText
* @param {String} text
*/
mono.TextNode.prototype.setText = function(text) {}
/**
* 获取字号
* @method getSize
* @retrun {Number} 字号
*/
mono.TextNode.prototype.getSize = function() {}
/**
* 设置字号
* @method setSize
* @param {Number} size
*/
mono.TextNode.prototype.setSize = function(size) {}
/**
* 获取字体的高度
* @method getHeight
* @return {Number} 字体高度
*/
mono.TextNode.prototype.getHeight = function() {}
/**
* 设置字体的高度
* @method setHeight
* @param {Number} height
*/
mono.TextNode.prototype.setHeight = function(height) {}
/**
* 获取字体
* @method getFont
* @return {String} 字体
*/
mono.TextNode.prototype.getFont = function() {}
/**
* 设置字体
* @method setFont
* @param {String} font
*/
mono.TextNode.prototype.setFont = function(font) {}
/**
* 获取字体的weight
* @method getWeight
* @return {String} 字体的weight
*/
mono.TextNode.prototype.getWeight = function() {}
/**
* 设置字体的weight
* @method setWeight
* @param {String} weight
*/
mono.TextNode.prototype.setWeight = function(weight) {}
/**
* 获取字体的样式
* @method getFontStyle
* @return {String} 字体的样式
*/
mono.TextNode.prototype.getFontStyle = function() {}
/**
* 设置字体的样式
* @method setFontStyle
* @param {String} fontStyle 字体的样式
*/
mono.TextNode.prototype.setFontStyle = function(fontStyle) {}
/**
* LatheNode(车削)对象
* @class mono.LatheNode
* @constructor
* @param {mono.Path} path
* @param {Number} segmentsH
* @param {Number} segmentsR
* @param {Number} arc
* @param {Boolean} startClosed
* @param {Boolean} endClosed
*/
mono.LatheNode = function(path, segmentsH, segmentsR,arc, startClosed, endClosed) {}
mono.LatheNode.prototype = new mono.Entity
/**
* 获取Path
* @method getPath
* @return {mono.Path} Path对象
*/
mono.LatheNode.prototype.getPath = function() {}
/**
* 设置Path
* @method setPath
* @param {mono.Path} path Path对象
*/
mono.LatheNode.prototype.setPath = function(path) {}
/**
* 获取车削中纬度方向的切片数
* @method getSegmentsH
* @return {Number} 切片数
*/
mono.LatheNode.prototype.getSegmentsH = function() {}
/**
* 设置车削中纬度方向的切片数
* @method setSegmentsH
* @param {Number} segmentsH
*/
mono.LatheNode.prototype.setSegmentsH = function(segmentsH) {}
/**
* 车削中经度方向的切片数
* @method getSegmentsR
* @return {Number} 切片数
*/
mono.LatheNode.prototype.getSegmentsR = function() {}
/**
* 设置车削中经度方向的切片数
* @method setSegmentsR
* @param {Number} segmentsR 切片数
*/
mono.LatheNode.prototype.setSegmentsR = function(segmentsR) {}
/**
* 获取弧度
* @method getArc
* @return {Number} 弧度
*/
mono.LatheNode.prototype.getArc = function() {}
/**
* 设置弧度
* @method setArc
* @param {Number} arc 弧度
*/
mono.LatheNode.prototype.setArc = function(arc) {}
/**
* 起始处是否闭合
* @method isStartClosed
* @return {Boolean} 如果为true,闭合,否则不闭合
*/
mono.LatheNode.prototype.isStartClosed = function() {}
/**
* 设置起始处是否闭合
* @method setStartClosed
* @param {Boolean} startClosed 如果为true,闭合,否则不闭合
*/
mono.LatheNode.prototype.setStartClosed = function(startClosed) {}
/**
* 结束处是否闭合
* @method isEndClosed
* @return {Boolean} 如果为true,闭合,否则不闭合
*/
mono.LatheNode.prototype.isEndClosed = function() {}
/**
* 设置结束处是否闭合
* @method setEndClosed
* @param {Boolean} endClosed 如果为true,闭合,否则不闭合
*/
mono.LatheNode.prototype.setEndClosed = function(endClosed) {}
/**
* CurvePlane(曲面)对象
* @class mono.CurvePlane
* @constructor
* @param {mono.Path} pathH 水平方向的Path
* @param {mono.Path} pathV 竖直方向的Path
* @param {Number} segmentsH 水平方向的切片数
* @param {Number} segmentsV 竖直方向的切片数
*/
mono.CurvePlane = function(pathH,pathV,segmentsH,segmentsV) {}
mono.CurvePlane.prototype = new mono.Entity
/**
* ComboNode(组合)对象
* @class mono.ComboNode
* @constructor
* @param {Array} combos 组合对象的数组
* @param {Array} operators 操作对象的数组
*/
mono.ComboNode = function(combos, operators) {}
mono.ComboNode.prototype = new mono.Entity
/**
* 数据容器是用于管理数据对象的。它是一种不可见的对象,在MVC框架中处于M(模型)层,它是所有视图的数据提供者
* 数据容器可以管理数据对象的增减事件变化,也可以监听到数据的属性事件变化。
* 数据容器上包含着选择容器,用于管理所有选中的数据
* @class mono.DataBox
* @constructor
* @param {String} name
* @return {mono.DataBox}
*/
mono.DataBox = function(name) {}
mono.DataBox.prototype = new mono.PropertyChangeDispatcher
/**
* 返回数据容器的名字
* @method getName
* return {String} 数据容器的名字
*/
mono.DataBox.prototype.getName = function() {}
/**
* 往数据容器中添加一个数据
* @method add
* @param {mono.Data} data 数据对象
* @param {String} index 添加的数据的次序
*/
mono.DataBox.prototype.add = function(data, index) {}
/**
* 如果节点有孩子,就把节点的孩子添加到数据容器中
* @method addByDescendant
* @param {mono.Data} data 数据对象
*/
mono.DataBox.prototype.addByDescendant = function(data) {}
/**
* 获取网元容器中的告警容器
* @method getAlarmBox
* @return {mono.AlarmBox} 告警容器
*/
mono.DataBox.prototype.getAlarmBox = function() {}
/**
* 通过数据的ID编号从数据容器中删除该数据
* @method removeById
* @param {Object} id 数据对象的编号
*/
mono.DataBox.prototype.removeById = function(id) {}
/**
* 从数据容器中删除某个数据
* @method remove
* @param {mono.Data} data 数据对象
*/
mono.DataBox.prototype.remove = function(data) {}
/**
* 通过数据ID判断是否包含某个数据
* @method containsById
* @param {Object} id 数据的ID编号、
* @return {Boolean} true为包含,false不包含
*/
mono.DataBox.prototype.containsById = function(id) {}
/**
* 判断是否包含某个数据
* @method contains
* @param {mono.Data} data
* @return {Boolean} true为包含,false不包含
*/
mono.DataBox.prototype.contains = function(data) {}
/**
* 数据容器的大小,也就是容器中数据的数量
* @method size
* @return {Number} 数据容器的大小
*/
mono.DataBox.prototype.size = function() {}
/**
* 数据容器中光源的数量
* method lightsSize
* @return {Number} 数据容器光源的数量
*/
mono.DataBox.prototype.lightsSize = function() {}
/**
* 获取数据容器中所有的光源
* @method getLights
* @return {mono.List} 数据容器中的光源
*/
mono.DataBox.prototype.getLights = function() {}
/**
* 获取数据容器中所有的光源
* @method getLightsArray
* @return {Array} 数据容器中的光源
*/
mono.DataBox.prototype.getLightsArray = function() {}
/**
* 清空数据容器中所有的数据
* @method clear
*/
mono.DataBox.prototype.clear = function() {}
/**
* 开始批处理
* @method startBatch
*/
mono.DataBox.prototype.startBatch = function() {}
/**
* 结束批处理
* @method endBatch
*/
mono.DataBox.prototype.endBatch = function() {}
/**
* 删除所有选中的数据
* @method removeSelection
*/
mono.DataBox.prototype.removeSelection = function() {}
/**
* 取消选中
* @method clearSelection
*/
mono.DataBox.prototype.clearSelection = function() {}
/**
* 取消编辑
* @method clearEditing
*/
mono.DataBox.prototype.clearEditing = function() {}
/**
* 根据数据的ID编号获取对应的数据
* @method getDataById
* @param {Object} id 数据的ID编号
* @return {mono.Data} 数据对象
*/
mono.DataBox.prototype.getDataById = function(id) {}
/**
* 添加数据容器的数据增减变化的监听器。当数据容器中的数据发生改变时(增加,删除,清空),就可以通过此方法监听
* @method addDataBoxChangeListener
* @param {Function} listener 网元更改事件的监听器
* @param {Object} scope 监听器的作用域,为空时指的是window
* @param {Boolean} ahead 是否添加在最前方,如果为空,则添加在最后一个位置
*/
mono.DataBox.prototype.addDataBoxChangeListener = function(listener, scope, ahead) {}
/**
* 移除数据容器的数据增减变化的监听器
* @method removeDataBoxChangeListener
* @param {Function} listener 网元更改事件监听器
* @param {Object} scope 监听器的作用域,为空时指的是window
*/
mono.DataBox.prototype.removeDataBoxChangeListener = function(listener, scope) {}
/**
* 添加数据容器中数据的属性更改事件的监听器。当数据容器中的数据属性发生变化时,比如网元位置,网元名称等,都可以通过此方法来监听
* @method addDataPropertyChangeListener
* @param {Function} listener 网元属性更改事件的监听器
* @param {Object} scope 监听器的作用域,为空时指的是window
* @param {Object} ahead 是否添加在最前方,如果为空,则添加在最后一个位置
*/
mono.DataBox.prototype.addDataPropertyChangeListener = function(listener, scope, ahead) {}
/**
* 移除数据容器中数据的属性更改事件的监听器
* @method removeDataPropertyChangeListener
* @param {Function} listener 网元属性更改事件的监听器
* @param {Object} scope 监听器的作用域,为空时指的是window
*/
mono.DataBox.prototype.removeDataPropertyChangeListener = function(listener, scope) {}
/**
* 获取数据容器中的选择容器,选择容器用于存放所有选中的数据对象,更详细的解释请参看SelectionModel类
* @method getSelectionModel
* @return {mono.SelectionModel} 选中数据的容器
*/
mono.DataBox.prototype.getSelectionModel = function() {}
/**
* 数据容器的大小,也就是容器中数据的数量
* @method size
* @return {Number} 数据容器的大小
*/
mono.DataBox.prototype.size = function() {}
/**
* 判断数据容器是否为空。当数据容器中没有数据时返回true,否则返回false
* @method isEmpty
* @return {Boolean} 当数据容器中没有数据时返回true,否则返回false
*/
mono.DataBox.prototype.isEmpty = function() {}
/**
* 获取数据容器的上限数。默认为-1,是没有上限的,一旦设置了上限数,当添加的数据数量大于这个上限数时,mono就会删除最旧的数据
* @method getLimit
* @return {Number} 数据容器的上限数
*/
mono.DataBox.prototype.getLimit = function() {}
/**
* 设置数据容器的上限数。默认为-1,是没有显示的,一旦设置了上限数,当添加的数据数量大于这个上限数时,mono就会删除最旧的数据
* @method setLimit
* @param {Number} limit
*/
mono.DataBox.prototype.setLimit = function(limit) {}
/**
* 从数据容器中删除第一个数据
* @method removeFirst
* @param {Number} count 数据容器的大小
*/
mono.DataBox.prototype.removeFirst = function(count) {}
/**
* 获取指定数据的所有兄弟数据
* @method getSiblings
* @param {mono.Data} data 指定的数据对象
* @return {mono.List} 所有兄弟数据的集合
*/
mono.DataBox.prototype.getSiblings = function(data) {}
/**
* 获取数据容器中所有根下的数据。根下的数据指的是没有父亲的数据
* @method getRoots
* @return {mono.List} 所有根下数据的集合
*/
mono.DataBox.prototype.getRoots = function() {}
/**
* 获取指定数据在兄弟数据中的序号
* @method getSiblingIndex
* @param {mono.Data} data
* @return {Number} 数据对象的序号
*/
mono.DataBox.prototype.getSiblingIndex = function(data) {}
/**
* 获取数据容器中的所有节点对象
* @method getNodes
* @return {mono.List}
*/
mono.DataBox.prototype.getNodes = function() {}
/**
* 获取数据容器中的所有Billboard对象
* @method getBillboards
* @return {mono.List}
*/
mono.DataBox.prototype.getBillboards = function() {}
/**
* 获取数据容器中的所有数据
* @method getDatas
* @return {mono.List}
*/
mono.DataBox.prototype.getDatas = function() {}
/**
* 获取数据容器中某个序号上的数据
* @method getDataAt
* @param {Object} index 数据的序号
* @return {mono.Data} 数据对象
*/
mono.DataBox.prototype.getDataAt = function(index) {}
/**
* 将数据容器中的数据转成集合
* @method toDatas
* @param {Object} matchFunction 转换成List集合时回调函数
* @param {Object} scope 回调函数的作用域,为空时指的是window
* @return {mono.List} 数据集合
*/
mono.DataBox.prototype.toDatas = function(matchFunction, scope) {}
/**
* 遍历数据容器中的所有数据
* @method forEach
* @param {Function} f 回调函数
* @param {Object} scope 回调函数的作用域,为空时指的是window
*/
mono.DataBox.prototype.forEach = function(f, scope) {}
/**
* 反序遍历数据容器中所有数据
* @method forEachReverse
* @param {Function} f 回调函数
* @param {Object} scope 回调函数的作用域,为空时指的是window
*/
mono.DataBox.prototype.forEachReverse = function(f, scope) {}
/**
* 深度优先遍历数据容器中指定数据的所有子孙数据。如果指定数据为空时,就会遍历数据容器中的所有数据
* @method forEachByDepthFirst
* @param {Function} callbackFunction 回调函数
* @param {mono.Data} data 遍历的数据对象,为空时会遍历数据容器中的所有数据
* @param {Object} scope 回调函数的作用域,为空时指的是window
*/
mono.DataBox.prototype.forEachByDepthFirst = function(callbackFunction, data, scope) {}
/**
* 广度优先遍历数据容器中指定数据的所有子孙数据。如果指定数据为空时,就会遍历数据容器中的所有数据
* @method forEachByBreadthFirst
* @param {Function} callbackFunction 回调函数
* @param {mono.Data} data 数据对象
* @param {Object} scope 回调函数的作用域,为空时指的是window
*/
mono.DataBox.prototype.forEachByBreadthFirst = function(callbackFunction, data, scope) {}
mono.Defaults = {}
/**
* mono中的工具类,提供了一些常用的方法
* @class mono.Utils
* @constructor
*/
mono.Utils = {}
/**
* 判断一个数是否是2的幂次方
* @method isPowerOfTwo
* @static
* @param {Number} value 数值
* @return {Boolean} 如果为true,则是2的幂次方,否则不是2的幂次方
*/
mono.Utils.isPowerOfTwo = function(value) {}
/**
* 创建1个新的Element对象
* @method createElement
* @static
* @param {mono.Element} element1 Element对象
* @param {mono.Element} element2 Element对象
* @param {String} material 材质的url路径
* @param {Number} materialIndexOffset 偏移量
* @return {mono.Element} Element对象
*/
mono.Utils.createElement = function(element1, element2, material, materialIndexOffset) {}
/**
* 如果参数clone为true,克隆一个对象,否则对element进行transform操作
* @method transformElement
* @static
* @param {mono.Element} element Element对象
* @param {Boolean} clone 如果为true,重新创建一个对象,如果为false,否则对element进行transform操作
* @return {mono.Element} Element对象
*/
mono.Utils.transformElement = function(element, clone) {}
/**
* 把element2合并到element1
* @method mergeElement
* @static
* @param {mono.Elment} element1 Element对象
* @param {mono.Element} element2 Element对象
* @param {Number} materialIndexOffset 偏移量
* @return {mono.Element} Element对象
*/
mono.Utils.mergeElement = function(element1, element2, materialIndexOffset) {}
/**
* 自动调整Network3D的Bounds
* @method autoAdjustNetworkBounds
* @static
* @param {mono.Network3D} network3D对象
* @param {Object} o {w:width, h: height}
* @param {Number} w 宽度
* @param {Number} h 高度
* @param {Number} left 与最左边的距离
* @param {Number} top 与最顶部的距离
*/
mono.Utils.autoAdjustNetworkBounds = function(network, o, w, h, left, top) {}
/**
* 判断某个对象内容是否为空
* @method isEmptyObject
* @static
* @param {Object} obj 对象
* @return {Boolean} 如果为空,返回true,否则返回false
*/
mono.Utils.isEmptyObject = function(obj) {}
/**
* 判断某个对象是否是数组
* @method isArray
* @static
* @param {Object} v 数组
* @return {Boolean} 如果是数组,返回true,否则返回false
*/
mono.Utils.isArray = function(v) {}
/**
* 判断两个对象是否相同
* @method isSame
* @static
* @param {Object} a
* @param {Object} b
* @return {Boolean} 如果相同,返回true,否则返回false
*/
mono.Utils.isSame = function(a, b) {}
/**
* 将对象转换为字符串
* @method toString
* @static
* @param {Object} a 对象
*/
mono.Utils.toString = function(a) {}
/**
* 验证license信息
* @method validateLicense
* @static
* @param {String} license license的信息
*/
mono.Utils.validateLicense = function(license) {}
/**
* Network3D是一个用于交互的视图组件,可以展示3D场景,并实现用户和3D场景之间的交互,比如旋转镜头,选中3D对象,通过鼠标或键盘移动3D对象等。
* Network3D需要由一个与之关联的DataBox驱动,显示DataBox中的网元。当初始化Network3D时,DataBox默认会绑定在Network3D上
* @class mono.Network3D
* @constructor
* @param {TGL.DataBox} dataBox 和Network3D绑定的数据容器,如果为空,twaver内部会创建一个数据容器与之绑定
* @param {TGL.Camera} camera Network3D场景中的镜头
* @param {Object} canvas network3D上用于绘制所有图元的画布,如果为空,twaver内部会创建一张空的画布
* @param {Object} parameters 其他相关的参数,此对象可以包含下面的属性:clearColor,clearAlpha,precision,fog,
* devicePixelRatio,preserveDrawingBuffer,antialias,maxLights
*/
mono.Network3D = function(dataBox, camera, canvas, parameters) {};
/**
* 设置和Network3D绑定的数据容器,databox不能为空
* @method setDataBox
* @param {mono.DataBox} dataBox
*/
mono.Network3D.prototype.setDataBox = function(dataBox) {}
/**
* 设置刷新Network3D之后的回调方法
* @method setRenderCallback
* @param {Function} f 回调方法
*/
mono.Network3D.prototype.setRenderCallback = function(f) {}
/**
* 设置刷新Network3D前的执行方法
* @method setBeforeRenderFunction
* @param {Function} f 刷新Network3D之前执行的方法
*/
mono.Network3D.prototype.setBeforeRenderFunction = function(f) {}
/**
* 获取和Network3D绑定的数据容器
* @method getDataBox
* @return {mono.DataBox} 返回和Network3D绑定的数据容器
*/
mono.Network3D.prototype.getDataBox = function() {}
/**
* 获取network3D的背景色
* @method getClearColor
* @return {String} 获取network3D的背景色
*/
mono.Network3D.prototype.getClearColor = function() {}
/**
* 设置network3D上的背景色
* @method setClearColor
* @param {string} clearColor
*/
mono.Network3D.prototype.setClearColor = function(clearColor) {}
/**
* 设置network3D背景色的透明度,取值范围0~1之间
* @method setClearAlpha
* @param {number} clearAlpha
*/
mono.Network3D.prototype.setClearAlpha = function(clearAlpha) {}
/**
* 获取Network3D的背景色透明度
* @method getClearAlpha
* @return {number}
*/
mono.Network3D.prototype.getClearAlpha = function() {}
/**
* 获取Network3D场景的镜头
* @method getCamera
* @return {mono.Camera}
*/
mono.Network3D.prototype.getCamera = function() {}
/**
* 强制刷新Network3D
* @method render
*/
mono.Network3D.prototype.render = function() {}
/**
* 获取Network3D上的Canvas组件,返回值为canvas
* @method getView
* @return {Object} 返回canvas
*/
mono.Network3D.prototype.getView = function() {}
/**
* 获取根视图
* @method getRootView
* @return {Object} 根视图
*/
mono.Network3D.prototype.getRootView = function() {}
/**
* 调整rootview的宽高
* @method adjustRootViewBounds
* @param {Number} w rootview的宽度
* @param {Number} h rootview的高度
*/
mono.Network3D.prototype.adjustRootViewBounds = function(w, h){}
/**
* 调整Network的位置及宽高
* @method adjustBounds
* @param {Number} w network的宽度值
* @param {Number} h network高度值
* @param {Number} x network的top的像素值
* @param {Number} y network的left的像素值
*/
mono.Network3D.prototype.adjustBounds = function(w, h, x, y) {}
/**
* 设置视角窗口大小
* @method setViewport
* @param {Number} x 视角窗口的左边像素值
* @param {Number} y 视角窗口的上边像素值
* @param {Number} width 视角窗口的宽度
* @param {Number} height 视角窗口的高度
*/
mono.Network3D.prototype.setViewport = function(x, y, width, height) {}
/**
* 设置是否显示坐标轴
* @method setShowAxis
* @param {Boolean} showAxis 是否显示坐标轴,值为true即显示坐标轴,false则不显示
*/
mono.Network3D.prototype.setShowAxis = function(showAxis) {}
/**
* 设置是否显示坐标轴文字
* @method setShowAxisText
* @param {Boolean} showAxisText 是否显示坐标轴文字,值为true即显示坐标轴文字,false则不显示
*/
mono.Network3D.prototype.setShowAxisText = function(showAxisText) {}
/**
* 网元是否可选
* @method isSelectable
* @param {mono.Data} element 指定的网元
* @return {Boolean} 值为true即为该网元可选,false则不可选
*/
mono.Network3D.prototype.isSelectable = function(element) {}
/**
* 设置是否可选过滤器,该过滤器可以用来过滤哪些网元可选,哪些网元不可选
* @method setSelectableFunction
* @param {Function} f 可选过滤器的函数
*/
mono.Network3D.prototype.setSelectableFunction = function(f) {}
/**
* 设置是否需要绘制选择边框的过滤器,该过滤器可以用来过滤哪些选中的网元需要绘制选择边框,哪些不需要
* @method setRenderSelectFunction
* @param {Function} f 网元选中时选中边框是否需要绘制的过滤器
*/
mono.Network3D.prototype.setRenderSelectFunction = function(f) {}
/**
* 将Network3D导出成图片
* @method toImageData
* @param {String} type 图片的格式类型,目前支持PNG,JPEG,BMP格式
* @param {Object} clipBounds Network3D上需要导出成图片的剪辑区域,它是一个包含x,y,w,h这些属性的对象
* @param {Number} width 生成的图片的宽度
* @param {Number} height 生成的图片的高度
* @return {String} 返回base64的图片资源字符串
*/
mono.Network3D.prototype.toImageData = function(type, clipBounds, width, height) {}
/**
* 获取鼠标事件下的网元
* @method getElementsByMouseEvent
* @param {Event} event 鼠标事件
* @param {Boolean} intersectUnVisible 是否获取不可见的网元,如果为true,当鼠标下的网元不可见,也会返回该网元,反之则不返回该网元
* @return {} 鼠标事件下所有的网元
*/
mono.Network3D.prototype.getElementsByMouseEvent = function(event, intersectUnVisible) {}
/**
* 将一个3D的坐标投射到2D平面上时所得到的2D的坐标
* @method getViewPosition
* @param {mono.Vec3} vector 3D的坐标值
* @return {Object} 返回一个包含x,y属性的对象
*/
mono.Network3D.prototype.getViewPosition = function(vector) {}
/**
* 设置Network3D的交互监听集,例如:
* var interactions = [selectionInteraction, defaultInteraction];
* network3d.setInteractions(interactions);
* @method setInteractions
* @param {Array} interactions 所有需要设置到Network上的交互监听集合
*/
mono.Network3D.prototype.setInteractions = function(interactions) {}
/**
* 获取所有的交互监听集
* @method getInteractions
* @return {Array} 所有的交互监听集
*/
mono.Network3D.prototype.getInteractions =function() {}
/**
* 广告牌,它是mono中提供的一种通用的3D对象,它和其他3D对象的区别在于当旋转镜头时,广告牌始终是面朝着镜头
* @class mono.Billboard
* @constructor
*/
mono.Billboard = function() {};
/**
* 将一个广告牌克隆出一个新的广告牌
* @method clone
* @param {mono.Billboard} element 被克隆的广告牌对象
* @return {mono.Billboard} 返回克隆的新广告牌
*/
mono.Billboard.prototype.clone = function(element){};
/**
* Light是所有灯的基类,在3D场景中,光照是非常重要的元素,它模拟了现实世界,在3D场景中的物体可以反射出光照效果
* @class mono.Light
* @constructor
* @param {Number} color 灯光的颜色值
*/
mono.Light = function(color) {};
/**
* 设置是否需要显示灯光的阴影
* @method setCastShadow
* @param {Boolean} castShadow 是否显示灯光阴影效果
*/
mono.Light.prototype.setCastShadow = function(castShadow) {}
/**
* 设置光照的颜色值
* @method setColor
* @param {Number} color 光照的颜色值
*/
mono.Light.prototype.setColor = function(color){},
/**
* 获取光照的颜色值
* @method getColor
* @return {Number} 返回光照的颜色值
*/
mono.Light.prototype.getColor = function(){return color}
/**
* 设置环境光照的颜色值
* @method setAmbient
* @param {mono.Color} ambient 环境光照的颜色
*/
mono.Light.prototype.setAmbient = function(ambient){}
/**
* 获取环境光照的颜色值
* @method getAmbient
* @return {mono.Color} 返回环境光照的颜色
*/
mono.Light.prototype.getAmbient = function(){return ambient},
/**
* 设置散射光的颜色值
* @method setDiffuse
* @param {mono.Color} diffuse 散射光的颜色值
*/
mono.Light.prototype.setDiffuse = function(diffuse){}
/**
* 获取散射光的颜色值
* @method getDiffuse
* @return {mono.Color} 返回散射光的颜色值
*/
mono.Light.prototype.getDiffuse = function(){return diffuse}
/**
* 设置镜面光的颜色值
* @method setSpecular
* @param {mono.Color} specular 镜面光的颜色值
*/
mono.Light.prototype.setSpecular = function(specular){},
/**
* 获取镜面光的颜色值
* @method getSpecular
* @return {mono.Color} 返回镜面光的颜色值
*/
mono.Light.prototype.getSpecular = function(){ return specular }
/**
* 点光源。在3D场景中创建一个指定颜色的点光源元素
* @class mono.PointLight
* @constructor
* @param {Number} hex 一个包含RGB的十六进制数组
* @param {Number} intensity 光照强度值,如果为空,默认设置为1
* @param {Number} distance 光照衰减的距离值
*/
mono.PointLight = function ( hex, intensity, distance ) {};
/**
* 设置光照的强度
* @method setIntensity
* @param {Number} intensity 光照的强度
*/
mono.PointLight.prototype.setIntensity = function(intensity){}
/**
* 获取光照的强度值
* @method getIntensity
* @return {Number} 返回光照的强度值
*/
mono.PointLight.prototype.getIntensity = function(){}
/**
* 设置光照的衰减距离
* @method setDistance
* @param {Number} distance 光照的衰减距离
*/
mono.PointLight.prototype.setDistance =function(distance){}
/**
* 获取光照的衰减距离
* @method getDistance
* @return {Number} 返回光照的衰减距离
*/
mono.PointLight.prototype.getDistance = function(){}
/**
* 聚光源。在3D场景中创建一个指定颜色的聚光灯元素
* @class mono.SpotLight
* @constructor
* @param {Number} hex 一个包含RGB的十六进制数组
* @param {Number} intensity 光照强度值,如果为空,默认设置为1
* @param {Number} distance 光照衰减的距离值
* @param {Number} angle 最大可扩散的光照弧度
* @param {} exponent
*/
mono.SpotLight = function ( hex, intensity, distance, angle, exponent ) {};
/**
* 设置光照衰减的距离值
* @method setDistance
* @param {Number} distance 光照衰减的距离值
*/
mono.SpotLight.prototype.setDistance = function(distance){}
/**
* 获取光照衰减的距离值
* @method getDistance
* @return {Number} 返回光照的衰减距离
*/
mono.SpotLight.prototype.getDistance = function(){}
/**
* 设置最大可扩散的光照弧度
* @method setAngle
* @param {Number} angle 最大可扩散的光照弧度
*/
mono.SpotLight.prototype.setAngle = function(angle){}
/**
* 获取最大可扩散的光照弧度
* @method getAngle
* @return {Number} 返回最大可扩散的光照弧度
*/
mono.SpotLight.prototype.getAngle = function(){}
/**
* 方向光源。在3D场景中创建一个指定颜色的方向光照
* @class mono.DirectionalLight
* @constructor
* @param {Number} hex 一个包含RGB的十六进制数组
* @param {Number} intensity 光照强度值,如果为空,默认设置为1
*/
mono.DirectionalLight = function ( hex, intensity ) {};
/**
* 环境光,环境光是那些在环境中进行了充分的散射,无法辨认其方向的光。
* @class mono.AmbientLight
* @constructor
* @param {Number} hex 一个包含RGB的十六进制数组
*/
mono.AmbientLight = function(hex) {};
/**
* 将一个点光源对象克隆出新的对象
* @method clone
* @return {mono.AmbientLight} 返回新的点光源对象
*/
mono.AmbientLight.prototype.clone = function() {}
/**
* 镜头是一个抽象的概念,它在3D场景中用于模仿人的眼睛来观察物体,用于将3D场景中的物体投射到2D的平面上。
* @class mono.Camera
* @constructor
*/
mono.Camera = function() {};
/**
* 镜头观察点的目标位置
* @method look
* @param {mono.Vec3} target 目标位置
*/
mono.Camera.prototype.look = function(target){}
/**
* 获取镜头观察点的目标位置
* @method getTarget
* @return {mono.Vec3} 返回观察点的位置坐标
*/
mono.Camera.prototype.getTarget = function(){}
/**
* 透视投影镜头,透视投影模仿人的眼睛来观察物体,距离镜头越远,在最终图像上看上去就越小,
* 透视投影的视景体可以看成一个金字塔的平截头体,顶部被一个平行于底面的平面截除。
* 使用透视投影镜头获得的结果是类似人眼在真实世界中看到的有“近大远小”的效果。
* @class mono.PerspectiveCamera
* @constructor
* @param {Number} fov yz平面上视野的角度值,可选值的范围在0~180之间
* @param {Number} aspect 视景体的纵横比,也就是宽度除以高度
* @param {Number} near 观察点到视景体的顶部平面的距离
* @param {Number} far 观察点到视景体的底部平面的距离
*/
mono.PerspectiveCamera = function ( fov, aspect, near, far ) {};
/**
* 默认的交互模式,mono中提供的默认交互模式包括可以在3D场景中旋转镜头,通过鼠标滚轮缩放镜头,键盘操作镜头等。
* @class mono.DefaultInteraction
* @constructor
* @param {mono.Network3D} network 用于添加默认交互的3D场景
*/
mono.DefaultInteraction = function(network) {};
/**
* 获取镜头旋转的速度
* @method getRotateSpeed
* @return {Number} 返回镜头旋转的速度
*/
mono.DefaultInteraction.prototype.getRotateSpeed = function(){return rotateSpeed}
/**
* 设置镜头旋转的速度
* @method setRotateSpeed
* @param {Number} rotateSpeed 镜头旋转的速度
*/
mono.DefaultInteraction.prototype.setRotateSpeed = function(rotateSpeed){}
/**
* 获取镜头缩放的速度
* @method getZoomSpeed
* @return {Number} 返回镜头缩放的速度
*/
mono.DefaultInteraction.prototype.getZoomSpeed = function(){return zoomSpeed}
/**
* 设置镜头缩放的速度
* @method setZoomSpeed
* @param {Number} zoomSpeed 镜头缩放的速度
*/
mono.DefaultInteraction.prototype.setZoomSpeed = function(zoomSpeed){}
/**
* 获取镜头平移的速度
* @method getPanSpeed
* @return {Number} 返回镜头平移的速度
*/
mono.DefaultInteraction.prototype.getPanSpeed = function(){return panSpeed},
/**
* 设置镜头平移的速度
* @method setPanSpeed
* @param {Number} panSpeed 镜头平移的速度
*/
mono.DefaultInteraction.prototype.setPanSpeed = function(panSpeed){}
/**
* 选择交互默认,当设置3D场景为选择交互模式时,3D场景中的对象可以被选中,也可以按住ctrl键进行框选
* @class mono.SelectionInteraction
* @constructor
* @param {mono.network3D} network 用于添加交互模式的3D场景
*/
mono.SelectionInteraction = function(network) {};
/**
* 可编辑交互模式,在此模式下可以编辑3D对象,例如平移,缩放,旋转等
* @class mono.EditInteraction
* @constructor
* @param {mono.Network3D} network 用于添加交互默认的3D场景
*/
mono.EditInteraction = function(network) {};
/**
* 设置是否显示帮助的组件
* @method setShowHelpers
* @param {Boolean} showHelpers 是否显示帮助的相关组件
*/
mono.EditInteraction.prototype.setShowHelpers = function(showHelpers) {}
/**
* 设置是否可缩放
* @method setScaleable
* @param {Boolean} scaleable 是否可缩放
*/
mono.EditInteraction.prototype.setScaleable = function(scaleable) {}
/**
* 设置是否可旋转
* @method setRotateable
* @param {Boolean} rotateable 是否可旋转
*/
mono.EditInteraction.prototype.setRotateable = function(rotateable) {}
/**
* 设置是否可平移
* @method setTranslateable
* @param {Boolean} translateable 是否可平移
*/
mono.EditInteraction.prototype.setTranslateable = function(translateable) {}
/**
* 设置默认的模式,mono中提供了三种模式:translate,rotate和scale
* @method setDefaultMode
* @param {String} defaultMode 默认的模式
*/
mono.EditInteraction.prototype.setDefaultMode = function(defaultMode) {}
/**
* 设置缩放率
* @method setScaleRate
* @param {Number} scaleRate 缩放率
*/
mono.EditInteraction.prototype.setScaleRate = function(scaleRate) {}
/**
* 设置是否需要等比例缩放
* @method setForceSameScale
* @param {Boolean} forceSameScale 是否等比例缩放
*/
mono.EditInteraction.prototype.setForceSameScale = function(forceSameScale) {}