GitHub-Proxy/draco
1
0
Fork 0
mirror of https://git.mirrors.martin98.com/https://github.com/google/draco synced 2025-06-04 11:25:44 +08:00
Code Issues Packages Projects Releases Wiki Activity

Update version to 1.2.3

Browse Source 
This fixes #300
This commit is contained in:
Frank Galligan 2017-11-25 12:55:27 -08:00
parent 441d5e05f7
commit ff89a1142c
12 changed files with 104 additions and 80 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
README.md
View File

@ -5,6 +5,9 @@
News
=======
### Version 1.2.3 release
* Fixed Visual Studio building issue
### Version 1.2.2 release
The latest version of Draco brings a number of small bug fixes
* Fixed issues when parsing ill-formatted .obj files

2
src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_encoder.h
View File

@ -77,6 +77,7 @@ class MeshPredictionSchemeConstrainedMultiParallelogramEncoder
// the edges are processed. For better compression, the flags are stored in
// in separate contexts based on the number of available parallelograms at a
// given vertex.
// TODO(scottgodfrey) reconsider std::vector<bool> (performance/space).
std::vector<bool> is_crease_edge_[kMaxNumParallelograms];
Mode selected_mode_;
};
@ -190,6 +191,7 @@ bool MeshPredictionSchemeConstrainedMultiParallelogramEncoder<
// Mark all parallelograms as excluded.
std::fill(exluded_parallelograms,
exluded_parallelograms + num_parallelograms, true);
// TODO(scottgodfrey) maybe this should be another std::fill.
// Mark the first |num_used_parallelograms| as not excluded.
for (int j = 0; j < num_used_parallelograms; ++j) {
exluded_parallelograms[j] = false;

2
src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_shared.h
View File

@ -22,6 +22,8 @@
namespace draco {
// TODO(scottgodfrey) consolidate Vertex/next/previous queries to one call
// (performance).
template <class CornerTableT>
inline void GetParallelogramEntries(
const CornerIndex ci, const CornerTableT *table,

144
src/draco/compression/attributes/prediction_schemes/prediction_scheme_decoder_factory.h
View File

@ -40,78 +40,100 @@ struct MeshPredictionSchemeDecoderFactory {
// for all mesh prediction schemes. The specialization is done in compile time
// to prevent instantiations of unneeded combinations of prediction schemes +
// prediction transforms.
template <
class TransformT, class MeshDataT,
typename std::enable_if<
TransformT::GetType() == PREDICTION_TRANSFORM_WRAP, int>::type = 0>
std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>> operator()(
PredictionSchemeMethod method, const PointAttribute *attribute,
const TransformT &transform, const MeshDataT &mesh_data,
uint16_t bitstream_version) {
if (method == MESH_PREDICTION_PARALLELOGRAM) {
return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
new MeshPredictionSchemeParallelogramDecoder<DataTypeT, TransformT,
MeshDataT>(
attribute, transform, mesh_data));
}
#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
else if (method == MESH_PREDICTION_MULTI_PARALLELOGRAM) {
return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
new MeshPredictionSchemeMultiParallelogramDecoder<
DataTypeT, TransformT, MeshDataT>(attribute, transform,
mesh_data));
}
#endif
else if (method == MESH_PREDICTION_CONSTRAINED_MULTI_PARALLELOGRAM) {
return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
new MeshPredictionSchemeConstrainedMultiParallelogramDecoder<
DataTypeT, TransformT, MeshDataT>(attribute, transform,
mesh_data));
}
#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
else if (method == MESH_PREDICTION_TEX_COORDS) {
return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
new MeshPredictionSchemeTexCoordsDecoder<DataTypeT, TransformT,
MeshDataT>(
attribute, transform, mesh_data, bitstream_version));
}
#endif
else if (method == MESH_PREDICTION_TEX_COORDS_PORTABLE) {
return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
new MeshPredictionSchemeTexCoordsPortableDecoder<
DataTypeT, TransformT, MeshDataT>(attribute, transform,
mesh_data));
} else if (method == MESH_PREDICTION_GEOMETRIC_NORMAL) {
return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
new MeshPredictionSchemeGeometricNormalDecoder<DataTypeT, TransformT,
template <class TransformT, class MeshDataT,
PredictionSchemeTransformType Method>
struct DispatchFunctor {
std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>> operator()(
PredictionSchemeMethod method, const PointAttribute *attribute,
const TransformT &transform, const MeshDataT &mesh_data,
uint16_t bitstream_version) {
if (method == MESH_PREDICTION_PARALLELOGRAM) {
return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
new MeshPredictionSchemeParallelogramDecoder<DataTypeT, TransformT,
MeshDataT>(
attribute, transform, mesh_data));
attribute, transform, mesh_data));
}
#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
else if (method == MESH_PREDICTION_MULTI_PARALLELOGRAM) {
return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
new MeshPredictionSchemeMultiParallelogramDecoder<
DataTypeT, TransformT, MeshDataT>(attribute, transform,
mesh_data));
}
#endif
else if (method == MESH_PREDICTION_CONSTRAINED_MULTI_PARALLELOGRAM) {
return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
new MeshPredictionSchemeConstrainedMultiParallelogramDecoder<
DataTypeT, TransformT, MeshDataT>(attribute, transform,
mesh_data));
}
#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
else if (method == MESH_PREDICTION_TEX_COORDS) {
return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
new MeshPredictionSchemeTexCoordsDecoder<DataTypeT, TransformT,
MeshDataT>(
attribute, transform, mesh_data, bitstream_version));
}
#endif
else if (method == MESH_PREDICTION_TEX_COORDS_PORTABLE) {
return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
new MeshPredictionSchemeTexCoordsPortableDecoder<
DataTypeT, TransformT, MeshDataT>(attribute, transform,
mesh_data));
} else if (method == MESH_PREDICTION_GEOMETRIC_NORMAL) {
return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
new MeshPredictionSchemeGeometricNormalDecoder<
DataTypeT, TransformT, MeshDataT>(attribute, transform,
mesh_data));
}
return nullptr;
}
return nullptr;
}
};
// Operator () specialized for normal octahedron transforms. These transforms
// are currently used only by the geometric normal prediction scheme (the
// transform is also used by delta coding, but delta predictor is not
// constructed in this function).
template <
class TransformT, class MeshDataT,
typename std::enable_if<
TransformT::GetType() ==
PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON_CANONICALIZED ||
TransformT::GetType() == PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON,
int>::type = 0>
template <class TransformT, class MeshDataT>
struct DispatchFunctor<TransformT, MeshDataT,
PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON_CANONICALIZED> {
std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>> operator()(
PredictionSchemeMethod method, const PointAttribute *attribute,
const TransformT &transform, const MeshDataT &mesh_data,
uint16_t bitstream_version) {
if (method == MESH_PREDICTION_GEOMETRIC_NORMAL) {
return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
new MeshPredictionSchemeGeometricNormalDecoder<
DataTypeT, TransformT, MeshDataT>(attribute, transform,
mesh_data));
}
return nullptr;
}
};
template <class TransformT, class MeshDataT>
struct DispatchFunctor<TransformT, MeshDataT,
PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON> {
std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>> operator()(
PredictionSchemeMethod method, const PointAttribute *attribute,
const TransformT &transform, const MeshDataT &mesh_data,
uint16_t bitstream_version) {
if (method == MESH_PREDICTION_GEOMETRIC_NORMAL) {
return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
new MeshPredictionSchemeGeometricNormalDecoder<
DataTypeT, TransformT, MeshDataT>(attribute, transform,
mesh_data));
}
return nullptr;
}
};
template <class TransformT, class MeshDataT>
std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>> operator()(
PredictionSchemeMethod method, const PointAttribute *attribute,
const TransformT &transform, const MeshDataT &mesh_data,
uint16_t bitstream_version) {
if (method == MESH_PREDICTION_GEOMETRIC_NORMAL) {
return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
new MeshPredictionSchemeGeometricNormalDecoder<DataTypeT, TransformT,
MeshDataT>(
attribute, transform, mesh_data));
}
return nullptr;
return DispatchFunctor<TransformT, MeshDataT, TransformT::GetType()>()(
method, attribute, transform, mesh_data, bitstream_version);
}
};

