void RaytraceCopierDefault::Copy(
AppData& app_data,
RaytraceCopierDefault::Params&,
Raytracer& raytracer,
unsigned tile
)
{
const unsigned w = app_data.cols();
const unsigned h = app_data.rows();
unsigned i = tile % w;
unsigned j = tile / w;
assert(j*h+i < w*h);
j = h-j-1;
raytracer.fbo << FramebufferTarget::Read;
fbo << FramebufferTarget::Draw;
gl.Flush();
gl.BlitFramebuffer(
app_data.tile*(i+0),
app_data.tile*(j+0),
app_data.tile*(i+1),
app_data.tile*(j+1),
app_data.tile*(i+0),
app_data.tile*(j+0),
app_data.tile*(i+1),
app_data.tile*(j+1),
BufferSelectBit::ColorBuffer,
BlitFilter::Nearest
);
raytracer.fbo << FramebufferTarget::Draw;
}
Acad::ErrorStatus
AcRectJig::setDimValue(const AcDbDimData* dimData,
const double dimValue)
{
if (dimData == NULL)
return Acad::eInvalidInput;
AppData *pDimAppData = (AppData*)dimData->appData();
int dimIndex = pDimAppData ? pDimAppData->index() : 0;
switch (dimIndex) {
case 1:
mpRect->setWidth(dimValue);
mLockWidth = true;
break;
case 2:
mpRect->setHeight(dimValue);
mLockHeight = true;
break;
}
return Acad::eOk;
mpRect->setWidth(dimValue);
return Acad::eOk;
}
void RepNode::eventCallback(DB_ENV* dbenv, u_int32_t which, void *info)
{
AppData *app = (AppData *)dbenv->app_private;
switch (which) {
case DB_EVENT_REP_MASTER:
app->setMaster(true);
break;
case DB_EVENT_REP_CLIENT:
app->setMaster(false);
break;
case DB_EVENT_REP_STARTUPDONE:
app->setStartupDone(true);
break;
// Don't care about this one, for now.
case DB_EVENT_REP_ELECTED:
case DB_EVENT_REP_NEWMASTER:
case DB_EVENT_REP_PERM_FAILED:
break;
default:
dbenv->errx(dbenv, "ignoring event %d", which);
}
}
void LogProgress(const AppData& app_data)
{
unsigned prom = ((1000*tile)/app_data.tiles());
app_data.logstr()
<< "Rendering face tile "
<< tile
<< " out of "
<< app_data.tiles()
<< " ("
<< (prom / 10)
<< "."
<< (prom % 10)
<< " %)"
<< std::endl;
}
bool
AcRectJig::updateDimData()
{
if (!mpRect || !mpDimData || (mpDimData->length() <= 0))
return false;
double width = mpRect->width();
double height = mpRect->height();
AcGePoint3d cenPt = mpRect->center();
AcGeVector3d vertDir = mNormal.crossProduct(mHorizDir);
int dimIndex1 = 0, dimIndex2 = 0;
AcGePoint3d pt1, pt2, pt3, pt4, dimPt;
pt1 = cenPt + 0.5 * width * mHorizDir + 0.5 * height * vertDir;
pt2 = cenPt - 0.5 * width * mHorizDir + 0.5 * height * vertDir;
pt3 = cenPt - 0.5 * width * mHorizDir - 0.5 * height * vertDir;
pt4 = cenPt + 0.5 * width * mHorizDir - 0.5 * height * vertDir;
for (int i = 0; i < mpDimData->length(); i++) {
AcDbDimData *pData = (*mpDimData)[i];
AppData *pDimAppData = (AppData*)pData->appData();
int dimIndex = pDimAppData ? pDimAppData->index() : 0;
double dimScale = pDimAppData->dimScale();
AcDbDimension *pDim = (AcDbDimension*)pData->dimension();
if (pDim->isKindOf(AcDbAlignedDimension::desc())) {
AcDbAlignedDimension *pAlnDim = AcDbAlignedDimension::cast(pDim);
switch (dimIndex) {
case 1:
dimPt = cenPt + (0.5 * height + 0.5 * dimScale) * vertDir;
pAlnDim->setXLine1Point(pt1);
pAlnDim->setXLine2Point(pt2);
pAlnDim->setDimLinePoint(dimPt);
break;
case 2:
dimPt = cenPt + (0.5 * width + 0.5 * dimScale) * mHorizDir;
pAlnDim->setXLine1Point(pt1);
pAlnDim->setXLine2Point(pt4);
pAlnDim->setDimLinePoint(dimPt);
break;
}
}
}
return true;
}
int do_run_main(int (*main_func)(AppData&), AppData& app_data)
{
std::ostream& errstr = app_data.errstr();
try
{
return main_func(app_data);
}
catch(ShaderVariableError& sve)
{
errstr << "Shader variable error";
print_error_common(sve, errstr);
sve.Cleanup();
}
catch(ProgramBuildError& pbe)
{
errstr << "Program build error";
print_error_common(pbe, errstr);
errstr << "Build log:" << std::endl;
errstr << pbe.Log() << std::endl;
pbe.Cleanup();
}
catch(LimitError& le)
{
errstr << "Limit error";
print_error_common(le, errstr);
errstr << "Value " << le.Value() << " exceeds limit ";
errstr << le.Limit() << std::endl;
le.Cleanup();
}
catch(Error& err)
{
errstr << "GL error";
print_error_common(err, errstr);
err.Cleanup();
}
catch(std::system_error& sye)
{
errstr << "System error";
print_std_error_common(sye, errstr);
errstr << "Error code: " << sye.code() << std::endl;
errstr << std::endl;
}
catch(std::runtime_error& rte)
{
errstr << "Runtime error";
print_std_error_common(rte, errstr);
errstr << std::endl;
}
catch(std::exception& se)
{
errstr << "Error";
print_std_error_common(se, errstr);
errstr << std::endl;
}
return 1;
}
//{
// "jsonrpc" : "2.0",
// "method" : "BasicCommunication.OnAppRegistered",
// "params" : {
// "application" : {
// "appID" : 846930886,
// "appName" : "Sina Weibo",
// "appType" : [ "NAVIGATION" ],
// "deviceName" : "10.27.0.132",
// "hmiDisplayLanguageDesired" : "EN-US",
// "icon" : "",
// "isMediaApplication" : true,
// "ngnMediaScreenAppName" : "Sina "
// },
// "vrSynonyms" : [ "Sina Weibo" ]
// }
//}
//{
// "jsonrpc" : "2.0",
// "method" : "BasicCommunication.OnAppRegistered",
// "params" : {
// "application" : {
// "appID" : 783368690,
// "appName" : "SyncProxyTester",
// "appType" : [
// "DEFAULT",
// "COMMUNICATION",
// "MEDIA",
// "MESSAGING",
// "NAVIGATION",
// "INFORMATION",
// "SOCIAL",
// "BACKGROUND_PROCESS",
// "TESTING",
// "SYSTEM"
// ],
// "deviceName" : "10.27.0.132",
// "hmiDisplayLanguageDesired" : "EN-US",
// "icon" : "",
// "isMediaApplication" : true,
// "ngnMediaScreenAppName" : "SPT"
// },
// "resumeVrGrammars" : true,
// "ttsName" : [
// {
// "text" : "TTS Name 1",
// "type" : "TEXT"
// },
// {
// "text" : "Tester",
// "type" : "TEXT"
// }
// ],
// "vrSynonyms" : [ "SPT", "Tester" ]
// }
//}
void AppList::newAppRegistered(Json::Value jsonObj)
{
AppData * pData = new AppData();
pData->setUIManager(m_pUIManager);
pData->m_iAppID = jsonObj["params"]["application"]["appID"].asInt();
pData->m_szAppName = jsonObj["params"]["application"]["appName"].asString();
pData->addExitAppCommand();
std::vector <AppData *>::iterator i;
for (i = m_AppDatas.begin(); i != m_AppDatas.end(); ++i) {
AppData * pOne = *i;
if (pOne->m_iAppID == pData->m_iAppID) {
m_AppDatas.erase(i);
delete pOne;
break;
}
}
m_AppDatas.push_back(pData);
}
void SkipFaces(const AppData& app_data)
{
while((face < 6) && (app_data.skip_face[face]))
{
if(app_data.verbosity > 2)
{
app_data.logstr()
<< "Skipping cube face "
<< face
<< std::endl;
}
++face;
}
}
void RaytraceCopierNV_copy_image::Copy(
AppData& app_data,
RaytraceCopierNV_copy_image::Params& params,
Raytracer& raytracer,
unsigned tile
)
{
const unsigned w = app_data.cols();
const unsigned h = app_data.rows();
unsigned i = tile % w;
unsigned j = tile / w;
assert(j*h+i < w*h);
j = h-j-1;
unsigned x = app_data.tile*i;
unsigned y = app_data.tile*j;
assert(copy_func);
((PFNglXCopyImageSubDataNV)copy_func)(
params.display,
params.source_context,
GetGLName(raytracer.rbo),
GL_RENDERBUFFER,
0, x, y, 0,
params.target_context,
GetGLName(rt_target.tex),
GL_TEXTURE_RECTANGLE,
0, x, y, 0,
app_data.tile,
app_data.tile,
1
);
OGLPLUS_VERIFY_SIMPLE(GetError);
}
CommonData(
const AppData& app_data,
const x11::Display& disp,
const glx::Context& ctx,
const RaytracerData& rtd,
RaytracerTarget& rtt
): display(disp)
, context(ctx)
, rt_data(rtd)
, rt_target(rtt)
, max_tiles(app_data.tiles())
, tile(0)
, face(0)
, keep_running(true)
{
SkipFaces(app_data);
}
void call_drawable_loop(
AppData& app_data,
x11::Display& display,
glx::Context& context,
Drawable& drawable,
DrawLoop drawable_loop
)
{
RaytracerData rt_data(app_data);
ResourceAllocator res_alloc;
RaytracerTarget rt_target(app_data, res_alloc);
CommonData common(
app_data,
display,
context,
rt_data,
rt_target
);
std::vector<std::thread> threads;
try
{
if(app_data.raytracer_params.empty())
{
app_data.raytracer_params.push_back(std::string());
}
for(auto& param : app_data.raytracer_params)
{
if(app_data.verbosity > 2)
{
app_data.logstr()
<< "Spawning raytracing thread on ";
if(param.empty())
{
app_data.logstr()
<< "the current X screen";
}
else
{
app_data.logstr()
<< "X screen "
<< param;
}
app_data.logstr() << std::endl;
}
threads.push_back(
std::thread(
main_thread,
std::ref(app_data),
std::ref(common),
std::cref(param)
)
);
}
}
catch (...)
{
for(auto& t: threads) t.join();
throw;
}
try
{
common.thread_ready.Wait(threads.size());
common.master_ready.Signal(threads.size());
drawable_loop(
drawable,
app_data,
common,
rt_target,
threads.size()
);
for(auto& t: threads) t.join();
}
catch (...)
{
common.Stop();
common.master_ready.Signal(threads.size());
for(auto& t: threads) t.join();
throw;
}
common.RethrowErrors();
}
void render_loop(AppData& app_data)
{
ResourceAllocator alloc;
RaytracerTarget raytrace_tgt(app_data, alloc);
RaytracerData raytrace_data(app_data);
RaytracerResources raytrace_res(app_data, raytrace_data, alloc);
Raytracer raytracer(app_data, raytrace_res);
RaytraceCopier::Params copy_params;
RaytraceCopier copier(app_data, raytrace_tgt);
Renderer renderer(app_data, raytrace_tgt.tex_unit);
Saver saver(app_data);
unsigned face = 0;
unsigned tile = 0;
const unsigned tiles = app_data.tiles();
while(true)
{
if(app_data.skip_face[face])
{
++face;
continue;
}
if(app_data.verbosity > 0)
{
app_data.logstr()
<< "Rendering cube face "
<< face
<< std::endl;
}
raytracer.Use(app_data);
if(tile == 0)
{
raytrace_tgt.Clear(app_data);
raytracer.InitFrame(app_data, face);
renderer.InitFrame(app_data, face);
}
if(tile < tiles)
{
raytracer.BeginWork(app_data);
raytracer.Raytrace(app_data, tile);
raytracer.EndWork(app_data);
copier.Copy(app_data, copy_params, raytracer, tile);
renderer.Use(app_data);
renderer.Render(app_data);
glfwSwapBuffers();
tile++;
}
else if(face < 6)
{
glfwSwapBuffers();
saver.SaveFrame(app_data, raytrace_tgt, face);
if(face < 5)
{
tile = 0;
face++;
}
else break;
}
glfwPollEvents();
int new_x, new_y;
glfwGetWindowSize(&new_x, &new_y);
if(new_x > 0)
{
app_data.render_width = unsigned(new_x);
}
if(new_y > 0)
{
app_data.render_height = unsigned(new_y);
}
if(glfwGetKey(GLFW_KEY_ESC))
{
glfwCloseWindow();
break;
}
if(!glfwGetWindowParam(GLFW_OPENED))
{
break;
}
}
}
void
AcRectangle::gripDimensionCbackFuncGuts(AcDbGripData* pGrip,
const AcDbObjectId& objId,
double dimScale,
AcDbDimDataPtrArray& dimDataArr,
bool isHover)
{
if (pGrip == NULL)
return;
AppData *pAppData = (AppData*)pGrip->appData();
int gripID = pAppData ? pAppData->index() : -1;
if ((gripID < 0) || (gripID > 4))
return;
AcDbEntity *pEnt = NULL;
if (acdbOpenAcDbEntity(pEnt, objId, AcDb::kForRead) != Acad::eOk)
return;
AcRectangle *pRect = AcRectangle::cast(pEnt);
if (pRect == NULL) {
pEnt->close();
return;
}
AcGeVector3d mHorizDir = pRect->horizDir();
AcGeVector3d mNormal = pRect->normal();
AcGeVector3d vertDir = mNormal.crossProduct(mHorizDir);
AcGePoint3d mCenter = pRect->center();
double mWidth = pRect->width();
double mHeight = pRect->height();
double mElevation = pRect->elevation();
pRect->close();
int dimIndex1 = 0, dimIndex2 = 0;
AcGePoint3d pt1, pt2, pt3, pt4, dimPt1, dimPt2;
double horizRot = userToLocalAngle(mNormal, mHorizDir);
pt1 = mCenter + 0.5 * mWidth * mHorizDir + 0.5 * mHeight * vertDir;
pt2 = mCenter - 0.5 * mWidth * mHorizDir + 0.5 * mHeight * vertDir;
pt3 = mCenter - 0.5 * mWidth * mHorizDir - 0.5 * mHeight * vertDir;
pt4 = mCenter + 0.5 * mWidth * mHorizDir - 0.5 * mHeight * vertDir;
AcDbAlignedDimension *pAlnDim1 = new AcDbAlignedDimension();
pAlnDim1->setDatabaseDefaults();
pAlnDim1->setNormal(mNormal);
pAlnDim1->setElevation(mElevation);
//pAlnDim1->setDimtad(1);
pAlnDim1->setHorizontalRotation(-horizRot);
AcDbAlignedDimension *pAlnDim2 = new AcDbAlignedDimension();
pAlnDim2->setDatabaseDefaults();
pAlnDim2->setNormal(mNormal);
pAlnDim2->setElevation(mElevation);
//pAlnDim2->setDimtad(1);
pAlnDim2->setHorizontalRotation(-horizRot);
if (isHover) {
AcCmColor dimColor;
dimColor.setColorIndex(8); // gray
pAlnDim1->setDimclrd(dimColor);
pAlnDim1->setDimclre(dimColor);
pAlnDim1->setDimclrt(dimColor);
pAlnDim2->setDimclrd(dimColor);
pAlnDim2->setDimclre(dimColor);
pAlnDim2->setDimclrt(dimColor);
}
switch (gripID) {
case 1:
dimIndex1 = 3;
dimPt1 = mCenter + (0.5 * mHeight + 0.5 * dimScale) * vertDir;
pAlnDim1->setXLine1Point(pt1);
pAlnDim1->setXLine2Point(pt2);
pAlnDim1->setDimLinePoint(dimPt1);
dimIndex2 = 4;
dimPt2 = mCenter + (0.5 * mWidth + 0.5 * dimScale) * mHorizDir;
pAlnDim2->setXLine1Point(pt1);
pAlnDim2->setXLine2Point(pt4);
pAlnDim2->setDimLinePoint(dimPt2);
break;
case 2:
dimIndex1 = 5;
dimPt1 = mCenter + (0.5 * mHeight + 0.5 * dimScale) * vertDir;
pAlnDim1->setXLine1Point(pt1);
pAlnDim1->setXLine2Point(pt2);
pAlnDim1->setDimLinePoint(dimPt1);
dimIndex2 = 6;
dimPt2 = mCenter - (0.5 * mWidth + 0.5 * dimScale) * mHorizDir;
pAlnDim2->setXLine1Point(pt2);
pAlnDim2->setXLine2Point(pt3);
pAlnDim2->setDimLinePoint(dimPt2);
break;
case 3:
dimIndex1 = 7;
dimPt1 = mCenter - (0.5 * mWidth + 0.5 * dimScale) * mHorizDir;
pAlnDim1->setXLine1Point(pt2);
pAlnDim1->setXLine2Point(pt3);
pAlnDim1->setDimLinePoint(dimPt1);
dimIndex2 = 8;
dimPt2 = mCenter - (0.5 * mHeight + 0.5 * dimScale) * vertDir;
pAlnDim2->setXLine1Point(pt3);
pAlnDim2->setXLine2Point(pt4);
pAlnDim2->setDimLinePoint(dimPt2);
break;
case 4:
dimIndex1 = 9;
dimPt1 = mCenter - (0.5 * mHeight + 0.5 * dimScale) * vertDir;
pAlnDim1->setXLine1Point(pt3);
pAlnDim1->setXLine2Point(pt4);
pAlnDim1->setDimLinePoint(dimPt1);
dimIndex2 = 10;
dimPt2 = mCenter + (0.5 * mWidth + 0.5 * dimScale) * mHorizDir;
pAlnDim2->setXLine1Point(pt4);
pAlnDim2->setXLine2Point(pt1);
pAlnDim2->setDimLinePoint(dimPt2);
break;
}
unsigned int ibitFlags = AcDbDimData::kDimFocal & ~AcDbDimData::kDimEditable ;
AcDbDimData *dimData1 = new AcDbDimData(pAlnDim1);
AppData *pDimAppData1 = new AppData(dimIndex1, dimScale);
dimData1->setAppData(pDimAppData1);
dimData1->setOwnerId(objId);
dimData1->setDimFocal(true);
//dimData1->setBitFlags(ibitFlags);
dimData1->setDimEditable(false);
dimData1->setDimValueFunc(AcRectangle::setDimValueCbackFunc);
AcDbDimData *dimData2 = new AcDbDimData(pAlnDim2);
AppData *pDimAppData2 = new AppData(dimIndex2, dimScale);
dimData2->setAppData(pDimAppData2);
dimData2->setOwnerId(objId);
dimData2->setDimFocal(true);
dimData2->setDimEditable(false);
dimData2->setDimHideIfValueIsZero(true);
dimData2->setDimValueFunc(setDimValueCbackFunc);
dimDataArr.append(dimData1);
dimDataArr.append(dimData2);
if(pAppData) {
pAppData->resetDimData();
pAppData->appendDimData(dimData1);
pAppData->appendDimData(dimData2);
}
}
void thread_loop(AppData& app_data, CommonData& common, x11::Display& display, glx::Context& context)
{
Context gl;
ResourceAllocator alloc;
RaytraceCopier::Params rtc_params(
display,
context,
common.context
);
RaytraceCopier rt_copier(app_data, common.rt_target);
RaytracerResources rt_res(app_data, common.rt_data, alloc);
Raytracer raytracer(app_data, rt_res);
raytracer.Use(app_data);
std::vector<unsigned> backlog(app_data.cols());
std::chrono::milliseconds bl_interval(100);
while(!common.Done())
{
// all threads must wait until
// the raytrace target is cleared
common.master_ready.Wait();
if(common.Done()) break;
raytracer.InitFrame(app_data, common.Face());
auto bl_begin = std::chrono::steady_clock::now();
unsigned tile = 0;
while(common.NextFaceTile(tile))
{
raytracer.Raytrace(app_data, tile);
backlog.push_back(tile);
auto now = std::chrono::steady_clock::now();
if(bl_begin + bl_interval < now)
{
gl.Finish();
auto lock = common.Lock();
for(unsigned bl_tile : backlog)
{
rt_copier.Copy(
app_data,
rtc_params,
raytracer,
bl_tile
);
}
lock.unlock();
backlog.clear();
bl_begin = now;
}
else gl.Finish();
}
auto lock = common.Lock();
for(unsigned bl_tile : backlog)
{
rt_copier.Copy(
app_data,
rtc_params,
raytracer,
bl_tile
);
}
lock.unlock();
backlog.clear();
gl.Finish();
// signal to the master that the raytracing
// of the current face has finished
common.thread_ready.Signal();
if(common.Done()) break;
// wait for the master to save the face image
common.master_ready.Wait();
}
}
Acad::ErrorStatus
AcRectangle::moveGripPointsAt(const AcDbVoidPtrArray& appData,
const AcGeVector3d& offset,
const int bitflags)
{
assertWriteEnabled();
if (!appData.length())
return Acad::eInvalidInput;
AcGePoint3d pt1, pt2;
AcGeVector3d diaVec;
AppData *pAppData = (AppData*)appData[0];
int gripID = pAppData->index();
AcGeVector3d vertDir = mNormal.crossProduct(mHorizDir);
switch(gripID) {
case 0:
mCenter += offset;
break;
case 1:
pt1 = mCenter + 0.5 * mWidth * mHorizDir + 0.5 * mHeight * vertDir;
pt2 = mCenter - 0.5 * mWidth * mHorizDir - 0.5 * mHeight * vertDir;
pt1 += offset;
diaVec = pt1 - pt2;
mCenter += 0.5 * offset;
mWidth = fabs(diaVec.dotProduct(mHorizDir));
mHeight = fabs(diaVec.dotProduct(vertDir));
break;
case 2:
pt1 = mCenter - 0.5 * mWidth * mHorizDir + 0.5 * mHeight * vertDir;
pt2 = mCenter + 0.5 * mWidth * mHorizDir - 0.5 * mHeight * vertDir;
pt1 += offset;
diaVec = pt1 - pt2;
mCenter += 0.5 * offset;
mWidth = fabs(diaVec.dotProduct(mHorizDir));
mHeight = fabs(diaVec.dotProduct(vertDir));
break;
case 3:
pt1 = mCenter - 0.5 * mWidth * mHorizDir - 0.5 * mHeight * vertDir;
pt2 = mCenter + 0.5 * mWidth * mHorizDir + 0.5 * mHeight * vertDir;
pt1 += offset;
diaVec = pt1 - pt2;
mCenter += 0.5 * offset;
mWidth = fabs(diaVec.dotProduct(mHorizDir));
mHeight = fabs(diaVec.dotProduct(vertDir));
break;
case 4:
pt1 = mCenter + 0.5 * mWidth * mHorizDir - 0.5 * mHeight * vertDir;
pt2 = mCenter - 0.5 * mWidth * mHorizDir + 0.5 * mHeight * vertDir;
pt1 += offset;
diaVec = pt1 - pt2;
mCenter += 0.5 * offset;
mWidth = fabs(diaVec.dotProduct(mHorizDir));
mHeight = fabs(diaVec.dotProduct(vertDir));
break;
}
// Update dynamic dimensions
//
AcDbDimDataPtrArray *pDimDataArr = NULL;
if (pAppData)
pDimDataArr = pAppData->dimData();
updateDimensions(pDimDataArr);
return Acad::eOk;
}
bool
AcRectangle::updateDimensions(AcDbDimDataPtrArray* pDimData)
{
if (!pDimData || (pDimData->length() <= 0))
return false;
int numDims = pDimData->length();
AcDbObjectId entId = objectId();
AcGeVector3d vertDir = mNormal.crossProduct(mHorizDir);
AcGePoint3d pt1, pt2, pt3, pt4, dimPt, textPt;
pt1 = mCenter + 0.5 * mWidth * mHorizDir + 0.5 * mHeight * vertDir;
pt2 = mCenter - 0.5 * mWidth * mHorizDir + 0.5 * mHeight * vertDir;
pt3 = mCenter - 0.5 * mWidth * mHorizDir - 0.5 * mHeight * vertDir;
pt4 = mCenter + 0.5 * mWidth * mHorizDir - 0.5 * mHeight * vertDir;
AcDbObjectId ownerId;
for (int i = 0; i < numDims; i++) {
AcDbDimData *pData = (*pDimData)[i];
ownerId = pData->ownerId();
if (!entId.isNull() && (entId != ownerId))
continue;
AppData *pDimAppData = (AppData*)pData->appData();
int dimIndex = pDimAppData ? pDimAppData->index() : 0;
double dimScale = pDimAppData->dimScale();
AcDbDimension *pDim = (AcDbDimension*)pData->dimension();
if (pDim->isKindOf(AcDbAlignedDimension::desc())) {
AcDbAlignedDimension *pAlnDim = AcDbAlignedDimension::cast(pDim);
//pAlnDim->setDimjust(1);
switch (dimIndex) {
case 1:
textPt = pt2 + 1.0 * vertDir;
dimPt = mCenter + (0.5 * mHeight + 0.5 * dimScale) * vertDir;
pAlnDim->setXLine1Point(pt1);
pAlnDim->setXLine2Point(pt2);
pAlnDim->setDimLinePoint(dimPt);
//pAlnDim->setTextPosition(textPt);
break;
case 2:
textPt = pt1 + 1.0 * mHorizDir;
dimPt = mCenter + (0.5 * mWidth + 0.5 * dimScale) * mHorizDir;
pAlnDim->setXLine1Point(pt1);
pAlnDim->setXLine2Point(pt4);
pAlnDim->setDimLinePoint(dimPt);
//pAlnDim->setTextPosition(textPt);
break;
case 3:
textPt = pt2 + 1.0 * vertDir;
dimPt = mCenter + (0.5 * mHeight + 0.5 * dimScale) * vertDir;
pAlnDim->setXLine1Point(pt1);
pAlnDim->setXLine2Point(pt2);
pAlnDim->setDimLinePoint(dimPt);
//pAlnDim->setTextPosition(textPt);
break;
case 4:
textPt = pt1 + 1.0 * mHorizDir;
dimPt = mCenter + (0.5 * mWidth + 0.5 * dimScale) * mHorizDir;
pAlnDim->setXLine1Point(pt1);
pAlnDim->setXLine2Point(pt4);
pAlnDim->setDimLinePoint(dimPt);
//pAlnDim->setTextPosition(textPt);
break;
case 5:
dimPt = mCenter + (0.5 * mHeight + 0.5 * dimScale) * vertDir;
pAlnDim->setXLine1Point(pt1);
pAlnDim->setXLine2Point(pt2);
pAlnDim->setDimLinePoint(dimPt);
break;
case 6:
dimPt = mCenter - (0.5 * mWidth + 0.5 * dimScale) * mHorizDir;
pAlnDim->setXLine1Point(pt2);
pAlnDim->setXLine2Point(pt3);
pAlnDim->setDimLinePoint(dimPt);
break;
case 7:
dimPt = mCenter - (0.5 * mWidth + 0.5 * dimScale) * mHorizDir;
pAlnDim->setXLine1Point(pt2);
pAlnDim->setXLine2Point(pt3);
pAlnDim->setDimLinePoint(dimPt);
break;
case 8:
dimPt = mCenter - (0.5 * mHeight + 0.5 * dimScale) * vertDir;
pAlnDim->setXLine1Point(pt3);
pAlnDim->setXLine2Point(pt4);
pAlnDim->setDimLinePoint(dimPt);
break;
case 9:
dimPt = mCenter - (0.5 * mHeight + 0.5 * dimScale) * vertDir;
pAlnDim->setXLine1Point(pt3);
pAlnDim->setXLine2Point(pt4);
pAlnDim->setDimLinePoint(dimPt);
break;
case 10:
dimPt = mCenter + (0.5 * mWidth + 0.5 * dimScale) * mHorizDir;
pAlnDim->setXLine1Point(pt4);
pAlnDim->setXLine2Point(pt1);
pAlnDim->setDimLinePoint(dimPt);
break;
}
}
}
return true;
}
void pbuffer_loop(
const glx::Pbuffer& pbuffer,
AppData& app_data,
CommonData& common,
RaytracerTarget& rt_target,
std::size_t n_threads
)
{
Context gl;
Renderer renderer(app_data, rt_target.tex_unit);
renderer.Use(app_data);
Saver saver(app_data);
while(!common.Done())
{
if(app_data.verbosity > 0)
{
app_data.logstr()
<< "Rendering cube face "
<< common.Face()
<< std::endl;
}
// clear the raytrace target
rt_target.Clear(app_data);
renderer.InitFrame(app_data, common.Face());
renderer.Render(app_data);
gl.Finish();
// signal all threads that they can start raytracing tiles
common.master_ready.Signal(n_threads);
if(common.Done()) break;
if(app_data.verbosity > 1)
{
// setup logging period
std::chrono::system_clock::duration log_period;
if(app_data.verbosity > 4)
{
log_period = std::chrono::seconds(1);
}
else if(app_data.verbosity > 3)
{
log_period = std::chrono::seconds(5);
}
else if(app_data.verbosity > 2)
{
log_period = std::chrono::seconds(10);
}
else if(app_data.verbosity > 1)
{
log_period = std::chrono::seconds(30);
}
auto log_time = std::chrono::system_clock::now();
while(!common.thread_ready.Signalled())
{
auto now = std::chrono::system_clock::now();
if(log_time + log_period < now)
{
common.LogProgress(app_data);
log_time = now;
}
std::chrono::milliseconds period(50);
std::this_thread::sleep_for(period);
}
}
// wait for all raytracer threads to finish
common.thread_ready.Wait(n_threads);
for(unsigned b=0; b!=2; ++b)
{
renderer.Render(app_data);
gl.Finish();
common.context.SwapBuffers(pbuffer);
}
// save the face image
saver.SaveFrame(app_data, rt_target, common.Face());
// switch the face
common.NextFace(app_data);
// signal that the master is ready to render
// the next face
common.master_ready.Signal(n_threads);
}
}
AcGeVector3d
AcRectangle::setDimValueCbackFunc(AcDbDimData* pThis,
AcDbEntity* pEnt,
double value,
const AcGeVector3d& offset)
{
if ((pThis == NULL) || (pEnt == NULL))
return offset;
pEnt->assertWriteEnabled();
AppData *pDimAppData = (AppData*)pThis->appData();
if (pDimAppData == NULL)
return offset;
int dimId = pDimAppData->index();
if ((dimId < 1) || (dimId > 10))
return offset;
AcRectangle *pRect = AcRectangle::cast(pEnt);
if (pRect == NULL)
return offset;
AcGePoint3d pt1, pt2, pt3, pt4, dimPt;
AcGeVector3d diaVec;
AcGeVector3d mHorizDir = pRect->horizDir();
AcGeVector3d mNormal = pRect->normal();
AcGeVector3d vertDir = mNormal.crossProduct(mHorizDir);
AcGePoint3d mCenter = pRect->center();
double mWidth = pRect->width();
double mHeight = pRect->height();
pt1 = mCenter + 0.5 * mWidth * mHorizDir + 0.5 * mHeight * vertDir;
pt2 = mCenter - 0.5 * mWidth * mHorizDir + 0.5 * mHeight * vertDir;
pt3 = mCenter - 0.5 * mWidth * mHorizDir - 0.5 * mHeight * vertDir;
pt4 = mCenter + 0.5 * mWidth * mHorizDir - 0.5 * mHeight * vertDir;
switch (dimId) {
case 1:
mCenter = mCenter + value * mHorizDir;
pRect->setCenter(mCenter);
break;
case 2:
mCenter = mCenter + value * vertDir;
pRect->setCenter(mCenter);
break;
case 3:
pt1 = pt2 + value * mHorizDir;
diaVec = pt1 - pt3;
mCenter = pt3 + 0.5 * diaVec;
mWidth = fabs(diaVec.dotProduct(mHorizDir));
mHeight = fabs(diaVec.dotProduct(vertDir));
pRect->setCenter(mCenter);
pRect->setWidth(mWidth);
pRect->setHeight(mHeight);
break;
case 4:
pt1 = pt4 + value * vertDir;
diaVec = pt1 - pt3;
mCenter = pt3 + 0.5 * diaVec;
mWidth = fabs(diaVec.dotProduct(mHorizDir));
mHeight = fabs(diaVec.dotProduct(vertDir));
pRect->setCenter(mCenter);
pRect->setWidth(mWidth);
pRect->setHeight(mHeight);
break;
case 5:
pt2 = pt1 - value * mHorizDir;
diaVec = pt2 - pt4;
mCenter = pt4 + 0.5 * diaVec;
mWidth = fabs(diaVec.dotProduct(mHorizDir));
mHeight = fabs(diaVec.dotProduct(vertDir));
pRect->setCenter(mCenter);
pRect->setWidth(mWidth);
pRect->setHeight(mHeight);
break;
case 6:
pt2 = pt3 + value * vertDir;
diaVec = pt2 - pt4;
mCenter = pt4 + 0.5 * diaVec;
mWidth = fabs(diaVec.dotProduct(mHorizDir));
mHeight = fabs(diaVec.dotProduct(vertDir));
pRect->setCenter(mCenter);
pRect->setWidth(mWidth);
pRect->setHeight(mHeight);
break;
case 7:
pt3 = pt2 - value * vertDir;
diaVec = pt3 - pt1;
mCenter = pt1 + 0.5 * diaVec;
mWidth = fabs(diaVec.dotProduct(mHorizDir));
mHeight = fabs(diaVec.dotProduct(vertDir));
pRect->setCenter(mCenter);
pRect->setWidth(mWidth);
pRect->setHeight(mHeight);
break;
case 8:
pt3 = pt4 - value * mHorizDir;
diaVec = pt3 - pt1;
mCenter = pt1 + 0.5 * diaVec;
mWidth = fabs(diaVec.dotProduct(mHorizDir));
mHeight = fabs(diaVec.dotProduct(vertDir));
pRect->setCenter(mCenter);
pRect->setWidth(mWidth);
pRect->setHeight(mHeight);
break;
case 9:
pt4 = pt3 + value * mHorizDir;
diaVec = pt4 - pt2;
mCenter = pt2 + 0.5 * diaVec;
mWidth = fabs(diaVec.dotProduct(mHorizDir));
mHeight = fabs(diaVec.dotProduct(vertDir));
pRect->setCenter(mCenter);
pRect->setWidth(mWidth);
pRect->setHeight(mHeight);
break;
case 10:
pt4 = pt1 - value * vertDir;
diaVec = pt4 - pt2;
mCenter = pt2 + 0.5 * diaVec;
mWidth = fabs(diaVec.dotProduct(mHorizDir));
mHeight = fabs(diaVec.dotProduct(vertDir));
pRect->setCenter(mCenter);
pRect->setWidth(mWidth);
pRect->setHeight(mHeight);
break;
}
return offset;
}
void window_loop(
const x11::Window& window,
AppData& app_data,
CommonData& common,
RaytracerTarget& rt_target,
std::size_t n_threads
)
{
Context gl;
Renderer renderer(app_data, rt_target.tex_unit);
renderer.Use(app_data);
Saver saver(app_data);
window.SelectInput(StructureNotifyMask| PointerMotionMask| KeyPressMask);
::XEvent event;
while(!common.Done())
{
if(app_data.verbosity > 0)
{
app_data.logstr()
<< "Rendering cube face "
<< common.Face()
<< std::endl;
}
// clear the raytrace target
rt_target.Clear(app_data);
renderer.InitFrame(app_data, common.Face());
renderer.Render(app_data);
common.context.SwapBuffers(window);
// setup logging period
std::chrono::system_clock::duration log_period;
if(app_data.verbosity > 4)
{
log_period = std::chrono::seconds(1);
}
else if(app_data.verbosity > 3)
{
log_period = std::chrono::seconds(5);
}
else if(app_data.verbosity > 2)
{
log_period = std::chrono::seconds(15);
}
else if(app_data.verbosity > 1)
{
log_period = std::chrono::minutes(1);
}
auto log_time = std::chrono::system_clock::now();
// signal all threads that they can start raytracing tiles
common.master_ready.Signal(n_threads);
while(!common.FaceDone())
{
unsigned slot = 0;
while(common.display.NextEvent(event))
{
switch(event.type)
{
case ClientMessage:
case DestroyNotify:
common.Stop();
break;
case ConfigureNotify:
app_data.render_width = event.xconfigure.width;
app_data.render_height = event.xconfigure.height;
break;
case MotionNotify:
break;
case KeyPress:
if(::XLookupKeysym(&event.xkey, 0) == XK_Escape)
common.Stop();
break;
default:;
}
}
if(common.Done()) break;
if((slot++ % 5) == 0)
{
auto lock = common.Lock();
renderer.Render(app_data);
gl.Finish();
lock.unlock();
common.context.SwapBuffers(window);
}
if(app_data.verbosity > 1)
{
auto now = std::chrono::system_clock::now();
if(log_time + log_period < now)
{
common.LogProgress(app_data);
log_time = now;
}
}
std::chrono::milliseconds period(5);
std::this_thread::sleep_for(period);
}
if(common.Done()) break;
// wait for all raytracer threads to finish
common.thread_ready.Wait(n_threads);
renderer.Render(app_data);
common.context.SwapBuffers(window);
if(app_data.verbosity > 1)
{
app_data.logstr()
<< "Finished cube face "
<< common.Face()
<< std::endl;
}
// save the face image
saver.SaveFrame(app_data, rt_target, common.Face());
// switch the face
common.NextFace(app_data);
// signal that the master is ready to render
// the next face
common.master_ready.Signal(n_threads);
}
}
