Создается ли контекст gl?

[Kostia]

if (texel.a < 0.5f) discard;

В таком случае альфа канал играет роль маски, можно принять как одно из решений для отрисовки травы, кустарников и деревьев вдали.
По поводу блендига, это всего лишь разные способы вычисления альфы в шейдере.

Впринципе я не сталкивался с такой проблемой, т.к. обычно работаю с 2D. Но для эффектов(система частиц, вывод полупрозрачных объектов...) я использовал бы другой способ. Сначала получил бы буфер глубины, путем рендеринга не прозрачных объектов в текстуру(читать тут http://code.google.com/p/gl33lessons/wiki/Lesson06). Затем просто отрендерил бы сцену с непрозрачными объектами и в самую последнюю очередь отсортированный список прозрачных объектов с выключенным тестом глубины, т.к. этот тест будем проводить мы в шейдере. Но и тут не все гладко, хотя теперь можно полноценно использовать альфу и мутить всякие эффекты не опасаясь, что они будут проявляться сквозь стены(пример недоработки в skyrim, размытие горения пламени видно сквозь предметы)

Можно узреть глубину своей сцены))

#version 330

uniform sampler2D colorTexture;

in vec3 fragColor;
in vec2 fragTex;

out vec4 ResultColor;

void main(void)
{
  // with Alpha test
  vec4 texel = texture(colorTexture, fragTex);
  if (texel.a < 0.5f) discard;
  //ResultColor = texel;
  ResultColor = vec4((1-gl_FragCoord.z)*8,(1-gl_FragCoord.z)*8,(1-gl_FragCoord.z)*8,1.0);
  
  // Std method
  // ResultColor = texture(colorTexture, fragTex);
 
}

Домашнее задание, нарисовать в этой сцене вращающийся полупрозрачный куб или какой другой объект)))

[Warn]

Проблему с перекрывающиеся листвой пока решил топорно – альфа тест и запись в буфер глубины – но, это подходит для объектов с полностью прозрачными областями текстуры. Как ты правильно заметил для листвы, травы и т.п.

Объекты с разной (0-255 Alpha) прозрачностью рисую последними в сцене, без записи в буфер глубины (но с тестом глубины). Порядок от дальних к ближним, при этом каждый такой объект рисуется в два этапа - сначала отсекаем все видимые треугольники у объекта (glCullFace(GL_FRONT)) – рисуем задние, затем наоборот – отсекаем задние glCullFace(GL_BACK) - рисуем передние. Если мысленно представить себе два стеклянных сосуда - один внутри другой, то порядок будет следующий. Сначала рисуем заднюю часть большого, потом заднюю часть маленького, потом переднюю часть маленькой и последней рисуем переднюю часть большого сосуда.

Сделал кубик с частично прозрачными местами, можно просмотреть через него на сценку. Вроде все работает как надо.

т.к. этот тест будем проводить мы в шейдере. Но и тут не все гладко, хотя теперь можно полноценно использовать альфу и мутить всякие эффекты не опасаясь, что они будут проявляться сквозь стены.

Да, надо потом попробовать и так сделать я что-то подобное мельком читал в нивидии Order Independent Transparency with Dual Depth Peeling. Понял что там аттчится много текстур в одну пишется мин и макс глубины сцены, а затем какой-то пин-понг начинается... в общем оставил на перспективу) Мне бы пока по простым постэффекты разобрать.

Обновленная версия.
Управление WASD + Mouse Wheel

[Kostia]

Выглядит отлично!
Да, то что в 2 этапа это правильно.
Прикручивай теперь рендер в текстуру, если еще не прикрутил и попробуй реализовать тени, bloom или HDR. И попробуй включить MSAA или постэффект FXAA
GLSL FXAA во сложении
rt_w и rt_h - размеры текстуры. Я их статично для тестов задал, по хорошему их из программы передавать нужно. Первоначальный код брал тут http://www.openengine.dk/code/extens.../TinyFxaa.glsl
И сделай пожалуйста плавное перемещение камеры, а то долго мучился чтобы во внутрь куба залезть

[Warn]

Спасибо, моделил, развертку делал и текстуры рисовал все сам.
Да рендер в текстуру прикрутить в последствии придется для пост-эффектов.
Пока хочу сделать отсечение объектов по пирамиде видимости камеры (фруструму).
Да и несколько унифицировать рендер объектов сцены и ввести соответствующие менеджеры ресурсов, а то каждый раз забивать новую переменную и ее спутник текстуру... - не выход, особенно если кол-во объектов в сцене будет расти. Еще прикрутить автоматическую сортировку объектов сцены, по очередности прорисовки и материалам. Материалы ввести. И еще пожалуй из первоочередных сделать проверку - куда указывает курсор, на какой объект и в какую его часть.
А камере я только колесо мыши забыл посадить на time based move – Cam.walk(50 * ElapsedTime); - где ElapsedTime – время за которое прорисовался предыдущий кадр (0.0 – 1.0 c);

