GitLab

Reenable blank issues

The PNG image type should be at offset 25 - not 27

https://en.wikipedia.org/wiki/Portable_Network_Graphics#File_header
8 header
8 IHDR start
4(width) + 4(height) + 1 bit depth
26th byte is color type

Fix for samplers being written out with default values and writing 0 filter fields if no filter value was read

Fixes #313.

Fix merging multiple meshes that have different flip face winding

Fixes #315

Fix spelling

Fix for samplers being written out with default values and writing 0 in filter fields if no filter value was read

Refactor JS builds for future modules

This should conclude the list of functions we need to implement the
necessary interface.

The new table is generated from all .wasm modules (scalar & SIMD
decoder, encoder and simplifier). This actually reduces the decoder size
as well as reducing all other modules, probably because the decoder used
a non-SIMD table before.

decoder size:
.js: 22183 => 22107 bytes (-0.4%)
.jz.gz: 6059 => 6049 bytes (-0.2%)

The gains on other (future) JS modules are more significant, at 3-7%.

We now automatically extract the module name to form an exports
statement from the UMD declaration.

This build is added for testing for now; it probably needs to export
vfetch optimization routines as well to be able to reduce the vertex
count easily.

Parts of the encoder rely on meshopt_Allocator; for simplicity, we
override new/delete to use sbrk which assumes stack-like allocation.

This change splits the decoder-specific configuration from general
configuration to make it easier to add other Wasm+JS builds.

Add meshopt_encodeFilter* function family

The error bound is larger than might be expected with 15 bits of
mantissa due to a shared exponent.

char is unsigned on ARM builds

Since octahedral decoder doesn't touch .w component, we need to encode
it using the full number of bits available for storage.

Also add roundtrip tests that caught this.

For now these are just using golden data

This effectively stores values smaller than 2^-100 as 0 even when we
have enough bits to represent the values; the acceptable input range for
exponent encoding is -100..100 to allow for the extra bit bias anyway.

On second thought, it's trivial to emulate single-component exp encoding
by simply passing stride=4 and multiplying count by the actual number of
elements, so we don't need the extra function.

The code used for these functions is taken more or less verbatim from
gltfpack. For exponential encoding, we support two variants -
one-at-a-time encoding and shared exponent encoding, the latter trades
off some quality for higher compression ratio.

Something changed with codecov bash script and 'src#*.gcov' no longer works, but './src*.gcov' does.

This change also switches to Ubuntu 20.04 to fix ARM64 coverage reporting that was failing because of gcov version mismatch between ARM64 and x64 systems.

This cleans up PRs from the repository itself.

This is more consistent with how my editors format text by default so it
results in fewer mismatches, and would work better if we were to ever
enforce column limits.

This is a fallout from #302

gltfpack: Switch to C++11

This is going to make Basis integration easier; there's no real reason
to keep using C++98 for gltfpack. Note that meshoptimizer continues to
use C++98 and that is unlikely to change.

gltfpack: Remove BLEND mode from materials that don't need it

This makes sure we can use them from Basisu encoder, since we're moving
a lot of things around in this change anyway this will help subsequent
changes.

Instead of eagerly processing all images we now do this lazily; the code
flow is a bit more complex but it's more optimal since we need to do
this only when we are confirming the blend validity, and only for the
diffuse texture.

This relies on extracting image metadata from all images, which means we
now always read image data at least once when processing scenes; but the
benefit is that we can now remove incorrect BLEND modes from materials
which seems worth it.

This extracts a readImage function that we can reuse elsewhere; during
serialization we skip reading if the URI can be written to the output
file as is.