djsundog/obj2gltf
1
0
Fork 0
mirror of https://github.com/CesiumGS/obj2gltf.git synced 2024-11-23 08:34:14 -05:00
Code Issues Packages Projects Releases Wiki Activity

Run prettier

Browse Source
This commit is contained in:
Sean Lilley 2021-08-02 11:31:59 -04:00
parent bd4b7320fa
commit dc3ec3074f
24 changed files with 4965 additions and 4137 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

131
CHANGES.md
View File

@ -1,147 +1,146 @@
Change Log # Change Log
==========
### 3.?.? - 2021-??-?? ### 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) - 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) - 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 ### 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 ### 3.1.0 - 2020-03-13
* Added back `inputUpAxis` and `outputUpAxis`. [#211](https://github.com/CesiumGS/obj2gltf/pull/211) - 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 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 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) - Fixed parsing faces that reference non-existing attributes. [#218](https://github.com/CesiumGS/obj2gltf/pull/218)
### 3.0.4 - 2019-07-22 ### 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 ### 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 ### 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 ### 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 ### 3.0.0 2018-12-05
* Breaking changes - 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) - 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 ### 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) - 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) - 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 parsing of faces with mismatching attributes. [#161](https://github.com/CesiumGS/obj2gltf/pull/161)
### 2.3.1 2018-10-16 ### 2.3.1 2018-10-16
* Improved parsing models with concave or n-sided faces. [#157](https://github.com/CesiumGS/obj2gltf/pull/157) - 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) - Fixed handling of objs with interleaved materials. [#155](https://github.com/CesiumGS/obj2gltf/pull/155)
### 2.3.0 2018-09-19 ### 2.3.0 2018-09-19
* Fixed handling of objs with mismatching attribute layouts. [#153](https://github.com/CesiumGS/obj2gltf/pull/153) - 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) - 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) - 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 unnormalized input normals. [#136](https://github.com/CesiumGS/obj2gltf/pull/136)
### 2.2.0 2018-01-29 ### 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) - 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) - 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 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 output name when running from the command line. [#126](https://github.com/CesiumGS/obj2gltf/pull/126)
### 2.1.0 2017-12-28 ### 2.1.0 2017-12-28
* Fixed loading faces that contain less than 3 vertices. [#120](https://github.com/CesiumGS/obj2gltf/pull/120) - 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) - 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 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 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) - 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) - 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) - 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 ### 2.0.0 2017-08-11
* Breaking changes - 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). - 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 `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. - 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. - `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 ### 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 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 line breaks. [#85](https://github.com/CesiumGS/obj2gltf/pull/85)
### 1.2.0 2017-07-11 ### 1.2.0 2017-07-11
* Change texture sampling to use `NEAREST_MIPMAP_LINEAR` by default. [#83](https://github.com/CesiumGS/obj2gltf/pull/83). - 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) - Fixed lighting when generating normals. [#89](https://github.com/CesiumGS/obj2gltf/pull/89)
### 1.1.1 2017-04-25 ### 1.1.1 2017-04-25
* Fixed `CHANGES.md` formatting. - Fixed `CHANGES.md` formatting.
### 1.1.0 2017-04-25 ### 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) - 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 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) - 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 ### 1.0.0 2017-04-13
* Breaking changes - 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)`. - 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. - Many library options and command-line parameters have been renamed.
* Project cleanup. [#49](https://github.com/CesiumGS/obj2gltf/pull/49) - Project cleanup. [#49](https://github.com/CesiumGS/obj2gltf/pull/49)
* Speed improvements, especially for larger models. - Speed improvements, especially for larger models.
* Preserves the objects and groups in the obj. - Preserves the objects and groups in the obj.
* Added documentation and tests. - Added documentation and tests.
* Material fixes. - Material fixes.
### 0.1.7 2017-01-06 ### 0.1.7 2017-01-06
* Update gltf-pipeline to 0.1.0-alpha9 - Update gltf-pipeline to 0.1.0-alpha9
* Added command to generate documentation (npm run jsdoc) - Added command to generate documentation (npm run jsdoc)
### 0.1.6 2016-09-07 ### 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 ### 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 ### 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 ### 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 ### 0.1.2 - 2016-07-25
* Converted the API to now use promises instead of callbacks. [#21](https://github.com/CesiumGS/OBJ2GLTF/pull/21) - 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. - 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 ### 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 ### 0.1.0 - 2016-07-20
* Initial release. - Initial release.

320
LICENSE.md
View File

@ -4,180 +4,180 @@ Copyright 2016-2020 Cesium GS, Inc. and Contributors
Version 2.0, January 2004 Version 2.0, January 2004
http://www.apache.org/licenses/ 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, "License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document. and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by "Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License. the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all "Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition, control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the "control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity. outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity "You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License. exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications, "Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation including but not limited to software source code, documentation
source, and configuration files. source, and configuration files.
"Object" form shall mean any form resulting from mechanical "Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation, not limited to compiled object code, generated documentation,
and conversions to other media types. and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or "Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work copyright notice that is included in or attached to the work
(an example is provided in the Appendix below). (an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object "Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of, separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof. the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including "Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted" the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems, communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution." designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity "Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work. 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, this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of, copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form. 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, this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made, (except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work, use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s) Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate granted to You under this License for that Work shall terminate
as of the date such litigation is filed. 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 Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You modifications, and in Source or Object form, provided that You
meet the following conditions: meet the following conditions:
(a) You must give any other recipients of the Work or (a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices (b) You must cause any modified files to carry prominent notices
stating that You changed the files; and stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works (c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work, attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of excluding those notices that do not pertain to any part of
the Derivative Works; and the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its (d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or, documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed that such additional attribution notices cannot be construed
as modifying the License. as modifying the License.
You may add Your own copyright statement to Your modifications and You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use, for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License. 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 any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions. this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions. 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, names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file. 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 agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS, Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License. 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, whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special, liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill, Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages. 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, the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity, and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify, of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability. 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 To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "{}" 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 same "printed page" as the copyright notice for easier
identification within third-party archives. 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"); Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License. you may not use this file except in compliance with the License.
You may obtain a copy of the License at You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0 http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS, distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and See the License for the specific language governing permissions and
limitations under the License. limitations under the License.
# Third-Party Code
Third-Party Code
================
obj2gltf includes the following third-party code. obj2gltf includes the following third-party code.
@ -226,7 +224,7 @@ obj2gltf includes the following third-party code.
> >
> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR > THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, > IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE > FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER > AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, > LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN > OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

126
README.md
View File

@ -5,6 +5,7 @@ Convert OBJ assets to [glTF](https://www.khronos.org/gltf) 2.0.
## Getting Started ## Getting Started
Install [Node.js](https://nodejs.org/en/) if you don't already have it, and then: Install [Node.js](https://nodejs.org/en/) if you don't already have it, and then:
``` ```
npm install -g obj2gltf npm install -g obj2gltf
``` ```
@ -22,27 +23,25 @@ npm install -g obj2gltf
#### Converting an obj model to gltf: #### Converting an obj model to gltf:
```javascript ```javascript
const obj2gltf = require('obj2gltf'); const obj2gltf = require("obj2gltf");
const fs = require('fs'); const fs = require("fs");
obj2gltf('model.obj') obj2gltf("model.obj").then(function (gltf) {
.then(function(gltf) { const data = Buffer.from(JSON.stringify(gltf));
const data = Buffer.from(JSON.stringify(gltf)); fs.writeFileSync("model.gltf", data);
fs.writeFileSync('model.gltf', data); });
});
``` ```
#### Converting an obj model to glb #### Converting an obj model to glb
```javascript ```javascript
const obj2gltf = require('obj2gltf'); const obj2gltf = require("obj2gltf");
const fs = require('fs'); const fs = require("fs");
const options = { const options = {
binary : true binary: true,
} };
obj2gltf('model.obj', options) obj2gltf("model.obj", options).then(function (glb) {
.then(function(glb) { fs.writeFileSync("model.glb", glb);
fs.writeFileSync('model.glb', glb); });
});
``` ```
## Material types ## Material types
@ -52,9 +51,9 @@ materials.
There are three shading models supported by `obj2gltf`: There are three shading models supported by `obj2gltf`:
* Metallic roughness PBR - Metallic roughness PBR
* Specular glossiness PBR (via `KHR_materials_pbrSpecularGlossiness` extension) - Specular glossiness PBR (via `KHR_materials_pbrSpecularGlossiness` extension)
* Unlit materials (via `KHR_materials_unlit` extension) - Unlit materials (via `KHR_materials_unlit` extension)
If the material type is known in advance, it should be specified with either the `metallicRoughness` or `specularGlossiness` flag. If the material type is known in advance, it should be specified with either the `metallicRoughness` or `specularGlossiness` flag.
@ -71,72 +70,79 @@ As a convenience the PBR textures may be supplied directly to the command line.
**Mapping of mtl slots to shading models** **Mapping of mtl slots to shading models**
|Slot| Metallic roughness|Specular glossiness| | Slot | Metallic roughness | Specular glossiness |
|----|-------------------|-------------------| | -------- | ------------------ | ------------------- |
|Ka|occlusion value|occlusion value| | Ka | occlusion value | occlusion value |
|Ke|emissive color|emissive color| | Ke | emissive color | emissive color |
|Kd|base color|diffuse color| | Kd | base color | diffuse color |
|Ks|metallic value|specular color| | Ks | metallic value | specular color |
|Ns|roughness value|glossiness value| | Ns | roughness value | glossiness value |
|d|alpha|alpha| | d | alpha | alpha |
|Tr|1.0 - alpha|1.0 - alpha| | Tr | 1.0 - alpha | 1.0 - alpha |
|map_Ka|occlusion texture|occlusion texture| | map_Ka | occlusion texture | occlusion texture |
|map_Ke|emissive texture|emissive texture| | map_Ke | emissive texture | emissive texture |
|map_Kd|base color texture|diffuse texture| | map_Kd | base color texture | diffuse texture |
|map_Ks|metallic texture|specular texture| | map_Ks | metallic texture | specular texture |
|map_Ns|roughness texture|glossiness texture| | map_Ns | roughness texture | glossiness texture |
|map_Bump|normal texture|normal texture| | map_Bump | normal texture | normal texture |
## Usage ## Usage
### Command line flags: ### Command line flags:
|Flag|Description|Required| | Flag | Description | Required |
|----|-----------|--------| | --------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------- |
|`-h`, `--help`|Display help.|No| | `-h`, `--help` | Display help. | No |
|`-i`, `--input`|Path to the obj file.| :white_check_mark: Yes| | `-i`, `--input` | Path to the obj file. | :white_check_mark: Yes |
|`-o`, `--output`|Path of the converted glTF or glb file.|No| | `-o`, `--output` | Path of the converted glTF or glb file. | No |
|`-b`, `--binary`|Save as binary glTF (.glb).|No, default `false`| | `-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`| | `-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`| | `-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`| | `--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`| | `--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`| | `--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`| | `--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`| | `--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`| | `--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| | `--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| | `--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| | `--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| | `--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| | `--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| | `--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| | `--alphaTexture` | Path to the alpha texture that should override textures in the .mtl file. | No |
|`--input-up-axis`|Up axis of the obj.|No| | `--input-up-axis` | Up axis of the obj. | No |
|`--output-up-axis`|Up axis of the converted glTF.|No| | `--output-up-axis` | Up axis of the converted glTF. | No |
|`--triangle-winding-order-sanitization`|Apply triangle winding order sanitization.|No| | `--triangle-winding-order-sanitization` | Apply triangle winding order sanitization. | No |
## Build Instructions ## Build Instructions
Run the tests: Run the tests:
``` ```
npm run test npm run test
``` ```
To run ESLint on the entire codebase, run: To run ESLint on the entire codebase, run:
``` ```
npm run eslint npm run eslint
``` ```
To run ESLint automatically when a file is saved, run the following and leave it open in a console window: To run ESLint automatically when a file is saved, run the following and leave it open in a console window:
``` ```
npm run eslint-watch npm run eslint-watch
``` ```
## Running Test Coverage ## Running Test Coverage
Coverage uses [nyc](https://github.com/istanbuljs/nyc). Run: Coverage uses [nyc](https://github.com/istanbuljs/nyc). Run:
``` ```
npm run coverage npm run coverage
``` ```
For complete coverage details, open `coverage/lcov-report/index.html`. 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. 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 ## Generating Documentation
To generate the documentation: To generate the documentation:
``` ```
npm run jsdoc npm run jsdoc
``` ```
@ -152,11 +159,12 @@ The documentation will be placed in the `doc` folder.
## Contributions ## Contributions
Pull requests are appreciated. Please use the same [Contributor License Agreement (CLA)](https://github.com/CesiumGS/cesium/blob/main/CONTRIBUTING.md) used for [CesiumJS](https://cesium.com/cesiumjs/). Pull requests are appreciated. Please use the same [Contributor License Agreement (CLA)](https://github.com/CesiumGS/cesium/blob/main/CONTRIBUTING.md) used for [CesiumJS](https://cesium.com/cesiumjs/).
--- ---
Developed by the Cesium team. Developed by the Cesium team.
<p align="center"> <p align="center">
<a href="https://cesium.com/"><img src="doc/cesium.png" onerror="this.src='cesium.png'"/></a> <a href="https://cesium.com/"><img src="doc/cesium.png" onerror="this.src='cesium.png'"/></a>
</p> </p>

390
bin/obj2gltf.js
View File

@ -1,10 +1,10 @@
#!/usr/bin/env node #!/usr/bin/env node
'use strict'; "use strict";
const Cesium = require('cesium'); const Cesium = require("cesium");
const fsExtra = require('fs-extra'); const fsExtra = require("fs-extra");
const path = require('path'); const path = require("path");
const yargs = require('yargs'); const yargs = require("yargs");
const obj2gltf = require('../lib/obj2gltf'); const obj2gltf = require("../lib/obj2gltf");
const defaultValue = Cesium.defaultValue; const defaultValue = Cesium.defaultValue;
const defined = Cesium.defined; const defined = Cesium.defined;
@ -14,148 +14,170 @@ const defaults = obj2gltf.defaults;
const args = process.argv; const args = process.argv;
const argv = yargs const argv = yargs
.usage('Usage: node $0 -i inputPath -o outputPath') .usage("Usage: node $0 -i inputPath -o outputPath")
.example('node $0 -i ./specs/data/box/box.obj -o box.gltf') .example("node $0 -i ./specs/data/box/box.obj -o box.gltf")
.help('h') .help("h")
.alias('h', 'help') .alias("h", "help")
.options({ .options({
input : { input: {
alias : 'i', alias: "i",
describe : 'Path to the obj file.', describe: "Path to the obj file.",
type : 'string', type: "string",
demandOption : true, demandOption: true,
coerce : function (p) { coerce: function (p) {
if (!defined(p)) { if (!defined(p)) {
return undefined; return undefined;
}
if (p.length === 0) {
throw new Error('Input path must be a file name');
}
return path.resolve(p);
}
},
output : {
alias : 'o',
describe : 'Path of the converted glTF or glb file.',
type : 'string',
coerce : function (p) {
if (!defined(p)) {
return undefined;
}
if (p.length === 0) {
throw new Error('Output path must be a file name');
}
return path.resolve(p);
}
},
binary : {
alias : 'b',
describe : 'Save as binary glTF (.glb)',
type : 'boolean',
default : defaults.binary
},
separate : {
alias : 's',
describe : 'Write separate buffers and textures instead of embedding them in the glTF.',
type : 'boolean',
default : defaults.separate
},
separateTextures : {
alias : 't',
describe : 'Write out separate textures only.',
type : 'boolean',
default : defaults.separateTextures
},
checkTransparency : {
describe : 'Do a more exhaustive check for texture transparency by looking at the alpha channel of each pixel. By default textures are considered to be opaque.',
type : 'boolean',
default : defaults.checkTransparency
},
secure : {
describe : 'Prevent the converter from reading textures or mtl files outside of the input obj directory.',
type : 'boolean',
default : defaults.secure
},
packOcclusion : {
describe : 'Pack the occlusion texture in the red channel of metallic-roughness texture.',
type : 'boolean',
default : defaults.packOcclusion
},
metallicRoughness : {
describe : 'The values in the .mtl file are already metallic-roughness PBR values and no conversion step should be applied. Metallic is stored in the Ks and map_Ks slots and roughness is stored in the Ns and map_Ns slots.',
type : 'boolean',
default : defaults.metallicRoughness
},
specularGlossiness : {
describe : 'The values in the .mtl file are already specular-glossiness PBR values and no conversion step should be applied. Specular is stored in the Ks and map_Ks slots and glossiness is stored in the Ns and map_Ns slots. The glTF will be saved with the KHR_materials_pbrSpecularGlossiness extension.',
type : 'boolean',
default : defaults.specularGlossiness
},
unlit : {
describe : 'The glTF will be saved with the KHR_materials_unlit extension.',
type : 'boolean',
default : defaults.unlit
},
metallicRoughnessOcclusionTexture : {
describe : 'Path to the metallic-roughness-occlusion texture that should override textures in the .mtl file, where occlusion is stored in the red channel, roughness is stored in the green channel, and metallic is stored in the blue channel. The model will be saved with a pbrMetallicRoughness material. This is often convenient in workflows where the .mtl does not exist or is not set up to use PBR materials. Intended for models with a single material',
type : 'string',
normalize : true
},
specularGlossinessTexture : {
describe : 'Path to the specular-glossiness texture that should override textures in the .mtl file, where specular color is stored in the red, green, and blue channels and specular glossiness is stored in the alpha channel. The model will be saved with a material using the KHR_materials_pbrSpecularGlossiness extension.',
type : 'string',
normalize : true
},
occlusionTexture : {
describe : 'Path to the occlusion texture that should override textures in the .mtl file.',
type : 'string',
normalize : true
},
normalTexture : {
describe : 'Path to the normal texture that should override textures in the .mtl file.',
type : 'string',
normalize : true
},
baseColorTexture : {
describe : 'Path to the baseColor/diffuse texture that should override textures in the .mtl file.',
type : 'string',
normalize : true
},
emissiveTexture : {
describe : 'Path to the emissive texture that should override textures in the .mtl file.',
type : 'string',
normalize : true
},
alphaTexture : {
describe : 'Path to the alpha texture that should override textures in the .mtl file.'
},
inputUpAxis : {
describe: 'Up axis of the obj.',
choices: ['X', 'Y', 'Z'],
type: 'string',
default: 'Y'
},
outputUpAxis : {
describe: 'Up axis of the converted glTF.',
choices: ['X', 'Y', 'Z'],
type: 'string',
default: 'Y'
},
triangleWindingOrderSanitization : {
describe: 'Apply triangle winding order sanitization.',
type: 'boolean',
default: defaults.triangleWindingOrderSanitization
} }
}).parse(args); if (p.length === 0) {
throw new Error("Input path must be a file name");
}
return path.resolve(p);
},
},
output: {
alias: "o",
describe: "Path of the converted glTF or glb file.",
type: "string",
coerce: function (p) {
if (!defined(p)) {
return undefined;
}
if (p.length === 0) {
throw new Error("Output path must be a file name");
}
return path.resolve(p);
},
},
binary: {
alias: "b",
describe: "Save as binary glTF (.glb)",
type: "boolean",
default: defaults.binary,
},
separate: {
alias: "s",
describe:
"Write separate buffers and textures instead of embedding them in the glTF.",
type: "boolean",
default: defaults.separate,
},
separateTextures: {
alias: "t",
describe: "Write out separate textures only.",
type: "boolean",
default: defaults.separateTextures,
},
checkTransparency: {
describe:
"Do a more exhaustive check for texture transparency by looking at the alpha channel of each pixel. By default textures are considered to be opaque.",
type: "boolean",
default: defaults.checkTransparency,
},
secure: {
describe:
"Prevent the converter from reading textures or mtl files outside of the input obj directory.",
type: "boolean",
default: defaults.secure,
},
packOcclusion: {
describe:
"Pack the occlusion texture in the red channel of metallic-roughness texture.",
type: "boolean",
default: defaults.packOcclusion,
},
metallicRoughness: {
describe:
"The values in the .mtl file are already metallic-roughness PBR values and no conversion step should be applied. Metallic is stored in the Ks and map_Ks slots and roughness is stored in the Ns and map_Ns slots.",
type: "boolean",
default: defaults.metallicRoughness,
},
specularGlossiness: {
describe:
"The values in the .mtl file are already specular-glossiness PBR values and no conversion step should be applied. Specular is stored in the Ks and map_Ks slots and glossiness is stored in the Ns and map_Ns slots. The glTF will be saved with the KHR_materials_pbrSpecularGlossiness extension.",
type: "boolean",
default: defaults.specularGlossiness,
},
unlit: {
describe:
"The glTF will be saved with the KHR_materials_unlit extension.",
type: "boolean",
default: defaults.unlit,
},
metallicRoughnessOcclusionTexture: {
describe:
"Path to the metallic-roughness-occlusion texture that should override textures in the .mtl file, where occlusion is stored in the red channel, roughness is stored in the green channel, and metallic is stored in the blue channel. The model will be saved with a pbrMetallicRoughness material. This is often convenient in workflows where the .mtl does not exist or is not set up to use PBR materials. Intended for models with a single material",
type: "string",
normalize: true,
},
specularGlossinessTexture: {
describe:
"Path to the specular-glossiness texture that should override textures in the .mtl file, where specular color is stored in the red, green, and blue channels and specular glossiness is stored in the alpha channel. The model will be saved with a material using the KHR_materials_pbrSpecularGlossiness extension.",
type: "string",
normalize: true,
},
occlusionTexture: {
describe:
"Path to the occlusion texture that should override textures in the .mtl file.",
type: "string",
normalize: true,
},
normalTexture: {
describe:
"Path to the normal texture that should override textures in the .mtl file.",
type: "string",
normalize: true,
},
baseColorTexture: {
describe:
"Path to the baseColor/diffuse texture that should override textures in the .mtl file.",
type: "string",
normalize: true,
},
emissiveTexture: {
describe:
"Path to the emissive texture that should override textures in the .mtl file.",
type: "string",
normalize: true,
},
alphaTexture: {
describe:
"Path to the alpha texture that should override textures in the .mtl file.",
},
inputUpAxis: {
describe: "Up axis of the obj.",
choices: ["X", "Y", "Z"],
type: "string",
default: "Y",
},
outputUpAxis: {
describe: "Up axis of the converted glTF.",
choices: ["X", "Y", "Z"],
type: "string",
default: "Y",
},
triangleWindingOrderSanitization: {
describe: "Apply triangle winding order sanitization.",
type: "boolean",
default: defaults.triangleWindingOrderSanitization,
},
})
.parse(args);
if (argv.metallicRoughness + argv.specularGlossiness > 1) { if (argv.metallicRoughness + argv.specularGlossiness > 1) {
console.error('Only one material type may be set from [--metallicRoughness, --specularGlossiness].'); console.error(
process.exit(1); "Only one material type may be set from [--metallicRoughness, --specularGlossiness]."
);
process.exit(1);
} }
if (defined(argv.metallicRoughnessOcclusionTexture) && defined(argv.specularGlossinessTexture)) { if (
console.error('--metallicRoughnessOcclusionTexture and --specularGlossinessTexture cannot both be set.'); defined(argv.metallicRoughnessOcclusionTexture) &&
process.exit(1); defined(argv.specularGlossinessTexture)
) {
console.error(
"--metallicRoughnessOcclusionTexture and --specularGlossinessTexture cannot both be set."
);
process.exit(1);
} }
const objPath = argv.input; const objPath = argv.input;
@ -164,55 +186,55 @@ let gltfPath = argv.output;
const filename = defaultValue(gltfPath, objPath); const filename = defaultValue(gltfPath, objPath);
const name = path.basename(filename, path.extname(filename)); const name = path.basename(filename, path.extname(filename));
const outputDirectory = path.dirname(filename); const outputDirectory = path.dirname(filename);
const binary = argv.binary || path.extname(filename).toLowerCase() === '.glb'; const binary = argv.binary || path.extname(filename).toLowerCase() === ".glb";
const extension = binary ? '.glb' : '.gltf'; const extension = binary ? ".glb" : ".gltf";
gltfPath = path.join(outputDirectory, name + extension); gltfPath = path.join(outputDirectory, name + extension);
const overridingTextures = { const overridingTextures = {
metallicRoughnessOcclusionTexture : argv.metallicRoughnessOcclusionTexture, metallicRoughnessOcclusionTexture: argv.metallicRoughnessOcclusionTexture,
specularGlossinessTexture : argv.specularGlossinessTexture, specularGlossinessTexture: argv.specularGlossinessTexture,
occlusionTexture : argv.occlusionTexture, occlusionTexture: argv.occlusionTexture,
normalTexture : argv.normalTexture, normalTexture: argv.normalTexture,
baseColorTexture : argv.baseColorTexture, baseColorTexture: argv.baseColorTexture,
emissiveTexture : argv.emissiveTexture, emissiveTexture: argv.emissiveTexture,
alphaTexture : argv.alphaTexture alphaTexture: argv.alphaTexture,
}; };
const options = { const options = {
binary : binary, binary: binary,
separate : argv.separate, separate: argv.separate,
separateTextures : argv.separateTextures, separateTextures: argv.separateTextures,
checkTransparency : argv.checkTransparency, checkTransparency: argv.checkTransparency,
secure : argv.secure, secure: argv.secure,
packOcclusion : argv.packOcclusion, packOcclusion: argv.packOcclusion,
metallicRoughness : argv.metallicRoughness, metallicRoughness: argv.metallicRoughness,
specularGlossiness : argv.specularGlossiness, specularGlossiness: argv.specularGlossiness,
unlit : argv.unlit, unlit: argv.unlit,
overridingTextures : overridingTextures, overridingTextures: overridingTextures,
outputDirectory : outputDirectory, outputDirectory: outputDirectory,
inputUpAxis : argv.inputUpAxis, inputUpAxis: argv.inputUpAxis,
outputUpAxis : argv.outputUpAxis, outputUpAxis: argv.outputUpAxis,
triangleWindingOrderSanitization: argv.triangleWindingOrderSanitization triangleWindingOrderSanitization: argv.triangleWindingOrderSanitization,
}; };
console.time('Total'); console.time("Total");
obj2gltf(objPath, options) obj2gltf(objPath, options)
.then(function(gltf) { .then(function (gltf) {
if (binary) { if (binary) {
// gltf is a glb buffer // gltf is a glb buffer
return fsExtra.outputFile(gltfPath, gltf); return fsExtra.outputFile(gltfPath, gltf);
} }
const jsonOptions = { const jsonOptions = {
spaces : 2 spaces: 2,
}; };
return fsExtra.outputJson(gltfPath, gltf, jsonOptions); return fsExtra.outputJson(gltfPath, gltf, jsonOptions);
}) })
.then(function() { .then(function () {
console.timeEnd('Total'); console.timeEnd("Total");
}) })
.catch(function(error) { .catch(function (error) {
console.log(error.message); console.log(error.message);
process.exit(1); process.exit(1);
}); });

169
gulpfile.js
View File

@ -1,108 +1,119 @@
'use strict'; "use strict";
const Cesium = require('cesium'); const Cesium = require("cesium");
const Promise = require('bluebird'); const Promise = require("bluebird");
const child_process = require('child_process'); const child_process = require("child_process");
const fsExtra = require('fs-extra'); const fsExtra = require("fs-extra");
const gulp = require('gulp'); const gulp = require("gulp");
const Jasmine = require('jasmine'); const Jasmine = require("jasmine");
const JasmineSpecReporter = require('jasmine-spec-reporter').SpecReporter; const JasmineSpecReporter = require("jasmine-spec-reporter").SpecReporter;
const open = require('open'); const open = require("open");
const path = require('path'); const path = require("path");
const yargs = require('yargs'); const yargs = require("yargs");
const defined = Cesium.defined; const defined = Cesium.defined;
const argv = yargs.argv; const argv = yargs.argv;
// Add third-party node module binaries to the system path // Add third-party node module binaries to the system path
// since some tasks need to call them directly. // since some tasks need to call them directly.
const environmentSeparator = process.platform === 'win32' ? ';' : ':'; const environmentSeparator = process.platform === "win32" ? ";" : ":";
const nodeBinaries = path.join(__dirname, 'node_modules', '.bin'); const nodeBinaries = path.join(__dirname, "node_modules", ".bin");
process.env.PATH += environmentSeparator + nodeBinaries; process.env.PATH += environmentSeparator + nodeBinaries;
const specFiles = ['**/*.js', '!node_modules/**', '!coverage/**', '!doc/**', '!bin/**']; const specFiles = [
"**/*.js",
"!node_modules/**",
"!coverage/**",
"!doc/**",
"!bin/**",
];
module.exports = { module.exports = {
test: test, test: test,
'test-watch': testWatch, "test-watch": testWatch,
coverage: coverage, coverage: coverage,
cloc: cloc cloc: cloc,
}; };
function test(done) { function test(done) {
const jasmine = new Jasmine(); const jasmine = new Jasmine();
jasmine.loadConfigFile('specs/jasmine.json'); jasmine.loadConfigFile("specs/jasmine.json");
jasmine.addReporter(new JasmineSpecReporter({ jasmine.addReporter(
displaySuccessfulSpec: !defined(argv.suppressPassed) || !argv.suppressPassed new JasmineSpecReporter({
})); displaySuccessfulSpec:
jasmine.execute(); !defined(argv.suppressPassed) || !argv.suppressPassed,
jasmine.onComplete(function (passed) { })
done(argv.failTaskOnError && !passed ? 1 : 0); );
}); jasmine.execute();
jasmine.onComplete(function (passed) {
done(argv.failTaskOnError && !passed ? 1 : 0);
});
} }
function testWatch() { 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 // We can't simply depend on the test task because Jasmine
// does not like being run multiple times in the same process. // does not like being run multiple times in the same process.
try { try {
child_process.execSync('jasmine JASMINE_CONFIG_PATH=specs/jasmine.json', { child_process.execSync("jasmine JASMINE_CONFIG_PATH=specs/jasmine.json", {
stdio: [process.stdin, process.stdout, process.stderr] stdio: [process.stdin, process.stdout, process.stderr],
}); });
} catch (exception) { } catch (exception) {
console.log('Tests failed to execute.'); console.log("Tests failed to execute.");
} }
}); });
} }
async function coverage() { async function coverage() {
fsExtra.removeSync('coverage/server'); fsExtra.removeSync("coverage/server");
child_process.execSync('nyc' + child_process.execSync(
' --all' + "nyc" +
' --reporter=lcov' + " --all" +
' --dir coverage' + " --reporter=lcov" +
' -x "specs/**" -x "coverage/**" -x "doc/**" -x "bin/**" -x "index.js" -x "gulpfile.js"' + " --dir coverage" +
' node_modules/jasmine/bin/jasmine.js' + ' -x "specs/**" -x "coverage/**" -x "doc/**" -x "bin/**" -x "index.js" -x "gulpfile.js"' +
' JASMINE_CONFIG_PATH=specs/jasmine.json', { " node_modules/jasmine/bin/jasmine.js" +
stdio: [process.stdin, process.stdout, process.stderr] " JASMINE_CONFIG_PATH=specs/jasmine.json",
}); {
open('coverage/lcov-report/index.html'); stdio: [process.stdin, process.stdout, process.stderr],
}
);
open("coverage/lcov-report/index.html");
} }
function cloc() { function cloc() {
let cmdLine; 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 //Run cloc on primary Source files only
const source = new Promise(function(resolve, reject) { const source = new Promise(function (resolve, reject) {
cmdLine = 'perl ' + clocPath + ' --quiet --progress-rate=0' + cmdLine = "perl " + clocPath + " --quiet --progress-rate=0" + " lib/ bin/";
' lib/ bin/';
child_process.exec(cmdLine, function(error, stdout, stderr) { child_process.exec(cmdLine, function (error, stdout, stderr) {
if (error) { if (error) {
console.log(stderr); console.log(stderr);
return reject(error); return reject(error);
} }
console.log('Source:'); console.log("Source:");
console.log(stdout); console.log(stdout);
resolve(); resolve();
});
}); });
});
//If running cloc on source succeeded, also run it on the tests. //If running cloc on source succeeded, also run it on the tests.
return source.then(function() { return source.then(function () {
return new Promise(function(resolve, reject) { return new Promise(function (resolve, reject) {
cmdLine = 'perl ' + clocPath + ' --quiet --progress-rate=0' + cmdLine =
' specs/lib/'; "perl " + clocPath + " --quiet --progress-rate=0" + " specs/lib/";
child_process.exec(cmdLine, function(error, stdout, stderr) { child_process.exec(cmdLine, function (error, stdout, stderr) {
if (error) { if (error) {
console.log(stderr); console.log(stderr);
return reject(error); return reject(error);
} }
console.log('Specs:'); console.log("Specs:");
console.log(stdout); console.log(stdout);
resolve(); resolve();
}); });
});
}); });
});
} }

