3DMP engines

2012.11.02 · Part I: Geometry

RayAABBIntersect()
RayTriangleIntersect()
step
tmax
delta
step
tmax
t
Delta
t
step
tmax
delta
step
tmax
delta
wrap
float diffuse = max(0, dot(L, N));
float wrap_diffuse = max(0, (dot(L, N) + wrap) / (1 + wrap));
// Generate 2D lookup table for skin shading

   float4 GenerateSkinLUT(float2 P : POSITION) : COLOR
{
  float wrap = 0.2;
  float scatterWidth = 0.3;
  float4 scatterColor = float4(0.15, 0.0, 0.0, 1.0);
  float shininess = 40.0;

  float NdotL = P.x * 2 - 1;  // remap from [0, 1] to [-1, 1]

  
   float NdotH = P.y * 2 - 1;

  float NdotL_wrap = (NdotL + wrap) / (1 + wrap); // wrap lighting
  
   float diffuse = max(NdotL_wrap, 0.0);

  // add color tint at transition from light to dark
  
   float scatter = smoothstep(0.0, scatterWidth, NdotL_wrap) *
                    smoothstep(scatterWidth * 2.0, scatterWidth,
                               NdotL_wrap);

  float specular = pow(NdotH, shininess);
  if (NdotL_wrap <= 0) specular = 0;
  float4 C;
  C.rgb = diffuse + scatter * scatterColor;
  C.a = specular;
  return C;
}

// Shade skin using lookup table

   half3 ShadeSkin(sampler2D skinLUT,
                half3 N,
                half3 L,
                half3 H,
                half3 diffuseColor,
                half3 specularColor) : COLOR
{
  half2 s;
  s.x = dot(N, L);
  s.y = dot(N, H);
  half4 light = tex2D(skinLUT, s * 0.5 + 0.5);
  return diffuseColor * light.rgb + specularColor * light.a;
}
modelView
modelViewProj
struct a2v {
  float4 pos    : POSITION;
  float3 normal : NORMAL;
};
struct v2f {
  float4 hpos : POSITION;
  float  dist : TEXCOORD0; // distance from light
};

v2f main(a2v IN,
         uniform float4x4 modelViewProj,
         uniform float4x4 modelView,
         uniform float    grow)
{
  v2f OUT;
  float4 P = IN.pos;
  P.xyz += IN.normal * grow;  // scale vertex along normal
  OUT.hpos = mul(modelViewProj, P);
  OUT.dist = length(mul(modelView, IN.pos));
  return OUT;
}
float4 main(float dist : TEX0) : COLOR
{
  return dist;  // return distance
}
// Given a point in object space, lookup into depth textures

   // returns depth

   float trace(float3 P,
            uniform float4x4  lightTexMatrix, // to light texture space
            
   uniform float4x4  lightMatrix,    // to light space
            
   uniform sampler2D lightDepthTex,
            )
{
  // transform point into light texture space
  
   float4 texCoord = mul(lightTexMatrix, float4(P, 1.0));

  // get distance from light at entry point
  
   float d_i = tex2Dproj(lightDepthTex, texCoord.xyw);

  // transform position to light space
  
   float4 Plight = mul(lightMatrix, float4(P, 1.0));

  // distance of this pixel from light (exit)
  
   float d_o = length(Plight);

  // calculate depth
  
   float s = d_o - d_i;
  return s;
}
float si = trace(IN.objCoord, lightTexMatrix, lightMatrix,
                 lightDepthTex);
return tex1D(scatterTex, si);
return exp(-si * sigma_t) * lightColor;
struct a2v {
  float4 pos     : POSITION;
  float3 normal  : NORMAL;
  float2 texture : TEXCOORD0;
};

struct v2f {
  float4 hpos     : POSITION;
  float2 texcoord : TEXCOORD0;
  float4 col      : COLOR0;
};

