Rendering task updates #11

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open

seuribe wants to merge 53 commits into master from rendering_task_updates

src/main/java/de/mfo/jsurf/rendering/cpu/AntiAliasedPixelRenderer.java

-Original file line number
+Diff line change
@@ -0,0 +1,82 @@
+    package de.mfo.jsurf.rendering.cpu;
+    import javax.vecmath.Color3f;
+    import de.mfo.jsurf.rendering.RenderingInterruptedException;
+    class AntiAliasedPixelRenderer extends PixelRenderStrategy {
+    	private final Color3f[] internalColorBuffer;
+    	private final float thresholdSqr;
+    	private final AntiAliasingPattern aap;
+    	private final ColumnSubstitutorPairProvider cspProvider;
+    	public AntiAliasedPixelRenderer(DrawcallStaticData dcsd, Color3f[] internalColorBuffer, PolynomialTracer polyTracer, ColumnSubstitutorPairProvider cspProvider) {
+    		super(dcsd, polyTracer);
+    		this.internalColorBuffer = internalColorBuffer;
+    		this.thresholdSqr = dcsd.antiAliasingThreshold * dcsd.antiAliasingThreshold;
+    		this.aap = dcsd.antiAliasingPattern;
+    		this.cspProvider = cspProvider;
+    	}
+    	@Override
+    	public void renderPixel(int x, int y, PixelStep step, ColumnSubstitutorPair csp) {
+    		internalColorBuffer[ step.internalBufferIndex ] = tracePolynomial( csp.scs, csp.gcs, step.u, step.v );
+    		if( x == 0 || y == 0 )
+    			return;
+    	    Color3f urColor = internalColorBuffer[ step.internalBufferIndex ];
+    	    Color3f ulColor = internalColorBuffer[ step.internalBufferIndex - 1 ];
+    	    Color3f lrColor = internalColorBuffer[ step.internalBufferIndex - step.width ];
+    	    Color3f llColor = internalColorBuffer[ step.internalBufferIndex - step.width - 1 ];
+            boolean doSuperSampling =
+            	aap != AntiAliasingPattern.OG_2x2 &&
+            	(thresholdSqr == 0 ||
+    			 areTooDifferent( ulColor, urColor ) ||
+        		 areTooDifferent( ulColor, llColor ) ||
+        		 areTooDifferent( ulColor, lrColor ) ||
+        		 areTooDifferent( urColor, llColor ) ||
+        		 areTooDifferent( urColor, lrColor ) ||
+        		 areTooDifferent( llColor, lrColor ));
+            // first average pixel-corner colors. Weight depends on whether more samples will be taken
+            Color3f accumulator = new Color3f( ulColor );
+            accumulator.add( urColor );
+            accumulator.add( llColor );
+            accumulator.add( lrColor );
+            accumulator.scale( doSuperSampling ? aap.cornerWeight : 0.25f);
+            if (doSuperSampling)
+            	sampleExceptCorners(step, accumulator);
+            accumulator.clamp( 0f, 1f );
+    	    colorBuffer[ step.colorBufferIndex ] = accumulator.get().getRGB();
+    	}
+        private void sampleExceptCorners( PixelStep step, Color3f accumulator )
+        {
+            for( AntiAliasingPattern.SamplingPoint sp : aap )
+            {
+                if( Thread.currentThread().isInterrupted() )
+                    throw new RenderingInterruptedException();
+                // corners already accumulated above
+                if (sp.isCorner)
+                	continue;
+                double v = step.vOld + sp.v * step.v_incr;
+                double u = step.uOld + sp.u * step.u_incr;
+                ColumnSubstitutorPair csp = cspProvider.get( v );
+                Color3f sample = tracePolynomial( csp.scs, csp.gcs, u, v );
+                accumulator.scaleAdd( sp.weight, sample, accumulator );
+            }
+        }
+        private boolean areTooDifferent(Color3f c1, Color3f c2) {
+        	float x = c1.x - c2.x;
+        	float y = c1.y - c2.y;
+        	float z = c1.z - c2.z;
+        	return (x * x) + (y * y) + (z * z) >= thresholdSqr;
+        }
+    }