4
index.js
View File

@ -1,2 +1,2 @@
'use strict'; "use strict";
module.exports = require('./lib/obj2gltf'); module.exports = require("./lib/obj2gltf");

131
lib/ArrayStorage.js
View File

@ -1,5 +1,5 @@
'use strict'; "use strict";
const Cesium = require('cesium'); const Cesium = require("cesium");
const ComponentDatatype = Cesium.ComponentDatatype; const ComponentDatatype = Cesium.ComponentDatatype;
@ -18,89 +18,92 @@ const fixedExpansionLength = 33554432; // 2^25 (~134 MB for a Float32Array)
* @private * @private
*/ */
function ArrayStorage(componentDatatype) { function ArrayStorage(componentDatatype) {
this.componentDatatype = componentDatatype; this.componentDatatype = componentDatatype;
this.typedArray = ComponentDatatype.createTypedArray(componentDatatype, 0); this.typedArray = ComponentDatatype.createTypedArray(componentDatatype, 0);
this.length = 0; this.length = 0;
} }
function resize(storage, length) { function resize(storage, length) {
const typedArray = ComponentDatatype.createTypedArray(storage.componentDatatype, length); const typedArray = ComponentDatatype.createTypedArray(
typedArray.set(storage.typedArray); storage.componentDatatype,
storage.typedArray = typedArray; length
);
typedArray.set(storage.typedArray);
storage.typedArray = typedArray;
} }
ArrayStorage.prototype.push = function(value) { ArrayStorage.prototype.push = function (value) {
const length = this.length; const length = this.length;
const typedArrayLength = this.typedArray.length; const typedArrayLength = this.typedArray.length;
if (length === 0) { if (length === 0) {
resize(this, initialLength); resize(this, initialLength);
} else if (length === typedArrayLength) { } else if (length === typedArrayLength) {
if (length < doublingThreshold) { if (length < doublingThreshold) {
resize(this, typedArrayLength * 2); resize(this, typedArrayLength * 2);
} else { } else {
resize(this, typedArrayLength + fixedExpansionLength); resize(this, typedArrayLength + fixedExpansionLength);
}
} }
}
this.typedArray[this.length++] = value; this.typedArray[this.length++] = value;
}; };
ArrayStorage.prototype.get = function(index) { ArrayStorage.prototype.get = function (index) {
return this.typedArray[index]; return this.typedArray[index];
}; };
const sizeOfUint16 = 2; const sizeOfUint16 = 2;
const sizeOfUint32 = 4; const sizeOfUint32 = 4;
const sizeOfFloat = 4; const sizeOfFloat = 4;
ArrayStorage.prototype.toUint16Buffer = function() { ArrayStorage.prototype.toUint16Buffer = function () {
const length = this.length; const length = this.length;
const typedArray = this.typedArray; 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); const buffer = Buffer.alloc(paddedLength * sizeOfUint16);
for (let i = 0; i < length; ++i) { for (let i = 0; i < length; ++i) {
buffer.writeUInt16LE(typedArray[i], i * sizeOfUint16); buffer.writeUInt16LE(typedArray[i], i * sizeOfUint16);
} }
return buffer; return buffer;
}; };
ArrayStorage.prototype.toUint32Buffer = function() { ArrayStorage.prototype.toUint32Buffer = function () {
const length = this.length; const length = this.length;
const typedArray = this.typedArray; const typedArray = this.typedArray;
const buffer = Buffer.alloc(length * sizeOfUint32); const buffer = Buffer.alloc(length * sizeOfUint32);
for (let i = 0; i < length; ++i) { for (let i = 0; i < length; ++i) {
buffer.writeUInt32LE(typedArray[i], i * sizeOfUint32); buffer.writeUInt32LE(typedArray[i], i * sizeOfUint32);
} }
return buffer; return buffer;
}; };
ArrayStorage.prototype.toFloatBuffer = function() { ArrayStorage.prototype.toFloatBuffer = function () {
const length = this.length; const length = this.length;
const typedArray = this.typedArray; const typedArray = this.typedArray;
const buffer = Buffer.alloc(length * sizeOfFloat); const buffer = Buffer.alloc(length * sizeOfFloat);
for (let i = 0; i < length; ++i) { for (let i = 0; i < length; ++i) {
buffer.writeFloatLE(typedArray[i], i * sizeOfFloat); buffer.writeFloatLE(typedArray[i], i * sizeOfFloat);
} }
return buffer; return buffer;
}; };
ArrayStorage.prototype.getMinMax = function(components) { ArrayStorage.prototype.getMinMax = function (components) {
const length = this.length; const length = this.length;
const typedArray = this.typedArray; const typedArray = this.typedArray;
const count = length / components; const count = length / components;
const min = new Array(components).fill(Number.POSITIVE_INFINITY); const min = new Array(components).fill(Number.POSITIVE_INFINITY);
const max = new Array(components).fill(Number.NEGATIVE_INFINITY); const max = new Array(components).fill(Number.NEGATIVE_INFINITY);
for (let i = 0; i < count; ++i) { for (let i = 0; i < count; ++i) {
for (let j = 0; j < components; ++j) { for (let j = 0; j < components; ++j) {
const index = i * components + j; const index = i * components + j;
const value = typedArray[index]; const value = typedArray[index];
min[j] = Math.min(min[j], value); min[j] = Math.min(min[j], value);
max[j] = Math.max(max[j], value); max[j] = Math.max(max[j], value);
}
} }
return { }
min : min, return {
max : max min: min,
}; max: max,
};
}; };