v2f main(a2v IN,
         uniform float4x4 lightMatrix)
{
  v2f OUT;

  // convert texture coordinates to NDC position [-1, 1]
  OUT.hpos.xy = IN.texture * 2 - 1;
  OUT.hpos.z = 0.0;
  OUT.hpos.w = 1.0;

  // diffuse lighting
  
   float3 N = normalize(mul((float3x3) lightMatrix, IN.normal));
  float3 L = normalize(-mul(lightMatrix, IN.pos).xyz);
  float diffuse = max(dot(N, L), 0);
  OUT.col = diffuse;

  OUT.texcoord = IN.texture;
  return OUT;
}
v2f main(float2 tex : TEXCOORD0)
{
  v2f OUT;
  // 7 samples, 2 texel spacing
  OUT.tex0 = tex + float2(-5.5, 0);
  OUT.tex1 = tex + float2(-3.5, 0);
  OUT.tex2 = tex + float2(-1.5, 0);
  OUT.tex3 = tex + float2(0, 0);
  OUT.tex4 = tex + float2(1.5, 0);
  OUT.tex5 = tex + float2(3.5, 0);
  OUT.tex6 = tex + float2(5.5, 0);
  return OUT;
}
half4 main(v2fConnector v2f,
           uniform sampler2D lightTex
           ) : COLOR
{
  // weights to blur red channel more than green and blue
  
   const float4 weight[7] = {
    { 0.006, 0.0,  0.0,  0.0 },
    { 0.061, 0.0,  0.0,  0.0 },
    { 0.242, 0.25, 0.25, 0.0 },
    { 0.383, 0.5,  0.5,  0.0 },
    { 0.242, 0.25, 0.20, 0.0 },
    { 0.061, 0.0,  0.0,  0.0 },
    { 0.006, 0.0,  0.0,  0.0 },
  };

  half4 a;
  a  = tex2D(lightTex, v2f.tex0) * weight[0];
  a += tex2D(lightTex, v2f.tex1) * weight[1];
  a += tex2D(lightTex, v2f.tex2) * weight[2];
  a += tex2D(lightTex, v2f.tex3) * weight[3];
  a += tex2D(lightTex, v2f.tex4) * weight[4];
  a += tex2D(lightTex, v2f.tex5) * weight[5];
  a += tex2D(lightTex, v2f.tex6) * weight[6];
  return a;
}
Module: wine
Branch: master
Commit: 09c6caea062c4aeaaea874bf6805ba31afdce39d
URL:    http://source.winehq.org/git/wine.git/?a=commit;h=09c6caea062c4aeaaea874bf6805ba31afdce39d

Author: David Adam <david.adam.cnrs at gmail.com>
Date:   Wed Nov 12 19:16:30 2008 +0100

d3dx8: Implement D3DXMatrixTransformation2D.

---

 dlls/d3dx9_36/d3dx9_36.spec |    2 +-
 dlls/d3dx9_36/math.c        |   80 +++++++++++++++++++++++++++++++++++++++++++
 dlls/d3dx9_36/tests/math.c  |   79 ++++++++++++++++++++++++++++++++++++++++++
 include/d3dx9math.h         |    1 +
 4 files changed, 161 insertions(+), 1 deletions(-)

diff --git a/dlls/d3dx9_36/d3dx9_36.spec b/dlls/d3dx9_36/d3dx9_36.spec
index 9058dd7..d7fba36 100644
--- a/dlls/d3dx9_36/d3dx9_36.spec
+++ b/dlls/d3dx9_36/d3dx9_36.spec
@@ -225,7 +225,7 @@
 @ stdcall D3DXMatrixScaling(ptr long long long) d3dx8.D3DXMatrixScaling
 @ stdcall D3DXMatrixShadow(ptr ptr ptr) d3dx8.D3DXMatrixShadow
 @ stdcall D3DXMatrixTransformation(ptr ptr ptr ptr ptr ptr ptr) d3dx8.D3DXMatrixTransformation
-@ stub D3DXMatrixTransformation2D
+@ stdcall D3DXMatrixTransformation2D(ptr ptr long ptr ptr long ptr)
 @ stdcall D3DXMatrixTranslation(ptr long long long) d3dx8.D3DXMatrixTranslation
 @ stdcall D3DXMatrixTranspose(ptr ptr) d3dx8.D3DXMatrixTranspose
 @ stub D3DXOptimizeFaces
