OGLESTexture::OGLESTexture(TextureType type, uint32_t array_size, uint32_t sample_count, uint32_t sample_quality, uint32_t access_hint)
: Texture(type, sample_count, sample_quality, access_hint),
hw_res_ready_(false)
{
array_size_ = array_size;
if ((array_size > 1) && !glloader_GLES_VERSION_3_0())
{
THR(errc::function_not_supported);
}
switch (type_)
{
case TT_1D:
case TT_2D:
if (array_size > 1)
{
target_type_ = GL_TEXTURE_2D_ARRAY;
}
else
{
target_type_ = GL_TEXTURE_2D;
}
break;
case TT_3D:
if (!glloader_GLES_VERSION_3_0() && !glloader_GLES_OES_texture_3D())
{
THR(errc::function_not_supported);
}
if (glloader_GLES_VERSION_3_0())
{
target_type_ = GL_TEXTURE_3D;
}
else
{
target_type_ = GL_TEXTURE_3D_OES;
}
break;
case TT_Cube:
target_type_ = GL_TEXTURE_CUBE_MAP;
break;
default:
BOOST_ASSERT(false);
target_type_ = GL_TEXTURE_2D;
break;
}
glGenTextures(1, &texture_);
glBindTexture(target_type_, texture_);
glTexParameteri(target_type_, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(target_type_, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
}
static void uart_port_putchar(int port, unsigned char c)
{
if (c == '\n')
uart_port_putchar(port, '\r');
while (!(inb(LSR(port)) & 0x20));
outb(c, THR(port));
}
// 枚举系统显卡
/////////////////////////////////////////////////////////////////////////////////
void D3D11AdapterList::Enumerate(IDXGIFactory1Ptr const & gi_factory)
{
// 枚举系统中的适配器
UINT adapter_no = 0;
IDXGIAdapter1* dxgi_adapter = nullptr;
while (gi_factory->EnumAdapters1(adapter_no, &dxgi_adapter) != DXGI_ERROR_NOT_FOUND)
{
if (dxgi_adapter != nullptr)
{
DXGI_ADAPTER_DESC ad;
dxgi_adapter->GetDesc(&ad);
D3D11AdapterPtr adapter = MakeSharedPtr<D3D11Adapter>(adapter_no, MakeCOMPtr(dxgi_adapter));
adapter->Enumerate();
adapters_.push_back(adapter);
}
++ adapter_no;
}
// 如果没有找到兼容的设备则抛出错误
if (adapters_.empty())
{
THR(errc::function_not_supported);
}
}
void FrameBuffer::Detach(uint32_t att)
{
switch (att)
{
case ATT_DepthStencil:
{
rs_view_.reset();
}
break;
default:
{
RenderEngine& re = Context::Instance().RenderFactoryInstance().RenderEngineInstance();
if (att >= static_cast<uint32_t>(ATT_Color0 + re.DeviceCaps().max_simultaneous_rts))
{
THR(errc::function_not_supported);
}
uint32_t clr_id = att - ATT_Color0;
if ((clr_views_.size() < clr_id + 1) && clr_views_[clr_id])
{
clr_views_[clr_id]->OnDetached(*this, att);
clr_views_[clr_id].reset();
}
}
break;
}
views_dirty_ = true;
}
// ╤оят
inline void
Verify(bool x)
{
if (!x)
{
THR(errc::function_not_supported);
}
}
/*
* Output a single byte to the serial port.
*/
void serial_putc (const char c)
{
/* wait for room in the tx FIFO on UART */
while ((LSR(CONFIG_SYS_IXP425_CONSOLE) & LSR_TEMT) == 0);
THR(CONFIG_SYS_IXP425_CONSOLE) = c;
/* If \n, also do \r */
if (c == '\n')
serial_putc ('\r');
}
void OGLTexture::BuildMipSubLevels()
{
if (glloader_GL_EXT_framebuffer_object())
{
this->GLBindTexture();
glGenerateMipmapEXT(target_type_);
}
else
{
THR(errc::function_not_supported);
}
}
OGLESTexture::OGLESTexture(TextureType type, uint32_t array_size, uint32_t sample_count, uint32_t sample_quality, uint32_t access_hint)
: Texture(type, sample_count, sample_quality, access_hint)
{
if (array_size > 1)
{
THR(errc::function_not_supported);
}
switch (type_)
{
case TT_1D:
case TT_2D:
target_type_ = GL_TEXTURE_2D;
break;
case TT_3D:
if (!glloader_GLES_VERSION_3_0() && !glloader_GLES_OES_texture_3D())
{
THR(errc::function_not_supported);
}
if (glloader_GLES_VERSION_3_0())
{
target_type_ = GL_TEXTURE_3D;
}
else
{
target_type_ = GL_TEXTURE_3D_OES;
}
break;
case TT_Cube:
target_type_ = GL_TEXTURE_CUBE_MAP;
break;
default:
BOOST_ASSERT(false);
target_type_ = GL_TEXTURE_2D;
break;
}
}
OGLESTexture2DRenderView::OGLESTexture2DRenderView(Texture& texture_2d, int array_index, int level)
: texture_2d_(*checked_cast<OGLESTexture2D*>(&texture_2d)),
array_index_(array_index), level_(level)
{
BOOST_ASSERT(Texture::TT_2D == texture_2d.Type());
if (array_index > 0)
{
THR(errc::function_not_supported);
}
uint32_t const channels = NumComponents(texture_2d.Format());
if (((1 == channels) || (2 == channels)) && (!(glloader_GLES_VERSION_3_0() || glloader_GLES_EXT_texture_rg())))
{
THR(errc::function_not_supported);
}
tex_ = texture_2d_.GLTexture();
width_ = texture_2d_.Width(level);
height_ = texture_2d_.Height(level);
pf_ = texture_2d_.Format();
}
OGLTexture::OGLTexture(TextureType type, uint32_t array_size, uint32_t sample_count, uint32_t sample_quality, uint32_t access_hint)
: Texture(type, sample_count, sample_quality, access_hint)
{
array_size_ = array_size;
if ((array_size > 1) && (!(glloader_GL_VERSION_3_0() || glloader_GL_EXT_texture_array())))
{
THR(errc::function_not_supported);
}
switch (type_)
{
case TT_1D:
if (array_size > 1)
{
target_type_ = GL_TEXTURE_1D_ARRAY;
}
else
{
target_type_ = GL_TEXTURE_1D;
}
break;
case TT_2D:
if (array_size > 1)
{
target_type_ = GL_TEXTURE_2D_ARRAY;
}
else
{
target_type_ = GL_TEXTURE_2D;
}
break;
case TT_3D:
target_type_ = GL_TEXTURE_3D;
break;
case TT_Cube:
target_type_ = GL_TEXTURE_CUBE_MAP;
break;
default:
BOOST_ASSERT(false);
target_type_ = GL_TEXTURE_1D;
break;
}
}
void FrameBuffer::DetachUAV(uint32_t att)
{
RenderEngine& re = Context::Instance().RenderFactoryInstance().RenderEngineInstance();
if (att >= static_cast<uint32_t>(ATT_Color0 + re.DeviceCaps().max_simultaneous_rts))
{
THR(errc::function_not_supported);
}
if ((ua_views_.size() < att + 1) && ua_views_[att])
{
ua_views_[att]->OnDetached(*this, att);
ua_views_[att].reset();
}
views_dirty_ = true;
}
OGLESDepthStencilRenderView::OGLESDepthStencilRenderView(Texture& texture, int array_index, int level)
: target_type_(checked_cast<OGLESTexture2D*>(&texture)->GLType()), array_index_(array_index), level_(level)
{
BOOST_ASSERT(Texture::TT_2D == texture.Type());
BOOST_ASSERT(IsDepthFormat(texture.Format()));
if (array_index > 0)
{
THR(errc::function_not_supported);
}
width_ = texture.Width(level);
height_ = texture.Height(level);
pf_ = texture.Format();
tex_ = checked_cast<OGLESTexture2D*>(&texture)->GLTexture();
}
static int fpga_write(int iobase, unsigned char wrd)
{
unsigned char bit;
int k;
unsigned long timeout = jiffies + HZ / 10;
for (k = 0; k < 8; k++) {
bit = (wrd & 0x80) ? (MCR_RTS | MCR_DTR) : MCR_DTR;
outb(bit | MCR_OUT1 | MCR_OUT2, MCR(iobase));
wrd <<= 1;
outb(0xfc, THR(iobase));
while ((inb(LSR(iobase)) & LSR_TSRE) == 0)
if (time_after(jiffies, timeout))
return -1;
}
return 0;
}
OGLESTextureCubeDepthStencilRenderView::OGLESTextureCubeDepthStencilRenderView(Texture& texture_cube, int array_index, Texture::CubeFaces face, int level)
: texture_cube_(*checked_cast<OGLESTextureCube*>(&texture_cube)),
face_(face), level_(level)
{
BOOST_ASSERT(Texture::TT_Cube == texture_cube.Type());
BOOST_ASSERT(IsDepthFormat(texture_cube.Format()));
if (array_index > 0)
{
THR(errc::function_not_supported);
}
width_ = texture_cube.Width(level);
height_ = texture_cube.Height(level);
pf_ = texture_cube.Format();
tex_ = checked_cast<OGLESTextureCube*>(&texture_cube)->GLTexture();
}
static inline void ser12_set_divisor(struct net_device *dev,
unsigned char divisor)
{
outb(0x81, LCR(dev->base_addr)); /* DLAB = 1 */
outb(divisor, DLL(dev->base_addr));
outb(0, DLM(dev->base_addr));
outb(0x01, LCR(dev->base_addr)); /* word length = 6 */
/*
* make sure the next interrupt is generated;
* 0 must be used to power the modem; the modem draws its
* power from the TxD line
*/
outb(0x00, THR(dev->base_addr));
/*
* it is important not to set the divider while transmitting;
* this reportedly makes some UARTs generating interrupts
* in the hundredthousands per second region
* Reported by: [email protected] (Ignacio Arenaza Nuno)
*/
}
OGLESTextureCubeRenderView::OGLESTextureCubeRenderView(Texture& texture_cube, int array_index, Texture::CubeFaces face, int level)
: texture_cube_(*checked_cast<OGLESTextureCube*>(&texture_cube)),
face_(face), level_(level)
{
UNREF_PARAM(array_index);
BOOST_ASSERT(Texture::TT_Cube == texture_cube.Type());
BOOST_ASSERT(0 == array_index);
uint32_t const channels = NumComponents(texture_cube.Format());
if (((1 == channels) || (2 == channels)) && (!(glloader_GLES_VERSION_3_0() || glloader_GLES_EXT_texture_rg())))
{
THR(errc::function_not_supported);
}
tex_ = texture_cube_.GLTexture();
width_ = texture_cube_.Width(level);
height_ = texture_cube_.Height(level);
pf_ = texture_cube_.Format();
}
OGLESTexture3DRenderView::OGLESTexture3DRenderView(Texture& texture_3d, int array_index, uint32_t slice, int level)
: texture_3d_(*checked_cast<OGLESTexture3D*>(&texture_3d)),
slice_(slice), level_(level), copy_to_tex_(0)
{
UNREF_PARAM(array_index);
BOOST_ASSERT(Texture::TT_3D == texture_3d.Type());
BOOST_ASSERT(texture_3d_.Depth(level) > slice);
BOOST_ASSERT(0 == array_index);
uint32_t const channels = NumComponents(texture_3d.Format());
if (((1 == channels) || (2 == channels)) && (!(glloader_GLES_VERSION_3_0() || glloader_GLES_EXT_texture_rg())))
{
THR(errc::function_not_supported);
}
tex_ = texture_3d_.GLTexture();
width_ = texture_3d_.Width(level);
height_ = texture_3d_.Height(level);
pf_ = texture_3d_.Format();
}
void OGLMapping::Mapping(GLenum& primType, uint32_t& primCount, RenderLayout const & rl)
{
uint32_t const vertexCount = static_cast<uint32_t>(rl.UseIndices() ? rl.NumIndices() : rl.NumVertices());
primType = GL_POINTS;
primCount = vertexCount;
switch (rl.TopologyType())
{
case RenderLayout::TT_PointList:
primType = GL_POINTS;
primCount = vertexCount;
break;
case RenderLayout::TT_LineList:
primType = GL_LINES;
primCount = vertexCount / 2;
break;
case RenderLayout::TT_LineStrip:
primType = GL_LINE_STRIP;
primCount = vertexCount - 1;
break;
case RenderLayout::TT_TriangleList:
primType = GL_TRIANGLES;
primCount = vertexCount / 3;
break;
case RenderLayout::TT_TriangleStrip:
primType = GL_TRIANGLE_STRIP;
primCount = vertexCount - 2;
break;
default:
THR(errc::function_not_supported);
}
}
void FrameBuffer::AttachUAV(uint32_t att, UnorderedAccessViewPtr const & view)
{
RenderEngine& re = Context::Instance().RenderFactoryInstance().RenderEngineInstance();
if (att >= static_cast<uint32_t>(re.DeviceCaps().max_simultaneous_uavs))
{
THR(errc::function_not_supported);
}
if ((att < ua_views_.size()) && ua_views_[att])
{
this->DetachUAV(att);
}
if (ua_views_.size() < att + 1)
{
ua_views_.resize(att + 1);
}
ua_views_[att] = view;
view->OnAttached(*this, att);
views_dirty_ = true;
}
static void yam_tx_byte(struct net_device *dev, struct yam_port *yp)
{
struct sk_buff *skb;
unsigned char b, temp;
switch (yp->tx_state) {
case TX_OFF:
break;
case TX_HEAD:
if (--yp->tx_count <= 0) {
if (!(skb = skb_dequeue(&yp->send_queue))) {
ptt_off(dev);
yp->tx_state = TX_OFF;
break;
}
yp->tx_state = TX_DATA;
if (skb->data[0] != 0) {
/* do_kiss_params(s, skb->data, skb->len); */
dev_kfree_skb_any(skb);
break;
}
yp->tx_len = skb->len - 1; /* strip KISS byte */
if (yp->tx_len >= YAM_MAX_FRAME || yp->tx_len < 2) {
dev_kfree_skb_any(skb);
break;
}
skb_copy_from_linear_data_offset(skb, 1,
yp->tx_buf,
yp->tx_len);
dev_kfree_skb_any(skb);
yp->tx_count = 0;
yp->tx_crcl = 0x21;
yp->tx_crch = 0xf3;
yp->tx_state = TX_DATA;
}
break;
case TX_DATA:
b = yp->tx_buf[yp->tx_count++];
outb(b, THR(dev->base_addr));
temp = yp->tx_crcl;
yp->tx_crcl = chktabl[temp] ^ yp->tx_crch;
yp->tx_crch = chktabh[temp] ^ b;
if (yp->tx_count >= yp->tx_len) {
yp->tx_state = TX_CRC1;
}
break;
case TX_CRC1:
yp->tx_crch = chktabl[yp->tx_crcl] ^ yp->tx_crch;
yp->tx_crcl = chktabh[yp->tx_crcl] ^ chktabl[yp->tx_crch] ^ 0xff;
outb(yp->tx_crcl, THR(dev->base_addr));
yp->tx_state = TX_CRC2;
break;
case TX_CRC2:
outb(chktabh[yp->tx_crch] ^ 0xFF, THR(dev->base_addr));
if (skb_queue_empty(&yp->send_queue)) {
yp->tx_count = (yp->bitrate * yp->txtail) / 8000;
if (yp->dupmode == 2)
yp->tx_count += (yp->bitrate * yp->holdd) / 8;
if (yp->tx_count == 0)
yp->tx_count = 1;
yp->tx_state = TX_TAIL;
} else {
yp->tx_count = 1;
yp->tx_state = TX_HEAD;
}
++dev->stats.tx_packets;
break;
case TX_TAIL:
if (--yp->tx_count <= 0) {
yp->tx_state = TX_OFF;
ptt_off(dev);
}
break;
}
}
OGLESRenderWindow::OGLESRenderWindow(std::string const & name, RenderSettings const & settings)
: OGLESFrameBuffer(false)
{
// Store info
name_ = name;
width_ = settings.width;
height_ = settings.height;
isFullScreen_ = settings.full_screen;
color_bits_ = NumFormatBits(settings.color_fmt);
WindowPtr const & main_wnd = Context::Instance().AppInstance().MainWnd();
on_paint_connect_ = main_wnd->OnPaint().connect(bind(&OGLESRenderWindow::OnPaint, this,
placeholders::_1));
on_exit_size_move_connect_ = main_wnd->OnExitSizeMove().connect(bind(&OGLESRenderWindow::OnExitSizeMove, this,
placeholders::_1));
on_size_connect_ = main_wnd->OnSize().connect(bind(&OGLESRenderWindow::OnSize, this,
placeholders::_1, placeholders::_2));
on_close_connect_ = main_wnd->OnClose().connect(bind(&OGLESRenderWindow::OnClose, this,
placeholders::_1));
if (isFullScreen_)
{
left_ = 0;
top_ = 0;
}
else
{
top_ = settings.top;
left_ = settings.left;
}
display_ = eglGetDisplay(EGL_DEFAULT_DISPLAY);
int r_size, g_size, b_size, a_size, d_size, s_size;
switch (settings.color_fmt)
{
case EF_ARGB8:
case EF_ABGR8:
r_size = 8;
g_size = 8;
b_size = 8;
a_size = 8;
break;
case EF_A2BGR10:
r_size = 10;
g_size = 10;
b_size = 10;
a_size = 2;
break;
default:
BOOST_ASSERT(false);
break;
}
switch (settings.depth_stencil_fmt)
{
case EF_D16:
d_size = 16;
s_size = 0;
break;
case EF_D24S8:
d_size = 24;
s_size = 8;
break;
case EF_D32F:
d_size = 32;
s_size = 0;
break;
default:
d_size = 0;
s_size = 0;
break;
}
std::vector<EGLint> visual_attr;
visual_attr.push_back(EGL_RENDERABLE_TYPE);
visual_attr.push_back(EGL_OPENGL_ES3_BIT_KHR);
visual_attr.push_back(EGL_RED_SIZE);
visual_attr.push_back(r_size);
visual_attr.push_back(EGL_GREEN_SIZE);
visual_attr.push_back(g_size);
visual_attr.push_back(EGL_BLUE_SIZE);
visual_attr.push_back(b_size);
visual_attr.push_back(EGL_ALPHA_SIZE);
visual_attr.push_back(a_size);
if (d_size > 0)
{
visual_attr.push_back(EGL_DEPTH_SIZE);
visual_attr.push_back(d_size);
}
if (s_size > 0)
{
visual_attr.push_back(EGL_STENCIL_SIZE);
visual_attr.push_back(s_size);
}
if (settings.sample_count > 1)
{
visual_attr.push_back(EGL_SAMPLES);
visual_attr.push_back(settings.sample_count);
}
visual_attr.push_back(EGL_NONE); // end of list
EGLint major_ver, minor_ver;
EGLint num_cfgs;
eglInitialize(display_, &major_ver, &minor_ver);
eglGetConfigs(display_, nullptr, 0, &num_cfgs);
#if !defined(KLAYGE_PLATFORM_ANDROID) || (__ANDROID_API__ >= 18)
if (!eglChooseConfig(display_, &visual_attr[0], &cfg_, 1, &num_cfgs))
#endif
{
visual_attr[1] = EGL_OPENGL_ES2_BIT;
eglChooseConfig(display_, &visual_attr[0], &cfg_, 1, &num_cfgs);
}
NativeWindowType wnd;
#if defined KLAYGE_PLATFORM_WINDOWS
wnd = hWnd_ = main_wnd->HWnd();
hDC_ = ::GetDC(hWnd_);
#elif defined KLAYGE_PLATFORM_LINUX
wnd = x_window_ = main_wnd->XWindow();
#elif defined KLAYGE_PLATFORM_ANDROID
wnd = a_window_ = main_wnd->AWindow();
EGLint format;
eglGetConfigAttrib(display_, cfg_, EGL_NATIVE_VISUAL_ID, &format);
ANativeWindow_setBuffersGeometry(wnd, 0, 0, format);
#endif
surf_ = eglCreateWindowSurface(display_, cfg_, wnd, nullptr);
EGLint ctx_attr[] = { EGL_CONTEXT_CLIENT_VERSION, 3, EGL_NONE };
#if !defined(KLAYGE_PLATFORM_ANDROID) || (__ANDROID_API__ >= 18)
context_ = eglCreateContext(display_, cfg_, EGL_NO_CONTEXT, ctx_attr);
if (nullptr == context_)
#endif
{
ctx_attr[1] = 2;
context_ = eglCreateContext(display_, cfg_, EGL_NO_CONTEXT, ctx_attr);
}
eglMakeCurrent(display_, surf_, surf_, context_);
if (!glloader_GLES_VERSION_2_0())
{
THR(errc::function_not_supported);
}
eglSwapInterval(display_, 0);
glPixelStorei(GL_PACK_ALIGNMENT, 1);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
viewport_->left = 0;
viewport_->top = 0;
viewport_->width = width_;
viewport_->height = height_;
std::wstring vendor, renderer, version;
Convert(vendor, reinterpret_cast<char const *>(glGetString(GL_VENDOR)));
Convert(renderer, reinterpret_cast<char const *>(glGetString(GL_RENDERER)));
Convert(version, reinterpret_cast<char const *>(glGetString(GL_VERSION)));
std::wostringstream oss;
oss << vendor << L" " << renderer << L" " << version;
if (settings.sample_count > 1)
{
oss << L" (" << settings.sample_count << L"x AA)";
}
description_ = oss.str();
}
void OGLMapping::MappingVertexFormat(GLenum& gltype, GLboolean& normalized, ElementFormat ef)
{
switch (ef)
{
case EF_A8:
case EF_R8:
case EF_GR8:
case EF_BGR8:
case EF_ARGB8:
case EF_ABGR8:
gltype = GL_UNSIGNED_BYTE;
normalized = GL_TRUE;
break;
case EF_R8UI:
case EF_GR8UI:
case EF_BGR8UI:
case EF_ABGR8UI:
gltype = GL_UNSIGNED_BYTE;
normalized = GL_FALSE;
break;
case EF_SIGNED_R8:
case EF_SIGNED_GR8:
case EF_SIGNED_BGR8:
case EF_SIGNED_ABGR8:
gltype = GL_BYTE;
normalized = GL_TRUE;
break;
case EF_R8I:
case EF_GR8I:
case EF_BGR8I:
case EF_ABGR8I:
gltype = GL_BYTE;
normalized = GL_FALSE;
break;
case EF_A2BGR10:
gltype = GL_UNSIGNED_INT_2_10_10_10_REV;
normalized = GL_TRUE;
break;
case EF_SIGNED_A2BGR10:
if (glloader_GL_VERSION_3_3() || glloader_GL_ARB_vertex_type_2_10_10_10_rev())
{
gltype = GL_INT_2_10_10_10_REV;
}
else
{
gltype = GL_UNSIGNED_INT_2_10_10_10_REV;
}
normalized = GL_TRUE;
break;
case EF_R16:
case EF_GR16:
case EF_BGR16:
case EF_ABGR16:
gltype = GL_UNSIGNED_SHORT;
normalized = GL_TRUE;
break;
case EF_R16UI:
case EF_GR16UI:
case EF_BGR16UI:
case EF_ABGR16UI:
gltype = GL_UNSIGNED_SHORT;
normalized = GL_FALSE;
break;
case EF_SIGNED_R16:
case EF_SIGNED_GR16:
case EF_SIGNED_BGR16:
case EF_SIGNED_ABGR16:
gltype = GL_SHORT;
normalized = GL_TRUE;
break;
case EF_R16I:
case EF_GR16I:
case EF_BGR16I:
case EF_ABGR16I:
gltype = GL_SHORT;
normalized = GL_FALSE;
break;
case EF_R32UI:
case EF_GR32UI:
case EF_BGR32UI:
case EF_ABGR32UI:
gltype = GL_UNSIGNED_INT;
normalized = GL_FALSE;
break;
case EF_R32I:
case EF_GR32I:
case EF_BGR32I:
case EF_ABGR32I:
gltype = GL_INT;
normalized = GL_FALSE;
break;
case EF_R16F:
case EF_GR16F:
case EF_BGR16F:
case EF_ABGR16F:
if (glloader_GL_VERSION_3_0() || glloader_GL_ARB_texture_rg())
{
gltype = GL_HALF_FLOAT_ARB;
}
else
{
gltype = GL_FLOAT;
}
normalized = GL_FALSE;
break;
case EF_B10G11R11F:
if (glloader_GL_VERSION_3_0() || glloader_GL_EXT_packed_float())
{
gltype = GL_UNSIGNED_INT_10F_11F_11F_REV;
}
else
{
THR(errc::function_not_supported);
}
normalized = GL_FALSE;
break;
case EF_R32F:
case EF_GR32F:
case EF_BGR32F:
case EF_ABGR32F:
gltype = GL_FLOAT;
normalized = GL_FALSE;
break;
default:
THR(errc::function_not_supported);
}
}
void OGLMapping::MappingFormat(GLint& internalFormat, GLenum& glformat, GLenum& gltype, ElementFormat ef)
{
switch (ef)
{
case EF_A8:
internalFormat = GL_ALPHA8;
glformat = GL_ALPHA;
gltype = GL_UNSIGNED_BYTE;
break;
case EF_R5G6B5:
internalFormat = GL_RGB565;
glformat = GL_BGRA;
gltype = GL_UNSIGNED_SHORT_5_6_5_REV;
break;
case EF_A1RGB5:
internalFormat = GL_RGB5_A1;
glformat = GL_BGRA;
gltype = GL_UNSIGNED_SHORT_1_5_5_5_REV;
break;
case EF_ARGB4:
internalFormat = GL_RGBA4;
glformat = GL_BGRA;
gltype = GL_UNSIGNED_SHORT_4_4_4_4_REV;
break;
case EF_R8:
if (glloader_GL_VERSION_3_0() || glloader_GL_ARB_texture_rg())
{
internalFormat = GL_R8;
glformat = GL_RED;
gltype = GL_UNSIGNED_BYTE;
}
else
{
internalFormat = GL_LUMINANCE8;
glformat = GL_LUMINANCE;
gltype = GL_UNSIGNED_BYTE;
}
break;
case EF_SIGNED_R8:
if (glloader_GL_VERSION_3_0() || glloader_GL_ARB_texture_rg())
{
internalFormat = GL_R8;
glformat = GL_RED;
gltype = GL_BYTE;
}
else
{
internalFormat = GL_LUMINANCE8;
glformat = GL_LUMINANCE;
gltype = GL_BYTE;
}
break;
case EF_GR8:
if (glloader_GL_VERSION_3_0() || glloader_GL_ARB_texture_rg())
{
internalFormat = GL_RG8;
glformat = GL_RG;
gltype = GL_UNSIGNED_BYTE;
}
else
{
THR(errc::function_not_supported);
}
break;
case EF_SIGNED_GR8:
if (glloader_GL_VERSION_3_0() || glloader_GL_ARB_texture_rg())
{
internalFormat = GL_RG8;
glformat = GL_RG;
gltype = GL_BYTE;
}
else
{
THR(errc::function_not_supported);
}
break;
case EF_BGR8:
internalFormat = GL_RGB8;
glformat = GL_RGB;
gltype = GL_UNSIGNED_BYTE;
break;
case EF_SIGNED_BGR8:
if (glloader_GL_VERSION_3_1() || glloader_GL_EXT_texture_snorm())
{
internalFormat = GL_RGB8_SNORM;
glformat = GL_RGB;
gltype = GL_BYTE;
}
else
{
THR(errc::function_not_supported);
}
break;
case EF_ARGB8:
internalFormat = GL_RGBA8;
glformat = GL_BGRA;
gltype = GL_UNSIGNED_INT_8_8_8_8_REV;
break;
case EF_ABGR8:
internalFormat = GL_RGBA8;
glformat = GL_RGBA;
gltype = GL_UNSIGNED_BYTE;
break;
case EF_SIGNED_ABGR8:
if (glloader_GL_VERSION_3_1() || glloader_GL_EXT_texture_snorm())
{
internalFormat = GL_RGBA8_SNORM;
glformat = GL_RGBA;
gltype = GL_BYTE;
}
else
{
THR(errc::function_not_supported);
}
break;
case EF_A2BGR10:
internalFormat = GL_RGB10_A2;
glformat = GL_RGBA;
gltype = GL_UNSIGNED_INT_2_10_10_10_REV;
break;
case EF_SIGNED_A2BGR10:
internalFormat = GL_RGB10_A2;
glformat = GL_RGBA;
if (glloader_GL_VERSION_3_3() || glloader_GL_ARB_vertex_type_2_10_10_10_rev())
{
gltype = GL_INT_2_10_10_10_REV;
}
else
{
gltype = GL_UNSIGNED_INT_2_10_10_10_REV;
}
break;
case EF_R8UI:
if (glloader_GL_VERSION_3_0() || glloader_GL_EXT_texture_integer())
{
internalFormat = GL_R8UI;
glformat = GL_RED_INTEGER_EXT;
gltype = GL_UNSIGNED_BYTE;
}
else
{
THR(errc::function_not_supported);
}
break;
case EF_R8I:
if (glloader_GL_VERSION_3_0() || glloader_GL_EXT_texture_integer())
{
internalFormat = GL_R8I;
glformat = GL_RED_INTEGER_EXT;
gltype = GL_BYTE;
}
else
{
THR(errc::function_not_supported);
}
break;
case EF_GR8UI:
if (glloader_GL_VERSION_3_0() || glloader_GL_EXT_texture_integer())
{
internalFormat = GL_RG8UI;
glformat = GL_RG_INTEGER;
gltype = GL_UNSIGNED_BYTE;
}
else
{
THR(errc::function_not_supported);
}
break;
case EF_GR8I:
if (glloader_GL_VERSION_3_0() || glloader_GL_EXT_texture_integer())
{
internalFormat = GL_RG8I;
glformat = GL_RG_INTEGER;
gltype = GL_BYTE;
}
else
{
THR(errc::function_not_supported);
}
break;
case EF_BGR8UI:
if (glloader_GL_VERSION_3_0() || glloader_GL_EXT_texture_integer())
{
internalFormat = GL_RGB8UI;
glformat = GL_RGB_INTEGER;
gltype = GL_UNSIGNED_BYTE;
}
else
{
THR(errc::function_not_supported);
}
break;
case EF_BGR8I:
if (glloader_GL_VERSION_3_0() || glloader_GL_EXT_texture_integer())
{
internalFormat = GL_RGB8I;
glformat = GL_RGB_INTEGER;
gltype = GL_BYTE;
}
else
{
THR(errc::function_not_supported);
}
break;
case EF_ABGR8UI:
if (glloader_GL_VERSION_3_0() || glloader_GL_EXT_texture_integer())
{
internalFormat = GL_RGBA8UI;
glformat = GL_RGBA_INTEGER;
gltype = GL_UNSIGNED_INT_8_8_8_8;
}
else
{
THR(errc::function_not_supported);
}
break;
case EF_ABGR8I:
if (glloader_GL_VERSION_3_0() || glloader_GL_EXT_texture_integer())
{
internalFormat = GL_RGBA8I;
glformat = GL_RGBA_INTEGER;
gltype = GL_UNSIGNED_INT_8_8_8_8;
}
else
{
THR(errc::function_not_supported);
}
break;
case EF_R16:
if (glloader_GL_VERSION_3_0() || glloader_GL_ARB_texture_rg())
{
internalFormat = GL_R16;
glformat = GL_RED;
gltype = GL_UNSIGNED_SHORT;
}
else
{
internalFormat = GL_LUMINANCE16;
glformat = GL_LUMINANCE;
gltype = GL_UNSIGNED_SHORT;
}
break;
case EF_SIGNED_R16:
if (glloader_GL_VERSION_3_0() || glloader_GL_ARB_texture_rg())
{
internalFormat = GL_R16;
glformat = GL_RED;
gltype = GL_SHORT;
}
else
{
internalFormat = GL_LUMINANCE16;
glformat = GL_LUMINANCE;
gltype = GL_SHORT;
}
break;
case EF_GR16:
if (glloader_GL_VERSION_3_0() || glloader_GL_ARB_texture_rg())
{
internalFormat = GL_RG16;
glformat = GL_RG;
gltype = GL_UNSIGNED_SHORT;
}
else
{
THR(errc::function_not_supported);
}
break;
case EF_SIGNED_GR16:
if (glloader_GL_VERSION_3_0() || glloader_GL_ARB_texture_rg())
{
internalFormat = GL_RG16;
glformat = GL_RG;
gltype = GL_SHORT;
}
else
{
THR(errc::function_not_supported);
}
break;
case EF_BGR16:
internalFormat = GL_RGB16;
glformat = GL_RGB;
gltype = GL_UNSIGNED_SHORT;
break;
case EF_SIGNED_BGR16:
internalFormat = GL_RGB16;
glformat = GL_RGB;
gltype = GL_SHORT;
break;
case EF_ABGR16:
internalFormat = GL_RGBA16;
glformat = GL_RGBA;
gltype = GL_UNSIGNED_SHORT;
break;
case EF_SIGNED_ABGR16:
internalFormat = GL_RGBA16;
glformat = GL_RGBA;
gltype = GL_SHORT;
break;
case EF_R16UI:
if (glloader_GL_VERSION_3_0() || glloader_GL_EXT_texture_integer())
{
internalFormat = GL_R16UI;
glformat = GL_RED_INTEGER_EXT;
gltype = GL_UNSIGNED_SHORT;
}
else
{
THR(errc::function_not_supported);
}
break;
case EF_R16I:
if (glloader_GL_VERSION_3_0() || glloader_GL_EXT_texture_integer())
{
internalFormat = GL_R16I;
glformat = GL_RED_INTEGER_EXT;
gltype = GL_SHORT;
}
else
{
THR(errc::function_not_supported);
}
break;
case EF_GR16UI:
if (glloader_GL_VERSION_3_0() || glloader_GL_EXT_texture_integer())
{
internalFormat = GL_RG16UI;
glformat = GL_RG_INTEGER;
gltype = GL_UNSIGNED_SHORT;
}
else
{
THR(errc::function_not_supported);
}
break;
case EF_GR16I:
if (glloader_GL_VERSION_3_0() || glloader_GL_EXT_texture_integer())
{
internalFormat = GL_RG16I;
glformat = GL_RG_INTEGER;
gltype = GL_SHORT;
}
else
{
THR(errc::function_not_supported);
}
break;
case EF_BGR16UI:
if (glloader_GL_VERSION_3_0() || glloader_GL_EXT_texture_integer())
{
internalFormat = GL_RGB16UI;
glformat = GL_RGB_INTEGER;
gltype = GL_UNSIGNED_SHORT;
}
else
{
THR(errc::function_not_supported);
}
break;
case EF_BGR16I:
if (glloader_GL_VERSION_3_0() || glloader_GL_EXT_texture_integer())
{
internalFormat = GL_RGB16I;
glformat = GL_RGB_INTEGER;
gltype = GL_SHORT;
}
else
{
THR(errc::function_not_supported);
}
break;
case EF_ABGR16UI:
if (glloader_GL_VERSION_3_0() || glloader_GL_EXT_texture_integer())
{
internalFormat = GL_RGBA16UI;
glformat = GL_RGBA_INTEGER;
gltype = GL_UNSIGNED_SHORT;
}
else
{
THR(errc::function_not_supported);
}
break;
case EF_ABGR16I:
if (glloader_GL_VERSION_3_0() || glloader_GL_EXT_texture_integer())
{
internalFormat = GL_RGBA16I;
glformat = GL_RGBA_INTEGER;
gltype = GL_SHORT;
}
else
{
THR(errc::function_not_supported);
}
break;
case EF_R32UI:
if (glloader_GL_VERSION_3_0() || glloader_GL_EXT_texture_integer())
{
internalFormat = GL_R32UI;
glformat = GL_RED_INTEGER_EXT;
gltype = GL_UNSIGNED_INT;
}
else
{
THR(errc::function_not_supported);
}
break;
case EF_R32I:
if (glloader_GL_VERSION_3_0() || glloader_GL_EXT_texture_integer())
{
internalFormat = GL_R32I;
glformat = GL_RED_INTEGER_EXT;
gltype = GL_INT;
}
else
{
THR(errc::function_not_supported);
}
break;
case EF_GR32UI:
if (glloader_GL_VERSION_3_0() || glloader_GL_EXT_texture_integer())
{
internalFormat = GL_RG32UI;
glformat = GL_RG_INTEGER;
gltype = GL_UNSIGNED_INT;
}
else
{
THR(errc::function_not_supported);
}
break;
case EF_GR32I:
if (glloader_GL_VERSION_3_0() || glloader_GL_EXT_texture_integer())
{
internalFormat = GL_RG32I;
glformat = GL_RG_INTEGER;
gltype = GL_INT;
}
else
{
THR(errc::function_not_supported);
}
break;
case EF_BGR32UI:
if (glloader_GL_VERSION_3_0() || glloader_GL_EXT_texture_integer())
{
internalFormat = GL_RGB32UI;
glformat = GL_RGB_INTEGER;
gltype = GL_UNSIGNED_INT;
}
else
{
THR(errc::function_not_supported);
}
break;
case EF_BGR32I:
if (glloader_GL_VERSION_3_0() || glloader_GL_EXT_texture_integer())
{
internalFormat = GL_RGB32I;
glformat = GL_RGB_INTEGER;
gltype = GL_INT;
}
else
{
THR(errc::function_not_supported);
}
break;
case EF_ABGR32UI:
if (glloader_GL_VERSION_3_0() || glloader_GL_EXT_texture_integer())
{
internalFormat = GL_RGBA32UI;
glformat = GL_RGBA_INTEGER;
gltype = GL_UNSIGNED_INT;
}
else
{
THR(errc::function_not_supported);
}
break;
case EF_ABGR32I:
if (glloader_GL_VERSION_3_0() || glloader_GL_EXT_texture_integer())
{
internalFormat = GL_RGBA32I;
glformat = GL_RGBA_INTEGER;
gltype = GL_INT;
}
else
{
THR(errc::function_not_supported);
}
break;
case EF_R16F:
if (glloader_GL_VERSION_3_0() || glloader_GL_ARB_texture_rg())
{
internalFormat = GL_R16F;
glformat = GL_RED;
gltype = GL_HALF_FLOAT_ARB;
}
else
{
internalFormat = GL_LUMINANCE16F_ARB;
glformat = GL_LUMINANCE;
gltype = GL_HALF_FLOAT_ARB;
}
break;
case EF_GR16F:
if (glloader_GL_VERSION_3_0() || glloader_GL_ARB_texture_rg())
{
internalFormat = GL_RG16F;
glformat = GL_RG;
gltype = GL_HALF_FLOAT_ARB;
}
else
{
internalFormat = GL_LUMINANCE_ALPHA16F_ARB;
glformat = GL_LUMINANCE_ALPHA;
gltype = GL_FLOAT;
}
break;
case EF_B10G11R11F:
if (glloader_GL_VERSION_3_0() || glloader_GL_EXT_packed_float())
{
internalFormat = GL_R11F_G11F_B10F;
glformat = GL_RGB;
gltype = GL_UNSIGNED_INT_10F_11F_11F_REV;
}
else
{
THR(errc::function_not_supported);
}
break;
case EF_BGR16F:
internalFormat = GL_RGB16F_ARB;
glformat = GL_RGB;
gltype = GL_HALF_FLOAT_ARB;
break;
case EF_ABGR16F:
internalFormat = GL_RGBA16F_ARB;
glformat = GL_RGBA;
gltype = GL_HALF_FLOAT_ARB;
break;
case EF_R32F:
if (glloader_GL_VERSION_3_0() || glloader_GL_ARB_texture_rg())
{
internalFormat = GL_R32F;
glformat = GL_RED;
gltype = GL_FLOAT;
}
else
{
internalFormat = GL_LUMINANCE32F_ARB;
glformat = GL_LUMINANCE;
gltype = GL_FLOAT;
}
break;
case EF_GR32F:
if (glloader_GL_VERSION_3_0() || glloader_GL_ARB_texture_rg())
{
internalFormat = GL_RG32F;
glformat = GL_RG;
gltype = GL_FLOAT;
}
else
{
internalFormat = GL_LUMINANCE_ALPHA32F_ARB;
glformat = GL_LUMINANCE_ALPHA;
gltype = GL_FLOAT;
}
break;
case EF_BGR32F:
internalFormat = GL_RGB32F_ARB;
glformat = GL_RGB;
gltype = GL_FLOAT;
break;
case EF_ABGR32F:
internalFormat = GL_RGBA32F_ARB;
glformat = GL_RGBA;
gltype = GL_FLOAT;
break;
case EF_BC1:
if (glloader_GL_EXT_texture_compression_s3tc())
{
internalFormat = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
glformat = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
gltype = GL_UNSIGNED_BYTE;
}
else
{
THR(errc::function_not_supported);
}
break;
case EF_BC2:
if (glloader_GL_EXT_texture_compression_s3tc())
{
internalFormat = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
glformat = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
gltype = GL_UNSIGNED_BYTE;
}
else
{
THR(errc::function_not_supported);
}
break;
case EF_BC3:
if (glloader_GL_EXT_texture_compression_s3tc())
{
internalFormat = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
glformat = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
gltype = GL_UNSIGNED_BYTE;
}
else
{
THR(errc::function_not_supported);
}
break;
case EF_BC4:
if (glloader_GL_VERSION_3_0() || glloader_GL_ARB_texture_compression_rgtc())
{
internalFormat = GL_COMPRESSED_RED_RGTC1;
glformat = GL_COMPRESSED_LUMINANCE;
gltype = GL_UNSIGNED_BYTE;
}
else
{
THR(errc::function_not_supported);
}
break;
case EF_BC5:
if (glloader_GL_VERSION_3_0() || glloader_GL_ARB_texture_compression_rgtc())
{
internalFormat = GL_COMPRESSED_RG_RGTC2;
glformat = GL_COMPRESSED_LUMINANCE_ALPHA;
gltype = GL_UNSIGNED_BYTE;
}
else
{
THR(errc::function_not_supported);
}
break;
case EF_SIGNED_BC4:
if (glloader_GL_VERSION_3_0() || glloader_GL_ARB_texture_compression_rgtc())
{
internalFormat = GL_COMPRESSED_SIGNED_RED_RGTC1;
glformat = GL_COMPRESSED_LUMINANCE;
gltype = GL_UNSIGNED_BYTE;
}
else
{
THR(errc::function_not_supported);
}
break;
case EF_SIGNED_BC5:
if (glloader_GL_VERSION_3_0() || glloader_GL_ARB_texture_compression_rgtc())
{
internalFormat = GL_COMPRESSED_SIGNED_RG_RGTC2;
glformat = GL_COMPRESSED_LUMINANCE_ALPHA;
gltype = GL_UNSIGNED_BYTE;
}
else
{
THR(errc::function_not_supported);
}
break;
case EF_D16:
internalFormat = GL_DEPTH_COMPONENT16;
glformat = GL_DEPTH_COMPONENT;
gltype = GL_UNSIGNED_SHORT;
break;
case EF_D24S8:
if (glloader_GL_VERSION_3_0())
{
internalFormat = GL_DEPTH24_STENCIL8;
glformat = GL_DEPTH_STENCIL;
gltype = GL_UNSIGNED_INT_24_8;
}
else if (glloader_GL_EXT_packed_depth_stencil())
{
internalFormat = GL_DEPTH24_STENCIL8_EXT;
glformat = GL_DEPTH_STENCIL_EXT;
gltype = GL_UNSIGNED_INT_24_8_EXT;
}
else
{
THR(errc::function_not_supported);
}
break;
case EF_D32F:
internalFormat = GL_DEPTH_COMPONENT32F;
glformat = GL_DEPTH_COMPONENT;
gltype = GL_FLOAT;
break;
case EF_ARGB8_SRGB:
internalFormat = GL_SRGB8_ALPHA8;
glformat = GL_BGRA;
gltype = GL_UNSIGNED_INT_8_8_8_8_REV;
break;
case EF_ABGR8_SRGB:
internalFormat = GL_SRGB8_ALPHA8;
glformat = GL_RGBA;
gltype = GL_UNSIGNED_BYTE;
break;
case EF_BC1_SRGB:
internalFormat = GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT;
glformat = GL_BGRA;
gltype = GL_UNSIGNED_BYTE;
break;
case EF_BC2_SRGB:
internalFormat = GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT;
glformat = GL_BGRA;
gltype = GL_UNSIGNED_BYTE;
break;
case EF_BC3_SRGB:
internalFormat = GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT;
glformat = GL_BGRA;
gltype = GL_UNSIGNED_BYTE;
break;
case EF_BC4_SRGB:
internalFormat = GL_COMPRESSED_SLUMINANCE;
glformat = GL_LUMINANCE;
gltype = GL_UNSIGNED_BYTE;
break;
case EF_BC5_SRGB:
internalFormat = GL_COMPRESSED_SLUMINANCE_ALPHA;
glformat = GL_LUMINANCE_ALPHA;
gltype = GL_UNSIGNED_BYTE;
break;
default:
THR(errc::function_not_supported);
}
}
void FrameBuffer::Attach(uint32_t att, RenderViewPtr const & view)
{
switch (att)
{
case ATT_DepthStencil:
{
if (rs_view_)
{
this->Detach(att);
}
rs_view_ = view;
}
break;
default:
{
BOOST_ASSERT(att >= ATT_Color0);
RenderEngine& re = Context::Instance().RenderFactoryInstance().RenderEngineInstance();
if (att >= static_cast<uint32_t>(ATT_Color0 + re.DeviceCaps().max_simultaneous_rts))
{
THR(errc::function_not_supported);
}
uint32_t clr_id = att - ATT_Color0;
if ((clr_id < clr_views_.size()) && clr_views_[clr_id])
{
this->Detach(att);
}
if (clr_views_.size() < clr_id + 1)
{
clr_views_.resize(clr_id + 1);
}
clr_views_[clr_id] = view;
size_t min_clr_index = clr_id;
for (size_t i = 0; i < clr_id; ++ i)
{
if (clr_views_[i])
{
min_clr_index = i;
}
}
if (min_clr_index == clr_id)
{
width_ = view->Width();
height_ = view->Height();
viewport_->left = 0;
viewport_->top = 0;
viewport_->width = width_;
viewport_->height = height_;
}
}
break;
}
view->OnAttached(*this, att);
views_dirty_ = true;
}
void MsgInputEngine::EnumDevices()
{
WindowPtr const & main_wnd = Context::Instance().AppInstance().MainWnd();
#if defined KLAYGE_PLATFORM_WINDOWS_DESKTOP
HWND hwnd = main_wnd->HWnd();
UINT devices = 0;
if (::GetRawInputDeviceList(nullptr, &devices, sizeof(RAWINPUTDEVICELIST)) != 0)
{
THR(errc::function_not_supported);
}
std::vector<RAWINPUTDEVICELIST> raw_input_devices(devices);
::GetRawInputDeviceList(&raw_input_devices[0], &devices, sizeof(raw_input_devices[0]));
RAWINPUTDEVICE rid;
rid.usUsagePage = HID_USAGE_PAGE_GENERIC;
rid.hwndTarget = hwnd;
std::vector<RAWINPUTDEVICE> rids;
for (size_t i = 0; i < raw_input_devices.size(); ++ i)
{
InputDevicePtr device;
switch (raw_input_devices[i].dwType)
{
case RIM_TYPEKEYBOARD:
device = MakeSharedPtr<MsgInputKeyboard>();
rid.usUsage = HID_USAGE_GENERIC_KEYBOARD;
rid.dwFlags = 0;
rids.push_back(rid);
break;
case RIM_TYPEMOUSE:
device = MakeSharedPtr<MsgInputMouse>(hwnd, raw_input_devices[i].hDevice);
rid.usUsage = HID_USAGE_GENERIC_MOUSE;
rid.dwFlags = 0;
rids.push_back(rid);
break;
case RIM_TYPEHID:
{
UINT size = 0;
if (0 == ::GetRawInputDeviceInfo(raw_input_devices[i].hDevice, RIDI_DEVICEINFO, nullptr, &size))
{
std::vector<uint8_t> buf(size);
::GetRawInputDeviceInfo(raw_input_devices[i].hDevice, RIDI_DEVICEINFO, &buf[0], &size);
RID_DEVICE_INFO* info = reinterpret_cast<RID_DEVICE_INFO*>(&buf[0]);
if ((HID_USAGE_PAGE_GENERIC == info->hid.usUsagePage)
&& ((HID_USAGE_GENERIC_GAMEPAD == info->hid.usUsage)
|| (HID_USAGE_GENERIC_JOYSTICK == info->hid.usUsage)))
{
device = MakeSharedPtr<MsgInputJoystick>(raw_input_devices[i].hDevice);
rid.usUsage = HID_USAGE_GENERIC_GAMEPAD;
rid.dwFlags = RIDEV_INPUTSINK;
rids.push_back(rid);
rid.usUsage = HID_USAGE_GENERIC_JOYSTICK;
rid.dwFlags = RIDEV_INPUTSINK;
rids.push_back(rid);
}
}
}
break;
default:
break;
}
if (device)
{
devices_.push_back(device);
}
}
if (::RegisterRawInputDevices(&rids[0], static_cast<UINT>(rids.size()), sizeof(rids[0])))
{
on_raw_input_ = main_wnd->OnRawInput().connect(bind(&MsgInputEngine::OnRawInput, this,
std::placeholders::_1, std::placeholders::_2));
}
#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8)
on_pointer_down_ = main_wnd->OnPointerDown().connect(std::bind(&MsgInputEngine::OnPointerDown, this,
std::placeholders::_2, std::placeholders::_3));
on_pointer_up_ = main_wnd->OnPointerUp().connect(std::bind(&MsgInputEngine::OnPointerUp, this,
std::placeholders::_2, std::placeholders::_3));
on_pointer_update_ = main_wnd->OnPointerUpdate().connect(std::bind(&MsgInputEngine::OnPointerUpdate, this,
std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
on_pointer_wheel_ = main_wnd->OnPointerWheel().connect(std::bind(&MsgInputEngine::OnPointerWheel, this,
std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
devices_.push_back(MakeSharedPtr<MsgInputTouch>());
#elif (_WIN32_WINNT >= _WIN32_WINNT_WIN7)
if (::GetSystemMetrics(SM_DIGITIZER) & NID_READY)
{
if (this->RegisterTouchWindow(hwnd, TWF_WANTPALM))
{
on_touch_ = main_wnd->OnTouch().connect(std::bind(&MsgInputEngine::OnTouch, this,
std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
devices_.push_back(MakeSharedPtr<MsgInputTouch>());
}
}
#endif
#elif (defined KLAYGE_PLATFORM_WINDOWS_RUNTIME) || (defined KLAYGE_PLATFORM_ANDROID) || (defined KLAYGE_PLATFORM_DARWIN) || (defined KLAYGE_PLATFORM_IOS)
on_pointer_down_ = main_wnd->OnPointerDown().connect(std::bind(&MsgInputEngine::OnPointerDown, this,
std::placeholders::_2, std::placeholders::_3));
on_pointer_up_ = main_wnd->OnPointerUp().connect(std::bind(&MsgInputEngine::OnPointerUp, this,
std::placeholders::_2, std::placeholders::_3));
on_pointer_update_ = main_wnd->OnPointerUpdate().connect(std::bind(&MsgInputEngine::OnPointerUpdate, this,
std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
on_pointer_wheel_ = main_wnd->OnPointerWheel().connect(std::bind(&MsgInputEngine::OnPointerWheel, this,
std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
devices_.push_back(MakeSharedPtr<MsgInputTouch>());
#if defined KLAYGE_PLATFORM_ANDROID
on_key_down_ = main_wnd->OnKeyDown().connect(std::bind(&MsgInputEngine::OnKeyDown, this,
std::placeholders::_2));
on_key_up_ = main_wnd->OnKeyUp().connect(std::bind(&MsgInputEngine::OnKeyUp, this,
std::placeholders::_2));
devices_.push_back(MakeSharedPtr<MsgInputKeyboard>());
on_mouse_down_ = main_wnd->OnMouseDown().connect(std::bind(&MsgInputEngine::OnMouseDown, this,
std::placeholders::_2, std::placeholders::_3));
on_mouse_up_ = main_wnd->OnMouseUp().connect(std::bind(&MsgInputEngine::OnMouseUp, this,
std::placeholders::_2, std::placeholders::_3));
on_mouse_move_ = main_wnd->OnMouseMove().connect(std::bind(&MsgInputEngine::OnMouseMove, this,
std::placeholders::_2));
on_mouse_wheel_ = main_wnd->OnMouseWheel().connect(std::bind(&MsgInputEngine::OnMouseWheel, this,
std::placeholders::_2, std::placeholders::_3));
devices_.push_back(MakeSharedPtr<MsgInputMouse>());
on_joystick_axis_ = main_wnd->OnJoystickAxis().connect(std::bind(&MsgInputEngine::OnJoystickAxis, this,
std::placeholders::_2, std::placeholders::_3));
on_joystick_buttons_ = main_wnd->OnJoystickButtons().connect(std::bind(&MsgInputEngine::OnJoystickButtons, this,
std::placeholders::_2));
devices_.push_back(MakeSharedPtr<MsgInputJoystick>());
#elif defined KLAYGE_PLATFORM_DARWIN
on_key_down_ = main_wnd->OnKeyDown().connect(std::bind(&MsgInputEngine::OnKeyDown, this,
std::placeholders::_2));
on_key_up_ = main_wnd->OnKeyUp().connect(std::bind(&MsgInputEngine::OnKeyUp, this,
std::placeholders::_2));
devices_.push_back(MakeSharedPtr<MsgInputKeyboard>());
#endif
#endif
#if (defined KLAYGE_PLATFORM_WINDOWS_DESKTOP) && (defined KLAYGE_HAVE_LIBOVR)
OVR::System::Init(OVR::Log::ConfigureDefaultLog(OVR::LogMask_All));
devices_.push_back(MakeSharedPtr<MsgInputOVR>());
#endif
#if ((defined KLAYGE_PLATFORM_WINDOWS_DESKTOP) && (_WIN32_WINNT >= _WIN32_WINNT_WIN7) && (_WIN32_WINNT < _WIN32_WINNT_WIN10)) \
|| (defined KLAYGE_PLATFORM_WINDOWS_RUNTIME) || (defined KLAYGE_PLATFORM_ANDROID)
devices_.push_back(MakeSharedPtr<MsgInputSensor>());
#endif
}
OGLESTexture3D::OGLESTexture3D(uint32_t width, uint32_t height, uint32_t depth, uint32_t numMipMaps, uint32_t array_size, ElementFormat format,
uint32_t sample_count, uint32_t sample_quality, uint32_t access_hint)
: OGLESTexture(TT_3D, array_size, sample_count, sample_quality, access_hint)
{
if (!glloader_GLES_VERSION_3_0() && !glloader_GLES_OES_texture_3D())
{
THR(errc::function_not_supported);
}
if (IsSRGB(format))
{
format = this->SRGBToRGB(format);
}
format_ = format;
if (0 == numMipMaps)
{
num_mip_maps_ = 1;
uint32_t w = width;
uint32_t h = height;
uint32_t d = depth;
while ((w > 1) && (h > 1) && (d > 1))
{
++ num_mip_maps_;
w = std::max<uint32_t>(1U, w / 2);
h = std::max<uint32_t>(1U, h / 2);
d = std::max<uint32_t>(1U, d / 2);
}
}
else
{
num_mip_maps_ = numMipMaps;
}
array_size_ = 1;
width_ = width;
height_ = height;
depth_ = depth;
tex_data_.resize(num_mip_maps_);
glBindTexture(target_type_, texture_);
if (glloader_GLES_VERSION_3_0())
{
glTexParameteri(target_type_, GL_TEXTURE_BASE_LEVEL, 0);
glTexParameteri(target_type_, GL_TEXTURE_MAX_LEVEL, num_mip_maps_ - 1);
}
else if (glloader_GLES_APPLE_texture_max_level())
{
glTexParameteri(target_type_, GL_TEXTURE_MAX_LEVEL_APPLE, num_mip_maps_ - 1);
}
else
{
OGLESRenderEngine& re = *checked_cast<OGLESRenderEngine*>(&Context::Instance().RenderFactoryInstance().RenderEngineInstance());
if (re.HackForTegra())
{
glTexParameteri(target_type_, GL_TEXTURE_MAX_LEVEL, num_mip_maps_ - 1);
}
}
}
