DWORD basetexture_set_lod(IWineD3DBaseTexture *iface, DWORD LODNew) { IWineD3DBaseTextureImpl *This = (IWineD3DBaseTextureImpl *)iface; DWORD old = This->baseTexture.LOD; /* The d3d9:texture test shows that SetLOD is ignored on non-managed * textures. The call always returns 0, and GetLOD always returns 0 */ if (This->resource.pool != WINED3DPOOL_MANAGED) { TRACE("Ignoring SetLOD on %s texture, returning 0\n", debug_d3dpool(This->resource.pool)); return 0; } if (LODNew >= This->baseTexture.level_count) LODNew = This->baseTexture.level_count - 1; if(This->baseTexture.LOD != LODNew) { This->baseTexture.LOD = LODNew; This->baseTexture.texture_rgb.states[WINED3DTEXSTA_MAXMIPLEVEL] = ~0U; This->baseTexture.texture_srgb.states[WINED3DTEXSTA_MAXMIPLEVEL] = ~0U; if(This->baseTexture.bindCount) { IWineD3DDeviceImpl_MarkStateDirty(This->resource.device, STATE_SAMPLER(This->baseTexture.sampler)); } } TRACE("(%p) : set LOD to %d\n", This, This->baseTexture.LOD); return old; }
DWORD basetexture_set_lod(IWineD3DBaseTextureImpl *texture, DWORD lod) { DWORD old = texture->baseTexture.LOD; TRACE("texture %p, lod %u.\n", texture, lod); /* The d3d9:texture test shows that SetLOD is ignored on non-managed * textures. The call always returns 0, and GetLOD always returns 0. */ if (texture->resource.pool != WINED3DPOOL_MANAGED) { TRACE("Ignoring SetLOD on %s texture, returning 0.\n", debug_d3dpool(texture->resource.pool)); return 0; } if (lod >= texture->baseTexture.level_count) lod = texture->baseTexture.level_count - 1; if (texture->baseTexture.LOD != lod) { texture->baseTexture.LOD = lod; texture->baseTexture.texture_rgb.states[WINED3DTEXSTA_MAXMIPLEVEL] = ~0U; texture->baseTexture.texture_srgb.states[WINED3DTEXSTA_MAXMIPLEVEL] = ~0U; if (texture->baseTexture.bindCount) IWineD3DDeviceImpl_MarkStateDirty(texture->resource.device, STATE_SAMPLER(texture->baseTexture.sampler)); } return old; }
HRESULT CDECL wined3d_volume_create(struct wined3d_device *device, UINT width, UINT height, UINT depth, UINT level, DWORD usage, enum wined3d_format_id format_id, enum wined3d_pool pool, void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_volume **volume) { struct wined3d_volume *object; HRESULT hr; TRACE("device %p, width %u, height %u, depth %u, usage %#x, format %s, pool %s\n", device, width, height, depth, usage, debug_d3dformat(format_id), debug_d3dpool(pool)); TRACE("parent %p, parent_ops %p, volume %p.\n", parent, parent_ops, volume); object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)); if (!object) { *volume = NULL; return WINED3DERR_OUTOFVIDEOMEMORY; } hr = volume_init(object, device, width, height, depth, level, usage, format_id, pool, parent, parent_ops); if (FAILED(hr)) { WARN("Failed to initialize volume, returning %#x.\n", hr); HeapFree(GetProcessHeap(), 0, object); return hr; } TRACE("Created volume %p.\n", object); *volume = object; return WINED3D_OK; }
DWORD CDECL wined3d_texture_set_lod(struct wined3d_texture *texture, DWORD lod) { DWORD old = texture->lod; TRACE("texture %p, lod %u.\n", texture, lod); /* The d3d9:texture test shows that SetLOD is ignored on non-managed * textures. The call always returns 0, and GetLOD always returns 0. */ if (texture->resource.pool != WINED3D_POOL_MANAGED) { TRACE("Ignoring SetLOD on %s texture, returning 0.\n", debug_d3dpool(texture->resource.pool)); return 0; } if (lod >= texture->level_count) lod = texture->level_count - 1; if (texture->lod != lod) { texture->lod = lod; texture->texture_rgb.states[WINED3DTEXSTA_MAXMIPLEVEL] = ~0U; texture->texture_srgb.states[WINED3DTEXSTA_MAXMIPLEVEL] = ~0U; if (texture->resource.bind_count) device_invalidate_state(texture->resource.device, STATE_SAMPLER(texture->sampler)); } return old; }
void *wined3d_resource_map_internal(struct wined3d_resource *resource, DWORD flags) { struct wined3d_device *device = resource->device; struct wined3d_context *context = NULL; void *mem; if (device->d3d_initialized) context = context_acquire(device, NULL); if (!wined3d_resource_prepare_map_memory(resource, context)) { WARN("Out of memory.\n"); context_release(context); return NULL; } if (flags & WINED3D_MAP_DISCARD) { switch (resource->map_binding) { case WINED3D_LOCATION_BUFFER: resource->map_buffer = wined3d_device_get_bo(device, resource->size, GL_STREAM_DRAW_ARB, GL_PIXEL_UNPACK_BUFFER_ARB, context); break; case WINED3D_LOCATION_SYSMEM: wined3d_resource_allocate_sysmem(resource); break; default: if (resource->access_fence) ERR("Location %s does not support DISCARD maps.\n", wined3d_debug_location(resource->map_binding)); if (resource->pool != WINED3D_POOL_DEFAULT) FIXME("Discard used on %s pool resource.\n", debug_d3dpool(resource->pool)); } wined3d_resource_validate_location(resource, resource->map_binding); } else { wined3d_resource_load_location(resource, context, resource->map_binding); } mem = wined3d_resource_get_map_ptr(resource, context, flags); if (context) context_release(context); return mem; }
static HRESULT volume_init(struct wined3d_volume *volume, struct wined3d_texture *container, const struct wined3d_resource_desc *desc, UINT level) { struct wined3d_device *device = container->resource.device; const struct wined3d_gl_info *gl_info = &device->adapter->gl_info; const struct wined3d_format *format = wined3d_get_format(gl_info, desc->format); HRESULT hr; UINT size; if (!gl_info->supported[EXT_TEXTURE3D]) { WARN("Volume cannot be created - no volume texture support.\n"); return WINED3DERR_INVALIDCALL; } /* TODO: Write tests for other resources and move this check * to resource_init, if applicable. */ if (desc->usage & WINED3DUSAGE_DYNAMIC && (desc->pool == WINED3D_POOL_MANAGED || desc->pool == WINED3D_POOL_SCRATCH)) { WARN("Attempted to create a DYNAMIC texture in pool %s.\n", debug_d3dpool(desc->pool)); return WINED3DERR_INVALIDCALL; } size = wined3d_format_calculate_size(format, device->surface_alignment, desc->width, desc->height, desc->depth); if (FAILED(hr = resource_init(&volume->resource, device, WINED3D_RTYPE_VOLUME, format, WINED3D_MULTISAMPLE_NONE, 0, desc->usage, desc->pool, desc->width, desc->height, desc->depth, size, NULL, &wined3d_null_parent_ops, &volume_resource_ops))) { WARN("Failed to initialize resource, returning %#x.\n", hr); return hr; } volume->texture_level = level; volume->locations = WINED3D_LOCATION_DISCARDED; if (desc->pool == WINED3D_POOL_DEFAULT && desc->usage & WINED3DUSAGE_DYNAMIC && gl_info->supported[ARB_PIXEL_BUFFER_OBJECT] && !format->convert) { wined3d_resource_free_sysmem(&volume->resource); volume->flags |= WINED3D_VFLAG_PBO; } volume->container = container; return WINED3D_OK; }
HRESULT wined3d_volume_create(struct wined3d_texture *container, const struct wined3d_resource_desc *desc, unsigned int level, struct wined3d_volume **volume) { struct wined3d_device_parent *device_parent = container->resource.device->device_parent; const struct wined3d_parent_ops *parent_ops; struct wined3d_volume *object; void *parent; HRESULT hr; TRACE("container %p, width %u, height %u, depth %u, level %u, format %s, " "usage %#x, pool %s, volume %p.\n", container, desc->width, desc->height, desc->depth, level, debug_d3dformat(desc->format), desc->usage, debug_d3dpool(desc->pool), volume); if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object)))) return E_OUTOFMEMORY; if (FAILED(hr = volume_init(object, container, desc, level))) { WARN("Failed to initialize volume, returning %#x.\n", hr); HeapFree(GetProcessHeap(), 0, object); return hr; } if (FAILED(hr = device_parent->ops->volume_created(device_parent, wined3d_texture_get_parent(container), object, &parent, &parent_ops))) { WARN("Failed to create volume parent, hr %#x.\n", hr); wined3d_volume_destroy(object); return hr; } TRACE("Created volume %p, parent %p, parent_ops %p.\n", object, parent, parent_ops); object->resource.parent = parent; object->resource.parent_ops = parent_ops; *volume = object; return WINED3D_OK; }
static HRESULT wined3d_texture_init(struct wined3d_texture *texture, const struct wined3d_texture_ops *texture_ops, UINT layer_count, UINT level_count, const struct wined3d_resource_desc *desc, struct wined3d_device *device, void *parent, const struct wined3d_parent_ops *parent_ops, const struct wined3d_resource_ops *resource_ops) { const struct wined3d_format *format = wined3d_get_format(&device->adapter->gl_info, desc->format); HRESULT hr; TRACE("texture %p, texture_ops %p, layer_count %u, level_count %u, resource_type %s, format %s, " "multisample_type %#x, multisample_quality %#x, usage %s, pool %s, width %u, height %u, depth %u, " "device %p, parent %p, parent_ops %p, resource_ops %p.\n", texture, texture_ops, layer_count, level_count, debug_d3dresourcetype(desc->resource_type), debug_d3dformat(desc->format), desc->multisample_type, desc->multisample_quality, debug_d3dusage(desc->usage), debug_d3dpool(desc->pool), desc->width, desc->height, desc->depth, device, parent, parent_ops, resource_ops); if ((format->flags & (WINED3DFMT_FLAG_BLOCKS | WINED3DFMT_FLAG_BLOCKS_NO_VERIFY)) == WINED3DFMT_FLAG_BLOCKS) { UINT width_mask = format->block_width - 1; UINT height_mask = format->block_height - 1; if (desc->width & width_mask || desc->height & height_mask) return WINED3DERR_INVALIDCALL; } if (FAILED(hr = resource_init(&texture->resource, device, desc->resource_type, format, desc->multisample_type, desc->multisample_quality, desc->usage, desc->pool, desc->width, desc->height, desc->depth, 0, parent, parent_ops, resource_ops))) { static unsigned int once; if ((desc->format == WINED3DFMT_DXT1 || desc->format == WINED3DFMT_DXT2 || desc->format == WINED3DFMT_DXT3 || desc->format == WINED3DFMT_DXT4 || desc->format == WINED3DFMT_DXT5) && !(format->flags & WINED3DFMT_FLAG_TEXTURE) && !once++) ERR_(winediag)("The application tried to create a DXTn texture, but the driver does not support them.\n"); WARN("Failed to initialize resource, returning %#x\n", hr); return hr; } wined3d_resource_update_draw_binding(&texture->resource); texture->texture_ops = texture_ops; texture->sub_resources = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, level_count * layer_count * sizeof(*texture->sub_resources)); if (!texture->sub_resources) { ERR("Failed to allocate sub-resource array.\n"); resource_cleanup(&texture->resource); return E_OUTOFMEMORY; } texture->layer_count = layer_count; texture->level_count = level_count; texture->filter_type = (desc->usage & WINED3DUSAGE_AUTOGENMIPMAP) ? WINED3D_TEXF_LINEAR : WINED3D_TEXF_NONE; texture->lod = 0; texture->flags = WINED3D_TEXTURE_POW2_MAT_IDENT; if (texture->resource.format->flags & WINED3DFMT_FLAG_FILTERING) { texture->min_mip_lookup = minMipLookup; texture->mag_lookup = magLookup; } else { texture->min_mip_lookup = minMipLookup_noFilter; texture->mag_lookup = magLookup_noFilter; } return WINED3D_OK; }