主页 / user-270698

Юрій Писанка's questions

Martin Hope
Юрій Писанка
Asked: 2022-07-22 00:57:08 +0000 UTC
  • 0

将模型从保险丝导出到搅拌机，而不通过网站运行动画 mixamo？一开始，当我导入它时，我得到了这个： 在此处输入图像描述 我关闭了透明度，我认为我不关心部门的眉毛，我会让材质 在此处输入图像描述 透明度克服但阴影不正确，当我没有尝试使用 ALT N 组合将其转出时，法线没有帮助 在此处输入图像描述 。我意识到问题出在网格中，但我不明白如何解决它，请帮忙。如果不通过mixamo站点，所有从fuse导入的都是这样的，但是这个解决方案不是很好。 模型搅拌机 3.0在此处输入图像描述

3d
Martin Hope
Юрій Писанка
Asked: 2022-07-02 04:26:24 +0000 UTC
  • 0

以前，我问过一个问题，关于在 C++ 程序中使用哪个库来 创建Web 界面，实际上是 C++ 中的http 服务器，HolyBlackCat，是根据cpp-httplib椭圆形的建议。 我真的很喜欢这个库，因为它只包含一个 *.h 文件，这将安装简化到了不可能的地步。和简单。

下面是一个最简单的启动服务器的例子

  //
//  hello.cc
//
//  Copyright (c) 2019 Yuji Hirose. All rights reserved.
//  MIT License
//

#include <httplib.h>
using namespace httplib;

int main(void) {
  Server svr;

  svr.Get("/hi", [](const Request & /*req*/, Response &res) { //Про запросу к адресу 192.168.0.102:8080/hi Вернуть текст как страницу
    res.set_content("Hello World!", "text/plain"); //Текст для возврата и формат
  });
  
    svr.Get("/", [](const Request & /*req*/, Response &res) { //Про запросу к адресу 192.168.0.102:8080/ Вернуть текст как страницу
    res.set_content("Main Pages!", "text/plain"); //Текст для возврата и формат
  });

  //Команда запускает цикл так что в реальных проектах в отдельный процесс её
  svr.listen("192.168.0.102", 8080); // 192.168.0.102:8080 Ип куда розшарить, Ип вашого пк ну и порт какой то главное чтобы не был занят всякими торрентами иле open server
  
  //Проверок не делаем , по этому если программа просто завершала роботу то нужно использовать правильный ип
  //список можно получить командой в консоли ipconfig берем ип lan иле wlan
  }

但是如何处理请求？，例如，在套接字中，我们指示将它们发送到何处的函数，并且在函数本身中，我们已经解析了 url，并且根据请求，我们形成页面并将其返回给用户，一切都很清楚，但没有解决了冻结问题，所以我开始寻找替代方案。在 httplib 中，我在任何示例中都没有看到任何熟悉的内容。

如何在httplib库中接收请求，对其 进行处理并用新数据向发送者返回响应？

通过处理的话，我的意思是在 php $_GET 中接收一个数组。查看客户端使用 get 请求从服务器请求什么，无论是变量还是文件的值，我们都会返回它。当然，我会自己编写处理程序，但是如何创建它并动态返回页面。如果 svr.Get 或类似物不采用文本，而是采用处理函数，这将更合乎逻辑。其中，当被请求时，它将向哪个客户端页面发送请求类型的 Get Post 请求和一个数组，键值。

c++
Martin Hope
Юрій Писанка
Asked: 2022-06-25 21:19:46 +0000 UTC
  • -1

也许有人有一个用于创建 http 服务器的库列表，非常希望它出现在 MSYS2 包管理器中。有足够的例子和俄语。

尝试了 boost asio ， libevent。该示例运行，但在第一个中它没有给浏览器正确的答案，第二个没有提供请求参数列表。我又尝试了一些，但编译后的程序只是因异常调用而崩溃。

唯一的例子工作得很好，我能够在上面构建我的结构 - 这些是纯套接字，但当从 PC 请求时它们有时会紧紧地挂起。

通过俄语的充分解释，我找到了 uWebSockets，但它（库）不适合我，这意味着它没用

分享图书馆列表和一个示例链接，或者更好的是一个足够的课程。

MinGW C++ 代码块

c++
Martin Hope
Юрій Писанка
Asked: 2022-08-25 04:06:35 +0000 UTC
  • 0

我在做一个游戏，像草这样的物体，例如萤火虫，花朵，只是一个带有半透明图片的正方形，我想让他们总是用一张脸在某个地方看相机，并且沿着一个限制轴，在某处没有，因为如果图片被边缘转动，她是不可见的。我试图只对它们应用相机旋转，但只有当相机直视物体时才看起来不错，转动时会变形。

所以。我计算了一个从物体到相机的单位向量，但现在我需要将其转换为弧度或度数。

这就是我如何将弧度（旋转角度）反转为方向矢量，从而制作一个自由相机，它可以在它看起来的地方移动。

glm::vec3 rotateToVec3(glm::vec2 rotate, float radius)
{
    float RadiusXZ = cos(rotate.x);
    float x = (sin(rotate.y) * RadiusXZ)*radius;
    float z = (-cos(rotate.y) * RadiusXZ)*radius;
    float y = (-sin(rotate.x)) * radius;
    return glm::vec3(x, y, z);
}

但是如何将矢量转换为旋转呢？我知道有必要应用 acos asin 之类的东西，但是如何应用呢？也许 glm 有现成的解决方案？

c++
Martin Hope
Юрій Писанка
Asked: 2022-08-10 02:29:22 +0000 UTC
  • 0

您需要将对象从两个字节的结构转换为两个字节的 int，通过端口在 ESP 到 arduino 之间传输，反之亦然，然后将其转换回结构。

C++ 语言，但没有库。

struct PIN
{
    unsigned char PinAndComand;
    unsigned char PWN;
}; 

PIN obj;
int content;

// content = (int)obj;
// obj = (PIN)content;
做什么的？在arduino中，没有办法通过序列传递结构，只有int。我需要为 arduino 的 esp 做一个端口倍增器。

在此处输入图像描述

为什么不使用 int 而不是 struct。

两年来，房间控制板只在esp上工作。但是我需要进行更改，但是我丢失了固件并且不记得锯了。我决定适当地制作一个新的，以免害怕触摸它。

c++
Martin Hope
Юрій Писанка
Asked: 2022-06-22 00:37:03 +0000 UTC
  • 0

我正在学习做布局，我想把它拉到 laravel 上，从头到尾为自己做一个博客，学习布局，使用框架等。我使用纯 CSS Via 预处理器。这里有一个问题，我做了一个流线图，但是如果没有足够的文字，那么它超出了块的边界，如何沿着块的高度缩放图像，使图片拉伸块并做到不要掉出来，我还没有选择看起来更好的东西，但是为了学习，你需要用两种解决方案来弄清楚。

在此处输入图像描述

在此处输入图像描述

#content {
  margin-left: $widthMenu;
  margin-right: $widthMenu;
  min-height: 100vh;
  .post {
    background-color: #eee;
    margin-bottom: 10px;
    box-shadow: 0 0 3px #333;
    border-radius: 3px;
    //$Border
    padding: 15px;
    min-height: 50%;
    font-family: cambria;
    img {
      //height:300px;
      box-shadow: 0 0 3px #333;
      margin: 10px;
      float: left;
      border: 7px solid #eee;
      width: 50%;
      vertical-align: top;
      max-width: 250px;
    }
    .img {
      box-shadow: 0 0 3px #333;
      margin: 10px;
      border: 7px solid #eee;
      width: 100px;
      ;
      height: 100px;
      ;
      background-size: cover;
      //max-width:250px;
      vertical-align: top;
    }
    .title {
      font-size: 27px;
      color: #777;
      text-shadow: 0 0 1px #333;
      transition: 0.3s;
      font-family: cambria;
      &:hover {
        text-shadow: 0 0 3px #333;
        cursor: pointer;
      }
    }
    p {
      margin: 5px;
    }
    .postFutter {
      margin-top: 7px;
      text-align: right;
      a {
        color: #aaa;
      }
    }
  }
}
HTML
<div class='post'>
  <a class="title">Кубизм</a>
  <hr>
  <img src="data/media/media3.jpg">
  <!--div class = "img" style = "background-image: url('data/media/media3.jpg');" ><div-->


  <p>
    Took me two hours, got the 4 minute speedrun trophy under two seconds short of the limit after countless of restarts. Very satisfying once you finally succeed. For two dollars it's a fantastic game at a fantastic prize (on the US store, EU was 3€)

  </p>
  <hr>
  <div class='postFutter'>


    <a href="#">Коментарів (0) | </a>
    <a>Дата: 21.06.2021</a>

  </div>
