JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_WGLNVDXInterop_nwglDXUnlockObjectsNV(JNIEnv *__env, jclass clazz, jlong deviceAddress, jint count, jlong objectsAddress, jlong __functionAddress) {
HANDLE device = (HANDLE)(intptr_t)deviceAddress;
HANDLE *objects = (HANDLE *)(intptr_t)objectsAddress;
wglDXUnlockObjectsNVPROC wglDXUnlockObjectsNV = (wglDXUnlockObjectsNVPROC)(intptr_t)__functionAddress;
UNUSED_PARAMS(__env, clazz)
return (jint)wglDXUnlockObjectsNV(device, count, objects);
}
void D3DPresentEngine::releaseSharedTexture()
{
if (!gl_handleD3D) return;
wglDXUnlockObjectsNV(gl_handleD3D, 1, &gl_handle);
wglDXUnregisterObjectNV(gl_handleD3D,gl_handle);
//glDeleteTextures(1, &gl_name);
SAFE_RELEASE(d3d_shared_surface);
SAFE_RELEASE(d3d_shared_texture);
}
//
// Must return S_OK (0) - otherwise the error can be checked.
//
HRESULT spoutGLDXinterop::UnlockInteropObject(HANDLE hDevice, HANDLE *hObject)
{
DWORD dwError;
HRESULT hr;
if(hDevice == NULL || hObject == NULL || *hObject == NULL) {
return E_HANDLE;
}
if (wglDXUnlockObjectsNV(hDevice, 1, hObject) == TRUE) {
return S_OK;
}
else {
dwError = GetLastError();
switch (dwError) {
case ERROR_NOT_LOCKED :
hr = E_ACCESSDENIED;
// printf(" spoutGLDXinterop::UnLockInteropObject ERROR_NOT_LOCKED\n");
break;
case ERROR_INVALID_DATA :
// printf(" spoutGLDXinterop::UnLockInteropObject ERROR_INVALID_DATA\n");
hr = E_ABORT;
break;
case ERROR_LOCK_FAILED :
hr = E_ABORT;
// printf(" spoutGLDXinterop::UnLockInteropObject ERROR_LOCK_FAILED\n");
break;
default:
hr = E_FAIL;
// printf(" spoutGLDXinterop::UnLockInteropObject UNKNOWN_ERROR\n");
break;
} // end switch
} // end fail
return hr;
} // end UnlockInteropObject
bool RenderManagerD3D11OpenGL::PresentEye(PresentEyeParameters params) {
if (params.m_buffer.OpenGL == nullptr) {
std::cerr
<< "RenderManagerD3D11OpenGL::PresentEye(): NULL buffer pointer"
<< std::endl;
return false;
}
// Verify that we have registered this buffer.
OglToD3DTexture* oglMap = nullptr;
for (size_t i = 0; i < m_oglToD3D.size(); i++) {
if (m_oglToD3D[i].OpenGLTexture ==
params.m_buffer.OpenGL->colorBufferName) {
oglMap = &m_oglToD3D[i];
}
}
if (oglMap == nullptr) {
std::cerr
<< "RenderManagerD3D11OpenGL::PresentEye(): Unregistered buffer"
<< " (call RegisterRenderBuffers before presenting)"
<< std::endl;
return false;
}
if (params.m_buffer.OpenGL->colorBufferName != oglMap->OpenGLTexture) {
std::cerr
<< "RenderManagerD3D11OpenGL::PresentEye(): Mis-matched buffer"
<< " (call RegisterRenderBuffers whenever a new render-texture "
"is created)"
<< std::endl;
return false;
}
// Create a new param buffer and fill in the new D3D buffer pointer
// along with our current info. Invert the flip-buffer flag, because
// we need to render upside-down. Rotate around the negative Z axis
// rather than the positive. Then call the D3D PresentEye method
// and clean up after ourselves.
PresentEyeParameters sendParams = params;
sendParams.m_flipInY = !sendParams.m_flipInY;
sendParams.m_buffer.OpenGL = nullptr;
sendParams.m_buffer.D3D11 = new RenderBufferD3D11;
sendParams.m_buffer.D3D11->colorBuffer = oglMap->D3DTexture;
sendParams.m_buffer.D3D11->colorBufferView =
oglMap->D3DrenderTargetView;
// Transpose the texture matrix because we're feeding it to Direct3D,
// which stores matrix elements in a different order. We're sending
// it our OpenGL transforms because we used OpenGL to render the two
// images, so that's what the texture matrix needs to assume.
matrix16 textureMat;
if (params.m_ATW != nullptr) {
// Transpose the matrix, because it is in OpenGL format.
for (size_t r = 0; r < 4; r++) {
for (size_t c = 0; c < 4; c++) {
textureMat.data[r * 4 + c] = params.m_ATW->data[c * 4 + r];
}
}
sendParams.m_ATW = &textureMat;
}
// Unlock the render target to enable Direct3D access
if (!wglDXUnlockObjectsNV(m_glD3DHandle, 1, &oglMap->glColorHandle)) {
std::cerr << "RenderManagerD3D11OpenGL::PresentEye: Can't unlock "
"Color buffer"
<< std::endl;
return false;
}
// Render the the eye with the relevant texture.
bool ret = m_D3D11Renderer->PresentEye(sendParams);
// Lock the render target for OpenGL access
if (!wglDXLockObjectsNV(m_glD3DHandle, 1, &oglMap->glColorHandle)) {
std::cerr << "RenderManagerD3D11OpenGL::PresentEye: Can't lock "
"Color buffer"
<< std::endl;
return false;
}
delete sendParams.m_buffer.D3D11;
return ret;
}
bool D3DPresentEngine::unlockSharedTexture()
{
if (!gl_handleD3D) return false;
if (!gl_handle) return false;
return wglDXUnlockObjectsNV(gl_handleD3D, 1, &gl_handle);
}
