vislite 0.5.0 → 0.5.2-alpha.0

package/src/common/tree/toPlainTree.ts

@@ -1,132 +1,132 @@
-import type TreeConfigType from '../../../types/TreeConfig'
-
-import toInnerTree from './toInnerTree'
-
-// 可以传递任意格式的树原始数据
-// 只要配置对应的解析方法即可
-export default function (initTree: any, config: TreeConfigType, noOpens: {}) {
-    let treeData = toInnerTree(initTree, config)
-
-    let alltreedata = treeData.value // 维护的树
-    let rootid = treeData.rid // 根结点ID
-
-    if (treeData.num == 1) {
-        alltreedata[rootid].left = 0.5
-        alltreedata[rootid].top = 0.5
-        alltreedata[rootid].show = true
-        return {
-            deep: 1,
-            node: alltreedata,
-            root: rootid,
-            size: 1
-        }
-    } else {
-
-        let beforeDis = [], size = 0, maxDeep = 0
-
-        if (noOpens[rootid]) {
-            alltreedata[rootid].left = 0.5
-            alltreedata[rootid].top = 0.5
-            alltreedata[rootid].show = true
-
-            size = 1
-        } else {
-            ; (function positionCalc(pNode, deep) {
-
-                if (deep > maxDeep) maxDeep = deep
-
-                let flag: number = 0
-                if (!noOpens[pNode.id]) {
-
-                    for (flag = 0; flag < pNode.children.length; flag++)
-
-                        // 因为全部的子结点的位置确定了，父结点的y位置就是子结点的中间位置
-                        // 因此有子结点的，先计算子结点
-                        positionCalc(alltreedata[pNode.children[flag]], deep + 1)
-
-                }
-
-                // left的位置比较简单，deep从0开始编号
-                // 比如deep=0，第一层，left=0+0.5=0.5，也就是根结点
-                alltreedata[pNode.id].left = deep + 0.5
-                if (flag == 0) {
-
-                    // beforeDis是一个数组，用以记录每一层此刻top下边缘（每一层是从上到下）
-                    // 比如一层的第一个，top值最小可以取top=0.5
-                    // 为了方便计算，beforeDis[deep] == undefined的时候表示现在准备计算的是这层的第一个结点
-                    // 因此设置最低上边缘为-0.5
-                    if (beforeDis[deep] == void 0) beforeDis[deep] = -0.5
-                    // 父边缘同意的进行初始化
-                    if (beforeDis[deep - 1] == void 0) beforeDis[deep - 1] = -0.5
-
-                    // 添加的新结点top值第一种求法：本层上边缘+1（比如上边缘是-0.5，那么top最小是top=-0.5+1=0.5）
-                    alltreedata[pNode.id].top = beforeDis[deep] + 1
-
-                    let pTop = beforeDis[deep] + 1 + (alltreedata[pNode.pid].children.length - 1) * 0.5
-                    // 计算的原则是：如果第一种可行，选择第一种，否则必须选择第二种
-                    // 判断第一种是否可行的方法就是：如果第一种计算后确定的孩子上边缘不对导致孩子和孩子的前兄弟重合就是可行的
-                    if (pTop - 1 < beforeDis[deep - 1])
-                        // 必须保证父亲结点和父亲的前一个兄弟保存1的距离，至少
-                        // 添加的新结点top值的第二种求法：根据孩子取孩子结点的中心top
-                        alltreedata[pNode.id].top = beforeDis[deep - 1] + 1 - (alltreedata[pNode.pid].children.length - 1) * 0.5
-
-                } else {
-
-                    // 此刻flag!=0
-                    // 意味着结点有孩子，那么问题就解决了，直接取孩子的中间即可
-                    // 其实，flag==0的分支计算的就是孩子，是没有孩子的叶结点，那是关键
-                    alltreedata[pNode.id].top = (alltreedata[pNode.children[0]].top + alltreedata[pNode.children[flag - 1]].top) * 0.5
-                }
-
-                // 因为计算孩子的时候
-                // 无法掌握父辈兄弟的情况
-                // 可能会出现父亲和兄弟重叠问题
-                if (alltreedata[pNode.id].top <= beforeDis[deep]) {
-                    let needUp = beforeDis[deep] + 1 - alltreedata[pNode.id].top
-                        (function doUp(_pid: number | string, _deep: number) {
-                            alltreedata[_pid].top += needUp;
-                            if (beforeDis[_deep] < alltreedata[_pid].top) beforeDis[_deep] = alltreedata[_pid].top
-
-                            for (let _flag = 0; _flag < alltreedata[_pid].children.length; _flag++) {
-                                doUp(alltreedata[_pid].children[_flag], _deep + 1)
-                            }
-                        })(pNode.id, deep)
-                }
-
-                // 计算好一个结点后，需要更新此刻该层的上边缘
-                beforeDis[deep] = alltreedata[pNode.id].top
-
-                // size在每次计算一个结点后更新，是为了最终绘图的时候知道树有多宽（此处应该叫高）
-                if (alltreedata[pNode.id].top + 0.5 > size) size = alltreedata[pNode.id].top + 0.5
-
-            })(alltreedata[rootid], 0)
-
-        }
-        // 对于不显示的，需要标记一下
-        for (let key in noOpens) {
-            if (noOpens[key]) {
-                alltreedata[key].isOpen = false
-                    ; (function updateHidden(pid, left, top) {
-                        for (let index = 0; index < alltreedata[pid].children.length; index++) {
-                            alltreedata[alltreedata[pid].children[index]].left = left
-                            alltreedata[alltreedata[pid].children[index]].top = top
-                            alltreedata[alltreedata[pid].children[index]].show = false
-
-                            updateHidden(alltreedata[pid].children[index], left, top)
-                        }
-                    })(key, alltreedata[key].left, alltreedata[key].top)
-            }
-        }
-
-        // 传递的参数分别表示：记录了位置信息的树结点集合、根结点ID和树的宽
-        return {
-            "node": alltreedata,
-            "root": rootid,
-            "size": size,
-            "deep": maxDeep + 1
-        }
-
-    }
-
-
+import type TreeConfigType from '../../../types/TreeConfig'
+
+import toInnerTree from './toInnerTree'
+
+// 可以传递任意格式的树原始数据
+// 只要配置对应的解析方法即可
+export default function (initTree: any, config: TreeConfigType, noOpens: {}) {
+    let treeData = toInnerTree(initTree, config)
+
+    let alltreedata = treeData.value // 维护的树
+    let rootid = treeData.rid // 根结点ID
+
+    if (treeData.num == 1) {
+        alltreedata[rootid].left = 0.5
+        alltreedata[rootid].top = 0.5
+        alltreedata[rootid].show = true
+        return {
+            deep: 1,
+            node: alltreedata,
+            root: rootid,
+            size: 1
+        }
+    } else {
+
+        let beforeDis = [], size = 0, maxDeep = 0
+
+        if (noOpens[rootid]) {
+            alltreedata[rootid].left = 0.5
+            alltreedata[rootid].top = 0.5
+            alltreedata[rootid].show = true
+
+            size = 1
+        } else {
+            ; (function positionCalc(pNode, deep) {
+
+                if (deep > maxDeep) maxDeep = deep
+
+                let flag: number = 0
+                if (!noOpens[pNode.id]) {
+
+                    for (flag = 0; flag < pNode.children.length; flag++)
+
+                        // 因为全部的子结点的位置确定了，父结点的y位置就是子结点的中间位置
+                        // 因此有子结点的，先计算子结点
+                        positionCalc(alltreedata[pNode.children[flag]], deep + 1)
+
+                }
+
+                // left的位置比较简单，deep从0开始编号
+                // 比如deep=0，第一层，left=0+0.5=0.5，也就是根结点
+                alltreedata[pNode.id].left = deep + 0.5
+                if (flag == 0) {
+
+                    // beforeDis是一个数组，用以记录每一层此刻top下边缘（每一层是从上到下）
+                    // 比如一层的第一个，top值最小可以取top=0.5
+                    // 为了方便计算，beforeDis[deep] == undefined的时候表示现在准备计算的是这层的第一个结点
+                    // 因此设置最低上边缘为-0.5
+                    if (beforeDis[deep] == void 0) beforeDis[deep] = -0.5
+                    // 父边缘同意的进行初始化
+                    if (beforeDis[deep - 1] == void 0) beforeDis[deep - 1] = -0.5
+
+                    // 添加的新结点top值第一种求法：本层上边缘+1（比如上边缘是-0.5，那么top最小是top=-0.5+1=0.5）
+                    alltreedata[pNode.id].top = beforeDis[deep] + 1
+
+                    let pTop = beforeDis[deep] + 1 + (alltreedata[pNode.pid].children.length - 1) * 0.5
+                    // 计算的原则是：如果第一种可行，选择第一种，否则必须选择第二种
+                    // 判断第一种是否可行的方法就是：如果第一种计算后确定的孩子上边缘不对导致孩子和孩子的前兄弟重合就是可行的
+                    if (pTop - 1 < beforeDis[deep - 1])
+                        // 必须保证父亲结点和父亲的前一个兄弟保存1的距离，至少
+                        // 添加的新结点top值的第二种求法：根据孩子取孩子结点的中心top
+                        alltreedata[pNode.id].top = beforeDis[deep - 1] + 1 - (alltreedata[pNode.pid].children.length - 1) * 0.5
+
+                } else {
+
+                    // 此刻flag!=0
+                    // 意味着结点有孩子，那么问题就解决了，直接取孩子的中间即可
+                    // 其实，flag==0的分支计算的就是孩子，是没有孩子的叶结点，那是关键
+                    alltreedata[pNode.id].top = (alltreedata[pNode.children[0]].top + alltreedata[pNode.children[flag - 1]].top) * 0.5
+                }
+
+                // 因为计算孩子的时候
+                // 无法掌握父辈兄弟的情况
+                // 可能会出现父亲和兄弟重叠问题
+                if (alltreedata[pNode.id].top <= beforeDis[deep]) {
+                    let needUp = beforeDis[deep] + 1 - alltreedata[pNode.id].top
+                        (function doUp(_pid: number | string, _deep: number) {
+                            alltreedata[_pid].top += needUp;
+                            if (beforeDis[_deep] < alltreedata[_pid].top) beforeDis[_deep] = alltreedata[_pid].top
+
+                            for (let _flag = 0; _flag < alltreedata[_pid].children.length; _flag++) {
+                                doUp(alltreedata[_pid].children[_flag], _deep + 1)
+                            }
+                        })(pNode.id, deep)
+                }
+
+                // 计算好一个结点后，需要更新此刻该层的上边缘
+                beforeDis[deep] = alltreedata[pNode.id].top
+
+                // size在每次计算一个结点后更新，是为了最终绘图的时候知道树有多宽（此处应该叫高）
+                if (alltreedata[pNode.id].top + 0.5 > size) size = alltreedata[pNode.id].top + 0.5
+
+            })(alltreedata[rootid], 0)
+
+        }
+        // 对于不显示的，需要标记一下
+        for (let key in noOpens) {
+            if (noOpens[key]) {
+                alltreedata[key].isOpen = false
+                    ; (function updateHidden(pid, left, top) {
+                        for (let index = 0; index < alltreedata[pid].children.length; index++) {
+                            alltreedata[alltreedata[pid].children[index]].left = left
+                            alltreedata[alltreedata[pid].children[index]].top = top
+                            alltreedata[alltreedata[pid].children[index]].show = false
+
+                            updateHidden(alltreedata[pid].children[index], left, top)
+                        }
+                    })(key, alltreedata[key].left, alltreedata[key].top)
+            }
+        }
+
+        // 传递的参数分别表示：记录了位置信息的树结点集合、根结点ID和树的宽
+        return {
+            "node": alltreedata,
+            "root": rootid,
+            "size": size,
+            "deep": maxDeep + 1
+        }
+
+    }
+
+
 }

package/src/common/webgl/buffer.ts

@@ -1,80 +1,80 @@
-// 缓冲区分为两种：
-// 1.缓冲区中保存了包含顶点的数据
-// 2.缓冲区保存了包含顶点的索引值
-
-// 获取一个新的缓冲区
-// isElement默认false，创建第一种缓冲区，为true创建第二种
-let newBuffer = (painter: WebGLRenderingContext) => {
-    return painter.createBuffer()
-}
-
-// 数据写入缓冲区
-// data是一个类型化数组，表示写入的数据
-// usage表示程序如何使用存储在缓冲区的数据
-let writeBuffer = (painter: WebGLRenderingContext, data: ArrayBuffer, isElement: boolean, usage: number) => {
-    let TYPE = isElement ? painter.ELEMENT_ARRAY_BUFFER : painter.ARRAY_BUFFER
-    painter.bufferData(TYPE, data, usage)
-}
-
-// 使用缓冲区数据
-// location指定待分配的attribute变量的存储位置
-// size每个分量个数
-// type数据类型，应该是以下的某个：
-//      gl.UNSIGNED_BYTE    Uint8Array
-//      gl.SHORT            Int16Array
-//      gl.UNSIGNED_SHORT   Uint16Array
-//      gl.INT              Int32Array
-//      gl.UNSIGNED_INT     Uint32Array
-//      gl.FLOAT            Float32Array
-// stride相邻两个数据项的字节数
-// offset数据的起点字节位置
-// normalized是否把非浮点型的数据归一化到[0,1]或[-1,1]区间
-let useBuffer = (painter: WebGLRenderingContext, location: number, size: number, type: number, stride: number, offset: number, normalized: boolean) => {
-
-    // 把缓冲区对象分配给目标变量
-    painter.vertexAttribPointer(location, size, type, normalized, stride, offset)
-
-    // 连接目标对象和缓冲区对象
-    painter.enableVertexAttribArray(location)
-}
-
-class BufferObject {
-
-    private __painter: WebGLRenderingContext
-    private __isElement: boolean
-
-    private __buffer: WebGLBuffer
-    private __type: number
-    private __fsize: number
-
-    constructor(painter: WebGLRenderingContext, isElement: boolean = false) {
-        this.__painter = painter
-        this.__isElement = isElement
-
-        this.__buffer = newBuffer(painter)
-        this.__type = isElement ? painter.ELEMENT_ARRAY_BUFFER : painter.ARRAY_BUFFER
-    }
-
-    // 使用这个缓冲区对象
-    // （先于写入和分配）
-    use() {
-        this.__painter.bindBuffer(this.__type, this.__buffer) // 绑定到目标
-        return this
-    }
-
-    // 写入数据
-    write(data: Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array) {
-        writeBuffer(this.__painter, data, this.__isElement, this.__painter.STATIC_DRAW)
-        this.__fsize = data.BYTES_PER_ELEMENT
-        return this
-    }
-
-    // 分配使用
-    // 第2～4位参数分别表示：一个完整数据的长度、一组数据的长度、读取位置偏移
-    divide(location: number, size: number, stride: number, offset: number = 0) {
-        useBuffer(this.__painter, location, size, this.__painter.FLOAT, stride * this.__fsize, offset * this.__fsize, false)
-        return this
-    }
-}
-
+// 缓冲区分为两种：
+// 1.缓冲区中保存了包含顶点的数据
+// 2.缓冲区保存了包含顶点的索引值
+
+// 获取一个新的缓冲区
+// isElement默认false，创建第一种缓冲区，为true创建第二种
+let newBuffer = (painter: WebGLRenderingContext) => {
+    return painter.createBuffer()
+}
+
+// 数据写入缓冲区
+// data是一个类型化数组，表示写入的数据
+// usage表示程序如何使用存储在缓冲区的数据
+let writeBuffer = (painter: WebGLRenderingContext, data: ArrayBuffer, isElement: boolean, usage: number) => {
+    let TYPE = isElement ? painter.ELEMENT_ARRAY_BUFFER : painter.ARRAY_BUFFER
+    painter.bufferData(TYPE, data, usage)
+}
+
+// 使用缓冲区数据
+// location指定待分配的attribute变量的存储位置
+// size每个分量个数
+// type数据类型，应该是以下的某个：
+//      gl.UNSIGNED_BYTE    Uint8Array
+//      gl.SHORT            Int16Array
+//      gl.UNSIGNED_SHORT   Uint16Array
+//      gl.INT              Int32Array
+//      gl.UNSIGNED_INT     Uint32Array
+//      gl.FLOAT            Float32Array
+// stride相邻两个数据项的字节数
+// offset数据的起点字节位置
+// normalized是否把非浮点型的数据归一化到[0,1]或[-1,1]区间
+let useBuffer = (painter: WebGLRenderingContext, location: number, size: number, type: number, stride: number, offset: number, normalized: boolean) => {
+
+    // 把缓冲区对象分配给目标变量
+    painter.vertexAttribPointer(location, size, type, normalized, stride, offset)
+
+    // 连接目标对象和缓冲区对象
+    painter.enableVertexAttribArray(location)
+}
+
+class BufferObject {
+
+    private __painter: WebGLRenderingContext
+    private __isElement: boolean
+
+    private __buffer: WebGLBuffer
+    private __type: number
+    private __fsize: number
+
+    constructor(painter: WebGLRenderingContext, isElement: boolean = false) {
+        this.__painter = painter
+        this.__isElement = isElement
+
+        this.__buffer = newBuffer(painter)
+        this.__type = isElement ? painter.ELEMENT_ARRAY_BUFFER : painter.ARRAY_BUFFER
+    }
+
+    // 使用这个缓冲区对象
+    // （先于写入和分配）
+    use() {
+        this.__painter.bindBuffer(this.__type, this.__buffer) // 绑定到目标
+        return this
+    }
+
+    // 写入数据
+    write(data: Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array) {
+        writeBuffer(this.__painter, data, this.__isElement, this.__painter.STATIC_DRAW)
+        this.__fsize = data.BYTES_PER_ELEMENT
+        return this
+    }
+
+    // 分配使用
+    // 第2～4位参数分别表示：一个完整数据的长度、一组数据的长度、读取位置偏移
+    divide(location: number, size: number, stride: number, offset: number = 0) {
+        useBuffer(this.__painter, location, size, this.__painter.FLOAT, stride * this.__fsize, offset * this.__fsize, false)
+        return this
+    }
+}
+
 export default BufferObject

package/src/common/webgl/doDraw.ts

@@ -1,109 +1,109 @@
-import BufferObject from './buffer'
-
-import getTexture from './getTexture'
-import getShader from './getShader'
-
-interface MeshWorldType {
-    matrix: number[]
-}
-
-interface GlobalWorldType {
-    matrix: number[]
-    proporion: number[]
-}
-
-import { meshType } from '../../../types/Object3D'
-
-export default function (type: string, painter: WebGLRenderingContext, mesh: meshType, meshWorld: MeshWorldType, globalWorld: GlobalWorldType) {
-    let shader = getShader(type, painter, mesh)
-
-    // 点数据写入缓冲区
-    new BufferObject(painter).use()
-        .write(mesh.geometry.attributes.position.array as Float32Array)
-        .divide(painter.getAttribLocation(shader.program, "a_position"), mesh.geometry.attributes.position.itemSize, mesh.geometry.attributes.position.itemSize, 0)
-
-    // 写入矩阵
-    painter.uniformMatrix4fv(painter.getUniformLocation(shader.program, "u_matrix_world"), false, globalWorld.matrix)
-    painter.uniformMatrix4fv(painter.getUniformLocation(shader.program, "u_matrix_proporion"), false, globalWorld.proporion)
-    painter.uniformMatrix4fv(painter.getUniformLocation(shader.program, "u_matrix_mesh"), false, meshWorld.matrix)
-
-    // 如果有法向量数据
-    if (mesh.geometry.attributes.normal) {
-        new BufferObject(painter).use()
-            .write(mesh.geometry.attributes.normal.array as Float32Array)
-            .divide(painter.getAttribLocation(shader.program, "a_normal"), mesh.geometry.attributes.normal.itemSize, mesh.geometry.attributes.normal.itemSize, 0)
-    }
-
-    // 颜色
-    if ("color" in mesh.material) {
-
-        // 写入颜色
-        painter.uniform4f(painter.getUniformLocation(shader.program, "u_color")
-            , mesh.material.color.r
-            , mesh.material.color.g
-            , mesh.material.color.b
-            , mesh.material.color.alpha)
-    }
-
-    // 多颜色
-    if ("colors" in mesh.material) {
-
-        // 写入颜色序列
-        new BufferObject(painter).use()
-            .write(mesh.material.colors.array as Float32Array)
-            .divide(painter.getAttribLocation(shader.program, "a_color"), mesh.material.colors.itemSize, mesh.material.colors.itemSize, 0)
-
-    }
-
-    // 立方纹理
-    else if ("cube" in mesh.material) {
-
-        let size = (mesh.material.cube.right.image.value as any).width
-
-        painter.uniform1i(painter.getUniformLocation(shader.program, "u_texture"), 0)
-
-        getTexture(type, painter, 'cube').useCube([
-            mesh.material.cube.right.image.value,
-            mesh.material.cube.left.image.value,
-            mesh.material.cube.top.image.value,
-            mesh.material.cube.bottom.image.value,
-            mesh.material.cube.far.image.value,
-            mesh.material.cube.near.image.value
-        ], size, size)
-
-    }
-
-    // 二维纹理
-    else if ("image" in mesh.material) {
-
-        painter.uniform1i(painter.getUniformLocation(shader.program, "u_sampler"), 0)
-
-        new BufferObject(painter).use()
-            .write(mesh.geometry.attributes.uv.array as Float32Array)
-            .divide(painter.getAttribLocation(shader.program, "a_textcoord"), mesh.geometry.attributes.uv.itemSize, 2, 0)
-
-        getTexture(type, painter, '2d').useImage(mesh.material.image.value)
-
-    }
-
-    // 如果使用了索引
-    if (mesh.geometry.index) {
-
-        // 索引数据
-        new BufferObject(painter, true).use()
-            .write(mesh.geometry.index.array as Uint8Array)
-
-        // 绘制
-        painter.drawElements(painter[mesh.geometry.type], mesh.geometry.index.count, painter.UNSIGNED_BYTE, 0)
-
-    }
-
-    // 否则
-    else {
-
-        // 绘制
-        painter.drawArrays(painter[mesh.geometry.type], 0, mesh.geometry.attributes.position.count)
-
-    }
-
+import BufferObject from './buffer'
+
+import getTexture from './getTexture'
+import getShader from './getShader'
+
+interface MeshWorldType {
+    matrix: number[]
+}
+
+interface GlobalWorldType {
+    matrix: number[]
+    proporion: number[]
+}
+
+import { meshType } from '../../../types/Object3D'
+
+export default function (type: string, painter: WebGLRenderingContext, mesh: meshType, meshWorld: MeshWorldType, globalWorld: GlobalWorldType) {
+    let shader = getShader(type, painter, mesh)
+
+    // 点数据写入缓冲区
+    new BufferObject(painter).use()
+        .write(mesh.geometry.attributes.position.array as Float32Array)
+        .divide(painter.getAttribLocation(shader.program, "a_position"), mesh.geometry.attributes.position.itemSize, mesh.geometry.attributes.position.itemSize, 0)
+
+    // 写入矩阵
+    painter.uniformMatrix4fv(painter.getUniformLocation(shader.program, "u_matrix_world"), false, globalWorld.matrix)
+    painter.uniformMatrix4fv(painter.getUniformLocation(shader.program, "u_matrix_proporion"), false, globalWorld.proporion)
+    painter.uniformMatrix4fv(painter.getUniformLocation(shader.program, "u_matrix_mesh"), false, meshWorld.matrix)
+
+    // 如果有法向量数据
+    if (mesh.geometry.attributes.normal) {
+        new BufferObject(painter).use()
+            .write(mesh.geometry.attributes.normal.array as Float32Array)
+            .divide(painter.getAttribLocation(shader.program, "a_normal"), mesh.geometry.attributes.normal.itemSize, mesh.geometry.attributes.normal.itemSize, 0)
+    }
+
+    // 颜色
+    if ("color" in mesh.material) {
+
+        // 写入颜色
+        painter.uniform4f(painter.getUniformLocation(shader.program, "u_color")
+            , mesh.material.color.r
+            , mesh.material.color.g
+            , mesh.material.color.b
+            , mesh.material.color.alpha)
+    }
+
+    // 多颜色
+    if ("colors" in mesh.material) {
+
+        // 写入颜色序列
+        new BufferObject(painter).use()
+            .write(mesh.material.colors.array as Float32Array)
+            .divide(painter.getAttribLocation(shader.program, "a_color"), mesh.material.colors.itemSize, mesh.material.colors.itemSize, 0)
+
+    }
+
+    // 立方纹理
+    else if ("cube" in mesh.material) {
+
+        let size = (mesh.material.cube.right.image.value as any).width
+
+        painter.uniform1i(painter.getUniformLocation(shader.program, "u_texture"), 0)
+
+        getTexture(type, painter, 'cube').useCube([
+            mesh.material.cube.right.image.value,
+            mesh.material.cube.left.image.value,
+            mesh.material.cube.top.image.value,
+            mesh.material.cube.bottom.image.value,
+            mesh.material.cube.far.image.value,
+            mesh.material.cube.near.image.value
+        ], size, size)
+
+    }
+
+    // 二维纹理
+    else if ("image" in mesh.material) {
+
+        painter.uniform1i(painter.getUniformLocation(shader.program, "u_sampler"), 0)
+
+        new BufferObject(painter).use()
+            .write(mesh.geometry.attributes.uv.array as Float32Array)
+            .divide(painter.getAttribLocation(shader.program, "a_textcoord"), mesh.geometry.attributes.uv.itemSize, 2, 0)
+
+        getTexture(type, painter, '2d').useImage(mesh.material.image.value)
+
+    }
+
+    // 如果使用了索引
+    if (mesh.geometry.index) {
+
+        // 索引数据
+        new BufferObject(painter, true).use()
+            .write(mesh.geometry.index.array as Uint8Array)
+
+        // 绘制
+        painter.drawElements(painter[mesh.geometry.type], mesh.geometry.index.count, painter.UNSIGNED_BYTE, 0)
+
+    }
+
+    // 否则
+    else {
+
+        // 绘制
+        painter.drawArrays(painter[mesh.geometry.type], 0, mesh.geometry.attributes.position.count)
+
+    }
+
 }