Newsgroup: it.comp.lang.c++
Titolo: Problema di Grafica con Devc++

Salve a Tutti, sono un neofita del C++ ,sto studiando sul "Guida al
C++" di Russel Winder della Jackson Libri  , l'ho trovato chiaro ma
non spiega come usare le librerie grafiche , come compilatore ho
istallato il Devc++ 4.01 e lavoro conWin98 e vorrei graficare una
funzione.Come posso fare ?Ho visto di avere la libreria OpenGl ma non
ho la documentazione e se volessi studiare le caratteristiche di tutte
le classi dovrei leggermi i sorgenti di tutti gli headers , a me
basterebbe sapere come disegnare un punto e una linea per iniziare.
Grazie per la vostra attenzione !
Saluti
Felix

 wrote in message
news:3f1af439...@powernews.libero.it...

Per la grafica e l'OpenGL (o per le DirectX) questo non e' il posto giusto.
Il C++ standard fa uso di grafica spartana ed al limite ti fa stampare il
carattere punto ma non il pixel!
Percio' ti consiglio di postare su it.comp.programmare.win32 in seguito.
Per dei tutorials vai qua:
Questo parte da 0 ed e' in italiano:
http://www.multiplayer.it/itaprogaming/docs&tuts/opengl/nehe/default.asp
poi...
http://www.gametutorials.com/Tutorials/OpenGL/OpenGL_Pg1.htm
http://www.codeproject.com/opengl/
http://www.codeguru.com/opengl/index.shtml
Maurus


I tutorial di NeHe sono spettacolari!!!
Se vuoi provare qualche cosa con la grafica (anche 3D con le OpenGL e sono
molto semplici)
Il tutorial è in inglese (ma trovi poca documentazione in italiano su questo
argomento).
http://nehe.gamedev.net/
Ciauz
--
Alberto

 wrote:
Grazie per gli utili suggerimenti purtroppo il codice che e' fornito
nelle lezioni e' concepito per il VisualC , ho provato a farlo girare
sul compilatore Devc++4.01 ma mi da messaggi di errore il primo dei
quali riguarda il file glu.h  a questo punto mi sono chiesto se avessi
la libreria bacata ma non sono un esperto e quindi sarei grato a chi
volesse indicarmi errori nel file sorgente glu.h  che sottopongo alla
vostra attenzione:
/*++ BUILD Version: 0004    // Increment this if a change has global
effects
Copyright (c) 1985-95, Microsoft Corporation
Module Name:
    glu.h
Abstract:
    Procedure declarations, constant definitions and macros for the
OpenGL
    Utility Library.
--*/
#ifndef __glu_h__
#ifndef __GLU_H__
#define __glu_h__
#define __GLU_H__
#include <GL/gl.h>
#ifdef __cplusplus
extern "C" {     (QUI' VIENE INDICATO UN ERRORE DI SINTASSI PRIMA
DELLA C)
#endif
/*
** Copyright 1991-1993, Silicon Graphics, Inc.
** All Rights Reserved.
** 
** This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics,
Inc.;
** the contents of this file may not be disclosed to third parties,
copied or
** duplicated in any form, in whole or in part, without the prior
written
** permission of Silicon Graphics, Inc.
** 
** RESTRICTED RIGHTS LEGEND:
** Use, duplication or disclosure by the Government is subject to
restrictions
** as set forth in subdivision (c)(1)(ii) of the Rights in Technical
Data
** and Computer Software clause at DFARS 
252.227-7013
, and/or in
similar or
** successor clauses in the FAR, DOD or NASA FAR Supplement.
Unpublished -
** rights reserved under the Copyright Laws of the United States.
*/
/*
** Return the error string associated with a particular error code.
** This will return 0 for an invalid error code.
**
** The generic function prototype that can be compiled for ANSI or
Unicode
** is defined as follows:
**
** LPCTSTR APIENTRY gluErrorStringWIN (GLenum errCode);
*/
#ifdef UNICODE
#define gluErrorStringWIN(errCode) ((LPCSTR)
gluErrorUnicodeStringEXT(errCode))
#else
#define gluErrorStringWIN(errCode) ((LPCWSTR) gluErrorString(errCode))
#endif
const GLubyte* APIENTRY gluErrorString (
    GLenum   errCode);
const wchar_t* APIENTRY gluErrorUnicodeStringEXT (
    GLenum   errCode);
const GLubyte* APIENTRY gluGetString (
    GLenum   name);
