ModelScaler

Defines how a model’s scale is calculated

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.

@NotNull String name()

Returns: The scaler type name (e.g., “default”, “entity”, “value”, “composite”)

scale()

Calculates the scale for a given tracker.

float scale(@NotNull Tracker tracker)

Parameters:

• 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()

Returns: The configuration data, or null if none

Static Factory Methods

defaultScaler()

Returns the default scaler (constant 1.0).

static @NotNull ModelScaler defaultScaler()

Returns: A scaler that always returns 1.0

Example:

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()

Returns: A scaler based on entity scale

Example:

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)

Parameters:

• 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)

Parameters:

• 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)

Parameters:

• 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)

Parameters:

• value - The multiplier

Returns: A new composite scaler

Example:

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)

Parameters:

• 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()

Returns: The JSON representation of this scaler

Example:

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);
}

Constants:

• DEFAULT - Returns 1.0
• ENTITY - 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);

JSON Format

Scalers are serialized using the following JSON format:

{
  "name": "value",
  "data": 2.0
}

For composite scalers:

{
  "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

• ModelRotation - For rotating models
• Tracker - For tracking model state