ImageBasedDensityProvider::ImageBasedDensityProvider(const std::string filename, const AABB model_aabb)
{
    int desired_channel_count = 0; // keep original amount of channels
    int img_x, img_y, img_z; // stbi requires pointer to int rather than to coord_t
    image = stbi_load(filename.c_str(), &img_x, &img_y, &img_z, desired_channel_count);
    image_size = Point3(img_x, img_y, img_z);
    if (!image)
    {
        const char* reason = "[unknown reason]";
        if (stbi_failure_reason())
        {
            reason = stbi_failure_reason();
        }
        logError("Cannot load image %s: '%s'.\n", filename.c_str(), reason);
        std::exit(-1);
    }
    { // compute aabb
        Point middle = model_aabb.getMiddle();
        Point model_aabb_size = model_aabb.max - model_aabb.min;
        Point image_size2 = Point(image_size.x, image_size.y);
        float aabb_aspect_ratio = float(model_aabb_size.X) / float(model_aabb_size.Y);
        float image_aspect_ratio = float(image_size.x) / float(image_size.y);
        Point aabb_size;
        if (image_aspect_ratio < aabb_aspect_ratio)
        {
            aabb_size = image_size2 * model_aabb_size.X / image_size.x;
        }
        else
        {
            aabb_size = image_size2 * model_aabb_size.Y / image_size.y;
        }
        print_aabb = AABB(middle - aabb_size / 2, middle + aabb_size / 2);
        assert(aabb_size.X >= model_aabb_size.X && aabb_size.Y >= model_aabb_size.Y);
    }
}
示例#2
0
int main(int argc, char** argv)
{
    if (argc < 2)
    {
        std::cerr << "Use " << argv[0] << " filename" << std::endl;
        return 1;
    }

    // load image
    int width, height, nc;
    float* rgba = stbi_loadf(argv[1], &width, &height, &nc, 4);
    if (stbi_failure_reason())
    {
        std::cerr << "stbi: " << stbi_failure_reason() << std::endl;
        return 1;
    }

    // create summed area table of luminance image
    summed_area_table lum_sat;
    lum_sat.create_lum(rgba, width, height, 4);

    // apply median cut
    std::vector<sat_region> regions;
    median_cut(lum_sat, 9, regions); // max 2^n cuts

    // create 2d positions from regions
    std::vector<float2> lights;
    create_lights(regions, lights);

    // draw a marker into image for each position
    size_t i = 0;
    for (auto l = lights.begin(); l != lights.end(); ++l)
    {
        std::cout << "Light " << i++ << ": (" << l->x << ", " << l->y << ")" << std::endl;
        draw(rgba, width, height, *l);
    }

    // save image with marked samples
    std::vector<unsigned char> conv;
    conv.resize(width*height*4);

    for (size_t i = 0; i < width * height * 4; ++i)
        conv[i] = static_cast<unsigned char>(rgba[i]*255);

    stbi_write_bmp("test.bmp", width, height, 4, &conv[0]);

    return 0;
}
示例#3
0
bool LoadImage( Image* image, const char* vfsPath )
{
    memset(image, 0, sizeof(Image));

    PHYSFS_File* file = PHYSFS_openRead(vfsPath);
    if(!file)
    {
        Error("Can't load '%s': %s", vfsPath, PHYSFS_getLastError());
        return false;
    }

    stbi_set_flip_vertically_on_load(1);

    image->data = stbi_load_from_callbacks(&PhysFSCallbacks,
                                           file,
                                           &image->width,
                                           &image->height,
                                           &image->channelCount,
                                           STBI_default);
    PHYSFS_close(file);
    if(!image->data)
    {
        Error("Can't load '%s': %s", vfsPath, stbi_failure_reason());
        return false;
    }

    image->type = GL_UNSIGNED_BYTE;

    return true;
}
示例#4
0
文件: image.cpp 项目: mattl/anaconda
void FileImage::load_file()
{
    FSFile fp(filename.c_str(), "r");

    if (!fp.is_open()) {
        printf("Could not open image \"%s\"\n", filename.c_str());
        return;
    }

    int w, h, channels;
    image = load_image(fp, fp.get_size(), &w, &h, &channels);

    width = w;
    height = h;

    fp.close();

    if (image == NULL) {
        printf("Could not load image \"%s\": %s\n", filename.c_str(),
               stbi_failure_reason());
        return;
    }

    if (!transparent.is_enabled())
        return;

#ifndef CHOWDREN_FORCE_TRANSPARENT
    if (channels != 1 && channels != 3)
        return;
#endif

    set_transparent_color(transparent);
}
示例#5
0
Stb::ImagePtr Stb::Image::loadFromStream(std::istream & s, Format fmt)
{
	ImagePtr image = std::static_pointer_cast<Image>(std::make_shared<Image::Wrapper>());

	try
	{
		int imageFmt = UNKNOWN;

		image->m_Data = stbi_load_from_callbacks(&g_StbCB, &s, &image->m_Width, &image->m_Height, &imageFmt, fmt);
		if (!image->m_Data)
			throw std::runtime_error(stbi_failure_reason());

		image->m_Format = static_cast<Format>(fmt == UNKNOWN ? imageFmt : fmt);
		if (image->m_Format == UNKNOWN)
			throw std::runtime_error("unable to determine pixel format for the image.");
	}
	catch (const std::exception & e)
	{
		if (image->m_Data)
			stbi_image_free(image->m_Data);

		std::clog << "Error reading image: " << e.what() << std::endl;
		image->m_Data = &g_DummyData;
		image->m_Width = 0;
		image->m_Height = 0;
		image->m_Format = UNKNOWN;
	}

	return image;
}
示例#6
0
bool ImageLoader::loadImageFromFile(const std::string& filename, std::vector<Uint8>& pixels, unsigned int& width, unsigned int& height)
{
    // Clear the array (just in case)
    pixels.clear();

    // Load the image and get a pointer to the pixels in memory
    int imgWidth, imgHeight, imgChannels;
    unsigned char* ptr = stbi_load(filename.c_str(), &imgWidth, &imgHeight, &imgChannels, STBI_rgb_alpha);

    if (ptr && imgWidth && imgHeight)
    {
        // Assign the image properties
        width  = imgWidth;
        height = imgHeight;

        // Copy the loaded pixels to the pixel buffer
        pixels.resize(width * height * 4);
        memcpy(&pixels[0], ptr, pixels.size());

        // Free the loaded pixels (they are now in our own pixel buffer)
        stbi_image_free(ptr);

        return true;
    }
    else
    {
        // Error, failed to load the image
        err() << "Failed to load image \"" << filename << "\". Reason : " << stbi_failure_reason() << std::endl;

        return false;
    }
}
示例#7
0
void Image::load()
{
    flags |= USED;

    if (tex != 0 || image != NULL)
        return;

    if (flags & FILE) {
        ((FileImage*)this)->load_file();
        return;
    }

    open_image_file();
    image_file.set_item(handle, AssetFile::IMAGE_DATA);
    FileStream stream(image_file);

    hotspot_x = stream.read_int16();
    hotspot_y = stream.read_int16();
    action_x = stream.read_int16();
    action_y = stream.read_int16();

    int size = stream.read_uint32();

    int w, h, channels;
    image = load_image(image_file, size, &w, &h, &channels);

    width = w;
    height = h;

    if (image == NULL) {
        std::cout << "Could not load image " << handle << std::endl;
        std::cout << stbi_failure_reason() << std::endl;
        return;
    }
}
示例#8
0
void Stb::Read(SoyPixelsImpl& Pixels,const ArrayBridge<char>& ArrayBuffer,TReadFunction ReadFunction)
{
#if defined(USE_STB)
	const stbi_uc* Buffer = reinterpret_cast<const stbi_uc*>( ArrayBuffer.GetArray() );
	auto BufferSize = size_cast<int>( ArrayBuffer.GetDataSize() );
	int Width = 0;
	int Height = 0;
	int Channels = 0;
	int RequestedChannels = 4;
	auto* DecodedPixels = stbi_load_from_memory( Buffer, BufferSize, &Width, &Height, &Channels, RequestedChannels );
	if ( !DecodedPixels )
	{
		//	gr: as this is not thread safe, it could come out mangled :( maybe add a lock around error popping before read (maybe have to lock around the whole thing)
		auto* StbError = stbi_failure_reason();
		if ( !StbError )
			StbError = "Unknown error";
		std::stringstream Error;
		Error << "Failed to read image pixels; " << StbError;
		
		throw Soy::AssertException( Error.str() );
	}
	
	//	convert output into pixels
	//	gr: have to assume size
	auto Format = SoyPixelsFormat::GetFormatFromChannelCount( Channels );
	SoyPixelsMeta Meta( Width, Height, Format );
	SoyPixelsRemote OutputPixels( DecodedPixels, Meta.GetDataSize(), Meta );
	Pixels.Copy( OutputPixels );
#else
	throw Soy::AssertException("No STB support, no image reading");
#endif
}
示例#9
0
void StbImageFactory::load(ResourceData *resource)
{
    StbImage* stbresource = static_cast<StbImage*>(resource);
    int x,y,comp;

    stbi_uc* data = stbi_load(stbresource->path().toLocal8Bit().data(), &x, &y, &comp, stbresource->m_comp);

    if(data != 0)
    {
        logInfo( "StbImage loaded " << resource->name() << " (" << x << "x" << y << ")");
        stbresource->m_data = data;
        stbresource->m_width = x;
        stbresource->m_height = y;

        // If we asked 0 components comp now contains the number of components
        if(stbresource->m_comp == 0)
            stbresource->m_comp = comp;

        stbresource->m_state = StbImage::STATE_LOADED;
        stbresource->buildTexture();
    }
    else
    {
        logWarn( "StbImage failed to load " << resource->name() << "\n" << stbi_failure_reason());
    }
}
示例#10
0
static int load_embedded_image(lua_State *L) {
    am_check_nargs(L, 1);
    const char *filename = luaL_checkstring(L, 1);
    am_embedded_file_record *rec = am_get_embedded_file(filename);
    if (rec == NULL) {
        return luaL_error(L, "embedded file not found: %s", filename);
    }
    int width, height;
    int components = 4;
    stbi_set_flip_vertically_on_load(1);
    stbi_uc *img_data =
        stbi_load_from_memory((stbi_uc const *)rec->data, rec->len, &width, &height, &components, 4);
    if (img_data == NULL) {
        return luaL_error(L, "error loading image %s: %s", filename, stbi_failure_reason());
    }
    am_image_buffer *img = am_new_userdata(L, am_image_buffer);
    img->width = width;
    img->height = height;
    img->format = AM_PIXEL_FORMAT_RGBA8;
    int sz = width * height * pixel_format_size(img->format);
    am_buffer *imgbuf = am_new_userdata(L, am_buffer);
    imgbuf->size = sz;
    imgbuf->data = img_data;
    img->buffer = imgbuf;
    img->buffer_ref = img->ref(L, -1);
    lua_pop(L, 1); // pop imgbuf
    return 1;
}
示例#11
0
static int load_image(lua_State *L) {
    am_check_nargs(L, 1);
    char *errmsg;
    int len;
    const char *filename = luaL_checkstring(L, 1);
    void *data = am_read_resource(filename, &len, &errmsg);
    if (data == NULL) {
        lua_pushstring(L, errmsg);
        free(errmsg);
        return lua_error(L);
    }
    int width, height;
    int components = 4;
    stbi_set_flip_vertically_on_load(1);
    stbi_uc *img_data =
        stbi_load_from_memory((stbi_uc const *)data, len, &width, &height, &components, 4);
    free(data);
    if (img_data == NULL) {
        return luaL_error(L, "error loading image %s: %s", filename, stbi_failure_reason());
    }
    am_image_buffer *img = am_new_userdata(L, am_image_buffer);
    img->width = width;
    img->height = height;
    img->format = AM_PIXEL_FORMAT_RGBA8;
    int sz = width * height * pixel_format_size(img->format);
    am_buffer *imgbuf = am_new_userdata(L, am_buffer);
    imgbuf->size = sz;
    imgbuf->data = img_data;
    img->buffer = imgbuf;
    img->buffer_ref = img->ref(L, -1);
    lua_pop(L, 1); // pop imgbuf
    return 1;
}
示例#12
0
文件: cimage.cpp 项目: dogtwelve/eepp
void cImage::LoadFromPack( cPack * Pack, const std::string& FilePackPath ) {
	if ( NULL != Pack && Pack->IsOpen() && -1 != Pack->Exists( FilePackPath ) ) {
		SafeDataPointer PData;

		Pack->ExtractFileToMemory( FilePackPath, PData );

		int w, h, c;
		Uint8 * data = stbi_load_from_memory( PData.Data, PData.DataSize, &w, &h, &c, mChannels );

		if ( NULL != data ) {
			mPixels		= data;
			mWidth		= (eeUint)w;
			mHeight		= (eeUint)h;

			if ( STBI_default == mChannels )
				mChannels	= (eeUint)c;

			mSize	= mWidth * mHeight * mChannels;

			mLoadedFromStbi = true;
		} else {
			eePRINTL( "Failed to load image %s. Reason: %s", stbi_failure_reason(), FilePackPath.c_str() );
		}
	} else {
		eePRINTL( "Failed to load image %s from pack.", FilePackPath.c_str() );
	}
}
示例#13
0
Image load_image(const std::string& filename, Image::Format format)
{
    int32_t width, height;
    auto data = stbi_load(filename.c_str(), &width, &height, nullptr, format);
    if (!data)
        std::cerr << stbi_failure_reason() << std::endl;
    return Image(width, height, format, data);
}
示例#14
0
	bool Image::LoadFile( uint8_t * data, int32_t size )
	{
		this->bpp = 4;
		stbi_convert_iphone_png_to_rgb(1);
		this->pixels = stbi_load_from_memory(data, (int)size, (int*)&this->width, (int*)&this->height, (int*)&this->original_bpp, this->bpp);
		if ( this->pixels == NULL )
		{
			std::cout << "elix::Image:" << stbi_failure_reason() << std::endl;
			this->length = 0;
			return false;
		}
		if ( this->bpp != 4 )
		{
			std::cout << "this->bpp:" << this->bpp << "-" << stbi_failure_reason() << std::endl;
		}
		this->length = this->width * this->height * this->bpp;
		return true;
	}
