1 /*
2  * Copyright 2011 Joakim Sindholt <opensource@zhasha.com>
3  *
4  * Permission is hereby granted, free of charge, to any person obtaining a
5  * copy of this software and associated documentation files (the "Software"),
6  * to deal in the Software without restriction, including without limitation
7  * on the rights to use, copy, modify, merge, publish, distribute, sub
8  * license, and/or sell copies of the Software, and to permit persons to whom
9  * the Software is furnished to do so, subject to the following conditions:
10  *
11  * The above copyright notice and this permission notice (including the next
12  * paragraph) shall be included in all copies or substantial portions of the
13  * Software.
14  *
15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
18  * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
19  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
20  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
21  * USE OR OTHER DEALINGS IN THE SOFTWARE. */
22 
23 #include "device9.h"
24 #include "volumetexture9.h"
25 #include "nine_helpers.h"
26 #include "nine_pipe.h"
27 
28 #define DBG_CHANNEL DBG_VOLUMETEXTURE
29 
30 static HRESULT
NineVolumeTexture9_ctor(struct NineVolumeTexture9 * This,struct NineUnknownParams * pParams,UINT Width,UINT Height,UINT Depth,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,HANDLE * pSharedHandle)31 NineVolumeTexture9_ctor( struct NineVolumeTexture9 *This,
32                          struct NineUnknownParams *pParams,
33                          UINT Width, UINT Height, UINT Depth, UINT Levels,
34                          DWORD Usage,
35                          D3DFORMAT Format,
36                          D3DPOOL Pool,
37                          HANDLE *pSharedHandle )
38 {
39     struct pipe_resource *info = &This->base.base.info;
40     struct pipe_screen *screen = pParams->device->screen;
41     enum pipe_format pf;
42     unsigned l;
43     D3DVOLUME_DESC voldesc;
44     HRESULT hr;
45 
46     DBG("This=%p pParams=%p Width=%u Height=%u Depth=%u Levels=%u "
47         "Usage=%d Format=%d Pool=%d pSharedHandle=%p\n",
48         This, pParams, Width, Height, Depth, Levels,
49         Usage, Format, Pool, pSharedHandle);
50 
51     user_assert(Width && Height && Depth, D3DERR_INVALIDCALL);
52 
53     /* user_assert(!pSharedHandle || Pool == D3DPOOL_DEFAULT, D3DERR_INVALIDCALL); */
54     user_assert(!pSharedHandle, D3DERR_INVALIDCALL); /* TODO */
55 
56     /* An IDirect3DVolume9 cannot be bound as a render target can it ? */
57     user_assert(!(Usage & (D3DUSAGE_RENDERTARGET | D3DUSAGE_DEPTHSTENCIL)),
58                 D3DERR_INVALIDCALL);
59     user_assert(!(Usage & D3DUSAGE_AUTOGENMIPMAP), D3DERR_INVALIDCALL);
60 
61     pf = d3d9_to_pipe_format_checked(screen, Format, PIPE_TEXTURE_3D, 0,
62                                      PIPE_BIND_SAMPLER_VIEW, FALSE,
63                                      Pool == D3DPOOL_SCRATCH);
64 
65     if (pf == PIPE_FORMAT_NONE)
66         return D3DERR_INVALIDCALL;
67 
68     /* We support ATI1 and ATI2 hacks only for 2D and Cube textures */
69     if (Format == D3DFMT_ATI1 || Format == D3DFMT_ATI2)
70         return D3DERR_INVALIDCALL;
71 
72     if (compressed_format(Format)) {
73         const unsigned w = util_format_get_blockwidth(pf);
74         const unsigned h = util_format_get_blockheight(pf);
75         /* Compressed formats are not compressed on depth component */
76         user_assert(!(Width % w) && !(Height % h), D3DERR_INVALIDCALL);
77     }
78 
79     info->screen = pParams->device->screen;
80     info->target = PIPE_TEXTURE_3D;
81     info->format = pf;
82     info->width0 = Width;
83     info->height0 = Height;
84     info->depth0 = Depth;
85     if (Levels)
86         info->last_level = Levels - 1;
87     else
88         info->last_level = util_logbase2(MAX2(MAX2(Width, Height), Depth));
89     info->array_size = 1;
90     info->nr_samples = 0;
91     info->nr_storage_samples = 0;
92     info->bind = PIPE_BIND_SAMPLER_VIEW;
93     info->usage = PIPE_USAGE_DEFAULT;
94     info->flags = 0;
95 
96     if (Usage & D3DUSAGE_DYNAMIC) {
97         info->usage = PIPE_USAGE_DYNAMIC;
98     }
99     if (Usage & D3DUSAGE_SOFTWAREPROCESSING)
100         DBG("Application asked for Software Vertex Processing, "
101             "but this is unimplemented\n");
102 
103     This->volumes = CALLOC(info->last_level + 1, sizeof(*This->volumes));
104     if (!This->volumes)
105         return E_OUTOFMEMORY;
106     This->base.pstype = 3;
107 
108     hr = NineBaseTexture9_ctor(&This->base, pParams, NULL,
109                                D3DRTYPE_VOLUMETEXTURE, Format, Pool, Usage);
110     if (FAILED(hr))
111         return hr;
112 
113     voldesc.Format = Format;
114     voldesc.Type = D3DRTYPE_VOLUME;
115     voldesc.Usage = Usage;
116     voldesc.Pool = Pool;
117     for (l = 0; l <= info->last_level; ++l) {
118         voldesc.Width = u_minify(Width, l);
119         voldesc.Height = u_minify(Height, l);
120         voldesc.Depth = u_minify(Depth, l);
121 
122         hr = NineVolume9_new(This->base.base.base.device, NineUnknown(This),
123                              This->base.base.resource, l,
124                              &voldesc, &This->volumes[l]);
125         if (FAILED(hr))
126             return hr;
127     }
128 
129     /* Textures start initially dirty */
130     NineVolumeTexture9_AddDirtyBox(This, NULL);
131 
132     return D3D_OK;
133 }
134 
135 static void
NineVolumeTexture9_dtor(struct NineVolumeTexture9 * This)136 NineVolumeTexture9_dtor( struct NineVolumeTexture9 *This )
137 {
138     unsigned l;
139 
140     DBG("This=%p\n", This);
141 
142     if (This->volumes) {
143         for (l = 0; l <= This->base.base.info.last_level; ++l)
144             if (This->volumes[l])
145                 NineUnknown_Destroy(&This->volumes[l]->base);
146         FREE(This->volumes);
147     }
148 
149     NineBaseTexture9_dtor(&This->base);
150 }
151 
152 HRESULT NINE_WINAPI
NineVolumeTexture9_GetLevelDesc(struct NineVolumeTexture9 * This,UINT Level,D3DVOLUME_DESC * pDesc)153 NineVolumeTexture9_GetLevelDesc( struct NineVolumeTexture9 *This,
154                                  UINT Level,
155                                  D3DVOLUME_DESC *pDesc )
156 {
157     user_assert(Level <= This->base.base.info.last_level, D3DERR_INVALIDCALL);
158 
159     *pDesc = This->volumes[Level]->desc;
160 
161     return D3D_OK;
162 }
163 
164 HRESULT NINE_WINAPI
NineVolumeTexture9_GetVolumeLevel(struct NineVolumeTexture9 * This,UINT Level,IDirect3DVolume9 ** ppVolumeLevel)165 NineVolumeTexture9_GetVolumeLevel( struct NineVolumeTexture9 *This,
166                                    UINT Level,
167                                    IDirect3DVolume9 **ppVolumeLevel )
168 {
169     user_assert(Level <= This->base.base.info.last_level, D3DERR_INVALIDCALL);
170 
171     NineUnknown_AddRef(NineUnknown(This->volumes[Level]));
172     *ppVolumeLevel = (IDirect3DVolume9 *)This->volumes[Level];
173 
174     return D3D_OK;
175 }
176 
177 HRESULT NINE_WINAPI
NineVolumeTexture9_LockBox(struct NineVolumeTexture9 * This,UINT Level,D3DLOCKED_BOX * pLockedVolume,const D3DBOX * pBox,DWORD Flags)178 NineVolumeTexture9_LockBox( struct NineVolumeTexture9 *This,
179                             UINT Level,
180                             D3DLOCKED_BOX *pLockedVolume,
181                             const D3DBOX *pBox,
182                             DWORD Flags )
183 {
184     DBG("This=%p Level=%u pLockedVolume=%p pBox=%p Flags=%d\n",
185         This, Level, pLockedVolume, pBox, Flags);
186 
187     user_assert(Level <= This->base.base.info.last_level, D3DERR_INVALIDCALL);
188 
189     return NineVolume9_LockBox(This->volumes[Level], pLockedVolume, pBox,
190                                Flags);
191 }
192 
193 HRESULT NINE_WINAPI
NineVolumeTexture9_UnlockBox(struct NineVolumeTexture9 * This,UINT Level)194 NineVolumeTexture9_UnlockBox( struct NineVolumeTexture9 *This,
195                               UINT Level )
196 {
197     DBG("This=%p Level=%u\n", This, Level);
198 
199     user_assert(Level <= This->base.base.info.last_level, D3DERR_INVALIDCALL);
200 
201     return NineVolume9_UnlockBox(This->volumes[Level]);
202 }
203 
204 HRESULT NINE_WINAPI
NineVolumeTexture9_AddDirtyBox(struct NineVolumeTexture9 * This,const D3DBOX * pDirtyBox)205 NineVolumeTexture9_AddDirtyBox( struct NineVolumeTexture9 *This,
206                                 const D3DBOX *pDirtyBox )
207 {
208     DBG("This=%p pDirtybox=%p\n", This, pDirtyBox);
209 
210     if (This->base.base.pool == D3DPOOL_DEFAULT) {
211         return D3D_OK;
212     }
213 
214     if (This->base.base.pool == D3DPOOL_MANAGED) {
215         This->base.managed.dirty = TRUE;
216         BASETEX_REGISTER_UPDATE(&This->base);
217     }
218 
219     if (!pDirtyBox) {
220         This->dirty_box.x = 0;
221         This->dirty_box.y = 0;
222         This->dirty_box.z = 0;
223         This->dirty_box.width = This->base.base.info.width0;
224         This->dirty_box.height = This->base.base.info.height0;
225         This->dirty_box.depth = This->base.base.info.depth0;
226     } else {
227         if (This->dirty_box.width == 0) {
228             d3dbox_to_pipe_box(&This->dirty_box, pDirtyBox);
229         } else {
230             struct pipe_box box;
231             d3dbox_to_pipe_box(&box, pDirtyBox);
232             u_box_union_3d(&This->dirty_box, &This->dirty_box, &box);
233         }
234         This->dirty_box.x = MAX2(This->dirty_box.x, 0);
235         This->dirty_box.y = MAX2(This->dirty_box.y, 0);
236         This->dirty_box.z = MAX2(This->dirty_box.z, 0);
237         This->dirty_box.width = MIN2(This->dirty_box.width,
238                                      This->base.base.info.width0 - This->dirty_box.x);
239         This->dirty_box.height = MIN2(This->dirty_box.height,
240                                      This->base.base.info.height0 - This->dirty_box.y);
241         This->dirty_box.depth = MIN2(This->dirty_box.depth,
242                                      This->base.base.info.depth0 - This->dirty_box.z);
243     }
244     return D3D_OK;
245 }
246 
247 IDirect3DVolumeTexture9Vtbl NineVolumeTexture9_vtable = {
248     (void *)NineUnknown_QueryInterface,
249     (void *)NineUnknown_AddRef,
250     (void *)NineUnknown_Release,
251     (void *)NineUnknown_GetDevice, /* actually part of Resource9 iface */
252     (void *)NineUnknown_SetPrivateData,
253     (void *)NineUnknown_GetPrivateData,
254     (void *)NineUnknown_FreePrivateData,
255     (void *)NineResource9_SetPriority,
256     (void *)NineResource9_GetPriority,
257     (void *)NineBaseTexture9_PreLoad,
258     (void *)NineResource9_GetType,
259     (void *)NineBaseTexture9_SetLOD,
260     (void *)NineBaseTexture9_GetLOD,
261     (void *)NineBaseTexture9_GetLevelCount,
262     (void *)NineBaseTexture9_SetAutoGenFilterType,
263     (void *)NineBaseTexture9_GetAutoGenFilterType,
264     (void *)NineBaseTexture9_GenerateMipSubLevels,
265     (void *)NineVolumeTexture9_GetLevelDesc,
266     (void *)NineVolumeTexture9_GetVolumeLevel,
267     (void *)NineVolumeTexture9_LockBox,
268     (void *)NineVolumeTexture9_UnlockBox,
269     (void *)NineVolumeTexture9_AddDirtyBox
270 };
271 
272 static const GUID *NineVolumeTexture9_IIDs[] = {
273     &IID_IDirect3DVolumeTexture9,
274     &IID_IDirect3DBaseTexture9,
275     &IID_IDirect3DResource9,
276     &IID_IUnknown,
277     NULL
278 };
279 
280 HRESULT
NineVolumeTexture9_new(struct NineDevice9 * pDevice,UINT Width,UINT Height,UINT Depth,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,struct NineVolumeTexture9 ** ppOut,HANDLE * pSharedHandle)281 NineVolumeTexture9_new( struct NineDevice9 *pDevice,
282                         UINT Width, UINT Height, UINT Depth, UINT Levels,
283                         DWORD Usage,
284                         D3DFORMAT Format,
285                         D3DPOOL Pool,
286                         struct NineVolumeTexture9 **ppOut,
287                         HANDLE *pSharedHandle )
288 {
289     NINE_DEVICE_CHILD_NEW(VolumeTexture9, ppOut, pDevice,
290                           Width, Height, Depth, Levels,
291                           Usage, Format, Pool, pSharedHandle);
292 }
293 
294