virtual void endFrame()
    {
        char buffer[ 256 ];

        for( U32 i = 0; i < mRecords.size(); ++ i )
        {
            if( i != 0 )
                mStream.write( 1, "," );

            SampleRecord& record = mRecords[ i ];
            if( record.mSet )
            {
                if( record.mType == TypeBool )
                {
                    if( record.mValue.mBool )
                        mStream.write( 4, "true" );
                    else
                        mStream.write( 5, "false" );
                }
                else if( record.mType == TypeS32 )
                {
                    dSprintf( buffer, sizeof( buffer ), "%d", record.mValue.mS32 );
                    mStream.write( dStrlen( buffer ), buffer );
                }
                else if( record.mType == TypeF32 )
                {
                    dSprintf( buffer, sizeof( buffer ), "%f", record.mValue.mF32 );
                    mStream.write( dStrlen( buffer ), buffer );
                }
                else if( record.mType == TypeString )
                {
                    //FIXME: does not do doubling of double quotes in the string at the moment
                    mStream.write( 1, "\"" );
                    mStream.write( dStrlen( record.mValue.mString ), record.mValue.mString );
                    mStream.write( 1, "\"" );
                }
                else
                    AssertWarn( false, "CSVSamplerBackend::endFrame - bug: invalid sample type" );
            }

            record.clean();
        }

        newline();
    }

bool PlatformAssert::process(Type         assertType,
                             const char  *filename,
                             U32          lineNumber,
                             const char  *message)
{
    // If we're somehow recursing, just die.
    if(processing)
        Platform::debugBreak();
    
    processing = true;
    bool ret = false;
    
    // always dump to the Assert to the Console
    if (Con::isActive())
    {
        if (assertType == Warning)
            Con::warnf(ConsoleLogEntry::Assert, "%s(%ld,0): {%s} - %s", filename, lineNumber, typeName[assertType], message);
        else
            Con::errorf(ConsoleLogEntry::Assert, "%s(%ld,0): {%s} - %s", filename, lineNumber, typeName[assertType], message);
    }
    
    // if not a WARNING pop-up a dialog box
    if (assertType != Warning)
    {
        // used for processing navGraphs (an assert won't botch the whole build)
        if(Con::getBoolVariable("$FP::DisableAsserts", false) == true)
            Platform::forceShutdown(1);
        
        char buffer[2048];
        dSprintf(buffer, 2048, "%s: (%s @ %ld)", typeName[assertType], filename, lineNumber);
        if( !ignoreAll )
        {
            // Display message box with Debug, Ignore, Ignore All, and Exit options
            switch( Platform::AlertAssert(buffer, message) )
            {
                case Platform::ALERT_ASSERT_DEBUG:				
                    ret = true;
                    break;
                case Platform::ALERT_ASSERT_IGNORE:
                    ret = false;
                    break;
                case Platform::ALERT_ASSERT_IGNORE_ALL:
                    ignoreAll = true;
                    ret = false;
                    break;
                default:
                case Platform::ALERT_ASSERT_EXIT:
                    Platform::forceShutdown(1);
                    break;
            }
        }
    }
    
    processing = false;
    
    return ret;
}

void EditTSCtrl::_renderScene( ObjectRenderInst*, SceneRenderState *state, BaseMatInstance* )
{
   GFXTransformSaver saver;

   // render through console callbacks
   SimSet * missionGroup = static_cast<SimSet*>(Sim::findObject("MissionGroup"));
   if(missionGroup)
   {
      mConsoleRendering = true;

      // [ rene, 27-Jan-10 ] This calls onEditorRender on the server objects instead
      //    of on the client objects which seems a bit questionable to me.
 
      for(SimSetIterator itr(missionGroup); *itr; ++itr)
      {
         SceneObject* object = dynamic_cast< SceneObject* >( *itr );
         if( object && object->isRenderEnabled() && !object->isHidden() )
         {
            char buf[2][16];
            dSprintf(buf[0], 16, object->isSelected() ? "true" : "false");
            dSprintf(buf[1], 16, object->isExpanded() ? "true" : "false");
            
           object->onEditorRender_callback( getIdString(), buf[0], buf[1] );
         }
      }

      mConsoleRendering = false;
   }

   // render the mission area...
   renderMissionArea();

   // Draw the grid
   if ( mRenderGridPlane )
      renderGrid();

   // render the editor stuff
   renderScene(mSaveViewport);

	// Draw the camera axis
   GFX->setClipRect(mSaveViewport);
   GFX->setStateBlock(mDefaultGuiSB);
   renderCameraAxis();
}

