//-----------------------------------------------------------------------------
// Initialize particle
//-----------------------------------------------------------------------------
void ParticleData::initializeParticle(Particle* init, const Point3F& inheritVelocity)
{
init->dataBlock = this;
// Calculate the constant accleration...
init->vel += inheritVelocity * inheritedVelFactor;
init->acc = init->vel * constantAcceleration;
// Calculate this instance's lifetime...
init->totalLifetime = lifetimeMS;
if (lifetimeVarianceMS != 0)
init->totalLifetime += S32(gRandGen.randI() % (2 * lifetimeVarianceMS + 1)) - S32(lifetimeVarianceMS);
// assign spin amount
init->spinSpeed = spinSpeed * gRandGen.randF( spinRandomMin, spinRandomMax );
}
//-----------------------------------------------------------------------------
UINT64 Crc64( UINT64 start_crc , UINT8 *addr ,UINT32 size)
{
UINT8 * limit;
UINT32 u32tmp ;
PAGED_CODE ();
start_crc = ~start_crc;
if (size > 4)
{
while ((uintptr_t)(addr) & 3)
{
start_crc = crc64_table[0][*addr++ ^ A1(start_crc)] ^ S8(start_crc);
--size;
}
limit = addr + (size & ~(size_t)(3));
size &= (size_t)(3);
while (addr < limit)
{
u32tmp = (UINT32)start_crc ^ (*(UINT32*)(addr));
addr += 4;
start_crc = crc64_table[3][A(u32tmp)] ^ crc64_table[2][B(u32tmp)] ^ S32(start_crc)^ crc64_table[1][C(u32tmp)] ^ crc64_table[0][D(u32tmp)];
}
}
while (size-- != 0)
start_crc = crc64_table[0][*addr++ ^ A1(start_crc)] ^ S8(start_crc);
return ~start_crc;
}
bool LLAlertDialog::setCheckBox( const std::string& check_title, const std::string& check_control )
{
const LLFontGL* font = LLResMgr::getInstance()->getRes( FONT_NAME );
const S32 LINE_HEIGHT = llfloor(font->getLineHeight() + 0.99f);
// Extend dialog for "check next time"
S32 max_msg_width = getRect().getWidth() - 2 * HPAD;
S32 check_width = S32(font->getWidth(check_title) + 0.99f) + 16;
max_msg_width = llmax(max_msg_width, check_width);
S32 dialog_width = max_msg_width + 2 * HPAD;
S32 dialog_height = getRect().getHeight();
dialog_height += LINE_HEIGHT;
dialog_height += LINE_HEIGHT / 2;
reshape( dialog_width, dialog_height, FALSE );
S32 msg_x = (getRect().getWidth() - max_msg_width) / 2;
LLRect check_rect;
check_rect.setOriginAndSize(msg_x, VPAD+BTN_HEIGHT+LINE_HEIGHT/2,
max_msg_width, LINE_HEIGHT);
mCheck = new LLCheckboxCtrl(std::string("check"), check_rect, check_title, font, onClickIgnore, this);
addChild(mCheck);
return true;
}
void LLNetMap::createObjectImage()
{
// Find the size of the side of a square that surrounds the circle that surrounds getRect().
F32 half_width = (F32)(getRect().getWidth() / 2);
F32 half_height = (F32)(getRect().getHeight() / 2);
F32 radius = sqrt( half_width * half_width + half_height * half_height );
S32 square_size = S32( 2 * radius );
// Find the least power of two >= the minimum size.
const S32 MIN_SIZE = 32;
const S32 MAX_SIZE = 256;
S32 img_size = MIN_SIZE;
while( (img_size*2 < square_size ) && (img_size < MAX_SIZE) )
{
img_size <<= 1;
}
if( mObjectImagep.isNull() ||
(mObjectImagep->getWidth() != img_size) ||
(mObjectImagep->getHeight() != img_size) )
{
mObjectRawImagep = new LLImageRaw(img_size, img_size, 4);
U8* data = mObjectRawImagep->getData();
memset( data, 0, img_size * img_size * 4 );
mObjectImagep = new LLImageGL( mObjectRawImagep, FALSE);
setScale(gMiniMapScale);
}
mUpdateNow = TRUE;
}
bool LLAlertDialog::setCheckBox( const LLString& check_title, const LLString& check_control )
{
const LLFontGL* font = gResMgr->getRes( font_name );
const S32 LINE_HEIGHT = llfloor(font->getLineHeight() + 0.99f);
// Extend dialog for "check next time"
S32 max_msg_width = mRect.getWidth() - 2 * HPAD;
S32 check_width = S32(font->getWidth(check_title) + 0.99f) + 16;
max_msg_width = llmax(max_msg_width, check_width);
S32 dialog_width = max_msg_width + 2 * HPAD;
S32 dialog_height = mRect.getHeight();
dialog_height += LINE_HEIGHT;
dialog_height += LINE_HEIGHT / 2;
reshape( dialog_width, dialog_height, FALSE );
S32 msg_x = (mRect.getWidth() - max_msg_width) / 2;
LLRect check_rect;
check_rect.setOriginAndSize(msg_x, VPAD+BTN_HEIGHT+LINE_HEIGHT/2,
max_msg_width, LINE_HEIGHT);
mCheck = new LLCheckboxCtrl("check", check_rect, check_title, font);
addChild(mCheck);
// mCheck is sometimes "show again" and sometimes "hide" :-(
// If it's "Show Again", and we showed it, it must be checked. JC
if (mIgnorable == IGNORE_SHOW_AGAIN)
{
mCheck->setValue(TRUE);
}
return true;
}
static void set_promiscuous_mode(struct net_device *dev)
{
struct fs_enet_private *fep = netdev_priv(dev);
fcc_t *fccp = fep->fcc.fccp;
S32(fccp, fcc_fpsmr, FCC_PSMR_PRO);
}
F32 GuiSliderCtrl::_getThumbValue( const GuiEvent& event )
{
Point2I curMousePos = globalToLocalCoord( event.mousePoint );
F32 value;
if( getWidth() >= getHeight() )
value = F32( curMousePos.x - mShiftPoint ) / F32( getWidth() - mShiftExtent ) * ( mRange.y - mRange.x ) + mRange.x;
else
value = F32( curMousePos.y ) / F32( getHeight() ) * ( mRange.y - mRange.x ) + mRange.x;
if(value > mRange.y )
value = mRange.y;
else if( value < mRange.x )
value = mRange.x;
if( mSnap || ( event.modifier & SI_SHIFT && mTicks >= 1 ) )
{
// If the shift key is held, snap to the nearest tick, if any are being drawn
F32 tickStep = ( mRange.y - mRange.x ) / F32( mTicks + 1 );
F32 tickSteps = (value - mRange.x ) / tickStep;
S32 actualTick = S32( tickSteps + 0.5 );
value = actualTick * tickStep + mRange.x;
AssertFatal( value <= mRange.y && value >= mRange.x, "Error, out of bounds value generated from shift-snap of slider" );
}
return value;
}
void GuiSliderCtrl::_updateThumb( F32 _value, bool snap, bool onWake, bool doCallback )
{
if( snap && mTicks > 0 )
{
// If the shift key is held, snap to the nearest tick, if any are being drawn
F32 tickStep = (mRange.y - mRange.x) / F32(mTicks + 1);
F32 tickSteps = (_value - mRange.x) / tickStep;
S32 actualTick = S32(tickSteps + 0.5);
_value = actualTick * tickStep + mRange.x;
}
// Clamp the thumb to legal values.
if( _value < mRange.x )
_value = mRange.x;
if( _value > mRange.y )
_value = mRange.y;
// If value hasn't changed and this isn't the initial update on
// waking, do nothing.
if( mValue == _value && !onWake )
return;
mValue = _value;
Point2I ext = getExtent();
ext.x -= ( mShiftExtent + mThumbSize.x ) / 2;
// update the bounding thumb rect
if (getWidth() >= getHeight())
{ // HORZ thumb
S32 mx = (S32)((F32(ext.x) * (mValue-mRange.x) / (mRange.y-mRange.x)));
S32 my = ext.y/2;
if(mDisplayValue)
my = mThumbSize.y/2;
mThumb.point.x = mx - (mThumbSize.x/2);
mThumb.point.y = my - (mThumbSize.y/2);
mThumb.extent = mThumbSize;
}
else
{ // VERT thumb
S32 mx = ext.x/2;
S32 my = (S32)((F32(ext.y) * (mValue-mRange.x) / (mRange.y-mRange.x)));
mThumb.point.x = mx - (mThumbSize.y/2);
mThumb.point.y = my - (mThumbSize.x/2);
mThumb.extent.x = mThumbSize.y;
mThumb.extent.y = mThumbSize.x;
}
setFloatVariable(mValue);
setUpdate();
// Use the alt console command if you want to continually update:
if ( !onWake && doCallback )
execAltConsoleCallback();
}
//
// Moving State
//
void SquadMoveTogether::StateMoving()
{
SquadObj::UnitList::Iterator i(&subject->GetList());
for (!i; *i; i++)
{
if ((*i)->Alive() && (*i)->data <= S32(points.GetCount()))
{
// Someone hasn't made it
return;
}
}
// LOG_DIAG(("Entire squad has made it to the destination!"))
// Were we spawned by a task ?
if (task)
{
task->ProcessEvent(Event(0xF14439C5)); // "SquadMove::Completed"
}
else
{
subject->NotifyPlayer(0x763C5781); // "Squad::TaskCompleted"
}
Quit();
}
void SFXXAudioVoice::_flush()
{
AssertFatal( mXAudioVoice != NULL,
"SFXXAudioVoice::_flush() - invalid voice" );
EnterCriticalSection( &mLock );
mXAudioVoice->Stop( 0 );
mXAudioVoice->FlushSourceBuffers();
mNonStreamBufferLoaded = false;
#ifdef DEBUG_SPEW
Platform::outputDebugString( "[SFXXAudioVoice] Flushed state" );
#endif
mIsPlaying = false;
mHasStarted = false;
mHasStopped = true;
//WORKAROUND: According to the docs, SamplesPlayed reported by the
// voice should get reset as soon as we submit a new buffer to the voice.
// Alas it won't. So, save the current value here and offset our future
// play cursors.
XAUDIO2_VOICE_STATE state;
mXAudioVoice->GetState( &state );
mSamplesPlayedOffset = - S32( state.SamplesPlayed );
LeaveCriticalSection( &mLock );
}
static void tx_kickstart(struct net_device *dev)
{
struct fs_enet_private *fep = netdev_priv(dev);
fcc_t *fccp = fep->fcc.fccp;
S32(fccp, fcc_ftodr, 0x80);
}
void AtlasOldMesher::writeVertex(Stream *s, Vert *vert, const S8 level)
{
S16 x, y, z;
const Point2I &vertPos = vert->pos;
Point3F center;
mBounds.getCenter(¢er);
if (vert->special)
z = vert->z;
else
z = mHeight->sampleRead(vertPos);
S32 xTmp, yTmp;
xTmp = (S32)mFloor(((vertPos.x * mHeight->mSampleSpacing - center.x) * mCompressionFactor.x) + 0.5);
yTmp = (S32)mFloor(((vertPos.y * mHeight->mSampleSpacing - center.y) * mCompressionFactor.y) + 0.5);
AssertFatal(S16(xTmp) == xTmp,
"AtlasOldMesher::writeVertex - Overflow writing x-coordinate!");
AssertFatal(S16(yTmp) == yTmp,
"AtlasOldMesher::writeVertex - Overflow writing y-coordinate!");
x = xTmp;
y = yTmp;
s->write(x);
s->write(y);
s->write(z);
// Morph info. Calculate the difference between the
// vert height, and the height of the same spot in the
// next lower-LOD mesh.
S16 morphHeight;
if (vert->special)
morphHeight = z; // special verts don't morph.
else
{
morphHeight = mHeight->getHeightAtLOD(vertPos, level + 1);
}
S32 morphDelta = (S32(morphHeight) - S32(z));
s->write(S16(morphDelta));
if(morphDelta != S16(morphDelta))
Con::warnf("AtlasOldMesher::writeVertex - overflow in lerpedHeight!");
}
void handleNameTagOptionChanged(const LLSD& newvalue)
{
S32 name_tag_option = S32(newvalue);
if(name_tag_option==2)
{
gSavedSettings.setBOOL("SmallAvatarNames", TRUE);
}
}
void LLMultiSlider::setSliderValue(const std::string& name, F32 value, BOOL from_event)
{
// exit if not there
if(!mValue.has(name)) {
return;
}
value = llclamp( value, mMinValue, mMaxValue );
// Round to nearest increment (bias towards rounding down)
value -= mMinValue;
value += mIncrement/2.0001f;
value -= fmod(value, mIncrement);
F32 newValue = mMinValue + value;
// now, make sure no overlap
// if we want that
if(!mAllowOverlap) {
bool hit = false;
// look at the current spot
// and see if anything is there
LLSD::map_iterator mIt = mValue.beginMap();
for(;mIt != mValue.endMap(); mIt++) {
F32 testVal = (F32)mIt->second.asReal() - newValue;
if(testVal > -FLOAT_THRESHOLD && testVal < FLOAT_THRESHOLD &&
mIt->first != name) {
hit = true;
break;
}
}
// if none found, stop
if(hit) {
return;
}
}
// now set it in the map
mValue[name] = newValue;
// set the control if it's the current slider and not from an event
if (!from_event && name == mCurSlider)
{
setControlValue(mValue);
}
F32 t = (newValue - mMinValue) / (mMaxValue - mMinValue);
S32 left_edge = mThumbWidth/2;
S32 right_edge = getRect().getWidth() - (mThumbWidth/2);
S32 x = left_edge + S32( t * (right_edge - left_edge) );
mThumbRects[name].mLeft = x - (mThumbWidth/2);
mThumbRects[name].mRight = x + (mThumbWidth/2);
}
void LLFloaterWorldMap::trackLocation(const LLVector3d& pos_global)
{
LLSimInfo* sim_info = LLWorldMap::getInstance()->simInfoFromPosGlobal(pos_global);
if (!sim_info)
{
LLWorldMap::getInstance()->mIsTrackingUnknownLocation = TRUE;
LLWorldMap::getInstance()->mInvalidLocation = FALSE;
LLWorldMap::getInstance()->mUnknownLocation = pos_global;
LLTracker::stopTracking(NULL);
S32 world_x = S32(pos_global.mdV[0] / 256);
S32 world_y = S32(pos_global.mdV[1] / 256);
LLWorldMap::getInstance()->sendMapBlockRequest(world_x, world_y, world_x, world_y, true);
setDefaultBtn("");
return;
}
if (sim_info->mAccess == SIM_ACCESS_DOWN)
{
// Down sim. Show the blue circle of death!
LLWorldMap::getInstance()->mIsTrackingUnknownLocation = TRUE;
LLWorldMap::getInstance()->mUnknownLocation = pos_global;
LLWorldMap::getInstance()->mInvalidLocation = TRUE;
LLTracker::stopTracking(NULL);
setDefaultBtn("");
return;
}
std::string sim_name;
LLWorldMap::getInstance()->simNameFromPosGlobal( pos_global, sim_name );
F32 region_x = (F32)fmod( pos_global.mdV[VX], (F64)REGION_WIDTH_METERS );
F32 region_y = (F32)fmod( pos_global.mdV[VY], (F64)REGION_WIDTH_METERS );
std::string full_name = llformat("%s (%d, %d, %d)",
sim_name.c_str(),
llround(region_x),
llround(region_y),
llround((F32)pos_global.mdV[VZ]));
std::string tooltip("");
mTrackedStatus = LLTracker::TRACKING_LOCATION;
LLTracker::trackLocation(pos_global, full_name, tooltip);
LLWorldMap::getInstance()->mIsTrackingUnknownLocation = FALSE;
LLWorldMap::getInstance()->mIsTrackingDoubleClick = FALSE;
LLWorldMap::getInstance()->mIsTrackingCommit = FALSE;
setDefaultBtn("Teleport");
}
void LLFloaterWorldMap::trackLocation(const LLVector3d& pos_global)
{
LLSimInfo* sim_info = LLWorldMap::getInstance()->simInfoFromPosGlobal(pos_global);
if (!sim_info)
{
// We haven't found a region for that point yet, leave the tracking to the world map
LLWorldMap::getInstance()->setTracking(pos_global);
LLTracker::stopTracking(NULL);
S32 world_x = S32(pos_global.mdV[0] / 256);
S32 world_y = S32(pos_global.mdV[1] / 256);
LLWorldMapMessage::getInstance()->sendMapBlockRequest(world_x, world_y, world_x, world_y, true);
setDefaultBtn("");
return;
}
if (sim_info->isDown())
{
// Down region. Show the blue circle of death!
// i.e. let the world map that this and tell it it's invalid
LLWorldMap::getInstance()->setTracking(pos_global);
LLWorldMap::getInstance()->setTrackingInvalid();
LLTracker::stopTracking(NULL);
setDefaultBtn("");
return;
}
std::string sim_name = sim_info->getName();
F32 region_x = (F32)fmod( pos_global.mdV[VX], (F64)REGION_WIDTH_METERS );
F32 region_y = (F32)fmod( pos_global.mdV[VY], (F64)REGION_WIDTH_METERS );
std::string full_name = llformat("%s (%d, %d, %d)",
// sim_name.c_str(),
// [RLVa:KB] - Alternate: Snowglobe-1.2.4 | Checked: 2009-07-04 (RLVa-1.0.0a)
(!gRlvHandler.hasBehaviour(RLV_BHVR_SHOWLOC)) ? sim_name.c_str() : RlvStrings::getString(RLV_STRING_HIDDEN_REGION).c_str(),
// [/RLVa:KB]
llround(region_x),
llround(region_y),
llround((F32)pos_global.mdV[VZ]));
std::string tooltip("");
mTrackedStatus = LLTracker::TRACKING_LOCATION;
LLTracker::trackLocation(pos_global, full_name, tooltip);
LLWorldMap::getInstance()->cancelTracking(); // The floater is taking over the tracking
setDefaultBtn("Teleport");
}
//
// SetVolume
//
// Sets the current redbook audio volume
//
void SetVolume(F32 volume)
{
if (initialized && driver)
{
AIL_redbook_set_volume
(
driver, Clamp<S32>(MIN_VOLUME, S32((volume * F32(MAX_VOLUME)) + 0.5F), MAX_VOLUME)
);
}
}
/**
* @luafunc table Team::getColor()
*
* @brief Get the team color
*
* @desc
* The team color is a table with 3 values: red, green, blue. These are returned
* as integers in the range of 0-255
*
* @code
* local color = team:getColor()
*
* local red = color[0]
* local green = color[1]
* local blue = color[2]
* @endcode
*
* @return A table of RGB values for this team's color.
*/
S32 Team::lua_getColor(lua_State *L)
{
const Color &color = getColor();
S32 r = S32(color.r * 255);
S32 g = S32(color.g * 255);
S32 b = S32(color.b * 255);
lua_newtable(L); // Create a table, with no slots pre-allocated for our data
lua_pushinteger(L, r);
lua_rawseti(L, 1, 0);
lua_pushinteger(L, g);
lua_rawseti(L, 1, 1);
lua_pushinteger(L, b);
lua_rawseti(L, 1, 2);
return 1;
}
LLViewerParcelOverlay::LLViewerParcelOverlay(LLViewerRegion* region, F32 region_width_meters)
: mRegion( region ),
mParcelGridsPerEdge( S32( region_width_meters / PARCEL_GRID_STEP_METERS ) ),
mRegionSize(S32(region_width_meters)),
mDirty( FALSE ),
mTimeSinceLastUpdate(),
mOverlayTextureIdx(-1),
mVertexCount(0),
mVertexArray(NULL),
mColorArray(NULL)
// mTexCoordArray(NULL),
{
// Create a texture to hold color information.
// 4 components
// Use mipmaps = FALSE, clamped, NEAREST filter, for sharp edges
mImageRaw = new LLImageRaw(mParcelGridsPerEdge, mParcelGridsPerEdge, OVERLAY_IMG_COMPONENTS);
mTexture = LLViewerTextureManager::getLocalTexture(mImageRaw.get(), FALSE);
mTexture->setAddressMode(LLTexUnit::TAM_CLAMP);
mTexture->setFilteringOption(LLTexUnit::TFO_POINT);
//
// Initialize the GL texture with empty data.
//
// Create the base texture.
U8 *raw = mImageRaw->getData();
const S32 COUNT = mParcelGridsPerEdge * mParcelGridsPerEdge * OVERLAY_IMG_COMPONENTS;
for (S32 i = 0; i < COUNT; i++)
{
raw[i] = 0;
}
mTexture->setSubImage(mImageRaw, 0, 0, mParcelGridsPerEdge, mParcelGridsPerEdge);
// Create storage for ownership information from simulator
// and initialize it.
mOwnership = new U8[ mParcelGridsPerEdge * mParcelGridsPerEdge ];
for (S32 i = 0; i < mParcelGridsPerEdge * mParcelGridsPerEdge; i++)
{
mOwnership[i] = PARCEL_PUBLIC;
}
gPipeline.markGLRebuild(this);
}
// return the default inventory for the given asset type.
// static
LLInventoryType::EType LLInventoryType::defaultForAssetType(LLAssetType::EType asset_type)
{
if((asset_type >= 0) && (asset_type < LLAssetType::AT_COUNT))
{
return DEFAULT_ASSET_FOR_INV_TYPE[S32(asset_type)];
}
else
{
return IT_NONE;
}
}
const char* LLSaleInfo::lookup(EForSale type)
{
if((type >= 0) && (type < FS_COUNT))
{
return FOR_SALE_NAMES[S32(type)];
}
else
{
return NULL;
}
}
// XUI:translate
// translation from a type to a human readable form.
// static
const char* LLInventoryType::lookupHumanReadable(EType type)
{
if((type >= 0) && (type < IT_COUNT))
{
return INVENTORY_TYPE_HUMAN_NAMES[S32(type)];
}
else
{
return NULL;
}
}
// static
const char* LLAssetType::lookup( LLAssetType::EType type )
{
if( (type >= 0) && (type < AT_COUNT ))
{
return mAssetTypeNames[ S32( type ) ];
}
else
{
return "-1";
}
}
// static
const char* LLAssetType::lookupHumanReadable(LLAssetType::EType type)
{
if( (type >= 0) && (type < AT_COUNT ))
{
return mAssetTypeHumanNames[S32(type)];
}
else
{
return NULL;
}
}
/* Some transmit errors cause the transmitter to shut
* down. We now issue a restart transmit. Since the
* errors close the BD and update the pointers, the restart
* _should_ pick up without having to reset any of our
* pointers either. Also, To workaround 8260 device erratum
* CPM37, we must disable and then re-enable the transmitter
* following a Late Collision, Underrun, or Retry Limit error.
*/
static void tx_restart(struct net_device *dev)
{
struct fs_enet_private *fep = netdev_priv(dev);
fcc_t __iomem *fccp = fep->fcc.fccp;
C32(fccp, fcc_gfmr, FCC_GFMR_ENT);
udelay(10);
S32(fccp, fcc_gfmr, FCC_GFMR_ENT);
fcc_cr_cmd(fep, CPM_CR_RESTART_TX);
}
// Store previous scissors settings
void ScissorsManager::enable(bool enable, DisplayMode displayMode, F32 x, F32 y, F32 width, F32 height)
{
mManagerEnabled = enable;
if(!enable)
return;
mGL->glGetValue(GLOPT::ScissorTest, &mScissorsWasEnabled);
if(mScissorsWasEnabled)
mGL->glGetValue(GLOPT::ScissorBox, &mScissorBox[0]);
static Point p1, p2;
p1 = DisplayManager::getScreenInfo()->convertCanvasToWindowCoord(x, DisplayManager::getScreenInfo()->getGameCanvasHeight() - y - height, displayMode);
p2 = DisplayManager::getScreenInfo()->convertCanvasToWindowCoord(width, height, displayMode);
mGL->glScissor(S32(p1.x), S32(p1.y), S32(p2.x), S32(p2.y));
mGL->glEnable(GLOPT::ScissorTest);
}
LLViewerParcelOverlay::LLViewerParcelOverlay(LLViewerRegion* region, F32 region_width_meters)
: mRegion( region ),
mParcelGridsPerEdge( S32( region_width_meters / PARCEL_GRID_STEP_METERS ) ),
mDirty( FALSE ),
mTimeSinceLastUpdate(),
mOverlayTextureIdx(-1),
mVertexCount(0),
mVertexArray(NULL),
mColorArray(NULL)
// mTexCoordArray(NULL),
{
// Create a texture to hold color information.
// 4 components
// Use mipmaps = FALSE, clamped, NEAREST filter, for sharp edges
mTexture = new LLImageGL(FALSE);
mImageRaw = new LLImageRaw(mParcelGridsPerEdge, mParcelGridsPerEdge, OVERLAY_IMG_COMPONENTS);
mTexture->createGLTexture(0, mImageRaw);
gGL.getTexUnit(0)->activate();
gGL.getTexUnit(0)->bind(mTexture);
mTexture->setAddressMode(LLTexUnit::TAM_CLAMP);
mTexture->setFilteringOption(LLTexUnit::TFO_POINT);
//
// Initialize the GL texture with empty data.
//
// Create the base texture.
U8 *raw = mImageRaw->getData();
const S32 COUNT = mParcelGridsPerEdge * mParcelGridsPerEdge * OVERLAY_IMG_COMPONENTS;
for (S32 i = 0; i < COUNT; i++)
{
raw[i] = 0;
}
mTexture->setSubImage(mImageRaw, 0, 0, mParcelGridsPerEdge, mParcelGridsPerEdge);
// Create storage for ownership information from simulator
// and initialize it.
mOwnership = new U8[ mParcelGridsPerEdge * mParcelGridsPerEdge ];
for (S32 i = 0; i < mParcelGridsPerEdge * mParcelGridsPerEdge; i++)
{
mOwnership[i] = PARCEL_PUBLIC;
}
// Make sure the texture matches the ownership information.
updateOverlayTexture();
sShowPropertyLines = gSavedSettings.getBOOL("ShowPropertyLines");
mPropertyColorAvail = gColors.getColor4U("PropertyColorAvail");
mPropertyColorOther = gColors.getColor4U("PropertyColorOther");
mPropertyColorGroup = gColors.getColor4U("PropertyColorGroup");
mPropertyColorSelf = gColors.getColor4U("PropertyColorSelf");
mPropertyColorForSale = gColors.getColor4U("PropertyColorForSale");
mPropertyColorAuction = gColors.getColor4U("PropertyColorAuction");
}
void LLMultiGesture::dump()
{
llinfos << "key " << S32(mKey) << " mask " << U32(mMask)
<< " trigger " << mTrigger
<< " replace " << mReplaceText
<< llendl;
U32 i;
for (i = 0; i < mSteps.size(); ++i)
{
LLGestureStep* step = mSteps[i];
step->dump();
}
}
static struct elf_sh * read_elf_sh(const struct elf_sh *p)
{
static struct elf_sh hdr;
hdr = *p;
if (need_byteswap)
{
hdr.name = S32(hdr.name);
hdr.type = S32(hdr.type);
hdr.flags = S32(hdr.flags);
hdr.addr = S32(hdr.addr);
hdr.offset = S32(hdr.offset);
hdr.size = S32(hdr.size);
hdr.linke = S32(hdr.linke);
hdr.info = S32(hdr.info);
hdr.addralign = S32(hdr.addralign);
hdr.entsize = S32(hdr.entsize);
}
return &hdr;
}
///////////////////////////////////////////////////////////////////////////
//
// Base primitive
//
Prim::Prim(Cineractive *cineractive, FScope *fScope, S32 defaultPriority)
: cineractive(cineractive),
done(FALSE),
priority(defaultPriority)
{
startTime = F32(cineractive->elapsedCycles) * GameTime::INTERVAL;
// Load configuration
if (fScope)
{
priority = S32(StdLoad::TypeU32(fScope, "Priority", priority));
}
}
