mirror of
https://github.com/mcneel/opennurbs.git
synced 2026-03-01 19:46:08 +08:00
467 lines
12 KiB
C++
467 lines
12 KiB
C++
#include "opennurbs.h"
|
|
|
|
#if !defined(ON_COMPILING_OPENNURBS)
|
|
// This check is included in all opennurbs source .c and .cpp files to insure
|
|
// ON_COMPILING_OPENNURBS is defined when opennurbs source is compiled.
|
|
// When opennurbs source is being compiled, ON_COMPILING_OPENNURBS is defined
|
|
// and the opennurbs .h files alter what is declared and how it is declared.
|
|
#error ON_COMPILING_OPENNURBS must be defined when compiling opennurbs
|
|
#endif
|
|
|
|
#include "opennurbs_subd_data.h"
|
|
|
|
/* $NoKeywords: $ */
|
|
/*
|
|
//
|
|
// Copyright (c) 1993-2015 Robert McNeel & Associates. All rights reserved.
|
|
// OpenNURBS, Rhinoceros, and Rhino3D are registered trademarks of Robert
|
|
// McNeel & Associates.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY.
|
|
// ALL IMPLIED WARRANTIES OF FITNESS FOR ANY PARTICULAR PURPOSE AND OF
|
|
// MERCHANTABILITY ARE HEREBY DISCLAIMED.
|
|
//
|
|
// For complete openNURBS copyright information see <http://www.opennurbs.org>.
|
|
//
|
|
////////////////////////////////////////////////////////////////
|
|
*/
|
|
|
|
#if defined(OPENNURBS_SUBD_WIP)
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// ON_SubDRef
|
|
//
|
|
|
|
ON_SubDRef::ON_SubDRef() ON_NOEXCEPT
|
|
{}
|
|
|
|
ON_SubDRef::~ON_SubDRef()
|
|
{
|
|
m_subd_sp.reset();
|
|
}
|
|
|
|
ON_SubDRef::ON_SubDRef(const ON_SubDRef& src) ON_NOEXCEPT
|
|
: m_subd_sp(src.m_subd_sp)
|
|
{}
|
|
|
|
ON_SubDRef& ON_SubDRef::operator=(const ON_SubDRef& src)
|
|
{
|
|
if ( this != &src )
|
|
m_subd_sp = src.m_subd_sp;
|
|
return *this;
|
|
}
|
|
|
|
#if defined(ON_HAS_RVALUEREF)
|
|
// rvalue copy constructor
|
|
ON_SubDRef::ON_SubDRef( ON_SubDRef&& src) ON_NOEXCEPT
|
|
: m_subd_sp(std::move(src.m_subd_sp))
|
|
{}
|
|
|
|
// rvalue assignment operator
|
|
ON_SubDRef& ON_SubDRef::operator=(ON_SubDRef&& src)
|
|
{
|
|
m_subd_sp.reset();
|
|
m_subd_sp = std::move(src.m_subd_sp);
|
|
return *this;
|
|
}
|
|
#endif
|
|
|
|
const class ON_SubD& ON_SubDRef::SubD() const
|
|
{
|
|
const ON_SubD* subd = m_subd_sp.get();
|
|
if ( nullptr == subd )
|
|
subd = &ON_SubD::Empty;
|
|
return *subd;
|
|
}
|
|
|
|
unsigned int ON_SubDRef::ReferenceCount() const
|
|
{
|
|
return (unsigned int)m_subd_sp.use_count();
|
|
}
|
|
|
|
void ON_SubDRef::Clear()
|
|
{
|
|
m_subd_sp.reset();
|
|
}
|
|
|
|
class ON_SubD& ON_SubDRef::NewSubD()
|
|
{
|
|
ON_SubD* subd = new ON_SubD();
|
|
ON_SubD* managed_subd = SetSubDForExperts(subd);
|
|
return *managed_subd;
|
|
}
|
|
|
|
class ON_SubD& ON_SubDRef::CopySubD(
|
|
const ON_SubDRef& src
|
|
)
|
|
{
|
|
return CopySubD(src.SubD());
|
|
}
|
|
|
|
class ON_SubD& ON_SubDRef::CopySubD(
|
|
const ON_SubD& src
|
|
)
|
|
{
|
|
ON_SubD* subd_copy = new ON_SubD(src);
|
|
ON_SubD* managed_subd = SetSubDForExperts(subd_copy);
|
|
return *managed_subd;
|
|
}
|
|
|
|
class ON_SubD& ON_SubDRef::UniqueSubD()
|
|
{
|
|
const ON_SubD& subd = SubD();
|
|
if (m_subd_sp.use_count() > 1 )
|
|
return CopySubD(subd);
|
|
if (subd.m_subdimple_sp.use_count() > 1)
|
|
return CopySubD(subd);
|
|
return const_cast< ON_SubD& >(subd);
|
|
}
|
|
|
|
class ON_SubD* ON_SubDRef::SetSubDForExperts(
|
|
class ON_SubD*& subd
|
|
)
|
|
{
|
|
Clear();
|
|
ON_SubD* managed_subd = ( subd == &ON_SubD::Empty ) ? nullptr : subd;
|
|
subd = nullptr;
|
|
if (nullptr != managed_subd )
|
|
m_subd_sp = std::shared_ptr<class ON_SubD>(managed_subd);
|
|
return managed_subd;
|
|
}
|
|
|
|
ON_SubDRef::ON_SubDRef(
|
|
const ON_SubD& subd
|
|
)
|
|
{
|
|
const ON_SubDimple* subdimple = subd.SubDimple();
|
|
if (nullptr != subdimple)
|
|
{
|
|
ON_SubD* managed_subd = new ON_SubD();
|
|
managed_subd->ShareDimple(subd);
|
|
this->SetSubDForExperts(managed_subd);
|
|
if (nullptr != managed_subd)
|
|
delete managed_subd;
|
|
}
|
|
}
|
|
|
|
ON_SubDRef ON_SubDRef::CreateReferenceForExperts(
|
|
const ON_SubD& subd
|
|
)
|
|
{
|
|
ON_SubDRef subd_ref(subd);
|
|
return subd_ref;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// ON_SubDComponentRef
|
|
//
|
|
|
|
ON_OBJECT_IMPLEMENT(ON_SubDComponentRef,ON_Geometry,"C221FC6D-36B7-47E8-90AA-AC8EC784E3DD");
|
|
|
|
ON_SubDComponentRef::ON_SubDComponentRef(const ON_SubDComponentRef& src) ON_NOEXCEPT
|
|
: ON_Geometry(src)
|
|
, m_subd_ref(src.m_subd_ref)
|
|
, m_component_ptr(src.m_component_ptr)
|
|
, m_component_index(src.m_component_index)
|
|
{}
|
|
|
|
ON_SubDComponentRef& ON_SubDComponentRef::operator=(const ON_SubDComponentRef& src)
|
|
{
|
|
if (this != &src)
|
|
{
|
|
ON_Geometry::operator=(src);
|
|
m_subd_ref = src.m_subd_ref;
|
|
m_component_ptr = src.m_component_ptr;
|
|
m_component_index = src.m_component_index;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
#if defined(ON_HAS_RVALUEREF)
|
|
ON_SubDComponentRef::ON_SubDComponentRef( ON_SubDComponentRef&& src ) ON_NOEXCEPT
|
|
: ON_Geometry(std::move(src))
|
|
, m_subd_ref(std::move(src.m_subd_ref))
|
|
, m_component_ptr(src.m_component_ptr)
|
|
, m_component_index(src.m_component_index)
|
|
{}
|
|
|
|
ON_SubDComponentRef& ON_SubDComponentRef::operator=(ON_SubDComponentRef&& src)
|
|
{
|
|
if ( this != &src )
|
|
{
|
|
Clear();
|
|
ON_Geometry::operator=(std::move(src));
|
|
m_subd_ref = std::move(src.m_subd_ref);
|
|
m_component_ptr = src.m_component_ptr;
|
|
m_component_index = src.m_component_index;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
#endif
|
|
|
|
ON_SubDComponentRef ON_SubDComponentRef::Create(
|
|
const ON_SubDRef& subd_ref,
|
|
ON_COMPONENT_INDEX component_index,
|
|
ON_SubDComponentLocation component_location
|
|
)
|
|
{
|
|
ON_SubDComponentPtr component_ptr = subd_ref.SubD().ComponentPtrFromComponentIndex(component_index);
|
|
return ON_SubDComponentRef::Create(subd_ref,component_ptr,component_location);
|
|
}
|
|
|
|
ON_SubDComponentRef ON_SubDComponentRef::Create(
|
|
const ON_SubDRef& subd_ref,
|
|
ON_SubDComponentPtr component_ptr,
|
|
ON_SubDComponentLocation component_location
|
|
)
|
|
{
|
|
ON_SubDComponentRef component_ref;
|
|
component_ref.m_subd_ref = subd_ref;
|
|
bool bValidInput = false;
|
|
switch (component_ptr.ComponentType())
|
|
{
|
|
case ON_SubDComponentPtr::Type::Vertex:
|
|
{
|
|
const ON_SubDVertex* vertex = ON_SUBD_VERTEX_POINTER(component_ptr.m_ptr);
|
|
if (nullptr != vertex && vertex->m_id > 0 && vertex->m_id < ON_UNSET_UINT_INDEX)
|
|
{
|
|
component_ref.m_component_ptr = component_ptr;
|
|
component_ref.m_component_index.Set(ON_COMPONENT_INDEX::TYPE::subd_vertex,(int)vertex->m_id);
|
|
component_ref.m_component_location = component_location;
|
|
bValidInput = true;
|
|
}
|
|
}
|
|
break;
|
|
case ON_SubDComponentPtr::Type::Edge:
|
|
{
|
|
const ON_SubDEdge* edge = ON_SUBD_EDGE_POINTER(component_ptr.m_ptr);
|
|
if (nullptr != edge && edge->m_id > 0 && edge->m_id < ON_UNSET_UINT_INDEX)
|
|
{
|
|
component_ref.m_component_ptr = component_ptr;
|
|
component_ref.m_component_index.Set(ON_COMPONENT_INDEX::TYPE::subd_edge,(int)edge->m_id);
|
|
component_ref.m_component_location = component_location;
|
|
bValidInput = true;
|
|
}
|
|
}
|
|
break;
|
|
case ON_SubDComponentPtr::Type::Face:
|
|
{
|
|
const ON_SubDFace* face = ON_SUBD_FACE_POINTER(component_ptr.m_ptr);
|
|
if (nullptr != face && face->m_id > 0 && face->m_id < ON_UNSET_UINT_INDEX)
|
|
{
|
|
component_ref.m_component_ptr = component_ptr;
|
|
component_ref.m_component_index.Set(ON_COMPONENT_INDEX::TYPE::subd_face,(int)face->m_id);
|
|
component_ref.m_component_location = component_location;
|
|
bValidInput = true;
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
if ( component_ptr.IsNull() )
|
|
bValidInput = true;
|
|
}
|
|
|
|
if (bValidInput)
|
|
{
|
|
return component_ref;
|
|
}
|
|
|
|
return ON_SUBD_RETURN_ERROR(component_ref);
|
|
}
|
|
|
|
ON_SubDComponentRef ON_SubDComponentRef::Create(
|
|
const ON_SubDRef& subd_ref,
|
|
const class ON_SubDVertex* vertex,
|
|
ON_SubDComponentLocation component_location
|
|
)
|
|
{
|
|
return ON_SubDComponentRef::Create(subd_ref, ON_SubDComponentPtr::Create(vertex),component_location);
|
|
}
|
|
|
|
ON_SubDComponentRef ON_SubDComponentRef::Create(
|
|
const ON_SubDRef& subd_ref,
|
|
const class ON_SubDEdge* edge,
|
|
ON_SubDComponentLocation component_location
|
|
)
|
|
{
|
|
return ON_SubDComponentRef::Create(subd_ref, ON_SubDComponentPtr::Create(edge),component_location);
|
|
}
|
|
|
|
ON_SubDComponentRef ON_SubDComponentRef::Create(
|
|
const ON_SubDRef& subd_ref,
|
|
const class ON_SubDFace* face,
|
|
ON_SubDComponentLocation component_location
|
|
)
|
|
{
|
|
return ON_SubDComponentRef::Create(subd_ref, ON_SubDComponentPtr::Create(face),component_location);
|
|
}
|
|
|
|
void ON_SubDComponentRef::Clear()
|
|
{
|
|
ON_Geometry::DestroyRuntimeCache();
|
|
PurgeUserData();
|
|
m_subd_ref.Clear();
|
|
m_component_ptr = ON_SubDComponentPtr::Null;
|
|
m_component_index = ON_COMPONENT_INDEX::UnsetComponentIndex;
|
|
}
|
|
|
|
ON_SubDRef ON_SubDComponentRef::SubDRef() const
|
|
{
|
|
return m_subd_ref;
|
|
}
|
|
|
|
const class ON_SubD& ON_SubDComponentRef::SubD() const
|
|
{
|
|
return m_subd_ref.SubD();
|
|
}
|
|
|
|
ON_COMPONENT_INDEX ON_SubDComponentRef::ComponentIndex() const
|
|
{
|
|
return m_component_index;
|
|
}
|
|
|
|
ON_SubDComponentPtr ON_SubDComponentRef::ComponentPtr() const
|
|
{
|
|
return m_component_ptr;
|
|
}
|
|
|
|
ON_SubDComponentLocation ON_SubDComponentRef::ComponentLocation() const
|
|
{
|
|
return m_component_location;
|
|
}
|
|
|
|
const class ON_SubDVertex* ON_SubDComponentRef::Vertex() const
|
|
{
|
|
return m_component_ptr.Vertex();
|
|
}
|
|
|
|
const class ON_SubDEdge* ON_SubDComponentRef::Edge() const
|
|
{
|
|
return m_component_ptr.Edge();
|
|
}
|
|
|
|
const class ON_SubDFace* ON_SubDComponentRef::Face() const
|
|
{
|
|
return m_component_ptr.Face();
|
|
}
|
|
|
|
bool ON_SubDComponentRef::IsValid(ON_TextLog* text_log) const
|
|
{
|
|
return (
|
|
m_component_ptr.IsNotNull()
|
|
&& (ON_SubDComponentLocation::ControlNet == m_component_location || ON_SubDComponentLocation::LimitSurface == m_component_location)
|
|
&& false == SubD().IsEmpty()
|
|
);
|
|
}
|
|
|
|
void ON_SubDComponentRef::Dump(ON_TextLog& text_log) const
|
|
{
|
|
return;
|
|
}
|
|
|
|
unsigned int ON_SubDComponentRef::SizeOf() const
|
|
{
|
|
size_t sz = ON_Geometry::SizeOf() + sizeof(*this) - sizeof(ON_Geometry);
|
|
return (unsigned int)sz;
|
|
}
|
|
|
|
ON::object_type ON_SubDComponentRef::ObjectType() const
|
|
{
|
|
return ON::object_type::subd_object;
|
|
}
|
|
|
|
// overrides of virtual ON_Geometry functions
|
|
int ON_SubDComponentRef::Dimension() const
|
|
{
|
|
return 3;
|
|
}
|
|
|
|
bool ON_SubDComponentRef::GetBBox(
|
|
double* boxmin,
|
|
double* boxmax,
|
|
bool bGrowBox
|
|
) const
|
|
{
|
|
if ( nullptr == boxmin || nullptr == boxmax )
|
|
return false;
|
|
|
|
ON_BoundingBox bbox = ON_BoundingBox::EmptyBoundingBox;
|
|
|
|
switch (m_component_ptr.ComponentType())
|
|
{
|
|
case ON_SubDComponentPtr::Type::Vertex:
|
|
{
|
|
const ON_SubDVertex* vertex = m_component_ptr.Vertex();
|
|
if ( nullptr == vertex )
|
|
break;
|
|
switch (m_component_location)
|
|
{
|
|
case ON_SubDComponentLocation::ControlNet:
|
|
bbox = vertex->ControlNetBoundingBox();
|
|
break;
|
|
case ON_SubDComponentLocation::LimitSurface:
|
|
bbox = vertex->LimitSurfaceBoundingBox(SubD());
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case ON_SubDComponentPtr::Type::Edge:
|
|
{
|
|
const ON_SubDEdge* edge = m_component_ptr.Edge();
|
|
if ( nullptr == edge )
|
|
break;
|
|
switch (m_component_location)
|
|
{
|
|
case ON_SubDComponentLocation::ControlNet:
|
|
bbox = edge->ControlNetBoundingBox();
|
|
break;
|
|
case ON_SubDComponentLocation::LimitSurface:
|
|
bbox = edge->LimitSurfaceBoundingBox(SubD());
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case ON_SubDComponentPtr::Type::Face:
|
|
{
|
|
const ON_SubDFace* face = m_component_ptr.Face();
|
|
if ( nullptr == face )
|
|
break;
|
|
switch (m_component_location)
|
|
{
|
|
case ON_SubDComponentLocation::ControlNet:
|
|
bbox = face->ControlNetBoundingBox();
|
|
break;
|
|
case ON_SubDComponentLocation::LimitSurface:
|
|
bbox = face->LimitSurfaceBoundingBox(SubD());
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (bGrowBox)
|
|
{
|
|
ON_BoundingBox bbox1;
|
|
bbox1.m_min = boxmin;
|
|
bbox1.m_max = boxmax;
|
|
if (bbox1.IsValid())
|
|
bbox.Union(bbox1);
|
|
}
|
|
|
|
boxmin[0] = bbox.m_min.x;
|
|
boxmin[1] = bbox.m_min.y;
|
|
boxmin[2] = bbox.m_min.z;
|
|
|
|
boxmax[0] = bbox.m_max.x;
|
|
boxmax[1] = bbox.m_max.y;
|
|
boxmax[2] = bbox.m_max.z;
|
|
|
|
return bbox.IsValid();
|
|
}
|
|
|
|
|
|
#endif
|