Cube::Cube(const position_type &where, std::shared_ptr<Texture> texture )
: Object3D(where) {
// 8 points, 6 surfaces
position_type
blf(-1.0, -1.0, 1.0) // front rectangle
, brf(1.0, -1.0, 1.0)
, trf(1.0, 1.0, 1.0)
, tlf(-1.0, 1.0, 1.0)
, blr(-1.0, -1.0, -1.0) // rear rectangle
, brr(1.0, -1.0, -1.0)
, trr(1.0, 1.0, -1.0)
, tlr(-1.0, 1.0, -1.0);
position_type
negZ(0.0, 0.0, -1.0)
, posZ(0.0, 0.0, 1.0)
, negY(0.0, -1.0, 0.0)
, posY(0.0, 1.0, 0.0)
, negX(-1.0, 0.0, 0.0)
, posX(1.0, 0.0, 0.0);
// if changing the order, make sure to change accessors so they grab the correct object
this->add_child(new Rectangle(POSITION_INHERIT, { blf, blr, brr, brf }, { negY, negY, negY, negY }, texture)); // bottom negY
this->add_child(new Rectangle(POSITION_INHERIT, { trr, brr, blr, tlr }, { negZ, negZ, negZ, negZ }, texture)); // rear negZ
this->add_child(new Rectangle(POSITION_INHERIT, { trf, brf, brr, trr }, { posX, posX, posX, posX }, texture)); // right posX
this->add_child(new Rectangle(POSITION_INHERIT, { tlr, blr, blf, tlf }, { negX, negX, negX, negX }, texture)); // left negX
this->add_child(new Rectangle(POSITION_INHERIT, { tlf, blf, brf, trf }, { posZ, posZ, posZ, posZ }, texture)); // front posZ
this->add_child(new Rectangle(POSITION_INHERIT, { tlr, tlf, trf, trr }, { posY, posY, posY, posY }, texture)); // top posY
} // Cube
bool CMPCInfo::ReadMetaData(CSongMetaData & MetaData) const
{
StreamInfo info;
FILE *fp = wxFopen( MetaData.Filename.GetFullPath(), wxT("rb") );
if (!fp)
return false;
Reader_file reader(fp);
if (info.ReadStreamInfo(&reader) != ERROR_CODE_OK)
{
return false;
}
MetaData.nBitrate = (int)(info.simple.AverageBitrate / 1024.0);
MetaData.nFilesize = info.simple.TotalFileLength;
MetaData.nDuration_ms = info.simple.PCMSamples * 1000 / info.simple.SampleFreq;
CSimpleTagReader tr;
CSimpleTagReader::CFile trf(fp,false);
tr.ReadTags(trf,ConvToUTF8(MetaData.Filename.GetFullPath()));
MetaData.Album = tr.TagValue(SIMPLETAG_FIELD_ALBUM);
MetaData.Title = tr.TagValue(SIMPLETAG_FIELD_TITLE);
MetaData.Notes = tr.TagValue(SIMPLETAG_FIELD_NOTES);
MetaData.Artist = tr.TagValue(SIMPLETAG_FIELD_ARTIST);
MetaData.Year = tr.TagValue(SIMPLETAG_FIELD_YEAR);
MetaData.Genre = tr.TagValue(SIMPLETAG_FIELD_GENRE);
char* track = tr.TagValue(SIMPLETAG_FIELD_TRACK);
MetaData.nTracknum = track ? atoi(track) : 0;
return true;
}
std::vector<cpunit::ExecutionReport>
cpunit::TestExecutionFacade::execute(const std::vector<std::string> &patterns, const double max_time, const bool verbose, const bool robust) {
CPUNIT_ITRACE("TestExecutionFacade::execute Running subtree matching '"<<patterns<<"' in "<<(robust ? "" : "non-")<<"robust mode.");
std::vector<TestUnit> tests;
for (std::size_t i=0; i<patterns.size(); ++i) {
std::vector<TestUnit> part = TestStore::get_instance().get_test_units(patterns[i]);
tests.insert(tests.end(), part.begin(), part.end());
}
TestRunnerFactory trf(robust, max_time);
return execute(tests, verbose, trf);
}
//==============================================================================
void CollisionDebugDrawer::visit(const Plane& plane)
{
Vec3 n = plane.getNormal().xyz();
const F32& o = plane.getOffset();
Quat q;
q.setFrom2Vec3(Vec3(0.0, 0.0, 1.0), n);
Mat3 rot(q);
rot.rotateXAxis(getPi<F32>() / 2.0);
Mat4 trf(Vec4(n * o, 1.0), rot);
m_dbg->setModelMatrix(trf);
m_dbg->drawGrid();
}
bool ReadMetaData(CSongMetaData & MetaData) const
{
FILE *fp = wxFopen( MetaData.Filename.GetFullPath(), wxT("rb") );
if (!fp)
return false;
CSimpleTagReader tr;
CSimpleTagReader::CFile trf(fp,true);
tr.ReadTags(trf,ConvToUTF8(MetaData.Filename.GetFullPath()));
MetaData.Album = tr.TagValue(SIMPLETAG_FIELD_ALBUM);
MetaData.Title = tr.TagValue(SIMPLETAG_FIELD_TITLE);
MetaData.Notes = tr.TagValue(SIMPLETAG_FIELD_NOTES);
MetaData.Artist = tr.TagValue(SIMPLETAG_FIELD_ARTIST);
MetaData.Year = tr.TagValue(SIMPLETAG_FIELD_YEAR);
MetaData.Genre = tr.TagValue(SIMPLETAG_FIELD_GENRE);
char* track = tr.TagValue(SIMPLETAG_FIELD_TRACK);
MetaData.nTracknum = track ? atoi(track) : 0;
return true;
}
Cube::Cube( const position_type &where, Texture::pointer_type texture )
: Object( where, texture )
{
glm::vec3
blf( -1.0, -1.0, 1.0 ) // front rectangle
, brf( 1.0, -1.0, 1.0 )
, trf( 1.0, 1.0, 1.0 )
, tlf( -1.0, 1.0, 1.0 )
, blr( -1.0, -1.0, -1.0 ) // rear rectangle
, brr( 1.0, -1.0, -1.0 )
, trr( 1.0, 1.0, -1.0 )
, tlr( -1.0, 1.0, -1.0 )
;
glm::vec3
negZ( 0.0, 0.0, -1.0 )
, posZ( 0.0, 0.0, 1.0 )
, negY( 0.0, -1.0, 0.0 )
, posY( 0.0, 1.0, 0.0 )
, negX( -1.0, 0.0, 0.0 )
, posX( 1.0, 0.0, 0.0 )
;
// gl_triangle strip
// for ccw winding: top left, bottom left, top right, bottom right
auto add_components = [ &]( const std::vector<Component::pointer_type>& vec )
{
for ( auto& v : vec )
this->components.emplace_back( v );
};
add_components( Triangle::from_quad( std::vector<glm::vec3>( { blf, blr, brf, brr } ), negY, texture ) ); // bottom
add_components( Triangle::from_quad( std::vector<glm::vec3>( { trr, brr, tlr, blr } ), negZ, texture ) ); // rear
add_components( Triangle::from_quad( std::vector<glm::vec3>( { trf, brf, trr, brr } ), posX, texture ) ); // right posX
add_components( Triangle::from_quad( std::vector<glm::vec3>( { tlr, blr, tlf, blf } ), negX, texture ) ); // left negX
add_components( Triangle::from_quad( std::vector<glm::vec3>( { tlf, blf, trf, brf } ), posZ, texture ) ); // front posZ
add_components( Triangle::from_quad( std::vector<glm::vec3>( { tlr, tlf, trr, trf } ), posY, texture ) ); // top posY
}
void C4GraphicsOverlay::DrawPicture(C4Facet &cgo, C4Object *pForObj, C4DrawTransform* trans)
{
assert(IsPicture());
// special blit mode
if (dwBlitMode == C4GFXBLIT_PARENT)
{
if (pForObj) pForObj->PrepareDrawing();
}
else
{
pDraw->SetBlitMode(dwBlitMode);
if (dwClrModulation != 0xffffff) pDraw->ActivateBlitModulation(dwClrModulation);
if (pMeshInstance)
pMeshInstance->SetFaceOrderingForClrModulation(dwClrModulation);
}
// the picture we are rendering is the one with trans applied, and the overlay transformation
// is applied to the picture we are rendering, so apply it afterwards. Note that
// C4BltTransform::operator*= does this = other * this.
C4DrawTransform trf(Transform, cgo.X + cgo.Wdt/2.0f, cgo.Y + cgo.Hgt/2.0f);
if(trans) trf *= *trans;
// Don't set pForObj because we don't draw the picture of pForObj, but the picture of another definition on top of pForObj:
pSourceGfx->Draw(cgo, pForObj->Color, NULL, iPhase, 0, &trf);
// cleanup
if (dwBlitMode == C4GFXBLIT_PARENT)
{
if (pForObj) pForObj->FinishedDrawing();
}
else
{
pDraw->ResetBlitMode();
pDraw->DeactivateBlitModulation();
}
}
int KReportItemText::renderSimpleData(OROPage *page, OROSection *section, const QPointF &offset,
const QVariant &data, KReportScriptHandler *script)
{
Q_UNUSED(script);
QString qstrValue;
QString cs = itemDataSource();
if (!cs.isEmpty()) {
if (cs.left(1) == QLatin1String("$")) { //Everything past $ is treated as a string
qstrValue = cs.mid(1);
} else {
qstrValue = data.toString();
}
} else {
qstrValue = m_itemValue->value().toString();
}
QPointF pos = m_pos.toScene();
QSizeF size = m_size.toScene();
pos += offset;
QRectF trf(pos, size);
qreal intStretch = trf.top() - offset.y();
if (qstrValue.length()) {
QRectF rect = trf;
int pos = 0;
QChar separator;
QRegExp re(QLatin1String("\\s"));
QPrinter prnt(QPrinter::HighResolution);
QFontMetrics fm(font(), &prnt);
// int intRectWidth = (int)(trf.width() * prnt.resolution()) - 10;
int intRectWidth = (int)((m_size.toPoint().width() / 72) * prnt.resolution());
int intLineCounter = 0;
qreal intBaseTop = trf.top();
qreal intRectHeight = trf.height();
while (qstrValue.length()) {
int idx = re.indexIn(qstrValue, pos);
if (idx == -1) {
idx = qstrValue.length();
separator = QLatin1Char('\n');
} else
separator = qstrValue.at(idx);
if (fm.boundingRect(qstrValue.left(idx)).width() < intRectWidth || pos == 0) {
pos = idx + 1;
if (separator == QLatin1Char('\n')) {
QString line = qstrValue.left(idx);
qstrValue.remove(0, idx + 1);
pos = 0;
rect.setTop(intBaseTop + (intLineCounter * intRectHeight));
rect.setBottom(rect.top() + intRectHeight);
OROTextBox * tb = new OROTextBox();
tb->setPosition(rect.topLeft());
tb->setSize(rect.size());
tb->setFont(font());
tb->setText(line);
tb->setFlags(textFlags());
tb->setTextStyle(textStyle());
tb->setLineStyle(lineStyle());
if (page) {
page->addPrimitive(tb);
}
if (section) {
OROTextBox *tb2 = dynamic_cast<OROTextBox*>(tb->clone());
tb2->setPosition(m_pos.toPoint());
section->addPrimitive(tb2);
}
if (!page) {
delete tb;
}
intStretch += intRectHeight;
intLineCounter++;
}
} else {
QString line = qstrValue.left(pos - 1);
qstrValue.remove(0, pos);
pos = 0;
rect.setTop(intBaseTop + (intLineCounter * intRectHeight));
rect.setBottom(rect.top() + intRectHeight);
OROTextBox * tb = new OROTextBox();
tb->setPosition(rect.topLeft());
tb->setSize(rect.size());
tb->setFont(font());
tb->setText(line);
tb->setFlags(textFlags());
tb->setTextStyle(textStyle());
tb->setLineStyle(lineStyle());
if (page) page->addPrimitive(tb);
intStretch += intRectHeight;
intLineCounter++;
}
}
intStretch += (m_bottomPadding / 100.0);
}
return intStretch; //Item returns its required section height
}
Error Dbg::run(RenderingContext& ctx)
{
ANKI_ASSERT(m_enabled);
if(!m_initialized)
{
ANKI_CHECK(lazyInit());
m_initialized = true;
}
CommandBufferPtr& cmdb = ctx.m_commandBuffer;
cmdb->beginRenderPass(m_fb);
cmdb->setViewport(0, 0, m_r->getWidth(), m_r->getHeight());
FrustumComponent& camFrc = *ctx.m_frustumComponent;
SceneNode& cam = camFrc.getSceneNode();
m_drawer->prepareFrame(cmdb);
m_drawer->setViewProjectionMatrix(camFrc.getViewProjectionMatrix());
m_drawer->setModelMatrix(Mat4::getIdentity());
// m_drawer->drawGrid();
SceneGraph& scene = cam.getSceneGraph();
SceneDebugDrawer sceneDrawer(m_drawer);
camFrc.getVisibilityTestResults().iterateAll([&](SceneNode& node) {
if(&node == &cam)
{
return;
}
// Set position
MoveComponent* mv = node.tryGetComponent<MoveComponent>();
if(mv)
{
m_drawer->setModelMatrix(Mat4(mv->getWorldTransform()));
}
else
{
m_drawer->setModelMatrix(Mat4::getIdentity());
}
// Spatial
if(m_flags.get(DbgFlag::SPATIAL_COMPONENT))
{
Error err = node.iterateComponentsOfType<SpatialComponent>([&](SpatialComponent& sp) -> Error {
sceneDrawer.draw(sp);
return ErrorCode::NONE;
});
(void)err;
}
// Frustum
if(m_flags.get(DbgFlag::FRUSTUM_COMPONENT))
{
Error err = node.iterateComponentsOfType<FrustumComponent>([&](FrustumComponent& frc) -> Error {
if(&frc != &camFrc)
{
sceneDrawer.draw(frc);
}
return ErrorCode::NONE;
});
(void)err;
}
// Sector/portal
if(m_flags.get(DbgFlag::SECTOR_COMPONENT))
{
Error err = node.iterateComponentsOfType<SectorComponent>([&](SectorComponent& psc) -> Error {
sceneDrawer.draw(psc);
return ErrorCode::NONE;
});
err = node.iterateComponentsOfType<PortalComponent>([&](PortalComponent& psc) -> Error {
sceneDrawer.draw(psc);
return ErrorCode::NONE;
});
(void)err;
}
// Decal
if(m_flags.get(DbgFlag::DECAL_COMPONENT))
{
Error err = node.iterateComponentsOfType<DecalComponent>([&](DecalComponent& psc) -> Error {
sceneDrawer.draw(psc);
return ErrorCode::NONE;
});
(void)err;
}
});
if(m_flags.get(DbgFlag::PHYSICS))
{
PhysicsDebugDrawer phyd(m_drawer);
m_drawer->setModelMatrix(Mat4::getIdentity());
phyd.drawWorld(scene.getPhysicsWorld());
}
#if 0
{
m_drawer->setViewProjectionMatrix(camFrc.getViewProjectionMatrix());
m_drawer->setModelMatrix(Mat4::getIdentity());
CollisionDebugDrawer cd(m_drawer);
Mat4 proj = camFrc.getProjectionMatrix();
m_drawer->setViewProjectionMatrix(camFrc.getViewProjectionMatrix());
Sphere s(Vec4(1.2, 2.0, -1.1, 0.0), 2.1);
s.accept(cd);
Transform trf = scene.findSceneNode("light0").getComponent<MoveComponent>().getWorldTransform();
Vec4 rayOrigin = trf.getOrigin();
Vec3 rayDir = -trf.getRotation().getZAxis().getNormalized();
m_drawer->setModelMatrix(Mat4::getIdentity());
m_drawer->drawLine(rayOrigin.xyz(), rayOrigin.xyz() + rayDir.xyz() * 10.0, Vec4(1.0, 1.0, 1.0, 1.0));
Array<Vec4, 2> intersectionPoints;
U intersectionPointCount;
s.intersectsRay(rayDir.xyz0(), rayOrigin, intersectionPoints, intersectionPointCount);
for(U i = 0; i < intersectionPointCount; ++i)
{
m_drawer->drawLine(Vec3(0.0), intersectionPoints[i].xyz(), Vec4(0.0, 1.0, 0.0, 1.0));
}
}
#endif
#if 0
{
Clusterer c;
c.init(getAllocator(), 16, 12, 30);
const FrustumComponent& frc = scene.findSceneNode("cam0").getComponent<FrustumComponent>();
const MoveComponent& movc = scene.findSceneNode("cam0").getComponent<MoveComponent>();
ClustererPrepareInfo pinf;
pinf.m_viewMat = frc.getViewMatrix();
pinf.m_projMat = frc.getProjectionMatrix();
pinf.m_camTrf = frc.getFrustum().getTransform();
c.prepare(m_r->getThreadPool(), pinf);
class DD : public ClustererDebugDrawer
{
public:
DebugDrawer* m_d;
void operator()(const Vec3& lineA, const Vec3& lineB, const Vec3& color)
{
m_d->drawLine(lineA, lineB, color.xyz1());
}
};
DD dd;
dd.m_d = m_drawer;
CollisionDebugDrawer cd(m_drawer);
Sphere s(Vec4(1.0, 0.1, -1.2, 0.0), 1.2);
PerspectiveFrustum fr(toRad(25.), toRad(35.), 0.1, 5.);
fr.transform(Transform(Vec4(0., 1., 0., 0.), Mat3x4::getIdentity(), 1.0));
m_drawer->setModelMatrix(Mat4(movc.getWorldTransform()));
// c.debugDraw(dd);
if(frc.getFrustum().insideFrustum(fr))
{
ClustererTestResult rez;
c.initTestResults(getAllocator(), rez);
Aabb sbox;
fr.computeAabb(sbox);
c.binPerspectiveFrustum(fr, sbox, rez);
//c.bin(s, sbox, rez);
c.debugDrawResult(rez, dd);
}
m_drawer->setColor(Vec4(1.0, 1.0, 0.0, 1.0));
frc.getFrustum().accept(cd);
fr.accept(cd);
}
#endif
#if 0
{
CollisionDebugDrawer cd(m_drawer);
Array<Vec3, 4> poly;
poly[0] = Vec3(0.0, 0.0, 0.0);
poly[1] = Vec3(2.5, 0.0, 0.0);
Mat4 trf(Vec4(147.392776, -12.132728, 16.607138, 1.0),
Mat3(Euler(toRad(45.0), toRad(0.0), toRad(120.0))),
1.0);
Array<Vec3, 4> polyw;
polyw[0] = trf.transform(poly[0]);
polyw[1] = trf.transform(poly[1]);
m_drawer->setModelMatrix(Mat4::getIdentity());
m_drawer->drawLine(polyw[0], polyw[1], Vec4(1.0));
Vec4 p0 = camFrc.getViewMatrix() * polyw[0].xyz1();
p0.w() = 0.0;
Vec4 p1 = camFrc.getViewMatrix() * polyw[1].xyz1();
p1.w() = 0.0;
Vec4 r = p1 - p0;
r.normalize();
Vec4 a = camFrc.getProjectionMatrix() * p0.xyz1();
a /= a.w();
Vec4 i;
if(r.z() > 0)
{
// Plane near(Vec4(0, 0, -1, 0), camFrc.getFrustum().getNear() +
// 0.001);
// Bool in = near.intersectRay(p0, r * 100000.0, i);
i.z() = -camFrc.getFrustum().getNear();
F32 t = (i.z() - p0.z()) / r.z();
i.x() = p0.x() + t * r.x();
i.y() = p0.y() + t * r.y();
i = camFrc.getProjectionMatrix() * i.xyz1();
i /= i.w();
}
else
{
i = camFrc.getProjectionMatrix() * (r * 100000.0).xyz1();
i /= i.w();
}
/*r *= 0.01;
Vec4 b = polyw[0].xyz0() + r;
b = camFrc.getViewProjectionMatrix() * b.xyz1();
Vec4 d = b / b.w();*/
m_drawer->setViewProjectionMatrix(Mat4::getIdentity());
m_drawer->drawLine(
Vec3(a.xy(), 0.1), Vec3(i.xy(), 0.1), Vec4(1.0, 0, 0, 1));
}
#endif
m_drawer->finishFrame();
cmdb->endRenderPass();
return ErrorCode::NONE;
}
void C4GraphicsOverlay::Draw(C4TargetFacet &cgo, C4Object *pForObj, int32_t iByPlayer)
{
assert(!IsPicture());
assert(pForObj);
// get target pos
float offX, offY;
float newzoom;
pForObj->GetDrawPosition(cgo, offX, offY, newzoom);
ZoomDataStackItem zdsi(newzoom);
// special blit mode
if (dwBlitMode == C4GFXBLIT_PARENT)
(OverlayObj ? static_cast<C4Object*>(OverlayObj) : pForObj)->PrepareDrawing();
else
{
pDraw->SetBlitMode(dwBlitMode);
if (dwClrModulation != 0xffffff) pDraw->ActivateBlitModulation(dwClrModulation);
if (pMeshInstance)
pMeshInstance->SetFaceOrderingForClrModulation(dwClrModulation);
}
if (eMode == MODE_Rank)
{
C4TargetFacet ccgo;
ccgo.Set(cgo.Surface, offX+pForObj->Shape.x,offY+pForObj->Shape.y,pForObj->Shape.Wdt,pForObj->Shape.Hgt, cgo.TargetX, cgo.TargetY);
DrawRankSymbol(ccgo, OverlayObj);
}
// drawing specific object?
else if (OverlayObj)
{
// TODO: Shouldn't have called PrepareDrawing/set ClrModulation here, since
// OverlayObj drawing will do it on its own.
if (eMode == MODE_ObjectPicture)
{
C4Facet fctTarget;
fctTarget.Set(cgo.Surface, offX+pForObj->Shape.x, offY+pForObj->Shape.y, pForObj->Shape.Wdt, pForObj->Shape.Hgt);
OverlayObj->DrawPicture(fctTarget, false, &C4DrawTransform(Transform, fctTarget.X+float(fctTarget.Wdt)/2, fctTarget.Y+float(fctTarget.Hgt)/2));
}
else
{
// Draw specified object at target pos of this object; offset by transform.
OverlayObj->Draw(cgo, iByPlayer, C4Object::ODM_Overlay, offX + Transform.GetXOffset(), offY + Transform.GetYOffset());
OverlayObj->DrawTopFace(cgo, iByPlayer, C4Object::ODM_Overlay, offX + Transform.GetXOffset(), offY + Transform.GetYOffset());
}
}
else if (eMode == MODE_ExtraGraphics)
{
// draw self with specified gfx
if (pSourceGfx)
{
C4DefGraphics *pPrevGfx = pForObj->GetGraphics();
C4DrawTransform *pPrevTrf = pForObj->pDrawTransform;
C4DrawTransform trf;
if (pPrevTrf)
{
trf = *pPrevTrf;
trf *= Transform;
}
else
{
trf = Transform;
}
pForObj->SetGraphics(pSourceGfx, true);
pForObj->pDrawTransform = &trf;
pForObj->Draw(cgo, iByPlayer, C4Object::ODM_BaseOnly);
pForObj->DrawTopFace(cgo, iByPlayer, C4Object::ODM_BaseOnly);
pForObj->SetGraphics(pPrevGfx, true);
pForObj->pDrawTransform = pPrevTrf;
}
}
else if(eMode == MODE_Picture || eMode == MODE_IngamePicture)
{
float twdt, thgt;
if (fZoomToShape)
{
twdt = pForObj->Shape.Wdt;
thgt = pForObj->Shape.Hgt;
}
else
{
twdt = pSourceGfx->pDef->Shape.Wdt;
thgt = pSourceGfx->pDef->Shape.Hgt;
}
C4TargetFacet ccgo;
ccgo.Set(cgo.Surface, offX-twdt/2, offY-thgt/2, twdt, thgt, cgo.TargetX, cgo.TargetY);
C4DrawTransform trf(Transform, offX, offY);
// Don't set pForObj because we don't draw the picture of pForObj, but the picture of another definition on top of pForObj:
pSourceGfx->Draw(ccgo, pForObj->Color, NULL, iPhase, 0, &trf);
}
else
{
// no object specified: Draw from fctBlit
// update by object color
if (fctBlit.Surface) fctBlit.Surface->SetClr(pForObj->Color);
if (!pMeshInstance)
{
// draw there
C4DrawTransform trf(Transform, offX, offY);
if (fZoomToShape)
{
float fZoom = std::min(pForObj->Shape.Wdt / std::max(fctBlit.Wdt, 1.0f), pForObj->Shape.Hgt / std::max(fctBlit.Hgt, 1.0f));
trf.ScaleAt(fZoom, fZoom, offX, offY);
}
fctBlit.DrawT(cgo.Surface, offX - fctBlit.Wdt/2 + fctBlit.TargetX, offY - fctBlit.Hgt/2 + fctBlit.TargetY, iPhase, 0, &trf);
}
else
{
C4Def *pDef = pSourceGfx->pDef;
// draw there
C4DrawTransform trf(Transform, offX, offY);
if (fZoomToShape)
{
float fZoom = std::min((float)pForObj->Shape.Wdt / std::max(pDef->Shape.Wdt, 1), (float)pForObj->Shape.Hgt / std::max(pDef->Shape.Hgt, 1));
trf.ScaleAt(fZoom, fZoom, offX, offY);
}
C4Value value;
pDef->GetProperty(P_MeshTransformation, &value);
StdMeshMatrix matrix;
if (C4ValueToMatrix(value, &matrix))
pDraw->SetMeshTransform(&matrix);
pDraw->RenderMesh(*pMeshInstance, cgo.Surface, offX - pDef->Shape.Wdt/2.0, offY - pDef->Shape.Hgt/2.0, pDef->Shape.Wdt, pDef->Shape.Hgt, pForObj->Color, &trf);
pDraw->SetMeshTransform(NULL);
}
}
// cleanup
if (dwBlitMode == C4GFXBLIT_PARENT)
(OverlayObj ? static_cast<C4Object*>(OverlayObj) : pForObj)->FinishedDrawing();
else
{
pDraw->ResetBlitMode();
pDraw->DeactivateBlitModulation();
}
}
void testRangeFilterTrigger(CuTest* tc)
{
TestRangeFilter trf(tc);
trf.testRangeFilterId();
trf.testRangeFilterRand();
}
void Viewer::cb_keyPress(int keycode)
{
switch(keycode)
{
case 'c' :
myMap.check();
break;
case 'a':
{
Utils::Chrono ch;
ch.start();
VertexAttribute<VEC3, MAP> pos2 = myMap.getAttribute<VEC3, VERTEX, MAP>("pos2") ;
if(!pos2.isValid())
pos2 = myMap.addAttribute<VEC3, VERTEX, MAP>("pos2") ;
for (int i=0; i< 10; ++i)
{
TraversorV<MAP> trav(myMap);
for (Dart d=trav.begin(), d_end = trav.end(); d!=d_end ; d = trav.next())
{
pos2[d] = VEC3(0,0,0);
int nb=0;
Traversor2VVaF<MAP> trf(myMap,d);
for (Dart e = trf.begin(),e_end =trf.end() ; e != e_end; e = trf.next())
{
pos2[d] += position[e];
nb++;
}
pos2[d]/=nb;
}
myMap.swapAttributes(position, pos2);
}
std::cout << "Traversor "<< ch.elapsed()<< " ms "<< std::endl;
Algo::Surface::Geometry::computeNormalVertices<PFP>(myMap, position, normal) ;
m_positionVBO->updateData(position) ;
m_normalVBO->updateData(normal) ;
updateGL();
}
break;
case 'b':
{
Utils::Chrono ch;
ch.start();
VertexAttribute<VEC3,MAP> pos2 = myMap.getAttribute<VEC3, VERTEX, MAP>("pos2") ;
if(!pos2.isValid())
pos2 = myMap.addAttribute<VEC3, VERTEX, MAP>("pos2") ;
for (int i=0; i< 6; ++i)
{
foreach_cell<VERTEX>(myMap, [&] (Vertex d)
{
pos2[d] = VEC3(0,0,0);
int nb=0;
foreach_adjacent2<FACE>(myMap,d,[&](Vertex e)
{
pos2[d] += position[e];
nb++;
});
pos2[d]/=nb;
});
myMap.swapAttributes(position,pos2);
}
std::cout << "Lambda "<< ch.elapsed()<< " ms "<< std::endl;
Algo::Surface::Geometry::computeNormalVertices<PFP>(myMap, position, normal) ;
m_positionVBO->updateData(position) ;
m_normalVBO->updateData(normal) ;
updateGL();
}
break;
case 'B':
{
Utils::Chrono ch;
ch.start();
VertexAttribute<VEC3,MAP> pos2 = myMap.getAttribute<VEC3, VERTEX, MAP>("pos2") ;
if(!pos2.isValid())
pos2 = myMap.addAttribute<VEC3, VERTEX, MAP>("pos2") ;
// foreach_cell_EvenOddd<VERTEX>(myMap, [&] (Vertex d)
// {
// pos2[d] = VEC3(0,0,0);
// int nb=0;
// foreach_adjacent2<FACE>(myMap,d,[&](Vertex e)
// {
// pos2[d] += position[e];
// nb++;
// });
// pos2[d]/=nb;
// },
// [&] (Vertex d)
// {
// position[d] = VEC3(0,0,0);
// int nb=0;
// foreach_adjacent2<FACE>(myMap,d,[&](Vertex e)
// {
// position[d] += pos2[e];
// nb++;
// });
// position[d]/=nb;
// },
// 3);
// std::cout << "Even/Odd "<< ch.elapsed()<< " ms "<< std::endl;
Algo::Surface::Geometry::computeNormalVertices<PFP>(myMap, position, normal) ;
m_positionVBO->updateData(position) ;
m_normalVBO->updateData(normal) ;
updateGL();
}
break;
case 'e':
{
Utils::Chrono ch;
ch.start();
VertexAttribute<VEC3,MAP> pos2 = myMap.getAttribute<VEC3, VERTEX, MAP>("pos2") ;
if(!pos2.isValid())
pos2 = myMap.addAttribute<VEC3, VERTEX, MAP>("pos2") ;
for (int i=0; i< 10; ++i)
{
TraversorV<MAP> trav(myMap);
for (Dart d=trav.begin(), d_end = trav.end(); d!=d_end ; d = trav.next())
{
pos2[d] = VEC3(0,0,0);
int nb=0;
Traversor2VE<MAP> trf(myMap,d);
for (Dart e = trf.begin(),e_end =trf.end() ; e != e_end; e = trf.next())
{
pos2[d] += position[myMap.phi1(e)];
nb++;
}
pos2[d]/=nb;
}
myMap.swapAttributes(position,pos2);
}
std::cout << "Traversor "<< ch.elapsed()<< " ms "<< std::endl;
Algo::Surface::Geometry::computeNormalVertices<PFP>(myMap, position, normal) ;
m_positionVBO->updateData(position) ;
m_normalVBO->updateData(normal) ;
updateGL();
}
break;
case 'f':
{
Utils::Chrono ch;
ch.start();
VertexAttribute<VEC3,MAP> pos2 = myMap.getAttribute<VEC3, VERTEX, MAP>("pos2") ;
if(!pos2.isValid())
pos2 = myMap.addAttribute<VEC3, VERTEX, MAP>("pos2") ;
for (int i=0; i< 10; ++i)
{
foreach_cell<VERTEX>(myMap, [&] (Vertex d)
{
pos2[d] = VEC3(0,0,0);
int nb=0;
foreach_incident2<EDGE>(myMap,d,[&](Edge e)
{
pos2[d] += position[myMap.phi1(e)];
nb++;
});
pos2[d]/=nb;
});
myMap.swapAttributes(position,pos2);
}
std::cout << "Lambda "<< ch.elapsed()<< " ms "<< std::endl;
Algo::Surface::Geometry::computeNormalVertices<PFP>(myMap, position, normal) ;
m_positionVBO->updateData(position) ;
m_normalVBO->updateData(normal) ;
updateGL();
}
break;
case'A':
{
myMap.disableQuickTraversal<VERTEX>() ;
#define NBLOOP 5
Utils::Chrono ch;
ch.start();
{
TraversorCell<MAP, VERTEX, FORCE_CELL_MARKING> trav(myMap,true);
for(unsigned int i=0; i<NBLOOP; ++i)
{
for (Cell<VERTEX> v = trav.begin(), e = trav.end(); v.dart != e.dart; v = trav.next())
{
normal[v][0] = 0.0f;
}
}
std::cout << "FORCE_CELL_MARKING "<< ch.elapsed()<< " ms "<< std::endl;
}
ch.start();
{
TraversorCell<MAP, VERTEX> trav(myMap);
for(unsigned int i=0; i<NBLOOP; ++i)
{
for (Cell<VERTEX> v = trav.begin(), e = trav.end(); v.dart != e.dart; v = trav.next())
{
normal[v][0] = 0.0f;
}
}
std::cout << "auto "<< ch.elapsed()<< " ms "<< std::endl;
}
ch.start();
{
TraversorCell<MAP, VERTEX> trav(myMap,true);
for(unsigned int i=0; i<NBLOOP; ++i)
{
for (Cell<VERTEX> v = trav.begin(), e = trav.end(); v.dart != e.dart; v = trav.next())
{
normal[v][0] = 0.0f;
}
}
std::cout << "auto forcedart "<< ch.elapsed()<< " ms "<< std::endl;
}
ch.start();
{
TraversorCell<MAP, VERTEX, FORCE_DART_MARKING> trav(myMap,true);
for(unsigned int i=0; i<NBLOOP; ++i)
{
for (Cell<VERTEX> v = trav.begin(), e = trav.end(); v.dart != e.dart; v = trav.next())
{
normal[v][0] = 0.0f;
}
}
std::cout << "FORCE_DART_MARKING "<< ch.elapsed()<< " ms "<< std::endl;
}
myMap.enableQuickTraversal<MAP, VERTEX>() ;
ch.start();
{
TraversorCell<MAP, VERTEX> trav(myMap);
for(unsigned int i=0; i<NBLOOP; ++i)
{
for (Cell<VERTEX> v = trav.begin(), e = trav.end(); v.dart != e.dart; v = trav.next())
{
normal[v][0] = 0.0f;
}
}
std::cout << "auto (quick) "<< ch.elapsed()<< " ms "<< std::endl;
}
ch.start();
{
TraversorCell<MAP, VERTEX, FORCE_QUICK_TRAVERSAL> trav(myMap);
for(unsigned int i=0; i<NBLOOP; ++i)
{
for (Cell<VERTEX> v = trav.begin(), e = trav.end(); v.dart != e.dart; v = trav.next())
{
normal[v][0] = 0.0f;
}
}
std::cout << "FORCE_QUICK_TRAVERSAL "<< ch.elapsed()<< " ms "<< std::endl;
}
}
break;
case'Z':
{
Utils::Chrono ch;
ch.start();
CGoGN::Parallel::NumberOfThreads = 1;
for (unsigned int i=0; i<4; ++i)
Algo::Surface::Geometry::Parallel::computeNormalVertices<PFP>(myMap, position, normal) ;
std::cout << "Algo::Surface::Geometry::Parallel::computeNormalVertices1 "<< ch.elapsed()<< " ms "<< std::endl;
ch.start();
CGoGN::Parallel::NumberOfThreads = 2;
for (unsigned int i=0; i<4; ++i)
Algo::Surface::Geometry::Parallel::computeNormalVertices<PFP>(myMap, position, normal) ;
std::cout << "Algo::Surface::Geometry::Parallel::computeNormalVertices2 "<< ch.elapsed()<< " ms "<< std::endl;
ch.start();
CGoGN::Parallel::NumberOfThreads = 3;
for (unsigned int i=0; i<4; ++i)
Algo::Surface::Geometry::Parallel::computeNormalVertices<PFP>(myMap, position, normal) ;
std::cout << "Algo::Surface::Geometry::Parallel::computeNormalVertices3 "<< ch.elapsed()<< " ms "<< std::endl;
ch.start();
CGoGN::Parallel::NumberOfThreads = 4;
for (unsigned int i=0; i<4; ++i)
Algo::Surface::Geometry::Parallel::computeNormalVertices<PFP>(myMap, position, normal) ;
std::cout << "Algo::Surface::Geometry::Parallel::computeNormalVertices4 "<< ch.elapsed()<< " ms "<< std::endl;
ch.start();
CGoGN::Parallel::NumberOfThreads = 8;
for (unsigned int i=0; i<4; ++i)
Algo::Surface::Geometry::Parallel::computeNormalVertices<PFP>(myMap, position, normal) ;
std::cout << "Algo::Surface::Geometry::Parallel::computeNormalVertices8 "<< ch.elapsed()<< " ms "<< std::endl;
// ch.start();
// Parallel::foreach_cell_EO<VERTEX>(myMap,[&](Vertex v, unsigned int thr)
// {
// normal[v] = Algo::Surface::Geometry::vertexNormal<PFP>(myMap,v,position);
// },
// [&](Vertex v, unsigned int th)
// {
// normal[v] = Algo::Surface::Geometry::vertexNormal<PFP>(myMap,v,position);
// },2,4,false,FORCE_CELL_MARKING);
// std::cout << "Parallel::foreach_cell_EO "<< ch.elapsed()<< " ms "<< std::endl;
}
break;
default:
break;
}
}
