MODEL_3D Class Reference

#include <3d_model.h>

Classes
struct	MATERIAL
struct	VERTEX

Public Member Functions
	MODEL_3D (const S3DMODEL &a3DModel, MATERIAL_MODE aMaterialMode)
	Load a 3D model. More...
	~MODEL_3D ()
void	DrawOpaque (bool aUseSelectedMaterial, SFVEC3F aSelectionColor=SFVEC3F(0.0f)) const
	Render the model into the current context. More...
void	DrawTransparent (float aOpacity, bool aUseSelectedMaterial, SFVEC3F aSelectionColor=SFVEC3F(0.0f)) const
	Render the model into the current context. More...
void	Draw (bool aTransparent, float aOpacity, bool aUseSelectedMaterial, const SFVEC3F &aSelectionColor, const glm::mat4 *aModelWorldMatrix, const SFVEC3F *aCameraWorldPos) const
	Render the model into the current context. More...
bool	HasOpaqueMeshes () const
	Return true if have opaque meshes to render. More...
bool	HasTransparentMeshes () const
	Return true if have transparent mesh's to render. More...
void	DrawBbox () const
	Draw main bounding box of the model. More...
void	DrawBboxes () const
	Draw individual bounding boxes of each mesh. More...
const BBOX_3D &	GetBBox () const
	Get the main bounding box. More...

Static Public Member Functions
static void	BeginDrawMulti (bool aUseColorInformation)
	Set some basic render states before drawing multiple models. More...
static void	EndDrawMulti ()
	Cleanup render states after drawing multiple models. More...

Static Private Member Functions
static void	MakeBbox (const BBOX_3D &aBox, unsigned int aIdxOffset, VERTEX *aVtxOut, GLuint *aIdxOut, const glm::vec4 &aColor)

Private Attributes
MATERIAL_MODE	m_materialMode
BBOX_3D	m_model_bbox
	global bounding box for this model More...
std::vector< BBOX_3D >	m_meshes_bbox
	individual bbox for each mesh More...
GLuint	m_vertex_buffer = 0
GLuint	m_index_buffer = 0
GLenum	m_index_buffer_type = GL_INVALID_ENUM
std::vector< MATERIAL >	m_materials
bool	m_have_opaque_meshes = false
bool	m_have_transparent_meshes = false
GLuint	m_bbox_vertex_buffer = 0
GLuint	m_bbox_index_buffer = 0
GLenum	m_bbox_index_buffer_type = GL_INVALID_ENUM

Static Private Attributes
static const wxChar *	m_logTrace = wxT( "KI_TRACE_EDA_OGL_3DMODEL" )
static constexpr unsigned int	bbox_vtx_count = 8
static constexpr unsigned int	bbox_idx_count = 24

Detailed Description

Definition at line 37 of file 3d_model.h.

Constructor & Destructor Documentation

MODEL_3D()

MODEL_3D::MODEL_3D	(	const S3DMODEL &	a3DModel,
		MATERIAL_MODE	aMaterialMode
	)

Load a 3D model.

Note

This must be called inside a gl context.

Parameters

a3DModel	a 3d model data to load.
aMaterialMode	a mode to render the materials of the model.

WARNING: Horrible hack here! Somehow, buffer values are being shared between pcbnew and the 3d viewer, which then frees the buffer, resulting in errors in pcbnew. To resolve this temporarily, we generate extra buffers in 3dviewer and use the higher numbers. These are freed on close. todo: Correctly separate the OpenGL contexts to prevent overlapping buffer vals

Definition at line 91 of file 3d_model.cpp.

