bool ezSockets::Connect(const MString& host, unsigned short port)
{
if(!Check())
return false;
#if defined(_XBOX)
if(!isdigit(host[0])) // don't do a DNS lookup for an IP address
{
XNDNS *pxndns = NULL;
XNetDnsLookup(host.c_str(), NULL, &pxndns);
while (pxndns->iStatus == WSAEINPROGRESS)
{
// Do something else while lookup is in progress
}
if (pxndns->iStatus == 0)
memcpy(&addr.sin_addr, &pxndns->aina[0], sizeof(struct in_addr));
else
return false;
XNetDnsRelease(pxndns);
}
else
addr.sin_addr.s_addr = inet_addr(host.c_str());
#else
struct hostent* phe;
phe = gethostbyname(host.c_str());
if (phe == NULL)
return false;
memcpy(&addr.sin_addr, phe->h_addr, sizeof(struct in_addr));
#endif
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
if(::connect(sock, (struct sockaddr*)&addr, sizeof(addr)) == SOCKET_ERROR)
return false;
state = skCONNECTED;
return true;
}
MSyslogMessage5424::MSyslogMessage5424(int facility, int severity, int version,
const MString& message,
const MString& timeStamp,
const MString& hostName,
const MString& appName,
const MString& procID,
const MString& msgID,
bool flagUTF8) :
mFacility(facility),
mSeverity(severity),
mVersion(version),
mTimeStamp(timeStamp),
mHostName(hostName),
mAppName(appName),
mProcID(procID),
mMsgID(msgID),
mUTF8Flag(flagUTF8),
mOwnMessage(false)
{
if (version <= 0) {
mVersion = 1;
} else if (version > 999) {
mVersion = 999;
}
if (message == "") {
mMessage = 0;
mUTF8Flag = true;
mMessageSize = 3; // BOM
} else {
mMessage = (unsigned char*)message.strData();
mMessageSize = message.length();
if (mUTF8Flag) mMessageSize += 3;
}
if (mTimeStamp == "") this->computeTimeStamp();
if (mHostName == "") this->getHostName();
if (mAppName == "") mAppName = "-";
if (mProcID == "") mProcID = "-";
if (mMsgID == "") mMsgID = "-";
}
void LiveScene::attributeNames( NameList &attrs ) const
{
if( !m_isRoot && m_dagPath.length() == 0 )
{
throw Exception( "IECoreMaya::LiveScene::attributeNames: Dag path no longer exists!" );
}
tbb::mutex::scoped_lock l( s_mutex );
attrs.clear();
attrs.push_back( SceneInterface::visibilityName );
// translate attributes with names starting with "ieAttr_":
MFnDependencyNode fnNode( m_dagPath.node() );
unsigned int n = fnNode.attributeCount();
for( unsigned int i=0; i<n; i++ )
{
MObject attr = fnNode.attribute( i );
MFnAttribute fnAttr( attr );
MString attrName = fnAttr.name();
if( attrName.length() > 7 && ( strstr( attrName.asChar(),"ieAttr_" ) == attrName.asChar() ) )
{
attrs.push_back( ( "user:" + attrName.substring( 7, attrName.length()-1 ) ).asChar() );
}
}
// add attributes from custom readers:
for ( std::vector< CustomAttributeReader >::const_iterator it = customAttributeReaders().begin(); it != customAttributeReaders().end(); it++ )
{
it->m_names( m_dagPath, attrs );
}
// remove duplicates:
std::sort( attrs.begin(), attrs.end() );
attrs.erase( std::unique( attrs.begin(), attrs.end() ), attrs.end() );
}
void printAllInstancesUsingIterator()
{
//
// Just use the MItInstancer iterator to enumerate all particles in
// all instancers in the scene.
//
MItInstancer it;
while( !it.isDone() )
{
MObject instancerNode = it.instancer();
MDagPath instancerPath = it.instancerPath();
MDagPath instancePath = it.path();
MMatrix instanceMatrix = it.matrix();
MString instancerNodeName = MFnDependencyNode(instancerNode).name();
MString instancerPathName = instancerPath.fullPathName();
MString instancePathName = instancePath.fullPathName();
MMatrix pathMatrix = instancePath.inclusiveMatrix();
MMatrix finalMatrixForPath = pathMatrix * instanceMatrix;
MPoint pos = MPoint::origin * finalMatrixForPath;
char str[512];
sprintf( str, "Instancer node %s, instancer path %s, instancing path %s at position (%lf,%lf,%lf)",
instancerNodeName.asChar(), instancerPathName.asChar(), instancePathName.asChar(), pos.x, pos.y, pos.z );
MGlobal::displayInfo( MString(str) );
it.next();
}
}
// Pull the shape data.
bool pullShape(const CacheFileEntry* entry,
GPUCache::SubNode::Ptr& geometry
)
{
// Assumption: Called from the main thread.
assert(geometry);
if (!geometry) return false;
// Lock the scheduler
tbb::unique_lock<tbb::mutex> lock(fBigMutex);
if (!entry) return false;
// A list of finished tasks
std::vector<WorkItem::Ptr> resultItems;
// Find the entry tasks, we have one or more tasks for reading shapes
std::pair<ShapeItemPtrListHashIterator,ShapeItemPtrListHashIterator> range =
fShapeTaskDone.get<1>().equal_range(entry);
for (ShapeItemPtrListHashIterator iter = range.first; iter != range.second; iter++) {
resultItems.push_back(*iter);
}
fShapeTaskDone.get<1>().erase(range.first, range.second);
// Background read complete
BOOST_FOREACH (const WorkItem::Ptr& item, resultItems) {
assert(item->type() == WorkItem::kShapeWorkItem);
#ifdef DEBUG_SCHEDULER
MString fileName = entry->fCacheFileName;
std::cout << "[gpuCache] Background reading (shape) of " << fileName.asChar() << " finished." << std::endl;
#endif
// Replace the shape node data.
SubNode::Ptr shape = item->geometry();
MString path = item->validatedGeometryPath();
if (shape && path.length() > 0) {
ReplaceSubNodeData(geometry, shape, path);
}
}
void AttributeParser::parseStringData(MFnDependencyNode & node, MObject & attr)
{
MStatus status;
MPlug plug = node.findPlug(attr, &status);
if (!status) return;
MString value;
status = plug.getValue(value);
if (!status) return;
if (value.length() == 0)
return;
MFnAttribute fnAttr(attr, &status);
if (!status) return;
MString name = fnAttr.name(&status);
if (!status) return;
onString(plug, name, value);
}
renderer::AssemblyInstance* createAssemblyInstance(const MayaObject* obj)
{
MayaObject* assemblyObject = getAssemblyMayaObject(obj);
boost::shared_ptr<AppleseedRenderer> appleRenderer = boost::static_pointer_cast<AppleseedRenderer>(getWorldPtr()->mRenderer);
renderer::Assembly* ass = getAssembly(obj);
renderer::Assembly* master = getMasterAssemblyFromProject(appleRenderer->getProjectPtr());
MString assemblyInstanceName = getAssemblyInstanceName(assemblyObject);
foundation::auto_release_ptr<renderer::AssemblyInstance> assemblyInstance = renderer::AssemblyInstanceFactory::create(assemblyInstanceName.asChar(), renderer::ParamArray(), ass->get_name());
fillMatrices(obj, assemblyInstance->transform_sequence());
renderer::AssemblyInstance* assInst = assemblyInstance.get();
master->assembly_instances().insert(assemblyInstance);
return assInst;
}
MStatus ParameterisedHolder<B>::removeUnecessaryAttributes()
{
MObjectArray toRemove;
MFnDependencyNode fnDN( B::thisMObject() );
for( unsigned i=0; i<fnDN.attributeCount(); i++ )
{
MObject attr = fnDN.attribute( i );
MFnAttribute fnAttr( attr );
MString attrName = fnAttr.name();
if( 0==strncmp( attrName.asChar(), g_attributeNamePrefix.c_str(), g_attributeNamePrefix.size() ) )
{
if( m_attributeNamesToParameters.find( fnAttr.name() )==m_attributeNamesToParameters.end() )
{
MPlug plug( B::thisMObject(), attr );
plug.setLocked( false ); // we can't remove things if they're locked
if( fnAttr.parent().isNull() )
{
toRemove.append( attr );
}
else
{
// we don't need to remove attributes which are the children
// of compounds as they'll be removed when their parent is removed
}
}
}
}
for( unsigned i=0; i<toRemove.length(); i++ )
{
MStatus s = fnDN.removeAttribute( toRemove[i] );
if( !s )
{
return s;
}
}
return MStatus::kSuccess;
}
MStringArray boingRbCmd::parseArguments(MString arg, MString token) {
MStringArray jobArgsArray;
MString stringBuffer;
for (unsigned int charIdx = 0; charIdx < arg.numChars(); charIdx++) {
MString ch = arg.substringW(charIdx, charIdx);
//cout<<"ch = "<<ch<<endl;
if (ch == token ) {
if (stringBuffer.length() > 0) {
jobArgsArray.append(stringBuffer);
//cout<<"jobArgsArray = "<<jobArgsArray<<endl;
stringBuffer.clear();
}
} else {
stringBuffer += ch;
//cout<<"stringBuffer = "<<stringBuffer<<endl;
}
}
jobArgsArray.append(stringBuffer);
return jobArgsArray;
}
MString AlembicObject::GetUniqueName(const MString& in_Name)
{
Abc::OObject parent = GetParentObject();
bool unique = false;
MString name = in_Name;
unsigned int index = 0;
while (!unique) {
unique = true;
for (size_t i = 0; i < parent.getNumChildren(); i++) {
MString childName = parent.getChildHeader(i).getName().c_str();
if (childName == name) {
index++;
MString indexString;
indexString.set((double)index);
name = in_Name + indexString;
unique = false;
break;
}
}
}
return name;
}
static void add_to_status_history(const MString& message)
{
static MString empty = rm(" ");
if (history == 0)
history = new MString[status_history_size];
int last_history =
(status_history_size + current_history - 1) % status_history_size;
if (message.isNull() || message.isEmpty() || message == empty)
return;
if (is_prefix(history[last_history], message))
{
history[last_history] = message;
return;
}
history[current_history] = message;
current_history = (current_history + 1) % status_history_size;
}
void operator() ( const MDagPath &dagPath, IECore::SceneInterface::NameList &tags, int filter )
{
MString p = dagPath.fullPathName();
IECorePython::ScopedGILLock gilLock;
object o;
try
{
o = m_read( p.asChar(), filter );
}
catch ( error_already_set )
{
PyErr_Print();
throw IECore::Exception( std::string( "Python exception while evaluating IECoreMaya::LiveScene tags" ) );
}
extract<list> l( o );
if ( !l.check() )
{
throw IECore::InvalidArgumentException( std::string( "Invalid value! Expecting a list of strings." ) );
}
IECorePython::listToSceneInterfaceNameList( l(), tags );
}
void maTranslator::writeHeader(fstream& f, const MString& fileName)
{
//
// Get the current time into the same format as used by Maya ASCII
// files.
//
time_t tempTime = time(NULL);
struct tm* curTime = localtime(&tempTime);
char formattedTime[100];
strftime(
formattedTime, sizeof(formattedTime), "%a, %b %e, %Y %r", curTime
);
//
// Write out the header information.
//
f << comment(fTranslatorName).asChar() << " "
<< fFileVersion.asChar() << " scene" << endl;
f << comment("Name: ").asChar() << fileName.asChar() << endl;
f << comment("Last modified: ").asChar() << formattedTime << endl;
}
Object colorTextureObject(MString attName, MColor c)
{
//Object Identifier="./Diffuse/Constant Texture" Label="Constant Texture" Name="" Type="Texture"
//<Parameter Name="Color" Type="RGB" Value="0.482866 0.456655 0.792157"/>
MString identifier = MString("./") + texObjMap[attName.asChar()].c_str() + "/Constant Texture";
MString label = "Constant Texture";
MString name = "";
MString type = "Texture";
Object o("subobject", name, type, label, identifier);
Parameter p("Color", c);
o.parameterList.push_back(p);
return o;
}
/*
* Return a new string with all occurrences of 'from' replaced with 'to'
*/
std::string replace_all(const MString &str, const char *from, const char *to)
{
std::string result(str.asChar());
std::string::size_type
index = 0,
from_len = strlen(from),
to_len = strlen(to);
while ((index = result.find(from, index)) != std::string::npos) {
result.replace(index, from_len, to);
index += to_len;
}
return result;
}
//is the specified plug on this node animation layered
//used when exporting
bool atomNodeWithAnimLayers::isPlugLayered(const MString &plugName, MStringArray &layerNames)
{
AttrLayersMap::iterator p;
std::string stdAttrName(plugName.asChar());
p = fAttrLayers.find(stdAttrName);
if(p != fAttrLayers.end())
{
PlugsAndLayers val = p->second;
layerNames = val.mLayerNames;
return true;
}
return false;
}
MStatus DateTimeParameterHandler::doUpdate( IECore::ConstParameterPtr parameter, MPlug &plug ) const
{
IECore::ConstDateTimeParameterPtr p = IECore::runTimeCast<const IECore::DateTimeParameter>( parameter );
if( !p )
{
return MS::kFailure;
}
MObject attribute = plug.attribute();
// we'd like to be setting the default value here, but as maya doesn't save the default value
// for dynamic string attributes in scene files, it'll be lost when the scene is reloaded. it's
// best therefore that we don't set the default at all, so that the default is "", which is what
// it'll be when we reload the scene - this ensures that any values set in the attribute later
// will be saved correctly (if we set the default to "X" and the value was "X", maya won't save the
// default or the value at all, and we end up with a value of "" on scene reload).
MFnTypedAttribute fnTAttr( attribute );
if( !fnTAttr.hasObj( attribute ) || fnTAttr.attrType() != MFnData::kString )
{
return MS::kFailure;
}
// Should this fail if getPlugValue fails?
MString v = "";
if( plug.getValue( v ) )
{
try
{
boost::posix_time::from_iso_string( v.asChar() );
}
catch ( boost::bad_lexical_cast )
{
return MS::kFailure;
}
}
return finishUpdating( parameter, plug );
}
bool SMOnlineRoom::Msg(const MString& command, const MString& data, ChatCommandPack& ccp)
{
MString tmp;
MString user;
MString message;
if (command.find("msg") == 0)
{
tmp = data.substr(command.length()+1);
if (tmp.length() > 0)
{
if (GetPlayerName(data, user))
if (tmp.length() >= (user.length()+3))
{
ccp.cmd = PM;
ccp.data.push(user);
ccp.data.push(tmp.substr(user.length()+3));
return true;
}
}
}
return false;
}
bool stripFileName(const MString & filePath, MString & fileName)
{
std::string str(filePath.asChar());
size_t found;
found = str.find_last_of("/\\");
str = str.substr(found+1);
// str is now in the form of xxx.abc
found = str.find_first_of(".");
str = str.substr(0, found);
fileName = MString(str.c_str());
return true;
}
MStatus SplitFromImage::splitFromBinaryImage(MFnMesh &mesh, MString image) {
cout << "Image filename: " << image.asChar() << endl;
// Load image
cv::Mat img;
img = cv::imread(image.asChar(), CV_LOAD_IMAGE_GRAYSCALE);
if (!img.data) // Check for invalid input
{
cout << "Could not open or find the image" << endl;
return MS::kFailure;
}
std::vector<std::vector<cv::Point> > contours;
std::vector<cv::Vec4i> hierarchy;
// Find contours
cv::findContours(img, contours, hierarchy, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE, cv::Point(0, 0));
for (int i = 0; i < contours.size(); i++) {
MFloatArray uPoints;
MFloatArray vPoints;
for (int j = 0; j < contours[i].size(); j++) {
cv::Point pt = contours[i][j];
float u = (float)pt.x / img.cols;
float v = (float)pt.y / img.rows;
uPoints.append(u);
vPoints.append(v);
}
MObject newMesh;
if (addPlaneSubMesh(newMesh, uPoints, vPoints, mesh) == MS::kSuccess)
cout << "Added plane sub mesh!" << endl;
else
cout << "Couldn't add plane sub mesh!" << endl;
}
return MS::kSuccess;
}
// Forward Gnuplot error messages to DDD status line
static void SetStatusHP(Agent *, void *client_data, void *call_data)
{
PlotWindowInfo *plot = (PlotWindowInfo *)client_data;
DataLength* dl = (DataLength *) call_data;
string s(dl->data, dl->length);
(void) plot; // Use it
#if 0
if (!plot->active)
{
// Probably an invocation problem
post_gdb_message(s);
return;
}
#endif
if (plot->command != 0)
{
string msg = s;
strip_space(msg);
MString xmsg = tb(msg);
XmCommandError(plot->command, xmsg.xmstring());
}
while (!s.empty())
{
string line;
if (s.contains('\n'))
line = s.before('\n');
else
line = s;
s = s.after('\n');
strip_space(line);
if (!line.empty())
set_status(line);
}
}
int MRtmpConnection::run()
{
int ret = E_SUCCESS;
if ((ret = m_protocol->handshakeWithClient()) != E_SUCCESS) {
return ret;
}
while (!RequestStop) {
MRtmpMessage *msg = NULL;
int res = m_protocol->recv_message(&msg);
if (res == E_SOCKET_CLOSE_NORMALLY) {
break;
}
if (res != E_SUCCESS) {
log_error("MRtmpConnection recv_message error.");
break;
}
mMSleep(10);
}
if (m_role == Role_Connection_Publish) {
MString url = m_protocol->getRtmpCtx()->url();
g_cchannel->sendLine(Internal_CMD_RemoveHasBackSourceRes, url);
BlsBackSource::instance()->remove(url);
log_trace("remove url from master(url=%s)", url.c_str());
}
m_socket->close();
deleteLater();
log_trace("MRtmpConnection exit normally.");
return E_SUCCESS;
}
void CBPoseSpaceCmd::loadVertexPosition(MObject& poseMesh)
{
MStatus status;
MFnMesh poseFn(poseMesh, &status);
unsigned numVertex = poseFn.numVertices();
float* data = new float[numVertex * 3];
MString filename = _cacheName + ".pose";
if(!is_regular_file(filename.asChar()))
return;
boost::iostreams::filtering_istream in;
in.push( boost::iostreams::gzip_decompressor());
in.push( boost::iostreams::file_source(filename.asChar(), ios::binary));
if(!in.read((char*)data, numVertex * 3 * 4)) {
MGlobal::displayError(MString("corrective blendshape failed to read enough data from pose cache ") + _cacheName);
delete[] data;
return;
}
MPointArray poseVertex;
poseVertex.setLength(numVertex);
for(unsigned i=0; i < numVertex; i++)
{
poseVertex[i].x = data[i*3];
poseVertex[i].y = data[i*3+1];
poseVertex[i].z = data[i*3+2];
}
poseFn.setPoints ( poseVertex, MSpace::kObject );
delete[] data;
MGlobal::displayInfo(MString("corrective blendshape read sculpt pose from ") + filename);
}
//---------------------------------------------------
void DagHelper::setArrayPlugSize ( MPlug& plug, uint size )
{
if ( plug.node().isNull() ) return;
#if MAYA_API_VERSION >= 800
MStatus status = plug.setNumElements ( size );
CHECK_STAT ( status );
#else
MObject node = plug.node();
MString plugPath = plug.info();
if ( node.hasFn ( MFn::kDagNode ) )
{
MFnDagNode dagFn ( node );
int dot = plugPath.index ( '.' );
plugPath = dagFn.fullPathName() + plugPath.substring ( dot, plugPath.length() );
}
MString command = MString ( "setAttr -s " ) + size + " \"" + plugPath + "\";";
MGlobal::executeCommand ( command );
#endif // MAYA 8.00+
}
bool isNodeSupported(MString typeName, ShaderNode& sn, MObject& shaderObject)
{
std::string tn(typeName.asChar());
if(mtm_findShaderTypeByName(tn, sn))
{
sn.shaderObject = shaderObject;
sn.mayaName = getObjectName(shaderObject);
sn.setPlugShaderName();
return true;
}
logger.debug(MString("Shader type ") + typeName + " not yet supported");
return false;
}
MStringList MString::split(const MString &sep)
{
MString temp(*this);
MStringList ret;
if (sep.isEmpty()) {
return ret;
}
while (temp.contains(sep)) {
size_type index = temp.find(sep);
MString ss = temp.substr(0, index);
if (!ss.isEmpty()) {
ret << ss;
}
temp = temp.substr(index + sep.size(), temp.size() - 1);
}
if (!temp.isEmpty()) {
ret << temp;
}
return ret;
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
GOSImage*
GOSImagePool::GetImage(PCSTR image_name)
{
Check_Object(this);
MString imageName = image_name;
Verify(imageName.GetLength() > 0);
//
//---------------------------
// Get the image for the name
//---------------------------
//
GOSImage* image;
if((image = imageHash.Find(imageName)) == nullptr)
{
gos_PushCurrentHeap(Heap);
image = new GOSImage(image_name);
Register_Object(image);
gos_PopCurrentHeap();
imageHash.AddValue(image, image->imageName);
}
Check_Object(image);
return image;
}
MStatus AlembicPolyMeshToSubdivCommand::doIt(const MArgList& args)
{
MStatus status;
MArgParser argData(syntax(), args, &status);
if (argData.isFlagSet("help"))
{
MGlobal::displayInfo("[ExocortexAlembic]: ExocortexAlembic_meshToSubdiv command:");
MGlobal::displayInfo(" -m : mesh to assign the initialShadingGroup on");
return MS::kSuccess;
}
const MString mesh = argData.isFlagSet("mesh") ? ("\"" + argData.flagArgumentString("mesh", 0) + "\"") : "";
MString result;
MGlobal::executePythonCommand(("ExoAlembic._functions.alembicPolyMeshToSubdiv(" + mesh) + ")", result);
if (result.length())
{
MPxCommand::setResult(result);
return MS::kFailure;
}
return MS::kSuccess;
}
void decreaseFileRef(const MFileObject& file)
{
MString resolvedFullName = file.resolvedFullName();
std::string key = resolvedFullName.asChar();
tbb::unique_lock<tbb::mutex> lock(fMutex);
// look up the file ref count
FileRefCountIterator fileRefCountIter = fFileRefCount.find(key);
if (fileRefCountIter != fFileRefCount.end()) {
// decrease the file ref count
if (--(*fileRefCountIter).second == 0) {
// file ref count reaches 0
// purge this reader from cache since the reader won't
// be referenced any more
// the reader may already be closed because of the capacity
fFileRefCount.erase(fileRefCountIter);
LeftIterator iter = fData.left.find(key);
if (iter != fData.left.end()) {
fData.left.erase(iter);
}
}
}
}
MayaPointPrimitiveWriter::MayaPointPrimitiveWriter(
double iFrame, MDagPath & iDag, Alembic::AbcGeom::OObject & iParent,
Alembic::Util::uint32_t iTimeIndex,
const JobArgs & iArgs) :
mIsAnimated(false), mDagPath(iDag)
{
MFnParticleSystem particle(mDagPath);
MString name = particle.name();
name = util::stripNamespaces(name, iArgs.stripNamespace);
Alembic::AbcGeom::OPoints obj(iParent, name.asChar(),
iTimeIndex);
mSchema = obj.getSchema();
Alembic::Abc::OCompoundProperty cp;
Alembic::Abc::OCompoundProperty up;
if (AttributesWriter::hasAnyAttr(particle, iArgs))
{
cp = mSchema.getArbGeomParams();
up = mSchema.getUserProperties();
}
mAttrs = AttributesWriterPtr(new AttributesWriter(cp, up, obj, particle,
iTimeIndex, iArgs, true));
MObject object = iDag.node();
if (iTimeIndex != 0 && util::isAnimated(object))
{
mIsAnimated = true;
}
if (!mIsAnimated || iArgs.setFirstAnimShape)
{
write(iFrame);
}
}