Febuary 14, 2020 - Febuary 21, 2020

Keywords:

- 3D
- animation
- C++
- implicit surfaces
- Qt
- Radium Engine
- research

Paul G. Kry invited me to participate to the Bellairs research institute animation workshop in Barbados. The workshop this year was a hackathon like where we had to determine if projects were feasible.

I worked on the "Time-based anisotropic blending" as the developer of the prototype in C++ under Radium Engine using private plugins provided by the STORM team (IRIT).

One limitation of implicit surfaces' work is than it does not offer a lot of control to compose two surfaces. Particularly, previous work does not allow to transform a sphere into a droplet while composed with a plane (we miss a direction information and a way to tell the operator to compose as an union for one side and as a blending for an other).

During this week, we :

- arrived at a proof of concept for automatic and user-based methods to generate parameter's field according to a given direction.
- illustrate the validity of our method on examples (droplet, wave, ferromagnetism, spiral composition).

Keywords:

- 3D
- animation
- C++
- cages
- contacts
- deformation
- implicit skinning
- implicit surfaces
- inverse position
- meshes
- Qt
- Radium Engine
- research

(November 2019 - December 2019 : 3 weeks full-time on site and working remotely since October 2019)

Waiting for a visa to start a Ph.D, Brian Wyvill offers me the possibility to come to the University of Victoria (BC, Canada) and continue the development of the work started with Loïc Barthe and Paul G. Kry.

To extend the previous work, I :

