mirror of
https://github.com/mcneel/opennurbs.git
synced 2026-03-01 03:26:09 +08:00
261 lines
8.6 KiB
C++
261 lines
8.6 KiB
C++
//
|
|
// Copyright (c) 1993-2022 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>.
|
|
//
|
|
////////////////////////////////////////////////////////////////
|
|
|
|
#include "opennurbs.h"
|
|
#include "opennurbs_internal_defines.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
|
|
|
|
static const wchar_t* XMLPath(void)
|
|
{
|
|
return ON_RDK_DOCUMENT ON_XML_SLASH ON_RDK_SETTINGS ON_XML_SLASH ON_RDK_GROUND_PLANE;
|
|
}
|
|
|
|
class ON_GroundPlane::CImpl : public ON_InternalXMLImpl
|
|
{
|
|
public:
|
|
CImpl() { }
|
|
CImpl(const CImpl& i) = delete;
|
|
CImpl(ON_XMLNode& n) : ON_InternalXMLImpl(&n) { }
|
|
|
|
bool Enabled(void) const { return GetParameter(XMLPath(), ON_RDK_GP_ENABLED, false).AsBool(); }
|
|
bool ShowUnderside(void) const { return GetParameter(XMLPath(), ON_RDK_GP_SHOW_UNDERSIDE, false).AsBool(); }
|
|
double Altitude(void) const { return GetParameter(XMLPath(), ON_RDK_GP_ALTITUDE, 0.0).AsDouble(); }
|
|
bool AutoAltitude(void) const { return GetParameter(XMLPath(), ON_RDK_GP_AUTO_ALTITUDE, false).AsBool(); }
|
|
bool ShadowOnly(void) const { return GetParameter(XMLPath(), ON_RDK_GP_SHADOW_ONLY, true).AsBool(); }
|
|
bool TextureOffsetLocked(void) const { return GetParameter(XMLPath(), ON_RDK_GP_TEXTURE_OFFSET_LOCKED, false).AsBool(); }
|
|
bool TextureSizeLocked(void) const { return GetParameter(XMLPath(), ON_RDK_GP_TEXTURE_SIZE_LOCKED, false).AsBool(); }
|
|
double TextureRotation(void) const { return GetParameter(XMLPath(), ON_RDK_GP_TEXTURE_ROTATION, false).AsDouble(); }
|
|
ON_UUID MaterialInstanceId(void) const { return GetParameter(XMLPath(), ON_RDK_GP_MATERIAL_ID, ON_nil_uuid).AsUuid(); }
|
|
ON_2dVector TextureOffset(void) const { return ON_2dVector(GetParameter(XMLPath(), ON_RDK_GP_TEXTURE_OFFSET, ON_nil_uuid).As2dPoint()); }
|
|
ON_2dVector TextureSize(void) const { return ON_2dVector(GetParameter(XMLPath(), ON_RDK_GP_TEXTURE_SIZE, ON_nil_uuid).As2dPoint()); }
|
|
|
|
void SetEnabled(bool v) { SetParameter(XMLPath(), ON_RDK_GP_ENABLED, v); }
|
|
void SetShowUnderside(bool v) { SetParameter(XMLPath(), ON_RDK_GP_SHOW_UNDERSIDE, v); }
|
|
void SetAltitude(double v) { SetParameter(XMLPath(), ON_RDK_GP_ALTITUDE, v); }
|
|
void SetAutoAltitude(bool v) { SetParameter(XMLPath(), ON_RDK_GP_AUTO_ALTITUDE, v); }
|
|
void SetShadowOnly(bool v) { SetParameter(XMLPath(), ON_RDK_GP_SHADOW_ONLY, v); }
|
|
void SetMaterialInstanceId(const ON_UUID& v) { SetParameter(XMLPath(), ON_RDK_GP_MATERIAL_ID, v); }
|
|
void SetTextureOffsetLocked(bool v) { SetParameter(XMLPath(), ON_RDK_GP_TEXTURE_OFFSET_LOCKED, v); }
|
|
void SetTextureSizeLocked(bool v) { SetParameter(XMLPath(), ON_RDK_GP_TEXTURE_SIZE_LOCKED, v); }
|
|
void SetTextureRotation(double v) { SetParameter(XMLPath(), ON_RDK_GP_TEXTURE_ROTATION, v); }
|
|
void SetTextureOffset(const ON_2dVector& v) { const ON_2dPoint p = v; SetParameter(XMLPath(), ON_RDK_GP_TEXTURE_OFFSET, p); }
|
|
void SetTextureSize(const ON_2dVector& v) { const ON_2dPoint p = v; SetParameter(XMLPath(), ON_RDK_GP_TEXTURE_SIZE, p); }
|
|
};
|
|
|
|
ON_GroundPlane::ON_GroundPlane()
|
|
{
|
|
_impl = new CImpl; // Uses local node.
|
|
}
|
|
|
|
ON_GroundPlane::ON_GroundPlane(ON_XMLNode& model_node)
|
|
{
|
|
_impl = new CImpl(model_node);
|
|
}
|
|
|
|
ON_GroundPlane::ON_GroundPlane(const ON_GroundPlane& gp)
|
|
{
|
|
_impl = new CImpl; // Uses local node.
|
|
operator = (gp);
|
|
}
|
|
|
|
ON_GroundPlane::~ON_GroundPlane()
|
|
{
|
|
delete _impl;
|
|
_impl = nullptr;
|
|
}
|
|
|
|
const ON_GroundPlane& ON_GroundPlane::operator = (const ON_GroundPlane& gp)
|
|
{
|
|
if (this != &gp)
|
|
{
|
|
// When copying the object, we need to directly copy the underlying XML. So we can't allow
|
|
// virtual overrides to execute because they might hide the real values we want to copy.
|
|
_impl->SetEnabled (gp._impl->Enabled());
|
|
_impl->SetShowUnderside (gp._impl->ShowUnderside());
|
|
_impl->SetAltitude (gp._impl->Altitude());
|
|
_impl->SetAutoAltitude (gp._impl->AutoAltitude());
|
|
_impl->SetShadowOnly (gp._impl->ShadowOnly());
|
|
_impl->SetMaterialInstanceId (gp._impl->MaterialInstanceId());
|
|
_impl->SetTextureOffset (gp._impl->TextureOffset());
|
|
_impl->SetTextureOffsetLocked(gp._impl->TextureOffsetLocked());
|
|
_impl->SetTextureSize (gp._impl->TextureSize());
|
|
_impl->SetTextureSizeLocked (gp._impl->TextureSizeLocked());
|
|
_impl->SetTextureRotation (gp._impl->TextureRotation());
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
bool ON_GroundPlane::operator == (const ON_GroundPlane& gp) const
|
|
{
|
|
// When checking equality, we need to directly check the underlying storage. So we can't allow
|
|
// virtual overrides to execute because they might hide the real values we want to check.
|
|
if (_impl->Enabled() != gp._impl->Enabled() ) return false;
|
|
if (_impl->ShowUnderside() != gp._impl->ShowUnderside() ) return false;
|
|
if (_impl->AutoAltitude() != gp._impl->AutoAltitude() ) return false;
|
|
if (_impl->ShadowOnly() != gp._impl->ShadowOnly() ) return false;
|
|
if (_impl->MaterialInstanceId() != gp._impl->MaterialInstanceId() ) return false;
|
|
if (_impl->TextureOffset() != gp._impl->TextureOffset() ) return false;
|
|
if (_impl->TextureOffsetLocked() != gp._impl->TextureOffsetLocked()) return false;
|
|
if (_impl->TextureSize() != gp._impl->TextureSize() ) return false;
|
|
if (_impl->TextureSizeLocked() != gp._impl->TextureSizeLocked() ) return false;
|
|
|
|
if (!IsDoubleEqual(_impl->Altitude(), gp._impl->Altitude())) return false;
|
|
if (!IsDoubleEqual(_impl->TextureRotation(), gp._impl->TextureRotation())) return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool ON_GroundPlane::operator != (const ON_GroundPlane& gp) const
|
|
{
|
|
return !(operator == (gp));
|
|
}
|
|
|
|
bool ON_GroundPlane::Enabled(void) const
|
|
{
|
|
return _impl->Enabled();
|
|
}
|
|
|
|
bool ON_GroundPlane::ShowUnderside(void) const
|
|
{
|
|
return _impl->ShowUnderside();
|
|
}
|
|
|
|
double ON_GroundPlane::Altitude(void) const
|
|
{
|
|
return _impl->Altitude();
|
|
}
|
|
|
|
bool ON_GroundPlane::AutoAltitude(void) const
|
|
{
|
|
return _impl->AutoAltitude();
|
|
}
|
|
|
|
bool ON_GroundPlane::ShadowOnly(void) const
|
|
{
|
|
return _impl->ShadowOnly();
|
|
}
|
|
|
|
ON_UUID ON_GroundPlane::MaterialInstanceId(void) const
|
|
{
|
|
return _impl->MaterialInstanceId();
|
|
}
|
|
|
|
ON_2dVector ON_GroundPlane::TextureOffset(void) const
|
|
{
|
|
return _impl->TextureOffset();
|
|
}
|
|
|
|
bool ON_GroundPlane::TextureOffsetLocked(void) const
|
|
{
|
|
return _impl->TextureOffsetLocked();
|
|
}
|
|
|
|
ON_2dVector ON_GroundPlane::TextureSize(void) const
|
|
{
|
|
return _impl->TextureSize();
|
|
}
|
|
|
|
bool ON_GroundPlane::TextureSizeLocked(void) const
|
|
{
|
|
return _impl->TextureSizeLocked();
|
|
}
|
|
|
|
double ON_GroundPlane::TextureRotation(void) const
|
|
{
|
|
return _impl->TextureRotation();
|
|
}
|
|
|
|
void ON_GroundPlane::SetEnabled(bool v)
|
|
{
|
|
_impl->SetEnabled(v);
|
|
}
|
|
|
|
void ON_GroundPlane::SetShowUnderside(bool v)
|
|
{
|
|
_impl->SetShowUnderside(v);
|
|
}
|
|
|
|
void ON_GroundPlane::SetAltitude(double v)
|
|
{
|
|
_impl->SetAltitude(v);
|
|
}
|
|
|
|
void ON_GroundPlane::SetAutoAltitude(bool v)
|
|
{
|
|
_impl->SetAutoAltitude(v);
|
|
}
|
|
|
|
void ON_GroundPlane::SetShadowOnly(bool v)
|
|
{
|
|
_impl->SetShadowOnly(v);
|
|
}
|
|
|
|
void ON_GroundPlane::SetMaterialInstanceId(const ON_UUID& v)
|
|
{
|
|
_impl->SetMaterialInstanceId(v);
|
|
}
|
|
|
|
void ON_GroundPlane::SetTextureOffset(const ON_2dVector& v)
|
|
{
|
|
_impl->SetTextureOffset(v);
|
|
}
|
|
|
|
void ON_GroundPlane::SetTextureOffsetLocked(bool v)
|
|
{
|
|
_impl->SetTextureOffsetLocked(v);
|
|
}
|
|
|
|
void ON_GroundPlane::SetTextureSize(const ON_2dVector& v)
|
|
{
|
|
_impl->SetTextureSize(v);
|
|
}
|
|
|
|
void ON_GroundPlane::SetTextureSizeLocked(bool v)
|
|
{
|
|
_impl->SetTextureSizeLocked(v);
|
|
}
|
|
|
|
void ON_GroundPlane::SetTextureRotation(double v)
|
|
{
|
|
_impl->SetTextureRotation(v);
|
|
}
|
|
|
|
bool ON_GroundPlane::PopulateMaterial(ON_Material& mat) const
|
|
{
|
|
mat = ON_Material::Default;
|
|
return true;
|
|
}
|
|
|
|
void ON_GroundPlane::SetXMLNode(ON_XMLNode& node) const
|
|
{
|
|
std::lock_guard<std::recursive_mutex> lg(_impl->_mutex);
|
|
_impl->SetModelNode(node);
|
|
}
|
|
|
|
void* ON_GroundPlane::EVF(const wchar_t* func, void* data)
|
|
{
|
|
return nullptr;
|
|
}
|
|
|
|
void ON_GroundPlane::OnInternalXmlChanged(const ON_GroundPlane*)
|
|
{
|
|
}
|