static void
readAndProcessHeaderFields(TSession *const sessionP,
time_t const deadline,
const char **const errorP,
uint16_t *const httpErrorCodeP) {
/*----------------------------------------------------------------------------
Read all the HTTP header fields from the session *sessionP, which has at
least one field coming. Update *sessionP to reflect the information in the
fields.
If we find an error in the fields or while trying to read them, we return
a text explanation of the problem as *errorP and an appropriate HTTP error
code as *httpErrorCodeP. Otherwise, we return *errorP = NULL and nothing
as *httpErrorCodeP.
-----------------------------------------------------------------------------*/
bool endOfHeader;
assert(!sessionP->validRequest);
/* Calling us doesn't make sense if there is already a valid request */
*errorP = NULL; /* initial assumption */
endOfHeader = false; /* Caller assures us there is at least one header */
while (!endOfHeader && !*errorP) {
char *field;
bool error;
readField(sessionP->connP, deadline, &endOfHeader, &field, &error);
if (error) {
xmlrpc_asprintf(errorP, "Failed to read header from "
"client connection.");
*httpErrorCodeP = 408; /* Request Timeout */
} else {
if (!endOfHeader) {
char *p;
char *fieldName;
p = &field[0];
getFieldNameToken(&p, &fieldName, errorP, httpErrorCodeP);
if (!*errorP) {
char *fieldValue;
NextToken((const char **) &p);
fieldValue = p;
TableAdd(&sessionP->requestHeaderFields,
fieldName, fieldValue);
processField(fieldName, fieldValue, sessionP, errorP,
httpErrorCodeP);
}
}
}
}
}
void GPSParser::parseByChar(char c) {
static SentenceType sentence;
static char fieldValue[13];
static byte fieldLength;
static byte fieldIndex;
//if (sentence == SENTENCE_GGA) Serial.print(c);
if (c == ',' || c == '*') {
//if (sentence == SENTENCE_GGA) Serial.print(' ');
// Process field
if (fieldIndex == 0) {
if (memcmp(fieldValue, "$GPGSA", 6) == 0) {
sentence = SENTENCE_GSA;
}
else if (memcmp(fieldValue, "$GPGGA", 6) == 0) {
sentence = SENTENCE_GGA;
}
}
// Add terminating zero
fieldValue[fieldLength] = 0;
processField(sentence, fieldIndex, fieldValue, fieldLength);
fieldIndex++;
fieldLength = 0;
}
else if (c == '\n') {
if (sentence == SENTENCE_GGA) {
//gpsInfo.print();
}
//state = INIT;
sentence = SENTENCE_NONE;
fieldIndex = 0;
fieldLength = 0;
}
else {
if (fieldLength < 12) {
fieldValue[fieldLength++] = c;
}
}
}
int main(int argc, char *argv[])
{
argList::noParallel();
timeSelector::addOptions();
# include "setRootCase.H"
# include "createTime.H"
// Get times list
instantList timeDirs = timeSelector::select0(runTime, args);
# include "createMesh.H"
# include "readTransportProperties.H"
const word& gFormat = runTime.graphFormat();
// Setup channel indexing for averaging over channel down to a line
IOdictionary channelDict
(
IOobject
(
"postChannelExtDict",
mesh.time().constant(),
mesh,
IOobject::MUST_READ_IF_MODIFIED,
IOobject::NO_WRITE
)
);
channelIndex channelIndexing(mesh, channelDict);
List<Triple<word> > fields(channelDict.lookup("fieldsAndIdentifiers"));
bool backwardsCompatibility(channelDict.lookupOrDefault("backwardsCompatibility", true));
// For each time step read all fields
forAll(timeDirs, timeI)
{
runTime.setTime(timeDirs[timeI], timeI);
Info << "Processing fields for time " << runTime.timeName() << endl;
Info << endl;
fileName path(runTime.rootPath()/runTime.caseName()/"graphs"/runTime.timeName());
mkDir(path);
forAll(fields, I)
{
const word& fieldName = fields[I].first();
const word& identifierName = fields[I].second();
const word& moment = fields[I].third();
IOobject fieldHeader
(
fieldName,
runTime.timeName(),
mesh,
IOobject::MUST_READ
);
if (!fieldHeader.headerOk())
{
Info << endl;
Info<< "No " << fieldName <<" field" << endl;
Info << endl;
continue;
}
Info << endl;
Info << fieldName << endl;
if(fieldHeader.headerClassName() == volScalarField::typeName)
{
Info << endl;
Info << " Reading field" << endl;
volScalarField field(fieldHeader, mesh);
Info << " Collapsing field" << endl;
Info << endl;
processField(field, channelIndexing, identifierName, path, gFormat, moment);
}
if(fieldHeader.headerClassName() == volVectorField::typeName)
{
Info << endl;
Info << " Reading field" << endl;
volVectorField field(fieldHeader, mesh);
Info << " Collapsing field" << endl;
Info << endl;
if((fieldHeader.name() == "U" || fieldHeader.name() == "UMean") && backwardsCompatibility)
{
processField(field.component(vector::X)(), channelIndexing, identifierName, path, gFormat, "mean");
}
else
{
processField(field.component(vector::X)(), channelIndexing, identifierName+"_x", path, gFormat, moment);
processField(field.component(vector::Y)(), channelIndexing, identifierName+"_y", path, gFormat, moment);
processField(field.component(vector::Z)(), channelIndexing, identifierName+"_z", path, gFormat, moment);
}
}
if(fieldHeader.headerClassName() == volSymmTensorField::typeName)
{
Info << endl;
Info << " Reading field" << endl;
volSymmTensorField field(fieldHeader, mesh);
Info << " Collapsing field" << endl;
Info << endl;
if((fieldHeader.name() == "UPrime2Mean") && backwardsCompatibility)
{
processField(field.component(symmTensor::XX)(), channelIndexing, "u", path, gFormat, "rms");
processField(field.component(symmTensor::YY)(), channelIndexing, "v", path, gFormat, "rms");
processField(field.component(symmTensor::ZZ)(), channelIndexing, "w", path, gFormat, "rms");
processField(field.component(symmTensor::XY)(), channelIndexing, "uv", path, gFormat, "mean", true);
}
else
{
processField(field.component(symmTensor::XX)(), channelIndexing, identifierName+"_xx", path, gFormat, moment);
processField(field.component(symmTensor::XY)(), channelIndexing, identifierName+"_xy", path, gFormat, moment, true);
processField(field.component(symmTensor::XZ)(), channelIndexing, identifierName+"_xz", path, gFormat, moment, true);
processField(field.component(symmTensor::YY)(), channelIndexing, identifierName+"_yy", path, gFormat, moment);
processField(field.component(symmTensor::YZ)(), channelIndexing, identifierName+"_yz", path, gFormat, moment, true);
processField(field.component(symmTensor::ZZ)(), channelIndexing, identifierName+"_zz", path, gFormat, moment);
}
}
if(fieldHeader.headerClassName() == volTensorField::typeName)
{
Info << endl;
Info << " Reading field" << endl;
volTensorField field(fieldHeader, mesh);
Info << " Collapsing field" << endl;
Info << endl;
processField(field.component(tensor::XX)(), channelIndexing, identifierName+"_xx", path, gFormat, moment);
processField(field.component(tensor::XY)(), channelIndexing, identifierName+"_xy", path, gFormat, moment, true);
processField(field.component(tensor::XZ)(), channelIndexing, identifierName+"_xz", path, gFormat, moment, true);
processField(field.component(tensor::YX)(), channelIndexing, identifierName+"_yx", path, gFormat, moment, true);
processField(field.component(tensor::YY)(), channelIndexing, identifierName+"_yy", path, gFormat, moment);
processField(field.component(tensor::YZ)(), channelIndexing, identifierName+"_yz", path, gFormat, moment, true);
processField(field.component(tensor::XZ)(), channelIndexing, identifierName+"_xz", path, gFormat, moment, true);
processField(field.component(tensor::YZ)(), channelIndexing, identifierName+"_yz", path, gFormat, moment, true);
processField(field.component(tensor::ZZ)(), channelIndexing, identifierName+"_zz", path, gFormat, moment);
}
}
}
void PropertyWindow::drawInternal() {
bool hasSelections = !selections().empty();
Camera* selectedCamera = Attorney::EditorPropertyWindow::getSelectedCamera(_parent);
if (selectedCamera != nullptr) {
if (ImGui::CollapsingHeader(selectedCamera->resourceName().c_str())) {
vec3<F32> eye = selectedCamera->getEye();
if (ImGui::InputFloat3("Eye", eye._v)) {
selectedCamera->setEye(eye);
}
vec3<F32> euler = selectedCamera->getEuler();
if (ImGui::InputFloat3("Euler", euler._v)) {
selectedCamera->setEuler(euler);
}
F32 aspect = selectedCamera->getAspectRatio();
if (ImGui::InputFloat("Aspect", &aspect)) {
selectedCamera->setAspectRatio(aspect);
}
F32 horizontalFoV = selectedCamera->getHorizontalFoV();
if (ImGui::InputFloat("FoV (horizontal)", &horizontalFoV)) {
selectedCamera->setHorizontalFoV(horizontalFoV);
}
vec2<F32> zPlanes = selectedCamera->getZPlanes();
if (ImGui::InputFloat2("zPlanes", zPlanes._v)) {
if (selectedCamera->isOrthoProjected()) {
selectedCamera->setProjection(selectedCamera->orthoRect(), zPlanes);
} else {
selectedCamera->setProjection(selectedCamera->getAspectRatio(), selectedCamera->getVerticalFoV(), zPlanes);
}
}
if (selectedCamera->isOrthoProjected()) {
vec4<F32> orthoRect = selectedCamera->orthoRect();
if (ImGui::InputFloat4("Ortho", orthoRect._v)) {
selectedCamera->setProjection(orthoRect, selectedCamera->getZPlanes());
}
}
ImGui::Text("View Matrix");
ImGui::Spacing();
mat4<F32> viewMatrix = selectedCamera->getViewMatrix();
EditorComponentField worldMatrixField = {
GFX::PushConstantType::MAT4,
EditorComponentFieldType::PUSH_TYPE,
true,
"View Matrix",
&viewMatrix
};
processBasicField(worldMatrixField);
ImGui::Text("Projection Matrix");
ImGui::Spacing();
mat4<F32> projMatrix = selectedCamera->getProjectionMatrix();
EditorComponentField projMatrixField = {
GFX::PushConstantType::MAT4,
EditorComponentFieldType::PUSH_TYPE,
true,
"Projection Matrix",
&projMatrix
};
processBasicField(projMatrixField);
}
} else if (hasSelections) {
const F32 smallButtonWidth = 60.0f;
F32 xOffset = ImGui::GetWindowSize().x * 0.5f - smallButtonWidth;
const vector<I64>& crtSelections = selections();
static bool closed = false;
for (I64 nodeGUID : crtSelections) {
SceneGraphNode* sgnNode = node(nodeGUID);
if (sgnNode != nullptr) {
bool enabled = sgnNode->isActive();
if (ImGui::Checkbox(sgnNode->name().c_str(), &enabled)) {
sgnNode->setActive(enabled);
}
ImGui::Separator();
vectorFast<EditorComponent*>& editorComp = Attorney::SceneGraphNodeEditor::editorComponents(*sgnNode);
for (EditorComponent* comp : editorComp) {
if (ImGui::CollapsingHeader(comp->name().c_str(), ImGuiTreeNodeFlags_OpenOnArrow)) {
//const I32 RV = ImGui::AppendTreeNodeHeaderButtons(comp->name().c_str(), ImGui::GetCursorPosX(), 1, &closed, "Remove", NULL, 0);
ImGui::NewLine();
ImGui::SameLine(xOffset);
if (ImGui::Button("INSPECT", ImVec2(smallButtonWidth, 20))) {
Attorney::EditorGeneralWidget::inspectMemory(_context.editor(), std::make_pair(comp, sizeof(EditorComponent)));
}
ImGui::SameLine();
if (ImGui::Button("REMOVE", ImVec2(smallButtonWidth, 20))) {
Attorney::EditorGeneralWidget::inspectMemory(_context.editor(), std::make_pair(nullptr, 0));
}
ImGui::Separator();
vector<EditorComponentField>& fields = Attorney::EditorComponentEditor::fields(*comp);
for (EditorComponentField& field : fields) {
ImGui::Text(field._name.c_str());
ImGui::Spacing();
if (processField(field) && !field._readOnly) {
Attorney::EditorComponentEditor::onChanged(*comp, field);
}
}
}
}
}
}
}
if (hasSelections) {
const F32 buttonWidth = 80.0f;
F32 xOffset = ImGui::GetWindowSize().x - buttonWidth - 20.0f;
ImGui::NewLine();
ImGui::Separator();
ImGui::NewLine();
ImGui::SameLine(xOffset);
if (ImGui::Button("ADD NEW", ImVec2(buttonWidth, 15))) {
ImGui::OpenPopup("COMP_SELECTION_GROUP");
}
static ComponentType selectedType = ComponentType::COUNT;
if (ImGui::BeginPopup("COMP_SELECTION_GROUP")) {
for (ComponentType type : ComponentType::_values()) {
if (type._to_integral() == ComponentType::COUNT) {
continue;
}
if (ImGui::Selectable(type._to_string())) {
selectedType = type;
}
}
ImGui::EndPopup();
}
if (selectedType._to_integral() != ComponentType::COUNT) {
ImGui::OpenPopup("Add new component");
}
if (ImGui::BeginPopupModal("Add new component", NULL, ImGuiWindowFlags_AlwaysAutoResize)) {
ImGui::Text("Add new %s component?", selectedType._to_string());
ImGui::Separator();
if (ImGui::Button("OK", ImVec2(120, 0))) {
selectedType = ComponentType::COUNT;
ImGui::CloseCurrentPopup();
}
ImGui::SetItemDefaultFocus();
ImGui::SameLine();
if (ImGui::Button("Cancel", ImVec2(120, 0))) {
selectedType = ComponentType::COUNT;
ImGui::CloseCurrentPopup();
}
ImGui::EndPopup();
}
}
}
