Современные технологии компьютерной графики

[Введите текст]

Реферат

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

Задача курсовой работы — изучить программирование шейдеров. Для этого будет использоваться язык HLSL и среда разработки FX Composer от компании nVidia, созданная для работы с языками программирования шейдеров высокого уровня и их оптимальной работы с видеокартами nVidia. В качестве основы взята модель пистолета с сайта http://3dlenta.com/ и текстура металла из официального каталога nVidia. На выходе я получу изображение в формате.bmp.

HLSL (High Level Shader Language) — высокоуровневый Си-подобный язык для написания шейдеров, разработанный Microsoft и являющийся частью DirectX. Аналоги: GLSL (OpenGL), Cg (OpenGL, Direct3D).

HLSL пришел на смену ассемблерному шейдерному языку и позиционируется как более удобный язык для разработки шейдеров. Доступен для Direct3D начиная с версии 9.0 (возможно комбинирование кода на HLSL и asm). Начиная с Direct3D10 ассемблерные вставки запрещены. [1]

HLSL является современным и удобным языком программирования шейдеров. Позволяет без особых усилий создавать красивые 3-х и 2-х мерные изображения. Множество сред разработки поддерживают этот язык. Я в своей работе буду использовать среду разработки nVidia FX Composer, которая поддерживается и свободно распространяется компанией nVidia.

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

При рендеринге сложных объектов требуется большая вычислительная мощность и для того, чтобы уменьшить нагрузку на аппаратуру и потребность разработчиков в более современной технике используется негласное правило: все что можно посчитать — считай сам, все что нельзя посчитать самому считай в вершинном шейдере, а все остальное в пиксельном. Такой подход обусловлен тем, что пиксельный шейдер и без того перегружен вычислениями, и такой подход помогает равномерно распределить вычисления в течении всего создания изображения. [2]

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

Описание алгоритма решения задачи.

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

Скачать с репозиториев nVidia текстуру, соответствующую модели и задумке автора.

Средствами Composerа наложить текстуру на модель.

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

Описание программного продукта

Среда разработки: nVidia FX Composer.

Язык разработки: HLSL.

Аппаратные требования: видеокарта — nVidia с поддержкой Directx 9.0 и выше, процессор — 1 гГц, оперативная память — 512 mb.

Структура программы: программа состоит из 4 техник (Simple, Textured, SimpleFalloff, TexturedFalloff), одного вершинного шейдера (std_dp_VS), 5 пиксельных шейдеров (metal_shared, metalPS, metalPS_t, metalQPS, metalQPS_t).

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

Модель была скачана с сайта http://netlib.narod.ru

Рис. 1

Текстура была скачана с официального репозитория текстур nVidia.

Рис. 2

Инструкция пользователю

Программу для работы с шейдерами можно скачать с официального сайта nVidia http://developer.download.nvidia.com. После установки запускать ярлыком с рабочего стола или из меню «Пуск». Более подробная информация дана далее в описании интерфейса.

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

Описание интерфейса

Рис. 3

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

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

Рис. 4

В левой части окна можно видеть окна навигации по текстурам и материалам, в центральной — пустое окно для редактирования кода, которое заполнится текстом после выбора текстуры или материала, которые необходимо отредактировать, а в правой части окно свойств и моя законченная модель. Чтобы дать пользователю более комфортный режим работы с моделью необходимо переключится в режим PowerUser: Edit — Layouts — PowerUser.

Рис. 5

В таком режиме в левой части экрана располагается библиотека текстур и материалов nVidia, а в правой части — модель, которую можно вертуть, отдалять, приближать, выбирая лучший ракурс и сохранить 2D изображение с помощью крайней правой пентаграммы на панели инструментов Save Viewport to File, после чего появляется стандартное окно для сохранения файла с возможностью выбрать каталог для сохранения и расширение выходного изображения. bmp,.jpeg,.png.

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