18
lib/Texture.js
View File

@ -1,4 +1,4 @@
'use strict'; "use strict";
module.exports = Texture; module.exports = Texture;
@ -8,12 +8,12 @@ module.exports = Texture;
* @private * @private
*/ */
function Texture() { function Texture() {
this.transparent = false; this.transparent = false;
this.source = undefined; this.source = undefined;
this.name = undefined; this.name = undefined;
this.extension = undefined; this.extension = undefined;
this.path = undefined; this.path = undefined;
this.pixels = undefined; this.pixels = undefined;
this.width = undefined; this.width = undefined;
this.height = undefined; this.height = undefined;
} }

980
lib/createGltf.js
View File

File diff suppressed because it is too large Load Diff

20
lib/getBufferPadded.js
View File

@ -1,4 +1,4 @@
'use strict'; "use strict";
module.exports = getBufferPadded; module.exports = getBufferPadded;
/** /**
@ -10,13 +10,13 @@ module.exports = getBufferPadded;
* @private * @private
*/ */
function getBufferPadded(buffer) { function getBufferPadded(buffer) {
const boundary = 4; const boundary = 4;
const byteLength = buffer.length; const byteLength = buffer.length;
const remainder = byteLength % boundary; const remainder = byteLength % boundary;
if (remainder === 0) { if (remainder === 0) {
return buffer; return buffer;
} }
const padding = (remainder === 0) ? 0 : boundary - remainder; const padding = remainder === 0 ? 0 : boundary - remainder;
const emptyBuffer = Buffer.alloc(padding); const emptyBuffer = Buffer.alloc(padding);
return Buffer.concat([buffer, emptyBuffer]); return Buffer.concat([buffer, emptyBuffer]);
} }

24
lib/getJsonBufferPadded.js
View File

@ -1,4 +1,4 @@
'use strict'; "use strict";
module.exports = getJsonBufferPadded; module.exports = getJsonBufferPadded;
/** /**
@ -13,17 +13,17 @@ module.exports = getJsonBufferPadded;
* @private * @private
*/ */
function getJsonBufferPadded(json) { function getJsonBufferPadded(json) {
let string = JSON.stringify(json); let string = JSON.stringify(json);
const boundary = 4; const boundary = 4;
const byteLength = Buffer.byteLength(string); const byteLength = Buffer.byteLength(string);
const remainder = byteLength % boundary; const remainder = byteLength % boundary;
const padding = (remainder === 0) ? 0 : boundary - remainder; const padding = remainder === 0 ? 0 : boundary - remainder;
let whitespace = ''; let whitespace = "";
for (let i = 0; i < padding; ++i) { for (let i = 0; i < padding; ++i) {
whitespace += ' '; whitespace += " ";
} }
string += whitespace; string += whitespace;
return Buffer.from(string); return Buffer.from(string);
} }

72
lib/gltfToGlb.js
View File

@ -1,6 +1,6 @@
'use strict'; "use strict";
const Cesium = require('cesium'); const Cesium = require("cesium");
const getJsonBufferPadded = require('./getJsonBufferPadded'); const getJsonBufferPadded = require("./getJsonBufferPadded");
const defined = Cesium.defined; const defined = Cesium.defined;
@ -18,44 +18,44 @@ module.exports = gltfToGlb;
* @private * @private
*/ */
function gltfToGlb(gltf, binaryBuffer) { function gltfToGlb(gltf, binaryBuffer) {
const buffer = gltf.buffers[0]; const buffer = gltf.buffers[0];
if (defined(buffer.uri)) { if (defined(buffer.uri)) {
binaryBuffer = Buffer.alloc(0); binaryBuffer = Buffer.alloc(0);
} }
// Create padded binary scene string // Create padded binary scene string
const jsonBuffer = getJsonBufferPadded(gltf); const jsonBuffer = getJsonBufferPadded(gltf);
// Allocate buffer (Global header) + (JSON chunk header) + (JSON chunk) + (Binary chunk header) + (Binary chunk) // Allocate buffer (Global header) + (JSON chunk header) + (JSON chunk) + (Binary chunk header) + (Binary chunk)
const glbLength = 12 + 8 + jsonBuffer.length + 8 + binaryBuffer.length; const glbLength = 12 + 8 + jsonBuffer.length + 8 + binaryBuffer.length;
const glb = Buffer.alloc(glbLength); const glb = Buffer.alloc(glbLength);
// Write binary glTF header (magic, version, length) // Write binary glTF header (magic, version, length)
let byteOffset = 0; let byteOffset = 0;
glb.writeUInt32LE(0x46546C67, byteOffset); glb.writeUInt32LE(0x46546c67, byteOffset);
byteOffset += 4; byteOffset += 4;
glb.writeUInt32LE(2, byteOffset); glb.writeUInt32LE(2, byteOffset);
byteOffset += 4; byteOffset += 4;
glb.writeUInt32LE(glbLength, byteOffset); glb.writeUInt32LE(glbLength, byteOffset);
byteOffset += 4; byteOffset += 4;
// Write JSON Chunk header (length, type) // Write JSON Chunk header (length, type)
glb.writeUInt32LE(jsonBuffer.length, byteOffset); glb.writeUInt32LE(jsonBuffer.length, byteOffset);
byteOffset += 4; byteOffset += 4;
glb.writeUInt32LE(0x4E4F534A, byteOffset); // JSON glb.writeUInt32LE(0x4e4f534a, byteOffset); // JSON
byteOffset += 4; byteOffset += 4;
// Write JSON Chunk // Write JSON Chunk
jsonBuffer.copy(glb, byteOffset); jsonBuffer.copy(glb, byteOffset);
byteOffset += jsonBuffer.length; byteOffset += jsonBuffer.length;
// Write Binary Chunk header (length, type) // Write Binary Chunk header (length, type)
glb.writeUInt32LE(binaryBuffer.length, byteOffset); glb.writeUInt32LE(binaryBuffer.length, byteOffset);
byteOffset += 4; byteOffset += 4;
glb.writeUInt32LE(0x004E4942, byteOffset); // BIN glb.writeUInt32LE(0x004e4942, byteOffset); // BIN
byteOffset += 4; byteOffset += 4;
// Write Binary Chunk // Write Binary Chunk
binaryBuffer.copy(glb, byteOffset); binaryBuffer.copy(glb, byteOffset);
return glb; return glb;
} }

1542
lib/loadMtl.js
View File

File diff suppressed because it is too large Load Diff

1177
lib/loadObj.js
View File

File diff suppressed because it is too large Load Diff

179
lib/loadTexture.js
View File

@ -1,11 +1,11 @@
'use strict'; "use strict";
const Cesium = require('cesium'); const Cesium = require("cesium");
const fsExtra = require('fs-extra'); const fsExtra = require("fs-extra");
const jpeg = require('jpeg-js'); const jpeg = require("jpeg-js");
const path = require('path'); const path = require("path");
const PNG = require('pngjs').PNG; const PNG = require("pngjs").PNG;
const Promise = require('bluebird'); const Promise = require("bluebird");
const Texture = require('./Texture'); const Texture = require("./Texture");
const defaultValue = Cesium.defaultValue; const defaultValue = Cesium.defaultValue;
const defined = Cesium.defined; const defined = Cesium.defined;
@ -25,112 +25,109 @@ module.exports = loadTexture;
* @private * @private
*/ */
function loadTexture(texturePath, options) { function loadTexture(texturePath, options) {
options = defaultValue(options, {}); options = defaultValue(options, {});
options.checkTransparency = defaultValue(options.checkTransparency, false); options.checkTransparency = defaultValue(options.checkTransparency, false);
options.decode = defaultValue(options.decode, false); options.decode = defaultValue(options.decode, false);
options.keepSource = defaultValue(options.keepSource, false); options.keepSource = defaultValue(options.keepSource, false);
return fsExtra.readFile(texturePath) return fsExtra.readFile(texturePath).then(function (source) {
.then(function(source) { const name = path.basename(texturePath, path.extname(texturePath));
const name = path.basename(texturePath, path.extname(texturePath)); const extension = path.extname(texturePath).toLowerCase();
const extension = path.extname(texturePath).toLowerCase(); const texture = new Texture();
const texture = new Texture(); texture.source = source;
texture.source = source; texture.name = name;
texture.name = name; texture.extension = extension;
texture.extension = extension; texture.path = texturePath;
texture.path = texturePath;
let decodePromise; let decodePromise;
if (extension === '.png') { if (extension === ".png") {
decodePromise = decodePng(texture, options); decodePromise = decodePng(texture, options);
} else if (extension === '.jpg' || extension === '.jpeg') { } else if (extension === ".jpg" || extension === ".jpeg") {
decodePromise = decodeJpeg(texture, options); decodePromise = decodeJpeg(texture, options);
} }
if (defined(decodePromise)) { if (defined(decodePromise)) {
return decodePromise return decodePromise.then(function () {
.then(function() { return texture;
return texture; });
}); }
}
return texture; return texture;
}); });
} }
function hasTransparency(pixels) { function hasTransparency(pixels) {
const pixelsLength = pixels.length / 4; const pixelsLength = pixels.length / 4;
for (let i = 0; i < pixelsLength; ++i) { for (let i = 0; i < pixelsLength; ++i) {
if (pixels[i * 4 + 3] < 255) { if (pixels[i * 4 + 3] < 255) {
return true; return true;
}
} }
return false; }
return false;
} }
function getChannels(colorType) { function getChannels(colorType) {
switch (colorType) { switch (colorType) {
case 0: // greyscale case 0: // greyscale
return 1; return 1;
case 2: // RGB case 2: // RGB
return 3; return 3;
case 4: // greyscale + alpha case 4: // greyscale + alpha
return 2; return 2;
case 6: // RGB + alpha case 6: // RGB + alpha
return 4; return 4;
default: default:
return 3; return 3;
} }
} }
function parsePng(data) { function parsePng(data) {
return new Promise(function(resolve, reject) { return new Promise(function (resolve, reject) {
new PNG().parse(data, function(error, decodedResults) { new PNG().parse(data, function (error, decodedResults) {
if (defined(error)) { if (defined(error)) {
reject(error); reject(error);
return; return;
} }
resolve(decodedResults); resolve(decodedResults);
});
}); });
});
} }
function decodePng(texture, options) { function decodePng(texture, options) {
// Color type is encoded in the 25th bit of the png // Color type is encoded in the 25th bit of the png
const source = texture.source; const source = texture.source;
const colorType = source[25]; const colorType = source[25];
const channels = getChannels(colorType); const channels = getChannels(colorType);
const checkTransparency = (channels === 4 && options.checkTransparency); const checkTransparency = channels === 4 && options.checkTransparency;
const decode = options.decode || checkTransparency; const decode = options.decode || checkTransparency;
if (decode) { if (decode) {
return parsePng(source) return parsePng(source).then(function (decodedResults) {
.then(function(decodedResults) { if (options.checkTransparency) {
if (options.checkTransparency) { texture.transparent = hasTransparency(decodedResults.data);
texture.transparent = hasTransparency(decodedResults.data); }
} if (options.decode) {
if (options.decode) {
texture.pixels = decodedResults.data;
texture.width = decodedResults.width;
texture.height = decodedResults.height;
if (!options.keepSource) {
texture.source = undefined; // Unload resources
}
}
});
}
}
function decodeJpeg(texture, options) {
if (options.decode) {
const source = texture.source;
const decodedResults = jpeg.decode(source);
texture.pixels = decodedResults.data; texture.pixels = decodedResults.data;
texture.width = decodedResults.width; texture.width = decodedResults.width;
texture.height = decodedResults.height; texture.height = decodedResults.height;
if (!options.keepSource) { if (!options.keepSource) {
texture.source = undefined; // Unload resources texture.source = undefined; // Unload resources
} }
} }
});
}
}
function decodeJpeg(texture, options) {
if (options.decode) {
const source = texture.source;
const decodedResults = jpeg.decode(source);
texture.pixels = decodedResults.data;
texture.width = decodedResults.width;
texture.height = decodedResults.height;
if (!options.keepSource) {
texture.source = undefined; // Unload resources
}
}
} }

