Add existing to tracked
This commit is contained in:
+22
@@ -0,0 +1,22 @@
|
||||
run-name: build
|
||||
on:
|
||||
push:
|
||||
concurrency:
|
||||
group: ${{ github.ref }}
|
||||
cancel-in-progress: true
|
||||
jobs:
|
||||
build:
|
||||
runs-on: ubuntu-latest
|
||||
strategy:
|
||||
matrix:
|
||||
node: [ 16, 20 ]
|
||||
name: Node ${{ matrix.node }}
|
||||
steps:
|
||||
- uses: actions/checkout@v3
|
||||
- uses: actions/setup-node@v3
|
||||
with:
|
||||
node-version: ${{ matrix.node }}
|
||||
- run: npm install
|
||||
- run: npm run eslint
|
||||
- run: npm run prettier-check
|
||||
- run: npm run test -- --failTaskOnError --suppressPassed
|
||||
+169
@@ -0,0 +1,169 @@
|
||||
# Change Log
|
||||
|
||||
### 3.2.0 - 2025-11-19
|
||||
|
||||
- Added `doubleSidedMaterial` option to force materials to be rendered double sided. [#294](https://github.com/CesiumGS/obj2gltf/pull/294)
|
||||
- Strip file paths of any enclosing double-quotes to allow the mtl/texture files to be properly parsed [#297](https://github.com/CesiumGS/obj2gltf/pull/297)
|
||||
|
||||
### 3.1.6 - 2023-02-10
|
||||
|
||||
- Update npm module dependencies.
|
||||
|
||||
### 3.1.5 - 2023-01-25
|
||||
|
||||
- Fixed crash when writing GLB files above 2GB. [#280](https://github.com/CesiumGS/obj2gltf/pull/280)
|
||||
|
||||
### 3.1.4 - 2021-10-15
|
||||
|
||||
- Unlocked CesiumJS package now that CesiumJS 1.86.1 is released with a fix for Node 16. [#270](https://github.com/CesiumGS/obj2gltf/pull/270)
|
||||
|
||||
### 3.1.3 - 2021-09-15
|
||||
|
||||
- Fixed bug where missing .mtl files were no longer being handled gracefully in Node 16. [#268](https://github.com/CesiumGS/obj2gltf/pull/268)
|
||||
- Fixed parsing models with tab separated elements like those exported from Tinkercad. [#259](https://github.com/CesiumGS/obj2gltf/pull/259)
|
||||
- Locked CesiumJS to 1.84.0 to prevent "ReferenceError: Blob is not defined" error when running obj2gltf.
|
||||
|
||||
### 3.1.2 - 2021-08-02
|
||||
|
||||
- Removed `minFilter` and `magFilter` from generated samplers so that runtime engines can use their preferred texture filtering. [#240](https://github.com/CesiumGS/obj2gltf/pull/240)
|
||||
- Triangle winding order sanitization is longer done by default. Use the `--triangle-winding-order-sanitization` option. [#236](https://github.com/CesiumGS/obj2gltf/pull/236)
|
||||
|
||||
### 3.1.1 - 2021-06-22
|
||||
|
||||
- Fixed security warnings by updating outdated npm dependencies. [#254](https://github.com/CesiumGS/obj2gltf/pull/254)
|
||||
|
||||
### 3.1.0 - 2020-03-13
|
||||
|
||||
- Added back `inputUpAxis` and `outputUpAxis`. [#211](https://github.com/CesiumGS/obj2gltf/pull/211)
|
||||
- Fixed handling of mtl and texture absolute paths. [#219](https://github.com/CesiumGS/obj2gltf/pull/219)
|
||||
- Fixed specular image not being decoded when referenced by other textures. [#217](https://github.com/CesiumGS/obj2gltf/pull/217)
|
||||
- Fixed parsing faces that reference non-existing attributes. [#218](https://github.com/CesiumGS/obj2gltf/pull/218)
|
||||
|
||||
### 3.0.4 - 2019-07-22
|
||||
|
||||
- No longer printing texture decode warning if the diffuse and alpha textures are the same. [#205](https://github.com/CesiumGS/obj2gltf/pull/205)
|
||||
|
||||
### 3.0.3 - 2019-06-26
|
||||
|
||||
- Fixed parsing of negative face indices. [#191](https://github.com/CesiumGS/obj2gltf/pull/191)
|
||||
|
||||
### 3.0.2 - 2019-03-21
|
||||
|
||||
- Fixed a crash when saving separate resources that would exceed the Node buffer size limit. [#173](https://github.com/CesiumGS/obj2gltf/pull/173)
|
||||
|
||||
### 3.0.1 - 2019-03-08
|
||||
|
||||
- Fixed handling of materials that don't have names. [#173](https://github.com/CesiumGS/obj2gltf/pull/173)
|
||||
|
||||
### 3.0.0 - 2018-12-05
|
||||
|
||||
- Breaking changes
|
||||
- The `--materialsCommon` flag has been removed. Use `--unlit` instead which uses the `KHR_materials_unlit` extension. [#152](https://github.com/CesiumGS/obj2gltf/pull/152)
|
||||
|
||||
### 2.3.2 - 2018-11-02
|
||||
|
||||
- Improved handling of primitives with different attributes using the same material. Materials are now duplicated. [#162](https://github.com/CesiumGS/obj2gltf/pull/162)
|
||||
- Fixed a bug where primitives without texture coordinates could use materials containing textures. Those textures are now removed. [#162](https://github.com/CesiumGS/obj2gltf/pull/162)
|
||||
- Improved parsing of faces with mismatching attributes. [#161](https://github.com/CesiumGS/obj2gltf/pull/161)
|
||||
|
||||
### 2.3.1 - 2018-10-16
|
||||
|
||||
- Improved parsing models with concave or n-sided faces. [#157](https://github.com/CesiumGS/obj2gltf/pull/157)
|
||||
- Fixed handling of objs with interleaved materials. [#155](https://github.com/CesiumGS/obj2gltf/pull/155)
|
||||
|
||||
### 2.3.0 - 2018-09-19
|
||||
|
||||
- Fixed handling of objs with mismatching attribute layouts. [#153](https://github.com/CesiumGS/obj2gltf/pull/153)
|
||||
- Fixed normalization of Windows paths when running the converter on Linux. [#150](https://github.com/CesiumGS/obj2gltf/pull/150)
|
||||
- Added ability to use the first material in the mtl file when the obj is missing `usemtl`. [#133](https://github.com/CesiumGS/obj2gltf/pull/133)
|
||||
- Fixed handling of unnormalized input normals. [#136](https://github.com/CesiumGS/obj2gltf/pull/136)
|
||||
|
||||
### 2.2.0 - 2018-01-29
|
||||
|
||||
- Fixed handling of materials where the diffuse and ambient texture are the same. [#127](https://github.com/CesiumGS/obj2gltf/pull/127)
|
||||
- Added ability to load alpha textures. [#124](https://github.com/CesiumGS/obj2gltf/pull/124)
|
||||
- Fixed handling of `usemtl` when appearing before an `o` or `g` token. [#123](https://github.com/CesiumGS/obj2gltf/pull/123)
|
||||
- Fixed output name when running from the command line. [#126](https://github.com/CesiumGS/obj2gltf/pull/126)
|
||||
|
||||
### 2.1.0 - 2017-12-28
|
||||
|
||||
- Fixed loading faces that contain less than 3 vertices. [#120](https://github.com/CesiumGS/obj2gltf/pull/120)
|
||||
- Attempt to load missing materials and textures from within the same directory as the obj. [#117](https://github.com/CesiumGS/obj2gltf/pull/117)
|
||||
- Fixed loading mtllib paths that contain spaces. [#116](https://github.com/CesiumGS/obj2gltf/pull/116)
|
||||
- Fixed checking for transparency when the diffuse texture is used in another texture slot. [#115](https://github.com/CesiumGS/obj2gltf/pull/115)
|
||||
- Fixed parsing mtl textures that contain texture map options. [#109](https://github.com/CesiumGS/obj2gltf/pull/109)
|
||||
- Added back support for the `CONSTANT` technique when a model uses the `KHR_materials_common` extension and has no normals. [#108](https://github.com/CesiumGS/obj2gltf/pull/108)
|
||||
- Improved handling of materials with alpha. If the alpha value is 0.0 it is now treated as 1.0. [#107](https://github.com/CesiumGS/obj2gltf/pull/107)
|
||||
|
||||
### 2.0.0 - 2017-08-11
|
||||
|
||||
- Breaking changes
|
||||
- Obj models now convert to glTF 2.0. Possible material profiles are `metallicRoughness`, `specGlossiness` (using the `KHR_materials_pbrSpecularGlossiness` extension), and `materialsCommon` (using the `KHR_materials_common` extension).
|
||||
- Removed `gltf-pipeline` dependency. The following options have been removed: `compress`, `optimize`, `generateNormals`, `optimizeForCesium`, `ao`, and `bypassPipeline`.
|
||||
- Removed `inputUpAxis` and `outputUpAxis`. This stage will be incorporated into `gltf-pipeline` instead.
|
||||
- `obj2gltf` no longer takes a `gltfPath` argument and saves a glTF file. Instead it returns a promise that resolves to the glTF JSON or glb buffer.
|
||||
|
||||
### 1.3.0 - 2017-08-11
|
||||
|
||||
- Fixed parsing models with concave or n-sided faces. [#85](https://github.com/CesiumGS/obj2gltf/pull/85)
|
||||
- Fixed parsing models with line breaks. [#85](https://github.com/CesiumGS/obj2gltf/pull/85)
|
||||
|
||||
### 1.2.0 - 2017-07-11
|
||||
|
||||
- Change texture sampling to use `NEAREST_MIPMAP_LINEAR` by default. [#83](https://github.com/CesiumGS/obj2gltf/pull/83).
|
||||
- Fixed lighting when generating normals. [#89](https://github.com/CesiumGS/obj2gltf/pull/89)
|
||||
|
||||
### 1.1.1 - 2017-04-25
|
||||
|
||||
- Fixed `CHANGES.md` formatting.
|
||||
|
||||
### 1.1.0 - 2017-04-25
|
||||
|
||||
- Added ability to convert the up-axis of the obj model. [#68](https://github.com/CesiumGS/obj2gltf/pull/68)
|
||||
- Fixed issues with an extra .bin file being saved when using `--separate`. [#62](https://github.com/CesiumGS/obj2gltf/pull/62)
|
||||
- Fixed issue where an ambient color of `[1, 1, 1]` overly brightens the converted model. [#70](https://github.com/CesiumGS/obj2gltf/pull/70)
|
||||
|
||||
### 1.0.0 - 2017-04-13
|
||||
|
||||
- Breaking changes
|
||||
- To use `obj2gltf` as a library, call `require('obj2gltf')(input, output, options)`. The previous calling code was `require('obj2gltf').convert(input, output, options)`.
|
||||
- Many library options and command-line parameters have been renamed.
|
||||
- Project cleanup. [#49](https://github.com/CesiumGS/obj2gltf/pull/49)
|
||||
- Speed improvements, especially for larger models.
|
||||
- Preserves the objects and groups in the obj.
|
||||
- Added documentation and tests.
|
||||
- Material fixes.
|
||||
|
||||
### 0.1.7 - 2017-01-06
|
||||
|
||||
- Update gltf-pipeline to 0.1.0-alpha9
|
||||
- Added command to generate documentation (npm run jsdoc)
|
||||
|
||||
### 0.1.6 - 2016-09-07
|
||||
|
||||
- Changed obj2gltf.js line endings from CRLF to LF in npm package.
|
||||
|
||||
### 0.1.5 - 2016-08-26
|
||||
|
||||
- Fixed incorrect parameter to the gltf-pipeline.
|
||||
|
||||
### 0.1.4 - 2016-08-25
|
||||
|
||||
- Added compression flag for quantizing positions, compressing texture coordinates, and oct-encoding normals.
|
||||
|
||||
### 0.1.3 - 2016-08-08
|
||||
|
||||
- Fixed a bug causing models with no mtl file to not convert.
|
||||
|
||||
### 0.1.2 - 2016-07-25
|
||||
|
||||
- Converted the API to now use promises instead of callbacks. [#21](https://github.com/CesiumGS/OBJ2GLTF/pull/21)
|
||||
- Added the ability to optimize the converted glTF for CesiumJS by using the sun as a default light source.
|
||||
|
||||
### 0.1.1 - 2016-07-21
|
||||
|
||||
- Updated to use gltf-pipeline 0.1.0-alpha2.
|
||||
|
||||
### 0.1.0 - 2016-07-20
|
||||
|
||||
- Initial release.
|
||||
+355
@@ -0,0 +1,355 @@
|
||||
Copyright 2016-2020 Cesium GS, Inc. and Contributors
|
||||
|
||||
Apache License
|
||||
Version 2.0, January 2004
|
||||
http://www.apache.org/licenses/
|
||||
|
||||
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
|
||||
|
||||
1. Definitions.
|
||||
|
||||
"License" shall mean the terms and conditions for use, reproduction,
|
||||
and distribution as defined by Sections 1 through 9 of this document.
|
||||
|
||||
"Licensor" shall mean the copyright owner or entity authorized by
|
||||
the copyright owner that is granting the License.
|
||||
|
||||
"Legal Entity" shall mean the union of the acting entity and all
|
||||
other entities that control, are controlled by, or are under common
|
||||
control with that entity. For the purposes of this definition,
|
||||
"control" means (i) the power, direct or indirect, to cause the
|
||||
direction or management of such entity, whether by contract or
|
||||
otherwise, or (ii) ownership of fifty percent (50%) or more of the
|
||||
outstanding shares, or (iii) beneficial ownership of such entity.
|
||||
|
||||
"You" (or "Your") shall mean an individual or Legal Entity
|
||||
exercising permissions granted by this License.
|
||||
|
||||
"Source" form shall mean the preferred form for making modifications,
|
||||
including but not limited to software source code, documentation
|
||||
source, and configuration files.
|
||||
|
||||
"Object" form shall mean any form resulting from mechanical
|
||||
transformation or translation of a Source form, including but
|
||||
not limited to compiled object code, generated documentation,
|
||||
and conversions to other media types.
|
||||
|
||||
"Work" shall mean the work of authorship, whether in Source or
|
||||
Object form, made available under the License, as indicated by a
|
||||
copyright notice that is included in or attached to the work
|
||||
(an example is provided in the Appendix below).
|
||||
|
||||
"Derivative Works" shall mean any work, whether in Source or Object
|
||||
form, that is based on (or derived from) the Work and for which the
|
||||
editorial revisions, annotations, elaborations, or other modifications
|
||||
represent, as a whole, an original work of authorship. For the purposes
|
||||
of this License, Derivative Works shall not include works that remain
|
||||
separable from, or merely link (or bind by name) to the interfaces of,
|
||||
the Work and Derivative Works thereof.
|
||||
|
||||
"Contribution" shall mean any work of authorship, including
|
||||
the original version of the Work and any modifications or additions
|
||||
to that Work or Derivative Works thereof, that is intentionally
|
||||
submitted to Licensor for inclusion in the Work by the copyright owner
|
||||
or by an individual or Legal Entity authorized to submit on behalf of
|
||||
the copyright owner. For the purposes of this definition, "submitted"
|
||||
means any form of electronic, verbal, or written communication sent
|
||||
to the Licensor or its representatives, including but not limited to
|
||||
communication on electronic mailing lists, source code control systems,
|
||||
and issue tracking systems that are managed by, or on behalf of, the
|
||||
Licensor for the purpose of discussing and improving the Work, but
|
||||
excluding communication that is conspicuously marked or otherwise
|
||||
designated in writing by the copyright owner as "Not a Contribution."
|
||||
|
||||
"Contributor" shall mean Licensor and any individual or Legal Entity
|
||||
on behalf of whom a Contribution has been received by Licensor and
|
||||
subsequently incorporated within the Work.
|
||||
|
||||
2. Grant of Copyright License. Subject to the terms and conditions of
|
||||
this License, each Contributor hereby grants to You a perpetual,
|
||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
||||
copyright license to reproduce, prepare Derivative Works of,
|
||||
publicly display, publicly perform, sublicense, and distribute the
|
||||
Work and such Derivative Works in Source or Object form.
|
||||
|
||||
3. Grant of Patent License. Subject to the terms and conditions of
|
||||
this License, each Contributor hereby grants to You a perpetual,
|
||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
||||
(except as stated in this section) patent license to make, have made,
|
||||
use, offer to sell, sell, import, and otherwise transfer the Work,
|
||||
where such license applies only to those patent claims licensable
|
||||
by such Contributor that are necessarily infringed by their
|
||||
Contribution(s) alone or by combination of their Contribution(s)
|
||||
with the Work to which such Contribution(s) was submitted. If You
|
||||
institute patent litigation against any entity (including a
|
||||
cross-claim or counterclaim in a lawsuit) alleging that the Work
|
||||
or a Contribution incorporated within the Work constitutes direct
|
||||
or contributory patent infringement, then any patent licenses
|
||||
granted to You under this License for that Work shall terminate
|
||||
as of the date such litigation is filed.
|
||||
|
||||
4. Redistribution. You may reproduce and distribute copies of the
|
||||
Work or Derivative Works thereof in any medium, with or without
|
||||
modifications, and in Source or Object form, provided that You
|
||||
meet the following conditions:
|
||||
|
||||
(a) You must give any other recipients of the Work or
|
||||
Derivative Works a copy of this License; and
|
||||
|
||||
(b) You must cause any modified files to carry prominent notices
|
||||
stating that You changed the files; and
|
||||
|
||||
(c) You must retain, in the Source form of any Derivative Works
|
||||
that You distribute, all copyright, patent, trademark, and
|
||||
attribution notices from the Source form of the Work,
|
||||
excluding those notices that do not pertain to any part of
|
||||
the Derivative Works; and
|
||||
|
||||
(d) If the Work includes a "NOTICE" text file as part of its
|
||||
distribution, then any Derivative Works that You distribute must
|
||||
include a readable copy of the attribution notices contained
|
||||
within such NOTICE file, excluding those notices that do not
|
||||
pertain to any part of the Derivative Works, in at least one
|
||||
of the following places: within a NOTICE text file distributed
|
||||
as part of the Derivative Works; within the Source form or
|
||||
documentation, if provided along with the Derivative Works; or,
|
||||
within a display generated by the Derivative Works, if and
|
||||
wherever such third-party notices normally appear. The contents
|
||||
of the NOTICE file are for informational purposes only and
|
||||
do not modify the License. You may add Your own attribution
|
||||
notices within Derivative Works that You distribute, alongside
|
||||
or as an addendum to the NOTICE text from the Work, provided
|
||||
that such additional attribution notices cannot be construed
|
||||
as modifying the License.
|
||||
|
||||
You may add Your own copyright statement to Your modifications and
|
||||
may provide additional or different license terms and conditions
|
||||
for use, reproduction, or distribution of Your modifications, or
|
||||
for any such Derivative Works as a whole, provided Your use,
|
||||
reproduction, and distribution of the Work otherwise complies with
|
||||
the conditions stated in this License.
|
||||
|
||||
5. Submission of Contributions. Unless You explicitly state otherwise,
|
||||
any Contribution intentionally submitted for inclusion in the Work
|
||||
by You to the Licensor shall be under the terms and conditions of
|
||||
this License, without any additional terms or conditions.
|
||||
Notwithstanding the above, nothing herein shall supersede or modify
|
||||
the terms of any separate license agreement you may have executed
|
||||
with Licensor regarding such Contributions.
|
||||
|
||||
6. Trademarks. This License does not grant permission to use the trade
|
||||
names, trademarks, service marks, or product names of the Licensor,
|
||||
except as required for reasonable and customary use in describing the
|
||||
origin of the Work and reproducing the content of the NOTICE file.
|
||||
|
||||
7. Disclaimer of Warranty. Unless required by applicable law or
|
||||
agreed to in writing, Licensor provides the Work (and each
|
||||
Contributor provides its Contributions) on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
|
||||
implied, including, without limitation, any warranties or conditions
|
||||
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
|
||||
PARTICULAR PURPOSE. You are solely responsible for determining the
|
||||
appropriateness of using or redistributing the Work and assume any
|
||||
risks associated with Your exercise of permissions under this License.
|
||||
|
||||
8. Limitation of Liability. In no event and under no legal theory,
|
||||
whether in tort (including negligence), contract, or otherwise,
|
||||
unless required by applicable law (such as deliberate and grossly
|
||||
negligent acts) or agreed to in writing, shall any Contributor be
|
||||
liable to You for damages, including any direct, indirect, special,
|
||||
incidental, or consequential damages of any character arising as a
|
||||
result of this License or out of the use or inability to use the
|
||||
Work (including but not limited to damages for loss of goodwill,
|
||||
work stoppage, computer failure or malfunction, or any and all
|
||||
other commercial damages or losses), even if such Contributor
|
||||
has been advised of the possibility of such damages.
|
||||
|
||||
9. Accepting Warranty or Additional Liability. While redistributing
|
||||
the Work or Derivative Works thereof, You may choose to offer,
|
||||
and charge a fee for, acceptance of support, warranty, indemnity,
|
||||
or other liability obligations and/or rights consistent with this
|
||||
License. However, in accepting such obligations, You may act only
|
||||
on Your own behalf and on Your sole responsibility, not on behalf
|
||||
of any other Contributor, and only if You agree to indemnify,
|
||||
defend, and hold each Contributor harmless for any liability
|
||||
incurred by, or claims asserted against, such Contributor by reason
|
||||
of your accepting any such warranty or additional liability.
|
||||
|
||||
END OF TERMS AND CONDITIONS
|
||||
|
||||
APPENDIX: How to apply the Apache License to your work.
|
||||
|
||||
To apply the Apache License to your work, attach the following
|
||||
boilerplate notice, with the fields enclosed by brackets "{}"
|
||||
replaced with your own identifying information. (Don't include
|
||||
the brackets!) The text should be enclosed in the appropriate
|
||||
comment syntax for the file format. We also recommend that a
|
||||
file or class name and description of purpose be included on the
|
||||
same "printed page" as the copyright notice for easier
|
||||
identification within third-party archives.
|
||||
|
||||
Copyright 2016-2020 Cesium GS, Inc. and Contributors
|
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License");
|
||||
you may not use this file except in compliance with the License.
|
||||
You may obtain a copy of the License at
|
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software
|
||||
distributed under the License is distributed on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
See the License for the specific language governing permissions and
|
||||
limitations under the License.
|
||||
|
||||
# Third-Party Code
|
||||
|
||||
obj2gltf includes the following third-party code.
|
||||
|
||||
### bluebird
|
||||
|
||||
> The MIT License (MIT)
|
||||
>
|
||||
> Copyright (c) 2013-2015 Petka Antonov
|
||||
>
|
||||
> Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
> of this software and associated documentation files (the "Software"), to deal
|
||||
> in the Software without restriction, including without limitation the rights
|
||||
> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
> copies of the Software, and to permit persons to whom the Software is
|
||||
> furnished to do so, subject to the following conditions:
|
||||
>
|
||||
> The above copyright notice and this permission notice shall be included in
|
||||
> all copies or substantial portions of the Software.
|
||||
>
|
||||
> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
> THE SOFTWARE.
|
||||
|
||||
### CesiumJS
|
||||
|
||||
https://cesium.com/cesiumjs/
|
||||
|
||||
> Copyright 2011-2020 CesiumJS Contributors
|
||||
>
|
||||
> Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at
|
||||
>
|
||||
> http://www.apache.org/licenses/LICENSE-2.0
|
||||
>
|
||||
> Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
|
||||
|
||||
See https://github.com/CesiumGS/cesium/blob/main/LICENSE.md
|
||||
|
||||
### fs-extra
|
||||
|
||||
https://www.npmjs.com/package/fs-extra
|
||||
|
||||
> (The MIT License)
|
||||
>
|
||||
> Copyright (c) 2011-2016 JP Richardson
|
||||
>
|
||||
> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files
|
||||
> (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify,
|
||||
> merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
|
||||
> furnished to do so, subject to the following conditions:
|
||||
>
|
||||
> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
|
||||
>
|
||||
> THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
> WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS
|
||||
> OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
> ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
### gltf-pipeline
|
||||
|
||||
https://www.npmjs.com/package/gltf-pipeline
|
||||
|
||||
> Copyright 2015-2020 Richard Lee, Cesium GS, Inc., and Contributors
|
||||
>
|
||||
> Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at
|
||||
>
|
||||
> http://www.apache.org/licenses/LICENSE-2.0
|
||||
>
|
||||
> Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
|
||||
|
||||
### mime
|
||||
|
||||
https://www.npmjs.com/package/mime
|
||||
|
||||
> Copyright (c) 2010 Benjamin Thomas, Robert Kieffer
|
||||
>
|
||||
> Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
> of this software and associated documentation files (the "Software"), to deal
|
||||
> in the Software without restriction, including without limitation the rights
|
||||
> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
> copies of the Software, and to permit persons to whom the Software is
|
||||
> furnished to do so, subject to the following conditions:
|
||||
>
|
||||
> The above copyright notice and this permission notice shall be included in
|
||||
> all copies or substantial portions of the Software.
|
||||
>
|
||||
> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
> THE SOFTWARE.
|
||||
|
||||
### pngjs
|
||||
|
||||
https://www.npmjs.com/package/pngjs
|
||||
|
||||
> pngjs2 original work Copyright (c) 2015 Luke Page & Original Contributors
|
||||
> pngjs derived work Copyright (c) 2012 Kuba Niegowski
|
||||
>
|
||||
> Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
> of this software and associated documentation files (the "Software"), to deal
|
||||
> in the Software without restriction, including without limitation the rights
|
||||
> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
> copies of the Software, and to permit persons to whom the Software is
|
||||
> furnished to do so, subject to the following conditions:
|
||||
>
|
||||
> The above copyright notice and this permission notice shall be included in
|
||||
> all copies or substantial portions of the Software.
|
||||
>
|
||||
> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
> THE SOFTWARE.
|
||||
|
||||
### yargs
|
||||
|
||||
https://www.npmjs.com/package/yargs
|
||||
|
||||
The command-line tool uses yargs.
|
||||
|
||||
> Copyright 2010 James Halliday (mail@substack.net)
|
||||
> Modified work Copyright 2014 Contributors (ben@npmjs.com)
|
||||
>
|
||||
> This project is free software released under the MIT/X11 license:
|
||||
>
|
||||
> Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
> of this software and associated documentation files (the "Software"), to deal
|
||||
> in the Software without restriction, including without limitation the rights
|
||||
> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
> copies of the Software, and to permit persons to whom the Software is
|
||||
> furnished to do so, subject to the following conditions:
|
||||
>
|
||||
> The above copyright notice and this permission notice shall be included in
|
||||
> all copies or substantial portions of the Software.
|
||||
>
|
||||
> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
> THE SOFTWARE.
|
||||
+171
@@ -0,0 +1,171 @@
|
||||
# OBJ2GLTF
|
||||
|
||||
Convert OBJ assets to [glTF](https://www.khronos.org/gltf) 2.0.
|
||||
|
||||
## Getting Started
|
||||
|
||||
Install [Node.js](https://nodejs.org/en/) if you don't already have it, and then:
|
||||
|
||||
```
|
||||
npm install -g obj2gltf
|
||||
```
|
||||
|
||||
### Using obj2gltf as a command-line tool:
|
||||
|
||||
`obj2gltf -i model.obj`
|
||||
|
||||
`obj2gltf -i model.obj -o model.gltf`
|
||||
|
||||
`obj2gltf -i model.obj -o model.glb`
|
||||
|
||||
### Using obj2gltf as a library:
|
||||
|
||||
#### Converting an obj model to gltf:
|
||||
|
||||
```javascript
|
||||
const obj2gltf = require("obj2gltf");
|
||||
const fs = require("fs");
|
||||
obj2gltf("model.obj").then(function (gltf) {
|
||||
const data = Buffer.from(JSON.stringify(gltf));
|
||||
fs.writeFileSync("model.gltf", data);
|
||||
});
|
||||
```
|
||||
|
||||
#### Converting an obj model to glb
|
||||
|
||||
```javascript
|
||||
const obj2gltf = require("obj2gltf");
|
||||
const fs = require("fs");
|
||||
const options = {
|
||||
binary: true,
|
||||
};
|
||||
obj2gltf("model.obj", options).then(function (glb) {
|
||||
fs.writeFileSync("model.glb", glb);
|
||||
});
|
||||
```
|
||||
|
||||
## Material types
|
||||
|
||||
Traditionally the .mtl file format describes the Blinn-Phong shading model. Meanwhile glTF 2.0 introduces physically-based
|
||||
materials.
|
||||
|
||||
There are three shading models supported by `obj2gltf`:
|
||||
|
||||
- Metallic roughness PBR
|
||||
- Specular glossiness PBR (via `KHR_materials_pbrSpecularGlossiness` extension)
|
||||
- Unlit materials (via `KHR_materials_unlit` extension)
|
||||
|
||||
If the material type is known in advance, it should be specified with either the `metallicRoughness` or `specularGlossiness` flag.
|
||||
|
||||
If lighting information is already present in the model, the `unlit` flag should be used. This will save the glTF with the `KHR_materials_unlit` extension.
|
||||
|
||||
If the model is created with PBR textures, either the `metallicRoughness` or `specularGlossiness` flag should be passed in.
|
||||
See the table below for more information about how to specify PBR values inside the .mtl file.
|
||||
|
||||
If none of these flags are provided, the .mtl is assumed to contain traditional Blinn-Phong materials which will be converted to metallic-roughness PBR.
|
||||
There may be some quality loss as traditional materials do not map perfectly to PBR materials.
|
||||
|
||||
Commonly in PBR workflows the the .mtl file may not exist or its values may be outdated or incorrect.
|
||||
As a convenience the PBR textures may be supplied directly to the command line.
|
||||
|
||||
**Mapping of mtl slots to shading models**
|
||||
|
||||
| Slot | Metallic roughness | Specular glossiness |
|
||||
| -------- | ------------------ | ------------------- |
|
||||
| Ka | occlusion value | occlusion value |
|
||||
| Ke | emissive color | emissive color |
|
||||
| Kd | base color | diffuse color |
|
||||
| Ks | metallic value | specular color |
|
||||
| Ns | roughness value | glossiness value |
|
||||
| d | alpha | alpha |
|
||||
| Tr | 1.0 - alpha | 1.0 - alpha |
|
||||
| map_Ka | occlusion texture | occlusion texture |
|
||||
| map_Ke | emissive texture | emissive texture |
|
||||
| map_Kd | base color texture | diffuse texture |
|
||||
| map_Ks | metallic texture | specular texture |
|
||||
| map_Ns | roughness texture | glossiness texture |
|
||||
| map_Bump | normal texture | normal texture |
|
||||
|
||||
## Usage
|
||||
|
||||
### Command line flags:
|
||||
|
||||
| Flag | Description | Required |
|
||||
| --------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------- |
|
||||
| `-h`, `--help` | Display help. | No |
|
||||
| `-i`, `--input` | Path to the obj file. | :white_check_mark: Yes |
|
||||
| `-o`, `--output` | Path of the converted glTF or glb file. | No |
|
||||
| `-b`, `--binary` | Save as binary glTF (.glb). | No, default `false` |
|
||||
| `-s`, `--separate` | Writes out separate buffers and textures instead of embedding them in the glTF file. | No, default `false` |
|
||||
| `-t`, `--separateTextures` | Write out separate textures only. | No, default `false` |
|
||||
| `--checkTransparency` | Do a more exhaustive check for texture transparency by looking at the alpha channel of each pixel. By default textures are considered to be opaque. | No, default `false` |
|
||||
| `--secure` | Prevent the converter from reading texture or mtl files outside of the input obj directory. | No, default `false` |
|
||||
| `--packOcclusion` | Pack the occlusion texture in the red channel of metallic-roughness texture. | No, default `false` |
|
||||
| `--metallicRoughness` | The values in the mtl file are already metallic-roughness PBR values and no conversion step should be applied. Metallic is stored in the Ks and map_Ks slots and roughness is stored in the Ns and map_Ns slots. | No, default `false` |
|
||||
| `--specularGlossiness` | The values in the mtl file are already specular-glossiness PBR values and no conversion step should be applied. Specular is stored in the Ks and map_Ks slots and glossiness is stored in the Ns and map_Ns slots. The glTF will be saved with the `KHR_materials_pbrSpecularGlossiness` extension. | No, default `false` |
|
||||
| `--unlit` | The glTF will be saved with the KHR_materials_unlit extension. | No, default `false` |
|
||||
| `--metallicRoughnessOcclusionTexture` | Path to the metallic-roughness-occlusion texture that should override textures in the .mtl file, where occlusion is stored in the red channel, roughness is stored in the green channel, and metallic is stored in the blue channel. The model will be saved with a pbrMetallicRoughness material. This is often convenient in workflows where the .mtl does not exist or is not set up to use PBR materials. Intended for models with a single material. | No |
|
||||
| `--specularGlossinessTexture` | Path to the specular-glossiness texture that should override textures in the .mtl file, where specular color is stored in the red, green, and blue channels and specular glossiness is stored in the alpha channel. The model will be saved with a material using the KHR_materials_pbrSpecularGlossiness extension. | No |
|
||||
| `--occlusionTexture` | Path to the occlusion texture that should override textures in the .mtl file. | No |
|
||||
| `--normalTexture` | Path to the normal texture that should override textures in the .mtl file. | No |
|
||||
| `--baseColorTexture` | Path to the baseColor/diffuse texture that should override textures in the .mtl file. | No |
|
||||
| `--emissiveTexture` | Path to the emissive texture that should override textures in the .mtl file. | No |
|
||||
| `--alphaTexture` | Path to the alpha texture that should override textures in the .mtl file. | No |
|
||||
| `--input-up-axis` | Up axis of the obj. | No |
|
||||
| `--output-up-axis` | Up axis of the converted glTF. | No |
|
||||
| `--triangle-winding-order-sanitization` | Apply triangle winding order sanitization. | No |
|
||||
| `--doubleSidedMaterial` | Allow the material properties to be double-sided | No, default `false` |
|
||||
|
||||
## Build Instructions
|
||||
|
||||
Run the tests:
|
||||
|
||||
```
|
||||
npm run test
|
||||
```
|
||||
|
||||
To run ESLint on the entire codebase, run:
|
||||
|
||||
```
|
||||
npm run eslint
|
||||
```
|
||||
|
||||
To run ESLint automatically when a file is saved, run the following and leave it open in a console window:
|
||||
|
||||
```
|
||||
npm run eslint-watch
|
||||
```
|
||||
|
||||
## Running Test Coverage
|
||||
|
||||
Coverage uses [nyc](https://github.com/istanbuljs/nyc). Run:
|
||||
|
||||
```
|
||||
npm run coverage
|
||||
```
|
||||
|
||||
For complete coverage details, open `coverage/lcov-report/index.html`.
|
||||
|
||||
The tests and coverage covers the Node.js module; it does not cover the command-line interface, which is tiny.
|
||||
|
||||
## Generating Documentation
|
||||
|
||||
To generate the documentation:
|
||||
|
||||
```
|
||||
npm run jsdoc
|
||||
```
|
||||
|
||||
The documentation will be placed in the `doc` folder.
|
||||
|
||||
## Contributions
|
||||
|
||||
Pull requests are appreciated. Please use the same [Contributor License Agreement (CLA)](https://github.com/CesiumGS/cesium/blob/main/CONTRIBUTING.md) used for [CesiumJS](https://cesium.com/cesiumjs/).
|
||||
|
||||
---
|
||||
|
||||
Developed by the Cesium team.
|
||||
|
||||
<p align="center">
|
||||
<a href="https://cesium.com/"><img src="doc/cesium.png" onerror="this.src='cesium.png'"/></a>
|
||||
</p>
|
||||
+58
@@ -0,0 +1,58 @@
|
||||
[
|
||||
{
|
||||
"name": "bluebird",
|
||||
"license": [
|
||||
"MIT"
|
||||
],
|
||||
"version": "3.7.2",
|
||||
"url": "https://www.npmjs.com/package/bluebird"
|
||||
},
|
||||
{
|
||||
"name": "cesium",
|
||||
"license": [
|
||||
"Apache-2.0"
|
||||
],
|
||||
"version": "1.109.0",
|
||||
"url": "https://www.npmjs.com/package/cesium"
|
||||
},
|
||||
{
|
||||
"name": "fs-extra",
|
||||
"license": [
|
||||
"MIT"
|
||||
],
|
||||
"version": "11.1.1",
|
||||
"url": "https://www.npmjs.com/package/fs-extra"
|
||||
},
|
||||
{
|
||||
"name": "jpeg-js",
|
||||
"license": [
|
||||
"BSD-3-Clause"
|
||||
],
|
||||
"version": "0.4.4",
|
||||
"url": "https://www.npmjs.com/package/jpeg-js"
|
||||
},
|
||||
{
|
||||
"name": "mime",
|
||||
"license": [
|
||||
"MIT"
|
||||
],
|
||||
"version": "3.0.0",
|
||||
"url": "https://www.npmjs.com/package/mime"
|
||||
},
|
||||
{
|
||||
"name": "pngjs",
|
||||
"license": [
|
||||
"MIT"
|
||||
],
|
||||
"version": "7.0.0",
|
||||
"url": "https://www.npmjs.com/package/pngjs"
|
||||
},
|
||||
{
|
||||
"name": "yargs",
|
||||
"license": [
|
||||
"MIT"
|
||||
],
|
||||
"version": "17.7.2",
|
||||
"url": "https://www.npmjs.com/package/yargs"
|
||||
}
|
||||
]
|
||||
+248
@@ -0,0 +1,248 @@
|
||||
#!/usr/bin/env node
|
||||
"use strict";
|
||||
const Cesium = require("cesium");
|
||||
const fsExtra = require("fs-extra");
|
||||
const path = require("path");
|
||||
const yargs = require("yargs");
|
||||
const obj2gltf = require("../lib/obj2gltf");
|
||||
|
||||
const defaultValue = (a, b) => a ?? b;
|
||||
const defined = Cesium.defined;
|
||||
|
||||
const defaults = obj2gltf.defaults;
|
||||
|
||||
const args = process.argv;
|
||||
|
||||
const argv = yargs
|
||||
.usage("Usage: node $0 -i inputPath -o outputPath")
|
||||
.example("node $0 -i ./specs/data/box/box.obj -o box.gltf")
|
||||
.help("h")
|
||||
.alias("h", "help")
|
||||
.options({
|
||||
input: {
|
||||
alias: "i",
|
||||
describe: "Path to the obj file.",
|
||||
type: "string",
|
||||
demandOption: true,
|
||||
coerce: function (p) {
|
||||
if (!defined(p)) {
|
||||
return undefined;
|
||||
}
|
||||
if (p.length === 0) {
|
||||
throw new Error("Input path must be a file name");
|
||||
}
|
||||
return path.resolve(p);
|
||||
},
|
||||
},
|
||||
output: {
|
||||
alias: "o",
|
||||
describe: "Path of the converted glTF or glb file.",
|
||||
type: "string",
|
||||
coerce: function (p) {
|
||||
if (!defined(p)) {
|
||||
return undefined;
|
||||
}
|
||||
if (p.length === 0) {
|
||||
throw new Error("Output path must be a file name");
|
||||
}
|
||||
return path.resolve(p);
|
||||
},
|
||||
},
|
||||
binary: {
|
||||
alias: "b",
|
||||
describe: "Save as binary glTF (.glb)",
|
||||
type: "boolean",
|
||||
default: defaults.binary,
|
||||
},
|
||||
separate: {
|
||||
alias: "s",
|
||||
describe:
|
||||
"Write separate buffers and textures instead of embedding them in the glTF.",
|
||||
type: "boolean",
|
||||
default: defaults.separate,
|
||||
},
|
||||
separateTextures: {
|
||||
alias: "t",
|
||||
describe: "Write out separate textures only.",
|
||||
type: "boolean",
|
||||
default: defaults.separateTextures,
|
||||
},
|
||||
checkTransparency: {
|
||||
describe:
|
||||
"Do a more exhaustive check for texture transparency by looking at the alpha channel of each pixel. By default textures are considered to be opaque.",
|
||||
type: "boolean",
|
||||
default: defaults.checkTransparency,
|
||||
},
|
||||
secure: {
|
||||
describe:
|
||||
"Prevent the converter from reading textures or mtl files outside of the input obj directory.",
|
||||
type: "boolean",
|
||||
default: defaults.secure,
|
||||
},
|
||||
packOcclusion: {
|
||||
describe:
|
||||
"Pack the occlusion texture in the red channel of metallic-roughness texture.",
|
||||
type: "boolean",
|
||||
default: defaults.packOcclusion,
|
||||
},
|
||||
metallicRoughness: {
|
||||
describe:
|
||||
"The values in the .mtl file are already metallic-roughness PBR values and no conversion step should be applied. Metallic is stored in the Ks and map_Ks slots and roughness is stored in the Ns and map_Ns slots.",
|
||||
type: "boolean",
|
||||
default: defaults.metallicRoughness,
|
||||
},
|
||||
specularGlossiness: {
|
||||
describe:
|
||||
"The values in the .mtl file are already specular-glossiness PBR values and no conversion step should be applied. Specular is stored in the Ks and map_Ks slots and glossiness is stored in the Ns and map_Ns slots. The glTF will be saved with the KHR_materials_pbrSpecularGlossiness extension.",
|
||||
type: "boolean",
|
||||
default: defaults.specularGlossiness,
|
||||
},
|
||||
unlit: {
|
||||
describe:
|
||||
"The glTF will be saved with the KHR_materials_unlit extension.",
|
||||
type: "boolean",
|
||||
default: defaults.unlit,
|
||||
},
|
||||
metallicRoughnessOcclusionTexture: {
|
||||
describe:
|
||||
"Path to the metallic-roughness-occlusion texture that should override textures in the .mtl file, where occlusion is stored in the red channel, roughness is stored in the green channel, and metallic is stored in the blue channel. The model will be saved with a pbrMetallicRoughness material. This is often convenient in workflows where the .mtl does not exist or is not set up to use PBR materials. Intended for models with a single material",
|
||||
type: "string",
|
||||
normalize: true,
|
||||
},
|
||||
specularGlossinessTexture: {
|
||||
describe:
|
||||
"Path to the specular-glossiness texture that should override textures in the .mtl file, where specular color is stored in the red, green, and blue channels and specular glossiness is stored in the alpha channel. The model will be saved with a material using the KHR_materials_pbrSpecularGlossiness extension.",
|
||||
type: "string",
|
||||
normalize: true,
|
||||
},
|
||||
occlusionTexture: {
|
||||
describe:
|
||||
"Path to the occlusion texture that should override textures in the .mtl file.",
|
||||
type: "string",
|
||||
normalize: true,
|
||||
},
|
||||
normalTexture: {
|
||||
describe:
|
||||
"Path to the normal texture that should override textures in the .mtl file.",
|
||||
type: "string",
|
||||
normalize: true,
|
||||
},
|
||||
baseColorTexture: {
|
||||
describe:
|
||||
"Path to the baseColor/diffuse texture that should override textures in the .mtl file.",
|
||||
type: "string",
|
||||
normalize: true,
|
||||
},
|
||||
emissiveTexture: {
|
||||
describe:
|
||||
"Path to the emissive texture that should override textures in the .mtl file.",
|
||||
type: "string",
|
||||
normalize: true,
|
||||
},
|
||||
alphaTexture: {
|
||||
describe:
|
||||
"Path to the alpha texture that should override textures in the .mtl file.",
|
||||
},
|
||||
inputUpAxis: {
|
||||
describe: "Up axis of the obj.",
|
||||
choices: ["X", "Y", "Z"],
|
||||
type: "string",
|
||||
default: "Y",
|
||||
},
|
||||
outputUpAxis: {
|
||||
describe: "Up axis of the converted glTF.",
|
||||
choices: ["X", "Y", "Z"],
|
||||
type: "string",
|
||||
default: "Y",
|
||||
},
|
||||
triangleWindingOrderSanitization: {
|
||||
describe: "Apply triangle winding order sanitization.",
|
||||
type: "boolean",
|
||||
default: defaults.triangleWindingOrderSanitization,
|
||||
},
|
||||
doubleSidedMaterial: {
|
||||
describe: "Allow the material properties to be double-sided",
|
||||
type: "boolean",
|
||||
default: defaults.doubleSidedMaterial,
|
||||
},
|
||||
})
|
||||
.parse(args);
|
||||
|
||||
if (argv.metallicRoughness + argv.specularGlossiness > 1) {
|
||||
console.error(
|
||||
"Only one material type may be set from [--metallicRoughness, --specularGlossiness].",
|
||||
);
|
||||
process.exitCode = 1;
|
||||
return;
|
||||
}
|
||||
|
||||
if (
|
||||
defined(argv.metallicRoughnessOcclusionTexture) &&
|
||||
defined(argv.specularGlossinessTexture)
|
||||
) {
|
||||
console.error(
|
||||
"--metallicRoughnessOcclusionTexture and --specularGlossinessTexture cannot both be set.",
|
||||
);
|
||||
process.exitCode = 1;
|
||||
return;
|
||||
}
|
||||
|
||||
const objPath = argv.input;
|
||||
let gltfPath = argv.output;
|
||||
|
||||
const filename = defaultValue(gltfPath, objPath);
|
||||
const name = path.basename(filename, path.extname(filename));
|
||||
const outputDirectory = path.dirname(filename);
|
||||
const binary = argv.binary || path.extname(filename).toLowerCase() === ".glb";
|
||||
const extension = binary ? ".glb" : ".gltf";
|
||||
|
||||
gltfPath = path.join(outputDirectory, name + extension);
|
||||
|
||||
const overridingTextures = {
|
||||
metallicRoughnessOcclusionTexture: argv.metallicRoughnessOcclusionTexture,
|
||||
specularGlossinessTexture: argv.specularGlossinessTexture,
|
||||
occlusionTexture: argv.occlusionTexture,
|
||||
normalTexture: argv.normalTexture,
|
||||
baseColorTexture: argv.baseColorTexture,
|
||||
emissiveTexture: argv.emissiveTexture,
|
||||
alphaTexture: argv.alphaTexture,
|
||||
};
|
||||
|
||||
const options = {
|
||||
binary: binary,
|
||||
separate: argv.separate,
|
||||
separateTextures: argv.separateTextures,
|
||||
checkTransparency: argv.checkTransparency,
|
||||
secure: argv.secure,
|
||||
packOcclusion: argv.packOcclusion,
|
||||
metallicRoughness: argv.metallicRoughness,
|
||||
specularGlossiness: argv.specularGlossiness,
|
||||
unlit: argv.unlit,
|
||||
overridingTextures: overridingTextures,
|
||||
outputDirectory: outputDirectory,
|
||||
inputUpAxis: argv.inputUpAxis,
|
||||
outputUpAxis: argv.outputUpAxis,
|
||||
triangleWindingOrderSanitization: argv.triangleWindingOrderSanitization,
|
||||
doubleSidedMaterial: argv.doubleSidedMaterial,
|
||||
};
|
||||
|
||||
console.time("Total");
|
||||
|
||||
obj2gltf(objPath, options)
|
||||
.then(function (gltf) {
|
||||
if (binary) {
|
||||
// gltf is a glb buffer
|
||||
return fsExtra.outputFile(gltfPath, gltf);
|
||||
}
|
||||
const jsonOptions = {
|
||||
spaces: 2,
|
||||
};
|
||||
return fsExtra.outputJson(gltfPath, gltf, jsonOptions);
|
||||
})
|
||||
.then(function () {
|
||||
console.timeEnd("Total");
|
||||
})
|
||||
.catch(function (error) {
|
||||
console.log(error.message);
|
||||
process.exitCode = 1;
|
||||
});
|
||||
BIN
Binary file not shown.
|
After Width: | Height: | Size: 4.6 KiB |
+2
@@ -0,0 +1,2 @@
|
||||
"use strict";
|
||||
module.exports = require("./lib/obj2gltf");
|
||||
+109
@@ -0,0 +1,109 @@
|
||||
"use strict";
|
||||
const Cesium = require("cesium");
|
||||
|
||||
const ComponentDatatype = Cesium.ComponentDatatype;
|
||||
|
||||
module.exports = ArrayStorage;
|
||||
|
||||
const initialLength = 1024; // 2^10
|
||||
const doublingThreshold = 33554432; // 2^25 (~134 MB for a Float32Array)
|
||||
const fixedExpansionLength = 33554432; // 2^25 (~134 MB for a Float32Array)
|
||||
|
||||
/**
|
||||
* Provides expandable typed array storage for geometry data. This is preferable to JS arrays which are
|
||||
* stored with double precision. The resizing mechanism is similar to std::vector.
|
||||
*
|
||||
* @param {ComponentDatatype} componentDatatype The data type.
|
||||
*
|
||||
* @private
|
||||
*/
|
||||
function ArrayStorage(componentDatatype) {
|
||||
this.componentDatatype = componentDatatype;
|
||||
this.typedArray = ComponentDatatype.createTypedArray(componentDatatype, 0);
|
||||
this.length = 0;
|
||||
}
|
||||
|
||||
function resize(storage, length) {
|
||||
const typedArray = ComponentDatatype.createTypedArray(
|
||||
storage.componentDatatype,
|
||||
length,
|
||||
);
|
||||
typedArray.set(storage.typedArray);
|
||||
storage.typedArray = typedArray;
|
||||
}
|
||||
|
||||
ArrayStorage.prototype.push = function (value) {
|
||||
const length = this.length;
|
||||
const typedArrayLength = this.typedArray.length;
|
||||
|
||||
if (length === 0) {
|
||||
resize(this, initialLength);
|
||||
} else if (length === typedArrayLength) {
|
||||
if (length < doublingThreshold) {
|
||||
resize(this, typedArrayLength * 2);
|
||||
} else {
|
||||
resize(this, typedArrayLength + fixedExpansionLength);
|
||||
}
|
||||
}
|
||||
|
||||
this.typedArray[this.length++] = value;
|
||||
};
|
||||
|
||||
ArrayStorage.prototype.get = function (index) {
|
||||
return this.typedArray[index];
|
||||
};
|
||||
|
||||
const sizeOfUint16 = 2;
|
||||
const sizeOfUint32 = 4;
|
||||
const sizeOfFloat = 4;
|
||||
|
||||
ArrayStorage.prototype.toUint16Buffer = function () {
|
||||
const length = this.length;
|
||||
const typedArray = this.typedArray;
|
||||
const paddedLength = length + (length % 2 === 0 ? 0 : 1); // Round to next multiple of 2
|
||||
const buffer = Buffer.alloc(paddedLength * sizeOfUint16);
|
||||
for (let i = 0; i < length; ++i) {
|
||||
buffer.writeUInt16LE(typedArray[i], i * sizeOfUint16);
|
||||
}
|
||||
return buffer;
|
||||
};
|
||||
|
||||
ArrayStorage.prototype.toUint32Buffer = function () {
|
||||
const length = this.length;
|
||||
const typedArray = this.typedArray;
|
||||
const buffer = Buffer.alloc(length * sizeOfUint32);
|
||||
for (let i = 0; i < length; ++i) {
|
||||
buffer.writeUInt32LE(typedArray[i], i * sizeOfUint32);
|
||||
}
|
||||
return buffer;
|
||||
};
|
||||
|
||||
ArrayStorage.prototype.toFloatBuffer = function () {
|
||||
const length = this.length;
|
||||
const typedArray = this.typedArray;
|
||||
const buffer = Buffer.alloc(length * sizeOfFloat);
|
||||
for (let i = 0; i < length; ++i) {
|
||||
buffer.writeFloatLE(typedArray[i], i * sizeOfFloat);
|
||||
}
|
||||
return buffer;
|
||||
};
|
||||
|
||||
ArrayStorage.prototype.getMinMax = function (components) {
|
||||
const length = this.length;
|
||||
const typedArray = this.typedArray;
|
||||
const count = length / components;
|
||||
const min = new Array(components).fill(Number.POSITIVE_INFINITY);
|
||||
const max = new Array(components).fill(Number.NEGATIVE_INFINITY);
|
||||
for (let i = 0; i < count; ++i) {
|
||||
for (let j = 0; j < components; ++j) {
|
||||
const index = i * components + j;
|
||||
const value = typedArray[index];
|
||||
min[j] = Math.min(min[j], value);
|
||||
max[j] = Math.max(max[j], value);
|
||||
}
|
||||
}
|
||||
return {
|
||||
min: min,
|
||||
max: max,
|
||||
};
|
||||
};
|
||||
+19
@@ -0,0 +1,19 @@
|
||||
"use strict";
|
||||
|
||||
module.exports = Texture;
|
||||
|
||||
/**
|
||||
* An object containing information about a texture.
|
||||
*
|
||||
* @private
|
||||
*/
|
||||
function Texture() {
|
||||
this.transparent = false;
|
||||
this.source = undefined;
|
||||
this.name = undefined;
|
||||
this.extension = undefined;
|
||||
this.path = undefined;
|
||||
this.pixels = undefined;
|
||||
this.width = undefined;
|
||||
this.height = undefined;
|
||||
}
|
||||
+712
@@ -0,0 +1,712 @@
|
||||
"use strict";
|
||||
const FS_WRITE_MAX_LENGTH = 2147479552; // See https://github.com/nodejs/node/issues/35605
|
||||
const BUFFER_MAX_LENGTH = require("buffer").constants.MAX_LENGTH;
|
||||
const BUFFER_MAX_BYTE_LENGTH = Math.min(FS_WRITE_MAX_LENGTH, BUFFER_MAX_LENGTH);
|
||||
const Cesium = require("cesium");
|
||||
const getBufferPadded = require("./getBufferPadded");
|
||||
const getDefaultMaterial = require("./loadMtl").getDefaultMaterial;
|
||||
const Texture = require("./Texture");
|
||||
|
||||
const defaultValue = (a, b) => a ?? b;
|
||||
const defined = Cesium.defined;
|
||||
const WebGLConstants = Cesium.WebGLConstants;
|
||||
|
||||
module.exports = createGltf;
|
||||
|
||||
/**
|
||||
* Create a glTF from obj data.
|
||||
*
|
||||
* @param {Object} objData An object containing an array of nodes containing geometry information and an array of materials.
|
||||
* @param {Object} options The options object passed along from lib/obj2gltf.js
|
||||
* @returns {Object} A glTF asset.
|
||||
*
|
||||
* @private
|
||||
*/
|
||||
function createGltf(objData, options) {
|
||||
const nodes = objData.nodes;
|
||||
let materials = objData.materials;
|
||||
const name = objData.name;
|
||||
|
||||
// Split materials used by primitives with different types of attributes
|
||||
materials = splitIncompatibleMaterials(nodes, materials, options);
|
||||
|
||||
const gltf = {
|
||||
accessors: [],
|
||||
asset: {},
|
||||
buffers: [],
|
||||
bufferViews: [],
|
||||
extensionsUsed: [],
|
||||
extensionsRequired: [],
|
||||
images: [],
|
||||
materials: [],
|
||||
meshes: [],
|
||||
nodes: [],
|
||||
samplers: [],
|
||||
scene: 0,
|
||||
scenes: [],
|
||||
textures: [],
|
||||
};
|
||||
|
||||
gltf.asset = {
|
||||
generator: "obj2gltf",
|
||||
version: "2.0",
|
||||
};
|
||||
|
||||
gltf.scenes.push({
|
||||
nodes: [],
|
||||
});
|
||||
|
||||
const bufferState = {
|
||||
positionBuffers: [],
|
||||
normalBuffers: [],
|
||||
uvBuffers: [],
|
||||
indexBuffers: [],
|
||||
positionAccessors: [],
|
||||
normalAccessors: [],
|
||||
uvAccessors: [],
|
||||
indexAccessors: [],
|
||||
};
|
||||
|
||||
const uint32Indices = requiresUint32Indices(nodes);
|
||||
|
||||
const nodesLength = nodes.length;
|
||||
for (let i = 0; i < nodesLength; ++i) {
|
||||
const node = nodes[i];
|
||||
const meshes = node.meshes;
|
||||
const meshesLength = meshes.length;
|
||||
|
||||
if (meshesLength === 1) {
|
||||
const meshIndex = addMesh(
|
||||
gltf,
|
||||
materials,
|
||||
bufferState,
|
||||
uint32Indices,
|
||||
meshes[0],
|
||||
options,
|
||||
);
|
||||
addNode(gltf, node.name, meshIndex, undefined);
|
||||
} else {
|
||||
// Add meshes as child nodes
|
||||
const parentIndex = addNode(gltf, node.name);
|
||||
for (let j = 0; j < meshesLength; ++j) {
|
||||
const mesh = meshes[j];
|
||||
const meshIndex = addMesh(
|
||||
gltf,
|
||||
materials,
|
||||
bufferState,
|
||||
uint32Indices,
|
||||
mesh,
|
||||
options,
|
||||
);
|
||||
addNode(gltf, mesh.name, meshIndex, parentIndex);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (gltf.images.length > 0) {
|
||||
gltf.samplers.push({
|
||||
wrapS: WebGLConstants.REPEAT,
|
||||
wrapT: WebGLConstants.REPEAT,
|
||||
});
|
||||
}
|
||||
|
||||
addBuffers(gltf, bufferState, name, options.separate);
|
||||
|
||||
if (options.specularGlossiness) {
|
||||
gltf.extensionsUsed.push("KHR_materials_pbrSpecularGlossiness");
|
||||
gltf.extensionsRequired.push("KHR_materials_pbrSpecularGlossiness");
|
||||
}
|
||||
|
||||
if (options.unlit) {
|
||||
gltf.extensionsUsed.push("KHR_materials_unlit");
|
||||
gltf.extensionsRequired.push("KHR_materials_unlit");
|
||||
}
|
||||
|
||||
return gltf;
|
||||
}
|
||||
|
||||
function addCombinedBufferView(gltf, buffers, accessors, byteStride, target) {
|
||||
const length = buffers.length;
|
||||
if (length === 0) {
|
||||
return;
|
||||
}
|
||||
const bufferViewIndex = gltf.bufferViews.length;
|
||||
const previousBufferView = gltf.bufferViews[bufferViewIndex - 1];
|
||||
const byteOffset = defined(previousBufferView)
|
||||
? previousBufferView.byteOffset + previousBufferView.byteLength
|
||||
: 0;
|
||||
let byteLength = 0;
|
||||
for (let i = 0; i < length; ++i) {
|
||||
const accessor = gltf.accessors[accessors[i]];
|
||||
accessor.bufferView = bufferViewIndex;
|
||||
accessor.byteOffset = byteLength;
|
||||
byteLength += buffers[i].length;
|
||||
}
|
||||
gltf.bufferViews.push({
|
||||
name: `bufferView_${bufferViewIndex}`,
|
||||
buffer: 0,
|
||||
byteLength: byteLength,
|
||||
byteOffset: byteOffset,
|
||||
byteStride: byteStride,
|
||||
target: target,
|
||||
});
|
||||
}
|
||||
|
||||
function addCombinedBuffers(gltf, bufferState, name) {
|
||||
addCombinedBufferView(
|
||||
gltf,
|
||||
bufferState.positionBuffers,
|
||||
bufferState.positionAccessors,
|
||||
12,
|
||||
WebGLConstants.ARRAY_BUFFER,
|
||||
);
|
||||
addCombinedBufferView(
|
||||
gltf,
|
||||
bufferState.normalBuffers,
|
||||
bufferState.normalAccessors,
|
||||
12,
|
||||
WebGLConstants.ARRAY_BUFFER,
|
||||
);
|
||||
addCombinedBufferView(
|
||||
gltf,
|
||||
bufferState.uvBuffers,
|
||||
bufferState.uvAccessors,
|
||||
8,
|
||||
WebGLConstants.ARRAY_BUFFER,
|
||||
);
|
||||
addCombinedBufferView(
|
||||
gltf,
|
||||
bufferState.indexBuffers,
|
||||
bufferState.indexAccessors,
|
||||
undefined,
|
||||
WebGLConstants.ELEMENT_ARRAY_BUFFER,
|
||||
);
|
||||
|
||||
let buffers = [];
|
||||
buffers = buffers.concat(
|
||||
bufferState.positionBuffers,
|
||||
bufferState.normalBuffers,
|
||||
bufferState.uvBuffers,
|
||||
bufferState.indexBuffers,
|
||||
);
|
||||
const buffer = getBufferPadded(Buffer.concat(buffers));
|
||||
|
||||
gltf.buffers.push({
|
||||
name: name,
|
||||
byteLength: buffer.length,
|
||||
extras: {
|
||||
_obj2gltf: {
|
||||
source: buffer,
|
||||
},
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
function addSeparateBufferView(
|
||||
gltf,
|
||||
buffer,
|
||||
accessor,
|
||||
byteStride,
|
||||
target,
|
||||
name,
|
||||
) {
|
||||
const bufferIndex = gltf.buffers.length;
|
||||
const bufferViewIndex = gltf.bufferViews.length;
|
||||
|
||||
gltf.buffers.push({
|
||||
name: `${name}_${bufferIndex}`,
|
||||
byteLength: buffer.length,
|
||||
extras: {
|
||||
_obj2gltf: {
|
||||
source: buffer,
|
||||
},
|
||||
},
|
||||
});
|
||||
|
||||
gltf.bufferViews.push({
|
||||
buffer: bufferIndex,
|
||||
byteLength: buffer.length,
|
||||
byteOffset: 0,
|
||||
byteStride: byteStride,
|
||||
target: target,
|
||||
});
|
||||
|
||||
gltf.accessors[accessor].bufferView = bufferViewIndex;
|
||||
gltf.accessors[accessor].byteOffset = 0;
|
||||
}
|
||||
|
||||
function addSeparateBufferViews(
|
||||
gltf,
|
||||
buffers,
|
||||
accessors,
|
||||
byteStride,
|
||||
target,
|
||||
name,
|
||||
) {
|
||||
const length = buffers.length;
|
||||
for (let i = 0; i < length; ++i) {
|
||||
addSeparateBufferView(
|
||||
gltf,
|
||||
buffers[i],
|
||||
accessors[i],
|
||||
byteStride,
|
||||
target,
|
||||
name,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
function addSeparateBuffers(gltf, bufferState, name) {
|
||||
addSeparateBufferViews(
|
||||
gltf,
|
||||
bufferState.positionBuffers,
|
||||
bufferState.positionAccessors,
|
||||
12,
|
||||
WebGLConstants.ARRAY_BUFFER,
|
||||
name,
|
||||
);
|
||||
addSeparateBufferViews(
|
||||
gltf,
|
||||
bufferState.normalBuffers,
|
||||
bufferState.normalAccessors,
|
||||
12,
|
||||
WebGLConstants.ARRAY_BUFFER,
|
||||
name,
|
||||
);
|
||||
addSeparateBufferViews(
|
||||
gltf,
|
||||
bufferState.uvBuffers,
|
||||
bufferState.uvAccessors,
|
||||
8,
|
||||
WebGLConstants.ARRAY_BUFFER,
|
||||
name,
|
||||
);
|
||||
addSeparateBufferViews(
|
||||
gltf,
|
||||
bufferState.indexBuffers,
|
||||
bufferState.indexAccessors,
|
||||
undefined,
|
||||
WebGLConstants.ELEMENT_ARRAY_BUFFER,
|
||||
name,
|
||||
);
|
||||
}
|
||||
|
||||
function addBuffers(gltf, bufferState, name, separate) {
|
||||
const buffers = bufferState.positionBuffers.concat(
|
||||
bufferState.normalBuffers,
|
||||
bufferState.uvBuffers,
|
||||
bufferState.indexBuffers,
|
||||
);
|
||||
const buffersLength = buffers.length;
|
||||
let buffersByteLength = 0;
|
||||
for (let i = 0; i < buffersLength; ++i) {
|
||||
buffersByteLength += buffers[i].length;
|
||||
}
|
||||
|
||||
if (separate && buffersByteLength > createGltf._getBufferMaxByteLength()) {
|
||||
// Don't combine buffers if the combined buffer will exceed the Node limit.
|
||||
addSeparateBuffers(gltf, bufferState, name);
|
||||
} else {
|
||||
addCombinedBuffers(gltf, bufferState, name);
|
||||
}
|
||||
}
|
||||
|
||||
function addTexture(gltf, texture) {
|
||||
const imageName = texture.name;
|
||||
const textureName = texture.name;
|
||||
const imageIndex = gltf.images.length;
|
||||
const textureIndex = gltf.textures.length;
|
||||
|
||||
gltf.images.push({
|
||||
name: imageName,
|
||||
extras: {
|
||||
_obj2gltf: texture,
|
||||
},
|
||||
});
|
||||
|
||||
gltf.textures.push({
|
||||
name: textureName,
|
||||
sampler: 0,
|
||||
source: imageIndex,
|
||||
});
|
||||
|
||||
return textureIndex;
|
||||
}
|
||||
|
||||
function getTexture(gltf, texture) {
|
||||
let textureIndex;
|
||||
const images = gltf.images;
|
||||
const length = images.length;
|
||||
for (let i = 0; i < length; ++i) {
|
||||
if (images[i].extras._obj2gltf === texture) {
|
||||
textureIndex = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!defined(textureIndex)) {
|
||||
textureIndex = addTexture(gltf, texture);
|
||||
}
|
||||
|
||||
return {
|
||||
index: textureIndex,
|
||||
};
|
||||
}
|
||||
|
||||
function cloneMaterial(material, removeTextures) {
|
||||
if (typeof material !== "object") {
|
||||
return material;
|
||||
} else if (material instanceof Texture) {
|
||||
if (removeTextures) {
|
||||
return undefined;
|
||||
}
|
||||
return material;
|
||||
} else if (Array.isArray(material)) {
|
||||
const length = material.length;
|
||||
const clonedArray = new Array(length);
|
||||
for (let i = 0; i < length; ++i) {
|
||||
clonedArray[i] = cloneMaterial(material[i], removeTextures);
|
||||
}
|
||||
return clonedArray;
|
||||
}
|
||||
const clonedObject = {};
|
||||
for (const name in material) {
|
||||
if (Object.prototype.hasOwnProperty.call(material, name)) {
|
||||
clonedObject[name] = cloneMaterial(material[name], removeTextures);
|
||||
}
|
||||
}
|
||||
return clonedObject;
|
||||
}
|
||||
|
||||
function resolveTextures(gltf, material) {
|
||||
for (const name in material) {
|
||||
if (Object.prototype.hasOwnProperty.call(material, name)) {
|
||||
const property = material[name];
|
||||
if (property instanceof Texture) {
|
||||
material[name] = getTexture(gltf, property);
|
||||
} else if (!Array.isArray(property) && typeof property === "object") {
|
||||
resolveTextures(gltf, property);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function addGltfMaterial(gltf, material, options) {
|
||||
resolveTextures(gltf, material);
|
||||
const materialIndex = gltf.materials.length;
|
||||
if (options.unlit) {
|
||||
if (!defined(material.extensions)) {
|
||||
material.extensions = {};
|
||||
}
|
||||
material.extensions.KHR_materials_unlit = {};
|
||||
}
|
||||
gltf.materials.push(material);
|
||||
return materialIndex;
|
||||
}
|
||||
|
||||
function getMaterialByName(materials, materialName) {
|
||||
const materialsLength = materials.length;
|
||||
for (let i = 0; i < materialsLength; ++i) {
|
||||
if (materials[i].name === materialName) {
|
||||
return materials[i];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function getMaterialIndex(materials, materialName) {
|
||||
const materialsLength = materials.length;
|
||||
for (let i = 0; i < materialsLength; ++i) {
|
||||
if (materials[i].name === materialName) {
|
||||
return i;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function getOrCreateGltfMaterial(gltf, materials, materialName, options) {
|
||||
const material = getMaterialByName(materials, materialName);
|
||||
let materialIndex = getMaterialIndex(gltf.materials, materialName);
|
||||
|
||||
if (!defined(materialIndex)) {
|
||||
materialIndex = addGltfMaterial(gltf, material, options);
|
||||
}
|
||||
|
||||
return materialIndex;
|
||||
}
|
||||
|
||||
function primitiveInfoMatch(a, b) {
|
||||
return a.hasUvs === b.hasUvs && a.hasNormals === b.hasNormals;
|
||||
}
|
||||
|
||||
function getSplitMaterialName(
|
||||
originalMaterialName,
|
||||
primitiveInfo,
|
||||
primitiveInfoByMaterial,
|
||||
) {
|
||||
let splitMaterialName = originalMaterialName;
|
||||
let suffix = 2;
|
||||
while (defined(primitiveInfoByMaterial[splitMaterialName])) {
|
||||
if (
|
||||
primitiveInfoMatch(
|
||||
primitiveInfo,
|
||||
primitiveInfoByMaterial[splitMaterialName],
|
||||
)
|
||||
) {
|
||||
break;
|
||||
}
|
||||
splitMaterialName = `${originalMaterialName}-${suffix++}`;
|
||||
}
|
||||
return splitMaterialName;
|
||||
}
|
||||
|
||||
function splitIncompatibleMaterials(nodes, materials, options) {
|
||||
const splitMaterials = [];
|
||||
const primitiveInfoByMaterial = {};
|
||||
const nodesLength = nodes.length;
|
||||
for (let i = 0; i < nodesLength; ++i) {
|
||||
const meshes = nodes[i].meshes;
|
||||
const meshesLength = meshes.length;
|
||||
for (let j = 0; j < meshesLength; ++j) {
|
||||
const primitives = meshes[j].primitives;
|
||||
const primitivesLength = primitives.length;
|
||||
for (let k = 0; k < primitivesLength; ++k) {
|
||||
const primitive = primitives[k];
|
||||
const hasUvs = primitive.uvs.length > 0;
|
||||
const hasNormals = primitive.normals.length > 0;
|
||||
const primitiveInfo = {
|
||||
hasUvs: hasUvs,
|
||||
hasNormals: hasNormals,
|
||||
};
|
||||
const originalMaterialName = defaultValue(
|
||||
primitive.material,
|
||||
"default",
|
||||
);
|
||||
const splitMaterialName = getSplitMaterialName(
|
||||
originalMaterialName,
|
||||
primitiveInfo,
|
||||
primitiveInfoByMaterial,
|
||||
);
|
||||
primitive.material = splitMaterialName;
|
||||
primitiveInfoByMaterial[splitMaterialName] = primitiveInfo;
|
||||
|
||||
let splitMaterial = getMaterialByName(
|
||||
splitMaterials,
|
||||
splitMaterialName,
|
||||
);
|
||||
if (defined(splitMaterial)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
const originalMaterial = getMaterialByName(
|
||||
materials,
|
||||
originalMaterialName,
|
||||
);
|
||||
if (defined(originalMaterial)) {
|
||||
splitMaterial = cloneMaterial(originalMaterial, !hasUvs);
|
||||
} else {
|
||||
splitMaterial = getDefaultMaterial(options);
|
||||
}
|
||||
splitMaterial.name = splitMaterialName;
|
||||
splitMaterials.push(splitMaterial);
|
||||
}
|
||||
}
|
||||
}
|
||||
return splitMaterials;
|
||||
}
|
||||
|
||||
function addVertexAttribute(gltf, array, components, name) {
|
||||
const count = array.length / components;
|
||||
const minMax = array.getMinMax(components);
|
||||
const type = components === 3 ? "VEC3" : "VEC2";
|
||||
|
||||
const accessor = {
|
||||
name: name,
|
||||
componentType: WebGLConstants.FLOAT,
|
||||
count: count,
|
||||
min: minMax.min,
|
||||
max: minMax.max,
|
||||
type: type,
|
||||
};
|
||||
|
||||
const accessorIndex = gltf.accessors.length;
|
||||
gltf.accessors.push(accessor);
|
||||
return accessorIndex;
|
||||
}
|
||||
|
||||
function addIndexArray(gltf, array, uint32Indices, name) {
|
||||
const componentType = uint32Indices
|
||||
? WebGLConstants.UNSIGNED_INT
|
||||
: WebGLConstants.UNSIGNED_SHORT;
|
||||
const count = array.length;
|
||||
const minMax = array.getMinMax(1);
|
||||
|
||||
const accessor = {
|
||||
name: name,
|
||||
componentType: componentType,
|
||||
count: count,
|
||||
min: minMax.min,
|
||||
max: minMax.max,
|
||||
type: "SCALAR",
|
||||
};
|
||||
|
||||
const accessorIndex = gltf.accessors.length;
|
||||
gltf.accessors.push(accessor);
|
||||
return accessorIndex;
|
||||
}
|
||||
|
||||
function requiresUint32Indices(nodes) {
|
||||
const nodesLength = nodes.length;
|
||||
for (let i = 0; i < nodesLength; ++i) {
|
||||
const meshes = nodes[i].meshes;
|
||||
const meshesLength = meshes.length;
|
||||
for (let j = 0; j < meshesLength; ++j) {
|
||||
const primitives = meshes[j].primitives;
|
||||
const primitivesLength = primitives.length;
|
||||
for (let k = 0; k < primitivesLength; ++k) {
|
||||
// Reserve the 65535 index for primitive restart
|
||||
const vertexCount = primitives[k].positions.length / 3;
|
||||
if (vertexCount > 65534) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
function addPrimitive(
|
||||
gltf,
|
||||
materials,
|
||||
bufferState,
|
||||
uint32Indices,
|
||||
mesh,
|
||||
primitive,
|
||||
index,
|
||||
options,
|
||||
) {
|
||||
const hasPositions = primitive.positions.length > 0;
|
||||
const hasNormals = primitive.normals.length > 0;
|
||||
const hasUVs = primitive.uvs.length > 0;
|
||||
|
||||
const attributes = {};
|
||||
if (hasPositions) {
|
||||
const accessorIndex = addVertexAttribute(
|
||||
gltf,
|
||||
primitive.positions,
|
||||
3,
|
||||
`${mesh.name}_${index}_positions`,
|
||||
);
|
||||
attributes.POSITION = accessorIndex;
|
||||
bufferState.positionBuffers.push(primitive.positions.toFloatBuffer());
|
||||
bufferState.positionAccessors.push(accessorIndex);
|
||||
}
|
||||
if (hasNormals) {
|
||||
const accessorIndex = addVertexAttribute(
|
||||
gltf,
|
||||
primitive.normals,
|
||||
3,
|
||||
`${mesh.name}_${index}_normals`,
|
||||
);
|
||||
attributes.NORMAL = accessorIndex;
|
||||
bufferState.normalBuffers.push(primitive.normals.toFloatBuffer());
|
||||
bufferState.normalAccessors.push(accessorIndex);
|
||||
}
|
||||
if (hasUVs) {
|
||||
const accessorIndex = addVertexAttribute(
|
||||
gltf,
|
||||
primitive.uvs,
|
||||
2,
|
||||
`${mesh.name}_${index}_texcoords`,
|
||||
);
|
||||
attributes.TEXCOORD_0 = accessorIndex;
|
||||
bufferState.uvBuffers.push(primitive.uvs.toFloatBuffer());
|
||||
bufferState.uvAccessors.push(accessorIndex);
|
||||
}
|
||||
|
||||
const indexAccessorIndex = addIndexArray(
|
||||
gltf,
|
||||
primitive.indices,
|
||||
uint32Indices,
|
||||
`${mesh.name}_${index}_indices`,
|
||||
);
|
||||
const indexBuffer = uint32Indices
|
||||
? primitive.indices.toUint32Buffer()
|
||||
: primitive.indices.toUint16Buffer();
|
||||
bufferState.indexBuffers.push(indexBuffer);
|
||||
bufferState.indexAccessors.push(indexAccessorIndex);
|
||||
|
||||
// Unload resources
|
||||
primitive.positions = undefined;
|
||||
primitive.normals = undefined;
|
||||
primitive.uvs = undefined;
|
||||
primitive.indices = undefined;
|
||||
|
||||
const materialIndex = getOrCreateGltfMaterial(
|
||||
gltf,
|
||||
materials,
|
||||
primitive.material,
|
||||
options,
|
||||
);
|
||||
|
||||
return {
|
||||
attributes: attributes,
|
||||
indices: indexAccessorIndex,
|
||||
material: materialIndex,
|
||||
mode: WebGLConstants.TRIANGLES,
|
||||
};
|
||||
}
|
||||
|
||||
function addMesh(gltf, materials, bufferState, uint32Indices, mesh, options) {
|
||||
const gltfPrimitives = [];
|
||||
const primitives = mesh.primitives;
|
||||
const primitivesLength = primitives.length;
|
||||
for (let i = 0; i < primitivesLength; ++i) {
|
||||
gltfPrimitives.push(
|
||||
addPrimitive(
|
||||
gltf,
|
||||
materials,
|
||||
bufferState,
|
||||
uint32Indices,
|
||||
mesh,
|
||||
primitives[i],
|
||||
i,
|
||||
options,
|
||||
),
|
||||
);
|
||||
}
|
||||
|
||||
const gltfMesh = {
|
||||
name: mesh.name,
|
||||
primitives: gltfPrimitives,
|
||||
};
|
||||
|
||||
const meshIndex = gltf.meshes.length;
|
||||
gltf.meshes.push(gltfMesh);
|
||||
return meshIndex;
|
||||
}
|
||||
|
||||
function addNode(gltf, name, meshIndex, parentIndex) {
|
||||
const node = {
|
||||
name: name,
|
||||
mesh: meshIndex,
|
||||
};
|
||||
|
||||
const nodeIndex = gltf.nodes.length;
|
||||
gltf.nodes.push(node);
|
||||
|
||||
if (defined(parentIndex)) {
|
||||
const parentNode = gltf.nodes[parentIndex];
|
||||
if (!defined(parentNode.children)) {
|
||||
parentNode.children = [];
|
||||
}
|
||||
parentNode.children.push(nodeIndex);
|
||||
} else {
|
||||
gltf.scenes[gltf.scene].nodes.push(nodeIndex);
|
||||
}
|
||||
|
||||
return nodeIndex;
|
||||
}
|
||||
|
||||
// Exposed for testing
|
||||
createGltf._getBufferMaxByteLength = function () {
|
||||
return BUFFER_MAX_BYTE_LENGTH;
|
||||
};
|
||||
+22
@@ -0,0 +1,22 @@
|
||||
"use strict";
|
||||
module.exports = getBufferPadded;
|
||||
|
||||
/**
|
||||
* Pad the buffer to the next 4-byte boundary to ensure proper alignment for the section that follows.
|
||||
*
|
||||
* @param {Buffer} buffer The buffer.
|
||||
* @returns {Buffer} The padded buffer.
|
||||
*
|
||||
* @private
|
||||
*/
|
||||
function getBufferPadded(buffer) {
|
||||
const boundary = 4;
|
||||
const byteLength = buffer.length;
|
||||
const remainder = byteLength % boundary;
|
||||
if (remainder === 0) {
|
||||
return buffer;
|
||||
}
|
||||
const padding = remainder === 0 ? 0 : boundary - remainder;
|
||||
const emptyBuffer = Buffer.alloc(padding);
|
||||
return Buffer.concat([buffer, emptyBuffer]);
|
||||
}
|
||||
+29
@@ -0,0 +1,29 @@
|
||||
"use strict";
|
||||
module.exports = getJsonBufferPadded;
|
||||
|
||||
/**
|
||||
* Convert the JSON object to a padded buffer.
|
||||
*
|
||||
* Pad the JSON with extra whitespace to fit the next 4-byte boundary. This ensures proper alignment
|
||||
* for the section that follows.
|
||||
*
|
||||
* @param {Object} [json] The JSON object.
|
||||
* @returns {Buffer} The padded JSON buffer.
|
||||
*
|
||||
* @private
|
||||
*/
|
||||
function getJsonBufferPadded(json) {
|
||||
let string = JSON.stringify(json);
|
||||
|
||||
const boundary = 4;
|
||||
const byteLength = Buffer.byteLength(string);
|
||||
const remainder = byteLength % boundary;
|
||||
const padding = remainder === 0 ? 0 : boundary - remainder;
|
||||
let whitespace = "";
|
||||
for (let i = 0; i < padding; ++i) {
|
||||
whitespace += " ";
|
||||
}
|
||||
string += whitespace;
|
||||
|
||||
return Buffer.from(string);
|
||||
}
|
||||
+61
@@ -0,0 +1,61 @@
|
||||
"use strict";
|
||||
const Cesium = require("cesium");
|
||||
const getJsonBufferPadded = require("./getJsonBufferPadded");
|
||||
|
||||
const defined = Cesium.defined;
|
||||
|
||||
module.exports = gltfToGlb;
|
||||
|
||||
/**
|
||||
* Convert a glTF to binary glTF.
|
||||
*
|
||||
* The glTF is expected to have a single buffer and all embedded resources stored in bufferViews.
|
||||
*
|
||||
* @param {Object} gltf The glTF asset.
|
||||
* @param {Buffer} binaryBuffer The binary buffer.
|
||||
* @returns {Buffer} The glb buffer.
|
||||
*
|
||||
* @private
|
||||
*/
|
||||
function gltfToGlb(gltf, binaryBuffer) {
|
||||
const buffer = gltf.buffers[0];
|
||||
if (defined(buffer.uri)) {
|
||||
binaryBuffer = Buffer.alloc(0);
|
||||
}
|
||||
|
||||
// Create padded binary scene string
|
||||
const jsonBuffer = getJsonBufferPadded(gltf);
|
||||
|
||||
// Allocate buffer (Global header) + (JSON chunk header) + (JSON chunk) + (Binary chunk header) + (Binary chunk)
|
||||
const glbLength = 12 + 8 + jsonBuffer.length + 8 + binaryBuffer.length;
|
||||
const glb = Buffer.alloc(glbLength);
|
||||
|
||||
// Write binary glTF header (magic, version, length)
|
||||
let byteOffset = 0;
|
||||
glb.writeUInt32LE(0x46546c67, byteOffset);
|
||||
byteOffset += 4;
|
||||
glb.writeUInt32LE(2, byteOffset);
|
||||
byteOffset += 4;
|
||||
glb.writeUInt32LE(glbLength, byteOffset);
|
||||
byteOffset += 4;
|
||||
|
||||
// Write JSON Chunk header (length, type)
|
||||
glb.writeUInt32LE(jsonBuffer.length, byteOffset);
|
||||
byteOffset += 4;
|
||||
glb.writeUInt32LE(0x4e4f534a, byteOffset); // JSON
|
||||
byteOffset += 4;
|
||||
|
||||
// Write JSON Chunk
|
||||
jsonBuffer.copy(glb, byteOffset);
|
||||
byteOffset += jsonBuffer.length;
|
||||
|
||||
// Write Binary Chunk header (length, type)
|
||||
glb.writeUInt32LE(binaryBuffer.length, byteOffset);
|
||||
byteOffset += 4;
|
||||
glb.writeUInt32LE(0x004e4942, byteOffset); // BIN
|
||||
byteOffset += 4;
|
||||
|
||||
// Write Binary Chunk
|
||||
binaryBuffer.copy(glb, byteOffset);
|
||||
return glb;
|
||||
}
|
||||
+991
@@ -0,0 +1,991 @@
|
||||
"use strict";
|
||||
const Cesium = require("cesium");
|
||||
const path = require("path");
|
||||
const Promise = require("bluebird");
|
||||
const loadTexture = require("./loadTexture");
|
||||
const outsideDirectory = require("./outsideDirectory");
|
||||
const readLines = require("./readLines");
|
||||
const Texture = require("./Texture");
|
||||
|
||||
const CesiumMath = Cesium.Math;
|
||||
const clone = Cesium.clone;
|
||||
const combine = Cesium.combine;
|
||||
const defaultValue = (a, b) => a ?? b;
|
||||
const defined = Cesium.defined;
|
||||
|
||||
module.exports = loadMtl;
|
||||
|
||||
/**
|
||||
* Parse a .mtl file and load textures referenced within. Returns an array of glTF materials with Texture
|
||||
* objects stored in the texture slots.
|
||||
* <p>
|
||||
* Packed PBR textures (like metallicRoughnessOcclusion and specularGlossiness) require all input textures to be decoded before hand.
|
||||
* If a texture is of an unsupported format like .gif or .tga it can't be packed and a metallicRoughness texture will not be created.
|
||||
* Similarly if a texture cannot be found it will be ignored and a default value will be used instead.
|
||||
* </p>
|
||||
*
|
||||
* @param {String} mtlPath Path to the .mtl file.
|
||||
* @param {Object} options The options object passed along from lib/obj2gltf.js
|
||||
* @returns {Promise} A promise resolving to an array of glTF materials with Texture objects stored in the texture slots.
|
||||
*
|
||||
* @private
|
||||
*/
|
||||
function loadMtl(mtlPath, options) {
|
||||
let material;
|
||||
let values;
|
||||
let value;
|
||||
|
||||
const mtlDirectory = path.dirname(mtlPath);
|
||||
const materials = [];
|
||||
const texturePromiseMap = {}; // Maps texture paths to load promises so that no texture is loaded twice
|
||||
const texturePromises = [];
|
||||
|
||||
const overridingTextures = options.overridingTextures;
|
||||
const overridingSpecularTexture = defaultValue(
|
||||
overridingTextures.metallicRoughnessOcclusionTexture,
|
||||
overridingTextures.specularGlossinessTexture,
|
||||
);
|
||||
const overridingSpecularShininessTexture = defaultValue(
|
||||
overridingTextures.metallicRoughnessOcclusionTexture,
|
||||
overridingTextures.specularGlossinessTexture,
|
||||
);
|
||||
const overridingAmbientTexture = defaultValue(
|
||||
overridingTextures.metallicRoughnessOcclusionTexture,
|
||||
overridingTextures.occlusionTexture,
|
||||
);
|
||||
const overridingNormalTexture = overridingTextures.normalTexture;
|
||||
const overridingDiffuseTexture = overridingTextures.baseColorTexture;
|
||||
const overridingEmissiveTexture = overridingTextures.emissiveTexture;
|
||||
const overridingAlphaTexture = overridingTextures.alphaTexture;
|
||||
|
||||
// Textures that are packed into PBR textures need to be decoded first
|
||||
const decodeOptions = {
|
||||
decode: true,
|
||||
};
|
||||
|
||||
const diffuseTextureOptions = {
|
||||
checkTransparency: options.checkTransparency,
|
||||
};
|
||||
|
||||
const ambientTextureOptions = defined(overridingAmbientTexture)
|
||||
? undefined
|
||||
: options.packOcclusion
|
||||
? decodeOptions
|
||||
: undefined;
|
||||
const specularTextureOptions = defined(overridingSpecularTexture)
|
||||
? undefined
|
||||
: decodeOptions;
|
||||
const specularShinessTextureOptions = defined(
|
||||
overridingSpecularShininessTexture,
|
||||
)
|
||||
? undefined
|
||||
: decodeOptions;
|
||||
const emissiveTextureOptions = undefined;
|
||||
const normalTextureOptions = undefined;
|
||||
const alphaTextureOptions = {
|
||||
decode: true,
|
||||
};
|
||||
|
||||
function createMaterial(name) {
|
||||
material = new Material();
|
||||
material.name = name;
|
||||
material.specularShininess = options.metallicRoughness ? 1.0 : 0.0;
|
||||
material.specularTexture = overridingSpecularTexture;
|
||||
material.specularShininessTexture = overridingSpecularShininessTexture;
|
||||
material.diffuseTexture = overridingDiffuseTexture;
|
||||
material.ambientTexture = overridingAmbientTexture;
|
||||
material.normalTexture = overridingNormalTexture;
|
||||
material.emissiveTexture = overridingEmissiveTexture;
|
||||
material.alphaTexture = overridingAlphaTexture;
|
||||
materials.push(material);
|
||||
}
|
||||
|
||||
function normalizeTexturePath(texturePath, mtlDirectory) {
|
||||
//Remove double quotes around the texture file if it exists
|
||||
texturePath = texturePath.replace(/^"(.+)"$/, "$1");
|
||||
// Removes texture options from texture name
|
||||
// Assumes no spaces in texture name
|
||||
const re = /-(bm|t|s|o|blendu|blendv|boost|mm|texres|clamp|imfchan|type)/;
|
||||
if (re.test(texturePath)) {
|
||||
texturePath = texturePath.split(/\s+/).pop();
|
||||
}
|
||||
texturePath = texturePath.replace(/\\/g, "/");
|
||||
return path.normalize(path.resolve(mtlDirectory, texturePath));
|
||||
}
|
||||
|
||||
function parseLine(line) {
|
||||
line = line.trim();
|
||||
if (/^newmtl/i.test(line)) {
|
||||
const name = line.substring(7).trim();
|
||||
createMaterial(name);
|
||||
} else if (/^Ka /i.test(line)) {
|
||||
values = line.substring(3).trim().split(" ");
|
||||
material.ambientColor = [
|
||||
parseFloat(values[0]),
|
||||
parseFloat(values[1]),
|
||||
parseFloat(values[2]),
|
||||
1.0,
|
||||
];
|
||||
} else if (/^Ke /i.test(line)) {
|
||||
values = line.substring(3).trim().split(" ");
|
||||
material.emissiveColor = [
|
||||
parseFloat(values[0]),
|
||||
parseFloat(values[1]),
|
||||
parseFloat(values[2]),
|
||||
1.0,
|
||||
];
|
||||
} else if (/^Kd /i.test(line)) {
|
||||
values = line.substring(3).trim().split(" ");
|
||||
material.diffuseColor = [
|
||||
parseFloat(values[0]),
|
||||
parseFloat(values[1]),
|
||||
parseFloat(values[2]),
|
||||
1.0,
|
||||
];
|
||||
} else if (/^Ks /i.test(line)) {
|
||||
values = line.substring(3).trim().split(" ");
|
||||
material.specularColor = [
|
||||
parseFloat(values[0]),
|
||||
parseFloat(values[1]),
|
||||
parseFloat(values[2]),
|
||||
1.0,
|
||||
];
|
||||
} else if (/^Ns /i.test(line)) {
|
||||
value = line.substring(3).trim();
|
||||
material.specularShininess = parseFloat(value);
|
||||
} else if (/^d /i.test(line)) {
|
||||
value = line.substring(2).trim();
|
||||
material.alpha = correctAlpha(parseFloat(value));
|
||||
} else if (/^Tr /i.test(line)) {
|
||||
value = line.substring(3).trim();
|
||||
material.alpha = correctAlpha(1.0 - parseFloat(value));
|
||||
} else if (/^map_Ka /i.test(line)) {
|
||||
if (!defined(overridingAmbientTexture)) {
|
||||
material.ambientTexture = normalizeTexturePath(
|
||||
line.substring(7).trim(),
|
||||
mtlDirectory,
|
||||
);
|
||||
}
|
||||
} else if (/^map_Ke /i.test(line)) {
|
||||
if (!defined(overridingEmissiveTexture)) {
|
||||
material.emissiveTexture = normalizeTexturePath(
|
||||
line.substring(7).trim(),
|
||||
mtlDirectory,
|
||||
);
|
||||
}
|
||||
} else if (/^map_Kd /i.test(line)) {
|
||||
if (!defined(overridingDiffuseTexture)) {
|
||||
material.diffuseTexture = normalizeTexturePath(
|
||||
line.substring(7).trim(),
|
||||
mtlDirectory,
|
||||
);
|
||||
}
|
||||
} else if (/^map_Ks /i.test(line)) {
|
||||
if (!defined(overridingSpecularTexture)) {
|
||||
material.specularTexture = normalizeTexturePath(
|
||||
line.substring(7).trim(),
|
||||
mtlDirectory,
|
||||
);
|
||||
}
|
||||
} else if (/^map_Ns /i.test(line)) {
|
||||
if (!defined(overridingSpecularShininessTexture)) {
|
||||
material.specularShininessTexture = normalizeTexturePath(
|
||||
line.substring(7).trim(),
|
||||
mtlDirectory,
|
||||
);
|
||||
}
|
||||
} else if (/^map_Bump /i.test(line)) {
|
||||
if (!defined(overridingNormalTexture)) {
|
||||
material.normalTexture = normalizeTexturePath(
|
||||
line.substring(9).trim(),
|
||||
mtlDirectory,
|
||||
);
|
||||
}
|
||||
} else if (/^map_d /i.test(line)) {
|
||||
if (!defined(overridingAlphaTexture)) {
|
||||
material.alphaTexture = normalizeTexturePath(
|
||||
line.substring(6).trim(),
|
||||
mtlDirectory,
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function loadMaterialTextures(material) {
|
||||
// If an alpha texture is present the diffuse texture needs to be decoded so they can be packed together
|
||||
const diffuseAlphaTextureOptions = defined(material.alphaTexture)
|
||||
? alphaTextureOptions
|
||||
: diffuseTextureOptions;
|
||||
|
||||
if (material.diffuseTexture === material.ambientTexture) {
|
||||
// OBJ models are often exported with the same texture in the diffuse and ambient slots but this is typically not desirable, particularly
|
||||
// when saving with PBR materials where the ambient texture is treated as the occlusion texture.
|
||||
material.ambientTexture = undefined;
|
||||
}
|
||||
|
||||
const textureNames = [
|
||||
"diffuseTexture",
|
||||
"ambientTexture",
|
||||
"emissiveTexture",
|
||||
"specularTexture",
|
||||
"specularShininessTexture",
|
||||
"normalTexture",
|
||||
"alphaTexture",
|
||||
];
|
||||
const textureOptions = [
|
||||
diffuseAlphaTextureOptions,
|
||||
ambientTextureOptions,
|
||||
emissiveTextureOptions,
|
||||
specularTextureOptions,
|
||||
specularShinessTextureOptions,
|
||||
normalTextureOptions,
|
||||
alphaTextureOptions,
|
||||
];
|
||||
|
||||
const sharedOptions = {};
|
||||
textureNames.forEach(function (name, index) {
|
||||
const texturePath = material[name];
|
||||
const originalOptions = textureOptions[index];
|
||||
if (defined(texturePath) && defined(originalOptions)) {
|
||||
if (!defined(sharedOptions[texturePath])) {
|
||||
sharedOptions[texturePath] = clone(originalOptions);
|
||||
}
|
||||
const options = sharedOptions[texturePath];
|
||||
options.checkTransparency =
|
||||
options.checkTransparency || originalOptions.checkTransparency;
|
||||
options.decode = options.decode || originalOptions.decode;
|
||||
options.keepSource =
|
||||
options.keepSource ||
|
||||
!originalOptions.decode ||
|
||||
!originalOptions.checkTransparency;
|
||||
}
|
||||
});
|
||||
|
||||
textureNames.forEach(function (name) {
|
||||
const texturePath = material[name];
|
||||
if (defined(texturePath)) {
|
||||
loadMaterialTexture(
|
||||
material,
|
||||
name,
|
||||
sharedOptions[texturePath],
|
||||
mtlDirectory,
|
||||
texturePromiseMap,
|
||||
texturePromises,
|
||||
options,
|
||||
);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
return readLines(mtlPath, parseLine)
|
||||
.then(function () {
|
||||
const length = materials.length;
|
||||
for (let i = 0; i < length; ++i) {
|
||||
loadMaterialTextures(materials[i]);
|
||||
}
|
||||
return Promise.all(texturePromises);
|
||||
})
|
||||
.then(function () {
|
||||
return convertMaterials(materials, options);
|
||||
});
|
||||
}
|
||||
|
||||
function correctAlpha(alpha) {
|
||||
// An alpha of 0.0 usually implies a problem in the export, change to 1.0 instead
|
||||
return alpha === 0.0 ? 1.0 : alpha;
|
||||
}
|
||||
|
||||
function Material() {
|
||||
this.name = undefined;
|
||||
this.ambientColor = [0.0, 0.0, 0.0, 1.0]; // Ka
|
||||
this.emissiveColor = [0.0, 0.0, 0.0, 1.0]; // Ke
|
||||
this.diffuseColor = [0.5, 0.5, 0.5, 1.0]; // Kd
|
||||
this.specularColor = [0.0, 0.0, 0.0, 1.0]; // Ks
|
||||
this.specularShininess = 0.0; // Ns
|
||||
this.alpha = 1.0; // d / Tr
|
||||
this.ambientTexture = undefined; // map_Ka
|
||||
this.emissiveTexture = undefined; // map_Ke
|
||||
this.diffuseTexture = undefined; // map_Kd
|
||||
this.specularTexture = undefined; // map_Ks
|
||||
this.specularShininessTexture = undefined; // map_Ns
|
||||
this.normalTexture = undefined; // map_Bump
|
||||
this.alphaTexture = undefined; // map_d
|
||||
}
|
||||
|
||||
loadMtl.getDefaultMaterial = function (options) {
|
||||
return convertMaterial(new Material(), options);
|
||||
};
|
||||
|
||||
// Exposed for testing
|
||||
loadMtl._createMaterial = function (materialOptions, options) {
|
||||
return convertMaterial(combine(materialOptions, new Material()), options);
|
||||
};
|
||||
|
||||
function loadMaterialTexture(
|
||||
material,
|
||||
name,
|
||||
textureOptions,
|
||||
mtlDirectory,
|
||||
texturePromiseMap,
|
||||
texturePromises,
|
||||
options,
|
||||
) {
|
||||
const texturePath = material[name];
|
||||
if (!defined(texturePath)) {
|
||||
return;
|
||||
}
|
||||
|
||||
let texturePromise = texturePromiseMap[texturePath];
|
||||
if (!defined(texturePromise)) {
|
||||
const shallowPath = path.join(mtlDirectory, path.basename(texturePath));
|
||||
if (options.secure && outsideDirectory(texturePath, mtlDirectory)) {
|
||||
// Try looking for the texture in the same directory as the obj
|
||||
options.logger(
|
||||
"Texture file is outside of the mtl directory and the secure flag is true. Attempting to read the texture file from within the obj directory instead.",
|
||||
);
|
||||
texturePromise = loadTexture(shallowPath, textureOptions).catch(
|
||||
function (error) {
|
||||
options.logger(error.message);
|
||||
options.logger(
|
||||
`Could not read texture file at ${shallowPath}. This texture will be ignored`,
|
||||
);
|
||||
},
|
||||
);
|
||||
} else {
|
||||
texturePromise = loadTexture(texturePath, textureOptions)
|
||||
.catch(function (error) {
|
||||
// Try looking for the texture in the same directory as the obj
|
||||
options.logger(error.message);
|
||||
options.logger(
|
||||
`Could not read texture file at ${texturePath}. Attempting to read the texture file from within the obj directory instead.`,
|
||||
);
|
||||
return loadTexture(shallowPath, textureOptions);
|
||||
})
|
||||
.catch(function (error) {
|
||||
options.logger(error.message);
|
||||
options.logger(
|
||||
`Could not read texture file at ${shallowPath}. This texture will be ignored.`,
|
||||
);
|
||||
});
|
||||
}
|
||||
texturePromiseMap[texturePath] = texturePromise;
|
||||
}
|
||||
|
||||
texturePromises.push(
|
||||
texturePromise.then(function (texture) {
|
||||
material[name] = texture;
|
||||
}),
|
||||
);
|
||||
}
|
||||
|
||||
function convertMaterial(material, options) {
|
||||
if (options.specularGlossiness) {
|
||||
return createSpecularGlossinessMaterial(material, options);
|
||||
} else if (options.metallicRoughness) {
|
||||
return createMetallicRoughnessMaterial(material, options);
|
||||
}
|
||||
// No material type specified, convert the material to metallic roughness
|
||||
convertTraditionalToMetallicRoughness(material);
|
||||
return createMetallicRoughnessMaterial(material, options);
|
||||
}
|
||||
|
||||
function convertMaterials(materials, options) {
|
||||
return materials.map(function (material) {
|
||||
return convertMaterial(material, options);
|
||||
});
|
||||
}
|
||||
|
||||
function resizeChannel(
|
||||
sourcePixels,
|
||||
sourceWidth,
|
||||
sourceHeight,
|
||||
targetPixels,
|
||||
targetWidth,
|
||||
targetHeight,
|
||||
) {
|
||||
// Nearest neighbor sampling
|
||||
const widthRatio = sourceWidth / targetWidth;
|
||||
const heightRatio = sourceHeight / targetHeight;
|
||||
|
||||
for (let y = 0; y < targetHeight; ++y) {
|
||||
for (let x = 0; x < targetWidth; ++x) {
|
||||
const targetIndex = y * targetWidth + x;
|
||||
const sourceY = Math.round(y * heightRatio);
|
||||
const sourceX = Math.round(x * widthRatio);
|
||||
const sourceIndex = sourceY * sourceWidth + sourceX;
|
||||
const sourceValue = sourcePixels.readUInt8(sourceIndex);
|
||||
targetPixels.writeUInt8(sourceValue, targetIndex);
|
||||
}
|
||||
}
|
||||
return targetPixels;
|
||||
}
|
||||
|
||||
let scratchResizeChannel;
|
||||
|
||||
function getTextureChannel(
|
||||
texture,
|
||||
index,
|
||||
targetWidth,
|
||||
targetHeight,
|
||||
targetChannel,
|
||||
) {
|
||||
const pixels = texture.pixels; // RGBA
|
||||
const sourceWidth = texture.width;
|
||||
const sourceHeight = texture.height;
|
||||
const sourcePixelsLength = sourceWidth * sourceHeight;
|
||||
const targetPixelsLength = targetWidth * targetHeight;
|
||||
|
||||
// Allocate the scratchResizeChannel on demand if the texture needs to be resized
|
||||
let sourceChannel = targetChannel;
|
||||
if (sourcePixelsLength > targetPixelsLength) {
|
||||
if (
|
||||
!defined(scratchResizeChannel) ||
|
||||
sourcePixelsLength > scratchResizeChannel.length
|
||||
) {
|
||||
scratchResizeChannel = Buffer.alloc(sourcePixelsLength);
|
||||
}
|
||||
sourceChannel = scratchResizeChannel;
|
||||
}
|
||||
|
||||
for (let i = 0; i < sourcePixelsLength; ++i) {
|
||||
const value = pixels.readUInt8(i * 4 + index);
|
||||
sourceChannel.writeUInt8(value, i);
|
||||
}
|
||||
|
||||
if (sourcePixelsLength > targetPixelsLength) {
|
||||
resizeChannel(
|
||||
sourceChannel,
|
||||
sourceWidth,
|
||||
sourceHeight,
|
||||
targetChannel,
|
||||
targetWidth,
|
||||
targetHeight,
|
||||
);
|
||||
}
|
||||
|
||||
return targetChannel;
|
||||
}
|
||||
|
||||
function writeChannel(pixels, channel, index) {
|
||||
const pixelsLength = pixels.length / 4;
|
||||
for (let i = 0; i < pixelsLength; ++i) {
|
||||
const value = channel.readUInt8(i);
|
||||
pixels.writeUInt8(value, i * 4 + index);
|
||||
}
|
||||
}
|
||||
|
||||
function getMinimumDimensions(textures, options) {
|
||||
let width = Number.POSITIVE_INFINITY;
|
||||
let height = Number.POSITIVE_INFINITY;
|
||||
|
||||
const length = textures.length;
|
||||
for (let i = 0; i < length; ++i) {
|
||||
const texture = textures[i];
|
||||
width = Math.min(texture.width, width);
|
||||
height = Math.min(texture.height, height);
|
||||
}
|
||||
|
||||
for (let i = 0; i < length; ++i) {
|
||||
const texture = textures[i];
|
||||
if (texture.width !== width || texture.height !== height) {
|
||||
options.logger(
|
||||
`Texture ${texture.path} will be scaled from ${texture.width}x${texture.height} to ${width}x${height}.`,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
return [width, height];
|
||||
}
|
||||
|
||||
function isChannelSingleColor(buffer) {
|
||||
const first = buffer.readUInt8(0);
|
||||
const length = buffer.length;
|
||||
for (let i = 1; i < length; ++i) {
|
||||
if (buffer[i] !== first) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
function createDiffuseAlphaTexture(diffuseTexture, alphaTexture, options) {
|
||||
const packDiffuse = defined(diffuseTexture);
|
||||
const packAlpha = defined(alphaTexture);
|
||||
|
||||
if (!packDiffuse) {
|
||||
return undefined;
|
||||
}
|
||||
|
||||
if (!packAlpha) {
|
||||
return diffuseTexture;
|
||||
}
|
||||
|
||||
if (diffuseTexture === alphaTexture) {
|
||||
return diffuseTexture;
|
||||
}
|
||||
|
||||
if (!defined(diffuseTexture.pixels) || !defined(alphaTexture.pixels)) {
|
||||
options.logger(
|
||||
`Could not get decoded texture data for ${diffuseTexture.path} or ${alphaTexture.path}. The material will be created without an alpha texture.`,
|
||||
);
|
||||
return diffuseTexture;
|
||||
}
|
||||
|
||||
const packedTextures = [diffuseTexture, alphaTexture];
|
||||
const dimensions = getMinimumDimensions(packedTextures, options);
|
||||
const width = dimensions[0];
|
||||
const height = dimensions[1];
|
||||
const pixelsLength = width * height;
|
||||
const pixels = Buffer.alloc(pixelsLength * 4, 0xff); // Initialize with 4 channels
|
||||
const scratchChannel = Buffer.alloc(pixelsLength);
|
||||
|
||||
// Write into the R, G, B channels
|
||||
const redChannel = getTextureChannel(
|
||||
diffuseTexture,
|
||||
0,
|
||||
width,
|
||||
height,
|
||||
scratchChannel,
|
||||
);
|
||||
writeChannel(pixels, redChannel, 0);
|
||||
const greenChannel = getTextureChannel(
|
||||
diffuseTexture,
|
||||
1,
|
||||
width,
|
||||
height,
|
||||
scratchChannel,
|
||||
);
|
||||
writeChannel(pixels, greenChannel, 1);
|
||||
const blueChannel = getTextureChannel(
|
||||
diffuseTexture,
|
||||
2,
|
||||
width,
|
||||
height,
|
||||
scratchChannel,
|
||||
);
|
||||
writeChannel(pixels, blueChannel, 2);
|
||||
|
||||
// First try reading the alpha component from the alpha channel, but if it is a single color read from the red channel instead.
|
||||
let alphaChannel = getTextureChannel(
|
||||
alphaTexture,
|
||||
3,
|
||||
width,
|
||||
height,
|
||||
scratchChannel,
|
||||
);
|
||||
if (isChannelSingleColor(alphaChannel)) {
|
||||
alphaChannel = getTextureChannel(
|
||||
alphaTexture,
|
||||
0,
|
||||
width,
|
||||
height,
|
||||
scratchChannel,
|
||||
);
|
||||
}
|
||||
writeChannel(pixels, alphaChannel, 3);
|
||||
|
||||
const texture = new Texture();
|
||||
texture.name = diffuseTexture.name;
|
||||
texture.extension = ".png";
|
||||
texture.pixels = pixels;
|
||||
texture.width = width;
|
||||
texture.height = height;
|
||||
texture.transparent = true;
|
||||
|
||||
return texture;
|
||||
}
|
||||
|
||||
function createMetallicRoughnessTexture(
|
||||
metallicTexture,
|
||||
roughnessTexture,
|
||||
occlusionTexture,
|
||||
options,
|
||||
) {
|
||||
if (defined(options.overridingTextures.metallicRoughnessOcclusionTexture)) {
|
||||
return metallicTexture;
|
||||
}
|
||||
|
||||
const packMetallic = defined(metallicTexture);
|
||||
const packRoughness = defined(roughnessTexture);
|
||||
const packOcclusion = defined(occlusionTexture) && options.packOcclusion;
|
||||
|
||||
if (!packMetallic && !packRoughness) {
|
||||
return undefined;
|
||||
}
|
||||
|
||||
if (packMetallic && !defined(metallicTexture.pixels)) {
|
||||
options.logger(
|
||||
`Could not get decoded texture data for ${metallicTexture.path}. The material will be created without a metallicRoughness texture.`,
|
||||
);
|
||||
return undefined;
|
||||
}
|
||||
|
||||
if (packRoughness && !defined(roughnessTexture.pixels)) {
|
||||
options.logger(
|
||||
`Could not get decoded texture data for ${roughnessTexture.path}. The material will be created without a metallicRoughness texture.`,
|
||||
);
|
||||
return undefined;
|
||||
}
|
||||
|
||||
if (packOcclusion && !defined(occlusionTexture.pixels)) {
|
||||
options.logger(
|
||||
`Could not get decoded texture data for ${occlusionTexture.path}. The occlusion texture will not be packed in the metallicRoughness texture.`,
|
||||
);
|
||||
return undefined;
|
||||
}
|
||||
|
||||
const packedTextures = [
|
||||
metallicTexture,
|
||||
roughnessTexture,
|
||||
occlusionTexture,
|
||||
].filter(function (texture) {
|
||||
return defined(texture) && defined(texture.pixels);
|
||||
});
|
||||
|
||||
const dimensions = getMinimumDimensions(packedTextures, options);
|
||||
const width = dimensions[0];
|
||||
const height = dimensions[1];
|
||||
const pixelsLength = width * height;
|
||||
const pixels = Buffer.alloc(pixelsLength * 4, 0xff); // Initialize with 4 channels, unused channels will be white
|
||||
const scratchChannel = Buffer.alloc(pixelsLength);
|
||||
|
||||
if (packMetallic) {
|
||||
// Write into the B channel
|
||||
const metallicChannel = getTextureChannel(
|
||||
metallicTexture,
|
||||
0,
|
||||
width,
|
||||
height,
|
||||
scratchChannel,
|
||||
);
|
||||
writeChannel(pixels, metallicChannel, 2);
|
||||
}
|
||||
|
||||
if (packRoughness) {
|
||||
// Write into the G channel
|
||||
const roughnessChannel = getTextureChannel(
|
||||
roughnessTexture,
|
||||
0,
|
||||
width,
|
||||
height,
|
||||
scratchChannel,
|
||||
);
|
||||
writeChannel(pixels, roughnessChannel, 1);
|
||||
}
|
||||
|
||||
if (packOcclusion) {
|
||||
// Write into the R channel
|
||||
const occlusionChannel = getTextureChannel(
|
||||
occlusionTexture,
|
||||
0,
|
||||
width,
|
||||
height,
|
||||
scratchChannel,
|
||||
);
|
||||
writeChannel(pixels, occlusionChannel, 0);
|
||||
}
|
||||
|
||||
const length = packedTextures.length;
|
||||
const names = new Array(length);
|
||||
for (let i = 0; i < length; ++i) {
|
||||
names[i] = packedTextures[i].name;
|
||||
}
|
||||
const name = names.join("_");
|
||||
|
||||
const texture = new Texture();
|
||||
texture.name = name;
|
||||
texture.extension = ".png";
|
||||
texture.pixels = pixels;
|
||||
texture.width = width;
|
||||
texture.height = height;
|
||||
|
||||
return texture;
|
||||
}
|
||||
|
||||
function createSpecularGlossinessTexture(
|
||||
specularTexture,
|
||||
glossinessTexture,
|
||||
options,
|
||||
) {
|
||||
if (defined(options.overridingTextures.specularGlossinessTexture)) {
|
||||
return specularTexture;
|
||||
}
|
||||
|
||||
const packSpecular = defined(specularTexture);
|
||||
const packGlossiness = defined(glossinessTexture);
|
||||
|
||||
if (!packSpecular && !packGlossiness) {
|
||||
return undefined;
|
||||
}
|
||||
|
||||
if (packSpecular && !defined(specularTexture.pixels)) {
|
||||
options.logger(
|
||||
`Could not get decoded texture data for ${specularTexture.path}. The material will be created without a specularGlossiness texture.`,
|
||||
);
|
||||
return undefined;
|
||||
}
|
||||
|
||||
if (packGlossiness && !defined(glossinessTexture.pixels)) {
|
||||
options.logger(
|
||||
`Could not get decoded texture data for ${glossinessTexture.path}. The material will be created without a specularGlossiness texture.`,
|
||||
);
|
||||
return undefined;
|
||||
}
|
||||
|
||||
const packedTextures = [specularTexture, glossinessTexture].filter(
|
||||
function (texture) {
|
||||
return defined(texture) && defined(texture.pixels);
|
||||
},
|
||||
);
|
||||
|
||||
const dimensions = getMinimumDimensions(packedTextures, options);
|
||||
const width = dimensions[0];
|
||||
const height = dimensions[1];
|
||||
const pixelsLength = width * height;
|
||||
const pixels = Buffer.alloc(pixelsLength * 4, 0xff); // Initialize with 4 channels, unused channels will be white
|
||||
const scratchChannel = Buffer.alloc(pixelsLength);
|
||||
|
||||
if (packSpecular) {
|
||||
// Write into the R, G, B channels
|
||||
const redChannel = getTextureChannel(
|
||||
specularTexture,
|
||||
0,
|
||||
width,
|
||||
height,
|
||||
scratchChannel,
|
||||
);
|
||||
writeChannel(pixels, redChannel, 0);
|
||||
const greenChannel = getTextureChannel(
|
||||
specularTexture,
|
||||
1,
|
||||
width,
|
||||
height,
|
||||
scratchChannel,
|
||||
);
|
||||
writeChannel(pixels, greenChannel, 1);
|
||||
const blueChannel = getTextureChannel(
|
||||
specularTexture,
|
||||
2,
|
||||
width,
|
||||
height,
|
||||
scratchChannel,
|
||||
);
|
||||
writeChannel(pixels, blueChannel, 2);
|
||||
}
|
||||
|
||||
if (packGlossiness) {
|
||||
// Write into the A channel
|
||||
const glossinessChannel = getTextureChannel(
|
||||
glossinessTexture,
|
||||
0,
|
||||
width,
|
||||
height,
|
||||
scratchChannel,
|
||||
);
|
||||
writeChannel(pixels, glossinessChannel, 3);
|
||||
}
|
||||
|
||||
const length = packedTextures.length;
|
||||
const names = new Array(length);
|
||||
for (let i = 0; i < length; ++i) {
|
||||
names[i] = packedTextures[i].name;
|
||||
}
|
||||
const name = names.join("_");
|
||||
|
||||
const texture = new Texture();
|
||||
texture.name = name;
|
||||
texture.extension = ".png";
|
||||
texture.pixels = pixels;
|
||||
texture.width = width;
|
||||
texture.height = height;
|
||||
|
||||
return texture;
|
||||
}
|
||||
|
||||
function createSpecularGlossinessMaterial(material, options) {
|
||||
const emissiveTexture = material.emissiveTexture;
|
||||
const normalTexture = material.normalTexture;
|
||||
const occlusionTexture = material.ambientTexture;
|
||||
const diffuseTexture = material.diffuseTexture;
|
||||
const alphaTexture = material.alphaTexture;
|
||||
const specularTexture = material.specularTexture;
|
||||
const glossinessTexture = material.specularShininessTexture;
|
||||
const specularGlossinessTexture = createSpecularGlossinessTexture(
|
||||
specularTexture,
|
||||
glossinessTexture,
|
||||
options,
|
||||
);
|
||||
const diffuseAlphaTexture = createDiffuseAlphaTexture(
|
||||
diffuseTexture,
|
||||
alphaTexture,
|
||||
options,
|
||||
);
|
||||
|
||||
let emissiveFactor = material.emissiveColor.slice(0, 3);
|
||||
let diffuseFactor = material.diffuseColor;
|
||||
let specularFactor = material.specularColor.slice(0, 3);
|
||||
let glossinessFactor = material.specularShininess;
|
||||
|
||||
if (defined(emissiveTexture)) {
|
||||
emissiveFactor = [1.0, 1.0, 1.0];
|
||||
}
|
||||
|
||||
if (defined(diffuseTexture)) {
|
||||
diffuseFactor = [1.0, 1.0, 1.0, 1.0];
|
||||
}
|
||||
|
||||
if (defined(specularTexture)) {
|
||||
specularFactor = [1.0, 1.0, 1.0];
|
||||
}
|
||||
|
||||
if (defined(glossinessTexture)) {
|
||||
glossinessFactor = 1.0;
|
||||
}
|
||||
|
||||
let transparent = false;
|
||||
if (defined(alphaTexture)) {
|
||||
transparent = true;
|
||||
} else {
|
||||
const alpha = material.alpha;
|
||||
diffuseFactor[3] = alpha;
|
||||
transparent = alpha < 1.0;
|
||||
}
|
||||
|
||||
if (defined(diffuseTexture)) {
|
||||
transparent = transparent || diffuseTexture.transparent;
|
||||
}
|
||||
|
||||
const doubleSided = transparent || options.doubleSidedMaterial;
|
||||
const alphaMode = transparent ? "BLEND" : "OPAQUE";
|
||||
|
||||
return {
|
||||
name: material.name,
|
||||
extensions: {
|
||||
KHR_materials_pbrSpecularGlossiness: {
|
||||
diffuseTexture: diffuseAlphaTexture,
|
||||
specularGlossinessTexture: specularGlossinessTexture,
|
||||
diffuseFactor: diffuseFactor,
|
||||
specularFactor: specularFactor,
|
||||
glossinessFactor: glossinessFactor,
|
||||
},
|
||||
},
|
||||
emissiveTexture: emissiveTexture,
|
||||
normalTexture: normalTexture,
|
||||
occlusionTexture: occlusionTexture,
|
||||
emissiveFactor: emissiveFactor,
|
||||
alphaMode: alphaMode,
|
||||
doubleSided: doubleSided,
|
||||
};
|
||||
}
|
||||
|
||||
function createMetallicRoughnessMaterial(material, options) {
|
||||
const emissiveTexture = material.emissiveTexture;
|
||||
const normalTexture = material.normalTexture;
|
||||
let occlusionTexture = material.ambientTexture;
|
||||
const baseColorTexture = material.diffuseTexture;
|
||||
const alphaTexture = material.alphaTexture;
|
||||
const metallicTexture = material.specularTexture;
|
||||
const roughnessTexture = material.specularShininessTexture;
|
||||
const metallicRoughnessTexture = createMetallicRoughnessTexture(
|
||||
metallicTexture,
|
||||
roughnessTexture,
|
||||
occlusionTexture,
|
||||
options,
|
||||
);
|
||||
const diffuseAlphaTexture = createDiffuseAlphaTexture(
|
||||
baseColorTexture,
|
||||
alphaTexture,
|
||||
options,
|
||||
);
|
||||
|
||||
if (options.packOcclusion) {
|
||||
occlusionTexture = metallicRoughnessTexture;
|
||||
}
|
||||
|
||||
let emissiveFactor = material.emissiveColor.slice(0, 3);
|
||||
let baseColorFactor = material.diffuseColor;
|
||||
let metallicFactor = material.specularColor[0];
|
||||
let roughnessFactor = material.specularShininess;
|
||||
|
||||
if (defined(emissiveTexture)) {
|
||||
emissiveFactor = [1.0, 1.0, 1.0];
|
||||
}
|
||||
|
||||
if (defined(baseColorTexture)) {
|
||||
baseColorFactor = [1.0, 1.0, 1.0, 1.0];
|
||||
}
|
||||
|
||||
if (defined(metallicTexture)) {
|
||||
metallicFactor = 1.0;
|
||||
}
|
||||
|
||||
if (defined(roughnessTexture)) {
|
||||
roughnessFactor = 1.0;
|
||||
}
|
||||
|
||||
let transparent = false;
|
||||
if (defined(alphaTexture)) {
|
||||
transparent = true;
|
||||
} else {
|
||||
const alpha = material.alpha;
|
||||
baseColorFactor[3] = alpha;
|
||||
transparent = alpha < 1.0;
|
||||
}
|
||||
|
||||
if (defined(baseColorTexture)) {
|
||||
transparent = transparent || baseColorTexture.transparent;
|
||||
}
|
||||
|
||||
const doubleSided = transparent || options.doubleSidedMaterial;
|
||||
const alphaMode = transparent ? "BLEND" : "OPAQUE";
|
||||
|
||||
return {
|
||||
name: material.name,
|
||||
pbrMetallicRoughness: {
|
||||
baseColorTexture: diffuseAlphaTexture,
|
||||
metallicRoughnessTexture: metallicRoughnessTexture,
|
||||
baseColorFactor: baseColorFactor,
|
||||
metallicFactor: metallicFactor,
|
||||
roughnessFactor: roughnessFactor,
|
||||
},
|
||||
emissiveTexture: emissiveTexture,
|
||||
normalTexture: normalTexture,
|
||||
occlusionTexture: occlusionTexture,
|
||||
emissiveFactor: emissiveFactor,
|
||||
alphaMode: alphaMode,
|
||||
doubleSided: doubleSided,
|
||||
};
|
||||
}
|
||||
|
||||
function luminance(color) {
|
||||
return color[0] * 0.2125 + color[1] * 0.7154 + color[2] * 0.0721;
|
||||
}
|
||||
|
||||
function convertTraditionalToMetallicRoughness(material) {
|
||||
// Translate the blinn-phong model to the pbr metallic-roughness model
|
||||
// Roughness factor is a combination of specular intensity and shininess
|
||||
// Metallic factor is 0.0
|
||||
// Textures are not converted for now
|
||||
const specularIntensity = luminance(material.specularColor);
|
||||
|
||||
// Transform from 0-1000 range to 0-1 range. Then invert.
|
||||
let roughnessFactor = material.specularShininess;
|
||||
roughnessFactor = roughnessFactor / 1000.0;
|
||||
roughnessFactor = 1.0 - roughnessFactor;
|
||||
roughnessFactor = CesiumMath.clamp(roughnessFactor, 0.0, 1.0);
|
||||
|
||||
// Low specular intensity values should produce a rough material even if shininess is high.
|
||||
if (specularIntensity < 0.1) {
|
||||
roughnessFactor *= 1.0 - specularIntensity;
|
||||
}
|
||||
|
||||
const metallicFactor = 0.0;
|
||||
|
||||
material.specularColor = [
|
||||
metallicFactor,
|
||||
metallicFactor,
|
||||
metallicFactor,
|
||||
1.0,
|
||||
];
|
||||
material.specularShininess = roughnessFactor;
|
||||
}
|
||||
+757
@@ -0,0 +1,757 @@
|
||||
"use strict";
|
||||
const Cesium = require("cesium");
|
||||
const path = require("path");
|
||||
const Promise = require("bluebird");
|
||||
|
||||
const ArrayStorage = require("./ArrayStorage");
|
||||
const loadMtl = require("./loadMtl");
|
||||
const outsideDirectory = require("./outsideDirectory");
|
||||
const readLines = require("./readLines");
|
||||
|
||||
const Axis = Cesium.Axis;
|
||||
const Cartesian3 = Cesium.Cartesian3;
|
||||
const ComponentDatatype = Cesium.ComponentDatatype;
|
||||
const CoplanarPolygonGeometryLibrary = Cesium.CoplanarPolygonGeometryLibrary;
|
||||
const defaultValue = (a, b) => a ?? b;
|
||||
const defined = Cesium.defined;
|
||||
const PolygonPipeline = Cesium.PolygonPipeline;
|
||||
const RuntimeError = Cesium.RuntimeError;
|
||||
const WindingOrder = Cesium.WindingOrder;
|
||||
const Matrix4 = Cesium.Matrix4;
|
||||
|
||||
module.exports = loadObj;
|
||||
|
||||
// Object name (o) -> node
|
||||
// Group name (g) -> mesh
|
||||
// Material name (usemtl) -> primitive
|
||||
|
||||
function Node() {
|
||||
this.name = undefined;
|
||||
this.meshes = [];
|
||||
}
|
||||
|
||||
function Mesh() {
|
||||
this.name = undefined;
|
||||
this.primitives = [];
|
||||
}
|
||||
|
||||
function Primitive() {
|
||||
this.material = undefined;
|
||||
this.indices = new ArrayStorage(ComponentDatatype.UNSIGNED_INT);
|
||||
this.positions = new ArrayStorage(ComponentDatatype.FLOAT);
|
||||
this.normals = new ArrayStorage(ComponentDatatype.FLOAT);
|
||||
this.uvs = new ArrayStorage(ComponentDatatype.FLOAT);
|
||||
}
|
||||
|
||||
// OBJ regex patterns are modified from ThreeJS (https://github.com/mrdoob/three.js/blob/master/examples/js/loaders/OBJLoader.js)
|
||||
const vertexPattern =
|
||||
/v(\s+[\d|\.|\+|\-|e|E]+)(\s+[\d|\.|\+|\-|e|E]+)(\s+[\d|\.|\+|\-|e|E]+)/; // v float float float
|
||||
const normalPattern =
|
||||
/vn(\s+[\d|\.|\+|\-|e|E]+)(\s+[\d|\.|\+|\-|e|E]+)(\s+[\d|\.|\+|\-|e|E]+)/; // vn float float float
|
||||
const uvPattern = /vt(\s+[\d|\.|\+|\-|e|E]+)(\s+[\d|\.|\+|\-|e|E]+)/; // vt float float
|
||||
const facePattern = /(-?\d+)\/?(-?\d*)\/?(-?\d*)/g; // for any face format "f v", "f v/v", "f v//v", "f v/v/v"
|
||||
|
||||
const scratchCartesian = new Cartesian3();
|
||||
|
||||
/**
|
||||
* Parse an obj file.
|
||||
*
|
||||
* @param {String} objPath Path to the obj file.
|
||||
* @param {Object} options The options object passed along from lib/obj2gltf.js
|
||||
* @returns {Promise} A promise resolving to the obj data, which includes an array of nodes containing geometry information and an array of materials.
|
||||
*
|
||||
* @private
|
||||
*/
|
||||
function loadObj(objPath, options) {
|
||||
const axisTransform = getAxisTransform(
|
||||
options.inputUpAxis,
|
||||
options.outputUpAxis,
|
||||
);
|
||||
|
||||
// Global store of vertex attributes listed in the obj file
|
||||
let globalPositions = new ArrayStorage(ComponentDatatype.FLOAT);
|
||||
let globalNormals = new ArrayStorage(ComponentDatatype.FLOAT);
|
||||
let globalUvs = new ArrayStorage(ComponentDatatype.FLOAT);
|
||||
|
||||
// The current node, mesh, and primitive
|
||||
let node;
|
||||
let mesh;
|
||||
let primitive;
|
||||
let activeMaterial;
|
||||
|
||||
// All nodes seen in the obj
|
||||
const nodes = [];
|
||||
|
||||
// Used to build the indices. The vertex cache is unique to each primitive.
|
||||
let vertexCache = {};
|
||||
const vertexCacheLimit = 1000000;
|
||||
let vertexCacheCount = 0;
|
||||
let vertexCount = 0;
|
||||
|
||||
// All mtl paths seen in the obj
|
||||
let mtlPaths = [];
|
||||
|
||||
// Buffers for face data that spans multiple lines
|
||||
let lineBuffer = "";
|
||||
|
||||
// Used for parsing face data
|
||||
const faceVertices = [];
|
||||
const facePositions = [];
|
||||
const faceUvs = [];
|
||||
const faceNormals = [];
|
||||
|
||||
function clearVertexCache() {
|
||||
vertexCache = {};
|
||||
vertexCacheCount = 0;
|
||||
}
|
||||
|
||||
function getName(name) {
|
||||
return name === "" ? undefined : name;
|
||||
}
|
||||
|
||||
function addNode(name) {
|
||||
node = new Node();
|
||||
node.name = getName(name);
|
||||
nodes.push(node);
|
||||
addMesh();
|
||||
}
|
||||
|
||||
function addMesh(name) {
|
||||
mesh = new Mesh();
|
||||
mesh.name = getName(name);
|
||||
node.meshes.push(mesh);
|
||||
addPrimitive();
|
||||
}
|
||||
|
||||
function addPrimitive() {
|
||||
primitive = new Primitive();
|
||||
primitive.material = activeMaterial;
|
||||
mesh.primitives.push(primitive);
|
||||
|
||||
// Clear the vertex cache for each new primitive
|
||||
clearVertexCache();
|
||||
vertexCount = 0;
|
||||
}
|
||||
|
||||
function reusePrimitive(callback) {
|
||||
const primitives = mesh.primitives;
|
||||
const primitivesLength = primitives.length;
|
||||
for (let i = 0; i < primitivesLength; ++i) {
|
||||
if (primitives[i].material === activeMaterial) {
|
||||
if (!defined(callback) || callback(primitives[i])) {
|
||||
primitive = primitives[i];
|
||||
clearVertexCache();
|
||||
vertexCount = primitive.positions.length / 3;
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
addPrimitive();
|
||||
}
|
||||
|
||||
function useMaterial(name) {
|
||||
activeMaterial = getName(name);
|
||||
reusePrimitive();
|
||||
}
|
||||
|
||||
function faceAndPrimitiveMatch(uvs, normals, primitive) {
|
||||
const faceHasUvs = defined(uvs[0]);
|
||||
const faceHasNormals = defined(normals[0]);
|
||||
const primitiveHasUvs = primitive.uvs.length > 0;
|
||||
const primitiveHasNormals = primitive.normals.length > 0;
|
||||
return (
|
||||
primitiveHasUvs === faceHasUvs && primitiveHasNormals === faceHasNormals
|
||||
);
|
||||
}
|
||||
|
||||
function checkPrimitive(uvs, normals) {
|
||||
const firstFace = primitive.indices.length === 0;
|
||||
if (!firstFace && !faceAndPrimitiveMatch(uvs, normals, primitive)) {
|
||||
reusePrimitive(function (primitive) {
|
||||
return faceAndPrimitiveMatch(uvs, normals, primitive);
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
function getIndexFromStart(index, attributeData, components) {
|
||||
const i = parseInt(index);
|
||||
if (i < 0) {
|
||||
// Negative vertex indexes reference the vertices immediately above it
|
||||
return attributeData.length / components + i;
|
||||
}
|
||||
return i - 1;
|
||||
}
|
||||
|
||||
function correctAttributeIndices(
|
||||
attributeIndices,
|
||||
attributeData,
|
||||
components,
|
||||
) {
|
||||
const length = attributeIndices.length;
|
||||
for (let i = 0; i < length; ++i) {
|
||||
if (attributeIndices[i].length === 0) {
|
||||
attributeIndices[i] = undefined;
|
||||
} else {
|
||||
attributeIndices[i] = getIndexFromStart(
|
||||
attributeIndices[i],
|
||||
attributeData,
|
||||
components,
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function correctVertices(vertices, positions, uvs, normals) {
|
||||
const length = vertices.length;
|
||||
for (let i = 0; i < length; ++i) {
|
||||
vertices[i] = `${defaultValue(positions[i], "")}/${defaultValue(
|
||||
uvs[i],
|
||||
"",
|
||||
)}/${defaultValue(normals[i], "")}`;
|
||||
}
|
||||
}
|
||||
|
||||
function createVertex(p, u, n) {
|
||||
// Positions
|
||||
if (defined(p) && globalPositions.length > 0) {
|
||||
if (p * 3 >= globalPositions.length) {
|
||||
throw new RuntimeError(`Position index ${p} is out of bounds`);
|
||||
}
|
||||
const px = globalPositions.get(p * 3);
|
||||
const py = globalPositions.get(p * 3 + 1);
|
||||
const pz = globalPositions.get(p * 3 + 2);
|
||||
primitive.positions.push(px);
|
||||
primitive.positions.push(py);
|
||||
primitive.positions.push(pz);
|
||||
}
|
||||
|
||||
// Normals
|
||||
if (defined(n) && globalNormals.length > 0) {
|
||||
if (n * 3 >= globalNormals.length) {
|
||||
throw new RuntimeError(`Normal index ${n} is out of bounds`);
|
||||
}
|
||||
const nx = globalNormals.get(n * 3);
|
||||
const ny = globalNormals.get(n * 3 + 1);
|
||||
const nz = globalNormals.get(n * 3 + 2);
|
||||
primitive.normals.push(nx);
|
||||
primitive.normals.push(ny);
|
||||
primitive.normals.push(nz);
|
||||
}
|
||||
|
||||
// UVs
|
||||
if (defined(u) && globalUvs.length > 0) {
|
||||
if (u * 2 >= globalUvs.length) {
|
||||
throw new RuntimeError(`UV index ${u} is out of bounds`);
|
||||
}
|
||||
const ux = globalUvs.get(u * 2);
|
||||
const uy = globalUvs.get(u * 2 + 1);
|
||||
primitive.uvs.push(ux);
|
||||
primitive.uvs.push(uy);
|
||||
}
|
||||
}
|
||||
|
||||
function addVertex(v, p, u, n) {
|
||||
let index = vertexCache[v];
|
||||
if (!defined(index)) {
|
||||
index = vertexCount++;
|
||||
vertexCache[v] = index;
|
||||
createVertex(p, u, n);
|
||||
|
||||
// Prevent the vertex cache from growing too large. As a result of clearing the cache there
|
||||
// may be some duplicate vertices.
|
||||
vertexCacheCount++;
|
||||
if (vertexCacheCount > vertexCacheLimit) {
|
||||
clearVertexCache();
|
||||
}
|
||||
}
|
||||
return index;
|
||||
}
|
||||
|
||||
function getPosition(index, result) {
|
||||
const px = globalPositions.get(index * 3);
|
||||
const py = globalPositions.get(index * 3 + 1);
|
||||
const pz = globalPositions.get(index * 3 + 2);
|
||||
return Cartesian3.fromElements(px, py, pz, result);
|
||||
}
|
||||
|
||||
function getNormal(index, result) {
|
||||
const nx = globalNormals.get(index * 3);
|
||||
const ny = globalNormals.get(index * 3 + 1);
|
||||
const nz = globalNormals.get(index * 3 + 2);
|
||||
return Cartesian3.fromElements(nx, ny, nz, result);
|
||||
}
|
||||
|
||||
const scratch1 = new Cartesian3();
|
||||
const scratch2 = new Cartesian3();
|
||||
const scratch3 = new Cartesian3();
|
||||
const scratch4 = new Cartesian3();
|
||||
const scratch5 = new Cartesian3();
|
||||
const scratchCenter = new Cartesian3();
|
||||
const scratchAxis1 = new Cartesian3();
|
||||
const scratchAxis2 = new Cartesian3();
|
||||
const scratchNormal = new Cartesian3();
|
||||
const scratchPositions = [
|
||||
new Cartesian3(),
|
||||
new Cartesian3(),
|
||||
new Cartesian3(),
|
||||
new Cartesian3(),
|
||||
];
|
||||
const scratchVertexIndices = [];
|
||||
const scratchPoints = [];
|
||||
|
||||
function checkWindingCorrect(
|
||||
positionIndex1,
|
||||
positionIndex2,
|
||||
positionIndex3,
|
||||
normalIndex,
|
||||
) {
|
||||
if (!defined(normalIndex)) {
|
||||
// If no face normal, we have to assume the winding is correct.
|
||||
return true;
|
||||
}
|
||||
const normal = getNormal(normalIndex, scratchNormal);
|
||||
const A = getPosition(positionIndex1, scratch1);
|
||||
const B = getPosition(positionIndex2, scratch2);
|
||||
const C = getPosition(positionIndex3, scratch3);
|
||||
|
||||
const BA = Cartesian3.subtract(B, A, scratch4);
|
||||
const CA = Cartesian3.subtract(C, A, scratch5);
|
||||
const cross = Cartesian3.cross(BA, CA, scratch3);
|
||||
|
||||
return Cartesian3.dot(normal, cross) >= 0;
|
||||
}
|
||||
|
||||
function addTriangle(index1, index2, index3, correctWinding) {
|
||||
if (correctWinding) {
|
||||
primitive.indices.push(index1);
|
||||
primitive.indices.push(index2);
|
||||
primitive.indices.push(index3);
|
||||
} else {
|
||||
primitive.indices.push(index1);
|
||||
primitive.indices.push(index3);
|
||||
primitive.indices.push(index2);
|
||||
}
|
||||
}
|
||||
|
||||
function addFace(
|
||||
vertices,
|
||||
positions,
|
||||
uvs,
|
||||
normals,
|
||||
triangleWindingOrderSanitization,
|
||||
) {
|
||||
correctAttributeIndices(positions, globalPositions, 3);
|
||||
correctAttributeIndices(normals, globalNormals, 3);
|
||||
correctAttributeIndices(uvs, globalUvs, 2);
|
||||
correctVertices(vertices, positions, uvs, normals);
|
||||
|
||||
checkPrimitive(uvs, faceNormals);
|
||||
|
||||
if (vertices.length === 3) {
|
||||
const isWindingCorrect =
|
||||
!triangleWindingOrderSanitization ||
|
||||
checkWindingCorrect(
|
||||
positions[0],
|
||||
positions[1],
|
||||
positions[2],
|
||||
normals[0],
|
||||
);
|
||||
const index1 = addVertex(vertices[0], positions[0], uvs[0], normals[0]);
|
||||
const index2 = addVertex(vertices[1], positions[1], uvs[1], normals[1]);
|
||||
const index3 = addVertex(vertices[2], positions[2], uvs[2], normals[2]);
|
||||
addTriangle(index1, index2, index3, isWindingCorrect);
|
||||
} else {
|
||||
// Triangulate if the face is not a triangle
|
||||
const points = scratchPoints;
|
||||
const vertexIndices = scratchVertexIndices;
|
||||
|
||||
points.length = 0;
|
||||
vertexIndices.length = 0;
|
||||
|
||||
for (let i = 0; i < vertices.length; ++i) {
|
||||
const index = addVertex(vertices[i], positions[i], uvs[i], normals[i]);
|
||||
vertexIndices.push(index);
|
||||
if (i === scratchPositions.length) {
|
||||
scratchPositions.push(new Cartesian3());
|
||||
}
|
||||
points.push(getPosition(positions[i], scratchPositions[i]));
|
||||
}
|
||||
|
||||
const validGeometry =
|
||||
CoplanarPolygonGeometryLibrary.computeProjectTo2DArguments(
|
||||
points,
|
||||
scratchCenter,
|
||||
scratchAxis1,
|
||||
scratchAxis2,
|
||||
);
|
||||
if (!validGeometry) {
|
||||
return;
|
||||
}
|
||||
const projectPoints =
|
||||
CoplanarPolygonGeometryLibrary.createProjectPointsTo2DFunction(
|
||||
scratchCenter,
|
||||
scratchAxis1,
|
||||
scratchAxis2,
|
||||
);
|
||||
const points2D = projectPoints(points);
|
||||
const indices = PolygonPipeline.triangulate(points2D);
|
||||
const isWindingCorrect =
|
||||
PolygonPipeline.computeWindingOrder2D(points2D) !==
|
||||
WindingOrder.CLOCKWISE;
|
||||
|
||||
for (let i = 0; i < indices.length - 2; i += 3) {
|
||||
addTriangle(
|
||||
vertexIndices[indices[i]],
|
||||
vertexIndices[indices[i + 1]],
|
||||
vertexIndices[indices[i + 2]],
|
||||
isWindingCorrect,
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function parseLine(line) {
|
||||
line = line.trim();
|
||||
let result;
|
||||
|
||||
if (line.length === 0 || line.charAt(0) === "#") {
|
||||
// Don't process empty lines or comments
|
||||
} else if (/^o\s/i.test(line)) {
|
||||
const objectName = line.substring(2).trim();
|
||||
addNode(objectName);
|
||||
} else if (/^g\s/i.test(line)) {
|
||||
const groupName = line.substring(2).trim();
|
||||
addMesh(groupName);
|
||||
} else if (/^usemtl/i.test(line)) {
|
||||
const materialName = line.substring(7).trim();
|
||||
useMaterial(materialName);
|
||||
} else if (/^mtllib/i.test(line)) {
|
||||
const mtllibLine = line.substring(7).trim();
|
||||
mtlPaths = mtlPaths.concat(getMtlPaths(mtllibLine));
|
||||
} else if ((result = vertexPattern.exec(line)) !== null) {
|
||||
const position = scratchCartesian;
|
||||
position.x = parseFloat(result[1]);
|
||||
position.y = parseFloat(result[2]);
|
||||
position.z = parseFloat(result[3]);
|
||||
if (defined(axisTransform)) {
|
||||
Matrix4.multiplyByPoint(axisTransform, position, position);
|
||||
}
|
||||
globalPositions.push(position.x);
|
||||
globalPositions.push(position.y);
|
||||
globalPositions.push(position.z);
|
||||
} else if ((result = normalPattern.exec(line)) !== null) {
|
||||
const normal = Cartesian3.fromElements(
|
||||
parseFloat(result[1]),
|
||||
parseFloat(result[2]),
|
||||
parseFloat(result[3]),
|
||||
scratchNormal,
|
||||
);
|
||||
if (Cartesian3.equals(normal, Cartesian3.ZERO)) {
|
||||
Cartesian3.clone(Cartesian3.UNIT_Z, normal);
|
||||
} else {
|
||||
Cartesian3.normalize(normal, normal);
|
||||
}
|
||||
if (defined(axisTransform)) {
|
||||
Matrix4.multiplyByPointAsVector(axisTransform, normal, normal);
|
||||
}
|
||||
globalNormals.push(normal.x);
|
||||
globalNormals.push(normal.y);
|
||||
globalNormals.push(normal.z);
|
||||
} else if ((result = uvPattern.exec(line)) !== null) {
|
||||
globalUvs.push(parseFloat(result[1]));
|
||||
globalUvs.push(1.0 - parseFloat(result[2])); // Flip y so 0.0 is the bottom of the image
|
||||
} else {
|
||||
// face line or invalid line
|
||||
// Because face lines can contain n vertices, we use a line buffer in case the face data spans multiple lines.
|
||||
// If there's a line continuation don't create face yet
|
||||
if (line.slice(-1) === "\\") {
|
||||
lineBuffer += line.substring(0, line.length - 1);
|
||||
return;
|
||||
}
|
||||
lineBuffer += line;
|
||||
if (lineBuffer.substring(0, 2) === "f ") {
|
||||
while ((result = facePattern.exec(lineBuffer)) !== null) {
|
||||
faceVertices.push(result[0]);
|
||||
facePositions.push(result[1]);
|
||||
faceUvs.push(result[2]);
|
||||
faceNormals.push(result[3]);
|
||||
}
|
||||
if (faceVertices.length > 2) {
|
||||
addFace(
|
||||
faceVertices,
|
||||
facePositions,
|
||||
faceUvs,
|
||||
faceNormals,
|
||||
options.triangleWindingOrderSanitization,
|
||||
);
|
||||
}
|
||||
|
||||
faceVertices.length = 0;
|
||||
facePositions.length = 0;
|
||||
faceNormals.length = 0;
|
||||
faceUvs.length = 0;
|
||||
}
|
||||
lineBuffer = "";
|
||||
}
|
||||
}
|
||||
|
||||
// Create a default node in case there are no o/g/usemtl lines in the obj
|
||||
addNode();
|
||||
|
||||
// Parse the obj file
|
||||
return readLines(objPath, parseLine).then(function () {
|
||||
// Unload resources
|
||||
globalPositions = undefined;
|
||||
globalNormals = undefined;
|
||||
globalUvs = undefined;
|
||||
|
||||
// Load materials and textures
|
||||
return finishLoading(
|
||||
nodes,
|
||||
mtlPaths,
|
||||
objPath,
|
||||
defined(activeMaterial),
|
||||
options,
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
function getMtlPaths(mtllibLine) {
|
||||
// Handle paths with spaces. E.g. mtllib my material file.mtl
|
||||
const mtlPaths = [];
|
||||
//Remove double quotes around the mtl file if it exists
|
||||
mtllibLine = mtllibLine.replace(/^"(.+)"$/, "$1");
|
||||
const splits = mtllibLine.split(" ");
|
||||
const length = splits.length;
|
||||
let startIndex = 0;
|
||||
for (let i = 0; i < length; ++i) {
|
||||
if (path.extname(splits[i]) !== ".mtl") {
|
||||
continue;
|
||||
}
|
||||
const mtlPath = splits.slice(startIndex, i + 1).join(" ");
|
||||
mtlPaths.push(mtlPath);
|
||||
startIndex = i + 1;
|
||||
}
|
||||
return mtlPaths;
|
||||
}
|
||||
|
||||
function finishLoading(nodes, mtlPaths, objPath, usesMaterials, options) {
|
||||
nodes = cleanNodes(nodes);
|
||||
if (nodes.length === 0) {
|
||||
throw new RuntimeError(`${objPath} does not have any geometry data`);
|
||||
}
|
||||
const name = path.basename(objPath, path.extname(objPath));
|
||||
return loadMtls(mtlPaths, objPath, options).then(function (materials) {
|
||||
if (materials.length > 0 && !usesMaterials) {
|
||||
assignDefaultMaterial(nodes, materials, usesMaterials);
|
||||
}
|
||||
assignUnnamedMaterial(nodes, materials);
|
||||
return {
|
||||
nodes: nodes,
|
||||
materials: materials,
|
||||
name: name,
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
function normalizeMtlPath(mtlPath, objDirectory) {
|
||||
mtlPath = mtlPath.replace(/\\/g, "/");
|
||||
return path.normalize(path.resolve(objDirectory, mtlPath));
|
||||
}
|
||||
|
||||
function loadMtls(mtlPaths, objPath, options) {
|
||||
const objDirectory = path.dirname(objPath);
|
||||
let materials = [];
|
||||
|
||||
// Remove duplicates
|
||||
mtlPaths = mtlPaths.filter(function (value, index, self) {
|
||||
return self.indexOf(value) === index;
|
||||
});
|
||||
|
||||
return Promise.map(
|
||||
mtlPaths,
|
||||
function (mtlPath) {
|
||||
mtlPath = normalizeMtlPath(mtlPath, objDirectory);
|
||||
const shallowPath = path.join(objDirectory, path.basename(mtlPath));
|
||||
if (options.secure && outsideDirectory(mtlPath, objDirectory)) {
|
||||
// Try looking for the .mtl in the same directory as the obj
|
||||
options.logger(
|
||||
"The material file is outside of the obj directory and the secure flag is true. Attempting to read the material file from within the obj directory instead.",
|
||||
);
|
||||
return loadMtl(shallowPath, options)
|
||||
.then(function (materialsInMtl) {
|
||||
materials = materials.concat(materialsInMtl);
|
||||
})
|
||||
.catch(function (error) {
|
||||
options.logger(error.message);
|
||||
options.logger(
|
||||
`Could not read material file at ${shallowPath}. Using default material instead.`,
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
return loadMtl(mtlPath, options)
|
||||
.catch(function (error) {
|
||||
// Try looking for the .mtl in the same directory as the obj
|
||||
options.logger(error.message);
|
||||
options.logger(
|
||||
`Could not read material file at ${mtlPath}. Attempting to read the material file from within the obj directory instead.`,
|
||||
);
|
||||
return loadMtl(shallowPath, options);
|
||||
})
|
||||
.then(function (materialsInMtl) {
|
||||
materials = materials.concat(materialsInMtl);
|
||||
})
|
||||
.catch(function (error) {
|
||||
options.logger(error.message);
|
||||
options.logger(
|
||||
`Could not read material file at ${shallowPath}. Using default material instead.`,
|
||||
);
|
||||
});
|
||||
},
|
||||
{ concurrency: 10 },
|
||||
).then(function () {
|
||||
return materials;
|
||||
});
|
||||
}
|
||||
|
||||
function assignDefaultMaterial(nodes, materials) {
|
||||
const defaultMaterial = materials[0].name;
|
||||
const nodesLength = nodes.length;
|
||||
for (let i = 0; i < nodesLength; ++i) {
|
||||
const meshes = nodes[i].meshes;
|
||||
const meshesLength = meshes.length;
|
||||
for (let j = 0; j < meshesLength; ++j) {
|
||||
const primitives = meshes[j].primitives;
|
||||
const primitivesLength = primitives.length;
|
||||
for (let k = 0; k < primitivesLength; ++k) {
|
||||
const primitive = primitives[k];
|
||||
primitive.material = defaultValue(primitive.material, defaultMaterial);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function assignUnnamedMaterial(nodes, materials) {
|
||||
// If there is a material that doesn't have a name, assign that
|
||||
// material to any primitives whose material is undefined.
|
||||
const unnamedMaterial = materials.find(function (material) {
|
||||
return material.name.length === 0;
|
||||
});
|
||||
|
||||
if (!defined(unnamedMaterial)) {
|
||||
return;
|
||||
}
|
||||
|
||||
const nodesLength = nodes.length;
|
||||
for (let i = 0; i < nodesLength; ++i) {
|
||||
const meshes = nodes[i].meshes;
|
||||
const meshesLength = meshes.length;
|
||||
for (let j = 0; j < meshesLength; ++j) {
|
||||
const primitives = meshes[j].primitives;
|
||||
const primitivesLength = primitives.length;
|
||||
for (let k = 0; k < primitivesLength; ++k) {
|
||||
const primitive = primitives[k];
|
||||
if (!defined(primitive.material)) {
|
||||
primitive.material = unnamedMaterial.name;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function removeEmptyMeshes(meshes) {
|
||||
return meshes.filter(function (mesh) {
|
||||
// Remove empty primitives
|
||||
mesh.primitives = mesh.primitives.filter(function (primitive) {
|
||||
return primitive.indices.length > 0 && primitive.positions.length > 0;
|
||||
});
|
||||
// Valid meshes must have at least one primitive
|
||||
return mesh.primitives.length > 0;
|
||||
});
|
||||
}
|
||||
|
||||
function meshesHaveNames(meshes) {
|
||||
const meshesLength = meshes.length;
|
||||
for (let i = 0; i < meshesLength; ++i) {
|
||||
if (defined(meshes[i].name)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
function removeEmptyNodes(nodes) {
|
||||
const final = [];
|
||||
const nodesLength = nodes.length;
|
||||
for (let i = 0; i < nodesLength; ++i) {
|
||||
const node = nodes[i];
|
||||
const meshes = removeEmptyMeshes(node.meshes);
|
||||
if (meshes.length === 0) {
|
||||
continue;
|
||||
}
|
||||
node.meshes = meshes;
|
||||
if (!defined(node.name) && meshesHaveNames(meshes)) {
|
||||
// If the obj has groups (g) but not object groups (o) then convert meshes to nodes
|
||||
const meshesLength = meshes.length;
|
||||
for (let j = 0; j < meshesLength; ++j) {
|
||||
const mesh = meshes[j];
|
||||
const convertedNode = new Node();
|
||||
convertedNode.name = mesh.name;
|
||||
convertedNode.meshes = [mesh];
|
||||
final.push(convertedNode);
|
||||
}
|
||||
} else {
|
||||
final.push(node);
|
||||
}
|
||||
}
|
||||
return final;
|
||||
}
|
||||
|
||||
function setDefaultNames(items, defaultName, usedNames) {
|
||||
const itemsLength = items.length;
|
||||
for (let i = 0; i < itemsLength; ++i) {
|
||||
const item = items[i];
|
||||
let name = defaultValue(item.name, defaultName);
|
||||
const occurrences = usedNames[name];
|
||||
if (defined(occurrences)) {
|
||||
usedNames[name]++;
|
||||
name = `${name}_${occurrences}`;
|
||||
} else {
|
||||
usedNames[name] = 1;
|
||||
}
|
||||
item.name = name;
|
||||
}
|
||||
}
|
||||
|
||||
function setDefaults(nodes) {
|
||||
const usedNames = {};
|
||||
setDefaultNames(nodes, "Node", usedNames);
|
||||
const nodesLength = nodes.length;
|
||||
for (let i = 0; i < nodesLength; ++i) {
|
||||
const node = nodes[i];
|
||||
setDefaultNames(node.meshes, `${node.name}-Mesh`, usedNames);
|
||||
}
|
||||
}
|
||||
|
||||
function cleanNodes(nodes) {
|
||||
nodes = removeEmptyNodes(nodes);
|
||||
setDefaults(nodes);
|
||||
return nodes;
|
||||
}
|
||||
|
||||
function getAxisTransform(inputUpAxis, outputUpAxis) {
|
||||
if (inputUpAxis === "X" && outputUpAxis === "Y") {
|
||||
return Axis.X_UP_TO_Y_UP;
|
||||
} else if (inputUpAxis === "X" && outputUpAxis === "Z") {
|
||||
return Axis.X_UP_TO_Z_UP;
|
||||
} else if (inputUpAxis === "Y" && outputUpAxis === "X") {
|
||||
return Axis.Y_UP_TO_X_UP;
|
||||
} else if (inputUpAxis === "Y" && outputUpAxis === "Z") {
|
||||
return Axis.Y_UP_TO_Z_UP;
|
||||
} else if (inputUpAxis === "Z" && outputUpAxis === "X") {
|
||||
return Axis.Z_UP_TO_X_UP;
|
||||
} else if (inputUpAxis === "Z" && outputUpAxis === "Y") {
|
||||
return Axis.Z_UP_TO_Y_UP;
|
||||
}
|
||||
}
|
||||
+133
@@ -0,0 +1,133 @@
|
||||
"use strict";
|
||||
const Cesium = require("cesium");
|
||||
const fsExtra = require("fs-extra");
|
||||
const jpeg = require("jpeg-js");
|
||||
const path = require("path");
|
||||
const PNG = require("pngjs").PNG;
|
||||
const Promise = require("bluebird");
|
||||
const Texture = require("./Texture");
|
||||
|
||||
const defaultValue = (a, b) => a ?? b;
|
||||
const defined = Cesium.defined;
|
||||
|
||||
module.exports = loadTexture;
|
||||
|
||||
/**
|
||||
* Load a texture file.
|
||||
*
|
||||
* @param {String} texturePath Path to the texture file.
|
||||
* @param {Object} [options] An object with the following properties:
|
||||
* @param {Boolean} [options.checkTransparency=false] Do a more exhaustive check for texture transparency by looking at the alpha channel of each pixel.
|
||||
* @param {Boolean} [options.decode=false] Whether to decode the texture.
|
||||
* @param {Boolean} [options.keepSource=false] Whether to keep the source image contents in memory.
|
||||
* @returns {Promise} A promise resolving to a Texture object.
|
||||
*
|
||||
* @private
|
||||
*/
|
||||
function loadTexture(texturePath, options) {
|
||||
options = defaultValue(options, {});
|
||||
options.checkTransparency = defaultValue(options.checkTransparency, false);
|
||||
options.decode = defaultValue(options.decode, false);
|
||||
options.keepSource = defaultValue(options.keepSource, false);
|
||||
|
||||
return fsExtra.readFile(texturePath).then(function (source) {
|
||||
const name = path.basename(texturePath, path.extname(texturePath));
|
||||
const extension = path.extname(texturePath).toLowerCase();
|
||||
const texture = new Texture();
|
||||
texture.source = source;
|
||||
texture.name = name;
|
||||
texture.extension = extension;
|
||||
texture.path = texturePath;
|
||||
|
||||
let decodePromise;
|
||||
if (extension === ".png") {
|
||||
decodePromise = decodePng(texture, options);
|
||||
} else if (extension === ".jpg" || extension === ".jpeg") {
|
||||
decodePromise = decodeJpeg(texture, options);
|
||||
}
|
||||
|
||||
if (defined(decodePromise)) {
|
||||
return decodePromise.then(function () {
|
||||
return texture;
|
||||
});
|
||||
}
|
||||
|
||||
return texture;
|
||||
});
|
||||
}
|
||||
|
||||
function hasTransparency(pixels) {
|
||||
const pixelsLength = pixels.length / 4;
|
||||
for (let i = 0; i < pixelsLength; ++i) {
|
||||
if (pixels[i * 4 + 3] < 255) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
function getChannels(colorType) {
|
||||
switch (colorType) {
|
||||
case 0: // greyscale
|
||||
return 1;
|
||||
case 2: // RGB
|
||||
return 3;
|
||||
case 4: // greyscale + alpha
|
||||
return 2;
|
||||
case 6: // RGB + alpha
|
||||
return 4;
|
||||
default:
|
||||
return 3;
|
||||
}
|
||||
}
|
||||
|
||||
function parsePng(data) {
|
||||
return new Promise(function (resolve, reject) {
|
||||
new PNG().parse(data, function (error, decodedResults) {
|
||||
if (defined(error)) {
|
||||
reject(error);
|
||||
return;
|
||||
}
|
||||
resolve(decodedResults);
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
function decodePng(texture, options) {
|
||||
// Color type is encoded in the 25th bit of the png
|
||||
const source = texture.source;
|
||||
const colorType = source[25];
|
||||
const channels = getChannels(colorType);
|
||||
|
||||
const checkTransparency = channels === 4 && options.checkTransparency;
|
||||
const decode = options.decode || checkTransparency;
|
||||
|
||||
if (decode) {
|
||||
return parsePng(source).then(function (decodedResults) {
|
||||
if (options.checkTransparency) {
|
||||
texture.transparent = hasTransparency(decodedResults.data);
|
||||
}
|
||||
if (options.decode) {
|
||||
texture.pixels = decodedResults.data;
|
||||
texture.width = decodedResults.width;
|
||||
texture.height = decodedResults.height;
|
||||
if (!options.keepSource) {
|
||||
texture.source = undefined; // Unload resources
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
function decodeJpeg(texture, options) {
|
||||
if (options.decode) {
|
||||
const source = texture.source;
|
||||
const decodedResults = jpeg.decode(source);
|
||||
texture.pixels = decodedResults.data;
|
||||
texture.width = decodedResults.width;
|
||||
texture.height = decodedResults.height;
|
||||
if (!options.keepSource) {
|
||||
texture.source = undefined; // Unload resources
|
||||
}
|
||||
}
|
||||
}
|
||||
+257
@@ -0,0 +1,257 @@
|
||||
"use strict";
|
||||
const Cesium = require("cesium");
|
||||
const fsExtra = require("fs-extra");
|
||||
const path = require("path");
|
||||
const createGltf = require("./createGltf");
|
||||
const loadObj = require("./loadObj");
|
||||
const writeGltf = require("./writeGltf");
|
||||
|
||||
const defaultValue = (a, b) => a ?? b;
|
||||
const defined = Cesium.defined;
|
||||
const DeveloperError = Cesium.DeveloperError;
|
||||
|
||||
module.exports = obj2gltf;
|
||||
|
||||
/**
|
||||
* Converts an obj file to a glTF or glb.
|
||||
*
|
||||
* @param {String} objPath Path to the obj file.
|
||||
* @param {Object} [options] An object with the following properties:
|
||||
* @param {Boolean} [options.binary=false] Convert to binary glTF.
|
||||
* @param {Boolean} [options.separate=false] Write out separate buffer files and textures instead of embedding them in the glTF.
|
||||
* @param {Boolean} [options.separateTextures=false] Write out separate textures only.
|
||||
* @param {Boolean} [options.checkTransparency=false] Do a more exhaustive check for texture transparency by looking at the alpha channel of each pixel.
|
||||
* @param {Boolean} [options.secure=false] Prevent the converter from reading textures or mtl files outside of the input obj directory.
|
||||
* @param {Boolean} [options.packOcclusion=false] Pack the occlusion texture in the red channel of the metallic-roughness texture.
|
||||
* @param {Boolean} [options.metallicRoughness=false] The values in the mtl file are already metallic-roughness PBR values and no conversion step should be applied. Metallic is stored in the Ks and map_Ks slots and roughness is stored in the Ns and map_Ns slots.
|
||||
* @param {Boolean} [options.specularGlossiness=false] The values in the mtl file are already specular-glossiness PBR values and no conversion step should be applied. Specular is stored in the Ks and map_Ks slots and glossiness is stored in the Ns and map_Ns slots. The glTF will be saved with the KHR_materials_pbrSpecularGlossiness extension.
|
||||
* @param {Boolean} [options.unlit=false] The glTF will be saved with the KHR_materials_unlit extension.
|
||||
* @param {Object} [options.overridingTextures] An object containing texture paths that override textures defined in the .mtl file. This is often convenient in workflows where the .mtl does not exist or is not set up to use PBR materials. Intended for models with a single material.
|
||||
* @param {String} [options.overridingTextures.metallicRoughnessOcclusionTexture] Path to the metallic-roughness-occlusion texture, where occlusion is stored in the red channel, roughness is stored in the green channel, and metallic is stored in the blue channel. The model will be saved with a pbrMetallicRoughness material.
|
||||
* @param {String} [options.overridingTextures.specularGlossinessTexture] Path to the specular-glossiness texture, where specular color is stored in the red, green, and blue channels and specular glossiness is stored in the alpha channel. The model will be saved with a material using the KHR_materials_pbrSpecularGlossiness extension.
|
||||
* @param {String} [options.overridingTextures.occlusionTexture] Path to the occlusion texture. Ignored if metallicRoughnessOcclusionTexture is also set.
|
||||
* @param {String} [options.overridingTextures.normalTexture] Path to the normal texture.
|
||||
* @param {String} [options.overridingTextures.baseColorTexture] Path to the baseColor/diffuse texture.
|
||||
* @param {String} [options.overridingTextures.emissiveTexture] Path to the emissive texture.
|
||||
* @param {String} [options.overridingTextures.alphaTexture] Path to the alpha texture.
|
||||
* @param {String} [options.inputUpAxis='Y'] Up axis of the obj. Choices are 'X', 'Y', and 'Z'.
|
||||
* @param {String} [options.outputUpAxis='Y'] Up axis of the converted glTF. Choices are 'X', 'Y', and 'Z'.
|
||||
* @param {String} [options.triangleWindingOrderSanitization=false] Apply triangle winding order sanitization.
|
||||
* @param {Logger} [options.logger] A callback function for handling logged messages. Defaults to console.log.
|
||||
* @param {Writer} [options.writer] A callback function that writes files that are saved as separate resources.
|
||||
* @param {String} [options.outputDirectory] Output directory for writing separate resources when options.writer is not defined.
|
||||
* @param {Boolean} [options.doubleSidedMaterial=false] Allows materials to be double sided.
|
||||
* @return {Promise} A promise that resolves to the glTF JSON or glb buffer.
|
||||
*/
|
||||
function obj2gltf(objPath, options) {
|
||||
const defaults = obj2gltf.defaults;
|
||||
options = defaultValue(options, {});
|
||||
options.binary = defaultValue(options.binary, defaults.binary);
|
||||
options.separate = defaultValue(options.separate, defaults.separate);
|
||||
options.separateTextures =
|
||||
defaultValue(options.separateTextures, defaults.separateTextures) ||
|
||||
options.separate;
|
||||
options.checkTransparency = defaultValue(
|
||||
options.checkTransparency,
|
||||
defaults.checkTransparency,
|
||||
);
|
||||
options.doubleSidedMaterial = defaultValue(
|
||||
options.doubleSidedMaterial,
|
||||
defaults.doubleSidedMaterial,
|
||||
);
|
||||
options.secure = defaultValue(options.secure, defaults.secure);
|
||||
options.packOcclusion = defaultValue(
|
||||
options.packOcclusion,
|
||||
defaults.packOcclusion,
|
||||
);
|
||||
options.metallicRoughness = defaultValue(
|
||||
options.metallicRoughness,
|
||||
defaults.metallicRoughness,
|
||||
);
|
||||
options.specularGlossiness = defaultValue(
|
||||
options.specularGlossiness,
|
||||
defaults.specularGlossiness,
|
||||
);
|
||||
options.unlit = defaultValue(options.unlit, defaults.unlit);
|
||||
options.overridingTextures = defaultValue(
|
||||
options.overridingTextures,
|
||||
Cesium.Frozen.EMPTY_OBJECT,
|
||||
);
|
||||
options.logger = defaultValue(options.logger, getDefaultLogger());
|
||||
options.writer = defaultValue(
|
||||
options.writer,
|
||||
getDefaultWriter(options.outputDirectory),
|
||||
);
|
||||
options.inputUpAxis = defaultValue(options.inputUpAxis, defaults.inputUpAxis);
|
||||
options.outputUpAxis = defaultValue(
|
||||
options.outputUpAxis,
|
||||
defaults.outputUpAxis,
|
||||
);
|
||||
options.triangleWindingOrderSanitization = defaultValue(
|
||||
options.triangleWindingOrderSanitization,
|
||||
defaults.triangleWindingOrderSanitization,
|
||||
);
|
||||
|
||||
if (!defined(objPath)) {
|
||||
throw new DeveloperError("objPath is required");
|
||||
}
|
||||
|
||||
if (options.separateTextures && !defined(options.writer)) {
|
||||
throw new DeveloperError(
|
||||
"Either options.writer or options.outputDirectory must be defined when writing separate resources.",
|
||||
);
|
||||
}
|
||||
|
||||
if (
|
||||
options.metallicRoughness + options.specularGlossiness + options.unlit >
|
||||
1
|
||||
) {
|
||||
throw new DeveloperError(
|
||||
"Only one material type may be set from [metallicRoughness, specularGlossiness, unlit].",
|
||||
);
|
||||
}
|
||||
|
||||
if (
|
||||
defined(options.overridingTextures.metallicRoughnessOcclusionTexture) &&
|
||||
defined(options.overridingTextures.specularGlossinessTexture)
|
||||
) {
|
||||
throw new DeveloperError(
|
||||
"metallicRoughnessOcclusionTexture and specularGlossinessTexture cannot both be defined.",
|
||||
);
|
||||
}
|
||||
|
||||
if (defined(options.overridingTextures.metallicRoughnessOcclusionTexture)) {
|
||||
options.metallicRoughness = true;
|
||||
options.specularGlossiness = false;
|
||||
options.packOcclusion = true;
|
||||
}
|
||||
|
||||
if (defined(options.overridingTextures.specularGlossinessTexture)) {
|
||||
options.metallicRoughness = false;
|
||||
options.specularGlossiness = true;
|
||||
}
|
||||
|
||||
return loadObj(objPath, options)
|
||||
.then(function (objData) {
|
||||
return createGltf(objData, options);
|
||||
})
|
||||
.then(function (gltf) {
|
||||
return writeGltf(gltf, options);
|
||||
});
|
||||
}
|
||||
|
||||
function getDefaultLogger() {
|
||||
return function (message) {
|
||||
console.log(message);
|
||||
};
|
||||
}
|
||||
|
||||
function getDefaultWriter(outputDirectory) {
|
||||
if (defined(outputDirectory)) {
|
||||
return function (file, data) {
|
||||
const outputFile = path.join(outputDirectory, file);
|
||||
return fsExtra.outputFile(outputFile, data);
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Default values that will be used when calling obj2gltf(options) unless specified in the options object.
|
||||
*/
|
||||
obj2gltf.defaults = {
|
||||
/**
|
||||
* Gets or sets whether the converter will return a glb.
|
||||
* @type Boolean
|
||||
* @default false
|
||||
*/
|
||||
binary: false,
|
||||
/**
|
||||
* Gets or sets whether to write out separate buffer and texture,
|
||||
* shader files, and textures instead of embedding them in the glTF.
|
||||
* @type Boolean
|
||||
* @default false
|
||||
*/
|
||||
separate: false,
|
||||
/**
|
||||
* Gets or sets whether to write out separate textures only.
|
||||
* @type Boolean
|
||||
* @default false
|
||||
*/
|
||||
separateTextures: false,
|
||||
/**
|
||||
* Gets or sets whether the converter will do a more exhaustive check for texture transparency by looking at the alpha channel of each pixel.
|
||||
* @type Boolean
|
||||
* @default false
|
||||
*/
|
||||
checkTransparency: false,
|
||||
/**
|
||||
* Gets and sets whether a material will be doubleSided or not
|
||||
* @type Boolean
|
||||
* @default false
|
||||
*/
|
||||
doubleSidedMaterial: false,
|
||||
/**
|
||||
* Gets or sets whether the source model can reference paths outside of its directory.
|
||||
* @type Boolean
|
||||
* @default false
|
||||
*/
|
||||
secure: false,
|
||||
/**
|
||||
* Gets or sets whether to pack the occlusion texture in the red channel of the metallic-roughness texture.
|
||||
* @type Boolean
|
||||
* @default false
|
||||
*/
|
||||
packOcclusion: false,
|
||||
/**
|
||||
* Gets or sets whether rhe values in the .mtl file are already metallic-roughness PBR values and no conversion step should be applied. Metallic is stored in the Ks and map_Ks slots and roughness is stored in the Ns and map_Ns slots.
|
||||
* @type Boolean
|
||||
* @default false
|
||||
*/
|
||||
metallicRoughness: false,
|
||||
/**
|
||||
* Gets or sets whether the values in the .mtl file are already specular-glossiness PBR values and no conversion step should be applied. Specular is stored in the Ks and map_Ks slots and glossiness is stored in the Ns and map_Ns slots. The glTF will be saved with the KHR_materials_pbrSpecularGlossiness extension.
|
||||
* @type Boolean
|
||||
* @default false
|
||||
*/
|
||||
specularGlossiness: false,
|
||||
/**
|
||||
* Gets or sets whether the glTF will be saved with the KHR_materials_unlit extension.
|
||||
* @type Boolean
|
||||
* @default false
|
||||
*/
|
||||
unlit: false,
|
||||
/**
|
||||
* Gets or sets the up axis of the obj.
|
||||
* @type String
|
||||
* @default 'Y'
|
||||
*/
|
||||
inputUpAxis: "Y",
|
||||
/**
|
||||
* Gets or sets the up axis of the converted glTF.
|
||||
* @type String
|
||||
* @default 'Y'
|
||||
*/
|
||||
outputUpAxis: "Y",
|
||||
/**
|
||||
* Gets or sets whether triangle winding order sanitization will be applied.
|
||||
* @type Boolean
|
||||
* @default false
|
||||
*/
|
||||
windingOrderSanitization: false,
|
||||
};
|
||||
|
||||
/**
|
||||
* A callback function that logs messages.
|
||||
* @callback Logger
|
||||
*
|
||||
* @param {String} message The message to log.
|
||||
*/
|
||||
|
||||
/**
|
||||
* A callback function that writes files that are saved as separate resources.
|
||||
* @callback Writer
|
||||
*
|
||||
* @param {String} file The relative path of the file.
|
||||
* @param {Buffer} data The file data to write.
|
||||
* @returns {Promise} A promise that resolves when the file is written.
|
||||
*/
|
||||
+17
@@ -0,0 +1,17 @@
|
||||
"use strict";
|
||||
const path = require("path");
|
||||
|
||||
module.exports = outsideDirectory;
|
||||
|
||||
/**
|
||||
* Checks if a file is outside of a directory.
|
||||
*
|
||||
* @param {String} file Path to the file.
|
||||
* @param {String} directory Path to the directory.
|
||||
* @returns {Boolean} Whether the file is outside of the directory.
|
||||
*
|
||||
* @private
|
||||
*/
|
||||
function outsideDirectory(file, directory) {
|
||||
return path.relative(directory, file).indexOf("..") === 0;
|
||||
}
|
||||
+40
@@ -0,0 +1,40 @@
|
||||
"use strict";
|
||||
const fsExtra = require("fs-extra");
|
||||
const Promise = require("bluebird");
|
||||
const readline = require("readline");
|
||||
const events = require("events");
|
||||
|
||||
module.exports = readLines;
|
||||
|
||||
/**
|
||||
* Read a file line-by-line.
|
||||
*
|
||||
* @param {String} path Path to the file.
|
||||
* @param {Function} callback Function to call when reading each line.
|
||||
* @returns {Promise} A promise when the reader is finished.
|
||||
*
|
||||
* @private
|
||||
*/
|
||||
function readLines(path, callback) {
|
||||
const stream = fsExtra.createReadStream(path);
|
||||
return events.once(stream, "open").then(function () {
|
||||
return new Promise(function (resolve, reject) {
|
||||
stream.on("error", reject);
|
||||
stream.on("end", resolve);
|
||||
|
||||
const lineReader = readline.createInterface({
|
||||
input: stream,
|
||||
});
|
||||
|
||||
const callbackWrapper = function (line) {
|
||||
try {
|
||||
callback(line);
|
||||
} catch (error) {
|
||||
reject(error);
|
||||
}
|
||||
};
|
||||
|
||||
lineReader.on("line", callbackWrapper);
|
||||
});
|
||||
});
|
||||
}
|
||||
+206
@@ -0,0 +1,206 @@
|
||||
"use strict";
|
||||
const Cesium = require("cesium");
|
||||
const mime = require("mime");
|
||||
const PNG = require("pngjs").PNG;
|
||||
const Promise = require("bluebird");
|
||||
const getBufferPadded = require("./getBufferPadded");
|
||||
const gltfToGlb = require("./gltfToGlb");
|
||||
|
||||
const defined = Cesium.defined;
|
||||
const RuntimeError = Cesium.RuntimeError;
|
||||
|
||||
module.exports = writeGltf;
|
||||
|
||||
/**
|
||||
* Write glTF resources as embedded data uris or external files.
|
||||
*
|
||||
* @param {Object} gltf The glTF asset.
|
||||
* @param {Object} options The options object passed along from lib/obj2gltf.js
|
||||
* @returns {Promise} A promise that resolves to the glTF JSON or glb buffer.
|
||||
*
|
||||
* @private
|
||||
*/
|
||||
function writeGltf(gltf, options) {
|
||||
return encodeTextures(gltf).then(function () {
|
||||
const binary = options.binary;
|
||||
const separate = options.separate;
|
||||
const separateTextures = options.separateTextures;
|
||||
|
||||
const promises = [];
|
||||
if (separateTextures) {
|
||||
promises.push(writeSeparateTextures(gltf, options));
|
||||
} else {
|
||||
writeEmbeddedTextures(gltf);
|
||||
}
|
||||
|
||||
if (separate) {
|
||||
promises.push(writeSeparateBuffers(gltf, options));
|
||||
} else if (!binary) {
|
||||
writeEmbeddedBuffer(gltf);
|
||||
}
|
||||
|
||||
const binaryBuffer = gltf.buffers[0].extras._obj2gltf.source;
|
||||
|
||||
return Promise.all(promises).then(function () {
|
||||
deleteExtras(gltf);
|
||||
removeEmpty(gltf);
|
||||
if (binary) {
|
||||
return gltfToGlb(gltf, binaryBuffer);
|
||||
}
|
||||
return gltf;
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
function encodePng(texture) {
|
||||
// Constants defined by pngjs
|
||||
const rgbColorType = 2;
|
||||
const rgbaColorType = 6;
|
||||
|
||||
const png = new PNG({
|
||||
width: texture.width,
|
||||
height: texture.height,
|
||||
colorType: texture.transparent ? rgbaColorType : rgbColorType,
|
||||
inputColorType: rgbaColorType,
|
||||
inputHasAlpha: true,
|
||||
});
|
||||
|
||||
png.data = texture.pixels;
|
||||
|
||||
return new Promise(function (resolve, reject) {
|
||||
const chunks = [];
|
||||
const stream = png.pack();
|
||||
stream.on("data", function (chunk) {
|
||||
chunks.push(chunk);
|
||||
});
|
||||
stream.on("end", function () {
|
||||
resolve(Buffer.concat(chunks));
|
||||
});
|
||||
stream.on("error", reject);
|
||||
});
|
||||
}
|
||||
|
||||
function encodeTexture(texture) {
|
||||
if (
|
||||
!defined(texture.source) &&
|
||||
defined(texture.pixels) &&
|
||||
texture.extension === ".png"
|
||||
) {
|
||||
return encodePng(texture).then(function (encoded) {
|
||||
texture.source = encoded;
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
function encodeTextures(gltf) {
|
||||
// Dynamically generated PBR textures need to be encoded to png prior to being saved
|
||||
const encodePromises = [];
|
||||
const images = gltf.images;
|
||||
const length = images.length;
|
||||
for (let i = 0; i < length; ++i) {
|
||||
encodePromises.push(encodeTexture(images[i].extras._obj2gltf));
|
||||
}
|
||||
return Promise.all(encodePromises);
|
||||
}
|
||||
|
||||
function deleteExtras(gltf) {
|
||||
const buffers = gltf.buffers;
|
||||
const buffersLength = buffers.length;
|
||||
for (let i = 0; i < buffersLength; ++i) {
|
||||
delete buffers[i].extras;
|
||||
}
|
||||
|
||||
const images = gltf.images;
|
||||
const imagesLength = images.length;
|
||||
for (let i = 0; i < imagesLength; ++i) {
|
||||
delete images[i].extras;
|
||||
}
|
||||
}
|
||||
|
||||
function removeEmpty(json) {
|
||||
Object.keys(json).forEach(function (key) {
|
||||
if (
|
||||
!defined(json[key]) ||
|
||||
(Array.isArray(json[key]) && json[key].length === 0)
|
||||
) {
|
||||
delete json[key]; // Delete values that are undefined or []
|
||||
} else if (typeof json[key] === "object") {
|
||||
removeEmpty(json[key]);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
function writeSeparateBuffers(gltf, options) {
|
||||
const buffers = gltf.buffers;
|
||||
return Promise.map(
|
||||
buffers,
|
||||
function (buffer) {
|
||||
const source = buffer.extras._obj2gltf.source;
|
||||
const bufferUri = `${buffer.name}.bin`;
|
||||
buffer.uri = bufferUri;
|
||||
return options.writer(bufferUri, source);
|
||||
},
|
||||
{ concurrency: 10 },
|
||||
);
|
||||
}
|
||||
|
||||
function writeSeparateTextures(gltf, options) {
|
||||
const images = gltf.images;
|
||||
return Promise.map(
|
||||
images,
|
||||
function (image) {
|
||||
const texture = image.extras._obj2gltf;
|
||||
const imageUri = image.name + texture.extension;
|
||||
image.uri = imageUri;
|
||||
return options.writer(imageUri, texture.source);
|
||||
},
|
||||
{ concurrency: 10 },
|
||||
);
|
||||
}
|
||||
|
||||
function writeEmbeddedBuffer(gltf) {
|
||||
const buffer = gltf.buffers[0];
|
||||
const source = buffer.extras._obj2gltf.source;
|
||||
|
||||
// Buffers larger than ~192MB cannot be base64 encoded due to a NodeJS limitation. Source: https://github.com/nodejs/node/issues/4266
|
||||
if (source.length > 201326580) {
|
||||
throw new RuntimeError(
|
||||
"Buffer is too large to embed in the glTF. Use the --separate flag instead.",
|
||||
);
|
||||
}
|
||||
|
||||
buffer.uri = `data:application/octet-stream;base64,${source.toString(
|
||||
"base64",
|
||||
)}`;
|
||||
}
|
||||
|
||||
function writeEmbeddedTextures(gltf) {
|
||||
const buffer = gltf.buffers[0];
|
||||
const bufferExtras = buffer.extras._obj2gltf;
|
||||
const bufferSource = bufferExtras.source;
|
||||
const images = gltf.images;
|
||||
const imagesLength = images.length;
|
||||
const sources = [bufferSource];
|
||||
let byteOffset = bufferSource.length;
|
||||
|
||||
for (let i = 0; i < imagesLength; ++i) {
|
||||
const image = images[i];
|
||||
const texture = image.extras._obj2gltf;
|
||||
const textureSource = texture.source;
|
||||
const textureByteLength = textureSource.length;
|
||||
|
||||
image.mimeType = mime.getType(texture.extension);
|
||||
image.bufferView = gltf.bufferViews.length;
|
||||
gltf.bufferViews.push({
|
||||
buffer: 0,
|
||||
byteOffset: byteOffset,
|
||||
byteLength: textureByteLength,
|
||||
});
|
||||
byteOffset += textureByteLength;
|
||||
sources.push(textureSource);
|
||||
}
|
||||
|
||||
const source = getBufferPadded(Buffer.concat(sources));
|
||||
bufferExtras.source = source;
|
||||
buffer.byteLength = source.length;
|
||||
}
|
||||
+75
@@ -0,0 +1,75 @@
|
||||
{
|
||||
"name": "obj2gltf",
|
||||
"version": "3.2.0",
|
||||
"description": "Convert OBJ model format to glTF",
|
||||
"license": "Apache-2.0",
|
||||
"contributors": [
|
||||
{
|
||||
"name": "Cesium GS, Inc. and Contributors",
|
||||
"url": "https://github.com/CesiumGS/obj2gltf/graphs/contributors"
|
||||
}
|
||||
],
|
||||
"keywords": [
|
||||
"obj",
|
||||
"gltf"
|
||||
],
|
||||
"homepage": "https://github.com/CesiumGS/obj2gltf",
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "git@github.com:CesiumGS/obj2gltf.git"
|
||||
},
|
||||
"bugs": {
|
||||
"url": "https://github.com/CesiumGS/obj2gltf/issues"
|
||||
},
|
||||
"main": "index.js",
|
||||
"engines": {
|
||||
"node": ">=14.0.0"
|
||||
},
|
||||
"dependencies": {
|
||||
"bluebird": "^3.7.2",
|
||||
"cesium": "^1.86.1",
|
||||
"fs-extra": "^11.0.0",
|
||||
"jpeg-js": "^0.4.3",
|
||||
"mime": "^3.0.0",
|
||||
"pngjs": "^7.0.0",
|
||||
"yargs": "^17.2.1"
|
||||
},
|
||||
"devDependencies": {
|
||||
"cloc": "^2.8.0",
|
||||
"eslint": "^8.0.1",
|
||||
"eslint-config-cesium": "^10.0.1",
|
||||
"eslint-config-prettier": "^9.0.0",
|
||||
"eslint-plugin-n": "^16.1.0",
|
||||
"gulp": "^4.0.2",
|
||||
"husky": "^8.0.3",
|
||||
"jasmine": "^5.0.0",
|
||||
"jasmine-spec-reporter": "^7.0.0",
|
||||
"jsdoc": "^4.0.0",
|
||||
"lint-staged": "^15.0.2",
|
||||
"nyc": "^15.1.0",
|
||||
"prettier": "3.1.1"
|
||||
},
|
||||
"lint-staged": {
|
||||
"*.(js|ts)": [
|
||||
"eslint --cache --quiet --fix",
|
||||
"prettier --write"
|
||||
],
|
||||
"*.!(js|ts)": "prettier --write"
|
||||
},
|
||||
"scripts": {
|
||||
"prepare": "husky install",
|
||||
"pre-commit": "lint-staged",
|
||||
"jsdoc": "jsdoc ./lib -R ./README.md -d doc",
|
||||
"eslint": "eslint \"./**/*.js\" --cache --quiet",
|
||||
"test": "gulp test",
|
||||
"test-watch": "gulp test-watch",
|
||||
"coverage": "gulp coverage",
|
||||
"cloc": "gulp cloc",
|
||||
"prettier": "prettier --write \"**/*\"",
|
||||
"prettier-check": "prettier --check \"**/*\"",
|
||||
"generate-third-party": "gulp generate-third-party"
|
||||
},
|
||||
"bin": {
|
||||
"obj2gltf": "./bin/obj2gltf.js"
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user