EXTRUDE:

le agrega volumen en una dirección, responde a parametros

se puede aplicar en splines, de esta manera el splines obtiene volumen y es renderizable

*también es aplicable en textos.

BEVEL:

este modificador, trabaja muy parecido a EXTRUDE, pero con la diferencia que nos permite agregar un bisel

en sus parametros, podemos aplicar 3 niveles de bevel rápidamente.

dentro de las opciones de bevel, cada level esta compuesto por dos parámetros:

HEIGH- indica la profundidad del nivel

OUTLINE – indica cuanto de biselado tendrá este nivel

*nota: la función de KEEP LINES FROM CROSSING evita los cruces de geometría, corrigiendolos defectos que generan ciertas líneas.

Neste tutorial mostrarei como aplicar modificadores a objetos paramétricos e modelar objetos editáveis, as maiores ferramentas para criação de modelos complexos, e para seguir este tutorial com sucesso precisará de um conhecimento básico do 3D Studio, pode encontrar aqui. No 3D Studio Max 2009 existem dois tipos de objeto. Existe o objeto paramétrico e o editável. O paramétrico é um objeto para o qual podem ser passados parâmetros para especificar altura, tamanho, etc… Os modificadores só podem ser aplicados a objetos paramétricos. Um objeto editável, por outro lado, não pode receber esses parâmetros e nem modificadores podem ser aplicados a esse tipo. Então o que podemos fazer com objetos editáveis? Os objetos editáveis podem ser modelados, uma solução muito flexível. Abaixo podemos ver um cilindro editável com alguns segmentos a mais sendo editado.

MODIFICANDO OBJETOS PARAMÉTRICOS

As primitivas do 3D Studio são por default paramétricas. Podemos aplicar modificadores nessas primitivas no painel Modify. Não vou explicar os modificadores aqui, porque são muitos, e isso resultaria em um tutorial muito grande, e depois você pode conhecer os outros modificadores você mesmo. Para este tutorial vamos criar uma cadeia de DNA.

1. Crie a primitiva Plane no painel Create.
2. Vá ao painel Modify e preencha o parâmetro Length Segs para 11, Width Segs para 1, Length para 300 e Width para 60.
3. No topo do painel Modify há um Rollout chamado Modifier List. Nessa lista estão os modificadores que vamos aplicar. Clique nesse rollout e no Modificador Lattice.
4. Marque a Radio Box Icosa nos parâmetros do modificador Lattice na categoria Joints e digite 6 nos segmentos.
5. Clique novamente na Modifier List e selecione Twist.
6. No parâmetro Angle do Twist digite 360 e marque a Radio Box Y na categoria Twist Axis.
7. Agora nós temos algo muito semelhante com uma cadeia de DNA, mas você deve ter notado que as juntas ficaram meio achatadas. Para corrigir isso arraste o modificador Twist para baixo de Lattice.
8. Renderize a cena clicando no botão Render e temos uma cadeia de DNA pronta!

COMO ISSO FOI FEITO?

Você pode estar se perguntando pra que foram necessários todos aqueles passos. Os ajustes dos segmentos do Plane foram necessários para criar as juntas certas quando o modificador lattice fosse aplicado. O Lattice transformou os segmentos em cilindros e suas extremidades em juntas para dar ao Cilindro uma aparência de DNA, e os ajustes em seus parâmetros foram usados para transformar as juntas em esferas, como nas gravuras de DNA. Enfim, o Twist foi usado para girar o DNA em 360 graus.

MODELANDO OBJETOS EDITÁVEIS

Existem vários tipos de objetos editáveis. Neste tutorial usarei Editable Poly. Antes de começar devo explicaro uso do Soft Selection. Vamos criar algumas montanhas em um Plane agora.

1. Crie um objeto Plane(não muito pequeno) e no parâmetro Width Segs digite 12 e em Length Segs também.
2. Clique com o botão direito nesse objeto e depois em Convert To -> Editable Poly.
3. Vá ao Painel Modify e clique no botão de mais a esquerda de Editable Poly.
4. Selecione o subojeto Vertex.
5. Selecione qualquer um dos pontos que aparecem sobre o plano e você poderá escalá-lo, girá-lo, mudar sua posição e até deletá-lo! Tudo isso usando as ferramentas básicas de Scale, Rotate e Move, mas antes de começar a modificá-lo devo informar da ferramenta Soft Selection. Essa ferramenta permite uma transformação menos abrupta das vértices de um objeto editável. Para usá-la marque a checkbox Use Soft Selection. Abaixo dessa checkbox haverão valores de Fallof e Pinch para declarar quanto outras vértices serão afetadas. Divirta-se!

A cena renderizada deve ter ficado pelo menos um pouco parecida com isso:

Estou quase abrindo uma série JAVA X PHP neste weblog!

Depois da aula de ontem fiquei ainda mais curioso sobre o tratamento de memória dessas duas linguagens. Se já não bastasse a diferença que existe com relação ao tratamento de tipo e o retorno que os scripts dão para os ternários, ontem vimos como elas atribuem valores para os atributos das classes.

EM JAVA

Criamos 3 arquivos