306
lib/obj2gltf.js
View File

@ -1,10 +1,10 @@
'use strict'; "use strict";
const Cesium = require('cesium'); const Cesium = require("cesium");
const fsExtra = require('fs-extra'); const fsExtra = require("fs-extra");
const path = require('path'); const path = require("path");
const createGltf = require('./createGltf'); const createGltf = require("./createGltf");
const loadObj = require('./loadObj'); const loadObj = require("./loadObj");
const writeGltf = require('./writeGltf'); const writeGltf = require("./writeGltf");
const defaultValue = Cesium.defaultValue; const defaultValue = Cesium.defaultValue;
const defined = Cesium.defined; const defined = Cesium.defined;
@ -43,152 +43,190 @@ module.exports = obj2gltf;
* @return {Promise} A promise that resolves to the glTF JSON or glb buffer. * @return {Promise} A promise that resolves to the glTF JSON or glb buffer.
*/ */
function obj2gltf(objPath, options) { function obj2gltf(objPath, options) {
const defaults = obj2gltf.defaults; const defaults = obj2gltf.defaults;
options = defaultValue(options, {}); options = defaultValue(options, {});
options.binary = defaultValue(options.binary, defaults.binary); options.binary = defaultValue(options.binary, defaults.binary);
options.separate = defaultValue(options.separate, defaults.separate); options.separate = defaultValue(options.separate, defaults.separate);
options.separateTextures = defaultValue(options.separateTextures, defaults.separateTextures) || options.separate; options.separateTextures =
options.checkTransparency = defaultValue(options.checkTransparency, defaults.checkTransparency); defaultValue(options.separateTextures, defaults.separateTextures) ||
options.secure = defaultValue(options.secure, defaults.secure); options.separate;
options.packOcclusion = defaultValue(options.packOcclusion, defaults.packOcclusion); options.checkTransparency = defaultValue(
options.metallicRoughness = defaultValue(options.metallicRoughness, defaults.metallicRoughness); options.checkTransparency,
options.specularGlossiness = defaultValue(options.specularGlossiness, defaults.specularGlossiness); defaults.checkTransparency
options.unlit = defaultValue(options.unlit, defaults.unlit); );
options.overridingTextures = defaultValue(options.overridingTextures, defaultValue.EMPTY_OBJECT); options.secure = defaultValue(options.secure, defaults.secure);
options.logger = defaultValue(options.logger, getDefaultLogger()); options.packOcclusion = defaultValue(
options.writer = defaultValue(options.writer, getDefaultWriter(options.outputDirectory)); options.packOcclusion,
options.inputUpAxis = defaultValue(options.inputUpAxis, defaults.inputUpAxis); defaults.packOcclusion
options.outputUpAxis = defaultValue(options.outputUpAxis, defaults.outputUpAxis); );
options.triangleWindingOrderSanitization = defaultValue(options.triangleWindingOrderSanitization, defaults.triangleWindingOrderSanitization); 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.logger = defaultValue(options.logger, getDefaultLogger());
options.writer = defaultValue(
options.writer,
getDefaultWriter(options.outputDirectory)
);
options.inputUpAxis = defaultValue(options.inputUpAxis, defaults.inputUpAxis);
options.outputUpAxis = defaultValue(
options.outputUpAxis,
defaults.outputUpAxis
);
options.triangleWindingOrderSanitization = defaultValue(
options.triangleWindingOrderSanitization,
defaults.triangleWindingOrderSanitization
);
if (!defined(objPath)) { if (!defined(objPath)) {
throw new DeveloperError('objPath is required'); throw new DeveloperError("objPath is required");
} }
if (options.separateTextures && !defined(options.writer)) { 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) { if (
throw new DeveloperError('Only one material type may be set from [metallicRoughness, specularGlossiness, unlit].'); 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)) { if (
throw new DeveloperError('metallicRoughnessOcclusionTexture and specularGlossinessTexture cannot both be defined.'); defined(options.overridingTextures.metallicRoughnessOcclusionTexture) &&
} defined(options.overridingTextures.specularGlossinessTexture)
) {
throw new DeveloperError(
"metallicRoughnessOcclusionTexture and specularGlossinessTexture cannot both be defined."
);
}
if (defined(options.overridingTextures.metallicRoughnessOcclusionTexture)) { if (defined(options.overridingTextures.metallicRoughnessOcclusionTexture)) {
options.metallicRoughness = true; options.metallicRoughness = true;
options.specularGlossiness = false; options.specularGlossiness = false;
options.packOcclusion = true; options.packOcclusion = true;
} }
if (defined(options.overridingTextures.specularGlossinessTexture)) { if (defined(options.overridingTextures.specularGlossinessTexture)) {
options.metallicRoughness = false; options.metallicRoughness = false;
options.specularGlossiness = true; options.specularGlossiness = true;
} }
return loadObj(objPath, options) return loadObj(objPath, options)
.then(function(objData) { .then(function (objData) {
return createGltf(objData, options); return createGltf(objData, options);
}) })
.then(function(gltf) { .then(function (gltf) {
return writeGltf(gltf, options); return writeGltf(gltf, options);
}); });
} }
function getDefaultLogger() { function getDefaultLogger() {
return function(message) { return function (message) {
console.log(message); console.log(message);
}; };
} }
function getDefaultWriter(outputDirectory) { function getDefaultWriter(outputDirectory) {
if (defined(outputDirectory)) { if (defined(outputDirectory)) {
return function(file, data) { return function (file, data) {
const outputFile = path.join(outputDirectory, file); const outputFile = path.join(outputDirectory, file);
return fsExtra.outputFile(outputFile, data); return fsExtra.outputFile(outputFile, data);
}; };
} }
} }
/** /**
* Default values that will be used when calling obj2gltf(options) unless specified in the options object. * Default values that will be used when calling obj2gltf(options) unless specified in the options object.
*/ */
obj2gltf.defaults = { obj2gltf.defaults = {
/** /**
* Gets or sets whether the converter will return a glb. * Gets or sets whether the converter will return a glb.
* @type Boolean * @type Boolean
* @default false * @default false
*/ */
binary : false, binary: false,
/** /**
* Gets or sets whether to write out separate buffer and texture, * Gets or sets whether to write out separate buffer and texture,
* shader files, and textures instead of embedding them in the glTF. * shader files, and textures instead of embedding them in the glTF.
* @type Boolean * @type Boolean
* @default false * @default false
*/ */
separate : false, separate: false,
/** /**
* Gets or sets whether to write out separate textures only. * Gets or sets whether to write out separate textures only.
* @type Boolean * @type Boolean
* @default false * @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. * 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 * @type Boolean
* @default false * @default false
*/ */
checkTransparency : false, checkTransparency: false,
/** /**
* Gets or sets whether the source model can reference paths outside of its directory. * Gets or sets whether the source model can reference paths outside of its directory.
* @type Boolean * @type Boolean
* @default false * @default false
*/ */
secure : false, secure: false,
/** /**
* Gets or sets whether to pack the occlusion texture in the red channel of the metallic-roughness texture. * Gets or sets whether to pack the occlusion texture in the red channel of the metallic-roughness texture.
* @type Boolean * @type Boolean
* @default false * @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. * 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 * @type Boolean
* @default false * @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. * 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 * @type Boolean
* @default false * @default false
*/ */
specularGlossiness : false, specularGlossiness: false,
/** /**
* Gets or sets whether the glTF will be saved with the KHR_materials_unlit extension. * Gets or sets whether the glTF will be saved with the KHR_materials_unlit extension.
* @type Boolean * @type Boolean
* @default false * @default false
*/ */
unlit : false, unlit: false,
/** /**
* Gets or sets the up axis of the obj. * Gets or sets the up axis of the obj.
* @type String * @type String
* @default 'Y' * @default 'Y'
*/ */
inputUpAxis: 'Y', inputUpAxis: "Y",
/** /**
* Gets or sets the up axis of the converted glTF. * Gets or sets the up axis of the converted glTF.
* @type String * @type String
* @default 'Y' * @default 'Y'
*/ */
outputUpAxis: 'Y', outputUpAxis: "Y",
/** /**
* Gets or sets whether triangle winding order sanitization will be applied. * Gets or sets whether triangle winding order sanitization will be applied.
* @type Boolean * @type Boolean
* @default false * @default false
*/ */
windingOrderSanitization : false windingOrderSanitization: false,
}; };
/** /**

6
lib/outsideDirectory.js
View File

@ -1,5 +1,5 @@
'use strict'; "use strict";
const path = require('path'); const path = require("path");
module.exports = outsideDirectory; module.exports = outsideDirectory;
@ -13,5 +13,5 @@ module.exports = outsideDirectory;
* @private * @private
*/ */
function outsideDirectory(file, directory) { function outsideDirectory(file, directory) {
return (path.relative(directory, file).indexOf('..') === 0); return path.relative(directory, file).indexOf("..") === 0;
} }

42
lib/readLines.js
View File

@ -1,7 +1,7 @@
'use strict'; "use strict";
const fsExtra = require('fs-extra'); const fsExtra = require("fs-extra");
const Promise = require('bluebird'); const Promise = require("bluebird");
const readline = require('readline'); const readline = require("readline");
module.exports = readLines; module.exports = readLines;
@ -15,23 +15,23 @@ module.exports = readLines;
* @private * @private
*/ */
function readLines(path, callback) { function readLines(path, callback) {
return new Promise(function(resolve, reject) { return new Promise(function (resolve, reject) {
const stream = fsExtra.createReadStream(path); const stream = fsExtra.createReadStream(path);
stream.on('error', reject); stream.on("error", reject);
stream.on('end', resolve); stream.on("end", resolve);
const lineReader = readline.createInterface({ const lineReader = readline.createInterface({
input : stream input: stream,
});
const callbackWrapper = function(line) {
try {
callback(line);
} catch (error) {
reject(error);
}
};
lineReader.on('line', callbackWrapper);
}); });
const callbackWrapper = function (line) {
try {
callback(line);
} catch (error) {
reject(error);
}
};
lineReader.on("line", callbackWrapper);
});
} }

281
lib/writeGltf.js
View File

