---

MDITransparent.cpp

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

#include <vcl.h>
#pragma hdrstop

#include "MDITransparent.h"
#include "MDIEdit.h"
#include "MDIFrame.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TTransparentForm *TransparentForm;
rgb *transparentview;

    long testx,testy,testz;
const float pi=3.141592;
const float pi2=2*pi;
const float pih=pi/2;
const float pirad=pi/180;
int ox,oy, mrotx, mroty;
bool mdown;

//---------------------------------------------------------------------------
__fastcall TTransparentForm::TTransparentForm(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TTransparentForm::SetPixelFormatDescriptor()
{
    PIXELFORMATDESCRIPTOR pfd = {
        sizeof(PIXELFORMATDESCRIPTOR),
        1,
        PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
        PFD_TYPE_RGBA,
        24,
        0,0,0,0,0,0,
        0,0,
        0,0,0,0,0,
        32,
        0,
        0,
        PFD_MAIN_PLANE,
        0,
        0,0,
    };
    PixelFormat = ChoosePixelFormat(hdc, &pfd);
    SetPixelFormat(hdc, PixelFormat, &pfd);
}

//---------------------------------------------------------------------
void __fastcall TTransparentForm::FormClose(TObject *Sender, TCloseAction &Action)
{
delete [] transparentview;
Action=caFree;
FrameForm->Transparent->Checked = false;
memusage = memusage - 3*1024*1024;
FrameForm->memupdate();
wglDeleteContext(hrc);
ReleaseDC(Handle,hdc);
}
//---------------------------------------------------------------------
void __fastcall TTransparentForm::FormCreate(TObject *Sender)
{
    int i,a;

    transparentview = new rgb[1024*1024];
    memusage = memusage + 3*1024*1024;
    FrameForm->memupdate();

    mrotx=0; mroty=0;xres=256;yres=256;thresh = 400;
    hdc = GetDC(Handle);
    SetPixelFormatDescriptor();
    hrc = wglCreateContext(hdc);
    if(hrc == NULL) ShowMessage("Could not create DC!");
    wglMakeCurrent(hdc, hrc);

    w = ClientWidth;
    h = ClientHeight;

    glEnable(GL_DEPTH_TEST);
    glEnable(GL_CULL_FACE);

    glClearColor(0.2f, 0.2f, 0.2f, 1.0f);
    glOrtho (-50.0,50.0,-50.0,50.0,-50.0,50.0);

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glFlush();
    SwapBuffers(hdc);
    FormResize(Sender);
    RayCast();
}
//---------------------------------------------------------------------
void __fastcall TTransparentForm::FormResize(TObject *Sender)
{
        PrepareGLWindow();
        if (autores->Checked) {RayCast();}
        PaintGL();
}
//---------------------------------------------------------------------------
void __fastcall TTransparentForm::FormPaint(TObject *Sender)
{
        PaintGL();
}
//---------------------------------------------------------------------------
void __fastcall TTransparentForm::PaintGL()
{
        float i;

        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        PrepareGLWindow();
        glColor3f(0.6f,0.6f,0.6f);
        glLineWidth(3.0f);
        glBegin(GL_LINE_STRIP);
        glVertex3f(-50,-50,0);
        glVertex3f(50,-50,0);
        glVertex3f(50,50,0);
        glVertex3f(-50,50,0);
        glVertex3f(-50,-50,0);
        glEnd();

        glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
        glDrawPixels(xres, yres, GL_RGB, GL_UNSIGNED_BYTE,transparentview);
                        // we use unsigned byte (char) to meet speed issues.
                        // 16 bit data (__int16) slows down drawing to much.

        glFlush();
        SwapBuffers(hdc);
}

void __fastcall TTransparentForm::PrepareGLWindow()
{
        wglMakeCurrent(hdc, hrc);

        GLfloat nRange = 50.0;
        w = ClientWidth-200;
        h = ClientHeight;

        if(h == 0) h = 1;
        if(w == 0) w = 1;

        glViewport(200, 0, w, h);
        glLoadIdentity();

        if (w <= h)
        {        glOrtho (-nRange, nRange, -nRange*h/w, nRange*h/w, -nRange, nRange);
                glPixelZoom((float)w/(float)xres, (float)w/(float)yres);}
         else
        {        glOrtho (-nRange*w/h, nRange*w/h, -nRange, nRange, -nRange, nRange);
                glPixelZoom((float)h/(float)xres, (float)h/(float)yres);}

        glRasterPos2d(-50,-50);
}
//---------------------------------------------------------------------------

void __fastcall TTransparentForm::FormActivate(TObject *Sender)
{
        PaintGL();
}
//---------------------------------------------------------------------------
void __fastcall TTransparentForm::RayCast()
{
        int a,i,k,maxres;
        __int16 value;
        int aktpos, rowsize,pagesize, px, py, pz;
        int h,ita, ite;
        float j,t,ta,te,tx,ty,tz,xrcos,yrcos,zrcos,xrsin,yrsin,zrsin,xrot,yrot,zrot;
        float valcr, valcg, valcb, valgx,valgy,valgz,value1,value2,value3, value4, value11, value22,pfx,pfy,pfz,sx,sy,sz,s1x,s1y;
        float temp, fr, fg, fb;
        bool detset;
        double valsh, ac, ac2;
        float lx, ly, lz, alphasum, alpha;
        unsigned char col, vcol;
        const trlimit = 1/256;

        alphasum = 1.0;

        vertex pppos;
        vertex dlookup[1024];
        if (autores->Checked)
        { if (w>h) {xres=h;yres=h;} else {xres=w;yres=w;} }
        else
        {
        xres = StrToInt(textx->Caption);
        yres = StrToInt(texty->Caption);
        }
        xrot = (float)StrToFloat(txrot->Text)*pirad;
//        yrot = (float)StrToFloat(tyrot->Text)*pirad;
        zrot = (float)StrToFloat(tzrot->Text)*pirad;

        xrcos = _fm_cos(xrot);
//        yrcos = _fm_cos(yrot);
        zrcos = _fm_cos(zrot);
        xrsin = _fm_sin(xrot);
//        yrsin = _fm_sin(yrot);
        zrsin = _fm_sin(zrot);

        FrameForm->StatusProgress->Position = 0;
        FrameForm->StatusProgress->Visible = true;
        maxres = MAX(MAX(sizeX,sizeY),sizeZ);


        lx =0; ly=1; lz=0;

        temp = ly;
        ly = temp*xrcos - lz * xrsin;
        lz = temp*xrsin + lz * xrcos;

        temp = lx;
        lx = temp*zrcos - ly * zrsin;
        ly = temp*zrsin + ly * zrcos;


        dx.x = (float)maxres/(float)xres;
        dx.y = 0;
        dx.z = 0;

        temp = dx.y;

        dx.x = dx.x;
        dx.y = temp * xrcos - dx.z*xrsin;
        dx.z = temp * xrsin + dx.z*xrcos;

        temp = dx.x;

        dx.x = temp * zrcos - dx.y * zrsin;
        dx.y = temp * zrsin + dx.y * zrcos;
        dx.z = dx.z;

        dy.x = 0;
        dy.y = 0;
        dy.z = (float)maxres/(float)yres;

        temp = dy.y;

        dy.x = dy.x;
        dy.y = temp * xrcos - dy.z*xrsin;
        dy.z = temp * xrsin + dy.z*xrcos;

        temp = dy.x;

        dy.x = temp * zrcos - dy.y * zrsin;
        dy.y = temp * zrsin + dy.y * zrcos;
        dy.z = dy.z;


        dz.x = 0;
        dz.y = 1;
        dz.z = 0;

        temp = dz.y;

        dz.x = dz.x;
        dz.y = temp * xrcos - dz.z*xrsin;
        dz.z = temp * xrsin + dz.z*xrcos;

        temp = dz.x;

        dz.x = temp * zrcos - dz.y * zrsin;
        dz.y = temp * zrsin + dz.y * zrcos;
        dz.z = dz.z;

        o.x = -(maxres/2);
        o.y = -(sizeY/2);
        o.z = -(maxres/2);

        temp = o.y;

        o.x = o.x;
        o.y = temp * xrcos - o.z*xrsin;
        o.z = temp * xrsin + o.z*xrcos;

        temp = o.x;

        o.x = temp * zrcos - o.y * zrsin;
        o.y = temp * zrsin + o.y * zrcos;
        o.z = o.z;

        o.x = o.x + sizeX/2;
        o.y = o.y + sizeY/2;
        o.z = o.z + sizeZ/2;

        pagesize = sizeX*sizeY;
        rowsize = sizeX;

        for (i=0; i<1024; i++)
        {
        dlookup[i].x = (i-512) * dz.x;        //Lookup-Values für RayCast berechnen
        dlookup[i].y = (i-512) * dz.y;
        dlookup[i].z = (i-512) * dz.z;
        }

        k = 0;
        for (a=0; a<yres; a++)
        {
                pppos.x = o.x + a * dy.x;
                pppos.y = o.y + a * dy.y;
                pppos.z = o.z + a * dy.z;

                if (arepaint->Checked == false) {FrameForm->StatusProgress->Position = (int)(100 * ((float)a / (float)yres));}
                for (i=0; i<xres; i++)
                {
                        ppos.x = pppos.x + i * dx.x;     // Rotierten Startpunkt für parametrisierte
                        ppos.y = pppos.y + i * dx.y;     // Gerade berechnen ...
                        ppos.z = pppos.z + i * dx.z;

                        ta = 9999;
                        te = 9999;

                        if (dz.x!=0)
                        {
                          t = -ppos.x/dz.x;                      // Schneide Ray mit x=0
                          ty = ppos.y + t*dz.y;
                          tz = ppos.z + t*dz.z;
                          if (ty>=0 && tz>=2 && ty<sizeY-1 && tz<sizeZ-3) { if (ta==9999) ta=t; else te=t; }

                          t = (sizeX-1-ppos.x)/dz.x;               // Schneide Ray mit x=sizeX
                          ty = ppos.y + t*dz.y;
                          tz = ppos.z + t*dz.z;
                          if (ty>=0 && tz>=2 && ty<sizeY-1 && tz<sizeZ-3) { if (ta==9999) ta=t; else te=t; }
                        }

                        if (dz.y!=0)
                        {
                          t = -ppos.y/dz.y;                      // Schneide Ray mit y=0
                          tx = ppos.x + t*dz.x;
                          tz = ppos.z + t*dz.z;
                          if (tx>=0 && tz>=2 && tx<sizeX-1 && tz<sizeZ-3) { if (ta==9999) ta=t; else te=t; }

                          t = (sizeY-1-ppos.y)/dz.y;               // Schneide Ray mit y=sizeY
                          tx = ppos.x + t*dz.x;
                          tz = ppos.z + t*dz.z;
                          if (tx>=0 && tz>=2 && tx<sizeX-1 && tz<sizeZ-3) { if (ta==9999) ta=t; else te=t; }
                        }

                        if (dz.z!=0)
                        {
                          t = (2-ppos.z)/dz.z;                      // Schneide Ray mit z=0
                          tx = ppos.x + t*dz.x;
                          ty = ppos.y + t*dz.y;
                          if (tx>=0 && ty>=0 && tx<sizeX-1 && ty<sizeY-1) { if (ta==9999) ta=t; else te=t; }

                          t = (sizeZ-3-ppos.z)/dz.z;               // Schneide Ray mit z=sizeZ
                          tx = ppos.x + t*dz.x;
                          ty = ppos.y + t*dz.y;
                          if (tx>=0 && ty>=0 && tx<sizeX-1 && ty<sizeY-1) { if (ta==9999) ta=t; else te=t; }
                        }

                        if (ta>te) {t=ta; ta=te; te=t;}

                        if (te==9999)
                        {
                        transparentview[k].r=transparentview[k].b=transparentview[k].g = 0;
                        }
                        else
                        {
                        value = 0; ita = (int)ta+512; ite = (int)te+512-2;
                        alphasum = 1.0;fr = 0.0; fg = 0.0; fb = 0.0;
                        for (j=ta; j<te && alphasum>trlimit; j = j + 1.0)
                        { //if (detset==0) j += detval;

                          pfx = (ppos.x) + j * dz.x;
                          pfy = (ppos.y) + j * dz.y;
                          pfz = (ppos.z) + j * dz.z;

/*label1:                   pfx = (ppos.x) + dlookup[j].x;
                          pfy = (ppos.y) + dlookup[j].y;
                          pfz = (ppos.z) + dlookup[j].z;
*/
                          px = (int)pfx;
                          py = (int)pfy;
                          pz = (int)pfz;
                          if (pz>=sizeZ) {pz=sizeZ-1;}
                          aktpos = pagesize*pz + rowsize*py + px;
                          if (trilinear->Checked)
                          {
                                sx = pfx-px;
                                sy = pfy-py;
                                sz = pfz-pz;
                                s1x = 1-sx;
                                s1y = 1-sy;
                                value1 = (float)data[aktpos]*s1x                  + (float)data[aktpos+1]*sx;
                                value2 = (float)data[aktpos+rowsize]*s1x          + (float)data[aktpos+rowsize+1]*sx;
                                value3 = (float)data[aktpos+pagesize+rowsize]*s1x + (float)data[aktpos+pagesize+rowsize+1]*sx;
                                value4 = (float)data[aktpos+pagesize]*s1x         + (float)data[aktpos+pagesize+1]*sx;
                                value11 = value1*(s1y) + value2*(sy);
                                value22 = value4*(s1y) + value3*(sy);
                                value = (int)(value11*(1-sz) + value22*(sz));
                          }
                          else
                          {
                                value = data[pagesize*pz + rowsize*py + px];
                          }

                                if (trilinear->Checked)
                                {sx = fabs(pfx-(float)px);
                                sy = fabs(pfy-(float)py);
                                sz = fabs(pfz-(float)pz);
                                s1x = (float)1-sx;
                                value1 = (float)color[aktpos].a*s1x                  + (float)color[aktpos+1].a*sx;
                                value2 = (float)color[aktpos+rowsize].a*s1x          + (float)color[aktpos+rowsize+1].a*sx;
                                value3 = (float)color[aktpos+pagesize+rowsize].a*s1x + (float)color[aktpos+pagesize+rowsize+1].a*sx;
                                value4 = (float)color[aktpos+pagesize].a*s1x         + (float)color[aktpos+pagesize+1].a*sx;
                                value11 = value1*(1-sy) + value2*(sy);
                                value22 = value4*(1-sy) + value3*(sy);
                                alpha=(float)((value11*(1-sz) + value22*(sz))/255);

                                //alpha = ((float)color[aktpos].a/255);

                                if (alpha>0.0)
                                {
                                value1 = (float)color[aktpos].r*s1x                  + (float)color[aktpos+1].r*sx;
                                value2 = (float)color[aktpos+rowsize].r*s1x          + (float)color[aktpos+rowsize+1].r*sx;
                                value3 = (float)color[aktpos+pagesize+rowsize].r*s1x + (float)color[aktpos+pagesize+rowsize+1].r*sx;
                                value4 = (float)color[aktpos+pagesize].r*s1x         + (float)color[aktpos+pagesize+1].r*sx;
                                value11 = value1*(1-sy) + value2*(sy);
                                value22 = value4*(1-sy) + value3*(sy);
                                valcr=((value11*(1-sz) + value22*(sz)));
                                //valcr = color[aktpos].r;

                                value1 = (float)color[aktpos].g*s1x                  + (float)color[aktpos+1].g*sx;
                                value2 = (float)color[aktpos+rowsize].g*s1x          + (float)color[aktpos+rowsize+1].g*sx;
                                value3 = (float)color[aktpos+pagesize+rowsize].g*s1x + (float)color[aktpos+pagesize+rowsize+1].g*sx;
                                value4 = (float)color[aktpos+pagesize].g*s1x         + (float)color[aktpos+pagesize+1].g*sx;
                                value11 = value1*(1-sy) + value2*(sy);
                                value22 = value4*(1-sy) + value3*(sy);
                                valcg=((value11*(1-sz) + value22*(sz)));
                                //valcg = color[aktpos].g;

                                value1 = (float)color[aktpos].b*s1x                  + (float)color[aktpos+1].b*sx;
                                value2 = (float)color[aktpos+rowsize].b*s1x          + (float)color[aktpos+rowsize+1].b*sx;
                                value3 = (float)color[aktpos+pagesize+rowsize].b*s1x + (float)color[aktpos+pagesize+rowsize+1].b*sx;
                                value4 = (float)color[aktpos+pagesize].b*s1x         + (float)color[aktpos+pagesize+1].b*sx;
                                value11 = value1*(1-sy) + value2*(sy);
                                value22 = value4*(1-sy) + value3*(sy);
                                valcb=((value11*(1-sz) + value22*(sz)));
                                //valcb = color[aktpos].b;

                                value1 = (float)gradient[aktpos].y*s1x                  + (float)gradient[aktpos+1].y*sx;
                                value2 = (float)gradient[aktpos+rowsize].y*s1x          + (float)gradient[aktpos+rowsize+1].y*sx;
                                value3 = (float)gradient[aktpos+pagesize+rowsize].y*s1x + (float)gradient[aktpos+pagesize+rowsize+1].y*sx;
                                value4 = (float)gradient[aktpos+pagesize].y*s1x         + (float)gradient[aktpos+pagesize+1].y*sx;
                                value11 = value1*(1-sy) + value2*(sy);
                                value22 = value4*(1-sy) + value3*(sy);
                                valgy=((value11*(1-sz) + value22*(sz)));

                                value1 = (float)gradient[aktpos].x*s1x                  + (float)gradient[aktpos+1].x*sx;
                                value2 = (float)gradient[aktpos+rowsize].x*s1x          + (float)gradient[aktpos+rowsize+1].x*sx;
                                value3 = (float)gradient[aktpos+pagesize+rowsize].x*s1x + (float)gradient[aktpos+pagesize+rowsize+1].x*sx;
                                value4 = (float)gradient[aktpos+pagesize].x*s1x         + (float)gradient[aktpos+pagesize+1].x*sx;
                                value11 = value1*(1-sy) + value2*(sy);
                                value22 = value4*(1-sy) + value3*(sy);
                                valgx=((value11*(1-sz) + value22*(sz)));

                                value1 = (float)gradient[aktpos].z*s1x                  + (float)gradient[aktpos+1].z*sx;
                                value2 = (float)gradient[aktpos+rowsize].z*s1x          + (float)gradient[aktpos+rowsize+1].z*sx;
                                value3 = (float)gradient[aktpos+pagesize+rowsize].z*s1x + (float)gradient[aktpos+pagesize+rowsize+1].z*sx;
                                value4 = (float)gradient[aktpos+pagesize].z*s1x         + (float)gradient[aktpos+pagesize+1].z*sx;
                                value11 = value1*(1-sy) + value2*(sy);
                                value22 = value4*(1-sy) + value3*(sy);
                                valgz=((value11*(1-sz) + value22*(sz)));

                                valsh = fabs(valgx*lx+valgy*ly+valgz*lz);
                                if (valsh>1) {valsh=1.0;}
                                if (valsh<0) {valsh=0.0;}
                                ac=_fm_acos(valsh);
                                if (ac<0) {ac=0;}
                                if (ac>pih) {ac=pih;}
                                ac = 1-(ac/pih);
                                //ac = fabs(valsh);
                                if (highlights->Checked) {
                                valsh = valsh*valsh;
                                valsh = valsh*valsh;
                                valsh = valsh*valsh;
                                valsh = valsh*valsh;
                                valsh = valsh*valsh;
                                //valsh = valsh*valsh;
                                ac2 = (float)255*valsh;
                                //h = (int)255*ac2;
                                //if (h>255) {col=255;} else {col = h;}
                                fr = fr + (float)((alphasum) * (alpha) * ac * (valcr+ac2));
                                fg = fg + (float)((alphasum) * (alpha) * ac * (valcg+ac2));
                                fb = fb + (float)((alphasum) * (alpha) * ac * (valcb+ac2));
                                }
                                else {
                                fr = fr + (float)((alphasum) * (alpha) * ac * valcr);
                                fg = fg + (float)((alphasum) * (alpha) * ac * valcg);
                                fb = fb + (float)((alphasum) * (alpha) * ac * valcb);
                                }

                                alphasum = alphasum * (1-alpha);
                                }
                                }
                                else
                                {
                                alpha = (float)color[aktpos].a/255;

                                if (alpha>0.0)
                                {valsh = fabs(gradient[pagesize*pz + rowsize*py + px].x*lx+gradient[pagesize*pz + rowsize*py + px].y*ly+gradient[pagesize*pz + rowsize*py + px].z*lz);
                                if (valsh>1) {valsh=1.0;}
                                if (valsh<0) {valsh=0.0;}
                                ac=_fm_acos(valsh);
                                if (ac<0) {ac=0;}
                                if (ac>pih) {ac=pih;}
                                ac = 1-(ac/pih);
                                //ac = fabs(valsh);
                                if (highlights->Checked) {
                                valsh = valsh*valsh;
                                valsh = valsh*valsh;
                                valsh = valsh*valsh;
                                valsh = valsh*valsh;
                                valsh = valsh*valsh;
                                valsh = valsh*valsh;
                                ac2 = 255*valsh;
                                //h = (int)255*ac2;
                                //if (h>255) {col=255;} else {col = h;}
                                fr = fr + (float)((alphasum) * (alpha) * ac * (color[aktpos].r+ac2));
                                fg = fg + (float)((alphasum) * (alpha) * ac * (color[aktpos].g+ac2));
                                fb = fb + (float)((alphasum) * (alpha) * ac * (color[aktpos].b+ac2));
                                }
                                else {
                                fr = fr + (float)((alphasum) * (alpha) * ac * color[aktpos].r);
                                fg = fg + (float)((alphasum) * (alpha) * ac * color[aktpos].g);
                                fb = fb + (float)((alphasum) * (alpha) * ac * color[aktpos].b);
                                }

                                alphasum = alphasum * (1-alpha);
                                }
                                }
                        }
                        if (alphasum>trlimit)
                        {
                        //fr = fr + alphasum*20;
                        //fg = fg + alphasum*20;
                        //fb = fb + alphasum*30;
                        }
                        if (fr>255) {fr=255;}
                        if (fg>255) {fg=255;}
                        if (fb>255) {fb=255;}
                        transparentview[k].r= (unsigned char)fr;
                        transparentview[k].g= (unsigned char)fg;
                        transparentview[k].b= (unsigned char)fb;
                        }

                k++;
                }
        }
        FrameForm->StatusProgress->Visible = false;
}

//---------------------------------------------------------------------------
void __fastcall TTransparentForm::FormMouseDown(TObject *Sender,
      TMouseButton Button, TShiftState Shift, int X, int Y)
{
mdown=true;
ox = X;
oy = Y;
}
//---------------------------------------------------------------------------

void __fastcall TTransparentForm::FormMouseMove(TObject *Sender,
      TShiftState Shift, int X, int Y)
{
if (mdown)
{
mrotx -= (Y-oy);
mroty -= (X-ox);
if (mrotx<0) mrotx += 360;
if (mrotx>360) mrotx -= 360;
if (mroty<0) mroty += 360;
if (mroty>360) mroty -= 360;

if (arepaint->Checked) {RayCast(); PaintGL(); }
txrot->Text = IntToStr(mrotx);
tzrot->Text = IntToStr(mroty);
ox = X;
oy = Y;
}
        
}
//---------------------------------------------------------------------------

void __fastcall TTransparentForm::FormMouseUp(TObject *Sender,
      TMouseButton Button, TShiftState Shift, int X, int Y)
{
mdown=false;
RayCast();
PaintGL();

}
//---------------------------------------------------------------------------

void __fastcall TTransparentForm::autoresClick(TObject *Sender)
{
if (autores->Checked==true)
        {
        ResTrackBar->Enabled=false;
        textx->Enabled=false;
        Label2->Enabled=false;
        texty->Enabled=false;
        }
        else
        {
        ResTrackBar->Enabled=true;
        textx->Enabled=true;
        Label2->Enabled=true;
        texty->Enabled=true;
        }
if (arepaint->Checked) {RayCast();PaintGL();}
        
}
//---------------------------------------------------------------------------

void __fastcall TTransparentForm::trilinearClick(TObject *Sender)
{
if (arepaint->Checked) {RayCast();PaintGL();}        
}
//---------------------------------------------------------------------------

void __fastcall TTransparentForm::ResTrackBarChange(TObject *Sender)
{
switch (ResTrackBar->Position)
        {
        case 1: textx->Caption = "32"; texty->Caption = "32"; break;
        case 2: textx->Caption = "64"; texty->Caption = "64"; break;
        case 3: textx->Caption = "128"; texty->Caption = "128"; break;
        case 4: textx->Caption = "256"; texty->Caption = "256"; break;
        case 5: textx->Caption = "512"; texty->Caption = "512"; break;
        case 6: textx->Caption = "1024"; texty->Caption = "1024";
        }
if (arepaint->Checked) {RayCast();PaintGL();}

}
//---------------------------------------------------------------------------

---