Exemplo n.º 1
0
//----------------------------------------------------------------------------//
void OpenGL3Texture::loadFromMemory(const void* buffer, const Sizef& buffer_size,
                    PixelFormat pixel_format)
{
    if (!isPixelFormatSupported(pixel_format))
        CEGUI_THROW(InvalidRequestException(
            "Data was supplied in an unsupported pixel format."));

    initInternalPixelFormatFields(pixel_format);
    setTextureSize_impl(buffer_size);

    // store size of original data we are loading
    d_dataSize = buffer_size;
    updateCachedScaleValues();

    // save old texture binding
    GLuint old_tex;
    glGetIntegerv(GL_TEXTURE_BINDING_2D, reinterpret_cast<GLint*>(&old_tex));

    // do the real work of getting the data into the texture
    glBindTexture(GL_TEXTURE_2D, d_ogltexture);

    if (d_isCompressed)
        loadCompressedTextureBuffer(buffer_size, buffer);
    else
        loadUncompressedTextureBuffer(buffer_size, buffer);

    // restore previous texture binding.
    glBindTexture(GL_TEXTURE_2D, old_tex);
}
Exemplo n.º 2
0
//----------------------------------------------------------------------------//
Direct3D11Texture::Direct3D11Texture(IDevice11& device, const Size& sz) :
    d_device(device),
    d_texture(0),
    d_resourceView(0),
    d_size(0, 0),
    d_dataSize(0, 0),
    d_texelScaling(0, 0)
{
    D3D11_TEXTURE2D_DESC tex_desc;
    ZeroMemory(&tex_desc, sizeof(tex_desc));
    tex_desc.Width = static_cast<UINT>(sz.d_width);
    tex_desc.Height = static_cast<UINT>(sz.d_height);
    tex_desc.ArraySize = 1;
    tex_desc.SampleDesc.Count = 1;
    tex_desc.SampleDesc.Quality = 0;
    tex_desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
    tex_desc.Usage = D3D11_USAGE_DEFAULT;
    tex_desc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
    tex_desc.CPUAccessFlags = 0;
    tex_desc.MiscFlags = 0;
    tex_desc.MipLevels = 1;

    if (FAILED(d_device.d_device->CreateTexture2D(&tex_desc, 0, &d_texture)))
        CEGUI_THROW(RendererException(
            "Direct3D11Texture: Failed to create texture with specified size."));

    initialiseShaderResourceView();

    d_dataSize = sz;
    updateTextureSize();
    updateCachedScaleValues();
}
Exemplo n.º 3
0
//----------------------------------------------------------------------------//
void OpenGLTexture::setTextureSize(const Size& sz)
{
    const Size size(d_owner.getAdjustedTextureSize(sz));

    // make sure size is within boundaries
    GLfloat maxSize;
    glGetFloatv(GL_MAX_TEXTURE_SIZE, &maxSize);
    if ((size.d_width > maxSize) || (size.d_height > maxSize))
        CEGUI_THROW(RendererException(
            "OpenGLTexture::setTextureSize: size too big"));

    // save old texture binding
    GLuint old_tex;
    glGetIntegerv(GL_TEXTURE_BINDING_2D, reinterpret_cast<GLint*>(&old_tex));

    // set texture to required size
    glBindTexture(GL_TEXTURE_2D, d_ogltexture);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8,
                 static_cast<GLsizei>(size.d_width),
                 static_cast<GLsizei>(size.d_height),
                 0, GL_RGBA , GL_UNSIGNED_BYTE, 0);

    // restore previous texture binding.
    glBindTexture(GL_TEXTURE_2D, old_tex);

    d_dataSize = d_size = size;
    updateCachedScaleValues();
}
Exemplo n.º 4
0
//----------------------------------------------------------------------------//
void OpenGLTexture::initialise(GLuint tex, const Sizef& size) 
{
    d_ogltexture = tex;
    d_size = size;
    d_dataSize = size;
    initInternalPixelFormatFields(PF_RGBA);
    updateCachedScaleValues();
}
Exemplo n.º 5
0
//----------------------------------------------------------------------------//
void DirectFBTexture::loadFromMemory(const void* buffer,
                                     const Sizef& buffer_size,
                                     PixelFormat pixel_format)
{
    if (!isPixelFormatSupported(pixel_format))
        CEGUI_THROW(InvalidRequestException(
            "Data was supplied in an unsupported pixel format."));

    cleanupDirectFBTexture();

    DFBSurfaceDescription desc;
    desc.flags = static_cast<DFBSurfaceDescriptionFlags>
        (DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT);
    desc.width = buffer_size.d_width;
    desc.height = buffer_size.d_height;
    desc.pixelformat = DSPF_ARGB;

    if (d_directfb.CreateSurface(&d_directfb, &desc, &d_texture))
        CEGUI_THROW(RendererException("Failed to create surface."));

    char* dest;
    int pitch;

    if(d_texture->Lock(d_texture, DSLF_WRITE, reinterpret_cast<void**>(&dest), &pitch))
    {
        d_texture->Release(d_texture);
        d_texture = 0;
        CEGUI_THROW(RendererException("Directfb::Lock failed."));
    }

    // Copy data in.
    const size_t pix_sz = (pixel_format == PF_RGB) ? 3 : 4;
    const char* src = static_cast<const char*>(buffer);

    for (int i = 0; i < buffer_size.d_height; ++i)
    {
        for (int j = 0; j < buffer_size.d_width; ++j)
        {
            dest[j * 4 + 0] = src[j * pix_sz + 2];
            dest[j * 4 + 1] = src[j * pix_sz + 1];
            dest[j * 4 + 2] = src[j * pix_sz + 0];
            dest[j * 4 + 3] = (pix_sz == 3) ? 0xFF : src[j * pix_sz + 3];
        }

        dest += pitch;
        src += static_cast<size_t>(buffer_size.d_width) * pix_sz;
    }

    d_texture->Unlock(d_texture);

    // update size and scaling info
    int rw, rh;
    d_texture->GetSize(d_texture, &rw, &rh);
    d_size.d_width = static_cast<float>(rw);
    d_size.d_height = static_cast<float>(rh);
    d_dataSize = buffer_size;
    updateCachedScaleValues();
}
Exemplo n.º 6
0
//----------------------------------------------------------------------------//
void Direct3D11Texture::loadFromMemory(const void* buffer,
                                       const Size& buffer_size,
                                       PixelFormat pixel_format)
{
    cleanupDirect3D11Texture();

    const void* img_src = buffer;
    if (pixel_format == PF_RGB)
    {
        const char* src = static_cast<const char*>(buffer);
        char* dest = new char[buffer_size.d_width * buffer_size.d_height * 4];

        for (int i = 0; i < buffer_size.d_width * buffer_size.d_height; ++i)
        {
            dest[i * 4 + 0] = src[i * 3 + 0];
            dest[i * 4 + 1] = src[i * 3 + 1];
            dest[i * 4 + 2] = src[i * 3 + 2];
            dest[i * 4 + 3] = 0xFF;
        }

        img_src = dest;
    }

    D3D11_TEXTURE2D_DESC tex_desc;
    ZeroMemory(&tex_desc, sizeof(tex_desc));
    tex_desc.Width = static_cast<UINT>(buffer_size.d_width);
    tex_desc.Height = static_cast<UINT>(buffer_size.d_height);
    tex_desc.ArraySize = 1;
    tex_desc.SampleDesc.Count = 1;
    tex_desc.SampleDesc.Quality = 0;
    tex_desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
    tex_desc.Usage = D3D11_USAGE_DEFAULT;
    tex_desc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
    tex_desc.CPUAccessFlags = 0;
    tex_desc.MiscFlags = 0;
    tex_desc.MipLevels = 1;

    D3D11_SUBRESOURCE_DATA data;
    ZeroMemory(&data, sizeof(D3D11_SUBRESOURCE_DATA));
    data.pSysMem = img_src;
    data.SysMemPitch = 4 * tex_desc.Width;

    HRESULT hr = d_device.d_device->CreateTexture2D(&tex_desc, &data, &d_texture);

    if (pixel_format == PF_RGB)
        delete[] img_src;

    if (FAILED(hr))
        CEGUI_THROW(RendererException(
            "Direct3D11Texture::loadFromMemory: Failed to "
            "create texture from memory buffer."));

    initialiseShaderResourceView();

    d_dataSize = buffer_size;
    updateTextureSize();
    updateCachedScaleValues();
}
Exemplo n.º 7
0
//----------------------------------------------------------------------------//
void OpenGL3Texture::setTextureSize(const Sizef& sz)
{
    initInternalPixelFormatFields(PF_RGBA);

    setTextureSize_impl(sz);

    d_dataSize = d_size;
    updateCachedScaleValues();
}
Exemplo n.º 8
0
//----------------------------------------------------------------------------//
OpenGLTexture::OpenGLTexture(OpenGLRenderer& owner, GLuint tex,
                             const Size& size) :
    d_ogltexture(tex),
    d_size(size),
    d_grabBuffer(0),
    d_dataSize(size),
    d_owner(owner)
{
    updateCachedScaleValues();
}
Exemplo n.º 9
0
//----------------------------------------------------------------------------//
void DirectFBTexture::cleanupDirectFBTexture()
{
    if (!d_texture)
        return;

    d_texture->Release(d_texture);
    d_texture = 0;
    d_size = d_dataSize = Sizef(0,0);
    updateCachedScaleValues();
}
Exemplo n.º 10
0
//----------------------------------------------------------------------------//
OpenGL3Texture::OpenGL3Texture(OpenGL3Renderer& owner, const String& name,
                             GLuint tex, const Sizef& size) :
    d_ogltexture(tex),
    d_size(size),
    d_grabBuffer(0),
    d_dataSize(size),
    d_owner(owner),
    d_name(name)
{
    initInternalPixelFormatFields(PF_RGBA);
    updateCachedScaleValues();
}
Exemplo n.º 11
0
//----------------------------------------------------------------------------//
void OpenGLTexture::setOpenGLTexture(GLuint tex, const Size& size)
{
    if (d_ogltexture != tex)
    {
        // cleanup the current state first.
        cleanupOpenGLTexture();

        d_ogltexture = tex;
    }

    d_dataSize = d_size = size;
    updateCachedScaleValues();
}
Exemplo n.º 12
0
//----------------------------------------------------------------------------//
void OpenGLTexture::loadFromMemory(const void* buffer, const Sizef& buffer_size,
                    PixelFormat pixel_format)
{
    if (!isPixelFormatSupported(pixel_format))
        throw InvalidRequestException(
            "Data was supplied in an unsupported pixel format.");

    initInternalPixelFormatFields(pixel_format);
    setTextureSize_impl(buffer_size);

    // store size of original data we are loading
    d_dataSize = buffer_size;
    updateCachedScaleValues();

    blitFromMemory(buffer, Rectf(glm::vec2(0, 0), buffer_size));
}
Exemplo n.º 13
0
	void IrrlichtTexture::loadFromFile(const String& filename, const String& resourceGroup)
	{
		freeTexture();

        RawDataContainer texFile;
        System::getSingleton().getResourceProvider()->loadRawDataContainer(filename, texFile, resourceGroup);

        IrrlichtMemoryFile imf(filename, texFile.getDataPtr(), texFile.getSize());

		driver->setTextureCreationFlag(irr::video::ETCF_CREATE_MIP_MAPS,true);
		tex=driver->getTexture(&imf);
		tex->grab();

        // unload file data buffer
        System::getSingleton().getResourceProvider()->unloadRawDataContainer(texFile);
        updateCachedScaleValues();
	}
