Aktív témák

• #16 3man csendes tag

  2009-11-11 19:31:57 #16

  Összes hozzászólása itt Válaszok az összes hozzászólására itt Válaszok erre a hozzászólásra

  Privát üzenet küldése

  

  3man

  csendes tag

  Most az alapok utan kicsit melyebbre merulok.
  A bumpmap, normalmap es a parallax technikak egyik nelkulozhetetlen segedeszkoze a tangens-ter. Ennek bemutatasahoz egy egyszeru 2d matrix osztalyt hoztam ossze. A reszleteket a megadott linkeken megtalalja akit erdekel.

  A tangens ter a haromszogre rahuzott map iranyultsagat adja meg. A szamitas az alabbi feltetelbol indul ki.
  Ha a haromszog egyik (vec1) csucsabol T (tangens) iranyban U.x erteket lepek, azutan B (bitangens/binormal) iranyban U.y erteket, akkor eljutok a vec2 re.
  Ugyan ez V.x V.y-al vegigjatszva a vec3-ra jutok, ami a harmadik csucsa a haromszognek. Ez a kiindulo egyenlet.

  U=txcoord2-txcoord1;// a haromszog csucsainak map koordinatai
  V=txcoord3-txcoord1;
  V1=vec2-vec1;//a haromszog csucsai
  V2=vec3-vec1;

  A kiindulo egyenlet:
  vec2=vec1+T*U.x + B*U.y
  vec3=vec1+T*V.x + B*V.y

  vec1-et levonva ezt kapom
  V1=T*U.x + B*U.y
  V2=T*V.x + B*V.y

  Matrix alakba felirva
  [V1,V2]=[U,V][T,B]

  Az [U,V] inverzevel beszorzom a ket oldalt.
  [V1,V2][U,V]^-1=[T,B]
  es meg is kaptam a tangens vektorokat.

  Az algoritmus csak 2 dimenzioban jo, 3d-hez modositani kell.

  void pixelv(float3 par1,float3 color)

  {

  int x1=x_size/2+(int)par1.x;

  int y1=y_size/2-(int)par1.y;

  int r=(int)(color.r*255.0);

  int g=(int)(color.g*255.0);

  int b=(int)(color.b*255.0);

  pixel(x1,y1,r,g,b);

  }

  class matrix2D
  {
  public:
  float a,b;
  float c,d;

  matrix2D() {a=b=c=d=0;};
  matrix2D(float s1,float s2,float s3,float s4) {a=s1;b=s2;c=s3;d=s4;};
  matrix2D(float3 vc1,float3 vc2)
  {
  a=vc1.x; b=vc1.y;
  c=vc2.x; d=vc2.y;
  };
  matrix2D operator* (float f)
  {
  matrix2D m(a,b,c,d);
  m.a*=f;m.b*=f;
  m.c*=f;m.d*=f;
  return m;
  }
  float3 operator* (float3 f)
  {
  float3 vec;
  vec.x=f.x*a + f.y*c;
  vec.y=f.x*b + f.y*d;
  vec.z=0;
  return vec;
  }
  matrix2D Transpose()//http://en.wikipedia.org/wiki/Transpose
  {
  matrix2D m;

  m.a=a; m.b=c;
  m.c=b; m.d=d;

  return m;
  }
  matrix2D Adjugate()//http://en.wikipedia.org/wiki/Adjugate_matrix
  {
  matrix2D m;

  m.a=d; m.b=-b;
  m.c=-c;m.d=a;

  return m;
  }
  float Determinant()//http://en.wikipedia.org/wiki/Determinant
  {
  return a*d-b*c;
  }
  matrix2D Inverse()//http://en.wikipedia.org/wiki/Invertible_matrix
  {
  matrix2D m=Adjugate()*(1.0/Determinant());

  return m;
  }

  };
  void draw_function()

  {
  float3 vec1=float3(0,0,0);
  float3 vec2=float3(300,200,0);
  float3 vec3=float3(-50,150,0);

  float3 txcoord1=float3(0,0,0);
  float3 txcoord2=float3(1,0,0);
  float3 txcoord3=float3(0,1,0);

  float3 U=txcoord2-txcoord1;
  float3 V=txcoord3-txcoord1;
  matrix2D uvSpace=matrix2D(U,V);
  uvSpace=uvSpace.Inverse();

  float3 V1=vec2-vec1;
  float3 V2=vec3-vec1;

  float3 T=V1*uvSpace.a + V2*uvSpace.b;
  float3 B=V1*uvSpace.c + V2*uvSpace.d;

  matrix2D TanSpace=matrix2D(T,B);
  TanSpace=TanSpace.Inverse();

  for(int y=-250;y<250;y++)
  for(int x=-400;x<400;x++)
  {
  float3 screen=float3(x,y,0);
  float3 temp=screen-vec1;
  float3 txcoord=txcoord1 + TanSpace*temp;

  pixelv(screen,txcoord);
  }
  linev(vec1,vec1+T*4,float3(0.0,0.0,0.5));
  linev(vec1,vec1+B*4,float3(0.0,0.0,0.5));
  linev(vec1,vec1-T*4,float3(0.0,0.0,0.5));
  linev(vec1,vec1-B*4,float3(0.0,0.0,0.5));

  linev(vec1,vec2,float3(1,1,1));
  linev(vec1,vec3,float3(1,1,1));
  }

Aktív témák