42306

Исследование и разработка некоторых графических алгоритмов

Дипломная

Информатика, кибернетика и программирование

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

Русский

2015-01-19

6.69 MB

1 чел.

Исследование и разработка некоторых графических алгоритмов


Реферат:

Шайдуров А.Г. Исследование и разработка некоторых графических алгоритмов. Квалификационная работа на степень магистра наук по направлению «Математика. Прикладная математика»: 137 стр., 62 ил, библ.: 35 назв., 1 приложение.

Ключевые слова: ДЕТАЛИЗАЦИЯ ПОВЕРХНОСТЕЙ, ЛОКАЛЬНАЯ ТРАССИРОВКА ЛУЧЕЙ, ПОСТРОЕНИЕ ОТРАЖЕНИЙ, КУБИЧЕСКИЕ ТЕКСТУРЫ, АЛИАСИНГ, PARALLAX MAPPING, GPU ALGORITHMS.

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


Содержание


 Введение

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

В главе 1 приводится краткий обзор существующих методов рушения рассматриваемых в работе задач. Глава 2 посвящена описанию разработанных алгоритмов. В главе 3 подводятся итоги и рассматриваются направления дальнейших исследований. В Приложении 1 находятся фрагменты исходного кода.


Постановка задачи

Предлагается выполнить следующую работу:

  1.  Исследовать некоторые из существующих методов и алгоритмов компьютерной графики.
  2.  Предложить новые методы или модификации существующих.
  3.  Реализовать предложенные методы, по возможности на графическом оборудовании.


1. Существующие алгоритмы


1.1. Методы улучшения детализации поверхностей

Мелкие детали сильно влияют на внешний вид объектов, но моделирование всех деталей с помощью геометрии приводит к чрезмерному усложнению модели. Существует несколько методов улучшения детализации объектов без усложнения геометрической модели: normal mapping, parallax mapping, displacement mapping и другие [, , , , , , ].


1.1.1. Bump mapping

Один из наиболее простых методов основан на модификации нормали к поверхности. Его предложил Jim Blinn в 1978 году. Поверхность задается с помощью геометрической модели сравнительно низкой детализации и дополнительной информации для увеличения детализации – карты высот или карты нормалей (). В каждом элементе карты высот содержится смещение H соответствующей точки вдоль нормали к геометрической поверхности. Если для каждой точки геометрической поверхности добавить это смещение, то получится более детализированная поверхность. Для того, чтобы получить изображение детализированной поверхности с небольшими вычислительными затратами, для рисования поверхности используется геометрическая модель с низкой детализацией. Информация в карте высот используется для вычисления нормали Ns к детализированной поверхности. Для этого при обработке каждого пикселя выполняется численное дифференцирование карты высот на остове нескольких соседних выборок. Вместо карты высот можно использовать карту нормалей, в которой хранятся нормали к детализированной поверхности в касательном пространстве исходной (геометрической) поверхности. В этом случае требуется только одна выборка из карты нормалей. Кроме того, выполняется меньше математических расчетов, так как не выполняется численное дифференцирование. Недостатки по сравнению с картой высот – отсутствие информации о смещении поверхности вдоль нормали (которая может понадобиться для других методов), а также невозможность использования дополнительных текстур детализации. При расчете освещения точки P вместо геометрической нормали Ng используется полученная нормаль, в результате чего достигается увеличение детализации.

рис.  


1.1.2. Parallax mapping

Parallax mapping – развитие предыдущих методов. Кроме модификации нормали в этом методе подвергаются изменениям текстурные координаты. Для этого требуется карта высот, карты нормалей здесь недостаточно. При рисовании поверхности точка S пересечения вектора наблюдения с поверхностью, заданной в карте высот, аппроксимируется точкой S` (). Для того, чтобы обрабатываемый пиксель имел цвет точки S` (а не G), исходные текстурные координаты TG, взятые из геометрической модели, заменяются на TS. Такая аппроксимация дает удовлетворительные результаты только в том случае, если высота меняется не очень быстро. Кроме того, данный метод не учитывает возможность перекрытия пикселя другим участком поверхности ().

рис.  

рис.  



1.1.3. Методы, основанные на трассировке в карте высот

Методы, использующие трассировку в карте высот (parallax occlusion mapping, steep parallax mapping, relief mapping), работают следующим образом. Сначала выполняется перевод вектора наблюдения (направленного из камеры к обрабатываемому пикселю) в касательное пространство. Затем ищется точка пересечения S этого вектора с поверхностью, заданной в карте высот. После этого вычисляется цвет точки S, который возвращается в качестве результата. Дополнительно можно определить, находится ли точка S в тени. Для этого ищется пересечение вектора, направленного из точки S к источнику света, с поверхностью (подобно тому, как находилось пересечения вектора наблюдения с поверхностью на предыдущем этапе). Если пересечение существует, точка находится в тени; иначе – освещена. Эта информация используется в процессе расчета освещения.

Ключевая операция в таких алгоритмах – вычисление пересечения луча с поверхностью. Наиболее простой способ – линейный поиск.


Методы нахождения пересечения луча с поверхностью


Линейный поиск

В процессе линейного поиска осуществляется смещение вдоль вектора наблюдения на небольшую фиксированную величину до тех пор, пока текущая точка Si не окажется ниже поверхности (). Для того, чтобы проверить положение текущей точки относительно поверхности, осуществляется выборка из карты высот по координатам x и y точки Si (поиск проводится в касательном пространстве, поэтому в качестве текстурных координат используются координаты точки Si). Если координата z точки Si меньше (или больше – в зависимости от направления оси z касательного пространства) значения из карты высот, то Si находится ниже поверхности, иначе – выше.

рис.  

У линейного поиска есть недостаток – для точного поиска пересечения величина смещения вдоль вектора наблюдения должна быть небольшой. Это приводит к большому числу итераций и низкой скорости работы. Увеличение величины смещения приводит к двум проблемам:

  1.  Снижение точности поиска. Абсолютная погрешность в касательном пространстве равна длине вектора смещения.
  2.  Пропуск мелких деталей (выступов и т.п.) (). Это общая проблема всех дискретных методов.

рис.  

Вторая проблема особенно неприятна, так как мелкие детали могут внезапно появляться и исчезать при движении объекта или камеры. Это один из основных недостатков методов, использующих трассировку в карте высот, по сравнению с геометрическими методами (displacement mapping). У геометрических методов тоже есть проблемы дискретизации, но формируемая поверхность получается непрерывной. Кроме того, у таких методов нет зависимости от вектора наблюдения, поэтому при движении объекта или камеры поверхность не меняется и не происходит внезапного появления и исчезновения мелких деталей.

Для ускорения поиска пересечения без снижения точности существует несколько методов.


Бинарный поиск

Это рекурсивный алгоритм. На каждой итерации текущий отрезок делится пополам и выбирается та половина, концы которой находятся по разные стороны от поверхности ().

Скорость сходимости бинарного поиска гораздо выше, чем у линейного, но для корректной работы требуется, чтобы для вектора, подаваемого на вход алгоритма, существовало единственное пересечение с поверхностью. В противном случае алгоритм может найти не первое пересечение (). Можно достичь хороших результатов, если комбинировать линейный поиск с бинарным. В этом случае сначала выполняется линейный поиск с достаточно большим шагом (чтобы ускорить поиск) для локализации пересечения. Затем следует бинарный поиск для уточнения пересечения. При этом в качестве начального отрезка для бинарного поиска используется отрезок, сформированный последней и предпоследней точками, полученными в процессе линейного поиска. Линейный поиск останавливается, как только текущая точка оказывается под поверхностью, поэтому последняя точка находится под поверхностью, а предпоследняя – над поверхностью (иначе поиск завершился бы на предыдущем шаге). В случае выбора большого шага для линейного поиска возможно существование более одного пересечения получившегося отрезка с поверхностью (что может привести к некорректной работе бинарного поиска), но на практике это маловероятно. К сожалению, пропуск мелких деталей по-прежнему возможен, т.к. локализация точки пересечения осуществляется линейным поиском с достаточно большим шагом. Таким образом, рассмотренный комбинированный подход решает первую из названных выше проблем, но не вторую.

рис.  

рис.  


Методы, использующие предварительно рассчитанные данные

В алгоритме per-pixel displacement mapping with distance functions [] расстояние от каждой точки до поверхности сохраняется в трехмерной текстуре. Для поиска пересечения выполняется трассировка сфер, при осуществлении которой используется сохраненная информация.

Алгоритм cone step mapping [] для каждого элемента карты высот на этапе предрасчета данных (который выполняется один раз) рассчитывает конус и сохраняет его угол в двумерной текстуре. Конус рассчитывается таким образом, чтобы он не пересекал поверхность, заданную в карте высот, и его угол был максимальным (т.е. конус касается поверхности). Для нахождения пересечения вектора наблюдения с поверхностью на каждом шаге вычисляется пересечение этого вектора с сохраненным конусом. Для получения конуса из рассчитанной на подготовительном этапе текстуры используются текстурные координаты текущей точки. Вычисленное пересечение с конусом считается новой текущей точкой. Так как конус касается поверхности, но не пересекает ее, последовательность точек только приближается к поверхности, но не может перескочить через нее. Благодаря этому решается вторая проблема линейного поиска. Но в большинстве случаев последовательность точек так и не достигает поверхности, и на практике это привадит к заметным искажениям. То есть первая проблема остается нерешенной.

Quad-directional cone step [] – развитие предыдущего метода. Отличие заключается в том, что вместо одного угла конуса сохраняется четыре для каждого направления. Это позволяет немного увеличить точность поиска, но не решает полностью проблемы предыдущего алгоритма.

Алгоритм relaxed cone stepping [] во многом похож на комбинацию линейного и бинарного поисков. Только вместо линейного поиска используется модификация метода cone step mapping: конус рассчитывается таким образом, чтобы любой отрезок внутри него пересекал поверхность не более одного раза. Это менее жесткое ограничение. В результате радиусы конусов оказываются значительно больше, что приводит к ускорению сходимости. Кроме того, так как любой отрезок внутри конуса пересекает поверхность не более одного раза, можно еще уточнить пересечение при помощи бинарного поиска, имеющего высокую скорость сходимости.


1.2. Метод наложения окружающей среды с использованием кубических текстур

Существует эффективный метод построения отражений на зеркальных объектах, который легко реализовать на графическом оборудовании. Для этого точка наблюдения помещается в центр зеркального объекта, угол обзора для перспективной матрицы проекции [, ] устанавливается равным 90 градусам, и окружающая среда рисуется в 6 направлениях (справа, слева, сверху, снизу, спереди и сзади объекта). 6 полученных изображений формируют кубическую текстуру. При рисовании зеркального объекта на основе направления вектора наблюдения и нормали вычисляется вектор отражения. Он используется в качестве текстурных координат для кубической текстуры (по трехмерному вектору направления определяется грань куба и двумерные текстурные координаты соответствующей двумерной текстуры, это обычно осуществляется аппаратно). Полученное из кубической текстуры значение и есть цвет отражения в обрабатываемом пикселе.

Один из основных недостатков данного метода – отсутствие самоотражений, поскольку сам объект при построении кубической текстуры не рисуется. Это может привести к некорректным отражениям на невыпуклых объектах: там, где должен отражаться объект, отражается окружающая среда.

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

Более подробно о методе наложения окружающей среды с использованием кубических текстурных карт можно прочитать, например, в [, ].


1.3. Алгоритмы теневых буферов

Алгоритм теневых буферов – один из наиболее распространенных методов построения теней. Его предложил Lance Williams в 1978 году. Алгоритм достаточно простой. На первом этапе требуется нарисовать с позиции источника света в буфер глубины все объекты, которые могут отбрасывать тень. На втором этапе рисуется сцена с позиции наблюдателя. Для того, чтобы определить, находится ли пиксель в тени, он переводится в систему координат источника света. Если его глубина больше сохраненного на первом этапе значения, то он находится в тени, иначе – освещен.

К преимуществам алгоритма по сравнению с другими относится небольшая зависимость от геометрической сложности объектов, универсальность (работает с любой геометрией, а также с прозрачными текстурами), простота реализации. В то же время алгоритм работает в пространстве изображения, что приводит к алиасингу и проблемам передискретизации. Кроме того, буфер глубины имеет ограниченную точность, к тому же для него требуется дополнительная память.

Существуют многочисленные модификации этого алгоритма [, , , , , , , , , , , , , , , , ]. В этих модификациях предпринимаются попытки улучшить базовый алгоритм, например, уменьшить алиасинг или размыть границы теней.


2. Предлагаемые алгоритмы

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

Использованные идеи лежат в основе метода локальной трассировки, в котором комбинируется классическая трассировка лучей и кубические текстуры для получения отражений.

Оба предлагаемых алгоритма допускают эффективную реализацию на существующем графическом оборудовании.

Реализации всех алгоритмов можно найти в Приложении 1. Программы для демонстрации предложенных методов были написаны на языке программирования C++. Для программирования графического процессора использовался язык HLSL. Взаимодействие с графическим оборудованием осуществлялось через интерфейс Direct3D 9.0c. В качестве начальной точки для реализации методов, использующих графическое оборудование, использовался проект SimpleSample из DirectX SDK (за исключением методов построения теней, для которых за основу был взят проект ShadowMap). Многие текстуры были взяты из NVIDIA SDK. Использовались следующие инструменты: Visual C++ 6.0, Visual Studio 2003, Visual Studio 2008, DirectX SDK April 2007, DirectX SDK August 2007, DirectX SDK March 2008, NVIDIA SDK 9.5, NVIDIA NVPerfHUD 4.1.


2.1. Развитие методов parallax occlusion mapping

Прежде всего, были реализованы несколько методов улучшения детализации поверхностей: normal mapping, две разновидности parallax mapping, parallax occlusion mapping. Две реализации parallax mapping отличаются друг от друга тем, что в одной для вычисления текстурных координат TS` используется пересечение плоскости, проходящей через точку G параллельно касательной плоскости, с вектором наблюдения V (как на ), а во второй – пересечение сферы с центром в обрабатываемом пикселе и радиусом, равным значению высоты точки G. В первом случае требуется одно деление, одно умножение и одно сложение, а во втором – нормирование вектора V, одно умножение и одно сложение (см. Приложение 1). Но вектор V в любом случае требуется нормировать для вычисления освещения, поэтому второй метод несколько более производительный. Кроме того, в случаях, когда вектор V почти параллелен касательной плоскости,  использование первого метода приводит к сильным искажениям из-за слишком большого смещения текстурных координат.

На  показан результат отображения плоскости (два треугольника) без применения каких-либо методов улучшения детализации поверхности. Далее показаны методы normal mapping () и parallax mapping (). На  показаны искажения, вносимые методом parallax mapping при достаточно больших локальных изменениях высоты.

рис.  

рис.  

рис.  

рис.  

В предлагаемой реализации parallax occlusion mapping, в отличие от других подобных методов, например, relief mapping [], возможны два направления линейного поиска: вверх и вниз. Для нахождения пересечения вектора V с поверхностью используется направление вниз. Далее, если источник света находится над поверхностью, пересечение вектора, направленного на источник света, с поверхностью (с целью определить, находится ли точка в тени) определяется с помощью линейного поиска вверх. Это можно было реализовать с помощью поиска вниз в направлении от источника света к исследуемой точке, как это сделано в методе relief mapping. Но трассировка вверх понадобится для построения отражений (если вектор отражения направлен вверх). Результат можно посмотреть на .

рис.  




2.1.1. Вычисление градиентов

рис.  

Для корректной фильтрации текстур и выбора уровня детализации требуются градиенты текстурных координат. На  изображен пиксель в пространстве текстурных координат. ddx – вектор производных текстурных координат вдоль оси x пространства изображения, а ddy – вдоль y. Эти векторы позволяют определить, какие элементы текстуры вносят вклад в обрабатываемый пиксель и выполнить фильтрацию. В стандартных функциях выборки текстур градиенты вычисляются автоматически с помощью метода конечных разностей (берутся значения текстурных координат в соседних пикселях). Обычно такой метод дает достаточно точное приближение градиентов. Но на границах объектов происходит разрыв текстурных координат, в соседних пикселях значения текстурных координат сильно различаются. Это приводит к неправильному вычислению градиентов и некорректной фильтрации текстур, что проявляется в виде отдельных точек на силуэтах объектов ().

рис.  

В некоторых реализациях [] градиенты  вычисляются на основе немодифицированных текстурных координат (т.е. из базовой плоскости). Это позволяет избежать разрывов текстурных координат и точек на силуэтах (), но внутри объектов градиенты оказываются неправильными. В результате из-за неправильного выбора уровня детализации и фильтрации на одних участках может возникнуть алиасинг (если используется более высокий уровень детализации, чем требуется), на других – потеря четкости (в противоположном случае).

рис.  

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

Следующие иллюстрации показывают преимущества предлагаемого метода: на  показан результат использования стандартного метода вычисления градиентов (есть точки на границах объектов); на  используется метод вычисления градиентов на основе немодифицированных текстурных координат (точек нет, но задняя стенка оказалась размытой);  иллюстрирует применение предложенного метода (точек нет, задняя стенка не размыта).

рис.  

рис.  

рис.  


2.1.2. Построение отражений

Отражения в предлагаемом алгоритме реализуются следующим образом. После того, как было найдено пересечение S вектора V с поверхностью и определено, находится ли точка S в тени, вычисляется вектор отражения R и выполняется трассировка в карте высот в направлении от точки S вдоль вектора R.

Если пересечение SR с поверхностью найдено, в точке S отражается сама поверхность (точка SR). В этом случае вычисляется цвет точки SR. Для этого берется значение из диффузной текстуры по смещенным координатам (соответствующим точке SR), вычисляется нормаль. Затем выполняется трассировка в направлении источника света для определения самозатенения и вычисляется освещение точки SR.

Если пересечение при трассировке вдоль вектора V не было найдено, в точке S отражается окружающая среда, а не поверхность. Чтобы получить отражение окружающей среды, используется значение из кубической текстуры. Эта идея используется в методе локальной трассировки лучей.

На  показан результат с отключенными отражениями. Далее добавляются отражения с коэффициентом отражения 50% () и 100% ().

рис.  

рис.  

рис.  


2.1.3. Вычисление нормалей

Во многих алгоритмах улучшения детализации поверхностей, основанных на трассировке в карте высот, при расчете освещения пикселя нормаль берется из карты нормалей. Но в предлагаемом алгоритме нормаль используется еще и для вычисления вектора отражения R, поэтому требования к точности нормалей усиливаются. В данной реализации использовались текстуры, у которых в первых трех (или двух) компонентах хранились нормали, а в четвертой – высота. Но эти текстуры задавались в неизвестном касательном пространстве, связь между нормалями и высотой (коэффициент масштабирования, который использовался при построении карты нормалей) тоже неизвестна. Предпринимались попытки подобрать коэффициент масштабирования нормалей вдоль оси z касательного пространства, но соответствие с картой высот так и не было достигнуто (кроме того, этот коэффициент может быть разным для разных текстур). Это приводит к неправильному вычислению вектора отражения, что в свою очередь является причиной некорректных отражений. Ниже приведен соответствующий пример (). Отражения от горизонтальной плоскости рассчитываются верно (там координаты x и y нормали равны нулю, и коэффициент масштабирования вдоль оси z не влияет на направление нормали), но на боковых стенках отчетливо видны искажения.

рис.  

Для решения этой проблемы нормали брались не из карты нормалей, а вычислялись методом дифференцирования карты высот. Сначала был реализован метод дифференцирования по трем выборкам из карты высот: центральный элемент текстуры (C), справа от него (R) и сверху (U) (). Частная производная функции высоты по координате x аппроксимировалась разницей между значениями высоты в элементах R и C, а по координате y – разницей между U и C. Но такой способ получения нормалей принес другие проблемы (). Для сравнения на  приведен результат при использовании карты нормалей.

рис.  

рис.  

рис.  

После этого был реализован метод дифференцирования по четырем выборкам: справа (R), слева (L), сверху (U) и снизу (D) от центрального элемента (C) (). Частные производные по x и y аппроксимировались разностями между элементами R, L и U, D соответственно. Результат показан на .

рис.  

рис.  

Также был попробован метод дифференцирования на основе восьми выборок []. К четырем выборкам из предыдущего метода добавилось еще четыре выборки, расположенные на диагоналях. На  показаны весовые коэффициенты для дифференцирования по x, а на  – по y. Но это по-прежнему не решало проблему ().

рис.  

рис.  

рис.  

Позже было выяснено, что проблема была вызвана недостаточно качественной картой высот: значения в карте высот менялись слишком дискретно, были области с одинаковым значением высоты, которое резко менялось на другое. В таких областях с одинаковым значением методы дифференцирования высоты давали нормаль, направленную вдоль оси z, там, где она должна быть направлена по-другому (), что и приводило к дефектам в виде отдельных точек.

рис.  

Проблему удалось решить, увеличив шаг дифференцирования. При увеличении шага дифференцирования соседние выборки оказываются в областях с разным значением высоты, в результате чего вычисляется нормаль, направленная не вдоль оси z (), и удается избежать дефектов.

рис.  

Результаты для шага дифференцирования, равного 5, показаны на (3 выборки),  (4 выборки) и  (8 выборок).

рис.  

рис.  

рис.  

Использование слишком большого шага дифференцирования приводит к другим искажениям. Примеры таких искажений демонстрируются для шага дифференцирования, равного 32, на  (3 выборки),  (4 выборки) и  (8 выборок).

рис.  

рис.  

рис.  


2.1.4. Определение числа итераций

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

Первое время для определения числа итераций использовался подход, применяемый в других реализациях трассировки в карте высот: задается минимальное и максимальное число итераций, после чего осуществляется интерполяция между ними. В качестве параметра интерполяции используется координата z нормированного вектора, вдоль которого выполняется трассировка. Таким образом, для вектора, перпендикулярного касательной плоскости, выполняется минимальное число итераций, а для почти параллельного – почти максимальное, что соответствует требованиям. Сначала такой подход использовался и для линейного поиска, и для бинарного. На  показана визуализация общего числа итераций (включая итерации для построения теней и отражений). Чем ярче пиксель, тем больше для него выполнялось итераций.

рис.  

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

Несмотря на то, что рассмотренный подход подбирает число итераций в зависимости от направления вектора трассировки, у него есть недостатки. Например, для вектора, перпендикулярного касательной плоскости, можно выполнить только одну итерацию, переместившись на максимальную глубину, так как для такого вектора существует только одно пересечение с поверхностью, и его можно найти с помощью гораздо более быстрого бинарного поиска. А для вектора, почти параллельного касательной плоскости, шаг линейного поиска должен быть гораздо меньше (соответственно число итераций должно быть гораздо больше). Но если указать максимальное число итераций очень большим, то для промежуточных углов наклона вектора число итераций будет быстро увеличиваться, даже если минимальное число итераций установить равным 1. Таким образом, данный подход обеспечивает не очень оптимальное распределение числа итераций в зависимости от угла наклона вектора трассировки. Поэтому был придуман новый метод. В отличие от предыдущего, он вычисляет не число итераций, а связанную с ним величину шага поиска. Для этого сначала задается число элементов карты высот, которое хотелось бы проходить за одну итерацию. Величина шага затем вычисляется таким образом, чтобы проекция шага на касательную плоскость по каждому направлению (x и y) не превосходила указанного числа. Также обеспечивается, чтобы проекция шага на ось z не превосходила максимальной высоты (это возможно для почти перпендикулярных к касательной плоскости векторов). На следующих рисунках показана визуализация числа итераций для разных углов наклона вектора трассировки. Видно, что для почти перпендикулярного вектора () число итераций значительно меньше, чем для вектора, близкого к параллельному ().

рис.  

рис.  


2.1.5. Проблема ошибочных самозатенений

Используемому методу построения теней присуща проблема ошибочных самозатенений, которая характерна также для алгоритмов shadow mapping. Эта проблема проявляется в виде затенения некоторых точек, которые не должны находиться в тени. Это происходит из-за того, что в некоторых случаях алгоритм нахождения пересечения вектора наблюдения V с поверхностью возвращает точку S`, расположенную немного под поверхностью. Затем, в ходе трассировки от точки S` вдоль вектора L, направленного на источник света, находится пересечение SL с поверхностью (), в результате чего алгоритм ошибочно считает, что точка S находится в тени. Помимо ошибочного затенения это приводит еще и к тому, что в точке S (аппроксимированной S`) будет отражаться точка SR, полученная при трассировке от S` вдоль вектора отражения R ().

рис.  

Напрашивается очевидное решение проблемы – сместить точку S` вдоль вектора V на небольшую величину перед тем, как осуществлять трассировки вдоль векторов L и R (). В приведенном примере при трассировке от смещенной точки S`` вдоль векторов L и R пересечений с поверхностью найдено не будет, в результате чего обрабатываемая точка не будет затенена, и в ней будет отражаться окружающая среда, а не сама поверхность.