- showed that the method can be generalized to more deformation types : skeletal-based, point-based.
- optimized the update time when deforming (assertion on the structure of the space cover) and improvement of results' quality (optimization of time allow a significant increase of the sampling grid and makes spline approximation relevant where spline interpolation keeps being a limitation).
- set the main limitation about the method which is due to the local overlaps of the space and its discontinuities.
- started to study the method on concrete models (elephant's trump, arm of an octopus).
- proposed a space covering with adaptive refinement with respect to a target iso-surface in a scalar field.

During my experience and my supervised academic projects, I was appreciate for my autonomy but also for the relevancy and the originality of my results.

I give keywords to help the reader having a better idea about the technologies and concepts I worked on during my work experience.

Keywords:

- 3D
- animation
- automation of computations
- C++
- CADO-NFS
- cages
- contacts
- cryptanalysis
- deformation
- discrete logarithm
- finite fields
- implicit skinning
- implicit surfaces
- inverse position
- mathematics
- meshes
- number field sieve
- parameter setting
- Python 3
- Qt
- Radium Engine
- research
- teaching

Keywords:

- 3D
- animation
- C++
- cages
- contacts
- deformation
- implicit skinning
- implicit surfaces
- inverse position
- meshes
- Python 3
- Qt
- Radium Engine
- research

(April 2019 - September 2019 : 6 months full-time as my graduation internship)

Implicit skinning propose the automatic correction of folds and preserve volume at joint while deforming a 3D character with an animation skeleton. However, a limitation of this method is that it keeps being rigid transforms of primitives (implicit surfaces) and does not allow free deformation of the mesh (shapekey like, sculpting muscle bulge).

Under the initial supervision of Loïc Barthe and Pascal Romon, my job was to find a method allowing the animation of an implicit primitive using a cage-based deformation.

To solve this problem, I :

- studied state of the art on free form deformations using a 2D prototype in Java implemented under Processing IDE.
- prototyped the 3D methods in C++ under Radium-Engine with an UI with Qt.
- followed the track of the inverse position solving and proposed a software architecture to answer this problem.
- proposed methods and analyzed their relevancy.

I first investigate methods based on direct solving of the inverse position problem with a weakness due to the computation time for the first one and lack of consistency of the field for the other. Then, I explored methods based on the approximation of the given space deformation using a regular grid. My work focused on improving the robustness of the scalar field deformation (spline reconstruction for better continuity, space region detection using tetrahedral cut). With this methods, I started looking at solving self-intersection of the field with itself. This allow then to correct simple self-contacts of a mesh with itself using a desired effect by the chosen composition operator.

Here is an arm like example with muscle grow where we can add an automatic bulging effect at the contact:

For this work, we gave me the mark of 20 / 20.

For more details and explanations, I invite the reader to study my master thesis (in French, but feel free to contact me if interested and motivate me to write an english version) :

Also slides for my master thesis defense (animations are working under Okular and are fluent are a first reading of all the slides) :

Slides of the scientific presentation :

- en Juin 2019 : TRANCHO_presentation_june_21_2019.pdf
- updated in July 2019 : TRANCHO_presentation_july_08_2019.pdf

Keywords:

- automation of computations
- CADO-NFS
- cryptanalysis
- discrete logarithm
- finite fields
- number field sieve
- parameter setting
- Python 3
- research

(May 2018 - August 2018 : 4 months full-time as a master research internship)

CADO-NFS allow to check the robustness of public key cryptographic systems against mathematical-based attacks when this is based on factoring or discrete logarithm solving in finite fields.

At first CADO-NFS was designed to achieve record on the size of the finite fields to break. Pierrick Gaudry gave me the task to find a method to get a relevant parameter set for CADO-NFS on little size prime finite fields (attacks from an individual's workstation) and reduce as much as possible the range where CADO-NFS is better than concurrent softwares.

During this experience, I:

- understood the general functionalities of CADO-NFS for discrete logarithm solving, its parameters and their task in the pipeline.
- developed scripts (Python 3) for the parsing of results and automation of sub-processes of CADO-NFS to try hypothesis on parameters' configuration on remote machines.
- by a huge number of trials and examples, I reported relevant bugs in CADO-NFS.
- showed that CADO-NFS beats concurrent softwares for Sophie-Germain prime finite fields (worst case) starting from size with 40 digits.

My contribution, parameters sets for prime finite field of size between 30 and 100 digits had been added to CADO-NFS (commits c77fe4b3b5f2 and 1cd07513de565).

For this work, I was given the mark of 19 / 20.

Fun fact related to this subject : Pierrick Gaudry illustrated type of concrete application of CADO-NFS on small size prime finite field : he showed how to break Moscow internet voting system for elections while using prime finite fields of size 256 bits (77 digits), he details to break the encryption scheme here.

I invite the reader to study my work in the following document :

Defense slides :

Slides of scientific presentation given to CARAMBA team :

Keywords:

- teaching
- mathematics

(September 2017 : 18 hours of training)

As soon as students come at the University Paris-Est Marne-La-Vallée, they have to participate to two weeks of preparation in mathematics. Objective is to make the bridge between topics studied at high school and push these to be ready for courses given at the university.

I handled two groups of 13 students each and trained them on the following topics:

- complex numbers.
- algebraic real and complex calculus (polynomials, inequalities).
- study of functions (limits, function's graph).
- study of sequences (recursive sequences).
- integration (Riemann integration, initiation to integration by parts).
- geometry (complex plane, line equation in plane and space).

These projects were developed for an academic purpose to run over Linux.
(To try them, the read would have to install SDL 1.2, MLV, OpenGL, libg3x : given, Processing IDE).

Keywords:

- 2D
- 3D
- animation
- animation skeleton
- automatic hitbox generation
- C
- C++
- character creation
- collisions detection
- computer controlled opponents
- correcting codes
- deformation
- discrete differential geometry
- factoring of polynomials
- finite fields
- GLSL
- image synthesis
- Java 8
- meshes
- morphing
- OpenGL 2
- OpenGL 3
- procedural generation by scripts
- processing IDE
- Python 3
- QR codes
- scene graph
- SDL

Keywords:

- 3D
- deformation
- discrete differential geometry
- Java 8
- meshes
- processing IDE

2019 : Master degree's second year

Here is a project made for the discrete differential geometry course, is implemented the mesh deformation using discrete curvature flows. The idea is to deform a mesh based on a characteristic like the curvature, the maximization of the volume or something else.

On application is noise / sharp features reduction in a mesh.

The project was made in Java 8 under Processing IDE (OpenGL's overlay). We propose the following :

- a software architecture to handle discrete curvature flows on surfaces (here a mesh).
- various flows, examples, parameters and data about the surface.

For more details, the reader is free to run projet.pde under Processing IDE and read the manual in this same file :

Some scientific documents related to the project :

- Mean curvature flow by the faces : 2019_TRANCHO_VEILLERETTE_document_geometrie_differentielle.pdf
- Face-driven flow experience : 2019_TRANCHO_VEILLERETTE_flots_par_faces.pdf

Keywords:

- 3D
- animation
- C++
- GLSL
- image synthesis
- OpenGL 3
- procedural generation by scripts
- scene graph

2019 : Master degree's second year

The objective of this project was to visualize a solar system. It is possible to define properties, add planets and generate an asteroid ring from a script system.

In C++, from a OpenGL 3 overlay, we propose :

- software architecture to split tasks related to rendering and the ones related to scene graph and geometry.
- solar system rendering using shaders (GLSL).
- procedural generation and to parameterize asteroids and planets.

My job in this project was the software architecture and the processing of geometry.

- Sources of the project : 2019_TRANCHO_VEILLERETTE_systeme_solaire.zip

Keywords:

- 3D
- animation
- C
- OpenGL 2
- procedural generation by scripts
- scene graph

2018 : Master degree's first year

In C language, we propose the visualization of a scene graph using combination of simple primitives (spheres, cylinders, torus and others).

A proposed script language is proposed to the user to build the scene, it means defining primitives, transforms, colors, animations, components schemes.

I was responsible of the scene graph and of setting up the script language for procedural generation of the scene.

To run the project, please install libg3x : given overlay of OpenGL.

- Sources of the project : 2018_TRANCHO_VEILLERETTE_graphe_scene.zip

Keywords:

- C
- correcting codes
- factoring of polynomials
- finite fields
- QR codes

2017 : Undergraduate's third year supervised project

With a personal interest for cryptography and stimulating lectures given in mathematics applied to computer science (arithmetic and combinatorics) given by Jean-Yves Thibon, I came to Marc Zipstein asking to work in crypto, Marc Zipstein and Jean-Yves Thibon then offered me the opportunity to work on correcting codes and to familiarize myself with finite field concept.

Implemented in C, I propose :

- to research irreducible polynomials in Z/
_{2Z}[X] (all the small ones using an Eratosthene sieve and larger ones using recursive factoring with the Berlekamp algorithm). - a calculator to handle computations in a finite field F
_{2q}isomorphic to F_{2}[X]/_{(P(X))}such as P is irreducible in F_{2}[X] and q is P's degree. - to code, decode and correct errors for BCH and Reed-Solomon codes.
- from the correction codes I have, it was possible to handle QR codes (can be checked with a standard software) for coding, decoding and correcting errors.

- Sources of the project : 2017_TRANCHO_codes_correcteurs.zip
- Document about project : TRANCHO_rapport_codes_correcteurs.pdf
- Defense slides : TRANCHO_presentation_code_correcteurs.pdf

Fun fact : Nintendo propose a challenge asking to factorize a polynomial in F

Keywords:

- 2D
- animation
- animation skeleton
- automatic hitbox generation
- C
- character creation
- collisions detection
- SDL

2017 : Undergraduate's third year supervised project

I came to Cyril Nicaud with my idea to create a mini-Blender in 2D and I thank him warmly for trusting me and for supporting me in this ambitious project.

The purpose was to create characters from nothing and being able to make them fight (we drew at the defense).

The project followed the given steps :

- a skeletal editor (hierarchic model of joints with rotation limit).
- a shape editor (modeling visible part by association of a tree of circles to each bone of the character).
- an animation editor (defining the rotation of the articulations and the global character's moving).
- automatic hitbox generation (model's refinement : circles and rectangles).
- automatic impact hit detection and interactive handling of character into a fighting game.

- Sources of the project : 2017_TRANCHO_personnages_articules.zip
- Document about the project : TRANCHO_personnages_articules.pdf
- Hitbox related complement : TRANCHO_hitbox.pdf

You can make your characters fight against each other !

You can edit your own characters for a better fight.

But you can also create your character from scratch.

Keywords:

- 2D
- animation
- C
- character creation
- SDL

2016 : Undergraduate's second year project

The purpose of the project was to make a combination game. However, I found fun to add a character and to propose the user to edit it (shape of the face, hairs, morphology, colors).

Note that this game run without image files (only procedural).

Fun fact : this project was honored by a Borie award, a cool distinction for a student project !

- Sources of the project : 2016_TRANCHO_VEILLERETTE_avatars.zip

Keywords:

- 2D
- C
- computer controlled opponents
- SDL

2016 : Undergraduate's second year

In C language, this classic snake have something more : you can play against other players and even against computers. The computer can have various given gameplays : one will collect the apples in the map, one will try to survive and an other will attack the other players to lock them somewhere !

A fun game has at least one AI with attack job !

- Sources of the project : 2016_TRANCHO_VEILLERETTE_snake.zip

2020 July

Few tricks to handle mathematics, here the first chapters focus on:

- Factoring ideas for fractions, numerical sequences, integrals, circle equations and others.
- Transform of a linear recursive numerical sequence into a matrix computations (allow to compute the Fibonacci sequence and more general ones in logarithmic time).

- Document : Mathemagie.pdf

2019 August

My master thesis in compute science on the deformation of implicit surfaces :

- Introduction and explanation of skeletal-based deformation's methods, composition of implicit surfaces.
- State of the art on cage-based deformations and inverse position's problem solving in the case of Free Form Deformations.
- Proposal of direct solving methods (accordance between deformed and original spaces : numerical solving which involve binding but expensive in time; navigation in barycentric coordinates' space : gradient descent but lack of accordance within the constraints given by the weights' computation).
- Proposal of approximation methods (discrete covering of space : requires high resolution to fit the deformation) and trilinear and triquadratic (interpolation and approximation) reconstruction.
- Space's self-overlapping detection (tetrahedra sampling) and composition order of scalar values' proposal.
- Application of the surface's deformation to correct mesh self-contact and effects' adding according to used operator.

For more details have a look at my experience about it.

- Document : TRANCHO_Kevin_memoire_master.pdf
- Master thesis' beamer : TRANCHO_Kevin_soutenance.pdf
- Scientific presentation (presented to the STORM team at the IRIT and the MFX team at the Loria) in June 2019 : TRANCHO_presentation_june_21_2019.pdf
- Scientific presentation updated in July 2019 : TRANCHO_presentation_july_08_2019.pdf

2019 May

During the discrete topology class, I had to make a state of the art and short explanations from my understanding about
critical kernels and P-simple sets based on sets of convex polytopes presented at the
digital topology workshop by Tat Yung Kong.

- Document : TRANCHO_Kevin_topologie_discrete.pdf

2019 April

During class of mathematical morphology, I had to do the review and explain the article "Constrained Connectivity for Hierarchical
Image Partitioning and Simplification" by Pierre Soille.

- Document : TRANCHO_Kevin_compte_rendu_article.pdf

2018 August

The report of my work during my master's program first year's internship which focus on :

- Explanation of my understanding of the number field sieve algorithm for discrete logarithms solving in prime finite field.
- Study and proposal of methods to find relevant parameters sets for the NFS algorithm with respect to Kleinjung and Joux-Lercier's polynomial selection.
- Benchmarks and comparison with concurrent softwares : Pari/GP (used in Sage) and Magma.

For more details have a look at my experience about it.

- Document : TRANCHO_Kevin_M1_rapport_stage_2017-2018.pdf
- Internship defense beamer : TRANCHO_Kevin_soutenance_slides.pdf
- Scientific presentation (presented to the CARAMBA team at the Loria) : TRANCHO_presentation_cado_nfs.pdf

2020 April - present

A current personal project. Its purpose is to propose tools and processes for the modeling
of characters and their animation using a implicit-based model.

Processes on meshes were intensively studied for virtual creation of articulated characters.
However, to reach their goals, artists would have some limitations with discrete aspect of
meshes (set of polygons of high resolution) while modeling : thus an artist has to sculpt
and then remesh the character by a retopology step to get a final clean low poly mesh.
An other natural limitation is encountered while deforming the mesh for its animation.
Here, the rigging step is often tedious and is difficult to control.

The purpose of my personal work is to give interest at how to propose tools for virtual
creation of characters to artists while continuing to express the creativity and save more
control on it : a continuous modeling and possibility to sculpt deformation of the implicit
surface while deforming the character for its animation. On final step is to propose tools
free enough to allow controled metamorphosis and combination of characters, meshes processes
being here too restrictive for perform this kind for operations.

If the reader has interest for this project, I propose the following documents (French) :

- Results' presentation in November 2020 :
TRANCHO_Kevin_november_2020_results.pdf

- Binary parametrable operator building : analytic method for composition of implicit surfaces and metamorphosis of the operator for a given parameters' set (parametrable aspect for the binary operator has the purpose of allowing a non-symmetrical n-ary building and composition deformation in space).
- Implicit clustering : interactive parameter interpolation in space using control positions.
- Sculpting (composition with a position) : example of application for the possibilities provided by the operator.
- N-ary building : n-ary operator building using a given binary operator.
- Pipeline proposal for operator and additionnal features handling : parameterized field and node composition scheme.

- Try the prototype.
- Initial proposal of character metamorphosis project as a thesis subject in 2019 (refused by the academic research because too applied, technical and specific) : TRANCHO_Kevin_sujet_these.pdf
- My master thesis in computer science as an introduction to implicit surfaces : TRANCHO_Kevin_memoire_master.pdf

2016 June

To work my skills on automata, I played the game to code the concepts and algorithms from
my theoretical course in C to manipulate glossaries.

One will find here :

- glossaries handling (adding, delete and other).
- properties checking (deterministic, standard, complete and also local properties).
- automata handling (complete, determine, standardize, concat, join, minimize and more).

- Sources in C : 2016_TRANCHO_automates.zip

2015 November

Tools for image manipulation in 2D using SDL with a application :
build of a character using different parts and color edition.

KI_Images allow operations such as transforms, combination, edition of pictures with SDL.

In the demo, the user can change the colors of the character and rotate articulations
using directionnal arrows.

- Sources in C : 2015_TRANCHO_KI_Images.zip

2018 January

Inspired by our python 3 exam, with a friend, we created both our own one.

You can pass mine : 2 points by good answer and 2 bonus points if you play on paper
(Well if you get 26 / 20, you probably start doing python at breakfast).

You have 1 hour :

- python exam 2018 : 2018_TRANCHO_python_empty.py
- fast correction proposal (please check yourself first) : 2018_TRANCHO_python.py
- simplified and explained correction proposal (please check yourself first) : 2018_TRANCHO_python_explications.py

2015 December

To propose to other students to work their programming skills in C and linked lists, I
proposed two autocorrected exercises using unitary testing.

Antoine Meyer and Marc Zipstein liked the idea and proposed it online to other students.

First exercise is a simple exercise to review linked lists concepts and the second one is
more a challenge (in fact I didn't know yet that I proposed an exercise about graphs).

The player has just to code functions in .c in the directory "exercices" and compile to see the given score.

- completing the code is left to the reader as an exercise : 2015_TRANCHO_exercices_autocorriges.zip
- correction proposal (please try it yourself first) : 2015_TRANCHO_exercices_correction.zip

2018 December

The Fibonacci sequence is well-known for its interest in particular for complexity courses !

Fun fact : it can be computed in logarithmic time complexity !
It is the same as considering it as two recurrent sequences and can be reduced to matrix exponnentiation.

If intersted, I propose the following document to detail a bit the theory and some generalization of the topic.

I would be happy to discuss a better and more efficient solution
(I can compute the billionth element of the Fibonacci's sequence in 46.834 seconds using my C implementation and my laptop).

You can also do benchmarks by your own using obscurantist following code :

- in C : 2018_TRANCHO_fibo_log_C.zip
- in python 3 : 2018_TRANCHO_fibo.py
- in mathematics : Mathemagie.pdf

2018 January

Well, if you want to keep a simple and cool factorial definition in mind, keep its natural definition.
Otherwise if you like combinatorics, I propose an other definition :

I save time compared to natural definition due to the idea we can optimize the computation
of sets of factor elements using fast exponent method.

However sympy use a better method to compute factorial.

I let you a python 3 code to test yourself this definition :

- in python 3 : 2018_TRANCHO_powerfact.py

Before having a real education in computer science, I was still able to create some cool games. Here are some which are interesting to share.

2015 October

What is best that create a pokemon like game to use my skills in both 2D art and programming ?
At this time, I didn't yet studied C and C++ at university, but creation does not wait.

As a player of Pokemaths is offered to :

- move on the map to interact with other characters and meet random opponents.
- create you own map to handle your characters.
- fight against character to improve yours, acquire skills and evolve.
- try an adventure, fight the masters and finally arrive to the final boss !
- there is also a chat, field management and other trials to simulate multiplayer at the university (but this is more related to hacking than anything else).

From the creator side, I have :

- a map editor (background, entities an others).
- scripts for the AI of the masters, entities handling : all the content can be edited using files.

Made to run with Linux using SDL 1.2.

Commands :

- Directional arrows -- move the current character.
- Right shift -- menu.
- Enter -- for interactions.
- Space -- to place a block.

Map editor : accessible using "edit" option

- Directional arrows -- move the cursor.
- Clic -- select the element to set (surroundings, background, interaction).
- Keypad 0, 2, 4, 5, 6, 8 -- to set the adjacency of the current tile.
- Keypad 0 -- to set the data related to current entity bloc.
- Keypad +/- -- alternatives for the tile.
- Space -- to place the tile.
- A -- to automatically solve adjacency of the tile in the map.
- F -- filling a region.
- Z -- automatic adjacency correction for tile and its neighborhood.
- Enter -- automatic tile placing on / off.
- Backspace -- get the tile under the cursor.
- Suppr -- hide surroundings.
- G -- go to coordindates you write in terminal.
- S -- save cursor position as your future position as a player.
- M -- goto an other map (input the number in the terminal).
- E -- set entity value for you as a player, in the terminal : [ID] [VALEUR] .

Entities are in the directory "ent" and have to be scripted (it can be interesting to contact me if you want to mod the game, I would be happy to help you).

Hacks:

- Roll the mouse wheel or spam a mouse button to automatically send an attack.
- Run several windows in the same time to train different characters and do massive recruitement.
- Close the window to ingore fights.
- Being happy anti-cheat is not in this version (Well, it would probably have banned you since you're reading this section) !
- Mod the game
- The most powerful hack : play to the game !

Known bugs:

- If you control a character, it exists in your map, try to avoid placing a block on its virtual position (to define this position, press Enter to free the character and then embody it).
- Compress the project using .zip : some of the files won't survive to extracting.

The project is not the original version (you don't have to be kevin to access everything and anti-cheat is removed) but it should work under your Linux with SDL:

- Sources of the project : 2015_TRANCHO_pokemaths.tar.gz

2012 April

Probably my first real game in C/C++ developed at the beginning of high school.
It is a puzzle game where first levels are here to warm you up and then the real game
starts !

The objective is to get the diamond without being captured by blue bears and if you can
collect a maximum amount of money in your path, this is very much to your credit !

Blue bears only see 2 blocks ahead in all directions by not diagonals, easy puzzle.
You also have all the time you need to move.

With the game, you have my identity generator (unless your name is "kevin") and my map
editor (if you want to create your own puzzles).

Commands :

- Directional arrows -- to move your character.
- S -- save your game.
- L -- load last save.

Note : please preserve your ears, reduce music volume.

Well yes, I know, this one runs under Windows but run with Wine ;)

- Project (windows application, sources, editors) : 2012_TRANCHO_fricours.zip
- A video of the 50 first levels, but you would have to play to discover next opponents ;) : Fricours.wmv

P.S.: there are also secret levels ! (have a nice solving)

Before discovering programming, I need a way to create games, here are some of the huge
number of games I created with GameMaker as a child. A child game !

Note : you should probably really reduce the volume of the techno musics to avoid jumping
from your seat, not being to sensitive to bright colors and you should have robust mouse
and keyboard to play !

2012 June

Street fighter like fighting game.

For this game, I need all a team of artists to do all the art for the characters.
But you can still play to the prototype and embody a character to fight an other
controlled by computer in this fighting game.

Commands :

- Directional arrows -- moving.
- Space -- kick.
- Keypad 0 -- punch.
- Keypad 1 -- special attack (loaded bar).

- Application (windows) : KFB_demo.exe
- Sources and assets : KFB_sources.zip

2012 October

Arcade game.

A particular PacMan like with my assets. Here, the opponents are not defined during the
game, but by a path where I tried to predict you moves, be fast, good luck.

- Directional arrows -- moving.

- Application (windows) : TBR.exe
- Sources and assets : TBR_sources.zip

Here are some of my 3D models. I don't have any real training in Blender, these models
are just creations of a passionate amateur.

Models starting from 2020 run with Blender 2.83 and the older ones works with Blender 2.79.

2020

A robot-creature's modeling.

- Modeling by mesh edition and material work.
- Grappling feature for arms, legs and tail.
- Compensation rig (controled stretch and volume variation of the arms).
- Rigid body deformation work : armor and pistons.

- The blender project (2.83) : 2020_TK_bot.blend

2020

A bit like a checking, I tried to exert myself like a real 3D artist would do. On this model, I worked my skills about:

- Character sculpting.
- Retopology of the mesh.
- Rigging : painting weights, adding bones for automatic muscle deformations, shapekeys for joint deformation correction (knee folds and chest grow).
- Animation controls : skeletal handling constraints.
- UV-cut and texture.

- The blender project (2.82) : 2020_human_dragon.blend