void VertexParamsDefHLSL::print( Stream &stream, bool isVerterShader ) { assignConstantNumbers(); const char *opener = "ConnectData main( VertData IN"; stream.write( dStrlen(opener), opener ); // find all the uniform variables and print them out for( U32 i=0; i<LangElement::elementList.size(); i++) { Var *var = dynamic_cast<Var*>(LangElement::elementList[i]); if( var ) { if( var->uniform ) { const char* nextVar = ",\r\n "; stream.write( dStrlen(nextVar), nextVar ); U8 varNum[64]; dSprintf( (char*)varNum, sizeof(varNum), "register(C%d)", var->constNum ); U8 output[256]; if (var->arraySize <= 1) dSprintf( (char*)output, sizeof(output), "uniform %-8s %-15s : %s", var->type, var->name, varNum ); else dSprintf( (char*)output, sizeof(output), "uniform %-8s %s[%d] : %s", var->type, var->name, var->arraySize, varNum ); stream.write( dStrlen((char*)output), output ); } } } const char *closer = "\r\n)\r\n{\r\n ConnectData OUT;\r\n\r\n"; stream.write( dStrlen(closer), closer ); }
void PostEffectVis::_setDefaultCaption( VisWindow &vis, U32 texIndex ) { PostEffect *pfx = vis.pfx; GuiWindowCtrl *winCtrl = vis.window[texIndex]; if ( texIndex == Target ) { char caption[256]; char name[256]; if ( pfx->getName() == NULL || dStrlen( pfx->getName() ) == 0 ) dSprintf( name, 256, "(none)" ); else dSprintf( name, 256, "%s", pfx->getName() ); dSprintf( caption, 256, "%s[%i] target [NOT ENABLED]", name, pfx->getId() ); winCtrl->setDataField( StringTable->insert("text"), NULL, caption ); } else { char caption[256]; char name[256]; if ( pfx->getName() == NULL || dStrlen( pfx->getName() ) == 0 ) dSprintf( name, 256, "(none)" ); else dSprintf( name, 256, "%s", pfx->getName() ); dSprintf( caption, 256, "%s[%i] input%i - %s [NOT ENABLED]", name, pfx->getId(), texIndex-1, pfx->mTexFilename[texIndex-1].c_str() ); winCtrl->setDataField( StringTable->insert("text"), NULL, caption ); } }
//----------------------------------------------------------------------------- bool Platform::setClipboard(const char *text) { ScrapRef clip; U32 textSize; OSStatus err = noErr; // make sure we have something to copy textSize = dStrlen(text); if(textSize == 0) return false; // get a local ref to the system clipboard GetScrapByName( kScrapClipboardScrap, kScrapClearNamedScrap, &clip ); // put the data on the clipboard as text err = PutScrapFlavor( clip, kScrapFlavorTypeText, kScrapFlavorMaskNone, textSize, text); // put the data on the clipboard as unicode const UTF16 *utf16Data = convertUTF8toUTF16(text); err |= PutScrapFlavor( clip, kScrapFlavorTypeUnicode, kScrapFlavorMaskNone, dStrlen(utf16Data) * sizeof(UTF16), utf16Data); delete [] utf16Data; // and see if we were successful. if( err == noErr ) return true; else return false; }
void ShaderConnectorHLSL::print( Stream &stream, bool isVertexShader ) { const char * header = "struct "; const char * header2 = "\r\n{\r\n"; const char * footer = "};\r\n\r\n\r\n"; stream.write( dStrlen(header), header ); stream.write( dStrlen((char*)mName), mName ); stream.write( dStrlen(header2), header2 ); // print out elements for( U32 i=0; i<mElementList.size(); i++ ) { U8 output[256]; Var *var = mElementList[i]; if (var->arraySize <= 1) dSprintf( (char*)output, sizeof(output), " %s %-15s : %s;\r\n", var->type, var->name, var->connectName ); else dSprintf( (char*)output, sizeof(output), " %s %s[%d] : %s;\r\n", var->type, var->name, var->arraySize, var->connectName ); stream.write( dStrlen((char*)output), output ); } stream.write( dStrlen(footer), footer ); }
//------------------------------------------------------------------------------ static void log(const char *string) { // Bail if we ain't logging. if (!consoleLogMode) { return; } // In mode 1, we open, append, close on each log write. if ((consoleLogMode & 0x3) == 1) { consoleLogFile.open(defLogFileName, Torque::FS::File::ReadWrite); } // Write to the log if its status is hunky-dory. if ((consoleLogFile.getStatus() == Stream::Ok) || (consoleLogFile.getStatus() == Stream::EOS)) { consoleLogFile.setPosition(consoleLogFile.getStreamSize()); // If this is the first write... if (newLogFile) { // Make a header. Platform::LocalTime lt; Platform::getLocalTime(lt); char buffer[128]; dSprintf(buffer, sizeof(buffer), "//-------------------------- %d/%d/%d -- %02d:%02d:%02d -----\r\n", lt.month + 1, lt.monthday, lt.year + 1900, lt.hour, lt.min, lt.sec); consoleLogFile.write(dStrlen(buffer), buffer); newLogFile = false; if (consoleLogMode & 0x4) { // Dump anything that has been printed to the console so far. consoleLogMode -= 0x4; U32 size, line; ConsoleLogEntry *log; getLockLog(log, size); for (line = 0; line < size; line++) { consoleLogFile.write(dStrlen(log[line].mString), log[line].mString); consoleLogFile.write(2, "\r\n"); } unlockLog(); } } // Now write what we came here to write. consoleLogFile.write(dStrlen(string), string); consoleLogFile.write(2, "\r\n"); } if ((consoleLogMode & 0x3) == 1) { consoleLogFile.close(); } }
void ShaderGenPrinterHLSL::printMainComment(Stream& stream) { const char * header5 = "// Main\r\n"; const char * line = "//-----------------------------------------------------------------------------\r\n"; stream.write( dStrlen(line), line ); stream.write( dStrlen(header5), header5 ); stream.write( dStrlen(line), line ); }
void ShaderGenPrinterGLSL::printMainComment( Stream& stream ) { // Print out main function definition const char * header5 = "// Main \r\n"; const char * line = "//-----------------------------------------------------------------------------\r\n"; stream.write( dStrlen(line), line ); stream.write( dStrlen(header5), header5 ); stream.write( dStrlen(line), line ); }
static bool isMainDotCsPresent(char *dir) { char maincsbuf[MAX_MAC_PATH_LONG]; const char *maincsname = "/main.cs"; const U32 len = dStrlen(dir) + dStrlen(maincsname)+1; AssertISV(len < MAX_MAC_PATH_LONG, "Sorry, path is too long, I can't run from this folder."); dSprintf(maincsbuf,MAX_MAC_PATH_LONG,"%s%s", dir, maincsname); return Platform::isFile(maincsbuf); }
//-------------------------------------------------------------------------- // On add - verify data settings //-------------------------------------------------------------------------- bool CustomMaterial::onAdd() { if (Parent::onAdd() == false) return false; mShaderData = dynamic_cast<ShaderData*>(Sim::findObject( mShaderDataName ) ); if(mShaderDataName.isNotEmpty() && mShaderData == NULL) { logError("Failed to find ShaderData %s", mShaderDataName.c_str()); return false; } const char* samplerDecl = "sampler"; S32 i = 0; for (SimFieldDictionaryIterator itr(getFieldDictionary()); *itr; ++itr) { SimFieldDictionary::Entry* entry = *itr; if (dStrStartsWith(entry->slotName, samplerDecl)) { if (i >= MAX_TEX_PER_PASS) { logError("Too many sampler declarations, you may only have %i", MAX_TEX_PER_PASS); return false; } if (dStrlen(entry->slotName) == dStrlen(samplerDecl)) { logError("sampler declarations must have a sampler name, e.g. sampler[\"diffuseMap\"]"); return false; } // Assert sampler names are defined on ShaderData S32 pos = -1; String samplerName = entry->slotName + dStrlen(samplerDecl); samplerName.insert(0, '$'); mShaderData->hasSamplerDef(samplerName, pos); if(pos == -1) { const char *error = (avar("CustomMaterial(%s) bind sampler[%s] and is not present on ShaderData(%s)", getName(), samplerName.c_str(), mShaderDataName.c_str() )); Con::errorf(error); GFXAssertFatal(0, error); continue; } mSamplerNames[pos] = samplerName; mTexFilename[pos] = entry->value; ++i; } } return true; }
void ShaderGenPrinterHLSL::printShaderHeader(Stream& stream) { const char *header1 = "//*****************************************************************************\r\n"; const char *header2 = "// Torque -- HLSL procedural shader\r\n"; stream.write( dStrlen(header1), header1 ); stream.write( dStrlen(header2), header2 ); stream.write( dStrlen(header1), header1 ); const char* header3 = "\r\n"; stream.write( dStrlen(header3), header3 ); }
//-------------------------------------------------------------------------- // print //-------------------------------------------------------------------------- void Var::print( Stream &stream ) { if( structName[0] != '\0' ) { stream.write( dStrlen((char*)structName), structName ); if(GFX->getAdapterType() == OpenGL) stream.write( 1, "_" ); else stream.write( 1, "." ); } stream.write( dStrlen((char*)name), name ); }
//-------------------------------------- bool Platform::isSubDirectory(const char *pParent, const char *pDir) { if (!pParent || !*pDir) return false; const char* fileName = avar("%s/*", pParent); TempAlloc< TCHAR > file( dStrlen( fileName ) + 1 ); TempAlloc< TCHAR > dir( dStrlen( pDir ) + 1 ); #ifdef UNICODE convertUTF8toUTF16( fileName, file, file.size ); convertUTF8toUTF16( pDir, dir, dir.size ); #else dStrcpy( file, fileName ); dStrcpy( dir, pDir ); #endif backslash( file ); backslash( dir ); // this is somewhat of a brute force method but we need to be 100% sure // that the user cannot enter things like ../dir or /dir etc,... WIN32_FIND_DATA findData; HANDLE handle = FindFirstFile(file, &findData); if (handle == INVALID_HANDLE_VALUE) return false; do { // if it is a directory... if (findData.dwFileAttributes & (FILE_ATTRIBUTE_DIRECTORY| FILE_ATTRIBUTE_OFFLINE| FILE_ATTRIBUTE_SYSTEM| FILE_ATTRIBUTE_TEMPORARY) ) { //FIXME: this has to be dStrcasecmp but there's no implementation for Unicode // and the names match if (dStrcmp(dir, findData.cFileName ) == 0) { // then we have a real sub directory FindClose(handle); return true; } } }while(FindNextFile(handle, &findData)); FindClose(handle); return false; }
// [tom, 7/12/2005] Rather then converting this to unicode, just using the ANSI // versions of the Win32 API as its quicker for testing. bool Platform::cdFileExists(const char *filePath, const char *volumeName, S32 serialNum) { if (!filePath || !filePath[0]) return true; //first find the CD device... char fileBuf[1024]; char drivesBuf[256]; S32 length = GetLogicalDriveStringsA(256, drivesBuf); char *drivePtr = drivesBuf; while (S32(drivePtr - drivesBuf) < length) { char driveVolume[256], driveFileSystem[256]; U32 driveSerial, driveFNLength, driveFlags; if ((dStricmp(drivePtr, "A:\\") != 0 && dStricmp(drivePtr, "B:\\") != 0) && GetVolumeInformationA((const char*)drivePtr, &driveVolume[0], (unsigned long)255, (unsigned long*)&driveSerial, (unsigned long*)&driveFNLength, (unsigned long*)&driveFlags, &driveFileSystem[0], (unsigned long)255)) { #if defined (TORQUE_DEBUG) || !defined (TORQUE_SHIPPING) Con::printf("Found Drive: %s, vol: %s, serial: %d", drivePtr, driveVolume, driveSerial); #endif //see if the volume and serial number match if (!dStricmp(volumeName, driveVolume) && (!serialNum || (serialNum == driveSerial))) { //see if the file exists on this volume if(dStrlen(drivePtr) == 3 && drivePtr[2] == '\\' && filePath[0] == '\\') dSprintf(fileBuf, sizeof(fileBuf), "%s%s", drivePtr, filePath + 1); else dSprintf(fileBuf, sizeof(fileBuf), "%s%s", drivePtr, filePath); #if defined (TORQUE_DEBUG) || !defined (TORQUE_SHIPPING) Con::printf("Looking for file: %s on %s", fileBuf, driveVolume); #endif WIN32_FIND_DATAA findData; HANDLE h = FindFirstFileA(fileBuf, &findData); if(h != INVALID_HANDLE_VALUE) { FindClose(h); return true; } FindClose(h); } } //check the next drive drivePtr += dStrlen(drivePtr) + 1; } return false; }
S32 GuiTabBookCtrl::calculatePageTabWidth( GuiTabPageCtrl *page ) { if( !page ) return mMinTabWidth; const char* text = page->getText(); if( !text || dStrlen(text) == 0 || mProfile == NULL || mProfile->mFont == NULL ) return mMinTabWidth; GFont *font = mProfile->mFont; return font->getStrNWidth( text, dStrlen(text) ); }
ColladaAppNode::ColladaAppNode(const domNode* node, ColladaAppNode* parent) : p_domNode(node), appParent(parent), nodeExt(new ColladaExtension_node(node)), lastTransformTime(TSShapeLoader::DefaultTime-1), defaultTransformValid(false), invertMeshes(false) { mName = dStrdup(_GetNameOrId(node)); mParentName = dStrdup(parent ? parent->getName() : "ROOT"); // Extract user properties from the <node> extension as whitespace separated // "name=value" pairs char* properties = dStrdup(nodeExt->user_properties); char* pos = properties; char* end = properties + dStrlen( properties ); while ( pos < end ) { // Find the '=' character to separate the name and value pair char* split = dStrchr( pos, '=' ); if ( !split ) break; // Get the name (whitespace trimmed string up to the '=') // and value (whitespace trimmed string after the '=') *split = '\0'; char* name = TrimFirstWord( pos ); char* value = TrimFirstWord( split + 1 ); mProps.insert(StringTable->insert(name), dAtof(value)); pos = value + dStrlen( value ) + 1; } dFree( properties ); // Create vector of transform elements for (S32 iChild = 0; iChild < node->getContents().getCount(); iChild++) { switch (node->getContents()[iChild]->getElementType()) { case COLLADA_TYPE::TRANSLATE: case COLLADA_TYPE::ROTATE: case COLLADA_TYPE::SCALE: case COLLADA_TYPE::SKEW: case COLLADA_TYPE::MATRIX: case COLLADA_TYPE::LOOKAT: nodeTransforms.increment(); nodeTransforms.last().element = node->getContents()[iChild]; break; } } }
ExecuteThread::ExecuteThread(const char *executable, const char *args /* = NULL */, const char *directory /* = NULL */) : Thread(0, NULL, false) { SHELLEXECUTEINFO shl; dMemset(&shl, 0, sizeof(shl)); shl.cbSize = sizeof(shl); shl.fMask = SEE_MASK_NOCLOSEPROCESS; char exeBuf[1024]; Platform::makeFullPathName(executable, exeBuf, sizeof(exeBuf)); TempAlloc< TCHAR > dirBuf( ( directory ? dStrlen( directory ) : 0 ) + 1 ); dirBuf[ dirBuf.size - 1 ] = 0; #ifdef UNICODE WCHAR exe[ 1024 ]; convertUTF8toUTF16( exeBuf, exe, sizeof( exe ) / sizeof( exe[ 0 ] ) ); TempAlloc< WCHAR > argsBuf( ( args ? dStrlen( args ) : 0 ) + 1 ); argsBuf[ argsBuf.size - 1 ] = 0; if( args ) convertUTF8toUTF16( args, argsBuf, argsBuf.size ); if( directory ) convertUTF8toUTF16( directory, dirBuf, dirBuf.size ); #else char* exe = exeBuf; char* argsBuf = args; if( directory ) dStrpcy( dirBuf, directory ); #endif backslash( exe ); backslash( dirBuf ); shl.lpVerb = TEXT( "open" ); shl.lpFile = exe; shl.lpParameters = argsBuf; shl.lpDirectory = dirBuf; shl.nShow = SW_SHOWNORMAL; if(ShellExecuteEx(&shl) && shl.hProcess) { mProcess = shl.hProcess; start(); } }
/// Open the file and emit a row with the names of all enabled keys. virtual bool init( const char* fileName ) { if( !mStream.open( fileName, Torque::FS::File::Write ) ) { Con::errorf( "CSVSamplerBackend::init -- could not open '%s' for writing", fileName ); return false; } Con::printf( "CSVSamplerBackend::init -- writing samples to '%s'", fileName ); bool first = true; for( U32 i = 0; i < gSampleKeys.size(); ++ i ) { SampleKey& key = gSampleKeys[ i ]; if( key.mEnabled ) { if( !first ) mStream.write( 1, "," ); mRecords.push_back( SampleRecord( i + 1 ) ); mStream.write( dStrlen( key.mName ), key.mName ); first = false; } } newline(); return true; }
void SimComponent::write(Stream &stream, U32 tabStop, U32 flags /* = 0 */) { MutexHandle handle; handle.lock(mMutex); // When this goes out of scope, it will unlock it // export selected only? if((flags & SelectedOnly) && !isSelected()) { for(U32 i = 0; i < mComponentList.size(); i++) mComponentList[i]->write(stream, tabStop, flags); return; } stream.writeTabs(tabStop); char buffer[1024]; dSprintf(buffer, sizeof(buffer), "new %s(%s) {\r\n", getClassName(), getName() ? getName() : ""); stream.write(dStrlen(buffer), buffer); writeFields(stream, tabStop + 1); if(mComponentList.size()) { stream.write(2, "\r\n"); stream.writeTabs(tabStop+1); stream.writeLine((U8 *)"// Note: This is a list of behaviors, not arbitrary SimObjects as in a SimGroup or SimSet.\r\n"); for(U32 i = 0; i < mComponentList.size(); i++) mComponentList[i]->write(stream, tabStop + 1, flags); } stream.writeTabs(tabStop); stream.write(4, "};\r\n"); }
//-------------------------------------- S32 Platform::getFileSize(const char *pFilePath) { if (!pFilePath || !*pFilePath) return -1; TempAlloc< TCHAR > buf( dStrlen( pFilePath ) + 1 ); #ifdef UNICODE convertUTF8toUTF16( pFilePath, buf, buf.size ); #else dStrcpy( buf, pFilePath ); #endif backslash( buf ); // Get file info WIN32_FIND_DATA findData; HANDLE handle = FindFirstFile(buf, &findData); if(handle == INVALID_HANDLE_VALUE) return -1; FindClose(handle); // if the file is a Directory, Offline, System or Temporary then FALSE if (findData.dwFileAttributes & (FILE_ATTRIBUTE_DIRECTORY| FILE_ATTRIBUTE_OFFLINE| FILE_ATTRIBUTE_SYSTEM| FILE_ATTRIBUTE_TEMPORARY) ) return -1; // must be a real file then return findData.nFileSizeLow; }
//-------------------------------------- bool Platform::createPath(const char *file) { TempAlloc< TCHAR > pathbuf( dStrlen( file ) + 1 ); #ifdef UNICODE TempAlloc< WCHAR > fileBuf( pathbuf.size ); convertUTF8toUTF16( file, fileBuf, fileBuf.size ); const WCHAR* fileName = fileBuf; const WCHAR* dir; #else const char* fileName = file; const char* dir; #endif pathbuf[ 0 ] = 0; U32 pathLen = 0; while((dir = dStrchr(fileName, '/')) != NULL) { TCHAR* pathptr = pathbuf; dMemcpy( pathptr + pathLen, fileName, ( dir - fileName ) * sizeof( TCHAR ) ); pathbuf[pathLen + dir-fileName] = 0; // ignore return value because we are fine with already existing directory CreateDirectory(pathbuf, NULL); pathLen += dir - fileName; pathbuf[pathLen++] = '\\'; fileName = dir + 1; } return true; }
bool Platform::getFileTimes(const char *filePath, FileTime *createTime, FileTime *modifyTime) { WIN32_FIND_DATA findData; TempAlloc< TCHAR > fp( dStrlen( filePath ) + 1 ); #ifdef UNICODE convertUTF8toUTF16( filePath, fp, fp.size ); #else dStrcpy( fp, filePath ); #endif backslash( fp ); HANDLE h = FindFirstFile(fp, &findData); if(h == INVALID_HANDLE_VALUE) return false; if(createTime) { createTime->v1 = findData.ftCreationTime.dwLowDateTime; createTime->v2 = findData.ftCreationTime.dwHighDateTime; } if(modifyTime) { modifyTime->v1 = findData.ftLastWriteTime.dwLowDateTime; modifyTime->v2 = findData.ftLastWriteTime.dwHighDateTime; } FindClose(h); return true; }
//-------------------------------------- bool MaterialList::readText(Stream &stream, U8 firstByte) { free(); if (!firstByte) return (stream.getStatus() == Stream::Ok || stream.getStatus() == Stream::EOS); char buf[1024]; buf[0] = firstByte; U32 offset = 1; for(;;) { stream.readLine((U8*)(buf+offset), sizeof(buf)-offset); if(!buf[0]) break; offset = 0; // Material paths are a legacy of Tribes tools, // strip them off... char *name = &buf[dStrlen(buf)]; while (name != buf && name[-1] != '/' && name[-1] != '\\') name--; // Add it to the list mMaterialNames.push_back(name); mMatInstList.push_back(NULL); } return (stream.getStatus() == Stream::Ok || stream.getStatus() == Stream::EOS); }
//----------------------------------------------------------------------------- bool Platform::dumpDirectories(const char *path, Vector<StringTableEntry> &directoryVector, S32 depth, bool noBasePath) { if (isCachePath(path)) { PROFILE_START(dumpDirectories); ResourceManager->initExcludedDirectories(); const S32 len = dStrlen(path)+1; char newpath[len]; dSprintf(newpath, len, "%s", path); if(newpath[len - 1] == '/') newpath[len - 1] = '\0'; // cut off the trailing slash, if there is one // Insert base path to follow what Windows does. if ( !noBasePath ) directoryVector.push_back(StringTable->insert(newpath)); bool ret = recurseDumpDirectoriesCache(newpath, "", directoryVector, depth, noBasePath); PROFILE_END(); return ret; } PROFILE_START(dumpDirectories); ResourceManager->initExcludedDirectories(); bool ret = android_DumpDirectories(path, "", directoryVector, depth, noBasePath); PROFILE_END(); return ret; }
void RedBook::setLastError(const char * error) { if(!error || dStrlen(error) >= sizeof(smLastError)) setLastError("Invalid error string passed"); else dStrcpy(smLastError, error); }
U32 getNumChars() const { if( mNumChars == U32_MAX ) mNumChars = dStrlen( utf16() ); return mNumChars; }
void ShaderGenPrinterGLSL::printVertexShaderCloser( Stream& stream ) { // We are render OpenGL upside down for use DX9 texture coords. // Must be the last vertex feature. const char *closer = " gl_Position.y *= -1;\r\n}\r\n"; stream.write( dStrlen(closer), closer ); }
//----------------------------------------------------------------------------- bool Platform::dumpPath(const char *path, Vector<Platform::FileInfo>& fileVector, S32 depth) { if (isCachePath(path)) { PROFILE_START(dumpPath); const S32 len = dStrlen(path) + 1; char newpath[255]; strcpy(newpath, path); if(newpath[len - 2] == '/') newpath[len - 2] = '\0'; // cut off the trailing slash, if there is one bool ret = recurseDumpPathCache( newpath, fileVector, depth); PROFILE_END(); return ret; } PROFILE_START(dumpPath); bool ret = android_DumpPath( path, fileVector, depth); PROFILE_END(); return ret; }
void Settings::buildGroupString(String &name, const UTF8 *settingName) { // here we want to loop through the stack and build a "/" seperated string // representing the entire current group stack that gets pre-pended to the // setting name passed in if(mGroupStack.size() > 0) { for(S32 i=0; i < mGroupStack.size(); i++) { S32 pos = 0; if(name.size() > 0) pos = name.size()-1; // tack on the "/" in front if this isn't the first if(i == 0) { name.insert(pos, mGroupStack[i]); } else { name.insert(pos, "/"); name.insert(pos+1, mGroupStack[i]); } } // tack on a final "/" name.insert(name.size()-1, "/"); if(dStrlen(settingName) > 0) name.insert(name.size()-1, settingName); } else name = settingName; }
//-------------------------------------- StringTableEntry _StringTable::insert(const char* _val, const bool caseSens) { // Added 3/29/2007 -- If this is undesirable behavior, let me know -patw const char *val = _val; if( val == NULL ) val = ""; //- Node **walk, *temp; U32 key = hashString(val); walk = &buckets[key % numBuckets]; while((temp = *walk) != NULL) { if(caseSens && !dStrcmp(temp->val, val)) return temp->val; else if(!caseSens && !dStricmp(temp->val, val)) return temp->val; walk = &(temp->next); } char *ret = 0; if(!*walk) { *walk = (Node *) mempool.alloc(sizeof(Node)); (*walk)->next = 0; (*walk)->val = (char *) mempool.alloc(dStrlen(val) + 1); dStrcpy((*walk)->val, val); ret = (*walk)->val; itemCount ++; } if(itemCount > 2 * numBuckets) { resize(4 * numBuckets - 1); } return ret; }
void ShaderGenPrinterGLSL::printShaderHeader( Stream& stream ) { const char *header1 = "//*****************************************************************************\r\n"; const char *header2 = "// Torque -- GLSL procedural shader\r\n"; stream.write( dStrlen(header1), header1 ); stream.write( dStrlen(header2), header2 ); stream.write( dStrlen(header1), header1 ); // Cheap HLSL compatibility. const char* header3 = "#include \"shaders/common/gl/hlslCompat.glsl\"\r\n"; stream.write( dStrlen(header3), header3 ); const char* header4 = "\r\n"; stream.write( dStrlen(header4), header4 ); }