DynamicExchangeSocket.h

#if !defined(DYNAMICEXCHANGESOCKET_H)
#define DYNAMICEXCHANGESOCKET_H
 
#ifdef _MSC_VER
#pragma once
#endif // _MSC_VER
 
#include "XSocket.h"
#include "DynamicExchangeCommon.h"
 
BEGIN_MOOTOOLS_NAMESPACE
 
// define MOOTOOLS_NO_DYNSERVER_CLASS if you don't need a complete support from a client application
class DLL_3DFUNCTION CDynExchangeSocket : public CXSocket
{
public:
    CDynExchangeSocket();
    virtual ~CDynExchangeSocket();
 
    bool SendMessageData(unsigned int message, const unsigned char *data = NULL, fileuint dataSize = 0, const CCustomData *additionalData = NULL); // Send any kind of data. data and/or additionalData can be NULL.
    
    // send information
    // additionalCustomData can be used to define a specific value between the caller and the client.
    // For example you can pass a DYNAMICDATA_3DSOFTWARE that will allow to filter only data from a specific software.
#ifndef MOOTOOLS_NO_DYN3D
    bool SendScene(C3DScene *scene, bool deleteIt, const CCustomData *additionalCustomData = NULL); // Send a scene to an external application. If the scene is temporary, using deleteIt = true, is a good idea, so it is deleted before sending it to the external application (this limit memory consumption)
    bool SendNode(C3DSceneNode *node, bool skipGeom = false, const CCustomData *additionalCustomData = NULL); // If skipGeom is true, then only the node (without the geometry) is sent.
    bool SendNodes(C3DScene *scene, const C3DNodeArray& nodes, const CBitArray *skipGeoms = NULL, const CCustomData *additionalCustomData = NULL);
#endif
 
#if !defined(MOOTOOLS_NO_DYNBITMAP) && !defined(MOOTOOLS_NO_BITMAP)
    bool SendBitmap(Bitmap *bitmap, bool deleteIt, const CCustomData *additionalCustomData = NULL);
#endif
 
    // Receive information
#ifndef MOOTOOLS_NO_DYNBITMAP
    virtual void ReceiveBitmap(const CXString& filename, CBitmap *bitmap, bool asAlpha) {};
#endif
 
#ifndef MOOTOOLS_NO_DYN3D
    virtual bool ReceiveScene(C3DScene *scene, const CCustomData *additionalData = NULL) const { return false; } // Receive a scene from software. The receiver is owner of the scene if it return true and then should delete it if needed. If the receiver return false, it can't handle the scene and the caller will delete it
    virtual bool ReceiveNode(C3DSceneNode *node, const CCustomData *additionalData = NULL) const { return false; } // Receive a node. The receiver is owner of the node if it return true and then should delete it if needed. If the receiver return false, it can't handle the node and the caller will delete it
    virtual bool ReceiveNodes(C3DNodeArray& nodes, const CCustomData *additionalData = NULL) const { return false; } // Receive several nodes.  // Receive a node. The receiver is owner of the nodes if it return true and then should delete it if needed. If the receiver return false, it can't handle the nodes and the caller will delete it
#endif
 
    virtual bool ReceiveMessageData(const CXSocket& clientSocket, unsigned int message, const unsigned char *data, fileuint dataSize, const CCustomData *additionalData = NULL) { return false; } // Received private data. The receiver must copy the data the owner of the data, it return true. It then should delete the data using xDeallocateArray. If the method return false, then the data is automatically freed
 
protected:
    virtual bool ReceiveData(CXSocket& clientSocket, unsigned int messageID, const void *memory, fileuint dataSize, const CDataBlockArray& blocks); // Called by an external thread when server receive a message and some data with SOCKET_FLAGS_POINT_TO_POINT set. Return true to confirm that you handle it. In such case, you are responsible to free the memory (with Free method). clientSocket can be used to send a confirmation to the client. It is temporary and should not be stored.
 
#ifndef MOOTOOLS_NO_DYN3D
    bool SendScene(unsigned int messageID, C3DScene *scene, bool deleteIt, const CCustomData *additionalCustomData = NULL);
    C3DScene *ReceiveScene(const CDataBlockArray& blocks, CCustomData& data);
#endif
};
class DLL_3DFUNCTION CDynExchangeSocket : public CXSocket {…};
 
class DLL_3DFUNCTION CDynServerSocket : public CDynExchangeSocket
{
public:
    CDynServerSocket();
    virtual ~CDynServerSocket();
 
protected:
    virtual bool ReceiveData(CXSocket& clientSocket, unsigned int messageID, const void *memory, fileuint dataSize, const CDataBlockArray& blocks); // Called by an external thread when server receive a message and some data with SOCKET_FLAGS_POINT_TO_POINT set. Return true to confirm that you handle it. In such case, you are responsible to free the memory (with Free method). clientSocket can be used to send a confirmation to the client. It is temporary and should not be stored.
};
class DLL_3DFUNCTION CDynServerSocket : public CDynExchangeSocket {…};
 
class DLL_3DFUNCTION CDynClientSocket : public CDynExchangeSocket
{
public:
    CDynClientSocket();
    virtual ~CDynClientSocket();
 
    #ifndef MOOTOOLS_NO_DYN3D
    #ifdef MOOTOOLS_PRODUCT_BUILD
    protected:
    unsigned int lock;
 
    public:
    virtual void BeginSceneScan() {};
    virtual void EndSceneScan() {};
    virtual void ReceiveScene(const CXString& filename, C3DScene *scene, bool updateMode, bool silentMode) {};
    virtual C3DScene *ReadScene(const CXString& filename, bool updateMode, bool silentMode) { return NULL; };
    #endif
    #endif
 
protected:
    virtual bool ReceiveData(CXSocket& clientSocket, unsigned int messageID, const void *memory, fileuint dataSize, const CDataBlockArray& blocks); // Called by an external thread when server receive a message and some data with SOCKET_FLAGS_POINT_TO_POINT set. Return true to confirm that you handle it. In such case, you are responsible to free the memory (with Free method). clientSocket can be used to send a confirmation to the client. It is temporary and should not be stored.
};
class DLL_3DFUNCTION CDynClientSocket : public CDynExchangeSocket {…};
 
END_MOOTOOLS_NAMESPACE
 
#endif // !defined(DYNAMICEXCHANGESOCKET_H)