Una function para ampliar una parte de la pantalla

Previous topic - Next topic

chve

Pues eso, ya tenia escrita esta function, pero en otro lenguaje y con bugs. :rant:

Y la reescribi para GLBasis y parece que funciona bin y sin errores (o eso creo)
Las functiones que devuelven el  rgb las agarre  del foro porque no vi otro modo mejor  :D
Code (glbasic) Select


// --------------------------------------------------------------------------------;
//                       --- Function   Zoom  ---                                  ;
// --------------------------------------------------------------------------------;
//                                                                                 ;
// Zoom (xm,ym,xstartgrid,ystartgrid,wbox,hbox,xnumgrid,ynumgrid,border,exborder)  ;
// xmpix <------------------ X mouse/pixel Position                                ;
// ympix <------------------ Y mouse/pixel Position                                ;
// xstartgrid <-------------- Position X left up start Zoom                        ;
// ystartgrid <-------------- Position Y left up start Zoom                        ;
// wbox <---------------- X Size IN pinxels of Each box IN zoom                    ;
// hbox <---------------- Y Size IN pinxels of Each box IN Zoom                    ;
// xnumgrid <------------ Amount of X boxes IN Zoom                                ;
// ynumgrid <------------ Amount ofY  boxes IN Zoom                                ;
// border <-------------- Size IN pinxels of border                                ;
// exborder <------------ exterior border                                          ;
//---------------------------------------------------------------------------------;

FUNCTION zoom: xmpix, ympix, xstartgrid, ystartgrid, wbox, hbox, xnumgrid, ynumgrid, border,exborder
LOCAL widegrid, heightgrid, xcurs, ycurs, xpix, ypix
LOCAL xborder, yborder
LOCAL xzoom, yzoom, posx, posy
    STATIC numx=1 ,numy=1, timerfrm, timercolor

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

timerfrm=timerfrm+GETTIMER()
IF timerfrm >= 399.0
  timerfrm = timerfrm - 399.0
  INC timercolor, 1
  IF timercolor > 2 THEN timercolor = 1
  //PRINT "tiempo paso!!!  "+timercolor ,100,100,RGB(0,5,55)
ENDIF


widegrid=wbox*xnumgrid+xnumgrid*border ;  heightgrid=hbox*ynumgrid+ynumgrid*border

xpix=xmpix ; ypix=ympix
posx = xstartgrid
posy = ystartgrid

// DRAWRECT xmpix,ympix,xnumgrid, ynumgrid, RGB (0,255,255)     //un recuadro  del Zoom que se escanea. Es un cuadrado fijo
DRAWLINE xmpix, ympix-1, xmpix+xnumgrid,ympix-1, RGB(0,255,255)                             // horizontal - arriba
DRAWLINE xmpix+xnumgrid, ympix, xmpix+xnumgrid,ympix+ynumgrid , RGB(0,255,255)          // vertical - derecha
DRAWLINE xmpix, ympix+ynumgrid, xmpix+xnumgrid,ympix+ynumgrid,  RGB(0,255,255)          // Horizontal - abajo
DRAWLINE xmpix-1, ympix, xmpix-1 ,ympix+ynumgrid, RGB(0,255,255)                            // vertical - izquierda

    DRAWRECT xstartgrid-exborder-border,ystartgrid-exborder-border,widegrid+exborder*2+border,heightgrid+exborder*2+border, RGB (0,255,255) //el borde exterior
IF border> 0 THEN DRAWRECT xstartgrid-border,ystartgrid-border,widegrid+border,heightgrid+border, RGB (20,95,30)             // la rejilla interna


FOR ax=1 TO ynumgrid                     //Read pinxels for drawing grid
xpix=xmpix
posx=xstartgrid
FOR bx=1 TO xnumgrid
// dibuja el borde
IF border> 0 THEN DRAWRECT posx-1, posy-1,wbox+2,hbox+2,  RGB(50,50,50)

col% = GETPIXEL(xpix, ypix)

r=(col%)
g=(col%)
b=(col%)
a=(col%)

rgbr(r)
rgbg(g)
rgbb(b)
rgba(a)

