Panda3D Manual: Atributos Render

Render Atributos BásicosDepois de carregar um modelo , pode alterar sua aparência , alterando a sua atributos. Por exemplo, você pode aplicar um cor para o modelo, você pode iluminar com luzes, Você pode fazer com que seja obscurecido por nevoeiro, Você pode fazê-lo parcialmente transparenteE assim por diante . Todos esses atributos são chamados de render.

Coletivamente, todos os atributos de um objeto são chamados de objeto Estado render, Ou às vezes apenas o objeto do Estado.

Propagação de AtributosOs atributos podem ser armazenados em qualquer nó do grafo de cena , definindo um atributo de um nó automaticamente aplica a esse nó , bem como a todos os filhos do nó (a menos que uma substituição é, com efeito , mas isso é um tópico mais avançado) .

É possível criar esses atributos e atribuir-lhes um nó diretamente:

Mas em muitos casos , especialmente com os atributos mais comumente vez , você não precisa criar os atributos diretamente como existe uma função de conveniência em NodePath (por exemplo, nodePath.setFog ()) Que gerencia a criação de atributos para você, haverá também uma função correspondente claras sobre NodePath para remover o atributo (nodePath.clearFog ()).

Atributo Prioridades RenderCada atributo tem um prioridade. Por padrão, que é prioridade zero. Isso afeta o valor de prioridade de herança de atributos.

Secção incompletaNota: esta seção está incompleta. Ele será atualizado em breve .

Lista de todos os atributos

A seguir está uma lista concisa de todas as RenderAttribs apoiado por Panda3D . documentação adicional pode ser encontrada clicando sobre o nome do RenderAttrib .

AlphaTestAttrib : Oculta parte do modelo , baseado no canal da textura alfa.

AntialiasAttrib : Controla o antialiasing em tela cheia e antialiasing borda do polígono .

AudioVolumeAttrib : Aplica-se uma escala de volume de áudio para sons posicionais.

AuxBitplaneAttrib : Causas shader gerador para produzir dados extra.

ClipPlaneAttrib : corta um pedaço do modelo, usando um plano de corte.

ColorAttrib : Tons modelo. Só funciona se o modelo não está iluminado.

ColorBlendAttrib : Especifica como as cores são misturadas com o frame buffer, para efeitos especiais.

ColorScaleAttrib : Cores vértice modula com uma cor plana.

ColorWriteAttrib : Faz com que o modelo não prejudicar a R, G , B, ou um canal de framebuffer .

CullBinAttrib : Controla a ordem na qual a geometria torna Panda.

CullFaceAttrib : backfaces Causas ou frontfaces do modelo a ser visível.

DepthOffsetAttrib : Faz com que o Z-buffer para tratar o objeto como se fosse mais perto ou mais longe.

DepthTestAttrib : Altera a forma como o Z-buffer afeta o modelo.

DepthWriteAttrib : Controla se ou não o modelo afeta o Z-buffer.

DrawMaskAttrib : Controla quais câmeras podem ver os objetos .

FogAttrib : Faz com que o modelo a ser obscurecida pela névoa se está longe da câmera.

LightAttrib : Faz com que o modelo a ser iluminada pelas luzes certas .

LightRampAttrib : permite o mapeamento de tom HDR ou sombreamento de desenhos animados.

MaterialAttrib : Altera a forma como o modelo reflete a luz .

RenderModeAttrib : Utilizado para permitir processamento wireframe.

RescaleNormalAttrib : É possível desativar a correção automática de normals unidade não .

ShadeModelAttrib : Pode causar o modelo apareça facetada , em vez de lisa.

ShaderAttrib : Dá um controle quase ilimitado, mas difícil de usar.

StencilAttrib : Faz com que o modelo de afectar o buffer estêncil, ou ser afetado pelo buffer estêncil.

TexGenAttrib : Faz com que o sistema de síntese de coordenadas de textura para o modelo.

TexMatrixAttrib : Altera a textura coordenadas existentes.

TextureAttrib : Aplica-se um mapa de textura para o modelo.

TransparencyAttrib : Faz com que o modelo fique parcialmente transparente .

IndocumentadosInfelizmente, o manual Panda3D é ainda um trabalho em progresso : há muitos aspectos que não são totalmente documentado. Esses atributos ainda não são documentadas:

AudioVolumeAttrib , CullBinAttrib , DepthOffsetAttrib , DrawMaskAttrib , RenderModeAttrib , RescaleNormalAttrib , ShadeModelAttrib

No entanto, embora o manual não documentar essas classes , a Referência documentação não .

Secção incompletaNota: esta seção está incompleta. Ele será atualizado em breve .

Panda3D Manual: Luz

Noções básicas de iluminaçãoNo mundo real se você colocar uma luz em um quarto , os objetos na sala são iluminados . Por exemplo, se você colocar um candeeiro de mesa em sua sala, a lâmpada acende automaticamente seu sofá e sua cadeira. Em um motor 3D, como Panda3D , as luzes não iluminam as coisas automaticamente. Em vez disso, você deve dizer a cadeira e sofá para ser iluminado pela lâmpada .

Então, para reiterar , a iluminação de uma cena em Panda3D é composto por duas etapas: 1. Criando luzes, e posicioná-los dentro da cena . 2. Contando a outros objetos para ser iluminado pelas luzes .

Panda3D define quatro tipos diferentes de objetos de luz : ponto, direcional, ambiente e holofotes. Cada um desses é um nó que deve ser dada em algum lugar dentro do gráfico da cena . Como qualquer coisa que você põe em cena , as luzes têm uma posição e orientação , que é determinado pelas operações básicas gráfico cena como setPos (), setHpr (), Etc A lookAt () método é particularmente útil para apontar holofotes e das luzes direcionais em um objeto específico. O código a seguir insere uma luz direcional à cena : dlight = DirectionalLight('my dlight')dlnp = render.attachNewNode(dlight)

Note que, ao contrário de um real, físico bulbo de luz , os objetos de luz não é visível se directamente . Embora você não pode ver uma luz própria Panda , você pode ver o efeito que tem sobre a geometria em torno dele. Se você quiser fazer uma luz visível, um truque simples é carregar um modelo simples (como uma esfera ), e mãe -lo diretamente para a própria luz .

Criando a luz e colocá-lo no grafo de cena não é , por si só , qualquer efeito visível. Seu próximo passo é informar algum objeto a ser iluminado pela luz . Para fazer isso , use o nodePath.setLight () método, que acende a luz para o NodePath indicado e tudo abaixo no gráfico de cena.

No caso mais simples , você quer todas as suas luzes para iluminar tudo o que podem , assim que você ativá-los na renda, no topo do gráfico de cena:

No caso mais simples , você quer todas as suas luzes para iluminar tudo o que podem , assim que você ativá-los na renda, no topo do gráfico de cena:

render.SetLight(plnp)

Você pode remover a definição de luz de render:

render.ClearLight(plnp)

Você também pode aplicar o SetLight () chamada para um sub -nó no grafo de cena, de modo que uma luz que só afeta um determinado objeto ou grupo de objetos : sofá.SetLight(plnp)

Note que há duas (ou mais) NodePaths envolvidos aqui: a NodePath da luz própria , que define a posição e / ou da orientação da luz, e os NodePath (s) em que você chamar SetLight (), Que determina o subconjunto do grafo de cena a luz acende.

Não há nenhuma exigência para estes dois NodePaths estar relacionadas de alguma forma.

Lots of Lights : Implicações PerformanceCada luz desacelera tornando um pouco. Usando uma meia dúzia de luzes para iluminar um objeto não é problema de todos. No entanto , se você usar uma centena de luzes para iluminar um objeto , esse objeto tornaria lentamente.

Devido a isso, quando você cria um grande mundo virtual , você precisa escolher quais as luzes que afetam objetos . Por exemplo, se você tivesse um calabouço com cem tochas, não seria prático para dizer a cada objeto a ser iluminado por cada tocha. Em vez disso, para cada objeto na masmorra, você pode querer procurar o mais próximo de três ou quatro tochas, e dizer ao objeto a ser iluminado apenas por aqueles três ou quatro tochas.

Quando a iluminação por pixel é habilitado , luzes são consideravelmente mais caros.

Luzes coloridasTodas as luzes têm uma cor , que é especificado pelo light.setColor ( VBase4 (r, b g , a)). A cor padrão é o branco total : setColor ( VBase4 (1, 1 , 1, 1 )). O componente alfa é largamente irrelevante .

Nota: R, G, B os valores podem ser maiores do que 1 , se você quiser luzes brilhantes ! No entanto, você não pode usar para fazer uma iluminação mais brilhante do que o seu modelo de cor, textura .

Ponto luzesPonto luzes são o tipo de luz mais fácil de entender: um ponto de luz simula a luz que emana de um único ponto no espaço e brilhando em todas as direções , como uma lâmpada muito pequena luz. A posição de um ponto de luz é importante , mas a sua orientação não importa.

plight = PointLight('plight')plight.setColor(VBase4(0.2, 0.2, 0.2, 1))plnp = render.attachNewNode(plight)plnp.setPos(10, 20, 0)render.setLight(plnp)

AtenuaçãoVocê pode definir os coeficientes de atenuação , o que faz com que a luz a cair gradualmente com a distância. Há três coeficientes de atenuação : A, B , C.

plight.setAttenuation(Point3(A, B, C))

Definir obras coeficientes A e B e C para 0 entre 0 e 1 poço .

plight.setAttenuation(Point3(0, 0, 0.5))

Luzes direcionaisA luz direcional é uma onda infinita de luz, sempre na mesma direção , como a luz solar . A posição da luz direcional não importa, mas sua orientação é importante. O padrão de luz direcional está brilhando para a frente (+ Y) , você pode usar nodePath.setHpr () ou nodePath.lookAt () girá-lo para enfrentar em uma direção diferente . dlight = DirectionalLight('dlight')dlight.setColor(VBase4(0.8, 0.8, 0.5, 1))dlnp = render.attachNewNode(dlight)dlnp.setHpr(0, -60, 0)render.setLight(dlnp)

Luzes AmbientUma luz ambiente é utilizado para preencher as sombras no lado escuro de um objeto , de modo que não parece completamente preto. A luz de uma luz ambiente é uniformemente distribuída em todo o mundo , por isso a posição da luz ambiente e orientação são irrelevantes.

Normalmente você não deseja criar um ambiente sem luz também a criação de um dos outros tipos de luzes, uma vez que o objeto iluminado apenas pela luz ambiente será totalmente plana sombreadas e você não será capaz de ver qualquer um dos seus detalhes. Normalmente , as luzes do ambiente são dadas uma cor bastante cinza escuro, para que eles não dominam as outras luzes na cena.

alight = AmbientLight('alight')alight.setColor(VBase4(0.2, 0.2, 0.2, 1))alnp = render.attachNewNode(alight)render.setLight(alnp)

HolofotesFocos representam o tipo mais sofisticado de luz. Um holofote tem tanto um ponto e uma direção , e um campo de visão . De fato, um holofote contém uma lente , tal como uma câmara que , a lente deve ser um PerspectiveLens e é usado para definir a área de efeito da luz (a luz ilumina tudo dentro do campo de visão da lente ).

Note que a palavra Inglês holofotes "é uma palavra , ao contrário de outros tipos de luzes , que são duas palavras. Assim, o nome da classe está correctamente escrito " Spotlight ", não" Spotlight " .

slight = Spotlight('slight')slight.setColor(VBase4(1, 1, 1, 1))lens = PerspectiveLens()slight.setLens(lens)slnp = render.attachNewNode(slight)slnp.setPos(10, 20, 0)slnp.lookAt(myObject)render.setLight(slnp)

Juntando TudoAqui está um exemplo de iluminação. Há uma luz ambiente e duas luzes direcionais iluminação da cena, e uma luz verde ambiental que afeta apenas um dos pandas.

import direct.directbase.DirectStartfrom pandac.PandaModules import * # Put two pandas in the scene, panda x and panda y.x = loader.loadModel('panda')x.reparentTo(render)x.setPos(10,0,-6) y = loader.loadModel('panda')y.reparentTo(render)y.setPos(-10,0,-6) # Position the camera to view the two pandas.base.trackball.node().setPos(0, 60, 0) # Now create some lights to apply to everything in the scene. # Create Ambient LightambientLight = AmbientLight('ambientLight')ambientLight.setColor(Vec4(0.1, 0.1, 0.1, 1))ambientLightNP = render.attachNewNode(ambientLight)render.setLight(ambientLightNP) # Directional light 01directionalLight = DirectionalLight('directionalLight')directionalLight.setColor(Vec4(0.8, 0.2, 0.2, 1))directionalLightNP = render.attachNewNode(directionalLight)# This light is facing backwards, towards the camera.directionalLightNP.setHpr(180, -20, 0)render.setLight(directionalLightNP) # Directional light 02directionalLight = DirectionalLight('directionalLight')directionalLight.setColor(Vec4(0.2, 0.2, 0.8, 1))directionalLightNP = render.attachNewNode(directionalLight)# This light is facing forwards, away from the camera.directionalLightNP.setHpr(0, -20, 0)render.setLight(directionalLightNP) # Now attach a green light only to object x.ambient = AmbientLight('ambient')ambient.setColor(Vec4(0.5, 1, 0.5, 1))ambientNP = x.attachNewNode(ambient) # If we did not call setLightOff() first, the green light would add to# the total set of lights on this object. Since we do call# setLightOff(), we are turning off all the other lights on this# object first, and then turning on only the green light.x.setLightOff()x.setLight(ambientNP) #run the examplerun()

Shadow Mapping Quanto à versão 1.7.0 , Panda3D oferece suporte mapeamento totalmente automático sombra de holofotes e luzes direccionais . Você pode habilitar sombras

chamando setShadowCaster (). Os nós que recebem sombras precisará ter o Shader Generator ativado , caso contrário nenhuma sombra vai aparecer. # Use a 512x512 resolution shadow maplight.setShadowCaster(True, 512, 512)# Enable the shader generator for the receiving nodesrender.setShaderAuto()

Note que, embora em geral sombreamento é fácil de configurar , você vai querer ajustar as configurações de luz da lente para obter a melhor precisão buffer de profundidade. Use o setNearFar () método na lente para obter um ajuste perfeito do que está sendo processado . Além disso, para luzes direcionais , você vai precisar ligar para setFilmSize () na lente e da posição da luz corretamente para que a câmara irá receber uma luz óptima vista da cena.

Além disso, note que todas as luzes é, na verdade também uma câmera , assim você pode facilmente excluir objetos sendo sombreado (por exemplo, por razões de performance ) por uso de máscaras câmera.

Se você tem objetos muito fino, você pode executar em self-shadowing problemas se a parte traseira do objeto lança sombras sobre o seu frontside . Você pode facilmente corrigir isso através da aplicação de uma profundidade de deslocamento para o objeto em questão. A profundidade de deslocamento de um meio de utilizar um desvio tão pequeno quanto possível, mas grande o suficiente para fazer a diferença. Isso geralmente deve ser suficiente. Você pode chamar setDepthOffset () no NodePath ou usar o profundidade de compensação escalar no arquivo do ovo. .

leaves.setDepthOffset(1)

Panda3D Manual : Materiais

   Prev TopoPróximo

  Pitão/C + +

  Materiais Materiais afetam as superfícies dos modelos aparecem quando as luzes são ativadas no Panda. Estas têm efeitos diversos, tais como a forma como um objeto brilhante aparece , o brilho de suas cores , etc propriedades do material são combinadas com texturas e iluminação para obter a aparência final de um objeto.

Deve ser enfatizado que somente os materiais de trabalho quando as luzes são aplicados a um objeto. Caso contrário , os materiais não têm nenhum efeito .

Explicação da Luz

Quando a luz atinge um modelo 3D , a luz reflete fora do modelo. Se não houvesse nenhuma luz, refletindo o modelo , o modelo parece escuro. A luz, refletindo o modelo é o que ele faz para ter uma tela de cor não-negros. No mundo real , a luz é incrivelmente complicado --- tão complicado, que é inviável para fazer cálculos realistas. Em vez disso, Panda3D deixa em suas mãos, dando-lhe algumas ferramentas básicas para expressar a quantidade de luz que você quer reflectindo em cada superfície.

As ferramentas fornecidas são luzes e materiais. As luzes são utilizadas para expressar o quanto a luz é impressionante o modelo. Os materiais são utilizados para expressar o quanto de luz que atinge o modelo é refletido.

Panda3D separa a luz que atinge o modelo em duas categorias gerais : não direccional e direccional. Direcionais de luz é a luz que vem diretamente de uma lâmpada especial . Porque nós sabemos onde ele está vindo , nós também sabemos que direção ele está vindo. luz não direcional é a luz que talvez veio de algum lugar, saltou -se um pouco , e depois , eventualmente, acertar o modelo. Porque nós não sabemos exatamente de onde veio , não sabemos em que direção ele está vindo. Panda3D alças luz direcional e não direcional separadamente.

Existem quatro tipos de luzes no Panda3D : ponto, ambiente , difuso e direcional. A luz ambiente só cria a luz não direcional . As outras três criam a luz direcional.

Quando a luz atinge a superfície do modelo, é o material que regula a quantidade de que ela reflete. O material consiste de quatro valores:

Ambient Scattering: regula o quanto a luz é refletida não direcional . luz não direcional é sempre assumida a vir de todas as direções, e ele sempre se reflete em todas as direções igualmente.

Espalhamento difuso: regula a quantidade de luz direcional é dispersa. Espalhamento significa que a luz pode ter chegado a partir de uma determinada direção , mas ele rebate o modelo em todas as direções . Espalhamento de luz parece bater uma parede pintada de branco.

Reflexão Especular: regula o quanto de luz direcional é refletida. Reflexão especular se parece com a luz que atinge um pedaço de plástico brilhante : você pode ver vagamente uma reflexão da luz do plástico , mas a reflexão parece apenas um ponto brilhante .

Emissividade: regula a quantidade de luz na superfície produz a si mesmo , para superfícies brilhantes como o brilho de néon ou varas.

O comportamento padrão de comportamento e explicitoSe o modelo não tem um material explícito, não tem uma cor lisa, e não tem as cores de vértice, o comportamento é o seguinte:

1. Toda a luz é refletida não direcional sem cor . 2. Toda a luz direcional é espalhada sem cor . 3. Nenhum reflexão especular ocorre. 4. Nenhum emissivity ocorre.

Se o modelo não tem um material explícito, mas ele tem uma cor lisa ou uma cor de vértice , o comportamento é o seguinte:

1. Toda a luz é refletida não direcional após ser modulada pela cor do modelo. 2. Toda a luz direcional é dispersado após ser modulada pela cor do modelo. 3. Nenhum reflexão especular ocorre. 4. Nenhum emissividade ocorre.

Quando você define um material explícita em um objeto, o comportamento é o seguinte:

1. Toda a luz é refletida não direcional após ser modulada pela cor explícita ambiente.

2. Toda a luz direcional é dispersado após ser modulada pela cor difusa explícito.

3. Toda a luz direcional é refletida especularmente após ser modulada pela cor explícita especular.

4. A cor emissiva explícito é adicionado à luz.