</div>

该解决方案在 css 中是可取 的整个项目

html
Martin Hope
Юрій Писанка
Asked: 2022-01-09 06:15:31 +0000 UTC
  • 0

编写了一个类，让您无需大量代码即可快速绘制飞机。但是几十架飞机，一切都在几秒钟内冻结了一秒钟。我究竟做错了什么。

请注意，该类仅用于显示正方形，每个正方形都有自己的纹理，不适用于模型。

我将添加一点问题，如何正确绘制每个帧都是唯一的网格，因为它在 OpenGL 2.0 中仅在标准中。OpenGL 3.0

class Plane3_3
{
public:
    //Шейдер программа
    GLuint shaderProgramPlane;

    //Структура одного полигона
    struct Mesh
    {
        GLuint Texture;
        GLuint VAOparam,VBOpoints;
        int Size;
        float R,G,B,A;
    };

    //Временный масив для компиляции в VAO
    vector<GLfloat>Vertex2D;

    //Набор меша 
    std::vector<Mesh>ArrMesh;
    //Екземпляр набора для сброса в масив
    Mesh Temp;


    //Задать цвет
    void Color4f(float R,float G,float B,float A)
    {
        Temp.R = R;
        Temp.G = G;
        Temp.B = B;
        Temp.A = A;
    }

    //Задать цвет в диапазоне  - 255
    void Color4uf(float R,float G,float B,float A)
    {
        Temp.R = R/255;
        Temp.G = G/255;
        Temp.B = B/255;
        Temp.A = A/255;
    }

    //Очистить временные переменные задать текстуру изза нее и цвета не могу месш вклеить в один vao
    void Begin(GLuint Texture)
    {
        Vertex2D.clear();
        Temp.VAOparam = 0;
        Temp.VBOpoints = 0;
        Temp.Texture = Texture;
    }


    //Отрендорить (Скомпилировать) и сбросить в масив
    void End()
    {
    //Создать VAO буфер
    glGenVertexArrays(1,&Temp.VAOparam);
    //Создать VBO буфер
    glGenBuffers(1,&Temp.VBOpoints);

    //Активировать VAO Буфер
    glBindVertexArray(Temp.VBOpoints);
        //Активировать VBO Буфер и связать переменную с буфером
        glBindBuffer(GL_ARRAY_BUFFER,Temp.VBOpoints);
            //Скопировать (координаты) в VBO  ==  GL_ARRAY_BUFFER
            glBufferData(GL_ARRAY_BUFFER,sizeof(float)*Vertex2D.size(),&Vertex2D[0],GL_STREAM_DRAW); //GL_STATIC_DRAW GL_DYNAMIC_DRAW GL_STREAM_DRAW
            //Как шейдер должен распознать точку Текстурные координаты
            glVertexAttribPointer(0,2,GL_FLOAT,GL_FALSE,4*sizeof(GL_FLOAT),(GLvoid*)0);
            //Активировать индекс layout
            glEnableVertexAttribArray(0);


            //Как шейдер должен распознать точку координаты
            glVertexAttribPointer(1,2,GL_FLOAT,GL_FALSE,4*sizeof(GL_FLOAT),(GLvoid*)(2 * sizeof(GL_FLOAT)));
            //Активировать индекс layout
            glEnableVertexAttribArray(1);


        //деактивирую наверное VBO Буфер
        glBindBuffer(GL_ARRAY_BUFFER,0);
    //деактивирую наверное VAO буфер
    glBindVertexArray(0);

    Temp.Size = Vertex2D.size()/4;

    //Сброс в масив
    ArrMesh.push_back(Temp);
    }

    //Создать шейдер
    void CreateShader()
    {//--------------------------------
    GLuint vertexShader;
    vertexShader = glCreateShader(GL_VERTEX_SHADER);
    const GLchar* vertexShaderSourse = "#version 330 core\n"
        "layout(location=0) in vec2 TextCord;\n"
        "layout(location=1) in vec2 position;\n"
        "out vec2 TexCoords;\n"
        "void main()\n"
        "{\n"
        "TexCoords = TextCord;\n"
        "gl_Position = vec4(position.x,position.y,0,1);\n"
        "}\0";
    glShaderSource(vertexShader,1,&vertexShaderSourse,NULL);
    glCompileShader(vertexShader);

    {
        GLint success;
        GLchar infoLog[512];
        glGetShaderiv(vertexShader,GL_COMPILE_STATUS,&success);
        if(!success)
        {
            glGetShaderInfoLog(vertexShader,512,NULL,infoLog);
            std::cout<<"error vertex shader"<<std::endl<<infoLog<<std::endl;
        }
    }
    













    GLuint fragmentShader;
    fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    const GLchar* fragmentShaderSourse = "#version 330 core\n"
        "out vec4 color;\n"
        "in vec2 TexCoords;\n"
        "uniform sampler2D ourTexture;\n"
        "uniform vec4 colorUS;\n"
        "void main()\n"
        "{\n"
        "color = texture(ourTexture, TexCoords)*colorUS;\n"
        "}\n"
        "\0";
    glShaderSource(fragmentShader,1,&fragmentShaderSourse,NULL);
    glCompileShader(fragmentShader);

    {
        GLint success;
        GLchar infoLog[512];
        glGetShaderiv(fragmentShader,GL_COMPILE_STATUS,&success);
        if(!success)
        {
            glGetShaderInfoLog(fragmentShader,512,NULL,infoLog);
            std::cout<<"Fragment Error"<<std::endl<<infoLog<<std::endl;
        }
    }
    


    shaderProgramPlane = glCreateProgram();
    glAttachShader(shaderProgramPlane,vertexShader);
    glAttachShader(shaderProgramPlane,fragmentShader);

    glLinkProgram(shaderProgramPlane);

    glDeleteShader(vertexShader);
    glDeleteShader(fragmentShader);

    {
    GLint success;
    GLchar infoLog[512];
    glGetProgramiv(shaderProgramPlane,GL_LINK_STATUS,&success);
        if(!success)
        {
            glGetProgramInfoLog(shaderProgramPlane,512,NULL,infoLog);
            std::cout<<"error shader"<<std::endl<<infoLog<<std::endl;
        }

    }
    }//--------------------------------













    


    //Добавить точку
    void AddPoint(float tx, float ty,float x,float y)
    {
        Vertex2D.push_back(tx);
        Vertex2D.push_back(ty);

        Vertex2D.push_back(x);
        Vertex2D.push_back(y);
    }



    //Рисовать все
    void Draw()
    {
                
        //Активировать шейдер
        glUseProgram(shaderProgramPlane);

        for(int i = 0; i<ArrMesh.size();i++)
        {

        glActiveTexture(GL_TEXTURE0);
        glBindTexture(GL_TEXTURE_2D, ArrMesh[i].Texture);
        glUniform1i(glGetUniformLocation(shaderProgramPlane, "ourTexture"), 0);


        glUniform4f(glGetUniformLocation(shaderProgramPlane, "colorUS"), ArrMesh[i].R,ArrMesh[i].G,ArrMesh[i].B,ArrMesh[i].A);

        //Активировать vao
        glBindVertexArray(ArrMesh[i].VAOparam);
        //Рисовать масив
        glDrawArrays(GL_TRIANGLES,0,ArrMesh[i].Size);
        //Не понятно вроде деактивирую
        glBindVertexArray(0);

        }

    }


//Очистить все
    void Clear()
    {
        for(int i = 0; i<ArrMesh.size();i++)
        {
        glDeleteVertexArrays(1,&ArrMesh[i].VAOparam);
        glDeleteBuffers(1,&ArrMesh[i].VBOpoints);
        }
        ArrMesh.clear();
    }




