有人向我解释了来自 android 开发者网站的代码

Question

Im following this training tutorial on this site http://developer.android.com/training/graphics/opengl/touch.html#listener .

The link shows an example of how to respond to touch events and rotate a triangle. I have the code all setup and working i just don't understand this portion of code:

private final float TOUCH_SCALE_FACTOR = 180.0f / 320;
private float mPreviousX;
private float mPreviousY;

@Override
public boolean onTouchEvent(MotionEvent e) {
// MotionEvent reports input details from the touch screen
// and other input controls. In this case, you are only
// interested in events where the touch position changed.

float x = e.getX();
float y = e.getY();

switch (e.getAction()) {
    case MotionEvent.ACTION_MOVE:

        float dx = x - mPreviousX;
        float dy = y - mPreviousY;

        // reverse direction of rotation above the mid-line
        if (y > getHeight() / 2) {
          dx = dx * -1 ;
        }

        // reverse direction of rotation to left of the mid-line
        if (x < getWidth() / 2) {
          dy = dy * -1 ;
        }

        mRenderer.setAngle(
                mRenderer.getAngle() +
                ((dx + dy) * TOUCH_SCALE_FACTOR));
        requestRender();
}

mPreviousX = x;
mPreviousY = y;
return true;
}

getAngle and setAngle are sort of utility methods in mRenderer object as can be further seen in the example shown in the link.

I need an explanation of how this code calculates the angle exactly, how can it take the increments dx and dy and some them up and use that as an angle and what is happening with getHeight and getWidth arent these the height and width of the whole screen? i hope I've been clear enough, thanks.

Answer 1

Although this question is massively down-voted it is unfair to leave out a very common openGL developer problem which is that most (almost) all examples and tutorials are extremely poorly designed which misleads many developers in early stage or even makes them lose hope of ever understanding how this works.

The reason for that is that a basic openGL setup requires a lot of knowledge and is massive in code size. A proficient developer will break the code to multiple classes such as shader, context, buffer, objects, matrices... while more or less all the examples or tutorials will show everything in the same class/file simply because it is easier to navigate for a fresh developer. What this leads to is that authors will try to find a smallest (number of lines) solution to a problem which is not directly bound to the article you are reading.

As for this example you are using: I do not know the whole example or what it looks like but just seeing the method you posted it would suggest you have some shape in the middle (a triangle as mentioned) which is rotated by dragging through the screen.

What you would normally do is get the vector from the center to the finger (x-getWidth(), y-getHeight()) which can then be used to compute the angle via methods such as atan2f and the angle is then set to the object. This is actually a way shorter way as well but it would require some knowledge of math and definitely some explanation on the code itself.

So instead of that the author used a very simple procedure which says by dragging vertically or horizontally the object will rotate by some angle and the rotation direction depends on what part of the screen you are dragging on. Further the author actually added both vertical and horizontal rotation which in the end is simply a sum of 2 values.

I agree this may be extremely confusing to understand for developers with little experience in such coding. If nothing else this answer should be something to consider for all of you possible future authors of tutorials and examples.