static void MyColorBoxFaces( TQ3BoxData *myBoxData )
{
TQ3ColorRGB faceColor ;
short face ;
// sanity check - you need to have set up
// the face attribute set for the box data
// before calling this.
if( myBoxData->faceAttributeSet == NULL )
return ;
// make each face of a box a different color
for( face = 0; face < 6; face++) {
myBoxData->faceAttributeSet[face] = Q3AttributeSet_New();
switch( face ) {
case 0:
faceColor.r = 1.0F;
faceColor.g = 0.0F;
faceColor.b = 0.0F;
break;
case 1:
faceColor.r = 0.0F;
faceColor.g = 1.0F;
faceColor.b = 0.0F;
break;
case 2:
faceColor.r = 0.0F;
faceColor.g = 0.0F;
faceColor.b = 1.0F;
break;
case 3:
faceColor.r = 1.0F;
faceColor.g = 1.0F;
faceColor.b = 0.0F;
break;
case 4:
faceColor.r = 1.0F;
faceColor.g = 0.0F;
faceColor.b = 1.0F;
break;
case 5:
faceColor.r = 0.0F;
faceColor.g = 1.0F;
faceColor.b = 1.0F;
break;
}
Q3AttributeSet_Add(myBoxData->faceAttributeSet[face], kQ3AttributeTypeDiffuseColor, &faceColor);
}
}
static CQ3ObjectRef MakeDefaultAttSet()
{
CQ3ObjectRef theAtts( Q3AttributeSet_New() );
if (theAtts.isvalid())
{
TQ3ColorRGB defaultColor = { 1.0f, 1.0f, 1.0f };
Q3AttributeSet_Add( theAtts.get(), kQ3AttributeTypeDiffuseColor, &defaultColor );
}
return theAtts;
}
// build a polygon that is a CIELab refrence
TQ3GeometryObject LogoWin2::NewPolyGCIELabRef(void)
{
TQ3GeometryObject geometryObject = NULL;
//TQ3TriGridData ciepoly;
TQ3PolygonData ciepoly;
TQ3Vertex3D *vertices;
long i;
double Lxy[4];
double lab[4];
McoStatus state;
TQ3ColorRGB color = { 0.0, 0.0, 0.0 };
double big_ab,big_rgb;
TQ3Param2D param2D;
ciepoly.numVertices = NumCIExyzRef;
ciepoly.vertices = (TQ3Vertex3D *) NewPtr (NumCIExyzRef * sizeof(TQ3Vertex3D));
if (ciepoly.vertices == NULL) return NULL;
vertices = ciepoly.vertices;
ciepoly.polygonAttributeSet = NULL;
for (i=0; i<NumCIExyzRef; i++)
{
Lxy[0] = 50;
Lxy[1] = CIExyzRef2[i*4+1];
Lxy[2] = CIExyzRef2[i*4+2];
vertices[i].point.x = Lxy[1];
vertices[i].point.y = Lxy[2];
vertices[i].point.z = 0.5;
sxyztolab(Lxy,lab);
big_ab = bigger(fabs(lab[1]),fabs(lab[2]));
if (big_ab>127)
{
lab[1] = lab[1]*127/big_ab;
lab[2] = lab[2]*127/big_ab;
}
labtonxyzinplace(lab,1);
state = xyztorgb->compute(lab, monitor_z, 1);
if(state != MCO_SUCCESS)
return NULL;
big_rgb = bigger(lab[1],bigger(lab[2],lab[3]));
if (big_rgb>255)
{
lab[0] = lab[0]*255/big_rgb;
lab[1] = lab[1]*255/big_rgb;
lab[2] = lab[2]*255/big_rgb;
}
color.r = lab[0]/256;
color.g = lab[1]/256;
color.b = lab[2]/256;
vertices[i].attributeSet = Q3AttributeSet_New();
Q3AttributeSet_Add(vertices[i].attributeSet, kQ3AttributeTypeDiffuseColor, &color);
param2D.u = Lxy[1]*1.37;
param2D.v = Lxy[2]*1.1;
Q3AttributeSet_Add(vertices[i].attributeSet, kQ3AttributeTypeShadingUV, ¶m2D);
}
geometryObject = Q3Polygon_New(&ciepoly);
for (i = 0; i < NumCIExyzRef; i++)
Q3Object_Dispose(vertices[i].attributeSet);
DisposePtr ((char *) vertices);
return geometryObject;
}
TQ3GeometryObject LogoWin2::NewLogoObject(void)
{
TQ3GeometryObject geometryObject = NULL;
TQ3TriGridData data;
TQ3Vertex3D *vertices;
TQ3Vertex3D norms;
unsigned long i,j,k;
float uuValue, vvValue,
uuMin, uuMax, uuStep,
vvMin, vvMax, vvStep,
radius;
TQ3Boolean hasUVAttributes;
TQ3Param2D param2D;
TQ3ColorRGB color = { 0.0, 0.0, 0.0 };
double *gammutSurface;
double lab[4];
McoStatus status;
double x,y,z,X,Y,Z;
// uuValue is an angle used to revolve the cross section about the y axis
// vvValue is an angle used to generate each half circular cross section
uuMin = 0.0;
uuMax = 360.0;
vvMin = - 90.0;
vvMax = 90.0;
uuStep = 12.0;
vvStep = 12.0;
radius = 1.0;
// Setup TQ3TriGridData
data.numRows = (unsigned long) ((vvMax - vvMin) / vvStep) + 1;
data.numColumns = (unsigned long) ((uuMax - uuMin) / uuStep) + 1;
data.facetAttributeSet = NULL;
data.triGridAttributeSet= NULL;
data.vertices = (TQ3Vertex3D *) NewPtr (data.numRows * data.numColumns * sizeof(TQ3Vertex3D));
if (data.vertices == NULL) return NULL;
// Set trigrid vertices and shading UVs, if it hasUVAttributes
vertices = data.vertices;
i = 0;
for (vvValue = vvMin; vvValue <= vvMax; vvValue += vvStep)
{
for (uuValue = uuMax; uuValue >= uuMin; uuValue -= uuStep)
{
vertices[i].point.x = uMath_Cos_Deg(vvValue) * uMath_Cos_Deg(uuValue) * radius;
vertices[i].point.y = 1.5*uMath_Sin_Deg(vvValue) * radius;
vertices[i].point.z = uMath_Cos_Deg(vvValue) * uMath_Sin_Deg(uuValue) * radius;
param2D.u = 1.0 - ((uuValue - uuMin) / (uuMax - uuMin));
param2D.v = (vvValue - vvMin) / (vvMax - vvMin);
vertices[i].attributeSet = Q3AttributeSet_New();
Q3AttributeSet_Add(vertices[i].attributeSet, kQ3AttributeTypeShadingUV, ¶m2D);
norms.point.x = uMath_Cos_Deg(vvValue) * uMath_Cos_Deg(uuValue) * (radius+1);
norms.point.y = 1.5*uMath_Sin_Deg(vvValue)*(radius+1);
norms.point.z = uMath_Cos_Deg(vvValue) * uMath_Sin_Deg(uuValue) * (radius+1);
Q3AttributeSet_Add(vertices[i].attributeSet, kQ3AttributeTypeNormal, &norms);
i++;
}
}
geometryObject = Q3TriGrid_New (&data);
for (i = 0; i < data.numRows * data.numColumns; i++)
Q3Object_Dispose(vertices[i].attributeSet);
DisposePtr ((char *) vertices);
return geometryObject;
}
static TQ3GroupObject QD3DSupport_GroundInit(TQ3ShaderObject groundShaderObject)
{
long i;
TQ3GeometryObject polygonObj = NULL;
TQ3GroupPosition myGroupPosition;
TQ3GroupObject groundGroup;
TQ3PolygonData polygonData;
TQ3Vertex3D vertices[kNumGrndTextureVertices] = {0,-3,GROUND_SIZE,nil,
GROUND_SIZE,-3,GROUND_SIZE,nil,
GROUND_SIZE,-3,-GROUND_SIZE,nil,
0,-3,-GROUND_SIZE,nil};
TQ3AttributeSet attribs[kNumGrndTextureVertices] = {NULL, NULL, NULL, NULL};
float ambient = 1.0F;
TQ3Param2D uv[kNumGrndTextureVertices] = {0,0,1,0,1,1,0,1};
if (groundShaderObject == NULL)
{
return NULL;
}
groundGroup = Q3OrderedDisplayGroup_New();
if (groundGroup == NULL)
{
return NULL;
}
/* ADD TEXTURE SHADER OBJECT TO GROUP */
myGroupPosition = Q3Group_AddObject(groundGroup, groundShaderObject);
if ( myGroupPosition == nil )
{
Utils_DisplayErrorMsg("Q3Group_AddObject failed!");
goto outOfMem;
}
Q3Object_Dispose(groundShaderObject);
/* CREATE VERTICES */
for (i=0; i < kNumGrndTextureVertices; i++)
{
attribs[i] = Q3AttributeSet_New();
if( attribs[i] == NULL )
{
Utils_DisplayErrorMsg("Attribute set creation failed!");
goto outOfMem;
}
Q3AttributeSet_Add(attribs[i], kQ3AttributeTypeShadingUV, &uv[i]);
vertices[i].attributeSet = attribs[i];
}
/* CREATE NEW POLYGON OBJECT */
polygonData.numVertices = kNumGrndTextureVertices;
polygonData.vertices = vertices;
polygonData.polygonAttributeSet = nil;
polygonObj = Q3Polygon_New(&polygonData);
if( polygonObj == NULL )
{
Utils_DisplayErrorMsg("Polygon_New failed!");
goto outOfMem;
}
for (i=0; i < kNumGrndTextureVertices; i++)
{
Q3Object_Dispose(attribs[i]);
attribs[i] = NULL;
}
myGroupPosition = Q3Group_AddObject(groundGroup, polygonObj);
Q3Object_Dispose(polygonObj);
if ( myGroupPosition == nil )
{
Utils_DisplayErrorMsg("Q3Group_AddObject failed!");
goto outOfMem;
}
/* Success! */
return groundGroup;
/* Error handling */
outOfMem:
if (groundGroup)
{
Q3Object_Dispose(groundGroup);
}
for (i=0; i < kNumGrndTextureVertices; i++)
{
if( attribs[i] )
{
Q3Object_Dispose(attribs[i]);
}
}
return NULL;
}
/*!
@function IndexedLineSetV1ToObject
@abstract Attempt to convert a VRML 1 IndexedLineSet node to a Quesa object.
@param ioNode Node to convert.
@param inReader The reader object.
@result An object reference, or NULL on failure.
*/
CQ3ObjectRef IndexedLineSetV1ToObject( PolyValue& ioNode, CVRMLReader& inReader )
{
CQ3ObjectRef theObject( Q3DisplayGroup_New() );
ThrowIfNullQuesaOb_( theObject );
PolyValue::Dictionary& theDict( ioNode.GetDictionary() );
int polylineNum = 0;
// I am not going to bother with normals, so it is better not to use lighting.
CQ3ObjectRef theShader( Q3NULLIllumination_New() );
ThrowIfNullQuesaOb_( theShader );
Q3Group_AddObject( theObject.get(), theShader.get() );
// Gather data
PolyValue::IntVec pointIndices;
PolyValue::IntVec colorIndices;
GetIntVecFromField( theDict, "coordIndex", pointIndices );
GetIntVecFromField( theDict, "materialIndex", colorIndices );
StandardizeIndexVector( pointIndices );
StandardizeIndexVector( colorIndices );
const SVRML1State& theState( inReader.GetVRML1State() );
const std::vector<TQ3Point3D>& thePoints( theState.coordinate3 );
const std::vector<TQ3ColorRGB>& theColors( theState.diffuseColor );
bool isColorPerVertex( (theState.materialBinding == eVRML1Value_PER_VERTEX) or
(theState.materialBinding == eVRML1Value_PER_VERTEX_INDEXED) );
// Note: the VRML 1 spec, unlike the VRML 2 spec, indicates that colors
// can be per segment rather than per polyline. Currently I will not
// support that.
bool isColorPerPolyline( (theState.materialBinding == eVRML1Value_PER_PART) or
(theState.materialBinding == eVRML1Value_PER_PART_INDEXED) or
(theState.materialBinding == eVRML1Value_PER_FACE) or
(theState.materialBinding == eVRML1Value_PER_FACE_INDEXED) );
// Start building polylines
std::vector<TQ3Vertex3D> vertices;
std::vector<CQ3ObjectRef> vertAttSets;
for (unsigned int i = 0; i < pointIndices.size(); ++i)
{
if (pointIndices[i] < 0)
{
// FInish a PolyLine
TQ3PolyLineData polyData;
polyData.numVertices = vertices.size();
polyData.vertices = &vertices[0];
polyData.segmentAttributeSet = NULL;
CQ3ObjectRef polyAtts;
if (not theColors.empty())
{
polyAtts = GetIndexedMaterial( inReader, 0 );
if (isColorPerPolyline)
{
TQ3ColorRGB polyColor;
if (colorIndices.empty())
{
polyColor = theColors[ polylineNum ];
}
else
{
polyColor = theColors[ colorIndices[polylineNum] ];
}
Q3AttributeSet_Add( polyAtts.get(), kQ3AttributeTypeDiffuseColor,
&polyColor );
}
polyData.polyLineAttributeSet = polyAtts.get();
}
else
{
polyData.polyLineAttributeSet = NULL;
}
CQ3ObjectRef polyLine( Q3PolyLine_New( &polyData ) );
ThrowIfNullQuesaOb_( polyLine );
Q3Group_AddObject( theObject.get(), polyLine.get() );
vertices.clear();
vertAttSets.clear();
polylineNum += 1;
}
else
{
TQ3Vertex3D aVertex;
aVertex.point = thePoints[ pointIndices[i] ];
if (isColorPerVertex and (not theColors.empty()))
{
TQ3ColorRGB vertColor;
if (colorIndices.empty())
{
vertColor = theColors[ pointIndices[i] ];
}
else
{
vertColor = theColors[ colorIndices[i] ];
}
CQ3ObjectRef vertAtts( Q3AttributeSet_New() );
ThrowIfNullQuesaOb_( vertAtts );
Q3AttributeSet_Add( vertAtts.get(), kQ3AttributeTypeDiffuseColor,
&vertColor );
vertAttSets.push_back( vertAtts );
aVertex.attributeSet = vertAtts.get();
}
else
{
aVertex.attributeSet = NULL;
}
vertices.push_back( aVertex );
}
}
if (polylineNum == 0)
{
// no sense returning an empty display group
theObject = CQ3ObjectRef();
}
return theObject;
}
/*!
@function IndexedLineSetV2ToObject
@abstract Attempt to convert a VRML 2 IndexedLineSet node to a Quesa object.
@param ioNode Node to convert.
@param inReader The reader object.
@result An object reference, or NULL on failure.
*/
CQ3ObjectRef IndexedLineSetV2ToObject( PolyValue& ioNode )
{
CQ3ObjectRef theObject( Q3DisplayGroup_New() );
ThrowIfNullQuesaOb_( theObject );
// The VRML 2 spec says that lines are not lit.
CQ3ObjectRef theShader( Q3NULLIllumination_New() );
ThrowIfNullQuesaOb_( theShader );
Q3Group_AddObject( theObject.get(), theShader.get() );
PolyValue::Dictionary& theDict( ioNode.GetDictionary() );
// Gather data from fields
std::vector<TQ3Point3D> thePoints;
std::vector<TQ3ColorRGB> theColors;
PolyValue::IntVec pointIndices;
PolyValue::IntVec colorIndices;
GetNodeArray( theDict, "coord", "Coordinate", "point", thePoints );
GetNodeArray( theDict, "color", "Color", "color", theColors );
GetIntVecFromField( theDict, "coordIndex", pointIndices );
GetIntVecFromField( theDict, "colorIndex", colorIndices );
StandardizeIndexVector( pointIndices );
StandardizeIndexVector( colorIndices );
bool isColorPerVertex = true;
if (IsKeyPresent( theDict, "colorPerVertex" ))
{
PolyValue& theNode( theDict[ "colorPerVertex" ] );
if (theNode.GetType() == PolyValue::kDataTypeBool)
{
isColorPerVertex = theNode.GetBool();
}
}
// Start building polylines
std::vector<TQ3Vertex3D> vertices;
std::vector<CQ3ObjectRef> vertAttSets;
int polylineNum = 0;
for (unsigned int i = 0; i < pointIndices.size(); ++i)
{
if (pointIndices[i] < 0)
{
// FInish a PolyLine
TQ3PolyLineData polyData;
polyData.numVertices = vertices.size();
polyData.vertices = &vertices[0];
polyData.segmentAttributeSet = NULL;
CQ3ObjectRef polyAtts;
if ((not isColorPerVertex) and (not theColors.empty()))
{
TQ3ColorRGB polyColor;
if (colorIndices.empty())
{
polyColor = theColors[ polylineNum ];
}
else
{
polyColor = theColors[ colorIndices[polylineNum] ];
}
polyAtts = CQ3ObjectRef( Q3AttributeSet_New() );
ThrowIfNullQuesaOb_( polyAtts );
Q3AttributeSet_Add( polyAtts.get(), kQ3AttributeTypeDiffuseColor,
&polyColor );
polyData.polyLineAttributeSet = polyAtts.get();
}
else
{
polyData.polyLineAttributeSet = NULL;
}
CQ3ObjectRef polyLine( Q3PolyLine_New( &polyData ) );
ThrowIfNullQuesaOb_( polyLine );
Q3Group_AddObject( theObject.get(), polyLine.get() );
vertices.clear();
vertAttSets.clear();
polylineNum += 1;
}
else
{
TQ3Vertex3D aVertex;
aVertex.point = thePoints[ pointIndices[i] ];
if (isColorPerVertex and (not theColors.empty()))
{
TQ3ColorRGB vertColor;
if (colorIndices.empty())
{
vertColor = theColors[ pointIndices[i] ];
}
else
{
vertColor = theColors[ colorIndices[i] ];
}
CQ3ObjectRef vertAtts( Q3AttributeSet_New() );
ThrowIfNullQuesaOb_( vertAtts );
Q3AttributeSet_Add( vertAtts.get(), kQ3AttributeTypeDiffuseColor,
&vertColor );
vertAttSets.push_back( vertAtts );
aVertex.attributeSet = vertAtts.get();
}
else
{
aVertex.attributeSet = NULL;
}
vertices.push_back( aVertex );
}
}
if (polylineNum == 0)
{
// no sense returning an empty display group
theObject = CQ3ObjectRef();
}
return theObject;
}
