| item |
| Stomach Contents: Structure - array
|
|---|
| 1 |
| Stomach Contents: Structure - struct |
|---|
| author |
noreply@blogger.com (Chet Haase)
|
| category |
| Stomach Contents: Structure - array
|
|---|
| 1 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
animation
|
|
| 2 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
demo
|
|
| 3 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
graphics
|
|
| 4 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
code
|
|
| 5 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
android
|
|
|
| description |
| Stomach Contents: Structure - struct |
|---|
| value |
The animation support <a href="http://android-developers.blogspot.com/2011/02/animation-in-honeycomb.html">added in Android 3.0</a> and <a href="http://android-developers.blogspot.com/2011/05/introducing-viewpropertyanimator.html">enhanced since then</a> is useful, allowing a flexible system of property animation to animate literally anything you want. Like a store going out of business: if it ain't nailed down, it's up for grabs.<br />
<br />
But that doesn't mean we're done yet; there are many things that we'd like to do to keep improving the animation system and making Android animations easier to write and more powerful. One of those things is curved motion.<br />
<br />
Right now, if you animate something between a start and end point, it will move in a straight line between those values. For example, a translation animation, where the object moves from one (x, y) location to another, will move in a straight line beween those points. You can (and should) use non-linear timing for these animations, and the animation framework uses ease-in/ease-out timing by default. But the actual spacial movement is linear; there is no way for you to specify a curved path for an object to take between the end values of an animation.<br />
<br />
Even if you use a multi-point keyframe animation, where you specify several intermediate points for the animation to pass through along the way, you are still going to move linearly between each of those points.<br />
<br />
One goal with animations is to make them feel as natural as possible. And just as motion in the real world (you know, the one we have to use as we move between the machines of our lives) is not linear, animations in our GUIs should not be limited to linear. For example, f a view moves from corner of the screen to the opposite corner, wouldn't it be nice to have the option to give it a little curve in and out at both ends, instead of being locked into a straight-line movement?<br />
<br />
We'd like to add this kind of capability to the animation system in a future release; it needs to be easy to create such animations, we just have to provide the APIs and functionality to let you do it.<br />
<br />
As I was looking into the problem, I created some prototype code using the existing animation APIs and realized that there's nothing stopping you from having this capability already. The flexibility of the Animator APIs allow you to do exactly the kinds of operations you need to get curved motion. You just need a little more code to do it.<br />
<br />
I thought it would help to post some of my prototype code to show you how. In particular, I thought this sample was interesting because it shows:<br />
<ul>
<li>How to move things along curves and complex paths</li>
<li>How to use the Animator APIs to do more than what the base library supports. In particular, how to use TypeEvaluator to animate custom types.</li>
</ul>
<br />
Some notes and caveats before we begin:<br />
<ul>
<li>This is a prototype only, and does not necessarily represent the way it would appear in any final API. It's just a sample program, and a pretty simple one at that.</li>
<li>Simply computing the location based on the fraction time elapsed in a curve interval is probably not the motion you want. It will give the mathematically correct motion along that path, but the time spent traveling along any particular length of that curve is dependent on the structure of the curve. Basically, you'll end up with slower and faster portions of the curve. This problem is admirably described <a href="http://www.planetclegg.com/projects/WarpingTextToSplines.html">on this blog</a>. A more complete solution flattens the curve and ensures uniform speed. But again, it's just a simple demo, so I'll leave correct path-time-distance navigation as an exercise for the reader (and for the writer, since this would be a part of any future implementation in the SDK).</li>
<li>The timing of the animation along a multiple-point path such as the one in the demo app is not as flexible as I'd like it to be. Basically, you end up with something that gives equal time in the overall animation to each individual interval. In addition, any "move" operations in the middle of the path cause the animation to wait at that location for that interval's equal slice of the duration. <a href="http://2.bp.blogspot.com/-3rGwpYgEm3E/TwRrkvVXfyI/AAAAAAAABfY/S8yqCr-rPvw/s1600/Screen+shot+2012-01-04+at+7.06.54+AM.png" imageanchor="1" style="clear: right; float: right; margin-bottom: 1em; margin-left: 1em;"><img border="0" src="http://2.bp.blogspot.com/-3rGwpYgEm3E/TwRrkvVXfyI/AAAAAAAABfY/S8yqCr-rPvw/s1600/Screen+shot+2012-01-04+at+7.06.54+AM.png" /></a>It should be possible, in a more complete implementation, to define the time associated with any particular interval.</li>
<li>This description assumes a foreknowledge of Bézier curves; if you have no idea what I'm talking about, you might want to go look them up (such as on the blog linked above or various other places on the web, such as <a href="http://en.wikipedia.org/wiki/B%C3%A9zier_curve">Wikipedia</a>). Or you can just read along, refer to the mathematically imprecise sketch to the right, and hopefully not get too lost.</li>
<li>The code as written requires Android 4.0 to build. Actually, it's mostly compatible back to 3.0, but the PathEvaluator class uses a generic specification for TypeEvaluator that was introduced in 4.0 (not necessary, just convenient when I wrote the code).</li>
</ul>
<br />
On with the code.<br />
<br />
The activity code is in PathAnimationActivity.onCreate(). First, we set up the path itself:<br />
<pre>AnimatorPath path = new AnimatorPath();
path.moveTo(0, 0);
path.lineTo(0, 300);
path.curveTo(100, 0, 300, 900, 400, 500);
</pre>
Here, we are constructing an AnimatorPath (which is part of the demo project that we'll see below) and supplying it with operations that will become points in the path, along with the operations to navigate the intervals up to those points. The first operation defines where the path starts, (0, 0). Then we move in a straight line to (0, 300). Finally, we move along a curve (a cubic Bézier curve, to be precise) to the point (400, 500), using control points (100, 0) and (300, 900) along the way.<br />
<br />
Next, we set up an ObjectAnimator to animate this path:<br />
<pre> final ObjectAnimator anim = ObjectAnimator.ofObject(this, "buttonLoc",
new PathEvaluator(), path.getPoints().toArray());
</pre>
This animator uses a new PathEvaluator object (introduced below). It also queries the AnimatorPath object to get an array of PathPoint (covered below) objects; these will become the points in the animation that define the intervals that we animate between. The animator will send the animated values to the <code>this</code> object, which is the activity instance itself. We implement the setter below to receive those values and pass them along to the actual Button object that we want to move on the screen:<br />
<pre> public void setButtonLoc(PathPoint newLoc) {
mButton.setTranslationX(newLoc.mX);
mButton.setTranslationY(newLoc.mY);
}
</pre>
<br />
The AnimatorPath class referred to above stores information about the overall path. Its API consists of everything seen above:<br />
<pre>public void moveTo(float x, float y);
public void lineTo(float x, float y);
public void curveTo(float c0X, float c0Y, float c1X, float c1Y, float x, float y);
public Collection<pathpoint> getPoints();
</pathpoint></pre>
<br />
Internally, AnimatorPath uses PathPoint to store the information at each point along the path. The PathPoint class is a simple data structure that just holds an x/y location, optional control point information (for curves), and the operation that tells the path containing that path point how to nagivate the interval leading up to that point. There are three factory methods that AnimatorPath uses to construct PathPoints as its API is called:<br />
<pre> public static PathPoint moveTo(float x, float y);
public static PathPoint lineTo(float x, float y);
public static PathPoint curveTo(float c0X, float c0Y, float c1X, float c1Y, float x, float y);
</pre>
<br />
All of the logic of actually animating between points along the path (besides that in the Android Animator engine itself) is in the class PathEvaluator. This class implements the single method in the TypeEvaluator interface, evaluate():<br />
<pre> public PathPoint evaluate(float t, PathPoint startValue, PathPoint endValue) {...}
</pre>
The return value of evaluator() depends on the operation described by the endValue PathPoint object.<br />
<br />
For curves, we calculate the x/y values given the anchor points (the location at startValue and endValue) and control points (both control points are stored in the endValue structure).<br />
<pre> if (endValue.mOperation == PathPoint.CURVE) {
float oneMinusT = 1 - t;
x = oneMinusT * oneMinusT * oneMinusT * startValue.mX +
3 * oneMinusT * oneMinusT * t * endValue.mControl0X +
3 * oneMinusT * t * t * endValue.mControl1X +
t * t * t * endValue.mX;
y = oneMinusT * oneMinusT * oneMinusT * startValue.mY +
3 * oneMinusT * oneMinusT * t * endValue.mControl0Y +
3 * oneMinusT * t * t * endValue.mControl1Y +
t * t * t * endValue.mY;
}
</pre>
For lines, we perform a simple linear interpolation between the start and end points:<br />
<pre> else if (endValue.mOperation == PathPoint.LINE) {
x = startValue.mX + t * (endValue.mX - startValue.mX);
y = startValue.mY + t * (endValue.mY - startValue.mY);
}
</pre>
For moves, we simply jump to the location defined by the end value:<br />
<pre> else {
x = endValue.mX;
y = endValue.mY;
}
</pre>
Finally, we create a new PathPoint with this calculated xy information, which will be passed to the setButtonLoc() method seen above:<br />
<pre> return PathPoint.moveTo(x, y);
</pre>
<br />
... and that's it. There's really not much to it, which was the whole point of posting this code. If you want to add curved motion to your animations, you can wait for the framework to do it for you... or you can take what I've done here and modify it to suit your needs. Yay, TypeEvaluator!<br />
<br />
I've posted the code on code.google.com; <a href="http://code.google.com/p/android-path-animation">check it out for yourself</a>. Or you can download the Eclipse project (including the pre-built apk) <a href="https://sites.google.com/site/androidcontentfromchet/downloads/android-path-animation.zip">here</a>.<div class="blogger-post-footer"><img width='1' height='1' src='https://blogger.googleusercontent.com/tracker/6843566830671277353-234478442663300991?l=graphics-geek.blogspot.com' alt='' /></div>
|
|
| guid |
| Stomach Contents: Structure - struct |
|---|
| isPermaLink |
NO
|
| value |
tag:blogger.com,1999:blog-6843566830671277353.post-234478442663300991
|
|
| link |
http://graphics-geek.blogspot.com/2012/01/curved-motion-in-android.html
|
| pubDate |
Wed, 04 Jan 2012 17:49:00 GMT
|
| title |
Curved Motion in Android
|
|
| 2 |
| Stomach Contents: Structure - struct |
|---|
| author |
noreply@blogger.com (Chet Haase)
|
| category |
| Stomach Contents: Structure - array
|
|---|
| 1 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
video
|
|
| 2 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
android
|
|
| 3 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
presentation
|
|
|
| description |
| Stomach Contents: Structure - struct |
|---|
| value |
Last month, <a href="http://www.curious-creature.org/">Romain</a> and I once again braved Bay Area rush hour traffic and gave a couple of talks at the SF Android user group. Those talks were recorded and are now posted online:<br />
<br />
<a href="http://marakana.com/forums/android/general/566.html">An Introduction to Ice Cream Sandwich (Android 4.0)</a><br />
This talk overviews some of the user and developer features of the new Android 4.0 release, through slides and demos. We also got side-swiped by a massive Q&A phase in the middle; always interesting to see what's on peoples's minds (and maybe even answer those questions sometimes).<br />
<br />
<a href="http://marakana.com/forums/android/general/570.html">Sticky GUIs</a><br />
This talk discusses some principles, approaches, and techniques in graphics, animation, layouts, and performance that may help you create better and more usable UI applications.<br />
<br />
(The ICS recording has interesting audio. It reminds me of early efforts at "stereo" with the Chet instrument coming out of your left speaker and the Romain instrument coming out of your right speaker. But the recordings are very good otherwise. And maybe it's better this way - you can just mute one of the speakers and mute the speaker you're tired of).<div class="blogger-post-footer"><img width='1' height='1' src='https://blogger.googleusercontent.com/tracker/6843566830671277353-2582025260570075641?l=graphics-geek.blogspot.com' alt='' /></div>
|
|
| guid |
| Stomach Contents: Structure - struct |
|---|
| isPermaLink |
NO
|
| value |
tag:blogger.com,1999:blog-6843566830671277353.post-2582025260570075641
|
|
| link |
http://graphics-geek.blogspot.com/2011/12/video-sf-android-user-group-talks-1111.html
|
| pubDate |
Wed, 14 Dec 2011 22:58:00 GMT
|
| title |
Video: SF Android User Group Talks 11/11
|
|
| 3 |
| Stomach Contents: Structure - struct |
|---|
| author |
noreply@blogger.com (Chet Haase)
|
| category |
| Stomach Contents: Structure - array
|
|---|
| 1 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
android
|
|
| 2 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
presentation
|
|
| 3 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
conferences
|
|
|
| description |
| Stomach Contents: Structure - struct |
|---|
| value |
I spent last week at <a href="http://devoxx.com/">Devoxx</a>, giving several talks with <a href="http://curious-creature.org/">Romain Guy</a> about Android (graphics, GUIs, performance, the latest developer features ... the usual). Now that I've recovered from a total system collapse over the weekend (apparently the body does insist on getting a little sleep now and then), I thought I'd post some thoughts and also the slides from our presentations.<br />
<br />
<span style="font-size: large;">Thoughts</span><br />
<br />
<a href="http://devoxx.com/">Devoxx</a> is my favorite developer conference. It is a perfect mix of highly technical (focused on developers, not business/marketing/PR), inexpensive (at 350-700 Euros, it's quite a deal for 2-5 days of full technical content of this caliber, even at the current exchange rate of 1 Euro == $97,000.02), and personal (it's a relatively small, single venue, so you're all together there in the talks, in the lobby, in the hallways, and on the show floor). And it's in an interesting venue (Antwerp, while not balmy in November, is a far more interesting location to return to than, say, San Jose). Oh, and the beer is quite nice.<br />
<br />
The conference is well run, the talks are professionally recorded and viewable on the excellent <a href="http://parleys.com/">parleys.com</a> website, and the beer is tasty. Parleys, and its free subscription for conference attendees, is particularly crucial since the comfortable theater seating guarantees that you'll have to catch up on at least some of the talks later.<br />
<br />
<span style="font-size: large;">Content</span><br />
<br />
Romain and I gave several talks this year, not all of which have accompanying slides:<br />
<br />
<b>University: Android Awesomeness</b><br />
This vaguely-titled 3-hour talk on Monday was in two parts. In the first half, Romain and I did a very quick introduction to the Android 4.0 release, then Philip Milne (another engineer on the Android framework team) followed up with a deep-dive into the GridLayout class that is new in the 4.0 release. The second half was more interactive, as we showed how we use the tools that ship with the SDK to debug performance, memory, and UI issues.<br />
You can download the slides for this talk here: <a href="https://docs.google.com/viewer?a=v&pid=explorer&chrome=true&srcid=0B4UFoayBOKIZMjM4ZDg1OTktZjY5Yy00OGU5LTkwMGUtZTAwZjU5NTk4MTIy">Part 1</a> and <a href="https://docs.google.com/viewer?a=v&pid=explorer&chrome=true&srcid=0B4UFoayBOKIZZTJkMGM4YjgtYTljYS00ZDVlLTkxMDItNjY1MDgyODZmOWIx">Part 2</a>.<br />
<br />
<b>Lab: Just Desserts: Developing with the Latest Features from Honeycomb and Ice Cream Sandwich</b><br />
This was a 3-hour lab on Tuesday morning in which we showed how to use some of the new features like fragments, TextureView, layers, and animations. No slides for this one; you had to be there. (I may post code projects later once I whip the code into presentable shape).<br />
<br />
<b>Session: Graphics Goodies</b><br />
Wednesday's talk was an updated version of the Android Accelerated Rendering talk we did at Google IO.<br />
<a href="https://docs.google.com/viewer?a=v&pid=explorer&chrome=true&srcid=0B4UFoayBOKIZZDQ0NGUxMDctMzM3OC00NTg0LTgzYWUtZGQ3ZmJkZmNjY2Iy">Here are the slides</a>.<br />
<br />
<b>Session: Sticky GUIs</b><br />
This presentation on Thursday was a collection of techniques and principles for creating GUI applications that will make your users stick: graphics, performance, animations, GUIs; they're all important.<br />
<a href="https://docs.google.com/viewer?a=v&pid=explorer&chrome=true&srcid=0B4UFoayBOKIZMDU5MWJhNGMtMzM4My00ZTI4LWEwNDktN2I3ZGMzYWI0OTMw">Here are the slides</a>.<br />
<br />
Android Awesomeness, Graphics Goodies, and Sticky GUIs were all recorded and will be available soon on the <a href="http://parleys.com/">parleys.com</a> website. You may get more out of the full presentations than from just the slides. In fact, I hope you do, because otherwise I don't know why we traveled that far to present them.<div class="blogger-post-footer"><img width='1' height='1' src='https://blogger.googleusercontent.com/tracker/6843566830671277353-6519957126992175583?l=graphics-geek.blogspot.com' alt='' /></div>
|
|
| guid |
| Stomach Contents: Structure - struct |
|---|
| isPermaLink |
NO
|
| value |
tag:blogger.com,1999:blog-6843566830671277353.post-6519957126992175583
|
|
| link |
http://graphics-geek.blogspot.com/2011/11/devoxxblog-of-slides-and-such.html
|
| pubDate |
Tue, 22 Nov 2011 23:05:00 GMT
|
| title |
#DevoxxBlog: Of Slides and Such
|
|
| 4 |
| Stomach Contents: Structure - struct |
|---|
| author |
noreply@blogger.com (Chet Haase)
|
| category |
| Stomach Contents: Structure - array
|
|---|
| 1 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
video
|
|
| 2 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
flex
|
|
| 3 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
animation
|
|
| 4 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
graphics
|
|
| 5 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
UI
|
|
| 6 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
android
|
|
| 7 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
presentation
|
|
| 8 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
effects
|
|
| 9 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
conferences
|
|
|
| description |
| Stomach Contents: Structure - struct |
|---|
| value |
I'm starting to prepare presentations for the ~8 hours of talks that <a href="http://curious-creature.org/">Romain</a> and I are giving at <a href="http://devoxx.com/">Devoxx</a> in a couple of weeks. "Preparing" generally entails mostly worrying, followed by a mad rush of writing slides and code at night, on the long flight, after beers, between talks, and sometimes during the talks. It's a busy time of year.<br />
<br />
I realized that the organizers of <a href="http://devoxx.com/">Devoxx</a> had recently released all of the recorded talks from last year into the wild (read: they're free on <a href="http://parleys.com/">parleys.com</a>), so it seemed worth linking to them in case anyone wanted to see what we had to say last time around.<br />
<br />
I'll give a plug for the <a href="http://devoxx.com/">conference</a> and the <a href="http://parleys.com/">Parleys</a> site here. If there were an ad banner, it'd go here. Not because I'm paid (I would make a poor ad salesman, apparently), but because I think that both the conference and the parleys site rock. The organizers do a great job of putting it all together, and the recordings and presentation of the talks on <a href="http://parleys.com/">parleys.com</a> is the best I've seen by far of any conferences I've spoken at.<br />
<br />
<table cellpadding="0" cellspacing="0" class="tr-caption-container" style="float: right; margin-left: 1em; text-align: right;"><tbody>
<tr><td style="text-align: center;"><a href="http://2.bp.blogspot.com/-OOMM5eHUMek/TrVTw6yWMjI/AAAAAAAABD4/bxD5VIUgmoM/s1600/PICT2812.jpg" imageanchor="1" style="clear: right; margin-bottom: 1em; margin-left: auto; margin-right: auto;"><img border="0" height="150" src="http://2.bp.blogspot.com/-OOMM5eHUMek/TrVTw6yWMjI/AAAAAAAABD4/bxD5VIUgmoM/s200/PICT2812.jpg" width="200" /></a></td></tr>
<tr><td class="tr-caption" style="text-align: center;">Yes, that young man on the pedestal is<br />
throwing a hand. It's an Antwerp thing.</td></tr>
</tbody></table>
<a href="http://parleys.com/">Parleys</a> is a subscription site; after the annual conference, you can join for the year (for a fee of 79 Euros) to watch all talks given at the conference. During that year, the talks are made freely available, one by one, then at the end they are all free. That year has passed, so the 2010 talks are all available now for free. If you enjoy them, consider joining parleys next time around to see them earlier. Or better yet, join us in balmy Antwerp, where the beer is good and so are the fries.<br />
<br />
<a href="http://www.parleys.com/#st=5&id=2191">Dive into Android, Part 1</a><br />
Romain talks about layout. This talk includes live-coding a custom layout, which is a good lesson in how to do it yourself (although you probably don't need to do it on stage in front of the cameras to make it work the way you want).<br />
<br />
<a href="http://www.parleys.com/#st=5&id=2194">Dive into Android, Part 2</a><br />
I talk about custom graphics. This is kind of a Filthy Rich Client talk, but more focused on the core principles and approaches of doing custom graphics in Android applications. nothing over-the-top filthy, just good stuff to know about Android GUI development.<br />
<br />
<a href="http://www.parleys.com/#st=5&id=2110">Android Graphics and Animations</a><br />
We cover lots of architectural details about the Android platform, including the view hierarchy, classes used in custom graphics, and pre-3.0 animations (remember: this talk was given before Android 3.0 (Honeycomb) was released). <br />
<br />
<a href="http://www.parleys.com/#st=5&id=2115">Android UI Development: Tips, Tricks, & Techniques</a><br />
This talk consists of a smattering of tips that will help you write efficient Android applications. We discuss the various tools that you should use, techniques for avoiding unnecessary garbage creation, and various performance tips. <br />
<br />
<a href="http://www.parleys.com/#st=5&id=2161">Flex 4 Fun</a>This is my swan song for the platform that I worked on prior to Android, and for my <a href="http://www.amazon.com/Flex-4-Fun-Chet-Haase/dp/0981531628">Flex 4 Fun</a> book that was published last year. I cover various things from the book, including graphics objects, filters, states and transitions, component skinning, and (of course) animation effects (the area I worked on for Flex 4). Lots of demos and code.<div class="blogger-post-footer"><img width='1' height='1' src='https://blogger.googleusercontent.com/tracker/6843566830671277353-7966527997592151369?l=graphics-geek.blogspot.com' alt='' /></div>
|
|
| guid |
| Stomach Contents: Structure - struct |
|---|
| isPermaLink |
NO
|
| value |
tag:blogger.com,1999:blog-6843566830671277353.post-7966527997592151369
|
|
| link |
http://graphics-geek.blogspot.com/2011/11/devoxx-then-and-now.html
|
| pubDate |
Sat, 05 Nov 2011 15:23:00 GMT
|
| title |
Devoxx: Then and Now
|
|
| 5 |
| Stomach Contents: Structure - struct |
|---|
| author |
noreply@blogger.com (Chet Haase)
|
| description |
| Stomach Contents: Structure - struct |
|---|
| value |
<a href="http://curious-creature.org/">Romain</a> and I wrote this article for the Android developer blog about
graphics and animation features (what else?) in the latest Android
release.<br /><br />Enjoy...<br />
<br />
<a href="http://android-developers.blogspot.com/2011/11/android-40-graphics-and-animations.html">http://android-developers.blogspot.com/2011/11/android-40-graphics-and-animations.html</a><div class="blogger-post-footer"><img width='1' height='1' src='https://blogger.googleusercontent.com/tracker/6843566830671277353-58885915132375949?l=graphics-geek.blogspot.com' alt='' /></div>
|
|
| guid |
| Stomach Contents: Structure - struct |
|---|
| isPermaLink |
NO
|
| value |
tag:blogger.com,1999:blog-6843566830671277353.post-58885915132375949
|
|
| link |
http://graphics-geek.blogspot.com/2011/11/android-40-graphics-and-animation.html
|
| pubDate |
Tue, 01 Nov 2011 16:08:00 GMT
|
| title |
Android 4.0 Graphics and Animation
|
|
| 6 |
| Stomach Contents: Structure - struct |
|---|
| author |
noreply@blogger.com (Chet Haase)
|
| category |
| Stomach Contents: Structure - array
|
|---|
| 1 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
animation
|
|
| 2 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
demo
|
|
| 3 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
code
|
|
| 4 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
UI
|
|
| 5 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
android
|
|
|
| description |
| Stomach Contents: Structure - struct |
|---|
| value |
One of the app developers here on Android asked me about the best way to animate adding and removing items from a UI. Specifically, he wanted to fade items in and out as they became visible/invisible.<br />
<br />
So I wrote up a sample activity that used <a href="http://graphics-geek.blogspot.com/2011/06/introducing-viewpropertyanimator.html">ViewPropertyAnimator</a>, showing how to set the visibility at the right time (making it visible before fading it in, listening for the onAnimationEnd() to set it invisible after fading it out). Pretty straightforward, but if you haven't played around a lot with the new animation classes yet (WHY HAVEN'T YOU?!?!), it's probably not obvious:<br />
<br />
To make it invisible:<br />
<pre>invisibleButton.animate().alpha(0f).setListener(new AnimatorListenerAdapter() {
public void onAnimationEnd(Animator animation) {
invisibleButton.setVisibility(View.INVISIBLE);
invisibleButton.setAlpha(1f);
invisibleButton.animate().setListener(null);
}
});
</pre>
To make it visible again:<br />
<pre>invisibleButton.setAlpha(0);
invisibleButton.setVisibility(View.VISIBLE);
invisibleButton.animate().alpha(1);
</pre>
<br />
I sent the sample application along to the developer. <br />
<br />
Then I thought I'd add to that sample and show how to also add/remove views, or set them to View.GONE as well as View.INVISIBLE.<br />
<br />
I sent that updated sample to the developer as well. <br />
<br />
Then I thought I might as well show how you'd do the same thing with <a href="http://graphics-geek.blogspot.com/2011/02/animation-in-honeycomb.html">ObjectAnimator</a>. It's a little more code than ViewPropertyAnimator, but still pretty straightforward. For example, fading the object out and making it invisible looks like this:<br />
<pre> ObjectAnimator anim = ObjectAnimator.ofFloat(invisibleButton1, "alpha",0);
anim.addListener(new AnimatorListenerAdapter() {
public void onAnimationEnd(Animator animation) {
invisibleButton1.setAlpha(1);
invisibleButton1.setVisibility(View.INVISIBLE);
}
});
anim.start();
</pre>
<br />
I sent this further updated sample to the developer. <br />
<br />
Then I thought I'd poke at a utility class that's been on my mind for a while. We have all of these new animation capabilities as of the Honeycomb release, but I'd still like it to be simpler to run these kinds of animations, especially ones that involve several actions like this: <i>fade</i> this view out, then <i>remove</i> it. So I wrote up a Fade class that has utility methods in it for fading/adding/removing/etc. I enhanced the sample to use the new Fade utilities. Now making a view invisible is just one step:<br />
<pre> fade.hide(invisibleButton2, View.INVISIBLE);
</pre>
Similarly, making that view visible again is a single call:<br />
<pre> fade.show(invisibleButton2);
</pre>
<br />
I sent this latest version of the sample to the developer. He was getting pretty tired of hearing from me by this time.<br />
<br />
Then I tweaked the Fade class to have a duration property.<br />
<br />
I was going to send this final (ha!) update to the developer, but I didn't want him to call security on me. I think he got what he needed the first time around. So rather than continue to bury him in yet more ways to accomplish this simple task, I thought I'd publish it here.<br />
<br />
Check out the <a href="https://sites.google.com/site/androidcontentfromchet/downloads/Fader.zip">sample code</a> for FaderActivity, which shows all of these things: ViewPropertyAnimator, ObjectAnimator, and this new Fade utility class. I hope that something like the Fade class and other higher-level animation classes will make it into the SDK eventually, but in the meantime, Fade should simplify fading tasks.<br />
<br />
There are a couple of things to note about fading animations. One thing is that there is an abrupt 'pop' when an item is removed from or added to a layout that is affected by that change. For example, the LinearLayout used in the example expands or contracts when the first button is removed or added or when the last button is set to VISIBLE or GONE (although you can't see that change since it's the last item in that layout). There's nothing to be done about this problem right now, although you might play with the LayoutTransition class available in 3.0, which animates the layout changes as well.<br />
<br />
It's also worth noting that the Fade class is great at fading things out from their current alpha and then back to an alpha value of 1 (fully opaque). It does not compensate for in-between alpha values that your views might want to persist between fades. That logic could be added, but there's some tedious logic around knowing when an in-between value is coming from the view itself vs. some other fade animation that happens to be running when you start the new one (for example, you fade an item out and then, halfway through, you fade it back in). The Fade class is great for the common case where views are typically just opaque (alpha == 1). But it seemed worth mentioning.<br />
<br />
You can grab a zipped version of the Eclipse project with the source for the example activity and the utility Fade class <a href="https://sites.google.com/site/androidcontentfromchet/downloads/Fader.zip">here</a>. <br />
<br />
Enjoy.<div class="blogger-post-footer"><img width='1' height='1' src='https://blogger.googleusercontent.com/tracker/6843566830671277353-3901987724650624192?l=graphics-geek.blogspot.com' alt='' /></div>
|
|
| guid |
| Stomach Contents: Structure - struct |
|---|
| isPermaLink |
NO
|
| value |
tag:blogger.com,1999:blog-6843566830671277353.post-3901987724650624192
|
|
| link |
http://graphics-geek.blogspot.com/2011/09/old-views-dont-die-they-just-fade-away.html
|
| pubDate |
Fri, 16 Sep 2011 18:19:00 GMT
|
| title |
Old Views Don't Die; They Just Fade Away
|
|
| 7 |
| Stomach Contents: Structure - struct |
|---|
| author |
noreply@blogger.com (Chet Haase)
|
| category |
| Stomach Contents: Structure - array
|
|---|
| 1 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
animation
|
|
| 2 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
android
|
|
|
| description |
| Stomach Contents: Structure - struct |
|---|
| value |
<p>A bug was filed on <a href="http://code.google.com/p/android/issues/list">android.com</a> recently that had me poring through the code and docs to understand three boolean flags in the old Animation class: <code>fillBefore</code>, <code>fillAfter</code>, and <code>fillEnabled</code>. On the surface, these properties don't seem that difficult to understand; they control how animations behave before and after they run. But between some complicated interactions of the properties and some, er, inaccuracies in the reference docs, it turned out to be somewhat tricky to understand how they work and how they're supposed to work. Once I got through that exercise (including fixing the docs - look for those fixes in a future release), I thought it might be helpful to explain how these flags really work.</p>
<p>First, let's cover the behavior of <code>fillBefore</code> and <code>fillAfter</code>. We'll get to <code>fillEnabled</code> and it's, um, special behavior after that.</p>
<h2>Before and After</h2>
<p><code>fillBefore</code> and <code>fillAfter</code> are pretty simple, conceptually; they define how an animation behaves before and after it runs. <code>fillBefore</code> controls whether the initial value of the animation is applied before its start time and <code>fillAfter</code> controls whether the animation's ending value persists after it ends. There are a couple of important nuances to understand, however.</p>
<ul>
<li>start time: The starting time of an animation, for the purposes of <code>fillBefore</code>, is not the time when you call <code>startAnimation()</code> on a View. Rather, it's the time that the animation will actually start running. These two times are the same if there is no <code>startOffset</code> set on the animation, but if you want to delay your animation, you might set a <code>startOffset</code> value to achieve that delay. <code>fillBefore</code> controls whether the animation will use the initial value of the animation during that startOffset phase.</li>
<li>AnimationSet: If you want to control the fill behavior of an animation that is inside an AnimationSet, it is certainly possible to do this. But if you want to control what happens outside the runtime of that AnimationSet, then you need to set the fill behavior on the set itself. For example, the <code>fillAfter</code> flag controls whether a ScaleAnimation's end value is used after it ends. But if the animation you set on your View is actually an AnimationSet containing that inner ScaleAnimation, then you need to set <code>fillAfter</code> on the AnimationSet if you want the value to persist after the AnimationSet ends. You can think of the fill behavior flags as having scope, which is either global (when not contained in an AnimationSet) or local to the AnimationSet in which their contained. Or you can just play with them enough to get the hang of it, like I did. It's also worth noting, as stated in the docs (correctly this time) that if you set the value of <code>fillBefore</code> or <code>fillAfter</code> these values will override those in the child animations of the set.</li>
</ul>
<p>The default values for these flags are <code>true</code> for <code>fillBefore</code> and <code>false</code> for <code>fillAfter</code>. So by default, animations will set their initial value immediately when the animation starts (regardless of <code>startOffset</code>), but will not persist those values after they end.</p>
<p>So that's all there is to those flags: you set or unset them according to whether you want the animation values to be used outside of when the animation is actually running. Well, sort of...</p>
<h2>The Enabler</h2>
<p>Here's where the other flag, <code>fillEnabled</code>, comes in. This flag controls when the other flags are actually taken into account. Or that's what some of the docs would have you believe. In actual fact, this flag controls <i>only the behavior of <code>fillBefore</code></i>, and essentially leaves <code>fillAfter</code> to its own devices.</p>
<p>Here's how the value of <code>fillEnabled</code> works:</p>
<ul>
<li><b>false</b>: If <code>fillEnabled</code>is false (which it is by default), then the value of <code>fillBefore</code> will be ignored. That's right, you can set or unset it all you want, but it will ignore your wishes and will essentially assume that <code>fillBefore</code> is true.</li>
<li><b>true</b>: When <code>fillEnabled</code> is true, the value of <code>fillBefore</code> will be taken into account to determine whether to apply the animation before it begins. The value of <code>fillAfter</code>, as I said earlier, will be used as-is, regardless of the value of <code>fillEnabled</code>.</li>
</ul>
<p>All of this means that the only way to get an animation to <i>not</i> persist its starting value before it actually starts running is to set <i>both</i> <code>fillEnabled</code> to true and <code>fillBefore</code> to false. Any other combination will result in the animation being applied before its starting time. Meanwhile, the value of <code>fillAfter</code> is applied directly, regardless of the value of <code>fillEnabled</code>. I believe it is this asymmetric behavior (coupled with an unfortunately generically named "fillEnabled" property and some, well, bugs in the docs) that made these three variables particularly difficult for some people to understand. Some people like me.</p>
<p>At this point, you might be asking yourself why these variables were created and defined in this way. All I can say is, welcome to the wonderful world of API development, where behavior needs to evolve while compatibility is preserved. In any case, I hope this explanation helps those who needed it.</p>
<p><i>p.s. For those starting to use the <a href="http://android-developers.blogspot.com/2011/02/animation-in-honeycomb.html">new animation system introduced in Android 3.0</a>, you can forget about all of this; there is no fill behavior (before, after, or enabled) for Animator-based animations.</i></p><div class="blogger-post-footer"><img width='1' height='1' src='https://blogger.googleusercontent.com/tracker/6843566830671277353-3047124683122277495?l=graphics-geek.blogspot.com' alt='' /></div>
|
|
| guid |
| Stomach Contents: Structure - struct |
|---|
| isPermaLink |
NO
|
| value |
tag:blogger.com,1999:blog-6843566830671277353.post-3047124683122277495
|
|
| link |
http://graphics-geek.blogspot.com/2011/08/mysterious-behavior-of-fillbefore.html
|
| pubDate |
Wed, 24 Aug 2011 14:21:00 GMT
|
| title |
The Mysterious Behavior of fillBefore, fillAfter, and fillEnabled
|
|
| 8 |
| Stomach Contents: Structure - struct |
|---|
| author |
noreply@blogger.com (Chet Haase)
|
| category |
| Stomach Contents: Structure - array
|
|---|
| 1 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
video
|
|
| 2 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
animation
|
|
| 3 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
demo
|
|
| 4 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
graphics
|
|
| 5 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
code
|
|
| 6 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
android
|
|
|
| description |
| Stomach Contents: Structure - struct |
|---|
| value |
<p>Here's a simple app that I wrote recently to see how background processing affects frame rate. There's nothing too complicated going on in the app, but it seemed worth publishing to show how to do various things in Android, such as:
</p><ul><li>Using a single ValueAnimator (3.0+ API) to animate several objects independently</li><li>Manipulating the transform of Canvas to move/rotate objects</li><li>Using the GPU to provide faster rendering (3.0+ capability)
</li><li>Tracking the current frames per second performance
</li></ul>Here's a video of the running application, captured using HDMI on a 3.1 tablet. You can see how the More, Less, and GPU controls affect what's going on in the app. Note that it starts out with no GPU acceleration and bogs down when we have lots of flakes on the screen. Then see how the frame rate improves once the GPU box is checked. The app is accelerated by default; non-GPU rendering is performed by setting a software layer on the view, which forces rendering to happen in software to a bitmap, which is then copied into the view.<p></p>
<iframe src="http://www.youtube.com/embed/_hCfvYuHOTY?hl=en&fs=1" allowfullscreen="" frameborder="0" height="349" width="425"></iframe>
<p><a href="https://sites.google.com/site/androidcontentfromchet/downloads/Droidflakes.zip">Here's the code</a> (a zipped Eclipse project for the app). You should be able to build/run it for any 3.0+ target device.
</p><p>
Note: this is not the Renderscript app that I showed in <a href="http://marakana.com/forums/android/general/381.html">a recent user group talk</a>. That other app is based on this one, but uses Renderscript to animate and draw the droidflakes. This version just uses the standard Canvas API to draw bitmaps. I'll post the Renderscript version soon.
</p><div class="blogger-post-footer"><img width='1' height='1' src='https://blogger.googleusercontent.com/tracker/6843566830671277353-2899293055739509748?l=graphics-geek.blogspot.com' alt='' /></div>
|
|
| guid |
| Stomach Contents: Structure - struct |
|---|
| isPermaLink |
NO
|
| value |
tag:blogger.com,1999:blog-6843566830671277353.post-2899293055739509748
|
|
| link |
http://graphics-geek.blogspot.com/2011/08/droidflakes-android-animation-demo.html
|
| pubDate |
Thu, 04 Aug 2011 15:56:00 GMT
|
| title |
DroidFlakes: An Android Animation Demo
|
|
| 9 |
| Stomach Contents: Structure - struct |
|---|
| author |
noreply@blogger.com (Chet Haase)
|
| category |
| Stomach Contents: Structure - array
|
|---|
| 1 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
video
|
|
| 2 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
UI
|
|
| 3 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
android
|
|
| 4 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
conferences
|
|
|
| description |
| Stomach Contents: Structure - struct |
|---|
| value |
<p><a href="http://www.curious-creature.org/">Romain</a> and I gave several talks at the excellent <a href="http://devoxx.com/">Devoxx</a> conference in balmy Antwerp last November. The video of one of these talks, <a href="http://www.parleys.com/#st=5&id=2115">Android UI Development: Tips, Tricks and Techniques</a>, has just been published for free on the <a href="http://parleys.com/">Parleys.com</a> site. All of the conference talks have been available for months to subscribers (79 Euros), but for those who haven't gotten around to registering <span style="font-style: italic;">quite</span> yet, the talks are published incrementally for free throughout the year, and our UI Tips talk is now available.</p>
<p>This talk covers a mix of topics, from "Garbage Zero" (techniques to avoid producing garbage when it matters) to an exploration of various tools and performance techniques that we use to produce better Android code.</p>
<p>Check out the video here: <a href="http://www.parleys.com/#st=5&id=2115">Android UI Development: Tips, Tricks and Techniques</a>.</p><div class="blogger-post-footer"><img width='1' height='1' src='https://blogger.googleusercontent.com/tracker/6843566830671277353-8368761966808144817?l=graphics-geek.blogspot.com' alt='' /></div>
|
|
| guid |
| Stomach Contents: Structure - struct |
|---|
| isPermaLink |
NO
|
| value |
tag:blogger.com,1999:blog-6843566830671277353.post-8368761966808144817
|
|
| link |
http://graphics-geek.blogspot.com/2011/06/video-android-ui-tips-tricks-and.html
|
| pubDate |
Wed, 29 Jun 2011 14:48:00 GMT
|
| title |
Video: Android UI: Tips, Tricks, and Techniques
|
|
| 10 |
| Stomach Contents: Structure - struct |
|---|
| author |
noreply@blogger.com (Chet Haase)
|
| category |
| Stomach Contents: Structure - array
|
|---|
| 1 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
graphics
|
|
| 2 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
article
|
|
| 3 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
android
|
|
|
| description |
| Stomach Contents: Structure - struct |
|---|
| value |
<p>I've given some talks about Android graphics recently, and the same questions keep coming up: </p><ul><li>What is Renderscript appropriate for?</li><li>Is it a replacement for OpenGL rendering?</li><li>How do I access Renderscript from NDK code?</li><li>When do I choose between the different rendering options?</li><li>Can I have a free tablet?</li></ul>
<p>It seemed to me that a brief article might help. In particular, I wanted to write something that lays out the various rendering options that Android provides and describes how we envision developers using them (and how we use them ourselves in the applications that we ship) so that you might better understand how and when to use them in your applications. Of course you're not bound to what we think; if you come up with new ways to use what the platform provides, all the better. But we can at least provide a little guidance to help you navigate the myriad of options. Hopefully this article will help answer the questions above. Except for the last question about the free tablet - I can't help you there.</p>
<p>First, I should explain what I mean by <i>rendering</i>, for everyone reading this that's not a graphics geek. "Rendering" is a synonym for drawing. Rendering is also defined as the process of turning an animal carcass into fat and other component pieces... but that's not what I'm talking about here. This article is about is all of the ways, in the Android platform, of drawing things onto the display. For example, you might have a drawing application, or a photo album, or a game, or a reading program, or anything else that needs to draw its content to the screen. If you're just using the SDK components (ImageView, Button, TextView, and so on), then we handle the rendering of these components internally. But if you have custom components that draw their own graphical elements, or if you're writing a fullscreen game that draws everything itself, then you need to know how to draw those items onto the device screen so that the user can see and interact with them.</p>
<p>There are two options for writing Android applications, each with their own ways of rendering graphics. I'll cover each of these in the following sections.</p>
<ul><li>SDK</li>
<li>NDK</li>
</ul>
<h1>The Android SDK</h1>
<p>The SDK is the typical, default approach for most GUI applications. You write your application using the Java programming language and the libraries that the SDK provides. Most of the graphics on the screen are drawn by the framework for the standard View objects such as Button, TextView, ListView, and so on. If you create custom Views or have customized rendering that you want to do for your application, then you need to know about the rendering options available to SDK applications. There are basically three options:</p>
<ul><li>The Canvas API</li>
<li>Renderscript</li>
<li>OpenGL wrappers</li>
</ul>
<h3>The Canvas API</h3>
<p>What I mean by "Canvas API" is the standard rendering for a typical SDK application that uses View objects (standard and custom) and performs and rendering by calling the various methods in the Canvas class. The rendering process of the Android view hierarchy consists of calls to each View's <code>onDraw()</code> method. This method takes a single parameter, Canvas, which is the object used by the view to draw its content. For example, a <code>Button</code> might tell its background Drawable to draw itself into the Canvas and then draw its label with a call to <code>Canvas.drawText()</code>.</p>
<p>If you have a custom View, in which you implement the <code>onDraw()</code> method and draw your own graphic elements, then you would typically call methods in the Canvas object passed in to the <code>onDraw()</code> method. For example, you might draw lines with <code>Canvas.drawLine()</code> and circles with <code>Canvas.drawCircle()</code>.</p>
<p>This approach to rendering is typical for most GUI applications, and is fine for most purposes when you just need standard GUI components and graphics and for which the performance of your application is not an issue. With the GPU acceleration that we added in Android 3.0, the performance for the Canvas API is even better than it used to be. As discussed in the article <a href="http://android-developers.blogspot.com/2011/03/android-30-hardware-acceleration.html">Android 3.0 Hardware Acceleration</a>, all rendering done by the SDK now happens via OpenGL calls to the GPU. This level of hardware acceleration for standard as well as custom views and graphics can provide excellent performance and allows for parallelism by offloading rendering work from the CPU onto the GPU.</p>
<p>But sometimes you may want to go beyond what the Canvas API provides, either in terms of the graphics functionality you need or the performance that your particular situation requires. For example, the Canvas API does not provide complete 3D rendering capabilities. In these situations, you might want to look beyond the Canvas API to the other options available in the SDK.</p>
<h3>Renderscript</h3>
<p>The Renderscript API was introduced in Android 3.0. Renderscript was actually in use in an earlier form long before this release; the Live Wallpapers that shipped with earlier releases were written using Renderscript. But Android 3.0 introduced the first public form of the API and the runtime library. Describing what Renderscript is and how to use it is beyond the scope of this article. Instead, I'll just refer you to Jason Sams's introductory articles, <a href="http://android-developers.blogspot.com/2011/02/introducing-renderscript.html">Introducing Renderscript</a> and <a href="http://android-developers.blogspot.com/2011/03/renderscript.html">Renderscript Part 2</a>. Very briefly, Renderscript is a language, API, and runtime library that you can use to achieve high performance rendering and computation for Android applications.</p>
<p>An application using Renderscript is an SDK application, using any of the SDK APIs and facilities provided at that level, with addition pieces of the application written using the Renderscript language. These scripts are initialized from Dalvik code. The scripts automatically provide glue code that wraps fields at the Renderscript level, so that SDK code can set values in Renderscript code by calling simple methods. Renderscript has a reference to a drawing surface that it renders to in a thread that is separate from the UI toolkit thread. It handles its own rendering and the timing of when that rendering happens.</p>
<p>One of the things that makes Renderscript compelling is that it can determine, at runtime, the best way to achieve high performance for a particular operation. For example, it might send graphics operations down to the GPU, or it might parcel out independent computations to separate cores in a multi-core device. All of this is transparent to the application; it simply starts the script, sets the values, and lets it go.</p>
<p>An important use case for Renderscript arises for SDK applications that need functionality or performance that cannot be had through the SDK directly. For example, your application may need to perform 3D graphics operations or heavy computation that takes too much time at the SDK level. You might consider taking these portions of your application and farming them out to Renderscript to do the work there instead.</p>
<p>An important consequence of the Renderscript approach using SDK and runtime-compiled code is that Renderscript applications are fully portable between devices. That is, you only need to compile your application once, not per-architecture (as you must do with the NDK). This single apk is then runnable on any device that supports the SDK level that you compiled for (3.0 and above, since 3.0 is the first Android release to support Renderscript).</p>
<p>Examples of Renderscript in Android 3.0 include the Live Wallpapers, the video wall view in the YouTube application, and the Books application (including that beautiful page-turn effect). Other examples can be found in the SDK samples; you should check these out to understand how to write Renderscript as well as how to initialize and interact with the scripts from SDK applications.</p>
<h3>OpenGL Wrapper Functions</h3>
<p>Android also provides wrappers for OpenGL APIs at the SDK level. That is, you can write an application using the SDK, with full access to usual SDK APIs and functionality, and still use OpenGL ES 1.x and OpenGL ES 2.0 APIs, by calling the wrapper functions in GLES10 or GLES20 classes. These wrappers call the underlying OpenGL APIs at the native level for those versions of OpenGL ES.</p>
<p>For casually exploring or using OpenGL, this may be a reasonable option. But while this approach works, it's not a recommended practice as a general approach for complex scenes that require high-performance graphics. For one thing, it is difficult to achieve high performance levels equivalent to native access to OpenGL due to the overhead of calling down from the SDK to the native level for every OpenGL call.</p>
<p>The Music application that shipped with Android 3.0 used this approach. The application was an SDK application which needed some simple 3D graphics operations, such as the carousel view of albums. The main reason that it uses the SDK/OpenGL approach is because it is an unbundled application (not dependent upon a particular release of the SDK) and needed to work on releases back to 2.2. It therefore used APIs that were available on those previous releases.
</p>
<h1>NDK</h1>
<p>The NDK exists to provide an easy porting layer for existing applications written in native code, or which use native libraries. Porting might be more easily and quickly accomplished by using the NDK than by converting existing code to the language and APIs used by the SDK.</p>
<p>The NDK does not provide the rich GUI toolkit of the Android platform at the native level, so developers do not have access to the View objects, or the events, or the rest of the infrastructure that is provided in the SDK APIs. But there is a graphics environment at the NDK level that is sufficient for some specific purposes. In particular, game developers that simply want a fullscreen game experience can find what they need with OpenGL. This API provides low-level graphics functionality that lets applications display 2D and 3D graphics using the GPU for maximum graphics performance.</p>
<p>One important restriction of the NDK to keep in mind is that it compiles applications to specific CPU architectures. This means that if you only build your application for one specific chip, then the application will not work on Android devices that do not have that chip architecture. This is particularly important in the broad and growing Android ecosystem where new devices are coming out all the time. You probably want your application to work as well on new chips as it did on the ones you used to develop the application. So while the NDK OpenGL solution provides a reasonable route to fast graphics performance, it does so at the cost of the portability that other solutions offer.</p>
<p>One of the questions that came up about Renderscript when I talked to developers was how to access it from the NDK. This is not currently possible. Renderscript is specifically created to be a companion to SDK applications. We envision users of Renderscript as SDK applications that use Renderscript for their high-performance graphics or computation needs. These applications might be primarily SDK applications, with GUIs and interaction and most other facilities provided by the SDK APIs and small but important pieces of functionality provided by Renderscript, such as graphics effects that would otherwise not be possible or not perform as well. Or these applications might use Renderscript for most of what they do, just using the SDK to initialize the scripts and letting Renderscript take over from there.</p>
<h2>And So...</h2>
<p>I've tried to explain and categorize the different rendering options that we provide in the Android platform. What may seem confusing at first, because of the potential overlap, is actually simple once you understand how these libraries differ from each other in their purpose, their use, and their advantages. Here's one last brief take at a breakdown of when you might consider the various options:</p>
<ul>
<li><span style="font-weight: bold;">SDK Canvas API</span>: If you're writing a normal GUI application, using the SDK and the Canvas API is probably the most sensible option. If you need custom 2D graphics, there is plenty of power and reasonable performance in the Canvas API.</li>
<li><span style="font-weight: bold;">SDK Renderscript</span>: If you want a fully portable, SDK application with access to the power, speed, and functionality of the Renderscript library and underlying GPU and multi-core CPU architectures, then it's worth exploring this new feature of Android.</li>
<li><span style="font-weight: bold;">SDK OpenGL Wrappers</span>: If you are writing an SDK application and want to sprinkle in some 3D effects with OpenGL, you could see whether the OpenGL wrapper functions suit your needs.</li>
<li><span style="font-weight: bold;">NDK OpenGL</span>: If you are porting your application from a different platform or existing native code and are looking for the fastest way to get it up and running on Android, then using the NDK with OpenGL is worth considering.</li>
</ul>
<p>Whatever your rendering need, Android has something for you. So keep those cool graphics applications coming! (Sorry I still can't help you with the free tablet, though. There were tablets given away at Google I/O this year, so you could get one of those if you can travel back in time. I think there's an app for that. It probably uses Renderscript.)</p><div class="blogger-post-footer"><img width='1' height='1' src='https://blogger.googleusercontent.com/tracker/6843566830671277353-3664950331852690240?l=graphics-geek.blogspot.com' alt='' /></div>
|
|
| guid |
| Stomach Contents: Structure - struct |
|---|
| isPermaLink |
NO
|
| value |
tag:blogger.com,1999:blog-6843566830671277353.post-3664950331852690240
|
|
| link |
http://graphics-geek.blogspot.com/2011/06/android-rendering-options.html
|
| pubDate |
Thu, 23 Jun 2011 18:22:00 GMT
|
| title |
Android Rendering Options
|
|
| 11 |
| Stomach Contents: Structure - struct |
|---|
| author |
noreply@blogger.com (Chet Haase)
|
| category |
| Stomach Contents: Structure - array
|
|---|
| 1 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
video
|
|
| 2 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
animation
|
|
| 3 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
article
|
|
| 4 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
android
|
|
|
| description |
| Stomach Contents: Structure - struct |
|---|
| value |
<p>The property animation capabilities that are in Android 3.0 (described in the article <a href="http://android-developers.blogspot.com/2011/02/animation-in-honeycomb.html">Animation in Honeycomb</a>) represent a good building block for powerful animation capabilities in the platform. But we're not stopping there. One minor addition to the platform was added in the 3.1 release, ViewPropertyAnimator. This class allows very easy and efficient one-liner animations of some of the new View properties like alpha, rotation, and scaleX/Y.</p>
<p>Check out the <a href="http://android-developers.blogspot.com/2011/05/introducing-viewpropertyanimator.html">Introducing ViewPropertyAnimator</a> article on the Android developer blog for more about this new API. In the meantime, enjoy this teaser trailer that shows the demo described in the article. The interesting part is the code (shown in <a href="http://android-developers.blogspot.com/2011/05/introducing-viewpropertyanimator.html">the article</a>, not here). And the soundtrack, of course: turn up your speakers.</p>
<iframe src="http://www.youtube.com/embed/abfLUJCCxsw" allowfullscreen="" width="560" frameborder="0" height="349"></iframe><div class="blogger-post-footer"><img width='1' height='1' src='https://blogger.googleusercontent.com/tracker/6843566830671277353-4971097699975090430?l=graphics-geek.blogspot.com' alt='' /></div>
|
|
| guid |
| Stomach Contents: Structure - struct |
|---|
| isPermaLink |
NO
|
| value |
tag:blogger.com,1999:blog-6843566830671277353.post-4971097699975090430
|
|
| link |
http://graphics-geek.blogspot.com/2011/06/introducing-viewpropertyanimator.html
|
| pubDate |
Wed, 01 Jun 2011 17:45:00 GMT
|
| title |
Introducing ViewPropertyAnimator
|
|
| 12 |
| Stomach Contents: Structure - struct |
|---|
| author |
noreply@blogger.com (Chet Haase)
|
| category |
| Stomach Contents: Structure - array
|
|---|
| 1 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
video
|
|
| 2 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
android
|
|
| 3 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
conferences
|
|
|
| description |
| Stomach Contents: Structure - struct |
|---|
| value |
<p>I had the chance to speak at <a href="http://www.google.com/events/io/2011/">Google I/O</a> this week, giving two talks with <a href="http://curious-creature.org/">Romain Guy</a>, <a href="http://www.google.com/events/io/2011/sessions/honeycomb-highlights.html">Honeycomb Highlights</a> and <a href="http://www.google.com/events/io/2011/sessions/accelerated-android-rendering.html">Android Accelerated Rendering</a>. The talks were fun, as were the conversations with the developers that came by our Android Office Hours. The conference was enjoyable and relaxing; I'm looking forward to my system recovering by sometime in June of 2012.</p>
<p>Google's pretty good at posting content online (surprise, surprise), and I/O is no exception. Our Honeycomb talk was available on YouTube as we were giving it (nothing like streaming live to the world to keep the nervous tension alive), and I hope to see the Rendering talk posted there soon. In the meantime, Romain provided links to the all of the video, slide, and demo resources for our talks; check out <a href="http://www.curious-creature.org/2011/05/12/android-presentations-at-google-io-2011/">his blog</a> for all of the details. And hopefully see you at some future I/O or other Android-related conference!</p><div class="blogger-post-footer"><img width='1' height='1' src='https://blogger.googleusercontent.com/tracker/6843566830671277353-6657516160094524748?l=graphics-geek.blogspot.com' alt='' /></div>
|
|
| guid |
| Stomach Contents: Structure - struct |
|---|
| isPermaLink |
NO
|
| value |
tag:blogger.com,1999:blog-6843566830671277353.post-6657516160094524748
|
|
| link |
http://graphics-geek.blogspot.com/2011/05/iou-io-slides-and-videos.html
|
| pubDate |
Fri, 13 May 2011 17:12:00 GMT
|
| title |
IOU IO Slides and Videos
|
|
| 13 |
| Stomach Contents: Structure - struct |
|---|
| author |
noreply@blogger.com (Chet Haase)
|
| category |
| Stomach Contents: Structure - array
|
|---|
| 1 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
animation
|
|
| 2 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
android
|
|
| 3 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
presentation
|
|
| 4 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
conferences
|
|
|
| description |
| Stomach Contents: Structure - struct |
|---|
| value |
<p>Here are the slides from our presentations at <a href="http://andevcon.com/">AnDevCon</a>:</p>
<p><a href="https://sites.google.com/site/androidcontentfromchet/downloads/AnDevConHCKeynote.pdf">Android 3.0: Honeycomb and Get It</a>. This presentation, with <a href="http://www.curious-creature.org">Romain Guy</a>, was an overview of some of the highlights in the 3.0 release, for users and for developers.</p>
<p><a href="https://sites.google.com/site/androidcontentfromchet/downloads/Androidimation.pdf">Androidimation: Animation in Android</a>. This presentation discussed how to use the animation APIs in Android, including the animation classes in the SDK before 3.0 and the new animation system in 3.0.</p>
<p>Enjoy.</p><div class="blogger-post-footer"><img width='1' height='1' src='https://blogger.googleusercontent.com/tracker/6843566830671277353-6289739134035816595?l=graphics-geek.blogspot.com' alt='' /></div>
|
|
| guid |
| Stomach Contents: Structure - struct |
|---|
| isPermaLink |
NO
|
| value |
tag:blogger.com,1999:blog-6843566830671277353.post-6289739134035816595
|
|
| link |
http://graphics-geek.blogspot.com/2011/03/andevcon-slides.html
|
| pubDate |
Thu, 10 Mar 2011 00:20:00 GMT
|
| title |
AnDevCon Slides
|
|
| 14 |
| Stomach Contents: Structure - struct |
|---|
| author |
noreply@blogger.com (Chet Haase)
|
| category |
| Stomach Contents: Structure - array
|
|---|
| 1 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
video
|
|
| 2 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
android
|
|
|
| description |
| Stomach Contents: Structure - struct |
|---|
| value |
<p>I've gotten some questions about how the video in <a href="http://graphics-geek.blogspot.com/2011/02/http://http://graphics-geek.blogspot.com/2011/02/animation-in-honeycomb.html">my recent animation article</a> as well as the <a href="http://www.curious-creature.org/2011/02/18/android-3-0-animations-demo/">video of Romain's excellent photo viewing app</a> were created. I thought I'd spend a few words on it in case anyone else wants to do something similar.</p>
<p>I can tell you how I did it, but it'll cost you. About $200, in fact; that's how much I paid Amazon for the setup I used.
</p>
<p>First, the reasons I wanted the device:</p>
<ul><li>Debugging animations is hard: So many of the issues I chase with animations are timing-dependent. So the typical approach of step-debugging doesn't work; as soon as you stop in the debugger, you've lost the stream of whatever is causing the issue.. Nor does it help to hack the code and add tracing output everywhere, because sometimes you can't easily access the code in question (although this is what I end up doing in many cases where I can change the code). Sometimes it helps to dramatically sloooooooow down the animations, so that you can see it unfold instead of trying not to blink and miss the action.
But what would be really nice is to be able to catch the actual animation, at speed, and then be able to see it played back in slow motion. That's what HDMI recording gives me. I thought about getting a high-speed camera, but between the cost, the reliance on a lot of light for each frame, and the setup for any shot, that didn't seem like a great general solution.</li>
<li>Screencasting: I've been wanting to do more blogging about Android development. In particular, I'd like to post some video tutorials, something like I did in a previous life. I find that forum to be very efficient, once I get into the groove. I can talk through a demo, show the demo, and show the code, and do so in far less time than it takes me to write an article, for example. But that means I'll need some way to screencast from the device that's running the animation code that I'll be talking about. I could take a video of me playing with the device, but it's more of a hassle to set it up, and the quality of the video just isn't as good.</li></ul>
<p>The solution: an HDMI recorder. The Xoom device on which I recorded the video has an HDMI output port. So all I needed was a device on the other end of the HDMI cable to record that output stream. I picked up an Intensity Pro PCI Express card by Blackmagic, and that did the trick. I installed the card in my Mac Pro, installed the software that came with the device, and it was a simple matter of running the capture software to capture the actual video stream. You can also use other capture software, such as Adobe Premiere, but I found the software that came with the device sufficient for my needs. I did notice an occasional dropped frame (I had to set a setting in the software to not stop recording when there is a dropped frame), but overall it seems fine, at least for my use cases.</p>
<p>Here's a picture of the recorder's box (the card is in my machine and I didn't feel like taking it out). I like the sheer recursiveness here: it's a picture taken with the device of the recorder, uploaded via HDMI from the device to the recorder. I've put some other completely random objects on the shelf with it to give you a sense for its size (small).</p>
<a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="http://2.bp.blogspot.com/-Jx54Nzjtxs8/TWbWbuMjw9I/AAAAAAAAAdY/bJmRa2QqGFA/s1600/IntensityPro.jpg"><img style="cursor: pointer; width: 400px; height: 225px;" src="http://2.bp.blogspot.com/-Jx54Nzjtxs8/TWbWbuMjw9I/AAAAAAAAAdY/bJmRa2QqGFA/s400/IntensityPro.jpg" alt="" id="BLOGGER_PHOTO_ID_5577380960290456530" border="0" /></a>
<p>I'm sure there are other solutions out there, but this setup works for me.</p><div class="blogger-post-footer"><img width='1' height='1' src='https://blogger.googleusercontent.com/tracker/6843566830671277353-5710733071568030356?l=graphics-geek.blogspot.com' alt='' /></div>
|
|
| guid |
| Stomach Contents: Structure - struct |
|---|
| isPermaLink |
NO
|
| value |
tag:blogger.com,1999:blog-6843566830671277353.post-5710733071568030356
|
|
| link |
http://graphics-geek.blogspot.com/2011/02/recording-animations-via-hdmi.html
|
| pubDate |
Thu, 24 Feb 2011 19:39:00 GMT
|
| title |
Recording Animations via HDMI
|
|
| 15 |
| Stomach Contents: Structure - struct |
|---|
| author |
noreply@blogger.com (Chet Haase)
|
| category |
| Stomach Contents: Structure - array
|
|---|
| 1 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
video
|
|
| 2 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
animation
|
|
| 3 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
android
|
|
|
| description |
| Stomach Contents: Structure - struct |
|---|
| value |
<p>I've posted an article, <a href="http://android-developers.blogspot.com/2011/02/animation-in-honeycomb.html">Animation in Honeycomb</a>, on the <a href="http://android-developers.blogspot.com/">Android Developers blog</a>. The article gives an overview of the new property animation system in Android 3.0. <a href="http://android-developers.blogspot.com/2011/02/animation-in-honeycomb.html">Check it out</a>.</p>
<p>And while you wait, <a href="http://youtu.be/-9nxx066eHE">here's the demo reel for the article</a>. I wanted to show some of the home screen interactions and API demos from the SDK that take advantage of the new animation framework. The sound track has nothing whatsoever to do with Android, but the video seemed to want audio. It was a sound decision.</p><div class="blogger-post-footer"><img width='1' height='1' src='https://blogger.googleusercontent.com/tracker/6843566830671277353-3560406904973720831?l=graphics-geek.blogspot.com' alt='' /></div>
|
|
| guid |
| Stomach Contents: Structure - struct |
|---|
| isPermaLink |
NO
|
| value |
tag:blogger.com,1999:blog-6843566830671277353.post-3560406904973720831
|
|
| link |
http://graphics-geek.blogspot.com/2011/02/animation-in-honeycomb.html
|
| pubDate |
Thu, 24 Feb 2011 19:33:00 GMT
|
| title |
Animation in Honeycomb
|
|
| 16 |
| Stomach Contents: Structure - struct |
|---|
| author |
noreply@blogger.com (Chet Haase)
|
| category |
| Stomach Contents: Structure - array
|
|---|
| 1 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
video
|
|
| 2 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
flex
|
|
| 3 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
flex 4
|
|
| 4 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
presentation
|
|
| 5 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
conferences
|
|
| 6 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
book
|
|
|
| description |
| Stomach Contents: Structure - struct |
|---|
| value |
<div style="float: right; text-align: right; font-style: italic;"><a href="http://www.artima.com/shop/flex_4_fun"><iframe src="http://rcm.amazon.com/e/cm?lt1=_blank&bc1=000000&IS2=1&bg1=FFFFFF&fc1=000000&lc1=0000FF&t=filriccli-20&o=1&p=8&l=as1&m=amazon&f=ifr&md=10FE9736YVPPT7A0FBG2&asins=0981531628" style="width: 120px; height: 240px;" marginwidth="0" marginheight="0" frameborder="0" scrolling="no"></iframe></a></div><p>The international book tour for <a href="http://www.artima.com/shop/flex_4_fun">Flex 4 Fun</a> began last November in Antwerp, Belgium (the home of diamonds, chocolate, and GUI toolkit programming books). It was a gray a rainy day, which is unusual for Antwerp except for the months between September and June.
</p><p>
The tour began as all such things do: parties dripping with scantily-clad programming celebrities, mobs of teeming fans fighting for autographs and shreds of clothing, and all-night hacking orgies. It was unforgettable, it was a blur of over-caffeinated memory, it was ... just another book tour.
</p><p>
The tour came to an abrupt end. I can't confirm that it was because of overcrowded venues and rabid crowds that overwhelmed Interpol forces. I can only say that I had to leave the town anonymously, quickly, and with only 10 pounds of chocolate as a memory of the experience.
</p><p>
<span style="font-style: italic;">Or...</span>
</p><p>
I gave a talk on <a href="http://www.artima.com/shop/flex_4_fun">Flex 4 Fun</a> at <a href="http://devoxx.com/">Devoxx</a>. The presentation gave an overview of some of the graphics and animation features in Flex 4, and worked through an example of skinning a component to show some of these new features. This was one of several talks I gave that week, although this was the only one on Flex. In fact, it's probably the last such talk, since I don't have a lot of opportunity to do Flex development in my new Androidal life. Call it my final Flex fling ... 4 fun.
</p><p>
Instead of embedding the video, I'll encourage you to go to <a href="http://parleys.com/#st=5&id=2161&sl=1">Parleys.com</a> to watch the presentation, and to check out the many other videos from the <a href="http://devoxx.com/">Devoxx</a> conference. Parleys has a subscription model (79 Euros to watch all videos from Devoxx 2010), but there are a few talks available for free now (like this one) to whet your appetite.
</p><p>
Enjoy the video while I continue to recover from the tour.
</p><div class="blogger-post-footer"><img width='1' height='1' src='https://blogger.googleusercontent.com/tracker/6843566830671277353-6342154175535133547?l=graphics-geek.blogspot.com' alt='' /></div>
|
|
| guid |
| Stomach Contents: Structure - struct |
|---|
| isPermaLink |
NO
|
| value |
tag:blogger.com,1999:blog-6843566830671277353.post-6342154175535133547
|
|
| link |
http://graphics-geek.blogspot.com/2011/02/flex-4-fun-international-tour.html
|
| pubDate |
Wed, 16 Feb 2011 14:53:00 GMT
|
| title |
Flex 4 Fun: The International Tour
|
|
| 17 |
| Stomach Contents: Structure - struct |
|---|
| author |
noreply@blogger.com (Chet Haase)
|
| category |
| Stomach Contents: Structure - array
|
|---|
| 1 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
humor
|
|
| 2 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
t-shirt
|
|
|
| description |
| Stomach Contents: Structure - struct |
|---|
| value |
<p>(Cross-post with <a href="http://chetchat.blogspot.com/">my humor blog</a>; I figured this content would wear well on my geek blog, too).</p><p>For no good reason at all, I decided that geeks need more T-shirts and that I need to provide them. Fortunately, I don't have to pit my sewing skills against such a high goal; I'll just let <a href="http://www.cafepress.com/codedependent">CafePress</a> do it for me.</p><p>Here's the first such effort, especially topical for this blog, "<span class="Apple-style-span"><b>codedependent</b></span>" (available in various colors/styles - see the <a href="http://www.cafepress.com/codedependent">site</a> for the full array):</p>
<a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="http://www.cafepress.com/codedependent"><img style="cursor:pointer; cursor:hand;width: 394px; height: 400px;" src="http://2.bp.blogspot.com/_l1oSIKeXdHo/TTHvRFJWSZI/AAAAAAAAAc8/AqxvepMMMt0/s400/Codedependent-tee.png" border="0" alt="" id="BLOGGER_PHOTO_ID_5562490091497474450" /></a><div class="blogger-post-footer"><img width='1' height='1' src='https://blogger.googleusercontent.com/tracker/6843566830671277353-6939182467226034059?l=graphics-geek.blogspot.com' alt='' /></div>
|
|
| guid |
| Stomach Contents: Structure - struct |
|---|
| isPermaLink |
NO
|
| value |
tag:blogger.com,1999:blog-6843566830671277353.post-6939182467226034059
|
|
| link |
http://graphics-geek.blogspot.com/2011/01/codedependent-clothing-line.html
|
| pubDate |
Sat, 15 Jan 2011 19:34:00 GMT
|
| title |
CodeDependent: The Clothing Line
|
|
| 18 |
| Stomach Contents: Structure - struct |
|---|
| author |
noreply@blogger.com (Chet Haase)
|
| category |
| Stomach Contents: Structure - array
|
|---|
| 1 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
video
|
|
| 2 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
code
|
|
| 3 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
android
|
|
| 4 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
effects
|
|
|
| description |
| Stomach Contents: Structure - struct |
|---|
| value |
<p><a href="http://chetchat.blogspot.com/2011/01/when-i-am-king-solving-resolving.html">Everyone's supposed to make a resolution</a> on New Years, so here's mine: post more articles/blogs/videos about Android development. Starting with today's video tutorial.</p>
<p>Here's the first in what I hope will be a series of video tutorials on anything ranging from graphics to animation and back to graphics (hey, it's my show and I might as well talk about the things I enjoy).</p>
<p>For the <a href="http://devoxx.com/">Devoxx</a> conference last November, I developed a simple picture-viewing application to demonstrate various facets of UI development that <a href="http://www.curious-creature.org/">Romain Guy</a> and I were talking about that week. You can see the presentations online at <a href="http://parleys.com/">parleys.com</a> (you'll have to register for 79 Euros to get access to them for now). But I wanted to deep dive into particular aspects of this application for my blog. Here's the first of these tutorials, in which I talk about the simple reflection effect used in the application. By the way, credit for the beautiful pictures goes to <a href="http://www.flickr.com/photos/romainguy/">Romain</a>, my source for all of my, er, borrowed images.
</p>
<p>The video is in two parts (because YouTube thinks that I talk too much, so I had to split it). This first part introduces the show and talks about the effect at a high level:</p>
<object height="385" width="480"><param name="movie" value="http://www.youtube.com/v/N9xI5GQf4OA?fs=1&hl=en_US&rel=0"><param name="allowFullScreen" value="true"><param name="allowscriptaccess" value="always"><embed src="http://www.youtube.com/v/N9xI5GQf4OA?fs=1&hl=en_US&rel=0" type="application/x-shockwave-flash" allowscriptaccess="always" allowfullscreen="true" height="385" width="480"></embed></object>
<p>Part 2 dives into the code that makes the reflection effect work:</p>
<object height="385" width="480"><param name="movie" value="http://www.youtube.com/v/-wuDDbP6tBo?fs=1&hl=en_US&rel=0"><param name="allowFullScreen" value="true"><param name="allowscriptaccess" value="always"><embed src="http://www.youtube.com/v/-wuDDbP6tBo?fs=1&hl=en_US&rel=0" type="application/x-shockwave-flash" allowscriptaccess="always" allowfullscreen="true" height="385" width="480"></embed></object>
<p>The code in the video is a tad blurry (given the resolution of the video compared to the size of the IDE window), so here's the code from PictureView.java that I walk through for your reading pleasure (note that this code looks slightly different than that in the video due to formatting for a smaller line wrap. Also, the blurryBitmap image is now created to be only as high as the reflection height, as described in the comments):</p>
<pre>
private Bitmap getReflection(Bitmap bitmap) {
Bitmap reflection = reflections.get(bitmap);
if (reflection == null) {
// We're cropping the height of the reflection to 80
int reflectionH = 80;
reflection = Bitmap.createBitmap(bitmap.getWidth(),
reflectionH, Bitmap.Config.ARGB_8888);
Bitmap blurryBitmap = Bitmap.createBitmap(bitmap, 0,
bitmap.getHeight() - reflectionH,
bitmap.getWidth(), reflectionH);
// cheap and easy scaling algorithm; down-scale it, then
// upscale it. The filtering during the scale operations
// will blur the resulting image
blurryBitmap = Bitmap.createScaledBitmap(
Bitmap.createScaledBitmap(
blurryBitmap,blurryBitmap.getWidth() / 2,
blurryBitmap.getHeight() / 2, true),
blurryBitmap.getWidth(), blurryBitmap.getHeight(), true);
// This shader will hold a cropped, inverted,
// blurry version of the original image
BitmapShader bitmapShader = new BitmapShader(blurryBitmap,
TileMode.CLAMP, TileMode.CLAMP);
Matrix invertMatrix = new Matrix();
invertMatrix.setScale(1f, -1f);
invertMatrix.preTranslate(0, -reflectionH);
bitmapShader.setLocalMatrix(invertMatrix);
// This shader holds an alpha gradient
Shader alphaGradient = new LinearGradient(0, 0, 0, reflectionH,
0x80ffffff, 0x00000000, TileMode.CLAMP);
// This shader combines the previous two, resulting in a
// blurred, fading reflection
ComposeShader compositor = new ComposeShader(bitmapShader,
alphaGradient, PorterDuff.Mode.DST_IN);
Paint reflectionPaint = new Paint();
reflectionPaint.setShader(compositor);
// Draw the reflection into the bitmap that we will return
Canvas canvas = new Canvas(reflection);
canvas.drawRect(0, 0, reflection.getWidth(),
reflection.getHeight(), reflectionPaint);
}
return reflection;
}
</pre>
<p>And finally, <a href="https://sites.google.com/site/androidcontentfromchet/downloads/PicSure.zip">here's the Eclipse project</a> complete with source code, images, and everything you need to build and run the application. The app is targeted at Android 2.2 (Froyo) (and probably could work on earlier versions as well), so you should be able to run it on the emulator or any appropriate device. Note that it's just a demo and not really a full-featured photo viewer; it was written to demonstrate particular effects and techniques, not to be a real application.</p>
<p>Now that my New Year's resolution is fulfilled, I should go back to working on Android framework code...</p><div class="blogger-post-footer"><img width='1' height='1' src='https://blogger.googleusercontent.com/tracker/6843566830671277353-2516804979261934094?l=graphics-geek.blogspot.com' alt='' /></div>
|
|
| guid |
| Stomach Contents: Structure - struct |
|---|
| isPermaLink |
NO
|
| value |
tag:blogger.com,1999:blog-6843566830671277353.post-2516804979261934094
|
|
| link |
http://graphics-geek.blogspot.com/2011/01/video-reflections-on-android.html
|
| pubDate |
Tue, 04 Jan 2011 18:39:00 GMT
|
| title |
Video: Reflections on Android
|
|
| 19 |
| Stomach Contents: Structure - struct |
|---|
| author |
noreply@blogger.com (Chet Haase)
|
| category |
| Stomach Contents: Structure - array
|
|---|
| 1 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
animation
|
|
| 2 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
graphics
|
|
| 3 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
UI
|
|
| 4 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
android
|
|
| 5 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
presentation
|
|
| 6 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
conferences
|
|
|
| description |
| Stomach Contents: Structure - struct |
|---|
| value |
<p>Here are slides for two of the approximately 871 talks that Romain Guy and I gave at <a href="http://devoxx.com/">Devoxx</a> last month (and again at the <a href="http://www.sfandroid.org/">SF Android User Group</a> meeting a couple of days ago).</p>
<p>Videos of all of the Devoxx sessions are already posted on the excellent <a href="http://parleys.com">Parleys</a> site for a small subscription fee, and should be made freely available sometime in the next few months. You probably want to check out those videos for the complete details. But in case you were at the talks, are sick of listening to us speak, or simply want to peruse the slideware, here you go...</p>
<a href="https://sites.google.com/site/androidcontentfromchet/downloads/GraphicsandAnimations-Devoxx2010.pdf">
</a><p><a href="https://sites.google.com/site/androidcontentfromchet/downloads/GraphicsandAnimations-Devoxx2010.pdf">Android Graphics and Animation</a></p>
<p><a href="https://sites.google.com/site/androidcontentfromchet/downloads/UITipsTricksTechniques.pdf">Android UI Development: Tips, Tricks and Techniques</a></p><div class="blogger-post-footer"><img width='1' height='1' src='https://blogger.googleusercontent.com/tracker/6843566830671277353-4635971957214002526?l=graphics-geek.blogspot.com' alt='' /></div>
|
|
| guid |
| Stomach Contents: Structure - struct |
|---|
| isPermaLink |
NO
|
| value |
tag:blogger.com,1999:blog-6843566830671277353.post-4635971957214002526
|
|
| link |
http://graphics-geek.blogspot.com/2010/12/slides-from-recent-android.html
|
| pubDate |
Fri, 03 Dec 2010 00:40:00 GMT
|
| title |
Slides from Recent Android Presentations
|
|
| 20 |
| Stomach Contents: Structure - struct |
|---|
| author |
noreply@blogger.com (Chet Haase)
|
| category |
| Stomach Contents: Structure - array
|
|---|
| 1 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
flex
|
|
| 2 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
book
|
|
|
| description |
| Stomach Contents: Structure - struct |
|---|
| value |
<div style="float: right; text-align: right; font-style: italic;"><a href="http://www.artima.com/shop/flex_4_fun"><iframe src="http://rcm.amazon.com/e/cm?lt1=_blank&bc1=000000&IS2=1&bg1=FFFFFF&fc1=000000&lc1=0000FF&t=filriccli-20&o=1&p=8&l=as1&m=amazon&f=ifr&md=10FE9736YVPPT7A0FBG2&asins=0981531628" style="width: 120px; height: 240px;" marginwidth="0" marginheight="0" frameborder="0" scrolling="no"></iframe></a></div><p>By popular demand, <a style="font-style: italic;" href="http://www.artima.com/shop/flex_4_fun">Flex 4 Fun</a> is now available for the Kindle!</p><p>If you order the eBook on the <a href="http://www.artima.com/shop/flex_4_fun">Artima</a> site, you can download the Mobi as well as the PDF version. In fact, if you already bought the eBook, you can log into your Artima account and download the new Mobi version. Once you have the .mobi file, you can copy/email it to your Kindle device and start reading.</p><div class="blogger-post-footer"><img width='1' height='1' src='https://blogger.googleusercontent.com/tracker/6843566830671277353-2185101476684934558?l=graphics-geek.blogspot.com' alt='' /></div>
|
|
| guid |
| Stomach Contents: Structure - struct |
|---|
| isPermaLink |
NO
|
| value |
tag:blogger.com,1999:blog-6843566830671277353.post-2185101476684934558
|
|
| link |
http://graphics-geek.blogspot.com/2010/11/flex-4-fun-4-kindle.html
|
| pubDate |
Sat, 27 Nov 2010 14:59:00 GMT
|
| title |
Flex 4 Fun 4 Kindle
|
|
| 21 |
| Stomach Contents: Structure - struct |
|---|
| author |
noreply@blogger.com (Chet Haase)
|
| category |
| Stomach Contents: Structure - array
|
|---|
| 1 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
flex
|
|
| 2 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
android
|
|
| 3 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
presentation
|
|
| 4 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
conferences
|
|
|
| description |
| Stomach Contents: Structure - struct |
|---|
| value |
<p>I'm back from the annual <a href="http://devoxx.com/">Devoxx</a> conference, a fun and thoroughly exhausting week in Antwerp spent presenting, attending, and generally hanging out. It's always a great time, despite the weather and the overall grayscale cityscape.</p>
<p>This picture from the show was taken during one of my sessions when I was either talking about a GUI frame or saying hello to my Hawaiian friends.</p>
<a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="http://lh3.ggpht.com/_ZrYb6GjXXeM/TOUkXMEdc6I/AAAAAAAAKl0/Fkgt-NLyhH0/s800/DSC_0258.jpg"><img style="cursor: pointer; width: 400px; height: 266px;" src="http://lh3.ggpht.com/_ZrYb6GjXXeM/TOUkXMEdc6I/AAAAAAAAKl0/Fkgt-NLyhH0/s800/DSC_0258.jpg" alt="" border="0" /></a>
<p>I presented in several sessions, including 4 sessions with <a href="http://www.curious-creature.org/">Romain Guy</a> about Android and UI programming and one on topics from my book, <a href="http://artima.com/shop/flex_4_fun">Flex 4 Fun</a>. I spent most of the week either on stage or writing slides and demos to present on stage. There's nothing like procrastination to keep you busy at the last minute.</p>
<p>For anyone that missed the presentations, see below about their availability on <a href="http://parleys.com/">parleys.com</a>. We may also post the slides someday, although it's always better to get the full deal (slides+audio+video). Also, I intend to post a couple of the demos I showed in the Android talks (the Flex demos are already available on the book site).</p>
<p>The sessions this year were, as always, recorded and will be released on <a href="http://parleys.com/">parleys.com</a>, an excellent site for viewing presentations with lots of content from previous years as well as other developer forums. The talks are released incrementally during the year for free, or you can buy a subscription to view them all for 79 Euros. In fact, parleys just announced that the 2009 recordings are now all available and all free. The talks and the recordings are of very high quality, so you should check out the site..</p>
<p>Anyway, thanks to Stephan Janssen for another great conference. Shaka!</p><div class="blogger-post-footer"><img width='1' height='1' src='https://blogger.googleusercontent.com/tracker/6843566830671277353-4856394155187802781?l=graphics-geek.blogspot.com' alt='' /></div>
|
|
| guid |
| Stomach Contents: Structure - struct |
|---|
| isPermaLink |
NO
|
| value |
tag:blogger.com,1999:blog-6843566830671277353.post-4856394155187802781
|
|
| link |
http://graphics-geek.blogspot.com/2010/11/shaka-devoxx.html
|
| pubDate |
Sun, 21 Nov 2010 23:02:00 GMT
|
| title |
Shaka Devoxx
|
|
| 22 |
| Stomach Contents: Structure - struct |
|---|
| author |
noreply@blogger.com (Chet Haase)
|
| category |
| Stomach Contents: Structure - array
|
|---|
| 1 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
flex
|
|
| 2 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
flex 4
|
|
| 3 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
book
|
|
|
| description |
| Stomach Contents: Structure - struct |
|---|
| value |
<div style="float: right; text-align: right; font-style: italic;"><a href="http://www.artima.com/shop/flex_4_fun"><iframe src="http://rcm.amazon.com/e/cm?lt1=_blank&bc1=000000&IS2=1&bg1=FFFFFF&fc1=000000&lc1=0000FF&t=filriccli-20&o=1&p=8&l=as1&m=amazon&f=ifr&md=10FE9736YVPPT7A0FBG2&asins=0981531628" style="width: 120px; height: 240px;" marginwidth="0" marginheight="0" frameborder="0" scrolling="no"></iframe></a></div><a style="font-style: italic;" href="http://www.artima.com/shop/flex_4_fun">Flex 4 Fun</a> is finally, once again, in stock at <a href="http://www.amazon.com/gp/product/0981531628?ie=UTF8&tag=filriccli-20&linkCode=as2&camp=1789&creative=390957&creativeASIN=0981531628">Amazon.com</a><img src="http://www.assoc-amazon.com/e/ir?t=filriccli-20&l=as2&o=1&a=0981531628" alt="" style="border: medium none ! important; margin: 0px ! important;" border="0" height="1" width="1" />. It's been "Temporarily out of stock" for the past coupjle of weeks for reasons that escape me, but which are probably one of these two possibilities:
<ul><li>Amazon is really new at this business of selling books and is still learning how to keep appropriate amounts of inventory on-hand.</li><li>They lost all the copies they had and had to rewrite the book from scratch, based purely on the cover picture on their website. I hope their version is as gripping as the original.</li></ul>In any case, you can now order it in peace.
At the same time, they bumped the price a bit, to $26.60. This is <span style="font-style: italic;">fantastic</span> news, of course, for two reasons:
<ul><li>The book now costs just about a cup of coffee more than it used to on Amazon. This means that you may have to forego that cup when you read it, thus preventing unfortunate spills and mess.</li><li>Even better, the new price means that the book is just over Amazon's Free Shipping limit here in the U.S. That's probably the thing that a lot of you were waiting for in order to finally purchase it.</li></ul>So go ahead. It's ready. Now. Go.<div class="blogger-post-footer"><img width='1' height='1' src='https://blogger.googleusercontent.com/tracker/6843566830671277353-5144991727518292281?l=graphics-geek.blogspot.com' alt='' /></div>
|
|
| guid |
| Stomach Contents: Structure - struct |
|---|
| isPermaLink |
NO
|
| value |
tag:blogger.com,1999:blog-6843566830671277353.post-5144991727518292281
|
|
| link |
http://graphics-geek.blogspot.com/2010/10/amazon-restocks-massive-shelves.html
|
| pubDate |
Fri, 29 Oct 2010 14:44:00 GMT
|
| title |
Amazon Restocks Massive Shelves
|
|
| 23 |
| Stomach Contents: Structure - struct |
|---|
| author |
noreply@blogger.com (Chet Haase)
|
| category |
| Stomach Contents: Structure - array
|
|---|
| 1 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
flex
|
|
| 2 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
flex 4
|
|
| 3 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
presentation
|
|
| 4 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
book
|
|
|
| description |
| Stomach Contents: Structure - struct |
|---|
| value |
<div style="float: right; text-align: right; font-style: italic;"><a href="http://www.artima.com/shop/flex_4_fun"><iframe src="http://rcm.amazon.com/e/cm?lt1=_blank&bc1=000000&IS2=1&bg1=FFFFFF&fc1=000000&lc1=0000FF&t=filriccli-20&o=1&p=8&l=as1&m=amazon&f=ifr&md=10FE9736YVPPT7A0FBG2&asins=0981531628" style="width: 120px; height: 240px;" marginwidth="0" marginheight="0" scrolling="no" frameborder="0"></iframe></a></div><p>I'll be joining Jacob Surber from Adobe this week to speak to the local Flex user group, <a href="http://www.silvafug.org/">SilvaFUG</a> (which I think stands for "Silicon Valley Flex User Group." Or maybe it's "Silver and Fugly"). We'll be in San Francisco on Tuesday evening (the 12th) and San Jose on Thursday evening (the 14th).</p>
<p>The topic is "Fun with Flex Skinning." I'll start off with an overview of the visual aspects of Flex 4 (which, by bizarre coincidence, are <span style="font-style: italic;">exactly</span> the topics covered by <a style="font-style: italic;" href="http://www.artima.com/shop/flex_4_fun">Flex 4 Fun</a>. Funny how that worked out). Then I'll walk through an extended example of skinning a simple component to show how these visual elements are used to enable easy development of very custom-looking components. I promise there will be much more code than bullet-points. Jacob will then go into more detail about skinning, including possible workflows and tools for design and development of custom components.</p>
<p>More information about the events can be found on the <a href="http://www.silvafug.org/">SilvaFUG</a> site.</p>
<p>I hope to see you there; it should be a <s>Flex 4 </s>Fun evening. Both times.</p><div class="blogger-post-footer"><img width='1' height='1' src='https://blogger.googleusercontent.com/tracker/6843566830671277353-5240411828754994699?l=graphics-geek.blogspot.com' alt='' /></div>
|
|
| guid |
| Stomach Contents: Structure - struct |
|---|
| isPermaLink |
NO
|
| value |
tag:blogger.com,1999:blog-6843566830671277353.post-5240411828754994699
|
|
| link |
http://graphics-geek.blogspot.com/2010/10/speaking-of-flex.html
|
| pubDate |
Sat, 09 Oct 2010 15:16:00 GMT
|
| title |
Speaking of Flex...
|
|
| 24 |
| Stomach Contents: Structure - struct |
|---|
| author |
noreply@blogger.com (Chet Haase)
|
| category |
| Stomach Contents: Structure - array
|
|---|
| 1 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
flex
|
|
| 2 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
flex 4
|
|
| 3 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
book
|
|
|
| description |
| Stomach Contents: Structure - struct |
|---|
| value |
<div style="float: right; text-align: right; font-style: italic;"><a href="http://www.artima.com/shop/flex_4_fun"><iframe src="http://rcm.amazon.com/e/cm?lt1=_blank&bc1=000000&IS2=1&bg1=FFFFFF&fc1=000000&lc1=0000FF&t=filriccli-20&o=1&p=8&l=as1&m=amazon&f=ifr&md=10FE9736YVPPT7A0FBG2&asins=0981531628" style="width: 120px; height: 240px;" marginwidth="0" marginheight="0" scrolling="no" frameborder="0"></iframe></a></div><a style="font-style: italic;" href="http://www.artima.com/shop/flex_4_fun">Flex 4 Fun</a> is finally available for purchase at <a href="http://www.amazon.com/gp/product/0981531628?ie=UTF8&tag=filriccli-20&linkCode=as2&camp=1789&creative=390957&creativeASIN=0981531628">Amazon</a>. First, it went from looking like this on their site (with the depressing "Temporarily out of stock" message):<p><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="http://1.bp.blogspot.com/_l1oSIKeXdHo/TKCqF6tf_KI/AAAAAAAAAXs/oIUk2JRP9_E/s1600/Screen+shot+2010-09-19+at+12.04.43+PM.png"><img style="cursor: pointer; width: 400px; height: 121px;" src="http://1.bp.blogspot.com/_l1oSIKeXdHo/TKCqF6tf_KI/AAAAAAAAAXs/oIUk2JRP9_E/s400/Screen+shot+2010-09-19+at+12.04.43+PM.png" alt="" id="BLOGGER_PHOTO_ID_5521600161792392354" border="0" /></a></p><p>to looking like this, after they were finally ready to ship it out (I figure they probably wanted to dust off the copies first, then put them on the shelves to see <a href="http://graphics-geek.blogspot.com/2010/09/done-done-its-here.html">how nice they looked</a>):</p><p><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="http://1.bp.blogspot.com/_l1oSIKeXdHo/TKCsUDQuRxI/AAAAAAAAAYU/YjzLMl5AdMU/s1600/Screen+shot+2010-09-20+at+10.25.35+AM.png"><img style="cursor: pointer; width: 347px; height: 62px;" src="http://1.bp.blogspot.com/_l1oSIKeXdHo/TKCsUDQuRxI/AAAAAAAAAYU/YjzLMl5AdMU/s400/Screen+shot+2010-09-20+at+10.25.35+AM.png" alt="" id="BLOGGER_PHOTO_ID_5521602603629037330" border="0" /></a></p><p>Then for the past few days, the amount of stock appears to continuously change. In fact, they seem to have a hard time figuring out how much stock to keep on hand. Here are some screenshots from the Amazon page over the past few days. (Not that I've visited the site that many times or anything. After all, I already have a copy, so why would I need to? That would be silly.)
</p><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="http://3.bp.blogspot.com/_l1oSIKeXdHo/TKCsoHnoYJI/AAAAAAAAAY8/2GE3dTLtzhg/s1600/Screen+shot+2010-09-21+at+12.47.41+PM.png"><img style="cursor: pointer; width: 354px; height: 67px;" src="http://3.bp.blogspot.com/_l1oSIKeXdHo/TKCsoHnoYJI/AAAAAAAAAY8/2GE3dTLtzhg/s400/Screen+shot+2010-09-21+at+12.47.41+PM.png" alt="" id="BLOGGER_PHOTO_ID_5521602948396245138" border="0" /></a>
<a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="http://2.bp.blogspot.com/_l1oSIKeXdHo/TKCsn0R8zNI/AAAAAAAAAYs/ovAgU-Z2UIo/s1600/Screen+shot+2010-09-22+at+8.55.58+AM.png"><img style="cursor: pointer; width: 352px; height: 68px;" src="http://2.bp.blogspot.com/_l1oSIKeXdHo/TKCsn0R8zNI/AAAAAAAAAYs/ovAgU-Z2UIo/s400/Screen+shot+2010-09-22+at+8.55.58+AM.png" alt="" id="BLOGGER_PHOTO_ID_5521602943205035218" border="0" /></a>
<a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="http://1.bp.blogspot.com/_l1oSIKeXdHo/TKCsnYc5LkI/AAAAAAAAAYk/Hfm0JAhOy5E/s1600/Screen+shot+2010-09-22+at+10.02.14+AM.png"><img style="cursor: pointer; width: 349px; height: 68px;" src="http://1.bp.blogspot.com/_l1oSIKeXdHo/TKCsnYc5LkI/AAAAAAAAAYk/Hfm0JAhOy5E/s400/Screen+shot+2010-09-22+at+10.02.14+AM.png" alt="" id="BLOGGER_PHOTO_ID_5521602935734742594" border="0" /></a>
<a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="http://1.bp.blogspot.com/_l1oSIKeXdHo/TKCsnYxp98I/AAAAAAAAAYc/n6HoFsSdcLk/s1600/Screen+shot+2010-09-27+at+6.48.27+AM.png"><img style="cursor: pointer; width: 345px; height: 71px;" src="http://1.bp.blogspot.com/_l1oSIKeXdHo/TKCsnYxp98I/AAAAAAAAAYc/n6HoFsSdcLk/s400/Screen+shot+2010-09-27+at+6.48.27+AM.png" alt="" id="BLOGGER_PHOTO_ID_5521602935821825986" border="0" /></a>
<p>Get yours soon. Who knows when they're going to run out completely?</p><p>Oh, and don't forget about that free shipping for orders over $25 thing. Amazon toyed briefly with a price just over $26. And I mean briefly. I saw it at that price just once over the past two weeks. Now it's down at $24.39 (below the $24.93 price before it was in stock, in the first image above). Apparently the book is like pork bellies or flax futures and the price fluctuates with demand. Or their clerks just get the numbers transposed occasionally. Since it's so close to the free shipping limit of $25, you'll probably want to bundle it with another relevant, yet highly affordable book, like <a style="font-style: italic;" href="http://www.amazon.com/gp/product/1440466971?ie=UTF8&tag=filriccli-20&linkCode=as2&camp=1789&creative=390957&creativeASIN=1440466971">When I am King...</a>. I'm just saying....
</p><div class="blogger-post-footer"><img width='1' height='1' src='https://blogger.googleusercontent.com/tracker/6843566830671277353-373791510133228472?l=graphics-geek.blogspot.com' alt='' /></div>
|
|
| guid |
| Stomach Contents: Structure - struct |
|---|
| isPermaLink |
NO
|
| value |
tag:blogger.com,1999:blog-6843566830671277353.post-373791510133228472
|
|
| link |
http://graphics-geek.blogspot.com/2010/09/flex-4-fun-only-n-left-order-soon.html
|
| pubDate |
Mon, 27 Sep 2010 14:21:00 GMT
|
| title |
Flex 4 Fun: Only n left-- order soon!
|
|
| 25 |
| Stomach Contents: Structure - struct |
|---|
| author |
noreply@blogger.com (Chet Haase)
|
| category |
| Stomach Contents: Structure - array
|
|---|
| 1 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
flex
|
|
| 2 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
humor
|
|
| 3 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
flex 4
|
|
| 4 |
| Stomach Contents: Structure - struct |
|---|
| domain |
http://www.blogger.com/atom/ns#
|
| value |
book
|
|
|
| description |
| Stomach Contents: Structure - struct |
|---|
| value |
<p>I ran across <a href="http://www.artima.com/shop/flex_4_fun"><i>Flex 4 Fun</i></a> in the wild this weekend and managed to get some photographs. I thought that it might help you to understand how you might benefit from the book. Here are some ways that others have found it useful.</p>
<p>First of all, the book makes a lovely <em>objet d'art</em>, and was being displayed alongside other great works of art when I encountered it here:</p>
<p><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="http://4.bp.blogspot.com/_l1oSIKeXdHo/TIuvn5y_M2I/AAAAAAAAAWs/gdAlSTp9_Jo/s1600/P1050501-1.jpg"><img style="cursor:pointer; cursor:hand;width: 300px; height: 400px;" src="http://4.bp.blogspot.com/_l1oSIKeXdHo/TIuvn5y_M2I/AAAAAAAAAWs/gdAlSTp9_Jo/s400/P1050501-1.jpg" border="0" alt="" id="BLOGGER_PHOTO_ID_5515695268709741410" /></a></p>
<p>It also makes a nice decoration for some household areas, such as this aquarium:</p>
<p><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="http://3.bp.blogspot.com/_l1oSIKeXdHo/TIuv2iUTBLI/AAAAAAAAAXM/bO2snuzsAxc/s1600/P1050507-1.jpg"><img style="cursor:pointer; cursor:hand;width: 400px; height: 300px;" src="http://3.bp.blogspot.com/_l1oSIKeXdHo/TIuv2iUTBLI/AAAAAAAAAXM/bO2snuzsAxc/s400/P1050507-1.jpg" border="0" alt="" id="BLOGGER_PHOTO_ID_5515695520105039026" /></a></p>
<p>This person apparently found the code recipes useful in the kitchen:</p>
<p><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="http://2.bp.blogspot.com/_l1oSIKeXdHo/TIuvmUtf2fI/AAAAAAAAAWk/quVrQqAr-QI/s1600/P1050500-1.jpg"><img style="cursor:pointer; cursor:hand;width: 400px; height: 300px;" src="http://2.bp.blogspot.com/_l1oSIKeXdHo/TIuvmUtf2fI/AAAAAAAAAWk/quVrQqAr-QI/s400/P1050500-1.jpg" border="0" alt="" id="BLOGGER_PHOTO_ID_5515695241574734322" /></a></p>
<p>At 280+ pages, the book is a perfect size for some household tasks, such as leveling this piece of furniture:</p>
<p><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="http://2.bp.blogspot.com/_l1oSIKeXdHo/TIuv1xwlUoI/AAAAAAAAAW8/GDsJ-W6beN8/s1600/P1050503-1.jpg"><img style="cursor:pointer; cursor:hand;width: 400px; height: 300px;" src="http://2.bp.blogspot.com/_l1oSIKeXdHo/TIuv1xwlUoI/AAAAAAAAAW8/GDsJ-W6beN8/s400/P1050503-1.jpg" border="0" alt="" id="BLOGGER_PHOTO_ID_5515695507070341762" /></a></p>
<p>A good graphics algorithm is always music to the ears:</p>
<p><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="http://4.bp.blogspot.com/_l1oSIKeXdHo/TIuv1QtpSxI/AAAAAAAAAW0/9rfC3CTYpi4/s1600/P1050502-1.jpg"><img style="cursor:pointer; cursor:hand;width: 400px; height: 300px;" src="http://4.bp.blogspot.com/_l1oSIKeXdHo/TIuv1QtpSxI/AAAAAAAAAW0/9rfC3CTYpi4/s400/P1050502-1.jpg" border="0" alt="" id="BLOGGER_PHOTO_ID_5515695498199649042" /></a></p>
<p>This family apparently found the book more interesting to watch on a Friday night than television or a movie:</p>
<p> <a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="http://1.bp.blogspot.com/_l1oSIKeXdHo/TIuvkn89oLI/AAAAAAAAAWU/fsQyEHCqdyw/s1600/P1050495-1.jpg"><img style="cursor:pointer; cursor:hand;width: 400px; height: 300px;" src="http://1.bp.blogspot.com/_l1oSIKeXdHo/TIuvkn89oLI/AAAAAAAAAWU/fsQyEHCqdyw/s400/P1050495-1.jpg" border="0" alt="" id="BLOGGER_PHOTO_ID_5515695212380135602" /></a></p>
<p>And of course the book looks great on a bookshelf, where it fits naturally with both the great works of literature:</p>
<p><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="http://1.bp.blogspot.com/_l1oSIKeXdHo/TIuvlfXGJ8I/AAAAAAAAAWc/lIWVVIuPwDY/s1600/P1050497-1.jpg"><img style="cursor:pointer; cursor:hand;width: 400px; height: 300px;" src="http://1.bp.blogspot.com/_l1oSIKeXdHo/TIuvlfXGJ8I/AAAAAAAAAWc/lIWVVIuPwDY/s400/P1050497-1.jpg" border="0" alt="" id="BLOGGER_PHOTO_ID_5515695227253696450" /></a></p>
<p>and the less great works of children's literature:</p>
<p><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="http://1.bp.blogspot.com/_l1oSIKeXdHo/TIuv2PDHyXI/AAAAAAAAAXE/9xCg8nlGMOw/s1600/P1050504-1.jpg"><img style="cursor:pointer; cursor:hand;width: 400px; height: 300px;" src="http://1.bp.blogspot.com/_l1oSIKeXdHo/TIuv2PDHyXI/AAAAAAAAAXE/9xCg8nlGMOw/s400/P1050504-1.jpg" border="0" alt="" id="BLOGGER_PHOTO_ID_5515695514932726130" /></a></p>
<p>But the book won't stay on that kids' shelf for long:</p>
<p><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="http://3.bp.blogspot.com/_l1oSIKeXdHo/TIuv3ZdA4jI/AAAAAAAAAXU/1zoJmHb4j5A/s1600/P1050511-crop-1.jpg"><img style="cursor:pointer; cursor:hand;width: 400px; height: 328px;" src="http://3.bp.blogspot.com/_l1oSIKeXdHo/TIuv3ZdA4jI/AAAAAAAAAXU/1zoJmHb4j5A/s400/P1050511-crop-1.jpg" border="0" alt="" id="BLOGGER_PHOTO_ID_5515695534905549362" /></a></p>
<p><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="http://4.bp.blogspot.com/_l1oSIKeXdHo/TIv0Zy4fCuI/AAAAAAAAAXk/5mihi_WUCP4/s1600/P1050512.jpg"><img style="cursor:pointer; cursor:hand;width: 400px; height: 300px;" src="http://4.bp.blogspot.com/_l1oSIKeXdHo/TIv0Zy4fCuI/AAAAAAAAAXk/5mihi_WUCP4/s400/P1050512.jpg" border="0" alt="" id="BLOGGER_PHOTO_ID_5515770892637899490" /></a></p>
<p>Even the family pet may enjoy the book - everyone wants to be an RIA developer:</p>
<p>
<a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="http://3.bp.blogspot.com/_l1oSIKeXdHo/TIuvjsizRDI/AAAAAAAAAWM/bzPJ6mggONM/s1600/P1050494-1.jpg"><img style="cursor:pointer; cursor:hand;width: 400px; height: 300px;" src="http://3.bp.blogspot.com/_l1oSIKeXdHo/TIuvjsizRDI/AAAAAAAAAWM/bzPJ6mggONM/s400/P1050494-1.jpg" border="0" alt="" id="BLOGGER_PHOTO_ID_5515695196432712754" /></a></p>
<p>And finally, this Flex developer was so excited by the book's arrival that he bought two:</p>
<a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="http://2.bp.blogspot.com/_l1oSIKeXdHo/TIuv7ixO3FI/AAAAAAAAAXc/PpB4YGKJ9qU/s1600/Truman.jpg"><img src="http://2.bp.blogspot.com/_l1oSIKeXdHo/TIuv7ixO3FI/AAAAAAAAAXc/PpB4YGKJ9qU/s400/Truman.jpg" alt="" border="0" id="BLOGGER_PHOTO_ID_5515695606125747282" style="cursor:pointer; cursor:hand;width: 400px; height: 300px;" /></a>
<p>As you can see, there are plenty of uses for the book. What will you do with yours?</p><div class="blogger-post-footer"><img width='1' height='1' src='https://blogger.googleusercontent.com/tracker/6843566830671277353-3412750691648339011?l=graphics-geek.blogspot.com' alt='' /></div>
|
|
| guid |
| Stomach Contents: Structure - struct |
|---|
| isPermaLink |
NO
|
| value |
tag:blogger.com,1999:blog-6843566830671277353.post-3412750691648339011
|
|
| link |
http://graphics-geek.blogspot.com/2010/09/book-montage.html
|
| pubDate |
Sat, 11 Sep 2010 16:27:00 GMT
|
| title |
Book Montage
|
|
|