{
 wxLogTrace( m_logTrace, wxT( "MODEL_3D::MODEL_3D %u meshes %u materials" ),
 static_cast<unsigned int>( a3DModel.m_MeshesSize ),
 static_cast<unsigned int>( a3DModel.m_MaterialsSize ) );
 
 auto start_time = std::chrono::high_resolution_clock::now();
 GLuint buffers[8];
 
 glGenBuffers( 6, buffers );
 m_bbox_vertex_buffer = buffers[2];
 m_bbox_index_buffer = buffers[3];
 m_vertex_buffer = buffers[4];
 m_index_buffer = buffers[5];
 
 // Validate a3DModel pointers
 wxASSERT( a3DModel.m_Materials != nullptr );
 wxASSERT( a3DModel.m_Meshes != nullptr );
 wxASSERT( a3DModel.m_MaterialsSize > 0 );
 wxASSERT( a3DModel.m_MeshesSize > 0 );
 
 m_materialMode = aMaterialMode;
 
 if( a3DModel.m_Materials == nullptr || a3DModel.m_Meshes == nullptr
 || a3DModel.m_MaterialsSize == 0 || a3DModel.m_MeshesSize == 0 )
 return;
 
 // create empty bbox for each mesh. it will be updated when the vertices are copied.
 m_meshes_bbox.resize( a3DModel.m_MeshesSize );
 
 // copy materials for later use during rendering.
 m_materials.reserve( a3DModel.m_MaterialsSize );
 
 for( unsigned int i = 0; i < a3DModel.m_MaterialsSize; ++i )
 m_materials.emplace_back( a3DModel.m_Materials[i] );
 
 // build temporary vertex and index buffers for bounding boxes.
 // the first box is the outer box.
 std::vector<VERTEX> bbox_tmp_vertices( ( m_meshes_bbox.size() + 1 ) * bbox_vtx_count );
 std::vector<GLuint> bbox_tmp_indices( ( m_meshes_bbox.size() + 1 ) * bbox_idx_count );
 
 // group all meshes by material.
 // for each material create a combined vertex and index buffer.
 // some models might have many sub-meshes. so iterate over the
 // input meshes only once.
 struct MESH_GROUP
 {
 std::vector<VERTEX> m_vertices;
 std::vector<GLuint> m_indices;
 };
 
 std::vector<MESH_GROUP> mesh_groups( m_materials.size() );
 
 for( unsigned int mesh_i = 0; mesh_i < a3DModel.m_MeshesSize; ++mesh_i )
 {
 const SMESH& mesh = a3DModel.m_Meshes[mesh_i];
 
 // silently ignore meshes that have invalid material references or invalid geometry.
 if( mesh.m_MaterialIdx >= m_materials.size()
 || mesh.m_Positions == nullptr
 || mesh.m_FaceIdx == nullptr
 || mesh.m_Normals == nullptr
 || mesh.m_FaceIdxSize == 0
 || mesh.m_VertexSize == 0 )
 {
 continue;
 }
 
 MESH_GROUP& mesh_group = mesh_groups[mesh.m_MaterialIdx];
 MATERIAL& material = m_materials[mesh.m_MaterialIdx];
 
 if( material.IsTransparent() && m_materialMode != MATERIAL_MODE::DIFFUSE_ONLY )
 m_have_transparent_meshes = true;
 else
 m_have_opaque_meshes = true;
 
 const unsigned int vtx_offset = mesh_group.m_vertices.size();
 mesh_group.m_vertices.resize( mesh_group.m_vertices.size() + mesh.m_VertexSize );
 
 // copy vertex data and update the bounding box.
 // use material color for mesh bounding box or some sort of average vertex color.
 glm::vec3 avg_color = material.m_Diffuse;
 
 BBOX_3D &mesh_bbox = m_meshes_bbox[mesh_i];
 
 for( unsigned int vtx_i = 0; vtx_i < mesh.m_VertexSize; ++vtx_i )
 {
 mesh_bbox.Union( mesh.m_Positions[vtx_i] );
 
 VERTEX& vtx_out = mesh_group.m_vertices[vtx_offset + vtx_i];
 
 vtx_out.m_pos = mesh.m_Positions[vtx_i];
 vtx_out.m_nrm = glm::clamp( glm::vec4( mesh.m_Normals[vtx_i], 1.0f ) * 127.0f,
 -127.0f, 127.0f );
 
 vtx_out.m_tex_uv = mesh.m_Texcoords != nullptr ? mesh.m_Texcoords[vtx_i]
 : glm::vec2 (0);
 
 if( mesh.m_Color != nullptr )
 {
 avg_color = ( avg_color + mesh.m_Color[vtx_i] ) * 0.5f;
 
 vtx_out.m_color =
 glm::clamp( glm::vec4( mesh.m_Color[vtx_i],
 1 - material.m_Transparency ) * 255.0f,
 0.0f, 255.0f );
 
 vtx_out.m_cad_color =
 glm::clamp( glm::vec4( MaterialDiffuseToColorCAD( mesh.m_Color[vtx_i] ),
 1 ) * 255.0f, 0.0f, 255.0f );
 }
 else
 {
 // the mesh will be rendered with other meshes that might have
 // vertex colors. thus, we can't enable/disable vertex colors
 // for individual meshes during rendering.
 
 // if there are no vertex colors, use material color instead.
 vtx_out.m_color =
 glm::clamp( glm::vec4( material.m_Diffuse,
 1 - material.m_Transparency ) * 255.0f,
 0.0f, 255.0f );
 
 vtx_out.m_cad_color =
 glm::clamp( glm::vec4 ( MaterialDiffuseToColorCAD( material.m_Diffuse ),
 1 ) * 255.0f,
 0.0f, 255.0f );
 }
 }
 
 if( mesh_bbox.IsInitialized() )
 {
 // generate geometry for the bounding box
 MakeBbox( mesh_bbox, ( mesh_i + 1 ) * bbox_vtx_count,
 &bbox_tmp_vertices[( mesh_i + 1 ) * bbox_vtx_count],
 &bbox_tmp_indices[( mesh_i + 1 ) * bbox_idx_count],
 { avg_color, 1.0f } );
 
 // bump the outer bounding box
 m_model_bbox.Union( mesh_bbox );
 
 // add to the material group
 material.m_bbox.Union( mesh_bbox );
 }
 
 
 // append indices of this mesh to the mesh group.
 const unsigned int idx_offset = mesh_group.m_indices.size();
 unsigned int use_idx_count = mesh.m_FaceIdxSize;
 
 if( use_idx_count % 3 != 0 )
 {
 wxLogTrace( m_logTrace, wxT( " index count %u not multiple of 3, truncating" ),
 static_cast<unsigned int>( use_idx_count ) );
 use_idx_count = ( use_idx_count / 3 ) * 3;
 }
 
 mesh_group.m_indices.resize( mesh_group.m_indices.size() + use_idx_count );
 
 for( unsigned int idx_i = 0; idx_i < use_idx_count; ++idx_i )
 {
 if( mesh.m_FaceIdx[idx_i] >= mesh.m_VertexSize )
 {
 wxLogTrace( m_logTrace, wxT( " index %u out of range (%u)" ),
 static_cast<unsigned int>( mesh.m_FaceIdx[idx_i] ),
 static_cast<unsigned int>( mesh.m_VertexSize ) );
 
 // FIXME: should skip this triangle
 }
 
 mesh_group.m_indices[idx_offset + idx_i] = mesh.m_FaceIdx[idx_i] + vtx_offset;
 }
 }
 
 // generate geometry for the outer bounding box
 if( m_model_bbox.IsInitialized() )
 MakeBbox( m_model_bbox, 0, &bbox_tmp_vertices[0], &bbox_tmp_indices[0],
 { 0.0f, 1.0f, 0.0f, 1.0f } );
 
 // create bounding box buffers
 glGenBuffers( 1, &m_bbox_vertex_buffer );
 glBindBuffer( GL_ARRAY_BUFFER, m_bbox_vertex_buffer );
 glBufferData( GL_ARRAY_BUFFER, sizeof( VERTEX ) * bbox_tmp_vertices.size(),
 bbox_tmp_vertices.data(), GL_STATIC_DRAW );
 
 glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, m_bbox_index_buffer );
 
 if( bbox_tmp_vertices.size() <= std::numeric_limits<GLushort>::max() )
 {
 m_bbox_index_buffer_type = GL_UNSIGNED_SHORT;
 
 auto u16buf = std::make_unique<GLushort[]>( bbox_tmp_indices.size() );
 
 for( unsigned int i = 0; i < bbox_tmp_indices.size(); ++i )
 u16buf[i] = static_cast<GLushort>( bbox_tmp_indices[i] );
 
 glBufferData( GL_ELEMENT_ARRAY_BUFFER, sizeof( GLushort ) * bbox_tmp_indices.size(),
 u16buf.get(), GL_STATIC_DRAW );
 }
 else
 {
 m_bbox_index_buffer_type = GL_UNSIGNED_INT;
 glBufferData( GL_ELEMENT_ARRAY_BUFFER, sizeof( GLuint ) * bbox_tmp_indices.size(),
 bbox_tmp_indices.data(), GL_STATIC_DRAW );
 }
 
 // merge the mesh group geometry data.
 unsigned int total_vertex_count = 0;
 unsigned int total_index_count = 0;
 
 for( const MESH_GROUP& mg : mesh_groups )
 {
 total_vertex_count += mg.m_vertices.size();
 total_index_count += mg.m_indices.size();
 }
 
 wxLogTrace( m_logTrace, wxT( " total %u vertices, %u indices" ),
 total_vertex_count, total_index_count );
 
 glBindBuffer( GL_ARRAY_BUFFER, m_vertex_buffer );
 glBufferData( GL_ARRAY_BUFFER, sizeof( VERTEX ) * total_vertex_count,
 nullptr, GL_STATIC_DRAW );
 
 unsigned int idx_size = 0;
 
 if( total_vertex_count <= std::numeric_limits<GLushort>::max() )
 {
 m_index_buffer_type = GL_UNSIGNED_SHORT;
 idx_size = sizeof( GLushort );
 }
 else
 {
 m_index_buffer_type = GL_UNSIGNED_INT;
 idx_size = sizeof( GLuint );
 }
 
 // temporary index buffer which will contain either GLushort or GLuint
 // type indices. allocate with a bit of meadow at the end.
 auto tmp_idx = std::make_unique<GLuint[]>( ( idx_size * total_index_count + 8 ) / sizeof( GLuint ) );
 
 unsigned int prev_vtx_count = 0;
 unsigned int idx_offset = 0;
 unsigned int vtx_offset = 0;
 
 for( unsigned int mg_i = 0; mg_i < mesh_groups.size (); ++mg_i )
 {
 MESH_GROUP& mg = mesh_groups[mg_i];
 MATERIAL& mat = m_materials[mg_i];
 uintptr_t tmp_idx_ptr = reinterpret_cast<uintptr_t>( tmp_idx.get() );
 
 if( m_index_buffer_type == GL_UNSIGNED_SHORT )
 {
 GLushort* idx_out = reinterpret_cast<GLushort*>( tmp_idx_ptr + idx_offset );
 
 for( GLuint idx : mg.m_indices )
 *idx_out++ = static_cast<GLushort>( idx + prev_vtx_count );
 }
 else if( m_index_buffer_type == GL_UNSIGNED_INT )
 {
 GLuint* idx_out = reinterpret_cast<GLuint*>( tmp_idx_ptr + idx_offset );
 
 for( GLuint idx : mg.m_indices )
 *idx_out++ = static_cast<GLuint>( idx + prev_vtx_count );
 }
 
 glBufferSubData( GL_ARRAY_BUFFER, vtx_offset, mg.m_vertices.size() * sizeof( VERTEX ),
 mg.m_vertices.data() );
 
 mat.m_render_idx_buffer_offset = idx_offset;
 mat.m_render_idx_count = mg.m_indices.size();
 
 prev_vtx_count += mg.m_vertices.size();
 idx_offset += mg.m_indices.size() * idx_size;
 vtx_offset += mg.m_vertices.size() * sizeof( VERTEX );
 }
 
 glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, m_index_buffer );
 glBufferData( GL_ELEMENT_ARRAY_BUFFER, idx_size * total_index_count, tmp_idx.get(),
 GL_STATIC_DRAW );
 
 glBindBuffer( GL_ARRAY_BUFFER, 0 );
 glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, 0 );
 
 auto end_time = std::chrono::high_resolution_clock::now();
 
 wxLogTrace( m_logTrace, wxT( " loaded in %u ms\n" ),
 (unsigned int)std::chrono::duration_cast<std::chrono::milliseconds> (
  end_time - start_time).count() );
}

