void OGLESRenderEngine::Uniform3fv(GLint location, GLsizei count, GLfloat const * value)
{
bool dirty = false;
KLAYGE_AUTO(iter_p, uniformf_cache_.find(cur_program_));
if (iter_p == uniformf_cache_.end())
{
dirty = true;
iter_p = uniformf_cache_.insert(std::make_pair(cur_program_, std::map<GLint, float4>())).first;
}
for (GLsizei i = 0; i < count; ++ i)
{
KLAYGE_AUTO(iter_v, iter_p->second.find(location + i));
if (iter_v == iter_p->second.end())
{
dirty = true;
iter_p->second.insert(std::make_pair(location, float4(value[i * 3 + 0], value[i * 3 + 1], value[i * 3 + 2], 0)));
}
else
{
if ((iter_v->second.x() != value[i * 3 + 0]) || (iter_v->second.y() != value[i * 3 + 1])
|| (iter_v->second.z() != value[i * 3 + 2]))
{
dirty = true;
iter_v->second.x() = value[i * 3 + 0];
iter_v->second.y() = value[i * 3 + 1];
iter_v->second.z() = value[i * 3 + 2];
}
}
}
if (dirty)
{
glUniform3fv(location, count, value);
}
}
void OGLESRenderEngine::Uniform1f(GLint location, float value)
{
bool dirty = false;
KLAYGE_AUTO(iter_p, uniformf_cache_.find(cur_program_));
if (iter_p == uniformf_cache_.end())
{
dirty = true;
iter_p = uniformf_cache_.insert(std::make_pair(cur_program_, std::map<GLint, float4>())).first;
}
KLAYGE_AUTO(iter_v, iter_p->second.find(location));
if (iter_v == iter_p->second.end())
{
dirty = true;
iter_p->second.insert(std::make_pair(location, float4(value, 0, 0, 0)));
}
else
{
if (iter_v->second.x() != value)
{
dirty = true;
iter_v->second.x() = value;
}
}
if (dirty)
{
glUniform1f(location, value);
}
}
ID3D11DepthStencilViewPtr const & D3D11Texture::RetriveD3DDSV(D3D11_DEPTH_STENCIL_VIEW_DESC const & desc)
{
char const * p = reinterpret_cast<char const *>(&desc);
size_t hash_val = 0;
boost::hash_range(hash_val, p, p + sizeof(desc));
KLAYGE_AUTO(iter, d3d_ds_views_.find(hash_val));
if (iter != d3d_ds_views_.end())
{
return iter->second;
}
ID3D11DepthStencilView* ds_view;
d3d_device_->CreateDepthStencilView(this->D3DResource().get(), &desc, &ds_view);
KLAYGE_AUTO(ret, d3d_ds_views_.insert(std::make_pair(hash_val, MakeCOMPtr(ds_view))));
return ret.first->second;
}
ID3D11UnorderedAccessViewPtr const & D3D11Texture::RetriveD3DUAV(D3D11_UNORDERED_ACCESS_VIEW_DESC const & desc)
{
char const * p = reinterpret_cast<char const *>(&desc);
size_t hash_val = 0;
boost::hash_range(hash_val, p, p + sizeof(desc));
KLAYGE_AUTO(iter, d3d_ua_views_.find(hash_val));
if (iter != d3d_ua_views_.end())
{
return iter->second;
}
ID3D11UnorderedAccessView* d3d_ua_view;
d3d_device_->CreateUnorderedAccessView(this->D3DResource().get(), &desc, &d3d_ua_view);
KLAYGE_AUTO(ret, d3d_ua_views_.insert(std::make_pair(hash_val, MakeCOMPtr(d3d_ua_view))));
return ret.first->second;
}
ID3D11RenderTargetViewPtr const & D3D11Texture::RetriveD3DRTV(D3D11_RENDER_TARGET_VIEW_DESC const & desc)
{
char const * p = reinterpret_cast<char const *>(&desc);
size_t hash_val = 0;
boost::hash_range(hash_val, p, p + sizeof(desc));
KLAYGE_AUTO(iter, d3d_rt_views_.find(hash_val));
if (iter != d3d_rt_views_.end())
{
return iter->second;
}
ID3D11RenderTargetView* rt_view;
d3d_device_->CreateRenderTargetView(this->D3DResource().get(), &desc, &rt_view);
KLAYGE_AUTO(ret, d3d_rt_views_.insert(std::make_pair(hash_val, MakeCOMPtr(rt_view))));
return ret.first->second;
}
ID3D11ShaderResourceViewPtr const & D3D11Texture::RetriveD3DSRV(D3D11_SHADER_RESOURCE_VIEW_DESC const & desc)
{
char const * p = reinterpret_cast<char const *>(&desc);
size_t hash_val = 0;
boost::hash_range(hash_val, p, p + sizeof(desc));
KLAYGE_AUTO(iter, d3d_sr_views_.find(hash_val));
if (iter != d3d_sr_views_.end())
{
return iter->second;
}
ID3D11ShaderResourceView* d3d_sr_view;
d3d_device_->CreateShaderResourceView(this->D3DResource().get(), &desc, &d3d_sr_view);
KLAYGE_AUTO(ret, d3d_sr_views_.insert(std::make_pair(hash_val, MakeCOMPtr(d3d_sr_view))));
return ret.first->second;
}
void OGLESRenderEngine::BindBuffer(GLenum target, GLuint buffer, bool force)
{
KLAYGE_AUTO(iter, binded_buffer_.find(target));
if (force || (iter == binded_buffer_.end()) || (iter->second != buffer))
{
glBindBuffer(target, buffer);
binded_buffer_[target] = buffer;
}
}
void OGLESTexture::TexParameterf(GLenum pname, GLfloat param)
{
KLAYGE_AUTO(iter, tex_param_f_.find(pname));
if ((iter == tex_param_f_.end()) || (iter->second != param))
{
glBindTexture(target_type_, texture_);
glTexParameterf(target_type_, pname, param);
tex_param_f_[pname] = param;
}
}
Lobby::PlayerAddrsIter Lobby::ID(sockaddr_in const & addr)
{
for (KLAYGE_AUTO(iter, players_.begin()); iter != players_.end(); ++ iter)
{
if (0 == std::memcmp(&addr, &(iter->second.addr), sizeof(addr)))
{
return iter;
}
}
return players_.end();
}
// 消息接受函数
/////////////////////////////////////////////////////////////////////////////////
void Player::ReceiveFunc()
{
static time_t lastTime = std::time(nullptr);
for (;;)
{
if (std::time(nullptr) - lastTime >= 10 * 1000)
{
char msg(MSG_NOP);
socket_.Send(&msg, sizeof(msg));
lastTime = std::time(nullptr);
}
if (!sendQueue_.empty())
{
// 发送队列里的消息
typedef KLAYGE_DECLTYPE(sendQueue_) SendQueneType;
KLAYGE_FOREACH(SendQueneType::reference msg, sendQueue_)
{
socket_.Send(&msg[0], static_cast<int>(msg.size()));
}
}
char revBuf[Max_Buffer];
std::fill_n(revBuf, sizeof(revBuf), 0);
if (socket_.Receive(revBuf, sizeof(revBuf)) != -1)
{
uint32_t ID;
std::memcpy(&ID, &revBuf[1], 4);
// 删除已发送的信息
for (KLAYGE_AUTO(iter, sendQueue_.begin()); iter != sendQueue_.end();)
{
std::vector<char>& msg = *iter;
uint32_t sendID;
std::memcpy(&sendID, &msg[1], 4);
if (sendID == ID)
{
iter = sendQueue_.erase(iter);
}
else
{
++ iter;
}
}
if (MSG_QUIT == revBuf[0])
{
break;
}
}
}
void ResLoader::DelPath(std::string const & path)
{
std::string real_path = this->RealPath(path);
if (!real_path.empty())
{
KLAYGE_AUTO(iter, std::find(paths_.begin(), paths_.end(), real_path));
if (iter != paths_.end())
{
paths_.erase(iter);
}
}
}
bool KFont::Load(std::istream& kfont_input)
{
if (kfont_input)
{
kfont_header header;
kfont_input.read(reinterpret_cast<char*>(&header), sizeof(header));
LittleEndianToNative<sizeof(header.fourcc)>(&header.fourcc);
LittleEndianToNative<sizeof(header.version)>(&header.version);
LittleEndianToNative<sizeof(header.start_ptr)>(&header.start_ptr);
LittleEndianToNative<sizeof(header.validate_chars)>(&header.validate_chars);
LittleEndianToNative<sizeof(header.non_empty_chars)>(&header.non_empty_chars);
LittleEndianToNative<sizeof(header.char_size)>(&header.char_size);
LittleEndianToNative<sizeof(header.base)>(&header.base);
LittleEndianToNative<sizeof(header.scale)>(&header.scale);
if ((MakeFourCC<'K', 'F', 'N', 'T'>::value == header.fourcc) && (KFONT_VERSION == header.version))
{
char_size_ = header.char_size;
dist_base_ = header.base;
dist_scale_ = header.scale;
kfont_input.seekg(header.start_ptr, std::ios_base::beg);
std::vector<std::pair<int32_t, int32_t> > temp_char_index(header.non_empty_chars);
kfont_input.read(reinterpret_cast<char*>(&temp_char_index[0]), static_cast<std::streamsize>(temp_char_index.size() * sizeof(temp_char_index[0])));
std::vector<std::pair<int32_t, uint32_t> > temp_char_advance(header.validate_chars);
kfont_input.read(reinterpret_cast<char*>(&temp_char_advance[0]), static_cast<std::streamsize>(temp_char_advance.size() * sizeof(temp_char_advance[0])));
typedef KLAYGE_DECLTYPE(temp_char_index) TCIType;
KLAYGE_FOREACH(TCIType::reference ci, temp_char_index)
{
LittleEndianToNative<sizeof(ci.first)>(&ci.first);
LittleEndianToNative<sizeof(ci.second)>(&ci.second);
char_index_advance_.insert(std::make_pair(ci.first, std::make_pair(ci.second, 0)));
}
typedef KLAYGE_DECLTYPE(temp_char_advance) TCAType;
KLAYGE_FOREACH(TCAType::reference ca, temp_char_advance)
{
LittleEndianToNative<sizeof(ca.first)>(&ca.first);
LittleEndianToNative<sizeof(ca.second)>(&ca.second);
KLAYGE_AUTO(iter, char_index_advance_.find(ca.first));
if (iter != char_index_advance_.end())
{
iter->second.second = ca.second;
}
else
{
char_index_advance_[ca.first] = std::make_pair(-1, ca.second);
}
}
void OGLESRenderEngine::DeleteBuffers(GLsizei n, GLuint const * buffers)
{
for (GLsizei i = 0; i < n; ++ i)
{
for (KLAYGE_AUTO(iter, binded_buffer_.begin()); iter != binded_buffer_.end();)
{
if (iter->second == buffers[i])
{
binded_buffer_.erase(iter ++);
}
else
{
++ iter;
}
}
}
glDeleteBuffers(n, buffers);
}
void OGLTexture::TexParameterf(GLenum pname, GLfloat param)
{
KLAYGE_AUTO(iter, tex_param_f_.find(pname));
if ((iter == tex_param_f_.end()) || (iter->second != param))
{
if (glloader_GL_EXT_direct_state_access())
{
glTextureParameterfEXT(texture_, target_type_, pname, param);
}
else
{
glBindTexture(target_type_, texture_);
glTexParameterf(target_type_, pname, param);
}
tex_param_f_[pname] = param;
}
}