рис.  

Несмотря на кажущуюся простоту такого способа, существует одна сложность – определение величины смещения. Если она слишком маленькая – точка S`` останется под поверхностью и проблемы останутся, если слишком большая – появятся другие проблемы (отставание теней от отбрасывающих их объектов, некорректные отражения).

В первой реализации использовалось фиксированное смещение. Как оказалось, такой способ иногда может только добавить проблем. На  показан пример такой ситуации. В процессе линейного поиска мелкий выступ был пропущен, а после бинарного поиска последняя аппроксимация S` оказалась над поверхностью. Если не делать никакого смещения, то в данном случае все будет нормально (точка не будет считаться затененной, а отражаться в ней будет окружающая среда). Но если выполнить смещение на неудачную для данной ситуации величину, то возникнут упоминаемые выше проблемы.

рис.  

Далее иллюстрируется пример практического возникновения описанной выше ситуации. На  не выполняется никакого смещения, и в то же время не возникает ошибочного самозатенения. При добавлении небольшого смещения начинают появляться дефекты (слева). На  приведен результат для коэффициента смещения, равного 0.002. При дальнейшем увеличении величины смещения дефекты исчезают. На  используется коэффициент, равный 0.01. Таким образом, для данной ситуации подходят первый и третий варианты величины смещения. Но для других углов зрения и направлений источника света такие варианты могут привести к неудовлетворительным результатам. Для первого варианта (отсутствие смещения) вероятно возникновение ошибочных самозатенений. В третьем варианте используется достаточно большое смещение, что может привести к заметному отставанию теней от отбрасывающих их объектов.

рис.  

рис.  

рис.  

Позже был реализован другой способ выбора величины смещения. Длина вектора смещения выбиралась кратной длине шага линейного поиска. При этом смещение выполнялось относительно точки, полученной в результате выполнения линейного поиска (без уточнения бинарным поиском). В случае не очень большого смещения и достаточного числа итераций линейного поиска гарантируется, что смещенная точка совпадет с точкой, полученной на одной из итераций линейного поиска (за исключением последней). А это в свою очередь гарантирует, что смещенная точка окажется над поверхностью (в противном случае линейный поиск закончился бы раньше – в смещенной точке), благодаря чему удается избежать ошибочных самозатенений.

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

Для решения проблемы некоторое время использовалась модификация приведенного выше метода. Длина вектора смещения выбиралась кратной длине последнего шага бинарного поиска, а не линейного. Кроме того, смещение выполнялось относительно уточненной бинарным поиском точки. При большом числе итераций бинарного поиска смещение оказывается слишком маленьким (точка оказывается слишком близко к поверхности, а также начинает проявляться конечность точности вычислений). Если для смещения использовать большой множитель для устранения названной проблемы, точка может не совпадать ни с одной из точек, полученных в процессе линейного поиска, и возможно возникновение ситуации, проиллюстрированной на .

В конечном варианте использовался следующий подход. Сначала в качестве смещенной точки выбирается точка из предпоследней итерации линейного поиска. Если бинарный поиск не выполняется (когда точка, из которой начинался линейный поиск, лежит на поверхности; в этом случае применение бинарного поиска приводит к некорректным результатам), то смещение не меняется. В противном случае при осуществлении бинарного поиска на каждой итерации выполняется следующие действия. Если текущая точка находится выше поверхности и расстояние до поверхности больше некоторого значения (g_max_raytrace_bias), то текущая точка запоминается в качестве смещенной. Сравнение расстояния до поверхности с величиной g_max_raytrace_bias выполняется для того, чтобы точка не оказалась слишком близко к поверхности (одна из проблем предыдущего метода). Стоит отметить, что в итоге расстояние от смещенной точки до поверхности может оказаться как меньше, чем g_max_raytrace_bias (только в том случае, когда расстояние уже от первой смещенной точки (из предпоследней итерации линейного поиска) меньше, чем g_max_raytrace_bias), так и больше (в остальных случаях). Ниже приведен окончательный на данный момент вариант процедуры бинарного поиска.


void BinarySearch(inout float3 dir, inout float3 delta, inout float3 offset, out float3 offset_back, in float2 uv, in float2 dx, in float2 dy, in int binary_search_steps, inout int steps)

{

offset_back = offset - delta;

if (start_diff != 0)

{

 float delta_len = length(delta);

 for (int cur_step = 0; cur_step < binary_search_steps; cur_step++)

 {

  delta *= 0.5;

  if ((tex2Dgrad(NormalHeightTextureSampler, uv + offset, dx, dy).w * g_max_height - offset.z) * start_diff > 0)

  {

   // outside

   if (delta_len > g_max_raytrace_bias)

    offset_back = offset;

   offset += delta;

  }

  else

   // inside

   offset -= delta;

  delta_len *= 0.5;

 }

 steps += binary_search_steps;

}

}


2.2. Метод локальной трассировки лучей

Сначала выполняется стандартная аппаратная растеризация треугольника с удалением невидимых точек при помощи буфера глубины. Для каждого пикселя ищется пересечение с другими треугольниками в пределах одного объекта (а не всей сцены, как в классической трассировке) в направлении источника света. Если пересечение найдено, пиксель находится в тени. Затем ищется пересечение вдоль отраженного луча. Если оно существует, то выбирается значение цвета из текстуры (текстурные координаты вычисляются на основе барицентрических координат, которые вычисляются в процессе поиска пересечения луча) и снова выполняется трассировка в направлении источника света для определения затенения отраженной точки. Если пересечения вдоль отраженного луча не существует, берется значение из кубической карты. Этот алгоритм устраняет один из основных недостатков построения отражений с помощью кубических текстур – отсутствие самоотражений, которые возможны на невыпуклых объектах. Благодаря тому, что трассировка выполняется для одного объекта, а не для всей сцены, этот алгоритм работает существенно быстрее классической трассировки лучей, и его можно эффективно реализовать на графических процессорах.

Ниже показывается сравнение стандартного метода построения отражений, основанного на применении кубических текстур, с предлагаемым алгоритмом. На  для построения отражений используется только кубическая текстура. Из-за этого в местах, где должен отражаться сам объект, отражается окружающая среда. На  к кубическим текстурам добавляется локальная трассировка лучей, благодаря чему корректно воспроизводятся самоотражения. К сожалению, для этого примера пришлось отключить тени в отражении, поскольку в противном случае получались некорректные результаты. Скорее всего, это происходит из-за ошибки компилятора HLSL или рекомпилятора шейдеров в драйвере. В режиме программной эмуляции  (при использовании устройства D3DDEVTYPE_REF) проблем не возникало, и тени в отражении правильно отображались.

рис.  

рис.  


2.2.1. Пространство, в котором вычисляется освещение

Результаты расчета освещения зависят от того, в каком пространстве (системе координат) оно вычисляется. Если системы координат связаны не ортогональными преобразованиями, углы между одними и теми же векторами в разных системах координат будут разными. Из-за этого разными будут и результаты расчета освещения (поскольку они зависят от углов между направлением наблюдения, нормалью, направлением света). Обычно правильными считаются результаты, полученные в пространстве наблюдателя (т.е. после применения к объекту мировых и видовых преобразований, но до проецирования) [, ]. На практике освещение рассчитывается в том пространстве, в котором это удобнее или эффективнее реализовать. Если преобразования из используемого пространства в пространство наблюдателя ортогональное, то результаты будут правильными.

В предлагаемых реализациях (это относится не только к локальной трассировки лучей, но и к методам из предыдущей главы) освещение рассчитывается в мировой системе координат. Поскольку система координат наблюдателя получается из мировой применением поворотов и переносов (т.е. ортогональных преобразований), освещение рассчитывается корректно.


2.2.2. Вычисление вектора отражения

Вектор отражения тоже зависит от того, в каком пространстве его вычислять. Также как и освещение, он рассчитывался в мировом пространстве.

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

рис.  

Рассмотрим систему координат S2, переход в которую осуществляется линейным преобразованием сдвига (или скоса) []:

x = x + y

y = y

Векторы, параллельные оси x (у которых координата y нулевая) не меняются после такого преобразования. На  показан случай, когда вектор отражения рассчитывается в системе координат S1, после чего применяется указанное выше преобразование.

рис.  

Если сначала перейти в систему координат S2, и уже в ней вычислить вектор отражения, то результат будет другим ().

рис.  

Существует еще одна деталь в вопросе вычисления вектора отражения. Можно рассчитывать его для каждого пикселя, а можно для каждой вершины. Во втором варианте для значений в пикселях используется линейная интерполяция (на практике линейная интерполяция в пространстве наблюдателя (или любом другом до проецирования) заменяется на гиперболическую в пространстве после деления на w (например, в пространстве изображения) [], которая осуществляется аппаратно во время растеризации).

Формула для вычисления вектора отражения имеет вид R = 2 * (V, N) * NV [, , ] (предполагается, что длина вектора N равна 1). Несложно заметить, что R зависит линейно от V. Но N входит нелинейно. Это может привести к неправильным результатам при использовании линейной интерполяции. Пример возникновения такой ситуации приводится ниже.

Пусть для двух вершин вектор направления взгляда V один и тот же (это случается в случае использования ортогональной проекции), а векторы нормали – разные ().

рис.  

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

Первым рассмотрим вариант с использованием интерполяции. Сначала надо вычислить векторы отражений в каждой вершине. В первой вершине получим вектор R1, а во второй – R2 (). Несложно видеть, что R1 = -R2. После выполнения линейной интерполяции с коэффициентом 0.5 получим, что вектор отражения в промежуточной точке R` = 0. На  показан результат для попиксельного вычисления (N` – интерполированная нормаль). Видно, что вектор R` получился ненулевым.

рис.  

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


2.3. Исследование методов теневых буферов


2.3.1. Устранение ошибок передискретизации

В статье [] кратко рассматривается метод устранения ошибок передискретизации, которые приводят к ошибочным самозатенениям (). Он заключается в применении билинейной интерполяции к значениям из теневого буфера (буфера глубины, сформированного на этапе рисования сцены с позиции источника света). Этот метод основан на том, что если четыре точки лежат на одной плоскости, то в результате билинейной интерполяции получаются точки, которые тоже лежат на этой плоскости []. Это позволяет решить проблему передискретизации внутри треугольников, но на их границах выборки из четырех соседних элементов теневого буфера могут принадлежать разным треугольникам и, соответственно, разным плоскостям. Также в статье [] отмечается, что этот метод не будет работать в случае гиперболического распределения глубины (которое возникает из-за перспективной проекции при использовании точечных источников света).

рис.  

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

рис.  

В ходе исследований данного метода было обнаружено, что он несколько скругляет границы теней. На  показан результат стандартного варианта, на  – исследуемого метода. Конечно, этот метод не может заменить такие алгоритмы смягчения границ теней, как Percentage Closer Filtering (PCF), но все же делает границы более сглаженными.

рис.  

рис.  


2.3.2. Устранение проективного алиасинга

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

В данной работе предлагается простой метод устранения проективного алиасинга, который легко реализовать на графических процессорах. Если треугольник расположен почти параллельно направлению света, то он считается затененным. Для того, чтобы избежать резких изменений затененности в граничных положениях, используется кубическая интерполяция. Доступ к целым примитивам (а не отдельным вершинам или пикселям) есть в Direct3D 10 [, , ]. Но реализация этого метода осуществлялась в Direct3D 9, поэтому проверки параллельности выполнялись для каждого пикселя. Для этого вычисляется градиент значения глубины в пространстве источника света. Если величина градиента оказывается большой (в качестве нормы используется сумма модулей), то глубина меняется быстро, и пиксель считается затененным. Графический процессор позволяет вычислять градиенты в пространстве изображения. Для перевода градиентов из пространства изображения в пространство источника света используется метод, предложенный в статье [].

При реализации этого метода возникла проблема. Если точка наблюдения находится близко от участка поверхности, расположенного далеко от точечного источника света, то в случае гиперболического распределения глубины значения глубины в соседних пикселях почти одинаковые. Точности представления чисел с плавающей точкой (32 бита) оказывается недостаточно, чтобы различить эти значения, в результате чего градиенты получаются нулевыми. Это приводит к появлению отдельных освещенных пикселей (точнее, групп из четырех пикселей, поскольку из-за особенностей вычисления градиентов на графических процессорах в пределах таких фрагментов градиенты одинаковые), в то время как большая часть поверхности считается затененной (). Эту проблему удалось решить, заменив гиперболическое распределение глубины на линейное. Но после этого возникла другая проблема – при приближении источника света снова появляется проективный алиасинг.

рис.  

Ниже приведены результаты. На  иллюстрируется проективный алиасинг. На  он устранен описанным методом. При приближении источника света алиасинг возвращается ().

рис.  

рис.  

рис.  


Заключение

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

Простые методы улучшения детализации поверхностей, такие как bump mapping и parallax mapping, давно применяются на практике. В последнее время все чаще начинают использоваться гораздо более сложные методы, например parallax occlusion mapping, displacement mapping. У пиксельных методов, основанных на трассировке в карте высот, есть преимущество перед геометрическими методами, применяющими тесселяцию – автоматическая настройка уровня детализации. Чем ближе объект, тем больше пикселей получается при растеризации, и при использовании пиксельных методов для близких объектов автоматически выполняется больше расчетов. Чтобы добиться аналогичного результата для геометрических методов, приходится использовать специальные методы адаптивной тесселяции, которые определяют участки, для которых требуется увеличить детализацию (например, близко расположенные к точке наблюдения), и увеличивают для них геометрическую детализацию.

В работе предлагается развитие алгоритмов, использующих трассировку в карте высот. Рассматриваются методы вычисления градиентов текстурных координат (для устранения точек на границах объектов), построения отражений, определения числа итераций (для настройки уровня детализации), а также устранения ошибочных самозатенений и самоотражений.

Для построения отражений на сложных объектах в реальном времени обычно используется метод кубического текстурирования. Но такой метод приводит к некорректным результатам для невыпуклых объектов, поскольку он не позволяет получить самоотражения. Алгоритм трассировки лучей приводит к сильному снижению производительности. К тому же его сложнее реализовать на графических процессорах из-за того, что ему требуется доступ ко всей сцене.

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

Метод теневых буферов – самый распространенный алгоритм построения теней в реальном времени. В работе анализируется метод устранения ошибок передискретизации, предложенный в статье [].

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

Помимо описанных алгоритмов проводились исследования в области рисования символов. Основная идея была предложена сотрудником ИММ УрО РАН Бахтеревым М.О.

Символы рисуются с помощью горизонтальных и вертикальных линий. При масштабировании используется промежуточный растр высокого разрешения (произведение исходного и целевого разрешений или их наименьшее общее кратное), сдвиги и эллипсы для плавного перехода между линиями (везде используются целочисленные алгоритмы Брезенхема). Если в группе пикселей промежуточного растра, соответствующей конечному пикселю, присутствует хотя бы один пиксель, имеющий цвет символа, конечный пиксель закрашивается.

Также вместо эллипсов исследовался вариант использования кривых Безье второй степени с аппаратным сглаживанием в OpenGL.

Возможно дальнейшее развитие предложенных методов. Для устранения одного из недостатков методов улучшения детализации поверхностей, использующих трассировку в карте высот, перед геометрическими методам – отсутствие деталей на силуэтах объектов, можно использовать подход, который описывается в [, , ]. Также можно увеличить глубину трассировки и добавить преломления. Это относится и к алгоритму локальной трассировки лучей.

Метод устранения проективного алиасинга, свойственного алгоритму теневых буферов, можно реализовать, проводя вычисления для треугольников, а не для каждого пикселя. Такая возможность появилась в Direct3D 10 [, , ]. Еще можно рассмотреть другие нормы для градиентов. Также можно попробовать оценить область, которую занимает проекция элементы теневого буфера в текстурном пространстве объекта с равномерной параметризацией, используя методы, которые применяются для вычисления уровня детализации для текстур [].


Список литературы

  1.  Гайдуков С. А. OpenGL. Профессиональное программирование трехмерной графики на C++. – СПб.: БХВ-Петербург, 2004. – 736 с.
  2.  Порев В. Н. Компьютерная графика. – СПб.: БХВ-Петербург, 2004. – 432 с.
  3.  Тихомиров Ю. В. OpenGL. Программирование трехмерной графики. – 2-е изд. – СПб.: БХВ-Петербург, 2002. – 304 с.
  4.  Р. Гонсалес, Р. Вудс. Цифровая обработка изображений. – Москва: Техносфера, 2005 – 1072 с.
  5.  Mark Segal, Kurt Akeley. The OpenGL Graphics System: A Specification (Version 1.5) Editor(version 1.1): Chris Frazier. Editor (versions 1.2, 1.21, 1.3, 1.4, 1.5): Jon Leech.
  6.  Neider J. Davis T.  OpenGL Programming Guide.
  7.  Samuel R. Buss. 3-D computer graphics. A mathematical introduction with OpenGL.
  8.  Eric Lengyel. Mathematics for 3D Game Programming and Computer Graphics, Second Edition.
  9.  DirectX SDK Documentation (March 2008).
  10.  David Blythe. Direct3D 10. SIGGRAPH 2006. Microsoft Corporation.
  11.  David Blythe. The Direct3D 10 System. Microsoft Corporation.
  12.  Xi Wangy, Xin Tong, Stephen Lin, Shimin Hu, Baining Guo, Heung-Yeung Shum. Generalized Displacement Maps. Tsinghua University. Microsoft Research Asia.
  13.  Markus Fahlen. Illumination for Real-Time Rendering of Large Architectural Environments.
  14.  Lars Peter Gamsbøl Christiansen. Implementing and Combining Light, Shadows and Reflections in 3D Engines. Technical University of Denmark. 2005.
  15.  Gregory S. Johnson, Ikrima Elhassan. Irregular Shadow Maps. Department of Computer Sciences. The University of Texas at Austin.
  16.  Thomas Annen. Advanced Shadow Map Parameterization.
  17.  Michael Wimmer, Daniel Scherzer and Werner Purgathofer. Light Space Perspective Shadow Maps. Eurographics Symposium on Rendering (2004).
  18.  Tom Lokovic, Eric Veach. Deep Shadow Maps. Pixar Animation Studios.
  19.  Hamilton Yu-Ik Chong. Real-Time Perspective Optimal Shadow Maps.
  20.  John R. Isidoro. Shadow Mapping: GPU-based Tips and Techniques. ATI Research. 3D Applications Research Group. Game Developers Conference 2006.
  21.  William Donnelly, Andrew Lauritzen. Variance Shadow Maps. Computer Graphics Lab, School of Computer Science, University of Waterloo.
  22.  Fan Zhang, Leilei Xu, Chenjun Tao, Hanqiu Sun. Generalized Linear Perspective Shadow Map Reparameterization. The Chinese University of Hong Kong.
  23.  Marc Stamminger and George Drettakis. Perspective Shadow Maps. REVES - INRIA Sophia-Antipolis, France.
  24.  Tobias Martin and Tiow-Seng Tan. Anti-aliasing and Continuity with Trapezoidal Shadow Maps. School of Computing, National University of Singapore. Eurographics Symposium on Rendering (2004).
  25.  Daniel Scherzer. Robust Shadow Maps for Large Environments. Institute of Computer Graphics. Vienna University of Technology. Austria.
  26.  Gary King. Shadow Mapping Algorithms. NVIDIA Corporation.
  27.  Cass Everitt. Shadow Mapping. NVIDIA Corporation.
  28.  Cass Everitt. Mathematics of Per-Pixel Lighting. NVIDIA Corporation.
  29.  Cass Everitt. Projective Texture Mapping. NVIDIA Corporation.
  30.  Kirill Dmitriev, Yury Uralsky. Soft shadows using hierarchical min-max shadow maps. NVIDIA Corporation. Game Developers Conference 2007.
  31.  Louis Bavoil. Advanced Soft Shadow Mapping Techniques. NVIDIA Corporation. Game Developers Conference 2008.
  32.  Simon Kozlov. Perspective Shadow Maps: Care and Feeding. GPU Gems.
  33.  William Donnelly, University of Waterloo. Per-Pixel Displacement Mapping with Distance Functions. GPU Gems 2.
  34.  Yury Uralsky, NVIDIA Corporation. Efficient Soft-Edged Shadows Using Pixel Shader Branching. GPU Gems 2.
  35.  Fabio Policarpo, Perpetual Entertainment; Manuel M. Oliveira, Instituto de Informática—UFRGS. Relaxed Cone Stepping for Relief Mapping. GPU Gems 3.


Приложение 1


character.h

#pragma once

#include "ScalarTypes.h"

struct character {

int *lines;

scalar *curves;

int numLines;

int numCurves;

};

extern scalar line_offset, curve_offset;


fonts.h

#pragma once

#include "ScalarTypes.h"

struct character {

scalar *lines;

scalar *curves;

int numLines;

int numCurves;

};


FrameBuffer.h

#pragma once

#include <windows.h>

#include "fonts.h"

extern bool draw_curve, color_curve;

inline unsigned long RGBA(unsigned char R, unsigned char G, unsigned char B, unsigned char A=0) {

return B | G << 8 | R << 16 | A << 24;

}

inline unsigned char GetR(unsigned long color) {

return (unsigned char)(color >> 16 & 0x000000FF);

}

inline unsigned char GetG(unsigned long color) {

return (unsigned char)(color >> 8 & 0x000000FF);

}

inline unsigned char GetB(unsigned long color) {

return (unsigned char)(color & 0x000000FF);

}

inline unsigned char GetA(unsigned long color) {

return (unsigned char)(color >> 24 & 0x000000FF);

}

class FrameBuffer {

int width, height;

unsigned long *pImage;

BITMAPINFO bi;

public:

FrameBuffer() {

 width=height=0;

 pImage=NULL;

 bi.bmiHeader.biSize=sizeof(BITMAPINFO);

 bi.bmiHeader.biWidth=width;

 bi.bmiHeader.biHeight=height;

 bi.bmiHeader.biPlanes=1;

 bi.bmiHeader.biBitCount=32;

 bi.bmiHeader.biCompression=BI_RGB;

 bi.bmiHeader.biSizeImage=0;

 bi.bmiHeader.biXPelsPerMeter=0;

 bi.bmiHeader.biYPelsPerMeter=0;

 bi.bmiHeader.biClrUsed=0;

 bi.bmiHeader.biClrImportant=0;

 bi.bmiColors[0].rgbBlue=0;

 bi.bmiColors[0].rgbGreen=0;

 bi.bmiColors[0].rgbRed=0;

 bi.bmiColors[0].rgbReserved=0;

}

void Init(int width, int height) {

 FrameBuffer::width=bi.bmiHeader.biWidth=width;

 FrameBuffer::height=bi.bmiHeader.biHeight=height;

 if (pImage)

  delete[] pImage;

 pImage=new unsigned long[width*height];

}

inline int GetWidth() {

 return width;

}

inline int GetHeight() {

 return height;

}

unsigned long ReadPixel(int x, int y) {

 return x >= 0 && x < width && y >=0 && y < height ? pImage[x+y*width] : 0;

}

void WritePixel(int x, int y, unsigned long color) {

 if (x >= 0 && x < width && y >=0 && y < height)

  pImage[x+y*width]=color;

}

void Line(int x0, int y0, int x1, int y1, unsigned long color) {

 int

  xerr=0, yerr=0,

  dx=x1-x0, dy=y1-y0,

  incX=dx >= 0 ? 1 : -1, incY=dy >= 0 ? 1 : -1,

  d, half_d;

 dx=abs(dx);

 dy=abs(dy);

 d=dx >= dy ? dx : dy;

 half_d=d>>1;

 for (int i=d; i > 0; i--) {

  WritePixel(x0, y0, color);

  xerr+=dx;

  yerr+=dy;

  if (xerr > half_d) {

   xerr-=d;

   x0+=incX;

  }

  if (yerr > half_d) {

   yerr-=d;

   y0+=incY;

  }

 }

 WritePixel(x0, y0, color);

}

void Bezier(Vector p0, Vector p1, Vector p2, unsigned long color, unsigned depth = 4) {

 if (depth-- > 0) {

  Vector

   r0=(p0+p1)/2,

   r1=(p1+p2)/2,

   s0=(r0+r1)/2;

  Bezier(p0, r0, s0, color, depth);

  Bezier(s0, r1, p2, color, depth);

 }

 else {

  p0.homogenize3();

  p2.homogenize3();

  Line((int)floor(p0.X), (int)floor(p0.Y), (int)floor(p2.X), (int)floor(p2.Y), color);

 }

}

void DrwaChar(character const *ch, unsigned long color, scalar scale_x, scalar scale_y) {

 register int idx;

 if (ch->lines)

  for (idx = 0; idx < ch->numLines; idx++)

   Line(int(ch->lines[idx*4+0]*scale_x), int(ch->lines[idx*4+1]*scale_y), int(ch->lines[idx*4+2]*scale_x), int(ch->lines[idx*4+3]*scale_y), color);

 if (ch->curves && draw_curve)

  for (idx = 0; idx < ch->numCurves; idx++)

   Bezier(

    Vector(floor(ch->curves[idx*0xf+0x0]*scale_x/ch->curves[idx*0xf+0x4])*ch->curves[idx*0xf+0x4]+ch->curves[idx*0xf+0x1], floor(ch->curves[idx*0xf+0x2]*scale_y/ch->curves[idx*0xf+0x4])*ch->curves[idx*0xf+0x4]+ch->curves[idx*0xf+0x3], 0.0, ch->curves[idx*0xf+0x4]),

    Vector(floor(ch->curves[idx*0xf+0x5]*scale_x/ch->curves[idx*0xf+0x9])*ch->curves[idx*0xf+0x9]+ch->curves[idx*0xf+0x6], floor(ch->curves[idx*0xf+0x7]*scale_y/ch->curves[idx*0xf+0x9])*ch->curves[idx*0xf+0x9]+ch->curves[idx*0xf+0x8], 0.0, ch->curves[idx*0xf+0x9]),

    Vector(floor(ch->curves[idx*0xf+0xa]*scale_x/ch->curves[idx*0xf+0xe])*ch->curves[idx*0xf+0xe]+ch->curves[idx*0xf+0xb], floor(ch->curves[idx*0xf+0xc]*scale_y/ch->curves[idx*0xf+0xe])*ch->curves[idx*0xf+0xe]+ch->curves[idx*0xf+0xd], 0.0, ch->curves[idx*0xf+0xe]),

    color_curve ? RGBA(0, 255, 0, 0) : color

   );

}

void BitBlt(HDC hdc) {

 SetDIBitsToDevice(hdc, 0, 0, width, height, 0, 0, 0, height, pImage, &bi, DIB_RGB_COLORS);

}

void BitBlt(HDC hdc, RECT &rt) {

 SetDIBitsToDevice(hdc, rt.left, rt.top, rt.right-rt.left, rt.bottom-rt.top, rt.left, rt.top, rt.top, rt.bottom-rt.top, pImage, &bi, DIB_RGB_COLORS);

}

void Clear(unsigned long color=0) {

 register unsigned long *cur=pImage, *end=pImage+width*height;

 while (cur != end)

  *cur++=color;

}

friend FrameBuffer *Up(const FrameBuffer &fb, unsigned int X, unsigned int Y) {

 FrameBuffer *UpBuffer=new FrameBuffer;

 UpBuffer->Init(fb.width*X, fb.height*Y);

 register int curY=UpBuffer->height;

 while (curY--) {

  register int curX=UpBuffer->width;

  while (curX--)

   UpBuffer->pImage[curX+curY*UpBuffer->width]=fb.pImage[curX/X+curY/Y*fb.width];

 }

 return UpBuffer;

}

friend void Down(const FrameBuffer &fb, unsigned int X, unsigned int Y){

}

friend void Copy(FrameBuffer &dst, const FrameBuffer &src,

 int dstX, int dstY,

 int srcX, int srcY,

 int width, int height) {

 register int curY=height;

 while (curY--)  {

  register int curX=width;

  while (curX--)

   dst.pImage[dstX+curX+(dstY+curY)*dst.width]=src.pImage[srcX+curX+(srcY+curY)*src.width];

 }

}

~FrameBuffer() {

 width=height=0;

 memset(&bi, 0, sizeof(bi));

 if (pImage)

  delete[] pImage;

}

};


ScalarTypes.h

#ifndef SCALAR_H

#define SCALAR_H

typedef double scalar;

typedef unsigned int IDX;

#endif


vector.h

#ifndef VECTOR_H

#define VECTOR_H

#include "ScalarTypes.h"

struct Matrix;

union Vector {

scalar array[4];

struct {

 scalar _0, _1, _2, _3;

};

struct {

 scalar X, Y, Z, W;

};

struct {

 scalar R, G, B, A;

};

Vector();// ? inline

Vector(const Vector &vec);

Vector(const scalar array[4]);

Vector(scalar _);

Vector(scalar _0, scalar _1, scalar _2);

Vector(scalar _0, scalar _1, scalar _2, scalar _3);

scalar sqr_norm3() const;

scalar norm3() const;

Vector &normalize3();

Vector &homogenize3();

Vector &homogenize4();

scalar &operator [] (IDX i);

const scalar &operator [] (IDX i) const;

Vector operator - () const;

Vector &operator += (scalar _);

Vector &operator -= (scalar _);

Vector &operator *= (scalar _);

Vector &operator /= (scalar _);

Vector &operator += (const Vector &vec);

Vector &operator -= (const Vector &vec);

Vector &operator *= (const Vector &vec);

Vector &operator /= (const Vector &vec);

Vector &operator *= (const Matrix &mat);

friend Vector operator + (const Vector &vec, scalar _);

friend Vector operator - (const Vector &vec, scalar _);

friend Vector operator * (const Vector &vec, scalar _);

friend Vector operator / (const Vector &vec, scalar _);

friend Vector operator + (const Vector &vec1, const Vector &vec2);

friend Vector operator - (const Vector &vec1, const Vector &vec2);

friend Vector operator * (const Vector &vec1, const Vector &vec2);

friend Vector operator / (const Vector &vec1, const Vector &vec2);

friend Vector operator * (const Vector &vec, const Matrix &mat);

scalar dot3(const Vector &vec) const;

scalar dot4(const Vector &vec) const;

Vector cross(const Vector &vec) const;

};

#endif


vector.cpp

#include "stdafx.h"

#include "ScalarTypes.h"

#include "vector.h"

#include "matrix.h"

Vector::Vector() {}

Vector::Vector(const Vector &vec) {

_0=vec._0;

_1=vec._1;

_2=vec._2;

_3=vec._3;

}

Vector::Vector(const scalar array[4]):

_0(array[0]), _1(array[1]), _2(array[2]), _3(array[3]) {}

Vector::Vector(scalar _):

_0(_), _1(_), _2(_), _3(1.0) {}

Vector::Vector(scalar _0, scalar _1, scalar _2):

_0(_0), _1(_1), _2(_2), _3(1.0) {}

Vector::Vector(scalar _0, scalar _1, scalar _2, scalar _3):

_0(_0), _1(_1), _2(_2), _3(_3) {}

scalar Vector::sqr_norm3() const {

return _0*_0+_1*_1+_2*_2;

}

scalar Vector::norm3() const {

return sqrt(this->sqr_norm3());

}

Vector &Vector::normalize3() {

return *this/=this->norm3();//?

}

Vector &Vector::homogenize3() {

this->X/=this->W;

this->Y/=this->W;

this->Z/=this->W;

return *this;

}

Vector &Vector::homogenize4() {

return *this/=this->W;//?

}

scalar &Vector::operator [] (IDX i) {

return array[i];

}

const scalar &Vector::operator [] (IDX i) const {

return array[i];

}

Vector Vector::operator - () const {

return Vector(-_0, -_1, -_2, -_3);

}

Vector &Vector::operator += (scalar _) {

_0+=_;

_1+=_;

_2+=_;

_3+=_;

return *this;

}

Vector &Vector::operator -= (scalar _) {

_0-=_;

_1-=_;

_2-=_;

_3-=_;

return *this;

}

Vector &Vector::operator *= (scalar _) {

_0*=_;

_1*=_;

_2*=_;

_3*=_;

return *this;

}

Vector &Vector::operator /= (scalar _) {

_0/=_;

_1/=_;

_2/=_;

_3/=_;

return *this;

}

Vector &Vector::operator += (const Vector &vec) {

_0+=vec._0;

_1+=vec._1;

_2+=vec._2;

_3+=vec._3;

return *this;

}

Vector &Vector::operator -= (const Vector &vec) {

_0-=vec._0;

_1-=vec._1;

_2-=vec._2;

_3-=vec._3;

return *this;

}

Vector &Vector::operator *= (const Vector &vec) {

_0*=vec._0;

_1*=vec._1;

_2*=vec._2;

_3*=vec._3;

return *this;

}

Vector &Vector::operator /= (const Vector &vec) {

_0/=vec._0;

_1/=vec._1;

_2/=vec._2;

_3/=vec._3;

return *this;

}

Vector &Vector::operator *= (const Matrix &mat) {

return *this=*this*mat;//?

}

Vector operator + (const Vector &vec, scalar _) {

return Vector(vec)+=_;

}

Vector operator - (const Vector &vec, scalar _) {

return Vector(vec)-=_;

}

Vector operator * (const Vector &vec, scalar _) {

return Vector(vec)*=_;

}

Vector operator / (const Vector &vec, scalar _) {

return Vector(vec)/=_;

}

Vector operator + (const Vector &vec1, const Vector &vec2) {

return Vector(vec1)+=vec2;

}

Vector operator - (const Vector &vec1, const Vector &vec2) {

return Vector(vec1)-=vec2;

}

Vector operator * (const Vector &vec1, const Vector &vec2) {

return Vector(vec1)*=vec2;

}

Vector operator / (const Vector &vec1, const Vector &vec2) {

return Vector(vec1)/=vec2;

}

Vector operator * (const Vector &vec, const Matrix &mat) {

Vector product(0.0, 0.0, 0.0, 0.0);

for (IDX i=0; i < 4; i++)

 for (IDX j=0; j < 4; j++)

  product[i]+=vec[j]*mat(j, i);

return product;

}

scalar Vector::dot3(const Vector &vec) const {

return this->X*vec.X+this->Y*vec.Y+this->Z*vec.Z;

}

scalar Vector::dot4(const Vector &vec) const {

return this->X*vec.X+this->Y*vec.Y+this->Z*vec.Z+this->W*vec.W;

}

Vector Vector::cross(const Vector &vec) const {

Vector product;

product.X=this->Y*vec.Z-vec.Y*this->Z;

product.Y=-(this->X*vec.Z-vec.X*this->Z);

product.Z=this->X*vec.Y-vec.X*this->Y;

product.W=1;

return product;

}


matrix.h

#ifndef MATRIX_H

#define MATRIX_H

#include "ScalarTypes.h"

#include "vector.h"

struct Matrix {

union{

 scalar array1D[16];

 scalar array2D[4][4];

 struct {

  scalar

   _0, _1, _2, _3,

   _4, _5, _6, _7,

   _8, _9, _A, _B,

   _C, _D, _E, _F;

 };

 struct {

  scalar

   _00, _01, _02, _03,

   _10, _11, _12, _13,

   _20, _21, _22, _23,

   _30, _31, _32, _33;

 };

 struct {

  scalar

   a, b, c, p,

   d, e, f, q,

   g, h, i, r,

   x, y, z, w;

 };

};

Matrix();

inline Matrix(const scalar array1D[16]);//? inline

inline Matrix(const scalar array2D[4][4]);

inline Matrix(const scalar array0[4], const scalar array1[4], const scalar array2[4], const scalar array3[4]);

inline Matrix(const Vector &vec0, const Vector &vec1, const Vector &vec2, const Vector &vec3);

Matrix(

 scalar _0, scalar _1, scalar _2, scalar _3,

 scalar _4, scalar _5, scalar _6, scalar _7,

 scalar _8, scalar _9, scalar _A, scalar _B,

 scalar _C, scalar _D, scalar _E, scalar _F);

inline Matrix &set_value(const scalar array1D[16]);

inline Matrix &set_value(const scalar array2D[4][4]);

inline Matrix &set_value(const scalar array0[4], const scalar array1[4], const scalar array2[4], const scalar array3[4]);

inline Matrix &set_value(const Vector &vec0, const Vector &vec1, const Vector &vec2, const Vector &vec3);

inline Matrix &set_value(

 scalar _0, scalar _1, scalar _2, scalar _3,

 scalar _4, scalar _5, scalar _6, scalar _7,

 scalar _8, scalar _9, scalar _A, scalar _B,

 scalar _C, scalar _D, scalar _E, scalar _F);

Matrix inverse() const;

Matrix transpose() const;

Matrix operator - () const;

Vector &operator [] (IDX i);

const Vector &operator [] (IDX i) const;

scalar &operator () (IDX i);

const scalar &operator () (IDX i) const;

scalar &operator () (IDX i, IDX j);

const scalar &operator () (IDX i, IDX j) const;

Matrix &operator += (scalar _);

Matrix &operator -= (scalar _);

Matrix &operator *= (scalar _);

Matrix &operator /= (scalar _);

Matrix &operator += (const Matrix &mat);

Matrix &operator -= (const Matrix &mat);

Matrix &operator *= (const Matrix &mat);

friend Matrix operator + (const Matrix &mat, scalar _);

friend Matrix operator - (const Matrix &mat, scalar _);

friend Matrix operator * (const Matrix &mat, scalar _);

friend Matrix operator / (const Matrix &mat, scalar _);

friend Matrix operator + (const Matrix &mat1, const Matrix &mat2);

friend Matrix operator - (const Matrix &mat1, const Matrix &mat2);

friend Matrix operator * (const Matrix &mat1, const Matrix &mat2);

friend Matrix identity();

friend Matrix scale(scalar _);

friend Matrix scale(const Vector &vec);

friend Matrix translate(const Vector &vec);

friend Matrix rotate(Vector axis, scalar angle);

};

#endif


matrix.cpp

#include "stdafx.h"

#include "ScalarTypes.h"

#include "vector.h"

#include "matrix.h"

inline scalar ABS(scalar x) {

return x>=0?x:-x;

}

Matrix::Matrix() {}

inline Matrix::Matrix(const scalar array1D[16]) {

set_value(array1D);

}

inline Matrix::Matrix(const scalar array2D[4][4]) {

set_value(array2D);

}

inline Matrix::Matrix(const scalar array0[4], const scalar array1[4], const scalar array2[4], const scalar array3[4]) {

set_value(array0, array1, array2, array3);

}

inline Matrix::Matrix(const Vector &vec0, const Vector &vec1, const Vector &vec2, const Vector &vec3) {

set_value(vec0, vec1, vec2, vec3);

}

Matrix::Matrix(scalar _0, scalar _1, scalar _2, scalar _3,

     scalar _4, scalar _5, scalar _6, scalar _7,

     scalar _8, scalar _9, scalar _A, scalar _B,

     scalar _C, scalar _D, scalar _E, scalar _F) {

set_value(

 _0, _1, _2, _3,

 _4, _5, _6, _7,

 _8, _9, _A, _B,

 _C, _D, _E, _F);

}

inline Matrix &Matrix::set_value(const scalar array1D[16]) {

for (IDX i=0; i < 16; i++)

 Matrix::array1D[i]=array1D[i];

return *this;

}

inline Matrix &Matrix::set_value(const scalar array2D[4][4]) {

for (IDX i=0; i < 16; i++)

 Matrix::array2D[0][i]=array2D[0][i];

return *this;

}

inline Matrix &Matrix::set_value(const scalar array0[4], const scalar array1[4], const scalar array2[4], const scalar array3[4]) {

for (IDX i=0; i < 4; i++)

 array2D[0][i]=array0[i];

for (i=0; i < 4; i++)

 array2D[1][i]=array1[i];

for (i=0; i < 4; i++)

 array2D[2][i]=array2[i];

for (i=0; i < 4; i++)

 array2D[3][i]=array3[i];

return *this;

}

inline Matrix &Matrix::set_value(const Vector &vec0, const Vector &vec1, const Vector &vec2, const Vector &vec3) {

for (IDX i=0; i < 4; i++)

 array2D[0][i]=vec0[i];

for (i=0; i < 4; i++)

 array2D[1][i]=vec1[i];

for (i=0; i < 4; i++)

 array2D[2][i]=vec2[i];

for (i=0; i < 4; i++)

 array2D[3][i]=vec3[i];

return *this;

}

inline Matrix &Matrix::set_value(scalar _0, scalar _1, scalar _2, scalar _3,

      scalar _4, scalar _5, scalar _6, scalar _7,

      scalar _8, scalar _9, scalar _A, scalar _B,

      scalar _C, scalar _D, scalar _E, scalar _F) {

Matrix::_0=_0, Matrix::_1=_1, Matrix::_2=_2, Matrix::_3=_3;

Matrix::_4=_4, Matrix::_5=_5, Matrix::_6=_6, Matrix::_7=_7;

Matrix::_8=_8, Matrix::_9=_9, Matrix::_A=_A, Matrix::_B=_B;

Matrix::_C=_C, Matrix::_D=_D, Matrix::_E=_E, Matrix::_F=_F;

return *this;

}

Matrix Matrix::inverse() const {

scalar mat[4][8]={

 array2D[0][0], array2D[0][1], array2D[0][2], array2D[0][3], 1.0, 0.0, 0.0, 0.0,

 array2D[1][0], array2D[1][1], array2D[1][2], array2D[1][3], 0.0, 1.0, 0.0, 0.0,

 array2D[2][0], array2D[2][1], array2D[2][2], array2D[2][3], 0.0, 0.0, 1.0, 0.0,

 array2D[3][0], array2D[3][1], array2D[3][2], array2D[3][3], 0.0, 0.0, 0.0, 1.0

};

scalar *rows[4]={ mat[0], mat[1], mat[2], mat[3] };

for (IDX i=0; i < 4; i++) {

 IDX row_num=i;

 scalar major=ABS(rows[i][i]);

 for (IDX r=i+1; r < 4; r++) {

  scalar cur_ABS=ABS(rows[r][i]);

  if (cur_ABS > major) {

   major=cur_ABS;

   row_num=r;

  }

 }

 if (row_num != i) {

  (int &)rows[i]^=(int)rows[row_num];//?

  (int &)rows[row_num]^=(int)rows[i];

  (int &)rows[i]^=(int)rows[row_num];

 }

 for (r=i+1; r < 4; r++) {

  scalar factor=rows[r][i]/rows[i][i];

  for (IDX c=i; c < 8; c++)

   rows[r][c]-=factor*rows[i][c];

 }

}

for (i=3; i > 0; i--)

 for (IDX r=0; r < i; r++) {

  scalar factor=rows[r][i]/rows[i][i];

  for (IDX c=4; c < 8; c++)

   rows[r][c]-=factor*rows[i][c];

 }

return Matrix(

 rows[0][4]/rows[0][0], rows[0][5]/rows[0][0], rows[0][6]/rows[0][0], rows[0][7]/rows[0][0],

 rows[1][4]/rows[1][1], rows[1][5]/rows[1][1], rows[1][6]/rows[1][1], rows[1][7]/rows[1][1],

 rows[2][4]/rows[2][2], rows[2][5]/rows[2][2], rows[2][6]/rows[2][2], rows[2][7]/rows[2][2],

 rows[3][4]/rows[3][3], rows[3][5]/rows[3][3], rows[3][6]/rows[3][3], rows[3][7]/rows[3][3]);

}

Matrix Matrix::transpose() const {

return Matrix(

 array2D[0][0], array2D[1][0], array2D[2][0], array2D[3][0],

 array2D[0][1], array2D[1][1], array2D[2][1], array2D[3][1],

 array2D[0][2], array2D[1][2], array2D[2][2], array2D[3][2],

 array2D[0][3], array2D[1][3], array2D[2][3], array2D[3][3]);

}

Matrix Matrix::operator - () const {

return Matrix(

 -_0, -_1, -_2, -_3,

 -_4, -_5, -_6, -_7,

 -_8, -_9, -_A, -_B,

 -_C, -_D, -_E, -_F);

}

Vector &Matrix::operator [] (IDX i) {

return (Vector &)array2D[i][0];

}

const Vector &Matrix::operator [] (IDX i) const {

return (Vector &)array2D[i][0];

}

scalar &Matrix::operator () (IDX i) {

return array1D[i];

}

const scalar &Matrix::operator () (IDX i) const {

return array1D[i];

}

scalar &Matrix::operator () (IDX i, IDX j) {

return array2D[i][j];

}

const scalar &Matrix::operator () (IDX i, IDX j) const {

return array2D[i][j];

}

Matrix &Matrix::operator += (scalar _) {

for (IDX i=0; i < 16; i++)

 this->operator () (i) += _;

return *this;

}

Matrix &Matrix::operator -= (scalar _) {

for (IDX i=0; i < 16; i++)

 this->operator () (i) -= _;

return *this;

}

Matrix &Matrix::operator *= (scalar _) {

for (IDX i=0; i < 16; i++)

 this->operator () (i) *= _;

return *this;

}

Matrix &Matrix::operator /= (scalar _) {

for (IDX i=0; i < 16; i++)

 this->operator () (i) /= _;

return *this;

}

Matrix &Matrix::operator += (const Matrix &mat) {

for (IDX i=0; i < 16; i++)

 this->operator () (i) += mat(i);

return *this;

}

Matrix &Matrix::operator -= (const Matrix &mat) {

for (IDX i=0; i < 16; i++)

 this->operator () (i) -= mat(i);

return *this;

}

Matrix &Matrix::operator *= (const Matrix &mat) {

return *this=*this*mat;//?

}

Matrix operator + (const Matrix &mat, scalar _) {

return Matrix(mat)+=_;

}

Matrix operator - (const Matrix &mat, scalar _) {

return Matrix(mat)-=_;

}

Matrix operator * (const Matrix &mat, scalar _) {

return Matrix(mat)*=_;

}

Matrix operator / (const Matrix &mat, scalar _) {

return Matrix(mat)/=_;

}

Matrix operator + (const Matrix &mat1, const Matrix &mat2) {

return Matrix(mat1)+=mat2;

}

Matrix operator - (const Matrix &mat1, const Matrix &mat2) {

return Matrix(mat1)-=mat2;

}

Matrix operator * (const Matrix &mat1, const Matrix &mat2) {

Matrix product(

 0.0, 0.0, 0.0, 0.0,

 0.0, 0.0, 0.0, 0.0,

 0.0, 0.0, 0.0, 0.0,

 0.0, 0.0, 0.0, 0.0);

for (IDX i=0; i < 4; i++)

 for (IDX j=0; j < 4; j++)

  for (IDX k=0; k < 4; k++)

   product(i, j)+=mat1(i, k)*mat2(k, j);

return product;

}

Matrix identity() {

return scale(1.0);

}

Matrix scale(scalar _) {

return scale(Vector(_, _, _));

}

Matrix scale(const Vector &vec) {

return Matrix(

 vec.X, 0.0  , 0.0  , 0.0  ,

 0.0  , vec.Y, 0.0  , 0.0  ,

 0.0  , 0.0  , vec.Z, 0.0  ,

 0.0  , 0.0  , 0.0  , vec.W);

}

Matrix translate(const Vector &vec) {

return Matrix(

 1.0  , 0.0  , 0.0  , 0.0,

 0.0  , 1.0  , 0.0  , 0.0,

 0.0  , 0.0  , 1.0  , 0.0,

 vec.X, vec.Y, vec.Z, 1.0);

}

Matrix rotate(Vector axis, scalar angle) {

axis.normalize3();

scalar

 &x=axis.X,

 &y=axis.Y,

 &z=axis.Z,

 sin_angle=sin(angle),

 cos_angle=cos(angle);

return Matrix(

 (1.0-x*x)*cos_angle+x*x        , z*sin_angle+x*y*(1.0-cos_angle), x*z*(1.0-cos_angle)-y*sin_angle, 0.0,

 x*y*(1.0-cos_angle)-z*sin_angle, (1.0-y*y)*cos_angle+y*y        , y*z*(1.0-cos_angle)+x*sin_angle, 0.0,

 x*z*(1-cos_angle)+y*sin_angle  , y*z*(1-cos_angle)-x*sin_angle  , (1-z*z)*cos_angle+z*z          , 0.0,

 0.0                            , 0.0                            , 0.0                            , 1.0);

}


raster scale.cpp

// raster scale.cpp : Defines the entry point for the application.

//

#include "stdafx.h"

#include "resource.h"

#define MAX_LOADSTRING 100

// Global Variables:

HINSTANCE hInst;        // current instance

TCHAR szTitle[MAX_LOADSTRING];        // The title bar text

TCHAR szWindowClass[MAX_LOADSTRING];        // The title bar text

// Foward declarations of functions included in this code module:

ATOM    MyRegisterClass(HINSTANCE hInstance);

BOOL    InitInstance(HINSTANCE, int);

LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);