References bbox_idx_count, bbox_vtx_count, DIFFUSE_ONLY, BBOX_3D::IsInitialized(), MODEL_3D::MATERIAL::IsTransparent(), MODEL_3D::MATERIAL::m_bbox, m_bbox_index_buffer, m_bbox_index_buffer_type, m_bbox_vertex_buffer, MODEL_3D::VERTEX::m_cad_color, MODEL_3D::VERTEX::m_color, SMESH::m_Color, SMATERIAL::m_Diffuse, SMESH::m_FaceIdx, SMESH::m_FaceIdxSize, m_have_opaque_meshes, m_have_transparent_meshes, m_index_buffer, m_index_buffer_type, m_logTrace, SMESH::m_MaterialIdx, m_materialMode, m_materials, S3DMODEL::m_Materials, S3DMODEL::m_MaterialsSize, S3DMODEL::m_Meshes, m_meshes_bbox, S3DMODEL::m_MeshesSize, m_model_bbox, SMESH::m_Normals, MODEL_3D::VERTEX::m_nrm, MODEL_3D::VERTEX::m_pos, SMESH::m_Positions, MODEL_3D::MATERIAL::m_render_idx_buffer_offset, MODEL_3D::MATERIAL::m_render_idx_count, MODEL_3D::VERTEX::m_tex_uv, SMESH::m_Texcoords, SMATERIAL::m_Transparency, m_vertex_buffer, SMESH::m_VertexSize, MakeBbox(), MaterialDiffuseToColorCAD(), and BBOX_3D::Union().

