Blender V5.3
draco_bridge/intern/encoder.cpp
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2026 Blender Authors
2 *
3 * SPDX-License-Identifier: Apache-2.0 */
4
9
10#include "encoder.h"
11
12#include <memory>
13#include <vector>
14
15#include "draco/compression/encode.h"
16#include "draco/core/encoder_buffer.h"
17#include "draco/mesh/mesh.h"
18
19#define LOG_PREFIX "DracoEncoder | "
20
21struct Encoder {
22 draco::Mesh mesh;
25 std::vector<std::unique_ptr<draco::DataBuffer>> buffers;
26 draco::EncoderBuffer encoderBuffer;
27 uint32_t compressionLevel = 7;
28 size_t rawSize = 0;
29 struct {
30 uint32_t position = 14;
31 uint32_t normal = 10;
32 uint32_t uv = 12;
33 uint32_t color = 10;
34 uint32_t generic = 12;
36};
37
38Encoder *encoderCreate(uint32_t vertexCount)
39{
40 Encoder *encoder = new Encoder;
41 encoder->mesh.set_num_points(vertexCount);
42 return encoder;
43}
44
45void encoderRelease(Encoder *encoder)
46{
47 delete encoder;
48}
49
50void encoderSetCompressionLevel(Encoder *encoder, uint32_t compressionLevel)
51{
52 encoder->compressionLevel = compressionLevel;
53}
54
56 uint32_t position,
57 uint32_t normal,
58 uint32_t uv,
59 uint32_t color,
60 uint32_t generic)
61{
62 encoder->quantization.position = position;
63 encoder->quantization.normal = normal;
64 encoder->quantization.uv = uv;
65 encoder->quantization.color = color;
66 encoder->quantization.generic = generic;
67}
68
69bool encoderEncode(Encoder *encoder, uint8_t preserveTriangleOrder)
70{
71 printf(LOG_PREFIX "Preserve triangle order: %s\n", preserveTriangleOrder ? "yes" : "no");
72
73 draco::Encoder dracoEncoder;
74
75 int speed = 10 - static_cast<int>(encoder->compressionLevel);
76 dracoEncoder.SetSpeedOptions(speed, speed);
77
78 dracoEncoder.SetAttributeQuantization(draco::GeometryAttribute::POSITION,
79 encoder->quantization.position);
80 dracoEncoder.SetAttributeQuantization(draco::GeometryAttribute::NORMAL,
81 encoder->quantization.normal);
82 dracoEncoder.SetAttributeQuantization(draco::GeometryAttribute::TEX_COORD,
83 encoder->quantization.uv);
84 dracoEncoder.SetAttributeQuantization(draco::GeometryAttribute::COLOR,
85 encoder->quantization.color);
86 dracoEncoder.SetAttributeQuantization(draco::GeometryAttribute::GENERIC,
87 encoder->quantization.generic);
88 dracoEncoder.SetTrackEncodedProperties(true);
89
90 if (preserveTriangleOrder) {
91 dracoEncoder.SetEncodingMethod(draco::MESH_SEQUENTIAL_ENCODING);
92 }
93
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);
98 size_t encodedSize = encoder->encoderBuffer.size();
99 float compressionRatio = static_cast<float>(encoder->rawSize) /
100 static_cast<float>(encodedSize);
101 printf(LOG_PREFIX "Encoded %" PRIu32 " vertices, %" PRIu32
102 " indices, raw size: %zu, encoded size: %zu, compression ratio: %.2f\n",
103 encoder->encodedVertices,
104 encoder->encodedIndices,
105 encoder->rawSize,
106 encodedSize,
107 compressionRatio);
108 return true;
109 }
110 else {
111 printf(LOG_PREFIX "Error during Draco encoding: %s\n", encoderStatus.error_msg());
112 return false;
113 }
114}
115
117{
118 return encoder->encodedVertices;
119}
120
122{
123 return encoder->encodedIndices;
124}
125
127{
128 return encoder->encoderBuffer.size();
129}
130
131void encoderCopy(Encoder *encoder, uint8_t *data)
132{
133 memcpy(data, encoder->encoderBuffer.data(), encoder->encoderBuffer.size());
134}
135
136template<class T> void encodeIndices(Encoder *encoder, uint32_t indexCount, T *indices)
137{
138 int face_count = indexCount / 3;
139 encoder->mesh.SetNumFaces(static_cast<size_t>(face_count));
140 encoder->rawSize += indexCount * sizeof(T);
141
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);
147 }
148}
149
151 size_t indexComponentType,
152 uint32_t indexCount,
153 void *indices)
154{
155 switch (indexComponentType) {
157 encodeIndices(encoder, indexCount, reinterpret_cast<int8_t *>(indices));
158 break;
160 encodeIndices(encoder, indexCount, reinterpret_cast<uint8_t *>(indices));
161 break;
163 encodeIndices(encoder, indexCount, reinterpret_cast<int16_t *>(indices));
164 break;
166 encodeIndices(encoder, indexCount, reinterpret_cast<uint16_t *>(indices));
167 break;
169 encodeIndices(encoder, indexCount, reinterpret_cast<uint32_t *>(indices));
170 break;
171 default:
172 printf(LOG_PREFIX "Index component type %zu not supported\n", indexComponentType);
173 }
174}
175
176static draco::GeometryAttribute::Type getAttributeSemantics(char *attribute)
177{
178 if (!strcmp(attribute, "POSITION")) {
179 return draco::GeometryAttribute::POSITION;
180 }
181 if (!strcmp(attribute, "NORMAL")) {
182 return draco::GeometryAttribute::NORMAL;
183 }
184 if (!strncmp(attribute, "TEXCOORD", strlen("TEXCOORD"))) {
185 return draco::GeometryAttribute::TEX_COORD;
186 }
187 if (!strncmp(attribute, "COLOR", strlen("COLOR"))) {
188 return draco::GeometryAttribute::COLOR;
189 }
190
191 return draco::GeometryAttribute::GENERIC;
192}
193
194static draco::DataType getDataType(size_t componentType)
195{
196 switch (componentType) {
198 return draco::DataType::DT_INT8;
199
201 return draco::DataType::DT_UINT8;
202
204 return draco::DataType::DT_INT16;
205
207 return draco::DataType::DT_UINT16;
208
210 return draco::DataType::DT_UINT32;
211
213 return draco::DataType::DT_FLOAT32;
214
215 default:
216 return draco::DataType::DT_INVALID;
217 }
218}
219
220API(uint32_t)
222 char *attributeName,
223 size_t componentType,
224 char *dataType,
225 void *data,
226 bool normalized)
227{
228 auto buffer = std::make_unique<draco::DataBuffer>();
229 uint32_t count = encoder->mesh.num_points();
230 size_t componentCount = getNumberOfComponents(dataType);
231 size_t stride = getAttributeStride(componentType, dataType);
232
233 draco::GeometryAttribute::Type semantics = getAttributeSemantics(attributeName);
234 draco::GeometryAttribute attribute;
235 attribute.Init(
236 semantics, &*buffer, componentCount, getDataType(componentType), normalized, stride, 0);
237
238 auto id = static_cast<uint32_t>(encoder->mesh.AddAttribute(attribute, true, count));
239 auto dataBytes = reinterpret_cast<uint8_t *>(data);
240
241 for (uint32_t i = 0; i < count; i++) {
242 encoder->mesh.attribute(id)->SetAttributeValue(draco::AttributeValueIndex(i),
243 dataBytes + i * stride);
244 }
245
246 encoder->buffers.emplace_back(std::move(buffer));
247 encoder->rawSize += count * stride;
248 return id;
249}
unsigned long long int uint64_t
#define printf
size_t getAttributeStride(size_t componentType, char *dataType)
size_t getNumberOfComponents(char *dataType)
#define API(returnType)
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)
#define position
#define attribute(slot)
#define PRIu32
Definition inttypes.h:119
ccl_device_inline Quaternion normalized(const Quaternion q)
#define T
struct Encoder::@146213254337362273361267346001315320117046016215 quantization
draco::EncoderBuffer encoderBuffer
std::vector< std::unique_ptr< draco::DataBuffer > > buffers