    Plane3_3()
    {
        Temp.R = 1;
        Temp.G = 1;
        Temp.B = 1;
        Temp.A = 1;
    }

    ~Plane3_3()
    {
    }
};

/// 决定走另一条路。这些点是静态的，正方形只收集一次，然后使用着色器修改为所需的点。

/*
Керування через шейдер замість меша напряму (рендор мешів лагає)
Предається стандартний меш координати 1 1 
Текстурні координати 1 1
В такому випадку в шейдер ми передаємо координати меша і текстурного квадрата 
Передеємо розміри обох кубів.
*/

class Square
{
    public:
    //Шейдер программа
    GLuint shaderProgramPlane;






    //Создать шейдер
    void CreateShader()
    {//--------------------------------
    GLuint vertexShader;
    vertexShader = glCreateShader(GL_VERTEX_SHADER);
    const GLchar* vertexShaderSourse = "#version 330 core\n"
        "layout(location=0) in vec2 TextCord;\n"
        "layout(location=1) in vec2 position;\n"
        "uniform vec2 S;\n"
        "uniform vec2 P;\n"
        "out vec2 TexCoords;\n"
        "void main()\n"
        "{\n"
        "TexCoords = TextCord;\n"
        "gl_Position = vec4(position.x*S.x+P.x,position.y*S.y+P.y,0,1);\n"
        "}\0";
    glShaderSource(vertexShader,1,&vertexShaderSourse,NULL);
    glCompileShader(vertexShader);

    {
        GLint success;
        GLchar infoLog[512];
        glGetShaderiv(vertexShader,GL_COMPILE_STATUS,&success);
        if(!success)
        {
            glGetShaderInfoLog(vertexShader,512,NULL,infoLog);
            std::cout<<"error vertex shader"<<std::endl<<infoLog<<std::endl;
        }
    }
    













    GLuint fragmentShader;
    fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    const GLchar* fragmentShaderSourse = "#version 330 core\n"
        "out vec4 color;\n"
        "in vec2 TexCoords;\n"
        "uniform sampler2D ourTexture;\n"
        "uniform vec4 colorUS;\n"
        "uniform int textureEnable;\n"
        "uniform vec2 Stx;\n" //Розміркуба текстурних кординат
        "uniform vec2 Ptx;\n" //Зміщення текстурних координат, через шейдер
        "void main()\n"
        "{\n"
        "vec2 TC = TexCoords;\n"
        "TC.x = TC.x * Stx.x + Ptx.x;\n"
        "TC.y = TC.y * Stx.y + Ptx.y;\n"
    //  "TexCoords.y = (TexCoords.y*Stx.y)+Ptx.y;\n"

        "if(textureEnable)\n"
        "color = texture(ourTexture, TC)*colorUS;\n"
        "else\n"
        "color = colorUS;\n"
        "}\n"
        "\0";
    glShaderSource(fragmentShader,1,&fragmentShaderSourse,NULL);
    glCompileShader(fragmentShader);

    {
        GLint success;
        GLchar infoLog[512];
        glGetShaderiv(fragmentShader,GL_COMPILE_STATUS,&success);
        if(!success)
        {
            glGetShaderInfoLog(fragmentShader,512,NULL,infoLog);
            std::cout<<"Fragment Error"<<std::endl<<infoLog<<std::endl;
        }
    }
    


    shaderProgramPlane = glCreateProgram();
    glAttachShader(shaderProgramPlane,vertexShader);
    glAttachShader(shaderProgramPlane,fragmentShader);

    glLinkProgram(shaderProgramPlane);

    glDeleteShader(vertexShader);
    glDeleteShader(fragmentShader);

    {
    GLint success;
    GLchar infoLog[512];
    glGetProgramiv(shaderProgramPlane,GL_LINK_STATUS,&success);
        if(!success)
        {
            glGetProgramInfoLog(shaderProgramPlane,512,NULL,infoLog);
            std::cout<<"error shader"<<std::endl<<infoLog<<std::endl;
        }

    }
    }//--------------------------------






    GLuint VAOparam,VBOpoints;

    void Comp()
    {
    //Создать VAO буфер
    glGenVertexArrays(1,&VAOparam);
    //Создать VBO буфер
    glGenBuffers(1,&VBOpoints);

    std::vector<float> Vertex2D;


    //Point A
    //tx
    Vertex2D.push_back(0);
    //ty
    Vertex2D.push_back(0);


    //x
    Vertex2D.push_back(-0.5);
    //y
    Vertex2D.push_back(-0.5);





    //Point B

    //tx
    Vertex2D.push_back(1);
    //ty
    Vertex2D.push_back(0);

    //x
    Vertex2D.push_back(0.5);
    //y
    Vertex2D.push_back(-0.5);




    //Point C
    //tx
    Vertex2D.push_back(1);
    //ty
    Vertex2D.push_back(1);


    //x
    Vertex2D.push_back(0.5);
    //y
    Vertex2D.push_back(0.5);


    //Point C
    //tx
    Vertex2D.push_back(1);
    //ty
    Vertex2D.push_back(1);


    //x
    Vertex2D.push_back(0.5);
    //y
    Vertex2D.push_back(0.5);




        //Point A
    //tx
    Vertex2D.push_back(0);
    //ty
    Vertex2D.push_back(0);


    //x
    Vertex2D.push_back(-0.5);
    //y
    Vertex2D.push_back(-0.5);








    //Point D

    //tx
    Vertex2D.push_back(0);
    //ty
    Vertex2D.push_back(1);

    //x
    Vertex2D.push_back(-0.5);
    //y
    Vertex2D.push_back(0.5);


    //Активировать VAO Буфер
    glBindVertexArray(VBOpoints);
        //Активировать VBO Буфер и связать переменную с буфером
        glBindBuffer(GL_ARRAY_BUFFER,VBOpoints);
            //Скопировать (координаты) в VBO  ==  GL_ARRAY_BUFFER
            glBufferData(GL_ARRAY_BUFFER,sizeof(float)*Vertex2D.size(),&Vertex2D[0],GL_STATIC_DRAW); //GL_STATIC_DRAW GL_DYNAMIC_DRAW GL_STREAM_DRAW
            //Как шейдер должен распознать точку Текстурные координаты
            glVertexAttribPointer(0,2,GL_FLOAT,GL_FALSE,4*sizeof(GL_FLOAT),(GLvoid*)0);
            //Активировать индекс layout
            glEnableVertexAttribArray(0);


            //Как шейдер должен распознать точку координаты
            glVertexAttribPointer(1,2,GL_FLOAT,GL_FALSE,4*sizeof(GL_FLOAT),(GLvoid*)(2 * sizeof(GL_FLOAT)));
            //Активировать индекс layout
            glEnableVertexAttribArray(1);


        //деактивирую наверное VBO Буфер
        glBindBuffer(GL_ARRAY_BUFFER,0);
    //деактивирую наверное VAO буфер
    glBindVertexArray(0);
    }
    
    //Розмір і позиція куба
    float SX,SY,X,Y;


    void SetSizeAndPos(float sx,float sy,float x,float y)
    {
        SX = sx;
        SY = sy;
        X = x;
        Y = y;
    }

    bool TextureEnable;
    void SetTextureEnable(bool Enable)
    {
        TextureEnable = Enable;
    }

    //Розмір і позиця текстури
    float txSX,txSY,txX,txY;
    void SetTxSizeAndPos(float sx,float sy,float x,float y)
    {
        txSX = sx;
        txSY = sy;
        txX = x;
        txY = y;
    }


