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);
}
GLSimpleShader::GLSimpleShader(const char *vert, const char *fragment) :
mProjectionMatrix(1),
mModelViewMatrix(1)
{
GLuint program[2];
program[0] = compile(GL_VERTEX_SHADER, vert);
program[1] = compile(GL_FRAGMENT_SHADER, fragment);
mProgram = linkProgram(program);
glDeleteShader(program[0]);
glDeleteShader(program[1]);
dMemset(mLightPos, '\0', sizeof(mLightPos));
dMemset(mLightColor, '\0', sizeof(mLightColor));
}
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;
}
void FontRenderBatcher::init( GFont *font, U32 n )
{
// Clear out batched results
dMemset(mSheets.address(), 0, mSheets.memSize());
mSheets.clear();
mStorage.freeBlocks(true);
mFont = font;
mLength = n;
}
static void netToIPSocketAddress(const NetAddress *address, struct sockaddr_in *sockAddr)
{
dMemset(sockAddr, 0, sizeof(struct sockaddr_in));
sockAddr->sin_family = AF_INET;
sockAddr->sin_port = htons(address->port);
char tAddr[20];
dSprintf(tAddr, 20, "%d.%d.%d.%d", address->netNum[0], address->netNum[1], address->netNum[2], address->netNum[3]);
//fprintf(stdout,"netToIPSocketAddress(): %s\n",tAddr);fflush(NULL);
sockAddr->sin_addr.s_addr = inet_addr(tAddr);
}
Tokenizer::Tokenizer()
{
dMemset(mFileName, 0, sizeof(mFileName));
mpBuffer = NULL;
mBufferSize = 0;
mStartPos = 0;
mCurrPos = 0;
mTokenIsQuoted = false;
dMemset(mCurrTokenBuffer, 0, sizeof(mCurrTokenBuffer));
mTokenIsCurrent = false;
mSingleTokens = NULL;
VECTOR_SET_ASSOCIATION(mLinePositions);
}
SimManagerNameDictionary::SimManagerNameDictionary()
{
#ifdef USE_CLASSIC_SIMDICTIONARY
hashTable = new SimObject *[DefaultTableSize];
hashTableSize = DefaultTableSize;
hashEntryCount = 0;
dMemset( hashTable, 0, sizeof( hashTable[ 0 ] ) * hashTableSize );
#endif
mutex = Mutex::createMutex();
}
///
/// ShaderConstHandles
///
void ShaderConstHandles::init( GFXShader *shader, CustomMaterial* mat /*=NULL*/ )
{
mDiffuseColorSC = shader->getShaderConstHandle("$diffuseMaterialColor");
mTexMatSC = shader->getShaderConstHandle(ShaderGenVars::texMat);
mToneMapTexSC = shader->getShaderConstHandle(ShaderGenVars::toneMap);
mSpecularColorSC = shader->getShaderConstHandle(ShaderGenVars::specularColor);
mSpecularPowerSC = shader->getShaderConstHandle(ShaderGenVars::specularPower);
mParallaxInfoSC = shader->getShaderConstHandle("$parallaxInfo");
mFogDataSC = shader->getShaderConstHandle(ShaderGenVars::fogData);
mFogColorSC = shader->getShaderConstHandle(ShaderGenVars::fogColor);
mDetailScaleSC = shader->getShaderConstHandle(ShaderGenVars::detailScale);
mVisiblitySC = shader->getShaderConstHandle(ShaderGenVars::visibility);
mColorMultiplySC = shader->getShaderConstHandle(ShaderGenVars::colorMultiply);
mAlphaTestValueSC = shader->getShaderConstHandle(ShaderGenVars::alphaTestValue);
mModelViewProjSC = shader->getShaderConstHandle(ShaderGenVars::modelview);
mWorldViewOnlySC = shader->getShaderConstHandle(ShaderGenVars::worldViewOnly);
mWorldToCameraSC = shader->getShaderConstHandle(ShaderGenVars::worldToCamera);
mWorldToObjSC = shader->getShaderConstHandle(ShaderGenVars::worldToObj);
mViewToObjSC = shader->getShaderConstHandle(ShaderGenVars::viewToObj);
mCubeTransSC = shader->getShaderConstHandle(ShaderGenVars::cubeTrans);
mObjTransSC = shader->getShaderConstHandle(ShaderGenVars::objTrans);
mCubeEyePosSC = shader->getShaderConstHandle(ShaderGenVars::cubeEyePos);
mEyePosSC = shader->getShaderConstHandle(ShaderGenVars::eyePos);
mEyePosWorldSC = shader->getShaderConstHandle(ShaderGenVars::eyePosWorld);
m_vEyeSC = shader->getShaderConstHandle(ShaderGenVars::vEye);
mEyeMatSC = shader->getShaderConstHandle(ShaderGenVars::eyeMat);
mOneOverFarplane = shader->getShaderConstHandle(ShaderGenVars::oneOverFarplane);
mAccumTimeSC = shader->getShaderConstHandle(ShaderGenVars::accumTime);
mMinnaertConstantSC = shader->getShaderConstHandle(ShaderGenVars::minnaertConstant);
mSubSurfaceParamsSC = shader->getShaderConstHandle(ShaderGenVars::subSurfaceParams);
mDiffuseAtlasParamsSC = shader->getShaderConstHandle(ShaderGenVars::diffuseAtlasParams);
mDiffuseAtlasTileSC = shader->getShaderConstHandle(ShaderGenVars::diffuseAtlasTileParams);
mBumpAtlasParamsSC = shader->getShaderConstHandle(ShaderGenVars::bumpAtlasParams);
mBumpAtlasTileSC = shader->getShaderConstHandle(ShaderGenVars::bumpAtlasTileParams);
mRTSizeSC = shader->getShaderConstHandle( "$targetSize" );
mOneOverRTSizeSC = shader->getShaderConstHandle( "$oneOverTargetSize" );
mDetailBumpStrength = shader->getShaderConstHandle( "$detailBumpStrength" );
mViewProjSC = shader->getShaderConstHandle( "$viewProj" );
// MFT_ImposterVert
mImposterUVs = shader->getShaderConstHandle( "$imposterUVs" );
mImposterLimits = shader->getShaderConstHandle( "$imposterLimits" );
for (S32 i = 0; i < TEXTURE_STAGE_COUNT; ++i)
mRTParamsSC[i] = shader->getShaderConstHandle( String::ToString( "$rtParams%d", i ) );
// Clear any existing texture handles.
dMemset( mTexHandlesSC, 0, sizeof( mTexHandlesSC ) );
if(mat)
{
for (S32 i = 0; i < Material::MAX_TEX_PER_PASS; ++i)
mTexHandlesSC[i] = shader->getShaderConstHandle(mat->mSamplerNames[i]);
}
}
MemFileData(MemFileSystem* fs, const Path& path)
{
mPath = path;
mBufferSize = 1024;
mFileSize = 0;
mBuffer = dMalloc(mBufferSize);
dMemset(mBuffer, 0, mBufferSize);
mModified = Time::getCurrentTime();
mLastAccess = mModified;
mFileSystem = fs;
}
Point2I Win32WindowManager::getDesktopResolution()
{
DEVMODE devMode;
dMemset( &devMode, 0, sizeof( devMode ) );
devMode.dmSize = sizeof( devMode );
if (!::EnumDisplaySettings(NULL, ENUM_REGISTRY_SETTINGS, &devMode))
return Point2I(-1,-1);
// Return Resolution
return Point2I(devMode.dmPelsWidth, devMode.dmPelsHeight);
}
//----------------------------------------------------------------------------
// Constructor
//----------------------------------------------------------------------------
CustomMaterial::CustomMaterial()
{
mFallback = NULL;
mMaxTex = 0;
mVersion = 1.1f;
mTranslucent = false;
dMemset( mFlags, 0, sizeof( mFlags ) );
mShaderData = NULL;
mRefract = false;
mStateBlockData = NULL;
mForwardLit = false;
}
bool Tokenizer::reset()
{
mStartPos = 0;
mCurrPos = 0;
mTokenIsQuoted = false;
dMemset(mCurrTokenBuffer, 0, sizeof(mCurrTokenBuffer));
mTokenIsCurrent = false;
return true;
}
S32 Win32WindowManager::getDesktopBitDepth()
{
DEVMODE devMode;
dMemset( &devMode, 0, sizeof( devMode ) );
devMode.dmSize = sizeof( devMode );
if (!::EnumDisplaySettings(NULL, ENUM_REGISTRY_SETTINGS, &devMode))
return -1;
// Return Bits per Pixel
return (S32)devMode.dmBitsPerPel;
}
//--------------------------------------------------------------------------
// Splash Data
//--------------------------------------------------------------------------
SplashData::SplashData()
{
soundProfile = NULL;
soundProfileId = 0;
scale.set(1, 1, 1);
dMemset( emitterList, 0, sizeof( emitterList ) );
dMemset( emitterIDList, 0, sizeof( emitterIDList ) );
delayMS = 0;
delayVariance = 0;
lifetimeMS = 1000;
lifetimeVariance = 0;
width = 4.0;
numSegments = 10;
velocity = 5.0;
height = 0.0;
acceleration = 0.0;
texWrap = 1.0;
texFactor = 3.0;
ejectionFreq = 5;
ejectionAngle = 45.0;
ringLifetime = 1.0;
startRadius = 0.5;
explosion = NULL;
explosionId = 0;
dMemset( textureName, 0, sizeof( textureName ) );
U32 i;
for( i=0; i<NUM_TIME_KEYS; i++ )
times[i] = 1.0;
times[0] = 0.0;
for( i=0; i<NUM_TIME_KEYS; i++ )
colors[i].set( 1.0, 1.0, 1.0, 1.0 );
}
bool MacFileSystemChangeNotifier::internalAddNotification( const Torque::Path& dir )
{
// Map the path.
Torque::Path fullFSPath = mFS->mapTo( dir );
String osPath = PathToOS( fullFSPath );
// Create event stream.
Event* event = new Event;
CFStringRef path = CFStringCreateWithCharacters( NULL, osPath.utf16(), osPath.numChars() );
CFArrayRef paths = CFArrayCreate( NULL, ( const void** ) &path, 1, NULL );
FSEventStreamRef stream;
CFAbsoluteTime latency = 3.f;
FSEventStreamContext context;
dMemset( &context, 0, sizeof( context ) );
context.info = event;
stream = FSEventStreamCreate(
NULL,
&fsNotifyCallback,
&context,
paths,
kFSEventStreamEventIdSinceNow,
latency,
kFSEventStreamCreateFlagNone
);
event->mStream = stream;
event->mDir = dir;
event->mHasChanged = false;
mEvents.push_back( event );
// Put it in the run loop and start the stream.
FSEventStreamScheduleWithRunLoop( stream, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode );
FSEventStreamStart( stream );
CFRelease( path );
CFRelease( paths );
#ifdef DEBUG_SPEW
Platform::outputDebugString( "[MacFileSystemChangeNotifier] Added change notification %i to '%s' (full path: %s)",
mEvents.size(), dir.getFullPath().c_str(), osPath.c_str() );
#endif
return true;
}
void ObjectRenderInst::clear()
{
userData = NULL;
dMemset( this, 0, sizeof( ObjectRenderInst ) );
// The memset here is kinda wrong... it clears the
// state initialized by the delegate constructor.
//
// This fixes it... but we probably need to have a
// real constructor for RenderInsts.
renderDelegate.clear();
}
LightManager::LightManager( const char *name, const char *id )
: mName( name ),
mId( id ),
mIsActive( false ),
mSceneManager( NULL ),
mDefaultLight( NULL ),
mAvailableSLInterfaces( NULL ),
mCullPos( Point3F::Zero )
{
_getLightManagers().insert( mName, this );
dMemset( &mSpecialLights, 0, sizeof( mSpecialLights ) );
}