LRESULT CALLBACK About(HWND, UINT, WPARAM, LPARAM);

FrameBuffer frame_buffer, smallBitmap, largeBitmap;

RECT fb_rt;

int large_width = 8, large_height = 16;

scalar

weight = sqrt(2)/2,

line_offset = 0.0,

curve_offset = 0.5;

bool

draw_curve = true,

color_curve = false;

void Init() {

character ch={new scalar[4*4], new scalar[1*15], 4, 1};

ch.lines[0]=0+line_offset;

ch.lines[1]=0+line_offset;

ch.lines[2]=0+line_offset;

ch.lines[3]=14+line_offset;

ch.lines[4]=1+line_offset;

ch.lines[5]=15+line_offset;

ch.lines[6]=6+line_offset;

ch.lines[7]=15+line_offset;

ch.lines[8]=7+line_offset;

ch.lines[9]=14+line_offset;

ch.lines[10]=7+line_offset;

ch.lines[11]=10+line_offset;

ch.lines[12]=6+line_offset;

ch.lines[13]=9+line_offset;

ch.lines[14]=1+line_offset;

ch.lines[15]=9+line_offset;

ch.curves[0x0]=0+line_offset;   //x

ch.curves[0x1]=curve_offset;   //offset

ch.curves[0x2]=14+line_offset;   //y

ch.curves[0x3]=curve_offset;   //offset

ch.curves[0x4]=1;      //weight

ch.curves[0x5]=(0+line_offset)*weight; //x

ch.curves[0x6]=curve_offset*weight;  //offset

ch.curves[0x7]=(15+line_offset)*weight; //y

ch.curves[0x8]=curve_offset*weight;  //offset

ch.curves[0x9]=weight;     //weight

ch.curves[0xa]=1+line_offset;   //x

ch.curves[0xb]=curve_offset;   //offset

ch.curves[0xc]=15+line_offset;   //y

ch.curves[0xd]=curve_offset;   //offset

ch.curves[0xe]=1;      //weight

smallBitmap.Init(8, 16);

smallBitmap.Clear(RGBA(255, 255, 255, 255));

/* smallBitmap.Line(0, 0, 0, 14, 0);

smallBitmap.Line(1, 15, 6, 15, 0);

smallBitmap.Line(7, 14, 7, 10, 0);

smallBitmap.Line(6, 9, 1, 9, 0);*/

// largeBitmap=Up(smallBitmap, 16, 16);

// largeBitmap = new FrameBuffer;

largeBitmap.Init(large_width, large_height);

largeBitmap.Clear(RGBA(255, 255, 255, 255));

/* largeBitmap->Line(0, 0, 0, 14*scale, 0);

largeBitmap->Line(1*scale, 15*scale, 6*scale, 15*scale, 0);

largeBitmap->Line(7*scale, 14*scale, 7*scale, 10*scale, 0);

largeBitmap->Line(6*scale, 9*scale, 1*scale, 9*scale, 0);

largeBitmap->Bezier(

 Vector(0, 14*scale, 0, 1)*weight,

 Vector(0, 15*scale, 0, 1)*weight,

 Vector(1*scale, 15*scale, 0, 1)*weight,

 0);*/

smallBitmap.DrwaChar(&ch, 0, 1, 1);

largeBitmap.DrwaChar(&ch, 0, (scalar)large_width/8, (scalar)large_height/16);

}