• Pessoa.java :: classe que possui os atributos de uma Pessoa;
• Parametros.java :: classe que tem dois metodos. Um que muda o valor de uma variavel x e outra que muda o atributo nome da classe Pessoa;
• Teste.java :: classe que tenta modificar o valor de x, de y e do nome da Pessoa.

Pessoa .java

class Pessoa {
int id;
String nome;
}

Parametros.java

class Parametros {
int mudarInt (int x) {
x = 7;
return 10;
};

void mudarNome (Pessoa p) {
p.nome = “Joao”;
}
}

Teste.java

class Teste {
public static void main (String [] args) {
int x = 4;

Parametros p = new Parametros();

int y = p.mudarInt(x);

Pessoa pes = new Pessoa();
pes.nome = “Jose”;

p.mudarNome(pes);

System.out.println(“X = “+x);
System.out.println(“Y = “+y);
System.out.println(“P.NOME = “+pes.nome);

}
}

Ao compilar Teste.java temos como retorno:

E:\xampp\htdocs\testes\parametrizacao> java Teste
X = 4
Y = 10
P.NOME = Joao
Process java exited with code 0

Isso acontece porque X é uma variavel local em ambos os casos. Dentro de Teste ele está no escopo da classe e dentro de Parametros, está no escopo do método mudarInt. Este método retorna o valor 10, que é atribuído a variável Y, logo X permanecerá com valor 4 dentro do escopo de Teste e Y recebeu 10 do método mudar Int.

A grande sacada está no valor do atributo “nome” da classe Pessoa…

Quando estamos trabalhando com atribuição das classes em Java, o que acontece é uma cópia do valor da variável que referencia um objeto. Isso nos leva a entender que o trabalho de troca de valores dos atributos dentro de uma classe para esse objeto copiado está sempre se referindo ao mesmo objeto.

Tivemos como exemplo os correios.

Você pode mandar duas cartas para o mesmo endereço. O endereço em questão é a referência para o seu objeto. Duas cartas (comandos) referenciando (destinatário para o endereço de referência) o mesmo objeto.

Como a última ação foi mudar o valor de nome do objeto único que foi criado e referenciado para ‘João’, este irá fixar e devolver o valor citado.

Diferentemente do que acontece com o PHP.

O PHP não cria cópias de referências, portanto a cada atribuição de referências dentro de um método, uma nova instância será criada. Dá pra imaginar que o valor do atributo nome da classe Pessoa na primeira referência será ‘José’ e na segunda referência será ‘João’. Ao chamar o valor do atributo ele devolverá ‘José’, pois o objeto chamado está na primeira referência, enquanto que a segunda existe apenas dentro do escopo do método e será eliminado da memória pelo interpretador.

Vamos fazer o teste?

EM PHP

criamos igualmente 3 arquivos:

• Pessoa.class.php :: classe que possui os atributos de uma Pessoa;
• Parametros.class.php :: classe que tem dois metodos. Um que muda o valor de uma variavel x e outra que muda o atributo nome da classe Pessoa;
• Teste.class.php :: classe que tenta modificar o valor de x, de y e do nome da Pessoa.

Pessoa.class.php

class Pessoa{
var $id;
var $nome;

/** setters and getters para atributo ID */
public function setID($id) {
$this->id = $id;
}
public function getID() {
return $this->id;
}

/** setters and getters para atributo NOME */
public function setNome($nome) {
$this->nome = $nome;
}
public function getNome() {
return $this->nome;
}
}

Parametros.class.php

class Parametros {
public function mudarInt($x) {
$x = 7;
return 10;
}

public function mudarNome($objeto, $nome) {
$objetoPessoa = $objeto;
$objetoPessoa->setNome = $nome;
}
}

Teste.class.php

/** inclui as classes auxiliares para a classe Teste */
require_once(“Pessoa.class.php”);
require_once(“Parametros.class.php”);

class Teste {
public function __construct(){
$x = 4;

$p = new Parametros();
$pes = new Pessoa();

$y = $p->mudarInt($x);

$pes->setNome(“Jose”);

$p->mudarNome($pes, “Joao”);

$saida = “X = “.$x.”<br />Y = “.$y.”<br />PES::NOME = “.$pes->getNome().”<hr>”;

echo $saida;
}
}

$teste = new Teste();

Ao interpretar a classe Teste.class.php temos como retorno:

X = 4
Y = 10
PES::NOME = Jose

Muito interessante, porém creio que o tratamento de objetos em Java tem menos gambiarras e a lógica de copiar referências deveria ser adotada como padrão para qualquer linguagem de programação. Vamos esperar as próximas versões do PHP pra ver o que acontece.

um abraço ao visitante

Diogo Besson

Hoy querría hablar de los modificadores de acceso que disponemos en .net cuando nos disponemos a definir nuestras clases. Como siempre pondremos un ejemplo para abordar el tema.

Primero enumeramos los distintos modificadores:

Información obtenida de Msdn: http://msdn.microsoft.com/es-es/library/ba0a1yw2(VS.80).aspx

Las clases definidas sin estar contenidas dentro de otras, es decir, definidas dentro de un namespace solo podrán utilizar los modificadores public e internal.