Так же пользователь может самостоятельно удалить или изменить положение источника света, а так же добавить новый с помощью кнопки Add Point Light.

С помощью кнопок New и Open можно создать новый или открыть уже созданный проект. С помощью кнопки Import можно импортировать в проект еще модель или текстуру.

Описание структурных элементов программы

Вершинный шейдер std_dp_VS определяет вершины модели и в соответствии с ее формой применяет текстуру.

Пиксельный шейдер metal_shared нормализует вектора и задает цвет текстуре.

Пиксельный шейдер metalPS осуществляет предварительную подготовку цвета.

Пиксельный шейдер metalPS_t осуществляет окончательное применение цвета в мировых координатах Пиксельный шейдер metalQPS осуществляет предварительную подготовку отражения и источника света Пиксельный шейдер metalQPS_t отображает отражения и тени на лицевой стороне модели.

Изображение, полученное с помощью шейдеров:

шейдер трехмерный изображение программа Рис. 6

Заключение

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

1. http://ru.wikipedia.org/wiki/HLSL

2. http://www.gamedev.ru

3. http://netlib.narod.ru

4. http://developer.download.nvidia.com

Приложение

// #define _XSI_/* predefined when running in XSI */

// #define TORQUE/* predefined in TGEA 1.7 and up */

// #define _3DSMAX_/* predefined in 3DS Max */

#ifdef _3DSMAX_

int ParamID = 0×0003;/* Used by Max to select the correct parser */

#endif /* _3DSMAX_ */

#ifdef _XSI_

#define Main Static/* Technique name used for export to XNA */

#endif /* _XSI_ */

#ifndef FXCOMPOSER_VERSION/* for very old versions */

#define FXCOMPOSER_VERSION 180

#endif /* FXCOMPOSER_VERSION */

#ifndef DIRECT3D_VERSION

#define DIRECT3D_VERSION 0×900

#endif /* DIRECT3D_VERSION */

#define FLIP_TEXTURE_Y/* Different in OpenGL & DirectX */

/*** EFFECT-SPECIFIC CODE BEGINS HERE *********************/

/******* Lighting Macros *******/

/** To use «Object-Space» lighting definitions, change these two macros: **/

#define LIGHT_COORDS «World»

// #define OBJECT_SPACE_LIGHTS /* Define if LIGHT_COORDS is «Object» */

float Script: STANDARDSGLOBAL <

string UIWidget = «none» ;

string ScriptClass = «object» ;

string ScriptOrder = «standard» ;

string ScriptOutput = «color» ;

// string Script = «Technique=Technique?Simple:Simple10:Textured:Textured10:SimpleFalloff:SimpleFalloff10:TexturedFalloff:TexturedFalloff10;» ;

> = 0.8;

/**** UNTWEAKABLES: Hidden & Automatically-Tracked Parameters **********/

// transform object vertices to world-space:

float4x4 gWorldXf: World < string UIWidget="None"; >;

// transform object normals, tangents, & binormals to world-space:

float4x4 gWorldITXf: WorldInverseTranspose < string UIWidget="None"; >;

// transform object vertices to view space and project them in perspective:

float4x4 gWvpXf: WorldViewProjection < string UIWidget="None"; >;

// provide tranform from «view» or «eye» coords back to world-space:

float4x4 gViewIXf: ViewInverse < string UIWidget="None"; >;

/************* TWEAKABLES **************/

// «DirPos» Lamp 0 /////////

float4 gLamp0DirPos: POSITION < // or direction, if W==0

string Object = «Light0» ;

string UIName = «Lamp 0 Position/Direction» ;

string Space = (LIGHT_COORDS);

> = {-0.5f, 2.0f, 1.25f, 1.0};

float3 gLamp0Color: SPECULAR <

string UIName = «Lamp 0» ;

string Object = «Light0» ;

string UIWidget = «Color» ;

> = {1.0f, 1.0f, 1.0f};

float gLamp0Intensity <

string UIWidget = «slider» ;

float UIMin = 1.0;