É possível misturar e combinar explícita com o comportamento padrão. Por exemplo , você pode especificar uma cor especular explícito , mas não especificar um ambiente explícita, difusa, ou a cor emissiva. Se você fizer isso , o comportamento seria:

1. Toda a luz é refletida não direcional após ser modulada pela cor do modelo. 2. Toda a luz direcional é dispersado após ser modulada pela cor do modelo. 3. Toda a luz direcional é refletida especularmente após ser modulada pela cor

explícita especular. 4. Nenhum emissividade ocorre.

Criação e utilização de materiaisPara utilizar materiais explícitos, importar as matérias do módulo quando você começar o seu primeiro script. Então, a criação de materiais é uma questão de criar instâncias da classe de Material e definindo as propriedades relevantes:

from pandac.PandaModules import Materialfrom pandac.PandaModules import VBase4#VBase4 has to be imported in order to set colors in the methods

myMaterial = Material()myMaterial.setShininess(5.0) #Make this material shinymyMaterial.setAmbient(VBase4(0,0,1,1)) #Make this material blue

myNode = loader.loadModel("panda") #Load the model to apply the material tomyNode.setMaterial(myMaterial) #Apply the material to this nodePath

Material PropertiesA tabela a seguir detalhes as propriedades disponíveis em um material, seus efeitos , bem como o método setter relevantes. A maioria destas propriedades têm adicional obter e claro os métodos também.

Propriedade Efeitos Setter Método

Ambiente

Esta é a cor do objeto como ele aparece na ausência de luz direta. Esta será a multiplicado por todas as luzes do ambiente em vigor sobre a matéria para definir a cor base.

material.setAmbient ( VBase4 (R , G , B, A))

Difuso

Esta é a cor principal de um objeto , a cor do objeto como ele aparece na luz directa, na ausência de destaques. Esta será multiplicado por todas as luzes em vigor sobre a matéria para obter a cor de partes do objeto iluminado pelas luzes .

material.setDiffuse ( VBase4 (R , G , B, A))

Emissão

Esta é a cor do objeto como ele aparece na ausência de qualquer whatsover luz, incluindo luz ambiente. É como se o objeto está brilhando por essa cor (mas é claro que não vai iluminar objetos vizinhos)

material.setEmission ( VBase4 (R , G , B, A))

Brilho

Este controla o tamanho da mancha realce especular. Em geral, maior número de produzir um menor realce especular , o que torna o objeto aparecerá mais brilhante . Números menores produzem um maior destaque , o que torna o objeto parece menos brilhante.

material.setShininess ( <float> )

Especular Esta é a cor de realce de um objeto : a cor das reflexões pequeno destaque .

material.setSpecular ( VBase4 (R , G , B, O ))

Em inglês:

Property Effects Setter Method

Ambient

This is the color of the object as it appears in the absence of direct light. This will be the multiplied by any ambient lights in effect on the material to set its base color.

material.setAmbient(VBase4(R,G,B,A))

Diffuse

This is the primary color of an object; the color of the object as it appears in direct light, in the absence of highlights. This will be multiplied by any lights in effect on the material to get the color in the parts of the object illuminated by the lights.

material.setDiffuse(VBase4(R,G,B,A))

Emission

This is the color of the object as it appears in the absence of any light whatsover, including ambient light. It is as if the object is glowing by this color (although of course it will not illuminate neighboring objects)

material.setEmission(VBase4(R,G,B,A))

Shininess

This controls the size of the specular highlight spot. In general, larger number produce a smaller specular highlight, which makes the object appear shinier. Smaller numbers produce a larger highlight, which makes the object appear less shiny.

material.setShininess(<float>)

SpecularThis is the highlight color of an object: the color of small highlight reflections.

material.setSpecular(VBase4(R,G,B,A))

Other Material MethodsAlém dos métodos setter indicado acima, você também pode obter as propriedades dos materiais com os seus métodos get , como material.getShininess () , material.getDiffuse (), Etc

Propriedades também podem ser redefinido usando os métodos claros: material.clearAmbient (),material.clearSpecular (), Brilho , etc não tem um método claro .

Além disso, você pode verificar se um material tem uma propriedade com o tem métodos : material.hasAmbient () , material.hasEmission (), Etc

Os materiais têm dois outros métodos que não foram cobertos ainda, SETLOCAL () e setTwoside (). controles SETLOCAL se usar câmera em relação especulares ou especular ortogonais destaques. Isso deve ser definido como True , a menos de uma câmera de projeção ortogonal está em uso. controles setTwoside se a iluminação deve aparecer em ambos os lados de um polígono. Ambos os métodos têm obter métodos equivalentes .

Classes relacionadas

Material MaterialCollection Panda3D Manual: Teste de profundidade e de

profundidade Escrever   Prev Topo Próximo

  Pitão/C + +

  

Ativar ou desativar o buffer de profundidade Por padrão, o buffer de profundidade é habilitado e funciona normalmente. É

possível desativar o uso do buffer de profundidade. Também é possível alterar o comportamento do buffer de profundidade.

A coisa mais comum que queremos fazer é desativar a profundidade escrever. Isto significa que a geometria ainda será testado contra o buffer de profundidade , mas isso não afetará o buffer de profundidade . Isto é frequentemente usado na renderização objetos como estas partículas que são transparentes. Para ativar ou desativar a profundidade escrever , use:

nodePath.setDepthWrite(False) # DisablenodePath.setDepthWrite(True) # Enable

Também pode ser desejável para desativar o teste de profundidade . Isto significa que a geometria paga qualquer tipo de atenção para o conteúdo do buffer de profundidade . Isto é usado frequentemente para tornar as coisas como displays "heads -up , que não têm relação com a profundidade em 3D da cena. Para ativar ou desativar a profundidade de teste , use:

nodePath.setDepthTest(False) # DisablenodePath.setDepthTest(True) # Enable

Alterando o buffer de profundidadeOcasionalmente, é desejável alterar a funcionalidade do buffer de profundidade. Normalmente, o buffer de profundidade só torna as coisas que estão na frente, mas pode ser feito para tornar as coisas que estão em volta, ou igual . Isto é raramente utilizado , mas pode ser importante para determinados algoritmos incomuns como volumes de sombra.

Para fazer isso , você precisará usar o DepthTestAttrib diretamente, em uma das seguintes variantes :

nodePath.setAttrib(DepthTestAttrib.make(RenderAttrib.MNone))nodePath.setAttrib(DepthTestAttrib.make(RenderAttrib.MNever))nodePath.setAttrib(DepthTestAttrib.make(RenderAttrib.MLess))nodePath.setAttrib(DepthTestAttrib.make(RenderAttrib.MEqual))nodePath.setAttrib(DepthTestAttrib.make(RenderAttrib.MLessEqual))nodePath.setAttrib(DepthTestAttrib.make(RenderAttrib.MGreater))nodePath.setAttrib(DepthTestAttrib.make(RenderAttrib.MGreaterEqual))nodePath.setAttrib(DepthTestAttrib.make(RenderAttrib.MNotEqual))

nodePath.setAttrib(DepthTestAttrib.make(RenderAttrib.MAlways))

Profundidade SeleçãoAo virar teste profundidade fora, às vezes é desejável usar a classificação de profundidade em seu lugar. Classificando a profundidade é controlada pelo sistema de abate , o que pode ser controlado pelo CullBinAttrib .

TransparênciaAlgumas definições do TransparencyAttrib também pode afetar o teste de profundidade .

Panda3D Manual: Nevoeiro

Nevoeiro BasicPara ativar a neblina, criar um objeto da classe Nevoeiro, E depois aplicá-lo usando o setFog operador:

myFog = Fog("Fog Name")myFog.setColor(R,G,B)myFog.setExpDensity(Float 0 to 1)render.setFog(myFog)

No entanto, há mais aqui do que aparenta. Nós criamos uma nó de nevoeiro, Que vai para o grafo de cena. Portanto, o nevoeiro de uma posição , um lugar onde a neblina é ( conceitualmente) mais grossa .

Se o objeto de nevoeiro , não é pai no grafo de cena ( no exemplo anterior , por exemplo ), então a posição do nevoeiro é ignorado, eo nevoeiro é câmera relativa. Da mesma forma, se o nevoeiro é exponencial , a posição do nevoeiro é ignorado, eo nevoeiro é câmera relativa.

O setFog directiva cria um objeto atributo nevoeiro. Como em qualquer Render Attribute, O atributo de nevoeiro afeta o nó que está ligado a ela e todos os nós abaixo dele no grafo de cena. Assim, você pode facilmente causar apenas um subconjunto dos objetos (ou apenas um modelo único ) a ser afetado pela névoa , chamando setFog na raiz do subgrafo que você quer ser afetados. Para remover o atributo de nevoeiro depois, usar o clearFog directiva: render.clearFog()

Quando você tiver neblina na verdade, muitas vezes é desejável definir a cor de fundo para coincidir com o nevoeiro :

base.setBackgroundColor( myFogColor )

Modos de Nevoeiro

Existem dois modos de nevoeiro em Panda: Fog.MExponential e Fog.MLinear. Você pode alternar o modo de um Nevoeiro objeto usando fog.getMode () e fog.setMode ( Fog.Mode ). Esta troca de modo explícito , não é normalmente necessário , como Nevoeiro métodos implicitamente mudar o modo para você. A Nevoeiro objeto em um Panda3D nó que pode ser pai no grafo de cena com uma posição , cor e orientação , como qualquer outro nó ( importante, Nevoeiro é uma subclasse de PandaNode, E não de NodePath) (Não Nevoeiro nós temos uma

escala ?).

A posição de um Nevoeiro nó do grafo de cena não determina quais objetos neblina

afeta, Determina a origem e direção da névoa quando ele está em modo linear. Quando um nó está no modo de nevoeiro exponencial a sua posição e orientação no grafo de cena são irrelevantes. De qualquer maneira , um Nevoeiro nó deve ser ativado pelo telefone nodePath.setFog ( fogNode ) em alguns NodePath no grafo de cena. Que NodePath chamar o setFog método em determinar quais partes da cena será fogged : que NodePath e todos os seus filhos .

Nevoeiro LinearEste é o modo padrão. Neste modo, o posição e orientação de um Nevoeiro nó são importantes. Um modo linear Nevoeiro nó deve primeiro ser pai no grafo de cena, então ativado ligando setFog ( fogNode ) em alguns NodePath no grafo de cena.

Instalação de um nó de nevoeiro lineares na origem :

colour = (0.5,0.8,0.8)linfog = Fog("A linear-mode Fog node")linfog.setColor(*colour)linfog.setLinearRange(0,320)linfog.setLinearFallback(45,160,320)render.attachNewNode(linfog)render.setFog(linfog)

No modo linear , o começo e opaco distâncias do nevoeiro são definidos como desvios ao longo da frente local ( + Y) do nó de nevoeiro. O início distância é a distância entre o nó de nevoeiro em que o fog começará a ter efeito, e opaco da distância é a distância entre o nó de nevoeiro em que o nevoeiro será totalmente opaco . Da leitura da página API para o Nevoeiro class, it sounds as if beyond this opaque point there is no fog (rather than continuing opaque fog up to the location of the fog node as you might expect): "the fog will be rendered as if it extended along the vector from the onset ponto a ponto opaco ".

Estas configurações podem ser modificadas utilizando os métodos getLinearOnsetPoint (), getLinearOpaquePoint (), setLinearOnsetPoint (float x , y, z), setLinearOpaquePoint (pos Point3D ) e setLinearRange (float início , float opaco) de Nevoeiro.

Há um problema com hardware de processamento de nevoeiro , o que significa que o nevoeiro linear repartição pode desaparecer e , dependendo do ângulo a partir do qual ele é visto :

"O efeito de névoa subjacente apoiado por hardware geralmente é apenas uma dimensão, e devem ser prestados com base na distância linear em relação ao plano da câmera. Assim, o efeito no-mundo - é mais eficaz quando o vetor de nevoeiro do ponto de início para opaco ponto é mais quase paralelo ao vetor da câmara ocular. Como o ângulo entre o vetor de nevoeiro e os aumentos vetor olho , a precisão do efeito diminui, até um colapso total do efeito em um ângulo de 90 graus. " O Nevoeiro método setLinearFallback (float ângulo, início float , float opaco) define como a neblina deve ser tomada quando os efeitos de nevoeiro diminui dessa forma. ângulo é o ângulo de visão mínimo ( ângulo entre a direção da câmera e direção de nevoeiro ) na qual o efeito de recurso será empregado. começo e opaco especificar câmera em relação aparecimento e as distâncias opaco , que será caído novamente, substituindo o Nevoeiro início próprio nó e as distâncias opaco.

O setLinearFallback (float ângulo, início float , float opaco) solução só ficam bem em determinadas situações, por exemplo, quando o nevoeiro é profundo dentro de uma caverna escura. Portanto, em geral , neblina modo exponencial é mais útil do que o padrão de nevoeiro modo linear.

Nevoeiro Exponencial

No modo de nevoeiro exponencial a posição e orientação do seu nó de nevoeiro no grafo de cena eo início e pontos opacos são ignorados (na verdade você nem precisa colocar o nó de nevoeiro no grafo de cena ). Instead, fog is rendered camera relative according to a density factor: the fog begins at the camera and continues to infinity, with an exponentially increasing density determined by the density factor. Os movimentos de nevoeiro com a câmera, a posição da câmera e as mudanças de orientação:

"O ponto de início eo ponto opaco não são usados , eo efeito de nevoeiro é baseado no valor especificado para set_exp_density (), E isso não importa para qual objeto o nó do nevoeiro é pai , ou se ele é pai em qualquer lugar em todos ". O fog.setExpDensity (float) método determina o valor da densidade utilizada para cálculos de nevoeiro exponenciais.

Você ativar um efeito de névoa exponencial chamando o setFog ( Fog ) método de NodePath, Por exemplo: render.setFog ( myFog ):

Instalação alguns nevoeiro cena escala exponencial:

colour = (0.5,0.8,0.8)expfog = Fog("Scene-wide exponential Fog object")expfog.setColor(*colour)

expfog.setExpDensity(0.005)render.setFog(expfog)base.setBackgroundColor(*colour)

A última linha no exemplo acima não é realmente afetar o nevoeiro , no entanto, que geralmente fica melhor se a cor de fundo de cena coincide com a cor do nevoeiro.

Desde setFog é chamado render que os efeitos da cena inteira. setFog pode tão facilmente ser chamado em alguns outros NodePath eo único efeito que será NodePath e seus filhos. O efeito nevoeiro expontential pode ser desligado usando novamente clearFog:

render.clearFog()

Alpha TestingO teste alfa atributo determina se ou não parte de um nó será processado com base no valor alfa de sua textura. Isso é particularmente útil para a renderização de geometria complexa em profundidade ou stencil buffer com um cartão de textura ao invés de criar explicitamente as formas.

Este teste é diferente do processamento em relação ao valor de transparência alfa. Caso você defina um teste alpha atributo em um nó que é renderização para o buffer de cor, você pode ser surpreendido com o resultado. Todos os pixels que passar no teste alfa será processado como se nenhum teste havia sido realizado , incluindo a sua transparência e adequada pixels que falhar no teste não serão prestados a todos.

Lembre-se de definir a prioridade do seu atributo para substituir qualquer teste alfa outros atributos herdados maior no grafo de cena.

No exemplo abaixo , criamos um atributo que causaria objetos para renderizar somente se o seu valor alfa é inferior a um quarto intensidade .

lowPassFilter = AlphaTestAttrib.make(RenderAttrib.MLess,0.25)

E agora , esse atributo pode ser adicionado a um nó para permitir a ação.

nodePath.setAttrib(lowPassFilter)

Secção incompletaNota: esta seção está incompleta. Ele será atualizado em breve .

Cor Escrever MáscarasCor escrever máscaras permitem que você escreve para o bloco vermelho, verde, azul, ou canais alfa do framebuffer . Isto não é um recurso freqüentemente usado, mas tem algumas aplicações :

Ao usar vermelho-azul óculos 3D , você pode querer processar a imagem vermelha , então a imagem azul. (Na verdade , o Panda utiliza esta técnica automaticamente quando você definir vermelho-azul- estéreo 1 em seu arquivo Config.prc ).

Battletech Battle Pods ligar 3 monitores em preto-e - branco para um único R , G, B saída da placa de vídeo ( muito !) Com a ajuda de máscaras escrever cor , você pode atualizar um monitor individual.

Às vezes, se quer armazenar os dados no canal alfa do framebuffer . Usando uma máscara de cor pode evitar acidentalmente sobrescrever os dados.

Usando uma máscara cor - escrever não é livre. Durante o processamento normal, cada pixel de escrita para o buffer de quadro exige uma memória escrever. Com uma máscara cor -activa , uma memória de leitura -modificação-gravação do ciclo é necessário, que é mais caro .

Por padrão , a cor escrever máscaras estão desligados.

Ligar a Máscara de CorPara habilitar escreve a todos os canais do framebuffer , use isto:

bits = ColorWriteAttrib.CAlphabits |= ColorWriteAttrib.CRedbits |= ColorWriteAttrib.CGreenbits |= ColorWriteAttrib.CBluenodePath.setAttrib(ColorWriteAttrib.make(bits))

Para desativar escreve para um ou mais canais , omita esse bocado . Você também pode usar:

nodePath.setAttrib(ColorWriteAttrib.make(ColorWriteAttrib.CAll))

Para permitir que todos os bits.

AntialiasingO antialias atributo de um nó controla o tipo de suavização é aplicada para esse nó. Para escolher uma das várias formas de anti-aliasing , invocar uma das seguintes variantes :

np.setAntialias(AntialiasAttrib.MNone)np.setAntialias(AntialiasAttrib.MPoint)np.setAntialias(AntialiasAttrib.MLine)np.setAntialias(AntialiasAttrib.MPolygon)np.setAntialias(AntialiasAttrib.MMultisample)np.setAntialias(AntialiasAttrib.MAuto)

Em geral, quando tornar modelos poligonais , antialiasing multisample parece melhor . No entanto, quando as linhas e pontos de prestação , que geralmente fica melhor para escolher um dos modos de antialiasing especializados. O Mauto configuração seleciona automaticamente o tipo que geralmente funciona melhor

para a geometria em questão. Assim, se você quiser ativar antialiasing em toda a cena , basta usar:

render.setAntialias(AntialiasAttrib.MAuto)

render.setAntialias(AntialiasAttrib .Mauto)

Para que multisample antialiasing para o trabalho, você tem que ter multisample bits disponível na sua framebuffer . Para solicitar este , acrescentar:

multisample framebuffer -1multisamples 2

ao seu arquivo Config.prc . Note que nem todas as placas gráficas têm esta capacidade. Você também pode solicitar multisamples mais , como 4 ou 8 , dependendo da sua placa gráfica. Se o seu cartão pode fornecer amostras adicionais , que produz um anti-aliasing de alta qualidade , a um custo pequeno para tornar o tempo.

A função clearAntialias pode ser usado para remover a antialias configuração. A função setAntialias tem um parâmetro de prioridade opcional, para controlar substitui atributo.

