// TODO: Implement manual hud scale control in mod loader to fix this
static void __cdecl Indicator_Display(ObjectMaster* _this)
{
if (!*(bool*)_this->UnknownB_ptr)
return;
njSetTexture(&multicommon_TEXLIST);
njSetTextureNum(arrow);
njColorBlendingMode(NJD_SOURCE_COLOR, NJD_COLOR_BLENDING_SRCALPHA);
njColorBlendingMode(NJD_DESTINATION_COLOR, NJD_COLOR_BLENDING_INVSRCALPHA);
for (Uint32 i = 0; i < 4; i++)
DrawElement(i, arrow);
for (Uint32 i = 0; i < 4; i++)
{
TextureIndex index = IsControllerEnabled((Uint8)i) ? p : cpu_1;
njSetTextureNum(index);
DrawElement(i, index);
}
for (Uint8 i = 0; i < 4; i++)
{
TextureIndex index = IsControllerEnabled(i) ? (TextureIndex)(p1 + i) : cpu_2;
njSetTextureNum(index);
DrawElement(i, index);
}
}
void Window::Draw(C4TargetFacet &cgo)
{
// invisible?
if (!IsVisible()) return;
// draw window itself
DrawElement(cgo);
// get target area
C4Rect &rcClientRect = GetClientRect();
C4Rect &rcClipArea = (IsComponentOutsideClientArea() ? GetBounds() : GetClientRect());
// clip to window area
int clx1, cly1, clx2, cly2;
pDraw->GetPrimaryClipper(clx1, cly1, clx2, cly2);
float nclx1 = cgo.TargetX+rcClipArea.x, ncly1 = cgo.TargetY+rcClipArea.y, nclx2 = cgo.TargetX+rcClipArea.x+rcClipArea.Wdt-1, ncly2 = cgo.TargetY+rcClipArea.y+rcClipArea.Hgt-1;
pDraw->ApplyZoom(nclx1, ncly1);
pDraw->ApplyZoom(nclx2, ncly2);
pDraw->SubPrimaryClipper(nclx1, ncly1, nclx2, ncly2);
// update target area
cgo.TargetX += rcClientRect.x; cgo.TargetY += rcClientRect.y;
// draw contents
Container::Draw(cgo);
// reset target area
cgo.TargetX -= rcClientRect.x; cgo.TargetY -= rcClientRect.y;
// reset clipper
pDraw->SetPrimaryClipper(clx1, cly1, clx2, cly2);
}
static void
DisplayResults(TView* view)
{
unsigned long i;
register TElement* ep;
TSpectra ambient;
GetAmbient(&ambient);
BeginDraw(view, 0);
ep = params->elements;
for (i=0; i< params->nElements; i++, ep++) {
TColor32b c;
TSpectra s;
int k;
/* add ambient approximation */
if (params->addAmbient) {
for (k=kNumberOfRadSamples; k--;)
s.samples[k] = (ep->rad.samples[k] + (ambient.samples[k]*
ep->patch->reflectance->samples[k]))*params->intensityScale;
} else {
for (k=kNumberOfRadSamples; k--; )
s.samples[k] = ep->rad.samples[k]*params->intensityScale;
}
/* quantize color */
c = SpectraToRGB(&s);
DrawElement(ep, *(unsigned long*)&c);
}
EndDraw();
}
void *ChangeElementSize( ElementTypePtr Element )
{
int eax;
int ecx;
int ebx;
int esi;
int edi;
BDimension value;
Boolean changed;
if ( PCB->ElementOn )
EraseElement( Element );
{
Cardinal n;
LineTypePtr line;
changed = 0;
n = Element->LineN + -1;
if ( Element->LineN + -1 != -1 )
{
line = ( line * 88 ) + -88;
n = n;
do
{
if ( value + -1 <= 0x98967f && line->Thickness != value )
{
AddObjectToSizeUndoList( 8192, (void*)Element, (void*)line, (void*)Element );
changed = 1;
line->Thickness = value;
}
n += -1;
}
while ( n + -1 != -1 );
Element = Element;
}
{
Cardinal n = Element->ArcN + -1;
ArcTypePtr arc;
if ( Element->ArcN + -1 != -1 )
{
arc = ( arc * 68 ) + -68;
do
{
if ( value + -1 <= 0x98967f && arc->Thickness != value )
{
AddObjectToSizeUndoList( 32768, (void*)Element, (void*)arc, (void*)Element );
changed = 1;
arc->Thickness = value;
}
n += -1;
}
while ( n + -1 != -1 );
Element = Element;
}
if ( PCB->ElementOn )
DrawElement( Element, 0 );
return 0;
}
}
}
void Mesh::Render(Renderer &renderer, bool ignore_material, size_t instances) {
SetAttributes(vbo_, format_, static_cast<int>(vertex_size_), nullptr);
for (auto it = indices_.begin(); it != indices_.end(); ++it) {
if (!ignore_material) it->mat->Set(renderer);
GL_CALL(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, it->ibo));
DrawElement(renderer, it->count, static_cast<int32_t>(instances));
}
UnSetAttributes(format_);
}
void DrawPad(void)
{
int i,j, val, ptr;
ptr = 0;
for (j=0;j<PadHeight;j++)
for (i=0;i<PadWidth;i++) {
val = GamePad[ptr++];
if (i%2) continue;
DrawElement(i, j, val);
}
worker(WorkerPoint.x, WorkerPoint.y);
}
CGEnElement* CGEnMain::DrawElement(float x, float y, float z, CGEnAnim *anim, int frame_in_starttime, UI starttime)
{
if(!anim) return 0;
CLightTex *tex = anim->GetFrameTex(0);
if(!tex) return 0;
CGEnElement *el = DrawElement(x,y,z,tex);
if(el){
SetAnim(el,anim,frame_in_starttime,starttime);
}
return el;
}
CGEnElement* CGEnMain::DrawElement(OPointer objptr, float x, float y, float z, CGEnResource *res, int frame_in_starttime, UI starttime)
{
CGEnElement *el=NULL;
if(!res) return NULL;
eResourceType type = res->GetType();
if(type==resAnim)
{
el = DrawElement(x,y,z,(CGEnAnim*)res,frame_in_starttime,starttime);
if(el){
el->ObjPtr = objptr;
}
}else
if(type==resLightTex)
{
el = DrawElement(x,y,z,(CLightTex*)res);
if(el){
el->ObjPtr = objptr;
}
}
return el;
}
//! 显示数据集。
BOOL CDrawing::DrawVector(CDC* pDC, OgdcDatasetVector* pDatasetV)
{
OGDCASSERT(!OGDCIS0(m_dCoordRatio) && !m_rcClient.IsRectEmpty());
OgdcQueryDef queryDef;
queryDef.m_nType = OgdcQueryDef::Bounds;
queryDef.m_nOptions = OgdcQueryDef::Geometry;
queryDef.m_nCursorType = OgdcQueryDef::OpenStatic;
queryDef.m_nCursorLocation = OgdcQueryDef::UseClient;
queryDef.m_rc2Bounds = m_rcViewBounds;
OgdcRect2D rcDtBounds = pDatasetV->GetBounds();
double dSearchArea = m_rcViewBounds.Width() * m_rcViewBounds.Height();
double dDatasetArea = rcDtBounds.Width() * rcDtBounds.Height();
if(dSearchArea >= dDatasetArea*0.6)
{
queryDef.m_rc2Bounds = rcDtBounds;
}
OgdcRecordset* pRecordset = pDatasetV->Query(queryDef);
if(pRecordset != NULL)
{
OgdcElement* pElement = NULL;
pRecordset->Move(OgdcRecordset::Begin, 0);
while(!pRecordset->IsEOF())
{
if(pRecordset->GetElement(pElement) && pElement != NULL)
{
DrawElement(pDC, pElement);
}
else//断网情况下避免长时间等待 http://192.168.115.2:8090/browse/UGC-4322
{
break;
}
pRecordset->Move();
if(pElement != NULL)
{
delete pElement;
pElement = NULL;
}
}
pDatasetV->ReleaseRecordset(pRecordset);
pRecordset = NULL;
}
return TRUE;
}
void
DrawObject (int type, void *ptr1, void *ptr2)
{
switch (type)
{
case VIA_TYPE:
if (PCB->ViaOn)
DrawVia ((PinType *) ptr2);
break;
case LINE_TYPE:
if (((LayerType *) ptr1)->On)
DrawLine ((LayerType *) ptr1, (LineType *) ptr2);
break;
case ARC_TYPE:
if (((LayerType *) ptr1)->On)
DrawArc ((LayerType *) ptr1, (ArcType *) ptr2);
break;
case TEXT_TYPE:
if (((LayerType *) ptr1)->On)
DrawText ((LayerType *) ptr1, (TextType *) ptr2);
break;
case POLYGON_TYPE:
if (((LayerType *) ptr1)->On)
DrawPolygon ((LayerType *) ptr1, (PolygonType *) ptr2);
break;
case ELEMENT_TYPE:
if (PCB->ElementOn &&
(FRONT ((ElementType *) ptr2) || PCB->InvisibleObjectsOn))
DrawElement ((ElementType *) ptr2);
break;
case RATLINE_TYPE:
if (PCB->RatOn)
DrawRat ((RatType *) ptr2);
break;
case PIN_TYPE:
if (PCB->PinOn)
DrawPin ((PinType *) ptr2);
break;
case PAD_TYPE:
if (PCB->PinOn)
DrawPad ((PadType *) ptr2);
break;
case ELEMENTNAME_TYPE:
if (PCB->ElementOn &&
(FRONT ((ElementType *) ptr2) || PCB->InvisibleObjectsOn))
DrawElementName ((ElementType *) ptr1);
break;
}
}
//! 显示几何对象。
BOOL CDrawing::DrawElement(CDC* pDC, OgdcElement* pElement, BOOL bSelected)
{
OGDCASSERT(!OGDCIS0(m_dCoordRatio) && !m_rcClient.IsRectEmpty() && pElement != NULL);
switch(pElement->GetType())
{
case OgdcElement::ElemPoint:
{
return DrawElement(pDC,(OgdcElemPoint*)pElement, bSelected);
}
case OgdcElement::ElemMultiPoint:
{
return DrawElement(pDC,(OgdcElemMultiPoint*)pElement, bSelected);
}
case OgdcElement::ElemLine:
{
return DrawElement(pDC,(OgdcElemLine*)pElement, bSelected);
}
case OgdcElement::ElemRegion:
{
return DrawElement(pDC,(OgdcElemRegion*)pElement, bSelected);
}
case OgdcElement::ElemText:
{
return DrawElement(pDC,(OgdcElemText*)pElement, bSelected);
}
case OgdcElement::ElemPoint3D:
{
return DrawElement(pDC,(OgdcElemPoint3D*)pElement, bSelected);
}
case OgdcElement::ElemLine3D:
{
return DrawElement(pDC,(OgdcElemLine3D*)pElement, bSelected);
}
case OgdcElement::ElemRegion3D:
{
return DrawElement(pDC,(OgdcElemRegion3D*)pElement, bSelected);
}
default:
{
break;
}
}
return FALSE;
}
void MusRC::DrawLayer( MusDC *dc, MusLayer *layer, MusStaff *staff )
{
wxASSERT_MSG( dc , "DC cannot be NULL");
MusLayerElement *pelement = NULL;
int j;
for(j = 0; j < layer->GetElementCount(); j++)
{
pelement = (MusLayerElement*)layer->m_children[j];
//pelement->Init( m_r );
if ( !pelement->m_in_layer_app ) {
DrawElement( dc, pelement, layer, staff );
}
}
}
void Mesh::RenderStereo(Renderer &renderer, const Shader *shader,
const vec4i *viewport, const mat4 *mvp,
const vec3 *camera_position, bool ignore_material,
size_t instances) {
SetAttributes(vbo_, format_, static_cast<int>(vertex_size_), nullptr);
for (auto it = indices_.begin(); it != indices_.end(); ++it) {
if (!ignore_material) it->mat->Set(renderer);
GL_CALL(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, it->ibo));
for (auto i = 0; i < 2; ++i) {
renderer.set_camera_pos(camera_position[i]);
renderer.set_model_view_projection(mvp[i]);
shader->Set(renderer);
auto vp = viewport[i];
glViewport(vp.x(), vp.y(), vp.z(), vp.w());
DrawElement(renderer, it->count, static_cast<int32_t>(instances));
}
}
UnSetAttributes(format_);
}
/* ----------------------------------------------------------------------
* selects/unselects all visible objects within the passed box
* Flag determines if the block is to be selected or unselected
* returns true if the state of any object has changed
*/
bool
SelectBlock (BoxTypePtr Box, bool Flag)
{
bool changed = false;
if (PCB->RatOn || !Flag)
RAT_LOOP (PCB->Data);
{
if (LINE_IN_BOX ((LineTypePtr) line, Box) &&
!TEST_FLAG (LOCKFLAG, line) && TEST_FLAG (SELECTEDFLAG, line) != Flag)
{
AddObjectToFlagUndoList (RATLINE_TYPE, line, line, line);
ASSIGN_FLAG (SELECTEDFLAG, Flag, line);
if (PCB->RatOn)
DrawRat (line, 0);
changed = true;
}
}
END_LOOP;
/* check layers */
LAYER_LOOP(PCB->Data, max_copper_layer + 2);
{
if (layer == & PCB->Data->SILKLAYER)
{
if (! (PCB->ElementOn || !Flag))
continue;
}
else if (layer == & PCB->Data->BACKSILKLAYER)
{
if (! (PCB->InvisibleObjectsOn || !Flag))
continue;
}
else
if (! (layer->On || !Flag))
continue;
LINE_LOOP (layer);
{
if (LINE_IN_BOX (line, Box)
&& !TEST_FLAG (LOCKFLAG, line)
&& TEST_FLAG (SELECTEDFLAG, line) != Flag)
{
AddObjectToFlagUndoList (LINE_TYPE, layer, line, line);
ASSIGN_FLAG (SELECTEDFLAG, Flag, line);
if (layer->On)
DrawLine (layer, line, 0);
changed = true;
}
}
END_LOOP;
ARC_LOOP (layer);
{
if (ARC_IN_BOX (arc, Box)
&& !TEST_FLAG (LOCKFLAG, arc)
&& TEST_FLAG (SELECTEDFLAG, arc) != Flag)
{
AddObjectToFlagUndoList (ARC_TYPE, layer, arc, arc);
ASSIGN_FLAG (SELECTEDFLAG, Flag, arc);
if (layer->On)
DrawArc (layer, arc, 0);
changed = true;
}
}
END_LOOP;
TEXT_LOOP (layer);
{
if (!Flag || TEXT_IS_VISIBLE(PCB, layer, text))
{
if (TEXT_IN_BOX (text, Box)
&& !TEST_FLAG (LOCKFLAG, text)
&& TEST_FLAG (SELECTEDFLAG, text) != Flag)
{
AddObjectToFlagUndoList (TEXT_TYPE, layer, text, text);
ASSIGN_FLAG (SELECTEDFLAG, Flag, text);
if (TEXT_IS_VISIBLE(PCB, layer, text))
DrawText (layer, text, 0);
changed = true;
}
}
}
END_LOOP;
POLYGON_LOOP (layer);
{
if (POLYGON_IN_BOX (polygon, Box)
&& !TEST_FLAG (LOCKFLAG, polygon)
&& TEST_FLAG (SELECTEDFLAG, polygon) != Flag)
{
AddObjectToFlagUndoList (POLYGON_TYPE, layer, polygon, polygon);
ASSIGN_FLAG (SELECTEDFLAG, Flag, polygon);
if (layer->On)
DrawPolygon (layer, polygon, 0);
changed = true;
}
}
END_LOOP;
}
END_LOOP;
/* elements */
ELEMENT_LOOP (PCB->Data);
{
{
bool gotElement = false;
if ((PCB->ElementOn || !Flag)
&& !TEST_FLAG (LOCKFLAG, element)
&& ((TEST_FLAG (ONSOLDERFLAG, element) != 0) == SWAP_IDENT
|| PCB->InvisibleObjectsOn))
{
if (BOX_IN_BOX
(&ELEMENT_TEXT (PCB, element).BoundingBox, Box)
&& !TEST_FLAG (LOCKFLAG, &ELEMENT_TEXT (PCB, element))
&& TEST_FLAG (SELECTEDFLAG,
&ELEMENT_TEXT (PCB, element)) != Flag)
{
/* select all names of element */
ELEMENTTEXT_LOOP (element);
{
AddObjectToFlagUndoList (ELEMENTNAME_TYPE,
element, text, text);
ASSIGN_FLAG (SELECTEDFLAG, Flag, text);
}
END_LOOP;
if (PCB->ElementOn)
DrawElementName (element, 0);
changed = true;
}
if ((PCB->PinOn || !Flag) && ELEMENT_IN_BOX (element, Box))
if (TEST_FLAG (SELECTEDFLAG, element) != Flag)
{
AddObjectToFlagUndoList (ELEMENT_TYPE,
element, element, element);
ASSIGN_FLAG (SELECTEDFLAG, Flag, element);
PIN_LOOP (element);
{
if (TEST_FLAG (SELECTEDFLAG, pin) != Flag)
{
AddObjectToFlagUndoList (PIN_TYPE, element, pin, pin);
ASSIGN_FLAG (SELECTEDFLAG, Flag, pin);
if (PCB->PinOn)
DrawPin (pin, 0);
changed = true;
}
}
END_LOOP;
PAD_LOOP (element);
{
if (TEST_FLAG (SELECTEDFLAG, pad) != Flag)
{
AddObjectToFlagUndoList (PAD_TYPE, element, pad, pad);
ASSIGN_FLAG (SELECTEDFLAG, Flag, pad);
if (PCB->PinOn)
DrawPad (pad, 0);
changed = true;
}
}
END_LOOP;
if (PCB->PinOn)
DrawElement (element, 0);
changed = true;
gotElement = true;
}
}
if ((PCB->PinOn || !Flag) && !TEST_FLAG (LOCKFLAG, element) && !gotElement)
{
PIN_LOOP (element);
{
if ((VIA_OR_PIN_IN_BOX (pin, Box)
&& TEST_FLAG (SELECTEDFLAG, pin) != Flag))
{
AddObjectToFlagUndoList (PIN_TYPE, element, pin, pin);
ASSIGN_FLAG (SELECTEDFLAG, Flag, pin);
if (PCB->PinOn)
DrawPin (pin, 0);
changed = true;
}
}
END_LOOP;
PAD_LOOP (element);
{
if (PAD_IN_BOX (pad, Box)
&& TEST_FLAG (SELECTEDFLAG, pad) != Flag)
{
AddObjectToFlagUndoList (PAD_TYPE, element, pad, pad);
ASSIGN_FLAG (SELECTEDFLAG, Flag, pad);
if (PCB->PinOn)
DrawPad (pad, 0);
changed = true;
}
}
END_LOOP;
}
}
}
END_LOOP;
/* end with vias */
if (PCB->ViaOn || !Flag)
VIA_LOOP (PCB->Data);
{
if (VIA_OR_PIN_IN_BOX (via, Box)
&& !TEST_FLAG (LOCKFLAG, via)
&& TEST_FLAG (SELECTEDFLAG, via) != Flag)
{
AddObjectToFlagUndoList (VIA_TYPE, via, via, via);
ASSIGN_FLAG (SELECTEDFLAG, Flag, via);
if (PCB->ViaOn)
DrawVia (via, 0);
changed = true;
}
}
END_LOOP;
if (changed)
{
Draw ();
IncrementUndoSerialNumber ();
}
return (changed);
}
void DrawCell(int x, int y)
{
if (y < 0 || x < 0 || y >= PadHeight || x >= PadWidth) return;
DrawElement(x, y, GamePad[y*PadWidth + x ]);
}
bool
SelectObjectByName (int Type, char *Pattern, bool Flag)
{
bool changed = false;
#if defined(HAVE_REGCOMP)
#define REGEXEC(arg) (regexec_match_all(&compiled, (arg)))
int result;
regex_t compiled;
/* compile the regular expression */
result = regcomp (&compiled, Pattern, REG_EXTENDED | REG_ICASE);
if (result)
{
char errorstring[128];
regerror (result, &compiled, errorstring, 128);
Message (_("regexp error: %s\n"), errorstring);
regfree (&compiled);
return (false);
}
#else
#define REGEXEC(arg) (re_exec((arg)) == 1)
char *compiled;
/* compile the regular expression */
if ((compiled = re_comp (Pattern)) != NULL)
{
Message (_("re_comp error: %s\n"), compiled);
return (false);
}
#endif
/* loop over all visible objects with names */
if (Type & TEXT_TYPE)
ALLTEXT_LOOP (PCB->Data);
{
if (!TEST_FLAG (LOCKFLAG, text)
&& TEXT_IS_VISIBLE (PCB, layer, text)
&& text->TextString
&& REGEXEC (text->TextString)
&& TEST_FLAG (SELECTEDFLAG, text) != Flag)
{
AddObjectToFlagUndoList (TEXT_TYPE, layer, text, text);
ASSIGN_FLAG (SELECTEDFLAG, Flag, text);
DrawText (layer, text, 0);
changed = true;
}
}
ENDALL_LOOP;
if (PCB->ElementOn && (Type & ELEMENT_TYPE))
ELEMENT_LOOP (PCB->Data);
{
if (!TEST_FLAG (LOCKFLAG, element)
&& ((TEST_FLAG (ONSOLDERFLAG, element) != 0) == SWAP_IDENT
|| PCB->InvisibleObjectsOn)
&& TEST_FLAG (SELECTEDFLAG, element) != Flag)
{
String name = ELEMENT_NAME (PCB, element);
if (name && REGEXEC (name))
{
AddObjectToFlagUndoList (ELEMENT_TYPE, element, element, element);
ASSIGN_FLAG (SELECTEDFLAG, Flag, element);
PIN_LOOP (element);
{
AddObjectToFlagUndoList (PIN_TYPE, element, pin, pin);
ASSIGN_FLAG (SELECTEDFLAG, Flag, pin);
}
END_LOOP;
PAD_LOOP (element);
{
AddObjectToFlagUndoList (PAD_TYPE, element, pad, pad);
ASSIGN_FLAG (SELECTEDFLAG, Flag, pad);
}
END_LOOP;
ELEMENTTEXT_LOOP (element);
{
AddObjectToFlagUndoList (ELEMENTNAME_TYPE, element, text, text);
ASSIGN_FLAG (SELECTEDFLAG, Flag, text);
}
END_LOOP;
DrawElementName (element, 0);
DrawElement (element, 0);
changed = true;
}
}
}
END_LOOP;
if (PCB->PinOn && (Type & PIN_TYPE))
ALLPIN_LOOP (PCB->Data);
{
if (!TEST_FLAG (LOCKFLAG, element)
&& pin->Name && REGEXEC (pin->Name)
&& TEST_FLAG (SELECTEDFLAG, pin) != Flag)
{
AddObjectToFlagUndoList (PIN_TYPE, element, pin, pin);
ASSIGN_FLAG (SELECTEDFLAG, Flag, pin);
DrawPin (pin, 0);
changed = true;
}
}
ENDALL_LOOP;
if (PCB->PinOn && (Type & PAD_TYPE))
ALLPAD_LOOP (PCB->Data);
{
if (!TEST_FLAG (LOCKFLAG, element)
&& ((TEST_FLAG (ONSOLDERFLAG, pad) != 0) == SWAP_IDENT
|| PCB->InvisibleObjectsOn)
&& TEST_FLAG (SELECTEDFLAG, pad) != Flag)
if (pad->Name && REGEXEC (pad->Name))
{
AddObjectToFlagUndoList (PAD_TYPE, element, pad, pad);
ASSIGN_FLAG (SELECTEDFLAG, Flag, pad);
DrawPad (pad, 0);
changed = true;
}
}
ENDALL_LOOP;
if (PCB->ViaOn && (Type & VIA_TYPE))
VIA_LOOP (PCB->Data);
{
if (!TEST_FLAG (LOCKFLAG, via)
&& via->Name
&& REGEXEC (via->Name) && TEST_FLAG (SELECTEDFLAG, via) != Flag)
{
AddObjectToFlagUndoList (VIA_TYPE, via, via, via);
ASSIGN_FLAG (SELECTEDFLAG, Flag, via);
DrawVia (via, 0);
changed = true;
}
}
END_LOOP;
#if defined(HAVE_REGCOMP)
#if !defined(sgi)
regfree (&compiled);
#endif
#endif
if (changed)
{
IncrementUndoSerialNumber ();
Draw ();
}
return (changed);
}
/* Compute form-factors from the shooting patch to every elements */
static void ComputeFormfactors(unsigned long shootPatch)
{
unsigned long i;
TVector3f up[5];
TPoint3f lookat[5];
TPoint3f center;
TVector3f normal, tangentU, tangentV, vec;
int face;
double norm;
TPatch* sp;
double* fp;
TElement* ep;
/* get the center of shootPatch */
sp = &(params->patches[shootPatch]);
center = sp->center;
normal = sp->normal;
/* rotate the hemi-cube along the normal axis of the patch randomly */
/* this will reduce the hemi-cube aliasing artifacts */
do {
vec.x = RandomFloat;
vec.y = RandomFloat;
vec.z = RandomFloat;
/* get a tangent vector */
CrossVector(tangentU, normal, vec);
NormalizeVector(norm, tangentU);
} while (norm==0); /* bad choice of the random vector */
/* compute tangentV */
CrossVector(tangentV, normal, tangentU);
/* assign the lookats and ups for each hemicube face */
AddVector(lookat[0], center, normal);
up[0] = tangentU;
AddVector(lookat[1], center, tangentU);
up[1] = normal;
AddVector(lookat[2], center, tangentV);
up[2] = normal;
SubVector(lookat[3], center, tangentU);
up[3] = normal;
SubVector(lookat[4], center, tangentV);
up[4] = normal;
/* position the hemicube slightly above the center of the shooting patch */
ScaleVector(normal, params->worldSize*0.0001);
AddVector(hemicube.view.camera, center, normal);
/* clear the formfactors */
fp = formfactors;
for (i=params->nElements; i--; fp++)
*fp = 0.0;
for (face=0; face < 5; face++)
{
hemicube.view.lookat = lookat[face];
hemicube.view.up = up[face];
/* draw elements */
BeginDraw(&(hemicube.view), kBackgroundItem);
for (i=0; i< params->nElements; i++)
DrawElement(¶ms->elements[i], i);
/* color element i with its index */
EndDraw();
/* get formfactors */
if (face==0)
SumFactors(formfactors, hemicube.view.xRes, hemicube.view.yRes,
hemicube.view.buffer, hemicube.topFactors);
else
SumFactors(formfactors, hemicube.view.xRes, hemicube.view.yRes/2,
hemicube.view.buffer, hemicube.sideFactors);
}
/* compute reciprocal form-factors */
ep = params->elements;
fp = formfactors;
for (i=params->nElements; i--; ep++, fp++)
{
*fp *= sp->area / ep->area;
/* This is a potential source of hemi-cube aliasing */
/* To do this right, we need to subdivide the shooting patch
and reshoot. For now we just clip it to unity */
if ((*fp) > 1.0) *fp = 1.0;
}
}
//-----------------------------------------------------------------------------
// Draw a particular subcircuit with its top left corner at *cx and *cy (in
// characters). If it is a leaf element then just print it and return; else
// loop over the elements of the subcircuit and call ourselves recursively.
// At the end updates *cx and *cy.
//
// In simulation mode, returns TRUE the circuit is energized after the given
// element, else FALSE. This is needed to colour all the wires correctly,
// since the colouring indicates whether a wire is energized.
//-----------------------------------------------------------------------------
BOOL DrawElement(int which, void *elem, int *cx, int *cy, BOOL poweredBefore)
{
BOOL poweredAfter;
int cx0 = *cx, cy0 = *cy;
ElemLeaf *leaf = (ElemLeaf *)elem;
SetBkColor(Hdc, InSimulationMode ? HighlightColours.simBg :
HighlightColours.bg);
NormText();
if(elem == Selected && !InSimulationMode) {
EmphText();
ThisHighlighted = TRUE;
} else {
ThisHighlighted = FALSE;
}
switch(which) {
case ELEM_SERIES_SUBCKT: {
int i;
ElemSubcktSeries *s = (ElemSubcktSeries *)elem;
poweredAfter = poweredBefore;
for(i = 0; i < s->count; i++) {
poweredAfter = DrawElement(s->contents[i].which,
s->contents[i].d.any, cx, cy, poweredAfter);
}
break;
}
case ELEM_PARALLEL_SUBCKT: {
int i;
ElemSubcktParallel *p = (ElemSubcktParallel *)elem;
int widthMax = CountWidthOfElement(which, elem, (*cx)/POS_WIDTH);
int heightMax = CountHeightOfElement(which, elem);
poweredAfter = FALSE;
int lowestPowered = -1;
int downBy = 0;
for(i = 0; i < p->count; i++) {
BOOL poweredThis;
poweredThis = DrawElement(p->contents[i].which,
p->contents[i].d.any, cx, cy, poweredBefore);
if(InSimulationMode) {
if(poweredThis) poweredAfter = TRUE;
PoweredText(poweredThis);
}
while((*cx - cx0) < widthMax*POS_WIDTH) {
int gx = *cx/POS_WIDTH;
int gy = *cy/POS_HEIGHT;
if(CheckBoundsUndoIfFails(gx, gy)) return FALSE;
DM_BOUNDS(gx, gy);
DisplayMatrix[gx][gy] = PADDING_IN_DISPLAY_MATRIX;
DisplayMatrixWhich[gx][gy] = ELEM_PADDING;
char buf[256];
int j;
for(j = 0; j < POS_WIDTH; j++) {
buf[j] = '-';
}
buf[j] = '\0';
DrawChars(*cx, *cy + (POS_HEIGHT/2), buf);
*cx += POS_WIDTH;
}
*cx = cx0;
int justDrewHeight = CountHeightOfElement(p->contents[i].which,
p->contents[i].d.any);
*cy += POS_HEIGHT*justDrewHeight;
downBy += justDrewHeight;
if(poweredThis) {
lowestPowered = downBy - 1;
}
}
*cx = cx0 + POS_WIDTH*widthMax;
*cy = cy0;
int j;
BOOL needWire;
if(*cx/POS_WIDTH != ColsAvailable) {
needWire = FALSE;
for(j = heightMax - 1; j >= 1; j--) {
if(j <= lowestPowered) PoweredText(poweredAfter);
if(DisplayMatrix[*cx/POS_WIDTH - 1][*cy/POS_HEIGHT + j]) {
needWire = TRUE;
}
if(needWire) VerticalWire(*cx - 1, *cy + j*POS_HEIGHT);
}
// stupid special case
if(lowestPowered == 0 && InSimulationMode) {
EmphText();
DrawChars(*cx - 1, *cy + (POS_HEIGHT/2), "+");
}
}
PoweredText(poweredBefore);
needWire = FALSE;
for(j = heightMax - 1; j >= 1; j--) {
if(DisplayMatrix[cx0/POS_WIDTH][*cy/POS_HEIGHT + j]) {
needWire = TRUE;
}
if(needWire) VerticalWire(cx0 - 1, *cy + j*POS_HEIGHT);
}
break;
}
default:
poweredAfter = DrawLeaf(which, leaf, cx, cy, poweredBefore);
break;
}
NormText();
return poweredAfter;
}
void CreateOneToolbar( GtkWidget * Box, int NumTable, short int PtrOnToolBarElementsList[][NBR_ELE_TOOLBAR_X_MAX], char * PtrOnToolTipsText[][NBR_ELE_TOOLBAR_X_MAX] )
{
int CurrentAvail = 0;
while( ToolbarBtnRadio[ CurrentAvail ]!=NULL && CurrentAvail<NBR_ELE_IN_TOOLBAR )
CurrentAvail++;
if ( CurrentAvail<NBR_ELE_IN_TOOLBAR )
{
StrElement ToolBarEle;
int ScanToolBarX,ScanToolBarY;
GSList * PtrListRadiosBtn = NULL;
ScanToolBarX = 0;
ScanToolBarY = 0;
ToolbarTable[ NumTable ] = gtk_table_new( NBR_ELE_TOOLBAR_X_MAX, NBR_ELE_TOOLBAR_Y_MAX, FALSE/*homogeneous*/ );
gtk_box_pack_start (GTK_BOX(Box), ToolbarTable[ NumTable ], TRUE, TRUE, 0);
do
{
ToolBarEle.Type = PtrOnToolBarElementsList[ScanToolBarY][ScanToolBarX];
ToolBarEle.ConnectedWithTop = 0;
if ( ToolBarEle.Type==EDIT_POINTER )
{
if ( PtrOnToolBarElementsList!=ToolBarElementsSequential )
NumWidgetEditPointer[ NUM_TOOLBAR_FOR_RUNGS ] = CurrentAvail;
else
NumWidgetEditPointer[ NUM_TOOLBAR_FOR_SEQ ] = CurrentAvail;
}
if ( ToolBarEle.Type!=0 )
{
GdkGC * gc = drawing_area->style->bg_gc[0];
char * pHelpText = PtrOnToolTipsText[ ScanToolBarY ][ ScanToolBarX ];
ToolbarPixmap[ CurrentAvail ] = gdk_pixmap_new( GDK_DRAWABLE(drawing_area->window), PIXELS_SIZE_IN_TOOLBAR, PIXELS_SIZE_IN_TOOLBAR, -1 );
gdk_draw_rectangle (GDK_DRAWABLE(ToolbarPixmap[ CurrentAvail ]), gc, TRUE, 0, 0, PIXELS_SIZE_IN_TOOLBAR, PIXELS_SIZE_IN_TOOLBAR);
#ifdef SEQUENTIAL_SUPPORT
if ( PtrOnToolBarElementsList==ToolBarElementsSequential )
DrawSeqElementForToolBar(ToolbarPixmap[ CurrentAvail ], 0, 0, PIXELS_SIZE_IN_TOOLBAR, ToolBarEle.Type );
else
#endif
DrawElement(ToolbarPixmap[ CurrentAvail ], 0, 0, PIXELS_SIZE_IN_TOOLBAR, PIXELS_SIZE_IN_TOOLBAR, ToolBarEle, TRUE);
ToolbarImage[ CurrentAvail ] = gtk_image_new_from_pixmap( ToolbarPixmap[ CurrentAvail ], NULL );
ToolbarBtnRadio[ CurrentAvail ] = gtk_radio_button_new( PtrListRadiosBtn );
PtrListRadiosBtn = gtk_radio_button_get_group (GTK_RADIO_BUTTON(ToolbarBtnRadio[ CurrentAvail ]));
gtk_button_set_relief (GTK_BUTTON( ToolbarBtnRadio[ CurrentAvail ] ), GTK_RELIEF_NONE);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON(ToolbarBtnRadio[ CurrentAvail ]), FALSE);
gtk_container_add( GTK_CONTAINER( ToolbarBtnRadio[ CurrentAvail ] ), ToolbarImage[ CurrentAvail ] );
gtk_widget_show( ToolbarImage[ CurrentAvail ] );
gtk_table_attach( GTK_TABLE( ToolbarTable[ NumTable ] ), ToolbarBtnRadio[ CurrentAvail ],
ScanToolBarX, ScanToolBarX+1, ScanToolBarY, ScanToolBarY+1,
0, 0, 0, 0 );
gtk_signal_connect( GTK_OBJECT (ToolbarBtnRadio[ CurrentAvail ]), "clicked", (GtkSignalFunc) ButtonToolbarSignal, GINT_TO_POINTER((int)ToolBarEle.Type) );
if (pHelpText!=NULL )
gtk_tooltips_set_tip (TheTooltips, ToolbarBtnRadio[ CurrentAvail ], pHelpText, NULL);
gtk_widget_show( ToolbarBtnRadio[ CurrentAvail ] );
CurrentAvail++;
}//if ( ToolBarEle.Type!=0 )
ScanToolBarX++;
if (ScanToolBarX>=NBR_ELE_TOOLBAR_X_MAX)
{
ScanToolBarX = 0;
ScanToolBarY++;
}
}
while( PtrOnToolBarElementsList[ScanToolBarY][ScanToolBarX]!=-1 );
}
}
/* Shared sketch algorithm for pursuing Gabors */
void PursueElement()
{
int img, orient, x, y, besto, bestx, besty, mo, mx, my, t, here, shift, i, j, trace[2];
float r, maxPooled, maxResponse, average, overShoot;
t = 0; /* t is for iterations */
do
{ /* select the next Gabor */
maxPooled = NEGMAX;
for (x=startx; x<=endx; x++)
for (y=starty; y<=endy; y++)
{
here = px(x, y, sizexSubsample, sizeySubsample);
for (orient=0; orient<numOrient; orient++)
{
r = pooledMax1map[orient][here];
if (maxPooled<r)
{
maxPooled = r;
besto = orient; bestx = x; besty = y;
}
}
}
/* estimate the parameter of exponential model */
selectedOrient[t] = besto; selectedx[t] = bestx; selectedy[t] = besty;
average = maxPooled/numImage;
j = numStoredPoint-1;
while (storedExpectation[j]>average)
j--;
if (j==numStoredPoint-1)
{
selectedlambda[t] = storedlambda[j];
selectedLogZ[t] = storedLogZ[j];
}
else
{ /* linear interpolation */
overShoot = (average-storedExpectation[j])/(storedExpectation[j+1]-storedExpectation[j]);
selectedlambda[t] = storedlambda[j]+(storedlambda[j+1]-storedlambda[j])*overShoot;
selectedLogZ[t] = storedLogZ[j]+(storedLogZ[j+1]-storedLogZ[j])*overShoot;
}
/* plot selected and perturbed Gabor and inhibit nearby Gabors */
DrawElement(commonTemplate, besto, bestx*subsample, besty*subsample, sqrt(average));
here = px(bestx, besty, sizexSubsample, sizeySubsample);
for (img=0; img<numImage; img++)
{
i = besto*numImage+img;
maxResponse = MAX1map[i][here];
shift = ROUND(trackMap[i][here]);
mo = orientShifted[besto][shift];
mx = bestx*subsample + xShift[besto][shift];
my = besty*subsample + yShift[besto][shift];
if (maxResponse>0.)
{
DrawElement(deformedTemplate[img], mo, mx, my, sqrt(maxResponse)); //mark
NonMaximumSuppression(img, mo, mx, my); //mark
}
}
t++;
}
while (t<numElement);
}
