parcelador

Este documento fornece uma visão geral abrangente do Parceler, uma biblioteca de geração de código para Android que simplifica a criação de objetos Parcelable. Ele detalha os recursos do Parceler, incluindo tipos de dados suportados, técnicas de serialização, tratamento de polimorfismo e configurações avançadas, juntamente com integração com outras bibliotecas Android populares. A última parte apresenta o Mitsuba 3, um sistema de renderização voltado para pesquisa, descrevendo seus recursos, instalação e uso.

Parcelador

Tem alguma pergunta? Pergunte no StackOverflow.

Encontrou um problema? Por favor, denuncie.

No Android, Parcelables são uma ótima maneira de serializar objetos Java entre contextos.

Em comparação com a serialização tradicional, os Parcelables levam cerca de 10 vezes menos tempo para serializar e desserializar.

Há uma grande falha com Parcelables, no entanto.

Parcelables contêm uma tonelada de código padrão.

Para implementar um Parcelable, você deve espelhar os métodos writeToParcel() e createFromParcel() de forma que eles leiam e gravem no Parcel na mesma ordem.

Além disso, um Parcelable deve definir um Parcelable.Creator CREATOR final estático público para que a infraestrutura Android possa aproveitar o código de serialização.

Parceler é uma biblioteca de geração de código que gera o código-fonte padrão do Android Parcelable.

Você não precisa mais implementar a interface Parcelable, o writeToParcel() ou createFromParcel() ou o public static final CREATOR.

Você simplesmente anota um POJO com @Parcel e o Parceler faz o resto.

Como o Parceler usa o processador de anotação Java JSR-269, não há necessidade de executar uma ferramenta manualmente para gerar o código Parcelable.

Basta anotar seu Java Bean, compilar e pronto.

Por padrão, o Parceler serializará os campos da sua instância diretamente:

Tenha cuidado para não usar campos privados ao usar a estratégia de serialização de campo padrão, pois isso incorrerá em uma penalidade de desempenho devido à reflexão.

Para usar o código gerado, você pode referenciar a classe gerada diretamente ou através da classe utilitária Parcels:

Para desreferenciar o @Parcel, basta chamar o método Parcels.unwrap():

Claro, o Parcelable empacotado pode ser adicionado a um Android Bundle para transferir de atividade para atividade:

E desreferenciado no método onCreate():

Essa técnica de embrulhar e desembrulhar funciona bem com o padrão Intent Factory.

Além disso, o Parceler é suportado pelas seguintes bibliotecas:

Transfuse - Permite que beans anotados @Parcel sejam usados ​​com a injeção @Extra.

FragmentArgs - Usa o adaptador ParcelerArgsBundler para agrupar e desembrulhar beans anotados @Parcel com parâmetros de fragmento.

Dart - detecta automaticamente beans anotados @Parcel e os desembrulha automaticamente ao usar @InjectExtra.

AndroidAnnotations - detecta automaticamente beans anotados @Parcel e os agrupa/desembrulha automaticamente ao usar @Extra, @FragmentArg, @InstanceState e outras anotações relacionadas ao Bundle.

ActivityStarter - Suporta nativamente objetos Parceler como argumentos para Atividades, Fragmentos, Serviços, etc.

Remoter - Suporta nativamente objetos Parceler como argumentos em interfaces @Remoter.

Tipos de atributos de lote

Apenas um número selecionado de tipos pode ser usado como atributos de uma classe @Parcel.

A lista a seguir inclui os tipos mapeados:

byte

dobro

flutuador

interno

longo

personagem

booleano

Corda

IBinder

Pacote

SparseArray de qualquer um dos tipos mapeados*

SparseBooleanArray

Campo Observável

List, ArrayList e LinkedList de qualquer um dos tipos mapeados*

Map, HashMap, LinkedHashMap, SortedMap e TreeMap de qualquer um dos tipos mapeados*

Set, HashSet, SortedSet, TreeSet, LinkedHashSet de qualquer um dos tipos mapeados*

Parcelável

Serializável

Matriz de qualquer um dos tipos mapeados

Qualquer outra classe anotada com @Parcel

*O pacote apresentará erro se o parâmetro genérico não for mapeado.

O Parceler também oferece suporte direto a qualquer um dos tipos acima.

Isto é especialmente útil ao lidar com coleções de classes anotadas com @Parcel:

Polimorfismo

Observe que o Parceler não desembrulha hierarquias de herança, portanto, quaisquer campos polimórficos serão desembrulhados como instâncias da classe base.

Isso ocorre porque o Parceler opta pelo desempenho em vez de verificar .getClass() para cada dado.

Consulte a seção Serialização personalizada para obter um exemplo de como trabalhar com campos polimórficos.

Técnicas de serialização

O Parceler oferece várias opções de como serializar e desserializar um objeto, além da serialização baseada em campo vista acima.

Serialização getter/setter

O Parceler pode ser configurado para serializar usando métodos getter e setter e um construtor não vazio.

Além disso, campos, métodos e parâmetros construtores podem ser associados usando a anotação @ParcelProperty.

Isso suporta uma série de estratégias de bean, incluindo imutabilidade e beans getter/setter tradicionais.