Aviso geral sobre Clip PlanesA maioria dos motoristas faz um trabalho muito pobre de planos de execução do grampo. Além disso , a maneira que os aviões clip combinar com shaders podem ser imprevisíveis . O uso de aviões clipe não é recomendado. É possível emular aviões clip em um sombreador usando o descartar instrução.

Secção incompletaNota: esta seção está incompleta. Ele será atualizado em breve .

Cor e modelo do LoaderQuando você cria um modelo em 3D Max, Maya , ou algo parecido , você pode colorir o modelo certo no programa de modelagem. Eu não estou falando sobre o uso de uma textura. Estou falando apenas definir uma cor única para o modelo como um todo. Isso é chamado de cores "flat ". Estes programas também permitem a arte de " pintar cores vértice ": você pode colorir cada vértice do modelo de uma cor diferente. Claro que, às vezes você nem , caso em que o modelo é apenas um branco.

Cada modelo de carregar já tem um atributo de cor . Atributos de cor normalmente não são criados explicitamente pelo programador , que são normalmente criados

pelo gestor único modelo . Existem três cores possíveis atributos criado pelo gestor de modelo:

Método Explicação

ColorAttrib.makeVertex () Usada pelo gerenciador de modelo para indicar que o modelo tem cores vértice armazenados em seus painéis de vértice.

ColorAttrib.makeFlat ( Vec4 (R , B G , A))

Usada pelo gerenciador de modelo para indicar que o modelo tem uma cor plana.

ColorAttrib.makeOff ()

Usada pelo gerenciador de modelo para indicar que nenhuma cor em particular foi especificado. Essencialmente o mesmo em branco liso, mas possivelmente um pouco mais rápido para processar.

Panda combina os atributos de cor com as texturas . Se você está acostumado a photoshop, você deve pensar o modelo de cor como fundo (background) da camada, e as texturas que vão acima . Por padrão, cada textura é modulada (multiplicado ) com a camada anterior, mas como no photoshop, que pode ser mudado .

Recolorir ModeloSe desejar, você pode substituir manualmente o atributo de cor que foi especificada pelo gestor do modelo.

nodePath.setColor (r, b g , a)

Novamente, esta é uma substituir. Se o modelo já tinha cores vértice , estes vão desaparecer : o setColor método é substituir as cores com um novo. Se o modelo já tinha uma cor lisa, que será substituído com a nova cor lisa. Refira-se que o atributo cor criado pelo carregador modelo tem baixa prioridade. Isso significa que mesmo um padrão de prioridades setColor é o suficiente para substituí-lo . Você pode remover uma versão anterior setColor uso clearColor.

Matizar o modeloÀs vezes, você não quer substituir a cor existente , às vezes , você quer matiz as cores existentes. Para isso, você precisa setColorScale:

import direct.directbase.DirectStartfrom pandac.PandaModules import ColorAttrib

# Load three copies of Nik's dragon, which has vertex colors.model1 = loader.loadModel("nik-dragon")model2 = loader.loadModel("nik-dragon")model3 = loader.loadModel("nik-dragon")

# Put them in the scene.model1.reparentTo(render)model2.reparentTo(render)model3.reparentTo(render)

# Arrange them left-to-rightmodel1.setPos(-10,50,0)model2.setPos( 0,50,0)model3.setPos( 10,50,0)

# Model 1 will be left alone, so you can see the original.# Model 2 will be recolored light blue.# Model 3 will be tinted light blue.model2.setColor(0.6, 0.6, 1.0, 1.0)model3.setColorScale(0.6, 0.6, 1.0, 1.0)

run()

Isso produz o seguinte resultado:

O modelo da esquerda é o modelo original, inalterado. Nik usou cores vértice todo . O amarelo da barriga , os olhos negros, boca vermelha , estas são todas as cores de vértice. O do meio tem sido setColored uma cor meio azul. Como você pode ver , o setColor substitui totalmente a cores de vértice. A da direita foi bas setColorScaleed para a mesma cor azul- médio , mas apenas o modelo de matizes .

Classes relacionadas

ColorScaleAttrib ColorAttrib NodePath Backface e Frontface Abate Por padrão, o Panda3D automaticamente abates (não processar ) backfaces

de polígonos. Em outras palavras, o polígono age como um espelho : você pode vê-lo de um lado , mas do outro lado , é ver -through. backface abate é uma otimização de performance muito útil. Sem ele , o motor 3D teria para tornar o dentro da superfície de modelos 3D. Uma vez que esta superfície não é visível qualquer forma , isso é totalmente desperdiçado trabalho. Desde que a superfície do interior é igual à superfície da parte externa , isto aproximadamente o dobro da quantidade de trabalho da placa de vídeo tem que fazer. É por isso que backface abate é ativado por padrão .

Curiosamente, isso significa que se você mover a câmera dentro de um modelo fechado em 3D, normalmente você pode ver para fora. Isso é realmente muito mais conveniente do tempo.

No entanto, existem casos em que você quer ser capaz de ver backfaces . Há também casos muito raros, quando você não quero ver front- faces. Portanto, backface e abate frontface pode ser controlado.

Atenção: inexperiente modeladores 3D , por vezes, criar modelos com os polígonos que enfrentam interior, Ou seja , o lado visível do polígono está no interior do modelo 3D e ver o lado é através do lado de fora . Como resultado, o modelo 3D pode parecer muito estranho - que pode ter buracos, ou ele pode olhar de dentro para fora . Desligar backface abate pode classificar de "corrigir" estes modelos, a um alto custo : em primeiro lugar , faz-lhes render um meia mais rápido, e segundo , faz com que os artefatos de iluminação estranho (porque a placa de vídeo é o cálculo da iluminação para o interior do modelo, não de fora ). Esta não é uma solução real para a modelagem 3D ruim: a correção só é real para fazer os modelos 3D corretamente em primeiro lugar.

Em outras palavras, não alteram a backface frontface abate ou menos que você esteja usando um algoritmo que exige, como sombras stencil.

Rendering Dupla Face Há uma maneira rápida de tornar um determinado NodePath em sua cena

de dupla face, o que significa que não o abate é realizado em todos e os dois lados são visíveis , sem hassling com attribs :

nodePath.setTwoSided(True)

Se você quiser um controle mais avançado sobre o sacrifício que você pode querer olhar para o CullFaceAttrib :

Controlando Backface e Frontface Abate

Existem três definições válidas para abate :

nodePath.setAttrib(CullFaceAttrib.make(CullFaceAttrib.MCullNone))nodePath.setAttrib(CullFaceAttrib.make(CullFaceAttrib.MCullClockwise))nodePath.setAttrib(CullFaceAttrib.make(CullFaceAttrib.MCullCounterClockwise))

Nenhum significa que todas as faces são visíveis , tanto para trás e da frente. No sentido horário, é a configuração padrão , ele faz backfaces de ser abatidos. Sentido anti-horário é o cenário inverso , provoca frontfaces de ser abatidos.

Panda3D Manual: Luz Rampas

   Prev TopoPróximo

  Pitão/C + +

  

Light RampasNo padrão OpenGL e DirectX de iluminação , os cálculos que se seguem são realizadas:

o valor é calculado de iluminação é fixada ao intervalo 0-1 é combinado com as texturas é fixada ao intervalo 0-1 novamente ele é escrito para o frame buffer

Este processo contém dois grampos. O LightRampAttrib é um meio de especificar que você deseja substituir esses dois operadores de aperto com algo um pouco mais esperto. Isto é particularmente relevante para dois algoritmos principais gráficos : HDR de mapeamento de tom e de sombreamento de desenhos animados.

Deve ser enfatizado que as rampas de luz tem efeito a menos que a iluminação por pixel é ativado via o gerador de shader.

HDR de mapeamento de tomEm HDR mapeamento de tom , a braçadeira primeiro é totalmente removido , eo segundo é substituído pelo operador de mapeamento de tom . O tom mapas mapeamento operador valores de brilho na faixa de 0 a infinito novos valores de brilho na gama 0-1, no entanto, fá-lo sem aperto. Para ativar o HDR mapeamento de tom , use um dos seguintes procedimentos:

np.setAttrib(LightRampAttrib.makeHdr0())np.setAttrib(LightRampAttrib.makeHdr1())np.setAttrib(LightRampAttrib.makeHdr2())

O mapeamento de tom HDR2 operador é um operador familiar que é usado em muitos sistemas. Tem a desvantagem de que tende a reduzir o contraste muito:

FINAL_RGB = RGB () / (RGB + 1)

O operador de mapeamento HDR1 tom é similar , mas atribui o intervalo de mais de contraste com brilhos no intervalo 0-1, e menos de brilho na faixa de 1 até infinito . Isso rende uma cena de alto contraste , mas com mais washout :

FINAL_RGB = (RGB ^ 2 + RGB) / (RGB ^ 2 + RGB + 1)

O operador de mapeamento de tom HDR0 atribui ainda mais a gama de contraste disponível para brilhos na faixa de 0-1. Isto é ainda mais contrastantes , mas com ainda mais washout :

FINAL_RGB = (RGB ^ 3 + 2 + ^ RGB RGB) / (RGB + RGB ^ 3 ^ 2 + RGB + 1)

Cartoon sombreado ( iluminação Quantized )Na sombra dos desenhos animados, o primeiro grampo é removido por completo, eo segundo é substituído por uma função de quantização. Isso substitui um gradiente contínuo de valores de brilho com um conjunto discreto de níveis de luz. Esta função só se aplica a quantização luzes direcionais , não os ambientes.

Para ativar a iluminação quantizado, use um dos seguintes :

np.setAttrib(LightRampAttrib.makeSingleThreshold(t0, l0))np.setAttrib(LightRampAttrib.makeDoubleThreshold(t0, l0, t1, l1))

Em um sistema de limite único, o brilho da contribuição de iluminação difusa é comparada com o limiar t0. Se o limite não for cumprido , a contribuição da luz difusa é eliminado. Se ela for cumprida , o brilho do pixel é normalizado ao nível especificado l0. Em um sistema de limite de duas vezes , o brilho da contribuição de iluminação difusa é comparado com os limiares t0 e t1. Se não for atingido, a contribuição luz difusa é eliminado. Se ela for cumprida , o brilho do pixel é normalizada , quer l0 ou l1, Dependendo do limiar foi aprovada.

Futuro rampas LightEstamos interessados em saber se existem outras rampas luz que você gostaria de ver . Em caso afirmativo , informe-nos sobre os fóruns.

Auxiliar de Controle bitplaneO framebuffer contém sempre uma cor e um bitplane bitplane profundidade. Ela também pode ter um estêncil ou bitplane bitplane acumulação. Além disso, se é um

framebuffer render a textura , pode ter bitplanos auxiliar. Estes bitplanos auxiliar pode ser usado para armazenar mais ou menos arbitrária de dados definidos pelo usuário.

Quando a iluminação por pixel é ativado via o gerador de shader, O gerador de sombreamento podem ser feitas para produzir dados extra no bitplanos auxiliares. Isto é feito definindo uma AuxBitplaneAttrib :

np.setAttrib(AuxBitplaneAttrib.make(bits))

Onde bits é um conjunto de bits que indica o que deve ser escrito no bitplanos auxiliares.

Embora o canal framebuffer do alfa não é tecnicamente um bitplane auxiliares. No entanto, uma vez que não é geralmente usado para armazenar todos os dados de valor, também pode ser pensado como uma bitplane auxiliares: um lugar para armazenar dados definidos pelo usuário .

Quando o gerador de shader não está ativado, este attrib não tem efeito.

Valores que podem ser solicitadasThe following is a list of bits that can be passed to AuxBitplaneAttrib.make:

AuxBitplaneAttrib.ABOGlow: cópia do mapa brilho (aka mapa de auto-iluminação ) para o canal alfa do framebuffer . Geralmente este é um prelúdio para a execução de um filtro de flor sobre a cena.

AuxBitplaneAttrib.ABOAuxNormal: Loja da câmara espaço normal da superfície do polígono nos canais RGB da bitplane primeiro auxiliar. Isto é frequentemente usado para ajudar a detectar arestas em um filtro de tinta cartoon.

AuxBitplaneAttrib.ABOAuxGlow: cópia do mapa brilho (aka mapa de auto-iluminação ) para o canal alfa do bitplane primeiro auxiliar.

Panda3D Manual: Teste Stencil / Write Attribute

   Prev TopoPróximo

  Pitão/C + +

  

O StencilAttrib é usado para testar e gravar o buffer estêncil. Note-se que ambas as ações podem ser realizadas em simultâneo com um único StencilAttrib .

O buffer de estêncil é um buffer de gráficos auxiliares, além da cor mais conhecidos e buffers de profundidade. Ele fornece uma máscara per- pixel para o pipeline de processamento que pode ser explorada seletivamente tornar objetos ou partes de objetos . As aplicações típicas do stencil buffer incluem máscara binária, sombreamento e reflexões planar.

Geralmente, usando o buffer estêncil envolve a criação de alguns objetos que não são prestados para o buffer de cor. Sua contribuição para a cena renderizada é proporcionar uma fronteira invisível que pode ser usado para ligar o buffer de cores de processamento e fora de outros objetos na cena. Pense nisso como um cartão de corte por meio do qual o mundo é visto .

Durante uma comparação stencil, o valor de referência StencilAttrib é comparado com o valor armazenado no buffer de estêncil. A ordem importa aqui. Por exemplo, considere a função StencilAttrib.SCFGreaterThan comparação com o valor de referência r = 1. Um pixel passa o teste de estêncil , se r> Sp, Onde Sp é o valor no buffer de estêncil em pixel p. Objetos de valores que contribuem para o buffer estêncil que serão lidos por funções StencilAttributes outros comparação deve ser processado em primeiro lugar, ou resultados inesperados irá ocorrer. Ver Como controlar Ordem Render.

O buffer de estêncil é desativado por padrão. Para poder utilizar StencilAttribs , você deve adicionar a seguinte linha ao seu arquivo config.prc :

framebuffer-stencil #t

StencilAttribs são definidos exclusivamente por suas funções de construtor , por isso vamos analisar a entender o que cada parte faz. O seguinte código cria um atributo que indica um objeto para se tornar o stencil buffer é exatamente 1, e não se modificar o buffer estêncil.

stencilReader = StencilAttrib.make(1,StencilAttrib.SCFEqual,StencilAttrib.SOKeep, StencilAttrib.SOKeep,StencilAttrib.SOKeep,1,1,0)

O primeiro parâmetro é um boolean. Se este parâmetro for zero , o StencilAttrib não é processado. Em seguida é a função de comparação usa esse atributo , neste caso, Equal. Os próximos três fatores determinam o que acontece com o stencil buffer , dependendo do resultado da comparação. Nós vamos chegar a estes em um minuto. Os três Manter os valores deste atributo dizer nunca para modificar os valores no buffer. Próximo é o valor de referência para a função de comparação. Antes o valor de referência é passado para a função de comparação , no entanto , é bitwise ANDed com uma máscara. No nosso caso, estamos interessados na leitura , mas não por escrito, o stencil buffer , então passamos 1 e 0 para o ler e escrever máscaras, respectivamente. Estas máscaras são os dois últimos parâmetros para a StencilAttrib .

Em seguida, vamos olhar para um atributo que escreve o stencil buffer estêncil. Presumivelmente, estas duas funções irá trabalhar em conjunto para criar um efeito .

constantOneStencil = StencilAttrib.make(1,StencilAttrib.SCFAlways,StencilAttrib.SOZero, StencilAttrib.SOReplace,StencilAttrib.SOReplace,1,0,1)

Novamente vamos começar por permitir o atributo. A função de comparação aqui é sempre , o que significa que o teste passa , não importa os parâmetros. Em seguida é a operação a ser realizada no stencil buffer , se o teste falhar (o que neste caso nunca vai acontecer) - que define o valor stencil buffer para zero. O próximo parâmetro determina o que deve acontecer se a função de stencil passes, mas o teste de profundidade falhar, e, finalmente, o que deve acontecer se os dois testes de stencil e profundidade passar. No nosso caso, queremos definir o valor do buffer de estêncil quer passar o teste de profundidade ou não, assim que ambos são definidos para substituir. O valor de referência fixado no stencil buffer é 1. Estamos escrevendo , independentemente do que está na reserva já , então vamos definir a ler e escrever máscaras para 0 e 1 , respectivamente.

Agora nós podemos adicionar esses atributos para nós em cena para explorar o efeito. Aqui está o script inteiro.

from pandac.PandaModules import *

## Do this before the next import:loadPrcFileData("", "framebuffer-stencil #t")

import direct.directbase.DirectStart

constantOneStencil = StencilAttrib.make(1,StencilAttrib.SCFAlways,StencilAttrib.SOZero,StencilAttrib.SOReplace,StencilAttrib.SOReplace,1,0,1) stencilReader = StencilAttrib.make(1,StencilAttrib.SCFEqual,StencilAttrib.SOKeep, StencilAttrib.SOKeep,StencilAttrib.SOKeep,1,1,0)

cm = CardMaker("cardmaker")cm.setFrame(-.5,.5,-.5,.5)

## To rotate the card to face the camera, we create## it and then parent it to the camera.viewingSquare = render.attachNewNode(cm.generate())viewingSquare.reparentTo(base.camera)viewingSquare.setPos(0, 5, 0)

viewingSquare.node().setAttrib(constantOneStencil)viewingSquare.node().setAttrib(ColorWriteAttrib.make(0))viewingSquare.setBin('background',0)viewingSquare.setDepthWrite(0)

view = loader.loadModel("models/Panda")view.reparentTo(render)view.setScale(3)view.setY(150)view.node().setAttrib(stencilReader)

Você pode obter uma visão um pouco mais em estênceis neste tópico no fórum: http://www.panda3d.org/phpbb2/viewtopic.php?p=48451 # 48451

Panda3D Manual: Texturização

Na sua forma mais simples , texturização consiste meramente em aplicar uma textura em seu programa de modelagem. Quando você exportar o modelo , o caminho para a textura e algumas opções para ele , como filtragem ou método de repetição (ver páginas seguintes ) estão guardados no arquivo do ovo. Os caminhos de textura pode ser relativo ( como pode ser visto a partir do arquivo de ovo) ou absoluta ( caminho completo ). Ver Carregando Models Para obter mais informações sobre Filename Panda Syntax. Na maioria dos casos, o caminho relativo faz mais sentido.

Panda pode carregar JPG , PNG , TIF, e uma série de outros formatos de arquivo .

Mais avançados métodos de texturização são descritos nas secções seguintes .

A mapa de textura ou imagem de textura é um arquivo de imagem bidimensional , como um JPEG ou um arquivo do Windows BMP, que é usado para aplicar a cor de um modelo 3 -D. É chamado de "textura" , porque um dos primeiros usos dessa técnica consiste em aplicar uma textura interessante para paredes e pisos que seria uma cor, plano de plástico para o futuro. texturização Hoje é tão comum em aplicações 3-D que muitas vezes é a única coisa usada para aplicar a cor para modelos - sem mapas de textura , muitos modelos seriam simplesmente branco.

Há uma vasta gama de efeitos de renderização que podem ser alcançados com diferentes variantes de texturização. Antes que você pode aprender sobre eles, é importante compreender as noções básicas de texturização em primeiro lugar.

