void rePTerrainRenderable::getHeigtmap(int x0, int y0, int x1, int y1, float vertices[])
{
int i=0;
reVec3 offset(-int(columns()/2)*size().x, 0, -int(rows()/2)*size().y);
for ( size_t y=y0; y<y1; y++)
for ( size_t x=x0; x<x1; x++)
{
float x1 = x*size().x;
float y1 = y*size().y;
reVec4 pos = reVec4(x1, 0, y1, 1);
pos.x+=offset.x; pos.z +=offset.z;
reVec4 wpos = node->worldTransform().matrix * pos;
vertices[i++] = calculateVertex(wpos).y;
}
};
void rePTerrain::updateHeightmap()
{
reVec3 center = worldTransform().position();
center.y = 0;
body->readTransform();
reVec3 offset3 = center - reVec3(collisionCols*collisionWidth/2, 0, collisionRows*collisionHeight/2);
reVec4 offset(offset3.x, offset3.y, offset3.z, 0);
int i=0;
for ( size_t y=0; y<collisionRows+1; y++)
{
for ( size_t x = 0; x<collisionCols+1; x++)
{
reVec4 pos = reVec4(x*collisionWidth, 0, y*collisionHeight, 0) + offset;
heightmap[i] = calculateVertex(pos).y;
i+=1;
}
}
}
void OsmAnd::MapRasterizer_P::rasterizePolyline(
const Context& context,
SkCanvas& canvas,
const std::shared_ptr<const MapPrimitiviser::Primitive>& primitive,
bool drawOnlyShadow)
{
const auto& points31 = primitive->sourceObject->points31;
const auto& area31 = context.area31;
const auto& env = context.env;
assert(points31.size() >= 2);
SkPaint paint = _defaultPaint;
if (!updatePaint(context, paint, primitive->evaluationResult, PaintValuesSet::Layer_1, false))
return;
bool ok;
ColorARGB shadowColor;
ok = primitive->evaluationResult.getIntegerValue(env->styleBuiltinValueDefs->id_OUTPUT_SHADOW_COLOR, shadowColor.argb);
if (!ok || shadowColor == ColorARGB::fromSkColor(SK_ColorTRANSPARENT))
shadowColor = context.shadowColor;
float shadowRadius;
ok = primitive->evaluationResult.getFloatValue(env->styleBuiltinValueDefs->id_OUTPUT_SHADOW_RADIUS, shadowRadius);
if (drawOnlyShadow && (!ok || shadowRadius <= 0.0f))
return;
SkPath path;
int pointIdx = 0;
bool intersect = false;
int prevCross = 0;
PointF vertex;
const auto pointsCount = points31.size();
auto pPoint = points31.constData();
PointF pVertex;
PointF tempVertex;
for (pointIdx = 0; pointIdx < pointsCount; pointIdx++, pPoint++)
{
const auto& point = *pPoint;
calculateVertex(context, point, vertex);
int cross = 0;
cross |= (point.x < area31.left() ? 1 : 0);
cross |= (point.x > area31.right() ? 2 : 0);
cross |= (point.y < area31.top() ? 4 : 0);
cross |= (point.y > area31.bottom() ? 8 : 0);
if (pointIdx > 0)
{
if ((prevCross & cross) == 0)
{
if (prevCross != 0 || !intersect)
{
simplifyVertexToDirection(context, pVertex, vertex, tempVertex);
path.moveTo(tempVertex.x, tempVertex.y);
}
simplifyVertexToDirection(context, vertex, pVertex, tempVertex);
path.lineTo(tempVertex.x, tempVertex.y);
intersect = true;
}
}
prevCross = cross;
pVertex = vertex;
}
if (!intersect)
return;
if (drawOnlyShadow)
{
rasterizePolylineShadow(
context,
canvas,
path,
paint,
shadowColor,
shadowRadius);
}
else
{
if (updatePaint(context, paint, primitive->evaluationResult, PaintValuesSet::Layer_minus2, false))
canvas.drawPath(path, paint);
if (updatePaint(context, paint, primitive->evaluationResult, PaintValuesSet::Layer_minus1, false))
canvas.drawPath(path, paint);
if (updatePaint(context, paint, primitive->evaluationResult, PaintValuesSet::Layer_0, false))
canvas.drawPath(path, paint);
if (updatePaint(context, paint, primitive->evaluationResult, PaintValuesSet::Layer_1, false))
canvas.drawPath(path, paint);
canvas.drawPath(path, paint);
if (updatePaint(context, paint, primitive->evaluationResult, PaintValuesSet::Layer_2, false))
canvas.drawPath(path, paint);
if (updatePaint(context, paint, primitive->evaluationResult, PaintValuesSet::Layer_3, false))
canvas.drawPath(path, paint);
if (updatePaint(context, paint, primitive->evaluationResult, PaintValuesSet::Layer_4, false))
canvas.drawPath(path, paint);
if (updatePaint(context, paint, primitive->evaluationResult, PaintValuesSet::Layer_5, false))
canvas.drawPath(path, paint);
rasterizePolylineIcons(context, canvas, path, primitive->evaluationResult);
}
}
void OsmAnd::MapRasterizer_P::rasterizePolygon(
const Context& context,
SkCanvas& canvas,
const std::shared_ptr<const MapPrimitiviser::Primitive>& primitive)
{
const auto& points31 = primitive->sourceObject->points31;
const auto& area31 = context.area31;
assert(points31.size() > 2);
assert(primitive->sourceObject->isClosedFigure());
assert(primitive->sourceObject->isClosedFigure(true));
//////////////////////////////////////////////////////////////////////////
//if ((primitive->sourceObject->id >> 1) == 9223372032559801460u)
//{
// int i = 5;
//}
//////////////////////////////////////////////////////////////////////////
SkPaint paint = _defaultPaint;
if (!updatePaint(context, paint, primitive->evaluationResult, PaintValuesSet::Layer_1, true))
return;
// Construct and test geometry against bbox area
SkPath path;
bool containsAtLeastOnePoint = false;
int pointIdx = 0;
PointF vertex;
Utilities::CHValue prevChValue;
QVector< PointI > outerPoints;
const auto pointsCount = points31.size();
auto pPoint = points31.constData();
for (auto pointIdx = 0; pointIdx < pointsCount; pointIdx++, pPoint++)
{
const auto& point = *pPoint;
calculateVertex(context, point, vertex);
// Hit-test
if (!containsAtLeastOnePoint)
{
if (area31.contains(point))
containsAtLeastOnePoint = true;
else
outerPoints.push_back(point);
const auto chValue = Utilities::computeCohenSutherlandValue(point, area31);
if (Q_LIKELY(pointIdx > 0))
{
// Check if line crosses area (reject only if points are on the same side)
const auto intersectedChValue = prevChValue & chValue;
if (static_cast<unsigned int>(intersectedChValue) != 0)
containsAtLeastOnePoint = true;
}
prevChValue = chValue;
}
// Plot vertex
if (pointIdx == 0)
path.moveTo(vertex.x, vertex.y);
else
path.lineTo(vertex.x, vertex.y);
}
//////////////////////////////////////////////////////////////////////////
//if ((primitive->sourceObject->id >> 1) == 9223372032559801460u)
//{
// int i = 5;
//}
//////////////////////////////////////////////////////////////////////////
if (!containsAtLeastOnePoint)
{
// Check area is inside polygon
bool ok = true;
ok = ok || containsHelper(outerPoints, area31.topLeft);
ok = ok || containsHelper(outerPoints, area31.bottomRight);
ok = ok || containsHelper(outerPoints, PointI(0, area31.bottom()));
ok = ok || containsHelper(outerPoints, PointI(area31.right(), 0));
if (!ok)
return;
}
//////////////////////////////////////////////////////////////////////////
//if ((primitive->sourceObject->id >> 1) == 95692962u)
//{
// int i = 5;
//}
//////////////////////////////////////////////////////////////////////////
if (!primitive->sourceObject->innerPolygonsPoints31.isEmpty())
{
path.setFillType(SkPath::kEvenOdd_FillType);
for (const auto& polygon : constOf(primitive->sourceObject->innerPolygonsPoints31))
{
pointIdx = 0;
for (auto itVertex = cachingIteratorOf(constOf(polygon)); itVertex; ++itVertex, pointIdx++)
{
const auto& point = *itVertex;
calculateVertex(context, point, vertex);
if (pointIdx == 0)
path.moveTo(vertex.x, vertex.y);
else
path.lineTo(vertex.x, vertex.y);
}
}
}
canvas.drawPath(path, paint);
if (updatePaint(context, paint, primitive->evaluationResult, PaintValuesSet::Layer_2, false))
canvas.drawPath(path, paint);
}
void rePlayer::messageProcess( reMessageDispatcher* sender, reMessage* message )
{
reVec3 deltaAngle(0,0,0);
float rs = .5f;
switch (message->id)
{
case reM_TIMER:
if (model())
{
reVec3 dirZ = reVec3(model()->worldTransform().matrix * reVec4(0,0,-1, 0));
reVec3 dirX = reVec3(model()->worldTransform().matrix * reVec4(1,0,0, 0));
if (reRadial::shared()->input()->keyStates['W'])
{
body->btBody->applyCentralForce(toBullet(dirZ * 50.0f));
}
if (reRadial::shared()->input()->keyStates['S'])
{
body->btBody->applyCentralForce(toBullet(dirZ * -50.0f));
}
if (reRadial::shared()->input()->keyStates[' '])
{
body->btBody->applyCentralForce(toBullet(dirX * 1.0f));
//reVec4 f = worldTransform().matrix * reVec4(0,-200,0,0);
//btVector3 bf(f.x, f.y, f.z);
//body->btBody->applyCentralForce(bf);
}
if (reRadial::shared()->input()->keyStates['A'])
{
reVec3 v = reVec3(glm::rotate(reMat4(), rs, reVec3(0,1,0)) * reVec4(fromBullet(body->btBody->getLinearVelocity()), 0));
body->btBody->setLinearVelocity(toBullet(v));
model()->transform(glm::rotate(reMat4(), rs, reVec3(0,1,0)) * model()->transform().matrix);
//body->btBody->applyCentralForce(toBullet(f));
}
if (reRadial::shared()->input()->keyStates['D'])
{
reVec3 v = reVec3(glm::rotate(reMat4(), -rs, reVec3(0,1,0)) * reVec4(fromBullet(body->btBody->getLinearVelocity()), 0));
body->btBody->setLinearVelocity(toBullet(v));
model()->transform(glm::rotate(reMat4(), -rs, reVec3(0,1,0)) * model()->transform().matrix);
//deltaAngle += reVec3(0,-1,0);
//model()->transform(glm::rotate(reMat4(), -1.0f, reVec3(0,1,0)) * model()->transform().matrix);
}
reVec3 pos = worldTransform().position();
camera->lookAt(pos);
light->lookAt(pos);
if (pos.y < calculateVertex(reVec4(pos,1)).y)
{
//__debugbreak();
}
break;
}
}
if (glm::length(fromBullet(body->btBody->getLinearVelocity())))
{
reVec3 dir = glm::normalize(fromBullet(body->btBody->getLinearVelocity()));
if (!dir.z)
{
return;
}
float yaw = dir.z < 0 ? glm::atan(dir.x / dir.z) : M_PI - glm::atan(dir.x / -dir.z);
float pitch = glm::atan(dir.y / abs(dir.z));
reMat4 y(glm::rotate(reMat4(), glm::degrees(yaw), reVec3(0,1,0)));
reMat4 p(glm::rotate(reMat4(), glm::degrees(pitch), reVec3(1,0,0)));
model()->children->at(0)->transform(p);
reVec3 da = reVec3(0, glm::degrees(yaw), 0) - camera->lookAngles();
camera->lookAngles(camera->lookAngles() + da / 5.0f );
}
}
