safina3d

Create your first C4D plugin

2019-10-31T01:11:00.017+01:00

The main purpose of this tutorial is to explain the process of creating Cinema 4D plugins. Object generator plugins (ObjectData) are a good starting point, as they are easy to understand and develop. This tutorial will show you how to create a 3D Torus Knot generator from scratch using Python.

It's important to note that in real-world projects, plugin creation is not always straightforward. We often go through a prototyping phase by doing a POC (proof of concept) to check the feasibility of our idea. This allows us to quickly test and only after that, we can begin developing the plugin.

The TorusKnot plugin for Cinema 4D allows you to generate splines in the shape of a torus knot. It uses the following mathematical properties to calculate the points of the spline:

The variable t, which defines the position of each point on the spline. This variable can range from MIN_T to MAX_T, with a T_STEP interval between each value used.
The radii R and r, which determine the general shape of the torus knot. R corresponds to KNOT_PARAM_R0, and r corresponds to KNOT_PARAM_R1.
The parameter n, which determines the number of turns of the spline. The higher this number is, the more turns the spline will have.

By using these parameters, the TorusKnot plugin allows you to generate splines in the shape of a torus knot in a simple and fast way, offering many possibilities for creating complex 3D shapes in Cinema 4D.

Some useful links

How to install python 3rd party library in Cinema 4D ?

2019-10-02T03:53:00.013+02:00

Update (For R21 and +)

	1- Download https://bootstrap.pypa.io/get-pip.py.
	2- Download the c4dpy version matching your Cinema 4D version. (Already included in R21 and +)
	3- Move c4dpy and get-pip.py in the Cinema 4D folder.
	4- Open a shell to the Cinema 4D folder:
		|_ Window: Type cmd in the top path and press Enter.
		|_ Mac: Open a new shell, then with cd navigate to your Cinema 4D folder. (You can drag and drop the path).
	5- Run this command line c4dpy get-pip.py. This will execute the get-pip script which will, download and install the pip module.
	6- Now you can start to play with pip c4dpy -m pip install pygame. c4dpy allow to runs any module with the -m argument see c4dpy commandline.

Source: plugincafe

    1- Go to Cinema 4D python's directory
    2- If "pip" is not installed yet, download the get-pip.py file from https://bootstrap.pypa.io/get-pip.py
    3- Install pip (command line): .\python get-pip.py 
    4- Install pygame : .\python -m pip install pygame

Measure the execution time of a script

2019-03-26T07:40:00.002+01:00

Sometimes we have to choose between several algorithms that have the same goal. Performance and therefore the execution time can be considered as a good criterion, although there are many others. For that the best solution would be to use a profiling tool, but if you want a quick solution we can simply calculate the difference of time between the beginning and the end of each algorithm.

In python, for ease and clarity of use, we can write this as a custom decorator and call it anywhere in our script.

To use this decorator :

Add the following snippet to your source code
Add the @measure() annotation above the function's signature that you want to test

def measure(iterations=1):
    """
    This decorator allows you to print the average execution time of a function
    :param iterations: number of times that function will be called
    """
    import time

    def decorator(fn):

        def wrapper(*args, **kwargs):
            _sum = 0.0
            _result = None
            for i in xrange(iterations):
                _start = time.time()
                _result = fn(*args, **kwargs)
                _sum += time.time() - _start

            print '"%s" Function called %s time(s). Average execution time: %f sec' % (fn.__name__, iterations, _sum / iterations)
            return _result

        return wrapper

    return decorator

Example

@measure()
def my_function():
    ...

The tested function is called once, but we can increase the number of iterations to get a more precise value. this can be achieved by changing the value of the decorator's argument

@measure(1000)
def my_function():
    ...

Example of use

Let's say we have a scene containing 2000 different objects and we want to sort them (in the object manager) by type, and by name (if they have the same type).

In the following source code we test 3 sorting algorithms:

Python default sort algorithm (Timsort)
The Insertion sort
The Bubble sort

the goal is to know which one is the fastest.

import c4d


def measure(iterations=1):
    """
    This decorator allows you to print the average execution time of a function
    :param iterations: number of times that function will be called
    :return: fn
    """
    import time

    def decorator(fn):
        def wrapper(*args, **kwargs):
            _sum = 0.0
            _result = None
            for i in xrange(iterations):
                _start = time.time()
                _result = fn(*args, **kwargs)
                _sum += time.time() - _start

            print '"%s" Function called %s time(s). Average execution time: %f sec' % (fn.__name__, iterations, _sum / iterations)
            return _result
        return wrapper
    return decorator


def gt(a, b):
    """ Checks that A value is greater than B """
    type_a = a.GetType()
    type_b = b.GetType()
    
    if type_a == type_b:
        return a.GetName() > b.GetName()
    
    return a.GetType() > b.GetType()


