유니티 클라이언트와 c++ 서버 플랫 버퍼로 통신하기 성공~

c++ 서버는 boost/asio 기반으로 만들었다.

#include <iostream>

#include <iterator>

#include <nta/tcp.hpp>

#include "packets.h"

class flatbuffers_filter : public nta::receive_filter // 아직 작성되지 않음

{

public:

virtual result feed(const std::byte* data, std::size_t size) {

return drain(size);

}

};

class session : public nta::tcp::session

{

public:

session(nta::tcp::session_params params) :

nta::tcp::session(std::move(params))

{

}

virtual void on_opened() override

{

std::cout << "opened" << std::endl;

flatbuffers::FlatBufferBuilder builder;

builder.Finish(MyGames::packet::CreateVector2(builder, 10.0f, 10.0f));

auto data = builder.GetBufferPointer();

auto size = builder.GetSize();

std::vector<char> buffer(sizeof(packet::header) + size);

packet::header header{ 0, size };

std::memcpy(buffer.data(), &header, sizeof(header));

this->send(buffer.data(), buffer.size());

}

virtual void on_closed() override

{

}

virtual void on_received(const std::error_code& err, const nta::packet& packet) override

{

if (err)

this->close();

}

virtual void on_sent(const std::error_code &) override

{

}

};

int main(){

nta::tcp::server_builder builder;

builder

.endpoint("localhost:16333")

.max_sessions(1)

.session <session>();

std::shared_ptr<nta::tcp::server> server = builder.build();

server->run();

return 0;

}

유니티 클라이언트는 c#을 이용해서 만들었다.

using System;

using System.Collections.Generic;

using System.Net;

using System.Net.Sockets;

using System.IO;

using UnityEngine;

namespace Assets

{

  public class ReadBuffer

  {

    byte[] buffer;

    public MemoryStream stream;

    public int readPosition = 0;

    public ReadBuffer(int bufferSize = 1024*2)

    {

      buffer = new byte[bufferSize];

      stream = new MemoryStream();

    }

    public byte[] Prepare()

    {

      return buffer;

    }

    public byte[] Prepare(int size)

    {

      if (buffer.Length < size)

      {

        buffer = new byte[size];

      }

      return buffer;

    }

    public void Commit(int size)

    {

      if ((stream.Capacity - stream.Position) < size) // 이거 지우면 해결되는데 뭐냐

      {

        int readableSize = ReadableSize;

        Buffer.BlockCopy(stream.GetBuffer(), readPosition, stream.GetBuffer(), 0, readableSize);

        stream.SetLength(readableSize);

        stream.Position = readableSize;

        readPosition = 0;

      }

      stream.Write(buffer, 0, size);

    }

    public void Consume(int size)

    {

      if ((stream.Length - readPosition) < size)

        throw new ArgumentOutOfRangeException("consume size too big");

      readPosition += size;

    }

    public byte[] Data()

    {

      int readableSize = ReadableSize;

      byte[] ret = new byte[readableSize];

      Array.Copy(stream.GetBuffer(), readPosition, ret, 0, readableSize);

      return ret;

    }

    public int ReadableSize

    {

      get

      {

        return (int)(stream.Length - readPosition);

      }

    }

  }

  public class RemoteServer : IServer

  {

    TcpClient tcpClient;

    IPEndPoint endpoint;

    NetworkStream networkStream;

    Queue<KeyValuePair<int, byte[]>> packetQueue = new Queue<KeyValuePair<int, byte[]>>();

    Action<int, byte[]> packetHandler;

    static int packetHeaderSize = 8;

    class ReadContext

    {

      public ReadBuffer readBuffer = new ReadBuffer();

      public Queue<KeyValuePair<int, byte[]>> packetQueue;

      public List<KeyValuePair<int, byte[]>> enqueueBuffer = new List<KeyValuePair<int, byte[]>>();

    }

    public RemoteServer(IPEndPoint endpoint, Action<int, byte[]> packetHandler)

    {

      tcpClient = new TcpClient();

      this.endpoint = endpoint;

      this.packetHandler = packetHandler;

    }

