rockgen.py

        name="Y skew",
        description="Y Skew ratio. 0.5 is no skew.",
        min=-1.0, max=1.0, default=defaults[5])
    scale_Z: FloatVectorProperty(
        name="Z scale",
        description="Z axis scaling range.",
        min=0.0, max=256.0, step=1,
        default=defaults[3], size=2)
    skew_Z: FloatProperty(
        name="Z skew",
        description="Z Skew ratio. 0.5 is no skew.",
        min=-1.0, max=1.0, default=defaults[6])
    use_scale_dis: BoolProperty(
        name="Scale displace textures",
        description="Scale displacement textures with dimensions.  May cause streched textures.",
        default=defaults[7])
    scale_fac: FloatVectorProperty(
        name="Scaling Factor",
        description="XYZ scaling factor.  1: no scaling.",
        min=0.0001, max=256.0, step=0.1,
        default=defaults[8], size=3)

    # @todo Possible to title this section "Physical Properties:"?
    deform: FloatProperty(
        name="Deformation",
        description="Rock deformation",
        min=0.0, max=1024.0, default=defaults[9])
    rough: FloatProperty(
        name="Roughness",
        description="Rock roughness",
        min=0.0, max=1024.0, default=defaults[10])
    detail: IntProperty(
        name="Detail level",
        description="Detail level.  WARNING: Slow at high values!",
        min=1, max=1024, default=defaults[11])
    display_detail: IntProperty(
        name="Display Detail",
        description="Display detail.  Use a lower value for high numbers of rocks.",
        min=1, max=128, default=defaults[12])
    smooth_fac: FloatProperty(
        name="Smooth Factor",
        description="Smoothing factor.  A value of 0 disables.",
        min=0.0, max=128.0, default=defaults[13])
    smooth_it: IntProperty(
        name="Smooth Iterations",
        description="Smoothing iterations.  A value of 0 disables.",
        min=0, max=128, default=defaults[14])

    use_generate: BoolProperty(
        name="Generate Rocks",
        description="Enable actual generation.",
        default=defaults[15])
    use_random_seed: BoolProperty(
        name="Use a random seed",
        description="Create a seed based on time. Causes user seed to be ignored.",
        default=defaults[16])
    user_seed: IntProperty(
        name="User seed",
        description="Use a specific seed for the generator.",
        min=0, max=1048576, default=defaults[17])

    def draw(self, context):
        layout = self.layout
        box = layout.box()
        box.prop(self, 'num_of_rocks')
        box = layout.box()
        box.prop(self, 'scale_X')
        box.prop(self, 'skew_X')
        box.prop(self, 'scale_Y')
        box.prop(self, 'skew_Y')
        box.prop(self, 'scale_Z')
        box.prop(self, 'skew_Z')
        box.prop(self, 'use_scale_dis')
        if self.use_scale_dis:
            box.prop(self, 'scale_fac')
        else:
            self.scale_fac = utils.toFloats(self.defaults[8])
        box = layout.box()
        box.prop(self, 'deform')
        box.prop(self, 'rough')
        box.prop(self, 'detail')
        box.prop(self, 'display_detail')
        box.prop(self, 'smooth_fac')
        box.prop(self, 'smooth_it')

        box = layout.box()
        box.prop(self, 'use_generate')
        box.prop(self, 'use_random_seed')
        if not self.use_random_seed:
            box.prop(self, 'user_seed')
        box.prop(self, 'preset_values')

    @classmethod
    def poll(cls, context):
        return context.mode == 'OBJECT'
        # return (context.object is not None and context.object.mode == 'OBJECT')

    def execute(self, context):

        # The following "if" block loads preset values:
        if self.lastPreset != int(self.preset_values):
            self.scale_X = utils.toFloats(self.presetsList[int(self.preset_values)][1])
            self.scale_Y = utils.toFloats(self.presetsList[int(self.preset_values)][2])
            self.scale_Z = utils.toFloats(self.presetsList[int(self.preset_values)][3])
            self.skew_X = float(self.presetsList[int(self.preset_values)][4])
            self.skew_Y = float(self.presetsList[int(self.preset_values)][5])
            self.skew_Z = float(self.presetsList[int(self.preset_values)][6])
            self.use_scale_dis = bool(self.presetsList[int(self.preset_values)][7])
            self.scale_fac = utils.toFloats(self.presetsList[int(self.preset_values)][8])
            self.deform = float(self.presetsList[int(self.preset_values)][9])
            self.rough = float(self.presetsList[int(self.preset_values)][10])
            self.detail = int(self.presetsList[int(self.preset_values)][11])
            self.display_detail = int(self.presetsList[int(self.preset_values)][12])
            self.smooth_fac = float(self.presetsList[int(self.preset_values)][13])
            self.smooth_it = int(self.presetsList[int(self.preset_values)][14])
            self.use_generate = bool(self.presetsList[int(self.preset_values)][15])
            self.use_random_seed = bool(self.presetsList[int(self.preset_values)][16])
            self.user_seed = int(self.presetsList[int(self.preset_values)][17])
            self.lastPreset = int(self.preset_values)

        # todo Add deform, deform_Var, rough, and rough_Var:
        #   *** todo completed 4/23/2011 ***
        #   *** Eliminated "deform_Var" and "rough_Var" so the script is not
        #       as complex to use.  May add in again as advanced features. ***
        if self.use_generate:
            generateRocks(context,
                          self.scale_X,
                          self.skew_X,
                          self.scale_Y,
                          self.skew_Y,
                          self.scale_Z,
                          self.skew_Z,
                          self.scale_fac,
                          self.detail,
                          self.display_detail,
                          self.deform,
                          self.rough,
                          self.smooth_fac,
                          self.smooth_it,
                          self.num_of_rocks,
                          self.user_seed,
                          self.use_scale_dis,
                          self.use_random_seed)

        return {'FINISHED'}


# Register:
def menu_func_rocks(self, context):
    self.layout.operator(
        OBJECT_OT_add_mesh_rock.bl_idname,
        text="Rock Generator",
        icon="PLUGIN")


classes = (
    OBJECT_OT_add_mesh_rock,
)


def register():
    from bpy.utils import register_class
    for cls in classes:
        register_class(cls)
    bpy.types.VIEW3D_MT_mesh_add.append(menu_func_rocks)


def unregister():
    from bpy.utils import unregister_class
    for cls in reversed(classes):
        unregister_class(cls)
    bpy.types.VIEW3D_MT_mesh_add.remove(menu_func_rocks)


if __name__ == "__main__":
    register()