Distorted Android

///////////////////////////////////////////////////////////////////////////////////////////////////

// Copyright 2016 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Distorted.                                                               //

//                                                                                               //

// Distorted is free software: you can redistribute it and/or modify                             //

// it under the terms of the GNU General Public License as published by                          //

// the Free Software Foundation, either version 2 of the License, or                             //

// (at your option) any later version.                                                           //

//                                                                                               //

// Distorted is distributed in the hope that it will be useful,                                  //

// but WITHOUT ANY WARRANTY; without even the implied warranty of                                //

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                 //

// GNU General Public License for more details.                                                  //

//                                                                                               //

// You should have received a copy of the GNU General Public License                             //

// along with Distorted.  If not, see <http://www.gnu.org/licenses/>.                            //

///////////////////////////////////////////////////////////////////////////////////////////////////

package org.distorted.library;

import android.opengl.Matrix;

import java.util.ArrayList;

///////////////////////////////////////////////////////////////////////////////////////////////////

abstract class DistortedOutputSurface extends DistortedSurface

{

  private ArrayList<DistortedNode> mChildren;

  private int mNumChildren;   // ==mChildren.length(), but we only create mChildren if the first one gets added

  private float mX, mY, mFOV;

  int mWidth,mHeight,mDepth;

  float mDistance;

  float[] mProjectionMatrix;

///////////////////////////////////////////////////////////////////////////////////////////////////

  DistortedOutputSurface(int width, int height, int color)

    {

    super(width,height,color);

    mProjectionMatrix = new float[16];

    mWidth = width;

    mHeight= height;

    mFOV = 60.0f;

    mX   =  0.0f;

    mY   =  0.0f;

    createProjection();

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  void createProjection()

    {

    if( mWidth>0 && mHeight>1 )

      {

      if( mFOV>0.0f )  // perspective projection

        {

        float left   = (-mX-mWidth /2.0f)/mHeight;

        float right  = (-mX+mWidth /2.0f)/mHeight;

        float bottom = (-mY-mHeight/2.0f)/mHeight;

        float top    = (-mY+mHeight/2.0f)/mHeight;

        float near   = (top-bottom) / (2.0f*(float)Math.tan(mFOV*Math.PI/360));

        mDistance    = mHeight*near/(top-bottom);

        float far    = 2*mDistance-near;

        mDepth       = (int)((far-near)/2);

        Matrix.frustumM(mProjectionMatrix, 0, left, right, bottom, top, near, far);

        }

      else             // parallel projection

        {

        float left   = -mX-mWidth /2.0f;

        float right  = -mX+mWidth /2.0f;

        float bottom = -mY-mHeight/2.0f;

        float top    = -mY+mHeight/2.0f;

        float near   = (mWidth+mHeight)/2;

        mDistance    = 2*near;

        float far    = 3*near;

        mDepth       = (int)near;

        Matrix.orthoM(mProjectionMatrix, 0, left, right, bottom, top, near, far);

        }

      }

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

// PUBLIC API

///////////////////////////////////////////////////////////////////////////////////////////////////

/**

 * Draw the (texture,mesh,effects) object to the Framebuffer.

 * <p>

 * Must be called from a thread holding OpenGL Context.

 *

 * @param surface InputSurface to skin our Mesh with.

 * @param mesh Class descendant from MeshObject

 * @param effects The DistortedEffects to use when rendering

 * @param time Current time, in milliseconds.

 */

  public void renderTo(DistortedInputSurface surface, MeshObject mesh, DistortedEffects effects, long time)

    {

    surface.create();  // Watch out  - this needs to be before

    create();          // the 'setAsInput' because this has side-effects!

    if( surface.setAsInput() )

      {

      DistortedSurface.deleteAllMarked();

      effects.drawPriv(surface.getWidth()/2.0f, surface.getHeight()/2.0f, mesh, this, time);

      }

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

/**

 * Draws the Tree, and all its children, to the Framebuffer.

 * <p>

 * Must be called from a thread holding OpenGL Context.

 *

 * @param dt DistortedNode to render.

 * @param time Current time, in milliseconds. This will be passed to all the Effects stored in the Tree.

 */

  public void renderTo(DistortedNode dt, long time)

    {

    DistortedSurface.deleteAllMarked();

    create();

    dt.drawRecursive(time,this);

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

/**

 * Bind this Surface as a Framebuffer we can render to.

 */

  public abstract void setAsOutput();

///////////////////////////////////////////////////////////////////////////////////////////////////

/**

 * Create new Projection matrix.

 *

 * @param fov Vertical 'field of view' of the Projection frustrum (in degrees).

 * @param x X-coordinate of the point at which our camera looks at. 0 is the center.

 * @param y Y-coordinate of the point at which our camera looks at. 0 is the center.

 */

  public void setProjection(float fov, float x, float y)

    {

    mFOV = fov;

    mX = x;

    mY = y;

    createProjection();

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

/**

 * Resize the underlying Framebuffer.

 *

 * @param width The new width.

 * @param height The new height.

 */

  public void resize(int width, int height)

    {

    if( mWidth!=width || mHeight!=height )

      {

      mWidth = width;

      mHeight= height;

      createProjection();

      mSizeX = width;

      mSizeY = height;

      if( mColorH[0]>0 ) markForDeletion();

      }

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

/**

 * Adds a new child to the last position in the list of our Surface's children.

 *

 * @param node The new Node to add.

 */

  public synchronized void attach(DistortedNode node)

    {

    if( mChildren==null ) mChildren = new ArrayList<>(2);

    mChildren.add(node);

    mNumChildren++;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

/**

 * Adds a new child to the last position in the list of our Surface's children.

 *

 * @param surface InputSurface to initialize our child Node with.

 * @param effects DistortedEffects to initialize our child Node with.

 * @param mesh MeshObject to initialize our child Node with.

 * @return the newly constructed child Node, or null if we couldn't allocate resources.

 */

  public synchronized DistortedNode attach(DistortedInputSurface surface, DistortedEffects effects, MeshObject mesh)

    {

    if( mChildren==null ) mChildren = new ArrayList<>(2);

    DistortedNode node = new DistortedNode(surface,effects,mesh);

    mChildren.add(node);

    mNumChildren++;

    return node;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

/**

 * Removes the first occurrence of a specified child from the list of children of our Surface.

 *

 * @param node The Node to remove.

 * @return <code>true</code> if the child was successfully removed.

 */

  public synchronized boolean detach(DistortedNode node)

    {

    if( mChildren.remove(node) )

      {

      mNumChildren--;

      return true;

      }

    return false;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

/**

 * Removes all children Nodes.

 */

  public synchronized void detachAll()

    {

    mNumChildren = 0;

    mChildren.clear();

    }

}