mirrors/bgfx
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Fixed update texture.

Browse Source
This commit is contained in:
bkaradzic 2012-11-03 21:36:17 -07:00
parent 20fdda0659
commit ff656de290
7 changed files with 276 additions and 213 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

74
include/bgfx.h
View File

@ -243,6 +243,26 @@ namespace bgfx
}; };
}; };
struct UniformType
{
enum Enum
{
Uniform1i,
Uniform1f,
End,
Uniform1iv,
Uniform1fv,
Uniform2fv,
Uniform3fv,
Uniform4fv,
Uniform3x3fv,
Uniform4x4fv,
Count
};
};
static const uint16_t invalidHandle = UINT16_MAX; static const uint16_t invalidHandle = UINT16_MAX;
BGFX_HANDLE(DynamicIndexBufferHandle); BGFX_HANDLE(DynamicIndexBufferHandle);
@ -257,6 +277,11 @@ namespace bgfx
BGFX_HANDLE(VertexDeclHandle); BGFX_HANDLE(VertexDeclHandle);
BGFX_HANDLE(VertexShaderHandle); BGFX_HANDLE(VertexShaderHandle);
typedef void (*FatalFn)(Fatal::Enum _code, const char* _str);
typedef void* (*ReallocFn)(void* _ptr, size_t _size);
typedef void (*FreeFn)(void* _ptr);
typedef void (*CacheFn)(uint64_t _id, bool _store, void* _data, uint32_t& _length);
struct Memory struct Memory
{ {
uint8_t* data; uint8_t* data;
@ -291,30 +316,13 @@ namespace bgfx
VertexBufferHandle handle; VertexBufferHandle handle;
}; };
struct UniformType struct TextureInfo
{ {
enum Enum TextureFormat::Enum format;
{ uint16_t width;
Uniform1i, uint16_t height;
Uniform1f, uint16_t depth;
End,
Uniform1iv,
Uniform1fv,
Uniform2fv,
Uniform3fv,
Uniform4fv,
Uniform3x3fv,
Uniform4x4fv,
Count
}; };
};
typedef void (*FatalFn)(Fatal::Enum _code, const char* _str);
typedef void* (*ReallocFn)(void* _ptr, size_t _size);
typedef void (*FreeFn)(void* _ptr);
typedef void (*CacheFn)(uint64_t _id, bool _store, void* _data, uint32_t& _length);
struct VertexDecl struct VertexDecl
{ {
@ -432,13 +440,13 @@ namespace bgfx
/// ///
void destroyDynamicVertexBuffer(DynamicVertexBufferHandle _handle); void destroyDynamicVertexBuffer(DynamicVertexBufferHandle _handle);
/// /// Returns true if internal transient index buffer has enough space.
bool checkAvailTransientIndexBuffer(uint16_t _num); bool checkAvailTransientIndexBuffer(uint16_t _num);
/// ///
const TransientIndexBuffer* allocTransientIndexBuffer(uint16_t _num); const TransientIndexBuffer* allocTransientIndexBuffer(uint16_t _num);
/// /// Returns true if internal transient vertex buffer has enough space.
bool checkAvailTransientVertexBuffer(uint16_t _num, const VertexDecl& _decl); bool checkAvailTransientVertexBuffer(uint16_t _num, const VertexDecl& _decl);
/// ///
@ -447,26 +455,28 @@ namespace bgfx
/// ///
const InstanceDataBuffer* allocInstanceDataBuffer(uint16_t _num, uint16_t _stride); const InstanceDataBuffer* allocInstanceDataBuffer(uint16_t _num, uint16_t _stride);
/// /// Create vertex shader from memory buffer.
VertexShaderHandle createVertexShader(const Memory* _mem); VertexShaderHandle createVertexShader(const Memory* _mem);
/// /// Destroy vertex shader. Once program is created with vertex shader
/// it is safe to destroy vertex shader.
void destroyVertexShader(VertexShaderHandle _handle); void destroyVertexShader(VertexShaderHandle _handle);
/// /// Create fragment shader from memory buffer.
FragmentShaderHandle createFragmentShader(const Memory* _mem); FragmentShaderHandle createFragmentShader(const Memory* _mem);
/// /// Destroy fragment shader. Once program is created with fragment shader
/// it is safe to destroy fragment shader.
void destroyFragmentShader(FragmentShaderHandle _handle); void destroyFragmentShader(FragmentShaderHandle _handle);
/// /// Create program with vertex and fragment shaders.
ProgramHandle createProgram(VertexShaderHandle _vsh, FragmentShaderHandle _fsh); ProgramHandle createProgram(VertexShaderHandle _vsh, FragmentShaderHandle _fsh);
/// /// Destroy program.
void destroyProgram(ProgramHandle _handle); void destroyProgram(ProgramHandle _handle);
/// /// Create texture from memory buffer.
TextureHandle createTexture(const Memory* _mem, uint32_t _flags = BGFX_TEXTURE_NONE, uint16_t* _width = NULL, uint16_t* _height = NULL); TextureHandle createTexture(const Memory* _mem, uint32_t _flags = BGFX_TEXTURE_NONE, TextureInfo* _info = NULL);
/// ///
TextureHandle createTexture2D(uint16_t _width, uint16_t _height, uint8_t _numMips, TextureFormat::Enum _format, uint32_t _flags = BGFX_TEXTURE_NONE, const Memory* _mem = NULL); TextureHandle createTexture2D(uint16_t _width, uint16_t _height, uint8_t _numMips, TextureFormat::Enum _format, uint32_t _flags = BGFX_TEXTURE_NONE, const Memory* _mem = NULL);

76
src/bgfx.cpp
View File

@ -979,79 +979,79 @@ namespace bgfx
s_ctx.destroyProgram(_handle); s_ctx.destroyProgram(_handle);
} }
TextureHandle createTexture(const Memory* _mem, uint32_t _flags, uint16_t* _width, uint16_t* _height) TextureHandle createTexture(const Memory* _mem, uint32_t _flags, TextureInfo* _info)
{ {
BX_CHECK(NULL != _mem, "_mem can't be NULL"); BX_CHECK(NULL != _mem, "_mem can't be NULL");
return s_ctx.createTexture(_mem, _flags, _width, _height); return s_ctx.createTexture(_mem, _flags, _info);
} }
TextureHandle createTexture2D(uint16_t _width, uint16_t _height, uint8_t _numMips, TextureFormat::Enum _format, uint32_t _flags, const Memory* _mem) TextureHandle createTexture2D(uint16_t _width, uint16_t _height, uint8_t _numMips, TextureFormat::Enum _format, uint32_t _flags, const Memory* _mem)
{ {
uint32_t size = sizeof(uint32_t)+sizeof(TextureInfo); uint32_t size = sizeof(uint32_t)+sizeof(TextureCreate);
const bgfx::Memory* mem = alloc(size); const bgfx::Memory* mem = alloc(size);
StreamWrite stream(mem->data, mem->size); StreamWrite stream(mem->data, mem->size);
uint32_t magic = BGFX_MAGIC; uint32_t magic = BGFX_MAGIC;
stream.write(magic); stream.write(magic);
TextureInfo ti; TextureCreate tc;
ti.m_flags = _flags; tc.m_flags = _flags;
ti.m_width = _width; tc.m_width = _width;
ti.m_height = _height; tc.m_height = _height;
ti.m_depth = 0; tc.m_depth = 0;
ti.m_numMips = _numMips; tc.m_numMips = _numMips;
ti.m_type = uint8_t(_format); tc.m_type = uint8_t(_format);
ti.m_cubeMap = false; tc.m_cubeMap = false;
ti.m_mem = _mem; tc.m_mem = _mem;
stream.write(ti); stream.write(tc);
return s_ctx.createTexture(mem, _flags, NULL, NULL); return s_ctx.createTexture(mem, _flags, NULL);
} }
TextureHandle createTexture3D(uint16_t _width, uint16_t _height, uint16_t _depth, uint8_t _numMips, TextureFormat::Enum _format, uint32_t _flags, const Memory* _mem) TextureHandle createTexture3D(uint16_t _width, uint16_t _height, uint16_t _depth, uint8_t _numMips, TextureFormat::Enum _format, uint32_t _flags, const Memory* _mem)
{ {
uint32_t size = sizeof(uint32_t)+sizeof(TextureInfo); uint32_t size = sizeof(uint32_t)+sizeof(TextureCreate);
const bgfx::Memory* mem = alloc(size); const bgfx::Memory* mem = alloc(size);
StreamWrite stream(mem->data, mem->size); StreamWrite stream(mem->data, mem->size);
uint32_t magic = BGFX_MAGIC; uint32_t magic = BGFX_MAGIC;
stream.write(magic); stream.write(magic);
TextureInfo ti; TextureCreate tc;
ti.m_flags = _flags; tc.m_flags = _flags;
ti.m_width = _width; tc.m_width = _width;
ti.m_height = _height; tc.m_height = _height;
ti.m_depth = _depth; tc.m_depth = _depth;
ti.m_numMips = _numMips; tc.m_numMips = _numMips;
ti.m_type = uint8_t(_format); tc.m_type = uint8_t(_format);
ti.m_cubeMap = false; tc.m_cubeMap = false;
ti.m_mem = _mem; tc.m_mem = _mem;
stream.write(ti); stream.write(tc);
return s_ctx.createTexture(mem, _flags, NULL, NULL); return s_ctx.createTexture(mem, _flags, NULL);
} }
TextureHandle createTextureCube(uint16_t _sides, uint16_t _width, uint8_t _numMips, TextureFormat::Enum _format, uint32_t _flags, const Memory* _mem) TextureHandle createTextureCube(uint16_t _sides, uint16_t _width, uint8_t _numMips, TextureFormat::Enum _format, uint32_t _flags, const Memory* _mem)
{ {
uint32_t size = sizeof(uint32_t)+sizeof(TextureInfo); uint32_t size = sizeof(uint32_t)+sizeof(TextureCreate);
const bgfx::Memory* mem = alloc(size); const bgfx::Memory* mem = alloc(size);
StreamWrite stream(mem->data, mem->size); StreamWrite stream(mem->data, mem->size);
uint32_t magic = BGFX_MAGIC; uint32_t magic = BGFX_MAGIC;
stream.write(magic); stream.write(magic);
TextureInfo ti; TextureCreate tc;
ti.m_flags = _flags; tc.m_flags = _flags;
ti.m_width = _width; tc.m_width = _width;
ti.m_sides = _sides; tc.m_sides = _sides;
ti.m_depth = 0; tc.m_depth = 0;
ti.m_numMips = _numMips; tc.m_numMips = _numMips;
ti.m_type = uint8_t(_format); tc.m_type = uint8_t(_format);
ti.m_cubeMap = true; tc.m_cubeMap = true;
ti.m_mem = _mem; tc.m_mem = _mem;
stream.write(ti); stream.write(tc);
return s_ctx.createTexture(mem, _flags, NULL, NULL); return s_ctx.createTexture(mem, _flags, NULL);
} }
void destroyTexture(TextureHandle _handle) void destroyTexture(TextureHandle _handle)

