Welcome, Guest. Please login or register. Did you miss your activation email?

Show Posts

This section allows you to view all posts made by this member. Note that you can only see posts made in areas you currently have access to.


Messages - milen

Pages: [1]
1
Window / Re: Failed to activate OpenGL context
« on: October 24, 2018, 07:38:48 am »
eXpl0it3r, Thank you for reply.

But I create and use windows only in separate threads. Each window with its event/draw(update) loop is whole in its thread.

I create class in main(), but the windows are created and controller whole locally in function, whole in its self thread.
So one doubtfully thing is updating of Vertex in the main(). So I remove the whole for cycle from main(), so, there are created only two empty windows.
But the problem persists - I must close them in reverse order of the creation - so if I close first the window 1, and then the window 2, then the Error message "Failed to activate OpenGL context: The handle is invalid." is written, but if I close first window 2, than 1 - no message is displayed.

In the two cases the program seems to work properly and the exit code i 0. But this message in the console worry me.
Why the row of creation/closing is important?! The each class has fully independent memory, thread and so on. No any shared resources. I try to use std::thread and the result is the same.

2
Window / Failed to activate OpenGL context
« on: October 23, 2018, 08:32:32 am »
Failed to activate OpenGL context: The handle is invalid.

Hello,
I try to make my simple Chart class for C++ with SFML. The idea is to make simple windows for charts, each in different thread so to not affect the main program.

The problem is that the opened windows must be closed in reverse order - from the last opened to the first. Else the upper error message displays in the console. Seems that the program works, but this message worry me.
I am not C++ developer, so preliminary thank you for any help!

My source is:

MChart.hpp
#pragma once

#include <SFML/Graphics.hpp>
#include <string>


class MChart
{

public:
  MChart(const unsigned int width = 500, const unsigned int height = 500,
         const std::string xlabel = "", const std::string ylabel = "", const std::string title = "");

  ~MChart();

  void set_data_len(unsigned int N);
  void append_data(float x, float y);
  void update_data(unsigned int i, float x, float y);

private:
  static unsigned int fig_num;

  const unsigned int border{10};
  unsigned int width, height;
  const std::string xlabel, ylabel, title;
  unsigned int fig_num_c;

  sf::Thread th;
  bool MustToStop{false};
  bool Stopped{false};

  sf::VertexArray graph{sf::LinesStrip};
  sf::VertexArray box_grid{sf::Lines};

  void run_dis();
};
 

MChart.cpp
#include <string>
#include <iostream>
#include <SFML/Graphics.hpp>
#include "MChart.hpp"


unsigned int MChart::fig_num{1};


MChart::MChart(const unsigned int width, const unsigned int height,
               const std::string xlabel, const std::string ylabel, const std::string title) :
               width{width}, height{height}, xlabel{xlabel}, ylabel{ylabel}, title{title},
               th{&MChart::run_dis, this}
               // the list of initializers is initialized in declaration order in *.hpp file (see -Wreorder)
{
    this->fig_num_c = MChart::fig_num++;
    this->th.launch();
}

MChart::~MChart()
{
    this->MustToStop = true;
    while (!this->Stopped)
        ;
}

void MChart::run_dis()
{
    // Initialize window
    sf::ContextSettings settings;
    settings.antialiasingLevel = 8;
    sf::RenderWindow window{sf::VideoMode(this->width, this->height),
                            std::to_string(this->fig_num_c), sf::Style::Close, settings};
    window.setVerticalSyncEnabled(true);

    // Draw window
    while (window.isOpen())
    {
        sf::Event event;
        while (window.pollEvent(event))
        {
            if ((event.type == sf::Event::Closed) ||
                ((event.type == sf::Event::KeyPressed) &&
                 (event.key.code == sf::Keyboard::Escape)))
                window.close();
        }

        if (this->MustToStop)
            window.close();

        window.clear(sf::Color(0, 5, 55));

        window.draw(this->graph);
        window.draw(this->box_grid);

        window.display();
    }

    this->Stopped = true;
}

void MChart::set_data_len(unsigned int N)
{
    this->graph.resize(N);
}

void MChart::append_data(float x, float y)
{
    this->graph.append(sf::Vertex(sf::Vector2f(x, y), sf::Color::Yellow));
}

void MChart::update_data(unsigned int i, float x, float y)
{
    if (i < this->graph.getVertexCount())
        graph[i].position = sf::Vector2f(x, y);
}
 

main.cpp
#include "MChart.hpp"

int main()
{
        MChart ch1, ch2;

        for (int i = 0; i < 300; i++)
        {
                ch1.append_data(i, i);
                ch2.append_data(i, i / 2);
        }
        system("pause");
        return 0;
}
 

3
Graphics / Re: fastPixelRendering
« on: August 11, 2015, 06:19:53 pm »
Jesper Juhl, thanks, I will learn about the computer random generators.

