15#include "draco/compression/encode.h"
16#include "draco/core/encoder_buffer.h"
17#include "draco/mesh/mesh.h"
19#define LOG_PREFIX "DracoEncoder | "
25 std::vector<std::unique_ptr<draco::DataBuffer>>
buffers;
34 uint32_t
generic = 12;
41 encoder->
mesh.set_num_points(vertexCount);
71 printf(
LOG_PREFIX "Preserve triangle order: %s\n", preserveTriangleOrder ?
"yes" :
"no");
73 draco::Encoder dracoEncoder;
76 dracoEncoder.SetSpeedOptions(speed, speed);
78 dracoEncoder.SetAttributeQuantization(draco::GeometryAttribute::POSITION,
80 dracoEncoder.SetAttributeQuantization(draco::GeometryAttribute::NORMAL,
82 dracoEncoder.SetAttributeQuantization(draco::GeometryAttribute::TEX_COORD,
84 dracoEncoder.SetAttributeQuantization(draco::GeometryAttribute::COLOR,
86 dracoEncoder.SetAttributeQuantization(draco::GeometryAttribute::GENERIC,
88 dracoEncoder.SetTrackEncodedProperties(
true);
90 if (preserveTriangleOrder) {
91 dracoEncoder.SetEncodingMethod(draco::MESH_SEQUENTIAL_ENCODING);
94 auto encoderStatus = dracoEncoder.EncodeMeshToBuffer(encoder->
mesh, &encoder->
encoderBuffer);
95 if (encoderStatus.ok()) {
96 encoder->
encodedVertices =
static_cast<uint32_t
>(dracoEncoder.num_encoded_points());
97 encoder->
encodedIndices =
static_cast<uint32_t
>(dracoEncoder.num_encoded_faces() * 3);
99 float compressionRatio =
static_cast<float>(encoder->
rawSize) /
100 static_cast<float>(encodedSize);
102 " indices, raw size: %zu, encoded size: %zu, compression ratio: %.2f\n",
111 printf(
LOG_PREFIX "Error during Draco encoding: %s\n", encoderStatus.error_msg());
138 int face_count = indexCount / 3;
139 encoder->
mesh.SetNumFaces(
static_cast<size_t>(face_count));
140 encoder->
rawSize += indexCount *
sizeof(
T);
142 for (
int i = 0; i < face_count; ++i) {
143 draco::Mesh::Face face = {draco::PointIndex(indices[3 * i + 0]),
144 draco::PointIndex(indices[3 * i + 1]),
145 draco::PointIndex(indices[3 * i + 2])};
146 encoder->
mesh.SetFace(draco::FaceIndex(
static_cast<uint32_t
>(i)), face);
151 size_t indexComponentType,
155 switch (indexComponentType) {
157 encodeIndices(encoder, indexCount,
reinterpret_cast<int8_t *
>(indices));
160 encodeIndices(encoder, indexCount,
reinterpret_cast<uint8_t *
>(indices));
163 encodeIndices(encoder, indexCount,
reinterpret_cast<int16_t *
>(indices));
166 encodeIndices(encoder, indexCount,
reinterpret_cast<uint16_t *
>(indices));
169 encodeIndices(encoder, indexCount,
reinterpret_cast<uint32_t *
>(indices));
172 printf(
LOG_PREFIX "Index component type %zu not supported\n", indexComponentType);
179 return draco::GeometryAttribute::POSITION;
182 return draco::GeometryAttribute::NORMAL;
184 if (!strncmp(
attribute,
"TEXCOORD", strlen(
"TEXCOORD"))) {
185 return draco::GeometryAttribute::TEX_COORD;
187 if (!strncmp(
attribute,
"COLOR", strlen(
"COLOR"))) {
188 return draco::GeometryAttribute::COLOR;
191 return draco::GeometryAttribute::GENERIC;
196 switch (componentType) {
198 return draco::DataType::DT_INT8;
201 return draco::DataType::DT_UINT8;
204 return draco::DataType::DT_INT16;
207 return draco::DataType::DT_UINT16;
210 return draco::DataType::DT_UINT32;
213 return draco::DataType::DT_FLOAT32;
216 return draco::DataType::DT_INVALID;
223 size_t componentType,
228 auto buffer = std::make_unique<draco::DataBuffer>();
229 uint32_t count = encoder->mesh.num_points();
238 auto id =
static_cast<uint32_t
>(encoder->mesh.AddAttribute(
attribute,
true, count));
239 auto dataBytes =
reinterpret_cast<uint8_t *
>(data);
241 for (uint32_t i = 0; i < count; i++) {
242 encoder->mesh.attribute(
id)->SetAttributeValue(draco::AttributeValueIndex(i),
243 dataBytes + i * stride);
246 encoder->buffers.emplace_back(std::move(buffer));
247 encoder->rawSize += count * stride;
unsigned long long int uint64_t
size_t getAttributeStride(size_t componentType, char *dataType)
size_t getNumberOfComponents(char *dataType)
uint32_t encoderGetEncodedVertexCount(Encoder *encoder)
void encoderSetIndices(Encoder *encoder, size_t indexComponentType, uint32_t indexCount, void *indices)
encoderSetAttribute(Encoder *encoder, char *attributeName, size_t componentType, char *dataType, void *data, bool normalized)
void encoderSetCompressionLevel(Encoder *encoder, uint32_t compressionLevel)
void encoderCopy(Encoder *encoder, uint8_t *data)
static draco::GeometryAttribute::Type getAttributeSemantics(char *attribute)
void encoderRelease(Encoder *encoder)
Encoder * encoderCreate(uint32_t vertexCount)
uint64_t encoderGetByteLength(Encoder *encoder)
void encoderSetQuantizationBits(Encoder *encoder, uint32_t position, uint32_t normal, uint32_t uv, uint32_t color, uint32_t generic)
void encodeIndices(Encoder *encoder, uint32_t indexCount, T *indices)
static draco::DataType getDataType(size_t componentType)
bool encoderEncode(Encoder *encoder, uint8_t preserveTriangleOrder)
uint32_t encoderGetEncodedIndexCount(Encoder *encoder)
ccl_device_inline Quaternion normalized(const Quaternion q)
uint32_t compressionLevel
struct Encoder::@146213254337362273361267346001315320117046016215 quantization
draco::EncoderBuffer encoderBuffer
std::vector< std::unique_ptr< draco::DataBuffer > > buffers