Na texturização simples - de longe a forma mais comum - que você pode pensar o mapa de textura como uma camada de tinta que é aplicada ao modelo. Para que o

hardware de gráficos para saber em que direção a tinta deve ser aplicada , o modelo deve ter sido criado com coordenadas de textura- Um especial (u, v) par de coordenadas que está associado a cada vértice do modelo. Cada vértice é (u, v) as coordenadas da textura colocar o vértice em um ponto específico dentro do mapa de textura, da mesma forma que o vértice (x , y, z) coordenadas local do vértice em um determinado ponto no espaço 3-D.

textura Essas coordenadas são chamados UV's devido ao (u, v ) nome do par de coordenadas . Quase qualquer pacote de modelagem que você pode usar para criar um modelo de coordenadas de textura pode criar ao mesmo tempo , e muitas fazê-lo sem sequer perguntar.

Por convenção, cada mapa de textura é atribuída a ( u, v) coordenar o alcance de tal forma que u coordenar intervalos 0-1 , da esquerda para a direita, e vai coordenar o v 0-1 de baixo para cima . Isso significa que o canto inferior esquerdo da textura é a coordenada ( 0, 0 ), e no canto superior direito está em (1, 1). Por exemplo, dê uma olhada em alguns mapas de textura típica:

É a (u, v) as coordenadas da textura que você atribui os vértices que determinam como a textura será aplicada ao seu modelo. Quando cada triângulo do seu modelo é desenhado , é desenhada com as cores do seu mapa de textura que se inserem no mesmo triângulo de vértices (u, v) espaço de textura . Por exemplo , a amostra smiley.egg modelo que vem com o Panda tem seus vértices definidos, tais que a u coordenar os aumentos de 0-1 em torno de seu diâmetro, e os v coordenar os aumentos de 0 na parte inferior a 1 em cima. Isso faz com que a imagem de textura para ser envolvido na horizontal em torno da esfera :

Note que a (u, v intervalo) para uma imagem de textura é sempre o mesmo, 0-1 , independentemente do tamanho da textura.

Textura tamanhos Standard

A maioria dos gráficos hardware requer que as imagens de sua textura ser sempre um tamanho que é uma potência de dois em cada dimensão. Isso significa que você pode usar qualquer uma das seguintes opções de tamanho de textura : 1, 2 , 4, 8 , 16, 32 , 64, 128 , 256, 512, 1024 , 2048, ou assim por diante (mas se você tiver um realmente placa high-end, você provavelmente precisará parar por aí ).

As texturas normalmente não têm de ser quadrado: eles não têm que ter o mesmo tamanho em ambas as dimensões . Mas cada dimensão tem geralmente de ser uma potência de dois . Assim, 64 × 128 é certo, por exemplo, ou 512 × 32 ou 256 × 256 . Mas você não pode fazer uma imagem de textura que é de 200 × 200 pixels , já que 200 não é uma potência de dois.

Por padrão, o Panda3D redimensionar automaticamente qualquer imagem de textura até a próxima potência de dois menores , quando você ler a partir do disco , assim que você normalmente não tem que pensar sobre isso - mas a sua aplicação irá carregar mais rápido se você dimensionar corretamente suas texturas em primeiro lugar.

Se você gostaria Panda3D para redimensionar suas imagens até a próxima potência maior das duas em vez de descer para a próxima potência de dois menores , use:

textures-power-2 up

No seu arquivo config. O padrão é :

textures-power-2 down

Observe que o tamanho que você escolhe para a imagem de textura não tem nada a ver com o tamanho ou a forma da imagem de textura na tela - que é controlada pelo tamanho e forma do polígono de aplicá-lo para . Fazendo uma imagem de textura mais não fazê-lo fazê-lo parecer maior na tela , mas tenderá a tornar mais nítidas e mais detalhadas. Da mesma forma , fazendo uma textura mais pequenos tendem a torná-lo mais distorcido .

Padded Texturas

Às vezes , você precisa carregar dados em uma textura de cada frame. O exemplo mais comum é quando você está jogando um filme. Digamos , por exemplo, que o filme está codificado em 640x480 a 30 fps. Nenhuma destas dimensões é uma potência de dois. Seria teoricamente possível para Panda3D para redimensionar a imagem para 512x512 , mas teria de fazê-lo 30 vezes por segundo , que é demasiado caro para ser prático.

Em vez disso panda, almofadas os dados. Panda cria uma textura de 1024x512 , que é a menor potência de duas dimensões que pode conter um filme de 640x480. Fura o filme 640x480 no canto inferior esquerdo da textura. Em seguida, ele adiciona uma borda preta para a borda direita ea borda superior do filme estofamento, fora de 1024x512 .

Desse ponto em diante , é só uma textura com um filme no canto inferior esquerdo, e barras pretas nos lados superior e direito. No entanto , se você usar coordenadas UV com cuidado, você pode fazer apenas um filme a ser exibido . Para fazer isso , você precisa saber como os grandes barras pretas são:

padx = texture.getPadXSize()pady = texture.getPadYSize()

Panda3D só usa texturas acolchoado em alguns casos muito especiais: 1. Ao reproduzir um poder não- de-dois filmes. 2. Ao utilizar tornar a textura , e uma potência não- de-dois buffer.

Textura tamanhos não padronizados

Algumas placas gráficas mais recentes podem processar as texturas que não são uma potência de dois . Isso geralmente não é muito útil para carregar a arte do disco : afinal , a arte do jogo é criado em potência de dois tamanhos , não importa o quê. No entanto, é útil para evitar o desperdício de preenchimento filme do tipo descrito acima. Se você tiver um destes cartões e você deseja habilitar o uso de energia não- de - duas texturas , você pode colocar a seguinte linha no seu Config.prc :

textures-power-2 none

Você também pode tentar ter panda detectar as suas capacidades de placa de vídeo automaticamente, usando o seguinte comando:

textures-auto-power-2 #t

Se esta variável é verdadeira, então panda vai esperar até abrir uma janela, e depois pedir o driver da janela , se o driver não suporta a potência de duas texturas . Se assim for, então a variável de configuração textures_power_2 será automaticamente ajustado. Desta forma , você pode configurar Panda3D usar o poder de não -de- duas texturas se eles estiverem disponíveis . Atenção: existe uma armadilha potencial uso texturas auto - poder -2. Se você abrir uma janela que não suporta a potência de duas texturas , panda vai mudar em texturas , poder -2 none modo. Se você abra uma segundo janela usando uma placa de vídeo diferentes, que não suporta ou não-poder -de- duas texturas , então panda não terão nenhuma escolha mas para imprimir uma mensagem de erro.

Note que alguns cartões aparecer ser capaz de processar ou não-poder -de- duas texturas , mas o motorista é realmente apenas escalar as texturas em tempo de carga. Com os cartões como estes, é melhor você deixar Panda fazer o escalonamento, ou texturas dinâmica pode render muito lentamente.

Panda3D Manual: Modos Wrap Textura

   Prev TopoPróximo

  Pitão/C + +

  

Conforme descrito anteriormente , o (U, v) coordenadas de textura que você atribui a sua vértices são o que determina como a textura se encaixa em sua geometria. Muitas vezes, você irá usar coordenadas de textura , que sempre estão dentro do intervalo [0 , 1] , que é a gama completa dos pixels da imagem de textura. No entanto , também é legal de usar textura coordenadas que ir para fora deste intervalo , você pode ter valores negativos , por exemplo, números ou superior a 1.

Portanto, se a imagem da textura é definida somente no intervalo [0, 1], o que faz o olhar de textura como fora deste intervalo ? Você pode especificar isso com o Modo de embrulhar textura.

texture.setWrapU(wrapMode)texture.setWrapV(wrapMode)

O parâmetro wrapMode é especificada separadamente para os u e v direcções ( também há uma setWrapW () para texturas em 3-D, Mas isso é um tópico avançado ). O wrapMode pode ser qualquer um dos seguintes valores:

Texture.WMRepeat A imagem da textura se repete até ao infinito.

Texture.WMClamp O último pixel da imagem da textura se estende ao infinito.

Texture.WMBorderColor A cor especificada pela texture.setBorderColor () é usado para preencher o espaço.

Texture.WMMirror A imagem de textura vira -e-volta por diante até o infinito.

Texture.WMMirrorOnce A imagem de textura vira para trás, uma vez, e então o "limite de cor " é usada.

Considere a imagem da textura simples a seguir :

Vamos aplicar essa textura no centro de um polígono cuja textura coordenadas grande gama consideravelmente mais distante do que [0, 1], em ambos os sentidos.

WMRepeattexture.setWrapU(Texture.WMRepeat)texture.setWrapV(Texture.WMRepeat)

WMRepeat modo é frequentemente usado para a telha de textura relativamente pequeno sobre uma grande superfície.

WMClamp

texture.setWrapU(Texture.WMClamp)texture.setWrapV(Texture.WMClamp)

WMClamp modo é raramente usado em grandes polígonos , porque, francamente , parece terrível quando os pixels estendem ao infinito como este , mas este modo é geralmente a escolha certa quando a textura exatamente preenche o polígono (ver Um cuidado sobre um erro comum embrulhar , abaixo).

WMBorderColortexture.setWrapU(Texture.WMBorderColor)texture.setWrapV(Texture.WMBorderColor)texture.setBorderColor(VBase4(0.4, 0.5, 1, 1))

A cor azul foi escolhida anteriormente para fins de ilustração , você pode usar qualquer cor que você quiser para a cor da borda . Normalmente, você usaria a cor de fundo da textura como a cor da borda , como este:

texture.setWrapU(Texture.WMBorderColor)texture.setWrapV(Texture.WMBorderColor)

Alguns drivers muito antigos gráficos não suportam WMBorderColor. Neste caso, Panda3D vai cair de volta para WMClamp, Que será semelhante enquanto existir uma margem suficiente de cor de fundo em torno da borda de sua textura ( textura ao contrário do nosso exemplo , que vai toda a maneira para fora da borda).

WMMirror

texture.setWrapU(Texture.WMMirror)texture.setWrapV(Texture.WMMirror)

Muitos drivers gráficos mais velhos não suportam WMMirror. Neste caso, Panda3D vai cair de volta para WMRepeat.

WMMirrorOncetexture.setWrapU(Texture.WMMirrorOnce)texture.setWrapV(Texture.WMMirrorOnce)texture.setBorderColor(VBase4(0.4, 0.5, 1, 1))

Poucos drivers gráficos de apoio WMMirrorOnce. Neste caso, Panda3D vai cair de volta para WMBorderColor.

Definir os modos de envolver diferentesÉ possível definir os modos de envolver diferentes na u e v direções:

texture.setWrapU(Texture.WMRepeat)texture.setWrapV(Texture.WMClamp)

Um cuidado sobre o modo envoltório de erros comunsQuando você aplica uma textura que se pretende exatamente preencher um polígono - isto é, a textura coordenadas intervalo 0-1 , mas não ainda - você geralmente deve definir o seu modo de envolver a braçadeira. Isto porque se você deixá-lo manter o valor padrão de repetir, A cor pode sangrar a partir do lado oposto , produzindo uma fina linha ao longo da borda de seu polígono , como este:

Este é um erro particularmente comum com uma textura que é pintado como um recorte alfa , onde há uma imagem com um fundo totalmente transparente : você vai ver muitas vezes um fino, borda visível mal - flutuante ao longo do topo (por exemplo) do polígono . Esta vantagem é realmente a borda inferior da textura sangramento na parte superior , pois o designer especificado WMRepeat ao invés do modo correto, WMClamp.

Panda3D Manual: Tipos de filtro de texturaÉ raro que os pixels de uma imagem de textura correspondência um-para- um com tela de pixels reais , quando a textura é visível na tela . Normalmente, é o caso de que seja um único pixel da textura é esticada sobre vários pixels da tela (ampliação textura- A imagem da textura é esticada maior ), ou o contrário, que vários pixels de uma textura de contribuir para a cor de um pixel da tela única (minification textura- A imagem de textura é squished menor). Muitas vezes, um único polígono terá alguns pixels de textura que precisam ser ampliados e alguns pixels que precisam ser minified ( a placa gráfica pode lidar com dois processos em um único polígono ).

Você pode controlar como a textura olha quando ela for ampliada ou minified definindo sua tipo de filtro.

texture.setMagfilter(filterType)texture.setMinfilter(filterType)

Há uma configuração separada FilterType para ampliação e minimização . Para tanto a ampliação e minimização, o FilterType podem ser:

Texture.FTNearest Prove o pixel mais próximo.

Texture.FTLinear Exemplo mais próximo dos quatro pixels e interpolação linear deles.

Para minification apenas , para além das duas opções acima , você também pode escolher entre:

Texture.FTNearestMipmapNearest Ponto de amostra do pixel em relação ao nível mais próximo mipmap .

Texture.FTLinearMipmapNearest Bilinear filtrar o pixel mais próximo do nível mipmap .

Texture.FTNearestMipmapLinear Ponto de amostra do pixel a partir de dois níveis mipmap e linearmente mistura.

Texture.FTLinearMipmapLinearBi-linearmente o filtro de pixel a partir de dois níveis mipmap e linearmente misturar os resultados. Isto também é chamado filtragem trilinear.

O tipo de filtro padrão para ambos é a ampliação e minification FTLinear.

Considere os efeitos visuais dos diversos tipos de filtros na ampliação e minimização da textura que se segue:

FTNearesttexture.setMagfilter ( Texture.FTNearest )texture.setMinfilter ( Texture.FTNearest )

Normalmente, FTNearest é usado apenas para conseguir um efeito pixelly especial.

FTLineartexture.setMagfilter ( Texture.FTLinear )texture.setMinfilter ( Texture.FTLinear )

FTLinear é uma boa opção de uso geral, embora não seja perfeito.

MipmapsMuitos tutoriais gráficos vai continuar por páginas e páginas sobre o que exatamente significa mipmapping e como tudo funciona por dentro. Vamos poupá-lo dos detalhes aqui , mas você deve compreender as seguintes coisas sobre mipmapping :

(1) requer 33% mais memória de textura (por mipmapped textura ), mas ele processa rapidamente.

(2) ajuda a olhar de textura muito suave do que filtrar apenas quando é minified .

(3) Mipmapping não tem nada a ver com a ampliação.

(4) tem uma tendência a diluir-se texturas minified um pouco demais, principalmente quando a textura é aplicada a um polígono que está quase de lado para a câmera.

Existem quatro tipos de filtros diferentes, que envolvem mipmapping , mas quase sempre quer usar apenas a última, FTLinearMipmapLinear. Os outros modos são para usuários avançados, e às vezes pode ser usado para ajustar os artefatos mipmap um pouco (especialmente para reduzir o ponto 4 , acima). Se você não entender a descrição na tabela acima , não vale a pena se preocupar . texture.setMinfilter ( Texture.FTLinearMipmapLinear )

Filtragem anisotrópicaHá um acréscimo final a textura filtragem equação: você pode habilitar a filtragem anisotrópica em cima de qualquer um dos modos de filtro acima , o que permite um mais caro , o modo de tornar um pouco mais lento que geralmente produz efeitos superior. Em particular, a filtragem anisotrópica é geralmente melhor no tratamento minification textura que mipmapping, e não tendem a borrar as textura muito.

Para habilitar a filtragem anisotrópica, você pode especificar o grau :

texture.setAnisotropicDegree(degree)

O grau deve ser um número inteiro. O valor padrão é 1, que indica a ausência de filtragem anisotrópica , configurá-lo para um maior número para indicar a quantidade de filtragem que você necessita. Números maiores são mais caros , mas produzem um resultado melhor , até a capacidade de sua placa gráfica. Muitas placas gráficas não suportam qualquer grau diferente de 2, que é geralmente suficiente de qualquer maneira.

degree other than 2, which is usually sufficient anyway.

texture.setAnisotropicDegree(2)

Algumas placas mais antigas não é possível executar a filtragem anisotrópica .

Panda3D Manual : Substituição simples da texturaEmbora normalmente você vai carregar e exibir modelos que já estão texturizados, você também pode aplicar ou substituir uma imagem de textura de um modelo em tempo de execução . Para fazer isso, você deve primeiro obter um identificador para a textura , por exemplo, carregá-lo diretamente:

myTexture = loader.loadTexture("myTexture.png")

LoadTexture acima ( ) chamada pesquisa ao longo do actual modelo de caminho para o arquivo de imagem nomeado ( neste exemplo, um arquivo chamado " myTexture.png "). Se a textura não for encontrado ou não pode ser lido por alguma razão, nenhum é retornado.

Assim que tiver uma textura, você pode aplicá-la a um modelo com o SetTexture () chamada. Por exemplo , suponha que você usou a classe CardMaker para gerar um cartão simples branco: cm = CardMaker('card')card = render.attachNewNode(cm.generate())

Depois, você pode carregar uma textura e aplicá-lo para o cartão como este:

tex = loader.loadTexture('maps/noise.rgb')card.setTexture(tex)

(Note que não é necessário usar o parâmetro override ao SetTexture () call - ou seja, você não precisa fazer card.setTexture ( tex, 1) - porque neste caso , o cartão já não tem qualquer outra textura aplicada a ele , assim que sua textura será visível mesmo sem o substituir .)

Para que isso funcione, o modelo que você deve aplicá-lo já coordenadas de textura definidos (ver Simples Texturing). Quando isso acontece, o CardMaker gera coordenadas de textura por padrão quando ele gera um cartão , por isso não há problema .

Você também pode usar SetTexture () para substituir a textura de um modelo já com textura . Neste caso, você deve especificar um segundo parâmetro para SetTexture , que é o mesmo parâmetro override opcional Panda você pode especificar em qualquer tipo de Panda mudança de estado. Normalmente, você simplesmente passar um como o segundo parâmetro para SetTexture (). Sem essa substituição, a textura que é atribuído diretamente ao nível Geom terá precedência sobre a mudança de estado que você faz no nó do modelo, ea mudança de textura não será feita.

Por exemplo, para alterar a aparência do sorriso :

smiley = loader.loadModel('smiley.egg')smiley.reparentTo(render)tex = loader.loadTexture('maps/noise.rgb')smiley.setTexture(tex, 1)

Muitas vezes, você deseja substituir a textura em apenas um pedaço de um modelo, em vez de definir a textura de cada elemento . Para fazer isso , basta obter uma NodePath identificador para a parte ou partes do modelo que você deseja alterar , conforme descrito na seção Manipulando um pedaço de um modeloE fazer a SetTexture () exortar os NodePaths .

Por exemplo , este modelo de automóvel tem múltiplas texturas disponíveis em diferentes cores :

Para a maior parte , este carro foi pintado com uma imagem de textura grande, que se parece com isto:

Mas também temos uma versão azul da mesma imagem da textura :

Embora seja tentador usar SetTexture ( ) para atribuir a textura do azul para o carro inteiro, que também atribui a textura azul para os pneus do carro, que precisará

usar um mapa de textura diferente. Então, ao invés , nós aplicamos a textura azul apenas para as peças que queremos mudar :