Exemplo n.º 14
0
	void	FlowVRCegTexture::loadFromMemory(const void* buffPtr,
								   const Size &buffer_size,
								   PixelFormat pixelFormat)
	{
		std::cout << "FlowVRCegTexture::loadFromMemory()"
		          << std::endl;

		int imageType;
		int pixelType;

		switch(pixelFormat)
		{
			case  Texture::PF_RGB:
			{
				std::cout << "RGB texture requested.\n";
				imageType = flowvr::render::ChunkTexture::RGB;
				pixelType = ftl::Type::vector(ftl::Type::Byte, 3);
				break;
			}
			case Texture::PF_RGBA:
			{
				std::cout << "RGBA texture requested.\n";
				imageType = flowvr::render::ChunkTexture::RGBA;
				pixelType = ftl::Type::vector(ftl::Type::Byte, 4);
				break;
			}
			default:
				return; // failed
		}

		FlowVRCegRenderer *parent = dynamic_cast<FlowVRCegRenderer*>( &m_owner );
		flowvr::render::ChunkTexture *textureBuffer
			= parent->m_writer->addTexture(m_nTxId, imageType, pixelType, buffer_size.d_width, buffer_size.d_height );

		memcpy(textureBuffer->data(),buffPtr,textureBuffer->dataSize());
		m_originalSize = m_size = Size(  textureBuffer->nx, textureBuffer->ny );


		static int n = 0;
		std::string fname = ftl::toString<int>(n++)+ ".png";
		parent->getChunkWriter().saveTexture( textureBuffer, fname );
		m_strFileName = fname;

		updateCachedScaleValues();
	}