float UIMax = 10 000.0f;

float UIStep = 0.1;

string UIName = «Lamp 0 Quadratic Intensity» ;

> = 1.0f;

// Ambient Light

float3 gAmbiColor: AMBIENT <

string UIName = «Ambient Light» ;

string UIWidget = «Color» ;

> = {0.07f, 0.07f, 0.07f};

// surface color

float3 gSurfaceColor: DIFFUSE <

string UIName = «Surface» ;

string UIWidget = «Color» ;

> = {1,1,1};

float gSpecExpon <

string UIWidget = «slider» ;

float UIMin = 1.0;

float UIMax = 128.0;

float UIStep = 1.0;

string UIName = «Specular Exponent» ;

> = 12.0;

float gKd <

string UIWidget = «slider» ;

float UIMin = 0.0;

float UIMax = 1.0;

float UIStep = 0.01;

string UIName = «Diffuse» ;

> = 0.1;

float gKr <

string UIWidget = «slider» ;

float UIMin = 0.0;

float UIMax = 1.0;

float UIStep = 0.05;

string UIName = «Reflection» ;

> = 0.2;

texture gColorTexture: DIFFUSE <

string ResourceName = «default_color.dds» ;

string UIName = «Diffuse Texture» ;

string ResourceType = «2D» ;

>;

sampler2D gColorSampler = sampler_state {

Texture = ;

#if DIRECT3D_VERSION >= 0xa00

Filter = MIN_MAG_MIP_LINEAR;

#else /* DIRECT3D_VERSION < 0xa00 */

MinFilter = Linear;

MipFilter = Linear;

MagFilter = Linear;

#endif /* DIRECT3D_VERSION */

AddressU = Wrap;

AddressV = Wrap;

};

texture gEnvTexture: ENVIRONMENT <

string ResourceName = «default_reflection.dds» ;

string UIName = «Environment» ;

string ResourceType = «Cube» ;

>;

samplerCUBE gEnvSampler = sampler_state {

Texture = ;

#if DIRECT3D_VERSION >= 0xa00

Filter = MIN_MAG_MIP_LINEAR;

#else /* DIRECT3D_VERSION < 0xa00 */

MinFilter = Linear;

MipFilter = Linear;

MagFilter = Linear;

#endif /* DIRECT3D_VERSION */

AddressU = Clamp;

AddressV = Clamp;

AddressW = Clamp;

};

/************* DATA STRUCTS **************/

/* data from application vertex buffer */

struct appdata {

float3 Position: POSITION;

float4 UV: TEXCOORD0;

float4 Normal: NORMAL;

float4 Tangent: TANGENT0;

float4 Binormal: BINORMAL0;

};

/* data passed from vertex shader to pixel shader */

struct vertexOutput {

float4 HPosition: POSITION;

float2 UV: TEXCOORD0;

// The following values are passed in «World» coordinates since

// it tends to be the most flexible and easy for handling

// reflections, sky lighting, and other «global» effects.

float3 LightVec: TEXCOORD1;

float3 WorldNormal: TEXCOORD2;

float3 WorldTangent: TEXCOORD3;

float3 WorldBinormal: TEXCOORD4;

float3 WorldView: TEXCOORD5;

};

/*********** vertex shader for pixel-shaded versions ******/

/*********** Generic Vertex Shader ******/