@ -1,10 +1,10 @@
'use strict'; "use strict";
const Cesium = require('cesium'); const Cesium = require("cesium");
const mime = require('mime'); const mime = require("mime");
const PNG = require('pngjs').PNG; const PNG = require("pngjs").PNG;
const Promise = require('bluebird'); const Promise = require("bluebird");
const getBufferPadded = require('./getBufferPadded'); const getBufferPadded = require("./getBufferPadded");
const gltfToGlb = require('./gltfToGlb'); const gltfToGlb = require("./gltfToGlb");
const defined = Cesium.defined; const defined = Cesium.defined;
const RuntimeError = Cesium.RuntimeError; const RuntimeError = Cesium.RuntimeError;
@ -21,170 +21,185 @@ module.exports = writeGltf;
* @private * @private
*/ */
function writeGltf(gltf, options) { function writeGltf(gltf, options) {
return encodeTextures(gltf) return encodeTextures(gltf).then(function () {
.then(function() { const binary = options.binary;
const binary = options.binary; const separate = options.separate;
const separate = options.separate; const separateTextures = options.separateTextures;
const separateTextures = options.separateTextures;
const promises = []; const promises = [];
if (separateTextures) { if (separateTextures) {
promises.push(writeSeparateTextures(gltf, options)); promises.push(writeSeparateTextures(gltf, options));
} else { } else {
writeEmbeddedTextures(gltf); writeEmbeddedTextures(gltf);
} }
if (separate) { if (separate) {
promises.push(writeSeparateBuffers(gltf, options)); promises.push(writeSeparateBuffers(gltf, options));
} else if (!binary) { } else if (!binary) {
writeEmbeddedBuffer(gltf); writeEmbeddedBuffer(gltf);
} }
const binaryBuffer = gltf.buffers[0].extras._obj2gltf.source; const binaryBuffer = gltf.buffers[0].extras._obj2gltf.source;
return Promise.all(promises) return Promise.all(promises).then(function () {
.then(function() { deleteExtras(gltf);
deleteExtras(gltf); removeEmpty(gltf);
removeEmpty(gltf); if (binary) {
if (binary) { return gltfToGlb(gltf, binaryBuffer);
return gltfToGlb(gltf, binaryBuffer); }
} return gltf;
return gltf; });
}); });
});
} }
function encodePng(texture) { function encodePng(texture) {
// Constants defined by pngjs // Constants defined by pngjs
const rgbColorType = 2; const rgbColorType = 2;
const rgbaColorType = 6; const rgbaColorType = 6;
const png = new PNG({ const png = new PNG({
width : texture.width, width: texture.width,
height : texture.height, height: texture.height,
colorType : texture.transparent ? rgbaColorType : rgbColorType, colorType: texture.transparent ? rgbaColorType : rgbColorType,
inputColorType : rgbaColorType, inputColorType: rgbaColorType,
inputHasAlpha : true inputHasAlpha: true,
});
png.data = texture.pixels;
return new Promise(function (resolve, reject) {
const chunks = [];
const stream = png.pack();
stream.on("data", function (chunk) {
chunks.push(chunk);
}); });
stream.on("end", function () {
png.data = texture.pixels; resolve(Buffer.concat(chunks));
return new Promise(function(resolve, reject) {
const chunks = [];
const stream = png.pack();
stream.on('data', function(chunk) {
chunks.push(chunk);
});
stream.on('end', function() {
resolve(Buffer.concat(chunks));
});
stream.on('error', reject);
}); });
stream.on("error", reject);
});
} }
function encodeTexture(texture) { function encodeTexture(texture) {
if (!defined(texture.source) && defined(texture.pixels) && texture.extension === '.png') { if (
return encodePng(texture) !defined(texture.source) &&
.then(function(encoded) { defined(texture.pixels) &&
texture.source = encoded; texture.extension === ".png"
}); ) {
} return encodePng(texture).then(function (encoded) {
texture.source = encoded;
});
}
} }
function encodeTextures(gltf) { function encodeTextures(gltf) {
// Dynamically generated PBR textures need to be encoded to png prior to being saved // Dynamically generated PBR textures need to be encoded to png prior to being saved
const encodePromises = []; const encodePromises = [];
const images = gltf.images; const images = gltf.images;
const length = images.length; const length = images.length;
for (let i = 0; i < length; ++i) { for (let i = 0; i < length; ++i) {
encodePromises.push(encodeTexture(images[i].extras._obj2gltf)); encodePromises.push(encodeTexture(images[i].extras._obj2gltf));
} }
return Promise.all(encodePromises); return Promise.all(encodePromises);
} }
function deleteExtras(gltf) { function deleteExtras(gltf) {
const buffers = gltf.buffers; const buffers = gltf.buffers;
const buffersLength = buffers.length; const buffersLength = buffers.length;
for (let i = 0; i < buffersLength; ++i) { for (let i = 0; i < buffersLength; ++i) {
delete buffers[i].extras; delete buffers[i].extras;
} }
const images = gltf.images; const images = gltf.images;
const imagesLength = images.length; const imagesLength = images.length;
for (let i = 0; i < imagesLength; ++i) { for (let i = 0; i < imagesLength; ++i) {
delete images[i].extras; delete images[i].extras;
} }
} }
function removeEmpty(json) { function removeEmpty(json) {
Object.keys(json).forEach(function(key) { Object.keys(json).forEach(function (key) {
if (!defined(json[key]) || (Array.isArray(json[key]) && json[key].length === 0)) { if (
delete json[key]; // Delete values that are undefined or [] !defined(json[key]) ||
} else if (typeof json[key] === 'object') { (Array.isArray(json[key]) && json[key].length === 0)
removeEmpty(json[key]); ) {
} delete json[key]; // Delete values that are undefined or []
}); } else if (typeof json[key] === "object") {
removeEmpty(json[key]);
}
});
} }
function writeSeparateBuffers(gltf, options) { function writeSeparateBuffers(gltf, options) {
const buffers = gltf.buffers; const buffers = gltf.buffers;
return Promise.map(buffers, function(buffer) { return Promise.map(
const source = buffer.extras._obj2gltf.source; buffers,
const bufferUri = buffer.name + '.bin'; function (buffer) {
buffer.uri = bufferUri; const source = buffer.extras._obj2gltf.source;
return options.writer(bufferUri, source); const bufferUri = buffer.name + ".bin";
}, {concurrency : 10}); buffer.uri = bufferUri;
return options.writer(bufferUri, source);
},
{ concurrency: 10 }
);
} }
function writeSeparateTextures(gltf, options) { function writeSeparateTextures(gltf, options) {
const images = gltf.images; const images = gltf.images;
return Promise.map(images, function(image) { return Promise.map(
const texture = image.extras._obj2gltf; images,
const imageUri = image.name + texture.extension; function (image) {
image.uri = imageUri; const texture = image.extras._obj2gltf;
return options.writer(imageUri, texture.source); const imageUri = image.name + texture.extension;
}, {concurrency : 10}); image.uri = imageUri;
return options.writer(imageUri, texture.source);
},
{ concurrency: 10 }
);
} }
function writeEmbeddedBuffer(gltf) { function writeEmbeddedBuffer(gltf) {
const buffer = gltf.buffers[0]; const buffer = gltf.buffers[0];
const source = buffer.extras._obj2gltf.source; const source = buffer.extras._obj2gltf.source;
// Buffers larger than ~192MB cannot be base64 encoded due to a NodeJS limitation. Source: https://github.com/nodejs/node/issues/4266 // 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) { 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) { function writeEmbeddedTextures(gltf) {
const buffer = gltf.buffers[0]; const buffer = gltf.buffers[0];
const bufferExtras = buffer.extras._obj2gltf; const bufferExtras = buffer.extras._obj2gltf;
const bufferSource = bufferExtras.source; const bufferSource = bufferExtras.source;
const images = gltf.images; const images = gltf.images;
const imagesLength = images.length; const imagesLength = images.length;
const sources = [bufferSource]; const sources = [bufferSource];
let byteOffset = bufferSource.length; let byteOffset = bufferSource.length;
for (let i = 0; i < imagesLength; ++i) { for (let i = 0; i < imagesLength; ++i) {
const image = images[i]; const image = images[i];
const texture = image.extras._obj2gltf; const texture = image.extras._obj2gltf;
const textureSource = texture.source; const textureSource = texture.source;
const textureByteLength = textureSource.length; const textureByteLength = textureSource.length;
image.mimeType = mime.getType(texture.extension); image.mimeType = mime.getType(texture.extension);
image.bufferView = gltf.bufferViews.length; image.bufferView = gltf.bufferViews.length;
gltf.bufferViews.push({ gltf.bufferViews.push({
buffer : 0, buffer: 0,
byteOffset : byteOffset, byteOffset: byteOffset,
byteLength : textureByteLength byteLength: textureByteLength,
}); });
byteOffset += textureByteLength; byteOffset += textureByteLength;
sources.push(textureSource); sources.push(textureSource);
} }
const source = getBufferPadded(Buffer.concat(sources)); const source = getBufferPadded(Buffer.concat(sources));
bufferExtras.source = source; bufferExtras.source = source;
buffer.byteLength = source.length; buffer.byteLength = source.length;
} }

550
specs/lib/createGltfSpec.js
View File

@ -1,288 +1,308 @@
'use strict'; "use strict";
const Cesium = require('cesium'); const Cesium = require("cesium");
const obj2gltf = require('../../lib/obj2gltf'); const obj2gltf = require("../../lib/obj2gltf");
const createGltf = require('../../lib/createGltf'); const createGltf = require("../../lib/createGltf");
const loadObj = require('../../lib/loadObj'); const loadObj = require("../../lib/loadObj");
const { getDefaultMaterial } = require('../../lib/loadMtl'); const { getDefaultMaterial } = require("../../lib/loadMtl");
const clone = Cesium.clone; const clone = Cesium.clone;
const defined = Cesium.defined; const defined = Cesium.defined;
const WebGLConstants = Cesium.WebGLConstants; const WebGLConstants = Cesium.WebGLConstants;
const boxObjPath = 'specs/data/box/box.obj'; const boxObjPath = "specs/data/box/box.obj";
const groupObjPath = 'specs/data/box-objects-groups-materials/box-objects-groups-materials.obj'; const groupObjPath =
const complexObjPath = 'specs/data/box-complex-material/box-complex-material.obj'; "specs/data/box-objects-groups-materials/box-objects-groups-materials.obj";
const noMaterialsObjPath = 'specs/data/box-no-materials/box-no-materials.obj'; const complexObjPath =
const mixedAttributesObjPath = 'specs/data/box-mixed-attributes-2/box-mixed-attributes-2.obj'; "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; let options;
describe('createGltf', () => { describe("createGltf", () => {
let boxObjData; let boxObjData;
let groupObjData; let groupObjData;
let complexObjData; let complexObjData;
let noMaterialsObjData; let noMaterialsObjData;
let mixedAttributesObjData; let mixedAttributesObjData;
beforeEach(async () => { beforeEach(async () => {
options = clone(obj2gltf.defaults); options = clone(obj2gltf.defaults);
options.overridingTextures = {}; options.overridingTextures = {};
options.logger = () => {}; options.logger = () => {};
boxObjData = await loadObj(boxObjPath, options); boxObjData = await loadObj(boxObjPath, options);
groupObjData = await loadObj(groupObjPath, options); groupObjData = await loadObj(groupObjPath, options);
complexObjData = await loadObj(complexObjPath, options); complexObjData = await loadObj(complexObjPath, options);
noMaterialsObjData = await loadObj(noMaterialsObjPath, options); noMaterialsObjData = await loadObj(noMaterialsObjPath, options);
mixedAttributesObjData = await loadObj(mixedAttributesObjPath, options); mixedAttributesObjData = await loadObj(mixedAttributesObjPath, options);
}); });
it('simple gltf', () => { it("simple gltf", () => {
const gltf = createGltf(boxObjData, options); const gltf = createGltf(boxObjData, options);
expect(gltf.materials.length).toBe(1); expect(gltf.materials.length).toBe(1);
expect(gltf.scene).toBe(0); expect(gltf.scene).toBe(0);
expect(gltf.scenes[0].nodes[0]).toBe(0); expect(gltf.scenes[0].nodes[0]).toBe(0);
expect(gltf.nodes.length).toBe(1); expect(gltf.nodes.length).toBe(1);
expect(gltf.meshes.length).toBe(1); expect(gltf.meshes.length).toBe(1);
const primitives = gltf.meshes[0].primitives; const primitives = gltf.meshes[0].primitives;
const primitive = primitives[0]; const primitive = primitives[0];
const attributes = primitive.attributes; const attributes = primitive.attributes;
const positionAccessor = gltf.accessors[attributes.POSITION]; const positionAccessor = gltf.accessors[attributes.POSITION];
const normalAccessor = gltf.accessors[attributes.NORMAL]; const normalAccessor = gltf.accessors[attributes.NORMAL];
const uvAccessor = gltf.accessors[attributes.TEXCOORD_0]; const uvAccessor = gltf.accessors[attributes.TEXCOORD_0];
const indexAccessor = gltf.accessors[primitive.indices]; const indexAccessor = gltf.accessors[primitive.indices];
expect(primitives.length).toBe(1); expect(primitives.length).toBe(1);
expect(positionAccessor.count).toBe(24); expect(positionAccessor.count).toBe(24);
expect(normalAccessor.count).toBe(24); expect(normalAccessor.count).toBe(24);
expect(uvAccessor.count).toBe(24); expect(uvAccessor.count).toBe(24);
expect(indexAccessor.count).toBe(36); expect(indexAccessor.count).toBe(36);
}); });
it('does not combine buffers when that buffer would exceed the Node buffer size limit', () => { it("does not combine buffers when that buffer would exceed the Node buffer size limit", () => {
spyOn(createGltf, '_getBufferMaxByteLength').and.returnValue(0); spyOn(createGltf, "_getBufferMaxByteLength").and.returnValue(0);
const clonedOptions = clone(options, true); const clonedOptions = clone(options, true);
clonedOptions.separate = true; clonedOptions.separate = true;
const gltf = createGltf(boxObjData, clonedOptions); const gltf = createGltf(boxObjData, clonedOptions);
expect(gltf.accessors.length).toBe(4); expect(gltf.accessors.length).toBe(4);
expect(gltf.buffers.length).toBe(4); expect(gltf.buffers.length).toBe(4);
expect(gltf.bufferViews.length).toBe(4); expect(gltf.bufferViews.length).toBe(4);
const length = gltf.buffers.length; const length = gltf.buffers.length;
for (let i = 0; i < length; ++i) { for (let i = 0; i < length; ++i) {
const accessor = gltf.accessors[i]; const accessor = gltf.accessors[i];
const bufferView = gltf.bufferViews[i]; const bufferView = gltf.bufferViews[i];
const buffer = gltf.buffers[i]; const buffer = gltf.buffers[i];
expect(accessor.bufferView).toBe(i); expect(accessor.bufferView).toBe(i);
expect(accessor.byteOffset).toBe(0); expect(accessor.byteOffset).toBe(0);
expect(bufferView.buffer).toBe(i); expect(bufferView.buffer).toBe(i);
expect(bufferView.byteOffset).toBe(0); expect(bufferView.byteOffset).toBe(0);
expect(bufferView.byteLength).toBe(buffer.byteLength); expect(bufferView.byteLength).toBe(buffer.byteLength);
}
});
it('multiple nodes, meshes, and primitives', () => {
const gltf = createGltf(groupObjData, options);
expect(gltf.materials.length).toBe(3);
expect(gltf.scene).toBe(0);
expect(gltf.scenes[0].nodes[0]).toBe(0);
expect(gltf.nodes.length).toBe(4);
expect(gltf.nodes[0].mesh).toBeUndefined();
expect(gltf.nodes[0].children.length).toBe(3);
expect(gltf.meshes.length).toBe(3);
// Check for two primitives in each mesh
const length = gltf.meshes.length;
for (let i = 0; i < length; ++i) {
const mesh = gltf.meshes[i];
expect(mesh.primitives.length).toBe(2);
}
});
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) => {
return texture.index;
}).sort()).toEqual([0, 1, 2, 3, 4]);
expect(gltf.samplers[0]).toBeDefined();
});
it('creates default material', () => {
const gltf = createGltf(noMaterialsObjData, options);
const material = gltf.materials[0];
const pbr = material.pbrMetallicRoughness;
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]);
expect(pbr.metallicFactor).toBe(0.0); // No metallic
expect(pbr.roughnessFactor).toBe(1.0); // Fully rough
expect(material.emissiveTexture).toBeUndefined();
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.doubleSided).toBe(false);
});
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']);
});
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']);
});
it('runs without normals', () => {
boxObjData.nodes[0].meshes[0].primitives[0].normals.length = 0;
const gltf = createGltf(boxObjData, options);
const attributes = gltf.meshes[0].primitives[0].attributes;
expect(attributes.POSITION).toBeDefined();
expect(attributes.NORMAL).toBeUndefined();
expect(attributes.TEXCOORD_0).toBeDefined();
});
it('runs without uvs', () => {
boxObjData.nodes[0].meshes[0].primitives[0].uvs.length = 0;
const gltf = createGltf(boxObjData, options);
const attributes = gltf.meshes[0].primitives[0].attributes;
expect(attributes.POSITION).toBeDefined();
expect(attributes.NORMAL).toBeDefined();
expect(attributes.TEXCOORD_0).toBeUndefined();
});
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;
const gltf = createGltf(boxObjData, options);
const attributes = gltf.meshes[0].primitives[0].attributes;
expect(attributes.POSITION).toBeDefined();
expect(attributes.NORMAL).toBeUndefined();
expect(attributes.TEXCOORD_0).toBeUndefined();
});
it('splits incompatible materials', () => {
const gltf = createGltf(mixedAttributesObjData, options);
const materials = gltf.materials;
const meshes = gltf.meshes;
const referenceMaterial = mixedAttributesObjData.materials[0];
delete referenceMaterial.name;
referenceMaterial.pbrMetallicRoughness.baseColorTexture = {
index : 0
};
const referenceMaterialNoTextures = clone(referenceMaterial, true);
referenceMaterialNoTextures.pbrMetallicRoughness.baseColorTexture = undefined;
const defaultMaterial = getDefaultMaterial(options);
delete defaultMaterial.name;
const materialNames = materials.map((material) => {
const name = material.name;
delete material.name;
return name;
});
// Expect three copies of each material for
// * positions/normals/uvs
// * positions/normals
// * positions/uvs
expect(materialNames).toEqual([
'default',
'default-2',
'default-3',
'Material',
'Material-2',
'Material-3',
'Missing',
'Missing-2',
'Missing-3'
]);
expect(materials.length).toBe(9);
expect(materials[0]).toEqual(defaultMaterial);
expect(materials[1]).toEqual(defaultMaterial);
expect(materials[2]).toEqual(defaultMaterial);
expect(materials[3]).toEqual(referenceMaterial);
expect(materials[4]).toEqual(referenceMaterial);
expect(materials[5]).toEqual(referenceMaterialNoTextures);
expect(materials[6]).toEqual(defaultMaterial);
expect(materials[7]).toEqual(defaultMaterial);
expect(materials[8]).toEqual(defaultMaterial);
// Test that primitives without uvs reference materials without textures
const meshesLength = meshes.length;
for (let i = 0; i < meshesLength; ++i) {
const mesh = meshes[i];
const primitives = mesh.primitives;
const primitivesLength = primitives.length;
for (let j = 0; j < primitivesLength; ++j) {
const primitive = primitives[j];
const material = materials[primitive.material];
if (!defined(primitive.attributes.TEXCOORD_0)) {
expect(material.pbrMetallicRoughness.baseColorTexture).toBeUndefined();
}
}
}
});
function expandObjData(objData, duplicatesLength) {
const primitive = objData.nodes[0].meshes[0].primitives[0];
const indices = primitive.indices;
const positions = primitive.positions;
const normals = primitive.normals;
const uvs = primitive.uvs;
const indicesLength = indices.length;
const vertexCount = positions.length / 3;
for (let i = 1; i < duplicatesLength; ++i) {
for (let j = 0; j < vertexCount; ++j) {
positions.push(0.0);
positions.push(0.0);
positions.push(0.0);
normals.push(0.0);
normals.push(0.0);
normals.push(0.0);
uvs.push(0.0);
uvs.push(0.0);
}
for (let k = 0; k < indicesLength; ++k) {
indices.push(indices.get(k) + vertexCount * i);
}
}
} }
});
it('detects need to use uint32 indices', () => { it("multiple nodes, meshes, and primitives", () => {
expandObjData(boxObjData, 2731); // Right above 65536 limit const gltf = createGltf(groupObjData, options);
let primitive = boxObjData.nodes[0].meshes[0].primitives[0];
const indicesLength = primitive.indices.length;
const vertexCount = primitive.positions.length / 3;
const gltf = createGltf(boxObjData, options); expect(gltf.materials.length).toBe(3);
primitive = gltf.meshes[0].primitives[0]; expect(gltf.scene).toBe(0);
const indicesAccessor = gltf.accessors[primitive.indices]; expect(gltf.scenes[0].nodes[0]).toBe(0);
expect(indicesAccessor.count).toBe(indicesLength); expect(gltf.nodes.length).toBe(4);
expect(indicesAccessor.max[0]).toBe(vertexCount - 1); expect(gltf.nodes[0].mesh).toBeUndefined();
expect(indicesAccessor.componentType).toBe(WebGLConstants.UNSIGNED_INT); expect(gltf.nodes[0].children.length).toBe(3);
expect(gltf.meshes.length).toBe(3);
const positionAccessor = gltf.accessors[primitive.attributes.POSITION]; // Check for two primitives in each mesh
expect(positionAccessor.count).toBe(vertexCount); const length = gltf.meshes.length;
for (let i = 0; i < length; ++i) {
const mesh = gltf.meshes[i];
expect(mesh.primitives.length).toBe(2);
}
});
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) => {
return texture.index;
})
.sort()
).toEqual([0, 1, 2, 3, 4]);
expect(gltf.samplers[0]).toBeDefined();
});
it("creates default material", () => {
const gltf = createGltf(noMaterialsObjData, options);
const material = gltf.materials[0];
const pbr = material.pbrMetallicRoughness;
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]);
expect(pbr.metallicFactor).toBe(0.0); // No metallic
expect(pbr.roughnessFactor).toBe(1.0); // Fully rough
expect(material.emissiveTexture).toBeUndefined();
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.doubleSided).toBe(false);
});
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",
]);
});
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"]);
});
it("runs without normals", () => {
boxObjData.nodes[0].meshes[0].primitives[0].normals.length = 0;
const gltf = createGltf(boxObjData, options);
const attributes = gltf.meshes[0].primitives[0].attributes;
expect(attributes.POSITION).toBeDefined();
expect(attributes.NORMAL).toBeUndefined();
expect(attributes.TEXCOORD_0).toBeDefined();
});
it("runs without uvs", () => {
boxObjData.nodes[0].meshes[0].primitives[0].uvs.length = 0;
const gltf = createGltf(boxObjData, options);
const attributes = gltf.meshes[0].primitives[0].attributes;
expect(attributes.POSITION).toBeDefined();
expect(attributes.NORMAL).toBeDefined();
expect(attributes.TEXCOORD_0).toBeUndefined();
});
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;
const gltf = createGltf(boxObjData, options);
const attributes = gltf.meshes[0].primitives[0].attributes;
expect(attributes.POSITION).toBeDefined();
expect(attributes.NORMAL).toBeUndefined();
expect(attributes.TEXCOORD_0).toBeUndefined();
});
it("splits incompatible materials", () => {
const gltf = createGltf(mixedAttributesObjData, options);
const materials = gltf.materials;
const meshes = gltf.meshes;
const referenceMaterial = mixedAttributesObjData.materials[0];
delete referenceMaterial.name;
referenceMaterial.pbrMetallicRoughness.baseColorTexture = {
index: 0,
};
const referenceMaterialNoTextures = clone(referenceMaterial, true);
referenceMaterialNoTextures.pbrMetallicRoughness.baseColorTexture =
undefined;
const defaultMaterial = getDefaultMaterial(options);
delete defaultMaterial.name;
const materialNames = materials.map((material) => {
const name = material.name;
delete material.name;
return name;
}); });
// Expect three copies of each material for
// * positions/normals/uvs
// * positions/normals
// * positions/uvs
expect(materialNames).toEqual([
"default",
"default-2",
"default-3",
"Material",
"Material-2",
"Material-3",
"Missing",
"Missing-2",
"Missing-3",
]);
expect(materials.length).toBe(9);
expect(materials[0]).toEqual(defaultMaterial);
expect(materials[1]).toEqual(defaultMaterial);
expect(materials[2]).toEqual(defaultMaterial);
expect(materials[3]).toEqual(referenceMaterial);
expect(materials[4]).toEqual(referenceMaterial);
expect(materials[5]).toEqual(referenceMaterialNoTextures);
expect(materials[6]).toEqual(defaultMaterial);
expect(materials[7]).toEqual(defaultMaterial);
expect(materials[8]).toEqual(defaultMaterial);
// Test that primitives without uvs reference materials without textures
const meshesLength = meshes.length;
for (let i = 0; i < meshesLength; ++i) {
const mesh = meshes[i];
const primitives = mesh.primitives;
const primitivesLength = primitives.length;
for (let j = 0; j < primitivesLength; ++j) {
const primitive = primitives[j];
const material = materials[primitive.material];
if (!defined(primitive.attributes.TEXCOORD_0)) {
expect(
material.pbrMetallicRoughness.baseColorTexture
).toBeUndefined();
}
}
}
});
function expandObjData(objData, duplicatesLength) {
const primitive = objData.nodes[0].meshes[0].primitives[0];
const indices = primitive.indices;
const positions = primitive.positions;
const normals = primitive.normals;
const uvs = primitive.uvs;
const indicesLength = indices.length;
const vertexCount = positions.length / 3;
for (let i = 1; i < duplicatesLength; ++i) {
for (let j = 0; j < vertexCount; ++j) {
positions.push(0.0);
positions.push(0.0);
positions.push(0.0);
normals.push(0.0);
normals.push(0.0);
normals.push(0.0);
uvs.push(0.0);
uvs.push(0.0);
}
for (let k = 0; k < indicesLength; ++k) {
indices.push(indices.get(k) + vertexCount * i);
}
}
}
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;
const vertexCount = primitive.positions.length / 3;
const gltf = createGltf(boxObjData, options);
primitive = gltf.meshes[0].primitives[0];
const indicesAccessor = gltf.accessors[primitive.indices];
expect(indicesAccessor.count).toBe(indicesLength);
expect(indicesAccessor.max[0]).toBe(vertexCount - 1);
expect(indicesAccessor.componentType).toBe(WebGLConstants.UNSIGNED_INT);
const positionAccessor = gltf.accessors[primitive.attributes.POSITION];
expect(positionAccessor.count).toBe(vertexCount);
});
}); });

