path: root/src/jogl/classes/com/jogamp/graph/curve/Region.java

/**
 * Copyright 2010 JogAmp Community. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification, are
 * permitted provided that the following conditions are met:
 *
 *    1. Redistributions of source code must retain the above copyright notice, this list of
 *       conditions and the following disclaimer.
 *
 *    2. Redistributions in binary form must reproduce the above copyright notice, this list
 *       of conditions and the following disclaimer in the documentation and/or other materials
 *       provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * The views and conclusions contained in the software and documentation are those of the
 * authors and should not be interpreted as representing official policies, either expressed
 * or implied, of JogAmp Community.
 */
package com.jogamp.graph.curve;

import java.util.ArrayList;
import java.util.List;

import jogamp.graph.geom.plane.AffineTransform;
import jogamp.opengl.Debug;

import com.jogamp.graph.geom.Triangle;
import com.jogamp.graph.geom.Vertex;
import com.jogamp.opengl.math.geom.AABBox;
import com.jogamp.opengl.math.geom.Frustum;

/**
 * Abstract Outline shape representation define the method an OutlineShape(s)
 * is bound and rendered.
 *
 * @see com.jogamp.graph.curve.opengl.GLRegion
 */
public abstract class Region {

    /** Debug flag for region impl (graph.curve) */
    public static final boolean DEBUG = Debug.debug("graph.curve");
    public static final boolean DEBUG_INSTANCE = Debug.debug("graph.curve.instance");

    /**
     * Rendering-Mode bit for {@link Region#getRenderModes() Region} and {@link com.jogamp.graph.curve.opengl.RegionRenderer#getRenderModes() RegionRenderer}.
     * <p>
     * MSAA based Anti-Aliasing, a two pass region rendering, slower and more
     * resource hungry (FBO), but providing fast MSAA in case
     * the whole scene is not rendered with MSAA.
     * </p>
     */
    public static final int MSAA_RENDERING_BIT        = 1 <<  0;

    /**
     * Rendering-Mode bit for {@link Region#getRenderModes() Region} and {@link com.jogamp.graph.curve.opengl.RegionRenderer#getRenderModes() RegionRenderer}.
     * <p>
     * View based Anti-Aliasing, a two pass region rendering, slower and more
     * resource hungry (FBO), but AA is perfect. Otherwise the default fast one
     * pass MSAA region rendering is being used.
     * </p>
     */
    public static final int VBAA_RENDERING_BIT        = 1 <<  1;

    /**
     * Rendering-Mode bit for {@link Region#getRenderModes() Region} and {@link com.jogamp.graph.curve.opengl.RegionRenderer#getRenderModes() RegionRenderer}.
     * <p>
     * Use non uniform weights [0.0 .. 1.9] for curve region rendering.
     * Otherwise the default weight 1.0 for uniform curve region rendering is
     * being applied.
     * </p>
     */
    public static final int VARIABLE_CURVE_WEIGHT_BIT  = 1 <<  8;

    public static final int TWO_PASS_DEFAULT_TEXTURE_UNIT = 0;

    private final int renderModes;
    private boolean dirty = true;
    private int numVertices = 0;
    protected final AABBox box = new AABBox();
    protected Frustum frustum = null;

    public static boolean isVBAA(int renderModes) {
        return 0 != (renderModes & Region.VBAA_RENDERING_BIT);
    }
    public static boolean isMSAA(int renderModes) {
        return 0 != (renderModes & Region.MSAA_RENDERING_BIT);
    }

    /**
     * Check if render mode capable of non uniform weights
     *
     * @param renderModes
     *            bit-field of modes, e.g.
     *            {@link Region#VARIABLE_CURVE_WEIGHT_BIT},
     *            {@link Region#VBAA_RENDERING_BIT}
     * @return true of capable of non uniform weights */
    public static boolean isNonUniformWeight(int renderModes) {
        return 0 != (renderModes & Region.VARIABLE_CURVE_WEIGHT_BIT);
    }