void APIENTRY gluOrtho2D (
    GLdouble left, 
    GLdouble right, 
    GLdouble bottom, 
    GLdouble top);
void APIENTRY gluPerspective (
    GLdouble fovy, 
    GLdouble aspect, 
    GLdouble zNear, 
    GLdouble zFar);
void APIENTRY gluPickMatrix (
    GLdouble x, 
    GLdouble y, 
    GLdouble width, 
    GLdouble height, 
    GLint    viewport[4]);
void APIENTRY gluLookAt (
    GLdouble eyex, 
    GLdouble eyey, 
    GLdouble eyez, 
    GLdouble centerx, 
    GLdouble centery, 
    GLdouble centerz, 
    GLdouble upx, 
    GLdouble upy, 
    GLdouble upz);
int APIENTRY gluProject (
ll    GLdouble        objx, 
    GLdouble        objy, 
    GLdouble        objz,  
    const GLdouble  modelMatrix[16], 
    const GLdouble  projMatrix[16], 
    const GLint     viewport[4], 
    GLdouble        *winx, 
    GLdouble        *winy, 
    GLdouble        *winz);
int APIENTRY gluUnProject (
    GLdouble       winx, 
    GLdouble       winy, 
    GLdouble       winz, 
    const GLdouble modelMatrix[16], 
    const GLdouble projMatrix[16], 
    const GLint    viewport[4], 
    GLdouble       *objx, 
    GLdouble       *objy, 
    GLdouble       *objz);
int APIENTRY gluScaleImage (
    GLenum      format, 
    GLint       widthin, 
    GLint       heightin, 
    GLenum      typein, 
    const void  *datain, 
    GLint       widthout, 
    GLint       heightout, 
    GLenum      typeout, 
    void        *dataout);
int APIENTRY gluBuild1DMipmaps (
    GLenum      target, 
    GLint       components, 
    GLint       width, 
    GLenum      format, 
    GLenum      type, 
    const void  *data);
int APIENTRY gluBuild2DMipmaps (
    GLenum      target, 
    GLint       components, 
    GLint       width, 
    GLint       height, 
    GLenum      format, 
    GLenum      type, 
    const void  *data);
#ifdef __cplusplus
class GLUnurbs;
class GLUquadric;
class GLUtesselator;
/* backwards compatibility: */
typedef class GLUnurbs GLUnurbsObj;
typedef class GLUquadric GLUquadricObj;
typedef class GLUtesselator GLUtesselatorObj;
typedef class GLUtesselator GLUtriangulatorObj;
#else
typedef struct GLUnurbs GLUnurbs;
typedef struct GLUquadric GLUquadric;
typedef struct GLUtesselator GLUtesselator;
/* backwards compatibility: */
typedef struct GLUnurbs GLUnurbsObj;
typedef struct GLUquadric GLUquadricObj;
typedef struct GLUtesselator GLUtesselatorObj;
typedef struct GLUtesselator GLUtriangulatorObj;
#endif
GLUquadric* APIENTRY gluNewQuadric (void);
void APIENTRY gluDeleteQuadric (
    GLUquadric          *state);
void APIENTRY gluQuadricNormals (
    GLUquadric          *quadObject, 
    GLenum              normals);
void APIENTRY gluQuadricTexture (
    GLUquadric          *quadObject, 
    GLboolean           textureCoords);
void APIENTRY gluQuadricOrientation (
    GLUquadric          *quadObject, 
    GLenum              orientation);
void APIENTRY gluQuadricDrawStyle (
    GLUquadric          *quadObject, 
    GLenum              drawStyle);
void APIENTRY gluCylinder (
    GLUquadric          *qobj, 
    GLdouble            baseRadius, 
    GLdouble            topRadius, 
    GLdouble            height, 
    GLint               slices, 
    GLint               stacks);
void APIENTRY gluDisk (
    GLUquadric          *qobj, 
    GLdouble            innerRadius, 
    GLdouble            outerRadius, 
    GLint               slices, 
    GLint               loops);
void APIENTRY gluPartialDisk (
    GLUquadric          *qobj, 
    GLdouble            innerRadius, 
    GLdouble            outerRadius, 
    GLint               slices, 
    GLint               loops, 
    GLdouble            startAngle, 
    GLdouble            sweepAngle);
void APIENTRY gluSphere (
    GLUquadric          *qobj, 
    GLdouble            radius, 
    GLint               slices, 
    GLint               stacks);
void APIENTRY gluQuadricCallback (
    GLUquadric          *qobj, 
    GLenum              which, 
    void                (CALLBACK* fn)());
