Update lost device support for D3DPOOL_DEFAULT and improve render to texture support.

panda/src/dxgsg8/dxGraphicsStateGuardian8.cxx

@@ -3374,7 +3374,7 @@ reset_d3d_device(D3DPRESENT_PARAMETERS *presentation_params,
     // regenerated, a prerequisite to calling Reset().  Actually, this
     // shouldn't be necessary, because all of our textures and
     // vbuffers are stored in the D3DPOOL_MANAGED memory class.
-    //    release_all();
+    release_all();
 
     // Just to be extra-conservative for now, we'll go ahead and
     // release the vbuffers and ibuffers at least; they're relatively
@@ -3382,6 +3382,8 @@ reset_d3d_device(D3DPRESENT_PARAMETERS *presentation_params,
     release_all_vertex_buffers();
     release_all_index_buffers();
 
+    _prepared_objects->update(this);
+
     hr = _d3d_device->Reset(&_presentation_reset);
     if (FAILED(hr)) {
       return hr;
@@ -3436,6 +3438,10 @@ check_cooperative_level() {
   switch (hr) {
   case D3DERR_DEVICENOTRESET:
     _dx_is_ready = false;
+
+    // call this just in case
+    _prepared_objects->update (this);
+
     hr = reset_d3d_device(&_screen->_presentation_params);
     if (FAILED(hr)) {
       // I think this shouldnt fail unless I've screwed up the

panda/src/dxgsg8/dxTextureContext8.cxx

@@ -630,26 +630,43 @@ create_texture(DXScreenData &scrn) {
     mip_level_count = 1;
   }
 
+  DWORD usage;
+  D3DPOOL pool;
+
+  if (_texture->get_render_to_texture ()) {
+    // REQUIRED
+    pool = D3DPOOL_DEFAULT;
+    usage = D3DUSAGE_RENDERTARGET;
+
+// *****
+    target_pixel_format = D3DFMT_X8R8G8B8;
+  }
+  else {
+    pool = D3DPOOL_MANAGED;
+//    pool = D3DPOOL_DEFAULT;
+    usage = 0;
+  }
+
   switch (_texture->get_texture_type()) {
   case Texture::TT_1d_texture:
   case Texture::TT_2d_texture:
     hr = scrn._d3d_device->CreateTexture
-      (target_width, target_height, mip_level_count, 0x0,
-       target_pixel_format, D3DPOOL_MANAGED, &_d3d_2d_texture);
+      (target_width, target_height, mip_level_count, usage,
+       target_pixel_format, pool, &_d3d_2d_texture);
     _d3d_texture = _d3d_2d_texture;
     break;
 
   case Texture::TT_3d_texture:
     hr = scrn._d3d_device->CreateVolumeTexture
-      (target_width, target_height, target_depth, mip_level_count, 0x0,
-       target_pixel_format, D3DPOOL_MANAGED, &_d3d_volume_texture);
+      (target_width, target_height, target_depth, mip_level_count, usage,
+       target_pixel_format, pool, &_d3d_volume_texture);
     _d3d_texture = _d3d_volume_texture;
     break;
 
   case Texture::TT_cube_map:
     hr = scrn._d3d_device->CreateCubeTexture
-      (target_width, mip_level_count, 0x0,
-       target_pixel_format, D3DPOOL_MANAGED, &_d3d_cube_texture);
+      (target_width, mip_level_count, usage,
+       target_pixel_format, pool, &_d3d_cube_texture);
     _d3d_texture = _d3d_cube_texture;
     break;
   }

panda/src/dxgsg8/dxVertexBufferContext8.cxx

@@ -190,6 +190,11 @@ DXVertexBufferContext8::
 void DXVertexBufferContext8::
 create_vbuffer(DXScreenData &scrn) {
   if (_vbuffer != NULL) {
+    if (dxgsg8_cat.is_debug()) {
+      dxgsg8_cat.debug()
+        << "deleting vertex buffer " << _vbuffer << "\n";
+    }
+
     RELEASE(_vbuffer, dxgsg8, "vertex buffer", RELEASE_ONCE);
     _vbuffer = NULL;
   }
@@ -199,7 +204,7 @@ create_vbuffer(DXScreenData &scrn) {
   HRESULT hr = scrn._d3d_device->CreateVertexBuffer
 //    (get_data()->get_data_size_bytes(), D3DUSAGE_WRITEONLY,
 //     _fvf, D3DPOOL_MANAGED, &_vbuffer);
-      (get_data()->get_data_size_bytes(), D3DUSAGE_WRITEONLY | D3DUSAGE_DYNAMIC,
+     (get_data()->get_data_size_bytes(), D3DUSAGE_WRITEONLY | D3DUSAGE_DYNAMIC,
      _fvf, D3DPOOL_DEFAULT, &_vbuffer);
   if (FAILED(hr)) {
     dxgsg8_cat.warning()

panda/src/dxgsg8/wdxGraphicsBuffer8.cxx

@@ -29,7 +29,6 @@
     // can be specified via the DXGraphicsStateGuardian8 member
     // _render_to_texture_d3d_format  default = D3DFMT_X8R8G8B8
 
-  // LOST DEVICE case for D3DPOOL_DEFAULT buffers
   // should check texture creation with CheckDepthStencilMatch
   // support copy from texture to ram?
     // check D3DCAPS2_DYNAMICTEXTURES
@@ -102,55 +101,59 @@ begin_frame() {
 ////////////////////////////////////////////////////////////////////
 void wdxGraphicsBuffer8::
 begin_render_texture() {
-  DXGraphicsStateGuardian8 *dxgsg;
-  DCAST_INTO_V(dxgsg, _gsg);
 
-  HRESULT hr;
-  bool state;
+  if (_gsg != (GraphicsStateGuardian *)NULL) {
 
-  state = false;
+    DXGraphicsStateGuardian8 *dxgsg;
+    DCAST_INTO_V(dxgsg, _gsg);
 
-  // save render context
-  hr = dxgsg -> _d3d_device -> GetRenderTarget (&_back_buffer);
-  if (SUCCEEDED (hr)) {
-    hr = dxgsg -> _d3d_device -> GetDepthStencilSurface (&_z_stencil_buffer);
-    if (SUCCEEDED (hr)) {
-      state = true;
-    }
-  }
+    HRESULT hr;
+    bool state;
 
-  // set render context
-  if (state && _dx_texture_context8)
-  {
-    int tex_index;
-    DXTextureContext8 *dx_texture_context8;
+    state = false;
 
-    // ***** assume 0 ???
-    tex_index = 0;
+    if (dxgsg -> _d3d_device) {
+      Texture *tex = get_texture(0);
+      tex->set_render_to_texture(true);
+      TextureContext *tc = tex->prepare_now(_gsg->get_prepared_objects(), _gsg);
 
-    Texture *tex = get_texture(tex_index);
+      _dx_texture_context8 = DCAST (DXTextureContext8, tc);
 
-    // ***** ??? CAST
+      // save render context
+      hr = dxgsg -> _d3d_device -> GetRenderTarget (&_back_buffer);
+      if (SUCCEEDED (hr)) {
+        hr = dxgsg -> _d3d_device -> GetDepthStencilSurface (&_z_stencil_buffer);
+        if (SUCCEEDED (hr)) {
+          state = true;
+        }
+      }
 
-    // use saved dx_texture_context8
-    dx_texture_context8 = _dx_texture_context8;
+      // set render context
+      if (state && _dx_texture_context8)
+      {
+        DXTextureContext8 *dx_texture_context8;
 
-    UINT mipmap_level;
+        // use saved dx_texture_context8
+        dx_texture_context8 = _dx_texture_context8;
 
-    mipmap_level = 0;
-    _direct_3d_surface = NULL;
+        UINT mipmap_level;
 
-    // render to texture 2D
-    IDirect3DTexture8 *direct_3d_texture;
+        mipmap_level = 0;
+        _direct_3d_surface = NULL;
 
-    direct_3d_texture = dx_texture_context8 -> _d3d_2d_texture;
-    if (direct_3d_texture) {
-      hr = direct_3d_texture -> GetSurfaceLevel (mipmap_level, &_direct_3d_surface);
-      if (SUCCEEDED (hr)) {
-        hr = dxgsg -> _d3d_device -> SetRenderTarget (_direct_3d_surface,
-          _z_stencil_buffer);
-        if (SUCCEEDED (hr)) {
+        // render to texture 2D
+        IDirect3DTexture8 *direct_3d_texture;
+
+        direct_3d_texture = dx_texture_context8 -> _d3d_2d_texture;
+        if (direct_3d_texture) {
+          hr = direct_3d_texture -> GetSurfaceLevel (mipmap_level, &_direct_3d_surface);
+          if (SUCCEEDED (hr)) {
+            hr = dxgsg -> _d3d_device -> SetRenderTarget (_direct_3d_surface,
+              _z_stencil_buffer);
+            if (SUCCEEDED (hr)) {
 
+            }
+          }
         }
       }
     }
@@ -168,54 +171,33 @@ begin_render_texture() {
 ////////////////////////////////////////////////////////////////////
 void wdxGraphicsBuffer8::
 end_render_texture() {
-  DXGraphicsStateGuardian8 *dxgsg;
-  DCAST_INTO_V(dxgsg, _gsg);
-
-// is this really needed ??? seems to work without it though
-/*
-
-  // Find the color texture, if there is one. That one can be bound to
-  // the framebuffer.  All others must be marked RTM_copy_to_texture.
-
-  int tex_index = -1;
-  for (int i=0; i<count_textures(); i++) {
-    if (get_rtm_mode(i) == RTM_bind_or_copy) {
-      if ((get_texture(i)->get_format() != Texture::F_depth_component)&&
-          (get_texture(i)->get_format() != Texture::F_stencil_index)&&
-          (tex_index < 0)) {
-        tex_index = i;
-      } else {
-        _textures[i]._rtm_mode = RTM_copy_texture;
-      }
-    }
-  }
 
-  if (tex_index >= 0) {
-    Texture *tex = get_texture(tex_index);
-    TextureContext *tc = tex->prepare_now(_gsg->get_prepared_objects(), _gsg);
-    nassertv(tc != (TextureContext *)NULL);
-  }
+  if (_gsg != (GraphicsStateGuardian *)NULL) {
 
-*/
+    DXGraphicsStateGuardian8 *dxgsg;
+    DCAST_INTO_V(dxgsg, _gsg);
 
-  // restore render context
-  HRESULT hr;
+    if (dxgsg -> _d3d_device) {
+      // restore render context
+      HRESULT hr;
 
-  if (_back_buffer) {
-    hr = dxgsg -> _d3d_device -> SetRenderTarget (_back_buffer,
-      _z_stencil_buffer);
-    if (SUCCEEDED (hr)) {
-      _back_buffer -> Release ( );
+      if (_back_buffer) {
+        hr = dxgsg -> _d3d_device -> SetRenderTarget (_back_buffer,
+          _z_stencil_buffer);
+        if (SUCCEEDED (hr)) {
+          _back_buffer -> Release ( );
+        }
+        _back_buffer = NULL;
+      }
+      if (_z_stencil_buffer) {
+        _z_stencil_buffer -> Release ( );
+        _z_stencil_buffer = NULL;
+      }
+      if (_direct_3d_surface) {
+        _direct_3d_surface -> Release ( );
+        _direct_3d_surface = NULL;
+      }
     }
-    _back_buffer = NULL;
-  }
-  if (_z_stencil_buffer) {
-    _z_stencil_buffer -> Release ( );
-    _z_stencil_buffer = NULL;
-  }
-  if (_direct_3d_surface) {
-    _direct_3d_surface -> Release ( );
-    _direct_3d_surface = NULL;
   }
 }
 
@@ -230,42 +212,49 @@ end_render_texture() {
 ////////////////////////////////////////////////////////////////////
 void wdxGraphicsBuffer8::
 select_cube_map(int cube_map_index) {
-  DXGraphicsStateGuardian8 *dxgsg;
-  DCAST_INTO_V(dxgsg, _gsg);
 
-  _cube_map_index = cube_map_index;
+  if (_gsg != (GraphicsStateGuardian *)NULL) {
 
-  HRESULT hr;
-  UINT mipmap_level;
-  int render_target_index;
-  DXTextureContext8 *dx_texture_context8;
+    DXGraphicsStateGuardian8 *dxgsg;
+    DCAST_INTO_V(dxgsg, _gsg);
 
-  mipmap_level = 0;
-  render_target_index = 0;
-  dx_texture_context8 = _dx_texture_context8;
+    _cube_map_index = cube_map_index;
 
-  if (_direct_3d_surface) {
-      _direct_3d_surface -> Release ( );
-      _direct_3d_surface = NULL;
-  }
+    HRESULT hr;
+    UINT mipmap_level;
+    int render_target_index;
+    DXTextureContext8 *dx_texture_context8;
 
-  // render to cubemap face
-  IDirect3DCubeTexture8 *direct_3d_cube_texture;
+    mipmap_level = 0;
+    render_target_index = 0;
+    dx_texture_context8 = _dx_texture_context8;
 
-  direct_3d_cube_texture = dx_texture_context8 -> _d3d_cube_texture;
-  if (direct_3d_cube_texture) {
-    if (_cube_map_index >= 0 && _cube_map_index < 6) {
-      hr = direct_3d_cube_texture -> GetCubeMapSurface (
-        (D3DCUBEMAP_FACES) _cube_map_index, mipmap_level, &_direct_3d_surface);
-      if (SUCCEEDED (hr)) {
-        hr = dxgsg -> _d3d_device -> SetRenderTarget (_direct_3d_surface,
-          _z_stencil_buffer);
-        if (SUCCEEDED (hr)) {
+    if (_direct_3d_surface) {
+        _direct_3d_surface -> Release ( );
+        _direct_3d_surface = NULL;
+    }
 
+    if (dxgsg -> _d3d_device) {
+
+      // render to cubemap face
+      IDirect3DCubeTexture8 *direct_3d_cube_texture;
+
+      direct_3d_cube_texture = dx_texture_context8 -> _d3d_cube_texture;
+      if (direct_3d_cube_texture) {
+        if (_cube_map_index >= 0 && _cube_map_index < 6) {
+          hr = direct_3d_cube_texture -> GetCubeMapSurface (
+            (D3DCUBEMAP_FACES) _cube_map_index, mipmap_level, &_direct_3d_surface);
+          if (SUCCEEDED (hr)) {
+            hr = dxgsg -> _d3d_device -> SetRenderTarget (_direct_3d_surface,
+              _z_stencil_buffer);
+            if (SUCCEEDED (hr)) {
+
+            }
+          }
+        } else {
+          // error: invalid cube map face index
         }
       }
-    } else {
-      // error: invalid cube map face index
     }
   }
 }
@@ -373,49 +362,23 @@ open_buffer() {
 
   // create texture
   int tex_index;
-  UINT texture_depth;
-  DXTextureContext8 *dx_texture_context8;
 
   state = false;
   _is_valid = false;
 
-// **** assume tex_index is 0 ???
+  // assume tex_index is 0
   tex_index = 0;
-  texture_depth = 1;
 
   Texture *tex = get_texture(tex_index);
-  TextureContext *tc = tex->prepare_now(_gsg->get_prepared_objects(), _gsg);
 
-// ***** ??? CAST
-  dx_texture_context8 = (DXTextureContext8 *) tc;
+  // SET render to texture
+  tex->set_render_to_texture(true);
 
-  // release managed texture
-  if (dx_texture_context8 -> _d3d_texture) {
-    dx_texture_context8 -> _d3d_texture -> Release ( );
-  }
-  dx_texture_context8 -> _d3d_texture = NULL;
-  dx_texture_context8 -> _d3d_2d_texture = NULL;
-  dx_texture_context8 -> _d3d_volume_texture = NULL;
-  dx_texture_context8 -> _d3d_cube_texture = NULL;
-
-  // save dx_texture_context8
-  _dx_texture_context8 = dx_texture_context8;
-
-  // create render texture
-  if (wdxGraphicsBuffer8::create_render_texture (
-    get_x_size ( ),
-    get_y_size ( ),
-    texture_depth,
-    dxgsg -> _render_to_texture_d3d_format,
-    dx_texture_context8,
-    dxgsg -> _d3d_device)) {
-
-    // override texture managed format
-    dx_texture_context8 -> _d3d_format = dxgsg -> _render_to_texture_d3d_format;
-    dx_texture_context8 -> _has_mipmaps = false;
+  TextureContext *tc = tex->prepare_now(_gsg->get_prepared_objects(), _gsg);
+  if (tc != NULL) {
+    _dx_texture_context8 = DCAST (DXTextureContext8, tc);
 
     _is_valid = true;
-
     state = true;
   }
 
@@ -442,75 +405,3 @@ process_1_event() {
   // Call window_proc
   DispatchMessage(&msg);
 }
-
-////////////////////////////////////////////////////////////////////
-//     Function: wdxGraphicsBuffer8::create_render_texture
-//       Access: Private
-//  Description: Creates a texture that can be rendered into
-////////////////////////////////////////////////////////////////////
-bool wdxGraphicsBuffer8::
-create_render_texture (UINT texture_width, UINT texture_height, UINT texture_depth, D3DFORMAT texture_format, DXTextureContext8 *dx_texture_context8, IDirect3DDevice8 *direct_3d_device)
-{
-  bool state;
-  HRESULT hr;
-  DWORD usage;
-  D3DPOOL pool;
-  UINT mip_level_count;
-  D3DFORMAT pixel_format;
-  int texture_type;
-
-  state = false;
-
-  texture_type = dx_texture_context8 -> _texture -> get_texture_type ( );
-
-  // assume 1 mip level
-  mip_level_count = 1;
-
-  // REQUIRED pool and usage
-  pool = D3DPOOL_DEFAULT;
-  usage = D3DUSAGE_RENDERTARGET;
-
-// ???
-// usage |= D3DUSAGE_DYNAMIC;
-
-  pixel_format = texture_format;
-
-  switch (texture_type)
-  {
-    case Texture::TT_2d_texture:
-        hr = direct_3d_device->CreateTexture
-        (texture_width, texture_height, mip_level_count, usage,
-        pixel_format, pool, &dx_texture_context8 -> _d3d_2d_texture);
-        dx_texture_context8 -> _d3d_texture = dx_texture_context8 -> _d3d_2d_texture;
-        break;
-
-    case Texture::TT_3d_texture:
-        // DX8 does not support rendering to volume textures so this should fail
-        hr = direct_3d_device->CreateVolumeTexture
-        (texture_width, texture_height, texture_depth, mip_level_count, usage,
-        pixel_format, pool, &dx_texture_context8 -> _d3d_volume_texture);
-        dx_texture_context8 -> _d3d_texture = dx_texture_context8 -> _d3d_volume_texture;
-        break;
-
-    case Texture::TT_cube_map:
-        hr = direct_3d_device->CreateCubeTexture
-        (texture_width, mip_level_count, usage,
-        pixel_format, pool, &dx_texture_context8 -> _d3d_cube_texture);
-        dx_texture_context8 -> _d3d_texture = dx_texture_context8 -> _d3d_cube_texture;
-        break;
-
-    default:
-        break;
-  }
-
-  if (FAILED(hr)) {
-    dxgsg8_cat.error()
-      << "create_render_texture failed" << D3DERRORSTRING(hr);
-  }
-  else {
-    state = true;
-  }
-
-  return state;
-}
-

panda/src/dxgsg8/wdxGraphicsBuffer8.h

@@ -79,9 +79,6 @@ public:
   }
   virtual TypeHandle force_init_type() {init_type(); return get_class_type();}
 
-private:
-  bool create_render_texture (UINT texture_width, UINT texture_height, UINT texture_depth, D3DFORMAT texture_format, DXTextureContext8 *dx_texture_context8, IDirect3DDevice8 *direct_3d_device);
-
 private:
   static TypeHandle _type_handle;
 

panda/src/dxgsg9/dxGraphicsStateGuardian9.cxx

@@ -3485,7 +3485,7 @@ reset_d3d_device(D3DPRESENT_PARAMETERS *presentation_params,
     // regenerated, a prerequisite to calling Reset().  Actually, this
     // shouldn't be necessary, because all of our textures and
     // vbuffers are stored in the D3DPOOL_MANAGED memory class.
-    //    release_all();
+    release_all();
 
     // Just to be extra-conservative for now, we'll go ahead and
     // release the vbuffers and ibuffers at least; they're relatively
@@ -3493,6 +3493,8 @@ reset_d3d_device(D3DPRESENT_PARAMETERS *presentation_params,
     release_all_vertex_buffers();
     release_all_index_buffers();
 
+    _prepared_objects->update(this);
+
     hr = _d3d_device->Reset(&_presentation_reset);
     if (FAILED(hr)) {
       return hr;
@@ -3547,6 +3549,10 @@ check_cooperative_level() {
   switch (hr) {
   case D3DERR_DEVICENOTRESET:
     _dx_is_ready = false;
+
+    // call this just in case
+    _prepared_objects->update (this);
+
     hr = reset_d3d_device(&_screen->_presentation_params);
     if (FAILED(hr)) {
       // I think this shouldnt fail unless I've screwed up the

panda/src/dxgsg9/dxTextureContext9.cxx

@@ -633,26 +633,43 @@ create_texture(DXScreenData &scrn) {
     mip_level_count = 1;
   }
 
+  DWORD usage;
+  D3DPOOL pool;
+
+  if (_texture->get_render_to_texture ()) {
+    // REQUIRED
+    pool = D3DPOOL_DEFAULT;
+    usage = D3DUSAGE_RENDERTARGET;
+
+// *****
+    target_pixel_format = D3DFMT_X8R8G8B8;
+  }
+  else {
+    pool = D3DPOOL_MANAGED;
+//    pool = D3DPOOL_DEFAULT;
+    usage = 0;
+  }
+
   switch (_texture->get_texture_type()) {
   case Texture::TT_1d_texture:
   case Texture::TT_2d_texture:
     hr = scrn._d3d_device->CreateTexture
-      (target_width, target_height, mip_level_count, 0x0,
-       target_pixel_format, D3DPOOL_MANAGED, &_d3d_2d_texture, NULL);
+      (target_width, target_height, mip_level_count, usage,
+       target_pixel_format, pool, &_d3d_2d_texture, NULL);
     _d3d_texture = _d3d_2d_texture;
     break;
 
   case Texture::TT_3d_texture:
     hr = scrn._d3d_device->CreateVolumeTexture
-      (target_width, target_height, target_depth, mip_level_count, 0x0,
-       target_pixel_format, D3DPOOL_MANAGED, &_d3d_volume_texture, NULL);
+      (target_width, target_height, target_depth, mip_level_count, usage,
+       target_pixel_format, pool, &_d3d_volume_texture, NULL);
     _d3d_texture = _d3d_volume_texture;
     break;
 
   case Texture::TT_cube_map:
     hr = scrn._d3d_device->CreateCubeTexture
-      (target_width, mip_level_count, 0x0,
-       target_pixel_format, D3DPOOL_MANAGED, &_d3d_cube_texture, NULL);
+      (target_width, mip_level_count, usage,
+       target_pixel_format, pool, &_d3d_cube_texture, NULL);
     _d3d_texture = _d3d_cube_texture;
     break;
   }

panda/src/dxgsg9/wdxGraphicsBuffer9.cxx

@@ -29,7 +29,6 @@
     // can be specified via the DXGraphicsStateGuardian9 member
     // _render_to_texture_d3d_format  default = D3DFMT_X8R8G8B8
 
-  // LOST DEVICE case for D3DPOOL_DEFAULT buffers
   // should check texture creation with CheckDepthStencilMatch
   // support copy from texture to ram?
     // check D3DCAPS2_DYNAMICTEXTURES
@@ -102,58 +101,62 @@ begin_frame() {
 ////////////////////////////////////////////////////////////////////
 void wdxGraphicsBuffer9::
 begin_render_texture() {
-  DXGraphicsStateGuardian9 *dxgsg;
-  DCAST_INTO_V(dxgsg, _gsg);
 
-  HRESULT hr;
-  bool state;
-  int render_target_index;
+  if (_gsg != (GraphicsStateGuardian *)NULL) {
 
-  state = false;
-  render_target_index = 0;
-
-  // save render context
-  hr = dxgsg -> _d3d_device -> GetRenderTarget (render_target_index,
-    &_back_buffer);
-  if (SUCCEEDED (hr)) {
-    hr = dxgsg -> _d3d_device -> GetDepthStencilSurface (&_z_stencil_buffer);
-    if (SUCCEEDED (hr)) {
-      state = true;
-    }
-  }
+    DXGraphicsStateGuardian9 *dxgsg;
+    DCAST_INTO_V(dxgsg, _gsg);
 
-  // set render context
-  if (state && _dx_texture_context9)
-  {
-    int tex_index;
-    DXTextureContext9 *dx_texture_context9;
+    HRESULT hr;
+    bool state;
+    int render_target_index;
 
-    // ***** assume 0 ???
-    tex_index = 0;
+    state = false;
+    render_target_index = 0;
 
-    Texture *tex = get_texture(tex_index);
+    if (dxgsg -> _d3d_device) {
+      Texture *tex = get_texture(0);
+      tex->set_render_to_texture(true);
+      TextureContext *tc = tex->prepare_now(_gsg->get_prepared_objects(), _gsg);
 
-    // ***** ??? CAST
+      _dx_texture_context9 = DCAST (DXTextureContext9, tc);
 
-    // use saved dx_texture_context9
-    dx_texture_context9 = _dx_texture_context9;
+      // save render context
+      hr = dxgsg -> _d3d_device -> GetRenderTarget (render_target_index,
+        &_back_buffer);
+      if (SUCCEEDED (hr)) {
+        hr = dxgsg -> _d3d_device -> GetDepthStencilSurface (&_z_stencil_buffer);
+        if (SUCCEEDED (hr)) {
+          state = true;
+        }
+      }
 
-    UINT mipmap_level;
+      // set render context
+      if (state && _dx_texture_context9)
+      {
+        DXTextureContext9 *dx_texture_context9;
 
-    mipmap_level = 0;
-    _direct_3d_surface = NULL;
+        // use saved dx_texture_context9
+        dx_texture_context9 = _dx_texture_context9;
 
-    // render to texture 2D
-    IDirect3DTexture9 *direct_3d_texture;
+        UINT mipmap_level;
 
-    direct_3d_texture = dx_texture_context9 -> _d3d_2d_texture;
-    if (direct_3d_texture) {
-      hr = direct_3d_texture -> GetSurfaceLevel (mipmap_level, &_direct_3d_surface);
-      if (SUCCEEDED (hr)) {
-        hr = dxgsg -> _d3d_device -> SetRenderTarget (render_target_index,
-          _direct_3d_surface);
-        if (SUCCEEDED (hr)) {
+        mipmap_level = 0;
+        _direct_3d_surface = NULL;
+
+        // render to texture 2D
+        IDirect3DTexture9 *direct_3d_texture;
+
+        direct_3d_texture = dx_texture_context9 -> _d3d_2d_texture;
+        if (direct_3d_texture) {
+          hr = direct_3d_texture -> GetSurfaceLevel (mipmap_level, &_direct_3d_surface);
+          if (SUCCEEDED (hr)) {
+            hr = dxgsg -> _d3d_device -> SetRenderTarget (render_target_index,
+              _direct_3d_surface);
+            if (SUCCEEDED (hr)) {
 
+            }
+          }
         }
       }
     }
@@ -171,59 +174,38 @@ begin_render_texture() {
 ////////////////////////////////////////////////////////////////////
 void wdxGraphicsBuffer9::
 end_render_texture() {
-  DXGraphicsStateGuardian9 *dxgsg;
-  DCAST_INTO_V(dxgsg, _gsg);
-
-// is this really needed ??? seems to work without it though
-/*
-
-  // Find the color texture, if there is one. That one can be bound to
-  // the framebuffer.  All others must be marked RTM_copy_to_texture.
-
-  int tex_index = -1;
-  for (int i=0; i<count_textures(); i++) {
-    if (get_rtm_mode(i) == RTM_bind_or_copy) {
-      if ((get_texture(i)->get_format() != Texture::F_depth_component)&&
-          (get_texture(i)->get_format() != Texture::F_stencil_index)&&
-          (tex_index < 0)) {
-        tex_index = i;
-      } else {
-        _textures[i]._rtm_mode = RTM_copy_texture;
-      }
-    }
-  }
 
-  if (tex_index >= 0) {
-    Texture *tex = get_texture(tex_index);
-    TextureContext *tc = tex->prepare_now(_gsg->get_prepared_objects(), _gsg);
-    nassertv(tc != (TextureContext *)NULL);
-  }
+    if (_gsg != (GraphicsStateGuardian *)NULL) {
 
-*/
+      DXGraphicsStateGuardian9 *dxgsg;
+      DCAST_INTO_V(dxgsg, _gsg);
 
-  // restore render context
-  HRESULT hr;
-  int render_target_index;
+      if (dxgsg -> _d3d_device) {
+      // restore render context
+      HRESULT hr;
+      int render_target_index;
 
-  render_target_index = 0;
+      render_target_index = 0;
 
-  if (_back_buffer) {
-    hr = dxgsg -> _d3d_device -> SetRenderTarget (render_target_index, _back_buffer);
-    if (SUCCEEDED (hr)) {
-      _back_buffer -> Release ( );
-    }
-    _back_buffer = NULL;
-  }
-  if (_z_stencil_buffer) {
-    hr = dxgsg -> _d3d_device -> SetDepthStencilSurface (_z_stencil_buffer);
-    if (SUCCEEDED (hr)) {
-      _z_stencil_buffer -> Release ( );
+      if (_back_buffer) {
+        hr = dxgsg -> _d3d_device -> SetRenderTarget (render_target_index, _back_buffer);
+        if (SUCCEEDED (hr)) {
+          _back_buffer -> Release ( );
+        }
+        _back_buffer = NULL;
+      }
+      if (_z_stencil_buffer) {
+        hr = dxgsg -> _d3d_device -> SetDepthStencilSurface (_z_stencil_buffer);
+        if (SUCCEEDED (hr)) {
+          _z_stencil_buffer -> Release ( );
+        }
+        _z_stencil_buffer = NULL;
+      }
+      if (_direct_3d_surface) {
+        _direct_3d_surface -> Release ( );
+        _direct_3d_surface = NULL;
+      }
     }
-    _z_stencil_buffer = NULL;
-  }
-  if (_direct_3d_surface) {
-    _direct_3d_surface -> Release ( );
-    _direct_3d_surface = NULL;
   }
 }
 
@@ -238,42 +220,49 @@ end_render_texture() {
 ////////////////////////////////////////////////////////////////////
 void wdxGraphicsBuffer9::
 select_cube_map(int cube_map_index) {
-  DXGraphicsStateGuardian9 *dxgsg;
-  DCAST_INTO_V(dxgsg, _gsg);
 
-  _cube_map_index = cube_map_index;
+  if (_gsg != (GraphicsStateGuardian *)NULL) {
 
-  HRESULT hr;
-  UINT mipmap_level;
-  int render_target_index;
-  DXTextureContext9 *dx_texture_context9;
+    DXGraphicsStateGuardian9 *dxgsg;
+    DCAST_INTO_V(dxgsg, _gsg);
 
-  mipmap_level = 0;
-  render_target_index = 0;
-  dx_texture_context9 = _dx_texture_context9;
+    _cube_map_index = cube_map_index;
 
-  if (_direct_3d_surface) {
-      _direct_3d_surface -> Release ( );
-      _direct_3d_surface = NULL;
-  }
+    HRESULT hr;
+    UINT mipmap_level;
+    int render_target_index;
+    DXTextureContext9 *dx_texture_context9;
 
-  // render to cubemap face
-  IDirect3DCubeTexture9 *direct_3d_cube_texture;
+    mipmap_level = 0;
+    render_target_index = 0;
+    dx_texture_context9 = _dx_texture_context9;
 
-  direct_3d_cube_texture = dx_texture_context9 -> _d3d_cube_texture;
-  if (direct_3d_cube_texture) {
-      if (_cube_map_index >= 0 && _cube_map_index < 6) {
-      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);
-        if (SUCCEEDED (hr)) {
+    if (_direct_3d_surface) {
+        _direct_3d_surface -> Release ( );
+        _direct_3d_surface = NULL;
+    }
 
+    if (dxgsg -> _d3d_device) {
+
+      // render to cubemap face
+      IDirect3DCubeTexture9 *direct_3d_cube_texture;
+
+      direct_3d_cube_texture = dx_texture_context9 -> _d3d_cube_texture;
+      if (direct_3d_cube_texture) {
+          if (_cube_map_index >= 0 && _cube_map_index < 6) {
+          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);
+            if (SUCCEEDED (hr)) {
+
+            }
+          }
+        } else {
+          // error: invalid cube map face index
         }
       }
-    } else {
-      // error: invalid cube map face index
     }
   }
 }
@@ -381,49 +370,23 @@ open_buffer() {
 
   // create texture
   int tex_index;
-  UINT texture_depth;
-  DXTextureContext9 *dx_texture_context9;
 
   state = false;
   _is_valid = false;
 
-// **** assume tex_index is 0 ???
+  // assume tex_index is 0
   tex_index = 0;
-  texture_depth = 1;
 
   Texture *tex = get_texture(tex_index);
-  TextureContext *tc = tex->prepare_now(_gsg->get_prepared_objects(), _gsg);
 
-// ***** ??? CAST
-  dx_texture_context9 = (DXTextureContext9 *) tc;
+  // SET render to texture
+  tex->set_render_to_texture(true);
 
-  // release managed texture
-  if (dx_texture_context9 -> _d3d_texture) {
-    dx_texture_context9 -> _d3d_texture -> Release ( );
-  }
-  dx_texture_context9 -> _d3d_texture = NULL;
-  dx_texture_context9 -> _d3d_2d_texture = NULL;
-  dx_texture_context9 -> _d3d_volume_texture = NULL;
-  dx_texture_context9 -> _d3d_cube_texture = NULL;
-
-  // save dx_texture_context9
-  _dx_texture_context9 = dx_texture_context9;
-
-  // create render texture
-  if (wdxGraphicsBuffer9::create_render_texture (
-    get_x_size ( ),
-    get_y_size ( ),
-    texture_depth,
-    dxgsg -> _render_to_texture_d3d_format,
-    dx_texture_context9,
-    dxgsg -> _d3d_device)) {
-
-    // override texture managed format
-    dx_texture_context9 -> _d3d_format = dxgsg -> _render_to_texture_d3d_format;
-    dx_texture_context9 -> _has_mipmaps = false;
+  TextureContext *tc = tex->prepare_now(_gsg->get_prepared_objects(), _gsg);
+  if (tc != NULL) {
+    _dx_texture_context9 = DCAST (DXTextureContext9, tc);
 
     _is_valid = true;
-
     state = true;
   }
 
@@ -451,74 +414,3 @@ process_1_event() {
   DispatchMessage(&msg);
 }
 
-////////////////////////////////////////////////////////////////////
-//     Function: wdxGraphicsBuffer9::create_render_texture
-//       Access: Private
-//  Description: Creates a texture that can be rendered into
-////////////////////////////////////////////////////////////////////
-bool wdxGraphicsBuffer9::
-create_render_texture (UINT texture_width, UINT texture_height, UINT texture_depth, D3DFORMAT texture_format, DXTextureContext9 *dx_texture_context9, IDirect3DDevice9 *direct_3d_device)
-{
-  bool state;
-  HRESULT hr;
-  DWORD usage;
-  D3DPOOL pool;
-  UINT mip_level_count;
-  D3DFORMAT pixel_format;
-  int texture_type;
-
-  state = false;
-
-  texture_type = dx_texture_context9 -> _texture -> get_texture_type ( );
-
-  // assume 1 mip level
-  mip_level_count = 1;
-
-  // REQUIRED pool and usage
-  pool = D3DPOOL_DEFAULT;
-  usage = D3DUSAGE_RENDERTARGET;
-
-// ???
-// usage |= D3DUSAGE_DYNAMIC;
-
-  pixel_format = texture_format;
-
-  switch (texture_type)
-  {
-    case Texture::TT_2d_texture:
-        hr = direct_3d_device->CreateTexture
-        (texture_width, texture_height, mip_level_count, usage,
-        pixel_format, pool, &dx_texture_context9 -> _d3d_2d_texture, NULL);
-        dx_texture_context9 -> _d3d_texture = dx_texture_context9 -> _d3d_2d_texture;
-        break;
-
-    case Texture::TT_3d_texture:
-        // DX9 does not support rendering to volume textures so this should fail
-        hr = direct_3d_device->CreateVolumeTexture
-        (texture_width, texture_height, texture_depth, mip_level_count, usage,
-        pixel_format, pool, &dx_texture_context9 -> _d3d_volume_texture, NULL);
-        dx_texture_context9 -> _d3d_texture = dx_texture_context9 -> _d3d_volume_texture;
-        break;
-
-    case Texture::TT_cube_map:
-        hr = direct_3d_device->CreateCubeTexture
-        (texture_width, mip_level_count, usage,
-        pixel_format, pool, &dx_texture_context9 -> _d3d_cube_texture, NULL);
-        dx_texture_context9 -> _d3d_texture = dx_texture_context9 -> _d3d_cube_texture;
-        break;
-
-    default:
-        break;
-  }
-
-  if (FAILED(hr)) {
-    dxgsg9_cat.error()
-      << "create_render_texture failed" << D3DERRORSTRING(hr);
-  }
-  else {
-    state = true;
-  }
-
-  return state;
-}
-

panda/src/dxgsg9/wdxGraphicsBuffer9.h

@@ -79,9 +79,6 @@ public:
   }
   virtual TypeHandle force_init_type() {init_type(); return get_class_type();}
 
-private:
-  bool create_render_texture (UINT texture_width, UINT texture_height, UINT texture_depth, D3DFORMAT texture_format, DXTextureContext9 *dx_texture_context9, IDirect3DDevice9 *direct_3d_device);
-
 private:
   static TypeHandle _type_handle;