// insert: two versions: depending on whether we need to copy the pointer.
// decide if monom is in the set: if so, (equiv monom, false) is returned.
// If it is not in the set, it is copied into the memory block, and (equiv monom, true) is returned.
// Note: the only pointers this function returns (as the first part of the pair) are pointers into
// the memory block.
std::pair<const int*, bool> findOrInsert(const int* monom)
{
std::pair<int*, int*> mon { mMonomialMemory.alloc(elementSize()) };
std::copy(monom, monom + elementSize(), mon.first);
assert(mon.second - mon.first >= elementSize());
return findOrInsertTopInternedMonomial(mon.first);
}
void
SimdArrayType::generateCode
(const SyntaxNodePtr &node,
LContext &lcontext) const
{
SimdLContext &slcontext = static_cast <SimdLContext &> (lcontext);
VariableNodePtr var = node.cast<VariableNode>();
if( var && var->initialValue.cast<ValueNode>())
{
SizeVector sizes;
SizeVector offsets;
coreSizes(0, sizes, offsets);
slcontext.addInst (new SimdInitializeInst(sizes,
offsets,
node->lineNumber));
return;
}
else if (isAssignment(node)) // return or assignment
{
slcontext.addInst (new SimdAssignArrayInst
(size(), elementSize(), node->lineNumber));
return;
}
else if ( node.cast<ArrayIndexNode>() )
{
if(unknownSize() || unknownElementSize())
{
slcontext.addInst (new SimdIndexVSArrayInst(elementSize(),
unknownElementSize(),
size(),
unknownSize(),
node->lineNumber));
}
else
{
slcontext.addInst (new SimdIndexArrayInst(elementSize(),
node->lineNumber,
size()));
}
return;
}
else if (node.cast<SizeNode>())
{
assert(size() == 0);
slcontext.addInst (new SimdPushRefInst (unknownSize(),
node->lineNumber));
}
else if (node.cast<CallNode>())
{
slcontext.addInst (new SimdPushPlaceholderInst(objectSize(),
node->lineNumber));
return;
}
}
void W32HBox::setPosition(int x, int y, Size size) {
int elementCounter = visibleElementsNumber();
if (elementCounter == 0) {
return;
}
x += leftMargin();
y += topMargin();
if (homogeneous()) {
Size elementSize(0, size.Height - topMargin() - bottomMargin());
for (W32WidgetList::const_iterator it = myElements.begin(); it != myElements.end(); ++it) {
if ((*it)->isVisible()) {
Size currentSize = (*it)->minimumSize();
elementSize.Width = std::max(currentSize.Width, elementSize.Width);
}
}
if (myAlignment != LEFT) {
const short extraWidth = size.Width - leftMargin() - rightMargin() - elementSize.Width * elementCounter - spacing() * (elementCounter - 1);
if (myAlignment == CENTER) {
x += extraWidth / 2;
} else if (myAlignment == RIGHT) {
x += extraWidth;
} else if (myAlignment == FILL) {
elementSize.Width += extraWidth / elementCounter;
}
}
const short deltaX = elementSize.Width + spacing();
for (W32WidgetList::const_iterator it = myElements.begin(); it != myElements.end(); ++it) {
if ((*it)->isVisible()) {
(*it)->setPosition(x, y, elementSize);
x += deltaX;
}
}
} else {
if (myAlignment != LEFT) {
short extraWidth = size.Width - leftMargin() - rightMargin() - spacing() * (elementCounter - 1);
for (W32WidgetList::const_iterator it = myElements.begin(); it != myElements.end(); ++it) {
if ((*it)->isVisible()) {
Size currentSize = (*it)->minimumSize();
extraWidth -= currentSize.Width;
}
}
if (myAlignment == CENTER) {
x += extraWidth / 2;
} else if (myAlignment == RIGHT) {
x += extraWidth;
}
}
const int elementHeight = size.Height - topMargin() - bottomMargin();
Size elementSize;
for (W32WidgetList::const_iterator it = myElements.begin(); it != myElements.end(); ++it) {
if ((*it)->isVisible()) {
Size elementSize = (*it)->minimumSize();
elementSize.Height = elementHeight;
(*it)->setPosition(x, y, elementSize);
x += elementSize.Width + spacing();
}
}
}
}
unsigned computeNrDashes(Stack* S) {
unsigned number = 1;
for (unsigned i = 0; i < S->stackPointer; ++i) {
number += 3 + elementSize(S->array[i]);
}
return number;
}
Tensor Tensor::reshape(const char* data, const std::vector<int>& shape, bool alloc, Format fmt)
{
if (device_ == VK_NULL_HANDLE)
{
CV_Error(Error::StsError, "device is NULL");
return *this;
}
CV_Assert(shape.size() > 0 && shape.size() <= 6);
if (shape_ != shape) shape_ = shape;
if (checkFormat(fmt) && fmt != format_) format_ = fmt;
size_t new_size = shapeCount(shape_) * elementSize(format_);
if (alloc || new_size > size_in_byte_)
alloc = true;
size_in_byte_ = new_size;
if (alloc)
{
buffer_.reset(new Buffer(device_, size_in_byte_, data));
}
else if (data)
{
void* p = map();
memcpy(p, data, size_in_byte_);
unMap();
}
return *this;
}
size_t compactTractChar::bytes() const
{
size_t elementSize( 0 );
if( m_tract.empty() )
{
unsigned char el0( 0 );
elementSize = sizeof( el0 );
}
else
{
elementSize = sizeof( m_tract.front() );
}
return ( sizeof( *this ) + ( elementSize * m_tract.size() ) ) * CHAR_BIT / 8.;
}
size_t
SimdArrayType::alignedObjectSize () const
{
return elementSize() * size();
}
size_t
SimdArrayType::objectSize () const
{
return elementSize() * size();
}
size_t StdArrayType::objectAlignment() const {
return elementSize();
}
size_t StdArrayType::objectSize() const {
return size()*elementSize();
}
bool
Reader::readProperty(PropertyInfo& prop)
{
size_t num = prop.size * elementSize(prop.dims);
size_t bytes = dataSizeInBytes(prop.type) * num;
char* buffer = 0;
//
// Cache the offset pointer
//
prop.offset = tell();
bool readok = false;
if (prop.requested)
{
if ((buffer = (char*)data(prop, bytes)))
{
read(buffer, bytes);
if (!m_error) readok = true;
}
else
{
seekForward(bytes);
}
}
else
{
seekForward(bytes);
}
if (m_error) return false;
if (readok)
{
if (m_swapped)
{
switch (prop.type)
{
case Gto::Int:
case Gto::String:
case Gto::Float:
swapWords(buffer, num);
break;
case Gto::Short:
case Gto::Half:
swapShorts(buffer, num);
break;
case Gto::Double:
swapWords(buffer, num * 2);
break;
case Gto::Byte:
case Gto::Boolean:
break;
}
}
dataRead(prop);
}
return true;
}
void AccessCase::emitIntrinsicGetter(AccessGenerationState& state)
{
CCallHelpers& jit = *state.jit;
JSValueRegs valueRegs = state.valueRegs;
GPRReg baseGPR = state.baseGPR;
GPRReg valueGPR = valueRegs.payloadGPR();
switch (intrinsic()) {
case TypedArrayLengthIntrinsic: {
jit.load32(MacroAssembler::Address(state.baseGPR, JSArrayBufferView::offsetOfLength()), valueGPR);
jit.boxInt32(valueGPR, valueRegs, CCallHelpers::DoNotHaveTagRegisters);
state.succeed();
return;
}
case TypedArrayByteLengthIntrinsic: {
TypedArrayType type = structure()->classInfo()->typedArrayStorageType;
jit.load32(MacroAssembler::Address(state.baseGPR, JSArrayBufferView::offsetOfLength()), valueGPR);
if (elementSize(type) > 1) {
// We can use a bitshift here since we TypedArrays cannot have byteLength that overflows an int32.
jit.lshift32(valueGPR, Imm32(logElementSize(type)), valueGPR);
}
jit.boxInt32(valueGPR, valueRegs, CCallHelpers::DoNotHaveTagRegisters);
state.succeed();
return;
}
case TypedArrayByteOffsetIntrinsic: {
GPRReg scratchGPR = state.scratchGPR;
CCallHelpers::Jump emptyByteOffset = jit.branch32(
MacroAssembler::NotEqual,
MacroAssembler::Address(baseGPR, JSArrayBufferView::offsetOfMode()),
TrustedImm32(WastefulTypedArray));
jit.loadPtr(MacroAssembler::Address(baseGPR, JSObject::butterflyOffset()), scratchGPR);
jit.loadPtr(MacroAssembler::Address(baseGPR, JSArrayBufferView::offsetOfVector()), valueGPR);
jit.loadPtr(MacroAssembler::Address(scratchGPR, Butterfly::offsetOfArrayBuffer()), scratchGPR);
jit.loadPtr(MacroAssembler::Address(scratchGPR, ArrayBuffer::offsetOfData()), scratchGPR);
jit.subPtr(scratchGPR, valueGPR);
CCallHelpers::Jump done = jit.jump();
emptyByteOffset.link(&jit);
jit.move(TrustedImmPtr(0), valueGPR);
done.link(&jit);
jit.boxInt32(valueGPR, valueRegs, CCallHelpers::DoNotHaveTagRegisters);
state.succeed();
return;
}
default:
break;
}
RELEASE_ASSERT_NOT_REACHED();
}
/// \brief Get the size of an element (not equal to char size for a variable-width encodings) of this string
/// \return the size of one element
std::size_t elementSize() const
{
return elementSize( (Encoding)m_encoding);
}
/// \brief Copy constructor
/// \brief o string reference to copy
StringConst( const String& o)
:String(ConstC,o.m_ar,o.m_size*elementSize(encoding()),encoding(),o.m_codepage){}
void LightFlareData::prepRender( SceneState *state, LightFlareState *flareState )
{
PROFILE_SCOPE( LightFlareData_prepRender );
// No elements then nothing to render.
if ( mElementCount == 0 )
return;
// We need these all over the place later.
const Point3F &camPos = state->getCameraPosition();
const RectI &viewport = GFX->getViewport();
const Point3F &lightPos = flareState->lightMat.getPosition();
LightInfo *lightInfo = flareState->lightInfo;
bool isVectorLight = lightInfo->getType() == LightInfo::Vector;
// Perform visibility testing on the light...
// Project the light position from world to screen space, we need this
// position later, and it tells us if it is actually onscreen.
Point3F lightPosSS;
bool onscreen = MathUtils::mProjectWorldToScreen( lightPos, &lightPosSS, viewport, GFX->getWorldMatrix(), gClientSceneGraph->getNonClipProjection() );
U32 visDelta = U32_MAX;
U32 fadeOutTime = 20;
U32 fadeInTime = 125;
// Fade factor based on amount of occlusion.
F32 occlusionFade = 1.0f;
bool lightVisible = true;
if ( !state->isReflectPass() )
{
// It is onscreen, so raycast as a simple occlusion test.
U32 losMask = STATIC_COLLISION_MASK |
ShapeBaseObjectType |
StaticTSObjectType |
ItemObjectType |
PlayerObjectType;
GameConnection *conn = GameConnection::getConnectionToServer();
if ( !conn )
return;
bool needsRaycast = true;
// NOTE: if hardware does not support HOQ it will return NULL
// and we will retry every time but there is not currently a good place
// for one-shot initialization of LightFlareState
if ( flareState->occlusionQuery == NULL )
flareState->occlusionQuery = GFX->createOcclusionQuery();
if ( flareState->fullPixelQuery == NULL )
flareState->fullPixelQuery = GFX->createOcclusionQuery();
if ( flareState->occlusionQuery &&
( ( isVectorLight && flareState->worldRadius > 0.0f ) ||
( !isVectorLight && mOcclusionRadius > 0.0f ) ) )
{
// Always treat light as onscreen if using HOQ
// it will be faded out if offscreen anyway.
onscreen = true;
U32 pixels = -1;
GFXOcclusionQuery::OcclusionQueryStatus status = flareState->occlusionQuery->getStatus( true, &pixels );
String str = flareState->occlusionQuery->statusToString( status );
Con::setVariable( "$Flare::OcclusionStatus", str.c_str() );
Con::setIntVariable( "$Flare::OcclusionVal", pixels );
if ( status == GFXOcclusionQuery::Occluded )
occlusionFade = 0.0f;
if ( status != GFXOcclusionQuery::Unset )
needsRaycast = false;
RenderPassManager *pass = state->getRenderPass();
OccluderRenderInst *ri = pass->allocInst<OccluderRenderInst>();
Point3F scale( Point3F::One );
if ( isVectorLight && flareState->worldRadius > 0.0f )
scale *= flareState->worldRadius;
else
scale *= mOcclusionRadius;
ri->type = RenderPassManager::RIT_Occluder;
ri->query = flareState->occlusionQuery;
ri->query2 = flareState->fullPixelQuery;
ri->position = lightPos;
ri->scale = scale;
ri->orientation = pass->allocUniqueXform( lightInfo->getTransform() );
ri->isSphere = true;
state->getRenderPass()->addInst( ri );
if ( status == GFXOcclusionQuery::NotOccluded )
{
U32 fullPixels;
flareState->fullPixelQuery->getStatus( true, &fullPixels );
occlusionFade = (F32)pixels / (F32)fullPixels;
// Approximation of the full pixel count rather than doing
// two queries, but it is not very accurate.
/*
F32 dist = ( camPos - lightPos ).len();
F32 radius = scale.x;
radius = ( radius / dist ) * state->getWorldToScreenScale().y;
occlusionFade = (F32)pixels / (4.0f * radius * radius);
occlusionFade = mClampF( occlusionFade, 0.0f, 1.0f );
*/
}
}
Con::setFloatVariable( "$Flare::OcclusionFade", occlusionFade );
if ( needsRaycast )
{
// Use a raycast to determine occlusion.
bool fps = conn->isFirstPerson();
GameBase *control = conn->getControlObject();
if ( control && fps )
control->disableCollision();
RayInfo rayInfo;
if ( gClientContainer.castRayRendered( camPos, lightPos, losMask, &rayInfo ) )
occlusionFade = 0.0f;
if ( control && fps )
control->enableCollision();
}
lightVisible = onscreen && occlusionFade > 0.0f;
// To perform a fade in/out when we gain or lose visibility
// we must update/store the visibility state and time.
U32 currentTime = Sim::getCurrentTime();
if ( lightVisible != flareState->visible )
{
flareState->visible = lightVisible;
flareState->visChangedTime = currentTime;
}
// Save this in the state so that we have it during the reflect pass.
flareState->occlusion = occlusionFade;
visDelta = currentTime - flareState->visChangedTime;
}
else // state->isReflectPass()
{
occlusionFade = flareState->occlusion;
lightVisible = flareState->visible;
visDelta = Sim::getCurrentTime() - flareState->visChangedTime;
}
// We can only skip rendering if the light is not visible, and it
// has elapsed the fadeOutTime.
if ( !lightVisible && visDelta > fadeOutTime )
return;
// In a reflection we only render the elements with zero distance.
U32 elementCount = mElementCount;
if ( state->isReflectPass() )
{
elementCount = 0;
for ( ; elementCount < mElementCount; elementCount++ )
{
if ( mElementDist[elementCount] > 0.0f )
break;
}
}
if ( elementCount == 0 )
return;
// A bunch of preparatory math before generating verts...
const Point2I &vpExtent = viewport.extent;
Point3F viewportExtent( vpExtent.x, vpExtent.y, 1.0f );
Point2I halfViewportExtentI( viewport.extent / 2 );
Point3F halfViewportExtentF( (F32)halfViewportExtentI.x * 0.5f, (F32)halfViewportExtentI.y, 0.0f );
Point3F screenCenter( 0,0,0 );
Point3F oneOverViewportExtent( 1.0f / viewportExtent.x, 1.0f / viewportExtent.y, 1.0f );
lightPosSS.y -= viewport.point.y;
lightPosSS *= oneOverViewportExtent;
lightPosSS = ( lightPosSS * 2.0f ) - Point3F::One;
lightPosSS.y = -lightPosSS.y;
lightPosSS.z = 0.0f;
Point3F flareVec( screenCenter - lightPosSS );
F32 flareLength = flareVec.len();
flareVec.normalizeSafe();
Point3F basePoints[4];
basePoints[0] = Point3F( -0.5, 0.5, 0.0 );
basePoints[1] = Point3F( -0.5, -0.5, 0.0 );
basePoints[2] = Point3F( 0.5, -0.5, 0.0 );
basePoints[3] = Point3F( 0.5, 0.5, 0.0 );
Point3F rotatedBasePoints[4];
rotatedBasePoints[0] = basePoints[0];
rotatedBasePoints[1] = basePoints[1];
rotatedBasePoints[2] = basePoints[2];
rotatedBasePoints[3] = basePoints[3];
Point3F fvec( -1, 0, 0 );
F32 rot = mAcos( mDot( fvec, flareVec ) );
Point3F rvec( 0, -1, 0 );
rot *= mDot( rvec, flareVec ) > 0.0f ? 1.0f : -1.0f;
vectorRotateZAxis( rotatedBasePoints[0], rot );
vectorRotateZAxis( rotatedBasePoints[1], rot );
vectorRotateZAxis( rotatedBasePoints[2], rot );
vectorRotateZAxis( rotatedBasePoints[3], rot );
// Here we calculate a the light source's influence on the effect's size
// and brightness...
// Scale based on the current light brightness compared to its normal output.
F32 lightSourceBrightnessScale = lightInfo->getBrightness() / flareState->fullBrightness;
// Scale based on world space distance from camera to light source.
F32 lightSourceWSDistanceScale = ( isVectorLight ) ? 1.0f : getMin( 10.0f / ( lightPos - camPos ).len(), 1.5f );
// Scale based on screen space distance from screen position of light source to the screen center.
F32 lightSourceSSDistanceScale = ( 1.5f - ( lightPosSS - screenCenter ).len() ) / 1.5f;
// Scale based on recent visibility changes, fading in or out.
F32 fadeInOutScale = 1.0f;
if ( lightVisible && visDelta < fadeInTime && flareState->occlusion )
fadeInOutScale = (F32)visDelta / (F32)fadeInTime;
else if ( !lightVisible && visDelta < fadeOutTime )
fadeInOutScale = 1.0f - (F32)visDelta / (F32)fadeOutTime;
// This combined scale influences the size of all elements this effect renders.
// Note we also add in a scale that is user specified in the Light.
F32 lightSourceIntensityScale = lightSourceBrightnessScale *
lightSourceWSDistanceScale *
lightSourceSSDistanceScale *
fadeInOutScale *
flareState->scale *
occlusionFade;
// The baseColor which modulates the color of all elements.
ColorF baseColor;
if ( flareState->fullBrightness == 0.0f )
baseColor = ColorF::BLACK;
else
// These are the factors which affect the "alpha" of the flare effect.
// Modulate more in as appropriate.
baseColor = ColorF::WHITE * lightSourceBrightnessScale * occlusionFade;
// Fill in the vertex buffer...
const U32 vertCount = 4 * elementCount;
if ( flareState->vertBuffer.isNull() ||
flareState->vertBuffer->mNumVerts != vertCount )
flareState->vertBuffer.set( GFX, vertCount, GFXBufferTypeDynamic );
GFXVertexPCT *pVert = flareState->vertBuffer.lock();
const Point2I &widthHeightI = mFlareTexture.getWidthHeight();
Point2F oneOverTexSize( 1.0f / (F32)widthHeightI.x, 1.0f / (F32)widthHeightI.y );
for ( U32 i = 0; i < elementCount; i++ )
{
Point3F *basePos = mElementRotate[i] ? rotatedBasePoints : basePoints;
ColorF elementColor( baseColor * mElementTint[i] );
if ( mElementUseLightColor[i] )
elementColor *= lightInfo->getColor();
Point3F elementPos;
elementPos = lightPosSS + flareVec * mElementDist[i] * flareLength;
elementPos.z = 0.0f;
F32 maxDist = 1.5f;
F32 elementDist = mSqrt( ( elementPos.x * elementPos.x ) + ( elementPos.y * elementPos.y ) );
F32 distanceScale = ( maxDist - elementDist ) / maxDist;
distanceScale = 1.0f;
const RectF &elementRect = mElementRect[i];
Point3F elementSize( elementRect.extent.x, elementRect.extent.y, 1.0f );
elementSize *= mElementScale[i] * distanceScale * mScale * lightSourceIntensityScale;
if ( elementSize.x < 100.0f )
{
F32 alphaScale = mPow( elementSize.x / 100.0f, 2 );
elementColor *= alphaScale;
}
elementColor.clamp();
Point2F texCoordMin, texCoordMax;
texCoordMin = elementRect.point * oneOverTexSize;
texCoordMax = ( elementRect.point + elementRect.extent ) * oneOverTexSize;
pVert->color = elementColor;
pVert->point = ( basePos[0] * elementSize * oneOverViewportExtent ) + elementPos;
pVert->texCoord.set( texCoordMin.x, texCoordMax.y );
pVert++;
pVert->color = elementColor;
pVert->point = ( basePos[1] * elementSize * oneOverViewportExtent ) + elementPos;
pVert->texCoord.set( texCoordMax.x, texCoordMax.y );
pVert++;
pVert->color = elementColor;
pVert->point = ( basePos[2] * elementSize * oneOverViewportExtent ) + elementPos;
pVert->texCoord.set( texCoordMax.x, texCoordMin.y );
pVert++;
pVert->color = elementColor;
pVert->point = ( basePos[3] * elementSize * oneOverViewportExtent ) + elementPos;
pVert->texCoord.set( texCoordMin.x, texCoordMin.y );
pVert++;
}
flareState->vertBuffer.unlock();
// Create and submit the render instance...
RenderPassManager *renderManager = state->getRenderPass();
ParticleRenderInst *ri = renderManager->allocInst<ParticleRenderInst>();
ri->vertBuff = &flareState->vertBuffer;
ri->primBuff = &mFlarePrimBuffer;
ri->translucentSort = true;
ri->type = RenderPassManager::RIT_Particle;
ri->sortDistSq = ( lightPos - camPos ).lenSquared();
ri->modelViewProj = &MatrixF::Identity;
ri->bbModelViewProj = ri->modelViewProj;
ri->count = elementCount;
// Only draw the light flare in high-res mode, never off-screen mode
ri->systemState = ParticleRenderInst::AwaitingHighResDraw;
ri->blendStyle = ParticleRenderInst::BlendGreyscale;
ri->diffuseTex = &*(mFlareTexture);
ri->softnessDistance = 1.0f;
// Sort by texture too.
ri->defaultKey = ri->diffuseTex ? (U32)ri->diffuseTex : (U32)ri->vertBuff;
renderManager->addInst( ri );
}