    void Draw(GLuint Texture,float R,float G,float B,float A)
    {
                
        //Активировать шейдер
        glUseProgram(shaderProgramPlane);

        if(TextureEnable)
        {
            glActiveTexture(GL_TEXTURE0);
            glBindTexture(GL_TEXTURE_2D, Texture);
            glUniform1i(glGetUniformLocation(shaderProgramPlane, "ourTexture"), 0);
        }

        glUniform1i(glGetUniformLocation(shaderProgramPlane, "textureEnable"), TextureEnable);


        glUniform4f(glGetUniformLocation(shaderProgramPlane, "colorUS"), R/255,G/255,B/255,A/255);


        glUniform2f(glGetUniformLocation(shaderProgramPlane, "S"), SX,SY);
        glUniform2f(glGetUniformLocation(shaderProgramPlane, "P"), X,Y);

        glUniform2f(glGetUniformLocation(shaderProgramPlane, "Stx"), txSX,txSY);
        glUniform2f(glGetUniformLocation(shaderProgramPlane, "Ptx"), txX,txY);
        //glUniform1f(glGetUniformLocation(shaderProgramPlane, "sx"), SX);
        //glUniform1f(glGetUniformLocation(shaderProgramPlane, "sy"), SY);

        //Активировать vao
        glBindVertexArray(VAOparam);
        //Рисовать масив
        glDrawArrays(GL_TRIANGLES,0,6);
        //Не понятно вроде деактивирую
        glBindVertexArray(0);

        
    }


    Square()
    {
    }

    ~Square()
    {
    }
};

//Функція малює квадрат по координатам Ця функція для 2.0 стандарту але користувач може вказати свою
void UserOpenGL3_3_DrawPlane(bool TextureEnable,GLuint TextureID,double x1,double y1,double tx1,double ty1,double x2,double y2,double tx2,double ty2,double x3,double y3,double tx3,double ty3,double x4,double y4,double tx4,double ty4,double R,double G,double B,double A)
{
    Square1.SetSizeAndPos(x2-x1,y4-y1,(x1+x2+x3+x4)/4,(y1+y2+y3+y4)/4);
    Square1.SetTxSizeAndPos(tx2-tx1,ty4-ty1,tx1,ty1);
    Square1.SetTextureEnable(TextureEnable);
    Square1.Draw(TextureID,R,G,B,A);
}
c++
Martin Hope
Юрій Писанка
Asked: 2020-08-17 06:00:54 +0000 UTC
  • 0

我试图弄清楚（地址）读写ESP8266内存。这是代码

   char copy[1000];
   spi_flash_erase_sector(0x7c); //Очистка зачем она нужна непонятно но без нее не работает
   spi_flash_write(0x7c000, (uint32 *)&copy, sizeof(copy)); //Непосредствено запись
   ...
   char ssidAp[1000];
   spi_flash_read(0x7c000, (uint32 *)&ssidAp, sizeof(ssidAp)); //Чтение

一切正常，但如果我在清理中指定地址不是 0x7c 而是 0x7c000 就像在其他地方一样，录制不起作用。数量应该相同。有什么问题，有人可以解决它。（我想将地址转换为十进制系统，但在我解决这个问题之前，这是不可能的）

=== 构建答案===

感谢您解决一切问题的答案。

7C000 = 507904（字节）

7C = 124（只是数字）

扇区大小（以字节为单位）= 4096

记录开始的字节 = 507904 唤醒的扇区号 = 124

结果是开始擦除的初始扇区 = Number * Size = 124 * 4096；

在这种情况下，在十进制系统中，它像这样唤醒

spi_flash_erase_sector(124);
spi_flash_write(507904, (uint32 *)&copy, sizeof(copy));

或者

int Num = 124;
spi_flash_erase_sector(Num);
spi_flash_write(Num * 4096, (uint32 *)&copy, sizeof(copy));
wifi
Martin Hope
Юрій Писанка
Asked: 2020-03-07 04:04:17 +0000 UTC
  • 0

我正在完成一键即时访问声音的程序。

我希望通过单击已保存项目的文件，该文件会在我的程序中打开，但是如何实现它以便程序获取文件的路径？

如果我没有关闭控制台，那将是可能的，这就是答案，

int main(int count, char *arg[])
{
   // arg[0] Адрес программы
   // arg[1] то что нужно файл через который программа была открыта
   // или адрес на то что пытались открыть с помощью этой параграммы
}

但是我关闭了控制台，现在这不是通过参数实现的。

使用以下设置禁用控制台。

在此处输入图像描述

在此处输入图像描述

因此，我使用禁用控制台的 C++ 窗口库 glfw 来使用我的程序打开文件。

或者至少告诉我这个技术叫什么，比如我之前不知道把文件拖到窗口里叫拖放，所以搜索起来很困难。

在此处输入图像描述

如果有人需要它。像这样组织的。感谢你的回答。

    std::string arg = GetCommandLineA();
    std::vector<std::string> Masiv;

    bool tumbler = 0;
    std::string Stemp = "";
    while(arg.size() > 0)
    {

        if(arg[0] == '"')
        {
            tumbler = !tumbler;
            if(tumbler == 0)
            {
                Masiv.push_back(Stemp);
                Stemp = "";
            }
        }

        if(tumbler)
        {
            if(arg[0] != '"')
                Stemp+=arg[0];

        }

        arg.erase(arg.begin()+0);
    }


if(Masiv.size()>1)
    Open(Masiv[1]);
c++
Martin Hope
Юрій Писанка
Asked: 2020-02-15 06:08:17 +0000 UTC
  • 1

例如，有这个代码

<div>
   <div onclick = "$(this).parent().append('<div>text1.5</div>');">text1</div>
   <div>text2</div>
</div>

当我点击时，我得到以下结果

<div>
   <div onclick = "$(this).parent().append('<div>text1.5</div>');">text1</div>
   <div>text2</div>
   <div>text1.5</div>
</div>

但我需要页面是这样的

<div>
   <div onclick = "$(this).parent().append('<div>text1.5</div>');">text1</div>
   <div>text1.5</div>
   <div>text2</div>
</div>

如何实施？

简而言之，如何在找到的元素之后而不是在找到的元素中添加新元素，如下面的函数

$(this).append('<div>text1.5</div>');
javascript
Martin Hope
Юрій Писанка
Asked: 2020-02-13 03:58:27 +0000 UTC
  • 0

C++。vector 在添加新元素时随机调用类的析构函数。

有一个类并立即创建该类的一个向量

class Mp3Window
{

public:
    float Balans;
    float Volume;
    bool Init;
    Mp3Window()
    {
        Init = 0;
        Balans = 0;
        Volume = 0;
    }
    HSAMPLE sample;
    HCHANNEL channel;
    std::string SubName;


    std::string URL;





    //DevChBTG::OBGECT Procces;
    int idObject;
    int idPlay;
    int idPause;
    int idGrup;

    int idTextKey;
    char key;

    int Temp;

    ~Mp3Window()
    {

        {
            BASS_ChannelStop(channel);
            BASS_StreamFree(channel);
        }
    }

};

std::vector<Mp3Window>MusMAs;

这是添加新元素的代码

{
            Mp3Window W;
            MusMAs.push_back(W);
        }
            int id = MusMAs.size()-1;
            MusMAs[id].idGrup = ID1;
            MusMAs[id].idObject = GUI.FindIdObject("CoPres1track",ID1);
            MusMAs[id].idPause = GUI.FindIdObject("CoPres1Pause",ID1);
            MusMAs[id].idPlay = GUI.FindIdObject("CoPres1Play",ID1);
            MusMAs[id].idTextKey = GUI.FindIdObject("CoPres1key",ID1);
            MusMAs[id].URL = URL;
            MusMAs[id].Init = true;
            GUI.mObgects[MusMAs[id].idTextKey].Text = "";




                //nameMP3->Text = utf8_encode( utf8_decode(S).c_str());
                MusMAs[id].sample = MUS;
                MusMAs[id].channel=BASS_SampleGetChannel(MusMAs[id].sample, FALSE); 
                //BASS_ChannelPlay(MusMAs[MusMAs.size()-1].channel, FALSE); //Запуск в начале

