C++ dMemset函数代码示例

Etherform::Etherform()
{
	//mTypeMask |= EtherformObjectType;
	delta.pos.set(0.0f,0.0f,0.0f);
	delta.rot.set(0.0f,0.0f,0.0f);
	delta.rotOffset.set(0.0f,0.0f,0.0f);
	delta.warpOffset.set(0.0f,0.0f,0.0f);
	delta.posVec.set(0.0f,0.0f,0.0f);
	delta.rotVec.set(0.0f,0.0f,0.0f);
	delta.warpTicks = 0;
	delta.dt = 1.0f;
	delta.move = NullMove;
	mPredictionCount = sMaxPredictionTicks;

	mRot.set(0, 0, 0);
	mVelocity.set(0.0f, 0.0f, 0.0f);

	dMemset( mLaserTrailList, 0, sizeof( mLaserTrailList ) );

   for (S32 j = 0; j < EtherformData::MaxJetEmitters; j++)
      mJetEmitter[j] = 0;

	mConvex.init(this);
	mWorkingQueryBox.minExtents.set(-1e9f, -1e9f, -1e9f);
	mWorkingQueryBox.maxExtents.set(-1e9f, -1e9f, -1e9f);
}

void Forest::getLocalWindTrees( const Point3F &camPos, F32 radius, Vector<TreePlacementInfo> *placementInfo )
{
   PROFILE_SCOPE( Forest_getLocalWindTrees );

   Vector<ForestItem> items;
   items.reserve( placementInfo->capacity() );
   mData->getItems( camPos, radius, &items );

   TreePlacementInfo treeInfo;
   dMemset( &treeInfo, 0, sizeof ( TreePlacementInfo ) );

   // Reserve some space in the output.
   placementInfo->reserve( items.size() );

   // Build an info struct for each returned item.
   Vector<ForestItem>::const_iterator iter = items.begin();
   for ( ; iter != items.end(); iter++ )
   {
      // Skip over any zero wind elements here and
      // just keep them out of the final list.
      treeInfo.dataBlock = iter->getData();
      if ( treeInfo.dataBlock->mWindScale < 0.001f )
         continue;

      treeInfo.pos = iter->getPosition();
      treeInfo.scale = iter->getScale();
      treeInfo.itemKey = iter->getKey();
      placementInfo->push_back( treeInfo );
   }
}

AtlasImportOldCHUHelper::AtlasImportOldCHUHelper(const char *chuFile, AtlasFile *outFile)
{
   mChuFileName = chuFile;
   mChuFile     = NULL;
   mAtlasFile   = outFile;
   dMemset(&mHeader, 0, sizeof(mHeader));
}

void ConvexShape::writeFields( Stream &stream, U32 tabStop )
{
   Parent::writeFields( stream, tabStop );

   // Now write all planes.

   stream.write(2, "\r\n");   

   S32 count = mSurfaces.size();
   if ( count > smMaxSurfaces )
   {
       Con::errorf( "ConvexShape has too many surfaces to save! Truncated value %d to maximum value of %d", count, smMaxSurfaces );
       count = smMaxSurfaces;
   }

   for ( U32 i = 0; i < count; i++ )
   {      
      const MatrixF &mat = mSurfaces[i];

		QuatF quat( mat );
		Point3F pos( mat.getPosition() );

      stream.writeTabs(tabStop);

      char buffer[1024];
      dMemset( buffer, 0, 1024 );      
      
      dSprintf( buffer, 1024, "surface = \"%g %g %g %g %g %g %g\";", 
         quat.x, quat.y, quat.z, quat.w, pos.x, pos.y, pos.z );      

      stream.writeLine( (const U8*)buffer );
   }
}

void Win32WindowManager::lowerCurtain()
{
   if(mCurtainWindow)
      return;

   // For now just grab monitor of the first window... we may need to
   // beef this up later on, maybe by passing in the window that's entering
   // leaving full-screen to lowerCurtain.
   HMONITOR hMon = MonitorFromWindow(mWindowListHead->getHWND(), MONITOR_DEFAULTTOPRIMARY);

   // Get the monitor's extents.
   MONITORINFO monInfo;
   dMemset(&monInfo, 0, sizeof MONITORINFO);
   monInfo.cbSize = sizeof MONITORINFO;

   GetMonitorInfo(hMon, &monInfo);
 
   mCurtainWindow = CreateWindow(Win32Window::getCurtainWindowClassName(), 
                           dT(""), (WS_POPUP | WS_MAXIMIZE | WS_VISIBLE),
                           monInfo.rcWork.left, monInfo.rcWork.top, 
                           monInfo.rcWork.right - monInfo.rcWork.left, 
                           monInfo.rcWork.bottom - monInfo.rcWork.top, 
                           NULL, NULL, NULL, NULL);

   if (!mOffscreenRender)
      SetWindowPos(mCurtainWindow, HWND_TOPMOST, 0, 0, 0, 0,  SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW);
}

void LightManager::unregisterGlobalLight( LightInfo *light )
{
   mRegisteredLights.unregisterLight( light );

   // If this is the sun... clear the special light too.
   if ( light == mSpecialLights[slSunLightType] )
      dMemset( mSpecialLights, 0, sizeof( mSpecialLights ) );
}