car = loader.loadModel('bvw-f2004--carnsx/carnsx.egg')blue = loader.loadTexture('bvw-f2004--carnsx/carnsx-blue.png')car.find('**/body/body').setTexture(blue, 1)car.find('**/body/polySurface1').setTexture(blue, 1)car.find('**/body/polySurface2').setTexture(blue, 1)

E o resultado é este:

Se você está interessado em mudar a imagem de uma textura durante a execução do programa, dizer para ajustar alguns de seus pixels, ver Criação de novas texturas a partir do zero.

Manual Panda3D : Introdução multitextura

Panda3D fornece a capacidade de aplicar mais de uma imagem de textura de uma vez para os polígonos do modelo. As texturas são aplicadas em cima da outra , como camadas de tinta , muito parecida com as "camadas" de um programa de foto- pintura popular.

Para uma camada de textura segundo um modelo , você tem que entender conceito Panda , de um TextureStage. Pense em um TextureStage como um slot para manter uma imagem de textura única. Você pode ter tantos TextureStages diferentes como você deseja em sua cena , e cada TextureStage pode ser usado em um, vários ou todos os modelos.

Quando você aplica uma textura a um modelo, por exemplo, com o SetTexture () chamada , você é realmente obrigatório a textura de um TextureStage particular. Se você não especificar um TextureStage de usar, Panda assume que quer dizer o "padrão" TextureStage objeto , que é um ponteiro global que pode ser acessado como TextureStage.getDefault ().

Cada TextureStage pode conter uma imagem de textura para um determinado modelo . Se você atribuir uma textura para um TextureStage particular, e depois (ou uma menor nó) atribuir uma textura diferente ao TextureStage mesmo , a nova textura substitui completamente o antigo. ( Dentro da cena global , uma TextureStage dado pode ser usado para armazenar qualquer número de diferentes texturas diferentes para nós , mas ela só tem uma textura para qualquer um nó particular.)

No entanto, você pode ter tantos TextureStages diferentes como você deseja. Se criar um novo TextureStage e usá-lo para atribuir uma segunda textura de um nó , o nó tem agora duas texturas que lhe são atribuídas .

Embora não exista limite para o número de TextureStages você atribui a esse propósito, a placa gráfica vai impor algum limite para o número que pode render em qualquer um nó . placas de vídeo modernas normalmente têm um limite de 4 ou 8 as texturas de uma vez , algumas placas antigas só pode fazer dois , e algumas placas muito antigas têm um limite de 1 (apenas uma textura de cada vez) . Você pode descobrir o limite do seu cartão de multitexture particular com a chamada base.win.getGsg (). getMaxTextureStages ().

Lembre-se, no entanto, que este limite só restringe o número de TextureStages diferentes você pode ter em qualquer um nó particular , você ainda pode ter tantos TextureStages diferentes como você quiser, desde que todos eles estão em diferentes nós .

Vamos voltar ao exemplo de Substituição simples da textura, Onde substituiu a textura normal em smiley.egg com uma imagem nova textura que contém um padrão de cor aleatória. Desta vez, em vez de atribuir a nova textura à TextureStage padrão, vamos criar um TextureStage novo para ele , para que tanto as texturas ainda estará em vigor:

smiley = loader.loadModel('smiley.egg')smiley.reparentTo(render)tex = loader.loadTexture('maps/noise.rgb')ts = TextureStage('ts')smiley.setTexture(ts, tex)

Observe que podemos criar um objeto novo TextureStage on the fly , o único parâmetro obrigatório para o parâmetro TextureStage é um nome , que só é significativa para nós. Quando passamos a TextureStage como o primeiro parâmetro para SetTexture (), que significa atribuir a textura indicada a esse TextureStage . Observe também que não precisamos mais para especificar uma

substituição para o SetTexture () chamada, uma vez que não está substituindo a textura especificada no nível Geom , mas nós estamos adicionando a ele.

E o resultado é este:

E o resultado é este:

Para desfazer um convite anterior para adicionar uma textura , use:

smiley.clearTexture (ts)

passando o TextureStage mesmo que você usou antes. Ou , em alternativa , pode usar simplesmente :

smiley.clearTexture ()

para remover todos especificações textura que você adicionou anteriormente ao smiley nó. Isso não remove as texturas originais que estavam no modelo quando você carregá-la ; as texturas são atribuídos a um nível diferente do nó , sobre o Geom objetos que compõem o modelo.

Panda3D Manual: Modos de Textura

Existem vários tipos de texturas : texturas de cor, mapas normais, gloss mapas, brilho, e assim por diante . Para distinguir estas , utilize o TextureStage.setMode função. Além disso , dentro da categoria geral das texturas da cor, há várias maneiras de combinar as cores : Módulo , decalque, Blend, e assim sucessivamente. Estes , também, são controlados usando o TextureStage.setMode função.

O BásicoVamos voltar ao exemplo da aplicação de uma textura para o modelo de smiley. Neste caso, vamos criar um novo TextureStage para aplicar a textura da imagem abaixo :

Para esta cena:

Note que a parte circular branca da imagem de amostra não é realmente branca em tudo, mas um recorte (alfa que você está vendo através da imagem para o fundo da página branca ). Temos prestado smiley.egg contra um fundo colorido para que você possa ver os efeitos de alpha nos vários modos abaixo , em alguns deles , o alfa é propagado através da cor final, assim smiley é transparente nas partes da imagem, mas em outros modos , o alfa é usado para um propósito diferente, risonho e não é transparente não .

Note também que, para fins de ilustração , temos apenas aplicou a textura da imagem de exemplo para uma parte do modelo sorridente , ao invés de todo o modelo . ( Isso foi feito através da transformação das coordenadas de textura do estágio de textura , que é coberto em um tópico mais tarde.)

Modo MóduloEste é o padrão blend mode . Neste modo , a cor, textura superior é multiplicado pela cor da textura de fundo para produzir o resultado . Isto significa que a cor da textura resultante será escura (ou pelo menos , não brilhante ) do que de ambas as cores da textura original.

ts = TextureStage('ts')ts.setMode(TextureStage.MModulate)smiley.setTexture(ts, tex)

Note que neste modo, um corte alpha na textura top produz um recorte alpha na imagem resultante.

Modo AdicionarNeste modo , a cor, textura top é adicionado à cor, textura de fundo, e fixada a 1 ( branco). Isto significa que a cor da textura resultante será brilhante (ou pelo menos , não mais escuras ) do que de ambas as cores da textura original.

ts = TextureStage('ts')ts.setMode(TextureStage.MAdd)smiley.setTexture(ts, tex)

Note que nesta modalidade , como no modo modular , um recorte alpha na textura top produz um recorte alpha na imagem resultante. Observe também que , salvo uma ou ambas as texturas a sua fonte era bastante escuro, há uma tendência para as cores para obter lavadas em branco onde tudo braçadeiras para 1.

Substituir modoNeste modo, a textura top substitui completamente a textura de fundo. Este modo não é frequentemente utilizado.

ts = TextureStage('ts')ts.setMode(TextureStage.MReplace)smiley.setTexture(ts, tex)

Note-se que o recorte alfa é preservado , mas os efeitos de iluminação (que são considerados parte da textura subjacente) foram perdidos.

modo DecalNeste modo, a textura top substitui completamente a textura de fundo, mas apenas quando alfa = 1 no top de textura . Quando alfa = 0, mostra a textura de fundo através de , e há uma mistura harmoniosa de valores de alfa entre 0 e 1 .

ts = TextureStage('ts')ts.setMode(TextureStage.MDecal)smiley.setTexture(ts, tex)

Note-se que o recorte alfa não é mais preservada deste modo , porque o alfa é usado para determinar qual a textura deve ser visível. Observe também que os efeitos de iluminação são perdidos para a parte decalled da textura.

Panda3D também fornece um recurso interno de decalque, para a prestação de um polígono coplanar com pequenas e incorporado dentro de um polígono maior , o que não está relacionada com a textura de decalque blend mode .

Blend modeBlend mode é similar ao modo de decalque , exceto que você pode especificar a cor do decal como um parâmetro em tempo de execução . Você pode variar a cor e você não tem que ter uma imagem de textura diferente para cada cor possível. No

entanto, o decalque vai ser sempre monocromáticas (que será desenhado em tons diferentes de qualquer cor que você especificar).

modo de mistura pode ser usada apenas com uma textura em tons de cinza , e ele não usa alpha. Uma vez que a textura do exemplo acima não é uma textura em tons de cinza , vamos usar uma textura diferente para este exemplo:

Esta textura não tem um canal alfa , é simplesmente uma imagem em tons de cinza com um grande branco " A " em um campo de preto. modo de Blend irá produzir a cor original , onde a imagem é preto, ea cor que especificar com TextureStage.setColor () onde a imagem é branca. Quando a imagem é tons de cinza , haverá uma mistura suave entre as cores. ts = TextureStage('ts')ts.setMode(TextureStage.MBlend)ts.setColor(Vec4(1, 0, 0, 1))smiley.setTexture(ts, tex)

E nós podemos mudar a cor do decalque à vontade, simplesmente com:

ts.setColor(Vec4(0, 0, 1, 1))

Note que, como o exemplo acima do decalque , a informação iluminação é perdida quando o decalque é aplicado.

Modo Normal MapNormal mapas são mapas que causam superfícies parecem ter aumentado e áreas rebaixadas . Eles também são chamados mapas "bump ". Diferentemente da maioria dos mapas, normal não afeta a cor do modelo - que afetam a iluminação. Quando a luz atinge um modelo de mapeamento normal , a luz cria sombras e destaques ao longo desses sulcos e saliências. Se não houver luzes são aplicados ao modelo , então não haverá sombras ou reflexos , eo mapa normal será invisível . Atualmente, Panda3D permite apenas um mapa normal por polígono, mapas adicionais normal será ignorado.

ts = TextureStage('ts')ts.setMode(TextureStage.MNormal)smiley.setTexture(ts, tex)

Desde parallax mapping não parece muito bom, sem o mapeamento normal , eles são freqüentemente usados juntos . Como uma otimização, a maioria das pessoas preferem guardar o mapa de altura para o canal alfa do mapa normal. Se você estiver usando como um mapa de altura embalado normal / , você precisa usar o modo MNormalHeight no Panda:

# The second parameter to loadTexture will be stored in the texture's alpha channel.tex = loader.loadTexture("normalmap.png", "heightmap.png") ts = TextureStage('ts')ts.setMode(TextureStage.MNormalHeight)smiley.setTexture(ts, tex)

Por padrão, o algoritmo de mapeamento de paralaxe usará três amostras, eo efeito será dimensionada em 0,1 . Para alterar esses parâmetros , use as seguintes linhas Config.prc :

parallax-mapping-samples 3parallax-mapping-scale 0.1

A quantidade de amostras é como exato o mapeamento de paralaxe será. Os valores mais baixos são mais baratos, mas o resultado será menos precisas. A escala é a magnitude do efeito - com um valor menor diminui efeito , com um valor

superior à superfície vai ter mais profundidade aparente ( embora os artefatos devido à falta de oclusão será mais visível). Use um valor negativo para inverter o efeito (este tem o mesmo efeito de inverter o heightmap ).

Gloss Mode MapUm gloss mapa é uma imagem em preto -e-branco , indicando que o modelo é suposto ser brilhante e onde é suposto ser maçante. mapas Gloss não afetar a cor do modelo - que afetam o grau em que o modelo reflete especulares . Então, se não as luzes são aplicados ao modelo e, portanto, não há reflexos especulares em tudo, então o brilho do mapa será invisível.

Mais precisamente, o brilho mapa afeta o material cor especular do modelo. Se o modelo já tem um material de cor especular , então é multiplicado pelo valor (0-1 ), no brilho do mapa. Desta forma, o brilho pode mapear efetivamente ligar ou desligar a especularidade em uma base per- pixel. Se o modelo já não tem uma cor especular material especificado, em seguida, aplicar um brilho mapa faz com que o material de cor especular na faixa de fora a branco brilhante.

Um gloss mapa deve ser um alpha da textura :

ts = TextureStage('ts')ts.setMode(TextureStage.MGloss)smiley.setTexture(ts, tex)

Se desejar, você pode embalar um modular , textura e um brilho -mapa em uma textura RGBA único. Nesse caso , os componentes RGB são apenas valores de cor regulares que são moduladas para o modelo, e os controles de brilho A :

ts = TextureStage('ts')ts.setMode(TextureStage.MModulateGlow)smiley.setTexture(ts, tex)

Atualmente, Panda3D só permite que um mapa brilho por polígono , mapas brilho adicional será ignorado.

Veja também: Programas de exemplo : filtro de brilho

Glow mapas são nova Panda3D a partir da versão 1.5.0. Eles só funcionam quando geração shader está habilitado.

Panda3D Manual : Ordem Textura

Quando há múltiplas texturas com efeito, dependendo do Textura Blend Mode em uso, ele pode ser importante para controlar a ordem em que as texturas aplicadas. Por exemplo, embora modula a modalidade e modo Adicionar ordem são

independentes, a fim de textura faz uma grande diferença no modo de Decal , o modo Replace, e modo Blend.

Para especificar a ordem de textura , use TextureStage.setSort () em um ou mais dos seus TextureStages . Se você não especificar um valor de classificação , o valor de classificação padrão é 0. Quando a geometria é processado , todas as texturas são processados em ordem crescente de valor do tipo , de modo que o maior valor de classificação é processado por cima. Assim, se você quiser usar o modo de Decal , por exemplo, para aplicar uma textura em cima de um menor de textura, que seria uma boa idéia usar setSort () para dar um maior valor de classificação para a textura do decalque. Além disso, uma vez que alguns hardware pode não ser capaz de processar todos os TextureStages que você tenha definido em um nó particular , o Panda oferece uma maneira para que você possa especificar quais s (textura) são os mais importantes . Utilização TextureStage.setPriority () para isso.

O valor de prioridade só é consultado quando tiver aplicado TextureStages mais de um nó específico do que o seu hardware atual pode render. Neste caso , a Panda irá selecionar as texturas n com o valor de prioridade mais alta ( e , em seguida, classificá-los em ordem pelo setSort () valor). Entre duas texturas com a mesma prioridade , Panda irá preferir aquele com o menor valor de classificação. A prioridade padrão é 0.

Panda3D Manual: Textura Combine Modos

   Prev TopoPróximo

  Pitão/C + +

  Algumas das informações nesta página podem não estar corretas.

Veja o Discussão para mais detalhes.

Além dos vários Textura Blend Modes descrito anteriormente , existe uma interface mais avançada em TextureStage que permite um maior vocabulário de opções de mistura de texturas .

Embora várias das seguintes opções ( CMReplace , CMModulate , CMAdd ) tem paralelos óbvios com a simples mistura modos descritos anteriormente , eles são de fato mais poderosa , porque com cada um dos seguintes você pode especificar a

fonte de particular ou de fontes a serem utilizados para a funcionamento , você não está limitado a simples aplicação da operação para a textura superior e textura abaixo.

modos RGBA seguir especificam o efeito da RGB (cor) canais. Um conjunto distinto de métodos, a seguir, especifica o efeito do canal alfa.

ts.setCombineRgb(TextureStage.CMReplace, source, operand)

Este modo é semelhante ao " modo de substituição ". Seja qual for a cor é especificada pelo operando fonte e se torna a nova cor.

ts.setCombineRgb(TextureStage.CMModulate, source0, operand0, source1, operand1)

Este modo é similar ao " modula a modalidade ". A cor de source0/operand0 é multiplicado pela cor de source1/operand1.

ts.setCombineRgb(TextureStage.CMAdd, source0, operand0, source1, operand1)

Este modo é semelhante ao "adicionar "mode. A cor de source0/operand0 é adicionado à cor source1/operand1 , eo resultado é fixada a 1 ( branco).

ts.setCombineRgb(TextureStage.CMAddSigned, source0, operand0, source1, operand1)

Neste modo , as cores são adicionadas como assinado números, eo resultado wraps.

ts.setCombineRgb(TextureStage.CMSubtract, source0, operand0, source1, operand1)

Neste modo, source1/operand1 é subtraído source0/operand0 .

ts.setCombineRgb(TextureStage.CMInterpolate, source0, operand0, source1, operand1, source2, operand2)

Esta é a única modalidade que usa três fontes. O valor da source2/operand2 é usado para selecionar entre source0/operand0 e source1/operand1 . Quando source2 é 0, Source0 é selecionado, e quando source2 é 1, source1 é selecionado. Quando source2 está entre 0 e 1, a cor é suave mistura entre Source0 e source1 .

Modos de AlphaOs métodos a seguir mais ou menos duplicar a funcionalidade do anterior, mas que eles controlam o que acontece com o canal alfa. Assim, você tem o controle explícito sobre a possibilidade de um corte alpha na textura superior deve produzir um recorte alfa do objeto resultante.

ts.setCombineAlpha(TextureStage.CMReplace, source, operand)

ts.setCombineAlpha(TextureStage.CMModulate, source0, operand0, source1, operand1)ts.setCombineAlpha(TextureStage.CMAdd, source0, operand0, source1, operand1)ts.setCombineAlpha(TextureStage.CMAddSigned, source0, operand0, source1, operand1)ts.setCombineAlpha(TextureStage.CMSubtract, source0, operand0, source1, operand1)ts.setCombineAlpha(TextureStage.CMInterpolate, source0, operand0, source1, operand1, source2, operand2)

valores de origemEsta tabela lista os valores válidos para qualquer fonte, Source0 , source1 ou source2 , nas chamadas acima. Esta ampla lhe dá o controle sobre a qual duas (ou três) texturas são usados como insumos para o referido combinar os modos.

TextureStage.CSTexture A textura da imagem atual, ou "top".

TextureStage.CSConstant A cor constante, especificado através TextureStage.setColor ().

TextureStage.CSConstantColorScale O mesmo que CSConstant , mas a cor será alterada pela NodePath.setColorScale ().

TextureStage.CSPrimaryColor A "cor" principal do objeto , antes do primeiro estágio de textura foi aplicada , incluindo os efeitos de iluminação.

TextureStage.CSPrevious O resultado do estágio de textura anterior , ou seja, a textura abaixo.

TextureStage.CSLastSavedResultO resultado de qualquer uma das fases textura anterior , mais especificamente, a última etapa para que TextureStage.setSavedResult (verdadeiro) foi chamado.

OperandosEsta tabela lista os valores válidos para qualquer um operando, operand0 , operando1 ou operando2 , nas chamadas acima. Isso afina o canal de dados que é usado em cada entrada de textura.

TextureStage.COSrcColorUse a cor RGB. Quando usado em um setCombineAlpha () chamada , RGB é automaticamente agregadas em tons de cinza.

TextureStage.COOneMinusSrcColor O complemento da cor RGB.

TextureStage.COSrcAlphaUse o valor de alfa. Quando usado em um setCombineRgb () chamada alfa é automaticamente expandido em RGB uniforme.

TextureStage.COOneMinusSrcAlpha O complemento do valor alfa.

Discussão relatada á cima

Nas seções Operandos ele diz que " Quando usado em um setCombineAlpha () chamada , RGB é automaticamente agregadas em tons de cinza. " exceto que não é