示例#15
0
Texture2D loadTexture(u8 *image_data, u64 image_size, RenderContext *render_context, RenderContext::Format format, int force_components) {
	int tex_w, tex_h, tex_comps;
	stbi_set_flip_vertically_on_load(true);
	u8 *tex_data = (u8 *)stbi_loadf_from_memory((stbi_uc *)image_data, image_size, &tex_w, &tex_h, &tex_comps, force_components);
	const char *fail_reason = stbi_failure_reason();
	Texture2D result  = render_context->createTexture2D(tex_data, (u32)tex_w,  (u32)tex_h, format);
	stbi_image_free(tex_data);
	return result;	
}
示例#16
0
std::string StbContext::GetError()
{
	//	gr: as this is not thread safe, it could come out mangled :( maybe add a lock around error popping before read (maybe have to lock around the whole thing)
	auto* StbError = stbi_failure_reason();
	if ( !StbError )
		return "Unknown error";

	return StbError;
}
示例#17
0
Bitmap Bitmap::bitmapFromFile(std::string filePath) {
    int width, height, channels;
    unsigned char* pixels = stbi_load(filePath.c_str(), &width, &height, &channels, 0);
    if(!pixels) throw std::runtime_error(stbi_failure_reason());

    Bitmap bmp(width, height, (Format)channels, pixels);
    stbi_image_free(pixels);
    return bmp;
}
示例#18
0
    //---------------------------------------------------------------------
    Codec::DecodeResult STBIImageCodec::decode(DataStreamPtr& input) const
    {
        // Buffer stream into memory (TODO: override IO functions instead?)
        MemoryDataStream memStream(input, true);

        int width, height, components;
        stbi_uc* pixelData = stbi_load_from_memory(memStream.getPtr(),
                static_cast<int>(memStream.size()), &width, &height, &components, 0);

        if (!pixelData)
        {
            OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, 
                "Error decoding image: " + String(stbi_failure_reason()),
                "STBIImageCodec::decode");
        }

        SharedPtr<ImageData> imgData(OGRE_NEW ImageData());
        MemoryDataStreamPtr output;

        imgData->depth = 1; // only 2D formats handled by this codec
        imgData->width = width;
        imgData->height = height;
        imgData->num_mipmaps = 0; // no mipmaps in non-DDS 
        imgData->flags = 0;

        switch( components )
        {
            case 1:
                imgData->format = PF_BYTE_L;
                break;
            case 2:
                imgData->format = PF_BYTE_LA;
                break;
            case 3:
                imgData->format = PF_BYTE_RGB;
                break;
            case 4:
                imgData->format = PF_BYTE_RGBA;
                break;
            default:
                stbi_image_free(pixelData);
                OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND,
                            "Unknown or unsupported image format",
                            "STBIImageCodec::decode");
                break;
        }
        
        size_t dstPitch = imgData->width * PixelUtil::getNumElemBytes(imgData->format);
        imgData->size = dstPitch * imgData->height;
        output.bind(OGRE_NEW MemoryDataStream(pixelData, imgData->size, true));
        
        DecodeResult ret;
        ret.first = output;
        ret.second = imgData;
        return ret;
    }
