使用智能指针对纹理对象进行大规模包装,对于底层实现

轩辕崇正

为了解决纹理共享使用带来的销毁冲突问题，我使用了智能指针，而我发现，我得把所有纹理全部统一成智能指针，要不很麻烦.
但我仔细想来，所有纹理对象都需要用这个指针来包装一下,对于一个引擎的底层实现来讲,是否过于复杂和冗于了?
(我感觉底层实现应该尽可能精简和高效,少用一些封装,特别是大规模数量的对象.)

Asura_Xiu

IDirect3DTexture 是 com 接口吧
提供有 AddRef 和 Release
你只需要在每个引用此纹理时 AddRef
销毁的时候尽情 Release
com 计数就会完美解决了

游戏阿家

用智能指针~~你得小心哟~~

??b我心

智能指针的封装并不复杂，我看很多开源引擎的资源管理策略都是用smart_ptr做的．

轩辕崇正

??b我心: Re:使用智能指针对纹理对象进行大规模包装,对于底层实现是否合适??

智能指针的封装并不复杂，我看很多开源引擎的资源管理策略都是用smart_ptr做的．

恩，已经全部应用了智能指针了。

游戏阿家

楼主现在用的具体是什么智能指针? Boost的? STL的? 自己实现的?

轩辕崇正

游戏阿家: Re:使用智能指针对纹理对象进行大规模包装,对于底层实现是否合适??

楼主现在用的具体是什么智能指针? Boost的? STL的? 自己实现的?

自己随便写的：

1. 
   
2. //-------------------------------------------------------------------
   
3. // CZSharePtr 共享指针
   
4. //-------------------------------------------------------------------
   
5. enum EMEMORYTYPE
   
6. {
   
7.         MT_NEW        = 0,
   
8.         MT_MALLOC        = 1,
   
9. };
   
10. 
    
11. template <typename T, EMEMORYTYPE type>
    
12. class CZSharePtr
    
13. {
    
14. public:
    
15.         CZSharePtr(int null=0) : m_pPoint(NULL), m_pRefCount(NULL) {}
    
16.         ~CZSharePtr()        {        Release();        }
    
17. 
    
18.         void Release()
    
19.         {
    
20.                 if (m_pPoint == NULL)        return;
    
21.                 if (--(*m_pRefCount) == 0)
    
22.                 {
    
23.                         switch (type)
    
24.                         {
    
25.                         case MT_NEW:
    
26.                                 delete m_pPoint, m_pPoint=NULL;
    
27.                                 delete m_pRefCount, m_pRefCount=NULL;
    
28.                                 break;
    
29.                         case MT_MALLOC:
    
30.                                 free(m_pPoint), m_pPoint=NULL;
    
31.                                 delete m_pRefCount, m_pRefCount=NULL;
    
32.                                 break;
    
33.                         }
    
34.                 }
    
35.         }
    
36. 
    
37.         void operator = (T* ptr)
    
38.         {
    
39.                 if (ptr == NULL)        return;
    
40.                 if (m_pRefCount == NULL)        m_pRefCount = new int(1);
    
41.                 else                        (*m_pRefCount)++;
    
42.                 m_pPoint = ptr;
    
43.         }
    
44. 
    
45.         void operator = (const CZSharePtr& src)
    
46.         {
    
47.                 m_pPoint=src.m_pPoint, m_pRefCount=src.m_pRefCount;
    
48.                 (*m_pRefCount)++;
    
49.         }
    
50. 
    
51.         bool operator == (T* src)        {        return m_pPoint==src;                }
    
52.         T* GetPoint()                {        return m_pPoint;        }
    
53. 
    
54.         template <typename type>
    
55.         operator type* ()                {        return (type*)m_pPoint;        }
    
56. 
    
57. private:
    
58.         T*                m_pPoint;
    
59.         int*        m_pRefCount;        // 引用计数器
    
60. };
    

复制代码

写的不太好，以后用的频繁了，再具体修改。

游戏阿家

[em4].........你是引用计数是对应于一个智能指针而不是一个对象???.............

1. 
   
2. 
   
3. template <typename T, EMEMORYTYPE type>
   
