Documentation Index
Fetch the complete documentation index at: https://mintlify.com/toxicity188/BetterModel/llms.txt
Use this file to discover all available pages before exploring further.
Overview
The ModelScaler interface defines how a model’s scale is calculated. Scalers can be constant values, derived from entity attributes, or composites of multiple scalers. They are serializable to JSON for configuration purposes.
Interface Definition
public sealed interface ModelScaler
Core Methods
name()
Returns the name of this scaler type.
Returns: The scaler type name (e.g., “default”, “entity”, “value”, “composite”)
scale()
Calculates the scale for a given tracker.
float scale(@NotNull Tracker tracker)
tracker - The tracker instance to calculate scale for
Returns: The calculated scale factor
data()
Returns the configuration data for this scaler as a JSON element.
@Nullable JsonElement data()
Static Factory Methods
defaultScaler()
Returns the default scaler (constant 1.0).
static @NotNull ModelScaler defaultScaler()
ModelScaler scaler = ModelScaler.defaultScaler();
float scale = scaler.scale(tracker); // Always 1.0
entity()
Returns a scaler that uses the entity’s scale attribute.
static @NotNull ModelScaler entity()
ModelScaler scaler = ModelScaler.entity();
float scale = scaler.scale(tracker); // Returns entity's scale attribute
value()
Returns a constant value scaler.
static @NotNull ModelScaler value(float value)
value - The constant scale value
Returns: A scaler that always returns the specified value
Example:
ModelScaler scaler = ModelScaler.value(2.0f);
float scale = scaler.scale(tracker); // Always 2.0
composite()
Creates a composite scaler that multiplies the results of multiple scalers.
static @NotNull ModelScaler composite(@NotNull ModelScaler... scalers)
scalers - The scalers to combine
Returns: A composite scaler that multiplies all child scaler results
Example:
ModelScaler base = ModelScaler.value(2.0f);
ModelScaler entity = ModelScaler.entity();
ModelScaler combined = ModelScaler.composite(base, entity);
// Result: 2.0 * entity.scale
deserialize()
Deserializes a scaler from a JSON object.
static @NotNull ModelScaler deserialize(@NotNull JsonObject element)
element - The JSON object containing scaler configuration
Returns: The deserialized scaler, or the default scaler if invalid
Example:
JsonObject json = new JsonObject();
json.addProperty("name", "value");
json.addProperty("data", 1.5);
ModelScaler scaler = ModelScaler.deserialize(json);
Instance Methods
multiply()
Multiplies this scaler by a constant value.
default @NotNull ModelScaler multiply(float value)
ModelScaler entity = ModelScaler.entity();
ModelScaler doubled = entity.multiply(2.0f);
// Result: entity.scale * 2.0
composite()
Multiplies this scaler by another scaler.
default @NotNull ModelScaler composite(@NotNull ModelScaler scaler)
scaler - The other scaler to multiply with
Returns: A new composite scaler
Example:
ModelScaler base = ModelScaler.value(1.5f);
ModelScaler entity = ModelScaler.entity();
ModelScaler combined = base.composite(entity);
// Result: 1.5 * entity.scale
serialize()
Serializes this scaler to a JSON object.
default @NotNull JsonObject serialize()
ModelScaler scaler = ModelScaler.value(2.0f);
JsonObject json = scaler.serialize();
// {"name": "value", "data": 2.0}
Nested Interfaces
Getter
Functional interface for calculating scale values.
interface Getter {
float get(@NotNull Tracker tracker);
static @NotNull Getter value(float value);
}
DEFAULT - Returns 1.0ENTITY - Returns entity scale attribute
Builder
Builder interface for creating Getters from JSON.
interface Builder {
@Nullable Getter build(@NotNull JsonElement data);
}
Usage Example
import kr.toxicity.model.api.tracker.ModelScaler;
import kr.toxicity.model.api.tracker.Tracker;
// Create a constant scaler
ModelScaler constant = ModelScaler.value(1.5f);
// Create an entity-based scaler
ModelScaler entityScaler = ModelScaler.entity();
// Combine multiple scalers
ModelScaler combined = ModelScaler.composite(
ModelScaler.value(2.0f),
ModelScaler.entity()
);
// Or use the fluent API
ModelScaler fluent = ModelScaler.entity()
.multiply(1.5f)
.composite(ModelScaler.value(0.8f));
// Calculate scale for a tracker
float scale = combined.scale(tracker);
// Serialize to JSON
JsonObject json = combined.serialize();
// Deserialize from JSON
ModelScaler loaded = ModelScaler.deserialize(json);
{
"name": "value",
"data": 2.0
}
{
"name": "composite",
"data": [
{"name": "entity"},
{"name": "value", "data": 1.5}
]
}
Extending ModelScaler
You can register custom scaler types using the Deserializer:
ModelScaler.DESERIALIZER.addScaler("custom", data -> {
// Custom logic to build a Getter from JSON data
return tracker -> {
// Custom scale calculation
return 1.0f;
};
});
See Also