About the flickering problem:

I try another my code with fast sinusoid moving:

#include <SFML/Graphics.hpp>
#include <iostream>
#include <sstream>
#include <cmath>

using namespace std;

constexpr double pi() { return atan(1)*4; }

int main()
{
    const unsigned int s = 500u;
    const unsigned int N = 1000u;

    sf::RenderWindow window(sf::VideoMode(s, s),
                            "Osc",
                            sf::Style::Close);
    //window.setVerticalSyncEnabled(true);
    //window.setFramerateLimit(60);

    sf::VertexArray chart(sf::LinesStrip, N+1);
    for (unsigned int i=0; i<=N; i++){
        unsigned int x = i*s/N;
        unsigned int y = s/2 - (s/2-100)*sin(i*2*pi()/N);
        chart[i].position = sf::Vector2f(x, y);
        chart[i].color = sf::Color::Blue;
    }

    while (window.isOpen())
    {
        sf::Event event;
        while (window.pollEvent(event))
            if (event.type == sf::Event::Closed) window.close();

        unsigned int tmpy = chart[0].position.y;
        for (unsigned int i=0; i<N; i++)
            chart[i].position.y = chart[i+1].position.y;
        chart[N].position.y = tmpy;

        window.clear(sf::Color::Yellow);
        window.draw(chart);
        window.display();
    }
    return 0;
}
 

The speed of sinusoid depends on framerate, therefore I do not use verticalSync or FrameRate, to see maximum speed of my PC.
AND - the same problem - sinusoid moves indeed very fast, and on every 2-3 seconds - STOPS for a very little time, and starts moving again.

Just like some buffer overflows... I can try my code on another hardware. Interesting where is the problem - compiler, SFML or hardware, may be video-driver (it is updated)?

4
Graphics / Re: Chart Graph
« on: August 11, 2015, 05:25:02 pm »
Thank you!
I slowly learn the basics of the language and library. I correct the array and this works - now the sinusoid moves (slowly, but moves)!

5
Graphics / Re: fastPixelRendering
« on: August 11, 2015, 05:22:24 pm »
Fumasu, thank you very much!

Your code works! And for some optimization I return the:

for (unsigned int i=3; i<sz; i+=4) px[i] = 255; // set alfa once

and delete the:

px[i+3] = px[i];

It works very well for almost any different sizes (do not see any difference if there are power of two).

BUT, there are still two problems:

- flickering! I thing that on every some seconds (1-3), the rendering stops for a blink, and then continue. This is very strange, such any buffer overflows or ... I have no idea.

- when I set big size of the screen - over 700 pixels - all compiles good, but starting the result exe says - "name.exe stopped working". And Windows suggest to Close. This is completely understandable. I have large amounts of RAM (10GB!, and 1GB Video), the Maximum Texture size, as I mentioned is 16384... I do not know.

But Thanks, for me now is interesting another question - what is wrong with the old well known rand()? Is it bad also in other compilers, or in GCC only?...

P.S. Thenks also for advise about to make my compiled version for SFML!!! I try - it indeed is very simple - I play now with SFML 2.3.1 64bit for TDM 5.1 64bit!!!

6
Graphics / Re: fastPixelRendering
« on: August 10, 2015, 06:25:47 pm »
The Shaders are out of my knowledge.

BUT the code is sooo fast, the dots moves very fast. It will be very good, if there are not the described strange effects. I thing that the problem is specifically hardware - why the power of 2 size (for example 512) do not work, but size 500 work almost fine?!....