const char *SimDataBlockEvent::getDebugName()
{
   SimObject *obj = Sim::findObject(id);
   static char buffer[256];
   dSprintf(buffer, sizeof(buffer), "%s [%s - %s]",
            getClassName(),
            obj ? obj->getName() : "",
            obj ? obj->getClassName() : "NONE");
   return buffer;
}

void PixelParamsDefHLSL::print( Stream &stream, bool isVerterShader )
{
   assignConstantNumbers();

   const char * opener = "Fragout main( ConnectData IN";
   stream.write( dStrlen(opener), opener );

   // find all the sampler & 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 )
         {
            WRITESTR( ",\r\n              " );

            U8 varNum[32];

            if( var->sampler )
            {
               //dSprintf( (char*)varNum, sizeof(varNum), ": register(S%d)", var->constNum );
               varNum[0] = NULL;
            }
            else
            {
               dSprintf( (char*)varNum, sizeof(varNum), ": register(C%d)", var->constNum );
            }

            U8 output[256];
            if (var->arraySize <= 1)
               dSprintf( (char*)output, sizeof(output), "uniform %-9s %-15s %s", var->type, var->name, varNum );
            else
               dSprintf( (char*)output, sizeof(output), "uniform %-9s %s[%d] %s", var->type, var->name, var->arraySize, varNum );

            WRITESTR( (char*) output );
         }
      }
   }

   const char *closer = "\r\n)\r\n{\r\n   Fragout OUT;\r\n\r\n";
   stream.write( dStrlen(closer), closer );
}

 void script_simobject_setfield_float(U32 objectId, const char* fieldName, F32 v)
 {
    SimObject *object = Sim::findObject( objectId );
    if( object )
    {
       char buf[256];
       dSprintf(buf, 256, "%g", v );
       object->setDataField(fieldName, "", buf);
    }
 }

   const char* RemoteCommandEvent::addTaggedString(const char* str)
	   {
	   NetStringHandle s(str);
	   gNetStringTable->incStringRefScript(s.getIndex());

	   char *ret = Con::getReturnBuffer(10);
	   ret[0] = StringTagPrefixByte;
	   dSprintf(ret + 1, 9, "%d", s.getIndex());
	   return ret;
	   }

XftFont *loadFont(const char *name, S32 size, Display *display)
{
  XftFont *fontInfo = NULL;
  char* fontname = const_cast<char*>(name);
  if (dStrlen(fontname)==0)
    fontname = "arial";
  else if (stristr(const_cast<char*>(name), "arial") != NULL)
    fontname = "arial";
  else if (stristr(const_cast<char*>(name), "lucida console") != NULL)
    fontname = "lucida console";

  char* weight = "medium";
  char* slant = "roman"; // no slant

  if (stristr(const_cast<char*>(name), "bold") != NULL)
    weight = "bold";
  if (stristr(const_cast<char*>(name), "italic") != NULL)
    slant = "italic";

  int mSize = size - 2 - (int)((float)size * 0.1);
  char xfontName[512];
  // We specify a lower DPI to get 'correct' looking fonts, if we go with the
  // native DPI the fonts are to big and don't fit the widgets.
  dSprintf(xfontName, 512, "%s-%d:%s:slant=%s:dpi=76", fontname, mSize, weight, slant);

  // Lets see if Xft can get a font for us.
  char xftname[1024];
  fontInfo = XftFontOpenName(display, DefaultScreen(display), xfontName);
  // Cant find a suitabke font, default to a known font (6x10)
  if ( !fontInfo )
    {
  	dSprintf(xfontName, 512, "6x10-%d:%s:slant=%s:dpi=76", mSize, weight, slant);
      fontInfo = XftFontOpenName(display, DefaultScreen(display), xfontName);
    }
      XftNameUnparse(fontInfo->pattern, xftname, 1024);

#ifdef DEBUG
      Con::printf("Font '%s %d' mapped to '%s'\n", name, size, xftname);
#endif

  return fontInfo;
}

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);
}

 void script_simobject_setfield_int(U32 objectId, const char* fieldName, S32 v)
 {
    SimObject *object = Sim::findObject( objectId );
    if( object )
    {
       // this seems pretty lame, though it is how it is handled in consoleType.cpp
       char buf[256];
       dSprintf(buf, 256, "%d", v );
       object->setDataField(fieldName, "", buf);
    }
 }

 bool Platform::hasSubDirectory(const char *pPath)
 {
   if (!pPath)
     return false;

   struct dirent *d;
   DIR           *dip;
   dip = opendir(pPath);
   if (dip == NULL)
     return false;

   while (d = readdir(dip))
     {
	bool isDir = false;
	if (d->d_type == DT_UNKNOWN)
	{
		char child [1024];
		if ((pPath[dStrlen(pPath) - 1] == '/'))
			dSprintf(child, 1024, "%s%s", pPath, d->d_name);
		else
			dSprintf(child, 1024, "%s/%s", pPath, d->d_name);
		isDir = Platform::isDirectory (child);
	}
	else if (d->d_type & DT_DIR)
		isDir = true;
	  	if( isDir )
	  	{
 	  	// Skip the . and .. directories
 	  	if (dStrcmp(d->d_name, ".") == 0 ||dStrcmp(d->d_name, "..") == 0)
 		    continue;
 		if (Platform::isExcludedDirectory(d->d_name))
 		    continue;
 		  Platform::clearExcludedDirectories();
 		  closedir(dip);
 		  return true;
 	}
     }
   closedir(dip);
   Platform::clearExcludedDirectories();
   return false;
 }