示例#19
0
TextureResourceData* TextureLoader_stbi(ResourceDataSource &dataSource, Allocator &alloc, bool forceRGBA)
{
    stbi_io_callbacks callbacks;
    callbacks.read = read;
    callbacks.skip = skip;
    callbacks.eof = eof;

    int x, y, bpp;
    auto pixels = stbi_load_from_callbacks(&callbacks, &dataSource, &x, &y, &bpp, forceRGBA ? 4 : 0);
    if (!pixels)
    {
#ifdef STB_DO_ERROR_PRINT
        DFLOG_WARN(stbi_failure_reason());
#endif
        return nullptr;
    }

    auto fmt = PixelFormat::INVALID;

    if (bpp == STBI_rgb)
    {
        fmt = PixelFormat::RGB;
    }
    else if (bpp == STBI_rgb_alpha)
    {
        fmt = PixelFormat::RGBA;
    }
    else
    {
        DFLOG_WARN("Parsed image with an invalid bpp");
        stbi_image_free(pixels);
        return nullptr;
    }

    if (forceRGBA)
        fmt = PixelFormat::RGBA;

    auto resource = MAKE_NEW(alloc, TextureResourceData);
    resource->format = fmt;

    resource->mipLevels.resize(1);
    resource->mipLevels[0].width = x;
    resource->mipLevels[0].height = y;

    int compCount = forceRGBA ? 4 : bpp;

    resource->mipLevels[0].pixels.resize(compCount * x * y);
    memcpy(resource->mipLevels[0].pixels.data(), pixels, compCount * x * y);

    stbi_image_free(pixels);

    return resource;
}
示例#20
0
bool Texture::load(std::string filename)
{
	int width, height, channels;
	unsigned char* ptr = stbi_load(filename.c_str(), &width, &height, &channels, STBI_rgb_alpha);

	bool result = false;
	if (ptr && width && height) result = load(ptr, width, height);
	else printLog("Failed to load image \"%s\". Reason : %s\n", filename.c_str(), stbi_failure_reason());
	stbi_image_free(ptr);

	return result;
}
示例#21
0
文件: cimage.cpp 项目: dogtwelve/eepp
cImage::cImage( std::string Path, const eeUint& forceChannels ) :
	mPixels(NULL),
	mWidth(0),
	mHeight(0),
	mChannels(forceChannels),
	mSize(0),
	mAvoidFree(false),
	mLoadedFromStbi(false)
{
	int w, h, c;
	cPack * tPack = NULL;
	Uint8 * data = stbi_load( Path.c_str(), &w, &h, &c, mChannels );

	if ( NULL == data ) {
		data = stbi_load( ( Sys::GetProcessPath() + Path ).c_str(), &w, &h, &c, mChannels );
	}

	if ( NULL != data ) {
		mPixels		= data;
		mWidth		= (eeUint)w;
		mHeight		= (eeUint)h;

		if ( STBI_default == mChannels )
			mChannels	= (eeUint)c;

		mSize	= mWidth * mHeight * mChannels;

		mLoadedFromStbi = true;
	} else if ( cPackManager::instance()->FallbackToPacks() && NULL != ( tPack = cPackManager::instance()->Exists( Path ) ) ) {
		LoadFromPack( tPack, Path );
	} else {
		std::string reason = ".";

		if ( NULL != stbi_failure_reason() ) {
			reason = ", reason: " + std::string( stbi_failure_reason() );
		}

		eePRINTL( "Failed to load image %s. Reason: %s", Path.c_str(), reason.c_str() );
	}
}
示例#22
0
bool STB_Image_Loader::decode(ResourceLoadOptions& options)
{
	std::vector<uint8> data;
	StreamRead(options.stream, data);

	if( data.empty() ) return false;

	int width, height, comp;
	
	byte* pixelData = stbi_load_from_memory(
		&data[0], data.size(), &width, &height,
		&comp, 0 /* 0=auto-detect, 3=RGB, 4=RGBA */ );

	if( !pixelData )
	{
		const char* error = stbi_failure_reason();
		LogError("STB image error: %s", error);
		return false;
	}

	// Build our image with the pixel data returned by stb_image.
	PixelFormat pf = PixelFormat::Unknown;
	
	switch( comp )
	{
	case 0:
	case 1: break;
	case 3: pf = PixelFormat::R8G8B8; break;
	case 4: pf = PixelFormat::R8G8B8A8; break;
	}

	if( pf == PixelFormat::Unknown )
	{
		LogError( "Implement support for more pixel formats" );
		return false;
	}
	
	std::vector<byte> buffer;
	uint32 size = width*height*comp; 
	buffer.resize(size);
	
	memcpy(&buffer[0], pixelData, size);
	free(pixelData);

	Image* image = static_cast<Image*>( options.resource );
	image->setWidth( width );
	image->setHeight( height );
	image->setPixelFormat( pf );
	image->setBuffer( buffer );

	return true;
}
示例#23
0
bool Texture::load(const void* memFile, std::size_t size)
{
	int width, height, channels;
	const unsigned char* buffer = static_cast<const unsigned char*>(memFile);
	unsigned char* ptr = stbi_load_from_memory(buffer, static_cast<int>(size), &width, &height, &channels, STBI_rgb_alpha);

	bool result = false;
	if (ptr && width && height) result = load(ptr, width, height);
	else printLog("Failed to load image from memory. Reason : %s\n", stbi_failure_reason());
	stbi_image_free(ptr);

	return result;
}
示例#24
0
文件: zip.c 项目: ccxvii/mio
static unsigned char *read_zip_file(FILE *file, int offset, int *sizep)
{
	int sig, method, csize, usize;
	int namelength, extralength;
	char *cdata, *udata;

	fseek(file, offset, 0);

	sig = getlong(file);
	if (sig != ZIP_LOCAL_FILE_SIG) {
		warn("zip: wrong signature for local file");
		return NULL;
	}

	(void) getshort(file); /* version */
	(void) getshort(file); /* general */
	method = getshort(file);
	(void) getshort(file); /* file time */
	(void) getshort(file); /* file date */
	(void) getlong(file); /* crc-32 */
	csize = getlong(file); /* csize */
	usize = getlong(file); /* usize */
	namelength = getshort(file);
	extralength = getshort(file);

	fseek(file, namelength + extralength, 1);

	if (method == 0 && csize == usize) {
		cdata = malloc(csize);
		fread(cdata, 1, csize, file);
		*sizep = csize;
		return (unsigned char*) cdata;
	}

	if (method == 8) {
		cdata = malloc(csize);
		fread(cdata, 1, csize, file);
		udata = malloc(usize);
		usize = stbi_zlib_decode_noheader_buffer(udata, usize, cdata, csize);
		free(cdata);
		if (usize < 0) {
			warn("zip: %s", stbi_failure_reason());
			return NULL;
		}
		*sizep = usize;
		return (unsigned char*) udata;
	}

	warn("zip: unknown compression method");
	return NULL;
}
示例#25
0
bool Texture::load(const std::string &path, GLenum min_filter, GLenum mag_filter, GLenum wrap_s, GLenum wrap_t) {
    int width, height, perPixComp;
    const char *image_path = path.c_str();
    unsigned char* image = stbi_load(image_path, &width, &height, &perPixComp, 3);
    if (!image) {
        std::cout << "ERROR::TEXTURE::LOADING_FAILED\n" << stbi_failure_reason() << std::endl;
        return false;
    } else {
        load(image, width, height, min_filter, mag_filter, wrap_s, wrap_t);
        stbi_image_free(image);
    }

    return true;
}
示例#26
0
    int Render::loadTexture(string texture_file, string texture_name)
    {

        //std::string path(GLSL_SOURCE_DIR);
        //path += "../../../sprites/boid.png";
        //path += "../../../sprites/enjalot.jpg";
        printf("LOAD TEXTURE!!!!!!!!!!!!!!\n");
        //printf("path: %s\n", path.c_str());

        //Load an image with stb_image
        int w,h,channels;
        int force_channels = 0;

        unsigned char *im = stbi_load( texture_file.c_str(), &w, &h, &channels, force_channels );
        printf("after load w: %d h: %d channels: %d\n", w, h, channels);
        printf("im looking for the image at %s\n", texture_file.c_str());
        if (im == NULL)
        {
            printf("fail!: %s\n", stbi_failure_reason());
            printf("WTF\n");
        }

        //load as gl texture
        glGenTextures(1, &gl_textures[texture_name]);
        glBindTexture(GL_TEXTURE_2D, gl_textures[texture_name]);

        glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        
        //better way to do this?
        if(channels == 3)
        {
            glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, w, h, 0,
                     GL_RGB, GL_UNSIGNED_BYTE, &im[0]);
        }
        else if (channels == 4)
        {
             glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0,
                  GL_RGBA, GL_UNSIGNED_BYTE, &im[0]);
        }

        glBindTexture(GL_TEXTURE_2D,0);
        free(im);
        return 0; //success
    }
