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-??-??
* Removed `minFilter` and `magFilter` from generated samplers so that runtime engines can use their preferred texture filtering. [#240](https://github.com/CesiumGS/obj2gltf/pull/240)
* Triangle winding order sanitization is longer done by default. Use the `--triangle-winding-order-sanitization` option. [#236](https://github.com/CesiumGS/obj2gltf/pull/236)
- Removed `minFilter` and `magFilter` from generated samplers so that runtime engines can use their preferred texture filtering. [#240](https://github.com/CesiumGS/obj2gltf/pull/240)
- Triangle winding order sanitization is longer done by default. Use the `--triangle-winding-order-sanitization` option. [#236](https://github.com/CesiumGS/obj2gltf/pull/236)
### 3.1.1 - 2021-06-22
* Fixed security warnings by updating outdated npm dependencies. [#254](https://github.com/CesiumGS/obj2gltf/pull/254)
- Fixed security warnings by updating outdated npm dependencies. [#254](https://github.com/CesiumGS/obj2gltf/pull/254)
### 3.1.0 - 2020-03-13
* Added back `inputUpAxis` and `outputUpAxis`. [#211](https://github.com/CesiumGS/obj2gltf/pull/211)
* Fixed handling of mtl and texture absolute paths. [#219](https://github.com/CesiumGS/obj2gltf/pull/219)
* Fixed specular image not being decoded when referenced by other textures. [#217](https://github.com/CesiumGS/obj2gltf/pull/217)
* Fixed parsing faces that reference non-existing attributes. [#218](https://github.com/CesiumGS/obj2gltf/pull/218)
- Added back `inputUpAxis` and `outputUpAxis`. [#211](https://github.com/CesiumGS/obj2gltf/pull/211)
- Fixed handling of mtl and texture absolute paths. [#219](https://github.com/CesiumGS/obj2gltf/pull/219)
- Fixed specular image not being decoded when referenced by other textures. [#217](https://github.com/CesiumGS/obj2gltf/pull/217)
- Fixed parsing faces that reference non-existing attributes. [#218](https://github.com/CesiumGS/obj2gltf/pull/218)
### 3.0.4 - 2019-07-22
* No longer printing texture decode warning if the diffuse and alpha textures are the same. [#205](https://github.com/CesiumGS/obj2gltf/pull/205)
- No longer printing texture decode warning if the diffuse and alpha textures are the same. [#205](https://github.com/CesiumGS/obj2gltf/pull/205)
### 3.0.3 2019-06-26
* Fixed parsing of negative face indices. [#191](https://github.com/CesiumGS/obj2gltf/pull/191)
- Fixed parsing of negative face indices. [#191](https://github.com/CesiumGS/obj2gltf/pull/191)
### 3.0.2 2019-03-21
* Fixed a crash when saving separate resources that would exceed the Node buffer size limit. [#173](https://github.com/CesiumGS/obj2gltf/pull/173)
- Fixed a crash when saving separate resources that would exceed the Node buffer size limit. [#173](https://github.com/CesiumGS/obj2gltf/pull/173)
### 3.0.1 2019-03-08
* Fixed handling of materials that don't have names. [#173](https://github.com/CesiumGS/obj2gltf/pull/173)
- Fixed handling of materials that don't have names. [#173](https://github.com/CesiumGS/obj2gltf/pull/173)
### 3.0.0 2018-12-05
* Breaking changes
* The `--materialsCommon` flag has been removed. Use `--unlit` instead which uses the `KHR_materials_unlit` extension. [#152](https://github.com/CesiumGS/obj2gltf/pull/152)
- Breaking changes
- The `--materialsCommon` flag has been removed. Use `--unlit` instead which uses the `KHR_materials_unlit` extension. [#152](https://github.com/CesiumGS/obj2gltf/pull/152)
### 2.3.2 2018-11-02
* Improved handling of primitives with different attributes using the same material. Materials are now duplicated. [#162](https://github.com/CesiumGS/obj2gltf/pull/162)
* Fixed a bug where primitives without texture coordinates could use materials containing textures. Those textures are now removed. [#162](https://github.com/CesiumGS/obj2gltf/pull/162)
* Improved parsing of faces with mismatching attributes. [#161](https://github.com/CesiumGS/obj2gltf/pull/161)
- Improved handling of primitives with different attributes using the same material. Materials are now duplicated. [#162](https://github.com/CesiumGS/obj2gltf/pull/162)
- Fixed a bug where primitives without texture coordinates could use materials containing textures. Those textures are now removed. [#162](https://github.com/CesiumGS/obj2gltf/pull/162)
- Improved parsing of faces with mismatching attributes. [#161](https://github.com/CesiumGS/obj2gltf/pull/161)
### 2.3.1 2018-10-16
* Improved parsing models with concave or n-sided faces. [#157](https://github.com/CesiumGS/obj2gltf/pull/157)
* Fixed handling of objs with interleaved materials. [#155](https://github.com/CesiumGS/obj2gltf/pull/155)
- Improved parsing models with concave or n-sided faces. [#157](https://github.com/CesiumGS/obj2gltf/pull/157)
- Fixed handling of objs with interleaved materials. [#155](https://github.com/CesiumGS/obj2gltf/pull/155)
### 2.3.0 2018-09-19
* Fixed handling of objs with mismatching attribute layouts. [#153](https://github.com/CesiumGS/obj2gltf/pull/153)
* Fixed normalization of Windows paths when running the converter on Linux. [#150](https://github.com/CesiumGS/obj2gltf/pull/150)
* Added ability to use the first material in the mtl file when the obj is missing `usemtl`. [#133](https://github.com/CesiumGS/obj2gltf/pull/133)
* Fixed handling of unnormalized input normals. [#136](https://github.com/CesiumGS/obj2gltf/pull/136)
- Fixed handling of objs with mismatching attribute layouts. [#153](https://github.com/CesiumGS/obj2gltf/pull/153)
- Fixed normalization of Windows paths when running the converter on Linux. [#150](https://github.com/CesiumGS/obj2gltf/pull/150)
- Added ability to use the first material in the mtl file when the obj is missing `usemtl`. [#133](https://github.com/CesiumGS/obj2gltf/pull/133)
- Fixed handling of unnormalized input normals. [#136](https://github.com/CesiumGS/obj2gltf/pull/136)
### 2.2.0 2018-01-29
* Fixed handling of materials where the diffuse and ambient texture are the same. [#127](https://github.com/CesiumGS/obj2gltf/pull/127)
* Added ability to load alpha textures. [#124](https://github.com/CesiumGS/obj2gltf/pull/124)
* Fixed handling of `usemtl` when appearing before an `o` or `g` token. [#123](https://github.com/CesiumGS/obj2gltf/pull/123)
* Fixed output name when running from the command line. [#126](https://github.com/CesiumGS/obj2gltf/pull/126)
- Fixed handling of materials where the diffuse and ambient texture are the same. [#127](https://github.com/CesiumGS/obj2gltf/pull/127)
- Added ability to load alpha textures. [#124](https://github.com/CesiumGS/obj2gltf/pull/124)
- Fixed handling of `usemtl` when appearing before an `o` or `g` token. [#123](https://github.com/CesiumGS/obj2gltf/pull/123)
- Fixed output name when running from the command line. [#126](https://github.com/CesiumGS/obj2gltf/pull/126)
### 2.1.0 2017-12-28
* Fixed loading faces that contain less than 3 vertices. [#120](https://github.com/CesiumGS/obj2gltf/pull/120)
* Attempt to load missing materials and textures from within the same directory as the obj. [#117](https://github.com/CesiumGS/obj2gltf/pull/117)
* Fixed loading mtllib paths that contain spaces. [#116](https://github.com/CesiumGS/obj2gltf/pull/116)
* Fixed checking for transparency when the diffuse texture is used in another texture slot. [#115](https://github.com/CesiumGS/obj2gltf/pull/115)
* Fixed parsing mtl textures that contain texture map options. [#109](https://github.com/CesiumGS/obj2gltf/pull/109)
* Added back support for the `CONSTANT` technique when a model uses the `KHR_materials_common` extension and has no normals. [#108](https://github.com/CesiumGS/obj2gltf/pull/108)
* Improved handling of materials with alpha. If the alpha value is 0.0 it is now treated as 1.0. [#107](https://github.com/CesiumGS/obj2gltf/pull/107)
- Fixed loading faces that contain less than 3 vertices. [#120](https://github.com/CesiumGS/obj2gltf/pull/120)
- Attempt to load missing materials and textures from within the same directory as the obj. [#117](https://github.com/CesiumGS/obj2gltf/pull/117)
- Fixed loading mtllib paths that contain spaces. [#116](https://github.com/CesiumGS/obj2gltf/pull/116)
- Fixed checking for transparency when the diffuse texture is used in another texture slot. [#115](https://github.com/CesiumGS/obj2gltf/pull/115)
- Fixed parsing mtl textures that contain texture map options. [#109](https://github.com/CesiumGS/obj2gltf/pull/109)
- Added back support for the `CONSTANT` technique when a model uses the `KHR_materials_common` extension and has no normals. [#108](https://github.com/CesiumGS/obj2gltf/pull/108)
- Improved handling of materials with alpha. If the alpha value is 0.0 it is now treated as 1.0. [#107](https://github.com/CesiumGS/obj2gltf/pull/107)
### 2.0.0 2017-08-11
* Breaking changes
* Obj models now convert to glTF 2.0. Possible material profiles are `metallicRoughness`, `specGlossiness` (using the `KHR_materials_pbrSpecularGlossiness` extension), and `materialsCommon` (using the `KHR_materials_common` extension).
* Removed `gltf-pipeline` dependency. The following options have been removed: `compress`, `optimize`, `generateNormals`, `optimizeForCesium`, `ao`, and `bypassPipeline`.
* Removed `inputUpAxis` and `outputUpAxis`. This stage will be incorporated into `gltf-pipeline` instead.
* `obj2gltf` no longer takes a `gltfPath` argument and saves a glTF file. Instead it returns a promise that resolves to the glTF JSON or glb buffer.
- Breaking changes
- Obj models now convert to glTF 2.0. Possible material profiles are `metallicRoughness`, `specGlossiness` (using the `KHR_materials_pbrSpecularGlossiness` extension), and `materialsCommon` (using the `KHR_materials_common` extension).
- Removed `gltf-pipeline` dependency. The following options have been removed: `compress`, `optimize`, `generateNormals`, `optimizeForCesium`, `ao`, and `bypassPipeline`.
- Removed `inputUpAxis` and `outputUpAxis`. This stage will be incorporated into `gltf-pipeline` instead.
- `obj2gltf` no longer takes a `gltfPath` argument and saves a glTF file. Instead it returns a promise that resolves to the glTF JSON or glb buffer.
### 1.3.0 2017-08-11
* Fixed parsing models with concave or n-sided faces. [#85](https://github.com/CesiumGS/obj2gltf/pull/85)
* Fixed parsing models with line breaks. [#85](https://github.com/CesiumGS/obj2gltf/pull/85)
- Fixed parsing models with concave or n-sided faces. [#85](https://github.com/CesiumGS/obj2gltf/pull/85)
- Fixed parsing models with line breaks. [#85](https://github.com/CesiumGS/obj2gltf/pull/85)
### 1.2.0 2017-07-11
* Change texture sampling to use `NEAREST_MIPMAP_LINEAR` by default. [#83](https://github.com/CesiumGS/obj2gltf/pull/83).
* Fixed lighting when generating normals. [#89](https://github.com/CesiumGS/obj2gltf/pull/89)
- Change texture sampling to use `NEAREST_MIPMAP_LINEAR` by default. [#83](https://github.com/CesiumGS/obj2gltf/pull/83).
- Fixed lighting when generating normals. [#89](https://github.com/CesiumGS/obj2gltf/pull/89)
### 1.1.1 2017-04-25
* Fixed `CHANGES.md` formatting.
- Fixed `CHANGES.md` formatting.
### 1.1.0 2017-04-25
* Added ability to convert the up-axis of the obj model. [#68](https://github.com/CesiumGS/obj2gltf/pull/68)
* Fixed issues with an extra .bin file being saved when using `--separate`. [#62](https://github.com/CesiumGS/obj2gltf/pull/62)
* Fixed issue where an ambient color of `[1, 1, 1]` overly brightens the converted model. [#70](https://github.com/CesiumGS/obj2gltf/pull/70)
- Added ability to convert the up-axis of the obj model. [#68](https://github.com/CesiumGS/obj2gltf/pull/68)
- Fixed issues with an extra .bin file being saved when using `--separate`. [#62](https://github.com/CesiumGS/obj2gltf/pull/62)
- Fixed issue where an ambient color of `[1, 1, 1]` overly brightens the converted model. [#70](https://github.com/CesiumGS/obj2gltf/pull/70)
### 1.0.0 2017-04-13
* Breaking changes
* To use `obj2gltf` as a library, call `require('obj2gltf')(input, output, options)`. The previous calling code was `require('obj2gltf').convert(input, output, options)`.
* Many library options and command-line parameters have been renamed.
* Project cleanup. [#49](https://github.com/CesiumGS/obj2gltf/pull/49)
* Speed improvements, especially for larger models.
* Preserves the objects and groups in the obj.
* Added documentation and tests.
* Material fixes.
- Breaking changes
- To use `obj2gltf` as a library, call `require('obj2gltf')(input, output, options)`. The previous calling code was `require('obj2gltf').convert(input, output, options)`.
- Many library options and command-line parameters have been renamed.
- Project cleanup. [#49](https://github.com/CesiumGS/obj2gltf/pull/49)
- Speed improvements, especially for larger models.
- Preserves the objects and groups in the obj.
- Added documentation and tests.
- Material fixes.
### 0.1.7 2017-01-06
* Update gltf-pipeline to 0.1.0-alpha9
* Added command to generate documentation (npm run jsdoc)
- Update gltf-pipeline to 0.1.0-alpha9
- Added command to generate documentation (npm run jsdoc)
### 0.1.6 2016-09-07
* Changed obj2gltf.js line endings from CRLF to LF in npm package.
- Changed obj2gltf.js line endings from CRLF to LF in npm package.
### 0.1.5 2016-08-26
* Fixed incorrect parameter to the gltf-pipeline.
- Fixed incorrect parameter to the gltf-pipeline.
### 0.1.4 2016-08-25
* Added compression flag for quantizing positions, compressing texture coordinates, and oct-encoding normals.
- Added compression flag for quantizing positions, compressing texture coordinates, and oct-encoding normals.
### 0.1.3 - 2016-08-08
* Fixed a bug causing models with no mtl file to not convert.
- Fixed a bug causing models with no mtl file to not convert.
### 0.1.2 - 2016-07-25
* Converted the API to now use promises instead of callbacks. [#21](https://github.com/CesiumGS/OBJ2GLTF/pull/21)
* Added the ability to optimize the converted glTF for CesiumJS by using the sun as a default light source.
- Converted the API to now use promises instead of callbacks. [#21](https://github.com/CesiumGS/OBJ2GLTF/pull/21)
- Added the ability to optimize the converted glTF for CesiumJS by using the sun as a default light source.
### 0.1.1 - 2016-07-21
* Updated to use gltf-pipeline 0.1.0-alpha2.
- Updated to use gltf-pipeline 0.1.0-alpha2.
### 0.1.0 - 2016-07-20
* Initial release.
- Initial release.

4
LICENSE.md
View File

@ -202,9 +202,7 @@ Copyright 2016-2020 Cesium GS, Inc. and Contributors
See the License for the specific language governing permissions and
limitations under the License.
Third-Party Code
================
# Third-Party Code
obj2gltf includes the following third-party code.

42
README.md
View File

@ -5,6 +5,7 @@ Convert OBJ assets to [glTF](https://www.khronos.org/gltf) 2.0.
## Getting Started
Install [Node.js](https://nodejs.org/en/) if you don't already have it, and then:
```
npm install -g obj2gltf
```
@ -22,26 +23,24 @@ npm install -g obj2gltf
#### Converting an obj model to gltf:
```javascript
const obj2gltf = require('obj2gltf');
const fs = require('fs');
obj2gltf('model.obj')
.then(function(gltf) {
const obj2gltf = require("obj2gltf");
const fs = require("fs");
obj2gltf("model.obj").then(function (gltf) {
const data = Buffer.from(JSON.stringify(gltf));
fs.writeFileSync('model.gltf', data);
fs.writeFileSync("model.gltf", data);
});
```
#### Converting an obj model to glb
```javascript
const obj2gltf = require('obj2gltf');
const fs = require('fs');
const obj2gltf = require("obj2gltf");
const fs = require("fs");
const options = {
binary : true
}
obj2gltf('model.obj', options)
.then(function(glb) {
fs.writeFileSync('model.glb', glb);
binary: true,
};
obj2gltf("model.obj", options).then(function (glb) {
fs.writeFileSync("model.glb", glb);
});
```
@ -52,9 +51,9 @@ materials.
There are three shading models supported by `obj2gltf`:
* Metallic roughness PBR
* Specular glossiness PBR (via `KHR_materials_pbrSpecularGlossiness` extension)
* Unlit materials (via `KHR_materials_unlit` extension)
- Metallic roughness PBR
- Specular glossiness PBR (via `KHR_materials_pbrSpecularGlossiness` extension)
- Unlit materials (via `KHR_materials_unlit` extension)
If the material type is known in advance, it should be specified with either the `metallicRoughness` or `specularGlossiness` flag.
@ -72,7 +71,7 @@ As a convenience the PBR textures may be supplied directly to the command line.
**Mapping of mtl slots to shading models**
| Slot | Metallic roughness | Specular glossiness |
|----|-------------------|-------------------|
| -------- | ------------------ | ------------------- |
| Ka | occlusion value | occlusion value |
| Ke | emissive color | emissive color |
| Kd | base color | diffuse color |
@ -92,7 +91,7 @@ As a convenience the PBR textures may be supplied directly to the command line.
### Command line flags:
| Flag | Description | Required |
|----|-----------|--------|
| --------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------- |
| `-h`, `--help` | Display help. | No |
| `-i`, `--input` | Path to the obj file. | :white_check_mark: Yes |
| `-o`, `--output` | Path of the converted glTF or glb file. | No |
@ -119,14 +118,19 @@ As a convenience the PBR textures may be supplied directly to the command line.
## Build Instructions
Run the tests:
```
npm run test
```
To run ESLint on the entire codebase, run:
```
npm run eslint
```
To run ESLint automatically when a file is saved, run the following and leave it open in a console window:
```
npm run eslint-watch
```
@ -134,9 +138,11 @@ npm run eslint-watch
## Running Test Coverage
Coverage uses [nyc](https://github.com/istanbuljs/nyc). Run:
```
npm run coverage
```
For complete coverage details, open `coverage/lcov-report/index.html`.
The tests and coverage covers the Node.js module; it does not cover the command-line interface, which is tiny.
@ -144,6 +150,7 @@ The tests and coverage covers the Node.js module; it does not cover the command-
## Generating Documentation
To generate the documentation:
```
npm run jsdoc
```
@ -157,6 +164,7 @@ Pull requests are appreciated. Please use the same [Contributor License Agreeme
---
Developed by the Cesium team.
<p align="center">
<a href="https://cesium.com/"><img src="doc/cesium.png" onerror="this.src='cesium.png'"/></a>
</p>

206
bin/obj2gltf.js
View File

@ -1,10 +1,10 @@
#!/usr/bin/env node
'use strict';
const Cesium = require('cesium');
const fsExtra = require('fs-extra');
const path = require('path');
const yargs = require('yargs');
const obj2gltf = require('../lib/obj2gltf');
"use strict";
const Cesium = require("cesium");
const fsExtra = require("fs-extra");
const path = require("path");
const yargs = require("yargs");
const obj2gltf = require("../lib/obj2gltf");
const defaultValue = Cesium.defaultValue;
const defined = Cesium.defined;
@ -14,147 +14,169 @@ const defaults = obj2gltf.defaults;
const args = process.argv;
const argv = yargs
.usage('Usage: node $0 -i inputPath -o outputPath')
.example('node $0 -i ./specs/data/box/box.obj -o box.gltf')
.help('h')
.alias('h', 'help')
.usage("Usage: node $0 -i inputPath -o outputPath")
.example("node $0 -i ./specs/data/box/box.obj -o box.gltf")
.help("h")
.alias("h", "help")
.options({
input: {
alias : 'i',
describe : 'Path to the obj file.',
type : 'string',
alias: "i",
describe: "Path to the obj file.",
type: "string",
demandOption: true,
coerce: function (p) {
if (!defined(p)) {
return undefined;
}
if (p.length === 0) {
throw new Error('Input path must be a file name');
throw new Error("Input path must be a file name");
}
return path.resolve(p);
}
},
},
output: {
alias : 'o',
describe : 'Path of the converted glTF or glb file.',
type : 'string',
alias: "o",
describe: "Path of the converted glTF or glb file.",
type: "string",
coerce: function (p) {
if (!defined(p)) {
return undefined;
}
if (p.length === 0) {
throw new Error('Output path must be a file name');
throw new Error("Output path must be a file name");
}
return path.resolve(p);
}
},
},
binary: {
alias : 'b',
describe : 'Save as binary glTF (.glb)',
type : 'boolean',
default : defaults.binary
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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.'
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'
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'
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);
describe: "Apply triangle winding order sanitization.",
type: "boolean",
default: defaults.triangleWindingOrderSanitization,
},
})
.parse(args);
if (argv.metallicRoughness + argv.specularGlossiness > 1) {
console.error('Only one material type may be set from [--metallicRoughness, --specularGlossiness].');
console.error(
"Only one material type may be set from [--metallicRoughness, --specularGlossiness]."
);
process.exit(1);
}
if (defined(argv.metallicRoughnessOcclusionTexture) && defined(argv.specularGlossinessTexture)) {
console.error('--metallicRoughnessOcclusionTexture and --specularGlossinessTexture cannot both be set.');
if (
defined(argv.metallicRoughnessOcclusionTexture) &&
defined(argv.specularGlossinessTexture)
) {
console.error(
"--metallicRoughnessOcclusionTexture and --specularGlossinessTexture cannot both be set."
);
process.exit(1);
}
@ -164,8 +186,8 @@ let gltfPath = argv.output;
const filename = defaultValue(gltfPath, objPath);
const name = path.basename(filename, path.extname(filename));
const outputDirectory = path.dirname(filename);
const binary = argv.binary || path.extname(filename).toLowerCase() === '.glb';
const extension = binary ? '.glb' : '.gltf';
const binary = argv.binary || path.extname(filename).toLowerCase() === ".glb";
const extension = binary ? ".glb" : ".gltf";
gltfPath = path.join(outputDirectory, name + extension);
@ -176,7 +198,7 @@ const overridingTextures = {
normalTexture: argv.normalTexture,
baseColorTexture: argv.baseColorTexture,
emissiveTexture: argv.emissiveTexture,
alphaTexture : argv.alphaTexture
alphaTexture: argv.alphaTexture,
};
const options = {
@ -193,10 +215,10 @@ const options = {
outputDirectory: outputDirectory,
inputUpAxis: argv.inputUpAxis,
outputUpAxis: argv.outputUpAxis,
triangleWindingOrderSanitization: argv.triangleWindingOrderSanitization
triangleWindingOrderSanitization: argv.triangleWindingOrderSanitization,
};
console.time('Total');
console.time("Total");
obj2gltf(objPath, options)
.then(function (gltf) {
@ -205,12 +227,12 @@ obj2gltf(objPath, options)
return fsExtra.outputFile(gltfPath, gltf);
}
const jsonOptions = {
spaces : 2
spaces: 2,
};
return fsExtra.outputJson(gltfPath, gltf, jsonOptions);
})
.then(function () {
console.timeEnd('Total');
console.timeEnd("Total");
})
.catch(function (error) {
console.log(error.message);

93
gulpfile.js
View File

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

4
index.js
View File

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

13
lib/ArrayStorage.js
View File

@ -1,5 +1,5 @@
'use strict';
const Cesium = require('cesium');
"use strict";
const Cesium = require("cesium");
const ComponentDatatype = Cesium.ComponentDatatype;
@ -24,7 +24,10 @@ function ArrayStorage(componentDatatype) {
}
function resize(storage, length) {
const typedArray = ComponentDatatype.createTypedArray(storage.componentDatatype, length);
const typedArray = ComponentDatatype.createTypedArray(
storage.componentDatatype,
length
);
typedArray.set(storage.typedArray);
storage.typedArray = typedArray;
}
@ -57,7 +60,7 @@ const sizeOfFloat = 4;
ArrayStorage.prototype.toUint16Buffer = function () {
const length = this.length;
const typedArray = this.typedArray;
const paddedLength = length + ((length % 2 === 0) ? 0 : 1); // Round to next multiple of 2
const paddedLength = length + (length % 2 === 0 ? 0 : 1); // Round to next multiple of 2
const buffer = Buffer.alloc(paddedLength * sizeOfUint16);
for (let i = 0; i < length; ++i) {
buffer.writeUInt16LE(typedArray[i], i * sizeOfUint16);
@ -101,6 +104,6 @@ ArrayStorage.prototype.getMinMax = function(components) {
}
return {
min: min,
max : max
max: max,
};
};

2
lib/Texture.js
View File

@ -1,4 +1,4 @@
'use strict';
"use strict";
module.exports = Texture;

316
lib/createGltf.js
View File

@ -1,9 +1,9 @@
'use strict';
const BUFFER_MAX_BYTE_LENGTH = require('buffer').constants.MAX_LENGTH;
const Cesium = require('cesium');
const getBufferPadded = require('./getBufferPadded');
const getDefaultMaterial = require('./loadMtl').getDefaultMaterial;
const Texture = require('./Texture');
"use strict";
const BUFFER_MAX_BYTE_LENGTH = require("buffer").constants.MAX_LENGTH;
const Cesium = require("cesium");
const getBufferPadded = require("./getBufferPadded");
const getDefaultMaterial = require("./loadMtl").getDefaultMaterial;
const Texture = require("./Texture");
const defaultValue = Cesium.defaultValue;
const defined = Cesium.defined;
@ -42,16 +42,16 @@ function createGltf(objData, options) {
samplers: [],
scene: 0,
scenes: [],
textures : []
textures: [],
};
gltf.asset = {
generator : 'obj2gltf',
version: '2.0'
generator: "obj2gltf",
version: "2.0",
};
gltf.scenes.push({
nodes : []
nodes: [],
});
const bufferState = {
@ -62,7 +62,7 @@ function createGltf(objData, options) {
positionAccessors: [],
normalAccessors: [],
uvAccessors: [],
indexAccessors : []
indexAccessors: [],
};
const uint32Indices = requiresUint32Indices(nodes);
@ -74,14 +74,28 @@ function createGltf(objData, options) {
const meshesLength = meshes.length;
if (meshesLength === 1) {
const meshIndex = addMesh(gltf, materials, bufferState, uint32Indices, meshes[0], options);
const meshIndex = addMesh(
gltf,
materials,
bufferState,
uint32Indices,
meshes[0],
options
);
addNode(gltf, node.name, meshIndex, undefined);
} else {
// Add meshes as child nodes
const parentIndex = addNode(gltf, node.name);
for (let j = 0; j < meshesLength; ++j) {
const mesh = meshes[j];
const meshIndex = addMesh(gltf, materials, bufferState, uint32Indices, mesh, options);
const meshIndex = addMesh(
gltf,
materials,
bufferState,
uint32Indices,
mesh,
options
);
addNode(gltf, mesh.name, meshIndex, parentIndex);
}
}
@ -90,20 +104,20 @@ function createGltf(objData, options) {
if (gltf.images.length > 0) {
gltf.samplers.push({
wrapS: WebGLConstants.REPEAT,
wrapT : WebGLConstants.REPEAT
wrapT: WebGLConstants.REPEAT,
});
}
addBuffers(gltf, bufferState, name, options.separate);
if (options.specularGlossiness) {
gltf.extensionsUsed.push('KHR_materials_pbrSpecularGlossiness');
gltf.extensionsRequired.push('KHR_materials_pbrSpecularGlossiness');
gltf.extensionsUsed.push("KHR_materials_pbrSpecularGlossiness");
gltf.extensionsRequired.push("KHR_materials_pbrSpecularGlossiness");
}
if (options.unlit) {
gltf.extensionsUsed.push('KHR_materials_unlit');
gltf.extensionsRequired.push('KHR_materials_unlit');
gltf.extensionsUsed.push("KHR_materials_unlit");
gltf.extensionsRequired.push("KHR_materials_unlit");
}
return gltf;
@ -116,7 +130,9 @@ function addCombinedBufferView(gltf, buffers, accessors, byteStride, target) {
}
const bufferViewIndex = gltf.bufferViews.length;
const previousBufferView = gltf.bufferViews[bufferViewIndex - 1];
const byteOffset = defined(previousBufferView) ? previousBufferView.byteOffset + previousBufferView.byteLength : 0;
const byteOffset = defined(previousBufferView)
? previousBufferView.byteOffset + previousBufferView.byteLength
: 0;
let byteLength = 0;
for (let i = 0; i < length; ++i) {
const accessor = gltf.accessors[accessors[i]];
@ -125,23 +141,52 @@ function addCombinedBufferView(gltf, buffers, accessors, byteStride, target) {
byteLength += buffers[i].length;
}
gltf.bufferViews.push({
name : 'bufferView_' + bufferViewIndex,
name: "bufferView_" + bufferViewIndex,
buffer: 0,
byteLength: byteLength,
byteOffset: byteOffset,
byteStride: byteStride,
target : target
target: target,
});
}
function addCombinedBuffers(gltf, bufferState, name) {
addCombinedBufferView(gltf, bufferState.positionBuffers, bufferState.positionAccessors, 12, WebGLConstants.ARRAY_BUFFER);
addCombinedBufferView(gltf, bufferState.normalBuffers, bufferState.normalAccessors, 12, WebGLConstants.ARRAY_BUFFER);
addCombinedBufferView(gltf, bufferState.uvBuffers, bufferState.uvAccessors, 8, WebGLConstants.ARRAY_BUFFER);
addCombinedBufferView(gltf, bufferState.indexBuffers, bufferState.indexAccessors, undefined, WebGLConstants.ELEMENT_ARRAY_BUFFER);
addCombinedBufferView(
gltf,
bufferState.positionBuffers,
bufferState.positionAccessors,
12,
WebGLConstants.ARRAY_BUFFER
);
addCombinedBufferView(
gltf,
bufferState.normalBuffers,
bufferState.normalAccessors,
12,
WebGLConstants.ARRAY_BUFFER
);
addCombinedBufferView(
gltf,
bufferState.uvBuffers,
bufferState.uvAccessors,
8,
WebGLConstants.ARRAY_BUFFER
);
addCombinedBufferView(
gltf,
bufferState.indexBuffers,
bufferState.indexAccessors,
undefined,
WebGLConstants.ELEMENT_ARRAY_BUFFER
);
let buffers = [];
buffers = buffers.concat(bufferState.positionBuffers, bufferState.normalBuffers, bufferState.uvBuffers, bufferState.indexBuffers);
buffers = buffers.concat(
bufferState.positionBuffers,
bufferState.normalBuffers,
bufferState.uvBuffers,
bufferState.indexBuffers
);
const buffer = getBufferPadded(Buffer.concat(buffers));
gltf.buffers.push({
@ -149,24 +194,31 @@ function addCombinedBuffers(gltf, bufferState, name) {
byteLength: buffer.length,
extras: {
_obj2gltf: {
source : buffer
}
}
source: buffer,
},
},
});
}
function addSeparateBufferView(gltf, buffer, accessor, byteStride, target, name) {
function addSeparateBufferView(
gltf,
buffer,
accessor,
byteStride,
target,
name
) {
const bufferIndex = gltf.buffers.length;
const bufferViewIndex = gltf.bufferViews.length;
gltf.buffers.push({
name : name + '_' + bufferIndex,
name: name + "_" + bufferIndex,
byteLength: buffer.length,
extras: {
_obj2gltf: {
source : buffer
}
}
source: buffer,
},
},
});
gltf.bufferViews.push({
@ -174,36 +226,82 @@ function addSeparateBufferView(gltf, buffer, accessor, byteStride, target, name)
byteLength: buffer.length,
byteOffset: 0,
byteStride: byteStride,
target : target
target: target,
});
gltf.accessors[accessor].bufferView = bufferViewIndex;
gltf.accessors[accessor].byteOffset = 0;
}
function addSeparateBufferViews(gltf, buffers, accessors, byteStride, target, name) {
function addSeparateBufferViews(
gltf,
buffers,
accessors,
byteStride,
target,
name
) {
const length = buffers.length;
for (let i = 0; i < length; ++i) {
addSeparateBufferView(gltf, buffers[i], accessors[i], byteStride, target, name);
addSeparateBufferView(
gltf,
buffers[i],
accessors[i],
byteStride,
target,
name
);
}
}
function addSeparateBuffers(gltf, bufferState, name) {
addSeparateBufferViews(gltf, bufferState.positionBuffers, bufferState.positionAccessors, 12, WebGLConstants.ARRAY_BUFFER, name);
addSeparateBufferViews(gltf, bufferState.normalBuffers, bufferState.normalAccessors, 12, WebGLConstants.ARRAY_BUFFER, name);
addSeparateBufferViews(gltf, bufferState.uvBuffers, bufferState.uvAccessors, 8, WebGLConstants.ARRAY_BUFFER, name);
addSeparateBufferViews(gltf, bufferState.indexBuffers, bufferState.indexAccessors, undefined, WebGLConstants.ELEMENT_ARRAY_BUFFER, name);
addSeparateBufferViews(
gltf,
bufferState.positionBuffers,
bufferState.positionAccessors,
12,
WebGLConstants.ARRAY_BUFFER,
name
);
addSeparateBufferViews(
gltf,
bufferState.normalBuffers,
bufferState.normalAccessors,
12,
WebGLConstants.ARRAY_BUFFER,
name
);
addSeparateBufferViews(
gltf,
bufferState.uvBuffers,
bufferState.uvAccessors,
8,
WebGLConstants.ARRAY_BUFFER,
name
);
addSeparateBufferViews(
gltf,
bufferState.indexBuffers,
bufferState.indexAccessors,
undefined,
WebGLConstants.ELEMENT_ARRAY_BUFFER,
name
);
}
function addBuffers(gltf, bufferState, name, separate) {
const buffers = bufferState.positionBuffers.concat(bufferState.normalBuffers, bufferState.uvBuffers, bufferState.indexBuffers);
const buffers = bufferState.positionBuffers.concat(
bufferState.normalBuffers,
bufferState.uvBuffers,
bufferState.indexBuffers
);
const buffersLength = buffers.length;
let buffersByteLength = 0;
for (let i = 0; i < buffersLength; ++i) {
buffersByteLength += buffers[i].length;
}
if (separate && (buffersByteLength > createGltf._getBufferMaxByteLength())) {
if (separate && buffersByteLength > createGltf._getBufferMaxByteLength()) {
// Don't combine buffers if the combined buffer will exceed the Node limit.
addSeparateBuffers(gltf, bufferState, name);
} else {
@ -220,14 +318,14 @@ function addTexture(gltf, texture) {
gltf.images.push({
name: imageName,
extras: {
_obj2gltf : texture
}
_obj2gltf: texture,
},
});
gltf.textures.push({
name: textureName,
sampler: 0,
source : imageIndex
source: imageIndex,
});
return textureIndex;
@ -249,12 +347,12 @@ function getTexture(gltf, texture) {
}
return {
index : textureIndex
index: textureIndex,
};
}
function cloneMaterial(material, removeTextures) {
if (typeof material !== 'object') {
if (typeof material !== "object") {
return material;
} else if (material instanceof Texture) {
if (removeTextures) {
@ -284,7 +382,7 @@ function resolveTextures(gltf, material) {
const property = material[name];
if (property instanceof Texture) {
material[name] = getTexture(gltf, property);
} else if (!Array.isArray(property) && (typeof property === 'object')) {
} else if (!Array.isArray(property) && typeof property === "object") {
resolveTextures(gltf, property);
}
}
@ -334,18 +432,26 @@ function getOrCreateGltfMaterial(gltf, materials, materialName, options) {
}
function primitiveInfoMatch(a, b) {
return a.hasUvs === b.hasUvs &&
a.hasNormals === b.hasNormals;
return a.hasUvs === b.hasUvs && a.hasNormals === b.hasNormals;
}
function getSplitMaterialName(originalMaterialName, primitiveInfo, primitiveInfoByMaterial) {
function getSplitMaterialName(
originalMaterialName,
primitiveInfo,
primitiveInfoByMaterial
) {
let splitMaterialName = originalMaterialName;
let suffix = 2;
while (defined(primitiveInfoByMaterial[splitMaterialName])) {
if (primitiveInfoMatch(primitiveInfo, primitiveInfoByMaterial[splitMaterialName])) {
if (
primitiveInfoMatch(
primitiveInfo,
primitiveInfoByMaterial[splitMaterialName]
)
) {
break;
}
splitMaterialName = originalMaterialName + '-' + suffix++;
splitMaterialName = originalMaterialName + "-" + suffix++;
}
return splitMaterialName;
}
@ -366,19 +472,32 @@ function splitIncompatibleMaterials(nodes, materials, options) {
const hasNormals = primitive.normals.length > 0;
const primitiveInfo = {
hasUvs: hasUvs,
hasNormals : hasNormals
hasNormals: hasNormals,
};
const originalMaterialName = defaultValue(primitive.material, 'default');
const splitMaterialName = getSplitMaterialName(originalMaterialName, primitiveInfo, primitiveInfoByMaterial);
const originalMaterialName = defaultValue(
primitive.material,
"default"
);
const splitMaterialName = getSplitMaterialName(
originalMaterialName,
primitiveInfo,
primitiveInfoByMaterial
);
primitive.material = splitMaterialName;
primitiveInfoByMaterial[splitMaterialName] = primitiveInfo;
let splitMaterial = getMaterialByName(splitMaterials, splitMaterialName);
let splitMaterial = getMaterialByName(
splitMaterials,
splitMaterialName
);
if (defined(splitMaterial)) {
continue;
}
const originalMaterial = getMaterialByName(materials, originalMaterialName);
const originalMaterial = getMaterialByName(
materials,
originalMaterialName
);
if (defined(originalMaterial)) {
splitMaterial = cloneMaterial(originalMaterial, !hasUvs);
} else {
@ -395,7 +514,7 @@ function splitIncompatibleMaterials(nodes, materials, options) {
function addVertexAttribute(gltf, array, components, name) {
const count = array.length / components;
const minMax = array.getMinMax(components);
const type = (components === 3 ? 'VEC3' : 'VEC2');
const type = components === 3 ? "VEC3" : "VEC2";
const accessor = {
name: name,
@ -403,7 +522,7 @@ function addVertexAttribute(gltf, array, components, name) {
count: count,
min: minMax.min,
max: minMax.max,
type : type
type: type,
};
const accessorIndex = gltf.accessors.length;
@ -412,7 +531,9 @@ function addVertexAttribute(gltf, array, components, name) {
}
function addIndexArray(gltf, array, uint32Indices, name) {
const componentType = uint32Indices ? WebGLConstants.UNSIGNED_INT : WebGLConstants.UNSIGNED_SHORT;
const componentType = uint32Indices
? WebGLConstants.UNSIGNED_INT
: WebGLConstants.UNSIGNED_SHORT;
const count = array.length;
const minMax = array.getMinMax(1);
@ -422,7 +543,7 @@ function addIndexArray(gltf, array, uint32Indices, name) {
count: count,
min: minMax.min,
max: minMax.max,
type : 'SCALAR'
type: "SCALAR",
};
const accessorIndex = gltf.accessors.length;
@ -450,33 +571,64 @@ function requiresUint32Indices(nodes) {
return false;
}
function addPrimitive(gltf, materials, bufferState, uint32Indices, mesh, primitive, index, options) {
function addPrimitive(
gltf,
materials,
bufferState,
uint32Indices,
mesh,
primitive,
index,
options
) {
const hasPositions = primitive.positions.length > 0;
const hasNormals = primitive.normals.length > 0;
const hasUVs = primitive.uvs.length > 0;
const attributes = {};
if (hasPositions) {
const accessorIndex = addVertexAttribute(gltf, primitive.positions, 3, mesh.name + '_' + index + '_positions');
const accessorIndex = addVertexAttribute(
gltf,
primitive.positions,
3,
mesh.name + "_" + index + "_positions"
);
attributes.POSITION = accessorIndex;
bufferState.positionBuffers.push(primitive.positions.toFloatBuffer());
bufferState.positionAccessors.push(accessorIndex);
}
if (hasNormals) {
const accessorIndex = addVertexAttribute(gltf, primitive.normals, 3, mesh.name + '_' + index + '_normals');
const accessorIndex = addVertexAttribute(
gltf,
primitive.normals,
3,
mesh.name + "_" + index + "_normals"
);
attributes.NORMAL = accessorIndex;
bufferState.normalBuffers.push(primitive.normals.toFloatBuffer());
bufferState.normalAccessors.push(accessorIndex);
}
if (hasUVs) {
const accessorIndex = addVertexAttribute(gltf, primitive.uvs, 2, mesh.name + '_' + index + '_texcoords');
const accessorIndex = addVertexAttribute(
gltf,
primitive.uvs,
2,
mesh.name + "_" + index + "_texcoords"
);
attributes.TEXCOORD_0 = accessorIndex;
bufferState.uvBuffers.push(primitive.uvs.toFloatBuffer());
bufferState.uvAccessors.push(accessorIndex);
}
const indexAccessorIndex = addIndexArray(gltf, primitive.indices, uint32Indices, mesh.name + '_' + index + '_indices');
const indexBuffer = uint32Indices ? primitive.indices.toUint32Buffer() : primitive.indices.toUint16Buffer();
const indexAccessorIndex = addIndexArray(
gltf,
primitive.indices,
uint32Indices,
mesh.name + "_" + index + "_indices"
);
const indexBuffer = uint32Indices
? primitive.indices.toUint32Buffer()
: primitive.indices.toUint16Buffer();
bufferState.indexBuffers.push(indexBuffer);
bufferState.indexAccessors.push(indexAccessorIndex);
@ -486,13 +638,18 @@ function addPrimitive(gltf, materials, bufferState, uint32Indices, mesh, primiti
primitive.uvs = undefined;
primitive.indices = undefined;
const materialIndex = getOrCreateGltfMaterial(gltf, materials, primitive.material, options);
const materialIndex = getOrCreateGltfMaterial(
gltf,
materials,
primitive.material,
options
);
return {
attributes: attributes,
indices: indexAccessorIndex,
material: materialIndex,
mode : WebGLConstants.TRIANGLES
mode: WebGLConstants.TRIANGLES,
};
}
@ -501,12 +658,23 @@ function addMesh(gltf, materials, bufferState, uint32Indices, mesh, options) {
const primitives = mesh.primitives;
const primitivesLength = primitives.length;
for (let i = 0; i < primitivesLength; ++i) {
gltfPrimitives.push(addPrimitive(gltf, materials, bufferState, uint32Indices, mesh, primitives[i], i, options));
gltfPrimitives.push(
addPrimitive(
gltf,
materials,
bufferState,
uint32Indices,
mesh,
primitives[i],
i,
options
)
);
}
const gltfMesh = {
name: mesh.name,
primitives : gltfPrimitives
primitives: gltfPrimitives,
};
const meshIndex = gltf.meshes.length;
@ -517,7 +685,7 @@ function addMesh(gltf, materials, bufferState, uint32Indices, mesh, options) {
function addNode(gltf, name, meshIndex, parentIndex) {
const node = {
name: name,
mesh : meshIndex
mesh: meshIndex,
};
const nodeIndex = gltf.nodes.length;

4
lib/getBufferPadded.js
View File

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

8
lib/getJsonBufferPadded.js
View File

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

12
lib/gltfToGlb.js
View File

@ -1,6 +1,6 @@
'use strict';
const Cesium = require('cesium');
const getJsonBufferPadded = require('./getJsonBufferPadded');
"use strict";
const Cesium = require("cesium");
const getJsonBufferPadded = require("./getJsonBufferPadded");
const defined = Cesium.defined;
@ -32,7 +32,7 @@ function gltfToGlb(gltf, binaryBuffer) {
// Write binary glTF header (magic, version, length)
let byteOffset = 0;
glb.writeUInt32LE(0x46546C67, byteOffset);
glb.writeUInt32LE(0x46546c67, byteOffset);
byteOffset += 4;
glb.writeUInt32LE(2, byteOffset);
byteOffset += 4;
@ -42,7 +42,7 @@ function gltfToGlb(gltf, binaryBuffer) {
// Write JSON Chunk header (length, type)
glb.writeUInt32LE(jsonBuffer.length, byteOffset);
byteOffset += 4;
glb.writeUInt32LE(0x4E4F534A, byteOffset); // JSON
glb.writeUInt32LE(0x4e4f534a, byteOffset); // JSON
byteOffset += 4;
// Write JSON Chunk
@ -52,7 +52,7 @@ function gltfToGlb(gltf, binaryBuffer) {
// Write Binary Chunk header (length, type)
glb.writeUInt32LE(binaryBuffer.length, byteOffset);
byteOffset += 4;
glb.writeUInt32LE(0x004E4942, byteOffset); // BIN
glb.writeUInt32LE(0x004e4942, byteOffset); // BIN
byteOffset += 4;
// Write Binary Chunk

458
lib/loadMtl.js
View File

@ -1,11 +1,11 @@
'use strict';
const Cesium = require('cesium');
const path = require('path');
const Promise = require('bluebird');
const loadTexture = require('./loadTexture');
const outsideDirectory = require('./outsideDirectory');
const readLines = require('./readLines');
const Texture = require('./Texture');
"use strict";
const Cesium = require("cesium");
const path = require("path");
const Promise = require("bluebird");
const loadTexture = require("./loadTexture");
const outsideDirectory = require("./outsideDirectory");
const readLines = require("./readLines");
const Texture = require("./Texture");
const CesiumMath = Cesium.Math;
const clone = Cesium.clone;
@ -41,9 +41,18 @@ function loadMtl(mtlPath, options) {
const texturePromises = [];
const overridingTextures = options.overridingTextures;
const overridingSpecularTexture = defaultValue(overridingTextures.metallicRoughnessOcclusionTexture, overridingTextures.specularGlossinessTexture);
const overridingSpecularShininessTexture = defaultValue(overridingTextures.metallicRoughnessOcclusionTexture, overridingTextures.specularGlossinessTexture);
const overridingAmbientTexture = defaultValue(overridingTextures.metallicRoughnessOcclusionTexture, overridingTextures.occlusionTexture);
const overridingSpecularTexture = defaultValue(
overridingTextures.metallicRoughnessOcclusionTexture,
overridingTextures.specularGlossinessTexture
);
const overridingSpecularShininessTexture = defaultValue(
overridingTextures.metallicRoughnessOcclusionTexture,
overridingTextures.specularGlossinessTexture
);
const overridingAmbientTexture = defaultValue(
overridingTextures.metallicRoughnessOcclusionTexture,
overridingTextures.occlusionTexture
);
const overridingNormalTexture = overridingTextures.normalTexture;
const overridingDiffuseTexture = overridingTextures.baseColorTexture;
const overridingEmissiveTexture = overridingTextures.emissiveTexture;
@ -51,20 +60,30 @@ function loadMtl(mtlPath, options) {
// Textures that are packed into PBR textures need to be decoded first
const decodeOptions = {
decode : true
decode: true,
};
const diffuseTextureOptions = {
checkTransparency : options.checkTransparency
checkTransparency: options.checkTransparency,
};
const ambientTextureOptions = defined(overridingAmbientTexture) ? undefined : (options.packOcclusion ? decodeOptions : undefined);
const specularTextureOptions = defined(overridingSpecularTexture) ? undefined : decodeOptions;
const specularShinessTextureOptions = defined(overridingSpecularShininessTexture) ? undefined : decodeOptions;
const ambientTextureOptions = defined(overridingAmbientTexture)
? undefined
: options.packOcclusion
? decodeOptions
: undefined;
const specularTextureOptions = defined(overridingSpecularTexture)
? undefined
: decodeOptions;
const specularShinessTextureOptions = defined(
overridingSpecularShininessTexture
)
? undefined
: decodeOptions;
const emissiveTextureOptions = undefined;
const normalTextureOptions = undefined;
const alphaTextureOptions = {
decode : true
decode: true,
};
function createMaterial(name) {
@ -88,7 +107,7 @@ function loadMtl(mtlPath, options) {
if (re.test(texturePath)) {
texturePath = texturePath.split(/\s+/).pop();
}
texturePath = texturePath.replace(/\\/g, '/');
texturePath = texturePath.replace(/\\/g, "/");
return path.normalize(path.resolve(mtlDirectory, texturePath));
}
@ -98,36 +117,36 @@ function loadMtl(mtlPath, options) {
const name = line.substring(7).trim();
createMaterial(name);
} else if (/^Ka /i.test(line)) {
values = line.substring(3).trim().split(' ');
values = line.substring(3).trim().split(" ");
material.ambientColor = [
parseFloat(values[0]),
parseFloat(values[1]),
parseFloat(values[2]),
1.0
1.0,
];
} else if (/^Ke /i.test(line)) {
values = line.substring(3).trim().split(' ');
values = line.substring(3).trim().split(" ");
material.emissiveColor = [
parseFloat(values[0]),
parseFloat(values[1]),
parseFloat(values[2]),
1.0
1.0,
];
} else if (/^Kd /i.test(line)) {
values = line.substring(3).trim().split(' ');
values = line.substring(3).trim().split(" ");
material.diffuseColor = [
parseFloat(values[0]),
parseFloat(values[1]),
parseFloat(values[2]),
1.0
1.0,
];
} else if (/^Ks /i.test(line)) {
values = line.substring(3).trim().split(' ');
values = line.substring(3).trim().split(" ");
material.specularColor = [
parseFloat(values[0]),
parseFloat(values[1]),
parseFloat(values[2]),
1.0
1.0,
];
} else if (/^Ns /i.test(line)) {
value = line.substring(3).trim();
@ -140,38 +159,61 @@ function loadMtl(mtlPath, options) {
material.alpha = correctAlpha(1.0 - parseFloat(value));
} else if (/^map_Ka /i.test(line)) {
if (!defined(overridingAmbientTexture)) {
material.ambientTexture = normalizeTexturePath(line.substring(7).trim(), mtlDirectory);
material.ambientTexture = normalizeTexturePath(
line.substring(7).trim(),
mtlDirectory
);
}
} else if (/^map_Ke /i.test(line)) {
if (!defined(overridingEmissiveTexture)) {
material.emissiveTexture = normalizeTexturePath(line.substring(7).trim(), mtlDirectory);
material.emissiveTexture = normalizeTexturePath(
line.substring(7).trim(),
mtlDirectory
);
}
} else if (/^map_Kd /i.test(line)) {
if (!defined(overridingDiffuseTexture)) {
material.diffuseTexture = normalizeTexturePath(line.substring(7).trim(), mtlDirectory);
material.diffuseTexture = normalizeTexturePath(
line.substring(7).trim(),
mtlDirectory
);
}
} else if (/^map_Ks /i.test(line)) {
if (!defined(overridingSpecularTexture)) {
material.specularTexture = normalizeTexturePath(line.substring(7).trim(), mtlDirectory);
material.specularTexture = normalizeTexturePath(
line.substring(7).trim(),
mtlDirectory
);
}
} else if (/^map_Ns /i.test(line)) {
if (!defined(overridingSpecularShininessTexture)) {
material.specularShininessTexture = normalizeTexturePath(line.substring(7).trim(), mtlDirectory);
material.specularShininessTexture = normalizeTexturePath(
line.substring(7).trim(),
mtlDirectory
);
}
} else if (/^map_Bump /i.test(line)) {
if (!defined(overridingNormalTexture)) {
material.normalTexture = normalizeTexturePath(line.substring(9).trim(), mtlDirectory);
material.normalTexture = normalizeTexturePath(
line.substring(9).trim(),
mtlDirectory
);
}
} else if (/^map_d /i.test(line)) {
if (!defined(overridingAlphaTexture)) {
material.alphaTexture = normalizeTexturePath(line.substring(6).trim(), mtlDirectory);
material.alphaTexture = normalizeTexturePath(
line.substring(6).trim(),
mtlDirectory
);
}
}
}
function loadMaterialTextures(material) {
// If an alpha texture is present the diffuse texture needs to be decoded so they can be packed together
const diffuseAlphaTextureOptions = defined(material.alphaTexture) ? alphaTextureOptions : diffuseTextureOptions;
const diffuseAlphaTextureOptions = defined(material.alphaTexture)
? alphaTextureOptions
: diffuseTextureOptions;
if (material.diffuseTexture === material.ambientTexture) {
// OBJ models are often exported with the same texture in the diffuse and ambient slots but this is typically not desirable, particularly
@ -179,8 +221,24 @@ function loadMtl(mtlPath, options) {
material.ambientTexture = undefined;
}
const textureNames = ['diffuseTexture', 'ambientTexture', 'emissiveTexture', 'specularTexture', 'specularShininessTexture', 'normalTexture', 'alphaTexture'];
const textureOptions = [diffuseAlphaTextureOptions, ambientTextureOptions, emissiveTextureOptions, specularTextureOptions, specularShinessTextureOptions, normalTextureOptions, alphaTextureOptions];
const textureNames = [
"diffuseTexture",
"ambientTexture",
"emissiveTexture",
"specularTexture",
"specularShininessTexture",
"normalTexture",
"alphaTexture",
];
const textureOptions = [
diffuseAlphaTextureOptions,
ambientTextureOptions,
emissiveTextureOptions,
specularTextureOptions,
specularShinessTextureOptions,
normalTextureOptions,
alphaTextureOptions,
];
const sharedOptions = {};
textureNames.forEach(function (name, index) {
@ -191,16 +249,28 @@ function loadMtl(mtlPath, options) {
sharedOptions[texturePath] = clone(originalOptions);
}
const options = sharedOptions[texturePath];
options.checkTransparency = options.checkTransparency || originalOptions.checkTransparency;
options.checkTransparency =
options.checkTransparency || originalOptions.checkTransparency;
options.decode = options.decode || originalOptions.decode;
options.keepSource = options.keepSource || !originalOptions.decode || !originalOptions.checkTransparency;
options.keepSource =
options.keepSource ||
!originalOptions.decode ||
!originalOptions.checkTransparency;
}
});
textureNames.forEach(function (name) {
const texturePath = material[name];
if (defined(texturePath)) {
loadMaterialTexture(material, name, sharedOptions[texturePath], mtlDirectory, texturePromiseMap, texturePromises, options);
loadMaterialTexture(
material,
name,
sharedOptions[texturePath],
mtlDirectory,
texturePromiseMap,
texturePromises,
options
);
}
});
}
@ -249,7 +319,15 @@ loadMtl._createMaterial = function(materialOptions, options) {
return convertMaterial(combine(materialOptions, new Material()), options);
};
function loadMaterialTexture(material, name, textureOptions, mtlDirectory, texturePromiseMap, texturePromises, options) {
function loadMaterialTexture(
material,
name,
textureOptions,
mtlDirectory,
texturePromiseMap,
texturePromises,
options
) {
const texturePath = material[name];
if (!defined(texturePath)) {
return;
@ -260,32 +338,48 @@ function loadMaterialTexture(material, name, textureOptions, mtlDirectory, textu
const shallowPath = path.join(mtlDirectory, path.basename(texturePath));
if (options.secure && outsideDirectory(texturePath, mtlDirectory)) {
// Try looking for the texture in the same directory as the obj
options.logger('Texture file is outside of the mtl directory and the secure flag is true. Attempting to read the texture file from within the obj directory instead.');
texturePromise = loadTexture(shallowPath, textureOptions)
.catch(function(error) {
options.logger(
"Texture file is outside of the mtl directory and the secure flag is true. Attempting to read the texture file from within the obj directory instead."
);
texturePromise = loadTexture(shallowPath, textureOptions).catch(function (
error
) {
options.logger(error.message);
options.logger('Could not read texture file at ' + shallowPath + '. This texture will be ignored');
options.logger(
"Could not read texture file at " +
shallowPath +
". This texture will be ignored"
);
});
} else {
texturePromise = loadTexture(texturePath, textureOptions)
.catch(function (error) {
// Try looking for the texture in the same directory as the obj
options.logger(error.message);
options.logger('Could not read texture file at ' + texturePath + '. Attempting to read the texture file from within the obj directory instead.');
options.logger(
"Could not read texture file at " +
texturePath +
". Attempting to read the texture file from within the obj directory instead."
);
return loadTexture(shallowPath, textureOptions);
})
.catch(function (error) {
options.logger(error.message);
options.logger('Could not read texture file at ' + shallowPath + '. This texture will be ignored.');
options.logger(
"Could not read texture file at " +
shallowPath +
". This texture will be ignored."
);
});
}
texturePromiseMap[texturePath] = texturePromise;
}
texturePromises.push(texturePromise
.then(function(texture) {
texturePromises.push(
texturePromise.then(function (texture) {
material[name] = texture;
}));
})
);
}
function convertMaterial(material, options) {
@ -305,7 +399,14 @@ function convertMaterials(materials, options) {
});
}
function resizeChannel(sourcePixels, sourceWidth, sourceHeight, targetPixels, targetWidth, targetHeight) {
function resizeChannel(
sourcePixels,
sourceWidth,
sourceHeight,
targetPixels,
targetWidth,
targetHeight
) {
// Nearest neighbor sampling
const widthRatio = sourceWidth / targetWidth;
const heightRatio = sourceHeight / targetHeight;
@ -325,7 +426,13 @@ function resizeChannel(sourcePixels, sourceWidth, sourceHeight, targetPixels, ta
let scratchResizeChannel;
function getTextureChannel(texture, index, targetWidth, targetHeight, targetChannel) {
function getTextureChannel(
texture,
index,
targetWidth,
targetHeight,
targetChannel
) {
const pixels = texture.pixels; // RGBA
const sourceWidth = texture.width;
const sourceHeight = texture.height;
@ -335,7 +442,10 @@ function getTextureChannel(texture, index, targetWidth, targetHeight, targetChan
// Allocate the scratchResizeChannel on demand if the texture needs to be resized
let sourceChannel = targetChannel;
if (sourcePixelsLength > targetPixelsLength) {
if (!defined(scratchResizeChannel) || (sourcePixelsLength > scratchResizeChannel.length)) {
if (
!defined(scratchResizeChannel) ||
sourcePixelsLength > scratchResizeChannel.length
) {
scratchResizeChannel = Buffer.alloc(sourcePixelsLength);
}
sourceChannel = scratchResizeChannel;
@ -347,7 +457,14 @@ function getTextureChannel(texture, index, targetWidth, targetHeight, targetChan
}
if (sourcePixelsLength > targetPixelsLength) {
resizeChannel(sourceChannel, sourceWidth, sourceHeight, targetChannel, targetWidth, targetHeight);
resizeChannel(
sourceChannel,
sourceWidth,
sourceHeight,
targetChannel,
targetWidth,
targetHeight
);
}
return targetChannel;
@ -375,7 +492,19 @@ function getMinimumDimensions(textures, options) {
for (let i = 0; i < length; ++i) {
const texture = textures[i];
if (texture.width !== width || texture.height !== height) {
options.logger('Texture ' + texture.path + ' will be scaled from ' + texture.width + 'x' + texture.height + ' to ' + width + 'x' + height + '.');
options.logger(
"Texture " +
texture.path +
" will be scaled from " +
texture.width +
"x" +
texture.height +
" to " +
width +
"x" +
height +
"."
);
}
}
@ -410,7 +539,13 @@ function createDiffuseAlphaTexture(diffuseTexture, alphaTexture, options) {
}
if (!defined(diffuseTexture.pixels) || !defined(alphaTexture.pixels)) {
options.logger('Could not get decoded texture data for ' + diffuseTexture.path + ' or ' + alphaTexture.path + '. The material will be created without an alpha texture.');
options.logger(
"Could not get decoded texture data for " +
diffuseTexture.path +
" or " +
alphaTexture.path +
". The material will be created without an alpha texture."
);
return diffuseTexture;
}
@ -419,27 +554,57 @@ function createDiffuseAlphaTexture(diffuseTexture, alphaTexture, options) {
const width = dimensions[0];
const height = dimensions[1];
const pixelsLength = width * height;
const pixels = Buffer.alloc(pixelsLength * 4, 0xFF); // Initialize with 4 channels
const pixels = Buffer.alloc(pixelsLength * 4, 0xff); // Initialize with 4 channels
const scratchChannel = Buffer.alloc(pixelsLength);
// Write into the R, G, B channels
const redChannel = getTextureChannel(diffuseTexture, 0, width, height, scratchChannel);
const redChannel = getTextureChannel(
diffuseTexture,
0,
width,
height,
scratchChannel
);
writeChannel(pixels, redChannel, 0);
const greenChannel = getTextureChannel(diffuseTexture, 1, width, height, scratchChannel);
const greenChannel = getTextureChannel(
diffuseTexture,
1,
width,
height,
scratchChannel
);
writeChannel(pixels, greenChannel, 1);
const blueChannel = getTextureChannel(diffuseTexture, 2, width, height, scratchChannel);
const blueChannel = getTextureChannel(
diffuseTexture,
2,
width,
height,
scratchChannel
);
writeChannel(pixels, blueChannel, 2);
// First try reading the alpha component from the alpha channel, but if it is a single color read from the red channel instead.
let alphaChannel = getTextureChannel(alphaTexture, 3, width, height, scratchChannel);
let alphaChannel = getTextureChannel(
alphaTexture,
3,
width,
height,
scratchChannel
);
if (isChannelSingleColor(alphaChannel)) {
alphaChannel = getTextureChannel(alphaTexture, 0, width, height, scratchChannel);
alphaChannel = getTextureChannel(
alphaTexture,
0,
width,
height,
scratchChannel
);
}
writeChannel(pixels, alphaChannel, 3);
const texture = new Texture();
texture.name = diffuseTexture.name;
texture.extension = '.png';
texture.extension = ".png";
texture.pixels = pixels;
texture.width = width;
texture.height = height;
@ -448,7 +613,12 @@ function createDiffuseAlphaTexture(diffuseTexture, alphaTexture, options) {
return texture;
}
function createMetallicRoughnessTexture(metallicTexture, roughnessTexture, occlusionTexture, options) {
function createMetallicRoughnessTexture(
metallicTexture,
roughnessTexture,
occlusionTexture,
options
) {
if (defined(options.overridingTextures.metallicRoughnessOcclusionTexture)) {
return metallicTexture;
}
@ -462,21 +632,37 @@ function createMetallicRoughnessTexture(metallicTexture, roughnessTexture, occlu
}
if (packMetallic && !defined(metallicTexture.pixels)) {
options.logger('Could not get decoded texture data for ' + metallicTexture.path + '. The material will be created without a metallicRoughness texture.');
options.logger(
"Could not get decoded texture data for " +
metallicTexture.path +
". The material will be created without a metallicRoughness texture."
);
return undefined;
}
if (packRoughness && !defined(roughnessTexture.pixels)) {
options.logger('Could not get decoded texture data for ' + roughnessTexture.path + '. The material will be created without a metallicRoughness texture.');
options.logger(
"Could not get decoded texture data for " +
roughnessTexture.path +
". The material will be created without a metallicRoughness texture."
);
return undefined;
}
if (packOcclusion && !defined(occlusionTexture.pixels)) {
options.logger('Could not get decoded texture data for ' + occlusionTexture.path + '. The occlusion texture will not be packed in the metallicRoughness texture.');
options.logger(
"Could not get decoded texture data for " +
occlusionTexture.path +
". The occlusion texture will not be packed in the metallicRoughness texture."
);
return undefined;
}
const packedTextures = [metallicTexture, roughnessTexture, occlusionTexture].filter(function(texture) {
const packedTextures = [
metallicTexture,
roughnessTexture,
occlusionTexture,
].filter(function (texture) {
return defined(texture) && defined(texture.pixels);
});
@ -484,24 +670,42 @@ function createMetallicRoughnessTexture(metallicTexture, roughnessTexture, occlu
const width = dimensions[0];
const height = dimensions[1];
const pixelsLength = width * height;
const pixels = Buffer.alloc(pixelsLength * 4, 0xFF); // Initialize with 4 channels, unused channels will be white
const pixels = Buffer.alloc(pixelsLength * 4, 0xff); // Initialize with 4 channels, unused channels will be white
const scratchChannel = Buffer.alloc(pixelsLength);
if (packMetallic) {
// Write into the B channel
const metallicChannel = getTextureChannel(metallicTexture, 0, width, height, scratchChannel);
const metallicChannel = getTextureChannel(
metallicTexture,
0,
width,
height,
scratchChannel
);
writeChannel(pixels, metallicChannel, 2);
}
if (packRoughness) {
// Write into the G channel
const roughnessChannel = getTextureChannel(roughnessTexture, 0, width, height, scratchChannel);
const roughnessChannel = getTextureChannel(
roughnessTexture,
0,
width,
height,
scratchChannel
);
writeChannel(pixels, roughnessChannel, 1);
}
if (packOcclusion) {
// Write into the R channel
const occlusionChannel = getTextureChannel(occlusionTexture, 0, width, height, scratchChannel);
const occlusionChannel = getTextureChannel(
occlusionTexture,
0,
width,
height,
scratchChannel
);
writeChannel(pixels, occlusionChannel, 0);
}
@ -510,11 +714,11 @@ function createMetallicRoughnessTexture(metallicTexture, roughnessTexture, occlu
for (let i = 0; i < length; ++i) {
names[i] = packedTextures[i].name;
}
const name = names.join('_');
const name = names.join("_");
const texture = new Texture();
texture.name = name;
texture.extension = '.png';
texture.extension = ".png";
texture.pixels = pixels;
texture.width = width;
texture.height = height;
@ -522,7 +726,11 @@ function createMetallicRoughnessTexture(metallicTexture, roughnessTexture, occlu
return texture;
}
function createSpecularGlossinessTexture(specularTexture, glossinessTexture, options) {
function createSpecularGlossinessTexture(
specularTexture,
glossinessTexture,
options
) {
if (defined(options.overridingTextures.specularGlossinessTexture)) {
return specularTexture;
}
@ -535,16 +743,26 @@ function createSpecularGlossinessTexture(specularTexture, glossinessTexture, opt
}
if (packSpecular && !defined(specularTexture.pixels)) {
options.logger('Could not get decoded texture data for ' + specularTexture.path + '. The material will be created without a specularGlossiness texture.');
options.logger(
"Could not get decoded texture data for " +
specularTexture.path +
". The material will be created without a specularGlossiness texture."
);
return undefined;
}
if (packGlossiness && !defined(glossinessTexture.pixels)) {
options.logger('Could not get decoded texture data for ' + glossinessTexture.path + '. The material will be created without a specularGlossiness texture.');
options.logger(
"Could not get decoded texture data for " +
glossinessTexture.path +
". The material will be created without a specularGlossiness texture."
);
return undefined;
}
const packedTextures = [specularTexture, glossinessTexture].filter(function(texture) {
const packedTextures = [specularTexture, glossinessTexture].filter(function (
texture
) {
return defined(texture) && defined(texture.pixels);
});
@ -552,22 +770,46 @@ function createSpecularGlossinessTexture(specularTexture, glossinessTexture, opt
const width = dimensions[0];
const height = dimensions[1];
const pixelsLength = width * height;
const pixels = Buffer.alloc(pixelsLength * 4, 0xFF); // Initialize with 4 channels, unused channels will be white
const pixels = Buffer.alloc(pixelsLength * 4, 0xff); // Initialize with 4 channels, unused channels will be white
const scratchChannel = Buffer.alloc(pixelsLength);
if (packSpecular) {
// Write into the R, G, B channels
const redChannel = getTextureChannel(specularTexture, 0, width, height, scratchChannel);
const redChannel = getTextureChannel(
specularTexture,
0,
width,
height,
scratchChannel
);
writeChannel(pixels, redChannel, 0);
const greenChannel = getTextureChannel(specularTexture, 1, width, height, scratchChannel);
const greenChannel = getTextureChannel(
specularTexture,
1,
width,
height,
scratchChannel
);
writeChannel(pixels, greenChannel, 1);
const blueChannel = getTextureChannel(specularTexture, 2, width, height, scratchChannel);
const blueChannel = getTextureChannel(
specularTexture,
2,
width,
height,
scratchChannel
);
writeChannel(pixels, blueChannel, 2);
}
if (packGlossiness) {
// Write into the A channel
const glossinessChannel = getTextureChannel(glossinessTexture, 0, width, height, scratchChannel);
const glossinessChannel = getTextureChannel(
glossinessTexture,
0,
width,
height,
scratchChannel
);
writeChannel(pixels, glossinessChannel, 3);
}
@ -576,11 +818,11 @@ function createSpecularGlossinessTexture(specularTexture, glossinessTexture, opt
for (let i = 0; i < length; ++i) {
names[i] = packedTextures[i].name;
}
const name = names.join('_');
const name = names.join("_");
const texture = new Texture();
texture.name = name;
texture.extension = '.png';
texture.extension = ".png";
texture.pixels = pixels;
texture.width = width;
texture.height = height;
@ -596,8 +838,16 @@ function createSpecularGlossinessMaterial(material, options) {
const alphaTexture = material.alphaTexture;
const specularTexture = material.specularTexture;
const glossinessTexture = material.specularShininessTexture;
const specularGlossinessTexture = createSpecularGlossinessTexture(specularTexture, glossinessTexture, options);
const diffuseAlphaTexture = createDiffuseAlphaTexture(diffuseTexture, alphaTexture, options);
const specularGlossinessTexture = createSpecularGlossinessTexture(
specularTexture,
glossinessTexture,
options
);
const diffuseAlphaTexture = createDiffuseAlphaTexture(
diffuseTexture,
alphaTexture,
options
);
let emissiveFactor = material.emissiveColor.slice(0, 3);
let diffuseFactor = material.diffuseColor;
@ -634,7 +884,7 @@ function createSpecularGlossinessMaterial(material, options) {
}
const doubleSided = transparent;
const alphaMode = transparent ? 'BLEND' : 'OPAQUE';
const alphaMode = transparent ? "BLEND" : "OPAQUE";
return {
name: material.name,
@ -644,15 +894,15 @@ function createSpecularGlossinessMaterial(material, options) {
specularGlossinessTexture: specularGlossinessTexture,
diffuseFactor: diffuseFactor,
specularFactor: specularFactor,
glossinessFactor : glossinessFactor
}
glossinessFactor: glossinessFactor,
},
},
emissiveTexture: emissiveTexture,
normalTexture: normalTexture,
occlusionTexture: occlusionTexture,
emissiveFactor: emissiveFactor,
alphaMode: alphaMode,
doubleSided : doubleSided
doubleSided: doubleSided,
};
}
@ -664,8 +914,17 @@ function createMetallicRoughnessMaterial(material, options) {
const alphaTexture = material.alphaTexture;
const metallicTexture = material.specularTexture;
const roughnessTexture = material.specularShininessTexture;
const metallicRoughnessTexture = createMetallicRoughnessTexture(metallicTexture, roughnessTexture, occlusionTexture, options);
const diffuseAlphaTexture = createDiffuseAlphaTexture(baseColorTexture, alphaTexture, options);
const metallicRoughnessTexture = createMetallicRoughnessTexture(
metallicTexture,
roughnessTexture,
occlusionTexture,
options
);
const diffuseAlphaTexture = createDiffuseAlphaTexture(
baseColorTexture,
alphaTexture,
options
);
if (options.packOcclusion) {
occlusionTexture = metallicRoughnessTexture;
@ -706,7 +965,7 @@ function createMetallicRoughnessMaterial(material, options) {
}
const doubleSided = transparent;
const alphaMode = transparent ? 'BLEND' : 'OPAQUE';
const alphaMode = transparent ? "BLEND" : "OPAQUE";
return {
name: material.name,
@ -715,14 +974,14 @@ function createMetallicRoughnessMaterial(material, options) {
metallicRoughnessTexture: metallicRoughnessTexture,
baseColorFactor: baseColorFactor,
metallicFactor: metallicFactor,
roughnessFactor : roughnessFactor
roughnessFactor: roughnessFactor,
},
emissiveTexture: emissiveTexture,
normalTexture: normalTexture,
occlusionTexture: occlusionTexture,
emissiveFactor: emissiveFactor,
alphaMode: alphaMode,
doubleSided : doubleSided
doubleSided: doubleSided,
};
}
@ -745,11 +1004,16 @@ function convertTraditionalToMetallicRoughness(material) {
// Low specular intensity values should produce a rough material even if shininess is high.
if (specularIntensity < 0.1) {
roughnessFactor *= (1.0 - specularIntensity);
roughnessFactor *= 1.0 - specularIntensity;
}
const metallicFactor = 0.0;
material.specularColor = [metallicFactor, metallicFactor, metallicFactor, 1.0];
material.specularColor = [
metallicFactor,
metallicFactor,
metallicFactor,
1.0,
];
material.specularShininess = roughnessFactor;
}

227
lib/loadObj.js
View File

@ -1,12 +1,12 @@
'use strict';
const Cesium = require('cesium');
const path = require('path');
const Promise = require('bluebird');
"use strict";
const Cesium = require("cesium");
const path = require("path");
const Promise = require("bluebird");
const ArrayStorage = require('./ArrayStorage');
const loadMtl = require('./loadMtl');
const outsideDirectory = require('./outsideDirectory');
const readLines = require('./readLines');
const ArrayStorage = require("./ArrayStorage");
const loadMtl = require("./loadMtl");
const outsideDirectory = require("./outsideDirectory");
const readLines = require("./readLines");
const Axis = Cesium.Axis;
const Cartesian3 = Cesium.Cartesian3;
@ -44,8 +44,10 @@ function Primitive() {
}
// OBJ regex patterns are modified from ThreeJS (https://github.com/mrdoob/three.js/blob/master/examples/js/loaders/OBJLoader.js)
const vertexPattern = /v( +[\d|\.|\+|\-|e|E]+)( +[\d|\.|\+|\-|e|E]+)( +[\d|\.|\+|\-|e|E]+)/; // v float float float
const normalPattern = /vn( +[\d|\.|\+|\-|e|E]+)( +[\d|\.|\+|\-|e|E]+)( +[\d|\.|\+|\-|e|E]+)/; // vn float float float
const vertexPattern =
/v( +[\d|\.|\+|\-|e|E]+)( +[\d|\.|\+|\-|e|E]+)( +[\d|\.|\+|\-|e|E]+)/; // v float float float
const normalPattern =
/vn( +[\d|\.|\+|\-|e|E]+)( +[\d|\.|\+|\-|e|E]+)( +[\d|\.|\+|\-|e|E]+)/; // vn float float float
const uvPattern = /vt( +[\d|\.|\+|\-|e|E]+)( +[\d|\.|\+|\-|e|E]+)/; // vt float float
const facePattern = /(-?\d+)\/?(-?\d*)\/?(-?\d*)/g; // for any face format "f v", "f v/v", "f v//v", "f v/v/v"
@ -61,7 +63,10 @@ const scratchCartesian = new Cartesian3();
* @private
*/
function loadObj(objPath, options) {
const axisTransform = getAxisTransform(options.inputUpAxis, options.outputUpAxis);
const axisTransform = getAxisTransform(
options.inputUpAxis,
options.outputUpAxis
);
// Global store of vertex attributes listed in the obj file
let globalPositions = new ArrayStorage(ComponentDatatype.FLOAT);
@ -87,7 +92,7 @@ function loadObj(objPath, options) {
let mtlPaths = [];
// Buffers for face data that spans multiple lines
let lineBuffer = '';
let lineBuffer = "";
// Used for parsing face data
const faceVertices = [];
@ -101,7 +106,7 @@ function loadObj(objPath, options) {
}
function getName(name) {
return (name === '' ? undefined : name);
return name === "" ? undefined : name;
}
function addNode(name) {
@ -154,7 +159,9 @@ function loadObj(objPath, options) {
const faceHasNormals = defined(normals[0]);
const primitiveHasUvs = primitive.uvs.length > 0;
const primitiveHasNormals = primitive.normals.length > 0;
return primitiveHasUvs === faceHasUvs && primitiveHasNormals === faceHasNormals;
return (
primitiveHasUvs === faceHasUvs && primitiveHasNormals === faceHasNormals
);
}
function checkPrimitive(uvs, normals) {
@ -170,18 +177,26 @@ function loadObj(objPath, options) {
const i = parseInt(index);
if (i < 0) {
// Negative vertex indexes reference the vertices immediately above it
return (attributeData.length / components + i);
return attributeData.length / components + i;
}
return i - 1;
}
function correctAttributeIndices(attributeIndices, attributeData, components) {
function correctAttributeIndices(
attributeIndices,
attributeData,
components
) {
const length = attributeIndices.length;
for (let i = 0; i < length; ++i) {
if (attributeIndices[i].length === 0) {
attributeIndices[i] = undefined;
} else {
attributeIndices[i] = getIndexFromStart(attributeIndices[i], attributeData, components);
attributeIndices[i] = getIndexFromStart(
attributeIndices[i],
attributeData,
components
);
}
}
}
@ -189,13 +204,18 @@ function loadObj(objPath, options) {
function correctVertices(vertices, positions, uvs, normals) {
const length = vertices.length;
for (let i = 0; i < length; ++i) {
vertices[i] = defaultValue(positions[i], '') + '/' + defaultValue(uvs[i], '') + '/' + defaultValue(normals[i], '');
vertices[i] =
defaultValue(positions[i], "") +
"/" +
defaultValue(uvs[i], "") +
"/" +
defaultValue(normals[i], "");
}
}
function createVertex(p, u, n) {
// Positions
if (defined(p) && (globalPositions.length > 0)) {
if (defined(p) && globalPositions.length > 0) {
if (p * 3 >= globalPositions.length) {
throw new RuntimeError(`Position index ${p} is out of bounds`);
}
@ -208,7 +228,7 @@ function loadObj(objPath, options) {
}
// Normals
if (defined(n) && (globalNormals.length > 0)) {
if (defined(n) && globalNormals.length > 0) {
if (n * 3 >= globalNormals.length) {
throw new RuntimeError(`Normal index ${n} is out of bounds`);
}
@ -221,7 +241,7 @@ function loadObj(objPath, options) {
}
// UVs
if (defined(u) && (globalUvs.length > 0)) {
if (defined(u) && globalUvs.length > 0) {
if (u * 2 >= globalUvs.length) {
throw new RuntimeError(`UV index ${u} is out of bounds`);
}
@ -272,11 +292,21 @@ function loadObj(objPath, options) {
const scratchAxis1 = new Cartesian3();
const scratchAxis2 = new Cartesian3();
const scratchNormal = new Cartesian3();
const scratchPositions = [new Cartesian3(), new Cartesian3(), new Cartesian3(), new Cartesian3()];
const scratchPositions = [
new Cartesian3(),
new Cartesian3(),
new Cartesian3(),
new Cartesian3(),
];
const scratchVertexIndices = [];
const scratchPoints = [];
function checkWindingCorrect(positionIndex1, positionIndex2, positionIndex3, normalIndex) {
function checkWindingCorrect(
positionIndex1,
positionIndex2,
positionIndex3,
normalIndex
) {
if (!defined(normalIndex)) {
// If no face normal, we have to assume the winding is correct.
return true;
@ -290,7 +320,7 @@ function loadObj(objPath, options) {
const CA = Cartesian3.subtract(C, A, scratch5);
const cross = Cartesian3.cross(BA, CA, scratch3);
return (Cartesian3.dot(normal, cross) >= 0);
return Cartesian3.dot(normal, cross) >= 0;
}
function addTriangle(index1, index2, index3, correctWinding) {
@ -305,7 +335,13 @@ function loadObj(objPath, options) {
}
}
function addFace(vertices, positions, uvs, normals, triangleWindingOrderSanitization) {
function addFace(
vertices,
positions,
uvs,
normals,
triangleWindingOrderSanitization
) {
correctAttributeIndices(positions, globalPositions, 3);
correctAttributeIndices(normals, globalNormals, 3);
correctAttributeIndices(uvs, globalUvs, 2);
@ -314,12 +350,20 @@ function loadObj(objPath, options) {
checkPrimitive(uvs, faceNormals);
if (vertices.length === 3) {
const isWindingCorrect = !triangleWindingOrderSanitization || checkWindingCorrect(positions[0], positions[1], positions[2], normals[0]);
const isWindingCorrect =
!triangleWindingOrderSanitization ||
checkWindingCorrect(
positions[0],
positions[1],
positions[2],
normals[0]
);
const index1 = addVertex(vertices[0], positions[0], uvs[0], normals[0]);
const index2 = addVertex(vertices[1], positions[1], uvs[1], normals[1]);
const index3 = addVertex(vertices[2], positions[2], uvs[2], normals[2]);
addTriangle(index1, index2, index3, isWindingCorrect);
} else { // Triangulate if the face is not a triangle
} else {
// Triangulate if the face is not a triangle
const points = scratchPoints;
const vertexIndices = scratchVertexIndices;
@ -335,17 +379,35 @@ function loadObj(objPath, options) {
points.push(getPosition(positions[i], scratchPositions[i]));
}
const validGeometry = CoplanarPolygonGeometryLibrary.computeProjectTo2DArguments(points, scratchCenter, scratchAxis1, scratchAxis2);
const validGeometry =
CoplanarPolygonGeometryLibrary.computeProjectTo2DArguments(
points,
scratchCenter,
scratchAxis1,
scratchAxis2
);
if (!validGeometry) {
return;
}
const projectPoints = CoplanarPolygonGeometryLibrary.createProjectPointsTo2DFunction(scratchCenter, scratchAxis1, scratchAxis2);
const projectPoints =
CoplanarPolygonGeometryLibrary.createProjectPointsTo2DFunction(
scratchCenter,
scratchAxis1,
scratchAxis2
);
const points2D = projectPoints(points);
const indices = PolygonPipeline.triangulate(points2D);
const isWindingCorrect = PolygonPipeline.computeWindingOrder2D(points2D) !== WindingOrder.CLOCKWISE;
const isWindingCorrect =
PolygonPipeline.computeWindingOrder2D(points2D) !==
WindingOrder.CLOCKWISE;
for (let i = 0; i < indices.length - 2; i += 3) {
addTriangle(vertexIndices[indices[i]], vertexIndices[indices[i+1]], vertexIndices[indices[i+2]], isWindingCorrect);
addTriangle(
vertexIndices[indices[i]],
vertexIndices[indices[i + 1]],
vertexIndices[indices[i + 2]],
isWindingCorrect
);
}
}
}
@ -354,7 +416,7 @@ function loadObj(objPath, options) {
line = line.trim();
let result;
if ((line.length === 0) || (line.charAt(0) === '#')) {
if (line.length === 0 || line.charAt(0) === "#") {
// Don't process empty lines or comments
} else if (/^o\s/i.test(line)) {
const objectName = line.substring(2).trim();
@ -380,7 +442,12 @@ function loadObj(objPath, options) {
globalPositions.push(position.y);
globalPositions.push(position.z);
} else if ((result = normalPattern.exec(line)) !== null) {
const normal = Cartesian3.fromElements(parseFloat(result[1]), parseFloat(result[2]), parseFloat(result[3]), scratchNormal);
const normal = Cartesian3.fromElements(
parseFloat(result[1]),
parseFloat(result[2]),
parseFloat(result[3]),
scratchNormal
);
if (Cartesian3.equals(normal, Cartesian3.ZERO)) {
Cartesian3.clone(Cartesian3.UNIT_Z, normal);
} else {
@ -395,15 +462,16 @@ function loadObj(objPath, options) {
} else if ((result = uvPattern.exec(line)) !== null) {
globalUvs.push(parseFloat(result[1]));
globalUvs.push(1.0 - parseFloat(result[2])); // Flip y so 0.0 is the bottom of the image
} else { // face line or invalid line
} else {
// face line or invalid line
// Because face lines can contain n vertices, we use a line buffer in case the face data spans multiple lines.
// If there's a line continuation don't create face yet
if (line.slice(-1) === '\\') {
if (line.slice(-1) === "\\") {
lineBuffer += line.substring(0, line.length - 1);
return;
}
lineBuffer += line;
if (lineBuffer.substring(0, 2) === 'f ') {
if (lineBuffer.substring(0, 2) === "f ") {
while ((result = facePattern.exec(lineBuffer)) !== null) {
faceVertices.push(result[0]);
facePositions.push(result[1]);
@ -411,7 +479,13 @@ function loadObj(objPath, options) {
faceNormals.push(result[3]);
}
if (faceVertices.length > 2) {
addFace(faceVertices, facePositions, faceUvs, faceNormals, options.triangleWindingOrderSanitization);
addFace(
faceVertices,
facePositions,
faceUvs,
faceNormals,
options.triangleWindingOrderSanitization
);
}
faceVertices.length = 0;
@ -419,7 +493,7 @@ function loadObj(objPath, options) {
faceNormals.length = 0;
faceUvs.length = 0;
}
lineBuffer = '';
lineBuffer = "";
}
}
@ -427,29 +501,34 @@ function loadObj(objPath, options) {
addNode();
// Parse the obj file
return readLines(objPath, parseLine)
.then(function() {
return readLines(objPath, parseLine).then(function () {
// Unload resources
globalPositions = undefined;
globalNormals = undefined;
globalUvs = undefined;
// Load materials and textures
return finishLoading(nodes, mtlPaths, objPath, defined(activeMaterial), options);
return finishLoading(
nodes,
mtlPaths,
objPath,
defined(activeMaterial),
options
);
});
}
function getMtlPaths(mtllibLine) {
// Handle paths with spaces. E.g. mtllib my material file.mtl
const mtlPaths = [];
const splits = mtllibLine.split(' ');
const splits = mtllibLine.split(" ");
const length = splits.length;
let startIndex = 0;
for (let i = 0; i < length; ++i) {
if (path.extname(splits[i]) !== '.mtl') {
if (path.extname(splits[i]) !== ".mtl") {
continue;
}
const mtlPath = splits.slice(startIndex, i + 1).join(' ');
const mtlPath = splits.slice(startIndex, i + 1).join(" ");
mtlPaths.push(mtlPath);
startIndex = i + 1;
}
@ -459,11 +538,10 @@ function getMtlPaths(mtllibLine) {
function finishLoading(nodes, mtlPaths, objPath, usesMaterials, options) {
nodes = cleanNodes(nodes);
if (nodes.length === 0) {
throw new RuntimeError(objPath + ' does not have any geometry data');
throw new RuntimeError(objPath + " does not have any geometry data");
}
const name = path.basename(objPath, path.extname(objPath));
return loadMtls(mtlPaths, objPath, options)
.then(function(materials) {
return loadMtls(mtlPaths, objPath, options).then(function (materials) {
if (materials.length > 0 && !usesMaterials) {
assignDefaultMaterial(nodes, materials, usesMaterials);
}
@ -471,13 +549,13 @@ function finishLoading(nodes, mtlPaths, objPath, usesMaterials, options) {
return {
nodes: nodes,
materials: materials,
name : name
name: name,
};
});
}
function normalizeMtlPath(mtlPath, objDirectory) {
mtlPath = mtlPath.replace(/\\/g, '/');
mtlPath = mtlPath.replace(/\\/g, "/");
return path.normalize(path.resolve(objDirectory, mtlPath));
}
@ -490,19 +568,27 @@ function loadMtls(mtlPaths, objPath, options) {
return self.indexOf(value) === index;
});
return Promise.map(mtlPaths, function(mtlPath) {
return Promise.map(
mtlPaths,
function (mtlPath) {
mtlPath = normalizeMtlPath(mtlPath, objDirectory);
const shallowPath = path.join(objDirectory, path.basename(mtlPath));
if (options.secure && outsideDirectory(mtlPath, objDirectory)) {
// Try looking for the .mtl in the same directory as the obj
options.logger('The material file is outside of the obj directory and the secure flag is true. Attempting to read the material file from within the obj directory instead.');
options.logger(
"The material file is outside of the obj directory and the secure flag is true. Attempting to read the material file from within the obj directory instead."
);
return loadMtl(shallowPath, options)
.then(function (materialsInMtl) {
materials = materials.concat(materialsInMtl);
})
.catch(function (error) {
options.logger(error.message);
options.logger('Could not read material file at ' + shallowPath + '. Using default material instead.');
options.logger(
"Could not read material file at " +
shallowPath +
". Using default material instead."
);
});
}
@ -510,7 +596,11 @@ function loadMtls(mtlPaths, objPath, options) {
.catch(function (error) {
// Try looking for the .mtl in the same directory as the obj
options.logger(error.message);
options.logger('Could not read material file at ' + mtlPath + '. Attempting to read the material file from within the obj directory instead.');
options.logger(
"Could not read material file at " +
mtlPath +
". Attempting to read the material file from within the obj directory instead."
);
return loadMtl(shallowPath, options);
})
.then(function (materialsInMtl) {
@ -518,10 +608,15 @@ function loadMtls(mtlPaths, objPath, options) {
})
.catch(function (error) {
options.logger(error.message);
options.logger('Could not read material file at ' + shallowPath + '. Using default material instead.');
options.logger(
"Could not read material file at " +
shallowPath +
". Using default material instead."
);
});
}, {concurrency : 10})
.then(function() {
},
{ concurrency: 10 }
).then(function () {
return materials;
});
}
@ -578,7 +673,7 @@ function removeEmptyMeshes(meshes) {
return primitive.indices.length > 0 && primitive.positions.length > 0;
});
// Valid meshes must have at least one primitive
return (mesh.primitives.length > 0);
return mesh.primitives.length > 0;
});
}
@ -627,7 +722,7 @@ function setDefaultNames(items, defaultName, usedNames) {
const occurrences = usedNames[name];
if (defined(occurrences)) {
usedNames[name]++;
name = name + '_' + occurrences;
name = name + "_" + occurrences;
} else {
usedNames[name] = 1;
}
@ -637,11 +732,11 @@ function setDefaultNames(items, defaultName, usedNames) {
function setDefaults(nodes) {
const usedNames = {};
setDefaultNames(nodes, 'Node', usedNames);
setDefaultNames(nodes, "Node", usedNames);
const nodesLength = nodes.length;
for (let i = 0; i < nodesLength; ++i) {
const node = nodes[i];
setDefaultNames(node.meshes, node.name + '-Mesh', usedNames);
setDefaultNames(node.meshes, node.name + "-Mesh", usedNames);
}
}
@ -652,17 +747,17 @@ function cleanNodes(nodes) {
}
function getAxisTransform(inputUpAxis, outputUpAxis) {
if (inputUpAxis === 'X' && outputUpAxis === 'Y') {
if (inputUpAxis === "X" && outputUpAxis === "Y") {
return Axis.X_UP_TO_Y_UP;
} else if (inputUpAxis === 'X' && outputUpAxis === 'Z') {
} else if (inputUpAxis === "X" && outputUpAxis === "Z") {
return Axis.X_UP_TO_Z_UP;
} else if (inputUpAxis === 'Y' && outputUpAxis === 'X') {
} else if (inputUpAxis === "Y" && outputUpAxis === "X") {
return Axis.Y_UP_TO_X_UP;
} else if (inputUpAxis === 'Y' && outputUpAxis === 'Z') {
} else if (inputUpAxis === "Y" && outputUpAxis === "Z") {
return Axis.Y_UP_TO_Z_UP;
} else if (inputUpAxis === 'Z' && outputUpAxis === 'X') {
} else if (inputUpAxis === "Z" && outputUpAxis === "X") {
return Axis.Z_UP_TO_X_UP;
} else if (inputUpAxis === 'Z' && outputUpAxis === 'Y') {
} else if (inputUpAxis === "Z" && outputUpAxis === "Y") {
return Axis.Z_UP_TO_Y_UP;
}
}

31
lib/loadTexture.js
View File

@ -1,11 +1,11 @@
'use strict';
const Cesium = require('cesium');
const fsExtra = require('fs-extra');
const jpeg = require('jpeg-js');
const path = require('path');
const PNG = require('pngjs').PNG;
const Promise = require('bluebird');
const Texture = require('./Texture');
"use strict";
const Cesium = require("cesium");
const fsExtra = require("fs-extra");
const jpeg = require("jpeg-js");
const path = require("path");
const PNG = require("pngjs").PNG;
const Promise = require("bluebird");
const Texture = require("./Texture");
const defaultValue = Cesium.defaultValue;
const defined = Cesium.defined;
@ -30,8 +30,7 @@ function loadTexture(texturePath, options) {
options.decode = defaultValue(options.decode, false);
options.keepSource = defaultValue(options.keepSource, false);
return fsExtra.readFile(texturePath)
.then(function(source) {
return fsExtra.readFile(texturePath).then(function (source) {
const name = path.basename(texturePath, path.extname(texturePath));
const extension = path.extname(texturePath).toLowerCase();
const texture = new Texture();
@ -41,15 +40,14 @@ function loadTexture(texturePath, options) {
texture.path = texturePath;
let decodePromise;
if (extension === '.png') {
if (extension === ".png") {
decodePromise = decodePng(texture, options);
} else if (extension === '.jpg' || extension === '.jpeg') {
} else if (extension === ".jpg" || extension === ".jpeg") {
decodePromise = decodeJpeg(texture, options);
}
if (defined(decodePromise)) {
return decodePromise
.then(function() {
return decodePromise.then(function () {
return texture;
});
}
@ -101,12 +99,11 @@ function decodePng(texture, options) {
const colorType = source[25];
const channels = getChannels(colorType);
const checkTransparency = (channels === 4 && options.checkTransparency);
const checkTransparency = channels === 4 && options.checkTransparency;
const decode = options.decode || checkTransparency;
if (decode) {
return parsePng(source)
.then(function(decodedResults) {
return parsePng(source).then(function (decodedResults) {
if (options.checkTransparency) {
texture.transparent = hasTransparency(decodedResults.data);
}

88
lib/obj2gltf.js
View File

@ -1,10 +1,10 @@
'use strict';
const Cesium = require('cesium');
const fsExtra = require('fs-extra');
const path = require('path');
const createGltf = require('./createGltf');
const loadObj = require('./loadObj');
const writeGltf = require('./writeGltf');
"use strict";
const Cesium = require("cesium");
const fsExtra = require("fs-extra");
const path = require("path");
const createGltf = require("./createGltf");
const loadObj = require("./loadObj");
const writeGltf = require("./writeGltf");
const defaultValue = Cesium.defaultValue;
const defined = Cesium.defined;
@ -47,34 +47,72 @@ function obj2gltf(objPath, options) {
options = defaultValue(options, {});
options.binary = defaultValue(options.binary, defaults.binary);
options.separate = defaultValue(options.separate, defaults.separate);
options.separateTextures = defaultValue(options.separateTextures, defaults.separateTextures) || options.separate;
options.checkTransparency = defaultValue(options.checkTransparency, defaults.checkTransparency);
options.separateTextures =
defaultValue(options.separateTextures, defaults.separateTextures) ||
options.separate;
options.checkTransparency = defaultValue(
options.checkTransparency,
defaults.checkTransparency
);
options.secure = defaultValue(options.secure, defaults.secure);
options.packOcclusion = defaultValue(options.packOcclusion, defaults.packOcclusion);
options.metallicRoughness = defaultValue(options.metallicRoughness, defaults.metallicRoughness);
options.specularGlossiness = defaultValue(options.specularGlossiness, defaults.specularGlossiness);
options.packOcclusion = defaultValue(
options.packOcclusion,
defaults.packOcclusion
);
options.metallicRoughness = defaultValue(
options.metallicRoughness,
defaults.metallicRoughness
);
options.specularGlossiness = defaultValue(
options.specularGlossiness,
defaults.specularGlossiness
);
options.unlit = defaultValue(options.unlit, defaults.unlit);
options.overridingTextures = defaultValue(options.overridingTextures, defaultValue.EMPTY_OBJECT);
options.overridingTextures = defaultValue(
options.overridingTextures,
defaultValue.EMPTY_OBJECT
);
options.logger = defaultValue(options.logger, getDefaultLogger());
options.writer = defaultValue(options.writer, getDefaultWriter(options.outputDirectory));
options.writer = defaultValue(
options.writer,
getDefaultWriter(options.outputDirectory)
);
options.inputUpAxis = defaultValue(options.inputUpAxis, defaults.inputUpAxis);
options.outputUpAxis = defaultValue(options.outputUpAxis, defaults.outputUpAxis);
options.triangleWindingOrderSanitization = defaultValue(options.triangleWindingOrderSanitization, defaults.triangleWindingOrderSanitization);
options.outputUpAxis = defaultValue(
options.outputUpAxis,
defaults.outputUpAxis
);
options.triangleWindingOrderSanitization = defaultValue(
options.triangleWindingOrderSanitization,
defaults.triangleWindingOrderSanitization
);
if (!defined(objPath)) {
throw new DeveloperError('objPath is required');
throw new DeveloperError("objPath is required");
}
if (options.separateTextures && !defined(options.writer)) {
throw new DeveloperError('Either options.writer or options.outputDirectory must be defined when writing separate resources.');
throw new DeveloperError(
"Either options.writer or options.outputDirectory must be defined when writing separate resources."
);
}
if (options.metallicRoughness + options.specularGlossiness + options.unlit > 1) {
throw new DeveloperError('Only one material type may be set from [metallicRoughness, specularGlossiness, unlit].');
if (
options.metallicRoughness + options.specularGlossiness + options.unlit >
1
) {
throw new DeveloperError(
"Only one material type may be set from [metallicRoughness, specularGlossiness, unlit]."
);
}
if (defined(options.overridingTextures.metallicRoughnessOcclusionTexture) && defined(options.overridingTextures.specularGlossinessTexture)) {
throw new DeveloperError('metallicRoughnessOcclusionTexture and specularGlossinessTexture cannot both be defined.');
if (
defined(options.overridingTextures.metallicRoughnessOcclusionTexture) &&
defined(options.overridingTextures.specularGlossinessTexture)
) {
throw new DeveloperError(
"metallicRoughnessOcclusionTexture and specularGlossinessTexture cannot both be defined."
);
}
if (defined(options.overridingTextures.metallicRoughnessOcclusionTexture)) {
@ -176,19 +214,19 @@ obj2gltf.defaults = {
* @type String
* @default 'Y'
*/
inputUpAxis: 'Y',
inputUpAxis: "Y",
/**
* Gets or sets the up axis of the converted glTF.
* @type String
* @default 'Y'
*/
outputUpAxis: 'Y',
outputUpAxis: "Y",
/**
* Gets or sets whether triangle winding order sanitization will be applied.
* @type Boolean
* @default false
*/
windingOrderSanitization : false
windingOrderSanitization: false,
};
/**

6
lib/outsideDirectory.js
View File

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

16
lib/readLines.js
View File

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

71
lib/writeGltf.js
View File

@ -1,10 +1,10 @@
'use strict';
const Cesium = require('cesium');
const mime = require('mime');
const PNG = require('pngjs').PNG;
const Promise = require('bluebird');
const getBufferPadded = require('./getBufferPadded');
const gltfToGlb = require('./gltfToGlb');
"use strict";
const Cesium = require("cesium");
const mime = require("mime");
const PNG = require("pngjs").PNG;
const Promise = require("bluebird");
const getBufferPadded = require("./getBufferPadded");
const gltfToGlb = require("./gltfToGlb");
const defined = Cesium.defined;
const RuntimeError = Cesium.RuntimeError;
@ -21,8 +21,7 @@ module.exports = writeGltf;
* @private
*/
function writeGltf(gltf, options) {
return encodeTextures(gltf)
.then(function() {
return encodeTextures(gltf).then(function () {
const binary = options.binary;
const separate = options.separate;
const separateTextures = options.separateTextures;
@ -42,8 +41,7 @@ function writeGltf(gltf, options) {
const binaryBuffer = gltf.buffers[0].extras._obj2gltf.source;
return Promise.all(promises)
.then(function() {
return Promise.all(promises).then(function () {
deleteExtras(gltf);
removeEmpty(gltf);
if (binary) {
@ -64,7 +62,7 @@ function encodePng(texture) {
height: texture.height,
colorType: texture.transparent ? rgbaColorType : rgbColorType,
inputColorType: rgbaColorType,
inputHasAlpha : true
inputHasAlpha: true,
});
png.data = texture.pixels;
@ -72,20 +70,23 @@ function encodePng(texture) {
return new Promise(function (resolve, reject) {
const chunks = [];
const stream = png.pack();
stream.on('data', function(chunk) {
stream.on("data", function (chunk) {
chunks.push(chunk);
});
stream.on('end', function() {
stream.on("end", function () {
resolve(Buffer.concat(chunks));
});
stream.on('error', reject);
stream.on("error", reject);
});
}
function encodeTexture(texture) {
if (!defined(texture.source) && defined(texture.pixels) && texture.extension === '.png') {
return encodePng(texture)
.then(function(encoded) {
if (
!defined(texture.source) &&
defined(texture.pixels) &&
texture.extension === ".png"
) {
return encodePng(texture).then(function (encoded) {
texture.source = encoded;
});
}
@ -118,9 +119,12 @@ function deleteExtras(gltf) {
function removeEmpty(json) {
Object.keys(json).forEach(function (key) {
if (!defined(json[key]) || (Array.isArray(json[key]) && json[key].length === 0)) {
if (
!defined(json[key]) ||
(Array.isArray(json[key]) && json[key].length === 0)
) {
delete json[key]; // Delete values that are undefined or []
} else if (typeof json[key] === 'object') {
} else if (typeof json[key] === "object") {
removeEmpty(json[key]);
}
});
@ -128,22 +132,30 @@ function removeEmpty(json) {
function writeSeparateBuffers(gltf, options) {
const buffers = gltf.buffers;
return Promise.map(buffers, function(buffer) {
return Promise.map(
buffers,
function (buffer) {
const source = buffer.extras._obj2gltf.source;
const bufferUri = buffer.name + '.bin';
const bufferUri = buffer.name + ".bin";
buffer.uri = bufferUri;
return options.writer(bufferUri, source);
}, {concurrency : 10});
},
{ concurrency: 10 }
);
}
function writeSeparateTextures(gltf, options) {
const images = gltf.images;
return Promise.map(images, function(image) {
return Promise.map(
images,
function (image) {
const texture = image.extras._obj2gltf;
const imageUri = image.name + texture.extension;
image.uri = imageUri;
return options.writer(imageUri, texture.source);
}, {concurrency : 10});
},
{ concurrency: 10 }
);
}
function writeEmbeddedBuffer(gltf) {
@ -152,10 +164,13 @@ function writeEmbeddedBuffer(gltf) {
// Buffers larger than ~192MB cannot be base64 encoded due to a NodeJS limitation. Source: https://github.com/nodejs/node/issues/4266
if (source.length > 201326580) {
throw new RuntimeError('Buffer is too large to embed in the glTF. Use the --separate flag instead.');
throw new RuntimeError(
"Buffer is too large to embed in the glTF. Use the --separate flag instead."
);
}
buffer.uri = 'data:application/octet-stream;base64,' + source.toString('base64');
buffer.uri =
"data:application/octet-stream;base64," + source.toString("base64");
}
function writeEmbeddedTextures(gltf) {
@ -178,7 +193,7 @@ function writeEmbeddedTextures(gltf) {
gltf.bufferViews.push({
buffer: 0,
byteOffset: byteOffset,
byteLength : textureByteLength
byteLength: textureByteLength,
});
byteOffset += textureByteLength;
sources.push(textureSource);

112
specs/lib/createGltfSpec.js
View File

@ -1,23 +1,26 @@
'use strict';
const Cesium = require('cesium');
const obj2gltf = require('../../lib/obj2gltf');
const createGltf = require('../../lib/createGltf');
const loadObj = require('../../lib/loadObj');
const { getDefaultMaterial } = require('../../lib/loadMtl');
"use strict";
const Cesium = require("cesium");
const obj2gltf = require("../../lib/obj2gltf");
const createGltf = require("../../lib/createGltf");
const loadObj = require("../../lib/loadObj");
const { getDefaultMaterial } = require("../../lib/loadMtl");
const clone = Cesium.clone;
const defined = Cesium.defined;
const WebGLConstants = Cesium.WebGLConstants;
const boxObjPath = 'specs/data/box/box.obj';
const groupObjPath = 'specs/data/box-objects-groups-materials/box-objects-groups-materials.obj';
const complexObjPath = 'specs/data/box-complex-material/box-complex-material.obj';
const noMaterialsObjPath = 'specs/data/box-no-materials/box-no-materials.obj';
const mixedAttributesObjPath = 'specs/data/box-mixed-attributes-2/box-mixed-attributes-2.obj';
const boxObjPath = "specs/data/box/box.obj";
const groupObjPath =
"specs/data/box-objects-groups-materials/box-objects-groups-materials.obj";
const complexObjPath =
"specs/data/box-complex-material/box-complex-material.obj";
const noMaterialsObjPath = "specs/data/box-no-materials/box-no-materials.obj";
const mixedAttributesObjPath =
"specs/data/box-mixed-attributes-2/box-mixed-attributes-2.obj";
let options;
describe('createGltf', () => {
describe("createGltf", () => {
let boxObjData;
let groupObjData;
let complexObjData;
@ -36,7 +39,7 @@ describe('createGltf', () => {
mixedAttributesObjData = await loadObj(mixedAttributesObjPath, options);
});
it('simple gltf', () => {
it("simple gltf", () => {
const gltf = createGltf(boxObjData, options);
expect(gltf.materials.length).toBe(1);
@ -60,8 +63,8 @@ describe('createGltf', () => {
expect(indexAccessor.count).toBe(36);
});
it('does not combine buffers when that buffer would exceed the Node buffer size limit', () => {
spyOn(createGltf, '_getBufferMaxByteLength').and.returnValue(0);
it("does not combine buffers when that buffer would exceed the Node buffer size limit", () => {
spyOn(createGltf, "_getBufferMaxByteLength").and.returnValue(0);
const clonedOptions = clone(options, true);
clonedOptions.separate = true;
@ -83,7 +86,7 @@ describe('createGltf', () => {
}
});
it('multiple nodes, meshes, and primitives', () => {
it("multiple nodes, meshes, and primitives", () => {
const gltf = createGltf(groupObjData, options);
expect(gltf.materials.length).toBe(3);
@ -102,22 +105,32 @@ describe('createGltf', () => {
}
});
it('multiple textures', () => {
it("multiple textures", () => {
const gltf = createGltf(complexObjData, options);
const material = gltf.materials[0];
const pbr = material.pbrMetallicRoughness;
const textures = [pbr.metallicRoughnessTexture, pbr.baseColorTexture, material.emissiveTexture, material.normalTexture, material.occlusionTexture];
expect(textures.map((texture) => {
const textures = [
pbr.metallicRoughnessTexture,
pbr.baseColorTexture,
material.emissiveTexture,
material.normalTexture,
material.occlusionTexture,
];
expect(
textures
.map((texture) => {
return texture.index;
}).sort()).toEqual([0, 1, 2, 3, 4]);
})
.sort()
).toEqual([0, 1, 2, 3, 4]);
expect(gltf.samplers[0]).toBeDefined();
});
it('creates default material', () => {
it("creates default material", () => {
const gltf = createGltf(noMaterialsObjData, options);
const material = gltf.materials[0];
const pbr = material.pbrMetallicRoughness;
expect(material.name).toBe('default');
expect(material.name).toBe("default");
expect(pbr.baseColorTexture).toBeUndefined();
expect(pbr.metallicRoughnessTexture).toBeUndefined();
expect(pbr.baseColorFactor).toEqual([0.5, 0.5, 0.5, 1.0]);
@ -127,25 +140,29 @@ describe('createGltf', () => {
expect(material.normalTexture).toBeUndefined();
expect(material.ambientTexture).toBeUndefined();
expect(material.emissiveFactor).toEqual([0.0, 0.0, 0.0]);
expect(material.alphaMode).toBe('OPAQUE');
expect(material.alphaMode).toBe("OPAQUE");
expect(material.doubleSided).toBe(false);
});
it('adds KHR_materials_pbrSpecularGlossiness extension when specularGlossiness is set', () => {
it("adds KHR_materials_pbrSpecularGlossiness extension when specularGlossiness is set", () => {
options.specularGlossiness = true;
const gltf = createGltf(noMaterialsObjData, options);
expect(gltf.extensionsUsed).toEqual(['KHR_materials_pbrSpecularGlossiness']);
expect(gltf.extensionsRequired).toEqual(['KHR_materials_pbrSpecularGlossiness']);
expect(gltf.extensionsUsed).toEqual([
"KHR_materials_pbrSpecularGlossiness",
]);
expect(gltf.extensionsRequired).toEqual([
"KHR_materials_pbrSpecularGlossiness",
]);
});
it('adds KHR_materials_unlit extension when unlit is set', () => {
it("adds KHR_materials_unlit extension when unlit is set", () => {
options.unlit = true;
const gltf = createGltf(noMaterialsObjData, options);
expect(gltf.extensionsUsed).toEqual(['KHR_materials_unlit']);
expect(gltf.extensionsRequired).toEqual(['KHR_materials_unlit']);
expect(gltf.extensionsUsed).toEqual(["KHR_materials_unlit"]);
expect(gltf.extensionsRequired).toEqual(["KHR_materials_unlit"]);
});
it('runs without normals', () => {
it("runs without normals", () => {
boxObjData.nodes[0].meshes[0].primitives[0].normals.length = 0;
const gltf = createGltf(boxObjData, options);
@ -155,7 +172,7 @@ describe('createGltf', () => {
expect(attributes.TEXCOORD_0).toBeDefined();
});
it('runs without uvs', () => {
it("runs without uvs", () => {
boxObjData.nodes[0].meshes[0].primitives[0].uvs.length = 0;
const gltf = createGltf(boxObjData, options);
@ -165,7 +182,7 @@ describe('createGltf', () => {
expect(attributes.TEXCOORD_0).toBeUndefined();
});
it('runs without uvs and normals', () => {
it("runs without uvs and normals", () => {
boxObjData.nodes[0].meshes[0].primitives[0].normals.length = 0;
boxObjData.nodes[0].meshes[0].primitives[0].uvs.length = 0;
@ -176,7 +193,7 @@ describe('createGltf', () => {
expect(attributes.TEXCOORD_0).toBeUndefined();
});
it('splits incompatible materials', () => {
it("splits incompatible materials", () => {
const gltf = createGltf(mixedAttributesObjData, options);
const materials = gltf.materials;
const meshes = gltf.meshes;
@ -184,11 +201,12 @@ describe('createGltf', () => {
const referenceMaterial = mixedAttributesObjData.materials[0];
delete referenceMaterial.name;
referenceMaterial.pbrMetallicRoughness.baseColorTexture = {
index : 0
index: 0,
};
const referenceMaterialNoTextures = clone(referenceMaterial, true);
referenceMaterialNoTextures.pbrMetallicRoughness.baseColorTexture = undefined;
referenceMaterialNoTextures.pbrMetallicRoughness.baseColorTexture =
undefined;
const defaultMaterial = getDefaultMaterial(options);
delete defaultMaterial.name;
@ -204,15 +222,15 @@ describe('createGltf', () => {
// * positions/normals
// * positions/uvs
expect(materialNames).toEqual([
'default',
'default-2',
'default-3',
'Material',
'Material-2',
'Material-3',
'Missing',
'Missing-2',
'Missing-3'
"default",
"default-2",
"default-3",
"Material",
"Material-2",
"Material-3",
"Missing",
"Missing-2",
"Missing-3",
]);
expect(materials.length).toBe(9);
@ -236,7 +254,9 @@ describe('createGltf', () => {
const primitive = primitives[j];
const material = materials[primitive.material];
if (!defined(primitive.attributes.TEXCOORD_0)) {
expect(material.pbrMetallicRoughness.baseColorTexture).toBeUndefined();
expect(
material.pbrMetallicRoughness.baseColorTexture
).toBeUndefined();
}
}
}
@ -269,7 +289,7 @@ describe('createGltf', () => {
}
}
it('detects need to use uint32 indices', () => {
it("detects need to use uint32 indices", () => {
expandObjData(boxObjData, 2731); // Right above 65536 limit
let primitive = boxObjData.nodes[0].meshes[0].primitives[0];
const indicesLength = primitive.indices.length;

324
specs/lib/loadMtlSpec.js
View File

@ -1,31 +1,42 @@
'use strict';
const Cesium = require('cesium');
const fsExtra = require('fs-extra');
const loadMtl = require('../../lib/loadMtl');
const loadTexture = require('../../lib/loadTexture');
const obj2gltf = require('../../lib/obj2gltf');
"use strict";
const Cesium = require("cesium");
const fsExtra = require("fs-extra");
const loadMtl = require("../../lib/loadMtl");
const loadTexture = require("../../lib/loadTexture");
const obj2gltf = require("../../lib/obj2gltf");
const clone = Cesium.clone;
const coloredMaterialPath = 'specs/data/box/box.mtl';
const texturedMaterialPath = 'specs/data/box-complex-material/box-complex-material.mtl';
const texturedWithOptionsMaterialPath = 'specs/data/box-texture-options/box-texture-options.mtl';
const multipleMaterialsPath = 'specs/data/box-multiple-materials/box-multiple-materials.mtl';
const externalMaterialPath = 'specs/data/box-external-resources/box-external-resources.mtl';
const resourcesInRootMaterialPath = 'specs/data/box-resources-in-root/box-resources-in-root.mtl';
const externalInRootMaterialPath = 'specs/data/box-external-resources-in-root/box-external-resources-in-root.mtl';
const transparentMaterialPath = 'specs/data/box-transparent/box-transparent.mtl';
const sharedTexturesMaterialPath = 'specs/data/box-shared-textures/box-shared-textures.mtl';
const sharedTexturesMaterial2Path = 'specs/data/box-shared-textures-2/box-shared-textures-2.mtl';
const coloredMaterialPath = "specs/data/box/box.mtl";
const texturedMaterialPath =
"specs/data/box-complex-material/box-complex-material.mtl";
const texturedWithOptionsMaterialPath =
"specs/data/box-texture-options/box-texture-options.mtl";
const multipleMaterialsPath =
"specs/data/box-multiple-materials/box-multiple-materials.mtl";
const externalMaterialPath =
"specs/data/box-external-resources/box-external-resources.mtl";
const resourcesInRootMaterialPath =
"specs/data/box-resources-in-root/box-resources-in-root.mtl";
const externalInRootMaterialPath =
"specs/data/box-external-resources-in-root/box-external-resources-in-root.mtl";
const transparentMaterialPath =
"specs/data/box-transparent/box-transparent.mtl";
const sharedTexturesMaterialPath =
"specs/data/box-shared-textures/box-shared-textures.mtl";
const sharedTexturesMaterial2Path =
"specs/data/box-shared-textures-2/box-shared-textures-2.mtl";
const diffuseTexturePath = 'specs/data/box-textured/cesium.png';
const transparentDiffuseTexturePath = 'specs/data/box-complex-material/diffuse.png';
const alphaTexturePath = 'specs/data/box-complex-material-alpha/alpha.png';
const ambientTexturePath = 'specs/data/box-complex-material/ambient.gif';
const normalTexturePath = 'specs/data/box-complex-material/bump.png';
const emissiveTexturePath = 'specs/data/box-complex-material/emission.jpg';
const specularTexturePath = 'specs/data/box-complex-material/specular.jpeg';
const specularShininessTexturePath = 'specs/data/box-complex-material/shininess.png';
const diffuseTexturePath = "specs/data/box-textured/cesium.png";
const transparentDiffuseTexturePath =
"specs/data/box-complex-material/diffuse.png";
const alphaTexturePath = "specs/data/box-complex-material-alpha/alpha.png";
const ambientTexturePath = "specs/data/box-complex-material/ambient.gif";
const normalTexturePath = "specs/data/box-complex-material/bump.png";
const emissiveTexturePath = "specs/data/box-complex-material/emission.jpg";
const specularTexturePath = "specs/data/box-complex-material/specular.jpeg";
const specularShininessTexturePath =
"specs/data/box-complex-material/shininess.png";
let diffuseTexture;
let transparentDiffuseTexture;
@ -37,24 +48,30 @@ let specularTexture;
let specularShininessTexture;
const checkTransparencyOptions = {
checkTransparency : true
checkTransparency: true,
};
const decodeOptions = {
decode : true
decode: true,
};
let options;
describe('loadMtl', () => {
describe("loadMtl", () => {
beforeAll(async () => {
diffuseTexture = await loadTexture(diffuseTexturePath, decodeOptions);
transparentDiffuseTexture = await loadTexture(transparentDiffuseTexturePath, checkTransparencyOptions);
transparentDiffuseTexture = await loadTexture(
transparentDiffuseTexturePath,
checkTransparencyOptions
);
alphaTexture = await loadTexture(alphaTexturePath, decodeOptions);
ambientTexture = await loadTexture(ambientTexturePath);
normalTexture = await loadTexture(normalTexturePath);
emissiveTexture = await loadTexture(emissiveTexturePath);
specularTexture = await loadTexture(specularTexturePath, decodeOptions);
specularShininessTexture = await loadTexture(specularShininessTexturePath, decodeOptions);
specularShininessTexture = await loadTexture(
specularShininessTexturePath,
decodeOptions
);
});
beforeEach(() => {
@ -63,7 +80,7 @@ describe('loadMtl', () => {
options.logger = () => {};
});
it('loads mtl', async () => {
it("loads mtl", async () => {
options.metallicRoughness = true;
const materials = await loadMtl(coloredMaterialPath, options);
expect(materials.length).toBe(1);
@ -74,16 +91,16 @@ describe('loadMtl', () => {
expect(pbr.baseColorFactor).toEqual([0.64, 0.64, 0.64, 1.0]);
expect(pbr.metallicFactor).toBe(0.5);
expect(pbr.roughnessFactor).toBe(96.078431);
expect(material.name).toBe('Material');
expect(material.name).toBe("Material");
expect(material.emissiveTexture).toBeUndefined();
expect(material.normalTexture).toBeUndefined();
expect(material.ambientTexture).toBeUndefined();
expect(material.emissiveFactor).toEqual([0.0, 0.0, 0.1]);
expect(material.alphaMode).toBe('OPAQUE');
expect(material.alphaMode).toBe("OPAQUE");
expect(material.doubleSided).toBe(false);
});
it('loads mtl with textures', async () => {
it("loads mtl with textures", async () => {
options.metallicRoughness = true;
const materials = await loadMtl(texturedMaterialPath, options);
expect(materials.length).toBe(1);
@ -94,16 +111,16 @@ describe('loadMtl', () => {
expect(pbr.baseColorFactor).toEqual([1.0, 1.0, 1.0, 0.9]);
expect(pbr.metallicFactor).toBe(1.0);
expect(pbr.roughnessFactor).toBe(1.0);
expect(material.name).toBe('Material');
expect(material.name).toBe("Material");
expect(material.emissiveTexture).toBeDefined();
expect(material.normalTexture).toBeDefined();
expect(material.occlusionTexture).toBeDefined();
expect(material.emissiveFactor).toEqual([1.0, 1.0, 1.0]);
expect(material.alphaMode).toBe('BLEND');
expect(material.alphaMode).toBe("BLEND");
expect(material.doubleSided).toBe(true);
});
it('loads mtl with textures having options', async () => {
it("loads mtl with textures having options", async () => {
options.metallicRoughness = true;
const materials = await loadMtl(texturedWithOptionsMaterialPath, options);
expect(materials.length).toBe(1);
@ -114,54 +131,60 @@ describe('loadMtl', () => {
expect(pbr.baseColorFactor).toEqual([1.0, 1.0, 1.0, 0.9]);
expect(pbr.metallicFactor).toBe(1.0);
expect(pbr.roughnessFactor).toBe(1.0);
expect(material.name).toBe('Material');
expect(material.name).toBe("Material");
expect(material.emissiveTexture).toBeDefined();
expect(material.normalTexture).toBeDefined();
expect(material.occlusionTexture).toBeDefined();
expect(material.emissiveFactor).toEqual([1.0, 1.0, 1.0]);
expect(material.alphaMode).toBe('BLEND');
expect(material.alphaMode).toBe("BLEND");
expect(material.doubleSided).toBe(true);
});
it('loads mtl with multiple materials', async () => {
it("loads mtl with multiple materials", async () => {
options.metallicRoughness = true;
const materials = await loadMtl(multipleMaterialsPath, options);
expect(materials.length).toBe(3);
expect(materials[0].name).toBe('Blue');
expect(materials[0].pbrMetallicRoughness.baseColorFactor).toEqual([0.0, 0.0, 0.64, 1.0]);
expect(materials[1].name).toBe('Green');
expect(materials[1].pbrMetallicRoughness.baseColorFactor).toEqual([0.0, 0.64, 0.0, 1.0]);
expect(materials[2].name).toBe('Red');
expect(materials[2].pbrMetallicRoughness.baseColorFactor).toEqual([0.64, 0.0, 0.0, 1.0]);
expect(materials[0].name).toBe("Blue");
expect(materials[0].pbrMetallicRoughness.baseColorFactor).toEqual([
0.0, 0.0, 0.64, 1.0,
]);
expect(materials[1].name).toBe("Green");
expect(materials[1].pbrMetallicRoughness.baseColorFactor).toEqual([
0.0, 0.64, 0.0, 1.0,
]);
expect(materials[2].name).toBe("Red");
expect(materials[2].pbrMetallicRoughness.baseColorFactor).toEqual([
0.64, 0.0, 0.0, 1.0,
]);
});
it('sets overriding textures', async () => {
spyOn(fsExtra, 'readFile').and.callThrough();
it("sets overriding textures", async () => {
spyOn(fsExtra, "readFile").and.callThrough();
options.overridingTextures = {
metallicRoughnessOcclusionTexture: alphaTexturePath,
baseColorTexture: alphaTexturePath,
emissiveTexture : emissiveTexturePath
emissiveTexture: emissiveTexturePath,
};
const materials = await loadMtl(texturedMaterialPath, options);
const material = materials[0];
const pbr = material.pbrMetallicRoughness;
expect(pbr.baseColorTexture.name).toBe('alpha');
expect(pbr.metallicRoughnessTexture.name).toBe('alpha');
expect(material.emissiveTexture.name).toBe('emission');
expect(material.normalTexture.name).toBe('bump');
expect(pbr.baseColorTexture.name).toBe("alpha");
expect(pbr.metallicRoughnessTexture.name).toBe("alpha");
expect(material.emissiveTexture.name).toBe("emission");
expect(material.normalTexture.name).toBe("bump");
expect(fsExtra.readFile.calls.count()).toBe(3);
});
it('loads texture outside of the mtl directory', async () => {
it("loads texture outside of the mtl directory", async () => {
const materials = await loadMtl(externalMaterialPath, options);
const material = materials[0];
const baseColorTexture = material.pbrMetallicRoughness.baseColorTexture;
expect(baseColorTexture.source).toBeDefined();
expect(baseColorTexture.name).toBe('cesium');
expect(baseColorTexture.name).toBe("cesium");
});
it('does not load texture outside of the mtl directory when secure is true', async () => {
const spy = jasmine.createSpy('logger');
it("does not load texture outside of the mtl directory when secure is true", async () => {
const spy = jasmine.createSpy("logger");
options.logger = spy;
options.secure = true;
@ -169,30 +192,38 @@ describe('loadMtl', () => {
const material = materials[0];
const baseColorTexture = material.pbrMetallicRoughness.baseColorTexture;
expect(baseColorTexture).toBeUndefined();
expect(spy.calls.argsFor(0)[0].indexOf('Texture file is outside of the mtl directory and the secure flag is true. Attempting to read the texture file from within the obj directory instead') >= 0).toBe(true);
expect(spy.calls.argsFor(1)[0].indexOf('ENOENT') >= 0).toBe(true);
expect(spy.calls.argsFor(2)[0].indexOf('Could not read texture file') >= 0).toBe(true);
expect(
spy.calls
.argsFor(0)[0]
.indexOf(
"Texture file is outside of the mtl directory and the secure flag is true. Attempting to read the texture file from within the obj directory instead"
) >= 0
).toBe(true);
expect(spy.calls.argsFor(1)[0].indexOf("ENOENT") >= 0).toBe(true);
expect(
spy.calls.argsFor(2)[0].indexOf("Could not read texture file") >= 0
).toBe(true);
});
it('loads textures from root directory when the texture paths do not exist', async () => {
it("loads textures from root directory when the texture paths do not exist", async () => {
const materials = await loadMtl(resourcesInRootMaterialPath, options);
const material = materials[0];
const baseColorTexture = material.pbrMetallicRoughness.baseColorTexture;
expect(baseColorTexture.source).toBeDefined();
expect(baseColorTexture.name).toBe('cesium');
expect(baseColorTexture.name).toBe("cesium");
});
it('loads textures from root directory when texture is outside of the mtl directory and secure is true', async () => {
it("loads textures from root directory when texture is outside of the mtl directory and secure is true", async () => {
options.secure = true;
const materials = await loadMtl(externalInRootMaterialPath, options);
const material = materials[0];
const baseColorTexture = material.pbrMetallicRoughness.baseColorTexture;
expect(baseColorTexture.source).toBeDefined();
expect(baseColorTexture.name).toBe('cesium');
expect(baseColorTexture.name).toBe("cesium");
});
it('alpha of 0.0 is treated as 1.0', async () => {
it("alpha of 0.0 is treated as 1.0", async () => {
const materials = await loadMtl(transparentMaterialPath, options);
expect(materials.length).toBe(1);
const material = materials[0];
@ -200,11 +231,11 @@ describe('loadMtl', () => {
expect(pbr.baseColorTexture).toBeUndefined();
expect(pbr.metallicRoughnessTexture).toBeUndefined();
expect(pbr.baseColorFactor[3]).toEqual(1.0);
expect(material.alphaMode).toBe('OPAQUE');
expect(material.alphaMode).toBe("OPAQUE");
expect(material.doubleSided).toBe(false);
});
it('ambient texture is ignored if it is the same as the diffuse texture', async () => {
it("ambient texture is ignored if it is the same as the diffuse texture", async () => {
const materials = await loadMtl(sharedTexturesMaterialPath, options);
expect(materials.length).toBe(1);
const material = materials[0];
@ -213,7 +244,7 @@ describe('loadMtl', () => {
expect(pbr.occlusionTexture).toBeUndefined();
});
it('texture referenced by specular is decoded', async () => {
it("texture referenced by specular is decoded", async () => {
const materials = await loadMtl(sharedTexturesMaterialPath, options);
expect(materials.length).toBe(1);
const material = materials[0];
@ -224,7 +255,7 @@ describe('loadMtl', () => {
expect(pbr.metallicRoughnessTexture.source).toBeUndefined();
});
it('texture referenced by diffuse and emissive is not decoded', async () => {
it("texture referenced by diffuse and emissive is not decoded", async () => {
const materials = await loadMtl(sharedTexturesMaterial2Path, options);
expect(materials.length).toBe(1);
const material = materials[0];
@ -234,8 +265,8 @@ describe('loadMtl', () => {
expect(pbr.baseColorTexture.source).toBeDefined();
});
describe('metallicRoughness', () => {
it('creates default material', () => {
describe("metallicRoughness", () => {
it("creates default material", () => {
const material = loadMtl._createMaterial(undefined, options);
const pbr = material.pbrMetallicRoughness;
expect(pbr.baseColorTexture).toBeUndefined();
@ -247,21 +278,24 @@ describe('loadMtl', () => {
expect(material.normalTexture).toBeUndefined();
expect(material.ambientTexture).toBeUndefined();
expect(material.emissiveFactor).toEqual([0.0, 0.0, 0.0]);
expect(material.alphaMode).toBe('OPAQUE');
expect(material.alphaMode).toBe("OPAQUE");
expect(material.doubleSided).toBe(false);
});
it('creates material with textures', () => {
it("creates material with textures", () => {
options.metallicRoughness = true;
const material = loadMtl._createMaterial({
const material = loadMtl._createMaterial(
{
diffuseTexture: diffuseTexture,
ambientTexture: ambientTexture,
normalTexture: normalTexture,
emissiveTexture: emissiveTexture,
specularTexture: specularTexture,
specularShininessTexture : specularShininessTexture
}, options);
specularShininessTexture: specularShininessTexture,
},
options
);
const pbr = material.pbrMetallicRoughness;
expect(pbr.baseColorTexture).toBeDefined();
@ -273,57 +307,69 @@ describe('loadMtl', () => {
expect(material.normalTexture).toBeDefined();
expect(material.occlusionTexture).toBeDefined();
expect(material.emissiveFactor).toEqual([1.0, 1.0, 1.0]);
expect(material.alphaMode).toBe('OPAQUE');
expect(material.alphaMode).toBe("OPAQUE");
expect(material.doubleSided).toBe(false);
});
it('packs occlusion in metallic roughness texture', () => {
it("packs occlusion in metallic roughness texture", () => {
options.metallicRoughness = true;
options.packOcclusion = true;
const material = loadMtl._createMaterial({
const material = loadMtl._createMaterial(
{
ambientTexture: alphaTexture,
specularTexture: specularTexture,
specularShininessTexture : specularShininessTexture
}, options);
specularShininessTexture: specularShininessTexture,
},
options
);
const pbr = material.pbrMetallicRoughness;
expect(pbr.metallicRoughnessTexture).toBeDefined();
expect(pbr.metallicRoughnessTexture).toBe(material.occlusionTexture);
});
it('does not create metallic roughness texture if decoded texture data is not available', () => {
it("does not create metallic roughness texture if decoded texture data is not available", () => {
options.metallicRoughness = true;
options.packOcclusion = true;
const material = loadMtl._createMaterial({
const material = loadMtl._createMaterial(
{
ambientTexture: ambientTexture, // Is a .gif which can't be decoded
specularTexture: specularTexture,
specularShininessTexture : specularShininessTexture
}, options);
specularShininessTexture: specularShininessTexture,
},
options
);
const pbr = material.pbrMetallicRoughness;
expect(pbr.metallicRoughnessTexture).toBeUndefined();
expect(material.occlusionTexture).toBeUndefined();
});
it('sets material for transparent diffuse texture', () => {
it("sets material for transparent diffuse texture", () => {
options.metallicRoughness = true;
const material = loadMtl._createMaterial({
diffuseTexture : transparentDiffuseTexture
}, options);
expect(material.alphaMode).toBe('BLEND');
const material = loadMtl._createMaterial(
{
diffuseTexture: transparentDiffuseTexture,
},
options
);
expect(material.alphaMode).toBe("BLEND");
expect(material.doubleSided).toBe(true);
});
it('packs alpha texture in base color texture', () => {
it("packs alpha texture in base color texture", () => {
options.metallicRoughness = true;
const material = loadMtl._createMaterial({
const material = loadMtl._createMaterial(
{
diffuseTexture: diffuseTexture,
alphaTexture : alphaTexture
}, options);
alphaTexture: alphaTexture,
},
options
);
const pbr = material.pbrMetallicRoughness;
expect(pbr.baseColorTexture).toBeDefined();
@ -334,33 +380,36 @@ describe('loadMtl', () => {
const pixelsLength = pixels.length / 4;
for (let i = 0; i < pixelsLength; ++i) {
const alpha = pixels[i * 4 + 3];
hasBlack = hasBlack || (alpha === 0);
hasWhite = hasWhite || (alpha === 255);
hasBlack = hasBlack || alpha === 0;
hasWhite = hasWhite || alpha === 255;
}
expect(hasBlack).toBe(true);
expect(hasWhite).toBe(true);
expect(pbr.baseColorFactor[3]).toEqual(1);
expect(material.alphaMode).toBe('BLEND');
expect(material.alphaMode).toBe("BLEND");
expect(material.doubleSided).toBe(true);
});
it('uses diffuse texture if diffuse and alpha are the same', () => {
it("uses diffuse texture if diffuse and alpha are the same", () => {
options.metallicRoughness = true;
const material = loadMtl._createMaterial({
const material = loadMtl._createMaterial(
{
diffuseTexture: diffuseTexture,
alphaTexture : diffuseTexture
}, options);
alphaTexture: diffuseTexture,
},
options
);
const pbr = material.pbrMetallicRoughness;
expect(pbr.baseColorTexture).toBe(diffuseTexture);
expect(material.alphaMode).toBe('BLEND');
expect(material.alphaMode).toBe("BLEND");
expect(material.doubleSided).toBe(true);
});
});
describe('specularGlossiness', () => {
it('creates default material', () => {
describe("specularGlossiness", () => {
it("creates default material", () => {
options.specularGlossiness = true;
const material = loadMtl._createMaterial(undefined, options);
const pbr = material.extensions.KHR_materials_pbrSpecularGlossiness;
@ -373,21 +422,24 @@ describe('loadMtl', () => {
expect(material.normalTexture).toBeUndefined();
expect(material.occlusionTexture).toBeUndefined();
expect(material.emissiveFactor).toEqual([0.0, 0.0, 0.0]);
expect(material.alphaMode).toBe('OPAQUE');
expect(material.alphaMode).toBe("OPAQUE");
expect(material.doubleSided).toBe(false);
});
it('creates material with textures', () => {
it("creates material with textures", () => {
options.specularGlossiness = true;
const material = loadMtl._createMaterial({
const material = loadMtl._createMaterial(
{
diffuseTexture: diffuseTexture,
ambientTexture: ambientTexture,
normalTexture: normalTexture,
emissiveTexture: emissiveTexture,
specularTexture: specularTexture,
specularShininessTexture : specularShininessTexture
}, options);
specularShininessTexture: specularShininessTexture,
},
options
);
const pbr = material.extensions.KHR_materials_pbrSpecularGlossiness;
expect(pbr.diffuseTexture).toBeDefined();
@ -399,40 +451,49 @@ describe('loadMtl', () => {
expect(material.normalTexture).toBeDefined();
expect(material.occlusionTexture).toBeDefined();
expect(material.emissiveFactor).toEqual([1.0, 1.0, 1.0]);
expect(material.alphaMode).toBe('OPAQUE');
expect(material.alphaMode).toBe("OPAQUE");
expect(material.doubleSided).toBe(false);
});
it('does not create specular glossiness texture if decoded texture data is not available', () => {
it("does not create specular glossiness texture if decoded texture data is not available", () => {
options.specularGlossiness = true;
const material = loadMtl._createMaterial({
const material = loadMtl._createMaterial(
{
specularTexture: ambientTexture, // Is a .gif which can't be decoded
specularShininessTexture : specularShininessTexture
}, options);
specularShininessTexture: specularShininessTexture,
},
options
);
const pbr = material.extensions.KHR_materials_pbrSpecularGlossiness;
expect(pbr.specularGlossinessTexture).toBeUndefined();
});
it('sets material for transparent diffuse texture', () => {
it("sets material for transparent diffuse texture", () => {
options.specularGlossiness = true;
const material = loadMtl._createMaterial({
diffuseTexture : transparentDiffuseTexture
}, options);
const material = loadMtl._createMaterial(
{
diffuseTexture: transparentDiffuseTexture,
},
options
);
expect(material.alphaMode).toBe('BLEND');
expect(material.alphaMode).toBe("BLEND");
expect(material.doubleSided).toBe(true);
});
it('packs alpha texture in diffuse texture', () => {
it("packs alpha texture in diffuse texture", () => {
options.specularGlossiness = true;
const material = loadMtl._createMaterial({
const material = loadMtl._createMaterial(
{
diffuseTexture: diffuseTexture,
alphaTexture : alphaTexture
}, options);
alphaTexture: alphaTexture,
},
options
);
const pbr = material.extensions.KHR_materials_pbrSpecularGlossiness;
expect(pbr.diffuseTexture).toBeDefined();
@ -443,27 +504,30 @@ describe('loadMtl', () => {
const pixelsLength = pixels.length / 4;
for (let i = 0; i < pixelsLength; ++i) {
const alpha = pixels[i * 4 + 3];
hasBlack = hasBlack || (alpha === 0);
hasWhite = hasWhite || (alpha === 255);
hasBlack = hasBlack || alpha === 0;
hasWhite = hasWhite || alpha === 255;
}
expect(hasBlack).toBe(true);
expect(hasWhite).toBe(true);
expect(pbr.diffuseFactor[3]).toEqual(1);
expect(material.alphaMode).toBe('BLEND');
expect(material.alphaMode).toBe("BLEND");
expect(material.doubleSided).toBe(true);
});
it('uses diffuse texture if diffuse and alpha are the same', () => {
it("uses diffuse texture if diffuse and alpha are the same", () => {
options.specularGlossiness = true;
const material = loadMtl._createMaterial({
const material = loadMtl._createMaterial(
{
diffuseTexture: diffuseTexture,
alphaTexture : diffuseTexture
}, options);
alphaTexture: diffuseTexture,
},
options
);
const pbr = material.extensions.KHR_materials_pbrSpecularGlossiness;
expect(pbr.diffuseTexture).toEqual(diffuseTexture);
expect(material.alphaMode).toBe('BLEND');
expect(material.alphaMode).toBe("BLEND");
expect(material.doubleSided).toBe(true);
});
});

490
specs/lib/loadObjSpec.js
View File

@ -1,53 +1,72 @@
'use strict';
const Cesium = require('cesium');
const path = require('path');
"use strict";
const Cesium = require("cesium");
const path = require("path");
const loadObj = require('../../lib/loadObj');
const obj2gltf = require('../../lib/obj2gltf');
const loadObj = require("../../lib/loadObj");
const obj2gltf = require("../../lib/obj2gltf");
const Cartesian3 = Cesium.Cartesian3;
const CesiumMath = Cesium.Math;
const clone = Cesium.clone;
const RuntimeError = Cesium.RuntimeError;
const objPath = 'specs/data/box/box.obj';
const objRotatedUrl = 'specs/data/box-rotated/box-rotated.obj';
const objNormalsPath = 'specs/data/box-normals/box-normals.obj';
const objUvsPath = 'specs/data/box-uvs/box-uvs.obj';
const objPositionsOnlyPath = 'specs/data/box-positions-only/box-positions-only.obj';
const objNegativeIndicesPath = 'specs/data/box-negative-indices/box-negative-indices.obj';
const objTrianglesPath = 'specs/data/box-triangles/box-triangles.obj';
const objObjectsPath = 'specs/data/box-objects/box-objects.obj';
const objGroupsPath = 'specs/data/box-groups/box-groups.obj';
const objObjectsGroupsPath = 'specs/data/box-objects-groups/box-objects-groups.obj';
const objObjectsGroupsMaterialsPath = 'specs/data/box-objects-groups-materials/box-objects-groups-materials.obj';
const objObjectsGroupsMaterialsPath2 = 'specs/data/box-objects-groups-materials-2/box-objects-groups-materials-2.obj';
const objUsemtlPath = 'specs/data/box-usemtl/box-usemtl.obj';
const objNoMaterialsPath = 'specs/data/box-no-materials/box-no-materials.obj';
const objMultipleMaterialsPath = 'specs/data/box-multiple-materials/box-multiple-materials.obj';
const objUncleanedPath = 'specs/data/box-uncleaned/box-uncleaned.obj';
const objMtllibPath = 'specs/data/box-mtllib/box-mtllib.obj';
const objMtllibSpacesPath = 'specs/data/box-mtllib-spaces/box mtllib.obj';
const objMissingMtllibPath = 'specs/data/box-missing-mtllib/box-missing-mtllib.obj';
const objMissingUsemtlPath = 'specs/data/box-missing-usemtl/box-missing-usemtl.obj';
const objUnnamedMaterialPath = 'specs/data/box-unnamed-material/box-unnamed-material.obj';
const objExternalResourcesPath = 'specs/data/box-external-resources/box-external-resources.obj';
const objResourcesInRootPath = 'specs/data/box-resources-in-root/box-resources-in-root.obj';
const objExternalResourcesInRootPath = 'specs/data/box-external-resources-in-root/box-external-resources-in-root.obj';
const objTexturedPath = 'specs/data/box-textured/box-textured.obj';
const objMissingTexturePath = 'specs/data/box-missing-texture/box-missing-texture.obj';
const objSubdirectoriesPath = 'specs/data/box-subdirectories/box-textured.obj';
const objWindowsPaths = 'specs/data/box-windows-paths/box-windows-paths.obj';
const objInvalidContentsPath = 'specs/data/box/box.mtl';
const objConcavePath = 'specs/data/concave/concave.obj';
const objUnnormalizedPath = 'specs/data/box-unnormalized/box-unnormalized.obj';
const objMixedAttributesPath = 'specs/data/box-mixed-attributes/box-mixed-attributes.obj';
const objMissingAttributesPath = 'specs/data/box-missing-attributes/box-missing-attributes.obj';
const objIncompletePositionsPath = 'specs/data/box-incomplete-attributes/box-incomplete-positions.obj';
const objIncompleteNormalsPath = 'specs/data/box-incomplete-attributes/box-incomplete-normals.obj';
const objIncompleteUvsPath = 'specs/data/box-incomplete-attributes/box-incomplete-uvs.obj';
const objIncorrectWindingOrderPath = 'specs/data/box-incorrect-winding-order/box-incorrect-winding-order.obj';
const objInvalidPath = 'invalid.obj';
const objPath = "specs/data/box/box.obj";
const objRotatedUrl = "specs/data/box-rotated/box-rotated.obj";
const objNormalsPath = "specs/data/box-normals/box-normals.obj";
const objUvsPath = "specs/data/box-uvs/box-uvs.obj";
const objPositionsOnlyPath =
"specs/data/box-positions-only/box-positions-only.obj";
const objNegativeIndicesPath =
"specs/data/box-negative-indices/box-negative-indices.obj";
const objTrianglesPath = "specs/data/box-triangles/box-triangles.obj";
const objObjectsPath = "specs/data/box-objects/box-objects.obj";
const objGroupsPath = "specs/data/box-groups/box-groups.obj";
const objObjectsGroupsPath =
"specs/data/box-objects-groups/box-objects-groups.obj";
const objObjectsGroupsMaterialsPath =
"specs/data/box-objects-groups-materials/box-objects-groups-materials.obj";
const objObjectsGroupsMaterialsPath2 =
"specs/data/box-objects-groups-materials-2/box-objects-groups-materials-2.obj";
const objUsemtlPath = "specs/data/box-usemtl/box-usemtl.obj";
const objNoMaterialsPath = "specs/data/box-no-materials/box-no-materials.obj";
const objMultipleMaterialsPath =
"specs/data/box-multiple-materials/box-multiple-materials.obj";
const objUncleanedPath = "specs/data/box-uncleaned/box-uncleaned.obj";
const objMtllibPath = "specs/data/box-mtllib/box-mtllib.obj";
const objMtllibSpacesPath = "specs/data/box-mtllib-spaces/box mtllib.obj";
const objMissingMtllibPath =
"specs/data/box-missing-mtllib/box-missing-mtllib.obj";
const objMissingUsemtlPath =
"specs/data/box-missing-usemtl/box-missing-usemtl.obj";
const objUnnamedMaterialPath =
"specs/data/box-unnamed-material/box-unnamed-material.obj";
const objExternalResourcesPath =
"specs/data/box-external-resources/box-external-resources.obj";
const objResourcesInRootPath =
"specs/data/box-resources-in-root/box-resources-in-root.obj";
const objExternalResourcesInRootPath =
"specs/data/box-external-resources-in-root/box-external-resources-in-root.obj";
const objTexturedPath = "specs/data/box-textured/box-textured.obj";
const objMissingTexturePath =
"specs/data/box-missing-texture/box-missing-texture.obj";
const objSubdirectoriesPath = "specs/data/box-subdirectories/box-textured.obj";
const objWindowsPaths = "specs/data/box-windows-paths/box-windows-paths.obj";
const objInvalidContentsPath = "specs/data/box/box.mtl";
const objConcavePath = "specs/data/concave/concave.obj";
const objUnnormalizedPath = "specs/data/box-unnormalized/box-unnormalized.obj";
const objMixedAttributesPath =
"specs/data/box-mixed-attributes/box-mixed-attributes.obj";
const objMissingAttributesPath =
"specs/data/box-missing-attributes/box-missing-attributes.obj";
const objIncompletePositionsPath =
"specs/data/box-incomplete-attributes/box-incomplete-positions.obj";
const objIncompleteNormalsPath =
"specs/data/box-incomplete-attributes/box-incomplete-normals.obj";
const objIncompleteUvsPath =
"specs/data/box-incomplete-attributes/box-incomplete-uvs.obj";
const objIncorrectWindingOrderPath =
"specs/data/box-incorrect-winding-order/box-incorrect-winding-order.obj";
const objInvalidPath = "invalid.obj";
function getMeshes(data) {
let meshes = [];
@ -75,14 +94,14 @@ function getPrimitives(data) {
let options;
describe('loadObj', () => {
describe("loadObj", () => {
beforeEach(() => {
options = clone(obj2gltf.defaults);
options.overridingTextures = {};
options.logger = () => {};
});
it('loads obj with positions, normals, and uvs', async () => {
it("loads obj with positions, normals, and uvs", async () => {
const data = await loadObj(objPath, options);
const materials = data.materials;
const nodes = data.nodes;
@ -90,7 +109,7 @@ describe('loadObj', () => {
const meshes = getMeshes(data);
const primitives = getPrimitives(data);
expect(name).toBe('box');
expect(name).toBe("box");
expect(materials.length).toBe(1);
expect(nodes.length).toBe(1);
expect(meshes.length).toBe(1);
@ -100,16 +119,16 @@ describe('loadObj', () => {
const mesh = meshes[0];
const primitive = primitives[0];
expect(node.name).toBe('Cube');
expect(mesh.name).toBe('Cube-Mesh');
expect(node.name).toBe("Cube");
expect(mesh.name).toBe("Cube-Mesh");
expect(primitive.positions.length / 3).toBe(24);
expect(primitive.normals.length / 3).toBe(24);
expect(primitive.uvs.length / 2).toBe(24);
expect(primitive.indices.length).toBe(36);
expect(primitive.material).toBe('Material');
expect(primitive.material).toBe("Material");
});
it('loads obj with normals', async () => {
it("loads obj with normals", async () => {
const data = await loadObj(objNormalsPath, options);
const primitive = getPrimitives(data)[0];
expect(primitive.positions.length / 3).toBe(24);
@ -117,7 +136,7 @@ describe('loadObj', () => {
expect(primitive.uvs.length / 2).toBe(0);
});
it('normalizes normals', async () => {
it("normalizes normals", async () => {
const data = await loadObj(objUnnormalizedPath, options);
const scratchNormal = new Cesium.Cartesian3();
const primitive = getPrimitives(data)[0];
@ -127,12 +146,23 @@ describe('loadObj', () => {
const normalX = normals.get(i * 3);
const normalY = normals.get(i * 3 + 1);
const normalZ = normals.get(i * 3 + 2);
const normal = Cartesian3.fromElements(normalX, normalY, normalZ, scratchNormal);
expect(CesiumMath.equalsEpsilon(Cartesian3.magnitude(normal), 1.0, CesiumMath.EPSILON5)).toBe(true);
const normal = Cartesian3.fromElements(
normalX,
normalY,
normalZ,
scratchNormal
);
expect(
CesiumMath.equalsEpsilon(
Cartesian3.magnitude(normal),
1.0,
CesiumMath.EPSILON5
)
).toBe(true);
}
});
it('loads obj with uvs', async () => {
it("loads obj with uvs", async () => {
const data = await loadObj(objUvsPath, options);
const primitive = getPrimitives(data)[0];
expect(primitive.positions.length / 3).toBe(20);
@ -140,140 +170,142 @@ describe('loadObj', () => {
expect(primitive.uvs.length / 2).toBe(20);
});
it('loads obj with negative indices', async () => {
it("loads obj with negative indices", async () => {
const results = [
await loadObj(objPositionsOnlyPath, options),
await loadObj(objNegativeIndicesPath, options)
await loadObj(objNegativeIndicesPath, options),
];
const positionsReference = getPrimitives(results[0])[0].positions.toFloatBuffer();
const positionsReference = getPrimitives(
results[0]
)[0].positions.toFloatBuffer();
const positions = getPrimitives(results[1])[0].positions.toFloatBuffer();
expect(positions).toEqual(positionsReference);
});
it('loads obj with triangle faces', async () => {
it("loads obj with triangle faces", async () => {
const data = await loadObj(objTrianglesPath, options);
const primitive = getPrimitives(data)[0];
expect(primitive.positions.length / 3).toBe(24);
expect(primitive.indices.length).toBe(36);
});
it('loads obj with objects', async () => {
it("loads obj with objects", async () => {
const data = await loadObj(objObjectsPath, options);
const nodes = data.nodes;
expect(nodes.length).toBe(3);
expect(nodes[0].name).toBe('CubeBlue');
expect(nodes[1].name).toBe('CubeGreen');
expect(nodes[2].name).toBe('CubeRed');
expect(nodes[0].name).toBe("CubeBlue");
expect(nodes[1].name).toBe("CubeGreen");
expect(nodes[2].name).toBe("CubeRed");
const primitives = getPrimitives(data);
expect(primitives.length).toBe(3);
expect(primitives[0].material).toBe('Blue');
expect(primitives[1].material).toBe('Green');
expect(primitives[2].material).toBe('Red');
expect(primitives[0].material).toBe("Blue");
expect(primitives[1].material).toBe("Green");
expect(primitives[2].material).toBe("Red");
});
it('loads obj with groups', async () => {
it("loads obj with groups", async () => {
const data = await loadObj(objGroupsPath, options);
const nodes = data.nodes;
expect(nodes.length).toBe(3);
expect(nodes[0].name).toBe('CubeBlue');
expect(nodes[1].name).toBe('CubeGreen');
expect(nodes[2].name).toBe('CubeRed');
expect(nodes[0].name).toBe("CubeBlue");
expect(nodes[1].name).toBe("CubeGreen");
expect(nodes[2].name).toBe("CubeRed");
const primitives = getPrimitives(data);
expect(primitives.length).toBe(3);
expect(primitives[0].material).toBe('Blue');
expect(primitives[1].material).toBe('Green');
expect(primitives[2].material).toBe('Red');
expect(primitives[0].material).toBe("Blue");
expect(primitives[1].material).toBe("Green");
expect(primitives[2].material).toBe("Red");
});
it('loads obj with objects and groups', async () => {
it("loads obj with objects and groups", async () => {
const data = await loadObj(objObjectsGroupsPath, options);
const nodes = data.nodes;
expect(nodes.length).toBe(3);
expect(nodes[0].name).toBe('CubeBlue');
expect(nodes[1].name).toBe('CubeGreen');
expect(nodes[2].name).toBe('CubeRed');
expect(nodes[0].name).toBe("CubeBlue");
expect(nodes[1].name).toBe("CubeGreen");
expect(nodes[2].name).toBe("CubeRed");
const meshes = getMeshes(data);
expect(meshes.length).toBe(3);
expect(meshes[0].name).toBe('CubeBlue_CubeBlue_Blue');
expect(meshes[1].name).toBe('CubeGreen_CubeGreen_Green');
expect(meshes[2].name).toBe('CubeRed_CubeRed_Red');
expect(meshes[0].name).toBe("CubeBlue_CubeBlue_Blue");
expect(meshes[1].name).toBe("CubeGreen_CubeGreen_Green");
expect(meshes[2].name).toBe("CubeRed_CubeRed_Red");
const primitives = getPrimitives(data);
expect(primitives.length).toBe(3);
expect(primitives[0].material).toBe('Blue');
expect(primitives[1].material).toBe('Green');
expect(primitives[2].material).toBe('Red');
expect(primitives[0].material).toBe("Blue");
expect(primitives[1].material).toBe("Green");
expect(primitives[2].material).toBe("Red");
});
function loadsObjWithObjectsGroupsAndMaterials(data) {
const nodes = data.nodes;
expect(nodes.length).toBe(1);
expect(nodes[0].name).toBe('Cube');
expect(nodes[0].name).toBe("Cube");
const meshes = getMeshes(data);
expect(meshes.length).toBe(3);
expect(meshes[0].name).toBe('Blue');
expect(meshes[1].name).toBe('Green');
expect(meshes[2].name).toBe('Red');
expect(meshes[0].name).toBe("Blue");
expect(meshes[1].name).toBe("Green");
expect(meshes[2].name).toBe("Red");
const primitives = getPrimitives(data);
expect(primitives.length).toBe(6);
expect(primitives[0].material).toBe('Blue');
expect(primitives[1].material).toBe('Green');
expect(primitives[2].material).toBe('Green');
expect(primitives[3].material).toBe('Red');
expect(primitives[4].material).toBe('Red');
expect(primitives[5].material).toBe('Blue');
expect(primitives[0].material).toBe("Blue");
expect(primitives[1].material).toBe("Green");
expect(primitives[2].material).toBe("Green");
expect(primitives[3].material).toBe("Red");
expect(primitives[4].material).toBe("Red");
expect(primitives[5].material).toBe("Blue");
}
it('loads obj with objects, groups, and materials', async () => {
it("loads obj with objects, groups, and materials", async () => {
const data = await loadObj(objObjectsGroupsMaterialsPath, options);
loadsObjWithObjectsGroupsAndMaterials(data);
});
it('loads obj with objects, groups, and materials (2)', async () => {
it("loads obj with objects, groups, and materials (2)", async () => {
// The usemtl lines are placed in an unordered fashion but
// should produce the same result as the previous test
const data = await loadObj(objObjectsGroupsMaterialsPath2, options);
loadsObjWithObjectsGroupsAndMaterials(data);
});
it('loads obj with concave face containing 5 vertices', async () => {
it("loads obj with concave face containing 5 vertices", async () => {
const data = await loadObj(objConcavePath, options);
const primitive = getPrimitives(data)[0];
expect(primitive.positions.length / 3).toBe(30);
expect(primitive.indices.length).toBe(48);
});
it('loads obj with usemtl only', async () => {
it("loads obj with usemtl only", async () => {
const data = await loadObj(objUsemtlPath, options);
const nodes = data.nodes;
expect(nodes.length).toBe(1);
expect(nodes[0].name).toBe('Node'); // default name
expect(nodes[0].name).toBe("Node"); // default name
const meshes = getMeshes(data);
expect(meshes.length).toBe(1);
expect(meshes[0].name).toBe('Node-Mesh');
expect(meshes[0].name).toBe("Node-Mesh");
const primitives = getPrimitives(data);
expect(primitives.length).toBe(3);
expect(primitives[0].material).toBe('Blue');
expect(primitives[1].material).toBe('Green');
expect(primitives[2].material).toBe('Red');
expect(primitives[0].material).toBe("Blue");
expect(primitives[1].material).toBe("Green");
expect(primitives[2].material).toBe("Red");
});
it('loads obj with no materials', async () => {
it("loads obj with no materials", async () => {
const data = await loadObj(objNoMaterialsPath, options);
const nodes = data.nodes;
expect(nodes.length).toBe(1);
expect(nodes[0].name).toBe('Node'); // default name
expect(nodes[0].name).toBe("Node"); // default name
const primitives = getPrimitives(data);
expect(primitives.length).toBe(1);
});
it('loads obj with multiple materials', async () => {
it("loads obj with multiple materials", async () => {
// The usemtl markers are interleaved, but should condense to just three primitives
const data = await loadObj(objMultipleMaterialsPath, options);
const nodes = data.nodes;
@ -285,9 +317,9 @@ describe('loadObj', () => {
expect(primitives[0].indices.length).toBe(12);
expect(primitives[1].indices.length).toBe(12);
expect(primitives[2].indices.length).toBe(12);
expect(primitives[0].material).toBe('Red');
expect(primitives[1].material).toBe('Green');
expect(primitives[2].material).toBe('Blue');
expect(primitives[0].material).toBe("Red");
expect(primitives[1].material).toBe("Green");
expect(primitives[2].material).toBe("Blue");
for (let i = 0; i < 3; ++i) {
const indices = primitives[i].indices;
@ -297,7 +329,7 @@ describe('loadObj', () => {
}
});
it('loads obj uncleaned', async () => {
it("loads obj uncleaned", async () => {
// Obj with extraneous o, g, and usemtl lines
// Also tests handling of o and g lines with the same names
const data = await loadObj(objUncleanedPath, options);
@ -309,11 +341,11 @@ describe('loadObj', () => {
expect(meshes.length).toBe(1);
expect(primitives.length).toBe(1);
expect(nodes[0].name).toBe('Cube');
expect(meshes[0].name).toBe('Cube_1');
expect(nodes[0].name).toBe("Cube");
expect(meshes[0].name).toBe("Cube_1");
});
it('loads obj with multiple mtllibs', async () => {
it("loads obj with multiple mtllibs", async () => {
const data = await loadObj(objMtllibPath, options);
const materials = data.materials;
expect(materials.length).toBe(3);
@ -323,15 +355,21 @@ describe('loadObj', () => {
return a.name.localeCompare(b.name);
});
expect(materials[0].name).toBe('Blue');
expect(materials[0].pbrMetallicRoughness.baseColorFactor).toEqual([0.0, 0.0, 0.64, 1.0]);
expect(materials[1].name).toBe('Green');
expect(materials[1].pbrMetallicRoughness.baseColorFactor).toEqual([0.0, 0.64, 0.0, 1.0]);
expect(materials[2].name).toBe('Red');
expect(materials[2].pbrMetallicRoughness.baseColorFactor).toEqual([0.64, 0.0, 0.0, 1.0]);
expect(materials[0].name).toBe("Blue");
expect(materials[0].pbrMetallicRoughness.baseColorFactor).toEqual([
0.0, 0.0, 0.64, 1.0,
]);
expect(materials[1].name).toBe("Green");
expect(materials[1].pbrMetallicRoughness.baseColorFactor).toEqual([
0.0, 0.64, 0.0, 1.0,
]);
expect(materials[2].name).toBe("Red");
expect(materials[2].pbrMetallicRoughness.baseColorFactor).toEqual([
0.64, 0.0, 0.0, 1.0,
]);
});
it('loads obj with mtllib paths with spaces', async () => {
it("loads obj with mtllib paths with spaces", async () => {
const data = await loadObj(objMtllibSpacesPath, options);
const materials = data.materials;
expect(materials.length).toBe(3);
@ -341,71 +379,98 @@ describe('loadObj', () => {
return a.name.localeCompare(b.name);
});
expect(materials[0].name).toBe('Blue');
expect(materials[0].pbrMetallicRoughness.baseColorFactor).toEqual([0.0, 0.0, 0.64, 1.0]);
expect(materials[1].name).toBe('Green');
expect(materials[1].pbrMetallicRoughness.baseColorFactor).toEqual([0.0, 0.64, 0.0, 1.0]);
expect(materials[2].name).toBe('Red');
expect(materials[2].pbrMetallicRoughness.baseColorFactor).toEqual([0.64, 0.0, 0.0, 1.0]);
expect(materials[0].name).toBe("Blue");
expect(materials[0].pbrMetallicRoughness.baseColorFactor).toEqual([
0.0, 0.0, 0.64, 1.0,
]);
expect(materials[1].name).toBe("Green");
expect(materials[1].pbrMetallicRoughness.baseColorFactor).toEqual([
0.0, 0.64, 0.0, 1.0,
]);
expect(materials[2].name).toBe("Red");
expect(materials[2].pbrMetallicRoughness.baseColorFactor).toEqual([
0.64, 0.0, 0.0, 1.0,
]);
});
it('loads obj with missing mtllib', async () => {
const spy = jasmine.createSpy('logger');
it("loads obj with missing mtllib", async () => {
const spy = jasmine.createSpy("logger");
options.logger = spy;
const data = await loadObj(objMissingMtllibPath, options);
expect(data.materials.length).toBe(0);
expect(spy.calls.argsFor(0)[0].indexOf('ENOENT') >= 0).toBe(true);
expect(spy.calls.argsFor(0)[0].indexOf(path.resolve('/box.mtl')) >= 0).toBe(true);
expect(spy.calls.argsFor(1)[0].indexOf('Attempting to read the material file from within the obj directory instead.') >= 0).toBe(true);
expect(spy.calls.argsFor(2)[0].indexOf('ENOENT') >= 0).toBe(true);
expect(spy.calls.argsFor(3)[0].indexOf('Could not read material file') >= 0).toBe(true);
expect(spy.calls.argsFor(0)[0].indexOf("ENOENT") >= 0).toBe(true);
expect(spy.calls.argsFor(0)[0].indexOf(path.resolve("/box.mtl")) >= 0).toBe(
true
);
expect(
spy.calls
.argsFor(1)[0]
.indexOf(
"Attempting to read the material file from within the obj directory instead."
) >= 0
).toBe(true);
expect(spy.calls.argsFor(2)[0].indexOf("ENOENT") >= 0).toBe(true);
expect(
spy.calls.argsFor(3)[0].indexOf("Could not read material file") >= 0
).toBe(true);
});
it('loads obj with missing usemtl', async () => {
it("loads obj with missing usemtl", async () => {
const data = await loadObj(objMissingUsemtlPath, options);
expect(data.materials.length).toBe(1);
expect(data.nodes[0].meshes[0].primitives[0].material).toBe('Material');
expect(data.nodes[0].meshes[0].primitives[0].material).toBe("Material");
});
it('loads obj with unnamed material', async () => {
it("loads obj with unnamed material", async () => {
const data = await loadObj(objUnnamedMaterialPath, options);
expect(data.materials.length).toBe(1);
expect(data.nodes[0].meshes[0].primitives[0].material).toBe('');
expect(data.nodes[0].meshes[0].primitives[0].material).toBe("");
});
it('loads .mtl outside of the obj directory', async () => {
it("loads .mtl outside of the obj directory", async () => {
const data = await loadObj(objExternalResourcesPath, options);
const materials = data.materials;
expect(materials.length).toBe(2);
// .mtl files are loaded in an arbitrary order, so find the "MaterialTextured" material
const materialTextured = materials[0].name === 'MaterialTextured' ? materials[0] : materials[1];
const baseColorTexture = materialTextured.pbrMetallicRoughness.baseColorTexture;
const materialTextured =
materials[0].name === "MaterialTextured" ? materials[0] : materials[1];
const baseColorTexture =
materialTextured.pbrMetallicRoughness.baseColorTexture;
expect(baseColorTexture.source).toBeDefined();
expect(baseColorTexture.name).toEqual('cesium');
expect(baseColorTexture.name).toEqual("cesium");
});
it('does not load .mtl outside of the obj directory when secure is true', async () => {
const spy = jasmine.createSpy('logger');
it("does not load .mtl outside of the obj directory when secure is true", async () => {
const spy = jasmine.createSpy("logger");
options.logger = spy;
options.secure = true;
const data = await loadObj(objExternalResourcesPath, options);
expect(data.materials.length).toBe(1); // obj references 2 materials, one of which is outside the input directory
expect(spy.calls.argsFor(0)[0].indexOf('The material file is outside of the obj directory and the secure flag is true. Attempting to read the material file from within the obj directory instead.') >= 0).toBe(true);
expect(spy.calls.argsFor(1)[0].indexOf('ENOENT') >= 0).toBe(true);
expect(spy.calls.argsFor(2)[0].indexOf('Could not read material file') >= 0).toBe(true);
expect(
spy.calls
.argsFor(0)[0]
.indexOf(
"The material file is outside of the obj directory and the secure flag is true. Attempting to read the material file from within the obj directory instead."
) >= 0
).toBe(true);
expect(spy.calls.argsFor(1)[0].indexOf("ENOENT") >= 0).toBe(true);
expect(
spy.calls.argsFor(2)[0].indexOf("Could not read material file") >= 0
).toBe(true);
});
it('loads .mtl from root directory when the .mtl path does not exist', async () => {
it("loads .mtl from root directory when the .mtl path does not exist", async () => {
const data = await loadObj(objResourcesInRootPath, options);
const baseColorTexture = data.materials[0].pbrMetallicRoughness.baseColorTexture;
expect(baseColorTexture.name).toBe('cesium');
const baseColorTexture =
data.materials[0].pbrMetallicRoughness.baseColorTexture;
expect(baseColorTexture.name).toBe("cesium");
expect(baseColorTexture.source).toBeDefined();
});
it('loads .mtl from root directory when the .mtl path is outside of the obj directory and secure is true', async () => {
it("loads .mtl from root directory when the .mtl path is outside of the obj directory and secure is true", async () => {
options.secure = true;
const data = await loadObj(objExternalResourcesInRootPath, options);
@ -413,48 +478,64 @@ describe('loadObj', () => {
expect(materials.length).toBe(2);
// .mtl files are loaded in an arbitrary order, so find the "MaterialTextured" material
const materialTextured = materials[0].name === 'MaterialTextured' ? materials[0] : materials[1];
const baseColorTexture = materialTextured.pbrMetallicRoughness.baseColorTexture;
const materialTextured =
materials[0].name === "MaterialTextured" ? materials[0] : materials[1];
const baseColorTexture =
materialTextured.pbrMetallicRoughness.baseColorTexture;
expect(baseColorTexture.source).toBeDefined();
expect(baseColorTexture.name).toEqual('cesium');
expect(baseColorTexture.name).toEqual("cesium");
});
it('loads obj with texture', async () => {
it("loads obj with texture", async () => {
const data = await loadObj(objTexturedPath, options);
const baseColorTexture = data.materials[0].pbrMetallicRoughness.baseColorTexture;
expect(baseColorTexture.name).toBe('cesium');
const baseColorTexture =
data.materials[0].pbrMetallicRoughness.baseColorTexture;
expect(baseColorTexture.name).toBe("cesium");
expect(baseColorTexture.source).toBeDefined();
});
it('loads obj with missing texture', async () => {
const spy = jasmine.createSpy('logger');
it("loads obj with missing texture", async () => {
const spy = jasmine.createSpy("logger");
options.logger = spy;
const data = await loadObj(objMissingTexturePath, options);
const baseColorTexture = data.materials[0].pbrMetallicRoughness.baseColorTexture;
const baseColorTexture =
data.materials[0].pbrMetallicRoughness.baseColorTexture;
expect(baseColorTexture).toBeUndefined();
expect(spy.calls.argsFor(0)[0].indexOf('ENOENT') >= 0).toBe(true);
expect(spy.calls.argsFor(0)[0].indexOf(path.resolve('/cesium.png')) >= 0).toBe(true);
expect(spy.calls.argsFor(1)[0].indexOf('Attempting to read the texture file from within the obj directory instead.') >= 0).toBe(true);
expect(spy.calls.argsFor(2)[0].indexOf('ENOENT') >= 0).toBe(true);
expect(spy.calls.argsFor(3)[0].indexOf('Could not read texture file') >= 0).toBe(true);
expect(spy.calls.argsFor(0)[0].indexOf("ENOENT") >= 0).toBe(true);
expect(
spy.calls.argsFor(0)[0].indexOf(path.resolve("/cesium.png")) >= 0
).toBe(true);
expect(
spy.calls
.argsFor(1)[0]
.indexOf(
"Attempting to read the texture file from within the obj directory instead."
) >= 0
).toBe(true);
expect(spy.calls.argsFor(2)[0].indexOf("ENOENT") >= 0).toBe(true);
expect(
spy.calls.argsFor(3)[0].indexOf("Could not read texture file") >= 0
).toBe(true);
});
it('loads obj with subdirectories', async () => {
it("loads obj with subdirectories", async () => {
const data = await loadObj(objSubdirectoriesPath, options);
const baseColorTexture = data.materials[0].pbrMetallicRoughness.baseColorTexture;
expect(baseColorTexture.name).toBe('cesium');
const baseColorTexture =
data.materials[0].pbrMetallicRoughness.baseColorTexture;
expect(baseColorTexture.name).toBe("cesium");
expect(baseColorTexture.source).toBeDefined();
});
it('loads obj with windows paths', async () => {
it("loads obj with windows paths", async () => {
const data = await loadObj(objWindowsPaths, options);
const baseColorTexture = data.materials[0].pbrMetallicRoughness.baseColorTexture;
expect(baseColorTexture.name).toBe('cesium');
const baseColorTexture =
data.materials[0].pbrMetallicRoughness.baseColorTexture;
expect(baseColorTexture.name).toBe("cesium");
expect(baseColorTexture.source).toBeDefined();
});
it('separates faces that don\'t use the same attributes as other faces in the primitive', async () => {
it("separates faces that don't use the same attributes as other faces in the primitive", async () => {
const data = await loadObj(objMixedAttributesPath, options);
const primitives = getPrimitives(data);
expect(primitives.length).toBe(4);
@ -466,16 +547,29 @@ describe('loadObj', () => {
function getFirstPosition(data) {
const primitive = getPrimitives(data)[0];
return new Cartesian3(primitive.positions.get(0), primitive.positions.get(1), primitive.positions.get(2));
return new Cartesian3(
primitive.positions.get(0),
primitive.positions.get(1),
primitive.positions.get(2)
);
}
function getFirstNormal(data) {
const primitive = getPrimitives(data)[0];
return new Cartesian3(primitive.normals.get(0), primitive.normals.get(1), primitive.normals.get(2));
return new Cartesian3(
primitive.normals.get(0),
primitive.normals.get(1),
primitive.normals.get(2)
);
}
async function checkAxisConversion(inputUpAxis, outputUpAxis, position, normal) {
const sameAxis = (inputUpAxis === outputUpAxis);
async function checkAxisConversion(
inputUpAxis,
outputUpAxis,
position,
normal
) {
const sameAxis = inputUpAxis === outputUpAxis;
options.inputUpAxis = inputUpAxis;
options.outputUpAxis = outputUpAxis;
const data = await loadObj(objRotatedUrl, options);
@ -490,12 +584,12 @@ describe('loadObj', () => {
}
}
it('performs up axis conversion', async () => {
it("performs up axis conversion", async () => {
const data = await loadObj(objRotatedUrl, options);
const position = getFirstPosition(data);
const normal = getFirstNormal(data);
const axes = ['X', 'Y', 'Z'];
const axes = ["X", "Y", "Z"];
const axesLength = axes.length;
for (let i = 0; i < axesLength; ++i) {
for (let j = 0; j < axesLength; ++j) {
@ -504,7 +598,7 @@ describe('loadObj', () => {
}
});
it('ignores missing normals and uvs', async () => {
it("ignores missing normals and uvs", async () => {
const data = await loadObj(objMissingAttributesPath, options);
const primitive = getPrimitives(data)[0];
expect(primitive.positions.length).toBeGreaterThan(0);
@ -519,12 +613,18 @@ describe('loadObj', () => {
return new Uint16Array(indices.toUint16Buffer().buffer);
}
it('applies triangle winding order sanitization', async () => {
it("applies triangle winding order sanitization", async () => {
options.triangleWindingOrderSanitization = false;
const indicesIncorrect = await loadAndGetIndices(objIncorrectWindingOrderPath, options);
const indicesIncorrect = await loadAndGetIndices(
objIncorrectWindingOrderPath,
options
);
options.triangleWindingOrderSanitization = true;
const indicesCorrect = await loadAndGetIndices(objIncorrectWindingOrderPath, options);
const indicesCorrect = await loadAndGetIndices(
objIncorrectWindingOrderPath,
options
);
expect(indicesIncorrect[0]).toBe(0);
expect(indicesIncorrect[2]).toBe(2);
@ -535,53 +635,65 @@ describe('loadObj', () => {
expect(indicesCorrect[1]).toBe(2);
});
it('throws when position index is out of bounds', async () => {
it("throws when position index is out of bounds", async () => {
let thrownError;
try {
await loadObj(objIncompletePositionsPath, options);
} catch (e) {
thrownError = e;
}
expect(thrownError).toEqual(new RuntimeError('Position index 1 is out of bounds'));
expect(thrownError).toEqual(
new RuntimeError("Position index 1 is out of bounds")
);
});
it('throws when normal index is out of bounds', async () => {
it("throws when normal index is out of bounds", async () => {
let thrownError;
try {
await loadObj(objIncompleteNormalsPath, options);
} catch (e) {
thrownError = e;
}
expect(thrownError).toEqual(new RuntimeError('Normal index 1 is out of bounds'));
expect(thrownError).toEqual(
new RuntimeError("Normal index 1 is out of bounds")
);
});
it('throws when uv index is out of bounds', async () => {
it("throws when uv index is out of bounds", async () => {
let thrownError;
try {
await loadObj(objIncompleteUvsPath, options);
} catch (e) {
thrownError = e;
}
expect(thrownError).toEqual(new RuntimeError('UV index 1 is out of bounds'));
expect(thrownError).toEqual(
new RuntimeError("UV index 1 is out of bounds")
);
});
it('throws when file has invalid contents', async () => {
it("throws when file has invalid contents", async () => {
let thrownError;
try {
await loadObj(objInvalidContentsPath, options);
} catch (e) {
thrownError = e;
}
expect(thrownError).toEqual(new RuntimeError(objInvalidContentsPath + ' does not have any geometry data'));
expect(thrownError).toEqual(
new RuntimeError(
objInvalidContentsPath + " does not have any geometry data"
)
);
});
it('throw when reading invalid file', async () => {
it("throw when reading invalid file", async () => {
let thrownError;
try {
await loadObj(objInvalidPath, options);
} catch (e) {
thrownError = e;
}
expect(thrownError.message.startsWith('ENOENT: no such file or directory')).toBe(true);
expect(
thrownError.message.startsWith("ENOENT: no such file or directory")
).toBe(true);
});
});

60
specs/lib/loadTextureSpec.js
View File

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

118
specs/lib/obj2gltfSpec.js
View File

@ -1,91 +1,93 @@
'use strict';
const { DeveloperError } = require('cesium');
const fsExtra = require('fs-extra');
const path = require('path');
const Promise = require('bluebird');
const createGltf = require('../../lib/createGltf');
const obj2gltf = require('../../lib/obj2gltf');
"use strict";
const { DeveloperError } = require("cesium");
const fsExtra = require("fs-extra");
const path = require("path");
const Promise = require("bluebird");
const createGltf = require("../../lib/createGltf");
const obj2gltf = require("../../lib/obj2gltf");
const texturedObjPath = 'specs/data/box-textured/box-textured.obj';
const complexObjPath = 'specs/data/box-complex-material/box-complex-material.obj';
const missingMtllibObjPath = 'specs/data/box-missing-mtllib/box-missing-mtllib.obj';
const texturedObjPath = "specs/data/box-textured/box-textured.obj";
const complexObjPath =
"specs/data/box-complex-material/box-complex-material.obj";
const missingMtllibObjPath =
"specs/data/box-missing-mtllib/box-missing-mtllib.obj";
const outputDirectory = 'output';
const outputDirectory = "output";
const textureUrl = 'specs/data/box-textured/cesium.png';
const textureUrl = "specs/data/box-textured/cesium.png";
describe('obj2gltf', () => {
describe("obj2gltf", () => {
beforeEach(() => {
spyOn(fsExtra, 'outputFile').and.returnValue(Promise.resolve());
spyOn(fsExtra, "outputFile").and.returnValue(Promise.resolve());
});
it('converts obj to gltf', async () => {
it("converts obj to gltf", async () => {
const gltf = await obj2gltf(texturedObjPath);
expect(gltf).toBeDefined();
expect(gltf.images.length).toBe(1);
});
it('converts obj to glb', async () => {
it("converts obj to glb", async () => {
const options = {
binary : true
binary: true,
};
const glb = await obj2gltf(texturedObjPath, options);
const magic = glb.toString('utf8', 0, 4);
expect(magic).toBe('glTF');
const magic = glb.toString("utf8", 0, 4);
expect(magic).toBe("glTF");
});
it('convert obj to gltf with separate resources', async () => {
it("convert obj to gltf with separate resources", async () => {
const options = {
separate: true,
separateTextures: true,
outputDirectory : outputDirectory
outputDirectory: outputDirectory,
};
await obj2gltf(texturedObjPath, options);
expect(fsExtra.outputFile.calls.count()).toBe(2); // Saves out .png and .bin
});
it('convert obj to gltf with separate resources when buffer exceeds Node limit', async () => {
spyOn(createGltf, '_getBufferMaxByteLength').and.returnValue(0);
it("convert obj to gltf with separate resources when buffer exceeds Node limit", async () => {
spyOn(createGltf, "_getBufferMaxByteLength").and.returnValue(0);
const options = {
separate: true,
separateTextures: true,
outputDirectory : outputDirectory
outputDirectory: outputDirectory,
};
await obj2gltf(texturedObjPath, options);
expect(fsExtra.outputFile.calls.count()).toBe(5); // Saves out .png and four .bin for positions, normals, uvs, and indices
});
it('converts obj to glb with separate resources', async () => {
it("converts obj to glb with separate resources", async () => {
const options = {
separate: true,
separateTextures: true,
outputDirectory: outputDirectory,
binary : true
binary: true,
};
await obj2gltf(texturedObjPath, options);
expect(fsExtra.outputFile.calls.count()).toBe(2); // Saves out .png and .bin
});
it('converts obj with multiple textures', async () => {
it("converts obj with multiple textures", async () => {
const options = {
separateTextures: true,
outputDirectory : outputDirectory
outputDirectory: outputDirectory,
};
await obj2gltf(complexObjPath, options);
expect(fsExtra.outputFile.calls.count()).toBe(5); // baseColor, metallicRoughness, occlusion, emission, normal
});
it('sets overriding textures (1)', async () => {
it("sets overriding textures (1)", async () => {
const options = {
overridingTextures: {
metallicRoughnessOcclusionTexture: textureUrl,
normalTexture: textureUrl,
baseColorTexture: textureUrl,
emissiveTexture: textureUrl,
alphaTexture : textureUrl
alphaTexture: textureUrl,
},
separateTextures: true,
outputDirectory : outputDirectory
outputDirectory: outputDirectory,
};
await obj2gltf(complexObjPath, options);
const args = fsExtra.outputFile.calls.allArgs();
@ -95,7 +97,7 @@ describe('obj2gltf', () => {
}
});
it('sets overriding textures (2)', async () => {
it("sets overriding textures (2)", async () => {
const options = {
overridingTextures: {
specularGlossinessTexture: textureUrl,
@ -103,10 +105,10 @@ describe('obj2gltf', () => {
normalTexture: textureUrl,
baseColorTexture: textureUrl,
emissiveTexture: textureUrl,
alphaTexture : textureUrl
alphaTexture: textureUrl,
},
separateTextures: true,
outputDirectory : outputDirectory
outputDirectory: outputDirectory,
};
await obj2gltf(complexObjPath, options);
const args = fsExtra.outputFile.calls.allArgs();
@ -116,18 +118,18 @@ describe('obj2gltf', () => {
}
});
it('uses a custom logger', async () => {
it("uses a custom logger", async () => {
let lastMessage;
const options = {
logger: (message) => {
lastMessage = message;
}
},
};
await obj2gltf(missingMtllibObjPath, options);
expect(lastMessage.indexOf('Could not read material file') >= 0).toBe(true);
expect(lastMessage.indexOf("Could not read material file") >= 0).toBe(true);
});
it('uses a custom writer', async () => {
it("uses a custom writer", async () => {
const filePaths = [];
const fileContents = [];
const options = {
@ -135,27 +137,27 @@ describe('obj2gltf', () => {
writer: (relativePath, contents) => {
filePaths.push(relativePath);
fileContents.push(contents);
}
},
};
await obj2gltf(texturedObjPath, options);
expect(filePaths).toEqual(['cesium.png', 'box-textured.bin']);
expect(filePaths).toEqual(["cesium.png", "box-textured.bin"]);
expect(fileContents[0]).toBeDefined();
expect(fileContents[1]).toBeDefined();
});
it('throws if objPath is undefined', () => {
it("throws if objPath is undefined", () => {
let thrownError;
try {
obj2gltf(undefined);
} catch (e) {
thrownError = e;
}
expect(thrownError).toEqual(new DeveloperError('objPath is required'));
expect(thrownError).toEqual(new DeveloperError("objPath is required"));
});
it('throws if both options.writer and options.outputDirectory are undefined when writing separate resources', () => {
it("throws if both options.writer and options.outputDirectory are undefined when writing separate resources", () => {
const options = {
separateTextures : true
separateTextures: true,
};
let thrownError;
@ -164,13 +166,17 @@ describe('obj2gltf', () => {
} catch (e) {
thrownError = e;
}
expect(thrownError).toEqual(new DeveloperError('Either options.writer or options.outputDirectory must be defined when writing separate resources.'));
expect(thrownError).toEqual(
new DeveloperError(
"Either options.writer or options.outputDirectory must be defined when writing separate resources."
)
);
});
it('throws if more than one material type is set', () => {
it("throws if more than one material type is set", () => {
const options = {
metallicRoughness: true,
specularGlossiness : true
specularGlossiness: true,
};
let thrownError;
@ -179,15 +185,19 @@ describe('obj2gltf', () => {
} catch (e) {
thrownError = e;
}
expect(thrownError).toEqual(new DeveloperError('Only one material type may be set from [metallicRoughness, specularGlossiness, unlit].'));
expect(thrownError).toEqual(
new DeveloperError(
"Only one material type may be set from [metallicRoughness, specularGlossiness, unlit]."
)
);
});
it('throws if metallicRoughnessOcclusionTexture and specularGlossinessTexture are both defined', () => {
it("throws if metallicRoughnessOcclusionTexture and specularGlossinessTexture are both defined", () => {
const options = {
overridingTextures: {
metallicRoughnessOcclusionTexture: textureUrl,
specularGlossinessTexture : textureUrl
}
specularGlossinessTexture: textureUrl,
},
};
let thrownError;
@ -196,6 +206,10 @@ describe('obj2gltf', () => {
} catch (e) {
thrownError = e;
}
expect(thrownError).toEqual(new DeveloperError('metallicRoughnessOcclusionTexture and specularGlossinessTexture cannot both be defined.'));
expect(thrownError).toEqual(
new DeveloperError(
"metallicRoughnessOcclusionTexture and specularGlossinessTexture cannot both be defined."
)
);
});
});