Ejemplo n.º 1
0
//////////////////////////////////////////////////////////////////////
// Descripcion:
// - Crea una superficie compleja y le asocia una superficie para que
//   sea backbuffer. En caso de que todo vaya bien, se intentara
//   crear un objeto para controla el gamma.
// Parametros:
// - poDXDraw: Instancia a clase DXDraw con objeto DirectDraw.
// - ubNumBackBuffers: Numero de buffers en superficie compleja.
// - poBackBuffer: Puntero a superfice que hara de backbuffer y sera
//   de tipo ATTACHED, acabando asociada a la compleja creada.
// - wMem: Tipo de memoria en donde crear la superficie compleja.
// - bD3DSurface: True si la superficie se va a utilizar con un device
//   3D y false en caso contrario. Por defecto vale false.
// Devuelve:
// - true: Todo fue bien.
// - false: Existieron problemas
// Notas:
// - Este metodo es ideal para crear, rapidamente, un sistema de
//   intercambio con superficie compleja. Simplemente realiza las
//   dos llamadas que hay que efectuar por separado, aqui dentro.
// - En caso de que ya haya creada una superficie, la liberara.
////////////////////////////////////////////////////////////////////// 
bool DXDDSurfaceScreen::CreateComplex(const DXDraw* const poDXDraw, 
                                      const byte ubNumBackBuffers,
                                      DXDDSurfaceBack* const poBackBuffer, 
                                      const DXDDDefs::DXDDMemType& wMem,
                                      const bool bD3DSurface)
{
  // SOLO si existe puntero a la supercie pasada
  DXASSERT(NULL != poBackBuffer);
  // SOLO si superficie pasada no esta creada
  DXASSERT(DXDDDefs::SURFACETYPE_NOCREATED == poBackBuffer->GetType());
 
  if (CreateComplex(poDXDraw, ubNumBackBuffers, wMem, bD3DSurface)) {
    // Se ha creado la superficie compleja
    if(AttachToComplex(poBackBuffer)) {
      // Se logro asociar el backbuffer
      
      // Se guarda la referencia al BackBuffer
      m_poBackBuffer = poBackBuffer; 
            
      // Todo correcto
      return true;
    }
  }
  
  // Existieron problemas
  return false;
}
Ejemplo n.º 2
0
//////////////////////////////////////////////////////////////////////
// Descripcion:
// - Crea una superficie primaria simple.
// Parametros:
// - poDXDraw: Puntero a instancia DXDraw.
// - wMem: Memoria en donde crear la superficie primaria
// - bD3DSurface: True si la superficie se va a utilizar con un device
//   3D y false en caso contrario. Por defecto vale false.
// Devuelve:
// - true: Todo ha ido correctamente.
// - false: Ha ocurrido algun error.
// Notas:
// - Este metodo crea una superficie primaria simple. Una superficie
//   primaria simple NO puede tener asociados BackBuffer, pero si
//   puede realizar la operacion de Flip. 
// - Este tipo de superficies primarias NO son recomendadas 
//   para el trabajo a ventana completa
// - Este tipo de superficies primarias son las UNICAS que se pueden
//   utilizar en modo ventana.
////////////////////////////////////////////////////////////////////// 
bool DXDDSurfaceScreen::CreatePrimary(const DXDraw* const poDXDraw, 
                                      const DXDDDefs::DXDDMemType& wMem, 
                                      const bool bD3DSurface)
{
  // SOLO si hay instancia a DXDraw
  DXASSERT(NULL != poDXDraw);
  // SOLO si la superficie actual no es ATTACH
  DXASSERT(DXDDDefs::SURFACETYPE_ATTACHED != m_SurfaceType);

  DDSURFACEDESC2  desc;      // Estructura de definicion de surface
  DWORD           dwFlagMem; // Flag con el tipo de memoria
  
  // Inicializaciones
  memset(&desc, 0, sizeof(desc));
  desc.dwSize = sizeof(desc);  
    
  // Si la surface esta ocupada la libera
  if (m_pDDSurface != NULL) {
    Clean();
    Init();
  }    
  
  // Establece flags dependiendo del tipo de memoria
  switch(wMem)
  {
    case DXDDDefs::VIDEOMEM: // Memoria de video
      dwFlagMem = DDSCAPS_VIDEOMEMORY;
      break;
    case DXDDDefs::SYSTEMMEM: // Memoria de sistema
      dwFlagMem = DDSCAPS_SYSTEMMEMORY;
      break;    
   }
    
  // Establece la descripcion para una superficie 
  // primaria simple.
  desc.dwFlags = DDSD_CAPS;
  desc.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | dwFlagMem;
  // ¿Se va a utilizar con un device 3D?
  if (bD3DSurface) { desc.ddsCaps.dwCaps |= DDSCAPS_3DDEVICE; }  

  // Procede a crear la superficie
  m_CodeResult = poDXDraw->GetObj()->CreateSurface(&desc, 
                                                   &m_pDDSurface, 
                                                   NULL);
  if (FAILED(m_CodeResult)) {
    // Hay problemas
    DXDDError::DXDDErrorToString(m_CodeResult, m_sLastCode);
    return false;
  }
  
  // Obtiene datos sobre la superficie creada  
  m_dwWidth = poDXDraw->GetDisplayWidth();    
  m_dwHeight = poDXDraw->GetDisplayHeight();  
  m_SurfaceType = DXDDDefs::SURFACETYPE_PRIMARY;
  SetPixelFormat();         
  
  // Todo correcto
  return true;
}
Ejemplo n.º 3
0
//////////////////////////////////////////////////////////////////////
// Descripcion:
// - Configura los altavoces del usuario segun el tipo y 
//   su geometria.
// Parametros:
// - dwType: Tipo de altavoces entre:
//     * DSSPEAKER_HEADPHONE <auriculares>
//     * DSSPEAKER_MONO <sistema mono>
//     * DSSPEAKER_QUAD <sistema cuadrafonico>
//     * DSSPEAKER_STEREO <sistema estereo>
//     * DSSPEAKER_SURROUND <sistema doble surround>
// - dwGeometry: Geometria de los altavoces con respecto al usuario:
//     * DSSPEAKER_GEOMETRY_MIN <5 grados>
//     * DSSPEAKER_GEOMETRY_NARROW <10 grados>
//     * DSSPEAKER_GEOMETRY_WIDE <20 grados>
//     * DSSPEAKER_GEOMETRY_MAX <180 grados>
// Devuelve:
// true: Si se han configurado altavoces con exito.
// false: Si no se ha podido realizar la configuracion.
// Notas:
// - La informacion de la geometria solo tiene sentido cuando se
//   habla de altavoces stereo en cuyo caso tiene valor por defecto
//   a DSSPEAKER_GEOMETRY_WIDE.
// - En el caso de que no se haya creado objeto DirectSound el 
//   metodo retorna sin hacer nada.
////////////////////////////////////////////////////////////////////// 
bool DXSound::SetSpeakers(const dword dwType, 
						  const dword dwGeometry)
{  
  // SOLO si hay objeto DirectSound
  DXASSERT(m_lpDSObj != NULL);
  
    // Efectua configuracion de altavoces
  if (dwType != DSSPEAKER_STEREO) {
    // Configuracion no estereo
    m_CodeResult = m_lpDSObj->SetSpeakerConfig(dwType);
  }
  else {
    // Configuracion estereo; hay que combinar flags
    m_CodeResult = m_lpDSObj->SetSpeakerConfig(DSSPEAKER_COMBINED(dwType, dwGeometry));
  }

  // Comprueba resultado operacion
  if (FAILED(m_CodeResult)) {
    // Hay problemas
    DXDSError::DXDSErrorToString(m_CodeResult, m_sLastCode);
    return false;
  }
  
  // Todo correcto
  return true;
}
Ejemplo n.º 4
0
void CDxMonthPicker::ScrollLeft(int nMonthCount)
{
    int nYear = m_dtFirstMonth.GetYear();
    int nMonth = m_dtFirstMonth.GetMonth();
    if (nYear < 100 || (nYear == 100 && nMonth <= 2))
        return;
    int nYearNew = nYear - nMonthCount / 12;
    int nMonthNew = nMonth - nMonthCount % 12;
    if (nMonthNew < 1)
    {
        nMonthNew += 12;
        nYearNew--;
    }
    DXASSERT(nMonthNew >= 1 && nMonthNew <= 12);

    if (m_dtMinRange.GetStatus() == COleDateTime::valid)
    {
        if (nYearNew < m_dtMinRange.GetYear())
        {
            nYearNew = m_dtMinRange.GetYear();
            nMonthNew = m_dtMinRange.GetMonth();
        }

        if (m_dtMinRange.GetYear() == nYearNew)
        {
            if (nMonthNew < m_dtMinRange.GetMonth())
                nMonthNew = m_dtMinRange.GetMonth();
        }
    }

    m_dtFirstMonth.SetDate(nYearNew, nMonthNew, 1);

    Populate();
}
Ejemplo n.º 5
0
//////////////////////////////////////////////////////////////////////
// Descripcion:
// - Detiene el sonido que se este reproduciendo.
// Parametros:
// - bInitPlayPos: Indica si hay que parar y poner al comienzo el 
//   cursor de reproduccion. Por defecto vale true, con lo que se
//   llevara al comienzo el cursor si no se recibe otro parametro.
// Devuelve:
// - true: Si se detiene el sonido o el sonido.
// - false: Existe algun tipo de problema.
// Notas:
// - Aunque el buffer se encuentre sin ser reproducido, al llamar a 
//   stop se devolvera true si todo sale bien.
////////////////////////////////////////////////////////////////////// 
bool DXDSWAVSound::Stop(const bool bInitPlayPos)
{
  // SOLO si hay buffer secundario
  DXASSERT(m_lpDSBuffer != NULL);
  
  // Para la reproduccion
  m_CodeResult = m_lpDSBuffer->Stop();
  if (FAILED(m_CodeResult)) {
    // Hay problemas
    DXDSError::DXDSErrorToString(m_CodeResult, m_sLastCode);
    return false;
  }

  // ¿Hay que resituar el cursor?
  if (bInitPlayPos) {
    // Si; ademas de parar hay que situar el cursor en la pos. inicial
    if (!SetPlayPosition()) {
      // No se pudo situar el cursor; se establece codigo de error interno
      m_CodeResult = S_OK;
      m_sLastCode = DXDSBUFFERS_SETPLAYPOSERROR_MSG;
      return false;
    }
  }   

  // Todo correcto
  return true;
}
Ejemplo n.º 6
0
//////////////////////////////////////////////////////////////////////
// Descripcion:
// - Reproduce el sonido almacenado (o asociado) en el buffer secundario.
// Parametros:
// - dwFlags: Modo de reproduccion. Por defecto reproduce una 
//   sola vez el sonido y acaba. Si recibe DSBPLAY_LOOPING se
//   reproducira el sonido continuamente.
// Devuelve:
// - true: Si la operacion se realiza con exito.
// - false: Existe algun problema.
// Notas:
////////////////////////////////////////////////////////////////////// 
bool DXDSWAVSound::Play(const dword dwFlags)
{
  // SOLO si hay buffer secundario
  DXASSERT(m_lpDSBuffer != NULL);
  
  DWORD dwStatus;    // Estado del buffer secundario

  // Inicializaciones  
  dwStatus = m_lpDSBuffer->GetStatus(&dwStatus);

  // ¿Se ha perdido el buffer?
  if (dwStatus &  DSBSTATUS_BUFFERLOST) {
    // Si; se llama al metodo Restore para recuperarlo    
    Restore();
  }

  // Se pone en marcha el sonido
  m_CodeResult = m_lpDSBuffer->Play(0, 0, dwFlags);
  if (FAILED(m_CodeResult)) {
    // Hay problemas
    DXDSError::DXDSErrorToString(m_CodeResult, m_sLastCode);
    return false;
  } 

  // Todo correcto
  return true;
}
Ejemplo n.º 7
0
CString GetLocaleString(LCTYPE LCType, int nMaxLength)
{
    CString strResult;

    int nResult = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LCType , strResult.GetBufferSetLength(nMaxLength), nMaxLength);
    strResult.ReleaseBuffer();
    DXASSERT(strResult.GetLength() == nResult - 1);

    return strResult;
}
Ejemplo n.º 8
0
void XTPGetAsSystemTime(const COleDateTime& dateTime, SYSTEMTIME& st)
{
#if _MSC_VER < 1200
    UNREFERENCED_PARAMETER(dateTime);
    UNREFERENCED_PARAMETER(st);
    DXASSERT(FALSE);
#else
    dateTime.GetAsSystemTime(st);
#endif
}
Ejemplo n.º 9
0
//////////////////////////////////////////////////////////////////////
// Descripcion:
// - Elimina cualquier referencia posible a paleta en la superficie
// Parametros:
// Devuelve:
// - true: Todo ha ido bien.
// - false: Ha existido algun tipo de problema.
// Notas:
// - Solo valido si la superficie es de mas de 8 Bpp
////////////////////////////////////////////////////////////////////// 
bool DXDDSurfaceScreen::UnSetPalette(void)
{
  // SOLO si hay superficie creada
  DXASSERT(m_pDDSurface != NULL);  
  // SOLO si la superficie es de mas de 8 Bpp
  DXASSERT(GetBpp() > 8);
  
  // Si no tenia asociada paleta, retorna sin mas
  if (!m_bPalette) { return true; }

  // Procede a asociar la paleta
  m_CodeResult = m_pDDSurface->SetPalette(NULL);
  if (FAILED(m_CodeResult)) {
    // Hay problemas
    DXDDError::DXDDErrorToString(m_CodeResult, m_sLastCode);
    return false;
  }
  
  // Todo correcto
  return true;
}
Ejemplo n.º 10
0
//////////////////////////////////////////////////////////////////////
// Descripcion:
// - Comprueba si se esta reproduciendo, o no, el sonido.
// Parametros:
// Devuelve:
// - Si se esta reproduccion devuelve true y false en caso contrario.
// Notas:
////////////////////////////////////////////////////////////////////// 
bool DXDSWAVSound::IsPlaying(void)
{
  // SOLO si objeto creado
  DXASSERT(m_lpDSBuffer);
  
  // Vbles
  DWORD  dwStatus = 0; // Donde se recogera el status
  
  // Se toma el status y se comprueba
  m_lpDSBuffer->GetStatus(&dwStatus);  
  // Evalua la comprobacion
  return (dwStatus & DSBSTATUS_PLAYING) ? true : false;      
}
Ejemplo n.º 11
0
//////////////////////////////////////////////////////////////////////
// Descripcion:
// - Asocia una paleta a la superficie, siempre y cuando esta sea de
//   8 Bpp.
// Parametros:
// - poDXPalette: Instancia valida a clase DXDDPalette.
// Devuelve:
// - true: Todo ha ido bien.
// - false: Ha existido algun tipo de problema.
// Notas:
// - Recordar que es imprescindible que que la superficie sea de 8 Bpp.
// - Si se quiere quitar una paleta, basta con llamar a UnSetPalette.
// - Se pueden asociar multiples paletas a una superficie. El efecto
//   sera quitar la antigua y poner la nueva. De inmediato, se veran
//   los cambios en la informacion grafica de la superficie.
////////////////////////////////////////////////////////////////////// 
bool DXDDSurfaceScreen::SetPalette(DXDDPalette* const poDXPalette)
{
  // SOLO si hay superficie creada
  DXASSERT(m_pDDSurface != NULL);  
  // SOLO si poDXPalette es una instancia valida
  DXASSERT(poDXPalette != NULL);
  // SOLO si la superficie es de mas de 8 Bpp
  DXASSERT(GetBpp() > 8);

  // Procede a asociar la paleta
  m_CodeResult = m_pDDSurface->SetPalette(poDXPalette->GetObj());
  if (FAILED(m_CodeResult)) {
    // Hay problemas
    DXDDError::DXDDErrorToString(m_CodeResult, m_sLastCode);
    return false;
  }

  // Actualiza flags
  m_bPalette = true;
  
  // Todo correcto
  return true;
}
Ejemplo n.º 12
0
//////////////////////////////////////////////////////////////////////
// Descripcion:
// - Asocia una superficie invisible (back) a la superficie primaria
//   de tipo complejo creada.
// Parametros:
// - poAttachSurface: Superficie ATTACHED a asociar a la superficie 
//   primaria compleja.
// Devuelve:
// - true: Todo ha ido bien.
// - false: Han existido problemas.
// Notas:
// - Si ya hay una superficie back asociada, no se tendra de en
//   cuenta. Esto es asi, dado que hay operaciones que trabajan
//   con varias superficies ATTACH asociadas.
// - Se puede crear manualmente una superficie compleja utilizando
//   CreateComplex y despues este metodo.
// - La superficie rebida por parametro pasa a ser del tipo ATTACH y
//   sus atributos son adecuadamente cambiados en este metodo.
// - Se puede evitar el uso de CreateComplex y AttachToComplex, 
//   utilizando la version de CreateComplex que recibe los mismos
//   parametros que los dos primeros metodos citados.
////////////////////////////////////////////////////////////////////// 
bool DXDDSurfaceScreen::AttachToComplex(DXDDSurfaceBack* const poAttachSurface)
{
  // SOLO si hay superficie compleja creada
  DXASSERT (NULL != m_pDDSurface);
  DXASSERT (DXDDDefs::SURFACETYPE_COMPLEX == m_SurfaceType);
  // SOLO si existe puntero a la supercie pasada
  DXASSERT(NULL != poAttachSurface);
  // SOLO si superficie pasada no esta creada
  DXASSERT(DXDDDefs::SURFACETYPE_NOCREATED == poAttachSurface->GetType());
  
  DDSCAPS2    ddscaps; // Descripcion de superficie
  
  // Inicializaciones
  memset(&ddscaps, 0, sizeof(ddscaps));  

  // Establece descripcion
  ddscaps.dwCaps = DDSCAPS_BACKBUFFER;

  // Asocia superficie pasada a primaria compleja
  m_CodeResult = m_pDDSurface->GetAttachedSurface(&ddscaps,
                                                  &poAttachSurface->m_pDDSurface);
  if (FAILED(m_CodeResult)) {
    // Hay problemas
    DXDDError::DXDDErrorToString(m_CodeResult, m_sLastCode);
    return false;
  }    
  
  // Actualiza valores de superficie ATTACH pasada y asociada
  poAttachSurface->m_dwWidth = m_dwWidth;                 
  poAttachSurface->m_dwHeight = m_dwHeight;               
  SetPixelFormat();                                       
  poAttachSurface->m_SurfaceType = DXDDDefs::SURFACETYPE_ATTACHED; 
  
  // Todo correcto
  return true;
}
Ejemplo n.º 13
0
//////////////////////////////////////////////////////////////////////
// Descripcion:
// - Crea un nuevo buffer que utiliza los mismos recursos e informacion
//   que el recibido como parametro. Este metodo NO aloja en memoria un
//   fichero .wav.
// Parametros:
// - poDXSound: Objeto DirectSound.
// - poDSBufferSource: Buffer origen sobre el que realizar la duplicacion.
// Devuelve:
// - true: Si no ha existido ningun problema.
// - false: Si ha ocurrido algun problema en el parametro recibido o
//   bien al ir a duplicar.
// Notas:
// - MUY IMPORTANTE: La llamada a este metodo no siempre tendra exito.
//   DirectX no dejara crear un buffer duplicado en software si el
//   original esta en hardware.
// - Al duplicar un buffer, realmente se crea una referencia a otro
//   buffer ya existente pero pudiendo modificar sus atributos y 
//   pudiendo tocarlo o pararlo libremente. El unico problema
//   se derivara al querer cambiar el contenido del buffer. Realizar 
//   un cambio en el mismo afectara a todos los buffers duplicados 
//   que apunten a el, incluido el buffer original.
// - En el caso de que ya existiera un buffer secundario, este se
//   liberara.
////////////////////////////////////////////////////////////////////// 
bool DXDSWAVSound::Create(DXSound* const poDXSound, 
                          DXDSWAVBuffer* const poDSBufferSource)
{
  // SOLO si hay existencia de objeto DirectSound
  DXASSERT(poDXSound != NULL);
  DXASSERT(poDXSound->GetObj() != NULL);
  
  // Si ya existia buffer secundario se libera
  if (m_lpDSBuffer) { 
	Destroy(); 
  }

  // Duplica buffer
  m_CodeResult = poDXSound->GetObj()->DuplicateSoundBuffer(poDSBufferSource->GetObj(),
                                                           &m_lpDSBuffer);  
  if (FAILED(m_CodeResult)) {
    // Hay problemas
    DXDSError::DXDSErrorToString(m_CodeResult, m_sLastCode);
    return false;
  }

  // Todo correcto
  return true;
}
Ejemplo n.º 14
0
//////////////////////////////////////////////////////////////////////
// Descripcion:
// - Devuelve el valor actual del volumen del sonido.
// Parametros:
// - lVolume: Referencia a la vble en donde alojar el volumen.
// Devuelve:
// - plVolume: Valor del volumen.
// - Por funcion:
//        - true: Si todo se ha realizado con exito.
//        - false: si ha existido algun problema.
// Notas:
// - MUY IMPORTANTE: Para trabajar con este control es necesario
//   haber pasado al metodo Create el flag DSBCAPS_CTRLVOLUME.
////////////////////////////////////////////////////////////////////// 
bool DXDSWAVSound::GetVolume(LONG& lVolume)
{
  // SOLO si hay buffer secundario
  DXASSERT(m_lpDSBuffer != NULL);

  // Obtiene valor del volumen
  m_CodeResult = m_lpDSBuffer->GetVolume(&lVolume);
  if (FAILED(m_CodeResult)) {
    // Hay problemas
    DXDSError::DXDSErrorToString(m_CodeResult, m_sLastCode);
    return false;
  }

  // Todo correcto
  return true;
}
Ejemplo n.º 15
0
//////////////////////////////////////////////////////////////////////
// Descripcion:
// - Establece el valor para el sonido. Por defecto establece una
//   atenuacion a medio camino entre el volumen maximo y el volumen
//   minimo.
// Parametros:
// - lVolume: Volumen para el sonido. Cuanto mas proximo a cero 
//   menor atenuacion y mayor volumen. El valor maximo del sonido
//   se encuentra en DSBVOLUME_MAX y el minimo en DSBVOLUME_MIN.
// Devuelve:
// - true: Si la operacion se ha realizado con exito. 
// - false: Si ha existido algun problema al modificar el volumen.
// Notas:
// - MUY IMPORTANTE: Para trabajar con este control es necesario
//   haber pasado al metodo Create el flag DSBCAPS_CTRLVOLUME.
// - En caso de sobrepasar los maximos y minimos del sonido con 
//   lVolume se devolvera true y se acotara convenientemente.
////////////////////////////////////////////////////////////////////// 
bool DXDSWAVSound::SetVolume(const LONG& lVolume)
{
  // SOLO si hay buffer secundario
  DXASSERT(m_lpDSBuffer != NULL);

  // Establece volumen
  m_CodeResult = m_lpDSBuffer->SetVolume(lVolume);
  if (FAILED(m_CodeResult)) {
    // Hay problemas
    DXDSError::DXDSErrorToString(m_CodeResult, m_sLastCode);
    return false;
  }  
  
  // Todo correcto
  return true;
}
Ejemplo n.º 16
0
//////////////////////////////////////////////////////////////////////
// Descripcion:
// - Obtiene la posicion del puntero de lectura sobre el buffer.
// Parametros:
// - pdwPlayPos: Direccion de la vble en donde almacenar la
//   posicion de lectura.
// Devuelve:
// - dwPlayPos: Referencia a la vble donde depositar el valor.
// - Por funcion:
//       - true: Si la operacion ha salido con exito.
//       - false: Si ha ocurrido algun problema.
// Notas:
////////////////////////////////////////////////////////////////////// 
bool DXDSWAVSound::GetPlayPosition(DWORD& dwPlayPos)
{
  // SOLO si hay buffer secundario
  DXASSERT(m_lpDSBuffer != NULL);

  // Obtiene posicion de lectura
  m_CodeResult = m_lpDSBuffer->GetCurrentPosition(&dwPlayPos, NULL);
  if (FAILED(m_CodeResult)) {
    // Hay problemas
    DXDSError::DXDSErrorToString(m_CodeResult, m_sLastCode);
    return false;
  }

  // Todo correcto
  return true;
}
Ejemplo n.º 17
0
//////////////////////////////////////////////////////////////////////
// Descripcion:
// - Comprueba si el objeto esta creado sobre dispositivo hardware
//   o software.
// Parametros:
// Devuelve:
// - Si esta en hardware true. Si esta en software false.
// Notas:
////////////////////////////////////////////////////////////////////// 
bool DXDSWAVSound::IsInHardware(void)
{
  // SOLO si objeto creado
  DXASSERT(m_lpDSBuffer);

  // Toma la informacion del buffer para saber donde se ha alojado
  DSBCAPS dsbcaps;
  memset(&dsbcaps, 0, sizeof(DSBCAPS));
  dsbcaps.dwSize = sizeof(DSBCAPS);
  m_CodeResult = m_lpDSBuffer->GetCaps(&dsbcaps);
  if (FAILED(m_CodeResult)) {
    // Hay problemas
    DXDSError::DXDSErrorToString(m_CodeResult, m_sLastCode);
    return false;
  }

  // Retorna resultado
  if (dsbcaps.dwFlags & DSBCAPS_LOCHARDWARE) { return true; }
  return false;
}
Ejemplo n.º 18
0
//////////////////////////////////////////////////////////////////////
// Descripcion:
// - Realiza la operacion de intercambio de paginas en una superficie
//   primaria compleja (COMPLEX).
//   En caso de que se este trabajando con una superficie PRIMARY
//   que posea un backbuffer falso asociado, la operacion consistira
//   en copiar el contenido del backbuffer sobre la superficie primaria
//   mediante un simple bliteado.
// Parametros:
// - dwFlags: Flag con los que hacer el intercambio de paginas. Por
//   defecto es DDFLIP_WAIT. Consultar ayuda de DirectX para mas 
//   informacion.
// Devuelve:
// - true: Todo ha ido bien.
// - false: Ha existido algun tipo de problema.
// Notas:
// - Es imprescindible que este metodo lo llame la superficie
//   primaria (pero siempre y cuando, esta superficie primera tenga
//   un BackBuffer asociado, es decir, que sea una sup. compleja).
////////////////////////////////////////////////////////////////////// 
bool DXDDSurfaceScreen::Flip(const dword dwFlags)
{
  // SOLO si la superficie es COMPLEX
  DXASSERT(DXDDDefs::SURFACETYPE_COMPLEX == m_SurfaceType);
  
  // Se realiza el flip
  #ifdef _DEBUG
	m_CodeResult = m_pDDSurface->Flip(NULL, dwFlags);  
	if (FAILED(m_CodeResult)) {
	  // Hay problemas
	  DXDDError::DXDDErrorToString(m_CodeResult, m_sLastCode);
	  return false;
	} 
  #else
	m_pDDSurface->Flip(NULL, dwFlags);
  #endif
  
  //m_pDDSurface->BltFast(0, 0, m_poBackBuffer->GetObj(), NULL, DDBLTFAST_WAIT);
  //  Todo correcto
  return true;
}
Ejemplo n.º 19
0
BOOL ShiftDate_Month(COleDateTime &refDate, int nMonthCount)
{
    SYSTEMTIME sysDate;
    if (!GetAsSystemTime(refDate, sysDate))
        return FALSE;

    int nYearNew = sysDate.wYear + nMonthCount / 12;
    int nMonthNew = sysDate.wMonth + nMonthCount % 12;

    if (nMonthNew > 12)
    {
        nMonthNew -= 12 * (nMonthCount / abs(nMonthCount));
        nYearNew++;
    }
    else if (nMonthNew <= 0)
    {
        nYearNew--;
        nMonthNew += 12;

        DXASSERT(nMonthNew >= 1 && nMonthNew <= 12);
    }

    return COleDateTime::valid == refDate.SetDate(nYearNew, nMonthNew, 1);
}