ENGINE 3D openGL, ancora ombre

nuova immagine del l'engine 3D che sto realizando... (dopo 2 settimane ci rimetto le mani sopra XD)

rispetto al vecchio codicce ho corretto dei errori riguardanti l'estrusione della mesh, rispetto alla luce ...
inoltre ora è strutturato in modo che tutte le mesh possano proiettare lombra....
inoltre volendo ci possono essere vare sorgenti di luce :

SQLite e JAVA

Per semplificare l'interfaccia tra SQLite e Java ho scritto una piccola libreria composta da 3 classi:

-GetSQLDriver

-SQLib

-SQLEasy

Documentazione:

//libreria carica driver SQL

GetSQLDriver:

il metodo load carica il driver SQL

   driver= cartella dove si trova il driver (default="org.sqlite.JDBC")

  

   public static void load(String driver="org.sqlite.JDBC");

//Libreria gestione Database

SQLib:

il costruttore

   name=indicato il data base da caricare

   public SQLlib(String name);

metodo che chiude il database

   public void SQLClose();

metodo per modificare il db con istruzioni SQLite

   ed=comando SQLite

   public void addMod(String ed);

motodo che restituisce un dato dal DB, la natura del dato va specificata in SQLite

  ed=comando SQLite

  ResultSet= lista valori restituiti

  public ResultSet getMod(String ed)

//Libreria gestione Database, semplificata

SQLEasy:

il costruttore

   name=indicato il data base da caricare

   public SQLEasy(String name);

metodo che chiude il database

   public void SQLClose();

metodo per modificare il db con istruzioni SQLite

   ed=comando SQLite

   public void addMod(String ed);

motodo che restituisce un dato dal DB, la natura del dato va specificata in SQLite

  ed=comando SQLite

  ResultSet= lista valori restituiti

  public ResultSet getMod(String ed)

motodo veloce per creare una tabella

    a=nome tabella

    b=attributi tabella (in SQLite)

    public void crateTable(String a,String b);

motodo veloce per inserire i dati in una tabella

    a=nome tabella

    b=valori da inserire nella tabella (in SQLite)

    public void putValues(String a,String b);

motodo veloce per eliminare una tabella

    a=nome tabella

    public void deleteTable(String a);

motodo veloce per eliminare una riga

    a=nome tabella

    b=caratteristiche che ha il records da eliminare (in SQLite)

    public void deleteRecords(String a,String b);

motodo veloce per conoscere i dati di una tabella

    nTabella=nome della tabella

    nColonne[]=array contenente i nomi delle colonne

    records=valore boolean

         -true verrà restituita una array a due dimenzioni

               dove la prima indicherà il records ed la seconda i dati in esso contenuti

         -false verrà restituita una array a due dimenzioni

               dove la prima indicherà la colonna ed la seconda i dati in essa contenuti

    public String[][] getArrayFrom(String nTabella,String[] nColonne,boolean records=true)

Esempio:

//importo le classi per gestire SQLite

import java.sql.*;

class DbTest{

public DbTest (){

  GetSQLDriver.load(); // carico il driver

  SQLEasy test1=new SQLEasy("Test1.db"); // carico db

  //creo la tabella ed immetto i valori in essa

  test1.crateTable(“tab1”,”id int, nome char[250] ”);

  test1.putValues(“tab1”,”0,’ciao0’ ”);

  test1.putValues(“tab1”,”1,’ciao1’ ”);

  test1.putValues(“tab1”,”2,’ciao2’ ”);

 

  String[] t={“id”,”nome”};

   //stampo (tipo righe)

  printArrayRecords(

                                test1.getArrayFrom("uno",h),”Numero | Nome” ," | ","----------");

                                 );

  //cancello la riga 1

  test1.deleteRecords(“tab1”,”id=1”);

   //stampo (tipo colonne)

  printArrayColonne (

                                test1.getArrayFrom("uno",h,false),”Numero | Nome” ," | ","----------");

                                 );

  //cancella la tabella

  public void deleteTable(“tab1”);

  //chiudo il database

  test1.SQLClose()

}

