double
OPMSD::calcStructMSD(const Topology& Itop) const
{
//Required to get the correct results
Sim->dynamics->updateAllParticles();
double acc = 0.0;
for (const shared_ptr<IDRange>& molRange : Itop.getMolecules())
{
Vector origPos(0,0,0), currPos(0,0,0);
double totmass = 0.0;
for (const unsigned long& ID : *molRange)
{
double pmass = Sim->species[Sim->particles[ID]]->getMass(ID);
totmass += pmass;
currPos += Sim->particles[ID].getPosition() * pmass;
origPos += initPos[ID] * pmass;
}
currPos /= totmass;
origPos /= totmass;
acc += (currPos - origPos).nrm2();
}
acc /= Itop.getMoleculeCount() * Sim->units.unitArea();
return acc;
}
void Camera1stPerson::CalcMatrix(void)
{
float cosa = cosf(currXZRads);
float sina = sinf(currXZRads);
glm::vec3 currPos(sina, 0.0f, cosa);
glm::vec3 UpRotAxis;
UpRotAxis.x = currPos.z;
UpRotAxis.y = currPos.y;
UpRotAxis.z = -currPos.x;
glm::mat4 xRotation = Utils::getRotationMatrixRads(UpRotAxis, currYRads);
currPos = glm::vec3(xRotation * glm::vec4(currPos, 0.0));
this->lookDir = glm::normalize(currPos);
this->upDir = glm::normalize(glm::cross(currPos, UpRotAxis));
this->CalcLookAtMatrix();
}
void MovableText::_setupGeometry()
{
assert(mpFont);
assert(!mpMaterial.isNull());
unsigned int vertexCount = 0;
//count letters to determine how many vertices are needed
std::string::iterator i = mCaption.begin();
std::string::iterator iend = mCaption.end();
for ( ; i != iend; ++i )
{
if ((*i != ' ') && (*i != '\n'))
{
vertexCount += 6;
}
}
if (mRenderOp.vertexData)
{
delete mRenderOp.vertexData;
mRenderOp.vertexData = NULL;
mUpdateColors = true;
}
if (mCaption.empty())
{
return;
}
if (!mRenderOp.vertexData)
mRenderOp.vertexData = new VertexData();
mRenderOp.indexData = 0;
mRenderOp.vertexData->vertexStart = 0;
mRenderOp.vertexData->vertexCount = vertexCount;
mRenderOp.operationType = RenderOperation::OT_TRIANGLE_LIST;
mRenderOp.useIndexes = false;
VertexDeclaration *decl = mRenderOp.vertexData->vertexDeclaration;
VertexBufferBinding *bind = mRenderOp.vertexData->vertexBufferBinding;
size_t offset = 0;
// create/bind positions/tex.ccord. buffer
if (!decl->findElementBySemantic(VES_POSITION))
decl->addElement(POS_TEX_BINDING, offset, VET_FLOAT3, VES_POSITION);
offset += VertexElement::getTypeSize(VET_FLOAT3);
if (!decl->findElementBySemantic(VES_TEXTURE_COORDINATES))
decl->addElement(POS_TEX_BINDING, offset, Ogre::VET_FLOAT2,
Ogre::VES_TEXTURE_COORDINATES, 0);
HardwareVertexBufferSharedPtr ptbuf =
HardwareBufferManager::getSingleton().createVertexBuffer(
decl->getVertexSize(POS_TEX_BINDING),
mRenderOp.vertexData->vertexCount,
HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY);
bind->setBinding(POS_TEX_BINDING, ptbuf);
// Colours - store these in a separate buffer because they change less often
if (!decl->findElementBySemantic(VES_DIFFUSE))
decl->addElement(COLOUR_BINDING, 0, VET_COLOUR, VES_DIFFUSE);
HardwareVertexBufferSharedPtr cbuf =
HardwareBufferManager::getSingleton().createVertexBuffer(
decl->getVertexSize(COLOUR_BINDING),
mRenderOp.vertexData->vertexCount,
HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY);
bind->setBinding(COLOUR_BINDING, cbuf);
float *pPCBuff =
static_cast<float*> (ptbuf->lock(HardwareBuffer::HBL_DISCARD));
Real spaceWidth = mSpaceWidth;
// Derive space width from a capital A
if (spaceWidth == 0)
spaceWidth = mpFont->getGlyphAspectRatio('A') * mCharHeight * 2.0;
float total_height = mCharHeight;
float total_width = 0.0f;
float current_width = 0.0f;
i = mCaption.begin();
iend = mCaption.end();
for ( ; i != iend; ++i )
{
if (*i == '\n')
{
total_height += mCharHeight + 0.01;
if ( current_width > total_width )
{
total_width = current_width;
current_width = 0.0;
}
}
else
{
current_width += mpFont->getGlyphAspectRatio(*i) * mCharHeight * 2.0;
}
}
if ( current_width > total_width )
{
total_width = current_width;
}
float top = 0.0f;
switch (mVerticalAlignment)
{
case MovableText::V_ABOVE:
top = total_height * 2;
break;
case MovableText::V_CENTER:
top = 0.5 * total_height * 2;
break;
case MovableText::V_BELOW:
top = 0.0f;
break;
}
float starting_left = 0.0f;
switch (mHorizontalAlignment)
{
case MovableText::H_LEFT:
starting_left = 0.0f;
break;
case MovableText::H_CENTER:
starting_left = -total_width / 2.0f;
break;
}
float left = starting_left;
bool newLine = true;
Real len = 0.0f;
// for calculation of AABB
Ogre::Vector3 min(9999999.0f), max(-9999999.0f), currPos(0.0f);
Ogre::Real maxSquaredRadius = -99999999.0f;
float largestWidth = 0.0f;
for (i = mCaption.begin(); i != iend; ++i)
{
if (newLine)
{
len = 0.0f;
for (String::iterator j = i; j != iend && *j != '\n'; j++)
{
if (*j == ' ')
len += spaceWidth;
else
len += mpFont->getGlyphAspectRatio(*j) * mCharHeight * 2.0;
}
newLine = false;
}
if (*i == '\n')
{
left = starting_left;
top -= mCharHeight * 2.0;
newLine = true;
continue;
}
if (*i == ' ')
{
// Just leave a gap, no tris
left += spaceWidth;
continue;
}
Real horiz_height = mpFont->getGlyphAspectRatio(*i);
Real u1, u2, v1, v2;
Ogre::Font::UVRect utmp;
utmp = mpFont->getGlyphTexCoords(*i);
u1 = utmp.left;
u2 = utmp.right;
v1 = utmp.top;
v2 = utmp.bottom;
// each vert is (x, y, z, u, v)
//-------------------------------------------------------------------------------------
// First tri
//
// Upper left
currPos = Ogre::Vector3(left, top, 0.0);
*pPCBuff++ = currPos.x;
*pPCBuff++ = currPos.y;
*pPCBuff++ = currPos.z;
*pPCBuff++ = u1;
*pPCBuff++ = v1;
// Deal with bounds
min.makeFloor(currPos);
max.makeCeil(currPos);
maxSquaredRadius = std::max(maxSquaredRadius, currPos.squaredLength());
top -= mCharHeight * 2.0;
// Bottom left
currPos = Ogre::Vector3(left, top, 0.0);
*pPCBuff++ = currPos.x;
*pPCBuff++ = currPos.y;
*pPCBuff++ = currPos.z;
*pPCBuff++ = u1;
*pPCBuff++ = v2;
// Deal with bounds
min.makeFloor(currPos);
max.makeCeil(currPos);
maxSquaredRadius = std::max(maxSquaredRadius, currPos.squaredLength());
top += mCharHeight * 2.0;
left += horiz_height * mCharHeight * 2.0;
// Top right
currPos = Ogre::Vector3(left, top, 0.0);
*pPCBuff++ = currPos.x;
*pPCBuff++ = currPos.y;
*pPCBuff++ = currPos.z;
*pPCBuff++ = u2;
*pPCBuff++ = v1;
//-------------------------------------------------------------------------------------
// Deal with bounds
min.makeFloor(currPos);
max.makeCeil(currPos);
maxSquaredRadius = std::max(maxSquaredRadius, currPos.squaredLength());
//-------------------------------------------------------------------------------------
// Second tri
//
// Top right (again)
currPos = Ogre::Vector3(left, top, 0.0);
*pPCBuff++ = currPos.x;
*pPCBuff++ = currPos.y;
*pPCBuff++ = currPos.z;
*pPCBuff++ = u2;
*pPCBuff++ = v1;
min.makeFloor(currPos);
max.makeCeil(currPos);
maxSquaredRadius = std::max(maxSquaredRadius, currPos.squaredLength());
top -= mCharHeight * 2.0;
left -= horiz_height * mCharHeight * 2.0;
// Bottom left (again)
currPos = Ogre::Vector3(left, top, 0.0);
*pPCBuff++ = currPos.x;
*pPCBuff++ = currPos.y;
*pPCBuff++ = currPos.z;
*pPCBuff++ = u1;
*pPCBuff++ = v2;
min.makeFloor(currPos);
max.makeCeil(currPos);
maxSquaredRadius = std::max(maxSquaredRadius, currPos.squaredLength());
left += horiz_height * mCharHeight * 2.0;
// Bottom right
currPos = Ogre::Vector3(left, top, 0.0);
*pPCBuff++ = currPos.x;
*pPCBuff++ = currPos.y;
*pPCBuff++ = currPos.z;
*pPCBuff++ = u2;
*pPCBuff++ = v2;
//-------------------------------------------------------------------------------------
min.makeFloor(currPos);
max.makeCeil(currPos);
maxSquaredRadius = std::max(maxSquaredRadius, currPos.squaredLength());
// Go back up with top
top += mCharHeight * 2.0;
float currentWidth = (left + 1) / 2 - 0;
if (currentWidth > largestWidth)
largestWidth = currentWidth;
}
// Unlock vertex buffer
ptbuf->unlock();
// update AABB/Sphere radius
mAABB = Ogre::AxisAlignedBox(min, max);
mRadius = Ogre::Math::Sqrt(maxSquaredRadius);
if (mUpdateColors)
this->_updateColors();
mNeedUpdate = false;
}
WIN_EVENT_RV winEventFile::getNextRecord(winEvent** ppEvent) {
WIN_EVENT_RV rv = WIN_EVENT_ERROR;
if (ppEvent && *ppEvent == NULL) {
DWORD dwLength = 0;
DWORD dwHeaderID = 0;
if (getData(&dwLength, sizeof(DWORD), m_lNextRecordPos, NULL) >= 0 &&
getData(&dwHeaderID, sizeof(DWORD), NULL) >= 0) {
LITTLETOHOST32(dwLength);
LITTLETOHOST32(dwHeaderID);
bool bFound = false;
if (dwHeaderID == EVENTLOGRECORD_HEADER_ID) {
bFound = true;
} else {
DEBUG("winEventFile::getNextRecord() Next record was not found in the expected location. Searching...");
while (!bFound) {
if (getData(&dwHeaderID, sizeof(DWORD), NULL) >= 0) {
LITTLETOHOST32(dwHeaderID);
if (dwHeaderID == EVENTLOGRECORD_HEADER_ID) {
DEBUG("winEventFile::getNextRecord() Next record found at offset: " << offset() - 8 << " (diff = " << ((offset() - 8) - m_lNextRecordPos) << ")");
bFound = true;
m_lNextRecordPos = currPos() - 8;
} else {
dwLength = dwHeaderID;
}
} else {
ERROR("winEventFile::getNextRecord() Failure reading data while trying to find record header.");
break;
}
}
}
if (bFound) {
char* buffer = (char*)calloc(EVENTLOGRECORD_LENGTH, 1);
if (buffer) {
if (getData(buffer, EVENTLOGRECORD_LENGTH, m_lNextRecordPos, NULL) >= 0) {
*ppEvent = new winEvent(this, buffer, m_lNextRecordPos, dwLength);
m_lNextRecordPos += dwLength;
rv = WIN_EVENT_SUCCESS;
} else {
ERROR("winEventFile::getNextRecord() Failure reading next record.");
}
free(buffer);
buffer = NULL;
} else {
ERROR("winEventFile::getNextRecord() Unable to allocate buffer for record storage.");
}
} else {
ERROR("winEventFile::getNextRecord() Unable to find next record.");
}
} else {
ERROR("winEventFile::getNextRecord() Failed reading length/header.");
}
} else {
ERROR("winEventFile::getNextRecord() Invalid destination pointer.");
}
return rv;
}
