source: proiecte/SIMEO/Simeo/src/SimeoGui/GuiUpdater.cpp @ 167

#include "GuiUpdater.h"


GuiUpdater::GuiUpdater(int port, hostent *serv)
{
        portno = port;
        server = serv;
}


GuiUpdater::~GuiUpdater()
{

}


void GuiUpdater::init()
{
        char buffer[256];
        int n;

    sockfd = socket(AF_INET, SOCK_STREAM, 0);

    if (sockfd < 0) {
        printf("Error opening socket\n");
                exit(0);
        }

    if (server == NULL) {
        printf("Error, no such host\n");
        exit(0);
    }

    memset((char *) &serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    memcpy((char *)&serv_addr.sin_addr.s_addr,
           (char *)server->h_addr,
           server->h_length);
    serv_addr.sin_port = htons(portno);

    if (connect(sockfd,(struct sockaddr*) &serv_addr,sizeof(serv_addr)) < 0) {
        printf("Error connecting!\n");
                exit(0);
        }

    // astept mesaj de la server
    memset(buffer, 0, 256);
    n = recv(sockfd, buffer, 255, 0);

    if (n < 0) {
            printf("Error reading from socket!\n");
                exit(0);
        }

    printf("[SRV]%s\n", buffer);

}

void GuiUpdater::receiveData(int sock, void* buffer, size_t size)
{
        size_t total;
        int ret;

        for (total = 0; total < size; total += ret) {
                ret = recv(sock, (char *) buffer + total, size - total, 0);
                if (ret <= 0) {
                        perror("recv");
                        exit(-1);
                }
        }
}

void* GuiUpdater::unpackInt(void *buffer, int &a)
{
        int *buff = (int *) buffer;
        a = *buff ++;

        return buff;
}

void* GuiUpdater::unpackScalar(void *buffer, btScalar &a)
{
        float *buff = (float *) buffer;
        a = *buff ++;

        return buff;
}

void* GuiUpdater::unpackVector3(void *buffer, btVector3 &v)
{
        btScalar a;

        buffer = unpackScalar(buffer, a);
        v.setX(a);
        buffer = unpackScalar(buffer, a);
        v.setY(a);
        buffer = unpackScalar(buffer, a);
        v.setZ(a);

        return buffer;
}

void* GuiUpdater::unpackMatrix3x3(void *buffer, btMatrix3x3 &m)
{
        btVector3 v;

        for (int i = 0; i < 3; ++ i) {
                buffer = unpackVector3(buffer, m[i]);
        }

        return buffer;
}

void GuiUpdater::unpackAddData(void *buffer, int n, map<int,guiAddData *> &addObjects)
{
        for (int i = 0; i < n; ++ i) {
                guiAddData *obj = new guiAddData;
                int j;

                buffer = unpackInt(buffer, obj->id);
                buffer = unpackInt(buffer, obj->numIndices);

                obj->indexPointer = new int [obj->numIndices];
                for (j = 0; j < obj->numIndices; ++ j) {
                        buffer = unpackInt(buffer, obj->indexPointer[j]);
                }

                buffer = unpackInt(buffer, obj->numVertices);
                obj->vertexPointer = new btVector3 [obj->numVertices];
                for (j = 0; j < obj->numVertices; ++ j) {
                                buffer = unpackVector3(buffer, obj->vertexPointer[j]);
                }

                addObjects[obj->id] = obj;
        }
}

void GuiUpdater::unpackUpdateData(void *buffer, int n, map<int, guiUpdateData *> &updateObjects)
{
        for (int i = 0; i < n; ++ i) {
                guiUpdateData *obj = new guiUpdateData;
                int j;

                buffer = unpackInt(buffer, obj->id);

                for (j = 0; j < 16; ++ j) {
                        buffer = unpackScalar(buffer, obj->m[j]);
                }

                buffer = unpackMatrix3x3(buffer, obj->rot);

                buffer = unpackVector3(buffer, obj->aabbMin);

                buffer = unpackVector3(buffer, obj->aabbMax);

                updateObjects[obj->id] = obj;
        }
}

void GuiUpdater::applyChanges(map<int, guiAddData *> addObjects, map<int, guiUpdateData *> updateObjects, int *removeObjects, int remObjNum)
{
//      getchar();
        map<int, guiAddData *>::iterator it_add = addObjects.begin();
        for ( ; it_add != addObjects.end(); it_add ++) {
//              printf("[%d]\n", addObjects.coun);
                if (m_cache.find(it_add->first) != m_cache.end()) {
                        printf("Adding existing object\n");
                        exit(-1);
                }

                guiObject *obj = new guiObject;
                obj->ad = it_add->second;
                if (m_cache[it_add->second->id]) delete m_cache[it_add->second->id];
                m_cache[it_add->second->id] = obj;
        }

        map<int, guiUpdateData *>::iterator it_update = updateObjects.begin();
        for ( ; it_update != updateObjects.end(); it_update ++) {
                if (m_cache.find(it_update->first) != m_cache.end()) {
                        guiObject *obj = m_cache.find(it_update->first)->second;
                        obj->ud = it_update->second;
                } else {
                        printf("Updating missing object\n");
//                      exit(-1);
                }
        }

        map<int, guiObject *>::iterator it;
        for (int i = 0; i < remObjNum; ++ i) {
                it = m_cache.find(removeObjects[i]);
                if (it != m_cache.end()) {
                        delete it->second;
                        m_cache.erase(it);
                }
        }
}

int GuiUpdater::update()
{
        map<int, guiAddData *> addObjects;
        map<int, guiUpdateData *> updateObjects;
        int *removeObjects;

//      char buffer[256];
        char ask = 'a';
        int n;

        n = send(sockfd,(const void*) &ask,1, 0);
        if (n < 0) {
                        printf("Error writing to socket!\n");
                exit(0);
        }


        int size;

        // receive add objects
        receiveData(sockfd, (void *) &n, sizeof(int));
        receiveData(sockfd, (void *) &size, sizeof(int));


        void *buffer = new char [size];
        receiveData(sockfd, (void *) buffer, size);
        unpackAddData(buffer, n, addObjects);
        delete [] (char *) buffer;
        printf("added object no = %d (%d)\n", (int) addObjects.size(), n);

        // receive update objects
        receiveData(sockfd, (void *) &n, sizeof(int));
        receiveData(sockfd, (void *) &size, sizeof(int));
        buffer = new char [size];
        receiveData(sockfd, (void *) buffer, size);
        unpackUpdateData(buffer, n, updateObjects);
        delete [] (char *) buffer;

        printf("updated object no = %d (%d)\n", (int) updateObjects.size(), n);
        map<int, guiUpdateData *>::iterator it = updateObjects.begin();
        for ( ; it != updateObjects.end(); it ++) {
                for (int j = 0; j < 16; ++ j) {
                //      buffer = unpackScalar(buffer, obj->m[j]);
                        printf("TEST %d, %d: %f\n", j, it->first, it->second->m[j]);
                }
        }

        // receive remove objects
        receiveData(sockfd, (void *) &n, sizeof(int));
        removeObjects = new int[n];     // the number of objects (object ids in this case)
        receiveData(sockfd, (void *) &size, sizeof(int));
        buffer = new char [size];
        receiveData(sockfd, (void *) buffer, size);

        for (int i = 0; i < n; ++ i) {
                buffer = unpackInt(buffer, removeObjects[i]);
        }

        delete [] (int *) buffer;

        applyChanges(addObjects, updateObjects, removeObjects, n);

//      gd = new guiUpdateData[n];
//      receiveData(sockfd, (void *) gd, sizeof(guiUpdateData) * n);

        return n;
}