结果，当一个新元素添加到旧元素时，调用析构函数并删除歌曲；图为失去访问歌曲的结果（变量）

在此处输入图像描述

如果我注释掉析构函数一切正常 在此处输入图像描述

如何在不评论析构函数的情况下使一切正常

c++
Martin Hope
Юрій Писанка
Asked: 2020-09-21 19:52:21 +0000 UTC
  • 0

我手动找到光源的旋转，并且我知道每一帧应该在 xyz 中旋转多少度。但是使用函数
DirectLight.transform.Rotate(10,10,45); 源而不是到达给定的旋转位置。它相对于当前的旋转移动，并且在 LOOP 中它醒来时根本没有任何语言旋转。

DirectLight.transform.rotation = new Quaternion(10,10,45,1); 以度为单位采取错误的位置

如何以度数指定源应如何在此框架中旋转？

unity3d
Martin Hope
Юрій Писанка
Asked: 2020-06-05 02:19:46 +0000 UTC
  • 1

大家好，我正在使用自己的界面制作应用程序，但是没有关于如何更改使用 glfw 创建的窗口样式的说明。因此，我决定通过 WinApi 修改窗口。但从未设法使用 glfw 获得窗口句柄。我这样做是为了在创建窗口后立即获得活动窗口的句柄。这可以禁用框架，但理论上，如果在创建窗口和应用窗口属性之间，由于某种原因，任何其他窗口变为活动状态，则该属性将应用于活动窗口。

问题是如何使用 GLFW 获取句柄。所以它是我创建的窗口的 100% 句柄。我找到了这个命令，glfwGetWin32Window(window)但是 IDE 告诉我这样的命令不存在。

这是有效的代码，但方式不正确。

C++、视觉工作室 2010、glfw、WinApi。

#pragma comment(lib, "opengl32.lib")
#pragma comment(lib, "glfw3.lib")
#pragma comment(lib, "glew32s.lib")
#include <iostream>
// GLEW
#define GLEW_STATIC
#include <GL/glew.h>
// GLFW
#include <GLFW/glfw3.h>
#include <GLFW/glfw3native.h>

// GLFW
#include <GLFW/glfw3.h>
#include<Windows.h>



int main()
{
    // Init GLFW
    glfwInit();
    // Set all the required options for GLFW
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);


    GLFWwindow* window = glfwCreateWindow(700, 500, "OpenGL", nullptr, nullptr);


    glfwMakeContextCurrent(window);
    glewExperimental = GL_TRUE;
    glewInit();

    //HWND ds = FindWindow("Notepad", NULL); //Получит дескриптор пно названию возможно по классу?
    HWND ds = GetForegroundWindow(); //Получить дескриптор активного окна
    std::cout<<ds;

    //Сделать окно прозрачным
    /*SetWindowLong(ds, GWL_EXSTYLE,
        GetWindowLong(ds, GWL_EXSTYLE) | WS_EX_LAYERED);
    // Делаем окно на 70% не прозрачным
    ::SetLayeredWindowAttributes(ds, 0, (255 * 70) / 100, LWA_ALPHA);*/




    //HWND hWnd =  glfwGetWin32Window(window); Не работает Отсуцтвует команда




    SetWindowLongPtr(ds, GWL_STYLE, WS_POPUP | WS_VISIBLE); //Вимкнути рамки

    // HWND hWnd = GetForegroundWindow(); //Получить дескриптор активного окна





    // Game loop
    while (!glfwWindowShouldClose(window))
    {
        glfwSwapBuffers(window);
        glfwPollEvents();
        glClearColor(0.5, 0.5, 0.7, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    }
    // Terminate GLFW, clearing any resources allocated by GLFW.
    glfwTerminate();
    return 0;
}
c++
Martin Hope
Юрій Писанка
Asked: 2020-05-16 05:07:29 +0000 UTC
  • 2

我从 arduino 的串口读取数据。我在互联网上找到了代码，但它的工作原理很奇怪。

读取时触发读取数据条件，否则不触发。 

while(1)
{
    // memset(szBuff,0,sizeof(szBuff));
    if( ReadFile(hSerial, LPVOID(szBuff), 1, &dwBytesRead, NULL))
    {
        cout << szBuff;
    }
    else
        cout << "noooooooo";    
}

==================================

#include<Windows.h>
#include<stdio.h>
#include<iostream>

using namespace std;

void main()
{
    HANDLE hSerial;
    hSerial = CreateFile(TEXT("COM3"), 
                         GENERIC_READ | GENERIC_WRITE, 
                         0,
                         NULL, 
                         OPEN_EXISTING,                              
                         FILE_ATTRIBUTE_NORMAL,
                         //FILE_FLAG_OVERLAPPED, 
                         NULL);        

    if ( hSerial == INVALID_HANDLE_VALUE)
    {
        printf("Error initializing handler");
    } 
    else 
    {    
        // Set the parameters of the handler to the serial port.
        DCB dcb = {0};    
        dcb.DCBlength = sizeof(dcb);

        if ( !GetCommState(hSerial, &dcb) )
        {
            printf("Error setting parameters");
        }

        //FillMemory(&dcb, sizeof(dcb), 0);
        dcb.BaudRate = CBR_9600;
        dcb.ByteSize = 8;
        dcb.StopBits = ONESTOPBIT;
        dcb.Parity = NOPARITY;

        if ( !SetCommState(hSerial, &dcb) )
        {
        // error setting serial port state.
        }

        // Tell the program not to wait for data to show up
        COMMTIMEOUTS timeouts = {0};

        timeouts.ReadIntervalTimeout = 0;//20;
        timeouts.ReadTotalTimeoutConstant = 0;//20;
        timeouts.ReadTotalTimeoutMultiplier = 0;//50;
        timeouts.WriteTotalTimeoutConstant = 0;//100;
        timeouts.WriteTotalTimeoutMultiplier = 0;//100;

        //if ( !SetCommTimeouts(hSerial, &timeouts) )
        //{
        // printf("Error setting the timeouts");
        //}

        char szBuff[2] = "";
        DWORD dwBytesRead = 0;
        int i = 0;
        char test[] = "B\n";
        // int maxSamples = 10;
        // DWORD dwCommStatus;

        // WriteFile(hSerial, test, 2, &dwBytesRead, NULL);

        // SetCommMask(hSerial,EV_RXCHAR);
        // WaitCommEvent (hSerial, &dwCommStatus, 0);

        // if (dwCommStatus & EV_RXCHAR) 
        {    
            while(1)
            {
                // memset(szBuff,0,sizeof(szBuff));
                if( ReadFile(hSerial, LPVOID(szBuff), 1, &dwBytesRead, NULL))
                {
                    cout<<szBuff;
                }
                else
                    cout << "noooooooo";    
            }            
        }                      
        CloseHandle(hSerial);
    }
}
c++
Martin Hope
Юрій Писанка
Asked: 2020-03-07 00:06:21 +0000 UTC
  • 2

情况：我正在用 C++ 实现一个用于管理本地网络上的计算机的程序。

问题：如何从客户端发送数据结构并在服务器程序上接收。请举个例子。也许有一个专门的图书馆，类似于curl互联网。
解决方案：事实证明，全球网络和本地网络并没有我想象的那么不同。对于解决方案，我将使用我自己的 C++ HTTP 服务器，您可以curl从浏览器访问它。

这是我在同一站点上找到并修改的服务器代码。程序接收到一个请求并从 index.html 文件中返回文本，如果它不存在，它会发送一个文件不存在的消息。感谢所有为这个问题做出贡献的人。

#include <iostream>
#include <sstream>
#include <string>
#include <fstream>

// Для корректной работы freeaddrinfo в MinGW
// Подробнее: http://stackoverflow.com/a/20306451
#define _WIN32_WINNT 0x501

#include <WinSock2.h>
#include <WS2tcpip.h>