public static void main(String[] args){

new DbTest();

}

 public void printArrayRecords(String[][] array,String x,String sv,String so){

    if(array!=null){

    System.out.println(x);

        for(int j=0;j<array.length;j++){

          for(int i=0;i<array[j].length;i++){ 

            System.out.print(array[j][i]+sv);

           }

          System.out.println("");

          System.out.println(so);

        }  

        }

    }

 

  DbTest

  public void printArrayColonne(String[][] array,String x,String sv,String so){

    if(array!=null){

    System.out.println(x);

        for(int j=0;j<array[0].length;j++){

          for(int i=0;i<array.length;i++){ 

            System.out.print(array[i][j]+sv);

           }

          System.out.println("");

          System.out.println(so);

        }  

        }

    }

}

STRUTTURA DATA BASE

Ecco a lei professore la struttura del database creata da pampanelli andrea e me

COMPITI

Ecco i copiti da lei ass.
perfavore se può controlli il 9... che molto probabilmente è sbagliato...

ESERCIZIO 13 pag233

Materiali (Codice, Descrizione, Fornitore, Prezzo, IndirizzoFornitore, Quantità, PosizioneInMagazzino, Acciaio, NomeAcciaio, ResistenzaAcciaio, NomeFornitore)

Dipendenze

Acciaio -->(NomeAcciaio, ResistenzaAcciaio) //2rN

NomeAcciaio --> ResistenzaAcciaio //3rN

Acciaio --> ResistenzaAcciaio (transitiva) //3rN

Fornitore --> (IndirizzoFornitore, NomeFornitore) //2rN

Tabelle

Acciaio(Acciaio, NomeAcciaio) //2rN e 3fN

TipoAcciao(NomeAcciaio, ResistenzaAcciaio) //3fN

Fornitore (Fornitore, IndirizzoFornitore, NomeFornitore) //2rN

Materiali(Codice, Descrizione, Prezzo, IndirizzoFornitore,

Quantità, PosizioneInMagazzino, Acciaio, Fornitore) //2rN

ESERCIZIO 12 pag233

Scrivo la tabella di base:

Libro (CodiceDelLibro, NomeAutore, TitoloLibro, NomeEditore, IndirizzoEditore, Prezzo, AnnoEdizione)

Determino la chiave primaria:

Libro (CodiceDelLibro, NomeAutore, TitoloLibro, NomeEditore, IndirizzoEditore, Prezzo, AnnoEdizione)

Normalizzazione:

1fN:

Non vi sono dati ripetuti.

2fN:

Trovo dipendenze:

IndirizzoEditore --> nomeEditore

//siccome l’indirizzo può avere solo un editore, quindi solo quel nome, ed l’indirizzo è un dato univoco, mentre possono esistere editori con nomi uguali

3fN:

non ci sono dipendenze transitive

tabelle finali

Editore(IndirizzoEditore, nomeEditore)

Libro (CodiceDelLibro, NomeAutore, TitoloLibro, Prezzo, Anno Edizione, IndirizzoEditore)

Esercizio 11 pag233

//////////////

Tabella 1:

Esami1(Corso, Matricola, Data, Voto, NomeCorso)

Dipendenze:

(Matricola, Corso) --> Voto

Corso --> NomeCorso

Tabelle:

Corso(Corso, NomeCorso)

Matricola(Matricola, Corso, Voto)

Esami1(Corso, Matricola, Data)

///////////////

Tabella 2:

Esami2(Corso, Matricola, Data, VotoInCifre, VotoInLettere)

Dipendenze:

( Matricola, Corso )-->(VotoInCifre, VotoInLettere)

Proprietà transitiva:

VotoInCifre --> VotoInLettere

VotoInLettere --> VotoInCifre

( Matricola, Corso ) --> VotoInLettere

( Matricola, Corso ) --> VotoInCifre

Per togliere la 3° forma normale, siccome VotoInCifre e VotoInLettere possono essere sia determinanti che determinate, scelgo come determinante VotoInCifre

Tebelle :

Matricola(Matricola, Corso, VotoInCifre)

VotoCifre(VotoInCifre, VotoInLettere)

Esami2(Corso, Matricola, Data)

ESERCIZIO 10 pag233

Anagrafica (Nome, Cognome, Matricola, Nascita, Indirizzo, CodiceDipartimento, NomeDipartimento, IndirizzoDipartimento, Stipendio)

