diff --git a/panda/src/dxgsg9/dxGraphicsStateGuardian9.cxx b/panda/src/dxgsg9/dxGraphicsStateGuardian9.cxx
index b690f9cec9..604f11ceb6 100755
--- a/panda/src/dxgsg9/dxGraphicsStateGuardian9.cxx
+++ b/panda/src/dxgsg9/dxGraphicsStateGuardian9.cxx
@@ -66,8 +66,10 @@
 
 
 #define DEBUG_LRU false
-#define DEFAULT_ENABLE_LRU true
-#define DEFAULT_ENABLE_DX_MANAGED false
+
+
+#define DBG_S if (false) {
+#define DBG_E }
 
 
 TypeHandle DXGraphicsStateGuardian9::_type_handle;
@@ -529,6 +531,8 @@ do_clear(const RenderBuffer &buffer) {
   DWORD main_flags = 0;
   DWORD aux_flags = 0;
 
+DBG_S dxgsg9_cat.error ( ) << "DXGraphicsStateGuardian9::do_clear\n"; DBG_E
+
   //set appropriate flags
   if (buffer_type & RenderBuffer::T_back) {
     main_flags |=  D3DCLEAR_TARGET;
@@ -545,6 +549,9 @@ do_clear(const RenderBuffer &buffer) {
   }
 
   if ((main_flags | aux_flags) != 0) {
+
+DBG_S dxgsg9_cat.error ( ) << "ccccc DXGraphicsStateGuardian9::really do_clear\n"; DBG_E
+
     HRESULT hr = _d3d_device->Clear(0, NULL, main_flags | aux_flags, _d3dcolor_clear_value,
                                     _depth_clear_value, (DWORD)_stencil_clear_value);
     if (FAILED(hr) && main_flags == D3DCLEAR_TARGET && aux_flags != 0) {
@@ -593,6 +600,9 @@ do_clear(const RenderBuffer &buffer) {
 ////////////////////////////////////////////////////////////////////
 void DXGraphicsStateGuardian9::
 prepare_display_region() {
+
+// DBG_S dxgsg9_cat.error ( ) << "DXGraphicsStateGuardian9::PRE prepare_display_region\n"; DBG_E
+
   if (_current_display_region == (DisplayRegion*)0L) {
     dxgsg9_cat.error()
       << "Invalid NULL display region in prepare_display_region()\n";
@@ -600,9 +610,13 @@ prepare_display_region() {
   } else if (_current_display_region != _actual_display_region) {
     _actual_display_region = _current_display_region;
 
+// DBG_S dxgsg9_cat.error ( ) << "DXGraphicsStateGuardian9::prepare_display_region\n"; DBG_E
+
     int l, u, w, h;
     _actual_display_region->get_region_pixels_i(l, u, w, h);
 
+DBG_S dxgsg9_cat.error ( ) << "display_region " << l << " " << u << " "  << w << " "  << h << "\n"; DBG_E
+
     // Create the viewport
     D3DVIEWPORT9 vp = { l, u, w, h, 0.0f, 1.0f };
     HRESULT hr = _d3d_device->SetViewport(&vp);
@@ -701,35 +715,15 @@ prepare_lens() {
 bool DXGraphicsStateGuardian9::
 begin_frame() {
 
+DBG_S dxgsg9_cat.error ( ) << "^^^^^^^^^^^ begin_frame \n"; DBG_E
+
+  GraphicsStateGuardian::begin_frame();
+
   if (_lru)
   {
     _lru -> begin_frame ( );
   }
 
-  return GraphicsStateGuardian::begin_frame();
-}
-
-////////////////////////////////////////////////////////////////////
-//     Function: DXGraphicsStateGuardian9::begin_scene
-//       Access: Public, Virtual
-//  Description: Called between begin_frame() and end_frame() to mark
-//               the beginning of drawing commands for a "scene"
-//               (usually a particular DisplayRegion) within a frame.
-//               All 3-D drawing commands, except the clear operation,
-//               must be enclosed within begin_scene() .. end_scene().
-//
-//               The return value is true if successful (in which case
-//               the scene will be drawn and end_scene() will be
-//               called later), or false if unsuccessful (in which
-//               case nothing will be drawn and end_scene() will not
-//               be called).
-////////////////////////////////////////////////////////////////////
-bool DXGraphicsStateGuardian9::
-begin_scene() {
-  if (!GraphicsStateGuardian::begin_scene()) {
-    return false;
-  }
-
   HRESULT hr = _d3d_device->BeginScene();
 
   if (FAILED(hr)) {
@@ -753,6 +747,54 @@ begin_scene() {
   return true;
 }
 
+////////////////////////////////////////////////////////////////////
+//     Function: DXGraphicsStateGuardian9::begin_scene
+//       Access: Public, Virtual
+//  Description: Called between begin_frame() and end_frame() to mark
+//               the beginning of drawing commands for a "scene"
+//               (usually a particular DisplayRegion) within a frame.
+//               All 3-D drawing commands, except the clear operation,
+//               must be enclosed within begin_scene() .. end_scene().
+//
+//               The return value is true if successful (in which case
+//               the scene will be drawn and end_scene() will be
+//               called later), or false if unsuccessful (in which
+//               case nothing will be drawn and end_scene() will not
+//               be called).
+////////////////////////////////////////////////////////////////////
+bool DXGraphicsStateGuardian9::
+begin_scene() {
+  if (!GraphicsStateGuardian::begin_scene()) {
+    return false;
+  }
+
+DBG_S dxgsg9_cat.error ( ) << "DXGraphicsStateGuardian9::begin_scene\n"; DBG_E
+
+/*
+  HRESULT hr = _d3d_device->BeginScene();
+
+  if (FAILED(hr)) {
+    if (hr == D3DERR_DEVICELOST) {
+      if (dxgsg9_cat.is_debug()) {
+        dxgsg9_cat.debug()
+          << "BeginScene returns D3DERR_DEVICELOST" << endl;
+      }
+
+      check_cooperative_level();
+
+    } else {
+      dxgsg9_cat.error()
+        << "BeginScene failed, unhandled error hr == "
+        << D3DERRORSTRING(hr) << endl;
+      throw_event("panda3d-render-error");
+    }
+    return false;
+  }
+*/
+
+  return true;
+}
+
 ////////////////////////////////////////////////////////////////////
 //     Function: DXGraphicsStateGuardian9::end_scene
 //       Access: Public, Virtual
@@ -764,6 +806,10 @@ begin_scene() {
 ////////////////////////////////////////////////////////////////////
 void DXGraphicsStateGuardian9::
 end_scene() {
+
+DBG_S dxgsg9_cat.error ( ) << "DXGraphicsStateGuardian9::end_scene\n"; DBG_E
+
+/*
   HRESULT hr = _d3d_device->EndScene();
 
   if (FAILED(hr)) {
@@ -781,6 +827,8 @@ end_scene() {
     }
     return;
   }
+*/
+
 }
 
 ////////////////////////////////////////////////////////////////////
@@ -793,6 +841,26 @@ end_scene() {
 void DXGraphicsStateGuardian9::
 end_frame() {
 
+DBG_S dxgsg9_cat.error ( ) << "@@@@@@@@@@ end_frame \n"; DBG_E
+
+  HRESULT hr = _d3d_device->EndScene();
+
+  if (FAILED(hr)) {
+    if (hr == D3DERR_DEVICELOST) {
+      if (dxgsg9_cat.is_debug()) {
+        dxgsg9_cat.debug()
+          << "EndScene returns DeviceLost\n";
+      }
+      check_cooperative_level();
+
+    } else {
+      dxgsg9_cat.error()
+        << "EndScene failed, unhandled error hr == " << D3DERRORSTRING(hr);
+      throw_event("panda3d-render-error");
+    }
+    return;
+  }
+
   if (_lru)
   {
     int frames;
@@ -3906,6 +3974,9 @@ show_frame() {
     return;
   }
 
+DBG_S dxgsg9_cat.error ( ) << "- - - - - DXGraphicsStateGuardian9::show_frame\n"; DBG_E
+
+
   HRESULT hr;
 
   if (_swap_chain) {
diff --git a/panda/src/dxgsg9/wdxGraphicsBuffer9.cxx b/panda/src/dxgsg9/wdxGraphicsBuffer9.cxx
index 222b9e76e1..a4e78d463c 100644
--- a/panda/src/dxgsg9/wdxGraphicsBuffer9.cxx
+++ b/panda/src/dxgsg9/wdxGraphicsBuffer9.cxx
@@ -23,17 +23,12 @@
 
 
 // ISSUES:
-  // size issues
-    // texture size must not exeeed the original frame buffer width
-    // or height due to the size of the original depth/stencil buffer
-  // render to texure format
-    // can be specified via the DXGraphicsStateGuardian9 member
-    // _render_to_texture_d3d_format  default = D3DFMT_X8R8G8B8
-
   // should check texture creation with CheckDepthStencilMatch
   // support copy from texture to ram?
     // check D3DCAPS2_DYNAMICTEXTURES
 
+#define DBG_S if (false) {
+#define DBG_E }
 #define FL << "\n" << __FILE__ << " " << __LINE__ << "\n"
 
 TypeHandle wdxGraphicsBuffer9::_type_handle;
@@ -71,6 +66,7 @@ wdxGraphicsBuffer9(GraphicsPipe *pipe, GraphicsStateGuardian *gsg,
 ////////////////////////////////////////////////////////////////////
 wdxGraphicsBuffer9::
 ~wdxGraphicsBuffer9() {
+  this -> close_buffer ( );
 }
 
 ////////////////////////////////////////////////////////////////////
@@ -88,6 +84,8 @@ begin_frame() {
     return false;
   }
 
+DBG_S dxgsg9_cat.error ( ) << "wdxGraphicsBuffer9::begin_frame\n"; DBG_E
+
   DXGraphicsStateGuardian9 *dxgsg;
   DCAST_INTO_R(dxgsg, _gsg, false);
 
@@ -118,6 +116,8 @@ begin_render_texture() {
     state = false;
     render_target_index = 0;
 
+DBG_S dxgsg9_cat.error ( ) << "wdxGraphicsBuffer9::begin_render_texture\n"; DBG_E
+
     if (dxgsg -> _d3d_device) {
       Texture *tex = get_texture(0);
       tex->set_render_to_texture(true);
@@ -166,6 +166,13 @@ begin_render_texture() {
                 hr = dxgsg -> _d3d_device -> SetDepthStencilSurface (this -> _new_z_stencil_surface);
                 if (SUCCEEDED (hr)) {
 
+                } else {
+                  dxgsg9_cat.error ( ) << "SetDepthStencilSurface " << D3DERRORSTRING(hr) FL;
+                }
+              } else {
+                hr = dxgsg -> _d3d_device -> SetDepthStencilSurface (_z_stencil_buffer);
+                if (SUCCEEDED (hr)) {
+
                 } else {
                   dxgsg9_cat.error ( ) << "SetDepthStencilSurface " << D3DERRORSTRING(hr) FL;
                 }
@@ -194,13 +201,15 @@ begin_render_texture() {
 void wdxGraphicsBuffer9::
 end_render_texture() {
 
-    if (_gsg != (GraphicsStateGuardian *)NULL) {
+DBG_S dxgsg9_cat.error ( ) << "wdxGraphicsBuffer9::end_render_texture\n"; DBG_E
 
-      DXGraphicsStateGuardian9 *dxgsg;
-      DCAST_INTO_V(dxgsg, _gsg);
+  if (_gsg != (GraphicsStateGuardian *)NULL) {
 
-      if (dxgsg -> _d3d_device) {
-      // restore render context
+    DXGraphicsStateGuardian9 *dxgsg;
+    DCAST_INTO_V(dxgsg, _gsg);
+
+    if (dxgsg -> _d3d_device) {
+    // restore render context
       HRESULT hr;
       int render_target_index;
 
@@ -276,17 +285,26 @@ select_cube_map(int cube_map_index) {
           hr = direct_3d_cube_texture -> GetCubeMapSurface (
             (D3DCUBEMAP_FACES) _cube_map_index, mipmap_level, &_direct_3d_surface);
           if (SUCCEEDED (hr)) {
-            hr = dxgsg -> _d3d_device -> SetRenderTarget (render_target_index,
-              _direct_3d_surface);
+            hr = dxgsg -> _d3d_device -> SetRenderTarget (render_target_index, _direct_3d_surface);
             if (SUCCEEDED (hr)) {
               if (this -> _new_z_stencil_surface) {
-                hr = dxgsg -> _d3d_device -> SetDepthStencilSurface (this -> _new_z_stencil_surface);
+                hr = dxgsg -> _d3d_device -> SetDepthStencilSurface (_new_z_stencil_surface);
+                if (SUCCEEDED (hr)) {
+
+                } else {
+                  dxgsg9_cat.error ( ) << "SetDepthStencilSurface " << D3DERRORSTRING(hr) FL;
+                }
+              } else {
+                hr = dxgsg -> _d3d_device -> SetDepthStencilSurface (_z_stencil_buffer);
                 if (SUCCEEDED (hr)) {
 
                 } else {
                   dxgsg9_cat.error ( ) << "SetDepthStencilSurface " << D3DERRORSTRING(hr) FL;
                 }
               }
+
+DBG_S dxgsg9_cat.error ( ) << "select_cube_map " << _cube_map_index << "\n";  DBG_E
+
             } else {
               dxgsg9_cat.error ( ) << "SetRenderTarget " << D3DERRORSTRING(hr) FL;
             }
@@ -294,7 +312,6 @@ select_cube_map(int cube_map_index) {
             dxgsg9_cat.error ( ) << "GetCubeMapSurface " << D3DERRORSTRING(hr) FL;
           }
         } else {
-          // error: invalid cube map face index
           dxgsg9_cat.error ( ) << "Invalid Cube Map Face Index " << _cube_map_index FL;
         }
       }
@@ -317,6 +334,8 @@ make_current() {
   DCAST_INTO_V(dxgsg, _gsg);
 
   // do nothing here
+DBG_S dxgsg9_cat.error ( ) << "wdxGraphicsBuffer9::make_current\n"; DBG_E
+
 }
 
 ////////////////////////////////////////////////////////////////////
@@ -420,64 +439,74 @@ open_buffer() {
 
   Texture *tex = get_texture(tex_index);
 
-  // SET render to texture
+  // render to texture must be set
   tex->set_render_to_texture(true);
 
   TextureContext *tc = tex->prepare_now(_gsg->get_prepared_objects(), _gsg);
   if (tc != NULL) {
+    HRESULT hr;
+    IDirect3DSurface9 *_depth_stencil_surface;
+
     _dx_texture_context9 = DCAST (DXTextureContext9, tc);
 
-// ***** CREATE A DEPTH STENCIL BUFFER IF NEEDED
-
-HRESULT hr;
-IDirect3DSurface9 *_depth_stencil_surface;
-
-hr = dxgsg -> _d3d_device -> GetDepthStencilSurface (&_depth_stencil_surface);
-if (SUCCEEDED  (hr))
-{
-  D3DSURFACE_DESC surface_description;
-
-  hr = _depth_stencil_surface -> GetDesc (&surface_description);
-  if (SUCCEEDED  (hr))
-  {
-    UINT width;
-    UINT height;
-    D3DFORMAT format;
-    D3DMULTISAMPLE_TYPE multisample_type;
-    DWORD multisample_quality;
-    BOOL discard;
-
-    width = tex -> get_x_size ( );
-    height = tex -> get_y_size ( );
-    format = surface_description.Format;
-    multisample_type = surface_description.MultiSampleType;
-    multisample_quality = surface_description.MultiSampleQuality;
-    discard = true;
-
-    hr = dxgsg -> _d3d_device -> CreateDepthStencilSurface (
-      width, height, format, multisample_type, multisample_quality,
-      discard, &this -> _new_z_stencil_surface, NULL);
-    if (SUCCEEDED  (hr)) {
-
-    } else {
-      dxgsg9_cat.error ( ) << "GetDesc " << D3DERRORSTRING(hr) FL;
-    }
-  }
-  else
-  {
-    dxgsg9_cat.error ( ) << "GetDepthStencilSurface " << D3DERRORSTRING(hr) FL;
-  }
-
-  _depth_stencil_surface -> Release ( );
-}
-else
-{
-  dxgsg9_cat.error ( ) << "GetDepthStencilSurface " << D3DERRORSTRING(hr) FL;
-}
-
+    // create a depth stencil buffer if needed
+    hr = dxgsg -> _d3d_device -> GetDepthStencilSurface (&_depth_stencil_surface);
+    if (SUCCEEDED  (hr))
     {
+      D3DSURFACE_DESC surface_description;
+
+      // get and copy the current depth stencil's parameters for the new buffer
+      hr = _depth_stencil_surface -> GetDesc (&surface_description);
+      if (SUCCEEDED  (hr)) {
+        UINT width;
+        UINT height;
+        D3DFORMAT format;
+        D3DMULTISAMPLE_TYPE multisample_type;
+        DWORD multisample_quality;
+        BOOL discard;
+
+        width = tex -> get_x_size ( );
+        height = tex -> get_y_size ( );
+
+DBG_S dxgsg9_cat.error ( ) << "-------------RTT SIZE " << "t width " << width << " t height " << height FL; DBG_E
+
+        if (surface_description.Width < width || surface_description.Height < height) {
+          format = surface_description.Format;
+          multisample_type = surface_description.MultiSampleType;
+          multisample_quality = surface_description.MultiSampleQuality;
+          discard = false;
+
+          hr = dxgsg -> _d3d_device -> CreateDepthStencilSurface (
+            width, height, format, multisample_type, multisample_quality,
+            discard, &this -> _new_z_stencil_surface, NULL);
+          if (SUCCEEDED  (hr)) {
+
+DBG_S dxgsg9_cat.error ( ) << "-------------OK CreatedDepthStencilSurface " << D3DERRORSTRING(hr) FL; DBG_E
+
+            state = true;
+
+          } else {
+            dxgsg9_cat.error ( ) << "CreateDepthStencilSurface " << D3DERRORSTRING(hr) FL;
+          }
+        }
+        else {
+          // no need to create a separate depth stencil buffer since
+          // the current depth stencil buffer size is big enough
+          state = true;
+        }
+      }
+      else {
+        dxgsg9_cat.error ( ) << "GetDesc " << D3DERRORSTRING(hr) FL;
+      }
+
+      _depth_stencil_surface -> Release ( );
+    }
+    else {
+      dxgsg9_cat.error ( ) << "GetDepthStencilSurface " << D3DERRORSTRING(hr) FL;
+    }
+
+    if (state) {
       _is_valid = true;
-      state = true;
     }
   }