예제 #1
0
void myinit(void) {    
    int width, height, comp;

    glClearColor (0.0, 0.0, 0.0, 0.0);
    glEnable(GL_DEPTH_TEST);

    glGenTextures(50,texName);
    glBindTexture(GL_TEXTURE_2D, texName[0]);
    image = (GLubyte *) read_texture("anna.sgi", &width, &height, &comp);
    gluBuild2DMipmaps(GL_TEXTURE_2D, 4, width, height, GL_RGBA, 
        GL_UNSIGNED_BYTE, image);
    free(image);

    glBindTexture(GL_TEXTURE_2D, texName[1]);
    image = (GLubyte *) read_texture("wall1.sgi", &width, &height, &comp);
    gluBuild2DMipmaps(GL_TEXTURE_2D, 4, width, height, GL_RGBA, 
        GL_UNSIGNED_BYTE, image);
    free(image);

    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
    glEnable(GL_TEXTURE_2D);
    glShadeModel(GL_FLAT);
}
예제 #2
0
void
init_images(void)
{
  int comp;

  a_data = read_texture("a.rgb", &a_width, &a_height, &comp);
  printf("%dx%dx%d\n", a_width, a_height, comp);
  b_data = read_texture("b.rgb", &b_width, &b_height, &comp);
  printf("%dx%dx%d\n", b_width, b_height, comp);
}
예제 #3
0
MultiTex::MultiTex(std::string filename, float alpha, bool repeat)
  : m_alpha(alpha)
{
  static unsigned *image;
  static int width, height, components;
    
  image = read_texture(filename.c_str(), &width, &height, &components);
  
  GLuint texId; glGenTextures(1, &texId);
  m_texID = texId;

  glBindTexture(GL_TEXTURE_2D, m_texID);
  gluBuild2DMipmaps( GL_TEXTURE_2D, components, width, height, 
  		     GL_RGBA, GL_UNSIGNED_BYTE, image );
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

  if (repeat) 
  {
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
  }
  else 
  {
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);    
  }
}
    Image* ImageSerializer_rgb::serialize_read(std::istream& in) {
        int width = 0 ;
        int height = 0 ;
        int bpp = 0 ;
        unsigned* data = read_texture(in, &width, &height, &bpp) ;

        // Note: it seems that data is always encoded as a RGBA image,
        // bpp seems to only return the original color encoding...
        bpp = 4 ;

        Image::ColorEncoding color_encoding ;
        switch(bpp) {
        case 1:
            color_encoding = Image::GRAY ;
            break ;
        case 3:
            color_encoding = Image::RGB ;
            break ;
        case 4:
            color_encoding = Image::RGBA ;
            break ;
        default:
            ogf_assert(false) ;
            break ;
        }

        Image* result = new Image(color_encoding, width, height) ;
        memcpy(result->base_mem(), data, width * height * bpp) ;
        free(data) ;
        
        return result ;
    }
예제 #5
0
void load_img(const char *fname)
{
    img = read_texture(fname, &w, &h, &comp);
    if (!img) {
	fprintf(stderr, "Could not open %s\n", fname);
	exit(1);
    }
}
예제 #6
0
파일: texmovie.c 프로젝트: xtmacbook/SGI
void init(int argc, char *argv[]) {
    unsigned *image;
    int i, width, height, components, flame=0;
	char fname[sizeof("../../data//flame/f00") + 1];

    glEnable(GL_TEXTURE_2D);
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

	/* Use the flame files if there are no command-line parameters */
    if (argc < 1) {
	flame = 1;
	argc = 32;
    }

    for(i = 0; i < argc; i++) {
	if (flame) {
	    (void)sprintf(fname, "../../data/flame/f%.2d",i);
	    image = read_texture(fname, &width, &height, &components);
	} else
	    image = read_texture(argv[i], &width, &height, &components);

	if (image == NULL) {
	    fprintf(stderr, "Error: Can't load image file \"%s\".\n", argv[i]);
	    exit(EXIT_FAILURE);
	} else {
	    printf("%d x %d image loaded\n", width, height);

	}

	glBindTexture(GL_TEXTURE_2D, i+1);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
	glTexImage2D(GL_TEXTURE_2D, 0, components, width,
			 height, 0, GL_RGBA, GL_UNSIGNED_BYTE, image);
	texture_count++;
    }

    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
    glEnable(GL_TEXTURE_2D);
    glClearColor(.25f, .25f, .25f, .25f);

    glAlphaFunc(GL_GREATER, 0.f);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}