7
Graphics / Chart Graph
« on: August 10, 2015, 06:22:23 pm »
I want to draw moving Chart Graph - like wave on oscilloscope. I refresh the points coordinates on every cycle BUT nothing changes on the screen - only one fully static sinusoide (blue on yellow), which do not moves :(
I also try to update positions with sf::Vectror2f(x, y), but the result is same unsuccessful. My code is:

#include <SFML/Graphics.hpp>
#include <iostream>
#include <sstream>
#include <cmath>

using namespace std;

constexpr double pi() { return atan(1)*4; }


int main()
{
    const unsigned int s = 500u;
    const unsigned int N = 1000u;

    sf::RenderWindow window(sf::VideoMode(s, s),
                            "Osc",
                            sf::Style::Close);
    window.setVerticalSyncEnabled(true);
    window.setFramerateLimit(60);

    sf::VertexArray chart(sf::LinesStrip, N);
    for (unsigned int i=0; i<N-1; i++){
        unsigned int x = i*s/N;
        unsigned int y = s/2 - (s/2-100)*sin(i*2*pi()/N);
        chart.append(sf::Vertex(sf::Vector2f(x, y), sf::Color::Blue));
    }

    while (window.isOpen())
    {
        sf::Event event;
        while (window.pollEvent(event))
            if (event.type == sf::Event::Closed) window.close();

        // HERE?!:
        unsigned int tmpy = chart[0].position.y;
        for (unsigned int i=0; i<N-2; i++)
            chart[i].position.y = chart[i+1].position.y;
        chart[N-1].position.y = tmpy;

        window.clear(sf::Color::Yellow);
        window.draw(chart);
        window.display();
    }
    return 0;
}
 

I just start to play with C++ and SFML.
I use Code::Blocks with  TDM-GCC 4.9.2, 64 bit and SFML-2.3.1-windows-gcc-4.8.1-tdm-64-bit.zip.
My system is: Windows 7 64 bit, NVIDIA GeForce GT610

8
Graphics / fastPixelRendering
« on: August 10, 2015, 04:26:04 pm »
I just start to play with C++ and SFML.
I use Code::Blocks with  TDM-GCC 4.9.2, 64 bit and SFML-2.3.1-windows-gcc-4.8.1-tdm-64-bit.zip.
My system is: Windows 7 64 bit, NVIDIA GeForce GT610

I try to make window with effect of snowflakes as on the old televisions. Make two variants. The PROBLEMS are the same:
- flickering
- when I set texture (window) size - power of 2 (as I read that this is faster for the graphic card), on the screen are almost static image of dots, more or less grouped in rows or columns.
- at different size of the screen - the effects are different - flickering (the best case, shown in the next examples), or "moving" random pixels...

The VerticalSync or FrameRate do not change anything special.

Is proper this my code or I make some error logic?

First variant:
----------------
(with Texture from Image)

#include <sstream>
#include <time.h>
#include <stdlib.h>

using namespace std;

string num2str(int i){
    stringstream s;
    s << i;
    return s.str();
}

int main()
{
    const unsigned int s = 500;
    unsigned char c;


    sf::RenderWindow window(sf::VideoMode(s, s),
                            "Random",
                            sf::Style::Close);
    window.setVerticalSyncEnabled(true);
    window.setFramerateLimit(60);

    sf::Image img;
    img.create(s, s, sf::Color(0, 0, 0));

    sf::Texture texture;
    sf::Sprite sprite;
    //window.setTitle(num2str(sf::Texture::getMaximumSize())); // for my card this is 16384
    texture.loadFromImage(img);
    sprite.setTexture(texture, true);

    srand(time(0));

    while (window.isOpen())
    {
        sf::Event event;
        while (window.pollEvent(event))
            if (event.type == sf::Event::Closed) window.close();

        for (unsigned int i=0; i<s; i++)
            for (unsigned int j=0; j<s; j++){
                c = (rand()%2 == 0) ? 0 : 255;
                img.setPixel(i, j, sf::Color(c, c, c));
            }

        texture.update(img);

        window.clear();
        window.draw(sprite);
        window.display();
    }
    return 0;
}
 


Second variant:
--------------------
(with Texture from Array)

#include <SFML/Graphics.hpp>
#include <iostream>
#include <sstream>
#include <time.h>
#include <stdlib.h>

using namespace std;

string num2str(int i){
    stringstream s;
    s << i;
    return s.str();
}

int main()
{
    const unsigned int s = 500;
    const unsigned int sz = s*s*4;
    sf::Uint8 px[sz];

    for (unsigned int i=3; i<sz; i+=4) px[i] = 255; // set alfa once


    sf::RenderWindow window(sf::VideoMode(s, s),
                            "Random",
                            sf::Style::Close);
    window.setVerticalSyncEnabled(true);
    window.setFramerateLimit(60);

    sf::Texture texture;
    texture.create(s, s);

    sf::Sprite sprite;
    //window.setTitle(num2str(sf::Texture::getMaximumSize()));
    //window.setTitle(num2str(RAND_MAX));
    sprite.setTexture(texture);

    srand(time(0));

    while (window.isOpen())
    {
        sf::Event event;
        while (window.pollEvent(event))
            if (event.type == sf::Event::Closed) window.close();
/* [b]I try this to optimize the random fast pixel choice, but the screen become black with only little white random dots[/b]
        for (unsigned int i=0; i<sz-2*16*4; i+=16*4){
                c = rand();
                for (unsigned int j=0; j<16; j++){
                    px[i+j] = (((c >> j) & 1u) == 0) ? 0 : 255;
                    px[i+j+1] = px[i+j]; px[i+j+2] = px[i+j];
                    px[i+j+3] = 255;
                }
        }
*/

        for (unsigned int i=0; i<sz-4; i+=4){
            px[i] = (rand()%2 == 0) ? 0 : 255;
            px[i+1] = px[i]; px[i+2] = px[i];
        }

        texture.update(px);

        window.clear();
        window.draw(sprite);
        window.display();
    }
    return 0;
}
 

Pages: [1]
anything