livie
/
phoenix-firestorm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
phoenix-firestorm/indra/newview/llmeshrepository.cpp

2813 lines
66 KiB
C++
Raw Blame History

/**
* @file llmeshrepository.cpp
* @brief Mesh repository implementation.
*
* $LicenseInfo:firstyear=2005&license=viewergpl$
*
* Copyright (c) 2005-2009, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
#include "llviewerprecompiledheaders.h"
#include "apr_pools.h"
#include "apr_dso.h"
#include "llmeshrepository.h"
#include "llagent.h"
#include "llappviewer.h"
#include "llbufferstream.h"
#include "llcurl.h"
#include "llfasttimer.h"
#include "llfloatermodelpreview.h"
#include "llfloaterperms.h"
#include "lleconomy.h"
#include "llimagej2c.h"
#include "llhost.h"
#include "llnotificationsutil.h"
#include "llsd.h"
#include "llsdutil_math.h"
#include "llsdserialize.h"
#include "llthread.h"
#include "llvfile.h"
#include "llviewercontrol.h"
#include "llviewermenufile.h"
#include "llviewerobjectlist.h"
#include "llviewerregion.h"
#include "llviewertexturelist.h"
#include "llvolume.h"
#include "llvolumemgr.h"
#include "llvovolume.h"
#include "llworld.h"
#include "material_codes.h"
#include "pipeline.h"
#include <queue>
LLFastTimer::DeclareTimer FTM_MESH_UPDATE("Mesh Update");
LLFastTimer::DeclareTimer FTM_LOAD_MESH("Load Mesh");
LLMeshRepository gMeshRepo;
const U32 MAX_MESH_REQUESTS_PER_SECOND = 100;
U32 LLMeshRepository::sBytesReceived = 0;
U32 LLMeshRepository::sHTTPRequestCount = 0;
U32 LLMeshRepository::sHTTPRetryCount = 0;
U32 LLMeshRepository::sCacheBytesRead = 0;
U32 LLMeshRepository::sCacheBytesWritten = 0;
U32 LLMeshRepository::sPeakKbps = 0;
std::string header_lod[] =
{
"lowest_lod",
"low_lod",
"medium_lod",
"high_lod"
};
//get the number of bytes resident in memory for given volume
U32 get_volume_memory_size(const LLVolume* volume)
{
U32 indices = 0;
U32 vertices = 0;
for (U32 i = 0; i < volume->getNumVolumeFaces(); ++i)
{
const LLVolumeFace& face = volume->getVolumeFace(i);
indices += face.mNumIndices;
vertices += face.mNumVertices;
}
return indices*2+vertices*11+sizeof(LLVolume)+sizeof(LLVolumeFace)*volume->getNumVolumeFaces();
}
std::string scrub_host_name(std::string http_url, const LLHost& host)
{ //curl loves to abuse the DNS cache, so scrub host names out of urls where trivial to prevent DNS timeouts
std::string ip_string = host.getIPString();
std::string host_string = host.getHostName();
std::string::size_type idx = http_url.find(host_string);
if (!ip_string.empty() && !host_string.empty() && idx != std::string::npos)
{
http_url.replace(idx, host_string.length(), ip_string);
}
return http_url;
}
LLVertexBuffer* get_vertex_buffer_from_mesh(LLCDMeshData& mesh, F32 scale = 1.f)
{
LLVertexBuffer* buff = new LLVertexBuffer(LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_NORMAL, 0);
buff->allocateBuffer(mesh.mNumTriangles*3, 0, true);
LLStrider<LLVector3> pos;
LLStrider<LLVector3> norm;
buff->getVertexStrider(pos);
buff->getNormalStrider(norm);
const F32* v = mesh.mVertexBase;
if (mesh.mIndexType == LLCDMeshData::INT_16)
{
U16* idx = (U16*) mesh.mIndexBase;
for (S32 j = 0; j < mesh.mNumTriangles; ++j)
{
F32* mp0 = (F32*) ((U8*)v+idx[0]*mesh.mVertexStrideBytes);
F32* mp1 = (F32*) ((U8*)v+idx[1]*mesh.mVertexStrideBytes);
F32* mp2 = (F32*) ((U8*)v+idx[2]*mesh.mVertexStrideBytes);
idx = (U16*) (((U8*)idx)+mesh.mIndexStrideBytes);
LLVector3 v0(mp0);
LLVector3 v1(mp1);
LLVector3 v2(mp2);
LLVector3 n = (v1-v0)%(v2-v0);
n.normalize();
*pos++ = v0*scale;
*pos++ = v1*scale;
*pos++ = v2*scale;
*norm++ = n;
*norm++ = n;
*norm++ = n;
}
}
else
{
U32* idx = (U32*) mesh.mIndexBase;
for (S32 j = 0; j < mesh.mNumTriangles; ++j)
{
F32* mp0 = (F32*) ((U8*)v+idx[0]*mesh.mVertexStrideBytes);
F32* mp1 = (F32*) ((U8*)v+idx[1]*mesh.mVertexStrideBytes);
F32* mp2 = (F32*) ((U8*)v+idx[2]*mesh.mVertexStrideBytes);
idx = (U32*) (((U8*)idx)+mesh.mIndexStrideBytes);
LLVector3 v0(mp0);
LLVector3 v1(mp1);
LLVector3 v2(mp2);
LLVector3 n = (v1-v0)%(v2-v0);
n.normalize();
*(pos++) = v0*scale;
*(pos++) = v1*scale;
*(pos++) = v2*scale;
*(norm++) = n;
*(norm++) = n;
*(norm++) = n;
}
}
return buff;
}
S32 LLMeshRepoThread::sActiveHeaderRequests = 0;
S32 LLMeshRepoThread::sActiveLODRequests = 0;
U32 LLMeshRepoThread::sMaxConcurrentRequests = 1;
class LLTextureCostResponder : public LLCurl::Responder
{
public:
LLTextureUploadData mData;
LLMeshUploadThread* mThread;
LLTextureCostResponder(LLTextureUploadData data, LLMeshUploadThread* thread)
: mData(data), mThread(thread)
{
}
virtual void completed(U32 status, const std::string& reason, const LLSD& content)
{
mThread->mPendingConfirmations--;
if (isGoodStatus(status))
{
mThread->priceResult(mData, content);
}
else
{
llwarns << status << ": " << reason << llendl;
llwarns << "Retrying. (" << ++mData.mRetries << ")" << llendl;
if (status == 499)
{
mThread->uploadTexture(mData);
}
else
{
llerrs << "Unhandled status " << status << llendl;
}
}
}
};
class LLTextureUploadResponder : public LLCurl::Responder
{
public:
LLTextureUploadData mData;
LLMeshUploadThread* mThread;
LLTextureUploadResponder(LLTextureUploadData data, LLMeshUploadThread* thread)
: mData(data), mThread(thread)
{
}
virtual void completed(U32 status, const std::string& reason, const LLSD& content)
{
mThread->mPendingUploads--;
if (isGoodStatus(status))
{
mData.mUUID = content["new_asset"].asUUID();
gMeshRepo.updateInventory(LLMeshRepository::inventory_data(mData.mPostData, content));
mThread->onTextureUploaded(mData);
}
else
{
llwarns << status << ": " << reason << llendl;
llwarns << "Retrying. (" << ++mData.mRetries << ")" << llendl;
if (status == 404)
{
mThread->uploadTexture(mData);
}
else if (status == 499)
{
mThread->mConfirmedTextureQ.push(mData);
}
else
{
llerrs << "Unhandled status " << status << llendl;
}
}
}
};
class LLMeshCostResponder : public LLCurl::Responder
{
public:
LLMeshUploadData mData;
LLMeshUploadThread* mThread;
LLMeshCostResponder(LLMeshUploadData data, LLMeshUploadThread* thread)
: mData(data), mThread(thread)
{
}
virtual void completed(U32 status, const std::string& reason, const LLSD& content)
{
mThread->mPendingConfirmations--;
if (isGoodStatus(status))
{
mThread->priceResult(mData, content);
}
else
{
llwarns << status << ": " << reason << llendl;
llwarns << "Retrying. (" << ++mData.mRetries << ")" << llendl;
if (status == 499)
{
mThread->uploadModel(mData);
}
else if (status == 400)
{
llwarns << "Status 400 received from server, giving up." << llendl;
}
else
{
llerrs << "Unhandled status " << status << llendl;
}
}
}
};
class LLMeshUploadResponder : public LLCurl::Responder
{
public:
LLMeshUploadData mData;
LLMeshUploadThread* mThread;
LLMeshUploadResponder(LLMeshUploadData data, LLMeshUploadThread* thread)
: mData(data), mThread(thread)
{
}
virtual void completed(U32 status, const std::string& reason, const LLSD& content)
{
mThread->mPendingUploads--;
if (isGoodStatus(status))
{
mData.mUUID = content["new_asset"].asUUID();
if (mData.mUUID.isNull())
{
LLSD args;
std::string message = content["error"]["message"];
std::string identifier = content["error"]["identifier"];
std::string invalidity_identifier = content["error"]["invalidity_identifier"];
args["MESSAGE"] = message;
args["IDENTIFIER"] = identifier;
args["INVALIDITY_IDENTIFIER"] = invalidity_identifier;
args["LABEL"] = mData.mBaseModel->mLabel;
gMeshRepo.uploadError(args);
}
else
{
gMeshRepo.updateInventory(LLMeshRepository::inventory_data(mData.mPostData, content));
mThread->onModelUploaded(mData);
}
}
else
{
llwarns << status << ": " << reason << llendl;
llwarns << "Retrying. (" << ++mData.mRetries << ")" << llendl;
if (status == 404)
{
mThread->uploadModel(mData);
}
else if (status == 499)
{
mThread->mConfirmedQ.push(mData);
}
else if (status != 500)
{ //drop internal server errors on the floor, otherwise grab
llerrs << "Unhandled status " << status << llendl;
}
}
}
};
class LLMeshHeaderResponder : public LLCurl::Responder
{
public:
LLVolumeParams mMeshParams;
LLMeshHeaderResponder(const LLVolumeParams& mesh_params)
: mMeshParams(mesh_params)
{
}
virtual void completedRaw(U32 status, const std::string& reason,
const LLChannelDescriptors& channels,
const LLIOPipe::buffer_ptr_t& buffer);
};
class LLMeshLODResponder : public LLCurl::Responder
{
public:
LLVolumeParams mMeshParams;
S32 mLOD;
U32 mRequestedBytes;
U32 mOffset;
LLMeshLODResponder(const LLVolumeParams& mesh_params, S32 lod, U32 offset, U32 requested_bytes)
: mMeshParams(mesh_params), mLOD(lod), mOffset(offset), mRequestedBytes(requested_bytes)
{
}
virtual void completedRaw(U32 status, const std::string& reason,
const LLChannelDescriptors& channels,
const LLIOPipe::buffer_ptr_t& buffer);
};
class LLMeshSkinInfoResponder : public LLCurl::Responder
{
public:
LLUUID mMeshID;
U32 mRequestedBytes;
U32 mOffset;
LLMeshSkinInfoResponder(const LLUUID& id, U32 offset, U32 size)
: mMeshID(id), mRequestedBytes(size), mOffset(offset)
{
}
virtual void completedRaw(U32 status, const std::string& reason,
const LLChannelDescriptors& channels,
const LLIOPipe::buffer_ptr_t& buffer);
};
class LLMeshDecompositionResponder : public LLCurl::Responder
{
public:
LLUUID mMeshID;
U32 mRequestedBytes;
U32 mOffset;
LLMeshDecompositionResponder(const LLUUID& id, U32 offset, U32 size)
: mMeshID(id), mRequestedBytes(size), mOffset(offset)
{
}
virtual void completedRaw(U32 status, const std::string& reason,
const LLChannelDescriptors& channels,
const LLIOPipe::buffer_ptr_t& buffer);
};
LLMeshRepoThread::LLMeshRepoThread()
: LLThread("mesh repo", NULL)
{
mWaiting = false;
mMutex = new LLMutex(NULL);
mHeaderMutex = new LLMutex(NULL);
mSignal = new LLCondition(NULL);
}
LLMeshRepoThread::~LLMeshRepoThread()
{
}
void LLMeshRepoThread::run()
{
mCurlRequest = new LLCurlRequest();
LLCDResult res = LLConvexDecomposition::initThread();
if (res != LLCD_OK)
{
llwarns << "convex decomposition unable to be loaded" << llendl;
}
while (!LLApp::isQuitting())
{
mWaiting = true;
mSignal->wait();
mWaiting = false;
if (!LLApp::isQuitting())
{
static U32 count = 0;
static F32 last_hundred = gFrameTimeSeconds;
if (gFrameTimeSeconds - last_hundred > 1.f)
{ //a second has gone by, clear count
last_hundred = gFrameTimeSeconds;
count = 0;
}
// NOTE: throttling intentionally favors LOD requests over header requests
while (!mLODReqQ.empty() && count < MAX_MESH_REQUESTS_PER_SECOND && sActiveLODRequests < sMaxConcurrentRequests)
{
{
LLMutexLock lock(mMutex);
LODRequest req = mLODReqQ.front();
mLODReqQ.pop();
if (fetchMeshLOD(req.mMeshParams, req.mLOD))
{
count++;
}
}
}
while (!mHeaderReqQ.empty() && count < MAX_MESH_REQUESTS_PER_SECOND && sActiveHeaderRequests < sMaxConcurrentRequests)
{
{
LLMutexLock lock(mMutex);
HeaderRequest req = mHeaderReqQ.front();
mHeaderReqQ.pop();
if (fetchMeshHeader(req.mMeshParams))
{
count++;
}
}
}
{
std::set<LLUUID> incomplete;
for (std::set<LLUUID>::iterator iter = mSkinRequests.begin(); iter != mSkinRequests.end(); ++iter)
{
LLUUID mesh_id = *iter;
if (!fetchMeshSkinInfo(mesh_id))
{
incomplete.insert(mesh_id);
}
}
mSkinRequests = incomplete;
}
{
std::set<LLUUID> incomplete;
for (std::set<LLUUID>::iterator iter = mDecompositionRequests.begin(); iter != mDecompositionRequests.end(); ++iter)
{
LLUUID mesh_id = *iter;
if (!fetchMeshDecomposition(mesh_id))
{
incomplete.insert(mesh_id);
}
}
mDecompositionRequests = incomplete;
}
}
mCurlRequest->process();
}
res = LLConvexDecomposition::quitThread();
if (res != LLCD_OK)
{
llwarns << "convex decomposition unable to be quit" << llendl;
}
delete mCurlRequest;
delete mMutex;
}
void LLMeshRepoThread::loadMeshSkinInfo(const LLUUID& mesh_id)
{ //protected by mSignal, no locking needed here
mSkinRequests.insert(mesh_id);
}
void LLMeshRepoThread::loadMeshDecomposition(const LLUUID& mesh_id)
{ //protected by mSignal, no locking needed here
mDecompositionRequests.insert(mesh_id);
}
void LLMeshRepoThread::loadMeshLOD(const LLVolumeParams& mesh_params, S32 lod)
{ //protected by mSignal, no locking needed here
mesh_header_map::iterator iter = mMeshHeader.find(mesh_params.getSculptID());
if (iter != mMeshHeader.end())
{ //if we have the header, request LOD byte range
LODRequest req(mesh_params, lod);
mLODReqQ.push(req);
}
else
{
HeaderRequest req(mesh_params);
pending_lod_map::iterator pending = mPendingLOD.find(mesh_params);
if (pending != mPendingLOD.end())
{ //append this lod request to existing header request
pending->second.push_back(lod);
if (pending->second.size() > 4)
{
llerrs << "WTF?" << llendl;
}
}
else
{ //if no header request is pending, fetch header
mHeaderReqQ.push(req);
mPendingLOD[mesh_params].push_back(lod);
}
}
}
//static
std::string LLMeshRepoThread::constructUrl(LLUUID mesh_id)
{
std::string http_url;
if (gAgent.getRegion())
{
http_url = gAgent.getRegion()->getCapability("GetMesh");
scrub_host_name(http_url, gAgent.getRegionHost());
}
if (!http_url.empty())
{
http_url += "/?mesh_id=";
http_url += mesh_id.asString().c_str();
}
else
{
llwarns << "Current region does not have GetMesh capability! Cannot load " << mesh_id << ".mesh" << llendl;
}
return http_url;
}
bool LLMeshRepoThread::fetchMeshSkinInfo(const LLUUID& mesh_id)
{ //protected by mMutex
mHeaderMutex->lock();
if (mMeshHeader.find(mesh_id) == mMeshHeader.end())
{ //we have no header info for this mesh, do nothing
mHeaderMutex->unlock();
return false;
}
U32 header_size = mMeshHeaderSize[mesh_id];
if (header_size > 0)
{
S32 offset = header_size + mMeshHeader[mesh_id]["skin"]["offset"].asInteger();
S32 size = mMeshHeader[mesh_id]["skin"]["size"].asInteger();
mHeaderMutex->unlock();
if (offset >= 0 && size > 0)
{
//check VFS for mesh skin info
LLVFile file(gVFS, mesh_id, LLAssetType::AT_MESH);
if (file.getSize() >= offset+size)
{
LLMeshRepository::sCacheBytesRead += size;
file.seek(offset);
U8* buffer = new U8[size];
file.read(buffer, size);
//make sure buffer isn't all 0's (reserved block but not written)
bool zero = true;
for (S32 i = 0; i < llmin(size, 1024) && zero; ++i)
{
zero = buffer[i] > 0 ? false : true;
}
if (!zero)
{ //attempt to parse
if (skinInfoReceived(mesh_id, buffer, size))
{
delete[] buffer;
return true;
}
}
delete[] buffer;
}
//reading from VFS failed for whatever reason, fetch from sim
std::vector<std::string> headers;
headers.push_back("Accept: application/octet-stream");
std::string http_url = constructUrl(mesh_id);
if (!http_url.empty())
{
++sActiveLODRequests;
LLMeshRepository::sHTTPRequestCount++;
mCurlRequest->getByteRange(constructUrl(mesh_id), headers, offset, size,
new LLMeshSkinInfoResponder(mesh_id, offset, size));
}
}
}
else
{
mHeaderMutex->unlock();
}
//early out was not hit, effectively fetched
return true;
}
bool LLMeshRepoThread::fetchMeshDecomposition(const LLUUID& mesh_id)
{ //protected by mMutex
mHeaderMutex->lock();
if (mMeshHeader.find(mesh_id) == mMeshHeader.end())
{ //we have no header info for this mesh, do nothing
mHeaderMutex->unlock();
return false;
}
U32 header_size = mMeshHeaderSize[mesh_id];
if (header_size > 0)
{
S32 offset = header_size + mMeshHeader[mesh_id]["decomposition"]["offset"].asInteger();
S32 size = mMeshHeader[mesh_id]["decomposition"]["size"].asInteger();
mHeaderMutex->unlock();
if (offset >= 0 && size > 0)
{
//check VFS for mesh skin info
LLVFile file(gVFS, mesh_id, LLAssetType::AT_MESH);
if (file.getSize() >= offset+size)
{
LLMeshRepository::sCacheBytesRead += size;
file.seek(offset);
U8* buffer = new U8[size];
file.read(buffer, size);
//make sure buffer isn't all 0's (reserved block but not written)
bool zero = true;
for (S32 i = 0; i < llmin(size, 1024) && zero; ++i)
{
zero = buffer[i] > 0 ? false : true;
}
if (!zero)
{ //attempt to parse
if (decompositionReceived(mesh_id, buffer, size))
{
delete[] buffer;
return true;
}
}
delete[] buffer;
}
//reading from VFS failed for whatever reason, fetch from sim
std::vector<std::string> headers;
headers.push_back("Accept: application/octet-stream");
std::string http_url = constructUrl(mesh_id);
if (!http_url.empty())
{
++sActiveLODRequests;
LLMeshRepository::sHTTPRequestCount++;
mCurlRequest->getByteRange(constructUrl(mesh_id), headers, offset, size,
new LLMeshDecompositionResponder(mesh_id, offset, size));
}
}
}
else
{
mHeaderMutex->unlock();
}
//early out was not hit, effectively fetched
return true;
}
bool LLMeshRepoThread::fetchMeshHeader(const LLVolumeParams& mesh_params)
{
bool retval = false;
{
//look for mesh in asset in vfs
LLVFile file(gVFS, mesh_params.getSculptID(), LLAssetType::AT_MESH);
S32 size = file.getSize();
if (size > 0)
{
U8 buffer[1024];
S32 bytes = llmin(size, 1024);
LLMeshRepository::sCacheBytesRead += bytes;
file.read(buffer, bytes);
if (headerReceived(mesh_params, buffer, bytes))
{ //did not do an HTTP request, return false
return false;
}
}
}
//either cache entry doesn't exist or is corrupt, request header from simulator
std::vector<std::string> headers;
headers.push_back("Accept: application/octet-stream");
std::string http_url = constructUrl(mesh_params.getSculptID());
if (!http_url.empty())
{
++sActiveHeaderRequests;
retval = true;
//grab first 4KB if we're going to bother with a fetch. Cache will prevent future fetches if a full mesh fits
//within the first 4KB
LLMeshRepository::sHTTPRequestCount++;
mCurlRequest->getByteRange(http_url, headers, 0, 4096, new LLMeshHeaderResponder(mesh_params));
}
return retval;
}
bool LLMeshRepoThread::fetchMeshLOD(const LLVolumeParams& mesh_params, S32 lod)
{ //protected by mMutex
mHeaderMutex->lock();
bool retval = false;
LLUUID mesh_id = mesh_params.getSculptID();
U32 header_size = mMeshHeaderSize[mesh_id];
if (header_size > 0)
{
S32 offset = header_size + mMeshHeader[mesh_id][header_lod[lod]]["offset"].asInteger();
S32 size = mMeshHeader[mesh_id][header_lod[lod]]["size"].asInteger();
mHeaderMutex->unlock();
if (offset >= 0 && size > 0)
{
//check VFS for mesh asset
LLVFile file(gVFS, mesh_id, LLAssetType::AT_MESH);
if (file.getSize() >= offset+size)
{
LLMeshRepository::sCacheBytesRead += size;
file.seek(offset);
U8* buffer = new U8[size];
file.read(buffer, size);
//make sure buffer isn't all 0's (reserved block but not written)
bool zero = true;
for (S32 i = 0; i < llmin(size, 1024) && zero; ++i)
{
zero = buffer[i] > 0 ? false : true;
}
if (!zero)
{ //attempt to parse
if (lodReceived(mesh_params, lod, buffer, size))
{
delete[] buffer;
return false;
}
}
delete[] buffer;
}
//reading from VFS failed for whatever reason, fetch from sim
std::vector<std::string> headers;
headers.push_back("Accept: application/octet-stream");
std::string http_url = constructUrl(mesh_id);
if (!http_url.empty())
{
++sActiveLODRequests;
retval = true;
LLMeshRepository::sHTTPRequestCount++;
mCurlRequest->getByteRange(constructUrl(mesh_id), headers, offset, size,
new LLMeshLODResponder(mesh_params, lod, offset, size));
}
else
{
mUnavailableQ.push(LODRequest(mesh_params, lod));
}
}
else
{
mUnavailableQ.push(LODRequest(mesh_params, lod));
}
}
else
{
mHeaderMutex->unlock();
}
return retval;
}
bool LLMeshRepoThread::headerReceived(const LLVolumeParams& mesh_params, U8* data, S32 data_size)
{
LLSD header;
U32 header_size = 0;
if (data_size > 0)
{
std::string res_str((char*) data, data_size);
std::string deprecated_header("<? LLSD/Binary ?>");
if (res_str.substr(0, deprecated_header.size()) == deprecated_header)
{
res_str = res_str.substr(deprecated_header.size()+1, data_size);
header_size = deprecated_header.size()+1;
}
data_size = res_str.size();
std::istringstream stream(res_str);
if (!LLSDSerialize::fromBinary(header, stream, data_size))
{
llwarns << "Mesh header parse error. Not a valid mesh asset!" << llendl;
return false;
}
header_size += stream.tellg();
}
else
{
header["404"] = 1;
}
{
U32 cost = gMeshRepo.calcResourceCost(header);
LLUUID mesh_id = mesh_params.getSculptID();
mHeaderMutex->lock();
mMeshHeaderSize[mesh_id] = header_size;
mMeshHeader[mesh_id] = header;
mMeshResourceCost[mesh_id] = cost;
mHeaderMutex->unlock();
//check for pending requests
pending_lod_map::iterator iter = mPendingLOD.find(mesh_params);
if (iter != mPendingLOD.end())
{
for (U32 i = 0; i < iter->second.size(); ++i)
{
LODRequest req(mesh_params, iter->second[i]);
mLODReqQ.push(req);
}
}
mPendingLOD.erase(iter);
}
return true;
}
bool LLMeshRepoThread::lodReceived(const LLVolumeParams& mesh_params, S32 lod, U8* data, S32 data_size)
{
LLVolume* volume = new LLVolume(mesh_params, LLVolumeLODGroup::getVolumeScaleFromDetail(lod));
std::string mesh_string((char*) data, data_size);
std::istringstream stream(mesh_string);
if (volume->unpackVolumeFaces(stream, data_size))
{
LoadedMesh mesh(volume, mesh_params, lod);
if (volume->getNumFaces() > 0)
{
LLMutexLock lock(mMutex);
mLoadedQ.push(mesh);
return true;
}
}
return false;
}
bool LLMeshRepoThread::skinInfoReceived(const LLUUID& mesh_id, U8* data, S32 data_size)
{
LLSD skin;
if (data_size > 0)
{
std::string res_str((char*) data, data_size);
std::istringstream stream(res_str);
if (!unzip_llsd(skin, stream, data_size))
{
llwarns << "Mesh skin info parse error. Not a valid mesh asset!" << llendl;
return false;
}
}
{
LLMeshSkinInfo info;
info.mMeshID = mesh_id;
if (skin.has("joint_names"))
{
for (U32 i = 0; i < skin["joint_names"].size(); ++i)
{
info.mJointNames.push_back(skin["joint_names"][i]);
}
}
if (skin.has("inverse_bind_matrix"))
{
for (U32 i = 0; i < skin["inverse_bind_matrix"].size(); ++i)
{
LLMatrix4 mat;
for (U32 j = 0; j < 4; j++)
{
for (U32 k = 0; k < 4; k++)
{
mat.mMatrix[j][k] = skin["inverse_bind_matrix"][i][j*4+k].asReal();
}
}
info.mInvBindMatrix.push_back(mat);
}
}
if (skin.has("bind_shape_matrix"))
{
for (U32 j = 0; j < 4; j++)
{
for (U32 k = 0; k < 4; k++)
{
info.mBindShapeMatrix.mMatrix[j][k] = skin["bind_shape_matrix"][j*4+k].asReal();
}
}
}
if (skin.has("alt_inverse_bind_matrix"))
{
for (U32 i = 0; i < skin["alt_inverse_bind_matrix"].size(); ++i)
{
LLMatrix4 mat;
for (U32 j = 0; j < 4; j++)
{
for (U32 k = 0; k < 4; k++)
{
mat.mMatrix[j][k] = skin["alt_inverse_bind_matrix"][i][j*4+k].asReal();
}
}
info.mAlternateBindMatrix.push_back(mat);
}
}
mSkinInfoQ.push(info);
}
return true;
}
bool LLMeshRepoThread::decompositionReceived(const LLUUID& mesh_id, U8* data, S32 data_size)
{
LLSD decomp;
if (data_size > 0)
{
std::string res_str((char*) data, data_size);
std::istringstream stream(res_str);
if (!unzip_llsd(decomp, stream, data_size))
{
llwarns << "Mesh decomposition parse error. Not a valid mesh asset!" << llendl;
return false;
}
}
{
LLMeshDecomposition* d = new LLMeshDecomposition();
d->mMeshID = mesh_id;
// updated for const-correctness. gcc is picky about this type of thing - Nyx
const LLSD::Binary& hulls = decomp["HullList"].asBinary();
const LLSD::Binary& position = decomp["Position"].asBinary();
U16* p = (U16*) &position[0];
d->mHull.resize(hulls.size());
LLVector3 min;
LLVector3 max;
LLVector3 range;
min.setValue(decomp["Min"]);
max.setValue(decomp["Max"]);
range = max-min;
for (U32 i = 0; i < hulls.size(); ++i)
{
U8 count = hulls[i];
for (U32 j = 0; j < count; ++j)
{
d->mHull[i].push_back(LLVector3(
(F32) p[0]/65535.f*range.mV[0]+min.mV[0],
(F32) p[1]/65535.f*range.mV[1]+min.mV[1],
(F32) p[2]/65535.f*range.mV[2]+min.mV[2]));
p += 3;
}
}
//get mesh for decomposition
for (U32 i = 0; i < d->mHull.size(); ++i)
{
LLCDHull hull;
hull.mNumVertices = d->mHull[i].size();
hull.mVertexBase = d->mHull[i][0].mV;
hull.mVertexStrideBytes = 12;
LLCDMeshData mesh;
LLCDResult res = LLCD_OK;
if (LLConvexDecomposition::getInstance() != NULL)
{
res = LLConvexDecomposition::getInstance()->getMeshFromHull(&hull, &mesh);
}
if (res != LLCD_OK)
{
llwarns << "could not get mesh from hull from convex decomposition lib." << llendl;
return false;
}
d->mMesh.push_back(get_vertex_buffer_from_mesh(mesh));
}
mDecompositionQ.push(d);
}
return true;
}
LLMeshUploadThread::LLMeshUploadThread(LLMeshUploadThread::instance_list& data, LLVector3& scale, bool upload_textures,
bool upload_skin, bool upload_joints)
: LLThread("mesh upload")
{
mInstanceList = data;
mUploadTextures = upload_textures;
mUploadSkin = upload_skin;
mUploadJoints = upload_joints;
mMutex = new LLMutex(NULL);
mCurlRequest = NULL;
mPendingConfirmations = 0;
mPendingUploads = 0;
mPendingCost = 0;
mFinished = false;
mOrigin = gAgent.getPositionAgent();
mHost = gAgent.getRegionHost();
mUploadObjectAssetCapability = gAgent.getRegion()->getCapability("UploadObjectAsset");
mNewInventoryCapability = gAgent.getRegion()->getCapability("NewFileAgentInventoryVariablePrice");
mOrigin += gAgent.getAtAxis() * scale.magVec();
scrub_host_name(mUploadObjectAssetCapability, mHost);
scrub_host_name(mNewInventoryCapability, mHost);
}
LLMeshUploadThread::~LLMeshUploadThread()
{
}
void LLMeshUploadThread::run()
{
mCurlRequest = new LLCurlRequest();
//build map of LLModel refs to instances for callbacks
for (instance_list::iterator iter = mInstanceList.begin(); iter != mInstanceList.end(); ++iter)
{
mInstance[iter->mModel].push_back(*iter);
}
std::set<LLPointer<LLViewerTexture> > textures;
//populate upload queue with relevant models
for (instance_map::iterator iter = mInstance.begin(); iter != mInstance.end(); ++iter)
{
LLMeshUploadData data;
data.mBaseModel = iter->first;
LLModelInstance& instance = *(iter->second.begin());
for (S32 i = 0; i < 5; i++)
{
data.mModel[i] = instance.mLOD[i];
}
uploadModel(data);
if (mUploadTextures)
{
for (std::vector<LLImportMaterial>::iterator material_iter = instance.mMaterial.begin();
material_iter != instance.mMaterial.end(); ++material_iter)
{
if (textures.find(material_iter->mDiffuseMap) == textures.end())
{
textures.insert(material_iter->mDiffuseMap);
LLTextureUploadData data(material_iter->mDiffuseMap, material_iter->mDiffuseMapLabel);
uploadTexture(data);
}
}
}
}
//upload textures
bool done = false;
do
{
if (!mTextureQ.empty())
{
sendCostRequest(mTextureQ.front());
mTextureQ.pop();
}
if (!mConfirmedTextureQ.empty())
{
doUploadTexture(mConfirmedTextureQ.front());
mConfirmedTextureQ.pop();
}
mCurlRequest->process();
done = mTextureQ.empty() && mConfirmedTextureQ.empty();
}
while (!done || mCurlRequest->getQueued() > 0);
LLSD object_asset;
object_asset["objects"] = LLSD::emptyArray();
done = false;
do
{
static S32 count = 0;
static F32 last_hundred = gFrameTimeSeconds;
if (gFrameTimeSeconds - last_hundred > 1.f)
{
last_hundred = gFrameTimeSeconds;
count = 0;
}
//how many requests to push before calling process
const S32 PUSH_PER_PROCESS = 32;
S32 tcount = llmin(count+PUSH_PER_PROCESS, 100);
while (!mUploadQ.empty() && count < tcount)
{ //send any pending upload requests
mMutex->lock();
LLMeshUploadData data = mUploadQ.front();
mUploadQ.pop();
mMutex->unlock();
sendCostRequest(data);
count++;
}
tcount = llmin(count+PUSH_PER_PROCESS, 100);
while (!mConfirmedQ.empty() && count < tcount)
{ //process any meshes that have been confirmed for upload
LLMeshUploadData& data = mConfirmedQ.front();
doUploadModel(data);
mConfirmedQ.pop();
count++;
}
tcount = llmin(count+PUSH_PER_PROCESS, 100);
while (!mInstanceQ.empty() && count < tcount)
{ //create any objects waiting for upload
count++;
object_asset["objects"].append(createObject(mInstanceQ.front()));
mInstanceQ.pop();
}
mCurlRequest->process();
done = mInstanceQ.empty() && mConfirmedQ.empty() && mUploadQ.empty();
}
while (!done || mCurlRequest->getQueued() > 0);
delete mCurlRequest;
mCurlRequest = NULL;
// now upload the object asset
std::string url = mUploadObjectAssetCapability;
if (object_asset["objects"][0].has("permissions"))
{ //copy permissions from first available object to be used for coalesced object
object_asset["permissions"] = object_asset["objects"][0]["permissions"];
}
LLHTTPClient::post(url, object_asset, new LLHTTPClient::Responder());
mFinished = true;
}
void LLMeshUploadThread::uploadModel(LLMeshUploadData& data)
{ //called from arbitrary thread
{
LLMutexLock lock(mMutex);
mUploadQ.push(data);
}
}
void LLMeshUploadThread::uploadTexture(LLTextureUploadData& data)
{ //called from mesh upload thread
mTextureQ.push(data);
}
static LLFastTimer::DeclareTimer FTM_NOTIFY_MESH_LOADED("Notify Loaded");
static LLFastTimer::DeclareTimer FTM_NOTIFY_MESH_UNAVAILABLE("Notify Unavailable");
void LLMeshRepoThread::notifyLoadedMeshes()
{
while (!mLoadedQ.empty())
{
mMutex->lock();
LoadedMesh mesh = mLoadedQ.front();
mLoadedQ.pop();
mMutex->unlock();
if (mesh.mVolume && mesh.mVolume->getNumVolumeFaces() > 0)
{
gMeshRepo.notifyMeshLoaded(mesh.mMeshParams, mesh.mVolume);
}
else
{
gMeshRepo.notifyMeshUnavailable(mesh.mMeshParams,
LLVolumeLODGroup::getVolumeDetailFromScale(mesh.mVolume->getDetail()));
}
}
while (!mUnavailableQ.empty())
{
mMutex->lock();
LODRequest req = mUnavailableQ.front();
mUnavailableQ.pop();
mMutex->unlock();
gMeshRepo.notifyMeshUnavailable(req.mMeshParams, req.mLOD);
}
while (!mSkinInfoQ.empty())
{
gMeshRepo.notifySkinInfoReceived(mSkinInfoQ.front());
mSkinInfoQ.pop();
}
while (!mDecompositionQ.empty())
{
gMeshRepo.notifyDecompositionReceived(mDecompositionQ.front());
mDecompositionQ.pop();
}
}
S32 LLMeshRepoThread::getActualMeshLOD(const LLVolumeParams& mesh_params, S32 lod)
{ //only ever called from main thread
lod = llclamp(lod, 0, 3);
LLMutexLock lock(mHeaderMutex);
mesh_header_map::iterator iter = mMeshHeader.find(mesh_params.getSculptID());
if (iter != mMeshHeader.end())
{
LLSD& header = iter->second;
if (header.has("404"))
{
return -1;
}
if (header[header_lod[lod]]["size"].asInteger() > 0)
{
return lod;
}
//search down to find the next available lower lod
for (S32 i = lod-1; i >= 0; --i)
{
if (header[header_lod[i]]["size"].asInteger() > 0)
{
return i;
}
}
//search up to find then ext available higher lod
for (S32 i = lod+1; i < 4; ++i)
{
if (header[header_lod[i]]["size"].asInteger() > 0)
{
return i;
}
}
//header exists and no good lod found, treat as 404
header["404"] = 1;
return -1;
}
return lod;
}
U32 LLMeshRepoThread::getResourceCost(const LLUUID& mesh_id)
{
LLMutexLock lock(mHeaderMutex);
std::map<LLUUID, U32>::iterator iter = mMeshResourceCost.find(mesh_id);
if (iter != mMeshResourceCost.end())
{
return iter->second;
}
return 0;
}
void LLMeshRepository::cacheOutgoingMesh(LLMeshUploadData& data, LLSD& header)
{
mThread->mMeshHeader[data.mUUID] = header;
// we cache the mesh for default parameters
LLVolumeParams volume_params;
volume_params.setType(LL_PCODE_PROFILE_SQUARE, LL_PCODE_PATH_LINE);
volume_params.setSculptID(data.mUUID, LL_SCULPT_TYPE_MESH);
for (U32 i = 0; i < 4; i++)
{
if (data.mModel[i].notNull())
{
LLPointer<LLVolume> volume = new LLVolume(volume_params, LLVolumeLODGroup::getVolumeScaleFromDetail(i));
volume->copyVolumeFaces(data.mModel[i]);
}
}
}
void LLMeshLODResponder::completedRaw(U32 status, const std::string& reason,
const LLChannelDescriptors& channels,
const LLIOPipe::buffer_ptr_t& buffer)
{
LLMeshRepoThread::sActiveLODRequests--;
S32 data_size = buffer->countAfter(channels.in(), NULL);
if (status < 200 || status > 400)
{
llwarns << status << ": " << reason << llendl;
}
if (data_size < mRequestedBytes)
{
if (status == 499 || status == 503)
{ //timeout or service unavailable, try again
LLMeshRepository::sHTTPRetryCount++;
gMeshRepo.mThread->loadMeshLOD(mMeshParams, mLOD);
}
else
{
llwarns << "Unhandled status " << status << llendl;
}
return;
}
LLMeshRepository::sBytesReceived += mRequestedBytes;
U8* data = NULL;
if (data_size > 0)
{
data = new U8[data_size];
buffer->readAfter(channels.in(), NULL, data, data_size);
}
if (gMeshRepo.mThread->lodReceived(mMeshParams, mLOD, data, data_size))
{
//good fetch from sim, write to VFS for caching
LLVFile file(gVFS, mMeshParams.getSculptID(), LLAssetType::AT_MESH, LLVFile::WRITE);
S32 offset = mOffset;
S32 size = mRequestedBytes;
if (file.getSize() >= offset+size)
{
file.seek(offset);
file.write(data, size);
LLMeshRepository::sCacheBytesWritten += size;
}
}
delete [] data;
}
void LLMeshSkinInfoResponder::completedRaw(U32 status, const std::string& reason,
const LLChannelDescriptors& channels,
const LLIOPipe::buffer_ptr_t& buffer)
{
S32 data_size = buffer->countAfter(channels.in(), NULL);
if (status < 200 || status > 400)
{
llwarns << status << ": " << reason << llendl;
}
if (data_size < mRequestedBytes)
{
if (status == 499 || status == 503)
{ //timeout or service unavailable, try again
LLMeshRepository::sHTTPRetryCount++;
gMeshRepo.mThread->loadMeshSkinInfo(mMeshID);
}
else
{
llwarns << "Unhandled status " << status << llendl;
}
return;
}
LLMeshRepository::sBytesReceived += mRequestedBytes;
U8* data = NULL;
if (data_size > 0)
{
data = new U8[data_size];
buffer->readAfter(channels.in(), NULL, data, data_size);
}
if (gMeshRepo.mThread->skinInfoReceived(mMeshID, data, data_size))
{
//good fetch from sim, write to VFS for caching
LLVFile file(gVFS, mMeshID, LLAssetType::AT_MESH, LLVFile::WRITE);
S32 offset = mOffset;
S32 size = mRequestedBytes;
if (file.getSize() >= offset+size)
{
LLMeshRepository::sCacheBytesWritten += size;
file.seek(offset);
file.write(data, size);
}
}
delete [] data;
}
void LLMeshDecompositionResponder::completedRaw(U32 status, const std::string& reason,
const LLChannelDescriptors& channels,
const LLIOPipe::buffer_ptr_t& buffer)
{
S32 data_size = buffer->countAfter(channels.in(), NULL);
if (status < 200 || status > 400)
{
llwarns << status << ": " << reason << llendl;
}
if (data_size < mRequestedBytes)
{
if (status == 499 || status == 503)
{ //timeout or service unavailable, try again
LLMeshRepository::sHTTPRetryCount++;
gMeshRepo.mThread->loadMeshDecomposition(mMeshID);
}
else
{
llwarns << "Unhandled status " << status << llendl;
}
return;
}
LLMeshRepository::sBytesReceived += mRequestedBytes;
U8* data = NULL;
if (data_size > 0)
{
data = new U8[data_size];
buffer->readAfter(channels.in(), NULL, data, data_size);
}
if (gMeshRepo.mThread->decompositionReceived(mMeshID, data, data_size))
{
//good fetch from sim, write to VFS for caching
LLVFile file(gVFS, mMeshID, LLAssetType::AT_MESH, LLVFile::WRITE);
S32 offset = mOffset;
S32 size = mRequestedBytes;
if (file.getSize() >= offset+size)
{
LLMeshRepository::sCacheBytesWritten += size;
file.seek(offset);
file.write(data, size);
}
}
delete [] data;
}
void LLMeshHeaderResponder::completedRaw(U32 status, const std::string& reason,
const LLChannelDescriptors& channels,
const LLIOPipe::buffer_ptr_t& buffer)
{
LLMeshRepoThread::sActiveHeaderRequests--;
if (status < 200 || status > 400)
{
llwarns << status << ": " << reason << llendl;
}
S32 data_size = buffer->countAfter(channels.in(), NULL);
U8* data = NULL;
if (data_size > 0)
{
data = new U8[data_size];
buffer->readAfter(channels.in(), NULL, data, data_size);
}
LLMeshRepository::sBytesReceived += llmin(data_size, 4096);
if (!gMeshRepo.mThread->headerReceived(mMeshParams, data, data_size))
{
llwarns << "Header responder failed with status: " << status << ": " << reason << llendl;
if (status == 503 || status == 499)
{ //retry
LLMeshRepository::sHTTPRetryCount++;
LLMeshRepoThread::HeaderRequest req(mMeshParams);
gMeshRepo.mThread->mHeaderReqQ.push(req);
}
}
else if (data && data_size > 0)
{
//header was successfully retrieved from sim, cache in vfs
LLUUID mesh_id = mMeshParams.getSculptID();
LLSD header = gMeshRepo.mThread->mMeshHeader[mesh_id];
std::stringstream str;
S32 lod_bytes = 0;
for (U32 i = 0; i < LLModel::LOD_PHYSICS; ++i)
{ //figure out how many bytes we'll need to reserve in the file
std::string lod_name = header_lod[i];
lod_bytes = llmax(lod_bytes, header[lod_name]["offset"].asInteger()+header[lod_name]["size"].asInteger());
}
//just in case skin info or decomposition is at the end of the file (which it shouldn't be)
lod_bytes = llmax(lod_bytes, header["skin"]["offset"].asInteger() + header["skin"]["size"].asInteger());
lod_bytes = llmax(lod_bytes, header["decomposition"]["offset"].asInteger() + header["decomposition"]["size"].asInteger());
S32 header_bytes = (S32) gMeshRepo.mThread->mMeshHeaderSize[mesh_id];
S32 bytes = lod_bytes + header_bytes;
//it's possible for the remote asset to have more data than is needed for the local cache
//only allocate as much space in the VFS as is needed for the local cache
data_size = llmin(data_size, bytes);
LLVFile file(gVFS, mesh_id, LLAssetType::AT_MESH, LLVFile::WRITE);
if (file.getMaxSize() >= bytes || file.setMaxSize(bytes))
{
LLMeshRepository::sCacheBytesWritten += data_size;
file.write((const U8*) data, data_size);
//zero out the rest of the file
U8 block[4096];
memset(block, 0, 4096);
while (bytes-file.tell() > 4096)
{
file.write(block, 4096);
}
S32 remaining = bytes-file.tell();
if (remaining < 0 || remaining > 4096)
{
llerrs << "Bad padding of mesh asset cache entry." << llendl;
}
if (remaining > 0)
{
file.write(block, remaining);
}
}
}
delete [] data;
}
LLMeshRepository::LLMeshRepository()
: mMeshMutex(NULL),
mMeshThreadCount(0),
mThread(NULL)
{
}
void LLMeshRepository::init()
{
mMeshMutex = new LLMutex(NULL);
mDecompThread = new LLPhysicsDecomp();
mDecompThread->start();
while (!mDecompThread->mInited)
{ //wait for physics decomp thread to init
apr_sleep(100);
}
mThread = new LLMeshRepoThread();
mThread->start();
}
void LLMeshRepository::shutdown()
{
mThread->mSignal->signal();
delete mThread;
mThread = NULL;
for (U32 i = 0; i < mUploads.size(); ++i)
{
delete mUploads[i];
}
mUploads.clear();
delete mMeshMutex;
mMeshMutex = NULL;
if (mDecompThread)
{
mDecompThread->shutdown();
delete mDecompThread;
mDecompThread = NULL;
}
}
S32 LLMeshRepository::loadMesh(LLVOVolume* vobj, const LLVolumeParams& mesh_params, S32 detail)
{
if (detail < 0 || detail > 4)
{
return detail;
}
LLFastTimer t(FTM_LOAD_MESH);
{
LLMutexLock lock(mMeshMutex);
//add volume to list of loading meshes
mesh_load_map::iterator iter = mLoadingMeshes[detail].find(mesh_params);
if (iter != mLoadingMeshes[detail].end())
{ //request pending for this mesh, append volume id to list
iter->second.insert(vobj->getID());
}
else
{
//first request for this mesh
mLoadingMeshes[detail][mesh_params].insert(vobj->getID());
mPendingRequests.push_back(LLMeshRepoThread::LODRequest(mesh_params, detail));
}
}
//do a quick search to see if we can't display something while we wait for this mesh to load
LLVolume* volume = vobj->getVolume();
if (volume)
{
if (volume->getNumVolumeFaces() == 0 && !volume->isTetrahedron())
{
volume->makeTetrahedron();
}
LLVolumeParams params = volume->getParams();
LLVolumeLODGroup* group = LLPrimitive::getVolumeManager()->getGroup(params);
if (group)
{
//first see what the next lowest LOD available might be
for (S32 i = detail-1; i >= 0; --i)
{
LLVolume* lod = group->refLOD(i);
if (lod && !lod->isTetrahedron() && lod->getNumVolumeFaces() > 0)
{
group->derefLOD(lod);
return i;
}
group->derefLOD(lod);
}
//no lower LOD is a available, is a higher lod available?
for (S32 i = detail+1; i < 4; ++i)
{
LLVolume* lod = group->refLOD(i);
if (lod && !lod->isTetrahedron() && lod->getNumVolumeFaces() > 0)
{
group->derefLOD(lod);
return i;
}
group->derefLOD(lod);
}
}
else
{
llerrs << "WTF?" << llendl;
}
}
return detail;
}
static LLFastTimer::DeclareTimer FTM_START_MESH_THREAD("Start Thread");
static LLFastTimer::DeclareTimer FTM_LOAD_MESH_LOD("Load LOD");
static LLFastTimer::DeclareTimer FTM_MESH_LOCK1("Lock 1");
static LLFastTimer::DeclareTimer FTM_MESH_LOCK2("Lock 2");
void LLMeshRepository::notifyLoadedMeshes()
{ //called from main thread
LLMeshRepoThread::sMaxConcurrentRequests = gSavedSettings.getU32("MeshMaxConcurrentRequests");
//clean up completed upload threads
for (std::vector<LLMeshUploadThread*>::iterator iter = mUploads.begin(); iter != mUploads.end(); )
{
LLMeshUploadThread* thread = *iter;
if (thread->isStopped() && thread->finished())
{
iter = mUploads.erase(iter);
delete thread;
}
else
{
++iter;
}
}
//update inventory
if (!mInventoryQ.empty())
{
LLMutexLock lock(mMeshMutex);
while (!mInventoryQ.empty())
{
inventory_data& data = mInventoryQ.front();
LLAssetType::EType asset_type = LLAssetType::lookup(data.mPostData["asset_type"].asString());
LLInventoryType::EType inventory_type = LLInventoryType::lookup(data.mPostData["inventory_type"].asString());
on_new_single_inventory_upload_complete(
asset_type,
inventory_type,
data.mPostData["asset_type"].asString(),
data.mPostData["folder_id"].asUUID(),
data.mPostData["name"],
data.mPostData["description"],
data.mResponse,
0);
mInventoryQ.pop();
}
}
if (!mThread->mWaiting)
{ //curl thread is churning, wait for it to go idle
return;
}
LLFastTimer t(FTM_MESH_UPDATE);
{
LLFastTimer t(FTM_MESH_LOCK1);
mMeshMutex->lock();
}
{
LLFastTimer t(FTM_MESH_LOCK2);
mThread->mMutex->lock();
}
//popup queued error messages from background threads
while (!mUploadErrorQ.empty())
{
LLNotificationsUtil::add("MeshUploadError", mUploadErrorQ.front());
mUploadErrorQ.pop();
}
S32 push_count = LLMeshRepoThread::sMaxConcurrentRequests-(LLMeshRepoThread::sActiveHeaderRequests+LLMeshRepoThread::sActiveLODRequests);
if (push_count > 0)
{
//calculate "score" for pending requests
//create score map
std::map<LLUUID, F32> score_map;
for (U32 i = 0; i < 4; ++i)
{
for (mesh_load_map::iterator iter = mLoadingMeshes[i].begin(); iter != mLoadingMeshes[i].end(); ++iter)
{
F32 max_score = 0.f;
for (std::set<LLUUID>::iterator obj_iter = iter->second.begin(); obj_iter != iter->second.end(); ++obj_iter)
{
LLViewerObject* object = gObjectList.findObject(*obj_iter);
if (object)
{
LLDrawable* drawable = object->mDrawable;
if (drawable)
{
F32 cur_score = drawable->getRadius()/llmax(drawable->mDistanceWRTCamera, 1.f);
max_score = llmax(max_score, cur_score);
}
}
}
score_map[iter->first.getSculptID()] = max_score;
}
}
//set "score" for pending requests
for (std::vector<LLMeshRepoThread::LODRequest>::iterator iter = mPendingRequests.begin(); iter != mPendingRequests.end(); ++iter)
{
iter->mScore = score_map[iter->mMeshParams.getSculptID()];
}
//sort by "score"
std::sort(mPendingRequests.begin(), mPendingRequests.end(), LLMeshRepoThread::CompareScoreGreater());
while (!mPendingRequests.empty() && push_count > 0)
{
LLFastTimer t(FTM_LOAD_MESH_LOD);
LLMeshRepoThread::LODRequest& request = mPendingRequests.front();
mThread->loadMeshLOD(request.mMeshParams, request.mLOD);
mPendingRequests.erase(mPendingRequests.begin());
push_count--;
}
}
//send skin info requests
while (!mPendingSkinRequests.empty())
{
mThread->loadMeshSkinInfo(mPendingSkinRequests.front());
mPendingSkinRequests.pop();
}
//send decomposition requests
while (!mPendingDecompositionRequests.empty())
{
mThread->loadMeshDecomposition(mPendingDecompositionRequests.front());
mPendingDecompositionRequests.pop();
}
mThread->notifyLoadedMeshes();
mThread->mMutex->unlock();
mMeshMutex->unlock();
mThread->mSignal->signal();
}
void LLMeshRepository::notifySkinInfoReceived(LLMeshSkinInfo& info)
{
mSkinMap[info.mMeshID] = info;
mLoadingSkins.erase(info.mMeshID);
}
void LLMeshRepository::notifyDecompositionReceived(LLMeshDecomposition* decomp)
{
mDecompositionMap[decomp->mMeshID] = decomp;
mLoadingDecompositions.erase(decomp->mMeshID);
}
void LLMeshRepository::notifyMeshLoaded(const LLVolumeParams& mesh_params, LLVolume* volume)
{
S32 detail = LLVolumeLODGroup::getVolumeDetailFromScale(volume->getDetail());
//get list of objects waiting to be notified this mesh is loaded
mesh_load_map::iterator obj_iter = mLoadingMeshes[detail].find(mesh_params);
if (volume && obj_iter != mLoadingMeshes[detail].end())
{
//make sure target volume is still valid
if (volume->getNumVolumeFaces() <= 0)
{
llwarns << "Mesh loading returned empty volume." << llendl;
volume->makeTetrahedron();
}
{ //update system volume
LLVolume* sys_volume = LLPrimitive::getVolumeManager()->refVolume(mesh_params, detail);
if (sys_volume)
{
sys_volume->copyVolumeFaces(volume);
LLPrimitive::getVolumeManager()->unrefVolume(sys_volume);
}
else
{
llwarns << "Couldn't find system volume for given mesh." << llendl;
}
}
//notify waiting LLVOVolume instances that their requested mesh is available
for (std::set<LLUUID>::iterator vobj_iter = obj_iter->second.begin(); vobj_iter != obj_iter->second.end(); ++vobj_iter)
{
LLVOVolume* vobj = (LLVOVolume*) gObjectList.findObject(*vobj_iter);
if (vobj)
{
vobj->notifyMeshLoaded();
}
}
mLoadingMeshes[detail].erase(mesh_params);
}
}
void LLMeshRepository::notifyMeshUnavailable(const LLVolumeParams& mesh_params, S32 lod)
{
//get list of objects waiting to be notified this mesh is loaded
mesh_load_map::iterator obj_iter = mLoadingMeshes[lod].find(mesh_params);
F32 detail = LLVolumeLODGroup::getVolumeScaleFromDetail(lod);
if (obj_iter != mLoadingMeshes[lod].end())
{
for (std::set<LLUUID>::iterator vobj_iter = obj_iter->second.begin(); vobj_iter != obj_iter->second.end(); ++vobj_iter)
{
LLVOVolume* vobj = (LLVOVolume*) gObjectList.findObject(*vobj_iter);
if (vobj)
{
LLVolume* obj_volume = vobj->getVolume();
if (obj_volume &&
obj_volume->getDetail() == detail &&
obj_volume->getParams() == mesh_params)
{ //should force volume to find most appropriate LOD
vobj->setVolume(obj_volume->getParams(), lod);
}
}
}
mLoadingMeshes[lod].erase(mesh_params);
}
}
S32 LLMeshRepository::getActualMeshLOD(const LLVolumeParams& mesh_params, S32 lod)
{
return mThread->getActualMeshLOD(mesh_params, lod);
}
U32 LLMeshRepository::calcResourceCost(LLSD& header)
{
U32 bytes = 0;
for (U32 i = 0; i < 4; i++)
{
bytes += header[header_lod[i]]["size"].asInteger();
}
bytes += header["skin"]["size"].asInteger();
return bytes/4096 + 1;
}
U32 LLMeshRepository::getResourceCost(const LLUUID& mesh_id)
{
return mThread->getResourceCost(mesh_id);
}
const LLMeshSkinInfo* LLMeshRepository::getSkinInfo(const LLUUID& mesh_id)
{
if (mesh_id.notNull())
{
skin_map::iterator iter = mSkinMap.find(mesh_id);
if (iter != mSkinMap.end())
{
return &(iter->second);
}
//no skin info known about given mesh, try to fetch it
{
LLMutexLock lock(mMeshMutex);
//add volume to list of loading meshes
std::set<LLUUID>::iterator iter = mLoadingSkins.find(mesh_id);
if (iter == mLoadingSkins.end())
{ //no request pending for this skin info
mLoadingSkins.insert(mesh_id);
mPendingSkinRequests.push(mesh_id);
}
}
}
return NULL;
}
const LLMeshDecomposition* LLMeshRepository::getDecomposition(const LLUUID& mesh_id)
{
if (mesh_id.notNull())
{
decomposition_map::iterator iter = mDecompositionMap.find(mesh_id);
if (iter != mDecompositionMap.end())
{
return iter->second;
}
//no skin info known about given mesh, try to fetch it
{
LLMutexLock lock(mMeshMutex);
//add volume to list of loading meshes
std::set<LLUUID>::iterator iter = mLoadingDecompositions.find(mesh_id);
if (iter == mLoadingDecompositions.end())
{ //no request pending for this skin info
mLoadingDecompositions.insert(mesh_id);
mPendingDecompositionRequests.push(mesh_id);
}
}
}
return NULL;
}
const LLSD& LLMeshRepository::getMeshHeader(const LLUUID& mesh_id)
{
return mThread->getMeshHeader(mesh_id);
}
const LLSD& LLMeshRepoThread::getMeshHeader(const LLUUID& mesh_id)
{
static LLSD dummy_ret;
if (mesh_id.notNull())
{
LLMutexLock lock(mHeaderMutex);
mesh_header_map::iterator iter = mMeshHeader.find(mesh_id);
if (iter != mMeshHeader.end())
{
return iter->second;
}
}
return dummy_ret;
}
void LLMeshRepository::uploadModel(std::vector<LLModelInstance>& data, LLVector3& scale, bool upload_textures,
bool upload_skin, bool upload_joints)
{
LLMeshUploadThread* thread = new LLMeshUploadThread(data, scale, upload_textures, upload_skin, upload_joints);
mUploads.push_back(thread);
thread->start();
}
S32 LLMeshRepository::getMeshSize(const LLUUID& mesh_id, S32 lod)
{
if (mThread)
{
LLMeshRepoThread::mesh_header_map::iterator iter = mThread->mMeshHeader.find(mesh_id);
if (iter != mThread->mMeshHeader.end())
{
LLSD& header = iter->second;
if (header.has("404"))
{
return -1;
}
S32 size = header[header_lod[lod]]["size"].asInteger();
return size;
}
}
return -1;
}
void LLMeshUploadThread::sendCostRequest(LLMeshUploadData& data)
{
//write model file to memory buffer
std::stringstream ostr;
LLModel::physics_shape& phys_shape = data.mModel[LLModel::LOD_PHYSICS].notNull() ?
data.mModel[LLModel::LOD_PHYSICS]->mPhysicsShape :
data.mBaseModel->mPhysicsShape;
LLSD header = LLModel::writeModel(ostr,
data.mModel[LLModel::LOD_PHYSICS],
data.mModel[LLModel::LOD_HIGH],
data.mModel[LLModel::LOD_MEDIUM],
data.mModel[LLModel::LOD_LOW],
data.mModel[LLModel::LOD_IMPOSTOR],
phys_shape,
mUploadSkin,
mUploadJoints,
true);
std::string desc = data.mBaseModel->mLabel;
// Grab the total vertex count of the model
// along with other information for the "asset_resources" map
// to send to the server.
LLSD asset_resources = LLSD::emptyMap();
std::string url = mNewInventoryCapability;
if (!url.empty())
{
LLSD body = generate_new_resource_upload_capability_body(
LLAssetType::AT_MESH,
desc,
desc,
LLFolderType::FT_MESH,
LLInventoryType::IT_MESH,
LLFloaterPerms::getNextOwnerPerms(),
LLFloaterPerms::getGroupPerms(),
LLFloaterPerms::getEveryonePerms());
body["asset_resources"] = asset_resources;
mPendingConfirmations++;
LLCurlRequest::headers_t headers;
data.mPostData = body;
mCurlRequest->post(url, headers, body, new LLMeshCostResponder(data, this));
}
}
void LLMeshUploadThread::sendCostRequest(LLTextureUploadData& data)
{
if (data.mTexture.notNull() && data.mTexture->getDiscardLevel() >= 0)
{
LLSD asset_resources = LLSD::emptyMap();
std::string url = mNewInventoryCapability;
if (!url.empty())
{
LLSD body = generate_new_resource_upload_capability_body(
LLAssetType::AT_TEXTURE,
data.mLabel,
data.mLabel,
LLFolderType::FT_TEXTURE,
LLInventoryType::IT_TEXTURE,
LLFloaterPerms::getNextOwnerPerms(),
LLFloaterPerms::getGroupPerms(),
LLFloaterPerms::getEveryonePerms());
body["asset_resources"] = asset_resources;
mPendingConfirmations++;
LLCurlRequest::headers_t headers;
data.mPostData = body;
mCurlRequest->post(url, headers, body, new LLTextureCostResponder(data, this));
}
}
}
void LLMeshUploadThread::doUploadModel(LLMeshUploadData& data)
{
if (!data.mRSVP.empty())
{
std::stringstream ostr;
LLModel::physics_shape& phys_shape = data.mModel[LLModel::LOD_PHYSICS].notNull() ?
data.mModel[LLModel::LOD_PHYSICS]->mPhysicsShape :
data.mBaseModel->mPhysicsShape;
LLModel::writeModel(ostr,
data.mModel[LLModel::LOD_PHYSICS],
data.mModel[LLModel::LOD_HIGH],
data.mModel[LLModel::LOD_MEDIUM],
data.mModel[LLModel::LOD_LOW],
data.mModel[LLModel::LOD_IMPOSTOR],
phys_shape,
mUploadSkin,
mUploadJoints);
data.mAssetData = ostr.str();
LLCurlRequest::headers_t headers;
mPendingUploads++;
mCurlRequest->post(data.mRSVP, headers, data.mAssetData, new LLMeshUploadResponder(data, this));
}
}
void LLMeshUploadThread::doUploadTexture(LLTextureUploadData& data)
{
if (!data.mRSVP.empty())
{
std::stringstream ostr;
if (!data.mTexture->isRawImageValid())
{
data.mTexture->reloadRawImage(data.mTexture->getDiscardLevel());
}
LLPointer<LLImageJ2C> upload_file = LLViewerTextureList::convertToUploadFile(data.mTexture->getRawImage());
ostr.write((const char*) upload_file->getData(), upload_file->getDataSize());
data.mAssetData = ostr.str();
LLCurlRequest::headers_t headers;
mPendingUploads++;
mCurlRequest->post(data.mRSVP, headers, data.mAssetData, new LLTextureUploadResponder(data, this));
}
}
void LLMeshUploadThread::onModelUploaded(LLMeshUploadData& data)
{
createObjects(data);
}
void LLMeshUploadThread::onTextureUploaded(LLTextureUploadData& data)
{
mTextureMap[data.mTexture] = data;
}
void LLMeshUploadThread::createObjects(LLMeshUploadData& data)
{
instance_list& instances = mInstance[data.mBaseModel];
for (instance_list::iterator iter = instances.begin(); iter != instances.end(); ++iter)
{ //create prims that reference given mesh
LLModelInstance& instance = *iter;
instance.mMeshID = data.mUUID;
mInstanceQ.push(instance);
}
}
LLSD LLMeshUploadThread::createObject(LLModelInstance& instance)
{
LLMatrix4 transformation = instance.mTransform;
if (instance.mMeshID.isNull())
{
llerrs << "WTF?" << llendl;
}
// check for reflection
BOOL reflected = (transformation.determinant() < 0);
// compute position
LLVector3 position = LLVector3(0, 0, 0) * transformation;
// compute scale
LLVector3 x_transformed = LLVector3(1, 0, 0) * transformation - position;
LLVector3 y_transformed = LLVector3(0, 1, 0) * transformation - position;
LLVector3 z_transformed = LLVector3(0, 0, 1) * transformation - position;
F32 x_length = x_transformed.normalize();
F32 y_length = y_transformed.normalize();
F32 z_length = z_transformed.normalize();
LLVector3 scale = LLVector3(x_length, y_length, z_length);
// adjust for "reflected" geometry
LLVector3 x_transformed_reflected = x_transformed;
if (reflected)
{
x_transformed_reflected *= -1.0;
}
// compute rotation
LLMatrix3 rotation_matrix;
rotation_matrix.setRows(x_transformed_reflected, y_transformed, z_transformed);
LLQuaternion quat_rotation = rotation_matrix.quaternion();
quat_rotation.normalize(); // the rotation_matrix might not have been orthoginal. make it so here.
LLVector3 euler_rotation;
quat_rotation.getEulerAngles(&euler_rotation.mV[VX], &euler_rotation.mV[VY], &euler_rotation.mV[VZ]);
//
// build parameter block to construct this prim
//
LLSD object_params;
// create prim
// set volume params
U8 sculpt_type = LL_SCULPT_TYPE_MESH;
if (reflected)
{
sculpt_type |= LL_SCULPT_FLAG_MIRROR;
}
LLVolumeParams volume_params;
volume_params.setType( LL_PCODE_PROFILE_SQUARE, LL_PCODE_PATH_LINE );
volume_params.setBeginAndEndS( 0.f, 1.f );
volume_params.setBeginAndEndT( 0.f, 1.f );
volume_params.setRatio ( 1, 1 );
volume_params.setShear ( 0, 0 );
volume_params.setSculptID(instance.mMeshID, sculpt_type);
object_params["shape"] = volume_params.asLLSD();
object_params["material"] = LL_MCODE_WOOD;
object_params["group-id"] = gAgent.getGroupID();
object_params["pos"] = ll_sd_from_vector3(position + mOrigin);
object_params["rotation"] = ll_sd_from_quaternion(quat_rotation);
object_params["scale"] = ll_sd_from_vector3(scale);
object_params["name"] = instance.mModel->mLabel;
// load material from dae file
object_params["facelist"] = LLSD::emptyArray();
for (S32 i = 0; i < instance.mMaterial.size(); i++)
{
LLTextureEntry te;
LLImportMaterial& mat = instance.mMaterial[i];
te.setColor(mat.mDiffuseColor);
LLUUID diffuse_id = mTextureMap[mat.mDiffuseMap].mUUID;
if (diffuse_id.notNull())
{
te.setID(diffuse_id);
}
else
{
te.setID(LLUUID("5748decc-f629-461c-9a36-a35a221fe21f")); // blank texture
}
te.setFullbright(mat.mFullbright);
object_params["facelist"][i] = te.asLLSD();
}
// set extra parameters
LLSculptParams sculpt_params;
sculpt_params.setSculptTexture(instance.mMeshID);
sculpt_params.setSculptType(sculpt_type);
U8 buffer[MAX_OBJECT_PARAMS_SIZE+1];
LLDataPackerBinaryBuffer dp(buffer, MAX_OBJECT_PARAMS_SIZE);
sculpt_params.pack(dp);
std::vector<U8> v(dp.getCurrentSize());
memcpy(&v[0], buffer, dp.getCurrentSize());
LLSD extra_parameter;
extra_parameter["extra_parameter"] = sculpt_params.mType;
extra_parameter["param_data"] = v;
object_params["extra_parameters"].append(extra_parameter);
LLPermissions perm;
perm.setNextOwnerBits(gAgent.getID(), LLUUID::null, TRUE, LLFloaterPerms::getNextOwnerPerms());
perm.setGroupBits(gAgent.getID(), LLUUID::null, TRUE, LLFloaterPerms::getGroupPerms());
perm.setEveryoneBits(gAgent.getID(), LLUUID::null, TRUE, LLFloaterPerms::getEveryonePerms());
object_params["permissions"] = ll_create_sd_from_permissions(perm);
object_params["physics_shape_type"] = (U8)(LLViewerObject::PHYSICS_SHAPE_CONVEX_HULL);
return object_params;
}
void LLMeshUploadThread::priceResult(LLMeshUploadData& data, const LLSD& content)
{
mPendingCost += content["upload_price"].asInteger();
data.mRSVP = content["rsvp"].asString();
data.mRSVP = scrub_host_name(data.mRSVP, mHost);
mConfirmedQ.push(data);
}
void LLMeshUploadThread::priceResult(LLTextureUploadData& data, const LLSD& content)
{
mPendingCost += content["upload_price"].asInteger();
data.mRSVP = content["rsvp"].asString();
data.mRSVP = scrub_host_name(data.mRSVP, mHost);
mConfirmedTextureQ.push(data);
}
bool LLImportMaterial::operator<(const LLImportMaterial &rhs) const
{
if (mDiffuseMap != rhs.mDiffuseMap)
{
return mDiffuseMap < rhs.mDiffuseMap;
}
if (mDiffuseMapFilename != rhs.mDiffuseMapFilename)
{
return mDiffuseMapFilename < rhs.mDiffuseMapFilename;
}
if (mDiffuseMapLabel != rhs.mDiffuseMapLabel)
{
return mDiffuseMapLabel < rhs.mDiffuseMapLabel;
}
if (mDiffuseColor != rhs.mDiffuseColor)
{
return mDiffuseColor < rhs.mDiffuseColor;
}
return mFullbright < rhs.mFullbright;
}
void LLMeshRepository::updateInventory(inventory_data data)
{
LLMutexLock lock(mMeshMutex);
mInventoryQ.push(data);
}
void LLMeshRepository::uploadError(LLSD& args)
{
LLMutexLock lock(mMeshMutex);
mUploadErrorQ.push(args);
}
//static
F32 LLMeshRepository::getStreamingCost(const LLSD& header, F32 radius)
{
F32 dlowest = llmin(radius/0.06f, 256.f);
F32 dlow = llmin(radius/0.24f, 256.f);
F32 dmid = llmin(radius/1.0f, 256.f);
F32 dhigh = 0.f;
F32 bytes_lowest = header["lowest_lod"]["size"].asReal()/1024.f;
F32 bytes_low = header["low_lod"]["size"].asReal()/1024.f;
F32 bytes_mid = header["medium_lod"]["size"].asReal()/1024.f;
F32 bytes_high = header["high_lod"]["size"].asReal()/1024.f;
if (bytes_high == 0.f)
{
return 0.f;
}
if (bytes_mid == 0.f)
{
bytes_mid = bytes_high;
}
if (bytes_low == 0.f)
{
bytes_low = bytes_mid;
}
if (bytes_lowest == 0.f)
{
bytes_lowest = bytes_low;
}
F32 cost = 0.f;
cost += llmax(256.f-dlowest, 1.f)/32.f*bytes_lowest;
cost += llmax(dlowest-dlow, 1.f)/32.f*bytes_low;
cost += llmax(dlow-dmid, 1.f)/32.f*bytes_mid;
cost += llmax(dmid-dhigh, 1.f)/32.f*bytes_high;
cost *= gSavedSettings.getF32("MeshStreamingCostScaler");
return cost;
}
LLPhysicsDecomp::LLPhysicsDecomp()
: LLThread("Physics Decomp")
{
mInited = false;
mQuitting = false;
mDone = false;
mStage = -1;
mContinue = 1;
mSignal = new LLCondition(NULL);
mMutex = new LLMutex(NULL);
setStatusMessage("Idle");
}
LLPhysicsDecomp::~LLPhysicsDecomp()
{
shutdown();
}
void LLPhysicsDecomp::shutdown()
{
if (mSignal)
{
mQuitting = true;
mContinue = 0;
mSignal->signal();
while (!mDone)
{
apr_sleep(100);
}
}
}
void LLPhysicsDecomp::setStatusMessage(std::string msg)
{
LLMutexLock lock(mMutex);
mStatus = msg;
}
void LLPhysicsDecomp::execute(const char* stage, LLModel* mdl)
{
LLMutexLock lock(mMutex);
if (mModel.notNull())
{
llwarns << "Not done processing previous model." << llendl;
return;
}
mModel = mdl;
//load model into LLCD
if (mdl)
{
mStage = mStageID[stage];
U16 index_offset = 0;
if (mStage == 0)
{
mPositions.clear();
mIndices.clear();
//queue up vertex positions and indices
for (S32 i = 0; i < mdl->getNumVolumeFaces(); ++i)
{
const LLVolumeFace& face = mdl->getVolumeFace(i);
if (mPositions.size() + face.mNumVertices > 65535)
{
continue;
}
for (U32 j = 0; j < face.mNumVertices; ++j)
{
mPositions.push_back(LLVector3(face.mPositions[j].getF32ptr()));
}
for (U32 j = 0; j < face.mNumIndices; ++j)
{
mIndices.push_back(face.mIndices[j]+index_offset);
}
index_offset += face.mNumVertices;
}
}
//signal decomposition thread
mSignal->signal();
}
}
//static
S32 LLPhysicsDecomp::llcdCallback(const char* status, S32 p1, S32 p2)
{
LLPhysicsDecomp* comp = gMeshRepo.mDecompThread;
comp->setStatusMessage(llformat("%s: %d/%d", status, p1, p2));
return comp->mContinue;
}
void LLPhysicsDecomp::cancel()
{
mContinue = 0;
}
void LLPhysicsDecomp::run()
{
LLConvexDecomposition::initSystem();
mInited = true;
while (!mQuitting)
{
mSignal->wait();
if (!mQuitting)
{
//load data intoLLCD
if (mStage == 0)
{
mMesh.mVertexBase = mPositions[0].mV;
mMesh.mVertexStrideBytes = 12;
mMesh.mNumVertices = mPositions.size();
mMesh.mIndexType = LLCDMeshData::INT_16;
mMesh.mIndexBase = &(mIndices[0]);
mMesh.mIndexStrideBytes = 6;
mMesh.mNumTriangles = mIndices.size()/3;
LLCDResult ret = LLCD_OK;
if (LLConvexDecomposition::getInstance() != NULL)
{
ret = LLConvexDecomposition::getInstance()->setMeshData(&mMesh);
}
if (ret)
{
llerrs << "Convex Decomposition thread valid but could not set mesh data" << llendl;
}
}
setStatusMessage("Executing.");
mContinue = 1;
LLCDResult ret = LLCD_OK;
if (LLConvexDecomposition::getInstance() != NULL)
{
ret = LLConvexDecomposition::getInstance()->executeStage(mStage);
}
mContinue = 0;
if (ret)
{
llerrs << "Convex Decomposition thread valid but could not execute stage " << mStage << llendl;
}
setStatusMessage("Reading results");
S32 num_hulls =0;
if (LLConvexDecomposition::getInstance() != NULL)
{
num_hulls = LLConvexDecomposition::getInstance()->getNumHullsFromStage(mStage);
}
if (mModel.isNull())
{
llerrs << "mModel should never be null here!" << llendl;
}
mMutex->lock();
mModel->mPhysicsShape.clear();
mModel->mPhysicsShape.resize(num_hulls);
mModel->mHullCenter.clear();
mModel->mHullCenter.resize(num_hulls);
std::vector<LLPointer<LLVertexBuffer> > mesh_buffer;
mesh_buffer.resize(num_hulls);
mModel->mPhysicsCenter.clearVec();
mModel->mPhysicsPoints = 0;
mMutex->unlock();
for (S32 i = 0; i < num_hulls; ++i)
{
std::vector<LLVector3> p;
LLCDHull hull;
// if LLConvexDecomposition is a stub, num_hulls should have been set to 0 above, and we should not reach this code
LLConvexDecomposition::getInstance()->getHullFromStage(mStage, i, &hull);
const F32* v = hull.mVertexBase;
LLVector3 hull_center;
for (S32 j = 0; j < hull.mNumVertices; ++j)
{
LLVector3 vert(v[0], v[1], v[2]);
p.push_back(vert);
hull_center += vert;
v = (F32*) (((U8*) v) + hull.mVertexStrideBytes);
}
hull_center *= 1.f/hull.mNumVertices;
LLCDMeshData mesh;
// if LLConvexDecomposition is a stub, num_hulls should have been set to 0 above, and we should not reach this code
LLConvexDecomposition::getInstance()->getMeshFromStage(mStage, i, &mesh);
mesh_buffer[i] = get_vertex_buffer_from_mesh(mesh);
mMutex->lock();
mModel->mPhysicsShape[i] = p;
mModel->mHullCenter[i] = hull_center;
mModel->mPhysicsPoints += hull.mNumVertices;
mModel->mPhysicsCenter += hull_center;
mMutex->unlock();
}
{
LLMutexLock lock(mMutex);
mModel->mPhysicsCenter *= 1.f/mModel->mPhysicsPoints;
LLFloaterModelPreview::onModelDecompositionComplete(mModel, mesh_buffer);
//done updating model
mModel = NULL;
}
setStatusMessage("Done.");
LLFloaterModelPreview::sInstance->mModelPreview->refresh();
}
}
LLConvexDecomposition::quitSystem();
//delete mSignal;
delete mMutex;
mSignal = NULL;
mMutex = NULL;
mDone = true;
}
Reference in New Issue View Git Blame Copy Permalink