29
src/bgfx_p.h
View File

@ -163,7 +163,7 @@ namespace bgfx
uint16_t m_height; uint16_t m_height;
}; };
struct TextureInfo struct TextureCreate
{ {
uint32_t m_flags; uint32_t m_flags;
uint16_t m_width; uint16_t m_width;
@ -2014,29 +2014,24 @@ namespace bgfx
fragmentShaderDecRef(m_programRef[_handle.idx].m_fsh); fragmentShaderDecRef(m_programRef[_handle.idx].m_fsh);
} }
TextureHandle createTexture(const Memory* _mem, uint32_t _flags, uint16_t* _width, uint16_t* _height) TextureHandle createTexture(const Memory* _mem, uint32_t _flags, TextureInfo* _info = NULL)
{ {
if (NULL != _width if (NULL != _info)
|| NULL != _height)
{ {
int width = 0;
int height = 0;
Dds dds; Dds dds;
if (parseDds(dds, _mem) ) if (parseDds(dds, _mem) )
{ {
width = dds.m_width; _info->format = dds.m_type;
height = dds.m_height; _info->width = (uint16_t)dds.m_width;
_info->height = (uint16_t)dds.m_height;
_info->depth = (uint16_t)dds.m_depth;
} }
else
if (NULL != _width)
{ {
*_width = (uint16_t)width; _info->format = TextureFormat::Unknown;
} _info->width = 0;
_info->height = 0;
if (NULL != _height) _info->depth = 0;
{
*_height = (uint16_t)height;
} }
} }

41
src/renderer_d3d11.cpp
View File

@ -1362,40 +1362,42 @@ namespace bgfx
if (BGFX_MAGIC == magic) if (BGFX_MAGIC == magic)
{ {
TextureInfo ti; TextureCreate tc;
stream.read(ti); stream.read(tc);
D3D11_TEXTURE2D_DESC desc; D3D11_TEXTURE2D_DESC desc;
desc.Width = ti.m_width; desc.Width = tc.m_width;
desc.Height = ti.m_height; desc.Height = tc.m_height;
desc.MipLevels = ti.m_numMips; desc.MipLevels = tc.m_numMips;
desc.ArraySize = 1; desc.ArraySize = 1;
desc.Format = s_textureFormat[ti.m_type].m_fmt; desc.Format = s_textureFormat[tc.m_type].m_fmt;
desc.SampleDesc.Count = 1; desc.SampleDesc.Count = 1;
desc.SampleDesc.Quality = 0; desc.SampleDesc.Quality = 0;
desc.BindFlags = D3D11_BIND_SHADER_RESOURCE; desc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
desc.CPUAccessFlags = 0; desc.CPUAccessFlags = 0;
desc.MiscFlags = 0; desc.MiscFlags = 0;
m_numMips = ti.m_numMips; m_numMips = tc.m_numMips;
if (NULL != ti.m_mem) if (NULL != tc.m_mem)
{ {
desc.Usage = D3D11_USAGE_IMMUTABLE; desc.Usage = D3D11_USAGE_IMMUTABLE;
D3D11_SUBRESOURCE_DATA* srd = (D3D11_SUBRESOURCE_DATA*)alloca(ti.m_numMips*sizeof(D3D11_SUBRESOURCE_DATA) ); D3D11_SUBRESOURCE_DATA* srd = (D3D11_SUBRESOURCE_DATA*)alloca(tc.m_numMips*sizeof(D3D11_SUBRESOURCE_DATA) );
uint32_t bpp = s_textureFormat[ti.m_type].m_bpp; uint32_t bpp = s_textureFormat[tc.m_type].m_bpp;
uint8_t* data = ti.m_mem->data; uint8_t* data = tc.m_mem->data;
for (uint8_t side = 0, numSides = ti.m_cubeMap ? 6 : 1; side < numSides; ++side) for (uint8_t side = 0, numSides = tc.m_cubeMap ? 6 : 1; side < numSides; ++side)
{ {
uint32_t width = ti.m_width; uint32_t width = tc.m_width;
uint32_t height = ti.m_height; uint32_t height = tc.m_height;
uint32_t depth = tc.m_depth;
for (uint32_t lod = 0, num = ti.m_numMips; lod < num; ++lod) for (uint32_t lod = 0, num = tc.m_numMips; lod < num; ++lod)
{ {
width = uint32_max(width, 1); width = uint32_max(1, width);
height = uint32_max(height, 1); height = uint32_max(1, height);
depth = uint32_max(1, depth);
srd[lod].pSysMem = data; srd[lod].pSysMem = data;
srd[lod].SysMemPitch = width*bpp; srd[lod].SysMemPitch = width*bpp;
@ -1405,12 +1407,13 @@ namespace bgfx
width >>= 1; width >>= 1;
height >>= 1; height >>= 1;
depth >>= 1;
} }
} }
DX_CHECK(s_renderCtx.m_device->CreateTexture2D(&desc, srd, &m_texture2d) ); DX_CHECK(s_renderCtx.m_device->CreateTexture2D(&desc, srd, &m_texture2d) );
release(ti.m_mem); release(tc.m_mem);
} }
else else
{ {
@ -1422,7 +1425,7 @@ namespace bgfx
D3D11_SHADER_RESOURCE_VIEW_DESC srv; D3D11_SHADER_RESOURCE_VIEW_DESC srv;
memset(&srv, 0, sizeof(srv) ); memset(&srv, 0, sizeof(srv) );
srv.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D; srv.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
srv.Texture2D.MipLevels = ti.m_numMips; srv.Texture2D.MipLevels = tc.m_numMips;
DX_CHECK(s_renderCtx.m_device->CreateShaderResourceView(m_ptr, &srv, &m_srv) ); DX_CHECK(s_renderCtx.m_device->CreateShaderResourceView(m_ptr, &srv, &m_srv) );
} }
else else

37
src/renderer_d3d9.cpp
View File

@ -1285,36 +1285,38 @@ namespace bgfx
if (BGFX_MAGIC == magic) if (BGFX_MAGIC == magic)
{ {
TextureInfo ti; TextureCreate tc;
stream.read(ti); stream.read(tc);
if (ti.m_cubeMap) if (tc.m_cubeMap)
{ {
createCubeTexture(ti.m_width, ti.m_numMips, s_textureFormat[ti.m_type].m_fmt); createCubeTexture(tc.m_width, tc.m_numMips, s_textureFormat[tc.m_type].m_fmt);
} }
else if (ti.m_depth > 1) else if (tc.m_depth > 1)
{ {
createVolumeTexture(ti.m_width, ti.m_height, ti.m_depth, ti.m_numMips, s_textureFormat[ti.m_type].m_fmt); createVolumeTexture(tc.m_width, tc.m_height, tc.m_depth, tc.m_numMips, s_textureFormat[tc.m_type].m_fmt);
} }
else else
{ {
createTexture(ti.m_width, ti.m_height, ti.m_numMips, s_textureFormat[ti.m_type].m_fmt); createTexture(tc.m_width, tc.m_height, tc.m_numMips, s_textureFormat[tc.m_type].m_fmt);
} }
if (NULL != ti.m_mem) if (NULL != tc.m_mem)
{ {
uint32_t bpp = s_textureFormat[ti.m_type].m_bpp; uint32_t bpp = s_textureFormat[tc.m_type].m_bpp;
uint8_t* data = ti.m_mem->data; uint8_t* data = tc.m_mem->data;
for (uint8_t side = 0, numSides = ti.m_cubeMap ? 6 : 1; side < numSides; ++side) for (uint8_t side = 0, numSides = tc.m_cubeMap ? 6 : 1; side < numSides; ++side)
{ {
uint32_t width = ti.m_width; uint32_t width = tc.m_width;
uint32_t height = ti.m_height; uint32_t height = tc.m_height;
uint32_t depth = tc.m_depth;
for (uint32_t lod = 0, num = ti.m_numMips; lod < num; ++lod) for (uint32_t lod = 0, num = tc.m_numMips; lod < num; ++lod)
{ {
width = uint32_max(width, 1); width = uint32_max(1, width);
height = uint32_max(height, 1); height = uint32_max(1, height);
depth = uint32_max(1, depth);
uint32_t pitch; uint32_t pitch;
uint32_t slicePitch; uint32_t slicePitch;
@ -1326,10 +1328,11 @@ namespace bgfx
width >>= 1; width >>= 1;
height >>= 1; height >>= 1;
depth >>= 1;
} }
} }
release(ti.m_mem); release(tc.m_mem);
} }
} }
else else

174
src/renderer_gl.cpp
View File

@ -1158,6 +1158,72 @@ namespace bgfx
} }
} }
static void texImage(GLenum _target, GLint _level, GLint _internalFormat, GLsizei _width, GLsizei _height, GLsizei _depth, GLint _border, GLenum _format, GLenum _type, const GLvoid* _pixels)
{
#if BGFX_CONFIG_RENDERER_OPENGL|BGFX_CONFIG_RENDERER_OPENGLES3
if (_target == GL_TEXTURE_3D)
{
GL_CHECK(glTexImage3D(_target
, _level
, _internalFormat
, _width
, _height
, _depth
, _border
, _format
, _type
, _pixels
) );
}
else
#endif // BGFX_CONFIG_RENDERER_OPENGL|BGFX_CONFIG_RENDERER_OPENGLES3
{
BX_UNUSED(_depth);
GL_CHECK(glTexImage2D(_target
, _level
, _internalFormat
, _width
, _height
, _border
, _format
, _type
, _pixels
) );
}
}
static void compressedTexImage(GLenum _target, GLint _level, GLenum _internalformat, GLsizei _width, GLsizei _height, GLsizei _depth, GLint _border, GLsizei _imageSize, const GLvoid* _data)
{
#if BGFX_CONFIG_RENDERER_OPENGL|BGFX_CONFIG_RENDERER_OPENGLES3
if (_target == GL_TEXTURE_3D)
{
GL_CHECK(glCompressedTexImage3D(_target
, _level
, _internalformat
, _width
, _height
, _depth
, _border
, _imageSize
, _data
) );
}
else
#endif // BGFX_CONFIG_RENDERER_OPENGL|BGFX_CONFIG_RENDERER_OPENGLES3
{
BX_UNUSED(_depth);
GL_CHECK(glCompressedTexImage2D(_target
, _level
, _internalformat
, _width
, _height
, _border
, _imageSize
, _data
) );
}
}
void Texture::create(const Memory* _mem, uint32_t _flags) void Texture::create(const Memory* _mem, uint32_t _flags)
{ {
Dds dds; Dds dds;
@ -1171,12 +1237,12 @@ namespace bgfx
{ {
m_target = GL_TEXTURE_CUBE_MAP; m_target = GL_TEXTURE_CUBE_MAP;
} }
#if BGFX_CONFIG_RENDERER_OPENGL #if BGFX_CONFIG_RENDERER_OPENGL|BGFX_CONFIG_RENDERER_OPENGLES3
else if (dds.m_depth > 1) else if (dds.m_depth > 1)
{ {
m_target = GL_TEXTURE_3D; m_target = GL_TEXTURE_3D;
} }
#endif // BGFX_CONFIG_RENDERER_OPENGL #endif // BGFX_CONFIG_RENDERER_OPENGL|BGFX_CONFIG_RENDERER_OPENGLES3
else else
{ {
m_target = GL_TEXTURE_2D; m_target = GL_TEXTURE_2D;
@ -1250,10 +1316,7 @@ namespace bgfx
} }
} }
#if BGFX_CONFIG_RENDERER_OPENGL texImage(target+side
if (target == GL_TEXTURE_3D)
{
GL_CHECK(glTexImage3D(target
, lod , lod
, internalFmt , internalFmt
, width , width
@ -1263,22 +1326,7 @@ namespace bgfx
, m_fmt , m_fmt
, m_type , m_type
, bits , bits
) ); );
}
else
#endif // BGFX_CONFIG_RENDERER_OPENGL
{
GL_CHECK(glTexImage2D(target+side
, lod
, internalFmt
, width
, height
, 0
, m_fmt
, m_type
, bits
) );
}
} }
width >>= 1; width >>= 1;
@ -1306,10 +1354,7 @@ namespace bgfx
Mip mip; Mip mip;
if (getRawImageData(dds, side, ii, _mem, mip) ) if (getRawImageData(dds, side, ii, _mem, mip) )
{ {
#if BGFX_CONFIG_RENDERER_OPENGL compressedTexImage(target+side
if (m_target == GL_TEXTURE_3D)
{
GL_CHECK(glCompressedTexImage3D(target
, ii , ii
, internalFmt , internalFmt
, width , width
@ -1318,21 +1363,7 @@ namespace bgfx
, 0 , 0
, mip.m_size , mip.m_size
, mip.m_data , mip.m_data
) ); );
}
else
#endif // BGFX_CONFIG_RENDERER_OPENGL
{
GL_CHECK(glCompressedTexImage2D(target+side
, ii
, internalFmt
, width
, height
, 0
, mip.m_size
, mip.m_data
) );
}
} }
width >>= 1; width >>= 1;
@ -1341,15 +1372,9 @@ namespace bgfx
} }
} }
} }
} }
else else
{ {
m_target = GL_TEXTURE_2D;
GL_CHECK(glGenTextures(1, &m_id) );
BX_CHECK(0 != m_id, "Failed to generate texture id.");
GL_CHECK(glBindTexture(m_target, m_id) );
StreamRead stream(_mem->data, _mem->size); StreamRead stream(_mem->data, _mem->size);
uint32_t magic; uint32_t magic;
@ -1357,37 +1382,63 @@ namespace bgfx
if (BGFX_MAGIC == magic) if (BGFX_MAGIC == magic)
{ {
TextureInfo ti; TextureCreate tc;
stream.read(ti); stream.read(tc);
const TextureFormatInfo& tfi = s_textureFormat[ti.m_type]; if (tc.m_cubeMap)
{
m_target = GL_TEXTURE_CUBE_MAP;
}
else if (tc.m_depth > 1)
{
m_target = GL_TEXTURE_3D;
}
else
{
m_target = GL_TEXTURE_2D;
}
GL_CHECK(glGenTextures(1, &m_id) );
BX_CHECK(0 != m_id, "Failed to generate texture id.");
GL_CHECK(glBindTexture(m_target, m_id) );
const TextureFormatInfo& tfi = s_textureFormat[tc.m_type];
GLenum internalFmt = tfi.m_internalFmt; GLenum internalFmt = tfi.m_internalFmt;
m_fmt = tfi.m_fmt; m_fmt = tfi.m_fmt;
m_type = tfi.m_type; m_type = tfi.m_type;
uint32_t bpp = s_textureFormat[ti.m_type].m_bpp; GLenum target = m_target;
uint8_t* data = NULL != ti.m_mem ? ti.m_mem->data : NULL; if (tc.m_cubeMap)
for (uint8_t side = 0, numSides = ti.m_cubeMap ? 6 : 1; side < numSides; ++side)
{ {
uint32_t width = ti.m_width; target = GL_TEXTURE_CUBE_MAP_POSITIVE_X;
uint32_t height = ti.m_height; }
for (uint32_t lod = 0, num = ti.m_numMips; lod < num; ++lod) uint32_t bpp = s_textureFormat[tc.m_type].m_bpp;
uint8_t* data = NULL != tc.m_mem ? tc.m_mem->data : NULL;
for (uint8_t side = 0, numSides = tc.m_cubeMap ? 6 : 1; side < numSides; ++side)
{
uint32_t width = tc.m_width;
uint32_t height = tc.m_height;
uint32_t depth = tc.m_depth;
for (uint32_t lod = 0, num = tc.m_numMips; lod < num; ++lod)
{ {
width = uint32_max(width, 1); width = uint32_max(width, 1);
height = uint32_max(height, 1); height = uint32_max(height, 1);
depth = uint32_max(1, depth);
GL_CHECK(glTexImage2D(m_target texImage(target+side
, lod , lod
, internalFmt , internalFmt
, width , width
, height , height
, depth
, 0 , 0
, m_fmt , m_fmt
, m_type , m_type
, data , data
) ); );
if (NULL != data) if (NULL != data)
{ {
@ -1396,12 +1447,13 @@ namespace bgfx
width >>= 1; width >>= 1;
height >>= 1; height >>= 1;
depth >>= 1;
} }
} }
if (NULL != ti.m_mem) if (NULL != tc.m_mem)
{ {
release(ti.m_mem); release(tc.m_mem);
} }
} }
else else

8
src/renderer_null.cpp
View File

@ -114,12 +114,12 @@ namespace bgfx
if (BGFX_MAGIC == magic) if (BGFX_MAGIC == magic)
{ {
TextureInfo ti; TextureCreate tc;
stream.read(ti); stream.read(tc);
if (NULL != ti.m_mem) if (NULL != tc.m_mem)
{ {
release(ti.m_mem); release(tc.m_mem);
} }
} }
} }