ConditionerFeature::ConditionerFeature( const GFXFormat bufferFormat )
    :  mBufferFormat(bufferFormat)
{
    dMemset( mMethodDependency, 0, sizeof( mMethodDependency ) );

    smConditioners.push_back( this );
    smDirtyConditioners = true;
}

LightFlareData::LightFlareData()
 : mFlareEnabled( true ),
   mElementCount( 0 ),
   mScale( 1.0f ),
   mLOSMask( LosMask ),
   mOcclusionRadius( 0.0f ),
   mRenderReflectPass( true )
{
   dMemset( mElementRect, 0, sizeof( RectF ) * MAX_ELEMENTS );   
   dMemset( mElementScale, 0, sizeof( F32 ) * MAX_ELEMENTS );
   dMemset( mElementTint, 0, sizeof( ColorF ) * MAX_ELEMENTS );
   dMemset( mElementRotate, 0, sizeof( bool ) * MAX_ELEMENTS );
   dMemset( mElementUseLightColor, 0, sizeof( bool ) * MAX_ELEMENTS );   

   for ( U32 i = 0; i < MAX_ELEMENTS; i++ )   
      mElementDist[i] = -1.0f;   
}

void RenderPassData::reset()
{
    for( U32 i = 0; i < Material::MAX_TEX_PER_PASS; ++ i )
        destructInPlace( &mTexSlot[ i ] );

    dMemset( &mTexSlot, 0, sizeof(mTexSlot) );
    dMemset( &mTexType, 0, sizeof(mTexType) );

    mCubeMap = NULL;
    mNumTex = mNumTexReg = mStageNum = 0;
    mGlow = false;
    mBlendOp = Material::None;

    mFeatureData.clear();

    for (U32 i = 0; i < STATE_MAX; i++)
        mRenderStates[i] = NULL;
}

void GFXGLShaderConstBuffer::onShaderReload( GFXGLShader *shader )
{
   AssertFatal( shader == mShader, "GFXGLShaderConstBuffer::onShaderReload, mismatched shaders!" );

   delete[] mBuffer;
   mBuffer = new U8[mShader->mConstBufferSize];
   dMemset(mBuffer, 0, mShader->mConstBufferSize);
   mWasLost = true;
}

PlatformFont::CharInfo& EmscriptenFont::getCharInfo(const UTF16 character) const
{
    // Declare and clear out the CharInfo that will be returned.
    static PlatformFont::CharInfo characterInfo;
    dMemset(&characterInfo, 0, sizeof(characterInfo));

    // Return character information.
    return characterInfo;
}

TerrCell::TerrCell()
   :  mMaterials( 0 ),
      mMaterial( NULL ),
      mIsInteriorOnly( false ),
      mTriCount( 0 ),
      mHasEmpty( false )
{
   dMemset( mChildren, 0, sizeof( mChildren ) );
}

   virtual void execute()
   {
#ifndef TORQUE_OS_XENON
      // do it
      struct hostent* hostent = gethostbyname(mRequest.remoteAddr);
      if (hostent == NULL)
      {
         // oh well!  leave the lookup data unmodified (h_length) should
         // still be -1 from initialization
         mRequest.complete = true;
      }
      else
      {
         // copy the stuff we need from the hostent 
         dMemset(mRequest.out_h_addr, 0, 
            sizeof(mRequest.out_h_addr));
         dMemcpy(mRequest.out_h_addr, hostent->h_addr, hostent->h_length);

         mRequest.out_h_length = hostent->h_length;
         mRequest.complete = true;
      }
#else
      XNDNS *pxndns = NULL;
      HANDLE hEvent = CreateEvent(NULL, false, false, NULL);
      XNetDnsLookup(mRequest.remoteAddr, hEvent, &pxndns);

      while(pxndns->iStatus == WSAEINPROGRESS) 
         WaitForSingleObject(hEvent, INFINITE);

      if(pxndns->iStatus == 0 && pxndns->cina > 0)
      {
         dMemset(mRequest.out_h_addr, 0, sizeof(mRequest.out_h_addr));

         // This is a suspect section. I need to revisit. [2/22/2010 Pat]
         dMemcpy(mRequest.out_h_addr, pxndns->aina, sizeof(IN_ADDR)); 
         mRequest.out_h_length = sizeof(IN_ADDR);
      }

      mRequest.complete = true;

      XNetDnsRelease(pxndns);
      CloseHandle(hEvent);
#endif
   }

static void sfxFormatToWAVEFORMATEX( const SFXFormat& format, WAVEFORMATEX *wfx )
{
   dMemset( wfx, 0, sizeof( WAVEFORMATEX ) ); 
   wfx->wFormatTag = WAVE_FORMAT_PCM; 
   wfx->nChannels = format.getChannels();
   wfx->nSamplesPerSec = format.getSamplesPerSecond();
   wfx->wBitsPerSample = format.getBitsPerChannel();
   wfx->nBlockAlign = wfx->nChannels * wfx->wBitsPerSample / 8;
   wfx->nAvgBytesPerSec = wfx->nSamplesPerSec * wfx->nBlockAlign; 
}

 bool UUID::fromString( const char* str )
 {
    if( parse_token( str, ( xuuid_t* ) this ) != 0 )
    {
       dMemset( this, 0, sizeof( UUID ) );
       return false;
    }
    
    return true;
 }