Exemplo n.º 15
0
//----------------------------------------------------------------------------//
void Direct3D9Texture::createDirect3D9Texture(const Sizef sz, D3DFORMAT format)
{
    cleanupDirect3D9Texture();

    const Sizef tex_sz(d_owner.getAdjustedSize(sz));

    HRESULT hr = D3DXCreateTexture(d_owner.getDevice(),
                                   static_cast<UINT>(tex_sz.d_width),
                                   static_cast<UINT>(tex_sz.d_height),
                                   1, 0, format, D3DPOOL_MANAGED, &d_texture);

    if (FAILED(hr))
        CEGUI_THROW(RendererException("D3DXCreateTexture failed."));

    d_dataSize = sz;
    updateTextureSize();
    updateCachedScaleValues();
}
Exemplo n.º 16
0
//----------------------------------------------------------------------------//
void Direct3D10Texture::setDirect3DTexture(ID3D10Texture2D* tex)
{
    if (d_texture != tex)
    {
        cleanupDirect3D10Texture();
        d_dataSize.d_width = d_dataSize.d_height = 0;

        d_texture = tex;
        if (d_texture)
            d_texture->AddRef();
    }

    initialiseShaderResourceView();

    updateTextureSize();
    d_dataSize = d_size;
    updateCachedScaleValues();
}
Exemplo n.º 17
0
//----------------------------------------------------------------------------//
DirectFBTexture::DirectFBTexture(IDirectFB& directfb, const Size& size) :
    d_directfb(directfb),
    d_texture(0),
    d_size(0, 0),
    d_dataSize(0, 0),
    d_texelScaling(0, 0)
{
    DFBSurfaceDescription desc;
    desc.flags = static_cast<DFBSurfaceDescriptionFlags>
        (DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT);
    desc.width = size.d_width;
    desc.height = size.d_height;
    desc.pixelformat = DSPF_ARGB;

    if (d_directfb.CreateSurface(&d_directfb, &desc, &d_texture))
        throw RendererException("DirectFBTexture: Failed to create texture of "
                                "specified size.");

    d_size = d_dataSize = size;
    updateCachedScaleValues();
}
Exemplo n.º 18
0
//----------------------------------------------------------------------------//
void OpenGLTexture::loadFromMemory(const void* buffer, const Size& buffer_size,
                    PixelFormat pixel_format)
{
    GLint comps;
    GLenum format;
    switch (pixel_format)
    {
    case PF_RGB:
        comps = 3;
        format = GL_RGB;
        break;
    case PF_RGBA:
        comps = 4;
        format = GL_RGBA;
        break;
    };

    setTextureSize(buffer_size);
    // store size of original data we are loading
    d_dataSize = buffer_size;
    // update scale values
    updateCachedScaleValues();

    // save old states
    GLuint old_tex, old_pack;
    glGetIntegerv(GL_TEXTURE_BINDING_2D, reinterpret_cast<GLint*>(&old_tex));
    glGetIntegerv(GL_UNPACK_ALIGNMENT, reinterpret_cast<GLint*>(&old_pack));

    // do the real work of getting the data into the texture
    glBindTexture(GL_TEXTURE_2D, d_ogltexture);
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0,
                    static_cast<GLsizei>(buffer_size.d_width),
                    static_cast<GLsizei>(buffer_size.d_height),
                    format, GL_UNSIGNED_BYTE, buffer);

    // restore previous states.
    glPixelStorei(GL_UNPACK_ALIGNMENT, old_pack);
    glBindTexture(GL_TEXTURE_2D, old_tex);
}
Exemplo n.º 19
0
//----------------------------------------------------------------------------//
void OpenGLESTexture::blitFromMemory(void* sourceData, const Rectf& area)
{
    // store size of original data we are loading
    d_dataSize = area.getSize();
    setTextureSize(d_dataSize);
    // update scale values
    updateCachedScaleValues();

    // save old texture binding
    GLuint old_tex;
    glGetIntegerv(GL_TEXTURE_BINDING_2D, reinterpret_cast<GLint*>(&old_tex));

    // do the real work of getting the data into the texture
    glBindTexture(GL_TEXTURE_2D, d_ogltexture);
    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0,
                    static_cast<GLsizei>(d_dataSize.d_width),
                    static_cast<GLsizei>(d_dataSize.d_height),
                    GL_RGBA, GL_UNSIGNED_BYTE, sourceData);

    // restore previous texture binding.
    glBindTexture(GL_TEXTURE_2D, old_tex);
}
Exemplo n.º 20
0
	void IrrlichtTexture::loadFromMemory(const void* buffPtr, 
		uint buffWidth, uint buffHeight, PixelFormat pixelFormat)
	{
		freeTexture();
		
		irr::core::dimension2d<irr::s32> dim(buffWidth,buffHeight);
		irr::core::stringc name=getUniqueName();

		driver->setTextureCreationFlag(irr::video::ETCF_CREATE_MIP_MAPS,true);

        unsigned int pixelSize;
        irr::video::ECOLOR_FORMAT texFormat;

        switch(pixelFormat)
        {
            case PF_RGB:
                pixelSize = 3;
                texFormat = irr::video::ECF_R8G8B8;
                break;
            case PF_RGBA:
                pixelSize = 4;
                texFormat = irr::video::ECF_A8R8G8B8;
                break;
        }

		tex=driver->addTexture(dim,name.c_str(), texFormat);
		
		if(texFormat == tex->getColorFormat()) // paranoid!
		{
			irr::u32* tt=(irr::u32*)tex->lock(); 
			irr::core::dimension2d<irr::s32> d=tex->getSize();
			memcpy(tt,buffPtr,d.Width*d.Height*pixelSize);
			tex->unlock();
		}
		tex->grab();
        updateCachedScaleValues();
	}