910
specs/lib/loadMtlSpec.js
View File

@ -1,31 +1,42 @@
'use strict'; "use strict";
const Cesium = require('cesium'); const Cesium = require("cesium");
const fsExtra = require('fs-extra'); const fsExtra = require("fs-extra");
const loadMtl = require('../../lib/loadMtl'); const loadMtl = require("../../lib/loadMtl");
const loadTexture = require('../../lib/loadTexture'); const loadTexture = require("../../lib/loadTexture");
const obj2gltf = require('../../lib/obj2gltf'); const obj2gltf = require("../../lib/obj2gltf");
const clone = Cesium.clone; const clone = Cesium.clone;
const coloredMaterialPath = 'specs/data/box/box.mtl'; const coloredMaterialPath = "specs/data/box/box.mtl";
const texturedMaterialPath = 'specs/data/box-complex-material/box-complex-material.mtl'; const texturedMaterialPath =
const texturedWithOptionsMaterialPath = 'specs/data/box-texture-options/box-texture-options.mtl'; "specs/data/box-complex-material/box-complex-material.mtl";
const multipleMaterialsPath = 'specs/data/box-multiple-materials/box-multiple-materials.mtl'; const texturedWithOptionsMaterialPath =
const externalMaterialPath = 'specs/data/box-external-resources/box-external-resources.mtl'; "specs/data/box-texture-options/box-texture-options.mtl";
const resourcesInRootMaterialPath = 'specs/data/box-resources-in-root/box-resources-in-root.mtl'; const multipleMaterialsPath =
const externalInRootMaterialPath = 'specs/data/box-external-resources-in-root/box-external-resources-in-root.mtl'; "specs/data/box-multiple-materials/box-multiple-materials.mtl";
const transparentMaterialPath = 'specs/data/box-transparent/box-transparent.mtl'; const externalMaterialPath =
const sharedTexturesMaterialPath = 'specs/data/box-shared-textures/box-shared-textures.mtl'; "specs/data/box-external-resources/box-external-resources.mtl";
const sharedTexturesMaterial2Path = 'specs/data/box-shared-textures-2/box-shared-textures-2.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 diffuseTexturePath = "specs/data/box-textured/cesium.png";
const transparentDiffuseTexturePath = 'specs/data/box-complex-material/diffuse.png'; const transparentDiffuseTexturePath =
const alphaTexturePath = 'specs/data/box-complex-material-alpha/alpha.png'; "specs/data/box-complex-material/diffuse.png";
const ambientTexturePath = 'specs/data/box-complex-material/ambient.gif'; const alphaTexturePath = "specs/data/box-complex-material-alpha/alpha.png";
const normalTexturePath = 'specs/data/box-complex-material/bump.png'; const ambientTexturePath = "specs/data/box-complex-material/ambient.gif";
const emissiveTexturePath = 'specs/data/box-complex-material/emission.jpg'; const normalTexturePath = "specs/data/box-complex-material/bump.png";
const specularTexturePath = 'specs/data/box-complex-material/specular.jpeg'; const emissiveTexturePath = "specs/data/box-complex-material/emission.jpg";
const specularShininessTexturePath = 'specs/data/box-complex-material/shininess.png'; const specularTexturePath = "specs/data/box-complex-material/specular.jpeg";
const specularShininessTexturePath =
"specs/data/box-complex-material/shininess.png";
let diffuseTexture; let diffuseTexture;
let transparentDiffuseTexture; let transparentDiffuseTexture;
@ -37,434 +48,487 @@ let specularTexture;
let specularShininessTexture; let specularShininessTexture;
const checkTransparencyOptions = { const checkTransparencyOptions = {
checkTransparency : true checkTransparency: true,
}; };
const decodeOptions = { const decodeOptions = {
decode : true decode: true,
}; };
let options; let options;
describe('loadMtl', () => { describe("loadMtl", () => {
beforeAll(async () => { beforeAll(async () => {
diffuseTexture = await loadTexture(diffuseTexturePath, decodeOptions); diffuseTexture = await loadTexture(diffuseTexturePath, decodeOptions);
transparentDiffuseTexture = await loadTexture(transparentDiffuseTexturePath, checkTransparencyOptions); transparentDiffuseTexture = await loadTexture(
alphaTexture = await loadTexture(alphaTexturePath, decodeOptions); transparentDiffuseTexturePath,
ambientTexture = await loadTexture(ambientTexturePath); checkTransparencyOptions
normalTexture = await loadTexture(normalTexturePath); );
emissiveTexture = await loadTexture(emissiveTexturePath); alphaTexture = await loadTexture(alphaTexturePath, decodeOptions);
specularTexture = await loadTexture(specularTexturePath, decodeOptions); ambientTexture = await loadTexture(ambientTexturePath);
specularShininessTexture = await loadTexture(specularShininessTexturePath, decodeOptions); normalTexture = await loadTexture(normalTexturePath);
emissiveTexture = await loadTexture(emissiveTexturePath);
specularTexture = await loadTexture(specularTexturePath, decodeOptions);
specularShininessTexture = await loadTexture(
specularShininessTexturePath,
decodeOptions
);
});
beforeEach(() => {
options = clone(obj2gltf.defaults);
options.overridingTextures = {};
options.logger = () => {};
});
it("loads mtl", async () => {
options.metallicRoughness = true;
const materials = await loadMtl(coloredMaterialPath, options);
expect(materials.length).toBe(1);
const material = materials[0];
const pbr = material.pbrMetallicRoughness;
expect(pbr.baseColorTexture).toBeUndefined();
expect(pbr.metallicRoughnessTexture).toBeUndefined();
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.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.doubleSided).toBe(false);
});
it("loads mtl with textures", async () => {
options.metallicRoughness = true;
const materials = await loadMtl(texturedMaterialPath, options);
expect(materials.length).toBe(1);
const material = materials[0];
const pbr = material.pbrMetallicRoughness;
expect(pbr.baseColorTexture).toBeDefined();
expect(pbr.metallicRoughnessTexture).toBeDefined();
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.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.doubleSided).toBe(true);
});
it("loads mtl with textures having options", async () => {
options.metallicRoughness = true;
const materials = await loadMtl(texturedWithOptionsMaterialPath, options);
expect(materials.length).toBe(1);
const material = materials[0];
const pbr = material.pbrMetallicRoughness;
expect(pbr.baseColorTexture).toBeDefined();
expect(pbr.metallicRoughnessTexture).toBeDefined();
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.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.doubleSided).toBe(true);
});
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,
]);
});
it("sets overriding textures", async () => {
spyOn(fsExtra, "readFile").and.callThrough();
options.overridingTextures = {
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(fsExtra.readFile.calls.count()).toBe(3);
});
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");
});
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;
const materials = await loadMtl(externalMaterialPath, options);
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);
});
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");
});
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");
});
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];
const pbr = material.pbrMetallicRoughness;
expect(pbr.baseColorTexture).toBeUndefined();
expect(pbr.metallicRoughnessTexture).toBeUndefined();
expect(pbr.baseColorFactor[3]).toEqual(1.0);
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 () => {
const materials = await loadMtl(sharedTexturesMaterialPath, options);
expect(materials.length).toBe(1);
const material = materials[0];
const pbr = material.pbrMetallicRoughness;
expect(pbr.baseColorTexture).toBeDefined();
expect(pbr.occlusionTexture).toBeUndefined();
});
it("texture referenced by specular is decoded", async () => {
const materials = await loadMtl(sharedTexturesMaterialPath, options);
expect(materials.length).toBe(1);
const material = materials[0];
const pbr = material.pbrMetallicRoughness;
expect(pbr.baseColorTexture.pixels).toBeDefined();
expect(pbr.baseColorTexture.source).toBeDefined();
expect(pbr.metallicRoughnessTexture.pixels).toBeDefined();
expect(pbr.metallicRoughnessTexture.source).toBeUndefined();
});
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];
const pbr = material.pbrMetallicRoughness;
expect(pbr.baseColorTexture).toBe(material.emissiveTexture);
expect(pbr.baseColorTexture.pixels).toBeUndefined();
expect(pbr.baseColorTexture.source).toBeDefined();
});
describe("metallicRoughness", () => {
it("creates default material", () => {
const material = loadMtl._createMaterial(undefined, options);
const pbr = material.pbrMetallicRoughness;
expect(pbr.baseColorTexture).toBeUndefined();
expect(pbr.metallicRoughnessTexture).toBeUndefined();
expect(pbr.baseColorFactor).toEqual([0.5, 0.5, 0.5, 1.0]);
expect(pbr.metallicFactor).toBe(0.0); // No metallic
expect(pbr.roughnessFactor).toBe(1.0); // Fully rough
expect(material.emissiveTexture).toBeUndefined();
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.doubleSided).toBe(false);
}); });
beforeEach(() => { it("creates material with textures", () => {
options = clone(obj2gltf.defaults); options.metallicRoughness = true;
options.overridingTextures = {};
options.logger = () => {}; 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();
expect(pbr.metallicRoughnessTexture).toBeDefined();
expect(pbr.baseColorFactor).toEqual([1.0, 1.0, 1.0, 1.0]);
expect(pbr.metallicFactor).toBe(1.0);
expect(pbr.roughnessFactor).toBe(1.0);
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("OPAQUE");
expect(material.doubleSided).toBe(false);
}); });
it('loads mtl', async () => { it("packs occlusion in metallic roughness texture", () => {
options.metallicRoughness = true; options.metallicRoughness = true;
const materials = await loadMtl(coloredMaterialPath, options); options.packOcclusion = true;
expect(materials.length).toBe(1);
const material = materials[0]; const material = loadMtl._createMaterial(
const pbr = material.pbrMetallicRoughness; {
expect(pbr.baseColorTexture).toBeUndefined(); ambientTexture: alphaTexture,
expect(pbr.metallicRoughnessTexture).toBeUndefined(); specularTexture: specularTexture,
expect(pbr.baseColorFactor).toEqual([0.64, 0.64, 0.64, 1.0]); specularShininessTexture: specularShininessTexture,
expect(pbr.metallicFactor).toBe(0.5); },
expect(pbr.roughnessFactor).toBe(96.078431); options
expect(material.name).toBe('Material'); );
expect(material.emissiveTexture).toBeUndefined();
expect(material.normalTexture).toBeUndefined(); const pbr = material.pbrMetallicRoughness;
expect(material.ambientTexture).toBeUndefined(); expect(pbr.metallicRoughnessTexture).toBeDefined();
expect(material.emissiveFactor).toEqual([0.0, 0.0, 0.1]); expect(pbr.metallicRoughnessTexture).toBe(material.occlusionTexture);
expect(material.alphaMode).toBe('OPAQUE');
expect(material.doubleSided).toBe(false);
}); });
it('loads mtl with textures', async () => { it("does not create metallic roughness texture if decoded texture data is not available", () => {
options.metallicRoughness = true; options.metallicRoughness = true;
const materials = await loadMtl(texturedMaterialPath, options); options.packOcclusion = true;
expect(materials.length).toBe(1);
const material = materials[0]; const material = loadMtl._createMaterial(
const pbr = material.pbrMetallicRoughness; {
expect(pbr.baseColorTexture).toBeDefined(); ambientTexture: ambientTexture, // Is a .gif which can't be decoded
expect(pbr.metallicRoughnessTexture).toBeDefined(); specularTexture: specularTexture,
expect(pbr.baseColorFactor).toEqual([1.0, 1.0, 1.0, 0.9]); specularShininessTexture: specularShininessTexture,
expect(pbr.metallicFactor).toBe(1.0); },
expect(pbr.roughnessFactor).toBe(1.0); options
expect(material.name).toBe('Material'); );
expect(material.emissiveTexture).toBeDefined();
expect(material.normalTexture).toBeDefined(); const pbr = material.pbrMetallicRoughness;
expect(material.occlusionTexture).toBeDefined(); expect(pbr.metallicRoughnessTexture).toBeUndefined();
expect(material.emissiveFactor).toEqual([1.0, 1.0, 1.0]); expect(material.occlusionTexture).toBeUndefined();
expect(material.alphaMode).toBe('BLEND');
expect(material.doubleSided).toBe(true);
}); });
it('loads mtl with textures having options', async () => { it("sets material for transparent diffuse texture", () => {
options.metallicRoughness = true; options.metallicRoughness = true;
const materials = await loadMtl(texturedWithOptionsMaterialPath, options);
expect(materials.length).toBe(1); const material = loadMtl._createMaterial(
const material = materials[0]; {
const pbr = material.pbrMetallicRoughness; diffuseTexture: transparentDiffuseTexture,
expect(pbr.baseColorTexture).toBeDefined(); },
expect(pbr.metallicRoughnessTexture).toBeDefined(); options
expect(pbr.baseColorFactor).toEqual([1.0, 1.0, 1.0, 0.9]); );
expect(pbr.metallicFactor).toBe(1.0); expect(material.alphaMode).toBe("BLEND");
expect(pbr.roughnessFactor).toBe(1.0); expect(material.doubleSided).toBe(true);
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.doubleSided).toBe(true);
}); });
it('loads mtl with multiple materials', async () => { it("packs alpha texture in base color texture", () => {
options.metallicRoughness = true; options.metallicRoughness = true;
const materials = await loadMtl(multipleMaterialsPath, options);
expect(materials.length).toBe(3); const material = loadMtl._createMaterial(
expect(materials[0].name).toBe('Blue'); {
expect(materials[0].pbrMetallicRoughness.baseColorFactor).toEqual([0.0, 0.0, 0.64, 1.0]); diffuseTexture: diffuseTexture,
expect(materials[1].name).toBe('Green'); alphaTexture: alphaTexture,
expect(materials[1].pbrMetallicRoughness.baseColorFactor).toEqual([0.0, 0.64, 0.0, 1.0]); },
expect(materials[2].name).toBe('Red'); options
expect(materials[2].pbrMetallicRoughness.baseColorFactor).toEqual([0.64, 0.0, 0.0, 1.0]); );
const pbr = material.pbrMetallicRoughness;
expect(pbr.baseColorTexture).toBeDefined();
let hasBlack = false;
let hasWhite = false;
const pixels = pbr.baseColorTexture.pixels;
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;
}
expect(hasBlack).toBe(true);
expect(hasWhite).toBe(true);
expect(pbr.baseColorFactor[3]).toEqual(1);
expect(material.alphaMode).toBe("BLEND");
expect(material.doubleSided).toBe(true);
}); });
it('sets overriding textures', async () => { it("uses diffuse texture if diffuse and alpha are the same", () => {
spyOn(fsExtra, 'readFile').and.callThrough(); options.metallicRoughness = true;
options.overridingTextures = {
metallicRoughnessOcclusionTexture : alphaTexturePath, const material = loadMtl._createMaterial(
baseColorTexture : alphaTexturePath, {
emissiveTexture : emissiveTexturePath diffuseTexture: diffuseTexture,
}; alphaTexture: diffuseTexture,
const materials = await loadMtl(texturedMaterialPath, options); },
const material = materials[0]; options
const pbr = material.pbrMetallicRoughness; );
expect(pbr.baseColorTexture.name).toBe('alpha');
expect(pbr.metallicRoughnessTexture.name).toBe('alpha'); const pbr = material.pbrMetallicRoughness;
expect(material.emissiveTexture.name).toBe('emission'); expect(pbr.baseColorTexture).toBe(diffuseTexture);
expect(material.normalTexture.name).toBe('bump'); expect(material.alphaMode).toBe("BLEND");
expect(fsExtra.readFile.calls.count()).toBe(3); expect(material.doubleSided).toBe(true);
});
});
describe("specularGlossiness", () => {
it("creates default material", () => {
options.specularGlossiness = true;
const material = loadMtl._createMaterial(undefined, options);
const pbr = material.extensions.KHR_materials_pbrSpecularGlossiness;
expect(pbr.diffuseTexture).toBeUndefined();
expect(pbr.specularGlossinessTexture).toBeUndefined();
expect(pbr.diffuseFactor).toEqual([0.5, 0.5, 0.5, 1.0]);
expect(pbr.specularFactor).toEqual([0.0, 0.0, 0.0]); // No specular color
expect(pbr.glossinessFactor).toEqual(0.0); // Rough surface
expect(material.emissiveTexture).toBeUndefined();
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.doubleSided).toBe(false);
}); });
it('loads texture outside of the mtl directory', async () => { it("creates material with textures", () => {
const materials = await loadMtl(externalMaterialPath, options); options.specularGlossiness = true;
const material = materials[0];
const baseColorTexture = material.pbrMetallicRoughness.baseColorTexture; const material = loadMtl._createMaterial(
expect(baseColorTexture.source).toBeDefined(); {
expect(baseColorTexture.name).toBe('cesium'); diffuseTexture: diffuseTexture,
ambientTexture: ambientTexture,
normalTexture: normalTexture,
emissiveTexture: emissiveTexture,
specularTexture: specularTexture,
specularShininessTexture: specularShininessTexture,
},
options
);
const pbr = material.extensions.KHR_materials_pbrSpecularGlossiness;
expect(pbr.diffuseTexture).toBeDefined();
expect(pbr.specularGlossinessTexture).toBeDefined();
expect(pbr.diffuseFactor).toEqual([1.0, 1.0, 1.0, 1.0]);
expect(pbr.specularFactor).toEqual([1.0, 1.0, 1.0]);
expect(pbr.glossinessFactor).toEqual(1.0);
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("OPAQUE");
expect(material.doubleSided).toBe(false);
}); });
it('does not load texture outside of the mtl directory when secure is true', async () => { it("does not create specular glossiness texture if decoded texture data is not available", () => {
const spy = jasmine.createSpy('logger'); options.specularGlossiness = true;
options.logger = spy;
options.secure = true;
const materials = await loadMtl(externalMaterialPath, options); const material = loadMtl._createMaterial(
const material = materials[0]; {
const baseColorTexture = material.pbrMetallicRoughness.baseColorTexture; specularTexture: ambientTexture, // Is a .gif which can't be decoded
expect(baseColorTexture).toBeUndefined(); specularShininessTexture: specularShininessTexture,
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); options
expect(spy.calls.argsFor(2)[0].indexOf('Could not read texture file') >= 0).toBe(true); );
const pbr = material.extensions.KHR_materials_pbrSpecularGlossiness;
expect(pbr.specularGlossinessTexture).toBeUndefined();
}); });
it('loads textures from root directory when the texture paths do not exist', async () => { it("sets material for transparent diffuse texture", () => {
const materials = await loadMtl(resourcesInRootMaterialPath, options); options.specularGlossiness = true;
const material = materials[0];
const baseColorTexture = material.pbrMetallicRoughness.baseColorTexture; const material = loadMtl._createMaterial(
expect(baseColorTexture.source).toBeDefined(); {
expect(baseColorTexture.name).toBe('cesium'); diffuseTexture: transparentDiffuseTexture,
},
options
);
expect(material.alphaMode).toBe("BLEND");
expect(material.doubleSided).toBe(true);
}); });
it('loads textures from root directory when texture is outside of the mtl directory and secure is true', async () => { it("packs alpha texture in diffuse texture", () => {
options.secure = true; options.specularGlossiness = true;
const materials = await loadMtl(externalInRootMaterialPath, options); const material = loadMtl._createMaterial(
const material = materials[0]; {
const baseColorTexture = material.pbrMetallicRoughness.baseColorTexture; diffuseTexture: diffuseTexture,
expect(baseColorTexture.source).toBeDefined(); alphaTexture: alphaTexture,
expect(baseColorTexture.name).toBe('cesium'); },
options
);
const pbr = material.extensions.KHR_materials_pbrSpecularGlossiness;
expect(pbr.diffuseTexture).toBeDefined();
let hasBlack = false;
let hasWhite = false;
const pixels = pbr.diffuseTexture.pixels;
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;
}
expect(hasBlack).toBe(true);
expect(hasWhite).toBe(true);
expect(pbr.diffuseFactor[3]).toEqual(1);
expect(material.alphaMode).toBe("BLEND");
expect(material.doubleSided).toBe(true);
}); });
it('alpha of 0.0 is treated as 1.0', async () => { it("uses diffuse texture if diffuse and alpha are the same", () => {
const materials = await loadMtl(transparentMaterialPath, options); options.specularGlossiness = true;
expect(materials.length).toBe(1);
const material = materials[0]; const material = loadMtl._createMaterial(
const pbr = material.pbrMetallicRoughness; {
expect(pbr.baseColorTexture).toBeUndefined(); diffuseTexture: diffuseTexture,
expect(pbr.metallicRoughnessTexture).toBeUndefined(); alphaTexture: diffuseTexture,
expect(pbr.baseColorFactor[3]).toEqual(1.0); },
expect(material.alphaMode).toBe('OPAQUE'); options
expect(material.doubleSided).toBe(false); );
});
const pbr = material.extensions.KHR_materials_pbrSpecularGlossiness;
it('ambient texture is ignored if it is the same as the diffuse texture', async () => { expect(pbr.diffuseTexture).toEqual(diffuseTexture);
const materials = await loadMtl(sharedTexturesMaterialPath, options); expect(material.alphaMode).toBe("BLEND");
expect(materials.length).toBe(1); expect(material.doubleSided).toBe(true);
const material = materials[0];
const pbr = material.pbrMetallicRoughness;
expect(pbr.baseColorTexture).toBeDefined();
expect(pbr.occlusionTexture).toBeUndefined();
});
it('texture referenced by specular is decoded', async () => {
const materials = await loadMtl(sharedTexturesMaterialPath, options);
expect(materials.length).toBe(1);
const material = materials[0];
const pbr = material.pbrMetallicRoughness;
expect(pbr.baseColorTexture.pixels).toBeDefined();
expect(pbr.baseColorTexture.source).toBeDefined();
expect(pbr.metallicRoughnessTexture.pixels).toBeDefined();
expect(pbr.metallicRoughnessTexture.source).toBeUndefined();
});
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];
const pbr = material.pbrMetallicRoughness;
expect(pbr.baseColorTexture).toBe(material.emissiveTexture);
expect(pbr.baseColorTexture.pixels).toBeUndefined();
expect(pbr.baseColorTexture.source).toBeDefined();
});
describe('metallicRoughness', () => {
it('creates default material', () => {
const material = loadMtl._createMaterial(undefined, options);
const pbr = material.pbrMetallicRoughness;
expect(pbr.baseColorTexture).toBeUndefined();
expect(pbr.metallicRoughnessTexture).toBeUndefined();
expect(pbr.baseColorFactor).toEqual([0.5, 0.5, 0.5, 1.0]);
expect(pbr.metallicFactor).toBe(0.0); // No metallic
expect(pbr.roughnessFactor).toBe(1.0); // Fully rough
expect(material.emissiveTexture).toBeUndefined();
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.doubleSided).toBe(false);
});
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 pbr = material.pbrMetallicRoughness;
expect(pbr.baseColorTexture).toBeDefined();
expect(pbr.metallicRoughnessTexture).toBeDefined();
expect(pbr.baseColorFactor).toEqual([1.0, 1.0, 1.0, 1.0]);
expect(pbr.metallicFactor).toBe(1.0);
expect(pbr.roughnessFactor).toBe(1.0);
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('OPAQUE');
expect(material.doubleSided).toBe(false);
});
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 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', () => {
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 pbr = material.pbrMetallicRoughness;
expect(pbr.metallicRoughnessTexture).toBeUndefined();
expect(material.occlusionTexture).toBeUndefined();
});
it('sets material for transparent diffuse texture', () => {
options.metallicRoughness = true;
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', () => {
options.metallicRoughness = true;
const material = loadMtl._createMaterial({
diffuseTexture : diffuseTexture,
alphaTexture : alphaTexture
}, options);
const pbr = material.pbrMetallicRoughness;
expect(pbr.baseColorTexture).toBeDefined();
let hasBlack = false;
let hasWhite = false;
const pixels = pbr.baseColorTexture.pixels;
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);
}
expect(hasBlack).toBe(true);
expect(hasWhite).toBe(true);
expect(pbr.baseColorFactor[3]).toEqual(1);
expect(material.alphaMode).toBe('BLEND');
expect(material.doubleSided).toBe(true);
});
it('uses diffuse texture if diffuse and alpha are the same', () => {
options.metallicRoughness = true;
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.doubleSided).toBe(true);
});
});
describe('specularGlossiness', () => {
it('creates default material', () => {
options.specularGlossiness = true;
const material = loadMtl._createMaterial(undefined, options);
const pbr = material.extensions.KHR_materials_pbrSpecularGlossiness;
expect(pbr.diffuseTexture).toBeUndefined();
expect(pbr.specularGlossinessTexture).toBeUndefined();
expect(pbr.diffuseFactor).toEqual([0.5, 0.5, 0.5, 1.0]);
expect(pbr.specularFactor).toEqual([0.0, 0.0, 0.0]); // No specular color
expect(pbr.glossinessFactor).toEqual(0.0); // Rough surface
expect(material.emissiveTexture).toBeUndefined();
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.doubleSided).toBe(false);
});
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 pbr = material.extensions.KHR_materials_pbrSpecularGlossiness;
expect(pbr.diffuseTexture).toBeDefined();
expect(pbr.specularGlossinessTexture).toBeDefined();
expect(pbr.diffuseFactor).toEqual([1.0, 1.0, 1.0, 1.0]);
expect(pbr.specularFactor).toEqual([1.0, 1.0, 1.0]);
expect(pbr.glossinessFactor).toEqual(1.0);
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('OPAQUE');
expect(material.doubleSided).toBe(false);
});
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 pbr = material.extensions.KHR_materials_pbrSpecularGlossiness;
expect(pbr.specularGlossinessTexture).toBeUndefined();
});
it('sets material for transparent diffuse texture', () => {
options.specularGlossiness = true;
const material = loadMtl._createMaterial({
diffuseTexture : transparentDiffuseTexture
}, options);
expect(material.alphaMode).toBe('BLEND');
expect(material.doubleSided).toBe(true);
});
it('packs alpha texture in diffuse texture', () => {
options.specularGlossiness = true;
const material = loadMtl._createMaterial({
diffuseTexture : diffuseTexture,
alphaTexture : alphaTexture
}, options);
const pbr = material.extensions.KHR_materials_pbrSpecularGlossiness;
expect(pbr.diffuseTexture).toBeDefined();
let hasBlack = false;
let hasWhite = false;
const pixels = pbr.diffuseTexture.pixels;
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);
}
expect(hasBlack).toBe(true);
expect(hasWhite).toBe(true);
expect(pbr.diffuseFactor[3]).toEqual(1);
expect(material.alphaMode).toBe('BLEND');
expect(material.doubleSided).toBe(true);
});
it('uses diffuse texture if diffuse and alpha are the same', () => {
options.specularGlossiness = true;
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.doubleSided).toBe(true);
});
}); });
});
}); });

