namespace x3d
{
X3DFieldDefinition* LinePropertiesFields[] =
{
&X3DFieldDefinition("metadata", FieldType_SFNode, SAIFieldAccess_inputOutput,-1),
&X3DFieldDefinition("applied", FieldType_SFBool, SAIFieldAccess_inputOutput,-1),
&X3DFieldDefinition("linetype", FieldType_SFInt32, SAIFieldAccess_inputOutput,-1),
&X3DFieldDefinition("linewidthScaleFactor", FieldType_SFFloat, SAIFieldAccess_inputOutput,-1),
/*
SFBool [in,out] applied TRUE
SFInt32 [in,out] linetype 1 [1,8)
SFFloat [in,out] linewidthScaleFactor 0 [-8,8)
SFNode [in,out] metadata NULL [X3DMetadataObject]
*/
};
NodeType LineProperties::s_nodeType("LineProperties", typeid(LineProperties), LinePropertiesFields, _countof(LinePropertiesFields));
LineProperties::LineProperties() : X3DAppearanceChildNode(&s_nodeType)
{
}
} // x3d
namespace x3d
{
X3DFieldDefinition* Layer2DFields[] =
{
&X3DFieldDefinition("addChildren", FieldType_MFNode, SAIFieldAccess_inputOnly,-1),
&X3DFieldDefinition("children", FieldType_MFNode, SAIFieldAccess_inputOutput,-1),
/*
???
*/
};
NodeType Layer2D::s_nodeType("Layer2D", typeid(Layer2D), Layer2DFields, _countof(Layer2DFields));
Layer2D::Layer2D() : X3DGroupingNode(&s_nodeType)
{
}
// virtual
void Layer2D::Draw(X3DDrawContext* pDC)
{
DrawChildren(pDC, getChildrenField());
}
} // x3d
NodeType* Anchor::GetNodeType()
{
static X3DFieldDefinition* fields[] =
{
&X3DFieldDefinition("description", FieldType_SFString, SAIFieldAccess_inputOutput, -1),//offsetof(Anchor, m_description),
&X3DFieldDefinition("parameter", FieldType_MFString, SAIFieldAccess_inputOutput, -1),//offsetof(Anchor, m_parameter),
&X3DFieldDefinition("url", FieldType_MFString, SAIFieldAccess_inputOutput, offsetof(Anchor, m_url)),
};
static NodeType nodeType("Anchor", typeid(Anchor), fields, _countof(fields), X3DGroupingNode::GetNodeType());
return &nodeType;
}
NodeType* MovieTexture::GetNodeType()
{
static X3DFieldDefinition* MovieTextureFields[] =
{
&X3DFieldDefinition("loop", FieldType_SFBool, SAIFieldAccess_inputOutput,-1),
&X3DFieldDefinition("repeatS", FieldType_SFBool, SAIFieldAccess_initializeOnly,-1),
&X3DFieldDefinition("repeatT", FieldType_SFBool, SAIFieldAccess_initializeOnly,-1),
&X3DFieldDefinition("speed", FieldType_SFFloat, SAIFieldAccess_inputOutput,-1),
&X3DFieldDefinition("startTime", FieldType_SFTime, SAIFieldAccess_inputOutput,-1),
&X3DFieldDefinition("stopTime", FieldType_SFTime, SAIFieldAccess_inputOutput,-1),
&X3DFieldDefinition("url", FieldType_MFURL, SAIFieldAccess_inputOutput,-1),
/*
SFBool [in,out] loop FALSE
SFFloat [in,out] speed 1.0 (-8,8)
SFTime [in,out] startTime 0 (-8,8)
SFTime [in,out] stopTime 0 (-8,8)
MFString [in,out] url [] [urn]
SFBool [] repeatS TRUE
SFBool [] repeatT TRUE
SFTime [out] duration_changed
SFBool [out] isActive
*/
};
static NodeType nodeType(WSTR("MovieTexture"), typeid(MovieTexture), MovieTextureFields, _countof(MovieTextureFields), X3DTexture2DNode::GetNodeType());
return &nodeType;
}
NodeType* FloatVertexAttribute::GetNodeType()
{
static X3DFieldDefinition* fields[] =
{
&X3DFieldDefinition("value", FieldType_MFFloat, SAIFieldAccess_inputOutput,-1),
&X3DFieldDefinition("name", FieldType_SFString, SAIFieldAccess_initializeOnly,-1),
&X3DFieldDefinition("numComponents", FieldType_SFInt32, SAIFieldAccess_initializeOnly,-1),
/*
SFNode [in,out] metadata NULL [X3DMetadataObject]
MFFloat [in,out] value [] (-?,?)
SFString [] name ""
SFInt32 [] numComponents 4 [1..4]
*/
};
static NodeType nodeType("FloatVertexAttribute", typeid(FloatVertexAttribute), fields, _countof(fields), X3DVertexAttributeNode::GetNodeType());
return &nodeType;
}
namespace x3d
{
X3DFieldDefinition* ProximitySensorFields[] =
{
&X3DFieldDefinition("center", FieldType_SFVec3f, SAIFieldAccess_inputOutput,-1),
&X3DFieldDefinition("enabled", FieldType_SFBool, SAIFieldAccess_inputOutput,-1),
&X3DFieldDefinition("enterTime", FieldType_SFTime, SAIFieldAccess_outputOnly,-1),
&X3DFieldDefinition("exitTime", FieldType_SFTime, SAIFieldAccess_outputOnly,-1),
&X3DFieldDefinition("isActive", FieldType_SFBool, SAIFieldAccess_outputOnly,-1),
&X3DFieldDefinition("size", FieldType_SFVec3f, SAIFieldAccess_inputOutput,-1),
&X3DFieldDefinition("orientation_changed", FieldType_SFRotation, SAIFieldAccess_outputOnly,-1),
&X3DFieldDefinition("position_changed", FieldType_SFVec3f, SAIFieldAccess_outputOnly,-1),
/*
SFVec3f [in,out] center 0 0 0 (-8,8)
SFBool [in,out] enabled TRUE
SFNode [in,out] metadata NULL [X3DMetadataObject]
SFVec3f [in,out] size 0 0 0 [0,8)
SFTime [out] enterTime
SFTime [out] exitTime
SFVec3f [out] centerOfRotation_changed
SFBool [out] isActive
SFRotation [out] orientation_changed
SFVec3f [out] position_changed
*/
};
NodeType ProximitySensor::s_nodeType(WSTR("ProximitySensor"), typeid(ProximitySensor), ProximitySensorFields, _countof(ProximitySensorFields));
ProximitySensor::ProximitySensor() : X3DEnvironmentalSensorNode(&s_nodeType)
{
// Cache pointers to relevant fields
m_center = static_cast<SFVec3f*>(getField(WSTR("center")));
m_size = static_cast<SFVec3f*>(getField(WSTR("size")));
m_enterTime = static_cast<SFTime*>(getField(WSTR("enterTime")));
m_exitTime = static_cast<SFTime*>(getField(WSTR("exitTime")));
m_isActive = static_cast<SFBool*>(getField(WSTR("isActive")));
m_orientation_changed = static_cast<SFRotation*>(getField(WSTR("orientation_changed")));
m_position_changed = static_cast<SFVec3f*>(getField(WSTR("position_changed")));
// TODO m_centerOfRotation_changed
// Set default values
m_center->m_value[0] = m_center->m_value[1] = m_center->m_value[2] = 0;
m_size->m_value[0] = m_size->m_value[1] = m_size->m_value[2] = 0;
}
ProximitySensor::~ProximitySensor()
{
}
} // x3d
namespace x3d
{
X3DFieldDefinition* QuantizationParameterFields[] =
{
&X3DFieldDefinition("colorMin", FieldType_SFFloat, SAIFieldAccess_initializeOnly,-1),
&X3DFieldDefinition("colorMax", FieldType_SFFloat, SAIFieldAccess_initializeOnly,-1),
&X3DFieldDefinition("colorNbBits", FieldType_SFInt32, SAIFieldAccess_initializeOnly,-1),
&X3DFieldDefinition("colorQuant", FieldType_SFBool, SAIFieldAccess_initializeOnly,-1),
&X3DFieldDefinition("isLocal", FieldType_SFBool, SAIFieldAccess_initializeOnly,-1),
&X3DFieldDefinition("position2DMin", FieldType_SFVec2f, SAIFieldAccess_initializeOnly,-1),
&X3DFieldDefinition("position2DMax", FieldType_SFVec2f, SAIFieldAccess_initializeOnly,-1),
&X3DFieldDefinition("position2DNbBits", FieldType_SFInt32, SAIFieldAccess_initializeOnly,-1),
&X3DFieldDefinition("position2DQuant", FieldType_SFBool, SAIFieldAccess_initializeOnly,-1),
&X3DFieldDefinition("sizeMin", FieldType_SFFloat, SAIFieldAccess_initializeOnly,-1),
&X3DFieldDefinition("sizeMax", FieldType_SFFloat, SAIFieldAccess_initializeOnly,-1),
&X3DFieldDefinition("sizeNbBits", FieldType_SFInt32, SAIFieldAccess_initializeOnly,-1),
&X3DFieldDefinition("sizeQuant", FieldType_SFBool, SAIFieldAccess_initializeOnly,-1),
/*
field SFBool isLocal FALSE
field SFBool position3DQuant FALSE
field SFVec3f position3DMin -., -., -.
field SFVec3f position3DMax +., +., +.
field SFInt32 position3DNbBits 16
field SFBool position2DQuant FALSE
field SFVec2f position2DMin -., -.
field SFVec2f position2DMax +., +.
field SFInt32 position2DNbBits 16
field SFBool drawOrderQuant TRUE
field SFVec3f drawOrderMin -.
field SFVec3f drawOrderMax +.
field SFInt32 drawOrderNbBits 8
field SFBool colorQuant TRUE
field SFFloat colorMin 0.0
field SFFloat colorMax 1.0
field SFInt32 colorNbBits 8
field SFBool textureCoordinateQuant TRUE
field SFFloat textureCoordinateMin 0.0
field SFFloat textureCoordinateMax 1.0
field SFInt32 textureCoordinateNbBits 16
field SFBool angleQuant TRUE
field SFFloat angleMin 0.0
field SFFloat angleMax 2¶
field SFInt32 angleNbBits 16
field SFBool scaleQuant FALSE
field SFFloat scaleMin 0.0
field SFFloat scaleMax +.
field SFInt32 scaleNbBits 8
field SFBool keyQuant TRUE
field SFFloat keyMin 0.0
field SFFloat keyMax 1.0
field SFInt32 keyNbBits 8
field SFBool normalQuant TRUE
field SFInt32 normalNbBits 8
field SFBool sizeQuant FALSE
field SFFloat sizeMin 0.0
field SFFloat sizeMax +.
field SFInt32 sizeNbBits 8
field SFBool useEfficientCoding FALSE
*/
};
NodeType QuantizationParameter::s_nodeType(WSTR("QuantizationParameter"), typeid(QuantizationParameter), QuantizationParameterFields, _countof(QuantizationParameterFields));
QuantizationParameter::QuantizationParameter() : X3DChildNode(&s_nodeType)
{
// Cache pointers to relevant fields
m_isLocal = static_cast<SFBool*>(getField(WSTR("isLocal")));
m_position2DQuant = static_cast<SFBool*>(getField(WSTR("position2DQuant")));
m_position2DMin = static_cast<SFVec2f*>(getField(WSTR("position2DMin")));
m_position2DMax = static_cast<SFVec2f*>(getField(WSTR("position2DMax")));
m_position2DNbBits = static_cast<SFInt32*>(getField(WSTR("position2DNbBits")));
m_colorQuant = static_cast<SFBool*>(getField(WSTR("colorQuant")));
m_colorMin = static_cast<SFFloat*>(getField(WSTR("colorMin")));
m_colorMax = static_cast<SFFloat*>(getField(WSTR("colorMax")));
m_colorNbBits = static_cast<SFInt32*>(getField(WSTR("colorNbBits")));
m_sizeQuant = static_cast<SFBool*>(getField(WSTR("sizeQuant")));
m_sizeMin = static_cast<SFFloat*>(getField(WSTR("sizeMin")));
m_sizeMax = static_cast<SFFloat*>(getField(WSTR("sizeMax")));
m_sizeNbBits = static_cast<SFInt32*>(getField(WSTR("sizeNbBits")));
// Set defaults
m_isLocal->m_value = false;
m_position2DQuant->m_value = false;
// TODO min,max (+- infinite, how to express?)
m_position2DMin->m_value[0] = FLT_MIN;
m_position2DMin->m_value[1] = FLT_MIN;
m_position2DMax->m_value[0] = FLT_MAX;
m_position2DMax->m_value[1] = FLT_MAX;
m_position2DNbBits->m_value = 16;
m_colorQuant->m_value = true;
m_colorMin->m_value = 0;
m_colorMax->m_value = 1;
m_colorNbBits->m_value = 8;
m_sizeQuant->m_value = false;
m_sizeMin->m_value = 0;
//m_sizeMax->m_value = 1; ????
m_sizeNbBits->m_value = 8;
}
QuantizationParameter::~QuantizationParameter()
{
}
} // x3d
namespace x3d
{
#if 0
X3DFieldDefinition Box::Fields[] =
{
X3DFieldDefinition(WSTR("metadata"), FieldType_SFNode, SAIFieldAccess_inputOutput, offsetof(Box, m_metadata)),
X3DFieldDefinition("size", FieldType_SFVec3f, SAIFieldAccess_initializeOnly, offsetof(Box, m_size)),
/*
SFVec3f [] size 2 2 2 (0,8)
*/
};
NodeType Box::s_nodeType("Box", typeid(Box), Fields, _countof(Fields));
#endif
TypedX3DFieldDefinition<SFVec3f>* Box::get_sizeFieldDef()
{
static TypedX3DFieldDefinition<SFVec3f> size("size", SAIFieldAccess_initializeOnly, offsetof(Box, m_size), Vec3f(2,2,2));
return &size;
}
NodeType* Box::GetNodeType()
{
static X3DFieldDefinition* fields[] =
{
get_sizeFieldDef(),
};
static NodeType nodeType("Box", typeid(Box), fields, _countof(fields), X3DGeometryNode::GetNodeType());
return &nodeType;
}
NodeType* Box::nodeType(GetNodeType());
Box::Box() : X3DGeometryNode(GetNodeType()), m_size(new SFVec3f(get_sizeFieldDef(), this, Vec3f(2,2,2)))
{
// m_vertexBuffer = NULL;
// m_size = NULL;
// Cache pointers to relevant fields
// m_size = static_cast<SFVec3f*>(getField(WSTR("size")));
ASSERT(m_size);
// Set defaults
// m_size->m_value[0] = m_size->m_value[1] = m_size->m_value[2] = 2;
}
Vec3f Box::getSize3f()
{
return getSize();
}
void Box::setSize3f(Vec3f size)
{
setSize(size);
}
void Box::Draw(X3DDrawContext* pDC, X3DTextureNodeImplImpl* pTextureNode)
{
if (!m_shape.IsValid(pDC->m_renderContext))
{
m_shape.Create(pDC->m_renderContext, getSize());
}
m_shape.Draw(pDC->m_renderContext);
/*
// Obtain the technique
ID3D10EffectTechnique* g_pTechnique;
g_pTechnique = g_pEffect->GetTechniqueByName("Render");
*/
#if 0
LDraw::vector3f s = m_size->m_value;
if (true)
{
if (m_vertexBuffer == NULL)
{
VERTEX_XYZ_NORMAL vertices[4*4];
vertices[0].position = LDraw::vector3f(-s[0]/2, -s[1]/2, s[2]/2);
vertices[0].normal = LDraw::vector3f(0, 0, 1);
vertices[1].position = LDraw::vector3f(s[0]/2, -s[1]/2, s[2]/2);
vertices[1].normal = LDraw::vector3f(0, 0, 1);
vertices[2].position = LDraw::vector3f(s[0]/2, s[1]/2, s[2]/2);
vertices[2].normal = LDraw::vector3f(0, 0, 1);
vertices[3].position = LDraw::vector3f(-s[0]/2, s[1]/2, s[2]/2);
vertices[3].normal = LDraw::vector3f(0, 0, 1);
m_vertexBuffer = pDC->m_pGraphics3D->CreateVertexBuffer(sizeof(VERTEX_XYZ_NORMAL)*4*4, vertices, GL_STATIC_DRAW);
// pDC->m_pGraphics3D->BindBuffer(GL_ARRAY_BUFFER, m_buffer);
// pDC->m_pGraphics3D->BufferData(GL_ARRAY_BUFFER, sizeof(VERTEX_XYZ_NORMAL)*4*4, vertices, 0);
LDraw::VertexDeclElement elements[] =
{
{"POSITION", 0, 0, LDraw::DECLTYPE_FLOAT3, 0},
{"NORMAL", 0, 3*4, LDraw::DECLTYPE_FLOAT3, 0},
};
m_vertexDeclaration = pDC->m_pGraphics3D->CreateVertexDeclaration(elements, 2);
}
pDC->m_pGraphics3D->SetVertexDeclaration(m_vertexDeclaration);
pDC->m_pGraphics3D->SetVertexBuffer(0, m_vertexBuffer, 0, sizeof(VERTEX_XYZ_NORMAL));
// pDC->m_pGraphics3D->InterleavedArrays(GL_N3F_V3F, 0, NULL);
pDC->m_pGraphics3D->DrawArrays(GL_TRIANGLE_FAN, 0, 4);
// pDC->m_pGraphics3D->DrawArrays(GL_TRIANGLE_FAN, 4, 4);
// pDC->m_pGraphics3D->DrawArrays(GL_TRIANGLE_FAN, 8, 4);
// pDC->m_pGraphics3D->DrawArrays(GL_TRIANGLE_FAN, 12, 4);
}
else
{
#if 0
pDC->m_pGraphics3D->glBegin(GL_QUADS);
// front (cw)
/*
glVertex3d(-m_boxSize[0]/2, -m_boxSize[1]/2, m_boxSize[2]/2);
glVertex3d(m_boxSize[0]/2, -m_boxSize[1]/2, m_boxSize[2]/2);
glVertex3d(m_boxSize[0]/2, m_boxSize[1]/2, m_boxSize[2]/2);
glVertex3d(-m_boxSize[0]/2, m_boxSize[1]/2, m_boxSize[2]/2);
*/
// front (ccw)
/*
lglNormal(pDC->m_pGraphics, vector3f(-s[0]/2, -s[1]/2, s[2]/2),
vector3f(s[0]/2, -s[1]/2, s[2]/2),
vector3f(s[0]/2, s[1]/2, s[2]/2));
*/
pDC->m_pGraphics3D->glNormalf(0, 0, 1);
pDC->m_pGraphics3D->glTexCoordf(0, 0);
pDC->m_pGraphics3D->glVertexf(-s[0]/2, -s[1]/2, s[2]/2);
pDC->m_pGraphics3D->glTexCoordf(1, 0);
pDC->m_pGraphics3D->glVertexf(s[0]/2, -s[1]/2, s[2]/2);
pDC->m_pGraphics3D->glTexCoordf(1, 1);
pDC->m_pGraphics3D->glVertexf(s[0]/2, s[1]/2, s[2]/2);
pDC->m_pGraphics3D->glTexCoordf(0, 1);
pDC->m_pGraphics3D->glVertexf(-s[0]/2, s[1]/2, s[2]/2);
/*
lglNormal(pDC->m_pGraphics, vector3f(-s[0]/2, -s[1]/2, s[2]/2),
vector3f(-s[0]/2, s[1]/2, s[2]/2),
vector3f(s[0]/2, s[1]/2, s[2]/2));
pDC->m_pGraphics3D->glTexCoord(0, 0);
pDC->m_pGraphics3D->glVertex(-s[0]/2, -s[1]/2, s[2]/2);
pDC->m_pGraphics3D->glTexCoord(1, 0);
pDC->m_pGraphics3D->glVertex(-s[0]/2, s[1]/2, s[2]/2);
pDC->m_pGraphics3D->glTexCoord(1, 1);
pDC->m_pGraphics3D->glVertex(s[0]/2, s[1]/2, s[2]/2);
pDC->m_pGraphics3D->glTexCoord(0, 1);
pDC->m_pGraphics3D->glVertex(s[0]/2, -s[1]/2, s[2]/2);
*/
// back (ccw)
pDC->m_pGraphics3D->glNormalf(0, 0, -1);
/*
lglNormal(pDC->m_pGraphics, LDraw::vector3f(-s[0]/2, -s[1]/2, -s[2]/2),
LDraw::vector3f(-s[0]/2, s[1]/2, -s[2]/2),
LDraw::vector3f(s[0]/2, s[1]/2, -s[2]/2));
*/
pDC->m_pGraphics3D->glTexCoordf(0, 0);
pDC->m_pGraphics3D->glVertexf(-s[0]/2, -s[1]/2, -s[2]/2);
pDC->m_pGraphics3D->glTexCoordf(1, 0);
pDC->m_pGraphics3D->glVertexf(-s[0]/2, s[1]/2, -s[2]/2);
pDC->m_pGraphics3D->glTexCoordf(1, 1);
pDC->m_pGraphics3D->glVertexf(s[0]/2, s[1]/2, -s[2]/2);
pDC->m_pGraphics3D->glTexCoordf(0, 1);
pDC->m_pGraphics3D->glVertexf(s[0]/2, -s[1]/2, -s[2]/2);
// left side
/*
lglNormal(pDC->m_pGraphics, LDraw::vector3f(-s[0]/2, -s[1]/2, s[2]/2),
LDraw::vector3f(-s[0]/2, -s[1]/2, -s[2]/2),
LDraw::vector3f(-s[0]/2, s[1]/2, -s[2]/2));
*/
pDC->m_pGraphics3D->glNormalf(-1, 0, 0);
pDC->m_pGraphics3D->glTexCoordf(0, 0);
pDC->m_pGraphics3D->glVertexf(-s[0]/2, s[1]/2, s[2]/2);
pDC->m_pGraphics3D->glTexCoordf(1, 0);
pDC->m_pGraphics3D->glVertexf(-s[0]/2, s[1]/2, -s[2]/2);
pDC->m_pGraphics3D->glTexCoordf(1, 1);
pDC->m_pGraphics3D->glVertexf(-s[0]/2, -s[1]/2, -s[2]/2);
pDC->m_pGraphics3D->glTexCoordf(0, 1);
pDC->m_pGraphics3D->glVertexf(-s[0]/2, -s[1]/2, s[2]/2);
// right side
/*
lglNormal(pDC->m_pGraphics, LDraw::vector3f(s[0]/2, -s[1]/2, s[2]/2),
LDraw::vector3f(s[0]/2, -s[1]/2, -s[2]/2),
LDraw::vector3f(s[0]/2, s[1]/2, -s[2]/2));
*/
pDC->m_pGraphics3D->glNormalf(1, 0, 0);
pDC->m_pGraphics3D->glTexCoordf(0, 0);
pDC->m_pGraphics3D->glVertexf(s[0]/2, -s[1]/2, s[2]/2);
pDC->m_pGraphics3D->glTexCoordf(1, 0);
pDC->m_pGraphics3D->glVertexf(s[0]/2, -s[1]/2, -s[2]/2);
pDC->m_pGraphics3D->glTexCoordf(1, 1);
pDC->m_pGraphics3D->glVertexf(s[0]/2, s[1]/2, -s[2]/2);
pDC->m_pGraphics3D->glTexCoordf(0, 1);
pDC->m_pGraphics3D->glVertexf(s[0]/2, s[1]/2, s[2]/2);
// top side
/*
lglNormal(pDC->m_pGraphics, LDraw::vector3f(-s[0]/2, -s[1]/2, -s[2]/2),
LDraw::vector3f(-s[0]/2, -s[1]/2, s[2]/2),
LDraw::vector3f(s[0]/2, -s[1]/2, s[2]/2));
*/
pDC->m_pGraphics3D->glNormalf(0, -1, 0);
pDC->m_pGraphics3D->glTexCoordf(0, 0);
pDC->m_pGraphics3D->glVertexf(-s[0]/2, -s[1]/2, -s[2]/2);
pDC->m_pGraphics3D->glTexCoordf(1, 0);
pDC->m_pGraphics3D->glVertexf(-s[0]/2, -s[1]/2, s[2]/2);
pDC->m_pGraphics3D->glTexCoordf(1, 1);
pDC->m_pGraphics3D->glVertexf(s[0]/2, -s[1]/2, s[2]/2);
pDC->m_pGraphics3D->glTexCoordf(0, 1);
pDC->m_pGraphics3D->glVertexf(s[0]/2, -s[1]/2, -s[2]/2);
// bottom side
/*
lglNormal(pDC->m_pGraphics, LDraw::vector3f(-s[0]/2, s[1]/2, -s[2]/2),
LDraw::vector3f(-s[0]/2, s[1]/2, s[2]/2),
LDraw::vector3f(s[0]/2, s[1]/2, s[2]/2));
*/
pDC->m_pGraphics3D->glNormalf(0, 1, 0);
pDC->m_pGraphics3D->glTexCoordf(0, 0);
pDC->m_pGraphics3D->glVertexf(-s[0]/2, s[1]/2, -s[2]/2);
pDC->m_pGraphics3D->glTexCoordf(1, 0);
pDC->m_pGraphics3D->glVertexf(-s[0]/2, s[1]/2, s[2]/2);
pDC->m_pGraphics3D->glTexCoordf(1, 1);
pDC->m_pGraphics3D->glVertexf(s[0]/2, s[1]/2, s[2]/2);
pDC->m_pGraphics3D->glTexCoordf(0, 1);
pDC->m_pGraphics3D->glVertexf(s[0]/2, s[1]/2, -s[2]/2);
pDC->m_pGraphics3D->glEnd();
#endif
}
#endif
}
// X3DBoundedImplImpl
BoundingBox Box::CalculateBoundingBox(gm::matrix4f& transform)
{
m_computedBBoxValid = true;
// m_computedBBoxSize = getSize();
return BoundingBox(Vec3f(0,0,0), getSize());
/*
m_boxCenter[0] = 0;
m_boxCenter[1] = 0;
m_boxCenter[2] = 0;
*/
}
void Box::AddShapeDesc(physx::PxRigidActor* actor)
{
Vec3f size = getSize();
#if defined(PX_PHYSICS_NXPHYSICS_API)
physx::PxMaterial* mMaterial;
mMaterial = Gui::gPhysics->createMaterial(0.5f, 0.5f, 0.1f); //static friction, dynamic friction, restitution
physx::PxBoxGeometry geometry(size[0]*0.5f, size[1]*0.5f, size[1]*0.5f);
actor->createShape(geometry, *mMaterial);
#if 0
physx::PxRigidBodyExt::updateMassAndInertia(actor, sphereDensity);
#endif
#endif
}
} // x3d
namespace x3d
{
X3DFieldDefinition* IndexedFaceSet2DFields[] =
{
&X3DFieldDefinition("color", FieldType_SFNode, SAIFieldAccess_inputOutput,-1),
&X3DFieldDefinition("colorPerVertex", FieldType_SFBool, SAIFieldAccess_initializeOnly,-1),
&X3DFieldDefinition("convex", FieldType_SFBool, SAIFieldAccess_initializeOnly,-1),
&X3DFieldDefinition("coord", FieldType_SFNode, SAIFieldAccess_inputOutput,-1),
&X3DFieldDefinition("coordIndex", FieldType_MFInt32, SAIFieldAccess_initializeOnly,-1),
&X3DFieldDefinition("texCoordIndex", FieldType_MFInt32, SAIFieldAccess_initializeOnly,-1),
/*
eventIn MFInt32 set_colorIndex
eventIn MFInt32 set_coordIndex
eventIn MFInt32 set_texCoordIndex
exposedField SFNode color NULL
exposedField SFNode coord NULL
exposedField SFNode texCoord NULL
field MFInt32 colorIndex []
field SFBool colorPerVertex TRUE
field SFBool convex TRUE
field MFInt32 coordIndex []
field MFInt32 texCoordIndex []
*/
};
NodeType IndexedFaceSet2D::s_nodeType(WSTR("IndexedFaceSet2D"), typeid(IndexedFaceSet2D), IndexedFaceSet2DFields, _countof(IndexedFaceSet2DFields));
IndexedFaceSet2D::IndexedFaceSet2D() : X3DGeometryNode(&s_nodeType)
{
// Cache pointers to relevant fields
m_coord = static_cast<SFNode*>(getField(WSTR("coord")));
m_coordIndex = static_cast<MFInt32*>(getField(WSTR("coordIndex")));
m_convex = static_cast<SFBool*>(getField(WSTR("convex")));
// Set defaults
// m_convex->m_value = true;
}
IndexedFaceSet2D::~IndexedFaceSet2D()
{
}
void IndexedFaceSet2D::Draw(X3DDrawContext* pDC, X3DTextureNodeImplImpl* pTextureNode)
{
ASSERT(0);
#if 0
if (pDC->m_pGraphics2D)
{
Coordinate2D* coordinate2D = dynamic_cast<Coordinate2D*>(m_coord->m_value);
if (coordinate2D)
{
MFVec2f* point = coordinate2D->getPoint();
//MFVec2f* texpoint;
//MFInt32* useTexCoordIndex;
/*
if (texcoordinate)
{
texpoint = static_cast<MFVec2f*>(static_cast<CLTextureCoordinate*>(texcoordinate.p)->m_point);
if (texCoordIndex->m_items.GetSize() > 0)
{
if (texCoordIndex->m_items.GetSize() != coordIndex->m_items.GetSize())
{
// TODO, mark this object with some kind of error flag
// m_bError = TRUE
return; // Error
}
useTexCoordIndex = texCoordIndex;
}
else
{
useTexCoordIndex = coordIndex;
}
}
*/
LDraw::Brush* pBrush = pDC->m_pBrush;
if (m_convex->m_value != false)
{
if (m_coordIndex->m_items.GetSize() == 0)
{
// LDraw::GraphicsPath path;
/*
for (int i = 0; i < point->m_items.GetSize(); i++)
{
gmVector2& v = point->m_items[i];
glVertex2(v);
}
*/
pDC->m_pGraphics2D->FillPolygon(pBrush, (LDraw::PointF*)point->m_items.GetData(), point->m_items.GetSize());
}
else
{
int i = 0;
while (i < m_coordIndex->m_items.GetSize())
{
//CArray<gmVector3,gmVector3&> vertices;
int j = i;
int count = 0;
while (j < m_coordIndex->m_items.GetSize())
{
long index = m_coordIndex->m_items[j];
if (index == -1)
{
j++;
break;
}
count++;
//glVertex3(static_cast<SFVec3f*>(<ILSFVec3f>(point->m_items[index]).p)->m_v);
// vertices.Add(static_cast<SFVec3f*>(<ILSFVec3f>(point->m_items[index]).p)->m_v);
j++;
}
//int count = j-i;
ASSERT(count >= 3);
pDC->m_pGraphics2D->FillPolygon(pBrush, (LDraw::PointD*)point->m_items.GetData() + i, count);
#if 0
glBegin(GL_POLYGON);
/*
LDraw::gmVector3f v2 = point->m_items[coordIndex->m_items[i+2]];
LDraw::gmVector3f v1 = point->m_items[coordIndex->m_items[i+1]];
LDraw::gmVector3f v0 = point->m_items[coordIndex->m_items[i]];
lglNormal(v2, v1, v0);
*/
if (TRUE)
{
for (int k = count-1; k >= 0; k--)
{
/*
if (texcoordinate)
{
long texIndex = useTexCoordIndex->m_items[i+k];
gmVector2& texvec = texpoint->m_items[texIndex];
glTexCoord2f(texvec[0], texvec[1]);
}
*/
gmVector2& v = point->m_items[m_coordIndex->m_items[i+k]];
glVertex2(v);
}
}
else
{
/*
for (int k = 0; k < count; k++)
{
if (texcoordinate)
{
long texIndex = useTexCoordIndex->m_items[i+k];
gmVector2& texvec = texpoint->m_items[texIndex];
glTexCoord2f(texvec[0], texvec[1]);
}
LDraw::gmVector3f& v = point->m_items[coordIndex->m_items[i+k]];
glVertex3(v);
}
*/
}
i = j;
glEnd();
#endif
}
}
}
else
{
int i = 0;
while (i < m_coordIndex->m_items.GetSize())
{
//CArray<gmVector3,gmVector3&> vertices;
int j = i;
int count = 0;
while (j < m_coordIndex->m_items.GetSize())
{
long index = m_coordIndex->m_items[j];
if (index == -1)
{
j++;
break;
}
count++;
//glVertex3(static_cast<SFVec3f*>(<ILSFVec3f>(point->m_items[index]).p)->m_v);
// vertices.Add(static_cast<SFVec3f*>(<ILSFVec3f>(point->m_items[index]).p)->m_v);
j++;
}
//int count = j-i;
ASSERT(count >= 3);
pDC->m_pGraphics3D->glBegin(GL_LINE_STRIP);
/*
LDraw::gmVector3f v2 = point->m_items[coordIndex->m_items[i+2]];
LDraw::gmVector3f v1 = point->m_items[coordIndex->m_items[i+1]];
LDraw::gmVector3f v0 = point->m_items[coordIndex->m_items[i]];
lglNormal(v2, v1, v0);
*/
if (true)
{
for (int k = count-1; k >= 0; k--)
{
/*
if (texcoordinate)
{
long texIndex = useTexCoordIndex->m_items[i+k];
gmVector2& texvec = texpoint->m_items[texIndex];
glTexCoord2f(texvec[0], texvec[1]);
}
*/
LDraw::vector2f& v = point->m_items[m_coordIndex->m_items[i+k]];
pDC->m_pGraphics3D->glVertex(v);
}
}
else
{
/*
for (int k = 0; k < count; k++)
{
if (texcoordinate)
{
long texIndex = useTexCoordIndex->m_items[i+k];
gmVector2& texvec = texpoint->m_items[texIndex];
glTexCoord2f(texvec[0], texvec[1]);
}
LDraw::gmVector3f& v = point->m_items[coordIndex->m_items[i+k]];
glVertex3(v);
}
*/
}
i = j;
pDC->m_pGraphics3D->glEnd();
}
}
}
return;
}
Coordinate2D* coordinate2D = dynamic_cast<Coordinate2D*>(m_coord->m_value);
if (coordinate2D)
{
MFVec2f* point = coordinate2D->getPoint();
//MFVec2f* texpoint;
//MFInt32* useTexCoordIndex;
/*
if (texcoordinate)
{
texpoint = static_cast<MFVec2f*>(static_cast<CLTextureCoordinate*>(texcoordinate.p)->m_point);
if (texCoordIndex->m_items.GetSize() > 0)
{
if (texCoordIndex->m_items.GetSize() != coordIndex->m_items.GetSize())
{
// TODO, mark this object with some kind of error flag
// m_bError = TRUE
return; // Error
}
useTexCoordIndex = texCoordIndex;
}
else
{
useTexCoordIndex = coordIndex;
}
}
*/
if (m_convex->m_value != false)
{
if (m_coordIndex->m_items.GetSize() == 0)
{
pDC->m_pGraphics3D->glBegin(GL_POLYGON);
for (int i = 0; i < point->m_items.GetSize(); i++)
{
LDraw::vector2f& v = point->m_items[i];
pDC->m_pGraphics3D->glVertex(v);
}
pDC->m_pGraphics3D->glEnd();
}
else
{
int i = 0;
while (i < m_coordIndex->m_items.GetSize())
{
//CArray<gmVector3,gmVector3&> vertices;
int j = i;
int count = 0;
while (j < m_coordIndex->m_items.GetSize())
{
long index = m_coordIndex->m_items[j];
if (index == -1)
{
j++;
break;
}
count++;
//glVertex3(static_cast<SFVec3f*>(<ILSFVec3f>(point->m_items[index]).p)->m_v);
// vertices.Add(static_cast<SFVec3f*>(<ILSFVec3f>(point->m_items[index]).p)->m_v);
j++;
}
//int count = j-i;
ASSERT(count >= 3);
pDC->m_pGraphics3D->glBegin(GL_POLYGON);
/*
LDraw::gmVector3f v2 = point->m_items[coordIndex->m_items[i+2]];
LDraw::gmVector3f v1 = point->m_items[coordIndex->m_items[i+1]];
LDraw::gmVector3f v0 = point->m_items[coordIndex->m_items[i]];
lglNormal(v2, v1, v0);
*/
if (true)
{
for (int k = count-1; k >= 0; k--)
{
/*
if (texcoordinate)
{
long texIndex = useTexCoordIndex->m_items[i+k];
gmVector2& texvec = texpoint->m_items[texIndex];
glTexCoord2f(texvec[0], texvec[1]);
}
*/
LDraw::vector2f& v = point->m_items[m_coordIndex->m_items[i+k]];
pDC->m_pGraphics3D->glVertex(v);
}
}
else
{
/*
for (int k = 0; k < count; k++)
{
if (texcoordinate)
{
long texIndex = useTexCoordIndex->m_items[i+k];
gmVector2& texvec = texpoint->m_items[texIndex];
glTexCoord2f(texvec[0], texvec[1]);
}
LDraw::gmVector3f& v = point->m_items[coordIndex->m_items[i+k]];
glVertex3(v);
}
*/
}
i = j;
pDC->m_pGraphics3D->glEnd();
}
}
}
else
{
int i = 0;
while (i < m_coordIndex->m_items.GetSize())
{
//CArray<gmVector3,gmVector3&> vertices;
int j = i;
int count = 0;
while (j < m_coordIndex->m_items.GetSize())
{
long index = m_coordIndex->m_items[j];
if (index == -1)
{
j++;
break;
}
count++;
//glVertex3(static_cast<SFVec3f*>(<ILSFVec3f>(point->m_items[index]).p)->m_v);
// vertices.Add(static_cast<SFVec3f*>(<ILSFVec3f>(point->m_items[index]).p)->m_v);
j++;
}
//int count = j-i;
ASSERT(count >= 3);
pDC->m_pGraphics3D->glBegin(GL_LINE_STRIP);
/*
LDraw::gmVector3f v2 = point->m_items[coordIndex->m_items[i+2]];
LDraw::gmVector3f v1 = point->m_items[coordIndex->m_items[i+1]];
LDraw::gmVector3f v0 = point->m_items[coordIndex->m_items[i]];
lglNormal(v2, v1, v0);
*/
if (true)
{
for (int k = count-1; k >= 0; k--)
{
/*
if (texcoordinate)
{
long texIndex = useTexCoordIndex->m_items[i+k];
gmVector2& texvec = texpoint->m_items[texIndex];
glTexCoord2f(texvec[0], texvec[1]);
}
*/
LDraw::vector2f& v = point->m_items[m_coordIndex->m_items[i+k]];
pDC->m_pGraphics3D->glVertex(v);
}
}
else
{
/*
for (int k = 0; k < count; k++)
{
if (texcoordinate)
{
long texIndex = useTexCoordIndex->m_items[i+k];
gmVector2& texvec = texpoint->m_items[texIndex];
glTexCoord2f(texvec[0], texvec[1]);
}
LDraw::gmVector3f& v = point->m_items[coordIndex->m_items[i+k]];
glVertex3(v);
}
*/
}
i = j;
pDC->m_pGraphics3D->glEnd();
}
}
}
#endif
}
} // x3d