예제 #7
0
int create_texture(const char *fname, GLsizei *w,  GLsizei *h, GLsizei *padW, GLsizei *padH, int *comps)
{
    unsigned int *img, *padImg = NULL;
    int y, iw, ih;

    iw = (int)(*w);
    ih = (int)(*h);
    img = read_texture(fname, &iw, &ih, comps);
    if (!img) return -1;
    *w = iw;
    *h = ih;

    /* if width & height are not powers of two, pad image with black */
    if (*w & (*w - 1))
    {
        *padW = roundup(*w);
    }
    else
    {
        *padW = *w;
    }
    if (*h & (*h - 1))
    {
        *padH = roundup(*h);
    }
    else
    {
        *padH = *h;
    }

    if (*padW != *w || *padH != *h)
    {
        printf("rounding %s up...\n", fname);
        padImg = (unsigned int *)malloc(*padW * *padH * sizeof(GLuint));
        if (!padImg)
        {
            fprintf(stderr, "Malloc of %d bytes failed.\n",
            (int)(*padW * *padH * sizeof(GLuint)));
            exit(1);
        }

        memset(padImg, 0, *padW * *padH * sizeof(GLuint));
        for (y = 0; y < *h; y++)
        {
            memcpy(&padImg[y * *padW], &img[y * *w], *w * sizeof(GLuint));
        }
    }


    /* you should use texture objects here if your system supports them... */
    glTexImage2D(GL_TEXTURE_2D, 0, 4, *padW, *padH, 0,
             GL_RGBA, GL_UNSIGNED_BYTE, img);

    free(img);
    if (padImg) free(padImg);

    return 0;
}
예제 #8
0
파일: underwater.c 프로젝트: mox601/grafica
void init(void) {
    int width, height, components;
    GLubyte *image;
    float density, fog_density, far_cull;

    glClearColor (0.0, 0.0, 0.0, 0.0);
    glEnable(GL_DEPTH_TEST);
    glShadeModel(GL_SMOOTH);

    if (!(image = (GLubyte *)read_texture("data/sea.rgb", &width, &height, &components))) {
	perror("sea.rgb");
	exit(EXIT_FAILURE);
    }
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexImage2D(GL_TEXTURE_2D, 0, 4, width, height, 0,
		GL_RGBA, GL_UNSIGNED_BYTE, image);

    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
    glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
    glTexGenfv(GL_S, GL_EYE_PLANE, s_plane);
    glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
    glTexGenfv(GL_T, GL_EYE_PLANE, t_plane);

    glEnable(GL_TEXTURE_GEN_S);
    glEnable(GL_TEXTURE_GEN_T);
    glEnable(GL_TEXTURE_2D);
    glEnable(GL_CULL_FACE);
    glEnable(GL_LIGHTING);
    glEnable(GL_LIGHT0);
    glEnable(GL_AUTO_NORMAL);
    glEnable(GL_NORMALIZE);
    glFrontFace(GL_CW);
    glCullFace(GL_BACK);
    glMaterialf (GL_FRONT, GL_SHININESS, 64.0);
    { int e; if (e = glGetError()) printf("error %x\n", e); }

    density = 1.- expf(-5.5 * fog_density * fog_density *
		     far_cull * far_cull);
#define MAX(a,b) ((a) > (b) ? (a) : (b))
#define MIN(a,b) ((a) < (b) ? (a) : (b))
    density = MAX(MIN(density, 1.), 0.);

    glClearColor(.09f,.18f,.18f,1.f);

    glFogi(GL_FOG_MODE, GL_EXP);
    glFogf(GL_FOG_DENSITY, fog_params[0]);
    glFogfv(GL_FOG_COLOR, fog_params+1);
    glEnable(GL_FOG);
    {
    GLfloat pos[] = {0.,150.,1.,1.};
    glLightfv(GL_LIGHT0, GL_POSITION, pos);
    }
}
예제 #9
0
GLuint *load_img(char *fname, GLsizei *imgW, GLsizei *imgH)
{
  GLuint *img;

  img = read_texture(fname, imgW, imgH, &comp);
  if (!img) {
    fprintf(stderr, "Could not open %s\n", fname);
    exit(1);
  }

  return img;
}
예제 #10
0
void
init(char *filename)
{
  double l = 0;
  int i;

  func = brighten;

  if (filename) {
    image = read_texture(filename, &width, &height, &components);
    if (image == NULL) {
      fprintf(stderr, "Error: Can't load image file \"%s\".\n",
        filename);
      exit(1);
    } else {
      printf("%d x %d image loaded\n", width, height);
    }
    if (components < 3 || components > 4) {
      printf("must be RGB or RGBA image\n");
      exit(1);
    }
  } else {
    int i, j;
    components = 4;
    width = height = 512;
    image = (unsigned *) malloc(width * height * sizeof(unsigned));
    for (j = 0; j < height; j++)
      for (i = 0; i < width; i++) {
        if (i & 1)
          image[i + j * width] = 0xff;
        else
          image[i + j * width] = 0xff00;
        if (j & 1)
          image[i + j * width] |= 0xff0000;
      }

  }
  null = (unsigned *) malloc(width * height * sizeof *image);

  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  glClearColor(.25, .25, .25, .25);

  /* compute luminance */
  for (i = 0; i < width * height; i++) {
    GLubyte *p = (GLubyte *) (image + i);
    double r = p[0] / 255.;
    double g = p[1] / 255.;
    double b = p[2] / 255.;
    l += r * .3086 + g * .0820 + b * .114;
  }
  luma = l / (width * height);
  printf("average luminance = %f\n", luma);
}
예제 #11
0
void init(char *fname) {
    int width, height, components;
    GLubyte *image;

    glClearColor(0.0, 0.0, 0.0, 0.0);
    glEnable(GL_DEPTH_TEST);
    glShadeModel(GL_SMOOTH);

    if (!(image = (GLubyte *)read_texture(fname, &width, &height, &components))) {
	perror(fname);
	exit(EXIT_FAILURE);
    }
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexImage2D(GL_TEXTURE_2D, 0, 4, width, height, 0,
		GL_RGBA, GL_UNSIGNED_BYTE, image);

    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
    glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
    glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);

    glEnable(GL_TEXTURE_GEN_S);
    glEnable(GL_TEXTURE_GEN_T);
    glEnable(GL_TEXTURE_2D);
    glEnable(GL_CULL_FACE);
    glEnable(GL_LIGHTING);
    glEnable(GL_LIGHT0);
    glEnable(GL_NORMALIZE);
    glFrontFace(GL_CW);
    glCullFace(GL_BACK);
    glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
    glEnable(GL_COLOR_MATERIAL);
#if 1
    glMaterialf (GL_FRONT, GL_SHININESS, 64.0);
    glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1);
    {
    GLfloat pos[4] = { 0, 0, 1, 1};
    glLightfv(GL_LIGHT0, GL_POSITION, pos);
    }
#endif
    { int e; if (e = glGetError()) printf("error %x\n", e); }

#if 0
    glClearColor(.2,.2f,.58f,1.f);
