void GL1TextureProvider::copy_image_from(
int x,
int y,
int width,
int height,
int level,
TextureFormat texture_format,
GraphicContextProvider *gc)
{
throw_if_disposed();
OpenGL::set_active(static_cast<GL1GraphicContextProvider*>(gc));
GL1TextureStateTracker state_tracker(texture_type, handle);
GLint gl_internal_format;
GLenum gl_pixel_format;
to_opengl_textureformat(texture_format, gl_internal_format, gl_pixel_format);
glCopyTexImage2D(
GL_TEXTURE_2D,
level,
gl_internal_format,
x, y,
width, height,
0);
}
void GL3ProgramObjectProvider::set_storage_buffer_index(int buffer_index, int bind_unit_index)
{
throw_if_disposed();
if (buffer_index == -1 )
return;
glShaderStorageBlockBinding(handle, buffer_index, bind_unit_index);
}
void GL1TextureProvider::set_texture_compare(TextureCompareMode mode, CompareFunction func)
{
throw_if_disposed();
GL1TextureStateTracker state_tracker(texture_type, handle);
glTexParameteri(texture_type, GL_TEXTURE_COMPARE_MODE, OpenGL::to_enum(mode));
glTexParameteri(texture_type, GL_TEXTURE_COMPARE_FUNC, OpenGL::to_enum(func));
}
void GL1TextureProvider::set_wrap_mode(
TextureWrapMode wrap_s)
{
throw_if_disposed();
GL1TextureStateTracker state_tracker(texture_type, handle);
glTexParameteri(texture_type, GL_TEXTURE_WRAP_S, OpenGL::to_enum(wrap_s));
}
void CL_OpenGLProgramObjectProvider::attach(const CL_ShaderObject &obj)
{
throw_if_disposed();
shaders.push_back(obj);
CL_OpenGL::set_active();
glAttachShader(handle, (GLuint) obj.get_handle());
}
bool CL_InputDeviceProvider_DirectInput::poll(bool peek_only)
{
throw_if_disposed();
// peek_only is not supported, as WM_INPUT is used as the event trigger
update();
return false;
}
void GL3ProgramObjectProvider::set_uniform_buffer_index(int block_index, int bind_index)
{
throw_if_disposed();
if (block_index == -1 )
return;
glUniformBlockBinding(handle, block_index, bind_index);
}
PixelBuffer GL1TextureProvider::get_pixeldata(GraphicContext &gc, TextureFormat texture_format, int level) const
{
throw_if_disposed();
OpenGL::set_active(gc);
GL1TextureStateTracker state_tracker(texture_type, handle);
GLenum gl_format = 0, gl_type = 0;
bool supported = to_opengl_pixelformat(texture_format, gl_format, gl_type);
if (supported)
{
PixelBuffer buffer(pot_width, pot_height, texture_format);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
#ifndef __ANDROID__
glPixelStorei(GL_UNPACK_ROW_LENGTH, buffer.get_pitch() / buffer.get_bytes_per_pixel());
glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
#endif
glGetTexImage(texture_type, level, gl_format, gl_type, buffer.get_data());
return buffer.copy(Rect(0,0, width, height));
}
else
{
PixelBuffer buffer(pot_width, pot_height, tf_rgba8);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
#ifndef __ANDROID__
glPixelStorei(GL_UNPACK_ROW_LENGTH, buffer.get_pitch() / buffer.get_bytes_per_pixel());
glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
#endif
glGetTexImage(texture_type, level, GL_RGBA, GL_UNSIGNED_BYTE, buffer.get_data());
return buffer.copy(Rect(0,0, width, height)).to_format(texture_format);
}
}
void InputContext_Impl::add_tablet(InputDevice &tablet)
{
throw_if_disposed();
std::unique_lock<std::recursive_mutex> mutex_lock(mutex);
tablets.push_back(tablet);
tablet.impl->input_contexts.push_back(input_context);
}
void InputContext_Impl::add_joystick(InputDevice &joystick)
{
throw_if_disposed();
std::unique_lock<std::recursive_mutex> mutex_lock(mutex);
joysticks.push_back(joystick);
joystick.impl->input_contexts.push_back(input_context);
}
void InputContext_Impl::add_mouse(InputDevice &mouse)
{
throw_if_disposed();
std::unique_lock<std::recursive_mutex> mutex_lock(mutex);
mice.push_back(mouse);
mouse.impl->input_contexts.push_back(input_context);
}
bool CL_OpenGLProgramObjectProvider::get_validate_status() const
{
throw_if_disposed();
CL_OpenGL::set_active();
GLint status = 0;
glGetProgramiv(handle, GL_VALIDATE_STATUS, &status);
return (status != GL_FALSE);
}
std::vector<CL_ProgramUniform> CL_OpenGLProgramObjectProvider::get_uniforms() const
{
throw_if_disposed();
if (cached_uniforms.empty())
fetch_uniforms();
return cached_uniforms;
}
int CL_OpenGLProgramObjectProvider::get_uniform_count() const
{
throw_if_disposed();
if (cached_uniforms.empty())
fetch_uniforms();
return (int)cached_uniforms.size();
}
std::vector<CL_ProgramAttribute> CL_OpenGLProgramObjectProvider::get_attributes() const
{
throw_if_disposed();
if (cached_attribs.empty())
fetch_attributes();
return cached_attribs;
}
int CL_OpenGLProgramObjectProvider::get_attribute_count() const
{
throw_if_disposed();
if (cached_attribs.empty())
fetch_attributes();
return (int)cached_attribs.size();
}
void InputContext_Impl::add_keyboard(InputDevice &keyboard)
{
throw_if_disposed();
std::unique_lock<std::recursive_mutex> mutex_lock(mutex);
keyboards.push_back(keyboard);
keyboard.impl->input_contexts.push_back(input_context);
}
bool GL3ProgramObjectProvider::get_link_status() const
{
throw_if_disposed();
OpenGL::set_active();
GLint status = 0;
glGetProgramiv(handle, GL_LINK_STATUS, &status);
return (status != GL_FALSE);
}
void GL3ProgramObjectProvider::set_uniform3i(int location, int v1, int v2, int v3)
{
throw_if_disposed();
if (location >= 0)
{
ProgramObjectStateTracker state_tracker(handle);
glUniform3i(location, v1, v2, v3);
}
}
void GL3ProgramObjectProvider::set_uniform4f(int location, float v1, float v2, float v3, float v4)
{
throw_if_disposed();
if (location >= 0)
{
ProgramObjectStateTracker state_tracker(handle);
glUniform4f(location, v1, v2, v3, v4);
}
}
CL_String CL_InputDeviceProvider_Win32Keyboard::get_key_name(int virtual_key) const
{
throw_if_disposed();
TCHAR name[1024];
UINT scancode = MapVirtualKey(virtual_key, 0);
int length = GetKeyNameText(scancode << 16, name, 1024);
return CL_String(name, length);
}
void InputContext_Impl::clear()
{
throw_if_disposed();
keyboards.clear();
mice.clear();
joysticks.clear();
tablets.clear();
}
void CL_OpenGLProgramObjectProvider::link()
{
throw_if_disposed();
CL_OpenGL::set_active();
glLinkProgram(handle);
cached_attribs.clear();
cached_uniforms.clear();
}
void CL_OpenGLProgramObjectProvider::set_uniform1i(const CL_StringRef &name, int p1)
{
throw_if_disposed();
CL_ProgramObjectStateTracker state_tracker(handle);
int loc = get_uniform_location(name);
if (loc == -1)
return;
glUniform1i(loc, p1);
}
bool CL_InputDeviceProvider_Win32Keyboard::get_keycode(int keycode) const
{
throw_if_disposed();
// Ignore all key events when we don't have focus
if (!window->has_focus())
return false;
return (GetKeyState(keycode) & 0xfe) != 0;
}
int GL3ProgramObjectProvider::get_storage_buffer_index(const std::string &name) const
{
throw_if_disposed();
OpenGL::set_active();
if (!glGetProgramResourceIndex)
throw Exception("incorrect OpenGL version");
return glGetProgramResourceIndex(handle, GL_SHADER_STORAGE_BLOCK, name.c_str());
}
int GL3ProgramObjectProvider::get_uniform_buffer_index(const std::string &block_name) const
{
throw_if_disposed();
OpenGL::set_active();
if (!glGetUniformBlockIndex)
throw Exception("incorrect OpenGL version");
return glGetUniformBlockIndex(handle, StringHelp::text_to_local8(block_name).c_str());
}
void GL3ProgramObjectProvider::set_uniform_matrix(int location, int size, int count, bool transpose, const float *data)
{
throw_if_disposed();
if (location >= 0)
{
ProgramObjectStateTracker state_tracker(handle);
if( size == 2 ) glUniformMatrix2fv(location, count, transpose, data);
else if( size == 3 ) glUniformMatrix3fv(location, count, transpose, data);
else if( size == 4 ) glUniformMatrix4fv(location, count, transpose, data);
}
}
bool CL_InputDeviceProvider_DirectInput::get_keycode(int keycode) const
{
throw_if_disposed();
if (keycode < 0 || keycode >= 128) return false;
DIJOYSTATE2 joystate2;
HRESULT result = directinput_device->GetDeviceState(sizeof(DIJOYSTATE2), &joystate2);
if (FAILED(result)) return false;
return LOBYTE(joystate2.rgbButtons[keycode]) != 0;
}
int CL_InputDeviceProvider_DirectInput::get_button_count() const
{
throw_if_disposed();
int count=0;
for ( int x = 0; x < 32; x++ )
{
count += check_axis(DIJOFS_BUTTON( x ));
}
return count;
}
