Random line of code thread
category: code [glöplog]
Preacher: made my day
Quote:
Code:bool found = false; foreach(int index in comparisonLineIndicesArray[index0]) { if (index1==index) { found = true; break; } } if (!found) { foreach(int index in comparisonLineIndicesArray[index1]) { if (index0==index) { found = true; break; } } }
Code:
bool found = comparisonLineIndicesArray[index0].Contains(index1) || comparisonLineIndicesArray[index1].Contains(index0);
I'm curious about the usage of this.
@Orace: It was used to generate wireframe information from indexed polygon data.
Originally I had used a very slow bruteforce version where I was adding a polygon edge to a list and also comparing with every previous element in case this edge already existed (because it might be shared by more than one polygons).
Then I wrote this optimized version, having an array of lists, so if for example I want to search for edge with index points 7 and 15, I go to comparisonLineIndicesArray[7] and search if there is a second index with value 15 there. Also have to do comparisonLineIndicesArray[15] and search for 7, and if not then add the new edge to one of the lists. Much less time, almost instant instead of minutes for some of our big models.
Originally I had used a very slow bruteforce version where I was adding a polygon edge to a list and also comparing with every previous element in case this edge already existed (because it might be shared by more than one polygons).
Then I wrote this optimized version, having an array of lists, so if for example I want to search for edge with index points 7 and 15, I go to comparisonLineIndicesArray[7] and search if there is a second index with value 15 there. Also have to do comparisonLineIndicesArray[15] and search for 7, and if not then add the new edge to one of the lists. Much less time, almost instant instead of minutes for some of our big models.
Oh, your second code is shorter version, I see :)
You use a array of lists.
Does all the element of this array are used ?
I have good result with a Dictionary<int, HashSet<int>>.
I have a second implementation using SortedSet<Edge> (c# 4.0).
(For c# 3.0, you can use Dictionary<Edge, object> where you use only Keys and all value are null)
Where edge implement IComparable.
There is less code :
But it three time slower :o(
Does all the element of this array are used ?
I have good result with a Dictionary<int, HashSet<int>>.
Code:
class EdgeContainer2 : IEdgeContainer
{
private readonly Dictionary<int, HashSet<int>> _comparisonLineIndicesArray = new Dictionary<int, HashSet<int>>();
/// <summary>
/// Adds a edge to this container.
/// </summary>
/// <param name="edge">Edge to add.</param>
/// <returns>true if edge id added to the container. false otherwise.</returns>
public bool AddEdge(Edge edge)
{
var index0 = edge.Index0;
var index1 = edge.Index1;
var found = Found(index0, index1) || Found(index1, index0);
if (found)
{
return false;
}
// The edge is not found, we add it.
HashSet<int> set;
_comparisonLineIndicesArray.TryGetValue(index0, out set);
if (set == null)
{
// The set is not created yet, we create it.
set = new HashSet<int>();
_comparisonLineIndicesArray.Add(index0, set);
}
// Add the edge.
set.Add(index1);
return true;
}
/// <summary>
/// Return true if the oriented edge "index0-index1" is already in this container.
/// </summary>
private bool Found(int index0, int index1)
{
HashSet<int> set;
_comparisonLineIndicesArray.TryGetValue(index0, out set);
return (set != null) && set.Contains(index1);
}
public int Count
{
get { return _comparisonLineIndicesArray.Values.Sum(set => set.Count); }
}
}
I have a second implementation using SortedSet<Edge> (c# 4.0).
(For c# 3.0, you can use Dictionary<Edge, object> where you use only Keys and all value are null)
Where edge implement IComparable.
Code:
public int CompareTo(object obj)
{
int result;
if (obj == null)
{
result = 1;
}
else
{
var otherEdge = obj as Edge;
if (otherEdge == null)
{
throw new ArgumentException("Object is not a Edge");
}
result = otherEdge.Index0 - Index0;
if (result == 0)
{
result = otherEdge.Index1 - Index1;
}
}
return result;
}
There is less code :
Code:
class EdgeContainer1 : IEdgeContainer
{
private readonly SortedSet<Edge> _edgeList = new SortedSet<Edge>();
public bool AddEdge(Edge edge)
{
var result = false;
lock (_edgeList)
{
result = _edgeList.Add(edge);
}
return result;
}
public int Count
{
get { return _edgeList.Count; }
}
}
But it three time slower :o(
i wonder if Optimus is into C# at all! ;)
Oh, wait, random code here:
Oh, wait, random code here:
Code:
// UNSIGNED !!!!
float plane(float3 p)
{
return abs(p.y);
}
float sphere(float3 p,float x)
{
return length(p)-x;
}
float cube(float3 p,float3 x)
{
//return max(max(abs(p.x)-x.x,abs(p.y)-x.y),abs(p.z)-x.z); // many asciis
//return length(max(abs(p)-x,0.)); // unsigned, artefacts
p=abs(p)-x; // smallest in
return max(max(p.x,p.y),p.z); // ascii-count -> 42 :D
}
// UNSIGNED !!!!
float rcube(float3 p,float3 x,float y )
{
return length(max(abs(p)-x,0.))-y;
}
// SIGNED - TEST
float srcube(float3 p,float3 x,float y )
{
//return max(max(abs(p.x)-x.x-y,abs(p.y)-x.y-y),abs(p.z)-x.z-y);
p=abs(p)-(x-y); // smallest in
return max(max(p.x,p.y),p.z); // ascii-count -> 42 :D
}
float ring(float3 p,float x,float y,float z)
{
//return max(abs(length(p.xz)-r)-r2,abs(p.y)-c);
return max(abs(length(p.xy)-x)-y,abs(p.z)-z);
}
float octahedron(float3 p,float x)
{
p=abs(p);
return (p.x+p.y+p.z-x)/3;
}
// TEST ONLY!
float octahedron_extruded(float3 p,float x)
{
// p=abs(clamp(p,-1.,1.));
p=clamp(abs(p),0.,1.);
return (p.x+p.y+p.z-x)/3;
}
float cylinderX(float3 p,float x,float y)
{
return max(abs(p.x)-y,length(p.yz)-x);
}
float cylinderY(float3 p,float x,float y)
{
return max(abs(p.y)-y,length(p.xz)-x);
}
float cylinderZ(float3 p,float x,float y)
{
return max(abs(p.z)-y,length(p.xy)-x);
// return length(p.xy-y)-x;
}
float torusX(float3 p,float x,float y)
{
return length(float2(length(float2(p.y,p.z))-x,p.x))-y;
}
float torusY(float3 p,float x,float y)
{
return length(float2(length(float2(p.x,p.z))-x,p.y))-y;
}
float torusZ(float3 p,float x,float y)
{
return length(float2(length(float2(p.x,p.y))-x,p.z))-y;
}
float hexagonX(float3 p,float x,float y)
{
p=abs(p);
return max(p.x-y,max(p.y+p.z*.5,p.z)-x);
}
float hexagonY(float3 p,float x,float y)
{
p=abs(p);
return max(p.y-y,max(p.z+p.x*.5,p.x)-x);
}
float hexagonZ(float3 p,float x,float y)
{
p=abs(p);
//return max(p.z-y,max(p.x+p.y*0.57735,p.y)-x);
return max(p.z-y,max(p.x+p.y*.5,p.y)-x);
}
float octagonX(float3 p,float x,float y)
{
p=abs(p);
return max(p.x-y,max(p.z+p.y*.5,p.y+p.z*.5)-x);
}
float octagonY(float3 p,float x,float y)
{
p=abs(p);
return max(p.y-y,max(p.z+p.x*.5,p.x+p.z*.5)-x);
}
float octagonZ(float3 p,float x,float y)
{
p=abs(p);
return max(p.z-y,max(p.y+p.x*.5,p.x+p.y*.5)-x);
}
float capsuleX(float3 p,float x,float y)
{
p=abs(p);
return min(max(p.x-x,length(p.yz)-y),length(p-float3(x,0.,0.))-y);
}
float capsuleY(float3 p,float x,float y)
{
p=abs(p);
return min(max(p.y-x,length(p.xz)-y),length(p-float3(0.,x,0.))-y);
}
float capsuleZ(float3 p,float x,float y)
{
p=abs(p);
return min(max(p.z-x,length(p.xy)-y),length(p-float3(0.,0.,x))-y);
}
float prismX(float3 p,float x,float y)
{
return max(abs(p.z)-y,max(abs(p.y)*.9+p.x*.5,-p.x)-x*.5);
}
float prismY(float3 p,float x,float y)
{
return max(abs(p.z)-y,max(abs(p.x)*.9+p.y*.5,-p.y)-x*.5);
}
float prismZ(float3 p,float x,float y)
{
return max(abs(p.y)-y,max(abs(p.x)*.9+p.z*.5,-p.z)-x*.5);
}
// Strange Stuff:
// y=.5 ??
float eightspheres(float3 p,float3 x,float y )
{
return length(abs(p)-x)-y;
}
// y=.5
float wrongHexahedron(float3 p,float3 x,float y )
{
p=abs(p)-x;
p+=y*p.zxy;
return max(max(p.x,p.y),p.z);
}
// x,y = .5
float wronglyOctagon(float3 p,float3 x,float y )
{
p=abs(p)-x;
p+=y*p.zyx;
return max(max(p.x,p.y),p.z);
}
Code:
jsr demoflowupdate
mov AX, 13h
Code:
idletime = idletime;
A quote from some Pascal code that I really wrote years ago:
As soon as I finished typing that sentence, I had to grin :)
Code:
if not working then break;As soon as I finished typing that sentence, I had to grin :)
Code:
print(lambda f:f(f))(lambda s,l='',c='':lambda x=0:s(s,x,c+l)if x else c+l)('h')('e')('l')('l')('o')(' ')('w')('o')('r')('l')('d')()
Code:
eor.l #"KrIs",(a1)+
Code:
$('pouetbox_groupmain').select('.prod a').map(function(element){return element.readAttribute('href').split("=")[1]})Code:
$('.prod a').map(function(){return $(this).attr('href').split("=")[1]})
Code:
.loader bsr WaitRaster ; required for whatever reason lmpr: EQU &FA
hmpr: EQU &FB
vmpr: EQU &FC
hmpr: EQU &FB
vmpr: EQU &FC
Code:
fillScreensWithShit:
LD D,15
loop2:
LD A,D
SLA A
OUT (hmpr),A
LD HL,&8000
LD BC,32768
loop1:
ADD A,D
ADD A,D
ADD A,D
ADD A,D
LD (HL),A
INC HL
DEC BC
LD A,B
OR C
JR NZ,loop1
DEC D
JR NZ,loop2
RET
Quote:
(base+roid) * ambush * backstab * killing blow * [weapon bonus * (%deception + %iron hand + %counter strike + %rising shot + %be like water + %followthrouh + %like the wind + %COM + %BAR) + 0.RELIC] * execute * slag * crit * deathmark
orace: setting AB=a+b for and edge, a and b indices, and comparing ABs is faster than comparing aa bb for each.
for example, to "smooth" a mesh, storing int value=K*x+MAX*(K*y+MAX*K*z) and comparing values before testing distance between two vertices. (K and MAX choosen optimaly)
I do not trust standard libs...
for example, to "smooth" a mesh, storing int value=K*x+MAX*(K*y+MAX*K*z) and comparing values before testing distance between two vertices. (K and MAX choosen optimaly)
I do not trust standard libs...
Code:
loop square1
From this intro of mine. :)
Code:
; WARNING: explicit Random Seeds :)
VOXOBJ_PRECALC
GET CLOUDTEX,a1
FX_TEXGEN_CLOUD.P a1,#128,#"FUCK",#"THIS"
Code:
illegal ; if this triggers, your bloody code is crap!
Viewpoint{
description "FrontView"
position 0 0 1.1292
fieldOfView 0.2618 }
description "FrontView"
position 0 0 1.1292
fieldOfView 0.2618 }
Code:
add.w #$242,a1 ; Tyranny (For You)
Code:
jsr -1012+(BOOTCODE-BOOT)(a2)Code:
; one last thing: initialise the psg
ld hl, #0000
ld de, #FFBF
ld c, #FD
ResetPSG: ld b, d
out (c), l
ld b, e
out (c), h
inc l
bit 4, l ; gasman is too cool to have to do this :)
jr z, ResetPSG