#endif
    glBlendFunc(GL_SRC_ALPHA, GL_ONE);
    glEnable(GL_BLEND);
}
예제 #12
0
파일: warp.c 프로젝트: AlexGreulich/HRTFVR
void
init(char *filename)
{
  if (filename) {
    image = read_texture(filename, &width, &height, &components);
    if (image == NULL) {
      fprintf(stderr, "Error: Can't load image file \"%s\".\n",
        filename);
      exit(1);
    } else {
      printf("%d x %d image loaded\n", width, height);
    }
    if (components < 3 || components > 4) {
      printf("must be RGB or RGBA image\n");
      exit(1);
    }
  } else {
    int i, j;
    components = 4;
    width = height = 512;
    image = (unsigned *) malloc(width * height * sizeof(unsigned));
    for (j = 0; j < height; j++)
      for (i = 0; i < width; i++) {
        if (i & 64)
          image[i + j * width] = 0xff;
        else
          image[i + j * width] = 0xff00;
        if (j & 64)
          image[i + j * width] |= 0xff0000;
      }

  }
  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  glTexImage2D(GL_TEXTURE_2D, 0, components, width,
    height, 0, GL_RGBA, GL_UNSIGNED_BYTE,
    image);
  glEnable(GL_TEXTURE_2D);
  glMatrixMode(GL_TEXTURE);
  glLoadIdentity();
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  gluPerspective(90., 1., .1, 10.);
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();
  glTranslatef(0., 0., -1.5);
  glClearColor(.25, .25, .25, 0.);

}
예제 #13
0
파일: vpaint.c 프로젝트: xtmacbook/SGI
int
main(int argc, char *argv[])
{
    glutInit(&argc, argv);
    glutInitWindowSize(20, 20);
    glutInitDisplayMode(GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE | GLUT_ACCUM);
    (void) glutCreateWindow("Voronoi art");
    glutKeyboardFunc(key);
    glutDisplayFunc(redraw);
    glutMouseFunc(mouse);
    glutMotionFunc(motion);
    glutIdleFunc(idle);

    /*
     * Load the image and sample it 
     */
    img = (GLuint *)read_texture((argc > 1) ? argv[1] : mandrill, &w, &h, &comp);
    if (!img) {
	fprintf(stderr, "Could not open image.\n");
	exit(1);
    }
    glutReshapeWindow(w, h);
    init();

    /*
     * Menu 
     */
    sampleMenu = glutCreateMenu(menu);
    glutAddMenuEntry("More samples ('+')", '+');
    glutAddMenuEntry("Fewer samples ('-')", '-');
    glutAddMenuEntry("Resample points ('r')", 'r');
    glutAddMenuEntry("View source image ('i')", 'i');
    if (canDrawEdges)
	glutAddMenuEntry("Toggle drawing region edges ('e')", 'e');
    glutAddMenuEntry("", ' ');
    glutAddMenuEntry("Paint with mouse strokes ('s')", 's');
    glutAddMenuEntry("exit", '\033');
    glutAttachMenu(GLUT_RIGHT_BUTTON);

    strokeMenu = glutCreateMenu(menu);
    glutAddMenuEntry("View source image ('i')", 'i');
    glutAddMenuEntry("", ' ');
    glutAddMenuEntry("Paint with random samples ('s')", 's');
    glutAddMenuEntry("exit", '\033');

    glutMainLoop();

    return 0;
}
예제 #14
0
static void
imgLoad(char *filename_in, int *w_out, int *h_out, GLubyte **img_out)
{
    int comp;

    *img_out = (GLubyte *)read_texture(filename_in, w_out, h_out, &comp);
    if (img_out == NULL) {
	fprintf(stderr, "unable to read %s\n", filename_in);
	exit(EXIT_FAILURE);
    }
    if (comp != 3 && comp != 4) {
	fprintf(stderr, "%s: image is not RGB or RGBA\n", filename_in);
	exit(EXIT_FAILURE);
    }
}
예제 #15
0
void 
init_textures(char *filename)
{
  unsigned *buf;
  int width, height, components;

  if (filename) {
    buf = read_texture(filename, &width, &height, &components);
    if (buf == NULL) {
      fprintf(stderr, "Error: Can't load image file \"%s\".\n",
        filename);
      exit(1);
    } else {
      printf("%d x %d texture loaded\n", width, height);
    }
  } else {
    int i, j;
    GLubyte *p;
    components = 4;
    width = height = 512;
    buf = (unsigned *) malloc(width * height * sizeof(unsigned));
    p = (GLubyte *) buf;
    for (j = 0; j < height; j++) {
      for (i = 0; i < width; i++) {
        if (i & 1)
          p[4 * (i + j * width) + 0] = 0xff;
        else
          p[4 * (i + j * width) + 1] = 0xff;
        if (j & 1)
          p[4 * (i + j * width) + 2] = 0xff;
      }
    }
  }

  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  glTexImage2D(GL_TEXTURE_2D, 0, components, width,
    height, 0, GL_RGBA, GL_UNSIGNED_BYTE,
    buf);
  free(buf);
}
예제 #16
0
파일: writer.c 프로젝트: waless/hwlib
hwgm_material_t* read_material(context_t* context, const reader_material_t* material)
{
    hwgm_material_t* out     = NULL;
    hwgm_texture_t*  texture = NULL;
    hwu32            offset  = 0;
    hwu32            i;

    out = (hwgm_material_t*)(context->materials + context->material_pos);
    hwgm_material_initialize(out);

    offset   = context->material_pos + sizeof(hwgm_material_t);
    textures = (hwgm_texture_t*)((hwu8*)context->materials + offset);
    for(i = 0; i < material->diffuse_texture_cont; ++i) {
        texture = read_texture(context, material->diffuse_textures + i);
        out->textures[i] = texture;
    }

    return out;
}
예제 #17
0
void imgLoad(const char *filenameIn, int borderIn, GLfloat borderColorIn[4], int *wOut, int *hOut, GLubyte ** imgOut)
{
    int border = borderIn;
    int width, height;
    int w, h;
    GLubyte *image, *img, *p;
    int i, j, components;

    image = (GLubyte *) read_texture(filenameIn, &width, &height, &components);
    w = width + 2 * border;
    h = height + 2 * border;
    img = (GLubyte *) calloc(w * h, 4 * sizeof(unsigned char));

    p = img;
    for (j = -border; j < height + border; ++j)
    {
        for (i = -border; i < width + border; ++i)
        {
            if (0 <= j && j <= height - 1 && 0 <= i && i <= width - 1)
            {
                p[0] = image[4 * (j * width + i) + 0];
                p[1] = image[4 * (j * width + i) + 1];
                p[2] = image[4 * (j * width + i) + 2];
                p[3] = 0xff;
            }
            else
            {
                p[0] = (unsigned char)(borderColorIn[0]) * 0xff;
                p[1] = (unsigned char)(borderColorIn[1]) * 0xff;
                p[2] = (unsigned char)(borderColorIn[2]) * 0xff;
                p[3] = (unsigned char)(borderColorIn[3]) * 0xff;
            }
            p += 4;
        }
    }
    free(image);
    *wOut = w;
    *hOut = h;
    *imgOut = img;
}
예제 #18
0
파일: spheremap.c 프로젝트: xtmacbook/SGI
void 
init(const char *fname)
{
    static GLfloat lightpos[] = {.5, .75, 1.5, 1};
    GLuint *img;
    int w, h;
    int comps;

    glEnable(GL_DEPTH_TEST);
#if 0
    glEnable(GL_LIGHTING);
    glEnable(GL_LIGHT0);
#endif
    glEnable(GL_CULL_FACE);

    glLightfv(GL_LIGHT0, GL_POSITION, lightpos);

    cone = gluNewQuadric();
    base = gluNewQuadric();
    sphere = gluNewQuadric();

    img = (GLuint *)read_texture(fname, &w, &h, &comps);
    if (!img) {
	fprintf(stderr, "Could not open %s\n", fname);
	exit(1);
    }
    floorList = glGenLists(1);
    glNewList(floorList, GL_COMPILE);
    glTexImage2D(GL_TEXTURE_2D, 0, 4, w, h, 0,
		 GL_RGBA, GL_UNSIGNED_BYTE, img);
    glEndList();
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    free(img);

    glClearColor(.25, .25, .5, 1.0);

    realloc_textures();
}
예제 #19
0
void load_img(const char *fname)
{
    int i;
    GLubyte *src, *dst;
    GLfloat pix, avg;

    img = read_texture(fname, &w, &h, &comp);
    if (!img) {
	fprintf(stderr, "Could not open %s\n", fname);
	exit(1);
    }

    black = alloc_image();
    memset(black, 0, w * h * sizeof(GLuint));

    lum = alloc_image();
    src = (GLubyte *)img;
    dst = (GLubyte *)lum;
    avg = 0.;
    /* compute average luminance at same time that we set luminance image.
     * note that little care is taken to avoid mathematical error when
     * computing overall average... */
    for (i = 0; i < w * h; i++) {
	pix = (float)src[0]*RW + (float)src[1]*GW + (float)src[2]*BW;
	if (pix > 255) pix = 255;
	dst[0] = dst[1] = dst[2] = pix;
	avg += pix / 255.;
	src += 4;
	dst += 4;
    }

    avgLum = alloc_image();
    pix = avg * 255. / (float)(w*h);
    dst = (GLubyte *)avgLum;
    for (i = 0; i < w * h; i++) {
	dst[0] = dst[1] = dst[2] = pix;
	dst += 4;
    }
}
예제 #20
0
파일: dither.c 프로젝트: xtmacbook/SGI
/* Parse arguments, and set up interface between OpenGL and window system */
int
main(int argc, char *argv[])
{
    int comp;
    glutInit(&argc, argv);
    glutInitWindowSize(512, 512);
    glutInitDisplayMode(GLUT_RGBA|GLUT_ACCUM);
    (void)glutCreateWindow("dither");
    glutReshapeFunc(reshape);
    glutKeyboardFunc(key);
/*    create_menu();	*/

    img = read_texture((argc > 1) ? argv[1] : "../../data/mandrill_small.rgb", &image_w, &image_h, &comp);
    if (!img) {
	fprintf(stderr, "Could not open image.\n");
	exit(1);
    }

    glutDisplayFunc(redraw);
    CHECK_ERROR("main");
    glutMainLoop();
    return 0;
}
예제 #21
0
파일: texpage.c 프로젝트: amlanpradhan/GLUT
static void
loadtiles(void) {
    int lx, rx, ty, by;	/* image bounding box */
    static int ox = TILES*TILESIZE/2, oy = TILES*TILESIZE/2;  /* image origin */
    static int ot = 0, os = 0;
    int dx = 0, dy = 0, nx = -1, ny = -1;
    float trx, try;
#define S_TSIZE	(TSIZE-TILESIZE)	/* visible portion of texture = TSIZE less one tile for slop */

    /* calculate tile #'s at corners of visible region */
    lx = x - S_TSIZE/2;
    rx = lx + S_TSIZE;
    by = y - S_TSIZE/2;
    ty = by + S_TSIZE;
    lx /= TILESIZE; rx /= TILESIZE;
    by /= TILESIZE; ty /= TILESIZE;

    dx = ((x - S_TSIZE/2)/TILESIZE) - ((ox - S_TSIZE/2)/TILESIZE);
    
    nx = lx; ny = by;
    if (dx < 0) {
	/* add on left */
	os -= TILESIZE;
	if (os < 0) os += TSIZE;
	nx = lx;
    } else if (dx > 0) {
	nx = rx;
    }

    dy = ((y - S_TSIZE/2) / TILESIZE) - ((oy - S_TSIZE/2) / TILESIZE);
    if (dy > 0) {
	/* add on bottom */
	ny = ty;
    } else if (dy < 0) {
	/* add on top */
	ot -= TILESIZE;
	if (ot < 0) ot += TSIZE;
	ny = by;
    }
if (dx || dy) printf("dx %d dy %d   lx %d rx %d   by %d ty %d   nx %d ny %d   os %d ot %d\n", dx, dy, lx, rx, by, ty, nx, ny, os, ot);
    if (dx) {
	int t;
	for(t = 0; t < TSIZE; t += TILESIZE) {
	    glTexSubImage2D(GL_TEXTURE_2D, 0, os, (t+ot) % TSIZE, TILESIZE,
                 TILESIZE, GL_RGBA, GL_UNSIGNED_BYTE,
                 tiles[ny+t/TILESIZE][nx].data);
printf("load %d %d  %d %d\n", nx, ny+t/TILESIZE, os, (t+ot) % TSIZE);
	}
    }

    if (dy) {
	int s;
	for(s = 0; s < TSIZE; s += TILESIZE) {
	    glTexSubImage2D(GL_TEXTURE_2D, 0, (s+os) % TSIZE, ot, TILESIZE,
                 TILESIZE, GL_RGBA, GL_UNSIGNED_BYTE,
                 tiles[ny][nx+s/TILESIZE].data);
printf("load %d %d  %d %d\n", nx+s/TILESIZE, ny, (s+os) % TSIZE, ot);
	}
    }
    if (dx > 0) {
	os += TILESIZE;
	if (os >= TSIZE) os -= TSIZE;
    }
    if (dy > 0) {
	ot += TILESIZE;
	if (ot >= TSIZE) ot -= TSIZE;
    }
    ox = x; oy = y;
    glMatrixMode(GL_TEXTURE);
    glLoadIdentity();
    trx = (float)((x-TILES*TILESIZE/2) % TSIZE)/TSIZE;
    try = (float)((y-TILES*TILESIZE/2) % TSIZE)/TSIZE;
    glTranslatef(trx, try, 0.f);
    glMatrixMode(GL_MODELVIEW);
}