de todo verdade . Em vez disso, gera um erro que o operando não é adequado para uso como um operando alfa. Que é muito ruim , pois eu realmente queria esse comportamento. Será que o suporte de renderização subjacente a este comportamento e só verificar o parâmetro precisa ser relaxado? Será que o processamento subjacente precisa ser melhorado para suportar esse comportamento ( se é possível? )? Ou será que a documentação só precisa corrigir para refletir o comportamento real?

Panda3D Manual: Textura Transforma

É possível aplicar uma matriz para transformar a (u, v) as coordenadas da textura de um modelo antes da renderização. Desta forma , você pode ajustar a posição , rotação ou escala de uma textura , deslizando a textura ao redor para se adequar às suas necessidades específicas.

Use os métodos a seguir para NodePath fazer isso:

nodePath.setTexOffset(TextureStage, uOffset, vOffset);nodePath.setTexScale(TextureStage, uScale, vScale);nodePath.setTexRotate(TextureStage, degrees);

Se você não tiver um TextureStage particular , use TextureStage.getDefault () como o primeiro parâmetro . Note que a operação em cada caso, é aplicada ao (u, v) as coordenadas da textura , e não para a textura , assim ele vai ter o efeito oposto sobre a textura. Por exemplo , a chamada nodePath.setTexScale (ts , 2, 2 ) efetivamente duplicar os valores das coordenadas de textura sobre o modelo , que duplica o espaço sobre o qual a textura é aplicada e, portanto, faz com que a textura apareça metade do tamanho .

Os métodos aplicam-se a 2- d transformar a sua textura coordenadas, o que é apropriado , pois geralmente são coordenadas de textura bidimensional. No entanto , às vezes você está trabalhando com 3- d textura coordenadas, E você realmente deseja aplicar um 3-d transformar. Para esses casos, existem os seguintes métodos:

nodePath.setTexPos(TextureStage, uOffset, vOffset, wOffset);nodePath.setTexScale(TextureStage, uScale, vScale, wScale);nodePath.setTexHpr(TextureStage, h, p, r);

E há também uma forma genérica:

nodePath.setTexTransform(TextureStage, transform);

Este último método define um objeto TransformState genéricos. Este é o mesmo tipo de matriz 4x4 transformar objeto que você pode começar a partir de um NodePath através, por exemplo , NodePath.getTransform (). Você também pode construir uma nova TransformState através de uma série de métodos como

TransformState.makePos ( VBase3 (0, 1 , 0)). Se pretende candidatar-se a 2- d transformar só , você deve restringir-se a métodos como TransformState.makePos2d ( VBase2 (0 , 1)), Usando apenas 2 -d podem permitir que as operações de back-end gráfico para utilizar um cálculo um pouco mais simples .

Note que a textura transformar está associado a um TextureStage particular , não é uma propriedade fixa do modelo ou sua textura coordenadas. Você pode, portanto, aplicar uma textura diferente para transformar cada TextureStage diferentes, de modo que se você tem múltiplas texturas em vigor em um nó particular, eles não precisam ser todos no mesmo lugar , mesmo que todos usam a mesma textura coordenadas. Por exemplo, esta técnica foi usada para gerar as imagens da amostra no Textura Blend Modes seção. Na verdade, o código a seguir foi utilizado para colocar esta textura da amostra ( extraída ):

smiley = loader.loadModel('smiley.egg')ts = TextureStage('ts')pattern = loader.loadTexture('color_pattern.png')smiley.setTexture(ts, pattern)smiley.setTexScale(ts, 8, 4)smiley.setTexOffset(ts, -4, -2)

e textura, o resultado :

No exemplo acima , nós aplicamos uma escala de (8, 4) para reduzir o tamanho da imagem decalque substancialmente , e então nós especificado um deslocamento de (-4 , -2 ) para deslizá-lo em torno da positiva (u, v ) em direcção ao rosto sorridente (desde o (0 , 0) coordenar acontece de estar na parte traseira do smiley ). No entanto , essas operações afetam somente a imagem do decalque , a textura smiley original mantém-se inalterada a partir de sua posição normal , apesar de ambas as texturas estão usando a mesma textura coordenadas.

Panda3D Manual: Textura vários conjuntos de coordenadas

Além disso, a textura simples transforma , também é possível ter mais de um conjunto de coordenadas de textura de um modelo . Panda permite que você defina como muitos conjuntos diferentes de coordenadas de textura que você quiser, e cada jogo pode ser completamente alheios a todos os outros.

Quando você tem textura vários conjuntos de coordenadas (Às vezes chamado vários conjuntos de UV) em um modelo , cada conjunto terá o seu próprio nome , que é qualquer seqüência arbitrária . A textura coordenadas padrão definido não tem nome (seu nome é uma string vazia ).

Normalmente, você criar vários conjuntos de coordenadas de textura no pacote de modelagem mesma que você usa para criar o modelo. Nem todos os pacotes de modelagem, e não todos os conversores Panda , suporte textura várias coordenadas. De fato, a partir da data desta escrita, apenas a versão 1.1 Panda3D (ou superior) do conversor maya2egg é conhecido por converter a textura em múltiplas coordenadas Panda.

Se acontecer de ter um modelo com vários conjuntos de coordenadas de textura , você pode especificar que um conjunto de textura particular deve usar chamando TextureStage.setTexcoordName ( "nome"). Lembre-se de um TextureStage é usada para aplicar uma textura a um modelo , e assim todos terão uma textura TextureStage associados ( embora a maioria das texturas é só usar o TextureStage padrão). Caso você não chamar esse método para um TextureStage particular, o comportamento padrão é usar o padrão, textura unnamed conjunto de coordenadas .

O TextureStages diferente em um modelo podem compartilhar a mesma textura conjuntos coordenados , ou eles podem usar uma textura de cada conjunto de coordenadas diferentes , ou qualquer combinação.

Panda3D Manual: Textura automática Coordenadas

   Prev TopoPróximo

  Pitão/C + +

  

Além de usar coordenadas de textura que são incorporadas ao modelo , também é possível gerar coordenadas de textura em tempo de execução . Normalmente você usaria essa técnica para conseguir algum efeito especial , como texturização projetiva ou mapeamento do ambiente, mas às vezes você pode simplesmente

querer aplicar uma textura a um modelo que já não tem coordenadas de textura , e esta é a única maneira de fazer isso .

As coordenadas de textura gerada por esta técnica são geradas on- the-fly, e não são armazenados no modelo. Quando você desligar o modo de produção, a textura coordenadas deixam de existir.

Use o método NodePath a seguir para habilitar a geração automática de coordenadas de textura :

nodePath.setTexGen(TextureStage, texGenMode)

O parâmetro texGenMode especifica como as coordenadas de textura devem ser computados , e pode ser qualquer uma das seguintes opções. Na lista abaixo , "olho ", o espaço de coordenadas da câmera de observação, e " mundo " significa que as coordenadas do mundo , por exemplo, o espaço de coordenadas render, a raiz do grafo de cena.

TexGenAttrib.MWorldPosition Copia o (x , y, z ) posição de cada vértice , no espaço do mundo , ao (u, v , w) coordenadas de textura.

TexGenAttrib.MEyePosition Copia o (x , y, z ) posição de cada vértice , no espaço da câmera, ao ( u, v , w) coordenadas de textura.

TexGenAttrib.MWorldNormal Copia o (x , y, z) de iluminação normal de cada vértice , no espaço do mundo , ao (u, v , w) coordenadas de textura.

TexGenAttrib.MEyeNormal Copia o (x , y, z) de iluminação normal de cada vértice , no espaço da câmera, ao ( u, v , w) coordenadas de textura.

TexGenAttrib.MEyeSphereMap Gera (u, v) as coordenadas da textura com base na iluminação normal eo vetor para aplicar um mapa esfera padrão de reflexão .

TexGenAttrib.MEyeCubeMap Gera (u, v , w) coordenadas de textura com base na iluminação normal eo vetor para aplicar um mapa de cubo padrão de reflexão .

TexGenAttrib.MWorldCubeMap Gera (u, v , w) coordenadas de textura com base na iluminação normal eo vetor para aplicar um mapa de cubo padrão de reflexão .

TexGenAttrib.MPointSprite Gera (u, v) as coordenadas da textura no intervalo ( 0, 0) para (1, 1 ) por pontos grandes de modo que a textura cobre a praça. Este é um modo especial que deve ser aplicado apenas quando estão prestando sprites, geometria da ponta especiais que são renderizados como quadrados. Não faz sentido aplicar este modo para qualquer outro tipo de geometria. Normalmente você não iria definir este modo diretamente; deixar o SpriteParticleRenderer fazê-lo para você.

TexGenAttrib.MLightVector Gera especiais ( u , v, w) textura coordenadas que representam o vetor de cada vértice a uma luz especial no grafo de cena , no espaço tangente a cada vértice . Este é

usado para implementar mapas normal. Este modo requer que cada vértice tem uma tangente e um binormal computado para ele antes do tempo , você também deve especificar o NodePath que representa a direção da luz. Normalmente, você não definir esta modalidade , quer directamente , uso NodePath.setNormalMap (), ou implementar mapas normal usando shaders programáveis.

Note-se que várias das opções acima gerar textura coordenadas 3-D : ( u, v , w) em vez de apenas (u, v). A terceira coordenada pode ser importante se você tem uma textura 3-D ou um mapa de cubo ( descrito posteriormente ), mas se você só tem uma textura normal 2-D a coordenar extra é ignorado. (No entanto , mesmo com uma textura de 2-D , você pode aplicar um 3 -D para transformar a textura coordenadas , o que traria de volta a terceira coordenada na equação. )

Além disso, note que quase todas estas opções têm um efeito muito limitado, você geralmente usar a maioria desses só para executar o efeito especial que eles foram projetados. Este manual irá discutir estes modos special-purpose TexGen em seções posteriores , como cada um dos efeitos é discutida , por agora, você só precisa entender que elas existem, e não se preocupar sobre o que exatamente eles fazem.

O modo que é mais provável que tenha utilidade geral é o primeiro : MWorldPosition. Este modo converte cada vértice (x , y, z ) posição no espaço mundial, e em seguida, copia esses três valores numéricos para a ( u, v , w) coordenadas de textura. Isso significa, por exemplo, que se você aplicar uma textura normal 2-D para o objeto, o objeto ( x , y) a posição será utilizado para procurar cores na textura.

Por exemplo , o modelo de amostra teapot.egg que vem com o Panda não tem textura coordenadas construída no modelo, de modo que você normalmente não pode aplicar uma textura a ele. Mas você pode permitir a geração automática de coordenadas de textura e , em seguida, aplicar uma textura :

teapot = loader.loadModel('teapot.egg')tex = loader.loadTexture('maps/color-grid.rgb')teapot.setTexGen(TextureStage.getDefault(), TexGenAttrib.MWorldPosition)teapot.setTexture(tex)

E você acaba com algo como isto:

Você pode usar isso em conjunto com uma textura de transformação para manipular as coordenadas de textura. Por exemplo, para girar a textura de 90 graus , você poderia fazer algo como isto:

teapot.setTexTransform(TextureStage.getDefault(), TransformState.makeHpr(VBase3(0, 90, 0)))

Finalmente, considere que as duas únicas opções para a armação de coordenar a textura coordenar geração são " mundo "e" olho "para a raiz e as NodePath NodePath câmera , respectivamente. Mas o que se pretende gerar a textura coordenadas em relação a algum outro nó, dizem que o bule de chá em si? As imagens acima são todas muito bem para um bule de chá que acontece de estar situada na origem , mas suponho que nós queremos o bule de chá para permanecer o mesmo quando passamos em outro lugar no mundo?

Se você utilizar apenas MWorldPosition, Então quando você mudar a posição do bule de chá , por exemplo, por pais para um nó móvel, o bule parecerão mover-se enquanto o seu padrão de textura permanece no local - talvez não o efeito que você tinha em mente. O que você provavelmente foi destinado para o bule de chá para tomar o seu padrão de textura junto com ele como ele se move ao redor. Para fazer isso, você precisará calcular a textura coordenadas no espaço do nó bule , ao invés de no espaço do mundo .

Panda3D fornece a capacidade de gerar coordenadas de textura no espaço de coordenadas de um nó arbitrário que você gosta. Para fazer isso , use MWorldPosition em conjugação com o projetor da Panda "textura" , que se aplica a transformação relativa entre quaisquer dois NodePaths arbitrária para transformar a textura , você pode usá-lo para calcular a transformação do espaço em relação ao mundo bule espaço , como este: teapot.setTexGen ( TextureStage.getDefault (), TexGenAttrib.MWorldPosition )teapot.setTexProjector ( TextureStage.getDefault () , render, bule de chá );

Pode parecer um pouco tortuoso para converter os vértices bule de espaço do mundo para gerar as coordenadas de textura e, em seguida, converter a textura coordenadas de volta ao espaço bule de novo - afinal, eles não começam no espaço bule ? Teria economizado muito esforço apenas para mantê-los lá! Por que não apenas fornecer um Panda MObjectPosition modo que iria converter coordenadas de textura da posição natural do objeto ? Essa é uma pergunta justa, e MObjectPosition seria uma ótima idéia para um modelo tão simples como o bule de chá , que é, afinal, apenas um nó . Mas, para modelos mais sofisticados , que podem conter várias sub- nós , cada um com seu próprio espaço de coordenadas , a idéia de MObjectPosition é menos útil , a menos que você realmente queria que cada sub -nó para ser re- texturizados dentro do seu próprio espaço de coordenadas . Ao invés de oferecer esse recurso de valor questionável, Panda3D prefere dar-lhe a possibilidade de especificar as coordenadas espaço especial que você tinha em mente, de forma inequívoca. Observe que você apenas deseja chamar setTexProjector () quando você estiver usando o modo MWorldPosition. Os outros modos são geralmente calculados a partir de vetores ( por exemplo, os normais ), não as posições, e, geralmente, não faz sentido aplicar uma transformação em relação a um vetor.

Panda3D Manual: Texturas Projetada

Em um seção anterior, Que introduziu formas de aplicar uma transformação explícita a textura de um modelo de coordenadas, com métodos como setTexOffset () e setTexScale (). Além deste controle explícito , Panda3D oferece um mecanismo simples para aplicar uma textura automática transformar cada frame , calculado a partir da transformação relativa entre quaisquer dois nós. nodePath.setTexProjector(textureStage, fromNodePath, toNodePath)

Quando você tiver ativado esse modo , a relação cena -gráfico de transformar fromNodePath para toNodePath- Isto é, o resultado de fromNodePath.getTransform toNodePath ()- é aplicada automaticamente como uma textura coordenadas para transformar o textureStage indicado. O resultado é mais ou menos como se você executou o comando a seguir a cada frame:

nodePath.setTexTransform(textureStage, fromNodePath.getTransform(toNodePath))

Não há necessidade de qualquer fromNodePath ou toNodePath ter qualquer relação com a nodePath que está recebendo a setTexProjector () convite, eles podem ser quaisquer dois NodePaths arbitrária. Se qualquer um deles é apenas NodePath (), que representa o topo do gráfico. Isto tem várias aplicações úteis. Nós já introduziram uma aplicação, Em conjugação com MWorldPosition, Para mover a textura coordenadas geradas a partir da raiz do gráfico para o modelo em si.

Intervalo animado textura transformaOutro aplicativo útil para um TexProjector é permitir a utilização dos vários LerpIntervals Para animar a textura transformar. Embora não existam LerpIntervals que a textura diretamente animar transforma, você pode fazer uma LerpInterval animar um NodePath - e , em seguida, criar um efeito TexProjector a seguir que NodePath . Por exemplo:

smiley = loader.loadModel('smiley.egg')lerper = NodePath('lerper')smiley.setTexProjector(TextureStage.getDefault(), NodePath(), lerper)i = lerper.posInterval(5, VBase3(0, 1, 0))i.loop()

Observe que você não tem sequer a mãe do NodePath animado para o grafo de cena. No exemplo acima , temos que configurar o intervalo Eu repetidamente para mover o NodePath autônomo lerper da posição (0, 0 , 0) para (0, 1 , 0) mais de 5 segundos. Desde smiley é atribuído um TexProjector que copia a transformação da relação NodePath () para lerper- Isto é, a transformação do líquido lerper- isso significa que estamos realmente anima a textura coordenadas em smiley de (0 , 0) para (0, 1) ( coordenada Z é ignorado para uma textura normal 2-D ).

Texturas ProjetadaOutro aplicativo útil do TexProjector é implementar texturas projetadas- Isto é, uma textura aplicada à geometria como se tivesse sido projetado a partir de uma lente , algures no mundo , algo como um projetor de slides. Você pode usar esse recurso para aplicar um efeito de lanterna, por exemplo, ou simples sombras projetadas .

Isso funciona porque o efeito TexProjector faz um truque adicional : se a segunda no NodePath setTexProjector () chamada acontece a ser um LensNode , o TexProjector aplica automaticamente matriz de projeção para a textura da lente coordenadas ( além de aplicar a transformação relativa entre os nós ).

Para implementar as texturas projetadas, você precisa fazer três etapas:

1. Aplique a textura que você quer para o modelo que você quer projetá-la em , geralmente em sua TextureStage própria , de modo que é multitextured.

2. Coloque o MWorldPosition TexGen modo do modelo. Isso copia o modelo de cargos em seu vértice coordenadas de textura , para TextureStage sua textura. 3. Chamada model.setTexProjector ( textureStage , NodePath () , projector), Onde projetor é o NodePath ao LensNode deseja projeto de.

Para sua conveniência , a classe NodePath define o seguinte método que executa estas três etapas de uma só vez :

nodePath.projectTexture(textureStage, texture, lensNodePath)

