/* TODO(sergey): Deduplicate with the iteration above, but make it pretty,
* without bunch of arguments passing around making code readability even
* more cluttered.
*/
void ImageManager::tag_reload_image(const string& filename,
void *builtin_data,
InterpolationType interpolation,
ExtensionType extension)
{
for(size_t type = 0; type < IMAGE_DATA_NUM_TYPES; type++) {
for(size_t slot = 0; slot < images[type].size(); slot++) {
if(images[type][slot] && image_equals(images[type][slot],
filename,
builtin_data,
interpolation,
extension))
{
images[type][slot]->need_load = true;
break;
}
}
}
}
void ImageManager::remove_image(const string& filename,
void *builtin_data,
InterpolationType interpolation,
ExtensionType extension)
{
size_t slot;
for(int type = 0; type < IMAGE_DATA_NUM_TYPES; type++) {
for(slot = 0; slot < images[type].size(); slot++) {
if(images[type][slot] && image_equals(images[type][slot],
filename,
builtin_data,
interpolation,
extension))
{
remove_image(type_index_to_flattened_slot(slot, (ImageDataType)type));
return;
}
}
}
}
int ImageManager::add_image(const string& filename,
void *builtin_data,
bool animated,
float frame,
InterpolationType interpolation,
ExtensionType extension,
bool use_alpha,
ImageMetaData& metadata)
{
Image *img;
size_t slot;
get_image_metadata(filename, builtin_data, metadata);
ImageDataType type = metadata.type;
thread_scoped_lock device_lock(device_mutex);
/* No half textures on OpenCL, use full float instead. */
if(!has_half_images) {
if(type == IMAGE_DATA_TYPE_HALF4) {
type = IMAGE_DATA_TYPE_FLOAT4;
}
else if(type == IMAGE_DATA_TYPE_HALF) {
type = IMAGE_DATA_TYPE_FLOAT;
}
}
/* Fnd existing image. */
for(slot = 0; slot < images[type].size(); slot++) {
img = images[type][slot];
if(img && image_equals(img,
filename,
builtin_data,
interpolation,
extension,
use_alpha))
{
if(img->frame != frame) {
img->frame = frame;
img->need_load = true;
}
if(img->use_alpha != use_alpha) {
img->use_alpha = use_alpha;
img->need_load = true;
}
img->users++;
return type_index_to_flattened_slot(slot, type);
}
}
/* Find free slot. */
for(slot = 0; slot < images[type].size(); slot++) {
if(!images[type][slot])
break;
}
/* Count if we're over the limit.
* Very unlikely, since max_num_images is insanely big. But better safe than sorry. */
int tex_count = 0;
for(int type = 0; type < IMAGE_DATA_NUM_TYPES; type++) {
tex_count += tex_num_images[type];
}
if(tex_count > max_num_images) {
printf("ImageManager::add_image: Reached image limit (%d), skipping '%s'\n",
max_num_images, filename.c_str());
return -1;
}
if(slot == images[type].size()) {
images[type].resize(images[type].size() + 1);
}
/* Add new image. */
img = new Image();
img->filename = filename;
img->builtin_data = builtin_data;
img->builtin_free_cache = metadata.builtin_free_cache;
img->need_load = true;
img->animated = animated;
img->frame = frame;
img->interpolation = interpolation;
img->extension = extension;
img->users = 1;
img->use_alpha = use_alpha;
img->mem = NULL;
images[type][slot] = img;
++tex_num_images[type];
need_update = true;
return type_index_to_flattened_slot(slot, type);
}
int ImageManager::add_image(const string& filename,
void *builtin_data,
bool animated,
float frame,
bool& is_float,
bool& is_linear,
InterpolationType interpolation,
ExtensionType extension,
bool use_alpha)
{
Image *img;
size_t slot;
ImageDataType type = get_image_metadata(filename, builtin_data, is_linear);
thread_scoped_lock device_lock(device_mutex);
/* Do we have a float? */
if(type == IMAGE_DATA_TYPE_FLOAT || type == IMAGE_DATA_TYPE_FLOAT4)
is_float = true;
/* No single channel and half textures on CUDA (Fermi) and no half on OpenCL, use available slots */
if((type == IMAGE_DATA_TYPE_FLOAT ||
type == IMAGE_DATA_TYPE_HALF4 ||
type == IMAGE_DATA_TYPE_HALF) &&
tex_num_images[type] == 0) {
type = IMAGE_DATA_TYPE_FLOAT4;
}
if(type == IMAGE_DATA_TYPE_BYTE && tex_num_images[type] == 0) {
type = IMAGE_DATA_TYPE_BYTE4;
}
/* Fnd existing image. */
for(slot = 0; slot < images[type].size(); slot++) {
img = images[type][slot];
if(img && image_equals(img,
filename,
builtin_data,
interpolation,
extension))
{
if(img->frame != frame) {
img->frame = frame;
img->need_load = true;
}
if(img->use_alpha != use_alpha) {
img->use_alpha = use_alpha;
img->need_load = true;
}
img->users++;
return type_index_to_flattened_slot(slot, type);
}
}
/* Find free slot. */
for(slot = 0; slot < images[type].size(); slot++) {
if(!images[type][slot])
break;
}
if(slot == images[type].size()) {
/* Max images limit reached. */
if(images[type].size() == tex_num_images[type]) {
printf("ImageManager::add_image: Reached %s image limit (%d), skipping '%s'\n",
name_from_type(type).c_str(), tex_num_images[type], filename.c_str());
return -1;
}
images[type].resize(images[type].size() + 1);
}
/* Add new image. */
img = new Image();
img->filename = filename;
img->builtin_data = builtin_data;
img->need_load = true;
img->animated = animated;
img->frame = frame;
img->interpolation = interpolation;
img->extension = extension;
img->users = 1;
img->use_alpha = use_alpha;
images[type][slot] = img;
need_update = true;
return type_index_to_flattened_slot(slot, type);
}
int ImageManager::add_image(const string& filename,
void *builtin_data,
bool animated,
float frame,
bool& is_float,
bool& is_linear,
InterpolationType interpolation,
ExtensionType extension,
bool use_alpha)
{
Image *img;
size_t slot;
bool builtin_free_cache;
ImageDataType type = get_image_metadata(filename, builtin_data, is_linear, builtin_free_cache);
thread_scoped_lock device_lock(device_mutex);
/* Check whether it's a float texture. */
is_float = (type == IMAGE_DATA_TYPE_FLOAT || type == IMAGE_DATA_TYPE_FLOAT4);
/* No single channel and half textures on CUDA (Fermi) and no half on OpenCL, use available slots */
if(!has_half_images) {
if(type == IMAGE_DATA_TYPE_HALF4) {
type = IMAGE_DATA_TYPE_FLOAT4;
}
else if(type == IMAGE_DATA_TYPE_HALF) {
type = IMAGE_DATA_TYPE_FLOAT;
}
}
if(cuda_fermi_limits) {
if(type == IMAGE_DATA_TYPE_FLOAT) {
type = IMAGE_DATA_TYPE_FLOAT4;
}
else if(type == IMAGE_DATA_TYPE_BYTE) {
type = IMAGE_DATA_TYPE_BYTE4;
}
}
/* Fnd existing image. */
for(slot = 0; slot < images[type].size(); slot++) {
img = images[type][slot];
if(img && image_equals(img,
filename,
builtin_data,
interpolation,
extension,
use_alpha))
{
if(img->frame != frame) {
img->frame = frame;
img->need_load = true;
}
if(img->use_alpha != use_alpha) {
img->use_alpha = use_alpha;
img->need_load = true;
}
img->users++;
return type_index_to_flattened_slot(slot, type);
}
}
/* Find free slot. */
for(slot = 0; slot < images[type].size(); slot++) {
if(!images[type][slot])
break;
}
/* Count if we're over the limit */
if(cuda_fermi_limits) {
if(tex_num_images[IMAGE_DATA_TYPE_BYTE4] == TEX_NUM_BYTE4_CUDA
|| tex_num_images[IMAGE_DATA_TYPE_FLOAT4] == TEX_NUM_FLOAT4_CUDA)
{
printf("ImageManager::add_image: Reached %s image limit (%d), skipping '%s'\n",
name_from_type(type).c_str(), tex_num_images[type], filename.c_str());
return -1;
}
}
else {
/* Very unlikely, since max_num_images is insanely big. But better safe than sorry. */
int tex_count = 0;
for(int type = 0; type < IMAGE_DATA_NUM_TYPES; type++) {
tex_count += tex_num_images[type];
}
if(tex_count > max_num_images) {
printf("ImageManager::add_image: Reached image limit (%d), skipping '%s'\n",
max_num_images, filename.c_str());
return -1;
}
}
if(slot == images[type].size()) {
images[type].resize(images[type].size() + 1);
}
/* Add new image. */
img = new Image();
img->filename = filename;
img->builtin_data = builtin_data;
img->builtin_free_cache = builtin_free_cache;
img->need_load = true;
img->animated = animated;
img->frame = frame;
img->interpolation = interpolation;
img->extension = extension;
img->users = 1;
img->use_alpha = use_alpha;
images[type][slot] = img;
++tex_num_images[type];
need_update = true;
return type_index_to_flattened_slot(slot, type);
}
