static QVector<float> parseFPLAINFile(const QString& datFileName, Mesh::Elements& elements) {
// FPLAIN.DAT - CONNECTIVITY (NODE NUM, NODE N, NODE E, NODE S, NODE W, MANNING-N, BED ELEVATION)
QFileInfo fi(datFileName);
QString elemFileName(fi.dir().filePath("FPLAIN.DAT"));
QFile elemFile(elemFileName);
if (!elemFile.open(QIODevice::ReadOnly | QIODevice::Text)) throw LoadStatus::Err_FileNotFound;
QTextStream elemStream(&elemFile);
QVector<float> elevations;
QVector<QVector<int> > orientedEdgeGroups;
while (!elemStream.atEnd())
{
QString line = elemStream.readLine();
QStringList lineParts = line.split(" ", QString::SkipEmptyParts);
if (lineParts.size() != 7) {
throw LoadStatus::Err_UnknownFormat;
}
QVector<int> edgeGroup(4);
edgeGroup[0] = lineParts[1].toInt() -1; //numbered from 1, 0 bondary node
edgeGroup[1] = lineParts[2].toInt() -1; //numbered from 1, 0 bondary node
edgeGroup[2] = lineParts[3].toInt() -1; //numbered from 1, 0 bondary node
edgeGroup[3] = lineParts[4].toInt() -1; //numbered from 1, 0 bondary node
orientedEdgeGroups.push_back(edgeGroup);
elevations.push_back(lineParts[6].toFloat());
}
createElements(orientedEdgeGroups, elements);
return elevations;
}
void BBUnitSprite::setUnitVisualModel(RTSEditor::RTSUnitVisualModel *pUnitVisualModel)
{
if(!pUnitVisualModel) return;
m_pUnitVisualMode = pUnitVisualModel;
createElements();
};
void BBUnitSprite::setEntity(BBProject::BBEntity *pEntity)
{
if(!pEntity) return;
m_pEntity = pEntity;
createElements();
};
/*
Constructors
*/
ProxyConfigWidget::ProxyConfigWidget(QWidget *parent) :
QWidget(parent)
{
this->setWhatsThis(tr("Proxy settings.<br>"
"You can choose one of the options:"
"<ul><li>none - no proxy;</li>"
"<li>http proxy;</li>"
"<li>socks5 proxy.</li></ul>"
"and specify the proxy settings"));
createElements();
layoutElements();
}
void GameSettings::update()
{
Root* root = Ogre::Root::getSingletonPtr();
Ogre::RenderSystem* renderer = root->getRenderSystem();
#if OGRE_VERSION_MINOR == 7 || OGRE_VERSION_MINOR == 8
const RenderSystemList& renderers = root->getAvailableRenderers();
#else
const RenderSystemList renderers = *root->getAvailableRenderers();
#endif
createElements(mVideoRenderer, renderers.size());
for (unsigned int i = 0; i < renderers.size(); ++i)
{
Ogre::RenderSystem* cur = renderers[i];
ListboxItem* item = mVideoRenderer->getListboxItemFromIndex(i);
item->setText(cur->getName());
if (cur == renderer)
{
mVideoRenderer->setItemSelectState(item, true);
}
}
ConfigOptionMap config = renderer->getConfigOptions();
setOption(config, "Full Screen", mVideoFullscreen);
std::vector<RadioButton*> videoColorDepth;
videoColorDepth.push_back(mVideoColorDepth32);
videoColorDepth.push_back(mVideoColorDepth16);
setOption(config, "Colour Depth", videoColorDepth);
std::vector<RadioButton*> videoAntiAliasing;
videoAntiAliasing.push_back(mVideoFsaa0);
videoAntiAliasing.push_back(mVideoFsaa2);
videoAntiAliasing.push_back(mVideoFsaa4);
videoAntiAliasing.push_back(mVideoFsaa8);
setOption(config, "FSAA", videoAntiAliasing);
std::vector<RadioButton*> videoRttMode;
videoRttMode.push_back(mVideoRttModeFBO);
videoRttMode.push_back(mVideoRttModePBuffer);
videoRttMode.push_back(mVideoRttModeCopy);
setOption(config, "RTT Preferred Mode", videoRttMode);
setOption(config, "Video Mode", mVideoResolution);
}
MainWindow::MainWindow()
{
settings.defaults();
m_hsi = NULL;
m_sectval = NULL;
m_mainval = NULL;
m_specval = NULL;
m_waveval = NULL;
m_maincan = new CurveCanvas2D(&m_points);
m_mainstatus = new QLabel;
m_mainstatus->setText("Ready");
m_scroll = new QScrollArea;
m_scroll->setBackgroundRole(QPalette::Dark);
m_scroll->setWidget(m_maincan);
setCentralWidget(m_scroll);
QStatusBar *statusArea = new QStatusBar;
statusArea->addWidget(m_mainstatus);
setStatusBar(statusArea);
m_sectwin = new SectionWindow(this);
m_sectwin->setWindowTitle("Section Viewer");
m_sectwin->hide();
m_specwin = new SpectrumWindow(this);
m_specwin->setWindowTitle("Spectrum Viewer");
m_specwin->hide();
createMainOptions();
createSectOptions();
createElements();
setWindowTitle(tr("Image Viewer"));
resize(settings.mainWidth, settings.mainHeight);
}
void createElementsOrExit(){
g_print ("Creating elements.\n");
createElements();
g_print ("Checking elements.\n");
exitOnInvalidElement();
}
void ExtLang::build(const Lang &lang,ulen map_atom_count)
{
original_atom_count=lang.getAtomCount();
// atoms
{
ulen len=LenAdd(lang.getAtomCount(),lang.getRuleCount());
auto atoms=createAtoms(len);
ulen index=0;
for(auto &atom : lang.getAtoms() )
{
atoms->index=index++;
atoms->name=pool.dup(atom.name);
atoms->map_index=atom.map_index;
++atoms;
}
for(auto &rule : lang.getRules() )
{
atoms->index=index++;
atoms->name=pool.cat(StrLen("@",1),rule.ret->name,StrLen("::",2),rule.name);
atoms->map_index=rule.map_index+map_atom_count;
++atoms;
}
}
// synts
{
ulen len=lang.getSyntCount();
auto synts=createSynts(len);
for(auto &synt : lang.getSynts() )
{
synts->index=synt.index;
synts->name=pool.dup(synt.name);
synts->is_lang=synt.is_lang;
synts->map_index=synt.map_index;
synts->rules.len=synt.rules.len;
++synts;
}
}
// rules
{
ulen len=lang.getRuleCount();
auto rules=createRules(len);
auto atoms=getAtoms();
auto synts=getSynts();
ulen delta=original_atom_count;
for(auto &rule : lang.getRules() )
{
rules->index=rule.index;
rules->name=pool.dup(rule.name);
rules->map_index=rule.map_index;
rules->ret=&(synts[rule.ret->index]);
auto args=createElements(*rules,LenAdd(rule.args.len,1));
for(auto element : rule.args )
{
element.apply( [=] (const AtomDesc *atom) { args->ptr=&(atoms[atom->index]); } ,
[=] (const SyntDesc *synt) { args->ptr=&(synts[synt->index]); } );
++args;
}
args->ptr=&(atoms[rule.index+delta]);
++rules;
}
}
// synts.rules
{
auto synts=this->synts;
auto *ptr=rules.ptr;
for(; +synts ;++synts)
{
ulen len=synts->rules.len;
synts->rules.ptr=ptr;
ptr+=len;
}
}
pool.shrink_extra();
}
TopLang::TopLang(const CondLang &clang)
{
Collector<RuleRec> collector;
DynArray<ulen> map(DoRaw(clang.getSyntCount()));
// atoms
{
auto range=clang.getAtoms();
auto atoms=createAtoms(range.len);
for(; +atoms ;++atoms,++range)
{
atoms->index=range->index;
atoms->name=pool.dup(range->name);
atoms->map_index=range->index;
}
}
// synts
{
auto range=clang.getSynts();
ulen len=0;
for(auto &synt : range ) len=LenAdd(len, Max<ulen>(synt.kinds.len,1) );
auto synts=createSynts(len);
ulen index=0;
ulen map_index=0;
for(; +range ;++range,++map_index)
if( +range->kinds )
{
map[map_index]=index;
StrLen name=range->name;
bool is_lang=range->is_lang;
ulen desc_map_index=range->index;
for(auto &kind : range->kinds )
{
synts->rules.len=makeRules(collector,*range,kind.index);
synts->index=index++;
synts->name=pool.cat(name,StrLen(".",1),kind.name);
synts->is_lang=is_lang;
synts->map_index=desc_map_index;
synts->kind_index=kind.index;
++synts;
}
}
else
{
map[map_index]=index;
synts->rules.len=makeRules(collector,*range);
synts->index=index++;
synts->name=pool.dup(range->name);
synts->is_lang=range->is_lang;
synts->map_index=range->index;
++synts;
}
}
// rules
{
auto range=collector.flat();
auto rules=createRules(range.len);
auto atoms=getAtoms();
auto synts=getSynts();
ulen index=0;
for(; +rules ;++rules,++range)
{
rules->index=index++;
rules->name=range->name;
rules->map_index=range->map_index;
auto arange=Range_const(range->args);
auto args=createElements(*rules,arange.len);
for(; +args ;++args,++arange)
{
arange->element.apply( [=] (const CondLangBase::AtomDesc *atom) { args->ptr=&(atoms[atom->index]); } ,
[=,&map] (const CondLangBase::SyntDesc *synt) { args->ptr=&(synts[map[synt->index]+arange->kind_index]); } );
}
}
}
// synt.rules rules.ret
{
auto synts=this->synts;
auto *ptr=rules.ptr;
for(; +synts ;++synts)
{
ulen len=synts->rules.len;
synts->rules.ptr=ptr;
for(auto &rule : Range(ptr,len) ) rule.ret=synts.ptr;
ptr+=len;
}
}
pool.shrink_extra();
}
int main() {
SDL_Init(SDL_INIT_VIDEO);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2);
SDL_Window* window = SDL_CreateWindow("OpenGL", 100, 100, 800, 600, SDL_WINDOW_OPENGL);
SDL_GLContext context = SDL_GL_CreateContext(window);
// Initialize GLEW
glewExperimental = GL_TRUE;
glewInit();
GLuint vao = createVao();
GLuint vbo = createVertices();
GLuint ebo = createElements();
// Create and compile the vertex shader
GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vertexShader, 1, &vertexSource, NULL);
glCompileShader(vertexShader);
// Create and compile the fragment shader
GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragmentShader, 1, &fragmentSource, NULL);
glCompileShader(fragmentShader);
// Link the vertex and fragment shader into a shader program
GLuint shaderProgram = glCreateProgram();
glAttachShader(shaderProgram, vertexShader);
glAttachShader(shaderProgram, fragmentShader);
glBindFragDataLocation(shaderProgram, 0, "outColor");
glLinkProgram(shaderProgram);
glUseProgram(shaderProgram);
// Specify the layout of the vertex data
GLint posAttrib = glGetAttribLocation(shaderProgram, "position");
glEnableVertexAttribArray(posAttrib);
glVertexAttribPointer(posAttrib, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), 0);
GLint colAttrib = glGetAttribLocation(shaderProgram, "color");
glEnableVertexAttribArray(colAttrib);
glVertexAttribPointer(colAttrib, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), (void*)(2 * sizeof(GLfloat)));
SDL_Event windowEvent;
while (true) {
if (SDL_PollEvent(&windowEvent)) {
if (windowEvent.type == SDL_QUIT
|| (windowEvent.type == SDL_KEYUP
&& windowEvent.key.keysym.sym == SDLK_ESCAPE)) break;
}
// Clear the screen to black
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT);
// Draw a rectangle from the 2 triangles using 6 indices
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
// Swap buffers
SDL_GL_SwapWindow(window);
}
glDeleteProgram(shaderProgram);
glDeleteShader(fragmentShader);
glDeleteShader(vertexShader);
glDeleteBuffers(1, &ebo);
glDeleteBuffers(1, &vbo);
glDeleteVertexArrays(1, &vao);
SDL_GL_DeleteContext(context);
}
LRESULT CALLBACK WndProc(HWND hwnd, UINT Message, WPARAM wParam, LPARAM lParam) {
SOCKET sd;
LPSOCKET_INFORMATION SocketInfo;
DWORD RecvBytes, SendBytes;
DWORD Flags;
switch (Message) {
case WM_CREATE:
createElements(hwnd);
break;
case WM_SOCKET:
if (WSAGETSELECTERROR(lParam)) {
printf("Socket failed with error %d\n", WSAGETSELECTERROR(lParam));
FreeSocketInformation(wParam);
} else {
switch (WSAGETSELECTEVENT(lParam)) {
case FD_CONNECT:
break;
case FD_ACCEPT:
if ((sd = accept(wParam, NULL, NULL)) == INVALID_SOCKET) {
break;
}
CreateSocketInformation(sd);
WSAAsyncSelect(sd, hwnd, WM_SOCKET, FD_READ | FD_CLOSE);
break;
case FD_READ:
SocketInfo = GetSocketInformation(wParam);
// Read data only if the receive buffer is empty.
if (SocketInfo->BytesRECV != 0) {
SocketInfo->RecvPosted = TRUE;
return 0;
} else {
SocketInfo->DataBuf.buf = SocketInfo->Buffer;
SocketInfo->DataBuf.len = DATA_BUFSIZE;
Flags = 0;
if (WSARecv(SocketInfo->Socket, &(SocketInfo->DataBuf), 1, &RecvBytes,
&Flags, NULL, NULL) == SOCKET_ERROR) {
if (WSAGetLastError() != WSAEWOULDBLOCK) {
printf("WSARecv() failed with error %d\n", WSAGetLastError());
FreeSocketInformation(wParam);
return 0;
}
} else { // No error so update the byte count
SocketInfo->BytesRECV = RecvBytes;
}
break;
}
break;
case FD_WRITE:
SocketInfo = GetSocketInformation(wParam);
if (SocketInfo->BytesRECV > SocketInfo->BytesSEND) {
SocketInfo->DataBuf.buf = SocketInfo->Buffer + SocketInfo->BytesSEND;
SocketInfo->DataBuf.len = SocketInfo->BytesRECV - SocketInfo->BytesSEND;
if (WSASend(SocketInfo->Socket, &(SocketInfo->DataBuf), 1, &SendBytes, 0,
NULL, NULL) == SOCKET_ERROR) {
if (WSAGetLastError() != WSAEWOULDBLOCK) {
printf("WSASend() failed with error %d\n", WSAGetLastError());
FreeSocketInformation(wParam);
return 0;
}
}
else { // No error so update the byte count
SocketInfo->BytesSEND += SendBytes;
}
}
if (SocketInfo->BytesSEND == SocketInfo->BytesRECV) {
SocketInfo->BytesSEND = 0;
SocketInfo->BytesRECV = 0;
// If a RECV occurred during our SENDs then we need to post an FD_READ
// notification on the socket.
if (SocketInfo->RecvPosted == TRUE) {
SocketInfo->RecvPosted = FALSE;
PostMessage(hwnd, WM_SOCKET, wParam, FD_READ);
}
}
break;
case FD_CLOSE:
printf("Closing socket %d\n", wParam);
FreeSocketInformation(wParam);
break;
}
}
break;
case WM_DESTROY: // Terminate program
PostQuitMessage(0);
break;
default:
return DefWindowProc(hwnd, Message, wParam, lParam);
}
return 0;
}
void BBUnitSprite::setState(RTSEditor::RTS_UNIT_VISUAL_STATE nState)
{
m_nState = nState;
createElements();
};
BottomLang::BottomLang(const CondLang &clang)
{
// atoms
{
auto range=clang.getAtoms();
auto atoms=createAtoms(range.len);
for(; +atoms ;++atoms,++range)
{
atoms->index=range->index;
atoms->name=pool.dup(range->name);
}
}
// synts
{
auto range=clang.getSynts();
auto synts=createSynts(range.len);
for(; +synts ;++synts,++range)
{
synts->index=range->index;
synts->name=pool.dup(range->name);
synts->is_lang=range->is_lang;
}
}
// rules
{
auto range=clang.getRules();
auto rules=createRules(range.len);
for(; +rules ;++rules,++range)
{
rules->index=range->index;
rules->name=pool.dup(range->name);
}
}
// synts.rules
{
auto range=clang.getSynts();
auto synts=this->synts;
ulen off=0;
auto rules=getRules();
for(; +synts ;++synts,++range)
{
ulen len=range->rules.len;
synts->rules=rules.part(off,len);
off+=len;
}
}
// rules.ret rules.args
{
auto range=clang.getRules();
auto rules=this->rules;
auto atoms=getAtoms();
auto synts=getSynts();
for(; +rules ;++rules,++range)
{
rules->ret=&(synts[range->ret->index]);
auto arange=range->args;
auto args=createElements(*rules,arange.len);
for(; +args ;++args,++arange)
{
arange->apply( [=] (const CondLangBase::AtomDesc *atom) { args->ptr=&(atoms[atom->index]); } ,
[=] (const CondLangBase::SyntDesc *synt) { args->ptr=&(synts[synt->index]); } );
}
}
}
pool.shrink_extra();
}
