Koło informatyczne 2013

  2 x Button z palety Standard
  1 x ColorDialog z palety Dialogs
  3 x Edit z palety Standard
15 x Label z palety Standard
  9 x Panel z palety Standard
  2 x RadioGroup z palety Standard
  1 x SaveDialog z palety Dialogs
  4 x ScrollBar z palety Standard

Form1

Button1

Button2

ColorDialog1

Edit1

Edit2

Edit3

Label1

Label2

Label3

Label4

Label5

Label6

Label7

Label8

Label9

Label10

Label11

Label12

Label13

Label14

Label15

Panel1

Panel2

Panel3

Panel4

Panel5

Panel6

Panel7

Panel8

Panel9

RadioGroup1

RadioGroup2

ScrollBar1

ScrollBar2

ScrollBar3

ScrollBar4

SaveDialog1

Timer1

//---------------------------------------------------------------------------
void __fastcall Tfrm3D::FormCreate(TObject *Sender)
{
  hdc = GetDC(pnlGL->Handle);  // Zmiana !!!
  SetPixelFormatDescriptor();
  hrc = wglCreateContext(hdc);
  wglMakeCurrent(hdc, hrc);
  SetupRC();
}
//---------------------------------------------------------------------------

...

//---------------------------------------------------------------------------
void __fastcall Tfrm3D::FormResize(TObject *Sender)
{
  glViewport(0, 0, pnlGL->Width, pnlGL->Height);   // Zmiana !!!
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  gluPerspective(45.0f,(GLfloat)pnlGL->Width/(GLfloat)pnlGL->Height,0.1f,300.0f);  // Zmiana !!!
  glMatrixMode(GL_MODELVIEW);
  glClearColor(0.0f, 0.0f, 0.0f, 0.0f);   // kolor tła
  glEnable(GL_DEPTH_TEST);  // włącza bufor głębokości
  glDepthFunc(GL_LESS);
  glEnable(GL_CULL_FACE);   // włącza opcję eliminacji ścian
  glFrontFace(GL_CW);       // ściany o wierzchołkach ułożonych zgodnie z ruchem wskazówek
                            // zegara będą traktowane jako zwrócone przodem
  glCullFace(GL_BACK);      // pomija rysowanie ścian odwróconych tyłem
}
//---------------------------------------------------------------------------

// Zmienne globalne

// Wierzchołki
GLfloat V[][3] = {{ 0.5f,-0.5f, 0.5f},
                  {-0.5f,-0.5f, 0.5f},
                  {-0.5f, 0.5f, 0.5f},
                  { 0.5f, 0.5f, 0.5f},
                  { 0.5f,-0.5f,-0.5f},
                  {-0.5f,-0.5f,-0.5f},
                  {-0.5f, 0.5f,-0.5f},
                  { 0.5f, 0.5f,-0.5f}};

// Kolory
GLubyte C[][3] = {{0x80, 0x00, 0x00}, // clMaroon
                  {0x00, 0x80, 0x00}, // clGreen
                  {0x80, 0x80, 0x00}, // clOlive
                  {0x00, 0x00, 0x80}, // clNavy
                  {0x80, 0x00, 0x80}, // clPurple
                  {0x00, 0x80, 0x80}, // clTeal
                  {0xFF, 0x00, 0x00}, // clRed
                  {0x00, 0xFF, 0xFF}}; // clAqua

// Wierzchołki ścian
int S[] = {0,1,2,3,   // przednia
           3,2,6,7,   // górna
           7,6,5,4,   // tylna
           4,5,1,0,   // spodnia
           0,3,7,4,   // prawa
           1,5,6,2};  // lewa

// Definicje ścian
int F[][3] = {{GL_QUADS, 4, 0},  // przednia
              {GL_QUADS, 4, 4},  // górna
              {GL_QUADS, 4, 8},  // tylnia
              {GL_QUADS, 4,12},  // spodnia
              {GL_QUADS, 4,16},  // prawa
              {GL_QUADS, 4,20}}; // lewa