src/main/java/de/mfo/jsurf/rendering/cpu/AntiAliasingPattern.java

            
                      Original file line number
                      Diff line number
                      Diff line change
                  
    @@ -21,33 +21,36 @@
  
    public enum AntiAliasingPattern implements Iterable< AntiAliasingPattern.SamplingPoint >

    {

        OG_1x1( getOGSSPattern( 1 ) ),

        OG_2x2( getOGSSPattern( 2 ) ),

        OG_3x3( getOGSSPattern( 3 ) ),

        OG_4x4( getOGSSPattern( 4 ) ),

        OG_5x5( getOGSSPattern( 5 ) ),

        OG_6x6( getOGSSPattern( 6 ) ),

        OG_7x7( getOGSSPattern( 7 ) ),

        OG_8x8( getOGSSPattern( 8 ) ),

        RG_2x2( getRGSSPattern() ),

        QUINCUNX( getQuincunxPattern() );

        OG_1x1( getOGSSPattern( 1 ), 1 ),

        OG_2x2( getOGSSPattern( 2 ), 2 ),

        OG_3x3( getOGSSPattern( 3 ), 3 ),

        OG_4x4( getOGSSPattern( 4 ), 4 ),

        OG_5x5( getOGSSPattern( 5 ), 5 ),

        OG_6x6( getOGSSPattern( 6 ), 6 ),

        OG_7x7( getOGSSPattern( 7 ), 7 ),

        OG_8x8( getOGSSPattern( 8 ), 8 ),

        RG_2x2( getRGSSPattern(), 2 ),

        QUINCUNX( getQuincunxPattern(), 3 );

        private final SamplingPoint[] points;

        public final int vSteps;

        public final float cornerWeight;

        public static class SamplingPoint

        {

            private float u, v, weight;

            public final float u;

            public final float v;

            public final float weight;

            public final boolean isCorner;

            private SamplingPoint( float u, float v, float weight )

            {

                this.u = u;

                this.v = v;

                this.weight = weight;

                this.isCorner = (u == 0.0 || u == 1.0) && (v == 0.0 || v == 1.0);

            }

            public float getU() { return u;}

            public float getV() { return v; }

            public float getWeight() { return weight; }

        }

        private class SamplingPointIterator implements Iterator< SamplingPoint >

    @@ -86,7 +89,19 @@ public void remove()
  
            }

        }

        private AntiAliasingPattern( SamplingPoint[] points ) { this.points = points; }

        private AntiAliasingPattern( SamplingPoint[] points, int vSteps ) {

        	this.points = points;

        	this.cornerWeight = findFirstCorner().weight;

        	this.vSteps = vSteps;

    	}

        SamplingPoint findFirstCorner() {

        	for (SamplingPoint sp : points)

        		if (sp.isCorner)

        			return sp;

        	return points[0];

        }

        public Iterator< SamplingPoint > iterator() { return new SamplingPointIterator( this.points ); }

        private static SamplingPoint[] getOGSSPattern( int size )

src/main/java/de/mfo/jsurf/rendering/cpu/BasicPixelRenderer.java

-Original file line number
+Diff line change
@@ -0,0 +1,11 @@
+    package de.mfo.jsurf.rendering.cpu;
+    class BasicPixelRenderer extends PixelRenderStrategy {
+    	public BasicPixelRenderer(DrawcallStaticData dcsd, PolynomialTracer polyTracer) {
+    		super(dcsd, polyTracer);
+    	}
+    	@Override public void renderPixel(int x, int y, PixelStep step, ColumnSubstitutorPair csp) {
+    		colorBuffer[ step.colorBufferIndex ] = tracePolynomial(csp.scs, csp.gcs, step.u, step.v ).get().getRGB();
+    	}
+    }

src/main/java/de/mfo/jsurf/rendering/cpu/ColorBufferPool.java

-Original file line number
+Diff line change
@@ -0,0 +1,115 @@
+    package de.mfo.jsurf.rendering.cpu;
+    import java.util.ArrayList;
+    import java.util.List;
+    import javax.vecmath.Color3f;
+    /**
+     * The buffers returned from this class will not have the exact size requested, but the
+     * size of the minimum power of two higher (or equal) to it.<br/>
+     * For example, if asked for a buffer for 457 colors, it will return one of size 512.<br/>
+     * <br/>
+     * This will waste memory, but allows to reuse the buffers for different parts, and also
+     * when the rendering size changes. It also keeps them nicely aligned in memory, which
+     * could produce more speed improvements.
+     *
+     * @author Sebastian
+     *
+     */
+    public class ColorBufferPool {
+    	// Should be an array of lists, but Java does not allow arrays of generic types
+        private List<List<Color3f[]>> bufferPool;
+        private boolean dontPool = false;
+        // Usage statistics
+        private int createdBuffers = 0;
+        private int requestedBuffers = 0;
+        private int totalBufferSize = 0;
+        // the biggest buffer it can hold is of size 2^32 == 2^16 x 2^16, an area of 65536 x 65536
+        private static final int MAX_POWER_OF_TWO = 32;
+        public static ColorBufferPool createDummyPool() {
+        	ColorBufferPool pool = new ColorBufferPool();
+        	pool.dontPool = true;
+        	return pool;
+        }
+        public ColorBufferPool() {
+        	bufferPool = new ArrayList<List<Color3f[]>>(MAX_POWER_OF_TWO);
+        	for (int i = 0 ; i < MAX_POWER_OF_TWO ; i++) {
+        		bufferPool.add(new ArrayList<Color3f[]>());
+        	}
+        }
+        public Color3f[] getBuffer(int size) {
+        	size = powOf2Roundup(size);
+        	int index = highestOneBit(size);
+        	requestedBuffers++;
+        	List<Color3f[]> bucket = bufferPool.get(index);
+        	synchronized (bucket) {
+            	if (dontPool || bucket.isEmpty()) {
+                	createdBuffers++;
+                	totalBufferSize += size;
+            		return new Color3f[size];
+            	} else
+            		return bucket.remove(bucket.size() - 1);
+        	}
+        }
+        /** Index of the highest bit set in the binary representation of an integer */
+        public static int highestOneBit(int x) {
+        	int index = 0;
+        	if ((x & 0xFFFF0000) != 0) {
+        		index += 16;
+        		x >>= 16;
+        	}
+        	if ((x & 0xFF00) != 0) {
+        		index += 8;
+        		x >>= 8;
+        	}
+        	if ((x & 0xF0) != 0) {
+        		index += 4;
+        		x >>= 4;
+        	}
+        	if ((x & 0x0C) != 0) {
+        		index += 2;
+        		x >>= 2;
+        	}
+        	if ((x & 2) != 0)
+        		index++;
+        	return index;
+        }
+        // https://stackoverflow.com/questions/364985/algorithm-for-finding-the-smallest-power-of-two-thats-greater-or-equal-to-a-giv
+        /** Minimum power of two bigger or equal to value */
+        private int powOf2Roundup(int x) {
+    	    if (x < 0)
+    	        return 0;
+    	    --x;
+    	    x |= x >> 1;
+    	    x |= x >> 2;
+    	    x |= x >> 4;
+    	    x |= x >> 8;
+    	    x |= x >> 16;
+    	    return x+1;
+    	}
+    	public void releaseBuffer(Color3f[] buffer) {
+        	int size = buffer.length;
+        	int index = highestOneBit(size);
+        	List<Color3f[]> bucket = bufferPool.get(index);
+        	synchronized (bucket) {
+            	bucket.add(buffer);
+        	}
+        }
+    	public String getPoolStatistics() {
+    		return "Requests / created: " + requestedBuffers + "/" + createdBuffers + ". Total size: " + totalBufferSize;
+    	}
+    }