void UpdateFrameBuffer() {

frame_buffer.Clear(RGBA(255, 255, 255, 255));

Copy(frame_buffer, smallBitmap, 0, 0, 0, 0, smallBitmap.GetWidth(), smallBitmap.GetHeight());

Copy(frame_buffer, largeBitmap, smallBitmap.GetWidth()+8, 0, 0, 0, largeBitmap.GetWidth(), largeBitmap.GetHeight());

}

int APIENTRY WinMain(HINSTANCE hInstance,

                    HINSTANCE hPrevInstance,

                    LPSTR     lpCmdLine,

                    int       nCmdShow)

{

 // TODO: Place code here.

MSG msg;

HACCEL hAccelTable;

// Initialize global strings

LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);

LoadString(hInstance, IDC_RASTERSCALE, szWindowClass, MAX_LOADSTRING);

MyRegisterClass(hInstance);

// Perform application initialization:

if (!InitInstance (hInstance, nCmdShow))

{

 return FALSE;

}

hAccelTable = LoadAccelerators(hInstance, (LPCTSTR)IDC_RASTERSCALE);

 

// Main message loop:

while (GetMessage(&msg, NULL, 0, 0))

{

 if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))

 {

  TranslateMessage(&msg);

  DispatchMessage(&msg);

 }

}

return msg.wParam;

}

//

//  FUNCTION: MyRegisterClass()

//

//  PURPOSE: Registers the window class.

//

//  COMMENTS:

//

//    This function and its usage is only necessary if you want this code

//    to be compatible with Win32 systems prior to the 'RegisterClassEx'

//    function that was added to Windows 95. It is important to call this function

//    so that the application will get 'well formed' small icons associated

