rSize ruiAbsoluteLayout::Layout(rRect& rect){
if (m_layoutItems.size() == 0) return rSize(0, 0);
rPoint ptmin(INT32_MAX, INT32_MAX);
rPoint ptmax(INT32_MIN, INT32_MIN);
for (size_t i = 0; i < m_layoutItems.size(); i++){
ruiWidget* widget = m_layoutItems[i];
int margins[4] = { 0, 0, 0, 0 };
int top = 0;
int left = 0;
int bottom = 0;
int right = 0;
ruiStyle* properties = widget->ComputedStyle();
bool hasTop = properties->GetInt("top", top);
bool hasLeft = properties->GetInt("left", left);
bool hasBottom = properties->GetInt("bottom", bottom);
bool hasRight = properties->GetInt("right", right);
rSize itemSize = widget->Size();
rPoint position;
if (hasTop)
position.y = top;
else if (hasBottom)
position.y = rect.Bottom() - bottom - itemSize.y;
else
position.y = 0;
if (hasLeft)
position.x = left;
else if (hasRight)
position.x = rect.Right() - right - itemSize.x;
else
position.x = 0;
widget->SetPosition(position);
UpdatePoints(ptmin, ptmax, position);
UpdatePoints(ptmin, ptmax, rPoint(position.x + itemSize.x, position.y + itemSize.y));
}
rPoint difference = ptmax - ptmin;
return rSize(difference.x, difference.y);
}
bool RateLimiter::OpenElement(rapidxml::xml_node<>* elementNode)
{
if(!OpenCADProperties(elementNode)) return false;
if(!OpenControlNodes(elementNode)) return false;
// Element properties
m_upLimit = XMLParser::GetNodeValueDouble(elementNode, "UpperLimit");
m_lowLimit = XMLParser::GetNodeValueDouble(elementNode, "LowerLimit");
StartMove(m_position);
UpdatePoints();
return true;
}
bool Exponential::OpenElement(rapidxml::xml_node<>* elementNode)
{
if(!OpenCADProperties(elementNode)) return false;
if(!OpenControlNodes(elementNode)) return false;
// Element properties
auto value = elementNode->first_node("Value");
m_aValue = XMLParser::GetNodeValueDouble(value, "A");
m_bValue = XMLParser::GetNodeValueDouble(value, "B");
StartMove(m_position);
UpdatePoints();
return true;
}
void Constant::SetValue(double value)
{
m_value = value;
wxString text = StringFromDouble(m_value);
if(m_glText)
m_glText->SetText(text);
else
m_glText = new OpenGLText(text);
m_width = m_glText->GetWidth() + 6 + 2 * m_borderSize;
m_height = m_glText->GetHeight() + 6 + 2 * m_borderSize;
UpdatePoints();
}
/*
==================
void Actor::Initalize(const char* GPSData, double OriginLatitude, double OriginLongitude)
==================
*/
void Actor::Initalize(const char* GPSData, double OriginLatitude, double OriginLongitude) {
gpsData.Import(GPSData);
UpdatePoints(OriginLatitude, OriginLongitude);
renderObject = new Cube();
renderObject->SetRealPosition(loggedPoints.front());
((Cube*)renderObject)->Scale(glm::vec3(0.5f, 0.5f, 0.5f));
//renderObject->Translate(glm::vec3(2, 2, 2));
printf("GPS -> Realspace Conversion\n");
printf("----------------------\n");
for (unsigned int i = 0; i < loggedPoints.size(); i++) {
printf("X: %f | Y: %f | Z: %f\n", loggedPoints[i].x, loggedPoints[i].y, loggedPoints[i].z);
}
printf("----------------------\n\n");
}
void RateLimiter::Rotate(bool clockwise)
{
if(clockwise)
m_angle += 90.0;
else
m_angle -= 90.0;
if(m_angle >= 360.0)
m_angle = 0.0;
else if(m_angle < 0)
m_angle = 270.0;
UpdatePoints();
for(auto it = m_nodeList.begin(), itEnd = m_nodeList.end(); it != itEnd; ++it) {
Node* node = *it;
node->Rotate(clockwise);
}
}
void ACollectable::OnBeginOverlap(AActor* actor, UPrimitiveComponent* actorComponent, int32 actorBodyIndex, bool bFromSweep, const FHitResult & SweepResult)
{
GEngine->AddOnScreenDebugMessage(-1, 2.0f, FColor::Red, TEXT("BeginOverlap"));
if (Role == ROLE_Authority) { UpdatePoints(Cast<ACharacter>(actor), 5); Destroy(); }
}
/**
* @brief Create help create tool.
* @param _id tool id, 0 if tool doesn't exist yet.
* @param d1 first detail.
* @param d2 second detail.
* @param d1id id first detail.
* @param d2id id second detail.
* @param indexD1 index edge in first detail.
* @param indexD2 index edge in second detail.
* @param scene pointer to scene.
* @param doc dom document container.
* @param data container with variables.
* @param parse parser file mode.
* @param typeCreation way we create this tool.
*/
VToolUnionDetails* VToolUnionDetails::Create(const quint32 _id, const VDetail &d1, const VDetail &d2,
const quint32 &d1id, const quint32 &d2id, const quint32 &indexD1,
const quint32 &indexD2, VMainGraphicsScene *scene, VPattern *doc,
VContainer *data, const Document &parse, const Source &typeCreation)
{
VToolUnionDetails *unionDetails = 0;
quint32 id = _id;
if (typeCreation == Source::FromGui)
{
id = data->getNextId();
}
else
{
if (parse != Document::FullParse)
{
doc->UpdateToolData(id, data);
}
}
VAbstractTool::AddRecord(id, Tool::UnionDetails, doc);
if (parse == Document::FullParse)
{
//Scene doesn't show this tool, so doc will destroy this object.
unionDetails = new VToolUnionDetails(doc, data, id, d1, d2, indexD1, indexD2, typeCreation, doc);
QHash<quint32, VDataTool*>* tools = doc->getTools();
tools->insert(id, unionDetails);
for (int i = 0; i < d1.CountNode(); ++i)
{
doc->IncrementReferens(d1.at(i).getId());
}
for (int i = 0; i < d2.CountNode(); ++i)
{
doc->IncrementReferens(d2.at(i).getId());
}
}
VNodeDetail det1p1;
VNodeDetail det1p2;
d1.NodeOnEdge(indexD1, det1p1, det1p2);
Q_UNUSED(det1p2);
VPointF point1;
VPointF point2;
PointsOnEdge(d1, indexD1, point1, point2, data);
VPointF point3;
VPointF point4;
PointsOnEdge(d2, indexD2, point3, point4, data);
const qreal dx = point1.x() - point4.x();
const qreal dy = point1.y() - point4.y();
point3.setX(point3.x()+dx);
point3.setY(point3.y()+dy);
point4.setX(point4.x()+dx);
point4.setY(point4.y()+dy);
const qreal angle = QLineF(point4.toQPointF(), point3.toQPointF()).angleTo(QLineF(point1.toQPointF(),
point2.toQPointF()));
qint32 pointsD2 = 0; //Keeps count points second detail, what we already add.
if (typeCreation == Source::FromGui)
{
qint32 j = 0, i = 0;
VDetail newDetail;
do
{
AddToNewDetail(unionDetails, doc, data, newDetail, d1.RemoveEdge(indexD1), i, id);
++i;
if (i > d1.indexOfNode(det1p1.getId()) && pointsD2 < d2.RemoveEdge(indexD2).CountNode()-2)
{
do
{
FindJ(pointsD2, d2, indexD2, j);
if (pointsD2 == d2.RemoveEdge(indexD2).CountNode() -2)
{
break;
}
if (j >= d2.RemoveEdge(indexD2).CountNode())
{
j=0;
}
AddToNewDetail(unionDetails, doc, data, newDetail, d2.RemoveEdge(indexD2), j, id, dx, dy,
det1p1.getId(), angle);
++pointsD2;
++j;
} while (pointsD2 < d2.RemoveEdge(indexD2).CountNode());
}
} while (i < d1.RemoveEdge(indexD1).CountNode());
newDetail.setName("Detail");
newDetail.setWidth(d1.getWidth());
VToolDetail::Create(0, newDetail, scene, doc, data, parse, Source::FromTool);
QHash<quint32, VDataTool*>* tools = doc->getTools();
SCASSERT(tools != nullptr);
{
VToolDetail *toolDet = qobject_cast<VToolDetail*>(tools->value(d1id));
SCASSERT(toolDet != nullptr);
bool ask = false;
toolDet->Remove(ask);
}
VToolDetail *toolDet = qobject_cast<VToolDetail*>(tools->value(d2id));
SCASSERT(toolDet != nullptr);
bool ask = false;
toolDet->Remove(ask);
}
else
{
quint32 idCount = 0;
qint32 j = 0, i = 0;
do
{
UpdatePoints(id, data, d1.RemoveEdge(indexD1), i, idCount);
++i;
if (i > d1.indexOfNode(det1p1.getId()) && pointsD2 < d2.RemoveEdge(indexD2).CountNode()-2)
{
do
{
FindJ(pointsD2, d2, indexD2, j);
if (pointsD2 == d2.RemoveEdge(indexD2).CountNode()-2)
{
break;
}
if (j >= d2.RemoveEdge(indexD2).CountNode())
{
j=0;
}
UpdatePoints(id, data, d2.RemoveEdge(indexD2), j, idCount, dx, dy, det1p1.getId(), angle);
++pointsD2;
++j;
} while (pointsD2 < d2.RemoveEdge(indexD2).CountNode());
}
} while (i<d1.RemoveEdge(indexD1).CountNode());
}
return nullptr;
}
void
SubdivUserData::Populate(MObject mesh)
{
MStatus s;
MFnMesh meshFn(mesh);
MIntArray vertexCount, vertexList;
meshFn.getVertices(vertexCount, vertexList);
MUintArray edgeIds;
MDoubleArray edgeCreaseData;
meshFn.getCreaseEdges(edgeIds, edgeCreaseData);
MUintArray vtxIds;
MDoubleArray vtxCreaseData;
meshFn.getCreaseVertices(vtxIds, vtxCreaseData );
short level = 1;
FindAttribute(meshFn, "smoothLevel", &level);
if(level < 1) level = 1;
short interpBoundary = 0;
FindAttribute(meshFn, "boundaryRule", &interpBoundary);
if(CompareArray(_vertexList, vertexList) &&
CompareArray(_edgeIds, edgeIds) &&
CompareArray(_edgeCreaseData, edgeCreaseData) &&
CompareArray(_vtxIds, vtxIds) &&
CompareArray(_vtxCreaseData, vtxCreaseData) &&
_level == level &&
_interpBoundary == interpBoundary)
{
return;
}
// update topology
_vertexList = vertexList;
_edgeIds = edgeIds;
_edgeCreaseData = edgeCreaseData;
_vtxIds = vtxIds;
_vtxCreaseData = vtxCreaseData;
_level = level;
_interpBoundary = interpBoundary;
if(_loop){
MIntArray triangleCounts;
meshFn.getTriangles(triangleCounts, vertexList);
int numTriangles = vertexList.length()/3;
vertexCount.clear();
for(int i = 0; i < numTriangles; ++i){
vertexCount.append(3);
}
}
// XXX redundant copy... replace _vertexList with numIndices, etc
// create Osd mesh
std::vector<int> numIndices, faceIndices, edgeCreaseIndices, vtxCreaseIndices;
std::vector<float> edgeCreases, vtxCreases;
numIndices.resize(vertexCount.length());
faceIndices.resize(vertexList.length());
for(int i = 0; i < (int)vertexCount.length(); ++i) numIndices[i] = vertexCount[i];
for(int i = 0; i < (int)vertexList.length(); ++i) faceIndices[i] = vertexList[i];
vtxCreaseIndices.resize(vtxIds.length());
for(int i = 0; i < (int)vtxIds.length(); ++i) vtxCreaseIndices[i] = vtxIds[i];
vtxCreases.resize(vtxCreaseData.length());
for(int i = 0; i < (int)vtxCreaseData.length(); ++i) vtxCreases[i] = (float)vtxCreaseData[i];
edgeCreases.resize(edgeCreaseData.length());
for(int i = 0; i < (int)edgeCreaseData.length(); ++i) edgeCreases[i] = (float)edgeCreaseData[i];
// edge crease index is stored as pair of <face id> <edge localid> ...
int nEdgeIds = edgeIds.length();
edgeCreaseIndices.resize(nEdgeIds*2);
for(int i = 0; i < nEdgeIds; ++i){
int2 vertices;
if (meshFn.getEdgeVertices(edgeIds[i], vertices) != MS::kSuccess) {
s.perror("ERROR can't get creased edge vertices");
continue;
}
edgeCreaseIndices[i*2] = vertices[0];
edgeCreaseIndices[i*2+1] = vertices[1];
}
OpenSubdiv::OsdHbrMesh *hbrMesh = ConvertToHBR(meshFn.numVertices(), numIndices, faceIndices,
vtxCreaseIndices, vtxCreases,
std::vector<int>(), std::vector<float>(),
edgeCreaseIndices, edgeCreases,
interpBoundary, _loop);
int kernel = OpenSubdiv::OsdKernelDispatcher::kCPU;
if (OpenSubdiv::OsdKernelDispatcher::HasKernelType(OpenSubdiv::OsdKernelDispatcher::kOPENMP)) {
kernel = OpenSubdiv::OsdKernelDispatcher::kOPENMP;
}
_osdmesh->Create(hbrMesh, level, kernel);
delete hbrMesh;
// create vertex buffer
if (_vertexBuffer) {
delete _vertexBuffer;
}
_vertexBuffer = _osdmesh->InitializeVertexBuffer(6 /* position + normal */);
// create element array buffer
if (_elementArrayBuffer) delete _elementArrayBuffer;
_elementArrayBuffer = _osdmesh->CreateElementArrayBuffer(level);
_cachedTotal = -1;
UpdatePoints(mesh);
}