src/main/java/de/mfo/jsurf/rendering/cpu/ColumnSubstitutorPair.java

-Original file line number
+Diff line change
@@ -0,0 +1,16 @@
+    package de.mfo.jsurf.rendering.cpu;
+    import de.mfo.jsurf.algebra.ColumnSubstitutor;
+    import de.mfo.jsurf.algebra.ColumnSubstitutorForGradient;
+    class ColumnSubstitutorPair
+    {
+        public final ColumnSubstitutor scs;
+        public final ColumnSubstitutorForGradient gcs;
+        ColumnSubstitutorPair( ColumnSubstitutor scs, ColumnSubstitutorForGradient gcs )
+        {
+            this.scs = scs;
+            this.gcs = gcs;
+        }
+    }

src/main/java/de/mfo/jsurf/rendering/cpu/ColumnSubstitutorPairProvider.java

-Original file line number
+Diff line change
@@ -0,0 +1,30 @@
+    package de.mfo.jsurf.rendering.cpu;
+    import de.mfo.jsurf.algebra.RowSubstitutor;
+    import de.mfo.jsurf.algebra.RowSubstitutorForGradient;
+    class ColumnSubstitutorPairProvider {
+        private final RowSubstitutor surfaceRowSubstitutor;
+        private final RowSubstitutorForGradient gradientRowSubstitutor;
+        private final ColumnSubstitutorPair[] csps;
+        private final double vMult;
+        private final double vInc;
+    	public ColumnSubstitutorPairProvider(DrawcallStaticData dcsd, PixelStep step) {
+            this.surfaceRowSubstitutor = dcsd.surfaceRowSubstitutor;
+            this.gradientRowSubstitutor = dcsd.gradientRowSubstitutor;
+            this.vInc = -step.v_start;
+            this.vMult = (double)dcsd.antiAliasingPattern.vSteps / step.v_incr;
+            this.csps = new ColumnSubstitutorPair[(dcsd.antiAliasingPattern.vSteps + 1) * (step.height + 1)];
+    	}
+    	public ColumnSubstitutorPair get(double v) {
+    		int index = (int)((v + vInc) * vMult);
+    		if (csps[index] == null)
+    			csps[index] = new ColumnSubstitutorPair(surfaceRowSubstitutor.setV( v ), gradientRowSubstitutor.setV( v ));
+    		return csps[index];
+    	}
+    }

src/main/java/de/mfo/jsurf/rendering/cpu/DrawcallStaticData.java

-Original file line number
+Diff line change
@@ Expand Up / @@ -22,7 +22,7 @@ @@
     import javax.vecmath.*;
-    class DrawcallStaticData
+    public class DrawcallStaticData
     {
         int[] colorBuffer;
         int width;
@@ Expand Down @@

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Rendering task updates #11

Uh oh!

Diff view

Diff view

There are no files selected for viewing

Uh oh!

Rendering task updates #11

Are you sure you want to change the base?

Uh oh!

Rendering task updates #11

Uh oh!

Uh oh!

Diff view

Diff view

There are no files selected for viewing

Uh oh!