~MODEL_3D()

MODEL_3D::~MODEL_3D

(

)

Definition at line 560 of file 3d_model.cpp.

{
 if( glDeleteBuffers )
 {
 glDeleteBuffers( 1, &m_vertex_buffer );
 glDeleteBuffers( 1, &m_index_buffer );
 glDeleteBuffers( 1, &m_bbox_vertex_buffer );
 glDeleteBuffers( 1, &m_bbox_index_buffer );
 }
}

References m_bbox_index_buffer, m_bbox_vertex_buffer, m_index_buffer, and m_vertex_buffer.

Member Function Documentation

BeginDrawMulti()

void MODEL_3D::BeginDrawMulti ( bool  aUseColorInformation )

static

Set some basic render states before drawing multiple models.

Definition at line 389 of file 3d_model.cpp.

{
 glEnableClientState( GL_VERTEX_ARRAY );
 glEnableClientState( GL_NORMAL_ARRAY );
 
 if( aUseColorInformation )
 {
 glEnableClientState( GL_COLOR_ARRAY );
 glEnableClientState( GL_TEXTURE_COORD_ARRAY );
 glEnable( GL_COLOR_MATERIAL );
 }
 
 glColorMaterial( GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE );
}

Referenced by EDA_3D_MODEL_VIEWER::OnPaint(), RENDER_3D_OPENGL::renderOpaqueModels(), and RENDER_3D_OPENGL::renderTransparentModels().

