mirror of
https://github.com/CesiumGS/obj2gltf.git
synced 2024-11-23 08:34:14 -05:00
Run prettier
This commit is contained in:
Sean Lilley
parent
bd4b7320fa
commit
dc3ec3074f
131
CHANGES.md
131
CHANGES.md
@ -1,147 +1,146 @@
|
||||
Change Log
|
||||
==========
|
||||
# Change Log
|
||||
|
||||
### 3.?.? - 2021-??-??
|
||||
|
||||
* 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)
|
||||
- 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)
|
||||
- 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)
|
||||
- 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)
|
||||
- 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)
|
||||
- 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)
|
||||
- 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)
|
||||
- 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)
|
||||
- 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)
|
||||
- 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)
|
||||
- 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)
|
||||
- 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)
|
||||
- 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)
|
||||
- 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.
|
||||
- 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)
|
||||
- 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)
|
||||
- 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.
|
||||
- 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)
|
||||
- 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.
|
||||
- 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)
|
||||
- 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.
|
||||
- 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.
|
||||
- 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.
|
||||
- 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.
|
||||
- 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.
|
||||
- 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.
|
||||
- Updated to use gltf-pipeline 0.1.0-alpha2.
|
||||
|
||||
### 0.1.0 - 2016-07-20
|
||||
|
||||
* Initial release.
|
||||
- Initial release.
|
||||
|
||||
46
LICENSE.md
46
LICENSE.md
@ -4,9 +4,9 @@ Copyright 2016-2020 Cesium GS, Inc. and Contributors
|
||||
Version 2.0, January 2004
|
||||
http://www.apache.org/licenses/
|
||||
|
||||
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
|
||||
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
|
||||
|
||||
1. Definitions.
|
||||
1. Definitions.
|
||||
|
||||
"License" shall mean the terms and conditions for use, reproduction,
|
||||
and distribution as defined by Sections 1 through 9 of this document.
|
||||
@ -65,14 +65,14 @@ Copyright 2016-2020 Cesium GS, Inc. and Contributors
|
||||
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
|
||||
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
|
||||
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,
|
||||
@ -88,7 +88,7 @@ Copyright 2016-2020 Cesium GS, Inc. and Contributors
|
||||
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
|
||||
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:
|
||||
@ -129,7 +129,7 @@ Copyright 2016-2020 Cesium GS, Inc. and Contributors
|
||||
reproduction, and distribution of the Work otherwise complies with
|
||||
the conditions stated in this License.
|
||||
|
||||
5. Submission of Contributions. Unless You explicitly state otherwise,
|
||||
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.
|
||||
@ -137,12 +137,12 @@ Copyright 2016-2020 Cesium GS, Inc. and Contributors
|
||||
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
|
||||
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
|
||||
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
|
||||
@ -152,7 +152,7 @@ Copyright 2016-2020 Cesium GS, Inc. and Contributors
|
||||
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,
|
||||
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
|
||||
@ -164,7 +164,7 @@ Copyright 2016-2020 Cesium GS, Inc. and Contributors
|
||||
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
|
||||
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
|
||||
@ -175,9 +175,9 @@ Copyright 2016-2020 Cesium GS, Inc. and Contributors
|
||||
incurred by, or claims asserted against, such Contributor by reason
|
||||
of your accepting any such warranty or additional liability.
|
||||
|
||||
END OF TERMS AND CONDITIONS
|
||||
END OF TERMS AND CONDITIONS
|
||||
|
||||
APPENDIX: How to apply the Apache License to your work.
|
||||
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 "{}"
|
||||
@ -188,23 +188,21 @@ Copyright 2016-2020 Cesium GS, Inc. and Contributors
|
||||
same "printed page" as the copyright notice for easier
|
||||
identification within third-party archives.
|
||||
|
||||
Copyright 2016-2020 Cesium GS, Inc. and Contributors
|
||||
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
|
||||
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.
|
||||
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
|
||||
================
|
||||
# Third-Party Code
|
||||
|
||||
obj2gltf includes the following third-party code.
|
||||
|
||||
|
||||
120
README.md
120
README.md
@ -5,6 +5,7 @@ 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
|
||||
```
|
||||
@ -22,27 +23,25 @@ npm install -g obj2gltf
|
||||
#### Converting an obj model to gltf:
|
||||
|
||||
```javascript
|
||||
const obj2gltf = require('obj2gltf');
|
||||
const fs = require('fs');
|
||||
obj2gltf('model.obj')
|
||||
.then(function(gltf) {
|
||||
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);
|
||||
});
|
||||
fs.writeFileSync("model.gltf", data);
|
||||
});
|
||||
```
|
||||
|
||||
#### Converting an obj model to glb
|
||||
|
||||
```javascript
|
||||
const obj2gltf = require('obj2gltf');
|
||||
const fs = require('fs');
|
||||
const obj2gltf = require("obj2gltf");
|
||||
const fs = require("fs");
|
||||
const options = {
|
||||
binary : true
|
||||
}
|
||||
obj2gltf('model.obj', options)
|
||||
.then(function(glb) {
|
||||
fs.writeFileSync('model.glb', glb);
|
||||
});
|
||||
binary: true,
|
||||
};
|
||||
obj2gltf("model.obj", options).then(function (glb) {
|
||||
fs.writeFileSync("model.glb", glb);
|
||||
});
|
||||
```
|
||||
|
||||
## Material types
|
||||
@ -52,9 +51,9 @@ 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)
|
||||
- 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.
|
||||
|
||||
@ -71,62 +70,67 @@ 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|
|
||||
| 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|
|
||||
| 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 |
|
||||
|
||||
## 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
|
||||
```
|
||||
@ -134,9 +138,11 @@ 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.
|
||||
@ -144,6 +150,7 @@ The tests and coverage covers the Node.js module; it does not cover the command-
|
||||
## Generating Documentation
|
||||
|
||||
To generate the documentation:
|
||||
|
||||
```
|
||||
npm run jsdoc
|
||||
```
|
||||
@ -157,6 +164,7 @@ Pull requests are appreciated. Please use the same [Contributor License Agreeme
|
||||
---
|
||||
|
||||
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>
|
||||
|
||||
298
bin/obj2gltf.js
298
bin/obj2gltf.js
@ -1,10 +1,10 @@
|
||||
#!/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');
|
||||
"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 = Cesium.defaultValue;
|
||||
const defined = Cesium.defined;
|
||||
@ -14,147 +14,169 @@ 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')
|
||||
.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) {
|
||||
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');
|
||||
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) {
|
||||
},
|
||||
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');
|
||||
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
|
||||
binary: {
|
||||
alias: "b",
|
||||
describe: "Save as binary glTF (.glb)",
|
||||
type: "boolean",
|
||||
default: defaults.binary,
|
||||
},
|
||||
separateTextures : {
|
||||
alias : 't',
|
||||
describe : 'Write out separate textures only.',
|
||||
type : 'boolean',
|
||||
default : defaults.separateTextures
|
||||
separate: {
|
||||
alias: "s",
|
||||
describe:
|
||||
"Write separate buffers and textures instead of embedding them in the glTF.",
|
||||
type: "boolean",
|
||||
default: defaults.separate,
|
||||
},
|
||||
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
|
||||
separateTextures: {
|
||||
alias: "t",
|
||||
describe: "Write out separate textures only.",
|
||||
type: "boolean",
|
||||
default: defaults.separateTextures,
|
||||
},
|
||||
secure : {
|
||||
describe : 'Prevent the converter from reading textures or mtl files outside of the input obj directory.',
|
||||
type : 'boolean',
|
||||
default : defaults.secure
|
||||
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,
|
||||
},
|
||||
packOcclusion : {
|
||||
describe : 'Pack the occlusion texture in the red channel of metallic-roughness texture.',
|
||||
type : 'boolean',
|
||||
default : defaults.packOcclusion
|
||||
secure: {
|
||||
describe:
|
||||
"Prevent the converter from reading textures or mtl files outside of the input obj directory.",
|
||||
type: "boolean",
|
||||
default: defaults.secure,
|
||||
},
|
||||
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
|
||||
packOcclusion: {
|
||||
describe:
|
||||
"Pack the occlusion texture in the red channel of metallic-roughness texture.",
|
||||
type: "boolean",
|
||||
default: defaults.packOcclusion,
|
||||
},
|
||||
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
|
||||
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,
|
||||
},
|
||||
unlit : {
|
||||
describe : 'The glTF will be saved with the KHR_materials_unlit extension.',
|
||||
type : 'boolean',
|
||||
default : defaults.unlit
|
||||
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,
|
||||
},
|
||||
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
|
||||
unlit: {
|
||||
describe:
|
||||
"The glTF will be saved with the KHR_materials_unlit extension.",
|
||||
type: "boolean",
|
||||
default: defaults.unlit,
|
||||
},
|
||||
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
|
||||
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,
|
||||
},
|
||||
occlusionTexture : {
|
||||
describe : 'Path to the occlusion texture that should override textures in the .mtl file.',
|
||||
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,
|
||||
},
|
||||
normalTexture : {
|
||||
describe : 'Path to the normal texture that should override textures in the .mtl file.',
|
||||
type : 'string',
|
||||
normalize : true
|
||||
occlusionTexture: {
|
||||
describe:
|
||||
"Path to the occlusion 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
|
||||
normalTexture: {
|
||||
describe:
|
||||
"Path to the normal 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
|
||||
baseColorTexture: {
|
||||
describe:
|
||||
"Path to the baseColor/diffuse 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.'
|
||||
emissiveTexture: {
|
||||
describe:
|
||||
"Path to the emissive texture that should override textures in the .mtl file.",
|
||||
type: "string",
|
||||
normalize: true,
|
||||
},
|
||||
inputUpAxis : {
|
||||
describe: 'Up axis of the obj.',
|
||||
choices: ['X', 'Y', 'Z'],
|
||||
type: 'string',
|
||||
default: 'Y'
|
||||
alphaTexture: {
|
||||
describe:
|
||||
"Path to the alpha texture that should override textures in the .mtl file.",
|
||||
},
|
||||
outputUpAxis : {
|
||||
describe: 'Up axis of the converted glTF.',
|
||||
choices: ['X', 'Y', 'Z'],
|
||||
type: 'string',
|
||||
default: 'Y'
|
||||
inputUpAxis: {
|
||||
describe: "Up axis of the obj.",
|
||||
choices: ["X", "Y", "Z"],
|
||||
type: "string",
|
||||
default: "Y",
|
||||
},
|
||||
triangleWindingOrderSanitization : {
|
||||
describe: 'Apply triangle winding order sanitization.',
|
||||
type: 'boolean',
|
||||
default: defaults.triangleWindingOrderSanitization
|
||||
}
|
||||
}).parse(args);
|
||||
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,
|
||||
},
|
||||
})
|
||||
.parse(args);
|
||||
|
||||
if (argv.metallicRoughness + argv.specularGlossiness > 1) {
|
||||
console.error('Only one material type may be set from [--metallicRoughness, --specularGlossiness].');
|
||||
console.error(
|
||||
"Only one material type may be set from [--metallicRoughness, --specularGlossiness]."
|
||||
);
|
||||
process.exit(1);
|
||||
}
|
||||
|
||||
if (defined(argv.metallicRoughnessOcclusionTexture) && defined(argv.specularGlossinessTexture)) {
|
||||
console.error('--metallicRoughnessOcclusionTexture and --specularGlossinessTexture cannot both be set.');
|
||||
if (
|
||||
defined(argv.metallicRoughnessOcclusionTexture) &&
|
||||
defined(argv.specularGlossinessTexture)
|
||||
) {
|
||||
console.error(
|
||||
"--metallicRoughnessOcclusionTexture and --specularGlossinessTexture cannot both be set."
|
||||
);
|
||||
process.exit(1);
|
||||
}
|
||||
|
||||
@ -164,55 +186,55 @@ 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';
|
||||
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
|
||||
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
|
||||
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,
|
||||
};
|
||||
|
||||
console.time('Total');
|
||||
console.time("Total");
|
||||
|
||||
obj2gltf(objPath, options)
|
||||
.then(function(gltf) {
|
||||
.then(function (gltf) {
|
||||
if (binary) {
|
||||
// gltf is a glb buffer
|
||||
return fsExtra.outputFile(gltfPath, gltf);
|
||||
}
|
||||
const jsonOptions = {
|
||||
spaces : 2
|
||||
spaces: 2,
|
||||
};
|
||||
return fsExtra.outputJson(gltfPath, gltf, jsonOptions);
|
||||
})
|
||||
.then(function() {
|
||||
console.timeEnd('Total');
|
||||
.then(function () {
|
||||
console.timeEnd("Total");
|
||||
})
|
||||
.catch(function(error) {
|
||||
.catch(function (error) {
|
||||
console.log(error.message);
|
||||
process.exit(1);
|
||||
});
|
||||
|
||||
103
gulpfile.js
103
gulpfile.js
@ -1,40 +1,49 @@
|
||||
'use strict';
|
||||
"use strict";
|
||||
|
||||
const Cesium = require('cesium');
|
||||
const Promise = require('bluebird');
|
||||
const child_process = require('child_process');
|
||||
const fsExtra = require('fs-extra');
|
||||
const gulp = require('gulp');
|
||||
const Jasmine = require('jasmine');
|
||||
const JasmineSpecReporter = require('jasmine-spec-reporter').SpecReporter;
|
||||
const open = require('open');
|
||||
const path = require('path');
|
||||
const yargs = require('yargs');
|
||||
const Cesium = require("cesium");
|
||||
const Promise = require("bluebird");
|
||||
const child_process = require("child_process");
|
||||
const fsExtra = require("fs-extra");
|
||||
const gulp = require("gulp");
|
||||
const Jasmine = require("jasmine");
|
||||
const JasmineSpecReporter = require("jasmine-spec-reporter").SpecReporter;
|
||||
const open = require("open");
|
||||
const path = require("path");
|
||||
const yargs = require("yargs");
|
||||
|
||||
const defined = Cesium.defined;
|
||||
const argv = yargs.argv;
|
||||
|
||||
// Add third-party node module binaries to the system path
|
||||
// since some tasks need to call them directly.
|
||||
const environmentSeparator = process.platform === 'win32' ? ';' : ':';
|
||||
const nodeBinaries = path.join(__dirname, 'node_modules', '.bin');
|
||||
const environmentSeparator = process.platform === "win32" ? ";" : ":";
|
||||
const nodeBinaries = path.join(__dirname, "node_modules", ".bin");
|
||||
process.env.PATH += environmentSeparator + nodeBinaries;
|
||||
|
||||
const specFiles = ['**/*.js', '!node_modules/**', '!coverage/**', '!doc/**', '!bin/**'];
|
||||
const specFiles = [
|
||||
"**/*.js",
|
||||
"!node_modules/**",
|
||||
"!coverage/**",
|
||||
"!doc/**",
|
||||
"!bin/**",
|
||||
];
|
||||
|
||||
module.exports = {
|
||||
test: test,
|
||||
'test-watch': testWatch,
|
||||
"test-watch": testWatch,
|
||||
coverage: coverage,
|
||||
cloc: cloc
|
||||
cloc: cloc,
|
||||
};
|
||||
|
||||
function test(done) {
|
||||
const jasmine = new Jasmine();
|
||||
jasmine.loadConfigFile('specs/jasmine.json');
|
||||
jasmine.addReporter(new JasmineSpecReporter({
|
||||
displaySuccessfulSpec: !defined(argv.suppressPassed) || !argv.suppressPassed
|
||||
}));
|
||||
jasmine.loadConfigFile("specs/jasmine.json");
|
||||
jasmine.addReporter(
|
||||
new JasmineSpecReporter({
|
||||
displaySuccessfulSpec:
|
||||
!defined(argv.suppressPassed) || !argv.suppressPassed,
|
||||
})
|
||||
);
|
||||
jasmine.execute();
|
||||
jasmine.onComplete(function (passed) {
|
||||
done(argv.failTaskOnError && !passed ? 1 : 0);
|
||||
@ -42,64 +51,66 @@ function test(done) {
|
||||
}
|
||||
|
||||
function testWatch() {
|
||||
return gulp.watch(specFiles).on('change', function () {
|
||||
return gulp.watch(specFiles).on("change", function () {
|
||||
// We can't simply depend on the test task because Jasmine
|
||||
// does not like being run multiple times in the same process.
|
||||
try {
|
||||
child_process.execSync('jasmine JASMINE_CONFIG_PATH=specs/jasmine.json', {
|
||||
stdio: [process.stdin, process.stdout, process.stderr]
|
||||
child_process.execSync("jasmine JASMINE_CONFIG_PATH=specs/jasmine.json", {
|
||||
stdio: [process.stdin, process.stdout, process.stderr],
|
||||
});
|
||||
} catch (exception) {
|
||||
console.log('Tests failed to execute.');
|
||||
console.log("Tests failed to execute.");
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
async function coverage() {
|
||||
fsExtra.removeSync('coverage/server');
|
||||
child_process.execSync('nyc' +
|
||||
' --all' +
|
||||
' --reporter=lcov' +
|
||||
' --dir coverage' +
|
||||
fsExtra.removeSync("coverage/server");
|
||||
child_process.execSync(
|
||||
"nyc" +
|
||||
" --all" +
|
||||
" --reporter=lcov" +
|
||||
" --dir coverage" +
|
||||
' -x "specs/**" -x "coverage/**" -x "doc/**" -x "bin/**" -x "index.js" -x "gulpfile.js"' +
|
||||
' node_modules/jasmine/bin/jasmine.js' +
|
||||
' JASMINE_CONFIG_PATH=specs/jasmine.json', {
|
||||
stdio: [process.stdin, process.stdout, process.stderr]
|
||||
});
|
||||
open('coverage/lcov-report/index.html');
|
||||
" node_modules/jasmine/bin/jasmine.js" +
|
||||
" JASMINE_CONFIG_PATH=specs/jasmine.json",
|
||||
{
|
||||
stdio: [process.stdin, process.stdout, process.stderr],
|
||||
}
|
||||
);
|
||||
open("coverage/lcov-report/index.html");
|
||||
}
|
||||
|
||||
function cloc() {
|
||||
let cmdLine;
|
||||
const clocPath = path.join('node_modules', 'cloc', 'lib', 'cloc');
|
||||
const clocPath = path.join("node_modules", "cloc", "lib", "cloc");
|
||||
|
||||
//Run cloc on primary Source files only
|
||||
const source = new Promise(function(resolve, reject) {
|
||||
cmdLine = 'perl ' + clocPath + ' --quiet --progress-rate=0' +
|
||||
' lib/ bin/';
|
||||
const source = new Promise(function (resolve, reject) {
|
||||
cmdLine = "perl " + clocPath + " --quiet --progress-rate=0" + " lib/ bin/";
|
||||
|
||||
child_process.exec(cmdLine, function(error, stdout, stderr) {
|
||||
child_process.exec(cmdLine, function (error, stdout, stderr) {
|
||||
if (error) {
|
||||
console.log(stderr);
|
||||
return reject(error);
|
||||
}
|
||||
console.log('Source:');
|
||||
console.log("Source:");
|
||||
console.log(stdout);
|
||||
resolve();
|
||||
});
|
||||
});
|
||||
|
||||
//If running cloc on source succeeded, also run it on the tests.
|
||||
return source.then(function() {
|
||||
return new Promise(function(resolve, reject) {
|
||||
cmdLine = 'perl ' + clocPath + ' --quiet --progress-rate=0' +
|
||||
' specs/lib/';
|
||||
child_process.exec(cmdLine, function(error, stdout, stderr) {
|
||||
return source.then(function () {
|
||||
return new Promise(function (resolve, reject) {
|
||||
cmdLine =
|
||||
"perl " + clocPath + " --quiet --progress-rate=0" + " specs/lib/";
|
||||
child_process.exec(cmdLine, function (error, stdout, stderr) {
|
||||
if (error) {
|
||||
console.log(stderr);
|
||||
return reject(error);
|
||||
}
|
||||
console.log('Specs:');
|
||||
console.log("Specs:");
|
||||
console.log(stdout);
|
||||
resolve();
|
||||
});
|
||||
|
||||
4
index.js
4
index.js
@ -1,2 +1,2 @@
|
||||
'use strict';
|
||||
module.exports = require('./lib/obj2gltf');
|
||||
"use strict";
|
||||
module.exports = require("./lib/obj2gltf");
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
'use strict';
|
||||
const Cesium = require('cesium');
|
||||
"use strict";
|
||||
const Cesium = require("cesium");
|
||||
|
||||
const ComponentDatatype = Cesium.ComponentDatatype;
|
||||
|
||||
@ -24,12 +24,15 @@ function ArrayStorage(componentDatatype) {
|
||||
}
|
||||
|
||||
function resize(storage, length) {
|
||||
const typedArray = ComponentDatatype.createTypedArray(storage.componentDatatype, length);
|
||||
const typedArray = ComponentDatatype.createTypedArray(
|
||||
storage.componentDatatype,
|
||||
length
|
||||
);
|
||||
typedArray.set(storage.typedArray);
|
||||
storage.typedArray = typedArray;
|
||||
}
|
||||
|
||||
ArrayStorage.prototype.push = function(value) {
|
||||
ArrayStorage.prototype.push = function (value) {
|
||||
const length = this.length;
|
||||
const typedArrayLength = this.typedArray.length;
|
||||
|
||||
@ -46,7 +49,7 @@ ArrayStorage.prototype.push = function(value) {
|
||||
this.typedArray[this.length++] = value;
|
||||
};
|
||||
|
||||
ArrayStorage.prototype.get = function(index) {
|
||||
ArrayStorage.prototype.get = function (index) {
|
||||
return this.typedArray[index];
|
||||
};
|
||||
|
||||
@ -54,10 +57,10 @@ const sizeOfUint16 = 2;
|
||||
const sizeOfUint32 = 4;
|
||||
const sizeOfFloat = 4;
|
||||
|
||||
ArrayStorage.prototype.toUint16Buffer = function() {
|
||||
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 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);
|
||||
@ -65,7 +68,7 @@ ArrayStorage.prototype.toUint16Buffer = function() {
|
||||
return buffer;
|
||||
};
|
||||
|
||||
ArrayStorage.prototype.toUint32Buffer = function() {
|
||||
ArrayStorage.prototype.toUint32Buffer = function () {
|
||||
const length = this.length;
|
||||
const typedArray = this.typedArray;
|
||||
const buffer = Buffer.alloc(length * sizeOfUint32);
|
||||
@ -75,7 +78,7 @@ ArrayStorage.prototype.toUint32Buffer = function() {
|
||||
return buffer;
|
||||
};
|
||||
|
||||
ArrayStorage.prototype.toFloatBuffer = function() {
|
||||
ArrayStorage.prototype.toFloatBuffer = function () {
|
||||
const length = this.length;
|
||||
const typedArray = this.typedArray;
|
||||
const buffer = Buffer.alloc(length * sizeOfFloat);
|
||||
@ -85,7 +88,7 @@ ArrayStorage.prototype.toFloatBuffer = function() {
|
||||
return buffer;
|
||||
};
|
||||
|
||||
ArrayStorage.prototype.getMinMax = function(components) {
|
||||
ArrayStorage.prototype.getMinMax = function (components) {
|
||||
const length = this.length;
|
||||
const typedArray = this.typedArray;
|
||||
const count = length / components;
|
||||
@ -100,7 +103,7 @@ ArrayStorage.prototype.getMinMax = function(components) {
|
||||
}
|
||||
}
|
||||
return {
|
||||
min : min,
|
||||
max : max
|
||||
min: min,
|
||||
max: max,
|
||||
};
|
||||
};
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
'use strict';
|
||||
"use strict";
|
||||
|
||||
module.exports = Texture;
|
||||
|
||||
|
||||
@ -1,9 +1,9 @@
|
||||
'use strict';
|
||||
const BUFFER_MAX_BYTE_LENGTH = require('buffer').constants.MAX_LENGTH;
|
||||
const Cesium = require('cesium');
|
||||
const getBufferPadded = require('./getBufferPadded');
|
||||
const getDefaultMaterial = require('./loadMtl').getDefaultMaterial;
|
||||
const Texture = require('./Texture');
|
||||
"use strict";
|
||||
const BUFFER_MAX_BYTE_LENGTH = require("buffer").constants.MAX_LENGTH;
|
||||
const Cesium = require("cesium");
|
||||
const getBufferPadded = require("./getBufferPadded");
|
||||
const getDefaultMaterial = require("./loadMtl").getDefaultMaterial;
|
||||
const Texture = require("./Texture");
|
||||
|
||||
const defaultValue = Cesium.defaultValue;
|
||||
const defined = Cesium.defined;
|
||||
@ -29,40 +29,40 @@ function createGltf(objData, options) {
|
||||
materials = splitIncompatibleMaterials(nodes, materials, options);
|
||||
|
||||
const gltf = {
|
||||
accessors : [],
|
||||
asset : {},
|
||||
buffers : [],
|
||||
bufferViews : [],
|
||||
extensionsUsed : [],
|
||||
extensionsRequired : [],
|
||||
images : [],
|
||||
materials : [],
|
||||
meshes : [],
|
||||
nodes : [],
|
||||
samplers : [],
|
||||
scene : 0,
|
||||
scenes : [],
|
||||
textures : []
|
||||
accessors: [],
|
||||
asset: {},
|
||||
buffers: [],
|
||||
bufferViews: [],
|
||||
extensionsUsed: [],
|
||||
extensionsRequired: [],
|
||||
images: [],
|
||||
materials: [],
|
||||
meshes: [],
|
||||
nodes: [],
|
||||
samplers: [],
|
||||
scene: 0,
|
||||
scenes: [],
|
||||
textures: [],
|
||||
};
|
||||
|
||||
gltf.asset = {
|
||||
generator : 'obj2gltf',
|
||||
version: '2.0'
|
||||
generator: "obj2gltf",
|
||||
version: "2.0",
|
||||
};
|
||||
|
||||
gltf.scenes.push({
|
||||
nodes : []
|
||||
nodes: [],
|
||||
});
|
||||
|
||||
const bufferState = {
|
||||
positionBuffers : [],
|
||||
normalBuffers : [],
|
||||
uvBuffers : [],
|
||||
indexBuffers : [],
|
||||
positionAccessors : [],
|
||||
normalAccessors : [],
|
||||
uvAccessors : [],
|
||||
indexAccessors : []
|
||||
positionBuffers: [],
|
||||
normalBuffers: [],
|
||||
uvBuffers: [],
|
||||
indexBuffers: [],
|
||||
positionAccessors: [],
|
||||
normalAccessors: [],
|
||||
uvAccessors: [],
|
||||
indexAccessors: [],
|
||||
};
|
||||
|
||||
const uint32Indices = requiresUint32Indices(nodes);
|
||||
@ -74,14 +74,28 @@ function createGltf(objData, options) {
|
||||
const meshesLength = meshes.length;
|
||||
|
||||
if (meshesLength === 1) {
|
||||
const meshIndex = addMesh(gltf, materials, bufferState, uint32Indices, meshes[0], options);
|
||||
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);
|
||||
const meshIndex = addMesh(
|
||||
gltf,
|
||||
materials,
|
||||
bufferState,
|
||||
uint32Indices,
|
||||
mesh,
|
||||
options
|
||||
);
|
||||
addNode(gltf, mesh.name, meshIndex, parentIndex);
|
||||
}
|
||||
}
|
||||
@ -89,21 +103,21 @@ function createGltf(objData, options) {
|
||||
|
||||
if (gltf.images.length > 0) {
|
||||
gltf.samplers.push({
|
||||
wrapS : WebGLConstants.REPEAT,
|
||||
wrapT : WebGLConstants.REPEAT
|
||||
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');
|
||||
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');
|
||||
gltf.extensionsUsed.push("KHR_materials_unlit");
|
||||
gltf.extensionsRequired.push("KHR_materials_unlit");
|
||||
}
|
||||
|
||||
return gltf;
|
||||
@ -116,7 +130,9 @@ function addCombinedBufferView(gltf, buffers, accessors, byteStride, target) {
|
||||
}
|
||||
const bufferViewIndex = gltf.bufferViews.length;
|
||||
const previousBufferView = gltf.bufferViews[bufferViewIndex - 1];
|
||||
const byteOffset = defined(previousBufferView) ? previousBufferView.byteOffset + previousBufferView.byteLength : 0;
|
||||
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]];
|
||||
@ -125,85 +141,167 @@ function addCombinedBufferView(gltf, buffers, accessors, byteStride, target) {
|
||||
byteLength += buffers[i].length;
|
||||
}
|
||||
gltf.bufferViews.push({
|
||||
name : 'bufferView_' + bufferViewIndex,
|
||||
buffer : 0,
|
||||
byteLength : byteLength,
|
||||
byteOffset : byteOffset,
|
||||
byteStride : byteStride,
|
||||
target : target
|
||||
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);
|
||||
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);
|
||||
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
|
||||
}
|
||||
}
|
||||
name: name,
|
||||
byteLength: buffer.length,
|
||||
extras: {
|
||||
_obj2gltf: {
|
||||
source: buffer,
|
||||
},
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
function addSeparateBufferView(gltf, buffer, accessor, byteStride, target, name) {
|
||||
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
|
||||
}
|
||||
}
|
||||
name: name + "_" + bufferIndex,
|
||||
byteLength: buffer.length,
|
||||
extras: {
|
||||
_obj2gltf: {
|
||||
source: buffer,
|
||||
},
|
||||
},
|
||||
});
|
||||
|
||||
gltf.bufferViews.push({
|
||||
buffer : bufferIndex,
|
||||
byteLength : buffer.length,
|
||||
byteOffset : 0,
|
||||
byteStride : byteStride,
|
||||
target : target
|
||||
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) {
|
||||
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);
|
||||
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);
|
||||
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 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())) {
|
||||
if (separate && buffersByteLength > createGltf._getBufferMaxByteLength()) {
|
||||
// Don't combine buffers if the combined buffer will exceed the Node limit.
|
||||
addSeparateBuffers(gltf, bufferState, name);
|
||||
} else {
|
||||
@ -218,16 +316,16 @@ function addTexture(gltf, texture) {
|
||||
const textureIndex = gltf.textures.length;
|
||||
|
||||
gltf.images.push({
|
||||
name : imageName,
|
||||
extras : {
|
||||
_obj2gltf : texture
|
||||
}
|
||||
name: imageName,
|
||||
extras: {
|
||||
_obj2gltf: texture,
|
||||
},
|
||||
});
|
||||
|
||||
gltf.textures.push({
|
||||
name : textureName,
|
||||
sampler : 0,
|
||||
source : imageIndex
|
||||
name: textureName,
|
||||
sampler: 0,
|
||||
source: imageIndex,
|
||||
});
|
||||
|
||||
return textureIndex;
|
||||
@ -249,12 +347,12 @@ function getTexture(gltf, texture) {
|
||||
}
|
||||
|
||||
return {
|
||||
index : textureIndex
|
||||
index: textureIndex,
|
||||
};
|
||||
}
|
||||
|
||||
function cloneMaterial(material, removeTextures) {
|
||||
if (typeof material !== 'object') {
|
||||
if (typeof material !== "object") {
|
||||
return material;
|
||||
} else if (material instanceof Texture) {
|
||||
if (removeTextures) {
|
||||
@ -284,7 +382,7 @@ function resolveTextures(gltf, material) {
|
||||
const property = material[name];
|
||||
if (property instanceof Texture) {
|
||||
material[name] = getTexture(gltf, property);
|
||||
} else if (!Array.isArray(property) && (typeof property === 'object')) {
|
||||
} else if (!Array.isArray(property) && typeof property === "object") {
|
||||
resolveTextures(gltf, property);
|
||||
}
|
||||
}
|
||||
@ -334,18 +432,26 @@ function getOrCreateGltfMaterial(gltf, materials, materialName, options) {
|
||||
}
|
||||
|
||||
function primitiveInfoMatch(a, b) {
|
||||
return a.hasUvs === b.hasUvs &&
|
||||
a.hasNormals === b.hasNormals;
|
||||
return a.hasUvs === b.hasUvs && a.hasNormals === b.hasNormals;
|
||||
}
|
||||
|
||||
function getSplitMaterialName(originalMaterialName, primitiveInfo, primitiveInfoByMaterial) {
|
||||
function getSplitMaterialName(
|
||||
originalMaterialName,
|
||||
primitiveInfo,
|
||||
primitiveInfoByMaterial
|
||||
) {
|
||||
let splitMaterialName = originalMaterialName;
|
||||
let suffix = 2;
|
||||
while (defined(primitiveInfoByMaterial[splitMaterialName])) {
|
||||
if (primitiveInfoMatch(primitiveInfo, primitiveInfoByMaterial[splitMaterialName])) {
|
||||
if (
|
||||
primitiveInfoMatch(
|
||||
primitiveInfo,
|
||||
primitiveInfoByMaterial[splitMaterialName]
|
||||
)
|
||||
) {
|
||||
break;
|
||||
}
|
||||
splitMaterialName = originalMaterialName + '-' + suffix++;
|
||||
splitMaterialName = originalMaterialName + "-" + suffix++;
|
||||
}
|
||||
return splitMaterialName;
|
||||
}
|
||||
@ -365,20 +471,33 @@ function splitIncompatibleMaterials(nodes, materials, options) {
|
||||
const hasUvs = primitive.uvs.length > 0;
|
||||
const hasNormals = primitive.normals.length > 0;
|
||||
const primitiveInfo = {
|
||||
hasUvs : hasUvs,
|
||||
hasNormals : hasNormals
|
||||
hasUvs: hasUvs,
|
||||
hasNormals: hasNormals,
|
||||
};
|
||||
const originalMaterialName = defaultValue(primitive.material, 'default');
|
||||
const splitMaterialName = getSplitMaterialName(originalMaterialName, primitiveInfo, primitiveInfoByMaterial);
|
||||
const originalMaterialName = defaultValue(
|
||||
primitive.material,
|
||||
"default"
|
||||
);
|
||||
const splitMaterialName = getSplitMaterialName(
|
||||
originalMaterialName,
|
||||
primitiveInfo,
|
||||
primitiveInfoByMaterial
|
||||
);
|
||||
primitive.material = splitMaterialName;
|
||||
primitiveInfoByMaterial[splitMaterialName] = primitiveInfo;
|
||||
|
||||
let splitMaterial = getMaterialByName(splitMaterials, splitMaterialName);
|
||||
let splitMaterial = getMaterialByName(
|
||||
splitMaterials,
|
||||
splitMaterialName
|
||||
);
|
||||
if (defined(splitMaterial)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
const originalMaterial = getMaterialByName(materials, originalMaterialName);
|
||||
const originalMaterial = getMaterialByName(
|
||||
materials,
|
||||
originalMaterialName
|
||||
);
|
||||
if (defined(originalMaterial)) {
|
||||
splitMaterial = cloneMaterial(originalMaterial, !hasUvs);
|
||||
} else {
|
||||
@ -395,15 +514,15 @@ function splitIncompatibleMaterials(nodes, materials, options) {
|
||||
function addVertexAttribute(gltf, array, components, name) {
|
||||
const count = array.length / components;
|
||||
const minMax = array.getMinMax(components);
|
||||
const type = (components === 3 ? 'VEC3' : 'VEC2');
|
||||
const type = components === 3 ? "VEC3" : "VEC2";
|
||||
|
||||
const accessor = {
|
||||
name : name,
|
||||
componentType : WebGLConstants.FLOAT,
|
||||
count : count,
|
||||
min : minMax.min,
|
||||
max : minMax.max,
|
||||
type : type
|
||||
name: name,
|
||||
componentType: WebGLConstants.FLOAT,
|
||||
count: count,
|
||||
min: minMax.min,
|
||||
max: minMax.max,
|
||||
type: type,
|
||||
};
|
||||
|
||||
const accessorIndex = gltf.accessors.length;
|
||||
@ -412,17 +531,19 @@ function addVertexAttribute(gltf, array, components, name) {
|
||||
}
|
||||
|
||||
function addIndexArray(gltf, array, uint32Indices, name) {
|
||||
const componentType = uint32Indices ? WebGLConstants.UNSIGNED_INT : WebGLConstants.UNSIGNED_SHORT;
|
||||
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'
|
||||
name: name,
|
||||
componentType: componentType,
|
||||
count: count,
|
||||
min: minMax.min,
|
||||
max: minMax.max,
|
||||
type: "SCALAR",
|
||||
};
|
||||
|
||||
const accessorIndex = gltf.accessors.length;
|
||||
@ -450,33 +571,64 @@ function requiresUint32Indices(nodes) {
|
||||
return false;
|
||||
}
|
||||
|
||||
function addPrimitive(gltf, materials, bufferState, uint32Indices, mesh, primitive, index, options) {
|
||||
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');
|
||||
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');
|
||||
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');
|
||||
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();
|
||||
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);
|
||||
|
||||
@ -486,13 +638,18 @@ function addPrimitive(gltf, materials, bufferState, uint32Indices, mesh, primiti
|
||||
primitive.uvs = undefined;
|
||||
primitive.indices = undefined;
|
||||
|
||||
const materialIndex = getOrCreateGltfMaterial(gltf, materials, primitive.material, options);
|
||||
const materialIndex = getOrCreateGltfMaterial(
|
||||
gltf,
|
||||
materials,
|
||||
primitive.material,
|
||||
options
|
||||
);
|
||||
|
||||
return {
|
||||
attributes : attributes,
|
||||
indices : indexAccessorIndex,
|
||||
material : materialIndex,
|
||||
mode : WebGLConstants.TRIANGLES
|
||||
attributes: attributes,
|
||||
indices: indexAccessorIndex,
|
||||
material: materialIndex,
|
||||
mode: WebGLConstants.TRIANGLES,
|
||||
};
|
||||
}
|
||||
|
||||
@ -501,12 +658,23 @@ function addMesh(gltf, materials, bufferState, uint32Indices, mesh, options) {
|
||||
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));
|
||||
gltfPrimitives.push(
|
||||
addPrimitive(
|
||||
gltf,
|
||||
materials,
|
||||
bufferState,
|
||||
uint32Indices,
|
||||
mesh,
|
||||
primitives[i],
|
||||
i,
|
||||
options
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
const gltfMesh = {
|
||||
name : mesh.name,
|
||||
primitives : gltfPrimitives
|
||||
name: mesh.name,
|
||||
primitives: gltfPrimitives,
|
||||
};
|
||||
|
||||
const meshIndex = gltf.meshes.length;
|
||||
@ -516,8 +684,8 @@ function addMesh(gltf, materials, bufferState, uint32Indices, mesh, options) {
|
||||
|
||||
function addNode(gltf, name, meshIndex, parentIndex) {
|
||||
const node = {
|
||||
name : name,
|
||||
mesh : meshIndex
|
||||
name: name,
|
||||
mesh: meshIndex,
|
||||
};
|
||||
|
||||
const nodeIndex = gltf.nodes.length;
|
||||
@ -537,6 +705,6 @@ function addNode(gltf, name, meshIndex, parentIndex) {
|
||||
}
|
||||
|
||||
// Exposed for testing
|
||||
createGltf._getBufferMaxByteLength = function() {
|
||||
createGltf._getBufferMaxByteLength = function () {
|
||||
return BUFFER_MAX_BYTE_LENGTH;
|
||||
};
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
'use strict';
|
||||
"use strict";
|
||||
module.exports = getBufferPadded;
|
||||
|
||||
/**
|
||||
@ -16,7 +16,7 @@ function getBufferPadded(buffer) {
|
||||
if (remainder === 0) {
|
||||
return buffer;
|
||||
}
|
||||
const padding = (remainder === 0) ? 0 : boundary - remainder;
|
||||
const padding = remainder === 0 ? 0 : boundary - remainder;
|
||||
const emptyBuffer = Buffer.alloc(padding);
|
||||
return Buffer.concat([buffer, emptyBuffer]);
|
||||
}
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
'use strict';
|
||||
"use strict";
|
||||
module.exports = getJsonBufferPadded;
|
||||
|
||||
/**
|
||||
@ -18,10 +18,10 @@ function getJsonBufferPadded(json) {
|
||||
const boundary = 4;
|
||||
const byteLength = Buffer.byteLength(string);
|
||||
const remainder = byteLength % boundary;
|
||||
const padding = (remainder === 0) ? 0 : boundary - remainder;
|
||||
let whitespace = '';
|
||||
const padding = remainder === 0 ? 0 : boundary - remainder;
|
||||
let whitespace = "";
|
||||
for (let i = 0; i < padding; ++i) {
|
||||
whitespace += ' ';
|
||||
whitespace += " ";
|
||||
}
|
||||
string += whitespace;
|
||||
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
'use strict';
|
||||
const Cesium = require('cesium');
|
||||
const getJsonBufferPadded = require('./getJsonBufferPadded');
|
||||
"use strict";
|
||||
const Cesium = require("cesium");
|
||||
const getJsonBufferPadded = require("./getJsonBufferPadded");
|
||||
|
||||
const defined = Cesium.defined;
|
||||
|
||||
@ -32,7 +32,7 @@ function gltfToGlb(gltf, binaryBuffer) {
|
||||
|
||||
// Write binary glTF header (magic, version, length)
|
||||
let byteOffset = 0;
|
||||
glb.writeUInt32LE(0x46546C67, byteOffset);
|
||||
glb.writeUInt32LE(0x46546c67, byteOffset);
|
||||
byteOffset += 4;
|
||||
glb.writeUInt32LE(2, byteOffset);
|
||||
byteOffset += 4;
|
||||
@ -42,7 +42,7 @@ function gltfToGlb(gltf, binaryBuffer) {
|
||||
// Write JSON Chunk header (length, type)
|
||||
glb.writeUInt32LE(jsonBuffer.length, byteOffset);
|
||||
byteOffset += 4;
|
||||
glb.writeUInt32LE(0x4E4F534A, byteOffset); // JSON
|
||||
glb.writeUInt32LE(0x4e4f534a, byteOffset); // JSON
|
||||
byteOffset += 4;
|
||||
|
||||
// Write JSON Chunk
|
||||
@ -52,7 +52,7 @@ function gltfToGlb(gltf, binaryBuffer) {
|
||||
// Write Binary Chunk header (length, type)
|
||||
glb.writeUInt32LE(binaryBuffer.length, byteOffset);
|
||||
byteOffset += 4;
|
||||
glb.writeUInt32LE(0x004E4942, byteOffset); // BIN
|
||||
glb.writeUInt32LE(0x004e4942, byteOffset); // BIN
|
||||
byteOffset += 4;
|
||||
|
||||
// Write Binary Chunk
|
||||
|
||||
520
lib/loadMtl.js
520
lib/loadMtl.js
@ -1,11 +1,11 @@
|
||||
'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');
|
||||
"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;
|
||||
@ -41,9 +41,18 @@ function loadMtl(mtlPath, options) {
|
||||
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 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;
|
||||
@ -51,20 +60,30 @@ function loadMtl(mtlPath, options) {
|
||||
|
||||
// Textures that are packed into PBR textures need to be decoded first
|
||||
const decodeOptions = {
|
||||
decode : true
|
||||
decode: true,
|
||||
};
|
||||
|
||||
const diffuseTextureOptions = {
|
||||
checkTransparency : options.checkTransparency
|
||||
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 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
|
||||
decode: true,
|
||||
};
|
||||
|
||||
function createMaterial(name) {
|
||||
@ -88,7 +107,7 @@ function loadMtl(mtlPath, options) {
|
||||
if (re.test(texturePath)) {
|
||||
texturePath = texturePath.split(/\s+/).pop();
|
||||
}
|
||||
texturePath = texturePath.replace(/\\/g, '/');
|
||||
texturePath = texturePath.replace(/\\/g, "/");
|
||||
return path.normalize(path.resolve(mtlDirectory, texturePath));
|
||||
}
|
||||
|
||||
@ -98,36 +117,36 @@ function loadMtl(mtlPath, options) {
|
||||
const name = line.substring(7).trim();
|
||||
createMaterial(name);
|
||||
} else if (/^Ka /i.test(line)) {
|
||||
values = line.substring(3).trim().split(' ');
|
||||
values = line.substring(3).trim().split(" ");
|
||||
material.ambientColor = [
|
||||
parseFloat(values[0]),
|
||||
parseFloat(values[1]),
|
||||
parseFloat(values[2]),
|
||||
1.0
|
||||
1.0,
|
||||
];
|
||||
} else if (/^Ke /i.test(line)) {
|
||||
values = line.substring(3).trim().split(' ');
|
||||
values = line.substring(3).trim().split(" ");
|
||||
material.emissiveColor = [
|
||||
parseFloat(values[0]),
|
||||
parseFloat(values[1]),
|
||||
parseFloat(values[2]),
|
||||
1.0
|
||||
1.0,
|
||||
];
|
||||
} else if (/^Kd /i.test(line)) {
|
||||
values = line.substring(3).trim().split(' ');
|
||||
values = line.substring(3).trim().split(" ");
|
||||
material.diffuseColor = [
|
||||
parseFloat(values[0]),
|
||||
parseFloat(values[1]),
|
||||
parseFloat(values[2]),
|
||||
1.0
|
||||
1.0,
|
||||
];
|
||||
} else if (/^Ks /i.test(line)) {
|
||||
values = line.substring(3).trim().split(' ');
|
||||
values = line.substring(3).trim().split(" ");
|
||||
material.specularColor = [
|
||||
parseFloat(values[0]),
|
||||
parseFloat(values[1]),
|
||||
parseFloat(values[2]),
|
||||
1.0
|
||||
1.0,
|
||||
];
|
||||
} else if (/^Ns /i.test(line)) {
|
||||
value = line.substring(3).trim();
|
||||
@ -140,38 +159,61 @@ function loadMtl(mtlPath, options) {
|
||||
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);
|
||||
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);
|
||||
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);
|
||||
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);
|
||||
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);
|
||||
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);
|
||||
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);
|
||||
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;
|
||||
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
|
||||
@ -179,11 +221,27 @@ function loadMtl(mtlPath, options) {
|
||||
material.ambientTexture = undefined;
|
||||
}
|
||||
|
||||
const textureNames = ['diffuseTexture', 'ambientTexture', 'emissiveTexture', 'specularTexture', 'specularShininessTexture', 'normalTexture', 'alphaTexture'];
|
||||
const textureOptions = [diffuseAlphaTextureOptions, ambientTextureOptions, emissiveTextureOptions, specularTextureOptions, specularShinessTextureOptions, normalTextureOptions, alphaTextureOptions];
|
||||
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) {
|
||||
textureNames.forEach(function (name, index) {
|
||||
const texturePath = material[name];
|
||||
const originalOptions = textureOptions[index];
|
||||
if (defined(texturePath) && defined(originalOptions)) {
|
||||
@ -191,29 +249,41 @@ function loadMtl(mtlPath, options) {
|
||||
sharedOptions[texturePath] = clone(originalOptions);
|
||||
}
|
||||
const options = sharedOptions[texturePath];
|
||||
options.checkTransparency = options.checkTransparency || originalOptions.checkTransparency;
|
||||
options.checkTransparency =
|
||||
options.checkTransparency || originalOptions.checkTransparency;
|
||||
options.decode = options.decode || originalOptions.decode;
|
||||
options.keepSource = options.keepSource || !originalOptions.decode || !originalOptions.checkTransparency;
|
||||
options.keepSource =
|
||||
options.keepSource ||
|
||||
!originalOptions.decode ||
|
||||
!originalOptions.checkTransparency;
|
||||
}
|
||||
});
|
||||
|
||||
textureNames.forEach(function(name) {
|
||||
textureNames.forEach(function (name) {
|
||||
const texturePath = material[name];
|
||||
if (defined(texturePath)) {
|
||||
loadMaterialTexture(material, name, sharedOptions[texturePath], mtlDirectory, texturePromiseMap, texturePromises, options);
|
||||
loadMaterialTexture(
|
||||
material,
|
||||
name,
|
||||
sharedOptions[texturePath],
|
||||
mtlDirectory,
|
||||
texturePromiseMap,
|
||||
texturePromises,
|
||||
options
|
||||
);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
return readLines(mtlPath, parseLine)
|
||||
.then(function() {
|
||||
.then(function () {
|
||||
const length = materials.length;
|
||||
for (let i = 0; i < length; ++i) {
|
||||
loadMaterialTextures(materials[i]);
|
||||
}
|
||||
return Promise.all(texturePromises);
|
||||
})
|
||||
.then(function() {
|
||||
.then(function () {
|
||||
return convertMaterials(materials, options);
|
||||
});
|
||||
}
|
||||
@ -240,16 +310,24 @@ function Material() {
|
||||
this.alphaTexture = undefined; // map_d
|
||||
}
|
||||
|
||||
loadMtl.getDefaultMaterial = function(options) {
|
||||
loadMtl.getDefaultMaterial = function (options) {
|
||||
return convertMaterial(new Material(), options);
|
||||
};
|
||||
|
||||
// Exposed for testing
|
||||
loadMtl._createMaterial = function(materialOptions, options) {
|
||||
loadMtl._createMaterial = function (materialOptions, options) {
|
||||
return convertMaterial(combine(materialOptions, new Material()), options);
|
||||
};
|
||||
|
||||
function loadMaterialTexture(material, name, textureOptions, mtlDirectory, texturePromiseMap, texturePromises, options) {
|
||||
function loadMaterialTexture(
|
||||
material,
|
||||
name,
|
||||
textureOptions,
|
||||
mtlDirectory,
|
||||
texturePromiseMap,
|
||||
texturePromises,
|
||||
options
|
||||
) {
|
||||
const texturePath = material[name];
|
||||
if (!defined(texturePath)) {
|
||||
return;
|
||||
@ -260,32 +338,48 @@ function loadMaterialTexture(material, name, textureOptions, mtlDirectory, textu
|
||||
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(
|
||||
"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');
|
||||
options.logger(
|
||||
"Could not read texture file at " +
|
||||
shallowPath +
|
||||
". This texture will be ignored"
|
||||
);
|
||||
});
|
||||
} else {
|
||||
texturePromise = loadTexture(texturePath, textureOptions)
|
||||
.catch(function(error) {
|
||||
.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.');
|
||||
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) {
|
||||
.catch(function (error) {
|
||||
options.logger(error.message);
|
||||
options.logger('Could not read texture file at ' + shallowPath + '. This texture will be ignored.');
|
||||
options.logger(
|
||||
"Could not read texture file at " +
|
||||
shallowPath +
|
||||
". This texture will be ignored."
|
||||
);
|
||||
});
|
||||
}
|
||||
texturePromiseMap[texturePath] = texturePromise;
|
||||
}
|
||||
|
||||
texturePromises.push(texturePromise
|
||||
.then(function(texture) {
|
||||
texturePromises.push(
|
||||
texturePromise.then(function (texture) {
|
||||
material[name] = texture;
|
||||
}));
|
||||
})
|
||||
);
|
||||
}
|
||||
|
||||
function convertMaterial(material, options) {
|
||||
@ -300,12 +394,19 @@ function convertMaterial(material, options) {
|
||||
}
|
||||
|
||||
function convertMaterials(materials, options) {
|
||||
return materials.map(function(material) {
|
||||
return materials.map(function (material) {
|
||||
return convertMaterial(material, options);
|
||||
});
|
||||
}
|
||||
|
||||
function resizeChannel(sourcePixels, sourceWidth, sourceHeight, targetPixels, targetWidth, targetHeight) {
|
||||
function resizeChannel(
|
||||
sourcePixels,
|
||||
sourceWidth,
|
||||
sourceHeight,
|
||||
targetPixels,
|
||||
targetWidth,
|
||||
targetHeight
|
||||
) {
|
||||
// Nearest neighbor sampling
|
||||
const widthRatio = sourceWidth / targetWidth;
|
||||
const heightRatio = sourceHeight / targetHeight;
|
||||
@ -325,7 +426,13 @@ function resizeChannel(sourcePixels, sourceWidth, sourceHeight, targetPixels, ta
|
||||
|
||||
let scratchResizeChannel;
|
||||
|
||||
function getTextureChannel(texture, index, targetWidth, targetHeight, targetChannel) {
|
||||
function getTextureChannel(
|
||||
texture,
|
||||
index,
|
||||
targetWidth,
|
||||
targetHeight,
|
||||
targetChannel
|
||||
) {
|
||||
const pixels = texture.pixels; // RGBA
|
||||
const sourceWidth = texture.width;
|
||||
const sourceHeight = texture.height;
|
||||
@ -335,7 +442,10 @@ function getTextureChannel(texture, index, targetWidth, targetHeight, targetChan
|
||||
// Allocate the scratchResizeChannel on demand if the texture needs to be resized
|
||||
let sourceChannel = targetChannel;
|
||||
if (sourcePixelsLength > targetPixelsLength) {
|
||||
if (!defined(scratchResizeChannel) || (sourcePixelsLength > scratchResizeChannel.length)) {
|
||||
if (
|
||||
!defined(scratchResizeChannel) ||
|
||||
sourcePixelsLength > scratchResizeChannel.length
|
||||
) {
|
||||
scratchResizeChannel = Buffer.alloc(sourcePixelsLength);
|
||||
}
|
||||
sourceChannel = scratchResizeChannel;
|
||||
@ -347,7 +457,14 @@ function getTextureChannel(texture, index, targetWidth, targetHeight, targetChan
|
||||
}
|
||||
|
||||
if (sourcePixelsLength > targetPixelsLength) {
|
||||
resizeChannel(sourceChannel, sourceWidth, sourceHeight, targetChannel, targetWidth, targetHeight);
|
||||
resizeChannel(
|
||||
sourceChannel,
|
||||
sourceWidth,
|
||||
sourceHeight,
|
||||
targetChannel,
|
||||
targetWidth,
|
||||
targetHeight
|
||||
);
|
||||
}
|
||||
|
||||
return targetChannel;
|
||||
@ -375,7 +492,19 @@ function getMinimumDimensions(textures, options) {
|
||||
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 + '.');
|
||||
options.logger(
|
||||
"Texture " +
|
||||
texture.path +
|
||||
" will be scaled from " +
|
||||
texture.width +
|
||||
"x" +
|
||||
texture.height +
|
||||
" to " +
|
||||
width +
|
||||
"x" +
|
||||
height +
|
||||
"."
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@ -410,7 +539,13 @@ function createDiffuseAlphaTexture(diffuseTexture, alphaTexture, options) {
|
||||
}
|
||||
|
||||
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.');
|
||||
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;
|
||||
}
|
||||
|
||||
@ -419,27 +554,57 @@ function createDiffuseAlphaTexture(diffuseTexture, alphaTexture, 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 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);
|
||||
const redChannel = getTextureChannel(
|
||||
diffuseTexture,
|
||||
0,
|
||||
width,
|
||||
height,
|
||||
scratchChannel
|
||||
);
|
||||
writeChannel(pixels, redChannel, 0);
|
||||
const greenChannel = getTextureChannel(diffuseTexture, 1, width, height, scratchChannel);
|
||||
const greenChannel = getTextureChannel(
|
||||
diffuseTexture,
|
||||
1,
|
||||
width,
|
||||
height,
|
||||
scratchChannel
|
||||
);
|
||||
writeChannel(pixels, greenChannel, 1);
|
||||
const blueChannel = getTextureChannel(diffuseTexture, 2, width, height, scratchChannel);
|
||||
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);
|
||||
let alphaChannel = getTextureChannel(
|
||||
alphaTexture,
|
||||
3,
|
||||
width,
|
||||
height,
|
||||
scratchChannel
|
||||
);
|
||||
if (isChannelSingleColor(alphaChannel)) {
|
||||
alphaChannel = getTextureChannel(alphaTexture, 0, width, height, scratchChannel);
|
||||
alphaChannel = getTextureChannel(
|
||||
alphaTexture,
|
||||
0,
|
||||
width,
|
||||
height,
|
||||
scratchChannel
|
||||
);
|
||||
}
|
||||
writeChannel(pixels, alphaChannel, 3);
|
||||
|
||||
const texture = new Texture();
|
||||
texture.name = diffuseTexture.name;
|
||||
texture.extension = '.png';
|
||||
texture.extension = ".png";
|
||||
texture.pixels = pixels;
|
||||
texture.width = width;
|
||||
texture.height = height;
|
||||
@ -448,7 +613,12 @@ function createDiffuseAlphaTexture(diffuseTexture, alphaTexture, options) {
|
||||
return texture;
|
||||
}
|
||||
|
||||
function createMetallicRoughnessTexture(metallicTexture, roughnessTexture, occlusionTexture, options) {
|
||||
function createMetallicRoughnessTexture(
|
||||
metallicTexture,
|
||||
roughnessTexture,
|
||||
occlusionTexture,
|
||||
options
|
||||
) {
|
||||
if (defined(options.overridingTextures.metallicRoughnessOcclusionTexture)) {
|
||||
return metallicTexture;
|
||||
}
|
||||
@ -462,21 +632,37 @@ function createMetallicRoughnessTexture(metallicTexture, roughnessTexture, occlu
|
||||
}
|
||||
|
||||
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.');
|
||||
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.');
|
||||
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.');
|
||||
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) {
|
||||
const packedTextures = [
|
||||
metallicTexture,
|
||||
roughnessTexture,
|
||||
occlusionTexture,
|
||||
].filter(function (texture) {
|
||||
return defined(texture) && defined(texture.pixels);
|
||||
});
|
||||
|
||||
@ -484,24 +670,42 @@ function createMetallicRoughnessTexture(metallicTexture, roughnessTexture, occlu
|
||||
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 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);
|
||||
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);
|
||||
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);
|
||||
const occlusionChannel = getTextureChannel(
|
||||
occlusionTexture,
|
||||
0,
|
||||
width,
|
||||
height,
|
||||
scratchChannel
|
||||
);
|
||||
writeChannel(pixels, occlusionChannel, 0);
|
||||
}
|
||||
|
||||
@ -510,11 +714,11 @@ function createMetallicRoughnessTexture(metallicTexture, roughnessTexture, occlu
|
||||
for (let i = 0; i < length; ++i) {
|
||||
names[i] = packedTextures[i].name;
|
||||
}
|
||||
const name = names.join('_');
|
||||
const name = names.join("_");
|
||||
|
||||
const texture = new Texture();
|
||||
texture.name = name;
|
||||
texture.extension = '.png';
|
||||
texture.extension = ".png";
|
||||
texture.pixels = pixels;
|
||||
texture.width = width;
|
||||
texture.height = height;
|
||||
@ -522,7 +726,11 @@ function createMetallicRoughnessTexture(metallicTexture, roughnessTexture, occlu
|
||||
return texture;
|
||||
}
|
||||
|
||||
function createSpecularGlossinessTexture(specularTexture, glossinessTexture, options) {
|
||||
function createSpecularGlossinessTexture(
|
||||
specularTexture,
|
||||
glossinessTexture,
|
||||
options
|
||||
) {
|
||||
if (defined(options.overridingTextures.specularGlossinessTexture)) {
|
||||
return specularTexture;
|
||||
}
|
||||
@ -535,16 +743,26 @@ function createSpecularGlossinessTexture(specularTexture, glossinessTexture, opt
|
||||
}
|
||||
|
||||
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.');
|
||||
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.');
|
||||
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) {
|
||||
const packedTextures = [specularTexture, glossinessTexture].filter(function (
|
||||
texture
|
||||
) {
|
||||
return defined(texture) && defined(texture.pixels);
|
||||
});
|
||||
|
||||
@ -552,22 +770,46 @@ function createSpecularGlossinessTexture(specularTexture, glossinessTexture, opt
|
||||
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 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);
|
||||
const redChannel = getTextureChannel(
|
||||
specularTexture,
|
||||
0,
|
||||
width,
|
||||
height,
|
||||
scratchChannel
|
||||
);
|
||||
writeChannel(pixels, redChannel, 0);
|
||||
const greenChannel = getTextureChannel(specularTexture, 1, width, height, scratchChannel);
|
||||
const greenChannel = getTextureChannel(
|
||||
specularTexture,
|
||||
1,
|
||||
width,
|
||||
height,
|
||||
scratchChannel
|
||||
);
|
||||
writeChannel(pixels, greenChannel, 1);
|
||||
const blueChannel = getTextureChannel(specularTexture, 2, width, height, scratchChannel);
|
||||
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);
|
||||
const glossinessChannel = getTextureChannel(
|
||||
glossinessTexture,
|
||||
0,
|
||||
width,
|
||||
height,
|
||||
scratchChannel
|
||||
);
|
||||
writeChannel(pixels, glossinessChannel, 3);
|
||||
}
|
||||
|
||||
@ -576,11 +818,11 @@ function createSpecularGlossinessTexture(specularTexture, glossinessTexture, opt
|
||||
for (let i = 0; i < length; ++i) {
|
||||
names[i] = packedTextures[i].name;
|
||||
}
|
||||
const name = names.join('_');
|
||||
const name = names.join("_");
|
||||
|
||||
const texture = new Texture();
|
||||
texture.name = name;
|
||||
texture.extension = '.png';
|
||||
texture.extension = ".png";
|
||||
texture.pixels = pixels;
|
||||
texture.width = width;
|
||||
texture.height = height;
|
||||
@ -596,8 +838,16 @@ function createSpecularGlossinessMaterial(material, options) {
|
||||
const alphaTexture = material.alphaTexture;
|
||||
const specularTexture = material.specularTexture;
|
||||
const glossinessTexture = material.specularShininessTexture;
|
||||
const specularGlossinessTexture = createSpecularGlossinessTexture(specularTexture, glossinessTexture, options);
|
||||
const diffuseAlphaTexture = createDiffuseAlphaTexture(diffuseTexture, alphaTexture, options);
|
||||
const specularGlossinessTexture = createSpecularGlossinessTexture(
|
||||
specularTexture,
|
||||
glossinessTexture,
|
||||
options
|
||||
);
|
||||
const diffuseAlphaTexture = createDiffuseAlphaTexture(
|
||||
diffuseTexture,
|
||||
alphaTexture,
|
||||
options
|
||||
);
|
||||
|
||||
let emissiveFactor = material.emissiveColor.slice(0, 3);
|
||||
let diffuseFactor = material.diffuseColor;
|
||||
@ -634,25 +884,25 @@ function createSpecularGlossinessMaterial(material, options) {
|
||||
}
|
||||
|
||||
const doubleSided = transparent;
|
||||
const alphaMode = transparent ? 'BLEND' : 'OPAQUE';
|
||||
const alphaMode = transparent ? "BLEND" : "OPAQUE";
|
||||
|
||||
return {
|
||||
name : material.name,
|
||||
extensions : {
|
||||
name: material.name,
|
||||
extensions: {
|
||||
KHR_materials_pbrSpecularGlossiness: {
|
||||
diffuseTexture : diffuseAlphaTexture,
|
||||
specularGlossinessTexture : specularGlossinessTexture,
|
||||
diffuseFactor : diffuseFactor,
|
||||
specularFactor : specularFactor,
|
||||
glossinessFactor : glossinessFactor
|
||||
}
|
||||
diffuseTexture: diffuseAlphaTexture,
|
||||
specularGlossinessTexture: specularGlossinessTexture,
|
||||
diffuseFactor: diffuseFactor,
|
||||
specularFactor: specularFactor,
|
||||
glossinessFactor: glossinessFactor,
|
||||
},
|
||||
emissiveTexture : emissiveTexture,
|
||||
normalTexture : normalTexture,
|
||||
occlusionTexture : occlusionTexture,
|
||||
emissiveFactor : emissiveFactor,
|
||||
alphaMode : alphaMode,
|
||||
doubleSided : doubleSided
|
||||
},
|
||||
emissiveTexture: emissiveTexture,
|
||||
normalTexture: normalTexture,
|
||||
occlusionTexture: occlusionTexture,
|
||||
emissiveFactor: emissiveFactor,
|
||||
alphaMode: alphaMode,
|
||||
doubleSided: doubleSided,
|
||||
};
|
||||
}
|
||||
|
||||
@ -664,8 +914,17 @@ function createMetallicRoughnessMaterial(material, options) {
|
||||
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);
|
||||
const metallicRoughnessTexture = createMetallicRoughnessTexture(
|
||||
metallicTexture,
|
||||
roughnessTexture,
|
||||
occlusionTexture,
|
||||
options
|
||||
);
|
||||
const diffuseAlphaTexture = createDiffuseAlphaTexture(
|
||||
baseColorTexture,
|
||||
alphaTexture,
|
||||
options
|
||||
);
|
||||
|
||||
if (options.packOcclusion) {
|
||||
occlusionTexture = metallicRoughnessTexture;
|
||||
@ -706,23 +965,23 @@ function createMetallicRoughnessMaterial(material, options) {
|
||||
}
|
||||
|
||||
const doubleSided = transparent;
|
||||
const alphaMode = transparent ? 'BLEND' : 'OPAQUE';
|
||||
const alphaMode = transparent ? "BLEND" : "OPAQUE";
|
||||
|
||||
return {
|
||||
name : material.name,
|
||||
pbrMetallicRoughness : {
|
||||
baseColorTexture : diffuseAlphaTexture,
|
||||
metallicRoughnessTexture : metallicRoughnessTexture,
|
||||
baseColorFactor : baseColorFactor,
|
||||
metallicFactor : metallicFactor,
|
||||
roughnessFactor : roughnessFactor
|
||||
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
|
||||
emissiveTexture: emissiveTexture,
|
||||
normalTexture: normalTexture,
|
||||
occlusionTexture: occlusionTexture,
|
||||
emissiveFactor: emissiveFactor,
|
||||
alphaMode: alphaMode,
|
||||
doubleSided: doubleSided,
|
||||
};
|
||||
}
|
||||
|
||||
@ -745,11 +1004,16 @@ function convertTraditionalToMetallicRoughness(material) {
|
||||
|
||||
// Low specular intensity values should produce a rough material even if shininess is high.
|
||||
if (specularIntensity < 0.1) {
|
||||
roughnessFactor *= (1.0 - specularIntensity);
|
||||
roughnessFactor *= 1.0 - specularIntensity;
|
||||
}
|
||||
|
||||
const metallicFactor = 0.0;
|
||||
|
||||
material.specularColor = [metallicFactor, metallicFactor, metallicFactor, 1.0];
|
||||
material.specularColor = [
|
||||
metallicFactor,
|
||||
metallicFactor,
|
||||
metallicFactor,
|
||||
1.0,
|
||||
];
|
||||
material.specularShininess = roughnessFactor;
|
||||
}
|
||||
|
||||
255
lib/loadObj.js
255
lib/loadObj.js
@ -1,12 +1,12 @@
|
||||
'use strict';
|
||||
const Cesium = require('cesium');
|
||||
const path = require('path');
|
||||
const Promise = require('bluebird');
|
||||
"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 ArrayStorage = require("./ArrayStorage");
|
||||
const loadMtl = require("./loadMtl");
|
||||
const outsideDirectory = require("./outsideDirectory");
|
||||
const readLines = require("./readLines");
|
||||
|
||||
const Axis = Cesium.Axis;
|
||||
const Cartesian3 = Cesium.Cartesian3;
|
||||
@ -44,8 +44,10 @@ function Primitive() {
|
||||
}
|
||||
|
||||
// OBJ regex patterns are modified from ThreeJS (https://github.com/mrdoob/three.js/blob/master/examples/js/loaders/OBJLoader.js)
|
||||
const vertexPattern = /v( +[\d|\.|\+|\-|e|E]+)( +[\d|\.|\+|\-|e|E]+)( +[\d|\.|\+|\-|e|E]+)/; // v float float float
|
||||
const normalPattern = /vn( +[\d|\.|\+|\-|e|E]+)( +[\d|\.|\+|\-|e|E]+)( +[\d|\.|\+|\-|e|E]+)/; // vn float float float
|
||||
const vertexPattern =
|
||||
/v( +[\d|\.|\+|\-|e|E]+)( +[\d|\.|\+|\-|e|E]+)( +[\d|\.|\+|\-|e|E]+)/; // v float float float
|
||||
const normalPattern =
|
||||
/vn( +[\d|\.|\+|\-|e|E]+)( +[\d|\.|\+|\-|e|E]+)( +[\d|\.|\+|\-|e|E]+)/; // vn float float float
|
||||
const uvPattern = /vt( +[\d|\.|\+|\-|e|E]+)( +[\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"
|
||||
|
||||
@ -61,7 +63,10 @@ const scratchCartesian = new Cartesian3();
|
||||
* @private
|
||||
*/
|
||||
function loadObj(objPath, options) {
|
||||
const axisTransform = getAxisTransform(options.inputUpAxis, options.outputUpAxis);
|
||||
const axisTransform = getAxisTransform(
|
||||
options.inputUpAxis,
|
||||
options.outputUpAxis
|
||||
);
|
||||
|
||||
// Global store of vertex attributes listed in the obj file
|
||||
let globalPositions = new ArrayStorage(ComponentDatatype.FLOAT);
|
||||
@ -87,7 +92,7 @@ function loadObj(objPath, options) {
|
||||
let mtlPaths = [];
|
||||
|
||||
// Buffers for face data that spans multiple lines
|
||||
let lineBuffer = '';
|
||||
let lineBuffer = "";
|
||||
|
||||
// Used for parsing face data
|
||||
const faceVertices = [];
|
||||
@ -101,7 +106,7 @@ function loadObj(objPath, options) {
|
||||
}
|
||||
|
||||
function getName(name) {
|
||||
return (name === '' ? undefined : name);
|
||||
return name === "" ? undefined : name;
|
||||
}
|
||||
|
||||
function addNode(name) {
|
||||
@ -154,13 +159,15 @@ function loadObj(objPath, options) {
|
||||
const faceHasNormals = defined(normals[0]);
|
||||
const primitiveHasUvs = primitive.uvs.length > 0;
|
||||
const primitiveHasNormals = primitive.normals.length > 0;
|
||||
return primitiveHasUvs === faceHasUvs && primitiveHasNormals === faceHasNormals;
|
||||
return (
|
||||
primitiveHasUvs === faceHasUvs && primitiveHasNormals === faceHasNormals
|
||||
);
|
||||
}
|
||||
|
||||
function checkPrimitive(uvs, normals) {
|
||||
const firstFace = primitive.indices.length === 0;
|
||||
if (!firstFace && !faceAndPrimitiveMatch(uvs, normals, primitive)) {
|
||||
reusePrimitive(function(primitive) {
|
||||
reusePrimitive(function (primitive) {
|
||||
return faceAndPrimitiveMatch(uvs, normals, primitive);
|
||||
});
|
||||
}
|
||||
@ -170,18 +177,26 @@ function loadObj(objPath, options) {
|
||||
const i = parseInt(index);
|
||||
if (i < 0) {
|
||||
// Negative vertex indexes reference the vertices immediately above it
|
||||
return (attributeData.length / components + i);
|
||||
return attributeData.length / components + i;
|
||||
}
|
||||
return i - 1;
|
||||
}
|
||||
|
||||
function correctAttributeIndices(attributeIndices, attributeData, components) {
|
||||
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);
|
||||
attributeIndices[i] = getIndexFromStart(
|
||||
attributeIndices[i],
|
||||
attributeData,
|
||||
components
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -189,13 +204,18 @@ function loadObj(objPath, options) {
|
||||
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], '');
|
||||
vertices[i] =
|
||||
defaultValue(positions[i], "") +
|
||||
"/" +
|
||||
defaultValue(uvs[i], "") +
|
||||
"/" +
|
||||
defaultValue(normals[i], "");
|
||||
}
|
||||
}
|
||||
|
||||
function createVertex(p, u, n) {
|
||||
// Positions
|
||||
if (defined(p) && (globalPositions.length > 0)) {
|
||||
if (defined(p) && globalPositions.length > 0) {
|
||||
if (p * 3 >= globalPositions.length) {
|
||||
throw new RuntimeError(`Position index ${p} is out of bounds`);
|
||||
}
|
||||
@ -208,7 +228,7 @@ function loadObj(objPath, options) {
|
||||
}
|
||||
|
||||
// Normals
|
||||
if (defined(n) && (globalNormals.length > 0)) {
|
||||
if (defined(n) && globalNormals.length > 0) {
|
||||
if (n * 3 >= globalNormals.length) {
|
||||
throw new RuntimeError(`Normal index ${n} is out of bounds`);
|
||||
}
|
||||
@ -221,7 +241,7 @@ function loadObj(objPath, options) {
|
||||
}
|
||||
|
||||
// UVs
|
||||
if (defined(u) && (globalUvs.length > 0)) {
|
||||
if (defined(u) && globalUvs.length > 0) {
|
||||
if (u * 2 >= globalUvs.length) {
|
||||
throw new RuntimeError(`UV index ${u} is out of bounds`);
|
||||
}
|
||||
@ -272,11 +292,21 @@ function loadObj(objPath, options) {
|
||||
const scratchAxis1 = new Cartesian3();
|
||||
const scratchAxis2 = new Cartesian3();
|
||||
const scratchNormal = new Cartesian3();
|
||||
const scratchPositions = [new Cartesian3(), new Cartesian3(), new Cartesian3(), new Cartesian3()];
|
||||
const scratchPositions = [
|
||||
new Cartesian3(),
|
||||
new Cartesian3(),
|
||||
new Cartesian3(),
|
||||
new Cartesian3(),
|
||||
];
|
||||
const scratchVertexIndices = [];
|
||||
const scratchPoints = [];
|
||||
|
||||
function checkWindingCorrect(positionIndex1, positionIndex2, positionIndex3, normalIndex) {
|
||||
function checkWindingCorrect(
|
||||
positionIndex1,
|
||||
positionIndex2,
|
||||
positionIndex3,
|
||||
normalIndex
|
||||
) {
|
||||
if (!defined(normalIndex)) {
|
||||
// If no face normal, we have to assume the winding is correct.
|
||||
return true;
|
||||
@ -290,7 +320,7 @@ function loadObj(objPath, options) {
|
||||
const CA = Cartesian3.subtract(C, A, scratch5);
|
||||
const cross = Cartesian3.cross(BA, CA, scratch3);
|
||||
|
||||
return (Cartesian3.dot(normal, cross) >= 0);
|
||||
return Cartesian3.dot(normal, cross) >= 0;
|
||||
}
|
||||
|
||||
function addTriangle(index1, index2, index3, correctWinding) {
|
||||
@ -305,7 +335,13 @@ function loadObj(objPath, options) {
|
||||
}
|
||||
}
|
||||
|
||||
function addFace(vertices, positions, uvs, normals, triangleWindingOrderSanitization) {
|
||||
function addFace(
|
||||
vertices,
|
||||
positions,
|
||||
uvs,
|
||||
normals,
|
||||
triangleWindingOrderSanitization
|
||||
) {
|
||||
correctAttributeIndices(positions, globalPositions, 3);
|
||||
correctAttributeIndices(normals, globalNormals, 3);
|
||||
correctAttributeIndices(uvs, globalUvs, 2);
|
||||
@ -314,12 +350,20 @@ function loadObj(objPath, options) {
|
||||
checkPrimitive(uvs, faceNormals);
|
||||
|
||||
if (vertices.length === 3) {
|
||||
const isWindingCorrect = !triangleWindingOrderSanitization || checkWindingCorrect(positions[0], positions[1], positions[2], normals[0]);
|
||||
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
|
||||
} else {
|
||||
// Triangulate if the face is not a triangle
|
||||
const points = scratchPoints;
|
||||
const vertexIndices = scratchVertexIndices;
|
||||
|
||||
@ -335,17 +379,35 @@ function loadObj(objPath, options) {
|
||||
points.push(getPosition(positions[i], scratchPositions[i]));
|
||||
}
|
||||
|
||||
const validGeometry = CoplanarPolygonGeometryLibrary.computeProjectTo2DArguments(points, scratchCenter, scratchAxis1, scratchAxis2);
|
||||
const validGeometry =
|
||||
CoplanarPolygonGeometryLibrary.computeProjectTo2DArguments(
|
||||
points,
|
||||
scratchCenter,
|
||||
scratchAxis1,
|
||||
scratchAxis2
|
||||
);
|
||||
if (!validGeometry) {
|
||||
return;
|
||||
}
|
||||
const projectPoints = CoplanarPolygonGeometryLibrary.createProjectPointsTo2DFunction(scratchCenter, scratchAxis1, scratchAxis2);
|
||||
const projectPoints =
|
||||
CoplanarPolygonGeometryLibrary.createProjectPointsTo2DFunction(
|
||||
scratchCenter,
|
||||
scratchAxis1,
|
||||
scratchAxis2
|
||||
);
|
||||
const points2D = projectPoints(points);
|
||||
const indices = PolygonPipeline.triangulate(points2D);
|
||||
const isWindingCorrect = PolygonPipeline.computeWindingOrder2D(points2D) !== WindingOrder.CLOCKWISE;
|
||||
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);
|
||||
addTriangle(
|
||||
vertexIndices[indices[i]],
|
||||
vertexIndices[indices[i + 1]],
|
||||
vertexIndices[indices[i + 2]],
|
||||
isWindingCorrect
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -354,7 +416,7 @@ function loadObj(objPath, options) {
|
||||
line = line.trim();
|
||||
let result;
|
||||
|
||||
if ((line.length === 0) || (line.charAt(0) === '#')) {
|
||||
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();
|
||||
@ -379,8 +441,13 @@ function loadObj(objPath, options) {
|
||||
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);
|
||||
} 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 {
|
||||
@ -395,15 +462,16 @@ function loadObj(objPath, options) {
|
||||
} 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
|
||||
} 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);
|
||||
if (line.slice(-1) === "\\") {
|
||||
lineBuffer += line.substring(0, line.length - 1);
|
||||
return;
|
||||
}
|
||||
lineBuffer += line;
|
||||
if (lineBuffer.substring(0, 2) === 'f ') {
|
||||
if (lineBuffer.substring(0, 2) === "f ") {
|
||||
while ((result = facePattern.exec(lineBuffer)) !== null) {
|
||||
faceVertices.push(result[0]);
|
||||
facePositions.push(result[1]);
|
||||
@ -411,7 +479,13 @@ function loadObj(objPath, options) {
|
||||
faceNormals.push(result[3]);
|
||||
}
|
||||
if (faceVertices.length > 2) {
|
||||
addFace(faceVertices, facePositions, faceUvs, faceNormals, options.triangleWindingOrderSanitization);
|
||||
addFace(
|
||||
faceVertices,
|
||||
facePositions,
|
||||
faceUvs,
|
||||
faceNormals,
|
||||
options.triangleWindingOrderSanitization
|
||||
);
|
||||
}
|
||||
|
||||
faceVertices.length = 0;
|
||||
@ -419,7 +493,7 @@ function loadObj(objPath, options) {
|
||||
faceNormals.length = 0;
|
||||
faceUvs.length = 0;
|
||||
}
|
||||
lineBuffer = '';
|
||||
lineBuffer = "";
|
||||
}
|
||||
}
|
||||
|
||||
@ -427,29 +501,34 @@ function loadObj(objPath, options) {
|
||||
addNode();
|
||||
|
||||
// Parse the obj file
|
||||
return readLines(objPath, parseLine)
|
||||
.then(function() {
|
||||
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);
|
||||
return finishLoading(
|
||||
nodes,
|
||||
mtlPaths,
|
||||
objPath,
|
||||
defined(activeMaterial),
|
||||
options
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
function getMtlPaths(mtllibLine) {
|
||||
// Handle paths with spaces. E.g. mtllib my material file.mtl
|
||||
const mtlPaths = [];
|
||||
const splits = mtllibLine.split(' ');
|
||||
const splits = mtllibLine.split(" ");
|
||||
const length = splits.length;
|
||||
let startIndex = 0;
|
||||
for (let i = 0; i < length; ++i) {
|
||||
if (path.extname(splits[i]) !== '.mtl') {
|
||||
if (path.extname(splits[i]) !== ".mtl") {
|
||||
continue;
|
||||
}
|
||||
const mtlPath = splits.slice(startIndex, i + 1).join(' ');
|
||||
const mtlPath = splits.slice(startIndex, i + 1).join(" ");
|
||||
mtlPaths.push(mtlPath);
|
||||
startIndex = i + 1;
|
||||
}
|
||||
@ -459,25 +538,24 @@ function getMtlPaths(mtllibLine) {
|
||||
function finishLoading(nodes, mtlPaths, objPath, usesMaterials, options) {
|
||||
nodes = cleanNodes(nodes);
|
||||
if (nodes.length === 0) {
|
||||
throw new RuntimeError(objPath + ' does not have any geometry data');
|
||||
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) {
|
||||
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
|
||||
nodes: nodes,
|
||||
materials: materials,
|
||||
name: name,
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
function normalizeMtlPath(mtlPath, objDirectory) {
|
||||
mtlPath = mtlPath.replace(/\\/g, '/');
|
||||
mtlPath = mtlPath.replace(/\\/g, "/");
|
||||
return path.normalize(path.resolve(objDirectory, mtlPath));
|
||||
}
|
||||
|
||||
@ -486,42 +564,59 @@ function loadMtls(mtlPaths, objPath, options) {
|
||||
let materials = [];
|
||||
|
||||
// Remove duplicates
|
||||
mtlPaths = mtlPaths.filter(function(value, index, self) {
|
||||
mtlPaths = mtlPaths.filter(function (value, index, self) {
|
||||
return self.indexOf(value) === index;
|
||||
});
|
||||
|
||||
return Promise.map(mtlPaths, function(mtlPath) {
|
||||
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.');
|
||||
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) {
|
||||
.then(function (materialsInMtl) {
|
||||
materials = materials.concat(materialsInMtl);
|
||||
})
|
||||
.catch(function(error) {
|
||||
.catch(function (error) {
|
||||
options.logger(error.message);
|
||||
options.logger('Could not read material file at ' + shallowPath + '. Using default material instead.');
|
||||
options.logger(
|
||||
"Could not read material file at " +
|
||||
shallowPath +
|
||||
". Using default material instead."
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
return loadMtl(mtlPath, options)
|
||||
.catch(function(error) {
|
||||
.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.');
|
||||
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) {
|
||||
.then(function (materialsInMtl) {
|
||||
materials = materials.concat(materialsInMtl);
|
||||
})
|
||||
.catch(function(error) {
|
||||
.catch(function (error) {
|
||||
options.logger(error.message);
|
||||
options.logger('Could not read material file at ' + shallowPath + '. Using default material instead.');
|
||||
options.logger(
|
||||
"Could not read material file at " +
|
||||
shallowPath +
|
||||
". Using default material instead."
|
||||
);
|
||||
});
|
||||
}, {concurrency : 10})
|
||||
.then(function() {
|
||||
},
|
||||
{ concurrency: 10 }
|
||||
).then(function () {
|
||||
return materials;
|
||||
});
|
||||
}
|
||||
@ -546,7 +641,7 @@ function assignDefaultMaterial(nodes, materials) {
|
||||
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) {
|
||||
const unnamedMaterial = materials.find(function (material) {
|
||||
return material.name.length === 0;
|
||||
});
|
||||
|
||||
@ -572,13 +667,13 @@ function assignUnnamedMaterial(nodes, materials) {
|
||||
}
|
||||
|
||||
function removeEmptyMeshes(meshes) {
|
||||
return meshes.filter(function(mesh) {
|
||||
return meshes.filter(function (mesh) {
|
||||
// Remove empty primitives
|
||||
mesh.primitives = mesh.primitives.filter(function(primitive) {
|
||||
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);
|
||||
return mesh.primitives.length > 0;
|
||||
});
|
||||
}
|
||||
|
||||
@ -627,7 +722,7 @@ function setDefaultNames(items, defaultName, usedNames) {
|
||||
const occurrences = usedNames[name];
|
||||
if (defined(occurrences)) {
|
||||
usedNames[name]++;
|
||||
name = name + '_' + occurrences;
|
||||
name = name + "_" + occurrences;
|
||||
} else {
|
||||
usedNames[name] = 1;
|
||||
}
|
||||
@ -637,11 +732,11 @@ function setDefaultNames(items, defaultName, usedNames) {
|
||||
|
||||
function setDefaults(nodes) {
|
||||
const usedNames = {};
|
||||
setDefaultNames(nodes, 'Node', 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);
|
||||
setDefaultNames(node.meshes, node.name + "-Mesh", usedNames);
|
||||
}
|
||||
}
|
||||
|
||||
@ -652,17 +747,17 @@ function cleanNodes(nodes) {
|
||||
}
|
||||
|
||||
function getAxisTransform(inputUpAxis, outputUpAxis) {
|
||||
if (inputUpAxis === 'X' && outputUpAxis === 'Y') {
|
||||
if (inputUpAxis === "X" && outputUpAxis === "Y") {
|
||||
return Axis.X_UP_TO_Y_UP;
|
||||
} else if (inputUpAxis === 'X' && outputUpAxis === 'Z') {
|
||||
} else if (inputUpAxis === "X" && outputUpAxis === "Z") {
|
||||
return Axis.X_UP_TO_Z_UP;
|
||||
} else if (inputUpAxis === 'Y' && outputUpAxis === 'X') {
|
||||
} else if (inputUpAxis === "Y" && outputUpAxis === "X") {
|
||||
return Axis.Y_UP_TO_X_UP;
|
||||
} else if (inputUpAxis === 'Y' && outputUpAxis === 'Z') {
|
||||
} else if (inputUpAxis === "Y" && outputUpAxis === "Z") {
|
||||
return Axis.Y_UP_TO_Z_UP;
|
||||
} else if (inputUpAxis === 'Z' && outputUpAxis === 'X') {
|
||||
} else if (inputUpAxis === "Z" && outputUpAxis === "X") {
|
||||
return Axis.Z_UP_TO_X_UP;
|
||||
} else if (inputUpAxis === 'Z' && outputUpAxis === 'Y') {
|
||||
} else if (inputUpAxis === "Z" && outputUpAxis === "Y") {
|
||||
return Axis.Z_UP_TO_Y_UP;
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,11 +1,11 @@
|
||||
'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');
|
||||
"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 = Cesium.defaultValue;
|
||||
const defined = Cesium.defined;
|
||||
@ -30,8 +30,7 @@ function loadTexture(texturePath, options) {
|
||||
options.decode = defaultValue(options.decode, false);
|
||||
options.keepSource = defaultValue(options.keepSource, false);
|
||||
|
||||
return fsExtra.readFile(texturePath)
|
||||
.then(function(source) {
|
||||
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();
|
||||
@ -41,15 +40,14 @@ function loadTexture(texturePath, options) {
|
||||
texture.path = texturePath;
|
||||
|
||||
let decodePromise;
|
||||
if (extension === '.png') {
|
||||
if (extension === ".png") {
|
||||
decodePromise = decodePng(texture, options);
|
||||
} else if (extension === '.jpg' || extension === '.jpeg') {
|
||||
} else if (extension === ".jpg" || extension === ".jpeg") {
|
||||
decodePromise = decodeJpeg(texture, options);
|
||||
}
|
||||
|
||||
if (defined(decodePromise)) {
|
||||
return decodePromise
|
||||
.then(function() {
|
||||
return decodePromise.then(function () {
|
||||
return texture;
|
||||
});
|
||||
}
|
||||
@ -84,8 +82,8 @@ function getChannels(colorType) {
|
||||
}
|
||||
|
||||
function parsePng(data) {
|
||||
return new Promise(function(resolve, reject) {
|
||||
new PNG().parse(data, function(error, decodedResults) {
|
||||
return new Promise(function (resolve, reject) {
|
||||
new PNG().parse(data, function (error, decodedResults) {
|
||||
if (defined(error)) {
|
||||
reject(error);
|
||||
return;
|
||||
@ -101,12 +99,11 @@ function decodePng(texture, options) {
|
||||
const colorType = source[25];
|
||||
const channels = getChannels(colorType);
|
||||
|
||||
const checkTransparency = (channels === 4 && options.checkTransparency);
|
||||
const checkTransparency = channels === 4 && options.checkTransparency;
|
||||
const decode = options.decode || checkTransparency;
|
||||
|
||||
if (decode) {
|
||||
return parsePng(source)
|
||||
.then(function(decodedResults) {
|
||||
return parsePng(source).then(function (decodedResults) {
|
||||
if (options.checkTransparency) {
|
||||
texture.transparent = hasTransparency(decodedResults.data);
|
||||
}
|
||||
|
||||
114
lib/obj2gltf.js
114
lib/obj2gltf.js
@ -1,10 +1,10 @@
|
||||
'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');
|
||||
"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 = Cesium.defaultValue;
|
||||
const defined = Cesium.defined;
|
||||
@ -47,34 +47,72 @@ function obj2gltf(objPath, options) {
|
||||
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.separateTextures =
|
||||
defaultValue(options.separateTextures, defaults.separateTextures) ||
|
||||
options.separate;
|
||||
options.checkTransparency = defaultValue(
|
||||
options.checkTransparency,
|
||||
defaults.checkTransparency
|
||||
);
|
||||
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.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, defaultValue.EMPTY_OBJECT);
|
||||
options.overridingTextures = defaultValue(
|
||||
options.overridingTextures,
|
||||
defaultValue.EMPTY_OBJECT
|
||||
);
|
||||
options.logger = defaultValue(options.logger, getDefaultLogger());
|
||||
options.writer = defaultValue(options.writer, getDefaultWriter(options.outputDirectory));
|
||||
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);
|
||||
options.outputUpAxis = defaultValue(
|
||||
options.outputUpAxis,
|
||||
defaults.outputUpAxis
|
||||
);
|
||||
options.triangleWindingOrderSanitization = defaultValue(
|
||||
options.triangleWindingOrderSanitization,
|
||||
defaults.triangleWindingOrderSanitization
|
||||
);
|
||||
|
||||
if (!defined(objPath)) {
|
||||
throw new DeveloperError('objPath is required');
|
||||
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.');
|
||||
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 (
|
||||
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) &&
|
||||
defined(options.overridingTextures.specularGlossinessTexture)
|
||||
) {
|
||||
throw new DeveloperError(
|
||||
"metallicRoughnessOcclusionTexture and specularGlossinessTexture cannot both be defined."
|
||||
);
|
||||
}
|
||||
|
||||
if (defined(options.overridingTextures.metallicRoughnessOcclusionTexture)) {
|
||||
@ -89,23 +127,23 @@ function obj2gltf(objPath, options) {
|
||||
}
|
||||
|
||||
return loadObj(objPath, options)
|
||||
.then(function(objData) {
|
||||
.then(function (objData) {
|
||||
return createGltf(objData, options);
|
||||
})
|
||||
.then(function(gltf) {
|
||||
.then(function (gltf) {
|
||||
return writeGltf(gltf, options);
|
||||
});
|
||||
}
|
||||
|
||||
function getDefaultLogger() {
|
||||
return function(message) {
|
||||
return function (message) {
|
||||
console.log(message);
|
||||
};
|
||||
}
|
||||
|
||||
function getDefaultWriter(outputDirectory) {
|
||||
if (defined(outputDirectory)) {
|
||||
return function(file, data) {
|
||||
return function (file, data) {
|
||||
const outputFile = path.join(outputDirectory, file);
|
||||
return fsExtra.outputFile(outputFile, data);
|
||||
};
|
||||
@ -121,74 +159,74 @@ obj2gltf.defaults = {
|
||||
* @type Boolean
|
||||
* @default false
|
||||
*/
|
||||
binary : 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,
|
||||
separate: false,
|
||||
/**
|
||||
* Gets or sets whether to write out separate textures only.
|
||||
* @type Boolean
|
||||
* @default false
|
||||
*/
|
||||
separateTextures : 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,
|
||||
checkTransparency: false,
|
||||
/**
|
||||
* Gets or sets whether the source model can reference paths outside of its directory.
|
||||
* @type Boolean
|
||||
* @default false
|
||||
*/
|
||||
secure : 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,
|
||||
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,
|
||||
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,
|
||||
specularGlossiness: false,
|
||||
/**
|
||||
* Gets or sets whether the glTF will be saved with the KHR_materials_unlit extension.
|
||||
* @type Boolean
|
||||
* @default false
|
||||
*/
|
||||
unlit : false,
|
||||
unlit: false,
|
||||
/**
|
||||
* Gets or sets the up axis of the obj.
|
||||
* @type String
|
||||
* @default 'Y'
|
||||
*/
|
||||
inputUpAxis: 'Y',
|
||||
inputUpAxis: "Y",
|
||||
/**
|
||||
* Gets or sets the up axis of the converted glTF.
|
||||
* @type String
|
||||
* @default 'Y'
|
||||
*/
|
||||
outputUpAxis: 'Y',
|
||||
outputUpAxis: "Y",
|
||||
/**
|
||||
* Gets or sets whether triangle winding order sanitization will be applied.
|
||||
* @type Boolean
|
||||
* @default false
|
||||
*/
|
||||
windingOrderSanitization : false
|
||||
windingOrderSanitization: false,
|
||||
};
|
||||
|
||||
/**
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
'use strict';
|
||||
const path = require('path');
|
||||
"use strict";
|
||||
const path = require("path");
|
||||
|
||||
module.exports = outsideDirectory;
|
||||
|
||||
@ -13,5 +13,5 @@ module.exports = outsideDirectory;
|
||||
* @private
|
||||
*/
|
||||
function outsideDirectory(file, directory) {
|
||||
return (path.relative(directory, file).indexOf('..') === 0);
|
||||
return path.relative(directory, file).indexOf("..") === 0;
|
||||
}
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
'use strict';
|
||||
const fsExtra = require('fs-extra');
|
||||
const Promise = require('bluebird');
|
||||
const readline = require('readline');
|
||||
"use strict";
|
||||
const fsExtra = require("fs-extra");
|
||||
const Promise = require("bluebird");
|
||||
const readline = require("readline");
|
||||
|
||||
module.exports = readLines;
|
||||
|
||||
@ -15,16 +15,16 @@ module.exports = readLines;
|
||||
* @private
|
||||
*/
|
||||
function readLines(path, callback) {
|
||||
return new Promise(function(resolve, reject) {
|
||||
return new Promise(function (resolve, reject) {
|
||||
const stream = fsExtra.createReadStream(path);
|
||||
stream.on('error', reject);
|
||||
stream.on('end', resolve);
|
||||
stream.on("error", reject);
|
||||
stream.on("end", resolve);
|
||||
|
||||
const lineReader = readline.createInterface({
|
||||
input : stream
|
||||
input: stream,
|
||||
});
|
||||
|
||||
const callbackWrapper = function(line) {
|
||||
const callbackWrapper = function (line) {
|
||||
try {
|
||||
callback(line);
|
||||
} catch (error) {
|
||||
@ -32,6 +32,6 @@ function readLines(path, callback) {
|
||||
}
|
||||
};
|
||||
|
||||
lineReader.on('line', callbackWrapper);
|
||||
lineReader.on("line", callbackWrapper);
|
||||
});
|
||||
}
|
||||
|
||||
@ -1,10 +1,10 @@
|
||||
'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');
|
||||
"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;
|
||||
@ -21,8 +21,7 @@ module.exports = writeGltf;
|
||||
* @private
|
||||
*/
|
||||
function writeGltf(gltf, options) {
|
||||
return encodeTextures(gltf)
|
||||
.then(function() {
|
||||
return encodeTextures(gltf).then(function () {
|
||||
const binary = options.binary;
|
||||
const separate = options.separate;
|
||||
const separateTextures = options.separateTextures;
|
||||
@ -42,8 +41,7 @@ function writeGltf(gltf, options) {
|
||||
|
||||
const binaryBuffer = gltf.buffers[0].extras._obj2gltf.source;
|
||||
|
||||
return Promise.all(promises)
|
||||
.then(function() {
|
||||
return Promise.all(promises).then(function () {
|
||||
deleteExtras(gltf);
|
||||
removeEmpty(gltf);
|
||||
if (binary) {
|
||||
@ -60,32 +58,35 @@ function encodePng(texture) {
|
||||
const rgbaColorType = 6;
|
||||
|
||||
const png = new PNG({
|
||||
width : texture.width,
|
||||
height : texture.height,
|
||||
colorType : texture.transparent ? rgbaColorType : rgbColorType,
|
||||
inputColorType : rgbaColorType,
|
||||
inputHasAlpha : true
|
||||
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) {
|
||||
return new Promise(function (resolve, reject) {
|
||||
const chunks = [];
|
||||
const stream = png.pack();
|
||||
stream.on('data', function(chunk) {
|
||||
stream.on("data", function (chunk) {
|
||||
chunks.push(chunk);
|
||||
});
|
||||
stream.on('end', function() {
|
||||
stream.on("end", function () {
|
||||
resolve(Buffer.concat(chunks));
|
||||
});
|
||||
stream.on('error', reject);
|
||||
stream.on("error", reject);
|
||||
});
|
||||
}
|
||||
|
||||
function encodeTexture(texture) {
|
||||
if (!defined(texture.source) && defined(texture.pixels) && texture.extension === '.png') {
|
||||
return encodePng(texture)
|
||||
.then(function(encoded) {
|
||||
if (
|
||||
!defined(texture.source) &&
|
||||
defined(texture.pixels) &&
|
||||
texture.extension === ".png"
|
||||
) {
|
||||
return encodePng(texture).then(function (encoded) {
|
||||
texture.source = encoded;
|
||||
});
|
||||
}
|
||||
@ -117,10 +118,13 @@ function deleteExtras(gltf) {
|
||||
}
|
||||
|
||||
function removeEmpty(json) {
|
||||
Object.keys(json).forEach(function(key) {
|
||||
if (!defined(json[key]) || (Array.isArray(json[key]) && json[key].length === 0)) {
|
||||
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') {
|
||||
} else if (typeof json[key] === "object") {
|
||||
removeEmpty(json[key]);
|
||||
}
|
||||
});
|
||||
@ -128,22 +132,30 @@ function removeEmpty(json) {
|
||||
|
||||
function writeSeparateBuffers(gltf, options) {
|
||||
const buffers = gltf.buffers;
|
||||
return Promise.map(buffers, function(buffer) {
|
||||
return Promise.map(
|
||||
buffers,
|
||||
function (buffer) {
|
||||
const source = buffer.extras._obj2gltf.source;
|
||||
const bufferUri = buffer.name + '.bin';
|
||||
const bufferUri = buffer.name + ".bin";
|
||||
buffer.uri = bufferUri;
|
||||
return options.writer(bufferUri, source);
|
||||
}, {concurrency : 10});
|
||||
},
|
||||
{ concurrency: 10 }
|
||||
);
|
||||
}
|
||||
|
||||
function writeSeparateTextures(gltf, options) {
|
||||
const images = gltf.images;
|
||||
return Promise.map(images, function(image) {
|
||||
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});
|
||||
},
|
||||
{ concurrency: 10 }
|
||||
);
|
||||
}
|
||||
|
||||
function writeEmbeddedBuffer(gltf) {
|
||||
@ -152,10 +164,13 @@ function writeEmbeddedBuffer(gltf) {
|
||||
|
||||
// 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.');
|
||||
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');
|
||||
buffer.uri =
|
||||
"data:application/octet-stream;base64," + source.toString("base64");
|
||||
}
|
||||
|
||||
function writeEmbeddedTextures(gltf) {
|
||||
@ -176,9 +191,9 @@ function writeEmbeddedTextures(gltf) {
|
||||
image.mimeType = mime.getType(texture.extension);
|
||||
image.bufferView = gltf.bufferViews.length;
|
||||
gltf.bufferViews.push({
|
||||
buffer : 0,
|
||||
byteOffset : byteOffset,
|
||||
byteLength : textureByteLength
|
||||
buffer: 0,
|
||||
byteOffset: byteOffset,
|
||||
byteLength: textureByteLength,
|
||||
});
|
||||
byteOffset += textureByteLength;
|
||||
sources.push(textureSource);
|
||||
|
||||
@ -1,23 +1,26 @@
|
||||
'use strict';
|
||||
const Cesium = require('cesium');
|
||||
const obj2gltf = require('../../lib/obj2gltf');
|
||||
const createGltf = require('../../lib/createGltf');
|
||||
const loadObj = require('../../lib/loadObj');
|
||||
const { getDefaultMaterial } = require('../../lib/loadMtl');
|
||||
"use strict";
|
||||
const Cesium = require("cesium");
|
||||
const obj2gltf = require("../../lib/obj2gltf");
|
||||
const createGltf = require("../../lib/createGltf");
|
||||
const loadObj = require("../../lib/loadObj");
|
||||
const { getDefaultMaterial } = require("../../lib/loadMtl");
|
||||
|
||||
const clone = Cesium.clone;
|
||||
const defined = Cesium.defined;
|
||||
const WebGLConstants = Cesium.WebGLConstants;
|
||||
|
||||
const boxObjPath = 'specs/data/box/box.obj';
|
||||
const groupObjPath = 'specs/data/box-objects-groups-materials/box-objects-groups-materials.obj';
|
||||
const complexObjPath = 'specs/data/box-complex-material/box-complex-material.obj';
|
||||
const noMaterialsObjPath = 'specs/data/box-no-materials/box-no-materials.obj';
|
||||
const mixedAttributesObjPath = 'specs/data/box-mixed-attributes-2/box-mixed-attributes-2.obj';
|
||||
const boxObjPath = "specs/data/box/box.obj";
|
||||
const groupObjPath =
|
||||
"specs/data/box-objects-groups-materials/box-objects-groups-materials.obj";
|
||||
const complexObjPath =
|
||||
"specs/data/box-complex-material/box-complex-material.obj";
|
||||
const noMaterialsObjPath = "specs/data/box-no-materials/box-no-materials.obj";
|
||||
const mixedAttributesObjPath =
|
||||
"specs/data/box-mixed-attributes-2/box-mixed-attributes-2.obj";
|
||||
|
||||
let options;
|
||||
|
||||
describe('createGltf', () => {
|
||||
describe("createGltf", () => {
|
||||
let boxObjData;
|
||||
let groupObjData;
|
||||
let complexObjData;
|
||||
@ -36,7 +39,7 @@ describe('createGltf', () => {
|
||||
mixedAttributesObjData = await loadObj(mixedAttributesObjPath, options);
|
||||
});
|
||||
|
||||
it('simple gltf', () => {
|
||||
it("simple gltf", () => {
|
||||
const gltf = createGltf(boxObjData, options);
|
||||
|
||||
expect(gltf.materials.length).toBe(1);
|
||||
@ -60,8 +63,8 @@ describe('createGltf', () => {
|
||||
expect(indexAccessor.count).toBe(36);
|
||||
});
|
||||
|
||||
it('does not combine buffers when that buffer would exceed the Node buffer size limit', () => {
|
||||
spyOn(createGltf, '_getBufferMaxByteLength').and.returnValue(0);
|
||||
it("does not combine buffers when that buffer would exceed the Node buffer size limit", () => {
|
||||
spyOn(createGltf, "_getBufferMaxByteLength").and.returnValue(0);
|
||||
const clonedOptions = clone(options, true);
|
||||
clonedOptions.separate = true;
|
||||
|
||||
@ -83,7 +86,7 @@ describe('createGltf', () => {
|
||||
}
|
||||
});
|
||||
|
||||
it('multiple nodes, meshes, and primitives', () => {
|
||||
it("multiple nodes, meshes, and primitives", () => {
|
||||
const gltf = createGltf(groupObjData, options);
|
||||
|
||||
expect(gltf.materials.length).toBe(3);
|
||||
@ -102,22 +105,32 @@ describe('createGltf', () => {
|
||||
}
|
||||
});
|
||||
|
||||
it('multiple textures', () => {
|
||||
it("multiple textures", () => {
|
||||
const gltf = createGltf(complexObjData, options);
|
||||
const material = gltf.materials[0];
|
||||
const pbr = material.pbrMetallicRoughness;
|
||||
const textures = [pbr.metallicRoughnessTexture, pbr.baseColorTexture, material.emissiveTexture, material.normalTexture, material.occlusionTexture];
|
||||
expect(textures.map((texture) => {
|
||||
const textures = [
|
||||
pbr.metallicRoughnessTexture,
|
||||
pbr.baseColorTexture,
|
||||
material.emissiveTexture,
|
||||
material.normalTexture,
|
||||
material.occlusionTexture,
|
||||
];
|
||||
expect(
|
||||
textures
|
||||
.map((texture) => {
|
||||
return texture.index;
|
||||
}).sort()).toEqual([0, 1, 2, 3, 4]);
|
||||
})
|
||||
.sort()
|
||||
).toEqual([0, 1, 2, 3, 4]);
|
||||
expect(gltf.samplers[0]).toBeDefined();
|
||||
});
|
||||
|
||||
it('creates default material', () => {
|
||||
it("creates default material", () => {
|
||||
const gltf = createGltf(noMaterialsObjData, options);
|
||||
const material = gltf.materials[0];
|
||||
const pbr = material.pbrMetallicRoughness;
|
||||
expect(material.name).toBe('default');
|
||||
expect(material.name).toBe("default");
|
||||
expect(pbr.baseColorTexture).toBeUndefined();
|
||||
expect(pbr.metallicRoughnessTexture).toBeUndefined();
|
||||
expect(pbr.baseColorFactor).toEqual([0.5, 0.5, 0.5, 1.0]);
|
||||
@ -127,25 +140,29 @@ describe('createGltf', () => {
|
||||
expect(material.normalTexture).toBeUndefined();
|
||||
expect(material.ambientTexture).toBeUndefined();
|
||||
expect(material.emissiveFactor).toEqual([0.0, 0.0, 0.0]);
|
||||
expect(material.alphaMode).toBe('OPAQUE');
|
||||
expect(material.alphaMode).toBe("OPAQUE");
|
||||
expect(material.doubleSided).toBe(false);
|
||||
});
|
||||
|
||||
it('adds KHR_materials_pbrSpecularGlossiness extension when specularGlossiness is set', () => {
|
||||
it("adds KHR_materials_pbrSpecularGlossiness extension when specularGlossiness is set", () => {
|
||||
options.specularGlossiness = true;
|
||||
const gltf = createGltf(noMaterialsObjData, options);
|
||||
expect(gltf.extensionsUsed).toEqual(['KHR_materials_pbrSpecularGlossiness']);
|
||||
expect(gltf.extensionsRequired).toEqual(['KHR_materials_pbrSpecularGlossiness']);
|
||||
expect(gltf.extensionsUsed).toEqual([
|
||||
"KHR_materials_pbrSpecularGlossiness",
|
||||
]);
|
||||
expect(gltf.extensionsRequired).toEqual([
|
||||
"KHR_materials_pbrSpecularGlossiness",
|
||||
]);
|
||||
});
|
||||
|
||||
it('adds KHR_materials_unlit extension when unlit is set', () => {
|
||||
it("adds KHR_materials_unlit extension when unlit is set", () => {
|
||||
options.unlit = true;
|
||||
const gltf = createGltf(noMaterialsObjData, options);
|
||||
expect(gltf.extensionsUsed).toEqual(['KHR_materials_unlit']);
|
||||
expect(gltf.extensionsRequired).toEqual(['KHR_materials_unlit']);
|
||||
expect(gltf.extensionsUsed).toEqual(["KHR_materials_unlit"]);
|
||||
expect(gltf.extensionsRequired).toEqual(["KHR_materials_unlit"]);
|
||||
});
|
||||
|
||||
it('runs without normals', () => {
|
||||
it("runs without normals", () => {
|
||||
boxObjData.nodes[0].meshes[0].primitives[0].normals.length = 0;
|
||||
|
||||
const gltf = createGltf(boxObjData, options);
|
||||
@ -155,7 +172,7 @@ describe('createGltf', () => {
|
||||
expect(attributes.TEXCOORD_0).toBeDefined();
|
||||
});
|
||||
|
||||
it('runs without uvs', () => {
|
||||
it("runs without uvs", () => {
|
||||
boxObjData.nodes[0].meshes[0].primitives[0].uvs.length = 0;
|
||||
|
||||
const gltf = createGltf(boxObjData, options);
|
||||
@ -165,7 +182,7 @@ describe('createGltf', () => {
|
||||
expect(attributes.TEXCOORD_0).toBeUndefined();
|
||||
});
|
||||
|
||||
it('runs without uvs and normals', () => {
|
||||
it("runs without uvs and normals", () => {
|
||||
boxObjData.nodes[0].meshes[0].primitives[0].normals.length = 0;
|
||||
boxObjData.nodes[0].meshes[0].primitives[0].uvs.length = 0;
|
||||
|
||||
@ -176,7 +193,7 @@ describe('createGltf', () => {
|
||||
expect(attributes.TEXCOORD_0).toBeUndefined();
|
||||
});
|
||||
|
||||
it('splits incompatible materials', () => {
|
||||
it("splits incompatible materials", () => {
|
||||
const gltf = createGltf(mixedAttributesObjData, options);
|
||||
const materials = gltf.materials;
|
||||
const meshes = gltf.meshes;
|
||||
@ -184,11 +201,12 @@ describe('createGltf', () => {
|
||||
const referenceMaterial = mixedAttributesObjData.materials[0];
|
||||
delete referenceMaterial.name;
|
||||
referenceMaterial.pbrMetallicRoughness.baseColorTexture = {
|
||||
index : 0
|
||||
index: 0,
|
||||
};
|
||||
|
||||
const referenceMaterialNoTextures = clone(referenceMaterial, true);
|
||||
referenceMaterialNoTextures.pbrMetallicRoughness.baseColorTexture = undefined;
|
||||
referenceMaterialNoTextures.pbrMetallicRoughness.baseColorTexture =
|
||||
undefined;
|
||||
|
||||
const defaultMaterial = getDefaultMaterial(options);
|
||||
delete defaultMaterial.name;
|
||||
@ -204,15 +222,15 @@ describe('createGltf', () => {
|
||||
// * positions/normals
|
||||
// * positions/uvs
|
||||
expect(materialNames).toEqual([
|
||||
'default',
|
||||
'default-2',
|
||||
'default-3',
|
||||
'Material',
|
||||
'Material-2',
|
||||
'Material-3',
|
||||
'Missing',
|
||||
'Missing-2',
|
||||
'Missing-3'
|
||||
"default",
|
||||
"default-2",
|
||||
"default-3",
|
||||
"Material",
|
||||
"Material-2",
|
||||
"Material-3",
|
||||
"Missing",
|
||||
"Missing-2",
|
||||
"Missing-3",
|
||||
]);
|
||||
|
||||
expect(materials.length).toBe(9);
|
||||
@ -236,7 +254,9 @@ describe('createGltf', () => {
|
||||
const primitive = primitives[j];
|
||||
const material = materials[primitive.material];
|
||||
if (!defined(primitive.attributes.TEXCOORD_0)) {
|
||||
expect(material.pbrMetallicRoughness.baseColorTexture).toBeUndefined();
|
||||
expect(
|
||||
material.pbrMetallicRoughness.baseColorTexture
|
||||
).toBeUndefined();
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -269,7 +289,7 @@ describe('createGltf', () => {
|
||||
}
|
||||
}
|
||||
|
||||
it('detects need to use uint32 indices', () => {
|
||||
it("detects need to use uint32 indices", () => {
|
||||
expandObjData(boxObjData, 2731); // Right above 65536 limit
|
||||
let primitive = boxObjData.nodes[0].meshes[0].primitives[0];
|
||||
const indicesLength = primitive.indices.length;
|
||||
|
||||
@ -1,31 +1,42 @@
|
||||
'use strict';
|
||||
const Cesium = require('cesium');
|
||||
const fsExtra = require('fs-extra');
|
||||
const loadMtl = require('../../lib/loadMtl');
|
||||
const loadTexture = require('../../lib/loadTexture');
|
||||
const obj2gltf = require('../../lib/obj2gltf');
|
||||
"use strict";
|
||||
const Cesium = require("cesium");
|
||||
const fsExtra = require("fs-extra");
|
||||
const loadMtl = require("../../lib/loadMtl");
|
||||
const loadTexture = require("../../lib/loadTexture");
|
||||
const obj2gltf = require("../../lib/obj2gltf");
|
||||
|
||||
const clone = Cesium.clone;
|
||||
|
||||
const coloredMaterialPath = 'specs/data/box/box.mtl';
|
||||
const texturedMaterialPath = 'specs/data/box-complex-material/box-complex-material.mtl';
|
||||
const texturedWithOptionsMaterialPath = 'specs/data/box-texture-options/box-texture-options.mtl';
|
||||
const multipleMaterialsPath = 'specs/data/box-multiple-materials/box-multiple-materials.mtl';
|
||||
const externalMaterialPath = 'specs/data/box-external-resources/box-external-resources.mtl';
|
||||
const resourcesInRootMaterialPath = 'specs/data/box-resources-in-root/box-resources-in-root.mtl';
|
||||
const externalInRootMaterialPath = 'specs/data/box-external-resources-in-root/box-external-resources-in-root.mtl';
|
||||
const transparentMaterialPath = 'specs/data/box-transparent/box-transparent.mtl';
|
||||
const sharedTexturesMaterialPath = 'specs/data/box-shared-textures/box-shared-textures.mtl';
|
||||
const sharedTexturesMaterial2Path = 'specs/data/box-shared-textures-2/box-shared-textures-2.mtl';
|
||||
const coloredMaterialPath = "specs/data/box/box.mtl";
|
||||
const texturedMaterialPath =
|
||||
"specs/data/box-complex-material/box-complex-material.mtl";
|
||||
const texturedWithOptionsMaterialPath =
|
||||
"specs/data/box-texture-options/box-texture-options.mtl";
|
||||
const multipleMaterialsPath =
|
||||
"specs/data/box-multiple-materials/box-multiple-materials.mtl";
|
||||
const externalMaterialPath =
|
||||
"specs/data/box-external-resources/box-external-resources.mtl";
|
||||
const resourcesInRootMaterialPath =
|
||||
"specs/data/box-resources-in-root/box-resources-in-root.mtl";
|
||||
const externalInRootMaterialPath =
|
||||
"specs/data/box-external-resources-in-root/box-external-resources-in-root.mtl";
|
||||
const transparentMaterialPath =
|
||||
"specs/data/box-transparent/box-transparent.mtl";
|
||||
const sharedTexturesMaterialPath =
|
||||
"specs/data/box-shared-textures/box-shared-textures.mtl";
|
||||
const sharedTexturesMaterial2Path =
|
||||
"specs/data/box-shared-textures-2/box-shared-textures-2.mtl";
|
||||
|
||||
const diffuseTexturePath = 'specs/data/box-textured/cesium.png';
|
||||
const transparentDiffuseTexturePath = 'specs/data/box-complex-material/diffuse.png';
|
||||
const alphaTexturePath = 'specs/data/box-complex-material-alpha/alpha.png';
|
||||
const ambientTexturePath = 'specs/data/box-complex-material/ambient.gif';
|
||||
const normalTexturePath = 'specs/data/box-complex-material/bump.png';
|
||||
const emissiveTexturePath = 'specs/data/box-complex-material/emission.jpg';
|
||||
const specularTexturePath = 'specs/data/box-complex-material/specular.jpeg';
|
||||
const specularShininessTexturePath = 'specs/data/box-complex-material/shininess.png';
|
||||
const diffuseTexturePath = "specs/data/box-textured/cesium.png";
|
||||
const transparentDiffuseTexturePath =
|
||||
"specs/data/box-complex-material/diffuse.png";
|
||||
const alphaTexturePath = "specs/data/box-complex-material-alpha/alpha.png";
|
||||
const ambientTexturePath = "specs/data/box-complex-material/ambient.gif";
|
||||
const normalTexturePath = "specs/data/box-complex-material/bump.png";
|
||||
const emissiveTexturePath = "specs/data/box-complex-material/emission.jpg";
|
||||
const specularTexturePath = "specs/data/box-complex-material/specular.jpeg";
|
||||
const specularShininessTexturePath =
|
||||
"specs/data/box-complex-material/shininess.png";
|
||||
|
||||
let diffuseTexture;
|
||||
let transparentDiffuseTexture;
|
||||
@ -37,24 +48,30 @@ let specularTexture;
|
||||
let specularShininessTexture;
|
||||
|
||||
const checkTransparencyOptions = {
|
||||
checkTransparency : true
|
||||
checkTransparency: true,
|
||||
};
|
||||
const decodeOptions = {
|
||||
decode : true
|
||||
decode: true,
|
||||
};
|
||||
|
||||
let options;
|
||||
|
||||
describe('loadMtl', () => {
|
||||
describe("loadMtl", () => {
|
||||
beforeAll(async () => {
|
||||
diffuseTexture = await loadTexture(diffuseTexturePath, decodeOptions);
|
||||
transparentDiffuseTexture = await loadTexture(transparentDiffuseTexturePath, checkTransparencyOptions);
|
||||
transparentDiffuseTexture = await loadTexture(
|
||||
transparentDiffuseTexturePath,
|
||||
checkTransparencyOptions
|
||||
);
|
||||
alphaTexture = await loadTexture(alphaTexturePath, decodeOptions);
|
||||
ambientTexture = await loadTexture(ambientTexturePath);
|
||||
normalTexture = await loadTexture(normalTexturePath);
|
||||
emissiveTexture = await loadTexture(emissiveTexturePath);
|
||||
specularTexture = await loadTexture(specularTexturePath, decodeOptions);
|
||||
specularShininessTexture = await loadTexture(specularShininessTexturePath, decodeOptions);
|
||||
specularShininessTexture = await loadTexture(
|
||||
specularShininessTexturePath,
|
||||
decodeOptions
|
||||
);
|
||||
});
|
||||
|
||||
beforeEach(() => {
|
||||
@ -63,7 +80,7 @@ describe('loadMtl', () => {
|
||||
options.logger = () => {};
|
||||
});
|
||||
|
||||
it('loads mtl', async () => {
|
||||
it("loads mtl", async () => {
|
||||
options.metallicRoughness = true;
|
||||
const materials = await loadMtl(coloredMaterialPath, options);
|
||||
expect(materials.length).toBe(1);
|
||||
@ -74,16 +91,16 @@ describe('loadMtl', () => {
|
||||
expect(pbr.baseColorFactor).toEqual([0.64, 0.64, 0.64, 1.0]);
|
||||
expect(pbr.metallicFactor).toBe(0.5);
|
||||
expect(pbr.roughnessFactor).toBe(96.078431);
|
||||
expect(material.name).toBe('Material');
|
||||
expect(material.name).toBe("Material");
|
||||
expect(material.emissiveTexture).toBeUndefined();
|
||||
expect(material.normalTexture).toBeUndefined();
|
||||
expect(material.ambientTexture).toBeUndefined();
|
||||
expect(material.emissiveFactor).toEqual([0.0, 0.0, 0.1]);
|
||||
expect(material.alphaMode).toBe('OPAQUE');
|
||||
expect(material.alphaMode).toBe("OPAQUE");
|
||||
expect(material.doubleSided).toBe(false);
|
||||
});
|
||||
|
||||
it('loads mtl with textures', async () => {
|
||||
it("loads mtl with textures", async () => {
|
||||
options.metallicRoughness = true;
|
||||
const materials = await loadMtl(texturedMaterialPath, options);
|
||||
expect(materials.length).toBe(1);
|
||||
@ -94,16 +111,16 @@ describe('loadMtl', () => {
|
||||
expect(pbr.baseColorFactor).toEqual([1.0, 1.0, 1.0, 0.9]);
|
||||
expect(pbr.metallicFactor).toBe(1.0);
|
||||
expect(pbr.roughnessFactor).toBe(1.0);
|
||||
expect(material.name).toBe('Material');
|
||||
expect(material.name).toBe("Material");
|
||||
expect(material.emissiveTexture).toBeDefined();
|
||||
expect(material.normalTexture).toBeDefined();
|
||||
expect(material.occlusionTexture).toBeDefined();
|
||||
expect(material.emissiveFactor).toEqual([1.0, 1.0, 1.0]);
|
||||
expect(material.alphaMode).toBe('BLEND');
|
||||
expect(material.alphaMode).toBe("BLEND");
|
||||
expect(material.doubleSided).toBe(true);
|
||||
});
|
||||
|
||||
it('loads mtl with textures having options', async () => {
|
||||
it("loads mtl with textures having options", async () => {
|
||||
options.metallicRoughness = true;
|
||||
const materials = await loadMtl(texturedWithOptionsMaterialPath, options);
|
||||
expect(materials.length).toBe(1);
|
||||
@ -114,54 +131,60 @@ describe('loadMtl', () => {
|
||||
expect(pbr.baseColorFactor).toEqual([1.0, 1.0, 1.0, 0.9]);
|
||||
expect(pbr.metallicFactor).toBe(1.0);
|
||||
expect(pbr.roughnessFactor).toBe(1.0);
|
||||
expect(material.name).toBe('Material');
|
||||
expect(material.name).toBe("Material");
|
||||
expect(material.emissiveTexture).toBeDefined();
|
||||
expect(material.normalTexture).toBeDefined();
|
||||
expect(material.occlusionTexture).toBeDefined();
|
||||
expect(material.emissiveFactor).toEqual([1.0, 1.0, 1.0]);
|
||||
expect(material.alphaMode).toBe('BLEND');
|
||||
expect(material.alphaMode).toBe("BLEND");
|
||||
expect(material.doubleSided).toBe(true);
|
||||
});
|
||||
|
||||
it('loads mtl with multiple materials', async () => {
|
||||
it("loads mtl with multiple materials", async () => {
|
||||
options.metallicRoughness = true;
|
||||
const materials = await loadMtl(multipleMaterialsPath, options);
|
||||
expect(materials.length).toBe(3);
|
||||
expect(materials[0].name).toBe('Blue');
|
||||
expect(materials[0].pbrMetallicRoughness.baseColorFactor).toEqual([0.0, 0.0, 0.64, 1.0]);
|
||||
expect(materials[1].name).toBe('Green');
|
||||
expect(materials[1].pbrMetallicRoughness.baseColorFactor).toEqual([0.0, 0.64, 0.0, 1.0]);
|
||||
expect(materials[2].name).toBe('Red');
|
||||
expect(materials[2].pbrMetallicRoughness.baseColorFactor).toEqual([0.64, 0.0, 0.0, 1.0]);
|
||||
expect(materials[0].name).toBe("Blue");
|
||||
expect(materials[0].pbrMetallicRoughness.baseColorFactor).toEqual([
|
||||
0.0, 0.0, 0.64, 1.0,
|
||||
]);
|
||||
expect(materials[1].name).toBe("Green");
|
||||
expect(materials[1].pbrMetallicRoughness.baseColorFactor).toEqual([
|
||||
0.0, 0.64, 0.0, 1.0,
|
||||
]);
|
||||
expect(materials[2].name).toBe("Red");
|
||||
expect(materials[2].pbrMetallicRoughness.baseColorFactor).toEqual([
|
||||
0.64, 0.0, 0.0, 1.0,
|
||||
]);
|
||||
});
|
||||
|
||||
it('sets overriding textures', async () => {
|
||||
spyOn(fsExtra, 'readFile').and.callThrough();
|
||||
it("sets overriding textures", async () => {
|
||||
spyOn(fsExtra, "readFile").and.callThrough();
|
||||
options.overridingTextures = {
|
||||
metallicRoughnessOcclusionTexture : alphaTexturePath,
|
||||
baseColorTexture : alphaTexturePath,
|
||||
emissiveTexture : emissiveTexturePath
|
||||
metallicRoughnessOcclusionTexture: alphaTexturePath,
|
||||
baseColorTexture: alphaTexturePath,
|
||||
emissiveTexture: emissiveTexturePath,
|
||||
};
|
||||
const materials = await loadMtl(texturedMaterialPath, options);
|
||||
const material = materials[0];
|
||||
const pbr = material.pbrMetallicRoughness;
|
||||
expect(pbr.baseColorTexture.name).toBe('alpha');
|
||||
expect(pbr.metallicRoughnessTexture.name).toBe('alpha');
|
||||
expect(material.emissiveTexture.name).toBe('emission');
|
||||
expect(material.normalTexture.name).toBe('bump');
|
||||
expect(pbr.baseColorTexture.name).toBe("alpha");
|
||||
expect(pbr.metallicRoughnessTexture.name).toBe("alpha");
|
||||
expect(material.emissiveTexture.name).toBe("emission");
|
||||
expect(material.normalTexture.name).toBe("bump");
|
||||
expect(fsExtra.readFile.calls.count()).toBe(3);
|
||||
});
|
||||
|
||||
it('loads texture outside of the mtl directory', async () => {
|
||||
it("loads texture outside of the mtl directory", async () => {
|
||||
const materials = await loadMtl(externalMaterialPath, options);
|
||||
const material = materials[0];
|
||||
const baseColorTexture = material.pbrMetallicRoughness.baseColorTexture;
|
||||
expect(baseColorTexture.source).toBeDefined();
|
||||
expect(baseColorTexture.name).toBe('cesium');
|
||||
expect(baseColorTexture.name).toBe("cesium");
|
||||
});
|
||||
|
||||
it('does not load texture outside of the mtl directory when secure is true', async () => {
|
||||
const spy = jasmine.createSpy('logger');
|
||||
it("does not load texture outside of the mtl directory when secure is true", async () => {
|
||||
const spy = jasmine.createSpy("logger");
|
||||
options.logger = spy;
|
||||
options.secure = true;
|
||||
|
||||
@ -169,30 +192,38 @@ describe('loadMtl', () => {
|
||||
const material = materials[0];
|
||||
const baseColorTexture = material.pbrMetallicRoughness.baseColorTexture;
|
||||
expect(baseColorTexture).toBeUndefined();
|
||||
expect(spy.calls.argsFor(0)[0].indexOf('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') >= 0).toBe(true);
|
||||
expect(spy.calls.argsFor(1)[0].indexOf('ENOENT') >= 0).toBe(true);
|
||||
expect(spy.calls.argsFor(2)[0].indexOf('Could not read texture file') >= 0).toBe(true);
|
||||
expect(
|
||||
spy.calls
|
||||
.argsFor(0)[0]
|
||||
.indexOf(
|
||||
"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"
|
||||
) >= 0
|
||||
).toBe(true);
|
||||
expect(spy.calls.argsFor(1)[0].indexOf("ENOENT") >= 0).toBe(true);
|
||||
expect(
|
||||
spy.calls.argsFor(2)[0].indexOf("Could not read texture file") >= 0
|
||||
).toBe(true);
|
||||
});
|
||||
|
||||
it('loads textures from root directory when the texture paths do not exist', async () => {
|
||||
it("loads textures from root directory when the texture paths do not exist", async () => {
|
||||
const materials = await loadMtl(resourcesInRootMaterialPath, options);
|
||||
const material = materials[0];
|
||||
const baseColorTexture = material.pbrMetallicRoughness.baseColorTexture;
|
||||
expect(baseColorTexture.source).toBeDefined();
|
||||
expect(baseColorTexture.name).toBe('cesium');
|
||||
expect(baseColorTexture.name).toBe("cesium");
|
||||
});
|
||||
|
||||
it('loads textures from root directory when texture is outside of the mtl directory and secure is true', async () => {
|
||||
it("loads textures from root directory when texture is outside of the mtl directory and secure is true", async () => {
|
||||
options.secure = true;
|
||||
|
||||
const materials = await loadMtl(externalInRootMaterialPath, options);
|
||||
const material = materials[0];
|
||||
const baseColorTexture = material.pbrMetallicRoughness.baseColorTexture;
|
||||
expect(baseColorTexture.source).toBeDefined();
|
||||
expect(baseColorTexture.name).toBe('cesium');
|
||||
expect(baseColorTexture.name).toBe("cesium");
|
||||
});
|
||||
|
||||
it('alpha of 0.0 is treated as 1.0', async () => {
|
||||
it("alpha of 0.0 is treated as 1.0", async () => {
|
||||
const materials = await loadMtl(transparentMaterialPath, options);
|
||||
expect(materials.length).toBe(1);
|
||||
const material = materials[0];
|
||||
@ -200,11 +231,11 @@ describe('loadMtl', () => {
|
||||
expect(pbr.baseColorTexture).toBeUndefined();
|
||||
expect(pbr.metallicRoughnessTexture).toBeUndefined();
|
||||
expect(pbr.baseColorFactor[3]).toEqual(1.0);
|
||||
expect(material.alphaMode).toBe('OPAQUE');
|
||||
expect(material.alphaMode).toBe("OPAQUE");
|
||||
expect(material.doubleSided).toBe(false);
|
||||
});
|
||||
|
||||
it('ambient texture is ignored if it is the same as the diffuse texture', async () => {
|
||||
it("ambient texture is ignored if it is the same as the diffuse texture", async () => {
|
||||
const materials = await loadMtl(sharedTexturesMaterialPath, options);
|
||||
expect(materials.length).toBe(1);
|
||||
const material = materials[0];
|
||||
@ -213,7 +244,7 @@ describe('loadMtl', () => {
|
||||
expect(pbr.occlusionTexture).toBeUndefined();
|
||||
});
|
||||
|
||||
it('texture referenced by specular is decoded', async () => {
|
||||
it("texture referenced by specular is decoded", async () => {
|
||||
const materials = await loadMtl(sharedTexturesMaterialPath, options);
|
||||
expect(materials.length).toBe(1);
|
||||
const material = materials[0];
|
||||
@ -224,7 +255,7 @@ describe('loadMtl', () => {
|
||||
expect(pbr.metallicRoughnessTexture.source).toBeUndefined();
|
||||
});
|
||||
|
||||
it('texture referenced by diffuse and emissive is not decoded', async () => {
|
||||
it("texture referenced by diffuse and emissive is not decoded", async () => {
|
||||
const materials = await loadMtl(sharedTexturesMaterial2Path, options);
|
||||
expect(materials.length).toBe(1);
|
||||
const material = materials[0];
|
||||
@ -234,8 +265,8 @@ describe('loadMtl', () => {
|
||||
expect(pbr.baseColorTexture.source).toBeDefined();
|
||||
});
|
||||
|
||||
describe('metallicRoughness', () => {
|
||||
it('creates default material', () => {
|
||||
describe("metallicRoughness", () => {
|
||||
it("creates default material", () => {
|
||||
const material = loadMtl._createMaterial(undefined, options);
|
||||
const pbr = material.pbrMetallicRoughness;
|
||||
expect(pbr.baseColorTexture).toBeUndefined();
|
||||
@ -247,21 +278,24 @@ describe('loadMtl', () => {
|
||||
expect(material.normalTexture).toBeUndefined();
|
||||
expect(material.ambientTexture).toBeUndefined();
|
||||
expect(material.emissiveFactor).toEqual([0.0, 0.0, 0.0]);
|
||||
expect(material.alphaMode).toBe('OPAQUE');
|
||||
expect(material.alphaMode).toBe("OPAQUE");
|
||||
expect(material.doubleSided).toBe(false);
|
||||
});
|
||||
|
||||
it('creates material with textures', () => {
|
||||
it("creates material with textures", () => {
|
||||
options.metallicRoughness = true;
|
||||
|
||||
const material = loadMtl._createMaterial({
|
||||
diffuseTexture : diffuseTexture,
|
||||
ambientTexture : ambientTexture,
|
||||
normalTexture : normalTexture,
|
||||
emissiveTexture : emissiveTexture,
|
||||
specularTexture : specularTexture,
|
||||
specularShininessTexture : specularShininessTexture
|
||||
}, options);
|
||||
const material = loadMtl._createMaterial(
|
||||
{
|
||||
diffuseTexture: diffuseTexture,
|
||||
ambientTexture: ambientTexture,
|
||||
normalTexture: normalTexture,
|
||||
emissiveTexture: emissiveTexture,
|
||||
specularTexture: specularTexture,
|
||||
specularShininessTexture: specularShininessTexture,
|
||||
},
|
||||
options
|
||||
);
|
||||
|
||||
const pbr = material.pbrMetallicRoughness;
|
||||
expect(pbr.baseColorTexture).toBeDefined();
|
||||
@ -273,57 +307,69 @@ describe('loadMtl', () => {
|
||||
expect(material.normalTexture).toBeDefined();
|
||||
expect(material.occlusionTexture).toBeDefined();
|
||||
expect(material.emissiveFactor).toEqual([1.0, 1.0, 1.0]);
|
||||
expect(material.alphaMode).toBe('OPAQUE');
|
||||
expect(material.alphaMode).toBe("OPAQUE");
|
||||
expect(material.doubleSided).toBe(false);
|
||||
});
|
||||
|
||||
it('packs occlusion in metallic roughness texture', () => {
|
||||
it("packs occlusion in metallic roughness texture", () => {
|
||||
options.metallicRoughness = true;
|
||||
options.packOcclusion = true;
|
||||
|
||||
const material = loadMtl._createMaterial({
|
||||
ambientTexture : alphaTexture,
|
||||
specularTexture : specularTexture,
|
||||
specularShininessTexture : specularShininessTexture
|
||||
}, options);
|
||||
const material = loadMtl._createMaterial(
|
||||
{
|
||||
ambientTexture: alphaTexture,
|
||||
specularTexture: specularTexture,
|
||||
specularShininessTexture: specularShininessTexture,
|
||||
},
|
||||
options
|
||||
);
|
||||
|
||||
const pbr = material.pbrMetallicRoughness;
|
||||
expect(pbr.metallicRoughnessTexture).toBeDefined();
|
||||
expect(pbr.metallicRoughnessTexture).toBe(material.occlusionTexture);
|
||||
});
|
||||
|
||||
it('does not create metallic roughness texture if decoded texture data is not available', () => {
|
||||
it("does not create metallic roughness texture if decoded texture data is not available", () => {
|
||||
options.metallicRoughness = true;
|
||||
options.packOcclusion = true;
|
||||
|
||||
const material = loadMtl._createMaterial({
|
||||
ambientTexture : ambientTexture, // Is a .gif which can't be decoded
|
||||
specularTexture : specularTexture,
|
||||
specularShininessTexture : specularShininessTexture
|
||||
}, options);
|
||||
const material = loadMtl._createMaterial(
|
||||
{
|
||||
ambientTexture: ambientTexture, // Is a .gif which can't be decoded
|
||||
specularTexture: specularTexture,
|
||||
specularShininessTexture: specularShininessTexture,
|
||||
},
|
||||
options
|
||||
);
|
||||
|
||||
const pbr = material.pbrMetallicRoughness;
|
||||
expect(pbr.metallicRoughnessTexture).toBeUndefined();
|
||||
expect(material.occlusionTexture).toBeUndefined();
|
||||
});
|
||||
|
||||
it('sets material for transparent diffuse texture', () => {
|
||||
it("sets material for transparent diffuse texture", () => {
|
||||
options.metallicRoughness = true;
|
||||
|
||||
const material = loadMtl._createMaterial({
|
||||
diffuseTexture : transparentDiffuseTexture
|
||||
}, options);
|
||||
expect(material.alphaMode).toBe('BLEND');
|
||||
const material = loadMtl._createMaterial(
|
||||
{
|
||||
diffuseTexture: transparentDiffuseTexture,
|
||||
},
|
||||
options
|
||||
);
|
||||
expect(material.alphaMode).toBe("BLEND");
|
||||
expect(material.doubleSided).toBe(true);
|
||||
});
|
||||
|
||||
it('packs alpha texture in base color texture', () => {
|
||||
it("packs alpha texture in base color texture", () => {
|
||||
options.metallicRoughness = true;
|
||||
|
||||
const material = loadMtl._createMaterial({
|
||||
diffuseTexture : diffuseTexture,
|
||||
alphaTexture : alphaTexture
|
||||
}, options);
|
||||
const material = loadMtl._createMaterial(
|
||||
{
|
||||
diffuseTexture: diffuseTexture,
|
||||
alphaTexture: alphaTexture,
|
||||
},
|
||||
options
|
||||
);
|
||||
|
||||
const pbr = material.pbrMetallicRoughness;
|
||||
expect(pbr.baseColorTexture).toBeDefined();
|
||||
@ -334,33 +380,36 @@ describe('loadMtl', () => {
|
||||
const pixelsLength = pixels.length / 4;
|
||||
for (let i = 0; i < pixelsLength; ++i) {
|
||||
const alpha = pixels[i * 4 + 3];
|
||||
hasBlack = hasBlack || (alpha === 0);
|
||||
hasWhite = hasWhite || (alpha === 255);
|
||||
hasBlack = hasBlack || alpha === 0;
|
||||
hasWhite = hasWhite || alpha === 255;
|
||||
}
|
||||
expect(hasBlack).toBe(true);
|
||||
expect(hasWhite).toBe(true);
|
||||
expect(pbr.baseColorFactor[3]).toEqual(1);
|
||||
expect(material.alphaMode).toBe('BLEND');
|
||||
expect(material.alphaMode).toBe("BLEND");
|
||||
expect(material.doubleSided).toBe(true);
|
||||
});
|
||||
|
||||
it('uses diffuse texture if diffuse and alpha are the same', () => {
|
||||
it("uses diffuse texture if diffuse and alpha are the same", () => {
|
||||
options.metallicRoughness = true;
|
||||
|
||||
const material = loadMtl._createMaterial({
|
||||
diffuseTexture : diffuseTexture,
|
||||
alphaTexture : diffuseTexture
|
||||
}, options);
|
||||
const material = loadMtl._createMaterial(
|
||||
{
|
||||
diffuseTexture: diffuseTexture,
|
||||
alphaTexture: diffuseTexture,
|
||||
},
|
||||
options
|
||||
);
|
||||
|
||||
const pbr = material.pbrMetallicRoughness;
|
||||
expect(pbr.baseColorTexture).toBe(diffuseTexture);
|
||||
expect(material.alphaMode).toBe('BLEND');
|
||||
expect(material.alphaMode).toBe("BLEND");
|
||||
expect(material.doubleSided).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe('specularGlossiness', () => {
|
||||
it('creates default material', () => {
|
||||
describe("specularGlossiness", () => {
|
||||
it("creates default material", () => {
|
||||
options.specularGlossiness = true;
|
||||
const material = loadMtl._createMaterial(undefined, options);
|
||||
const pbr = material.extensions.KHR_materials_pbrSpecularGlossiness;
|
||||
@ -373,21 +422,24 @@ describe('loadMtl', () => {
|
||||
expect(material.normalTexture).toBeUndefined();
|
||||
expect(material.occlusionTexture).toBeUndefined();
|
||||
expect(material.emissiveFactor).toEqual([0.0, 0.0, 0.0]);
|
||||
expect(material.alphaMode).toBe('OPAQUE');
|
||||
expect(material.alphaMode).toBe("OPAQUE");
|
||||
expect(material.doubleSided).toBe(false);
|
||||
});
|
||||
|
||||
it('creates material with textures', () => {
|
||||
it("creates material with textures", () => {
|
||||
options.specularGlossiness = true;
|
||||
|
||||
const material = loadMtl._createMaterial({
|
||||
diffuseTexture : diffuseTexture,
|
||||
ambientTexture : ambientTexture,
|
||||
normalTexture : normalTexture,
|
||||
emissiveTexture : emissiveTexture,
|
||||
specularTexture : specularTexture,
|
||||
specularShininessTexture : specularShininessTexture
|
||||
}, options);
|
||||
const material = loadMtl._createMaterial(
|
||||
{
|
||||
diffuseTexture: diffuseTexture,
|
||||
ambientTexture: ambientTexture,
|
||||
normalTexture: normalTexture,
|
||||
emissiveTexture: emissiveTexture,
|
||||
specularTexture: specularTexture,
|
||||
specularShininessTexture: specularShininessTexture,
|
||||
},
|
||||
options
|
||||
);
|
||||
|
||||
const pbr = material.extensions.KHR_materials_pbrSpecularGlossiness;
|
||||
expect(pbr.diffuseTexture).toBeDefined();
|
||||
@ -399,40 +451,49 @@ describe('loadMtl', () => {
|
||||
expect(material.normalTexture).toBeDefined();
|
||||
expect(material.occlusionTexture).toBeDefined();
|
||||
expect(material.emissiveFactor).toEqual([1.0, 1.0, 1.0]);
|
||||
expect(material.alphaMode).toBe('OPAQUE');
|
||||
expect(material.alphaMode).toBe("OPAQUE");
|
||||
expect(material.doubleSided).toBe(false);
|
||||
});
|
||||
|
||||
it('does not create specular glossiness texture if decoded texture data is not available', () => {
|
||||
it("does not create specular glossiness texture if decoded texture data is not available", () => {
|
||||
options.specularGlossiness = true;
|
||||
|
||||
const material = loadMtl._createMaterial({
|
||||
specularTexture : ambientTexture, // Is a .gif which can't be decoded
|
||||
specularShininessTexture : specularShininessTexture
|
||||
}, options);
|
||||
const material = loadMtl._createMaterial(
|
||||
{
|
||||
specularTexture: ambientTexture, // Is a .gif which can't be decoded
|
||||
specularShininessTexture: specularShininessTexture,
|
||||
},
|
||||
options
|
||||
);
|
||||
|
||||
const pbr = material.extensions.KHR_materials_pbrSpecularGlossiness;
|
||||
expect(pbr.specularGlossinessTexture).toBeUndefined();
|
||||
});
|
||||
|
||||
it('sets material for transparent diffuse texture', () => {
|
||||
it("sets material for transparent diffuse texture", () => {
|
||||
options.specularGlossiness = true;
|
||||
|
||||
const material = loadMtl._createMaterial({
|
||||
diffuseTexture : transparentDiffuseTexture
|
||||
}, options);
|
||||
const material = loadMtl._createMaterial(
|
||||
{
|
||||
diffuseTexture: transparentDiffuseTexture,
|
||||
},
|
||||
options
|
||||
);
|
||||
|
||||
expect(material.alphaMode).toBe('BLEND');
|
||||
expect(material.alphaMode).toBe("BLEND");
|
||||
expect(material.doubleSided).toBe(true);
|
||||
});
|
||||
|
||||
it('packs alpha texture in diffuse texture', () => {
|
||||
it("packs alpha texture in diffuse texture", () => {
|
||||
options.specularGlossiness = true;
|
||||
|
||||
const material = loadMtl._createMaterial({
|
||||
diffuseTexture : diffuseTexture,
|
||||
alphaTexture : alphaTexture
|
||||
}, options);
|
||||
const material = loadMtl._createMaterial(
|
||||
{
|
||||
diffuseTexture: diffuseTexture,
|
||||
alphaTexture: alphaTexture,
|
||||
},
|
||||
options
|
||||
);
|
||||
|
||||
const pbr = material.extensions.KHR_materials_pbrSpecularGlossiness;
|
||||
expect(pbr.diffuseTexture).toBeDefined();
|
||||
@ -443,27 +504,30 @@ describe('loadMtl', () => {
|
||||
const pixelsLength = pixels.length / 4;
|
||||
for (let i = 0; i < pixelsLength; ++i) {
|
||||
const alpha = pixels[i * 4 + 3];
|
||||
hasBlack = hasBlack || (alpha === 0);
|
||||
hasWhite = hasWhite || (alpha === 255);
|
||||
hasBlack = hasBlack || alpha === 0;
|
||||
hasWhite = hasWhite || alpha === 255;
|
||||
}
|
||||
expect(hasBlack).toBe(true);
|
||||
expect(hasWhite).toBe(true);
|
||||
expect(pbr.diffuseFactor[3]).toEqual(1);
|
||||
expect(material.alphaMode).toBe('BLEND');
|
||||
expect(material.alphaMode).toBe("BLEND");
|
||||
expect(material.doubleSided).toBe(true);
|
||||
});
|
||||
|
||||
it('uses diffuse texture if diffuse and alpha are the same', () => {
|
||||
it("uses diffuse texture if diffuse and alpha are the same", () => {
|
||||
options.specularGlossiness = true;
|
||||
|
||||
const material = loadMtl._createMaterial({
|
||||
diffuseTexture : diffuseTexture,
|
||||
alphaTexture : diffuseTexture
|
||||
}, options);
|
||||
const material = loadMtl._createMaterial(
|
||||
{
|
||||
diffuseTexture: diffuseTexture,
|
||||
alphaTexture: diffuseTexture,
|
||||
},
|
||||
options
|
||||
);
|
||||
|
||||
const pbr = material.extensions.KHR_materials_pbrSpecularGlossiness;
|
||||
expect(pbr.diffuseTexture).toEqual(diffuseTexture);
|
||||
expect(material.alphaMode).toBe('BLEND');
|
||||
expect(material.alphaMode).toBe("BLEND");
|
||||
expect(material.doubleSided).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
@ -1,53 +1,72 @@
|
||||
'use strict';
|
||||
const Cesium = require('cesium');
|
||||
const path = require('path');
|
||||
"use strict";
|
||||
const Cesium = require("cesium");
|
||||
const path = require("path");
|
||||
|
||||
const loadObj = require('../../lib/loadObj');
|
||||
const obj2gltf = require('../../lib/obj2gltf');
|
||||
const loadObj = require("../../lib/loadObj");
|
||||
const obj2gltf = require("../../lib/obj2gltf");
|
||||
|
||||
const Cartesian3 = Cesium.Cartesian3;
|
||||
const CesiumMath = Cesium.Math;
|
||||
const clone = Cesium.clone;
|
||||
const RuntimeError = Cesium.RuntimeError;
|
||||
|
||||
const objPath = 'specs/data/box/box.obj';
|
||||
const objRotatedUrl = 'specs/data/box-rotated/box-rotated.obj';
|
||||
const objNormalsPath = 'specs/data/box-normals/box-normals.obj';
|
||||
const objUvsPath = 'specs/data/box-uvs/box-uvs.obj';
|
||||
const objPositionsOnlyPath = 'specs/data/box-positions-only/box-positions-only.obj';
|
||||
const objNegativeIndicesPath = 'specs/data/box-negative-indices/box-negative-indices.obj';
|
||||
const objTrianglesPath = 'specs/data/box-triangles/box-triangles.obj';
|
||||
const objObjectsPath = 'specs/data/box-objects/box-objects.obj';
|
||||
const objGroupsPath = 'specs/data/box-groups/box-groups.obj';
|
||||
const objObjectsGroupsPath = 'specs/data/box-objects-groups/box-objects-groups.obj';
|
||||
const objObjectsGroupsMaterialsPath = 'specs/data/box-objects-groups-materials/box-objects-groups-materials.obj';
|
||||
const objObjectsGroupsMaterialsPath2 = 'specs/data/box-objects-groups-materials-2/box-objects-groups-materials-2.obj';
|
||||
const objUsemtlPath = 'specs/data/box-usemtl/box-usemtl.obj';
|
||||
const objNoMaterialsPath = 'specs/data/box-no-materials/box-no-materials.obj';
|
||||
const objMultipleMaterialsPath = 'specs/data/box-multiple-materials/box-multiple-materials.obj';
|
||||
const objUncleanedPath = 'specs/data/box-uncleaned/box-uncleaned.obj';
|
||||
const objMtllibPath = 'specs/data/box-mtllib/box-mtllib.obj';
|
||||
const objMtllibSpacesPath = 'specs/data/box-mtllib-spaces/box mtllib.obj';
|
||||
const objMissingMtllibPath = 'specs/data/box-missing-mtllib/box-missing-mtllib.obj';
|
||||
const objMissingUsemtlPath = 'specs/data/box-missing-usemtl/box-missing-usemtl.obj';
|
||||
const objUnnamedMaterialPath = 'specs/data/box-unnamed-material/box-unnamed-material.obj';
|
||||
const objExternalResourcesPath = 'specs/data/box-external-resources/box-external-resources.obj';
|
||||
const objResourcesInRootPath = 'specs/data/box-resources-in-root/box-resources-in-root.obj';
|
||||
const objExternalResourcesInRootPath = 'specs/data/box-external-resources-in-root/box-external-resources-in-root.obj';
|
||||
const objTexturedPath = 'specs/data/box-textured/box-textured.obj';
|
||||
const objMissingTexturePath = 'specs/data/box-missing-texture/box-missing-texture.obj';
|
||||
const objSubdirectoriesPath = 'specs/data/box-subdirectories/box-textured.obj';
|
||||
const objWindowsPaths = 'specs/data/box-windows-paths/box-windows-paths.obj';
|
||||
const objInvalidContentsPath = 'specs/data/box/box.mtl';
|
||||
const objConcavePath = 'specs/data/concave/concave.obj';
|
||||
const objUnnormalizedPath = 'specs/data/box-unnormalized/box-unnormalized.obj';
|
||||
const objMixedAttributesPath = 'specs/data/box-mixed-attributes/box-mixed-attributes.obj';
|
||||
const objMissingAttributesPath = 'specs/data/box-missing-attributes/box-missing-attributes.obj';
|
||||
const objIncompletePositionsPath = 'specs/data/box-incomplete-attributes/box-incomplete-positions.obj';
|
||||
const objIncompleteNormalsPath = 'specs/data/box-incomplete-attributes/box-incomplete-normals.obj';
|
||||
const objIncompleteUvsPath = 'specs/data/box-incomplete-attributes/box-incomplete-uvs.obj';
|
||||
const objIncorrectWindingOrderPath = 'specs/data/box-incorrect-winding-order/box-incorrect-winding-order.obj';
|
||||
const objInvalidPath = 'invalid.obj';
|
||||
const objPath = "specs/data/box/box.obj";
|
||||
const objRotatedUrl = "specs/data/box-rotated/box-rotated.obj";
|
||||
const objNormalsPath = "specs/data/box-normals/box-normals.obj";
|
||||
const objUvsPath = "specs/data/box-uvs/box-uvs.obj";
|
||||
const objPositionsOnlyPath =
|
||||
"specs/data/box-positions-only/box-positions-only.obj";
|
||||
const objNegativeIndicesPath =
|
||||
"specs/data/box-negative-indices/box-negative-indices.obj";
|
||||
const objTrianglesPath = "specs/data/box-triangles/box-triangles.obj";
|
||||
const objObjectsPath = "specs/data/box-objects/box-objects.obj";
|
||||
const objGroupsPath = "specs/data/box-groups/box-groups.obj";
|
||||
const objObjectsGroupsPath =
|
||||
"specs/data/box-objects-groups/box-objects-groups.obj";
|
||||
const objObjectsGroupsMaterialsPath =
|
||||
"specs/data/box-objects-groups-materials/box-objects-groups-materials.obj";
|
||||
const objObjectsGroupsMaterialsPath2 =
|
||||
"specs/data/box-objects-groups-materials-2/box-objects-groups-materials-2.obj";
|
||||
const objUsemtlPath = "specs/data/box-usemtl/box-usemtl.obj";
|
||||
const objNoMaterialsPath = "specs/data/box-no-materials/box-no-materials.obj";
|
||||
const objMultipleMaterialsPath =
|
||||
"specs/data/box-multiple-materials/box-multiple-materials.obj";
|
||||
const objUncleanedPath = "specs/data/box-uncleaned/box-uncleaned.obj";
|
||||
const objMtllibPath = "specs/data/box-mtllib/box-mtllib.obj";
|
||||
const objMtllibSpacesPath = "specs/data/box-mtllib-spaces/box mtllib.obj";
|
||||
const objMissingMtllibPath =
|
||||
"specs/data/box-missing-mtllib/box-missing-mtllib.obj";
|
||||
const objMissingUsemtlPath =
|
||||
"specs/data/box-missing-usemtl/box-missing-usemtl.obj";
|
||||
const objUnnamedMaterialPath =
|
||||
"specs/data/box-unnamed-material/box-unnamed-material.obj";
|
||||
const objExternalResourcesPath =
|
||||
"specs/data/box-external-resources/box-external-resources.obj";
|
||||
const objResourcesInRootPath =
|
||||
"specs/data/box-resources-in-root/box-resources-in-root.obj";
|
||||
const objExternalResourcesInRootPath =
|
||||
"specs/data/box-external-resources-in-root/box-external-resources-in-root.obj";
|
||||
const objTexturedPath = "specs/data/box-textured/box-textured.obj";
|
||||
const objMissingTexturePath =
|
||||
"specs/data/box-missing-texture/box-missing-texture.obj";
|
||||
const objSubdirectoriesPath = "specs/data/box-subdirectories/box-textured.obj";
|
||||
const objWindowsPaths = "specs/data/box-windows-paths/box-windows-paths.obj";
|
||||
const objInvalidContentsPath = "specs/data/box/box.mtl";
|
||||
const objConcavePath = "specs/data/concave/concave.obj";
|
||||
const objUnnormalizedPath = "specs/data/box-unnormalized/box-unnormalized.obj";
|
||||
const objMixedAttributesPath =
|
||||
"specs/data/box-mixed-attributes/box-mixed-attributes.obj";
|
||||
const objMissingAttributesPath =
|
||||
"specs/data/box-missing-attributes/box-missing-attributes.obj";
|
||||
const objIncompletePositionsPath =
|
||||
"specs/data/box-incomplete-attributes/box-incomplete-positions.obj";
|
||||
const objIncompleteNormalsPath =
|
||||
"specs/data/box-incomplete-attributes/box-incomplete-normals.obj";
|
||||
const objIncompleteUvsPath =
|
||||
"specs/data/box-incomplete-attributes/box-incomplete-uvs.obj";
|
||||
const objIncorrectWindingOrderPath =
|
||||
"specs/data/box-incorrect-winding-order/box-incorrect-winding-order.obj";
|
||||
const objInvalidPath = "invalid.obj";
|
||||
|
||||
function getMeshes(data) {
|
||||
let meshes = [];
|
||||
@ -75,14 +94,14 @@ function getPrimitives(data) {
|
||||
|
||||
let options;
|
||||
|
||||
describe('loadObj', () => {
|
||||
describe("loadObj", () => {
|
||||
beforeEach(() => {
|
||||
options = clone(obj2gltf.defaults);
|
||||
options.overridingTextures = {};
|
||||
options.logger = () => {};
|
||||
});
|
||||
|
||||
it('loads obj with positions, normals, and uvs', async () => {
|
||||
it("loads obj with positions, normals, and uvs", async () => {
|
||||
const data = await loadObj(objPath, options);
|
||||
const materials = data.materials;
|
||||
const nodes = data.nodes;
|
||||
@ -90,7 +109,7 @@ describe('loadObj', () => {
|
||||
const meshes = getMeshes(data);
|
||||
const primitives = getPrimitives(data);
|
||||
|
||||
expect(name).toBe('box');
|
||||
expect(name).toBe("box");
|
||||
expect(materials.length).toBe(1);
|
||||
expect(nodes.length).toBe(1);
|
||||
expect(meshes.length).toBe(1);
|
||||
@ -100,16 +119,16 @@ describe('loadObj', () => {
|
||||
const mesh = meshes[0];
|
||||
const primitive = primitives[0];
|
||||
|
||||
expect(node.name).toBe('Cube');
|
||||
expect(mesh.name).toBe('Cube-Mesh');
|
||||
expect(node.name).toBe("Cube");
|
||||
expect(mesh.name).toBe("Cube-Mesh");
|
||||
expect(primitive.positions.length / 3).toBe(24);
|
||||
expect(primitive.normals.length / 3).toBe(24);
|
||||
expect(primitive.uvs.length / 2).toBe(24);
|
||||
expect(primitive.indices.length).toBe(36);
|
||||
expect(primitive.material).toBe('Material');
|
||||
expect(primitive.material).toBe("Material");
|
||||
});
|
||||
|
||||
it('loads obj with normals', async () => {
|
||||
it("loads obj with normals", async () => {
|
||||
const data = await loadObj(objNormalsPath, options);
|
||||
const primitive = getPrimitives(data)[0];
|
||||
expect(primitive.positions.length / 3).toBe(24);
|
||||
@ -117,7 +136,7 @@ describe('loadObj', () => {
|
||||
expect(primitive.uvs.length / 2).toBe(0);
|
||||
});
|
||||
|
||||
it('normalizes normals', async () => {
|
||||
it("normalizes normals", async () => {
|
||||
const data = await loadObj(objUnnormalizedPath, options);
|
||||
const scratchNormal = new Cesium.Cartesian3();
|
||||
const primitive = getPrimitives(data)[0];
|
||||
@ -127,12 +146,23 @@ describe('loadObj', () => {
|
||||
const normalX = normals.get(i * 3);
|
||||
const normalY = normals.get(i * 3 + 1);
|
||||
const normalZ = normals.get(i * 3 + 2);
|
||||
const normal = Cartesian3.fromElements(normalX, normalY, normalZ, scratchNormal);
|
||||
expect(CesiumMath.equalsEpsilon(Cartesian3.magnitude(normal), 1.0, CesiumMath.EPSILON5)).toBe(true);
|
||||
const normal = Cartesian3.fromElements(
|
||||
normalX,
|
||||
normalY,
|
||||
normalZ,
|
||||
scratchNormal
|
||||
);
|
||||
expect(
|
||||
CesiumMath.equalsEpsilon(
|
||||
Cartesian3.magnitude(normal),
|
||||
1.0,
|
||||
CesiumMath.EPSILON5
|
||||
)
|
||||
).toBe(true);
|
||||
}
|
||||
});
|
||||
|
||||
it('loads obj with uvs', async () => {
|
||||
it("loads obj with uvs", async () => {
|
||||
const data = await loadObj(objUvsPath, options);
|
||||
const primitive = getPrimitives(data)[0];
|
||||
expect(primitive.positions.length / 3).toBe(20);
|
||||
@ -140,140 +170,142 @@ describe('loadObj', () => {
|
||||
expect(primitive.uvs.length / 2).toBe(20);
|
||||
});
|
||||
|
||||
it('loads obj with negative indices', async () => {
|
||||
it("loads obj with negative indices", async () => {
|
||||
const results = [
|
||||
await loadObj(objPositionsOnlyPath, options),
|
||||
await loadObj(objNegativeIndicesPath, options)
|
||||
await loadObj(objNegativeIndicesPath, options),
|
||||
];
|
||||
const positionsReference = getPrimitives(results[0])[0].positions.toFloatBuffer();
|
||||
const positionsReference = getPrimitives(
|
||||
results[0]
|
||||
)[0].positions.toFloatBuffer();
|
||||
const positions = getPrimitives(results[1])[0].positions.toFloatBuffer();
|
||||
expect(positions).toEqual(positionsReference);
|
||||
});
|
||||
|
||||
it('loads obj with triangle faces', async () => {
|
||||
it("loads obj with triangle faces", async () => {
|
||||
const data = await loadObj(objTrianglesPath, options);
|
||||
const primitive = getPrimitives(data)[0];
|
||||
expect(primitive.positions.length / 3).toBe(24);
|
||||
expect(primitive.indices.length).toBe(36);
|
||||
});
|
||||
|
||||
it('loads obj with objects', async () => {
|
||||
it("loads obj with objects", async () => {
|
||||
const data = await loadObj(objObjectsPath, options);
|
||||
const nodes = data.nodes;
|
||||
expect(nodes.length).toBe(3);
|
||||
expect(nodes[0].name).toBe('CubeBlue');
|
||||
expect(nodes[1].name).toBe('CubeGreen');
|
||||
expect(nodes[2].name).toBe('CubeRed');
|
||||
expect(nodes[0].name).toBe("CubeBlue");
|
||||
expect(nodes[1].name).toBe("CubeGreen");
|
||||
expect(nodes[2].name).toBe("CubeRed");
|
||||
|
||||
const primitives = getPrimitives(data);
|
||||
expect(primitives.length).toBe(3);
|
||||
expect(primitives[0].material).toBe('Blue');
|
||||
expect(primitives[1].material).toBe('Green');
|
||||
expect(primitives[2].material).toBe('Red');
|
||||
expect(primitives[0].material).toBe("Blue");
|
||||
expect(primitives[1].material).toBe("Green");
|
||||
expect(primitives[2].material).toBe("Red");
|
||||
});
|
||||
|
||||
it('loads obj with groups', async () => {
|
||||
it("loads obj with groups", async () => {
|
||||
const data = await loadObj(objGroupsPath, options);
|
||||
const nodes = data.nodes;
|
||||
expect(nodes.length).toBe(3);
|
||||
expect(nodes[0].name).toBe('CubeBlue');
|
||||
expect(nodes[1].name).toBe('CubeGreen');
|
||||
expect(nodes[2].name).toBe('CubeRed');
|
||||
expect(nodes[0].name).toBe("CubeBlue");
|
||||
expect(nodes[1].name).toBe("CubeGreen");
|
||||
expect(nodes[2].name).toBe("CubeRed");
|
||||
|
||||
const primitives = getPrimitives(data);
|
||||
expect(primitives.length).toBe(3);
|
||||
expect(primitives[0].material).toBe('Blue');
|
||||
expect(primitives[1].material).toBe('Green');
|
||||
expect(primitives[2].material).toBe('Red');
|
||||
expect(primitives[0].material).toBe("Blue");
|
||||
expect(primitives[1].material).toBe("Green");
|
||||
expect(primitives[2].material).toBe("Red");
|
||||
});
|
||||
|
||||
it('loads obj with objects and groups', async () => {
|
||||
it("loads obj with objects and groups", async () => {
|
||||
const data = await loadObj(objObjectsGroupsPath, options);
|
||||
const nodes = data.nodes;
|
||||
expect(nodes.length).toBe(3);
|
||||
expect(nodes[0].name).toBe('CubeBlue');
|
||||
expect(nodes[1].name).toBe('CubeGreen');
|
||||
expect(nodes[2].name).toBe('CubeRed');
|
||||
expect(nodes[0].name).toBe("CubeBlue");
|
||||
expect(nodes[1].name).toBe("CubeGreen");
|
||||
expect(nodes[2].name).toBe("CubeRed");
|
||||
|
||||
const meshes = getMeshes(data);
|
||||
expect(meshes.length).toBe(3);
|
||||
expect(meshes[0].name).toBe('CubeBlue_CubeBlue_Blue');
|
||||
expect(meshes[1].name).toBe('CubeGreen_CubeGreen_Green');
|
||||
expect(meshes[2].name).toBe('CubeRed_CubeRed_Red');
|
||||
expect(meshes[0].name).toBe("CubeBlue_CubeBlue_Blue");
|
||||
expect(meshes[1].name).toBe("CubeGreen_CubeGreen_Green");
|
||||
expect(meshes[2].name).toBe("CubeRed_CubeRed_Red");
|
||||
|
||||
const primitives = getPrimitives(data);
|
||||
expect(primitives.length).toBe(3);
|
||||
expect(primitives[0].material).toBe('Blue');
|
||||
expect(primitives[1].material).toBe('Green');
|
||||
expect(primitives[2].material).toBe('Red');
|
||||
expect(primitives[0].material).toBe("Blue");
|
||||
expect(primitives[1].material).toBe("Green");
|
||||
expect(primitives[2].material).toBe("Red");
|
||||
});
|
||||
|
||||
function loadsObjWithObjectsGroupsAndMaterials(data) {
|
||||
const nodes = data.nodes;
|
||||
expect(nodes.length).toBe(1);
|
||||
expect(nodes[0].name).toBe('Cube');
|
||||
expect(nodes[0].name).toBe("Cube");
|
||||
const meshes = getMeshes(data);
|
||||
expect(meshes.length).toBe(3);
|
||||
expect(meshes[0].name).toBe('Blue');
|
||||
expect(meshes[1].name).toBe('Green');
|
||||
expect(meshes[2].name).toBe('Red');
|
||||
expect(meshes[0].name).toBe("Blue");
|
||||
expect(meshes[1].name).toBe("Green");
|
||||
expect(meshes[2].name).toBe("Red");
|
||||
const primitives = getPrimitives(data);
|
||||
expect(primitives.length).toBe(6);
|
||||
expect(primitives[0].material).toBe('Blue');
|
||||
expect(primitives[1].material).toBe('Green');
|
||||
expect(primitives[2].material).toBe('Green');
|
||||
expect(primitives[3].material).toBe('Red');
|
||||
expect(primitives[4].material).toBe('Red');
|
||||
expect(primitives[5].material).toBe('Blue');
|
||||
expect(primitives[0].material).toBe("Blue");
|
||||
expect(primitives[1].material).toBe("Green");
|
||||
expect(primitives[2].material).toBe("Green");
|
||||
expect(primitives[3].material).toBe("Red");
|
||||
expect(primitives[4].material).toBe("Red");
|
||||
expect(primitives[5].material).toBe("Blue");
|
||||
}
|
||||
|
||||
it('loads obj with objects, groups, and materials', async () => {
|
||||
it("loads obj with objects, groups, and materials", async () => {
|
||||
const data = await loadObj(objObjectsGroupsMaterialsPath, options);
|
||||
loadsObjWithObjectsGroupsAndMaterials(data);
|
||||
});
|
||||
|
||||
it('loads obj with objects, groups, and materials (2)', async () => {
|
||||
it("loads obj with objects, groups, and materials (2)", async () => {
|
||||
// The usemtl lines are placed in an unordered fashion but
|
||||
// should produce the same result as the previous test
|
||||
const data = await loadObj(objObjectsGroupsMaterialsPath2, options);
|
||||
loadsObjWithObjectsGroupsAndMaterials(data);
|
||||
});
|
||||
|
||||
it('loads obj with concave face containing 5 vertices', async () => {
|
||||
it("loads obj with concave face containing 5 vertices", async () => {
|
||||
const data = await loadObj(objConcavePath, options);
|
||||
const primitive = getPrimitives(data)[0];
|
||||
expect(primitive.positions.length / 3).toBe(30);
|
||||
expect(primitive.indices.length).toBe(48);
|
||||
});
|
||||
|
||||
it('loads obj with usemtl only', async () => {
|
||||
it("loads obj with usemtl only", async () => {
|
||||
const data = await loadObj(objUsemtlPath, options);
|
||||
const nodes = data.nodes;
|
||||
expect(nodes.length).toBe(1);
|
||||
expect(nodes[0].name).toBe('Node'); // default name
|
||||
expect(nodes[0].name).toBe("Node"); // default name
|
||||
|
||||
const meshes = getMeshes(data);
|
||||
expect(meshes.length).toBe(1);
|
||||
expect(meshes[0].name).toBe('Node-Mesh');
|
||||
expect(meshes[0].name).toBe("Node-Mesh");
|
||||
|
||||
const primitives = getPrimitives(data);
|
||||
expect(primitives.length).toBe(3);
|
||||
expect(primitives[0].material).toBe('Blue');
|
||||
expect(primitives[1].material).toBe('Green');
|
||||
expect(primitives[2].material).toBe('Red');
|
||||
expect(primitives[0].material).toBe("Blue");
|
||||
expect(primitives[1].material).toBe("Green");
|
||||
expect(primitives[2].material).toBe("Red");
|
||||
});
|
||||
|
||||
it('loads obj with no materials', async () => {
|
||||
it("loads obj with no materials", async () => {
|
||||
const data = await loadObj(objNoMaterialsPath, options);
|
||||
const nodes = data.nodes;
|
||||
expect(nodes.length).toBe(1);
|
||||
expect(nodes[0].name).toBe('Node'); // default name
|
||||
expect(nodes[0].name).toBe("Node"); // default name
|
||||
|
||||
const primitives = getPrimitives(data);
|
||||
expect(primitives.length).toBe(1);
|
||||
});
|
||||
|
||||
it('loads obj with multiple materials', async () => {
|
||||
it("loads obj with multiple materials", async () => {
|
||||
// The usemtl markers are interleaved, but should condense to just three primitives
|
||||
const data = await loadObj(objMultipleMaterialsPath, options);
|
||||
const nodes = data.nodes;
|
||||
@ -285,9 +317,9 @@ describe('loadObj', () => {
|
||||
expect(primitives[0].indices.length).toBe(12);
|
||||
expect(primitives[1].indices.length).toBe(12);
|
||||
expect(primitives[2].indices.length).toBe(12);
|
||||
expect(primitives[0].material).toBe('Red');
|
||||
expect(primitives[1].material).toBe('Green');
|
||||
expect(primitives[2].material).toBe('Blue');
|
||||
expect(primitives[0].material).toBe("Red");
|
||||
expect(primitives[1].material).toBe("Green");
|
||||
expect(primitives[2].material).toBe("Blue");
|
||||
|
||||
for (let i = 0; i < 3; ++i) {
|
||||
const indices = primitives[i].indices;
|
||||
@ -297,7 +329,7 @@ describe('loadObj', () => {
|
||||
}
|
||||
});
|
||||
|
||||
it('loads obj uncleaned', async () => {
|
||||
it("loads obj uncleaned", async () => {
|
||||
// Obj with extraneous o, g, and usemtl lines
|
||||
// Also tests handling of o and g lines with the same names
|
||||
const data = await loadObj(objUncleanedPath, options);
|
||||
@ -309,11 +341,11 @@ describe('loadObj', () => {
|
||||
expect(meshes.length).toBe(1);
|
||||
expect(primitives.length).toBe(1);
|
||||
|
||||
expect(nodes[0].name).toBe('Cube');
|
||||
expect(meshes[0].name).toBe('Cube_1');
|
||||
expect(nodes[0].name).toBe("Cube");
|
||||
expect(meshes[0].name).toBe("Cube_1");
|
||||
});
|
||||
|
||||
it('loads obj with multiple mtllibs', async () => {
|
||||
it("loads obj with multiple mtllibs", async () => {
|
||||
const data = await loadObj(objMtllibPath, options);
|
||||
const materials = data.materials;
|
||||
expect(materials.length).toBe(3);
|
||||
@ -323,15 +355,21 @@ describe('loadObj', () => {
|
||||
return a.name.localeCompare(b.name);
|
||||
});
|
||||
|
||||
expect(materials[0].name).toBe('Blue');
|
||||
expect(materials[0].pbrMetallicRoughness.baseColorFactor).toEqual([0.0, 0.0, 0.64, 1.0]);
|
||||
expect(materials[1].name).toBe('Green');
|
||||
expect(materials[1].pbrMetallicRoughness.baseColorFactor).toEqual([0.0, 0.64, 0.0, 1.0]);
|
||||
expect(materials[2].name).toBe('Red');
|
||||
expect(materials[2].pbrMetallicRoughness.baseColorFactor).toEqual([0.64, 0.0, 0.0, 1.0]);
|
||||
expect(materials[0].name).toBe("Blue");
|
||||
expect(materials[0].pbrMetallicRoughness.baseColorFactor).toEqual([
|
||||
0.0, 0.0, 0.64, 1.0,
|
||||
]);
|
||||
expect(materials[1].name).toBe("Green");
|
||||
expect(materials[1].pbrMetallicRoughness.baseColorFactor).toEqual([
|
||||
0.0, 0.64, 0.0, 1.0,
|
||||
]);
|
||||
expect(materials[2].name).toBe("Red");
|
||||
expect(materials[2].pbrMetallicRoughness.baseColorFactor).toEqual([
|
||||
0.64, 0.0, 0.0, 1.0,
|
||||
]);
|
||||
});
|
||||
|
||||
it('loads obj with mtllib paths with spaces', async () => {
|
||||
it("loads obj with mtllib paths with spaces", async () => {
|
||||
const data = await loadObj(objMtllibSpacesPath, options);
|
||||
const materials = data.materials;
|
||||
expect(materials.length).toBe(3);
|
||||
@ -341,71 +379,98 @@ describe('loadObj', () => {
|
||||
return a.name.localeCompare(b.name);
|
||||
});
|
||||
|
||||
expect(materials[0].name).toBe('Blue');
|
||||
expect(materials[0].pbrMetallicRoughness.baseColorFactor).toEqual([0.0, 0.0, 0.64, 1.0]);
|
||||
expect(materials[1].name).toBe('Green');
|
||||
expect(materials[1].pbrMetallicRoughness.baseColorFactor).toEqual([0.0, 0.64, 0.0, 1.0]);
|
||||
expect(materials[2].name).toBe('Red');
|
||||
expect(materials[2].pbrMetallicRoughness.baseColorFactor).toEqual([0.64, 0.0, 0.0, 1.0]);
|
||||
expect(materials[0].name).toBe("Blue");
|
||||
expect(materials[0].pbrMetallicRoughness.baseColorFactor).toEqual([
|
||||
0.0, 0.0, 0.64, 1.0,
|
||||
]);
|
||||
expect(materials[1].name).toBe("Green");
|
||||
expect(materials[1].pbrMetallicRoughness.baseColorFactor).toEqual([
|
||||
0.0, 0.64, 0.0, 1.0,
|
||||
]);
|
||||
expect(materials[2].name).toBe("Red");
|
||||
expect(materials[2].pbrMetallicRoughness.baseColorFactor).toEqual([
|
||||
0.64, 0.0, 0.0, 1.0,
|
||||
]);
|
||||
});
|
||||
|
||||
it('loads obj with missing mtllib', async () => {
|
||||
const spy = jasmine.createSpy('logger');
|
||||
it("loads obj with missing mtllib", async () => {
|
||||
const spy = jasmine.createSpy("logger");
|
||||
options.logger = spy;
|
||||
|
||||
const data = await loadObj(objMissingMtllibPath, options);
|
||||
expect(data.materials.length).toBe(0);
|
||||
expect(spy.calls.argsFor(0)[0].indexOf('ENOENT') >= 0).toBe(true);
|
||||
expect(spy.calls.argsFor(0)[0].indexOf(path.resolve('/box.mtl')) >= 0).toBe(true);
|
||||
expect(spy.calls.argsFor(1)[0].indexOf('Attempting to read the material file from within the obj directory instead.') >= 0).toBe(true);
|
||||
expect(spy.calls.argsFor(2)[0].indexOf('ENOENT') >= 0).toBe(true);
|
||||
expect(spy.calls.argsFor(3)[0].indexOf('Could not read material file') >= 0).toBe(true);
|
||||
expect(spy.calls.argsFor(0)[0].indexOf("ENOENT") >= 0).toBe(true);
|
||||
expect(spy.calls.argsFor(0)[0].indexOf(path.resolve("/box.mtl")) >= 0).toBe(
|
||||
true
|
||||
);
|
||||
expect(
|
||||
spy.calls
|
||||
.argsFor(1)[0]
|
||||
.indexOf(
|
||||
"Attempting to read the material file from within the obj directory instead."
|
||||
) >= 0
|
||||
).toBe(true);
|
||||
expect(spy.calls.argsFor(2)[0].indexOf("ENOENT") >= 0).toBe(true);
|
||||
expect(
|
||||
spy.calls.argsFor(3)[0].indexOf("Could not read material file") >= 0
|
||||
).toBe(true);
|
||||
});
|
||||
|
||||
it('loads obj with missing usemtl', async () => {
|
||||
it("loads obj with missing usemtl", async () => {
|
||||
const data = await loadObj(objMissingUsemtlPath, options);
|
||||
expect(data.materials.length).toBe(1);
|
||||
expect(data.nodes[0].meshes[0].primitives[0].material).toBe('Material');
|
||||
expect(data.nodes[0].meshes[0].primitives[0].material).toBe("Material");
|
||||
});
|
||||
|
||||
it('loads obj with unnamed material', async () => {
|
||||
it("loads obj with unnamed material", async () => {
|
||||
const data = await loadObj(objUnnamedMaterialPath, options);
|
||||
expect(data.materials.length).toBe(1);
|
||||
expect(data.nodes[0].meshes[0].primitives[0].material).toBe('');
|
||||
expect(data.nodes[0].meshes[0].primitives[0].material).toBe("");
|
||||
});
|
||||
|
||||
it('loads .mtl outside of the obj directory', async () => {
|
||||
it("loads .mtl outside of the obj directory", async () => {
|
||||
const data = await loadObj(objExternalResourcesPath, options);
|
||||
const materials = data.materials;
|
||||
expect(materials.length).toBe(2);
|
||||
|
||||
// .mtl files are loaded in an arbitrary order, so find the "MaterialTextured" material
|
||||
const materialTextured = materials[0].name === 'MaterialTextured' ? materials[0] : materials[1];
|
||||
const baseColorTexture = materialTextured.pbrMetallicRoughness.baseColorTexture;
|
||||
const materialTextured =
|
||||
materials[0].name === "MaterialTextured" ? materials[0] : materials[1];
|
||||
const baseColorTexture =
|
||||
materialTextured.pbrMetallicRoughness.baseColorTexture;
|
||||
expect(baseColorTexture.source).toBeDefined();
|
||||
expect(baseColorTexture.name).toEqual('cesium');
|
||||
expect(baseColorTexture.name).toEqual("cesium");
|
||||
});
|
||||
|
||||
it('does not load .mtl outside of the obj directory when secure is true', async () => {
|
||||
const spy = jasmine.createSpy('logger');
|
||||
it("does not load .mtl outside of the obj directory when secure is true", async () => {
|
||||
const spy = jasmine.createSpy("logger");
|
||||
options.logger = spy;
|
||||
options.secure = true;
|
||||
|
||||
const data = await loadObj(objExternalResourcesPath, options);
|
||||
expect(data.materials.length).toBe(1); // obj references 2 materials, one of which is outside the input directory
|
||||
expect(spy.calls.argsFor(0)[0].indexOf('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.') >= 0).toBe(true);
|
||||
expect(spy.calls.argsFor(1)[0].indexOf('ENOENT') >= 0).toBe(true);
|
||||
expect(spy.calls.argsFor(2)[0].indexOf('Could not read material file') >= 0).toBe(true);
|
||||
expect(
|
||||
spy.calls
|
||||
.argsFor(0)[0]
|
||||
.indexOf(
|
||||
"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."
|
||||
) >= 0
|
||||
).toBe(true);
|
||||
expect(spy.calls.argsFor(1)[0].indexOf("ENOENT") >= 0).toBe(true);
|
||||
expect(
|
||||
spy.calls.argsFor(2)[0].indexOf("Could not read material file") >= 0
|
||||
).toBe(true);
|
||||
});
|
||||
|
||||
it('loads .mtl from root directory when the .mtl path does not exist', async () => {
|
||||
it("loads .mtl from root directory when the .mtl path does not exist", async () => {
|
||||
const data = await loadObj(objResourcesInRootPath, options);
|
||||
const baseColorTexture = data.materials[0].pbrMetallicRoughness.baseColorTexture;
|
||||
expect(baseColorTexture.name).toBe('cesium');
|
||||
const baseColorTexture =
|
||||
data.materials[0].pbrMetallicRoughness.baseColorTexture;
|
||||
expect(baseColorTexture.name).toBe("cesium");
|
||||
expect(baseColorTexture.source).toBeDefined();
|
||||
});
|
||||
|
||||
it('loads .mtl from root directory when the .mtl path is outside of the obj directory and secure is true', async () => {
|
||||
it("loads .mtl from root directory when the .mtl path is outside of the obj directory and secure is true", async () => {
|
||||
options.secure = true;
|
||||
|
||||
const data = await loadObj(objExternalResourcesInRootPath, options);
|
||||
@ -413,48 +478,64 @@ describe('loadObj', () => {
|
||||
expect(materials.length).toBe(2);
|
||||
|
||||
// .mtl files are loaded in an arbitrary order, so find the "MaterialTextured" material
|
||||
const materialTextured = materials[0].name === 'MaterialTextured' ? materials[0] : materials[1];
|
||||
const baseColorTexture = materialTextured.pbrMetallicRoughness.baseColorTexture;
|
||||
const materialTextured =
|
||||
materials[0].name === "MaterialTextured" ? materials[0] : materials[1];
|
||||
const baseColorTexture =
|
||||
materialTextured.pbrMetallicRoughness.baseColorTexture;
|
||||
expect(baseColorTexture.source).toBeDefined();
|
||||
expect(baseColorTexture.name).toEqual('cesium');
|
||||
expect(baseColorTexture.name).toEqual("cesium");
|
||||
});
|
||||
|
||||
it('loads obj with texture', async () => {
|
||||
it("loads obj with texture", async () => {
|
||||
const data = await loadObj(objTexturedPath, options);
|
||||
const baseColorTexture = data.materials[0].pbrMetallicRoughness.baseColorTexture;
|
||||
expect(baseColorTexture.name).toBe('cesium');
|
||||
const baseColorTexture =
|
||||
data.materials[0].pbrMetallicRoughness.baseColorTexture;
|
||||
expect(baseColorTexture.name).toBe("cesium");
|
||||
expect(baseColorTexture.source).toBeDefined();
|
||||
});
|
||||
|
||||
it('loads obj with missing texture', async () => {
|
||||
const spy = jasmine.createSpy('logger');
|
||||
it("loads obj with missing texture", async () => {
|
||||
const spy = jasmine.createSpy("logger");
|
||||
options.logger = spy;
|
||||
|
||||
const data = await loadObj(objMissingTexturePath, options);
|
||||
const baseColorTexture = data.materials[0].pbrMetallicRoughness.baseColorTexture;
|
||||
const baseColorTexture =
|
||||
data.materials[0].pbrMetallicRoughness.baseColorTexture;
|
||||
expect(baseColorTexture).toBeUndefined();
|
||||
expect(spy.calls.argsFor(0)[0].indexOf('ENOENT') >= 0).toBe(true);
|
||||
expect(spy.calls.argsFor(0)[0].indexOf(path.resolve('/cesium.png')) >= 0).toBe(true);
|
||||
expect(spy.calls.argsFor(1)[0].indexOf('Attempting to read the texture file from within the obj directory instead.') >= 0).toBe(true);
|
||||
expect(spy.calls.argsFor(2)[0].indexOf('ENOENT') >= 0).toBe(true);
|
||||
expect(spy.calls.argsFor(3)[0].indexOf('Could not read texture file') >= 0).toBe(true);
|
||||
expect(spy.calls.argsFor(0)[0].indexOf("ENOENT") >= 0).toBe(true);
|
||||
expect(
|
||||
spy.calls.argsFor(0)[0].indexOf(path.resolve("/cesium.png")) >= 0
|
||||
).toBe(true);
|
||||
expect(
|
||||
spy.calls
|
||||
.argsFor(1)[0]
|
||||
.indexOf(
|
||||
"Attempting to read the texture file from within the obj directory instead."
|
||||
) >= 0
|
||||
).toBe(true);
|
||||
expect(spy.calls.argsFor(2)[0].indexOf("ENOENT") >= 0).toBe(true);
|
||||
expect(
|
||||
spy.calls.argsFor(3)[0].indexOf("Could not read texture file") >= 0
|
||||
).toBe(true);
|
||||
});
|
||||
|
||||
it('loads obj with subdirectories', async () => {
|
||||
it("loads obj with subdirectories", async () => {
|
||||
const data = await loadObj(objSubdirectoriesPath, options);
|
||||
const baseColorTexture = data.materials[0].pbrMetallicRoughness.baseColorTexture;
|
||||
expect(baseColorTexture.name).toBe('cesium');
|
||||
const baseColorTexture =
|
||||
data.materials[0].pbrMetallicRoughness.baseColorTexture;
|
||||
expect(baseColorTexture.name).toBe("cesium");
|
||||
expect(baseColorTexture.source).toBeDefined();
|
||||
});
|
||||
|
||||
it('loads obj with windows paths', async () => {
|
||||
it("loads obj with windows paths", async () => {
|
||||
const data = await loadObj(objWindowsPaths, options);
|
||||
const baseColorTexture = data.materials[0].pbrMetallicRoughness.baseColorTexture;
|
||||
expect(baseColorTexture.name).toBe('cesium');
|
||||
const baseColorTexture =
|
||||
data.materials[0].pbrMetallicRoughness.baseColorTexture;
|
||||
expect(baseColorTexture.name).toBe("cesium");
|
||||
expect(baseColorTexture.source).toBeDefined();
|
||||
});
|
||||
|
||||
it('separates faces that don\'t use the same attributes as other faces in the primitive', async () => {
|
||||
it("separates faces that don't use the same attributes as other faces in the primitive", async () => {
|
||||
const data = await loadObj(objMixedAttributesPath, options);
|
||||
const primitives = getPrimitives(data);
|
||||
expect(primitives.length).toBe(4);
|
||||
@ -466,16 +547,29 @@ describe('loadObj', () => {
|
||||
|
||||
function getFirstPosition(data) {
|
||||
const primitive = getPrimitives(data)[0];
|
||||
return new Cartesian3(primitive.positions.get(0), primitive.positions.get(1), primitive.positions.get(2));
|
||||
return new Cartesian3(
|
||||
primitive.positions.get(0),
|
||||
primitive.positions.get(1),
|
||||
primitive.positions.get(2)
|
||||
);
|
||||
}
|
||||
|
||||
function getFirstNormal(data) {
|
||||
const primitive = getPrimitives(data)[0];
|
||||
return new Cartesian3(primitive.normals.get(0), primitive.normals.get(1), primitive.normals.get(2));
|
||||
return new Cartesian3(
|
||||
primitive.normals.get(0),
|
||||
primitive.normals.get(1),
|
||||
primitive.normals.get(2)
|
||||
);
|
||||
}
|
||||
|
||||
async function checkAxisConversion(inputUpAxis, outputUpAxis, position, normal) {
|
||||
const sameAxis = (inputUpAxis === outputUpAxis);
|
||||
async function checkAxisConversion(
|
||||
inputUpAxis,
|
||||
outputUpAxis,
|
||||
position,
|
||||
normal
|
||||
) {
|
||||
const sameAxis = inputUpAxis === outputUpAxis;
|
||||
options.inputUpAxis = inputUpAxis;
|
||||
options.outputUpAxis = outputUpAxis;
|
||||
const data = await loadObj(objRotatedUrl, options);
|
||||
@ -490,12 +584,12 @@ describe('loadObj', () => {
|
||||
}
|
||||
}
|
||||
|
||||
it('performs up axis conversion', async () => {
|
||||
it("performs up axis conversion", async () => {
|
||||
const data = await loadObj(objRotatedUrl, options);
|
||||
const position = getFirstPosition(data);
|
||||
const normal = getFirstNormal(data);
|
||||
|
||||
const axes = ['X', 'Y', 'Z'];
|
||||
const axes = ["X", "Y", "Z"];
|
||||
const axesLength = axes.length;
|
||||
for (let i = 0; i < axesLength; ++i) {
|
||||
for (let j = 0; j < axesLength; ++j) {
|
||||
@ -504,7 +598,7 @@ describe('loadObj', () => {
|
||||
}
|
||||
});
|
||||
|
||||
it('ignores missing normals and uvs', async () => {
|
||||
it("ignores missing normals and uvs", async () => {
|
||||
const data = await loadObj(objMissingAttributesPath, options);
|
||||
const primitive = getPrimitives(data)[0];
|
||||
expect(primitive.positions.length).toBeGreaterThan(0);
|
||||
@ -519,12 +613,18 @@ describe('loadObj', () => {
|
||||
return new Uint16Array(indices.toUint16Buffer().buffer);
|
||||
}
|
||||
|
||||
it('applies triangle winding order sanitization', async () => {
|
||||
it("applies triangle winding order sanitization", async () => {
|
||||
options.triangleWindingOrderSanitization = false;
|
||||
const indicesIncorrect = await loadAndGetIndices(objIncorrectWindingOrderPath, options);
|
||||
const indicesIncorrect = await loadAndGetIndices(
|
||||
objIncorrectWindingOrderPath,
|
||||
options
|
||||
);
|
||||
|
||||
options.triangleWindingOrderSanitization = true;
|
||||
const indicesCorrect = await loadAndGetIndices(objIncorrectWindingOrderPath, options);
|
||||
const indicesCorrect = await loadAndGetIndices(
|
||||
objIncorrectWindingOrderPath,
|
||||
options
|
||||
);
|
||||
|
||||
expect(indicesIncorrect[0]).toBe(0);
|
||||
expect(indicesIncorrect[2]).toBe(2);
|
||||
@ -535,53 +635,65 @@ describe('loadObj', () => {
|
||||
expect(indicesCorrect[1]).toBe(2);
|
||||
});
|
||||
|
||||
it('throws when position index is out of bounds', async () => {
|
||||
it("throws when position index is out of bounds", async () => {
|
||||
let thrownError;
|
||||
try {
|
||||
await loadObj(objIncompletePositionsPath, options);
|
||||
} catch (e) {
|
||||
thrownError = e;
|
||||
}
|
||||
expect(thrownError).toEqual(new RuntimeError('Position index 1 is out of bounds'));
|
||||
expect(thrownError).toEqual(
|
||||
new RuntimeError("Position index 1 is out of bounds")
|
||||
);
|
||||
});
|
||||
|
||||
it('throws when normal index is out of bounds', async () => {
|
||||
it("throws when normal index is out of bounds", async () => {
|
||||
let thrownError;
|
||||
try {
|
||||
await loadObj(objIncompleteNormalsPath, options);
|
||||
} catch (e) {
|
||||
thrownError = e;
|
||||
}
|
||||
expect(thrownError).toEqual(new RuntimeError('Normal index 1 is out of bounds'));
|
||||
expect(thrownError).toEqual(
|
||||
new RuntimeError("Normal index 1 is out of bounds")
|
||||
);
|
||||
});
|
||||
|
||||
it('throws when uv index is out of bounds', async () => {
|
||||
it("throws when uv index is out of bounds", async () => {
|
||||
let thrownError;
|
||||
try {
|
||||
await loadObj(objIncompleteUvsPath, options);
|
||||
} catch (e) {
|
||||
thrownError = e;
|
||||
}
|
||||
expect(thrownError).toEqual(new RuntimeError('UV index 1 is out of bounds'));
|
||||
expect(thrownError).toEqual(
|
||||
new RuntimeError("UV index 1 is out of bounds")
|
||||
);
|
||||
});
|
||||
|
||||
it('throws when file has invalid contents', async () => {
|
||||
it("throws when file has invalid contents", async () => {
|
||||
let thrownError;
|
||||
try {
|
||||
await loadObj(objInvalidContentsPath, options);
|
||||
} catch (e) {
|
||||
thrownError = e;
|
||||
}
|
||||
expect(thrownError).toEqual(new RuntimeError(objInvalidContentsPath + ' does not have any geometry data'));
|
||||
expect(thrownError).toEqual(
|
||||
new RuntimeError(
|
||||
objInvalidContentsPath + " does not have any geometry data"
|
||||
)
|
||||
);
|
||||
});
|
||||
|
||||
it('throw when reading invalid file', async () => {
|
||||
it("throw when reading invalid file", async () => {
|
||||
let thrownError;
|
||||
try {
|
||||
await loadObj(objInvalidPath, options);
|
||||
} catch (e) {
|
||||
thrownError = e;
|
||||
}
|
||||
expect(thrownError.message.startsWith('ENOENT: no such file or directory')).toBe(true);
|
||||
expect(
|
||||
thrownError.message.startsWith("ENOENT: no such file or directory")
|
||||
).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
@ -1,85 +1,85 @@
|
||||
'use strict';
|
||||
const loadTexture = require('../../lib/loadTexture');
|
||||
"use strict";
|
||||
const loadTexture = require("../../lib/loadTexture");
|
||||
|
||||
const pngTexturePath = 'specs/data/box-complex-material/shininess.png';
|
||||
const jpgTexturePath = 'specs/data/box-complex-material/emission.jpg';
|
||||
const jpegTexturePath = 'specs/data/box-complex-material/specular.jpeg';
|
||||
const gifTexturePath = 'specs/data/box-complex-material/ambient.gif';
|
||||
const grayscaleTexturePath = 'specs/data/box-complex-material-alpha/alpha.png';
|
||||
const transparentTexturePath = 'specs/data/box-complex-material/diffuse.png';
|
||||
const pngTexturePath = "specs/data/box-complex-material/shininess.png";
|
||||
const jpgTexturePath = "specs/data/box-complex-material/emission.jpg";
|
||||
const jpegTexturePath = "specs/data/box-complex-material/specular.jpeg";
|
||||
const gifTexturePath = "specs/data/box-complex-material/ambient.gif";
|
||||
const grayscaleTexturePath = "specs/data/box-complex-material-alpha/alpha.png";
|
||||
const transparentTexturePath = "specs/data/box-complex-material/diffuse.png";
|
||||
|
||||
describe('loadTexture', () => {
|
||||
it('loads png texture', async () => {
|
||||
describe("loadTexture", () => {
|
||||
it("loads png texture", async () => {
|
||||
const texture = await loadTexture(pngTexturePath);
|
||||
expect(texture.transparent).toBe(false);
|
||||
expect(texture.source).toBeDefined();
|
||||
expect(texture.name).toBe('shininess');
|
||||
expect(texture.extension).toBe('.png');
|
||||
expect(texture.name).toBe("shininess");
|
||||
expect(texture.extension).toBe(".png");
|
||||
expect(texture.path).toBe(pngTexturePath);
|
||||
expect(texture.pixels).toBeUndefined();
|
||||
expect(texture.width).toBeUndefined();
|
||||
expect(texture.height).toBeUndefined();
|
||||
});
|
||||
|
||||
it('loads jpg texture', async () => {
|
||||
it("loads jpg texture", async () => {
|
||||
const texture = await loadTexture(jpgTexturePath);
|
||||
expect(texture.transparent).toBe(false);
|
||||
expect(texture.source).toBeDefined();
|
||||
expect(texture.name).toBe('emission');
|
||||
expect(texture.extension).toBe('.jpg');
|
||||
expect(texture.name).toBe("emission");
|
||||
expect(texture.extension).toBe(".jpg");
|
||||
expect(texture.path).toBe(jpgTexturePath);
|
||||
expect(texture.pixels).toBeUndefined();
|
||||
expect(texture.width).toBeUndefined();
|
||||
expect(texture.height).toBeUndefined();
|
||||
});
|
||||
|
||||
it('loads jpeg texture', async () => {
|
||||
it("loads jpeg texture", async () => {
|
||||
const texture = await loadTexture(jpegTexturePath);
|
||||
expect(texture.transparent).toBe(false);
|
||||
expect(texture.source).toBeDefined();
|
||||
expect(texture.name).toBe('specular');
|
||||
expect(texture.extension).toBe('.jpeg');
|
||||
expect(texture.name).toBe("specular");
|
||||
expect(texture.extension).toBe(".jpeg");
|
||||
expect(texture.path).toBe(jpegTexturePath);
|
||||
expect(texture.pixels).toBeUndefined();
|
||||
expect(texture.width).toBeUndefined();
|
||||
expect(texture.height).toBeUndefined();
|
||||
});
|
||||
|
||||
it('loads gif texture', async () => {
|
||||
it("loads gif texture", async () => {
|
||||
const texture = await loadTexture(gifTexturePath);
|
||||
expect(texture.transparent).toBe(false);
|
||||
expect(texture.source).toBeDefined();
|
||||
expect(texture.name).toBe('ambient');
|
||||
expect(texture.extension).toBe('.gif');
|
||||
expect(texture.name).toBe("ambient");
|
||||
expect(texture.extension).toBe(".gif");
|
||||
expect(texture.path).toBe(gifTexturePath);
|
||||
expect(texture.pixels).toBeUndefined();
|
||||
expect(texture.width).toBeUndefined();
|
||||
expect(texture.height).toBeUndefined();
|
||||
});
|
||||
|
||||
it('loads grayscale texture', async () => {
|
||||
it("loads grayscale texture", async () => {
|
||||
const texture = await loadTexture(grayscaleTexturePath);
|
||||
expect(texture.transparent).toBe(false);
|
||||
expect(texture.source).toBeDefined();
|
||||
expect(texture.extension).toBe('.png');
|
||||
expect(texture.extension).toBe(".png");
|
||||
});
|
||||
|
||||
it('loads texture with alpha channel', async () => {
|
||||
it("loads texture with alpha channel", async () => {
|
||||
const texture = await loadTexture(transparentTexturePath);
|
||||
expect(texture.transparent).toBe(false);
|
||||
});
|
||||
|
||||
it('loads texture with checkTransparency flag', async () => {
|
||||
it("loads texture with checkTransparency flag", async () => {
|
||||
const options = {
|
||||
checkTransparency : true
|
||||
checkTransparency: true,
|
||||
};
|
||||
const texture = await loadTexture(transparentTexturePath, options);
|
||||
expect(texture.transparent).toBe(true);
|
||||
});
|
||||
|
||||
it('loads and decodes png', async () => {
|
||||
it("loads and decodes png", async () => {
|
||||
const options = {
|
||||
decode : true
|
||||
decode: true,
|
||||
};
|
||||
const texture = await loadTexture(pngTexturePath, options);
|
||||
expect(texture.pixels).toBeDefined();
|
||||
@ -87,9 +87,9 @@ describe('loadTexture', () => {
|
||||
expect(texture.height).toBe(211);
|
||||
});
|
||||
|
||||
it('loads and decodes jpeg', async () => {
|
||||
it("loads and decodes jpeg", async () => {
|
||||
const options = {
|
||||
decode : true
|
||||
decode: true,
|
||||
};
|
||||
const texture = await loadTexture(jpegTexturePath, options);
|
||||
expect(texture.pixels).toBeDefined();
|
||||
|
||||
@ -1,91 +1,93 @@
|
||||
'use strict';
|
||||
const { DeveloperError } = require('cesium');
|
||||
const fsExtra = require('fs-extra');
|
||||
const path = require('path');
|
||||
const Promise = require('bluebird');
|
||||
const createGltf = require('../../lib/createGltf');
|
||||
const obj2gltf = require('../../lib/obj2gltf');
|
||||
"use strict";
|
||||
const { DeveloperError } = require("cesium");
|
||||
const fsExtra = require("fs-extra");
|
||||
const path = require("path");
|
||||
const Promise = require("bluebird");
|
||||
const createGltf = require("../../lib/createGltf");
|
||||
const obj2gltf = require("../../lib/obj2gltf");
|
||||
|
||||
const texturedObjPath = 'specs/data/box-textured/box-textured.obj';
|
||||
const complexObjPath = 'specs/data/box-complex-material/box-complex-material.obj';
|
||||
const missingMtllibObjPath = 'specs/data/box-missing-mtllib/box-missing-mtllib.obj';
|
||||
const texturedObjPath = "specs/data/box-textured/box-textured.obj";
|
||||
const complexObjPath =
|
||||
"specs/data/box-complex-material/box-complex-material.obj";
|
||||
const missingMtllibObjPath =
|
||||
"specs/data/box-missing-mtllib/box-missing-mtllib.obj";
|
||||
|
||||
const outputDirectory = 'output';
|
||||
const outputDirectory = "output";
|
||||
|
||||
const textureUrl = 'specs/data/box-textured/cesium.png';
|
||||
const textureUrl = "specs/data/box-textured/cesium.png";
|
||||
|
||||
describe('obj2gltf', () => {
|
||||
describe("obj2gltf", () => {
|
||||
beforeEach(() => {
|
||||
spyOn(fsExtra, 'outputFile').and.returnValue(Promise.resolve());
|
||||
spyOn(fsExtra, "outputFile").and.returnValue(Promise.resolve());
|
||||
});
|
||||
|
||||
it('converts obj to gltf', async () => {
|
||||
it("converts obj to gltf", async () => {
|
||||
const gltf = await obj2gltf(texturedObjPath);
|
||||
expect(gltf).toBeDefined();
|
||||
expect(gltf.images.length).toBe(1);
|
||||
});
|
||||
|
||||
it('converts obj to glb', async () => {
|
||||
it("converts obj to glb", async () => {
|
||||
const options = {
|
||||
binary : true
|
||||
binary: true,
|
||||
};
|
||||
const glb = await obj2gltf(texturedObjPath, options);
|
||||
const magic = glb.toString('utf8', 0, 4);
|
||||
expect(magic).toBe('glTF');
|
||||
const magic = glb.toString("utf8", 0, 4);
|
||||
expect(magic).toBe("glTF");
|
||||
});
|
||||
|
||||
it('convert obj to gltf with separate resources', async () => {
|
||||
it("convert obj to gltf with separate resources", async () => {
|
||||
const options = {
|
||||
separate : true,
|
||||
separateTextures : true,
|
||||
outputDirectory : outputDirectory
|
||||
separate: true,
|
||||
separateTextures: true,
|
||||
outputDirectory: outputDirectory,
|
||||
};
|
||||
await obj2gltf(texturedObjPath, options);
|
||||
expect(fsExtra.outputFile.calls.count()).toBe(2); // Saves out .png and .bin
|
||||
});
|
||||
|
||||
it('convert obj to gltf with separate resources when buffer exceeds Node limit', async () => {
|
||||
spyOn(createGltf, '_getBufferMaxByteLength').and.returnValue(0);
|
||||
it("convert obj to gltf with separate resources when buffer exceeds Node limit", async () => {
|
||||
spyOn(createGltf, "_getBufferMaxByteLength").and.returnValue(0);
|
||||
const options = {
|
||||
separate : true,
|
||||
separateTextures : true,
|
||||
outputDirectory : outputDirectory
|
||||
separate: true,
|
||||
separateTextures: true,
|
||||
outputDirectory: outputDirectory,
|
||||
};
|
||||
await obj2gltf(texturedObjPath, options);
|
||||
expect(fsExtra.outputFile.calls.count()).toBe(5); // Saves out .png and four .bin for positions, normals, uvs, and indices
|
||||
});
|
||||
|
||||
it('converts obj to glb with separate resources', async () => {
|
||||
it("converts obj to glb with separate resources", async () => {
|
||||
const options = {
|
||||
separate : true,
|
||||
separateTextures : true,
|
||||
outputDirectory : outputDirectory,
|
||||
binary : true
|
||||
separate: true,
|
||||
separateTextures: true,
|
||||
outputDirectory: outputDirectory,
|
||||
binary: true,
|
||||
};
|
||||
await obj2gltf(texturedObjPath, options);
|
||||
expect(fsExtra.outputFile.calls.count()).toBe(2); // Saves out .png and .bin
|
||||
});
|
||||
|
||||
it('converts obj with multiple textures', async () => {
|
||||
it("converts obj with multiple textures", async () => {
|
||||
const options = {
|
||||
separateTextures : true,
|
||||
outputDirectory : outputDirectory
|
||||
separateTextures: true,
|
||||
outputDirectory: outputDirectory,
|
||||
};
|
||||
await obj2gltf(complexObjPath, options);
|
||||
expect(fsExtra.outputFile.calls.count()).toBe(5); // baseColor, metallicRoughness, occlusion, emission, normal
|
||||
});
|
||||
|
||||
it('sets overriding textures (1)', async () => {
|
||||
it("sets overriding textures (1)", async () => {
|
||||
const options = {
|
||||
overridingTextures : {
|
||||
metallicRoughnessOcclusionTexture : textureUrl,
|
||||
normalTexture : textureUrl,
|
||||
baseColorTexture : textureUrl,
|
||||
emissiveTexture : textureUrl,
|
||||
alphaTexture : textureUrl
|
||||
overridingTextures: {
|
||||
metallicRoughnessOcclusionTexture: textureUrl,
|
||||
normalTexture: textureUrl,
|
||||
baseColorTexture: textureUrl,
|
||||
emissiveTexture: textureUrl,
|
||||
alphaTexture: textureUrl,
|
||||
},
|
||||
separateTextures : true,
|
||||
outputDirectory : outputDirectory
|
||||
separateTextures: true,
|
||||
outputDirectory: outputDirectory,
|
||||
};
|
||||
await obj2gltf(complexObjPath, options);
|
||||
const args = fsExtra.outputFile.calls.allArgs();
|
||||
@ -95,18 +97,18 @@ describe('obj2gltf', () => {
|
||||
}
|
||||
});
|
||||
|
||||
it('sets overriding textures (2)', async () => {
|
||||
it("sets overriding textures (2)", async () => {
|
||||
const options = {
|
||||
overridingTextures : {
|
||||
specularGlossinessTexture : textureUrl,
|
||||
occlusionTexture : textureUrl,
|
||||
normalTexture : textureUrl,
|
||||
baseColorTexture : textureUrl,
|
||||
emissiveTexture : textureUrl,
|
||||
alphaTexture : textureUrl
|
||||
overridingTextures: {
|
||||
specularGlossinessTexture: textureUrl,
|
||||
occlusionTexture: textureUrl,
|
||||
normalTexture: textureUrl,
|
||||
baseColorTexture: textureUrl,
|
||||
emissiveTexture: textureUrl,
|
||||
alphaTexture: textureUrl,
|
||||
},
|
||||
separateTextures : true,
|
||||
outputDirectory : outputDirectory
|
||||
separateTextures: true,
|
||||
outputDirectory: outputDirectory,
|
||||
};
|
||||
await obj2gltf(complexObjPath, options);
|
||||
const args = fsExtra.outputFile.calls.allArgs();
|
||||
@ -116,46 +118,46 @@ describe('obj2gltf', () => {
|
||||
}
|
||||
});
|
||||
|
||||
it('uses a custom logger', async () => {
|
||||
it("uses a custom logger", async () => {
|
||||
let lastMessage;
|
||||
const options = {
|
||||
logger : (message) => {
|
||||
logger: (message) => {
|
||||
lastMessage = message;
|
||||
}
|
||||
},
|
||||
};
|
||||
await obj2gltf(missingMtllibObjPath, options);
|
||||
expect(lastMessage.indexOf('Could not read material file') >= 0).toBe(true);
|
||||
expect(lastMessage.indexOf("Could not read material file") >= 0).toBe(true);
|
||||
});
|
||||
|
||||
it('uses a custom writer', async () => {
|
||||
it("uses a custom writer", async () => {
|
||||
const filePaths = [];
|
||||
const fileContents = [];
|
||||
const options = {
|
||||
separate : true,
|
||||
writer : (relativePath, contents) => {
|
||||
separate: true,
|
||||
writer: (relativePath, contents) => {
|
||||
filePaths.push(relativePath);
|
||||
fileContents.push(contents);
|
||||
}
|
||||
},
|
||||
};
|
||||
await obj2gltf(texturedObjPath, options);
|
||||
expect(filePaths).toEqual(['cesium.png', 'box-textured.bin']);
|
||||
expect(filePaths).toEqual(["cesium.png", "box-textured.bin"]);
|
||||
expect(fileContents[0]).toBeDefined();
|
||||
expect(fileContents[1]).toBeDefined();
|
||||
});
|
||||
|
||||
it('throws if objPath is undefined', () => {
|
||||
it("throws if objPath is undefined", () => {
|
||||
let thrownError;
|
||||
try {
|
||||
obj2gltf(undefined);
|
||||
} catch (e) {
|
||||
thrownError = e;
|
||||
}
|
||||
expect(thrownError).toEqual(new DeveloperError('objPath is required'));
|
||||
expect(thrownError).toEqual(new DeveloperError("objPath is required"));
|
||||
});
|
||||
|
||||
it('throws if both options.writer and options.outputDirectory are undefined when writing separate resources', () => {
|
||||
it("throws if both options.writer and options.outputDirectory are undefined when writing separate resources", () => {
|
||||
const options = {
|
||||
separateTextures : true
|
||||
separateTextures: true,
|
||||
};
|
||||
|
||||
let thrownError;
|
||||
@ -164,13 +166,17 @@ describe('obj2gltf', () => {
|
||||
} catch (e) {
|
||||
thrownError = e;
|
||||
}
|
||||
expect(thrownError).toEqual(new DeveloperError('Either options.writer or options.outputDirectory must be defined when writing separate resources.'));
|
||||
expect(thrownError).toEqual(
|
||||
new DeveloperError(
|
||||
"Either options.writer or options.outputDirectory must be defined when writing separate resources."
|
||||
)
|
||||
);
|
||||
});
|
||||
|
||||
it('throws if more than one material type is set', () => {
|
||||
it("throws if more than one material type is set", () => {
|
||||
const options = {
|
||||
metallicRoughness : true,
|
||||
specularGlossiness : true
|
||||
metallicRoughness: true,
|
||||
specularGlossiness: true,
|
||||
};
|
||||
|
||||
let thrownError;
|
||||
@ -179,15 +185,19 @@ describe('obj2gltf', () => {
|
||||
} catch (e) {
|
||||
thrownError = e;
|
||||
}
|
||||
expect(thrownError).toEqual(new DeveloperError('Only one material type may be set from [metallicRoughness, specularGlossiness, unlit].'));
|
||||
expect(thrownError).toEqual(
|
||||
new DeveloperError(
|
||||
"Only one material type may be set from [metallicRoughness, specularGlossiness, unlit]."
|
||||
)
|
||||
);
|
||||
});
|
||||
|
||||
it('throws if metallicRoughnessOcclusionTexture and specularGlossinessTexture are both defined', () => {
|
||||
it("throws if metallicRoughnessOcclusionTexture and specularGlossinessTexture are both defined", () => {
|
||||
const options = {
|
||||
overridingTextures : {
|
||||
metallicRoughnessOcclusionTexture : textureUrl,
|
||||
specularGlossinessTexture : textureUrl
|
||||
}
|
||||
overridingTextures: {
|
||||
metallicRoughnessOcclusionTexture: textureUrl,
|
||||
specularGlossinessTexture: textureUrl,
|
||||
},
|
||||
};
|
||||
|
||||
let thrownError;
|
||||
@ -196,6 +206,10 @@ describe('obj2gltf', () => {
|
||||
} catch (e) {
|
||||
thrownError = e;
|
||||
}
|
||||
expect(thrownError).toEqual(new DeveloperError('metallicRoughnessOcclusionTexture and specularGlossinessTexture cannot both be defined.'));
|
||||
expect(thrownError).toEqual(
|
||||
new DeveloperError(
|
||||
"metallicRoughnessOcclusionTexture and specularGlossinessTexture cannot both be defined."
|
||||
)
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
Loading…
Reference in New Issue
Block a user