vertexOutput std_dp_VS (appdata IN,

uniform float4x4 WorldITXf, // our four standard «untweakable» xforms

uniform float4x4 WorldXf,

uniform float4x4 ViewIXf,

uniform float4x4 WvpXf,

uniform float4 LampDirPos

) {

vertexOutput OUT = (vertexOutput)0;

OUT.WorldNormal = mul (IN.Normal, WorldITXf).xyz;

OUT.WorldTangent = mul (IN.Tangent, WorldITXf).xyz;

OUT.WorldBinormal = mul (IN.Binormal, WorldITXf).xyz;

float4 Po = float4(IN.Position.xyz, 1);

float4 Pw = mul (Po, WorldXf);// convert to «world» space

#ifdef OBJECT_SPACE_LIGHTS

float4 Lw = mul (LampDirPos, WorldXf);// convert to «world» space

#else /* !OBJECT_SPACE_LIGHTS — standard world-space lights */

float4 Lw = LampDirPos;

#endif /* !OBJECT_SPACE_LIGHTS */

if (Lw.w == 0) {

OUT.LightVec = -normalize (Lw.xyz);

} else {

// we are still passing a (non-normalized) vector

OUT.LightVec = Lw. xyz — Pw. xyz;

}

#ifdef FLIP_TEXTURE_Y

OUT.UV = float2(IN.UV.x,(1.0-IN.UV.y));

#else /* !FLIP_TEXTURE_Y */

OUT.UV = IN.UV.xy;

#endif /* !FLIP_TEXTURE_Y */

OUT.WorldView = normalize (ViewIXf[3]. xyz — Pw. xyz);

OUT.HPosition = mul (Po, WvpXf);

return OUT;

}

/********* pixel shaders ********/

void metal_shared (vertexOutput IN,

uniform float Kd,

uniform float SpecExpon,

uniform float Kr,

uniform samplerCUBE EnvSampler,

float3 LightColor,

uniform float3 AmbiColor,

out float3 DiffuseContrib,

out float3 SpecularContrib)

{

float3 Ln = normalize (IN.LightVec.xyz);

float3 Nn = normalize (IN.WorldNormal);

float3 Vn = normalize (IN.WorldView);

float3 Hn = normalize (Vn + Ln);

float4 litV = lit (dot (Ln, Nn), dot (Hn, Nn), SpecExpon);

DiffuseContrib = litV. y * Kd * LightColor + AmbiColor;

SpecularContrib = litV. z * LightColor;

float3 reflVect = -reflect (Vn, Nn);

float3 ReflectionContrib = Kr * texCUBE (EnvSampler, reflVect).rgb;

SpecularContrib += ReflectionContrib;

}

float4 metalPS (vertexOutput IN,

uniform float3 SurfaceColor,

uniform float Kd,

uniform float SpecExpon,

uniform float Kr,

uniform samplerCUBE EnvSampler,

uniform float3 LampColor,

uniform float3 AmbiColor

): COLOR {

float3 diffContrib;

float3 specContrib;

metal_shared (IN, Kd, SpecExpon, Kr,

EnvSampler, LampColor, AmbiColor,

diffContrib, specContrib);

float3 result = SurfaceColor * (specContrib + diffContrib);

return float4(result, 1);

}

float4 metalPS_t (vertexOutput IN,

uniform float3 SurfaceColor,

uniform sampler2D ColorSampler,

uniform float Kd,

uniform float SpecExpon,

uniform float Kr,

uniform samplerCUBE EnvSampler,

uniform float3 LampColor,

uniform float3 AmbiColor

): COLOR {

float3 diffContrib;

float3 specContrib;

metal_shared (IN, Kd, SpecExpon, Kr,

EnvSampler, LampColor, AmbiColor,

diffContrib, specContrib);

float3 map = tex2D (ColorSampler, IN. UV).xyz;

float3 result = SurfaceColor * map * (specContrib + diffContrib);

return float4(result, 1);

}

float4 metalQPS (vertexOutput IN,

uniform float3 SurfaceColor,

uniform float Kd,

uniform float SpecExpon,

uniform float Kr,

uniform samplerCUBE EnvSampler,

uniform float3 LampColor,

uniform float LampIntensity,

uniform float3 AmbiColor

): COLOR {

float3 diffContrib;

float3 specContrib;

float3 Cl = (LampIntensity/dot (IN.LightVec.xyz, IN.LightVec.xyz)) * LampColor;

metal_shared (IN, Kd, SpecExpon, Kr,

EnvSampler, Cl, AmbiColor,

diffContrib, specContrib);

float3 result = SurfaceColor * (specContrib + diffContrib);

return float4(result, 1);}