DRAWRECT posx,posy,wbox,hbox,  RGB(red,green,blue)
posx=posx+wbox+border

INC xpix,1
NEXT

posy= posy+hbox+border
INC ypix,1
NEXT

xpix=xmpix+numx-1 ; ypix=ympix+numy-1

IF KEY(205)=1 AND numx < xnumgrid THEN numx=numx+1 ; INC xpix,1   // mover el cursor derecha
IF KEY(203)=1 AND numx > 1 THEN numx=numx-1 ; DEC xpix, 1          // mover el cursor izquierda
IF KEY(208)=1 AND numy < ynumgrid THEN numy=numy+1 ; INC ypix,1   // mover el cursor arriba
IF KEY(200)=1 AND numy > 1 THEN numy=numy-1 ;DEC ypix, 1           // mover el cursor abajo

col% = GETPIXEL(xpix,ypix)

r=(col%)
g=(col%)
b=(col%)
a=(col%) // esto no lo uso


rgbr(r)
rgbg(g)
rgbb(b)
rgba(a) // esto no lo uso


IF timercolor=1 THEN SETPIXEL xpix,ypix, RGB(255,255,255)    // el pinxel que se escanea
            IF timercolor=2 THEN SETPIXEL xpix,ypix, RGB(255,green,blue) // el pinxel que se escanea

xzoom=xstartgrid
yzoom=ystartgrid


//las zonas para picar con el raton
xmpix=mx ; ympix=my
xborder=0 ; yborder=0
FOR k=1 TO xnumgrid
yborder=0 ; yzoom=ystartgrid
FOR j=1 TO ynumgrid

IF xmpix>xzoom AND xmpix<xzoom+wbox AND ympix> 0+yzoom AND ympix<yzoom+hbox AND b1=1
numx=k ; numy=j
xpix=k ; ypix=j

//DRAWRECT xborder+xstartgrid,yborder+ystartgrid,wbox,hbox , RGB(255,255,255)

j=xnumgrid ; k=ynumgrid
ENDIF
yzoom=yzoom+hbox+border
yborder=yborder+hbox+border

NEXT

xzoom=xzoom+wbox+border
xborder=xborder+wbox+border
NEXT


xcurs=0                           // calculo de posicion del 'cursor'
FOR M=1 TO xnumgrid
IF M=numx THEN xzoom=xstartgrid+xcurs
xcurs=xcurs+wbox+border
NEXT
ycurs=0
FOR N=1 TO ynumgrid
IF N=numy THEN yzoom=ystartgrid+ycurs
ycurs=ycurs+hbox+border
NEXT

  IF timercolor=1
     DRAWRECT xzoom-1,yzoom-1,wbox+2,hbox+2,RGB(255,0,128)  // el recuadro del grid
     DRAWRECT xzoom,yzoom,wbox,hbox,RGB(red,green,blue)
  ENDIF
  IF timercolor=2
  DRAWRECT xzoom-1,yzoom-1,wbox+2,hbox+2,RGB(80,80,255)
  DRAWRECT xzoom,yzoom,wbox,hbox,RGB(0,0,0)
  ENDIF


DRAWRECT xstartgrid-exborder-border,ystartgrid+heightgrid+exborder,widegrid+exborder*2+border,54, RGB(25,5,255) // El recuadro de texto
PRINT  " X = " + xpix+ " Y = "+ ypix+ "    Cursor X = " + numx + "  Cursor Y = " + numy , xstartgrid+1,ystartgrid+heightgrid+exborder+border+2,RGB(0,5,55)
PRINT " Color: "+ col% ,  xstartgrid+1,ystartgrid+heightgrid+exborder+border+18, RGB(0,5,55)
PRINT " Red: "+ red  + "  Green: " + green + "  Blue: " + blue + " alpha: "+ alph ,xstartgrid+1,ystartgrid+heightgrid+exborder+border+34,RGB(0,5,55)

ENDFUNCTION