Dipendenze:

CodiceDipartimento --> (NomeDipartimento, IndirizzoDipartimento)

Tabelle:

Dipartimento(codiceDipartimento, NomeDipartimento, IndirizzoDipartimento)

Anagrafica (Matricola , Nome, Cognome, Nascita, Indirizzo, CodiceDipartimento)

ESERCIZIO 9 pag233

Tabella1(NomeStudente, DataDiNascitaStudente, indirizzoStudente, numeroTelefonicoStudente, viaStudente, numeroCivicoStudente, cittaResidenzaStudente, cittaDiNascitaStudente, VotoMateria1, VotoMateria2, VotoMateria3, VotoMateria4, VotoMateria5, VotoMateria6, VotoMateria7, VotoMateria8, VotoMateria9)

Tabella:

Tabella1(NomeStudente, DataDiNascitaStudente, indirizzoStudente, numeroTelefonicoStudente, viaStudente, numeroCivicoStudente, cittaResidenzaStudente, cittaDiNascitaStudente, VotoMateria1, VotoMateria2, VotoMateria3, VotoMateria4, VotoMateria5, VotoMateria6, VotoMateria7, VotoMateria8, VotoMateria9)

1,2 Normalizazione

Studente(NomeStudente, DataDiNascitaStudente, indirizzoStudente, numeroTelefonicoStudente, viaStudente, numeroCivicoStudente, cittaResidenzaStudente, cittaDiNascitaStudente, Materia_id )

Materia(id, VotoMateria1, VotoMateria2, VotoMateria3, VotoMateria4, VotoMateria5, VotoMateria6, VotoMateria7, VotoMateria8, VotoMateria9)

Oppure:

Tabella:

abbiamo 2 entità materia e voti: quindi 2 tabelle

associate Molti a Molti

Studente(NomeStudente, DataDiNascitaStudente, indirizzoStudente, numeroTelefonicoStudente, viaStudente, numeroCivicoStudente, cittaResidenzaStudente, cittaDiNascitaStudente)

Materia(nomeMateria,votoMateria)

Associazioni:

Valutato(nomeMateria, NomeStudente, DataDiNascitaStudente, indirizzoStudente, numeroCivicoStudente )

Studente(NomeStudente, DataDiNascitaStudente, indirizzoStudente, numeroTelefonicoStudente, viaStudente, numeroCivicoStudente, cittaResidenzaStudente, cittaDiNascitaStudente)

Materia(nomeMateria,votoMateria)

ENGINE 3D openGL

da ormai un paio di settimane sto lavorando ad un progetto, un ENGINE3D!!

poi spiegherò cosa è un engine 3D ma per il momento... posto solo un immagine


E' scritto in c++ ed usa le librerie openGL e win32!

concetti di base r. d.b. versione immagine

Per un aspetto migliore ho preferito stampare la mia versione word:

concetti di base per la realizzazione di un data base:

----------------------------------------------------------------------------------------------
Tabella è definita RELAZIONALE IN FOMRA 1nF (prima forma normale/lizzata)
quando rispetta le seguenti caratteristiche:

1° Le righe devono contenere le istanze dell’entità
2° Le colonne devono contenere gli attributi dell’entità
3° Non è importante l’orine delle righe
4° Non è importante l’ordine delle colonne
5° Tutte le celle devono contenere dati del medesimo tipo (omogenei)
6° Non possono esistere due righe uguali
7° Ogni cella deve contenere un solo valore
8° Ogni colonna deve avere un nome univoco

----------------------------------------------------------------------------------------------
Le regole di derivazione

1) la prima regola di derivazione dice che:

ad ogni entità corrisponde una tabella
ad ogni riga corrisponde un istanza dell'entità
ad ogni colonna corrisponde un attributo dell'entità
la chiave primaria è una o più colonne

2) la seconda regola di derivazione dice:

la relazione 1 a M (uno a molti) si risolve mettendo la chiave esterna,
cioè la chiave primaria della tabella che corrisponde all'1,
nella tabella appartenente al ruolo di molti.

3) la terza regola di derivazione dice che:

nella associazione M a N (molti a molti)
si ha una tabella associativa formata da chiavi esterne delle entità(/tabelle) associate,
che insieme formano la sua chiave primaria della tabella associativa.