def insertion_sort(array):
    """ This function allows you to sort an array using the insertion sort algorithm """
    count = len(array)
    for i in xrange(count):
        current_value = array[i]
        pos = i
        while pos > 0 and gt(array[pos - 1], current_value):
            array[pos] = array[pos - 1]
            pos = pos - 1
        array[pos] = current_value
    return array


def bubble_sort(array):
    """ This function allows you to sort an array using the bubble sort algorithm """
    def swap(a, b):
        array[a], array[b] = array[b], array[a]

    count = len(array)
    swapped = True
    idx = -1
    while swapped:
        swapped = False
        idx = idx + 1
        for i in xrange(1, count - idx):
            if gt(array[i - 1], array[i]):
                swap(i - 1, i)
                swapped = True
                    
    return array


def _cmp(obj_a, obj_b):    
    return cmp(obj_a.GetType(), obj_b.GetType()) or cmp(obj_a.GetName(), obj_b.GetName())


def update_manager(doc, object_list):
    """ Updates all objects position in the object manager """
    doc.StartUndo()    
    for obj in object_list:
        doc.AddUndo(c4d.UNDOTYPE_CHANGE, obj)
        obj.Remove()
        doc.InsertObject(obj, None, None)
    
    doc.EndUndo()


@measure()
def main():

    obj = doc.GetFirstObject()
    if not obj: return
    
    objects = [obj]
    obj = obj.GetNext()
    while obj:
        objects.append(obj)
        obj = obj.GetNext()

    # Default sorting
    objects.sort(cmp=_cmp)

    # Insertion sorting
    # objects = insertion_sort(objects)

    # Bubble sorting
    # objects = bubble_sort(objects)

    objects.reverse()
    update_manager(doc, objects)
    
    c4d.EventAdd()


if __name__ == '__main__':
    main()

The results

Random Vertex Color

2018-01-26T22:54:00.010+01:00

RandomVertexColor is a Python script for Cinema 4D R18 and higher, designed to assign random colors to connected vertices using the Vertex Color Tag.

The script utilizes the vertex color tag associated with the selected object; if none exists, it creates a new one. Subsequently, random colors are applied to each connected chunk of vertices.

Installation:

Download the RandomVertexColor.py script.
Copy the script to the Cinema 4D scripts directory:

On Windows: C:\Program Files\MAXON\Cinema 4D RXX\library\scripts
On macOS: /Applications/MAXON/Cinema 4D RXX/library/scripts

How to Use:

Select your polygon object.
Execute the RandomVertexColor script by selecting it from the script menu or pressing the Execute button in the script manager.

ChangeLog:

V1.2
- Optimized performance
- Added detailed documentation and type hints
V1.1
- Code refactoring
- R23 support added

Game of life

2018-01-01T06:38:00.005+01:00

Another programming classic : Game Of Life (Cellular Automata family).

Game of life is not a game and has nothing to do with life. but where it gets interesting, is in the fact that you can build complexe patterns whith different behaviours only with very simple rules.

The original Game of life rules (for a 2D space) are:

Each cell with one or no neighbors dies, as if by solitude.
Each cell with more than three neighbors dies, as if by overpopulation.
Each cell with two or three neighbors survives.
Any dead cell with exactly three live neighbours becomes a live cell, as if by reproduction.

In this script (Xpresso python node) I tried to create 3D version of Game of life with the possibility to have dynamic rules. You can start with some rules and change them right in the middle of your simulation.

It's a is time based animation. Every frame, new calculations are done and there is no bounderies for your final shape. as far as your rules allows expansion of your pattern and your PC can handle it :)

Download Game of life project file

To create your own simulation, you have to :

Define a set of starting points (see fill_grid method in source code)
Set up your simulation rules
Press play button to start simulation

Source code


import c4d
from c4d import documents, Vector
from collections import defaultdict


class MultidimensionalDictionary:

    def __init__(self):
        self.cells = defaultdict(lambda: defaultdict(dict))

    def get_value(self, i, j, k):
        if self.cells.has_key(i) and self.cells[i].has_key(j) and self.cells[i][j].has_key(k):
            return self.cells[i][j][k]
        return None

    def set_value(self, i, j, k, value):
        self.cells[i][j][k] = value
        return self

    def for_each(self, fn):
        for ikey, ivalue in self.cells.items():
            for jkey, jvalue in ivalue.items():
                for kkey, kvalue in jvalue.items():
                    fn(kvalue, ikey, jkey, kkey)