(вопросы на перспективу)
Хотел спросить ты не знаешь, как Depth of Field делается?
И Blur как делают, усреднение соседних пикселей? Я смотрел в примерах Кренделя блюр, но там он какой-то слабенький, а чтобы совсем размазать сцену и постепенно наводить резкость?

И в чем принципиальная разница между MSAA и FXAA? Что дешевле в плане производительности и что более качественней? А то шейдер FXAA больно уж серьезный, тогда как MSAA можно включить/выбрать с помощью wglChoosePixelFormatARB и железо само обрабатывает острые грани.

[Kostia]

Хотел спросить ты не знаешь, как Depth of Field делается?

DOF, делается путем размытия пикселей в соответствии с Z-буфером. Но вот как именно, нужно читать. Хотя полагаю, если задается глубина фокусировки, то все отклонения размываются например по алгоритму gaussian blur с определенной силой (http://www.gamerendering.com/2008/10...filter-shader/)

И Blur как делают, усреднение соседних пикселей? Я смотрел в примерах Кренделя блюр, но там он какой-то слабенький, а чтобы совсем размазать сцену и постепенно наводить резкость?

Blur разный бывает. Самые простые примеры размытия и часто используемые это gaussian blur и radian blur.

radian blur fragment program:

uniform sampler2D tex;
vec3 texel_radius;
vec2 blur_center;

void main()
{
    texel_radius = vec3(0.02,0.02,32.0);
    blur_center = vec2(0.5);
    float radius = texel_radius.z;

    vec2 dxdy = length(texel_radius.xy) * (blur_center - gl_TexCoord[0].st);
    vec4 value = texture2D(tex, gl_TexCoord[0].st);
    float x = 1.0;
    while (x <= radius)
    {
        vec2 dudv = dxdy * x;
        value += texture2D(tex, gl_TexCoord[0].st + dudv) + texture2D(tex,gl_TexCoord[0].st - dudv);
        x += 1.0;
    }
    value /= 1.0 + 2.0 * radius;
    gl_FragColor = value;
}

И в чем принципиальная разница между MSAA и FXAA? Что дешевле в плане производительности и что более качественней? А то шейдер FXAA больно уж серьезный, тогда как MSAA можно включить/выбрать с помощью wglChoosePixelFormatARB и железо само обрабатывает острые грани.

Хоть он и серьезный, но зато быстрый! Не зря же он называется Fast approXimate Anti-Aliasing.
Разница между ними в том, что FAXX - пост эффект и обрабатывает всю сцену целиком, а MSAA сглаживает только грани.
Более качественное, это их совместное использование =) http://www.hmrengine.com/blog/?p=332
http://pmg.org.ru/nehe/nehe46.htm
с FBO чуть сложнее
вот конструктор в моем классе:

bool FBO::CreateFBO(int WIDTH, int HEIGHT, int Multisample)
{
	//TEX_id.Create(WIDTH, HEIGHT);
	if(WIDTH <= 0 || HEIGHT <= 0) return false;
	Size[0] = WIDTH; Size[1] = HEIGHT;
	if(Multisample>0){
		samples = Multisample;

		glGenRenderbuffersEXT(1, &CRBO_id);
		glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, CRBO_id);
		glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, Multisample, GL_RGBA8, WIDTH, HEIGHT);
		glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);

		glGenRenderbuffersEXT(1, &DRBO_id);
		glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, DRBO_id);
		glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, Multisample, GL_DEPTH_COMPONENT, WIDTH, HEIGHT);
		glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);

		glGenFramebuffersEXT(1, &MFBO_id);
		glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, MFBO_id);
		glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_RENDERBUFFER_EXT, CRBO_id);
		glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, DRBO_id);
		glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
	}

	glGenFramebuffersEXT(1, &FBO_id);
	//glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, FBO_id);


	return true;
}

[Kostia]

Матричные преобразования(фильтры) над изображениями тоже достаточно интересные.
Есть например выделение границ или тоже размытие.
По размытию могу добавить, что можно взять один из векторов треугольника паскаля помножить его на транспонированного самого себя и получить матрицу пропорций смешивания цветов.
Например
(1 2 1)*(1 2 1)Т =
1 2 1
2 4 2
1 2 1
Ну и считаешь сумму элементов и делишь
либо сразу:
1/16 2/16 1/16
2/16 4/16 2/16
1/16 2/16 1/16
либо после применения фильтра
А силу смешивания можно регулировать либо посчитав матрицу по больше(могут возникнуть проблемы), либо выполнив несколько проходов(качественно), либо проще всего менять средний элемент матрицы(немного лучше первого способа, в плане отсутствия проблем размеров матрицы, почти -_-), но в любом случае для увеличения размытия нужно увеличивать матрицу, кроме второго.
Если центральный элемент устремить к бесконечности, то получим при смешивании тот же цвет, если к нулю, то цвет в центре не будет принимать участия в смешивании.

как то так ^^
PS: завтра еще один экзамен, а я тут матрицы считаю)))

[Kostia]

