}</syntaxhighlight>

<syntaxhighlight lang="cpp">template <class T = Vertex>class APIVertexDeclaration {  static D3DVERTEXELEMENT9 fmt[MAXD3DDECLLENGTH + 1]; static unsigned vertexSize; public: static D3DVERTEXELEMENT9*format() { return fmt; } static unsigned size() { return vertexSize; }};</syntaxhighlight><syntaxhighlight lang="cpp">template <>D3DVERTEXELEMENT9 APIVertexDeclaration<Vertex>::fmt[MAXD3DDECLLENGTH + 1] = { { 0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0}, { 0, 12, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL, 0}, { 0, 24, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0}, D3DDECL_END()}; template<>unsigned APIVertexDeclaration<Vertex>::vertexSize = 32;</syntaxhighlight><syntaxhighlight lang="cpp"> template <>D3DVERTEXELEMENT9 APIVertexDeclaration<LitVertex>::fmt[MAXD3DDECLLENGTH + 1] = { { 0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0}, { 0, 12, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0}, D3DDECL_END()}; template <>unsigned APIVertexDeclaration<LitVertex>::vertexSize = 16;</syntaxhighlight>:: [http://msdn.microsoft.com/en-us/library/windows/desktop/bb172630%28v=vs.85%29.aspx D3DVERTEXELEMENT9 struct]

// Types//// Light holds the data for a single static light in world space//struct Light { int type; // POINT_LIGHT, SPOT_LIGHT, DIRECTIONAL_LIGHT float3 ambient; float3 diffuse; float3 specular; float3 direction; // in world space float3 position; // in world space float3 attenuation; // .xyz for 1.0f/ (.x + .y * d + .z * d * d) float3 spot; // .x = cos(phi/2), .y = cos(theta/2), .z = falloff float range; // where attenuation becomes 0}; // Material holds the reflectivity properties of the material//struct Material { float4 ambient; float4 diffuse; float4 specular; float power;}; // RawPixel holds the data for a single fragment of the stream//struct RawPixel { float2 texcoord : TEXCOORD0; // texture coordinate at this fragment float3 position : TEXCOORD1; // fragment position in world space float3 normal : TEXCOORD2; // lighting normal in world space float3 toViewer : TEXCOORD3; // direction to viewer in world space}; // Uniform Data (constant for a stream of fragments)//float4 ambient; // global ambient light - always onint noLights; // no of static lightsLight light[MLIGHTS]; // static lightsbool lightOn[MLIGHTS]; // light switchMaterial material; // material reflectivity bool texOn; // texture switchsampler2D tex; // set by the application // Types//// RawVertex holds the original data for a vertex in the stream//struct RawVertex {  float3 position : POSITION; // position in local space float3 normal : NORMAL; // normal in local space float2 texCoord : TEXCOORD0; // texture coordinates}; // TransformedVertex holds the transformed data for the vertex//struct TransformedVertex {  float4 position : POSITION; // position in homogeneous clip space float2 texCoord : TEXCOORD; // texture coordinates float3 worldPos : TEXCOORD1; // position in world space float3 worldNor : TEXCOORD2; // lighting normal in world space float3 toViewer : TEXCOORD3; // direction to viewer in world space}; // Uniform Data (constant for the stream of vertices)//// Geometryfloat4x4 viewProjection; // view * projection transformationfloat4x4 world; // world transformationfloat4 viewPoint; // camera viewpoint for specular calcs// Geometryfloat3 heading; // camera heading for specular calcs// Lit Vertexbool litVertex; // omit lighting calculations - already lit </syntaxhighlight>: effects.fx - VertexShader<syntaxhighlight lang="cpp">// vertexShader receives a raw data for a vertex and transforms that data//TransformedVertex vertexShader(RawVertex raw) {  TransformedVertex transformed; // result returned by this function float4 worldPosition; // world position of the vertex float3 worldNormal; // vertex normal in world space  // Transform the vertex to homogeneous clip coordinates // // A more efficient algorithm would accept the world*view*projection // tranformation as one uniform matrix and avoid the 2-stage product // This will require a bit of restructuring of the application code. // worldPosition = mul(float4(raw.position, 1.0), world); // local to world transformed.position = mul(worldPosition, viewProjection); //... to clip transformed.worldPos = worldPosition.xyz;  // Transform the vertex normal to world space. Only the rotation-scaling // part of the world transformation is used. Since the world // transformation may contain scaling, the result of this multiplication // needs to be normalized. // worldNormal = mul(raw.normal, (float3x3)world); worldNormal = normalize(worldNormal); transformed.worldNor = worldNormal; // Determine the direction from the camera's viewpoint to this vertex for // subsequent lighting calculations // transformed.toViewer = normalize(viewPoint - worldPosition.xyz); // pass the texture coordinates along unaltered // transformed.texCoord = raw.texCoord;  return transformed;} </syntaxhighlight>: effects.fx - FragmentShader<!syntaxhighlight lang="cpp">// The fragment shader receives raw fragment data and returns a pixel colour//float4 fragmentShader(RawPixel raw) : COLOR {  float4 colour; // result returned by this function float3 normal; // normal to the fragment float3 toViewer; // from fragment to the camera float3 toLightSource; // from fragment to current light source // lighting contribution accumulators float3 ambientLight = ambient.xyz; float3 diffuseLight = (float3)0; float3 specularLight = (float3)0; // lighting calculation factors float diffuseFactor, reflectFactor, distance; float attenuationFactor, spotFactor, rho; // normalize the fragment data normal = normalize(raw.normal); toViewer = normalize(raw.toViewer); // perform calculations for each light in turn for (int i = 0; i < noLights && i < MLIGHTS; i++) { if (lightOn[i]) { float diffuseFactor, reflectFactor, factor; // diffuse and reflection factors toLightSource = normalize((light[i].type == POINT_LIGHT)? light[i].position - raw.position : - light[i].direction); diffuseFactor = saturate(dot(normal, toLightSource)); reflectFactor = saturate(dot(normalize(2 * diffuseFactor * normal - toLightSource), toViewer));  attenuationFactor = 1.0f; spotFactor = 1.0f; if (light[i].type == POINT_LIGHT || light[i].type == SPOT_LIGHT) { // detail calcs for attenuationFactor and spotFactor distance = length(raw.position - light[i].position); if (distance < light[i].range) { attenuationFactor = light[i].attenuation.x + light[i].attenuation.y * distance + light[i].attenuation.z * distance * distance; attenuationFactor = 1.0f / attenuationFactor; if (light[i].type == SPOT_LIGHT) { rho = saturate(dot(normalize(light[i].position - float3(raw.position.x, raw.position.y, raw.position.z)), normalize(-light[i].direction))); if (rho <= light[i].spot.x) spotFactor = 0.0f; else if (rho <= light[i].spot.y) spotFactor = pow(abs( (rho - light[i].spot.x)/ (light[i].spot.y - light[i].spot.x)), light[i].spot.z); } } else attenuationFactor = 0.0f; }  // accumulate ambient, diffuse, and specular elements of light // ambientLight += attenuationFactor * spotFactor * light[i].ambient.xyz; diffuseLight += attenuationFactor * spotFactor * diffuseFactor * light[i].diffuse.xyz; specularLight += attenuationFactor * spotFactor * light[i].specular.xyz * pow(reflectFactor, material.power); } } // apply material reflectivity to each accumulated element of light // to obtain the colour of the lit fragment // colour.xyz = saturate(material.ambient.xyz * ambientLight) + saturate(material.diffuse.xyz * diffuseLight) + saturate(material.specular.xyz * specularLight); colour.w = material.diffuse.w;  // apply texture // if (texOn) colour *= tex2D(tex, raw.texcoord);  return colour;}</syntaxhighlight>: effects.fx -technique opaque<syntaxhighlight lang="cpp">technique opaque { pass { VertexShader = compile vs_3_0 vertexShader(); PixelShader = compile ps_3_0 fragmentShader(); }} </syntaxhighlight>: effects.fx -technique translucent<syntaxhighlight lang="cpp">technique translucent { pass { VertexShader = compile vs_3_0 vertexShader(); PixelShader = compile ps_3_0 fragmentShader(); }}</syntaxhighlight><syntaxhighlight lang="cpp"></syntaxhighlight>=== To Do ====== Resources === == Week 8 - Mar 4 ===== This Week ===* Frank Luna's notes for DirectX10 (page 306):[http://books.google.ca/books?id=AyACb-t8E-MC&pg=PA306&lpg=PA306#v=onepage&q&f=false Environment Maps](Google books):[http://libcat.senecac.on.ca/vwebv/holdingsInfo?searchId=19588&recCount=50&recPointer=2&bibId=261220 Environment Maps](Seneca ELibraray) * Design.cpp: Design::initialize() - create the skybox object<syntaxhighlight lang="cpp">// initialize initializes the general display design coordinator, creates the// primitive sets, textures, objects, lights, sounds, cameras, and text items//void Design::initialize() {  // ...  // create textures iTexture* sunset = CreateCubeTexture(L"Islands.dds");  // ...  iObject* skybox = CreateSkybox(); skybox->rotatex(-1.5708f); skybox->attach(sunset); setSkybox(skybox);  // ...}</syntaxhighlight>* Coordinator.cpp: Coordinator::render() - using different techniques for different objects<syntaxhighlight lang="cpp">void Coordinator::render() {  // adjust framecount and fps if (now - lastReset <= unitsPerSec) framecount++; else { // recalculate the frame rate fps = framecount * unitsPerSec / (now - lastReset); framecount = 0; lastReset = now; if (timerText) { wchar_t str[MAX_DESC + 1]; sprintf(str, fps, L" fps"); timerText->set(str); } } // update the user input devices userInput->update(); Coordinator::update(); // update the model update(); // update the audio audio->setVolume(volume); audio->setFrequencyRatio(frequency); audio->update(Camera::getView());  // start rendering display->beginDrawFrame(Camera::getView()); display->setAmbientLight(ambient.r, ambient.g, ambient.b); unsigned nPasses; // render all of the opaque unlit objects display->beginEffect("opaque", nPasses); for (unsigned i = 0; i < nPasses; i++) { display->beginPass(i); render(OPAQUE_OBJECT); display->endPass(); } display->endEffect(); // render all of the translucent unlit objects display->beginEffect("translucent", nPasses); for (unsigned i = 0; i < nPasses; i++) { display->beginPass(i); render(TRANSLUCENT_OBJECT); display->endPass(); } display->endEffect(); // render all of the lit objects display->beginEffect("litObjects", nPasses); for (unsigned i = 0; i < nPasses; i++) { display->beginPass(i); render(LIT_OBJECT); display->endPass(); } display->endEffect(); // render the skybox display->beginEffect("skybox", nPasses); if (background && !skybox) { Rectf fullScreen(0, 0, 1, 1); display->beginDrawHUD(0); background->render(fullScreen, true); display->endDrawHUD(); } else if (skybox) { for (unsigned i = 0; i < nPasses; i++) { display->beginPass(i); render(SKYBOX); display->endPass(); } } display->endEffect(); display->set(ALPHA_BLEND, false); display->beginDrawHUD(HUD_ALPHA); render(ALL_HUDS); display->endDrawHUD(); display->endDrawFrame(); render(ALL_SOUNDS);}</syntaxhighlight>: Coordinator::render(iObject*) - render a single object one subset at a time<syntaxhighlight lang="cpp">void Coordinator::render(iObject* object) {  display->setWorld(&object->world()); unsigned nSubsets = object->noSubsets(); for (unsigned i = 0; i < nSubsets; i++) { iTexture* texture = object->getTexture(i); if (texture) texture->attach(); display->setReflectivity(object->getReflectivity(i)); object->render(i); if (texture) texture->detach(); }}</syntaxhighlight>* Skybox class: iObject interface - CreateSkybox declaration<syntaxhighlight lang="cpp">class iObject : public Shape, public Base { public: // initialization virtual void attach(iTexture* t) = 0; virtual void attach(iTexture** t) = 0; // execution virtual unsigned noSubsets() const = 0; virtual void render(unsigned) = 0; virtual void setTextureFilter(unsigned) = 0; virtual iTexture* getTexture(unsigned) const = 0; virtual const void* getReflectivity(unsigned) const = 0; virtual bool belongsTo(Category category) const = 0;}; iObject* CreateObject(iGraphic*, const Reflectivity* = nullptr, unsigned = 1u);iObject* CreateBillboard(BillboardType, iGraphic*, const Reflectivity* = nullptr);iObject* CreateSkybox(); iObject* Clone(const iObject*);</syntaxhighlight>: Skybox class - derived from Object<syntaxhighlight lang="cpp">//-------------------------------- Skybox -------------------------------------//// A Skybox is an inverted Object that translates with the viewpoint//class Skybox : public Object { public: Skybox(); void render(unsigned);};</syntaxhighlight>: CreateSkybox<syntaxhighlight lang="cpp">iObject* CreateSkybox() {  return new Skybox();}</syntaxhighlight>: Skybox::Skybox - SKYBOX category, 2 x 2 x 2 cube<syntaxhighlight lang="cpp">Skybox::Skybox() : Object(SKYBOX, CreateIBox(-1, -1, -1 * MODEL_Z_AXIS, 1, 1, 1 * MODEL_Z_AXIS)) {}</syntaxhighlight>: Skybox::render(unsigned) - move skybox centroid to current camera position<syntaxhighlight lang="cpp">void Skybox::render(unsigned) {  Camera* camera = *(Camera**)(Camera::getCurrent()); Vector disp = camera->position() - position(); translate(disp.x, disp.y, disp.z);  Object::render(0);}</syntaxhighlight>* Texture class: iTexture interface - CreateCubeTexture declaration<syntaxhighlight lang="cpp">class iTexture : public Base { public: virtual void attach() const = 0; virtual void setFilter(unsigned) const = 0; virtual void detach() = 0; virtual void render(const Rectf&, bool = false) = 0;}; iTexture* CreateTexture(const wchar_t* file, unsigned filter = 0);iTexture* CreateCubeTexture(const wchar_t* file, unsigned filter = 0); iTexture* Clone(const iTexture*);</syntaxhighlight>: Texture class - add the cube parameter to constructor<syntaxhighlight lang="cpp">class Texture : public iTexture {  iAPITexture* apiTexture; // points to the api texture  Texture(const Texture&); virtual ~Texture();  public: Texture(const wchar_t* file, unsigned filter = 0, bool cube = false); Texture& operator=(const Texture&); void* clone() const { return new Texture(*this); } // execution void attach() const; void setFilter(unsigned) const; void detach(); void render(const Rectf&, bool); // termination void suspend(); void release();};</syntaxhighlight>: CreateCubeTexture - call constructor with true flag for cube<syntaxhighlight lang="cpp">iTexture* CreateCubeTexture(const wchar_t* file, unsigned filter) {  return new Texture(file, filter, true);}</syntaxhighlight>: Texture::Texture() - create APICubeTexture()<syntaxhighlight lang="cpp">Texture::Texture(const wchar_t* file, unsigned filter, bool cube) {  coordinator->add(this);  wchar_t* fileWithPath = nullptr; if (file) { // add the directory to create the relative filename int len = strlen(file) + strlen(TEXTURE_DIRECTORY) + 1; fileWithPath = new wchar_t[len + 1]; ::nameWithDir(fileWithPath, TEXTURE_DIRECTORY, file, len); }  // apiTexture on the graphics device if (cube) apiTexture = CreateAPICubeTexture(fileWithPath); else apiTexture = CreateAPITexture(fileWithPath, filter);  if (fileWithPath) delete [] fileWithPath;}</syntaxhighlight>: iAPITexture interface - add CreateAPICubeTexture declaration<syntaxhighlight lang="cpp">class iAPITexture { public: virtual iAPITexture* clone() const = 0; // execution virtual void attach() = 0; virtual void setFilter(unsigned flags) = 0; virtual void detach() = 0; virtual void render(const Rectf&, unsigned char, bool = false) = 0; // termination virtual void suspend() = 0; virtual void release() = 0; virtual void Delete() const = 0;}; iAPITexture* CreateAPITexture(const wchar_t* file, unsigned filter);iAPITexture* CreateAPICubeTexture(const wchar_t* file);</syntaxhighlight>* APITexture.h: APICubeTexture class definition<syntaxhighlight lang="cpp">class APICubeTexture : public iAPITexture, public APIBase {  wchar_t* file; // points to file with texture image unsigned filter; // default texture filtering flags  IDirect3DCubeTexture9* tex; // interface to texture COM object  virtual ~APICubeTexture();  void setup();  public: APICubeTexture(const wchar_t* file); APICubeTexture(const APICubeTexture&); iAPITexture& operator=(const APICubeTexture&); iAPITexture* clone() const { return new APICubeTexture(*this); } // execution void attach(); void setFilter(unsigned filter) {} void detach(); void render(const Rectf&, unsigned char, bool) {} // suspension void suspend(); // termination void release(); void Delete() const { delete this; }};</syntaxhighlight>:: [http://msdn.microsoft.com/en-us/library/windows/desktop/bb174329%28v=vs.85%29.aspx IDirect3DCubeTexture9 interface]: APICubeTexture class implementation<syntaxhighlight lang="cpp">//-------------------------------- APICubeTexture -----------------------------//// The APICubeTexture class implements a texture at the API level//iAPITexture* CreateAPICubeTexture(const wchar_t* file) {  return new APICubeTexture(file);} // constructor initializes the texture identifier//APICubeTexture::APICubeTexture(const wchar_t* file) {  if (file) { int len = strlen(file); this->file = new wchar_t[len + 1]; strcpy(this->file, file, len); } else this->file = nullptr;  tex = nullptr;} APICubeTexture::APICubeTexture(const APICubeTexture& src) {  file = nullptr; tex = nullptr; *this = src; } iAPITexture& APICubeTexture::operator=(const APICubeTexture& src) {  if (this != &src) { if (file) delete [] file; if (src.file) { int len = strlen(src.file); file = new wchar_t[len + 1]; strcpy(file, src.file, len); } else file = nullptr; suspend(); tex = nullptr; }  return *this;} // setup creates the api texture from the texture file//void APICubeTexture::setup() {  // create a texture COM object from the texture file // HRESULT hr; if (file && FAILED(hr = D3DXCreateCubeTextureFromFileEx(d3dd, file, 0, D3DX_DEFAULT, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, D3DX_DEFAULT, D3DX_DEFAULT, 0, nullptr, nullptr, &tex))) { error(L"APICubeTexture::11 Failed to create texture COM object from file"); tex = nullptr; }} // attach attaches the api texture to sampling stage i//void APICubeTexture::attach() {  if (!tex) setup();  if (tex) d3dd->SetTexture(0, tex);} // detach detaches the api texture from sampling stage 0//void APICubeTexture::detach() {  if (tex) d3dd->SetTexture(0, nullptr);} // suspend releases the api texture//void APICubeTexture::suspend() {  // release the Interface to the texture COM object if (tex) { tex->Release(); tex = nullptr; }} // releases suspends the api texture//void APICubeTexture::release() {  suspend();} // destructor releases the api texture//APICubeTexture::~APICubeTexture() {  release();}</syntaxhighlight>:: [http://msdn.microsoft.com/en-us/library/windows/desktop/bb172757%28v=vs.85%29.aspx D3DXCreateCubeTextureFromFileEx]* effects.fx: vertex shader outpu structure<syntaxhighlight lang="cpp">//-------------------------------- Skybox -------------------------------------//struct FS_Skybox { float4 pos : POSITION; float3 tex : TEXCOORD0;};</syntaxhighlight>: vertex shader<syntaxhighlight lang="cpp">FS_Skybox skyboxVertexShader(float3 pos : POSITION) { FS_Skybox output = (FS_Skybox) 0; output.pos = mul(float4(pos, 0), world); // Note the 0, this so the skybox rotates, but without translation output.pos = mul(output.pos, viewProjection).xyww; // The z coordinate is replaced by w, so that the point is always projected at infinity output.tex = pos.xzy; // Note that y and z are switched to match the texture coordinate system return output;}</syntaxhighlight>: skybox sampler state<syntaxhighlight lang="cpp">texture skyBox;samplerCUBE skySampler = sampler_state { texture = <skyBox>; MagFilter = LINEAR; Minfilter = LINEAR; Mipfilter = LINEAR; AddressU = MIRROR; AddressV = MIRROR; AddressW = MIRROR;};</syntaxhighlight>: fragment shader<syntaxhighlight lang="cpp">float4 skyboxFragmentShader(FS_Skybox input) : COLOR0 { return texCUBE(skySampler, input.tex);}</syntaxhighlight>: skybox technique<syntaxhighlight lang="cpp">technique skybox {  pass { AlphaBlendEnable = false; ZENABLE = true; ZWRITEENABLE = false; // By not storing the skybox's z-buffer value, it enables objects behind the skybox to be drawn, giving a realist look (e.g. an airplane in the distance) CullMode = None; VertexShader = compile vs_3_0 skyboxVertexShader(); PixelShader = compile ps_3_0 skyboxFragmentShader(); }}</syntaxhighlight> === To Do ====== Resources ===* [http://rbwhitaker.wikidot.com/skyboxes-1 RB Whitaker's notes on skyboxes]* [http://knol.google.com/k/3d-skybox# Koen Samyn's knol]* [http://www.gameengineer.net/samples-graphics.html Game Engineer's demo]* [http://www.planetside.co.uk/terragen Terragen Texture Tool]* DirectX Utility - DirectX Texture Tool  == Week 9 - Mar 11 ===== This Week ===* [http://msdn.microsoft.com/en-us/library/bb147178%28v=VS.85%29.aspx Mathematics of Lighting]* Lighting in Vertex Shaders** Notation**: G_a - global ambient color**: C_a - material ambient color**: C_d - material diffuse color**: C_s - material specular color**: L_{a_i} - ambient color of light i**: L_{d_i} - diffuse color of light i**: L_{s_i} - specular color of light i**: L_{dir_i} - direction vector of light i**: N - normal to the surface at the vertex*** [http://msdn.microsoft.com/en-us/library/bb172279%28v=VS.85%29.aspx Attenuation and Spotlight Factors]**** Atten_i - attenuation of light i***: d_i - distance from light i***:: d_i = |L_{dir_i}|***: a₀ - constant attenuation factor***: a₁ - linear attenuation factor***: a₂ - quadratic attenuation factor***: Atten_i = 1/(a₀ + a₁ d_i + a₂ d_i²)***: Atten_i = [0, 1]**** Spot_i - spot factor of light i***: Spot_i = {[r_i - cos(phi_i/2)]/[cos(theta_i/2) - cos(phi_i/2)]}^f_i***: r_i - cosine of angle from axis of spotlight_i***:: r_i = norm(- light direction in camera space) . norm(L_{dir_i})***: phi_i - penumbra (exterior cone) angle of spotlight_i***: theta_i - umbra (interior cone) angle of spotlight_i***: f_i - falloff factor of spotlight_i** [http://en.wikipedia.org/wiki/Blinn%E2%80%93Phong_shading_model Blinn-Phong and Phong]**: V - viewpoint vector**:: V = norm(Camera_position - Vertex_position)** Phong - account accurately for position of viewer**: Specular reflectance = (R_i . V)^p_i**: R_i - reflection vector**:: R_i = 2 * (N . L_{dir_i}) N - L_{dir_i}**: p_i - true specular power of light i**:** Blinn-Phong - use halfway vector instead of reflection vector - adjust power to compensate**: Specular reflectance = (N . H_i)^p'_i**: H_i - halfway vector**:: H_i = norm(V + L_{dir_i})**:: H_i = norm([0,0,1] + L_{dir_i}) - less computationally intensive - assumes that camera is at infinity along z axis**: p'_i - adjusted specular power of light i**:** [http://msdn.microsoft.com/en-us/library/bb172256%28v=VS.85%29.aspx Ambient]**: C_a * ( G_a + sum [L_{a_i} * Atten_i * Spot_i] )** [http://msdn.microsoft.com/en-us/library/bb219656%28v=VS.85%29.aspx Diffuse]**: C_d * sum [ L_{d_i} * (N . L_{dir_i}) * Atten_i * Spot_i ]** [http://msdn.microsoft.com/en-us/library/bb147399%28VS.85%29.aspx Specular]**: C_s * sum [ L_{s_i} * (N . H_i)^p'_i * Atten_i * Spot_i ] - Blinn-Phong**: C_s * sum [ L_{s_i} * (R_i . V)^p_i * Atten_i * Spot_i ] - Phong** [http://msdn.microsoft.com/en-us/library/ff471376%28v=vs.85%29.aspx HLSL Intrinsic Functions]*** [http://msdn.microsoft.com/en-us/library/bb509630%28v=vs.85%29.aspx normalize()] - normalize a vector*** [http://msdn.microsoft.com/en-us/library/bb509594%28v=vs.85%29.aspx dot(,)] - dot product of two vectors of any size*** [http://msdn.microsoft.com/en-us/library/bb509617%28v=vs.85%29.aspx length()] - length of a vector