bool TextureCube::SetSize(int size, unsigned format, TextureUsage usage, int multiSample)
{
if (size <= 0)
{
URHO3D_LOGERROR("Zero or negative cube texture size");
return false;
}
if (usage == TEXTURE_DEPTHSTENCIL)
{
URHO3D_LOGERROR("Depth-stencil usage not supported for cube textures");
return false;
}
multiSample = Clamp(multiSample, 1, 16);
if (multiSample > 1 && usage < TEXTURE_RENDERTARGET)
{
URHO3D_LOGERROR("Multisampling is only supported for rendertarget cube textures");
return false;
}
// Delete the old rendersurfaces if any
for (unsigned i = 0; i < MAX_CUBEMAP_FACES; ++i)
{
renderSurfaces_[i].Reset();
faceMemoryUse_[i] = 0;
}
usage_ = usage;
if (usage == TEXTURE_RENDERTARGET)
{
for (unsigned i = 0; i < MAX_CUBEMAP_FACES; ++i)
{
renderSurfaces_[i] = new RenderSurface(this);
#ifdef URHO3D_OPENGL
renderSurfaces_[i]->target_ = GL_TEXTURE_CUBE_MAP_POSITIVE_X + i;
#endif
}
// Nearest filtering by default
filterMode_ = FILTER_NEAREST;
}
if (usage == TEXTURE_RENDERTARGET)
SubscribeToEvent(E_RENDERSURFACEUPDATE, URHO3D_HANDLER(TextureCube, HandleRenderSurfaceUpdate));
else
UnsubscribeFromEvent(E_RENDERSURFACEUPDATE);
width_ = size;
height_ = size;
depth_ = 1;
format_ = format;
multiSample_ = multiSample;
autoResolve_ = multiSample > 1;
return Create();
}
bool TmxFile2D::BeginLoad(Deserializer& source)
{
if (GetName().Empty())
SetName(source.GetName());
loadXMLFile_ = new XMLFile(context_);
if (!loadXMLFile_->Load(source))
{
URHO3D_LOGERROR("Load XML failed " + source.GetName());
loadXMLFile_.Reset();
return false;
}
XMLElement rootElem = loadXMLFile_->GetRoot("map");
if (!rootElem)
{
URHO3D_LOGERROR("Invalid tmx file " + source.GetName());
loadXMLFile_.Reset();
return false;
}
// If we're async loading, request the texture now. Finish during EndLoad().
if (GetAsyncLoadState() == ASYNC_LOADING)
{
for (XMLElement tileSetElem = rootElem.GetChild("tileset"); tileSetElem; tileSetElem = tileSetElem.GetNext("tileset"))
{
// Tile set defined in TSX file
if (tileSetElem.HasAttribute("source"))
{
String source = tileSetElem.GetAttribute("source");
SharedPtr<XMLFile> tsxXMLFile = LoadTSXFile(source);
if (!tsxXMLFile)
return false;
tsxXMLFiles_[source] = tsxXMLFile;
String textureFilePath =
GetParentPath(GetName()) + tsxXMLFile->GetRoot("tileset").GetChild("image").GetAttribute("source");
GetSubsystem<ResourceCache>()->BackgroundLoadResource<Texture2D>(textureFilePath, true, this);
}
else
{
String textureFilePath = GetParentPath(GetName()) + tileSetElem.GetChild("image").GetAttribute("source");
GetSubsystem<ResourceCache>()->BackgroundLoadResource<Texture2D>(textureFilePath, true, this);
}
}
for (XMLElement imageLayerElem = rootElem.GetChild("imagelayer"); imageLayerElem;
imageLayerElem = imageLayerElem.GetNext("imagelayer"))
{
String textureFilePath = GetParentPath(GetName()) + imageLayerElem.GetChild("image").GetAttribute("source");
GetSubsystem<ResourceCache>()->BackgroundLoadResource<Texture2D>(textureFilePath, true, this);
}
}
return true;
}
bool TextureCube::SetSize(int size, uint32_t format, TextureUsage usage, int multiSample)
{
if (size <= 0)
{
URHO3D_LOGERROR("Zero or negative cube texture size");
return false;
}
if (usage == TEXTURE_DEPTHSTENCIL)
{
URHO3D_LOGERROR("Depth-stencil usage not supported for cube textures");
return false;
}
multiSample = Clamp(multiSample, 1, 16);
if (multiSample > 1 && usage < TEXTURE_RENDERTARGET)
{
URHO3D_LOGERROR("Multisampling is only supported for rendertarget cube textures");
return false;
}
// Delete the old rendersurfaces if any
for (unsigned i = 0; i < MAX_CUBEMAP_FACES; ++i)
{
renderSurfaces_[i].Reset();
faceMemoryUse_[i] = 0;
}
usage_ = usage;
if (usage == TEXTURE_RENDERTARGET)
{
for (unsigned i = 0; i < MAX_CUBEMAP_FACES; ++i)
{
renderSurfaces_[i] = new RenderSurface(this);
renderSurfaces_[i]->target_ = GL_TEXTURE_CUBE_MAP_POSITIVE_X + i;
}
// Nearest filtering by default
filterMode_ = FILTER_NEAREST;
}
if (usage == TEXTURE_RENDERTARGET)
g_graphicsSignals.renderSurfaceUpdate.Connect(this,&TextureCube::HandleRenderSurfaceUpdate);
else
g_graphicsSignals.renderSurfaceUpdate.Disconnect(this,&TextureCube::HandleRenderSurfaceUpdate);
width_ = size;
height_ = size;
format_ = format;
depth_ = 1;
multiSample_ = multiSample;
autoResolve_ = multiSample > 1;
return Create();
}
bool XMLFile::BeginLoad(Deserializer& source)
{
unsigned dataSize = source.GetSize();
if (!dataSize && !source.GetName().Empty())
{
URHO3D_LOGERROR("Zero sized XML data in " + source.GetName());
return false;
}
SharedArrayPtr<char> buffer(new char[dataSize]);
if (source.Read(buffer.Get(), dataSize) != dataSize)
return false;
if (!document_->load_buffer(buffer.Get(), dataSize))
{
URHO3D_LOGERROR("Could not parse XML data from " + source.GetName());
document_->reset();
return false;
}
XMLElement rootElem = GetRoot();
String inherit = rootElem.GetAttribute("inherit");
if (!inherit.Empty())
{
// The existence of this attribute indicates this is an RFC 5261 patch file
ResourceCache* cache = GetSubsystem<ResourceCache>();
// If being async loaded, GetResource() is not safe, so use GetTempResource() instead
XMLFile* inheritedXMLFile = GetAsyncLoadState() == ASYNC_DONE ? cache->GetResource<XMLFile>(inherit) :
cache->GetTempResource<XMLFile>(inherit);
if (!inheritedXMLFile)
{
URHO3D_LOGERRORF("Could not find inherited XML file: %s", inherit.CString());
return false;
}
// Patch this XMLFile and leave the original inherited XMLFile as it is
pugi::xml_document* patchDocument = document_;
document_ = new pugi::xml_document();
document_->reset(*inheritedXMLFile->document_);
Patch(rootElem);
delete patchDocument;
// Store resource dependencies so we know when to reload/repatch when the inherited resource changes
cache->StoreResourceDependency(this, inherit);
// Approximate patched data size
dataSize += inheritedXMLFile->GetMemoryUse();
}
// Note: this probably does not reflect internal data structure size accurately
SetMemoryUse(dataSize);
return true;
}
bool Texture3D::Create()
{
Release();
#ifdef GL_ES_VERSION_2_0
URHO3D_LOGERROR("Failed to create 3D texture, currently unsupported on OpenGL ES 2");
return false;
#else
if (!graphics_ || !width_ || !height_ || !depth_)
return false;
if (graphics_->IsDeviceLost())
{
URHO3D_LOGWARNING("Texture creation while device is lost");
return true;
}
unsigned format = GetSRGB() ? GetSRGBFormat(format_) : format_;
unsigned externalFormat = GetExternalFormat(format_);
unsigned dataType = GetDataType(format_);
glGenTextures(1, &object_.name_);
// Ensure that our texture is bound to OpenGL texture unit 0
graphics_->SetTextureForUpdate(this);
// If not compressed, create the initial level 0 texture with null data
bool success = true;
if (!IsCompressed())
{
glGetError();
glTexImage3D(target_, 0, format, width_, height_, depth_, 0, externalFormat, dataType, 0);
if (glGetError())
{
URHO3D_LOGERROR("Failed to create texture");
success = false;
}
}
// Set mipmapping
levels_ = CheckMaxLevels(width_, height_, depth_, requestedLevels_);
glTexParameteri(target_, GL_TEXTURE_BASE_LEVEL, 0);
glTexParameteri(target_, GL_TEXTURE_MAX_LEVEL, levels_ - 1);
// Set initial parameters, then unbind the texture
UpdateParameters();
graphics_->SetTexture(0, 0);
return success;
#endif
}
bool Texture3D::Create()
{
Release();
#ifdef GL_ES_VERSION_2_0
URHO3D_LOGERROR("Failed to create 3D texture, currently unsupported on OpenGL ES 2");
return false;
#else
if (!graphics_ || !width_ || !height_ || !depth_)
return false;
if (graphics_->IsDeviceLost())
{
URHO3D_LOGWARNING("Texture creation while device is lost");
return true;
}
unsigned format = GetSRGB() ? GetSRGBFormat(format_) : format_;
unsigned externalFormat = GetExternalFormat(format_);
unsigned dataType = GetDataType(format_);
glGenTextures(1, &object_);
// Ensure that our texture is bound to OpenGL texture unit 0
graphics_->SetTextureForUpdate(this);
// If not compressed, create the initial level 0 texture with null data
bool success = true;
if (!IsCompressed())
{
glGetError();
glTexImage3D(target_, 0, format, width_, height_, depth_, 0, externalFormat, dataType, 0);
if (glGetError())
{
URHO3D_LOGERROR("Failed to create texture");
success = false;
}
}
// Set mipmapping
levels_ = requestedLevels_;
if (!levels_)
{
unsigned maxSize = (unsigned)Max(Max((int)width_, (int)height_), (int)depth_);
while (maxSize)
{
maxSize >>= 1;
++levels_;
}
}
bool Texture2D::SetSize(int width, int height, unsigned format, TextureUsage usage, int multiSample, bool autoResolve)
{
if (width <= 0 || height <= 0)
{
URHO3D_LOGERROR("Zero or negative texture dimensions");
return false;
}
multiSample = Clamp(multiSample, 1, 16);
if (multiSample == 1)
autoResolve = false;
else if (multiSample > 1 && usage < TEXTURE_RENDERTARGET)
{
URHO3D_LOGERROR("Multisampling is only supported for rendertarget or depth-stencil textures");
return false;
}
// Disable mipmaps if multisample & custom resolve
if (multiSample > 1 && autoResolve == false)
requestedLevels_ = 1;
// Delete the old rendersurface if any
renderSurface_.Reset();
usage_ = usage;
if (usage >= TEXTURE_RENDERTARGET)
{
renderSurface_ = new RenderSurface(this);
// Clamp mode addressing by default and nearest filtering
addressModes_[COORD_U] = ADDRESS_CLAMP;
addressModes_[COORD_V] = ADDRESS_CLAMP;
filterMode_ = FILTER_NEAREST;
}
if (usage == TEXTURE_RENDERTARGET)
SubscribeToEvent(E_RENDERSURFACEUPDATE, URHO3D_HANDLER(Texture2D, HandleRenderSurfaceUpdate));
else
UnsubscribeFromEvent(E_RENDERSURFACEUPDATE);
width_ = width;
height_ = height;
format_ = format;
depth_ = 1;
multiSample_ = multiSample;
autoResolve_ = autoResolve;
return Create();
}
bool VertexBuffer::SetDataRange(const void* data, unsigned start, unsigned count, bool discard)
{
if (start == 0 && count == vertexCount_)
return SetData(data);
if (!data)
{
URHO3D_LOGERROR("Null pointer for vertex buffer data");
return false;
}
if (!vertexSize_)
{
URHO3D_LOGERROR("Vertex elements not defined, can not set vertex buffer data");
return false;
}
if (start + count > vertexCount_)
{
URHO3D_LOGERROR("Illegal range for setting new vertex buffer data");
return false;
}
if (!count)
return true;
if (shadowData_ && shadowData_.Get() + start * vertexSize_ != data)
memcpy(shadowData_.Get() + start * vertexSize_, data, count * vertexSize_);
if (object_)
{
if (graphics_->IsDeviceLost())
{
URHO3D_LOGWARNING("Vertex buffer data assignment while device is lost");
dataPending_ = true;
return true;
}
void* hwData = MapBuffer(start, count, discard);
if (hwData)
{
memcpy(hwData, data, count * vertexSize_);
UnmapBuffer();
}
else
return false;
}
return true;
}
void RaycastVehicle::SetWheelDataAttr(const VariantVector& value)
{
if (!vehicleData_)
{
URHO3D_LOGERROR("RaycastVehicle: vehicleData doesn't exist");
return;
}
if (value.Size() < 2)
{
URHO3D_LOGERROR("RaycastVehicle: Incorrect vehicleData");
return;
}
loadedWheelData_ = value;
}
bool VertexBuffer::SetDataRange(const void* data, unsigned start, unsigned count, bool discard)
{
if (start == 0 && count == vertexCount_)
return SetData(data);
if (!data)
{
URHO3D_LOGERROR("Null pointer for vertex buffer data");
return false;
}
if (!vertexSize_)
{
URHO3D_LOGERROR("Vertex elements not defined, can not set vertex buffer data");
return false;
}
if (start + count > vertexCount_)
{
URHO3D_LOGERROR("Illegal range for setting new vertex buffer data");
return false;
}
if (!count)
return true;
if (shadowData_ && shadowData_.Get() + start * vertexSize_ != data)
memcpy(shadowData_.Get() + start * vertexSize_, data, count * vertexSize_);
if (object_)
{
if (!graphics_->IsDeviceLost())
{
graphics_->SetVBO(object_);
if (!discard || start != 0)
glBufferSubData(GL_ARRAY_BUFFER, start * vertexSize_, count * vertexSize_, data);
else
glBufferData(GL_ARRAY_BUFFER, count * vertexSize_, data, dynamic_ ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW);
}
else
{
URHO3D_LOGWARNING("Vertex buffer data assignment while device is lost");
dataPending_ = true;
}
}
return true;
}
bool TmxImageLayer2D::Load(const XMLElement& element, const TileMapInfo2D& info)
{
LoadInfo(element);
XMLElement imageElem = element.GetChild("image");
if (!imageElem)
return false;
position_ = Vector2(0.0f, info.GetMapHeight());
source_ = imageElem.GetAttribute("source");
String textureFilePath = GetParentPath(tmxFile_->GetName()) + source_;
ResourceCache* cache = tmxFile_->GetSubsystem<ResourceCache>();
SharedPtr<Texture2D> texture(cache->GetResource<Texture2D>(textureFilePath));
if (!texture)
{
URHO3D_LOGERROR("Could not load texture " + textureFilePath);
return false;
}
sprite_ = new Sprite2D(tmxFile_->GetContext());
sprite_->SetTexture(texture);
sprite_->SetRectangle(IntRect(0, 0, texture->GetWidth(), texture->GetHeight()));
// Set image hot spot at left top
sprite_->SetHotSpot(Vector2(0.0f, 1.0f));
if (element.HasChild("properties"))
LoadPropertySet(element.GetChild("properties"));
return true;
}
void Skeleton::SetRootBoneIndex(unsigned index)
{
if (index < bones_.Size())
rootBoneIndex_ = index;
else
URHO3D_LOGERROR("Root bone index out of bounds");
}
bool Sound::LoadOggVorbis(Deserializer& source)
{
unsigned dataSize = source.GetSize();
SharedArrayPtr<signed char> data(new signed char[dataSize]);
source.Read(data.Get(), dataSize);
// Check for validity of data
int error;
stb_vorbis* vorbis = stb_vorbis_open_memory((unsigned char*)data.Get(), dataSize, &error, nullptr);
if (!vorbis)
{
URHO3D_LOGERROR("Could not read Ogg Vorbis data from " + source.GetName());
return false;
}
// Store length, frequency and stereo flag
stb_vorbis_info info = stb_vorbis_get_info(vorbis);
compressedLength_ = stb_vorbis_stream_length_in_seconds(vorbis);
frequency_ = info.sample_rate;
stereo_ = info.channels > 1;
stb_vorbis_close(vorbis);
data_ = data;
dataSize_ = dataSize;
sixteenBit_ = true;
compressed_ = true;
SetMemoryUse(dataSize);
return true;
}
bool File::Open(PackageFile* package, const String& fileName)
{
if (!package)
return false;
const PackageEntry* entry = package->GetEntry(fileName);
if (!entry)
return false;
bool success = OpenInternal(package->GetName(), FILE_READ, true);
if (!success)
{
URHO3D_LOGERROR("Could not open package file " + fileName);
return false;
}
fileName_ = fileName;
offset_ = entry->offset_;
checksum_ = entry->checksum_;
size_ = entry->size_;
compressed_ = package->IsCompressed();
// Seek to beginning of package entry's file data
SeekInternal(offset_);
return true;
}
void Graphics::SetExternalWindow(void* window)
{
if (!window_)
externalWindow_ = window;
else
URHO3D_LOGERROR("Window already opened, can not set external window");
}
Variant ValueAnimation::SubstractAndMultiply(const Variant& value1, const Variant& value2, float t) const
{
switch (valueType_)
{
case VAR_FLOAT:
return (value1.GetFloat() - value2.GetFloat()) * t;
case VAR_VECTOR2:
return (value1.GetVector2() - value2.GetVector2()) * t;
case VAR_VECTOR3:
return (value1.GetVector3() - value2.GetVector3()) * t;
case VAR_VECTOR4:
return (value1.GetVector4() - value2.GetVector4()) * t;
case VAR_QUATERNION:
return (value1.GetQuaternion() - value2.GetQuaternion()) * t;
case VAR_COLOR:
return (value1.GetColor() - value2.GetColor()) * t;
case VAR_DOUBLE:
return (value1.GetDouble() - value2.GetDouble()) * t;
default:
URHO3D_LOGERROR("Invalid value type for spline interpolation's substract and multiply operation");
return Variant::EMPTY;
}
}
bool ConstantBuffer::SetSize(unsigned size)
{
if (!size)
{
URHO3D_LOGERROR("Can not create zero-sized constant buffer");
return false;
}
// Round up to next 16 bytes
size += 15;
size &= 0xfffffff0;
size_ = size;
dirty_ = false;
shadowData_ = new unsigned char[size_];
memset(shadowData_.Get(), 0, size_);
if (graphics_)
{
#ifndef GL_ES_VERSION_2_0
if (!object_)
glGenBuffers(1, &object_);
graphics_->SetUBO(object_);
glBufferData(GL_UNIFORM_BUFFER, size_, shadowData_.Get(), GL_DYNAMIC_DRAW);
#endif
}
return true;
}
bool VertexBuffer::Create()
{
Release();
if (!vertexCount_ || !elementMask_)
return true;
if (graphics_)
{
D3D11_BUFFER_DESC bufferDesc;
memset(&bufferDesc, 0, sizeof bufferDesc);
bufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
bufferDesc.CPUAccessFlags = dynamic_ ? D3D11_CPU_ACCESS_WRITE : 0;
bufferDesc.Usage = dynamic_ ? D3D11_USAGE_DYNAMIC : D3D11_USAGE_DEFAULT;
bufferDesc.ByteWidth = (UINT)(vertexCount_ * vertexSize_);
graphics_->GetImpl()->GetDevice()->CreateBuffer(&bufferDesc, 0, (ID3D11Buffer**)&object_);
if (!object_)
{
URHO3D_LOGERROR("Failed to create vertex buffer");
return false;
}
}
return true;
}
bool Model::SetGeometry(unsigned index, unsigned lodLevel, Geometry* geometry)
{
if (index >= geometries_.Size())
{
URHO3D_LOGERROR("Geometry index out of bounds");
return false;
}
if (lodLevel >= geometries_[index].Size())
{
URHO3D_LOGERROR("LOD level index out of bounds");
return false;
}
geometries_[index][lodLevel] = geometry;
return true;
}
bool VertexBuffer::Create()
{
if (!vertexCount_ || !elementMask_)
{
Release();
return true;
}
if (graphics_)
{
if (graphics_->IsDeviceLost())
{
URHO3D_LOGWARNING("Vertex buffer creation while device is lost");
return true;
}
if (!object_)
glGenBuffers(1, &object_);
if (!object_)
{
URHO3D_LOGERROR("Failed to create vertex buffer");
return false;
}
graphics_->SetVBO(object_);
glBufferData(GL_ARRAY_BUFFER, vertexCount_ * vertexSize_, 0, dynamic_ ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW);
}
return true;
}
bool IndexBuffer::Create()
{
if (!indexCount_)
{
Release();
return true;
}
if (graphics_)
{
if (graphics_->IsDeviceLost())
{
URHO3D_LOGWARNING("Index buffer creation while device is lost");
return true;
}
if (!object_)
glGenBuffers(1, &object_);
if (!object_)
{
URHO3D_LOGERROR("Failed to create index buffer");
return false;
}
graphics_->SetIndexBuffer(this);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, indexCount_ * indexSize_, 0, dynamic_ ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW);
}
return true;
}
bool Model::SetNumGeometryLodLevels(unsigned index, unsigned num)
{
if (index >= geometries_.Size())
{
URHO3D_LOGERROR("Geometry index out of bounds");
return false;
}
if (!num)
{
URHO3D_LOGERROR("Zero LOD levels not allowed");
return false;
}
geometries_[index].Resize(num);
return true;
}
void CustomGeometry::DefineGeometry(unsigned index, PrimitiveType type, unsigned numVertices, bool hasNormals, bool hasColors,
bool hasTexCoords, bool hasTangents)
{
if (index > geometries_.Size())
{
URHO3D_LOGERROR("Geometry index out of bounds");
return;
}
geometryIndex_ = index;
primitiveTypes_[index] = type;
vertices_[index].Resize(numVertices);
// If defining the first geometry, reset the element mask
if (!index)
elementMask_ = MASK_POSITION;
if (hasNormals)
elementMask_ |= MASK_NORMAL;
if (hasColors)
elementMask_ |= MASK_COLOR;
if (hasTexCoords)
elementMask_ |= MASK_TEXCOORD1;
if (hasTangents)
elementMask_ |= MASK_TANGENT;
}
bool Texture2D::SetSize(int width, int height, unsigned format, TextureUsage usage)
{
if (width <= 0 || height <= 0)
{
URHO3D_LOGERROR("Zero or negative texture dimensions");
return false;
}
// Delete the old rendersurface if any
renderSurface_.Reset();
usage_ = usage;
if (usage >= TEXTURE_RENDERTARGET)
{
renderSurface_ = new RenderSurface(this);
// Clamp mode addressing by default, nearest filtering, and mipmaps disabled
addressMode_[COORD_U] = ADDRESS_CLAMP;
addressMode_[COORD_V] = ADDRESS_CLAMP;
filterMode_ = FILTER_NEAREST;
requestedLevels_ = 1;
}
if (usage == TEXTURE_RENDERTARGET)
SubscribeToEvent(E_RENDERSURFACEUPDATE, URHO3D_HANDLER(Texture2D, HandleRenderSurfaceUpdate));
else
UnsubscribeFromEvent(E_RENDERSURFACEUPDATE);
width_ = width;
height_ = height;
format_ = format;
return Create();
}
bool PListFile::LoadValue(PListValue& value, const XMLElement& valueElem)
{
String valueType = valueElem.GetName();
if (valueType == "string")
value.SetString(valueElem.GetValue());
else if (valueType == "real")
value.SetFloat(ToFloat(valueElem.GetValue()));
else if (valueType == "integer")
value.SetInt(ToInt(valueElem.GetValue()));
else if (valueType == "true")
value.SetBool(true);
else if (valueType == "false")
value.SetBool(false);
else if (valueType == "dict")
{
if (!LoadDict(value.ConvertToValueMap(), valueElem))
return false;
}
else if (valueType == "array")
{
if (!LoadArray(value.ConvertToValueVector(), valueElem))
return false;
}
else
{
URHO3D_LOGERROR("Supported value type");
return false;
}
return true;
}
bool Texture2DArray::GetData(unsigned layer, unsigned level, void* dest) const
{
#ifndef GL_ES_VERSION_2_0
if (!object_.name_ || !graphics_)
{
URHO3D_LOGERROR("Texture array not created, can not get data");
return false;
}
if (!dest)
{
URHO3D_LOGERROR("Null destination for getting data");
return false;
}
if (layer != 0)
{
URHO3D_LOGERROR("Only the full download of the array is supported, set layer=0");
return false;
}
if (level >= levels_)
{
URHO3D_LOGERROR("Illegal mip level for getting data");
return false;
}
if (graphics_->IsDeviceLost())
{
URHO3D_LOGWARNING("Getting texture data while device is lost");
return false;
}
graphics_->SetTextureForUpdate(const_cast<Texture2DArray*>(this));
if (!IsCompressed())
glGetTexImage(target_, level, GetExternalFormat(format_), GetDataType(format_), dest);
else
glGetCompressedTexImage(target_, level, dest);
graphics_->SetTexture(0, 0);
return true;
#else
URHO3D_LOGERROR("Getting texture data not supported");
return false;
#endif
}
bool VertexBuffer::SetData(const void* data)
{
if (!data)
{
URHO3D_LOGERROR("Null pointer for vertex buffer data");
return false;
}
if (!vertexSize_)
{
URHO3D_LOGERROR("Vertex elements not defined, can not set vertex buffer data");
return false;
}
if (shadowData_ && data != shadowData_.Get())
memcpy(shadowData_.Get(), data, vertexCount_ * vertexSize_);
if (object_)
{
if (dynamic_)
{
void* hwData = MapBuffer(0, vertexCount_, true);
if (hwData)
{
memcpy(hwData, data, vertexCount_ * vertexSize_);
UnmapBuffer();
}
else
return false;
}
else
{
D3D11_BOX destBox;
destBox.left = 0;
destBox.right = vertexCount_ * vertexSize_;
destBox.top = 0;
destBox.bottom = 1;
destBox.front = 0;
destBox.back = 1;
graphics_->GetImpl()->GetDeviceContext()->UpdateSubresource((ID3D11Buffer*)object_, 0, &destBox, data, 0, 0);
}
}
return true;
}
bool TmxTileLayer2D::Load(const XMLElement& element, const TileMapInfo2D& info)
{
LoadInfo(element);
XMLElement dataElem = element.GetChild("data");
if (!dataElem)
{
URHO3D_LOGERROR("Could not find data in layer");
return false;
}
if (dataElem.HasAttribute("encoding") && dataElem.GetAttribute("encoding") != "xml")
{
URHO3D_LOGERROR("Encoding not support now");
return false;
}
XMLElement tileElem = dataElem.GetChild("tile");
tiles_.Resize((unsigned)(width_ * height_));
for (int y = 0; y < height_; ++y)
{
for (int x = 0; x < width_; ++x)
{
if (!tileElem)
return false;
int gid = tileElem.GetInt("gid");
if (gid > 0)
{
SharedPtr<Tile2D> tile(new Tile2D());
tile->gid_ = gid;
tile->sprite_ = tmxFile_->GetTileSprite(gid);
tile->propertySet_ = tmxFile_->GetTilePropertySet(gid);
tiles_[y * width_ + x] = tile;
}
tileElem = tileElem.GetNext("tile");
}
}
if (element.HasChild("properties"))
LoadPropertySet(element.GetChild("properties"));
return true;
}
bool IndexBuffer::GetUsedVertexRange(unsigned start, unsigned count, unsigned& minVertex, unsigned& vertexCount)
{
if (!shadowData_)
{
URHO3D_LOGERROR("Used vertex range can only be queried from an index buffer with shadow data");
return false;
}
if (start + count > indexCount_)
{
URHO3D_LOGERROR("Illegal index range for querying used vertices");
return false;
}
minVertex = M_MAX_UNSIGNED;
unsigned maxVertex = 0;
if (indexSize_ == sizeof(unsigned))
{
unsigned* indices = ((unsigned*)shadowData_.Get()) + start;
for (unsigned i = 0; i < count; ++i)
{
if (indices[i] < minVertex)
minVertex = indices[i];
if (indices[i] > maxVertex)
maxVertex = indices[i];
}
}
else
{
unsigned short* indices = ((unsigned short*)shadowData_.Get()) + start;
for (unsigned i = 0; i < count; ++i)
{
if (indices[i] < minVertex)
minVertex = indices[i];
if (indices[i] > maxVertex)
maxVertex = indices[i];
}
}
vertexCount = maxVertex - minVertex + 1;
return true;
}
bool TextureCube::GetData(CubeMapFace face, unsigned level, void* dest) const
{
if (!object_ || !graphics_)
{
URHO3D_LOGERROR("No texture created, can not get data");
return false;
}
if (!dest)
{
URHO3D_LOGERROR("Null destination for getting data");
return false;
}
if (level >= levels_)
{
URHO3D_LOGERROR("Illegal mip level for getting data");
return false;
}
if (graphics_->IsDeviceLost())
{
URHO3D_LOGWARNING("Getting texture data while device is lost");
return false;
}
if (multiSample_ > 1 && !autoResolve_)
{
URHO3D_LOGERROR("Can not get data from multisampled texture without autoresolve");
return false;
}
if (resolveDirty_)
graphics_->ResolveToTexture(const_cast<TextureCube*>(this));
graphics_->SetTextureForUpdate(const_cast<TextureCube*>(this));
if (!IsCompressed())
glGetTexImage(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, level, GetExternalFormat(format_), GetDataType(format_), dest);
else
glGetCompressedTexImage(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, level, dest);
graphics_->SetTexture(0, nullptr);
return true;
}
