int QPanGesture::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QGesture::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
#ifndef QT_NO_PROPERTIES
if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast< QPointF*>(_v) = lastOffset(); break;
case 1: *reinterpret_cast< QPointF*>(_v) = offset(); break;
case 2: *reinterpret_cast< QPointF*>(_v) = delta(); break;
case 3: *reinterpret_cast< qreal*>(_v) = acceleration(); break;
case 4: *reinterpret_cast< qreal*>(_v) = QPanGesture::d_func()->horizontalVelocity(); break;
case 5: *reinterpret_cast< qreal*>(_v) = QPanGesture::d_func()->verticalVelocity(); break;
}
_id -= 6;
} else if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0: setLastOffset(*reinterpret_cast< QPointF*>(_v)); break;
case 1: setOffset(*reinterpret_cast< QPointF*>(_v)); break;
case 3: setAcceleration(*reinterpret_cast< qreal*>(_v)); break;
case 4: QPanGesture::d_func()->setHorizontalVelocity(*reinterpret_cast< qreal*>(_v)); break;
case 5: QPanGesture::d_func()->setVerticalVelocity(*reinterpret_cast< qreal*>(_v)); break;
}
_id -= 6;
} else if (_c == QMetaObject::ResetProperty) {
_id -= 6;
} else if (_c == QMetaObject::QueryPropertyDesignable) {
_id -= 6;
} else if (_c == QMetaObject::QueryPropertyScriptable) {
_id -= 6;
} else if (_c == QMetaObject::QueryPropertyStored) {
_id -= 6;
} else if (_c == QMetaObject::QueryPropertyEditable) {
_id -= 6;
} else if (_c == QMetaObject::QueryPropertyUser) {
_id -= 6;
}
#endif // QT_NO_PROPERTIES
return _id;
}
/**
* Calculates the block/function hits and the time spent in each block/function using the data
* from the event list.
**/
void analyzeEventList(const std::list<Event>& list, std::map<Offset, TimedBlock*> timedBlocks, std::map<Offset, TimedBlock*> timedFunctions)
{
msg("Analyzing the profiler event list...\n");
_timeb lastTime;
Offset lastOffset(0);
// We calculate the time spent in each basic block
for (std::list<Event>::const_iterator Iter = list.begin(); Iter != list.end(); ++Iter)
{
_timeb currentTime = Iter->getTime();
Offset currentOffset = Iter->getAddress();
// Increase the hit counter at the basic block defined by the breakpoint.
timedBlocks[currentOffset]->hit();
// If the start of a function is hit, the hit counter of the function increases.
if (currentOffset.isFunctionStart())
{
if (timedFunctions.find(currentOffset) == timedFunctions.end())
{
msg("Internal Error: Invalid function I (%08X)\n", currentOffset.getAddress());
}
timedFunctions[currentOffset]->hit();
}
// Skip the time calculation of the first event because we don't know how much time was spent
// on this block.
if (Iter == list.begin())
{
lastTime = currentTime;
lastOffset = currentOffset;
continue;
}
unsigned int difference = (currentTime.time - lastTime.time) * 1000 + currentTime.millitm - lastTime.millitm;
if (timedBlocks.find(lastOffset) == timedBlocks.end())
{
msg("Internal Error: Invalid block\n");
}
// The time spent between the last breakpoint and the current breakpoint
// is added to the block that was hit previously.
timedBlocks[lastOffset]->addTime(difference);
// The time spent in a function is increased whenever a breakpoint inside a function is followed
// by another breakpoint hit (either inside or outside the function).
Function lastFunction = timedBlocks[lastOffset]->getParentFunction();
Offset lastFunctionOffset = lastFunction.getAddress();
if (timedFunctions.find(lastFunctionOffset) == timedFunctions.end())
{
msg("Internal Error: Invalid function II\n");
}
timedFunctions[lastFunctionOffset]->addTime(difference);
lastTime = currentTime;
lastOffset = currentOffset;
}
}
/**
* zeichnet den Kartenausschnitt.
*
* @author OLiver
* @author FloSoft
*/
void TerrainRenderer::Draw(const GameWorldView& gwv, unsigned int* water)
{
assert(!gl_vertices.empty());
assert(!borders.empty());
/* if ((gwv.GetXOffset() == gwv.terrain_last_xoffset) && (gwv.GetYOffset() == gwv.terrain_last_yoffset) && (gwv.terrain_list != 0) && (GAMECLIENT.GetGlobalAnimation(4, 5, 4, 0) == gwv.terrain_last_global_animation))
{
glCallList(gwv.terrain_list);
*water = gwv.terrain_last_water;
return;
}
gwv.terrain_last_xoffset = gwv.GetXOffset();
gwv.terrain_last_yoffset = gwv.GetYOffset();
gwv.terrain_last_global_animation = GAMECLIENT.GetGlobalAnimation(4, 5, 4, 0);
if (gwv.terrain_list == 0)
gwv.terrain_list = glGenLists(1);
glNewList(gwv.terrain_list, GL_COMPILE_AND_EXECUTE);*/
// nach Texture in Listen sortieren
boost::array< std::vector<MapTile>, TT_COUNT> sorted_textures;
boost::array< std::vector<BorderTile>, 5> sorted_borders;
PreparedRoads sorted_roads;
Point<int> lastOffset(0, 0);
// Beim zeichnen immer nur beginnen, wo man auch was sieht
for(int y = gwv.GetFirstPt().y; y < gwv.GetLastPt().y; ++y)
{
unsigned char lastTerrain = 255;
unsigned char lastBorder = 255;
for(int x = gwv.GetFirstPt().x; x < gwv.GetLastPt().x; ++x)
{
Point<int> posOffset;
MapPoint tP = ConvertCoords(Point<int>(x, y), &posOffset);
TerrainType t = gwv.GetGameWorldViewer().GetNode(tP).t1;
if(posOffset != lastOffset)
lastTerrain = 255;
if(t == lastTerrain && tP != MapPoint(0, 0))
++sorted_textures[t].back().count;
else
{
MapTile tmp(GetTriangleIdx(tP), posOffset);
sorted_textures[t].push_back(tmp);
lastTerrain = t;
}
t = gwv.GetGameWorldViewer().GetNode(tP).t2;
if(t == lastTerrain)
++sorted_textures[t].back().count;
else
{
MapTile tmp(GetTriangleIdx(tP) + 1, posOffset);
sorted_textures[t].push_back(tmp);
}
lastTerrain = t;
const Borders& curBorders = borders[GetVertexIdx(tP)];
boost::array<unsigned char, 6> tiles =
{{
curBorders.left_right[0],
curBorders.left_right[1],
curBorders.right_left[0],
curBorders.right_left[1],
curBorders.top_down[0],
curBorders.top_down[1]
}};
// Offsets into gl_* arrays
boost::array<unsigned, 6> offsets =
{{
curBorders.left_right_offset[0],
curBorders.left_right_offset[1],
curBorders.right_left_offset[0],
curBorders.right_left_offset[1],
curBorders.top_down_offset[0],
curBorders.top_down_offset[1]
}};
for(unsigned char i = 0; i < 6; ++i)
{
if(!tiles[i])
continue;
if(tiles[i] == lastBorder)
{
BorderTile& curTile = sorted_borders[lastBorder - 1].back();
// Check that we did not wrap around the map and the expected offset matches
if(curTile.tileOffset + curTile.count == offsets[i])
{
++curTile.count;
continue;
}
}
lastBorder = tiles[i];
BorderTile tmp(offsets[i], posOffset);
sorted_borders[lastBorder - 1].push_back(tmp);
}
PrepareWaysPoint(sorted_roads, gwv, tP, posOffset);
lastOffset = posOffset;
}
}
if (water)
{
unsigned water_count = 0;
for(unsigned char t = 0; t < TT_COUNT; ++t){
if(!TerrainData::IsWater(TerrainType(t)))
continue;
for(std::vector<MapTile>::iterator it = sorted_textures[t].begin(); it != sorted_textures[t].end(); ++it)
{
water_count += it->count;
}
}
PointI diff = gwv.GetLastPt() - gwv.GetFirstPt();
if( diff.x && diff.y )
*water = 50 * water_count / ( diff.x * diff.y );
else
*water = 0;
}
lastOffset = PointI(0, 0);
if(vboBuffersUsed)
{
glBindBufferARB(GL_ARRAY_BUFFER_ARB, vbo_vertices);
glVertexPointer(2, GL_FLOAT, 0, NULL);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, vbo_texcoords);
glTexCoordPointer(2, GL_FLOAT, 0, NULL);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, vbo_colors);
glColorPointer(3, GL_FLOAT, 0, NULL);
}
else
{
glVertexPointer(2, GL_FLOAT, 0, &gl_vertices.front());
glTexCoordPointer(2, GL_FLOAT, 0, &gl_texcoords.front());
glColorPointer(3, GL_FLOAT, 0, &gl_colors.front());
}
// Arrays aktivieren
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
// Modulate2x
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);
glTexEnvf(GL_TEXTURE_ENV, GL_RGB_SCALE_EXT, 2.0f);
// Verschieben gem#ß x und y offset
glTranslatef( float(-gwv.GetXOffset()), float(-gwv.GetYOffset()), 0.0f);
// Alphablending aus
glDisable(GL_BLEND);
for(unsigned char t = 0; t < TT_COUNT; ++t)
{
if(sorted_textures[t].empty())
continue;
unsigned animationFrame;
TerrainType tt = TerrainType(t);
if(TerrainData::IsLava(tt))
animationFrame = GAMECLIENT.GetGlobalAnimation(TerrainData::GetFrameCount(tt), 5, 4, 0);
else if(TerrainData::IsWater(tt))
animationFrame = GAMECLIENT.GetGlobalAnimation(TerrainData::GetFrameCount(tt), 5, 2, 0);
else
animationFrame = 0;
VIDEODRIVER.BindTexture(LOADER.GetTerrainTexture(tt, animationFrame).GetTexture());
for(std::vector<MapTile>::iterator it = sorted_textures[t].begin(); it != sorted_textures[t].end(); ++it)
{
if(it->posOffset != lastOffset)
{
PointI trans = it->posOffset - lastOffset;
glTranslatef( float(trans.x), float(trans.y), 0.0f);
lastOffset = it->posOffset;
}
assert(it->tileOffset + it->count <= width * height * 2u);
glDrawArrays(GL_TRIANGLES, it->tileOffset * 3, it->count * 3); // Arguments are in Elements. 1 triangle has 3 values
}
}
glEnable(GL_BLEND);
glLoadIdentity();
glTranslatef( float(-gwv.GetXOffset()), float(-gwv.GetYOffset()), 0.0f);
lastOffset = PointI(0, 0);
for(unsigned short i = 0; i < 5; ++i)
{
if(sorted_borders[i].empty())
continue;
VIDEODRIVER.BindTexture(GetImage(borders, i)->GetTexture());
for(std::vector<BorderTile>::iterator it = sorted_borders[i].begin(); it != sorted_borders[i].end(); ++it)
{
if(it->posOffset != lastOffset)
{
PointI trans = it->posOffset - lastOffset;
glTranslatef( float(trans.x), float(trans.y), 0.0f);
lastOffset = it->posOffset;
}
assert(it->tileOffset + it->count <= gl_vertices.size());
glDrawArrays(GL_TRIANGLES, it->tileOffset * 3, it->count * 3); // Arguments are in Elements. 1 triangle has 3 values
}
}
glLoadIdentity();
DrawWays(sorted_roads);
// Wieder zurück ins normale modulate
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
}