int LD3dsExporter::getMaterial(int colorNumber)
{
IntIntMap::iterator it = m_colorNumbers.find(colorNumber);
if (it == m_colorNumbers.end())
{
int material = (int)m_colorNumbers.size();
Lib3dsMaterial *mat = lib3ds_material_new((std::string("ldraw_") +
ltostr(colorNumber)).c_str());
lib3ds_file_insert_material(m_file, mat, -1);
int r, g, b, a;
LDLPalette *pPalette = m_topModel->getMainModel()->getPalette();
pPalette->getRGBA(colorNumber, r, g, b, a);
LDLColorInfo colorInfo = pPalette->getAnyColorInfo(colorNumber);
mat->diffuse[0] = r / 255.0f;
mat->diffuse[1] = g / 255.0f;
mat->diffuse[2] = b / 255.0f;
mat->transparency = 1.0f - a / 255.0f;
mat->two_sided = 1;
if (colorInfo.rubber)
{
mat->specular[0] = mat->specular[1] = mat->specular[2] = 0.05f;
}
mat->shading = LIB3DS_SHADING_PHONG;
m_colorNumbers[colorNumber] = material;
return material;
}
else
{
return it->second;
}
}
Lib3dsMaterial* GLC_WorldTo3ds::create3dsMaterialFromGLC_Material(GLC_Material* pMat, const QString& matName)
{
Lib3dsMaterial* pSubject= lib3ds_material_new();
strcpy(pSubject->name, matName.toLocal8Bit().data());
// Ambient Color
QColor ambient= pMat->ambientColor();
pSubject->ambient[0]= static_cast<float>(ambient.redF());
pSubject->ambient[1]= static_cast<float>(ambient.greenF());
pSubject->ambient[2]= static_cast<float>(ambient.blueF());
pSubject->ambient[3]= static_cast<float>(ambient.alphaF());
// Diffuse Color
QColor diffuse= pMat->diffuseColor();
pSubject->diffuse[0]= static_cast<float>(diffuse.redF());
pSubject->diffuse[1]= static_cast<float>(diffuse.greenF());
pSubject->diffuse[2]= static_cast<float>(diffuse.blueF());
pSubject->diffuse[3]= static_cast<float>(diffuse.alphaF());
// Specular Color
QColor specular= pMat->specularColor();
pSubject->specular[0]= static_cast<float>(specular.redF());
pSubject->specular[1]= static_cast<float>(specular.greenF());
pSubject->specular[2]= static_cast<float>(specular.blueF());
pSubject->specular[3]= static_cast<float>(specular.alphaF());
// Shininess
pSubject->shininess= pMat->shininess();
// Transparency
pSubject->transparency= 1.0f - static_cast<float>(pMat->opacity());
// Texture
if (pMat->hasTexture())
{
if (!m_TextureToFileName.contains(pMat->textureHandle()))
{
QString filePath= QFileInfo(m_FileName).absolutePath();
QString textureName= matName;
QImage textureImage= pMat->textureHandle()->imageOfTexture();
if (!pMat->textureFileName().isEmpty())
{
textureName= matName + '-' + QFileInfo(pMat->textureFileName()).fileName();
textureImage.load(pMat->textureFileName());
}
else
{
textureName= textureName + ".jpg";
}
textureName= textureName.right(63);
if (!textureImage.isNull())
{
const QString type(QFileInfo(textureName).suffix());
QString newTextureFile= filePath + QDir::separator() + textureName;
textureImage.save(newTextureFile, type.toUpper().toAscii().data());
strcpy(pSubject->texture1_map.name, textureName.toLocal8Bit().data());
m_TextureToFileName.insert(pMat->textureHandle(), textureName);
}
}
else
{
QString textureName= m_TextureToFileName.value(pMat->textureHandle());
strcpy(pSubject->texture1_map.name, textureName.toLocal8Bit().data());
}
}
lib3ds_file_insert_material(m_pLib3dsFile, pSubject);
m_NameToMaterial.insert(matName, pSubject);
return pSubject;
}
static Lib3dsBool
mdata_read(Lib3dsFile *file, FILE *f)
{
Lib3dsChunk c;
Lib3dsWord chunk;
if (!lib3ds_chunk_read_start(&c, LIB3DS_MDATA, f)) {
return(LIB3DS_FALSE);
}
while ((chunk=lib3ds_chunk_read_next(&c, f))!=0) {
switch (chunk) {
case LIB3DS_MESH_VERSION:
{
file->mesh_version=lib3ds_intd_read(f);
}
break;
case LIB3DS_MASTER_SCALE:
{
file->master_scale=lib3ds_float_read(f);
}
break;
case LIB3DS_SHADOW_MAP_SIZE:
case LIB3DS_LO_SHADOW_BIAS:
case LIB3DS_HI_SHADOW_BIAS:
case LIB3DS_SHADOW_SAMPLES:
case LIB3DS_SHADOW_RANGE:
case LIB3DS_SHADOW_FILTER:
case LIB3DS_RAY_BIAS:
{
lib3ds_chunk_read_reset(&c, f);
if (!lib3ds_shadow_read(&file->shadow, f)) {
return(LIB3DS_FALSE);
}
}
break;
case LIB3DS_VIEWPORT_LAYOUT:
case LIB3DS_DEFAULT_VIEW:
{
lib3ds_chunk_read_reset(&c, f);
if (!lib3ds_viewport_read(&file->viewport, f)) {
return(LIB3DS_FALSE);
}
}
break;
case LIB3DS_O_CONSTS:
{
int i;
for (i=0; i<3; ++i) {
file->construction_plane[i]=lib3ds_float_read(f);
}
}
break;
case LIB3DS_AMBIENT_LIGHT:
{
lib3ds_chunk_read_reset(&c, f);
if (!ambient_read(file, f)) {
return(LIB3DS_FALSE);
}
}
break;
case LIB3DS_BIT_MAP:
case LIB3DS_SOLID_BGND:
case LIB3DS_V_GRADIENT:
case LIB3DS_USE_BIT_MAP:
case LIB3DS_USE_SOLID_BGND:
case LIB3DS_USE_V_GRADIENT:
{
lib3ds_chunk_read_reset(&c, f);
if (!lib3ds_background_read(&file->background, f)) {
return(LIB3DS_FALSE);
}
}
break;
case LIB3DS_FOG:
case LIB3DS_LAYER_FOG:
case LIB3DS_DISTANCE_CUE:
case LIB3DS_USE_FOG:
case LIB3DS_USE_LAYER_FOG:
case LIB3DS_USE_DISTANCE_CUE:
{
lib3ds_chunk_read_reset(&c, f);
if (!lib3ds_atmosphere_read(&file->atmosphere, f)) {
return(LIB3DS_FALSE);
}
}
break;
case LIB3DS_MAT_ENTRY:
{
Lib3dsMaterial *material;
material=lib3ds_material_new();
if (!material) {
return(LIB3DS_FALSE);
}
lib3ds_chunk_read_reset(&c, f);
if (!lib3ds_material_read(material, f)) {
return(LIB3DS_FALSE);
}
lib3ds_file_insert_material(file, material);
}
break;
case LIB3DS_NAMED_OBJECT:
{
lib3ds_chunk_read_reset(&c, f);
if (!named_object_read(file, f)) {
return(LIB3DS_FALSE);
}
}
break;
default:
lib3ds_chunk_unknown(chunk);
}
}
lib3ds_chunk_read_end(&c, f);
return(LIB3DS_TRUE);
}
static void
mdata_read(Lib3dsFile *file, Lib3dsIo *io) {
Lib3dsChunk c;
uint16_t chunk;
lib3ds_chunk_read_start(&c, CHK_MDATA, io);
while ((chunk = lib3ds_chunk_read_next(&c, io)) != 0) {
switch (chunk) {
case CHK_MESH_VERSION: {
file->mesh_version = lib3ds_io_read_intd(io);
break;
}
case CHK_MASTER_SCALE: {
file->master_scale = lib3ds_io_read_float(io);
break;
}
case CHK_SHADOW_MAP_SIZE:
case CHK_LO_SHADOW_BIAS:
case CHK_HI_SHADOW_BIAS:
case CHK_SHADOW_SAMPLES:
case CHK_SHADOW_RANGE:
case CHK_SHADOW_FILTER:
case CHK_RAY_BIAS: {
lib3ds_chunk_read_reset(&c, io);
lib3ds_shadow_read(&file->shadow, io);
break;
}
case CHK_VIEWPORT_LAYOUT:
case CHK_DEFAULT_VIEW: {
lib3ds_chunk_read_reset(&c, io);
lib3ds_viewport_read(&file->viewport, io);
break;
}
case CHK_O_CONSTS: {
int i;
for (i = 0; i < 3; ++i) {
file->construction_plane[i] = lib3ds_io_read_float(io);
}
break;
}
case CHK_AMBIENT_LIGHT: {
lib3ds_chunk_read_reset(&c, io);
ambient_read(file, io);
break;
}
case CHK_BIT_MAP:
case CHK_SOLID_BGND:
case CHK_V_GRADIENT:
case CHK_USE_BIT_MAP:
case CHK_USE_SOLID_BGND:
case CHK_USE_V_GRADIENT: {
lib3ds_chunk_read_reset(&c, io);
lib3ds_background_read(&file->background, io);
break;
}
case CHK_FOG:
case CHK_LAYER_FOG:
case CHK_DISTANCE_CUE:
case CHK_USE_FOG:
case CHK_USE_LAYER_FOG:
case CHK_USE_DISTANCE_CUE: {
lib3ds_chunk_read_reset(&c, io);
lib3ds_atmosphere_read(&file->atmosphere, io);
break;
}
case CHK_MAT_ENTRY: {
Lib3dsMaterial *material = lib3ds_material_new(NULL);
lib3ds_file_insert_material(file, material, -1);
lib3ds_chunk_read_reset(&c, io);
lib3ds_material_read(material, io);
break;
}
case CHK_NAMED_OBJECT: {
lib3ds_chunk_read_reset(&c, io);
named_object_read(file, io);
break;
}
default:
lib3ds_chunk_unknown(chunk, io);
}
}
lib3ds_chunk_read_end(&c, io);
}
int main(int argc, char **argv) {
Lib3dsFile *file = lib3ds_file_new();
file->frames = 360;
{
Lib3dsMaterial *mat = lib3ds_material_new("c_tex");
lib3ds_file_insert_material(file, mat, -1);
strcpy(mat->texture1_map.name, "cube.tga");
mat->texture1_map.percent = 1.0;
mat = lib3ds_material_new("c_red");
lib3ds_file_insert_material(file, mat, -1);
mat->diffuse[0] = 1.0;
mat->diffuse[1] = 0.0;
mat->diffuse[2] = 0.0;
mat = lib3ds_material_new("c_blue");
lib3ds_file_insert_material(file, mat, -1);
mat->diffuse[0] = 0.0;
mat->diffuse[1] = 0.0;
mat->diffuse[2] = 1.0;
}
{
int i, j;
Lib3dsMesh *mesh = lib3ds_mesh_new("cube");
Lib3dsMeshInstanceNode *inst;
lib3ds_file_insert_mesh(file, mesh, -1);
lib3ds_mesh_resize_vertices(mesh, 8, 1, 0);
for (i = 0; i < 8; ++i) {
lib3ds_vector_copy(mesh->vertices[i], g_vertices[i]);
mesh->texcos[i][0] = g_texcoords[i][0];
mesh->texcos[i][1] = g_texcoords[i][1];
}
lib3ds_mesh_resize_faces(mesh, 12);
for (i = 0; i < 12; ++i) {
for (j = 0; j < 3; ++j) {
mesh->faces[i].index[j] = g_indices[i][j];
}
}
for (i = 0; i < 8; ++i) {
mesh->faces[i].material = 0;
}
for (i = 0; i < 2; ++i) {
mesh->faces[8+i].material = 1;
}
for (i = 0; i < 2; ++i) {
mesh->faces[10+i].material = 2;
}
inst = lib3ds_node_new_mesh_instance(mesh, "01", NULL, NULL, NULL);
lib3ds_file_append_node(file, (Lib3dsNode*)inst, NULL);
}
{
Lib3dsCamera *camera;
Lib3dsCameraNode *n;
Lib3dsTargetNode *t;
int i;
camera = lib3ds_camera_new("camera01");
lib3ds_file_insert_camera(file, camera, -1);
lib3ds_vector_make(camera->position, 0.0, -100, 0.0);
lib3ds_vector_make(camera->target, 0.0, 0.0, 0.0);
n = lib3ds_node_new_camera(camera);
t = lib3ds_node_new_camera_target(camera);
lib3ds_file_append_node(file, (Lib3dsNode*)n, NULL);
lib3ds_file_append_node(file, (Lib3dsNode*)t, NULL);
lib3ds_track_resize(&n->pos_track, 37);
for (i = 0; i <= 36; i++) {
n->pos_track.keys[i].frame = 10 * i;
lib3ds_vector_make(n->pos_track.keys[i].value,
(float)(100.0 * cos(2 * M_PI * i / 36.0)),
(float)(100.0 * sin(2 * M_PI * i / 36.0)),
50.0
);
}
}
if (!lib3ds_file_save(file, "cube.3ds")) {
fprintf(stderr, "ERROR: Saving 3ds file failed!\n");
}
lib3ds_file_free(file);
}
// TODO: Build own exporter class
void objectExporter::on_buttonBox_accepted()
{
QString fileName = QFileDialog::getSaveFileName(gloParent, "Save 3ds Object", ".", "3D Object (*.3ds)", 0, 0);
QList<trackHandler*> trackList = gloParent->getTrackList();
trackHandler* curTrack = trackList[ui->trackBox->currentIndex()];
trackMesh* mesh = curTrack->mMesh;
QVector<float> *vertices = new QVector<float>();
QVector<unsigned int> *indices = new QVector<unsigned int>();
QVector<unsigned int> *borders = new QVector<unsigned int>();
Lib3dsFile *file = lib3ds_file_new();
file->frames = 360;
{
Lib3dsMaterial* mat = lib3ds_material_new("coaster");
lib3ds_file_insert_material(file, mat, -1);
mat->diffuse[0] = curTrack->trackColors[0].red()/255.f;
mat->diffuse[1] = curTrack->trackColors[0].green()/255.f;
mat->diffuse[2] = curTrack->trackColors[0].blue()/255.f;
}
{
for(int section = 0; section < curTrack->trackData->lSections.size(); ++section) {
vertices->clear();
indices->clear();
borders->clear();
mesh->build3ds(section, vertices, indices, borders);
float* fvertices = new float[vertices->size()];
for(int i = 0; i < vertices->size()/3; ++i) {
fvertices[3*i+0] = vertices->at(3*i+0);
fvertices[3*i+1] = -vertices->at(3*i+2);
fvertices[3*i+2] = vertices->at(3*i+1);
//exportScreen->doFastExport();
}
for(int subIndex = 0; subIndex < borders->size()-2; subIndex+= 2) {
int fromVIndex = borders->at(subIndex)/3;
int toVIndex = borders->at(subIndex+2)/3;
int fromIIndex = borders->at(subIndex+1)/3;
int toIIndex = borders->at(subIndex+3)/3;
int i, j;
QString name = QString::number(section).append(QString("_").append(QString::number(subIndex/2)));
Lib3dsMesh *mesh = lib3ds_mesh_new(name.toLocal8Bit().data());
Lib3dsMeshInstanceNode *inst;
lib3ds_file_insert_mesh(file, mesh, -1);
lib3ds_mesh_resize_vertices(mesh, toVIndex-fromVIndex, 1, 0);
for (i = 0; i < toVIndex-fromVIndex; ++i) {
lib3ds_vector_copy(mesh->vertices[i], &fvertices[(i+fromVIndex)*3]);
mesh->texcos[i][0] = 0.f;
mesh->texcos[i][1] = 0.f;
}
lib3ds_mesh_resize_faces(mesh, toIIndex-fromIIndex);
for (i = 0; i < toIIndex-fromIIndex; ++i) {
for (j = 0; j < 3; ++j) {
mesh->faces[i].index[j] = indices->at(3*(i+fromIIndex)+j)-fromVIndex;
mesh->faces[i].material = 0;
}
}
inst = lib3ds_node_new_mesh_instance(mesh, name.toLocal8Bit().data(), NULL, NULL, NULL);
lib3ds_file_append_node(file, (Lib3dsNode*)inst, NULL);
}
delete[] fvertices;
}
}
{
Lib3dsCamera *camera;
Lib3dsCameraNode *n;
Lib3dsTargetNode *t;
int i;
camera = lib3ds_camera_new("camera01");
lib3ds_file_insert_camera(file, camera, -1);
lib3ds_vector_make(camera->position, 0.0, -100, 0.0);
lib3ds_vector_make(camera->target, 0.0, 0.0, 0.0);
n = lib3ds_node_new_camera(camera);
t = lib3ds_node_new_camera_target(camera);
lib3ds_file_append_node(file, (Lib3dsNode*)n, NULL);
lib3ds_file_append_node(file, (Lib3dsNode*)t, NULL);
lib3ds_track_resize(&n->pos_track, 37);
for (i = 0; i <= 36; i++) {
n->pos_track.keys[i].frame = 10 * i;
lib3ds_vector_make(n->pos_track.keys[i].value,
(float)(100.0 * cos(2 * F_PI * i / 36.0)),
(float)(100.0 * sin(2 * F_PI * i / 36.0)),
50.0
);
}
}
if (!lib3ds_file_save(file, fileName.toLocal8Bit().data())) {
qDebug("ERROR: Saving 3ds file failed!\n");
}
lib3ds_file_free(file);
delete indices;
delete vertices;
}
