• Miércoles 20 de Noviembre de 2024, 18:46

Autor Tema:  Se Me Ocurrio Una "ocurrencia"  (Leído 1759 veces)

ibito

  • Miembro HIPER activo
  • ****
  • Mensajes: 549
  • Nacionalidad: mx
  • Se mas de C++ que lo que se de ese CSS
    • Ver Perfil
    • http://www.ibquezada.com
Se Me Ocurrio Una "ocurrencia"
« en: Martes 20 de Septiembre de 2005, 23:36 »
0
Pues no soy un guru en esto de programar videojuegos, y siempre que hago un "engine" de tiles, redibujo todo en pantalla, entonces, se me ocurrio algo para "mejorar" el performance, talvez asi se haga ya profesionalmente o los que saben mas no se, solo quiero ver si le ven ventajas a esto:

En vez de re-dibujar todo, solo se redibujan los 8 tiles (o 9 incluyendo el del sprite) alrededor del sprite que se mueve, si son varios pues solo los tiles de los sprites que se mueven... en caso de que algun tile sea animado pues el tile animado tambien, dejando intactos los demas tiles... no se si me di a entender... no sean muy duros con sus criticas  :ph34r:




 :P
______________________________________
www.hazjuegos.com Una comunidad dedicada al desarrollo de videojuegos.

JuanK

  • Miembro de ORO
  • ******
  • Mensajes: 5393
  • Nacionalidad: co
    • Ver Perfil
    • http://juank.io
Re: Se Me Ocurrio Una "ocurrencia"
« Respuesta #1 en: Martes 20 de Septiembre de 2005, 23:55 »
0
Sim el escroll se mueve habria que redibujar todos los tiles de todas formas,
sino es asi tu tecnica es muy buebna y se llama dirty reactangles, esta aument nmucho el performance cuan do son pocas cosas animadas, pero si son muchas, por el contrario lo disminuye en exceso.
[size=109]Juan Carlos Ruiz Pacheco
[/size]
Microsoft Technical Evangelist
@JuanKRuiz
http://juank.io

Neko-sama

  • Miembro activo
  • **
  • Mensajes: 99
    • Ver Perfil
Re: Se Me Ocurrio Una "ocurrencia"
« Respuesta #2 en: Miércoles 21 de Septiembre de 2005, 06:37 »
0
es una tecnica que se usa de forma profecional pero solo se usa para casos especificos...


mira... cuando haces un mapa de tiles es porque quieres hacer una escena bien grande y necesitas moverte en ella ... para eso tienes que mostrar que lo tiles se muevan... y para eso tienes que volver a dibujarlos todos...




lo que uso yo para mejorar el rendimiento...  es que solo pinto los tiles que se ven en pantalla...    no toooodos los tiles...  y no tengo ningun problema de rendimiento... incluyendo mis tiles animados...

y eso que he usado dos capas de tiles... claro... que una no se pinta completa para poder dejar ver la capa de atras... por ejemplo... en una caverna... tienes los tiles del marco principal por donde anda tu personaje y atras dejas ver los tiles del fondo de la caberna... eso lo puedes convinar con otra capa (una tercera) que muestre una imagen estatica de algo muy al fondo... de esa forma no tienes que dibujar tooodos los tiles que esten en pantalla... solo los pocos que uses para decorar cada capa...

si haces un juego tipo zelda... es una sola capa de tiles que necesitas y no debe ser mucho la exigencia de un computador la usar eso...

Amilius

  • Miembro HIPER activo
  • ****
  • Mensajes: 665
    • Ver Perfil
Re: Se Me Ocurrio Una "ocurrencia"
« Respuesta #3 en: Sábado 8 de Octubre de 2005, 14:29 »
0
Cita de: "ibito"
Pues no soy un guru en esto de programar videojuegos, y siempre que hago un "engine" de tiles, redibujo todo en pantalla, entonces, se me ocurrio algo para "mejorar" el performance, talvez asi se haga ya profesionalmente o los que saben mas no se, solo quiero ver si le ven ventajas a esto:

En vez de re-dibujar todo, solo se redibujan los 8 tiles (o 9 incluyendo el del sprite) alrededor del sprite que se mueve, si son varios pues solo los tiles de los sprites que se mueven... en caso de que algun tile sea animado pues el tile animado tambien, dejando intactos los demas tiles... no se si me di a entender... no sean muy duros con sus criticas  :ph34r:




 :P
La idea es buena, sería mejor que lo generalices a rectángulos en lugar de grupos de tiles. Si tu algoritmo principal puede dibujar la escena de tu juego limitándose al área de un rectángulo entonces podrías optimizar bastante al evitar transferencias de memoria innecesarias. En el juego de rol que hice, aunque se mueve con scroll, esta es una parte esencial tanto para evitar dibujar en vano en zonas que están tapadas por ejemplo por un menú opaco y además que garantiza control de límites: en los algoritmos que realizan transferencia de memoria ya no tengo que preocuparme si el elemento que estoy dibujando está saliendo de la zona donde puedo dibujar. Si la zona rectangular que voy a dibujar se "sale" de la zona de la pantalla (en general la zona que hay que redibujar), un algoritmo lo recorta y actualiza su posición y dimensiones:

Este código también sirve si aplicarás efecto de reflejo vertical a tus imágenes:
Código: Text
  1.  
  2. function EstaEnPantalla(var rDestino,rOrigen:Trect;const espejo:bytebool):bytebool;
  3. //  Determina si la imagen que debe ser dibujada aparece en pantalla y modifica
  4. //los rectángulos origen y destino si estos exceden las dimensiones adecuadas.
  5. begin
  6. with rDestino do
  7.  if (left<Limites_Lienzo.right) and (right>=Limites_Lienzo.left) and
  8.    (top<Limites_Lienzo.bottom) and (bottom>=Limites_Lienzo.top) then
  9.  begin
  10.    result:=true;
  11.    //Reducir el tamaño del cuadro si sale de pantalla
  12.    if espejo then
  13.    begin//caso del espejo
  14.      if right>Limites_Lienzo.right then
  15.      begin
  16.        right:=Limites_Lienzo.right;
  17.        rOrigen.Left:=rOrigen.Right-right+left;
  18.      end;
  19.      if left<Limites_Lienzo.left then
  20.      begin
  21.        left:=Limites_Lienzo.left;
  22.        rOrigen.right:=rOrigen.left+right-left;
  23.      end;
  24.    end
  25.    else
  26.    begin// caso normal
  27.      if right>Limites_Lienzo.right then
  28.      begin
  29.        right:=Limites_Lienzo.right;
  30.        rOrigen.Right:=rOrigen.Left+right-left;
  31.      end;
  32.      if left<Limites_Lienzo.left then
  33.      begin
  34.        left:=Limites_Lienzo.left;
  35.        rOrigen.Left:=rOrigen.Right-right+left;
  36.      end;
  37.    end;
  38.    if bottom>Limites_Lienzo.bottom then
  39.    begin
  40.      bottom:=Limites_Lienzo.bottom;
  41.      rOrigen.Bottom:=rOrigen.top+bottom-top;
  42.    end;
  43.    if top<Limites_Lienzo.top then
  44.    begin
  45.      top:=Limites_Lienzo.top;
  46.      rOrigen.top:=rOrigen.Bottom-bottom+top;
  47.    end;
  48.  end
  49.  else
  50.    result:=false;
  51. end;
  52.  
  53.