• osg + pbr（三）Pbr直射光，使用回调函数替代漫游器

    前面，用漫游器表示视点有些太笨重了，实际上也没有必要，用回调函数就可以了。

    class EyePointCallback : public osg::UniformCallback
    {
    public:
    EyePointCallback(osg::ref_ptrosg::Camera camera)
    {
    _camera = camera;
    }

    virtual void operator() (osg::Uniform* uniform, osg::NodeVisitor* nv)
{
	osg::Vec3 eye, center, up;
	_camera->getViewMatrixAsLookAt(eye, center, up);
	uniform->set(eye);
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    private:
    osg::ref_ptrosg::Camera _camera;
    };

    osg::ref_ptr camera = viewer->getCamera();
osg::ref_ptr camPosUniform = new osg::Uniform("camPos", osg::Vec3f(0, 0, 0));
camPosUniform->setUpdateCallback(new EyePointCallback(camera));

			stateset->addUniform(camPosUniform);

    • 1
    • 2
    • 3
    • 4
    • 5

    这里顺便把投影坐标系和摄像机坐标系的也加上，（暂时不用。）
    在这里插入图片描述
    代码如下：
    //通过Liblas读取.las文件，并在osg中显示出来,用shader，先在片元着色器指定使用绿色
    #include
    #include

    #include
    #include
    #include
    #include

    #include
    #include
    #include

    #include
    #include

    #include
    #include
    #include
    #include
    #include
    #include
    #include
    #include

    #include

    #include
    #include
    #include
    #include
    #include
    #include
    #include

    static const char * vertexShader_PBR =
    {
    “in vec3 aPos; \n”
    “in vec3 aNormal; \n”
    “varying vec3 WorldPos; \n”
    “varying vec3 Normal; \n”
    “uniform mat4 normalMatrix; \n”
    “uniform mat4 projection;\n”
    “uniform mat4 view;\n”
    “void main() \n”
    “{ \n”
    " WorldPos = aPos; \n"
    " Normal = vec3(normalMatrix * vec4(aNormal,1.0)); \n"
    " gl_Position = ftransform(); \n"
    //" gl_Position = projection * view * vec4(aPos,1.0); \n"
    “}\n”
    };

    static const char psShader_PBR =
    {
    “#version 330 core \n”
    “out vec4 FragColor; \n”
    “varying vec3 WorldPos; \n”
    “varying vec3 Normal; \n”
    “uniform vec3 albedo; \n”
    “uniform float metallic; \n”
    “uniform float roughness; \n”
    “uniform float ao; \n”
    “uniform vec3 lightPositions[4]; \n”
    “uniform vec3 lightColors[4]; \n”
    “uniform vec3 camPos; \n”
    “const float PI = 3.14159265359; \n”
    “float DistributionGGX(vec3 N, vec3 H, float roughness) \n”
    “{ \n”
    " float a = roughness    roughness; \n"
    " float a2 = aa; \n"
    " float NdotH = max(dot(N, H), 0.0); \n"
    " float NdotH2 = NdotH    NdotH; \n"
    " float nom = a2; \n"
    " float denom = (NdotH2 * (a2 - 1.0) + 1.0); \n"
    " denom = PI * denom * denom; \n"
    " return nom / denom; \n"
    “} \n”
    “float GeometrySchlickGGX(float NdotV, float roughness) \n”
    “{ \n”
    " float r = (roughness + 1.0); \n"
    " float k = (r*r) / 8.0; \n"
    " float nom = NdotV; \n"
    " float denom = NdotV * (1.0 - k) + k; \n"
    " return nom / denom; \n"
    “} \n”
    “float GeometrySmith(vec3 N, vec3 V, vec3 L, float roughness) \n”
    “{ \n”
    " float NdotV = max(dot(N, V), 0.0); \n"
    " float NdotL = max(dot(N, L), 0.0); \n"
    " float ggx2 = GeometrySchlickGGX(NdotV, roughness); \n"
    " float ggx1 = GeometrySchlickGGX(NdotL, roughness); \n"
    " return ggx1 * ggx2; \n"
    “} \n”
    “vec3 fresnelSchlick(float cosTheta, vec3 F0) \n”
    “{ \n”
    " return F0 + (1.0 - F0) * pow(clamp(1.0 - cosTheta, 0.0, 1.0), 5.0); \n"
    “} \n”
    “void main() \n”
    “{ \n”
    " vec3 N = normalize(Normal); \n"
    " vec3 V = normalize(camPos - WorldPos); \n"
    " vec3 F0 = vec3(0.04); \n"
    " F0 = mix(F0, albedo, metallic); \n"
    " vec3 Lo = vec3(0.0); \n"
    " for (int i = 0; i < 4; ++i) \n"
    " { \n"
    " vec3 L = normalize(lightPositions[i] - WorldPos); \n"
    " vec3 H = normalize(V + L); \n"
    " float distance = length(lightPositions[i] - WorldPos); \n"
    " float attenuation = 1.0 / (distance * distance); \n"
    " vec3 radiance = lightColors[i] * attenuation; \n"
    " float NDF = DistributionGGX(N, H, roughness); \n"
    " float G = GeometrySmith(N, V, L, roughness); \n"
    " vec3 F = fresnelSchlick(clamp(dot(H, V), 0.0, 1.0), F0); \n"
    " vec3 numerator = NDF * G * F; \n"
    " float denominator = 4.0 * max(dot(N, V), 0.0) * max(dot(N, L), 0.0) + 0.0001; \n"
    " vec3 specular = numerator / denominator; \n"
    " vec3 kS = F; \n"
    " vec3 kD = vec3(1.0) - kS; \n"
    " kD *= 1.0 - metallic; \n"
    " float NdotL = max(dot(N, L), 0.0); \n"
    " Lo += (kD * albedo / PI + specular) * radiance * NdotL; \n"
    " } \n"
    " vec3 ambient = vec3(0.03) * albedo * ao; \n"
    " vec3 color = ambient + Lo; \n"
    " color = color / (color + vec3(1.0)); \n"
    " color = pow(color, vec3(1.0 / 2.2)); \n"
    " FragColor = vec4(color, 1.0); \n"
    //" FragColor = vec4(1.0,0.0,0.0, 1.0); \n"
    “} \n”
    };

    osg::ref_ptrosg::Geode CreateSphereGeode()
    {
    osg::ref_ptrosg::Geode geode = new osg::Geode;
    osg::ref_ptrosg::Vec3Array vertices = new osg::Vec3Array(6);
    (*vertices)[0].set(0.0f, 0.0f, 1.0f);
    (*vertices)[1].set(-0.5f, -0.5f, 0.0f);
    (*vertices)[2].set(0.5f, -0.5f, 0.0f);
    (*vertices)[3].set(0.5f, 0.5f, 0.0f);
    (*vertices)[4].set(-0.5f, 0.5f, 0.0f);
    (*vertices)[5].set(0.0f, 0.0f, -1.0f);
    osg::ref_ptrosg::DrawElementsUInt indices = new osg::DrawElementsUInt(GL_TRIANGLES, 24);
    (*indices)[0] = 0; (*indices)[1] = 1; (*indices)[2] = 2;
    (*indices)[3] = 0; (*indices)[4] = 2; (*indices)[5] = 3;
    (*indices)[6] = 0; (*indices)[7] = 3; (*indices)[8] = 4;
    (*indices)[9] = 0; (*indices)[10] = 4; (*indices)[11] = 1;
    (*indices)[12] = 5; (*indices)[13] = 2; (*indices)[14] = 1;
    (*indices)[15] = 5; (*indices)[16] = 3; (*indices)[17] = 2;
    (*indices)[18] = 5; (*indices)[19] = 4; (*indices)[20] = 3;
    (*indices)[21] = 5; (*indices)[22] = 1; (*indices)[23] = 4;
    osg::ref_ptrosg::Geometry geom = new osg::Geometry;
    geom->setVertexArray(vertices.get());
    geom->addPrimitiveSet(indices.get());
    osgUtil::SmoothingVisitor::smooth(*geom);
    geode->addDrawable(geom);
    return geode;

    }

    osg::ref_ptrosg::Geode renderSphere(osg::Vec3f pos)
    {
    osg::ref_ptrosg::Geode geode = new osg::Geode;
    const unsigned int X_SEGMENTS = 64;
    const unsigned int Y_SEGMENTS = 64;
    const float PI = 3.14159265359f;
    osg::ref_ptrosg::Vec3Array vertices = new osg::Vec3Array;
    osg::ref_ptrosg::Vec3Array normalArray = new osg::Vec3Array;
    for (unsigned int x = 0; x <= X_SEGMENTS; ++x)
    {
    for (unsigned int y = 0; y <= Y_SEGMENTS; ++y)
    {
    float xSegment = (float)x / (float)X_SEGMENTS;
    float ySegment = (float)y / (float)Y_SEGMENTS;
    float xPos = std::cos(xSegment * 2.0f * PI) * std::sin(ySegment * PI);
    float yPos = std::cos(ySegment * PI);
    float zPos = std::sin(xSegment * 2.0f * PI) * std::sin(ySegment * PI);

    		vertices->push_back(osg::Vec3(xPos, yPos, zPos) + pos);
		normalArray->push_back(osg::Vec3(xPos, yPos, zPos));
	}
}
osg::ref_ptr indices = new osg::DrawElementsUInt();
bool oddRow = false;
for (unsigned int y = 0; y < Y_SEGMENTS; ++y)
{
	if (!oddRow) // even rows: y == 0, y == 2; and so on
	{
		for (unsigned int x = 0; x <= X_SEGMENTS; ++x)
		{
			indices->push_back(y       * (X_SEGMENTS + 1) + x);
			indices->push_back((y + 1) * (X_SEGMENTS + 1) + x);
		}
	}
	else
	{
		for (int x = X_SEGMENTS; x >= 0; --x)
		{
			indices->push_back((y + 1) * (X_SEGMENTS + 1) + x);
			indices->push_back(y       * (X_SEGMENTS + 1) + x);
		}
	}
	oddRow = !oddRow;
}
int indexCount = static_cast(indices->size());
indices->setMode(GL_TRIANGLE_STRIP);

osg::ref_ptr geom = new osg::Geometry;
geom->setVertexArray(vertices.get());
geom->addPrimitiveSet(indices.get());
geom->setNormalArray(normalArray, osg::Array::BIND_PER_VERTEX);

geom->setVertexAttribArray(1, vertices, osg::Array::BIND_PER_VERTEX);
geom->setVertexAttribArray(2, normalArray, osg::Array::BIND_PER_VERTEX);

//osgUtil::SmoothingVisitor::smooth(*geom);
geode->addDrawable(geom);
return geode;

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40

    }

    class EyePointCallback : public osg::UniformCallback
    {
    public:
    EyePointCallback(osg::ref_ptrosg::Camera camera)
    {
    _camera = camera;
    }

    virtual void operator() (osg::Uniform* uniform, osg::NodeVisitor* nv)
{
	osg::Vec3 eye, center, up;
	_camera->getViewMatrixAsLookAt(eye, center, up);
	uniform->set(eye);
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    private:
    osg::ref_ptrosg::Camera _camera;
    };

    class ProjectMatrixCallback : public osg::UniformCallback
    {
    public:
    ProjectMatrixCallback(osg::ref_ptrosg::Camera camera)
    {
    _camera = camera;
    }

    virtual void operator() (osg::Uniform* uniform, osg::NodeVisitor* nv)
{
	osg::Matrix projectionMatrix = _camera->getProjectionMatrix();
	uniform->set(projectionMatrix);
}

    • 1
    • 2
    • 3
    • 4
    • 5

    private:
    osg::ref_ptrosg::Camera _camera;
    };
    class ViewMatrixCallback : public osg::UniformCallback
    {
    public:
    ViewMatrixCallback(osg::ref_ptrosg::Camera camera)
    {
    _camera = camera;
    }

    virtual void operator() (osg::Uniform* uniform, osg::NodeVisitor* nv)
{
	osg::Matrix viewMatrix = _camera->getViewMatrix();
	uniform->set(viewMatrix);
}

    • 1
    • 2
    • 3
    • 4
    • 5

    private:
    osg::ref_ptrosg::Camera _camera;
    };
    int main()
    {

    osg::ref_ptr viewer = new osgViewer::Viewer;

osg::ref_ptr camera = viewer->getCamera();
osg::ref_ptr camPosUniform = new osg::Uniform("camPos", osg::Vec3f(0, 0, 0));
camPosUniform->setUpdateCallback(new EyePointCallback(camera));

osg::Matrix viewMatrix = camera->getViewMatrix();
osg::Matrix projMatrix = camera->getProjectionMatrix();
osg::Vec3f eye, center, up;
camera->getViewMatrixAsLookAt(eye, center, up);

//osg::ref_ptr camPosUniform = new osg::Uniform("camPos", eye);
osg::ref_ptr viewMatrixUniform = new osg::Uniform("view", viewMatrix);
viewMatrixUniform->setUpdateCallback(new ViewMatrixCallback(camera));
osg::ref_ptr projMatrixUniform = new osg::Uniform("projection",projMatrix);
projMatrixUniform->setUpdateCallback(new ProjectMatrixCallback(camera));
osg::ref_ptr grp = new osg::Group;
//漫反射比率
osg::Vec3f albedo(0.5f, 0.0f, 0.0f);
osg::ref_ptr albedoUniform = new osg::Uniform("albedo", albedo);
float ao = 1.0f;
osg::ref_ptr aoUniform = new osg::Uniform("ao", ao);

int nrRows = 7;
int nrColumns = 7;
float spacing = 2.5;
float ballRadius = 1.0f;

osg::ref_ptr lightColors = new osg::Vec3Array;
lightColors->push_back(osg::Vec3(300.0f, 300.0f, 300.0f));
lightColors->push_back(osg::Vec3(300.0f, 300.0f, 300.0f));
lightColors->push_back(osg::Vec3(300.0f, 300.0f, 300.0f));
lightColors->push_back(osg::Vec3(300.0f, 300.0f, 300.0f));

osg::ref_ptr lightColorsUniform = new osg::Uniform(osg::Uniform::FLOAT_VEC3, "lightColors", lightColors->size());
for (int i = 0; i < lightColors->size(); i++)
{
	lightColorsUniform->setElement(i, lightColors->at(i));
}
osg::ref_ptr lightPositions = new osg::Vec3Array;
lightPositions->push_back(osg::Vec3(-10.0f, 10.0f, 10.0f));
lightPositions->push_back(osg::Vec3(10.0f, 10.0f, 10.0f));
lightPositions->push_back(osg::Vec3(-10.0f, -10.0f, 10.0f));
lightPositions->push_back(osg::Vec3(10.0f, -10.0f, 10.0f));

osg::ref_ptr lightPositionsUniform = new osg::Uniform(osg::Uniform::FLOAT_VEC3, "lightPositions", lightPositions->size());
for (int i = 0; i < lightPositions->size(); i++)
{
	lightPositionsUniform->setElement(i, lightPositions->at(i));
}
for (int row = 0; row < nrRows; row++)
{
	float metallic = row * 1.0 / nrRows;
	for (int col = 0; col < nrColumns; col++)
	{
		float roughness = col * 1.0 / nrColumns;
		if (roughness <0.05)
		{
			roughness = 0.05;
		}
		if (roughness > 1.0)
		{
			roughness = 1.0;
		}
		osg::Vec3 ballCenter(
			(col - (nrColumns / 2)) * spacing,
			(row - (nrRows / 2)) * spacing,
			0.0f);
		osg::Matrix worldMatrix = osg::Matrix::translate(ballCenter);

		osg::Matrix inverse;
		inverse.invert(worldMatrix);
		osg::Matrix transPose;
		transPose.transpose(inverse);
		osg::ref_ptr geode = renderSphere(ballCenter);
		{
			osg::ref_ptr stateset = geode->getOrCreateStateSet();
			osg::ref_ptr vs = new osg::Shader(osg::Shader::VERTEX, vertexShader_PBR);
			osg::ref_ptr ps = new osg::Shader(osg::Shader::FRAGMENT, psShader_PBR);
			osg::ref_ptr program = new osg::Program;
			program->addBindAttribLocation("aPos", 1);
			program->addBindAttribLocation("aNormal", 2);
			program->addShader(vs);
			program->addShader(ps);

			osg::ref_ptr metallicUniform = new osg::Uniform("metallic", metallic);
			osg::ref_ptr roughnessUniform = new osg::Uniform("roughness", roughness);
			//osg::ref_ptr transposeInverseMatrixUniform = new osg::Uniform("normalMatrix", transPose);

			osg::Uniform* transposeInverseMatrixUniform = stateset->getOrCreateUniform("normalMatrix", osg::Uniform::FLOAT_MAT4);
			transposeInverseMatrixUniform->set(transPose);
			stateset->addUniform(albedoUniform);
			stateset->addUniform(metallicUniform);
			stateset->addUniform(roughnessUniform);
			stateset->addUniform(aoUniform);
			stateset->addUniform(lightPositionsUniform);
			stateset->addUniform(lightColorsUniform);
			stateset->addUniform(transposeInverseMatrixUniform);
			stateset->addUniform(viewMatrixUniform);
			stateset->addUniform(projMatrixUniform);
			stateset->addUniform(camPosUniform);
			stateset->setAttribute(program, osg::StateAttribute::ON);
		}
		grp->addChild(geode);
	}

}
grp->addChild(renderSphere(osg::Vec3(-10.0f, 10.0f, 10.0f)));
grp->addChild(renderSphere(osg::Vec3(10.0f, 10.0f, 10.0f)));
grp->addChild(renderSphere(osg::Vec3(-10.0f, -10.0f, 10.0f)));
grp->addChild(renderSphere(osg::Vec3(10.0f, -10.0f, 10.0f)));

viewer->getCamera()->setClearColor(osg::Vec4(0.1f, 0.1f, 0.1f, 1.0f));
viewer->setSceneData(grp);
viewer->run();

return 0;

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117

    }

  • 相关阅读:
    【HTML】标签学习（下.3）
    基于Fuzzing和ChatGPT结合的AI自动化测试实践分享
    蓝牙核心规范（V5.4）11.2-LE Audio 笔记之LE Auido架构
    GCC
    已更新！c++第四章知识点合集（自定义函数的格式和使用方法详解， #include，函数的嵌套 递归，局部变量与全局变量的区别等等）
    springcloud_2021.0.3学习笔记：通过spring-cloud-stream实现消息队列rabbitmq的消息生产和消费
    Leetcode算法入门与数组丨1. 数据结构与算法简介
    中台架构介绍和应用价值
    毕业季 | 华为专家亲授面试秘诀：如何拿到大厂高薪offer？
    C#中抽象类、抽象方法和接口暨内联临时变量的精彩表达
  • 原文地址：https://blog.csdn.net/directx3d_beginner/article/details/133094289