class Helper:

    @staticmethod
    def create_dict():
        return defaultdict(lambda: defaultdict(dict))

    @staticmethod
    def for_each(array, fn):
        for value in array:
            fn(value)

    @staticmethod
    def loop_around(i, j, k, fn):
        for a in xrange(i - 1, i + 2):
            for b in xrange(j - 1, j + 2):
                for c in xrange(k - 1, k + 2):
                    if (a, b, c) != (i, j, k):
                        fn(a, b, c)

    @staticmethod
    def fill_grid(generation):
        """
        Place here your points coordinates
        """
        init_points = [(-1, 0, 0), (1, 0, 0), (0, 0, 1), (0, 0, -1), (0, 1, 0), (0, -1, 0)]

        for p in init_points:
            generation.grid.set_value(p[0], p[1], p[2], Cell())


class Cell:

    def __init__(self, age=1):
        self.age = age


class Generation:

    def __init__(self):
        self.grid = MultidimensionalDictionary()

    def get_cells_count_around(self, i, j, k):
        counter = 0
        for a in xrange(i - 1, i + 2):
            for b in xrange(j - 1, j + 2):
                for c in xrange(k - 1, k + 2):
                    if self.grid.get_value(a, b, c):
                        counter += 1

        return counter - 1 if self.grid.get_value(i, j, k) else counter

    def get_next_generation(self):
        """ Get next cells generation """

        new_generation = Generation()

        def birth(i, j, k):
            """ Checks if a new cell can be born """
            current_cell = self.grid.get_value(i, j, k)
            if current_cell is None:
                count = self.get_cells_count_around(i, j, k)
                if birth_min <= count <= birth_max:
                    new_generation.grid.set_value(i, j, k, Cell())

        def update_cell(selected_cell, i, j, k):
            """ Checks if the current cell can survive """
            count = self.get_cells_count_around(i, j, k)
            if survival_min <= count <= survival_max:
                selected_cell.age += 1
                new_generation.grid.set_value(i, j, k, selected_cell)
            Helper.loop_around(i, j, k, birth)

        self.grid.for_each(update_cell)
        return new_generation


class C4dRender:

    SCALE_COEF = 1
    OLDEST_CELL_AGE = 0

    def __init__(self):
        self.generation = Generation()
        self.doc = documents.GetActiveDocument()
        self.tp = self.doc.GetParticleSystem()
        self.root_group = self.tp.GetRootGroup()

        Helper.fill_grid(self.generation)

    def update(self):
        self.tp.FreeAllParticles()
        self.generation.grid.for_each(self.render)
        c4d.EventAdd()
        self.generation = self.generation.get_next_generation()

    def render(self, cell, i, j, k):
        C4dRender.OLDEST_CELL_AGE = cell.age if cell.age > C4dRender.OLDEST_CELL_AGE else C4dRender.OLDEST_CELL_AGE
        # drawing particle
        p = self.tp.AllocParticle()
        self.tp.SetGroup(p, self.root_group)
        self.tp.SetPosition(p, Vector(i, j, k) * C4dRender.SCALE_COEF)
        self.tp.SetSize(p, cell.age * 0.5)
        self.tp.SetColor(p, Vector(c4d.utils.RangeMap(cell.age, 0, C4dRender.OLDEST_CELL_AGE, 0, 1, True), 0.2, 0.4))

instance = C4dRender()

def main():

    if frame % refresh == 0:
        instance.update()

Minesweeper

2017-11-27T16:31:00.004+01:00

Cinema 4D gives us a 3D engine, Objects, Gui and some programming languages.. that's all what we need to create some games.. of course there is some limitations, but it still possible.

that's why i developped a classic game "Minesweeper". The first of a long series (I hope...) of #Games4Cinema
This script is a draft, it still needs some features like placing flags or option menu etc...

Enjoy :)

Installation

Clone the project or download the zip file and extract it into the Maxon scripts directory.
- WindowsC:\Program Files\MAXON\CINEMA 4D R<version>\library\scripts\
- MacOs/Applications/MAXON/CINEMA 4D R<version>/library/scripts/
Restart Cinema 4D
Open Cinema 4D Menu

Script » User scripts » Minesweeper » minesweeper


# You can change the size of the grid and difficulty by changing the values passed to the `MinesweeperGui` object.
# The args are: Rows, Columns, Difficulty[EASY|MEDIUM|DIFFICULT]

if __name__ == '__main__':
    dlg = MinesweeperGui(15, 10, Level.EASY)
    dlg.Open(dlgtype=c4d.DLG_TYPE_ASYNC)

XPresso, Wheel animation

2011-10-26T05:28:00.002+02:00

This tutorial is a simple introduction to Xpresso and Thinking Particles.

Project file wheel.zip

Part I

Part II

Render test

Creating a Rain setup with Thinking Particles

2010-12-23T17:04:00.005+01:00

Cinema 4D : Rain Test #01 from safina3d on Vimeo.

Tutorial

Tutorial : Rain with Thinking Particles from safina3d on Vimeo.

Ripple effect

Download the project file