Academic background

This section details my education to give the reader a better knowledge about the courses I followed and particularities of my academic background.

Background in Computer science

The reader can find here my master thesis in computer science.

Master degree from the University Paris-Est Marne-La-Vallée

I am graduate from a Master's degree in computer science with major in imagery, Summa cum laude (17.289 / 20) top of class at the University Paris-Est Marne-La-Vallée in 2019.

We have to choose a major in second year, first year is common with the different possible majors.

In first year, I studied:

  • advanced software development (java 9, python 3, C++ 14), including concurrent multi-thread programming, design patterns, real time programming.
  • imagery (computer graphics and image processing).
  • databases and networks (network architecture and programming).
  • theory (problems' complexity, linear optimization, cryptography, data compression and combinatorics).

Then in the second year specialized in imagery I followed :
  • computer graphics and virtual reality (OpenGL 3, GLSL).
  • discrete geometry manipulation (curvature flow on curves and meshes, discrete topology, animation and simulation).
  • computer vision and machine learning (statistical learning, neural networks, gradient descent).
  • signal processing and image restoration.

Bachelor's degree in computer science from the University Paris-Est Marne-La-Vallée

I completed a "Licence" program in computer science at the University Paris-Est Marne-La-Vallée in 2017, Summa cum laude (17.714/20) top of class.

In this program, I studied :

  • system programming (C language), object-oriented programming (java 8), functional programming (Caml).
  • data structures (tree algorithmic, graph theory, hash tables).
  • language theory (automaton, syntax analysis, compiling).
  • mathematics for computer science (arithmetic, combinatorics, logic).

Background in Mathematics
Bachelor's degree in mathematics from the University Paris-Est Marne-La-Vallée

I completed a "Licence" degree in mathematics from the University Paris-Est Marne-La-Vallée in 2018, Magna cum laude (14.85/20).

In France, courses are often mandatory and follow a given program (sometimes with few options). Here, there were 3 semesters common with mathematics and with computer science and then the 3 last semesters gives a student a full "Licence" degree (undergraduate - bachelor's degree equivalent in 3 years at university). In this case I had the special opportunity to be allowed to follow courses from the mathematical program for the 3 last semester, being present as much as possible on my free time according to the compute science schedule and passed the exams like every student in the math program.

The courses given by this degree completed my skills in:

  • numerical solving methods (zero solving, integration numerical approximation, pseudo-random generators) and matrix computation (matrix decomposition).
  • geometry (euclidean, affine, projective) and algebra (groups, arithmetic, number theory).
  • topology and analysis (differentiation, complex analysis, hilbertian analysis).
  • integration, probabilities and statistics.

Mathematics and computer science's common part

The first 3 common semesters (passed with 17.09 / 20) of my program were common to both mathematics and computer science program and then split. In January 2016, I initially choose the computer science program. Then in January 2017, I started the mathematics program on my free time while keeping computer science as my main program.

In this common part, I learned the basics in:

  • computer science : algorithmic, recursions, complexity, database with python 3, C, PHP and SQL programming languages.
  • mathematics : calculus, linear algebra, analysis, logic, probabilities.


Bellairs research institute animation workshop

Febuary 14, 2020 - Febuary 21, 2020


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

Research in animation at the University of Victoria


  • 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 from October 2019 to December 2019 as a volunteer)

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.

Work experience

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.


Teaching mathematics in Jean Rose High school in Meaux, France


  • teaching
  • mathematics

(March 03, 2021 - April 16, 2021 and April 26, 2021 - July 06, 2021 : 4 months full-time)

As a replacement mission of a teaching in mathematics, I was contacted by the Jean Rose High school in Meaux, France.
I had to handle 7 groups of students of various levels : students in their last and current years to the French 'Baccalauréat' and undergraduate students in second year after the French 'Baccalauréat' studies (Accounting and Management's speciality).
I was teacher in mathematics in the following topics :

  • Conditional probabilities
  • Binomial law
  • Python 3
  • Differentiation
  • Sequences (geometric and arithmetic)
  • Two variables' statistics

I share here few of my work during this mission in case this can be useful for the reader (can be used for educational purpose) :

Research in animation at the IRIT


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

Research at the Loria


  • automation of computations
  • 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 :

Preparatory training in mathematics at the University Paris-Est Marne-La-Vallée


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

School projects

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


Discrete differential geometry


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

Solar system


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

Scene graph


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

Correcting codes


  • 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 F2q isomorphic to F2[X]/(P(X)) such as P is irreducible in F2[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.

Fun fact : Nintendo propose a challenge asking to factorize a polynomial in F2[X].

Creation and fighting of articulated customizable characters


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

Characters' fight

You can make your characters fight against each other !

Character modification for fighting

You can edit your own characters for a better fight.

Character full creation

But you can also create your character from scratch.

Avatars editor


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



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

Scientific writing and presentations

"Petits sorts de mathémagie" (Little mathemagics spells)

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

Master thesis in computer science : Cage-based deformations for 3D scalar fields' animation - Application to the "implicit skinning".

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.

State of the art and explanations of article : Hereditarily homology-simple sets and homology critical kernels of binary images on sets of convex polytopes.

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.

Review and explanation of article : Constrained Connectivity for Hierarchical Image Partitioning and Simplification.

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.

Parameters' set finding for discrete logarithm's problem's solving in prime finite fields using CADO-NFS.

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.

Tools and scientific projects

IMPACT : Implicit Modeling Processes for Articulated Characters Transformations

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


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.

Teaching projects

Python 3 exam : challenge

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 :

Autocorrected exercises on linked lists : challenge

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.

Cool coding

Fibonacci computation in logarithmic time complexity

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 :

Computer factorial

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 :

Games - self-taught programming

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


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

Fricours 4 (Moneybear 4)

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

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

Games - GameMaker

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 !

Kaner fight battle

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

TireBall Revolution (ShootBall Revolution)

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.

3D models

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.



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.



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.

Contact me
© Copyrights Kevin Trancho 2009 - 2021 - all rights reserved.