Por exemplo , poderíamos usá-lo para o projeto de textura de bambu (" ambi , reeds.png ) para o modelo ripple.egg , como este:

Você pode mover o projetor do mundo, ou até mesmo alterar o campo de visão da lente , ea imagem de bambu que segui-lo. ( Na imagem acima , o modelo da câmera e as linhas de projeção são visíveis apenas para fins de ilustração , normalmente você não iria vê-los. )

Esta imagem foi gerada com o seguinte código (extraído ; clique aqui para o programa completo ):

ripple = Actor.Actor('ripple.egg')ripple.reparentTo(render)

proj = render.attachNewNode(LensNode('proj'))lens = PerspectiveLens()proj.node().setLens(lens)proj.reparentTo(render)

proj.setPos(1.5, -7.3, 2.9)proj.setHpr(22, -15, 0)

tex = loader.loadTexture('maps/envir-reeds.png')ts = TextureStage('ts')ripple.projectTexture(ts, tex, proj)

Panda3D Manual: Mapeamento de ambiente simples

Existe uma técnica clássica em computação gráfica em tempo real para fazer os objetos aparecem brilhante ou reflexiva. É chamado mapeamento do ambiente ou às vezes mapeamento de reflexão ou, neste caso, mapeamento de campo.

Ambiente mapeamento não está traçado de raios. Mas é uma forma de queijo para obter um efeito similar. A idéia de ambas é que , matematicamente, é fácil calcular a direção na qual um raio de luz deve ter vindo antes que saltou fora de um determinado ponto de um objeto brilhante e entrou em seu olho. Se o processador estava usando ray tracing , que irá seguir este raio , para cada ponto do seu objeto brilhante , para trás de seus olhos, e determinar o objeto no meio do raio veio , e isso é o que você vê no reflexo.

Ray tracing é ainda muito de computação intensiva para ser feito em tempo real. Mas um vetor de reflexão é fácil de calcular por vértice , e se nós pudéssemos fazer um vetor para uma reflexão (u, v) par de coordenadas de textura , o hardware é particularmente bom em olhar a cor em uma imagem de textura , que corresponde ao (U, v par). Então, tudo o que precisamos é uma imagem que mostra os objetos em nosso meio.

Em mapeamento de campo, O vetor de reflexão 3-D é transformada em uma textura de 2-D par de coordenadas matematicamente aplicando uma distorção esférica. Isso significa que o mapa de ambiente deve ser uma visão do mundo visto através de uma lente olho de peixe de 360 graus, ou como refletido em uma esfera brilhante como um ornamento do feriado. Pode ver porque é chamado de mapeamento esfera.

Panda3D pode gerar mapas de campo para você. O mapa esfera acima foi gerado com o seguinte código:

scene = loader.loadModel('bvw-f2004--streetscene/street-scene.egg')scene.reparentTo(render)scene.setZ(-2)base.saveSphereMap('streetscene_env.jpg', size = 256)

A idéia é simplesmente colocar a câmera no meio do seu ambiente, aproximadamente onde o objeto seria brilhante . Então, basta chamar base.saveSphereMap ()E uma imagem de mapa adequado esfera será gerado e gravado em disco para você. Note que este recurso é novo a partir de Panda3D 1.1.

Agora você pode aplicar o mapa de ambiente para praticamente qualquer objeto que você gosta. Por exemplo, o bule de chá :

tex = loader.loadTexture('streetscene_env.jpg')teapot.setTexGen(TextureStage.getDefault(), TexGenAttrib.MEyeSphereMap)teapot.setTexture(tex)

Neste exemplo , você pode ver que a chave para o mapeamento da área de Panda é definir o modo TexGen para MEyeSphereMap . Este modo calcula um esférico (u, v) textura par de coordenadas com base no vetor de reflexão para cada vértice do bule. Para que isso funcione, o modelo deve ter definido normais para todos os seus vértices ( o bule tem normals bom).

bules Shiny são uma coisa, mas seria bom fazer algo como, digamos, um carro olhar brilhante. Nós poderíamos apenas fazer exatamente a mesma coisa acima, mas o nosso carro tem um mapa de textura já. Se nós apenas substituir o mapa de textura com o mapa do ambiente que vai acabar com um carro chrome:

car = loader.loadModel('bvw-f2004--carnsx/carnsx.egg')tex = loader.loadTexture('streetscene_env.jpg')car.setTexGen(TextureStage.getDefault(), TexGenAttrib.MEyeSphereMap)car.setTexture(tex, 1)

Isso parece bastante tolo. Então, nós realmente preferem usar multitexture aplicar textura tanto do automóvel regular, e uma camada um pouco de brilho em cima disso. Usaremos Modo Adicionar para adicionar o mapa do ambiente para a cor existente , que é apropriado para um destaque em um objeto brilhante .

Para poder usar o modo Adicionar sem saturar as cores , precisamos para escurecer o mapa de ambiente substancialmente. Nós poderíamos usar qualquer programa de processamento de imagem para fazer isso, para este exemplo, vamos usar o Panda3D imagem trans- utilidade:

image-trans -cscale 0.2 -o streetscene_env_dark.jpg streetscene_env.jpg

Assim, o novo mapa parecido com este:

Enquanto estamos de consertar as coisas , vamos mover as rodas para um nó diferente , para que possamos atribuir a brilhar só para o metal e corpo de vidro do carro:

car = loader.loadModel('bvw-f2004--carnsx/carnsx.egg')body = car.find('**/body')body.findAllMatches('**/FL_wheel*').reparentTo(car)

E agora, o brilho é aplicado da seguinte forma:

tex = loader.loadTexture('streetscene_env_dark.jpg')ts = TextureStage('env')ts.setMode(TextureStage.MAdd)body.setTexGen(ts, TexGenAttrib.MEyeSphereMap)body.setTexture(ts, tex)

Observe que a brilhante destaques são agora bastante sutil , mas ainda atraente, especialmente quando você vê o movimento do carro.

A técnica de mapa de domínio não é perfeito. O maior problema com ele é que você tem que prepará-la antes do tempo, o que significa que você tem que saber exatamente o que será refletido em seus objetos brilhantes - é impossível para um objeto para refletir um objeto dinâmico (por exemplo, um carro ao lado ).

Outro problema é que do ponto de vista é cozido no mapa esfera , de modo que se a câmara estava a oscilar ao redor para ver o carro do outro lado , as coisas que você podia ver no reflexo ainda estaria por trás dos objetos câmera deste lado.

Ambos estes problemas podem ser resolvidos por mapeamento de cubo, Que é uma técnica mais avançada , entre outras coisas , a aplicação de mapas de ambiente. No entanto , os mapas cubo nem sempre são ideais, muitas vezes , o mapa esfera venerável é realmente a melhor escolha.

É raro que um aplicativo apresenta uma visão closeup de um suave , redondo espelhado objeto no qual você pode ver claramente reflexões , como o exemplo acima bule , geralmente , são apenas reflexos glinting uma sutil na superfície , como o carro. Nestes casos, o mapa esfera é ideal , pois não é tão importante exatamente que As reflexões são , mas simplesmente que não existe são reflexões. E o mapa esfera é a maneira mais rápida e fácil para processar as reflexões.

Até agora, nós só falamos sobre mapas de textura normal 2-D. Começando com a versão 1.1, Panda3D também suporta o conceito de um mapa de textura 3-D. Esta é uma textura volumétrica : para além de uma altura e uma largura , ela também tem uma profundidade de :

A textura da imagem 3-D é sólido durante todo o tempo , se tivéssemos que cortar parte do cubo iríamos descobrir que o padrão xadrez continua em :

Isto é verdade não importa a forma que nós extirpar do cubo :

Além da usual u e v dimensões de textura , a textura 3-D também tem w. Para aplicar uma textura em 3-D para a geometria , você vai , portanto, precisa ter textura coordenadas 3-D (U, v , w) em sua geometria, em vez de apenas o ordinário (U, v).

Existem várias maneiras de obter textura coordenadas 3-D em um modelo . Uma maneira é atribuir textura 3-D adequado coordenadas para cada vértice ao criar o modelo , da mesma forma você pode atribuir textura coordenadas 2-D . Isso requer que o pacote de modelagem (e seu conversor Panda ) apoio textura coordenadas 3-D , no entanto, no momento da redação deste texto , nenhum dos conversores Panda que actualmente suportam textura coordenadas 3-D .

Mais comumente , textura coordenadas 3-D são atribuídos automaticamente para um modelo com um dos modos TexGen, Especialmente MWorldPosition. Por exemplo, para atribuir textura coordenadas 3-D para o bule de chá , você pode fazer algo como isto: teapot = loader.loadModel('teapot.egg')teapot.setTexGen(TextureStage.getDefault(), TexGenAttrib.MWorldPosition)teapot.setTexProjector(TextureStage.getDefault(), render, teapot)teapot.setTexPos(TextureStage.getDefault(), 0.44, 0.5, 0.2)teapot.setTexScale(TextureStage.getDefault(), 0.2)

O atribui acima textura coordenadas 3-D para o bule com base no (x , y, z ) as posições de seus vértices , que é uma maneira comum de atribuir textura coordenadas 3-D . O setTexPos () e setTexScale () solicita, em particular acima são para o modelo de bule , esses números são escolhidos a escala da textura de modo que sua unidade de cubo inclui o bule.

mapas de textura Armazenamento 3-D no disco é um pouco de um problema , uma vez que a maioria dos formatos de imagem só suporta imagens 2-D. Por convenção , então, Panda3D vai armazenar uma imagem de textura 3-D por corte -o em horizontal seções transversais e escrever cada fatia como uma imagem separada em 2-D . Quando você carregar uma textura 3-D , você especifica uma série de imagens 2-D que Panda3D irá carregar e empilhar como panquecas para fazer a imagem em 3-D.

A textura da imagem acima de 3 -D , por exemplo, são armazenados como arquivos de imagem de quatro em separado:

Note que, embora a imagem é armazenada como quatro imagens separadas no disco, internamente Panda3D armazena como uma imagem única, tridimensional, com altura , largura e profundidade.

A convenção Panda3D para nomear as fatias de uma textura 3-D é bastante rígida. Cada fatia deve ser numerada, e todos os nomes devem ser os mesmos, exceto para o número e o primeiro (em baixo) fatia deve ser numerada com 0. Se você seguiu esta convenção , então você pode carregar uma textura 3-D com um convite como este:

tex = loader.load3DTexture("grid_#.png")

O cardinal ("#") no nome do arquivo passado para loader.load3DTexture () será preenchido com o número sequencial de cada fatia , para as cargas acima de arquivos chamado " grid_0.png "," grid_1.png "," grid_2.png ", e assim por diante. Se você preferir para preencher o número de zeros a fatia com um certo número de algarismos , repita o cardinal , por exemplo, carregar " grid_ # # #. png "iria procurar arquivos com o nome " grid_000.png "," grid_001.png " E assim por diante . Observe que você não precisa usar marcas hash múltiplos contagem superior a 9 . Você pode contar com tão alto quanto você gosta , mesmo com apenas uma marca hash , ele só não vai preencher o número de zeros.

Lembre-se que você deve normalmente escolher uma potência de dois para o tamanho das imagens da sua textura. Isso se estende até o w tamanho , também: para a maioria das placas gráficas , o número de fatias de sua textura deve ser uma potência de dois. Ao contrário do normal (U, v) dimensões, Panda3D não irá automaticamente redimensionar sua textura 3-D se ele tem um poder não- de-dois no tamanho w dimensão , por isso é importante escolher corretamente o tamanho do mesmo.

Os pedidos de texturas 3-Dtexturas em 3-D são usados em aplicações de imagens médicas e científicas , mas eles são usados apenas raramente em programas de jogo 3-D. Uma razão para isso é a quantidade de memória de que necessitam , já que a textura 3-D requer armazenamento (V u × w) texels , uma textura grande 3 -D pode facilmente consumir uma fração substancial de sua memória de texturas disponíveis.

Mas provavelmente o motivo maior que texturas 3-D são raramente utilizados em jogos é que as imagens de textura em jogos geralmente são pintadas à mão , e é difícil para um artista para pintar uma textura 3-D. É geralmente muito mais fácil apenas para pintar a superfície de um objeto.

Assim, quando as texturas em 3-D são usados em tudo, eles são muitas vezes geradas processualmente . Um exemplo clássico de uma textura procedural 3-D é grão de madeira , é bastante fácil de definir uma textura woodgrain convincente processual . Por exemplo, clique aqui para ver um programa Panda3D que gera uma textura woodgrain e armazena-lo como uma série de arquivos chamados

woodgrain_0.png , woodgrain_1.png , e assim por diante. O código a seguir aplica-se esta textura woodgrain para o bule , para fazer um bule de chá que parece ter sido esculpido em um único bloco de madeira:

teapot = loader.loadModel('teapot.egg')teapot.setTexGen(TextureStage.getDefault(), TexGenAttrib.MWorldPosition)teapot.setTexProjector(TextureStage.getDefault(), render, teapot)teapot.setTexPos(TextureStage.getDefault(), 0.44, 0.5, 0.2)teapot.setTexScale(TextureStage.getDefault(), 0.2) tex = loader.load3DTexture('woodgrain_#.png')teapot.setTexture(tex)

No entanto, mesmo em termos processuais geradas texturas 3-D como este são usados apenas ocasionalmente. Se o algoritmo para gerar a sua textura não é muito complexa , pode fazer mais sentido um programa pixel shader para gerar a textura implicitamente, como seus modelos são prestados.

Ainda assim, mesmo se for usada apenas ocasionalmente , a textura 3-D continua a ser uma poderosa técnica de processamento para se manter em seu bolso traseiro.

Panda3D Manual: Mapas Cube

Há um tipo mais especial de mapa de textura : o mapa de cubo, Que é introduzido no Panda3D versão 1.1. Um mapa de cubo é semelhante a um textura 3-D, na medida em que requer textura coordenadas 3-D (U, v , w), Também , um mapa de cubo é armazenado no disco como uma seqüência de imagens comuns 2-D.

Mas ao contrário de uma textura 3-D, que é definido pelo empilhamento de um número arbitrário de imagens 2-D como panquecas para encher um volume , um

mapa de cubo é sempre definida com imagens exatamente seis 2-D , que são dobrados para formar um cubo.

As seis imagens de um mapa de cubo são numerados 0-5 , e cada imagem corresponde a uma face particular do cubo :

imagem 0 O + u (Ou + x) direito (face)

imagem 1 O -U (Ou -X) face ( esquerda)

imagem 2 O v + (Ou + y) Para a frente (face)

imagem 3 O -V (Ou -Y) face (costas)

imagem 4 O w + (Ou + z) face ( para cima)

Imagem 5 O -W (Ou -Z), face (em baixo)

Por + x cara, queremos dizer mais distante da face do cubo no eixo X positivo . Na falta do Panda3D Z -up sistema de coordenadas , este é o direito face. Da mesma forma, o -X face é a face mais distante ao longo do eixo X negativo , ou o esquerda face, e assim por diante para o Y e Z faces. Uma vez que as coordenadas de um mapa de textura são chamados (U, v , w) em vez de (X , y, z), É tecnicamente mais correto chamar essas as + u e -U faces , embora muitas vezes é mais fácil pensar neles como + x e -X.

Os rostos são definidos de acordo com o seguinte esquema:

Imagine que você corta o diagrama acima e dobrado em forma de cubo . Você poderia acabar com algo parecido com isto :

Note que, quando você prende o cubo de forma que as indicações para cada eixo face estão na direção apropriada ( como na foto acima ), vários são os rostos de cabeça para baixo ou de lado . Isso é devido à forma como os fabricantes de placas gráficas decidiu fixar o mapa faces do cubo (e também por causa do padrão Panda3D sistema de coordenadas ). Mas, na verdade , não importa o caminho que os rostos são orientados , contanto que você sempre gerar imagens mapa do cubo da mesma maneira.

Em certo sentido, um mapa do cubo é um tipo de textura da superfície , como uma textura normal 2-D. Mas em outro sentido , também é volumétrico como uma textura em 3-D : cada ponto, dentro da textura 3-D de coordenadas espaço é colorida de acordo com a face do cubo que vem mais próximo . Um modelo de domínio com o cubo mapa aplicada a ele iria pegar os mesmos seis faces:

Note-se que , enquanto uma textura 3-D atribui um pixel diferente da textura para cada ponto dentro de um volume, um mapa cubo atribui um pixel diferente da textura para cada direção a partir do centro .

Você pode carregar um mapa de cubo de uma série de seis arquivos de imagem , muito semelhante à maneira que você carregar uma textura 3-D:

tex = loader.loadCubeMap (' cubemap_ #. png )

Tal como acontece com uma textura 3-D , o ("#") marca hash no nome do arquivo vai ser preenchido com o número de seqüência de imagens, que no caso de um mapa de cubo será um dígito 0-5 . O exemplo acima , então, irá carregar as seis imagens de " cubemap_0.png "," cubemap_1.png "," cubemap_2.png "," cubemap_3.png "," cubemap_4.png "e" cubemap_5.png ", e montar los em um mapa de cubo.

Panda3D Manual: Mapeamento do Ambiente com Cube Maps

Embora haja outras aplicações para mapas de cubo, um uso muito comum de mapas é como um cubo mapear o ambiente, Semelhante ao mapeamento de campo. Na verdade , ele trabalha muito a mesma esfera de mapeamento .

Assim como com um mapa de domínio , você pode ter Panda3D gerar um mapa de cubo para você:

scene = loader.loadModel('bvw-f2004--streetscene/street-scene.egg')scene.reparentTo(render)scene.setZ(-2)base.saveCubeMap('streetscene_cube_#.jpg', size = 256)

O exemplo a seguir carrega o código de um ambiente , coloca a câmera no centro dele, e gera as seis faces do cubo a partir de um mapa do ponto de vista da câmera:

scene = loader.loadModel('bvw-f2004--streetscene/street-scene.egg')scene.reparentTo(render)scene.setZ(-2)base.saveCubeMap('streetscene_cube_#.jpg', size = 256)

Estas são as seis faces gerados:

Direita:

Esquerda:

Frente:

Back:

Top:

Bottom :

E quando eles são montados em um mapa de cubo , olha como este:

Ou, quando nós aplicamos esse mapa cubo de uma esfera , você pode ver não há absolutamente nenhuma emenda entre as extremidades :

Com o cubo mapa salvou -se como acima, você poderia aplicá-lo como um mapa de ambiente para o bule de chá como este:

tex = loader.loadCubeMap('streetscene_cube_#.jpg')teapot.setTexGen(TextureStage.getDefault(), TexGenAttrib.MEyeCubeMap)teapot.setTexture(tex)

E o resultado é muito parecido com o mapa esfera :

De fato, ele parece tão semelhantes que se pode saber porque nós incomodamos . Até o momento, um mapa do cubo parece muito similar a um mapa esfera , exceto que ele consome seis vezes a memória de textura. Dificilmente impressionante.

Mas como nós mencionamos mais cedo, Existem dois problemas com os mapas que os mapas esfera cubo pode resolver. Um desses problemas é que o ponto de vista é permanentemente cozido no mapa esfera. mapas Cube não têm necessariamente o mesmo problema. Na verdade , podemos resolvê-lo com uma variação simples:

tex = loader.loadCubeMap('streetscene_cube_#.jpg')teapot.setTexGen(TextureStage.getDefault(), TexGenAttrib.MWorldCubeMap)teapot.setTexture(tex)

Ao mudar MEyeCubeMap para MWorldCubeMap, Indicamos que gostaríamos que este mapa cubo para variar o seu ponto de vista como a câmera se move . Agora, o ambiente reflete irá variar de acordo com a direção que estamos olhando para ele , para que ele mostra o que está por trás das câmeras em tempo de execução , em vez de estar sempre mostrando a área por trás da câmera quando o mapa do cubo foi gerada , como um mapa esfera deve fazer . Para que isso funcione corretamente , você deve se assegurar que a câmara está sem estarem rodados (ou seja, setHpr (0, 0 , 0)) quando você gera o mapa cubo inicialmente.

Mesmo com MWorldCubeMap , porém, a imagem ainda é gerado antes do tempo , assim que a reflexão não na realidade mostrar o que está por trás das câmeras em tempo de execução . Ela apenas usa a direção atual da câmera para descobrir o que parte da imagem de reflexão para mostrar .

No entanto , você pode fazer um mapa de cubo que realmente faz refletir objetos dinâmicos no cenário , tornando um mapa de cubo dinâmico. Isto será discutido na próxima seção .

Panda3D Manual : Animação Textura automáticaÉ possível gerar um modelo que roda automaticamente através de uma seqüência de texturas , quando se está no grafo de cena , sem ter que executar uma tarefa especial para lidar com isso.

Para fazer isso , use o ovo- textura -cards utilitário de linha de comando. Este programa irá aceitar uma série de nomes de textura na linha de comando , e um arquivo de saída do ovo que gira através de cada textura na taxa de quadros especificados: egg-texture-cards -o flip.egg -fps 30 explosion*.jpg

Isso realmente cria um modelo com um polígono diferente para cada quadro da animação de textura. Cada polígono é colocado em um nó separado , e todos os nós são feitos de uma criança de um nó especial chamado SequenceNode.

O SequenceNode é um nó especial que só chama um de seus filhos em um momento, e ele gira a lista das crianças a uma taxa de frame particular. Você pai pode tornar o modelo com e ele irá automaticamente começar a animar com suas texturas . Se você precisa para começar em um quadro específico , use algo como isto:

flip = loader.loadModel('flip.egg')flip.find('**/+SequenceNode').node().pose(startFrame)flip.reparentTo(render)

Por padrão , todos os polígonos criados por ovo- textura -cards terá o mesmo tamanho. Isso significa que todas as suas texturas devem ser do mesmo tamanho também. Embora esta seja uma configuração simples , ele pode não ser ideal para determinados efeitos . Por exemplo, para animar uma explosão , que começa pequena e cresce mais , seria melhor usar uma pequena imagem da textura sobre um polígono pequeno quando a imagem é pequena, e tem uma imagem ampliada em um polígono maior quando ele cresce. Você pode conseguir este efeito, com o parâmetro -p , p- escalas especificando polígono cada frame em relação ao tamanho da textura correspondente.

egg-texture-cards -o flip.egg -fps 30 -p 240,240 explosion*.jpg

Existem vários outros parâmetros , bem ; uso de ovos de textura cartões -h Para obter uma lista completa.

Panda3D Manual: Jogando MPG e AVI

Panda agora suporta o formato AVI para texturas em Panda.

UsomyMovieTexture=loader.loadTexture("myMovie.avi")myObject.setTexture(myMovieTexture)

O subsistema filme é implementado utilizando FFMPEG . Por isso , ele suporta todos os formatos que FFMPEG suporta. As funções de controle do filme são as seguintes:

movie.play()movie.stop()movie.setTime(t)movie.getTime()movie.setLoopCount(n)movie.getLoopCount()movie.setPlayRate(speed)movie.getPlayRate()movie.isPlaying()

Se você quiser ouvir o áudio do filme , bem , você precisa carregá-lo duas vezes: uma como uma textura , e uma vez como um arquivo de som :

mySound=loader.loadSfx("myMovie.avi")

Depois, você pode synchonize o vídeo para o áudio:

myMovieTexture.synchronizeTo(mySound)

A partir desse ponto à frente , tocando o som fará com que a textura de atualização. Esta é mais precisa que a sincronização do vídeo manualmente.

Para poder -de-dois gráficos hardware limitadoSe o seu hardware de gráficos , não dá suporte a non poder -de-dois textura, o tamanho da textura de filme seria deslocado até a próxima potência maior das duas dimensões. Por exemplo, você tem um filme de 640 x 360 em tamanho, a textura gerada seria realmente 1024 x 512. O resultado é uma textura que contém um filme no canto inferior esquerdo, e uma região pad preto para a direita e porção superior da textura.

Para contornar este limite , você tem que mostrar apenas a parte inferior esquerdo da textura. Para ver uma demonstração completa deste processo, ver o Media Player programa de exemplo.

QuestõesO texure obras de decodificação de vídeo em um frame por frame base e copiar para o buffer de textura. Como tal , é desaconselhável a utilização de mais do que uma poucas texturas de alta resolução de vídeo , ao mesmo tempo .

Alguns formatos de codificação não funcionam. Até agora , o formato DV foi determinada incompatível com o Panda.

Panda3D Manual : Transparência e mistura

Lidar com profundidade Seleção

Normalmente transparência funciona como esperado no Panda automaticamente, mas às vezes isso parece dar errado , quando um objeto semi-transparente no fundo parece parcialmente obscuro objeto semitransparente na frente dele . Isto é especialmente provável de acontecer com grandes recortes polígono plano, ou quando um objeto transparente é contido dentro de outro objeto transparente, ou quando as partes de um objeto transparente pode ser visto atrás de outras partes do mesmo objeto.

O problema fundamental é que a transparência correto, na ausência de suporte de hardware especiais envolvendo bits framebuffer extra, requer desenho tudo em ordem da mais distante mais próximo . Isto significa que a classificação de cada polígono - na verdade, cada pixel, para correção verdade - em forma de volta -a- frente antes de desenhar a cena.

É , naturalmente, impossível separar cada objeto transparente em pixels individuais ou polígonos para classificar individualmente, tipo assim Panda objetos ao nível Geom , de acordo com o centro do volume delimitador. Isso funciona bem 95% do tempo.

Você executar em problemas com grandes polígonos planos , no entanto, uma vez que estes tendem a ter as peças que estão longe do centro do seu volume delimitador. A triagem bounding volume é muito provável que dão errado quando você tem dois ou mais apartamentos grandes fechar atrás do outro , e visualizá-las um pouco fora do eixo. ( Tente desenhar um retrato, um dos dois apartamentos , visto de cima, e imagine-se a vê-las em diferentes direções. imaginar também que o centro dos volumes é delimitadora ).

Agora, há uma série de soluções para este tipo de problema. Nenhuma solução é a certa para cada situação.

Em primeiro lugar, a melhor coisa a fazer é usar transparência M_dual . Este é um modo especial a transparência em que as partes completamente invisível do objeto não são atraídos para o buffer de Z a todos , de modo que eles não têm qualquer chance de obscurecer as coisas por trás delas. Isso só funciona bem se os

apartamentos são recortes típicos , onde há uma grande parte sólida (alpha == 1.0) e uma grande parte transparente (alpha == 0.0), e não um monte de peças semi-transparente (0,0 alfa < < 1.0) . É também um pouco mais caro do que o modo de renderização padrão do M_alpha , portanto, não é ativado por padrão no Panda. Mas palettize ovo vai ligá-lo automaticamente para um determinado modelo se detectar texturas que parecem recortes de natureza adequada , que é outra razão para usar ovo palettize se você não for usá-lo já.

Se você não usar ovos palettize (você deve realmente , você sabe) , você pode apenas mão -editar o ovo arquivos para colocar a linha :

<Scalar> alpha { dual }

dentro da referência <Texture> para as texturas em questão.

A segunda opção mais fácil é usar M_multisample transparência, que não tem qualquer problema ordenando a todos , mas só fica bem em muito os cartões de alta qualidade que têm bits multisample especiais de apoio à suavização de tela cheia. Além disso, no presente, só fica bem nessas placas high-end em modo OpenGL (desde nossa pandadx drivers não suportam M_multisample explicitamente agora). Mas se M_multisample não é suportada por um hardware específico ou panda driver , ele automaticamente retorna ao M_binary , que também não tem quaisquer problemas de ordem , mas sempre tem as bordas serrilhadas ao longo da borda do corte . Isso só funciona bem em imagens de textura , que representam recortes , como M_dual acima.

Se você usar palettize ovo, você pode acoplar M_multisample modo , colocando a palavra " ms " em linha com a textura (s). Sem palettize ovo , a mão -editar o ovo arquivos para colocar a linha :

<Scalar> alpha { ms }

dentro da referência <Texture> para as texturas em questão.

Uma terceira opção mais fácil é cortar um ou ambos os modelos concorrentes em pequenos pedaços , cada um dos quais pode ser classificado de forma independente pelo Panda. Por exemplo , você pode dividir um polígono em uma grande rede de pequenos polígonos , ea classificação é mais provável que seja preciso para cada parte (porque o centro da bounding volume está mais próximo do pixels). Você pode tirar uma foto para ver como isso funciona. Para fazer isso corretamente, você não pode simplesmente fazer uma grande malha de pequenos polígonos , desde Panda vai fazer uma malha em um único Geom tristrips , ao contrário, ele precisa ser separado malhas , de modo que cada um vai se tornar seu Geom própria . Obviamente, isso é um pouco mais caro também, já que você está

introduzindo vértices adicionais e adicionando mais objetos para a lista de classificação , para que você não quer ir muito louco com a pequenez de seus polígonos.

A quarta opção é simplesmente desabilitar a profundidade de escrever sobre seus objetos transparentes. Esta é mais eficaz quando você está tentando representar algo que é pouco visível , como o vidro ou uma bolha de sabão . Fazendo isso não melhora a probabilidade de classificação correta, mas tendem a fazer os artefatos de uma classificação incorreta menos óbvia. Você pode conseguir isso usando a opção de transparência " blend_no_occlude " em um arquivo de ovo , ou explicitamente desativar a profundidade de escrever em um modelo carregado com node_path.set_depth_write (false). Você deve ter cuidado apenas com a profundidade desativar escrever sobre as peças transparentes, e não nas partes opacas.

A opção final é fazer com que os pedidos de classificação explícita a Panda. Isso é muitas vezes o último recurso porque é mais difícil, e não generalizar bem, mas tem a vantagem de não adicionar sanções adicionais de desempenho, a sua cena . Só funciona bem quando os objetos transparentes podem ser classificados de forma confiável com relação a tudo o resto para trás. Por exemplo, as nuvens no céu pode ser estabelecida de forma confiável antes de quase tudo no cenário , exceto o próprio céu . Da mesma forma, um grande plano que é contra uma parede opaca pode confiantemente ser elaborado depois de todos os objetos opacos , mas antes de qualquer outro objeto transparente, independentemente do local onde a câmera passa a ser colocado em cena. Veja howto.control_render_order.txt para obter mais informações sobre explicitamente controlar a ordem de renderização.

Panda3D Manual: Gestão de Textura

diferentes placas de vídeo fornecem diferentes quantidades de memória de textura. Se você estiver carregando um monte de texturas diferentes, especialmente se forem grandes, você pode facilmente consumir toda a sua memória de texturas disponíveis. Em princípio , isso não deve causar problemas , contanto que você não tem todas as suas texturas na tela ao mesmo tempo: tanto OpenGL e DirectX são supostos expulsar automaticamente texturas de memória de gráficos conforme necessário.

Na prática, nem sempre esse trabalho de forma limpa . Em algumas placas gráficas integradas , a " memória gráfica "é na verdade seu sistema de memória , por isso nunca o driver de gráficos deve despejar texturas - mas se você carregar texturas demais, pode não haver memória suficiente para sua aplicação. Além disso, alguns

drivers de vídeo têm bugs importantes que se manifestam como começar a abordagem do limite de sua memória gráfica , causando estranhas renderização ou até mesmo falhas.

Por estas razões, pode ser útil para limitar a quantidade de memória gráfica seu aplicativo usa . Panda oferece várias ferramentas para ajudar com isso.

Automaticamente reduzindo texturas Você pode reduzir texturas automaticamente à medida que são carregados. A maneira mais fácil de fazer isso é colocar uma linha como:

texture-scale 0.5

em seu arquivo Config.prc . O exemplo acima todas as texturas escala por um fator de 0,5 em cada dimensão (para uma redução global de 1 / 4 do requisito de memória total). Se há determinadas texturas , que não devem ser escalados , texturas , por exemplo, GUI, você pode excluí-los com frases como :

exclude-texture-scale digits_*.pngexclude-texture-scale gui*.jpg

Ativando compressão de textura Outra possibilidade é a de habilitar e usar Texture Compression, Conforme descrito na próxima página . Se suportado pela sua placa gráfica, isto irá reduzir drasticamente os requisitos de memória de textura , para 04/01 ou 08/01 , do original . Existe alguma redução de qualidade, mas não tanto como a redução da qualidade que você deseja obter a partir de downscaling as texturas pelo montante equivalente. Também é possível ativar a compressão de textura em conjugação com o escalonamento de textura.

Limitar o uso de memória gráfica total Finalmente, pode ser prudente limitar a quantidade de memória gráfica que tenta usar o Panda , com uma linha como:

graphics-memory-limit 67108864

O exemplo acima impõe um limite de 64MB (64 * 1024 * 1024) na memória elementos gráficos que Panda tentará usar . Esta pode ser uma boa idéia para evitar a alocação de texturas fugitivo em cartões gráficos integrados sem limite de textura fixo, ou para contornar bugueiros gráficos que deixam de funcionar quando você usa muito. Panda vai automaticamente começar a descarregar texturas quando o limite especificado for excedido, mesmo se o driver de gráficos que permitem alocar mais .

Idealmente, seria ótimo para consultar a quantidade de memória gráfica útil fornecida pelo cartão, e definir este como o limite de memória , gráficos ,

infelizmente , isso é impraticável , por várias razões , incluindo as razões acima expostas . Normalmente, se você deseja que seu aplicativo para trabalhar em uma variedade de hardware, você terá que vir acima com um punhado de configurações padrão e permite ao usuário selecionar entre eles , de acordo com seu próprio conhecimento das capacidades de seu hardware.

Note que os gráficos -memory-limit é um novo recurso do Panda, e não está disponível em versões anteriores Panda3D 1.6.

uso de memória Acompanhamento Você pode ver quanta memória gráfica que você está consumindo realmente com o PStats ferramenta. Selecione a opção " A memória de gráficos "opção. Este gráfico mostra a quantidade de memória necessária para a tela ( ativos ) e inativos ( escondido ) texturas. Também inclui a memória requerida para buffers de vértice e índice , embora estes geralmente são muito menores do que os seus requisitos de memória de textura.

Panda3D Manual: Texture Compression

Você pode estar familiarizado com os formatos de arquivo de imagem como JPEG , que pode comprimir os dados de imagem dramática e fazer arquivos de imagem muito menor do que seria de outra forma , a troco de sacrificar um pouquinho a qualidade da imagem original.

compressão JPEG só se aplica para o tamanho da imagem em disco , no entanto. Uma vez que você carregar uma imagem de textura na memória, se ela veio de um JPEG , PNG, TGA ou arquivo , ele sempre pega a mesma quantidade de memória de textura na sua placa gráfica (baseada no tamanho da textura ).

Existe uma opção diferente , no entanto, para comprimir imagens de textura na memória. A maioria das placas gráficas modernas pode usar um punhado de tempo de execução de algoritmos de compressão para processar directamente a partir de uma textura que foi comprimido em memória. Isso é chamado de compressão DXT . Não é realmente muito parecido com compressão JPEG internamente , mas você pode pensar nisso da mesma forma . Ela tem algumas coisas em comum : ele reduz o tamanho da imagem dramaticamente (4 vezes ou até 8 vezes menor ), e sacrifica um pouco de qualidade de imagem.

Runtime compressão de textura

A maneira mais fácil de permitir imagens comprimidas textura é colocar o seguinte no seu arquivo Config.prc :

compressed-textures 1

Isso vai pedir o driver de gráficos para comprimir cada textura como ele carrega. Isso significa que ele tem um pouquinho mais de tempo para carregar cada textura, mas a textura resultante terá muito menos espaço na memória de textura.

Há uma vantagem importante para comprimir as texturas em tempo de execução da seguinte forma: o driver de gráficos será capaz de compactar todas as texturas usando qualquer algoritmo de compressão de textura entende , DXT ou não. Nem todas as placas gráficas suportam todos os algoritmos de compressão , assim que usar esta opção permite ao condutor escolher o melhor algoritmo que suporta. Se o driver de gráficos não suporta os algoritmos de compressão em tudo, ele simplesmente irá carregar as texturas uncompressed . De qualquer forma, sua aplicação ainda será executado e todas as suas texturas serão visíveis.

TXO formato de arquivo Panda tem um formato de arquivo nativo para o armazenamento de imagens de textura , chamado TXO ( a sigla é de " objeto de textura ). Isto é semelhante aos arquivos BAM. Um arquivo TXO contém todos os dados de textura da imagem em um formato muito semelhante à representação interna do Panda , de modo que ele carrega na memória muito rapidamente.

Mais importante , talvez , os arquivos podem opcionalmente armazenar TXO pré-comprimido imagens de textura . Você pode usar o comando:

egg2bam -txo -ctex model.egg -o model.bam

converter o modelo para um arquivo de BAM, e todos os seus arquivos de texturas para TXO , com os dados da imagem pré-comprimido dentro do TXO arquivo para que ele não precisa ser compactado em tempo de execução posterior. (Você pode precisar especificar " pandagl "em vez de " pandadx9 "como motor de renderização quando você executar o comando egg2bam - no momento da redação deste texto , não havia problemas com o uso da Panda DirectX driver em modo offline como este. Todavia, os arquivos resultantes TXO carga sobre o OpenGL ou DirectX em tempo de execução ).

TXO arquivos têm os mesmos inconvenientes como arquivos BAM : eles estão vinculados a uma determinada versão do Panda , de modo que você pode precisar de regenerá-los quando você vem actualizar a sua versão Panda.

A maior desvantagem para o armazenamento de imagens pré-comprimido textura desta maneira é que seu aplicativo pode não funcionar em todas as placas gráficas . Nem todas as placas gráficas suportam todos os tipos de compressão DXT, e se você tentar carregar um arquivo TXO que uma placa gráfica não entende , simplesmente não serão carregados. Assim, o pré- comprimir todas as suas texturas pode tornar o aplicativo mais portátil.

DDS arquivo de formato Além de nativos Panda TXO formato de arquivo , existe um formato razoavelmente padrão chamado DDS , que tem algumas das mesmas propriedades de TXO . Como TXO , você pode armazenar pré- imagens compactadas em um arquivo DDS. A maior vantagem do formato de arquivo DDS é que já existem várias ferramentas disponíveis na internet para gerar arquivos DDS , incluindo plugins GIMP e Photoshop. (Note, no entanto, que carregar arquivos DDS é um novo recurso do Panda, e esses arquivos não são suportados nas versões antes Panda 1.6. )

Gerar seus próprios arquivos DDS tem várias vantagens, o principal deles é que você tem controle completo sobre os artefatos de compressão de sua textura. No entanto, tem as questões de portabilidade mesmo que o armazenamento de imagens de textura pré- compactados em arquivos TXO : existe a possibilidade de algumas placas gráficas não suportam a compressão de textura que você usou , caso em que ele simplesmente não irá carregar.

Textura cache Existe um compromisso entre compressão dinâmica e pré- comprimido texturas : você pode pedir Panda para comprimir texturas em tempo real, e salve a imagem resultante comprimido para um TXO arquivo no disco. A próxima vez que você carregar a textura particular, ele irá carregar rapidamente a partir de seu arquivo TXO . Desde que o arquivo foi gerado por TXO driver do usuário gráfica, será presumivelmente o uso de um algoritmo de compressão suportados.

Para ativar esse recurso , basta inserir as seguintes linhas no seu arquivo Config.prc :

compressed-textures 1model-cache-dir /c/temp/panda-cachemodel-cache-compressed-textures 1

Onde o modelo cache - dir especifica qualquer pasta no disco (que será criado se não existir). Note que o modelo cache -dir já pode ser especificado , o padrão de distribuição de Panda especifica um modelo de cache para acelerar o carregamento de arquivos BAM.

DDS como formato de arquivo , a variável de modelo cache -comprimido , texturas é um novo recurso no Panda, e não está disponível em versões anteriores à 1.6.