4) la quarta regola di derivazione dice:

la relazione tra un entità forte ed un entità debole si risolve mettendo la chiave esterna,
cioè la chiave primaria della tabella/entità forte,
nella tabella/entità debole, ed insieme della chiave debole di quest’ultima entità
formano la chiave primaria della tabella dell'entità debole.

----------------------------------------------------------------------------------------------
In più:

CHIAVE ESTERNA-->è il dato che ci permette di risalire l'istanza di un altra tabella a cui è associata

Casi speciali:
Nella associazione 1 a 1, la chiave esterna va messa in una tabella, a libera scelta
Nella associazione 1(non tutti) a 1(tutti) la chiave esterna va su quella che ha tutte le istanza associate
Nella associazione 1(tutti) a 1(tutti) la chiave esterna va messa in una tabella, a libera scelta


----------------------------------------------------------------------------------------------
La Normalizzazione in breve:
Dopo aver trasformato il proprio schema concettuale in un database vero e proprio utilizzando le regole di derivazione, si passa ad normalizzare questo database:
Per normalizzazione si intende: Scovare le dipendenze funzionali, e trasitive, tra i vari attributi, e creare per esse delle tabelle separate.

----------------------------------------------------------------------------------------------
DIPENDENZA FUNZIONALE:
quando una variabile/attributo, dipende da un'altro attributo, e ne può determinare il valore.
(Tra gli attributi quindi vie è qualche tipo di relazione)

nomeOggetto-->coloreOggetto

il determinante è l’attributo che si trova a sinistra.
Si possono avare più determinanti, e più valori determinati:

(nomePersona; CognomePersona)-->codiceFiscale
nome Persona, cognome Persona determinano il codice Fiscale
(ed il codiceFiscale ha una dipendenza funzionale con nomePersona, cognome Persona)

nomeOggetto-->(coloreOggetto; formaOggetto)
nomeOggetto determina coloreOggetto e formaOggetto
(ed il coloreOggetto e formaOggetto hanno una dipendenza funzionale con nomeOggetto)

----------------------------------------------------------------------------------------------
DIPENDENZA TRANSITIVA: quando una variabile determina un'altra ed quando questultima ne determina un'altra ancora (e cosi via)

a-->b
b ha una dipendenza funzionale con a

b-->c
c ha una dipendenza funzionale con b

a-->b-->c
c ha una dipendenza funzionale con b che a sua volta ha una dipendenza funzionale con a
----------------------------------------------------------------------------------------------




----------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------
Esempio:

Ipotizziamo che ci sia solo un autore per disco (per semplificare)

----------------------------------------------------------------------------------------------
(prima parte) (prima regola)

Casadiscografica( nome ; amministratore)
Discho( nome; nomeAutore; cognomeAutore; numeroTracce)

----------------------------------------------------------------------------------------------
Poi: (derivazione seconda parte) (seconda regola)

Casadiscografica( nome; amministratore)
Discho( nome; nomeAutore; cognomeAutore; numeroTracce; nome_Casadiscografica)

----------------------------------------------------------------------------------------------
Normalizzata:

C’è una relazione funzionale:
nomeAutore-->cognomeAutore

per essa creiamo una tabella a parte:
Autore( id; nomeAutore, cognomeAutore)

n.b. il determinante (nomeAutore), o anche cognomeAutore, o la chiave composta tra i due, non è consigliata come chiave primari siccome ci potrebbero essere casi di omonimia.

E la relazioniamo con la tabella Discho
(di fatto abbiamo una sorta di relazione 1 a 1, totale da entrambe le tabelle/entità
(anche se in realtà non è proprio cosi, però ricordiamo che inizialmente abbiamo ipotizzato un solo autore per disco ))

Risultato:
Casadiscografica( nome; amministratore)
Autore( id; nomeAutore, cognomeAutore)
Discho( nome; numeroTracce; id_Autore; nome_Casadiscografica)
----------------------------------------------------------------------------------------------

COMPITI

Ecco l'esercizi datici da lei prof .:

Cubes Game

Il gioco non è finto; ancora, ma aleno sono riuscito a collegare i due cellulare ed a far muovere i cubetti.


