十八，镜面IBL-打印预过滤环境贴图

最新推荐文章于 2023-09-28 17:23:17 发布
最新推荐文章于 2023-09-28 17:23:17 发布
阅读量133 收藏
点赞数
分类专栏： osg+pbr 文章标签： osg
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/directx3d_beginner/article/details/133383831
版权

前面打印了各个级别的hdr环境贴图，也能看到预过滤环境贴图，现在进行打印各个级别的预过滤环境贴图。

运行结果如下
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
代码如下：
#include <osg/TextureCubeMap>
#include <osg/TexGen>
#include <osg/TexEnvCombine>
#include <osgUtil/ReflectionMapGenerator>
#include <osgDB/ReadFile>
#include <osgViewer/Viewer>
#include <osg/NodeVisitor>
#include <osg/ShapeDrawable>
#include <osgGA/TrackballManipulator>
#include <osgDB/WriteFile>

static const char * vertexShader =
{
//“#version 120 core\n”
“in vec3 aPos;\n”
“varying vec3 localPos;\n”
“void main(void)\n”
“{\n”
“localPos = aPos;\n”
" gl_Position = ftransform();\n"
//“gl_Position = view * view * vec4(aPos,1.0);”
“}\n”
};

static const char psShader =
{
“varying vec3 localPos;\n”
“uniform samplerCube environmentMap;”
“uniform float roughness;”
“const float PI = 3.1415926;”
“float VanDerCorpus(uint n, uint base) "
“{ "
" float invBase = 1.0 / float(base); "
" float denom = 1.0; "
" float result = 0.0; "
" for (uint i = 0u; i < 32u; ++i) "
" { "
" if (n > 0u) "
" { "
" denom = mod(float(n), 2.0); "
" result += denom * invBase; "
" invBase = invBase / 2.0; "
" n = uint(float(n) / 2.0); "
" } "
" } "
“return result; "
“} "
" "
“vec2 HammersleyNoBitOps(uint i, uint N) "
“{ "
" return vec2(float(i) / float(N), VanDerCorpus(i, 2u)); "
“} "
//“float RadicalInverse_Vdc(uint bits)\n”
//”{”
//“bits = (bits << 16u) | (bits >> 16u);”
//“bits = ((bits & 0x55555555u) << 1u ) | (bits & 0xAAAAAAAAu) >> 1u);”
//“bits = ((bits & 0x33333333u) << 2u ) | (bits & 0xCCCCCCCCu) >> 2u);”
//“bits = ((bits & 0x0F0F0F0Fu) << 4u ) | (bits & 0xF0F0F0F0u) >> 4u);”
//“bits = ((bits & 0x00FF00FFu) << 8u ) | (bits & 0xFF00FF00u) >> 8u);”
//“return float(bits) * 2.3283064365386963e-10;”
//”}”
//“vec2 Hammersley(uint i, uint N)”
//”{”
//“return vec2(float(i) / float(N), RadicalInverse_Vdc(i));”
//”}"
“vec3 ImportanceSampleGGX(vec2 Xi, vec3 N, float roughness)”
“{”
“float a = roughness * roughness;”
“float phi = 2.0 * PI * Xi.x;”
"float cosTheta = sqrt((1.0 - Xi.y)/(1.0+(aa-1.0) * Xi.y));"
“float sinTheta = sqrt(1.0 - cosTheta * cosTheta);”
“vec3 H;”
“H.x = cos(phi) * sinTheta;”
“H.y = sin(phi) * sinTheta;”
“H.z = cosTheta;”
“vec3 up = abs(N.z) < 0.999 ? vec3(0.0,0.0,1.0) : vec3(1.0,0.0,0.0);”
“vec3 tangent = normalize(cross(up,N));”
“vec3 bitangent = cross(N,tangent);”
“vec3 sampleVec = tangent * H.x + bitangent * H.y + N * H.z;”
“return normalize(sampleVec);”
“}”
"void main() "
"{ "
" vec3 N = normalize(localPos); "
" vec3 R = N; "
" vec3 V = R; "
" "
" const uint SAMPLE_COUNT = 1024u; "
" float totalWeight = 0.0; "
" vec3 prefilteredColor = vec3(0.0); "
" for (uint i = 0u; i < SAMPLE_COUNT; ++i) "
" { "
" vec2 Xi = HammersleyNoBitOps(i, SAMPLE_COUNT); "
" vec3 H = ImportanceSampleGGX(Xi, N, roughness); "
" vec3 L = normalize(2.0 * dot(V, H) * H - V); "
" "
" float NdotL = max(dot(N, L), 0.0); "
" if (NdotL > 0.0) "
" { "
" prefilteredColor += texture(environmentMap, L).rgb * NdotL; "
" totalWeight += NdotL; "
" } "
" } "
" prefilteredColor = prefilteredColor / totalWeight; "
" "
" gl_FragColor = vec4(prefilteredColor, 1.0); "
"} "
};
class MyNodeVisitor : public osg::NodeVisitor
{
public:
MyNodeVisitor() : osg::NodeVisitor(osg::NodeVisitor::TRAVERSE_ALL_CHILDREN)
{

}
void apply(osg::Geode& geode)
{
	int count = geode.getNumDrawables();
	for (int i = 0; i < count; i++)
	{
		osg::ref_ptr<osg::Geometry> geometry = geode.getDrawable(i)->asGeometry();
		if (!geometry.valid())
		{
			continue;
		}
		osg::Array* vertexArray = geometry->getVertexArray();
		geometry->setVertexAttribArray(1, vertexArray);

	}
	traverse(geode);
}

};

