Results 1 to 4 of 4

Thread: If any ideas -> add 2 code, thx :)

  1. #1
    Junior Member Newbie
    Join Date
    Jul 2003
    Location
    Slovenia
    Posts
    19

    If any ideas -> add 2 code, thx :)

    The question follows:
    how to interpolate n1, n2, n3, n4 in order 2 get phong shaded object (bilinear interpolation)?
    (didn't find anything on Google, Altavista, MSN, ...)


    GLfloat Color[3];

    GLfloat ambientLight[] = {0.3f, 0.3f, 0.3f, 1.0f};
    GLfloat diffuseLight[] = {1.0f, 1.0f, 1.0f, 1.0f};
    GLfloat specular[] = {1.0f, 1.0f, 1.0f, 1.0f};
    GLfloat lightPos[] = {50.0f, -100.0f, 0.0f};

    float sinus[365];
    float cosinus[365];

    void CalcTable(void)
    {
    int i;

    for(i=0; i<365; i++)
    {
    sinus[i] = sinf((float)i*PI2/365.0f);
    cosinus[i] = cosf((float)i*PI2/365.0f);
    }
    }

    void Rotation(int ax, int ay, int az, float v[3], float rot_v[3])
    {
    const int x = 0;
    const int y = 1;
    const int z = 2;

    rot_v[y] = v[y]*cosinus[ax] - v[z]*sinus[ax]; //x
    rot_v[z] = v[z]*cosinus[ax] + v[y]*sinus[ax];

    // rot_v[z] = rot_v[z]*cosinus[ay] - v[x]*sinus[ay]; //y
    // rot_v[x] = v[x]*cosinus[ay] + rot_v[x]*sinus[ay];

    // rot_v[x] = rot_v[x]*cosinus[az] - rot_v[y]*sinus[az]; //z
    // rot_v[y] = rot_v[y]*cosinus[az] - rot_v[x]*sinus[az];
    }

    void ReduceToUnit(float vector[3])
    {
    float length;

    length = (float)sqrt((vector[0]*vector[0]) +
    (vector[1]*vector[1]) +
    (vector[2]*vector[2]));
    if(length == 0.0f)
    length = 1.0f;

    vector[0] /= length;
    vector[1] /= length;
    vector[2] /= length;
    }

    void CalcCross(float v1[3], float v2[3], float n[3])
    {
    const int x = 0;
    const int y = 1;
    const int z = 2;

    n[x] = v1[y]*v2[z] - v1[z]*v2[y];
    n[y] = v1[z]*v2[x] - v1[x]*v2[z];
    n[z] = v1[x]*v2[y] - v1[y]*v2[x];

    ReduceToUnit(n);
    }

    void CalcLight(float normal[3])
    {
    static int R = 0;
    static int G = 1;
    static int B = 2;
    static int A = 3;

    GLfloat Iambient[4], Idiffuse[4], Ispecular[4];
    float ka[3], kd[3], ks[3];
    float l[3];
    float l_cross_n;
    float b = 10.0f;

    ka[R] = 1.0f;
    ka[G] = 0.0f;
    ka[B] = 1.0f;

    kd[R] = 1.0f;
    kd[G] = 0.0f;
    kd[B] = 1.0f;

    ks[R] = 0.8f;
    ks[G] = 0.8f;
    ks[B] = 0.8f;

    l[0] = lightPos[0];
    l[1] = lightPos[1];
    l[2] = lightPos[2];

    Rotation(angle, 0, 0, normal, normal);

    ReduceToUnit(l);

    l_cross_n = (normal[0]*l[0] + normal[1]*l[1] + normal[2]*l[2]);

    Iambient[R] = ambientLight[R]*ka[R];
    Iambient[G] = ambientLight[G]*ka[G];
    Iambient[B] = ambientLight[B]*ka[B];
    Iambient[A] = ambientLight[A];

    Idiffuse[R] = diffuseLight[R]*kd[R]*l_cross_n;
    Idiffuse[G] = diffuseLight[G]*kd[G]*l_cross_n;
    Idiffuse[B] = diffuseLight[B]*kd[B]*l_cross_n;
    Idiffuse[A] = diffuseLight[A];

    Ispecular[R] = specular[R]*ks[R]*(float)pow(l_cross_n, b);
    Ispecular[G] = specular[G]*ks[G]*(float)pow(l_cross_n, b);
    Ispecular[B] = specular[B]*ks[B]*(float)pow(l_cross_n, b);
    Ispecular[A] = specular[A];

    Color[R] = Iambient[R] + Idiffuse[R] + Ispecular[R];
    Color[G] = Iambient[G] + Idiffuse[G] + Ispecular[G];
    Color[B] = Iambient[B] + Idiffuse[B] + Ispecular[B];
    Color[A] = Iambient[A] + Idiffuse[A] + Ispecular[A];

    glColor4f(Color[R], Color[G], Color[B], Color[A]);
    }

    void QuadNormal(float A[3], float B[3], float C[3], float D[3])
    {
    const int x = 0;
    const int y = 1;
    const int z = 2;

    float vad[3], vab[3], n1[3];
    float vbc[3], vba[3], n2[3];
    float vcb[3], vcd[3], n3[3];
    float vdc[3], vda[3], n4[3];

    vad[x] = D[x] - A[x];
    vad[y] = D[y] - A[y];
    vad[z] = D[z] - A[z];

    vab[x] = B[x] - A[x];
    vab[y] = B[y] - A[y];
    vab[z] = B[z] - A[z];

    CalcCross(vad, vab, n1); // right up
    CalcLight(n1);

    vbc[x] = C[x] - B[x];
    vbc[y] = C[y] - B[y];
    vbc[z] = C[z] - B[z];

    vba[x] = -vab[x];
    vba[y] = -vab[y];
    vba[z] = -vab[z];

    CalcCross(vbc, vba, n2); // right down
    CalcLight(n2);

    vcb[x] = -vbc[x];
    vcb[y] = -vbc[y];
    vcb[z] = -vbc[z];

    vcd[x] = D[x] - C[x];
    vcd[y] = D[y] - C[y];
    vcd[z] = D[z] - C[z];

    CalcCross(vcb, vcd, n3); // left down
    CalcLight(n3);

    vdc[x] = -vcd[x];
    vdc[y] = -vcd[y];
    vdc[z] = -vcd[z];

    vda[x] = -vad[x];
    vda[y] = -vad[y];
    vda[z] = -vad[z];

    CalcCross(vdc, vda, n4); // left up
    CalcLight(n4);
    }

    Phong crazy Tenson :P

  2. #2
    Guest

    Re: If any ideas -> add 2 code, thx :)

    I suggest you should try your luck in advanced forum...

  3. #3
    Senior Member Frequent Contributor
    Join Date
    Apr 2000
    Location
    Adelaide, South Australia, Australia
    Posts
    763

    Re: If any ideas -> add 2 code, thx :)

    You should really reconsider posting slabs of code and asking people to try and figure out what you're talking about. It's like dumping the entire text of Hamlet onto a forum and asking "so, just who IS yorrick?"

    Not many people, I would think, have the time or can be bothered reading the code to find out where you reference n1-n4 so they can work out what you mean by "i want to interpolate 4 values". Besides, interpolating four values is cubic; so, I guess you're talking about linear interpolation about two axis, but why would I read your code to figure out if n1,n2 is one group or if its really n1,n3?

    If your queastion was "how do I interpolate between two values in two dimensions", then you'd probably get more people willing to answer you. Maybe.

    Incentially, the answer to that question is you work out the ratio you are between the two poijts you want to interpolate and compute the interpolate valuue as a weighted average of those two values. Its quite easy when you think about it: you know that yuo have a linear function and therefore you only have one degree of freedom (because its linear).

    here is a small snippet of sample code:

    Code :
    float v[2]={1.0, 2.0}, // the values we want to interpolate between
      d[2]={-2.0, 4.0}; // the "distance" of the two values
    for(float p=d[0]; p<d[1]; p+=(d[1]-d[0])/10.0) {
      float i=(p-d[0])/(d[1]-d[0]);
      printf("interpolated value @ %f is %f", p, v[0]*(1.0-i)+v[1]*i);
    }
    try and sort it out from there.
    cheers,
    John

  4. #4
    Junior Member Newbie
    Join Date
    Jul 2003
    Location
    Slovenia
    Posts
    19

    Re: If any ideas -> add 2 code, thx :)

    Thank u very much

Similar Threads

  1. Some Ideas
    By glfreak in forum OpenGL: General
    Replies: 12
    Last Post: 09-28-2011, 12:56 PM
  2. Glu Me Some Ideas
    By glfreak in forum OpenGL: General
    Replies: 2
    Last Post: 10-31-2008, 03:20 PM
  3. If any ideas -> just add 2 code, thx
    By Tenson in forum OpenGL: Advanced Coding
    Replies: 2
    Last Post: 08-02-2003, 11:30 PM
  4. Any ideas?
    By Kronos259 in forum OpenGL: Advanced Coding
    Replies: 1
    Last Post: 06-08-2003, 09:36 AM
  5. OT but any ideas?
    By Auto in forum OpenGL: Advanced Coding
    Replies: 15
    Last Post: 07-31-2002, 04:13 PM

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts
  •  
Proudly hosted by Digital Ocean