Draw()

void MODEL_3D::Draw	(	bool	aTransparent,
		float	aOpacity,
		bool	aUseSelectedMaterial,
		const SFVEC3F &	aSelectionColor,
		const glm::mat4 *	aModelWorldMatrix,
		const SFVEC3F *	aCameraWorldPos
	)		const

Render the model into the current context.

if aModelWorldMatrix and aCameraWorldPos is provided, it renders the material groups sorted.

Definition at line 418 of file 3d_model.cpp.

{
 if( aOpacity <= FLT_EPSILON )
 return;
 
  if( !glBindBuffer )
 throw std::runtime_error( "The OpenGL context no longer exists: unable to draw" );
 
 glBindBuffer( GL_ARRAY_BUFFER, m_vertex_buffer );
 glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, m_index_buffer );
 
 glVertexPointer( 3, GL_FLOAT, sizeof( VERTEX ),
 reinterpret_cast<const void*>( offsetof( VERTEX, m_pos ) ) );
 
 glNormalPointer( GL_BYTE, sizeof( VERTEX ),
 reinterpret_cast<const void*>( offsetof( VERTEX, m_nrm ) ) );
 
 glColorPointer( 4, GL_UNSIGNED_BYTE, sizeof( VERTEX ),
 reinterpret_cast<const void*>( m_materialMode == MATERIAL_MODE::CAD_MODE
 ? offsetof( VERTEX, m_cad_color )
 : offsetof( VERTEX, m_color ) ) );
 
 glTexCoordPointer( 2, GL_FLOAT, sizeof( VERTEX ),
 reinterpret_cast<const void*>( offsetof( VERTEX, m_tex_uv ) ) );
 
 const SFVEC4F param = SFVEC4F( 1.0f, 1.0f, 1.0f, aOpacity );
 
 glTexEnvfv( GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, (const float*)&param.x );
 
 std::vector<const MODEL_3D::MATERIAL *> materialsToRender;
 
 materialsToRender.reserve( m_materials.size() );
 
 if( aModelWorldMatrix && aCameraWorldPos )
 {
 // Sort Material groups
 
 std::vector<std::pair<const MODEL_3D::MATERIAL*, float>> materialsSorted;
 
 // Calculate the distance to the camera for each material group
 for( const MODEL_3D::MATERIAL& mat : m_materials )
 {
 if( mat.m_render_idx_count == 0 )
 {
 continue;
 }
 
 if( ( mat.IsTransparent() != aTransparent )
 && ( aOpacity >= 1.0f )
 && m_materialMode != MATERIAL_MODE::DIFFUSE_ONLY )
 {
 continue;
 }
 
 const BBOX_3D& bBox = mat.m_bbox;
 const SFVEC3F& bBoxCenter = bBox.GetCenter();
 const SFVEC3F bBoxWorld = *aModelWorldMatrix * glm::vec4( bBoxCenter, 1.0f );
 
 const float distanceToCamera = glm::length( *aCameraWorldPos - bBoxWorld );
 
 materialsSorted.emplace_back( &mat, distanceToCamera );
 }
 
 // Sort from back to front
 std::sort( materialsSorted.begin(), materialsSorted.end(),
 [&]( std::pair<const MODEL_3D::MATERIAL*, float>& a,
 std::pair<const MODEL_3D::MATERIAL*, float>& b ) {
 // If A is inside B, then A is rendered first
 if( b.first->m_bbox.Inside( a.first->m_bbox ) )
 {
 return true;
 }
 else
 {
 if( a.first->m_bbox.Inside( b.first->m_bbox ) )
 {
 return false;
 }
 }
 
 return a.second > b.second;
 } );
 
 for( const std::pair<const MODEL_3D::MATERIAL*, float>& mat : materialsSorted )
 {
 materialsToRender.push_back( mat.first );
 }
 }
 else
 {
 for( const MODEL_3D::MATERIAL& mat : m_materials )
 {
 // There is at least one default material created in case a mesh has no declared materials.
 // Most meshes have a material, so usually the first material will have nothing to render and is skip.
 // See S3D::GetModel for more details.
 if( mat.m_render_idx_count == 0 )
 {
 continue;
  }
 
 if( ( mat.IsTransparent() != aTransparent )
 && ( aOpacity >= 1.0f )
 && m_materialMode != MATERIAL_MODE::DIFFUSE_ONLY )
 {
 continue;
 }
 
 materialsToRender.push_back( &mat );
 }
 } 
 
 for( const MODEL_3D::MATERIAL* mat : materialsToRender )
 {
 switch( m_materialMode )
 {
 case MATERIAL_MODE::NORMAL:
 OglSetMaterial( *mat, aOpacity, aUseSelectedMaterial, aSelectionColor );
 break;
 
 case MATERIAL_MODE::DIFFUSE_ONLY:
 OglSetDiffuseMaterial( mat->m_Diffuse, aOpacity, aUseSelectedMaterial, aSelectionColor );
 break;
 
 case MATERIAL_MODE::CAD_MODE:
 OglSetDiffuseMaterial( MaterialDiffuseToColorCAD( mat->m_Diffuse ), aOpacity,
 aUseSelectedMaterial, aSelectionColor );
 break;
 
 default:
 break;
 }
 
 glDrawElements( GL_TRIANGLES, mat->m_render_idx_count, m_index_buffer_type,
 reinterpret_cast<const void*>(
 static_cast<uintptr_t>( mat->m_render_idx_buffer_offset ) ) );
 }
}