static void
init(char *filename) {
    int i;

    mesh0(-1.f,1.f,-1.f,1.f,0.f,1.f,0.f,1.f,0.f,64,64);
    if (filename) {
	image = read_texture(filename, &width, &height, &components);
	if (image == NULL) {
	    fprintf(stderr, "Error: Can't load image file \"%s\".\n",
		    filename);
	    exit(EXIT_FAILURE);
	} else {
	    printf("%d x %d image loaded\n", width, height);
	}
	if (components < 3 || components > 4) {
	    printf("must be RGB or RGBA image\n");
	    exit(EXIT_FAILURE);
	}
    } else {
	int i, j;
	components = 4; width = height = TSIZE;
	image = (unsigned *) malloc(width*height*sizeof(unsigned));
	for (j = 0; j < height; j++)
	    for (i = 0; i < width; i++) {
		if (i & 1)
		    image[i+j*width] = 0xff;
		else
		    image[i+j*width] = 0xff00;
		if (j&1)
		    image[i+j*width] |= 0xff0000;
	    }

    }
    if (width % TILESIZE || height % TILESIZE) {
#define TXSIZE 192
	unsigned *newimage = malloc(TXSIZE*TXSIZE*sizeof *newimage);
	gluScaleImage(GL_RGBA, width, height, GL_UNSIGNED_BYTE, image,
		TXSIZE, TXSIZE, GL_UNSIGNED_BYTE, newimage);
	free(image);
	image = newimage; width = height = TXSIZE; components = 4;
    }
    tile_image(image);
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);

    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, TSIZE,
                 TSIZE, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
    for(i = 0; i < TILES; i++) {
	int j;
	for(j = 0; j < TILES; j++) {
	    glTexSubImage2D(GL_TEXTURE_2D, 0, i*TILESIZE, j*TILESIZE, TILESIZE,
		 TILESIZE, GL_RGBA, GL_UNSIGNED_BYTE, 
		 tiles[(TILES-TSIZE/TILESIZE)/2+j][(TILES-TSIZE/TILESIZE)/2+i].data);
	}
    }
    glEnable(GL_TEXTURE_2D);

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(90.,1.,.1,10.);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glTranslatef(0.,0.,-1.0);
    glLineWidth(3.0);
    glClearColor(.25, .25, .25, .25);

    /* start at center of image */
    x = TILES*TILESIZE/2;
    y = TILES*TILESIZE/2;
}
예제 #22
0
/* Load BMF file format, function return bitmap font descriptor */
int glfLoadBMFFont(char *FName)
{
	FILE *f;
	char Header[4];
	char FontName[97];
	int i, flag;
	int LEndian;
	float tx, ty, tw, th;
	unsigned char temp, *tp;
	unsigned *texture;	/* Texture image */
	unsigned *mask;	/* Mask texture */
	int twidth, theight, tcomp;	/* Image parameters */
	float *temp_width;

	LEndian = LittleEndian();

	fopen_s(&f, FName, "rb");
	if (f == NULL) return GLF_ERROR; /* Error opening file */

	/* Get header */
	fread(Header, 1, 3, f);
	Header[3] = 0;
	if (strcmp(Header, "BMF")) return GLF_ERROR; /* Not BMF format */

	/* Get font name */
	fread(FontName, 1, 96, f);
	FontName[96] = 0;

	/* Allocate space for temp widths */
	
	temp_width = (float *)malloc(sizeof(float)*256);

	/* Read all 256 symbols information */
	for (i=0; i<256; i++)
	{
		fread(&tx, 4, 1, f);
		fread(&ty, 4, 1, f);
		fread(&tw, 4, 1, f);
		fread(&th, 4, 1, f);

		if (!LEndian)
		{
			tp = (unsigned char *)&tx;
			temp = tp[0]; tp[0] = tp[3]; tp[3] = temp;
			temp = tp[1]; tp[1] = tp[2]; tp[2] = temp;
			tp = (unsigned char *)&ty;
			temp = tp[0]; tp[0] = tp[3]; tp[3] = temp;
			temp = tp[1]; tp[1] = tp[2]; tp[2] = temp;
			tp = (unsigned char *)&tw;
			temp = tp[0]; tp[0] = tp[3]; tp[3] = temp;
			temp = tp[1]; tp[1] = tp[2]; tp[2] = temp;
			tp = (unsigned char *)&th;
			temp = tp[0]; tp[0] = tp[3]; tp[3] = temp;
			temp = tp[1]; tp[1] = tp[2]; tp[2] = temp;
		}
		
		Symbols[i].x = tx;
		Symbols[i].y = ty;
		Symbols[i].width  = tw;
		Symbols[i].height = th;
		temp_width[i] = tw;
	}

	/* Read texture image from file and build texture */
	texture = read_texture(f, &twidth, &theight, &tcomp);
	/* Generate mask texture */
	mask = texture_to_mask(texture, twidth, theight);

	/* Find unused font descriptor */
	flag = 0;
	for (i=0; i<MAX_FONTS; i++)
		if (bmf_in_use[i] == 0)
		{
			/* Initialize this font */
			bmf_in_use[i] = 1;
			bmf_curfont = i;
			flag = 1;
			break;
		}
	if (!flag) /* Not enought space for new texture */
	{
		fclose(f);
		free(texture);
		free(mask);
		free(temp_width);
		return -1;
	}

	m_widths[bmf_curfont].width = temp_width;

	/* Generating textures for font and mask */
	glGenTextures(1, &bmf_texture[bmf_curfont]);
	glGenTextures(1, &bmf_mask[bmf_curfont]);


	glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

	/* Build font texture */
	glBindTexture(GL_TEXTURE_2D, bmf_texture[bmf_curfont]);
	glTexImage2D(GL_TEXTURE_2D, 0, 3, twidth, theight, 0, GL_RGBA, GL_UNSIGNED_BYTE, texture);
	
	/* Linear filtering for better quality */
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	
	/* Build mask texture */
	glBindTexture(GL_TEXTURE_2D, bmf_mask[bmf_curfont]);
	glTexImage2D(GL_TEXTURE_2D, 0, 3, twidth, theight, 0, GL_RGBA, GL_UNSIGNED_BYTE, mask);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

	free(texture);
	free(mask);
	fclose(f);

	/* Now build list for each symbol */
	list_base[bmf_curfont] = glGenLists(256);
	for (i=0; i<256; i++)
	{
		glNewList(list_base[bmf_curfont]+i, GL_COMPILE);
		
		glBegin(GL_QUADS);
			glTexCoord2f(Symbols[i].x, Symbols[i].y); glVertex2f(0, 0);
			glTexCoord2f(Symbols[i].x+Symbols[i].width, Symbols[i].y); glVertex2f(Symbols[i].width, 0);
			glTexCoord2f(Symbols[i].x+Symbols[i].width, Symbols[i].y+Symbols[i].height); glVertex2f(Symbols[i].width, Symbols[i].height);
			glTexCoord2f(Symbols[i].x, Symbols[i].y+Symbols[i].height); glVertex2f(0, Symbols[i].height);
		glEnd();
		glTranslatef(Symbols[i].width+sym_space, 0, 0);

		glEndList();
		if (Symbols[i].height > m_max_height[bmf_curfont]) m_max_height[bmf_curfont] = Symbols[i].height;
	}
	return bmf_curfont;
}
예제 #23
0
파일: textmap.c 프로젝트: xtmacbook/SGI
texfnt *readtexfont(char *name) {
    texfnt *tfnt;
    unsigned char *image;
    unsigned char *cptr;
    unsigned short *sbuf, *sptr;
    short advancecell, xadvance;
    short llx, lly, urx, ury, ox, oy;
    int i, y, extralines;
    texchardesc *cd;
    int xsize, ysize, components;

    tfnt = (texfnt *)malloc(sizeof(texfnt));
    image = (unsigned char*)read_texture(name, &xsize, &ysize, &components);
    if(!image) {
	 fprintf(stderr,"textmap: can't open font image %s\n",name);
	 return 0;
    }
    extralines = ysize-xsize;
    if(extralines<1) {
	 fprintf(stderr,"textmap: bad input font!!\n");
	 return 0;
    }
    fb = (unsigned char *)malloc(xsize*extralines);
    sbuf = (unsigned short *)malloc(xsize*sizeof(short));
    cptr = fb;
    for(y=xsize; y<ysize; y++) {
	int x;
	for(x = 0; x < xsize; x++)
	    cptr[x] = image[4*(y*xsize+x)];
	cptr += xsize;
    }
    initget();
    tfnt->rasxsize = xsize;
    tfnt->rasysize = xsize;
    getbytes(&tfnt->charmin,sizeof(short));
/*printf("charmin 0x%x\n", tfnt->charmin);*/
    getbytes(&tfnt->charmax,sizeof(short));
    getbytes(&tfnt->pixhigh,sizeof(float));
    getbytes(&advancecell,sizeof(short));
    tfnt->nchars = tfnt->charmax-tfnt->charmin+1;
    tfnt->chars = (texchardesc *)malloc(tfnt->nchars*sizeof(texchardesc));
    tfnt->rasdata = (unsigned short *)malloc(tfnt->rasxsize*tfnt->rasysize*sizeof(long));
    sptr = tfnt->rasdata;
    for(y=0; y<tfnt->rasysize; y++) {
	int x;
	for(x = 0; x < xsize; x++) {
	    unsigned t = image[4*(y*xsize+x)];
	    sptr[x] = t | t << 8;
	}
	fixrow(sptr,tfnt->rasxsize);
	sptr += tfnt->rasxsize;
    }

    cd = tfnt->chars;
    for(i=0; i<tfnt->nchars; i++) {
	/*int c = tfnt->charmin+i;*/
	getbytes(&xadvance,sizeof(short));
	getbytes(&llx,sizeof(short));
	getbytes(&lly,sizeof(short));
	getbytes(&urx,sizeof(short));
	getbytes(&ury,sizeof(short));
	getbytes(&ox,sizeof(short));
	getbytes(&oy,sizeof(short));
	cd->movex = xadvance/(float)advancecell;

	if(llx>=0) {
	    cd->haveimage = 1;
	    cd->llx = (llx-ox)/tfnt->pixhigh;
	    cd->lly = (lly-oy)/tfnt->pixhigh;
	    cd->urx = (urx-ox+1)/tfnt->pixhigh;
	    cd->ury = (ury-oy+1)/tfnt->pixhigh;
	    cd->tllx = llx/(float)tfnt->rasxsize;
	    cd->tlly = lly/(float)tfnt->rasysize;
	    cd->turx = (urx+1)/(float)tfnt->rasxsize;
	    cd->tury = (ury+1)/(float)tfnt->rasysize;
	    cd->data[0] = cd->tllx;
	    cd->data[1] = cd->tlly;

	    cd->data[2] = cd->llx;
	    cd->data[3] = cd->lly;

	    cd->data[4] = cd->turx;
	    cd->data[5] = cd->tlly;

	    cd->data[6] = cd->urx;
	    cd->data[7] = cd->lly;

	    cd->data[8] = cd->turx;
	    cd->data[9] = cd->tury;

	    cd->data[10] = cd->urx;
	    cd->data[11] = cd->ury;

	    cd->data[12] = cd->tllx;
	    cd->data[13] = cd->tury;

	    cd->data[14] = cd->llx;
	    cd->data[15] = cd->ury;

	    cd->data[16] = cd->llx;
	    cd->data[17] = cd->lly;
	    cd->data[18] = cd->urx;
	    cd->data[19] = cd->lly;

	    cd->data[20] = cd->urx;
	    cd->data[21] = cd->ury;
	    cd->data[22] = cd->llx;
	    cd->data[23] = cd->ury;

	} else {
	    cd->haveimage = 0;
	}
	cd++;
    }
    free(fb);
    free(sbuf);
    free(image);
    return tfnt;
}
예제 #24
0
파일: fire.c 프로젝트: mox601/grafica
void
init(int argc, char *argv[]) {
    unsigned *image;
    int i, width, height, components;
    GLfloat pos[] = { 0.f, 1.f, 1.f, 0.f};

    glEnable(GL_TEXTURE_2D);
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

    if (argc < 1) {
	printf("usage: fire [textures]\n");
	printf("  e.g.,  fire flame/*\n\n"); /* */
	exit(0);
    }
    
    for(i = 0; i < argc; i++) {
	image = read_texture(argv[i], &width, &height, &components);
	if (image == NULL) {
	    fprintf(stderr, "Error: Can't load image file \"%s\".\n",
		    argv[i]);
	    exit(EXIT_FAILURE);
	} else {
	    printf("%d x %d image loaded\n", width, height);
	}
	glBindTexture(GL_TEXTURE_2D, i+1);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
	glTexImage2D(GL_TEXTURE_2D, 0, components, width,
                 height, 0, GL_RGBA, GL_UNSIGNED_BYTE, image);
	texture_count++;
    }

    glBindTexture(GL_TEXTURE_2D, 1+texture_count);
    image = read_texture("data/smoke.la", &width, &height, &components);
    if (image == NULL) {
	fprintf(stderr, "Error: Can't load image file \"%s\".\n", "smoke.la");
	exit(EXIT_FAILURE);
    }
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
    glTexImage2D(GL_TEXTURE_2D, 0, components, width,
	     height, 0, GL_RGBA, GL_UNSIGNED_BYTE, image);
    smoke = new_smoke(0.f, 0.f, 0.f, .0f, 2.5f, 0.f, 25, .4f, 1+texture_count);

    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
    glEnable(GL_TEXTURE_2D);
    glClearColor(.25f, .25f, .25f, .25f);

    glLightfv(GL_LIGHT0, GL_POSITION, pos);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(50.,1.,.1,20.);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glTranslatef(0.,0.,-5.5);
    glClearColor(.25f, .25f, .75f, .25f);

    glAlphaFunc(GL_GREATER, 0.016);
    glEnable(GL_ALPHA_TEST);

    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glEnable(GL_DEPTH_TEST);
    glEnable(GL_LIGHT0);
    glEnable(GL_NORMALIZE);
}
예제 #25
0
파일: vapor.c 프로젝트: mox601/grafica
void init(char *filename) {
    static GLfloat plane_mat[] = { 1.f, 1.f, .2f, 1.f };
    static unsigned *image;
    static int width, height, components, i;
    if (filename) {
	image = read_texture(filename, &width, &height, &components);
	if (image == NULL) {
	    fprintf(stderr, "Error: Can't load image file \"%s\".\n",
		    filename);
	    exit(EXIT_FAILURE);
	} else {
	    printf("%d x %d image loaded\n", width, height);
	}
	if (components != 2 && components != 4) {
	    printf("must be an rgba or la image\n");
	    exit(EXIT_FAILURE);
	}
	for(i = 0; i < width*height; i++)
		image[i] = image[i] | 0xffffff00;
    } else {
	int i, j;
	unsigned char *img;
	components = 4; width = height = 512;
	image = (unsigned *) malloc(width*height*sizeof(unsigned));
	img = (unsigned char *)image;
	for (j = 0; j < height; j++)
	    for (i = 0; i < width; i++) {
		int w2 = width/2, h2 = height/2;
		if (i & 32)
		    img[4*(i+j*width)+0] = 0xff;
		else
		    img[4*(i+j*width)+1] = 0xff;
		if (j&32)
		    img[4*(i+j*width)+2] = 0xff;
		if ((i-w2)*(i-w2) + (j-h2)*(j-h2) > 64*64 &&
		    (i-w2)*(i-w2) + (j-h2)*(j-h2) < 300*300) img[4*(i+j*width)+3] = 0xff;
	    }

    }
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    glTexImage2D(GL_TEXTURE_2D, 0, components, width,
                 height, 0, GL_RGBA, GL_UNSIGNED_BYTE, image);
    glEnable(GL_TEXTURE_2D);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(50.,1.,.1,10.);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glTranslatef(0.,0.,-5.5);

    glEnable(GL_LIGHT0);
    glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, plane_mat);

    glClearColor(0.1, 0.1, 0.6, 1.0);
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glEnable(GL_ALPHA_TEST);
    glAlphaFunc(GL_GREATER, 0./255.);

    glEnable(GL_DEPTH_TEST);
}
예제 #26
0
파일: snow.c 프로젝트: xtmacbook/SGI
int
main(int argc, char *argv[])
{
    unsigned *cloud;
    int texcomps, texwid, texht;

    GLUquadricObj *sphere;

    /* start and end of particles */
    static GLfloat begin[] = {0.f, -25.f, 0.f};
    static GLfloat   end[] = {0.f,-100.f, 0.f};
    static GLfloat fogcolor[] = {.4f, .4f, .4f, 1.f};

    glutInitWindowSize(winwid, winht);
    glutInit(&argc, argv);
    if(argc > 1)
    {
	char *args = argv[1];
	int done = GL_FALSE;
	while(!done)
	{
	    switch(*args)
	    {
	    case 's': /* single buffer */
		printf("Single Buffered\n");
		dblbuf = GL_FALSE;
		break;
	    case '-': /* do nothing */
		break;
	    case 0:
		done = GL_TRUE;
		break;
	    }
	    args++;
	}
    }
    if(dblbuf)
	glutInitDisplayMode(GLUT_RGBA|GLUT_DEPTH|GLUT_STENCIL|GLUT_DOUBLE);
    else
	glutInitDisplayMode(GLUT_RGBA|GLUT_DEPTH|GLUT_STENCIL);

    (void)glutCreateWindow("snow demo");

    glutDisplayFunc(redraw);
    glutReshapeFunc(reshape);
    glutMouseFunc(mouse);
    glutMotionFunc(motion);
    glutKeyboardFunc(key);
    glutIdleFunc(idle);

    glutCreateMenu(menu);
    glutAddMenuEntry("Toggle Overcast (o, O)", OVERCAST);
    glutAddMenuEntry("Toggle Fog (f, F)", FOG);
    glutAddMenuEntry("Toggle Snow (s, S)", SNOW);
    glutAddMenuEntry("Bigger Flakes (+)", BIGGER);
    glutAddMenuEntry("Smaller Flakes (-)", SMALLER);
    glutAddMenuEntry("Reset Flake Size to One (r, R)", RESETSIZE);
    glutAddMenuEntry("Toggle Point Antialiasing (a, A)", ANTIALIAS);
    glutAddMenuEntry("Snow Blending (b, B)", BLEND);
    glutAddMenuEntry("Exit Program", EXIT);
    glutAttachMenu(GLUT_RIGHT_BUTTON);

    printf("OpenGL Version %s\n", glGetString(GL_VERSION));

    /* draw a perspective scene */
    glMatrixMode(GL_PROJECTION);
    glFrustum(-5., 5., -5., 5., 10., 1000.); 
    glMatrixMode(GL_MODELVIEW);
    updateMV();

    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

    /* turn on features */
    glEnable(GL_DEPTH_TEST);

    glEnable(GL_LIGHTING);
    glEnable(GL_LIGHT0);

    /* place light 0 in the right place */
    glLightfv(GL_LIGHT0, GL_POSITION, lightpos);

    glClearColor(0.f, 0.f, 1.f, 1.f);
    glFogfv(GL_FOG_COLOR, fogcolor);
    glFogi(GL_FOG_MODE, GL_LINEAR);
    glFogf(GL_FOG_START, -200.f);
    glFogf(GL_FOG_END, 200.f);
    glHint(GL_FOG_HINT, GL_NICEST);


    glEnable(GL_COLOR_MATERIAL);
    glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);

    /* makes texturing faster, and looks better than GL_LINEAR */
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

    glNewList(LIGHT, GL_COMPILE);
    glDisable(GL_LIGHTING);
    sphere = gluNewQuadric();
    glColor3f(.7f, .2f, .7f);
    gluSphere(sphere, 5.f, 10, 10);
    gluDeleteQuadric(sphere);
    glEnable(GL_LIGHTING);
    glEndList();

    

    /* 10 X 20; vary size with transforms */
    /* one corner of house on origin; bottom on xz plane */
    glNewList(HOUSE, GL_COMPILE);
    glBegin(GL_QUADS);
    /* walls of house */
    glColor3f(1.f, 1.f, 0.f);
    /* front */
    glNormal3f( 0.f, 0.f, 1.f);
    glVertex3i( 0, 0, 0);
    glVertex3i(10, 0, 0);
    glVertex3i(10,10, 0);
    glVertex3i( 0,10, 0);
    /* back */
    glNormal3f( 0.f, 0.f, -1.f);
    glVertex3i( 0, 0, -20);
    glVertex3i( 0,10, -20);
    glVertex3i(10,10, -20);
    glVertex3i(10, 0, -20);
    /* left */
    glNormal3f(-1,  0.f,   0.f);
    glVertex3i( 0,  0,   0);
    glVertex3i( 0, 10,   0);
    glVertex3i( 0, 10, -20);
    glVertex3i( 0,  0, -20);
    /* right */
    glNormal3f( 1.f,  0.f,   0.f);
    glVertex3i(10,  0,   0);
    glVertex3i(10,  0, -20);
    glVertex3i(10, 10, -20);
    glVertex3i(10, 10,   0);
    /* roof of house */
    glColor3f(.8f, .1f, .1f);
    /* left top */
    glNormal3f(-.707f, .707f, 0.f);
    glVertex3i( 0, 10,   0);
    glVertex3i( 5, 15,   0);
    glVertex3i( 5, 15, -20);
    glVertex3i( 0, 10, -20);
    /* right top */
    glNormal3f( .707f, .707f, 0.f);
    glVertex3i(10, 10,   0);
    glVertex3i(10, 10, -20);
    glVertex3i( 5, 15, -20);
    glVertex3i( 5, 15,   0);
    glEnd();

    glBegin(GL_TRIANGLES);
    /* front */
    glNormal3f( 0.f,  0.f, 1.f);
    glVertex3i( 0, 10, 0);
    glVertex3i(10, 10, 0);
    glVertex3i( 5, 15, 0);
    /* back */
    glNormal3f( 0.f,  0.f,  -1.f);
    glVertex3i( 0, 10, -20);
    glVertex3i( 5, 15, -20);
    glVertex3i(10, 10, -20);
    glEnd();
    glEndList();

    glEnable(GL_CULL_FACE);
    /* load pattern for current 2d texture */

    cloud = read_texture("../../data/clouds.bw",
			    &texwid, &texht, &texcomps);

    gluBuild2DMipmaps(GL_TEXTURE_2D, GL_LUMINANCE, texwid, texht, GL_RGBA,
		      GL_UNSIGNED_BYTE, cloud);

    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_BLEND);

    free(cloud);
    initpart(&psys, begin, end, 200, 6000);
    updateptr = updatepart0;

    CHECK_ERROR("main()");
    glutMainLoop();

    return 0;
}
예제 #27
0
파일: cloud.c 프로젝트: mox601/grafica
void
init(char *filename) {
    GLfloat cloud_color[4] = { 1., 1., 1., 0., };
    GLfloat fog_color[4], fog_density = 0.05, density, far_cull;
    unsigned *image;
    int width, height, components;
    if (filename) {
	image = read_texture(filename, &width, &height, &components);
	if (image == NULL) {
	    fprintf(stderr, "Error: Can't load image file \"%s\".\n",
		    filename);
	    exit(EXIT_FAILURE);
	} else {
	    printf("%d x %d image loaded\n", width, height);
	}
	if (components != 1) {
	    printf("warning: texture should be a bw image (single component)\n");
	}
    } else {
	int i, j;
	unsigned char *img;
	components = 4; width = height = 512;
	image = (unsigned *) malloc(width*height*sizeof(unsigned));
	img = (unsigned char *)image;
	for (j = 0; j < height; j++)
	    for (i = 0; i < width; i++) {
		int w2 = width/2, h2 = height/2;
		if (i & 32)
		    img[4*(i+j*width)+0] = 0xff;
		else
		    img[4*(i+j*width)+1] = 0xff;
		if (j&32)
		    img[4*(i+j*width)+2] = 0xff;
		if ((i-w2)*(i-w2) + (j-h2)*(j-h2) > 64*64 &&
		    (i-w2)*(i-w2) + (j-h2)*(j-h2) < 300*300) img[4*(i+j*width)+3] = 0xff;
	    }

    }
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_BLEND);
    glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, cloud_color);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    glTexImage2D(GL_TEXTURE_2D, 0, components, width,
                 height, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                 image);
    glEnable(GL_TEXTURE_2D);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(50.,1.,.1,far_cull = 10.);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glTranslatef(0.,0.,-5.5);

    density = 1.- expf(-5.5 * fog_density * fog_density *
			      far_cull * far_cull);

