Атмосферное рассеяние OpenGL 3.3

введите описание изображения здесь

В настоящее время я пытаюсь преобразовать шейдер Шона О’Нила в версию 330, чтобы я мог попробовать его в приложении, которое я пишу. У меня возникли некоторые проблемы с устаревшими функциями, поэтому я заменил их, но я почти полностью новичок в glsl, так что я, вероятно, где-то допустил ошибку.

Оригинальные шейдеры можно найти здесь:
http://www.gamedev.net/topic/592043-solved-trying-to-use-atmospheric-scattering-oneill-2004-but-get-black-sphere/

Моя ужасная попытка конвертировать их:

Вершинный шейдер:

#version 330 core

// Input vertex data, different for all executions of this shader.
layout(location = 0) in vec3 vertexPosition_modelspace;
layout(location = 2) in vec3 vertexNormal_modelspace;uniform vec3 v3CameraPos;       // The camera's current position
uniform vec3 v3LightPos;        // The direction vector to the light source
uniform vec3 v3InvWavelength;   // 1 / pow(wavelength, 4) for the red, green, and blue channels
uniform float fCameraHeight;    // The camera's current height
uniform float fCameraHeight2;   // fCameraHeight^2
uniform float fOuterRadius;     // The outer (atmosphere) radius
uniform float fOuterRadius2;    // fOuterRadius^2
uniform float fInnerRadius;     // The inner (planetary) radius
uniform float fInnerRadius2;    // fInnerRadius^2
uniform float fKrESun;          // Kr * ESun
uniform float fKmESun;          // Km * ESun
uniform float fKr4PI;           // Kr * 4 * PI
uniform float fKm4PI;           // Km * 4 * PI
uniform float fScale;           // 1 / (fOuterRadius - fInnerRadius)
uniform float fScaleDepth;      // The scale depth (i.e. the altitude at which the atmosphere's average density is found)
uniform float fScaleOverScaleDepth; // fScale / fScaleDepth

const int nSamples = 2;
const float fSamples = 2.0;

invariant out vec3 v3Direction;

// Values that stay constant for the whole mesh.
uniform mat4 MVP;
uniform mat4 V;
uniform mat4 M;
uniform vec3 LightPosition_worldspace;out vec4    dgl_SecondaryColor;
out vec4   dgl_Color;float scale(float fCos)
{
float x = 1.0 - fCos;
return fScaleDepth * exp(-0.00287 + x*(0.459 + x*(3.83 + x*(-6.80 + x*5.25))));
}void main(void)
{

//gg_FrontColor = vec3(1.0, 0.0, 0.0);
//gg_FrontSecondaryColor = vec3(0.0, 1.0, 0.0);

// Get the ray from the camera to the vertex, and its length (which is the far point of the ray passing through the atmosphere)
vec3 v3Pos = vertexPosition_modelspace;
vec3 v3Ray = v3Pos - v3CameraPos;
float fFar = length(v3Ray);
v3Ray /= fFar;

// Calculate the ray's starting position, then calculate its scattering offset
vec3 v3Start = v3CameraPos;
float fHeight = length(v3Start);
float fDepth = exp(fScaleOverScaleDepth * (fInnerRadius - fCameraHeight));
float fStartAngle = dot(v3Ray, v3Start) / fHeight;
float fStartOffset = fDepth*scale(fStartAngle);

// Initialize the scattering loop variables
gl_FrontColor = vec4(0.0, 0.0, 0.0, 0.0);
gl_FrontSecondaryColor = vec4(0.0, 0.0, 0.0, 0.0);

float fSampleLength = fFar / fSamples;
float fScaledLength = fSampleLength * fScale;
vec3 v3SampleRay = v3Ray * fSampleLength;
vec3 v3SamplePoint = v3Start + v3SampleRay * 0.5;

// Now loop through the sample rays
vec3 v3FrontColor = vec3(0.2, 0.1, 0.0);
for(int i=0; i<nSamples; i++)
{
float fHeight = length(v3SamplePoint);
float fDepth = exp(fScaleOverScaleDepth * (fInnerRadius - fHeight));
float fLightAngle = dot(v3LightPos, v3SamplePoint) / fHeight;
float fCameraAngle = dot(v3Ray, v3SamplePoint) / fHeight;
float fScatter = (fStartOffset + fDepth*(scale(fLightAngle) - scale(fCameraAngle)));
vec3 v3Attenuate = exp(-fScatter * (v3InvWavelength * fKr4PI + fKm4PI));
v3FrontColor += v3Attenuate * (fDepth * fScaledLength);
v3SamplePoint += v3SampleRay;
}

// Finally, scale the Mie and Rayleigh colors and set up the varying variables for the pixel shader
gl_FrontSecondaryColor.rgb = v3FrontColor * fKmESun;
gl_FrontColor.rgb = v3FrontColor * (v3InvWavelength * fKrESun);
gl_Position =  MVP * vec4(vertexPosition_modelspace,1);
v3Direction = v3CameraPos - v3Pos;

dgl_SecondaryColor = gl_FrontSecondaryColor;
dgl_Color = gl_FrontColor;}

