717 lines
22 KiB
C++
717 lines
22 KiB
C++
/*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*/
|
|
|
|
/** \file
|
|
* \ingroup collada
|
|
*/
|
|
|
|
#include <sstream>
|
|
|
|
#include "COLLADABUUtils.h"
|
|
#include "COLLADASWPrimitves.h"
|
|
#include "COLLADASWSource.h"
|
|
#include "COLLADASWVertices.h"
|
|
|
|
#include "GeometryExporter.h"
|
|
|
|
#include "DNA_meshdata_types.h"
|
|
|
|
#include "BLI_utildefines.h"
|
|
|
|
#include "BKE_customdata.h"
|
|
#include "BKE_global.h"
|
|
#include "BKE_lib_id.h"
|
|
#include "BKE_material.h"
|
|
#include "BKE_mesh.h"
|
|
|
|
#include "collada_internal.h"
|
|
#include "collada_utils.h"
|
|
|
|
void GeometryExporter::exportGeom()
|
|
{
|
|
Scene *sce = blender_context.get_scene();
|
|
openLibrary();
|
|
|
|
GeometryFunctor gf;
|
|
gf.forEachMeshObjectInExportSet<GeometryExporter>(
|
|
sce, *this, this->export_settings.get_export_set());
|
|
|
|
closeLibrary();
|
|
}
|
|
|
|
void GeometryExporter::operator()(Object *ob)
|
|
{
|
|
bool use_instantiation = this->export_settings.get_use_object_instantiation();
|
|
Mesh *me = bc_get_mesh_copy(blender_context,
|
|
ob,
|
|
this->export_settings.get_export_mesh_type(),
|
|
this->export_settings.get_apply_modifiers(),
|
|
this->export_settings.get_triangulate());
|
|
|
|
std::string geom_id = get_geometry_id(ob, use_instantiation);
|
|
std::vector<Normal> nor;
|
|
std::vector<BCPolygonNormalsIndices> norind;
|
|
|
|
/* Skip if linked geometry was already exported from another reference */
|
|
if (use_instantiation && exportedGeometry.find(geom_id) != exportedGeometry.end()) {
|
|
return;
|
|
}
|
|
|
|
std::string geom_name = (use_instantiation) ? id_name(ob->data) : id_name(ob);
|
|
geom_name = encode_xml(geom_name);
|
|
|
|
exportedGeometry.insert(geom_id);
|
|
|
|
bool has_color = (bool)CustomData_has_layer(&me->fdata, CD_MCOL);
|
|
|
|
create_normals(nor, norind, me);
|
|
|
|
/* openMesh(geoId, geoName, meshId) */
|
|
openMesh(geom_id, geom_name);
|
|
|
|
/* writes <source> for vertex coords */
|
|
createVertsSource(geom_id, me);
|
|
|
|
/* writes <source> for normal coords */
|
|
createNormalsSource(geom_id, me, nor);
|
|
|
|
bool has_uvs = (bool)CustomData_has_layer(&me->ldata, CD_MLOOPUV);
|
|
|
|
/* writes <source> for uv coords if mesh has uv coords */
|
|
if (has_uvs) {
|
|
createTexcoordsSource(geom_id, me);
|
|
}
|
|
|
|
if (has_color) {
|
|
createVertexColorSource(geom_id, me);
|
|
}
|
|
/* <vertices> */
|
|
|
|
COLLADASW::Vertices verts(mSW);
|
|
verts.setId(getIdBySemantics(geom_id, COLLADASW::InputSemantic::VERTEX));
|
|
COLLADASW::InputList &input_list = verts.getInputList();
|
|
COLLADASW::Input input(COLLADASW::InputSemantic::POSITION,
|
|
getUrlBySemantics(geom_id, COLLADASW::InputSemantic::POSITION));
|
|
input_list.push_back(input);
|
|
verts.add();
|
|
|
|
createLooseEdgeList(ob, me, geom_id);
|
|
|
|
/* Only create Polylists if number of faces > 0 */
|
|
if (me->totface > 0) {
|
|
/* XXX slow */
|
|
if (ob->totcol) {
|
|
for (int a = 0; a < ob->totcol; a++) {
|
|
create_mesh_primitive_list(a, has_uvs, has_color, ob, me, geom_id, norind);
|
|
}
|
|
}
|
|
else {
|
|
create_mesh_primitive_list(0, has_uvs, has_color, ob, me, geom_id, norind);
|
|
}
|
|
}
|
|
|
|
closeMesh();
|
|
|
|
closeGeometry();
|
|
|
|
if (this->export_settings.get_include_shapekeys()) {
|
|
Key *key = BKE_key_from_object(ob);
|
|
if (key) {
|
|
KeyBlock *kb = (KeyBlock *)key->block.first;
|
|
/* skip the basis */
|
|
kb = kb->next;
|
|
for (; kb; kb = kb->next) {
|
|
BKE_keyblock_convert_to_mesh(kb, me);
|
|
export_key_mesh(ob, me, kb);
|
|
}
|
|
}
|
|
}
|
|
|
|
BKE_id_free(nullptr, me);
|
|
}
|
|
|
|
void GeometryExporter::export_key_mesh(Object *ob, Mesh *me, KeyBlock *kb)
|
|
{
|
|
std::string geom_id = get_geometry_id(ob, false) + "_morph_" + translate_id(kb->name);
|
|
std::vector<Normal> nor;
|
|
std::vector<BCPolygonNormalsIndices> norind;
|
|
|
|
if (exportedGeometry.find(geom_id) != exportedGeometry.end()) {
|
|
return;
|
|
}
|
|
|
|
std::string geom_name = kb->name;
|
|
|
|
exportedGeometry.insert(geom_id);
|
|
|
|
bool has_color = (bool)CustomData_has_layer(&me->fdata, CD_MCOL);
|
|
|
|
create_normals(nor, norind, me);
|
|
|
|
// openMesh(geoId, geoName, meshId)
|
|
openMesh(geom_id, geom_name);
|
|
|
|
/* writes <source> for vertex coords */
|
|
createVertsSource(geom_id, me);
|
|
|
|
/* writes <source> for normal coords */
|
|
createNormalsSource(geom_id, me, nor);
|
|
|
|
bool has_uvs = (bool)CustomData_has_layer(&me->ldata, CD_MLOOPUV);
|
|
|
|
/* writes <source> for uv coords if mesh has uv coords */
|
|
if (has_uvs) {
|
|
createTexcoordsSource(geom_id, me);
|
|
}
|
|
|
|
if (has_color) {
|
|
createVertexColorSource(geom_id, me);
|
|
}
|
|
|
|
/* <vertices> */
|
|
|
|
COLLADASW::Vertices verts(mSW);
|
|
verts.setId(getIdBySemantics(geom_id, COLLADASW::InputSemantic::VERTEX));
|
|
COLLADASW::InputList &input_list = verts.getInputList();
|
|
COLLADASW::Input input(COLLADASW::InputSemantic::POSITION,
|
|
getUrlBySemantics(geom_id, COLLADASW::InputSemantic::POSITION));
|
|
input_list.push_back(input);
|
|
verts.add();
|
|
|
|
// createLooseEdgeList(ob, me, geom_id, norind);
|
|
|
|
/* XXX slow */
|
|
if (ob->totcol) {
|
|
for (int a = 0; a < ob->totcol; a++) {
|
|
create_mesh_primitive_list(a, has_uvs, has_color, ob, me, geom_id, norind);
|
|
}
|
|
}
|
|
else {
|
|
create_mesh_primitive_list(0, has_uvs, has_color, ob, me, geom_id, norind);
|
|
}
|
|
|
|
closeMesh();
|
|
|
|
closeGeometry();
|
|
}
|
|
|
|
void GeometryExporter::createLooseEdgeList(Object *ob, Mesh *me, std::string &geom_id)
|
|
{
|
|
|
|
MEdge *medges = me->medge;
|
|
int totedges = me->totedge;
|
|
int edges_in_linelist = 0;
|
|
std::vector<unsigned int> edge_list;
|
|
int index;
|
|
|
|
/* Find all loose edges in Mesh
|
|
* and save vertex indices in edge_list */
|
|
for (index = 0; index < totedges; index++) {
|
|
MEdge *edge = &medges[index];
|
|
|
|
if (edge->flag & ME_LOOSEEDGE) {
|
|
edges_in_linelist += 1;
|
|
edge_list.push_back(edge->v1);
|
|
edge_list.push_back(edge->v2);
|
|
}
|
|
}
|
|
|
|
if (edges_in_linelist > 0) {
|
|
/* Create the list of loose edges */
|
|
COLLADASW::Lines lines(mSW);
|
|
|
|
lines.setCount(edges_in_linelist);
|
|
|
|
COLLADASW::InputList &til = lines.getInputList();
|
|
|
|
/* creates <input> in <lines> for vertices */
|
|
COLLADASW::Input input1(COLLADASW::InputSemantic::VERTEX,
|
|
getUrlBySemantics(geom_id, COLLADASW::InputSemantic::VERTEX),
|
|
0);
|
|
til.push_back(input1);
|
|
|
|
lines.prepareToAppendValues();
|
|
|
|
for (index = 0; index < edges_in_linelist; index++) {
|
|
lines.appendValues(edge_list[2 * index + 1]);
|
|
lines.appendValues(edge_list[2 * index]);
|
|
}
|
|
lines.finish();
|
|
}
|
|
}
|
|
|
|
static void prepareToAppendValues(bool is_triangulated,
|
|
COLLADASW::PrimitivesBase &primitive_list,
|
|
std::vector<unsigned long> &vcount_list)
|
|
{
|
|
/* performs the actual writing */
|
|
if (is_triangulated) {
|
|
((COLLADASW::Triangles &)primitive_list).prepareToAppendValues();
|
|
}
|
|
else {
|
|
/* sets <vcount> */
|
|
primitive_list.setVCountList(vcount_list);
|
|
((COLLADASW::Polylist &)primitive_list).prepareToAppendValues();
|
|
}
|
|
}
|
|
|
|
static void finish_and_delete_primitive_List(bool is_triangulated,
|
|
COLLADASW::PrimitivesBase *primitive_list)
|
|
{
|
|
if (is_triangulated) {
|
|
((COLLADASW::Triangles *)primitive_list)->finish();
|
|
}
|
|
else {
|
|
((COLLADASW::Polylist *)primitive_list)->finish();
|
|
}
|
|
delete primitive_list;
|
|
}
|
|
|
|
static COLLADASW::PrimitivesBase *create_primitive_list(bool is_triangulated,
|
|
COLLADASW::StreamWriter *mSW)
|
|
{
|
|
COLLADASW::PrimitivesBase *primitive_list;
|
|
|
|
if (is_triangulated) {
|
|
primitive_list = new COLLADASW::Triangles(mSW);
|
|
}
|
|
else {
|
|
primitive_list = new COLLADASW::Polylist(mSW);
|
|
}
|
|
return primitive_list;
|
|
}
|
|
|
|
static bool collect_vertex_counts_per_poly(Mesh *me,
|
|
int material_index,
|
|
std::vector<unsigned long> &vcount_list)
|
|
{
|
|
MPoly *mpolys = me->mpoly;
|
|
int totpolys = me->totpoly;
|
|
bool is_triangulated = true;
|
|
|
|
int i;
|
|
/* Expecting that p->mat_nr is always 0 if the mesh has no materials assigned */
|
|
for (i = 0; i < totpolys; i++) {
|
|
MPoly *p = &mpolys[i];
|
|
if (p->mat_nr == material_index) {
|
|
int vertex_count = p->totloop;
|
|
vcount_list.push_back(vertex_count);
|
|
if (vertex_count != 3) {
|
|
is_triangulated = false;
|
|
}
|
|
}
|
|
}
|
|
return is_triangulated;
|
|
}
|
|
|
|
std::string GeometryExporter::makeVertexColorSourceId(std::string &geom_id, char *layer_name)
|
|
{
|
|
std::string result = getIdBySemantics(geom_id, COLLADASW::InputSemantic::COLOR) + "-" +
|
|
layer_name;
|
|
return result;
|
|
}
|
|
|
|
/* powerful because it handles both cases when there is material and when there's not */
|
|
void GeometryExporter::create_mesh_primitive_list(short material_index,
|
|
bool has_uvs,
|
|
bool has_color,
|
|
Object *ob,
|
|
Mesh *me,
|
|
std::string &geom_id,
|
|
std::vector<BCPolygonNormalsIndices> &norind)
|
|
{
|
|
|
|
MPoly *mpolys = me->mpoly;
|
|
MLoop *mloops = me->mloop;
|
|
int totpolys = me->totpoly;
|
|
|
|
std::vector<unsigned long> vcount_list;
|
|
|
|
bool is_triangulated = collect_vertex_counts_per_poly(me, material_index, vcount_list);
|
|
int polygon_count = vcount_list.size();
|
|
|
|
/* no faces using this material */
|
|
if (polygon_count == 0) {
|
|
fprintf(
|
|
stderr, "%s: material with index %d is not used.\n", id_name(ob).c_str(), material_index);
|
|
return;
|
|
}
|
|
|
|
Material *ma = ob->totcol ? BKE_object_material_get(ob, material_index + 1) : nullptr;
|
|
COLLADASW::PrimitivesBase *primitive_list = create_primitive_list(is_triangulated, mSW);
|
|
|
|
/* sets count attribute in <polylist> */
|
|
primitive_list->setCount(polygon_count);
|
|
|
|
/* sets material name */
|
|
if (ma) {
|
|
std::string material_id = get_material_id(ma);
|
|
std::ostringstream ostr;
|
|
ostr << translate_id(material_id);
|
|
primitive_list->setMaterial(ostr.str());
|
|
}
|
|
|
|
COLLADASW::Input vertex_input(COLLADASW::InputSemantic::VERTEX,
|
|
getUrlBySemantics(geom_id, COLLADASW::InputSemantic::VERTEX),
|
|
0);
|
|
COLLADASW::Input normals_input(COLLADASW::InputSemantic::NORMAL,
|
|
getUrlBySemantics(geom_id, COLLADASW::InputSemantic::NORMAL),
|
|
1);
|
|
|
|
COLLADASW::InputList &til = primitive_list->getInputList();
|
|
til.push_back(vertex_input);
|
|
til.push_back(normals_input);
|
|
|
|
/* if mesh has uv coords writes <input> for TEXCOORD */
|
|
int num_layers = CustomData_number_of_layers(&me->ldata, CD_MLOOPUV);
|
|
int active_uv_index = CustomData_get_active_layer_index(&me->ldata, CD_MLOOPUV);
|
|
for (int i = 0; i < num_layers; i++) {
|
|
int layer_index = CustomData_get_layer_index_n(&me->ldata, CD_MLOOPUV, i);
|
|
if (!this->export_settings.get_active_uv_only() || layer_index == active_uv_index) {
|
|
|
|
// char *name = CustomData_get_layer_name(&me->ldata, CD_MLOOPUV, i);
|
|
COLLADASW::Input texcoord_input(
|
|
COLLADASW::InputSemantic::TEXCOORD,
|
|
makeUrl(makeTexcoordSourceId(geom_id, i, this->export_settings.get_active_uv_only())),
|
|
2, /* this is only until we have optimized UV sets */
|
|
(this->export_settings.get_active_uv_only()) ? 0 : layer_index - 1 /* set (0,1,2,...) */
|
|
);
|
|
til.push_back(texcoord_input);
|
|
}
|
|
}
|
|
|
|
int totlayer_mcol = CustomData_number_of_layers(&me->ldata, CD_MLOOPCOL);
|
|
if (totlayer_mcol > 0) {
|
|
int map_index = 0;
|
|
|
|
for (int a = 0; a < totlayer_mcol; a++) {
|
|
char *layer_name = bc_CustomData_get_layer_name(&me->ldata, CD_MLOOPCOL, a);
|
|
COLLADASW::Input input4(COLLADASW::InputSemantic::COLOR,
|
|
makeUrl(makeVertexColorSourceId(geom_id, layer_name)),
|
|
(has_uvs) ? 3 : 2, /* all color layers have same index order */
|
|
map_index /* set number equals color map index */
|
|
);
|
|
til.push_back(input4);
|
|
map_index++;
|
|
}
|
|
}
|
|
|
|
/* performs the actual writing */
|
|
prepareToAppendValues(is_triangulated, *primitive_list, vcount_list);
|
|
|
|
/* <p> */
|
|
int texindex = 0;
|
|
for (int i = 0; i < totpolys; i++) {
|
|
MPoly *p = &mpolys[i];
|
|
int loop_count = p->totloop;
|
|
|
|
if (p->mat_nr == material_index) {
|
|
MLoop *l = &mloops[p->loopstart];
|
|
BCPolygonNormalsIndices normal_indices = norind[i];
|
|
|
|
for (int j = 0; j < loop_count; j++) {
|
|
primitive_list->appendValues(l[j].v);
|
|
primitive_list->appendValues(normal_indices[j]);
|
|
if (has_uvs) {
|
|
primitive_list->appendValues(texindex + j);
|
|
}
|
|
|
|
if (has_color) {
|
|
primitive_list->appendValues(texindex + j);
|
|
}
|
|
}
|
|
}
|
|
|
|
texindex += loop_count;
|
|
}
|
|
|
|
finish_and_delete_primitive_List(is_triangulated, primitive_list);
|
|
}
|
|
|
|
/* creates <source> for positions */
|
|
void GeometryExporter::createVertsSource(std::string geom_id, Mesh *me)
|
|
{
|
|
#if 0
|
|
int totverts = dm->getNumVerts(dm);
|
|
MVert *verts = dm->getVertArray(dm);
|
|
#endif
|
|
int totverts = me->totvert;
|
|
MVert *verts = me->mvert;
|
|
|
|
COLLADASW::FloatSourceF source(mSW);
|
|
source.setId(getIdBySemantics(geom_id, COLLADASW::InputSemantic::POSITION));
|
|
source.setArrayId(getIdBySemantics(geom_id, COLLADASW::InputSemantic::POSITION) +
|
|
ARRAY_ID_SUFFIX);
|
|
source.setAccessorCount(totverts);
|
|
source.setAccessorStride(3);
|
|
|
|
COLLADASW::SourceBase::ParameterNameList ¶m = source.getParameterNameList();
|
|
param.push_back("X");
|
|
param.push_back("Y");
|
|
param.push_back("Z");
|
|
/* main function, it creates <source id = "">, <float_array id = ""
|
|
* count = ""> */
|
|
source.prepareToAppendValues();
|
|
/* appends data to <float_array> */
|
|
int i = 0;
|
|
for (i = 0; i < totverts; i++) {
|
|
Vector co;
|
|
if (export_settings.get_apply_global_orientation()) {
|
|
bc_add_global_transform(co, verts[i].co, export_settings.get_global_transform());
|
|
}
|
|
else {
|
|
copy_v3_v3(co, verts[i].co);
|
|
}
|
|
source.appendValues(co[0], co[1], co[2]);
|
|
}
|
|
|
|
source.finish();
|
|
}
|
|
|
|
void GeometryExporter::createVertexColorSource(std::string geom_id, Mesh *me)
|
|
{
|
|
/* Find number of vertex color layers */
|
|
int totlayer_mcol = CustomData_number_of_layers(&me->ldata, CD_MLOOPCOL);
|
|
if (totlayer_mcol == 0) {
|
|
return;
|
|
}
|
|
|
|
int map_index = 0;
|
|
for (int a = 0; a < totlayer_mcol; a++) {
|
|
|
|
map_index++;
|
|
MLoopCol *mloopcol = (MLoopCol *)CustomData_get_layer_n(&me->ldata, CD_MLOOPCOL, a);
|
|
|
|
COLLADASW::FloatSourceF source(mSW);
|
|
|
|
char *layer_name = bc_CustomData_get_layer_name(&me->ldata, CD_MLOOPCOL, a);
|
|
std::string layer_id = makeVertexColorSourceId(geom_id, layer_name);
|
|
source.setId(layer_id);
|
|
|
|
source.setNodeName(layer_name);
|
|
|
|
source.setArrayId(layer_id + ARRAY_ID_SUFFIX);
|
|
source.setAccessorCount(me->totloop);
|
|
source.setAccessorStride(4);
|
|
|
|
COLLADASW::SourceBase::ParameterNameList ¶m = source.getParameterNameList();
|
|
param.push_back("R");
|
|
param.push_back("G");
|
|
param.push_back("B");
|
|
param.push_back("A");
|
|
|
|
source.prepareToAppendValues();
|
|
|
|
MPoly *mpoly;
|
|
int i;
|
|
for (i = 0, mpoly = me->mpoly; i < me->totpoly; i++, mpoly++) {
|
|
MLoopCol *mlc = mloopcol + mpoly->loopstart;
|
|
for (int j = 0; j < mpoly->totloop; j++, mlc++) {
|
|
source.appendValues(mlc->r / 255.0f, mlc->g / 255.0f, mlc->b / 255.0f, mlc->a / 255.0f);
|
|
}
|
|
}
|
|
|
|
source.finish();
|
|
}
|
|
}
|
|
|
|
std::string GeometryExporter::makeTexcoordSourceId(std::string &geom_id,
|
|
int layer_index,
|
|
bool is_single_layer)
|
|
{
|
|
char suffix[20];
|
|
if (is_single_layer) {
|
|
suffix[0] = '\0';
|
|
}
|
|
else {
|
|
sprintf(suffix, "-%d", layer_index);
|
|
}
|
|
return getIdBySemantics(geom_id, COLLADASW::InputSemantic::TEXCOORD) + suffix;
|
|
}
|
|
|
|
/* creates <source> for texcoords */
|
|
void GeometryExporter::createTexcoordsSource(std::string geom_id, Mesh *me)
|
|
{
|
|
|
|
int totpoly = me->totpoly;
|
|
int totuv = me->totloop;
|
|
MPoly *mpolys = me->mpoly;
|
|
|
|
int num_layers = CustomData_number_of_layers(&me->ldata, CD_MLOOPUV);
|
|
|
|
/* write <source> for each layer
|
|
* each <source> will get id like meshName + "map-channel-1" */
|
|
int active_uv_index = CustomData_get_active_layer_index(&me->ldata, CD_MLOOPUV);
|
|
for (int a = 0; a < num_layers; a++) {
|
|
int layer_index = CustomData_get_layer_index_n(&me->ldata, CD_MLOOPUV, a);
|
|
if (!this->export_settings.get_active_uv_only() || layer_index == active_uv_index) {
|
|
MLoopUV *mloops = (MLoopUV *)CustomData_get_layer_n(&me->ldata, CD_MLOOPUV, a);
|
|
|
|
COLLADASW::FloatSourceF source(mSW);
|
|
std::string layer_id = makeTexcoordSourceId(
|
|
geom_id, a, this->export_settings.get_active_uv_only());
|
|
source.setId(layer_id);
|
|
source.setArrayId(layer_id + ARRAY_ID_SUFFIX);
|
|
|
|
source.setAccessorCount(totuv);
|
|
source.setAccessorStride(2);
|
|
COLLADASW::SourceBase::ParameterNameList ¶m = source.getParameterNameList();
|
|
param.push_back("S");
|
|
param.push_back("T");
|
|
|
|
source.prepareToAppendValues();
|
|
|
|
for (int index = 0; index < totpoly; index++) {
|
|
MPoly *mpoly = mpolys + index;
|
|
MLoopUV *mloop = mloops + mpoly->loopstart;
|
|
for (int j = 0; j < mpoly->totloop; j++) {
|
|
source.appendValues(mloop[j].uv[0], mloop[j].uv[1]);
|
|
}
|
|
}
|
|
|
|
source.finish();
|
|
}
|
|
}
|
|
}
|
|
|
|
bool operator<(const Normal &a, const Normal &b)
|
|
{
|
|
/* only needed to sort normal vectors and find() them later in a map.*/
|
|
return a.x < b.x || (a.x == b.x && (a.y < b.y || (a.y == b.y && a.z < b.z)));
|
|
}
|
|
|
|
/* creates <source> for normals */
|
|
void GeometryExporter::createNormalsSource(std::string geom_id, Mesh *me, std::vector<Normal> &nor)
|
|
{
|
|
#if 0
|
|
int totverts = dm->getNumVerts(dm);
|
|
MVert *verts = dm->getVertArray(dm);
|
|
#endif
|
|
|
|
COLLADASW::FloatSourceF source(mSW);
|
|
source.setId(getIdBySemantics(geom_id, COLLADASW::InputSemantic::NORMAL));
|
|
source.setArrayId(getIdBySemantics(geom_id, COLLADASW::InputSemantic::NORMAL) + ARRAY_ID_SUFFIX);
|
|
source.setAccessorCount((unsigned long)nor.size());
|
|
source.setAccessorStride(3);
|
|
COLLADASW::SourceBase::ParameterNameList ¶m = source.getParameterNameList();
|
|
param.push_back("X");
|
|
param.push_back("Y");
|
|
param.push_back("Z");
|
|
|
|
source.prepareToAppendValues();
|
|
|
|
std::vector<Normal>::iterator it;
|
|
for (it = nor.begin(); it != nor.end(); it++) {
|
|
Normal &n = *it;
|
|
|
|
Vector no{n.x, n.y, n.z};
|
|
if (export_settings.get_apply_global_orientation()) {
|
|
bc_add_global_transform(no, export_settings.get_global_transform());
|
|
}
|
|
source.appendValues(no[0], no[1], no[2]);
|
|
}
|
|
|
|
source.finish();
|
|
}
|
|
|
|
void GeometryExporter::create_normals(std::vector<Normal> &normals,
|
|
std::vector<BCPolygonNormalsIndices> &polygons_normals,
|
|
Mesh *me)
|
|
{
|
|
std::map<Normal, unsigned int> shared_normal_indices;
|
|
int last_normal_index = -1;
|
|
|
|
MVert *verts = me->mvert;
|
|
MLoop *mloops = me->mloop;
|
|
float(*lnors)[3] = nullptr;
|
|
bool use_custom_normals = false;
|
|
|
|
BKE_mesh_calc_normals_split(me);
|
|
if (CustomData_has_layer(&me->ldata, CD_NORMAL)) {
|
|
lnors = (float(*)[3])CustomData_get_layer(&me->ldata, CD_NORMAL);
|
|
use_custom_normals = true;
|
|
}
|
|
|
|
for (int poly_index = 0; poly_index < me->totpoly; poly_index++) {
|
|
MPoly *mpoly = &me->mpoly[poly_index];
|
|
bool use_vertex_normals = use_custom_normals || mpoly->flag & ME_SMOOTH;
|
|
|
|
if (!use_vertex_normals) {
|
|
/* For flat faces use face normal as vertex normal: */
|
|
|
|
float vector[3];
|
|
BKE_mesh_calc_poly_normal(mpoly, mloops + mpoly->loopstart, verts, vector);
|
|
|
|
Normal n = {vector[0], vector[1], vector[2]};
|
|
normals.push_back(n);
|
|
last_normal_index++;
|
|
}
|
|
|
|
BCPolygonNormalsIndices poly_indices;
|
|
for (int loop_index = 0; loop_index < mpoly->totloop; loop_index++) {
|
|
unsigned int loop_idx = mpoly->loopstart + loop_index;
|
|
if (use_vertex_normals) {
|
|
float normalized[3];
|
|
|
|
if (use_custom_normals) {
|
|
normalize_v3_v3(normalized, lnors[loop_idx]);
|
|
}
|
|
else {
|
|
normal_short_to_float_v3(normalized, verts[mloops[loop_index].v].no);
|
|
normalize_v3(normalized);
|
|
}
|
|
Normal n = {normalized[0], normalized[1], normalized[2]};
|
|
|
|
if (shared_normal_indices.find(n) != shared_normal_indices.end()) {
|
|
poly_indices.add_index(shared_normal_indices[n]);
|
|
}
|
|
else {
|
|
last_normal_index++;
|
|
poly_indices.add_index(last_normal_index);
|
|
shared_normal_indices[n] = last_normal_index;
|
|
normals.push_back(n);
|
|
}
|
|
}
|
|
else {
|
|
poly_indices.add_index(last_normal_index);
|
|
}
|
|
}
|
|
|
|
polygons_normals.push_back(poly_indices);
|
|
}
|
|
}
|
|
|
|
std::string GeometryExporter::getIdBySemantics(std::string geom_id,
|
|
COLLADASW::InputSemantic::Semantics type,
|
|
std::string other_suffix)
|
|
{
|
|
return geom_id + getSuffixBySemantic(type) + other_suffix;
|
|
}
|
|
|
|
COLLADASW::URI GeometryExporter::getUrlBySemantics(std::string geom_id,
|
|
COLLADASW::InputSemantic::Semantics type,
|
|
std::string other_suffix)
|
|
{
|
|
|
|
std::string id(getIdBySemantics(geom_id, type, other_suffix));
|
|
return COLLADASW::URI(COLLADABU::Utils::EMPTY_STRING, id);
|
|
}
|
|
|
|
COLLADASW::URI GeometryExporter::makeUrl(std::string id)
|
|
{
|
|
return COLLADASW::URI(COLLADABU::Utils::EMPTY_STRING, id);
|
|
}
|