References CAD_MODE, DIFFUSE_ONLY, BBOX_3D::GetCenter(), m_index_buffer, m_materialMode, m_materials, and m_vertex_buffer.

Referenced by DrawOpaque(), DrawTransparent(), and RENDER_3D_OPENGL::renderModel().

DrawBbox()

void MODEL_3D::DrawBbox

(

)

const

Draw main bounding box of the model.

Definition at line 572 of file 3d_model.cpp.

{
 if( !glBindBuffer )
 throw std::runtime_error( "The OpenGL context no longer exists: unable to draw bbox" );
 
 glBindBuffer( GL_ARRAY_BUFFER, m_bbox_vertex_buffer );
 glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, m_bbox_index_buffer );
 
 glVertexPointer( 3, GL_FLOAT, sizeof( VERTEX ),
 reinterpret_cast<const void*>( offsetof( VERTEX, m_pos ) ) );
 
 glColorPointer( 4, GL_UNSIGNED_BYTE, sizeof( VERTEX ),
 reinterpret_cast<const void*>( offsetof( VERTEX, m_color ) ) );
 
 glDrawElements( GL_LINES, bbox_idx_count, m_bbox_index_buffer_type,
 reinterpret_cast<const void*>( 0 ) );
}

References bbox_idx_count, m_bbox_index_buffer, m_bbox_index_buffer_type, and m_bbox_vertex_buffer.

Referenced by RENDER_3D_OPENGL::renderModel().

DrawBboxes()

void MODEL_3D::DrawBboxes

(

)

const

Draw individual bounding boxes of each mesh.

Definition at line 591 of file 3d_model.cpp.

{
 if( !glBindBuffer )
 throw std::runtime_error( "The OpenGL context no longer exists: unable to draw bboxes" );
 
 glBindBuffer( GL_ARRAY_BUFFER, m_bbox_vertex_buffer );
 glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, m_bbox_index_buffer );
 
 glVertexPointer( 3, GL_FLOAT, sizeof( VERTEX ),
 reinterpret_cast<const void*>( offsetof( VERTEX, m_pos ) ) );
 
 glColorPointer( 4, GL_UNSIGNED_BYTE, sizeof( VERTEX ),
 reinterpret_cast<const void*>( offsetof( VERTEX, m_color ) ) );
 
 unsigned int idx_size = m_bbox_index_buffer_type == GL_UNSIGNED_SHORT ? sizeof( GLushort )
 : sizeof( GLuint );
 
 glDrawElements( GL_LINES, bbox_idx_count * m_meshes_bbox.size(), m_bbox_index_buffer_type,
 reinterpret_cast<const void*>( 
 static_cast<uintptr_t>( bbox_idx_count * idx_size ) ) );
}