GLUtesselator* APIENTRY  gluNewTess(          
    void );
void APIENTRY  gluDeleteTess(       
    GLUtesselator       *tess );
void APIENTRY  gluTessBeginPolygon( 
    GLUtesselator       *tess,
    void                *polygon_data );
void APIENTRY  gluTessBeginContour( 
    GLUtesselator       *tess );
void APIENTRY  gluTessVertex(       
    GLUtesselator       *tess,
    GLdouble            coords[3], 
    void                *data );
void APIENTRY  gluTessEndContour(   
    GLUtesselator       *tess );
void APIENTRY  gluTessEndPolygon(   
    GLUtesselator       *tess );
void APIENTRY  gluTessProperty(     
    GLUtesselator       *tess,
    GLenum              which, 
    GLdouble            value );
 
void APIENTRY  gluTessNormal(       
    GLUtesselator       *tess, 
    GLdouble            x,
    GLdouble            y, 
    GLdouble            z );
void APIENTRY  gluTessCallback(     
    GLUtesselator       *tess,
    GLenum              which, 
    void                (CALLBACK *fn)());
void APIENTRY  gluGetTessProperty(  
    GLUtesselator       *tess,
    GLenum              which, 
    GLdouble            *value );
 
GLUnurbs* APIENTRY gluNewNurbsRenderer (void);
void APIENTRY gluDeleteNurbsRenderer (
    GLUnurbs            *nobj);
void APIENTRY gluBeginSurface (
    GLUnurbs            *nobj);
void APIENTRY gluBeginCurve (
    GLUnurbs            *nobj);
void APIENTRY gluEndCurve (
    GLUnurbs            *nobj);
void APIENTRY gluEndSurface (
    GLUnurbs            *nobj);
void APIENTRY gluBeginTrim (
    GLUnurbs            *nobj);
void APIENTRY gluEndTrim (
    GLUnurbs            *nobj);
void APIENTRY gluPwlCurve (
    GLUnurbs            *nobj, 
    GLint               count, 
    GLfloat             *array, 
    GLint               stride, 
    GLenum              type);
void APIENTRY gluNurbsCurve (
    GLUnurbs            *nobj, 
    GLint               nknots, 
    GLfloat             *knot, 
    GLint               stride, 
    GLfloat             *ctlarray, 
    GLint               order, 
    GLenum              type);
void APIENTRY 
gluNurbsSurface(     
    GLUnurbs            *nobj, 
    GLint               sknot_count, 
    float               *sknot, 
    GLint               tknot_count, 
    GLfloat             *tknot, 
    GLint               s_stride, 
    GLint               t_stride, 
    GLfloat             *ctlarray, 
    GLint               sorder, 
    GLint               torder, 
    GLenum              type);
void APIENTRY 
gluLoadSamplingMatrices (
    GLUnurbs            *nobj, 
    const GLfloat       modelMatrix[16], 
    const GLfloat       projMatrix[16], 
    const GLint         viewport[4] );
void APIENTRY 
gluNurbsProperty (
    GLUnurbs            *nobj, 
    GLenum              property, 
    GLfloat             value );
void APIENTRY 
gluGetNurbsProperty (
    GLUnurbs            *nobj, 
    GLenum              property, 
    GLfloat             *value );
void APIENTRY 
gluNurbsCallback (
    GLUnurbs            *nobj, 
    GLenum              which, 
    void                (CALLBACK* fn)() );
/****           Callback function prototypes    ****/
/* gluQuadricCallback */
typedef void (CALLBACK* GLUquadricErrorProc) (GLenum);
/* gluTessCallback */
typedef void (CALLBACK* GLUtessBeginProc)        (GLenum);
typedef void (CALLBACK* GLUtessEdgeFlagProc)     (GLboolean);
typedef void (CALLBACK* GLUtessVertexProc)       (void *);
typedef void (CALLBACK* GLUtessEndProc)          (void);
typedef void (CALLBACK* GLUtessErrorProc)        (GLenum);
typedef void (CALLBACK* GLUtessCombineProc)      (GLdouble[3],
                                                  void*[4], 
                                                  GLfloat[4],
                                                  void** );
typedef void (CALLBACK* GLUtessBeginDataProc)    (GLenum, void *);
typedef void (CALLBACK* GLUtessEdgeFlagDataProc) (GLboolean, void *);
typedef void (CALLBACK* GLUtessVertexDataProc)   (void *, void *);
typedef void (CALLBACK* GLUtessEndDataProc)      (void *);
typedef void (CALLBACK* GLUtessErrorDataProc)    (GLenum, void *);
typedef void (CALLBACK* GLUtessCombineDataProc)  (GLdouble[3],
                                                  void*[4], 
                                                  GLfloat[4],
                                                  void**,
                                                  void* );
