graphics/packets_queue.cpp


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

#include "packets_queue.hpp"
#include "../base/logging.hpp"

namespace graphics
{
  bool Command::isDebugging() const
  {
    return m_isDebugging;
  }

  void Command::setIsDebugging(bool flag)
  {
    m_isDebugging = flag;
  }

  void Command::setRenderContext(RenderContext * ctx)
  {
    m_ctx = ctx;
  }

  RenderContext * Command::renderContext()
  {
    return m_ctx;
  }

  const RenderContext *Command::renderContext() const
  {
    return m_ctx;
  }

  Command::Command()
    : m_isDebugging(false)
  {}

  Command::~Command()
  {}

  void Command::cancel()
  {}

  void Command::perform()
  {}

  void Command::dump()
  {}

  DumpCommand::DumpCommand(shared_ptr<Command> const & cmd)
    : m_cmd(cmd)
  {}

  void DumpCommand::perform()
  {
    m_cmd->dump();
  }

  Packet::Packet()
  {}

  Packet::Packet(EType type)
    : m_type(type)
  {}

  Packet::Packet(shared_ptr<Command> const & command,
                 EType type)
    : m_command(command),
      m_type(type)
  {}

  PacketsQueue::PacketsQueue()
    : m_fenceManager(5)
  {}

  struct SignalFence : public Command
  {
    int m_id;
    FenceManager * m_fenceManager;

    SignalFence(int id, FenceManager * fenceManager)
      : m_id(id), m_fenceManager(fenceManager)
    {}

    void perform()
    {
      m_fenceManager->signalFence(m_id);
    }

    void cancel()
    {
      perform();
    }
  };

  int PacketsQueue::insertFence(Packet::EType type)
  {
    int id = m_fenceManager.insertFence();
    processPacket(Packet(make_shared_ptr(new SignalFence(id, &m_fenceManager)), type));
    return id;
  }

  void PacketsQueue::joinFence(int id)
  {
    m_fenceManager.joinFence(id);
  }

  void PacketsQueue::completeCommands()
  {
    joinFence(insertFence(Packet::EFramePoint));
  }

  void PacketsQueue::cancelCommands()
  {
    joinFence(insertFence(Packet::ECancelPoint));
  }

  void PacketsQueue::cancel()
  {
    m_packets.Cancel();
    m_fenceManager.cancel();
  }

  void PacketsQueue::cancelFences()
  {
    m_fenceManager.cancel();
  }

  void PacketsQueue::processPacket(Packet const & packet)
  {
    if (m_packets.IsCancelled())
    {
      if (packet.m_command)
        packet.m_command->cancel();
    }
    else
      m_packets.PushBack(packet);
  }

  bool PacketsQueue::empty() const
  {
    return m_packets.Empty();
  }

  size_t PacketsQueue::size() const
  {
    return m_packets.Size();
  }
}