References bbox_idx_count, m_bbox_index_buffer, m_bbox_index_buffer_type, m_bbox_vertex_buffer, and m_meshes_bbox.

Referenced by RENDER_3D_OPENGL::renderModel().

DrawOpaque()

void MODEL_3D::DrawOpaque ( bool  aUseSelectedMaterial, SFVEC3F  aSelectionColor = SFVEC3F( 0.0f )  ) const

inline

Render the model into the current context.

Definition at line 55 of file 3d_model.h.

 {
 Draw( false, 1.0f, aUseSelectedMaterial, aSelectionColor, nullptr, nullptr );
 }

References Draw().

Referenced by EDA_3D_MODEL_VIEWER::OnPaint().

DrawTransparent()

void MODEL_3D::DrawTransparent ( float  aOpacity, bool  aUseSelectedMaterial, SFVEC3F  aSelectionColor = SFVEC3F( 0.0f )  ) const

inline

Render the model into the current context.

Definition at line 63 of file 3d_model.h.

 {
 Draw( true, aOpacity, aUseSelectedMaterial, aSelectionColor, nullptr, nullptr );
 }

References Draw().

Referenced by EDA_3D_MODEL_VIEWER::OnPaint().

EndDrawMulti()

void MODEL_3D::EndDrawMulti ( )

static

Cleanup render states after drawing multiple models.

Definition at line 405 of file 3d_model.cpp.

{
 glDisable( GL_COLOR_MATERIAL );
 glDisableClientState( GL_VERTEX_ARRAY );
 glDisableClientState( GL_NORMAL_ARRAY );
 glDisableClientState( GL_COLOR_ARRAY );
 glDisableClientState( GL_TEXTURE_COORD_ARRAY );
 
 glBindBuffer( GL_ARRAY_BUFFER, 0 );
 glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, 0 );
}

Referenced by EDA_3D_MODEL_VIEWER::OnPaint(), RENDER_3D_OPENGL::renderOpaqueModels(), and RENDER_3D_OPENGL::renderTransparentModels().

GetBBox()

const BBOX_3D & MODEL_3D::GetBBox ( ) const

inline

Get the main bounding box.

Returns

the main model bounding box.

Definition at line 103 of file 3d_model.h.

{ return m_model_bbox; }

References m_model_bbox.

Referenced by EDA_3D_MODEL_VIEWER::OnPaint().

HasOpaqueMeshes()

bool MODEL_3D::HasOpaqueMeshes ( ) const

inline

Return true if have opaque meshes to render.

Definition at line 82 of file 3d_model.h.

{ return m_have_opaque_meshes; }

References m_have_opaque_meshes.

HasTransparentMeshes()

bool MODEL_3D::HasTransparentMeshes ( ) const

inline

Return true if have transparent mesh's to render.

Definition at line 87 of file 3d_model.h.

{ return m_have_transparent_meshes; }

References m_have_transparent_meshes.

MakeBbox()

void MODEL_3D::MakeBbox ( const BBOX_3D &  aBox, unsigned int  aIdxOffset, VERTEX *  aVtxOut, GLuint *  aIdxOut, const glm::vec4 &  aColor  )

staticprivate

Definition at line 52 of file 3d_model.cpp.

{
 aVtxOut[0].m_pos = { aBox.Min().x, aBox.Min().y, aBox.Min().z };
 aVtxOut[1].m_pos = { aBox.Max().x, aBox.Min().y, aBox.Min().z };
 aVtxOut[2].m_pos = { aBox.Max().x, aBox.Max().y, aBox.Min().z };
 aVtxOut[3].m_pos = { aBox.Min().x, aBox.Max().y, aBox.Min().z };
 
 aVtxOut[4].m_pos = { aBox.Min().x, aBox.Min().y, aBox.Max().z };
 aVtxOut[5].m_pos = { aBox.Max().x, aBox.Min().y, aBox.Max().z };
 aVtxOut[6].m_pos = { aBox.Max().x, aBox.Max().y, aBox.Max().z };
 aVtxOut[7].m_pos = { aBox.Min().x, aBox.Max().y, aBox.Max().z };
 
 for( unsigned int i = 0; i < 8; ++i )
 aVtxOut[i].m_color = aVtxOut[i].m_cad_color = glm::clamp( aColor * 255.0f, 0.0f, 255.0f );
 
 #define bbox_line( vtx_a, vtx_b )\
 do { *aIdxOut++ = vtx_a + aIdxOffset; \
 *aIdxOut++ = vtx_b + aIdxOffset; } while( 0 )
 
 bbox_line( 0, 1 );
 bbox_line( 1, 2 );
 bbox_line( 2, 3 );
 bbox_line( 3, 0 );
 
 bbox_line( 4, 5 );
 bbox_line( 5, 6 );
 bbox_line( 6, 7 );
 bbox_line( 7, 4 );
 
 bbox_line( 0, 4 );
 bbox_line( 1, 5 );
 bbox_line( 2, 6 );
 bbox_line( 3, 7 );
 
 #undef bbox_line
}

