My answer is about this line in particular:
> ten , one // BUT? Without this line, blows up
> if openGL debug is enabled
I had problems using the OpenGL debug flag too, due to using buffers
(but my problems were because my buffers were not direct, so no harm
there).
Where is makeLines() called anyway? Or did I miss the call?
If you call makeLines() only once (i'm assuming this because I don't
know where you make the call) you may have to call
_lineVertices.position(0) before you use drawArrays() the second time.
On Aug 3, 8:09 am, Robert Green <rbgrn....@gmail.com> wrote:
> It would seem to me that you seek pixel perfect drawing but your code
> doesn't look pixel perfect at all, which is why you're having problems
> IMO.
>
> Problem stuff:
>
> ... in projection matrix ...
> _hgt2width = (float) MyApp._width / MyApp._height;
> gl.glOrthof(-_hgt2width, _hgt2width, -1, 1, 1, -1);
>
> gl.glScalef(1, _hgt2width, 1);
>
> float lscale = .002f*MyApp._curScale;
>
> It could be that I just don't understand what this is supposed to do
> but magic multipliers like .002 never look good to me when you're
> having issues with drawing precision.
>
> Here's what I'd do:
>
> gl.glMatrixMode(GL10.GL_PROJECTION);
> gl.glOrthof(0, MyApp._width, MyApp._height, 0, 1, -1);
> // now you can draw anywhere in your viewport pixel perfect
> orthographically.
> gl.glMatrixMode(GL10.GL_MODELVIEW);
> // ditch the fixed point (it's only faster on first-gen devices and
> only in certain cases)
> // now if you want a line 1px wide on the 10th line, draw a line with
> x on 9.5f
>
> Just be aware that you will need to figure out different relative
> positions to draw at given different resolution screens if you wish to
> remain pixel perfect. The other alternative is to stretch a fixed
> drawing area, like 320x480 to the other screen sizes. All you have to
> do to do that is set your orthof to those dimensions instead of the
> real screen dimensions - but you'll lose pixel-perfectness on anything
> that isn't that res.
>
> I didn't see you switching to your modelview anywhere in your code.
> If you're not doing that, you're going to want to use that matrix mode
> to draw. Projection should only be used to set the orthographic or
> perspective projection and no more.
>
> On Aug 2, 10:47 pm, SChaser <crotalistig...@gmail.com> wrote:> Source code is
> below.
>
> > Robert Green provides some helpful information, for which I am
> > thankful.
>
> > However, I am not clear on two of the points.
>
> > I currently have the situation where no lines at all show on the
> > emulator (the background color does) and things work perfectly on the
> > G1.
>
> > On Aug 2, 11:26 am, Robert Green <rbgrn....@gmail.com> wrote:
> > ....
>
> > > 1) You are in a native resolution to the screen you're rendering on
> > > (turn all the density and screen-size stuff on in the manifest to
> > > avoid compat mode)
>
> > Are these the attributes on the "support-screens" tag? I did not have
> > that tag, but adding it and turning on all the attributes in the check-
> > boxes did not solve the problem.
>
> > > 2) You draw the lines centered on their pixel, so they look a half
> > > pixel off.
> > > -- To draw a horizontal line across the top row of pixels, you need to
> > > make the line with 1.0f and have y be 0.5f (because it will draw from
> > > 0 to 1 that way)
>
> > I am drawing in fixed point projection(?) space, so the relationship
> > of the lines to pixels is not clear. Also, I don't want to have to
> > redraw the lines when the scale changes - I want to be able to zoom
> > and pan easily. Is there a way to achieve that and have the lines
> > show?
>
> > > 3) Make sure you don't have any z-fighting. Drawing 2 things on the
> > > exact same plane with depth-test turned on causes bad results on many
> > > opengl implementations.
>
> > Depth test turned off. I'm doing 2D only, so I think I'm clear there.
>
> > Again, thanks for the help.
>
> > ============ CODE SNIPS ==============
>
> > ----- Create glSurfaceView -------
> > private GLSurfaceView makeGLSurfaceView(GLSurfaceView.Renderer
> > renderer, Context context) {
> > GLSurfaceView view = new GLSurfaceView(context);
> > view.setDebugFlags(GLSurfaceView.DEBUG_CHECK_GL_ERROR |
> > GLSurfaceView.DEBUG_LOG_GL_CALLS);
> > view.setEGLConfigChooser(false);
> > if ( renderer != null ) {
> > view.setRenderer(renderer);
> > view.setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY);
> > }
> > view.getHolder().setFormat(PixelFormat.OPAQUE);
> > return view;
> > } // make gl surface view
>
> > ------------ onDrawFrame ----------
>
> > // Everything stuffed into onDrawFrame to make it easy to read on
> > forum
> > @Override
> > public void onDrawFrame(GL10 gl) {
> > gl.glClearColor(0,0,.2f, 1f);
> > gl.glDisable(GL10.GL_CULL_FACE);
> > gl.glShadeModel(GL10.GL_FLAT);
> > gl.glDisable(GL10.GL_DEPTH_TEST);
> > gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);
> > gl.glMatrixMode(GL10.GL_PROJECTION);
> > gl.glLoadIdentity();
> > gl.glViewport(0, 0, MyApp._width, MyApp._height);
> > gl.glEnable(GL10.GL_BLEND);
> > gl.glBlendFunc(GL10.GL_SRC_ALPHA, GL10.GL_ONE_MINUS_SRC_ALPHA);
> > gl.glEnable(GL10.GL_LINE_SMOOTH);
> > gl.glDisableClientState(GL10.GL_COLOR_ARRAY);
> > _hgt2width = (float) MyApp._width / MyApp._height;
> > gl.glOrthof(-_hgt2width, _hgt2width, -1, 1, 1, -1);
>
> > gl.glScalef(1, _hgt2width, 1);
> > gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
>
> > float lscale = .002f*MyApp._curScale;
>
> > gl.glPushMatrix();
> > gl.glColor4f(1f, 1f, 0f, 1f);
>
> > gl.glTranslatef(.375f, .5f, 0f);
> > gl.glScalef( lscale, lscale, 1f);
> > gl.glVertexPointer(2, GL10.GL_FIXED, 0, _lineVertices);
> > gl.glLineWidthx(0x1);
> > drawArrays(gl);
> > gl.glPopMatrix();
>
> > gl.glPushMatrix();
> > gl.glColor4f(1f, 1f, 1f, 1.0f);
> > gl.glScalef( lscale*8, lscale*8, 1f);
> > gl.glVertexPointer(2, GL10.GL_FIXED, 0, _lineVertices);
> > gl.glLineWidthx(0x1);
> > drawArrays(gl);
> > gl.glPopMatrix();
>
> > }
> > void drawArrays(GL10 gl) {
> > gl.glDrawArrays(GL10.GL_LINE_STRIP, 0, 5); //small square
> > gl.glDrawArrays(GL10.GL_LINE_STRIP, 5, 5); //medium square
> > gl.glDrawArrays(GL10.GL_LINE_STRIP, 10, 5);//large square
> > gl.glDrawArrays(GL10.GL_LINE_STRIP, 15, 2);//x axis
> > gl.glDrawArrays(GL10.GL_LINE_STRIP, 17, 2);//y axis
> > gl.glDrawArrays(GL10.GL_LINE_STRIP, 19, 2);//X half
> > gl.glDrawArrays(GL10.GL_LINE_STRIP, 21, 2);//X half
> > }
>
> > void makeLines() {
> > int hlf = 0x08000;
> > int one = 0x10000+hlf;
> > int sml = one/8;
> > int ten = one;
> > int big = 0x40000000;
> > Log.d("===jrm", String.format("one:%x big:%x", one, big));
> > int vertices[] = {
> > -sml , sml, //0 start square - scale 1/10
> > sml , sml, //1
> > sml , -sml, //2
> > -sml , -sml, //3
> > -sml , sml, //4
>
> > -one , one, //5 start square - scale 1
> > one , one, //6
> > one , -one, //7
> > -one , -one, //8
> > -one , one, //9
>
> > -ten , ten, //10 start square - scale 10
> > ten , ten, //11
> > ten , -ten, //12
> > -ten , -ten, //13
> > -ten , ten, //14
>
> > -big , 0, //15 start coord axes over huge area
> > big , 0, //16
>
> > 0 , big, //17
> > 0 , -big, //18
>
> > -big , -big, //19 start X over huge dimensions
> > big , big, //20
>
> > -big , big, //21
> > big , -big, //22
> > ten , one // BUT? Without this line, blows up
> > if openGL debug is enabled
>
> > };
> > this.numLines = vertices.length/2;
>
> > ByteBuffer vbb = ByteBuffer.allocateDirect(vertices.length*4);
> > vbb.order(ByteOrder.nativeOrder());
> > _lineVertices = vbb.asIntBuffer();
> > _lineVertices.put(vertices);
> > _lineVertices.position(0);
> > }
--
You received this message because you are subscribed to the Google
Groups "Android Developers" group.
To post to this group, send email to android-developers@googlegroups.com
To unsubscribe from this group, send email to
android-developers+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/android-developers?hl=en