示例#27
0
  Image load_image( const char* filename )
  {
    i32 width;
    i32 height;
    i32 format;

    // Using NULL because stbi_load takes an integer and nullptr
    // has type nullptr_t.
    u8* pixels = stbi_load( filename, &width, &height, &format, 0 );
    defer( stbi_image_free( pixels ) );

    if ( !pixels )
      throw std::runtime_error( stbi_failure_reason() );

    return load_image( width, height, (ImageFormat)format, pixels );
  }
示例#28
0
文件: texture.cpp 项目: redxdev/Wake
    TexturePtr Texture::load(const char* path)
    {
        int width;
        int height;
        int comp;
        stbi_set_flip_vertically_on_load(1); // we need to flip the y axis due to OpenGL
        unsigned char* data = stbi_load(path, &width, &height, &comp, STBI_rgb_alpha);
        if (data == nullptr)
        {
            std::cout << "Texture::load error: there was a problem loading the texture " << path << std::endl;
            std::cout << "STBI: " << stbi_failure_reason() << std::endl;
            return nullptr;
        }

        return TexturePtr(new Texture(data, width, height, comp, path));
    }
示例#29
0
kit::Texture::Ptr kit::Texture::create2DFromFile(std::string filename, kit::Texture::InternalFormat format, kit::Texture::EdgeSamplingMode edgemode, kit::Texture::FilteringMode minfilter, kit::Texture::FilteringMode magfilter)
{
  std::cout << "Loading texture from file " << filename.c_str() << std::endl;
  kit::Texture::Ptr returner = std::make_shared<kit::Texture>(Texture2D);
  returner->m_internalFormat    = format;

  // Try to load data from file
  unsigned char* bufferdata;
  int x, y, n;

  stbi_set_flip_vertically_on_load(1);
  bufferdata = stbi_load(filename.c_str(), &x, &y, &n, 4);
  if (bufferdata == nullptr)
  {
    KIT_ERR(stbi_failure_reason());
    x = 1;
    y = 1;
    n = 4;
    bufferdata = new unsigned char[4];
    bufferdata[0] = 255;
    bufferdata[1] = 0;
    bufferdata[2] = 0;
    bufferdata[3] = 255;
  }

  // Set resolution
  returner->m_resolution        = glm::uvec3(x, y, 0);

  // Specify storage and upload data to GPU
  KIT_GL(glTextureStorage2D(returner->m_glHandle, returner->calculateMipLevels(), returner->m_internalFormat, returner->m_resolution.x, returner->m_resolution.y));
  KIT_GL(glTextureSubImage2D(returner->m_glHandle, 0, 0, 0, x, y, GL_RGBA, GL_UNSIGNED_BYTE, bufferdata));

  // Free loaded data
  stbi_image_free(bufferdata);

  // Set parameters
  returner->setEdgeSamplingMode(edgemode);
  returner->setMinFilteringMode(minfilter);
  returner->setMagFilteringMode(magfilter);

  returner->setAnisotropicLevel(8.0f);

  // Generate mipmap
  returner->generateMipmap();

  return returner;
}
示例#30
0
bool ImageLoader::loadImageFromMemory(const void* data, std::size_t dataSize, std::vector<Uint8>& pixels, Vector2u& size)
{
    // Check input parameters
    if (data && dataSize)
    {
        // Clear the array (just in case)
        pixels.clear();

        // Load the image and get a pointer to the pixels in memory
        int width = 0;
        int height = 0;
        int channels = 0;
        const unsigned char* buffer = static_cast<const unsigned char*>(data);
        unsigned char* ptr = stbi_load_from_memory(buffer, static_cast<int>(dataSize), &width, &height, &channels, STBI_rgb_alpha);

        if (ptr)
        {
            // Assign the image properties
            size.x = width;
            size.y = height;

            if (width && height)
            {
                // Copy the loaded pixels to the pixel buffer
                pixels.resize(width * height * 4);
                memcpy(&pixels[0], ptr, pixels.size());
            }

            // Free the loaded pixels (they are now in our own pixel buffer)
            stbi_image_free(ptr);

            return true;
        }
        else
        {
            // Error, failed to load the image
            err() << "Failed to load image from memory. Reason: " << stbi_failure_reason() << std::endl;

            return false;
        }
    }
    else
    {
        err() << "Failed to load image from memory, no data provided" << std::endl;
        return false;
    }
}