    public void Start()

    {

      tcpClient.BeginConnect(endpoint.Address, endpoint.Port, (IAsyncResult ar)=> {

        networkStream = tcpClient.GetStream();

        DoReceive(new ReadContext { packetQueue = packetQueue });

      }, this);

    }

    public void Update()

    {

      List<KeyValuePair<int, byte[]>> packets = new List<KeyValuePair<int, byte[]>>();

      lock (packetQueue)

      {

        while(packetQueue.Count != 0)

        {

          packets.Add(packetQueue.Dequeue());

        }

      }

      foreach(var packet in packets)

      {

        packetHandler(packet.Key, packet.Value);

      }

    }

    public void Send(int type, byte[] data)

    {

      byte[] buffer = new byte[data.Length + 8];

      BitConverter.GetBytes(type).CopyTo(buffer, 0);

      BitConverter.GetBytes(data.Length).CopyTo(buffer, 4);

      data.CopyTo(buffer, 8);

      networkStream.BeginWrite(buffer, 0, buffer.Length, (IAsyncResult ar)=> {

      }, this);

    }

    void DoReceive(ReadContext readContext)

    {

      if (!networkStream.CanRead)

      {

        Debug.Log("NetworkStream can't reading");

        return;

      }

      byte[] buffer = readContext.readBuffer.Prepare();

      networkStream.BeginRead(buffer, 0, buffer.Length, (IAsyncResult ar) => {

        int bytesTransferred = networkStream.EndRead(ar);

        ReadContext context = (ReadContext)ar.AsyncState;

        context.readBuffer.Commit(bytesTransferred);

        while (packetHeaderSize <= readContext.readBuffer.ReadableSize)

        {

          byte[] data = readContext.readBuffer.Data();

          int type = BitConverter.ToInt32(data, 0);

          int size = BitConverter.ToInt32(data, sizeof(int));

          if (data.Length < size)

          {

            break;

          }

          byte[] packetBody = new byte[size];

          Array.Copy(data, packetHeaderSize, packetBody, 0, packetBody.Length);

          context.enqueueBuffer.Add(new KeyValuePair<int, byte[]>(type, packetBody));

          readContext.readBuffer.Consume(packetHeaderSize + size);

        }

        lock (packetQueue)

        {

          foreach (var item in context.enqueueBuffer)

          {

            packetQueue.Enqueue(item);

          }

        }

        context.enqueueBuffer.Clear();

        DoReceive(context);

      }, readContext);

    }

  }

}

플랫 버퍼의 총 크기는 알 수 없으므로 패킷 헤더에 타입과 사이즈를 넣었다. 헤더의 사이즈엔 플랫버퍼의 크기가 기록된다.

받은 데이터가 헤더를 제외하고 헤더에 명시된 플랫버퍼 크기 이상을 받았다면 그만큼 잘라서 쓰면 된다.

type은 플랫버퍼를 바이너리를 역직렬화 할 때 어떤 변환을 거칠 것인지 판단을 할 기준이 있어야 하기 때문에 반드시 필요하다.

using System.Collections.Generic;

using UnityEngine;

using Assets;

using System.Net;

using FlatBuffers;

public class GameController : MonoBehaviour {

  RemoteServer server;

  HashSet<GameObject> objects = new HashSet<GameObject>();

  // Use this for initialization

  void Start ()

{

    server = new RemoteServer(new IPEndPoint(IPAddress.Loopback, 16333), (int type, byte[] body)=>

    {

      switch(type)

      {

        case 0:

          {// 타입 0이면 Vector2로 변환하는 처리!

            var vec2 = MyGames.packet.Vector2.GetRootAsVector2(new ByteBuffer(body));

            Debug.Log(string.Format("{0} {1}", vec2.X, vec2.Y));

          }

          break;

      }

      

    });

    server.Start();

  }

  void Update ()

{

    server.Update();

  }

}

접속하면 c++ 서버에서 10, 10을 보내고 유니티 클라이언트에서 10, 10을 받았다. 많이 다듬어야겠지만 물꼬는 틀었다 ~_~