References bbox_line, MODEL_3D::VERTEX::m_pos, BBOX_3D::Max(), and BBOX_3D::Min().

Referenced by MODEL_3D().

Member Data Documentation

bbox_idx_count

constexpr unsigned int MODEL_3D::bbox_idx_count = 24

staticconstexprprivate

Definition at line 166 of file 3d_model.h.

Referenced by DrawBbox(), DrawBboxes(), and MODEL_3D().

bbox_vtx_count

constexpr unsigned int MODEL_3D::bbox_vtx_count = 8

staticconstexprprivate

Definition at line 165 of file 3d_model.h.

Referenced by MODEL_3D().

m_bbox_index_buffer

GLuint MODEL_3D::m_bbox_index_buffer = 0

private

Definition at line 169 of file 3d_model.h.

Referenced by DrawBbox(), DrawBboxes(), MODEL_3D(), and ~MODEL_3D().

m_bbox_index_buffer_type

GLenum MODEL_3D::m_bbox_index_buffer_type = GL_INVALID_ENUM

private

Definition at line 170 of file 3d_model.h.

Referenced by DrawBbox(), DrawBboxes(), and MODEL_3D().

m_bbox_vertex_buffer

GLuint MODEL_3D::m_bbox_vertex_buffer = 0

private

Definition at line 168 of file 3d_model.h.

Referenced by DrawBbox(), DrawBboxes(), MODEL_3D(), and ~MODEL_3D().

m_have_opaque_meshes

bool MODEL_3D::m_have_opaque_meshes = false

private

Definition at line 160 of file 3d_model.h.

Referenced by HasOpaqueMeshes(), and MODEL_3D().

m_have_transparent_meshes

bool MODEL_3D::m_have_transparent_meshes = false

private

Definition at line 161 of file 3d_model.h.

Referenced by HasTransparentMeshes(), and MODEL_3D().

m_index_buffer

GLuint MODEL_3D::m_index_buffer = 0

private

Definition at line 139 of file 3d_model.h.

Referenced by Draw(), MODEL_3D(), and ~MODEL_3D().

m_index_buffer_type

GLenum MODEL_3D::m_index_buffer_type = GL_INVALID_ENUM

private

Definition at line 140 of file 3d_model.h.

Referenced by MODEL_3D().

m_logTrace

const wxChar * MODEL_3D::m_logTrace = wxT( "KI_TRACE_EDA_OGL_3DMODEL" )

staticprivate

Definition at line 116 of file 3d_model.h.

Referenced by MODEL_3D().

m_materialMode

MATERIAL_MODE MODEL_3D::m_materialMode

private

Definition at line 121 of file 3d_model.h.

Referenced by Draw(), and MODEL_3D().

m_materials

std::vector<MATERIAL> MODEL_3D::m_materials

private

Definition at line 155 of file 3d_model.h.

Referenced by Draw(), and MODEL_3D().

m_meshes_bbox

std::vector<BBOX_3D> MODEL_3D::m_meshes_bbox

private

individual bbox for each mesh

Definition at line 124 of file 3d_model.h.

Referenced by DrawBboxes(), and MODEL_3D().

m_model_bbox

BBOX_3D MODEL_3D::m_model_bbox

private

global bounding box for this model

Definition at line 123 of file 3d_model.h.

Referenced by GetBBox(), and MODEL_3D().

m_vertex_buffer

GLuint MODEL_3D::m_vertex_buffer = 0

private

Definition at line 138 of file 3d_model.h.

Referenced by Draw(), MODEL_3D(), and ~MODEL_3D().

---

The documentation for this class was generated from the following files:

• 3d_model.h
• 3d_model.cpp