float4 metalQPS_t (vertexOutput IN,

uniform float3 SurfaceColor,

uniform sampler2D ColorSampler,

uniform float Kd,

uniform float SpecExpon,

uniform float Kr,

uniform samplerCUBE EnvSampler,

uniform float3 LampColor,

uniform float LampIntensity,

uniform float3 AmbiColor

): COLOR {

float3 diffContrib;

float3 specContrib;

float3 Cl = (LampIntensity/dot (IN.LightVec.xyz, IN.LightVec.xyz)) * LampColor;

metal_shared (IN, Kd, SpecExpon, Kr,

EnvSampler, Cl, AmbiColor,

diffContrib, specContrib);

float3 map = tex2D (ColorSampler, IN. UV).xyz;

float3 result = SurfaceColor * map * (diffContrib+specContrib);

return float4(result, 1);}

/// TECHNIQUES ////////////////////////

#if DIRECT3D_VERSION >= 0xa00

// Standard DirectX10 Material State Blocks

RasterizerState DisableCulling {CullMode = NONE;};

DepthStencilState DepthEnabling {DepthEnable = TRUE;};

DepthStencilState DepthDisabling {

DepthEnable = FALSE;

DepthWriteMask = ZERO;};

BlendState DisableBlend {BlendEnable[0] = FALSE;};

technique10 Simple10 <

string Script = «Pass=p0;» ;

> {

pass p0 <

string Script = «Draw=geometry;» ;

> {

SetVertexShader (CompileShader (vs₄_0, std_dp_VS (gWorldITXf, gWorldXf,

gViewIXf, gWvpXf,

gLamp0DirPos)));

SetGeometryShader (NULL);

SetPixelShader (CompileShader (ps₄_0, metalPS (gSurfaceColor,

gKd, gSpecExpon, gKr,

gEnvSampler,

gLamp0Color, gAmbiColor)));

SetRasterizerState (DisableCulling);

SetDepthStencilState (DepthEnabling, 0);

SetBlendState (DisableBlend, float4(0.0f, 0.0f, 0.0f, 0.0f), 0xFFFFFFFF);}}

#endif /* DIRECT3D_VERSION >= 0xa00 */

technique Simple <

string Script = «Pass=p0;» ;

> {pass p0 <

string Script = «Draw=geometry;» ;

> {

VertexShader = compile vs₃_0 std_dp_VS (gWorldITXf, gWorldXf,

gViewIXf, gWvpXf,

gLamp0DirPos);

ZEnable = true;

ZWriteEnable = true;

ZFunc = LessEqual;

AlphaBlendEnable = false;

CullMode = None;

PixelShader = compile ps₃_0 metalPS (gSurfaceColor,

gKd, gSpecExpon, gKr,

gEnvSampler,

gLamp0Color, gAmbiColor);

}

}

#if DIRECT3D_VERSION >= 0xa00

technique10 Textured10 <

string Script = «Pass=p0;» ;

> { pass p0 <

string Script = «Draw=geometry;» ;

> {

SetVertexShader (CompileShader (vs₄_0, std_dp_VS (gWorldITXf, gWorldXf,

gViewIXf, gWvpXf,

gLamp0DirPos)));

SetGeometryShader (NULL);

SetPixelShader (CompileShader (ps₄_0, metalPS_t (gSurfaceColor, gColorSampler,

gKd, gSpecExpon, gKr,

gEnvSampler,

gLamp0Color, gAmbiColor)));

SetRasterizerState (DisableCulling);

SetDepthStencilState (DepthEnabling, 0);

SetBlendState (DisableBlend, float4(0.0f, 0.0f, 0.0f, 0.0f), 0xFFFFFFFF);}}

#endif /* DIRECT3D_VERSION >= 0xa00 */

technique Textured <

string Script = «Pass=p0;» ;