    public static String getRenderModeString(int renderModes) {
        final String curveS = isNonUniformWeight(renderModes) ? "-curve" : "";
        if( Region.isVBAA(renderModes) ) {
            return "vbaa"+curveS;
        } else if( Region.isMSAA(renderModes) ) {
            return "msaa"+curveS;
        } else {
            return "norm"+curveS;
        }
    }

    protected Region(int regionRenderModes) {
        this.renderModes = regionRenderModes;
    }

    // FIXME: Better handling of impl. buffer growth .. !

    protected abstract void pushVertex(float[] coords, float[] texParams);
    protected abstract void pushIndex(int idx);

    /**
     * Return bit-field of render modes, see {@link #create(int)}.
     */
    public final int getRenderModes() {
        return renderModes;
    }

    protected void clearImpl() {
        dirty = true;
        numVertices = 0;
        box.reset();
    }

    /**
     * Return  true if capable of two pass rendering - VBAA, otherwise false.
     */
    public final boolean isVBAA() {
        return isVBAA(renderModes);
    }

    /**
     * Return  true if capable of two pass rendering - MSAA, otherwise false.
     */
    public final boolean isMSAA() {
        return isMSAA(renderModes);
    }

    /**
     * Return true if capable of nonuniform weights, otherwise false.
     */
    public final boolean isNonUniformWeight() {
        return Region.isNonUniformWeight(renderModes);
    }

    /** See {@link #setFrustum(Frustum)} */
    public final Frustum getFrustum() { return frustum; }

    /**
     * Set {@link Frustum} culling for {@link #addOutlineShape(OutlineShape, AffineTransform)}.
     */
    public final void setFrustum(Frustum frustum) {
        this.frustum = frustum;
    }

    final float[] coordsEx = new float[3];

    private void pushNewVertexImpl(final Vertex vertIn, final AffineTransform transform) {
        if( null != transform ) {
            final float[] coordsIn = vertIn.getCoord();
            transform.transform(coordsIn, coordsEx);
            coordsEx[2] = coordsIn[2];
            box.resize(coordsEx[0], coordsEx[1], coordsEx[2]);
            pushVertex(coordsEx, vertIn.getTexCoord());
        } else {
            box.resize(vertIn.getX(), vertIn.getY(), vertIn.getZ());
            pushVertex(vertIn.getCoord(), vertIn.getTexCoord());
        }
        numVertices++;
    }

    private void pushNewVertexIdxImpl(final Vertex vertIn, final AffineTransform transform) {
        pushIndex(numVertices);
        pushNewVertexImpl(vertIn, transform);
    }

    private final AABBox tmpBox = new AABBox();