//    with it.

//

ATOM MyRegisterClass(HINSTANCE hInstance)

{

WNDCLASSEX wcex;

wcex.cbSize = sizeof(WNDCLASSEX);

wcex.style   = CS_HREDRAW | CS_VREDRAW;

wcex.lpfnWndProc = (WNDPROC)WndProc;

wcex.cbClsExtra  = 0;

wcex.cbWndExtra  = 0;

wcex.hInstance  = hInstance;

wcex.hIcon   = LoadIcon(hInstance, (LPCTSTR)IDI_RASTERSCALE);

wcex.hCursor  = LoadCursor(NULL, IDC_ARROW);

wcex.hbrBackground = NULL;//(HBRUSH)(COLOR_WINDOW+1);

wcex.lpszMenuName = (LPCSTR)IDC_RASTERSCALE;

wcex.lpszClassName = szWindowClass;

wcex.hIconSm  = LoadIcon(wcex.hInstance, (LPCTSTR)IDI_SMALL);

return RegisterClassEx(&wcex);

}

//

//   FUNCTION: InitInstance(HANDLE, int)

//

//   PURPOSE: Saves instance handle and creates main window

//

//   COMMENTS:

//

//        In this function, we save the instance handle in a global variable and

//        create and display the main program window.

//

BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)

{

  HWND hWnd;

  hInst = hInstance; // Store instance handle in our global variable

  hWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,

     0, 0, 1024, 768, NULL, NULL, hInstance, NULL);

  if (!hWnd)

  {

     return FALSE;

  }

  ShowWindow(hWnd, nCmdShow);

  UpdateWindow(hWnd);

  return TRUE;

}

//

//  FUNCTION: WndProc(HWND, unsigned, WORD, LONG)

//

//  PURPOSE:  Processes messages for the main window.

//

//  WM_COMMAND - process the application menu

//  WM_PAINT - Paint the main window

//  WM_DESTROY - post a quit message and return

//

//

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)

{

int wmId, wmEvent;

PAINTSTRUCT ps;

HDC hdc;

TCHAR szHello[MAX_LOADSTRING];

LoadString(hInst, IDS_HELLO, szHello, MAX_LOADSTRING);

switch (message)

{

 case WM_COMMAND:

  wmId    = LOWORD(wParam);

  wmEvent = HIWORD(wParam);

  // Parse the menu selections:

  switch (wmId)

  {

   case IDM_ABOUT:

      DialogBox(hInst, (LPCTSTR)IDD_ABOUTBOX, hWnd, (DLGPROC)About);

      break;

   case IDM_EXIT:

      DestroyWindow(hWnd);

      break;

   default:

      return DefWindowProc(hWnd, message, wParam, lParam);

  }

  break;

 case WM_PAINT:

  hdc = BeginPaint(hWnd, &ps);

  // TODO: Add any drawing code here...

  frame_buffer.BitBlt(hdc);

  EndPaint(hWnd, &ps);

  break;

 case WM_SIZE:

  GetClientRect(hWnd, &fb_rt);

  frame_buffer.Init(fb_rt.right, fb_rt.bottom);

  UpdateFrameBuffer();

  break;

 case WM_KEYDOWN:

  switch (wParam) {

   case 0x41: //a

    large_width+=1;

    large_height+=2;

    break;

   case 0x5a: //z

    large_width-=1;

    large_height-=2;

    break;

   case 0x53: //s

    large_width++;

    break;

   case 0x58: //x

    large_width--;

    break;

   case 0x44: //d

    large_height++;

    break;

   case 0x43: //c

    large_height--;

    break;

   case 0x46: //f

    line_offset+=0.1;

    break;

   case 0x56: //v

    line_offset-=0.1;

    break;

   case 0x47: //g

    curve_offset+=0.1;

    break;

   case 0x42: //b

    curve_offset-=0.1;

    break;

   case 0x48: //h

    weight *= 1.1;

    break;

   case 0x4e: //n

    weight /= 1.1;

    break;

   case VK_SPACE:

    draw_curve=!draw_curve;

    break;

   case VK_CONTROL:

    color_curve=!color_curve;

    break;

   case VK_ESCAPE:

    PostMessage(hWnd, WM_QUIT, 0, 0);

    break;

  }

  Init();

  UpdateFrameBuffer();

  InvalidateRect(hWnd, NULL, FALSE);

  break;

 case WM_CREATE:

  Init();

  break;

 case WM_DESTROY:

//   delete largeBitmap;

  PostQuitMessage(0);

  break;

 default:

  return DefWindowProc(hWnd, message, wParam, lParam);

  }

  return 0;

}

// Mesage handler for about box.

LRESULT CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)

{

switch (message)

{

 case WM_INITDIALOG:

   return TRUE;

 case WM_COMMAND:

  if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)

  {

   EndDialog(hDlg, LOWORD(wParam));

   return TRUE;

  }

  break;

}

   return FALSE;

}


shadowmap.fx

//-----------------------------------------------------------------------------

// File: ShadowMap.fx

//

// Desc: Effect file for high dynamic range cube mapping sample.

//

// Copyright (c) Microsoft Corporation. All rights reserved.

//-----------------------------------------------------------------------------

#define SMAP_SIZE 512

#define SHADOW_EPSILON 0.000005f//0.00005f

#define SlopeScale 1.0f

float4x4 g_mWorldView;

float4x4 g_mProj;

float4x4 g_mViewToLightProj;  // Transform from view space to light projection space

float4   g_vMaterial;

texture  g_txScene;

texture  g_txShadow;

float3   g_vLightPos;  // Light position in view space

float3   g_vLightDir;  // Light direction in view space

float4   g_vLightDiffuse = float4( 1.0f, 1.0f, 1.0f, 1.0f );  // Light diffuse color

float4   g_vLightAmbient = float4( 0.3f, 0.3f, 0.3f, 1.0f );  // Use an ambient light of 0.3

float    g_fCosTheta;  // Cosine of theta of the spot light

float    g_grad_begin_fade = 0.001;

float    g_grad_end_fade = 0.002;

float2   g_screen_res = { 640, 480 };

sampler2D g_samScene =

sampler_state

{

   Texture = <g_txScene>;

   MinFilter = Point;

   MagFilter = Linear;

   MipFilter = Linear;

};

sampler2D g_samShadow =

sampler_state

{

   Texture = <g_txShadow>;

   MinFilter = Point;

   MagFilter = Point;

   MipFilter = Point;

   AddressU = Clamp;

   AddressV = Clamp;

};

//-----------------------------------------------------------------------------

// Vertex Shader: VertScene

// Desc: Process vertex for scene

//-----------------------------------------------------------------------------

void VertScene( float4 iPos : POSITION,

               float3 iNormal : NORMAL,

               float2 iTex : TEXCOORD0,

               out float4 oPos : POSITION,

               out float2 Tex : TEXCOORD0,

               out float4 vPos : TEXCOORD1,

               out float3 vNormal : TEXCOORD2,

               out float4 vPosLight : TEXCOORD3 )

{

   //

   // Transform position to view space

   //

   vPos = mul( iPos, g_mWorldView );

   //

   // Transform to screen coord

   //

   oPos = mul( vPos, g_mProj );

   //

   // Compute view space normal

   //

   vNormal = mul( iNormal, (float3x3)g_mWorldView );

   //

   // Propagate texture coord

   //

   Tex = iTex;

   //

   // Transform the position to light projection space, or the

   // projection space as if the camera is looking out from

   // the spotlight.

   //

   vPosLight = mul( vPos, g_mViewToLightProj );

}

//-----------------------------------------------------------------------------

// Pixel Shader: PixScene

// Desc: Process pixel (do per-pixel lighting) for enabled scene

//-----------------------------------------------------------------------------

float4 PixScene( float2 Tex : TEXCOORD0,

                float4 vPos : TEXCOORD1,

                float3 vNormal : TEXCOORD2,

                float4 vPosLight : TEXCOORD3 ) : COLOR

{

   float4 Diffuse;

   // vLight is the unit vector from the light to this pixel

   float3 vLight = normalize( float3( vPos - g_vLightPos ) );

   // Compute diffuse from the light

   if( dot( vLight, g_vLightDir ) > g_fCosTheta ) // Light must face the pixel (within Theta)

   {

       // Pixel is in lit area. Find out if it's

       // in shadow using 2x2 percentage closest filtering

       //transform from RT space to texture space.

       float2 ShadowTexC = 0.5 * vPosLight.xy / vPosLight.w + float2( 0.5, 0.5 );

       ShadowTexC.y = 1.0f - ShadowTexC.y;

       // transform to texel space

       float2 texelpos = SMAP_SIZE * ShadowTexC;

       

       // Determine the lerp amounts           

       float2 lerps = frac( texelpos );

       //read in bilerp stamp, doing the shadow checks

       float sourcevals[4];

       sourcevals[0] = (tex2D( g_samShadow, ShadowTexC ) + SHADOW_EPSILON < vPosLight.z / vPosLight.w)? 0.0f: 1.0f;  

 sourcevals[1] = (tex2D( g_samShadow, ShadowTexC + float2(1.0/SMAP_SIZE, 0) ) + SHADOW_EPSILON < vPosLight.z / vPosLight.w)? 0.0f: 1.0f;  

       sourcevals[2] = (tex2D( g_samShadow, ShadowTexC + float2(0, 1.0/SMAP_SIZE) ) + SHADOW_EPSILON < vPosLight.z / vPosLight.w)? 0.0f: 1.0f;  

       sourcevals[3] = (tex2D( g_samShadow, ShadowTexC + float2(1.0/SMAP_SIZE, 1.0/SMAP_SIZE) ) + SHADOW_EPSILON < vPosLight.z / vPosLight.w)? 0.0f: 1.0f;  

       

       // lerp between the shadow values to calculate our light amount

       float LightAmount = lerp( lerp( sourcevals[0], sourcevals[1], lerps.x ),

                                 lerp( sourcevals[2], sourcevals[3], lerps.x ),

                                 lerps.y );

       // Light it

       Diffuse = ( saturate( dot( -vLight, normalize( vNormal ) ) ) * LightAmount * ( 1 - g_vLightAmbient ) + g_vLightAmbient )

                 * g_vMaterial;

   } else

   {

       Diffuse = g_vLightAmbient * g_vMaterial;

   }

   return tex2D( g_samScene, Tex ) * Diffuse;

}

// Point

float4 PixScenePoint( float2 Tex : TEXCOORD0,

                float4 vPos : TEXCOORD1,

                float3 vNormal : TEXCOORD2,

                float4 vPosLight : TEXCOORD3 ) : COLOR

{

   float4 Diffuse;

   // vLight is the unit vector from the light to this pixel

   float3 vLight = normalize( float3( vPos - g_vLightPos ) );

   // Compute diffuse from the light

   if( dot( vLight, g_vLightDir ) > g_fCosTheta ) // Light must face the pixel (within Theta)

   {

       // Pixel is in lit area. Find out if it's

       // in shadow using 2x2 percentage closest filtering

       //transform from RT space to texture space.

       float2 ShadowTexC = 0.5 * vPosLight.xy / vPosLight.w + float2( 0.5 + 0.5/SMAP_SIZE, 0.5 - 0.5/SMAP_SIZE );

       ShadowTexC.y = 1.0f - ShadowTexC.y;

       

 // do the shadow check

 float Depth = tex2D( g_samShadow, ShadowTexC ) + SHADOW_EPSILON < vPosLight.z / vPosLight.w ? 0.0f : 1.0f;

       // Light it

       Diffuse = ( saturate( dot( -vLight, normalize( vNormal ) ) ) * Depth * ( 1 - g_vLightAmbient ) + g_vLightAmbient )

                 * g_vMaterial;

   } else

   {

       Diffuse = g_vLightAmbient * g_vMaterial;

   }

   return tex2D( g_samScene, Tex ) * Diffuse;

}

// Bilinear

float4 PixSceneBilinear( float2 Tex : TEXCOORD0,

                float4 vPos : TEXCOORD1,

                float3 vNormal : TEXCOORD2,

                float4 vPosLight : TEXCOORD3 ) : COLOR

{

   float4 Diffuse;

   // vLight is the unit vector from the light to this pixel

   float3 vLight = normalize( float3( vPos - g_vLightPos ) );

   // Compute diffuse from the light

   if( dot( vLight, g_vLightDir ) > g_fCosTheta ) // Light must face the pixel (within Theta)

   {

       // Pixel is in lit area. Find out if it's

       // in shadow using 2x2 percentage closest filtering

       //transform from RT space to texture space.

       float2 ShadowTexC = 0.5 * vPosLight.xy / vPosLight.w + float2( 0.5, 0.5 );

       ShadowTexC.y = 1.0f - ShadowTexC.y;

       // transform to texel space

       float2 texelpos = SMAP_SIZE * ShadowTexC;

       

       // Determine the lerp amounts           

       float2 lerps = frac( texelpos );

       //read in bilerp stamp

       float sourcevals[4];

       sourcevals[0] = (tex2D( g_samShadow, ShadowTexC ));  

 sourcevals[1] = (tex2D( g_samShadow, ShadowTexC + float2(1.0/SMAP_SIZE, 0) ));  

       sourcevals[2] = (tex2D( g_samShadow, ShadowTexC + float2(0, 1.0/SMAP_SIZE) ));  

       sourcevals[3] = (tex2D( g_samShadow, ShadowTexC + float2(1.0/SMAP_SIZE, 1.0/SMAP_SIZE) ));  

       

       // lerp between the depth values

       float Depth = lerp( lerp( sourcevals[0], sourcevals[1], lerps.x ),

                                 lerp( sourcevals[2], sourcevals[3], lerps.x ),

                                 lerps.y );

Depth = Depth + SHADOW_EPSILON < vPosLight.z / vPosLight.w ? 0.0f : 1.0f;

       // Light it

       Diffuse = ( saturate( dot( -vLight, normalize( vNormal ) ) ) * Depth * ( 1 - g_vLightAmbient ) + g_vLightAmbient )

                 * g_vMaterial;

   } else

   {

       Diffuse = g_vLightAmbient * g_vMaterial;

   }

   return tex2D( g_samScene, Tex ) * Diffuse;

}

// MaxDepth

float4 PixSceneMaxDepth( float2 Tex : TEXCOORD0,

                float4 vPos : TEXCOORD1,

                float3 vNormal : TEXCOORD2,

                float4 vPosLight : TEXCOORD3 ) : COLOR

{

   float4 Diffuse;

   // vLight is the unit vector from the light to this pixel

   float3 vLight = normalize( float3( vPos - g_vLightPos ) );

   // Compute diffuse from the light

   if( dot( vLight, g_vLightDir ) > g_fCosTheta ) // Light must face the pixel (within Theta)

   {

       // Pixel is in lit area. Find out if it's

       // in shadow using 2x2 percentage closest filtering

       //transform from RT space to texture space.

       float2 ShadowTexC = 0.5 * vPosLight.xy / vPosLight.w + float2( 0.5, 0.5 );

       ShadowTexC.y = 1.0f - ShadowTexC.y;

       //read depths

       float sourcevals[4];

       sourcevals[0] = (tex2D( g_samShadow, ShadowTexC ));  

 sourcevals[1] = (tex2D( g_samShadow, ShadowTexC + float2(1.0/SMAP_SIZE, 0) ));  

       sourcevals[2] = (tex2D( g_samShadow, ShadowTexC + float2(0, 1.0/SMAP_SIZE) ));  

       sourcevals[3] = (tex2D( g_samShadow, ShadowTexC + float2(1.0/SMAP_SIZE, 1.0/SMAP_SIZE) ));  

       

       // max of the depth values

       float Depth = max(max(sourcevals[0], sourcevals[1]), max(sourcevals[2], sourcevals[3]));

Depth = Depth + SHADOW_EPSILON < vPosLight.z / vPosLight.w ? 0.0f : 1.0f;

       // Light it

       Diffuse = ( saturate( dot( -vLight, normalize( vNormal ) ) ) * Depth * ( 1 - g_vLightAmbient ) + g_vLightAmbient )

                 * g_vMaterial;

   } else

   {

       Diffuse = g_vLightAmbient * g_vMaterial;

   }

   return tex2D( g_samScene, Tex ) * Diffuse;

}

// MinDepth

float4 PixSceneMinDepth( float2 Tex : TEXCOORD0,

                float4 vPos : TEXCOORD1,

                float3 vNormal : TEXCOORD2,

                float4 vPosLight : TEXCOORD3 ) : COLOR

{

   float4 Diffuse;

   // vLight is the unit vector from the light to this pixel

   float3 vLight = normalize( float3( vPos - g_vLightPos ) );

   // Compute diffuse from the light

   if( dot( vLight, g_vLightDir ) > g_fCosTheta ) // Light must face the pixel (within Theta)

   {

       // Pixel is in lit area. Find out if it's

       // in shadow using 2x2 percentage closest filtering

       //transform from RT space to texture space.

       float2 ShadowTexC = 0.5 * vPosLight.xy / vPosLight.w + float2( 0.5, 0.5 );

       ShadowTexC.y = 1.0f - ShadowTexC.y;

       //read depths

       float sourcevals[4];

       sourcevals[0] = (tex2D( g_samShadow, ShadowTexC ));  

 sourcevals[1] = (tex2D( g_samShadow, ShadowTexC + float2(1.0/SMAP_SIZE, 0) ));  

       sourcevals[2] = (tex2D( g_samShadow, ShadowTexC + float2(0, 1.0/SMAP_SIZE) ));  

       sourcevals[3] = (tex2D( g_samShadow, ShadowTexC + float2(1.0/SMAP_SIZE, 1.0/SMAP_SIZE) ));  

       

       // max of the depth values

       float Depth = min(min(sourcevals[0], sourcevals[1]), min(sourcevals[2], sourcevals[3]));

Depth = Depth + SHADOW_EPSILON < vPosLight.z / vPosLight.w ? 0.0f : 1.0f;

       // Light it

       Diffuse = ( saturate( dot( -vLight, normalize( vNormal ) ) ) * Depth * ( 1 - g_vLightAmbient ) + g_vLightAmbient )

                 * g_vMaterial;

   } else

   {

       Diffuse = g_vLightAmbient * g_vMaterial;

   }

   return tex2D( g_samScene, Tex ) * Diffuse;

}

// Grads

float4 PixSceneGrads( float2 Tex : TEXCOORD0,

                float4 vPos : TEXCOORD1,

                float3 vNormal : TEXCOORD2,

                float4 vPosLight : TEXCOORD3 ) : COLOR

{

   float4 Diffuse;

   // vLight is the unit vector from the light to this pixel

   float3 vLight = normalize( float3( vPos - g_vLightPos ) );

   // Compute diffuse from the light

   if( dot( vLight, g_vLightDir ) > g_fCosTheta ) // Light must face the pixel (within Theta)

   {

       // Pixel is in lit area. Find out if it's

       // in shadow using 2x2 percentage closest filtering

       //transform from RT space to texture space.

       float2 ShadowTexC = 0.5 * vPosLight.xy / vPosLight.w + float2( 0.5 + 0.5/SMAP_SIZE, 0.5 - 0.5/SMAP_SIZE );

       ShadowTexC.y = 1.0f - ShadowTexC.y;

       

 // compute grads wrt light src

 float3 str = vPosLight.xyz / vPosLight.w;

 float3

  d_str_dx = ddx(str) * g_screen_res.x,

  d_str_dy = ddy(str) * g_screen_res.y;

 float2x2 d_st_dxdy = { d_str_dx.xy, d_str_dy.xy };

 float2x2 d_st_dxdy_inv = float2x2(d_st_dxdy._22, d_st_dxdy._12, d_st_dxdy._21, d_st_dxdy._11) / determinant(d_st_dxdy);

 float2 d_r_dsdt_abs = abs(mul(d_st_dxdy_inv, float2(d_str_dx.z, d_str_dy.z)));

 float grads_magnitude = 0.5 * (d_r_dsdt_abs.x + d_r_dsdt_abs.y);//return grads_magnitude/10;

 // do the shadow check

 float Depth = tex2D( g_samShadow, ShadowTexC ) + SHADOW_EPSILON < vPosLight.z / vPosLight.w ? 0.0f : 1.0f;

 // apply grads fade

 Depth *= (1 - smoothstep(g_grad_begin_fade, g_grad_end_fade, grads_magnitude));

       // Light it

       Diffuse = ( saturate( dot( -vLight, normalize( vNormal ) ) ) * Depth * ( 1 - g_vLightAmbient ) + g_vLightAmbient )

                 * g_vMaterial;

   } else

   {

       Diffuse = g_vLightAmbient * g_vMaterial;

   }

   return tex2D( g_samScene, Tex ) * Diffuse;

}