(p.s. c'è un errore, e cioé il Thread addetto ad l'invio dei dati è lo stesso che che aspetta la ricezione , di conseguenza solo quando uno muove il suo cubetto si aggiorna la posizione del cubetto nemico)

ciao notte a tutti xD!!! 

(edit: il problema è stato aggirato mettendo nel loop, sia l'invio dei dati che la ricezione... )

SUPER DIBI GAME

Ispirato dalla frase del Dr. Vel., "tutto fa brodo"

Oggi ho deciso ... di pubblicare un mio piccolo progetto .. che sto portando avanti da qualche settimana... tra una domenica e l'altra.... 

Ed ecco la struttura del engine grafico 2D + qualcosina del gioco

Metodo per invertire i caratteri

Punto focale dell'ultimo compito:

public String invertiLettere(String s){
int l=s.length();
char[] c=new char[l];
char[] c1=new char[l];
c=s.toCharArray();
for(int i=0;i MINORE l;i++){
c1[i]=c[(s.length()-1)-i];
}
return new String(c1);
}


sotto MINORE mettere l'operatore logico, corrispondente (blogspot).

Progetto Informatica : Quiz Capitali

Programma in esecuzione:

Struttura:

Componenti gruppo:

   Gabriele Di Bari – capo gruppo
   Stefano Ceccarini
   Stefano Biscarini
   Alessandro Favilli
   Michele Baldassarri

Obiettivo del Progetto:

Realizzare un programma, simile ad un quiz e che funzioni nel seguente modo: Nella schermata del gioco dovrà essere presente un’immagine della capitale di cui si dovrà indovinare il nome,seguito dal nome della nazione, poi ancora, uno spazio in cui l’utente inserirà la risposta ed infine eventuali bottoni per iniziare, andare avanti e finire il gioco.

Suddivisione dei compiti:

• Gabriele Di Bari: Programmatore, leder gruppo, addetto alla suddivisione del lavoro all’interno del gruppo, aiutante per la documentazione.

• Michele Baldassarri: Documentazione e redattore della relazione.

• Stefano Ceccarini: Addetto alla creazione del data base, ha suddiviso i compiti per tale realizzazione.

• 
  Favilli Alessandro: Addetto alla ricerca immagini, ed supporto per la realizzazione del data base.
  

• Stefano biscarini: Ricerca immagini per il data base.

Tempo di realizzazione:

  Programmazione: 7 ore (circa).
  Creazione data base: 4 ore (circa).
  Documentazione: 6 ore (circa).

PDF. con codice sorgente

Calcolatrice

Dopo una giornata di lavoro, sono riuscito a finire la calcolatrice, sulle 500 righe di codice, Purtroppo non rispetta le specifiche richieste siccome, non avevo capito che doveva essere a 2 Display, in realtà utilizzare un solo Display è risultato molto più complicato del previsto, gestire i dati inseriti dall’utente è molto più difficile e complicato, ma credo proprio di esserci riuscito

Con questa calcolatrice si possono fare, moltiplicazione, divisione, sottrazione, divisione, elevare un numero ad una certa potenza (scelta dall’utente), e la radice quadrata ed il reciproco, il funzionamento è identico alla calcolatrice di windows, e cioè premendo ad esempio
1*2*3 al 2 viene stampato il risultato, idem per le altre operazioni, in oltre con l’uguale premendolo una volta si ha il risultato, ripremendolo si ripete la stessa operazione
Inoltre come richiesto dal professore di laboratorio ho inserito una “tabella” numerica per inserire i dati, ma volendo si può usare anche la tastiera normale. Ed ho tolto la possibilità all’utente di inserire lettere nel campo Text (da me chiamato rArea1).

Bene ora che mi sono letteralmente fuso il cervello, credo che spengerò immediatamente il pc, la saluto prof. Nata.

http://rapidshare.com/files/195648861/Calcolatrice.java.html

Compito test

Dopo aver provato la versione matematica ho lasciato perdere XD

intanto pubblico la versione funzionante che ho fatto in 10 minuti l'altro ieri XD




























Ecco la versione malforme che non funge... XD

http://rapidshare.com/files/187251270/RecInt.java.html

Tanti quadrati

Codice:

Tante (3000) Linee

Codice: (premerci sopra per visualizzarlo completamente)