bool GuiGradientSwatchCtrl::onWake()
{
	if ( !Parent::onWake() )
      return false;
	
	static const U32 bufSize = 512;
	char* altCommand = Con::getReturnBuffer(bufSize);
	dSprintf( altCommand, bufSize, "%s(%i.color, \"%i.setColor\");", mColorFunction, getId(), getId() );
	setField( "altCommand", altCommand );

	return true;
}

bool CIniFile::SetAllValues(const string &section, const string &prefix, const Vector<string> &values)
{
   char key[256];
   bool stat = true;
   for(S32 i = 0; i < values.size(); i++)
   {
      dSprintf(key, 255, "%s%d", prefix.c_str(), i);
      stat &= SetValue(section, key, values[i], true);
   }

   return stat;      // true if all worked, false if any failed
}

//-------------------------------------------------------------
//------------------------------ 时间格式化(YYYY-MM-DD HH:MM:SS)
pc_str	time_format		(uint64 _time)
{
	tm	tmTime;
	memset(&tmTime,0,sizeof(tmTime));
	if(getLocalTime(&tmTime,_time) != 0)
		return "";

	static char szDate[32] = {0};
	dSprintf(szDate,sizeof(szDate),"%.4d-%.2d-%.2d %.2d:%.2d:%.2d",tmTime.tm_year + 1900,tmTime.tm_mon + 1,tmTime.tm_mday,tmTime.tm_hour,tmTime.tm_min,tmTime.tm_sec);

	return szDate;
}

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 );
   }
}

//--------------------------------------------------------------------------
void Projectile::onCollision(const Point3F& hitPosition, const Point3F& hitNormal, SceneObject* hitObject)
{
   // No client specific code should be placed or branched from this function
   if(isClientObject())
      return;

   if (hitObject != NULL && isServerObject())
   {
      char *posArg = Con::getArgBuffer(64);
      char *normalArg = Con::getArgBuffer(64);

      dSprintf(posArg, 64, "%g %g %g", hitPosition.x, hitPosition.y, hitPosition.z);
      dSprintf(normalArg, 64, "%g %g %g", hitNormal.x, hitNormal.y, hitNormal.z);

      Con::executef(mDataBlock, "onCollision",
         scriptThis(),
         Con::getIntArg(hitObject->getId()),
         Con::getFloatArg(mFadeValue),
         posArg,
         normalArg);
   }
}

void SimDataBlock::write(Stream &stream, U32 tabStop, U32 flags)
{
   // Only output selected objects if they want that.
   if((flags & SelectedOnly) && !isSelected())
      return;

   stream.writeTabs(tabStop);
   char buffer[1024];

   // Client side datablocks are created with 'new' while
   // regular server datablocks use the 'datablock' keyword.
   if ( isClientOnly() )
      dSprintf(buffer, sizeof(buffer), "new %s(%s) {\r\n", getClassName(), getName() ? getName() : "");
   else
      dSprintf(buffer, sizeof(buffer), "datablock %s(%s) {\r\n", getClassName(), getName() ? getName() : "");

   stream.write(dStrlen(buffer), buffer);
   writeFields(stream, tabStop + 1);

   stream.writeTabs(tabStop);
   stream.write(4, "};\r\n");
}

