GitHub-Proxy/draco
1
0
Fork 0
mirror of https://git.mirrors.martin98.com/https://github.com/google/draco synced 2025-08-12 02:48:58 +08:00
Code Issues Packages Projects Releases Wiki Activity

added maya plugin config for cmake and sources

Browse Source
This commit is contained in:
Federico De Felici 2018-05-11 09:11:23 +02:00
parent 510a181005
commit e06d8f217f
3 changed files with 386 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

53
CMakeLists.txt
View File

@ -42,6 +42,7 @@ option(ENABLE_WEXTRA "" OFF)
option(IGNORE_EMPTY_BUILD_TYPE "" OFF)
option(BUILD_UNITY_PLUGIN "Build plugin library for Unity" OFF)
option(BUILD_FOR_GLTF "" OFF)
option(BUILD_MAYA_PLUGIN "Build plugin library for Maya" OFF)
if (BUILD_FOR_GLTF)
# Override settings when building for GLTF.
@ -108,6 +109,10 @@ if (BUILD_UNITY_PLUGIN)
set(BUILD_SHARED_LIBS ON CACHE BOOL "Build shared library for unity plugin.")
draco_enable_feature(FEATURE "BUILD_UNITY_PLUGIN")
endif ()
if (BUILD_MAYA_PLUGIN)
set(BUILD_SHARED_LIBS ON CACHE BOOL "Build shared library for maya plugin.")
draco_enable_feature(FEATURE "BUILD_MAYA_PLUGIN")
endif ()
if(ENABLE_EXTRA_SPEED)
if(MSVC)
@ -588,7 +593,13 @@ set(draco_unity_plug_sources
"${draco_src_root}/unity/draco_unity_plugin.cc"
"${draco_src_root}/unity/draco_unity_plugin.h")
include_directories("${draco_root}/src" "${draco_build_dir}")
set(draco_maya_plug_sources
"${draco_src_root}/maya/draco_maya_plugin.cc"
"${draco_src_root}/maya/draco_maya_plugin.h")
include_directories("${draco_root}/src" "${draco_build_dir}")
#
# Draco targets.
@ -784,7 +795,11 @@ else ()
${draco_points_enc_sources})
add_library(draco_unity_plugin OBJECT
${draco_unity_plug_sources})
add_library(draco_maya_plugin OBJECT
${draco_maya_plug_sources})
# Library targets that consume the object collections.
add_library(dracodec
${draco_version_sources}
@ -867,6 +882,34 @@ else ()
set_target_properties(dracodec_unity PROPERTIES BUNDLE true)
endif ()
endif ()
if (BUILD_MAYA_PLUGIN)
add_library(dracodec_maya
MODULE
${draco_version_sources}
$<TARGET_OBJECTS:draco_maya_plugin>
$<TARGET_OBJECTS:draco_attributes>
$<TARGET_OBJECTS:draco_compression_attributes_dec>
$<TARGET_OBJECTS:draco_compression_decode>
$<TARGET_OBJECTS:draco_compression_mesh_dec>
$<TARGET_OBJECTS:draco_compression_point_cloud_dec>
$<TARGET_OBJECTS:draco_core>
$<TARGET_OBJECTS:draco_core_bit_coders>
$<TARGET_OBJECTS:draco_dec_config>
$<TARGET_OBJECTS:draco_io>
$<TARGET_OBJECTS:draco_mesh>
$<TARGET_OBJECTS:draco_metadata>
$<TARGET_OBJECTS:draco_metadata_dec>
$<TARGET_OBJECTS:draco_point_cloud>
$<TARGET_OBJECTS:draco_points_dec>)
# For Mac, we need to build a .bundle for plugin.
if (APPLE)
set_target_properties(dracodec_maya PROPERTIES BUNDLE true)
endif ()
endif ()
set(draco_header_only_targets
draco_compression_attributes_pred_schemes_dec
draco_dec_config
@ -883,6 +926,9 @@ else ()
set_target_properties(draco PROPERTIES SOVERSION 1)
if (BUILD_UNITY_PLUGIN)
set_target_properties(dracodec_unity PROPERTIES SOVERSION 1)
endif ()
if (BUILD_MAYA_PLUGIN)
set_target_properties(dracodec_maya PROPERTIES SOVERSION 1)
endif ()
endif ()
@ -945,6 +991,11 @@ else ()
install(TARGETS dracodec_unity
DESTINATION "${CMAKE_INSTALL_PREFIX}/lib")
endif ()
if (BUILD_MAYA_PLUGIN)
install(TARGETS dracodec_maya
DESTINATION "${CMAKE_INSTALL_PREFIX}/lib")
endif ()
install(TARGETS draco_decoder draco_encoder DESTINATION
"${CMAKE_INSTALL_PREFIX}/bin")

232
src/draco/maya/draco_maya_plugin.cc Normal file
View File

@ -0,0 +1,232 @@
// Copyright 2017 The Draco Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
#include "draco/maya/draco_maya_plugin.h"
#ifdef BUILD_MAYA_PLUGIN
namespace draco {
namespace maya {
static void decode_faces(std::unique_ptr<draco::Mesh> &drc_mesh, Drc2PyMesh* out_mesh) {
int num_faces = drc_mesh->num_faces();
out_mesh->faces = new int[num_faces*3];
out_mesh->faces_num = num_faces;
for (int i = 0; i < num_faces; i++) {
const draco::Mesh::Face &face = drc_mesh->face(draco::FaceIndex(i));
out_mesh->faces[i * 3 + 0] = face[0].value();
out_mesh->faces[i * 3 + 1] = face[1].value();
out_mesh->faces[i * 3 + 2] = face[2].value();
}
}
static void decode_vertices(std::unique_ptr<draco::Mesh> &drc_mesh, Drc2PyMesh* out_mesh) {
int num_vertices = drc_mesh->num_points();
out_mesh->vertices = new float[num_vertices * 3];
out_mesh->vertices_num = num_vertices;
const auto pos_att = drc_mesh->GetNamedAttribute(draco::GeometryAttribute::POSITION);
for (int i = 0; i < num_vertices; i++) {
draco::PointIndex pi(i);
const draco::AttributeValueIndex val_index = pos_att->mapped_index(pi);
float out_vertex[3];
bool is_ok = pos_att->ConvertValue<float, 3>(val_index, out_vertex);
if (!is_ok) return;
out_mesh->vertices[i * 3 + 0] = out_vertex[0];
out_mesh->vertices[i * 3 + 1] = out_vertex[1];
out_mesh->vertices[i * 3 + 2] = out_vertex[2];
}
}
int hello() {
return 20;
}
void fill_int(int *num) {
*num = 1982;
}
MyStruct* fill_mystruct() {
MyStruct* my = new MyStruct();
my->num_faces = 500;
return my;
}
void fill_mystruct2(MyStruct** my) {
*my = new MyStruct();
(*my)->num_faces = 900;
}
void ReleaseMayaMesh(DracoToMayaMesh **mesh_ptr) {
DracoToMayaMesh *mesh = *mesh_ptr;
if (!mesh)
return;
if (mesh->indices) {
delete[] mesh->indices;
mesh->indices = nullptr;
}
if (mesh->position) {
delete[] mesh->position;
mesh->position = nullptr;
}
if (mesh->has_normal && mesh->normal) {
delete[] mesh->normal;
mesh->has_normal = false;
mesh->normal = nullptr;
}
if (mesh->has_texcoord && mesh->texcoord) {
delete[] mesh->texcoord;
mesh->has_texcoord = false;
mesh->texcoord = nullptr;
}
if (mesh->has_color && mesh->color) {
delete[] mesh->color;
mesh->has_color = false;
mesh->color = nullptr;
}
delete mesh;
*mesh_ptr = nullptr;
}
int drc2py_decode(char *data, unsigned int length, Drc2PyMesh **res_mesh) {
draco::DecoderBuffer buffer;
buffer.Init(data, length);
auto type_statusor = draco::Decoder::GetEncodedGeometryType(&buffer);
if (!type_statusor.ok()) {
// TODO(zhafang): Use enum instead.
return -1;
}
const draco::EncodedGeometryType geom_type = type_statusor.value();
if (geom_type != draco::TRIANGULAR_MESH) {
return -2;
}
draco::Decoder decoder;
auto statusor = decoder.DecodeMeshFromBuffer(&buffer);
if (!statusor.ok()) {
return -3;
}
std::unique_ptr<draco::Mesh> drc_mesh = std::move(statusor).value();
*res_mesh = new Drc2PyMesh();
//(*res_mesh)->faces_num = drc_mesh->num_faces();
//(*res_mesh)->vertices_num = drc_mesh->num_points();
decode_faces(drc_mesh, *res_mesh);
decode_vertices(drc_mesh, *res_mesh);
return 0;
}
int DecodeMeshForMaya(char *data, unsigned int length, DracoToMayaMesh **tmp_mesh) {
draco::DecoderBuffer buffer;
buffer.Init(data, length);
auto type_statusor = draco::Decoder::GetEncodedGeometryType(&buffer);
if (!type_statusor.ok()) {
// TODO(zhafang): Use enum instead.
return -1;
}
const draco::EncodedGeometryType geom_type = type_statusor.value();
if (geom_type != draco::TRIANGULAR_MESH) {
return -2;
}
draco::Decoder decoder;
auto statusor = decoder.DecodeMeshFromBuffer(&buffer);
if (!statusor.ok()) {
return -3;
}
std::unique_ptr<draco::Mesh> in_mesh = std::move(statusor).value();
*tmp_mesh = new DracoToMayaMesh();
DracoToMayaMesh *unity_mesh = *tmp_mesh;
unity_mesh->num_faces = in_mesh->num_faces();
unity_mesh->num_vertices = in_mesh->num_points();
unity_mesh->indices = new int[in_mesh->num_faces() * 3];
for (draco::FaceIndex face_id(0); face_id < in_mesh->num_faces(); ++face_id) {
const Mesh::Face &face = in_mesh->face(draco::FaceIndex(face_id));
memcpy(unity_mesh->indices + face_id.value() * 3,
reinterpret_cast<const int *>(face.data()), sizeof(int) * 3);
}
// TODO(zhafang): Add other attributes.
unity_mesh->position = new float[in_mesh->num_points() * 3];
const auto pos_att =
in_mesh->GetNamedAttribute(draco::GeometryAttribute::POSITION);
for (draco::PointIndex i(0); i < in_mesh->num_points(); ++i) {
const draco::AttributeValueIndex val_index = pos_att->mapped_index(i);
if (!pos_att->ConvertValue<float, 3>(
val_index, unity_mesh->position + i.value() * 3)) {
ReleaseMayaMesh(&unity_mesh);
return -8;
}
}
// Get normal attributes.
const auto normal_att =
in_mesh->GetNamedAttribute(draco::GeometryAttribute::NORMAL);
if (normal_att != nullptr) {
unity_mesh->normal = new float[in_mesh->num_points() * 3];
unity_mesh->has_normal = true;
for (draco::PointIndex i(0); i < in_mesh->num_points(); ++i) {
const draco::AttributeValueIndex val_index = normal_att->mapped_index(i);
if (!normal_att->ConvertValue<float, 3>(
val_index, unity_mesh->normal + i.value() * 3)) {
ReleaseMayaMesh(&unity_mesh);
return -8;
}
}
}
// Get color attributes.
const auto color_att =
in_mesh->GetNamedAttribute(draco::GeometryAttribute::COLOR);
if (color_att != nullptr) {
unity_mesh->color = new float[in_mesh->num_points() * 3];
unity_mesh->has_color = true;
for (draco::PointIndex i(0); i < in_mesh->num_points(); ++i) {
const draco::AttributeValueIndex val_index = color_att->mapped_index(i);
if (!color_att->ConvertValue<float, 3>(
val_index, unity_mesh->color + i.value() * 3)) {
ReleaseMayaMesh(&unity_mesh);
return -8;
}
}
}
// Get texture coordinates attributes.
const auto texcoord_att =
in_mesh->GetNamedAttribute(draco::GeometryAttribute::TEX_COORD);
if (texcoord_att != nullptr) {
unity_mesh->texcoord = new float[in_mesh->num_points() * 2];
unity_mesh->has_texcoord = true;
for (draco::PointIndex i(0); i < in_mesh->num_points(); ++i) {
const draco::AttributeValueIndex val_index =
texcoord_att->mapped_index(i);
if (!texcoord_att->ConvertValue<float, 3>(
val_index, unity_mesh->texcoord + i.value() * 3)) {
ReleaseMayaMesh(&unity_mesh);
return -8;
}
}
}
return in_mesh->num_faces();
}
} // namespace maya
} // namespace draco
#endif // BUILD_MAYA_PLUGIN

102
src/draco/maya/draco_maya_plugin.h Normal file
View File

@ -0,0 +1,102 @@
// Copyright 2017 The Draco Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
#ifndef DRACO_MAYA_PLUGIN_H_
#define DRACO_MAYA_PLUGIN_H_
#include "draco/compression/config/compression_shared.h"
#include "draco/compression/decode.h"
#ifdef BUILD_MAYA_PLUGIN
// If compiling with Visual Studio.
#if defined(_MSC_VER)
#define EXPORT_API __declspec(dllexport)
#else
// Other platforms don't need this.
#define EXPORT_API
#endif // defined(_MSC_VER)
namespace draco {
namespace maya {
extern "C" {
struct EXPORT_API DracoToMayaMesh {
DracoToMayaMesh()
: num_faces(0),
indices(nullptr),
num_vertices(0),
position(nullptr),
has_normal(false),
normal(nullptr),
has_texcoord(false),
texcoord(nullptr),
has_color(false),
color(nullptr) {}
int num_faces;
int *indices;
int num_vertices;
float *position;
bool has_normal;
float *normal;
bool has_texcoord;
float *texcoord;
bool has_color;
float *color;
};
void ReleaseMayaMesh(DracoToMayaMesh **mesh_ptr);
/* To use this function, you do not allocate memory for |tmp_mesh|, just
* define and pass a null pointer. Otherwise there will be memory leak.
*/
int EXPORT_API DecodeMeshForMaya(char *data, unsigned int length, DracoToMayaMesh **tmp_mesh);
struct EXPORT_API Drc2PyMesh {
Drc2PyMesh()
: faces_num(0),
vertices_num(0) {}
int faces_num;
int* faces;
int vertices_num;
float* vertices;
};
EXPORT_API int drc2py_decode(char *data, unsigned int length, Drc2PyMesh **res_mesh);
struct EXPORT_API MyStruct {
MyStruct()
: num_faces(0) {}
//indices(nullptr) {}
int num_faces;
//int *indices;
};
int EXPORT_API hello();
void EXPORT_API fill_int(int *num);
EXPORT_API MyStruct* fill_mystruct();
EXPORT_API void fill_mystruct2(MyStruct** my);
} // extern "C"
} // namespace maya
} // namespace draco
#endif // BUILD_MAYA_PLUGIN
#endif // DRACO_MAYA_PLUGIN_H_