1
src/draco/compression/config/compression_shared.h
View File

@ -33,6 +33,7 @@ static constexpr uint16_t kDracoBitstreamVersion = DRACO_BITSTREAM_VERSION(
kDracoBitstreamVersionMajor, kDracoBitstreamVersionMinor);
// Currently, we support point cloud and triangular mesh encoding.
// TODO(scottgodfrey) convert enum to enum class (safety, not performance).
enum EncodedGeometryType {
INVALID_GEOMETRY_TYPE = -1,
POINT_CLOUD = 0,

13
src/draco/compression/mesh/mesh_edgebreaker_decoder_impl.cc
View File

@ -356,16 +356,9 @@ bool MeshEdgeBreakerDecoderImpl<TraversalDecoder>::DecodeConnectivity() {
}
traversal_decoder_.Init(this);
#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
if (decoder_->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 2)) {
traversal_decoder_.SetNumEncodedVertices(num_encoded_vertices_);
} else
#endif
{
// Add one extra vertex for each split symbol.
traversal_decoder_.SetNumEncodedVertices(num_encoded_vertices_ +
num_encoded_split_symbols);
}
// Add one extra vertex for each split symbol.
traversal_decoder_.SetNumEncodedVertices(num_encoded_vertices_ +
num_encoded_split_symbols);
traversal_decoder_.SetNumAttributeData(num_attribute_data);
DecoderBuffer traversal_end_buffer;