string HttpRequest::buildRequest()
{
   // location is anything that comes after the first '/'
   TNL::U32 index = mUrl.find('/');
   string location = mUrl.substr(index, mUrl.length() - index);

   // request line
   mRequest = mMethod + " " + location + " HTTP/1.0";

   // content type and data encoding for POST requests
   if(mMethod == PostMethod)
   {
      stringstream encodedData("");
      for(map<string, string>::iterator it = mData.begin(); it != mData.end(); it++)
      {
         encodedData << "--" + HttpRequestBoundary + "\r\n";
         encodedData << "Content-Disposition: form-data; name=\"" + (*it).first + "\"\r\n\r\n";
         encodedData << (*it).second + "\r\n";
      }

      for(list<HttpRequestFileInfo>::iterator it = mFiles.begin(); it != mFiles.end(); it++)
      {
         stringstream fileData;
         fileData.write((const char*) (*it).data, (*it).length);

         encodedData << "--" + HttpRequestBoundary + "\r\n";
         encodedData << "Content-Disposition: form-data; name=\"" + (*it).fieldName + "\"; filename=\"" + (*it).fileName + "\"\r\n";
         encodedData << "Content-Type: image/png\r\n";
         encodedData << "Content-Transfer-Encoding: binary\r\n\r\n";
         encodedData << fileData.str();
         encodedData << "\r\n";
      }

      encodedData << "--" + HttpRequestBoundary + "\r\n";

      char contentLengthHeaderBuffer[1024] = { 0 };
      dSprintf(contentLengthHeaderBuffer, 1024, "\r\nContent-Length: %d", (U32) encodedData.tellp());

      mRequest += contentLengthHeaderBuffer;
      mRequest += "\r\nUser-Agent: Bitfighter";
      mRequest += "\r\nContent-Type: multipart/form-data, boundary=" + HttpRequestBoundary;
      mRequest += "\r\n\r\n";
      mRequest += encodedData.str();
   }
   else
   {
      mRequest += "\r\n\r\n";
   }

   return mRequest;
}

void SFXALProvider::init()
{
   if( LoadOAL10Library( NULL, &mOpenAL ) != AL_TRUE )
   {
      Con::printf( "SFXALProvider - OpenAL not available." );
      return;
   }
   mALDL = new ALDeviceList( mOpenAL );

   // Did we get any devices?
   if ( mALDL->GetNumDevices() < 1 )
   {
      Con::printf( "SFXALProvider - No valid devices found!" );
      return;
   }

   // Cool, loop through them, and caps em
   const char *deviceFormat = "OpenAL v%d.%d %s";

   char temp[256];
   for( S32 i = 0; i < mALDL->GetNumDevices(); i++ )
   {
      ALDeviceInfo* info = new ALDeviceInfo;
      
      info->name = String( mALDL->GetDeviceName( i ) );

      S32 major, minor, eax = 0;

      mALDL->GetDeviceVersion( i, &major, &minor );

      // Apologies for the blatent enum hack -patw
      for( S32 j = SFXALEAX2; j < SFXALEAXRAM; j++ )
         eax += (int)mALDL->IsExtensionSupported( i, (SFXALCaps)j );

      if( eax > 0 )
      {
         eax += 2; // EAX support starts at 2.0
         dSprintf( temp, sizeof( temp ), "[EAX %d.0] %s", eax, ( mALDL->IsExtensionSupported( i, SFXALEAXRAM ) ? "EAX-RAM" : "" ) );
      }
      else
         dStrcpy( temp, "" );

      info->driver = String::ToString( deviceFormat, major, minor, temp );
      info->hasHardware = eax > 0;
      info->maxBuffers = mALDL->GetMaxNumSources( i );

      mDeviceInfo.push_back( info );
   }

   regProvider( this );
}

bool TurretShapeData::preload(bool server, String &errorStr)
{
   if (!Parent::preload(server, errorStr))
      return false;

   // We have mShape at this point.  Resolve nodes.
   headingNode = mShape->findNode("heading");
   pitchNode = mShape->findNode("pitch");

   // Find any mirror pitch nodes
   for (U32 i = 0; i < NumMirrorDirectionNodes; ++i)
   {
      char name[32];
      dSprintf(name, 31, "pitch%d", i+1);
      pitchNodes[i] = mShape->findNode(name);

      dSprintf(name, 31, "heading%d", i+1);
      headingNodes[i] = mShape->findNode(name);
   }

   // Resolve weapon mount point node indexes
   for (U32 i = 0; i < ShapeBase::MaxMountedImages; i++) {
      char fullName[256];
      dSprintf(fullName,sizeof(fullName),"weaponMount%d",i);
      weaponMountNode[i] = mShape->findNode(fullName);
   }

   // Recoil animations
   recoilSequence[0] = mShape->findSequence("light_recoil");
   recoilSequence[1] = mShape->findSequence("medium_recoil");
   recoilSequence[2] = mShape->findSequence("heavy_recoil");

   // Optional sequences used when the turret rotates
   pitchSequence = mShape->findSequence("pitch");
   headingSequence = mShape->findSequence("heading");

   return true;
}