Voir la version complète : Résolu Comme un RPC maison ?
Bonsoir :)
... j'ai cherche des infos sur le plugin RPC pour C4D... pas de retour pertinent,
et je me demandais si ce serait complique de faire un truc 'maison' en langue de serpent ou autre ?
concretement :
- phase 1 : fabrication d'une série d'images en rotation a 360° sur l'objet sur X frames le tout sur Y couches, comme un QTVR-objet
- phase 2 : appliquer cette texture animée sur une face visant la camera... comme texture de particule ou de clone
- phase 3 : parametrage des pas de changement d'image en fonction des nombres de X et Y et l'orientation a la camera, avec évidemment un offset dans les deux axes pour varier les angles de vue d'un voisin a l'autre
- phase 4 : ben... c'est fini : quand la camera se déplace dans la foule, chaque item presente la 'bonne vue' a la camera, tout en conservant un positionnement spatial pour une vue relief et un compositing en Z... et pis ca se calcule quasi en temps réel...
je me disais meme qu'avec un camera shader ca pourrait être 'vraiment' temps reel (via une lecture des source de chaque objet en XRef)
mais la j'ai des doutes sur la resistance de C4D a ce genre traitement sur des millions de particules (?)
seul hic... je ne suis pas FourcheLangue :(
et peut-etre que ca existe déjà... et peut-etre que ça ne fait rever que moi...
Juste parce que ca m'turlupine... sisi :)
c'est un test foireux avec le CameraShader : j'ai tout faux sur mes contraintes de rotation, du coup le point de vue de l'objet ne tourne pas dans le bon sens
il y a un conflit de priorité pour le rafraichissement des cameras-Shader
et pis il manque la recuperation de la couche alpha a reinjecter dans la texture
et évidemment, en l'état ca ne fonctionne pas pour un cloneur...
et puis se pose la question de l'éclairage quand il y en a... une NormalMap en Post ?
apres, c'est pas oblige d'etre TempsReel avec le cameraShader : un QTVR precalcule ce serait deja bien !
... mais c'est tellement leger et rapide ... ca donne envie.
https://dl.dropboxusercontent.com/u/4223514/C4D/fakeRPC-render-web.mov
https://dl.dropboxusercontent.com/u/4223514/C4D/fakeRPC-editor-web.mov
le fichier C4D :
https://dl.dropboxusercontent.com/u/4223514/C4D/fakeRPC-1.zip
bon ok... je vais dormir...
valkaari
12/09/2013, 02h42
Tu sais que c'est pas ultra claire ton truc. Bon déjà je suis pas certain de savoir ce que c'est le RPC T.T
Salut Val,
oui... désole, il etait un peu tard pour que je poste quoi que ce soit ;)
pour ce qui est du plugin RPC, c'est ici : https://www.archvision.com/rpccontent/plugins
on notera que C4D n'est pas dans la liste... il y a eu des Beta, mais ca n'a pas eu l'air de fonctionner.
le principe est d'utiliser des photos sous differents angles d'un sujet (arbre, perso, véhicule, etc) pour peupler une scene d'architecture a moindre frais 3D
ca gere la couche alpha et les ombres portées
et la vue du sujet change en fonction de l'angle de vue de la camera, car il est lui meme oriente dans l'espace 3D :
une voiture en RPC composée de 36 vues en 360° : la texture change tous les 10° quand la camera tourne autour de la facette.
personnellement j'en ai trouve l'usage potentiel pour les films médicaux sur lesquels je bosse régulièrement car j'ai souvent besoin d'avoir des millions de molécules pour me balader dedans... or avec des instances Mograph... ca rame grave !
valkaari
12/09/2013, 14h13
Je penses pas que ton soucis soit la complexité des objets, mais bien leur nombre.
Bon, afficher 5000 voitures ou 5000 plans avec une texture c'est pas la même chose, ok, mais ça ne veut pas dire que ça sera super fluide avec 5000 plans texturés. Pas dans cinema4D en tout cas.
Puis j'imagine qu'il faut éviter que les plans s'entrechoquent.
On dirait typiquement le type de projet qui a l'air simple mais qui est en fait super complexe ^^
en fait, pour ce qui est du nombre et des comportements (collision, etc)
ca c'est le boulot du Mograph ou des particules.
Le texturage 360° dont je parle arrive en aval pour 'habiller' les clones ou particules
mais de manière pseudo3D
avec des Sprites sous X-Particles, on peut afficher des millions de 'facettes' sans planter C4D
et ca se calcule plutôt vite.
Ce shader-360-vers-camera donnerait l'illusion que les sprites sont en 3D
... avec les limitations visuelles d'intersections de plans et de 'crantage' lors des pseudo-rotation des objets
mais bon, je ne dis pas que c'est simple...
je me disais que si c'etait développable ce serait un chouette outil
valkaari
12/09/2013, 14h36
Ton fichier d'exemple est pas si mal en fait, suffit de pas oublier d'activer les effets post-prod dans la vue pour voir la texture et de glisser le shader camera dans le canal alpha.
Intéressant, y a pas mal de taf à produire par contre.
cool merci :)
je viens d'apprendre 2 trucs :)
je me disais que l'ideal serait meme d'avoir une XRef pour chaque objet afin que ce soit dissocie de la scene d'utilisation de la texture
... ce qui a mon avis complexifie encore un peu la sauce pour faire passer des map entre la XRef et la scene Master (?)
mais bon... je me tais a present vu que je serais incapable de le faire ni de financer sérieusement le dev
... par contre je serai client ! :)
César Vonc
12/09/2013, 15h02
Hmm, au début je pensais à modifier la texture matériau de chaque plan en fonction de l'angle, mais ça n'irait pas vu que le même matériau est appliqué à plusieurs plans ayant chacun un angle différent...
Je pense qu'il faudrait créer une texture comportant tous les angles de vue et jouer sur le décalage UV de la propriété Texture pour afficher tel ou tel image en fonction de la rotation de l'objet.
Mais bon, créer une texture comportant (360 / 10) * (180 / 10) = 648 images, ça fait un assez gros fichier. : P
À moins d'avoir 648 matériau chargeant chacune une image...
Édit : Pas si gros que ça en fait, ça donne 26 × 26 images, soit seulement une texture de 2600 pixels de large pour des images de 100 pixels ?
Concernant ton essai, c'est pas mal vu que CamShader permet d'éviter de créer des textures, mais si t'as 1000 particules, t'auras 1000 caméras, 1000 matériaux qui calculeront 1000 minis rendus ?
Je suis pas certain que ce soit vraiment plus économique au final. Faudrait faire des essais et comparaisons. T'as un rendu 360 ° sous la main ?
je suis parti sur un systeme de 36 frames par longitudes (1/10°) et 9 latitudes
voila un dossier avec les images calculées et nommées : image_LAT-LONG
... ca se suit dans l'ordre alpha pour faire un film
ou pour les ranger sur une map cote a cote
https://dl.dropboxusercontent.com/u/4223514/C4D/360-Render.zip (34 Mo)
ci joint egalement le fichier C4D pour générer les rendus (ou servir de matrice XRef a un CamShader :
l'aventage de la XRef est que le format de rendu peut être carre pour calculer les map, independemment du ratio de calcul du la scene finale)
https://dl.dropboxusercontent.com/u/4223514/C4D/360-VR.zip (1,5 Mo)
par contre, je suis parti sur du 512x512 ;) la ca risque d'etre gros (!)
[edit : oops, 1000 materiaux en effet avec CamShader...]
[edit/edit : peut-etre qu'en quantifiant le pas pour faire des sauts de cameras avec CamShader, on retombe sur la logique precalculee... sans pre-calculer et en ne générant "que" 400 textures ...]
sinon, juste pour info, l'objet en question : c'est une chaine de proteine complexe :)
valkaari
12/09/2013, 15h54
je partais sur la piste bête et méchante d'un quicktimeVR en mode séquences d'image machin là, ça crée un film qui part du haut et vas jusqu'en bas en tournant à 360.
Je calcul l'angle de la camera pour trouver quelle image du film afficher. Mais j'suis un peu fâcher avec les math là en fait ....
ça donne un truc du style (x*y/360) + x/360 --> ratio
ratio * nombre d'image total --> image à afficher.
x et y étant les angles par rapport à l'image. Le tout arrondit et remplacer le 360 par 2PI histoire de faire style je comprends ce que je fais.
Mais j'suis vraiment fâché avec les math là .....
César Vonc
12/09/2013, 16h13
L'idée du film est compacte, mais elle demanderait à avoir un matériau par particule, si je ne m'abuse ?
C'est vrai que le modèle 3d est plutôt complexe, Gyom !
On peut cependant garder des images de 512 et découper ça en 9 matériaux contenant chacun 36 images, ce qui donnerait 9 textures de 3072 de large, c'est plutôt raisonnable.
Du coup, tu pourrais presque monter à 18 latitudes !
Je me penche vite fait sur le script. Si t'as une idée pour regrouper automatiquement un lot d'images sur une texture sans se prendre la tête, je suis preneur. ^^
Si t'as une idée pour regrouper automatiquement un lot d'images sur une texture sans se prendre la tête, je suis preneur. ^^
hum... ce serait un truc sous ToShop... en automatisation... mais la je dois passer le relai a la vie de famille...
merci de votre interet en tous les cas :)
César Vonc
12/09/2013, 21h36
Ah et au fait, tu as fait 37 images au lieu de 36 pour la longitude, du coup il y a un petit saut d'image à un moment.
Je posterai le script dans la soirée, c'est marrant, ça marche pas trop mal. ^^
César Vonc
12/09/2013, 22h21
Hop, voilà le lien : http://vonc.fr/temp/fc4d/Panneau.rar
Ce que j'ai galéré pour réunir les images sur une texture, j'ai fait ça en html pour tout dire, d'où la taille minuscule et l'absence d'alpha. De toutes façons c'est juste pour essayer, hein. : P
Tu as quatre variables que tu peux modifier dans le script :
- Le préfixe du matériau à charger : "Tex."
- Le nombre d'images totales longitudinales : 36
- Le nombre d'images par côté dans chaque texture : 6 (en fait, c'est toujours la racine du nombre d'images long.)
- Le nombre de latitudes : 9
Tu as donc une texture et un matériau par latitude.
Y a juste un léger soucis quand on passe par-dessus le plan, le pointage vers la caméra le fait tourner assez brutalement.
import c4d
import math
nommat = "Tex."
nbX = 36.0
nbXc = 6.0
nbY = 9.0
arr = 1.0 / (nbX * 2.0)
pi2 = math.pi * 2.0
def main():
obj = op.GetObject()
if not obj : return
ptex = obj.GetTag(c4d.Ttexture)
if not ptex : return
rotX = obj[c4d.ID_BASEOBJECT_REL_ROTATION,c4d.VECTOR_X]
rotY = -obj[c4d.ID_BASEOBJECT_REL_ROTATION,c4d.VECTOR_Y]
rotY += pi2
while (rotX < 0) : rotX += pi2
while (rotY < 0) : rotY += pi2
rotX = rotX / pi2
rotY = (rotY / math.pi) - 1.5
# Longitude
decY = int((rotX + arr) * nbXc) / nbXc
decX = round(rotX * nbX) / nbXc
ptex[c4d.TEXTURETAG_OFFSETX] = -decX
ptex[c4d.TEXTURETAG_OFFSETY] = -decY
# Latitude
nY = int(round(rotY * (nbY - 1.0)))
matnom = nommat + str(nY)
mat = doc.SearchMaterial(matnom)
if mat : ptex[c4d.TEXTURETAG_MATERIAL] = mat
Salut Gyom
Un petit bonjour de cap Voltaire :icon_wavey:
C'est vrai que c'est intérressant ce RPC Fake. Pour le regroupement d'images j'avais fait un script sous After pour reconstituer une image découpée, ça pourrait t'aider. Par contre le script ne fera qu'une texture à la fois, mais la manip est assez rapide.
- tu crée un layer de la taille de la texture finale (en fait le script utilisais l'image originale en référence et aussi pour vérifier le résultat final, ici comme tu n'as pas d'image il faut créer un layer qui doit être le layer 1)
- tu place les dalles à la suite sur les calques suivants
- tu Sélectionne la comp dans la fenêtre de projet (et surtout rien dans la comp elle même)
- tu lance le script (recouvrement tu met 0)
Bon c'est un peu rustique mais c'était pour des besoin perso et malgré tout ça fonctionne.
Cesar... quelle efficacite :)
... sauf que je rentre juste et qu'il est trop tard pour me lancer dans de la 3D : dodo
en plus je vais peut-être finir par y comprendre quelque chose au code avec les sources ;)
Floc au Cap Voltaire : ca alors, on se prend une mousse demain ?
bonne nuit a tous....
edit : Cesar : ca marche bien en effet :) un grand merci pour tout ça !
je viens de le mettre dans un cloneur 10x10x10 : l'editeur reste fluide en navigation :)
alors,
quelques mises a jour :
- le fichier C4D pour calculer les 36 images (et non 37... je le sais pourtant que 1 = 0) :
https://dl.dropboxusercontent.com/u/4223514/C4D/360-VR.zip (1,5 Mo)
- la nouvelle série de rendus de 9x36 images en PNG+alpha avec un doc AE pour générer les 'planches' (Floc, je n'ai pas utilise ton script, j'ai fait un truc a la mano rapidement), cette fois j'ai fait du 256x256 pixels pour rester dans les clous de taille d'image :
https://dl.dropboxusercontent.com/u/4223514/C4D/AE_MapTiler.zip (11 Mo)
- les 9 planches pour chaque latitude de 36 images en PNG+alpha :
https://dl.dropboxusercontent.com/u/4223514/C4D/MapPano-9x36.zip (10 Mo)
edit :
- une scene utilisant 10x10x10 = 1000 clones, avec les rendus : 2 minutes pour 250 frames :P
bon ok... ca crante dans les rotations... normal,
apres pourquoi pas tester avec 1 image / degré ...
https://dl.dropboxusercontent.com/u/4223514/C4D/C4D_PanoAlfa.zip (11 Mo)
https://dl.dropboxusercontent.com/u/4223514/C4D/render-1000clones_web.mov (5 Mo)
https://dl.dropboxusercontent.com/u/4223514/C4D/editor-1000clones_web.mov (5 Mo)
C'est vrai que le modèle 3d est plutôt complexe, Gyom !
^^
hehe... et encore, la ce n'est que la version la plus 'simplifiee'... les modeles de molecules sont redoutablement lourds :
de la version LowPoly a la plus HighPoly... et meme des variantes si on veut encore plus lourd ;)
César Vonc
13/09/2013, 13h13
Pas mal, oui ! ^^
Il y a sans doute également moyen de donner une rotation aléatoire de départ à la protéine, pour qu'elles ne soient pas toutes dans le même sens.
Là où c'est le plus saccadé, c'est pour la rotation verticale. Je pense que tu peux aller sans crainte à 18 étapes au lieu de 9.
En revanche, il y a un soucis avec Mograph, le script n'est pas recalculé pour chaque instance, ce qui fait que toutes les vitamines ont la même image.
Je pense qu'il faudra transformer le script Python en effecteur Python pour que ça marche.
Il y a sans doute également moyen de donner une rotation aléatoire de départ à la protéine, pour qu'elles ne soient pas toutes dans le même sens.
ca ce serait la cerise... :)
Là où c'est le plus saccadé, c'est pour la rotation verticale. Je pense que tu peux aller sans crainte à 18 étapes au lieu de 9.
ok... je vais faire des tests
En revanche, il y a un soucis avec Mograph, le script n'est pas recalculé pour chaque instance, ce qui fait que toutes les vitamines ont la même image.
Je pense qu'il faudra transformer le script Python en effecteur Python pour que ça marche.
... voila, c'est en général a ce moment-la que je n'arrive plus a comprendre ;)
... et pour que ca marche aussi avec des particules (TP et/ou X-Particles) ? parce que dans ce cas la, je ne trouve pas la manip pour orienter les particules vers la camera...
César Vonc
13/09/2013, 13h29
Ah, j'ai peut-être une solution pour les deux : utiliser un Générateur python plutôt qu'un plan et un script python ou un effecteur ; car le générateur est bien recalculé à chaque instance.
Y aura aussi moyen de le faire regarder vers la caméra même pour les particules. Je vais essayer tout ça, mais ça se complique un peu. : P
Hey Gyom
On fait un ptit pot vers 18h si ça te dis ? ( cesar ou valkaari si vous êtes pas trop loin de montreuil vous êtes bien sur les bienvenus)
sinon pour orienter les particule c'est assez simple il suffit de connecter la position de la camera à l'entrée axe du neud TP PAlignment (et le mettre en mode "user position")
:) Merci Floc !
ca roule donc pour TP... et du coup pour X-Particles aussi vu qu'on peut generer des TP avec...
par contre pour ce soir ca ne va pas le faire : je recupere mes marmots dans 10 minutes et ils invitent des copains,
je suis bloque a la maison jusqu'a 18h30 / 19h... et si ma femme part finalement bosser ce soir, ben je reste bloque ici lol
vous pouvez passer neanmoins ;)
César Vonc
13/09/2013, 17h12
Tiens, voici la version Générateur Python, avec quelques DU pour faciliter la tâche (note que le nombre d'images X doit être une puissance, comme 4, 9, 16, 25, 36, 49... ce qui correspond au nombre d'images dans la texture).
Il y a un « orienteur vers la caméra » intégré, donc ça marche avec Mograph, particules et compagnie, sans effecteur ni bidouille ! ; )
Tu peux définir la rotation de ta molécule juste en modifiant la rotation du générateur. Ça marche pour l'instant qu'avec la rotation H, j'ai un petit soucis avec la rotation P. : /
import c4d
import math
import random
from c4d import Vector, Matrix
pi2 = math.pi * 2.0
def main():
# -- Récupère les variables --
tX = op[c4d.ID_USERDATA,6] * 0.5
tY = op[c4d.ID_USERDATA,7] * 0.5
cibleCam = op[c4d.ID_USERDATA,2]
cible = op[c4d.ID_USERDATA,5]
nommat = op[c4d.ID_USERDATA,3]
nbX = float(op[c4d.ID_USERDATA,4])
nbXc = float(int((nbX**0.5)))
nbX = nbXc**2
op[c4d.ID_USERDATA,4] = nbX
nbY = float(op[c4d.ID_USERDATA,1])
arr = 1.0 / (nbX * 2.0)
# -- Création de l'objet --
obj = c4d.BaseObject(c4d.Opolygon)
points = [c4d.Vector(-tX, -tY, 0),
c4d.Vector(tX, tY, 0),
c4d.Vector(-tX, tY, 0),
c4d.Vector(tX, -tY, 0)]
poly = c4d.CPolygon(2, 0, 3, 1)
obj.ResizeObject(4, 1)
obj.SetAllPoints(points)
obj.SetPolygon(0, poly)
obj.Message(c4d.MSG_UPDATE)
puvw = obj.MakeVariableTag(c4d.Tuvw, 1)
puvw.SetSlow(0, Vector(0.1666, 0.0, 0.0),
Vector(0.1666, 0.1666, 0.0),
Vector(0.0, 0.1666, 0.0),
Vector(0.0))
ptex = obj.MakeTag(c4d.Ttexture)
ptex[c4d.TEXTURETAG_PROJECTION] = c4d.TEXTURETAG_PROJECTION_UVW
# -- Pointe vers caméra --
cam = cible
if cibleCam :
bd = doc.GetRenderBaseDraw()
cam = bd.GetSceneCamera(doc)
if not cam : cam = bd.GetEditorCamera()
if cam :
opMg = op.GetMg()
camMg = cam.GetMg()
rotVec = camMg.off - opMg.off
rotVec = c4d.utils.VectorToHPB(rotVec)
obj.SetAbsRot(rotVec)
# -- Modifs de la texture --
rotOp = op[c4d.ID_BASEOBJECT_REL_ROTATION]
rotX = rotOp.x + obj[c4d.ID_BASEOBJECT_REL_ROTATION,c4d.VECTOR_X]
rotY = -obj[c4d.ID_BASEOBJECT_REL_ROTATION,c4d.VECTOR_Y]
rotY += pi2
while (rotX < 0) : rotX += pi2
while (rotY < 0) : rotY += pi2
rotX = rotX / pi2
rotY = (rotY / math.pi) - 1.5
# Longitude
decY = int((rotX + arr) * nbXc) / nbXc
decX = round(rotX * nbX) / nbXc
ptex[c4d.TEXTURETAG_OFFSETX] = -decX
ptex[c4d.TEXTURETAG_OFFSETY] = -decY
# Latitude
nY = int(round(rotY * (nbY - 1.0)))
matnom = nommat + str(nY)
mat = doc.SearchMaterial(matnom)
if mat : ptex[c4d.TEXTURETAG_MATERIAL] = mat
# Corrige la rotation
if cam :
matrice = c4d.utils.HPBToMatrix(rotVec)
opMgInv = (~opMg).GetNormalized()
opMgInv.off = Vector()
objMg = opMgInv * matrice
obj.SetMg(objMg)
return obj
Cesar :)
... un grand merci !
je teste tout ca asap...
César Vonc
14/09/2013, 15h11
Hop, voilà la version avec toutes les rotations opérationnelles !
Il suffit de pivoter l'objet pour que les images correspondantes s'affichent, tu peux du coup utiliser un effecteur randomisation pour définir la rotation aléatoire des clones !
import c4d
import math
from c4d import Vector
pi2 = math.pi * 2.0
def main():
# -- Récupère les variables --
tX = op[c4d.ID_USERDATA,6] * 0.5
tY = op[c4d.ID_USERDATA,7] * 0.5
cibleCam = op[c4d.ID_USERDATA,2]
cible = op[c4d.ID_USERDATA,5]
nommat = op[c4d.ID_USERDATA,3]
nbX = float(op[c4d.ID_USERDATA,4])
nbXc = float(int((nbX ** 0.5)))
nbX = nbXc ** 2
op[c4d.ID_USERDATA,4] = nbX
nbY = float(op[c4d.ID_USERDATA,1])
arr = 1.0 / (nbX * 2.0)
nbXi = 1.0 / nbXc
# -- Création de l'objet --
obj = c4d.BaseObject(c4d.Opolygon)
points = [Vector(-tX, -tY, 0),
Vector(tX, tY, 0),
Vector(-tX, tY, 0),
Vector(tX, -tY, 0)]
poly = c4d.CPolygon(2, 0, 3, 1)
obj.ResizeObject(4, 1)
obj.SetAllPoints(points)
obj.SetPolygon(0, poly)
obj.Message(c4d.MSG_UPDATE)
puvw = obj.MakeVariableTag(c4d.Tuvw, 1)
puvw.SetSlow(0, Vector(nbXi, 0.0, 0.0),
Vector(nbXi, nbXi, 0.0),
Vector(0.0, nbXi, 0.0),
Vector(0.0))
ptex = obj.MakeTag(c4d.Ttexture)
ptex[c4d.TEXTURETAG_PROJECTION] = c4d.TEXTURETAG_PROJECTION_UVW
# -- Pointe vers la caméra --
cam = cible
if cibleCam :
bd = doc.GetRenderBaseDraw()
cam = bd.GetSceneCamera(doc)
if not cam : cam = bd.GetEditorCamera()
if cam :
opMg = op.GetMg()
camMg = cam.GetMg()
rotVec = camMg.off - opMg.off
rotVec = (~opMg).MulV(rotVec)
rotVec = c4d.utils.VectorToHPB(rotVec)
obj.SetAbsRot(rotVec)
# -- Modifs de la texture --
rotX = obj[c4d.ID_BASEOBJECT_REL_ROTATION,c4d.VECTOR_X]
rotY = -obj[c4d.ID_BASEOBJECT_REL_ROTATION,c4d.VECTOR_Y]
while (rotX < 0) : rotX += pi2
while (rotY < 0) : rotY += pi2
rotX = (rotX / pi2)
rotY = (rotY / math.pi)
# Longitude
decY = int((rotX + arr) * nbXc) / nbXc
decX = round(rotX * nbX) / nbXc
ptex[c4d.TEXTURETAG_OFFSETX] = -decX
ptex[c4d.TEXTURETAG_OFFSETY] = -decY
# Latitude
rotY = (rotY + 0.5) % 1.0
nY = int(round(rotY * (nbY - 1.0)))
matnom = nommat + str(nY)
mat = doc.SearchMaterial(matnom)
if mat : ptex[c4d.TEXTURETAG_MATERIAL] = mat
return obj
http://vimeo.com/74519251
tu es un grand malade !!
Merci pour le partage ! :thumbup1:
Cesar ... bravo !
... c'est tres malin... et 100% C4D-friendly
... mais c'est le weekend ! faut penser aussi a faire une sieste par exemple ;)
merci encore.
Bonjour :)
voila la version finale opérationnelle du "Tiler" sous AfterEffect pour générer des 'planches' de textures a partir d'une serie d'images ordonnees.
https://dl.dropboxusercontent.com/u/4223514/C4D/MapTiler-64.zip (23 Mo)
La position de chaque occurrence ainsi que son 'TimeRemap' sont contrôles par expression en fonction du numero de calque :
il faut donc que le calque 'script' reste en dernier.
les variables a renseigner sur ce calque 'script' sont :
- CazNum : nombre de cases en X et Y, car la planche est constituée d'autant de cases en horizontal qu'en vertical / dans mon cas 8 x 8
- CazSizeX et CazSizeY qui sont les dimensions des images de la serie / dans mon cas 256 x 256
pour une taille de planche différente, il faudra aussi modifier la taille de la Comp.
il suffit ensuite de dupliquer le premier calque autant de fois que de cases disponibles / dans mon cas, 8 x 8 = 64 cases par planche
chaque calque vient se ranger a cote du precedent en decallant d'une image l'animation avec retour a la ligne automatique
dans mon cas, j'ai 1088 images pour tous mes points de vue, soit 64 images par planche x 17 planches
pour avoir les planches suivantes,
il suffit de se déplacer dans le temps : a chaque frame la série se decale du nombre d'images dans la planche,
dans mon cas, 17 planches = 17 frames a calculer.
Powered by vBulletin® Version 4.2.1 Copyright © 2024 vBulletin Solutions, Inc. Tous droits réservés