2
src/draco/compression/mesh/mesh_edgebreaker_encoder_impl.cc
View File

@ -28,7 +28,7 @@
#include "draco/mesh/prediction_degree_traverser.h"
namespace draco {
// TODO(scottgodfrey) consider converting 'typedef' to 'using' and deduplicate.
typedef CornerIndex CornerIndex;
typedef FaceIndex FaceIndex;
typedef VertexIndex VertexIndex;

4
src/draco/compression/mesh/mesh_edgebreaker_traversal_predictive_decoder.h
View File

@ -44,8 +44,8 @@ class MeshEdgeBreakerTraversalPredictiveDecoder
int32_t num_split_symbols;
if (!out_buffer->Decode(&num_split_symbols) || num_split_symbols < 0)
return false;
// Add one vertex for each split symbol.
num_vertices_ += num_split_symbols;
if (num_split_symbols >= num_vertices_)
return false;
// Set the valences of all initial vertices to 0.
vertex_valences_.resize(num_vertices_, 0);
if (!prediction_decoder_.StartDecoding(out_buffer))

4
src/draco/compression/mesh/mesh_edgebreaker_traversal_valence_decoder.h
View File

@ -64,8 +64,8 @@ class MeshEdgeBreakerTraversalValenceDecoder
if (!DecodeVarint(&num_split_symbols, out_buffer))
return false;
}
// Add one extra vertex for each split symbol.
num_vertices_ += num_split_symbols;
if (num_split_symbols >= num_vertices_)
return false;
int8_t mode;
if (!out_buffer->Decode(&mode))

2
src/draco/core/draco_version.h
View File

@ -18,7 +18,7 @@
namespace draco {
// Draco version is comprised of <major>.<minor>.<revision>.
static const char kDracoVersion[] = "1.2.2";
static const char kDracoVersion[] = "1.2.3";
const char *Version() { return kDracoVersion; }

4
src/draco/io/obj_decoder.cc
View File

@ -623,8 +623,8 @@ bool ObjDecoder::ParseMaterialFile(const std::string &file_name, bool *error) {
buffer_.Init(&data[0], file_size);
num_materials_ = 0;
while (ParseMaterialFileDefinition(error))
;
while (ParseMaterialFileDefinition(error)) {
}
// Restore the original buffer.
buffer_ = old_buffer;

3
src/draco/tools/draco_encoder.cc
View File

@ -49,7 +49,8 @@ Options::Options()
normals_deleted(false),
generic_quantization_bits(8),
generic_deleted(false),
compression_level(7) {}
compression_level(7),
use_metadata(false) {}
void Usage() {
printf("Usage: draco_encoder [options] -i input\n");