//-----------------------------------------------------------------------------

// Vertex Shader: VertLight

// Desc: Process vertex for the light object

//-----------------------------------------------------------------------------

void VertLight( float4 iPos : POSITION,

               float3 iNormal : NORMAL,

               float2 iTex : TEXCOORD0,

               out float4 oPos : POSITION,

               out float2 Tex : TEXCOORD0 )

{

   //

   // Transform position to view space

   //

   oPos = mul( iPos, g_mWorldView );

   //

   // Transform to screen coord

   //

   oPos = mul( oPos, g_mProj );

   //

   // Propagate texture coord

   //

   Tex = iTex;

}

//-----------------------------------------------------------------------------

// Pixel Shader: PixLight

// Desc: Process pixel for the light object

//-----------------------------------------------------------------------------

float4 PixLight( float2 Tex : TEXCOORD0,

                float4 vPos : TEXCOORD1 ) : COLOR

{

   return tex2D( g_samScene, Tex );

}

//-----------------------------------------------------------------------------

// Vertex Shader: VertShadow

// Desc: Process vertex for the shadow map

//-----------------------------------------------------------------------------

void VertShadow( float4 Pos : POSITION,

                float3 Normal : NORMAL,

                out float4 oPos : POSITION,

                out float2 Depth : TEXCOORD0 )

{

   //

   // Compute the projected coordinates

   //

   oPos = mul( Pos, g_mWorldView );

   oPos = mul( oPos, g_mProj );

   //

   // Store z and w in our spare texcoord

   //

   Depth.xy = oPos.zw;

}

//-----------------------------------------------------------------------------

// Pixel Shader: PixShadow

// Desc: Process pixel for the shadow map

//-----------------------------------------------------------------------------

void PixShadow( float2 Depth : TEXCOORD0,

               out float4 Color : COLOR )

{

   //

   // Depth is z / w

   //

   Color = Depth.x / Depth.y;

}

// SlopeScaleBias

void PixShadowSlopeScaleBiasMax( float2 Depth : TEXCOORD0,

               out float4 Color : COLOR )

{

   //

   // Depth is z / w

   //

   Color = Depth.x / Depth.y;

   Color += max(abs(ddx(Color)), abs(ddy(Color)));

}

void PixShadowSlopeScaleBiasSum( float2 Depth : TEXCOORD0,

               out float4 Color : COLOR )

{

   //

   // Depth is z / w

   //

   Color = Depth.x / Depth.y;

   Color += 0.5 * (abs(ddx(Color)) + abs(ddy(Color)));

}

//-----------------------------------------------------------------------------

// Technique: RenderScene

// Desc: Renders scene objects

//-----------------------------------------------------------------------------

technique RenderScene

{

   pass p0

   {

       VertexShader = compile vs_1_1 VertScene();

       PixelShader = compile ps_2_0 PixScene();

   }

}

technique RenderScenePoint

{

   pass p0

   {

       VertexShader = compile vs_1_1 VertScene();

       PixelShader = compile ps_2_0 PixScenePoint();

   }

}

technique RenderSceneBilinear

{

   pass p0

   {

       VertexShader = compile vs_1_1 VertScene();

       PixelShader = compile ps_2_0 PixSceneBilinear();

   }

}

technique RenderSceneMaxDepth

{

   pass p0

   {

       VertexShader = compile vs_1_1 VertScene();

       PixelShader = compile ps_2_0 PixSceneMaxDepth();

   }

}

technique RenderSceneMinDepth

{

   pass p0

   {

       VertexShader = compile vs_3_0 VertScene();

       PixelShader = compile ps_3_0 PixSceneMinDepth();

   }

}

technique RenderSxeneGrads

{

   pass p0

   {

       VertexShader = compile vs_3_0 VertScene();

       PixelShader = compile ps_3_0 PixSceneGrads();

   }

}

//-----------------------------------------------------------------------------

// Technique: RenderLight

// Desc: Renders the light object

//-----------------------------------------------------------------------------

technique RenderLight

{

   pass p0

   {

       VertexShader = compile vs_1_1 VertLight();

       PixelShader = compile ps_1_1 PixLight();

   }

}

//-----------------------------------------------------------------------------

// Technique: RenderShadow

// Desc: Renders the shadow map

//-----------------------------------------------------------------------------

technique RenderShadow

{

   pass p0

   {

       VertexShader = compile vs_1_1 VertShadow();

       PixelShader = compile ps_2_0 PixShadow();

   }

}

technique RenderShadowSlopeScaleBiasMax

{

   pass p0

   {

       VertexShader = compile vs_1_1 VertShadow();

       PixelShader = compile ps_2_a PixShadowSlopeScaleBiasMax();

   }

}

technique RenderShadowSlopeScaleBiasSum

{

   pass p0

   {

       VertexShader = compile vs_1_1 VertShadow();

       PixelShader = compile ps_2_a PixShadowSlopeScaleBiasSum();

   }

}


defines.fxh

//--------------------------------------------------------------------------------------

// File: defines.fxh

//--------------------------------------------------------------------------------------

#pragma once

// rendering modes

#define RENDERING_MODE_FINAL  0

#define RENDERING_MODE_LOCAL_NORMAL 1

#define RENDERING_MODE_WORAL_NORMAL 2

#define RENDERING_MODE_SEARCH_STEPS 3

// gradient evaluation methods

#define GRAD_METHOD_STD    0

#define GRAD_METHOD_BASE_PLANE  1

#define GRAD_METHOD_HYBRID   2


shared.fxh

//--------------------------------------------------------------------------------------

// File: shared.fxh

//--------------------------------------------------------------------------------------

//--------------------------------------------------------------------------------------

// Shared variables

//--------------------------------------------------------------------------------------

shared textureCUBE g_CubeTexture;   // color texture for cube

shared float  g_fTime;    // App's time in seconds

shared float4x4  g_mViewProjection;  // View * Projection matrix

//--------------------------------------------------------------------------------------

// Texture samplers

//--------------------------------------------------------------------------------------

samplerCUBE CubeMapSampler =

sampler_state

{

   Texture = <g_CubeTexture>;

   MipFilter = LINEAR;

   MinFilter = ANISOTROPIC;

   MagFilter = LINEAR;

   MaxAnisotropy = 16;

   AddressU = CLAMP;

   AddressV = CLAMP;

   AddressW = CLAMP;

};


Cube.fx

//--------------------------------------------------------------------------------------

// File: Cube.fx

//--------------------------------------------------------------------------------------

//--------------------------------------------------------------------------------------

// Includes

//--------------------------------------------------------------------------------------

#include "shared.fxh"

//--------------------------------------------------------------------------------------

// Global variables

//--------------------------------------------------------------------------------------

float4x4 g_mWorld;      // World matrix for cube

//--------------------------------------------------------------------------------------

// Vertex shader output structure

//--------------------------------------------------------------------------------------

struct VS_OUTPUT

{

   float4 Position  : POSITION;   // vertex position

   float3 TextureXYZ : TEXCOORD0;  // vertex texture coords

};

//--------------------------------------------------------------------------------------

// This shader computes standard transform

//--------------------------------------------------------------------------------------

VS_OUTPUT Transform_VS(float3 vPos : POSITION)

{

VS_OUTPUT Output;

 

float4x4 g_mWorldViewProjection = mul(g_mWorld, g_mViewProjection);

 

// Transform the position from object space to homogeneous projection space

Output.Position = mul(float4(vPos, 1), g_mWorldViewProjection);

 

// Just copy the texture coordinate through

Output.TextureXYZ = vPos;

 

return Output;

}

//--------------------------------------------------------------------------------------

// Cube pixel shader

//--------------------------------------------------------------------------------------

float4 Cube_PS(VS_OUTPUT In) : COLOR0

{

float4 Output;

 

// Lookup cube map

Output.rgb = texCUBE(CubeMapSampler, In.TextureXYZ);

 

Output.a = 1;

 

return Output;

}

//--------------------------------------------------------------------------------------

// Techniques

//--------------------------------------------------------------------------------------

technique Cube

{

pass P0

{

 VertexShader = compile vs_2_0 Transform_VS();

 PixelShader  = compile ps_2_0 Cube_PS();

 CullMode  = CW;

}

}


SurfaceDetailVariations.fx

//--------------------------------------------------------------------------------------

// File: SurfaceDetailVariations.fx

//--------------------------------------------------------------------------------------

//--------------------------------------------------------------------------------------

// Includes

//--------------------------------------------------------------------------------------

#include "defines.fxh"

#include "shared.fxh"

//--------------------------------------------------------------------------------------

// Global variables

//--------------------------------------------------------------------------------------

static const float3 g_MaterialAmbientColor  = { 0.2, 0.2, 0.2 }; // Material's ambient color

static const float3 g_MaterialDiffuseColor  = { 0.5, 0.5, 0.5 }; // Material's diffuse color

static const float3 g_MaterialSpecularColor = { 0.7, 0.7, 0.7 }; // Material's specular color

static const float3 g_Normal                = { 0.0, 0.0, -1.0 }; // Quad's normal in object space

static const float g_Shine = 128;

float  g_height_delta_scale;

float  g_max_height;

float  g_grad_threshold;

float  g_max_raytrace_bias;

float  g_linear_search_delta;

int   g_binary_search_steps;

float  g_reflectance;

bool  g_reflections;

bool  g_cast_shadows;

float  g_tex_scale;     // Simple transform in tangent space

float3  g_Eye;       // Eye position in world space

float3  g_WorldLightDir;    // Normalized light's direction in world space

float4  g_LightDiffuse;     // Light's diffuse color

float2  g_normal_height_map_res;  // Resolution of normal height map

int   g_rendering_mode;    // Renderein mode (normal,  final)

int   g_height_diff_samples;   // Technique (number of samples) of height map differentiation

int   g_grad_method;     // Gradients evaluation method

texture2D g_ColorTexture;     // Color texture for object

texture2D g_NormalHeightTexture;   // Normal & height texture for object

float4x4 g_mWorld;      // World matrix for object

//--------------------------------------------------------------------------------------

// Texture samplers

//--------------------------------------------------------------------------------------

sampler2D ColorTextureSampler =

sampler_state

{

   Texture = <g_ColorTexture>;

   MipFilter = LINEAR;

   MinFilter = ANISOTROPIC;

   MagFilter = LINEAR;

   MaxAnisotropy = 16;

   AddressU = MIRROR;

   AddressV = MIRROR;

};

sampler2D NormalHeightTextureSampler =

sampler_state

{

   Texture = <g_NormalHeightTexture>;

   MipFilter = LINEAR;

   MinFilter = LINEAR;

   MagFilter = LINEAR;

   MaxAnisotropy = 16;

   AddressU = MIRROR;

   AddressV = MIRROR;

};

//--------------------------------------------------------------------------------------

// Vertex shaders output structures

//--------------------------------------------------------------------------------------

struct TRANSFORM_REFLECT_VS_OUTPUT

{

   float4 Position  : POSITION;   // vertex position

   float2 TextureUV : TEXCOORD0;  // vertex texture coords

   float3 WorldPos  : TEXCOORD1;  // vertex position in world space

   float3 Normal  : TEXCOORD2;  // vertex normal in world space

   float3 Reflect  : TEXCOORD3;  // vertex reflection direction in world space

};

struct TRANSFORM_VS_OUTPUT

{

   float4 Position  : POSITION;   // vertex position

   float2 TextureUV : TEXCOORD0;  // vertex texture coords

   float3 WorldPos  : TEXCOORD1;  // vertex position in world space

};

//--------------------------------------------------------------------------------------

// This shader computes standard transform along with world normal and reflection direction

//--------------------------------------------------------------------------------------

TRANSFORM_REFLECT_VS_OUTPUT Transform_Reflect_VS(float3 vPos : POSITION, float2 vTexCoord0 : TEXCOORD0)

{

TRANSFORM_REFLECT_VS_OUTPUT Output;

 

float4x4 g_mWorldViewProjection = mul(g_mWorld, g_mViewProjection);

 

// Transform the position from object space to homogeneous projection space

Output.Position = mul(float4(vPos, 1), g_mWorldViewProjection);

 

// Just copy the texture coordinate through

Output.TextureUV = vTexCoord0;

 

// Transform the position from object space to world space

Output.WorldPos = mul(float4(vPos, 1), g_mWorld);

 

// Transform the normal from object space to world space

Output.Normal = normalize(mul(g_Normal, (float3x3)g_mWorld)); // normal (world space)

 

// Find reflection direction in world space

float3 v = g_Eye - Output.WorldPos;

Output.Reflect = reflect(-v, Output.Normal);

 

return Output;

}

//--------------------------------------------------------------------------------------

// This shader computes standard transform

//--------------------------------------------------------------------------------------

TRANSFORM_VS_OUTPUT Transform_VS(float3 vPos : POSITION, float2 vTexCoord0 : TEXCOORD0)

{

TRANSFORM_VS_OUTPUT Output;

 

float4x4 g_mWorldViewProjection = mul(g_mWorld, g_mViewProjection);

 

// Transform the position from object space to homogeneous projection space

Output.Position = mul(float4(vPos, 1), g_mWorldViewProjection);

 

// Just copy the texture coordinate through

Output.TextureUV = vTexCoord0;

 

// Transform the position from object space to world space

Output.WorldPos = mul(float4(vPos, 1), g_mWorld);

 

return Output;

}

//--------------------------------------------------------------------------------------

// Displacement mapping vertex shader

//--------------------------------------------------------------------------------------

TRANSFORM_VS_OUTPUT DisplacementMapping_VS(float3 vPos : POSITION, float2 vTexCoord0 : TEXCOORD0)

{

TRANSFORM_VS_OUTPUT Output;

float4x4 g_mWorldViewProjection = mul(g_mWorld, g_mViewProjection);

 

// Transform the position from object space to homogeneous projection space

Output.Position = mul(float4(vPos, 1), g_mWorldViewProjection);

 

// Just copy the texture coordinate through

Output.TextureUV = vTexCoord0;

 

// Transform the position from object space to world space

Output.WorldPos = mul(float4(vPos, 1), g_mWorld);

 

return Output;

}

//--------------------------------------------------------------------------------------

// Pixel shader output structure

//--------------------------------------------------------------------------------------

struct PS_OUTPUT

{

float4 RGBColor : COLOR0; // Pixel color

};

//--------------------------------------------------------------------------------------

// These functions returns normal (possible unnormalized) in (+t +b -n) space

//--------------------------------------------------------------------------------------

// Forward declarations

float3 FetchNormal(uniform sampler2D NormalHeightSampler, in float2 uv);

float3 FetchNormal(uniform sampler2D NormalHeightSampler, in float2 uv, in float2 dx, in float2 dy);

float3 FetchNormal(uniform sampler2D NormalHeightSampler, in float2 uv)

{

return FetchNormal(NormalHeightSampler, uv, ddx(uv), ddy(uv));

}

float3 FetchNormal(uniform sampler2D NormalHeightSampler, in float2 uv, in float2 dx, in float2 dy)

{

if(g_height_diff_samples == 0)

{

 // fetch normal from normal map

 float3 n = tex2Dgrad(NormalHeightSampler, uv, dx, dy).xyz;

 

 // unpack [0..1]->[-1..1]

 n = n * 2.0 - 1.0;

 

 // reconstruct z

 n.z = sqrt(1 - dot(n.xy, n.xy));

 

 return float3(n.x, -n.y, -n.z);

}

else

{

 /*------------------------------------------------------------------------------

 compute normal based on height map in normalized (+t +b +n) space

 U = u / g_tex_scale ( = 2u); dh/dU = 0.5 * dh/du

 V = v / g_tex_scale ( = 2v); dh/dV = 0.5 * dh/dv

 n = (dp/dU x dp/dV) - (dh/dU * dp/dU) - (dh/dV * dp/dV) (*)

 ------------------------------------------------------------------------------*/

 // compute delta

//  const float tex_compress = max(length(dx * g_normal_height_map_res), length(dy * g_normal_height_map_res));

//  const float2 delta = clamp((float2)tex_compress, 1, g_normal_height_map_res) / g_normal_height_map_res * g_height_delta_scale;

 const float2 delta = g_height_delta_scale / g_normal_height_map_res;

 

 float3 n;

 // ( * g_tex_scale) for d/du->d/dU, d/dv->d/dV

 // ( / -g_tex_scale) for unnormalized (+T +B -N) -> normalized (+t +b +n) space

 // (-) in formula (*)

 if (g_height_diff_samples == 3)

 {

  float

   height_centre = tex2Dgrad(NormalHeightSampler, float2(uv.x, uv.y), dx, dy).w,

   height_x  = tex2Dgrad(NormalHeightSampler, float2(uv.x + delta.x, uv.y), dx, dy).w,

   heitht_y  = tex2Dgrad(NormalHeightSampler, float2(uv.x, uv.y + delta.y), dx, dy).w;

  n.x = g_max_height * (height_x - height_centre) / delta;

  n.y = g_max_height * (heitht_y - height_centre) / delta;

 }

 else

  if (g_height_diff_samples == 4)

  {

   float

    height_px = tex2Dgrad(NormalHeightSampler, float2(uv.x + delta.x, uv.y), dx, dy).w,

    height_nx = tex2Dgrad(NormalHeightSampler, float2(uv.x - delta.x, uv.y), dx, dy).w,

    heitht_py = tex2Dgrad(NormalHeightSampler, float2(uv.x, uv.y + delta.y), dx, dy).w,

    heitht_ny = tex2Dgrad(NormalHeightSampler, float2(uv.x, uv.y - delta.y), dx, dy).w;

   n.x = g_max_height * (height_px - height_nx) / (delta.x * 2);

   n.y = g_max_height * (heitht_py - heitht_ny) / (delta.y * 2);

  }

  else // 8 samples

  {

   float

    height_nx_ny = tex2Dgrad(NormalHeightSampler, float2(uv.x - delta.x, uv.y - delta.y), dx, dy).w,

    height_0x_ny = tex2Dgrad(NormalHeightSampler, float2(uv.x, uv.y - delta.y), dx, dy).w,

    height_px_ny = tex2Dgrad(NormalHeightSampler, float2(uv.x + delta.x, uv.y - delta.y), dx, dy).w,

    height_nx_0y = tex2Dgrad(NormalHeightSampler, float2(uv.x - delta.x, uv.y), dx, dy).w,

    height_px_0y = tex2Dgrad(NormalHeightSampler, float2(uv.x + delta.x, uv.y), dx, dy).w,

    height_nx_py = tex2Dgrad(NormalHeightSampler, float2(uv.x - delta.x, uv.y + delta.y), dx, dy).w,

    height_0x_py = tex2Dgrad(NormalHeightSampler, float2(uv.x, uv.y + delta.y), dx, dy).w,

    height_px_py = tex2Dgrad(NormalHeightSampler, float2(uv.x + delta.x, uv.y + delta.y), dx, dy).w;

   n.x = g_max_height * (height_px_ny - height_nx_ny + height_px_py - height_nx_py + 2 * (height_px_0y - height_nx_0y)) / (delta.x * 8);

   n.y = g_max_height * (height_nx_py - height_nx_ny + height_px_py - height_px_ny + 2 * (height_0x_py - height_0x_ny)) / (delta.y * 8);

  }

 n.z = 1;

 

 // return in (+t +b -n) space

 return float3(n.xy, -n.z);

}

};

