rfbext.h

Go to the documentation of this file.

 
#ifndef PROTOCOL_EXTENSIONS_H
#define PROTOCOL_EXTENSIONS_H
 
#include <cstring> // memset
#include "depthquant.h"
#include "export.h"
 
#include <vistle/core/message.h>
 
namespace vistle {
 
const size_t RhrMessageSize = 840;
 
enum {
    rfbMatrices, 
    rfbLights, 
    rfbTile, 
    rfbBounds, 
    rfbAnimation, 
    rfbVariant, 
};
 
struct V_RHREXPORT rfbMsg {
    rfbMsg(uint8_t type): type(type), modificationCount(0) {}
 
    uint8_t type; 
    uint32_t modificationCount; 
};
 
enum { rfbEyeMiddle, rfbEyeLeft, rfbEyeRight };
 
struct V_RHREXPORT matricesMsg: public rfbMsg {
    matricesMsg()
    : rfbMsg(rfbMatrices), last(0), eye(rfbEyeMiddle), viewNum(-1), width(0), height(0), requestNumber(0), time(0.)
    {
        memset(model, '\0', sizeof(model));
        memset(view, '\0', sizeof(view));
        memset(proj, '\0', sizeof(proj));
        memset(head, '\0', sizeof(head));
    }
 
    uint8_t last; 
    uint8_t eye; 
    int16_t viewNum; 
    uint16_t width, height; 
    uint32_t requestNumber; 
    double time; 
    double model[16]; 
    double view[16]; 
    double proj[16]; 
    double head[16]; 
 
    bool operator==(const matricesMsg &other) const
    {
        if (eye != other.eye)
            return false;
        if (viewNum != other.viewNum)
            return false;
        if (width != other.width)
            return false;
        if (height != other.height)
            return false;
 
        for (int i = 0; i < 16; ++i) {
            if (model[i] != other.model[i])
                return false;
            if (view[i] != other.view[i])
                return false;
            if (proj[i] != other.proj[i])
                return false;
            if (head[i] != other.head[i])
                return false;
        }
 
        return true;
    }
};
static_assert(sizeof(matricesMsg) < RhrMessageSize, "RHR message too large");
 
struct V_RHREXPORT lightsMsg: public rfbMsg {
    lightsMsg(): rfbMsg(rfbLights), viewNum(-1)
    {
        memset(pad, '\0', sizeof(pad));
 
        lights[0].diffuse[0] = lights[0].diffuse[1] = lights[0].diffuse[2] = lights[0].diffuse[3] = 1;
        lights[0].specular[0] = lights[0].specular[1] = lights[0].specular[2] = lights[0].specular[3] = 1;
    }
 
    static const int NumLights = 4;
 
    struct Light {
        // as in OpenGL
        uint8_t enabled; 
 
        uint8_t pad[7]; 
 
        double position[4]; 
 
        double ambient[4]; 
        double diffuse[4]; 
        double specular[4]; 
 
        double spot_direction[3]; 
        double spot_cutoff; 
        double spot_exponent; 
 
        double attenuation[3]; 
 
        Light()
        {
            memset(this, '\0', sizeof(*this));
 
            position[2] = 1;
 
            ambient[3] = 1;
 
            spot_direction[2] = -1;
            spot_cutoff = 180;
 
            attenuation[0] = 1;
        }
 
        bool operator!=(const Light &o) const
        {
            if (enabled != o.enabled)
                return true;
 
            for (int i = 0; i < 4; ++i) {
                if (position[i] != o.position[i])
                    return true;
                if (ambient[i] != o.ambient[i])
                    return true;
                if (diffuse[i] != o.diffuse[i])
                    return true;
                if (specular[i] != o.specular[i])
                    return true;
            }
 
            for (int i = 0; i < 3; ++i) {
                if (spot_direction[i] != o.spot_direction[i])
                    return true;
                if (attenuation[i] != o.attenuation[i])
                    return true;
            }
 
            if (spot_cutoff != o.spot_cutoff)
                return true;
            if (spot_exponent != o.spot_exponent)
                return true;
 
            return false;
        }
    };
 
    int16_t viewNum; 
    uint8_t pad[5]; 
 
    Light lights[NumLights];
 