> {

pass p0 <

string Script = «Draw=geometry;» ;

> {

VertexShader = compile vs₃_0 std_dp_VS (gWorldITXf, gWorldXf,

gViewIXf, gWvpXf,

gLamp0DirPos);

ZEnable = true;

ZWriteEnable = true;

ZFunc = LessEqual;

AlphaBlendEnable = false;

CullMode = None;

PixelShader = compile ps₃_0 metalPS_t (gSurfaceColor, gColorSampler,

gKd, gSpecExpon, gKr,

gEnvSampler,

gLamp0Color, gAmbiColor);}}

// pixel shaded, quadratic falloff

#if DIRECT3D_VERSION >= 0xa00

technique10 SimpleFalloff10 <

string Script = «Pass=p0;» ;

> { pass p0 <

string Script = «Draw=geometry;» ;

> {

SetVertexShader (CompileShader (vs₄_0, std_dp_VS (gWorldITXf, gWorldXf,

gViewIXf, gWvpXf,

gLamp0DirPos)));

SetGeometryShader (NULL);

SetPixelShader (CompileShader (ps₄_0, metalQPS (gSurfaceColor,

gKd, gSpecExpon, gKr,

gEnvSampler,

gLamp0Color, gLamp0Intensity,

gAmbiColor)));

SetRasterizerState (DisableCulling);

SetDepthStencilState (DepthEnabling, 0);

SetBlendState (DisableBlend, float4(0.0f, 0.0f, 0.0f, 0.0f), 0xFFFFFFFF);

}

}

#endif /* DIRECT3D_VERSION >= 0xa00 */

technique SimpleFalloff <

string Script = «Pass=p0;» ;

> {

pass p0 <

string Script = «Draw=geometry;» ;

> {

VertexShader = compile vs₃_0 std_dp_VS (gWorldITXf, gWorldXf,

gViewIXf, gWvpXf,

gLamp0DirPos);

ZEnable = true;

ZWriteEnable = true;

ZFunc = LessEqual;

AlphaBlendEnable = false;

CullMode = None;

PixelShader = compile ps₃_0 metalQPS (gSurfaceColor,

gKd, gSpecExpon, gKr,

gEnvSampler,

gLamp0Color, gLamp0Intensity,

gAmbiColor);}}

#if DIRECT3D_VERSION >= 0xa00

technique10 TexturedFalloff10 <

string Script = «Pass=p0;» ;

> {

pass p0 <

string Script = «Draw=geometry;» ;

> {

SetVertexShader (CompileShader (vs₄_0, std_dp_VS (gWorldITXf, gWorldXf,

gViewIXf, gWvpXf,

gLamp0DirPos)));

SetGeometryShader (NULL);

SetPixelShader (CompileShader (ps₄_0, metalQPS_t (gSurfaceColor, gColorSampler,

gKd, gSpecExpon, gKr,

gEnvSampler,

gLamp0Color, gLamp0Intensity,

gAmbiColor)));

SetRasterizerState (DisableCulling);

SetDepthStencilState (DepthEnabling, 0);

SetBlendState (DisableBlend, float4(0.0f, 0.0f, 0.0f, 0.0f), 0xFFFFFFFF);}}

#endif /* DIRECT3D_VERSION >= 0xa00 */

technique TexturedFalloff <

string Script = «Pass=p0;» ;

> {pass p0 <

string Script = «Draw=geometry;» ;

> {

VertexShader = compile vs₃_0 std_dp_VS (gWorldITXf, gWorldXf,

gViewIXf, gWvpXf,

gLamp0DirPos);

ZEnable = true;

ZWriteEnable = true;

ZFunc = LessEqual;

AlphaBlendEnable = false;

CullMode = None;

PixelShader = compile ps₃_0 metalQPS_t (gSurfaceColor, gColorSampler,

gKd, gSpecExpon, gKr,

gEnvSampler,

gLamp0Color, gLamp0Intensity,

gAmbiColor);

}

}