Las clases definidas como public serán instanciables desde cualquier otra clase o proyecto. En el ejemplo: OtraClase.

Internal restringe la visibilidad de una clase a aquellas que se encuentran en el mismo ensamblado o proyecto desde la que se desea instanciar. En el ejemplo: la clase B es interna del proyecto ClasesModificadores con lo que no se puede instanciar desde el proyecto Modificadores.

Por otro lado, como sabemos, dentro de una clase podemos definir a su vez nuevas clases. En este caso tendremos disponibles todos los modificadores. En el ejemplo: ClasesAnidadas.

El modificador private obliga a usar la clase dentro de la clase en la que está definido.

Protected amplia la restricción de private permitiendo usar la clase en aquellas que hereden de la contenedora.

Por último protected internal combina las dos definidas anteriormente.

Y como siempre para verlo mas clarito, usemos el ejemplo que os dejo a continuación.

 Enlace para descargar el código del ejemplo: modificadores (renombrar el archivo a .zip y descomprimir).

Espero que os sirva.

Salu2, Guillermo.

Para expor o estado interno dos objetos ao mundo exterior, algumas linguagens se valem de um conceito chamado propriedade. Vou começar falando das linguagens que não tem propriedades como o Java. Estas linguagens consideram que as variáveis e constantes tem propósito apenas interno, apesar de poderem ser declaradas como públicas. Caso caiamos na tentação de usá-las como membros públicos para simplificar e desburocratizar a programação, compramos uma dor-de-cabeça futura.

O problema nesta abordagem é que quebrarmos o encapsulamento, expondo o interior do objeto como ele realmente é. Assim, se a representação interna mudar, obrigatoriamente, os clientes externos vão ser afetados. Isso é o indesejado alto acomplamento que propaga as alterações e amarra os objetos, reduzindo o reuso. Também temos o problema de não podermos controlar a atribuição, fazendo validações. Assim, podemos ter aluno.nota = 11 ! Outra possibilidade é engessar a classe. A própria Sun cometeu uma gafe ao criar a classe java.awt.Rectangle com campos públicos. Daí, depois não pôde evitar que façamos um rect.height = -100, que é bastante esquisito ! O retângulo é tão baixo que o topo está abaixo da base ?!?! E se ela os transformasse em campos privados quebrando a compatibilidade ? Já pensou ter que pedir para os usuários não fazerem upgrade de jvm porque senão o programa não vai mais rodar ? Por causa disso, espalhamos uma porção de getters e setters pelo código da classe por pura burocracia. O Java herdou essa filosofia do C++.

O conceito de propriedades não é nada novo, nem revolucionário. O velho Delphi já tinha propriedades. Para não mexer com a poeira do fundo do baú, vamos deixar o Delphi de lado e ver como o Scala expõe o estado interno sem burocracia e com escalabilidade: “Tornar o simples fácil e o difícil possível”.

Suponha o mesmo caso da classe Rectangle. Vejamos como ficaria a classe com a suposta quebra de encapsulamento:

class Rectangle {
   var x, y, width, height: Int
}

val rect = new Rectangle
rect.height = -100

Então, percebido o erro depois de esta classe estar sendo usada em vários programas, precisamos corrigi-lo. Felizmente, Scala tem um mecanismo sofisticado para permitirmos interferir na leitura e gravação da variável, sem alterar o uso externo da mesma. Vejamos como ficaria:

Class Rectangle {
    var x = 0
    var y = 0
    private var pwidth = 0
    private var pheight = 0

    def width_=(arg: Int) {
      if (arg < 0) throw new IllegalStateException("width não pode ser menor que zero" )
      pwidth = arg
    }
    def width = pwidth

    def height_=(arg: Int) {
      if (arg < 0) throw new IllegalStateException("height não pode ser menor que zero" )
      pheight = arg
    }
    def height = pheight
  }

val rect = new Rectangle
rect.height = -100  // Causa uma IllegalArgumentException

Assim, ganhamos o controle quando precisarmos, garantindo a manutenção da interface externa da classe para os clientes dela. É admissível que x e y possam receber valores negativos por estarem à esquerda do eixo y ou abaixo do eixo x. Assim, não precisamos da burocracia e poluição de getters e setters pobres desnecessários mas requeridos nas linguagens que não tem propriedades.

Bonus track

Por baixo dos panos, no bytecode, na verdade todos os campos ficam privados e têm os métodos de leitura e escrita.Vejam como ficou a classe Rectangle “descompilada” (sem implementação) para Java:

public class scalaintegration.Rectangle
   extends java.lang.Object implements scala.ScalaObject{
 private int pheight;
 private int pwidth;
 private int y;
 private int x;
 public scalaintegration.Rectangle();
 public int height();
 public void height_$eq(int);
 public int width();
 public void width_$eq(int);
 private void pheight_$eq(int);
 private int pheight();
 private void pwidth_$eq(int);
 private int pwidth();
 public void y_$eq(int);
 public int y();
 public void x_$eq(int);
 public int x();
 public int $tag();
 }

Alexei Barbosa de Aguiar