// Необходимо, чтобы линковка происходила с DLL-библиотекой
// Для работы с сокетам
#pragma comment(lib, "Ws2_32.lib")

using std::cerr;

//Получить один из ІР первый попавшыйся
std::string GetIP()
{
std::string out = "WinSock ERR";
WSADATA wsaData;
if (!WSAStartup(WINSOCK_VERSION, &wsaData)){char chInfo[64];
if (!gethostname(chInfo, sizeof(chInfo)))
{
hostent *sh;
sh=gethostbyname((char*)&chInfo);
if (sh!=NULL)
{
int nAdapter = 0;
while (sh->h_addr_list[nAdapter])
{
struct sockaddr_in adr;
memcpy(&adr.sin_addr, sh->h_addr_list[nAdapter], sh->h_length);
out = inet_ntoa(adr.sin_addr);
nAdapter++;
}
}
}
}
WSACleanup();
return out;
}

//Получить фаил в формате строки
bool getFile(char* url,std::string &r)
{
    r = "";
    std::ifstream in(url);
            if(in)
            {
                while(1)
                {
                    char t;
                    in.get(t);
                    if(in.eof()) break;
                    r+=t;
                }
            in.close();
            }
            else
            return false;
            return true;
}

int main()
{



    //char *a = (char*)x;

    std::string sIP = GetIP();
    std::cout<<sIP<<'\n';

    WSADATA wsaData; // служебная структура для хранение информации
    // о реализации Windows Sockets
    // старт использования библиотеки сокетов процессом
    // (подгружается Ws2_32.dll)
    int result = WSAStartup(MAKEWORD(2, 2), &wsaData);

    // Если произошла ошибка подгрузки библиотеки
    if (result != 0) {
        cerr << "WSAStartup failed: " << result << "\n";
        return result;
    }

    struct addrinfo* addr = NULL; // структура, хранящая информацию
    // об IP-адресе  слущающего сокета

    // Шаблон для инициализации структуры адреса
    struct addrinfo hints;
    ZeroMemory(&hints, sizeof(hints));

    hints.ai_family = AF_INET; // AF_INET определяет, что будет
    // использоваться сеть для работы с сокетом
    hints.ai_socktype = SOCK_STREAM; // Задаем потоковый тип сокета
    hints.ai_protocol = IPPROTO_TCP; // Используем протокол TCP
    hints.ai_flags = AI_PASSIVE; // Сокет будет биндиться на адрес,
    // чтобы принимать входящие соединения

    // Инициализируем структуру, хранящую адрес сокета - addr
    // Наш HTTP-сервер будет висеть на 8000-м порту локалхоста
    result = getaddrinfo(sIP.c_str(), "80", &hints, &addr);

    // Если инициализация структуры адреса завершилась с ошибкой,
    // выведем сообщением об этом и завершим выполнение программы
    if (result != 0) {
        cerr << "getaddrinfo failed: " << result << "\n";
        WSACleanup(); // выгрузка библиотеки Ws2_32.dll
        return 1;
    }

    // Создание сокета
    int listen_socket = socket(addr->ai_family, addr->ai_socktype,
        addr->ai_protocol);
    // Если создание сокета завершилось с ошибкой, выводим сообщение,
    // освобождаем память, выделенную под структуру addr,
    // выгружаем dll-библиотеку и закрываем программу
    if (listen_socket == INVALID_SOCKET) {
        cerr << "Error at socket: " << WSAGetLastError() << "\n";
        freeaddrinfo(addr);
        WSACleanup();
        return 1;
    }



    // Привязываем сокет к IP-адресу
    result = bind(listen_socket, addr->ai_addr, (int)addr->ai_addrlen);

    // Если привязать адрес к сокету не удалось, то выводим сообщение
    // об ошибке, освобождаем память, выделенную под структуру addr.
    // и закрываем открытый сокет.
    // Выгружаем DLL-библиотеку из памяти и закрываем программу.
    if (result == SOCKET_ERROR) {
        cerr << "bind failed with error: " << WSAGetLastError() << "\n";
        freeaddrinfo(addr);
        closesocket(listen_socket);
        WSACleanup();
        return 1;
    }

    // Инициализируем слушающий сокет
    if (listen(listen_socket, SOMAXCONN) == SOCKET_ERROR) {
        cerr << "listen failed with error: " << WSAGetLastError() << "\n";
        closesocket(listen_socket);
        WSACleanup();
        return 1;
    }


    const int max_client_buffer_size = 1024;
    char buf[max_client_buffer_size];
    int client_socket = INVALID_SOCKET;

    for (;;) {
        // Принимаем входящие соединения
        client_socket = accept(listen_socket, NULL, NULL);
        if (client_socket == INVALID_SOCKET) {
            cerr << "accept failed: " << WSAGetLastError() << "\n";
            closesocket(listen_socket);
            WSACleanup();
            return 1;
        }

        result = recv(client_socket, buf, max_client_buffer_size, 0);

        std::stringstream response; // сюда будет записываться ответ клиенту
        std::stringstream response_body; // тело ответа

        if (result == SOCKET_ERROR) {
            // ошибка получения данных
            cerr << "recv failed: " << result << "\n";
            closesocket(client_socket);
        } else if (result == 0) {
            // соединение закрыто клиентом
            cerr << "connection closed...\n";
        } else if (result > 0) {
            // Мы знаем фактический размер полученных данных, поэтому ставим метку конца строки
            // В буфере запроса.
            buf[result] = '\0';

            // Данные успешно получены
            // формируем тело ответа (HTML)
         /*   response_body << "<title>Test C++ HTTP Server</title>\n"
                << "<h1>Test page</h1>\n"
                << "<p>This is body of the test page...</p>\n";*/

            std::string file;

            std::string zp = buf;
            //int Start = zp.find("GET");
            //int End = zp.find("\n",Start);
            //zp = zp.substr(Start,End);

            //int pos = zp.find("comand=shutdownS",0);

            //if(pos != std::string::npos)
            //std::cout<<pos<<std::endl;

            std::cout<<'\n'<<zp<<'\n';

            if(getFile("index.html",file))
            {       
                    response_body<<file;
            }
            else
            {
                response_body << "<title>Test C++ HTTP Server</title>\n"
                << "<h1>No file index.html</h1>\n"
                << "<p>This is body of the test page...</p>\n";
            }


               /* << "<h2>Request headers</h2>\n"
                << "<pre>" << buf << "</pre>\n"
                << "<em><small>Test C++ Http Server</small></em>\n";*/

            // Формируем весь ответ вместе с заголовками
            response << "HTTP/1.1 200 OK\r\n"
                << "Version: HTTP/1.1\r\n"
                << "Content-Type: text/html; charset=utf-8\r\n"
                << "Content-Length: " << response_body.str().length()
                << "\r\n\r\n"
                << response_body.str();

            // Отправляем ответ клиенту с помощью функции send
            result = send(client_socket, response.str().c_str(),
                response.str().length(), 0);

            if (result == SOCKET_ERROR) {
                // произошла ошибка при отправле данных
                cerr << "send failed: " << WSAGetLastError() << "\n";
            }
            // Закрываем соединение к клиентом
            closesocket(client_socket);
        }
    }

    // Убираем за собой
    closesocket(listen_socket);
    freeaddrinfo(addr);
    WSACleanup();
    return 0;
}

当我试图找出代码时，我总是删除不必要的检查，因为这里是没有检查的代码