//---------------------------------------------------------------------------
void Figure3D(int n, bool cmode, GLfloat v[][3], int s[], GLubyte c[][3], int f[][3])
{
  for(int i = 0; i < n; i++)
  {
    if(cmode) glColor3ubv(c[i]);
    glBegin(f[i][0]);
      for(int j = 0; j < f[i][1]; j++)
      {
        if(!cmode) glColor3ubv(c[s[f[i][2]+j]]);
        glVertex3fv(v[s[f[i][2]+j]]);
      }
    glEnd();
  }
}
//---------------------------------------------------------------------------

  // Tutaj umieszczamy program dla OpenGL

  if(rdgView->ItemIndex) glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
  else                   glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
  
  glTranslatef(0,0,-2 - scbD->Position/10.0);
  glRotatef(scbX->Position,1,0,0);
  glRotatef(scbY->Position,0,1,0);
  glRotatef(scbZ->Position,0,0,1);

  Figure3D(6,!rdgColor->ItemIndex,V,S,C,F);

  // Koniec kodu dla OpenGL

//---------------------------------------------------------------------------
void __fastcall Tfrm3D::pnlC0Click(TObject *Sender)
{
  cldColor->Color = ((TPanel *) Sender)->Color;
  if(cldColor->Execute())
  {
    ((TPanel *) Sender)->Color = cldColor->Color;

    C[((TPanel *) Sender)-> Tag][0] = cldColor->Color & 0xff;
    C[((TPanel *) Sender)-> Tag][1] = ((cldColor->Color) >>  8) & 0xff;
    C[((TPanel *) Sender)-> Tag][2] = ((cldColor->Color) >> 16) & 0xff;
  }
}
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
void __fastcall Tfrm3D::edtAKeyPress(TObject *Sender, char &Key)
{
  if(Key == 13)
  {
    GLfloat a = StrToFloat(edtA->Text) / 2;
    if(a > 0)
      for(int i = 0; i < 8; i++)
        switch(i)
        {
          case 0: ;
          case 3: ;
          case 4: ;
          case 7:  V[i][0] =  a; break;
          default: V[i][0] = -a; break;
        }
  }
}
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
void __fastcall Tfrm3D::edtBKeyPress(TObject *Sender, char &Key)
{
  if(Key == 13)
  {
    GLfloat b = StrToFloat(edtB->Text) / 2;
    if(b > 0)
      for(int i = 0; i < 8; i++)
        switch(i)
        {
          case 2: ;
          case 3: ;
          case 6: ;
          case 7:  V[i][1] =  b; break;
          default: V[i][1] = -b; break;
        }
  }
}
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
void __fastcall Tfrm3D::edtCKeyPress(TObject *Sender, char &Key)
{
  if(Key == 13)
  {
    GLfloat c = StrToFloat(edtC->Text) / 2;
    if(c > 0)
      for(int i = 0; i < 8; i++)
        switch(i)
        {
          case 0: ;
          case 1: ;
          case 2: ;
          case 3:  V[i][2] =  c; break;
          default: V[i][2] = -c; break;
        }
  }
}
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
void __fastcall Tfrm3D::btnQuitClick(TObject *Sender)
{
  Close();
}
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
void __fastcall Tfrm3D::btnSaveClick(TObject *Sender)
{
  if(svdSave->Execute())
  {
    ofstream f(svdSave->FileName.c_str());
    int i;

    // V
    f << 8 << endl;
    for(i = 0; i < 8; i++)
      f << V[i][0] << " " << V[i][1] << " " << V[i][2] << endl;

    // C
    f << 8 << endl;
    for(i = 0; i < 8; i++)
      f << (int)C[i][0] << " " << (int)C[i][1] << " " << (int)C[i][2] << endl;

    // S
    f << 24 << endl;
    for(i = 0; i < 24; i += 4)
      f << S[i] << " " << S[i+1] << " " << S[i+2] << " " << S[i+3] << endl;

    // F
    f << 6 << endl;
    for(i = 0; i < 6; i++)
      f << F[i][0] << " " << F[i][1] << " " << F[i][2] << endl;
    f.close();
  }
}
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------

