Example_Basic.cg
上传用户:xhbjoy
上传日期:2014-10-07
资源大小:38068k
文件大小:8k
源码类别:

游戏引擎

开发平台:

Visual C++

  1. /*
  2.   Basic ambient lighting vertex program
  3. */
  4. void ambientOneTexture_vp(float4 position : POSITION,
  5.   float2 uv   : TEXCOORD0,
  6.   
  7.   out float4 oPosition : POSITION,
  8.   out float2 oUv    : TEXCOORD0,
  9.   out float4 colour    : COLOR,
  10.   uniform float4x4 worldViewProj,
  11.   uniform float4 ambient)
  12. {
  13. oPosition = mul(worldViewProj, position);
  14. oUv = uv;
  15. colour = ambient;
  16. }
  17. /*
  18.   Single-weight-per-vertex hardware skinning, 2 lights
  19.   The trouble with vertex programs is they're not general purpose, but
  20.   fixed function hardware skinning is very poorly supported
  21. */
  22. void hardwareSkinningOneWeight_vp(
  23. float4 position : POSITION,
  24. float3 normal   : NORMAL,
  25. float2 uv       : TEXCOORD0,
  26. float  blendIdx : BLENDINDICES,
  27. out float4 oPosition : POSITION,
  28. out float2 oUv       : TEXCOORD0,
  29. out float4 colour           : COLOR,
  30. // Support up to 24 bones of float3x4
  31. // vs_1_1 only supports 96 params so more than this is not feasible
  32. uniform float3x4   worldMatrix3x4Array[24],
  33. uniform float4x4 viewProjectionMatrix,
  34. uniform float4   lightPos[2],
  35. uniform float4   lightDiffuseColour[2],
  36. uniform float4   ambient)
  37. {
  38. // transform by indexed matrix
  39. float4 blendPos = float4(mul(worldMatrix3x4Array[blendIdx], position).xyz, 1.0);
  40. // view / projection
  41. oPosition = mul(viewProjectionMatrix, blendPos);
  42. // transform normal
  43. float3 norm = mul((float3x3)worldMatrix3x4Array[blendIdx], normal);
  44. // Lighting - support point and directional
  45. float3 lightDir0 =  normalize(
  46. lightPos[0].xyz -  (blendPos.xyz * lightPos[0].w));
  47. float3 lightDir1 =  normalize(
  48. lightPos[1].xyz -  (blendPos.xyz * lightPos[1].w));
  49. oUv = uv;
  50. colour = ambient + 
  51. (saturate(dot(lightDir0, norm)) * lightDiffuseColour[0]) + 
  52. (saturate(dot(lightDir1, norm)) * lightDiffuseColour[1]);
  53. }
  54. /*
  55.   Single-weight-per-vertex hardware skinning, shadow-caster pass
  56. */
  57. void hardwareSkinningOneWeightCaster_vp(
  58. float4 position : POSITION,
  59. float3 normal   : NORMAL,
  60. float  blendIdx : BLENDINDICES,
  61. out float4 oPosition : POSITION,
  62. out float4 colour    : COLOR,
  63. // Support up to 24 bones of float3x4
  64. // vs_1_1 only supports 96 params so more than this is not feasible
  65. uniform float3x4   worldMatrix3x4Array[24],
  66. uniform float4x4 viewProjectionMatrix,
  67. uniform float4   ambient)
  68. {
  69. // transform by indexed matrix
  70. float4 blendPos = float4(mul(worldMatrix3x4Array[blendIdx], position).xyz, 1.0);
  71. // view / projection
  72. oPosition = mul(viewProjectionMatrix, blendPos);
  73. colour = ambient;
  74. }
  75. /*
  76.   Two-weight-per-vertex hardware skinning, 2 lights
  77.   The trouble with vertex programs is they're not general purpose, but
  78.   fixed function hardware skinning is very poorly supported
  79. */
  80. void hardwareSkinningTwoWeights_vp(
  81. float4 position : POSITION,
  82. float3 normal   : NORMAL,
  83. float2 uv       : TEXCOORD0,
  84. float4 blendIdx : BLENDINDICES,
  85. float4 blendWgt : BLENDWEIGHT,
  86. out float4 oPosition : POSITION,
  87. out float2 oUv       : TEXCOORD0,
  88. out float4 colour           : COLOR,
  89. // Support up to 24 bones of float3x4
  90. // vs_1_1 only supports 96 params so more than this is not feasible
  91. uniform float3x4   worldMatrix3x4Array[24],
  92. uniform float4x4 viewProjectionMatrix,
  93. uniform float4   lightPos[2],
  94. uniform float4   lightDiffuseColour[2],
  95. uniform float4   ambient)
  96. {
  97. // transform by indexed matrix
  98. float4 blendPos = float4(0,0,0,0);
  99. int i;
  100. for (i = 0; i < 2; ++i)
  101. {
  102. blendPos += float4(mul(worldMatrix3x4Array[blendIdx[i]], position).xyz, 1.0) * blendWgt[i];
  103. }
  104. // view / projection
  105. oPosition = mul(viewProjectionMatrix, blendPos);
  106. // transform normal
  107. float3 norm = float3(0,0,0);
  108. for (i = 0; i < 2; ++i)
  109. {
  110. norm += mul((float3x3)worldMatrix3x4Array[blendIdx[i]], normal) * 
  111. blendWgt[i];
  112. }
  113. norm = normalize(norm);
  114. // Lighting - support point and directional
  115. float3 lightDir0 =  normalize(
  116. lightPos[0].xyz -  (blendPos.xyz * lightPos[0].w));
  117. float3 lightDir1 =  normalize(
  118. lightPos[1].xyz -  (blendPos.xyz * lightPos[1].w));
  119. oUv = uv;
  120. colour = ambient + 
  121. (saturate(dot(lightDir0, norm)) * lightDiffuseColour[0]) + 
  122. (saturate(dot(lightDir1, norm)) * lightDiffuseColour[1]);
  123. }
  124. /*
  125.   Two-weight-per-vertex hardware skinning, shadow caster pass
  126. */
  127. void hardwareSkinningTwoWeightsCaster_vp(
  128. float4 position : POSITION,
  129. float3 normal   : NORMAL,
  130. float2 uv       : TEXCOORD0,
  131. float4 blendIdx : BLENDINDICES,
  132. float4 blendWgt : BLENDWEIGHT,
  133. out float4 oPosition : POSITION,
  134. out float4 colour           : COLOR,
  135. // Support up to 24 bones of float3x4
  136. // vs_1_1 only supports 96 params so more than this is not feasible
  137. uniform float3x4   worldMatrix3x4Array[24],
  138. uniform float4x4 viewProjectionMatrix,
  139. uniform float4   ambient)
  140. {
  141. // transform by indexed matrix
  142. float4 blendPos = float4(0,0,0,0);
  143. int i;
  144. for (i = 0; i < 2; ++i)
  145. {
  146. blendPos += float4(mul(worldMatrix3x4Array[blendIdx[i]], position).xyz, 1.0) * blendWgt[i];
  147. }
  148. // view / projection
  149. oPosition = mul(viewProjectionMatrix, blendPos);
  150. colour = ambient;
  151. }
  152. /*
  153.   Four-weight-per-vertex hardware skinning, 2 lights
  154.   The trouble with vertex programs is they're not general purpose, but
  155.   fixed function hardware skinning is very poorly supported
  156. */
  157. void hardwareSkinningFourWeights_vp(
  158. float4 position : POSITION,
  159. float3 normal   : NORMAL,
  160. float2 uv       : TEXCOORD0,
  161. float4 blendIdx : BLENDINDICES,
  162. float4 blendWgt : BLENDWEIGHT,
  163. out float4 oPosition : POSITION,
  164. out float2 oUv       : TEXCOORD0,
  165. out float4 colour           : COLOR,
  166. // Support up to 24 bones of float3x4
  167. // vs_1_1 only supports 96 params so more than this is not feasible
  168. uniform float3x4   worldMatrix3x4Array[24],
  169. uniform float4x4 viewProjectionMatrix,
  170. uniform float4   lightPos[2],
  171. uniform float4   lightDiffuseColour[2],
  172. uniform float4   ambient)
  173. {
  174. // transform by indexed matrix
  175. float4 blendPos = float4(0,0,0,0);
  176. int i;
  177. for (i = 0; i < 4; ++i)
  178. {
  179. blendPos += float4(mul(worldMatrix3x4Array[blendIdx[i]], position).xyz, 1.0) * blendWgt[i];
  180. }
  181. // view / projection
  182. oPosition = mul(viewProjectionMatrix, blendPos);
  183. // transform normal
  184. float3 norm = float3(0,0,0);
  185. for (i = 0; i < 4; ++i)
  186. {
  187. norm += mul((float3x3)worldMatrix3x4Array[blendIdx[i]], normal) * 
  188. blendWgt[i];
  189. }
  190. norm = normalize(norm);
  191. // Lighting - support point and directional
  192. float3 lightDir0 =  normalize(
  193. lightPos[0].xyz -  (blendPos.xyz * lightPos[0].w));
  194. float3 lightDir1 =  normalize(
  195. lightPos[1].xyz -  (blendPos.xyz * lightPos[1].w));
  196. oUv = uv;
  197. colour = ambient + 
  198. (saturate(dot(lightDir0, norm)) * lightDiffuseColour[0]) + 
  199. (saturate(dot(lightDir1, norm)) * lightDiffuseColour[1]);
  200. }
  201. void hardwareMorphAnimation(float3 pos1 : POSITION,
  202.   float4 normal : NORMAL,
  203.   float2 uv   : TEXCOORD0,
  204.   float3 pos2   : TEXCOORD1,
  205.   
  206.   out float4 oPosition : POSITION,
  207.   out float2 oUv    : TEXCOORD0,
  208.   out float4 colour    : COLOR,
  209.   uniform float4x4 worldViewProj, 
  210.   uniform float4 anim_t)
  211. {
  212. // interpolate
  213. float4 interp = float4(pos1 + anim_t.x*(pos2 - pos1), 1.0f);
  214. oPosition = mul(worldViewProj, interp);
  215. oUv = uv;
  216. colour = float4(1,0,0,1);
  217. }
  218. void hardwarePoseAnimation(float3 pos : POSITION,
  219.   float4 normal : NORMAL,
  220.   float2 uv   : TEXCOORD0,
  221.   float3 pose1   : TEXCOORD1,
  222.   float3 pose2   : TEXCOORD2,
  223.   
  224.   out float4 oPosition : POSITION,
  225.   out float2 oUv    : TEXCOORD0,
  226.   out float4 colour    : COLOR,
  227.   uniform float4x4 worldViewProj, 
  228.   uniform float4 anim_t)
  229. {
  230. // interpolate
  231. float4 interp = float4(pos + anim_t.x*pose1 + anim_t.y*pose2, 1.0f);
  232. oPosition = mul(worldViewProj, interp);
  233. oUv = uv;
  234. colour = float4(1,0,0,1);
  235. }