Computer graphics using Java 2D and 3D (Liang, Y. Daniel Zhang, Hong)（Z-Library）

【One-Line Pitch】 A practical, code-first handbook for Java developers who want to master both 2D and 3D computer graphics, covering everything from basic drawing primitives to scene graphs, lighting, and animation. Ideal for programmers, engineers, and game developers who prefer Java over lower-level graphics APIs. 【Book Arc】 - **Opening (~0%–10%)**: Introduces computer graphics fundamentals, hardware (CRT/LCD, graphics boards), and the Java graphics ecosystem (AWT, Swing, JOGL, Java 3D). Includes a low-level assembly example for drawing circles, contrasting with high-level Java approaches. - **Early (~10%–23%)**: Dives into Java 2D basics—Graphics2D, Shape objects (Rectangle, Ellipse, Arc, QuadCurve, CubicCurve, Polygon), and GeneralPath for building complex paths. Covers mouse interaction and menu-driven drawing applications. - **Early (~23%–32%)**: Explores rendering details: color spaces (RGB, CMYK, CIEXYZ), Paint interface (Color, GradientPaint, TexturePaint), Stroke/BasicStroke settings, affine transformations, Porter–Duff compositing rules, clip paths, and font/glyph handling. - **Middle (~32%–48%)**: Advances 2D techniques with interactive transformations (translation, rotation, scaling, shearing, reflection) via AffineTransform, plus image processing (MediaTracker, BufferedImage). Introduces curve mathematics—B-spline to Bézier conversion for smooth paths. - **Late (~48%–100%)**: Transitions to 3D with Java 3D API: scene graphs, nodes, node components, rendering pipeline, backgrounds/bounds, and capability bits. Covers geometry (points, vectors, primitives), 3D affine transformations, view models (projections, picking, head tracking), lighting models, texturing, and animation. 【Key Takeaways】 - **Java 2D separates modeling from rendering** (Early): Create Shape objects (Ellipse2D, GeneralPath) and render them via Graphics2D.draw()/fill(), enabling reusable, transformable geometry. This OOP approach contrasts with low-level APIs like OpenGL. - **AffineTransform is the core of 2D manipulation** (Middle): Master translation, rotation, scaling, shearing, and reflection—all unified in one class. Interactive examples show real-time shape transformation via mouse drags, essential for building responsive graphics apps. - **Porter–Duff rules control compositing** (Middle): Twelve rules (e.g., SRC_OVER) determine how overlapping objects blend. Java 2D supports these via AlphaComposite, but note the screen's implicit alpha=1.0 limits some rules' visual impact. - **Clip paths enable creative rendering** (Middle): Use font glyphs as clipping shapes to confine drawing (e.g., 2000 random ellipses inside the word "Java"). This technique combines typography with graphics for striking visual effects. - **Curves require mathematical conversion** (Middle): B-spline curves are converted to cubic Bézier segments for rendering via GeneralPath. Understanding control point formulas is key for smooth, editable paths in drawing tools. - **Java 3D uses scene graphs, not immediate mode** (Late): Build a hierarchical graph of nodes (geometry, appearance, transforms) instead of issuing drawing commands. This declarative model simplifies complex scenes but requires learning capability bits for runtime modifications. - **Views and lighting are separate concerns in 3D** (Late): Projections, view specifications, picking, and head tracking are handled by the view model, while lights, illumination models, and texture mapping affect appearance—decoupling these simplifies scene design. 【Reading Tips】 - **Skim the opening hardware/assembly sections** (~0%–10%): They provide historical context but are not essential for Java practice. Focus on the Java API overview and key class summaries at chapter ends. - **Deep-read the 2D rendering chapters** (~23%–32%): Color, stroke, transform, and compositing details are foundational. Run the interactive examples (e.g., compositing rules, clipping) to see effects live. - **Practice the transformation examples** (~32%–42%): The mouse-driven transform code is the best way to internalize AffineTransform. Modify the code to add new shapes or transform types. - **Treat the B-spline math as optional** (~48%): If you're not building drawing tools, skim the formulas and focus on the GeneralPath rendering result. The image processing section is more broadly useful. - **For 3D, start with the scene graph structure** (~48%–60%): Understand nodes vs. node components before diving into lighting/texturing. The later chapters build on this architecture, so a solid grasp here pays off. 【Coverage Limits】 Excerpts cover roughly the first half of the book (2D thoroughly, 3D up to lighting/texturing). The final chapters on behavior, interaction, and animation are not sampled, so those topics are not addressed in this guide.