//*************************************
//Function rgbr(col) - return the red component of a 32 bit colour
//*************************************
FUNCTION rgbr: col%
red=bAND(col%,0xff)
RETURN red
ENDFUNCTION
//*************************************
//Function rgbg(col) - return the green component of a  32 bit colour
//*************************************
FUNCTION rgbg: col%
green=bAND(col%/0x100,0xff)
RETURN green
ENDFUNCTION
//*************************************
//Function rgbb(col) - return the blue component of a  32 bit colour
//*************************************
FUNCTION rgbb: col%
blue=bAND(col%/0x10000,0xff)
RETURN blue
ENDFUNCTION
//*************************************
//Function rgba(col) - return the alpha component of a  32 bit colour
//*************************************
FUNCTION rgba: col%
alph=bAND(col%/0x1000000,0xff)
RETURN alph
ENDFUNCTION





Y aqui para probarla con media:
http://www.4shared.com/file/QjAx_LXs/Zoom_function.html

Tambien aqui "coji prestado" algo del foro algo de  :D de Hemlos http://www.glbasic.com/forum/index.php?topic=3917.msg28705#msg28705   para poner limites de tiempo. Todo lo demas lo escribi yo.
Y me construi una subrutina para salvar screenshot que no acaba de funcionar aun bie jiji


Si no os parece gran cosa, tendriais que ver todo  lo demas que he hecho que es aun peor y muy lioso  :D

Una de las cosas mas dificiles que encuentro al programar, es definir el nombre de cada variable correctamente, para evitar hacerme un lio!!

Ruidesco

No sé exactamente qué hace la función, pero en GLBasic con un GRABSPRITE y un STRETCHSPRITE creo que se puede hacer una "lupa" en tiempo real bastante bien.

chve

Pues veras, Ruidesco. Yo aun no conzco todos los comandos del GLBasic y simpelemete adapte una function que tenia hecha en Blitz a GLBasic. Solo llevo como una o dos semanas solo con el GLBasic!!

Si, ya comprobe que esos comandos que me dijiste funcionan bien y podria usarlos en esa funcion.

Pero tambien veo que funciona bien para mi proposito tal como la hize.

La funcion zoom hace lo siguiente:

Haze zoom sobre una zona seleccionada con el raton y escanea los pinxels de esa zona.
Crea una rejilla o grid a la que que se pueden da las coordenadad x,y donde comienza a dibujar los pinxels escaneados,  la cantidad de pinxels que agrandara, el tamaño de cada pinxel agrandado, el tamaño de la rejilla y el borde exterior de la rejilla.  Y da los datos de x, y de los pinxels que escanea, la posicion x. y del "cursor" en la rejila y los colores.

Ademas, picando con el raton se selecciona el pinxel agrandado y tambien se selecciona con las flechas del cursor.
Y devuelve el color del pinxel que se ve" flasheando" igual que el rectangulo agrandado.


Si quires te bajas el archivo con un ejemplo y lo ves  :)

mentalthink

Como dice rudiesco se puede hacer una lupa de ese modo... yo cuando he necesitado ampliar algo, uso el Zoomsprite, o si lo tienes que rotar con Rotozoomsprite, aunque consume bastante "chicha"...

chve, sobre el tema de las variables, si me permites un consejo, yo siempre hago cosas de este modo, por ejemplo, si cargo un sprite, le digo algo asi.

spr_my_Sprite= el número que sea.

si es 3D
objX_nombre_Objecto = el ID que sea o el número.

para variables digamos globales locales, etc,
lo que hago es siempre
el nombre ,seguido de un guíon, más la parte final de la variable con la primera letra en mayúsculas... por ejemplo

count_Timer o algo asi....

Si no te quieres liar mucho con el código, usa locales y estaticas, y asi en cada función tienes lo que le corresponde a la misma.

chve

@mentalthink
Pues a mi function aun asi, le pienso añadir mas cositas para un proyecto que estoy haciendo de adivinar con las cartas del tarot.

Y lo que dices de escribir asi las variables, me parece buena idea y lo pienso hacer, pues "a mi manera" me lio mas que la sandalia de un romano.  :D
Me ire acostrumbrando a nombrarlas asi como me dijiste y sera mejor.

Asi que gracias por el consejo.  :)