osg::ref_ptrosg::TextureCubeMap getTextureCubeMap(osgViewer::Viewer& viewer,
int textureWidth,
int textureHeight)
{
unsigned int screenWidth, screenHeight;
osg::GraphicsContext::WindowingSystemInterface * wsInterface = osg::GraphicsContext::getWindowingSystemInterface();
wsInterface->getScreenResolution(osg::GraphicsContext::ScreenIdentifier(0), screenWidth, screenHeight);

osg::ref_ptr<osg::GraphicsContext::Traits> traits = new osg::GraphicsContext::Traits;
traits->x = 0;
traits->y = 0;
traits->width = screenWidth;
traits->height = screenHeight;
traits->windowDecoration = false;
traits->doubleBuffer = true;
traits->sharedContext = 0;
traits->readDISPLAY();
traits->setUndefinedScreenDetailsToDefaultScreen();

osg::ref_ptr<osg::GraphicsContext> gc = osg::GraphicsContext::createGraphicsContext(traits.get());
if (!gc)
{
	osg::notify(osg::NOTICE) << "GraphicsWindow has not been created successfully." << std::endl;
	return NULL;
}


osg::ref_ptr<osg::TextureCubeMap> texture = new osg::TextureCubeMap;

texture->setTextureSize(textureWidth, textureHeight);
texture->setInternalFormat(GL_RGB);
texture->setFilter(osg::Texture::MIN_FILTER, osg::Texture::LINEAR);
texture->setFilter(osg::Texture::MAG_FILTER, osg::Texture::LINEAR);
texture->setWrap(osg::Texture::WRAP_S, osg::Texture::CLAMP_TO_EDGE);
texture->setWrap(osg::Texture::WRAP_T, osg::Texture::CLAMP_TO_EDGE);
texture->setWrap(osg::Texture::WRAP_R, osg::Texture::CLAMP_TO_EDGE);

osg::Camera::RenderTargetImplementation renderTargetImplementation = osg::Camera::FRAME_BUFFER_OBJECT;
// front face
{

	osg::ref_ptr<osg::Camera> camera = new osg::Camera;
	camera->setName("Front face camera");
	camera->setGraphicsContext(gc.get());
	camera->setViewport(new osg::Viewport(0, 0, textureWidth, textureHeight));
	camera->setAllowEventFocus(false);
	camera->setRenderTargetImplementation(renderTargetImplementation);
	camera->setRenderOrder(osg::Camera::PRE_RENDER);
	//关联采样贴图
	camera->attach(osg::Camera::COLOR_BUFFER, texture, 0, osg::TextureCubeMap::POSITIVE_Y);

	osg::ref_ptr<osg::Image> printImage = new osg::Image;
	printImage->setFileName(camera->getName());
	printImage->allocateImage(textureWidth, textureHeight, 1, GL_RGBA, GL_UNSIGNED_BYTE);
	texture->setImage(0, printImage);
	camera->attach(osg::Camera::COLOR_BUFFER, printImage);
	viewer.addSlave(camera.get(), osg::Matrixd(), osg::Matrixd());
}


// top face
{
	osg::ref_ptr<osg::Camera> camera = new osg::Camera;
	camera->setName("Top face camera");
	camera->setGraphicsContext(gc.get());
	camera->setViewport(new osg::Viewport(0, 0, textureWidth, textureHeight));
	camera->setAllowEventFocus(false);
	camera->setRenderTargetImplementation(renderTargetImplementation);
	camera->setRenderOrder(osg::Camera::PRE_RENDER);
	//关联采样贴图
	camera->attach(osg::Camera::COLOR_BUFFER, texture, 0, osg::TextureCubeMap::POSITIVE_Z);
	osg::ref_ptr<osg::Image> printImage = new osg::Image;
	printImage->setFileName(camera->getName());
	printImage->allocateImage(textureWidth, textureHeight, 1, GL_RGBA, GL_UNSIGNED_BYTE);
	texture->setImage(1, printImage);
	camera->attach(osg::Camera::COLOR_BUFFER, printImage);
	viewer.addSlave(camera.get(), osg::Matrixd(), osg::Matrixd::rotate(osg::inDegrees(-90.0f), 1.0, 0.0, 0.0));
}

// left face
{
	osg::ref_ptr<osg::Camera> camera = new osg::Camera;
	camera->setName("Left face camera");
	camera->setGraphicsContext(gc.get());
	camera->setViewport(new osg::Viewport(0, 0, textureWidth, textureHeight));
	camera->setAllowEventFocus(false);
	camera->setRenderTargetImplementation(renderTargetImplementation);
	camera->setRenderOrder(osg::Camera::PRE_RENDER);
	//关联采样贴图
	camera->attach(osg::Camera::COLOR_BUFFER, texture, 0, osg::TextureCubeMap::NEGATIVE_X);
	osg::ref_ptr<osg::Image> printImage = new osg::Image;
	printImage->setFileName(camera->getName());
	printImage->allocateImage(textureWidth, textureHeight, 1, GL_RGBA, GL_UNSIGNED_BYTE);
	texture->setImage(2, printImage);
	camera->attach(osg::Camera::COLOR_BUFFER, printImage);
	viewer.addSlave(camera.get(), osg::Matrixd(), osg::Matrixd::rotate(osg::inDegrees(-90.0f), 0.0, 1.0, 0.0) * osg::Matrixd::rotate(osg::inDegrees(-90.0f), 0.0, 0.0, 1.0));
}

// right face
{
	osg::ref_ptr<osg::Camera> camera = new osg::Camera;
	camera->setName("Right face camera");
	camera->setGraphicsContext(gc.get());
	camera->setViewport(new osg::Viewport(0, 0, textureWidth, textureHeight));
	camera->setAllowEventFocus(false);
	camera->setRenderTargetImplementation(renderTargetImplementation);
	camera->setRenderOrder(osg::Camera::PRE_RENDER);
	//关联采样贴图
	camera->attach(osg::Camera::COLOR_BUFFER, texture, 0, osg::TextureCubeMap::POSITIVE_X);
	osg::ref_ptr<osg::Image> printImage = new osg::Image;
	printImage->setFileName(camera->getName());
	printImage->allocateImage(textureWidth, textureHeight, 1, GL_RGBA, GL_UNSIGNED_BYTE);
	texture->setImage(3, printImage);
	camera->attach(osg::Camera::COLOR_BUFFER, printImage);
	viewer.addSlave(camera.get(), osg::Matrixd(), osg::Matrixd::rotate(osg::inDegrees(90.0f), 0.0, 1.0, 0.0) * osg::Matrixd::rotate(osg::inDegrees(90.0f), 0.0, 0.0, 1.0));

}

// bottom face
{
	osg::ref_ptr<osg::Camera> camera = new osg::Camera;
	camera->setGraphicsContext(gc.get());
	camera->setName("Bottom face camera");
	camera->setViewport(new osg::Viewport(0, 0, textureWidth, textureHeight));
	camera->setAllowEventFocus(false);
	camera->setRenderTargetImplementation(renderTargetImplementation);
	camera->setRenderOrder(osg::Camera::PRE_RENDER);
	//关联采样贴图
	camera->attach(osg::Camera::COLOR_BUFFER, texture, 0, osg::TextureCubeMap::NEGATIVE_Z);
	osg::ref_ptr<osg::Image> printImage = new osg::Image;
	printImage->setFileName(camera->getName());
	printImage->allocateImage(textureWidth, textureHeight, 1, GL_RGBA, GL_UNSIGNED_BYTE);
	texture->setImage(4, printImage);
	camera->attach(osg::Camera::COLOR_BUFFER, printImage);
	viewer.addSlave(camera.get(), osg::Matrixd(), osg::Matrixd::rotate(osg::inDegrees(90.0f), 1.0, 0.0, 0.0) * osg::Matrixd::rotate(osg::inDegrees(180.0f), 0.0, 0.0, 1.0));

}

// back face
{
	osg::ref_ptr<osg::Camera> camera = new osg::Camera;
	camera->setName("Back face camera");
	camera->setGraphicsContext(gc.get());
	camera->setViewport(new osg::Viewport(0, 0, textureWidth, textureHeight));
	camera->setAllowEventFocus(false);
	camera->setRenderTargetImplementation(renderTargetImplementation);
	camera->setRenderOrder(osg::Camera::PRE_RENDER);
	//关联采样贴图
	camera->attach(osg::Camera::COLOR_BUFFER, texture, 0, osg::TextureCubeMap::NEGATIVE_Y);
	osg::ref_ptr<osg::Image> printImage = new osg::Image;
	printImage->setFileName(camera->getName());
	printImage->allocateImage(textureWidth, textureHeight, 1, GL_RGBA, GL_UNSIGNED_BYTE);
	texture->setImage(5, printImage);
	camera->attach(osg::Camera::COLOR_BUFFER, printImage);
	viewer.addSlave(camera.get(), osg::Matrixd(), osg::Matrixd::rotate(osg::inDegrees(180.0f), 1.0, 0.0, 0.0));

}

viewer.getCamera()->setProjectionMatrixAsPerspective(90.0f, 1.0, 0.1, 10);



//viewer.getCamera()->setNearFarRatio(0.0001f);
return texture;

}