4. class CZSharePtr
   
5. {
   
6. public:       
   
7.         CZSharePtr(int null=0) : m_pPoint(NULL), m_pRefCount(NULL) {}
   
8.         ~CZSharePtr()        {        Release();        }       
   
9. 
   
10.         void Release()       
    
11.         {               
    
12.                 if (m_pPoint == NULL)       
    
13.                         return;               
    
14.                 if (--(*m_pRefCount) == 0)               
    
15.                 {                       
    
16.                         switch (type)                       
    
17.                         {                       
    
18.                         case MT_NEW:                               
    
19.                                 delete m_pPoint, m_pPoint=NULL;
    
20.                                 delete m_pRefCount, m_pRefCount=NULL;
    
21.                                 break;                       
    
22.                         case MT_MALLOC:                               
    
23.                                 free(m_pPoint), m_pPoint=NULL;                               
    
24.                                 delete m_pRefCount, m_pRefCount=NULL;                               
    
25.                                 break;                       
    
26.                         }               
    
27.                 }       
    
28.         }
    
29. 
    
30.         void operator = (T* ptr)       
    
31.         {               
    
32.                 if (ptr == NULL)       
    
33.                         return;               
    
34.                 if (m_pRefCount == NULL)       
    
35.                         m_pRefCount = new int(1);               
    
36.                 else                       
    
37.                         (*m_pRefCount)++;               
    
38.                         m_pPoint = ptr;       
    
39.         }
    
40. 
    
41.         void operator = (const CZSharePtr& src)       
    
42.         {               
    
43.                 m_pPoint=src.m_pPoint, m_pRefCount=src.m_pRefCount;               
    
44.                 (*m_pRefCount)++;       
    
45.         }       
    
46. 
    
47.         bool operator == (T* src)       
    
48.         {       
    
49.                 return m_pPoint==src;
    
50.         }
    
51. 
    
52.         T* GetPoint()               
    
53.         {       
    
54.                 return m_pPoint;
    
55.         }
    
56. 
    
57.         template <typename type>        operator type* ()               
    
58.         {       
    
59.                 return (type*)m_pPoint;
    
60.         }
    
61. 
    
62. private:       
    
63.         T*                m_pPoint;        int*        m_pRefCount;        // 引用计数器
    
64. };
    
65. 
    
66. class CTexture
    
67. {
    
68. public:
    
69.         CTexture()
    
70.         {
    
71.                 cout << "Construct Texture " << this << endl;
    
72.         }
    
73. 
    
74.         ~CTexture()
    
75.         {
    
76.                 cout << "Destruct Texture " << this << endl;
    
77.         }
    
78. };
    
79. 
    
80. 
    
81. // 对象不会被删除
    
82. {
    
83.         CZSharePtr<CTexture, MT_NEW> texturePtr;
    
84.         texturePtr = new CTexture();
    
85.         texturePtr = texturePtr.GetPoint();
    
86. }
    
87. 
    
88. // pTextureA和pTextureB都没有被删除
    
89. {
    
90.         CZSharePtr<CTexture, MT_NEW> texturePtr;
    
91.         CTexture * pTextureA = new CTexture();
    
92.         CTexture * pTextureB = new CTexture();
    
93.         texturePtr = pTextureA;
    
94.         texturePtr = pTextureB;
    
95. }
    
96. 
    

复制代码

轩辕崇正

游戏阿家: Re: 使用智能指针对纹理对象进行大规模包装,对于底层实现是否合适??

[em4].........你是引用计数是对应于一个智能指针而不是一个对象???.............


[code]

template...

1：只用于一个new或malloc的指针。
2：该智能指针只绑定一个纹理，不支持已经指向一个纹理的情况，再指向下一个纹理。
仔细一想，的确，当智能指针已经指向一个纹理时，再指向其他纹理时，应该解除上一次的引用计数，且当引用计数为0则销毁。
谢谢了。

游戏阿家

.......楼主不禁让我想起一些执著的"黑客",他们从来不屑于学习已有的东西,而是热衷于自己去探索,有一天某个"黑客""发明"了一个算法令其颀喜不已,然而他并不知道,教科书里早就有这种方法了.