526 lines
13 KiB
C++
526 lines
13 KiB
C++
/*
|
|
* This program source code file is part of KiCad, a free EDA CAD application.
|
|
*
|
|
* Copyright (C) 2015-2017 Cirilo Bernardo <cirilo.bernardo@gmail.com>
|
|
* Copyright (C) 2020 KiCad Developers, see AUTHORS.txt for contributors.
|
|
*
|
|
* 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, you may find one here:
|
|
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
|
|
* or you may search the http://www.gnu.org website for the version 2 license,
|
|
* or you may write to the Free Software Foundation, Inc.,
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
#include <iostream>
|
|
#include <sstream>
|
|
#include <fstream>
|
|
#include <wx/filename.h>
|
|
#include <wx/log.h>
|
|
#include "plugins/3dapi/ifsg_api.h"
|
|
#include "plugins/3dapi/sg_version.h"
|
|
#include "streamwrapper.h"
|
|
#include "3d_cache/sg/sg_node.h"
|
|
#include "3d_cache/sg/scenegraph.h"
|
|
#include "3d_cache/sg/sg_appearance.h"
|
|
#include "3d_cache/sg/sg_shape.h"
|
|
#include "3d_cache/sg/sg_helpers.h"
|
|
|
|
|
|
// version format of the cache file
|
|
#define SG_VERSION_TAG "VERSION:2"
|
|
|
|
|
|
static void formatMaterial( SMATERIAL& mat, SGAPPEARANCE const* app )
|
|
{
|
|
float v0, v1, v2;
|
|
|
|
app->ambient.GetColor( v0, v1, v2 );
|
|
mat.m_Ambient.x = v0;
|
|
mat.m_Ambient.y = v1;
|
|
mat.m_Ambient.z = v2;
|
|
|
|
app->diffuse.GetColor( v0, v1, v2 );
|
|
mat.m_Diffuse.x = v0;
|
|
mat.m_Diffuse.y = v1;
|
|
mat.m_Diffuse.z = v2;
|
|
mat.m_Ambient.x *= v0;
|
|
mat.m_Ambient.y *= v1;
|
|
mat.m_Ambient.z *= v2;
|
|
|
|
app->emissive.GetColor( v0, v1, v2 );
|
|
mat.m_Emissive.x = v0;
|
|
mat.m_Emissive.y = v1;
|
|
mat.m_Emissive.z = v2;
|
|
|
|
app->specular.GetColor( v0, v1, v2 );
|
|
mat.m_Specular.x = v0;
|
|
mat.m_Specular.y = v1;
|
|
mat.m_Specular.z = v2;
|
|
|
|
mat.m_Shininess = app->shininess;
|
|
mat.m_Transparency = app->transparency;
|
|
}
|
|
|
|
|
|
bool S3D::WriteVRML( const char* filename, bool overwrite, SGNODE* aTopNode,
|
|
bool reuse, bool renameNodes )
|
|
{
|
|
if( nullptr == filename || filename[0] == 0 )
|
|
return false;
|
|
|
|
wxString ofile = wxString::FromUTF8Unchecked( filename );
|
|
|
|
if( wxFileName::Exists( ofile ) )
|
|
{
|
|
if( !overwrite )
|
|
return false;
|
|
|
|
// make sure we make no attempt to write a directory
|
|
if( !wxFileName::FileExists( ofile ) )
|
|
return false;
|
|
}
|
|
|
|
wxCHECK( aTopNode && aTopNode->GetNodeType() == S3D::SGTYPE_TRANSFORM, false );
|
|
|
|
OPEN_OSTREAM( op, filename );
|
|
|
|
if( op.fail() )
|
|
{
|
|
wxLogTrace( MASK_3D_SG, "%s:%s:%d * [INFO] failed to open file '%s'",
|
|
__FILE__, __FUNCTION__, __LINE__, filename );
|
|
|
|
return false;
|
|
}
|
|
|
|
op.imbue( std::locale( "C" ) );
|
|
op << "#VRML V2.0 utf8\n";
|
|
|
|
if( renameNodes )
|
|
{
|
|
aTopNode->ResetNodeIndex();
|
|
aTopNode->ReNameNodes();
|
|
}
|
|
|
|
aTopNode->WriteVRML( op, reuse );
|
|
|
|
if( !op.fail() )
|
|
{
|
|
CLOSE_STREAM( op );
|
|
return true;
|
|
}
|
|
|
|
CLOSE_STREAM( op );
|
|
|
|
wxLogTrace( MASK_3D_SG, "%s:%s:%d * [INFO] problems encountered writing file '%s'",
|
|
__FILE__, __FUNCTION__, __LINE__, filename );
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
void S3D::ResetNodeIndex( SGNODE* aNode )
|
|
{
|
|
wxCHECK( aNode, /* void */ );
|
|
|
|
aNode->ResetNodeIndex();
|
|
}
|
|
|
|
|
|
void S3D::RenameNodes( SGNODE* aNode )
|
|
{
|
|
wxCHECK( aNode, /* void */ );
|
|
|
|
aNode->ReNameNodes();
|
|
}
|
|
|
|
|
|
void S3D::DestroyNode( SGNODE* aNode ) noexcept
|
|
{
|
|
wxCHECK( aNode, /* void */ );
|
|
|
|
delete aNode;
|
|
}
|
|
|
|
|
|
bool S3D::WriteCache( const char* aFileName, bool overwrite, SGNODE* aNode,
|
|
const char* aPluginInfo )
|
|
{
|
|
if( nullptr == aFileName || aFileName[0] == 0 )
|
|
return false;
|
|
|
|
wxString ofile = wxString::FromUTF8Unchecked( aFileName );
|
|
|
|
wxCHECK( aNode, false );
|
|
|
|
if( wxFileName::Exists( ofile ) )
|
|
{
|
|
if( !overwrite )
|
|
{
|
|
wxLogTrace( MASK_3D_SG, "%s:%s:%d * [INFO] file exists not overwriting '%s'",
|
|
__FILE__, __FUNCTION__, __LINE__, aFileName );
|
|
|
|
return false;
|
|
}
|
|
|
|
// make sure we make no attempt to write a directory
|
|
if( !wxFileName::FileExists( aFileName ) )
|
|
{
|
|
wxLogTrace( MASK_3D_SG, "%s:%s:%d * [INFO] specified path is a directory '%s'",
|
|
__FILE__, __FUNCTION__, __LINE__, aFileName );
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
OPEN_OSTREAM( output, aFileName );
|
|
|
|
if( output.fail() )
|
|
{
|
|
wxLogTrace( MASK_3D_SG, "%s:%s:%d * [INFO] failed to open file '%s'",
|
|
__FILE__, __FUNCTION__, __LINE__, aFileName );
|
|
|
|
return false;
|
|
}
|
|
|
|
output << "(" << SG_VERSION_TAG << ")";
|
|
|
|
if( nullptr != aPluginInfo && aPluginInfo[0] != 0 )
|
|
output << "(" << aPluginInfo << ")";
|
|
else
|
|
output << "(INTERNAL:0.0.0.0)";
|
|
|
|
bool rval = aNode->WriteCache( output, nullptr );
|
|
CLOSE_STREAM( output );
|
|
|
|
if( !rval )
|
|
{
|
|
wxLogTrace( MASK_3D_SG, "%s:%s:%d * [INFO] problems encountered writing cache file '%s'",
|
|
__FILE__, __FUNCTION__, __LINE__, aFileName );
|
|
|
|
// delete the defective file
|
|
wxRemoveFile( ofile );
|
|
}
|
|
|
|
return rval;
|
|
}
|
|
|
|
|
|
SGNODE* S3D::ReadCache( const char* aFileName, void* aPluginMgr,
|
|
bool (*aTagCheck)( const char*, void* ) )
|
|
{
|
|
if( nullptr == aFileName || aFileName[0] == 0 )
|
|
return nullptr;
|
|
|
|
wxString ofile = wxString::FromUTF8Unchecked( aFileName );
|
|
|
|
if( !wxFileName::FileExists( aFileName ) )
|
|
{
|
|
wxLogTrace( MASK_3D_SG, "%s:%s:%d * [INFO] no such file '%s'",
|
|
__FILE__, __FUNCTION__, __LINE__, aFileName );
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
SGNODE* np = new SCENEGRAPH( nullptr );
|
|
|
|
OPEN_ISTREAM( file, aFileName );
|
|
|
|
if( file.fail() )
|
|
{
|
|
delete np;
|
|
|
|
wxLogTrace( MASK_3D_SG, "%s:%s:%d * [INFO] failed to open file '%s'",
|
|
__FILE__, __FUNCTION__, __LINE__, aFileName );
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
// from SG_VERSION_TAG 1, read the version tag; if it's not the expected tag
|
|
// then we fail to read the cache file
|
|
do
|
|
{
|
|
std::string name;
|
|
char schar;
|
|
file.get( schar );
|
|
|
|
if( '(' != schar )
|
|
{
|
|
wxLogTrace( MASK_3D_SG,
|
|
"%s:%s:%d * [INFO] corrupt data; missing left parenthesis at position '%d'",
|
|
__FILE__, __FUNCTION__, __LINE__, static_cast<int>( file.tellg() ) );
|
|
|
|
CLOSE_STREAM( file );
|
|
return nullptr;
|
|
}
|
|
|
|
file.get( schar );
|
|
|
|
while( ')' != schar && file.good() )
|
|
{
|
|
name.push_back( schar );
|
|
file.get( schar );
|
|
}
|
|
|
|
if( name.compare( SG_VERSION_TAG ) )
|
|
{
|
|
CLOSE_STREAM( file );
|
|
return nullptr;
|
|
}
|
|
|
|
} while( 0 );
|
|
|
|
// from SG_VERSION_TAG 2, read the PluginInfo string and check that it matches
|
|
// version tag; if it's not the expected tag then we fail to read the file
|
|
do
|
|
{
|
|
std::string name;
|
|
char schar;
|
|
file.get( schar );
|
|
|
|
if( '(' != schar )
|
|
{
|
|
wxLogTrace( MASK_3D_SG,
|
|
"%s:%s:%d * [INFO] corrupt data; missing left parenthesis at position '%d'",
|
|
__FILE__, __FUNCTION__, __LINE__, static_cast<int>( file.tellg() ) );
|
|
|
|
CLOSE_STREAM( file );
|
|
return nullptr;
|
|
}
|
|
|
|
file.get( schar );
|
|
|
|
while( ')' != schar && file.good() )
|
|
{
|
|
name.push_back( schar );
|
|
file.get( schar );
|
|
}
|
|
|
|
// check the plugin tag
|
|
if( nullptr != aTagCheck && nullptr != aPluginMgr
|
|
&& !aTagCheck( name.c_str(), aPluginMgr ) )
|
|
{
|
|
CLOSE_STREAM( file );
|
|
return nullptr;
|
|
}
|
|
|
|
} while( 0 );
|
|
|
|
bool rval = np->ReadCache( file, nullptr );
|
|
CLOSE_STREAM( file );
|
|
|
|
if( !rval )
|
|
{
|
|
delete np;
|
|
|
|
wxLogTrace( MASK_3D_SG, "%s:%s:%d * [INFO] problems encountered reading cache file '%s'",
|
|
__FILE__, __FUNCTION__, __LINE__, aFileName );
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
return np;
|
|
}
|
|
|
|
|
|
S3DMODEL* S3D::GetModel( SCENEGRAPH* aNode )
|
|
{
|
|
if( nullptr == aNode )
|
|
return nullptr;
|
|
|
|
if( aNode->GetNodeType() != S3D::SGTYPE_TRANSFORM )
|
|
return nullptr;
|
|
|
|
S3D::MATLIST materials;
|
|
std::vector< SMESH > meshes;
|
|
|
|
// the materials list shall have a default color; although the VRML
|
|
// default is an opaque black, the default used here shall be a median
|
|
// gray in hopes that it may help highlight faulty models; this color is
|
|
// also typical of MCAD applications. When a model has no associated
|
|
// material color it shall be assigned the index 0.
|
|
SGAPPEARANCE app( nullptr );
|
|
app.ambient = SGCOLOR( 0.6f, 0.6f, 0.6f );
|
|
app.diffuse = SGCOLOR( 0.6f, 0.6f, 0.6f );
|
|
app.specular = app.diffuse;
|
|
app.shininess = 0.05f;
|
|
app.transparency = 0.0f;
|
|
|
|
materials.matorder.push_back( &app );
|
|
materials.matmap.insert( std::pair< SGAPPEARANCE const*, int >( &app, 0 ) );
|
|
|
|
if( aNode->Prepare( nullptr, materials, meshes ) )
|
|
{
|
|
if( meshes.empty() )
|
|
return nullptr;
|
|
|
|
S3DMODEL* model = S3D::New3DModel();
|
|
|
|
// add all the materials
|
|
size_t j = materials.matorder.size();
|
|
SMATERIAL* lmat = new SMATERIAL[j];
|
|
|
|
for( size_t i = 0; i < j; ++i )
|
|
formatMaterial( lmat[i], materials.matorder[i] );
|
|
|
|
model->m_Materials = lmat;
|
|
model->m_MaterialsSize = j;
|
|
|
|
// add all the meshes
|
|
j = meshes.size();
|
|
SMESH* lmesh = new SMESH[j];
|
|
|
|
for( size_t i = 0; i < j; ++i )
|
|
lmesh[i] = meshes[i];
|
|
|
|
model->m_Meshes = lmesh;
|
|
model->m_MeshesSize = j;
|
|
|
|
return model;
|
|
}
|
|
|
|
size_t j = meshes.size();
|
|
|
|
for( size_t i = 0; i < j; ++i )
|
|
S3D::Free3DMesh( meshes[i] );
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
|
|
void S3D::Destroy3DModel( S3DMODEL** aModel )
|
|
{
|
|
if( nullptr == aModel || nullptr == *aModel )
|
|
return;
|
|
|
|
S3DMODEL* m = *aModel;
|
|
S3D::FREE_S3DMODEL( *m );
|
|
delete m;
|
|
*aModel = nullptr;
|
|
}
|
|
|
|
|
|
void Free3DModel( S3DMODEL& aModel )
|
|
{
|
|
S3D::FREE_S3DMODEL( aModel );
|
|
}
|
|
|
|
|
|
void S3D::Free3DMesh( SMESH& aMesh )
|
|
{
|
|
S3D::FREE_SMESH( aMesh );
|
|
}
|
|
|
|
|
|
S3DMODEL* S3D::New3DModel( void )
|
|
{
|
|
S3DMODEL* mp = new S3DMODEL;
|
|
S3D::INIT_S3DMODEL( *mp );
|
|
return mp;
|
|
}
|
|
|
|
|
|
void S3D::Init3DMaterial( SMATERIAL& aMat )
|
|
{
|
|
S3D::INIT_SMATERIAL( aMat );
|
|
}
|
|
|
|
|
|
void S3D::Init3DMesh( SMESH& aMesh )
|
|
{
|
|
S3D::INIT_SMESH( aMesh );
|
|
}
|
|
|
|
|
|
void S3D::GetLibVersion( unsigned char* Major, unsigned char* Minor, unsigned char* Patch,
|
|
unsigned char* Revision ) noexcept
|
|
{
|
|
if( Major )
|
|
*Major = KICADSG_VERSION_MAJOR;
|
|
|
|
if( Minor )
|
|
*Minor = KICADSG_VERSION_MINOR;
|
|
|
|
if( Revision )
|
|
*Revision = KICADSG_VERSION_REVISION;
|
|
|
|
if( Patch )
|
|
*Patch = KICADSG_VERSION_PATCH;
|
|
}
|
|
|
|
|
|
SGVECTOR S3D::CalcTriNorm( const SGPOINT& p1, const SGPOINT& p2, const SGPOINT& p3 )
|
|
{
|
|
glm::dvec3 tri = glm::dvec3( 0.0, 0.0, 0.0 );
|
|
glm::dvec3 pts[3];
|
|
|
|
pts[0] = glm::dvec3( p1.x, p1.y, p1.z );
|
|
pts[1] = glm::dvec3( p2.x, p2.y, p2.z );
|
|
pts[2] = glm::dvec3( p3.x, p3.y, p3.z );
|
|
|
|
// degenerate points are given a default 0, 0, 1 normal
|
|
if( S3D::degenerate( pts ) )
|
|
return SGVECTOR( 0.0, 0.0, 1.0 );
|
|
|
|
// normal
|
|
tri = glm::cross( pts[1] - pts[0], pts[2] - pts[0] );
|
|
glm::normalize( tri );
|
|
|
|
return SGVECTOR( tri.x, tri.y, tri.z );
|
|
}
|
|
|
|
|
|
S3D::SGTYPES S3D::GetSGNodeType( SGNODE* aNode )
|
|
{
|
|
if( nullptr == aNode )
|
|
return SGTYPE_END;
|
|
|
|
return aNode->GetNodeType();
|
|
}
|
|
|
|
|
|
SGNODE* S3D::GetSGNodeParent( SGNODE* aNode )
|
|
{
|
|
if( nullptr == aNode )
|
|
return nullptr;
|
|
|
|
return aNode->GetParent();
|
|
}
|
|
|
|
|
|
bool S3D::AddSGNodeRef( SGNODE* aParent, SGNODE* aChild )
|
|
{
|
|
if( nullptr == aParent || nullptr == aChild )
|
|
return false;
|
|
|
|
return aParent->AddRefNode( aChild );
|
|
}
|
|
|
|
|
|
bool S3D::AddSGNodeChild( SGNODE* aParent, SGNODE* aChild )
|
|
{
|
|
if( nullptr == aParent || nullptr == aChild )
|
|
return false;
|
|
|
|
return aParent->AddChildNode( aChild );
|
|
}
|
|
|
|
|
|
void S3D::AssociateSGNodeWrapper( SGNODE* aObject, SGNODE** aRefPtr )
|
|
{
|
|
if( nullptr == aObject || nullptr == aRefPtr || aObject != *aRefPtr )
|
|
return;
|
|
|
|
aObject->AssociateWrapper( aRefPtr );
|
|
}
|