628 lines
21 KiB
C++
628 lines
21 KiB
C++
//======= Copyright © 1996-2006, Valve Corporation, All rights reserved. ======
|
|
//
|
|
// Purpose:
|
|
//
|
|
//=============================================================================
|
|
|
|
#ifndef VALVEMAYA_H
|
|
#define VALVEMAYA_H
|
|
|
|
#if defined(_WIN32)
|
|
#pragma once
|
|
#endif
|
|
|
|
// Maya Includes
|
|
|
|
#include <maya/MAngle.h>
|
|
#include <maya/MDagModifier.h>
|
|
#include <maya/MDagPath.h>
|
|
#include <maya/MEulerRotation.h>
|
|
#include <maya/MFloatVector.h>
|
|
#include <maya/MGlobal.h>
|
|
#include <maya/MIOStream.h>
|
|
#include <maya/MMatrix.h>
|
|
#include <maya/MObject.h>
|
|
#include <maya/MQuaternion.h>
|
|
#include <maya/MString.h>
|
|
#include <maya/MSyntax.h>
|
|
#include <maya/MVector.h>
|
|
|
|
// Valve Includes
|
|
|
|
#include "mathlib/mathlib.h"
|
|
#include "tier1/interface.h"
|
|
#include "tier1/stringpool.h"
|
|
#include "tier1/utlstring.h"
|
|
#include "tier1/utlstringmap.h"
|
|
#include "tier1/utlvector.h"
|
|
|
|
#include "ValveMaya/Undo.h"
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Forward declarations
|
|
//-----------------------------------------------------------------------------
|
|
class IMayaVGui;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Maya-specific library singletons
|
|
//-----------------------------------------------------------------------------
|
|
extern IMayaVGui *g_pMayaVGui;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// Purpose: Group a bunch of functions into the Valve Maya Namespace
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
namespace ValveMaya {
|
|
//-----------------------------------------------------------------------------
|
|
// Forward declarations
|
|
//-----------------------------------------------------------------------------
|
|
class CUndo;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Statics
|
|
//-----------------------------------------------------------------------------
|
|
extern const MQuaternion v2mQuat; // Valve Engine -> Maya Quaternion
|
|
extern const MQuaternion m2vQuat; // Maya -> Valve Engine Quaternion
|
|
extern const MMatrix v2mMat; // Valve Engine -> Maya Matrix
|
|
extern const MMatrix m2vMat; // Maya -> Valve Engine Matrix
|
|
|
|
extern const MQuaternion
|
|
vc2mcQuat; // Valve Engine Camera -> Maya Camera Quaternion
|
|
extern const MQuaternion
|
|
mc2vcQuat; // Maya Camera -> Valve Camera Engine Quaternion
|
|
extern const MMatrix vc2mcMat; // Valve Engine Camera -> Maya Camera Quaternion
|
|
extern const MMatrix mc2vcMat; // Maya Camera -> Valve Camera Engine Quaternion
|
|
|
|
inline MQuaternion ValveToMaya(const MQuaternion &q) { return q * v2mQuat; }
|
|
inline MQuaternion ValveCameraToMayaCamera(const MQuaternion &q) {
|
|
return vc2mcQuat * q * v2mQuat;
|
|
}
|
|
inline MQuaternion MayaToValve(const MQuaternion &q) { return q * m2vQuat; }
|
|
inline MQuaternion MayaCameraToValveCamera(const MQuaternion &q) {
|
|
return mc2vcQuat * q * m2vQuat;
|
|
}
|
|
|
|
inline MVector ValveToMaya(const MVector &p) { return p.rotateBy(v2mQuat); }
|
|
inline MVector ValveCameraToMayaCamera(const MVector &p) {
|
|
return p.rotateBy(v2mQuat);
|
|
}
|
|
inline MVector MayaToValve(const MVector &p) { return p.rotateBy(m2vQuat); }
|
|
inline MVector MayaCameraToValveCamera(const MVector &p) {
|
|
return p.rotateBy(m2vQuat);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Connect, disconnect
|
|
//-----------------------------------------------------------------------------
|
|
bool ConnectLibraries(CreateInterfaceFn factory);
|
|
void DisconnectLibraries();
|
|
|
|
MStatus CreateDagNode(const char *const i_nodeType,
|
|
const char *const i_transformName = NULL,
|
|
const MObject &i_parentObj = MObject::kNullObj,
|
|
MObject *o_pTransformObj = NULL,
|
|
MObject *o_pShapeObj = NULL,
|
|
MDagModifier *i_mDagModifier = NULL);
|
|
|
|
inline MStatus CreateDagNode(CUndo &undo, const char *const i_nodeType,
|
|
const char *const i_transformName = NULL,
|
|
const MObject &i_parentObj = MObject::kNullObj,
|
|
MObject *o_pTransformObj = NULL,
|
|
MObject *o_pShapeObj = NULL) {
|
|
return CreateDagNode(i_nodeType, i_transformName, i_parentObj,
|
|
o_pTransformObj, o_pShapeObj, &undo.DagModifier());
|
|
}
|
|
|
|
bool IsNodeVisible(const MDagPath &mDagPath, bool bTemplateAsInvisible = true);
|
|
bool IsPathVisible(MDagPath mDagPath, bool bTemplateAsInvisible = true);
|
|
|
|
class CMSyntaxHelp {
|
|
public:
|
|
CMSyntaxHelp()
|
|
: m_groupedHelp(false) // Make case sensitive
|
|
,
|
|
m_helpCount(0),
|
|
m_shortNameLength(0) {}
|
|
|
|
void Clear();
|
|
|
|
MStatus AddFlag(MSyntax &i_mSyntax, const char *i_shortName,
|
|
const char *i_longName, const char *i_group,
|
|
const char *i_help,
|
|
const MSyntax::MArgType i_argType1 = MSyntax::kNoArg,
|
|
const MSyntax::MArgType i_argType2 = MSyntax::kNoArg,
|
|
const MSyntax::MArgType i_argType3 = MSyntax::kNoArg,
|
|
const MSyntax::MArgType i_argType4 = MSyntax::kNoArg,
|
|
const MSyntax::MArgType i_argType5 = MSyntax::kNoArg,
|
|
const MSyntax::MArgType i_argType6 = MSyntax::kNoArg);
|
|
|
|
void PrintHelp(const char *const i_cmdName, const char *const i_cmdDesc,
|
|
int i_lineLength = 0U);
|
|
|
|
void PrintHelp(const MString &i_cmdName, const MString &i_cmdDesc,
|
|
int i_lineLength = 0U) {
|
|
PrintHelp(i_cmdName.asChar(), i_cmdDesc.asChar(), i_lineLength);
|
|
}
|
|
|
|
protected:
|
|
public:
|
|
protected:
|
|
CCountedStringPool m_stringPool;
|
|
|
|
struct HelpData_t {
|
|
const char *m_shortName;
|
|
const char *m_longName;
|
|
const char *m_help;
|
|
CUtlVector<MSyntax::MArgType> m_argTypes;
|
|
};
|
|
|
|
CUtlVector<const char *> m_groupOrder;
|
|
CUtlStringMap<CUtlVector<HelpData_t> > m_groupedHelp;
|
|
int m_helpCount;
|
|
int m_shortNameLength;
|
|
};
|
|
|
|
MString RemoveNameSpace(const MString &mString);
|
|
|
|
MString &BackslashToSlash(MString &mString);
|
|
|
|
template <class T_t>
|
|
bool IsDefault(T_t &, const MPlug &);
|
|
|
|
bool IsDefault(const MPlug &aPlug);
|
|
|
|
uint NextAvailable(MPlug &mPlug);
|
|
|
|
MPlug NextAvailablePlug(MPlug &mPlug);
|
|
|
|
MObject AddColorSetToMesh(const MString &colorSetName, const MDagPath &mDagPath,
|
|
MDagModifier &mDagModifier);
|
|
|
|
MString GetMaterialPath(const MObject &shadingGroupObj,
|
|
MObject *pSurfaceShaderObj, MObject *pFileObj,
|
|
MObject *pPlace2dTextureObj, MObject *pVmtObj,
|
|
bool *pbTransparent, MString *pDebugWhy);
|
|
|
|
// Returns the first node that is connected to the specified plug as input or
|
|
// output
|
|
MObject FindConnectedNode(const MPlug &mPlug);
|
|
|
|
// Returns the plug connected to the specified plug as an input, a NULL plug if
|
|
// no plug is connected
|
|
MPlug FindInputPlug(const MPlug &dstPlug);
|
|
|
|
MPlug FindInputPlug(const MObject &dstNodeObj, const MString &dstPlugName);
|
|
|
|
MObject FindInputNode(const MPlug &dstPlug);
|
|
|
|
MObject FindInputNode(const MObject &dstNodeObj, const MString &dstPlugName);
|
|
|
|
MObject FindInputAttr(const MPlug &dstPlug);
|
|
|
|
MObject FindInputAttr(const MObject &dstNodeObj, const MString &dstPlugName);
|
|
|
|
// Returns the first found node MObject of the specified type in the history of
|
|
// the specified node
|
|
MObject FindInputNodeOfType(const MObject &dstNodeObj, const MString &typeName,
|
|
const MString &dstPlugName);
|
|
|
|
MObject FindInputNodeOfType(const MObject &dstNodeObj, const MString &typeName,
|
|
MSelectionList &doneList);
|
|
|
|
// Creates a deformer of the specified type and deforms the specified shape with
|
|
// an optional component
|
|
MObject DeformShape(ValveMaya::CUndo &undo, const MString &deformerType,
|
|
const MDagPath &inOrigDagPath,
|
|
MObject &origCompObj = MObject::kNullObj);
|
|
|
|
bool Substitute(MString &str, const MString &searchStr,
|
|
const MString &replaceStr);
|
|
|
|
bool SubstituteCaseInsensitive(MString &str, const MString &searchStr,
|
|
const MString &replaceStr);
|
|
|
|
bool SubstituteAll(MString &str, const MString &searchStr,
|
|
const MString &replaceStr);
|
|
|
|
bool SubstituteAllCaseInsensitive(MString &str, const MString &searchStr,
|
|
const MString &replaceStr);
|
|
|
|
void FixSlashes(MString &str, char correctPathSeparator = '/');
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Converts a Maya MMatrix to a Valve matrix3x4_t (transpose)
|
|
//-----------------------------------------------------------------------------
|
|
inline void MatrixMayaToValve(matrix3x4_t &mValve, const MMatrix &mMaya) {
|
|
mValve[0][0] = mMaya[0][0];
|
|
mValve[0][1] = mMaya[1][0];
|
|
mValve[0][2] = mMaya[2][0];
|
|
mValve[0][3] = mMaya[3][0];
|
|
mValve[1][0] = mMaya[0][1];
|
|
mValve[1][1] = mMaya[1][1];
|
|
mValve[1][2] = mMaya[2][1];
|
|
mValve[1][3] = mMaya[3][1];
|
|
mValve[2][0] = mMaya[0][2];
|
|
mValve[2][1] = mMaya[1][2];
|
|
mValve[2][2] = mMaya[2][2];
|
|
mValve[2][3] = mMaya[3][2];
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Converts a Valve matrix3x4_t to a Maya MMatrix (transpose)
|
|
//-----------------------------------------------------------------------------
|
|
inline void MatrixValveToMaya(MMatrix &mMaya, const matrix3x4_t &mValve) {
|
|
mMaya[0][0] = mValve[0][0];
|
|
mMaya[0][1] = mValve[1][0];
|
|
mMaya[0][2] = mValve[2][0];
|
|
mMaya[3][0] = 0.0;
|
|
mMaya[1][0] = mValve[0][1];
|
|
mMaya[1][1] = mValve[1][1];
|
|
mMaya[1][2] = mValve[2][1];
|
|
mMaya[3][1] = 0.0;
|
|
mMaya[2][0] = mValve[0][2];
|
|
mMaya[2][1] = mValve[1][2];
|
|
mMaya[2][2] = mValve[2][2];
|
|
mMaya[3][2] = 0.0;
|
|
mMaya[3][0] = mValve[0][3];
|
|
mMaya[3][1] = mValve[1][3];
|
|
mMaya[3][2] = mValve[2][3];
|
|
mMaya[3][3] = 1.0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Converts a Maya MVector to a Valve Vector
|
|
//-----------------------------------------------------------------------------
|
|
inline void VectorMayaToValve(Vector &vValve, const MVector &vMaya) {
|
|
vValve.x = vMaya.x;
|
|
vValve.y = vMaya.y;
|
|
vValve.z = vMaya.z;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Converts a Valve Vector to a Maya MVector
|
|
//-----------------------------------------------------------------------------
|
|
inline void VectorValveToMaya(MVector &vMaya, const Vector &vValve) {
|
|
vMaya.x = vValve.x;
|
|
vMaya.y = vValve.y;
|
|
vMaya.z = vValve.z;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Converts a Maya MQuaternion to a Valve Quaternion
|
|
//-----------------------------------------------------------------------------
|
|
inline void QuaternionMayaToValve(Quaternion &qValve,
|
|
const MQuaternion &qMaya) {
|
|
qValve.x = qMaya.x;
|
|
qValve.y = qMaya.y;
|
|
qValve.z = qMaya.z;
|
|
qValve.w = qMaya.w;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Converts a Maya MQuaternion to a Valve Quaternion
|
|
//-----------------------------------------------------------------------------
|
|
inline void QuaternionMayaToValve(Quaternion &qValve,
|
|
const MEulerRotation &eMaya) {
|
|
const MQuaternion qMaya = eMaya.asQuaternion();
|
|
|
|
qValve.x = qMaya.x;
|
|
qValve.y = qMaya.y;
|
|
qValve.z = qMaya.z;
|
|
qValve.w = qMaya.w;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Converts a Valve Quaternion to a Maya MQuaternion
|
|
//-----------------------------------------------------------------------------
|
|
inline void QuaternionValveToMaya(MQuaternion &qMaya,
|
|
const Quaternion &qValve) {
|
|
qMaya.x = qValve.x;
|
|
qMaya.y = qValve.y;
|
|
qMaya.z = qValve.z;
|
|
qMaya.w = qValve.w;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Converts a Valve Quaternion to a Maya MQuaternion
|
|
//-----------------------------------------------------------------------------
|
|
inline void QuaternionValveToMaya(MEulerRotation &eMaya,
|
|
const Quaternion &qValve) {
|
|
MQuaternion qMaya;
|
|
QuaternionValveToMaya(qMaya, qValve);
|
|
|
|
const MEulerRotation::RotationOrder roTmp = eMaya.order;
|
|
|
|
eMaya = qMaya;
|
|
|
|
if (eMaya.order != roTmp) {
|
|
eMaya.reorder(roTmp);
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Converts a Maya MEulerRotation to a Valve RadianEuler
|
|
//-----------------------------------------------------------------------------
|
|
inline void RadianEulerMayaToValve(RadianEuler &eValve,
|
|
const MEulerRotation &eMaya) {
|
|
if (eMaya.order == MEulerRotation::kXYZ) {
|
|
eValve.x = eMaya.x;
|
|
eValve.y = eMaya.y;
|
|
eValve.z = eMaya.z;
|
|
} else {
|
|
MEulerRotation eTmp = eMaya;
|
|
eTmp.reorder(MEulerRotation::kXYZ);
|
|
|
|
eValve.x = eTmp.x;
|
|
eValve.y = eTmp.y;
|
|
eValve.z = eTmp.z;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Converts a Valve RadianEuler to a Maya MEulerRotation
|
|
//-----------------------------------------------------------------------------
|
|
inline void RadianEulerValveToMaya(MEulerRotation &eMaya,
|
|
const RadianEuler &eValve) {
|
|
const MEulerRotation::RotationOrder roTmp = eMaya.order;
|
|
|
|
if (roTmp == MEulerRotation::kXYZ) {
|
|
eMaya.x = eValve.x;
|
|
eMaya.y = eValve.y;
|
|
eMaya.z = eValve.z;
|
|
} else {
|
|
eMaya.reorder(MEulerRotation::kXYZ);
|
|
|
|
eMaya.x = eValve.x;
|
|
eMaya.y = eValve.y;
|
|
eMaya.z = eValve.z;
|
|
|
|
eMaya.reorder(roTmp);
|
|
}
|
|
}
|
|
|
|
} // end namespace ValveMaya
|
|
|
|
// Make an alias for the ValveMaya namespace
|
|
|
|
namespace vm = ValveMaya;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// A simple stream class for printing information to the Maya script editor
|
|
//-----------------------------------------------------------------------------
|
|
class CMayaStream {
|
|
public:
|
|
enum StreamType { kInfo, kWarning, kError };
|
|
|
|
CMayaStream(const StreamType i_streamType = kInfo)
|
|
: m_streamType(i_streamType) {}
|
|
|
|
template <class T_t>
|
|
CMayaStream &operator<<(const T_t &v);
|
|
|
|
// This is a hack so CMayaStream << std::endl works as expected
|
|
CMayaStream &operator<<(std::ostream &(*StdEndl_t)(std::ostream &)) {
|
|
return flush();
|
|
}
|
|
|
|
CMayaStream &flush() { return outputString(); }
|
|
|
|
protected:
|
|
CMayaStream &outputString() {
|
|
// Always ensure it's terminated with a newline
|
|
if (*(m_string.asChar() + m_string.length() - 1) != '\n') {
|
|
m_string += "\n";
|
|
}
|
|
|
|
const char *pBegin = m_string.asChar();
|
|
const char *const pEnd = pBegin + m_string.length();
|
|
const char *pCurr = pBegin;
|
|
|
|
while (*pCurr && pCurr < pEnd) {
|
|
if (*pCurr == '\n') {
|
|
switch (m_streamType) {
|
|
case kWarning:
|
|
MGlobal::displayWarning(
|
|
MString(pBegin, pCurr - pBegin));
|
|
break;
|
|
case kError:
|
|
MGlobal::displayError(MString(pBegin, pCurr - pBegin));
|
|
break;
|
|
default:
|
|
MGlobal::displayInfo(MString(pBegin, pCurr - pBegin));
|
|
break;
|
|
}
|
|
|
|
++pCurr;
|
|
pBegin = pCurr;
|
|
} else {
|
|
++pCurr;
|
|
}
|
|
}
|
|
|
|
m_string.clear();
|
|
|
|
return *this;
|
|
}
|
|
|
|
CMayaStream &checkForFlush() {
|
|
const char *pCurr = m_string.asChar();
|
|
const char *pEnd = pCurr + m_string.length();
|
|
while (*pCurr && pCurr != pEnd) {
|
|
if (*pCurr == '\n') {
|
|
return outputString();
|
|
}
|
|
|
|
++pCurr;
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
StreamType m_streamType;
|
|
MString m_string;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
class CMayaWarnStream : public CMayaStream {
|
|
public:
|
|
CMayaWarnStream() : CMayaStream(CMayaStream::kWarning) {}
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
class CMayaErrStream : public CMayaStream {
|
|
public:
|
|
CMayaErrStream() : CMayaStream(CMayaStream::kError) {}
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Specialization for std::string
|
|
//-----------------------------------------------------------------------------
|
|
template <>
|
|
inline CMayaStream &CMayaStream::operator<<(const std::string &v) {
|
|
*this << v.c_str();
|
|
return *this;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Specialization for char
|
|
//-----------------------------------------------------------------------------
|
|
template <>
|
|
inline CMayaStream &CMayaStream::operator<<(const char &v) {
|
|
m_string += MString(&v, 1);
|
|
return *this;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Specialization for MVector
|
|
//-----------------------------------------------------------------------------
|
|
template <>
|
|
inline CMayaStream &CMayaStream::operator<<(const MVector &v) {
|
|
m_string += v.x;
|
|
m_string += " ";
|
|
m_string += v.y;
|
|
m_string += " ";
|
|
m_string += v.z;
|
|
return *this;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Specialization for MFloatVector
|
|
//-----------------------------------------------------------------------------
|
|
template <>
|
|
inline CMayaStream &CMayaStream::operator<<(const MFloatVector &v) {
|
|
m_string += v.x;
|
|
m_string += " ";
|
|
m_string += v.y;
|
|
m_string += " ";
|
|
m_string += v.z;
|
|
return *this;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Specialization for MEulerRotation
|
|
//-----------------------------------------------------------------------------
|
|
template <>
|
|
inline CMayaStream &CMayaStream::operator<<(const MEulerRotation &e) {
|
|
m_string += MAngle(e.x, MAngle::kRadians).asDegrees();
|
|
m_string += " ";
|
|
m_string += MAngle(e.y, MAngle::kRadians).asDegrees();
|
|
m_string += " ";
|
|
m_string += MAngle(e.z, MAngle::kRadians).asDegrees();
|
|
switch (e.order) {
|
|
case MEulerRotation::kXYZ:
|
|
m_string += " (XYZ)";
|
|
break;
|
|
case MEulerRotation::kXZY:
|
|
m_string += " (XZY)";
|
|
break;
|
|
case MEulerRotation::kYXZ:
|
|
m_string += " (YXZ)";
|
|
break;
|
|
case MEulerRotation::kYZX:
|
|
m_string += " (YZX)";
|
|
break;
|
|
case MEulerRotation::kZXY:
|
|
m_string += " (ZXY)";
|
|
break;
|
|
case MEulerRotation::kZYX:
|
|
m_string += " (ZYX)";
|
|
break;
|
|
default:
|
|
m_string += " (Unknown)";
|
|
break;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Specialization for MQuaternion
|
|
//-----------------------------------------------------------------------------
|
|
template <>
|
|
inline CMayaStream &CMayaStream::operator<<(const MQuaternion &q) {
|
|
m_string += q.x;
|
|
m_string += " ";
|
|
m_string += q.y;
|
|
m_string += " ";
|
|
m_string += q.z;
|
|
m_string += " ";
|
|
m_string += q.w;
|
|
|
|
m_string += " (";
|
|
operator<<(q.asEulerRotation());
|
|
m_string += ")";
|
|
|
|
return *this;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Specialization for Quaternion
|
|
//-----------------------------------------------------------------------------
|
|
template <>
|
|
inline CMayaStream &CMayaStream::operator<<(const Quaternion &q) {
|
|
return operator<<(MQuaternion(q.x, q.y, q.z, q.w));
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Specialization for RadianEuler
|
|
//-----------------------------------------------------------------------------
|
|
template <>
|
|
inline CMayaStream &CMayaStream::operator<<(const RadianEuler &e) {
|
|
return operator<<(MEulerRotation(e.x, e.y, e.z));
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Specialization for RadianEuler
|
|
//-----------------------------------------------------------------------------
|
|
template <>
|
|
inline CMayaStream &CMayaStream::operator<<(const Vector &v) {
|
|
return operator<<(MVector(v.x, v.y, v.z));
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
template <class T_t>
|
|
inline CMayaStream &CMayaStream::operator<<(const T_t &v) {
|
|
m_string += v;
|
|
return checkForFlush();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// minfo, mwarn & merr are ostreams which can be used to send stuff to
|
|
// the Maya history window
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
extern CMayaStream minfo;
|
|
extern CMayaWarnStream mwarn;
|
|
extern CMayaErrStream merr;
|
|
|
|
#endif // VALVEMAYA_H
|