Фрагмент шейдера:

#version 330 core

out vec4 dgl_FragColor;

uniform vec3 v3LightPos;
uniform float g;
uniform float g2;

invariant in vec3 v3Direction;

in vec4    dgl_SecondaryColor;
in vec4   dgl_Color;uniform mat4 MV;

void main (void)
{

float fCos = dot(v3LightPos, v3Direction) / length(v3Direction);
float fMiePhase = 1.5 * ((1.0 - g2) / (2.0 + g2)) * (1.0 + fCos*fCos) / pow(1.0 + g2 - 2.0*g*fCos, 1.5);
dgl_FragColor = dgl_Color + fMiePhase * dgl_SecondaryColor;
dgl_FragColor.a = dgl_FragColor.b;}

Я написал функцию для визуализации сферы, и я пытаюсь перевести этот шейдер в инвертированную версию, сфера работает совершенно нормально, с нормалями и всем остальным. Моя проблема в том, что сфера отображается полностью черным, поэтому шейдер не работает.
Изменить: есть солнце, чтобы нарисовать, но небо все еще все черное.

Вот как я пытаюсь визуализировать атмосферу внутри моего основного цикла рендеринга.

    glUseProgram(programAtmosphere);
glBindTexture(GL_TEXTURE_2D, 0);
//######################glUniform3f(v3CameraPos, getPlayerPos().x, getPlayerPos().y, getPlayerPos().z);

glm::vec3 lightDirection = lightPos/length(lightPos);

glUniform3f(v3LightPos, lightDirection.x , lightDirection.y, lightDirection.z);

glUniform3f(v3InvWavelength, 1.0f / pow(0.650f, 4.0f), 1.0f / pow(0.570f, 4.0f), 1.0f / pow(0.475f, 4.0f));

glUniform1fARB(fCameraHeight, 10.0f+length(getPlayerPos()));

glUniform1fARB(fCameraHeight2, (10.0f+length(getPlayerPos()))*(10.0f+length(getPlayerPos())));

glUniform1fARB(fInnerRadius, 10.0f);

glUniform1fARB(fInnerRadius2, 100.0f);

glUniform1fARB(fOuterRadius, 10.25f);

glUniform1fARB(fOuterRadius2, 10.25f*10.25f);

glUniform1fARB(fKrESun, 0.0025f * 20.0f);

glUniform1fARB(fKmESun, 0.0015f * 20.0f);

glUniform1fARB(fKr4PI, 0.0025f * 4.0f * 3.141592653f);

glUniform1fARB(fKm4PI, 0.0015f * 4.0f * 3.141592653f);

glUniform1fARB(fScale, 1.0f / 0.25f);glUniform1fARB(fScaleDepth, 0.25f);glUniform1fARB(fScaleOverScaleDepth, 4.0f / 0.25f );glUniform1fARB(g, -0.990f);glUniform1f(g2, -0.990f * -0.990f);

Есть идеи?

Редактировать: обновил код и добавил картинку.

5

Решение

Я думаю, что проблема в том, что вы пишете в FragColor, который может быть выходной переменной «тупика» в фрагментном шейдере, так как перед связыванием программы нужно явно связать ее с номером цвета:

glBindFragDataLocation(programAtmosphere,0,"FragColor");

или используя это в шейдере:

layout(location = 0) out vec4 FragColor

Вместо этого вы можете попробовать использовать встроенные переменные: gl_FragColor, который является псевдонимом для gl_FragData[0] и, следовательно, такой же, как указано выше обязательным.

РЕДАКТИРОВАТЬ: Забыл сказать, что при использовании устаревших встроенных, вы должны иметь декларацию совместимости:

#version 330 compatibility

РЕДАКТИРОВАТЬ 2: Чтобы проверить привязку, я бы написал постоянный цвет, чтобы отключить возможные ошибки вычислений, так как они могут не дать ожидаемого результата из-за ошибок или нулевого ввода.

2

Другие решения

Других решений пока нет …

По вопросам рекламы [email protected]