XnStatus XnSensorDepthStream::ConfigureStreamImpl()
{
XnStatus nRetVal = XN_STATUS_OK;
xnUSBShutdownReadThread(GetHelper()->GetPrivateData()->pSpecificDepthUsb->pUsbConnection->UsbEp);
nRetVal = SetActualRead(TRUE);
XN_IS_STATUS_OK(nRetVal);
XN_IS_STATUS_OK(m_Helper.ConfigureFirmware(m_InputFormat));
XN_IS_STATUS_OK(m_Helper.ConfigureFirmware(ResolutionProperty()));
XN_IS_STATUS_OK(m_Helper.ConfigureFirmware(FPSProperty()));
XN_IS_STATUS_OK(m_Helper.ConfigureFirmware(m_HoleFilter));
XN_IS_STATUS_OK(m_Helper.ConfigureFirmware(m_Gain));
// we need to turn decimation on when resolution is QVGA, and FPS is different than 60
// NOTE: this is ugly as hell. This logic should be moved to firmware.
XnBool bDecimation = (GetResolution() == XN_RESOLUTION_QVGA && GetFPS() != 60);
nRetVal = GetFirmwareParams()->m_DepthDecimation.SetValue(bDecimation);
XN_IS_STATUS_OK(nRetVal);
XN_IS_STATUS_OK(m_Helper.ConfigureFirmware(m_FirmwareRegistration));
XN_IS_STATUS_OK(m_Helper.ConfigureFirmware(m_FirmwareMirror));
XN_IS_STATUS_OK(m_Helper.ConfigureFirmware(m_GMCMode));
XN_IS_STATUS_OK(m_Helper.ConfigureFirmware(m_WhiteBalance));
nRetVal = m_Helper.GetCmosInfo()->SetCmosConfig(XN_CMOS_TYPE_DEPTH, GetResolution(), GetFPS());
XN_IS_STATUS_OK(nRetVal);
return XN_STATUS_OK;
}
void ezRendererTestBasics::RenderObjects(ezBitflags<ezShaderBindFlags> ShaderBindFlags)
{
ezCamera cam;
cam.SetCameraMode(ezCameraMode::PerspectiveFixedFovX, 90, 0.5f, 1000.0f);
cam.LookAt(ezVec3(0, 0, 0), ezVec3(0, 0, -1), ezVec3(0, 1, 0));
ezMat4 mProj;
cam.GetProjectionMatrix((float)GetResolution().width / (float)GetResolution().height, mProj);
ezMat4 mView = cam.GetViewMatrix();
ezMat4 mTransform, mOther, mRot;
mRot.SetRotationMatrixX(ezAngle::Degree(-90));
mOther.SetScalingMatrix(ezVec3(1.0f, 1.0f, 1.0f));
mTransform.SetTranslationMatrix(ezVec3(-0.3f, -0.3f, 0.0f));
RenderObject(m_hLongBox, mProj * mView * mTransform * mOther, ezColor(1, 0, 1, 0.25f), ShaderBindFlags);
mOther.SetRotationMatrixX(ezAngle::Degree(80.0f));
mTransform.SetTranslationMatrix(ezVec3(0.75f, 0, -1.8f));
RenderObject(m_hTorus, mProj * mView * mTransform * mOther * mRot, ezColor(1, 0, 0, 0.5f), ShaderBindFlags);
mOther.SetIdentity();
mTransform.SetTranslationMatrix(ezVec3(0, 0.1f, -2.0f));
RenderObject(m_hSphere, mProj * mView * mTransform * mOther, ezColor(0, 1, 0, 0.75f), ShaderBindFlags);
mOther.SetScalingMatrix(ezVec3(1.5f, 1.0f, 1.0f));
mTransform.SetTranslationMatrix(ezVec3(-0.6f, -0.2f, -2.2f));
RenderObject(m_hSphere2, mProj * mView * mTransform * mOther * mRot, ezColor(0, 0, 1, 1), ShaderBindFlags);
}
XnStatus XnSensorImageStream::ConfigureStreamImpl()
{
XnStatus nRetVal = XN_STATUS_OK;
xnUSBShutdownReadThread(GetHelper()->GetPrivateData()->pSpecificImageUsb->pUsbConnection->UsbEp);
nRetVal = SetActualRead(TRUE);
XN_IS_STATUS_OK(nRetVal);
nRetVal = ValidateMode();
XN_IS_STATUS_OK(nRetVal);
XN_IS_STATUS_OK(m_Helper.ConfigureFirmware(m_InputFormat));
XN_IS_STATUS_OK(m_Helper.ConfigureFirmware(ResolutionProperty()));
XN_IS_STATUS_OK(m_Helper.ConfigureFirmware(FPSProperty()));
XN_IS_STATUS_OK(m_Helper.ConfigureFirmware(m_AntiFlicker));
// image quality is only relevant for JPEG
if (m_InputFormat.GetValue() == XN_IO_IMAGE_FORMAT_JPEG)
{
XN_IS_STATUS_OK(m_Helper.ConfigureFirmware(m_ImageQuality));
}
XN_IS_STATUS_OK(m_Helper.ConfigureFirmware(m_FirmwareMirror));
if (GetResolution() != XN_RESOLUTION_UXGA && GetResolution() != XN_RESOLUTION_SXGA)
{
nRetVal = m_Helper.GetCmosInfo()->SetCmosConfig(XN_CMOS_TYPE_IMAGE, GetResolution(), GetFPS());
XN_IS_STATUS_OK(nRetVal);
}
return (XN_STATUS_OK);
}
void ImageChunk::ApplyData() {
mImage.create(GetResolution(), GetResolution(), sf::Color::Black);
const size_t ThreadCount = 16;
std::thread ImageThreads[ThreadCount];
int IncrementX = std::ceilf(GetResolution() / ThreadCount);
for (int i = 0; i < ThreadCount; i++) {
size_t MinX = i * IncrementX;
size_t MaxX = (size_t)std::fminf((1 + i) * IncrementX, GetResolution());
size_t MinY = 0;
size_t MaxY = GetResolution();
//ApplyArea(MinX, MinY, MaxX, MaxY);
ImageThreads[i] = std::thread(
ApplyArea,
this,
MinX,
MinY,
MaxX,
MaxY
);
}
for (int i = 0; i < ThreadCount; i++) {
ImageThreads[i].join();
}
mTexture.loadFromImage(mImage);
mDrawRectangle.setTexture(&mTexture, true);
mDrawRectangle.setSize((sf::Vector2f)mTexture.getSize());
mDrawRectangle.setPosition(GetX(), GetY());
mDrawRectangle.setScale(sf::Vector2f(GetSize() / mTexture.getSize().x, GetSize() / mTexture.getSize().y));
}
XnStatus XnSensorIRStream::ConfigureStreamImpl()
{
XnStatus nRetVal = XN_STATUS_OK;
xnUSBShutdownReadThread(GetHelper()->GetPrivateData()->pSpecificImageUsb->pUsbConnection->UsbEp);
nRetVal = SetActualRead(TRUE);
XN_IS_STATUS_OK(nRetVal);
nRetVal = m_Helper.ConfigureFirmware(ResolutionProperty());
XN_IS_STATUS_OK(nRetVal);;
nRetVal = m_Helper.ConfigureFirmware(FPSProperty());
XN_IS_STATUS_OK(nRetVal);;
// IR mirror is always off in firmware
nRetVal = GetFirmwareParams()->m_IRMirror.SetValue(FALSE);
XN_IS_STATUS_OK(nRetVal);
// CMOS
if (GetResolution() != XN_RESOLUTION_SXGA)
{
nRetVal = m_Helper.GetCmosInfo()->SetCmosConfig(XN_CMOS_TYPE_DEPTH, GetResolution(), GetFPS());
XN_IS_STATUS_OK(nRetVal);
}
return (XN_STATUS_OK);
}
XnStatus XnSensorImageStream::ConfigureStreamImpl()
{
XnStatus nRetVal = XN_STATUS_OK;
xnUSBShutdownReadThread(GetHelper()->GetPrivateData()->pSpecificImageUsb->pUsbConnection->UsbEp);
nRetVal = SetActualRead(TRUE);
XN_IS_STATUS_OK(nRetVal);
nRetVal = ValidateMode();
XN_IS_STATUS_OK(nRetVal);
nRetVal = m_Helper.ConfigureFirmware(m_InputFormat);
XN_IS_STATUS_OK(nRetVal);;
nRetVal = m_Helper.ConfigureFirmware(ResolutionProperty());
XN_IS_STATUS_OK(nRetVal);;
nRetVal = m_Helper.ConfigureFirmware(FPSProperty());
XN_IS_STATUS_OK(nRetVal);;
nRetVal = m_Helper.ConfigureFirmware(m_AntiFlicker);
XN_IS_STATUS_OK(nRetVal);;
// image quality is only relevant for JPEG
if (m_InputFormat.GetValue() == XN_IO_IMAGE_FORMAT_JPEG)
{
nRetVal = m_Helper.ConfigureFirmware(m_ImageQuality);
XN_IS_STATUS_OK(nRetVal);;
}
nRetVal = m_Helper.ConfigureFirmware(m_FirmwareMirror);
XN_IS_STATUS_OK(nRetVal);;
if (GetResolution() != XN_RESOLUTION_UXGA && GetResolution() != XN_RESOLUTION_SXGA)
{
nRetVal = m_Helper.GetCmosInfo()->SetCmosConfig(XN_CMOS_TYPE_IMAGE, GetResolution(), GetFPS());
XN_IS_STATUS_OK(nRetVal);
}
if (m_Helper.GetFirmwareVersion() >= XN_SENSOR_FW_VER_5_4)
{
nRetVal = m_Helper.ConfigureFirmware(m_Sharpness);
XN_IS_STATUS_OK(nRetVal);
nRetVal = m_Helper.ConfigureFirmware(m_FirmwareColorTemperature);
XN_IS_STATUS_OK(nRetVal);
nRetVal = m_Helper.ConfigureFirmware(m_FirmwareAutoWhiteBalance);
XN_IS_STATUS_OK(nRetVal);
nRetVal = m_Helper.ConfigureFirmware(m_FirmwareExposure);
XN_IS_STATUS_OK(nRetVal);
nRetVal = m_Helper.ConfigureFirmware(m_FirmwareAutoExposure);
XN_IS_STATUS_OK(nRetVal);
nRetVal = m_Helper.ConfigureFirmware(m_BackLightCompensation);
XN_IS_STATUS_OK(nRetVal);
nRetVal = m_Helper.ConfigureFirmware(m_Gain);
XN_IS_STATUS_OK(nRetVal);
nRetVal = m_Helper.ConfigureFirmware(m_LowLightCompensation);
XN_IS_STATUS_OK(nRetVal);
}
return (XN_STATUS_OK);
}
void OSVRHMDDescription::GetMonitorInfo(IHeadMountedDisplay::MonitorInfo& MonitorDesc) const
{
MonitorDesc.MonitorName = "OSVR-Display"; //@TODO
MonitorDesc.MonitorId = 0; //@TODO
MonitorDesc.DesktopX = GetDisplayOrigin(OSVRHMDDescription::LEFT_EYE).X;
MonitorDesc.DesktopY = GetDisplayOrigin(OSVRHMDDescription::LEFT_EYE).Y;
MonitorDesc.ResolutionX = GetResolution().X;
MonitorDesc.ResolutionY = GetResolution().Y;
}
void CWinsys::Init () {
Uint32 sdl_flags = SDL_INIT_VIDEO | SDL_INIT_NOPARACHUTE | SDL_INIT_TIMER;
if (SDL_Init (sdl_flags) < 0) Message ("Could not initialize SDL");
SDL_GL_SetAttribute(SDL_GL_CONTEXT_EGL, 1);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 1);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);
SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1);
#if defined (USE_STENCIL_BUFFER)
SDL_GL_SetAttribute (SDL_GL_STENCIL_SIZE, 8);
#endif
#ifdef USE_GLES
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
glHint(GL_LINE_SMOOTH_HINT, GL_FASTEST);
#endif
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
SetupVideoMode (GetResolution (param.res_type));
context = SDL_GL_CreateContext(window);
SetOrient(param.orient >= 0 ? param.orient : resolution.width < resolution.height);
Reshape (resolution.width, resolution.height);
//SDL_WM_SetCaption (WINDOW_TITLE, WINDOW_TITLE);
KeyRepeat (false);
if (USE_JOYSTICK) InitJoystick ();
// SDL_EnableUNICODE (1);
}
void CLinuxRenderer::CalcNormalDisplayRect(float fOffsetX1, float fOffsetY1, float fScreenWidth, float fScreenHeight, float fInputFrameRatio, float fZoomAmount)
{
// scale up image as much as possible
// and keep the aspect ratio (introduces with black bars)
// calculate the correct output frame ratio (using the users pixel ratio setting
// and the output pixel ratio setting)
float fOutputFrameRatio = fInputFrameRatio / g_settings.m_ResInfo[GetResolution()].fPixelRatio;
// maximize the movie width
float fNewWidth = fScreenWidth;
float fNewHeight = fNewWidth / fOutputFrameRatio;
if (fNewHeight > fScreenHeight)
{
fNewHeight = fScreenHeight;
fNewWidth = fNewHeight * fOutputFrameRatio;
}
// Scale the movie up by set zoom amount
fNewWidth *= fZoomAmount;
fNewHeight *= fZoomAmount;
// Centre the movie
float fPosY = (fScreenHeight - fNewHeight) / 2;
float fPosX = (fScreenWidth - fNewWidth) / 2;
rd.left = (int)(fPosX + fOffsetX1);
rd.right = (int)(rd.left + fNewWidth + 0.5f);
rd.top = (int)(fPosY + fOffsetY1);
rd.bottom = (int)(rd.top + fNewHeight + 0.5f);
}
inline VoxelGrid::GRID_INDEX GetNextFromGradient(const VoxelGrid::GRID_INDEX& index, const Eigen::Vector3d& gradient) const
{
// Given the gradient, pick the "best fit" of the 26 neighboring points
VoxelGrid::GRID_INDEX next_index = index;
double half_resolution = GetResolution() * 0.5;
if (gradient.x() > half_resolution)
{
next_index.x++;
}
else if (gradient.x() < -half_resolution)
{
next_index.x--;
}
if (gradient.y() > half_resolution)
{
next_index.y++;
}
else if (gradient.y() < -half_resolution)
{
next_index.y--;
}
if (gradient.z() > half_resolution)
{
next_index.z++;
}
else if (gradient.z() < -half_resolution)
{
next_index.z--;
}
return next_index;
}
void
DviDoc::CreateDocument (/*[in]*/ const char * lpszPathName)
{
fileStatus = DVIFILE_NOT_LOADED;
modificationTime = File::GetLastWriteTime(lpszPathName);
MIKTEXMFMODE mfmode;
if (! pSession->GetMETAFONTMode(GetMetafontMode(), &mfmode))
{
UNEXPECTED_CONDITION ("DviDoc::CreateDocument");
}
MIKTEX_ASSERT (pDvi == 0);
pDvi =
Dvi::Create(lpszPathName,
mfmode.szMnemonic,
GetResolution(),
GetShrinkFactor(),
(IsPrintContext()
? DviAccess::Sequential
: DviAccess::Random),
(IsPrintContext()
? DviPageMode::Dvips
: dviPageMode),
pSession->GetPaperSizeInfo(dvipsPaperName.c_str()),
landscape,
this);
pDvi->Scan ();
fileStatus = DVIFILE_LOADED;
}
void CComboRenderer::ManageDisplay()
{
const RECT& rv = g_graphicsContext.GetViewWindow();
float fScreenWidth = (float)rv.right - rv.left;
float fScreenHeight = (float)rv.bottom - rv.top;
float fOffsetX1 = (float)rv.left;
float fOffsetY1 = (float)rv.top;
float fPixelRatio = CDisplaySettings::Get().GetPixelRatio();
float fMaxScreenWidth = (float)CDisplaySettings::Get().GetResolutionInfo(g_graphicsContext.GetVideoResolution()).iWidth;
float fMaxScreenHeight = (float)CDisplaySettings::Get().GetResolutionInfo(g_graphicsContext.GetVideoResolution()).iHeight;
if (fOffsetX1 < 0) fOffsetX1 = 0;
if (fOffsetY1 < 0) fOffsetY1 = 0;
if (fScreenWidth + fOffsetX1 > fMaxScreenWidth) fScreenWidth = fMaxScreenWidth - fOffsetX1;
if (fScreenHeight + fOffsetY1 > fMaxScreenHeight) fScreenHeight = fMaxScreenHeight - fOffsetY1;
// Correct for HDTV_1080i -> 540p
if (GetResolution() == HDTV_1080i)
{
fOffsetY1 /= 2;
fScreenHeight /= 2;
fPixelRatio *= 2;
}
// source rect
rs.left = CMediaSettings::Get().GetCurrentVideoSettings().m_CropLeft;
rs.top = CMediaSettings::Get().GetCurrentVideoSettings().m_CropTop;
rs.right = m_iSourceWidth - CMediaSettings::Get().GetCurrentVideoSettings().m_CropRight;
rs.bottom = m_iSourceHeight - CMediaSettings::Get().GetCurrentVideoSettings().m_CropBottom;
CalcNormalDisplayRect(fOffsetX1, fOffsetY1, fScreenWidth, fScreenHeight, GetAspectRatio() * fPixelRatio, CDisplaySettings::Get().GetZoomAmount());
// check whether we need to alter our source rect
if (rd.left < fOffsetX1 || rd.right > fOffsetX1 + fScreenWidth)
{
// wants to be wider than we allow, so fix
float fRequiredWidth = (float)rd.right - rd.left;
if (rs.right <= rs.left) rs.right = rs.left+1;
float fHorizScale = fRequiredWidth / (float)(rs.right - rs.left);
float fNewWidth = fScreenWidth / fHorizScale;
rs.left = (rs.right - rs.left - (int)fNewWidth) / 2;
rs.right = rs.left + (int)fNewWidth;
rd.left = (int)fOffsetX1;
rd.right = (int)(fOffsetX1 + fScreenWidth);
}
if (rd.top < fOffsetY1 || rd.bottom > fOffsetY1 + fScreenHeight)
{
// wants to be wider than we allow, so fix
float fRequiredHeight = (float)rd.bottom - rd.top;
if (rs.bottom <= rs.top) rs.bottom = rs.top+1;
float fVertScale = fRequiredHeight / (float)(rs.bottom - rs.top);
float fNewHeight = fScreenHeight / fVertScale;
rs.top = (rs.bottom - rs.top - (int)fNewHeight) / 2;
rs.bottom = rs.top + (int)fNewHeight;
rd.top = (int)fOffsetY1;
rd.bottom = (int)(fOffsetY1 + fScreenHeight);
}
}
XnStatus XnSensorImageStream::ValidateMode()
{
XnStatus nRetVal = XN_STATUS_OK;
// validity checks
XnIOImageFormats nInputFormat = (XnIOImageFormats)m_InputFormat.GetValue();
XnOutputFormats nOutputFormat = GetOutputFormat();
XnResolutions nResolution = GetResolution();
XnUInt32 nFPS = GetFPS();
// check that input format matches output format
switch (nOutputFormat)
{
case XN_OUTPUT_FORMAT_RGB24:
if (nInputFormat != XN_IO_IMAGE_FORMAT_YUV422 &&
nInputFormat != XN_IO_IMAGE_FORMAT_UNCOMPRESSED_YUV422 &&
nInputFormat != XN_IO_IMAGE_FORMAT_BAYER)
{
// --avin mod--
//XN_LOG_WARNING_RETURN(XN_STATUS_DEVICE_BAD_PARAM, XN_MASK_DEVICE_SENSOR, "Input format %d cannot be converted to RGB24!", nInputFormat);
}
break;
case XN_OUTPUT_FORMAT_YUV422:
if (nInputFormat != XN_IO_IMAGE_FORMAT_YUV422 &&
nInputFormat != XN_IO_IMAGE_FORMAT_UNCOMPRESSED_YUV422)
{
XN_LOG_WARNING_RETURN(XN_STATUS_DEVICE_BAD_PARAM, XN_MASK_DEVICE_SENSOR, "Input format %d cannot be converted to YUV422!", nInputFormat);
}
break;
case XN_OUTPUT_FORMAT_JPEG:
if (nInputFormat != XN_IO_IMAGE_FORMAT_JPEG)
{
XN_LOG_WARNING_RETURN(XN_STATUS_DEVICE_BAD_PARAM, XN_MASK_DEVICE_SENSOR, "Input format %d cannot be converted to JPEG!", nInputFormat);
}
break;
case XN_OUTPUT_FORMAT_GRAYSCALE8:
if (nInputFormat != XN_IO_IMAGE_FORMAT_UNCOMPRESSED_GRAY8 &&
nInputFormat != XN_IO_IMAGE_FORMAT_UNCOMPRESSED_BAYER &&
nInputFormat != XN_IO_IMAGE_FORMAT_BAYER)
{
XN_LOG_WARNING_RETURN(XN_STATUS_DEVICE_BAD_PARAM, XN_MASK_DEVICE_SENSOR, "Input format %d cannot be converted to Gray8!", nInputFormat);
}
break;
default:
// we shouldn't have reached here. Theres a check at SetOutputFormat.
XN_ASSERT(FALSE);
XN_LOG_WARNING_RETURN(XN_STATUS_DEVICE_BAD_PARAM, XN_MASK_DEVICE_SENSOR, "Unsupported image output format: %d!", nOutputFormat);
}
// now check that mode exists
XnCmosPreset preset = { (XnUInt16)nInputFormat, (XnUInt16)nResolution, (XnUInt16)nFPS };
nRetVal = ValidateSupportedMode(preset);
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
inline std::pair<double, bool> EstimateDistance(const Eigen::Vector3d& location) const
{
const std::vector<int64_t> indices = LocationToGridIndex(location);
if (indices.size() == 3)
{
const Eigen::Vector3d gradient = EigenHelpers::StdVectorDoubleToEigenVector3d(GetGradient(indices[0], indices[1], indices[2], true));
const std::vector<double> cell_location = GridIndexToLocation(indices[0], indices[1], indices[2]);
const Eigen::Vector3d cell_location_to_our_location(location.x() - cell_location[0], location.y() - cell_location[1], location.z() - cell_location[2]);
const double nominal_distance = (double)distance_field_.GetImmutable(indices[0], indices[1], indices[2]).first;
const double corrected_nominal_distance = (nominal_distance >= 0.0) ? nominal_distance - (GetResolution() * 0.5) : nominal_distance + (GetResolution() * 0.5);
const double cell_location_to_our_location_dot_gradient = cell_location_to_our_location.dot(gradient);
//const double gradient_dot_gradient = gradient.dot(gradient); // == squared norm of gradient
//const Eigen::Vector3d cell_location_to_our_location_projected_on_gradient = (cell_location_to_our_location_dot_gradient / gradient.dot(gradient)) * gradient;
//const double distance_adjustment = cell_location_to_our_location_projected_on_gradient.norm();
const double distance_adjustment = cell_location_to_our_location_dot_gradient / gradient.norm();
const double distance_estimate = corrected_nominal_distance + distance_adjustment;
if ((corrected_nominal_distance >= 0.0) == (distance_estimate >= 0.0))
{
return std::make_pair(distance_estimate, true);
}
else if (corrected_nominal_distance >= 0.0)
{
const double fudge_distance = GetResolution() * 0.0625;
return std::make_pair(fudge_distance, true);
}
else
{
const double fudge_distance = GetResolution() * -0.0625;
return std::make_pair(fudge_distance, true);
}
// else
// {
// const double real_distance_adjustment = GetResolution() * 0.20710678118654757;
// const double revised_corrected_nominal_distance = (nominal_distance >= 0.0) ? nominal_distance - real_distance_adjustment : nominal_distance + real_distance_adjustment;
// const double revised_distance_estimate = revised_corrected_nominal_distance + distance_adjustment;
// return std::make_pair(revised_distance_estimate, true);
// }
}
else
{
return std::make_pair((double)distance_field_.GetOOBValue(), false);
}
}
uint32 MultimediaClock::SetResolution(uint32 ms)
{
if(m_CurrentPeriod == ms)
{
return m_CurrentPeriod;
}
Cleanup();
SetPeriod(ms);
return GetResolution();
}
XnStatus XnSensorIRStream::CalcRequiredSize(XnUInt32* pnRequiredSize) const
{
// in IR, in all resolutions except SXGA, we get additional 8 lines
XnUInt32 nYRes = GetYRes();
if (GetResolution() != XN_RESOLUTION_SXGA)
{
nYRes += 8;
}
*pnRequiredSize = GetXRes() * nYRes * GetBytesPerPixel();
return XN_STATUS_OK;
}
inline bool GradientIsEffectiveFlat(const Eigen::Vector3d& gradient) const
{
// A gradient is at a local maxima if the absolute value of all components (x,y,z) are less than 1/2 SDF resolution
double half_resolution = GetResolution() * 0.5;
if (fabs(gradient.x()) <= half_resolution && fabs(gradient.y()) <= half_resolution && fabs(gradient.z()) <= half_resolution)
{
return true;
}
else
{
return false;
}
}
void CXBMCRenderManager::UpdateResolution()
{
if (m_bReconfigured)
{
CRetakeLock<CExclusiveLock> lock(m_sharedSection);
if (g_graphicsContext.IsFullScreenVideo() && g_graphicsContext.IsFullScreenRoot())
{
RESOLUTION res = GetResolution();
g_graphicsContext.SetVideoResolution(res);
}
m_bReconfigured = false;
}
}
XnStatus XnSensorDepthStream::DecideFirmwareRegistration(XnBool bRegistration, XnProcessingType registrationType, XnResolutions nRes)
{
XnStatus nRetVal = XN_STATUS_OK;
// start with request
XnBool bFirmwareRegistration = bRegistration;
if (bFirmwareRegistration)
{
// old chip (PS1000) does not support registration for VGA
XnBool bHardwareRegistrationSupported =
m_Helper.GetPrivateData()->ChipInfo.nChipVer != XN_SENSOR_CHIP_VER_PS1000 || nRes == XN_RESOLUTION_QVGA;
switch (registrationType)
{
case XN_PROCESSING_HARDWARE:
if (!bHardwareRegistrationSupported)
{
XN_LOG_WARNING_RETURN(XN_STATUS_DEVICE_BAD_PARAM, XN_MASK_DEVICE_SENSOR, "Sensor does not support hardware registration for current configuration!");
}
break;
case XN_PROCESSING_SOFTWARE:
if (GetResolution() != XN_RESOLUTION_VGA)
{
XN_LOG_WARNING_RETURN(XN_STATUS_DEVICE_BAD_PARAM, XN_MASK_DEVICE_SENSOR, "Software registration is only supported for VGA resolution!");
}
bFirmwareRegistration = FALSE;
break;
case XN_PROCESSING_DONT_CARE:
bFirmwareRegistration = bHardwareRegistrationSupported;
break;
default:
XN_LOG_ERROR_RETURN(XN_STATUS_DEVICE_BAD_PARAM, XN_MASK_DEVICE_SENSOR, "Unknown registration type: %d", registrationType);
}
}
if (bRegistration && !bFirmwareRegistration)
{
// make sure software registration is initialized
if (!m_Registration.IsInitialized())
{
nRetVal = m_Registration.Init(m_Helper.GetPrivateData(), this, GetDepthToShiftTable());
XN_IS_STATUS_OK(nRetVal);
}
}
nRetVal = m_Helper.SimpleSetFirmwareParam(m_FirmwareRegistration, (XnUInt16)bFirmwareRegistration);
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
float Tile::GetMaxHeight() const {
static float max = std::numeric_limits<float>::min();
if (max == std::numeric_limits<float>::min()) {
const int res = GetResolution();
for (int i = 1; i < res; ++i) {
max = std::max(max, vertices_[i].y);
}
if (num_lod_ > 0) {
for (int dir = 0; dir < 4; ++dir) {
max = std::max(max, children_[dir]->GetMaxHeight());
}
}
}
return max;
}
XnStatus XnSensorDepthStream::ConfigureStreamImpl()
{
XnStatus nRetVal = XN_STATUS_OK;
xnUSBShutdownReadThread(GetHelper()->GetPrivateData()->pSpecificDepthUsb->pUsbConnection->UsbEp);
nRetVal = SetActualRead(TRUE);
XN_IS_STATUS_OK(nRetVal);
XN_IS_STATUS_OK(m_Helper.ConfigureFirmware(m_InputFormat));
XN_IS_STATUS_OK(m_Helper.ConfigureFirmware(ResolutionProperty()));
XN_IS_STATUS_OK(m_Helper.ConfigureFirmware(FPSProperty()));
XN_IS_STATUS_OK(m_Helper.ConfigureFirmware(m_HoleFilter));
XN_IS_STATUS_OK(m_Helper.ConfigureFirmware(m_Gain));
// we need to turn decimation on when resolution is QVGA, and FPS is different than 60
// NOTE: this is ugly as hell. This logic should be moved to firmware.
XnBool bDecimation = (GetResolution() == XN_RESOLUTION_QVGA && GetFPS() != 60);
nRetVal = GetFirmwareParams()->m_DepthDecimation.SetValue(bDecimation);
XN_IS_STATUS_OK(nRetVal);
XN_IS_STATUS_OK(m_Helper.ConfigureFirmware(m_FirmwareRegistration));
XN_IS_STATUS_OK(m_Helper.ConfigureFirmware(m_FirmwareMirror));
XN_IS_STATUS_OK(m_Helper.ConfigureFirmware(m_GMCMode));
XN_IS_STATUS_OK(m_Helper.ConfigureFirmware(m_WhiteBalance));
nRetVal = m_Helper.GetCmosInfo()->SetCmosConfig(XN_CMOS_TYPE_DEPTH, GetResolution(), GetFPS());
XN_IS_STATUS_OK(nRetVal);
// --avin mod--
//Turn off the IR projector anti-cover thingy. I find it annoying and It's off on the XBox360 so it must be safe :-)
//This is probably not the best way to do it, but adding it as a real param is too much work for me at the moment...
XnHostProtocolSetParam(GetHelper()->GetPrivateData(), 0x105, 0);
return XN_STATUS_OK;
}
XnStatus XnSensorDepthStream::SetRegistrationType(XnProcessingType type)
{
XnStatus nRetVal = XN_STATUS_OK;
if (type != m_RegistrationType.GetValue())
{
nRetVal = DecideFirmwareRegistration((XnBool)m_DepthRegistration.GetValue(), type, GetResolution());
XN_IS_STATUS_OK(nRetVal);
nRetVal = m_RegistrationType.UnsafeUpdateValue(type);
XN_IS_STATUS_OK(nRetVal);
}
return (XN_STATUS_OK);
}
void
ImageLoader::removeUnusedAlpha() {
if (!_isI60 && GetBitsPerPixel() == 32 && !HasAlpha()) {
// Compress unused fourth channel
AC_DEBUG << "ImageLoader removing unused fourth channel";
unsigned myHeight = GetHeight();
unsigned myWidth = GetWidth();
//unsigned myLineStride = GetBytesPerLine();
asl::Ptr<Block> myDestinationBlock = asl::Ptr<Block>(new Block());
myDestinationBlock->resize(myHeight * myWidth * 3);
unsigned char ** myLineArray = GetLineArray();
unsigned char * myDestination = myDestinationBlock->begin();
for (unsigned i = 0; i < myHeight; ++i) {
unsigned char * mySource = *myLineArray;
for (unsigned j = 0; j < myWidth; ++j) {
myDestination[0] = mySource[0];
myDestination[1] = mySource[1];
myDestination[2] = mySource[2];
mySource += 4;
myDestination += 3;
}
myLineArray++;
}
// Update internal representation
switch (_myEncoding) {
case RGBA :
_myEncoding = RGB;
break;
case BGRA :
_myEncoding = BGR;
break;
default:
throw ImageLoaderException("Unsupported pixel encoding", PLUS_FILE_LINE);
}
_myData = myDestinationBlock;
PLPixelFormat myPixelFormat;
mapPixelEncodingToFormat(_myEncoding, myPixelFormat);
SetBmpInfo(GetSize(), GetResolution(), myPixelFormat);
updateLineArray();
}
}
XnStatus XnSensorImageStream::ValidateMode()
{
XnStatus nRetVal = XN_STATUS_OK;
// validity checks
XnIOImageFormats nInputFormat = (XnIOImageFormats)m_InputFormat.GetValue();
XnOutputFormats nOutputFormat = GetOutputFormat();
XnResolutions nResolution = GetResolution();
// Avin: Removed to enable 1280x1024 Image
// check resolution
/*
if ((nResolution == XN_RESOLUTION_UXGA || nResolution == XN_RESOLUTION_SXGA) && nInputFormat != XN_IO_IMAGE_FORMAT_BAYER)
{
XN_LOG_WARNING_RETURN(XN_STATUS_DEVICE_BAD_PARAM, XN_MASK_DEVICE_SENSOR, "UXGA resolution is only supported with BAYER input!");
}
*/
// check output format
if (nOutputFormat == XN_OUTPUT_FORMAT_GRAYSCALE8 && nInputFormat != XN_IO_IMAGE_FORMAT_BAYER)
{
XN_LOG_WARNING_RETURN(XN_STATUS_DEVICE_BAD_PARAM, XN_MASK_DEVICE_SENSOR, "Grayscale8 output requires BAYER input!");
}
else if (nOutputFormat == XN_OUTPUT_FORMAT_YUV422 && nInputFormat != XN_IO_IMAGE_FORMAT_YUV422 && nInputFormat != XN_IO_IMAGE_FORMAT_UNCOMPRESSED_YUV422)
{
XN_LOG_WARNING_RETURN(XN_STATUS_DEVICE_BAD_PARAM, XN_MASK_DEVICE_SENSOR, "YUV output requires YUV input!");
}
// check input format
if (nInputFormat == XN_IO_IMAGE_FORMAT_BAYER && nResolution != XN_RESOLUTION_UXGA && nResolution != XN_RESOLUTION_SXGA)
{
XN_LOG_WARNING_RETURN(XN_STATUS_DEVICE_BAD_PARAM, XN_MASK_DEVICE_SENSOR, "BAYER input requires SXGA/UXGA resolution!");
}
else if (nInputFormat == XN_IO_IMAGE_FORMAT_JPEG && nOutputFormat != XN_OUTPUT_FORMAT_RGB24)
{
XN_LOG_WARNING_RETURN(XN_STATUS_DEVICE_BAD_PARAM, XN_MASK_DEVICE_SENSOR, "Jpeg input is only supported for RGB24 output!");
}
return (XN_STATUS_OK);
}
void
ImageLoader::loadI60File(asl::Ptr<ReadableBlockHandle> theImageBlock) {
_myImageMatrix.makeIdentity();
I60Header myHeader;
theImageBlock->getBlock().readData(myHeader, 0);
if (!myHeader.checkMagicNumber()) {
throw ImageLoaderException(string("Image ") + _myFilename +
" has a wrong magic number. '" + I60_MAGIC_NUMBER + "' expeced.", PLUS_FILE_LINE);
}
if (!myHeader.checkVersion()) {
throw ImageLoaderException(string("Image ") + _myFilename + " file format version: " +
as_string(myHeader.version) + " does not match current reader version: " +
as_string(CURRENT_IMAGE_FORMAT_VERSION), PLUS_FILE_LINE);
}
_myHeaderSize = myHeader.headersize;
_myEncoding = PixelEncoding(myHeader.encoding);
_isI60 = true;
unsigned myWidthPowerOfTwo = asl::nextPowerOfTwo(myHeader.width);
unsigned myHeightPowerOfTwo = asl::nextPowerOfTwo(myHeader.height);
_myImageMatrix.scale(Vector3f(float(myHeader.width) / myWidthPowerOfTwo,
float(myHeader.height) / myHeightPowerOfTwo,
1.0f));
// maybe we should cut off the i60 header here?
unsigned myBlockSize = theImageBlock->getBlock().size();
_myData = asl::Ptr<Block>(new Block());
_myData->resize(myBlockSize - sizeof(I60Header));
std::copy(theImageBlock->getBlock().begin()+sizeof(I60Header),
theImageBlock->getBlock().end(), _myData->begin());
// TODO: Add support for other compression formats
SetBmpInfo(PLPoint(myWidthPowerOfTwo, myHeightPowerOfTwo * myHeader.layercount),
GetResolution(), PLPixelFormat::L1 /* only correct for DXT5 */);
}
XnStatus XnSensorDepthStream::Init()
{
XnStatus nRetVal = XN_STATUS_OK;
nRetVal = SetBufferPool(&m_BufferPool);
XN_IS_STATUS_OK(nRetVal);
// init base
nRetVal = XnDepthStream::Init();
XN_IS_STATUS_OK(nRetVal);
m_InputFormat.UpdateSetCallback(SetInputFormatCallback, this);
m_DepthRegistration.UpdateSetCallback(SetRegistrationCallback, this);
m_HoleFilter.UpdateSetCallback(SetHoleFilterCallback, this);
m_WhiteBalance.UpdateSetCallback(SetWhiteBalanceCallback, this);
m_Gain.UpdateSetCallback(SetGainCallback, this);
m_RegistrationType.UpdateSetCallback(SetRegistrationTypeCallback, this);
m_AGCBin.UpdateSetCallback(SetAGCBinCallback, this);
m_AGCBin.UpdateGetCallback(GetAGCBinCallback, this);
m_GMCMode.UpdateSetCallback(SetGMCModeCallback, this);
XN_VALIDATE_ADD_PROPERTIES(this, &m_InputFormat, &m_DepthRegistration, &m_HoleFilter,
&m_WhiteBalance, &m_Gain, &m_AGCBin, &m_SharedBufferName, &m_ActualRead, &m_GMCMode,
&m_RegistrationType);
if (m_Helper.GetPrivateData()->pSensor->IsLowBandwidth())
{
nRetVal = m_InputFormat.UnsafeUpdateValue(XN_IO_DEPTH_FORMAT_COMPRESSED_PS);
XN_IS_STATUS_OK(nRetVal);
}
// set base properties default values
nRetVal = ResolutionProperty().UnsafeUpdateValue(XN_DEPTH_STREAM_DEFAULT_RESOLUTION);
XN_IS_STATUS_OK(nRetVal);
nRetVal = FPSProperty().UnsafeUpdateValue(XN_DEPTH_STREAM_DEFAULT_FPS);
XN_IS_STATUS_OK(nRetVal);
nRetVal = OutputFormatProperty().UnsafeUpdateValue(XN_DEPTH_STREAM_DEFAULT_OUTPUT_FORMAT);
XN_IS_STATUS_OK(nRetVal);
nRetVal = ParamCoefficientProperty().UnsafeUpdateValue(XN_SHIFTS_PARAM_COEFFICIENT);
XN_IS_STATUS_OK(nRetVal);
nRetVal = ShiftScaleProperty().UnsafeUpdateValue(XN_SHIFTS_SHIFT_SCALE);
XN_IS_STATUS_OK(nRetVal);
// read some data from firmware
XnDepthInformation DepthInformation;
nRetVal = XnHostProtocolAlgorithmParams(m_Helper.GetPrivateData(), XN_HOST_PROTOCOL_ALGORITHM_DEPTH_INFO, &DepthInformation, sizeof(XnDepthInformation), XN_RESOLUTION_VGA, 30);
XN_IS_STATUS_OK(nRetVal);
nRetVal = ConstShiftProperty().UnsafeUpdateValue(DepthInformation.nConstShift);
XN_IS_STATUS_OK(nRetVal);
nRetVal = ZeroPlaneDistanceProperty().UnsafeUpdateValue(m_Helper.GetFixedParams()->GetZeroPlaneDistance());
XN_IS_STATUS_OK(nRetVal);
nRetVal = ZeroPlanePixelSizeProperty().UnsafeUpdateValue(m_Helper.GetFixedParams()->GetZeroPlanePixelSize());
XN_IS_STATUS_OK(nRetVal);
nRetVal = EmitterDCmosDistanceProperty().UnsafeUpdateValue(m_Helper.GetFixedParams()->GetEmitterDCmosDistance());
XN_IS_STATUS_OK(nRetVal);
nRetVal = GetDCmosRCmosDistanceProperty().UnsafeUpdateValue(m_Helper.GetFixedParams()->GetDCmosRCmosDistance());
XN_IS_STATUS_OK(nRetVal);
// init helper
nRetVal = m_Helper.Init(this, this);
XN_IS_STATUS_OK(nRetVal);
if (m_Helper.GetFirmwareVersion() < XN_SENSOR_FW_VER_3_0)
{
nRetVal = m_GMCMode.UnsafeUpdateValue(FALSE);
XN_IS_STATUS_OK(nRetVal);
}
if (m_Helper.GetFirmwareVersion() < XN_SENSOR_FW_VER_4_0)
{
nRetVal = m_WhiteBalance.UnsafeUpdateValue(FALSE);
XN_IS_STATUS_OK(nRetVal);
}
// on old firmwares, the host decides on the default gain. On new firmwares, we read it from firmware
if (m_Helper.GetFirmware()->GetInfo()->nFWVer > XN_SENSOR_FW_VER_1_2)
{
nRetVal = m_Gain.UnsafeUpdateValue(GetFirmwareParams()->m_DepthGain.GetValue());
XN_IS_STATUS_OK(nRetVal);
}
// registration
XnCallbackHandle hCallbackDummy;
nRetVal = ResolutionProperty().OnChangeEvent().Register(DecideFirmwareRegistrationCallback, this, &hCallbackDummy);
XN_IS_STATUS_OK(nRetVal);
nRetVal = DecideFirmwareRegistration((XnBool)m_DepthRegistration.GetValue(), (XnProcessingType)m_RegistrationType.GetValue(), GetResolution());
XN_IS_STATUS_OK(nRetVal);
// data processor
nRetVal = m_Helper.RegisterDataProcessorProperty(m_InputFormat);
XN_IS_STATUS_OK(nRetVal);
nRetVal = m_Helper.RegisterDataProcessorProperty(ResolutionProperty());
XN_IS_STATUS_OK(nRetVal);
// pixel size factor
nRetVal = GetFirmwareParams()->m_ReferenceResolution.OnChangeEvent().Register(DecidePixelSizeFactorCallback, this, &m_hReferenceSizeChangedCallback);
XN_IS_STATUS_OK(nRetVal);
nRetVal = DecidePixelSizeFactor();
XN_IS_STATUS_OK(nRetVal);
// register supported modes
XnCmosPreset aSupportedModes[] =
{
{ XN_IO_DEPTH_FORMAT_COMPRESSED_PS, XN_RESOLUTION_QVGA, 30 },
{ XN_IO_DEPTH_FORMAT_COMPRESSED_PS, XN_RESOLUTION_QVGA, 60 },
{ XN_IO_DEPTH_FORMAT_COMPRESSED_PS, XN_RESOLUTION_VGA, 30 },
{ XN_IO_DEPTH_FORMAT_UNCOMPRESSED_11_BIT, XN_RESOLUTION_QVGA, 30 },
{ XN_IO_DEPTH_FORMAT_UNCOMPRESSED_11_BIT, XN_RESOLUTION_QVGA, 60 },
{ XN_IO_DEPTH_FORMAT_UNCOMPRESSED_11_BIT, XN_RESOLUTION_VGA, 30 },
{ XN_IO_DEPTH_FORMAT_UNCOMPRESSED_16_BIT, XN_RESOLUTION_QVGA, 30 },
{ XN_IO_DEPTH_FORMAT_UNCOMPRESSED_16_BIT, XN_RESOLUTION_QVGA, 60 },
{ XN_IO_DEPTH_FORMAT_UNCOMPRESSED_16_BIT, XN_RESOLUTION_VGA, 30 },
};
nRetVal = AddSupportedModes(aSupportedModes, sizeof(aSupportedModes)/sizeof(aSupportedModes[0]));
XN_IS_STATUS_OK(nRetVal);
if (m_Helper.GetFirmwareVersion() >= XN_SENSOR_FW_VER_5_2)
{
XnCmosPreset aSupportedModes25[] =
{
{ XN_IO_DEPTH_FORMAT_COMPRESSED_PS, XN_RESOLUTION_QVGA, 25 },
{ XN_IO_DEPTH_FORMAT_COMPRESSED_PS, XN_RESOLUTION_VGA, 25 },
{ XN_IO_DEPTH_FORMAT_UNCOMPRESSED_11_BIT, XN_RESOLUTION_QVGA, 25 },
{ XN_IO_DEPTH_FORMAT_UNCOMPRESSED_11_BIT, XN_RESOLUTION_VGA, 25 },
{ XN_IO_DEPTH_FORMAT_UNCOMPRESSED_16_BIT, XN_RESOLUTION_QVGA, 25 },
{ XN_IO_DEPTH_FORMAT_UNCOMPRESSED_16_BIT, XN_RESOLUTION_VGA, 25 },
};
nRetVal = AddSupportedModes(aSupportedModes25, sizeof(aSupportedModes25)/sizeof(aSupportedModes25[0]));
XN_IS_STATUS_OK(nRetVal);
}
return (XN_STATUS_OK);
}
//--------------------------------------------------------------------------
void VeRenderWindowD3D12::SetupCompositorList(const VeChar8** ppcList,
VeSizeT stNum, VeUInt32 u32ThreadNum, const VeChar8* pcHint) noexcept
{
VeRendererD3D12& kRenderer = *VeMemberCast(
&VeRendererD3D12::m_kRenderWindowList, m_kNode.get_list());
VeVector<VeRenderer::FrameTechnique*> kTechList;
{
for (VeSizeT i(0); i < stNum; ++i)
{
auto it = kRenderer.m_kCompositorMap.find(ppcList[i]);
if (it != kRenderer.m_kCompositorMap.end())
{
VeRenderer::FrameTechnique* pkTech = nullptr;
if (pcHint)
{
VeFixedString kHint = pcHint;
for (auto& tech : it->second->m_kTechniqueList)
{
if (tech.m_kName == kHint)
{
pkTech = &tech;
break;
}
}
}
if (pkTech)
{
kTechList.push_back(pkTech);
}
else if(it->second->m_kTechniqueList.size())
{
kTechList.push_back(&(it->second->m_kTechniqueList.front()));
}
}
}
}
{
m_kResourceMap.clear();
VeStringMap<VeFloat64> kValueMap;
kValueMap["screen_w"] = (VeFloat64)GetWidth();
kValueMap["screen_h"] = (VeFloat64)GetHeight();
for (auto pTech : kTechList)
{
for (auto& res : pTech->m_kResourceList)
{
auto it = m_kResourceMap.find(res.m_kName);
if (it == m_kResourceMap.end())
{
VeUInt32 w = (VeUInt32)ve_parser.CalculateExpression(
kValueMap, res.m_kWidth, 0);
VeUInt32 h = (VeUInt32)ve_parser.CalculateExpression(
kValueMap, res.m_kHeight, 0);
VeUInt16 d = (VeUInt16)ve_parser.CalculateExpression(
kValueMap, res.m_kDepth, 0);
VeUInt16 m = (VeUInt16)ve_parser.CalculateExpression(
kValueMap, res.m_kMipLevels, 0);
VeUInt16 c = (VeUInt16)ve_parser.CalculateExpression(
kValueMap, res.m_kCount, 0);
VeUInt16 q = (VeUInt16)ve_parser.CalculateExpression(
kValueMap, res.m_kQuality, 0);
VeUInt32 u32Use(0);
if (res.m_kSRVList.size()) u32Use |= VeRenderTexture::USEAGE_SRV;
if (res.m_kRTVList.size()) u32Use |= VeRenderTexture::USEAGE_RTV;
if (res.m_kDSVList.size()) u32Use |= VeRenderTexture::USEAGE_DSV;
VeRenderTextureD3D12* pkTexture = VE_NEW VeRenderTextureD3D12(
res.m_eDimension, (VeRenderTexture::Useage)u32Use,
res.m_eFormat, w, h, d, m, c, q);
pkTexture->Init(kRenderer);
if (res.m_kSRVList.size())
{
pkTexture->SetSRVNum((VeUInt32)res.m_kSRVList.size());
for (VeUInt32 i(0); i < res.m_kSRVList.size(); ++i)
{
auto& srv = res.m_kSRVList[i];
pkTexture->SetSRV(i, srv.m_eType, srv.m_eFormat,
srv.m_u32Param0, srv.m_u32Param1);
}
}
if (res.m_kRTVList.size())
{
pkTexture->SetRTVNum((VeUInt32)res.m_kRTVList.size());
for (VeUInt32 i(0); i < res.m_kRTVList.size(); ++i)
{
auto& rtv = res.m_kRTVList[i];
pkTexture->SetRTV(i, rtv.m_eType, rtv.m_eFormat,
rtv.m_u32Param0, rtv.m_u32Param1);
}
}
if (res.m_kDSVList.size())
{
pkTexture->SetDSVNum((VeUInt32)res.m_kDSVList.size());
for (VeUInt32 i(0); i < res.m_kDSVList.size(); ++i)
{
auto& dsv = res.m_kDSVList[i];
pkTexture->SetDSV(i, dsv.m_eType, dsv.m_eFormat,
dsv.m_u32Param0, dsv.m_u32Param1);
}
}
m_kResourceMap[res.m_kName] = pkTexture;
}
}
}
}
VeVector<VeStringMap<TargetCache>> kTargets;
kTargets.resize(kTechList.size());
for (VeSizeT i(kTechList.size() - 1); i < kTechList.size(); --i)
{
VeRenderer::FrameTechnique& kTech = *kTechList[i];
for (VeSizeT j(0); j < kTech.m_kTargetList.size(); ++j)
{
VeRenderer::FrameTarget& kTarget = kTech.m_kTargetList[j];
RecordRenderTargetPtr spTarget;
VeVector<ViewData> kRTVList;
ViewData kDSV;
if (kTarget.m_eType == VeRenderer::TARGET_OUTPUT)
{
if (i == (kTechList.size() - 1))
{
spTarget = VE_NEW RecordRenderTarget();
for (VeSizeT k(0); k < VeRendererD3D12::FRAME_COUNT; ++k)
{
spTarget->m_akRTVList[k].push_back(m_akFrameCache[k].m_hHandle);
spTarget->m_ahDSV[k].ptr = 0;
}
kRTVList.resize(kRTVList.size() + 1);
kRTVList.back().m_u32Width = GetWidth();
kRTVList.back().m_u32Height = GetHeight();
kRTVList.back().m_u32Depth = 1;
kRTVList.back().m_u32SubResource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES;
}
else
{
auto it = kTargets[i + 1].find(kTarget.m_kName);
if (it != kTargets[i + 1].end() && it->second.m_pkConfig->m_eType == VeRenderer::TARGET_INPUT)
{
spTarget = it->second.m_spRecorder;
}
}
}
else
{
spTarget = VE_NEW RecordRenderTarget();
for (auto& rtv : kTarget.m_kRTVList)
{
auto it = m_kResourceMap.find(rtv.m_kResName);
if (it != m_kResourceMap.end())
{
if (rtv.m_u32Index < it->second->m_kRTVList.size())
{
auto& kView = it->second->m_kRTVList[rtv.m_u32Index];
for (VeSizeT k(0); k < VeRendererD3D12::FRAME_COUNT; ++k)
{
spTarget->m_akRTVList[k].push_back(kView.m_hCPUHandle);
}
kRTVList.resize(kRTVList.size() + 1);
kRTVList.back().m_pkResource = it->second->m_pkResource;
kRTVList.back().m_u32Width = kView.m_u32Width;
kRTVList.back().m_u32Height = kView.m_u32Height;
kRTVList.back().m_u32Depth = kView.m_u32Depth;
kRTVList.back().m_u32SubResource = kView.m_u32SubResource;
}
}
}
auto it = m_kResourceMap.find(kTarget.m_kDSV.m_kResName);
if (it != m_kResourceMap.end())
{
if (kTarget.m_kDSV.m_u32Index < it->second->m_kDSVList.size())
{
auto& kView = it->second->m_kDSVList[kTarget.m_kDSV.m_u32Index];
for (VeSizeT k(0); k < VeRendererD3D12::FRAME_COUNT; ++k)
{
spTarget->m_ahDSV[k] = kView.m_hCPUHandle;
}
kDSV.m_pkResource = it->second->m_pkResource;
kDSV.m_u32Width = kView.m_u32Width;
kDSV.m_u32Height = kView.m_u32Height;
kDSV.m_u32Depth = kView.m_u32Depth;
kDSV.m_u32SubResource = kView.m_u32SubResource;
}
}
}
if (spTarget)
{
auto& tar = kTargets[i][kTarget.m_kName];
VE_ASSERT(!tar.m_pkConfig);
tar.m_pkConfig = &kTarget;
tar.m_spRecorder = spTarget;
tar.m_kRTVList = std::move(kRTVList);
tar.m_kDSV = kDSV;
}
}
}
RecordBarrierMap kBarriers;
kBarriers.resize(kTechList.size());
BarrierPathCache kResPathCache;
VeMap<ID3D12Resource*, VeMap<VeUInt32, D3D12_RESOURCE_STATES>> kClickCache;
for (VeSizeT i(0); i < kTechList.size(); ++i)
{
auto& kMap = kTargets[i];
VeRenderer::FrameTechnique& kTech = *kTechList[i];
kBarriers[i].resize(kTech.m_kClickList.size());
for (VeSizeT j(0); j < kTech.m_kClickList.size(); ++j)
{
VeRenderer::FrameClick& kClick = kTech.m_kClickList[j];
auto it = kMap.find(kClick.m_kTarget);
if (it == kMap.end()) continue;
auto& tar = it->second;
kClickCache.clear();
for (auto rtv : tar.m_kRTVList)
{
kClickCache[rtv.m_pkResource][rtv.m_u32SubResource] = D3D12_RESOURCE_STATE_RENDER_TARGET;
}
if(tar.m_kDSV.m_pkResource)
{
kClickCache[tar.m_kDSV.m_pkResource][tar.m_kDSV.m_u32SubResource] = D3D12_RESOURCE_STATE_DEPTH_WRITE;
}
for (auto& con : kClick.m_kContextList)
{
auto itRes = m_kResourceMap.find(con);
if (itRes != m_kResourceMap.end())
{
auto& cache = kClickCache[itRes->second->m_pkResource];
cache.clear();
cache[D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES] = D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE;
}
}
for (auto& cache : kClickCache)
{
for (auto& state : cache.second)
{
BarrierEvent(kBarriers, kResPathCache, i, j,
cache.first, state.first, state.second);
}
}
}
}
VeUInt32 u32GCLIndex(0);
bool bScene = false;
m_kRecorderList.resize(1);
m_kRecorderList.back().m_u32CommandIndex = 0;
m_kRecorderList.back().m_kTaskList.clear();
m_kProcessList.resize(1);
m_kProcessList.back().m_eType = TYPE_EXCUTE;
m_kProcessList.back().m_u16Start = 0;
m_kProcessList.back().m_u16Num = 1;
m_kCameraList.clear();
RectMap kRectMap;
RecordRenderTargetPtr spCurrent;
RecordViewportPtr spViewport;
RecordScissorRectPtr spScissorRect;
for (VeSizeT i(0); i < kTechList.size(); ++i)
{
VeRenderer::FrameTechnique& kTech = *kTechList[i];
auto& kMap = kTargets[i];
for (VeSizeT j(0); j < kTech.m_kClickList.size(); ++j)
{
VeRenderer::FrameClick& kClick = kTech.m_kClickList[j];
auto it = kMap.find(kClick.m_kTarget);
if(it == kMap.end()) continue;
TargetCache& kCache = it->second;
auto& bar = kBarriers[i][j];
if(bar.first)
{
if (bScene)
{
if (m_kProcessList.back().m_eType == TYPE_EXCUTE)
{
m_kProcessList.back().m_u16Num += 1;
}
else
{
m_kProcessList.resize(m_kProcessList.size() + 1);
m_kProcessList.back().m_eType = TYPE_EXCUTE;
m_kProcessList.back().m_u16Start = u32GCLIndex + 1;
m_kProcessList.back().m_u16Num = 1;
}
++u32GCLIndex;
m_kRecorderList.resize(m_kRecorderList.size() + 1);
m_kRecorderList.back().m_u32CommandIndex = u32GCLIndex;
m_kRecorderList.back().m_kTaskList.clear();
bScene = false;
}
m_kRecorderList.back().m_kTaskList.push_back(bar.first);
}
for (VeSizeT k(0); k < kClick.m_kPassList.size(); ++k)
{
switch (kClick.m_kPassList[k]->m_eType)
{
case VeRenderer::PASS_CLEAR:
{
if (bScene)
{
if (m_kProcessList.back().m_eType == TYPE_EXCUTE)
{
m_kProcessList.back().m_u16Num += 1;
}
else
{
m_kProcessList.resize(m_kProcessList.size() + 1);
m_kProcessList.back().m_eType = TYPE_EXCUTE;
m_kProcessList.back().m_u16Start = u32GCLIndex + 1;
m_kProcessList.back().m_u16Num = 1;
}
++u32GCLIndex;
m_kRecorderList.resize(m_kRecorderList.size() + 1);
m_kRecorderList.back().m_u32CommandIndex = u32GCLIndex;
m_kRecorderList.back().m_kTaskList.clear();
bScene = false;
}
VeRenderer::FrameClear& kClear = (VeRenderer::FrameClear&)*kClick.m_kPassList[k];
if (VE_MASK_HAS_ANY(kClear.m_u32Flags, VeRenderer::CLEAR_COLOR)
&& kClear.m_kColorArray.size())
{
VeSizeT stColorNum = kCache.m_spRecorder->m_akRTVList->size();
for (VeSizeT l(0); l < stColorNum; ++l)
{
RecordClearRTV* pkTask = VE_NEW RecordClearRTV();
for (VeSizeT m(0); m < VeRendererD3D12::FRAME_COUNT; ++m)
{
pkTask->m_ahHandle[m] = kCache.m_spRecorder->m_akRTVList[m][l];
}
if (l < kClear.m_kColorArray.size())
{
pkTask->m_kColor = kClear.m_kColorArray[l];
}
else
{
pkTask->m_kColor = kClear.m_kColorArray.back();
}
m_kRecorderList.back().m_kTaskList.push_back(pkTask);
}
}
if (VE_MASK_HAS_ANY(kClear.m_u32Flags, VeRenderer::CLEAR_DEPTH)
|| VE_MASK_HAS_ANY(kClear.m_u32Flags, VeRenderer::CLEAR_STENCIL))
{
if (kCache.m_spRecorder->m_ahDSV->ptr)
{
RecordClearDSV* pkTask = VE_NEW RecordClearDSV();
pkTask->m_eFlags = VE_TMIN(D3D12_CLEAR_FLAGS);
if (VE_MASK_HAS_ANY(kClear.m_u32Flags, VeRenderer::CLEAR_DEPTH))
{
pkTask->m_eFlags |= D3D12_CLEAR_FLAG_DEPTH;
}
if (VE_MASK_HAS_ANY(kClear.m_u32Flags, VeRenderer::CLEAR_STENCIL))
{
pkTask->m_eFlags |= D3D12_CLEAR_FLAG_STENCIL;
}
pkTask->m_f32Depth = kClear.m_f32Depth;
pkTask->m_u8Stencil = kClear.m_u8Stencil;
for (VeSizeT m(0); m < VeRendererD3D12::FRAME_COUNT; ++m)
{
pkTask->m_ahHandle[m] = kCache.m_spRecorder->m_ahDSV[m];
}
m_kRecorderList.back().m_kTaskList.push_back(pkTask);
}
}
}
break;
case VeRenderer::PASS_QUAD:
{
if (bScene)
{
if (m_kProcessList.back().m_eType == TYPE_EXCUTE)
{
m_kProcessList.back().m_u16Num += 1;
}
else
{
m_kProcessList.resize(m_kProcessList.size() + 1);
m_kProcessList.back().m_eType = TYPE_EXCUTE;
m_kProcessList.back().m_u16Start = u32GCLIndex + 1;
m_kProcessList.back().m_u16Num = 1;
}
++u32GCLIndex;
m_kRecorderList.resize(m_kRecorderList.size() + 1);
m_kRecorderList.back().m_u32CommandIndex = u32GCLIndex;
m_kRecorderList.back().m_kTaskList.clear();
bScene = false;
}
if (spCurrent != kCache.m_spRecorder)
{
m_kRecorderList.back().m_kTaskList.push_back(kCache.m_spRecorder);
spCurrent = kCache.m_spRecorder;
}
auto& rect = Get(kRectMap, GetResolution(kCache));
if (spViewport != rect.first)
{
m_kRecorderList.back().m_kTaskList.push_back(rect.first);
spViewport = rect.first;
}
if (spScissorRect != rect.second)
{
m_kRecorderList.back().m_kTaskList.push_back(rect.second);
spScissorRect = rect.second;
}
VeRenderer::FrameQuad& kQuad = (VeRenderer::FrameQuad&)*kClick.m_kPassList[k];
ID3D12RootSignature* pkRootSignature = nullptr;
ID3D12PipelineState* pkPipelineState = nullptr;
auto itRoot = kRenderer.m_kRootSignatureMap.find(kQuad.m_kRootSignature);
if(itRoot != kRenderer.m_kRootSignatureMap.end())
{
pkRootSignature = VeSmartPointerCast(VeRendererD3D12::RootSignatureD3D12,
itRoot->second)->m_pkRootSignature;
}
auto itPSO = kRenderer.m_kPipelineStateMap.find(kQuad.m_kPipelineState);
if (itPSO != kRenderer.m_kPipelineStateMap.end())
{
pkPipelineState = VeSmartPointerCast(VeRendererD3D12::PipelineStateD3D12,
itPSO->second)->m_pkPipelineState;
}
if (pkRootSignature && pkPipelineState)
{
RecordRenderQuad* pkQuad = VE_NEW RecordRenderQuad();
pkQuad->m_pkRootSignature = pkRootSignature;
pkQuad->m_pkPipelineState = pkPipelineState;
for (auto& itTab : kQuad.m_kTable)
{
bool bFinished = false;
for (auto context : kClick.m_kContextList)
{
if (context == itTab.second)
{
auto itRTRes = m_kResourceMap.find(itTab.second);
if (itRTRes != m_kResourceMap.end())
{
VeRenderTextureD3D12* pkTex = itRTRes->second;
if (pkTex->m_kSRVList.size())
{
pkQuad->m_kTable.push_back(std::make_pair(itTab.first, pkTex->m_kSRVList.front().m_hGPUHandle));
bFinished = true;
}
break;
}
}
}
if(!bFinished)
{
auto itRes = kRenderer.m_kResourceMap.find(itTab.second);
if (itRes != kRenderer.m_kResourceMap.end())
{
switch (itRes->second->GetDimension())
{
case VeRenderResource::DIMENSION_TEXTURE1D:
case VeRenderResource::DIMENSION_TEXTURE2D:
case VeRenderResource::DIMENSION_TEXTURE3D:
{
VeRenderTextureD3D12* pkTex = VeDynamicCast(VeRenderTextureD3D12, itRes->second.p());
if (pkTex && pkTex->m_kSRVList.size())
{
pkQuad->m_kTable.push_back(std::make_pair(itTab.first, pkTex->m_kSRVList.front().m_hGPUHandle));
}
}
break;
default:
break;
}
}
}
}
m_kRecorderList.back().m_kTaskList.push_back(pkQuad);
}
}
break;
case VeRenderer::PASS_SCENE:
{
VeRenderer::FrameScene& kScene = (VeRenderer::FrameScene&)*kClick.m_kPassList[k];
if (!bScene)
{
spCurrent = nullptr;
spViewport = nullptr;
spScissorRect = nullptr;
bScene = true;
}
m_kCameraList.resize(m_kCameraList.size() + 1);
m_kCameraList.back().m_u32CameraMask = VE_MASK(kScene.m_u32Camera);
m_kCameraList.back().m_kStageList.resize(kScene.m_u32Stage);
for (auto& stage : m_kCameraList.back().m_kStageList)
{
stage = u32GCLIndex + 1;
if (m_kProcessList.back().m_eType == TYPE_EXCUTE)
{
m_kProcessList.back().m_u16Num += u32ThreadNum;
}
else
{
m_kProcessList.resize(m_kProcessList.size() + 1);
m_kProcessList.back().m_eType = TYPE_EXCUTE;
m_kProcessList.back().m_u16Start = stage;
m_kProcessList.back().m_u16Num = u32ThreadNum;
}
u32GCLIndex += u32ThreadNum;
}
}
break;
default:
break;
}
}
if (bar.second)
{
if (bScene)
{
if (m_kProcessList.back().m_eType == TYPE_EXCUTE)
{
m_kProcessList.back().m_u16Num += 1;
}
else
{
m_kProcessList.resize(m_kProcessList.size() + 1);
m_kProcessList.back().m_eType = TYPE_EXCUTE;
m_kProcessList.back().m_u16Start = u32GCLIndex + 1;
m_kProcessList.back().m_u16Num = 1;
}
++u32GCLIndex;
m_kRecorderList.resize(m_kRecorderList.size() + 1);
m_kRecorderList.back().m_u32CommandIndex = u32GCLIndex;
m_kRecorderList.back().m_kTaskList.clear();
bScene = false;
}
m_kRecorderList.back().m_kTaskList.push_back(bar.second);
}
}
}
auto it = kResPathCache.find(nullptr);
if (it != kResPathCache.end())
{
if (it->second.size())
{
D3D12_RESOURCE_STATES eResPresent = GetState(it->second.back(), D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES);
RecordBarrier* pkBarrier = VE_NEW RecordBarrier();
for (VeSizeT i(0); i < VeRendererD3D12::FRAME_COUNT; ++i)
{
pkBarrier->m_akBarrierList[i].resize(pkBarrier->m_akBarrierList[i].size() + 1);
pkBarrier->m_akBarrierList[i].back().Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
pkBarrier->m_akBarrierList[i].back().Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE;
pkBarrier->m_akBarrierList[i].back().Transition.pResource = m_akFrameCache[i].m_pkBufferResource;
pkBarrier->m_akBarrierList[i].back().Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES;
pkBarrier->m_akBarrierList[i].back().Transition.StateBefore = eResPresent;
pkBarrier->m_akBarrierList[i].back().Transition.StateAfter = D3D12_RESOURCE_STATE_PRESENT;
}
if (bScene)
{
if (m_kProcessList.back().m_eType == TYPE_EXCUTE)
{
m_kProcessList.back().m_u16Num += 1;
}
else
{
m_kProcessList.resize(m_kProcessList.size() + 1);
m_kProcessList.back().m_eType = TYPE_EXCUTE;
m_kProcessList.back().m_u16Start = u32GCLIndex + 1;
m_kProcessList.back().m_u16Num = 1;
}
++u32GCLIndex;
m_kRecorderList.resize(m_kRecorderList.size() + 1);
m_kRecorderList.back().m_u32CommandIndex = u32GCLIndex;
m_kRecorderList.back().m_kTaskList.clear();
bScene = false;
}
m_kRecorderList.back().m_kTaskList.push_back(pkBarrier);
}
}
m_u32ThreadNum = u32ThreadNum;
ResizeDirectList(u32GCLIndex + 1);
}
inline std::vector<double> GetGradient(const int64_t x_index, const int64_t y_index, const int64_t z_index, const bool enable_edge_gradients=false) const
{
// Make sure the index is inside bounds
if ((x_index >= 0) && (y_index >= 0) && (z_index >= 0) && (x_index < GetNumXCells()) && (y_index < GetNumYCells()) && (z_index < GetNumZCells()))
{
// Make sure the index we're trying to query is one cell in from the edge
if ((x_index > 0) && (y_index > 0) && (z_index > 0) && (x_index < (GetNumXCells() - 1)) && (y_index < (GetNumYCells() - 1)) && (z_index < (GetNumZCells() - 1)))
{
double inv_twice_resolution = 1.0 / (2.0 * GetResolution());
double gx = (Get(x_index + 1, y_index, z_index) - Get(x_index - 1, y_index, z_index)) * inv_twice_resolution;
double gy = (Get(x_index, y_index + 1, z_index) - Get(x_index, y_index - 1, z_index)) * inv_twice_resolution;
double gz = (Get(x_index, y_index, z_index + 1) - Get(x_index, y_index, z_index - 1)) * inv_twice_resolution;
return std::vector<double>{gx, gy, gz};
}
// If we're on the edge, handle it specially
else if (enable_edge_gradients)
{
// Get the "best" indices we can use
int64_t low_x_index = std::max((int64_t)0, x_index - 1);
int64_t high_x_index = std::min(GetNumXCells() - 1, x_index + 1);
int64_t low_y_index = std::max((int64_t)0, y_index - 1);
int64_t high_y_index = std::min(GetNumYCells() - 1, y_index + 1);
int64_t low_z_index = std::max((int64_t)0, z_index - 1);
int64_t high_z_index = std::min(GetNumZCells() - 1, z_index + 1);
// Compute the axis increments
double x_increment = (high_x_index - low_x_index) * GetResolution();
double y_increment = (high_y_index - low_y_index) * GetResolution();
double z_increment = (high_z_index - low_z_index) * GetResolution();
// Compute the gradients for each axis - by default these are zero
double gx = 0.0;
double gy = 0.0;
double gz = 0.0;
// Only if the increments are non-zero do we compute the gradient of an axis
if (x_increment > 0.0)
{
double inv_x_increment = 1.0 / x_increment;
double high_x_value = Get(high_x_index, y_index, z_index);
double low_x_value = Get(low_x_index, y_index, z_index);
// Compute the gradient
gx = (high_x_value - low_x_value) * inv_x_increment;
}
if (y_increment > 0.0)
{
double inv_y_increment = 1.0 / y_increment;
double high_y_value = Get(x_index, high_y_index, z_index);
double low_y_value = Get(x_index, low_y_index, z_index);
// Compute the gradient
gy = (high_y_value - low_y_value) * inv_y_increment;
}
if (z_increment > 0.0)
{
double inv_z_increment = 1.0 / z_increment;
double high_z_value = Get(x_index, y_index, high_z_index);
double low_z_value = Get(x_index, y_index, low_z_index);
// Compute the gradient
gz = (high_z_value - low_z_value) * inv_z_increment;
}
// Assemble and return the computed gradient
return std::vector<double>{gx, gy, gz};
}
// Edge gradients disabled, return no gradient
else
{
return std::vector<double>();
}
}
// If we're out of bounds, return no gradient
else
{
return std::vector<double>();
}
}
void CLinuxRenderer::DrawAlpha(int x0, int y0, int w, int h, unsigned char *src, unsigned char *srca, int stride)
{
// OSD is drawn after draw_slice / put_image
// this means that the buffer has already been handed off to the RGB converter
// solution: have separate OSD textures
// if it's down the bottom, use sub alpha blending
// m_SubsOnOSD = (y0 > (int)(rs.bottom - rs.top) * 4 / 5);
//Sometimes happens when switching between fullscreen and small window
if( w == 0 || h == 0 )
{
CLog::Log(LOGINFO, "Zero dimensions specified to DrawAlpha, skipping");
return;
}
//use temporary rect for calculation to avoid messing with module-rect while other functions might be using it.
DRAWRECT osdRect;
RESOLUTION res = GetResolution();
if (w > m_iOSDTextureWidth)
{
//delete osdtextures so they will be recreated with the correct width
for (int i = 0; i < 2; ++i)
{
DeleteOSDTextures(i);
}
m_iOSDTextureWidth = w;
}
else
{
// clip to buffer
if (w > m_iOSDTextureWidth) w = m_iOSDTextureWidth;
if (h > g_settings.m_ResInfo[res].Overscan.bottom - g_settings.m_ResInfo[res].Overscan.top)
{
h = g_settings.m_ResInfo[res].Overscan.bottom - g_settings.m_ResInfo[res].Overscan.top;
}
}
// scale to fit screen
const RECT& rv = g_graphicsContext.GetViewWindow();
// Vobsubs are defined to be 720 wide.
// NOTE: This will not work nicely if we are allowing mplayer to render text based subs
// as it'll want to render within the pixel width it is outputting.
float xscale;
float yscale;
if(true /*isvobsub*/) // xbox_video.cpp is fixed to 720x576 osd, so this should be fine
{ // vobsubs are given to us unscaled
// scale them up to the full output, assuming vobsubs have same
// pixel aspect ratio as the movie, and are 720 pixels wide
float pixelaspect = m_fSourceFrameRatio * m_iSourceHeight / m_iSourceWidth;
xscale = (rv.right - rv.left) / 720.0f;
yscale = xscale * g_settings.m_ResInfo[res].fPixelRatio / pixelaspect;
}
else
{ // text subs/osd assume square pixels, but will render to full size of view window
// if mplayer could be fixed to use monitorpixelaspect when rendering it's osd
// this would give perfect output, however monitorpixelaspect currently doesn't work
// that way
xscale = 1.0f;
yscale = 1.0f;
}
// horizontal centering, and align to bottom of subtitles line
osdRect.left = (float)rv.left + (float)(rv.right - rv.left - (float)w * xscale) / 2.0f;
osdRect.right = osdRect.left + (float)w * xscale;
float relbottom = ((float)(g_settings.m_ResInfo[res].iSubtitles - g_settings.m_ResInfo[res].Overscan.top)) / (g_settings.m_ResInfo[res].Overscan.bottom - g_settings.m_ResInfo[res].Overscan.top);
osdRect.bottom = (float)rv.top + (float)(rv.bottom - rv.top) * relbottom;
osdRect.top = osdRect.bottom - (float)h * yscale;
int iOSDBuffer = (m_iOSDRenderBuffer + 1) % m_NumOSDBuffers;
//if new height is heigher than current osd-texture height, recreate the textures with new height.
if (h > m_iOSDTextureHeight[iOSDBuffer])
{
CSingleLock lock(g_graphicsContext);
DeleteOSDTextures(iOSDBuffer);
m_iOSDTextureHeight[iOSDBuffer] = h;
// Create osd textures for this buffer with new size
#if defined(HAS_SDL_OPENGL)
m_pOSDYTexture[iOSDBuffer] = new CGLTexture(SDL_CreateRGBSurface(SDL_HWSURFACE, m_iOSDTextureWidth, m_iOSDTextureHeight[iOSDBuffer], 32, RMASK, GMASK, BMASK, AMASK),false,true);
m_pOSDATexture[iOSDBuffer] = new CGLTexture(SDL_CreateRGBSurface(SDL_HWSURFACE, m_iOSDTextureWidth, m_iOSDTextureHeight[iOSDBuffer], 32, RMASK, GMASK, BMASK, AMASK),false,true);
if (m_pOSDYTexture[iOSDBuffer] == NULL || m_pOSDATexture[iOSDBuffer] == NULL)
#else
m_pOSDYTexture[iOSDBuffer] = SDL_CreateRGBSurface(SDL_HWSURFACE, m_iOSDTextureWidth, m_iOSDTextureHeight[iOSDBuffer],
32, RMASK, GMASK, BMASK, AMASK);
m_pOSDATexture[iOSDBuffer] = SDL_CreateRGBSurface(SDL_HWSURFACE, m_iOSDTextureWidth, m_iOSDTextureHeight[iOSDBuffer],
32, RMASK, GMASK, BMASK, AMASK);
if (m_pOSDYTexture[iOSDBuffer] == NULL || m_pOSDATexture[iOSDBuffer] == NULL)
#endif
{
CLog::Log(LOGERROR, "Could not create OSD/Sub textures");
DeleteOSDTextures(iOSDBuffer);
return;
}
else
{
CLog::Log(LOGDEBUG, "Created OSD textures (%i)", iOSDBuffer);
}
}
//We know the resources have been used at this point (or they are the second buffer, wich means they aren't in use anyways)
//reset these so the gpu doesn't try to block on these
#if defined(HAS_SDL_OPENGL)
int textureBytesSize = m_pOSDYTexture[iOSDBuffer]->textureWidth * m_pOSDYTexture[iOSDBuffer]->textureHeight * 4;
unsigned char *dst = new unsigned char[textureBytesSize];
unsigned char *dsta = new unsigned char[textureBytesSize];
//clear the textures
memset(dst, 0, textureBytesSize);
memset(dsta, 0, textureBytesSize);
//draw the osd/subs
int dstPitch = m_pOSDYTexture[iOSDBuffer]->textureWidth * 4;
CopyAlpha(w, h, src, srca, stride, dst, dsta, dstPitch);
m_pOSDYTexture[iOSDBuffer]->Update(m_pOSDYTexture[iOSDBuffer]->textureWidth,
m_pOSDYTexture[iOSDBuffer]->textureHeight,
dstPitch,
dst,
false);
m_pOSDATexture[iOSDBuffer]->Update(m_pOSDATexture[iOSDBuffer]->textureWidth,
m_pOSDATexture[iOSDBuffer]->textureHeight,
dstPitch,
dst,
false);
delete [] dst;
delete [] dsta;
#else
if (SDL_LockSurface(m_pOSDYTexture[iOSDBuffer]) == 0 &&
SDL_LockSurface(m_pOSDATexture[iOSDBuffer]) == 0)
{
//clear the textures
memset(m_pOSDYTexture[iOSDBuffer]->pixels, 0, m_pOSDYTexture[iOSDBuffer]->pitch*m_iOSDTextureHeight[iOSDBuffer]);
memset(m_pOSDATexture[iOSDBuffer]->pixels, 0, m_pOSDATexture[iOSDBuffer]->pitch*m_iOSDTextureHeight[iOSDBuffer]);
//draw the osd/subs
CopyAlpha(w, h, src, srca, stride, (BYTE*)m_pOSDYTexture[iOSDBuffer]->pixels, (BYTE*)m_pOSDATexture[iOSDBuffer]->pixels, m_pOSDYTexture[iOSDBuffer]->pitch);
}
SDL_UnlockSurface(m_pOSDYTexture[iOSDBuffer]);
SDL_UnlockSurface(m_pOSDATexture[iOSDBuffer]);
#endif
//set module variables to calculated values
m_OSDRect = osdRect;
m_OSDWidth = (float)w;
m_OSDHeight = (float)h;
m_OSDRendered = true;
}
void Context::init()
{
gHMDCTX = ohmd_ctx_create();
int num_devices = ohmd_ctx_probe(gHMDCTX);
if(num_devices < 0){
printf("failed to probe devices: %s\n", ohmd_ctx_get_error(gHMDCTX));
exit(-1);
}
if( num_devices==0 )
{
printf( "no HMD present!, goodbye!\n");
exit(-1);
}
printf( "num_devices<%d>\n", num_devices );
for( int i=0; i<num_devices; i++ )
{
auto vendor = GetDevString(i,OHMD_VENDOR);
auto product = GetDevString(i,OHMD_PRODUCT);
auto path = GetDevString(i,OHMD_PATH);
printf("hmd<%d> vendor<%s>\n", i, vendor.c_str() );
printf("hmd<%d> product<%s>\n", i, product.c_str() );
printf("hmd<%d> path<%s>\n", i, path.c_str() );
}
static const int khmddevno = 0;
auto vendor = GetDevString(khmddevno,OHMD_VENDOR);
auto product = GetDevString(khmddevno,OHMD_PRODUCT);
auto path = GetDevString(khmddevno,OHMD_PATH);
printf("hmd vendor<%s>\n", vendor.c_str() );
printf("hmd product<%s>\n", product.c_str() );
printf("hmd path<%s>\n", path.c_str() );
gHMDDEV = ohmd_list_open_device(gHMDCTX, khmddevno);
if(!gHMDDEV){
printf("failed to open device: %s\n", ohmd_ctx_get_error(gHMDCTX));
exit(-1);
}
Resolution res = GetResolution();
DistortionK dk = GetDistortionK();
float lens_sep = GetFloat(OHMD_LENS_HORIZONTAL_SEPARATION);
float lens_vctr = GetFloat(OHMD_LENS_VERTICAL_POSITION);
float fov_l = GetFloat(OHMD_LEFT_EYE_FOV);
float fov_r = GetFloat(OHMD_RIGHT_EYE_FOV);
float asp_l = GetFloat(OHMD_LEFT_EYE_ASPECT_RATIO);
float asp_r = GetFloat(OHMD_RIGHT_EYE_ASPECT_RATIO);
printf("hmd resolution<%d %d>\n", res.x, res.y );
printf("hmd lens separation<%f>\n", lens_sep );
printf("hmd lens vcenter<%f>\n", lens_vctr );
printf("hmd left FOV<%f>\n", fov_l );
printf("hmd left ASPECT<%f>\n", asp_l );
printf("hmd right FOV<%f>\n", fov_r );
printf("hmd right ASPECT<%f>\n", asp_r );
const auto&k = dk.k;
printf("hmd distortion K<%f %f %f %f %f %f>\n", k[0], k[1], k[2], k[3], k[4], k[5] );
ohmd_device_getf(gHMDDEV, OHMD_EYE_IPD, &gIPD);
gIPD = 0.043f;
printf( "IPD<%f>\n", gIPD );
}