int main()
{
int level = 0; //0,1,2,3,4
int maxLevel = 4;
float roughness = level * 1.0 / maxLevel;

int textureWidth = 128;
int textureHeight = 128;
float ratio = std::pow(0.5, level);
int mipWidth = textureWidth * ratio;
int mipHeight = textureHeight * ratio;
std::string strDir = "e:/hdr/lod/" + std::to_string(level) + "/";

osg::ref_ptr<osg::TextureCubeMap> tcm = new osg::TextureCubeMap;
tcm->setFilter(osg::Texture::MIN_FILTER, osg::Texture::LINEAR);
tcm->setFilter(osg::Texture::MAG_FILTER, osg::Texture::LINEAR);
tcm->setWrap(osg::Texture::WRAP_S, osg::Texture::CLAMP_TO_EDGE);
tcm->setWrap(osg::Texture::WRAP_T, osg::Texture::CLAMP_TO_EDGE);
tcm->setWrap(osg::Texture::WRAP_R, osg::Texture::CLAMP_TO_EDGE);

std::string strImagePosX = strDir + "Right face camera.bmp";
osg::ref_ptr<osg::Image> imagePosX = osgDB::readImageFile(strImagePosX);
tcm->setImage(osg::TextureCubeMap::POSITIVE_X, imagePosX);
std::string strImageNegX = strDir + "Left face camera.bmp";
osg::ref_ptr<osg::Image> imageNegX = osgDB::readImageFile(strImageNegX);
tcm->setImage(osg::TextureCubeMap::NEGATIVE_X, imageNegX);

std::string strImagePosY = strDir + "Front face camera.bmp";;
osg::ref_ptr<osg::Image> imagePosY = osgDB::readImageFile(strImagePosY);
tcm->setImage(osg::TextureCubeMap::POSITIVE_Y, imagePosY);
std::string strImageNegY = strDir + "Back face camera.bmp";;
osg::ref_ptr<osg::Image> imageNegY = osgDB::readImageFile(strImageNegY);
tcm->setImage(osg::TextureCubeMap::NEGATIVE_Y, imageNegY);

std::string strImagePosZ = strDir + "Top face camera.bmp";
osg::ref_ptr<osg::Image> imagePosZ = osgDB::readImageFile(strImagePosZ);
tcm->setImage(osg::TextureCubeMap::POSITIVE_Z, imagePosZ);
std::string strImageNegZ = strDir + "Bottom face camera.bmp";
osg::ref_ptr<osg::Image> imageNegZ = osgDB::readImageFile(strImageNegZ);
tcm->setImage(osg::TextureCubeMap::NEGATIVE_Z, imageNegZ);

osg::ref_ptr<osg::Box> box = new osg::Box(osg::Vec3(0, 0, 0), 1);
osg::ref_ptr<osg::ShapeDrawable> drawable = new osg::ShapeDrawable(box);
osg::ref_ptr<osg::Geode> geode = new osg::Geode;
geode->addDrawable(drawable);
MyNodeVisitor nv;
geode->accept(nv);
osg::ref_ptr<osg::StateSet> stateset = geode->getOrCreateStateSet();
stateset->setTextureAttributeAndModes(0, tcm, osg::StateAttribute::OVERRIDE | osg::StateAttribute::ON);

//shader

osg::ref_ptr<osg::Shader> vs1 = new osg::Shader(osg::Shader::VERTEX, vertexShader);
osg::ref_ptr<osg::Shader> ps1 = new osg::Shader(osg::Shader::FRAGMENT, psShader);
osg::ref_ptr<osg::Program> program1 = new osg::Program;
program1->addShader(vs1);
program1->addShader(ps1);
program1->addBindAttribLocation("aPos", 1);

osg::ref_ptr<osg::Uniform> tex0Uniform = new osg::Uniform("environmentMap", 0);
stateset->addUniform(tex0Uniform);
osg::ref_ptr<osg::Uniform> roughnessUniform = new osg::Uniform("roughness", roughness);
stateset->addUniform(roughnessUniform);
stateset->setAttribute(program1, osg::StateAttribute::ON);

osgViewer::Viewer viewer;
osg::ref_ptr<osgGA::TrackballManipulator> manipulator = new osgGA::TrackballManipulator();
viewer.setCameraManipulator(manipulator);
osg::Vec3d newEye(0, 0, 0);
osg::Vec3 newCenter(0, 0, 0);
osg::Vec3 newUp(0, 1, 0);
manipulator->setHomePosition(newEye, newCenter, newUp);
osg::ref_ptr<osg::TextureCubeMap> textureCubeMap = getTextureCubeMap(viewer, mipWidth, mipHeight);
viewer.setSceneData(geode.get());

bool bPrinted = false;
while (!viewer.done())
{
	viewer.frame();
	if (!bPrinted)
	{
		bPrinted = true;
		int imageNumber = textureCubeMap->getNumImages();
		for (int i = 0; i < imageNumber; i++)
		{

			osg::ref_ptr<osg::Image> theImage = textureCubeMap->getImage(i);
			std::string strPrintName = "e:/hdr/Prefilter/" + std::to_string(level) + "/" + theImage->getFileName() + ".bmp";
			osgDB::writeImageFile(*theImage, strPrintName);
		}
	}
}
return 0;

}

