Source code
/* Copyright (C) 2000 by Peter Eastman
This program is free software; you can redistribute it and/or modify it under the
terms of the GNU General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
PARTICULAR PURPOSE. See the GNU General Public License for more details. */
package artofillusion.material;
import artofillusion.object.*;
/** Material3D represents a Material whose properties are defined in 3D. */
public abstract class Material3D extends Material
{
/** Get the properties at point (x, y, z) at time t. More precisely, the properties
returned should represent an average over a region of width (xsize, ysize, zsize),
which is centered at (x, y, z). */
public abstract void getMaterialSpec(MaterialSpec spec, double x, double y, double z, double xsize, double ysize, double zsize, double t);
/** The default mapping is a LinearMaterialMapping. */
public MaterialMapping getDefaultMapping(Object3D obj)
{
return new LinearMaterialMapping(obj, this);
}
}
Run 1
The code is highly readable: it has a clear single responsibility (defining a 3D material interface), flat structure with no nesting, and concise but complete Javadoc comments. Class and method names are expressive ('Material3D', 'getMaterialSpec', 'getDefaultMapping'), and each statement or declaration is on its own line. The abstract method signature, though long, is documented clearly and follows a logical parameter order. The default mapping method is trivial and self-explanatory. Minor deductions: the abstract method has many parameters (potential readability burden for callers), and the class could include an example or usage note, but this does not significantly hurt clarity.
Run 2
The code is highly readable with clear structure: license header, package declaration, imports, class definition, and methods are logically organized. Nesting is minimal—only one method override exists with a single return statement. Intent is clearly conveyed through descriptive Javadoc comments explaining the abstract method's purpose and the default mapping behavior. Code length is concise and appropriate for the functionality. Action granularity is good, with one primary action per line. Reading flow is natural, following standard Java conventions. Minor deductions: the abstract method has seven parameters which could be encapsulated, and the class documentation could be slightly more descriptive, but these are negligible issues.
Run 3
The code is highly readable. It has a clear, logical structure with a single abstract class containing one abstract method and one concrete method. Nesting is minimal—only one class-level block and no conditional or loop nesting. Intent is explicit through descriptive naming and concise Javadoc comments that explain both the purpose of the class and the semantics of the method parameters. Code length is appropriate: there is no redundancy or unnecessary boilerplate. Each line performs one clear action, and the reading flow is natural, moving from package declaration to class definition, then method declarations in logical order. The only minor improvements could be formatting the parameter list of getMaterialSpec for vertical alignment, but this does not meaningfully impact readability.
Run 1
Code Structure: The small abstract class is logically organized, with documentation followed by two related methods. Nesting: Minimal nesting makes the code easy to scan. Clarity of intent: Class and method comments clearly explain the material's purpose, spatial averaging, and default mapping; descriptive names reinforce intent. Code length: Concise implementation with no unnecessary logic, though the abstract method signature is long. Action granularity: Each declaration or statement performs a single action. Reading flow: The sequence from class purpose to material specification and default mapping is natural. Wrapping the long signature and documenting the output parameter and time argument would slightly improve readability.
Run 2
Code Structure: A small, logically organized abstract class separates the material-specification contract from the default mapping implementation. Nesting: Minimal; the only implemented method contains a single return statement. Clarity of intent: Descriptive class and method names plus documentation clearly explain the purpose and spatial averaging behavior, although the output parameter spec is not explicitly documented. Code length: Concise, with no unnecessary implementation; the license header is standard boilerplate. Action granularity: Each statement performs one action, though the long abstract method declaration packs many parameters onto one line. Reading flow: Natural progression from class documentation to abstract contract to default implementation. Wildcard imports and the dense parameter list slightly reduce readability.
Run 3
Code Structure: A well-organized abstract class with two clearly separated methods. Nesting: Minimal, with no nested control flow. Clarity of intent: Class and method documentation clearly explain the material abstraction, spatial averaging, and default mapping; the many positional double parameters slightly reduce immediate clarity. Code length: Concise implementation with no unnecessary logic; the lengthy license header is standard boilerplate. Action granularity: The concrete method performs a single action per line, and the abstract declaration is straightforward. Reading flow: Natural progression from package and imports to class documentation and methods, though the long getMaterialSpec declaration and wildcard import modestly impair readability.