//--------------------------------------------------------------------------------------

// This function compute Blinn-Phong lighting

//--------------------------------------------------------------------------------------

float3 BlinnPhong(float3 TexColor, float3 n, float3 v, float3 l, float shadow = 1)

{

// return v * 0.5 + 0.5;

float3 h = normalize(v + l);

float3 color = g_MaterialDiffuseColor * TexColor * saturate(dot(l, n));

color += g_MaterialSpecularColor * pow(saturate(dot(h, n)), g_Shine);

color *= g_LightDiffuse;

color *= shadow;

color += g_MaterialAmbientColor * TexColor;

return color;

}

//--------------------------------------------------------------------------------------

// Flat pixel shader

//--------------------------------------------------------------------------------------

PS_OUTPUT Flat_PS(TRANSFORM_REFLECT_VS_OUTPUT In)

{

PS_OUTPUT Output;

 

// view and light directions

float3 v = normalize(g_Eye - In.WorldPos);

float3 l = normalize(g_WorldLightDir);

 

float3 n = normalize(In.Normal);

 

// Lookup texture

float3 TexColor = tex2D(ColorTextureSampler, In.TextureUV).rgb;

 

Output.RGBColor.rgb = BlinnPhong(TexColor, n, v, l);

Output.RGBColor.a = 1.0;

 

if (g_reflections)

{

 // Lookup cube map

 float3 reflect_color = texCUBE(CubeMapSampler, In.Reflect);

 

 // Combine with previous color

 Output.RGBColor.rgb = lerp(Output.RGBColor.rgb, reflect_color, g_reflectance);

}

return Output;

}

//--------------------------------------------------------------------------------------

// Normal Mapping pixel shader

//--------------------------------------------------------------------------------------

PS_OUTPUT NormalMapping_PS(TRANSFORM_VS_OUTPUT In)

{

PS_OUTPUT Output;

 

// view and light directions

float3 v = normalize(g_Eye - In.WorldPos);

float3 l = g_WorldLightDir;

 

// Lookup texture

float3 TexColor = tex2D(ColorTextureSampler, In.TextureUV).rgb;

float3 n = FetchNormal(NormalHeightTextureSampler, In.TextureUV);

 

if (g_rendering_mode == RENDERING_MODE_LOCAL_NORMAL)

 // pack normal [-1..1]->[0..1] and output

 return (PS_OUTPUT)float4((normalize(n) + 1) * .5f, 1);

 

n = normalize(mul(n, (float3x3)g_mWorld));

 

if (g_rendering_mode == RENDERING_MODE_WORAL_NORMAL)

 // pack normal [-1..1]->[0..1] and output

 return (PS_OUTPUT)float4((n + 1) * .5f, 1);

 

Output.RGBColor.rgb = BlinnPhong(TexColor, n, v, l);

Output.RGBColor.a = 1.0;

if (g_reflections)

{

 // find reflection direction in world space

 float3 reflect_dir = reflect(-v, n);

 

 // Lookup cube map

 float3 reflect_color = texCUBE(CubeMapSampler, reflect_dir);

 

 // Combine with previous color

 Output.RGBColor.rgb = lerp(Output.RGBColor.rgb, reflect_color, g_reflectance);

}

if (g_rendering_mode == RENDERING_MODE_FINAL)

 return Output;

 

return (PS_OUTPUT)0;

}

//--------------------------------------------------------------------------------------

// Parallax Mapping 1 pixel shader

//--------------------------------------------------------------------------------------

PS_OUTPUT ParallaxMapping_1_PS(TRANSFORM_VS_OUTPUT In)

{

PS_OUTPUT Output;

// view and light directions

float3 v = normalize(g_Eye - In.WorldPos);

float3 l = g_WorldLightDir;

 

// parallax

float height = (1.0 - tex2D(NormalHeightTextureSampler, In.TextureUV).w) * g_max_height;

float3 offset = mul((float3x3)g_mWorld, v) * g_tex_scale;

offset = normalize(float3(offset.xy, -offset.z)) * g_max_height;

In.TextureUV += height * offset;

 

// Lookup texture

float3 TexColor = tex2D(ColorTextureSampler, In.TextureUV).rgb;

float3 n = FetchNormal(NormalHeightTextureSampler, In.TextureUV);

 

if (g_rendering_mode == RENDERING_MODE_LOCAL_NORMAL)

 // pack normal [-1..1]->[0..1] and output

 return (PS_OUTPUT)float4((normalize(n) + 1) * .5f, 1);

 

n = normalize(mul(n, (float3x3)g_mWorld));

 

if (g_rendering_mode == RENDERING_MODE_WORAL_NORMAL)

 // pack normal [-1..1]->[0..1] and output

 return (PS_OUTPUT)float4((n + 1) * .5f, 1);

 

Output.RGBColor.rgb = BlinnPhong(TexColor, n, v, l);

Output.RGBColor.a = 1.0;

if (g_reflections)

{

 // find reflection direction in world space

 float3 reflect_dir = reflect(-v, n);

 

 // Lookup cube map

 float3 reflect_color = texCUBE(CubeMapSampler, reflect_dir);

 

 // Combine with previous color

 Output.RGBColor.rgb = lerp(Output.RGBColor.rgb, reflect_color, g_reflectance);

}

if (g_rendering_mode == RENDERING_MODE_FINAL)

 return Output;

 

return (PS_OUTPUT)0;

}

//--------------------------------------------------------------------------------------

// Parallax Mapping 2 pixel shader

//--------------------------------------------------------------------------------------

PS_OUTPUT ParallaxMapping_2_PS(TRANSFORM_VS_OUTPUT In)

{

PS_OUTPUT Output;

// view and light directions

float3 v = normalize(g_Eye - In.WorldPos);

float3 l = g_WorldLightDir;

 

// parallax

float height = (1.0 - tex2D(NormalHeightTextureSampler, In.TextureUV).w) * g_max_height;

float3 offset = mul((float3x3)g_mWorld, v);

offset = float3(offset.xy, -offset.z);

offset *= g_max_height / offset.z;

In.TextureUV += height * offset;

 

// Lookup texture

float3 TexColor = tex2D(ColorTextureSampler, In.TextureUV).rgb;

float3 n = FetchNormal(NormalHeightTextureSampler, In.TextureUV);

 

if (g_rendering_mode == RENDERING_MODE_LOCAL_NORMAL)

 // pack normal [-1..1]->[0..1] and output

 return (PS_OUTPUT)float4((normalize(n) + 1) * .5f, 1);

 

n = normalize(mul(n, (float3x3)g_mWorld));

 

if (g_rendering_mode == RENDERING_MODE_WORAL_NORMAL)

 // pack normal [-1..1]->[0..1] and output

 return (PS_OUTPUT)float4((n + 1) * .5f, 1);

 

Output.RGBColor.rgb = BlinnPhong(TexColor, n, v, l);

Output.RGBColor.a = 1.0;

if (g_reflections)

{

 // find reflection direction in world space

 float3 reflect_dir = reflect(-v, n);

 

 // Lookup cube map

 float3 reflect_color = texCUBE(CubeMapSampler, reflect_dir);

 

 // Combine with previous color

 Output.RGBColor.rgb = lerp(Output.RGBColor.rgb, reflect_color, g_reflectance);

}

if (g_rendering_mode == RENDERING_MODE_FINAL)

 return Output;

 

return (PS_OUTPUT)0;

}

//--------------------------------------------------------------------------------------

// Parallax Occlusion Mapping pixel shader

//--------------------------------------------------------------------------------------

// Search intersection point in (+T +B -N) space

static float start_diff;

bool LinearSearch(in float3 dir, out float3 delta, inout float3 offset, in float2 uv, in float2 dx, in float2 dy, in float linear_search_delta, inout int steps)

{

if (dir.z > 0)

{

 // search down

 delta = dir / dir.z;

 delta *= g_max_height - offset.z;

}

else

{

 // search up

 delta = dir / -dir.z;

 delta *= offset.z;

}

float2 delta_tex = abs(delta.xy);

const float2 target_delta_tex = linear_search_delta / g_normal_height_map_res;

float2 delta_scale_xy = target_delta_tex / delta_tex;

float delta_scale = min(min(delta_scale_xy.x, delta_scale_xy.y), 1);

delta *= delta_scale;

 

start_diff = tex2Dgrad(NormalHeightTextureSampler, uv + offset, dx, dy).w * g_max_height - offset.z;

int cur_step = 0;

bool no_intersect = true;

while (offset.z <= g_max_height && offset.z >= 0 && (no_intersect = (tex2Dgrad(NormalHeightTextureSampler, uv + offset, dx, dy).w * g_max_height - offset.z) * start_diff > 0))

{

 cur_step++;

 offset += delta;

 steps++;

}

return no_intersect;

}

void BinarySearch(inout float3 dir, inout float3 delta, inout float3 offset, out float3 offset_back, in float2 uv, in float2 dx, in float2 dy, in int binary_search_steps, inout int steps)

{

offset_back = offset - delta;

if (start_diff != 0)

{

 float delta_len = length(delta);

 for (int cur_step = 0; cur_step < binary_search_steps; cur_step++)

 {

  delta *= 0.5;

  if ((tex2Dgrad(NormalHeightTextureSampler, uv + offset, dx, dy).w * g_max_height - offset.z) * start_diff > 0)

  {

   // outside

   if (delta_len > g_max_raytrace_bias)

    offset_back = offset;

   offset += delta;

  }

  else

   // inside

   offset -= delta;

  delta_len *= 0.5;

 }

 steps += binary_search_steps;

}

}

PS_OUTPUT ParallaxOcclusionMapping_PS(TRANSFORM_VS_OUTPUT In)

{

PS_OUTPUT Output;

 

bool grads_from_base_plane;

float2

 IntersectUV, // offset texcoords

 dx, dy;   // corresponding grads

 

int overall_search_steps = 0;

// view and light directions

float3 local_view = In.WorldPos - g_Eye;

float3 local_light = g_WorldLightDir;

 

// transform in (+T +B -N) space

local_view = mul((float3x3)g_mWorld, local_view);

 

float3 delta;

 

// offset in (+T +B -N) space

float3

 offset = 0,

 offset_back;

 

// compute gradients in base plane

float2 base_dx, base_dy;

float4(base_dx, base_dy) = float4(ddx(In.TextureUV), ddy(In.TextureUV));

 

// search intersection in view direction

LinearSearch(local_view, delta, offset, In.TextureUV, base_dx, base_dy, g_linear_search_delta, overall_search_steps);

BinarySearch(local_view, delta, offset, offset_back, In.TextureUV, base_dx, base_dy, g_binary_search_steps, overall_search_steps);

 

// offset texture coords

IntersectUV = In.TextureUV + offset;

 

// transform base offset in world space

float3 obj_offset = offset / g_tex_scale; // in object space

float3 world_offset = mul(obj_offset, (float3x3)g_mWorld);

// Intersection point in world space (used for lighting direction computation for point light sources)

float3 world_pos = In.WorldPos + world_offset;

// return (PS_OUTPUT)float4(obj_offset * 0.5 + 0.5, 1);

 

float shadow_factor;

 

// search intersection in light direction

if (g_cast_shadows)

{

 local_light = mul((float3x3)g_mWorld, local_light); // in (+T +B -N) space

 offset = offset_back;

 shadow_factor = LinearSearch(local_light, delta, offset, In.TextureUV, base_dx, base_dy, g_linear_search_delta, overall_search_steps);

}

else

 shadow_factor = 1;

// lookup texture

float3 TexColor;

float3 n;

if (g_grad_method == GRAD_METHOD_STD)

 grads_from_base_plane = false;

else

 if (g_grad_method == GRAD_METHOD_BASE_PLANE)

  grads_from_base_plane = true;

 else

  if (g_grad_method == GRAD_METHOD_HYBRID)

  {

   float4(dx, dy) = float4(ddx(IntersectUV), ddy(IntersectUV));

   grads_from_base_plane = max(dot(dx, dx), dot(dy, dy)) > g_grad_threshold;

  }

  else

   return (PS_OUTPUT)0;

//float4(dx, dy) = float4(ddx(IntersectUV), ddy(IntersectUV));

//if (g_grad_method == GRAD_METHOD_BASE_PLANE || g_grad_method == GRAD_METHOD_HYBRID && max(dot(dx, dx), dot(dy, dy)) > g_grad_threshold)

if (grads_from_base_plane)

{

 TexColor = tex2Dgrad(ColorTextureSampler, IntersectUV, base_dx, base_dy).rgb;

 n = FetchNormal(NormalHeightTextureSampler, IntersectUV, base_dx, base_dy).xyz;

}

else

{

 TexColor = tex2D(ColorTextureSampler, IntersectUV).rgb;

 n = FetchNormal(NormalHeightTextureSampler, IntersectUV).xyz;

}

 

if (g_height_diff_samples == 0) // normal from normal map

 n.z *= 0.5 / g_max_height;

 

n = normalize(n);

 

float3 local_normal = n;

 

if (g_rendering_mode == RENDERING_MODE_LOCAL_NORMAL)

 // pack normal [-1..1]->[0..1] and output

 return (PS_OUTPUT)float4((local_normal + 1) * .5f, 1);

 

n = normalize(mul(n, (float3x3)g_mWorld));

 

if (g_rendering_mode == RENDERING_MODE_WORAL_NORMAL)

 // pack normal [-1..1]->[0..1] and output

 return (PS_OUTPUT)float4((n + 1) * .5f, 1);

 

float3 v = normalize(g_Eye - In.WorldPos);

float3 l = g_WorldLightDir;

 

Output.RGBColor.rgb = BlinnPhong(TexColor, n, v, l, shadow_factor);

// search intersection in reflection direction

if (g_reflections)

{

 offset = offset_back;

 float3 local_reflect = reflect(local_view, local_normal);

 bool cube_map_reflect = LinearSearch(local_reflect, delta, offset, In.TextureUV, base_dx, base_dy, g_linear_search_delta, overall_search_steps);

 

 // Transoform reflection direction in world space

 // Length is meaningless, so it is not required to transform from unnormalized (+T +B -N) space to normalized (+t +b -n) space (object space) (in general case transformation in tangent space required)

 // Normalize for lighting calculations (normalization not required if g_mWorld orthogonal)

 float3 world_reflect = normalize(mul(local_reflect, (float3x3)g_mWorld));

 if (cube_map_reflect)

 {

  float3 reflect_color = texCUBE(CubeMapSampler, world_reflect).rgb;

  Output.RGBColor.rgb = lerp(Output.RGBColor.rgb, reflect_color, g_reflectance);

 }

 else

 {

  BinarySearch(local_reflect, delta, offset, offset_back, In.TextureUV, base_dx, base_dy, g_binary_search_steps, overall_search_steps);

  

  // transform offset in world space

  obj_offset = offset / g_tex_scale; // in object space

  world_offset = mul(obj_offset, (float3x3)g_mWorld);

  // Intersection point in world space (used for lighting direction computation for point light sources)

  world_pos = In.WorldPos + world_offset;

  // offset texture coords

  IntersectUV = In.TextureUV + offset;

  

  if (g_grad_method == GRAD_METHOD_STD)

   grads_from_base_plane = false;

  else

   if (g_grad_method == GRAD_METHOD_BASE_PLANE)

    grads_from_base_plane = true;

   else

    if (g_grad_method == GRAD_METHOD_HYBRID)

    {

     float4(dx, dy) = float4(ddx(IntersectUV), ddy(IntersectUV));

     grads_from_base_plane = max(dot(dx, dx), dot(dy, dy)) > g_grad_threshold;

    }

    else

     return (PS_OUTPUT)0;

//float4(dx, dy) = float4(ddx(IntersectUV), ddy(IntersectUV));

//if (g_grad_method == GRAD_METHOD_BASE_PLANE || g_grad_method == GRAD_METHOD_HYBRID && max(dot(dx, dx), dot(dy, dy)) > g_grad_threshold)

  if (grads_from_base_plane)

  {

   TexColor = tex2Dgrad(ColorTextureSampler, IntersectUV, base_dx, base_dy).rgb;

   n = FetchNormal(NormalHeightTextureSampler, IntersectUV, base_dx, base_dy).xyz;

  }

  else

  {

   TexColor = tex2D(ColorTextureSampler, IntersectUV).rgb;

   n = FetchNormal(NormalHeightTextureSampler, IntersectUV).xyz;

  }

  

  if (g_cast_shadows)

  {

   offset = offset_back;

   shadow_factor = LinearSearch(local_light, delta, offset, In.TextureUV, base_dx, base_dy, g_linear_search_delta, overall_search_steps);

  }

  else

   shadow_factor = 1;

  

  if (g_height_diff_samples == 0) // normal from normal map

   n.z *= 0.5 / g_max_height;

  

  n = normalize(mul(n, (float3x3)g_mWorld));

  float3 reflect_color = BlinnPhong(TexColor, n, -world_reflect, l, shadow_factor);

  Output.RGBColor.rgb = lerp(Output.RGBColor.rgb, reflect_color, g_reflectance);

 }

}

 

Output.RGBColor.a = 1.0;

 

// if (g_rendering_mode == RENDERING_MODE_SEARCH_STEPS)

//  return (PS_OUTPUT)(float(overall_search_steps) / (255 * 6));

 

if (g_rendering_mode == RENDERING_MODE_FINAL)

 return Output;

 

return (PS_OUTPUT)0;

}

//--------------------------------------------------------------------------------------

// Displacement mapping pixel shader

//--------------------------------------------------------------------------------------

PS_OUTPUT DisplacementMapping_PS(TRANSFORM_VS_OUTPUT In)

{

PS_OUTPUT Output;

 

Output.RGBColor.rgb = In.WorldPos;

Output.RGBColor.a = 1.0;

return Output;

}

//--------------------------------------------------------------------------------------

// Techniques

//--------------------------------------------------------------------------------------

technique Flat

{

pass P0

{

 VertexShader = compile vs_2_0 Transform_Reflect_VS();

 PixelShader  = compile ps_2_0 Flat_PS();

}

}

technique NormalMapping

{

pass P0

{

 VertexShader = compile vs_3_0 Transform_VS();

 PixelShader  = compile ps_3_0 NormalMapping_PS();

}

}

technique ParallaxMapping_1

{

pass P0

{

 VertexShader = compile vs_3_0 Transform_VS();

 PixelShader  = compile ps_3_0 ParallaxMapping_1_PS();

}

}

technique ParallaxMapping_2

{

pass P0

{

 VertexShader = compile vs_3_0 Transform_VS();

 PixelShader  = compile ps_3_0 ParallaxMapping_2_PS();

}

}

technique ParallaxOcclusionMapping

{

pass P0

{

 VertexShader = compile vs_3_0 Transform_VS();

 PixelShader  = compile ps_3_0 ParallaxOcclusionMapping_PS();

}

}

technique DisplacementMapping

{

pass P0

{

 VertexShader = compile vs_3_0 DisplacementMapping_VS();

 PixelShader  = compile ps_3_0 DisplacementMapping_PS();

}

}


LocalRayTracing.fx

//--------------------------------------------------------------------------------------

// File: LocalRayTracing.fx

//--------------------------------------------------------------------------------------

//--------------------------------------------------------------------------------------

// Includes

//--------------------------------------------------------------------------------------

#include "shared.fxh"