directx3d_beginner
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ibl-converter:用于 PBR 的 IBL 地图转换器
05-29
使用它可以将不同的环境贴图转换为 PBR 渲染所需的格式。概述拖放 equirectangular 环境贴图以生成两个必要的纹理，以将基于图像的照明添加到 PBR 着色器。 用于着色器，但可以插入任何框架。支持的输入类型： .hdr...
IBL-镜面反射（预滤波篇）
Elsa的迷弟
04-12 611
由于我们在卷积环境贴图时事先不知道视角方向，因此 Epic Games 假设视角方向——也就是镜面反射方向——总是等于输出采样方向ωo，以作进一步近似。OpenGL 可以启用 GL_TEXTURE_CUBE_MAP_SEAMLESS，以为我们提供在立方体贴图的面之间进行正确过滤的选项。我们已经进行了大量的采样，但是在某些环境下，在某些较粗糙的 mip 级别上可能仍然不够，导致明亮区域周围出现点状图案。这样确实得到了一定程度的近似，尤其在正对物体法线时的高光效果会接近真实。观察1-7的分布，可以看到为。
osgPBR(十五）镜面IBL--查看不同级别的HDR环境贴图
coder
09-27 933
首先，设置可以使用Mipmap，启用三线性过滤，设置最大级别和最小级别。然后在shader中，用textureLod分别查看各个级别。
IBL-镜面反射（LUT篇）
Elsa的迷弟
04-25 295
首先我们将镜面反射部分的积分分割为两个部分。Lo​pωo​∫Ω​Li​pωi​dωi​∗∫Ω​fr​pωi​ωo​n⋅ωi​dωi​的积分即为预滤波，将所有照到该像素点的光照求积分。∫Ω​Li​pωi​dωi​需要我们知道，这个半球的光线照过来之后，有多少反射到了ωi​所在的方向。LUT求解的便是，在夹角cosθN⋅ωi​，粗糙度为roughness下，BRD。
十九，镜面IBL--BRDF积分贴图
coder
09-28 484
再看函数vec2 IntegrateBRDF(float NdotV, float roughness) ，可知积分贴图的横坐标是NotV,纵坐标是粗糙度。类似于预过滤环境贴图，也是通过低差异序列进行重要性采样获取采样向量。设置brdf积分贴图为512x512,纹理设置为GL_RG。也就是说，这两部分积分可以获得F0的系数和F0的偏差。再回顾下镜面部分的分割求和近似法。查看这个RG是如何计算的。在对每个采样向量中，
【PBR系列七】基于物理的环境光照(下)：镜面反射 IBL(Specular IBL)
qq_35312463的博客
08-28 2587
本文核心知识主要参照learnopengl-cn文章总结归并，并根据个人学习方向进行了筛选摘抄，如有错误或不完整之处，可参照原文阅读。
Learn OpenGL 笔记7.3 PBR-IBL-Diffuse irradiance（Image based lighting-漫反射辐照度）
u013617851的博客
01-13 674
IBL，或image based lighting基于图像的照明，是一组照明对象的技术，不是像前一章那样通过直接分析光，而是将周围环境视为一个 big light source大光源。这通常通过操纵立方体贴图环境贴图（取自现实世界或从 3D 场景生成）来完成，以便我们可以直接在我们的照明方程中使用它：将每个立方体贴图纹素视为一个light emitter光发射器。通过这种方式，我们可以有效地捕捉环境的全局光照和总体感觉，让对象在其环境中拥有更好的归属感。 由于基于图像的照明算法捕获某些（全局）环境的照明，
OpenGL 镜面反射 IBL
希望我的博客，能帮上你解决学习中工作中所遇到的问题
03-19 598
OpenGL镜面反射 IBL镜面反射 IBL简介蒙特卡洛积分和重要性采样低差异序列GGX 重要性采样捕获预过滤 mipmap 级别预过滤卷积的伪像高粗糙度的立方体贴图接缝预过滤卷积的亮点 镜面反射 IBL简介 在上一节教程中，我们预计算了辐照度图作为光照的间接漫反射部分，以将 PBR 与基于图像的照明相结合。在本教程中，我们将重点关注反射方程的镜面部分： 卷积的第一部分被称为预滤波环境贴图，它类似于辐照度图，是预先计算的环境卷积贴图，但这次考虑了粗糙度。因为随着粗糙度的增加，参与环境贴图卷积的采样向量会更
QT with OpenGL(IBL-镜面反射)
Elsa的迷弟
04-25 562
注意：开启该选项后，并不是对纹理做模糊，而是当指向像素边界时，会根据边界临近的纹理像素做插值。如果一个采样点覆盖率为16个像素，则应该在第2层mipmap上采样；mipmap每加1层，纹理大小就缩小一半，每四个像素合成一个像素。如果一个采样点覆盖率为4个像素，则应该在第1层mipmap上采样；指向立方体贴图，每个单位立体角向量指向的贴图像素数也是不同的。可以很大程度上改变效果，将更多的采样权值放在中心采样区。向量指向立方体贴图边角位置，该方向的像素数会偏多。，我们看到的边界结果才是纹理中真正存储的像素值。
learnopengl——Specular IBL——貌似读懂了
小孔明的专栏
08-27 857
in the previous tutorial we have set up PBR in combination with image based lighting
PyPI 官网下载 | ibl-pipeline-light-0.1.1.tar.gz
01-12
资源来自pypi官网。 资源全名：ibl-pipeline-light-0.1.1.tar.gz
Python库 | ndx-ibl-metadata-0.2.0.tar.gz
04-12
资源分类：Python库 所属语言：Python 资源全名：ndx-ibl-metadata-0.2.0.tar.gz 资源来源：官方 安装方法：https://lanzao.blog.csdn.net/article/details/101784059
IBL-IntroToProof:IBL任务序列，介绍证明课程
05-24
这些说明是IBL任务序列，用于介绍证明课程。 如果您使用这些笔记并加以改进，我会感到很高兴。 如果您进行了任何修改，则可以在GitHub上发出拉取请求，也可以通过电子邮件将这些修改提交给我。 大部分材料是我（）...
MATLAB用拟合出的代码绘图-ibl-changepoint:用于IBL任务数据的变更点检测和理想观察者分析的工具箱
05-21
MATLAB用拟合出的代码绘图变更点检测和理想观察者分析 该存储库包含一个工具箱，用于对IBL任务进行模型拟合和理想观察者模型的绘制。...IBL-T1 ， IBL-T4 ， ibl_witten_04 ， ibl_witten_05 ; 我们将在这里适合第
node-v6.15.0-darwin-x64.tar.xz
最新发布
05-09
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
本人通过学习动手学习深度学习这本书后，跟着书本写出的基于pytorch的练习集合.zip
05-09
本人通过学习动手学习深度学习这本书后，跟着书本写出的基于pytorch的练习集合.zip
node-v6.11.5-linux-ppc64le.tar.xz
05-09
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
基于UCC21520DWR驱动 TI维也纳PFC电源板AD设计硬件原理图+PCB工程文件.zip
05-09
基于UCC21520DWR驱动 TI维也纳PFC电源板AD设计硬件原理图+PCB工程文件，Altium Designer 设计的工程文件，包括原理图及PCB文件，4层板设计，板子大小为258x236mm，双面布局布线，可以用Altium(AD)软件打开或修改，可作为你产品设计的参考。
IBL 双曲柱面是怎么样的？
07-14
IBL（Image-Based Lighting）是一种基于图像的照明技术，用于模拟真实世界中的光照...总之，IBL双曲柱面是一种用于模拟环境光照的几何形状，通过投影环境贴图并计算物体表面的光照强度和颜色，实现更加真实的渲染效果。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值