#ifndef glclassH
#define glclassH

#include <Classes.hpp>

//---------------------------------------------------------------------------

class ObjectGL
{
  public:
    float         * V; // wierzchołki
    unsigned char * C; // kolory
    int           * S; // ściany
    int           * F; // ściany

    int nv,nc,ns,nf;

    ObjectGL(AnsiString fn);
    ~ObjectGL();
    void Load(AnsiString fn);
    void Show(bool cmode);
    
  private:
    void Clear();
};

#endif

//---------------------------------------------------------------------------

#pragma hdrstop

#include "glclass.h"
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include <ExtCtrls.hpp>

#include <gl/gl.h>
#include <gl/glu.h>
#include <fstream>

using namespace std;

//---------------------------------------------------------------------------

#pragma package(smart_init)

// Konstruktor
ObjectGL::ObjectGL(AnsiString fn)
{
  nv = nc = ns = nf = 0;
  Load(fn);
}

// Destruktor
ObjectGL::~ObjectGL()
{
  Clear();
}

// Ładuje obiekt z pliku
void ObjectGL::Load(AnsiString fn)
{
  Clear();

  ifstream f(fn.c_str(),ios_base::in);
  int i, n, c;

  if(f.good())
  {
    f >> nv;
    n = 3 * nv;
    V = new float [n];
    for(i = 0; i < n; i++) f >> V[i];

    f >> nc;
    n = 3 * nc;
    C = new unsigned char[n];
    for(i = 0; i < n; i++)
    {
      f >> c;
      C[i] = c;
    }

    f >> ns;
    S = new int[ns];
    for(i = 0; i < ns; i++) f >> S[i];

    f >> nf;
    n = 3 * nf;
    F = new int[n];
    for(i = 0; i < n; i++) f >> F[i];
  }
  f.close();
}

// Wyświetla obiekt
void ObjectGL::Show(bool cmode)
{
  for(int i = 0; i < nf; i++)
  {
    if(cmode) glColor3ubv(&C[3*i]);

    int ftyp = F[3 * i];
    int fnum = F[3 * i + 1];
    int fpos = F[3 * i + 2];

    glBegin(ftyp);
      for(int j = 0; j < fnum; j++)
      {
        int pos = 3 * S[fpos + j];
        if(!cmode) glColor3ubv(&C[pos]);
        glVertex3fv(&V[pos]);
      }
    glEnd();
  }
}

// Usuwa zawartość tablic
void ObjectGL::Clear()
{
  if(nv)
  {
    delete [] V;
    nv = 0;
  }

  if(nc)
  {
    delete [] C;
    nc = 0;
  }

  if(ns)
  {
    delete [] S;
    ns = 0;
  }

  if(nf)
  {
    delete [] F;
    nf = 0;
  }
}

  // Tutaj umieszczamy program dla OpenGL

  static GLfloat alphax = 0;
  static GLfloat alphay = 0;
  static GLfloat alphaz = 0;

  glTranslatef(0.0f,0.0f,-3.0f);
  glRotatef(alphax,1,0,0);
  glRotatef(alphay,0,1,0);
  glRotatef(alphaz,0,0,1);

//  glPolygonMode(GL_FRONT,GL_LINE);

  fig.Show(true);

  alphax += 0.5; if(alphax >= 360) alphax = 0;
  alphay += 0.2; if(alphay >= 360) alphay = 0;
  alphaz += 0.3; if(alphaz >= 360) alphaz = 0;
  
  // Koniec kodu dla OpenGL