Para configurar a serialização do método padrão, basta configurar a anotação @Parcel com Serialization.BEAN:

Para usar um construtor com serialização, anote o construtor desejado com a anotação @ParcelConstructor:

Se um construtor vazio estiver presente, o Parceler usará esse construtor, a menos que outro construtor seja anotado.

Misturando getters/setters e campos

Você também pode misturar e combinar técnicas de serialização usando a anotação @ParcelProperty.

No exemplo a seguir, firstName e lastName são gravados no bean usando o construtor enquanto firstName é lido do bean usando o campo e lastName é lido usando o método getLastName().

Os parâmetros firstName e lastName são coordenados pelos nomes dos parâmetros "first" e "last", respectivamente.

Para atributos que não devem ser serializados com Parceler, o campo de atributo, getter ou setter pode ser anotado por @Transient.

O Parceler oferece suporte a muitos estilos diferentes centrados no POJO.

Isso permite que classes anotadas @Parcel sejam usadas com outras bibliotecas baseadas em POJO, incluindo as seguintes:

GSON

Reino

Armário

XML simples

DBFlow

Suporte estático de fábrica

Como alternativa ao uso direto de um construtor, o Parceler oferece suporte ao uso de um Static Factory anotado para construir uma instância de uma determinada classe.

Este estilo suporta o processador de anotação AutoValue/biblioteca de geração de código do Google para gerar beans imutáveis.

O Parceler faz interface com o AutoValue por meio da anotação @ParcelFactory, que mapeia um método de fábrica estático na serialização @Parcel anotada:

AutoValue gera uma classe diferente da anotada @Parcel, portanto, você precisa especificar qual classe o Parceler deve construir na classe do utilitário Parcels:

E para desserializar:

Serialização personalizada

@Parcel inclui um parâmetro opcional para incluir um serializador manual ParcelConverter para o caso onde uma serialização especial é necessária.

Isso fornece uma opção ainda mais limpa para usar classes Parcelable do que implementá-las manualmente.

O código a seguir demonstra o uso de um ParcelConverter para desempacotar a hierarquia de herança durante a desserialização.

O Parceler também vem com uma série de classes base para facilitar a conversão da coleção, localizadas no pacote org.parceler.converter da API.

Essas classes base cuidam de uma variedade de trabalhos difíceis ou detalhados que lidam com coleções, incluindo verificações de nulos e iteração de coleções.

