/*
* This routine behaves a lot like graf_watchbox() - in fact, XaAES's
* graf_watchbox calls this.
*
* The differance here is that we handle colour icons properly (something
* that AES4.1 didn't do).
*
* I've re-used this bit from the WINDIAL module I wrote for the DULIB GEM library.
*
* This routine assumes that any clipping is going to be done elsewhere
* before we get to here.
*/
global
int watch_object(LOCK lock, XA_TREE *wt, int ob, int in_state, int out_state)
{
OBJECT *dial = wt->tree,
*the_object = dial + ob;
int pobf = -2, obf = ob;
G_i mx, my, mb, x, y, omx, omy;
vq_mouse(C.vh, &mb, &omx, &omy);
object_offset(dial, ob, wt->dx, wt->dy, &x, &y);
x--;
y--;
if (!mb) /* If mouse button is already released, assume that was just a click, so select */
{
(dial + ob)->ob_state = in_state;
hidem();
display_object(lock, wt, ob,x - the_object->r.x + 1, y - the_object->r.y + 1, 3);
showm();
} else
{
while (mb) /* This loop contains a pretty busy wait, but I don't think it's to */
{ /* much of a problem as the user is interacting with it continuously. */
Syield();
vq_mouse(C.vh, &mb, &mx, &my);
if ((mx != omx) or (my != omy))
{
omx = mx;
omy = my;
obf = find_object(dial, ob, 10, mx, my, wt->dx, wt->dy);
if (obf == ob)
(dial + ob)->ob_state = in_state;
else
(dial + ob)->ob_state = out_state;
if (pobf != obf)
{
pobf = obf;
hidem();
display_object(lock, wt, ob, x - the_object->r.x + 1, y - the_object->r.y + 1, 4);
showm();
}
}
}
}
f_interior(FIS_SOLID);
wr_mode(MD_TRANS);
if (obf == ob)
return 1;
else
return 0;
}
static void
doobjstat(void)
{
struct kinfo_vmobject *kvo;
int cnt, i;
kvo = kinfo_getvmobject(&cnt);
if (kvo == NULL) {
warn("Failed to fetch VM object list");
return;
}
printf("%5s %5s %5s %3s %3s %3s %2s %s\n", "RES", "ACT", "INACT",
"REF", "SHD", "CM", "TP", "PATH");
for (i = 0; i < cnt; i++)
display_object(&kvo[i]);
free(kvo);
}
void draw_sphere(
const glm::mat4 &modelTemp,
const glm::mat4 &view,
const glm::mat4 &projection,
GLuint &c0,
GLuint &c1,
GLuint &c2,
GLuint &c3
){
glm::mat4 modelview;
glm::mat4 modelview_projection;
modelview = view * modelTemp;
modelview_projection = projection * modelview;
GLuint m1 = glGetUniformLocation(programObject, "mvp"); // get the location of the uniform variable in the shader
glUniformMatrix4fv(m1, 1, GL_FALSE, &modelview_projection[0][0]);
GLuint m2 = glGetUniformLocation(programObject, "model"); // get the location of the uniform variable in the shader
glUniformMatrix4fv(m2, 1, GL_FALSE, &modelTemp[0][0]);
GLuint m3 = glGetUniformLocation(programObject, "view"); // get the location of the uniform variable in the shader
glUniformMatrix4fv(m3, 1, GL_FALSE, &view[0][0]);
glEnableVertexAttribArray(c3);
glVertexAttribPointer(c3,2,GL_FLOAT, GL_FALSE, sizeof(Vertex),(char*) NULL+48);
display_object(SPHERE,c0,c1,c2,c3);
}
int main(int argc, char **argv)
{
int idSockCli, lengthCli;
int idSockServ,lengthServ;
int etat_connexion;
char * servName;
int servPort;
int i;
int rcv;
obj objet;
struct sockaddr_in saddrServ; // Adresse serveur
struct hostent * hid;
obj* tab;
tab = (obj *)malloc(sizeof(obj) * TABLEN);
init_tab(tab);
printf("Connexion au serveur %s sur le port %s\n", argv[1], argv[2]);
servPort = atoi(argv[2]);
servName = argv[1];
// Création de l'identifiant de la socket client
if ((idSockCli = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
perror("socket() failed\n");
exit(0);
}
// Initialisation à zéro
lengthServ = sizeof(saddrServ);
bzero(&saddrServ, lengthServ);
hid = gethostbyname(servName);
saddrServ.sin_family = AF_INET; // Internet addresse
saddrServ.sin_port = htons(servPort); // Local port
bcopy(hid->h_addr,&(saddrServ.sin_addr.s_addr), hid->h_length);
if ((connect(idSockCli, (struct sockaddr *) &saddrServ, lengthServ)) < 0) {
perror("connect() failed\n");
exit(0);
}
printf("Connexion réussie\n");
for (i=0; i<TABLEN; i++) {
printf("Envoi de l'objet: %s\n", tab[i].id);
send(idSockCli, &tab[i], sizeof(tab[0]), 0); // transmission des données grace a la socket de service idsockcli
if((rcv= recv(idSockCli, &objet, sizeof(objet), 0)) < 0)
{
perror("rcv() Failed");
}
printf ("element modifié reçu\n");
display_object(objet);
printf("\n");
}
free(tab);
printf("Envoi terminé, fin de la connexion\n");
close(idSockCli);
return 0;
}
void display2()
{
glEnable(GL_DEPTH_TEST); // need depth test to correctly draw 3D objects
glClearColor(0,0,0,1);
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glUseProgram(programObject);
glm::mat4 projection = glm::perspective(60.0f,1.0f,.1f,100.0f);
glm::mat4 view = glm::lookAt
(glm::vec3(12.0, 12.0, 12.0), //position of the camera in world space
glm::vec3(0.0, 0.0, 0.0), // camera target
glm::vec3(0.0, 1.0, 0.0)); // up vector
glm::mat4 model = glm::mat4(1.0f);
model = glm::rotate(model, x_angle, glm::vec3(0.0f, 1.0f, 0.0f));
model = glm::rotate(model, y_angle, glm::vec3(1.0f, 0.0f, 0.0f));
model = glm::scale(model, glm::vec3(scale_size, scale_size, scale_size));
GLuint c0 = glGetAttribLocation(programObject, "position");
GLuint c1 = glGetAttribLocation(programObject, "color");
GLuint c2 = glGetAttribLocation(programObject, "normal");
GLuint c3 = glGetAttribLocation(programObject, "texCoord");
glEnableVertexAttribArray(c0);
glEnableVertexAttribArray(c1);
glEnableVertexAttribArray(c2);
/// setting up light
GLuint LightID = glGetUniformLocation(programObject, "LightPosition_worldspace");
//define the light
glm::vec3 lightPos = glm::vec3(10.0,14.0,10.0);
glUniform3f(LightID, lightPos.x, lightPos.y, lightPos.z);
// texture for cube mapping
glActiveTexture(GL_TEXTURE0);
glEnable (GL_TEXTURE_CUBE_MAP);
glBindTexture (GL_TEXTURE_CUBE_MAP, cubemap_texture);
glUniform1i(glGetUniformLocation(programObject, "env"), 0);
glUniform1i(glGetUniformLocation(programObject, "use_texture"), 1);
glEnableVertexAttribArray(c3);
glVertexAttribPointer(c3,2,GL_FLOAT, GL_FALSE, sizeof(Vertex),(char*) NULL+48);
// construct the modelview and modelview projection matricesrrt
///////////////////////////
float angle_in_degrees = 90.0;
//// negative y axis
glm::mat4 modelTemp = model;
//modelTemp = glm::rotate(modelTemp, angle_in_degrees, glm::vec3(0, 0, 1));
modelTemp = glm::translate(modelTemp,glm::vec3(0.0, -5.0, 0.0));
modelTemp = glm::scale(modelTemp,glm::vec3(10.0,10.0,10.0));
glm::mat4 modelview = view * modelTemp;
glm::mat4 modelview_projection = projection * modelview;
GLuint m1 = glGetUniformLocation(programObject, "mvp"); // get the location of the uniform variable in the shader
glUniformMatrix4fv(m1, 1, GL_FALSE, &modelview_projection[0][0]);
GLuint m2 = glGetUniformLocation(programObject, "model"); // get the location of the uniform variable in the shader
glUniformMatrix4fv(m2, 1, GL_FALSE, &modelTemp[0][0]);
GLuint m3 = glGetUniformLocation(programObject, "view"); // get the location of the uniform variable in the shader
glUniformMatrix4fv(m3, 1, GL_FALSE, &view[0][0]);
/////
modelTemp = model;
modelTemp = glm::translate(modelTemp,glm::vec3(0.0, 0.0, 4.0));
modelview = view * modelTemp;
modelview_projection = projection * modelview;
m1 = glGetUniformLocation(programObject, "mvp"); // get the location of the uniform variable in the shader
glUniformMatrix4fv(m1, 1, GL_FALSE, &modelview_projection[0][0]);
m2 = glGetUniformLocation(programObject, "model"); // get the location of the uniform variable in the shader
glUniformMatrix4fv(m2, 1, GL_FALSE, &modelTemp[0][0]);
glEnableVertexAttribArray(c3);
glVertexAttribPointer(c3,2,GL_FLOAT, GL_FALSE, sizeof(Vertex),(char*) NULL+48);
display_object(SPHERE,c0,c1,c2,c3);
glUniform1i(glGetUniformLocation(programObject, "use_texture"), 0);
// texture for texture mapping
glActiveTexture(GL_TEXTURE1);
glEnable (GL_TEXTURE_2D);
glBindTexture (GL_TEXTURE_2D, simple_texture);
glUniform1i(glGetUniformLocation(programObject, "tex"), 1);
// second sphere
modelTemp = model;
angle_in_degrees=90;
modelTemp = glm::translate(modelTemp,glm::vec3(0.0, 0.0, -4.0));
modelTemp = glm::rotate(modelTemp, angle_in_degrees, glm::vec3(1, 0, 0));
//modelTemp = glm::scale(modelTemp,glm::vec3(10.0,10.0,10.0));
modelview = view * modelTemp;
modelview_projection = projection * modelview;
m1 = glGetUniformLocation(programObject, "mvp"); // get the location of the uniform variable in the shader
glUniformMatrix4fv(m1, 1, GL_FALSE, &modelview_projection[0][0]);
m2 = glGetUniformLocation(programObject, "model"); // get the location of the uniform variable in the shader
glUniformMatrix4fv(m2, 1, GL_FALSE, &modelTemp[0][0]);
m3 = glGetUniformLocation(programObject, "view"); // get the location of the uniform variable in the shader
glUniformMatrix4fv(m3, 1, GL_FALSE, &view[0][0]);
display_object(SPHERE,c0,c1,c2,c3);
glutSwapBuffers();
glUseProgram(0);
}
void display_everything ()
{
//shadow
//First step: Render from the light POV to a FBO, story depth values only
glBindFramebuffer(GL_FRAMEBUFFER,fboId); //Rendering offscreen
//Using the fixed pipeline to render to the depthbuffer
glUseProgram(programObject);
// In the case we render the shadowmap to a higher resolution, the viewport must be modified accordingly.
glViewport(0,0,RENDER_WIDTH * SHADOW_MAP_RATIO,RENDER_HEIGHT* SHADOW_MAP_RATIO);
// Clear previous frame values
glClear( GL_DEPTH_BUFFER_BIT);
//Disable color rendering, we only want to write to the Z-Buffer
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
////////////////////////////
glUseProgram(programObject);
// DONOT use_texture
glUniform1i(glGetUniformLocation(programObject, "use_texture"), 0);
GLuint LightID = glGetUniformLocation(programObject, "LightPosition_worldspace");
//define the light
glm::vec3 lightPos = glm::vec3(0.0,20.0,0.0);
glUniform3f(LightID, lightPos.x, lightPos.y, lightPos.z);
glm::mat4 projection = glm::perspective(60.0f,1.0f,10.0f,400.0f);
glm::mat4 view = glm::lookAt(
glm::vec3(lightPos), //position of the camera in world space
glm::vec3(0.0, 0.0, -5.0), // camera target
glm::vec3(0.0, 1.0, 0.0)); // up vector
glm::mat4 model = glm::mat4(1.0f);
model = glm::rotate(model, x_angle, glm::vec3(0.0f, 1.0f, 0.0f));
model = glm::rotate(model, y_angle, glm::vec3(1.0f, 0.0f, 0.0f));
model = glm::scale(model, glm::vec3(scale_size, scale_size, scale_size));
///// darw object 1
glm::mat4 modelTemp = model;
modelTemp = glm::translate(modelTemp,glm::vec3(0.0, 1.0, 0.0));
//modelTemp = glm::scale(modelTemp,glm::vec3(5.0,5.0,5.0));
glm::mat4 modelview = view * modelTemp;
glm::mat4 modelview_projection = projection * modelview;
GLuint m1 = glGetUniformLocation(programObject, "mvp"); // get the location of the uniform variable in the shader
glUniformMatrix4fv(m1, 1, GL_FALSE, &modelview_projection[0][0]);
GLuint m2 = glGetUniformLocation(programObject, "model"); // get the location of the uniform variable in the shader
glUniformMatrix4fv(m2, 1, GL_FALSE, &modelTemp[0][0]);
GLuint m3 = glGetUniformLocation(programObject, "view"); // get the location of the uniform variable in the shader
glUniformMatrix4fv(m3, 1, GL_FALSE, &view[0][0]);
GLuint c0 = glGetAttribLocation(programObject, "position");
GLuint c1 = glGetAttribLocation(programObject, "color");
GLuint c2 = glGetAttribLocation(programObject, "normal");
GLuint c3 = glGetAttribLocation(programObject, "texCoord");
glEnableVertexAttribArray(c0);
glEnableVertexAttribArray(c1);
glEnableVertexAttribArray(c2);
glEnableVertexAttribArray(c3);
glVertexAttribPointer(c3,2,GL_FLOAT, GL_FALSE, sizeof(Vertex),(char*) NULL+48);
glCullFace(GL_FRONT);
display_object(CUBE,c0,c1,c2,c3);
//second object
modelTemp = model;
modelTemp = glm::translate(modelTemp,glm::vec3(0.0, 1.0, 0.0));
modelTemp = glm::scale(modelTemp,glm::vec3(15.0,15.0,15.0));
modelview = view * modelTemp;
modelview_projection = projection * modelview;
m1 = glGetUniformLocation(programObject, "mvp"); // get the location of the uniform variable in the shader
glUniformMatrix4fv(m1, 1, GL_FALSE, &modelview_projection[0][0]);
m2 = glGetUniformLocation(programObject, "model"); // get the location of the uniform variable in the shader
glUniformMatrix4fv(m2, 1, GL_FALSE, &modelTemp[0][0]);
m3 = glGetUniformLocation(programObject, "view"); // get the location of the uniform variable in the shader
glUniformMatrix4fv(m3, 1, GL_FALSE, &view[0][0]);
//display_object(CUBE,c0,c1,c2,c3);
// Now rendering from the camera POV, using the FBO to generate shadows
////////////////////////////
glUseProgram(programObject);
glBindFramebuffer(GL_FRAMEBUFFER,0);
glViewport(0,0,RENDER_WIDTH,RENDER_HEIGHT);
//glEnable(GL_DEPTH_TEST); // need depth test to correctly draw 3D objects
glDisable(GL_CULL_FACE);
//glClearColor(0,0,0,1);
//glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
//Enabling color write (previously disabled for light POV z-buffer rendering)
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
// Clear previous frame values
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
///
const shapes s = SQUARE;
glUseProgram(programObject);
glEnable(GL_DEPTH_TEST); // need depth test to correctly draw 3D objects
glClearColor(0,0,0,1);
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
// texture for NORMAL mapping
glActiveTexture(GL_TEXTURE2);
glEnable (GL_TEXTURE_2D);
glBindTexture (GL_TEXTURE_2D, normal_texture);
glUniform1i(glGetUniformLocation(programObject, "normal_tex"), 2);
////////////////
//Using the shadow shader
glUseProgram(programObject);
glUniform1i(glGetUniformLocation(programObject, "use_texture"), 1);
glActiveTexture(GL_TEXTURE0);
glEnable (GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D,depthTextureID);
glUniform1i(glGetUniformLocationARB(programObject,"ShadowMap"),0);
view = glm::lookAt(
glm::vec3(22,22,22), //position of the camera in world space
glm::vec3(2.0, 0.0, -5.0), // camera target
glm::vec3(0.0, 1.0, 0.0)); // up vector
projection = glm::perspective(60.0f,1.0f,10.0f,400.0f);
model = glm::mat4(1.0f);
model = glm::rotate(model, x_angle, glm::vec3(0.0f, 1.0f, 0.0f));
model = glm::rotate(model, y_angle, glm::vec3(1.0f, 0.0f, 0.0f));
model = glm::scale(model, glm::vec3(scale_size, scale_size, scale_size));
glActiveTexture(GL_TEXTURE1);
glEnable (GL_TEXTURE_2D);
glBindTexture (GL_TEXTURE_2D, simple_texture);
glUniform1i(glGetUniformLocation(programObject, "tex"), 1);
///// darw object 1
modelTemp = model;
modelTemp = glm::translate(modelTemp,glm::vec3(0.0, 1.0, 0.0));
//modelTemp = glm::scale(modelTemp,glm::vec3(5.0,5.0,5.0));
modelview = view * modelTemp;
modelview_projection = projection * modelview;
m1 = glGetUniformLocation(programObject, "mvp"); // get the location of the uniform variable in the shader
glUniformMatrix4fv(m1, 1, GL_FALSE, &modelview_projection[0][0]);
m2 = glGetUniformLocation(programObject, "model"); // get the location of the uniform variable in the shader
glUniformMatrix4fv(m2, 1, GL_FALSE, &modelTemp[0][0]);
m3 = glGetUniformLocation(programObject, "view"); // get the location of the uniform variable in the shader
glUniformMatrix4fv(m3, 1, GL_FALSE, &view[0][0]);
glm::mat4 biasMat = glm::mat4(0.0f);
biasMat[0][0]=0.5;
biasMat[1][1]=0.5;
biasMat[2][2]=0.5;
biasMat[3][3]=1.0;
biasMat[3][2]=0.5;
biasMat[2][1]=0.5;
biasMat[3][0]=0.5;
/// debug
cout <<"biaMat "<<biasMat[2][1]<<endl;
GLuint bias = glGetUniformLocation(programObject, "bias"); // get the location of the uniform variable in the shader
glUniformMatrix4fv(bias, 1, GL_FALSE, &biasMat[0][0]);
c0 = glGetAttribLocation(programObject, "position");
c1 = glGetAttribLocation(programObject, "color");
c2 = glGetAttribLocation(programObject, "normal");
c3 = glGetAttribLocation(programObject, "texCoord");
glEnableVertexAttribArray(c0);
glEnableVertexAttribArray(c1);
glEnableVertexAttribArray(c2);
glEnableVertexAttribArray(c3);
glVertexAttribPointer(c3,2,GL_FLOAT, GL_FALSE, sizeof(Vertex),(char*) NULL+48);
//glCullFace(GL_FRONT);
display_object(CUBE,c0,c1,c2,c3);
//display_object(CUBE,c0,c1,c2,c3);
glUniform1i(glGetUniformLocation(programObject, "use_texture"), 4);
glActiveTexture(GL_TEXTURE4);
glEnable (GL_TEXTURE_2D);
glBindTexture (GL_TEXTURE_2D, grass_texture);
glUniform1i(glGetUniformLocation(programObject, "grass"), 4);
// texture for NORMAL mapping
glActiveTexture(GL_TEXTURE5);
glEnable (GL_TEXTURE_2D);
glBindTexture (GL_TEXTURE_2D, normal_texture2);
glUniform1i(glGetUniformLocation(programObject, "normal_tex2"), 5);
///// kept static for shadow mapping
glm::mat4 modelTemp2;
modelTemp2 = glm::translate(modelTemp2,glm::vec3(-15.0, -15.0, -15.0));
modelTemp2 = glm::scale(modelTemp2,glm::vec3(35.0,1.0,35.0));
modelview = view * modelTemp2;
modelview_projection = projection * modelview;
m1 = glGetUniformLocation(programObject, "mvp"); // get the location of the uniform variable in the shader
glUniformMatrix4fv(m1, 1, GL_FALSE, &modelview_projection[0][0]);
m2 = glGetUniformLocation(programObject, "model"); // get the location of the uniform variable in the shader
glUniformMatrix4fv(m2, 1, GL_FALSE, &modelTemp[0][0]);
m3 = glGetUniformLocation(programObject, "view"); // get the location of the uniform variable in the shader
glUniformMatrix4fv(m3, 1, GL_FALSE, &view[0][0]);
glUniform1i(glGetUniformLocation(programObject, "use_texture"), 4);
display_object(CUBE,c0,c1,c2,c3);
modelTemp = model;
modelTemp = glm::translate(modelTemp,glm::vec3(0.0, 1.0, 0.0));
modelTemp = glm::scale(modelTemp,glm::vec3(15.0,15.0,15.0));
modelview = view * modelTemp;
modelview_projection = projection * modelview;
m1 = glGetUniformLocation(programObject, "mvp"); // get the location of the uniform variable in the shader
glUniformMatrix4fv(m1, 1, GL_FALSE, &modelview_projection[0][0]);
m2 = glGetUniformLocation(programObject, "model"); // get the location of the uniform variable in the shader
glUniformMatrix4fv(m2, 1, GL_FALSE, &modelTemp[0][0]);
m3 = glGetUniformLocation(programObject, "view"); // get the location of the uniform variable in the shader
glUniformMatrix4fv(m3, 1, GL_FALSE, &view[0][0]);
//display_object(BUNNY,c0,c1,c2,c3);
glutSwapBuffers();
glUseProgram(0);
}
int main(int argc, char **argv)
{
int idSockServ, lengthServ; // Identifiant socket serveur et taille structure
int idSockCli, lengthCli; // Identifiant socket client et taille structure
struct sockaddr_in saddrServ; // Adresse serveur
struct sockaddr_in saddrCli; // Adresse client
int servPort;
pid_t pid;
obj objet;
printf("Le serveur fonctionne sur le port %s\n", argv[1]);
servPort = atoi(argv[1]);
// Création du socket
if ((idSockServ = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) { // SOCK_STREAM: TCP, PF_INET: IPv4
perror("socket() failed\n");
exit(0);
}
// Initialisation à zéro
lengthServ = sizeof(saddrServ);
bzero(&saddrServ, lengthServ);
// Affectation des champs utiles du socket
saddrServ.sin_family = AF_INET; // IPv4
saddrServ.sin_addr.s_addr = htonl(INADDR_ANY); // Converts unsigned int arg from host byte order to network byte order
saddrServ.sin_port = htons(servPort); // Récupère le port passé en argument
// Association de la socket à l'adresse créée
if ((bind(idSockServ, (const struct sockaddr *) &saddrServ, lengthServ)) < 0) {
perror("bind() failed\n");
exit(0);
}
// Le serveur écoute sur le socket, la file d'attente a une longueur MAXBINDING
if (listen(idSockServ, MAXBINDING) < 0) {
perror("listen() failed\n");
exit(0);
}
while (1) {
printf("En attente de messages\n");
lengthCli = sizeof(saddrCli);
// Création d'une socket de service
if ((idSockCli = accept(idSockServ, (struct sockaddr *) &saddrCli, &lengthCli)) < 0) {
perror("accept() failed\n");
exit(0);
}
pid = fork();
switch(pid) {
case 0:
printf ("Traitement du client par le fils\n");
do {
if((recv(idSockCli, &objet, sizeof(objet), 0)) < 0) {
perror("rcv() Failed");
exit(0);
}
if (objet.ii != -1)
display_object(objet);
} while (objet.ii != -1);
return 0;
break;
case -1:
perror("Erreur");
break;
default:
printf("Délégation du traitement au fils\n");
}
}
return 0;
}