#include <iostream>
    #include <sstream>
    #include <string>
    #include <fstream>

    // Для корректной работы freeaddrinfo в MinGW
    // Подробнее: http://stackoverflow.com/a/20306451
    #define _WIN32_WINNT 0x501

    #include <WinSock2.h>
    #include <WS2tcpip.h>

    // Необходимо, чтобы линковка происходила с DLL-библиотекой
    // Для работы с сокетам
    #pragma comment(lib, "Ws2_32.lib")

    using std::cerr;

    //Получить один из ІР первый попавшыйся
    std::string GetIP()
    {
    std::string out = "WinSock ERR";
    WSADATA wsaData;
    if (!WSAStartup(WINSOCK_VERSION, &wsaData)){char chInfo[64];
    if (!gethostname(chInfo, sizeof(chInfo)))
    {
    hostent *sh;
    sh=gethostbyname((char*)&chInfo);
    if (sh!=NULL)
    {
    int nAdapter = 0;
    while (sh->h_addr_list[nAdapter])
    {
    struct sockaddr_in adr;
    memcpy(&adr.sin_addr, sh->h_addr_list[nAdapter], sh->h_length);
    out = inet_ntoa(adr.sin_addr);
    nAdapter++;
    }
    }
    }
    }
    WSACleanup();
    return out;
    }


    int main()
    {



        //char *a = (char*)x;

        std::string sIP = GetIP();
        std::cout<<sIP<<'\n';

        WSADATA wsaData; // служебная структура для хранение информации
        // о реализации Windows Sockets
        // старт использования библиотеки сокетов процессом
        // (подгружается Ws2_32.dll)
        int result = WSAStartup(MAKEWORD(2, 2), &wsaData);


        struct addrinfo* addr = NULL; // структура, хранящая информацию
        // об IP-адресе  слущающего сокета

        // Шаблон для инициализации структуры адреса
        struct addrinfo hints;
        ZeroMemory(&hints, sizeof(hints));

        hints.ai_family = AF_INET; // AF_INET определяет, что будет
        // использоваться сеть для работы с сокетом
        hints.ai_socktype = SOCK_STREAM; // Задаем потоковый тип сокета
        hints.ai_protocol = IPPROTO_TCP; // Используем протокол TCP
        hints.ai_flags = AI_PASSIVE; // Сокет будет биндиться на адрес,
        // чтобы принимать входящие соединения

        // Инициализируем структуру, хранящую адрес сокета - addr
        // Наш HTTP-сервер будет висеть на 8000-м порту локалхоста
        result = getaddrinfo(sIP.c_str(), "80", &hints, &addr);

        // Создание сокета
        int listen_socket = socket(addr->ai_family, addr->ai_socktype,
            addr->ai_protocol);
        // Если создание сокета завершилось с ошибкой, выводим сообщение,
        // освобождаем память, выделенную под структуру addr,
        // выгружаем dll-библиотеку и закрываем программу


        // Привязываем сокет к IP-адресу
        result = bind(listen_socket, addr->ai_addr, (int)addr->ai_addrlen);



        // Инициализируем слушающий сокет
        listen(listen_socket, SOMAXCONN);



        const int max_client_buffer_size = 1024;
        char buf[max_client_buffer_size];
        int client_socket = INVALID_SOCKET;

        for (;;) {
            // Принимаем входящие соединения
            client_socket = accept(listen_socket, NULL, NULL);


            result = recv(client_socket, buf, max_client_buffer_size, 0);

            std::stringstream response; // сюда будет записываться ответ клиенту
            std::stringstream response_body; // тело ответа

 if (result > 0) {
                // Мы знаем фактический размер полученных данных, поэтому ставим метку конца строки
                // В буфере запроса.
                buf[result] = '\0';

                std::string file;

                std::string zp = buf;

                std::cout<<'\n'<<zp<<'\n';

                //напечатать ответ
                    response_body << "<title>Test C++ HTTP Server</title>\n"
                    << "<h1>Hello server C++</h1>\n"
                    << "<p>This is body of the test page...</p>\n";




                // Формируем весь ответ вместе с заголовками
                response << "HTTP/1.1 200 OK\r\n"
                    << "Version: HTTP/1.1\r\n"
                    << "Content-Type: text/html; charset=utf-8\r\n"
                    << "Content-Length: " << response_body.str().length()
                    << "\r\n\r\n"
                    << response_body.str();

                // Отправляем ответ клиенту с помощью функции send
                result = send(client_socket, response.str().c_str(),
                    response.str().length(), 0);

                // Закрываем соединение к клиентом
                closesocket(client_socket);
            }
        }

        // Убираем за собой
        closesocket(listen_socket);
        freeaddrinfo(addr);
        WSACleanup();
        return 0;
    }

程序在启动时会在控制台中显示 IP 地址，必须在浏览器中输入该地址。如果您在本地网络上并且程序获取网络连接的适配器的地址，无论是 Wi-Fi 还是有线，本地网络上的任何计算机都可以发送请求并接收响应从你的程序。有个不知道怎么修复的bug，有时候页面加载时间长，没有收到响应，但是如果重新加载，响应立马就来了。

c++
Martin Hope
Юрій Писанка
Asked: 2020-10-09 23:31:27 +0000 UTC
  • -1

我正在使用c ++ windows forms curl为具有网络的机器人开发应用程序我想从文本字段发送文本，但是当我将它简单地添加到请求（代码中的注释行）时，应用程序在请求时崩溃。

问题：如何转换字符以添加到查询中？

private: std::string  ToStringUS(String^ T) 
         {
             string url = "";
             marshal_context ^ context = gcnew marshal_context();
             const char* str55554 = context->marshal_as<const char*>(T);
             url += str55554; 
             delete context;
             return url;
         }



    string url = "http://";
    url += ToStringUS(this->textBox1->Text);
    url += "?dat=";
    //url += ToStringUS(this->richTextBox1->Text);
    this->richTextBox1->Text =gcnew String(URLget(url).c_str());




    private: string URLget(string url) 
             {


 //string url = "http://";
 buffer = "";
              //необходимые CURL объекты
CURLcode result;

//проверяем результат инициализации
if (curl)
{



      //задаем все необходимые опции
      //определяем, куда выводить ошибки
      curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, errorBuffer);

      //указываем прокси сервер
      //curl_easy_setopt(curl, CURLOPT_PROXY, "proxy:8080");
      //задаем опцию отображение заголовка страницы
      curl_easy_setopt(curl, CURLOPT_HEADER, 0);
      //указываем функцию обратного вызова для записи получаемых данных
      curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, writer);
      //указываем куда записывать принимаемые данные
      curl_easy_setopt(curl, CURLOPT_WRITEDATA, &buffer);


      //задаем опцию - получить страницу по адресу http://google.com
      curl_easy_setopt(curl, CURLOPT_URL,url);
      //запускаем выполнение задачи
      result = curl_easy_perform(curl);
      //проверяем успешность выполнения операции
      if (result == CURLE_OK)   
      {
          return buffer;
      }
      else
      {
          return "нет доступа к серверу";
      }
      //выводим полученные данные на стандартный вывод (консоль)         
      //else      
        //выводим сообщение об ошибке
        //text<< "Ошибка! " << errorBuffer << endl;     
}
else
     return "ошыбка curl";


             }
winforms
Martin Hope
Юрій Писанка
Asked: 2020-10-02 23:25:30 +0000 UTC
  • 2

尝试在 Windows 窗体 c++ 项目中使用 c++ curl 库

 CURL *curl;
    CURLcode result;
    //инициализируем curl
    curl = curl_easy_init();

错误开始就行了 curl = curl_easy_init();，好像lib没有连接。lib组件如何以windows形式连接？通过程序连接和项目设置没有帮助。视觉工作室 2010 C++

1>CurlFormTest.obj : 错误 LNK2031: 未能为“extern "C" enum CURLcode __clrcall curl_global_init(long)”创建 P 或 Invoke (?curl_global_init@@$$J0YM?AW4CURLcode@@J@Z); 元数据中缺少调用约定

1>CurlFormTest.obj : 错误 LNK2028: 未解析的令牌引用 (0A00001A) "extern "C" enum CURLcode __clrcall curl_global_init(long)" (?curl_global_init@@$$J0YM?AW4CURLcode@@J@Z) 在函数 "int __clrcall main (cli::array^)" (?main@@$$HYMHP$01AP$AAVString@System@@@Z)

当他们回答我的问题时，一切都解决了，但是当我再次遇到这样的问题时，我忘记了如何解决它并再次阅读答案，很难找到正确的设置，所以我决定做一个图形提示我和其他人，在这里。 在此处输入图像描述 设置 curl 作品后。注意 Debug 和 Ralase 需要单独设置。在我看来，最好立即选择realase