Por exemplo, o ParcelConverter acima poderia ser escrito usando `ArrayListParcelConverter':

Aulas sem fonte Java

Para classes cuja fonte Java correspondente não está disponível, pode-se incluir a classe como Parcel usando a anotação @ParcelClass.

Esta anotação pode ser declarada em qualquer lugar conveniente na fonte compilada.

Por exemplo, pode-se incluir @ParcelClass junto com o aplicativo Android:

Múltiplas anotações @ParcelClass podem ser declaradas usando a anotação @ParcelClasses.

Além disso, as classes referenciadas por @ParcelClass podem ser configuradas usando a anotação @Parcel.

Isto permite a configuração da serialização através de qualquer parâmetro disponível na anotação @Parcel incluindo a técnica de serialização ou classes a serem analisadas.

Uma técnica útil é a capacidade de definir conversores personalizados globais para um tipo:

Isso permite um controle refinado sobre uma classe que não está disponível para modificação direta.

Configuração avançada

Ignorando análise

É uma prática comum que algumas bibliotecas exijam um bean para estender uma classe base.

Embora não seja o caso mais ideal, o Parceler suporta esta prática permitindo a configuração de quais classes na hierarquia de herança analisar através do parâmetro analyze:

Neste exemplo, apenas os campos das classes Um e Três serão serializados, evitando os parâmetros das classes BaseClass e Dois.

Embalagem específica

A classe de utilitário Parcels procura a classe fornecida para agrupar por classe.

Por razões de desempenho, isso ignora a herança, tanto as classes super quanto as classes base.

Existem duas soluções para este problema.

Primeiro, pode-se especificar tipos adicionais para associar ao tipo determinado através do parâmetro de implementação:

Segundo, também é possível especificar o tipo de classe ao usar o método Parcels.wrap():

Configurando o Proguard

Para configurar o Proguard, adicione as seguintes linhas ao arquivo de configuração do proguard. Eles manterão os arquivos relacionados à classe utilitária Parcels e à instância Parcelable CREATOR:

er

Obtendo Parceler

Você pode baixar o Parceler como uma dependência do Maven:

ou Gradle:

Ou da Maven Central.

Licença

exemplo:

Renderizador Mitsuba 3

Documentação	Vídeos tutoriais	Linux	Mac OS	Windows	PyPI

️

Aviso

️

Actualmente existe uma grande quantidade de trabalho indocumentado e instável em curso no

o ramo master . É altamente recomendável que você use nosso

último lançamento

até novo aviso.

Se você já deseja experimentar as próximas mudanças, dê uma olhada em

este guia de portabilidade.

Deve cobrir a maioria dos novos recursos e mudanças importantes que estão por vir.

Introdução

Mitsuba 3 é um sistema de renderização orientado para pesquisa para luz direta e inversa

simulação de transporte desenvolvida na EPFL na Suíça.

Consiste em uma biblioteca principal e um conjunto de plug-ins que implementam funcionalidades

variando de materiais e fontes de luz a algoritmos de renderização completos.

Mitsuba 3 é redirecionável : isso significa que as implementações subjacentes e

estruturas de dados podem ser transformadas para realizar várias tarefas diferentes. Para

Por exemplo, o mesmo código pode simular transporte RGB escalar (clássico de um raio por vez)

ou transporte espectral diferencial na GPU. Tudo isso se baseia

Dr.Jit, um compilador just-in-time (JIT) especializado desenvolvido especificamente para este projeto.

Principais recursos

• Plataforma cruzada : Mitsuba 3 foi testado em Linux ( x86_64 ), macOS

  ( aarch64 , x8664 ) e Windows ( x8664 ).

• Alto desempenho : o compilador Dr.Jit subjacente funde o código de renderização

  em kernels que alcançam desempenho de última geração usando

  um back-end LLVM direcionado à CPU e um back-end CUDA/OptiX

  visando GPUs NVIDIA com aceleração de hardware de rastreamento de raio.

• Python primeiro : Mitsuba 3 está profundamente integrado ao Python. Materiais,

  texturas e até mesmo algoritmos de renderização completos podem ser desenvolvidos em Python,

  que o sistema compila JIT (e opcionalmente diferencia) em tempo real.

  Isso permite a experimentação necessária para pesquisas em computação gráfica e

  outras disciplinas.

• Diferenciação : Mitsuba 3 é um renderizador diferenciável, o que significa que

  pode calcular derivadas de toda a simulação em relação à entrada

  parâmetros como pose de câmera, geometria, BSDFs, texturas e volumes. Isto

  implementa algoritmos de renderização diferenciáveis ​​recentes desenvolvidos na EPFL.

• Espectral e Polarização : Mitsuba 3 pode ser usado como monocromático

  renderizador, renderizador baseado em RGB ou renderizador espectral. Cada variante pode

  opcionalmente, considere os efeitos da polarização, se desejado.

Vídeos tutoriais, documentação

Gravamos vários vídeos no YouTube que fornecem uma introdução gentil

Mitsuba 3 e Dr.Jit. Além disso você pode encontrar notebooks Juypter completos

cobrindo uma variedade de aplicações, guias de instruções e documentação de referência

em readthedocs.

Instalação

Fornecemos rodas binárias pré-compiladas via PyPI. Instalar o Mitsuba desta forma é tão simples quanto executar

 pip instalar mitsuba

na linha de comando. O pacote Python inclui treze variantes por padrão:

• scalar_rgb

• scalar_spectral

• scalarspectralpolarized

• llvmadrgb

• llvmadmono

• llvmadmono_polarized

• llvmadspectral

• llvmadspectral_polarized

• cudaadrgb

• cudaadmono

• cudaadmono_polarized

• cudaadspectral

• cudaadspectral_polarized

Os dois primeiros realizam simulação clássica de um raio por vez usando um RGB

ou representação espectral de cores, enquanto os dois últimos podem ser usados ​​para representação inversa

renderização na CPU ou GPU. Para acessar variantes adicionais, você precisará

compilar uma versão personalizada do Dr.Jit usando CMake. Por favor veja o

documentação

para obter detalhes sobre isso.

Requisitos

• Python >= 3.8

• (opcional) Para computação na GPU: Nvidia driver >= 495.89

• (opcional) Para computação vetorizada/paralela na CPU: LLVM >= 11.1

Uso

Aqui está um exemplo simples de "Hello World" que mostra como é simples renderizar um

cena usando Mitsuba 3 do Python:

 # Importe a biblioteca usando o alias "mi"import mitsuba as mi# Defina a variante do renderermi.setvariant('scalarrgb')# Carregue uma scenecene = mi.loaddict(mi.cornellbox())# Renderize a cenaimg = mi. render(scene)# Grave a imagem renderizada em um arquivo EXRmi.Bitmap(img).write('cbox.exr')

Tutoriais e cadernos de exemplo cobrindo uma variedade de aplicações podem ser encontrados

na documentação.

Sobre

Este projeto foi criado por Wenzel Jakob.

Recursos e/ou melhorias significativas no código foram contribuídos por

Sébastien Speierer,

Nicolas Roussel,

Merlin Nimier-David,

Délio Vicini,

Tizian Zeltner,

Baptiste Nicolet,

Miguel Crespo,

Vicente Leroy e

Zi Yi Zhang.

Ao usar o Mitsuba 3 em projetos acadêmicos, cite:

 @software{Mitsuba3,title = {mitsuba 3 renderer},author = {Wenzel Jakob e Sébastien Speierer e Nicolas Roussel e Merlin Nimier-David e Delio Vicini e Tizian Zeltner e Baptiste Nicolet e Miguel Crespo e Vincent Leroy e Ziyi Zhang},nota = {https://mitsuba-renderer.org},versão = {3.1.1},ano = 2022}