diff --git a/dlls/d3dx9_36/math.c b/dlls/d3dx9_36/math.c
index b5cdde2..a00ffc5 100644
--- a/dlls/d3dx9_36/math.c
+++ b/dlls/d3dx9_36/math.c
@@ -1,6 +1,7 @@
 /*
  * Mathematical operations specific to D3DX9.
  *
+ * Copyright (C) 2008 David Adam
  * Copyright (C) 2008 Philip Nilsson
  *
  * This library is free software; you can redistribute it and/or
@@ -130,6 +131,85 @@ HRESULT WINAPI D3DXMatrixDecompose(D3DXVECTOR3 *poutscale, D3DXQUATERNION *poutr
 }
 
 /*************************************************************************
+ * D3DXMatrixTransformation2D
+ */
+D3DXMATRIX* WINAPI D3DXMatrixTransformation2D(
+    D3DXMATRIX *pout, CONST D3DXVECTOR2 *pscalingcenter,
+    FLOAT scalingrotation, CONST D3DXVECTOR2 *pscaling,
+    CONST D3DXVECTOR2 *protationcenter, FLOAT rotation,
+    CONST D3DXVECTOR2 *ptranslation)
+{
+    D3DXQUATERNION rot, sca_rot;
+    D3DXVECTOR3 rot_center, sca, sca_center, trans;
+
+    if ( pscalingcenter )
+    {
+        sca_center.x=pscalingcenter->x;
+        sca_center.y=pscalingcenter->y;
+        sca_center.z=0.0f;
+    }
+    else
+    {
+        sca_center.x=0.0f;
+        sca_center.y=0.0f;
+        sca_center.z=0.0f;
+    }
+
+    if ( pscaling )
+    {
+        sca.x=pscaling->x;
+        sca.y=pscaling->y;
+        sca.z=0.0f;
+    }
+    else
+    {
+        sca.x=0.0f;
+        sca.y=0.0f;
+        sca.z=0.0f;
+    }
+
+    if ( protationcenter )
+    {
+        rot_center.x=protationcenter->x;
+        rot_center.y=protationcenter->y;
+        rot_center.z=0.0f;
+    }
+    else
+    {
+        rot_center.x=0.0f;
+        rot_center.y=0.0f;
+        rot_center.z=0.0f;
+    }
+
+    if ( ptranslation )
+    {
+        trans.x=ptranslation->x;
+        trans.y=ptranslation->y;
+        trans.z=0.0f;
+    }
+    else
+    {
+        trans.x=0.0f;
+        trans.y=0.0f;
+        trans.z=0.0f;
+    }
+
+    rot.w=cos(rotation/2.0f);
+    rot.x=0.0f;
+    rot.y=0.0f;
+    rot.z=sin(rotation/2.0f);
+
+    sca_rot.w=cos(scalingrotation/2.0f);
+    sca_rot.x=0.0f;
+    sca_rot.y=0.0f;
+    sca_rot.z=sin(scalingrotation/2.0f);
+
+    D3DXMatrixTransformation(pout, &sca_center, &sca_rot, &sca, &rot_center, &rot, &trans);
+
+    return pout;
+}
+
+/*************************************************************************
  * D3DXPlaneTransformArray
  */
 D3DXPLANE* WINAPI D3DXPlaneTransformArray(
diff --git a/dlls/d3dx9_36/tests/math.c b/dlls/d3dx9_36/tests/math.c
index 2930d34..cc71b33 100644
--- a/dlls/d3dx9_36/tests/math.c
+++ b/dlls/d3dx9_36/tests/math.c
@@ -1,4 +1,5 @@
 /*
+ * Copyright 2008 David Adam
  * Copyright 2008 Philip Nilsson
  *
  * This library is free software; you can redistribute it and/or
@@ -584,6 +585,83 @@ static void test_Matrix_Decompose(void)
     ok(hr == D3DERR_INVALIDCALL, "Expected D3DERR_INVALIDCALL, got %x\n", hr);
 }
 
+static void test_Matrix_Transformation2D(void)
+{
+    D3DXMATRIX exp_mat, got_mat;
+    D3DXVECTOR2 rot_center, sca, sca_center, trans;
+    FLOAT rot, sca_rot;
+
+    rot_center.x = 3.0f;
+    rot_center.y = 4.0f;
+
+    sca.x = 12.0f;
+    sca.y = -3.0f;
+
+    sca_center.x = 9.0f;
+    sca_center.y = -5.0f;
+
+    trans.x = -6.0f;
+    trans.y = 7.0f;
+
+    rot = D3DX_PI/3.0f;
+
+    sca_rot = 5.0f*D3DX_PI/4.0f;
+
+    exp_mat.m[0][0] = -4.245192f;
+    exp_mat.m[1][0] = -0.147116f;
+    exp_mat.m[2][0] = 0.0f;
+    exp_mat.m[3][0] = 45.265373f;
+    exp_mat.m[0][1] = 7.647113f;
+    exp_mat.m[1][1] = 8.745192f;
+    exp_mat.m[2][1] = 0.0f;
+    exp_mat.m[3][1] = -13.401899f;
+    exp_mat.m[0][2] = 0.0f;
+    exp_mat.m[1][2] = 0.0f;
+    exp_mat.m[2][2] = 0.0f;
+    exp_mat.m[3][2] = 0.0f;
+    exp_mat.m[0][3] = 0.0f;
+    exp_mat.m[1][3] = 0.0f;
+    exp_mat.m[2][3] = 0.0f;
+    exp_mat.m[3][3] = 1.0f;
+
+    D3DXMatrixTransformation2D(&got_mat, &sca_center, sca_rot, &sca, &rot_center, rot, &trans);
+
+    expect_mat(&exp_mat, &got_mat);
+
+/*_________*/
+
+    sca_center.x = 9.0f;
+    sca_center.y = -5.0f;
+
+    trans.x = -6.0f;
+    trans.y = 7.0f;
+
+    rot = D3DX_PI/3.0f;
+
+    sca_rot = 5.0f*D3DX_PI/4.0f;
+
+    exp_mat.m[0][0] = 0.0f;
+    exp_mat.m[1][0] = 0.0f;
+    exp_mat.m[2][0] = 0.0f;
+    exp_mat.m[3][0] = 2.830127f;
+    exp_mat.m[0][1] = 0.0f;
+    exp_mat.m[1][1] = 0.0f;
+    exp_mat.m[2][1] = 0.0f;
+    exp_mat.m[3][1] = 12.294229f;
+    exp_mat.m[0][2] = 0.0f;
+    exp_mat.m[1][2] = 0.0f;
+    exp_mat.m[2][2] = 0.0f;
+    exp_mat.m[3][2] = 0.0f;
+    exp_mat.m[0][3] = 0.0f;
+    exp_mat.m[1][3] = 0.0f;
+    exp_mat.m[2][3] = 0.0f;
+    exp_mat.m[3][3] = 1.0f;
+
+    D3DXMatrixTransformation2D(&got_mat, &sca_center, sca_rot, NULL, NULL, rot, &trans);
+
+    expect_mat(&exp_mat, &got_mat);
+}
+
 static void test_D3DXVec_Array(void)
 {
     unsigned int i;
@@ -725,5 +803,6 @@ START_TEST(math)
 {
     test_Matrix_AffineTransformation2D();
     test_Matrix_Decompose();
+    test_Matrix_Transformation2D();
     test_D3DXVec_Array();
 }
diff --git a/include/d3dx9math.h b/include/d3dx9math.h
index 9992919..83b8749 100644
--- a/include/d3dx9math.h
+++ b/include/d3dx9math.h
@@ -296,6 +296,7 @@ D3DXMATRIX* WINAPI D3DXMatrixRotationZ(D3DXMATRIX *pout, FLOAT angle);
 D3DXMATRIX* WINAPI D3DXMatrixScaling(D3DXMATRIX *pout, FLOAT sx, FLOAT sy, FLOAT sz);
 D3DXMATRIX* WINAPI D3DXMatrixShadow(D3DXMATRIX *pout, CONST D3DXVECTOR4 *plight, CONST D3DXPLANE *pPlane);
 D3DXMATRIX* WINAPI D3DXMatrixTransformation(D3DXMATRIX *pout, CONST D3DXVECTOR3 *pscalingcenter, CONST D3DXQUATERNION *pscalingrotation, CONST D3DXVECTOR3 *pscaling, CONST D3DXVECTOR3 *protationcenter, CONST D3DXQUATERNION *protation, CONST D3DXVECTOR3 *ptranslation);
+D3DXMATRIX* WINAPI D3DXMatrixTransformation2D(D3DXMATRIX *pout, CONST D3DXVECTOR2 *pscalingcenter, FLOAT scalingrotation, CONST D3DXVECTOR2 *pscaling, CONST D3DXVECTOR2 *protationcenter, FLOAT rotation, CONST D3DXVECTOR2 *ptranslation);
 D3DXMATRIX* WINAPI D3DXMatrixTranslation(D3DXMATRIX *pout, FLOAT x, FLOAT y, FLOAT z);
 D3DXMATRIX* WINAPI D3DXMatrixTranspose(D3DXMATRIX *pout, CONST D3DXMATRIX *pm);
 

    incident_light = sum of all light that a patch can see
    excident_light = (incident_light*reflectance) + emmision
	

  structure PATCH
    emmision
    reflectance
    incident
    excident
  end structure

  load scene

  divide each surface into roughly equal sized patches


  initialise_patches:
  for each Patch in the scene
    if this patch is a light then
      patch.emmision = some amount of light
    else
      patch.emmision = black
    end if
    patch.excident = patch.emmision
  end Patch loop
  


  Passes_Loop:

  each patch collects light from the scene
  for each Patch in the scene
    render the scene from the point of view of this patch
    patch.incident = sum of incident light in rendering
  end Patch loop


  calculate excident light from each patch:
  for each Patch in the scene
    I = patch.incident
    R = patch.reflectance
    E = patch.emmision
    patch.excident = (I*R) + E
  end Patch loop

  Have we done enough passes?
    if not then goto Passes_Loop


  procedure Calc_Incident_Light(point: P, vector: N)  

    light TotalLight
    hemicube H, R, M
    H = empty
    M = Multiplier Hemicube
    R = empty

    div = sum of pixels in M

    camera C
    C.lens = P

    C.direction = N
    H.front = RenderView(C, N, Full_View)

    C.direction = N rotated 90° down
    H.down = RenderView(C, N, Top_Half)

    C.direction = N rotated 90° up
    H.up = RenderView(C, N, Bottom_Half)

    C.direction = N rotated 90° left
    H.left = RenderView(C, N, Right_Half)

    C.direction = N rotated 90° right
    H.right = RenderView(C, N, Left_Half)

    multiply all pixels in H by corresponding
    pixels in M, storing the results in R

    TotalLight = black

    loop p through each pixel in R
      add p to TotalLight 
    end loop
    
    divide TotalLight by div

    return TotalLight
  end procedure
	
  structure light
    float Red
    float Green
    float Blue
  end structure

  structure hemicube
    image front
    image up
    image down
    image left
    image right
  end structure

  structure camera
    point  lens
    vector direction
  end structure

####  CODE EDITING IN PROGRESS - BIT MESSY STILL ####

 float ratio2(float a, float b)
 {
     if ((a==0) && (b==0))    return 1.0;
     if ((a==0) || (b==0))    return 0.0;

     if (a>b)    return b/a;
     else        return a/b;
 }

 float ratio4(float a, float b, float c, float d) 
 {
     float q1 = ratio2(a,b);
     float q2 = ratio2(c,d);

     if (q1<q2)    return q1;
     else          return q2;
 }


 procedure CalcLightMap()

 vector  normal = LightMap.Surface_Normal
 float   Xres   = LightMap.X_resolution
 float   Yres   = LightMap.Y_resolution
 point3D SamplePoint
 light   I1, I2, I3, I4

 Accuracy = Some value greater than 0.0, and less than 1.0.  
            Higher values give a better quality Light Map (and a slower render).
            0.5 is ok for the first passes of the renderer.
            0.98 is good for the final pass.

 Spacing = 4     Higher values of Spacing give a slightly faster render, but
                 will be more likely to miss fine details. I find that 4 is
                 a pretty reasonable compromise. 


 // 1: Initially, calculate an even grid of pixels across the Light Map.
 // For each pixel calculate the 3D coordinates of the centre of the patch that
 // corresponds to this pixel. Render a hemicube at that point, and add up
 // the incident light. Write that value into the Light Map.
 // The spacing in this grid is fixed. The code only comes here once per Light
 // Map, per render pass. 

 for (y=0; y<Yres; y+=Spacing)
     for (x=0; x<Xres; x+=Spacing)
     {
         SamplePoint = Calculate coordinates of centre of patch
         incidentLight = Calc_Incident_Light(SamplePoint, normal)
         LightMap[x, y] = incidentLight
     }

 // return here when another pass is required
 Passes_Loop:
     threshold = pow(Accuracy, Spacing)


     // 2: Part 1.
     HalfSpacing = Spacing/2;
     for (y=HalfSpacing; y<=Yres+HalfSpacing; y+=Spacing)
     {
         for (x=HalfSpacing; x<=Xres+HalfSpacing; x+=Spacing)
         {
             // Calculate the inbetween pixels, whose neighbours are above and below this pixel
             if (x<Xres)    // Don't go off the edge of the Light Map now
             {
                 x1 = x
                 y1 = y-HalfSpacing

                 // Read the 2 (left and right) neighbours from the Light Map
                 I1 = LightMap[x1+HalfSpacing, y1]
                 I2 = LightMap[x1-HalfSpacing, y1]

                 // If the neighbours are very similar, then just interpolate.
                 if ( (ratio2(I1.R,I2.R) > threshold) &&
                      (ratio2(I1.G,I2.G) > threshold) &&
                      (ratio2(I1.B,I2.B) > threshold) )
                 {
                     incidentLight.R = (I1.R+I2.R) * 0.5
                     incidentLight.G = (I1.G+I2.G) * 0.5
                     incidentLight.B = (I1.B+I2.B) * 0.5
                     LightMap[x1, y1] = incidentLight
                 }
                 // Otherwise go to the effort of rendering a hemicube, and adding it all up.
                 else
                 {
                     SamplePoint = Calculate coordinates of centre of patch
                     incidentLight = Calc_Incident_Light(SamplePoint, normal)
                     LightMap[x1, y1] = incidentLight
                 }
             }
             

             // Calculate the inbetween pixels, whose neighbours are left and right of this pixel
             if (y<Yres)    // Don't go off the edge of the Light Map now
             {
                 x1 = x-HalfSpacing
                 y1 = y
              
                 // Read the 2 (up and down) neighbours from the Light Map
                 I1 = LightMap[x1,y1-HalfSpacing];
                 I2 = LightMap[x1,y1+HalfSpacing];

                 // If the neighbours are very similar, then just interpolate.
                 if ( (ratio2(I1.R,I2.R) > threshold) &&
                      (ratio2(I1.G,I2.G) > threshold) &&
                      (ratio2(I1.B,I2.B) > threshold) )
                 {
                     incidentLight.R = (I1.R+I2.R) * 0.5
                     incidentLight.G = (I1.G+I2.G) * 0.5
                     incidentLight.B = (I1.B+I2.B) * 0.5
                     LightMap[x1,y1] = incidentLight
                 }
                 // Otherwise go to the effort of rendering a hemicube, and adding it all up.
                 else
                 {
                     SamplePoint = Calculate coordinates of centre of patch
                     incidentLight = Calc_Incident_Light(SamplePoint, normal)
                     LightMap[x1, y1] = incidentLight
                 }

             }//end if

         }//end x loop
     }//end y loop



     // 3: Part 2
     // Calculate the pixels, whose neighbours are on all 4 sides of this pixel
    
     for (y=HalfSpacing; y<=(Yres-HalfSpacing); y+=Spacing)
     {
         for (x=HalfSpacing; x<=(Xres-HalfSpacing); x+=Spacing)
         {
             I1 = LightMap[x, y-HalfSpacing]
             I2 = LightMap[x, y+HalfSpacing]
             I3 = LightMap[x-HalfSpacing, y]
             I4 = LightMap[x+HalfSpacing, y]

             if ( (ratio4(I1.R,I2.R,I3.R,I4.R) > threshold) &&
                  (ratio4(I1.G,I2.G,I3.G,I4.G) > threshold) &&
                  (ratio4(I1.B,I2.B,I3.B,I4.B) > threshold) )
             {
                 incidentLight.R = (I1.R + I2.R + I3.R + I4.R) * 0.25
                 incidentLight.G = (I1.G + I2.G + I3.G + I4.G) * 0.25
                 incidentLight.B = (I1.B + I2.B + I3.B + I4.B) * 0.25
                 LightMap[x,y] = incidentLight
             }
             else
             {
                 SamplePoint = Calculate coordinates of centre of patch
                 incidentLight = Calc_Incident_Light(SamplePoint, normal)
                 LightMap[x, y] = incidentLight;
             }
         }
     }


     Spacing = Spacing / 2
     Stop if Spacing = 1, otherwise go to Passes_Loop




cegui 튜토리얼 번역 (0)	2013.02.04
GUI 제공하는 사이트들 (0)	2012.11.02

cegui 튜토리얼 번역 (0)	2013.02.04
CEGUI 설치 (0)	2012.11.02

Direct3D9에서 큐브 환경맵 만들어 보기 (0)	2012.11.08
환경 맵(큐브 맵, Cube Map) (0)	2012.11.08
투명처리와 알파 합성 (0)	2012.11.02
점 그리기 -크기 변환 (0)	2012.11.02
점그리기 (0)	2012.11.02

환경 맵(큐브 맵, Cube Map) (0)	2012.11.08
Direct 에서 스피어함수 (0)	2012.11.02
점 그리기 -크기 변환 (0)	2012.11.02
점그리기 (0)	2012.11.02
Directx D3DXCreateSphere 구현 (0)	2012.11.02

[소스] 해칭(Hatching) HLSL 소스 (0)	2013.01.05
VS에서 HLSL 편집하기 InteliShade (0)	2013.01.05
셰이더 내장함수 (0)	2012.11.02
smoothstep (0)	2012.11.02
NVIDIA계열 그래픽카드 오버클럭 하기 (0)	2012.10.31

동차좌표 (0)	2012.11.02
원근투형 TM (0)	2012.11.02
회전 변환 (0)	2012.11.02
일차 독립, 일차 종속 (0)	2012.11.02
3D 벡터 기초 연산 (0)	2012.11.02

원근투형 TM (0)	2012.11.02
회전행렬 (0)	2012.11.02
일차 독립, 일차 종속 (0)	2012.11.02
3D 벡터 기초 연산 (0)	2012.11.02
왼손 좌표계 vs 오른손 좌표계 의 외적 (0)	2012.11.02

Directx D3DXCreateSphere 구현 (0)	2012.11.02
디바이스를 잃었을때의 복구 절차 (0)	2012.11.02
Directx3D 에서 2D 점 그리기 (0)	2012.11.02
SetScissorRect 영역 그리기 (0)	2012.11.02
MFC에서 픽킹시 좌표얻기 (0)	2012.11.02

Description	Dimensions	Format	Size
Grid Texture	256x256x256	R32F	64 MB
Triangle List Texture	4096x2048	R32F	32 MB
Vertex Texture	1024x1024	A32B32G32R32F	8 MB
Normal Texture	1024x1024	A16B16G16R16F	4 MB
		Total Size:	108 MB

왼손 좌표계 vs 오른손 좌표계 의 외적 (0)	2012.11.02
directx 사원수 관련 함수 d3dx9math.h (0)	2012.11.02
표면 스케터링으로 실시간 근사 (0)	2012.11.02
D3DXMatrixTransformation2D (0)	2012.11.02
로컬좌표와 월드 좌표 (0)	2012.11.02

디바이스를 잃었을때의 복구 절차 (0)	2012.11.02
그래픽카드 디바이스. D3D_Device (0)	2012.11.02
SetScissorRect 영역 그리기 (0)	2012.11.02
MFC에서 픽킹시 좌표얻기 (0)	2012.11.02
텍스쳐 반투명, 알파값 없는 이미지 (0)	2012.11.02

directx 사원수 관련 함수 d3dx9math.h (0)	2012.11.02
GPU 에서 노멀맵 굽기 (0)	2012.11.02
D3DXMatrixTransformation2D (0)	2012.11.02
로컬좌표와 월드 좌표 (0)	2012.11.02
라디오시티 (0)	2012.11.02

[MFC] 프로그램 코드 라인수 계산기 (1)	2012.11.15
한국 과학기술 연합 사이트 (0)	2012.11.02
Process Explorer v14.01 & 로드된 DLL 파일 확인 또는 특정 프로세스가 포함하는 핸들 표시 (0)	2012.11.01
ECS P67H2-A3(B3) 오버클럭 후 클럭 고정 방법 (1)	2012.10.31
마이크로 소프트 고객센터 (0)	2012.10.31


Lighting a simple scene with Direct Lighting I modeled this simple scene in 3D Studio. I wanted the room to look as if it was lit by the sun shining in through the window. So, I set up a spotlight to shine in. When I rendered it, the entire room was pitch black, except for a couple of patches on the floor that the light reached. Turning up the Ambient Light simply caused the room to appear a uniform grey, except for the uniformly red floor, and light patches. Adding a point light source in the middle of the room brought out the details, but the scene doesn't have that bright glow that you expect from a sunlit room. Lastly, I turned the background colour to white, to give the appearance of a bright sky.

Lighting a simple scene with Global Lighting I modeled the same scene in my own radiosity renderer. To provide the source of light, I rendered an image of the sky withTerragen, and placed it outside the window. No other source of light was used. With no further effort on my part, the room looks realistically lit. Interesting points to note: The entire room is lit and visible, even those surfaces facing away from the sun. Soft shadows. The subtle change in brightness across the wall to the left of the scene. The grey walls, far from being grey, have a certain warmth to them. The ceiling could even be said to be ever so slightly pink.

	The Algorithm: On the far left you can see the light map in the process of being generated. Next to it, you can see which pixels were produced using a hemicube (red) and which were linearly interpolated (green).
	1: Use a hemicube to calculate every 4^th pixel. I'll show these pixels on the right as .
	2: Pass Type 1: Examine the pixels which are horizontally or vertically halfway between previously calculated pixels . If the neighbouring pixels differ by more than some threshold amount, then calculate this pixel using a hemicube, otherwise, interpolate from the neighbouring pixels.
	3: Pass Type 2: Examine the pixels which are in the middle of a group of 4 pixels. If the neighbours differ by much, then use a hemicube for this pixel, otherwise use linear interpolation.
	4: Pass Type 1: Same as step 2, but with half the spacing.
	5: Pass Type 2: Same as step 3, but with half the spacing.

DLL 임포트 방법들 (0)	2012.11.20
DLL 제작방법 – 1. Non-MFC DLL (0)	2012.11.03
lib 파일 생성과 사용 (0)	2012.11.01
DLL 과 EXE 만 사용법 , dll & def 만 사용 (0)	2012.11.01
\|DLL 분석 ①\|DLL파일 생성과 설명 (0)	2012.11.01

라디오시티 (0)	2012.11.02
에르미트 (0)	2012.11.02
직교투영 확대 축소 (0)	2012.11.02
폴리곤중간의 텍스처 좌표 구하기 (0)	2012.11.02
[D3DX] Vertex Normal (0)	2012.11.02

분류전체보기

'수학 (Mathematics) > 3D수학' 카테고리의 다른 글

'수학 (Mathematics) > 3D수학' 카테고리의 다른 글

'수학 (Mathematics) > 3D수학' 카테고리의 다른 글

'수학 (Mathematics) > 3D수학' 카테고리의 다른 글

'수학 (Mathematics) > 3D수학' 카테고리의 다른 글

'그래픽스(Graphics) > GUI Library' 카테고리의 다른 글

'그래픽스(Graphics) > GUI Library' 카테고리의 다른 글

'그래픽스(Graphics) > DirectX9~12' 카테고리의 다른 글

'수학 (Mathematics) > 3D수학' 카테고리의 다른 글

'그래픽스(Graphics) > DirectX9~12' 카테고리의 다른 글

'그래픽스(Graphics) > DirectX9~12' 카테고리의 다른 글

'그래픽스(Graphics) > DirectX9~12' 카테고리의 다른 글

'그래픽스(Graphics) > DirectX9~12' 카테고리의 다른 글

'그래픽스(Graphics) > DirectX9~12' 카테고리의 다른 글

'그래픽스(Graphics) > DirectX9~12' 카테고리의 다른 글

'그래픽스(Graphics) > Shader' 카테고리의 다른 글

Chapter 22. Baking Normal Maps on the GPU

22.1 The Traditional Implementation

22.1.1 Projection

22.1.2 The Boundary Cage

22.2 Acceleration Structures

22.2.1 The Uniform Grid

22.2.2 The 3D Digital Differential Analyzer

22.3 Feeding the GPU

Example 22-1. Helper Functions That Convert Between Grid Coordinates

Example 22-2. A Function That Maps a Linear Array Coordinate to a 2D Texture Coordinate

22.3.1 Indexing Limitations

22.3.2 Memory and Architectural Limitations

Table 22-1. Memory Usage Statistics for a Sample Reference Mesh

22.4 Implementation

22.4.1 Setup and Preprocessing

Example 22-3. Common Data Structures

22.4.2 The Single-Pass Implementation

Step 1

Example 22-4. Setting Up the Ray

Step 2

Example 22-5. Preparing for 3D-DDA

Step 3

Example 22-6. The Function Containing the Secondary Loop

Example 22-7. The Main Loop in the Pixel Shader

Step 4

Example 22-8. Converting the Normal to Tangent Space

Limitation

Example 22-9. An Example of Using Two Nested Loops to Work Around the Limitation

22.4.3 The Multipass Implementation

Limitation

Tiled Rendering

22.4.4 Antialiasing

22.5 Results

Possible Improvements

22.6 Conclusion

22.7 References

'수학 (Mathematics) > 3D수학' 카테고리의 다른 글

'그래픽스(Graphics) > DirectX9~12' 카테고리의 다른 글

'그래픽스(Graphics) > Shader' 카테고리의 다른 글

Chapter 16. Real-Time Approximations to Subsurface Scattering

16.1 The Visual Effects of Subsurface Scattering

16.2 Simple Scattering Approximations

Example 16-1. Excerpt from the Skin Shader Effect Incorporating Wrap Lighting

16.3 Simulating Absorption Using Depth Maps

Example 16-2. The Vertex Program for the Depth Pass

Example 16-3. The Fragment Program for the Depth Pass

Example 16-4. The Fragment Program Function for Calculating Penetration Depth Using Depth Map

16.3.1 Implementation Details

16.3.2 More Sophisticated Scattering Models

16.4 Texture-Space Diffusion

Example 16-5. A Vertex Program to Unwrap a Model and Perform Diffuse Lighting

Example 16-6. The Vertex Program for Diffusion Blur

Example 16-7. The Fragment Program for Diffusion Blur

16.4.1 Possible Future Work

16.5 Conclusion

16.6 References

Copyright

개요

SSS 켜기

SSS 머티리얼 파라미터

SubsurfaceInscatteringColor

SubsurfaceAbsorptionColor

SubsurfaceScatteringRadius

Entire Room Lit: 1^st Pass

View from the patch after 1^st Pass

Entire Room Lit: 2^nd Pass

Entire Room Lit: 3^rd Pass