1162
specs/lib/loadObjSpec.js
View File

File diff suppressed because it is too large Load Diff

176
specs/lib/loadTextureSpec.js
View File

@ -1,99 +1,99 @@
'use strict'; "use strict";
const loadTexture = require('../../lib/loadTexture'); const loadTexture = require("../../lib/loadTexture");
const pngTexturePath = 'specs/data/box-complex-material/shininess.png'; const pngTexturePath = "specs/data/box-complex-material/shininess.png";
const jpgTexturePath = 'specs/data/box-complex-material/emission.jpg'; const jpgTexturePath = "specs/data/box-complex-material/emission.jpg";
const jpegTexturePath = 'specs/data/box-complex-material/specular.jpeg'; const jpegTexturePath = "specs/data/box-complex-material/specular.jpeg";
const gifTexturePath = 'specs/data/box-complex-material/ambient.gif'; const gifTexturePath = "specs/data/box-complex-material/ambient.gif";
const grayscaleTexturePath = 'specs/data/box-complex-material-alpha/alpha.png'; const grayscaleTexturePath = "specs/data/box-complex-material-alpha/alpha.png";
const transparentTexturePath = 'specs/data/box-complex-material/diffuse.png'; const transparentTexturePath = "specs/data/box-complex-material/diffuse.png";
describe('loadTexture', () => { describe("loadTexture", () => {
it('loads png texture', async () => { it("loads png texture", async () => {
const texture = await loadTexture(pngTexturePath); const texture = await loadTexture(pngTexturePath);
expect(texture.transparent).toBe(false); expect(texture.transparent).toBe(false);
expect(texture.source).toBeDefined(); expect(texture.source).toBeDefined();
expect(texture.name).toBe('shininess'); expect(texture.name).toBe("shininess");
expect(texture.extension).toBe('.png'); expect(texture.extension).toBe(".png");
expect(texture.path).toBe(pngTexturePath); expect(texture.path).toBe(pngTexturePath);
expect(texture.pixels).toBeUndefined(); expect(texture.pixels).toBeUndefined();
expect(texture.width).toBeUndefined(); expect(texture.width).toBeUndefined();
expect(texture.height).toBeUndefined(); expect(texture.height).toBeUndefined();
}); });
it('loads jpg texture', async () => { it("loads jpg texture", async () => {
const texture = await loadTexture(jpgTexturePath); const texture = await loadTexture(jpgTexturePath);
expect(texture.transparent).toBe(false); expect(texture.transparent).toBe(false);
expect(texture.source).toBeDefined(); expect(texture.source).toBeDefined();
expect(texture.name).toBe('emission'); expect(texture.name).toBe("emission");
expect(texture.extension).toBe('.jpg'); expect(texture.extension).toBe(".jpg");
expect(texture.path).toBe(jpgTexturePath); expect(texture.path).toBe(jpgTexturePath);
expect(texture.pixels).toBeUndefined(); expect(texture.pixels).toBeUndefined();
expect(texture.width).toBeUndefined(); expect(texture.width).toBeUndefined();
expect(texture.height).toBeUndefined(); expect(texture.height).toBeUndefined();
}); });
it('loads jpeg texture', async () => { it("loads jpeg texture", async () => {
const texture = await loadTexture(jpegTexturePath); const texture = await loadTexture(jpegTexturePath);
expect(texture.transparent).toBe(false); expect(texture.transparent).toBe(false);
expect(texture.source).toBeDefined(); expect(texture.source).toBeDefined();
expect(texture.name).toBe('specular'); expect(texture.name).toBe("specular");
expect(texture.extension).toBe('.jpeg'); expect(texture.extension).toBe(".jpeg");
expect(texture.path).toBe(jpegTexturePath); expect(texture.path).toBe(jpegTexturePath);
expect(texture.pixels).toBeUndefined(); expect(texture.pixels).toBeUndefined();
expect(texture.width).toBeUndefined(); expect(texture.width).toBeUndefined();
expect(texture.height).toBeUndefined(); expect(texture.height).toBeUndefined();
}); });
it('loads gif texture', async () => { it("loads gif texture", async () => {
const texture = await loadTexture(gifTexturePath); const texture = await loadTexture(gifTexturePath);
expect(texture.transparent).toBe(false); expect(texture.transparent).toBe(false);
expect(texture.source).toBeDefined(); expect(texture.source).toBeDefined();
expect(texture.name).toBe('ambient'); expect(texture.name).toBe("ambient");
expect(texture.extension).toBe('.gif'); expect(texture.extension).toBe(".gif");
expect(texture.path).toBe(gifTexturePath); expect(texture.path).toBe(gifTexturePath);
expect(texture.pixels).toBeUndefined(); expect(texture.pixels).toBeUndefined();
expect(texture.width).toBeUndefined(); expect(texture.width).toBeUndefined();
expect(texture.height).toBeUndefined(); expect(texture.height).toBeUndefined();
}); });
it('loads grayscale texture', async () => { it("loads grayscale texture", async () => {
const texture = await loadTexture(grayscaleTexturePath); const texture = await loadTexture(grayscaleTexturePath);
expect(texture.transparent).toBe(false); expect(texture.transparent).toBe(false);
expect(texture.source).toBeDefined(); 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); const texture = await loadTexture(transparentTexturePath);
expect(texture.transparent).toBe(false); expect(texture.transparent).toBe(false);
}); });
it('loads texture with checkTransparency flag', async () => { it("loads texture with checkTransparency flag", async () => {
const options = { const options = {
checkTransparency : true checkTransparency: true,
}; };
const texture = await loadTexture(transparentTexturePath, options); const texture = await loadTexture(transparentTexturePath, options);
expect(texture.transparent).toBe(true); expect(texture.transparent).toBe(true);
}); });
it('loads and decodes png', async () => { it("loads and decodes png", async () => {
const options = { const options = {
decode : true decode: true,
}; };
const texture = await loadTexture(pngTexturePath, options); const texture = await loadTexture(pngTexturePath, options);
expect(texture.pixels).toBeDefined(); expect(texture.pixels).toBeDefined();
expect(texture.width).toBe(211); expect(texture.width).toBe(211);
expect(texture.height).toBe(211); expect(texture.height).toBe(211);
}); });
it('loads and decodes jpeg', async () => { it("loads and decodes jpeg", async () => {
const options = { const options = {
decode : true decode: true,
}; };
const texture = await loadTexture(jpegTexturePath, options); const texture = await loadTexture(jpegTexturePath, options);
expect(texture.pixels).toBeDefined(); expect(texture.pixels).toBeDefined();
expect(texture.width).toBe(211); expect(texture.width).toBe(211);
expect(texture.height).toBe(211); expect(texture.height).toBe(211);
}); });
}); });