/* gluNurbsCallback */
typedef void (CALLBACK* GLUnurbsErrorProc)   (GLenum);
/****           Generic constants               ****/
/* Version */
#define GLU_VERSION_1_1                 1
#define GLU_VERSION_1_2                 1
/* Errors: (return value 0 = no error) */
#define GLU_INVALID_ENUM        100900
#define GLU_INVALID_VALUE       100901
#define GLU_OUT_OF_MEMORY       100902
#define GLU_INCOMPATIBLE_GL_VERSION     100903
/* StringName */
#define GLU_VERSION             100800
#define GLU_EXTENSIONS          100801
/* Boolean */
#define GLU_TRUE                GL_TRUE
#define GLU_FALSE               GL_FALSE
/****           Quadric constants               ****/
/* QuadricNormal */
#define GLU_SMOOTH              100000
#define GLU_FLAT                100001
#define GLU_NONE                100002
/* QuadricDrawStyle */
#define GLU_POINT               100010
#define GLU_LINE                100011
#define GLU_FILL                100012
#define GLU_SILHOUETTE          100013
/* QuadricOrientation */
#define GLU_OUTSIDE             100020
#define GLU_INSIDE              100021
/* Callback types: */
/*      GLU_ERROR               100103 */
/****           Tesselation constants           ****/
#define GLU_TESS_MAX_COORD              1.0e150
/* TessProperty */
#define GLU_TESS_WINDING_RULE           100140
#define GLU_TESS_BOUNDARY_ONLY          100141
#define GLU_TESS_TOLERANCE              100142
/* TessWinding */
#define GLU_TESS_WINDING_ODD            100130
#define GLU_TESS_WINDING_NONZERO        100131
#define GLU_TESS_WINDING_POSITIVE       100132
#define GLU_TESS_WINDING_NEGATIVE       100133
#define GLU_TESS_WINDING_ABS_GEQ_TWO    100134
/* TessCallback */
#define GLU_TESS_BEGIN          100100  /* void (CALLBACK*)(GLenum
type)  */
#define GLU_TESS_VERTEX         100101  /* void (CALLBACK*)(void
*data) */
#define GLU_TESS_END            100102  /* void (CALLBACK*)(void)
*/
#define GLU_TESS_ERROR          100103  /* void (CALLBACK*)(GLenum
errno) */
#define GLU_TESS_EDGE_FLAG      100104  /* void (CALLBACK*)(GLboolean
boundaryEdge)  */
#define GLU_TESS_COMBINE        100105  /* void (CALLBACK*)(GLdouble
coords[3],
                                                            void
*data[4],
                                                            GLfloat
weight[4],
                                                            void
**dataOut)     */
#define GLU_TESS_BEGIN_DATA     100106  /* void (CALLBACK*)(GLenum
type,  
                                                            void
*polygon_data) */
#define GLU_TESS_VERTEX_DATA    100107  /* void (CALLBACK*)(void
*data, 
                                                            void
*polygon_data) */
#define GLU_TESS_END_DATA       100108  /* void (CALLBACK*)(void
*polygon_data) */
#define GLU_TESS_ERROR_DATA     100109  /* void (CALLBACK*)(GLenum
errno, 
                                                            void
*polygon_data) */
#define GLU_TESS_EDGE_FLAG_DATA 100110  /* void (CALLBACK*)(GLboolean
boundaryEdge,
                                                            void
*polygon_data) */
#define GLU_TESS_COMBINE_DATA   100111  /* void (CALLBACK*)(GLdouble
coords[3],
                                                            void
*data[4],
                                                            GLfloat
weight[4],
                                                            void
**dataOut,
                                                            void
