标签: hlsl

我正在尝试对我的 shaow 贴图实施 PCF 过滤，因此修改了 GPU Gems 文章（http://http.developer.nvidia.com/GPUGems/gpugems_ch11.html），以便它可以在当前着色器上运行。修改包括用 Texture2D.Sample() 函数替换 tex2Dproj 函数，以便它接受在 DirectX11 中创建的采样器状态。然后我将偏移值与普通阴影贴图比较进行了比较：

float2 ShTex;
ShTex.x = PSIn.ShadowMapSamplingPos.x/PSIn.ShadowMapSamplingPos.w/2.0f +0.5f;
ShTex.y = -PSIn.ShadowMapSamplingPos.y/PSIn.ShadowMapSamplingPos.w/2.0f +0.5f;
float realDistance = PSIn.ShadowMapSamplingPos.z/PSIn.ShadowMapSamplingPos.w;


(realDistance - xShBias) <= offset_lookup(xTextureSh, texSampler, ShTex, float2(x, y), scale); //Blocker-receiver comparison (the usual stuff, only that it gets 4*4 samples from near offsets then divides the final value with 16)

现在我得到的回报是这样的：

在文章中，它说并表明硬件应该神奇地插入结果。我猜 tex2Dproj 可能会这样做，但没有成功让它工作。

最近我遇到了 SampleCmpLevelZero 函数，我用这个采样器状态尝试了它：

