void EditorObject::save(QString filename)
{
QFile file(filename);
file.open(QIODevice::WriteOnly | QIODevice::Text);
if( ! file.isOpen() ){
qDebug() << "Unable to open " << filename << " for writing";
return;
}
QTextStream out(&file);
out << "version=1\n";
out << "name=" << m_name << "\n";
out << "size=" << tileCountX() << "," << tileCountY() << "," << layerCount() << "\n";
out << "description=" << m_description << "\n";
out << "\n# flatten a 3d grid in z,y,x order\n";
QString surfaceTypes = "";
QString shapes = "";
for(int z=0; z<layerCount(); ++z) {
for(int y=0; y<tileCountY(); ++y) {
for(int x=0; x<tileCountX(); ++x) {
surfaceTypes += QString::number(m_surfaceTypes->get(x,y,z)) + QString(",");
shapes += QString::number(m_shapes->get(x,y,z)) + QString(",");
}
surfaceTypes += " \\\n";
shapes += " \\\n";
}
surfaceTypes += "\\\n";
shapes += "\\\n";
}
out << "surfaceTypes=" << surfaceTypes << "\n";
out << "shapes=" << shapes << "\n";
out << "\n# list of graphics and their locations\n";
out << "# graphic=x,y,width,height,layer,graphicFile\n";
for(int z=0; z<layerCount(); ++z) {
QList<ObjectGraphic *> * list = m_graphics.at(z);
for(int i=0; i<list->size(); ++i) {
ObjectGraphic * graphic = list->at(i);
out << "graphic=" << graphic->x << "," << graphic->y << ","
<< graphic->width << "," << graphic->height << "," << z
<< "," << graphic->graphicName << "\n";
}
}
out << "\n# layer names\n";
for(int z=0; z<layerCount(); ++z) {
out << "layerName=" << m_layerNames.at(z) << "\n";
}
}
void EditorMap::addLayer(QString name)
{
MapLayer * layer = new MapLayer;
layer->name = name.isEmpty() ?
QObject::tr("Layer %1").arg(QString::number(layerCount()+1)) : name;
m_layers.append(layer);
}
void EditorMap::save()
{
QString filename = QDir(EditorResourceManager::mapsDir()).absoluteFilePath(m_name);
QFile file(filename);
file.open(QIODevice::WriteOnly | QIODevice::Text);
if( ! file.isOpen() ){
qDebug() << "Unable to open " << filename << " for writing";
return;
}
QTextStream out(&file);
out << "version=" << c_codeVersion << "\n";
out << "# size=sizeX,sizeY,layerCount\n";
out << "# sizes in number of tiles, not in actual coordinates.\n";
out << "size=" << tileCountX() << "," << tileCountY() << "," << layerCount() << "\n\n";
out << "# layer declarations. one declaration per layer\n";
out << "# layer=layerName\n";
for (int i=0; i<layerCount(); ++i)
out << "layer=" << layerName(i) << "\n";
out << "\n";
out << "# object declarations. uses tile coordinates\n";
out << "# object=tileX,tileY,layerIndex,objectId\n";
for (int layerIndex=0; layerIndex<m_layers.size(); ++layerIndex) {
QList<MapObject *> objects = m_layers.at(layerIndex)->objects;
for (int i=0; i<objects.size(); ++i) {
MapObject * object = objects.at(i);
if (object->layer == layerIndex)
out << "object=" << object->tileX << "," << object->tileY << "," << layerIndex << "," << object->object->resourceName() << "\n";
}
}
out << "\n";
out << "# entity declarations. use absolute coordinates\n";
out << "# entity=x,y,layerIndex,entityId\n";
for (int layerIndex=0; layerIndex<m_layers.size(); ++layerIndex) {
QList<EditorEntity *> entities = m_layers.at(layerIndex)->entities;
for (int i=0; i<entities.size(); ++i) {
EditorEntity * entity = entities.at(i);
out << "entity=" << entity->centerX() << "," << entity->centerY() << "," << entity->layer() << "," << entity->name() << "\n";
}
}
}
inline void Net::compute (Iterator begin, Iterator end, OutIterator itOut)
{
const int inputLayer = 0;
node_iterator itNode = beginNodes (inputLayer);
node_iterator itNodeEnd = endNodes (inputLayer);
for (Iterator it = begin; it != end && itNode != itNodeEnd; ++it, ++itNode)
{
(*itNode)->value = (*it);
}
compute_E ();
itNode = beginNodes (layerCount () -1);
itNodeEnd = endNodes (layerCount () -1);
for (Iterator it = begin; it != end && itNode != itNodeEnd; ++it, ++itNode)
{
(*itOut) = (*it);
}
}
void EditorMap::addEntity(EditorEntity * entity)
{
if (entity->parent() != NULL)
entity->parent()->removeEntity(entity);
entity->setParent(this);
while (entity->layer() >= layerCount())
addLayer();
m_layers.at(entity->layer())->entities.append(entity);
}
void EditorMap::addObject(MapObject * object)
{
if (object->parent != NULL)
object->parent->removeObject(object);
object->parent = this;
for (int i=0; i<object->object->layerCount(); ++i) {
int layerIndex = object->layer + i;
while (layerIndex >= layerCount())
addLayer();
m_layers.at(layerIndex)->objects.append(object);
}
}
void QgsMapCanvas::refreshAllLayers()
{
// reload all layers in canvas
for ( int i = 0; i < layerCount(); i++ )
{
QgsMapLayer *l = layer( i );
if ( l )
l->reload();
}
// clear the cache
clearCache();
// and then refresh
refresh();
}
bool EditorObject::build(ResourceFile & resources)
{
// create the container to hold the graphic ids
delete m_compiledGraphics;
m_compiledGraphics = new Array3<QString>(tileCountX(), tileCountY(), layerCount());
Array3< QList<QImage> * > animations(tileCountX(), tileCountY(), layerCount());
// initialize animation list
for (int z=0; z<layerCount(); z++) {
for (int y=0; y<tileCountY(); ++y) {
for (int x=0; x<tileCountX(); ++x) {
animations.set(x,y,z,new QList<QImage>());
}
}
}
// find out the greatest frames per second
int fps = 0;
for (int layerIndex=0; layerIndex<m_graphics.size(); ++layerIndex) {
QList<ObjectGraphic *> * layer = m_graphics.at(layerIndex);
for (int i=0; i<layer->size(); ++i) {
ObjectGraphic * graphicInstance = layer->at(i);
if (graphicInstance->graphic->framesPerSecond() > fps)
fps = graphicInstance->graphic->framesPerSecond();
}
}
// for each animation frame
int frame = 0;
while (true) {
if (frame > 0) {
// check if the animation has looped yet.
bool firstFrame = true;
for (int layerIndex=0; layerIndex<m_graphics.size(); ++layerIndex) {
QList<ObjectGraphic *> * layer = m_graphics.at(layerIndex);
for (int i=0; i<layer->size(); ++i) {
ObjectGraphic * graphicInstance = layer->at(i);
if ((frame+1) % graphicInstance->graphic->frameCount() != 0) {
firstFrame = false;
break;
}
}
if (! firstFrame)
break;
}
// this means all animations have looped and we're done
// collecting frames
if (firstFrame)
break;
}
for (int z=0; z<layerCount(); ++z) {
// render the layer once into a QImage
QImage layerImage(tileCountX() * Tile::sizeInt, tileCountY() * Tile::sizeInt, QImage::Format_ARGB32);
layerImage.fill(Qt::transparent);
QPainter layerPainter(&layerImage);
render(layerPainter, z, frame, fps);
// for each tile, draw that tile into a different QImage
for (int y=0; y<tileCountY(); ++y) {
for (int x=0; x<tileCountX(); ++x) {
QImage tileImage(Tile::sizeInt, Tile::sizeInt, QImage::Format_ARGB32);
tileImage.fill(Qt::transparent);
QPainter p(&tileImage);
p.drawImage(0, 0, layerImage, x * Tile::sizeInt, y * Tile::sizeInt, Tile::sizeInt, Tile::sizeInt);
QList<QImage> * frames = animations.get(x,y,z);
frames->append(tileImage);
}
}
}
++frame;
}
int frameCount = frame;
// create a spritesheet for each tile
for (int z=0; z<layerCount(); ++z) {
for (int y=0; y<tileCountY(); ++y) {
for (int x=0; x<tileCountX(); ++x ) {
// create the spritesheet
QList<QImage> * frames = animations.get(x,y,z);
QImage spritesheet(Tile::sizeInt * frameCount, Tile::sizeInt, QImage::Format_ARGB32);
spritesheet.fill(Qt::transparent);
QPainter p(&spritesheet);
for (int i=0; i<frameCount; ++i)
p.drawImage(i * Tile::sizeInt, 0, frames->at(i % frames->size()));
// create the binary data
QByteArray tile;
// magic character
tile.append("G");
int codeVersion = 1;
tile.append((char *) &codeVersion, 4);
int graphicType = Graphic::gtAnimation;
tile.append((char *) &graphicType, 4);
int storageType = Graphic::stPNG;
tile.append((char *) &storageType, 4);
// color key: hardcode magenta
char red = 255;
char green = 0;
char blue = 255;
tile.append(&red, 1);
tile.append(&green, 1);
tile.append(&blue, 1);
tile.append((char *) &frameCount, 4);
tile.append((char *) &fps, 4);
// frame width and height
tile.append((char *) &Tile::sizeInt, 4);
tile.append((char *) &Tile::sizeInt, 4);
// save spritesheet into memory
QByteArray imageData;
QBuffer buffer(&imageData);
buffer.open(QIODevice::WriteOnly);
spritesheet.save(&buffer, "PNG");
int imageDataSize = imageData.size();
tile.append((char *) &imageDataSize, 4);
tile.append(imageData);
// come up with a name
QString dash = "-";
QString ext = ".ani";
QString graphicName = m_name + dash + QString::number(x) +
dash + QString::number(y) + dash + QString::number(z) + ext;
resources.updateResource(graphicName.toStdString(), tile.constData(), tile.size());
m_compiledGraphics->set(x,y,z,graphicName);
}
}
}
// cleanup animation list
for (int z=0; z<layerCount(); z++) {
for (int y=0; y<tileCountY(); ++y) {
for (int x=0; x<tileCountX(); ++x) {
delete animations.get(x,y,z);
}
}
}
return true;
}
void EditorObject::addLayer(QString name)
{
QString newLayerName = name.isEmpty() ? QObject::tr("Layer %1").arg(QString::number(layerCount()+1))
: name;
m_graphics.insert(m_shapes->sizeZ(), new QList<ObjectGraphic *>());
m_shapes->redim(m_shapes->sizeX(), m_shapes->sizeY(), m_shapes->sizeZ()+1, (Tile::Shape) 0);
m_surfaceTypes->redim(m_shapes->sizeX(), m_shapes->sizeY(), m_shapes->sizeZ(), (Tile::SurfaceType) 0);
m_layerNames << newLayerName;
}
bool Sky::hasLayer(int index) const
{
return index >= 0 && index < layerCount();
}
void QgsMapCanvas::setLayerSet( QList<QgsMapCanvasLayer> &layers )
{
// create layer set
QStringList layerSet, layerSetOverview;
int i;
for ( i = 0; i < layers.size(); i++ )
{
QgsMapCanvasLayer &lyr = layers[i];
if ( !lyr.layer() )
{
continue;
}
if ( lyr.isVisible() )
{
layerSet.push_back( lyr.layer()->id() );
}
if ( lyr.isInOverview() )
{
layerSetOverview.push_back( lyr.layer()->id() );
}
}
const QStringList& layerSetOld = mapSettings().layers();
bool layerSetChanged = layerSetOld != layerSet;
// update only if needed
if ( layerSetChanged )
{
QgsDebugMsg( "Layers changed to: " + layerSet.join( ", " ) );
for ( i = 0; i < layerCount(); i++ )
{
// Add check if vector layer when disconnecting from selectionChanged slot
// Ticket #811 - racicot
QgsMapLayer *currentLayer = layer( i );
if ( !currentLayer )
continue;
disconnect( currentLayer, SIGNAL( repaintRequested() ), this, SLOT( refresh() ) );
disconnect( currentLayer, SIGNAL( layerCrsChanged() ), this, SLOT( layerCrsChange() ) );
QgsVectorLayer *isVectLyr = qobject_cast<QgsVectorLayer *>( currentLayer );
if ( isVectLyr )
{
disconnect( currentLayer, SIGNAL( selectionChanged() ), this, SLOT( selectionChangedSlot() ) );
}
}
mSettings.setLayers( layerSet );
for ( i = 0; i < layerCount(); i++ )
{
// Add check if vector layer when connecting to selectionChanged slot
// Ticket #811 - racicot
QgsMapLayer *currentLayer = layer( i );
connect( currentLayer, SIGNAL( repaintRequested() ), this, SLOT( refresh() ) );
connect( currentLayer, SIGNAL( layerCrsChanged() ), this, SLOT( layerCrsChange() ) );
QgsVectorLayer *isVectLyr = qobject_cast<QgsVectorLayer *>( currentLayer );
if ( isVectLyr )
{
connect( currentLayer, SIGNAL( selectionChanged() ), this, SLOT( selectionChangedSlot() ) );
}
}
updateDatumTransformEntries();
QgsDebugMsg( "Layers have changed, refreshing" );
emit layersChanged();
refresh();
}
if ( mMapOverview )
{
const QStringList& layerSetOvOld = mMapOverview->layerSet();
if ( layerSetOvOld != layerSetOverview )
{
mMapOverview->setLayerSet( layerSetOverview );
}
// refresh overview maplayers even if layer set is the same
// because full extent might have changed
updateOverview();
}
} // setLayerSet
