| 5 | const arrayBuffer = new ArrayBuffer(2); |
| 6 | const uint8Array = new Uint8Array(arrayBuffer); |
| 7 | const uint16array = new Uint16Array(arrayBuffer); |
| 8 | uint8Array[0] = 0xAA; |
| 9 | uint8Array[1] = 0xBB; |
| 10 | return uint16array[0] === 0xBBAA; |
| 11 | } |
| 12 | const swapToBigEndian = (buffer) => { |
| 13 | if (!isLittleEndian()) return buffer |
| 14 | const view = new DataView(buffer); |
| 15 | for (let i = 0; i < buffer.byteLength; i += 4) { |
| 16 | const value = view.getUint32(i, false) |
| 17 | view.setUint32(i, value, true) |
| 18 | } |
| 19 | return buffer; |
| 20 | } |
| 21 | const readBINOBJ = async file => { |
| 22 | const buffer = swapToBigEndian(await file.arrayBuffer()) |
| 23 | const intArray = new Int32Array(buffer) |
| 24 | const floatArray = new Float32Array(buffer) |
| 25 |
| 26 | let position = 0 |
| 27 | const readInt = () => intArray[position++] |
| 28 | const readFloat = () => floatArray[position++] |
| 29 |
| 30 | let n |
| 31 |
| 32 | n = readInt() |
| 33 | const vertices = [] |
| 34 | for (let i = 0; i < n; ++i) { |
| 35 | vertices.push(readFloat()) |
| 36 | } |
| 37 |
| 38 | n = readInt() |
| 39 | const textures = [] |
| 40 | for (let i = 0; i < n; ++i) { |
| 41 | textures.push(readFloat()) |
| 42 | } |
| 43 |
| 44 | n = readInt() |
| 45 | const normals = [] |
| 46 | for (let i = 0; i < n; ++i) { |
| 47 | normals.push(readFloat()) |
| 48 | } |
| 49 |
| 50 | n = readInt() |
| 51 | const faceIndexes = [] |
| 52 | for (let i = 0; i < n; ++i) { |
| 53 | faceIndexes.push([ |
| 54 | readInt(), // vertex index |
| 55 | readInt(), // texture index |
| 56 | readInt() // normal index |
| 57 | ]) |
| 58 | } |
| 59 |
| 60 | console.log(position, intArray.length) |
| 61 |
| 62 | return { |
| 63 | vertices, |
| 64 | textures, |
| 65 | normals, |
| 66 | faceIndexes |
| 67 | } |
| 68 | } |
| 69 | const writeBINOBJ = ({ vertices, textures, normals, faceIndexes }) => { |
| 70 | const datasize = 4 + 4 * vertices.length + 4 + 4 * textures.length + 4 + 4 * normals.length + 4 + 4 * 3 * faceIndexes.length |
| 71 | const buffer = new ArrayBuffer(datasize) |
| 72 | const view = new DataView(buffer) |
| 73 |
| 74 | let position = 0 |
| 75 |
| 76 | view.setInt32(4 * (position++), vertices.length, false) |
| 77 | for (const v of vertices) |
| 78 | view.setFloat32(4 * (position++), v, false) |
| 79 |
| 80 | view.setInt32(4 * (position++), textures.length, false) |
| 81 | for (const vt of textures) |
| 82 | view.setFloat32(4 * (position++), vt, false) |
| 83 |
| 84 | view.setInt32(4 * (position++), normals.length, false) |
| 85 | for (const vn of normals) |
| 86 | view.setFloat32(4 * (position++), vn, false) |
| 87 |
| 88 | view.setInt32(4 * (position++), faceIndexes.length, false) |
| 89 | for (const [vi, vti, vni] of faceIndexes) { |
| 90 | view.setInt32(4 * (position++), vi, false) |
| 91 | view.setInt32(4 * (position++), vti, false) |
| 92 | view.setInt32(4 * (position++), vni, false) |
| 93 | } |
| 94 |
| 95 | return buffer |
| 96 | } |
| 97 | const readOBJ = async file => { |
| 98 | const text = await file.text() |
| 99 |
| 100 | const vertices = [] |
| 101 | const textures = [] |
| 102 | const normals = [] |
| 103 | const faceIndexes = [] |
| 104 |
| 105 | const lines = text.split('\n') |
| 106 | for (const line of lines) { |
| 107 | const args = line.split(' ') |
| 108 | if (args[0] == 'v') { |
| 109 | vertices.push(parseFloat(args[1]), parseFloat(args[2]), parseFloat(args[3])) |
| 110 | } else if (args[0] == 'vt') { |
| 111 | textures.push(parseFloat(args[1]), parseFloat(args[2])) |
| 112 | } else if (args[0] == 'vn') { |
| 113 | normals.push(parseFloat(args[1]), parseFloat(args[2]), parseFloat(args[3])) |
| 114 | } else if (args[0] == 'f') { |
| 115 | const i1 = args[1].split('/') |
| 116 | const i2 = args[2].split('/') |
| 117 | const i3 = args[3].split('/') |
| 118 | faceIndexes.push([ |
| 119 | i1[0] - 1, |
| 120 | i1[1] - 1, |
| 121 | i1[2] - 1, |
| 122 | ], [ |
| 123 | i2[0] - 1, |
| 124 | i2[1] - 1, |
| 125 | i2[2] - 1 |
| 126 | ], [ |
| 127 | i3[0] - 1, |
| 128 | i3[1] - 1, |
| 129 | i3[2] - 1 |
| 130 | ]) |
| 131 | } |
| 132 | } |
| 133 |
| 134 | return { |
| 135 | vertices, |
| 136 | textures, |
| 137 | normals, |
| 138 | faceIndexes |
| 139 | } |
| 140 | } |
| 141 | const writeOBJ = ({ vertices, textures, normals, faceIndexes }) => { |
| 142 | let text = "" |
| 143 |
| 144 | for (let i = 0; i < vertices.length / 3; ++i) { |
| 145 | text += "v " + vertices[3 * i] + " " + vertices[3 * i + 1] + " " + vertices[3 * i + 2] + "\n" |
| 146 | } |
| 147 |
| 148 | for (let i = 0; i < textures.length / 2; ++i) { |
| 149 | text += "vt " + textures[2 * i] + " " + textures[2 * i + 1] + "\n" |
| 150 | } |
| 151 |
| 152 | for (let i = 0; i < normals.length / 3; ++i) { |
| 153 | text += "vn " + normals[3 * i] + " " + normals[3 * i + 1] + " " + normals[3 * i + 2] + "\n" |
| 154 | } |
| 155 |
| 156 | for (let i = 0; i < faceIndexes.length / 3; ++i) { |
| 157 | text += "f " + |
| 158 | (1 + faceIndexes[3 * i][0]) + "/" + (1 + faceIndexes[3 * i][1]) + "/" + (1 + faceIndexes[3 * i][2]) + " " + |
| 159 | (1 + faceIndexes[3 * i + 1][0]) + "/" + (2 + faceIndexes[3 * i + 1][1]) + "/" + (1 + faceIndexes[3 * i + 1][2])+ " " + |
| 160 | (1 + faceIndexes[3 * i + 2][0]) + "/" + (3 + faceIndexes[3 * i + 2][1]) + "/" + (1 + faceIndexes[3 * i + 2][2])+ |
| 161 | "\n" |
| 162 | } |
| 163 |
| 164 | return text |
| 165 | } |
| 166 | const save = (blob, filename) => { |
| 167 | const a = document.createElement('a') |
| 168 | a.download = filename |
| 169 | a.href = window.URL.createObjectURL(blob); |
| 170 | document.body.appendChild(a) |
| 171 | a.click() |
| 172 | document.body.removeChild(a) |
| 173 | } |
| 174 | const input = document.querySelector("input") |
| 175 | input.addEventListener('change', async () => { |
| 176 | const file = input.files[0] |
| 177 | if (file.name.endsWith('.binobj')) { |
| 178 | save(new Blob([ writeOBJ(await readBINOBJ(file)) ], { type: 'text/plain' }), file.name.substring(0, file.name.length - 7) + '.obj') |
| 179 | } else if (file.name.endsWith('.obj')) { |
| 180 | console.log(await readOBJ(file)) |
| 181 | save(new Blob([ writeBINOBJ(await readOBJ(file)) ], { type: 'text/plain' }), file.name.substring(0, file.name.length - 4) + '.binobj') |
| 182 | } |
| 183 | }) |
| 184 | </script> |
| 185 | </body> |