А теперь оптимизация. Для нормального блюра, чтобы всего за 2 проходы было все нормально заблюрено из матрицы можно взять вертикальный и горизонтальный центральные вектора и делать это так, как делается в "Gaussian Blur".
Сначала размазать по горизонтали используя эти коэффициенты, а потом по вертикали.
Оптимизация на лицо, взяв матрицу размером 7*7 и делая blur в 2 проходы, мы получим 7+7=14 выборок из текстуры, а при однойном проходе 7*7=49 выборок на пиксель.

[Warn]

Матричные преобразования(фильтры) над изображениями тоже достаточно интересные.

Ага, видел эти матрицы-фильтры, в виде шейдера их назначение куда более понятнее становится)

// текстуры
uniform sampler2D colorTexture, depthTexture;

// параметры полученные из вершинного шейдера
in Vertex
{
	vec2 texcoord;
} Vert;

layout(location = FRAG_OUTPUT0) out vec4 color;

#define KERNEL_SIZE 9

const float kernel[KERNEL_SIZE] = float[](
	0.0625, 0.1250, 0.0625,
	0.1250, 0.2500, 0.1250,
	0.0625, 0.1250, 0.0625
);

const vec2 offset[KERNEL_SIZE] = vec2[](
	vec2(-1.0,-1.0), vec2( 0.0,-1.0), vec2( 1.0,-1.0),
	vec2(-1.0, 0.0), vec2( 0.0, 0.0), vec2( 1.0, 0.0),
	vec2(-1.0, 1.0), vec2( 0.0, 1.0), vec2( 1.0, 1.0)
);

vec3 filter(in vec2 texcoord)
{
	vec2 pstep = vec2(2.0) / vec2(textureSize(colorTexture, 0));
	vec4 res   = vec4(0.0);

	for (int i = 0; i < KERNEL_SIZE; ++i)
		res += texture(colorTexture, texcoord + offset[i] * pstep) * kernel[i];

	return vec3(res);
}

void main(void)
{
	vec3 texel = filter(Vert.texcoord);

	color = vec4(texel, 1.0);
}

А теперь оптимизация.

Спасибо Костя за описание.
Как буду прикручивать постпроцессинг - блюр, попробую сделать.
Cегодня проверку фрустума прикрутил, долго ловил баг с проверкой сфер, пока не понял, что нормирую плоскость так же так и вектор 4d %.

завтра еще один экзамен, а я тут матрицы считаю)))

p.s. ну тогда считай 5-ка обеспечена ))

[Kostia]

p.s. ну тогда считай 5-ка обеспечена ))

Если бы была линейка, а тут численные методы, фи.

Спасибо Костя за описание.

Это были мысли вслух, на практике могут всплыть камни.

[Warn]

Соображаю над сцено-графом.
Охото чего-то понятного, удобного и эффективного.
Пока надумал что-то вроде этого)
Псевдо -

 
 // Визуальный объект
 SceneObject {
    objectMatrix : mat4
    refMesh = MeshMgr.Select('Box')
    refTex = TexMgr.Select('BoxTex')
    refShader = ShaderMgr.Select('SimpleShader')
    ...
  }
  
  // Контейнер для некой-локальной группы визуальных обьектов.
  // И таких же составляющих контейнеров.
  SceneNode {
    nodeMatrix : mat4
    parentNode : SceneNode;
    childNodes : array of SceneNode;
    objects : array of SceneObject;

    function CreateObject() : CSceneObject;
    procedure DeleteObject(var obj:CSceneObject);

    function CreateChildNode(): CSceneNode;
    procedure DeleteChildNode(var node:CSceneNode);
    ...
  }
  
  // Контейнер сцены.
  Scene 
  {
    WorldNode : SceneNode;
    procedure SetCamera(var camera : CCamera);
    proc Update(); 
    proc Draw();
    ...
  }

Примерно так должен выглядеть код

//On Initialize
var HomeNode: CSceneNode;
var HomeObject : CSceneObject;
var BoxInHome : CSceneObject;

var Camera : CCamera;


HomeNode := Scene.WorldNode.CreateChildNode();

// Позиция домика в мире
HomeNode.nodeMatrix.translate(10, 20, 20);
HomeObject := HomeNode.CreateObject();

HomeObject.refMesh := MeshMgr.Select('HomeModel');
HomeObject.refTex := MeshMgr.Select('HomeTexture');
HomeObject.refShader := MeshMgr.Select('StdAlphaTestShader');
HomeObject.renderStage = RStageWithAlphaTest;

BoxInHome = HomeNode.CreateObject();
BoxInHome.refMesh := MeshMgr.Select('BoxModel');
BoxInHome.refTex := MeshMgr.Select('BoxTexture');
BoxInHome.refShader := MeshMgr.Select('StdSolidShader');
BoxInHome.renderStage = RStageSolid;

// Позиция коробки в домике
BoxInHome.matrix.translate(1,2,1);


Scene.SetCamera(Camera);

//On Render loop

Scene.SortToStages();
Scene.SortStagesByDepth();
Scene.RenderSolidStage();
Scene.RenderAlphaTestStage();
Scene.RenderAlphaBlendStage();