    bool operator!=(const lightsMsg &o) const
    {
        if (viewNum != o.viewNum)
            return true;
        for (int i = 0; i < NumLights; ++i) {
            if (lights[i] != o.lights[i])
                return true;
        }
        return false;
    }
};
static_assert(sizeof(lightsMsg) < RhrMessageSize, "RHR message too large");
 
struct V_RHREXPORT boundsMsg: public rfbMsg {
    boundsMsg(): rfbMsg(rfbBounds), sendreply(0), radius(-1.)
    {
        memset(pad, '\0', sizeof(pad));
        memset(center, '\0', sizeof(center));
    }
 
    uint8_t sendreply; 
    uint8_t pad[6]; 
    double center[3]; 
    double radius; 
};
static_assert(sizeof(boundsMsg) < RhrMessageSize, "RHR message too large");
 
enum rfbTileFlags {
    rfbTileNone = 0,
    rfbTileFirst = 1,
    rfbTileLast = 2,
    rfbTileRequest = 4,
};
 
enum rfbTileFormats { rfbDepth8Bit, rfbDepth16Bit, rfbDepth24Bit, rfbDepth32Bit, rfbDepthFloat, rfbColorRGBA };
 
enum rfbTileCompressions {
    rfbTileRaw = 0,
    rfbTileDepthPredict = 1,
    rfbTileDepthPredictPlanar = 2,
    rfbTileDepthQuantize = 4,
    rfbTileDepthQuantizePlanar = 8,
    rfbTileDepthZfp = 16,
    rfbTileJpeg = 32,
    rfbTilePredictRGB = 64,
    rfbTilePredictRGBA = 128,
    rfbTileClear = 256,
};
 
struct V_RHREXPORT tileMsg: public rfbMsg {
    tileMsg()
    : rfbMsg(rfbTile)
    , flags(rfbTileNone)
    , format(rfbColorRGBA)
    , compression(rfbTileRaw)
    , eye(rfbEyeMiddle)
    , frameNumber(0)
    , requestNumber(0)
    , size(0)
    , x(0)
    , y(0)
    , viewNum(-1)
    , width(0)
    , height(0)
    , totalwidth(0)
    , totalheight(0)
    , timestep(-1)
    , unzippedsize(0)
    , requestTime(0.)
    {
        memset(model, '\0', sizeof(model));
        memset(view, '\0', sizeof(view));
        memset(proj, '\0', sizeof(proj));
        memset(proj, '\0', sizeof(head));
    }
 
    uint8_t flags; 
    uint8_t format; 
    uint8_t compression; 
    uint8_t eye; 
    uint32_t frameNumber; 
    uint32_t requestNumber; 
    uint32_t size; 
    uint16_t x; 
    uint16_t y; 
    int16_t viewNum; 
    uint16_t width; 
    uint16_t height; 
    uint16_t totalwidth; 
    uint16_t totalheight; 
    int32_t timestep; 
    int32_t unzippedsize; 
    double head[16]; 
    double view[16]; 
    double proj[16]; 
    double model[16]; 
    double requestTime; 
};
static_assert(sizeof(tileMsg) < RhrMessageSize, "RHR message too large");
 
struct V_RHREXPORT animationMsg: public rfbMsg {
    animationMsg(): rfbMsg(rfbAnimation), total(0), current(-1) {}
 
    int32_t total; 
    int32_t current; 
    double time; 
};
static_assert(sizeof(animationMsg) < RhrMessageSize, "RHR message too large");
 
struct V_RHREXPORT variantMsg: public rfbMsg {
    variantMsg(): rfbMsg(rfbVariant), configureVisibility(0), visible(0), remove(0)
    {
        memset(name, '\0', sizeof(name));
    }
 
    uint32_t configureVisibility;
    uint32_t visible;
    uint32_t remove;
    char name[200];
};
static_assert(sizeof(variantMsg) < RhrMessageSize, "RHR message too large");
 
typedef rfbMsg RhrSubMessage;
 
namespace message {
 
class V_RHREXPORT RemoteRenderMessage: public MessageBase<RemoteRenderMessage, REMOTERENDERING> {
public:
    RemoteRenderMessage(const RhrSubMessage &rhr, size_t payloadSize = 0);
    const RhrSubMessage &rhr() const;
    RhrSubMessage &rhr();
 
private:
    std::array<char, RhrMessageSize> m_rhr;
};
 
} // namespace message
 
} // namespace vistle
#endif