#define MAX(a,b) ((a) > (b) ? (a) : (b))
#define MIN(a,b) ((a) < (b) ? (a) : (b))
    density = MAX(MIN(density, 1.), 0.);

    fog_color[0] = .23 + density *.57;
    fog_color[1] = .35 + density *.45;
    fog_color[2] = .78 + density *.22;

    glClearColor(fog_color[0], fog_color[1], fog_color[2], 1.f);

    glFogi(GL_FOG_MODE, GL_EXP2);
    glFogf(GL_FOG_DENSITY, fog_density);
    glFogfv(GL_FOG_COLOR, fog_color);
    if (fog_density > 0)
	glEnable(GL_FOG);
}
예제 #28
0
void init(char *filename) {
    GLfloat fog_color[4], fog_density = 0.05, density, far_cull;
    unsigned *image;
    int width, height, components;
    if (filename) {
	image = read_texture(filename, &width, &height, &components);
	if (image == NULL) {
	    fprintf(stderr, "Error: Can't load image file \"%s\".\n",
		    filename);
	    exit(EXIT_FAILURE);
	} else {
	    printf("%d x %d image loaded\n", width, height);
	}
	if (components != 1 && components != 2) {
	    printf("must be a l or la image\n");
	    exit(EXIT_FAILURE);
	}
	if (components == 1) {
	    /* hack for RE */
	    int i;
	    GLubyte *p = (GLubyte *)image;
	    for(i = 0; i < width*height; i++) {
		p[i*4+3] = p[i*4+0];
	    }
	    components = 2;
	}
    } else {
	int i, j;
	unsigned char *img;
	components = 4; width = height = 512;
	image = (unsigned *) malloc(width*height*sizeof(unsigned));
	img = (unsigned char *)image;
	for (j = 0; j < height; j++)
	    for (i = 0; i < width; i++) {
		int w2 = width/2, h2 = height/2;
		if (i & 32)
		    img[4*(i+j*width)+0] = 0xff;
		else
		    img[4*(i+j*width)+1] = 0xff;
		if (j&32)
		    img[4*(i+j*width)+2] = 0xff;
		if ((i-w2)*(i-w2) + (j-h2)*(j-h2) > 64*64 &&
		    (i-w2)*(i-w2) + (j-h2)*(j-h2) < 300*300) img[4*(i+j*width)+3] = 0xff;
	    }

    }
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    glTexImage2D(GL_TEXTURE_2D, 0, components, width,
                 height, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                 image);
    /*glEnable(GL_TEXTURE_2D);*/
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(50.,1.,.1,far_cull = 10.);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glTranslatef(0.,0.,-5.5);

    density = 1.- expf(-5.5 * fog_density * fog_density *
			      far_cull * far_cull);

#define MAX(a,b) ((a) > (b) ? (a) : (b))
#define MIN(a,b) ((a) < (b) ? (a) : (b))
    density = MAX(MIN(density, 1.), 0.);

    fog_color[0] = .23*.2 + density *.57*.2;
    fog_color[1] = .35*.2 + density *.45*.2;
    fog_color[2] = .78*.5 + density *.22*.2;

    glClearColor(fog_color[0], fog_color[1], fog_color[2], 1.f);

    glFogi(GL_FOG_MODE, GL_EXP2);
    glFogf(GL_FOG_DENSITY, fog_density);
    glFogfv(GL_FOG_COLOR, fog_color);
    if (fog_density > 0)
	glEnable(GL_FOG);
    glLineWidth(2.0f);
    glEnable(GL_LINE_SMOOTH);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glPointSize(10.f);
    glEnable(GL_POINT_SMOOTH);
    glHint(GL_POINT_SMOOTH_HINT, GL_NICEST);
}
예제 #29
0
GLubyte *
loadtex3d(int *texwid, int *texht, int *texdepth, int *texcomps)
{
    char *filename;
    GLubyte *tex3ddata;
    GLuint *texslice; /* 2D slice of 3D texture */
    GLint max3dtexdims; /* maximum allowed 3d texture dimension */
    GLint newval;
    int i;

    /* load 3D texture data */
    filename = (char*)malloc(sizeof(char) * 
			     strlen("../data/skull/skullXX.la"));

    tex3ddata = (GLubyte *)malloc(Texwid * Texht * Texdepth * 
				  4 * sizeof(GLubyte));
    for(i = 0; i < Texdepth; i++)
    {
	glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
	sprintf(filename, "../data/skull/skull%d.la", i);
	/* read_texture reads as RGBA */
	texslice = read_texture(filename, texwid, texht, texcomps);

	if(!texslice)
	{
	    fprintf(stderr, "Couldn't read texture file skull%d.1a\n", i);
	    exit -1;
	}
	memcpy(&tex3ddata[i * Texwid * Texht * 4],  /* copy in a slice */
	       texslice, 
	       Texwid * Texht * 4 * sizeof(GLubyte));
	free(texslice);

    }
    free(filename);

    *texdepth = Texdepth;

#ifdef GL_EXT_texture3D
    glGetIntegerv(GL_MAX_3D_TEXTURE_SIZE_EXT, &max3dtexdims);
    fprintf(stderr, "Maximum 3d texture size: %d\n", max3dtexdims);
#endif

    /* adjust width */
    newval = *texwid;
    if(*texwid > max3dtexdims)
	newval = max3dtexdims;
    if(NOTPOW2(*texwid))
        newval = makepow2(*texwid);
    fprintf(stderr, "Texture width: %d Adjusted texture width: %d\n", *texwid, newval);
    if(newval != *texwid)
    {
	glPixelStorei(GL_UNPACK_ROW_LENGTH, *texwid);
	glPixelStorei(GL_UNPACK_SKIP_PIXELS, (*texwid - newval)/2);
	*texwid = newval;
    }

    /* adjust height */
    newval = *texht;
    if(*texht > max3dtexdims)
	newval = max3dtexdims;
    if(NOTPOW2(*texht))
        newval = makepow2(*texht);
    fprintf(stderr, "Texture height: %d Adjusted texture height: %d\n", *texht, newval);
    if(*texht > newval)
    {
#ifdef GL_EXT_texture3D
	glPixelStorei(GL_UNPACK_IMAGE_HEIGHT_EXT, *texht);
#endif
	glPixelStorei(GL_UNPACK_SKIP_ROWS, (*texht - newval)/2);
	*texht = newval;
    }

    /* adjust depth */
    newval = *texdepth;
    if(*texdepth > max3dtexdims)
	newval = max3dtexdims;
    if(NOTPOW2(*texdepth))
        newval = makepow2(*texdepth);
    fprintf(stderr, "Texture depth: %d Adjusted texture depth: %d\n", *texdepth, newval);
    if(*texdepth > newval)
    {
	*texdepth = newval;
    }
    return tex3ddata;
}
예제 #30
0
void init(char *filename) {
    static unsigned *image;
    static int width, height, components;
    if (filename) {
	image = read_texture(filename, &width, &height, &components);
	if (image == NULL) {
	    fprintf(stderr, "Error: Can't load image file \"%s\".\n",
		    filename);
	    exit(EXIT_FAILURE);
	} else {
	    printf("%d x %d image loaded\n", width, height);
	}
	if (components != 2 && components != 4) {
	    printf("must be an RGBA or LA image\n");
	    exit(EXIT_FAILURE);
	}
    } else {
	int i, j;
	unsigned char *img;
	components = 4; width = height = 512;
	image = (unsigned *) malloc(width*height*sizeof(unsigned));
	img = (unsigned char *)image;
	for (j = 0; j < height; j++)
	    for (i = 0; i < width; i++) {
		int w2 = width/2, h2 = height/2;
		if (i & 32)
		    img[4*(i+j*width)+0] = 0xff;
		else
		    img[4*(i+j*width)+1] = 0xff;
		if (j&32)
		    img[4*(i+j*width)+2] = 0xff;
		if ((i-w2)*(i-w2) + (j-h2)*(j-h2) > 64*64 &&
		    (i-w2)*(i-w2) + (j-h2)*(j-h2) < 300*300) img[4*(i+j*width)+3] = 0xff;
	    }

    }
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexImage2D(GL_TEXTURE_2D, 0, components, width,
                 height, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                 image);
    glEnable(GL_TEXTURE_2D);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(50.,1.,.1,20.);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glTranslatef(0.,0.,-5.5);
    glClearColor(.25f, .25f, .75f, .25f);

    glAlphaFunc(GL_GREATER, 0.016);
    glEnable(GL_ALPHA_TEST);

    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glEnable(GL_DEPTH_TEST);

    glEnable(GL_LIGHT0);
    glEnable(GL_COLOR_MATERIAL);
    glEnable(GL_NORMALIZE);
}