Exemplo n.º 21
0
//----------------------------------------------------------------------------//
void Direct3D10Texture::setOriginalDataSize(const Size& sz)
{
    d_dataSize = sz;
    updateCachedScaleValues();
}
Exemplo n.º 22
0
//----------------------------------------------------------------------------//
void Direct3D11Texture::loadFromMemory(const void* buffer,
                                       const Sizef& buffer_size,
                                       PixelFormat pixel_format)
{
    if (!isPixelFormatSupported(pixel_format))
        CEGUI_THROW(InvalidRequestException(
            "Data was supplied in an unsupported pixel format."));

    cleanupDirect3D11Texture();

    const void* img_src = buffer;
    if (pixel_format == PF_RGB)
    {
        const unsigned char* src = static_cast<const unsigned char*>(buffer);
        unsigned char* dest = new unsigned char[static_cast<unsigned int>( buffer_size.d_width * buffer_size.d_height * 4 )];

        for (int i = 0; i < buffer_size.d_width * buffer_size.d_height; ++i)
        {
            dest[i * 4 + 0] = src[i * 3 + 0];
            dest[i * 4 + 1] = src[i * 3 + 1];
            dest[i * 4 + 2] = src[i * 3 + 2];
            dest[i * 4 + 3] = 0xFF;
        }

        img_src = dest;
    }

    D3D11_TEXTURE2D_DESC tex_desc;
    ZeroMemory(&tex_desc, sizeof(tex_desc));
    tex_desc.Width = static_cast<UINT>(buffer_size.d_width);
    tex_desc.Height = static_cast<UINT>(buffer_size.d_height);
    tex_desc.ArraySize = 1;
    tex_desc.SampleDesc.Count = 1;
    tex_desc.SampleDesc.Quality = 0;
    tex_desc.Format = toD3DPixelFormat(pixel_format);
    tex_desc.Usage = D3D11_USAGE_DEFAULT;
    tex_desc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
    tex_desc.CPUAccessFlags = 0;
    tex_desc.MiscFlags = 0;
    tex_desc.MipLevels = 1;

    D3D11_SUBRESOURCE_DATA data;
    ZeroMemory(&data, sizeof(D3D11_SUBRESOURCE_DATA));
    data.pSysMem = img_src;
    data.SysMemPitch = calculateDataWidth(tex_desc.Width, pixel_format);

    HRESULT hr = d_device.d_device->CreateTexture2D(&tex_desc, &data, &d_texture);

    if (pixel_format == PF_RGB)
        delete[] img_src;

    if (FAILED(hr))
        CEGUI_THROW(RendererException(
            "Failed to create texture from memory buffer."));

    initialiseShaderResourceView();

    d_dataSize = buffer_size;
    updateTextureSize();
    updateCachedScaleValues();
}
Exemplo n.º 23
0
 void FlowVRCegTexture::setSize( const Size &sz )
 {
 	m_size = sz;
 	updateCachedScaleValues();
 }