372
specs/lib/obj2gltfSpec.js
View File

@ -1,201 +1,215 @@
'use strict'; "use strict";
const { DeveloperError } = require('cesium'); const { DeveloperError } = require("cesium");
const fsExtra = require('fs-extra'); const fsExtra = require("fs-extra");
const path = require('path'); const path = require("path");
const Promise = require('bluebird'); const Promise = require("bluebird");
const createGltf = require('../../lib/createGltf'); const createGltf = require("../../lib/createGltf");
const obj2gltf = require('../../lib/obj2gltf'); const obj2gltf = require("../../lib/obj2gltf");
const texturedObjPath = 'specs/data/box-textured/box-textured.obj'; const texturedObjPath = "specs/data/box-textured/box-textured.obj";
const complexObjPath = 'specs/data/box-complex-material/box-complex-material.obj'; const complexObjPath =
const missingMtllibObjPath = 'specs/data/box-missing-mtllib/box-missing-mtllib.obj'; "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(() => { 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); const gltf = await obj2gltf(texturedObjPath);
expect(gltf).toBeDefined(); expect(gltf).toBeDefined();
expect(gltf.images.length).toBe(1); expect(gltf.images.length).toBe(1);
}); });
it('converts obj to glb', async () => { it("converts obj to glb", async () => {
const options = { const options = {
binary : true binary: true,
}; };
const glb = await obj2gltf(texturedObjPath, options); const glb = await obj2gltf(texturedObjPath, options);
const magic = glb.toString('utf8', 0, 4); const magic = glb.toString("utf8", 0, 4);
expect(magic).toBe('glTF'); expect(magic).toBe("glTF");
}); });
it('convert obj to gltf with separate resources', async () => { it("convert obj to gltf with separate resources", async () => {
const options = { const options = {
separate : true, separate: true,
separateTextures : true, separateTextures: true,
outputDirectory : outputDirectory outputDirectory: outputDirectory,
}; };
await obj2gltf(texturedObjPath, options); await obj2gltf(texturedObjPath, options);
expect(fsExtra.outputFile.calls.count()).toBe(2); // Saves out .png and .bin 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 () => { it("convert obj to gltf with separate resources when buffer exceeds Node limit", async () => {
spyOn(createGltf, '_getBufferMaxByteLength').and.returnValue(0); spyOn(createGltf, "_getBufferMaxByteLength").and.returnValue(0);
const options = { const options = {
separate : true, separate: true,
separateTextures : true, separateTextures: true,
outputDirectory : outputDirectory outputDirectory: outputDirectory,
}; };
await obj2gltf(texturedObjPath, options); await obj2gltf(texturedObjPath, options);
expect(fsExtra.outputFile.calls.count()).toBe(5); // Saves out .png and four .bin for positions, normals, uvs, and indices 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 = { const options = {
separate : true, separate: true,
separateTextures : true, separateTextures: true,
outputDirectory : outputDirectory, outputDirectory: outputDirectory,
binary : true binary: true,
}; };
await obj2gltf(texturedObjPath, options); await obj2gltf(texturedObjPath, options);
expect(fsExtra.outputFile.calls.count()).toBe(2); // Saves out .png and .bin 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 = { const options = {
separateTextures : true, separateTextures: true,
outputDirectory : outputDirectory outputDirectory: outputDirectory,
}; };
await obj2gltf(complexObjPath, options); await obj2gltf(complexObjPath, options);
expect(fsExtra.outputFile.calls.count()).toBe(5); // baseColor, metallicRoughness, occlusion, emission, normal 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 = { const options = {
overridingTextures : { overridingTextures: {
metallicRoughnessOcclusionTexture : textureUrl, metallicRoughnessOcclusionTexture: textureUrl,
normalTexture : textureUrl, normalTexture: textureUrl,
baseColorTexture : textureUrl, baseColorTexture: textureUrl,
emissiveTexture : textureUrl, emissiveTexture: textureUrl,
alphaTexture : textureUrl alphaTexture: textureUrl,
}, },
separateTextures : true, separateTextures: true,
outputDirectory : outputDirectory outputDirectory: outputDirectory,
}; };
await obj2gltf(complexObjPath, options); await obj2gltf(complexObjPath, options);
const args = fsExtra.outputFile.calls.allArgs(); const args = fsExtra.outputFile.calls.allArgs();
const length = args.length; const length = args.length;
for (let i = 0; i < length; ++i) { for (let i = 0; i < length; ++i) {
expect(path.basename(args[i][0])).toBe(path.basename(textureUrl)); expect(path.basename(args[i][0])).toBe(path.basename(textureUrl));
} }
}); });
it('sets overriding textures (2)', async () => { it("sets overriding textures (2)", async () => {
const options = { const options = {
overridingTextures : { overridingTextures: {
specularGlossinessTexture : textureUrl, specularGlossinessTexture: textureUrl,
occlusionTexture : textureUrl, occlusionTexture: textureUrl,
normalTexture : textureUrl, normalTexture: textureUrl,
baseColorTexture : textureUrl, baseColorTexture: textureUrl,
emissiveTexture : textureUrl, emissiveTexture: textureUrl,
alphaTexture : textureUrl alphaTexture: textureUrl,
}, },
separateTextures : true, separateTextures: true,
outputDirectory : outputDirectory outputDirectory: outputDirectory,
}; };
await obj2gltf(complexObjPath, options); await obj2gltf(complexObjPath, options);
const args = fsExtra.outputFile.calls.allArgs(); const args = fsExtra.outputFile.calls.allArgs();
const length = args.length; const length = args.length;
for (let i = 0; i < length; ++i) { for (let i = 0; i < length; ++i) {
expect(path.basename(args[i][0])).toBe(path.basename(textureUrl)); expect(path.basename(args[i][0])).toBe(path.basename(textureUrl));
} }
}); });
it('uses a custom logger', async () => { it("uses a custom logger", async () => {
let lastMessage; let lastMessage;
const options = { const options = {
logger : (message) => { logger: (message) => {
lastMessage = message; lastMessage = message;
} },
}; };
await obj2gltf(missingMtllibObjPath, options); 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 filePaths = [];
const fileContents = []; const fileContents = [];
const options = { const options = {
separate : true, separate: true,
writer : (relativePath, contents) => { writer: (relativePath, contents) => {
filePaths.push(relativePath); filePaths.push(relativePath);
fileContents.push(contents); fileContents.push(contents);
} },
}; };
await obj2gltf(texturedObjPath, options); 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[0]).toBeDefined();
expect(fileContents[1]).toBeDefined(); expect(fileContents[1]).toBeDefined();
}); });
it('throws if objPath is undefined', () => { it("throws if objPath is undefined", () => {
let thrownError; let thrownError;
try { try {
obj2gltf(undefined); obj2gltf(undefined);
} catch (e) { } catch (e) {
thrownError = 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 = { const options = {
separateTextures : true separateTextures: true,
}; };
let thrownError; let thrownError;
try { try {
obj2gltf(texturedObjPath, options); obj2gltf(texturedObjPath, options);
} catch (e) { } catch (e) {
thrownError = 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 = { const options = {
metallicRoughness : true, metallicRoughness: true,
specularGlossiness : true specularGlossiness: true,
}; };
let thrownError; let thrownError;
try { try {
obj2gltf(texturedObjPath, options); obj2gltf(texturedObjPath, options);
} catch (e) { } catch (e) {
thrownError = 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 = { const options = {
overridingTextures : { overridingTextures: {
metallicRoughnessOcclusionTexture : textureUrl, metallicRoughnessOcclusionTexture: textureUrl,
specularGlossinessTexture : textureUrl specularGlossinessTexture: textureUrl,
} },
}; };
let thrownError; let thrownError;
try { try {
obj2gltf(texturedObjPath, options); obj2gltf(texturedObjPath, options);
} catch (e) { } catch (e) {
thrownError = 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."
)
);
});
}); });