    /**
     * Add the given {@link OutlineShape} to this region with the given optional {@link AffineTransform}.
     * <p>
     * In case {@link #setFrustum(Frustum) frustum culling is set}, the {@link OutlineShape}
     * is dropped if it's {@link OutlineShape#getBounds() bounding-box} is fully outside of the frustum.
     * The optional {@link AffineTransform} is applied to the bounding-box beforehand.
     * </p>
     */
    public final void addOutlineShape(final OutlineShape shape, final AffineTransform transform) {
        if( null != frustum ) {
            final AABBox shapeBox = shape.getBounds();
            final AABBox shapeBoxT;
            if( null != transform ) {
                transform.transform(shapeBox, tmpBox);
                shapeBoxT = tmpBox;
            } else {
                shapeBoxT = shapeBox;
            }
            if( frustum.isAABBoxOutside(shapeBoxT) ) {
                if(DEBUG_INSTANCE) {
                    System.err.println("Region.addOutlineShape(): Dropping outside shapeBoxT: "+shapeBoxT);
                }
                return;
            }
        }
        final List<Triangle> trisIn = shape.getTriangles(OutlineShape.VerticesState.QUADRATIC_NURBS);
        final ArrayList<Vertex> vertsIn = shape.getVertices();
        if(DEBUG_INSTANCE) {
            System.err.println("Region.addOutlineShape().0: tris: "+trisIn.size()+", verts "+vertsIn.size()+", transform "+transform);
        }
        final int idxOffset = numVertices;
        int vertsVNewIdxCount = 0, vertsTMovIdxCount = 0, vertsTNewIdxCount = 0, tris = 0;
        int vertsDupCountV = 0, vertsDupCountT = 0, vertsKnownMovedT = 0;
        if( vertsIn.size() >= 3 ) {
            if(DEBUG_INSTANCE) {
                System.err.println("Region.addOutlineShape(): Processing Vertices");
            }
            for(int i=0; i<vertsIn.size(); i++) {
                pushNewVertexImpl(vertsIn.get(i), transform);
                vertsVNewIdxCount++;
            }
            if(DEBUG_INSTANCE) {
                System.err.println("Region.addOutlineShape(): Processing Triangles");
            }
            for(int i=0; i<trisIn.size(); i++) {
                final Triangle triIn = trisIn.get(i);
                if(Region.DEBUG_INSTANCE) {
                    System.err.println("T["+i+"]: "+triIn);
                }
                // triEx.addVertexIndicesOffset(idxOffset);
                // triangles.add( triEx );
                final Vertex[] triInVertices = triIn.getVertices();
                final int tv0Idx = triInVertices[0].getId();
                if( Integer.MAX_VALUE-idxOffset > tv0Idx ) { // Integer.MAX_VALUE != i0 // FIXME: renderer uses SHORT!
                    // valid 'known' idx - move by offset
                    if(Region.DEBUG_INSTANCE) {
                        System.err.println("T["+i+"]: Moved "+tv0Idx+" + "+idxOffset+" -> "+(tv0Idx+idxOffset));
                    }
                    pushIndex(tv0Idx+idxOffset);
                    pushIndex(triInVertices[1].getId()+idxOffset);
                    pushIndex(triInVertices[2].getId()+idxOffset);
                    vertsTMovIdxCount+=3;
                } else {
                    // invalid idx - generate new one
                    if(Region.DEBUG_INSTANCE) {
                        System.err.println("T["+i+"]: New Idx "+numVertices);
                    }
                    pushNewVertexIdxImpl(triInVertices[0], transform);
                    pushNewVertexIdxImpl(triInVertices[1], transform);
                    pushNewVertexIdxImpl(triInVertices[2], transform);
                    vertsTNewIdxCount+=3;
                }
                tris++;
            }
        }
        if(DEBUG_INSTANCE) {
            System.err.println("Region.addOutlineShape().X: idxOffset "+idxOffset+", tris: "+tris+", verts [idx "+vertsTNewIdxCount+", add "+vertsTNewIdxCount+" = "+(vertsVNewIdxCount+vertsTNewIdxCount)+"]");
            System.err.println("Region.addOutlineShape().X: verts: idx[v-new "+vertsVNewIdxCount+", t-new "+vertsTNewIdxCount+" = "+(vertsVNewIdxCount+vertsTNewIdxCount)+"]");
            System.err.println("Region.addOutlineShape().X: verts: idx t-moved "+vertsTMovIdxCount+", numVertices "+numVertices);
            System.err.println("Region.addOutlineShape().X: verts: v-dups "+vertsDupCountV+", t-dups "+vertsDupCountT+", t-known "+vertsKnownMovedT);
            // int vertsDupCountV = 0, vertsDupCountT = 0;
            System.err.println("Region.addOutlineShape().X: box "+box);
        }
        setDirty(true);
    }

    public final void addOutlineShapes(final List<OutlineShape> shapes, final AffineTransform transform) {
        for (int i = 0; i < shapes.size(); i++) {
            addOutlineShape(shapes.get(i), transform);
        }
    }

    /** @return the AxisAligned bounding box of current region */
    public final AABBox getBounds() {
        return box;
    }

    /** Check if this region is dirty. A region is marked dirty when new
     * Vertices, Triangles, and or Lines are added after a call to update()
     *
     * @return true if region is Dirty, false otherwise
     *
     * @see update(GL2ES2) */
    public final boolean isDirty() {
        return dirty;
    }

    protected final void setDirty(boolean v) {
        dirty = v;
    }

    public String toString() {
        return "Region["+getRenderModeString(this.renderModes)+", dirty "+dirty+", vertices "+numVertices+", box "+box+"]";
    }
}