SamplerComparisonState cmpSampler
{
   Filter = COMPARISON_MIN_MAG_MIP_LINEAR;
   AddressU = Clamp;
   AddressV = Clamp; …

我正在处理程序纹理，它看起来很好，除了很远之外，小的纹理像素分解为噪点和莫尔图案。

我已经着手寻找一种解决方案来平均和量化远处和近处的图案比例，以便近处是完整的细节，远处则四舍五入，以便远处山的一个像素仅代表在那里找到了一种颜色，而不是 10 或 20 种颜色。

通过四舍五入体积纹理基于使用 if 语句的 World_Position 很容易做到这一点，即：

    if( camera-pixel_distance > 1200 meters ) {wpos = round(wpos/3)*3;}//---round far away pixels
    return texturefucntion(wpos);

四舍五入的结果是它们看起来像这样，除了很远的地方： 问题是我必须为各种距离设置大约 5 个 if 条件，并且我必须估计一个随机的好舍入值

我试图制作一个函数，将像素的距离切割成距离步长，并将 LOD 分隔符应用于 pixel_worldposition 值，使其在远处逐渐变圆，但我得到了无意义的结果，实际上 HLSL 完全翻转了。这是尝试：

float cmra= floor(_WorldSpaceCameraPos/500)*500;  //round camera distance by steps of 500m
float dst=  (1-distance(cmra,pos)/4500)*1000 ; //maximum faraway view is 4500 meters
pos= floor(pos/dst)*dst;//close pixels are rounded by 1000, far ones rounded by 20,30 etc

它返回了我无法理解的无意义模式。

是否有用于平滑和舍入距离纹理伪影的良好记录算法？我可以使用屏幕像素分辨率，结合像素的距离，将每个像素四舍五入为一种保持稳定颜色的颜色吗？

我只是想知道如何在HLSL中使用Texture2DArray.

我正在尝试实现一个模型加载器,其中模型具有不同的纹理量.目前我的HLSL使用尺寸为2的Texture2D(纹理和普通纹理),但由于我的模型具有不同数量的纹理,我希望使用Texture2DArray但不知道从哪里开始.我一直试图在互联网上找到例子,但没有运气:(

我加载纹理,编译为'ID3D11ShaderResourceView*'所以我应该创建一个变量ID3D11ShaderResourceView**我创建一个点到纹理的点数组,然后将其传递给着色器或什么？

有帮助吗？

我有两个（相同的）着色器，一个在 hlsl 中，一个在 glsl 中。在像素着色器中，我将向量乘以矩阵以进行法线变换。代码本质上是：

HLSL

float3 v = ...;
float3x3 m = ...;
float3 n = mul(v, m);

GLSL

vec3 v = ...;
mat3 m = ...;
vec3 n = v * m;

这应该执行行向量乘法，但在 glsl 中却没有。如果我明确地输入算法，它对两者都适用。据我所知，glsl 和 hlsl 规范都表示，如果向量位于左侧（事实确实如此），则它们应该执行行向量乘法。

另一个令人困惑的事情是，我在顶点着色器中将向量乘以矩阵，向量在左侧，但这在 glsl 和 hlsl 中都可以正常工作。这让我猜测这只是片段/像素着色器中的问题。

我使用以下方法将矩阵从顶点着色器传递到片段着色器：

out vec3 out_vs_TangentToWorldX;
out vec3 out_vs_TangentToWorldY;
out vec3 out_vs_TangentToWorldZ;

out_vs_TangentToWorldX = tangent * world3D;
out_vs_TangentToWorldY = binormal * world3D;
out_vs_TangentToWorldZ = normal * world3D;

在片段着色器中我用以下命令重建它：

in vec3 out_vs_TangentToWorldX;
in vec3 out_vs_TangentToWorldY;
in vec3 out_vs_TangentToWorldZ; …

我正在使用 C++ 和 Direct3D11 开发游戏引擎，现在我想向场景中添加可变数量的灯光。迄今为止，我设法添加和渲染了在着色器程序中已知和编码的计数的简单灯光。

在 shader.fx 中：

static const int LightsCount= 4;

struct NF3D_LIGHT
{
    // Members...
};

cbuffer Light : register(b5)
{
    NF3D_LIGHT light[LightsCount];
};

...

// And the pixel shader function:
float4 PS(PS_INPUT input) : SV_Target
{
    for(int i = 0; i < LightsCount; i++)
    {
        // Process each light and return the final pixel colour
    }
}

这工作正常。但如果我尝试：

cbuffer LIGHTS_COUNT : register(b13)
{
    int LightsCount;
}

要根据游戏中发生的情况使灯的数量发生变化，这是行不通的。我知道我可以LightsCount在应用程序开始时给出一个很大的值并向阵列添加灯光，但我发现这种方法复杂、固定且效率低下。

有谁知道如何解决这个问题？先感谢您。

我在 Windows 上有一个带有 CMake 的 DirectX11 项目。该项目包含（至少）三个子项目——一个用于核心 3D 引擎库——一个公共资产目录，其中包含构建在引擎之上的测试或示例应用程序使用的所有二进制数据。

./ 
+-- src/
|   +-- api/
|       +-- CmakeLists.txt
+-- tests/
|   +-- assets/
|   |   +-- shaders/
|   |   |   +-- 1.hlsl
|   |   |   +-- 2.hlsl
|   |   |       ...
|   |   +-- images/
|   |   |       ...
|   |   +-- models/
|   |   |       ...
|   |   +-- CmakeLists.txt
|   +-- sampleApp1/
|   |   +-- CmakeLists.txt
|   |        ...
|   +-- sampleApp2 
|   |   +-- CmakeLists.txt
|   | …

我在hlsli有一个常用的方法

/// RendererShaderTypes.hlsli
///
static inline float4 OverlayColor(float2 texOverlay, float4 videoColor)
{

      float4 texColor = float4(imageMixTexture[4].Sample(imageMixSampler[4], texOverlay));
      if (texColor.r == keyColor.r &&
          texColor.g == keyColor.g &&
          texColor.b == keyColor.b)
      {
          return videoColor;
      }
      return lerp(texColor, videoColor, transparency);
}

它是从多个 hlsl 像素着色器调用的。

#include "RendererShaderTypes.hlsli"
float4 main(PSPosTexOverlay input) : SV_TARGET
{
    return OverlayColor(input.texOverlay, backColor);
}

也调用另一个像素着色器

#include "RendererShaderTypes.hlsli"
float4 main(PSPosVideoTexture input) : SV_TARGET
{
     // lookup color of video
     float4 mixColor = mul(colorMatrix[0], VideoColor(imageMixSampler[0], imageMixTexture[0], input.texImage));
     mixColor.rgb *= mixColor.a;
     mixColor.a = 1.0f; …

我正在尝试通过 unity/CG/hlsl 中的计算着色器将纹理转换为频域，即我正在尝试从纹理读取像素值并输出基函数系数数组。我该怎么办？我对计算着色器真的很陌生，所以我有点迷失。我了解竞争条件的原因以及计算着色器如何划分工作负载，但有什么方法可以解决这个问题吗？一般来说，关于缓冲区和其他事情的一般文档对于没有这方面背景的人来说似乎有点平淡无奇。

我收到的错误： Shader error in 'Compute.compute': race condition writing to shared resource detected, consider making this write conditional. at kernel testBuffer at Compute.compute(xxx) (on d3d11)

一个简化的示例可能是将所有像素值相加，目前我的方法如下。我正在尝试使用结构化缓冲区，因为我不知道如何才能检索数据或将其存储在 GPU 上以便之后进行全局着色器访问？

struct valueStruct{
float4 values[someSize];
}

RWStructuredBuffer<valueStruct> valueBuffer;

// same behaviour if using RWStructuredBuffer<float3> valueBuffer;
// if using 'StructuredBuffer<float3> valueBuffer;' i get the error:
// Shader error in 'Compute.compute': l-value specifies const object at kernel testBuffer at Compute.compute(xxx) (on d3d11)

Texture2D<float4> Source;

[numthreads(8, 8, 1)]
void testBuffer(uint3 id : SV_DispatchThreadID) { …

我想知道哪种资源类型最适合使用，以便为静态数据保存尽可能多的元素，并且在绘制调用期间不会更改。我能看出常量缓冲区和只读结构化缓冲区之间的唯一区别是常量缓冲区数据必须在其ID3D12Resource对象内部按 256 字节对齐。

lights.hlsl

#define as_many_as_possible 1000

struct light
{
    float3 position;
    float falloff_start;
    float3 direction;
    float falloff_end;
    float3 color;
    float3 strenght;
};

struct light_data
{
    light lights [as_many_as_possible];
};
ConstantBuffer<light_data> cb_lights : register(b0);

// Versus

StructuredBuffer<light> sb_lights : register(s0);

如果我的目标是保存尽可能多的灯光数据，那么哪一个更好？

我想知道是否有可能从文件动态编译像素着色器并将其应用于网格.

首先,我将从一些背景信息开始.我有一个系统,它根据一系列数据创建HLSL像素着色器,这对这个问题并不重要.重要的是这些着色器不使用技术或通行证.因为它们不打算用作.fx文件.

该ShaderCompiler.CompileFromFile()方法能够将文件成功编译为CompiledShader.

是否可以将此着色器应用于网格？

因为我不想找到每个文件的入口点以将其包装在一种技术中,以允许将其编译为Effect.