void TiledLayerChromium::prepareToUpdate(const IntRect& layerRect)
{
m_skipsDraw = false;
m_skipsIdlePaint = false;
m_requestedUpdateTilesRect = IntRect();
m_paintRect = IntRect();
updateBounds();
if (layerRect.isEmpty() || !m_tiler->numTiles())
return;
int left, top, right, bottom;
m_tiler->layerRectToTileIndices(layerRect, left, top, right, bottom);
prepareToUpdateTiles(false, left, top, right, bottom);
}
void AcidDrop::update(float deltaTime)
{
m_fStateTime += deltaTime;
m_position->add(m_velocity->getX() * deltaTime, m_velocity->getY() * deltaTime);
updateBounds();
m_remove = ScreenUtils::isVectorOffScreen(*m_position);
if (OverlapTester::isPointInRectangle(*m_position, *m_destinationBounds))
{
World::getInstance()->getToxicClouds().push_back(std::unique_ptr<ToxicCloud>(new ToxicCloud(m_destinationBounds->getLowerLeft().getX() + m_destinationBounds->getWidth() / 2, m_destinationBounds->getLowerLeft().getY() + m_destinationBounds->getHeight() / 2, m_fWidth / 2, m_fWidth * 3, m_fPoisonTime, m_fPoisonToCreepHealthRatio)));
GameListener::getInstance()->playSound(SOUND_TOXIC_CLOUD);
m_remove = true;
}
}
void RendererImplementationBase3D::applyCurrentCoordinateSystem(const CoordinateSystemSpecification & spec)
{
const auto contents = renderView().visualizations();
for (auto visualization : contents)
{
auto rendered = static_cast<RenderedData *>(visualization);
rendered->setDefaultCoordinateSystem(spec);
}
updateAxisLabelFormat(spec);
updateBounds();
for (unsigned int i = 0; i < renderView().numberOfSubViews(); ++i)
{
resetCamera(true, i);
}
}
void EditorBuffer::draw(float x, float y, float w, float h) {
ofPushMatrix();
ofPushStyle();
ofTranslate(x, y);
// Need to calculate size of editor before drawing
updateBounds();
// Scale down if needed
float scale = 1;
if (bounds.width > 0 && bounds.height > 0) {
scale = min(w / bounds.width, h / bounds.height);
scale = min(scale, maxScale);
scale = max(scale, minScale);
ofScale(scale, scale);
}
// Move editor content if cursor is off screen
float offsetY = (h / scale) - cursorPoint.y;
if (offsetY < 0) {
ofTranslate(0, offsetY);
}
float offsetX = (w / scale) - cursorPoint.x;
if (offsetX < 0) {
ofTranslate(offsetX, 0);
}
// Draw selected text highlight
for (vector<ofTTFCharacter>::iterator i = shapes.begin(); i < shapes.end(); ++i) {
(*i).draw();
}
// Draw text buffer content
ofSetColor(textColor);
drawStrings();
// Draw cursor
ofSetColor(cursorColor);
ofRect(cursorPoint, 10, -lineHeight);
ofPopStyle();
ofPopMatrix();
}
void Overlay::rebuildGeometry()
{
Vector<Vector3> pos;
Vector< Color > colors;
pos.Push( Vector3(borderWidth, borderWidth, -0.1f) );
pos.Push( Vector3(borderWidth, size.y-borderWidth, -0.1f) );
pos.Push( Vector3(size.x-borderWidth, size.y-borderWidth, -0.1f) );
pos.Push( Vector3(size.x-borderWidth, borderWidth, -0.1f) );
Color color = backgroundColor;
color.a = opacity;
colors.Push(color);
colors.Push(color);
colors.Push(color);
colors.Push(color);
if( borderWidth > 0 )
{
pos.Push( Vector3(0, 0, -0.2f) );
pos.Push( Vector3(0, size.y, -0.2f) );
pos.Push( Vector3(size.x, size.y, -0.2f) );
pos.Push( Vector3(size.x, 0, -0.2f) );
color = borderColor;
colors.Push(color);
colors.Push(color);
colors.Push(color);
colors.Push(color);
}
GeometryBuffer* gb = renderable->getGeometryBuffer().get();
gb->clear();
gb->declarations.reset();
gb->set( VertexAttribute::Position, pos );
gb->set( VertexAttribute::Color, colors );
updateBounds();
}
bool GUIWidget::isDirty(bool cleanIfDirty)
{
if (!mIsActive)
return false;
bool dirty = mWidgetIsDirty || mDirtyContents.size() > 0;
if(cleanIfDirty && dirty)
{
mWidgetIsDirty = false;
for (auto& dirtyElement : mDirtyContents)
dirtyElement->_updateRenderElements();
mDirtyContents.clear();
updateBounds();
}
return dirty;
}
void LinksPlayer::setPropertyValue(
string name, string value, double duration, double by) {
//TODO: set scrollbar, support...
if (name == "transparency") {
double val;
val = stof(value);
if (val >= 0.0 && val <= 1.0) {
browserSetAlpha((int)(val * 0xFF), mBrowser);
}
} else if (name == "bounds") {
int x, y, w, h;
vector<string>* params;
params = split(value, ",");
if (params->size() != 4) {
delete params;
return;
}
x = (int)stof((*params)[0]);
y = (int)stof((*params)[1]);
w = (int)stof((*params)[2]);
h = (int)stof((*params)[3]);
delete params;
if (!hasBrowser) {
setBounds(x, y, w, h);
} else {
updateBounds(x, y, w, h);
}
return;
}
Player::setPropertyValue(name, value, duration, by);
}
void Form::update(float elapsedTime)
{
if (isDirty())
{
updateBounds();
// Cache themed attributes for performance.
_skin = getSkin(_state);
_opacity = getOpacity(_state);
GP_ASSERT(_layout);
if (_scroll != SCROLL_NONE)
{
updateScroll();
}
else
{
_layout->update(this, Vector2::zero());
}
}
}
bool CircleMesh::load(const float radius, int pointCount)
{
pointCount = std::max(3, pointCount);
const float radians = glm::two_pi<float>() / pointCount;
float theta = glm::half_pi<float>();
std::vector<Vertex> vertexarray;
vertexarray.reserve(pointCount + 1);
vertexarray.emplace_back(glm::vec3(0.f, 0.f, 0.f), glm::vec2(0.5f, 0.5f), glm::vec3(0.f, 0.f, 1.f));
for (int i = 0; i < pointCount; ++i)
{
vertexarray.emplace_back(glm::vec3(std::cos(theta) * radius, std::sin(theta) * radius, 0.f), glm::vec2(0.f), glm::vec3(0.f, 0.f, 1.f));
vertexarray.back().texCoords.x = (vertexarray.back().position.x / radius + 1.f) * 0.5f;
vertexarray.back().texCoords.y = 1.f - ((vertexarray.back().position.y / radius + 1.f) * 0.5f);
theta += radians;
}
std::vector<unsigned int> indices;
for (unsigned int i = 2; i < vertexarray.size(); ++i)
{
indices.push_back(0);
indices.push_back(i - 1);
indices.push_back(i);
}
indices.push_back(0);
indices.push_back(vertexarray.size() - 1);
indices.push_back(1);
m_radius = radius;
updateBounds(glm::vec3(-radius, -radius, 0.f), glm::vec3(radius, radius, 0.f));
return Mesh::load(vertexarray, indices);
}
void MediaPlayer::update(){
updateBounds();
if (que.size() > 0){
loadFromQue(queIndex);
}else{
if (groups.size() > 0){
calculateDimensions();
if (groups[groupIndex]->media.size() >= mediaIndex+1){
manageLooping();
timedelta = ofGetLastFrameTime();
if (loopingIndex == 1){
if (groups[groupIndex]->media[mediaIndex]->getPosition() > .96){
cout << "media done";
switchMedia(1);
}
}
groups[groupIndex]->media[mediaIndex]->update();
}
}
}
}
void Model::build()
{
if( modelBuilt ) return;
MeshRenderablesMap::iterator it = meshRenderables.find(mesh);
if( it == meshRenderables.end() )
{
RenderablesVector& rends = meshRenderables[mesh];
if( !MeshBuild(mesh, rends) )
{
LogError("Error building mesh '%s'", mesh->getPath().c_str());
return;
}
}
RenderablesVector& rends = meshRenderables[mesh];
for( size_t i = 0; i < rends.size(); ++i )
{
Renderable* rend = rends[i].get();
rend->onPreRender.Bind(this, &Model::onRender);
addRenderable( rend );
}
// Updates the model bounding box.
updateBounds();
// Re-compute the bounding box.
Transform* transform = getEntity()->getTransform().get();
transform->markBoundingVolumeDirty();
prepareSkinning();
modelBuilt = true;
}
void StaticSprite::loadSprite(uint32 fileHash, uint flags, int surfacePriority, int16 x, int16 y) {
_spriteResource.load(fileHash, true);
if (!_surface)
createSurface(surfacePriority, _spriteResource.getDimensions().width, _spriteResource.getDimensions().height);
if (flags & kSLFDefDrawOffset)
_drawOffset.set(0, 0, _spriteResource.getDimensions().width, _spriteResource.getDimensions().height);
else if (flags & kSLFCenteredDrawOffset)
_drawOffset.set(-(_spriteResource.getDimensions().width / 2), -(_spriteResource.getDimensions().height / 2),
_spriteResource.getDimensions().width, _spriteResource.getDimensions().height);
if (flags & kSLFDefPosition) {
_x = _spriteResource.getPosition().x;
_y = _spriteResource.getPosition().y;
} else if (flags & kSLFSetPosition) {
_x = x;
_y = y;
}
if (flags & kSLFDefCollisionBoundsOffset) {
_collisionBoundsOffset = _drawOffset;
updateBounds();
}
_needRefresh = true;
updatePosition();
}
void PSliderT<T>::setup(const std::string label, T *value, const T min, const T max, ci::Vec2<T> sliderLeft, ci::Vec2<T> sliderRight ){
mLabelText = label;
mValue = value;
mMin = min;
mMax = max;
mSliderLeft = sliderLeft;
mSliderRight = sliderRight;
mPosOffset = 0;
// texture skin rect
mSkinTexRect.set(0, 0, 13, 12);
mSkinDestRect = mSkinTexRect;
mSkinDestRect.offset(Vec2i(-7, -7));
bIsDragging = false;
mHandlePos.set(15, 22);
mHandleHitbox.set(-5, -7, 5, 5);
mSliderPct = 0.0f;
mGlobal = PretzelGlobal::getInstance();
updateBounds( mSliderLeft, mSliderRight );
}
void ColouredElement::setCurrentBounds (const Rectangle<int>& newBounds,
const Rectangle<int>& parentArea,
const bool undoable)
{
Rectangle<int> r (newBounds);
if (isStrokePresent)
{
r = r.expanded (-((int) strokeType.stroke.getStrokeThickness() / 2 + 1));
r.setSize (jmax (1, r.getWidth()), jmax (1, r.getHeight()));
}
RelativePositionedRectangle pr (position);
pr.updateFrom (r.getX() - parentArea.getX(),
r.getY() - parentArea.getY(),
r.getWidth(), r.getHeight(),
Rectangle<int> (0, 0, parentArea.getWidth(), parentArea.getHeight()),
getDocument()->getComponentLayout());
setPosition (pr, undoable);
updateBounds (parentArea);
}
// ----------------------------------------------------------------------
bool ObjMesh::loadFromObjFile(char *filename)
{
FILE *f = fopen(filename, "r");
if (!f) return false;
clear();
ObjMeshString s, subs[maxVerticesPerFace];
ObjMeshString mtllib, matName;
mHasTextureCoords = false;
mHasNormals = false;
strcpy(mtllib, "");
int materialNr = -1;
int i,j;
NxVec3 v;
ObjMeshTriangle t;
TexCoord tc;
std::vector<NxVec3> centermVertices;
std::vector<TexCoord> centermTexCoords;
std::vector<NxVec3> centerNormals;
extractPath(filename);
while (!feof(f)) {
if (fgets(s, OBJ_MESH_STRING_LEN, f) == NULL) break;
if (strncmp(s, "mtllib", 6) == 0) { // material library
sscanf(&s[7], "%s", mtllib);
importMtlFile(mtllib);
}
else if (strncmp(s, "usemtl", 6) == 0) { // use material
sscanf(&s[7], "%s", matName);
materialNr = 0;
int numMaterials = (int)mMaterials.size();
while (materialNr < numMaterials &&
strcasecmp(mMaterials[materialNr].name, matName) != 0)
materialNr++;
if (materialNr >= numMaterials)
materialNr = -1;
}
else if (strncmp(s, "v ", 2) == 0) { // vertex
sscanf(s, "v %f %f %f", &v.x, &v.y, &v.z);
mVertices.push_back(v);
}
else if (strncmp(s, "vn ", 3) == 0) { // normal
sscanf(s, "vn %f %f %f", &v.x, &v.y, &v.z);
mNormals.push_back(v);
}
else if (strncmp(s, "vt ", 3) == 0) { // texture coords
sscanf(s, "vt %f %f", &tc.u, &tc.v);
mTexCoords.push_back(tc);
}
else if (strncmp(s, "f ", 2) == 0) { // face
int nr;
nr = sscanf(s, "f %s %s %s %s %s %s %s %s %s %s %s %s %s %s %s",
subs[0], subs[1], subs[2], subs[3], subs[4],
subs[5], subs[6], subs[7], subs[8], subs[9],
subs[10], subs[11], subs[12],subs[13], subs[14]);
int vertNr[maxVerticesPerFace], texNr[maxVerticesPerFace];
int normalNr[maxVerticesPerFace];
for (i = 0; i < nr; i++) {
int refs[3];
parseRef(subs[i], refs);
vertNr[i] = refs[0]-1;
texNr[i] = refs[1]-1;
normalNr[i] = refs[2]-1;
}
if (nr <= 4) { // simple non-singular triangle or quad
if (vertNr[0] != vertNr[1] && vertNr[1] != vertNr[2] && vertNr[2] != vertNr[0]) {
t.init();
t.vertexNr[0] = vertNr[0];
t.vertexNr[1] = vertNr[1];
t.vertexNr[2] = vertNr[2];
t.normalNr[0] = normalNr[0];
t.normalNr[1] = normalNr[1];
t.normalNr[2] = normalNr[2];
t.texCoordNr[0] = texNr[0];
t.texCoordNr[1] = texNr[1];
t.texCoordNr[2] = texNr[2];
t.materialNr = materialNr;
mTriangles.push_back(t);
}
if (nr == 4) { // non-singular quad -> generate a second triangle
if (vertNr[2] != vertNr[3] && vertNr[3] != vertNr[0] && vertNr[0] != vertNr[2]) {
t.init();
t.vertexNr[0] = vertNr[2];
t.vertexNr[1] = vertNr[3];
t.vertexNr[2] = vertNr[0];
t.normalNr[0] = normalNr[2];
t.normalNr[1] = normalNr[3];
t.normalNr[2] = normalNr[0];
t.texCoordNr[0] = texNr[0];
t.texCoordNr[1] = texNr[1];
t.texCoordNr[2] = texNr[2];
t.materialNr = materialNr;
mTriangles.push_back(t);
}
}
}
else { // polygonal face
// compute center properties
NxVec3 centerPos(0.0f, 0.0f, 0.0f);
TexCoord centerTex; centerTex.zero();
for (i = 0; i < nr; i++) {
centerPos += mVertices[vertNr[i]];
if (texNr[i] >= 0) centerTex += mTexCoords[texNr[i]];
}
centerPos /= (float)nr;
centerTex /= (float)nr;
NxVec3 d1 = centerPos - mVertices[vertNr[0]];
NxVec3 d2 = centerPos - mVertices[vertNr[1]];
NxVec3 centerNormal = d1.cross(d2); centerNormal.normalize();
// add center vertex
centermVertices.push_back(centerPos);
centermTexCoords.push_back(centerTex);
centerNormals.push_back(centerNormal);
// add surrounding elements
for (i = 0; i < nr; i++) {
j = i+1; if (j >= nr) j = 0;
t.init();
t.vertexNr[0] = mVertices.size() + centermVertices.size()-1;
t.vertexNr[1] = vertNr[i];
t.vertexNr[2] = vertNr[j];
t.normalNr[0] = mNormals.size() + centerNormals.size()-1;
t.normalNr[1] = normalNr[i];
t.normalNr[2] = normalNr[j];
t.texCoordNr[0] = mTexCoords.size() + centermTexCoords.size()-1;
t.texCoordNr[1] = texNr[i];
t.texCoordNr[2] = texNr[j];
t.materialNr = materialNr;
mTriangles.push_back(t);
}
}
}
}
fclose(f);
// new center mVertices are inserted here.
// If they were inserted when generated, the vertex numbering would be corrupted
for (i = 0; i < (int)centermVertices.size(); i++)
mVertices.push_back(centermVertices[i]);
for (i = 0; i < (int)centerNormals.size(); i++)
mNormals.push_back(centerNormals[i]);
for (i = 0; i < (int)centermTexCoords.size(); i++)
mTexCoords.push_back(centermTexCoords[i]);
if (mTexCoords.size() > 0) mHasTextureCoords = true;
if (mNormals.size() > 0)
mHasNormals = true;
else
updateNormals();
updateBounds();
return true;
}
bool CapsuleMesh::load(const float radius, const float height, const unsigned int rings, const bool normalizedTexCoords)
{
m_radius = radius;
m_height = height;
m_rings = rings;
m_normTexCoords = normalizedTexCoords;
const float half = height * 0.5f;
const float stretch = radius / rings + 1.f;
const float R = 1.0f / (rings - 1);
const float S = 1.0f / (rings - 1);
const unsigned int texCoordMultS = normalizedTexCoords ? 1u : rings;
const unsigned int texCoordMultR = normalizedTexCoords ? 1u : rings;
std::vector<Vertex> vertexArray(rings * rings);
auto itr = vertexArray.begin();
for (std::size_t s = 0; s < rings; ++s)
{
for (std::size_t r = 0; r < rings; ++r)
{
static const float pi1 = glm::pi<float>();
static const float pi2 = glm::half_pi<float>();
float y = std::sin(-pi2 + pi1 * r * R);
const float x = std::cos(2 * pi1 * s * S) * std::sin(pi1 * r * R);
const float z = std::sin(2 * pi1 * s * S) * std::sin(pi1 * r * R);
if (y >= stretch)
y += half;
else
y -= half;
itr->position.x = x * radius;
itr->position.y = y * radius;
itr->position.z = z * radius;
itr->texCoords.x = texCoordMultS * s * -S;
itr->texCoords.y = texCoordMultR * r * R;
itr->normal.x = x;
itr->normal.y = y;
itr->normal.z = z;
++itr;
}
}
std::vector<unsigned int> indices(rings * rings * 6);
auto i = indices.begin();
for (std::size_t r = 0; r < rings - 1; ++r)
{
for (std::size_t s = 0; s < rings - 1; ++s)
{
// First triangle
*i++ = r * rings + s; // 0, 0
*i++ = r * rings + (s + 1); // 1, 0
*i++ = (r + 1) * rings + (s + 1); // 1, 1
// Second triangle
*i++ = r * rings + s; // 0, 0
*i++ = (r + 1) * rings + (s + 1); // 1, 1
*i++ = (r + 1) * rings + s; // 0, 1
}
}
updateBounds(glm::vec3(-radius, -half, -radius), glm::vec3(radius, half, radius));
return Mesh::load(vertexArray, indices);
}
void AtlasOldMesher::write(Stream *s, const S8 level, bool doWriteCollision)
{
AssertISV(mIndices.size(), "AtlasOldMesher::write - no indices to write?!?");
// First, figure our bounds.
updateBounds();
// Then, run the tristripper, get our geometry a bit more optimal.
///optimize();
// We start at the appropriate position in the TOC. It's great!
// Write min & max y values. This can be used to reconstruct
// the bounding box.
s->write(mMinZ);
s->write(mMaxZ);
// Write a placeholder for the mesh data file pos.
U32 currentPos = s->getPosition();
s->write(U32(0));
// write out the vertex data at the *end* of the file.
s->setPosition(s->getStreamSize());
U32 meshPos = s->getPosition();
// Write a sentinel.
s->write(U32(0xbeef1234));
// Make sure the vertex buffer is not too big.
if(mVerts.size() > 0xFFFF)
{
AssertISV(false,
"AtlasOldMesher::write - too many vertices! (> 65535) Try making a deeper tree!");
}
// Write vertices. All verts contain morph info.
s->write(U16(mVerts.size()));
for (int i = 0; i < mVerts.size(); i++)
writeVertex(s, &mVerts[i], level);
// Write the index buffer.
s->write(S32(mIndices.size()));
for(S32 i=0; i<mIndices.size(); i++)
s->write(mIndices[i]);
// Write the triangle count.
s->write(U32(mIndices.size()) / 3);
gOldChunkGenStats.outputRealTriangles += mIndices.size() / 3;
// Now, we have to make our collision info...
if(doWriteCollision)
{
s->write(U8(1));
writeCollision(s);
}
else
{
s->write(U8(0));
}
// write the postscript.
s->write(U32(0xb1e2e3f4));
// Rewind, and fill in the mesh data file pos.
s->setPosition(currentPos);
s->write(meshPos);
// Con::printf(" - %d indices, %d verts, meshOffset=%d", mIndices.size(), mVerts.size(), meshPos);
}
virtual void updatePosition( Point3D new_pos ) {
m_pos_text = new_pos;
updateBounds();
}
void GameLevel::load(const std::string &levelFile) {
unload();
std::string buffer = levelFile.empty() ? sTemplateMap : JsonParser::getBuffer(levelFile);
if (buffer.empty()) {
load("");
return;
}
JsonParser parser(buffer);
if (!parser) {
CCLOG("%s", buffer.c_str());
CCLOGERROR("Cannot load the level file: %s", levelFile.c_str());
}
CCLOG("Loading level file: %s", levelFile.empty() ? "Template" : levelFile.c_str());
auto& doc = parser.getCurrentDocument();
std::string paletteFile = doc[LEVEL_PALETTE_FILE].GetString();
CC_SAFE_DELETE(mPalette);
mPalette = new ColorPalette(paletteFile);
// Shadows.
if (doc.HasMember(SHADOW_GROUP)) {
mNumShadowGroup = doc[SHADOW_GROUP].Size();
parser.parseArray(doc, SHADOW_GROUP, [&](JsonSizeT i, JsonValueT &val) {
addShadowGroup();
mShadows[i]->load(val);
initShadowGroup(i);
});
}
// Sprites.
CC_ASSERT(mSpriteList.empty());
if (doc.HasMember(GAME_SPRITES)) {
parser.parseArray(doc, GAME_SPRITES, [&](JsonSizeT i, JsonValueT &val) {
mSpriteList.push_back(new GameSprite());
mSpriteList.back()->load(val);
mGameLayer->getBlockRoot()->addChild(mSpriteList.back()->getSprite(),
mSpriteList.back()->ZOrder);
});
}
// Effects.
CC_ASSERT(mEffects.empty());
if (doc.HasMember(GAME_FX)) {
parser.parseArray(doc, GAME_FX, [&](JsonSizeT i, JsonValueT &val) {
mEffects.push_back(val.GetString());
});
}
loadFx();
// Objects.
mHeroSpawnPos = doc[LEVEL_SPAWN_POS].GetVec2();
createHero(mHeroSpawnPos);
parser.parseArray(doc, LEVEL_BLOCK_ARRAY, [&](JsonSizeT i, JsonValueT& val) {
mObjectManager->createObject(val);
});
// Update shadow right after loading objects.
for (auto sm : mShadows) {
sm->update(0);
}
// Time events.
CC_ASSERT(mTimeEvents.empty());
if (doc.HasMember(TIME_EVENTS)) {
parser.parseArray(doc, TIME_EVENTS, [&](JsonSizeT i, JsonValueT &val) {
auto timeEvent = new TimeEvent();
timeEvent->load(val);
mTimeEvents.push_back(timeEvent);
});
}
updateBounds();
mBackground->clear();
mBackground->drawSolidRect({mBounds.getMinX(), mBounds.getMinY()},
{mBounds.getMaxX(), mBounds.getMaxY()},
Color4F(mPalette->getBackgroundColor()));
setCurrentFile(levelFile);
mGameLayer->afterLoad();
}
/** Removes any transparent borders by reducing the boundaries.
*
* This function reduces the bounds of an image until the top and
* bottom rows, and the left and right columns of pixels each
* contain at least one pixel with a non-zero alpha value
* (i.e. non-transparent pixel). Both mBounds and
* the size of #mImage are updated.
*
* @pre mBounds.size() == mImage->size()
* @post Either the first and last rows and columns all contain a
* pixel with alpha > 0 or mBounds.isEmpty() == true
* @post isMinimallyBounded() == true
*/
void BitmapImage::autoCrop()
{
if (!mEnableAutoCrop) return;
if (mBounds.isEmpty()) return; // Exit if current bounds are null
if (!mImage) return;
Q_ASSERT(mBounds.size() == mImage->size());
// Exit if already min bounded
if (mMinBound) return;
// Get image properties
const int width = mImage->width();
// Relative top and bottom row indices (inclusive)
int relTop = 0;
int relBottom = mBounds.height()-1;
// Check top row
bool isEmpty = true; // Used to track if a non-transparent pixel has been found
while (isEmpty && relTop <= relBottom) // Loop through rows
{
// Point cursor to the first pixel in the current top row
const QRgb* cursor = reinterpret_cast<const QRgb*>(mImage->constScanLine(relTop));
for (int col = 0; col < width; col++) // Loop through pixels in row
{
// If the pixel is not transparent
// (i.e. alpha channel > 0)
if (qAlpha(*cursor) != 0)
{
// We've found a non-transparent pixel in row relTop,
// so we can stop looking for one
isEmpty = false;
break;
}
// Move cursor to point to the next pixel in the row
cursor++;
}
if (isEmpty)
{
// If the row we just checked was empty, increase relTop
// to remove the empty row from the top of the bounding box
++relTop;
}
}
// Check bottom row
isEmpty = true; // Reset isEmpty
while (isEmpty && relBottom >= relTop) // Loop through rows
{
// Point cursor to the first pixel in the current bottom row
const QRgb* cursor = reinterpret_cast<const QRgb*>(mImage->constScanLine(relBottom));
for (int col = 0; col < width; col++) // Loop through pixels in row
{
// If the pixel is not transparent
// (i.e. alpha channel > 0)
if(qAlpha(*cursor) != 0)
{
// We've found a non-transparent pixel in row relBottom,
// so we can stop looking for one
isEmpty = false;
break;
}
// Move cursor to point to the next pixel in the row
++cursor;
}
if (isEmpty)
{
// If the row we just checked was empty, decrease relBottom
// to remove the empty row from the bottom of the bounding box
--relBottom;
}
}
// Relative left and right column indices (inclusive)
int relLeft = 0;
int relRight = mBounds.width()-1;
// Check left row
isEmpty = (relBottom >= relTop); // Check left only when
while (isEmpty && relBottom >= relTop && relLeft <= relRight) // Loop through columns
{
// Point cursor to the pixel at row relTop and column relLeft
const QRgb* cursor = reinterpret_cast<const QRgb*>(mImage->constScanLine(relTop)) + relLeft;
// Loop through pixels in column
// Note: we only need to loop from relTop to relBottom (inclusive)
// not the full image height, because rows 0 to relTop-1 and
// relBottom+1 to mBounds.height() have already been
// confirmed to contain only transparent pixels
for (int row = relTop; row <= relBottom; row++)
{
// If the pixel is not transparent
// (i.e. alpha channel > 0)
if(qAlpha(*cursor) != 0)
{
// We've found a non-transparent pixel in column relLeft,
// so we can stop looking for one
isEmpty = false;
break;
}
// Move cursor to point to next pixel in the column
// Increment by width because the data is in row-major order
cursor += width;
}
if (isEmpty)
{
// If the column we just checked was empty, increase relLeft
// to remove the empty column from the left of the bounding box
++relLeft;
}
}
// Check right row
isEmpty = (relBottom >= relTop); // Reset isEmpty
while (isEmpty && relRight >= relLeft) // Loop through columns
{
// Point cursor to the pixel at row relTop and column relRight
const QRgb* cursor = reinterpret_cast<const QRgb*>(mImage->constScanLine(relTop)) + relRight;
// Loop through pixels in column
// Note: we only need to loop from relTop to relBottom (inclusive)
// not the full image height, because rows 0 to relTop-1 and
// relBottom+1 to mBounds.height()-1 have already been
// confirmed to contain only transparent pixels
for (int row = relTop; row <= relBottom; row++)
{
// If the pixel is not transparent
// (i.e. alpha channel > 0)
if(qAlpha(*cursor) != 0)
{
// We've found a non-transparent pixel in column relRight,
// so we can stop looking for one
isEmpty = false;
break;
}
// Move cursor to point to next pixel in the column
// Increment by width because the data is in row-major order
cursor += width;
}
if (isEmpty)
{
// If the column we just checked was empty, increase relRight
// to remove the empty column from the left of the bounding box
--relRight;
}
}
//qDebug() << "Original" << mBounds;
//qDebug() << "Autocrop" << relLeft << relTop << relRight - mBounds.width() + 1 << relBottom - mBounds.height() + 1;
// Update mBounds and mImage if necessary
updateBounds(mBounds.adjusted(relLeft, relTop, relRight - mBounds.width() + 1, relBottom - mBounds.height() + 1));
//qDebug() << "New bounds" << mBounds;
mMinBound = true;
}
float DisplayObject::getWidth() {
updateBounds();
return absf(_max.x - _min.x);
}
bool msgProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) {
if(msg == WM_SIZE) {
updateBounds(hwnd);
}
if(msg == WM_PAINT) {
updateBounds(hwnd);
updateGraph(hwnd);
}
if(msg == WM_DESTROY) {
//SendMessage(GetParent(hwnd), WM_GRAPH_CHANGED, 0, 0);
bClosed = true;
}
if(msg == WM_CREATE) {
updateGraph(hwnd);
}
if(msg == WM_LBUTTONDBLCLK) {
// POINT point;
//GetCursorPos(&point);
int xPos = LOWORD(lParam);
int yPos = HIWORD(lParam);
RECT rect;
GetClientRect(hwnd, &rect);
if((xPos >= rect.left) && (xPos <= rect.right) && (yPos >= rect.top) &&
(yPos <= rect.bottom))
{
float x = toGraphX(xPos);
float y = toGraphY(rect.bottom - yPos);
for(int i = 0; i < mChannels.size(); i++) {
Channel* c = &mChannels[i];
c->insertKey(x);
}
}
updateGraph(hwnd);
}
if((msg == WM_MOUSEMOVE) && mLocked) {
if(wParam != MK_LBUTTON) {
mLocked = false;
} else {
POINT point;
point.x = LOWORD(lParam);
point.y = HIWORD(lParam);
/* //GetCursorPos(&point);
RECT rect;
GetClientRect(hwnd, &rect);
float x = (float)(point.x - rect.left) / (float)(rect.right - rect.left);
float y = 1.0f - (float)(point.y - rect.top) / (float)(rect.bottom - rect.top);
float dx = x - mOldX;
float dy = y - mOldY;
*/
RECT rc;
GetClientRect(hwnd, &rc);
float x = toGraphX(point.x);
float y = toGraphY(rc.bottom - point.y);
Channel* c = &mChannels[mLockedChannel];
c->moveKey(x,y,mXTreshold, ymin, ymax);
mOldX = x;
mOldY = y;
}
updateGraph(hwnd);
}
if((msg == WM_LBUTTONDOWN) & !mLocked) {
POINT point;
//GetCursorPos(&point);
point.x = LOWORD(lParam);
point.y = HIWORD(lParam);
RECT rc;
GetClientRect(hwnd, &rc);
// float x = (float)(point.x - rect.left) / (float)(rect.right - rect.left);
// float y = 1.0f - (float)(point.y - rect.top) / (float)(rect.bottom - rect.top);
float x = toGraphX(point.x);
float y = toGraphY(rc.bottom - point.y);
for(int i = 0; i < mChannels.size(); i++) {
Channel* c = &mChannels[i];
if(c->lockKey(x, y, mXTreshold, mYTreshold)) {
mLockedChannel = i;
mLocked = true;
mOldX = x;
mOldY = y;
break;
}
}
}
return false;
}
void ConvexShape::_updateGeometry( bool updateCollision )
{
mPlanes.clear();
for ( S32 i = 0; i < mSurfaces.size(); i++ )
mPlanes.push_back( PlaneF( mSurfaces[i].getPosition(), mSurfaces[i].getUpVector() ) );
Vector< Point3F > tangents;
for ( S32 i = 0; i < mSurfaces.size(); i++ )
tangents.push_back( mSurfaces[i].getRightVector() );
mGeometry.generate( mPlanes, tangents );
AssertFatal( mGeometry.faces.size() <= mSurfaces.size(), "Got more faces than planes?" );
const Vector< ConvexShape::Face > &faceList = mGeometry.faces;
const Vector< Point3F > &pointList = mGeometry.points;
// Reset our surface center points.
for ( S32 i = 0; i < faceList.size(); i++ )
mSurfaces[ faceList[i].id ].setPosition( faceList[i].centroid );
mPlanes.clear();
for ( S32 i = 0; i < mSurfaces.size(); i++ )
mPlanes.push_back( PlaneF( mSurfaces[i].getPosition(), mSurfaces[i].getUpVector() ) );
// Update bounding box.
updateBounds( false );
mVertexBuffer = NULL;
mPrimitiveBuffer = NULL;
mVertCount = 0;
mPrimCount = 0;
if ( updateCollision )
_updateCollision();
// Server does not need to generate vertex/prim buffers.
if ( isServerObject() )
return;
if ( faceList.empty() )
return;
// Get total vert and prim count.
for ( S32 i = 0; i < faceList.size(); i++ )
{
U32 count = faceList[i].triangles.size();
mPrimCount += count;
mVertCount += count * 3;
}
// Allocate VB and copy in data.
mVertexBuffer.set( GFX, mVertCount, GFXBufferTypeStatic );
VertexType *pVert = mVertexBuffer.lock();
for ( S32 i = 0; i < faceList.size(); i++ )
{
const ConvexShape::Face &face = faceList[i];
const Vector< U32 > &facePntMap = face.points;
const Vector< ConvexShape::Triangle > &triangles = face.triangles;
const ColorI &faceColor = sgConvexFaceColors[ i % sgConvexFaceColorCount ];
const Point3F binormal = mCross( face.normal, face.tangent );
for ( S32 j = 0; j < triangles.size(); j++ )
{
for ( S32 k = 0; k < 3; k++ )
{
pVert->normal = face.normal;
pVert->tangent = face.tangent;
pVert->color = faceColor;
pVert->point = pointList[ facePntMap[ triangles[j][k] ] ];
pVert->texCoord = face.texcoords[ triangles[j][k] ];
pVert++;
}
}
}
mVertexBuffer.unlock();
// Allocate PB
mPrimitiveBuffer.set( GFX, mPrimCount * 3, mPrimCount, GFXBufferTypeStatic );
U16 *pIndex;
mPrimitiveBuffer.lock( &pIndex );
for ( U16 i = 0; i < mPrimCount * 3; i++ )
{
*pIndex = i;
pIndex++;
}
mPrimitiveBuffer.unlock();
}
boost::uint32_t InPlaceReprojection::readBufferImpl(PointBuffer& buffer)
{
const boost::uint32_t numPoints = getPrevIterator().read(buffer);
const Schema& schema = buffer.getSchema();
Dimension const& old_x = schema.getDimension(m_reprojectionFilter.getOldXId());
Dimension const& old_y = schema.getDimension(m_reprojectionFilter.getOldYId());
Dimension const& old_z = schema.getDimension(m_reprojectionFilter.getOldZId());
Dimension const& new_x = schema.getDimension(m_reprojectionFilter.getNewXId());
Dimension const& new_y = schema.getDimension(m_reprojectionFilter.getNewYId());
Dimension const& new_z = schema.getDimension(m_reprojectionFilter.getNewZId());
bool logOutput = m_reprojectionFilter.log()->getLevel() > logDEBUG3;
if (logOutput)
{
m_reprojectionFilter.log()->floatPrecision(8);
m_reprojectionFilter.log()->get(logDEBUG3) << "old_x: " << old_x;
m_reprojectionFilter.log()->get(logDEBUG3) << "old_y: " << old_y;
m_reprojectionFilter.log()->get(logDEBUG3) << "old_z: " << old_z;
m_reprojectionFilter.log()->get(logDEBUG3) << "new_x: " << new_x;
m_reprojectionFilter.log()->get(logDEBUG3) << "new_y: " << new_y;
m_reprojectionFilter.log()->get(logDEBUG3) << "new_z: " << new_z;
}
logOutput = m_reprojectionFilter.log()->getLevel() > logDEBUG3;
for (boost::uint32_t pointIndex=0; pointIndex<numPoints; pointIndex++)
{
double x = m_reprojectionFilter.getScaledValue(buffer, old_x, pointIndex);
double y = m_reprojectionFilter.getScaledValue(buffer, old_y, pointIndex);
double z = m_reprojectionFilter.getScaledValue(buffer, old_z, pointIndex);
if (logOutput)
m_reprojectionFilter.log()->get(logDEBUG5) << "input: " << x << " y: " << y << " z: " << z << std::endl;
m_reprojectionFilter.transform(x,y,z);
if (logOutput)
m_reprojectionFilter.log()->get(logDEBUG5) << "output: " << x << " y: " << y << " z: " << z << std::endl;
m_reprojectionFilter.setScaledValue(buffer, x, new_x, pointIndex);
m_reprojectionFilter.setScaledValue(buffer, y, new_y, pointIndex);
m_reprojectionFilter.setScaledValue(buffer, z, new_z, pointIndex);
if (logOutput)
{
m_reprojectionFilter.log()->get(logDEBUG5) << "scaled: " << m_reprojectionFilter.getScaledValue(buffer, new_x, pointIndex)
<< " y: " << m_reprojectionFilter.getScaledValue(buffer, new_y, pointIndex)
<< " z: " << m_reprojectionFilter.getScaledValue(buffer, new_z, pointIndex) << std::endl;
}
buffer.setNumPoints(pointIndex+1);
}
if (logOutput)
m_reprojectionFilter.log()->clearFloat();
updateBounds(buffer);
return numPoints;
}
void ElectricBolt::update(float deltaTime, std::vector<std::unique_ptr<Creep>> &creeps, std::vector<std::unique_ptr<WorldPlatform>> &platforms, std::vector<std::unique_ptr<Projectile>> &projectiles)
{
m_fStateTime += deltaTime;
m_fFireTime += deltaTime;
m_position->add(m_velocity->getX() * deltaTime, m_velocity->getY() * deltaTime);
updateBounds();
m_remove = ScreenUtils::isVectorOffScreen(*m_position);
m_fAlpha -= deltaTime / m_iFadeTimeSeconds;
m_remove = m_fAlpha < 0;
if (!m_remove && m_fFireTime > m_fDamageTime)
{
m_iDamageSinceLastUpdate = 0;
while (m_fFireTime > m_fDamageTime)
{
m_fFireTime -= m_fDamageTime;
m_iDamageSinceLastUpdate += m_iDamage;
}
for (std::vector<std::unique_ptr<Creep>>::iterator itr = creeps.begin(); itr != creeps.end(); itr++)
{
if (OverlapTester::doRectanglesOverlap((*itr)->getBounds(), *m_bounds))
{
(*itr)->takeDamage(m_iDamageSinceLastUpdate, ELECTRIC);
if(FlagUtil::isFlagSet((*itr)->getState(), ALIVE))
{
(*itr)->electrify();
}
}
}
for (std::vector<std::unique_ptr<Projectile>>::iterator itr = projectiles.begin(); itr != projectiles.end(); itr++)
{
if ((*itr)->getProjectileState() == Projectile_State::STUCK && OverlapTester::doRectanglesOverlap((*itr)->getBounds(), *m_bounds))
{
(*itr)->zap(m_iZapDamage);
}
}
}
if (m_hasEscapedTowerPlatform)
{
for (std::vector<std::unique_ptr<WorldPlatform>>::iterator itr = platforms.begin(); itr != platforms.end(); itr++)
{
if (OverlapTester::doRectanglesOverlap((*itr)->getBounds(), *m_bounds))
{
float deltaY = fabs((*itr)->getPosition().getY() - m_position->getY());
float deltaX = fabs((*itr)->getPosition().getX() - m_position->getX());
if (deltaY > deltaX)
{
m_velocity->set(m_velocity->getX(), -m_velocity->getY());
}
else
{
m_velocity->set(-m_velocity->getX(), m_velocity->getY());
}
m_fAngle = m_velocity->angle();
return;
}
}
}
else
{
for (std::vector<std::unique_ptr<WorldPlatform>>::iterator itr = platforms.begin(); itr != platforms.end(); itr++)
{
if (OverlapTester::doRectanglesOverlap((*itr)->getBounds(), *m_bounds))
{
return;
}
}
m_hasEscapedTowerPlatform = true;
}
}
Vector2D DisplayObject::getMin() {
updateBounds(true);
return _min;
}
QVariant GraphicsUserListItem::itemChange(GraphicsItemChange change, const QVariant& value) {
if(change == ItemSceneHasChanged) {
updateBounds();
}
return QGraphicsItem::itemChange(change, value);
}
Vector2D DisplayObject::getMax() {
updateBounds(true);
return _max;
}
float DisplayObject::getHeight() {
updateBounds();
return absf(_max.y - _min.y);
}
virtual void updateSize( Vector3D scale ) {
m_size_text = scale[0];
updateBounds();
}
