FrameWork (Motor) ANDEngine GLES2

Inicio Foros Desarrolladores de apps/juegos Desarrolladores de apps/juegos FrameWork (Motor) ANDEngine GLES2

  • Este debate tiene 3 respuestas, 1 mensaje y ha sido actualizado por última vez el hace 7 años, 8 meses por Anónimo.
Viendo 4 entradas - de la 1 a la 4 (de un total de 4)
  • Autor
    Entradas
  • #17110
    Anónimo
    Inactivo

    Hola:

    En este hilo iré añadiendo cosas interesantes sobre la versión GLES2 de ANDEngine para Android.

    He estado dos semanas probando y no esta nada mal.

    Si os queréis apuntar a colaborar a poner info sobre el, bienvenido sois.

    Este FrameWork sera con el que trabajemos en AxouxereGames durante los próximos juegos y ademas portaremos nuestros primeros juegos a ANDEngine. De esta forma podremos valorar que mejora hay al trabajar con ANDEngine.

    Mejoras Iniciales:
    – Gráficos en OpenGL.
    – Desarrollo para una sola resolución (luego el te adapta de forma correcta a las distintas resoluciones).
    – Menor tamaño de los juegos al no depender de distintos tamaños de gráficos.
    – Mejor control del Táctil.
    – Una buena comunidad y ejemplos.
    – Es un proyecto que aun sigue vivo, con lo cual recibirá mejoras.

    Pronto os añadiré mas y os ayudare en vuestras dudas.

    Actualizado… Veo que no tengo nada de tiempo aun asi lo usare a modo diario de problemas que me voy encontrando y como las resuelvo…

    = Dia 05-11-2012 =

    – Sprites en Negro:
    Testeando una juego nuestro que hemos portado al motor ANDEngine, probandolo en un Galaxy S 1 nos dio un fallo curioso. Un recuadro Negro en lugar del gráfico. Esto no sucedía en móviles inferiores como el Galaxy Mini ni en otros superiores como el s2 u otros…

    Para Animaciones el ANDEngine usa Tiles que son muy cómodos para luego animar, pero el S1 debe tener una memoria muy limitada gráficamente en cuestión de tamaños de tiles para su pantalla, y intentando poner una explosión de gran tamaño teníamos este problema.

    Solución… no sobrepasar los 2000px de ancho en el Tile. Reducimos la calidad de la explosión en cuestión de tamaño y luego por open Gl le aplicamos un Scale al tamaño deseado.

    Resultado: Muy bueno, el scalado del Open GL con filtro bilinear hace que el acabado sea mas que decente. Ademas de que la aplicación al usar gráficos de fuente mas pequeños, ocupa mucho menos.

    Espero que esto ayude a alguien. 🙂 Ire añadiendo mas.

    #17139
    Anónimo
    Invitado

    Perfecto, será interesante lo que aqui comentes.

    #17534
    Anónimo
    Inactivo

    Por falta de tiempo iré publicando soluciones a problemas que vamos encontrando… 🙂

    #18558
    Anónimo
    Inactivo

    Acabamos de lanzar una nueva app con este motor y hemos aprendido muchísimo.

    Una de las cosas a tener en cuenta al usar cualquier motor que use OpenGL o directamente OpenGl es que las texturas tienen que estar en potencia de 2 y la posición de estas para su mejor calidad en posiciones enteras.

    La segunda es una clase que hizo uno chico que se apoya en el sistema de reescalamiento del AndEngine pero quitando las bandas negras tan molestas que se formaban cuando el tamaño de la pantalla no era proporcionalmente igual.

    También algo que nos trajo algún problema ha sido el diseñar para diversas versiones de Android, ya que las versiones 4.x tienen botones no físicos en dispositivos modernos que hacen que el tamaño de la pantalla sea menor, y esto hace mas difícil la colocación de objetos en pantalla que se quieran visibles, ya que en versiones anteriores a la 4.x o bien móviles con botones físicos no existe estos botones táctiles.

    Aquí os dejo la clase de reescalamiento sin bordes.

    import org.andengine.engine.options.resolutionpolicy.BaseResolutionPolicy;
    import org.andengine.opengl.view.RenderSurfaceView;

    import android.view.View.MeasureSpec;

    public class CroppedResolutionPolicy extends BaseResolutionPolicy
    {
    // ===========================================================
    // Fields
    // ===========================================================

    private final float mCameraWidth;
    private final float mCameraHeight;
    private float mMarginVertical; // Pixels from top of canvas to visible area, and from bottom of canvas to visible area
    private float mMarginHorizontal; // Pixels from left of canvas to visible area, and from right of canvas to visible area
    public int measuredWidth, measuredHeight;
    float nCanvasRatio;
    float nCamRatio;

    // ===========================================================
    // Constructors
    // ===========================================================

    public CroppedResolutionPolicy(final float nCameraWidth, final float nCameraHeight)
    {
    this.mCameraWidth = nCameraWidth;
    this.mCameraHeight = nCameraHeight;

    this.mMarginVertical = 0;
    this.mMarginHorizontal = 0;
    }

    // ===========================================================
    // Getter & Setter
    // ===========================================================
    public float getMarginVertical()
    {
    return this.mMarginVertical;
    }

    public float getMarginHorizontal()
    {
    return this.mMarginHorizontal;
    }

    @Override
    public void onMeasure(RenderSurfaceView pRenderSurfaceView, int pWidthMeasureSpec, int pHeightMeasureSpec)
    {
    BaseResolutionPolicy.throwOnNotMeasureSpecEXACTLY(pWidthMeasureSpec, pHeightMeasureSpec);

    measuredWidth = MeasureSpec.getSize(pWidthMeasureSpec);
    measuredHeight = MeasureSpec.getSize(pHeightMeasureSpec);

    nCamRatio = (float)mCameraWidth / (float)mCameraHeight;
    nCanvasRatio = (float)measuredWidth / (float)measuredHeight;

    if( (float)measuredWidth / (float)measuredHeight < nCamRatio )
    {
    // Scale to fit height, width will crop
    measuredWidth = (int) ( measuredHeight * nCamRatio);
    this.mMarginHorizontal = ( this.mCameraWidth – ( (float) this.mCameraHeight * nCanvasRatio ) ) / 2.0f;
    }
    else
    {
    // Scale to fit width, height will crop
    measuredHeight = (int) ( measuredWidth / nCamRatio );
    float Resultado=(float) this.mCameraWidth / nCanvasRatio;
    this.mMarginVertical = ( this.mCameraHeight – Resultado) / 2.0f;
    }

    pRenderSurfaceView.setMeasuredDimensionProxy(measuredWidth, measuredHeight);
    }
    }

    y aquí la manera de usarla.
    CroppedResolutionPolicy canvasSurface = new CroppedResolutionPolicy(480, 800);

    final EngineOptions engineOptions = new EngineOptions(true, ScreenOrientation.PORTRAIT_FIXED, canvasSurface, this.mCamera);

Viendo 4 entradas - de la 1 a la 4 (de un total de 4)
  • Debes estar registrado para responder a este debate.

A quienes visitais Todoandroid.es os ofrecemos un cupón descuento para la tienda AliExpress. Por compras superiores a 5$, tendrás 4$ de descuento. No es demasiado, pero algo ayuda ;D

Si e has decidido a comprar un nuevo teléfono móvil Android, smartwatch, pulsera de actividad, TV BOX, u otros productos.

Más Menos
Finaliza el:01-10-2020