c++
Martin Hope
Юрій Писанка
Asked: 2020-08-21 07:08:08 +0000 UTC
  • 0

我正在尝试为自己创建一个用于存储和描绘 3D 模型的类，但这就是问题所在。我加载立方体，一切都井井有条，我加载另一个平面，立方体将被绘制而不是它。我关闭立方体平面的加载平面绘制我做错了什么？

class MeshT
{
public: 
    std::vector<int>vec1;
    int InS;
    int VerS;
    bool IStexture; //Чи має mesh текстуру
    GLuint texture; //Текстура
    GLuint VBO, VAO, EBO;  //створитии змінні для буферів
    string Log;
    MeshT(std::string urlV,std::string urlI)
    {
        IStexture = false;
    //====Просто считую всі цифри які є============ВЕРШИНИ
    GLfloat* a;
    int av;
    {
        std::vector<float>t;
        ifstream f(urlV.c_str());
        if(!f) {Log+="Error loading "; Log+=urlV.c_str(); Log+='\n'; return;}
        while (!f.eof()) {
          float n;
          f >> n;
          t.push_back(n);
        }
        f.close();
        a = new GLfloat[t.size()];
        int i = 0;
        while(i<t.size()) {a[i] = t[i]; i++;}
        av = t.size();
    }



    //====Просто считую всі цифри які є============ІНДЕКСИ
    int inv = 0;
    GLint* in;
    if(urlI.size() != 0)
    {
        {
            std::vector<GLint>t;
            ifstream f(urlI.c_str());
            if(!f) {Log+="Error loading "; Log+=urlI.c_str(); Log+='\n'; return;}
            while (!f.eof()) {
              GLint n;
              f >> n;
              t.push_back(n);
            }
            f.close();
            in = new GLint[t.size()];
            int i = 0;
            while(i<t.size()) {in[i] = t[i]; i++;}
            inv = t.size();
        }
    }








    InS = inv;
    VerS = av;

    //=================Якщо індекси присутні=================
    if(InS != 0)
    {
    glGenVertexArrays(1, &VAO); //Згенерувати буфер
    glGenBuffers(1, &VBO);
    glGenBuffers(1, &EBO);
    // Bind the Vertex Array Object first, then bind and set vertex buffer(s) and attribute pointer(s).
    glBindVertexArray(VAO);

    glBindBuffer(GL_ARRAY_BUFFER, VBO); //зв'язую наш буфер з Open GL
    glBufferData(GL_ARRAY_BUFFER,sizeof(GLfloat) * av, a, GL_STATIC_DRAW);  //Передати дані на відеокарту

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLint)*inv, in, GL_STATIC_DRAW);

    glEnableVertexAttribArray(0);
    glVertexAttribPointer(
        0,//Номер для шейдера
        3,//Розмір в одиницях
        GL_FLOAT, //Float
        GL_FALSE, //Нормалізація
        8*sizeof(float), //Крок
        (GLvoid*)0 //Змішення в буфері
        );

     glVertexAttribPointer(
        1,//Номер для шейдера
        3,//Розмір в одиницях
        GL_FLOAT, //Float
        GL_FALSE, //Нормалізація
        8*sizeof(float), //Крок
        (GLvoid*)(3*sizeof(float)) //Змішення в буфері
        );
        glEnableVertexAttribArray(1);


        glVertexAttribPointer(
        2,//Номер для шейдера
        2,//Розмір в одиницях
        GL_FLOAT, //Float
        GL_FALSE, //Нормалізація
        8*sizeof(float), //Крок
        (GLvoid*)(6*sizeof(float)) //Змішення в буфері
        );
        glEnableVertexAttribArray(2);



    glBindBuffer(GL_ARRAY_BUFFER, 0); // Note that this is allowed, the call to glVertexAttribPointer registered VBO as the currently bound vertex buffer object so afterwards we can safely unbind

    glBindVertexArray(0); // Unbind VAO (it's always a good thing to unbind any buffer/array to prevent strange bugs), remember: do NOT unbind the EBO, keep it bound to this VAO
    }
    else
    {

        {
             //GLfloat* vertices,int vs,GLint* indices,int is   
        glGenVertexArrays(1, &VAO); //Згенерувати буфер


        // Bind the Vertex Array Object first, then bind and set vertex buffer(s) and attribute pointer(s).
        glBindVertexArray(VAO);

        glBindBuffer(GL_ARRAY_BUFFER, VBO); //зв'язую наш буфер з Open GL
        glBufferData(GL_ARRAY_BUFFER,sizeof(GLfloat) * av, a, GL_STATIC_DRAW);  //Передати дані на відеокарту



           glEnableVertexAttribArray(0);
    glVertexAttribPointer(
        0,//Номер для шейдера
        3,//Розмір в одиницях
        GL_FLOAT, //Float
        GL_FALSE, //Нормалізація
        8*sizeof(float), //Крок
        (GLvoid*)0 //Змішення в буфері
        );

     glVertexAttribPointer(
        1,//Номер для шейдера
        3,//Розмір в одиницях
        GL_FLOAT, //Float
        GL_FALSE, //Нормалізація
        8*sizeof(float), //Крок
        (GLvoid*)(3*sizeof(float)) //Змішення в буфері
        );
        glEnableVertexAttribArray(1);


        glVertexAttribPointer(
        2,//Номер для шейдера
        2,//Розмір в одиницях
        GL_FLOAT, //Float
        GL_FALSE, //Нормалізація
        8*sizeof(float), //Крок
        (GLvoid*)(6*sizeof(float)) //Змішення в буфері
        );
        glEnableVertexAttribArray(2);




        glBindBuffer(GL_ARRAY_BUFFER, 0); // Note that this is allowed, the call to glVertexAttribPointer registered VBO as the currently bound vertex buffer object so afterwards we can safely unbind

        glBindVertexArray(0); // Unbind VAO (it's always a good thing to unbind any buffer/array to prevent strange bugs), remember: do NOT unbind the EBO, keep it bound to this VAO
        }

    }



    }


    void setTexture(GLuint t)
    {
        IStexture = true;
        texture = t;
    }

    void draw()
    {
        //IMEG
        if(IStexture)
        {
        glActiveTexture(GL_TEXTURE0);
        glBindTexture(GL_TEXTURE_2D, texture);
        }

        glBindVertexArray(VAO);
        glDrawElements(GL_TRIANGLES, InS, GL_UNSIGNED_INT, 0);
        glBindVertexArray(0);


        //glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (GLvoid*)0);
        glEnableVertexAttribArray(0);
    }

    ~MeshT()
    {
        // Properly de-allocate all resources once they've outlived their purpose
        glDeleteVertexArrays(1, &VAO);
        glDeleteBuffers(1, &VBO);
        glDeleteBuffers(1, &EBO);
    }
};

加载

ShaderL test("data\\shaders\\all\\test.vs","data\\shaders\\all\\test.frag");

    MeshT CUB("data\\mesh\\Cube.vertex","data\\mesh\\Cube.index");
CUB.setTexture(LoTe("data\\texture\\1.jpg"));
cout<<"CUB: "<<CUB.Log<<endl;


MeshT plane("data\\mesh\\plane.vertex","data\\mesh\\plane.index");
cout<<"PLANE: "<<plane.Log<<endl;
plane.setTexture(CUB.texture);

绘画

caM(camera,test.shaderProgram,Wi,Hei);

    //========================(4)
        {
                    TransformU Tra1;
                    Tra1.translate(0,0,0);
                    Tra1.rotate(0,timer,0);
                    CUB.draw();
                    Tra1.active("model",test.shaderProgram);
        }

        {
                    TransformU Tra1;
                    Tra1.translate(0,-3,0);
                    Tra1.scale(5);
                    plane.draw();
                    Tra1.active("model",test.shaderProgram);
        }

完整项目 679KB

c++