*polygon_data) */
/* TessError */
#define GLU_TESS_ERROR1     100151
#define GLU_TESS_ERROR2     100152
#define GLU_TESS_ERROR3     100153
#define GLU_TESS_ERROR4     100154
#define GLU_TESS_ERROR5     100155
#define GLU_TESS_ERROR6     100156
#define GLU_TESS_ERROR7     100157
#define GLU_TESS_ERROR8     100158
#define GLU_TESS_MISSING_BEGIN_POLYGON  GLU_TESS_ERROR1
#define GLU_TESS_MISSING_BEGIN_CONTOUR  GLU_TESS_ERROR2
#define GLU_TESS_MISSING_END_POLYGON    GLU_TESS_ERROR3
#define GLU_TESS_MISSING_END_CONTOUR    GLU_TESS_ERROR4
#define GLU_TESS_COORD_TOO_LARGE        GLU_TESS_ERROR5
#define GLU_TESS_NEED_COMBINE_CALLBACK  GLU_TESS_ERROR6
/****           NURBS constants                 ****/
/* NurbsProperty */
#define GLU_AUTO_LOAD_MATRIX    100200
#define GLU_CULLING             100201
#define GLU_SAMPLING_TOLERANCE  100203
#define GLU_DISPLAY_MODE        100204
#define GLU_PARAMETRIC_TOLERANCE        100202
#define GLU_SAMPLING_METHOD             100205
#define GLU_U_STEP                      100206
#define GLU_V_STEP                      100207
/* NurbsSampling */
#define GLU_PATH_LENGTH                 100215
#define GLU_PARAMETRIC_ERROR            100216
#define GLU_DOMAIN_DISTANCE             100217
/* NurbsTrim */
#define GLU_MAP1_TRIM_2         100210
#define GLU_MAP1_TRIM_3         100211
/* NurbsDisplay */
/*      GLU_FILL                100012 */
#define GLU_OUTLINE_POLYGON     100240
#define GLU_OUTLINE_PATCH       100241
/* NurbsCallback */
/*      GLU_ERROR               100103 */
/* NurbsErrors */
#define GLU_NURBS_ERROR1        100251
#define GLU_NURBS_ERROR2        100252
#define GLU_NURBS_ERROR3        100253
#define GLU_NURBS_ERROR4        100254
#define GLU_NURBS_ERROR5        100255
#define GLU_NURBS_ERROR6        100256
#define GLU_NURBS_ERROR7        100257
#define GLU_NURBS_ERROR8        100258
#define GLU_NURBS_ERROR9        100259
#define GLU_NURBS_ERROR10       100260
#define GLU_NURBS_ERROR11       100261
#define GLU_NURBS_ERROR12       100262
#define GLU_NURBS_ERROR13       100263
#define GLU_NURBS_ERROR14       100264
#define GLU_NURBS_ERROR15       100265
#define GLU_NURBS_ERROR16       100266
#define GLU_NURBS_ERROR17       100267
#define GLU_NURBS_ERROR18       100268
#define GLU_NURBS_ERROR19       100269
#define GLU_NURBS_ERROR20       100270
#define GLU_NURBS_ERROR21       100271
#define GLU_NURBS_ERROR22       100272
#define GLU_NURBS_ERROR23       100273
#define GLU_NURBS_ERROR24       100274
#define GLU_NURBS_ERROR25       100275
#define GLU_NURBS_ERROR26       100276
#define GLU_NURBS_ERROR27       100277
#define GLU_NURBS_ERROR28       100278
#define GLU_NURBS_ERROR29       100279
#define GLU_NURBS_ERROR30       100280
#define GLU_NURBS_ERROR31       100281
#define GLU_NURBS_ERROR32       100282
#define GLU_NURBS_ERROR33       100283
#define GLU_NURBS_ERROR34       100284
#define GLU_NURBS_ERROR35       100285
#define GLU_NURBS_ERROR36       100286
#define GLU_NURBS_ERROR37       100287
/****           Backwards compatibility for old tesselator
****/
void APIENTRY   gluBeginPolygon( GLUtesselator *tess );
void APIENTRY   gluNextContour(  GLUtesselator *tess, 
                                 GLenum        type );
void APIENTRY   gluEndPolygon(   GLUtesselator *tess );
/* Contours types -- obsolete! */
#define GLU_CW          100120
#define GLU_CCW         100121
#define GLU_INTERIOR    100122
#define GLU_EXTERIOR    100123
#define GLU_UNKNOWN     100124
/* Names without "TESS_" prefix */
#define GLU_BEGIN       GLU_TESS_BEGIN
#define GLU_VERTEX      GLU_TESS_VERTEX
#define GLU_END         GLU_TESS_END
#define GLU_ERROR       GLU_TESS_ERROR
#define GLU_EDGE_FLAG   GLU_TESS_EDGE_FLAG
#ifdef __cplusplus
}
#endif
#endif /* __GLU_H__ */
#endif /* __glu_h__ */
Se non vi sono errori e' possibile fare delle modifiche sul file
sorgente che voglio compilare per renderlo compatibile col compilatore
Devc++4.01?
Grazie per la vostra attenzione!