//--------------------------------------------------------------------------------------

// Global variables

//--------------------------------------------------------------------------------------

static const float3 g_MaterialAmbientColor  = { 0.2, 0.2, 0.2 }; // Material's ambient color

static const float3 g_MaterialDiffuseColor  = { 0.5, 0.5, 0.5 }; // Material's diffuse color

static const float3 g_MaterialSpecularColor = { 0.7, 0.7, 0.7 }; // Material's specular color

static const float g_Shine = 128;

float  g_reflectance;

bool  g_reflections;

bool  g_cast_shadows;

float3  g_Eye;       // Eye position in world space

float3  g_WorldLightDir;    // Normalized light's direction in world space

float4  g_LightDiffuse;     // Light's diffuse color

int   g_vertex_count;     // Mesh vertex count

int   g_face_count;     // Mesh face count

texture2D g_ColorTexture;     // Color texture for object

texture1D g_position_texture;    // Texture with vertex positions

texture1D g_texcoord_texture;    // Texture with vertex texcoords

float4x4 g_mWorld;      // World matrix for object

/*float3  PositionArray[12] =

{

float3(-1.f, -2.f, 0),

float3(+1.f, -2.f, 0),

float3(-1.f, 0, 0),

 

float3(-1.f, 0, 0),

float3(+1.f, -2.f, 0),

float3(+1.f, 0, 0),

float3(-1.f, 0, 0),

float3(+1.f, 0, 0),

float3(-1.f, 0, -2.f),

float3(-1.f, 0, -2.f),

float3(+1.f, 0, 0),

float3(+1.f, 0, -2.f)

};

float2  TexcoordArray[12] =

{

float2(0.f, 0.f),

float2(1.f, 0.f),

float2(0.f, 1.f),

float2(0.f, 1.f),

float2(1.f, 0.f),

float2(1.f, 1.f),

float2(0.f, 1.f),

float2(1.f, 1.f),

float2(0.f, 0.f),

float2(0.f, 0.f),

float2(1.f, 1.f),

float2(1.f, 0.f)

};*/

//--------------------------------------------------------------------------------------

// Texture samplers

//--------------------------------------------------------------------------------------

sampler2D ColorTextureSampler = sampler_state

{

   Texture = <g_ColorTexture>;

   MipFilter = LINEAR;

   MinFilter = ANISOTROPIC;

   MagFilter = LINEAR;

   MaxAnisotropy = 16;

};

sampler1D PositionSampler = sampler_state

{

Texture = <g_position_texture>;

MipFilter = NONE;

MinFilter = POINT;

MagFilter = POINT;

};

sampler1D TexcoordSampler = sampler_state

{

Texture = <g_texcoord_texture>;

MipFilter = NONE;

MinFilter = POINT;

MagFilter = POINT;

};

//--------------------------------------------------------------------------------------

// Vertex shaders output structures

//--------------------------------------------------------------------------------------

struct CUBEMAP_VS_OUTPUT

{

   float4 Position : POSITION;  // vertex position

   float2 TextureUV : TEXCOORD0; // vertex texture coords

   float3 WorldPos : TEXCOORD1; // vertex position in world space

   float3 Normal  : TEXCOORD2; // vertex normal in world space

   float3 Reflect  : TEXCOORD3; // vertex reflection direction in world space

   int  FaceID  : TEXCOORD4; // face id

};

struct RAYTRACE_VS_OUTPUT

{

   float4 Position  : POSITION;  // vertex position

   float2 TextureUV  : TEXCOORD0; // vertex texture coords

   float3 ObjPos   : TEXCOORD1; // vertex position in object space

   float3 WorldPos  : TEXCOORD2; // vertex position in world space

   float3 Normal   : TEXCOORD3; // vertex normal in world space

   float3 ObjReflect  : TEXCOORD4; // vertex reflection direction in object space

   float3 WorldReflect : TEXCOORD5; // vertex reflection direction in world space

   int  FaceID   : TEXCOORD6; // face id

};

//--------------------------------------------------------------------------------------

// Cube map vertex shader

//--------------------------------------------------------------------------------------

CUBEMAP_VS_OUTPUT CubeMap_VS(float3 vPos : POSITION, float3 vNormal : NORMAL, float2 vTexCoord0 : TEXCOORD0, int vFaceID : TEXCOORD1)

{

CUBEMAP_VS_OUTPUT Output;

 

float4x4 g_mWorldViewProjection = mul(g_mWorld, g_mViewProjection);

 

// Transform the position from object space to homogeneous projection space

Output.Position = mul(float4(vPos, 1), g_mWorldViewProjection);

 

// Just copy the texture coordinate through

Output.TextureUV = vTexCoord0;

 

// Transform the position from object space to world space

Output.WorldPos = mul(float4(vPos, 1), g_mWorld);

// view direction

float3 v = Output.WorldPos - g_Eye;

 

// Transform the normal from object space to world space

Output.Normal = normalize(mul(vNormal, (float3x3)g_mWorld)); // normal (world space)

 

// Flip normal if necessary

Output.Normal = faceforward(Output.Normal, v, Output.Normal);

 

// Find reflection direction in world space

Output.Reflect = reflect(v, Output.Normal);

 

// Just copy the face id through

Output.FaceID = vFaceID;

 

return Output;

}

//--------------------------------------------------------------------------------------

// Ray tracing vertex shader

//--------------------------------------------------------------------------------------

RAYTRACE_VS_OUTPUT Raytrace_VS(float3 vPos : POSITION, float3 vNormal : NORMAL, float2 vTexCoord0 : TEXCOORD0, int vFaceID : TEXCOORD1)

{

RAYTRACE_VS_OUTPUT Output;

 

float4x4 g_mWorldViewProjection = mul(g_mWorld, g_mViewProjection);

 

// Transform the position from object space to homogeneous projection space

Output.Position = mul(float4(vPos, 1), g_mWorldViewProjection);

 

// Just copy the texture coordinate through

Output.TextureUV = vTexCoord0;

 

// Just copy the object position through

Output.ObjPos = vPos;

 

// Transform the position from object space to world space

Output.WorldPos = mul(float4(vPos, 1), g_mWorld);

// view direction

float3 v = Output.WorldPos - g_Eye;

 

// Transform the normal from object space to world space

Output.Normal = normalize(mul(vNormal, (float3x3)g_mWorld)); // normal (world space)

 

// Flip normal if necessary

Output.Normal = faceforward(Output.Normal, v, Output.Normal);

 

// Find reflection direction in world space

Output.WorldReflect = reflect(v, Output.Normal);

 

// Transform reflection direction in object space

Output.ObjReflect = mul((float3x3)g_mWorld, Output.WorldReflect);

 

// Just copy the face id through

Output.FaceID = vFaceID;

 

return Output;

}

//--------------------------------------------------------------------------------------

// This function compute Blinn-Phong lighting

//--------------------------------------------------------------------------------------

float3 BlinnPhong(float3 TexColor, float3 n, float3 v, float3 l, float shadow = 1)

{

float3 h = normalize(v + l);

float3 color = g_MaterialDiffuseColor * TexColor * saturate(dot(l, n));

color += g_MaterialSpecularColor * pow(saturate(dot(h, n)), g_Shine);

color *= g_LightDiffuse;

color *= shadow;

color += g_MaterialAmbientColor * TexColor;

return color;

}

//--------------------------------------------------------------------------------------

// Flat pixel shader

//--------------------------------------------------------------------------------------

float4 CubeMap_PS(CUBEMAP_VS_OUTPUT In) : COLOR0

{

float4 Output;

 

// view and light directions

float3 v = normalize(g_Eye - In.WorldPos);

float3 l = normalize(g_WorldLightDir);

 

float3 n = normalize(In.Normal);

 

// Lookup texture

float3 TexColor = tex2D(ColorTextureSampler, In.TextureUV);

 

Output.rgb = BlinnPhong(TexColor, n, v, l);

Output.a = 1.0;

 

if (g_reflections)

{

 // Lookup cube map

 float3 reflect_color = texCUBE(CubeMapSampler, In.Reflect);

 

 // Combine with previous color

 Output.rgb = lerp(Output.rgb, reflect_color, g_reflectance);

}

return Output;

}

//--------------------------------------------------------------------------------------

// This function computes barycentric coordinates

//--------------------------------------------------------------------------------------

float3 Barycentric(in float3 v0, in float3 v1, in float3 v2, in float3 q)

{

float3 e1 = v1 - v0;

float3 e2 = v2 - v0;

float3 f = q - v0;

float e1_dot_e1 = dot(e1, e1);

float e1_dot_e2 = dot(e1, e2);

float e2_dot_e2 = dot(e2, e2);

float B = dot(e2_dot_e2 * e1 - e1_dot_e2 * e2, f);

float C = dot(e1_dot_e1 * e2 - e1_dot_e2 * e1, f);

float D = e1_dot_e1 * e2_dot_e2 - e1_dot_e2 * e1_dot_e2;

float3 bary;

bary.y = B / D;

bary.z = C / D;

bary.x = 1.f - bary.y - bary.z;

return bary;

}

//--------------------------------------------------------------------------------------

// This function computes distance from p to plane along u

// p - ray origin

// u - ray direction

// v0, v1, v2 - plain pints (noncollinear)

//--------------------------------------------------------------------------------------

float RayPlaneDistance(float3 p, float3 u, float3 v0, float3 v1, float3 v2)

{

// Plane normal

float3 n = cross(v1 - v0, v2 - v0);

 

// Distance from origin along normal

float d = dot(n, v0);

 

return (d - dot(p, n)) / dot(u, n);

}

//--------------------------------------------------------------------------------------

// This function finds first ray versus plane intersection (returns false if there is no intersection)

// base_face - face, containing p (it excluded from intersrction testing)

// p - ray origin

// u - ray direction

// face - intersection face

// q - intersection point

// bary - barycentric coordinates of q

//--------------------------------------------------------------------------------------

bool RayTrace(in int base_face, in float3 p, in float3 u, out int face, out float3 q, out float3 bary)

{

float dist = 1e38; // distance from p to plane along u

bool intersect = false;

for (int cur_face = 0; cur_face < g_face_count; cur_face++)

 if (cur_face != base_face)

 {

  // Fetch 3 face vertices

  float3 v0, v1, v2;

  float4 t = { (float)cur_face / g_face_count + 0.5f / g_vertex_count, 0, 0, 0 };

  v0 = tex1Dlod(PositionSampler, t);

  t.x += 1.f / g_vertex_count;

  v1 = tex1Dlod(PositionSampler, t);

  t.x += 1.f / g_vertex_count;

  v2 = tex1Dlod(PositionSampler, t);

/*   v0 = PositionArray[cur_face + 0];

  v1 = PositionArray[cur_face + 1];

  v2 = PositionArray[cur_face + 2];*/

  

  // Find distance from p to current plane along p

  float cur_dist = RayPlaneDistance(p, u, v0, v1, v2);

  

  // Find intersection point

  float3 cur_q = p + cur_dist * u;

  

  if (cur_dist > 0 && cur_dist < dist)

  {

   // Compute barycenrtic coordinates

   float3 cur_bary = Barycentric(v0, v1, v2, cur_q);

   

   if (all(cur_bary >= 0))

   {

    dist = cur_dist;

    face = cur_face;

    q = cur_q;

    bary = cur_bary;

    intersect = true;

   }

  }

 }

return intersect;

}

//--------------------------------------------------------------------------------------

// Raytracing pixel shader

//--------------------------------------------------------------------------------------

float4 Raytrace_PS(RAYTRACE_VS_OUTPUT In) : COLOR0

{

float4 Output;

// view and light directions

float3 v = normalize(g_Eye - In.WorldPos);

float3 l = normalize(g_WorldLightDir);

float3 obj_l = mul((float3x3)g_mWorld, g_WorldLightDir);

 

float3 n = normalize(In.Normal);

 

int intersect_face;

float3 obj_q, bary;

 

// Lookup texture

float3 TexColor = tex2D(ColorTextureSampler, In.TextureUV).rgb;

 

float shadow_factor;

 

// Trace in light direction (in object space)

if (g_cast_shadows)

 shadow_factor = !RayTrace(In.FaceID, In.ObjPos, obj_l, intersect_face, obj_q, bary);

else

 shadow_factor = 1;

// return float4(bary, 1);

 

Output.rgb = BlinnPhong(TexColor, n, v, l, shadow_factor);

Output.a = 1.0;

 

if (g_reflections)

{

 float3 reflect_color;

 

 if (RayTrace(In.FaceID, In.ObjPos, In.ObjReflect, intersect_face, obj_q, bary))

 {

  // Transform intersection point in world space

  float3 world_q = mul(obj_q, (float3x3)g_mWorld);

  

  float3 v0, v1, v2;

  float2 t0, t1, t2;

  float4 t = { (float)intersect_face / g_face_count + 0.5f / g_vertex_count, 0, 0, 0 };

  v0 = tex1Dlod(PositionSampler, t);

  t0 = tex1Dlod(TexcoordSampler, t);

  t.x += 1.f / g_vertex_count;

  v1 = tex1Dlod(PositionSampler, t);

  t1 = tex1Dlod(TexcoordSampler, t);

  t.x += 1.f / g_vertex_count;

  v2 = tex1Dlod(PositionSampler, t);

  t2 = tex1Dlod(TexcoordSampler, t);

/*   v0 = PositionArray[intersect_face + 0];

  t0 = TexcoordArray[intersect_face + 0];

  v1 = PositionArray[intersect_face + 1];

  t1 = TexcoordArray[intersect_face + 1];

  v2 = PositionArray[intersect_face + 2];

  t2 = TexcoordArray[intersect_face + 2];*/

  

  // View in direction of ray tracing

  v = normalize(In.WorldReflect); // normalize for lighting calculations

  

  // Compute normal

  float3 n = cross(v1 - v0, v2 - v0); // in object space

  n = normalize(mul(n, (float3x3)g_mWorld)); // in world space

  n = faceforward(n, v, n);

  

  // Compute texture coordinates

  float2 texUV = t0 * bary[0] + t1 * bary[1] + t2 * bary[2];

  

  // Lookup texture

  float3 TexColor = tex2D(ColorTextureSampler, texUV);

  

  // Trace in light direction (in object space)

  if (g_cast_shadows)

   shadow_factor = !RayTrace(intersect_face, obj_q, obj_l, intersect_face, obj_q, bary);

  else

   shadow_factor = 1;

  

  // Perform lighting

  reflect_color = BlinnPhong(TexColor, n, -v, l, shadow_factor);

//   reflect_color = bary;

 }

 else

 {

  // Lookup cube map

  reflect_color = texCUBE(CubeMapSampler, In.WorldReflect);

 }

 // Combine with previous color

 Output.rgb = lerp(Output.rgb, reflect_color, g_reflectance);

}

return Output;

}

/*float4 Raytrace_PS(RAYTRACE_VS_OUTPUT In) : COLOR0

{

float4 Output;

float3 v0, v1, v2;

float2 t0, t1, t2;

float4 t = { (float)In.FaceID / g_face_count + 0.5f / g_vertex_count, 0, 0, 0 };

v0 = tex1Dlod(PositionSampler, t);

t0 = tex1Dlod(TexcoordSampler, t);

t.x += 1.f / g_vertex_count;

v1 = tex1Dlod(PositionSampler, t);

t1 = tex1Dlod(TexcoordSampler, t);

t.x += 1.f / g_vertex_count;

v2 = tex1Dlod(PositionSampler, t);

t2 = tex1Dlod(TexcoordSampler, t);

Output.rgb = Barycentric(v0, v1, v2, In.ObjPos);

Output.a = 1.f;

Output.rgb = (float3(t0, 0));

return Output;

}*/

//--------------------------------------------------------------------------------------

// Techniques

//--------------------------------------------------------------------------------------

technique CubeMap

{

pass P0

{

 VertexShader = compile vs_2_0 CubeMap_VS();

 PixelShader  = compile ps_2_0 CubeMap_PS();

}

}

technique LocalRayRracing

{

pass P0

{

 VertexShader = compile vs_3_0 Raytrace_VS();

 PixelShader  = compile ps_3_0 Raytrace_PS();

}

}


P

Ns

Ng

H

S

TG

TS

TS`

S`

V

G

SP

TG

TS`

TS

S`

V

G

S

TG

TS

V

0

T0

S1

S4

S3

S2

T1

T2

T3

T4

S

TG

TS

V

S0

T0

S1

S4

S3

S2

T1

T2

T3

T4

S

TG

TS

T0

V

S0

T1

S1

S2

T2

S

TG

TS

V

S0

T0

S3

S4

S1

S2

T3

T2

T1

T4

ddx

ddy

C

R

U

C

R

U

D

L

0

2

0

0

-2

-1

-1

1

1

0

0

2

-2

0

1

-1

-1

1

N

R

L

N

R

L

S

S`

L

V

SL

R

SR

S

S`

L

V

R

S``

S

S`

L

V

R

S``

V

N

R

V

N

R

V

N

R

V

N1

R1

N2

R2

V

R`

N`


 

А также другие работы, которые могут Вас заинтересовать

57923. Вирусные болезни – глобальная опасность для человечества 58 KB
  Формирование предметных и ключевых компетентностей: обобщение знаний об особенностях строения и жизнедеятельности вирусов; значении вирусов в природе и жизни человека методах изучения вирусных болезней.
57924. Сравнение симптомов заболеваний, которые вызываются вирусами и бактериями. Профилактика инфекционных болезней человека 39.5 KB
  Цель урока: познакомить учащихся с симптомами методами диагностики и профилактики типичных бактериальных и вирусных заболеваний человека;– научить применять знания о процессах жизнедеятельности вирусов и бактерий для диагностики лечения...
57925. Води суходолу Північної Америки. Основні річкові системи. Великі озера, їх походження 69 KB
  Мета: сформувати в учнів систему знань про внутрішні води Північної Америки розкрити загальні особливості вод суходолу показати їх залежність від рельєфу та клімату нерівномірність розподілу на території материка...
57926. Основы объектно-ориентированного программирования. Создание формы 573.5 KB
  Цель: Сформировать у учащихся представление о среде программирования Visul Studio; освоить основные приемы создания форм получить практические навыки создания формы в среде программирования; формировать у учащихся информационную компетентность.
57927. Клітинний цикл. Мітоз 62.5 KB
  Німецький вчений Рудольф Вірхов стверджував що клітина може виникнути тільки з попередньої клітини в результаті її поділу. Відома його знаменита фраза усяка клітина –з клітини З таким поняттям як поділ клітини ви вже неодноразово зустрічались на уроках біології.
57928. Створення програм з використанням оператора циклу з параметром 140 KB
  Після цього уроку ви зможете: використовувати оператор циклу з параметром для створення програм обчислення суми та добутку скінченої кількості чисел знаходження кількості елементів з певними властивостями; наводити особливості накопичення суми та...
57929. Снежная книга Зимы 214.5 KB
  Цель: обобщить представления детей о зиме, познакомить с новыми рассказами и стихотворениями о зиме; продолжить работу над техникой чтения. Воспитывать любовь к родному слову, бережное отношение к природе.
57930. Цитологія – наука про будову і функції клітини. Історія вивчення клітини. Методи цитологічних досліджень 356 KB
  Мета: сформувати основні положення клітинної теоріїрозширити уявлення про історію вивчення клітини розкрити основні методи цитологічних досліджень; розвивати критичне і логічне мислення удосконалювати творчі здібності вміння...
57931. Зорі. Еволюція зір 340 KB
  І почнемо ми з вами саме з визначення найголовнішого небесного світила – зорі. учні дають визначення зорі Вчені прийшли до висновку що зорі включаючи і наше Сонце мають життєві цикли. Ці стадії різні оскільки зорі складаються з різних елементів і відрізняються розмірами.